clang 22.0.0git
CodeGenModule.cpp
Go to the documentation of this file.
1//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===//
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 coordinates the per-module state used while generating code.
10//
11//===----------------------------------------------------------------------===//
12
13#include "CodeGenModule.h"
14#include "ABIInfo.h"
15#include "CGBlocks.h"
16#include "CGCUDARuntime.h"
17#include "CGCXXABI.h"
18#include "CGCall.h"
19#include "CGDebugInfo.h"
20#include "CGHLSLRuntime.h"
21#include "CGObjCRuntime.h"
22#include "CGOpenCLRuntime.h"
23#include "CGOpenMPRuntime.h"
24#include "CGOpenMPRuntimeGPU.h"
25#include "CodeGenFunction.h"
26#include "CodeGenPGO.h"
27#include "ConstantEmitter.h"
28#include "CoverageMappingGen.h"
29#include "TargetInfo.h"
31#include "clang/AST/ASTLambda.h"
32#include "clang/AST/CharUnits.h"
33#include "clang/AST/Decl.h"
34#include "clang/AST/DeclCXX.h"
35#include "clang/AST/DeclObjC.h"
37#include "clang/AST/Mangle.h"
43#include "clang/Basic/Module.h"
46#include "clang/Basic/Version.h"
50#include "llvm/ADT/STLExtras.h"
51#include "llvm/ADT/StringExtras.h"
52#include "llvm/ADT/StringSwitch.h"
53#include "llvm/Analysis/TargetLibraryInfo.h"
54#include "llvm/BinaryFormat/ELF.h"
55#include "llvm/IR/AttributeMask.h"
56#include "llvm/IR/CallingConv.h"
57#include "llvm/IR/DataLayout.h"
58#include "llvm/IR/Intrinsics.h"
59#include "llvm/IR/LLVMContext.h"
60#include "llvm/IR/Module.h"
61#include "llvm/IR/ProfileSummary.h"
62#include "llvm/ProfileData/InstrProfReader.h"
63#include "llvm/ProfileData/SampleProf.h"
64#include "llvm/Support/CRC.h"
65#include "llvm/Support/CodeGen.h"
66#include "llvm/Support/CommandLine.h"
67#include "llvm/Support/ConvertUTF.h"
68#include "llvm/Support/ErrorHandling.h"
69#include "llvm/Support/TimeProfiler.h"
70#include "llvm/Support/xxhash.h"
71#include "llvm/TargetParser/RISCVISAInfo.h"
72#include "llvm/TargetParser/Triple.h"
73#include "llvm/TargetParser/X86TargetParser.h"
74#include "llvm/Transforms/Utils/BuildLibCalls.h"
75#include <optional>
76#include <set>
77
78using namespace clang;
79using namespace CodeGen;
80
81static llvm::cl::opt<bool> LimitedCoverage(
82 "limited-coverage-experimental", llvm::cl::Hidden,
83 llvm::cl::desc("Emit limited coverage mapping information (experimental)"));
84
85static const char AnnotationSection[] = "llvm.metadata";
86static constexpr auto ErrnoTBAAMDName = "llvm.errno.tbaa";
87
89 switch (CGM.getContext().getCXXABIKind()) {
90 case TargetCXXABI::AppleARM64:
91 case TargetCXXABI::Fuchsia:
92 case TargetCXXABI::GenericAArch64:
93 case TargetCXXABI::GenericARM:
94 case TargetCXXABI::iOS:
95 case TargetCXXABI::WatchOS:
96 case TargetCXXABI::GenericMIPS:
97 case TargetCXXABI::GenericItanium:
98 case TargetCXXABI::WebAssembly:
99 case TargetCXXABI::XL:
100 return CreateItaniumCXXABI(CGM);
101 case TargetCXXABI::Microsoft:
102 return CreateMicrosoftCXXABI(CGM);
103 }
104
105 llvm_unreachable("invalid C++ ABI kind");
106}
107
108static std::unique_ptr<TargetCodeGenInfo>
110 const TargetInfo &Target = CGM.getTarget();
111 const llvm::Triple &Triple = Target.getTriple();
112 const CodeGenOptions &CodeGenOpts = CGM.getCodeGenOpts();
113
114 switch (Triple.getArch()) {
115 default:
117
118 case llvm::Triple::m68k:
119 return createM68kTargetCodeGenInfo(CGM);
120 case llvm::Triple::mips:
121 case llvm::Triple::mipsel:
122 if (Triple.getOS() == llvm::Triple::Win32)
123 return createWindowsMIPSTargetCodeGenInfo(CGM, /*IsOS32=*/true);
124 return createMIPSTargetCodeGenInfo(CGM, /*IsOS32=*/true);
125
126 case llvm::Triple::mips64:
127 case llvm::Triple::mips64el:
128 return createMIPSTargetCodeGenInfo(CGM, /*IsOS32=*/false);
129
130 case llvm::Triple::avr: {
131 // For passing parameters, R8~R25 are used on avr, and R18~R25 are used
132 // on avrtiny. For passing return value, R18~R25 are used on avr, and
133 // R22~R25 are used on avrtiny.
134 unsigned NPR = Target.getABI() == "avrtiny" ? 6 : 18;
135 unsigned NRR = Target.getABI() == "avrtiny" ? 4 : 8;
136 return createAVRTargetCodeGenInfo(CGM, NPR, NRR);
137 }
138
139 case llvm::Triple::aarch64:
140 case llvm::Triple::aarch64_32:
141 case llvm::Triple::aarch64_be: {
142 AArch64ABIKind Kind = AArch64ABIKind::AAPCS;
143 if (Target.getABI() == "darwinpcs")
144 Kind = AArch64ABIKind::DarwinPCS;
145 else if (Triple.isOSWindows())
146 return createWindowsAArch64TargetCodeGenInfo(CGM, AArch64ABIKind::Win64);
147 else if (Target.getABI() == "aapcs-soft")
148 Kind = AArch64ABIKind::AAPCSSoft;
149 else if (Target.getABI() == "pauthtest")
150 Kind = AArch64ABIKind::PAuthTest;
151
152 return createAArch64TargetCodeGenInfo(CGM, Kind);
153 }
154
155 case llvm::Triple::wasm32:
156 case llvm::Triple::wasm64: {
157 WebAssemblyABIKind Kind = WebAssemblyABIKind::MVP;
158 if (Target.getABI() == "experimental-mv")
159 Kind = WebAssemblyABIKind::ExperimentalMV;
160 return createWebAssemblyTargetCodeGenInfo(CGM, Kind);
161 }
162
163 case llvm::Triple::arm:
164 case llvm::Triple::armeb:
165 case llvm::Triple::thumb:
166 case llvm::Triple::thumbeb: {
167 if (Triple.getOS() == llvm::Triple::Win32)
168 return createWindowsARMTargetCodeGenInfo(CGM, ARMABIKind::AAPCS_VFP);
169
170 ARMABIKind Kind = ARMABIKind::AAPCS;
171 StringRef ABIStr = Target.getABI();
172 if (ABIStr == "apcs-gnu")
173 Kind = ARMABIKind::APCS;
174 else if (ABIStr == "aapcs16")
175 Kind = ARMABIKind::AAPCS16_VFP;
176 else if (CodeGenOpts.FloatABI == "hard" ||
177 (CodeGenOpts.FloatABI != "soft" && Triple.isHardFloatABI()))
178 Kind = ARMABIKind::AAPCS_VFP;
179
180 return createARMTargetCodeGenInfo(CGM, Kind);
181 }
182
183 case llvm::Triple::ppc: {
184 if (Triple.isOSAIX())
185 return createAIXTargetCodeGenInfo(CGM, /*Is64Bit=*/false);
186
187 bool IsSoftFloat =
188 CodeGenOpts.FloatABI == "soft" || Target.hasFeature("spe");
189 return createPPC32TargetCodeGenInfo(CGM, IsSoftFloat);
190 }
191 case llvm::Triple::ppcle: {
192 bool IsSoftFloat =
193 CodeGenOpts.FloatABI == "soft" || Target.hasFeature("spe");
194 return createPPC32TargetCodeGenInfo(CGM, IsSoftFloat);
195 }
196 case llvm::Triple::ppc64:
197 if (Triple.isOSAIX())
198 return createAIXTargetCodeGenInfo(CGM, /*Is64Bit=*/true);
199
200 if (Triple.isOSBinFormatELF()) {
201 PPC64_SVR4_ABIKind Kind = PPC64_SVR4_ABIKind::ELFv1;
202 if (Target.getABI() == "elfv2")
203 Kind = PPC64_SVR4_ABIKind::ELFv2;
204 bool IsSoftFloat = CodeGenOpts.FloatABI == "soft";
205
206 return createPPC64_SVR4_TargetCodeGenInfo(CGM, Kind, IsSoftFloat);
207 }
209 case llvm::Triple::ppc64le: {
210 assert(Triple.isOSBinFormatELF() && "PPC64 LE non-ELF not supported!");
211 PPC64_SVR4_ABIKind Kind = PPC64_SVR4_ABIKind::ELFv2;
212 if (Target.getABI() == "elfv1")
213 Kind = PPC64_SVR4_ABIKind::ELFv1;
214 bool IsSoftFloat = CodeGenOpts.FloatABI == "soft";
215
216 return createPPC64_SVR4_TargetCodeGenInfo(CGM, Kind, IsSoftFloat);
217 }
218
219 case llvm::Triple::nvptx:
220 case llvm::Triple::nvptx64:
222
223 case llvm::Triple::msp430:
225
226 case llvm::Triple::riscv32:
227 case llvm::Triple::riscv64: {
228 StringRef ABIStr = Target.getABI();
229 unsigned XLen = Target.getPointerWidth(LangAS::Default);
230 unsigned ABIFLen = 0;
231 if (ABIStr.ends_with("f"))
232 ABIFLen = 32;
233 else if (ABIStr.ends_with("d"))
234 ABIFLen = 64;
235 bool EABI = ABIStr.ends_with("e");
236 return createRISCVTargetCodeGenInfo(CGM, XLen, ABIFLen, EABI);
237 }
238
239 case llvm::Triple::systemz: {
240 bool SoftFloat = CodeGenOpts.FloatABI == "soft";
241 bool HasVector = !SoftFloat && Target.getABI() == "vector";
242 return createSystemZTargetCodeGenInfo(CGM, HasVector, SoftFloat);
243 }
244
245 case llvm::Triple::tce:
246 case llvm::Triple::tcele:
247 return createTCETargetCodeGenInfo(CGM);
248
249 case llvm::Triple::x86: {
250 bool IsDarwinVectorABI = Triple.isOSDarwin();
251 bool IsWin32FloatStructABI = Triple.isOSWindows() && !Triple.isOSCygMing();
252
253 if (Triple.getOS() == llvm::Triple::Win32) {
255 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
256 CodeGenOpts.NumRegisterParameters);
257 }
259 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
260 CodeGenOpts.NumRegisterParameters, CodeGenOpts.FloatABI == "soft");
261 }
262
263 case llvm::Triple::x86_64: {
264 StringRef ABI = Target.getABI();
265 X86AVXABILevel AVXLevel = (ABI == "avx512" ? X86AVXABILevel::AVX512
266 : ABI == "avx" ? X86AVXABILevel::AVX
267 : X86AVXABILevel::None);
268
269 switch (Triple.getOS()) {
270 case llvm::Triple::UEFI:
271 case llvm::Triple::Win32:
272 return createWinX86_64TargetCodeGenInfo(CGM, AVXLevel);
273 default:
274 return createX86_64TargetCodeGenInfo(CGM, AVXLevel);
275 }
276 }
277 case llvm::Triple::hexagon:
279 case llvm::Triple::lanai:
281 case llvm::Triple::r600:
283 case llvm::Triple::amdgcn:
285 case llvm::Triple::sparc:
287 case llvm::Triple::sparcv9:
289 case llvm::Triple::xcore:
291 case llvm::Triple::arc:
292 return createARCTargetCodeGenInfo(CGM);
293 case llvm::Triple::spir:
294 case llvm::Triple::spir64:
296 case llvm::Triple::spirv32:
297 case llvm::Triple::spirv64:
298 case llvm::Triple::spirv:
300 case llvm::Triple::dxil:
302 case llvm::Triple::ve:
303 return createVETargetCodeGenInfo(CGM);
304 case llvm::Triple::csky: {
305 bool IsSoftFloat = !Target.hasFeature("hard-float-abi");
306 bool hasFP64 =
307 Target.hasFeature("fpuv2_df") || Target.hasFeature("fpuv3_df");
308 return createCSKYTargetCodeGenInfo(CGM, IsSoftFloat ? 0
309 : hasFP64 ? 64
310 : 32);
311 }
312 case llvm::Triple::bpfeb:
313 case llvm::Triple::bpfel:
314 return createBPFTargetCodeGenInfo(CGM);
315 case llvm::Triple::loongarch32:
316 case llvm::Triple::loongarch64: {
317 StringRef ABIStr = Target.getABI();
318 unsigned ABIFRLen = 0;
319 if (ABIStr.ends_with("f"))
320 ABIFRLen = 32;
321 else if (ABIStr.ends_with("d"))
322 ABIFRLen = 64;
324 CGM, Target.getPointerWidth(LangAS::Default), ABIFRLen);
325 }
326 }
327}
328
330 if (!TheTargetCodeGenInfo)
331 TheTargetCodeGenInfo = createTargetCodeGenInfo(*this);
332 return *TheTargetCodeGenInfo;
333}
334
336 llvm::LLVMContext &Context,
337 const LangOptions &Opts) {
338#ifndef NDEBUG
339 // Don't verify non-standard ABI configurations.
340 if (Opts.AlignDouble || Opts.OpenCL || Opts.HLSL)
341 return;
342
343 llvm::Triple Triple = Target.getTriple();
344 llvm::DataLayout DL(Target.getDataLayoutString());
345 auto Check = [&](const char *Name, llvm::Type *Ty, unsigned Alignment) {
346 llvm::Align DLAlign = DL.getABITypeAlign(Ty);
347 llvm::Align ClangAlign(Alignment / 8);
348 if (DLAlign != ClangAlign) {
349 llvm::errs() << "For target " << Triple.str() << " type " << Name
350 << " mapping to " << *Ty << " has data layout alignment "
351 << DLAlign.value() << " while clang specifies "
352 << ClangAlign.value() << "\n";
353 abort();
354 }
355 };
356
357 Check("bool", llvm::Type::getIntNTy(Context, Target.BoolWidth),
358 Target.BoolAlign);
359 Check("short", llvm::Type::getIntNTy(Context, Target.ShortWidth),
360 Target.ShortAlign);
361 Check("int", llvm::Type::getIntNTy(Context, Target.IntWidth),
362 Target.IntAlign);
363 Check("long", llvm::Type::getIntNTy(Context, Target.LongWidth),
364 Target.LongAlign);
365 // FIXME: M68k specifies incorrect long long alignment in both LLVM and Clang.
366 if (Triple.getArch() != llvm::Triple::m68k)
367 Check("long long", llvm::Type::getIntNTy(Context, Target.LongLongWidth),
368 Target.LongLongAlign);
369 // FIXME: There are int128 alignment mismatches on multiple targets.
370 if (Target.hasInt128Type() && !Target.getTargetOpts().ForceEnableInt128 &&
371 !Triple.isAMDGPU() && !Triple.isSPIRV() &&
372 Triple.getArch() != llvm::Triple::ve)
373 Check("__int128", llvm::Type::getIntNTy(Context, 128), Target.Int128Align);
374
375 if (Target.hasFloat16Type())
376 Check("half", llvm::Type::getFloatingPointTy(Context, *Target.HalfFormat),
377 Target.HalfAlign);
378 if (Target.hasBFloat16Type())
379 Check("bfloat", llvm::Type::getBFloatTy(Context), Target.BFloat16Align);
380 Check("float", llvm::Type::getFloatingPointTy(Context, *Target.FloatFormat),
381 Target.FloatAlign);
382 // FIXME: AIX specifies wrong double alignment in DataLayout
383 if (!Triple.isOSAIX()) {
384 Check("double",
385 llvm::Type::getFloatingPointTy(Context, *Target.DoubleFormat),
386 Target.DoubleAlign);
387 Check("long double",
388 llvm::Type::getFloatingPointTy(Context, *Target.LongDoubleFormat),
389 Target.LongDoubleAlign);
390 }
391 if (Target.hasFloat128Type())
392 Check("__float128", llvm::Type::getFP128Ty(Context), Target.Float128Align);
393 if (Target.hasIbm128Type())
394 Check("__ibm128", llvm::Type::getPPC_FP128Ty(Context), Target.Ibm128Align);
395
396 Check("void*", llvm::PointerType::getUnqual(Context), Target.PointerAlign);
397#endif
398}
399
400CodeGenModule::CodeGenModule(ASTContext &C,
402 const HeaderSearchOptions &HSO,
403 const PreprocessorOptions &PPO,
404 const CodeGenOptions &CGO, llvm::Module &M,
405 DiagnosticsEngine &diags,
406 CoverageSourceInfo *CoverageInfo)
407 : Context(C), LangOpts(C.getLangOpts()), FS(FS), HeaderSearchOpts(HSO),
408 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
409 Target(C.getTargetInfo()), ABI(createCXXABI(*this)),
410 VMContext(M.getContext()), VTables(*this), StackHandler(diags),
411 SanitizerMD(new SanitizerMetadata(*this)),
412 AtomicOpts(Target.getAtomicOpts()) {
413
414 // Initialize the type cache.
415 Types.reset(new CodeGenTypes(*this));
416 llvm::LLVMContext &LLVMContext = M.getContext();
417 VoidTy = llvm::Type::getVoidTy(LLVMContext);
418 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
419 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
420 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
421 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
422 HalfTy = llvm::Type::getHalfTy(LLVMContext);
423 BFloatTy = llvm::Type::getBFloatTy(LLVMContext);
424 FloatTy = llvm::Type::getFloatTy(LLVMContext);
425 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
426 PointerWidthInBits = C.getTargetInfo().getPointerWidth(LangAS::Default);
428 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(LangAS::Default))
429 .getQuantity();
431 C.toCharUnitsFromBits(C.getTargetInfo().getMaxPointerWidth()).getQuantity();
433 C.toCharUnitsFromBits(C.getTargetInfo().getIntAlign()).getQuantity();
434 CharTy =
435 llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getCharWidth());
436 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
437 IntPtrTy = llvm::IntegerType::get(LLVMContext,
438 C.getTargetInfo().getMaxPointerWidth());
439 Int8PtrTy = llvm::PointerType::get(LLVMContext,
440 C.getTargetAddressSpace(LangAS::Default));
441 const llvm::DataLayout &DL = M.getDataLayout();
443 llvm::PointerType::get(LLVMContext, DL.getAllocaAddrSpace());
445 llvm::PointerType::get(LLVMContext, DL.getDefaultGlobalsAddressSpace());
446 ConstGlobalsPtrTy = llvm::PointerType::get(
447 LLVMContext, C.getTargetAddressSpace(GetGlobalConstantAddressSpace()));
449
450 // Build C++20 Module initializers.
451 // TODO: Add Microsoft here once we know the mangling required for the
452 // initializers.
453 CXX20ModuleInits =
454 LangOpts.CPlusPlusModules && getCXXABI().getMangleContext().getKind() ==
456
457 RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
458
459 if (LangOpts.ObjC)
460 createObjCRuntime();
461 if (LangOpts.OpenCL)
462 createOpenCLRuntime();
463 if (LangOpts.OpenMP)
464 createOpenMPRuntime();
465 if (LangOpts.CUDA)
466 createCUDARuntime();
467 if (LangOpts.HLSL)
468 createHLSLRuntime();
469
470 // Enable TBAA unless it's suppressed. TSan and TySan need TBAA even at O0.
471 if (LangOpts.Sanitize.hasOneOf(SanitizerKind::Thread | SanitizerKind::Type) ||
472 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
473 TBAA.reset(new CodeGenTBAA(Context, getTypes(), TheModule, CodeGenOpts,
474 getLangOpts()));
475
476 // If debug info or coverage generation is enabled, create the CGDebugInfo
477 // object.
478 if (CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo ||
479 CodeGenOpts.CoverageNotesFile.size() ||
480 CodeGenOpts.CoverageDataFile.size())
481 DebugInfo.reset(new CGDebugInfo(*this));
482 else if (getTriple().isOSWindows())
483 // On Windows targets, we want to emit compiler info even if debug info is
484 // otherwise disabled. Use a temporary CGDebugInfo instance to emit only
485 // basic compiler metadata.
486 CGDebugInfo(*this);
487
488 Block.GlobalUniqueCount = 0;
489
490 if (C.getLangOpts().ObjC)
491 ObjCData.reset(new ObjCEntrypoints());
492
493 if (CodeGenOpts.hasProfileClangUse()) {
494 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
495 CodeGenOpts.ProfileInstrumentUsePath, *FS,
496 CodeGenOpts.ProfileRemappingFile);
497 if (auto E = ReaderOrErr.takeError()) {
498 unsigned DiagID = Diags.getCustomDiagID(
499 DiagnosticsEngine::Error, "Error in reading profile %0: %1");
500 llvm::handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EI) {
501 Diags.Report(DiagID)
502 << CodeGenOpts.ProfileInstrumentUsePath << EI.message();
503 });
504 return;
505 }
506 PGOReader = std::move(ReaderOrErr.get());
507 }
508
509 // If coverage mapping generation is enabled, create the
510 // CoverageMappingModuleGen object.
511 if (CodeGenOpts.CoverageMapping)
512 CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo));
513
514 // Generate the module name hash here if needed.
515 if (CodeGenOpts.UniqueInternalLinkageNames &&
516 !getModule().getSourceFileName().empty()) {
517 std::string Path = getModule().getSourceFileName();
518 // Check if a path substitution is needed from the MacroPrefixMap.
519 for (const auto &Entry : LangOpts.MacroPrefixMap)
520 if (Path.rfind(Entry.first, 0) != std::string::npos) {
521 Path = Entry.second + Path.substr(Entry.first.size());
522 break;
523 }
524 ModuleNameHash = llvm::getUniqueInternalLinkagePostfix(Path);
525 }
526
527 // Record mregparm value now so it is visible through all of codegen.
528 if (Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
529 getModule().addModuleFlag(llvm::Module::Error, "NumRegisterParameters",
530 CodeGenOpts.NumRegisterParameters);
531
532 // If there are any functions that are marked for Windows secure hot-patching,
533 // then build the list of functions now.
534 if (!CGO.MSSecureHotPatchFunctionsFile.empty() ||
535 !CGO.MSSecureHotPatchFunctionsList.empty()) {
536 if (!CGO.MSSecureHotPatchFunctionsFile.empty()) {
537 auto BufOrErr = FS->getBufferForFile(CGO.MSSecureHotPatchFunctionsFile);
538 if (BufOrErr) {
539 const llvm::MemoryBuffer &FileBuffer = **BufOrErr;
540 for (llvm::line_iterator I(FileBuffer.getMemBufferRef(), true), E;
541 I != E; ++I)
542 this->MSHotPatchFunctions.push_back(std::string{*I});
543 } else {
544 auto &DE = Context.getDiagnostics();
545 unsigned DiagID =
546 DE.getCustomDiagID(DiagnosticsEngine::Error,
547 "failed to open hotpatch functions file "
548 "(-fms-hotpatch-functions-file): %0 : %1");
549 DE.Report(DiagID) << CGO.MSSecureHotPatchFunctionsFile
550 << BufOrErr.getError().message();
551 }
552 }
553
554 for (const auto &FuncName : CGO.MSSecureHotPatchFunctionsList)
555 this->MSHotPatchFunctions.push_back(FuncName);
556
557 llvm::sort(this->MSHotPatchFunctions);
558 }
559
560 if (!Context.getAuxTargetInfo())
561 checkDataLayoutConsistency(Context.getTargetInfo(), LLVMContext, LangOpts);
562}
563
565
566void CodeGenModule::createObjCRuntime() {
567 // This is just isGNUFamily(), but we want to force implementors of
568 // new ABIs to decide how best to do this.
569 switch (LangOpts.ObjCRuntime.getKind()) {
571 case ObjCRuntime::GCC:
573 ObjCRuntime.reset(CreateGNUObjCRuntime(*this));
574 return;
575
578 case ObjCRuntime::iOS:
580 ObjCRuntime.reset(CreateMacObjCRuntime(*this));
581 return;
582 }
583 llvm_unreachable("bad runtime kind");
584}
585
586void CodeGenModule::createOpenCLRuntime() {
587 OpenCLRuntime.reset(new CGOpenCLRuntime(*this));
588}
589
590void CodeGenModule::createOpenMPRuntime() {
591 if (!LangOpts.OMPHostIRFile.empty() && !FS->exists(LangOpts.OMPHostIRFile))
592 Diags.Report(diag::err_omp_host_ir_file_not_found)
593 << LangOpts.OMPHostIRFile;
594
595 // Select a specialized code generation class based on the target, if any.
596 // If it does not exist use the default implementation.
597 switch (getTriple().getArch()) {
598 case llvm::Triple::nvptx:
599 case llvm::Triple::nvptx64:
600 case llvm::Triple::amdgcn:
601 case llvm::Triple::spirv64:
602 assert(
603 getLangOpts().OpenMPIsTargetDevice &&
604 "OpenMP AMDGPU/NVPTX/SPIRV is only prepared to deal with device code.");
605 OpenMPRuntime.reset(new CGOpenMPRuntimeGPU(*this));
606 break;
607 default:
608 if (LangOpts.OpenMPSimd)
609 OpenMPRuntime.reset(new CGOpenMPSIMDRuntime(*this));
610 else
611 OpenMPRuntime.reset(new CGOpenMPRuntime(*this));
612 break;
613 }
614}
615
616void CodeGenModule::createCUDARuntime() {
617 CUDARuntime.reset(CreateNVCUDARuntime(*this));
618}
619
620void CodeGenModule::createHLSLRuntime() {
621 HLSLRuntime.reset(new CGHLSLRuntime(*this));
622}
623
624void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) {
625 Replacements[Name] = C;
626}
627
628void CodeGenModule::applyReplacements() {
629 for (auto &I : Replacements) {
630 StringRef MangledName = I.first;
631 llvm::Constant *Replacement = I.second;
632 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
633 if (!Entry)
634 continue;
635 auto *OldF = cast<llvm::Function>(Entry);
636 auto *NewF = dyn_cast<llvm::Function>(Replacement);
637 if (!NewF) {
638 if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
639 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
640 } else {
641 auto *CE = cast<llvm::ConstantExpr>(Replacement);
642 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
643 CE->getOpcode() == llvm::Instruction::GetElementPtr);
644 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
645 }
646 }
647
648 // Replace old with new, but keep the old order.
649 OldF->replaceAllUsesWith(Replacement);
650 if (NewF) {
651 NewF->removeFromParent();
652 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
653 NewF);
654 }
655 OldF->eraseFromParent();
656 }
657}
658
659void CodeGenModule::addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C) {
660 GlobalValReplacements.push_back(std::make_pair(GV, C));
661}
662
663void CodeGenModule::applyGlobalValReplacements() {
664 for (auto &I : GlobalValReplacements) {
665 llvm::GlobalValue *GV = I.first;
666 llvm::Constant *C = I.second;
667
668 GV->replaceAllUsesWith(C);
669 GV->eraseFromParent();
670 }
671}
672
673// This is only used in aliases that we created and we know they have a
674// linear structure.
675static const llvm::GlobalValue *getAliasedGlobal(const llvm::GlobalValue *GV) {
676 const llvm::Constant *C;
677 if (auto *GA = dyn_cast<llvm::GlobalAlias>(GV))
678 C = GA->getAliasee();
679 else if (auto *GI = dyn_cast<llvm::GlobalIFunc>(GV))
680 C = GI->getResolver();
681 else
682 return GV;
683
684 const auto *AliaseeGV = dyn_cast<llvm::GlobalValue>(C->stripPointerCasts());
685 if (!AliaseeGV)
686 return nullptr;
687
688 const llvm::GlobalValue *FinalGV = AliaseeGV->getAliaseeObject();
689 if (FinalGV == GV)
690 return nullptr;
691
692 return FinalGV;
693}
694
696 const ASTContext &Context, DiagnosticsEngine &Diags, SourceLocation Location,
697 bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV,
698 const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames,
699 SourceRange AliasRange) {
700 GV = getAliasedGlobal(Alias);
701 if (!GV) {
702 Diags.Report(Location, diag::err_cyclic_alias) << IsIFunc;
703 return false;
704 }
705
706 if (GV->hasCommonLinkage()) {
707 const llvm::Triple &Triple = Context.getTargetInfo().getTriple();
708 if (Triple.getObjectFormat() == llvm::Triple::XCOFF) {
709 Diags.Report(Location, diag::err_alias_to_common);
710 return false;
711 }
712 }
713
714 if (GV->isDeclaration()) {
715 Diags.Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;
716 Diags.Report(Location, diag::note_alias_requires_mangled_name)
717 << IsIFunc << IsIFunc;
718 // Provide a note if the given function is not found and exists as a
719 // mangled name.
720 for (const auto &[Decl, Name] : MangledDeclNames) {
721 if (const auto *ND = dyn_cast<NamedDecl>(Decl.getDecl())) {
722 IdentifierInfo *II = ND->getIdentifier();
723 if (II && II->getName() == GV->getName()) {
724 Diags.Report(Location, diag::note_alias_mangled_name_alternative)
725 << Name
727 AliasRange,
728 (Twine(IsIFunc ? "ifunc" : "alias") + "(\"" + Name + "\")")
729 .str());
730 }
731 }
732 }
733 return false;
734 }
735
736 if (IsIFunc) {
737 // Check resolver function type.
738 const auto *F = dyn_cast<llvm::Function>(GV);
739 if (!F) {
740 Diags.Report(Location, diag::err_alias_to_undefined)
741 << IsIFunc << IsIFunc;
742 return false;
743 }
744
745 llvm::FunctionType *FTy = F->getFunctionType();
746 if (!FTy->getReturnType()->isPointerTy()) {
747 Diags.Report(Location, diag::err_ifunc_resolver_return);
748 return false;
749 }
750 }
751
752 return true;
753}
754
755// Emit a warning if toc-data attribute is requested for global variables that
756// have aliases and remove the toc-data attribute.
757static void checkAliasForTocData(llvm::GlobalVariable *GVar,
758 const CodeGenOptions &CodeGenOpts,
759 DiagnosticsEngine &Diags,
760 SourceLocation Location) {
761 if (GVar->hasAttribute("toc-data")) {
762 auto GVId = GVar->getName();
763 // Is this a global variable specified by the user as local?
764 if ((llvm::binary_search(CodeGenOpts.TocDataVarsUserSpecified, GVId))) {
765 Diags.Report(Location, diag::warn_toc_unsupported_type)
766 << GVId << "the variable has an alias";
767 }
768 llvm::AttributeSet CurrAttributes = GVar->getAttributes();
769 llvm::AttributeSet NewAttributes =
770 CurrAttributes.removeAttribute(GVar->getContext(), "toc-data");
771 GVar->setAttributes(NewAttributes);
772 }
773}
774
775void CodeGenModule::checkAliases() {
776 // Check if the constructed aliases are well formed. It is really unfortunate
777 // that we have to do this in CodeGen, but we only construct mangled names
778 // and aliases during codegen.
779 bool Error = false;
780 DiagnosticsEngine &Diags = getDiags();
781 for (const GlobalDecl &GD : Aliases) {
782 const auto *D = cast<ValueDecl>(GD.getDecl());
783 SourceLocation Location;
784 SourceRange Range;
785 bool IsIFunc = D->hasAttr<IFuncAttr>();
786 if (const Attr *A = D->getDefiningAttr()) {
787 Location = A->getLocation();
788 Range = A->getRange();
789 } else
790 llvm_unreachable("Not an alias or ifunc?");
791
792 StringRef MangledName = getMangledName(GD);
793 llvm::GlobalValue *Alias = GetGlobalValue(MangledName);
794 const llvm::GlobalValue *GV = nullptr;
795 if (!checkAliasedGlobal(getContext(), Diags, Location, IsIFunc, Alias, GV,
796 MangledDeclNames, Range)) {
797 Error = true;
798 continue;
799 }
800
801 if (getContext().getTargetInfo().getTriple().isOSAIX())
802 if (const llvm::GlobalVariable *GVar =
803 dyn_cast<const llvm::GlobalVariable>(GV))
804 checkAliasForTocData(const_cast<llvm::GlobalVariable *>(GVar),
805 getCodeGenOpts(), Diags, Location);
806
807 llvm::Constant *Aliasee =
808 IsIFunc ? cast<llvm::GlobalIFunc>(Alias)->getResolver()
809 : cast<llvm::GlobalAlias>(Alias)->getAliasee();
810
811 llvm::GlobalValue *AliaseeGV;
812 if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
813 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
814 else
815 AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
816
817 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
818 StringRef AliasSection = SA->getName();
819 if (AliasSection != AliaseeGV->getSection())
820 Diags.Report(SA->getLocation(), diag::warn_alias_with_section)
821 << AliasSection << IsIFunc << IsIFunc;
822 }
823
824 // We have to handle alias to weak aliases in here. LLVM itself disallows
825 // this since the object semantics would not match the IL one. For
826 // compatibility with gcc we implement it by just pointing the alias
827 // to its aliasee's aliasee. We also warn, since the user is probably
828 // expecting the link to be weak.
829 if (auto *GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {
830 if (GA->isInterposable()) {
831 Diags.Report(Location, diag::warn_alias_to_weak_alias)
832 << GV->getName() << GA->getName() << IsIFunc;
833 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
834 GA->getAliasee(), Alias->getType());
835
836 if (IsIFunc)
837 cast<llvm::GlobalIFunc>(Alias)->setResolver(Aliasee);
838 else
839 cast<llvm::GlobalAlias>(Alias)->setAliasee(Aliasee);
840 }
841 }
842 // ifunc resolvers are usually implemented to run before sanitizer
843 // initialization. Disable instrumentation to prevent the ordering issue.
844 if (IsIFunc)
845 cast<llvm::Function>(Aliasee)->addFnAttr(
846 llvm::Attribute::DisableSanitizerInstrumentation);
847 }
848 if (!Error)
849 return;
850
851 for (const GlobalDecl &GD : Aliases) {
852 StringRef MangledName = getMangledName(GD);
853 llvm::GlobalValue *Alias = GetGlobalValue(MangledName);
854 Alias->replaceAllUsesWith(llvm::PoisonValue::get(Alias->getType()));
855 Alias->eraseFromParent();
856 }
857}
858
860 DeferredDeclsToEmit.clear();
861 EmittedDeferredDecls.clear();
862 DeferredAnnotations.clear();
863 if (OpenMPRuntime)
864 OpenMPRuntime->clear();
865}
866
868 StringRef MainFile) {
869 if (!hasDiagnostics())
870 return;
871 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
872 if (MainFile.empty())
873 MainFile = "<stdin>";
874 Diags.Report(diag::warn_profile_data_unprofiled) << MainFile;
875 } else {
876 if (Mismatched > 0)
877 Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
878
879 if (Missing > 0)
880 Diags.Report(diag::warn_profile_data_missing) << Visited << Missing;
881 }
882}
883
884static std::optional<llvm::GlobalValue::VisibilityTypes>
886 // Map to LLVM visibility.
887 switch (K) {
889 return std::nullopt;
891 return llvm::GlobalValue::DefaultVisibility;
893 return llvm::GlobalValue::HiddenVisibility;
895 return llvm::GlobalValue::ProtectedVisibility;
896 }
897 llvm_unreachable("unknown option value!");
898}
899
900static void
901setLLVMVisibility(llvm::GlobalValue &GV,
902 std::optional<llvm::GlobalValue::VisibilityTypes> V) {
903 if (!V)
904 return;
905
906 // Reset DSO locality before setting the visibility. This removes
907 // any effects that visibility options and annotations may have
908 // had on the DSO locality. Setting the visibility will implicitly set
909 // appropriate globals to DSO Local; however, this will be pessimistic
910 // w.r.t. to the normal compiler IRGen.
911 GV.setDSOLocal(false);
912 GV.setVisibility(*V);
913}
914
916 llvm::Module &M) {
917 if (!LO.VisibilityFromDLLStorageClass)
918 return;
919
920 std::optional<llvm::GlobalValue::VisibilityTypes> DLLExportVisibility =
921 getLLVMVisibility(LO.getDLLExportVisibility());
922
923 std::optional<llvm::GlobalValue::VisibilityTypes>
924 NoDLLStorageClassVisibility =
925 getLLVMVisibility(LO.getNoDLLStorageClassVisibility());
926
927 std::optional<llvm::GlobalValue::VisibilityTypes>
928 ExternDeclDLLImportVisibility =
929 getLLVMVisibility(LO.getExternDeclDLLImportVisibility());
930
931 std::optional<llvm::GlobalValue::VisibilityTypes>
932 ExternDeclNoDLLStorageClassVisibility =
933 getLLVMVisibility(LO.getExternDeclNoDLLStorageClassVisibility());
934
935 for (llvm::GlobalValue &GV : M.global_values()) {
936 if (GV.hasAppendingLinkage() || GV.hasLocalLinkage())
937 continue;
938
939 if (GV.isDeclarationForLinker())
940 setLLVMVisibility(GV, GV.getDLLStorageClass() ==
941 llvm::GlobalValue::DLLImportStorageClass
942 ? ExternDeclDLLImportVisibility
943 : ExternDeclNoDLLStorageClassVisibility);
944 else
945 setLLVMVisibility(GV, GV.getDLLStorageClass() ==
946 llvm::GlobalValue::DLLExportStorageClass
947 ? DLLExportVisibility
948 : NoDLLStorageClassVisibility);
949
950 GV.setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
951 }
952}
953
954static bool isStackProtectorOn(const LangOptions &LangOpts,
955 const llvm::Triple &Triple,
957 if (Triple.isGPU())
958 return false;
959 return LangOpts.getStackProtector() == Mode;
960}
961
964 if (CXX20ModuleInits && Primary && !Primary->isHeaderLikeModule())
965 EmitModuleInitializers(Primary);
966 EmitDeferred();
967 DeferredDecls.insert_range(EmittedDeferredDecls);
968 EmittedDeferredDecls.clear();
969 EmitVTablesOpportunistically();
970 applyGlobalValReplacements();
971 applyReplacements();
972 emitMultiVersionFunctions();
973
974 if (Context.getLangOpts().IncrementalExtensions &&
975 GlobalTopLevelStmtBlockInFlight.first) {
976 const TopLevelStmtDecl *TLSD = GlobalTopLevelStmtBlockInFlight.second;
977 GlobalTopLevelStmtBlockInFlight.first->FinishFunction(TLSD->getEndLoc());
978 GlobalTopLevelStmtBlockInFlight = {nullptr, nullptr};
979 }
980
981 // Module implementations are initialized the same way as a regular TU that
982 // imports one or more modules.
983 if (CXX20ModuleInits && Primary && Primary->isInterfaceOrPartition())
984 EmitCXXModuleInitFunc(Primary);
985 else
986 EmitCXXGlobalInitFunc();
987 EmitCXXGlobalCleanUpFunc();
988 registerGlobalDtorsWithAtExit();
989 EmitCXXThreadLocalInitFunc();
990 if (ObjCRuntime)
991 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
992 AddGlobalCtor(ObjCInitFunction);
993 if (Context.getLangOpts().CUDA && CUDARuntime) {
994 if (llvm::Function *CudaCtorFunction = CUDARuntime->finalizeModule())
995 AddGlobalCtor(CudaCtorFunction);
996 }
997 if (OpenMPRuntime) {
998 OpenMPRuntime->createOffloadEntriesAndInfoMetadata();
999 OpenMPRuntime->clear();
1000 }
1001 if (PGOReader) {
1002 getModule().setProfileSummary(
1003 PGOReader->getSummary(/* UseCS */ false).getMD(VMContext),
1004 llvm::ProfileSummary::PSK_Instr);
1005 if (PGOStats.hasDiagnostics())
1006 PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName);
1007 }
1008 llvm::stable_sort(GlobalCtors, [](const Structor &L, const Structor &R) {
1009 return L.LexOrder < R.LexOrder;
1010 });
1011 EmitCtorList(GlobalCtors, "llvm.global_ctors");
1012 EmitCtorList(GlobalDtors, "llvm.global_dtors");
1014 EmitStaticExternCAliases();
1015 checkAliases();
1019 if (CoverageMapping)
1020 CoverageMapping->emit();
1021 if (CodeGenOpts.SanitizeCfiCrossDso) {
1024 }
1025 if (LangOpts.Sanitize.has(SanitizerKind::KCFI))
1027 emitAtAvailableLinkGuard();
1028 if (Context.getTargetInfo().getTriple().isWasm())
1030
1031 if (getTriple().isAMDGPU() ||
1032 (getTriple().isSPIRV() && getTriple().getVendor() == llvm::Triple::AMD)) {
1033 // Emit amdhsa_code_object_version module flag, which is code object version
1034 // times 100.
1035 if (getTarget().getTargetOpts().CodeObjectVersion !=
1036 llvm::CodeObjectVersionKind::COV_None) {
1037 getModule().addModuleFlag(llvm::Module::Error,
1038 "amdhsa_code_object_version",
1039 getTarget().getTargetOpts().CodeObjectVersion);
1040 }
1041
1042 // Currently, "-mprintf-kind" option is only supported for HIP
1043 if (LangOpts.HIP) {
1044 auto *MDStr = llvm::MDString::get(
1045 getLLVMContext(), (getTarget().getTargetOpts().AMDGPUPrintfKindVal ==
1047 ? "hostcall"
1048 : "buffered");
1049 getModule().addModuleFlag(llvm::Module::Error, "amdgpu_printf_kind",
1050 MDStr);
1051 }
1052 }
1053
1054 // Emit a global array containing all external kernels or device variables
1055 // used by host functions and mark it as used for CUDA/HIP. This is necessary
1056 // to get kernels or device variables in archives linked in even if these
1057 // kernels or device variables are only used in host functions.
1058 if (!Context.CUDAExternalDeviceDeclODRUsedByHost.empty()) {
1060 for (auto D : Context.CUDAExternalDeviceDeclODRUsedByHost) {
1061 GlobalDecl GD;
1062 if (auto *FD = dyn_cast<FunctionDecl>(D))
1064 else
1065 GD = GlobalDecl(D);
1066 UsedArray.push_back(llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
1068 }
1069
1070 llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size());
1071
1072 auto *GV = new llvm::GlobalVariable(
1073 getModule(), ATy, false, llvm::GlobalValue::InternalLinkage,
1074 llvm::ConstantArray::get(ATy, UsedArray), "__clang_gpu_used_external");
1076 }
1077 if (LangOpts.HIP) {
1078 // Emit a unique ID so that host and device binaries from the same
1079 // compilation unit can be associated.
1080 auto *GV = new llvm::GlobalVariable(
1081 getModule(), Int8Ty, false, llvm::GlobalValue::ExternalLinkage,
1082 llvm::Constant::getNullValue(Int8Ty),
1083 "__hip_cuid_" + getContext().getCUIDHash());
1086 }
1087 emitLLVMUsed();
1088 if (SanStats)
1089 SanStats->finish();
1090
1091 if (CodeGenOpts.Autolink &&
1092 (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
1093 EmitModuleLinkOptions();
1094 }
1095
1096 // On ELF we pass the dependent library specifiers directly to the linker
1097 // without manipulating them. This is in contrast to other platforms where
1098 // they are mapped to a specific linker option by the compiler. This
1099 // difference is a result of the greater variety of ELF linkers and the fact
1100 // that ELF linkers tend to handle libraries in a more complicated fashion
1101 // than on other platforms. This forces us to defer handling the dependent
1102 // libs to the linker.
1103 //
1104 // CUDA/HIP device and host libraries are different. Currently there is no
1105 // way to differentiate dependent libraries for host or device. Existing
1106 // usage of #pragma comment(lib, *) is intended for host libraries on
1107 // Windows. Therefore emit llvm.dependent-libraries only for host.
1108 if (!ELFDependentLibraries.empty() && !Context.getLangOpts().CUDAIsDevice) {
1109 auto *NMD = getModule().getOrInsertNamedMetadata("llvm.dependent-libraries");
1110 for (auto *MD : ELFDependentLibraries)
1111 NMD->addOperand(MD);
1112 }
1113
1114 if (CodeGenOpts.DwarfVersion) {
1115 getModule().addModuleFlag(llvm::Module::Max, "Dwarf Version",
1116 CodeGenOpts.DwarfVersion);
1117 }
1118
1119 if (CodeGenOpts.Dwarf64)
1120 getModule().addModuleFlag(llvm::Module::Max, "DWARF64", 1);
1121
1122 if (Context.getLangOpts().SemanticInterposition)
1123 // Require various optimization to respect semantic interposition.
1124 getModule().setSemanticInterposition(true);
1125
1126 if (CodeGenOpts.EmitCodeView) {
1127 // Indicate that we want CodeView in the metadata.
1128 getModule().addModuleFlag(llvm::Module::Warning, "CodeView", 1);
1129 }
1130 if (CodeGenOpts.CodeViewGHash) {
1131 getModule().addModuleFlag(llvm::Module::Warning, "CodeViewGHash", 1);
1132 }
1133 if (CodeGenOpts.ControlFlowGuard) {
1134 // Function ID tables and checks for Control Flow Guard (cfguard=2).
1135 getModule().addModuleFlag(llvm::Module::Warning, "cfguard", 2);
1136 } else if (CodeGenOpts.ControlFlowGuardNoChecks) {
1137 // Function ID tables for Control Flow Guard (cfguard=1).
1138 getModule().addModuleFlag(llvm::Module::Warning, "cfguard", 1);
1139 }
1140 if (CodeGenOpts.EHContGuard) {
1141 // Function ID tables for EH Continuation Guard.
1142 getModule().addModuleFlag(llvm::Module::Warning, "ehcontguard", 1);
1143 }
1144 if (Context.getLangOpts().Kernel) {
1145 // Note if we are compiling with /kernel.
1146 getModule().addModuleFlag(llvm::Module::Warning, "ms-kernel", 1);
1147 }
1148 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
1149 // We don't support LTO with 2 with different StrictVTablePointers
1150 // FIXME: we could support it by stripping all the information introduced
1151 // by StrictVTablePointers.
1152
1153 getModule().addModuleFlag(llvm::Module::Error, "StrictVTablePointers",1);
1154
1155 llvm::Metadata *Ops[2] = {
1156 llvm::MDString::get(VMContext, "StrictVTablePointers"),
1157 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1158 llvm::Type::getInt32Ty(VMContext), 1))};
1159
1160 getModule().addModuleFlag(llvm::Module::Require,
1161 "StrictVTablePointersRequirement",
1162 llvm::MDNode::get(VMContext, Ops));
1163 }
1164 if (getModuleDebugInfo() || getTriple().isOSWindows())
1165 // We support a single version in the linked module. The LLVM
1166 // parser will drop debug info with a different version number
1167 // (and warn about it, too).
1168 getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version",
1169 llvm::DEBUG_METADATA_VERSION);
1170
1171 // We need to record the widths of enums and wchar_t, so that we can generate
1172 // the correct build attributes in the ARM backend. wchar_size is also used by
1173 // TargetLibraryInfo.
1174 uint64_t WCharWidth =
1175 Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
1176 getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
1177
1178 if (getTriple().isOSzOS()) {
1179 getModule().addModuleFlag(llvm::Module::Warning,
1180 "zos_product_major_version",
1181 uint32_t(CLANG_VERSION_MAJOR));
1182 getModule().addModuleFlag(llvm::Module::Warning,
1183 "zos_product_minor_version",
1184 uint32_t(CLANG_VERSION_MINOR));
1185 getModule().addModuleFlag(llvm::Module::Warning, "zos_product_patchlevel",
1186 uint32_t(CLANG_VERSION_PATCHLEVEL));
1187 std::string ProductId = getClangVendor() + "clang";
1188 getModule().addModuleFlag(llvm::Module::Error, "zos_product_id",
1189 llvm::MDString::get(VMContext, ProductId));
1190
1191 // Record the language because we need it for the PPA2.
1192 StringRef lang_str = languageToString(
1193 LangStandard::getLangStandardForKind(LangOpts.LangStd).Language);
1194 getModule().addModuleFlag(llvm::Module::Error, "zos_cu_language",
1195 llvm::MDString::get(VMContext, lang_str));
1196
1197 time_t TT = PreprocessorOpts.SourceDateEpoch
1198 ? *PreprocessorOpts.SourceDateEpoch
1199 : std::time(nullptr);
1200 getModule().addModuleFlag(llvm::Module::Max, "zos_translation_time",
1201 static_cast<uint64_t>(TT));
1202
1203 // Multiple modes will be supported here.
1204 getModule().addModuleFlag(llvm::Module::Error, "zos_le_char_mode",
1205 llvm::MDString::get(VMContext, "ascii"));
1206 }
1207
1208 llvm::Triple T = Context.getTargetInfo().getTriple();
1209 if (T.isARM() || T.isThumb()) {
1210 // The minimum width of an enum in bytes
1211 uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4;
1212 getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
1213 }
1214
1215 if (T.isRISCV()) {
1216 StringRef ABIStr = Target.getABI();
1217 llvm::LLVMContext &Ctx = TheModule.getContext();
1218 getModule().addModuleFlag(llvm::Module::Error, "target-abi",
1219 llvm::MDString::get(Ctx, ABIStr));
1220
1221 // Add the canonical ISA string as metadata so the backend can set the ELF
1222 // attributes correctly. We use AppendUnique so LTO will keep all of the
1223 // unique ISA strings that were linked together.
1224 const std::vector<std::string> &Features =
1226 auto ParseResult =
1227 llvm::RISCVISAInfo::parseFeatures(T.isRISCV64() ? 64 : 32, Features);
1228 if (!errorToBool(ParseResult.takeError()))
1229 getModule().addModuleFlag(
1230 llvm::Module::AppendUnique, "riscv-isa",
1231 llvm::MDNode::get(
1232 Ctx, llvm::MDString::get(Ctx, (*ParseResult)->toString())));
1233 }
1234
1235 if (CodeGenOpts.SanitizeCfiCrossDso) {
1236 // Indicate that we want cross-DSO control flow integrity checks.
1237 getModule().addModuleFlag(llvm::Module::Override, "Cross-DSO CFI", 1);
1238 }
1239
1240 if (CodeGenOpts.WholeProgramVTables) {
1241 // Indicate whether VFE was enabled for this module, so that the
1242 // vcall_visibility metadata added under whole program vtables is handled
1243 // appropriately in the optimizer.
1244 getModule().addModuleFlag(llvm::Module::Error, "Virtual Function Elim",
1245 CodeGenOpts.VirtualFunctionElimination);
1246 }
1247
1248 if (LangOpts.Sanitize.has(SanitizerKind::CFIICall)) {
1249 getModule().addModuleFlag(llvm::Module::Override,
1250 "CFI Canonical Jump Tables",
1251 CodeGenOpts.SanitizeCfiCanonicalJumpTables);
1252 }
1253
1254 if (CodeGenOpts.SanitizeCfiICallNormalizeIntegers) {
1255 getModule().addModuleFlag(llvm::Module::Override, "cfi-normalize-integers",
1256 1);
1257 }
1258
1259 if (!CodeGenOpts.UniqueSourceFileIdentifier.empty()) {
1260 getModule().addModuleFlag(
1261 llvm::Module::Append, "Unique Source File Identifier",
1262 llvm::MDTuple::get(
1263 TheModule.getContext(),
1264 llvm::MDString::get(TheModule.getContext(),
1265 CodeGenOpts.UniqueSourceFileIdentifier)));
1266 }
1267
1268 if (LangOpts.Sanitize.has(SanitizerKind::KCFI)) {
1269 getModule().addModuleFlag(llvm::Module::Override, "kcfi", 1);
1270 // KCFI assumes patchable-function-prefix is the same for all indirectly
1271 // called functions. Store the expected offset for code generation.
1272 if (CodeGenOpts.PatchableFunctionEntryOffset)
1273 getModule().addModuleFlag(llvm::Module::Override, "kcfi-offset",
1274 CodeGenOpts.PatchableFunctionEntryOffset);
1275 if (CodeGenOpts.SanitizeKcfiArity)
1276 getModule().addModuleFlag(llvm::Module::Override, "kcfi-arity", 1);
1277 }
1278
1279 if (CodeGenOpts.CFProtectionReturn &&
1280 Target.checkCFProtectionReturnSupported(getDiags())) {
1281 // Indicate that we want to instrument return control flow protection.
1282 getModule().addModuleFlag(llvm::Module::Min, "cf-protection-return",
1283 1);
1284 }
1285
1286 if (CodeGenOpts.CFProtectionBranch &&
1287 Target.checkCFProtectionBranchSupported(getDiags())) {
1288 // Indicate that we want to instrument branch control flow protection.
1289 getModule().addModuleFlag(llvm::Module::Min, "cf-protection-branch",
1290 1);
1291
1292 auto Scheme = CodeGenOpts.getCFBranchLabelScheme();
1293 if (Target.checkCFBranchLabelSchemeSupported(Scheme, getDiags())) {
1295 Scheme = Target.getDefaultCFBranchLabelScheme();
1296 getModule().addModuleFlag(
1297 llvm::Module::Error, "cf-branch-label-scheme",
1298 llvm::MDString::get(getLLVMContext(),
1300 }
1301 }
1302
1303 if (CodeGenOpts.FunctionReturnThunks)
1304 getModule().addModuleFlag(llvm::Module::Override, "function_return_thunk_extern", 1);
1305
1306 if (CodeGenOpts.IndirectBranchCSPrefix)
1307 getModule().addModuleFlag(llvm::Module::Override, "indirect_branch_cs_prefix", 1);
1308
1309 // Add module metadata for return address signing (ignoring
1310 // non-leaf/all) and stack tagging. These are actually turned on by function
1311 // attributes, but we use module metadata to emit build attributes. This is
1312 // needed for LTO, where the function attributes are inside bitcode
1313 // serialised into a global variable by the time build attributes are
1314 // emitted, so we can't access them. LTO objects could be compiled with
1315 // different flags therefore module flags are set to "Min" behavior to achieve
1316 // the same end result of the normal build where e.g BTI is off if any object
1317 // doesn't support it.
1318 if (Context.getTargetInfo().hasFeature("ptrauth") &&
1319 LangOpts.getSignReturnAddressScope() !=
1321 getModule().addModuleFlag(llvm::Module::Override,
1322 "sign-return-address-buildattr", 1);
1323 if (LangOpts.Sanitize.has(SanitizerKind::MemtagStack))
1324 getModule().addModuleFlag(llvm::Module::Override,
1325 "tag-stack-memory-buildattr", 1);
1326
1327 if (T.isARM() || T.isThumb() || T.isAArch64()) {
1328 // Previously 1 is used and meant for the backed to derive the function
1329 // attribute form it. 2 now means function attributes already set for all
1330 // functions in this module, so no need to propagate those from the module
1331 // flag. Value is only used in case of LTO module merge because the backend
1332 // will see all required function attribute set already. Value is used
1333 // before modules got merged. Any posive value means the feature is active
1334 // and required binary markings need to be emit accordingly.
1335 if (LangOpts.BranchTargetEnforcement)
1336 getModule().addModuleFlag(llvm::Module::Min, "branch-target-enforcement",
1337 2);
1338 if (LangOpts.BranchProtectionPAuthLR)
1339 getModule().addModuleFlag(llvm::Module::Min, "branch-protection-pauth-lr",
1340 2);
1341 if (LangOpts.GuardedControlStack)
1342 getModule().addModuleFlag(llvm::Module::Min, "guarded-control-stack", 2);
1343 if (LangOpts.hasSignReturnAddress())
1344 getModule().addModuleFlag(llvm::Module::Min, "sign-return-address", 2);
1345 if (LangOpts.isSignReturnAddressScopeAll())
1346 getModule().addModuleFlag(llvm::Module::Min, "sign-return-address-all",
1347 2);
1348 if (!LangOpts.isSignReturnAddressWithAKey())
1349 getModule().addModuleFlag(llvm::Module::Min,
1350 "sign-return-address-with-bkey", 2);
1351
1352 if (LangOpts.PointerAuthELFGOT)
1353 getModule().addModuleFlag(llvm::Module::Min, "ptrauth-elf-got", 1);
1354
1355 if (getTriple().isOSLinux()) {
1356 if (LangOpts.PointerAuthCalls)
1357 getModule().addModuleFlag(llvm::Module::Min, "ptrauth-sign-personality",
1358 1);
1359 assert(getTriple().isOSBinFormatELF());
1360 using namespace llvm::ELF;
1361 uint64_t PAuthABIVersion =
1362 (LangOpts.PointerAuthIntrinsics
1363 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INTRINSICS) |
1364 (LangOpts.PointerAuthCalls
1365 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_CALLS) |
1366 (LangOpts.PointerAuthReturns
1367 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_RETURNS) |
1368 (LangOpts.PointerAuthAuthTraps
1369 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_AUTHTRAPS) |
1370 (LangOpts.PointerAuthVTPtrAddressDiscrimination
1371 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRADDRDISCR) |
1372 (LangOpts.PointerAuthVTPtrTypeDiscrimination
1373 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRTYPEDISCR) |
1374 (LangOpts.PointerAuthInitFini
1375 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINI) |
1376 (LangOpts.PointerAuthInitFiniAddressDiscrimination
1377 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINIADDRDISC) |
1378 (LangOpts.PointerAuthELFGOT
1379 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_GOT) |
1380 (LangOpts.PointerAuthIndirectGotos
1381 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_GOTOS) |
1382 (LangOpts.PointerAuthTypeInfoVTPtrDiscrimination
1383 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_TYPEINFOVPTRDISCR) |
1384 (LangOpts.PointerAuthFunctionTypeDiscrimination
1385 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_FPTRTYPEDISCR);
1386 static_assert(AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_FPTRTYPEDISCR ==
1387 AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_LAST,
1388 "Update when new enum items are defined");
1389 if (PAuthABIVersion != 0) {
1390 getModule().addModuleFlag(llvm::Module::Error,
1391 "aarch64-elf-pauthabi-platform",
1392 AARCH64_PAUTH_PLATFORM_LLVM_LINUX);
1393 getModule().addModuleFlag(llvm::Module::Error,
1394 "aarch64-elf-pauthabi-version",
1395 PAuthABIVersion);
1396 }
1397 }
1398 }
1399
1400 if (CodeGenOpts.StackClashProtector)
1401 getModule().addModuleFlag(
1402 llvm::Module::Override, "probe-stack",
1403 llvm::MDString::get(TheModule.getContext(), "inline-asm"));
1404
1405 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
1406 getModule().addModuleFlag(llvm::Module::Min, "stack-probe-size",
1407 CodeGenOpts.StackProbeSize);
1408
1409 if (!CodeGenOpts.MemoryProfileOutput.empty()) {
1410 llvm::LLVMContext &Ctx = TheModule.getContext();
1411 getModule().addModuleFlag(
1412 llvm::Module::Error, "MemProfProfileFilename",
1413 llvm::MDString::get(Ctx, CodeGenOpts.MemoryProfileOutput));
1414 }
1415
1416 if (LangOpts.CUDAIsDevice && getTriple().isNVPTX()) {
1417 // Indicate whether __nvvm_reflect should be configured to flush denormal
1418 // floating point values to 0. (This corresponds to its "__CUDA_FTZ"
1419 // property.)
1420 getModule().addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz",
1421 CodeGenOpts.FP32DenormalMode.Output !=
1422 llvm::DenormalMode::IEEE);
1423 }
1424
1425 if (LangOpts.EHAsynch)
1426 getModule().addModuleFlag(llvm::Module::Warning, "eh-asynch", 1);
1427
1428 // Emit Import Call section.
1429 if (CodeGenOpts.ImportCallOptimization)
1430 getModule().addModuleFlag(llvm::Module::Warning, "import-call-optimization",
1431 1);
1432
1433 // Enable unwind v2 (epilog).
1434 if (CodeGenOpts.getWinX64EHUnwindV2() != llvm::WinX64EHUnwindV2Mode::Disabled)
1435 getModule().addModuleFlag(
1436 llvm::Module::Warning, "winx64-eh-unwindv2",
1437 static_cast<unsigned>(CodeGenOpts.getWinX64EHUnwindV2()));
1438
1439 // Indicate whether this Module was compiled with -fopenmp
1440 if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd)
1441 getModule().addModuleFlag(llvm::Module::Max, "openmp", LangOpts.OpenMP);
1442 if (getLangOpts().OpenMPIsTargetDevice)
1443 getModule().addModuleFlag(llvm::Module::Max, "openmp-device",
1444 LangOpts.OpenMP);
1445
1446 // Emit OpenCL specific module metadata: OpenCL/SPIR version.
1447 if (LangOpts.OpenCL || (LangOpts.CUDAIsDevice && getTriple().isSPIRV())) {
1448 EmitOpenCLMetadata();
1449 // Emit SPIR version.
1450 if (getTriple().isSPIR()) {
1451 // SPIR v2.0 s2.12 - The SPIR version used by the module is stored in the
1452 // opencl.spir.version named metadata.
1453 // C++ for OpenCL has a distinct mapping for version compatibility with
1454 // OpenCL.
1455 auto Version = LangOpts.getOpenCLCompatibleVersion();
1456 llvm::Metadata *SPIRVerElts[] = {
1457 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1458 Int32Ty, Version / 100)),
1459 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1460 Int32Ty, (Version / 100 > 1) ? 0 : 2))};
1461 llvm::NamedMDNode *SPIRVerMD =
1462 TheModule.getOrInsertNamedMetadata("opencl.spir.version");
1463 llvm::LLVMContext &Ctx = TheModule.getContext();
1464 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
1465 }
1466 }
1467
1468 // HLSL related end of code gen work items.
1469 if (LangOpts.HLSL)
1471
1472 if (uint32_t PLevel = Context.getLangOpts().PICLevel) {
1473 assert(PLevel < 3 && "Invalid PIC Level");
1474 getModule().setPICLevel(static_cast<llvm::PICLevel::Level>(PLevel));
1475 if (Context.getLangOpts().PIE)
1476 getModule().setPIELevel(static_cast<llvm::PIELevel::Level>(PLevel));
1477 }
1478
1479 if (getCodeGenOpts().CodeModel.size() > 0) {
1480 unsigned CM = llvm::StringSwitch<unsigned>(getCodeGenOpts().CodeModel)
1481 .Case("tiny", llvm::CodeModel::Tiny)
1482 .Case("small", llvm::CodeModel::Small)
1483 .Case("kernel", llvm::CodeModel::Kernel)
1484 .Case("medium", llvm::CodeModel::Medium)
1485 .Case("large", llvm::CodeModel::Large)
1486 .Default(~0u);
1487 if (CM != ~0u) {
1488 llvm::CodeModel::Model codeModel = static_cast<llvm::CodeModel::Model>(CM);
1489 getModule().setCodeModel(codeModel);
1490
1491 if ((CM == llvm::CodeModel::Medium || CM == llvm::CodeModel::Large) &&
1492 Context.getTargetInfo().getTriple().getArch() ==
1493 llvm::Triple::x86_64) {
1494 getModule().setLargeDataThreshold(getCodeGenOpts().LargeDataThreshold);
1495 }
1496 }
1497 }
1498
1499 if (CodeGenOpts.NoPLT)
1500 getModule().setRtLibUseGOT();
1501 if (getTriple().isOSBinFormatELF() &&
1502 CodeGenOpts.DirectAccessExternalData !=
1503 getModule().getDirectAccessExternalData()) {
1504 getModule().setDirectAccessExternalData(
1505 CodeGenOpts.DirectAccessExternalData);
1506 }
1507 if (CodeGenOpts.UnwindTables)
1508 getModule().setUwtable(llvm::UWTableKind(CodeGenOpts.UnwindTables));
1509
1510 switch (CodeGenOpts.getFramePointer()) {
1512 // 0 ("none") is the default.
1513 break;
1515 getModule().setFramePointer(llvm::FramePointerKind::Reserved);
1516 break;
1518 getModule().setFramePointer(llvm::FramePointerKind::NonLeaf);
1519 break;
1521 getModule().setFramePointer(llvm::FramePointerKind::All);
1522 break;
1523 }
1524
1525 SimplifyPersonality();
1526
1527 if (getCodeGenOpts().EmitDeclMetadata)
1528 EmitDeclMetadata();
1529
1530 if (getCodeGenOpts().CoverageNotesFile.size() ||
1531 getCodeGenOpts().CoverageDataFile.size())
1532 EmitCoverageFile();
1533
1534 if (CGDebugInfo *DI = getModuleDebugInfo())
1535 DI->finalize();
1536
1537 if (getCodeGenOpts().EmitVersionIdentMetadata)
1538 EmitVersionIdentMetadata();
1539
1540 if (!getCodeGenOpts().RecordCommandLine.empty())
1541 EmitCommandLineMetadata();
1542
1543 if (!getCodeGenOpts().StackProtectorGuard.empty())
1544 getModule().setStackProtectorGuard(getCodeGenOpts().StackProtectorGuard);
1545 if (!getCodeGenOpts().StackProtectorGuardReg.empty())
1546 getModule().setStackProtectorGuardReg(
1547 getCodeGenOpts().StackProtectorGuardReg);
1548 if (!getCodeGenOpts().StackProtectorGuardSymbol.empty())
1549 getModule().setStackProtectorGuardSymbol(
1550 getCodeGenOpts().StackProtectorGuardSymbol);
1551 if (getCodeGenOpts().StackProtectorGuardOffset != INT_MAX)
1552 getModule().setStackProtectorGuardOffset(
1553 getCodeGenOpts().StackProtectorGuardOffset);
1554 if (getCodeGenOpts().StackAlignment)
1555 getModule().setOverrideStackAlignment(getCodeGenOpts().StackAlignment);
1556 if (getCodeGenOpts().SkipRaxSetup)
1557 getModule().addModuleFlag(llvm::Module::Override, "SkipRaxSetup", 1);
1558 if (getLangOpts().RegCall4)
1559 getModule().addModuleFlag(llvm::Module::Override, "RegCallv4", 1);
1560
1561 if (getContext().getTargetInfo().getMaxTLSAlign())
1562 getModule().addModuleFlag(llvm::Module::Error, "MaxTLSAlign",
1563 getContext().getTargetInfo().getMaxTLSAlign());
1564
1566
1567 getTargetCodeGenInfo().emitTargetMetadata(*this, MangledDeclNames);
1568
1569 EmitBackendOptionsMetadata(getCodeGenOpts());
1570
1571 // If there is device offloading code embed it in the host now.
1572 EmbedObject(&getModule(), CodeGenOpts, *getFileSystem(), getDiags());
1573
1574 // Set visibility from DLL storage class
1575 // We do this at the end of LLVM IR generation; after any operation
1576 // that might affect the DLL storage class or the visibility, and
1577 // before anything that might act on these.
1579
1580 // Check the tail call symbols are truly undefined.
1581 if (getTriple().isPPC() && !MustTailCallUndefinedGlobals.empty()) {
1582 for (auto &I : MustTailCallUndefinedGlobals) {
1583 if (!I.first->isDefined())
1584 getDiags().Report(I.second, diag::err_ppc_impossible_musttail) << 2;
1585 else {
1586 StringRef MangledName = getMangledName(GlobalDecl(I.first));
1587 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
1588 if (!Entry || Entry->isWeakForLinker() ||
1589 Entry->isDeclarationForLinker())
1590 getDiags().Report(I.second, diag::err_ppc_impossible_musttail) << 2;
1591 }
1592 }
1593 }
1594
1595 // Emit `!llvm.errno.tbaa`, a module-level metadata that specifies the TBAA
1596 // for an int access. This allows LLVM to reason about what memory can be
1597 // accessed by certain library calls that only touch errno.
1598 if (TBAA) {
1599 TBAAAccessInfo TBAAInfo = getTBAAAccessInfo(Context.IntTy);
1600 if (llvm::MDNode *IntegerNode = getTBAAAccessTagInfo(TBAAInfo)) {
1601 auto *ErrnoTBAAMD = TheModule.getOrInsertNamedMetadata(ErrnoTBAAMDName);
1602 ErrnoTBAAMD->addOperand(IntegerNode);
1603 }
1604 }
1605}
1606
1607void CodeGenModule::EmitOpenCLMetadata() {
1608 // SPIR v2.0 s2.13 - The OpenCL version used by the module is stored in the
1609 // opencl.ocl.version named metadata node.
1610 // C++ for OpenCL has a distinct mapping for versions compatible with OpenCL.
1611 auto CLVersion = LangOpts.getOpenCLCompatibleVersion();
1612
1613 auto EmitVersion = [this](StringRef MDName, int Version) {
1614 llvm::Metadata *OCLVerElts[] = {
1615 llvm::ConstantAsMetadata::get(
1616 llvm::ConstantInt::get(Int32Ty, Version / 100)),
1617 llvm::ConstantAsMetadata::get(
1618 llvm::ConstantInt::get(Int32Ty, (Version % 100) / 10))};
1619 llvm::NamedMDNode *OCLVerMD = TheModule.getOrInsertNamedMetadata(MDName);
1620 llvm::LLVMContext &Ctx = TheModule.getContext();
1621 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
1622 };
1623
1624 EmitVersion("opencl.ocl.version", CLVersion);
1625 if (LangOpts.OpenCLCPlusPlus) {
1626 // In addition to the OpenCL compatible version, emit the C++ version.
1627 EmitVersion("opencl.cxx.version", LangOpts.OpenCLCPlusPlusVersion);
1628 }
1629}
1630
1631void CodeGenModule::EmitBackendOptionsMetadata(
1632 const CodeGenOptions &CodeGenOpts) {
1633 if (getTriple().isRISCV()) {
1634 getModule().addModuleFlag(llvm::Module::Min, "SmallDataLimit",
1635 CodeGenOpts.SmallDataLimit);
1636 }
1637}
1638
1640 // Make sure that this type is translated.
1642}
1643
1645 // Make sure that this type is translated.
1647}
1648
1650 if (!TBAA)
1651 return nullptr;
1652 return TBAA->getTypeInfo(QTy);
1653}
1654
1656 if (!TBAA)
1657 return TBAAAccessInfo();
1658 if (getLangOpts().CUDAIsDevice) {
1659 // As CUDA builtin surface/texture types are replaced, skip generating TBAA
1660 // access info.
1661 if (AccessType->isCUDADeviceBuiltinSurfaceType()) {
1662 if (getTargetCodeGenInfo().getCUDADeviceBuiltinSurfaceDeviceType() !=
1663 nullptr)
1664 return TBAAAccessInfo();
1665 } else if (AccessType->isCUDADeviceBuiltinTextureType()) {
1666 if (getTargetCodeGenInfo().getCUDADeviceBuiltinTextureDeviceType() !=
1667 nullptr)
1668 return TBAAAccessInfo();
1669 }
1670 }
1671 return TBAA->getAccessInfo(AccessType);
1672}
1673
1676 if (!TBAA)
1677 return TBAAAccessInfo();
1678 return TBAA->getVTablePtrAccessInfo(VTablePtrType);
1679}
1680
1682 if (!TBAA)
1683 return nullptr;
1684 return TBAA->getTBAAStructInfo(QTy);
1685}
1686
1688 if (!TBAA)
1689 return nullptr;
1690 return TBAA->getBaseTypeInfo(QTy);
1691}
1692
1694 if (!TBAA)
1695 return nullptr;
1696 return TBAA->getAccessTagInfo(Info);
1697}
1698
1701 if (!TBAA)
1702 return TBAAAccessInfo();
1703 return TBAA->mergeTBAAInfoForCast(SourceInfo, TargetInfo);
1704}
1705
1708 TBAAAccessInfo InfoB) {
1709 if (!TBAA)
1710 return TBAAAccessInfo();
1711 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
1712}
1713
1716 TBAAAccessInfo SrcInfo) {
1717 if (!TBAA)
1718 return TBAAAccessInfo();
1719 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
1720}
1721
1723 TBAAAccessInfo TBAAInfo) {
1724 if (llvm::MDNode *Tag = getTBAAAccessTagInfo(TBAAInfo))
1725 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
1726}
1727
1729 llvm::Instruction *I, const CXXRecordDecl *RD) {
1730 I->setMetadata(llvm::LLVMContext::MD_invariant_group,
1731 llvm::MDNode::get(getLLVMContext(), {}));
1732}
1733
1734void CodeGenModule::Error(SourceLocation loc, StringRef message) {
1735 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0");
1736 getDiags().Report(Context.getFullLoc(loc), diagID) << message;
1737}
1738
1739/// ErrorUnsupported - Print out an error that codegen doesn't support the
1740/// specified stmt yet.
1741void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) {
1743 "cannot compile this %0 yet");
1744 std::string Msg = Type;
1745 getDiags().Report(Context.getFullLoc(S->getBeginLoc()), DiagID)
1746 << Msg << S->getSourceRange();
1747}
1748
1749/// ErrorUnsupported - Print out an error that codegen doesn't support the
1750/// specified decl yet.
1751void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) {
1753 "cannot compile this %0 yet");
1754 std::string Msg = Type;
1755 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
1756}
1757
1759 llvm::function_ref<void()> Fn) {
1760 StackHandler.runWithSufficientStackSpace(Loc, Fn);
1761}
1762
1763llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
1764 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
1765}
1766
1767void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
1768 const NamedDecl *D) const {
1769 // Internal definitions always have default visibility.
1770 if (GV->hasLocalLinkage()) {
1771 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1772 return;
1773 }
1774 if (!D)
1775 return;
1776
1777 // Set visibility for definitions, and for declarations if requested globally
1778 // or set explicitly.
1780
1781 // OpenMP declare target variables must be visible to the host so they can
1782 // be registered. We require protected visibility unless the variable has
1783 // the DT_nohost modifier and does not need to be registered.
1784 if (Context.getLangOpts().OpenMP &&
1785 Context.getLangOpts().OpenMPIsTargetDevice && isa<VarDecl>(D) &&
1786 D->hasAttr<OMPDeclareTargetDeclAttr>() &&
1787 D->getAttr<OMPDeclareTargetDeclAttr>()->getDevType() !=
1788 OMPDeclareTargetDeclAttr::DT_NoHost &&
1790 GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
1791 return;
1792 }
1793
1794 if (Context.getLangOpts().HLSL && !D->isInExportDeclContext()) {
1795 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
1796 return;
1797 }
1798
1799 if (GV->hasDLLExportStorageClass() || GV->hasDLLImportStorageClass()) {
1800 // Reject incompatible dlllstorage and visibility annotations.
1801 if (!LV.isVisibilityExplicit())
1802 return;
1803 if (GV->hasDLLExportStorageClass()) {
1804 if (LV.getVisibility() == HiddenVisibility)
1806 diag::err_hidden_visibility_dllexport);
1807 } else if (LV.getVisibility() != DefaultVisibility) {
1809 diag::err_non_default_visibility_dllimport);
1810 }
1811 return;
1812 }
1813
1814 if (LV.isVisibilityExplicit() || getLangOpts().SetVisibilityForExternDecls ||
1815 !GV->isDeclarationForLinker())
1816 GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
1817}
1818
1820 llvm::GlobalValue *GV) {
1821 if (GV->hasLocalLinkage())
1822 return true;
1823
1824 if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
1825 return true;
1826
1827 // DLLImport explicitly marks the GV as external.
1828 if (GV->hasDLLImportStorageClass())
1829 return false;
1830
1831 const llvm::Triple &TT = CGM.getTriple();
1832 const auto &CGOpts = CGM.getCodeGenOpts();
1833 if (TT.isOSCygMing()) {
1834 // In MinGW, variables without DLLImport can still be automatically
1835 // imported from a DLL by the linker; don't mark variables that
1836 // potentially could come from another DLL as DSO local.
1837
1838 // With EmulatedTLS, TLS variables can be autoimported from other DLLs
1839 // (and this actually happens in the public interface of libstdc++), so
1840 // such variables can't be marked as DSO local. (Native TLS variables
1841 // can't be dllimported at all, though.)
1842 if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
1843 (!GV->isThreadLocal() || CGM.getCodeGenOpts().EmulatedTLS) &&
1844 CGOpts.AutoImport)
1845 return false;
1846 }
1847
1848 // On COFF, don't mark 'extern_weak' symbols as DSO local. If these symbols
1849 // remain unresolved in the link, they can be resolved to zero, which is
1850 // outside the current DSO.
1851 if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
1852 return false;
1853
1854 // Every other GV is local on COFF.
1855 // Make an exception for windows OS in the triple: Some firmware builds use
1856 // *-win32-macho triples. This (accidentally?) produced windows relocations
1857 // without GOT tables in older clang versions; Keep this behaviour.
1858 // FIXME: even thread local variables?
1859 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
1860 return true;
1861
1862 // Only handle COFF and ELF for now.
1863 if (!TT.isOSBinFormatELF())
1864 return false;
1865
1866 // If this is not an executable, don't assume anything is local.
1867 llvm::Reloc::Model RM = CGOpts.RelocationModel;
1868 const auto &LOpts = CGM.getLangOpts();
1869 if (RM != llvm::Reloc::Static && !LOpts.PIE) {
1870 // On ELF, if -fno-semantic-interposition is specified and the target
1871 // supports local aliases, there will be neither CC1
1872 // -fsemantic-interposition nor -fhalf-no-semantic-interposition. Set
1873 // dso_local on the function if using a local alias is preferable (can avoid
1874 // PLT indirection).
1875 if (!(isa<llvm::Function>(GV) && GV->canBenefitFromLocalAlias()))
1876 return false;
1877 return !(CGM.getLangOpts().SemanticInterposition ||
1878 CGM.getLangOpts().HalfNoSemanticInterposition);
1879 }
1880
1881 // A definition cannot be preempted from an executable.
1882 if (!GV->isDeclarationForLinker())
1883 return true;
1884
1885 // Most PIC code sequences that assume that a symbol is local cannot produce a
1886 // 0 if it turns out the symbol is undefined. While this is ABI and relocation
1887 // depended, it seems worth it to handle it here.
1888 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
1889 return false;
1890
1891 // PowerPC64 prefers TOC indirection to avoid copy relocations.
1892 if (TT.isPPC64())
1893 return false;
1894
1895 if (CGOpts.DirectAccessExternalData) {
1896 // If -fdirect-access-external-data (default for -fno-pic), set dso_local
1897 // for non-thread-local variables. If the symbol is not defined in the
1898 // executable, a copy relocation will be needed at link time. dso_local is
1899 // excluded for thread-local variables because they generally don't support
1900 // copy relocations.
1901 if (auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
1902 if (!Var->isThreadLocal())
1903 return true;
1904
1905 // -fno-pic sets dso_local on a function declaration to allow direct
1906 // accesses when taking its address (similar to a data symbol). If the
1907 // function is not defined in the executable, a canonical PLT entry will be
1908 // needed at link time. -fno-direct-access-external-data can avoid the
1909 // canonical PLT entry. We don't generalize this condition to -fpie/-fpic as
1910 // it could just cause trouble without providing perceptible benefits.
1911 if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
1912 return true;
1913 }
1914
1915 // If we can use copy relocations we can assume it is local.
1916
1917 // Otherwise don't assume it is local.
1918 return false;
1919}
1920
1921void CodeGenModule::setDSOLocal(llvm::GlobalValue *GV) const {
1922 GV->setDSOLocal(shouldAssumeDSOLocal(*this, GV));
1923}
1924
1925void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV,
1926 GlobalDecl GD) const {
1927 const auto *D = dyn_cast<NamedDecl>(GD.getDecl());
1928 // C++ destructors have a few C++ ABI specific special cases.
1929 if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) {
1931 return;
1932 }
1933 setDLLImportDLLExport(GV, D);
1934}
1935
1936void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV,
1937 const NamedDecl *D) const {
1938 if (D && D->isExternallyVisible()) {
1939 if (D->hasAttr<DLLImportAttr>())
1940 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
1941 else if ((D->hasAttr<DLLExportAttr>() ||
1943 !GV->isDeclarationForLinker())
1944 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
1945 }
1946}
1947
1948void CodeGenModule::setGVProperties(llvm::GlobalValue *GV,
1949 GlobalDecl GD) const {
1950 setDLLImportDLLExport(GV, GD);
1951 setGVPropertiesAux(GV, dyn_cast<NamedDecl>(GD.getDecl()));
1952}
1953
1954void CodeGenModule::setGVProperties(llvm::GlobalValue *GV,
1955 const NamedDecl *D) const {
1956 setDLLImportDLLExport(GV, D);
1957 setGVPropertiesAux(GV, D);
1958}
1959
1960void CodeGenModule::setGVPropertiesAux(llvm::GlobalValue *GV,
1961 const NamedDecl *D) const {
1962 setGlobalVisibility(GV, D);
1963 setDSOLocal(GV);
1964 GV->setPartition(CodeGenOpts.SymbolPartition);
1965}
1966
1967static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
1968 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
1969 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
1970 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
1971 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
1972 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
1973}
1974
1975llvm::GlobalVariable::ThreadLocalMode
1977 switch (CodeGenOpts.getDefaultTLSModel()) {
1979 return llvm::GlobalVariable::GeneralDynamicTLSModel;
1981 return llvm::GlobalVariable::LocalDynamicTLSModel;
1983 return llvm::GlobalVariable::InitialExecTLSModel;
1985 return llvm::GlobalVariable::LocalExecTLSModel;
1986 }
1987 llvm_unreachable("Invalid TLS model!");
1988}
1989
1990void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const {
1991 assert(D.getTLSKind() && "setting TLS mode on non-TLS var!");
1992
1993 llvm::GlobalValue::ThreadLocalMode TLM;
1994 TLM = GetDefaultLLVMTLSModel();
1995
1996 // Override the TLS model if it is explicitly specified.
1997 if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) {
1998 TLM = GetLLVMTLSModel(Attr->getModel());
1999 }
2000
2001 GV->setThreadLocalMode(TLM);
2002}
2003
2004static std::string getCPUSpecificMangling(const CodeGenModule &CGM,
2005 StringRef Name) {
2006 const TargetInfo &Target = CGM.getTarget();
2007 return (Twine('.') + Twine(Target.CPUSpecificManglingCharacter(Name))).str();
2008}
2009
2011 const CPUSpecificAttr *Attr,
2012 unsigned CPUIndex,
2013 raw_ostream &Out) {
2014 // cpu_specific gets the current name, dispatch gets the resolver if IFunc is
2015 // supported.
2016 if (Attr)
2017 Out << getCPUSpecificMangling(CGM, Attr->getCPUName(CPUIndex)->getName());
2018 else if (CGM.getTarget().supportsIFunc())
2019 Out << ".resolver";
2020}
2021
2022// Returns true if GD is a function decl with internal linkage and
2023// needs a unique suffix after the mangled name.
2025 CodeGenModule &CGM) {
2026 const Decl *D = GD.getDecl();
2027 return !CGM.getModuleNameHash().empty() && isa<FunctionDecl>(D) &&
2028 (CGM.getFunctionLinkage(GD) == llvm::GlobalValue::InternalLinkage);
2029}
2030
2031static std::string getMangledNameImpl(CodeGenModule &CGM, GlobalDecl GD,
2032 const NamedDecl *ND,
2033 bool OmitMultiVersionMangling = false) {
2034 SmallString<256> Buffer;
2035 llvm::raw_svector_ostream Out(Buffer);
2037 if (!CGM.getModuleNameHash().empty())
2039 bool ShouldMangle = MC.shouldMangleDeclName(ND);
2040 if (ShouldMangle)
2041 MC.mangleName(GD.getWithDecl(ND), Out);
2042 else {
2043 IdentifierInfo *II = ND->getIdentifier();
2044 assert(II && "Attempt to mangle unnamed decl.");
2045 const auto *FD = dyn_cast<FunctionDecl>(ND);
2046
2047 if (FD &&
2048 FD->getType()->castAs<FunctionType>()->getCallConv() == CC_X86RegCall) {
2049 if (CGM.getLangOpts().RegCall4)
2050 Out << "__regcall4__" << II->getName();
2051 else
2052 Out << "__regcall3__" << II->getName();
2053 } else if (FD && FD->hasAttr<CUDAGlobalAttr>() &&
2055 Out << "__device_stub__" << II->getName();
2056 } else if (FD &&
2057 DeviceKernelAttr::isOpenCLSpelling(
2058 FD->getAttr<DeviceKernelAttr>()) &&
2060 Out << "__clang_ocl_kern_imp_" << II->getName();
2061 } else {
2062 Out << II->getName();
2063 }
2064 }
2065
2066 // Check if the module name hash should be appended for internal linkage
2067 // symbols. This should come before multi-version target suffixes are
2068 // appended. This is to keep the name and module hash suffix of the
2069 // internal linkage function together. The unique suffix should only be
2070 // added when name mangling is done to make sure that the final name can
2071 // be properly demangled. For example, for C functions without prototypes,
2072 // name mangling is not done and the unique suffix should not be appeneded
2073 // then.
2074 if (ShouldMangle && isUniqueInternalLinkageDecl(GD, CGM)) {
2075 assert(CGM.getCodeGenOpts().UniqueInternalLinkageNames &&
2076 "Hash computed when not explicitly requested");
2077 Out << CGM.getModuleNameHash();
2078 }
2079
2080 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2081 if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
2082 switch (FD->getMultiVersionKind()) {
2086 FD->getAttr<CPUSpecificAttr>(),
2087 GD.getMultiVersionIndex(), Out);
2088 break;
2090 auto *Attr = FD->getAttr<TargetAttr>();
2091 assert(Attr && "Expected TargetAttr to be present "
2092 "for attribute mangling");
2093 const ABIInfo &Info = CGM.getTargetCodeGenInfo().getABIInfo();
2094 Info.appendAttributeMangling(Attr, Out);
2095 break;
2096 }
2098 auto *Attr = FD->getAttr<TargetVersionAttr>();
2099 assert(Attr && "Expected TargetVersionAttr to be present "
2100 "for attribute mangling");
2101 const ABIInfo &Info = CGM.getTargetCodeGenInfo().getABIInfo();
2102 Info.appendAttributeMangling(Attr, Out);
2103 break;
2104 }
2106 auto *Attr = FD->getAttr<TargetClonesAttr>();
2107 assert(Attr && "Expected TargetClonesAttr to be present "
2108 "for attribute mangling");
2109 unsigned Index = GD.getMultiVersionIndex();
2110 const ABIInfo &Info = CGM.getTargetCodeGenInfo().getABIInfo();
2111 Info.appendAttributeMangling(Attr, Index, Out);
2112 break;
2113 }
2115 llvm_unreachable("None multiversion type isn't valid here");
2116 }
2117 }
2118
2119 // Make unique name for device side static file-scope variable for HIP.
2120 if (CGM.getContext().shouldExternalize(ND) &&
2121 CGM.getLangOpts().GPURelocatableDeviceCode &&
2122 CGM.getLangOpts().CUDAIsDevice)
2124
2125 return std::string(Out.str());
2126}
2127
2128void CodeGenModule::UpdateMultiVersionNames(GlobalDecl GD,
2129 const FunctionDecl *FD,
2130 StringRef &CurName) {
2131 if (!FD->isMultiVersion())
2132 return;
2133
2134 // Get the name of what this would be without the 'target' attribute. This
2135 // allows us to lookup the version that was emitted when this wasn't a
2136 // multiversion function.
2137 std::string NonTargetName =
2138 getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true);
2139 GlobalDecl OtherGD;
2140 if (lookupRepresentativeDecl(NonTargetName, OtherGD)) {
2141 assert(OtherGD.getCanonicalDecl()
2142 .getDecl()
2143 ->getAsFunction()
2144 ->isMultiVersion() &&
2145 "Other GD should now be a multiversioned function");
2146 // OtherFD is the version of this function that was mangled BEFORE
2147 // becoming a MultiVersion function. It potentially needs to be updated.
2148 const FunctionDecl *OtherFD = OtherGD.getCanonicalDecl()
2149 .getDecl()
2150 ->getAsFunction()
2152 std::string OtherName = getMangledNameImpl(*this, OtherGD, OtherFD);
2153 // This is so that if the initial version was already the 'default'
2154 // version, we don't try to update it.
2155 if (OtherName != NonTargetName) {
2156 // Remove instead of erase, since others may have stored the StringRef
2157 // to this.
2158 const auto ExistingRecord = Manglings.find(NonTargetName);
2159 if (ExistingRecord != std::end(Manglings))
2160 Manglings.remove(&(*ExistingRecord));
2161 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
2162 StringRef OtherNameRef = MangledDeclNames[OtherGD.getCanonicalDecl()] =
2163 Result.first->first();
2164 // If this is the current decl is being created, make sure we update the name.
2165 if (GD.getCanonicalDecl() == OtherGD.getCanonicalDecl())
2166 CurName = OtherNameRef;
2167 if (llvm::GlobalValue *Entry = GetGlobalValue(NonTargetName))
2168 Entry->setName(OtherName);
2169 }
2170 }
2171}
2172
2174 GlobalDecl CanonicalGD = GD.getCanonicalDecl();
2175
2176 // Some ABIs don't have constructor variants. Make sure that base and
2177 // complete constructors get mangled the same.
2178 if (const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.getDecl())) {
2179 if (!getTarget().getCXXABI().hasConstructorVariants()) {
2180 CXXCtorType OrigCtorType = GD.getCtorType();
2181 assert(OrigCtorType == Ctor_Base || OrigCtorType == Ctor_Complete);
2182 if (OrigCtorType == Ctor_Base)
2183 CanonicalGD = GlobalDecl(CD, Ctor_Complete);
2184 }
2185 }
2186
2187 // In CUDA/HIP device compilation with -fgpu-rdc, the mangled name of a
2188 // static device variable depends on whether the variable is referenced by
2189 // a host or device host function. Therefore the mangled name cannot be
2190 // cached.
2191 if (!LangOpts.CUDAIsDevice || !getContext().mayExternalize(GD.getDecl())) {
2192 auto FoundName = MangledDeclNames.find(CanonicalGD);
2193 if (FoundName != MangledDeclNames.end())
2194 return FoundName->second;
2195 }
2196
2197 // Keep the first result in the case of a mangling collision.
2198 const auto *ND = cast<NamedDecl>(GD.getDecl());
2199 std::string MangledName = getMangledNameImpl(*this, GD, ND);
2200
2201 // Ensure either we have different ABIs between host and device compilations,
2202 // says host compilation following MSVC ABI but device compilation follows
2203 // Itanium C++ ABI or, if they follow the same ABI, kernel names after
2204 // mangling should be the same after name stubbing. The later checking is
2205 // very important as the device kernel name being mangled in host-compilation
2206 // is used to resolve the device binaries to be executed. Inconsistent naming
2207 // result in undefined behavior. Even though we cannot check that naming
2208 // directly between host- and device-compilations, the host- and
2209 // device-mangling in host compilation could help catching certain ones.
2210 assert(!isa<FunctionDecl>(ND) || !ND->hasAttr<CUDAGlobalAttr>() ||
2211 getContext().shouldExternalize(ND) || getLangOpts().CUDAIsDevice ||
2212 (getContext().getAuxTargetInfo() &&
2213 (getContext().getAuxTargetInfo()->getCXXABI() !=
2214 getContext().getTargetInfo().getCXXABI())) ||
2215 getCUDARuntime().getDeviceSideName(ND) ==
2217 *this,
2219 ND));
2220
2221 // This invariant should hold true in the future.
2222 // Prior work:
2223 // https://discourse.llvm.org/t/rfc-clang-diagnostic-for-demangling-failures/82835/8
2224 // https://github.com/llvm/llvm-project/issues/111345
2225 // assert(!((StringRef(MangledName).starts_with("_Z") ||
2226 // StringRef(MangledName).starts_with("?")) &&
2227 // !GD.getDecl()->hasAttr<AsmLabelAttr>() &&
2228 // llvm::demangle(MangledName) == MangledName) &&
2229 // "LLVM demangler must demangle clang-generated names");
2230
2231 auto Result = Manglings.insert(std::make_pair(MangledName, GD));
2232 return MangledDeclNames[CanonicalGD] = Result.first->first();
2233}
2234
2236 const BlockDecl *BD) {
2237 MangleContext &MangleCtx = getCXXABI().getMangleContext();
2238 const Decl *D = GD.getDecl();
2239
2240 SmallString<256> Buffer;
2241 llvm::raw_svector_ostream Out(Buffer);
2242 if (!D)
2243 MangleCtx.mangleGlobalBlock(BD,
2244 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
2245 else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D))
2246 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
2247 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D))
2248 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
2249 else
2250 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
2251
2252 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
2253 return Result.first->first();
2254}
2255
2257 auto it = MangledDeclNames.begin();
2258 while (it != MangledDeclNames.end()) {
2259 if (it->second == Name)
2260 return it->first;
2261 it++;
2262 }
2263 return GlobalDecl();
2264}
2265
2266llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
2267 return getModule().getNamedValue(Name);
2268}
2269
2270/// AddGlobalCtor - Add a function to the list that will be called before
2271/// main() runs.
2272void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority,
2273 unsigned LexOrder,
2274 llvm::Constant *AssociatedData) {
2275 // FIXME: Type coercion of void()* types.
2276 GlobalCtors.push_back(Structor(Priority, LexOrder, Ctor, AssociatedData));
2277}
2278
2279/// AddGlobalDtor - Add a function to the list that will be called
2280/// when the module is unloaded.
2281void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority,
2282 bool IsDtorAttrFunc) {
2283 if (CodeGenOpts.RegisterGlobalDtorsWithAtExit &&
2284 (!getContext().getTargetInfo().getTriple().isOSAIX() || IsDtorAttrFunc)) {
2285 DtorsUsingAtExit[Priority].push_back(Dtor);
2286 return;
2287 }
2288
2289 // FIXME: Type coercion of void()* types.
2290 GlobalDtors.push_back(Structor(Priority, ~0U, Dtor, nullptr));
2291}
2292
2293void CodeGenModule::EmitCtorList(CtorList &Fns, const char *GlobalName) {
2294 if (Fns.empty()) return;
2295
2296 const PointerAuthSchema &InitFiniAuthSchema =
2298
2299 // Ctor function type is ptr.
2300 llvm::PointerType *PtrTy = llvm::PointerType::get(
2301 getLLVMContext(), TheModule.getDataLayout().getProgramAddressSpace());
2302
2303 // Get the type of a ctor entry, { i32, ptr, ptr }.
2304 llvm::StructType *CtorStructTy = llvm::StructType::get(Int32Ty, PtrTy, PtrTy);
2305
2306 // Construct the constructor and destructor arrays.
2307 ConstantInitBuilder Builder(*this);
2308 auto Ctors = Builder.beginArray(CtorStructTy);
2309 for (const auto &I : Fns) {
2310 auto Ctor = Ctors.beginStruct(CtorStructTy);
2311 Ctor.addInt(Int32Ty, I.Priority);
2312 if (InitFiniAuthSchema) {
2313 llvm::Constant *StorageAddress =
2314 (InitFiniAuthSchema.isAddressDiscriminated()
2315 ? llvm::ConstantExpr::getIntToPtr(
2316 llvm::ConstantInt::get(
2317 IntPtrTy,
2318 llvm::ConstantPtrAuth::AddrDiscriminator_CtorsDtors),
2319 PtrTy)
2320 : nullptr);
2321 llvm::Constant *SignedCtorPtr = getConstantSignedPointer(
2322 I.Initializer, InitFiniAuthSchema.getKey(), StorageAddress,
2323 llvm::ConstantInt::get(
2324 SizeTy, InitFiniAuthSchema.getConstantDiscrimination()));
2325 Ctor.add(SignedCtorPtr);
2326 } else {
2327 Ctor.add(I.Initializer);
2328 }
2329 if (I.AssociatedData)
2330 Ctor.add(I.AssociatedData);
2331 else
2332 Ctor.addNullPointer(PtrTy);
2333 Ctor.finishAndAddTo(Ctors);
2334 }
2335
2336 auto List = Ctors.finishAndCreateGlobal(GlobalName, getPointerAlign(),
2337 /*constant*/ false,
2338 llvm::GlobalValue::AppendingLinkage);
2339
2340 // The LTO linker doesn't seem to like it when we set an alignment
2341 // on appending variables. Take it off as a workaround.
2342 List->setAlignment(std::nullopt);
2343
2344 Fns.clear();
2345}
2346
2347llvm::GlobalValue::LinkageTypes
2349 const auto *D = cast<FunctionDecl>(GD.getDecl());
2350
2352
2353 if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
2355
2357}
2358
2359llvm::ConstantInt *CodeGenModule::CreateCrossDsoCfiTypeId(llvm::Metadata *MD) {
2360 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
2361 if (!MDS) return nullptr;
2362
2363 return llvm::ConstantInt::get(Int64Ty, llvm::MD5Hash(MDS->getString()));
2364}
2365
2367 const RecordType *UT = Ty->getAsUnionType();
2368 if (!UT)
2369 return Ty;
2370 const RecordDecl *UD = UT->getDecl()->getDefinitionOrSelf();
2371 if (!UD->hasAttr<TransparentUnionAttr>())
2372 return Ty;
2373 for (const auto *it : UD->fields()) {
2374 return it->getType();
2375 }
2376 return Ty;
2377}
2378
2379// If `GeneralizePointers` is true, generalizes types to a void pointer with the
2380// qualifiers of the originally pointed-to type, e.g. 'const char *' and 'char *
2381// const *' generalize to 'const void *' while 'char *' and 'const char **'
2382// generalize to 'void *'.
2384 bool GeneralizePointers) {
2386
2387 if (!GeneralizePointers || !Ty->isPointerType())
2388 return Ty;
2389
2390 return Ctx.getPointerType(
2391 QualType(Ctx.VoidTy)
2393}
2394
2395// Apply type generalization to a FunctionType's return and argument types
2397 bool GeneralizePointers) {
2398 if (auto *FnType = Ty->getAs<FunctionProtoType>()) {
2399 SmallVector<QualType, 8> GeneralizedParams;
2400 for (auto &Param : FnType->param_types())
2401 GeneralizedParams.push_back(
2402 GeneralizeType(Ctx, Param, GeneralizePointers));
2403
2404 return Ctx.getFunctionType(
2405 GeneralizeType(Ctx, FnType->getReturnType(), GeneralizePointers),
2406 GeneralizedParams, FnType->getExtProtoInfo());
2407 }
2408
2409 if (auto *FnType = Ty->getAs<FunctionNoProtoType>())
2410 return Ctx.getFunctionNoProtoType(
2411 GeneralizeType(Ctx, FnType->getReturnType(), GeneralizePointers));
2412
2413 llvm_unreachable("Encountered unknown FunctionType");
2414}
2415
2416llvm::ConstantInt *CodeGenModule::CreateKCFITypeId(QualType T, StringRef Salt) {
2418 getContext(), T, getCodeGenOpts().SanitizeCfiICallGeneralizePointers);
2419 if (auto *FnType = T->getAs<FunctionProtoType>())
2421 FnType->getReturnType(), FnType->getParamTypes(),
2422 FnType->getExtProtoInfo().withExceptionSpec(EST_None));
2423
2424 std::string OutName;
2425 llvm::raw_string_ostream Out(OutName);
2427 T, Out, getCodeGenOpts().SanitizeCfiICallNormalizeIntegers);
2428
2429 if (!Salt.empty())
2430 Out << "." << Salt;
2431
2432 if (getCodeGenOpts().SanitizeCfiICallNormalizeIntegers)
2433 Out << ".normalized";
2434 if (getCodeGenOpts().SanitizeCfiICallGeneralizePointers)
2435 Out << ".generalized";
2436
2437 return llvm::ConstantInt::get(Int32Ty,
2438 static_cast<uint32_t>(llvm::xxHash64(OutName)));
2439}
2440
2442 const CGFunctionInfo &Info,
2443 llvm::Function *F, bool IsThunk) {
2444 unsigned CallingConv;
2445 llvm::AttributeList PAL;
2446 ConstructAttributeList(F->getName(), Info, GD, PAL, CallingConv,
2447 /*AttrOnCallSite=*/false, IsThunk);
2448 if (CallingConv == llvm::CallingConv::X86_VectorCall &&
2449 getTarget().getTriple().isWindowsArm64EC()) {
2450 SourceLocation Loc;
2451 if (const Decl *D = GD.getDecl())
2452 Loc = D->getLocation();
2453
2454 Error(Loc, "__vectorcall calling convention is not currently supported");
2455 }
2456 F->setAttributes(PAL);
2457 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
2458}
2459
2460static void removeImageAccessQualifier(std::string& TyName) {
2461 std::string ReadOnlyQual("__read_only");
2462 std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
2463 if (ReadOnlyPos != std::string::npos)
2464 // "+ 1" for the space after access qualifier.
2465 TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);
2466 else {
2467 std::string WriteOnlyQual("__write_only");
2468 std::string::size_type WriteOnlyPos = TyName.find(WriteOnlyQual);
2469 if (WriteOnlyPos != std::string::npos)
2470 TyName.erase(WriteOnlyPos, WriteOnlyQual.size() + 1);
2471 else {
2472 std::string ReadWriteQual("__read_write");
2473 std::string::size_type ReadWritePos = TyName.find(ReadWriteQual);
2474 if (ReadWritePos != std::string::npos)
2475 TyName.erase(ReadWritePos, ReadWriteQual.size() + 1);
2476 }
2477 }
2478}
2479
2480// Returns the address space id that should be produced to the
2481// kernel_arg_addr_space metadata. This is always fixed to the ids
2482// as specified in the SPIR 2.0 specification in order to differentiate
2483// for example in clGetKernelArgInfo() implementation between the address
2484// spaces with targets without unique mapping to the OpenCL address spaces
2485// (basically all single AS CPUs).
2486static unsigned ArgInfoAddressSpace(LangAS AS) {
2487 switch (AS) {
2489 return 1;
2491 return 2;
2493 return 3;
2495 return 4; // Not in SPIR 2.0 specs.
2497 return 5;
2499 return 6;
2500 default:
2501 return 0; // Assume private.
2502 }
2503}
2504
2506 const FunctionDecl *FD,
2507 CodeGenFunction *CGF) {
2508 assert(((FD && CGF) || (!FD && !CGF)) &&
2509 "Incorrect use - FD and CGF should either be both null or not!");
2510 // Create MDNodes that represent the kernel arg metadata.
2511 // Each MDNode is a list in the form of "key", N number of values which is
2512 // the same number of values as their are kernel arguments.
2513
2514 const PrintingPolicy &Policy = Context.getPrintingPolicy();
2515
2516 // MDNode for the kernel argument address space qualifiers.
2518
2519 // MDNode for the kernel argument access qualifiers (images only).
2521
2522 // MDNode for the kernel argument type names.
2524
2525 // MDNode for the kernel argument base type names.
2526 SmallVector<llvm::Metadata *, 8> argBaseTypeNames;
2527
2528 // MDNode for the kernel argument type qualifiers.
2530
2531 // MDNode for the kernel argument names.
2533
2534 if (FD && CGF)
2535 for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
2536 const ParmVarDecl *parm = FD->getParamDecl(i);
2537 // Get argument name.
2538 argNames.push_back(llvm::MDString::get(VMContext, parm->getName()));
2539
2540 if (!getLangOpts().OpenCL)
2541 continue;
2542 QualType ty = parm->getType();
2543 std::string typeQuals;
2544
2545 // Get image and pipe access qualifier:
2546 if (ty->isImageType() || ty->isPipeType()) {
2547 const Decl *PDecl = parm;
2548 if (const auto *TD = ty->getAs<TypedefType>())
2549 PDecl = TD->getDecl();
2550 const OpenCLAccessAttr *A = PDecl->getAttr<OpenCLAccessAttr>();
2551 if (A && A->isWriteOnly())
2552 accessQuals.push_back(llvm::MDString::get(VMContext, "write_only"));
2553 else if (A && A->isReadWrite())
2554 accessQuals.push_back(llvm::MDString::get(VMContext, "read_write"));
2555 else
2556 accessQuals.push_back(llvm::MDString::get(VMContext, "read_only"));
2557 } else
2558 accessQuals.push_back(llvm::MDString::get(VMContext, "none"));
2559
2560 auto getTypeSpelling = [&](QualType Ty) {
2561 auto typeName = Ty.getUnqualifiedType().getAsString(Policy);
2562
2563 if (Ty.isCanonical()) {
2564 StringRef typeNameRef = typeName;
2565 // Turn "unsigned type" to "utype"
2566 if (typeNameRef.consume_front("unsigned "))
2567 return std::string("u") + typeNameRef.str();
2568 if (typeNameRef.consume_front("signed "))
2569 return typeNameRef.str();
2570 }
2571
2572 return typeName;
2573 };
2574
2575 if (ty->isPointerType()) {
2576 QualType pointeeTy = ty->getPointeeType();
2577
2578 // Get address qualifier.
2579 addressQuals.push_back(
2580 llvm::ConstantAsMetadata::get(CGF->Builder.getInt32(
2581 ArgInfoAddressSpace(pointeeTy.getAddressSpace()))));
2582
2583 // Get argument type name.
2584 std::string typeName = getTypeSpelling(pointeeTy) + "*";
2585 std::string baseTypeName =
2586 getTypeSpelling(pointeeTy.getCanonicalType()) + "*";
2587 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2588 argBaseTypeNames.push_back(
2589 llvm::MDString::get(VMContext, baseTypeName));
2590
2591 // Get argument type qualifiers:
2592 if (ty.isRestrictQualified())
2593 typeQuals = "restrict";
2594 if (pointeeTy.isConstQualified() ||
2596 typeQuals += typeQuals.empty() ? "const" : " const";
2597 if (pointeeTy.isVolatileQualified())
2598 typeQuals += typeQuals.empty() ? "volatile" : " volatile";
2599 } else {
2600 uint32_t AddrSpc = 0;
2601 bool isPipe = ty->isPipeType();
2602 if (ty->isImageType() || isPipe)
2604
2605 addressQuals.push_back(
2606 llvm::ConstantAsMetadata::get(CGF->Builder.getInt32(AddrSpc)));
2607
2608 // Get argument type name.
2609 ty = isPipe ? ty->castAs<PipeType>()->getElementType() : ty;
2610 std::string typeName = getTypeSpelling(ty);
2611 std::string baseTypeName = getTypeSpelling(ty.getCanonicalType());
2612
2613 // Remove access qualifiers on images
2614 // (as they are inseparable from type in clang implementation,
2615 // but OpenCL spec provides a special query to get access qualifier
2616 // via clGetKernelArgInfo with CL_KERNEL_ARG_ACCESS_QUALIFIER):
2617 if (ty->isImageType()) {
2619 removeImageAccessQualifier(baseTypeName);
2620 }
2621
2622 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2623 argBaseTypeNames.push_back(
2624 llvm::MDString::get(VMContext, baseTypeName));
2625
2626 if (isPipe)
2627 typeQuals = "pipe";
2628 }
2629 argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));
2630 }
2631
2632 if (getLangOpts().OpenCL) {
2633 Fn->setMetadata("kernel_arg_addr_space",
2634 llvm::MDNode::get(VMContext, addressQuals));
2635 Fn->setMetadata("kernel_arg_access_qual",
2636 llvm::MDNode::get(VMContext, accessQuals));
2637 Fn->setMetadata("kernel_arg_type",
2638 llvm::MDNode::get(VMContext, argTypeNames));
2639 Fn->setMetadata("kernel_arg_base_type",
2640 llvm::MDNode::get(VMContext, argBaseTypeNames));
2641 Fn->setMetadata("kernel_arg_type_qual",
2642 llvm::MDNode::get(VMContext, argTypeQuals));
2643 }
2644 if (getCodeGenOpts().EmitOpenCLArgMetadata ||
2645 getCodeGenOpts().HIPSaveKernelArgName)
2646 Fn->setMetadata("kernel_arg_name",
2647 llvm::MDNode::get(VMContext, argNames));
2648}
2649
2650/// Determines whether the language options require us to model
2651/// unwind exceptions. We treat -fexceptions as mandating this
2652/// except under the fragile ObjC ABI with only ObjC exceptions
2653/// enabled. This means, for example, that C with -fexceptions
2654/// enables this.
2655static bool hasUnwindExceptions(const LangOptions &LangOpts) {
2656 // If exceptions are completely disabled, obviously this is false.
2657 if (!LangOpts.Exceptions) return false;
2658
2659 // If C++ exceptions are enabled, this is true.
2660 if (LangOpts.CXXExceptions) return true;
2661
2662 // If ObjC exceptions are enabled, this depends on the ABI.
2663 if (LangOpts.ObjCExceptions) {
2664 return LangOpts.ObjCRuntime.hasUnwindExceptions();
2665 }
2666
2667 return true;
2668}
2669
2671 const CXXMethodDecl *MD) {
2672 // Check that the type metadata can ever actually be used by a call.
2673 if (!CGM.getCodeGenOpts().LTOUnit ||
2675 return false;
2676
2677 // Only functions whose address can be taken with a member function pointer
2678 // need this sort of type metadata.
2679 return MD->isImplicitObjectMemberFunction() && !MD->isVirtual() &&
2681}
2682
2683SmallVector<const CXXRecordDecl *, 0>
2685 llvm::SetVector<const CXXRecordDecl *> MostBases;
2686
2687 std::function<void (const CXXRecordDecl *)> CollectMostBases;
2688 CollectMostBases = [&](const CXXRecordDecl *RD) {
2689 if (RD->getNumBases() == 0)
2690 MostBases.insert(RD);
2691 for (const CXXBaseSpecifier &B : RD->bases())
2692 CollectMostBases(B.getType()->getAsCXXRecordDecl());
2693 };
2694 CollectMostBases(RD);
2695 return MostBases.takeVector();
2696}
2697
2699 llvm::Function *F) {
2700 llvm::AttrBuilder B(F->getContext());
2701
2702 if ((!D || !D->hasAttr<NoUwtableAttr>()) && CodeGenOpts.UnwindTables)
2703 B.addUWTableAttr(llvm::UWTableKind(CodeGenOpts.UnwindTables));
2704
2705 if (CodeGenOpts.StackClashProtector)
2706 B.addAttribute("probe-stack", "inline-asm");
2707
2708 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
2709 B.addAttribute("stack-probe-size",
2710 std::to_string(CodeGenOpts.StackProbeSize));
2711
2712 if (!hasUnwindExceptions(LangOpts))
2713 B.addAttribute(llvm::Attribute::NoUnwind);
2714
2715 if (D && D->hasAttr<NoStackProtectorAttr>())
2716 ; // Do nothing.
2717 else if (D && D->hasAttr<StrictGuardStackCheckAttr>() &&
2719 B.addAttribute(llvm::Attribute::StackProtectStrong);
2720 else if (isStackProtectorOn(LangOpts, getTriple(), LangOptions::SSPOn))
2721 B.addAttribute(llvm::Attribute::StackProtect);
2723 B.addAttribute(llvm::Attribute::StackProtectStrong);
2724 else if (isStackProtectorOn(LangOpts, getTriple(), LangOptions::SSPReq))
2725 B.addAttribute(llvm::Attribute::StackProtectReq);
2726
2727 if (!D) {
2728 // Non-entry HLSL functions must always be inlined.
2729 if (getLangOpts().HLSL && !F->hasFnAttribute(llvm::Attribute::NoInline))
2730 B.addAttribute(llvm::Attribute::AlwaysInline);
2731 // If we don't have a declaration to control inlining, the function isn't
2732 // explicitly marked as alwaysinline for semantic reasons, and inlining is
2733 // disabled, mark the function as noinline.
2734 else if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
2735 CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining)
2736 B.addAttribute(llvm::Attribute::NoInline);
2737
2738 F->addFnAttrs(B);
2739 return;
2740 }
2741
2742 // Handle SME attributes that apply to function definitions,
2743 // rather than to function prototypes.
2744 if (D->hasAttr<ArmLocallyStreamingAttr>())
2745 B.addAttribute("aarch64_pstate_sm_body");
2746
2747 if (auto *Attr = D->getAttr<ArmNewAttr>()) {
2748 if (Attr->isNewZA())
2749 B.addAttribute("aarch64_new_za");
2750 if (Attr->isNewZT0())
2751 B.addAttribute("aarch64_new_zt0");
2752 }
2753
2754 // Track whether we need to add the optnone LLVM attribute,
2755 // starting with the default for this optimization level.
2756 bool ShouldAddOptNone =
2757 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
2758 // We can't add optnone in the following cases, it won't pass the verifier.
2759 ShouldAddOptNone &= !D->hasAttr<MinSizeAttr>();
2760 ShouldAddOptNone &= !D->hasAttr<AlwaysInlineAttr>();
2761
2762 // Non-entry HLSL functions must always be inlined.
2763 if (getLangOpts().HLSL && !F->hasFnAttribute(llvm::Attribute::NoInline) &&
2764 !D->hasAttr<NoInlineAttr>()) {
2765 B.addAttribute(llvm::Attribute::AlwaysInline);
2766 } else if ((ShouldAddOptNone || D->hasAttr<OptimizeNoneAttr>()) &&
2767 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2768 // Add optnone, but do so only if the function isn't always_inline.
2769 B.addAttribute(llvm::Attribute::OptimizeNone);
2770
2771 // OptimizeNone implies noinline; we should not be inlining such functions.
2772 B.addAttribute(llvm::Attribute::NoInline);
2773
2774 // We still need to handle naked functions even though optnone subsumes
2775 // much of their semantics.
2776 if (D->hasAttr<NakedAttr>())
2777 B.addAttribute(llvm::Attribute::Naked);
2778
2779 // OptimizeNone wins over OptimizeForSize and MinSize.
2780 F->removeFnAttr(llvm::Attribute::OptimizeForSize);
2781 F->removeFnAttr(llvm::Attribute::MinSize);
2782 } else if (D->hasAttr<NakedAttr>()) {
2783 // Naked implies noinline: we should not be inlining such functions.
2784 B.addAttribute(llvm::Attribute::Naked);
2785 B.addAttribute(llvm::Attribute::NoInline);
2786 } else if (D->hasAttr<NoDuplicateAttr>()) {
2787 B.addAttribute(llvm::Attribute::NoDuplicate);
2788 } else if (D->hasAttr<NoInlineAttr>() &&
2789 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2790 // Add noinline if the function isn't always_inline.
2791 B.addAttribute(llvm::Attribute::NoInline);
2792 } else if (D->hasAttr<AlwaysInlineAttr>() &&
2793 !F->hasFnAttribute(llvm::Attribute::NoInline)) {
2794 // (noinline wins over always_inline, and we can't specify both in IR)
2795 B.addAttribute(llvm::Attribute::AlwaysInline);
2796 } else if (CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining) {
2797 // If we're not inlining, then force everything that isn't always_inline to
2798 // carry an explicit noinline attribute.
2799 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
2800 B.addAttribute(llvm::Attribute::NoInline);
2801 } else {
2802 // Otherwise, propagate the inline hint attribute and potentially use its
2803 // absence to mark things as noinline.
2804 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
2805 // Search function and template pattern redeclarations for inline.
2806 auto CheckForInline = [](const FunctionDecl *FD) {
2807 auto CheckRedeclForInline = [](const FunctionDecl *Redecl) {
2808 return Redecl->isInlineSpecified();
2809 };
2810 if (any_of(FD->redecls(), CheckRedeclForInline))
2811 return true;
2812 const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern();
2813 if (!Pattern)
2814 return false;
2815 return any_of(Pattern->redecls(), CheckRedeclForInline);
2816 };
2817 if (CheckForInline(FD)) {
2818 B.addAttribute(llvm::Attribute::InlineHint);
2819 } else if (CodeGenOpts.getInlining() ==
2821 !FD->isInlined() &&
2822 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2823 B.addAttribute(llvm::Attribute::NoInline);
2824 }
2825 }
2826 }
2827
2828 // Add other optimization related attributes if we are optimizing this
2829 // function.
2830 if (!D->hasAttr<OptimizeNoneAttr>()) {
2831 if (D->hasAttr<ColdAttr>()) {
2832 if (!ShouldAddOptNone)
2833 B.addAttribute(llvm::Attribute::OptimizeForSize);
2834 B.addAttribute(llvm::Attribute::Cold);
2835 }
2836 if (D->hasAttr<HotAttr>())
2837 B.addAttribute(llvm::Attribute::Hot);
2838 if (D->hasAttr<MinSizeAttr>())
2839 B.addAttribute(llvm::Attribute::MinSize);
2840 }
2841
2842 F->addFnAttrs(B);
2843
2844 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
2845 if (alignment)
2846 F->setAlignment(llvm::Align(alignment));
2847
2848 if (!D->hasAttr<AlignedAttr>())
2849 if (LangOpts.FunctionAlignment)
2850 F->setAlignment(llvm::Align(1ull << LangOpts.FunctionAlignment));
2851
2852 // Some C++ ABIs require 2-byte alignment for member functions, in order to
2853 // reserve a bit for differentiating between virtual and non-virtual member
2854 // functions. If the current target's C++ ABI requires this and this is a
2855 // member function, set its alignment accordingly.
2856 if (getTarget().getCXXABI().areMemberFunctionsAligned()) {
2857 if (isa<CXXMethodDecl>(D) && F->getPointerAlignment(getDataLayout()) < 2)
2858 F->setAlignment(std::max(llvm::Align(2), F->getAlign().valueOrOne()));
2859 }
2860
2861 // In the cross-dso CFI mode with canonical jump tables, we want !type
2862 // attributes on definitions only.
2863 if (CodeGenOpts.SanitizeCfiCrossDso &&
2864 CodeGenOpts.SanitizeCfiCanonicalJumpTables) {
2865 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
2866 // Skip available_externally functions. They won't be codegen'ed in the
2867 // current module anyway.
2868 if (getContext().GetGVALinkageForFunction(FD) != GVA_AvailableExternally)
2870 }
2871 }
2872
2873 if (CodeGenOpts.CallGraphSection) {
2874 if (auto *FD = dyn_cast<FunctionDecl>(D))
2876 }
2877
2878 // Emit type metadata on member functions for member function pointer checks.
2879 // These are only ever necessary on definitions; we're guaranteed that the
2880 // definition will be present in the LTO unit as a result of LTO visibility.
2881 auto *MD = dyn_cast<CXXMethodDecl>(D);
2882 if (MD && requiresMemberFunctionPointerTypeMetadata(*this, MD)) {
2883 for (const CXXRecordDecl *Base : getMostBaseClasses(MD->getParent())) {
2884 llvm::Metadata *Id =
2885 CreateMetadataIdentifierForType(Context.getMemberPointerType(
2886 MD->getType(), /*Qualifier=*/std::nullopt, Base));
2887 F->addTypeMetadata(0, Id);
2888 }
2889 }
2890}
2891
2892void CodeGenModule::SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV) {
2893 const Decl *D = GD.getDecl();
2894 if (isa_and_nonnull<NamedDecl>(D))
2895 setGVProperties(GV, GD);
2896 else
2897 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
2898
2899 if (D && D->hasAttr<UsedAttr>())
2901
2902 if (const auto *VD = dyn_cast_if_present<VarDecl>(D);
2903 VD &&
2904 ((CodeGenOpts.KeepPersistentStorageVariables &&
2905 (VD->getStorageDuration() == SD_Static ||
2906 VD->getStorageDuration() == SD_Thread)) ||
2907 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() == SD_Static &&
2908 VD->getType().isConstQualified())))
2910}
2911
2912bool CodeGenModule::GetCPUAndFeaturesAttributes(GlobalDecl GD,
2913 llvm::AttrBuilder &Attrs,
2914 bool SetTargetFeatures) {
2915 // Add target-cpu and target-features attributes to functions. If
2916 // we have a decl for the function and it has a target attribute then
2917 // parse that and add it to the feature set.
2918 StringRef TargetCPU = getTarget().getTargetOpts().CPU;
2919 StringRef TuneCPU = getTarget().getTargetOpts().TuneCPU;
2920 std::vector<std::string> Features;
2921 const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.getDecl());
2922 FD = FD ? FD->getMostRecentDecl() : FD;
2923 const auto *TD = FD ? FD->getAttr<TargetAttr>() : nullptr;
2924 const auto *TV = FD ? FD->getAttr<TargetVersionAttr>() : nullptr;
2925 assert((!TD || !TV) && "both target_version and target specified");
2926 const auto *SD = FD ? FD->getAttr<CPUSpecificAttr>() : nullptr;
2927 const auto *TC = FD ? FD->getAttr<TargetClonesAttr>() : nullptr;
2928 bool AddedAttr = false;
2929 if (TD || TV || SD || TC) {
2930 llvm::StringMap<bool> FeatureMap;
2931 getContext().getFunctionFeatureMap(FeatureMap, GD);
2932
2933 // Produce the canonical string for this set of features.
2934 for (const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
2935 Features.push_back((Entry.getValue() ? "+" : "-") + Entry.getKey().str());
2936
2937 // Now add the target-cpu and target-features to the function.
2938 // While we populated the feature map above, we still need to
2939 // get and parse the target attribute so we can get the cpu for
2940 // the function.
2941 if (TD) {
2943 Target.parseTargetAttr(TD->getFeaturesStr());
2944 if (!ParsedAttr.CPU.empty() &&
2945 getTarget().isValidCPUName(ParsedAttr.CPU)) {
2946 TargetCPU = ParsedAttr.CPU;
2947 TuneCPU = ""; // Clear the tune CPU.
2948 }
2949 if (!ParsedAttr.Tune.empty() &&
2950 getTarget().isValidCPUName(ParsedAttr.Tune))
2951 TuneCPU = ParsedAttr.Tune;
2952 }
2953
2954 if (SD) {
2955 // Apply the given CPU name as the 'tune-cpu' so that the optimizer can
2956 // favor this processor.
2957 TuneCPU = SD->getCPUName(GD.getMultiVersionIndex())->getName();
2958 }
2959 } else {
2960 // Otherwise just add the existing target cpu and target features to the
2961 // function.
2962 Features = getTarget().getTargetOpts().Features;
2963 }
2964
2965 if (!TargetCPU.empty()) {
2966 Attrs.addAttribute("target-cpu", TargetCPU);
2967 AddedAttr = true;
2968 }
2969 if (!TuneCPU.empty()) {
2970 Attrs.addAttribute("tune-cpu", TuneCPU);
2971 AddedAttr = true;
2972 }
2973 if (!Features.empty() && SetTargetFeatures) {
2974 llvm::erase_if(Features, [&](const std::string& F) {
2975 return getTarget().isReadOnlyFeature(F.substr(1));
2976 });
2977 llvm::sort(Features);
2978 Attrs.addAttribute("target-features", llvm::join(Features, ","));
2979 AddedAttr = true;
2980 }
2981 // Add metadata for AArch64 Function Multi Versioning.
2982 if (getTarget().getTriple().isAArch64()) {
2983 llvm::SmallVector<StringRef, 8> Feats;
2984 bool IsDefault = false;
2985 if (TV) {
2986 IsDefault = TV->isDefaultVersion();
2987 TV->getFeatures(Feats);
2988 } else if (TC) {
2989 IsDefault = TC->isDefaultVersion(GD.getMultiVersionIndex());
2990 TC->getFeatures(Feats, GD.getMultiVersionIndex());
2991 }
2992 if (IsDefault) {
2993 Attrs.addAttribute("fmv-features");
2994 AddedAttr = true;
2995 } else if (!Feats.empty()) {
2996 // Sort features and remove duplicates.
2997 std::set<StringRef> OrderedFeats(Feats.begin(), Feats.end());
2998 std::string FMVFeatures;
2999 for (StringRef F : OrderedFeats)
3000 FMVFeatures.append("," + F.str());
3001 Attrs.addAttribute("fmv-features", FMVFeatures.substr(1));
3002 AddedAttr = true;
3003 }
3004 }
3005 return AddedAttr;
3006}
3007
3008void CodeGenModule::setNonAliasAttributes(GlobalDecl GD,
3009 llvm::GlobalObject *GO) {
3010 const Decl *D = GD.getDecl();
3011 SetCommonAttributes(GD, GO);
3012
3013 if (D) {
3014 if (auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
3015 if (D->hasAttr<RetainAttr>())
3016 addUsedGlobal(GV);
3017 if (auto *SA = D->getAttr<PragmaClangBSSSectionAttr>())
3018 GV->addAttribute("bss-section", SA->getName());
3019 if (auto *SA = D->getAttr<PragmaClangDataSectionAttr>())
3020 GV->addAttribute("data-section", SA->getName());
3021 if (auto *SA = D->getAttr<PragmaClangRodataSectionAttr>())
3022 GV->addAttribute("rodata-section", SA->getName());
3023 if (auto *SA = D->getAttr<PragmaClangRelroSectionAttr>())
3024 GV->addAttribute("relro-section", SA->getName());
3025 }
3026
3027 if (auto *F = dyn_cast<llvm::Function>(GO)) {
3028 if (D->hasAttr<RetainAttr>())
3029 addUsedGlobal(F);
3030 if (auto *SA = D->getAttr<PragmaClangTextSectionAttr>())
3031 if (!D->getAttr<SectionAttr>())
3032 F->setSection(SA->getName());
3033
3034 llvm::AttrBuilder Attrs(F->getContext());
3035 if (GetCPUAndFeaturesAttributes(GD, Attrs)) {
3036 // We know that GetCPUAndFeaturesAttributes will always have the
3037 // newest set, since it has the newest possible FunctionDecl, so the
3038 // new ones should replace the old.
3039 llvm::AttributeMask RemoveAttrs;
3040 RemoveAttrs.addAttribute("target-cpu");
3041 RemoveAttrs.addAttribute("target-features");
3042 RemoveAttrs.addAttribute("fmv-features");
3043 RemoveAttrs.addAttribute("tune-cpu");
3044 F->removeFnAttrs(RemoveAttrs);
3045 F->addFnAttrs(Attrs);
3046 }
3047 }
3048
3049 if (const auto *CSA = D->getAttr<CodeSegAttr>())
3050 GO->setSection(CSA->getName());
3051 else if (const auto *SA = D->getAttr<SectionAttr>())
3052 GO->setSection(SA->getName());
3053 }
3054
3056}
3057
3059 llvm::Function *F,
3060 const CGFunctionInfo &FI) {
3061 const Decl *D = GD.getDecl();
3062 SetLLVMFunctionAttributes(GD, FI, F, /*IsThunk=*/false);
3064
3065 F->setLinkage(llvm::Function::InternalLinkage);
3066
3067 setNonAliasAttributes(GD, F);
3068}
3069
3070static void setLinkageForGV(llvm::GlobalValue *GV, const NamedDecl *ND) {
3071 // Set linkage and visibility in case we never see a definition.
3073 // Don't set internal linkage on declarations.
3074 // "extern_weak" is overloaded in LLVM; we probably should have
3075 // separate linkage types for this.
3076 if (isExternallyVisible(LV.getLinkage()) &&
3077 (ND->hasAttr<WeakAttr>() || ND->isWeakImported()))
3078 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
3079}
3080
3081static bool hasExistingGeneralizedTypeMD(llvm::Function *F) {
3082 llvm::MDNode *MD = F->getMetadata(llvm::LLVMContext::MD_type);
3083 return MD && MD->hasGeneralizedMDString();
3084}
3085
3087 llvm::Function *F) {
3088 // Return if generalized type metadata is already attached.
3090 return;
3091
3092 // All functions which are not internal linkage could be indirect targets.
3093 // Address taken functions with internal linkage could be indirect targets.
3094 if (!F->hasLocalLinkage() ||
3095 F->getFunction().hasAddressTaken(nullptr, /*IgnoreCallbackUses=*/true,
3096 /*IgnoreAssumeLikeCalls=*/true,
3097 /*IgnoreLLVMUsed=*/false))
3098 F->addTypeMetadata(0, CreateMetadataIdentifierGeneralized(FD->getType()));
3099}
3100
3102 llvm::Function *F) {
3103 // Only if we are checking indirect calls.
3104 if (!LangOpts.Sanitize.has(SanitizerKind::CFIICall))
3105 return;
3106
3107 // Non-static class methods are handled via vtable or member function pointer
3108 // checks elsewhere.
3109 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
3110 return;
3111
3113 /*GeneralizePointers=*/false);
3114 llvm::Metadata *MD = CreateMetadataIdentifierForType(FnType);
3115 F->addTypeMetadata(0, MD);
3116 // Add the generalized identifier if not added already.
3118 QualType GenPtrFnType = GeneralizeFunctionType(getContext(), FD->getType(),
3119 /*GeneralizePointers=*/true);
3120 F->addTypeMetadata(0, CreateMetadataIdentifierGeneralized(GenPtrFnType));
3121 }
3122
3123 // Emit a hash-based bit set entry for cross-DSO calls.
3124 if (CodeGenOpts.SanitizeCfiCrossDso)
3125 if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
3126 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
3127}
3128
3130 llvm::CallBase *CB) {
3131 // Only if needed for call graph section and only for indirect calls.
3132 if (!CodeGenOpts.CallGraphSection || !CB->isIndirectCall())
3133 return;
3134
3135 llvm::Metadata *TypeIdMD = CreateMetadataIdentifierGeneralized(QT);
3136 llvm::MDTuple *TypeTuple = llvm::MDTuple::get(
3137 getLLVMContext(), {llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
3138 llvm::Type::getInt64Ty(getLLVMContext()), 0)),
3139 TypeIdMD});
3140 llvm::MDTuple *MDN = llvm::MDNode::get(getLLVMContext(), {TypeTuple});
3141 CB->setMetadata(llvm::LLVMContext::MD_callee_type, MDN);
3142}
3143
3144void CodeGenModule::setKCFIType(const FunctionDecl *FD, llvm::Function *F) {
3145 llvm::LLVMContext &Ctx = F->getContext();
3146 llvm::MDBuilder MDB(Ctx);
3147 llvm::StringRef Salt;
3148
3149 if (const auto *FP = FD->getType()->getAs<FunctionProtoType>())
3150 if (const auto &Info = FP->getExtraAttributeInfo())
3151 Salt = Info.CFISalt;
3152
3153 F->setMetadata(llvm::LLVMContext::MD_kcfi_type,
3154 llvm::MDNode::get(Ctx, MDB.createConstant(CreateKCFITypeId(
3155 FD->getType(), Salt))));
3156}
3157
3158static bool allowKCFIIdentifier(StringRef Name) {
3159 // KCFI type identifier constants are only necessary for external assembly
3160 // functions, which means it's safe to skip unusual names. Subset of
3161 // MCAsmInfo::isAcceptableChar() and MCAsmInfoXCOFF::isAcceptableChar().
3162 return llvm::all_of(Name, [](const char &C) {
3163 return llvm::isAlnum(C) || C == '_' || C == '.';
3164 });
3165}
3166
3168 llvm::Module &M = getModule();
3169 for (auto &F : M.functions()) {
3170 // Remove KCFI type metadata from non-address-taken local functions.
3171 bool AddressTaken = F.hasAddressTaken();
3172 if (!AddressTaken && F.hasLocalLinkage())
3173 F.eraseMetadata(llvm::LLVMContext::MD_kcfi_type);
3174
3175 // Generate a constant with the expected KCFI type identifier for all
3176 // address-taken function declarations to support annotating indirectly
3177 // called assembly functions.
3178 if (!AddressTaken || !F.isDeclaration())
3179 continue;
3180
3181 const llvm::ConstantInt *Type;
3182 if (const llvm::MDNode *MD = F.getMetadata(llvm::LLVMContext::MD_kcfi_type))
3183 Type = llvm::mdconst::extract<llvm::ConstantInt>(MD->getOperand(0));
3184 else
3185 continue;
3186
3187 StringRef Name = F.getName();
3188 if (!allowKCFIIdentifier(Name))
3189 continue;
3190
3191 std::string Asm = (".weak __kcfi_typeid_" + Name + "\n.set __kcfi_typeid_" +
3192 Name + ", " + Twine(Type->getZExtValue()) + "\n")
3193 .str();
3194 M.appendModuleInlineAsm(Asm);
3195 }
3196}
3197
3198void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
3199 bool IsIncompleteFunction,
3200 bool IsThunk) {
3201
3202 if (F->getIntrinsicID() != llvm::Intrinsic::not_intrinsic) {
3203 // If this is an intrinsic function, the attributes will have been set
3204 // when the function was created.
3205 return;
3206 }
3207
3208 const auto *FD = cast<FunctionDecl>(GD.getDecl());
3209
3210 if (!IsIncompleteFunction)
3211 SetLLVMFunctionAttributes(GD, getTypes().arrangeGlobalDeclaration(GD), F,
3212 IsThunk);
3213
3214 // Add the Returned attribute for "this", except for iOS 5 and earlier
3215 // where substantial code, including the libstdc++ dylib, was compiled with
3216 // GCC and does not actually return "this".
3217 if (!IsThunk && getCXXABI().HasThisReturn(GD) &&
3218 !(getTriple().isiOS() && getTriple().isOSVersionLT(6))) {
3219 assert(!F->arg_empty() &&
3220 F->arg_begin()->getType()
3221 ->canLosslesslyBitCastTo(F->getReturnType()) &&
3222 "unexpected this return");
3223 F->addParamAttr(0, llvm::Attribute::Returned);
3224 }
3225
3226 // Only a few attributes are set on declarations; these may later be
3227 // overridden by a definition.
3228
3229 setLinkageForGV(F, FD);
3230 setGVProperties(F, FD);
3231
3232 // Setup target-specific attributes.
3233 if (!IsIncompleteFunction && F->isDeclaration())
3235
3236 if (const auto *CSA = FD->getAttr<CodeSegAttr>())
3237 F->setSection(CSA->getName());
3238 else if (const auto *SA = FD->getAttr<SectionAttr>())
3239 F->setSection(SA->getName());
3240
3241 if (const auto *EA = FD->getAttr<ErrorAttr>()) {
3242 if (EA->isError())
3243 F->addFnAttr("dontcall-error", EA->getUserDiagnostic());
3244 else if (EA->isWarning())
3245 F->addFnAttr("dontcall-warn", EA->getUserDiagnostic());
3246 }
3247
3248 // If we plan on emitting this inline builtin, we can't treat it as a builtin.
3249 if (FD->isInlineBuiltinDeclaration()) {
3250 const FunctionDecl *FDBody;
3251 bool HasBody = FD->hasBody(FDBody);
3252 (void)HasBody;
3253 assert(HasBody && "Inline builtin declarations should always have an "
3254 "available body!");
3255 if (shouldEmitFunction(FDBody))
3256 F->addFnAttr(llvm::Attribute::NoBuiltin);
3257 }
3258
3260 // A replaceable global allocation function does not act like a builtin by
3261 // default, only if it is invoked by a new-expression or delete-expression.
3262 F->addFnAttr(llvm::Attribute::NoBuiltin);
3263 }
3264
3266 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3267 else if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
3268 if (MD->isVirtual())
3269 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3270
3271 // Don't emit entries for function declarations in the cross-DSO mode. This
3272 // is handled with better precision by the receiving DSO. But if jump tables
3273 // are non-canonical then we need type metadata in order to produce the local
3274 // jump table.
3275 if (!CodeGenOpts.SanitizeCfiCrossDso ||
3276 !CodeGenOpts.SanitizeCfiCanonicalJumpTables)
3278
3279 if (CodeGenOpts.CallGraphSection)
3281
3282 if (LangOpts.Sanitize.has(SanitizerKind::KCFI))
3283 setKCFIType(FD, F);
3284
3285 if (getLangOpts().OpenMP && FD->hasAttr<OMPDeclareSimdDeclAttr>())
3287
3288 if (CodeGenOpts.InlineMaxStackSize != UINT_MAX)
3289 F->addFnAttr("inline-max-stacksize", llvm::utostr(CodeGenOpts.InlineMaxStackSize));
3290
3291 if (const auto *CB = FD->getAttr<CallbackAttr>()) {
3292 // Annotate the callback behavior as metadata:
3293 // - The callback callee (as argument number).
3294 // - The callback payloads (as argument numbers).
3295 llvm::LLVMContext &Ctx = F->getContext();
3296 llvm::MDBuilder MDB(Ctx);
3297
3298 // The payload indices are all but the first one in the encoding. The first
3299 // identifies the callback callee.
3300 int CalleeIdx = *CB->encoding_begin();
3301 ArrayRef<int> PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());
3302 F->addMetadata(llvm::LLVMContext::MD_callback,
3303 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
3304 CalleeIdx, PayloadIndices,
3305 /* VarArgsArePassed */ false)}));
3306 }
3307}
3308
3309void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) {
3310 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
3311 "Only globals with definition can force usage.");
3312 LLVMUsed.emplace_back(GV);
3313}
3314
3315void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) {
3316 assert(!GV->isDeclaration() &&
3317 "Only globals with definition can force usage.");
3318 LLVMCompilerUsed.emplace_back(GV);
3319}
3320
3322 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
3323 "Only globals with definition can force usage.");
3324 if (getTriple().isOSBinFormatELF())
3325 LLVMCompilerUsed.emplace_back(GV);
3326 else
3327 LLVMUsed.emplace_back(GV);
3328}
3329
3330static void emitUsed(CodeGenModule &CGM, StringRef Name,
3331 std::vector<llvm::WeakTrackingVH> &List) {
3332 // Don't create llvm.used if there is no need.
3333 if (List.empty())
3334 return;
3335
3336 // Convert List to what ConstantArray needs.
3338 UsedArray.resize(List.size());
3339 for (unsigned i = 0, e = List.size(); i != e; ++i) {
3340 UsedArray[i] =
3341 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
3342 cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy);
3343 }
3344
3345 if (UsedArray.empty())
3346 return;
3347 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size());
3348
3349 auto *GV = new llvm::GlobalVariable(
3350 CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage,
3351 llvm::ConstantArray::get(ATy, UsedArray), Name);
3352
3353 GV->setSection("llvm.metadata");
3354}
3355
3356void CodeGenModule::emitLLVMUsed() {
3357 emitUsed(*this, "llvm.used", LLVMUsed);
3358 emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed);
3359}
3360
3362 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opts);
3363 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
3364}
3365
3366void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) {
3369 if (Opt.empty())
3370 return;
3371 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
3372 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
3373}
3374
3376 auto &C = getLLVMContext();
3377 if (getTarget().getTriple().isOSBinFormatELF()) {
3378 ELFDependentLibraries.push_back(
3379 llvm::MDNode::get(C, llvm::MDString::get(C, Lib)));
3380 return;
3381 }
3382
3385 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
3386 LinkerOptionsMetadata.push_back(llvm::MDNode::get(C, MDOpts));
3387}
3388
3389/// Add link options implied by the given module, including modules
3390/// it depends on, using a postorder walk.
3394 // Import this module's parent.
3395 if (Mod->Parent && Visited.insert(Mod->Parent).second) {
3396 addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited);
3397 }
3398
3399 // Import this module's dependencies.
3400 for (Module *Import : llvm::reverse(Mod->Imports)) {
3401 if (Visited.insert(Import).second)
3402 addLinkOptionsPostorder(CGM, Import, Metadata, Visited);
3403 }
3404
3405 // Add linker options to link against the libraries/frameworks
3406 // described by this module.
3407 llvm::LLVMContext &Context = CGM.getLLVMContext();
3408 bool IsELF = CGM.getTarget().getTriple().isOSBinFormatELF();
3409
3410 // For modules that use export_as for linking, use that module
3411 // name instead.
3413 return;
3414
3415 for (const Module::LinkLibrary &LL : llvm::reverse(Mod->LinkLibraries)) {
3416 // Link against a framework. Frameworks are currently Darwin only, so we
3417 // don't to ask TargetCodeGenInfo for the spelling of the linker option.
3418 if (LL.IsFramework) {
3419 llvm::Metadata *Args[2] = {llvm::MDString::get(Context, "-framework"),
3420 llvm::MDString::get(Context, LL.Library)};
3421
3422 Metadata.push_back(llvm::MDNode::get(Context, Args));
3423 continue;
3424 }
3425
3426 // Link against a library.
3427 if (IsELF) {
3428 llvm::Metadata *Args[2] = {
3429 llvm::MDString::get(Context, "lib"),
3430 llvm::MDString::get(Context, LL.Library),
3431 };
3432 Metadata.push_back(llvm::MDNode::get(Context, Args));
3433 } else {
3435 CGM.getTargetCodeGenInfo().getDependentLibraryOption(LL.Library, Opt);
3436 auto *OptString = llvm::MDString::get(Context, Opt);
3437 Metadata.push_back(llvm::MDNode::get(Context, OptString));
3438 }
3439 }
3440}
3441
3442void CodeGenModule::EmitModuleInitializers(clang::Module *Primary) {
3443 assert(Primary->isNamedModuleUnit() &&
3444 "We should only emit module initializers for named modules.");
3445
3446 // Emit the initializers in the order that sub-modules appear in the
3447 // source, first Global Module Fragments, if present.
3448 if (auto GMF = Primary->getGlobalModuleFragment()) {
3449 for (Decl *D : getContext().getModuleInitializers(GMF)) {
3450 if (isa<ImportDecl>(D))
3451 continue;
3452 assert(isa<VarDecl>(D) && "GMF initializer decl is not a var?");
3454 }
3455 }
3456 // Second any associated with the module, itself.
3457 for (Decl *D : getContext().getModuleInitializers(Primary)) {
3458 // Skip import decls, the inits for those are called explicitly.
3459 if (isa<ImportDecl>(D))
3460 continue;
3462 }
3463 // Third any associated with the Privat eMOdule Fragment, if present.
3464 if (auto PMF = Primary->getPrivateModuleFragment()) {
3465 for (Decl *D : getContext().getModuleInitializers(PMF)) {
3466 // Skip import decls, the inits for those are called explicitly.
3467 if (isa<ImportDecl>(D))
3468 continue;
3469 assert(isa<VarDecl>(D) && "PMF initializer decl is not a var?");
3471 }
3472 }
3473}
3474
3475void CodeGenModule::EmitModuleLinkOptions() {
3476 // Collect the set of all of the modules we want to visit to emit link
3477 // options, which is essentially the imported modules and all of their
3478 // non-explicit child modules.
3479 llvm::SetVector<clang::Module *> LinkModules;
3480 llvm::SmallPtrSet<clang::Module *, 16> Visited;
3481 SmallVector<clang::Module *, 16> Stack;
3482
3483 // Seed the stack with imported modules.
3484 for (Module *M : ImportedModules) {
3485 // Do not add any link flags when an implementation TU of a module imports
3486 // a header of that same module.
3487 if (M->getTopLevelModuleName() == getLangOpts().CurrentModule &&
3488 !getLangOpts().isCompilingModule())
3489 continue;
3490 if (Visited.insert(M).second)
3491 Stack.push_back(M);
3492 }
3493
3494 // Find all of the modules to import, making a little effort to prune
3495 // non-leaf modules.
3496 while (!Stack.empty()) {
3497 clang::Module *Mod = Stack.pop_back_val();
3498
3499 bool AnyChildren = false;
3500
3501 // Visit the submodules of this module.
3502 for (const auto &SM : Mod->submodules()) {
3503 // Skip explicit children; they need to be explicitly imported to be
3504 // linked against.
3505 if (SM->IsExplicit)
3506 continue;
3507
3508 if (Visited.insert(SM).second) {
3509 Stack.push_back(SM);
3510 AnyChildren = true;
3511 }
3512 }
3513
3514 // We didn't find any children, so add this module to the list of
3515 // modules to link against.
3516 if (!AnyChildren) {
3517 LinkModules.insert(Mod);
3518 }
3519 }
3520
3521 // Add link options for all of the imported modules in reverse topological
3522 // order. We don't do anything to try to order import link flags with respect
3523 // to linker options inserted by things like #pragma comment().
3524 SmallVector<llvm::MDNode *, 16> MetadataArgs;
3525 Visited.clear();
3526 for (Module *M : LinkModules)
3527 if (Visited.insert(M).second)
3528 addLinkOptionsPostorder(*this, M, MetadataArgs, Visited);
3529 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
3530 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
3531
3532 // Add the linker options metadata flag.
3533 if (!LinkerOptionsMetadata.empty()) {
3534 auto *NMD = getModule().getOrInsertNamedMetadata("llvm.linker.options");
3535 for (auto *MD : LinkerOptionsMetadata)
3536 NMD->addOperand(MD);
3537 }
3538}
3539
3540void CodeGenModule::EmitDeferred() {
3541 // Emit deferred declare target declarations.
3542 if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd)
3544
3545 // Emit code for any potentially referenced deferred decls. Since a
3546 // previously unused static decl may become used during the generation of code
3547 // for a static function, iterate until no changes are made.
3548
3549 if (!DeferredVTables.empty()) {
3550 EmitDeferredVTables();
3551
3552 // Emitting a vtable doesn't directly cause more vtables to
3553 // become deferred, although it can cause functions to be
3554 // emitted that then need those vtables.
3555 assert(DeferredVTables.empty());
3556 }
3557
3558 // Emit CUDA/HIP static device variables referenced by host code only.
3559 // Note we should not clear CUDADeviceVarODRUsedByHost since it is still
3560 // needed for further handling.
3561 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
3562 llvm::append_range(DeferredDeclsToEmit,
3563 getContext().CUDADeviceVarODRUsedByHost);
3564
3565 // Stop if we're out of both deferred vtables and deferred declarations.
3566 if (DeferredDeclsToEmit.empty())
3567 return;
3568
3569 // Grab the list of decls to emit. If EmitGlobalDefinition schedules more
3570 // work, it will not interfere with this.
3571 std::vector<GlobalDecl> CurDeclsToEmit;
3572 CurDeclsToEmit.swap(DeferredDeclsToEmit);
3573
3574 for (GlobalDecl &D : CurDeclsToEmit) {
3575 // Functions declared with the sycl_kernel_entry_point attribute are
3576 // emitted normally during host compilation. During device compilation,
3577 // a SYCL kernel caller offload entry point function is generated and
3578 // emitted in place of each of these functions.
3579 if (const auto *FD = D.getDecl()->getAsFunction()) {
3580 if (LangOpts.SYCLIsDevice && FD->hasAttr<SYCLKernelEntryPointAttr>() &&
3581 FD->isDefined()) {
3582 // Functions with an invalid sycl_kernel_entry_point attribute are
3583 // ignored during device compilation.
3584 if (!FD->getAttr<SYCLKernelEntryPointAttr>()->isInvalidAttr()) {
3585 // Generate and emit the SYCL kernel caller function.
3586 EmitSYCLKernelCaller(FD, getContext());
3587 // Recurse to emit any symbols directly or indirectly referenced
3588 // by the SYCL kernel caller function.
3589 EmitDeferred();
3590 }
3591 // Do not emit the sycl_kernel_entry_point attributed function.
3592 continue;
3593 }
3594 }
3595
3596 // We should call GetAddrOfGlobal with IsForDefinition set to true in order
3597 // to get GlobalValue with exactly the type we need, not something that
3598 // might had been created for another decl with the same mangled name but
3599 // different type.
3600 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
3602
3603 // In case of different address spaces, we may still get a cast, even with
3604 // IsForDefinition equal to true. Query mangled names table to get
3605 // GlobalValue.
3606 if (!GV)
3608
3609 // Make sure GetGlobalValue returned non-null.
3610 assert(GV);
3611
3612 // Check to see if we've already emitted this. This is necessary
3613 // for a couple of reasons: first, decls can end up in the
3614 // deferred-decls queue multiple times, and second, decls can end
3615 // up with definitions in unusual ways (e.g. by an extern inline
3616 // function acquiring a strong function redefinition). Just
3617 // ignore these cases.
3618 if (!GV->isDeclaration())
3619 continue;
3620
3621 // If this is OpenMP, check if it is legal to emit this global normally.
3622 if (LangOpts.OpenMP && OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(D))
3623 continue;
3624
3625 // Otherwise, emit the definition and move on to the next one.
3626 EmitGlobalDefinition(D, GV);
3627
3628 // If we found out that we need to emit more decls, do that recursively.
3629 // This has the advantage that the decls are emitted in a DFS and related
3630 // ones are close together, which is convenient for testing.
3631 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
3632 EmitDeferred();
3633 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
3634 }
3635 }
3636}
3637
3638void CodeGenModule::EmitVTablesOpportunistically() {
3639 // Try to emit external vtables as available_externally if they have emitted
3640 // all inlined virtual functions. It runs after EmitDeferred() and therefore
3641 // is not allowed to create new references to things that need to be emitted
3642 // lazily. Note that it also uses fact that we eagerly emitting RTTI.
3643
3644 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
3645 && "Only emit opportunistic vtables with optimizations");
3646
3647 for (const CXXRecordDecl *RD : OpportunisticVTables) {
3648 assert(getVTables().isVTableExternal(RD) &&
3649 "This queue should only contain external vtables");
3650 if (getCXXABI().canSpeculativelyEmitVTable(RD))
3651 VTables.GenerateClassData(RD);
3652 }
3653 OpportunisticVTables.clear();
3654}
3655
3657 for (const auto& [MangledName, VD] : DeferredAnnotations) {
3658 llvm::GlobalValue *GV = GetGlobalValue(MangledName);
3659 if (GV)
3660 AddGlobalAnnotations(VD, GV);
3661 }
3662 DeferredAnnotations.clear();
3663
3664 if (Annotations.empty())
3665 return;
3666
3667 // Create a new global variable for the ConstantStruct in the Module.
3668 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
3669 Annotations[0]->getType(), Annotations.size()), Annotations);
3670 auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false,
3671 llvm::GlobalValue::AppendingLinkage,
3672 Array, "llvm.global.annotations");
3673 gv->setSection(AnnotationSection);
3674}
3675
3676llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
3677 llvm::Constant *&AStr = AnnotationStrings[Str];
3678 if (AStr)
3679 return AStr;
3680
3681 // Not found yet, create a new global.
3682 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
3683 auto *gv = new llvm::GlobalVariable(
3684 getModule(), s->getType(), true, llvm::GlobalValue::PrivateLinkage, s,
3685 ".str", nullptr, llvm::GlobalValue::NotThreadLocal,
3686 ConstGlobalsPtrTy->getAddressSpace());
3687 gv->setSection(AnnotationSection);
3688 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3689 AStr = gv;
3690 return gv;
3691}
3692
3695 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
3696 if (PLoc.isValid())
3697 return EmitAnnotationString(PLoc.getFilename());
3698 return EmitAnnotationString(SM.getBufferName(Loc));
3699}
3700
3703 PresumedLoc PLoc = SM.getPresumedLoc(L);
3704 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
3705 SM.getExpansionLineNumber(L);
3706 return llvm::ConstantInt::get(Int32Ty, LineNo);
3707}
3708
3709llvm::Constant *CodeGenModule::EmitAnnotationArgs(const AnnotateAttr *Attr) {
3710 ArrayRef<Expr *> Exprs = {Attr->args_begin(), Attr->args_size()};
3711 if (Exprs.empty())
3712 return llvm::ConstantPointerNull::get(ConstGlobalsPtrTy);
3713
3714 llvm::FoldingSetNodeID ID;
3715 for (Expr *E : Exprs) {
3716 ID.Add(cast<clang::ConstantExpr>(E)->getAPValueResult());
3717 }
3718 llvm::Constant *&Lookup = AnnotationArgs[ID.ComputeHash()];
3719 if (Lookup)
3720 return Lookup;
3721
3723 LLVMArgs.reserve(Exprs.size());
3724 ConstantEmitter ConstEmiter(*this);
3725 llvm::transform(Exprs, std::back_inserter(LLVMArgs), [&](const Expr *E) {
3726 const auto *CE = cast<clang::ConstantExpr>(E);
3727 return ConstEmiter.emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(),
3728 CE->getType());
3729 });
3730 auto *Struct = llvm::ConstantStruct::getAnon(LLVMArgs);
3731 auto *GV = new llvm::GlobalVariable(getModule(), Struct->getType(), true,
3732 llvm::GlobalValue::PrivateLinkage, Struct,
3733 ".args");
3734 GV->setSection(AnnotationSection);
3735 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3736
3737 Lookup = GV;
3738 return GV;
3739}
3740
3741llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
3742 const AnnotateAttr *AA,
3743 SourceLocation L) {
3744 // Get the globals for file name, annotation, and the line number.
3745 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
3746 *UnitGV = EmitAnnotationUnit(L),
3747 *LineNoCst = EmitAnnotationLineNo(L),
3748 *Args = EmitAnnotationArgs(AA);
3749
3750 llvm::Constant *GVInGlobalsAS = GV;
3751 if (GV->getAddressSpace() !=
3752 getDataLayout().getDefaultGlobalsAddressSpace()) {
3753 GVInGlobalsAS = llvm::ConstantExpr::getAddrSpaceCast(
3754 GV,
3755 llvm::PointerType::get(
3756 GV->getContext(), getDataLayout().getDefaultGlobalsAddressSpace()));
3757 }
3758
3759 // Create the ConstantStruct for the global annotation.
3760 llvm::Constant *Fields[] = {
3761 GVInGlobalsAS, AnnoGV, UnitGV, LineNoCst, Args,
3762 };
3763 return llvm::ConstantStruct::getAnon(Fields);
3764}
3765
3767 llvm::GlobalValue *GV) {
3768 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
3769 // Get the struct elements for these annotations.
3770 for (const auto *I : D->specific_attrs<AnnotateAttr>())
3771 Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
3772}
3773
3775 SourceLocation Loc) const {
3776 const auto &NoSanitizeL = getContext().getNoSanitizeList();
3777 // NoSanitize by function name.
3778 if (NoSanitizeL.containsFunction(Kind, Fn->getName()))
3779 return true;
3780 // NoSanitize by location. Check "mainfile" prefix.
3781 auto &SM = Context.getSourceManager();
3782 FileEntryRef MainFile = *SM.getFileEntryRefForID(SM.getMainFileID());
3783 if (NoSanitizeL.containsMainFile(Kind, MainFile.getName()))
3784 return true;
3785
3786 // Check "src" prefix.
3787 if (Loc.isValid())
3788 return NoSanitizeL.containsLocation(Kind, Loc);
3789 // If location is unknown, this may be a compiler-generated function. Assume
3790 // it's located in the main file.
3791 return NoSanitizeL.containsFile(Kind, MainFile.getName());
3792}
3793
3795 llvm::GlobalVariable *GV,
3796 SourceLocation Loc, QualType Ty,
3797 StringRef Category) const {
3798 const auto &NoSanitizeL = getContext().getNoSanitizeList();
3799 if (NoSanitizeL.containsGlobal(Kind, GV->getName(), Category))
3800 return true;
3801 auto &SM = Context.getSourceManager();
3802 if (NoSanitizeL.containsMainFile(
3803 Kind, SM.getFileEntryRefForID(SM.getMainFileID())->getName(),
3804 Category))
3805 return true;
3806 if (NoSanitizeL.containsLocation(Kind, Loc, Category))
3807 return true;
3808
3809 // Check global type.
3810 if (!Ty.isNull()) {
3811 // Drill down the array types: if global variable of a fixed type is
3812 // not sanitized, we also don't instrument arrays of them.
3813 while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr()))
3814 Ty = AT->getElementType();
3816 // Only record types (classes, structs etc.) are ignored.
3817 if (Ty->isRecordType()) {
3818 std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy());
3819 if (NoSanitizeL.containsType(Kind, TypeStr, Category))
3820 return true;
3821 }
3822 }
3823 return false;
3824}
3825
3827 StringRef Category) const {
3828 const auto &XRayFilter = getContext().getXRayFilter();
3829 using ImbueAttr = XRayFunctionFilter::ImbueAttribute;
3830 auto Attr = ImbueAttr::NONE;
3831 if (Loc.isValid())
3832 Attr = XRayFilter.shouldImbueLocation(Loc, Category);
3833 if (Attr == ImbueAttr::NONE)
3834 Attr = XRayFilter.shouldImbueFunction(Fn->getName());
3835 switch (Attr) {
3836 case ImbueAttr::NONE:
3837 return false;
3838 case ImbueAttr::ALWAYS:
3839 Fn->addFnAttr("function-instrument", "xray-always");
3840 break;
3841 case ImbueAttr::ALWAYS_ARG1:
3842 Fn->addFnAttr("function-instrument", "xray-always");
3843 Fn->addFnAttr("xray-log-args", "1");
3844 break;
3845 case ImbueAttr::NEVER:
3846 Fn->addFnAttr("function-instrument", "xray-never");
3847 break;
3848 }
3849 return true;
3850}
3851
3854 SourceLocation Loc) const {
3855 const auto &ProfileList = getContext().getProfileList();
3856 // If the profile list is empty, then instrument everything.
3857 if (ProfileList.isEmpty())
3858 return ProfileList::Allow;
3859 llvm::driver::ProfileInstrKind Kind = getCodeGenOpts().getProfileInstr();
3860 // First, check the function name.
3861 if (auto V = ProfileList.isFunctionExcluded(Fn->getName(), Kind))
3862 return *V;
3863 // Next, check the source location.
3864 if (Loc.isValid())
3865 if (auto V = ProfileList.isLocationExcluded(Loc, Kind))
3866 return *V;
3867 // If location is unknown, this may be a compiler-generated function. Assume
3868 // it's located in the main file.
3869 auto &SM = Context.getSourceManager();
3870 if (auto MainFile = SM.getFileEntryRefForID(SM.getMainFileID()))
3871 if (auto V = ProfileList.isFileExcluded(MainFile->getName(), Kind))
3872 return *V;
3873 return ProfileList.getDefault(Kind);
3874}
3875
3878 SourceLocation Loc) const {
3879 auto V = isFunctionBlockedByProfileList(Fn, Loc);
3880 if (V != ProfileList::Allow)
3881 return V;
3882
3883 auto NumGroups = getCodeGenOpts().ProfileTotalFunctionGroups;
3884 if (NumGroups > 1) {
3885 auto Group = llvm::crc32(arrayRefFromStringRef(Fn->getName())) % NumGroups;
3886 if (Group != getCodeGenOpts().ProfileSelectedFunctionGroup)
3887 return ProfileList::Skip;
3888 }
3889 return ProfileList::Allow;
3890}
3891
3892bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) {
3893 // Never defer when EmitAllDecls is specified.
3894 if (LangOpts.EmitAllDecls)
3895 return true;
3896
3897 const auto *VD = dyn_cast<VarDecl>(Global);
3898 if (VD &&
3899 ((CodeGenOpts.KeepPersistentStorageVariables &&
3900 (VD->getStorageDuration() == SD_Static ||
3901 VD->getStorageDuration() == SD_Thread)) ||
3902 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() == SD_Static &&
3903 VD->getType().isConstQualified())))
3904 return true;
3905
3907}
3908
3909bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) {
3910 // In OpenMP 5.0 variables and function may be marked as
3911 // device_type(host/nohost) and we should not emit them eagerly unless we sure
3912 // that they must be emitted on the host/device. To be sure we need to have
3913 // seen a declare target with an explicit mentioning of the function, we know
3914 // we have if the level of the declare target attribute is -1. Note that we
3915 // check somewhere else if we should emit this at all.
3916 if (LangOpts.OpenMP >= 50 && !LangOpts.OpenMPSimd) {
3917 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr =
3918 OMPDeclareTargetDeclAttr::getActiveAttr(Global);
3919 if (!ActiveAttr || (*ActiveAttr)->getLevel() != (unsigned)-1)
3920 return false;
3921 }
3922
3923 if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
3925 // Implicit template instantiations may change linkage if they are later
3926 // explicitly instantiated, so they should not be emitted eagerly.
3927 return false;
3928 // Defer until all versions have been semantically checked.
3929 if (FD->hasAttr<TargetVersionAttr>() && !FD->isMultiVersion())
3930 return false;
3931 // Defer emission of SYCL kernel entry point functions during device
3932 // compilation.
3933 if (LangOpts.SYCLIsDevice && FD->hasAttr<SYCLKernelEntryPointAttr>())
3934 return false;
3935 }
3936 if (const auto *VD = dyn_cast<VarDecl>(Global)) {
3937 if (Context.getInlineVariableDefinitionKind(VD) ==
3939 // A definition of an inline constexpr static data member may change
3940 // linkage later if it's redeclared outside the class.
3941 return false;
3942 if (CXX20ModuleInits && VD->getOwningModule() &&
3943 !VD->getOwningModule()->isModuleMapModule()) {
3944 // For CXX20, module-owned initializers need to be deferred, since it is
3945 // not known at this point if they will be run for the current module or
3946 // as part of the initializer for an imported one.
3947 return false;
3948 }
3949 }
3950 // If OpenMP is enabled and threadprivates must be generated like TLS, delay
3951 // codegen for global variables, because they may be marked as threadprivate.
3952 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
3953 getContext().getTargetInfo().isTLSSupported() && isa<VarDecl>(Global) &&
3954 !Global->getType().isConstantStorage(getContext(), false, false) &&
3955 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Global))
3956 return false;
3957
3958 return true;
3959}
3960
3962 StringRef Name = getMangledName(GD);
3963
3964 // The UUID descriptor should be pointer aligned.
3966
3967 // Look for an existing global.
3968 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
3969 return ConstantAddress(GV, GV->getValueType(), Alignment);
3970
3971 ConstantEmitter Emitter(*this);
3972 llvm::Constant *Init;
3973
3974 APValue &V = GD->getAsAPValue();
3975 if (!V.isAbsent()) {
3976 // If possible, emit the APValue version of the initializer. In particular,
3977 // this gets the type of the constant right.
3978 Init = Emitter.emitForInitializer(
3979 GD->getAsAPValue(), GD->getType().getAddressSpace(), GD->getType());
3980 } else {
3981 // As a fallback, directly construct the constant.
3982 // FIXME: This may get padding wrong under esoteric struct layout rules.
3983 // MSVC appears to create a complete type 'struct __s_GUID' that it
3984 // presumably uses to represent these constants.
3985 MSGuidDecl::Parts Parts = GD->getParts();
3986 llvm::Constant *Fields[4] = {
3987 llvm::ConstantInt::get(Int32Ty, Parts.Part1),
3988 llvm::ConstantInt::get(Int16Ty, Parts.Part2),
3989 llvm::ConstantInt::get(Int16Ty, Parts.Part3),
3990 llvm::ConstantDataArray::getRaw(
3991 StringRef(reinterpret_cast<char *>(Parts.Part4And5), 8), 8,
3992 Int8Ty)};
3993 Init = llvm::ConstantStruct::getAnon(Fields);
3994 }
3995
3996 auto *GV = new llvm::GlobalVariable(
3997 getModule(), Init->getType(),
3998 /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name);
3999 if (supportsCOMDAT())
4000 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
4001 setDSOLocal(GV);
4002
4003 if (!V.isAbsent()) {
4004 Emitter.finalize(GV);
4005 return ConstantAddress(GV, GV->getValueType(), Alignment);
4006 }
4007
4008 llvm::Type *Ty = getTypes().ConvertTypeForMem(GD->getType());
4009 return ConstantAddress(GV, Ty, Alignment);
4010}
4011
4013 const UnnamedGlobalConstantDecl *GCD) {
4014 CharUnits Alignment = getContext().getTypeAlignInChars(GCD->getType());
4015
4016 llvm::GlobalVariable **Entry = nullptr;
4017 Entry = &UnnamedGlobalConstantDeclMap[GCD];
4018 if (*Entry)
4019 return ConstantAddress(*Entry, (*Entry)->getValueType(), Alignment);
4020
4021 ConstantEmitter Emitter(*this);
4022 llvm::Constant *Init;
4023
4024 const APValue &V = GCD->getValue();
4025
4026 assert(!V.isAbsent());
4027 Init = Emitter.emitForInitializer(V, GCD->getType().getAddressSpace(),
4028 GCD->getType());
4029
4030 auto *GV = new llvm::GlobalVariable(getModule(), Init->getType(),
4031 /*isConstant=*/true,
4032 llvm::GlobalValue::PrivateLinkage, Init,
4033 ".constant");
4034 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4035 GV->setAlignment(Alignment.getAsAlign());
4036
4037 Emitter.finalize(GV);
4038
4039 *Entry = GV;
4040 return ConstantAddress(GV, GV->getValueType(), Alignment);
4041}
4042
4044 const TemplateParamObjectDecl *TPO) {
4045 StringRef Name = getMangledName(TPO);
4046 CharUnits Alignment = getNaturalTypeAlignment(TPO->getType());
4047
4048 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
4049 return ConstantAddress(GV, GV->getValueType(), Alignment);
4050
4051 ConstantEmitter Emitter(*this);
4052 llvm::Constant *Init = Emitter.emitForInitializer(
4053 TPO->getValue(), TPO->getType().getAddressSpace(), TPO->getType());
4054
4055 if (!Init) {
4056 ErrorUnsupported(TPO, "template parameter object");
4057 return ConstantAddress::invalid();
4058 }
4059
4060 llvm::GlobalValue::LinkageTypes Linkage =
4062 ? llvm::GlobalValue::LinkOnceODRLinkage
4063 : llvm::GlobalValue::InternalLinkage;
4064 auto *GV = new llvm::GlobalVariable(getModule(), Init->getType(),
4065 /*isConstant=*/true, Linkage, Init, Name);
4066 setGVProperties(GV, TPO);
4067 if (supportsCOMDAT() && Linkage == llvm::GlobalValue::LinkOnceODRLinkage)
4068 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
4069 Emitter.finalize(GV);
4070
4071 return ConstantAddress(GV, GV->getValueType(), Alignment);
4072}
4073
4075 const AliasAttr *AA = VD->getAttr<AliasAttr>();
4076 assert(AA && "No alias?");
4077
4078 CharUnits Alignment = getContext().getDeclAlign(VD);
4079 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
4080
4081 // See if there is already something with the target's name in the module.
4082 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
4083 if (Entry)
4084 return ConstantAddress(Entry, DeclTy, Alignment);
4085
4086 llvm::Constant *Aliasee;
4087 if (isa<llvm::FunctionType>(DeclTy))
4088 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
4090 /*ForVTable=*/false);
4091 else
4092 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), DeclTy, LangAS::Default,
4093 nullptr);
4094
4095 auto *F = cast<llvm::GlobalValue>(Aliasee);
4096 F->setLinkage(llvm::Function::ExternalWeakLinkage);
4097 WeakRefReferences.insert(F);
4098
4099 return ConstantAddress(Aliasee, DeclTy, Alignment);
4100}
4101
4102template <typename AttrT> static bool hasImplicitAttr(const ValueDecl *D) {
4103 if (!D)
4104 return false;
4105 if (auto *A = D->getAttr<AttrT>())
4106 return A->isImplicit();
4107 return D->isImplicit();
4108}
4109
4110bool CodeGenModule::shouldEmitCUDAGlobalVar(const VarDecl *Global) const {
4111 assert(LangOpts.CUDA && "Should not be called by non-CUDA languages");
4112 // We need to emit host-side 'shadows' for all global
4113 // device-side variables because the CUDA runtime needs their
4114 // size and host-side address in order to provide access to
4115 // their device-side incarnations.
4116 return !LangOpts.CUDAIsDevice || Global->hasAttr<CUDADeviceAttr>() ||
4117 Global->hasAttr<CUDAConstantAttr>() ||
4118 Global->hasAttr<CUDASharedAttr>() ||
4119 Global->getType()->isCUDADeviceBuiltinSurfaceType() ||
4120 Global->getType()->isCUDADeviceBuiltinTextureType();
4121}
4122
4124 const auto *Global = cast<ValueDecl>(GD.getDecl());
4125
4126 // Weak references don't produce any output by themselves.
4127 if (Global->hasAttr<WeakRefAttr>())
4128 return;
4129
4130 // If this is an alias definition (which otherwise looks like a declaration)
4131 // emit it now.
4132 if (Global->hasAttr<AliasAttr>())
4133 return EmitAliasDefinition(GD);
4134
4135 // IFunc like an alias whose value is resolved at runtime by calling resolver.
4136 if (Global->hasAttr<IFuncAttr>())
4137 return emitIFuncDefinition(GD);
4138
4139 // If this is a cpu_dispatch multiversion function, emit the resolver.
4140 if (Global->hasAttr<CPUDispatchAttr>())
4141 return emitCPUDispatchDefinition(GD);
4142
4143 // If this is CUDA, be selective about which declarations we emit.
4144 // Non-constexpr non-lambda implicit host device functions are not emitted
4145 // unless they are used on device side.
4146 if (LangOpts.CUDA) {
4148 "Expected Variable or Function");
4149 if (const auto *VD = dyn_cast<VarDecl>(Global)) {
4150 if (!shouldEmitCUDAGlobalVar(VD))
4151 return;
4152 } else if (LangOpts.CUDAIsDevice) {
4153 const auto *FD = dyn_cast<FunctionDecl>(Global);
4154 if ((!Global->hasAttr<CUDADeviceAttr>() ||
4155 (LangOpts.OffloadImplicitHostDeviceTemplates &&
4158 !isLambdaCallOperator(FD) &&
4159 !getContext().CUDAImplicitHostDeviceFunUsedByDevice.count(FD))) &&
4160 !Global->hasAttr<CUDAGlobalAttr>() &&
4161 !(LangOpts.HIPStdPar && isa<FunctionDecl>(Global) &&
4162 !Global->hasAttr<CUDAHostAttr>()))
4163 return;
4164 // Device-only functions are the only things we skip.
4165 } else if (!Global->hasAttr<CUDAHostAttr>() &&
4166 Global->hasAttr<CUDADeviceAttr>())
4167 return;
4168 }
4169
4170 if (LangOpts.OpenMP) {
4171 // If this is OpenMP, check if it is legal to emit this global normally.
4172 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
4173 return;
4174 if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) {
4175 if (MustBeEmitted(Global))
4177 return;
4178 }
4179 if (auto *DMD = dyn_cast<OMPDeclareMapperDecl>(Global)) {
4180 if (MustBeEmitted(Global))
4182 return;
4183 }
4184 }
4185
4186 // Ignore declarations, they will be emitted on their first use.
4187 if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
4188 if (DeviceKernelAttr::isOpenCLSpelling(FD->getAttr<DeviceKernelAttr>()) &&
4190 addDeferredDeclToEmit(GlobalDecl(FD, KernelReferenceKind::Stub));
4191
4192 // Update deferred annotations with the latest declaration if the function
4193 // function was already used or defined.
4194 if (FD->hasAttr<AnnotateAttr>()) {
4195 StringRef MangledName = getMangledName(GD);
4196 if (GetGlobalValue(MangledName))
4197 DeferredAnnotations[MangledName] = FD;
4198 }
4199
4200 // Forward declarations are emitted lazily on first use.
4201 if (!FD->doesThisDeclarationHaveABody()) {
4203 (!FD->isMultiVersion() || !getTarget().getTriple().isAArch64()))
4204 return;
4205
4206 StringRef MangledName = getMangledName(GD);
4207
4208 // Compute the function info and LLVM type.
4210 llvm::Type *Ty = getTypes().GetFunctionType(FI);
4211
4212 GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false,
4213 /*DontDefer=*/false);
4214 return;
4215 }
4216 } else {
4217 const auto *VD = cast<VarDecl>(Global);
4218 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
4219 if (VD->isThisDeclarationADefinition() != VarDecl::Definition &&
4220 !Context.isMSStaticDataMemberInlineDefinition(VD)) {
4221 if (LangOpts.OpenMP) {
4222 // Emit declaration of the must-be-emitted declare target variable.
4223 if (std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
4224 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
4225
4226 // If this variable has external storage and doesn't require special
4227 // link handling we defer to its canonical definition.
4228 if (VD->hasExternalStorage() &&
4229 Res != OMPDeclareTargetDeclAttr::MT_Link)
4230 return;
4231
4232 bool UnifiedMemoryEnabled =
4234 if ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
4235 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
4236 !UnifiedMemoryEnabled) {
4237 (void)GetAddrOfGlobalVar(VD);
4238 } else {
4239 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
4240 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
4241 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
4242 UnifiedMemoryEnabled)) &&
4243 "Link clause or to clause with unified memory expected.");
4245 }
4246
4247 return;
4248 }
4249 }
4250 // If this declaration may have caused an inline variable definition to
4251 // change linkage, make sure that it's emitted.
4252 if (Context.getInlineVariableDefinitionKind(VD) ==
4255 return;
4256 }
4257 }
4258
4259 // Defer code generation to first use when possible, e.g. if this is an inline
4260 // function. If the global must always be emitted, do it eagerly if possible
4261 // to benefit from cache locality.
4262 if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
4263 // Emit the definition if it can't be deferred.
4264 EmitGlobalDefinition(GD);
4265 addEmittedDeferredDecl(GD);
4266 return;
4267 }
4268
4269 // If we're deferring emission of a C++ variable with an
4270 // initializer, remember the order in which it appeared in the file.
4272 cast<VarDecl>(Global)->hasInit()) {
4273 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
4274 CXXGlobalInits.push_back(nullptr);
4275 }
4276
4277 StringRef MangledName = getMangledName(GD);
4278 if (GetGlobalValue(MangledName) != nullptr) {
4279 // The value has already been used and should therefore be emitted.
4280 addDeferredDeclToEmit(GD);
4281 } else if (MustBeEmitted(Global)) {
4282 // The value must be emitted, but cannot be emitted eagerly.
4283 assert(!MayBeEmittedEagerly(Global));
4284 addDeferredDeclToEmit(GD);
4285 } else {
4286 // Otherwise, remember that we saw a deferred decl with this name. The
4287 // first use of the mangled name will cause it to move into
4288 // DeferredDeclsToEmit.
4289 DeferredDecls[MangledName] = GD;
4290 }
4291}
4292
4293// Check if T is a class type with a destructor that's not dllimport.
4295 if (const auto *RT =
4296 T->getBaseElementTypeUnsafe()->getAsCanonical<RecordType>())
4297 if (auto *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4298 RD = RD->getDefinitionOrSelf();
4299 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
4300 return true;
4301 }
4302
4303 return false;
4304}
4305
4306namespace {
4307 struct FunctionIsDirectlyRecursive
4308 : public ConstStmtVisitor<FunctionIsDirectlyRecursive, bool> {
4309 const StringRef Name;
4310 const Builtin::Context &BI;
4311 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C)
4312 : Name(N), BI(C) {}
4313
4314 bool VisitCallExpr(const CallExpr *E) {
4315 const FunctionDecl *FD = E->getDirectCallee();
4316 if (!FD)
4317 return false;
4318 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
4319 if (Attr && Name == Attr->getLabel())
4320 return true;
4321 unsigned BuiltinID = FD->getBuiltinID();
4322 if (!BuiltinID || !BI.isLibFunction(BuiltinID))
4323 return false;
4324 std::string BuiltinNameStr = BI.getName(BuiltinID);
4325 StringRef BuiltinName = BuiltinNameStr;
4326 return BuiltinName.consume_front("__builtin_") && Name == BuiltinName;
4327 }
4328
4329 bool VisitStmt(const Stmt *S) {
4330 for (const Stmt *Child : S->children())
4331 if (Child && this->Visit(Child))
4332 return true;
4333 return false;
4334 }
4335 };
4336
4337 // Make sure we're not referencing non-imported vars or functions.
4338 struct DLLImportFunctionVisitor
4339 : public RecursiveASTVisitor<DLLImportFunctionVisitor> {
4340 bool SafeToInline = true;
4341
4342 bool shouldVisitImplicitCode() const { return true; }
4343
4344 bool VisitVarDecl(VarDecl *VD) {
4345 if (VD->getTLSKind()) {
4346 // A thread-local variable cannot be imported.
4347 SafeToInline = false;
4348 return SafeToInline;
4349 }
4350
4351 // A variable definition might imply a destructor call.
4353 SafeToInline = !HasNonDllImportDtor(VD->getType());
4354
4355 return SafeToInline;
4356 }
4357
4358 bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
4359 if (const auto *D = E->getTemporary()->getDestructor())
4360 SafeToInline = D->hasAttr<DLLImportAttr>();
4361 return SafeToInline;
4362 }
4363
4364 bool VisitDeclRefExpr(DeclRefExpr *E) {
4365 ValueDecl *VD = E->getDecl();
4366 if (isa<FunctionDecl>(VD))
4367 SafeToInline = VD->hasAttr<DLLImportAttr>();
4368 else if (VarDecl *V = dyn_cast<VarDecl>(VD))
4369 SafeToInline = !V->hasGlobalStorage() || V->hasAttr<DLLImportAttr>();
4370 return SafeToInline;
4371 }
4372
4373 bool VisitCXXConstructExpr(CXXConstructExpr *E) {
4374 SafeToInline = E->getConstructor()->hasAttr<DLLImportAttr>();
4375 return SafeToInline;
4376 }
4377
4378 bool VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
4379 CXXMethodDecl *M = E->getMethodDecl();
4380 if (!M) {
4381 // Call through a pointer to member function. This is safe to inline.
4382 SafeToInline = true;
4383 } else {
4384 SafeToInline = M->hasAttr<DLLImportAttr>();
4385 }
4386 return SafeToInline;
4387 }
4388
4389 bool VisitCXXDeleteExpr(CXXDeleteExpr *E) {
4390 SafeToInline = E->getOperatorDelete()->hasAttr<DLLImportAttr>();
4391 return SafeToInline;
4392 }
4393
4394 bool VisitCXXNewExpr(CXXNewExpr *E) {
4395 SafeToInline = E->getOperatorNew()->hasAttr<DLLImportAttr>();
4396 return SafeToInline;
4397 }
4398 };
4399}
4400
4401// isTriviallyRecursive - Check if this function calls another
4402// decl that, because of the asm attribute or the other decl being a builtin,
4403// ends up pointing to itself.
4404bool
4405CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
4406 StringRef Name;
4407 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
4408 // asm labels are a special kind of mangling we have to support.
4409 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
4410 if (!Attr)
4411 return false;
4412 Name = Attr->getLabel();
4413 } else {
4414 Name = FD->getName();
4415 }
4416
4417 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
4418 const Stmt *Body = FD->getBody();
4419 return Body ? Walker.Visit(Body) : false;
4420}
4421
4422bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) {
4423 if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage)
4424 return true;
4425
4426 const auto *F = cast<FunctionDecl>(GD.getDecl());
4427 // Inline builtins declaration must be emitted. They often are fortified
4428 // functions.
4429 if (F->isInlineBuiltinDeclaration())
4430 return true;
4431
4432 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
4433 return false;
4434
4435 // We don't import function bodies from other named module units since that
4436 // behavior may break ABI compatibility of the current unit.
4437 if (const Module *M = F->getOwningModule();
4438 M && M->getTopLevelModule()->isNamedModule() &&
4439 getContext().getCurrentNamedModule() != M->getTopLevelModule()) {
4440 // There are practices to mark template member function as always-inline
4441 // and mark the template as extern explicit instantiation but not give
4442 // the definition for member function. So we have to emit the function
4443 // from explicitly instantiation with always-inline.
4444 //
4445 // See https://github.com/llvm/llvm-project/issues/86893 for details.
4446 //
4447 // TODO: Maybe it is better to give it a warning if we call a non-inline
4448 // function from other module units which is marked as always-inline.
4449 if (!F->isTemplateInstantiation() || !F->hasAttr<AlwaysInlineAttr>()) {
4450 return false;
4451 }
4452 }
4453
4454 if (F->hasAttr<NoInlineAttr>())
4455 return false;
4456
4457 if (F->hasAttr<DLLImportAttr>() && !F->hasAttr<AlwaysInlineAttr>()) {
4458 // Check whether it would be safe to inline this dllimport function.
4459 DLLImportFunctionVisitor Visitor;
4460 Visitor.TraverseFunctionDecl(const_cast<FunctionDecl*>(F));
4461 if (!Visitor.SafeToInline)
4462 return false;
4463
4464 if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(F)) {
4465 // Implicit destructor invocations aren't captured in the AST, so the
4466 // check above can't see them. Check for them manually here.
4467 for (const Decl *Member : Dtor->getParent()->decls())
4470 return false;
4471 for (const CXXBaseSpecifier &B : Dtor->getParent()->bases())
4472 if (HasNonDllImportDtor(B.getType()))
4473 return false;
4474 }
4475 }
4476
4477 // PR9614. Avoid cases where the source code is lying to us. An available
4478 // externally function should have an equivalent function somewhere else,
4479 // but a function that calls itself through asm label/`__builtin_` trickery is
4480 // clearly not equivalent to the real implementation.
4481 // This happens in glibc's btowc and in some configure checks.
4482 return !isTriviallyRecursive(F);
4483}
4484
4485bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
4486 return CodeGenOpts.OptimizationLevel > 0;
4487}
4488
4489void CodeGenModule::EmitMultiVersionFunctionDefinition(GlobalDecl GD,
4490 llvm::GlobalValue *GV) {
4491 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4492
4493 if (FD->isCPUSpecificMultiVersion()) {
4494 auto *Spec = FD->getAttr<CPUSpecificAttr>();
4495 for (unsigned I = 0; I < Spec->cpus_size(); ++I)
4496 EmitGlobalFunctionDefinition(GD.getWithMultiVersionIndex(I), nullptr);
4497 } else if (auto *TC = FD->getAttr<TargetClonesAttr>()) {
4498 for (unsigned I = 0; I < TC->featuresStrs_size(); ++I)
4499 if (TC->isFirstOfVersion(I))
4500 EmitGlobalFunctionDefinition(GD.getWithMultiVersionIndex(I), nullptr);
4501 } else
4502 EmitGlobalFunctionDefinition(GD, GV);
4503
4504 // Ensure that the resolver function is also emitted.
4506 // On AArch64 defer the resolver emission until the entire TU is processed.
4507 if (getTarget().getTriple().isAArch64())
4508 AddDeferredMultiVersionResolverToEmit(GD);
4509 else
4510 GetOrCreateMultiVersionResolver(GD);
4511 }
4512}
4513
4514void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
4515 const auto *D = cast<ValueDecl>(GD.getDecl());
4516
4517 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
4518 Context.getSourceManager(),
4519 "Generating code for declaration");
4520
4521 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
4522 // At -O0, don't generate IR for functions with available_externally
4523 // linkage.
4524 if (!shouldEmitFunction(GD))
4525 return;
4526
4527 llvm::TimeTraceScope TimeScope("CodeGen Function", [&]() {
4528 std::string Name;
4529 llvm::raw_string_ostream OS(Name);
4530 FD->getNameForDiagnostic(OS, getContext().getPrintingPolicy(),
4531 /*Qualified=*/true);
4532 return Name;
4533 });
4534
4535 if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
4536 // Make sure to emit the definition(s) before we emit the thunks.
4537 // This is necessary for the generation of certain thunks.
4539 ABI->emitCXXStructor(GD);
4540 else if (FD->isMultiVersion())
4541 EmitMultiVersionFunctionDefinition(GD, GV);
4542 else
4543 EmitGlobalFunctionDefinition(GD, GV);
4544
4545 if (Method->isVirtual())
4546 getVTables().EmitThunks(GD);
4547
4548 return;
4549 }
4550
4551 if (FD->isMultiVersion())
4552 return EmitMultiVersionFunctionDefinition(GD, GV);
4553 return EmitGlobalFunctionDefinition(GD, GV);
4554 }
4555
4556 if (const auto *VD = dyn_cast<VarDecl>(D))
4557 return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
4558
4559 llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
4560}
4561
4562static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
4563 llvm::Function *NewFn);
4564
4565static llvm::APInt
4569 if (RO.Architecture)
4570 Features.push_back(*RO.Architecture);
4571 return TI.getFMVPriority(Features);
4572}
4573
4574// Multiversion functions should be at most 'WeakODRLinkage' so that a different
4575// TU can forward declare the function without causing problems. Particularly
4576// in the cases of CPUDispatch, this causes issues. This also makes sure we
4577// work with internal linkage functions, so that the same function name can be
4578// used with internal linkage in multiple TUs.
4579static llvm::GlobalValue::LinkageTypes
4581 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
4583 return llvm::GlobalValue::InternalLinkage;
4584 return llvm::GlobalValue::WeakODRLinkage;
4585}
4586
4587void CodeGenModule::emitMultiVersionFunctions() {
4588 std::vector<GlobalDecl> MVFuncsToEmit;
4589 MultiVersionFuncs.swap(MVFuncsToEmit);
4590 for (GlobalDecl GD : MVFuncsToEmit) {
4591 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4592 assert(FD && "Expected a FunctionDecl");
4593
4594 auto createFunction = [&](const FunctionDecl *Decl, unsigned MVIdx = 0) {
4595 GlobalDecl CurGD{Decl->isDefined() ? Decl->getDefinition() : Decl, MVIdx};
4596 StringRef MangledName = getMangledName(CurGD);
4597 llvm::Constant *Func = GetGlobalValue(MangledName);
4598 if (!Func) {
4599 if (Decl->isDefined()) {
4600 EmitGlobalFunctionDefinition(CurGD, nullptr);
4601 Func = GetGlobalValue(MangledName);
4602 } else {
4603 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(CurGD);
4604 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
4605 Func = GetAddrOfFunction(CurGD, Ty, /*ForVTable=*/false,
4606 /*DontDefer=*/false, ForDefinition);
4607 }
4608 assert(Func && "This should have just been created");
4609 }
4610 return cast<llvm::Function>(Func);
4611 };
4612
4613 // For AArch64, a resolver is only emitted if a function marked with
4614 // target_version("default")) or target_clones("default") is defined
4615 // in this TU. For other architectures it is always emitted.
4616 bool ShouldEmitResolver = !getTarget().getTriple().isAArch64();
4617 SmallVector<CodeGenFunction::FMVResolverOption, 10> Options;
4618
4620 FD, [&](const FunctionDecl *CurFD) {
4621 llvm::SmallVector<StringRef, 8> Feats;
4622 bool IsDefined = CurFD->getDefinition() != nullptr;
4623
4624 if (const auto *TA = CurFD->getAttr<TargetAttr>()) {
4625 assert(getTarget().getTriple().isX86() && "Unsupported target");
4626 TA->getX86AddedFeatures(Feats);
4627 llvm::Function *Func = createFunction(CurFD);
4628 Options.emplace_back(Func, Feats, TA->getX86Architecture());
4629 } else if (const auto *TVA = CurFD->getAttr<TargetVersionAttr>()) {
4630 if (TVA->isDefaultVersion() && IsDefined)
4631 ShouldEmitResolver = true;
4632 llvm::Function *Func = createFunction(CurFD);
4633 char Delim = getTarget().getTriple().isAArch64() ? '+' : ',';
4634 TVA->getFeatures(Feats, Delim);
4635 Options.emplace_back(Func, Feats);
4636 } else if (const auto *TC = CurFD->getAttr<TargetClonesAttr>()) {
4637 for (unsigned I = 0; I < TC->featuresStrs_size(); ++I) {
4638 if (!TC->isFirstOfVersion(I))
4639 continue;
4640 if (TC->isDefaultVersion(I) && IsDefined)
4641 ShouldEmitResolver = true;
4642 llvm::Function *Func = createFunction(CurFD, I);
4643 Feats.clear();
4644 if (getTarget().getTriple().isX86()) {
4645 TC->getX86Feature(Feats, I);
4646 Options.emplace_back(Func, Feats, TC->getX86Architecture(I));
4647 } else {
4648 char Delim = getTarget().getTriple().isAArch64() ? '+' : ',';
4649 TC->getFeatures(Feats, I, Delim);
4650 Options.emplace_back(Func, Feats);
4651 }
4652 }
4653 } else
4654 llvm_unreachable("unexpected MultiVersionKind");
4655 });
4656
4657 if (!ShouldEmitResolver)
4658 continue;
4659
4660 llvm::Constant *ResolverConstant = GetOrCreateMultiVersionResolver(GD);
4661 if (auto *IFunc = dyn_cast<llvm::GlobalIFunc>(ResolverConstant)) {
4662 ResolverConstant = IFunc->getResolver();
4663 if (FD->isTargetClonesMultiVersion() &&
4664 !getTarget().getTriple().isAArch64()) {
4665 std::string MangledName = getMangledNameImpl(
4666 *this, GD, FD, /*OmitMultiVersionMangling=*/true);
4667 if (!GetGlobalValue(MangledName + ".ifunc")) {
4668 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
4669 llvm::FunctionType *DeclTy = getTypes().GetFunctionType(FI);
4670 // In prior versions of Clang, the mangling for ifuncs incorrectly
4671 // included an .ifunc suffix. This alias is generated for backward
4672 // compatibility. It is deprecated, and may be removed in the future.
4673 auto *Alias = llvm::GlobalAlias::create(
4674 DeclTy, 0, getMultiversionLinkage(*this, GD),
4675 MangledName + ".ifunc", IFunc, &getModule());
4676 SetCommonAttributes(FD, Alias);
4677 }
4678 }
4679 }
4680 llvm::Function *ResolverFunc = cast<llvm::Function>(ResolverConstant);
4681
4682 const TargetInfo &TI = getTarget();
4683 llvm::stable_sort(
4684 Options, [&TI](const CodeGenFunction::FMVResolverOption &LHS,
4685 const CodeGenFunction::FMVResolverOption &RHS) {
4686 return getFMVPriority(TI, LHS).ugt(getFMVPriority(TI, RHS));
4687 });
4688 CodeGenFunction CGF(*this);
4689 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4690
4691 setMultiVersionResolverAttributes(ResolverFunc, GD);
4692 if (!ResolverFunc->hasLocalLinkage() && supportsCOMDAT())
4693 ResolverFunc->setComdat(
4694 getModule().getOrInsertComdat(ResolverFunc->getName()));
4695 }
4696
4697 // Ensure that any additions to the deferred decls list caused by emitting a
4698 // variant are emitted. This can happen when the variant itself is inline and
4699 // calls a function without linkage.
4700 if (!MVFuncsToEmit.empty())
4701 EmitDeferred();
4702
4703 // Ensure that any additions to the multiversion funcs list from either the
4704 // deferred decls or the multiversion functions themselves are emitted.
4705 if (!MultiVersionFuncs.empty())
4706 emitMultiVersionFunctions();
4707}
4708
4709static void replaceDeclarationWith(llvm::GlobalValue *Old,
4710 llvm::Constant *New) {
4711 assert(cast<llvm::Function>(Old)->isDeclaration() && "Not a declaration");
4712 New->takeName(Old);
4713 Old->replaceAllUsesWith(New);
4714 Old->eraseFromParent();
4715}
4716
4717void CodeGenModule::emitCPUDispatchDefinition(GlobalDecl GD) {
4718 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4719 assert(FD && "Not a FunctionDecl?");
4720 assert(FD->isCPUDispatchMultiVersion() && "Not a multiversion function?");
4721 const auto *DD = FD->getAttr<CPUDispatchAttr>();
4722 assert(DD && "Not a cpu_dispatch Function?");
4723
4724 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
4725 llvm::FunctionType *DeclTy = getTypes().GetFunctionType(FI);
4726
4727 StringRef ResolverName = getMangledName(GD);
4728 UpdateMultiVersionNames(GD, FD, ResolverName);
4729
4730 llvm::Type *ResolverType;
4731 GlobalDecl ResolverGD;
4732 if (getTarget().supportsIFunc()) {
4733 ResolverType = llvm::FunctionType::get(
4734 llvm::PointerType::get(getLLVMContext(),
4735 getTypes().getTargetAddressSpace(FD->getType())),
4736 false);
4737 }
4738 else {
4739 ResolverType = DeclTy;
4740 ResolverGD = GD;
4741 }
4742
4743 auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
4744 ResolverName, ResolverType, ResolverGD, /*ForVTable=*/false));
4745
4746 if (supportsCOMDAT())
4747 ResolverFunc->setComdat(
4748 getModule().getOrInsertComdat(ResolverFunc->getName()));
4749
4750 SmallVector<CodeGenFunction::FMVResolverOption, 10> Options;
4751 const TargetInfo &Target = getTarget();
4752 unsigned Index = 0;
4753 for (const IdentifierInfo *II : DD->cpus()) {
4754 // Get the name of the target function so we can look it up/create it.
4755 std::string MangledName = getMangledNameImpl(*this, GD, FD, true) +
4756 getCPUSpecificMangling(*this, II->getName());
4757
4758 llvm::Constant *Func = GetGlobalValue(MangledName);
4759
4760 if (!Func) {
4761 GlobalDecl ExistingDecl = Manglings.lookup(MangledName);
4762 if (ExistingDecl.getDecl() &&
4763 ExistingDecl.getDecl()->getAsFunction()->isDefined()) {
4764 EmitGlobalFunctionDefinition(ExistingDecl, nullptr);
4765 Func = GetGlobalValue(MangledName);
4766 } else {
4767 if (!ExistingDecl.getDecl())
4768 ExistingDecl = GD.getWithMultiVersionIndex(Index);
4769
4770 Func = GetOrCreateLLVMFunction(
4771 MangledName, DeclTy, ExistingDecl,
4772 /*ForVTable=*/false, /*DontDefer=*/true,
4773 /*IsThunk=*/false, llvm::AttributeList(), ForDefinition);
4774 }
4775 }
4776
4777 llvm::SmallVector<StringRef, 32> Features;
4778 Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);
4779 llvm::transform(Features, Features.begin(),
4780 [](StringRef Str) { return Str.substr(1); });
4781 llvm::erase_if(Features, [&Target](StringRef Feat) {
4782 return !Target.validateCpuSupports(Feat);
4783 });
4784 Options.emplace_back(cast<llvm::Function>(Func), Features);
4785 ++Index;
4786 }
4787
4788 llvm::stable_sort(Options, [](const CodeGenFunction::FMVResolverOption &LHS,
4789 const CodeGenFunction::FMVResolverOption &RHS) {
4790 return llvm::X86::getCpuSupportsMask(LHS.Features) >
4791 llvm::X86::getCpuSupportsMask(RHS.Features);
4792 });
4793
4794 // If the list contains multiple 'default' versions, such as when it contains
4795 // 'pentium' and 'generic', don't emit the call to the generic one (since we
4796 // always run on at least a 'pentium'). We do this by deleting the 'least
4797 // advanced' (read, lowest mangling letter).
4798 while (Options.size() > 1 && llvm::all_of(llvm::X86::getCpuSupportsMask(
4799 (Options.end() - 2)->Features),
4800 [](auto X) { return X == 0; })) {
4801 StringRef LHSName = (Options.end() - 2)->Function->getName();
4802 StringRef RHSName = (Options.end() - 1)->Function->getName();
4803 if (LHSName.compare(RHSName) < 0)
4804 Options.erase(Options.end() - 2);
4805 else
4806 Options.erase(Options.end() - 1);
4807 }
4808
4809 CodeGenFunction CGF(*this);
4810 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4811 setMultiVersionResolverAttributes(ResolverFunc, GD);
4812
4813 if (getTarget().supportsIFunc()) {
4814 llvm::GlobalValue::LinkageTypes Linkage = getMultiversionLinkage(*this, GD);
4815 auto *IFunc = cast<llvm::GlobalValue>(GetOrCreateMultiVersionResolver(GD));
4816 unsigned AS = IFunc->getType()->getPointerAddressSpace();
4817
4818 // Fix up function declarations that were created for cpu_specific before
4819 // cpu_dispatch was known
4820 if (!isa<llvm::GlobalIFunc>(IFunc)) {
4821 auto *GI = llvm::GlobalIFunc::create(DeclTy, AS, Linkage, "",
4822 ResolverFunc, &getModule());
4823 replaceDeclarationWith(IFunc, GI);
4824 IFunc = GI;
4825 }
4826
4827 std::string AliasName = getMangledNameImpl(
4828 *this, GD, FD, /*OmitMultiVersionMangling=*/true);
4829 llvm::Constant *AliasFunc = GetGlobalValue(AliasName);
4830 if (!AliasFunc) {
4831 auto *GA = llvm::GlobalAlias::create(DeclTy, AS, Linkage, AliasName,
4832 IFunc, &getModule());
4833 SetCommonAttributes(GD, GA);
4834 }
4835 }
4836}
4837
4838/// Adds a declaration to the list of multi version functions if not present.
4839void CodeGenModule::AddDeferredMultiVersionResolverToEmit(GlobalDecl GD) {
4840 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4841 assert(FD && "Not a FunctionDecl?");
4842
4844 std::string MangledName =
4845 getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true);
4846 if (!DeferredResolversToEmit.insert(MangledName).second)
4847 return;
4848 }
4849 MultiVersionFuncs.push_back(GD);
4850}
4851
4852/// If a dispatcher for the specified mangled name is not in the module, create
4853/// and return it. The dispatcher is either an llvm Function with the specified
4854/// type, or a global ifunc.
4855llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(GlobalDecl GD) {
4856 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4857 assert(FD && "Not a FunctionDecl?");
4858
4859 std::string MangledName =
4860 getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true);
4861
4862 // Holds the name of the resolver, in ifunc mode this is the ifunc (which has
4863 // a separate resolver).
4864 std::string ResolverName = MangledName;
4865 if (getTarget().supportsIFunc()) {
4866 switch (FD->getMultiVersionKind()) {
4868 llvm_unreachable("unexpected MultiVersionKind::None for resolver");
4872 ResolverName += ".ifunc";
4873 break;
4876 break;
4877 }
4878 } else if (FD->isTargetMultiVersion()) {
4879 ResolverName += ".resolver";
4880 }
4881
4882 bool ShouldReturnIFunc =
4884
4885 // If the resolver has already been created, just return it. This lookup may
4886 // yield a function declaration instead of a resolver on AArch64. That is
4887 // because we didn't know whether a resolver will be generated when we first
4888 // encountered a use of the symbol named after this resolver. Therefore,
4889 // targets which support ifuncs should not return here unless we actually
4890 // found an ifunc.
4891 llvm::GlobalValue *ResolverGV = GetGlobalValue(ResolverName);
4892 if (ResolverGV && (isa<llvm::GlobalIFunc>(ResolverGV) || !ShouldReturnIFunc))
4893 return ResolverGV;
4894
4895 const CGFunctionInfo &FI = getTypes().arrangeGlobalDeclaration(GD);
4896 llvm::FunctionType *DeclTy = getTypes().GetFunctionType(FI);
4897
4898 // The resolver needs to be created. For target and target_clones, defer
4899 // creation until the end of the TU.
4901 AddDeferredMultiVersionResolverToEmit(GD);
4902
4903 // For cpu_specific, don't create an ifunc yet because we don't know if the
4904 // cpu_dispatch will be emitted in this translation unit.
4905 if (ShouldReturnIFunc) {
4906 unsigned AS = getTypes().getTargetAddressSpace(FD->getType());
4907 llvm::Type *ResolverType = llvm::FunctionType::get(
4908 llvm::PointerType::get(getLLVMContext(), AS), false);
4909 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4910 MangledName + ".resolver", ResolverType, GlobalDecl{},
4911 /*ForVTable=*/false);
4912 llvm::GlobalIFunc *GIF =
4913 llvm::GlobalIFunc::create(DeclTy, AS, getMultiversionLinkage(*this, GD),
4914 "", Resolver, &getModule());
4915 GIF->setName(ResolverName);
4916 SetCommonAttributes(FD, GIF);
4917 if (ResolverGV)
4918 replaceDeclarationWith(ResolverGV, GIF);
4919 return GIF;
4920 }
4921
4922 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4923 ResolverName, DeclTy, GlobalDecl{}, /*ForVTable=*/false);
4924 assert(isa<llvm::GlobalValue>(Resolver) && !ResolverGV &&
4925 "Resolver should be created for the first time");
4927 return Resolver;
4928}
4929
4930void CodeGenModule::setMultiVersionResolverAttributes(llvm::Function *Resolver,
4931 GlobalDecl GD) {
4932 const NamedDecl *D = dyn_cast_or_null<NamedDecl>(GD.getDecl());
4933 Resolver->setLinkage(getMultiversionLinkage(*this, GD));
4934
4935 // Function body has to be emitted before calling setGlobalVisibility
4936 // for Resolver to be considered as definition.
4937 setGlobalVisibility(Resolver, D);
4938
4939 setDSOLocal(Resolver);
4940
4941 // Set the default target-specific attributes, such as PAC and BTI ones on
4942 // AArch64. Not passing Decl to prevent setting unrelated attributes,
4943 // as Resolver can be shared by multiple declarations.
4944 // FIXME Some targets may require a non-null D to set some attributes
4945 // (such as "stackrealign" on X86, even when it is requested via
4946 // "-mstackrealign" command line option).
4947 getTargetCodeGenInfo().setTargetAttributes(/*D=*/nullptr, Resolver, *this);
4948}
4949
4950bool CodeGenModule::shouldDropDLLAttribute(const Decl *D,
4951 const llvm::GlobalValue *GV) const {
4952 auto SC = GV->getDLLStorageClass();
4953 if (SC == llvm::GlobalValue::DefaultStorageClass)
4954 return false;
4955 const Decl *MRD = D->getMostRecentDecl();
4956 return (((SC == llvm::GlobalValue::DLLImportStorageClass &&
4957 !MRD->hasAttr<DLLImportAttr>()) ||
4958 (SC == llvm::GlobalValue::DLLExportStorageClass &&
4959 !MRD->hasAttr<DLLExportAttr>())) &&
4961}
4962
4963/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
4964/// module, create and return an llvm Function with the specified type. If there
4965/// is something in the module with the specified name, return it potentially
4966/// bitcasted to the right type.
4967///
4968/// If D is non-null, it specifies a decl that correspond to this. This is used
4969/// to set the attributes on the function when it is first created.
4970llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
4971 StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable,
4972 bool DontDefer, bool IsThunk, llvm::AttributeList ExtraAttrs,
4973 ForDefinition_t IsForDefinition) {
4974 const Decl *D = GD.getDecl();
4975
4976 std::string NameWithoutMultiVersionMangling;
4977 if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
4978 // For the device mark the function as one that should be emitted.
4979 if (getLangOpts().OpenMPIsTargetDevice && OpenMPRuntime &&
4980 !OpenMPRuntime->markAsGlobalTarget(GD) && FD->isDefined() &&
4981 !DontDefer && !IsForDefinition) {
4982 if (const FunctionDecl *FDDef = FD->getDefinition()) {
4983 GlobalDecl GDDef;
4984 if (const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
4985 GDDef = GlobalDecl(CD, GD.getCtorType());
4986 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
4987 GDDef = GlobalDecl(DD, GD.getDtorType());
4988 else
4989 GDDef = GlobalDecl(FDDef);
4990 EmitGlobal(GDDef);
4991 }
4992 }
4993
4994 // Any attempts to use a MultiVersion function should result in retrieving
4995 // the iFunc instead. Name Mangling will handle the rest of the changes.
4996 if (FD->isMultiVersion()) {
4997 UpdateMultiVersionNames(GD, FD, MangledName);
4998 if (!IsForDefinition) {
4999 // On AArch64 we do not immediatelly emit an ifunc resolver when a
5000 // function is used. Instead we defer the emission until we see a
5001 // default definition. In the meantime we just reference the symbol
5002 // without FMV mangling (it may or may not be replaced later).
5003 if (getTarget().getTriple().isAArch64()) {
5004 AddDeferredMultiVersionResolverToEmit(GD);
5005 NameWithoutMultiVersionMangling = getMangledNameImpl(
5006 *this, GD, FD, /*OmitMultiVersionMangling=*/true);
5007 } else
5008 return GetOrCreateMultiVersionResolver(GD);
5009 }
5010 }
5011 }
5012
5013 if (!NameWithoutMultiVersionMangling.empty())
5014 MangledName = NameWithoutMultiVersionMangling;
5015
5016 // Lookup the entry, lazily creating it if necessary.
5017 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
5018 if (Entry) {
5019 if (WeakRefReferences.erase(Entry)) {
5020 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
5021 if (FD && !FD->hasAttr<WeakAttr>())
5022 Entry->setLinkage(llvm::Function::ExternalLinkage);
5023 }
5024
5025 // Handle dropped DLL attributes.
5026 if (D && shouldDropDLLAttribute(D, Entry)) {
5027 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
5028 setDSOLocal(Entry);
5029 }
5030
5031 // If there are two attempts to define the same mangled name, issue an
5032 // error.
5033 if (IsForDefinition && !Entry->isDeclaration()) {
5034 GlobalDecl OtherGD;
5035 // Check that GD is not yet in DiagnosedConflictingDefinitions is required
5036 // to make sure that we issue an error only once.
5037 if (lookupRepresentativeDecl(MangledName, OtherGD) &&
5038 (GD.getCanonicalDecl().getDecl() !=
5039 OtherGD.getCanonicalDecl().getDecl()) &&
5040 DiagnosedConflictingDefinitions.insert(GD).second) {
5041 getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name)
5042 << MangledName;
5043 getDiags().Report(OtherGD.getDecl()->getLocation(),
5044 diag::note_previous_definition);
5045 }
5046 }
5047
5048 if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
5049 (Entry->getValueType() == Ty)) {
5050 return Entry;
5051 }
5052
5053 // Make sure the result is of the correct type.
5054 // (If function is requested for a definition, we always need to create a new
5055 // function, not just return a bitcast.)
5056 if (!IsForDefinition)
5057 return Entry;
5058 }
5059
5060 // This function doesn't have a complete type (for example, the return
5061 // type is an incomplete struct). Use a fake type instead, and make
5062 // sure not to try to set attributes.
5063 bool IsIncompleteFunction = false;
5064
5065 llvm::FunctionType *FTy;
5066 if (isa<llvm::FunctionType>(Ty)) {
5067 FTy = cast<llvm::FunctionType>(Ty);
5068 } else {
5069 FTy = llvm::FunctionType::get(VoidTy, false);
5070 IsIncompleteFunction = true;
5071 }
5072
5073 llvm::Function *F =
5074 llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
5075 Entry ? StringRef() : MangledName, &getModule());
5076
5077 // Store the declaration associated with this function so it is potentially
5078 // updated by further declarations or definitions and emitted at the end.
5079 if (D && D->hasAttr<AnnotateAttr>())
5080 DeferredAnnotations[MangledName] = cast<ValueDecl>(D);
5081
5082 // If we already created a function with the same mangled name (but different
5083 // type) before, take its name and add it to the list of functions to be
5084 // replaced with F at the end of CodeGen.
5085 //
5086 // This happens if there is a prototype for a function (e.g. "int f()") and
5087 // then a definition of a different type (e.g. "int f(int x)").
5088 if (Entry) {
5089 F->takeName(Entry);
5090
5091 // This might be an implementation of a function without a prototype, in
5092 // which case, try to do special replacement of calls which match the new
5093 // prototype. The really key thing here is that we also potentially drop
5094 // arguments from the call site so as to make a direct call, which makes the
5095 // inliner happier and suppresses a number of optimizer warnings (!) about
5096 // dropping arguments.
5097 if (!Entry->use_empty()) {
5099 Entry->removeDeadConstantUsers();
5100 }
5101
5102 addGlobalValReplacement(Entry, F);
5103 }
5104
5105 assert(F->getName() == MangledName && "name was uniqued!");
5106 if (D)
5107 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
5108 if (ExtraAttrs.hasFnAttrs()) {
5109 llvm::AttrBuilder B(F->getContext(), ExtraAttrs.getFnAttrs());
5110 F->addFnAttrs(B);
5111 }
5112
5113 if (!DontDefer) {
5114 // All MSVC dtors other than the base dtor are linkonce_odr and delegate to
5115 // each other bottoming out with the base dtor. Therefore we emit non-base
5116 // dtors on usage, even if there is no dtor definition in the TU.
5117 if (isa_and_nonnull<CXXDestructorDecl>(D) &&
5118 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
5119 GD.getDtorType()))
5120 addDeferredDeclToEmit(GD);
5121
5122 // This is the first use or definition of a mangled name. If there is a
5123 // deferred decl with this name, remember that we need to emit it at the end
5124 // of the file.
5125 auto DDI = DeferredDecls.find(MangledName);
5126 if (DDI != DeferredDecls.end()) {
5127 // Move the potentially referenced deferred decl to the
5128 // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
5129 // don't need it anymore).
5130 addDeferredDeclToEmit(DDI->second);
5131 DeferredDecls.erase(DDI);
5132
5133 // Otherwise, there are cases we have to worry about where we're
5134 // using a declaration for which we must emit a definition but where
5135 // we might not find a top-level definition:
5136 // - member functions defined inline in their classes
5137 // - friend functions defined inline in some class
5138 // - special member functions with implicit definitions
5139 // If we ever change our AST traversal to walk into class methods,
5140 // this will be unnecessary.
5141 //
5142 // We also don't emit a definition for a function if it's going to be an
5143 // entry in a vtable, unless it's already marked as used.
5144 } else if (getLangOpts().CPlusPlus && D) {
5145 // Look for a declaration that's lexically in a record.
5146 for (const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
5147 FD = FD->getPreviousDecl()) {
5149 if (FD->doesThisDeclarationHaveABody()) {
5150 addDeferredDeclToEmit(GD.getWithDecl(FD));
5151 break;
5152 }
5153 }
5154 }
5155 }
5156 }
5157
5158 // Make sure the result is of the requested type.
5159 if (!IsIncompleteFunction) {
5160 assert(F->getFunctionType() == Ty);
5161 return F;
5162 }
5163
5164 return F;
5165}
5166
5167/// GetAddrOfFunction - Return the address of the given function. If Ty is
5168/// non-null, then this function will use the specified type if it has to
5169/// create it (this occurs when we see a definition of the function).
5170llvm::Constant *
5171CodeGenModule::GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty, bool ForVTable,
5172 bool DontDefer,
5173 ForDefinition_t IsForDefinition) {
5174 // If there was no specific requested type, just convert it now.
5175 if (!Ty) {
5176 const auto *FD = cast<FunctionDecl>(GD.getDecl());
5177 Ty = getTypes().ConvertType(FD->getType());
5178 if (DeviceKernelAttr::isOpenCLSpelling(FD->getAttr<DeviceKernelAttr>()) &&
5181 Ty = getTypes().GetFunctionType(FI);
5182 }
5183 }
5184
5185 // Devirtualized destructor calls may come through here instead of via
5186 // getAddrOfCXXStructor. Make sure we use the MS ABI base destructor instead
5187 // of the complete destructor when necessary.
5188 if (const auto *DD = dyn_cast<CXXDestructorDecl>(GD.getDecl())) {
5189 if (getTarget().getCXXABI().isMicrosoft() &&
5190 GD.getDtorType() == Dtor_Complete &&
5191 DD->getParent()->getNumVBases() == 0)
5192 GD = GlobalDecl(DD, Dtor_Base);
5193 }
5194
5195 StringRef MangledName = getMangledName(GD);
5196 auto *F = GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
5197 /*IsThunk=*/false, llvm::AttributeList(),
5198 IsForDefinition);
5199 // Returns kernel handle for HIP kernel stub function.
5200 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
5201 cast<FunctionDecl>(GD.getDecl())->hasAttr<CUDAGlobalAttr>()) {
5202 auto *Handle = getCUDARuntime().getKernelHandle(
5203 cast<llvm::Function>(F->stripPointerCasts()), GD);
5204 if (IsForDefinition)
5205 return F;
5206 return Handle;
5207 }
5208 return F;
5209}
5210
5212 llvm::GlobalValue *F =
5213 cast<llvm::GlobalValue>(GetAddrOfFunction(Decl)->stripPointerCasts());
5214
5215 return llvm::NoCFIValue::get(F);
5216}
5217
5218static const FunctionDecl *
5220 TranslationUnitDecl *TUDecl = C.getTranslationUnitDecl();
5222
5223 IdentifierInfo &CII = C.Idents.get(Name);
5224 for (const auto *Result : DC->lookup(&CII))
5225 if (const auto *FD = dyn_cast<FunctionDecl>(Result))
5226 return FD;
5227
5228 if (!C.getLangOpts().CPlusPlus)
5229 return nullptr;
5230
5231 // Demangle the premangled name from getTerminateFn()
5232 IdentifierInfo &CXXII =
5233 (Name == "_ZSt9terminatev" || Name == "?terminate@@YAXXZ")
5234 ? C.Idents.get("terminate")
5235 : C.Idents.get(Name);
5236
5237 for (const auto &N : {"__cxxabiv1", "std"}) {
5238 IdentifierInfo &NS = C.Idents.get(N);
5239 for (const auto *Result : DC->lookup(&NS)) {
5240 const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(Result);
5241 if (auto *LSD = dyn_cast<LinkageSpecDecl>(Result))
5242 for (const auto *Result : LSD->lookup(&NS))
5243 if ((ND = dyn_cast<NamespaceDecl>(Result)))
5244 break;
5245
5246 if (ND)
5247 for (const auto *Result : ND->lookup(&CXXII))
5248 if (const auto *FD = dyn_cast<FunctionDecl>(Result))
5249 return FD;
5250 }
5251 }
5252
5253 return nullptr;
5254}
5255
5256static void setWindowsItaniumDLLImport(CodeGenModule &CGM, bool Local,
5257 llvm::Function *F, StringRef Name) {
5258 // In Windows Itanium environments, try to mark runtime functions
5259 // dllimport. For Mingw and MSVC, don't. We don't really know if the user
5260 // will link their standard library statically or dynamically. Marking
5261 // functions imported when they are not imported can cause linker errors
5262 // and warnings.
5263 if (!Local && CGM.getTriple().isWindowsItaniumEnvironment() &&
5264 !CGM.getCodeGenOpts().LTOVisibilityPublicStd) {
5265 const FunctionDecl *FD = GetRuntimeFunctionDecl(CGM.getContext(), Name);
5266 if (!FD || FD->hasAttr<DLLImportAttr>()) {
5267 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
5268 F->setLinkage(llvm::GlobalValue::ExternalLinkage);
5269 }
5270 }
5271}
5272
5274 QualType ReturnTy, ArrayRef<QualType> ArgTys, StringRef Name,
5275 llvm::AttributeList ExtraAttrs, bool Local, bool AssumeConvergent) {
5276 if (AssumeConvergent) {
5277 ExtraAttrs =
5278 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
5279 }
5280
5281 QualType FTy = Context.getFunctionType(ReturnTy, ArgTys,
5284 Context.getCanonicalType(FTy).castAs<FunctionProtoType>());
5285 auto *ConvTy = getTypes().GetFunctionType(Info);
5286 llvm::Constant *C = GetOrCreateLLVMFunction(
5287 Name, ConvTy, GlobalDecl(), /*ForVTable=*/false,
5288 /*DontDefer=*/false, /*IsThunk=*/false, ExtraAttrs);
5289
5290 if (auto *F = dyn_cast<llvm::Function>(C)) {
5291 if (F->empty()) {
5292 SetLLVMFunctionAttributes(GlobalDecl(), Info, F, /*IsThunk*/ false);
5293 // FIXME: Set calling-conv properly in ExtProtoInfo
5294 F->setCallingConv(getRuntimeCC());
5295 setWindowsItaniumDLLImport(*this, Local, F, Name);
5296 setDSOLocal(F);
5297 }
5298 }
5299 return {ConvTy, C};
5300}
5301
5302/// CreateRuntimeFunction - Create a new runtime function with the specified
5303/// type and name.
5304llvm::FunctionCallee
5305CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name,
5306 llvm::AttributeList ExtraAttrs, bool Local,
5307 bool AssumeConvergent) {
5308 if (AssumeConvergent) {
5309 ExtraAttrs =
5310 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
5311 }
5312
5313 llvm::Constant *C =
5314 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
5315 /*DontDefer=*/false, /*IsThunk=*/false,
5316 ExtraAttrs);
5317
5318 if (auto *F = dyn_cast<llvm::Function>(C)) {
5319 if (F->empty()) {
5320 F->setCallingConv(getRuntimeCC());
5321 setWindowsItaniumDLLImport(*this, Local, F, Name);
5322 setDSOLocal(F);
5323 // FIXME: We should use CodeGenModule::SetLLVMFunctionAttributes() instead
5324 // of trying to approximate the attributes using the LLVM function
5325 // signature. The other overload of CreateRuntimeFunction does this; it
5326 // should be used for new code.
5327 markRegisterParameterAttributes(F);
5328 }
5329 }
5330
5331 return {FTy, C};
5332}
5333
5334/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
5335/// create and return an llvm GlobalVariable with the specified type and address
5336/// space. If there is something in the module with the specified name, return
5337/// it potentially bitcasted to the right type.
5338///
5339/// If D is non-null, it specifies a decl that correspond to this. This is used
5340/// to set the attributes on the global when it is first created.
5341///
5342/// If IsForDefinition is true, it is guaranteed that an actual global with
5343/// type Ty will be returned, not conversion of a variable with the same
5344/// mangled name but some other type.
5345llvm::Constant *
5346CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty,
5347 LangAS AddrSpace, const VarDecl *D,
5348 ForDefinition_t IsForDefinition) {
5349 // Lookup the entry, lazily creating it if necessary.
5350 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
5351 unsigned TargetAS = getContext().getTargetAddressSpace(AddrSpace);
5352 if (Entry) {
5353 if (WeakRefReferences.erase(Entry)) {
5354 if (D && !D->hasAttr<WeakAttr>())
5355 Entry->setLinkage(llvm::Function::ExternalLinkage);
5356 }
5357
5358 // Handle dropped DLL attributes.
5359 if (D && shouldDropDLLAttribute(D, Entry))
5360 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
5361
5362 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd && D)
5364
5365 if (Entry->getValueType() == Ty && Entry->getAddressSpace() == TargetAS)
5366 return Entry;
5367
5368 // If there are two attempts to define the same mangled name, issue an
5369 // error.
5370 if (IsForDefinition && !Entry->isDeclaration()) {
5371 GlobalDecl OtherGD;
5372 const VarDecl *OtherD;
5373
5374 // Check that D is not yet in DiagnosedConflictingDefinitions is required
5375 // to make sure that we issue an error only once.
5376 if (D && lookupRepresentativeDecl(MangledName, OtherGD) &&
5377 (D->getCanonicalDecl() != OtherGD.getCanonicalDecl().getDecl()) &&
5378 (OtherD = dyn_cast<VarDecl>(OtherGD.getDecl())) &&
5379 OtherD->hasInit() &&
5380 DiagnosedConflictingDefinitions.insert(D).second) {
5381 getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name)
5382 << MangledName;
5383 getDiags().Report(OtherGD.getDecl()->getLocation(),
5384 diag::note_previous_definition);
5385 }
5386 }
5387
5388 // Make sure the result is of the correct type.
5389 if (Entry->getType()->getAddressSpace() != TargetAS)
5390 return llvm::ConstantExpr::getAddrSpaceCast(
5391 Entry, llvm::PointerType::get(Ty->getContext(), TargetAS));
5392
5393 // (If global is requested for a definition, we always need to create a new
5394 // global, not just return a bitcast.)
5395 if (!IsForDefinition)
5396 return Entry;
5397 }
5398
5399 auto DAddrSpace = GetGlobalVarAddressSpace(D);
5400
5401 auto *GV = new llvm::GlobalVariable(
5402 getModule(), Ty, false, llvm::GlobalValue::ExternalLinkage, nullptr,
5403 MangledName, nullptr, llvm::GlobalVariable::NotThreadLocal,
5404 getContext().getTargetAddressSpace(DAddrSpace));
5405
5406 // If we already created a global with the same mangled name (but different
5407 // type) before, take its name and remove it from its parent.
5408 if (Entry) {
5409 GV->takeName(Entry);
5410
5411 if (!Entry->use_empty()) {
5412 Entry->replaceAllUsesWith(GV);
5413 }
5414
5415 Entry->eraseFromParent();
5416 }
5417
5418 // This is the first use or definition of a mangled name. If there is a
5419 // deferred decl with this name, remember that we need to emit it at the end
5420 // of the file.
5421 auto DDI = DeferredDecls.find(MangledName);
5422 if (DDI != DeferredDecls.end()) {
5423 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
5424 // list, and remove it from DeferredDecls (since we don't need it anymore).
5425 addDeferredDeclToEmit(DDI->second);
5426 DeferredDecls.erase(DDI);
5427 }
5428
5429 // Handle things which are present even on external declarations.
5430 if (D) {
5431 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
5433
5434 // FIXME: This code is overly simple and should be merged with other global
5435 // handling.
5436 GV->setConstant(D->getType().isConstantStorage(getContext(), false, false));
5437
5438 GV->setAlignment(getContext().getDeclAlign(D).getAsAlign());
5439
5440 setLinkageForGV(GV, D);
5441
5442 if (D->getTLSKind()) {
5443 if (D->getTLSKind() == VarDecl::TLS_Dynamic)
5444 CXXThreadLocals.push_back(D);
5445 setTLSMode(GV, *D);
5446 }
5447
5448 setGVProperties(GV, D);
5449
5450 // If required by the ABI, treat declarations of static data members with
5451 // inline initializers as definitions.
5452 if (getContext().isMSStaticDataMemberInlineDefinition(D)) {
5453 EmitGlobalVarDefinition(D);
5454 }
5455
5456 // Emit section information for extern variables.
5457 if (D->hasExternalStorage()) {
5458 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
5459 GV->setSection(SA->getName());
5460 }
5461
5462 // Handle XCore specific ABI requirements.
5463 if (getTriple().getArch() == llvm::Triple::xcore &&
5465 D->getType().isConstant(Context) &&
5467 GV->setSection(".cp.rodata");
5468
5469 // Handle code model attribute
5470 if (const auto *CMA = D->getAttr<CodeModelAttr>())
5471 GV->setCodeModel(CMA->getModel());
5472
5473 // Check if we a have a const declaration with an initializer, we may be
5474 // able to emit it as available_externally to expose it's value to the
5475 // optimizer.
5476 if (Context.getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
5477 D->getType().isConstQualified() && !GV->hasInitializer() &&
5478 !D->hasDefinition() && D->hasInit() && !D->hasAttr<DLLImportAttr>()) {
5479 const auto *Record =
5480 Context.getBaseElementType(D->getType())->getAsCXXRecordDecl();
5481 bool HasMutableFields = Record && Record->hasMutableFields();
5482 if (!HasMutableFields) {
5483 const VarDecl *InitDecl;
5484 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
5485 if (InitExpr) {
5486 ConstantEmitter emitter(*this);
5487 llvm::Constant *Init = emitter.tryEmitForInitializer(*InitDecl);
5488 if (Init) {
5489 auto *InitType = Init->getType();
5490 if (GV->getValueType() != InitType) {
5491 // The type of the initializer does not match the definition.
5492 // This happens when an initializer has a different type from
5493 // the type of the global (because of padding at the end of a
5494 // structure for instance).
5495 GV->setName(StringRef());
5496 // Make a new global with the correct type, this is now guaranteed
5497 // to work.
5498 auto *NewGV = cast<llvm::GlobalVariable>(
5499 GetAddrOfGlobalVar(D, InitType, IsForDefinition)
5500 ->stripPointerCasts());
5501
5502 // Erase the old global, since it is no longer used.
5503 GV->eraseFromParent();
5504 GV = NewGV;
5505 } else {
5506 GV->setInitializer(Init);
5507 GV->setConstant(true);
5508 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
5509 }
5510 emitter.finalize(GV);
5511 }
5512 }
5513 }
5514 }
5515 }
5516
5517 if (D &&
5520 // External HIP managed variables needed to be recorded for transformation
5521 // in both device and host compilations.
5522 if (getLangOpts().CUDA && D && D->hasAttr<HIPManagedAttr>() &&
5523 D->hasExternalStorage())
5525 }
5526
5527 if (D)
5528 SanitizerMD->reportGlobal(GV, *D);
5529
5530 LangAS ExpectedAS =
5531 D ? D->getType().getAddressSpace()
5532 : (LangOpts.OpenCL ? LangAS::opencl_global : LangAS::Default);
5533 assert(getContext().getTargetAddressSpace(ExpectedAS) == TargetAS);
5534 if (DAddrSpace != ExpectedAS) {
5536 *this, GV, DAddrSpace,
5537 llvm::PointerType::get(getLLVMContext(), TargetAS));
5538 }
5539
5540 return GV;
5541}
5542
5543llvm::Constant *
5545 const Decl *D = GD.getDecl();
5546
5548 return getAddrOfCXXStructor(GD, /*FnInfo=*/nullptr, /*FnType=*/nullptr,
5549 /*DontDefer=*/false, IsForDefinition);
5550
5551 if (isa<CXXMethodDecl>(D)) {
5552 auto FInfo =
5554 auto Ty = getTypes().GetFunctionType(*FInfo);
5555 return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
5556 IsForDefinition);
5557 }
5558
5559 if (isa<FunctionDecl>(D)) {
5561 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
5562 return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
5563 IsForDefinition);
5564 }
5565
5566 return GetAddrOfGlobalVar(cast<VarDecl>(D), /*Ty=*/nullptr, IsForDefinition);
5567}
5568
5570 StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage,
5571 llvm::Align Alignment) {
5572 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
5573 llvm::GlobalVariable *OldGV = nullptr;
5574
5575 if (GV) {
5576 // Check if the variable has the right type.
5577 if (GV->getValueType() == Ty)
5578 return GV;
5579
5580 // Because C++ name mangling, the only way we can end up with an already
5581 // existing global with the same name is if it has been declared extern "C".
5582 assert(GV->isDeclaration() && "Declaration has wrong type!");
5583 OldGV = GV;
5584 }
5585
5586 // Create a new variable.
5587 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
5588 Linkage, nullptr, Name);
5589
5590 if (OldGV) {
5591 // Replace occurrences of the old variable if needed.
5592 GV->takeName(OldGV);
5593
5594 if (!OldGV->use_empty()) {
5595 OldGV->replaceAllUsesWith(GV);
5596 }
5597
5598 OldGV->eraseFromParent();
5599 }
5600
5601 if (supportsCOMDAT() && GV->isWeakForLinker() &&
5602 !GV->hasAvailableExternallyLinkage())
5603 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
5604
5605 GV->setAlignment(Alignment);
5606
5607 return GV;
5608}
5609
5610/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
5611/// given global variable. If Ty is non-null and if the global doesn't exist,
5612/// then it will be created with the specified type instead of whatever the
5613/// normal requested type would be. If IsForDefinition is true, it is guaranteed
5614/// that an actual global with type Ty will be returned, not conversion of a
5615/// variable with the same mangled name but some other type.
5617 llvm::Type *Ty,
5618 ForDefinition_t IsForDefinition) {
5619 assert(D->hasGlobalStorage() && "Not a global variable");
5620 QualType ASTTy = D->getType();
5621 if (!Ty)
5622 Ty = getTypes().ConvertTypeForMem(ASTTy);
5623
5624 StringRef MangledName = getMangledName(D);
5625 return GetOrCreateLLVMGlobal(MangledName, Ty, ASTTy.getAddressSpace(), D,
5626 IsForDefinition);
5627}
5628
5629/// CreateRuntimeVariable - Create a new runtime global variable with the
5630/// specified type and name.
5631llvm::Constant *
5633 StringRef Name) {
5634 LangAS AddrSpace = getContext().getLangOpts().OpenCL ? LangAS::opencl_global
5636 auto *Ret = GetOrCreateLLVMGlobal(Name, Ty, AddrSpace, nullptr);
5637 setDSOLocal(cast<llvm::GlobalValue>(Ret->stripPointerCasts()));
5638 return Ret;
5639}
5640
5642 assert(!D->getInit() && "Cannot emit definite definitions here!");
5643
5644 StringRef MangledName = getMangledName(D);
5645 llvm::GlobalValue *GV = GetGlobalValue(MangledName);
5646
5647 // We already have a definition, not declaration, with the same mangled name.
5648 // Emitting of declaration is not required (and actually overwrites emitted
5649 // definition).
5650 if (GV && !GV->isDeclaration())
5651 return;
5652
5653 // If we have not seen a reference to this variable yet, place it into the
5654 // deferred declarations table to be emitted if needed later.
5655 if (!MustBeEmitted(D) && !GV) {
5656 DeferredDecls[MangledName] = D;
5657 return;
5658 }
5659
5660 // The tentative definition is the only definition.
5661 EmitGlobalVarDefinition(D);
5662}
5663
5664// Return a GlobalDecl. Use the base variants for destructors and constructors.
5666 if (auto const *CD = dyn_cast<const CXXConstructorDecl>(D))
5668 else if (auto const *DD = dyn_cast<const CXXDestructorDecl>(D))
5670 return GlobalDecl(D);
5671}
5672
5675 if (!DI || !getCodeGenOpts().hasReducedDebugInfo())
5676 return;
5677
5679 if (!GD)
5680 return;
5681
5682 llvm::Constant *Addr = GetAddrOfGlobal(GD)->stripPointerCasts();
5683 if (const auto *VD = dyn_cast<VarDecl>(D)) {
5685 cast<llvm::GlobalVariable>(Addr->stripPointerCasts()), VD);
5686 } else if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
5687 llvm::Function *Fn = cast<llvm::Function>(Addr);
5688 if (!Fn->getSubprogram())
5689 DI->EmitFunctionDecl(GD, FD->getLocation(), FD->getType(), Fn);
5690 }
5691}
5692
5694 return Context.toCharUnitsFromBits(
5695 getDataLayout().getTypeStoreSizeInBits(Ty));
5696}
5697
5699 if (LangOpts.OpenCL) {
5701 assert(AS == LangAS::opencl_global ||
5705 AS == LangAS::opencl_local ||
5707 return AS;
5708 }
5709
5710 if (LangOpts.SYCLIsDevice &&
5711 (!D || D->getType().getAddressSpace() == LangAS::Default))
5712 return LangAS::sycl_global;
5713
5714 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
5715 if (D) {
5716 if (D->hasAttr<CUDAConstantAttr>())
5717 return LangAS::cuda_constant;
5718 if (D->hasAttr<CUDASharedAttr>())
5719 return LangAS::cuda_shared;
5720 if (D->hasAttr<CUDADeviceAttr>())
5721 return LangAS::cuda_device;
5722 if (D->getType().isConstQualified())
5723 return LangAS::cuda_constant;
5724 }
5725 return LangAS::cuda_device;
5726 }
5727
5728 if (LangOpts.OpenMP) {
5729 LangAS AS;
5730 if (OpenMPRuntime->hasAllocateAttributeForGlobalVar(D, AS))
5731 return AS;
5732 }
5734}
5735
5737 // OpenCL v1.2 s6.5.3: a string literal is in the constant address space.
5738 if (LangOpts.OpenCL)
5740 if (LangOpts.SYCLIsDevice)
5741 return LangAS::sycl_global;
5742 if (LangOpts.HIP && LangOpts.CUDAIsDevice && getTriple().isSPIRV())
5743 // For HIPSPV map literals to cuda_device (maps to CrossWorkGroup in SPIR-V)
5744 // instead of default AS (maps to Generic in SPIR-V). Otherwise, we end up
5745 // with OpVariable instructions with Generic storage class which is not
5746 // allowed (SPIR-V V1.6 s3.42.8). Also, mapping literals to SPIR-V
5747 // UniformConstant storage class is not viable as pointers to it may not be
5748 // casted to Generic pointers which are used to model HIP's "flat" pointers.
5749 return LangAS::cuda_device;
5750 if (auto AS = getTarget().getConstantAddressSpace())
5751 return *AS;
5752 return LangAS::Default;
5753}
5754
5755// In address space agnostic languages, string literals are in default address
5756// space in AST. However, certain targets (e.g. amdgcn) request them to be
5757// emitted in constant address space in LLVM IR. To be consistent with other
5758// parts of AST, string literal global variables in constant address space
5759// need to be casted to default address space before being put into address
5760// map and referenced by other part of CodeGen.
5761// In OpenCL, string literals are in constant address space in AST, therefore
5762// they should not be casted to default address space.
5763static llvm::Constant *
5765 llvm::GlobalVariable *GV) {
5766 llvm::Constant *Cast = GV;
5767 if (!CGM.getLangOpts().OpenCL) {
5768 auto AS = CGM.GetGlobalConstantAddressSpace();
5769 if (AS != LangAS::Default)
5771 CGM, GV, AS,
5772 llvm::PointerType::get(
5773 CGM.getLLVMContext(),
5775 }
5776 return Cast;
5777}
5778
5779template<typename SomeDecl>
5781 llvm::GlobalValue *GV) {
5782 if (!getLangOpts().CPlusPlus)
5783 return;
5784
5785 // Must have 'used' attribute, or else inline assembly can't rely on
5786 // the name existing.
5787 if (!D->template hasAttr<UsedAttr>())
5788 return;
5789
5790 // Must have internal linkage and an ordinary name.
5791 if (!D->getIdentifier() || D->getFormalLinkage() != Linkage::Internal)
5792 return;
5793
5794 // Must be in an extern "C" context. Entities declared directly within
5795 // a record are not extern "C" even if the record is in such a context.
5796 const SomeDecl *First = D->getFirstDecl();
5797 if (First->getDeclContext()->isRecord() || !First->isInExternCContext())
5798 return;
5799
5800 // OK, this is an internal linkage entity inside an extern "C" linkage
5801 // specification. Make a note of that so we can give it the "expected"
5802 // mangled name if nothing else is using that name.
5803 std::pair<StaticExternCMap::iterator, bool> R =
5804 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
5805
5806 // If we have multiple internal linkage entities with the same name
5807 // in extern "C" regions, none of them gets that name.
5808 if (!R.second)
5809 R.first->second = nullptr;
5810}
5811
5812static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) {
5813 if (!CGM.supportsCOMDAT())
5814 return false;
5815
5816 if (D.hasAttr<SelectAnyAttr>())
5817 return true;
5818
5820 if (auto *VD = dyn_cast<VarDecl>(&D))
5822 else
5824
5825 switch (Linkage) {
5826 case GVA_Internal:
5828 case GVA_StrongExternal:
5829 return false;
5830 case GVA_DiscardableODR:
5831 case GVA_StrongODR:
5832 return true;
5833 }
5834 llvm_unreachable("No such linkage");
5835}
5836
5838 return getTriple().supportsCOMDAT();
5839}
5840
5842 llvm::GlobalObject &GO) {
5843 if (!shouldBeInCOMDAT(*this, D))
5844 return;
5845 GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
5846}
5847
5851
5852/// Pass IsTentative as true if you want to create a tentative definition.
5853void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D,
5854 bool IsTentative) {
5855 // OpenCL global variables of sampler type are translated to function calls,
5856 // therefore no need to be translated.
5857 QualType ASTTy = D->getType();
5858 if (getLangOpts().OpenCL && ASTTy->isSamplerT())
5859 return;
5860
5861 // HLSL default buffer constants will be emitted during HLSLBufferDecl codegen
5862 if (getLangOpts().HLSL &&
5864 return;
5865
5866 // If this is OpenMP device, check if it is legal to emit this global
5867 // normally.
5868 if (LangOpts.OpenMPIsTargetDevice && OpenMPRuntime &&
5869 OpenMPRuntime->emitTargetGlobalVariable(D))
5870 return;
5871
5872 llvm::TrackingVH<llvm::Constant> Init;
5873 bool NeedsGlobalCtor = false;
5874 // Whether the definition of the variable is available externally.
5875 // If yes, we shouldn't emit the GloablCtor and GlobalDtor for the variable
5876 // since this is the job for its original source.
5877 bool IsDefinitionAvailableExternally =
5879 bool NeedsGlobalDtor =
5880 !IsDefinitionAvailableExternally &&
5882
5883 // It is helpless to emit the definition for an available_externally variable
5884 // which can't be marked as const.
5885 // We don't need to check if it needs global ctor or dtor. See the above
5886 // comment for ideas.
5887 if (IsDefinitionAvailableExternally &&
5889 // TODO: Update this when we have interface to check constexpr
5890 // destructor.
5892 !D->getType().isConstantStorage(getContext(), true, true)))
5893 return;
5894
5895 const VarDecl *InitDecl;
5896 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
5897
5898 std::optional<ConstantEmitter> emitter;
5899
5900 // CUDA E.2.4.1 "__shared__ variables cannot have an initialization
5901 // as part of their declaration." Sema has already checked for
5902 // error cases, so we just need to set Init to UndefValue.
5903 bool IsCUDASharedVar =
5904 getLangOpts().CUDAIsDevice && D->hasAttr<CUDASharedAttr>();
5905 // Shadows of initialized device-side global variables are also left
5906 // undefined.
5907 // Managed Variables should be initialized on both host side and device side.
5908 bool IsCUDAShadowVar =
5909 !getLangOpts().CUDAIsDevice && !D->hasAttr<HIPManagedAttr>() &&
5910 (D->hasAttr<CUDAConstantAttr>() || D->hasAttr<CUDADeviceAttr>() ||
5911 D->hasAttr<CUDASharedAttr>());
5912 bool IsCUDADeviceShadowVar =
5913 getLangOpts().CUDAIsDevice && !D->hasAttr<HIPManagedAttr>() &&
5916 if (getLangOpts().CUDA &&
5917 (IsCUDASharedVar || IsCUDAShadowVar || IsCUDADeviceShadowVar)) {
5918 Init = llvm::UndefValue::get(getTypes().ConvertTypeForMem(ASTTy));
5919 } else if (getLangOpts().HLSL &&
5920 (D->getType()->isHLSLResourceRecord() ||
5922 Init = llvm::PoisonValue::get(getTypes().ConvertType(ASTTy));
5923 NeedsGlobalCtor = D->getType()->isHLSLResourceRecord();
5924 } else if (D->hasAttr<LoaderUninitializedAttr>()) {
5925 Init = llvm::UndefValue::get(getTypes().ConvertTypeForMem(ASTTy));
5926 } else if (!InitExpr) {
5927 // This is a tentative definition; tentative definitions are
5928 // implicitly initialized with { 0 }.
5929 //
5930 // Note that tentative definitions are only emitted at the end of
5931 // a translation unit, so they should never have incomplete
5932 // type. In addition, EmitTentativeDefinition makes sure that we
5933 // never attempt to emit a tentative definition if a real one
5934 // exists. A use may still exists, however, so we still may need
5935 // to do a RAUW.
5936 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
5938 } else {
5939 initializedGlobalDecl = GlobalDecl(D);
5940 emitter.emplace(*this);
5941 llvm::Constant *Initializer = emitter->tryEmitForInitializer(*InitDecl);
5942 if (!Initializer) {
5943 QualType T = InitExpr->getType();
5944 if (D->getType()->isReferenceType())
5945 T = D->getType();
5946
5947 if (getLangOpts().CPlusPlus) {
5949 if (!IsDefinitionAvailableExternally)
5950 NeedsGlobalCtor = true;
5951 if (InitDecl->hasFlexibleArrayInit(getContext())) {
5952 ErrorUnsupported(D, "flexible array initializer");
5953 // We cannot create ctor for flexible array initializer
5954 NeedsGlobalCtor = false;
5955 }
5956 } else {
5957 ErrorUnsupported(D, "static initializer");
5958 Init = llvm::PoisonValue::get(getTypes().ConvertType(T));
5959 }
5960 } else {
5961 Init = Initializer;
5962 // We don't need an initializer, so remove the entry for the delayed
5963 // initializer position (just in case this entry was delayed) if we
5964 // also don't need to register a destructor.
5965 if (getLangOpts().CPlusPlus && !NeedsGlobalDtor)
5966 DelayedCXXInitPosition.erase(D);
5967
5968#ifndef NDEBUG
5969 CharUnits VarSize = getContext().getTypeSizeInChars(ASTTy) +
5971 CharUnits CstSize = CharUnits::fromQuantity(
5972 getDataLayout().getTypeAllocSize(Init->getType()));
5973 assert(VarSize == CstSize && "Emitted constant has unexpected size");
5974#endif
5975 }
5976 }
5977
5978 llvm::Type* InitType = Init->getType();
5979 llvm::Constant *Entry =
5980 GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative));
5981
5982 // Strip off pointer casts if we got them.
5983 Entry = Entry->stripPointerCasts();
5984
5985 // Entry is now either a Function or GlobalVariable.
5986 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
5987
5988 // We have a definition after a declaration with the wrong type.
5989 // We must make a new GlobalVariable* and update everything that used OldGV
5990 // (a declaration or tentative definition) with the new GlobalVariable*
5991 // (which will be a definition).
5992 //
5993 // This happens if there is a prototype for a global (e.g.
5994 // "extern int x[];") and then a definition of a different type (e.g.
5995 // "int x[10];"). This also happens when an initializer has a different type
5996 // from the type of the global (this happens with unions).
5997 if (!GV || GV->getValueType() != InitType ||
5998 GV->getType()->getAddressSpace() !=
5999 getContext().getTargetAddressSpace(GetGlobalVarAddressSpace(D))) {
6000
6001 // Move the old entry aside so that we'll create a new one.
6002 Entry->setName(StringRef());
6003
6004 // Make a new global with the correct type, this is now guaranteed to work.
6006 GetAddrOfGlobalVar(D, InitType, ForDefinition_t(!IsTentative))
6007 ->stripPointerCasts());
6008
6009 // Replace all uses of the old global with the new global
6010 llvm::Constant *NewPtrForOldDecl =
6011 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV,
6012 Entry->getType());
6013 Entry->replaceAllUsesWith(NewPtrForOldDecl);
6014
6015 // Erase the old global, since it is no longer used.
6016 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
6017 }
6018
6020
6021 if (D->hasAttr<AnnotateAttr>())
6022 AddGlobalAnnotations(D, GV);
6023
6024 // Set the llvm linkage type as appropriate.
6025 llvm::GlobalValue::LinkageTypes Linkage = getLLVMLinkageVarDefinition(D);
6026
6027 // CUDA B.2.1 "The __device__ qualifier declares a variable that resides on
6028 // the device. [...]"
6029 // CUDA B.2.2 "The __constant__ qualifier, optionally used together with
6030 // __device__, declares a variable that: [...]
6031 // Is accessible from all the threads within the grid and from the host
6032 // through the runtime library (cudaGetSymbolAddress() / cudaGetSymbolSize()
6033 // / cudaMemcpyToSymbol() / cudaMemcpyFromSymbol())."
6034 if (LangOpts.CUDA) {
6035 if (LangOpts.CUDAIsDevice) {
6036 if (Linkage != llvm::GlobalValue::InternalLinkage &&
6037 (D->hasAttr<CUDADeviceAttr>() || D->hasAttr<CUDAConstantAttr>() ||
6040 GV->setExternallyInitialized(true);
6041 } else {
6043 }
6045 }
6046
6047 if (LangOpts.HLSL && GetGlobalVarAddressSpace(D) == LangAS::hlsl_input) {
6048 // HLSL Input variables are considered to be set by the driver/pipeline, but
6049 // only visible to a single thread/wave.
6050 GV->setExternallyInitialized(true);
6051 } else {
6052 GV->setInitializer(Init);
6053 }
6054
6055 if (LangOpts.HLSL)
6057
6058 if (emitter)
6059 emitter->finalize(GV);
6060
6061 // If it is safe to mark the global 'constant', do so now.
6062 GV->setConstant((D->hasAttr<CUDAConstantAttr>() && LangOpts.CUDAIsDevice) ||
6063 (!NeedsGlobalCtor && !NeedsGlobalDtor &&
6064 D->getType().isConstantStorage(getContext(), true, true)));
6065
6066 // If it is in a read-only section, mark it 'constant'.
6067 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
6068 const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()];
6069 if ((SI.SectionFlags & ASTContext::PSF_Write) == 0)
6070 GV->setConstant(true);
6071 }
6072
6073 CharUnits AlignVal = getContext().getDeclAlign(D);
6074 // Check for alignment specifed in an 'omp allocate' directive.
6075 if (std::optional<CharUnits> AlignValFromAllocate =
6077 AlignVal = *AlignValFromAllocate;
6078 GV->setAlignment(AlignVal.getAsAlign());
6079
6080 // On Darwin, unlike other Itanium C++ ABI platforms, the thread-wrapper
6081 // function is only defined alongside the variable, not also alongside
6082 // callers. Normally, all accesses to a thread_local go through the
6083 // thread-wrapper in order to ensure initialization has occurred, underlying
6084 // variable will never be used other than the thread-wrapper, so it can be
6085 // converted to internal linkage.
6086 //
6087 // However, if the variable has the 'constinit' attribute, it _can_ be
6088 // referenced directly, without calling the thread-wrapper, so the linkage
6089 // must not be changed.
6090 //
6091 // Additionally, if the variable isn't plain external linkage, e.g. if it's
6092 // weak or linkonce, the de-duplication semantics are important to preserve,
6093 // so we don't change the linkage.
6094 if (D->getTLSKind() == VarDecl::TLS_Dynamic &&
6095 Linkage == llvm::GlobalValue::ExternalLinkage &&
6096 Context.getTargetInfo().getTriple().isOSDarwin() &&
6097 !D->hasAttr<ConstInitAttr>())
6098 Linkage = llvm::GlobalValue::InternalLinkage;
6099
6100 // HLSL variables in the input address space maps like memory-mapped
6101 // variables. Even if they are 'static', they are externally initialized and
6102 // read/write by the hardware/driver/pipeline.
6103 if (LangOpts.HLSL && GetGlobalVarAddressSpace(D) == LangAS::hlsl_input)
6104 Linkage = llvm::GlobalValue::ExternalLinkage;
6105
6106 GV->setLinkage(Linkage);
6107 if (D->hasAttr<DLLImportAttr>())
6108 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
6109 else if (D->hasAttr<DLLExportAttr>())
6110 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
6111 else
6112 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
6113
6114 if (Linkage == llvm::GlobalVariable::CommonLinkage) {
6115 // common vars aren't constant even if declared const.
6116 GV->setConstant(false);
6117 // Tentative definition of global variables may be initialized with
6118 // non-zero null pointers. In this case they should have weak linkage
6119 // since common linkage must have zero initializer and must not have
6120 // explicit section therefore cannot have non-zero initial value.
6121 if (!GV->getInitializer()->isNullValue())
6122 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
6123 }
6124
6125 setNonAliasAttributes(D, GV);
6126
6127 if (D->getTLSKind() && !GV->isThreadLocal()) {
6128 if (D->getTLSKind() == VarDecl::TLS_Dynamic)
6129 CXXThreadLocals.push_back(D);
6130 setTLSMode(GV, *D);
6131 }
6132
6133 maybeSetTrivialComdat(*D, *GV);
6134
6135 // Emit the initializer function if necessary.
6136 if (NeedsGlobalCtor || NeedsGlobalDtor)
6137 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
6138
6139 SanitizerMD->reportGlobal(GV, *D, NeedsGlobalCtor);
6140
6141 // Emit global variable debug information.
6142 if (CGDebugInfo *DI = getModuleDebugInfo())
6143 if (getCodeGenOpts().hasReducedDebugInfo())
6144 DI->EmitGlobalVariable(GV, D);
6145}
6146
6147static bool isVarDeclStrongDefinition(const ASTContext &Context,
6148 CodeGenModule &CGM, const VarDecl *D,
6149 bool NoCommon) {
6150 // Don't give variables common linkage if -fno-common was specified unless it
6151 // was overridden by a NoCommon attribute.
6152 if ((NoCommon || D->hasAttr<NoCommonAttr>()) && !D->hasAttr<CommonAttr>())
6153 return true;
6154
6155 // C11 6.9.2/2:
6156 // A declaration of an identifier for an object that has file scope without
6157 // an initializer, and without a storage-class specifier or with the
6158 // storage-class specifier static, constitutes a tentative definition.
6159 if (D->getInit() || D->hasExternalStorage())
6160 return true;
6161
6162 // A variable cannot be both common and exist in a section.
6163 if (D->hasAttr<SectionAttr>())
6164 return true;
6165
6166 // A variable cannot be both common and exist in a section.
6167 // We don't try to determine which is the right section in the front-end.
6168 // If no specialized section name is applicable, it will resort to default.
6169 if (D->hasAttr<PragmaClangBSSSectionAttr>() ||
6170 D->hasAttr<PragmaClangDataSectionAttr>() ||
6171 D->hasAttr<PragmaClangRelroSectionAttr>() ||
6172 D->hasAttr<PragmaClangRodataSectionAttr>())
6173 return true;
6174
6175 // Thread local vars aren't considered common linkage.
6176 if (D->getTLSKind())
6177 return true;
6178
6179 // Tentative definitions marked with WeakImportAttr are true definitions.
6180 if (D->hasAttr<WeakImportAttr>())
6181 return true;
6182
6183 // A variable cannot be both common and exist in a comdat.
6184 if (shouldBeInCOMDAT(CGM, *D))
6185 return true;
6186
6187 // Declarations with a required alignment do not have common linkage in MSVC
6188 // mode.
6189 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
6190 if (D->hasAttr<AlignedAttr>())
6191 return true;
6192 QualType VarType = D->getType();
6193 if (Context.isAlignmentRequired(VarType))
6194 return true;
6195
6196 if (const auto *RD = VarType->getAsRecordDecl()) {
6197 for (const FieldDecl *FD : RD->fields()) {
6198 if (FD->isBitField())
6199 continue;
6200 if (FD->hasAttr<AlignedAttr>())
6201 return true;
6202 if (Context.isAlignmentRequired(FD->getType()))
6203 return true;
6204 }
6205 }
6206 }
6207
6208 // Microsoft's link.exe doesn't support alignments greater than 32 bytes for
6209 // common symbols, so symbols with greater alignment requirements cannot be
6210 // common.
6211 // Other COFF linkers (ld.bfd and LLD) support arbitrary power-of-two
6212 // alignments for common symbols via the aligncomm directive, so this
6213 // restriction only applies to MSVC environments.
6214 if (Context.getTargetInfo().getTriple().isKnownWindowsMSVCEnvironment() &&
6215 Context.getTypeAlignIfKnown(D->getType()) >
6216 Context.toBits(CharUnits::fromQuantity(32)))
6217 return true;
6218
6219 return false;
6220}
6221
6222llvm::GlobalValue::LinkageTypes
6225 if (Linkage == GVA_Internal)
6226 return llvm::Function::InternalLinkage;
6227
6228 if (D->hasAttr<WeakAttr>())
6229 return llvm::GlobalVariable::WeakAnyLinkage;
6230
6231 if (const auto *FD = D->getAsFunction())
6233 return llvm::GlobalVariable::LinkOnceAnyLinkage;
6234
6235 // We are guaranteed to have a strong definition somewhere else,
6236 // so we can use available_externally linkage.
6238 return llvm::GlobalValue::AvailableExternallyLinkage;
6239
6240 // Note that Apple's kernel linker doesn't support symbol
6241 // coalescing, so we need to avoid linkonce and weak linkages there.
6242 // Normally, this means we just map to internal, but for explicit
6243 // instantiations we'll map to external.
6244
6245 // In C++, the compiler has to emit a definition in every translation unit
6246 // that references the function. We should use linkonce_odr because
6247 // a) if all references in this translation unit are optimized away, we
6248 // don't need to codegen it. b) if the function persists, it needs to be
6249 // merged with other definitions. c) C++ has the ODR, so we know the
6250 // definition is dependable.
6252 return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
6253 : llvm::Function::InternalLinkage;
6254
6255 // An explicit instantiation of a template has weak linkage, since
6256 // explicit instantiations can occur in multiple translation units
6257 // and must all be equivalent. However, we are not allowed to
6258 // throw away these explicit instantiations.
6259 //
6260 // CUDA/HIP: For -fno-gpu-rdc case, device code is limited to one TU,
6261 // so say that CUDA templates are either external (for kernels) or internal.
6262 // This lets llvm perform aggressive inter-procedural optimizations. For
6263 // -fgpu-rdc case, device function calls across multiple TU's are allowed,
6264 // therefore we need to follow the normal linkage paradigm.
6265 if (Linkage == GVA_StrongODR) {
6266 if (getLangOpts().AppleKext)
6267 return llvm::Function::ExternalLinkage;
6268 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice &&
6269 !getLangOpts().GPURelocatableDeviceCode)
6270 return D->hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
6271 : llvm::Function::InternalLinkage;
6272 return llvm::Function::WeakODRLinkage;
6273 }
6274
6275 // C++ doesn't have tentative definitions and thus cannot have common
6276 // linkage.
6277 if (!getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
6278 !isVarDeclStrongDefinition(Context, *this, cast<VarDecl>(D),
6279 CodeGenOpts.NoCommon))
6280 return llvm::GlobalVariable::CommonLinkage;
6281
6282 // selectany symbols are externally visible, so use weak instead of
6283 // linkonce. MSVC optimizes away references to const selectany globals, so
6284 // all definitions should be the same and ODR linkage should be used.
6285 // http://msdn.microsoft.com/en-us/library/5tkz6s71.aspx
6286 if (D->hasAttr<SelectAnyAttr>())
6287 return llvm::GlobalVariable::WeakODRLinkage;
6288
6289 // Otherwise, we have strong external linkage.
6290 assert(Linkage == GVA_StrongExternal);
6291 return llvm::GlobalVariable::ExternalLinkage;
6292}
6293
6294llvm::GlobalValue::LinkageTypes
6299
6300/// Replace the uses of a function that was declared with a non-proto type.
6301/// We want to silently drop extra arguments from call sites
6302static void replaceUsesOfNonProtoConstant(llvm::Constant *old,
6303 llvm::Function *newFn) {
6304 // Fast path.
6305 if (old->use_empty())
6306 return;
6307
6308 llvm::Type *newRetTy = newFn->getReturnType();
6310
6311 SmallVector<llvm::CallBase *> callSitesToBeRemovedFromParent;
6312
6313 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
6314 ui != ue; ui++) {
6315 llvm::User *user = ui->getUser();
6316
6317 // Recognize and replace uses of bitcasts. Most calls to
6318 // unprototyped functions will use bitcasts.
6319 if (auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
6320 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
6321 replaceUsesOfNonProtoConstant(bitcast, newFn);
6322 continue;
6323 }
6324
6325 // Recognize calls to the function.
6326 llvm::CallBase *callSite = dyn_cast<llvm::CallBase>(user);
6327 if (!callSite)
6328 continue;
6329 if (!callSite->isCallee(&*ui))
6330 continue;
6331
6332 // If the return types don't match exactly, then we can't
6333 // transform this call unless it's dead.
6334 if (callSite->getType() != newRetTy && !callSite->use_empty())
6335 continue;
6336
6337 // Get the call site's attribute list.
6339 llvm::AttributeList oldAttrs = callSite->getAttributes();
6340
6341 // If the function was passed too few arguments, don't transform.
6342 unsigned newNumArgs = newFn->arg_size();
6343 if (callSite->arg_size() < newNumArgs)
6344 continue;
6345
6346 // If extra arguments were passed, we silently drop them.
6347 // If any of the types mismatch, we don't transform.
6348 unsigned argNo = 0;
6349 bool dontTransform = false;
6350 for (llvm::Argument &A : newFn->args()) {
6351 if (callSite->getArgOperand(argNo)->getType() != A.getType()) {
6352 dontTransform = true;
6353 break;
6354 }
6355
6356 // Add any parameter attributes.
6357 newArgAttrs.push_back(oldAttrs.getParamAttrs(argNo));
6358 argNo++;
6359 }
6360 if (dontTransform)
6361 continue;
6362
6363 // Okay, we can transform this. Create the new call instruction and copy
6364 // over the required information.
6365 newArgs.append(callSite->arg_begin(), callSite->arg_begin() + argNo);
6366
6367 // Copy over any operand bundles.
6369 callSite->getOperandBundlesAsDefs(newBundles);
6370
6371 llvm::CallBase *newCall;
6372 if (isa<llvm::CallInst>(callSite)) {
6373 newCall = llvm::CallInst::Create(newFn, newArgs, newBundles, "",
6374 callSite->getIterator());
6375 } else {
6376 auto *oldInvoke = cast<llvm::InvokeInst>(callSite);
6377 newCall = llvm::InvokeInst::Create(
6378 newFn, oldInvoke->getNormalDest(), oldInvoke->getUnwindDest(),
6379 newArgs, newBundles, "", callSite->getIterator());
6380 }
6381 newArgs.clear(); // for the next iteration
6382
6383 if (!newCall->getType()->isVoidTy())
6384 newCall->takeName(callSite);
6385 newCall->setAttributes(
6386 llvm::AttributeList::get(newFn->getContext(), oldAttrs.getFnAttrs(),
6387 oldAttrs.getRetAttrs(), newArgAttrs));
6388 newCall->setCallingConv(callSite->getCallingConv());
6389
6390 // Finally, remove the old call, replacing any uses with the new one.
6391 if (!callSite->use_empty())
6392 callSite->replaceAllUsesWith(newCall);
6393
6394 // Copy debug location attached to CI.
6395 if (callSite->getDebugLoc())
6396 newCall->setDebugLoc(callSite->getDebugLoc());
6397
6398 callSitesToBeRemovedFromParent.push_back(callSite);
6399 }
6400
6401 for (auto *callSite : callSitesToBeRemovedFromParent) {
6402 callSite->eraseFromParent();
6403 }
6404}
6405
6406/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we
6407/// implement a function with no prototype, e.g. "int foo() {}". If there are
6408/// existing call uses of the old function in the module, this adjusts them to
6409/// call the new function directly.
6410///
6411/// This is not just a cleanup: the always_inline pass requires direct calls to
6412/// functions to be able to inline them. If there is a bitcast in the way, it
6413/// won't inline them. Instcombine normally deletes these calls, but it isn't
6414/// run at -O0.
6415static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
6416 llvm::Function *NewFn) {
6417 // If we're redefining a global as a function, don't transform it.
6418 if (!isa<llvm::Function>(Old)) return;
6419
6421}
6422
6424 auto DK = VD->isThisDeclarationADefinition();
6425 if ((DK == VarDecl::Definition && VD->hasAttr<DLLImportAttr>()) ||
6426 (LangOpts.CUDA && !shouldEmitCUDAGlobalVar(VD)))
6427 return;
6428
6430 // If we have a definition, this might be a deferred decl. If the
6431 // instantiation is explicit, make sure we emit it at the end.
6434
6435 EmitTopLevelDecl(VD);
6436}
6437
6438void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD,
6439 llvm::GlobalValue *GV) {
6440 const auto *D = cast<FunctionDecl>(GD.getDecl());
6441
6442 // Compute the function info and LLVM type.
6444 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
6445
6446 // Get or create the prototype for the function.
6447 if (!GV || (GV->getValueType() != Ty))
6448 GV = cast<llvm::GlobalValue>(GetAddrOfFunction(GD, Ty, /*ForVTable=*/false,
6449 /*DontDefer=*/true,
6450 ForDefinition));
6451
6452 // Already emitted.
6453 if (!GV->isDeclaration())
6454 return;
6455
6456 // We need to set linkage and visibility on the function before
6457 // generating code for it because various parts of IR generation
6458 // want to propagate this information down (e.g. to local static
6459 // declarations).
6460 auto *Fn = cast<llvm::Function>(GV);
6461 setFunctionLinkage(GD, Fn);
6462
6463 // FIXME: this is redundant with part of setFunctionDefinitionAttributes
6464 setGVProperties(Fn, GD);
6465
6467
6468 maybeSetTrivialComdat(*D, *Fn);
6469
6470 CodeGenFunction(*this).GenerateCode(GD, Fn, FI);
6471
6472 setNonAliasAttributes(GD, Fn);
6473
6474 bool ShouldAddOptNone = !CodeGenOpts.DisableO0ImplyOptNone &&
6475 (CodeGenOpts.OptimizationLevel == 0) &&
6476 !D->hasAttr<MinSizeAttr>();
6477
6478 if (DeviceKernelAttr::isOpenCLSpelling(D->getAttr<DeviceKernelAttr>())) {
6480 !D->hasAttr<NoInlineAttr>() &&
6481 !Fn->hasFnAttribute(llvm::Attribute::NoInline) &&
6482 !D->hasAttr<OptimizeNoneAttr>() &&
6483 !Fn->hasFnAttribute(llvm::Attribute::OptimizeNone) &&
6484 !ShouldAddOptNone) {
6485 Fn->addFnAttr(llvm::Attribute::AlwaysInline);
6486 }
6487 }
6488
6490
6491 auto GetPriority = [this](const auto *Attr) -> int {
6492 Expr *E = Attr->getPriority();
6493 if (E) {
6494 return E->EvaluateKnownConstInt(this->getContext()).getExtValue();
6495 }
6496 return Attr->DefaultPriority;
6497 };
6498
6499 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>())
6500 AddGlobalCtor(Fn, GetPriority(CA));
6501 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>())
6502 AddGlobalDtor(Fn, GetPriority(DA), true);
6503 if (getLangOpts().OpenMP && D->hasAttr<OMPDeclareTargetDeclAttr>())
6505}
6506
6507void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
6508 const auto *D = cast<ValueDecl>(GD.getDecl());
6509 const AliasAttr *AA = D->getAttr<AliasAttr>();
6510 assert(AA && "Not an alias?");
6511
6512 StringRef MangledName = getMangledName(GD);
6513
6514 if (AA->getAliasee() == MangledName) {
6515 Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
6516 return;
6517 }
6518
6519 // If there is a definition in the module, then it wins over the alias.
6520 // This is dubious, but allow it to be safe. Just ignore the alias.
6521 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
6522 if (Entry && !Entry->isDeclaration())
6523 return;
6524
6525 Aliases.push_back(GD);
6526
6527 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
6528
6529 // Create a reference to the named value. This ensures that it is emitted
6530 // if a deferred decl.
6531 llvm::Constant *Aliasee;
6532 llvm::GlobalValue::LinkageTypes LT;
6533 if (isa<llvm::FunctionType>(DeclTy)) {
6534 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
6535 /*ForVTable=*/false);
6536 LT = getFunctionLinkage(GD);
6537 } else {
6538 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), DeclTy, LangAS::Default,
6539 /*D=*/nullptr);
6540 if (const auto *VD = dyn_cast<VarDecl>(GD.getDecl()))
6542 else
6543 LT = getFunctionLinkage(GD);
6544 }
6545
6546 // Create the new alias itself, but don't set a name yet.
6547 unsigned AS = Aliasee->getType()->getPointerAddressSpace();
6548 auto *GA =
6549 llvm::GlobalAlias::create(DeclTy, AS, LT, "", Aliasee, &getModule());
6550
6551 if (Entry) {
6552 if (GA->getAliasee() == Entry) {
6553 Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
6554 return;
6555 }
6556
6557 assert(Entry->isDeclaration());
6558
6559 // If there is a declaration in the module, then we had an extern followed
6560 // by the alias, as in:
6561 // extern int test6();
6562 // ...
6563 // int test6() __attribute__((alias("test7")));
6564 //
6565 // Remove it and replace uses of it with the alias.
6566 GA->takeName(Entry);
6567
6568 Entry->replaceAllUsesWith(GA);
6569 Entry->eraseFromParent();
6570 } else {
6571 GA->setName(MangledName);
6572 }
6573
6574 // Set attributes which are particular to an alias; this is a
6575 // specialization of the attributes which may be set on a global
6576 // variable/function.
6577 if (D->hasAttr<WeakAttr>() || D->hasAttr<WeakRefAttr>() ||
6578 D->isWeakImported()) {
6579 GA->setLinkage(llvm::Function::WeakAnyLinkage);
6580 }
6581
6582 if (const auto *VD = dyn_cast<VarDecl>(D))
6583 if (VD->getTLSKind())
6584 setTLSMode(GA, *VD);
6585
6586 SetCommonAttributes(GD, GA);
6587
6588 // Emit global alias debug information.
6589 if (isa<VarDecl>(D))
6590 if (CGDebugInfo *DI = getModuleDebugInfo())
6591 DI->EmitGlobalAlias(cast<llvm::GlobalValue>(GA->getAliasee()->stripPointerCasts()), GD);
6592}
6593
6594void CodeGenModule::emitIFuncDefinition(GlobalDecl GD) {
6595 const auto *D = cast<ValueDecl>(GD.getDecl());
6596 const IFuncAttr *IFA = D->getAttr<IFuncAttr>();
6597 assert(IFA && "Not an ifunc?");
6598
6599 StringRef MangledName = getMangledName(GD);
6600
6601 if (IFA->getResolver() == MangledName) {
6602 Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
6603 return;
6604 }
6605
6606 // Report an error if some definition overrides ifunc.
6607 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
6608 if (Entry && !Entry->isDeclaration()) {
6609 GlobalDecl OtherGD;
6610 if (lookupRepresentativeDecl(MangledName, OtherGD) &&
6611 DiagnosedConflictingDefinitions.insert(GD).second) {
6612 Diags.Report(D->getLocation(), diag::err_duplicate_mangled_name)
6613 << MangledName;
6614 Diags.Report(OtherGD.getDecl()->getLocation(),
6615 diag::note_previous_definition);
6616 }
6617 return;
6618 }
6619
6620 Aliases.push_back(GD);
6621
6622 // The resolver might not be visited yet. Specify a dummy non-function type to
6623 // indicate IsIncompleteFunction. Either the type is ignored (if the resolver
6624 // was emitted) or the whole function will be replaced (if the resolver has
6625 // not been emitted).
6626 llvm::Constant *Resolver =
6627 GetOrCreateLLVMFunction(IFA->getResolver(), VoidTy, {},
6628 /*ForVTable=*/false);
6629 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
6630 unsigned AS = getTypes().getTargetAddressSpace(D->getType());
6631 llvm::GlobalIFunc *GIF = llvm::GlobalIFunc::create(
6632 DeclTy, AS, llvm::Function::ExternalLinkage, "", Resolver, &getModule());
6633 if (Entry) {
6634 if (GIF->getResolver() == Entry) {
6635 Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
6636 return;
6637 }
6638 assert(Entry->isDeclaration());
6639
6640 // If there is a declaration in the module, then we had an extern followed
6641 // by the ifunc, as in:
6642 // extern int test();
6643 // ...
6644 // int test() __attribute__((ifunc("resolver")));
6645 //
6646 // Remove it and replace uses of it with the ifunc.
6647 GIF->takeName(Entry);
6648
6649 Entry->replaceAllUsesWith(GIF);
6650 Entry->eraseFromParent();
6651 } else
6652 GIF->setName(MangledName);
6653 SetCommonAttributes(GD, GIF);
6654}
6655
6656llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,
6658 return llvm::Intrinsic::getOrInsertDeclaration(&getModule(),
6659 (llvm::Intrinsic::ID)IID, Tys);
6660}
6661
6662static llvm::StringMapEntry<llvm::GlobalVariable *> &
6663GetConstantCFStringEntry(llvm::StringMap<llvm::GlobalVariable *> &Map,
6664 const StringLiteral *Literal, bool TargetIsLSB,
6665 bool &IsUTF16, unsigned &StringLength) {
6666 StringRef String = Literal->getString();
6667 unsigned NumBytes = String.size();
6668
6669 // Check for simple case.
6670 if (!Literal->containsNonAsciiOrNull()) {
6671 StringLength = NumBytes;
6672 return *Map.insert(std::make_pair(String, nullptr)).first;
6673 }
6674
6675 // Otherwise, convert the UTF8 literals into a string of shorts.
6676 IsUTF16 = true;
6677
6678 SmallVector<llvm::UTF16, 128> ToBuf(NumBytes + 1); // +1 for ending nulls.
6679 const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)String.data();
6680 llvm::UTF16 *ToPtr = &ToBuf[0];
6681
6682 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
6683 ToPtr + NumBytes, llvm::strictConversion);
6684
6685 // ConvertUTF8toUTF16 returns the length in ToPtr.
6686 StringLength = ToPtr - &ToBuf[0];
6687
6688 // Add an explicit null.
6689 *ToPtr = 0;
6690 return *Map.insert(std::make_pair(
6691 StringRef(reinterpret_cast<const char *>(ToBuf.data()),
6692 (StringLength + 1) * 2),
6693 nullptr)).first;
6694}
6695
6698 unsigned StringLength = 0;
6699 bool isUTF16 = false;
6700 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
6701 GetConstantCFStringEntry(CFConstantStringMap, Literal,
6702 getDataLayout().isLittleEndian(), isUTF16,
6703 StringLength);
6704
6705 if (auto *C = Entry.second)
6706 return ConstantAddress(
6707 C, C->getValueType(), CharUnits::fromQuantity(C->getAlignment()));
6708
6709 const ASTContext &Context = getContext();
6710 const llvm::Triple &Triple = getTriple();
6711
6712 const auto CFRuntime = getLangOpts().CFRuntime;
6713 const bool IsSwiftABI =
6714 static_cast<unsigned>(CFRuntime) >=
6715 static_cast<unsigned>(LangOptions::CoreFoundationABI::Swift);
6716 const bool IsSwift4_1 = CFRuntime == LangOptions::CoreFoundationABI::Swift4_1;
6717
6718 // If we don't already have it, get __CFConstantStringClassReference.
6719 if (!CFConstantStringClassRef) {
6720 const char *CFConstantStringClassName = "__CFConstantStringClassReference";
6721 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
6722 Ty = llvm::ArrayType::get(Ty, 0);
6723
6724 switch (CFRuntime) {
6725 default: break;
6726 case LangOptions::CoreFoundationABI::Swift: [[fallthrough]];
6728 CFConstantStringClassName =
6729 Triple.isOSDarwin() ? "$s15SwiftFoundation19_NSCFConstantStringCN"
6730 : "$s10Foundation19_NSCFConstantStringCN";
6731 Ty = IntPtrTy;
6732 break;
6734 CFConstantStringClassName =
6735 Triple.isOSDarwin() ? "$S15SwiftFoundation19_NSCFConstantStringCN"
6736 : "$S10Foundation19_NSCFConstantStringCN";
6737 Ty = IntPtrTy;
6738 break;
6740 CFConstantStringClassName =
6741 Triple.isOSDarwin() ? "__T015SwiftFoundation19_NSCFConstantStringCN"
6742 : "__T010Foundation19_NSCFConstantStringCN";
6743 Ty = IntPtrTy;
6744 break;
6745 }
6746
6747 llvm::Constant *C = CreateRuntimeVariable(Ty, CFConstantStringClassName);
6748
6749 if (Triple.isOSBinFormatELF() || Triple.isOSBinFormatCOFF()) {
6750 llvm::GlobalValue *GV = nullptr;
6751
6752 if ((GV = dyn_cast<llvm::GlobalValue>(C))) {
6753 IdentifierInfo &II = Context.Idents.get(GV->getName());
6754 TranslationUnitDecl *TUDecl = Context.getTranslationUnitDecl();
6756
6757 const VarDecl *VD = nullptr;
6758 for (const auto *Result : DC->lookup(&II))
6759 if ((VD = dyn_cast<VarDecl>(Result)))
6760 break;
6761
6762 if (Triple.isOSBinFormatELF()) {
6763 if (!VD)
6764 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6765 } else {
6766 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6767 if (!VD || !VD->hasAttr<DLLExportAttr>())
6768 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6769 else
6770 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6771 }
6772
6773 setDSOLocal(GV);
6774 }
6775 }
6776
6777 // Decay array -> ptr
6778 CFConstantStringClassRef =
6779 IsSwiftABI ? llvm::ConstantExpr::getPtrToInt(C, Ty) : C;
6780 }
6781
6782 QualType CFTy = Context.getCFConstantStringType();
6783
6784 auto *STy = cast<llvm::StructType>(getTypes().ConvertType(CFTy));
6785
6786 ConstantInitBuilder Builder(*this);
6787 auto Fields = Builder.beginStruct(STy);
6788
6789 // Class pointer.
6790 Fields.addSignedPointer(cast<llvm::Constant>(CFConstantStringClassRef),
6791 getCodeGenOpts().PointerAuth.ObjCIsaPointers,
6792 GlobalDecl(), QualType());
6793
6794 // Flags.
6795 if (IsSwiftABI) {
6796 Fields.addInt(IntPtrTy, IsSwift4_1 ? 0x05 : 0x01);
6797 Fields.addInt(Int64Ty, isUTF16 ? 0x07d0 : 0x07c8);
6798 } else {
6799 Fields.addInt(IntTy, isUTF16 ? 0x07d0 : 0x07C8);
6800 }
6801
6802 // String pointer.
6803 llvm::Constant *C = nullptr;
6804 if (isUTF16) {
6805 auto Arr = llvm::ArrayRef(
6806 reinterpret_cast<uint16_t *>(const_cast<char *>(Entry.first().data())),
6807 Entry.first().size() / 2);
6808 C = llvm::ConstantDataArray::get(VMContext, Arr);
6809 } else {
6810 C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
6811 }
6812
6813 // Note: -fwritable-strings doesn't make the backing store strings of
6814 // CFStrings writable.
6815 auto *GV =
6816 new llvm::GlobalVariable(getModule(), C->getType(), /*isConstant=*/true,
6817 llvm::GlobalValue::PrivateLinkage, C, ".str");
6818 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6819 // Don't enforce the target's minimum global alignment, since the only use
6820 // of the string is via this class initializer.
6821 CharUnits Align = isUTF16 ? Context.getTypeAlignInChars(Context.ShortTy)
6822 : Context.getTypeAlignInChars(Context.CharTy);
6823 GV->setAlignment(Align.getAsAlign());
6824
6825 // FIXME: We set the section explicitly to avoid a bug in ld64 224.1.
6826 // Without it LLVM can merge the string with a non unnamed_addr one during
6827 // LTO. Doing that changes the section it ends in, which surprises ld64.
6828 if (Triple.isOSBinFormatMachO())
6829 GV->setSection(isUTF16 ? "__TEXT,__ustring"
6830 : "__TEXT,__cstring,cstring_literals");
6831 // Make sure the literal ends up in .rodata to allow for safe ICF and for
6832 // the static linker to adjust permissions to read-only later on.
6833 else if (Triple.isOSBinFormatELF())
6834 GV->setSection(".rodata");
6835
6836 // String.
6837 Fields.add(GV);
6838
6839 // String length.
6840 llvm::IntegerType *LengthTy =
6841 llvm::IntegerType::get(getModule().getContext(),
6842 Context.getTargetInfo().getLongWidth());
6843 if (IsSwiftABI) {
6846 LengthTy = Int32Ty;
6847 else
6848 LengthTy = IntPtrTy;
6849 }
6850 Fields.addInt(LengthTy, StringLength);
6851
6852 // Swift ABI requires 8-byte alignment to ensure that the _Atomic(uint64_t) is
6853 // properly aligned on 32-bit platforms.
6854 CharUnits Alignment =
6855 IsSwiftABI ? Context.toCharUnitsFromBits(64) : getPointerAlign();
6856
6857 // The struct.
6858 GV = Fields.finishAndCreateGlobal("_unnamed_cfstring_", Alignment,
6859 /*isConstant=*/false,
6860 llvm::GlobalVariable::PrivateLinkage);
6861 GV->addAttribute("objc_arc_inert");
6862 switch (Triple.getObjectFormat()) {
6863 case llvm::Triple::UnknownObjectFormat:
6864 llvm_unreachable("unknown file format");
6865 case llvm::Triple::DXContainer:
6866 case llvm::Triple::GOFF:
6867 case llvm::Triple::SPIRV:
6868 case llvm::Triple::XCOFF:
6869 llvm_unreachable("unimplemented");
6870 case llvm::Triple::COFF:
6871 case llvm::Triple::ELF:
6872 case llvm::Triple::Wasm:
6873 GV->setSection("cfstring");
6874 break;
6875 case llvm::Triple::MachO:
6876 GV->setSection("__DATA,__cfstring");
6877 break;
6878 }
6879 Entry.second = GV;
6880
6881 return ConstantAddress(GV, GV->getValueType(), Alignment);
6882}
6883
6885 return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
6886}
6887
6889 if (ObjCFastEnumerationStateType.isNull()) {
6890 RecordDecl *D = Context.buildImplicitRecord("__objcFastEnumerationState");
6891 D->startDefinition();
6892
6893 QualType FieldTypes[] = {
6894 Context.UnsignedLongTy, Context.getPointerType(Context.getObjCIdType()),
6895 Context.getPointerType(Context.UnsignedLongTy),
6896 Context.getConstantArrayType(Context.UnsignedLongTy, llvm::APInt(32, 5),
6897 nullptr, ArraySizeModifier::Normal, 0)};
6898
6899 for (size_t i = 0; i < 4; ++i) {
6900 FieldDecl *Field = FieldDecl::Create(Context,
6901 D,
6903 SourceLocation(), nullptr,
6904 FieldTypes[i], /*TInfo=*/nullptr,
6905 /*BitWidth=*/nullptr,
6906 /*Mutable=*/false,
6907 ICIS_NoInit);
6908 Field->setAccess(AS_public);
6909 D->addDecl(Field);
6910 }
6911
6912 D->completeDefinition();
6913 ObjCFastEnumerationStateType = Context.getCanonicalTagType(D);
6914 }
6915
6916 return ObjCFastEnumerationStateType;
6917}
6918
6919llvm::Constant *
6921 assert(!E->getType()->isPointerType() && "Strings are always arrays");
6922
6923 // Don't emit it as the address of the string, emit the string data itself
6924 // as an inline array.
6925 if (E->getCharByteWidth() == 1) {
6926 SmallString<64> Str(E->getString());
6927
6928 // Resize the string to the right size, which is indicated by its type.
6929 const ConstantArrayType *CAT = Context.getAsConstantArrayType(E->getType());
6930 assert(CAT && "String literal not of constant array type!");
6931 Str.resize(CAT->getZExtSize());
6932 return llvm::ConstantDataArray::getString(VMContext, Str, false);
6933 }
6934
6935 auto *AType = cast<llvm::ArrayType>(getTypes().ConvertType(E->getType()));
6936 llvm::Type *ElemTy = AType->getElementType();
6937 unsigned NumElements = AType->getNumElements();
6938
6939 // Wide strings have either 2-byte or 4-byte elements.
6940 if (ElemTy->getPrimitiveSizeInBits() == 16) {
6942 Elements.reserve(NumElements);
6943
6944 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
6945 Elements.push_back(E->getCodeUnit(i));
6946 Elements.resize(NumElements);
6947 return llvm::ConstantDataArray::get(VMContext, Elements);
6948 }
6949
6950 assert(ElemTy->getPrimitiveSizeInBits() == 32);
6952 Elements.reserve(NumElements);
6953
6954 for(unsigned i = 0, e = E->getLength(); i != e; ++i)
6955 Elements.push_back(E->getCodeUnit(i));
6956 Elements.resize(NumElements);
6957 return llvm::ConstantDataArray::get(VMContext, Elements);
6958}
6959
6960static llvm::GlobalVariable *
6961GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT,
6962 CodeGenModule &CGM, StringRef GlobalName,
6963 CharUnits Alignment) {
6964 unsigned AddrSpace = CGM.getContext().getTargetAddressSpace(
6966
6967 llvm::Module &M = CGM.getModule();
6968 // Create a global variable for this string
6969 auto *GV = new llvm::GlobalVariable(
6970 M, C->getType(), !CGM.getLangOpts().WritableStrings, LT, C, GlobalName,
6971 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
6972 GV->setAlignment(Alignment.getAsAlign());
6973 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6974 if (GV->isWeakForLinker()) {
6975 assert(CGM.supportsCOMDAT() && "Only COFF uses weak string literals");
6976 GV->setComdat(M.getOrInsertComdat(GV->getName()));
6977 }
6978 CGM.setDSOLocal(GV);
6979
6980 return GV;
6981}
6982
6983/// GetAddrOfConstantStringFromLiteral - Return a pointer to a
6984/// constant array for the given string literal.
6987 StringRef Name) {
6988 CharUnits Alignment =
6989 getContext().getAlignOfGlobalVarInChars(S->getType(), /*VD=*/nullptr);
6990
6991 llvm::Constant *C = GetConstantArrayFromStringLiteral(S);
6992 llvm::GlobalVariable **Entry = nullptr;
6993 if (!LangOpts.WritableStrings) {
6994 Entry = &ConstantStringMap[C];
6995 if (auto GV = *Entry) {
6996 if (uint64_t(Alignment.getQuantity()) > GV->getAlignment())
6997 GV->setAlignment(Alignment.getAsAlign());
6999 GV->getValueType(), Alignment);
7000 }
7001 }
7002
7003 SmallString<256> MangledNameBuffer;
7004 StringRef GlobalVariableName;
7005 llvm::GlobalValue::LinkageTypes LT;
7006
7007 // Mangle the string literal if that's how the ABI merges duplicate strings.
7008 // Don't do it if they are writable, since we don't want writes in one TU to
7009 // affect strings in another.
7010 if (getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
7011 !LangOpts.WritableStrings) {
7012 llvm::raw_svector_ostream Out(MangledNameBuffer);
7014 LT = llvm::GlobalValue::LinkOnceODRLinkage;
7015 GlobalVariableName = MangledNameBuffer;
7016 } else {
7017 LT = llvm::GlobalValue::PrivateLinkage;
7018 GlobalVariableName = Name;
7019 }
7020
7021 auto GV = GenerateStringLiteral(C, LT, *this, GlobalVariableName, Alignment);
7022
7024 if (DI && getCodeGenOpts().hasReducedDebugInfo())
7025 DI->AddStringLiteralDebugInfo(GV, S);
7026
7027 if (Entry)
7028 *Entry = GV;
7029
7030 SanitizerMD->reportGlobal(GV, S->getStrTokenLoc(0), "<string literal>");
7031
7033 GV->getValueType(), Alignment);
7034}
7035
7036/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant
7037/// array for the given ObjCEncodeExpr node.
7045
7046/// GetAddrOfConstantCString - Returns a pointer to a character array containing
7047/// the literal and a terminating '\0' character.
7048/// The result has pointer to array type.
7050 StringRef GlobalName) {
7051 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
7053 getContext().CharTy, /*VD=*/nullptr);
7054
7055 llvm::Constant *C =
7056 llvm::ConstantDataArray::getString(getLLVMContext(), StrWithNull, false);
7057
7058 // Don't share any string literals if strings aren't constant.
7059 llvm::GlobalVariable **Entry = nullptr;
7060 if (!LangOpts.WritableStrings) {
7061 Entry = &ConstantStringMap[C];
7062 if (auto GV = *Entry) {
7063 if (uint64_t(Alignment.getQuantity()) > GV->getAlignment())
7064 GV->setAlignment(Alignment.getAsAlign());
7066 GV->getValueType(), Alignment);
7067 }
7068 }
7069
7070 // Create a global variable for this.
7071 auto GV = GenerateStringLiteral(C, llvm::GlobalValue::PrivateLinkage, *this,
7072 GlobalName, Alignment);
7073 if (Entry)
7074 *Entry = GV;
7075
7077 GV->getValueType(), Alignment);
7078}
7079
7081 const MaterializeTemporaryExpr *E, const Expr *Init) {
7082 assert((E->getStorageDuration() == SD_Static ||
7083 E->getStorageDuration() == SD_Thread) && "not a global temporary");
7084 const auto *VD = cast<VarDecl>(E->getExtendingDecl());
7085
7086 // If we're not materializing a subobject of the temporary, keep the
7087 // cv-qualifiers from the type of the MaterializeTemporaryExpr.
7088 QualType MaterializedType = Init->getType();
7089 if (Init == E->getSubExpr())
7090 MaterializedType = E->getType();
7091
7092 CharUnits Align = getContext().getTypeAlignInChars(MaterializedType);
7093
7094 auto InsertResult = MaterializedGlobalTemporaryMap.insert({E, nullptr});
7095 if (!InsertResult.second) {
7096 // We've seen this before: either we already created it or we're in the
7097 // process of doing so.
7098 if (!InsertResult.first->second) {
7099 // We recursively re-entered this function, probably during emission of
7100 // the initializer. Create a placeholder. We'll clean this up in the
7101 // outer call, at the end of this function.
7102 llvm::Type *Type = getTypes().ConvertTypeForMem(MaterializedType);
7103 InsertResult.first->second = new llvm::GlobalVariable(
7104 getModule(), Type, false, llvm::GlobalVariable::InternalLinkage,
7105 nullptr);
7106 }
7107 return ConstantAddress(InsertResult.first->second,
7108 llvm::cast<llvm::GlobalVariable>(
7109 InsertResult.first->second->stripPointerCasts())
7110 ->getValueType(),
7111 Align);
7112 }
7113
7114 // FIXME: If an externally-visible declaration extends multiple temporaries,
7115 // we need to give each temporary the same name in every translation unit (and
7116 // we also need to make the temporaries externally-visible).
7117 SmallString<256> Name;
7118 llvm::raw_svector_ostream Out(Name);
7120 VD, E->getManglingNumber(), Out);
7121
7122 APValue *Value = nullptr;
7123 if (E->getStorageDuration() == SD_Static && VD->evaluateValue()) {
7124 // If the initializer of the extending declaration is a constant
7125 // initializer, we should have a cached constant initializer for this
7126 // temporary. Note that this might have a different value from the value
7127 // computed by evaluating the initializer if the surrounding constant
7128 // expression modifies the temporary.
7129 Value = E->getOrCreateValue(false);
7130 }
7131
7132 // Try evaluating it now, it might have a constant initializer.
7133 Expr::EvalResult EvalResult;
7134 if (!Value && Init->EvaluateAsRValue(EvalResult, getContext()) &&
7135 !EvalResult.hasSideEffects())
7136 Value = &EvalResult.Val;
7137
7138 LangAS AddrSpace = GetGlobalVarAddressSpace(VD);
7139
7140 std::optional<ConstantEmitter> emitter;
7141 llvm::Constant *InitialValue = nullptr;
7142 bool Constant = false;
7143 llvm::Type *Type;
7144 if (Value) {
7145 // The temporary has a constant initializer, use it.
7146 emitter.emplace(*this);
7147 InitialValue = emitter->emitForInitializer(*Value, AddrSpace,
7148 MaterializedType);
7149 Constant =
7150 MaterializedType.isConstantStorage(getContext(), /*ExcludeCtor*/ Value,
7151 /*ExcludeDtor*/ false);
7152 Type = InitialValue->getType();
7153 } else {
7154 // No initializer, the initialization will be provided when we
7155 // initialize the declaration which performed lifetime extension.
7156 Type = getTypes().ConvertTypeForMem(MaterializedType);
7157 }
7158
7159 // Create a global variable for this lifetime-extended temporary.
7160 llvm::GlobalValue::LinkageTypes Linkage = getLLVMLinkageVarDefinition(VD);
7161 if (Linkage == llvm::GlobalVariable::ExternalLinkage) {
7162 const VarDecl *InitVD;
7163 if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
7165 // Temporaries defined inside a class get linkonce_odr linkage because the
7166 // class can be defined in multiple translation units.
7167 Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
7168 } else {
7169 // There is no need for this temporary to have external linkage if the
7170 // VarDecl has external linkage.
7171 Linkage = llvm::GlobalVariable::InternalLinkage;
7172 }
7173 }
7174 auto TargetAS = getContext().getTargetAddressSpace(AddrSpace);
7175 auto *GV = new llvm::GlobalVariable(
7176 getModule(), Type, Constant, Linkage, InitialValue, Name.c_str(),
7177 /*InsertBefore=*/nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
7178 if (emitter) emitter->finalize(GV);
7179 // Don't assign dllimport or dllexport to local linkage globals.
7180 if (!llvm::GlobalValue::isLocalLinkage(Linkage)) {
7181 setGVProperties(GV, VD);
7182 if (GV->getDLLStorageClass() == llvm::GlobalVariable::DLLExportStorageClass)
7183 // The reference temporary should never be dllexport.
7184 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
7185 }
7186 GV->setAlignment(Align.getAsAlign());
7187 if (supportsCOMDAT() && GV->isWeakForLinker())
7188 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
7189 if (VD->getTLSKind())
7190 setTLSMode(GV, *VD);
7191 llvm::Constant *CV = GV;
7192 if (AddrSpace != LangAS::Default)
7194 *this, GV, AddrSpace,
7195 llvm::PointerType::get(
7197 getContext().getTargetAddressSpace(LangAS::Default)));
7198
7199 // Update the map with the new temporary. If we created a placeholder above,
7200 // replace it with the new global now.
7201 llvm::Constant *&Entry = MaterializedGlobalTemporaryMap[E];
7202 if (Entry) {
7203 Entry->replaceAllUsesWith(CV);
7204 llvm::cast<llvm::GlobalVariable>(Entry)->eraseFromParent();
7205 }
7206 Entry = CV;
7207
7208 return ConstantAddress(CV, Type, Align);
7209}
7210
7211/// EmitObjCPropertyImplementations - Emit information for synthesized
7212/// properties for an implementation.
7213void CodeGenModule::EmitObjCPropertyImplementations(const
7215 for (const auto *PID : D->property_impls()) {
7216 // Dynamic is just for type-checking.
7217 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) {
7218 ObjCPropertyDecl *PD = PID->getPropertyDecl();
7219
7220 // Determine which methods need to be implemented, some may have
7221 // been overridden. Note that ::isPropertyAccessor is not the method
7222 // we want, that just indicates if the decl came from a
7223 // property. What we want to know is if the method is defined in
7224 // this implementation.
7225 auto *Getter = PID->getGetterMethodDecl();
7226 if (!Getter || Getter->isSynthesizedAccessorStub())
7228 const_cast<ObjCImplementationDecl *>(D), PID);
7229 auto *Setter = PID->getSetterMethodDecl();
7230 if (!PD->isReadOnly() && (!Setter || Setter->isSynthesizedAccessorStub()))
7232 const_cast<ObjCImplementationDecl *>(D), PID);
7233 }
7234 }
7235}
7236
7238 const ObjCInterfaceDecl *iface = impl->getClassInterface();
7239 for (const ObjCIvarDecl *ivar = iface->all_declared_ivar_begin();
7240 ivar; ivar = ivar->getNextIvar())
7241 if (ivar->getType().isDestructedType())
7242 return true;
7243
7244 return false;
7245}
7246
7249 CodeGenFunction CGF(CGM);
7251 E = D->init_end(); B != E; ++B) {
7252 CXXCtorInitializer *CtorInitExp = *B;
7253 Expr *Init = CtorInitExp->getInit();
7254 if (!CGF.isTrivialInitializer(Init))
7255 return false;
7256 }
7257 return true;
7258}
7259
7260/// EmitObjCIvarInitializations - Emit information for ivar initialization
7261/// for an implementation.
7262void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
7263 // We might need a .cxx_destruct even if we don't have any ivar initializers.
7264 if (needsDestructMethod(D)) {
7265 const IdentifierInfo *II = &getContext().Idents.get(".cxx_destruct");
7266 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
7267 ObjCMethodDecl *DTORMethod = ObjCMethodDecl::Create(
7268 getContext(), D->getLocation(), D->getLocation(), cxxSelector,
7269 getContext().VoidTy, nullptr, D,
7270 /*isInstance=*/true, /*isVariadic=*/false,
7271 /*isPropertyAccessor=*/true, /*isSynthesizedAccessorStub=*/false,
7272 /*isImplicitlyDeclared=*/true,
7273 /*isDefined=*/false, ObjCImplementationControl::Required);
7274 D->addInstanceMethod(DTORMethod);
7275 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod, false);
7276 D->setHasDestructors(true);
7277 }
7278
7279 // If the implementation doesn't have any ivar initializers, we don't need
7280 // a .cxx_construct.
7281 if (D->getNumIvarInitializers() == 0 ||
7282 AllTrivialInitializers(*this, D))
7283 return;
7284
7285 const IdentifierInfo *II = &getContext().Idents.get(".cxx_construct");
7286 Selector cxxSelector = getContext().Selectors.getSelector(0, &II);
7287 // The constructor returns 'self'.
7288 ObjCMethodDecl *CTORMethod = ObjCMethodDecl::Create(
7289 getContext(), D->getLocation(), D->getLocation(), cxxSelector,
7290 getContext().getObjCIdType(), nullptr, D, /*isInstance=*/true,
7291 /*isVariadic=*/false,
7292 /*isPropertyAccessor=*/true, /*isSynthesizedAccessorStub=*/false,
7293 /*isImplicitlyDeclared=*/true,
7294 /*isDefined=*/false, ObjCImplementationControl::Required);
7295 D->addInstanceMethod(CTORMethod);
7296 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod, true);
7298}
7299
7300// EmitLinkageSpec - Emit all declarations in a linkage spec.
7301void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) {
7302 if (LSD->getLanguage() != LinkageSpecLanguageIDs::C &&
7304 ErrorUnsupported(LSD, "linkage spec");
7305 return;
7306 }
7307
7308 EmitDeclContext(LSD);
7309}
7310
7311void CodeGenModule::EmitTopLevelStmt(const TopLevelStmtDecl *D) {
7312 // Device code should not be at top level.
7313 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
7314 return;
7315
7316 std::unique_ptr<CodeGenFunction> &CurCGF =
7317 GlobalTopLevelStmtBlockInFlight.first;
7318
7319 // We emitted a top-level stmt but after it there is initialization.
7320 // Stop squashing the top-level stmts into a single function.
7321 if (CurCGF && CXXGlobalInits.back() != CurCGF->CurFn) {
7322 CurCGF->FinishFunction(D->getEndLoc());
7323 CurCGF = nullptr;
7324 }
7325
7326 if (!CurCGF) {
7327 // void __stmts__N(void)
7328 // FIXME: Ask the ABI name mangler to pick a name.
7329 std::string Name = "__stmts__" + llvm::utostr(CXXGlobalInits.size());
7330 FunctionArgList Args;
7331 QualType RetTy = getContext().VoidTy;
7332 const CGFunctionInfo &FnInfo =
7334 llvm::FunctionType *FnTy = getTypes().GetFunctionType(FnInfo);
7335 llvm::Function *Fn = llvm::Function::Create(
7336 FnTy, llvm::GlobalValue::InternalLinkage, Name, &getModule());
7337
7338 CurCGF.reset(new CodeGenFunction(*this));
7339 GlobalTopLevelStmtBlockInFlight.second = D;
7340 CurCGF->StartFunction(GlobalDecl(), RetTy, Fn, FnInfo, Args,
7341 D->getBeginLoc(), D->getBeginLoc());
7342 CXXGlobalInits.push_back(Fn);
7343 }
7344
7345 CurCGF->EmitStmt(D->getStmt());
7346}
7347
7348void CodeGenModule::EmitDeclContext(const DeclContext *DC) {
7349 for (auto *I : DC->decls()) {
7350 // Unlike other DeclContexts, the contents of an ObjCImplDecl at TU scope
7351 // are themselves considered "top-level", so EmitTopLevelDecl on an
7352 // ObjCImplDecl does not recursively visit them. We need to do that in
7353 // case they're nested inside another construct (LinkageSpecDecl /
7354 // ExportDecl) that does stop them from being considered "top-level".
7355 if (auto *OID = dyn_cast<ObjCImplDecl>(I)) {
7356 for (auto *M : OID->methods())
7358 }
7359
7361 }
7362}
7363
7364/// EmitTopLevelDecl - Emit code for a single top level declaration.
7366 // Ignore dependent declarations.
7367 if (D->isTemplated())
7368 return;
7369
7370 // Consteval function shouldn't be emitted.
7371 if (auto *FD = dyn_cast<FunctionDecl>(D); FD && FD->isImmediateFunction())
7372 return;
7373
7374 switch (D->getKind()) {
7375 case Decl::CXXConversion:
7376 case Decl::CXXMethod:
7377 case Decl::Function:
7379 // Always provide some coverage mapping
7380 // even for the functions that aren't emitted.
7382 break;
7383
7384 case Decl::CXXDeductionGuide:
7385 // Function-like, but does not result in code emission.
7386 break;
7387
7388 case Decl::Var:
7389 case Decl::Decomposition:
7390 case Decl::VarTemplateSpecialization:
7392 if (auto *DD = dyn_cast<DecompositionDecl>(D))
7393 for (auto *B : DD->flat_bindings())
7394 if (auto *HD = B->getHoldingVar())
7395 EmitGlobal(HD);
7396
7397 break;
7398
7399 // Indirect fields from global anonymous structs and unions can be
7400 // ignored; only the actual variable requires IR gen support.
7401 case Decl::IndirectField:
7402 break;
7403
7404 // C++ Decls
7405 case Decl::Namespace:
7406 EmitDeclContext(cast<NamespaceDecl>(D));
7407 break;
7408 case Decl::ClassTemplateSpecialization: {
7409 const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
7410 if (CGDebugInfo *DI = getModuleDebugInfo())
7411 if (Spec->getSpecializationKind() ==
7413 Spec->hasDefinition())
7414 DI->completeTemplateDefinition(*Spec);
7415 } [[fallthrough]];
7416 case Decl::CXXRecord: {
7418 if (CGDebugInfo *DI = getModuleDebugInfo()) {
7419 if (CRD->hasDefinition())
7420 DI->EmitAndRetainType(
7421 getContext().getCanonicalTagType(cast<RecordDecl>(D)));
7422 if (auto *ES = D->getASTContext().getExternalSource())
7423 if (ES->hasExternalDefinitions(D) == ExternalASTSource::EK_Never)
7424 DI->completeUnusedClass(*CRD);
7425 }
7426 // Emit any static data members, they may be definitions.
7427 for (auto *I : CRD->decls())
7430 break;
7431 }
7432 // No code generation needed.
7433 case Decl::UsingShadow:
7434 case Decl::ClassTemplate:
7435 case Decl::VarTemplate:
7436 case Decl::Concept:
7437 case Decl::VarTemplatePartialSpecialization:
7438 case Decl::FunctionTemplate:
7439 case Decl::TypeAliasTemplate:
7440 case Decl::Block:
7441 case Decl::Empty:
7442 case Decl::Binding:
7443 break;
7444 case Decl::Using: // using X; [C++]
7445 if (CGDebugInfo *DI = getModuleDebugInfo())
7446 DI->EmitUsingDecl(cast<UsingDecl>(*D));
7447 break;
7448 case Decl::UsingEnum: // using enum X; [C++]
7449 if (CGDebugInfo *DI = getModuleDebugInfo())
7450 DI->EmitUsingEnumDecl(cast<UsingEnumDecl>(*D));
7451 break;
7452 case Decl::NamespaceAlias:
7453 if (CGDebugInfo *DI = getModuleDebugInfo())
7454 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
7455 break;
7456 case Decl::UsingDirective: // using namespace X; [C++]
7457 if (CGDebugInfo *DI = getModuleDebugInfo())
7458 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
7459 break;
7460 case Decl::CXXConstructor:
7462 break;
7463 case Decl::CXXDestructor:
7465 break;
7466
7467 case Decl::StaticAssert:
7468 // Nothing to do.
7469 break;
7470
7471 // Objective-C Decls
7472
7473 // Forward declarations, no (immediate) code generation.
7474 case Decl::ObjCInterface:
7475 case Decl::ObjCCategory:
7476 break;
7477
7478 case Decl::ObjCProtocol: {
7479 auto *Proto = cast<ObjCProtocolDecl>(D);
7480 if (Proto->isThisDeclarationADefinition())
7481 ObjCRuntime->GenerateProtocol(Proto);
7482 break;
7483 }
7484
7485 case Decl::ObjCCategoryImpl:
7486 // Categories have properties but don't support synthesize so we
7487 // can ignore them here.
7488 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
7489 break;
7490
7491 case Decl::ObjCImplementation: {
7492 auto *OMD = cast<ObjCImplementationDecl>(D);
7493 EmitObjCPropertyImplementations(OMD);
7494 EmitObjCIvarInitializations(OMD);
7495 ObjCRuntime->GenerateClass(OMD);
7496 // Emit global variable debug information.
7497 if (CGDebugInfo *DI = getModuleDebugInfo())
7498 if (getCodeGenOpts().hasReducedDebugInfo())
7499 DI->getOrCreateInterfaceType(getContext().getObjCInterfaceType(
7500 OMD->getClassInterface()), OMD->getLocation());
7501 break;
7502 }
7503 case Decl::ObjCMethod: {
7504 auto *OMD = cast<ObjCMethodDecl>(D);
7505 // If this is not a prototype, emit the body.
7506 if (OMD->getBody())
7508 break;
7509 }
7510 case Decl::ObjCCompatibleAlias:
7511 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
7512 break;
7513
7514 case Decl::PragmaComment: {
7515 const auto *PCD = cast<PragmaCommentDecl>(D);
7516 switch (PCD->getCommentKind()) {
7517 case PCK_Unknown:
7518 llvm_unreachable("unexpected pragma comment kind");
7519 case PCK_Linker:
7520 AppendLinkerOptions(PCD->getArg());
7521 break;
7522 case PCK_Lib:
7523 AddDependentLib(PCD->getArg());
7524 break;
7525 case PCK_Compiler:
7526 case PCK_ExeStr:
7527 case PCK_User:
7528 break; // We ignore all of these.
7529 }
7530 break;
7531 }
7532
7533 case Decl::PragmaDetectMismatch: {
7534 const auto *PDMD = cast<PragmaDetectMismatchDecl>(D);
7535 AddDetectMismatch(PDMD->getName(), PDMD->getValue());
7536 break;
7537 }
7538
7539 case Decl::LinkageSpec:
7540 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
7541 break;
7542
7543 case Decl::FileScopeAsm: {
7544 // File-scope asm is ignored during device-side CUDA compilation.
7545 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
7546 break;
7547 // File-scope asm is ignored during device-side OpenMP compilation.
7548 if (LangOpts.OpenMPIsTargetDevice)
7549 break;
7550 // File-scope asm is ignored during device-side SYCL compilation.
7551 if (LangOpts.SYCLIsDevice)
7552 break;
7553 auto *AD = cast<FileScopeAsmDecl>(D);
7554 getModule().appendModuleInlineAsm(AD->getAsmString());
7555 break;
7556 }
7557
7558 case Decl::TopLevelStmt:
7559 EmitTopLevelStmt(cast<TopLevelStmtDecl>(D));
7560 break;
7561
7562 case Decl::Import: {
7563 auto *Import = cast<ImportDecl>(D);
7564
7565 // If we've already imported this module, we're done.
7566 if (!ImportedModules.insert(Import->getImportedModule()))
7567 break;
7568
7569 // Emit debug information for direct imports.
7570 if (!Import->getImportedOwningModule()) {
7571 if (CGDebugInfo *DI = getModuleDebugInfo())
7572 DI->EmitImportDecl(*Import);
7573 }
7574
7575 // For C++ standard modules we are done - we will call the module
7576 // initializer for imported modules, and that will likewise call those for
7577 // any imports it has.
7578 if (CXX20ModuleInits && Import->getImportedModule() &&
7579 Import->getImportedModule()->isNamedModule())
7580 break;
7581
7582 // For clang C++ module map modules the initializers for sub-modules are
7583 // emitted here.
7584
7585 // Find all of the submodules and emit the module initializers.
7588 Visited.insert(Import->getImportedModule());
7589 Stack.push_back(Import->getImportedModule());
7590
7591 while (!Stack.empty()) {
7592 clang::Module *Mod = Stack.pop_back_val();
7593 if (!EmittedModuleInitializers.insert(Mod).second)
7594 continue;
7595
7596 for (auto *D : Context.getModuleInitializers(Mod))
7598
7599 // Visit the submodules of this module.
7600 for (auto *Submodule : Mod->submodules()) {
7601 // Skip explicit children; they need to be explicitly imported to emit
7602 // the initializers.
7603 if (Submodule->IsExplicit)
7604 continue;
7605
7606 if (Visited.insert(Submodule).second)
7607 Stack.push_back(Submodule);
7608 }
7609 }
7610 break;
7611 }
7612
7613 case Decl::Export:
7614 EmitDeclContext(cast<ExportDecl>(D));
7615 break;
7616
7617 case Decl::OMPThreadPrivate:
7619 break;
7620
7621 case Decl::OMPAllocate:
7623 break;
7624
7625 case Decl::OMPDeclareReduction:
7627 break;
7628
7629 case Decl::OMPDeclareMapper:
7631 break;
7632
7633 case Decl::OMPRequires:
7635 break;
7636
7637 case Decl::Typedef:
7638 case Decl::TypeAlias: // using foo = bar; [C++11]
7639 if (CGDebugInfo *DI = getModuleDebugInfo())
7640 DI->EmitAndRetainType(getContext().getTypedefType(
7641 ElaboratedTypeKeyword::None, /*Qualifier=*/std::nullopt,
7643 break;
7644
7645 case Decl::Record:
7646 if (CGDebugInfo *DI = getModuleDebugInfo())
7648 DI->EmitAndRetainType(
7649 getContext().getCanonicalTagType(cast<RecordDecl>(D)));
7650 break;
7651
7652 case Decl::Enum:
7653 if (CGDebugInfo *DI = getModuleDebugInfo())
7654 if (cast<EnumDecl>(D)->getDefinition())
7655 DI->EmitAndRetainType(
7656 getContext().getCanonicalTagType(cast<EnumDecl>(D)));
7657 break;
7658
7659 case Decl::HLSLRootSignature:
7661 break;
7662 case Decl::HLSLBuffer:
7664 break;
7665
7666 case Decl::OpenACCDeclare:
7668 break;
7669 case Decl::OpenACCRoutine:
7671 break;
7672
7673 default:
7674 // Make sure we handled everything we should, every other kind is a
7675 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind
7676 // function. Need to recode Decl::Kind to do that easily.
7677 assert(isa<TypeDecl>(D) && "Unsupported decl kind");
7678 break;
7679 }
7680}
7681
7683 // Do we need to generate coverage mapping?
7684 if (!CodeGenOpts.CoverageMapping)
7685 return;
7686 switch (D->getKind()) {
7687 case Decl::CXXConversion:
7688 case Decl::CXXMethod:
7689 case Decl::Function:
7690 case Decl::ObjCMethod:
7691 case Decl::CXXConstructor:
7692 case Decl::CXXDestructor: {
7693 if (!cast<FunctionDecl>(D)->doesThisDeclarationHaveABody())
7694 break;
7696 if (LimitedCoverage && SM.getMainFileID() != SM.getFileID(D->getBeginLoc()))
7697 break;
7699 SM.isInSystemHeader(D->getBeginLoc()))
7700 break;
7701 DeferredEmptyCoverageMappingDecls.try_emplace(D, true);
7702 break;
7703 }
7704 default:
7705 break;
7706 };
7707}
7708
7710 // Do we need to generate coverage mapping?
7711 if (!CodeGenOpts.CoverageMapping)
7712 return;
7713 if (const auto *Fn = dyn_cast<FunctionDecl>(D)) {
7714 if (Fn->isTemplateInstantiation())
7715 ClearUnusedCoverageMapping(Fn->getTemplateInstantiationPattern());
7716 }
7717 DeferredEmptyCoverageMappingDecls.insert_or_assign(D, false);
7718}
7719
7721 // We call takeVector() here to avoid use-after-free.
7722 // FIXME: DeferredEmptyCoverageMappingDecls is getting mutated because
7723 // we deserialize function bodies to emit coverage info for them, and that
7724 // deserializes more declarations. How should we handle that case?
7725 for (const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
7726 if (!Entry.second)
7727 continue;
7728 const Decl *D = Entry.first;
7729 switch (D->getKind()) {
7730 case Decl::CXXConversion:
7731 case Decl::CXXMethod:
7732 case Decl::Function:
7733 case Decl::ObjCMethod: {
7734 CodeGenPGO PGO(*this);
7737 getFunctionLinkage(GD));
7738 break;
7739 }
7740 case Decl::CXXConstructor: {
7741 CodeGenPGO PGO(*this);
7744 getFunctionLinkage(GD));
7745 break;
7746 }
7747 case Decl::CXXDestructor: {
7748 CodeGenPGO PGO(*this);
7751 getFunctionLinkage(GD));
7752 break;
7753 }
7754 default:
7755 break;
7756 };
7757 }
7758}
7759
7761 // In order to transition away from "__original_main" gracefully, emit an
7762 // alias for "main" in the no-argument case so that libc can detect when
7763 // new-style no-argument main is in used.
7764 if (llvm::Function *F = getModule().getFunction("main")) {
7765 if (!F->isDeclaration() && F->arg_size() == 0 && !F->isVarArg() &&
7766 F->getReturnType()->isIntegerTy(Context.getTargetInfo().getIntWidth())) {
7767 auto *GA = llvm::GlobalAlias::create("__main_void", F);
7768 GA->setVisibility(llvm::GlobalValue::HiddenVisibility);
7769 }
7770 }
7771}
7772
7773/// Turns the given pointer into a constant.
7774static llvm::Constant *GetPointerConstant(llvm::LLVMContext &Context,
7775 const void *Ptr) {
7776 uintptr_t PtrInt = reinterpret_cast<uintptr_t>(Ptr);
7777 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
7778 return llvm::ConstantInt::get(i64, PtrInt);
7779}
7780
7782 llvm::NamedMDNode *&GlobalMetadata,
7783 GlobalDecl D,
7784 llvm::GlobalValue *Addr) {
7785 if (!GlobalMetadata)
7786 GlobalMetadata =
7787 CGM.getModule().getOrInsertNamedMetadata("clang.global.decl.ptrs");
7788
7789 // TODO: should we report variant information for ctors/dtors?
7790 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
7791 llvm::ConstantAsMetadata::get(GetPointerConstant(
7792 CGM.getLLVMContext(), D.getDecl()))};
7793 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.getLLVMContext(), Ops));
7794}
7795
7796bool CodeGenModule::CheckAndReplaceExternCIFuncs(llvm::GlobalValue *Elem,
7797 llvm::GlobalValue *CppFunc) {
7798 // Store the list of ifuncs we need to replace uses in.
7799 llvm::SmallVector<llvm::GlobalIFunc *> IFuncs;
7800 // List of ConstantExprs that we should be able to delete when we're done
7801 // here.
7802 llvm::SmallVector<llvm::ConstantExpr *> CEs;
7803
7804 // It isn't valid to replace the extern-C ifuncs if all we find is itself!
7805 if (Elem == CppFunc)
7806 return false;
7807
7808 // First make sure that all users of this are ifuncs (or ifuncs via a
7809 // bitcast), and collect the list of ifuncs and CEs so we can work on them
7810 // later.
7811 for (llvm::User *User : Elem->users()) {
7812 // Users can either be a bitcast ConstExpr that is used by the ifuncs, OR an
7813 // ifunc directly. In any other case, just give up, as we don't know what we
7814 // could break by changing those.
7815 if (auto *ConstExpr = dyn_cast<llvm::ConstantExpr>(User)) {
7816 if (ConstExpr->getOpcode() != llvm::Instruction::BitCast)
7817 return false;
7818
7819 for (llvm::User *CEUser : ConstExpr->users()) {
7820 if (auto *IFunc = dyn_cast<llvm::GlobalIFunc>(CEUser)) {
7821 IFuncs.push_back(IFunc);
7822 } else {
7823 return false;
7824 }
7825 }
7826 CEs.push_back(ConstExpr);
7827 } else if (auto *IFunc = dyn_cast<llvm::GlobalIFunc>(User)) {
7828 IFuncs.push_back(IFunc);
7829 } else {
7830 // This user is one we don't know how to handle, so fail redirection. This
7831 // will result in an ifunc retaining a resolver name that will ultimately
7832 // fail to be resolved to a defined function.
7833 return false;
7834 }
7835 }
7836
7837 // Now we know this is a valid case where we can do this alias replacement, we
7838 // need to remove all of the references to Elem (and the bitcasts!) so we can
7839 // delete it.
7840 for (llvm::GlobalIFunc *IFunc : IFuncs)
7841 IFunc->setResolver(nullptr);
7842 for (llvm::ConstantExpr *ConstExpr : CEs)
7843 ConstExpr->destroyConstant();
7844
7845 // We should now be out of uses for the 'old' version of this function, so we
7846 // can erase it as well.
7847 Elem->eraseFromParent();
7848
7849 for (llvm::GlobalIFunc *IFunc : IFuncs) {
7850 // The type of the resolver is always just a function-type that returns the
7851 // type of the IFunc, so create that here. If the type of the actual
7852 // resolver doesn't match, it just gets bitcast to the right thing.
7853 auto *ResolverTy =
7854 llvm::FunctionType::get(IFunc->getType(), /*isVarArg*/ false);
7855 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
7856 CppFunc->getName(), ResolverTy, {}, /*ForVTable*/ false);
7857 IFunc->setResolver(Resolver);
7858 }
7859 return true;
7860}
7861
7862/// For each function which is declared within an extern "C" region and marked
7863/// as 'used', but has internal linkage, create an alias from the unmangled
7864/// name to the mangled name if possible. People expect to be able to refer
7865/// to such functions with an unmangled name from inline assembly within the
7866/// same translation unit.
7867void CodeGenModule::EmitStaticExternCAliases() {
7868 if (!getTargetCodeGenInfo().shouldEmitStaticExternCAliases())
7869 return;
7870 for (auto &I : StaticExternCValues) {
7871 const IdentifierInfo *Name = I.first;
7872 llvm::GlobalValue *Val = I.second;
7873
7874 // If Val is null, that implies there were multiple declarations that each
7875 // had a claim to the unmangled name. In this case, generation of the alias
7876 // is suppressed. See CodeGenModule::MaybeHandleStaticInExternC.
7877 if (!Val)
7878 break;
7879
7880 llvm::GlobalValue *ExistingElem =
7881 getModule().getNamedValue(Name->getName());
7882
7883 // If there is either not something already by this name, or we were able to
7884 // replace all uses from IFuncs, create the alias.
7885 if (!ExistingElem || CheckAndReplaceExternCIFuncs(ExistingElem, Val))
7886 addCompilerUsedGlobal(llvm::GlobalAlias::create(Name->getName(), Val));
7887 }
7888}
7889
7891 GlobalDecl &Result) const {
7892 auto Res = Manglings.find(MangledName);
7893 if (Res == Manglings.end())
7894 return false;
7895 Result = Res->getValue();
7896 return true;
7897}
7898
7899/// Emits metadata nodes associating all the global values in the
7900/// current module with the Decls they came from. This is useful for
7901/// projects using IR gen as a subroutine.
7902///
7903/// Since there's currently no way to associate an MDNode directly
7904/// with an llvm::GlobalValue, we create a global named metadata
7905/// with the name 'clang.global.decl.ptrs'.
7906void CodeGenModule::EmitDeclMetadata() {
7907 llvm::NamedMDNode *GlobalMetadata = nullptr;
7908
7909 for (auto &I : MangledDeclNames) {
7910 llvm::GlobalValue *Addr = getModule().getNamedValue(I.second);
7911 // Some mangled names don't necessarily have an associated GlobalValue
7912 // in this module, e.g. if we mangled it for DebugInfo.
7913 if (Addr)
7914 EmitGlobalDeclMetadata(*this, GlobalMetadata, I.first, Addr);
7915 }
7916}
7917
7918/// Emits metadata nodes for all the local variables in the current
7919/// function.
7920void CodeGenFunction::EmitDeclMetadata() {
7921 if (LocalDeclMap.empty()) return;
7922
7923 llvm::LLVMContext &Context = getLLVMContext();
7924
7925 // Find the unique metadata ID for this name.
7926 unsigned DeclPtrKind = Context.getMDKindID("clang.decl.ptr");
7927
7928 llvm::NamedMDNode *GlobalMetadata = nullptr;
7929
7930 for (auto &I : LocalDeclMap) {
7931 const Decl *D = I.first;
7932 llvm::Value *Addr = I.second.emitRawPointer(*this);
7933 if (auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
7934 llvm::Value *DAddr = GetPointerConstant(getLLVMContext(), D);
7935 Alloca->setMetadata(
7936 DeclPtrKind, llvm::MDNode::get(
7937 Context, llvm::ValueAsMetadata::getConstant(DAddr)));
7938 } else if (auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
7939 GlobalDecl GD = GlobalDecl(cast<VarDecl>(D));
7940 EmitGlobalDeclMetadata(CGM, GlobalMetadata, GD, GV);
7941 }
7942 }
7943}
7944
7945void CodeGenModule::EmitVersionIdentMetadata() {
7946 llvm::NamedMDNode *IdentMetadata =
7947 TheModule.getOrInsertNamedMetadata("llvm.ident");
7948 std::string Version = getClangFullVersion();
7949 llvm::LLVMContext &Ctx = TheModule.getContext();
7950
7951 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
7952 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
7953}
7954
7955void CodeGenModule::EmitCommandLineMetadata() {
7956 llvm::NamedMDNode *CommandLineMetadata =
7957 TheModule.getOrInsertNamedMetadata("llvm.commandline");
7958 std::string CommandLine = getCodeGenOpts().RecordCommandLine;
7959 llvm::LLVMContext &Ctx = TheModule.getContext();
7960
7961 llvm::Metadata *CommandLineNode[] = {llvm::MDString::get(Ctx, CommandLine)};
7962 CommandLineMetadata->addOperand(llvm::MDNode::get(Ctx, CommandLineNode));
7963}
7964
7965void CodeGenModule::EmitCoverageFile() {
7966 llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata("llvm.dbg.cu");
7967 if (!CUNode)
7968 return;
7969
7970 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata("llvm.gcov");
7971 llvm::LLVMContext &Ctx = TheModule.getContext();
7972 auto *CoverageDataFile =
7973 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageDataFile);
7974 auto *CoverageNotesFile =
7975 llvm::MDString::get(Ctx, getCodeGenOpts().CoverageNotesFile);
7976 for (int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
7977 llvm::MDNode *CU = CUNode->getOperand(i);
7978 llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
7979 GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
7980 }
7981}
7982
7984 bool ForEH) {
7985 // Return a bogus pointer if RTTI is disabled, unless it's for EH.
7986 // FIXME: should we even be calling this method if RTTI is disabled
7987 // and it's not for EH?
7988 if (!shouldEmitRTTI(ForEH))
7989 return llvm::Constant::getNullValue(GlobalsInt8PtrTy);
7990
7991 if (ForEH && Ty->isObjCObjectPointerType() &&
7992 LangOpts.ObjCRuntime.isGNUFamily())
7993 return ObjCRuntime->GetEHType(Ty);
7994
7996}
7997
7999 // Do not emit threadprivates in simd-only mode.
8000 if (LangOpts.OpenMP && LangOpts.OpenMPSimd)
8001 return;
8002 for (auto RefExpr : D->varlist()) {
8003 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
8004 bool PerformInit =
8005 VD->getAnyInitializer() &&
8006 !VD->getAnyInitializer()->isConstantInitializer(getContext(),
8007 /*ForRef=*/false);
8008
8010 getTypes().ConvertTypeForMem(VD->getType()),
8011 getContext().getDeclAlign(VD));
8012 if (auto InitFunction = getOpenMPRuntime().emitThreadPrivateVarDefinition(
8013 VD, Addr, RefExpr->getBeginLoc(), PerformInit))
8014 CXXGlobalInits.push_back(InitFunction);
8015 }
8016}
8017
8018llvm::Metadata *
8019CodeGenModule::CreateMetadataIdentifierImpl(QualType T, MetadataTypeMap &Map,
8020 StringRef Suffix) {
8021 if (auto *FnType = T->getAs<FunctionProtoType>())
8023 FnType->getReturnType(), FnType->getParamTypes(),
8024 FnType->getExtProtoInfo().withExceptionSpec(EST_None));
8025
8026 llvm::Metadata *&InternalId = Map[T.getCanonicalType()];
8027 if (InternalId)
8028 return InternalId;
8029
8030 if (isExternallyVisible(T->getLinkage())) {
8031 std::string OutName;
8032 llvm::raw_string_ostream Out(OutName);
8034 T, Out, getCodeGenOpts().SanitizeCfiICallNormalizeIntegers);
8035
8036 if (getCodeGenOpts().SanitizeCfiICallNormalizeIntegers)
8037 Out << ".normalized";
8038
8039 Out << Suffix;
8040
8041 InternalId = llvm::MDString::get(getLLVMContext(), Out.str());
8042 } else {
8043 InternalId = llvm::MDNode::getDistinct(getLLVMContext(),
8045 }
8046
8047 return InternalId;
8048}
8049
8051 assert(isa<FunctionType>(T));
8053 getContext(), T, getCodeGenOpts().SanitizeCfiICallGeneralizePointers);
8054 if (getCodeGenOpts().SanitizeCfiICallGeneralizePointers)
8057}
8058
8060 return CreateMetadataIdentifierImpl(T, MetadataIdMap, "");
8061}
8062
8063llvm::Metadata *
8065 return CreateMetadataIdentifierImpl(T, VirtualMetadataIdMap, ".virtual");
8066}
8067
8069 return CreateMetadataIdentifierImpl(T, GeneralizedMetadataIdMap,
8070 ".generalized");
8071}
8072
8073/// Returns whether this module needs the "all-vtables" type identifier.
8075 // Returns true if at least one of vtable-based CFI checkers is enabled and
8076 // is not in the trapping mode.
8077 return ((LangOpts.Sanitize.has(SanitizerKind::CFIVCall) &&
8078 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIVCall)) ||
8079 (LangOpts.Sanitize.has(SanitizerKind::CFINVCall) &&
8080 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFINVCall)) ||
8081 (LangOpts.Sanitize.has(SanitizerKind::CFIDerivedCast) &&
8082 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIDerivedCast)) ||
8083 (LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast) &&
8084 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIUnrelatedCast)));
8085}
8086
8087void CodeGenModule::AddVTableTypeMetadata(llvm::GlobalVariable *VTable,
8088 CharUnits Offset,
8089 const CXXRecordDecl *RD) {
8091 llvm::Metadata *MD = CreateMetadataIdentifierForType(T);
8092 VTable->addTypeMetadata(Offset.getQuantity(), MD);
8093
8094 if (CodeGenOpts.SanitizeCfiCrossDso)
8095 if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
8096 VTable->addTypeMetadata(Offset.getQuantity(),
8097 llvm::ConstantAsMetadata::get(CrossDsoTypeId));
8098
8099 if (NeedAllVtablesTypeId()) {
8100 llvm::Metadata *MD = llvm::MDString::get(getLLVMContext(), "all-vtables");
8101 VTable->addTypeMetadata(Offset.getQuantity(), MD);
8102 }
8103}
8104
8105llvm::SanitizerStatReport &CodeGenModule::getSanStats() {
8106 if (!SanStats)
8107 SanStats = std::make_unique<llvm::SanitizerStatReport>(&getModule());
8108
8109 return *SanStats;
8110}
8111
8112llvm::Value *
8114 CodeGenFunction &CGF) {
8115 llvm::Constant *C = ConstantEmitter(CGF).emitAbstract(E, E->getType());
8116 auto *SamplerT = getOpenCLRuntime().getSamplerType(E->getType().getTypePtr());
8117 auto *FTy = llvm::FunctionType::get(SamplerT, {C->getType()}, false);
8118 auto *Call = CGF.EmitRuntimeCall(
8119 CreateRuntimeFunction(FTy, "__translate_sampler_initializer"), {C});
8120 return Call;
8121}
8122
8124 QualType T, LValueBaseInfo *BaseInfo, TBAAAccessInfo *TBAAInfo) {
8125 return getNaturalTypeAlignment(T->getPointeeType(), BaseInfo, TBAAInfo,
8126 /* forPointeeType= */ true);
8127}
8128
8130 LValueBaseInfo *BaseInfo,
8131 TBAAAccessInfo *TBAAInfo,
8132 bool forPointeeType) {
8133 if (TBAAInfo)
8134 *TBAAInfo = getTBAAAccessInfo(T);
8135
8136 // FIXME: This duplicates logic in ASTContext::getTypeAlignIfKnown. But
8137 // that doesn't return the information we need to compute BaseInfo.
8138
8139 // Honor alignment typedef attributes even on incomplete types.
8140 // We also honor them straight for C++ class types, even as pointees;
8141 // there's an expressivity gap here.
8142 if (auto TT = T->getAs<TypedefType>()) {
8143 if (auto Align = TT->getDecl()->getMaxAlignment()) {
8144 if (BaseInfo)
8146 return getContext().toCharUnitsFromBits(Align);
8147 }
8148 }
8149
8150 bool AlignForArray = T->isArrayType();
8151
8152 // Analyze the base element type, so we don't get confused by incomplete
8153 // array types.
8155
8156 if (T->isIncompleteType()) {
8157 // We could try to replicate the logic from
8158 // ASTContext::getTypeAlignIfKnown, but nothing uses the alignment if the
8159 // type is incomplete, so it's impossible to test. We could try to reuse
8160 // getTypeAlignIfKnown, but that doesn't return the information we need
8161 // to set BaseInfo. So just ignore the possibility that the alignment is
8162 // greater than one.
8163 if (BaseInfo)
8165 return CharUnits::One();
8166 }
8167
8168 if (BaseInfo)
8170
8171 CharUnits Alignment;
8172 const CXXRecordDecl *RD;
8173 if (T.getQualifiers().hasUnaligned()) {
8174 Alignment = CharUnits::One();
8175 } else if (forPointeeType && !AlignForArray &&
8176 (RD = T->getAsCXXRecordDecl())) {
8177 // For C++ class pointees, we don't know whether we're pointing at a
8178 // base or a complete object, so we generally need to use the
8179 // non-virtual alignment.
8180 Alignment = getClassPointerAlignment(RD);
8181 } else {
8182 Alignment = getContext().getTypeAlignInChars(T);
8183 }
8184
8185 // Cap to the global maximum type alignment unless the alignment
8186 // was somehow explicit on the type.
8187 if (unsigned MaxAlign = getLangOpts().MaxTypeAlign) {
8188 if (Alignment.getQuantity() > MaxAlign &&
8189 !getContext().isAlignmentRequired(T))
8190 Alignment = CharUnits::fromQuantity(MaxAlign);
8191 }
8192 return Alignment;
8193}
8194
8196 unsigned StopAfter = getContext().getLangOpts().TrivialAutoVarInitStopAfter;
8197 if (StopAfter) {
8198 // This number is positive only when -ftrivial-auto-var-init-stop-after=* is
8199 // used
8200 if (NumAutoVarInit >= StopAfter) {
8201 return true;
8202 }
8203 if (!NumAutoVarInit) {
8204 unsigned DiagID = getDiags().getCustomDiagID(
8206 "-ftrivial-auto-var-init-stop-after=%0 has been enabled to limit the "
8207 "number of times ftrivial-auto-var-init=%1 gets applied.");
8208 getDiags().Report(DiagID)
8209 << StopAfter
8210 << (getContext().getLangOpts().getTrivialAutoVarInit() ==
8212 ? "zero"
8213 : "pattern");
8214 }
8215 ++NumAutoVarInit;
8216 }
8217 return false;
8218}
8219
8221 const Decl *D) const {
8222 // ptxas does not allow '.' in symbol names. On the other hand, HIP prefers
8223 // postfix beginning with '.' since the symbol name can be demangled.
8224 if (LangOpts.HIP)
8225 OS << (isa<VarDecl>(D) ? ".static." : ".intern.");
8226 else
8227 OS << (isa<VarDecl>(D) ? "__static__" : "__intern__");
8228
8229 // If the CUID is not specified we try to generate a unique postfix.
8230 if (getLangOpts().CUID.empty()) {
8232 PresumedLoc PLoc = SM.getPresumedLoc(D->getLocation());
8233 assert(PLoc.isValid() && "Source location is expected to be valid.");
8234
8235 // Get the hash of the user defined macros.
8236 llvm::MD5 Hash;
8237 llvm::MD5::MD5Result Result;
8238 for (const auto &Arg : PreprocessorOpts.Macros)
8239 Hash.update(Arg.first);
8240 Hash.final(Result);
8241
8242 // Get the UniqueID for the file containing the decl.
8243 llvm::sys::fs::UniqueID ID;
8244 auto Status = FS->status(PLoc.getFilename());
8245 if (!Status) {
8246 PLoc = SM.getPresumedLoc(D->getLocation(), /*UseLineDirectives=*/false);
8247 assert(PLoc.isValid() && "Source location is expected to be valid.");
8248 Status = FS->status(PLoc.getFilename());
8249 }
8250 if (!Status) {
8251 SM.getDiagnostics().Report(diag::err_cannot_open_file)
8252 << PLoc.getFilename() << Status.getError().message();
8253 } else {
8254 ID = Status->getUniqueID();
8255 }
8256 OS << llvm::format("%x", ID.getFile()) << llvm::format("%x", ID.getDevice())
8257 << "_" << llvm::utohexstr(Result.low(), /*LowerCase=*/true, /*Width=*/8);
8258 } else {
8259 OS << getContext().getCUIDHash();
8260 }
8261}
8262
8263void CodeGenModule::moveLazyEmissionStates(CodeGenModule *NewBuilder) {
8264 assert(DeferredDeclsToEmit.empty() &&
8265 "Should have emitted all decls deferred to emit.");
8266 assert(NewBuilder->DeferredDecls.empty() &&
8267 "Newly created module should not have deferred decls");
8268 NewBuilder->DeferredDecls = std::move(DeferredDecls);
8269 assert(EmittedDeferredDecls.empty() &&
8270 "Still have (unmerged) EmittedDeferredDecls deferred decls");
8271
8272 assert(NewBuilder->DeferredVTables.empty() &&
8273 "Newly created module should not have deferred vtables");
8274 NewBuilder->DeferredVTables = std::move(DeferredVTables);
8275
8276 assert(NewBuilder->MangledDeclNames.empty() &&
8277 "Newly created module should not have mangled decl names");
8278 assert(NewBuilder->Manglings.empty() &&
8279 "Newly created module should not have manglings");
8280 NewBuilder->Manglings = std::move(Manglings);
8281
8282 NewBuilder->WeakRefReferences = std::move(WeakRefReferences);
8283
8284 NewBuilder->ABI->MangleCtx = std::move(ABI->MangleCtx);
8285}
Defines the clang::ASTContext interface.
#define V(N, I)
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines the Diagnostic-related interfaces.
Defines enum values for all the target-independent builtin functions.
static bool shouldAssumeDSOLocal(const CIRGenModule &cgm, cir::CIRGlobalValueInterface gv)
static bool shouldBeInCOMDAT(CIRGenModule &cgm, const Decl &d)
static std::string getMangledNameImpl(CIRGenModule &cgm, GlobalDecl gd, const NamedDecl *nd)
static CIRGenCXXABI * createCXXABI(CIRGenModule &cgm)
static bool isVarDeclStrongDefinition(const ASTContext &astContext, CIRGenModule &cgm, const VarDecl *vd, bool noCommon)
static void setLinkageForGV(cir::GlobalOp &gv, const NamedDecl *nd)
static bool hasExistingGeneralizedTypeMD(llvm::Function *F)
static void AppendCPUSpecificCPUDispatchMangling(const CodeGenModule &CGM, const CPUSpecificAttr *Attr, unsigned CPUIndex, raw_ostream &Out)
static bool AllTrivialInitializers(CodeGenModule &CGM, ObjCImplementationDecl *D)
static const FunctionDecl * GetRuntimeFunctionDecl(ASTContext &C, StringRef Name)
static GlobalDecl getBaseVariantGlobalDecl(const NamedDecl *D)
static void checkAliasForTocData(llvm::GlobalVariable *GVar, const CodeGenOptions &CodeGenOpts, DiagnosticsEngine &Diags, SourceLocation Location)
static bool hasImplicitAttr(const ValueDecl *D)
static void emitUsed(CodeGenModule &CGM, StringRef Name, std::vector< llvm::WeakTrackingVH > &List)
static bool HasNonDllImportDtor(QualType T)
static llvm::Constant * GetPointerConstant(llvm::LLVMContext &Context, const void *Ptr)
Turns the given pointer into a constant.
static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S)
static llvm::GlobalValue::LinkageTypes getMultiversionLinkage(CodeGenModule &CGM, GlobalDecl GD)
static void setVisibilityFromDLLStorageClass(const clang::LangOptions &LO, llvm::Module &M)
static QualType GeneralizeTransparentUnion(QualType Ty)
static std::string getCPUSpecificMangling(const CodeGenModule &CGM, StringRef Name)
static void setWindowsItaniumDLLImport(CodeGenModule &CGM, bool Local, llvm::Function *F, StringRef Name)
static const char AnnotationSection[]
static bool isUniqueInternalLinkageDecl(GlobalDecl GD, CodeGenModule &CGM)
static bool allowKCFIIdentifier(StringRef Name)
static void replaceUsesOfNonProtoConstant(llvm::Constant *old, llvm::Function *newFn)
Replace the uses of a function that was declared with a non-proto type.
static llvm::Constant * castStringLiteralToDefaultAddressSpace(CodeGenModule &CGM, llvm::GlobalVariable *GV)
static void checkDataLayoutConsistency(const TargetInfo &Target, llvm::LLVMContext &Context, const LangOptions &Opts)
static QualType GeneralizeFunctionType(ASTContext &Ctx, QualType Ty, bool GeneralizePointers)
static bool needsDestructMethod(ObjCImplementationDecl *impl)
static bool isStackProtectorOn(const LangOptions &LangOpts, const llvm::Triple &Triple, clang::LangOptions::StackProtectorMode Mode)
static void removeImageAccessQualifier(std::string &TyName)
static llvm::StringMapEntry< llvm::GlobalVariable * > & GetConstantCFStringEntry(llvm::StringMap< llvm::GlobalVariable * > &Map, const StringLiteral *Literal, bool TargetIsLSB, bool &IsUTF16, unsigned &StringLength)
static void setLLVMVisibility(llvm::GlobalValue &GV, std::optional< llvm::GlobalValue::VisibilityTypes > V)
static llvm::GlobalVariable * GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT, CodeGenModule &CGM, StringRef GlobalName, CharUnits Alignment)
static bool hasUnwindExceptions(const LangOptions &LangOpts)
Determines whether the language options require us to model unwind exceptions.
static llvm::APInt getFMVPriority(const TargetInfo &TI, const CodeGenFunction::FMVResolverOption &RO)
static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod, SmallVectorImpl< llvm::MDNode * > &Metadata, llvm::SmallPtrSet< Module *, 16 > &Visited)
Add link options implied by the given module, including modules it depends on, using a postorder walk...
static llvm::cl::opt< bool > LimitedCoverage("limited-coverage-experimental", llvm::cl::Hidden, llvm::cl::desc("Emit limited coverage mapping information (experimental)"))
static CGCXXABI * createCXXABI(CodeGenModule &CGM)
static std::unique_ptr< TargetCodeGenInfo > createTargetCodeGenInfo(CodeGenModule &CGM)
static const llvm::GlobalValue * getAliasedGlobal(const llvm::GlobalValue *GV)
static QualType GeneralizeType(ASTContext &Ctx, QualType Ty, bool GeneralizePointers)
static constexpr auto ErrnoTBAAMDName
static unsigned ArgInfoAddressSpace(LangAS AS)
static void replaceDeclarationWith(llvm::GlobalValue *Old, llvm::Constant *New)
static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, llvm::Function *NewFn)
ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we implement a function with...
static std::optional< llvm::GlobalValue::VisibilityTypes > getLLVMVisibility(clang::LangOptions::VisibilityFromDLLStorageClassKinds K)
static bool requiresMemberFunctionPointerTypeMetadata(CodeGenModule &CGM, const CXXMethodDecl *MD)
static bool checkAliasedGlobal(const ASTContext &Context, DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector< GlobalDecl, StringRef > &MangledDeclNames, SourceRange AliasRange)
static void EmitGlobalDeclMetadata(CodeGenModule &CGM, llvm::NamedMDNode *&GlobalMetadata, GlobalDecl D, llvm::GlobalValue *Addr)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
TokenType getType() const
Returns the token's type, e.g.
#define X(type, name)
Definition Value.h:97
llvm::MachO::Target Target
Definition MachO.h:51
llvm::MachO::Record Record
Definition MachO.h:31
Defines the clang::Module class, which describes a module in the source code.
#define SM(sm)
static bool hasAttr(const Decl *D, bool IgnoreImplicitAttr)
Definition SemaCUDA.cpp:109
static const NamedDecl * getDefinition(const Decl *D)
Defines the SourceManager interface.
static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type)
Defines version macros and version-related utility functions for Clang.
__device__ __2f16 float __ockl_bool s
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition APValue.h:122
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition ASTContext.h:220
SourceManager & getSourceManager()
Definition ASTContext.h:833
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
@ WeakUnknown
Weak for now, might become strong later in this TU.
const ProfileList & getProfileList() const
Definition ASTContext.h:945
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
bool shouldExternalize(const Decl *D) const
Whether a C++ static variable or CUDA/HIP kernel should be externalized.
const XRayFunctionFilter & getXRayFilter() const
Definition ASTContext.h:941
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
StringRef getCUIDHash() const
IdentifierTable & Idents
Definition ASTContext.h:772
const LangOptions & getLangOpts() const
Definition ASTContext.h:926
SelectorTable & Selectors
Definition ASTContext.h:773
void forEachMultiversionedFunctionVersion(const FunctionDecl *FD, llvm::function_ref< void(FunctionDecl *)> Pred) const
Visits all versions of a multiversioned function with the passed predicate.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
const NoSanitizeList & getNoSanitizeList() const
Definition ASTContext.h:936
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
CharUnits getAlignOfGlobalVarInChars(QualType T, const VarDecl *VD) const
Return the alignment in characters that should be given to a global variable with type T.
GVALinkage GetGVALinkageForVariable(const VarDecl *VD) const
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
CanQualType VoidTy
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
const TargetInfo & getTargetInfo() const
Definition ASTContext.h:891
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
TargetCXXABI::Kind getCXXABIKind() const
Return the C++ ABI kind that should be used.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
CanQualType getCanonicalTagType(const TagDecl *TD) const
unsigned getTargetAddressSpace(LangAS AS) const
Module * getCurrentNamedModule() const
Get module under construction, nullptr if this is not a C++20 module.
Attr - This represents one attribute.
Definition Attr.h:44
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Definition Decl.h:4654
bool isLibFunction(unsigned ID) const
Return true if this is a builtin for a libc/libm function, with a "__builtin_" prefix (e....
Definition Builtins.h:302
std::string getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
Definition Builtins.cpp:80
Represents a base class of a C++ class.
Definition DeclCXX.h:146
CXXTemporary * getTemporary()
Definition ExprCXX.h:1512
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
Definition ExprCXX.h:1612
Represents a C++ base or member initializer.
Definition DeclCXX.h:2369
Expr * getInit() const
Get the initializer.
Definition DeclCXX.h:2571
FunctionDecl * getOperatorDelete() const
Definition ExprCXX.h:2667
CXXMethodDecl * getMethodDecl() const
Retrieve the declaration of the called method.
Definition ExprCXX.cpp:741
Represents a static or instance method of a struct/union/class.
Definition DeclCXX.h:2129
bool isImplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...
Definition DeclCXX.cpp:2710
bool isVirtual() const
Definition DeclCXX.h:2184
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Definition DeclCXX.h:2255
FunctionDecl * getOperatorNew() const
Definition ExprCXX.h:2461
Represents a C++ struct/union/class.
Definition DeclCXX.h:258
base_class_range bases()
Definition DeclCXX.h:608
unsigned getNumBases() const
Retrieves the number of base classes of this class.
Definition DeclCXX.h:602
bool hasDefinition() const
Definition DeclCXX.h:561
const CXXDestructorDecl * getDestructor() const
Definition ExprCXX.h:1471
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
Definition Expr.h:3060
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
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition CharUnits.h:185
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
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
std::string MSSecureHotPatchFunctionsFile
The name of a file that contains functions which will be compiled for hotpatching.
std::string RecordCommandLine
The string containing the commandline for the llvm.commandline metadata, if non-empty.
std::string FloatABI
The ABI to use for passing floating point arguments.
llvm::Reloc::Model RelocationModel
The name of the relocation model to use.
std::vector< std::string > TocDataVarsUserSpecified
List of global variables explicitly specified by the user as toc-data.
PointerAuthOptions PointerAuth
Configuration for pointer-signing.
std::vector< std::string > MSSecureHotPatchFunctionsList
A list of functions which will be compiled for hotpatching.
ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions.
Definition ABIInfo.h:48
virtual void appendAttributeMangling(TargetAttr *Attr, raw_ostream &Out) const
Definition ABIInfo.cpp:186
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
Definition Address.h:128
virtual void handleVarRegistration(const VarDecl *VD, llvm::GlobalVariable &Var)=0
Check whether a variable is a device variable and register it if true.
virtual llvm::GlobalValue * getKernelHandle(llvm::Function *Stub, GlobalDecl GD)=0
Get kernel handle by stub function.
virtual void internalizeDeviceSideVar(const VarDecl *D, llvm::GlobalValue::LinkageTypes &Linkage)=0
Adjust linkage of shadow variables in host compilation.
Implements C++ ABI-specific code generation functions.
Definition CGCXXABI.h:43
virtual void EmitCXXConstructors(const CXXConstructorDecl *D)=0
Emit constructor variants required by this ABI.
virtual llvm::Constant * getAddrOfRTTIDescriptor(QualType Ty)=0
virtual void EmitCXXDestructors(const CXXDestructorDecl *D)=0
Emit destructor variants required by this ABI.
virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
Definition CGCXXABI.cpp:309
virtual llvm::GlobalValue::LinkageTypes getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
Definition CGCXXABI.cpp:316
MangleContext & getMangleContext()
Gets the mangle context.
Definition CGCXXABI.h:113
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
Definition CGDebugInfo.h:59
void EmitExternalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl)
Emit information about an external variable.
void EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc, QualType FnType, llvm::Function *Fn=nullptr)
Emit debug info for a function declaration.
void AddStringLiteralDebugInfo(llvm::GlobalVariable *GV, const StringLiteral *S)
DebugInfo isn't attached to string literals by default.
CGFunctionInfo - Class to encapsulate the information about a function definition.
void handleGlobalVarDefinition(const VarDecl *VD, llvm::GlobalVariable *Var)
void addRootSignature(const HLSLRootSignatureDecl *D)
void addBuffer(const HLSLBufferDecl *D)
llvm::Type * getSamplerType(const Type *T)
void emitDeferredTargetDecls() const
Emit deferred declare target variables marked for deferred emission.
virtual void emitDeclareTargetFunction(const FunctionDecl *FD, llvm::GlobalValue *GV)
Emit code for handling declare target functions in the runtime.
virtual ConstantAddress getAddrOfDeclareTargetVar(const VarDecl *VD)
Returns the address of the variable marked as declare target with link clause OR as declare target wi...
bool hasRequiresUnifiedSharedMemory() const
Return whether the unified_shared_memory has been specified.
virtual void emitDeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn)
Marks function Fn with properly mangled versions of vector functions.
virtual void registerTargetGlobalVariable(const VarDecl *VD, llvm::Constant *Addr)
Checks if the provided global decl GD is a declare target variable and registers it when emitting cod...
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo)
void EmitCfiCheckFail()
Emit a cross-DSO CFI failure handling function.
Definition CGExpr.cpp:4210
void GenerateObjCGetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCGetter - Synthesize an Objective-C property getter function.
Definition CGObjC.cpp:1049
void EmitCfiCheckStub()
Emit a stub for the cross-DSO CFI check function.
Definition CGExpr.cpp:4171
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
Generate an Objective-C method.
Definition CGObjC.cpp:807
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
void GenerateObjCSetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCSetter - Synthesize an Objective-C property setter function for the given property.
Definition CGObjC.cpp:1672
llvm::LLVMContext & getLLVMContext()
bool isTrivialInitializer(const Expr *Init)
Determine whether the given initializer is trivial in the sense that it requires no code to be genera...
Definition CGDecl.cpp:1807
This class organizes the cross-function state that is used while generating LLVM code.
StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD)
ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD)
Get the address of a GUID.
void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const
Set visibility, dllimport/dllexport and dso_local.
void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD)
Create and attach type metadata for the given vtable.
void UpdateCompletedType(const TagDecl *TD)
llvm::MDNode * getTBAAAccessTagInfo(TBAAAccessInfo Info)
getTBAAAccessTagInfo - Get TBAA tag for a given memory access.
llvm::GlobalVariable::ThreadLocalMode GetDefaultLLVMTLSModel() const
Get LLVM TLS mode from CodeGenOptions.
void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
void setDSOLocal(llvm::GlobalValue *GV) const
llvm::MDNode * getTBAAStructInfo(QualType QTy)
CGHLSLRuntime & getHLSLRuntime()
Return a reference to the configured HLSL runtime.
llvm::Constant * EmitAnnotationArgs(const AnnotateAttr *Attr)
Emit additional args of the annotation.
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::ConstantInt * CreateKCFITypeId(QualType T, StringRef Salt)
Generate a KCFI type identifier for T.
bool NeedAllVtablesTypeId() const
Returns whether this module needs the "all-vtables" type identifier.
void addCompilerUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.compiler.used metadata.
CodeGenVTables & getVTables()
llvm::ConstantInt * CreateCrossDsoCfiTypeId(llvm::Metadata *MD)
Generate a cross-DSO type identifier for MD.
CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const
Return the store size, in character units, of the given LLVM type.
void createFunctionTypeMetadataForIcall(const FunctionDecl *FD, llvm::Function *F)
Create and attach type metadata to the given function.
bool getExpressionLocationsEnabled() const
Return true if we should emit location information for expressions.
void addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C)
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
void setGVPropertiesAux(llvm::GlobalValue *GV, const NamedDecl *D) const
const IntrusiveRefCntPtr< llvm::vfs::FileSystem > & getFileSystem() const
void EmitMainVoidAlias()
Emit an alias for "main" if it has no arguments (needed for wasm).
void DecorateInstructionWithInvariantGroup(llvm::Instruction *I, const CXXRecordDecl *RD)
Adds !invariant.barrier !tag to instruction.
DiagnosticsEngine & getDiags() const
bool isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn, SourceLocation Loc) const
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
llvm::Constant * getAddrOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the constructor/destructor of the given type.
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
llvm::Constant * EmitAnnotateAttr(llvm::GlobalValue *GV, const AnnotateAttr *AA, SourceLocation L)
Generate the llvm::ConstantStruct which contains the annotation information for a given GlobalValue.
void EmitOpenACCDeclare(const OpenACCDeclareDecl *D, CodeGenFunction *CGF=nullptr)
Definition CGDecl.cpp:2879
llvm::GlobalValue::LinkageTypes getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage)
Returns LLVM linkage for a declarator.
TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, TBAAAccessInfo SrcInfo)
mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the purposes of memory transfer call...
const LangOptions & getLangOpts() const
CGCUDARuntime & getCUDARuntime()
Return a reference to the configured CUDA runtime.
llvm::Constant * EmitAnnotationLineNo(SourceLocation L)
Emit the annotation line number.
QualType getObjCFastEnumerationStateType()
Retrieve the record type that describes the state of an Objective-C fast enumeration loop (for....
CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)
bool shouldMapVisibilityToDLLExport(const NamedDecl *D) const
CGOpenCLRuntime & getOpenCLRuntime()
Return a reference to the configured OpenCL runtime.
const std::string & getModuleNameHash() const
const TargetInfo & getTarget() const
bool shouldEmitRTTI(bool ForEH=false)
void EmitGlobal(GlobalDecl D)
Emit code for a single global function or var decl.
llvm::Metadata * CreateMetadataIdentifierForType(QualType T)
Create a metadata identifier for the given type.
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
void createIndirectFunctionTypeMD(const FunctionDecl *FD, llvm::Function *F)
Create and attach type metadata if the function is a potential indirect call target to support call g...
void AppendLinkerOptions(StringRef Opts)
Appends Opts to the "llvm.linker.options" metadata value.
void createCalleeTypeMetadataForIcall(const QualType &QT, llvm::CallBase *CB)
Create and attach type metadata to the given call.
void EmitExternalDeclaration(const DeclaratorDecl *D)
void AddDependentLib(StringRef Lib)
Appends a dependent lib to the appropriate metadata value.
void Release()
Finalize LLVM code generation.
ProfileList::ExclusionType isFunctionBlockedByProfileList(llvm::Function *Fn, SourceLocation Loc) const
llvm::MDNode * getTBAABaseTypeInfo(QualType QTy)
getTBAABaseTypeInfo - Get metadata that describes the given base access type.
bool lookupRepresentativeDecl(StringRef MangledName, GlobalDecl &Result) const
void EmitOMPAllocateDecl(const OMPAllocateDecl *D)
Emit a code for the allocate directive.
Definition CGDecl.cpp:2893
void setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D) const
Set the visibility for the given LLVM GlobalValue.
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD)
Returns LLVM linkage for a declarator.
bool HasHiddenLTOVisibility(const CXXRecordDecl *RD)
Returns whether the given record has hidden LTO visibility and therefore may participate in (single-m...
const llvm::DataLayout & getDataLayout() const
void Error(SourceLocation loc, StringRef error)
Emit a general error that something can't be done.
TBAAAccessInfo getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType)
getTBAAVTablePtrAccessInfo - Get the TBAA information that describes an access to a virtual table poi...
ConstantAddress GetWeakRefReference(const ValueDecl *VD)
Get a reference to the target of VD.
llvm::Constant * GetFunctionStart(const ValueDecl *Decl)
static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V)
void EmitTentativeDefinition(const VarDecl *D)
void EmitDeferredUnusedCoverageMappings()
Emit all the deferred coverage mappings for the uninstrumented functions.
void addUsedOrCompilerUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.compiler.used metadata.
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
bool imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc, StringRef Category=StringRef()) const
Imbue XRay attributes to a function, applying the always/never attribute lists in the process.
SanitizerMetadata * getSanitizerMetadata()
llvm::Metadata * CreateMetadataIdentifierGeneralized(QualType T)
Create a metadata identifier for the generalization of the given type.
void EmitGlobalAnnotations()
Emit all the global annotations.
CharUnits getClassPointerAlignment(const CXXRecordDecl *CD)
Returns the assumed alignment of an opaque pointer to the given class.
Definition CGClass.cpp:40
const llvm::Triple & getTriple() const
SmallVector< const CXXRecordDecl *, 0 > getMostBaseClasses(const CXXRecordDecl *RD)
Return a vector of most-base classes for RD.
void AddDeferredUnusedCoverageMapping(Decl *D)
Stored a deferred empty coverage mapping for an unused and thus uninstrumented top level declaration.
void MaybeHandleStaticInExternC(const SomeDecl *D, llvm::GlobalValue *GV)
If the declaration has internal linkage but is inside an extern "C" linkage specification,...
void DecorateInstructionWithTBAA(llvm::Instruction *Inst, TBAAAccessInfo TBAAInfo)
DecorateInstructionWithTBAA - Decorate the instruction with a TBAA tag.
llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD)
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.
llvm::Constant * CreateRuntimeVariable(llvm::Type *Ty, StringRef Name)
Create a new runtime global variable with the specified type and name.
void ConstructAttributeList(StringRef Name, const CGFunctionInfo &Info, CGCalleeInfo CalleeInfo, llvm::AttributeList &Attrs, unsigned &CallingConv, bool AttrOnCallSite, bool IsThunk)
Get the LLVM attributes and calling convention to use for a particular function type.
Definition CGCall.cpp:2402
llvm::Constant * GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty, LangAS AddrSpace, const VarDecl *D, ForDefinition_t IsForDefinition=NotForDefinition)
GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, create and return an llvm...
TBAAAccessInfo getTBAAAccessInfo(QualType AccessType)
getTBAAAccessInfo - Get TBAA information that describes an access to an object of the given type.
void setFunctionLinkage(GlobalDecl GD, llvm::Function *F)
llvm::Constant * GetAddrOfGlobal(GlobalDecl GD, ForDefinition_t IsForDefinition=NotForDefinition)
AtomicOptions getAtomicOpts()
Get the current Atomic options.
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
ProfileList::ExclusionType isFunctionBlockedFromProfileInstr(llvm::Function *Fn, SourceLocation Loc) const
void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV)
Add global annotations that are set on D, for the global GV.
void setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const
Set the TLS mode for the given LLVM GlobalValue for the thread-local variable declaration D.
ConstantAddress GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name=".str")
Return a pointer to a constant array for the given string literal.
ASTContext & getContext() const
ConstantAddress GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO)
Get the address of a template parameter object.
void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D)
Emit a code for threadprivate directive.
ConstantAddress GetAddrOfUnnamedGlobalConstantDecl(const UnnamedGlobalConstantDecl *GCD)
Get the address of a UnnamedGlobalConstant.
TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, TBAAAccessInfo TargetInfo)
mergeTBAAInfoForCast - Get merged TBAA information for the purposes of type casts.
llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, ForDefinition_t IsForDefinition=NotForDefinition)
Return the llvm::Constant for the address of the given global variable.
llvm::SanitizerStatReport & getSanStats()
llvm::Constant * EmitAnnotationString(StringRef Str)
Emit an annotation string.
void EmitOMPDeclareMapper(const OMPDeclareMapperDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare mapper construct.
Definition CGDecl.cpp:2871
void RefreshTypeCacheForClass(const CXXRecordDecl *Class)
llvm::MDNode * getTBAATypeInfo(QualType QTy)
getTBAATypeInfo - Get metadata used to describe accesses to objects of the given type.
void EmitOMPRequiresDecl(const OMPRequiresDecl *D)
Emit a code for requires directive.
Definition CGDecl.cpp:2889
void HandleCXXStaticMemberVarInstantiation(VarDecl *VD)
Tell the consumer that this variable has been instantiated.
const TargetCodeGenInfo & getTargetCodeGenInfo()
const CodeGenOptions & getCodeGenOpts() const
StringRef getMangledName(GlobalDecl GD)
llvm::Constant * GetConstantArrayFromStringLiteral(const StringLiteral *E)
Return a constant array for the given string.
void SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV)
Set attributes which are common to any form of a global definition (alias, Objective-C method,...
std::optional< CharUnits > getOMPAllocateAlignment(const VarDecl *VD)
Return the alignment specified in an allocate directive, if present.
Definition CGDecl.cpp:2944
llvm::GlobalVariable * CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage, llvm::Align Alignment)
Will return a global variable of the given type.
CharUnits getNaturalPointeeTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, TBAAAccessInfo InfoB)
mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the purposes of conditional ope...
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...
void setKCFIType(const FunctionDecl *FD, llvm::Function *F)
Set type metadata to the given function.
void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO)
void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare reduction construct.
Definition CGDecl.cpp:2864
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys={})
void AddDetectMismatch(StringRef Name, StringRef Value)
Appends a detect mismatch command to the linker options.
void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const
llvm::Value * createOpenCLIntToSamplerConversion(const Expr *E, CodeGenFunction &CGF)
ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)
Returns a pointer to a global variable representing a temporary with static or thread storage duratio...
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
LangAS GetGlobalConstantAddressSpace() const
Return the AST address space of constant literal, which is used to emit the constant literal as globa...
LangAS GetGlobalVarAddressSpace(const VarDecl *D)
Return the AST address space of the underlying global variable for D, as determined by its declaratio...
void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)
Set the LLVM function attributes (sext, zext, etc).
void EmitOpenACCRoutine(const OpenACCRoutineDecl *D, CodeGenFunction *CGF=nullptr)
Definition CGDecl.cpp:2884
void addReplacement(StringRef Name, llvm::Constant *C)
llvm::Constant * getConstantSignedPointer(llvm::Constant *Pointer, const PointerAuthSchema &Schema, llvm::Constant *StorageAddress, GlobalDecl SchemaDecl, QualType SchemaType)
Sign a constant pointer using the given scheme, producing a constant with the same IR type.
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::Metadata * CreateMetadataIdentifierForFnType(QualType T)
Create a metadata identifier for the given function type.
void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)
Set the LLVM function attributes which only apply to a function definition.
llvm::Metadata * CreateMetadataIdentifierForVirtualMemPtrType(QualType T)
Create a metadata identifier that is intended to be used to check virtual calls via a member function...
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
const GlobalDecl getMangledNameDecl(StringRef)
void ClearUnusedCoverageMapping(const Decl *D)
Remove the deferred empty coverage mapping as this declaration is actually instrumented.
void EmitTopLevelDecl(Decl *D)
Emit code for a single top level declaration.
llvm::Constant * EmitAnnotationUnit(SourceLocation Loc)
Emit the annotation's translation unit.
ConstantAddress GetAddrOfConstantCString(const std::string &Str, StringRef GlobalName=".str")
Returns a pointer to a character array containing the literal and a terminating '\0' character.
void printPostfixForExternalizedDecl(llvm::raw_ostream &OS, const Decl *D) const
Print the postfix for externalized static variable or kernels for single source offloading languages ...
void moveLazyEmissionStates(CodeGenModule *NewBuilder)
Move some lazily-emitted states to the NewBuilder.
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
void finalizeKCFITypes()
Emit KCFI type identifier constants and remove unused identifiers.
Per-function PGO state.
Definition CodeGenPGO.h:29
void setValueProfilingFlag(llvm::Module &M)
void setProfileVersion(llvm::Module &M)
void emitEmptyCounterMapping(const Decl *D, StringRef FuncName, llvm::GlobalValue::LinkageTypes Linkage)
Emit a coverage mapping range with a counter zero for an unused declaration.
CodeGenTBAA - This class organizes the cross-module state that is used while lowering AST types to LL...
This class organizes the cross-module state that is used while lowering AST types to LLVM types.
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
C++ methods have some special rules and also have implicit parameters.
Definition CGCall.cpp:373
const CGFunctionInfo & arrangeFreeFunctionType(CanQual< FunctionProtoType > Ty)
Arrange the argument and result information for a value of the given freestanding function type.
Definition CGCall.cpp:249
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition CGCall.cpp:1701
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
Definition CGCall.cpp:739
unsigned getTargetAddressSpace(QualType T) const
void RefreshTypeCacheForClass(const CXXRecordDecl *RD)
Remove stale types from the type cache when an inheritance model gets assigned to a class.
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
void UpdateCompletedType(const TagDecl *TD)
UpdateCompletedType - When we find the full definition for a TagDecl, replace the 'opaque' type we pr...
const CGFunctionInfo & arrangeGlobalDeclaration(GlobalDecl GD)
Definition CGCall.cpp:611
void EmitThunks(GlobalDecl GD)
EmitThunks - Emit the associated thunks for the given global decl.
A specialization of Address that requires the address to be an LLVM Constant.
Definition Address.h:296
static ConstantAddress invalid()
Definition Address.h:304
llvm::Constant * tryEmitForInitializer(const VarDecl &D)
Try to emit the initiaizer of the given declaration as an abstract constant.
void finalize(llvm::GlobalVariable *global)
llvm::Constant * emitAbstract(const Expr *E, QualType T)
Emit the result of the given expression as an abstract constant, asserting that it succeeded.
The standard implementation of ConstantInitBuilder used in Clang.
Organizes the cross-function state that is used while generating code coverage mapping data.
bool hasDiagnostics()
Whether or not the stats we've gathered indicate any potential problems.
void reportDiagnostics(DiagnosticsEngine &Diags, StringRef MainFile)
Report potential problems we've found to Diags.
void disableSanitizerForGlobal(llvm::GlobalVariable *GV)
TargetCodeGenInfo - This class organizes various target-specific codegeneration issues,...
Definition TargetInfo.h:47
virtual void getDependentLibraryOption(llvm::StringRef Lib, llvm::SmallString< 24 > &Opt) const
Gets the linker options necessary to link a dependent library on this platform.
Address performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, Address Addr, LangAS SrcAddr, llvm::Type *DestTy, bool IsNonNull=false) const
virtual LangAS getGlobalVarAddressSpace(CodeGenModule &CGM, const VarDecl *D) const
Get target favored AST address space of a global variable for languages other than OpenCL and CUDA.
virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M) const
setTargetAttributes - Provides a convenient hook to handle extra target-specific attributes for the g...
Definition TargetInfo.h:80
virtual LangAS getASTAllocaAddressSpace() const
Get the AST address space for alloca.
Definition TargetInfo.h:320
virtual void emitTargetMetadata(CodeGen::CodeGenModule &CGM, const llvm::MapVector< GlobalDecl, StringRef > &MangledDeclNames) const
emitTargetMetadata - Provides a convenient hook to handle extra target-specific metadata for the give...
Definition TargetInfo.h:85
virtual void emitTargetGlobals(CodeGen::CodeGenModule &CGM) const
Provides a convenient hook to handle extra target-specific globals.
Definition TargetInfo.h:90
virtual void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value, llvm::SmallString< 32 > &Opt) const
Gets the linker options necessary to detect object file mismatches on this platform.
Definition TargetInfo.h:297
Represents the canonical version of C arrays with a specified constant size.
Definition TypeBase.h:3760
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
Definition TypeBase.h:3836
Stores additional source code information like skipped ranges which is required by the coverage mappi...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
Definition DeclBase.h:1449
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
void addDecl(Decl *D)
Add the declaration D into this context.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Definition DeclBase.h:2373
ValueDecl * getDecl()
Definition Expr.h:1338
Decl - This represents one declaration (or definition), e.g.
Definition DeclBase.h:86
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
Definition DeclBase.h:1076
SourceLocation getEndLoc() const LLVM_READONLY
Definition DeclBase.h:435
T * getAttr() const
Definition DeclBase.h:573
ASTContext & getASTContext() const LLVM_READONLY
Definition DeclBase.cpp:546
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
Definition DeclBase.h:593
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
Definition DeclBase.cpp:870
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl,...
Definition DeclBase.cpp:560
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
Definition DeclBase.cpp:308
bool isInExportDeclContext() const
Whether this declaration was exported in a lexical context.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
Definition DeclBase.cpp:273
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
Definition DeclBase.h:559
SourceLocation getLocation() const
Definition DeclBase.h:439
SourceLocation getBeginLoc() const LLVM_READONLY
Definition DeclBase.h:431
TranslationUnitDecl * getTranslationUnitDecl()
Definition DeclBase.cpp:531
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Definition DeclBase.h:918
bool hasAttr() const
Definition DeclBase.h:577
Kind getKind() const
Definition DeclBase.h:442
Represents a ValueDecl that came out of a declarator.
Definition Decl.h:780
Concrete class used by the front-end to report problems and issues.
Definition Diagnostic.h:232
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
Definition Diagnostic.h:905
This represents one expression.
Definition Expr.h:112
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
QualType getType() const
Definition Expr.h:144
Represents a member of a struct/union/class.
Definition Decl.h:3160
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
Definition Decl.cpp:4689
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
Definition FileEntry.h:57
StringRef getName() const
The name of this FileEntry.
Definition FileEntry.h:61
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Definition Diagnostic.h:140
Represents a function declaration or definition.
Definition Decl.h:2000
bool isTargetClonesMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-clones functional...
Definition Decl.cpp:3713
bool isMultiVersion() const
True if this function is considered a multiversioned function.
Definition Decl.h:2689
const ParmVarDecl * getParamDecl(unsigned i) const
Definition Decl.h:2797
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
Definition Decl.cpp:3268
bool isImmediateFunction() const
Definition Decl.cpp:3329
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
Definition Decl.cpp:3751
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
Definition Decl.h:2921
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
Definition Decl.cpp:3695
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
Definition Decl.cpp:4253
bool isReplaceableGlobalAllocationFunction(UnsignedOrNone *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
Definition Decl.h:2594
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
Definition Decl.h:2326
bool isInlineBuiltinDeclaration() const
Determine if this function provides an inline implementation of a builtin.
Definition Decl.cpp:3515
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
Definition Decl.h:2470
FunctionDecl * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
FunctionDecl * getDefinition()
Get the definition for this declaration.
Definition Decl.h:2282
bool isTargetVersionMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-version functiona...
Definition Decl.cpp:3717
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
Definition Decl.cpp:3691
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
Definition Decl.cpp:4406
bool doesDeclarationForceExternallyVisibleDefinition() const
For a function declaration in C or C++, determine whether this declaration causes the definition to b...
Definition Decl.cpp:3930
bool isTargetMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target functionality.
Definition Decl.cpp:3699
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
Definition Decl.cpp:3815
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
Definition Decl.cpp:3188
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
Definition Decl.cpp:3235
FunctionDecl * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
Definition Decl.cpp:3677
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
Definition Decl.cpp:3114
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Definition TypeBase.h:4832
Represents a prototype with parameter type info, e.g.
Definition TypeBase.h:5254
FunctionType - C99 6.7.5.3 - Function Declarators.
Definition TypeBase.h:4450
CallingConv getCallConv() const
Definition TypeBase.h:4805
GlobalDecl - represents a global declaration.
Definition GlobalDecl.h:57
GlobalDecl getWithMultiVersionIndex(unsigned Index)
Definition GlobalDecl.h:192
CXXCtorType getCtorType() const
Definition GlobalDecl.h:108
GlobalDecl getWithKernelReferenceKind(KernelReferenceKind Kind)
Definition GlobalDecl.h:203
GlobalDecl getCanonicalDecl() const
Definition GlobalDecl.h:97
KernelReferenceKind getKernelReferenceKind() const
Definition GlobalDecl.h:135
GlobalDecl getWithDecl(const Decl *D)
Definition GlobalDecl.h:172
unsigned getMultiVersionIndex() const
Definition GlobalDecl.h:125
CXXDtorType getDtorType() const
Definition GlobalDecl.h:113
const Decl * getDecl() const
Definition GlobalDecl.h:106
HeaderSearchOptions - Helper class for storing options related to the initialization of the HeaderSea...
One of these records is kept for each identifier that is lexed.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
@ Swift5_0
Interoperability with the Swift 5.0 runtime.
@ Swift
Interoperability with the latest known version of the Swift runtime.
@ Swift4_2
Interoperability with the Swift 4.2 runtime.
@ Swift4_1
Interoperability with the Swift 4.1 runtime.
@ Protected
Override the IR-gen assigned visibility with protected visibility.
@ Default
Override the IR-gen assigned visibility with default visibility.
@ Hidden
Override the IR-gen assigned visibility with hidden visibility.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
clang::ObjCRuntime ObjCRuntime
CoreFoundationABI CFRuntime
std::string CUID
The user provided compilation unit ID, if non-empty.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Visibility getVisibility() const
Definition Visibility.h:89
void setLinkage(Linkage L)
Definition Visibility.h:92
Linkage getLinkage() const
Definition Visibility.h:88
bool isVisibilityExplicit() const
Definition Visibility.h:90
LinkageSpecLanguageIDs getLanguage() const
Return the language specified by this linkage specification.
Definition DeclCXX.h:3038
A global _GUID constant.
Definition DeclCXX.h:4398
Parts getParts() const
Get the decomposed parts of this declaration.
Definition DeclCXX.h:4428
APValue & getAsAPValue() const
Get the value of this MSGuidDecl as an APValue.
Definition DeclCXX.cpp:3761
MSGuidDeclParts Parts
Definition DeclCXX.h:4400
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
Definition Mangle.h:52
void mangleBlock(const DeclContext *DC, const BlockDecl *BD, raw_ostream &Out)
Definition Mangle.cpp:345
void mangleCtorBlock(const CXXConstructorDecl *CD, CXXCtorType CT, const BlockDecl *BD, raw_ostream &Out)
Definition Mangle.cpp:327
void mangleGlobalBlock(const BlockDecl *BD, const NamedDecl *ID, raw_ostream &Out)
Definition Mangle.cpp:310
bool shouldMangleDeclName(const NamedDecl *D)
Definition Mangle.cpp:121
void mangleName(GlobalDecl GD, raw_ostream &)
Definition Mangle.cpp:186
virtual void mangleCanonicalTypeName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0
Generates a unique string for an externally visible type for use with TBAA or type uniquing.
virtual void mangleStringLiteral(const StringLiteral *SL, raw_ostream &)=0
ManglerKind getKind() const
Definition Mangle.h:72
virtual void needsUniqueInternalLinkageNames()
Definition Mangle.h:132
virtual void mangleReferenceTemporary(const VarDecl *D, unsigned ManglingNumber, raw_ostream &)=0
void mangleDtorBlock(const CXXDestructorDecl *CD, CXXDtorType DT, const BlockDecl *BD, raw_ostream &Out)
Definition Mangle.cpp:336
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Definition ExprCXX.h:4922
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Definition ExprCXX.h:4947
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
Definition ExprCXX.h:4939
APValue * getOrCreateValue(bool MayCreate) const
Get the storage for the constant value of a materialized temporary of static storage duration.
Definition ExprCXX.h:4955
ValueDecl * getExtendingDecl()
Get the declaration which triggered the lifetime-extension of this temporary, if any.
Definition ExprCXX.h:4972
unsigned getManglingNumber() const
Definition ExprCXX.h:4983
Describes a module or submodule.
Definition Module.h:144
bool isInterfaceOrPartition() const
Definition Module.h:671
bool isNamedModuleUnit() const
Is this a C++20 named module unit.
Definition Module.h:676
Module * Parent
The parent of this module.
Definition Module.h:193
Module * getPrivateModuleFragment() const
Get the Private Module Fragment (sub-module) for this module, it there is one.
Definition Module.cpp:372
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Definition Module.h:458
Module * getGlobalModuleFragment() const
Get the Global Module Fragment (sub-module) for this module, it there is one.
Definition Module.cpp:361
llvm::iterator_range< submodule_iterator > submodules()
Definition Module.h:838
llvm::SmallVector< LinkLibrary, 2 > LinkLibraries
The set of libraries or frameworks to link against when an entity from this module is used.
Definition Module.h:520
bool isHeaderLikeModule() const
Is this module have similar semantics as headers.
Definition Module.h:648
bool UseExportAsModuleLinkName
Autolinking uses the framework name for linking purposes when this is false and the export_as name ot...
Definition Module.h:524
This represents a decl that may have a name.
Definition Decl.h:274
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
Definition Decl.h:295
LinkageInfo getLinkageAndVisibility() const
Determines the linkage and visibility of this entity.
Definition Decl.cpp:1226
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Definition Decl.h:301
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Definition Decl.cpp:1206
bool isExternallyVisible() const
Definition Decl.h:433
Represent a C++ namespace.
Definition Decl.h:592
This represents 'pragma omp threadprivate ...' directive.
Definition DeclOpenMP.h:110
ObjCEncodeExpr, used for @encode in Objective-C.
Definition ExprObjC.h:409
QualType getEncodedType() const
Definition ExprObjC.h:428
propimpl_range property_impls() const
Definition DeclObjC.h:2513
const ObjCInterfaceDecl * getClassInterface() const
Definition DeclObjC.h:2486
void addInstanceMethod(ObjCMethodDecl *method)
Definition DeclObjC.h:2490
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Definition DeclObjC.h:2597
init_iterator init_end()
init_end() - Retrieve an iterator past the last initializer.
Definition DeclObjC.h:2678
CXXCtorInitializer ** init_iterator
init_iterator - Iterates through the ivar initializer list.
Definition DeclObjC.h:2654
init_iterator init_begin()
init_begin() - Retrieve an iterator to the first initializer.
Definition DeclObjC.h:2669
unsigned getNumIvarInitializers() const
getNumArgs - Number of ivars which must be initialized.
Definition DeclObjC.h:2688
void setHasDestructors(bool val)
Definition DeclObjC.h:2708
void setHasNonZeroConstructors(bool val)
Definition DeclObjC.h:2703
Represents an ObjC class declaration.
Definition DeclObjC.h:1154
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
ObjCIvarDecl - Represents an ObjC instance variable.
Definition DeclObjC.h:1952
ObjCIvarDecl * getNextIvar()
Definition DeclObjC.h:1987
static ObjCMethodDecl * Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc, Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo, DeclContext *contextDecl, bool isInstance=true, bool isVariadic=false, bool isPropertyAccessor=false, bool isSynthesizedAccessorStub=false, bool isImplicitlyDeclared=false, bool isDefined=false, ObjCImplementationControl impControl=ObjCImplementationControl::None, bool HasRelatedResultType=false)
Definition DeclObjC.cpp:849
Represents one property declaration in an Objective-C interface.
Definition DeclObjC.h:731
ObjCMethodDecl * getGetterMethodDecl() const
Definition DeclObjC.h:901
bool isReadOnly() const
isReadOnly - Return true iff the property has a setter.
Definition DeclObjC.h:838
The basic abstraction for the target Objective-C runtime.
Definition ObjCRuntime.h:28
bool hasUnwindExceptions() const
Does this runtime use zero-cost exceptions?
Kind getKind() const
Definition ObjCRuntime.h:77
@ MacOSX
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
Definition ObjCRuntime.h:35
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Definition ObjCRuntime.h:40
@ GNUstep
'gnustep' is the modern non-fragile GNUstep runtime.
Definition ObjCRuntime.h:56
@ ObjFW
'objfw' is the Objective-C runtime included in ObjFW
Definition ObjCRuntime.h:59
@ iOS
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
Definition ObjCRuntime.h:45
@ GCC
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI
Definition ObjCRuntime.h:53
@ WatchOS
'watchos' is a variant of iOS for Apple's watchOS.
Definition ObjCRuntime.h:49
Represents a parameter to a function.
Definition Decl.h:1790
ParsedAttr - Represents a syntactic attribute.
Definition ParsedAttr.h:119
PipeType - OpenCL20.
Definition TypeBase.h:8096
uint16_t getConstantDiscrimination() const
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
Represents an unpacked "presumed" location which can be presented to the user.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
ExclusionType getDefault(llvm::driver::ProfileInstrKind Kind) const
std::optional< ExclusionType > isFunctionExcluded(StringRef FunctionName, llvm::driver::ProfileInstrKind Kind) const
bool isEmpty() const
Definition ProfileList.h:51
std::optional< ExclusionType > isFileExcluded(StringRef FileName, llvm::driver::ProfileInstrKind Kind) const
ExclusionType
Represents if an how something should be excluded from profiling.
Definition ProfileList.h:31
@ Skip
Profiling is skipped using the skipprofile attribute.
Definition ProfileList.h:35
@ Allow
Profiling is allowed.
Definition ProfileList.h:33
std::optional< ExclusionType > isLocationExcluded(SourceLocation Loc, llvm::driver::ProfileInstrKind Kind) const
A (possibly-)qualified type.
Definition TypeBase.h:937
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
Definition TypeBase.h:8362
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
Definition TypeBase.h:8356
bool isNull() const
Return true if this QualType doesn't point to a type yet.
Definition TypeBase.h:1004
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
Definition TypeBase.h:8278
LangAS getAddressSpace() const
Return the address space of this type.
Definition TypeBase.h:8404
bool isConstant(const ASTContext &Ctx) const
Definition TypeBase.h:1097
QualType getCanonicalType() const
Definition TypeBase.h:8330
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
Definition TypeBase.h:8372
QualType withCVRQualifiers(unsigned CVR) const
Definition TypeBase.h:1179
bool isConstQualified() const
Determine whether this type is const-qualified.
Definition TypeBase.h:8351
bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
Definition TypeBase.h:1036
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
Definition TypeBase.h:8324
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Definition TypeBase.h:1332
Represents a struct/union/class.
Definition Decl.h:4312
field_range fields() const
Definition Decl.h:4515
virtual void completeDefinition()
Note that the definition of this type is now complete.
Definition Decl.cpp:5218
Selector getSelector(unsigned NumArgs, const IdentifierInfo **IIV)
Can create any sort of selector.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
A trivial tuple used to represent a source range.
Stmt - This represents one statement.
Definition Stmt.h:85
child_range children()
Definition Stmt.cpp:299
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
Definition Stmt.cpp:338
SourceLocation getBeginLoc() const LLVM_READONLY
Definition Stmt.cpp:350
StringLiteral - This represents a string literal expression, e.g.
Definition Expr.h:1799
SourceLocation getStrTokenLoc(unsigned TokNum) const
Get one of the string literal token.
Definition Expr.h:1945
unsigned getLength() const
Definition Expr.h:1909
uint32_t getCodeUnit(size_t i) const
Definition Expr.h:1882
StringRef getString() const
Definition Expr.h:1867
unsigned getCharByteWidth() const
Definition Expr.h:1910
Represents the declaration of a struct/union/class/enum.
Definition Decl.h:3717
void startDefinition()
Starts the definition of this tag declaration.
Definition Decl.cpp:4895
Exposes information about the current target.
Definition TargetInfo.h:226
TargetOptions & getTargetOpts() const
Retrieve the target options.
Definition TargetInfo.h:323
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool isReadOnlyFeature(StringRef Feature) const
Determine whether the given target feature is read only.
virtual llvm::APInt getFMVPriority(ArrayRef< StringRef > Features) const
bool supportsIFunc() const
Identify whether this target supports IFuncs.
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
Definition TargetInfo.h:532
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings starting...
std::string TuneCPU
If given, the name of the target CPU to tune code for.
std::string CPU
If given, the name of the target CPU to generate code for.
@ Hostcall
printf lowering scheme involving hostcalls, currently used by HIP programs by default
A template parameter object.
const APValue & getValue() const
A declaration that models statements at global scope.
Definition Decl.h:4617
The top declaration context.
Definition Decl.h:105
static DeclContext * castToDeclContext(const TranslationUnitDecl *D)
Definition Decl.h:151
const RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
Definition Type.cpp:787
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Definition Type.h:41
bool isPointerType() const
Definition TypeBase.h:8515
const T * castAs() const
Member-template castAs<specific type>.
Definition TypeBase.h:9158
bool isReferenceType() const
Definition TypeBase.h:8539
bool isCUDADeviceBuiltinSurfaceType() const
Check if the type is the CUDA device builtin surface type.
Definition Type.cpp:5326
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition Type.cpp:752
bool isImageType() const
Definition TypeBase.h:8769
bool isPipeType() const
Definition TypeBase.h:8776
bool isCUDADeviceBuiltinTextureType() const
Check if the type is the CUDA device builtin texture type.
Definition Type.cpp:5335
bool isHLSLResourceRecord() const
Definition Type.cpp:5362
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
Definition Type.cpp:2435
bool isObjCObjectPointerType() const
Definition TypeBase.h:8684
bool isSamplerT() const
Definition TypeBase.h:8749
const T * getAs() const
Member-template getAs<specific type>'.
Definition TypeBase.h:9091
bool isRecordType() const
Definition TypeBase.h:8642
bool isHLSLResourceRecordArray() const
Definition Type.cpp:5366
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
Definition DeclCXX.h:4455
const APValue & getValue() const
Definition DeclCXX.h:4481
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Definition Decl.h:712
QualType getType() const
Definition Decl.h:723
Represents a variable declaration or definition.
Definition Decl.h:926
TLSKind getTLSKind() const
Definition Decl.cpp:2168
bool hasInit() const
Definition Decl.cpp:2398
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
Definition Decl.cpp:2260
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
Definition Decl.cpp:2257
bool hasFlexibleArrayInit(const ASTContext &Ctx) const
Whether this variable has a flexible array member initialized with one or more elements.
Definition Decl.cpp:2862
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
Definition Decl.h:1226
CharUnits getFlexibleArrayInitChars(const ASTContext &Ctx) const
If hasFlexibleArrayInit is true, compute the number of additional bytes necessary to store those elem...
Definition Decl.cpp:2877
bool hasConstantInitialization() const
Determine whether this variable has constant initialization.
Definition Decl.cpp:2648
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
Definition Decl.cpp:2366
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
Definition Decl.cpp:2241
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
Definition Decl.cpp:2851
const Expr * getInit() const
Definition Decl.h:1368
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
Definition Decl.h:1217
@ TLS_Dynamic
TLS with a dynamic initializer.
Definition Decl.h:952
@ DeclarationOnly
This declaration is only a declaration.
Definition Decl.h:1295
@ Definition
This declaration is definitely a definition.
Definition Decl.h:1301
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
Definition Decl.cpp:2375
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:2779
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
Definition Decl.h:1358
Defines the clang::TargetInfo interface.
#define INT_MAX
Definition limits.h:50
#define UINT_MAX
Definition limits.h:64
std::unique_ptr< TargetCodeGenInfo > createARMTargetCodeGenInfo(CodeGenModule &CGM, ARMABIKind Kind)
Definition ARM.cpp:846
std::unique_ptr< TargetCodeGenInfo > createM68kTargetCodeGenInfo(CodeGenModule &CGM)
Definition M68k.cpp:53
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
Definition CGValue.h:150
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
Definition CGValue.h:154
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
Definition CGValue.h:145
std::unique_ptr< TargetCodeGenInfo > createBPFTargetCodeGenInfo(CodeGenModule &CGM)
Definition BPF.cpp:102
std::unique_ptr< TargetCodeGenInfo > createMSP430TargetCodeGenInfo(CodeGenModule &CGM)
Definition MSP430.cpp:96
std::unique_ptr< TargetCodeGenInfo > createX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel)
Definition X86.cpp:3519
std::unique_ptr< TargetCodeGenInfo > createWebAssemblyTargetCodeGenInfo(CodeGenModule &CGM, WebAssemblyABIKind K)
std::unique_ptr< TargetCodeGenInfo > createPPC64_SVR4_TargetCodeGenInfo(CodeGenModule &CGM, PPC64_SVR4_ABIKind Kind, bool SoftFloatABI)
Definition PPC.cpp:1056
std::unique_ptr< TargetCodeGenInfo > createMIPSTargetCodeGenInfo(CodeGenModule &CGM, bool IsOS32)
Definition Mips.cpp:455
std::unique_ptr< TargetCodeGenInfo > createHexagonTargetCodeGenInfo(CodeGenModule &CGM)
Definition Hexagon.cpp:420
std::unique_ptr< TargetCodeGenInfo > createNVPTXTargetCodeGenInfo(CodeGenModule &CGM)
Definition NVPTX.cpp:361
std::unique_ptr< TargetCodeGenInfo > createSystemZTargetCodeGenInfo(CodeGenModule &CGM, bool HasVector, bool SoftFloatABI)
Definition SystemZ.cpp:548
std::unique_ptr< TargetCodeGenInfo > createWinX86_32TargetCodeGenInfo(CodeGenModule &CGM, bool DarwinVectorABI, bool Win32StructABI, unsigned NumRegisterParameters)
Definition X86.cpp:3508
std::unique_ptr< TargetCodeGenInfo > createAIXTargetCodeGenInfo(CodeGenModule &CGM, bool Is64Bit)
Definition PPC.cpp:1039
std::unique_ptr< TargetCodeGenInfo > createAMDGPUTargetCodeGenInfo(CodeGenModule &CGM)
Definition AMDGPU.cpp:784
CGObjCRuntime * CreateMacObjCRuntime(CodeGenModule &CGM)
X86AVXABILevel
The AVX ABI level for X86 targets.
Definition TargetInfo.h:604
std::unique_ptr< TargetCodeGenInfo > createTCETargetCodeGenInfo(CodeGenModule &CGM)
Definition TCE.cpp:77
CGObjCRuntime * CreateGNUObjCRuntime(CodeGenModule &CGM)
Creates an instance of an Objective-C runtime class.
std::unique_ptr< TargetCodeGenInfo > createWindowsARMTargetCodeGenInfo(CodeGenModule &CGM, ARMABIKind K)
Definition ARM.cpp:851
std::unique_ptr< TargetCodeGenInfo > createAVRTargetCodeGenInfo(CodeGenModule &CGM, unsigned NPR, unsigned NRR)
Definition AVR.cpp:151
std::unique_ptr< TargetCodeGenInfo > createDirectXTargetCodeGenInfo(CodeGenModule &CGM)
Definition DirectX.cpp:97
std::unique_ptr< TargetCodeGenInfo > createARCTargetCodeGenInfo(CodeGenModule &CGM)
Definition ARC.cpp:159
std::unique_ptr< TargetCodeGenInfo > createDefaultTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind Kind)
Definition AArch64.cpp:1345
std::unique_ptr< TargetCodeGenInfo > createSPIRVTargetCodeGenInfo(CodeGenModule &CGM)
Definition SPIR.cpp:681
std::unique_ptr< TargetCodeGenInfo > createWindowsMIPSTargetCodeGenInfo(CodeGenModule &CGM, bool IsOS32)
Definition Mips.cpp:460
std::unique_ptr< TargetCodeGenInfo > createSparcV8TargetCodeGenInfo(CodeGenModule &CGM)
Definition Sparc.cpp:399
std::unique_ptr< TargetCodeGenInfo > createVETargetCodeGenInfo(CodeGenModule &CGM)
Definition VE.cpp:69
std::unique_ptr< TargetCodeGenInfo > createCommonSPIRTargetCodeGenInfo(CodeGenModule &CGM)
Definition SPIR.cpp:676
std::unique_ptr< TargetCodeGenInfo > createRISCVTargetCodeGenInfo(CodeGenModule &CGM, unsigned XLen, unsigned FLen, bool EABI)
Definition RISCV.cpp:1026
std::unique_ptr< TargetCodeGenInfo > createWindowsAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind K)
Definition AArch64.cpp:1351
std::unique_ptr< TargetCodeGenInfo > createSparcV9TargetCodeGenInfo(CodeGenModule &CGM)
Definition Sparc.cpp:404
std::unique_ptr< TargetCodeGenInfo > createX86_32TargetCodeGenInfo(CodeGenModule &CGM, bool DarwinVectorABI, bool Win32StructABI, unsigned NumRegisterParameters, bool SoftFloatABI)
Definition X86.cpp:3498
std::unique_ptr< TargetCodeGenInfo > createLanaiTargetCodeGenInfo(CodeGenModule &CGM)
Definition Lanai.cpp:156
std::unique_ptr< TargetCodeGenInfo > createPPC32TargetCodeGenInfo(CodeGenModule &CGM, bool SoftFloatABI)
Definition PPC.cpp:1044
CGCUDARuntime * CreateNVCUDARuntime(CodeGenModule &CGM)
Creates an instance of a CUDA runtime class.
std::unique_ptr< TargetCodeGenInfo > createLoongArchTargetCodeGenInfo(CodeGenModule &CGM, unsigned GRLen, unsigned FLen)
std::unique_ptr< TargetCodeGenInfo > createPPC64TargetCodeGenInfo(CodeGenModule &CGM)
Definition PPC.cpp:1052
std::unique_ptr< TargetCodeGenInfo > createWinX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel)
Definition X86.cpp:3525
std::unique_ptr< TargetCodeGenInfo > createXCoreTargetCodeGenInfo(CodeGenModule &CGM)
Definition XCore.cpp:658
std::unique_ptr< TargetCodeGenInfo > createCSKYTargetCodeGenInfo(CodeGenModule &CGM, unsigned FLen)
Definition CSKY.cpp:173
@ OS
Indicates that the tracking object is a descendant of a referenced-counted OSObject,...
bool LT(InterpState &S, CodePtr OpPC)
Definition Interp.h:1240
llvm::PointerUnion< const Decl *, const Expr * > DeclTy
Definition Descriptor.h:29
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
CXXCtorType
C++ constructor types.
Definition ABI.h:24
@ Ctor_Base
Base object ctor.
Definition ABI.h:26
@ Ctor_Complete
Complete object ctor.
Definition ABI.h:25
bool isa(CodeGen::Address addr)
Definition Address.h:330
@ CPlusPlus
GVALinkage
A more specific kind of linkage than enum Linkage.
Definition Linkage.h:72
@ GVA_StrongODR
Definition Linkage.h:77
@ GVA_StrongExternal
Definition Linkage.h:76
@ GVA_AvailableExternally
Definition Linkage.h:74
@ GVA_DiscardableODR
Definition Linkage.h:75
@ GVA_Internal
Definition Linkage.h:73
std::string getClangVendor()
Retrieves the Clang vendor tag.
Definition Version.cpp:60
@ PCK_ExeStr
Definition PragmaKinds.h:19
@ PCK_Compiler
Definition PragmaKinds.h:18
@ PCK_Linker
Definition PragmaKinds.h:16
@ PCK_Lib
Definition PragmaKinds.h:17
@ PCK_Unknown
Definition PragmaKinds.h:15
@ PCK_User
Definition PragmaKinds.h:20
@ ICIS_NoInit
No in-class initializer.
Definition Specifiers.h:272
CXXABI * CreateMicrosoftCXXABI(ASTContext &Ctx)
@ AS_public
Definition Specifiers.h:124
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
@ CLanguageLinkage
Definition Linkage.h:64
CXXABI * CreateItaniumCXXABI(ASTContext &Ctx)
Creates an instance of a C++ ABI class.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
Definition Linkage.h:24
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
Definition Linkage.h:35
@ Module
Module linkage, which indicates that the entity can be referred to from other translation units withi...
Definition Linkage.h:54
@ Asm
Assembly: we accept this only so that we can preprocess it.
@ SD_Thread
Thread storage duration.
Definition Specifiers.h:342
@ SD_Static
Static storage duration.
Definition Specifiers.h:343
bool isLambdaCallOperator(const CXXMethodDecl *MD)
Definition ASTLambda.h:28
@ Result
The result type of a method or function.
Definition TypeBase.h:905
const FunctionProtoType * T
StringRef languageToString(Language L)
@ Dtor_Base
Base object dtor.
Definition ABI.h:37
@ Dtor_Complete
Complete object dtor.
Definition ABI.h:36
LangAS
Defines the address space values used by the address space qualifier of QualType.
void EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts, llvm::vfs::FileSystem &VFS, DiagnosticsEngine &Diags)
static const char * getCFBranchLabelSchemeFlagVal(const CFBranchLabelSchemeKind Scheme)
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
Definition Specifiers.h:188
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
Definition Specifiers.h:206
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
Definition Specifiers.h:194
CallingConv
CallingConv - Specifies the calling convention that a function uses.
Definition Specifiers.h:278
@ CC_X86RegCall
Definition Specifiers.h:287
U cast(CodeGen::Address addr)
Definition Address.h:327
@ None
No keyword precedes the qualified type name.
Definition TypeBase.h:5874
@ Struct
The "struct" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5855
bool isExternallyVisible(Linkage L)
Definition Linkage.h:90
@ EST_None
no exception specification
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number,...
Definition Version.cpp:96
@ HiddenVisibility
Objects with "hidden" visibility are not seen by the dynamic linker.
Definition Visibility.h:37
@ DefaultVisibility
Objects with "default" visibility are seen by the dynamic linker and act like normal objects.
Definition Visibility.h:46
cl::opt< bool > SystemHeadersCoverage
int const char * function
Definition c++config.h:31
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
llvm::PointerType * ConstGlobalsPtrTy
void* in the address space for constant globals
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
llvm::IntegerType * CharTy
char
unsigned char PointerWidthInBits
The width of a pointer into the generic address space.
llvm::Type * HalfTy
half, bfloat, float, double
llvm::CallingConv::ID getRuntimeCC() const
EvalResult is a struct with detailed info about an evaluated expression.
Definition Expr.h:645
APValue Val
Val - This is the value the expression can be folded to.
Definition Expr.h:647
bool hasSideEffects() const
Return true if the evaluated expression has side effects.
Definition Expr.h:639
Extra information about a function prototype.
Definition TypeBase.h:5339
static const LangStandard & getLangStandardForKind(Kind K)
uint16_t Part2
...-89ab-...
Definition DeclCXX.h:4377
uint32_t Part1
{01234567-...
Definition DeclCXX.h:4375
uint16_t Part3
...-cdef-...
Definition DeclCXX.h:4379
uint8_t Part4And5[8]
...-0123-456789abcdef}
Definition DeclCXX.h:4381
A library or framework to link against when an entity from this module is used.
Definition Module.h:503
Contains information gathered from parsing the contents of TargetAttr.
Definition TargetInfo.h:60
PointerAuthSchema InitFiniPointers
The ABI for function addresses in .init_array and .fini_array.
Describes how types, statements, expressions, and declarations should be printed.