CodeGenModule.h source code [llvm_projects/clang/lib/CodeGen/CodeGenModule.h]

1	//===--- CodeGenModule.h - Per-Module state for LLVM CodeGen ----- C++ --===//
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 is the internal per-translation-unit state used for llvm translation.
10	//
11	//===----------------------------------------------------------------------===//
12
13	#ifndef LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H
14	#define LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H
15
16	#include "CGVTables.h"
17	#include "CodeGenTypeCache.h"
18	#include "CodeGenTypes.h"
19	#include "SanitizerMetadata.h"
20	#include "clang/AST/DeclCXX.h"
21	#include "clang/AST/DeclObjC.h"
22	#include "clang/AST/DeclOpenMP.h"
23	#include "clang/AST/GlobalDecl.h"
24	#include "clang/AST/Mangle.h"
25	#include "clang/Basic/ABI.h"
26	#include "clang/Basic/LangOptions.h"
27	#include "clang/Basic/NoSanitizeList.h"
28	#include "clang/Basic/ProfileList.h"
29	#include "clang/Basic/StackExhaustionHandler.h"
30	#include "clang/Basic/TargetInfo.h"
31	#include "clang/Basic/XRayLists.h"
32	#include "clang/Lex/PreprocessorOptions.h"
33	#include "llvm/ADT/DenseMap.h"
34	#include "llvm/ADT/MapVector.h"
35	#include "llvm/ADT/SetVector.h"
36	#include "llvm/ADT/SmallPtrSet.h"
37	#include "llvm/ADT/StringMap.h"
38	#include "llvm/IR/Module.h"
39	#include "llvm/IR/ValueHandle.h"
40	#include "llvm/Transforms/Utils/SanitizerStats.h"
41	#include <optional>
42
43	namespace llvm {
44	class Module;
45	class Constant;
46	class ConstantInt;
47	class Function;
48	class GlobalValue;
49	class DataLayout;
50	class FunctionType;
51	class LLVMContext;
52	class IndexedInstrProfReader;
53
54	namespace vfs {
55	class FileSystem;
56	}
57	}
58
59	namespace clang {
60	class ASTContext;
61	class AtomicType;
62	class FunctionDecl;
63	class IdentifierInfo;
64	class ObjCImplementationDecl;
65	class ObjCEncodeExpr;
66	class BlockExpr;
67	class CharUnits;
68	class Decl;
69	class Expr;
70	class Stmt;
71	class StringLiteral;
72	class NamedDecl;
73	class PointerAuthSchema;
74	class ValueDecl;
75	class VarDecl;
76	class LangOptions;
77	class CodeGenOptions;
78	class HeaderSearchOptions;
79	class DiagnosticsEngine;
80	class AnnotateAttr;
81	class CXXDestructorDecl;
82	class Module;
83	class CoverageSourceInfo;
84	class InitSegAttr;
85
86	namespace CodeGen {
87
88	class CodeGenFunction;
89	class CodeGenTBAA;
90	class CGCXXABI;
91	class CGDebugInfo;
92	class CGObjCRuntime;
93	class CGOpenCLRuntime;
94	class CGOpenMPRuntime;
95	class CGCUDARuntime;
96	class CGHLSLRuntime;
97	class CoverageMappingModuleGen;
98	class TargetCodeGenInfo;
99
100	enum ForDefinition_t : bool {
101	NotForDefinition = false,
102	ForDefinition = true
103	};
104
105	/// The Counter with an optional additional Counter for
106	/// branches. `Skipped` counter can be calculated with `Executed` and
107	/// a common Counter (like `Parent`) as `(Parent-Executed)`.
108	///
109	/// In SingleByte mode, Counters are binary. Subtraction is not
110	/// applicable (but addition is capable). In this case, both
111	/// `Executed` and `Skipped` counters are required. `Skipped` is
112	/// `None` by default. It is allocated in the coverage mapping.
113	///
114	/// There might be cases that `Parent` could be induced with
115	/// `(Executed+Skipped)`. This is not always applicable.
116	class CounterPair {
117	public:
118	/// Optional value.
119	class ValueOpt {
120	private:
121	static constexpr uint32_t None = (`1u` << `31`); /// None is allocated.
122	static constexpr uint32_t Mask = None - `1`;
123
124	uint32_t Val;
125
126	public:
127	ValueOpt() : Val(None) {}
128
129	ValueOpt(unsigned InitVal) {
130	assert(!(InitVal & ~Mask));
131	Val = InitVal;
132	}
133
134	bool hasValue() const { return !(Val & None); }
135
136	operator uint32_t() const { return Val; }
137	};
138
139	ValueOpt Executed;
140	ValueOpt Skipped; /// May be None.
141
142	/// Initialized with Skipped=None.
143	CounterPair(unsigned Val) : Executed (Val) {}
144
145	// FIXME: Should work with {None, None}
146	CounterPair() : Executed (`0`) {}
147	};
148
149	struct OrderGlobalInitsOrStermFinalizers {
150	unsigned int priority;
151	unsigned int lex_order;
152	OrderGlobalInitsOrStermFinalizers(unsigned int p, unsigned int l)
153	: priority(p), lex_order(l) {}
154
155	bool operator==(const OrderGlobalInitsOrStermFinalizers &RHS) const {
156	return priority == RHS.priority && lex_order == RHS.lex_order;
157	}
158
159	bool operator<(const OrderGlobalInitsOrStermFinalizers &RHS) const {
160	return std::tie(args: priority, args: lex_order) <
161	std::tie(args: RHS.priority, args: RHS.lex_order);
162	}
163	};
164
165	struct ObjCEntrypoints {
166	ObjCEntrypoints() { memset(s: this, c: `0`, n: sizeof(*this)); }
167
168	/// void objc_alloc(id);
169	llvm::FunctionCallee objc_alloc;
170
171	/// void objc_allocWithZone(id);
172	llvm::FunctionCallee objc_allocWithZone;
173
174	/// void objc_alloc_init(id);
175	llvm::FunctionCallee objc_alloc_init;
176
177	/// void objc_autoreleasePoolPop(void);*
178	llvm::FunctionCallee objc_autoreleasePoolPop;
179
180	/// void objc_autoreleasePoolPop(void);*
181	/// Note this method is used when we are using exception handling
182	llvm::FunctionCallee objc_autoreleasePoolPopInvoke;
183
184	/// void objc_autoreleasePoolPush(void);*
185	llvm::Function *objc_autoreleasePoolPush;
186
187	/// id objc_autorelease(id);
188	llvm::Function *objc_autorelease;
189
190	/// id objc_autorelease(id);
191	/// Note this is the runtime method not the intrinsic.
192	llvm::FunctionCallee objc_autoreleaseRuntimeFunction;
193
194	/// id objc_autoreleaseReturnValue(id);
195	llvm::Function *objc_autoreleaseReturnValue;
196
197	/// void objc_copyWeak(id dest, id src);
198	llvm::Function *objc_copyWeak;
199
200	/// void objc_destroyWeak(id);*
201	llvm::Function *objc_destroyWeak;
202
203	/// id objc_initWeak(id, id);*
204	llvm::Function *objc_initWeak;
205
206	/// id objc_loadWeak(id);*
207	llvm::Function *objc_loadWeak;
208
209	/// id objc_loadWeakRetained(id);*
210	llvm::Function *objc_loadWeakRetained;
211
212	/// void objc_moveWeak(id dest, id src);
213	llvm::Function *objc_moveWeak;
214
215	/// id objc_retain(id);
216	llvm::Function *objc_retain;
217
218	/// id objc_retain(id);
219	/// Note this is the runtime method not the intrinsic.
220	llvm::FunctionCallee objc_retainRuntimeFunction;
221
222	/// id objc_retainAutorelease(id);
223	llvm::Function *objc_retainAutorelease;
224
225	/// id objc_retainAutoreleaseReturnValue(id);
226	llvm::Function *objc_retainAutoreleaseReturnValue;
227
228	/// id objc_retainAutoreleasedReturnValue(id);
229	llvm::Function *objc_retainAutoreleasedReturnValue;
230
231	/// id objc_retainBlock(id);
232	llvm::Function *objc_retainBlock;
233
234	/// void objc_release(id);
235	llvm::Function *objc_release;
236
237	/// void objc_release(id);
238	/// Note this is the runtime method not the intrinsic.
239	llvm::FunctionCallee objc_releaseRuntimeFunction;
240
241	/// void objc_storeStrong(id, id);*
242	llvm::Function *objc_storeStrong;
243
244	/// id objc_storeWeak(id, id);*
245	llvm::Function *objc_storeWeak;
246
247	/// id objc_unsafeClaimAutoreleasedReturnValue(id);
248	llvm::Function *objc_unsafeClaimAutoreleasedReturnValue;
249
250	/// A void(void) inline asm to use to mark that the return value of
251	/// a call will be immediately retain.
252	llvm::InlineAsm *retainAutoreleasedReturnValueMarker;
253
254	/// void clang.arc.use(...);
255	llvm::Function *clang_arc_use;
256
257	/// void clang.arc.noop.use(...);
258	llvm::Function *clang_arc_noop_use;
259	};
260
261	/// This class records statistics on instrumentation based profiling.
262	class InstrProfStats {
263	uint32_t VisitedInMainFile = `0`;
264	uint32_t MissingInMainFile = `0`;
265	uint32_t Visited = `0`;
266	uint32_t Missing = `0`;
267	uint32_t Mismatched = `0`;
268
269	public:
270	InstrProfStats() = default;
271	/// Record that we've visited a function and whether or not that function was
272	/// in the main source file.
273	void addVisited(bool MainFile) {
274	if (MainFile)
275	++VisitedInMainFile;
276	++Visited;
277	}
278	/// Record that a function we've visited has no profile data.
279	void addMissing(bool MainFile) {
280	if (MainFile)
281	++MissingInMainFile;
282	++Missing;
283	}
284	/// Record that a function we've visited has mismatched profile data.
285	void addMismatched(bool MainFile) { ++Mismatched; }
286	/// Whether or not the stats we've gathered indicate any potential problems.
287	bool hasDiagnostics() { return Missing \|\| Mismatched; }
288	/// Report potential problems we've found to \c Diags.
289	void reportDiagnostics(DiagnosticsEngine &Diags, StringRef MainFile);
290	};
291
292	/// A pair of helper functions for a __block variable.
293	class BlockByrefHelpers : public llvm::FoldingSetNode {
294	// MSVC requires this type to be complete in order to process this
295	// header.
296	public:
297	llvm::Constant *CopyHelper;
298	llvm::Constant *DisposeHelper;
299
300	/// The alignment of the field. This is important because
301	/// different offsets to the field within the byref struct need to
302	/// have different helper functions.
303	CharUnits Alignment;
304
305	BlockByrefHelpers(CharUnits alignment)
306	: CopyHelper(nullptr), DisposeHelper(nullptr), Alignment (alignment) {}
307	BlockByrefHelpers(const BlockByrefHelpers &) = default;
308	virtual ~BlockByrefHelpers();
309
310	void Profile(llvm::FoldingSetNodeID &id) const {
311	id.AddInteger(I: Alignment.getQuantity());
312	profileImpl(id);
313	}
314	virtual void profileImpl(llvm::FoldingSetNodeID &id) const = `0`;
315
316	virtual bool needsCopy() const { return true; }
317	virtual void emitCopy(CodeGenFunction &CGF, Address dest, Address src) = `0`;
318
319	virtual bool needsDispose() const { return true; }
320	virtual void emitDispose(CodeGenFunction &CGF, Address field) = `0`;
321	};
322
323	/// This class organizes the cross-function state that is used while generating
324	/// LLVM code.
325	class CodeGenModule : public CodeGenTypeCache {
326	CodeGenModule(const CodeGenModule &) = delete;
327	void operator=(const CodeGenModule &) = delete;
328
329	public:
330	struct Structor {
331	Structor()
332	: Priority(`0`), LexOrder(~`0u`), Initializer(nullptr),
333	AssociatedData(nullptr) {}
334	Structor(int Priority, unsigned LexOrder, llvm::Constant *Initializer,
335	llvm::Constant *AssociatedData)
336	: Priority(Priority), LexOrder(LexOrder), Initializer(Initializer),
337	AssociatedData(AssociatedData) {}
338	int Priority;
339	unsigned LexOrder;
340	llvm::Constant *Initializer;
341	llvm::Constant *AssociatedData;
342	};
343
344	typedef std::vector<Structor> CtorList;
345
346	private:
347	ASTContext &Context;
348	const LangOptions &LangOpts;
349	IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS; // Only used for debug info.
350	const HeaderSearchOptions &HeaderSearchOpts; // Only used for debug info.
351	const PreprocessorOptions &PreprocessorOpts; // Only used for debug info.
352	const CodeGenOptions &CodeGenOpts;
353	unsigned NumAutoVarInit = `0`;
354	llvm::Module &TheModule;
355	DiagnosticsEngine &Diags;
356	const TargetInfo &Target;
357	std::unique_ptr<CGCXXABI> ABI;
358	llvm::LLVMContext &VMContext;
359	std::string ModuleNameHash;
360	bool CXX20ModuleInits = false;
361	std::unique_ptr<CodeGenTBAA> TBAA;
362
363	mutable std::unique_ptr<TargetCodeGenInfo> TheTargetCodeGenInfo;
364
365	// This should not be moved earlier, since its initialization depends on some
366	// of the previous reference members being already initialized and also checks
367	// if TheTargetCodeGenInfo is NULL
368	std::unique_ptr<CodeGenTypes> Types;
369
370	/// Holds information about C++ vtables.
371	CodeGenVTables VTables;
372
373	std::unique_ptr<CGObjCRuntime> ObjCRuntime;
374	std::unique_ptr<CGOpenCLRuntime> OpenCLRuntime;
375	std::unique_ptr<CGOpenMPRuntime> OpenMPRuntime;
376	std::unique_ptr<CGCUDARuntime> CUDARuntime;
377	std::unique_ptr<CGHLSLRuntime> HLSLRuntime;
378	std::unique_ptr<CGDebugInfo> DebugInfo;
379	std::unique_ptr<ObjCEntrypoints> ObjCData;
380	llvm::MDNode NoObjCARCExceptionsMetadata = nullptr*;
381	std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader;
382	InstrProfStats PGOStats;
383	std::unique_ptr<llvm::SanitizerStatReport> SanStats;
384	StackExhaustionHandler StackHandler;
385
386	// A set of references that have only been seen via a weakref so far. This is
387	// used to remove the weak of the reference if we ever see a direct reference
388	// or a definition.
389	llvm::SmallPtrSet<llvm::GlobalValue*, `10`> WeakRefReferences;
390
391	/// This contains all the decls which have definitions but/ which are deferred
392	/// for emission and therefore should only be output if they are actually
393	/// used. If a decl is in this, then it is known to have not been referenced
394	/// yet.
395	llvm::DenseMap<StringRef, GlobalDecl> DeferredDecls;
396
397	llvm::StringSet<llvm::BumpPtrAllocator> DeferredResolversToEmit;
398
399	/// This is a list of deferred decls which we have seen that are* actually*
400	/// referenced. These get code generated when the module is done.
401	std::vector<GlobalDecl> DeferredDeclsToEmit;
402	void addDeferredDeclToEmit(GlobalDecl GD) {
403	DeferredDeclsToEmit.emplace_back(args&: GD);
404	addEmittedDeferredDecl(GD);
405	}
406
407	/// Decls that were DeferredDecls and have now been emitted.
408	llvm::DenseMap<llvm::StringRef, GlobalDecl> EmittedDeferredDecls;
409
410	void addEmittedDeferredDecl(GlobalDecl GD) {
411	// Reemission is only needed in incremental mode.
412	if (!Context.getLangOpts().IncrementalExtensions)
413	return;
414
415	// Assume a linkage by default that does not need reemission.
416	auto L = llvm::GlobalValue::ExternalLinkage;
417	if (llvm::isa<FunctionDecl>(Val: GD.getDecl()))
418	L = getFunctionLinkage(GD);
419	else if (auto *VD = llvm::dyn_cast<VarDecl>(Val: GD.getDecl()))
420	L = getLLVMLinkageVarDefinition(VD);
421
422	if (llvm::GlobalValue::isInternalLinkage(Linkage: L) \|\|
423	llvm::GlobalValue::isLinkOnceLinkage(Linkage: L) \|\|
424	llvm::GlobalValue::isWeakLinkage(Linkage: L)) {
425	EmittedDeferredDecls [getMangledName(GD)] = GD;
426	}
427	}
428
429	/// List of alias we have emitted. Used to make sure that what they point to
430	/// is defined once we get to the end of the of the translation unit.
431	std::vector<GlobalDecl> Aliases;
432
433	/// List of multiversion functions to be emitted. This list is processed in
434	/// conjunction with other deferred symbols and is used to ensure that
435	/// multiversion function resolvers and ifuncs are defined and emitted.
436	std::vector<GlobalDecl> MultiVersionFuncs;
437
438	llvm::MapVector<StringRef, llvm::TrackingVH<llvm::Constant>> Replacements;
439
440	/// List of global values to be replaced with something else. Used when we
441	/// want to replace a GlobalValue but can't identify it by its mangled name
442	/// anymore (because the name is already taken).
443	llvm::SmallVector<std::pair<llvm::GlobalValue , llvm::Constant >, `8`>
444	GlobalValReplacements;
445
446	/// Variables for which we've emitted globals containing their constant
447	/// values along with the corresponding globals, for opportunistic reuse.
448	llvm::DenseMap<const VarDecl, llvm::GlobalVariable> InitializerConstants;
449
450	/// Set of global decls for which we already diagnosed mangled name conflict.
451	/// Required to not issue a warning (on a mangling conflict) multiple times
452	/// for the same decl.
453	llvm::DenseSet<GlobalDecl> DiagnosedConflictingDefinitions;
454
455	/// A queue of (optional) vtables to consider emitting.
456	std::vector<const CXXRecordDecl*> DeferredVTables;
457
458	/// A queue of (optional) vtables that may be emitted opportunistically.
459	std::vector<const CXXRecordDecl *> OpportunisticVTables;
460
461	/// List of global values which are required to be present in the object file;
462	/// bitcast to i8. This is used for forcing visibility of symbols which may*
463	/// otherwise be optimized out.
464	std::vector<llvm::WeakTrackingVH> LLVMUsed;
465	std::vector<llvm::WeakTrackingVH> LLVMCompilerUsed;
466
467	/// Store the list of global constructors and their respective priorities to
468	/// be emitted when the translation unit is complete.
469	CtorList GlobalCtors;
470
471	/// Store the list of global destructors and their respective priorities to be
472	/// emitted when the translation unit is complete.
473	CtorList GlobalDtors;
474
475	/// An ordered map of canonical GlobalDecls to their mangled names.
476	llvm::MapVector<GlobalDecl, StringRef> MangledDeclNames;
477	llvm::StringMap<GlobalDecl, llvm::BumpPtrAllocator> Manglings;
478
479	/// Global annotations.
480	std::vector<llvm::Constant*> Annotations;
481
482	// Store deferred function annotations so they can be emitted at the end with
483	// most up to date ValueDecl that will have all the inherited annotations.
484	llvm::MapVector<StringRef, const ValueDecl *> DeferredAnnotations;
485
486	/// Map used to get unique annotation strings.
487	llvm::StringMap<llvm::Constant*> AnnotationStrings;
488
489	/// Used for uniquing of annotation arguments.
490	llvm::DenseMap<unsigned, llvm::Constant *> AnnotationArgs;
491
492	llvm::StringMap<llvm::GlobalVariable *> CFConstantStringMap;
493
494	llvm::DenseMap<llvm::Constant , llvm::GlobalVariable > ConstantStringMap;
495	llvm::DenseMap<const UnnamedGlobalConstantDecl , llvm::GlobalVariable >
496	UnnamedGlobalConstantDeclMap;
497	llvm::DenseMap<const Decl, llvm::Constant > StaticLocalDeclMap;
498	llvm::DenseMap<const Decl, llvm::GlobalVariable> StaticLocalDeclGuardMap;
499	llvm::DenseMap<const Expr, llvm::Constant > MaterializedGlobalTemporaryMap;
500
501	llvm::DenseMap<QualType, llvm::Constant *> AtomicSetterHelperFnMap;
502	llvm::DenseMap<QualType, llvm::Constant *> AtomicGetterHelperFnMap;
503
504	/// Map used to get unique type descriptor constants for sanitizers.
505	llvm::DenseMap<QualType, llvm::Constant *> TypeDescriptorMap;
506
507	/// Map used to track internal linkage functions declared within
508	/// extern "C" regions.
509	typedef llvm::MapVector<IdentifierInfo *,
510	llvm::GlobalValue *> StaticExternCMap;
511	StaticExternCMap StaticExternCValues;
512
513	/// thread_local variables defined or used in this TU.
514	std::vector<const VarDecl *> CXXThreadLocals;
515
516	/// thread_local variables with initializers that need to run
517	/// before any thread_local variable in this TU is odr-used.
518	std::vector<llvm::Function *> CXXThreadLocalInits;
519	std::vector<const VarDecl *> CXXThreadLocalInitVars;
520
521	/// Global variables with initializers that need to run before main.
522	std::vector<llvm::Function *> CXXGlobalInits;
523
524	/// When a C++ decl with an initializer is deferred, null is
525	/// appended to CXXGlobalInits, and the index of that null is placed
526	/// here so that the initializer will be performed in the correct
527	/// order. Once the decl is emitted, the index is replaced with ~0U to ensure
528	/// that we don't re-emit the initializer.
529	llvm::DenseMap<const Decl, unsigned*> DelayedCXXInitPosition;
530
531	typedef std::pair<OrderGlobalInitsOrStermFinalizers, llvm::Function *>
532	GlobalInitData;
533
534	// When a tail call is performed on an "undefined" symbol, on PPC without pc
535	// relative feature, the tail call is not allowed. In "EmitCall" for such
536	// tail calls, the "undefined" symbols may be forward declarations, their
537	// definitions are provided in the module after the callsites. For such tail
538	// calls, diagnose message should not be emitted.
539	llvm::SmallSetVector<std::pair<const FunctionDecl *, SourceLocation>, `4`>
540	MustTailCallUndefinedGlobals;
541
542	struct GlobalInitPriorityCmp {
543	bool operator()(const GlobalInitData &LHS,
544	const GlobalInitData &RHS) const {
545	return LHS.first.priority < RHS.first.priority;
546	}
547	};
548
549	/// Global variables with initializers whose order of initialization is set by
550	/// init_priority attribute.
551	SmallVector<GlobalInitData, `8`> PrioritizedCXXGlobalInits;
552
553	/// Global destructor functions and arguments that need to run on termination.
554	/// When UseSinitAndSterm is set, it instead contains sterm finalizer
555	/// functions, which also run on unloading a shared library.
556	typedef std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
557	llvm::Constant *>
558	CXXGlobalDtorsOrStermFinalizer_t;
559	SmallVector<CXXGlobalDtorsOrStermFinalizer_t, `8`>
560	CXXGlobalDtorsOrStermFinalizers;
561
562	typedef std::pair<OrderGlobalInitsOrStermFinalizers, llvm::Function *>
563	StermFinalizerData;
564
565	struct StermFinalizerPriorityCmp {
566	bool operator()(const StermFinalizerData &LHS,
567	const StermFinalizerData &RHS) const {
568	return LHS.first.priority < RHS.first.priority;
569	}
570	};
571
572	/// Global variables with sterm finalizers whose order of initialization is
573	/// set by init_priority attribute.
574	SmallVector<StermFinalizerData, `8`> PrioritizedCXXStermFinalizers;
575
576	/// The complete set of modules that has been imported.
577	llvm::SetVector<clang::Module *> ImportedModules;
578
579	/// The set of modules for which the module initializers
580	/// have been emitted.
581	llvm::SmallPtrSet<clang::Module *, `16`> EmittedModuleInitializers;
582
583	/// A vector of metadata strings for linker options.
584	SmallVector<llvm::MDNode *, `16`> LinkerOptionsMetadata;
585
586	/// A vector of metadata strings for dependent libraries for ELF.
587	SmallVector<llvm::MDNode *, `16`> ELFDependentLibraries;
588
589	/// @name Cache for Objective-C runtime types
590	/// @{
591
592	/// Cached reference to the class for constant strings. This value has type
593	/// int but is actually an Obj-C class pointer.*
594	llvm::WeakTrackingVH CFConstantStringClassRef;
595
596	/// The type used to describe the state of a fast enumeration in
597	/// Objective-C's for..in loop.
598	QualType ObjCFastEnumerationStateType;
599
600	/// @}
601
602	/// Lazily create the Objective-C runtime
603	void createObjCRuntime();
604
605	void createOpenCLRuntime();
606	void createOpenMPRuntime();
607	void createCUDARuntime();
608	void createHLSLRuntime();
609
610	bool isTriviallyRecursive(const FunctionDecl *F);
611	bool shouldEmitFunction(GlobalDecl GD);
612	// Whether a global variable should be emitted by CUDA/HIP host/device
613	// related attributes.
614	bool shouldEmitCUDAGlobalVar(const VarDecl VD) const*;
615	bool shouldOpportunisticallyEmitVTables();
616	/// Map used to be sure we don't emit the same CompoundLiteral twice.
617	llvm::DenseMap<const CompoundLiteralExpr , llvm::GlobalVariable >
618	EmittedCompoundLiterals;
619
620	/// Map of the global blocks we've emitted, so that we don't have to re-emit
621	/// them if the constexpr evaluator gets aggressive.
622	llvm::DenseMap<const BlockExpr , llvm::Constant > EmittedGlobalBlocks;
623
624	/// @name Cache for Blocks Runtime Globals
625	/// @{
626
627	llvm::Constant NSConcreteGlobalBlock = nullptr*;
628	llvm::Constant NSConcreteStackBlock = nullptr*;
629
630	llvm::FunctionCallee BlockObjectAssign = nullptr;
631	llvm::FunctionCallee BlockObjectDispose = nullptr;
632
633	llvm::Type BlockDescriptorType = nullptr*;
634	llvm::Type GenericBlockLiteralType = nullptr*;
635
636	struct {
637	int GlobalUniqueCount;
638	} Block;
639
640	GlobalDecl initializedGlobalDecl;
641
642	/// @}
643
644	/// void @llvm.lifetime.start(i64 %size, i8 nocapture <ptr>)*
645	llvm::Function LifetimeStartFn = nullptr*;
646
647	/// void @llvm.lifetime.end(i64 %size, i8 nocapture <ptr>)*
648	llvm::Function LifetimeEndFn = nullptr*;
649
650	/// void @llvm.fake.use(...)
651	llvm::Function FakeUseFn = nullptr*;
652
653	std::unique_ptr<SanitizerMetadata> SanitizerMD;
654
655	llvm::MapVector<const Decl , bool*> DeferredEmptyCoverageMappingDecls;
656
657	std::unique_ptr<CoverageMappingModuleGen> CoverageMapping;
658
659	/// Mapping from canonical types to their metadata identifiers. We need to
660	/// maintain this mapping because identifiers may be formed from distinct
661	/// MDNodes.
662	typedef llvm::DenseMap<QualType, llvm::Metadata *> MetadataTypeMap;
663	MetadataTypeMap MetadataIdMap;
664	MetadataTypeMap VirtualMetadataIdMap;
665	MetadataTypeMap GeneralizedMetadataIdMap;
666
667	// Helps squashing blocks of TopLevelStmtDecl into a single llvm::Function
668	// when used with -fincremental-extensions.
669	std::pair<std::unique_ptr<CodeGenFunction>, const TopLevelStmtDecl *>
670	GlobalTopLevelStmtBlockInFlight;
671
672	llvm::DenseMap<GlobalDecl, uint16_t> PtrAuthDiscriminatorHashes;
673
674	llvm::DenseMap<const CXXRecordDecl *, std::optional<PointerAuthQualifier>>
675	VTablePtrAuthInfos;
676	std::optional<PointerAuthQualifier>
677	computeVTPointerAuthentication(const CXXRecordDecl *ThisClass);
678
679	AtomicOptions AtomicOpts;
680
681	// A set of functions which should be hot-patched; see
682	// -fms-hotpatch-functions-file (and -list). This will nearly always be empty.
683	// The list is sorted for binary-searching.
684	std::vector<std::string> MSHotPatchFunctions;
685
686	public:
687	CodeGenModule(ASTContext &C, IntrusiveRefCntPtr<llvm::vfs::FileSystem> FS,
688	const HeaderSearchOptions &headersearchopts,
689	const PreprocessorOptions &ppopts,
690	const CodeGenOptions &CodeGenOpts, llvm::Module &M,
691	DiagnosticsEngine &Diags,
692	CoverageSourceInfo CoverageInfo = nullptr*);
693
694	~CodeGenModule();
695
696	void clear();
697
698	/// Finalize LLVM code generation.
699	void Release();
700
701	/// Get the current Atomic options.
702	AtomicOptions getAtomicOpts() { return AtomicOpts; }
703
704	/// Set the current Atomic options.
705	void setAtomicOpts(AtomicOptions AO) { AtomicOpts = AO; }
706
707	/// Return true if we should emit location information for expressions.
708	bool getExpressionLocationsEnabled() const;
709
710	/// Return a reference to the configured Objective-C runtime.
711	CGObjCRuntime &getObjCRuntime() {
712	if (!ObjCRuntime) createObjCRuntime();
713	return *ObjCRuntime;
714	}
715
716	/// Return true iff an Objective-C runtime has been configured.
717	bool hasObjCRuntime() { return !!ObjCRuntime; }
718
719	const std::string &getModuleNameHash() const { return ModuleNameHash; }
720
721	/// Return a reference to the configured OpenCL runtime.
722	CGOpenCLRuntime &getOpenCLRuntime() {
723	assert(OpenCLRuntime != nullptr);
724	return *OpenCLRuntime;
725	}
726
727	/// Return a reference to the configured OpenMP runtime.
728	CGOpenMPRuntime &getOpenMPRuntime() {
729	assert(OpenMPRuntime != nullptr);
730	return *OpenMPRuntime;
731	}
732
733	/// Return a reference to the configured CUDA runtime.
734	CGCUDARuntime &getCUDARuntime() {
735	assert(CUDARuntime != nullptr);
736	return *CUDARuntime;
737	}
738
739	/// Return a reference to the configured HLSL runtime.
740	CGHLSLRuntime &getHLSLRuntime() {
741	assert(HLSLRuntime != nullptr);
742	return *HLSLRuntime;
743	}
744
745	ObjCEntrypoints &getObjCEntrypoints() const {
746	assert(ObjCData != nullptr);
747	return *ObjCData;
748	}
749
750	// Version checking functions, used to implement ObjC's @available:
751	// i32 @__isOSVersionAtLeast(i32, i32, i32)
752	llvm::FunctionCallee IsOSVersionAtLeastFn = nullptr;
753	// i32 @__isPlatformVersionAtLeast(i32, i32, i32, i32)
754	llvm::FunctionCallee IsPlatformVersionAtLeastFn = nullptr;
755
756	InstrProfStats &getPGOStats() { return PGOStats; }
757	llvm::IndexedInstrProfReader getPGOReader() const* { return PGOReader.get(); }
758
759	CoverageMappingModuleGen getCoverageMapping() const* {
760	return CoverageMapping.get();
761	}
762
763	llvm::Constant getStaticLocalDeclAddress(const* VarDecl *D) {
764	return StaticLocalDeclMap [D];
765	}
766	void setStaticLocalDeclAddress(const VarDecl *D,
767	llvm::Constant *C) {
768	StaticLocalDeclMap [D] = C;
769	}
770
771	llvm::Constant *
772	getOrCreateStaticVarDecl(const VarDecl &D,
773	llvm::GlobalValue::LinkageTypes Linkage);
774
775	llvm::GlobalVariable getStaticLocalDeclGuardAddress(const* VarDecl *D) {
776	return StaticLocalDeclGuardMap [D];
777	}
778	void setStaticLocalDeclGuardAddress(const VarDecl *D,
779	llvm::GlobalVariable *C) {
780	StaticLocalDeclGuardMap [D] = C;
781	}
782
783	Address createUnnamedGlobalFrom(const VarDecl &D, llvm::Constant *Constant,
784	CharUnits Align);
785
786	bool lookupRepresentativeDecl(StringRef MangledName,
787	GlobalDecl &Result) const;
788
789	llvm::Constant *getAtomicSetterHelperFnMap(QualType Ty) {
790	return AtomicSetterHelperFnMap [Ty];
791	}
792	void setAtomicSetterHelperFnMap(QualType Ty,
793	llvm::Constant *Fn) {
794	AtomicSetterHelperFnMap [Ty] = Fn;
795	}
796
797	llvm::Constant *getAtomicGetterHelperFnMap(QualType Ty) {
798	return AtomicGetterHelperFnMap [Ty];
799	}
800	void setAtomicGetterHelperFnMap(QualType Ty,
801	llvm::Constant *Fn) {
802	AtomicGetterHelperFnMap [Ty] = Fn;
803	}
804
805	llvm::Constant *getTypeDescriptorFromMap(QualType Ty) {
806	return TypeDescriptorMap [Ty];
807	}
808	void setTypeDescriptorInMap(QualType Ty, llvm::Constant *C) {
809	TypeDescriptorMap [Ty] = C;
810	}
811
812	CGDebugInfo getModuleDebugInfo() { return* DebugInfo.get(); }
813
814	llvm::MDNode *getNoObjCARCExceptionsMetadata() {
815	if (!NoObjCARCExceptionsMetadata)
816	NoObjCARCExceptionsMetadata = llvm::MDNode::get(Context&: getLLVMContext(), MDs: {});
817	return NoObjCARCExceptionsMetadata;
818	}
819
820	ASTContext &getContext() const { return Context; }
821	const LangOptions &getLangOpts() const { return LangOpts; }
822	const IntrusiveRefCntPtr<llvm::vfs::FileSystem> &getFileSystem() const {
823	return FS;
824	}
825	const HeaderSearchOptions &getHeaderSearchOpts()
826	const { return HeaderSearchOpts; }
827	const PreprocessorOptions &getPreprocessorOpts()
828	const { return PreprocessorOpts; }
829	const CodeGenOptions &getCodeGenOpts() const { return CodeGenOpts; }
830	llvm::Module &getModule() const { return TheModule; }
831	DiagnosticsEngine &getDiags() const { return Diags; }
832	const llvm::DataLayout &getDataLayout() const {
833	return TheModule.getDataLayout();
834	}
835	const TargetInfo &getTarget() const { return Target; }
836	const llvm::Triple &getTriple() const { return Target.getTriple(); }
837	bool supportsCOMDAT() const;
838	void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO);
839
840	const ABIInfo &getABIInfo();
841	CGCXXABI &getCXXABI() const { return *ABI; }
842	llvm::LLVMContext &getLLVMContext() { return VMContext; }
843
844	bool shouldUseTBAA() const { return TBAA != nullptr; }
845
846	const TargetCodeGenInfo &getTargetCodeGenInfo();
847
848	CodeGenTypes &getTypes() { return *Types; }
849
850	CodeGenVTables &getVTables() { return VTables; }
851
852	ItaniumVTableContext &getItaniumVTableContext() {
853	return VTables.getItaniumVTableContext();
854	}
855
856	const ItaniumVTableContext &getItaniumVTableContext() const {
857	return VTables.getItaniumVTableContext();
858	}
859
860	MicrosoftVTableContext &getMicrosoftVTableContext() {
861	return VTables.getMicrosoftVTableContext();
862	}
863
864	CtorList &getGlobalCtors() { return GlobalCtors; }
865	CtorList &getGlobalDtors() { return GlobalDtors; }
866
867	/// getTBAATypeInfo - Get metadata used to describe accesses to objects of
868	/// the given type.
869	llvm::MDNode *getTBAATypeInfo(QualType QTy);
870
871	/// getTBAAAccessInfo - Get TBAA information that describes an access to
872	/// an object of the given type.
873	TBAAAccessInfo getTBAAAccessInfo(QualType AccessType);
874
875	/// getTBAAVTablePtrAccessInfo - Get the TBAA information that describes an
876	/// access to a virtual table pointer.
877	TBAAAccessInfo getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType);
878
879	llvm::MDNode *getTBAAStructInfo(QualType QTy);
880
881	/// getTBAABaseTypeInfo - Get metadata that describes the given base access
882	/// type. Return null if the type is not suitable for use in TBAA access tags.
883	llvm::MDNode *getTBAABaseTypeInfo(QualType QTy);
884
885	/// getTBAAAccessTagInfo - Get TBAA tag for a given memory access.
886	llvm::MDNode *getTBAAAccessTagInfo(TBAAAccessInfo Info);
887
888	/// mergeTBAAInfoForCast - Get merged TBAA information for the purposes of
889	/// type casts.
890	TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo,
891	TBAAAccessInfo TargetInfo);
892
893	/// mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the
894	/// purposes of conditional operator.
895	TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA,
896	TBAAAccessInfo InfoB);
897
898	/// mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the
899	/// purposes of memory transfer calls.
900	TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo,
901	TBAAAccessInfo SrcInfo);
902
903	/// getTBAAInfoForSubobject - Get TBAA information for an access with a given
904	/// base lvalue.
905	TBAAAccessInfo getTBAAInfoForSubobject(LValue Base, QualType AccessType) {
906	if (Base.getTBAAInfo().isMayAlias())
907	return TBAAAccessInfo::getMayAliasInfo();
908	return getTBAAAccessInfo(AccessType);
909	}
910
911	bool isPaddedAtomicType(QualType type);
912	bool isPaddedAtomicType(const AtomicType *type);
913
914	/// DecorateInstructionWithTBAA - Decorate the instruction with a TBAA tag.
915	void DecorateInstructionWithTBAA(llvm::Instruction *Inst,
916	TBAAAccessInfo TBAAInfo);
917
918	/// Adds !invariant.barrier !tag to instruction
919	void DecorateInstructionWithInvariantGroup(llvm::Instruction *I,
920	const CXXRecordDecl *RD);
921
922	/// Emit the given number of characters as a value of type size_t.
923	llvm::ConstantInt *getSize(CharUnits numChars);
924
925	/// Set the visibility for the given LLVM GlobalValue.
926	void setGlobalVisibility(llvm::GlobalValue GV, const* NamedDecl D) const*;
927
928	void setDSOLocal(llvm::GlobalValue GV) const*;
929
930	bool shouldMapVisibilityToDLLExport(const NamedDecl D) const* {
931	return getLangOpts().hasDefaultVisibilityExportMapping() && D &&
932	(D->getLinkageAndVisibility().getVisibility() ==
933	DefaultVisibility) &&
934	(getLangOpts().isAllDefaultVisibilityExportMapping() \|\|
935	(getLangOpts().isExplicitDefaultVisibilityExportMapping() &&
936	D->getLinkageAndVisibility().isVisibilityExplicit()));
937	}
938	void setDLLImportDLLExport(llvm::GlobalValue GV, GlobalDecl D) const*;
939	void setDLLImportDLLExport(llvm::GlobalValue GV, const* NamedDecl D) const*;
940	/// Set visibility, dllimport/dllexport and dso_local.
941	/// This must be called after dllimport/dllexport is set.
942	void setGVProperties(llvm::GlobalValue GV, GlobalDecl GD) const*;
943	void setGVProperties(llvm::GlobalValue GV, const* NamedDecl D) const*;
944
945	void setGVPropertiesAux(llvm::GlobalValue GV, const* NamedDecl D) const*;
946
947	/// Set the TLS mode for the given LLVM GlobalValue for the thread-local
948	/// variable declaration D.
949	void setTLSMode(llvm::GlobalValue GV, const* VarDecl &D) const;
950
951	/// Get LLVM TLS mode from CodeGenOptions.
952	llvm::GlobalVariable::ThreadLocalMode GetDefaultLLVMTLSModel() const;
953
954	static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V) {
955	switch (V) {
956	case DefaultVisibility: return llvm::GlobalValue::DefaultVisibility;
957	case HiddenVisibility: return llvm::GlobalValue::HiddenVisibility;
958	case ProtectedVisibility: return llvm::GlobalValue::ProtectedVisibility;
959	}
960	llvm_unreachable("unknown visibility!");
961	}
962
963	llvm::Constant *GetAddrOfGlobal(GlobalDecl GD,
964	ForDefinition_t IsForDefinition
965	= NotForDefinition);
966
967	/// Will return a global variable of the given type. If a variable with a
968	/// different type already exists then a new variable with the right type
969	/// will be created and all uses of the old variable will be replaced with a
970	/// bitcast to the new variable.
971	llvm::GlobalVariable *
972	CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty,
973	llvm::GlobalValue::LinkageTypes Linkage,
974	llvm::Align Alignment);
975
976	llvm::Function *CreateGlobalInitOrCleanUpFunction(
977	llvm::FunctionType ty, const* Twine &name, const CGFunctionInfo &FI,
978	SourceLocation Loc = SourceLocation (), bool TLS = false,
979	llvm::GlobalVariable::LinkageTypes Linkage =
980	llvm::GlobalVariable::InternalLinkage);
981
982	/// Return the AST address space of the underlying global variable for D, as
983	/// determined by its declaration. Normally this is the same as the address
984	/// space of D's type, but in CUDA, address spaces are associated with
985	/// declarations, not types. If D is nullptr, return the default address
986	/// space for global variable.
987	///
988	/// For languages without explicit address spaces, if D has default address
989	/// space, target-specific global or constant address space may be returned.
990	LangAS GetGlobalVarAddressSpace(const VarDecl *D);
991
992	/// Return the AST address space of constant literal, which is used to emit
993	/// the constant literal as global variable in LLVM IR.
994	/// Note: This is not necessarily the address space of the constant literal
995	/// in AST. For address space agnostic language, e.g. C++, constant literal
996	/// in AST is always in default address space.
997	LangAS GetGlobalConstantAddressSpace() const;
998
999	/// Return the llvm::Constant for the address of the given global variable.
1000	/// If Ty is non-null and if the global doesn't exist, then it will be created
1001	/// with the specified type instead of whatever the normal requested type
1002	/// would be. If IsForDefinition is true, it is guaranteed that an actual
1003	/// global with type Ty will be returned, not conversion of a variable with
1004	/// the same mangled name but some other type.
1005	llvm::Constant GetAddrOfGlobalVar(const* VarDecl *D,
1006	llvm::Type Ty = nullptr*,
1007	ForDefinition_t IsForDefinition
1008	= NotForDefinition);
1009
1010	/// Return the address of the given function. If Ty is non-null, then this
1011	/// function will use the specified type if it has to create it.
1012	llvm::Constant GetAddrOfFunction(GlobalDecl GD, llvm::Type Ty = nullptr,
1013	bool ForVTable = false,
1014	bool DontDefer = false,
1015	ForDefinition_t IsForDefinition
1016	= NotForDefinition);
1017
1018	// Return the function body address of the given function.
1019	llvm::Constant GetFunctionStart(const* ValueDecl *Decl);
1020
1021	/// Return a function pointer for a reference to the given function.
1022	/// This correctly handles weak references, but does not apply a
1023	/// pointer signature.
1024	llvm::Constant *getRawFunctionPointer(GlobalDecl GD,
1025	llvm::Type Ty = nullptr*);
1026
1027	/// Return the ABI-correct function pointer value for a reference
1028	/// to the given function. This will apply a pointer signature if
1029	/// necessary, caching the result for the given function.
1030	llvm::Constant getFunctionPointer(GlobalDecl GD, llvm::Type Ty = nullptr);
1031
1032	/// Return the ABI-correct function pointer value for a reference
1033	/// to the given function. This will apply a pointer signature if
1034	/// necessary.
1035	llvm::Constant getFunctionPointer(llvm::Constant Pointer,
1036	QualType FunctionType);
1037
1038	llvm::Constant getMemberFunctionPointer(const* FunctionDecl *FD,
1039	llvm::Type Ty = nullptr*);
1040
1041	llvm::Constant getMemberFunctionPointer(llvm::Constant Pointer,
1042	QualType FT);
1043
1044	CGPointerAuthInfo getFunctionPointerAuthInfo(QualType T);
1045
1046	CGPointerAuthInfo getMemberFunctionPointerAuthInfo(QualType FT);
1047
1048	CGPointerAuthInfo getPointerAuthInfoForPointeeType(QualType type);
1049
1050	CGPointerAuthInfo getPointerAuthInfoForType(QualType type);
1051
1052	bool shouldSignPointer(const PointerAuthSchema &Schema);
1053	llvm::Constant getConstantSignedPointer(llvm::Constant Pointer,
1054	const PointerAuthSchema &Schema,
1055	llvm::Constant *StorageAddress,
1056	GlobalDecl SchemaDecl,
1057	QualType SchemaType);
1058
1059	llvm::Constant *
1060	getConstantSignedPointer(llvm::Constant Pointer, unsigned* Key,
1061	llvm::Constant *StorageAddress,
1062	llvm::ConstantInt *OtherDiscriminator);
1063
1064	llvm::ConstantInt *
1065	getPointerAuthOtherDiscriminator(const PointerAuthSchema &Schema,
1066	GlobalDecl SchemaDecl, QualType SchemaType);
1067
1068	uint16_t getPointerAuthDeclDiscriminator(GlobalDecl GD);
1069	std::optional<CGPointerAuthInfo>
1070	getVTablePointerAuthInfo(CodeGenFunction *Context,
1071	const CXXRecordDecl *Record,
1072	llvm::Value *StorageAddress);
1073
1074	std::optional<PointerAuthQualifier>
1075	getVTablePointerAuthentication(const CXXRecordDecl *thisClass);
1076
1077	CGPointerAuthInfo EmitPointerAuthInfo(const RecordDecl *RD);
1078
1079	// Return whether RTTI information should be emitted for this target.
1080	bool shouldEmitRTTI(bool ForEH = false) {
1081	return (ForEH \|\| getLangOpts().RTTI) &&
1082	(!getLangOpts().isTargetDevice() \|\| !getTriple().isGPU());
1083	}
1084
1085	/// Get the address of the RTTI descriptor for the given type.
1086	llvm::Constant GetAddrOfRTTIDescriptor(QualType Ty, bool* ForEH = false);
1087
1088	/// Get the address of a GUID.
1089	ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD);
1090
1091	/// Get the address of a UnnamedGlobalConstant
1092	ConstantAddress
1093	GetAddrOfUnnamedGlobalConstantDecl(const UnnamedGlobalConstantDecl *GCD);
1094
1095	/// Get the address of a template parameter object.
1096	ConstantAddress
1097	GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO);
1098
1099	/// Get the address of the thunk for the given global decl.
1100	llvm::Constant GetAddrOfThunk(StringRef Name, llvm::Type FnTy,
1101	GlobalDecl GD);
1102
1103	/// Get a reference to the target of VD.
1104	ConstantAddress GetWeakRefReference(const ValueDecl *VD);
1105
1106	/// Returns the assumed alignment of an opaque pointer to the given class.
1107	CharUnits getClassPointerAlignment(const CXXRecordDecl *CD);
1108
1109	/// Returns the minimum object size for an object of the given class type
1110	/// (or a class derived from it).
1111	CharUnits getMinimumClassObjectSize(const CXXRecordDecl *CD);
1112
1113	/// Returns the minimum object size for an object of the given type.
1114	CharUnits getMinimumObjectSize(QualType Ty) {
1115	if (CXXRecordDecl *RD = Ty ->getAsCXXRecordDecl())
1116	return getMinimumClassObjectSize(CD: RD);
1117	return getContext().getTypeSizeInChars(T: Ty);
1118	}
1119
1120	/// Returns the assumed alignment of a virtual base of a class.
1121	CharUnits getVBaseAlignment(CharUnits DerivedAlign,
1122	const CXXRecordDecl *Derived,
1123	const CXXRecordDecl *VBase);
1124
1125	/// Given a class pointer with an actual known alignment, and the
1126	/// expected alignment of an object at a dynamic offset w.r.t that
1127	/// pointer, return the alignment to assume at the offset.
1128	CharUnits getDynamicOffsetAlignment(CharUnits ActualAlign,
1129	const CXXRecordDecl *Class,
1130	CharUnits ExpectedTargetAlign);
1131
1132	CharUnits
1133	computeNonVirtualBaseClassOffset(const CXXRecordDecl *DerivedClass,
1134	CastExpr::path_const_iterator Start,
1135	CastExpr::path_const_iterator End);
1136
1137	/// Returns the offset from a derived class to a class. Returns null if the
1138	/// offset is 0.
1139	llvm::Constant *
1140	GetNonVirtualBaseClassOffset(const CXXRecordDecl *ClassDecl,
1141	CastExpr::path_const_iterator PathBegin,
1142	CastExpr::path_const_iterator PathEnd);
1143
1144	llvm::FoldingSet<BlockByrefHelpers> ByrefHelpersCache;
1145
1146	/// Fetches the global unique block count.
1147	int getUniqueBlockCount() { return ++Block.GlobalUniqueCount; }
1148
1149	/// Fetches the type of a generic block descriptor.
1150	llvm::Type *getBlockDescriptorType();
1151
1152	/// The type of a generic block literal.
1153	llvm::Type *getGenericBlockLiteralType();
1154
1155	/// Gets the address of a block which requires no captures.
1156	llvm::Constant GetAddrOfGlobalBlock(const* BlockExpr *BE, StringRef Name);
1157
1158	/// Returns the address of a block which requires no caputres, or null if
1159	/// we've yet to emit the block for BE.
1160	llvm::Constant getAddrOfGlobalBlockIfEmitted(const* BlockExpr *BE) {
1161	return EmittedGlobalBlocks.lookup(Val: BE);
1162	}
1163
1164	/// Notes that BE's global block is available via Addr. Asserts that BE
1165	/// isn't already emitted.
1166	void setAddrOfGlobalBlock(const BlockExpr BE, llvm::Constant Addr);
1167
1168	/// Return a pointer to a constant CFString object for the given string.
1169	ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal);
1170
1171	/// Return a constant array for the given string.
1172	llvm::Constant GetConstantArrayFromStringLiteral(const* StringLiteral *E);
1173
1174	/// Return a pointer to a constant array for the given string literal.
1175	ConstantAddress
1176	GetAddrOfConstantStringFromLiteral(const StringLiteral *S,
1177	StringRef Name = ".str");
1178
1179	/// Return a pointer to a constant array for the given ObjCEncodeExpr node.
1180	ConstantAddress
1181	GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *);
1182
1183	/// Returns a pointer to a character array containing the literal and a
1184	/// terminating '\0' character. The result has pointer to array type.
1185	///
1186	/// \param GlobalName If provided, the name to use for the global (if one is
1187	/// created).
1188	ConstantAddress
1189	GetAddrOfConstantCString(const std::string &Str,
1190	const char GlobalName = nullptr*);
1191
1192	/// Returns a pointer to a constant global variable for the given file-scope
1193	/// compound literal expression.
1194	ConstantAddress GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr*E);
1195
1196	/// If it's been emitted already, returns the GlobalVariable corresponding to
1197	/// a compound literal. Otherwise, returns null.
1198	llvm::GlobalVariable *
1199	getAddrOfConstantCompoundLiteralIfEmitted(const CompoundLiteralExpr *E);
1200
1201	/// Notes that CLE's GlobalVariable is GV. Asserts that CLE isn't already
1202	/// emitted.
1203	void setAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *CLE,
1204	llvm::GlobalVariable *GV);
1205
1206	/// Returns a pointer to a global variable representing a temporary
1207	/// with static or thread storage duration.
1208	ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E,
1209	const Expr *Inner);
1210
1211	/// Retrieve the record type that describes the state of an
1212	/// Objective-C fast enumeration loop (for..in).
1213	QualType getObjCFastEnumerationStateType();
1214
1215	// Produce code for this constructor/destructor. This method doesn't try
1216	// to apply any ABI rules about which other constructors/destructors
1217	// are needed or if they are alias to each other.
1218	llvm::Function *codegenCXXStructor(GlobalDecl GD);
1219
1220	/// Return the address of the constructor/destructor of the given type.
1221	llvm::Constant *
1222	getAddrOfCXXStructor(GlobalDecl GD, const CGFunctionInfo FnInfo = nullptr*,
1223	llvm::FunctionType FnType = nullptr*,
1224	bool DontDefer = false,
1225	ForDefinition_t IsForDefinition = NotForDefinition) {
1226	return cast<llvm::Constant>(Val: getAddrAndTypeOfCXXStructor(GD, FnInfo, FnType,
1227	DontDefer,
1228	IsForDefinition)
1229	.getCallee());
1230	}
1231
1232	llvm::FunctionCallee getAddrAndTypeOfCXXStructor(
1233	GlobalDecl GD, const CGFunctionInfo FnInfo = nullptr*,
1234	llvm::FunctionType FnType = nullptr, bool* DontDefer = false,
1235	ForDefinition_t IsForDefinition = NotForDefinition);
1236
1237	/// Given a builtin id for a function like "__builtin_fabsf", return a
1238	/// Function for "fabsf".*
1239	llvm::Constant getBuiltinLibFunction(const* FunctionDecl *FD,
1240	unsigned BuiltinID);
1241
1242	llvm::Function getIntrinsic(unsigned* IID, ArrayRef<llvm::Type *> Tys = {});
1243
1244	void AddCXXGlobalInit(llvm::Function *F) { CXXGlobalInits.push_back(x: F); }
1245
1246	/// Emit code for a single top level declaration.
1247	void EmitTopLevelDecl(Decl *D);
1248
1249	/// Stored a deferred empty coverage mapping for an unused
1250	/// and thus uninstrumented top level declaration.
1251	void AddDeferredUnusedCoverageMapping(Decl *D);
1252
1253	/// Remove the deferred empty coverage mapping as this
1254	/// declaration is actually instrumented.
1255	void ClearUnusedCoverageMapping(const Decl *D);
1256
1257	/// Emit all the deferred coverage mappings
1258	/// for the uninstrumented functions.
1259	void EmitDeferredUnusedCoverageMappings();
1260
1261	/// Emit an alias for "main" if it has no arguments (needed for wasm).
1262	void EmitMainVoidAlias();
1263
1264	/// Tell the consumer that this variable has been instantiated.
1265	void HandleCXXStaticMemberVarInstantiation(VarDecl *VD);
1266
1267	/// If the declaration has internal linkage but is inside an
1268	/// extern "C" linkage specification, prepare to emit an alias for it
1269	/// to the expected name.
1270	template<typename SomeDecl>
1271	void MaybeHandleStaticInExternC(const SomeDecl D, llvm::GlobalValue GV);
1272
1273	/// Add a global to a list to be added to the llvm.used metadata.
1274	void addUsedGlobal(llvm::GlobalValue *GV);
1275
1276	/// Add a global to a list to be added to the llvm.compiler.used metadata.
1277	void addCompilerUsedGlobal(llvm::GlobalValue *GV);
1278
1279	/// Add a global to a list to be added to the llvm.compiler.used metadata.
1280	void addUsedOrCompilerUsedGlobal(llvm::GlobalValue *GV);
1281
1282	/// Add a destructor and object to add to the C++ global destructor function.
1283	void AddCXXDtorEntry(llvm::FunctionCallee DtorFn, llvm::Constant *Object) {
1284	CXXGlobalDtorsOrStermFinalizers.emplace_back(Args: DtorFn.getFunctionType(),
1285	Args: DtorFn.getCallee(), Args&: Object);
1286	}
1287
1288	/// Add an sterm finalizer to the C++ global cleanup function.
1289	void AddCXXStermFinalizerEntry(llvm::FunctionCallee DtorFn) {
1290	CXXGlobalDtorsOrStermFinalizers.emplace_back(Args: DtorFn.getFunctionType(),
1291	Args: DtorFn.getCallee(), Args: nullptr);
1292	}
1293
1294	/// Add an sterm finalizer to its own llvm.global_dtors entry.
1295	void AddCXXStermFinalizerToGlobalDtor(llvm::Function *StermFinalizer,
1296	int Priority) {
1297	AddGlobalDtor(Dtor: StermFinalizer, Priority);
1298	}
1299
1300	void AddCXXPrioritizedStermFinalizerEntry(llvm::Function *StermFinalizer,
1301	int Priority) {
1302	OrderGlobalInitsOrStermFinalizers Key(Priority,
1303	PrioritizedCXXStermFinalizers.size());
1304	PrioritizedCXXStermFinalizers.push_back(
1305	Elt: std::make_pair(x&: Key, y&: StermFinalizer));
1306	}
1307
1308	/// Create or return a runtime function declaration with the specified type
1309	/// and name. If \p AssumeConvergent is true, the call will have the
1310	/// convergent attribute added.
1311	///
1312	/// For new code, please use the overload that takes a QualType; it sets
1313	/// function attributes more accurately.
1314	llvm::FunctionCallee
1315	CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name,
1316	llvm::AttributeList ExtraAttrs = llvm::AttributeList (),
1317	bool Local = false, bool AssumeConvergent = false);
1318
1319	/// Create or return a runtime function declaration with the specified type
1320	/// and name. If \p AssumeConvergent is true, the call will have the
1321	/// convergent attribute added.
1322	llvm::FunctionCallee
1323	CreateRuntimeFunction(QualType ReturnTy, ArrayRef<QualType> ArgTys,
1324	StringRef Name,
1325	llvm::AttributeList ExtraAttrs = llvm::AttributeList (),
1326	bool Local = false, bool AssumeConvergent = false);
1327
1328	/// Create a new runtime global variable with the specified type and name.
1329	llvm::Constant CreateRuntimeVariable(llvm::Type Ty,
1330	StringRef Name);
1331
1332	///@name Custom Blocks Runtime Interfaces
1333	///@{
1334
1335	llvm::Constant *getNSConcreteGlobalBlock();
1336	llvm::Constant *getNSConcreteStackBlock();
1337	llvm::FunctionCallee getBlockObjectAssign();
1338	llvm::FunctionCallee getBlockObjectDispose();
1339
1340	///@}
1341
1342	llvm::Function *getLLVMLifetimeStartFn();
1343	llvm::Function *getLLVMLifetimeEndFn();
1344	llvm::Function *getLLVMFakeUseFn();
1345
1346	// Make sure that this type is translated.
1347	void UpdateCompletedType(const TagDecl *TD);
1348
1349	llvm::Constant getMemberPointerConstant(const* UnaryOperator *e);
1350
1351	/// Emit type info if type of an expression is a variably modified
1352	/// type. Also emit proper debug info for cast types.
1353	void EmitExplicitCastExprType(const ExplicitCastExpr *E,
1354	CodeGenFunction CGF = nullptr*);
1355
1356	/// Return the result of value-initializing the given type, i.e. a null
1357	/// expression of the given type. This is usually, but not always, an LLVM
1358	/// null constant.
1359	llvm::Constant *EmitNullConstant(QualType T);
1360
1361	/// Return a null constant appropriate for zero-initializing a base class with
1362	/// the given type. This is usually, but not always, an LLVM null constant.
1363	llvm::Constant EmitNullConstantForBase(const* CXXRecordDecl *Record);
1364
1365	/// Emit a general error that something can't be done.
1366	void Error(SourceLocation loc, StringRef error);
1367
1368	/// Print out an error that codegen doesn't support the specified stmt yet.
1369	void ErrorUnsupported(const Stmt S, const* char *Type);
1370
1371	/// Print out an error that codegen doesn't support the specified decl yet.
1372	void ErrorUnsupported(const Decl D, const* char *Type);
1373
1374	/// Run some code with "sufficient" stack space. (Currently, at least 256K is
1375	/// guaranteed). Produces a warning if we're low on stack space and allocates
1376	/// more in that case. Use this in code that may recurse deeply to avoid stack
1377	/// overflow.
1378	void runWithSufficientStackSpace(SourceLocation Loc,
1379	llvm::function_ref<void()> Fn);
1380
1381	/// Set the attributes on the LLVM function for the given decl and function
1382	/// info. This applies attributes necessary for handling the ABI as well as
1383	/// user specified attributes like section.
1384	void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F,
1385	const CGFunctionInfo &FI);
1386
1387	/// Set the LLVM function attributes (sext, zext, etc).
1388	void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info,
1389	llvm::Function F, bool* IsThunk);
1390
1391	/// Set the LLVM function attributes which only apply to a function
1392	/// definition.
1393	void SetLLVMFunctionAttributesForDefinition(const Decl D, llvm::Function F);
1394
1395	/// Set the LLVM function attributes that represent floating point
1396	/// environment.
1397	void setLLVMFunctionFEnvAttributes(const FunctionDecl D, llvm::Function F);
1398
1399	/// Return true iff the given type uses 'sret' when used as a return type.
1400	bool ReturnTypeUsesSRet(const CGFunctionInfo &FI);
1401
1402	/// Return true iff the given type has `inreg` set.
1403	bool ReturnTypeHasInReg(const CGFunctionInfo &FI);
1404
1405	/// Return true iff the given type uses an argument slot when 'sret' is used
1406	/// as a return type.
1407	bool ReturnSlotInterferesWithArgs(const CGFunctionInfo &FI);
1408
1409	/// Return true iff the given type uses 'fpret' when used as a return type.
1410	bool ReturnTypeUsesFPRet(QualType ResultType);
1411
1412	/// Return true iff the given type uses 'fp2ret' when used as a return type.
1413	bool ReturnTypeUsesFP2Ret(QualType ResultType);
1414
1415	/// Get the LLVM attributes and calling convention to use for a particular
1416	/// function type.
1417	///
1418	/// \param Name - The function name.
1419	/// \param Info - The function type information.
1420	/// \param CalleeInfo - The callee information these attributes are being
1421	/// constructed for. If valid, the attributes applied to this decl may
1422	/// contribute to the function attributes and calling convention.
1423	/// \param Attrs [out] - On return, the attribute list to use.
1424	/// \param CallingConv [out] - On return, the LLVM calling convention to use.
1425	void ConstructAttributeList(StringRef Name, const CGFunctionInfo &Info,
1426	CGCalleeInfo CalleeInfo,
1427	llvm::AttributeList &Attrs, unsigned &CallingConv,
1428	bool AttrOnCallSite, bool IsThunk);
1429
1430	/// Adjust Memory attribute to ensure that the BE gets the right attribute
1431	// in order to generate the library call or the intrinsic for the function
1432	// name 'Name'.
1433	void AdjustMemoryAttribute(StringRef Name, CGCalleeInfo CalleeInfo,
1434	llvm::AttributeList &Attrs);
1435
1436	/// Like the overload taking a `Function &`, but intended specifically
1437	/// for frontends that want to build on Clang's target-configuration logic.
1438	void addDefaultFunctionDefinitionAttributes(llvm::AttrBuilder &attrs);
1439
1440	StringRef getMangledName(GlobalDecl GD);
1441	StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD);
1442	const GlobalDecl getMangledNameDecl(StringRef);
1443
1444	void EmitTentativeDefinition(const VarDecl *D);
1445
1446	void EmitExternalDeclaration(const DeclaratorDecl *D);
1447
1448	void EmitVTable(CXXRecordDecl *Class);
1449
1450	void RefreshTypeCacheForClass(const CXXRecordDecl *Class);
1451
1452	/// Appends Opts to the "llvm.linker.options" metadata value.
1453	void AppendLinkerOptions(StringRef Opts);
1454
1455	/// Appends a detect mismatch command to the linker options.
1456	void AddDetectMismatch(StringRef Name, StringRef Value);
1457
1458	/// Appends a dependent lib to the appropriate metadata value.
1459	void AddDependentLib(StringRef Lib);
1460
1461
1462	llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD);
1463
1464	void setFunctionLinkage(GlobalDecl GD, llvm::Function *F) {
1465	F->setLinkage(getFunctionLinkage(GD));
1466	}
1467
1468	/// Return the appropriate linkage for the vtable, VTT, and type information
1469	/// of the given class.
1470	llvm::GlobalVariable::LinkageTypes getVTableLinkage(const CXXRecordDecl *RD);
1471
1472	/// Return the store size, in character units, of the given LLVM type.
1473	CharUnits GetTargetTypeStoreSize(llvm::Type Ty) const*;
1474
1475	/// Returns LLVM linkage for a declarator.
1476	llvm::GlobalValue::LinkageTypes
1477	getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage);
1478
1479	/// Returns LLVM linkage for a declarator.
1480	llvm::GlobalValue::LinkageTypes
1481	getLLVMLinkageVarDefinition(const VarDecl *VD);
1482
1483	/// Emit all the global annotations.
1484	void EmitGlobalAnnotations();
1485
1486	/// Emit an annotation string.
1487	llvm::Constant *EmitAnnotationString(StringRef Str);
1488
1489	/// Emit the annotation's translation unit.
1490	llvm::Constant *EmitAnnotationUnit(SourceLocation Loc);
1491
1492	/// Emit the annotation line number.
1493	llvm::Constant *EmitAnnotationLineNo(SourceLocation L);
1494
1495	/// Emit additional args of the annotation.
1496	llvm::Constant EmitAnnotationArgs(const* AnnotateAttr *Attr);
1497
1498	/// Generate the llvm::ConstantStruct which contains the annotation
1499	/// information for a given GlobalValue. The annotation struct is
1500	/// {i8 , i8 , i8 , i32}. The first field is a constant expression, the*
1501	/// GlobalValue being annotated. The second field is the constant string
1502	/// created from the AnnotateAttr's annotation. The third field is a constant
1503	/// string containing the name of the translation unit. The fourth field is
1504	/// the line number in the file of the annotated value declaration.
1505	llvm::Constant EmitAnnotateAttr(llvm::GlobalValue GV,
1506	const AnnotateAttr *AA,
1507	SourceLocation L);
1508
1509	/// Add global annotations that are set on D, for the global GV. Those
1510	/// annotations are emitted during finalization of the LLVM code.
1511	void AddGlobalAnnotations(const ValueDecl D, llvm::GlobalValue GV);
1512
1513	bool isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn,
1514	SourceLocation Loc) const;
1515
1516	bool isInNoSanitizeList(SanitizerMask Kind, llvm::GlobalVariable *GV,
1517	SourceLocation Loc, QualType Ty,
1518	StringRef Category = StringRef()) const;
1519
1520	/// Imbue XRay attributes to a function, applying the always/never attribute
1521	/// lists in the process. Returns true if we did imbue attributes this way,
1522	/// false otherwise.
1523	bool imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
1524	StringRef Category = StringRef()) const;
1525
1526	/// \returns true if \p Fn at \p Loc should be excluded from profile
1527	/// instrumentation by the SCL passed by \p -fprofile-list.
1528	ProfileList::ExclusionType
1529	isFunctionBlockedByProfileList(llvm::Function Fn, SourceLocation Loc) const*;
1530
1531	/// \returns true if \p Fn at \p Loc should be excluded from profile
1532	/// instrumentation.
1533	ProfileList::ExclusionType
1534	isFunctionBlockedFromProfileInstr(llvm::Function *Fn,
1535	SourceLocation Loc) const;
1536
1537	SanitizerMetadata *getSanitizerMetadata() {
1538	return SanitizerMD.get();
1539	}
1540
1541	void addDeferredVTable(const CXXRecordDecl *RD) {
1542	DeferredVTables.push_back(x: RD);
1543	}
1544
1545	/// Emit code for a single global function or var decl. Forward declarations
1546	/// are emitted lazily.
1547	void EmitGlobal(GlobalDecl D);
1548
1549	bool TryEmitBaseDestructorAsAlias(const CXXDestructorDecl *D);
1550
1551	llvm::GlobalValue *GetGlobalValue(StringRef Ref);
1552
1553	/// Set attributes which are common to any form of a global definition (alias,
1554	/// Objective-C method, function, global variable).
1555	///
1556	/// NOTE: This should only be called for definitions.
1557	void SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV);
1558
1559	void addReplacement(StringRef Name, llvm::Constant *C);
1560
1561	void addGlobalValReplacement(llvm::GlobalValue GV, llvm::Constant C);
1562
1563	/// Emit a code for threadprivate directive.
1564	/// \param D Threadprivate declaration.
1565	void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D);
1566
1567	/// Emit a code for declare reduction construct.
1568	void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D,
1569	CodeGenFunction CGF = nullptr*);
1570
1571	/// Emit a code for declare mapper construct.
1572	void EmitOMPDeclareMapper(const OMPDeclareMapperDecl *D,
1573	CodeGenFunction CGF = nullptr*);
1574
1575	// Emit code for the OpenACC Declare declaration.
1576	void EmitOpenACCDeclare(const OpenACCDeclareDecl *D,
1577	CodeGenFunction CGF = nullptr*);
1578	// Emit code for the OpenACC Routine declaration.
1579	void EmitOpenACCRoutine(const OpenACCRoutineDecl *D,
1580	CodeGenFunction CGF = nullptr*);
1581
1582	/// Emit a code for requires directive.
1583	/// \param D Requires declaration
1584	void EmitOMPRequiresDecl(const OMPRequiresDecl *D);
1585
1586	/// Emit a code for the allocate directive.
1587	/// \param D The allocate declaration
1588	void EmitOMPAllocateDecl(const OMPAllocateDecl *D);
1589
1590	/// Return the alignment specified in an allocate directive, if present.
1591	std::optional<CharUnits> getOMPAllocateAlignment(const VarDecl *VD);
1592
1593	/// Returns whether the given record has hidden LTO visibility and therefore
1594	/// may participate in (single-module) CFI and whole-program vtable
1595	/// optimization.
1596	bool HasHiddenLTOVisibility(const CXXRecordDecl *RD);
1597
1598	/// Returns whether the given record has public LTO visibility (regardless of
1599	/// -lto-whole-program-visibility) and therefore may not participate in
1600	/// (single-module) CFI and whole-program vtable optimization.
1601	bool AlwaysHasLTOVisibilityPublic(const CXXRecordDecl *RD);
1602
1603	/// Returns the vcall visibility of the given type. This is the scope in which
1604	/// a virtual function call could be made which ends up being dispatched to a
1605	/// member function of this class. This scope can be wider than the visibility
1606	/// of the class itself when the class has a more-visible dynamic base class.
1607	/// The client should pass in an empty Visited set, which is used to prevent
1608	/// redundant recursive processing.
1609	llvm::GlobalObject::VCallVisibility
1610	GetVCallVisibilityLevel(const CXXRecordDecl *RD,
1611	llvm::DenseSet<const CXXRecordDecl *> &Visited);
1612
1613	/// Emit type metadata for the given vtable using the given layout.
1614	void EmitVTableTypeMetadata(const CXXRecordDecl *RD,
1615	llvm::GlobalVariable *VTable,
1616	const VTableLayout &VTLayout);
1617
1618	llvm::Type getVTableComponentType() const*;
1619
1620	/// Generate a cross-DSO type identifier for MD.
1621	llvm::ConstantInt CreateCrossDsoCfiTypeId(llvm::Metadata MD);
1622
1623	/// Generate a KCFI type identifier for T.
1624	llvm::ConstantInt *CreateKCFITypeId(QualType T);
1625
1626	/// Create a metadata identifier for the given type. This may either be an
1627	/// MDString (for external identifiers) or a distinct unnamed MDNode (for
1628	/// internal identifiers).
1629	llvm::Metadata *CreateMetadataIdentifierForType(QualType T);
1630
1631	/// Create a metadata identifier that is intended to be used to check virtual
1632	/// calls via a member function pointer.
1633	llvm::Metadata *CreateMetadataIdentifierForVirtualMemPtrType(QualType T);
1634
1635	/// Create a metadata identifier for the generalization of the given type.
1636	/// This may either be an MDString (for external identifiers) or a distinct
1637	/// unnamed MDNode (for internal identifiers).
1638	llvm::Metadata *CreateMetadataIdentifierGeneralized(QualType T);
1639
1640	/// Create and attach type metadata to the given function.
1641	void createFunctionTypeMetadataForIcall(const FunctionDecl *FD,
1642	llvm::Function *F);
1643
1644	/// Set type metadata to the given function.
1645	void setKCFIType(const FunctionDecl FD, llvm::Function F);
1646
1647	/// Emit KCFI type identifier constants and remove unused identifiers.
1648	void finalizeKCFITypes();
1649
1650	/// Whether this function's return type has no side effects, and thus may
1651	/// be trivially discarded if it is unused.
1652	bool MayDropFunctionReturn(const ASTContext &Context,
1653	QualType ReturnType) const;
1654
1655	/// Returns whether this module needs the "all-vtables" type identifier.
1656	bool NeedAllVtablesTypeId() const;
1657
1658	/// Create and attach type metadata for the given vtable.
1659	void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset,
1660	const CXXRecordDecl *RD);
1661
1662	/// Return a vector of most-base classes for RD. This is used to implement
1663	/// control flow integrity checks for member function pointers.
1664	///
1665	/// A most-base class of a class C is defined as a recursive base class of C,
1666	/// including C itself, that does not have any bases.
1667	SmallVector<const CXXRecordDecl *, `0`>
1668	getMostBaseClasses(const CXXRecordDecl *RD);
1669
1670	/// Get the declaration of std::terminate for the platform.
1671	llvm::FunctionCallee getTerminateFn();
1672
1673	llvm::SanitizerStatReport &getSanStats();
1674
1675	llvm::Value *
1676	createOpenCLIntToSamplerConversion(const Expr *E, CodeGenFunction &CGF);
1677
1678	/// OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument
1679	/// information in the program executable. The argument information stored
1680	/// includes the argument name, its type, the address and access qualifiers
1681	/// used. This helper can be used to generate metadata for source code kernel
1682	/// function as well as generated implicitly kernels. If a kernel is generated
1683	/// implicitly null value has to be passed to the last two parameters,
1684	/// otherwise all parameters must have valid non-null values.
1685	/// \param FN is a pointer to IR function being generated.
1686	/// \param FD is a pointer to function declaration if any.
1687	/// \param CGF is a pointer to CodeGenFunction that generates this function.
1688	void GenKernelArgMetadata(llvm::Function *FN,
1689	const FunctionDecl FD = nullptr*,
1690	CodeGenFunction CGF = nullptr*);
1691
1692	/// Get target specific null pointer.
1693	/// \param T is the LLVM type of the null pointer.
1694	/// \param QT is the clang QualType of the null pointer.
1695	llvm::Constant getNullPointer(llvm::PointerType T, QualType QT);
1696
1697	CharUnits getNaturalTypeAlignment(QualType T,
1698	LValueBaseInfo BaseInfo = nullptr*,
1699	TBAAAccessInfo TBAAInfo = nullptr*,
1700	bool forPointeeType = false);
1701	CharUnits getNaturalPointeeTypeAlignment(QualType T,
1702	LValueBaseInfo BaseInfo = nullptr*,
1703	TBAAAccessInfo TBAAInfo = nullptr*);
1704	bool stopAutoInit();
1705
1706	/// Print the postfix for externalized static variable or kernels for single
1707	/// source offloading languages CUDA and HIP. The unique postfix is created
1708	/// using either the CUID argument, or the file's UniqueID and active macros.
1709	/// The fallback method without a CUID requires that the offloading toolchain
1710	/// does not define separate macros via the -cc1 options.
1711	void printPostfixForExternalizedDecl(llvm::raw_ostream &OS,
1712	const Decl D) const*;
1713
1714	/// Move some lazily-emitted states to the NewBuilder. This is especially
1715	/// essential for the incremental parsing environment like Clang Interpreter,
1716	/// because we'll lose all important information after each repl.
1717	void moveLazyEmissionStates(CodeGenModule *NewBuilder);
1718
1719	/// Emit the IR encoding to attach the CUDA launch bounds attribute to \p F.
1720	/// If \p MaxThreadsVal is not nullptr, the max threads value is stored in it,
1721	/// if a valid one was found.
1722	void handleCUDALaunchBoundsAttr(llvm::Function *F,
1723	const CUDALaunchBoundsAttr *A,
1724	int32_t MaxThreadsVal = nullptr*,
1725	int32_t MinBlocksVal = nullptr*,
1726	int32_t MaxClusterRankVal = nullptr*);
1727
1728	/// Emit the IR encoding to attach the AMD GPU flat-work-group-size attribute
1729	/// to \p F. Alternatively, the work group size can be taken from a \p
1730	/// ReqdWGS. If \p MinThreadsVal is not nullptr, the min threads value is
1731	/// stored in it, if a valid one was found. If \p MaxThreadsVal is not
1732	/// nullptr, the max threads value is stored in it, if a valid one was found.
1733	void handleAMDGPUFlatWorkGroupSizeAttr(
1734	llvm::Function F, const* AMDGPUFlatWorkGroupSizeAttr *A,
1735	const ReqdWorkGroupSizeAttr ReqdWGS = nullptr*,
1736	int32_t MinThreadsVal = nullptr, int32_t MaxThreadsVal = nullptr);
1737
1738	/// Emit the IR encoding to attach the AMD GPU waves-per-eu attribute to \p F.
1739	void handleAMDGPUWavesPerEUAttr(llvm::Function *F,
1740	const AMDGPUWavesPerEUAttr *A);
1741
1742	llvm::Constant *
1743	GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty, LangAS AddrSpace,
1744	const VarDecl *D,
1745	ForDefinition_t IsForDefinition = NotForDefinition);
1746
1747	// FIXME: Hardcoding priority here is gross.
1748	void AddGlobalCtor(llvm::Function Ctor, int* Priority = `65535`,
1749	unsigned LexOrder = ~`0U`,
1750	llvm::Constant AssociatedData = nullptr*);
1751	void AddGlobalDtor(llvm::Function Dtor, int* Priority = `65535`,
1752	bool IsDtorAttrFunc = false);
1753
1754	// Return whether structured convergence intrinsics should be generated for
1755	// this target.
1756	bool shouldEmitConvergenceTokens() const {
1757	// TODO: this should probably become unconditional once the controlled
1758	// convergence becomes the norm.
1759	return getTriple().isSPIRVLogical();
1760	}
1761
1762	void addUndefinedGlobalForTailCall(
1763	std::pair<const FunctionDecl *, SourceLocation> Global) {
1764	MustTailCallUndefinedGlobals.insert(X: Global);
1765	}
1766
1767	bool shouldZeroInitPadding() const {
1768	// In C23 (N3096) $6.7.10:
1769	// """
1770	// If any object is initialized with an empty iniitializer, then it is
1771	// subject to default initialization:
1772	// - if it is an aggregate, every member is initialized (recursively)
1773	// according to these rules, and any padding is initialized to zero bits;
1774	// - if it is a union, the first named member is initialized (recursively)
1775	// according to these rules, and any padding is initialized to zero bits.
1776	//
1777	// If the aggregate or union contains elements or members that are
1778	// aggregates or unions, these rules apply recursively to the subaggregates
1779	// or contained unions.
1780	//
1781	// If there are fewer initializers in a brace-enclosed list than there are
1782	// elements or members of an aggregate, or fewer characters in a string
1783	// literal used to initialize an array of known size than there are elements
1784	// in the array, the remainder of the aggregate is subject to default
1785	// initialization.
1786	// """
1787	//
1788	// From my understanding, the standard is ambiguous in the following two
1789	// areas:
1790	// 1. For a union type with empty initializer, if the first named member is
1791	// not the largest member, then the bytes comes after the first named member
1792	// but before padding are left unspecified. An example is:
1793	// union U { int a; long long b;};
1794	// union U u = {}; // The first 4 bytes are 0, but 4-8 bytes are left
1795	// unspecified.
1796	//
1797	// 2. It only mentions padding for empty initializer, but doesn't mention
1798	// padding for a non empty initialization list. And if the aggregation or
1799	// union contains elements or members that are aggregates or unions, and
1800	// some are non empty initializers, while others are empty initiailizers,
1801	// the padding initialization is unclear. An example is:
1802	// struct S1 { int a; long long b; };
1803	// struct S2 { char c; struct S1 s1; };
1804	// // The values for paddings between s2.c and s2.s1.a, between s2.s1.a
1805	// and s2.s1.b are unclear.
1806	// struct S2 s2 = { 'c' };
1807	//
1808	// Here we choose to zero initiailize left bytes of a union type. Because
1809	// projects like the Linux kernel are relying on this behavior. If we don't
1810	// explicitly zero initialize them, the undef values can be optimized to
1811	// return gabage data. We also choose to zero initialize paddings for
1812	// aggregates and unions, no matter they are initialized by empty
1813	// initializers or non empty initializers. This can provide a consistent
1814	// behavior. So projects like the Linux kernel can rely on it.
1815	return !getLangOpts().CPlusPlus;
1816	}
1817
1818	// Helper to get the alignment for a variable.
1819	unsigned getVtableGlobalVarAlignment(const VarDecl D = nullptr*) {
1820	LangAS AS = GetGlobalVarAddressSpace(D);
1821	unsigned PAlign = getItaniumVTableContext().isRelativeLayout()
1822	? `32`
1823	: getTarget().getPointerAlign(AddrSpace: AS);
1824	return PAlign;
1825	}
1826
1827	private:
1828	bool shouldDropDLLAttribute(const Decl D, const* llvm::GlobalValue GV) const*;
1829
1830	llvm::Constant *GetOrCreateLLVMFunction(
1831	StringRef MangledName, llvm::Type Ty, GlobalDecl D, bool* ForVTable,
1832	bool DontDefer = false, bool IsThunk = false,
1833	llvm::AttributeList ExtraAttrs = llvm::AttributeList (),
1834	ForDefinition_t IsForDefinition = NotForDefinition);
1835
1836	// Adds a declaration to the list of multi version functions if not present.
1837	void AddDeferredMultiVersionResolverToEmit(GlobalDecl GD);
1838
1839	// References to multiversion functions are resolved through an implicitly
1840	// defined resolver function. This function is responsible for creating
1841	// the resolver symbol for the provided declaration. The value returned
1842	// will be for an ifunc (llvm::GlobalIFunc) if the current target supports
1843	// that feature and for a regular function (llvm::GlobalValue) otherwise.
1844	llvm::Constant *GetOrCreateMultiVersionResolver(GlobalDecl GD);
1845
1846	// In scenarios where a function is not known to be a multiversion function
1847	// until a later declaration, it is sometimes necessary to change the
1848	// previously created mangled name to align with requirements of whatever
1849	// multiversion function kind the function is now known to be. This function
1850	// is responsible for performing such mangled name updates.
1851	void UpdateMultiVersionNames(GlobalDecl GD, const FunctionDecl *FD,
1852	StringRef &CurName);
1853
1854	bool GetCPUAndFeaturesAttributes(GlobalDecl GD,
1855	llvm::AttrBuilder &AttrBuilder,
1856	bool SetTargetFeatures = true);
1857	void setNonAliasAttributes(GlobalDecl GD, llvm::GlobalObject *GO);
1858
1859	/// Set function attributes for a function declaration.
1860	void SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
1861	bool IsIncompleteFunction, bool IsThunk);
1862
1863	void EmitGlobalDefinition(GlobalDecl D, llvm::GlobalValue GV = nullptr*);
1864
1865	void EmitGlobalFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV);
1866	void EmitMultiVersionFunctionDefinition(GlobalDecl GD, llvm::GlobalValue *GV);
1867
1868	void EmitGlobalVarDefinition(const VarDecl D, bool* IsTentative = false);
1869	void EmitAliasDefinition(GlobalDecl GD);
1870	void emitIFuncDefinition(GlobalDecl GD);
1871	void emitCPUDispatchDefinition(GlobalDecl GD);
1872	void EmitObjCPropertyImplementations(const ObjCImplementationDecl *D);
1873	void EmitObjCIvarInitializations(ObjCImplementationDecl *D);
1874
1875	// C++ related functions.
1876
1877	void EmitDeclContext(const DeclContext *DC);
1878	void EmitLinkageSpec(const LinkageSpecDecl *D);
1879	void EmitTopLevelStmt(const TopLevelStmtDecl *D);
1880
1881	/// Emit the function that initializes C++ thread_local variables.
1882	void EmitCXXThreadLocalInitFunc();
1883
1884	/// Emit the function that initializes global variables for a C++ Module.
1885	void EmitCXXModuleInitFunc(clang::Module *Primary);
1886
1887	/// Emit the function that initializes C++ globals.
1888	void EmitCXXGlobalInitFunc();
1889
1890	/// Emit the function that performs cleanup associated with C++ globals.
1891	void EmitCXXGlobalCleanUpFunc();
1892
1893	/// Emit the function that initializes the specified global (if PerformInit is
1894	/// true) and registers its destructor.
1895	void EmitCXXGlobalVarDeclInitFunc(const VarDecl *D,
1896	llvm::GlobalVariable *Addr,
1897	bool PerformInit);
1898
1899	void EmitPointerToInitFunc(const VarDecl VD, llvm::GlobalVariable Addr,
1900	llvm::Function InitFunc, InitSegAttr ISA);
1901
1902	/// EmitCtorList - Generates a global array of functions and priorities using
1903	/// the given list and name. This array will have appending linkage and is
1904	/// suitable for use as a LLVM constructor or destructor array. Clears Fns.
1905	void EmitCtorList(CtorList &Fns, const char *GlobalName);
1906
1907	/// Emit any needed decls for which code generation was deferred.
1908	void EmitDeferred();
1909
1910	/// Try to emit external vtables as available_externally if they have emitted
1911	/// all inlined virtual functions. It runs after EmitDeferred() and therefore
1912	/// is not allowed to create new references to things that need to be emitted
1913	/// lazily.
1914	void EmitVTablesOpportunistically();
1915
1916	/// Call replaceAllUsesWith on all pairs in Replacements.
1917	void applyReplacements();
1918
1919	/// Call replaceAllUsesWith on all pairs in GlobalValReplacements.
1920	void applyGlobalValReplacements();
1921
1922	void checkAliases();
1923
1924	std::map<int, llvm::TinyPtrVector<llvm::Function *>> DtorsUsingAtExit;
1925
1926	/// Register functions annotated with __attribute__((destructor)) using
1927	/// __cxa_atexit, if it is available, or atexit otherwise.
1928	void registerGlobalDtorsWithAtExit();
1929
1930	// When using sinit and sterm functions, unregister
1931	// __attribute__((destructor)) annotated functions which were previously
1932	// registered by the atexit subroutine using unatexit.
1933	void unregisterGlobalDtorsWithUnAtExit();
1934
1935	/// Emit deferred multiversion function resolvers and associated variants.
1936	void emitMultiVersionFunctions();
1937
1938	/// Emit any vtables which we deferred and still have a use for.
1939	void EmitDeferredVTables();
1940
1941	/// Emit a dummy function that reference a CoreFoundation symbol when
1942	/// @available is used on Darwin.
1943	void emitAtAvailableLinkGuard();
1944
1945	/// Emit the llvm.used and llvm.compiler.used metadata.
1946	void emitLLVMUsed();
1947
1948	/// For C++20 Itanium ABI, emit the initializers for the module.
1949	void EmitModuleInitializers(clang::Module *Primary);
1950
1951	/// Emit the link options introduced by imported modules.
1952	void EmitModuleLinkOptions();
1953
1954	/// Helper function for EmitStaticExternCAliases() to redirect ifuncs that
1955	/// have a resolver name that matches 'Elem' to instead resolve to the name of
1956	/// 'CppFunc'. This redirection is necessary in cases where 'Elem' has a name
1957	/// that will be emitted as an alias of the name bound to 'CppFunc'; ifuncs
1958	/// may not reference aliases. Redirection is only performed if 'Elem' is only
1959	/// used by ifuncs in which case, 'Elem' is destroyed. 'true' is returned if
1960	/// redirection is successful, and 'false' is returned otherwise.
1961	bool CheckAndReplaceExternCIFuncs(llvm::GlobalValue *Elem,
1962	llvm::GlobalValue *CppFunc);
1963
1964	/// Emit aliases for internal-linkage declarations inside "C" language
1965	/// linkage specifications, giving them the "expected" name where possible.
1966	void EmitStaticExternCAliases();
1967
1968	void EmitDeclMetadata();
1969
1970	/// Emit the Clang version as llvm.ident metadata.
1971	void EmitVersionIdentMetadata();
1972
1973	/// Emit the Clang commandline as llvm.commandline metadata.
1974	void EmitCommandLineMetadata();
1975
1976	/// Emit the module flag metadata used to pass options controlling the
1977	/// the backend to LLVM.
1978	void EmitBackendOptionsMetadata(const CodeGenOptions &CodeGenOpts);
1979
1980	/// Emits OpenCL specific Metadata e.g. OpenCL version.
1981	void EmitOpenCLMetadata();
1982
1983	/// Emit the llvm.gcov metadata used to tell LLVM where to emit the .gcno and
1984	/// .gcda files in a way that persists in .bc files.
1985	void EmitCoverageFile();
1986
1987	/// Given a sycl_kernel_entry_point attributed function, emit the
1988	/// corresponding SYCL kernel caller offload entry point function.
1989	void EmitSYCLKernelCaller(const FunctionDecl *KernelEntryPointFn,
1990	ASTContext &Ctx);
1991
1992	/// Determine whether the definition must be emitted; if this returns \c
1993	/// false, the definition can be emitted lazily if it's used.
1994	bool MustBeEmitted(const ValueDecl *D);
1995
1996	/// Determine whether the definition can be emitted eagerly, or should be
1997	/// delayed until the end of the translation unit. This is relevant for
1998	/// definitions whose linkage can change, e.g. implicit function instantions
1999	/// which may later be explicitly instantiated.
2000	bool MayBeEmittedEagerly(const ValueDecl *D);
2001
2002	/// Check whether we can use a "simpler", more core exceptions personality
2003	/// function.
2004	void SimplifyPersonality();
2005
2006	/// Helper function for getDefaultFunctionAttributes. Builds a set of function
2007	/// attributes which can be simply added to a function.
2008	void getTrivialDefaultFunctionAttributes(StringRef Name, bool HasOptnone,
2009	bool AttrOnCallSite,
2010	llvm::AttrBuilder &FuncAttrs);
2011
2012	/// Helper function for ConstructAttributeList and
2013	/// addDefaultFunctionDefinitionAttributes. Builds a set of function
2014	/// attributes to add to a function with the given properties.
2015	void getDefaultFunctionAttributes(StringRef Name, bool HasOptnone,
2016	bool AttrOnCallSite,
2017	llvm::AttrBuilder &FuncAttrs);
2018
2019	llvm::Metadata *CreateMetadataIdentifierImpl(QualType T, MetadataTypeMap &Map,
2020	StringRef Suffix);
2021	};
2022
2023	} // end namespace CodeGen
2024	} // end namespace clang
2025
2026	#endif // LLVM_CLANG_LIB_CODEGEN_CODEGENMODULE_H
2027

Browse the source code of llvm_projects/clang/lib/CodeGen/CodeGenModule.h