clang 19.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"
45#include "clang/Basic/Module.h"
48#include "clang/Basic/Version.h"
52#include "llvm/ADT/STLExtras.h"
53#include "llvm/ADT/StringExtras.h"
54#include "llvm/ADT/StringSwitch.h"
55#include "llvm/Analysis/TargetLibraryInfo.h"
56#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
57#include "llvm/IR/AttributeMask.h"
58#include "llvm/IR/CallingConv.h"
59#include "llvm/IR/DataLayout.h"
60#include "llvm/IR/Intrinsics.h"
61#include "llvm/IR/LLVMContext.h"
62#include "llvm/IR/Module.h"
63#include "llvm/IR/ProfileSummary.h"
64#include "llvm/ProfileData/InstrProfReader.h"
65#include "llvm/ProfileData/SampleProf.h"
66#include "llvm/Support/CRC.h"
67#include "llvm/Support/CodeGen.h"
68#include "llvm/Support/CommandLine.h"
69#include "llvm/Support/ConvertUTF.h"
70#include "llvm/Support/ErrorHandling.h"
71#include "llvm/Support/RISCVISAInfo.h"
72#include "llvm/Support/TimeProfiler.h"
73#include "llvm/Support/xxhash.h"
74#include "llvm/TargetParser/Triple.h"
75#include "llvm/TargetParser/X86TargetParser.h"
76#include <optional>
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";
86
88 switch (CGM.getContext().getCXXABIKind()) {
89 case TargetCXXABI::AppleARM64:
90 case TargetCXXABI::Fuchsia:
91 case TargetCXXABI::GenericAArch64:
92 case TargetCXXABI::GenericARM:
93 case TargetCXXABI::iOS:
94 case TargetCXXABI::WatchOS:
95 case TargetCXXABI::GenericMIPS:
96 case TargetCXXABI::GenericItanium:
97 case TargetCXXABI::WebAssembly:
98 case TargetCXXABI::XL:
99 return CreateItaniumCXXABI(CGM);
100 case TargetCXXABI::Microsoft:
101 return CreateMicrosoftCXXABI(CGM);
102 }
103
104 llvm_unreachable("invalid C++ ABI kind");
105}
106
107static std::unique_ptr<TargetCodeGenInfo>
109 const TargetInfo &Target = CGM.getTarget();
110 const llvm::Triple &Triple = Target.getTriple();
111 const CodeGenOptions &CodeGenOpts = CGM.getCodeGenOpts();
112
113 switch (Triple.getArch()) {
114 default:
116
117 case llvm::Triple::le32:
119 case llvm::Triple::m68k:
120 return createM68kTargetCodeGenInfo(CGM);
121 case llvm::Triple::mips:
122 case llvm::Triple::mipsel:
123 if (Triple.getOS() == llvm::Triple::NaCl)
125 return createMIPSTargetCodeGenInfo(CGM, /*IsOS32=*/true);
126
127 case llvm::Triple::mips64:
128 case llvm::Triple::mips64el:
129 return createMIPSTargetCodeGenInfo(CGM, /*IsOS32=*/false);
130
131 case llvm::Triple::avr: {
132 // For passing parameters, R8~R25 are used on avr, and R18~R25 are used
133 // on avrtiny. For passing return value, R18~R25 are used on avr, and
134 // R22~R25 are used on avrtiny.
135 unsigned NPR = Target.getABI() == "avrtiny" ? 6 : 18;
136 unsigned NRR = Target.getABI() == "avrtiny" ? 4 : 8;
137 return createAVRTargetCodeGenInfo(CGM, NPR, NRR);
138 }
139
140 case llvm::Triple::aarch64:
141 case llvm::Triple::aarch64_32:
142 case llvm::Triple::aarch64_be: {
143 AArch64ABIKind Kind = AArch64ABIKind::AAPCS;
144 if (Target.getABI() == "darwinpcs")
145 Kind = AArch64ABIKind::DarwinPCS;
146 else if (Triple.isOSWindows())
147 return createWindowsAArch64TargetCodeGenInfo(CGM, AArch64ABIKind::Win64);
148 else if (Target.getABI() == "aapcs-soft")
149 Kind = AArch64ABIKind::AAPCSSoft;
150
151 return createAArch64TargetCodeGenInfo(CGM, Kind);
152 }
153
154 case llvm::Triple::wasm32:
155 case llvm::Triple::wasm64: {
156 WebAssemblyABIKind Kind = WebAssemblyABIKind::MVP;
157 if (Target.getABI() == "experimental-mv")
158 Kind = WebAssemblyABIKind::ExperimentalMV;
159 return createWebAssemblyTargetCodeGenInfo(CGM, Kind);
160 }
161
162 case llvm::Triple::arm:
163 case llvm::Triple::armeb:
164 case llvm::Triple::thumb:
165 case llvm::Triple::thumbeb: {
166 if (Triple.getOS() == llvm::Triple::Win32)
167 return createWindowsARMTargetCodeGenInfo(CGM, ARMABIKind::AAPCS_VFP);
168
169 ARMABIKind Kind = ARMABIKind::AAPCS;
170 StringRef ABIStr = Target.getABI();
171 if (ABIStr == "apcs-gnu")
172 Kind = ARMABIKind::APCS;
173 else if (ABIStr == "aapcs16")
174 Kind = ARMABIKind::AAPCS16_VFP;
175 else if (CodeGenOpts.FloatABI == "hard" ||
176 (CodeGenOpts.FloatABI != "soft" &&
177 (Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
178 Triple.getEnvironment() == llvm::Triple::MuslEABIHF ||
179 Triple.getEnvironment() == llvm::Triple::EABIHF)))
180 Kind = ARMABIKind::AAPCS_VFP;
181
182 return createARMTargetCodeGenInfo(CGM, Kind);
183 }
184
185 case llvm::Triple::ppc: {
186 if (Triple.isOSAIX())
187 return createAIXTargetCodeGenInfo(CGM, /*Is64Bit=*/false);
188
189 bool IsSoftFloat =
190 CodeGenOpts.FloatABI == "soft" || Target.hasFeature("spe");
191 return createPPC32TargetCodeGenInfo(CGM, IsSoftFloat);
192 }
193 case llvm::Triple::ppcle: {
194 bool IsSoftFloat = CodeGenOpts.FloatABI == "soft";
195 return createPPC32TargetCodeGenInfo(CGM, IsSoftFloat);
196 }
197 case llvm::Triple::ppc64:
198 if (Triple.isOSAIX())
199 return createAIXTargetCodeGenInfo(CGM, /*Is64Bit=*/true);
200
201 if (Triple.isOSBinFormatELF()) {
202 PPC64_SVR4_ABIKind Kind = PPC64_SVR4_ABIKind::ELFv1;
203 if (Target.getABI() == "elfv2")
204 Kind = PPC64_SVR4_ABIKind::ELFv2;
205 bool IsSoftFloat = CodeGenOpts.FloatABI == "soft";
206
207 return createPPC64_SVR4_TargetCodeGenInfo(CGM, Kind, IsSoftFloat);
208 }
210 case llvm::Triple::ppc64le: {
211 assert(Triple.isOSBinFormatELF() && "PPC64 LE non-ELF not supported!");
212 PPC64_SVR4_ABIKind Kind = PPC64_SVR4_ABIKind::ELFv2;
213 if (Target.getABI() == "elfv1")
214 Kind = PPC64_SVR4_ABIKind::ELFv1;
215 bool IsSoftFloat = CodeGenOpts.FloatABI == "soft";
216
217 return createPPC64_SVR4_TargetCodeGenInfo(CGM, Kind, IsSoftFloat);
218 }
219
220 case llvm::Triple::nvptx:
221 case llvm::Triple::nvptx64:
223
224 case llvm::Triple::msp430:
226
227 case llvm::Triple::riscv32:
228 case llvm::Triple::riscv64: {
229 StringRef ABIStr = Target.getABI();
230 unsigned XLen = Target.getPointerWidth(LangAS::Default);
231 unsigned ABIFLen = 0;
232 if (ABIStr.ends_with("f"))
233 ABIFLen = 32;
234 else if (ABIStr.ends_with("d"))
235 ABIFLen = 64;
236 bool EABI = ABIStr.ends_with("e");
237 return createRISCVTargetCodeGenInfo(CGM, XLen, ABIFLen, EABI);
238 }
239
240 case llvm::Triple::systemz: {
241 bool SoftFloat = CodeGenOpts.FloatABI == "soft";
242 bool HasVector = !SoftFloat && Target.getABI() == "vector";
243 return createSystemZTargetCodeGenInfo(CGM, HasVector, SoftFloat);
244 }
245
246 case llvm::Triple::tce:
247 case llvm::Triple::tcele:
248 return createTCETargetCodeGenInfo(CGM);
249
250 case llvm::Triple::x86: {
251 bool IsDarwinVectorABI = Triple.isOSDarwin();
252 bool IsWin32FloatStructABI = Triple.isOSWindows() && !Triple.isOSCygMing();
253
254 if (Triple.getOS() == llvm::Triple::Win32) {
256 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
257 CodeGenOpts.NumRegisterParameters);
258 }
260 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
261 CodeGenOpts.NumRegisterParameters, CodeGenOpts.FloatABI == "soft");
262 }
263
264 case llvm::Triple::x86_64: {
265 StringRef ABI = Target.getABI();
266 X86AVXABILevel AVXLevel = (ABI == "avx512" ? X86AVXABILevel::AVX512
267 : ABI == "avx" ? X86AVXABILevel::AVX
268 : X86AVXABILevel::None);
269
270 switch (Triple.getOS()) {
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:
299 case llvm::Triple::ve:
300 return createVETargetCodeGenInfo(CGM);
301 case llvm::Triple::csky: {
302 bool IsSoftFloat = !Target.hasFeature("hard-float-abi");
303 bool hasFP64 =
304 Target.hasFeature("fpuv2_df") || Target.hasFeature("fpuv3_df");
305 return createCSKYTargetCodeGenInfo(CGM, IsSoftFloat ? 0
306 : hasFP64 ? 64
307 : 32);
308 }
309 case llvm::Triple::bpfeb:
310 case llvm::Triple::bpfel:
311 return createBPFTargetCodeGenInfo(CGM);
312 case llvm::Triple::loongarch32:
313 case llvm::Triple::loongarch64: {
314 StringRef ABIStr = Target.getABI();
315 unsigned ABIFRLen = 0;
316 if (ABIStr.ends_with("f"))
317 ABIFRLen = 32;
318 else if (ABIStr.ends_with("d"))
319 ABIFRLen = 64;
321 CGM, Target.getPointerWidth(LangAS::Default), ABIFRLen);
322 }
323 }
324}
325
327 if (!TheTargetCodeGenInfo)
328 TheTargetCodeGenInfo = createTargetCodeGenInfo(*this);
329 return *TheTargetCodeGenInfo;
330}
331
332CodeGenModule::CodeGenModule(ASTContext &C,
334 const HeaderSearchOptions &HSO,
335 const PreprocessorOptions &PPO,
336 const CodeGenOptions &CGO, llvm::Module &M,
337 DiagnosticsEngine &diags,
338 CoverageSourceInfo *CoverageInfo)
339 : Context(C), LangOpts(C.getLangOpts()), FS(FS), HeaderSearchOpts(HSO),
340 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
341 Target(C.getTargetInfo()), ABI(createCXXABI(*this)),
342 VMContext(M.getContext()), Types(*this), VTables(*this),
343 SanitizerMD(new SanitizerMetadata(*this)) {
344
345 // Initialize the type cache.
346 llvm::LLVMContext &LLVMContext = M.getContext();
347 VoidTy = llvm::Type::getVoidTy(LLVMContext);
348 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
349 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
350 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
351 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
352 HalfTy = llvm::Type::getHalfTy(LLVMContext);
353 BFloatTy = llvm::Type::getBFloatTy(LLVMContext);
354 FloatTy = llvm::Type::getFloatTy(LLVMContext);
355 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
356 PointerWidthInBits = C.getTargetInfo().getPointerWidth(LangAS::Default);
358 C.toCharUnitsFromBits(C.getTargetInfo().getPointerAlign(LangAS::Default))
359 .getQuantity();
361 C.toCharUnitsFromBits(C.getTargetInfo().getMaxPointerWidth()).getQuantity();
363 C.toCharUnitsFromBits(C.getTargetInfo().getIntAlign()).getQuantity();
364 CharTy =
365 llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getCharWidth());
366 IntTy = llvm::IntegerType::get(LLVMContext, C.getTargetInfo().getIntWidth());
367 IntPtrTy = llvm::IntegerType::get(LLVMContext,
368 C.getTargetInfo().getMaxPointerWidth());
369 Int8PtrTy = llvm::PointerType::get(LLVMContext, 0);
370 const llvm::DataLayout &DL = M.getDataLayout();
372 llvm::PointerType::get(LLVMContext, DL.getAllocaAddrSpace());
374 llvm::PointerType::get(LLVMContext, DL.getDefaultGlobalsAddressSpace());
375 ConstGlobalsPtrTy = llvm::PointerType::get(
376 LLVMContext, C.getTargetAddressSpace(GetGlobalConstantAddressSpace()));
378
379 // Build C++20 Module initializers.
380 // TODO: Add Microsoft here once we know the mangling required for the
381 // initializers.
382 CXX20ModuleInits =
383 LangOpts.CPlusPlusModules && getCXXABI().getMangleContext().getKind() ==
385
386 RuntimeCC = getTargetCodeGenInfo().getABIInfo().getRuntimeCC();
387
388 if (LangOpts.ObjC)
389 createObjCRuntime();
390 if (LangOpts.OpenCL)
391 createOpenCLRuntime();
392 if (LangOpts.OpenMP)
393 createOpenMPRuntime();
394 if (LangOpts.CUDA)
395 createCUDARuntime();
396 if (LangOpts.HLSL)
397 createHLSLRuntime();
398
399 // Enable TBAA unless it's suppressed. ThreadSanitizer needs TBAA even at O0.
400 if (LangOpts.Sanitize.has(SanitizerKind::Thread) ||
401 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
402 TBAA.reset(new CodeGenTBAA(Context, getTypes(), TheModule, CodeGenOpts,
403 getLangOpts(), getCXXABI().getMangleContext()));
404
405 // If debug info or coverage generation is enabled, create the CGDebugInfo
406 // object.
407 if (CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo ||
408 CodeGenOpts.CoverageNotesFile.size() ||
409 CodeGenOpts.CoverageDataFile.size())
410 DebugInfo.reset(new CGDebugInfo(*this));
411
412 Block.GlobalUniqueCount = 0;
413
414 if (C.getLangOpts().ObjC)
415 ObjCData.reset(new ObjCEntrypoints());
416
417 if (CodeGenOpts.hasProfileClangUse()) {
418 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
419 CodeGenOpts.ProfileInstrumentUsePath, *FS,
420 CodeGenOpts.ProfileRemappingFile);
421 // We're checking for profile read errors in CompilerInvocation, so if
422 // there was an error it should've already been caught. If it hasn't been
423 // somehow, trip an assertion.
424 assert(ReaderOrErr);
425 PGOReader = std::move(ReaderOrErr.get());
426 }
427
428 // If coverage mapping generation is enabled, create the
429 // CoverageMappingModuleGen object.
430 if (CodeGenOpts.CoverageMapping)
431 CoverageMapping.reset(new CoverageMappingModuleGen(*this, *CoverageInfo));
432
433 // Generate the module name hash here if needed.
434 if (CodeGenOpts.UniqueInternalLinkageNames &&
435 !getModule().getSourceFileName().empty()) {
436 std::string Path = getModule().getSourceFileName();
437 // Check if a path substitution is needed from the MacroPrefixMap.
438 for (const auto &Entry : LangOpts.MacroPrefixMap)
439 if (Path.rfind(Entry.first, 0) != std::string::npos) {
440 Path = Entry.second + Path.substr(Entry.first.size());
441 break;
442 }
443 ModuleNameHash = llvm::getUniqueInternalLinkagePostfix(Path);
444 }
445}
446
448
449void CodeGenModule::createObjCRuntime() {
450 // This is just isGNUFamily(), but we want to force implementors of
451 // new ABIs to decide how best to do this.
452 switch (LangOpts.ObjCRuntime.getKind()) {
454 case ObjCRuntime::GCC:
456 ObjCRuntime.reset(CreateGNUObjCRuntime(*this));
457 return;
458
461 case ObjCRuntime::iOS:
463 ObjCRuntime.reset(CreateMacObjCRuntime(*this));
464 return;
465 }
466 llvm_unreachable("bad runtime kind");
467}
468
469void CodeGenModule::createOpenCLRuntime() {
470 OpenCLRuntime.reset(new CGOpenCLRuntime(*this));
471}
472
473void CodeGenModule::createOpenMPRuntime() {
474 // Select a specialized code generation class based on the target, if any.
475 // If it does not exist use the default implementation.
476 switch (getTriple().getArch()) {
477 case llvm::Triple::nvptx:
478 case llvm::Triple::nvptx64:
479 case llvm::Triple::amdgcn:
480 assert(getLangOpts().OpenMPIsTargetDevice &&
481 "OpenMP AMDGPU/NVPTX is only prepared to deal with device code.");
482 OpenMPRuntime.reset(new CGOpenMPRuntimeGPU(*this));
483 break;
484 default:
485 if (LangOpts.OpenMPSimd)
486 OpenMPRuntime.reset(new CGOpenMPSIMDRuntime(*this));
487 else
488 OpenMPRuntime.reset(new CGOpenMPRuntime(*this));
489 break;
490 }
491}
492
493void CodeGenModule::createCUDARuntime() {
494 CUDARuntime.reset(CreateNVCUDARuntime(*this));
495}
496
497void CodeGenModule::createHLSLRuntime() {
498 HLSLRuntime.reset(new CGHLSLRuntime(*this));
499}
500
501void CodeGenModule::addReplacement(StringRef Name, llvm::Constant *C) {
502 Replacements[Name] = C;
503}
504
505void CodeGenModule::applyReplacements() {
506 for (auto &I : Replacements) {
507 StringRef MangledName = I.first;
508 llvm::Constant *Replacement = I.second;
509 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
510 if (!Entry)
511 continue;
512 auto *OldF = cast<llvm::Function>(Entry);
513 auto *NewF = dyn_cast<llvm::Function>(Replacement);
514 if (!NewF) {
515 if (auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
516 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
517 } else {
518 auto *CE = cast<llvm::ConstantExpr>(Replacement);
519 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
520 CE->getOpcode() == llvm::Instruction::GetElementPtr);
521 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
522 }
523 }
524
525 // Replace old with new, but keep the old order.
526 OldF->replaceAllUsesWith(Replacement);
527 if (NewF) {
528 NewF->removeFromParent();
529 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
530 NewF);
531 }
532 OldF->eraseFromParent();
533 }
534}
535
536void CodeGenModule::addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C) {
537 GlobalValReplacements.push_back(std::make_pair(GV, C));
538}
539
540void CodeGenModule::applyGlobalValReplacements() {
541 for (auto &I : GlobalValReplacements) {
542 llvm::GlobalValue *GV = I.first;
543 llvm::Constant *C = I.second;
544
545 GV->replaceAllUsesWith(C);
546 GV->eraseFromParent();
547 }
548}
549
550// This is only used in aliases that we created and we know they have a
551// linear structure.
552static const llvm::GlobalValue *getAliasedGlobal(const llvm::GlobalValue *GV) {
553 const llvm::Constant *C;
554 if (auto *GA = dyn_cast<llvm::GlobalAlias>(GV))
555 C = GA->getAliasee();
556 else if (auto *GI = dyn_cast<llvm::GlobalIFunc>(GV))
557 C = GI->getResolver();
558 else
559 return GV;
560
561 const auto *AliaseeGV = dyn_cast<llvm::GlobalValue>(C->stripPointerCasts());
562 if (!AliaseeGV)
563 return nullptr;
564
565 const llvm::GlobalValue *FinalGV = AliaseeGV->getAliaseeObject();
566 if (FinalGV == GV)
567 return nullptr;
568
569 return FinalGV;
570}
571
573 const ASTContext &Context, DiagnosticsEngine &Diags, SourceLocation Location,
574 bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV,
575 const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames,
576 SourceRange AliasRange) {
577 GV = getAliasedGlobal(Alias);
578 if (!GV) {
579 Diags.Report(Location, diag::err_cyclic_alias) << IsIFunc;
580 return false;
581 }
582
583 if (GV->hasCommonLinkage()) {
584 const llvm::Triple &Triple = Context.getTargetInfo().getTriple();
585 if (Triple.getObjectFormat() == llvm::Triple::XCOFF) {
586 Diags.Report(Location, diag::err_alias_to_common);
587 return false;
588 }
589 }
590
591 if (GV->isDeclaration()) {
592 Diags.Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;
593 Diags.Report(Location, diag::note_alias_requires_mangled_name)
594 << IsIFunc << IsIFunc;
595 // Provide a note if the given function is not found and exists as a
596 // mangled name.
597 for (const auto &[Decl, Name] : MangledDeclNames) {
598 if (const auto *ND = dyn_cast<NamedDecl>(Decl.getDecl())) {
599 if (ND->getName() == GV->getName()) {
600 Diags.Report(Location, diag::note_alias_mangled_name_alternative)
601 << Name
603 AliasRange,
604 (Twine(IsIFunc ? "ifunc" : "alias") + "(\"" + Name + "\")")
605 .str());
606 }
607 }
608 }
609 return false;
610 }
611
612 if (IsIFunc) {
613 // Check resolver function type.
614 const auto *F = dyn_cast<llvm::Function>(GV);
615 if (!F) {
616 Diags.Report(Location, diag::err_alias_to_undefined)
617 << IsIFunc << IsIFunc;
618 return false;
619 }
620
621 llvm::FunctionType *FTy = F->getFunctionType();
622 if (!FTy->getReturnType()->isPointerTy()) {
623 Diags.Report(Location, diag::err_ifunc_resolver_return);
624 return false;
625 }
626 }
627
628 return true;
629}
630
631// Emit a warning if toc-data attribute is requested for global variables that
632// have aliases and remove the toc-data attribute.
633static void checkAliasForTocData(llvm::GlobalVariable *GVar,
634 const CodeGenOptions &CodeGenOpts,
635 DiagnosticsEngine &Diags,
636 SourceLocation Location) {
637 if (GVar->hasAttribute("toc-data")) {
638 auto GVId = GVar->getName();
639 // Is this a global variable specified by the user as local?
640 if ((llvm::binary_search(CodeGenOpts.TocDataVarsUserSpecified, GVId))) {
641 Diags.Report(Location, diag::warn_toc_unsupported_type)
642 << GVId << "the variable has an alias";
643 }
644 llvm::AttributeSet CurrAttributes = GVar->getAttributes();
645 llvm::AttributeSet NewAttributes =
646 CurrAttributes.removeAttribute(GVar->getContext(), "toc-data");
647 GVar->setAttributes(NewAttributes);
648 }
649}
650
651void CodeGenModule::checkAliases() {
652 // Check if the constructed aliases are well formed. It is really unfortunate
653 // that we have to do this in CodeGen, but we only construct mangled names
654 // and aliases during codegen.
655 bool Error = false;
656 DiagnosticsEngine &Diags = getDiags();
657 for (const GlobalDecl &GD : Aliases) {
658 const auto *D = cast<ValueDecl>(GD.getDecl());
659 SourceLocation Location;
661 bool IsIFunc = D->hasAttr<IFuncAttr>();
662 if (const Attr *A = D->getDefiningAttr()) {
663 Location = A->getLocation();
664 Range = A->getRange();
665 } else
666 llvm_unreachable("Not an alias or ifunc?");
667
668 StringRef MangledName = getMangledName(GD);
669 llvm::GlobalValue *Alias = GetGlobalValue(MangledName);
670 const llvm::GlobalValue *GV = nullptr;
671 if (!checkAliasedGlobal(getContext(), Diags, Location, IsIFunc, Alias, GV,
672 MangledDeclNames, Range)) {
673 Error = true;
674 continue;
675 }
676
677 if (getContext().getTargetInfo().getTriple().isOSAIX())
678 if (const llvm::GlobalVariable *GVar =
679 dyn_cast<const llvm::GlobalVariable>(GV))
680 checkAliasForTocData(const_cast<llvm::GlobalVariable *>(GVar),
681 getCodeGenOpts(), Diags, Location);
682
683 llvm::Constant *Aliasee =
684 IsIFunc ? cast<llvm::GlobalIFunc>(Alias)->getResolver()
685 : cast<llvm::GlobalAlias>(Alias)->getAliasee();
686
687 llvm::GlobalValue *AliaseeGV;
688 if (auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
689 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
690 else
691 AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
692
693 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) {
694 StringRef AliasSection = SA->getName();
695 if (AliasSection != AliaseeGV->getSection())
696 Diags.Report(SA->getLocation(), diag::warn_alias_with_section)
697 << AliasSection << IsIFunc << IsIFunc;
698 }
699
700 // We have to handle alias to weak aliases in here. LLVM itself disallows
701 // this since the object semantics would not match the IL one. For
702 // compatibility with gcc we implement it by just pointing the alias
703 // to its aliasee's aliasee. We also warn, since the user is probably
704 // expecting the link to be weak.
705 if (auto *GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {
706 if (GA->isInterposable()) {
707 Diags.Report(Location, diag::warn_alias_to_weak_alias)
708 << GV->getName() << GA->getName() << IsIFunc;
709 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
710 GA->getAliasee(), Alias->getType());
711
712 if (IsIFunc)
713 cast<llvm::GlobalIFunc>(Alias)->setResolver(Aliasee);
714 else
715 cast<llvm::GlobalAlias>(Alias)->setAliasee(Aliasee);
716 }
717 }
718 }
719 if (!Error)
720 return;
721
722 for (const GlobalDecl &GD : Aliases) {
723 StringRef MangledName = getMangledName(GD);
724 llvm::GlobalValue *Alias = GetGlobalValue(MangledName);
725 Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
726 Alias->eraseFromParent();
727 }
728}
729
731 DeferredDeclsToEmit.clear();
732 EmittedDeferredDecls.clear();
733 DeferredAnnotations.clear();
734 if (OpenMPRuntime)
735 OpenMPRuntime->clear();
736}
737
739 StringRef MainFile) {
740 if (!hasDiagnostics())
741 return;
742 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
743 if (MainFile.empty())
744 MainFile = "<stdin>";
745 Diags.Report(diag::warn_profile_data_unprofiled) << MainFile;
746 } else {
747 if (Mismatched > 0)
748 Diags.Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
749
750 if (Missing > 0)
751 Diags.Report(diag::warn_profile_data_missing) << Visited << Missing;
752 }
753}
754
755static std::optional<llvm::GlobalValue::VisibilityTypes>
757 // Map to LLVM visibility.
758 switch (K) {
760 return std::nullopt;
762 return llvm::GlobalValue::DefaultVisibility;
764 return llvm::GlobalValue::HiddenVisibility;
766 return llvm::GlobalValue::ProtectedVisibility;
767 }
768 llvm_unreachable("unknown option value!");
769}
770
771void setLLVMVisibility(llvm::GlobalValue &GV,
772 std::optional<llvm::GlobalValue::VisibilityTypes> V) {
773 if (!V)
774 return;
775
776 // Reset DSO locality before setting the visibility. This removes
777 // any effects that visibility options and annotations may have
778 // had on the DSO locality. Setting the visibility will implicitly set
779 // appropriate globals to DSO Local; however, this will be pessimistic
780 // w.r.t. to the normal compiler IRGen.
781 GV.setDSOLocal(false);
782 GV.setVisibility(*V);
783}
784
786 llvm::Module &M) {
787 if (!LO.VisibilityFromDLLStorageClass)
788 return;
789
790 std::optional<llvm::GlobalValue::VisibilityTypes> DLLExportVisibility =
791 getLLVMVisibility(LO.getDLLExportVisibility());
792
793 std::optional<llvm::GlobalValue::VisibilityTypes>
794 NoDLLStorageClassVisibility =
795 getLLVMVisibility(LO.getNoDLLStorageClassVisibility());
796
797 std::optional<llvm::GlobalValue::VisibilityTypes>
798 ExternDeclDLLImportVisibility =
799 getLLVMVisibility(LO.getExternDeclDLLImportVisibility());
800
801 std::optional<llvm::GlobalValue::VisibilityTypes>
802 ExternDeclNoDLLStorageClassVisibility =
803 getLLVMVisibility(LO.getExternDeclNoDLLStorageClassVisibility());
804
805 for (llvm::GlobalValue &GV : M.global_values()) {
806 if (GV.hasAppendingLinkage() || GV.hasLocalLinkage())
807 continue;
808
809 if (GV.isDeclarationForLinker())
810 setLLVMVisibility(GV, GV.getDLLStorageClass() ==
811 llvm::GlobalValue::DLLImportStorageClass
812 ? ExternDeclDLLImportVisibility
813 : ExternDeclNoDLLStorageClassVisibility);
814 else
815 setLLVMVisibility(GV, GV.getDLLStorageClass() ==
816 llvm::GlobalValue::DLLExportStorageClass
817 ? DLLExportVisibility
818 : NoDLLStorageClassVisibility);
819
820 GV.setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
821 }
822}
823
824static bool isStackProtectorOn(const LangOptions &LangOpts,
825 const llvm::Triple &Triple,
827 if (Triple.isAMDGPU() || Triple.isNVPTX())
828 return false;
829 return LangOpts.getStackProtector() == Mode;
830}
831
834 if (CXX20ModuleInits && Primary && !Primary->isHeaderLikeModule())
835 EmitModuleInitializers(Primary);
836 EmitDeferred();
837 DeferredDecls.insert(EmittedDeferredDecls.begin(),
838 EmittedDeferredDecls.end());
839 EmittedDeferredDecls.clear();
840 EmitVTablesOpportunistically();
841 applyGlobalValReplacements();
842 applyReplacements();
843 emitMultiVersionFunctions();
844
845 if (Context.getLangOpts().IncrementalExtensions &&
846 GlobalTopLevelStmtBlockInFlight.first) {
847 const TopLevelStmtDecl *TLSD = GlobalTopLevelStmtBlockInFlight.second;
848 GlobalTopLevelStmtBlockInFlight.first->FinishFunction(TLSD->getEndLoc());
849 GlobalTopLevelStmtBlockInFlight = {nullptr, nullptr};
850 }
851
852 // Module implementations are initialized the same way as a regular TU that
853 // imports one or more modules.
854 if (CXX20ModuleInits && Primary && Primary->isInterfaceOrPartition())
855 EmitCXXModuleInitFunc(Primary);
856 else
857 EmitCXXGlobalInitFunc();
858 EmitCXXGlobalCleanUpFunc();
859 registerGlobalDtorsWithAtExit();
860 EmitCXXThreadLocalInitFunc();
861 if (ObjCRuntime)
862 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
863 AddGlobalCtor(ObjCInitFunction);
864 if (Context.getLangOpts().CUDA && CUDARuntime) {
865 if (llvm::Function *CudaCtorFunction = CUDARuntime->finalizeModule())
866 AddGlobalCtor(CudaCtorFunction);
867 }
868 if (OpenMPRuntime) {
869 OpenMPRuntime->createOffloadEntriesAndInfoMetadata();
870 OpenMPRuntime->clear();
871 }
872 if (PGOReader) {
873 getModule().setProfileSummary(
874 PGOReader->getSummary(/* UseCS */ false).getMD(VMContext),
875 llvm::ProfileSummary::PSK_Instr);
876 if (PGOStats.hasDiagnostics())
877 PGOStats.reportDiagnostics(getDiags(), getCodeGenOpts().MainFileName);
878 }
879 llvm::stable_sort(GlobalCtors, [](const Structor &L, const Structor &R) {
880 return L.LexOrder < R.LexOrder;
881 });
882 EmitCtorList(GlobalCtors, "llvm.global_ctors");
883 EmitCtorList(GlobalDtors, "llvm.global_dtors");
885 EmitStaticExternCAliases();
886 checkAliases();
890 if (CoverageMapping)
891 CoverageMapping->emit();
892 if (CodeGenOpts.SanitizeCfiCrossDso) {
895 }
896 if (LangOpts.Sanitize.has(SanitizerKind::KCFI))
898 emitAtAvailableLinkGuard();
899 if (Context.getTargetInfo().getTriple().isWasm())
901
902 if (getTriple().isAMDGPU()) {
903 // Emit amdhsa_code_object_version module flag, which is code object version
904 // times 100.
905 if (getTarget().getTargetOpts().CodeObjectVersion !=
906 llvm::CodeObjectVersionKind::COV_None) {
907 getModule().addModuleFlag(llvm::Module::Error,
908 "amdhsa_code_object_version",
909 getTarget().getTargetOpts().CodeObjectVersion);
910 }
911
912 // Currently, "-mprintf-kind" option is only supported for HIP
913 if (LangOpts.HIP) {
914 auto *MDStr = llvm::MDString::get(
915 getLLVMContext(), (getTarget().getTargetOpts().AMDGPUPrintfKindVal ==
917 ? "hostcall"
918 : "buffered");
919 getModule().addModuleFlag(llvm::Module::Error, "amdgpu_printf_kind",
920 MDStr);
921 }
922 }
923
924 // Emit a global array containing all external kernels or device variables
925 // used by host functions and mark it as used for CUDA/HIP. This is necessary
926 // to get kernels or device variables in archives linked in even if these
927 // kernels or device variables are only used in host functions.
928 if (!Context.CUDAExternalDeviceDeclODRUsedByHost.empty()) {
930 for (auto D : Context.CUDAExternalDeviceDeclODRUsedByHost) {
931 GlobalDecl GD;
932 if (auto *FD = dyn_cast<FunctionDecl>(D))
934 else
935 GD = GlobalDecl(D);
936 UsedArray.push_back(llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
938 }
939
940 llvm::ArrayType *ATy = llvm::ArrayType::get(Int8PtrTy, UsedArray.size());
941
942 auto *GV = new llvm::GlobalVariable(
943 getModule(), ATy, false, llvm::GlobalValue::InternalLinkage,
944 llvm::ConstantArray::get(ATy, UsedArray), "__clang_gpu_used_external");
946 }
947 if (LangOpts.HIP && !getLangOpts().OffloadingNewDriver) {
948 // Emit a unique ID so that host and device binaries from the same
949 // compilation unit can be associated.
950 auto *GV = new llvm::GlobalVariable(
951 getModule(), Int8Ty, false, llvm::GlobalValue::ExternalLinkage,
952 llvm::Constant::getNullValue(Int8Ty),
953 "__hip_cuid_" + getContext().getCUIDHash());
955 }
956 emitLLVMUsed();
957 if (SanStats)
958 SanStats->finish();
959
960 if (CodeGenOpts.Autolink &&
961 (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
962 EmitModuleLinkOptions();
963 }
964
965 // On ELF we pass the dependent library specifiers directly to the linker
966 // without manipulating them. This is in contrast to other platforms where
967 // they are mapped to a specific linker option by the compiler. This
968 // difference is a result of the greater variety of ELF linkers and the fact
969 // that ELF linkers tend to handle libraries in a more complicated fashion
970 // than on other platforms. This forces us to defer handling the dependent
971 // libs to the linker.
972 //
973 // CUDA/HIP device and host libraries are different. Currently there is no
974 // way to differentiate dependent libraries for host or device. Existing
975 // usage of #pragma comment(lib, *) is intended for host libraries on
976 // Windows. Therefore emit llvm.dependent-libraries only for host.
977 if (!ELFDependentLibraries.empty() && !Context.getLangOpts().CUDAIsDevice) {
978 auto *NMD = getModule().getOrInsertNamedMetadata("llvm.dependent-libraries");
979 for (auto *MD : ELFDependentLibraries)
980 NMD->addOperand(MD);
981 }
982
983 // Record mregparm value now so it is visible through rest of codegen.
984 if (Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
985 getModule().addModuleFlag(llvm::Module::Error, "NumRegisterParameters",
986 CodeGenOpts.NumRegisterParameters);
987
988 if (CodeGenOpts.DwarfVersion) {
989 getModule().addModuleFlag(llvm::Module::Max, "Dwarf Version",
990 CodeGenOpts.DwarfVersion);
991 }
992
993 if (CodeGenOpts.Dwarf64)
994 getModule().addModuleFlag(llvm::Module::Max, "DWARF64", 1);
995
996 if (Context.getLangOpts().SemanticInterposition)
997 // Require various optimization to respect semantic interposition.
998 getModule().setSemanticInterposition(true);
999
1000 if (CodeGenOpts.EmitCodeView) {
1001 // Indicate that we want CodeView in the metadata.
1002 getModule().addModuleFlag(llvm::Module::Warning, "CodeView", 1);
1003 }
1004 if (CodeGenOpts.CodeViewGHash) {
1005 getModule().addModuleFlag(llvm::Module::Warning, "CodeViewGHash", 1);
1006 }
1007 if (CodeGenOpts.ControlFlowGuard) {
1008 // Function ID tables and checks for Control Flow Guard (cfguard=2).
1009 getModule().addModuleFlag(llvm::Module::Warning, "cfguard", 2);
1010 } else if (CodeGenOpts.ControlFlowGuardNoChecks) {
1011 // Function ID tables for Control Flow Guard (cfguard=1).
1012 getModule().addModuleFlag(llvm::Module::Warning, "cfguard", 1);
1013 }
1014 if (CodeGenOpts.EHContGuard) {
1015 // Function ID tables for EH Continuation Guard.
1016 getModule().addModuleFlag(llvm::Module::Warning, "ehcontguard", 1);
1017 }
1018 if (Context.getLangOpts().Kernel) {
1019 // Note if we are compiling with /kernel.
1020 getModule().addModuleFlag(llvm::Module::Warning, "ms-kernel", 1);
1021 }
1022 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
1023 // We don't support LTO with 2 with different StrictVTablePointers
1024 // FIXME: we could support it by stripping all the information introduced
1025 // by StrictVTablePointers.
1026
1027 getModule().addModuleFlag(llvm::Module::Error, "StrictVTablePointers",1);
1028
1029 llvm::Metadata *Ops[2] = {
1030 llvm::MDString::get(VMContext, "StrictVTablePointers"),
1031 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1032 llvm::Type::getInt32Ty(VMContext), 1))};
1033
1034 getModule().addModuleFlag(llvm::Module::Require,
1035 "StrictVTablePointersRequirement",
1036 llvm::MDNode::get(VMContext, Ops));
1037 }
1038 if (getModuleDebugInfo())
1039 // We support a single version in the linked module. The LLVM
1040 // parser will drop debug info with a different version number
1041 // (and warn about it, too).
1042 getModule().addModuleFlag(llvm::Module::Warning, "Debug Info Version",
1043 llvm::DEBUG_METADATA_VERSION);
1044
1045 // We need to record the widths of enums and wchar_t, so that we can generate
1046 // the correct build attributes in the ARM backend. wchar_size is also used by
1047 // TargetLibraryInfo.
1048 uint64_t WCharWidth =
1049 Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
1050 getModule().addModuleFlag(llvm::Module::Error, "wchar_size", WCharWidth);
1051
1052 if (getTriple().isOSzOS()) {
1053 getModule().addModuleFlag(llvm::Module::Warning,
1054 "zos_product_major_version",
1055 uint32_t(CLANG_VERSION_MAJOR));
1056 getModule().addModuleFlag(llvm::Module::Warning,
1057 "zos_product_minor_version",
1058 uint32_t(CLANG_VERSION_MINOR));
1059 getModule().addModuleFlag(llvm::Module::Warning, "zos_product_patchlevel",
1060 uint32_t(CLANG_VERSION_PATCHLEVEL));
1061 std::string ProductId = getClangVendor() + "clang";
1062 getModule().addModuleFlag(llvm::Module::Error, "zos_product_id",
1063 llvm::MDString::get(VMContext, ProductId));
1064
1065 // Record the language because we need it for the PPA2.
1066 StringRef lang_str = languageToString(
1068 getModule().addModuleFlag(llvm::Module::Error, "zos_cu_language",
1069 llvm::MDString::get(VMContext, lang_str));
1070
1071 time_t TT = PreprocessorOpts.SourceDateEpoch
1072 ? *PreprocessorOpts.SourceDateEpoch
1073 : std::time(nullptr);
1074 getModule().addModuleFlag(llvm::Module::Max, "zos_translation_time",
1075 static_cast<uint64_t>(TT));
1076
1077 // Multiple modes will be supported here.
1078 getModule().addModuleFlag(llvm::Module::Error, "zos_le_char_mode",
1079 llvm::MDString::get(VMContext, "ascii"));
1080 }
1081
1082 llvm::Triple T = Context.getTargetInfo().getTriple();
1083 if (T.isARM() || T.isThumb()) {
1084 // The minimum width of an enum in bytes
1085 uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4;
1086 getModule().addModuleFlag(llvm::Module::Error, "min_enum_size", EnumWidth);
1087 }
1088
1089 if (T.isRISCV()) {
1090 StringRef ABIStr = Target.getABI();
1091 llvm::LLVMContext &Ctx = TheModule.getContext();
1092 getModule().addModuleFlag(llvm::Module::Error, "target-abi",
1093 llvm::MDString::get(Ctx, ABIStr));
1094
1095 // Add the canonical ISA string as metadata so the backend can set the ELF
1096 // attributes correctly. We use AppendUnique so LTO will keep all of the
1097 // unique ISA strings that were linked together.
1098 const std::vector<std::string> &Features =
1100 auto ParseResult =
1101 llvm::RISCVISAInfo::parseFeatures(T.isRISCV64() ? 64 : 32, Features);
1102 if (!errorToBool(ParseResult.takeError()))
1103 getModule().addModuleFlag(
1104 llvm::Module::AppendUnique, "riscv-isa",
1105 llvm::MDNode::get(
1106 Ctx, llvm::MDString::get(Ctx, (*ParseResult)->toString())));
1107 }
1108
1109 if (CodeGenOpts.SanitizeCfiCrossDso) {
1110 // Indicate that we want cross-DSO control flow integrity checks.
1111 getModule().addModuleFlag(llvm::Module::Override, "Cross-DSO CFI", 1);
1112 }
1113
1114 if (CodeGenOpts.WholeProgramVTables) {
1115 // Indicate whether VFE was enabled for this module, so that the
1116 // vcall_visibility metadata added under whole program vtables is handled
1117 // appropriately in the optimizer.
1118 getModule().addModuleFlag(llvm::Module::Error, "Virtual Function Elim",
1119 CodeGenOpts.VirtualFunctionElimination);
1120 }
1121
1122 if (LangOpts.Sanitize.has(SanitizerKind::CFIICall)) {
1123 getModule().addModuleFlag(llvm::Module::Override,
1124 "CFI Canonical Jump Tables",
1125 CodeGenOpts.SanitizeCfiCanonicalJumpTables);
1126 }
1127
1128 if (LangOpts.Sanitize.has(SanitizerKind::KCFI)) {
1129 getModule().addModuleFlag(llvm::Module::Override, "kcfi", 1);
1130 // KCFI assumes patchable-function-prefix is the same for all indirectly
1131 // called functions. Store the expected offset for code generation.
1132 if (CodeGenOpts.PatchableFunctionEntryOffset)
1133 getModule().addModuleFlag(llvm::Module::Override, "kcfi-offset",
1134 CodeGenOpts.PatchableFunctionEntryOffset);
1135 }
1136
1137 if (CodeGenOpts.CFProtectionReturn &&
1138 Target.checkCFProtectionReturnSupported(getDiags())) {
1139 // Indicate that we want to instrument return control flow protection.
1140 getModule().addModuleFlag(llvm::Module::Min, "cf-protection-return",
1141 1);
1142 }
1143
1144 if (CodeGenOpts.CFProtectionBranch &&
1145 Target.checkCFProtectionBranchSupported(getDiags())) {
1146 // Indicate that we want to instrument branch control flow protection.
1147 getModule().addModuleFlag(llvm::Module::Min, "cf-protection-branch",
1148 1);
1149 }
1150
1151 if (CodeGenOpts.FunctionReturnThunks)
1152 getModule().addModuleFlag(llvm::Module::Override, "function_return_thunk_extern", 1);
1153
1154 if (CodeGenOpts.IndirectBranchCSPrefix)
1155 getModule().addModuleFlag(llvm::Module::Override, "indirect_branch_cs_prefix", 1);
1156
1157 // Add module metadata for return address signing (ignoring
1158 // non-leaf/all) and stack tagging. These are actually turned on by function
1159 // attributes, but we use module metadata to emit build attributes. This is
1160 // needed for LTO, where the function attributes are inside bitcode
1161 // serialised into a global variable by the time build attributes are
1162 // emitted, so we can't access them. LTO objects could be compiled with
1163 // different flags therefore module flags are set to "Min" behavior to achieve
1164 // the same end result of the normal build where e.g BTI is off if any object
1165 // doesn't support it.
1166 if (Context.getTargetInfo().hasFeature("ptrauth") &&
1167 LangOpts.getSignReturnAddressScope() !=
1169 getModule().addModuleFlag(llvm::Module::Override,
1170 "sign-return-address-buildattr", 1);
1171 if (LangOpts.Sanitize.has(SanitizerKind::MemtagStack))
1172 getModule().addModuleFlag(llvm::Module::Override,
1173 "tag-stack-memory-buildattr", 1);
1174
1175 if (T.isARM() || T.isThumb() || T.isAArch64()) {
1176 if (LangOpts.BranchTargetEnforcement)
1177 getModule().addModuleFlag(llvm::Module::Min, "branch-target-enforcement",
1178 1);
1179 if (LangOpts.BranchProtectionPAuthLR)
1180 getModule().addModuleFlag(llvm::Module::Min, "branch-protection-pauth-lr",
1181 1);
1182 if (LangOpts.GuardedControlStack)
1183 getModule().addModuleFlag(llvm::Module::Min, "guarded-control-stack", 1);
1184 if (LangOpts.hasSignReturnAddress())
1185 getModule().addModuleFlag(llvm::Module::Min, "sign-return-address", 1);
1186 if (LangOpts.isSignReturnAddressScopeAll())
1187 getModule().addModuleFlag(llvm::Module::Min, "sign-return-address-all",
1188 1);
1189 if (!LangOpts.isSignReturnAddressWithAKey())
1190 getModule().addModuleFlag(llvm::Module::Min,
1191 "sign-return-address-with-bkey", 1);
1192 }
1193
1194 if (CodeGenOpts.StackClashProtector)
1195 getModule().addModuleFlag(
1196 llvm::Module::Override, "probe-stack",
1197 llvm::MDString::get(TheModule.getContext(), "inline-asm"));
1198
1199 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
1200 getModule().addModuleFlag(llvm::Module::Min, "stack-probe-size",
1201 CodeGenOpts.StackProbeSize);
1202
1203 if (!CodeGenOpts.MemoryProfileOutput.empty()) {
1204 llvm::LLVMContext &Ctx = TheModule.getContext();
1205 getModule().addModuleFlag(
1206 llvm::Module::Error, "MemProfProfileFilename",
1207 llvm::MDString::get(Ctx, CodeGenOpts.MemoryProfileOutput));
1208 }
1209
1210 if (LangOpts.CUDAIsDevice && getTriple().isNVPTX()) {
1211 // Indicate whether __nvvm_reflect should be configured to flush denormal
1212 // floating point values to 0. (This corresponds to its "__CUDA_FTZ"
1213 // property.)
1214 getModule().addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz",
1215 CodeGenOpts.FP32DenormalMode.Output !=
1216 llvm::DenormalMode::IEEE);
1217 }
1218
1219 if (LangOpts.EHAsynch)
1220 getModule().addModuleFlag(llvm::Module::Warning, "eh-asynch", 1);
1221
1222 // Indicate whether this Module was compiled with -fopenmp
1223 if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd)
1224 getModule().addModuleFlag(llvm::Module::Max, "openmp", LangOpts.OpenMP);
1225 if (getLangOpts().OpenMPIsTargetDevice)
1226 getModule().addModuleFlag(llvm::Module::Max, "openmp-device",
1227 LangOpts.OpenMP);
1228
1229 // Emit OpenCL specific module metadata: OpenCL/SPIR version.
1230 if (LangOpts.OpenCL || (LangOpts.CUDAIsDevice && getTriple().isSPIRV())) {
1231 EmitOpenCLMetadata();
1232 // Emit SPIR version.
1233 if (getTriple().isSPIR()) {
1234 // SPIR v2.0 s2.12 - The SPIR version used by the module is stored in the
1235 // opencl.spir.version named metadata.
1236 // C++ for OpenCL has a distinct mapping for version compatibility with
1237 // OpenCL.
1238 auto Version = LangOpts.getOpenCLCompatibleVersion();
1239 llvm::Metadata *SPIRVerElts[] = {
1240 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1241 Int32Ty, Version / 100)),
1242 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1243 Int32Ty, (Version / 100 > 1) ? 0 : 2))};
1244 llvm::NamedMDNode *SPIRVerMD =
1245 TheModule.getOrInsertNamedMetadata("opencl.spir.version");
1246 llvm::LLVMContext &Ctx = TheModule.getContext();
1247 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
1248 }
1249 }
1250
1251 // HLSL related end of code gen work items.
1252 if (LangOpts.HLSL)
1254
1255 if (uint32_t PLevel = Context.getLangOpts().PICLevel) {
1256 assert(PLevel < 3 && "Invalid PIC Level");
1257 getModule().setPICLevel(static_cast<llvm::PICLevel::Level>(PLevel));
1258 if (Context.getLangOpts().PIE)
1259 getModule().setPIELevel(static_cast<llvm::PIELevel::Level>(PLevel));
1260 }
1261
1262 if (getCodeGenOpts().CodeModel.size() > 0) {
1263 unsigned CM = llvm::StringSwitch<unsigned>(getCodeGenOpts().CodeModel)
1264 .Case("tiny", llvm::CodeModel::Tiny)
1265 .Case("small", llvm::CodeModel::Small)
1266 .Case("kernel", llvm::CodeModel::Kernel)
1267 .Case("medium", llvm::CodeModel::Medium)
1268 .Case("large", llvm::CodeModel::Large)
1269 .Default(~0u);
1270 if (CM != ~0u) {
1271 llvm::CodeModel::Model codeModel = static_cast<llvm::CodeModel::Model>(CM);
1272 getModule().setCodeModel(codeModel);
1273
1274 if ((CM == llvm::CodeModel::Medium || CM == llvm::CodeModel::Large) &&
1275 Context.getTargetInfo().getTriple().getArch() ==
1276 llvm::Triple::x86_64) {
1277 getModule().setLargeDataThreshold(getCodeGenOpts().LargeDataThreshold);
1278 }
1279 }
1280 }
1281
1282 if (CodeGenOpts.NoPLT)
1283 getModule().setRtLibUseGOT();
1284 if (getTriple().isOSBinFormatELF() &&
1285 CodeGenOpts.DirectAccessExternalData !=
1286 getModule().getDirectAccessExternalData()) {
1287 getModule().setDirectAccessExternalData(
1288 CodeGenOpts.DirectAccessExternalData);
1289 }
1290 if (CodeGenOpts.UnwindTables)
1291 getModule().setUwtable(llvm::UWTableKind(CodeGenOpts.UnwindTables));
1292
1293 switch (CodeGenOpts.getFramePointer()) {
1295 // 0 ("none") is the default.
1296 break;
1298 getModule().setFramePointer(llvm::FramePointerKind::NonLeaf);
1299 break;
1301 getModule().setFramePointer(llvm::FramePointerKind::All);
1302 break;
1303 }
1304
1305 SimplifyPersonality();
1306
1307 if (getCodeGenOpts().EmitDeclMetadata)
1308 EmitDeclMetadata();
1309
1310 if (getCodeGenOpts().CoverageNotesFile.size() ||
1311 getCodeGenOpts().CoverageDataFile.size())
1312 EmitCoverageFile();
1313
1314 if (CGDebugInfo *DI = getModuleDebugInfo())
1315 DI->finalize();
1316
1317 if (getCodeGenOpts().EmitVersionIdentMetadata)
1318 EmitVersionIdentMetadata();
1319
1320 if (!getCodeGenOpts().RecordCommandLine.empty())
1321 EmitCommandLineMetadata();
1322
1323 if (!getCodeGenOpts().StackProtectorGuard.empty())
1324 getModule().setStackProtectorGuard(getCodeGenOpts().StackProtectorGuard);
1325 if (!getCodeGenOpts().StackProtectorGuardReg.empty())
1326 getModule().setStackProtectorGuardReg(
1327 getCodeGenOpts().StackProtectorGuardReg);
1328 if (!getCodeGenOpts().StackProtectorGuardSymbol.empty())
1329 getModule().setStackProtectorGuardSymbol(
1330 getCodeGenOpts().StackProtectorGuardSymbol);
1331 if (getCodeGenOpts().StackProtectorGuardOffset != INT_MAX)
1332 getModule().setStackProtectorGuardOffset(
1333 getCodeGenOpts().StackProtectorGuardOffset);
1334 if (getCodeGenOpts().StackAlignment)
1335 getModule().setOverrideStackAlignment(getCodeGenOpts().StackAlignment);
1336 if (getCodeGenOpts().SkipRaxSetup)
1337 getModule().addModuleFlag(llvm::Module::Override, "SkipRaxSetup", 1);
1338 if (getLangOpts().RegCall4)
1339 getModule().addModuleFlag(llvm::Module::Override, "RegCallv4", 1);
1340
1341 if (getContext().getTargetInfo().getMaxTLSAlign())
1342 getModule().addModuleFlag(llvm::Module::Error, "MaxTLSAlign",
1343 getContext().getTargetInfo().getMaxTLSAlign());
1344
1346
1347 getTargetCodeGenInfo().emitTargetMetadata(*this, MangledDeclNames);
1348
1349 EmitBackendOptionsMetadata(getCodeGenOpts());
1350
1351 // If there is device offloading code embed it in the host now.
1352 EmbedObject(&getModule(), CodeGenOpts, getDiags());
1353
1354 // Set visibility from DLL storage class
1355 // We do this at the end of LLVM IR generation; after any operation
1356 // that might affect the DLL storage class or the visibility, and
1357 // before anything that might act on these.
1359}
1360
1361void CodeGenModule::EmitOpenCLMetadata() {
1362 // SPIR v2.0 s2.13 - The OpenCL version used by the module is stored in the
1363 // opencl.ocl.version named metadata node.
1364 // C++ for OpenCL has a distinct mapping for versions compatibile with OpenCL.
1365 auto Version = LangOpts.getOpenCLCompatibleVersion();
1366 llvm::Metadata *OCLVerElts[] = {
1367 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1368 Int32Ty, Version / 100)),
1369 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1370 Int32Ty, (Version % 100) / 10))};
1371 llvm::NamedMDNode *OCLVerMD =
1372 TheModule.getOrInsertNamedMetadata("opencl.ocl.version");
1373 llvm::LLVMContext &Ctx = TheModule.getContext();
1374 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
1375}
1376
1377void CodeGenModule::EmitBackendOptionsMetadata(
1378 const CodeGenOptions &CodeGenOpts) {
1379 if (getTriple().isRISCV()) {
1380 getModule().addModuleFlag(llvm::Module::Min, "SmallDataLimit",
1381 CodeGenOpts.SmallDataLimit);
1382 }
1383}
1384
1386 // Make sure that this type is translated.
1387 Types.UpdateCompletedType(TD);
1388}
1389
1391 // Make sure that this type is translated.
1392 Types.RefreshTypeCacheForClass(RD);
1393}
1394
1396 if (!TBAA)
1397 return nullptr;
1398 return TBAA->getTypeInfo(QTy);
1399}
1400
1402 if (!TBAA)
1403 return TBAAAccessInfo();
1404 if (getLangOpts().CUDAIsDevice) {
1405 // As CUDA builtin surface/texture types are replaced, skip generating TBAA
1406 // access info.
1407 if (AccessType->isCUDADeviceBuiltinSurfaceType()) {
1408 if (getTargetCodeGenInfo().getCUDADeviceBuiltinSurfaceDeviceType() !=
1409 nullptr)
1410 return TBAAAccessInfo();
1411 } else if (AccessType->isCUDADeviceBuiltinTextureType()) {
1412 if (getTargetCodeGenInfo().getCUDADeviceBuiltinTextureDeviceType() !=
1413 nullptr)
1414 return TBAAAccessInfo();
1415 }
1416 }
1417 return TBAA->getAccessInfo(AccessType);
1418}
1419
1422 if (!TBAA)
1423 return TBAAAccessInfo();
1424 return TBAA->getVTablePtrAccessInfo(VTablePtrType);
1425}
1426
1428 if (!TBAA)
1429 return nullptr;
1430 return TBAA->getTBAAStructInfo(QTy);
1431}
1432
1434 if (!TBAA)
1435 return nullptr;
1436 return TBAA->getBaseTypeInfo(QTy);
1437}
1438
1440 if (!TBAA)
1441 return nullptr;
1442 return TBAA->getAccessTagInfo(Info);
1443}
1444
1447 if (!TBAA)
1448 return TBAAAccessInfo();
1449 return TBAA->mergeTBAAInfoForCast(SourceInfo, TargetInfo);
1450}
1451
1454 TBAAAccessInfo InfoB) {
1455 if (!TBAA)
1456 return TBAAAccessInfo();
1457 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
1458}
1459
1462 TBAAAccessInfo SrcInfo) {
1463 if (!TBAA)
1464 return TBAAAccessInfo();
1465 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
1466}
1467
1469 TBAAAccessInfo TBAAInfo) {
1470 if (llvm::MDNode *Tag = getTBAAAccessTagInfo(TBAAInfo))
1471 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
1472}
1473
1475 llvm::Instruction *I, const CXXRecordDecl *RD) {
1476 I->setMetadata(llvm::LLVMContext::MD_invariant_group,
1477 llvm::MDNode::get(getLLVMContext(), {}));
1478}
1479
1480void CodeGenModule::Error(SourceLocation loc, StringRef message) {
1481 unsigned diagID = getDiags().getCustomDiagID(DiagnosticsEngine::Error, "%0");
1482 getDiags().Report(Context.getFullLoc(loc), diagID) << message;
1483}
1484
1485/// ErrorUnsupported - Print out an error that codegen doesn't support the
1486/// specified stmt yet.
1487void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type) {
1489 "cannot compile this %0 yet");
1490 std::string Msg = Type;
1491 getDiags().Report(Context.getFullLoc(S->getBeginLoc()), DiagID)
1492 << Msg << S->getSourceRange();
1493}
1494
1495/// ErrorUnsupported - Print out an error that codegen doesn't support the
1496/// specified decl yet.
1497void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type) {
1499 "cannot compile this %0 yet");
1500 std::string Msg = Type;
1501 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg;
1502}
1503
1504llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
1505 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
1506}
1507
1508void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV,
1509 const NamedDecl *D) const {
1510 // Internal definitions always have default visibility.
1511 if (GV->hasLocalLinkage()) {
1512 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1513 return;
1514 }
1515 if (!D)
1516 return;
1517
1518 // Set visibility for definitions, and for declarations if requested globally
1519 // or set explicitly.
1521
1522 // OpenMP declare target variables must be visible to the host so they can
1523 // be registered. We require protected visibility unless the variable has
1524 // the DT_nohost modifier and does not need to be registered.
1525 if (Context.getLangOpts().OpenMP &&
1526 Context.getLangOpts().OpenMPIsTargetDevice && isa<VarDecl>(D) &&
1527 D->hasAttr<OMPDeclareTargetDeclAttr>() &&
1528 D->getAttr<OMPDeclareTargetDeclAttr>()->getDevType() !=
1529 OMPDeclareTargetDeclAttr::DT_NoHost &&
1531 GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
1532 return;
1533 }
1534
1535 if (GV->hasDLLExportStorageClass() || GV->hasDLLImportStorageClass()) {
1536 // Reject incompatible dlllstorage and visibility annotations.
1537 if (!LV.isVisibilityExplicit())
1538 return;
1539 if (GV->hasDLLExportStorageClass()) {
1540 if (LV.getVisibility() == HiddenVisibility)
1542 diag::err_hidden_visibility_dllexport);
1543 } else if (LV.getVisibility() != DefaultVisibility) {
1545 diag::err_non_default_visibility_dllimport);
1546 }
1547 return;
1548 }
1549
1550 if (LV.isVisibilityExplicit() || getLangOpts().SetVisibilityForExternDecls ||
1551 !GV->isDeclarationForLinker())
1552 GV->setVisibility(GetLLVMVisibility(LV.getVisibility()));
1553}
1554
1556 llvm::GlobalValue *GV) {
1557 if (GV->hasLocalLinkage())
1558 return true;
1559
1560 if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
1561 return true;
1562
1563 // DLLImport explicitly marks the GV as external.
1564 if (GV->hasDLLImportStorageClass())
1565 return false;
1566
1567 const llvm::Triple &TT = CGM.getTriple();
1568 const auto &CGOpts = CGM.getCodeGenOpts();
1569 if (TT.isWindowsGNUEnvironment()) {
1570 // In MinGW, variables without DLLImport can still be automatically
1571 // imported from a DLL by the linker; don't mark variables that
1572 // potentially could come from another DLL as DSO local.
1573
1574 // With EmulatedTLS, TLS variables can be autoimported from other DLLs
1575 // (and this actually happens in the public interface of libstdc++), so
1576 // such variables can't be marked as DSO local. (Native TLS variables
1577 // can't be dllimported at all, though.)
1578 if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
1579 (!GV->isThreadLocal() || CGM.getCodeGenOpts().EmulatedTLS) &&
1580 CGOpts.AutoImport)
1581 return false;
1582 }
1583
1584 // On COFF, don't mark 'extern_weak' symbols as DSO local. If these symbols
1585 // remain unresolved in the link, they can be resolved to zero, which is
1586 // outside the current DSO.
1587 if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
1588 return false;
1589
1590 // Every other GV is local on COFF.
1591 // Make an exception for windows OS in the triple: Some firmware builds use
1592 // *-win32-macho triples. This (accidentally?) produced windows relocations
1593 // without GOT tables in older clang versions; Keep this behaviour.
1594 // FIXME: even thread local variables?
1595 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
1596 return true;
1597
1598 // Only handle COFF and ELF for now.
1599 if (!TT.isOSBinFormatELF())
1600 return false;
1601
1602 // If this is not an executable, don't assume anything is local.
1603 llvm::Reloc::Model RM = CGOpts.RelocationModel;
1604 const auto &LOpts = CGM.getLangOpts();
1605 if (RM != llvm::Reloc::Static && !LOpts.PIE) {
1606 // On ELF, if -fno-semantic-interposition is specified and the target
1607 // supports local aliases, there will be neither CC1
1608 // -fsemantic-interposition nor -fhalf-no-semantic-interposition. Set
1609 // dso_local on the function if using a local alias is preferable (can avoid
1610 // PLT indirection).
1611 if (!(isa<llvm::Function>(GV) && GV->canBenefitFromLocalAlias()))
1612 return false;
1613 return !(CGM.getLangOpts().SemanticInterposition ||
1614 CGM.getLangOpts().HalfNoSemanticInterposition);
1615 }
1616
1617 // A definition cannot be preempted from an executable.
1618 if (!GV->isDeclarationForLinker())
1619 return true;
1620
1621 // Most PIC code sequences that assume that a symbol is local cannot produce a
1622 // 0 if it turns out the symbol is undefined. While this is ABI and relocation
1623 // depended, it seems worth it to handle it here.
1624 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
1625 return false;
1626
1627 // PowerPC64 prefers TOC indirection to avoid copy relocations.
1628 if (TT.isPPC64())
1629 return false;
1630
1631 if (CGOpts.DirectAccessExternalData) {
1632 // If -fdirect-access-external-data (default for -fno-pic), set dso_local
1633 // for non-thread-local variables. If the symbol is not defined in the
1634 // executable, a copy relocation will be needed at link time. dso_local is
1635 // excluded for thread-local variables because they generally don't support
1636 // copy relocations.
1637 if (auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
1638 if (!Var->isThreadLocal())
1639 return true;
1640
1641 // -fno-pic sets dso_local on a function declaration to allow direct
1642 // accesses when taking its address (similar to a data symbol). If the
1643 // function is not defined in the executable, a canonical PLT entry will be
1644 // needed at link time. -fno-direct-access-external-data can avoid the
1645 // canonical PLT entry. We don't generalize this condition to -fpie/-fpic as
1646 // it could just cause trouble without providing perceptible benefits.
1647 if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
1648 return true;
1649 }
1650
1651 // If we can use copy relocations we can assume it is local.
1652
1653 // Otherwise don't assume it is local.
1654 return false;
1655}
1656
1657void CodeGenModule::setDSOLocal(llvm::GlobalValue *GV) const {
1658 GV->setDSOLocal(shouldAssumeDSOLocal(*this, GV));
1659}
1660
1661void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV,
1662 GlobalDecl GD) const {
1663 const auto *D = dyn_cast<NamedDecl>(GD.getDecl());
1664 // C++ destructors have a few C++ ABI specific special cases.
1665 if (const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) {
1667 return;
1668 }
1669 setDLLImportDLLExport(GV, D);
1670}
1671
1672void CodeGenModule::setDLLImportDLLExport(llvm::GlobalValue *GV,
1673 const NamedDecl *D) const {
1674 if (D && D->isExternallyVisible()) {
1675 if (D->hasAttr<DLLImportAttr>())
1676 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
1677 else if ((D->hasAttr<DLLExportAttr>() ||
1679 !GV->isDeclarationForLinker())
1680 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
1681 }
1682}
1683
1684void CodeGenModule::setGVProperties(llvm::GlobalValue *GV,
1685 GlobalDecl GD) const {
1686 setDLLImportDLLExport(GV, GD);
1687 setGVPropertiesAux(GV, dyn_cast<NamedDecl>(GD.getDecl()));
1688}
1689
1690void CodeGenModule::setGVProperties(llvm::GlobalValue *GV,
1691 const NamedDecl *D) const {
1692 setDLLImportDLLExport(GV, D);
1693 setGVPropertiesAux(GV, D);
1694}
1695
1696void CodeGenModule::setGVPropertiesAux(llvm::GlobalValue *GV,
1697 const NamedDecl *D) const {
1698 setGlobalVisibility(GV, D);
1699 setDSOLocal(GV);
1700 GV->setPartition(CodeGenOpts.SymbolPartition);
1701}
1702
1703static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S) {
1704 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
1705 .Case("global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
1706 .Case("local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
1707 .Case("initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
1708 .Case("local-exec", llvm::GlobalVariable::LocalExecTLSModel);
1709}
1710
1711llvm::GlobalVariable::ThreadLocalMode
1713 switch (CodeGenOpts.getDefaultTLSModel()) {
1715 return llvm::GlobalVariable::GeneralDynamicTLSModel;
1717 return llvm::GlobalVariable::LocalDynamicTLSModel;
1719 return llvm::GlobalVariable::InitialExecTLSModel;
1721 return llvm::GlobalVariable::LocalExecTLSModel;
1722 }
1723 llvm_unreachable("Invalid TLS model!");
1724}
1725
1726void CodeGenModule::setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const {
1727 assert(D.getTLSKind() && "setting TLS mode on non-TLS var!");
1728
1729 llvm::GlobalValue::ThreadLocalMode TLM;
1730 TLM = GetDefaultLLVMTLSModel();
1731
1732 // Override the TLS model if it is explicitly specified.
1733 if (const TLSModelAttr *Attr = D.getAttr<TLSModelAttr>()) {
1734 TLM = GetLLVMTLSModel(Attr->getModel());
1735 }
1736
1737 GV->setThreadLocalMode(TLM);
1738}
1739
1740static std::string getCPUSpecificMangling(const CodeGenModule &CGM,
1741 StringRef Name) {
1742 const TargetInfo &Target = CGM.getTarget();
1743 return (Twine('.') + Twine(Target.CPUSpecificManglingCharacter(Name))).str();
1744}
1745
1747 const CPUSpecificAttr *Attr,
1748 unsigned CPUIndex,
1749 raw_ostream &Out) {
1750 // cpu_specific gets the current name, dispatch gets the resolver if IFunc is
1751 // supported.
1752 if (Attr)
1753 Out << getCPUSpecificMangling(CGM, Attr->getCPUName(CPUIndex)->getName());
1754 else if (CGM.getTarget().supportsIFunc())
1755 Out << ".resolver";
1756}
1757
1758// Returns true if GD is a function decl with internal linkage and
1759// needs a unique suffix after the mangled name.
1761 CodeGenModule &CGM) {
1762 const Decl *D = GD.getDecl();
1763 return !CGM.getModuleNameHash().empty() && isa<FunctionDecl>(D) &&
1764 (CGM.getFunctionLinkage(GD) == llvm::GlobalValue::InternalLinkage);
1765}
1766
1767static std::string getMangledNameImpl(CodeGenModule &CGM, GlobalDecl GD,
1768 const NamedDecl *ND,
1769 bool OmitMultiVersionMangling = false) {
1770 SmallString<256> Buffer;
1771 llvm::raw_svector_ostream Out(Buffer);
1773 if (!CGM.getModuleNameHash().empty())
1775 bool ShouldMangle = MC.shouldMangleDeclName(ND);
1776 if (ShouldMangle)
1777 MC.mangleName(GD.getWithDecl(ND), Out);
1778 else {
1779 IdentifierInfo *II = ND->getIdentifier();
1780 assert(II && "Attempt to mangle unnamed decl.");
1781 const auto *FD = dyn_cast<FunctionDecl>(ND);
1782
1783 if (FD &&
1784 FD->getType()->castAs<FunctionType>()->getCallConv() == CC_X86RegCall) {
1785 if (CGM.getLangOpts().RegCall4)
1786 Out << "__regcall4__" << II->getName();
1787 else
1788 Out << "__regcall3__" << II->getName();
1789 } else if (FD && FD->hasAttr<CUDAGlobalAttr>() &&
1791 Out << "__device_stub__" << II->getName();
1792 } else {
1793 Out << II->getName();
1794 }
1795 }
1796
1797 // Check if the module name hash should be appended for internal linkage
1798 // symbols. This should come before multi-version target suffixes are
1799 // appended. This is to keep the name and module hash suffix of the
1800 // internal linkage function together. The unique suffix should only be
1801 // added when name mangling is done to make sure that the final name can
1802 // be properly demangled. For example, for C functions without prototypes,
1803 // name mangling is not done and the unique suffix should not be appeneded
1804 // then.
1805 if (ShouldMangle && isUniqueInternalLinkageDecl(GD, CGM)) {
1806 assert(CGM.getCodeGenOpts().UniqueInternalLinkageNames &&
1807 "Hash computed when not explicitly requested");
1808 Out << CGM.getModuleNameHash();
1809 }
1810
1811 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
1812 if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
1813 switch (FD->getMultiVersionKind()) {
1817 FD->getAttr<CPUSpecificAttr>(),
1818 GD.getMultiVersionIndex(), Out);
1819 break;
1821 auto *Attr = FD->getAttr<TargetAttr>();
1822 const ABIInfo &Info = CGM.getTargetCodeGenInfo().getABIInfo();
1823 Info.appendAttributeMangling(Attr, Out);
1824 break;
1825 }
1827 auto *Attr = FD->getAttr<TargetVersionAttr>();
1828 const ABIInfo &Info = CGM.getTargetCodeGenInfo().getABIInfo();
1829 Info.appendAttributeMangling(Attr, Out);
1830 break;
1831 }
1833 auto *Attr = FD->getAttr<TargetClonesAttr>();
1834 unsigned Index = GD.getMultiVersionIndex();
1835 const ABIInfo &Info = CGM.getTargetCodeGenInfo().getABIInfo();
1836 Info.appendAttributeMangling(Attr, Index, Out);
1837 break;
1838 }
1840 llvm_unreachable("None multiversion type isn't valid here");
1841 }
1842 }
1843
1844 // Make unique name for device side static file-scope variable for HIP.
1845 if (CGM.getContext().shouldExternalize(ND) &&
1846 CGM.getLangOpts().GPURelocatableDeviceCode &&
1847 CGM.getLangOpts().CUDAIsDevice)
1849
1850 return std::string(Out.str());
1851}
1852
1853void CodeGenModule::UpdateMultiVersionNames(GlobalDecl GD,
1854 const FunctionDecl *FD,
1855 StringRef &CurName) {
1856 if (!FD->isMultiVersion())
1857 return;
1858
1859 // Get the name of what this would be without the 'target' attribute. This
1860 // allows us to lookup the version that was emitted when this wasn't a
1861 // multiversion function.
1862 std::string NonTargetName =
1863 getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true);
1864 GlobalDecl OtherGD;
1865 if (lookupRepresentativeDecl(NonTargetName, OtherGD)) {
1866 assert(OtherGD.getCanonicalDecl()
1867 .getDecl()
1868 ->getAsFunction()
1869 ->isMultiVersion() &&
1870 "Other GD should now be a multiversioned function");
1871 // OtherFD is the version of this function that was mangled BEFORE
1872 // becoming a MultiVersion function. It potentially needs to be updated.
1873 const FunctionDecl *OtherFD = OtherGD.getCanonicalDecl()
1874 .getDecl()
1875 ->getAsFunction()
1877 std::string OtherName = getMangledNameImpl(*this, OtherGD, OtherFD);
1878 // This is so that if the initial version was already the 'default'
1879 // version, we don't try to update it.
1880 if (OtherName != NonTargetName) {
1881 // Remove instead of erase, since others may have stored the StringRef
1882 // to this.
1883 const auto ExistingRecord = Manglings.find(NonTargetName);
1884 if (ExistingRecord != std::end(Manglings))
1885 Manglings.remove(&(*ExistingRecord));
1886 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
1887 StringRef OtherNameRef = MangledDeclNames[OtherGD.getCanonicalDecl()] =
1888 Result.first->first();
1889 // If this is the current decl is being created, make sure we update the name.
1890 if (GD.getCanonicalDecl() == OtherGD.getCanonicalDecl())
1891 CurName = OtherNameRef;
1892 if (llvm::GlobalValue *Entry = GetGlobalValue(NonTargetName))
1893 Entry->setName(OtherName);
1894 }
1895 }
1896}
1897
1899 GlobalDecl CanonicalGD = GD.getCanonicalDecl();
1900
1901 // Some ABIs don't have constructor variants. Make sure that base and
1902 // complete constructors get mangled the same.
1903 if (const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.getDecl())) {
1904 if (!getTarget().getCXXABI().hasConstructorVariants()) {
1905 CXXCtorType OrigCtorType = GD.getCtorType();
1906 assert(OrigCtorType == Ctor_Base || OrigCtorType == Ctor_Complete);
1907 if (OrigCtorType == Ctor_Base)
1908 CanonicalGD = GlobalDecl(CD, Ctor_Complete);
1909 }
1910 }
1911
1912 // In CUDA/HIP device compilation with -fgpu-rdc, the mangled name of a
1913 // static device variable depends on whether the variable is referenced by
1914 // a host or device host function. Therefore the mangled name cannot be
1915 // cached.
1916 if (!LangOpts.CUDAIsDevice || !getContext().mayExternalize(GD.getDecl())) {
1917 auto FoundName = MangledDeclNames.find(CanonicalGD);
1918 if (FoundName != MangledDeclNames.end())
1919 return FoundName->second;
1920 }
1921
1922 // Keep the first result in the case of a mangling collision.
1923 const auto *ND = cast<NamedDecl>(GD.getDecl());
1924 std::string MangledName = getMangledNameImpl(*this, GD, ND);
1925
1926 // Ensure either we have different ABIs between host and device compilations,
1927 // says host compilation following MSVC ABI but device compilation follows
1928 // Itanium C++ ABI or, if they follow the same ABI, kernel names after
1929 // mangling should be the same after name stubbing. The later checking is
1930 // very important as the device kernel name being mangled in host-compilation
1931 // is used to resolve the device binaries to be executed. Inconsistent naming
1932 // result in undefined behavior. Even though we cannot check that naming
1933 // directly between host- and device-compilations, the host- and
1934 // device-mangling in host compilation could help catching certain ones.
1935 assert(!isa<FunctionDecl>(ND) || !ND->hasAttr<CUDAGlobalAttr>() ||
1936 getContext().shouldExternalize(ND) || getLangOpts().CUDAIsDevice ||
1937 (getContext().getAuxTargetInfo() &&
1938 (getContext().getAuxTargetInfo()->getCXXABI() !=
1939 getContext().getTargetInfo().getCXXABI())) ||
1940 getCUDARuntime().getDeviceSideName(ND) ==
1942 *this,
1944 ND));
1945
1946 auto Result = Manglings.insert(std::make_pair(MangledName, GD));
1947 return MangledDeclNames[CanonicalGD] = Result.first->first();
1948}
1949
1951 const BlockDecl *BD) {
1952 MangleContext &MangleCtx = getCXXABI().getMangleContext();
1953 const Decl *D = GD.getDecl();
1954
1955 SmallString<256> Buffer;
1956 llvm::raw_svector_ostream Out(Buffer);
1957 if (!D)
1958 MangleCtx.mangleGlobalBlock(BD,
1959 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
1960 else if (const auto *CD = dyn_cast<CXXConstructorDecl>(D))
1961 MangleCtx.mangleCtorBlock(CD, GD.getCtorType(), BD, Out);
1962 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(D))
1963 MangleCtx.mangleDtorBlock(DD, GD.getDtorType(), BD, Out);
1964 else
1965 MangleCtx.mangleBlock(cast<DeclContext>(D), BD, Out);
1966
1967 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
1968 return Result.first->first();
1969}
1970
1972 auto it = MangledDeclNames.begin();
1973 while (it != MangledDeclNames.end()) {
1974 if (it->second == Name)
1975 return it->first;
1976 it++;
1977 }
1978 return GlobalDecl();
1979}
1980
1981llvm::GlobalValue *CodeGenModule::GetGlobalValue(StringRef Name) {
1982 return getModule().getNamedValue(Name);
1983}
1984
1985/// AddGlobalCtor - Add a function to the list that will be called before
1986/// main() runs.
1987void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority,
1988 unsigned LexOrder,
1989 llvm::Constant *AssociatedData) {
1990 // FIXME: Type coercion of void()* types.
1991 GlobalCtors.push_back(Structor(Priority, LexOrder, Ctor, AssociatedData));
1992}
1993
1994/// AddGlobalDtor - Add a function to the list that will be called
1995/// when the module is unloaded.
1996void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority,
1997 bool IsDtorAttrFunc) {
1998 if (CodeGenOpts.RegisterGlobalDtorsWithAtExit &&
1999 (!getContext().getTargetInfo().getTriple().isOSAIX() || IsDtorAttrFunc)) {
2000 DtorsUsingAtExit[Priority].push_back(Dtor);
2001 return;
2002 }
2003
2004 // FIXME: Type coercion of void()* types.
2005 GlobalDtors.push_back(Structor(Priority, ~0U, Dtor, nullptr));
2006}
2007
2008void CodeGenModule::EmitCtorList(CtorList &Fns, const char *GlobalName) {
2009 if (Fns.empty()) return;
2010
2011 // Ctor function type is void()*.
2012 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
2013 llvm::Type *CtorPFTy = llvm::PointerType::get(CtorFTy,
2014 TheModule.getDataLayout().getProgramAddressSpace());
2015
2016 // Get the type of a ctor entry, { i32, void ()*, i8* }.
2017 llvm::StructType *CtorStructTy = llvm::StructType::get(
2018 Int32Ty, CtorPFTy, VoidPtrTy);
2019
2020 // Construct the constructor and destructor arrays.
2021 ConstantInitBuilder builder(*this);
2022 auto ctors = builder.beginArray(CtorStructTy);
2023 for (const auto &I : Fns) {
2024 auto ctor = ctors.beginStruct(CtorStructTy);
2025 ctor.addInt(Int32Ty, I.Priority);
2026 ctor.add(I.Initializer);
2027 if (I.AssociatedData)
2028 ctor.add(I.AssociatedData);
2029 else
2030 ctor.addNullPointer(VoidPtrTy);
2031 ctor.finishAndAddTo(ctors);
2032 }
2033
2034 auto list =
2035 ctors.finishAndCreateGlobal(GlobalName, getPointerAlign(),
2036 /*constant*/ false,
2037 llvm::GlobalValue::AppendingLinkage);
2038
2039 // The LTO linker doesn't seem to like it when we set an alignment
2040 // on appending variables. Take it off as a workaround.
2041 list->setAlignment(std::nullopt);
2042
2043 Fns.clear();
2044}
2045
2046llvm::GlobalValue::LinkageTypes
2048 const auto *D = cast<FunctionDecl>(GD.getDecl());
2049
2051
2052 if (const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
2054
2056}
2057
2058llvm::ConstantInt *CodeGenModule::CreateCrossDsoCfiTypeId(llvm::Metadata *MD) {
2059 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
2060 if (!MDS) return nullptr;
2061
2062 return llvm::ConstantInt::get(Int64Ty, llvm::MD5Hash(MDS->getString()));
2063}
2064
2066 if (auto *FnType = T->getAs<FunctionProtoType>())
2068 FnType->getReturnType(), FnType->getParamTypes(),
2069 FnType->getExtProtoInfo().withExceptionSpec(EST_None));
2070
2071 std::string OutName;
2072 llvm::raw_string_ostream Out(OutName);
2074 T, Out, getCodeGenOpts().SanitizeCfiICallNormalizeIntegers);
2075
2076 if (getCodeGenOpts().SanitizeCfiICallNormalizeIntegers)
2077 Out << ".normalized";
2078
2079 return llvm::ConstantInt::get(Int32Ty,
2080 static_cast<uint32_t>(llvm::xxHash64(OutName)));
2081}
2082
2084 const CGFunctionInfo &Info,
2085 llvm::Function *F, bool IsThunk) {
2086 unsigned CallingConv;
2087 llvm::AttributeList PAL;
2088 ConstructAttributeList(F->getName(), Info, GD, PAL, CallingConv,
2089 /*AttrOnCallSite=*/false, IsThunk);
2090 if (CallingConv == llvm::CallingConv::X86_VectorCall &&
2091 getTarget().getTriple().isWindowsArm64EC()) {
2092 SourceLocation Loc;
2093 if (const Decl *D = GD.getDecl())
2094 Loc = D->getLocation();
2095
2096 Error(Loc, "__vectorcall calling convention is not currently supported");
2097 }
2098 F->setAttributes(PAL);
2099 F->setCallingConv(static_cast<llvm::CallingConv::ID>(CallingConv));
2100}
2101
2102static void removeImageAccessQualifier(std::string& TyName) {
2103 std::string ReadOnlyQual("__read_only");
2104 std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
2105 if (ReadOnlyPos != std::string::npos)
2106 // "+ 1" for the space after access qualifier.
2107 TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);
2108 else {
2109 std::string WriteOnlyQual("__write_only");
2110 std::string::size_type WriteOnlyPos = TyName.find(WriteOnlyQual);
2111 if (WriteOnlyPos != std::string::npos)
2112 TyName.erase(WriteOnlyPos, WriteOnlyQual.size() + 1);
2113 else {
2114 std::string ReadWriteQual("__read_write");
2115 std::string::size_type ReadWritePos = TyName.find(ReadWriteQual);
2116 if (ReadWritePos != std::string::npos)
2117 TyName.erase(ReadWritePos, ReadWriteQual.size() + 1);
2118 }
2119 }
2120}
2121
2122// Returns the address space id that should be produced to the
2123// kernel_arg_addr_space metadata. This is always fixed to the ids
2124// as specified in the SPIR 2.0 specification in order to differentiate
2125// for example in clGetKernelArgInfo() implementation between the address
2126// spaces with targets without unique mapping to the OpenCL address spaces
2127// (basically all single AS CPUs).
2128static unsigned ArgInfoAddressSpace(LangAS AS) {
2129 switch (AS) {
2131 return 1;
2133 return 2;
2135 return 3;
2137 return 4; // Not in SPIR 2.0 specs.
2139 return 5;
2141 return 6;
2142 default:
2143 return 0; // Assume private.
2144 }
2145}
2146
2148 const FunctionDecl *FD,
2149 CodeGenFunction *CGF) {
2150 assert(((FD && CGF) || (!FD && !CGF)) &&
2151 "Incorrect use - FD and CGF should either be both null or not!");
2152 // Create MDNodes that represent the kernel arg metadata.
2153 // Each MDNode is a list in the form of "key", N number of values which is
2154 // the same number of values as their are kernel arguments.
2155
2156 const PrintingPolicy &Policy = Context.getPrintingPolicy();
2157
2158 // MDNode for the kernel argument address space qualifiers.
2160
2161 // MDNode for the kernel argument access qualifiers (images only).
2163
2164 // MDNode for the kernel argument type names.
2166
2167 // MDNode for the kernel argument base type names.
2168 SmallVector<llvm::Metadata *, 8> argBaseTypeNames;
2169
2170 // MDNode for the kernel argument type qualifiers.
2172
2173 // MDNode for the kernel argument names.
2175
2176 if (FD && CGF)
2177 for (unsigned i = 0, e = FD->getNumParams(); i != e; ++i) {
2178 const ParmVarDecl *parm = FD->getParamDecl(i);
2179 // Get argument name.
2180 argNames.push_back(llvm::MDString::get(VMContext, parm->getName()));
2181
2182 if (!getLangOpts().OpenCL)
2183 continue;
2184 QualType ty = parm->getType();
2185 std::string typeQuals;
2186
2187 // Get image and pipe access qualifier:
2188 if (ty->isImageType() || ty->isPipeType()) {
2189 const Decl *PDecl = parm;
2190 if (const auto *TD = ty->getAs<TypedefType>())
2191 PDecl = TD->getDecl();
2192 const OpenCLAccessAttr *A = PDecl->getAttr<OpenCLAccessAttr>();
2193 if (A && A->isWriteOnly())
2194 accessQuals.push_back(llvm::MDString::get(VMContext, "write_only"));
2195 else if (A && A->isReadWrite())
2196 accessQuals.push_back(llvm::MDString::get(VMContext, "read_write"));
2197 else
2198 accessQuals.push_back(llvm::MDString::get(VMContext, "read_only"));
2199 } else
2200 accessQuals.push_back(llvm::MDString::get(VMContext, "none"));
2201
2202 auto getTypeSpelling = [&](QualType Ty) {
2203 auto typeName = Ty.getUnqualifiedType().getAsString(Policy);
2204
2205 if (Ty.isCanonical()) {
2206 StringRef typeNameRef = typeName;
2207 // Turn "unsigned type" to "utype"
2208 if (typeNameRef.consume_front("unsigned "))
2209 return std::string("u") + typeNameRef.str();
2210 if (typeNameRef.consume_front("signed "))
2211 return typeNameRef.str();
2212 }
2213
2214 return typeName;
2215 };
2216
2217 if (ty->isPointerType()) {
2218 QualType pointeeTy = ty->getPointeeType();
2219
2220 // Get address qualifier.
2221 addressQuals.push_back(
2222 llvm::ConstantAsMetadata::get(CGF->Builder.getInt32(
2223 ArgInfoAddressSpace(pointeeTy.getAddressSpace()))));
2224
2225 // Get argument type name.
2226 std::string typeName = getTypeSpelling(pointeeTy) + "*";
2227 std::string baseTypeName =
2228 getTypeSpelling(pointeeTy.getCanonicalType()) + "*";
2229 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2230 argBaseTypeNames.push_back(
2231 llvm::MDString::get(VMContext, baseTypeName));
2232
2233 // Get argument type qualifiers:
2234 if (ty.isRestrictQualified())
2235 typeQuals = "restrict";
2236 if (pointeeTy.isConstQualified() ||
2238 typeQuals += typeQuals.empty() ? "const" : " const";
2239 if (pointeeTy.isVolatileQualified())
2240 typeQuals += typeQuals.empty() ? "volatile" : " volatile";
2241 } else {
2242 uint32_t AddrSpc = 0;
2243 bool isPipe = ty->isPipeType();
2244 if (ty->isImageType() || isPipe)
2246
2247 addressQuals.push_back(
2248 llvm::ConstantAsMetadata::get(CGF->Builder.getInt32(AddrSpc)));
2249
2250 // Get argument type name.
2251 ty = isPipe ? ty->castAs<PipeType>()->getElementType() : ty;
2252 std::string typeName = getTypeSpelling(ty);
2253 std::string baseTypeName = getTypeSpelling(ty.getCanonicalType());
2254
2255 // Remove access qualifiers on images
2256 // (as they are inseparable from type in clang implementation,
2257 // but OpenCL spec provides a special query to get access qualifier
2258 // via clGetKernelArgInfo with CL_KERNEL_ARG_ACCESS_QUALIFIER):
2259 if (ty->isImageType()) {
2261 removeImageAccessQualifier(baseTypeName);
2262 }
2263
2264 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2265 argBaseTypeNames.push_back(
2266 llvm::MDString::get(VMContext, baseTypeName));
2267
2268 if (isPipe)
2269 typeQuals = "pipe";
2270 }
2271 argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));
2272 }
2273
2274 if (getLangOpts().OpenCL) {
2275 Fn->setMetadata("kernel_arg_addr_space",
2276 llvm::MDNode::get(VMContext, addressQuals));
2277 Fn->setMetadata("kernel_arg_access_qual",
2278 llvm::MDNode::get(VMContext, accessQuals));
2279 Fn->setMetadata("kernel_arg_type",
2280 llvm::MDNode::get(VMContext, argTypeNames));
2281 Fn->setMetadata("kernel_arg_base_type",
2282 llvm::MDNode::get(VMContext, argBaseTypeNames));
2283 Fn->setMetadata("kernel_arg_type_qual",
2284 llvm::MDNode::get(VMContext, argTypeQuals));
2285 }
2286 if (getCodeGenOpts().EmitOpenCLArgMetadata ||
2287 getCodeGenOpts().HIPSaveKernelArgName)
2288 Fn->setMetadata("kernel_arg_name",
2289 llvm::MDNode::get(VMContext, argNames));
2290}
2291
2292/// Determines whether the language options require us to model
2293/// unwind exceptions. We treat -fexceptions as mandating this
2294/// except under the fragile ObjC ABI with only ObjC exceptions
2295/// enabled. This means, for example, that C with -fexceptions
2296/// enables this.
2297static bool hasUnwindExceptions(const LangOptions &LangOpts) {
2298 // If exceptions are completely disabled, obviously this is false.
2299 if (!LangOpts.Exceptions) return false;
2300
2301 // If C++ exceptions are enabled, this is true.
2302 if (LangOpts.CXXExceptions) return true;
2303
2304 // If ObjC exceptions are enabled, this depends on the ABI.
2305 if (LangOpts.ObjCExceptions) {
2306 return LangOpts.ObjCRuntime.hasUnwindExceptions();
2307 }
2308
2309 return true;
2310}
2311
2313 const CXXMethodDecl *MD) {
2314 // Check that the type metadata can ever actually be used by a call.
2315 if (!CGM.getCodeGenOpts().LTOUnit ||
2317 return false;
2318
2319 // Only functions whose address can be taken with a member function pointer
2320 // need this sort of type metadata.
2321 return MD->isImplicitObjectMemberFunction() && !MD->isVirtual() &&
2322 !isa<CXXConstructorDecl, CXXDestructorDecl>(MD);
2323}
2324
2327 llvm::SetVector<const CXXRecordDecl *> MostBases;
2328
2329 std::function<void (const CXXRecordDecl *)> CollectMostBases;
2330 CollectMostBases = [&](const CXXRecordDecl *RD) {
2331 if (RD->getNumBases() == 0)
2332 MostBases.insert(RD);
2333 for (const CXXBaseSpecifier &B : RD->bases())
2334 CollectMostBases(B.getType()->getAsCXXRecordDecl());
2335 };
2336 CollectMostBases(RD);
2337 return MostBases.takeVector();
2338}
2339
2341 llvm::Function *F) {
2342 llvm::AttrBuilder B(F->getContext());
2343
2344 if ((!D || !D->hasAttr<NoUwtableAttr>()) && CodeGenOpts.UnwindTables)
2345 B.addUWTableAttr(llvm::UWTableKind(CodeGenOpts.UnwindTables));
2346
2347 if (CodeGenOpts.StackClashProtector)
2348 B.addAttribute("probe-stack", "inline-asm");
2349
2350 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
2351 B.addAttribute("stack-probe-size",
2352 std::to_string(CodeGenOpts.StackProbeSize));
2353
2354 if (!hasUnwindExceptions(LangOpts))
2355 B.addAttribute(llvm::Attribute::NoUnwind);
2356
2357 if (D && D->hasAttr<NoStackProtectorAttr>())
2358 ; // Do nothing.
2359 else if (D && D->hasAttr<StrictGuardStackCheckAttr>() &&
2361 B.addAttribute(llvm::Attribute::StackProtectStrong);
2362 else if (isStackProtectorOn(LangOpts, getTriple(), LangOptions::SSPOn))
2363 B.addAttribute(llvm::Attribute::StackProtect);
2365 B.addAttribute(llvm::Attribute::StackProtectStrong);
2366 else if (isStackProtectorOn(LangOpts, getTriple(), LangOptions::SSPReq))
2367 B.addAttribute(llvm::Attribute::StackProtectReq);
2368
2369 if (!D) {
2370 // If we don't have a declaration to control inlining, the function isn't
2371 // explicitly marked as alwaysinline for semantic reasons, and inlining is
2372 // disabled, mark the function as noinline.
2373 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
2374 CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining)
2375 B.addAttribute(llvm::Attribute::NoInline);
2376
2377 F->addFnAttrs(B);
2378 return;
2379 }
2380
2381 // Handle SME attributes that apply to function definitions,
2382 // rather than to function prototypes.
2383 if (D->hasAttr<ArmLocallyStreamingAttr>())
2384 B.addAttribute("aarch64_pstate_sm_body");
2385
2386 if (auto *Attr = D->getAttr<ArmNewAttr>()) {
2387 if (Attr->isNewZA())
2388 B.addAttribute("aarch64_new_za");
2389 if (Attr->isNewZT0())
2390 B.addAttribute("aarch64_new_zt0");
2391 }
2392
2393 // Track whether we need to add the optnone LLVM attribute,
2394 // starting with the default for this optimization level.
2395 bool ShouldAddOptNone =
2396 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
2397 // We can't add optnone in the following cases, it won't pass the verifier.
2398 ShouldAddOptNone &= !D->hasAttr<MinSizeAttr>();
2399 ShouldAddOptNone &= !D->hasAttr<AlwaysInlineAttr>();
2400
2401 // Add optnone, but do so only if the function isn't always_inline.
2402 if ((ShouldAddOptNone || D->hasAttr<OptimizeNoneAttr>()) &&
2403 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2404 B.addAttribute(llvm::Attribute::OptimizeNone);
2405
2406 // OptimizeNone implies noinline; we should not be inlining such functions.
2407 B.addAttribute(llvm::Attribute::NoInline);
2408
2409 // We still need to handle naked functions even though optnone subsumes
2410 // much of their semantics.
2411 if (D->hasAttr<NakedAttr>())
2412 B.addAttribute(llvm::Attribute::Naked);
2413
2414 // OptimizeNone wins over OptimizeForSize and MinSize.
2415 F->removeFnAttr(llvm::Attribute::OptimizeForSize);
2416 F->removeFnAttr(llvm::Attribute::MinSize);
2417 } else if (D->hasAttr<NakedAttr>()) {
2418 // Naked implies noinline: we should not be inlining such functions.
2419 B.addAttribute(llvm::Attribute::Naked);
2420 B.addAttribute(llvm::Attribute::NoInline);
2421 } else if (D->hasAttr<NoDuplicateAttr>()) {
2422 B.addAttribute(llvm::Attribute::NoDuplicate);
2423 } else if (D->hasAttr<NoInlineAttr>() && !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2424 // Add noinline if the function isn't always_inline.
2425 B.addAttribute(llvm::Attribute::NoInline);
2426 } else if (D->hasAttr<AlwaysInlineAttr>() &&
2427 !F->hasFnAttribute(llvm::Attribute::NoInline)) {
2428 // (noinline wins over always_inline, and we can't specify both in IR)
2429 B.addAttribute(llvm::Attribute::AlwaysInline);
2430 } else if (CodeGenOpts.getInlining() == CodeGenOptions::OnlyAlwaysInlining) {
2431 // If we're not inlining, then force everything that isn't always_inline to
2432 // carry an explicit noinline attribute.
2433 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
2434 B.addAttribute(llvm::Attribute::NoInline);
2435 } else {
2436 // Otherwise, propagate the inline hint attribute and potentially use its
2437 // absence to mark things as noinline.
2438 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
2439 // Search function and template pattern redeclarations for inline.
2440 auto CheckForInline = [](const FunctionDecl *FD) {
2441 auto CheckRedeclForInline = [](const FunctionDecl *Redecl) {
2442 return Redecl->isInlineSpecified();
2443 };
2444 if (any_of(FD->redecls(), CheckRedeclForInline))
2445 return true;
2446 const FunctionDecl *Pattern = FD->getTemplateInstantiationPattern();
2447 if (!Pattern)
2448 return false;
2449 return any_of(Pattern->redecls(), CheckRedeclForInline);
2450 };
2451 if (CheckForInline(FD)) {
2452 B.addAttribute(llvm::Attribute::InlineHint);
2453 } else if (CodeGenOpts.getInlining() ==
2455 !FD->isInlined() &&
2456 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2457 B.addAttribute(llvm::Attribute::NoInline);
2458 }
2459 }
2460 }
2461
2462 // Add other optimization related attributes if we are optimizing this
2463 // function.
2464 if (!D->hasAttr<OptimizeNoneAttr>()) {
2465 if (D->hasAttr<ColdAttr>()) {
2466 if (!ShouldAddOptNone)
2467 B.addAttribute(llvm::Attribute::OptimizeForSize);
2468 B.addAttribute(llvm::Attribute::Cold);
2469 }
2470 if (D->hasAttr<HotAttr>())
2471 B.addAttribute(llvm::Attribute::Hot);
2472 if (D->hasAttr<MinSizeAttr>())
2473 B.addAttribute(llvm::Attribute::MinSize);
2474 }
2475
2476 F->addFnAttrs(B);
2477
2478 unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
2479 if (alignment)
2480 F->setAlignment(llvm::Align(alignment));
2481
2482 if (!D->hasAttr<AlignedAttr>())
2483 if (LangOpts.FunctionAlignment)
2484 F->setAlignment(llvm::Align(1ull << LangOpts.FunctionAlignment));
2485
2486 // Some C++ ABIs require 2-byte alignment for member functions, in order to
2487 // reserve a bit for differentiating between virtual and non-virtual member
2488 // functions. If the current target's C++ ABI requires this and this is a
2489 // member function, set its alignment accordingly.
2490 if (getTarget().getCXXABI().areMemberFunctionsAligned()) {
2491 if (isa<CXXMethodDecl>(D) && F->getPointerAlignment(getDataLayout()) < 2)
2492 F->setAlignment(std::max(llvm::Align(2), F->getAlign().valueOrOne()));
2493 }
2494
2495 // In the cross-dso CFI mode with canonical jump tables, we want !type
2496 // attributes on definitions only.
2497 if (CodeGenOpts.SanitizeCfiCrossDso &&
2498 CodeGenOpts.SanitizeCfiCanonicalJumpTables) {
2499 if (auto *FD = dyn_cast<FunctionDecl>(D)) {
2500 // Skip available_externally functions. They won't be codegen'ed in the
2501 // current module anyway.
2502 if (getContext().GetGVALinkageForFunction(FD) != GVA_AvailableExternally)
2504 }
2505 }
2506
2507 // Emit type metadata on member functions for member function pointer checks.
2508 // These are only ever necessary on definitions; we're guaranteed that the
2509 // definition will be present in the LTO unit as a result of LTO visibility.
2510 auto *MD = dyn_cast<CXXMethodDecl>(D);
2511 if (MD && requiresMemberFunctionPointerTypeMetadata(*this, MD)) {
2512 for (const CXXRecordDecl *Base : getMostBaseClasses(MD->getParent())) {
2513 llvm::Metadata *Id =
2515 MD->getType(), Context.getRecordType(Base).getTypePtr()));
2516 F->addTypeMetadata(0, Id);
2517 }
2518 }
2519}
2520
2521void CodeGenModule::SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV) {
2522 const Decl *D = GD.getDecl();
2523 if (isa_and_nonnull<NamedDecl>(D))
2524 setGVProperties(GV, GD);
2525 else
2526 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
2527
2528 if (D && D->hasAttr<UsedAttr>())
2530
2531 if (const auto *VD = dyn_cast_if_present<VarDecl>(D);
2532 VD &&
2533 ((CodeGenOpts.KeepPersistentStorageVariables &&
2534 (VD->getStorageDuration() == SD_Static ||
2535 VD->getStorageDuration() == SD_Thread)) ||
2536 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() == SD_Static &&
2537 VD->getType().isConstQualified())))
2539}
2540
2541bool CodeGenModule::GetCPUAndFeaturesAttributes(GlobalDecl GD,
2542 llvm::AttrBuilder &Attrs,
2543 bool SetTargetFeatures) {
2544 // Add target-cpu and target-features attributes to functions. If
2545 // we have a decl for the function and it has a target attribute then
2546 // parse that and add it to the feature set.
2547 StringRef TargetCPU = getTarget().getTargetOpts().CPU;
2548 StringRef TuneCPU = getTarget().getTargetOpts().TuneCPU;
2549 std::vector<std::string> Features;
2550 const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.getDecl());
2551 FD = FD ? FD->getMostRecentDecl() : FD;
2552 const auto *TD = FD ? FD->getAttr<TargetAttr>() : nullptr;
2553 const auto *TV = FD ? FD->getAttr<TargetVersionAttr>() : nullptr;
2554 assert((!TD || !TV) && "both target_version and target specified");
2555 const auto *SD = FD ? FD->getAttr<CPUSpecificAttr>() : nullptr;
2556 const auto *TC = FD ? FD->getAttr<TargetClonesAttr>() : nullptr;
2557 bool AddedAttr = false;
2558 if (TD || TV || SD || TC) {
2559 llvm::StringMap<bool> FeatureMap;
2560 getContext().getFunctionFeatureMap(FeatureMap, GD);
2561
2562 // Produce the canonical string for this set of features.
2563 for (const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
2564 Features.push_back((Entry.getValue() ? "+" : "-") + Entry.getKey().str());
2565
2566 // Now add the target-cpu and target-features to the function.
2567 // While we populated the feature map above, we still need to
2568 // get and parse the target attribute so we can get the cpu for
2569 // the function.
2570 if (TD) {
2572 Target.parseTargetAttr(TD->getFeaturesStr());
2573 if (!ParsedAttr.CPU.empty() &&
2574 getTarget().isValidCPUName(ParsedAttr.CPU)) {
2575 TargetCPU = ParsedAttr.CPU;
2576 TuneCPU = ""; // Clear the tune CPU.
2577 }
2578 if (!ParsedAttr.Tune.empty() &&
2579 getTarget().isValidCPUName(ParsedAttr.Tune))
2580 TuneCPU = ParsedAttr.Tune;
2581 }
2582
2583 if (SD) {
2584 // Apply the given CPU name as the 'tune-cpu' so that the optimizer can
2585 // favor this processor.
2586 TuneCPU = SD->getCPUName(GD.getMultiVersionIndex())->getName();
2587 }
2588 } else {
2589 // Otherwise just add the existing target cpu and target features to the
2590 // function.
2591 Features = getTarget().getTargetOpts().Features;
2592 }
2593
2594 if (!TargetCPU.empty()) {
2595 Attrs.addAttribute("target-cpu", TargetCPU);
2596 AddedAttr = true;
2597 }
2598 if (!TuneCPU.empty()) {
2599 Attrs.addAttribute("tune-cpu", TuneCPU);
2600 AddedAttr = true;
2601 }
2602 if (!Features.empty() && SetTargetFeatures) {
2603 llvm::erase_if(Features, [&](const std::string& F) {
2604 return getTarget().isReadOnlyFeature(F.substr(1));
2605 });
2606 llvm::sort(Features);
2607 Attrs.addAttribute("target-features", llvm::join(Features, ","));
2608 AddedAttr = true;
2609 }
2610
2611 return AddedAttr;
2612}
2613
2614void CodeGenModule::setNonAliasAttributes(GlobalDecl GD,
2615 llvm::GlobalObject *GO) {
2616 const Decl *D = GD.getDecl();
2617 SetCommonAttributes(GD, GO);
2618
2619 if (D) {
2620 if (auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
2621 if (D->hasAttr<RetainAttr>())
2622 addUsedGlobal(GV);
2623 if (auto *SA = D->getAttr<PragmaClangBSSSectionAttr>())
2624 GV->addAttribute("bss-section", SA->getName());
2625 if (auto *SA = D->getAttr<PragmaClangDataSectionAttr>())
2626 GV->addAttribute("data-section", SA->getName());
2627 if (auto *SA = D->getAttr<PragmaClangRodataSectionAttr>())
2628 GV->addAttribute("rodata-section", SA->getName());
2629 if (auto *SA = D->getAttr<PragmaClangRelroSectionAttr>())
2630 GV->addAttribute("relro-section", SA->getName());
2631 }
2632
2633 if (auto *F = dyn_cast<llvm::Function>(GO)) {
2634 if (D->hasAttr<RetainAttr>())
2635 addUsedGlobal(F);
2636 if (auto *SA = D->getAttr<PragmaClangTextSectionAttr>())
2637 if (!D->getAttr<SectionAttr>())
2638 F->setSection(SA->getName());
2639
2640 llvm::AttrBuilder Attrs(F->getContext());
2641 if (GetCPUAndFeaturesAttributes(GD, Attrs)) {
2642 // We know that GetCPUAndFeaturesAttributes will always have the
2643 // newest set, since it has the newest possible FunctionDecl, so the
2644 // new ones should replace the old.
2645 llvm::AttributeMask RemoveAttrs;
2646 RemoveAttrs.addAttribute("target-cpu");
2647 RemoveAttrs.addAttribute("target-features");
2648 RemoveAttrs.addAttribute("tune-cpu");
2649 F->removeFnAttrs(RemoveAttrs);
2650 F->addFnAttrs(Attrs);
2651 }
2652 }
2653
2654 if (const auto *CSA = D->getAttr<CodeSegAttr>())
2655 GO->setSection(CSA->getName());
2656 else if (const auto *SA = D->getAttr<SectionAttr>())
2657 GO->setSection(SA->getName());
2658 }
2659
2661}
2662
2664 llvm::Function *F,
2665 const CGFunctionInfo &FI) {
2666 const Decl *D = GD.getDecl();
2667 SetLLVMFunctionAttributes(GD, FI, F, /*IsThunk=*/false);
2669
2670 F->setLinkage(llvm::Function::InternalLinkage);
2671
2672 setNonAliasAttributes(GD, F);
2673}
2674
2675static void setLinkageForGV(llvm::GlobalValue *GV, const NamedDecl *ND) {
2676 // Set linkage and visibility in case we never see a definition.
2678 // Don't set internal linkage on declarations.
2679 // "extern_weak" is overloaded in LLVM; we probably should have
2680 // separate linkage types for this.
2681 if (isExternallyVisible(LV.getLinkage()) &&
2682 (ND->hasAttr<WeakAttr>() || ND->isWeakImported()))
2683 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
2684}
2685
2687 llvm::Function *F) {
2688 // Only if we are checking indirect calls.
2689 if (!LangOpts.Sanitize.has(SanitizerKind::CFIICall))
2690 return;
2691
2692 // Non-static class methods are handled via vtable or member function pointer
2693 // checks elsewhere.
2694 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
2695 return;
2696
2697 llvm::Metadata *MD = CreateMetadataIdentifierForType(FD->getType());
2698 F->addTypeMetadata(0, MD);
2699 F->addTypeMetadata(0, CreateMetadataIdentifierGeneralized(FD->getType()));
2700
2701 // Emit a hash-based bit set entry for cross-DSO calls.
2702 if (CodeGenOpts.SanitizeCfiCrossDso)
2703 if (auto CrossDsoTypeId = CreateCrossDsoCfiTypeId(MD))
2704 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
2705}
2706
2707void CodeGenModule::setKCFIType(const FunctionDecl *FD, llvm::Function *F) {
2708 llvm::LLVMContext &Ctx = F->getContext();
2709 llvm::MDBuilder MDB(Ctx);
2710 F->setMetadata(llvm::LLVMContext::MD_kcfi_type,
2711 llvm::MDNode::get(
2712 Ctx, MDB.createConstant(CreateKCFITypeId(FD->getType()))));
2713}
2714
2715static bool allowKCFIIdentifier(StringRef Name) {
2716 // KCFI type identifier constants are only necessary for external assembly
2717 // functions, which means it's safe to skip unusual names. Subset of
2718 // MCAsmInfo::isAcceptableChar() and MCAsmInfoXCOFF::isAcceptableChar().
2719 return llvm::all_of(Name, [](const char &C) {
2720 return llvm::isAlnum(C) || C == '_' || C == '.';
2721 });
2722}
2723
2725 llvm::Module &M = getModule();
2726 for (auto &F : M.functions()) {
2727 // Remove KCFI type metadata from non-address-taken local functions.
2728 bool AddressTaken = F.hasAddressTaken();
2729 if (!AddressTaken && F.hasLocalLinkage())
2730 F.eraseMetadata(llvm::LLVMContext::MD_kcfi_type);
2731
2732 // Generate a constant with the expected KCFI type identifier for all
2733 // address-taken function declarations to support annotating indirectly
2734 // called assembly functions.
2735 if (!AddressTaken || !F.isDeclaration())
2736 continue;
2737
2738 const llvm::ConstantInt *Type;
2739 if (const llvm::MDNode *MD = F.getMetadata(llvm::LLVMContext::MD_kcfi_type))
2740 Type = llvm::mdconst::extract<llvm::ConstantInt>(MD->getOperand(0));
2741 else
2742 continue;
2743
2744 StringRef Name = F.getName();
2745 if (!allowKCFIIdentifier(Name))
2746 continue;
2747
2748 std::string Asm = (".weak __kcfi_typeid_" + Name + "\n.set __kcfi_typeid_" +
2749 Name + ", " + Twine(Type->getZExtValue()) + "\n")
2750 .str();
2751 M.appendModuleInlineAsm(Asm);
2752 }
2753}
2754
2755void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
2756 bool IsIncompleteFunction,
2757 bool IsThunk) {
2758
2759 if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
2760 // If this is an intrinsic function, set the function's attributes
2761 // to the intrinsic's attributes.
2762 F->setAttributes(llvm::Intrinsic::getAttributes(getLLVMContext(), IID));
2763 return;
2764 }
2765
2766 const auto *FD = cast<FunctionDecl>(GD.getDecl());
2767
2768 if (!IsIncompleteFunction)
2769 SetLLVMFunctionAttributes(GD, getTypes().arrangeGlobalDeclaration(GD), F,
2770 IsThunk);
2771
2772 // Add the Returned attribute for "this", except for iOS 5 and earlier
2773 // where substantial code, including the libstdc++ dylib, was compiled with
2774 // GCC and does not actually return "this".
2775 if (!IsThunk && getCXXABI().HasThisReturn(GD) &&
2776 !(getTriple().isiOS() && getTriple().isOSVersionLT(6))) {
2777 assert(!F->arg_empty() &&
2778 F->arg_begin()->getType()
2779 ->canLosslesslyBitCastTo(F->getReturnType()) &&
2780 "unexpected this return");
2781 F->addParamAttr(0, llvm::Attribute::Returned);
2782 }
2783
2784 // Only a few attributes are set on declarations; these may later be
2785 // overridden by a definition.
2786
2787 setLinkageForGV(F, FD);
2788 setGVProperties(F, FD);
2789
2790 // Setup target-specific attributes.
2791 if (!IsIncompleteFunction && F->isDeclaration())
2793
2794 if (const auto *CSA = FD->getAttr<CodeSegAttr>())
2795 F->setSection(CSA->getName());
2796 else if (const auto *SA = FD->getAttr<SectionAttr>())
2797 F->setSection(SA->getName());
2798
2799 if (const auto *EA = FD->getAttr<ErrorAttr>()) {
2800 if (EA->isError())
2801 F->addFnAttr("dontcall-error", EA->getUserDiagnostic());
2802 else if (EA->isWarning())
2803 F->addFnAttr("dontcall-warn", EA->getUserDiagnostic());
2804 }
2805
2806 // If we plan on emitting this inline builtin, we can't treat it as a builtin.
2807 if (FD->isInlineBuiltinDeclaration()) {
2808 const FunctionDecl *FDBody;
2809 bool HasBody = FD->hasBody(FDBody);
2810 (void)HasBody;
2811 assert(HasBody && "Inline builtin declarations should always have an "
2812 "available body!");
2813 if (shouldEmitFunction(FDBody))
2814 F->addFnAttr(llvm::Attribute::NoBuiltin);
2815 }
2816
2818 // A replaceable global allocation function does not act like a builtin by
2819 // default, only if it is invoked by a new-expression or delete-expression.
2820 F->addFnAttr(llvm::Attribute::NoBuiltin);
2821 }
2822
2823 if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
2824 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2825 else if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
2826 if (MD->isVirtual())
2827 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2828
2829 // Don't emit entries for function declarations in the cross-DSO mode. This
2830 // is handled with better precision by the receiving DSO. But if jump tables
2831 // are non-canonical then we need type metadata in order to produce the local
2832 // jump table.
2833 if (!CodeGenOpts.SanitizeCfiCrossDso ||
2834 !CodeGenOpts.SanitizeCfiCanonicalJumpTables)
2836
2837 if (LangOpts.Sanitize.has(SanitizerKind::KCFI))
2838 setKCFIType(FD, F);
2839
2840 if (getLangOpts().OpenMP && FD->hasAttr<OMPDeclareSimdDeclAttr>())
2842
2843 if (CodeGenOpts.InlineMaxStackSize != UINT_MAX)
2844 F->addFnAttr("inline-max-stacksize", llvm::utostr(CodeGenOpts.InlineMaxStackSize));
2845
2846 if (const auto *CB = FD->getAttr<CallbackAttr>()) {
2847 // Annotate the callback behavior as metadata:
2848 // - The callback callee (as argument number).
2849 // - The callback payloads (as argument numbers).
2850 llvm::LLVMContext &Ctx = F->getContext();
2851 llvm::MDBuilder MDB(Ctx);
2852
2853 // The payload indices are all but the first one in the encoding. The first
2854 // identifies the callback callee.
2855 int CalleeIdx = *CB->encoding_begin();
2856 ArrayRef<int> PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());
2857 F->addMetadata(llvm::LLVMContext::MD_callback,
2858 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
2859 CalleeIdx, PayloadIndices,
2860 /* VarArgsArePassed */ false)}));
2861 }
2862}
2863
2864void CodeGenModule::addUsedGlobal(llvm::GlobalValue *GV) {
2865 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
2866 "Only globals with definition can force usage.");
2867 LLVMUsed.emplace_back(GV);
2868}
2869
2870void CodeGenModule::addCompilerUsedGlobal(llvm::GlobalValue *GV) {
2871 assert(!GV->isDeclaration() &&
2872 "Only globals with definition can force usage.");
2873 LLVMCompilerUsed.emplace_back(GV);
2874}
2875
2877 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
2878 "Only globals with definition can force usage.");
2879 if (getTriple().isOSBinFormatELF())
2880 LLVMCompilerUsed.emplace_back(GV);
2881 else
2882 LLVMUsed.emplace_back(GV);
2883}
2884
2885static void emitUsed(CodeGenModule &CGM, StringRef Name,
2886 std::vector<llvm::WeakTrackingVH> &List) {
2887 // Don't create llvm.used if there is no need.
2888 if (List.empty())
2889 return;
2890
2891 // Convert List to what ConstantArray needs.
2893 UsedArray.resize(List.size());
2894 for (unsigned i = 0, e = List.size(); i != e; ++i) {
2895 UsedArray[i] =
2896 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
2897 cast<llvm::Constant>(&*List[i]), CGM.Int8PtrTy);
2898 }
2899
2900 if (UsedArray.empty())
2901 return;
2902 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.Int8PtrTy, UsedArray.size());
2903
2904 auto *GV = new llvm::GlobalVariable(
2905 CGM.getModule(), ATy, false, llvm::GlobalValue::AppendingLinkage,
2906 llvm::ConstantArray::get(ATy, UsedArray), Name);
2907
2908 GV->setSection("llvm.metadata");
2909}
2910
2911void CodeGenModule::emitLLVMUsed() {
2912 emitUsed(*this, "llvm.used", LLVMUsed);
2913 emitUsed(*this, "llvm.compiler.used", LLVMCompilerUsed);
2914}
2915
2917 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opts);
2918 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
2919}
2920
2921void CodeGenModule::AddDetectMismatch(StringRef Name, StringRef Value) {
2924 if (Opt.empty())
2925 return;
2926 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
2927 LinkerOptionsMetadata.push_back(llvm::MDNode::get(getLLVMContext(), MDOpts));
2928}
2929
2931 auto &C = getLLVMContext();
2932 if (getTarget().getTriple().isOSBinFormatELF()) {
2933 ELFDependentLibraries.push_back(
2934 llvm::MDNode::get(C, llvm::MDString::get(C, Lib)));
2935 return;
2936 }
2937
2940 auto *MDOpts = llvm::MDString::get(getLLVMContext(), Opt);
2941 LinkerOptionsMetadata.push_back(llvm::MDNode::get(C, MDOpts));
2942}
2943
2944/// Add link options implied by the given module, including modules
2945/// it depends on, using a postorder walk.
2949 // Import this module's parent.
2950 if (Mod->Parent && Visited.insert(Mod->Parent).second) {
2951 addLinkOptionsPostorder(CGM, Mod->Parent, Metadata, Visited);
2952 }
2953
2954 // Import this module's dependencies.
2955 for (Module *Import : llvm::reverse(Mod->Imports)) {
2956 if (Visited.insert(Import).second)
2957 addLinkOptionsPostorder(CGM, Import, Metadata, Visited);
2958 }
2959
2960 // Add linker options to link against the libraries/frameworks
2961 // described by this module.
2962 llvm::LLVMContext &Context = CGM.getLLVMContext();
2963 bool IsELF = CGM.getTarget().getTriple().isOSBinFormatELF();
2964
2965 // For modules that use export_as for linking, use that module
2966 // name instead.
2968 return;
2969
2970 for (const Module::LinkLibrary &LL : llvm::reverse(Mod->LinkLibraries)) {
2971 // Link against a framework. Frameworks are currently Darwin only, so we
2972 // don't to ask TargetCodeGenInfo for the spelling of the linker option.
2973 if (LL.IsFramework) {
2974 llvm::Metadata *Args[2] = {llvm::MDString::get(Context, "-framework"),
2975 llvm::MDString::get(Context, LL.Library)};
2976
2977 Metadata.push_back(llvm::MDNode::get(Context, Args));
2978 continue;
2979 }
2980
2981 // Link against a library.
2982 if (IsELF) {
2983 llvm::Metadata *Args[2] = {
2984 llvm::MDString::get(Context, "lib"),
2985 llvm::MDString::get(Context, LL.Library),
2986 };
2987 Metadata.push_back(llvm::MDNode::get(Context, Args));
2988 } else {
2990 CGM.getTargetCodeGenInfo().getDependentLibraryOption(LL.Library, Opt);
2991 auto *OptString = llvm::MDString::get(Context, Opt);
2992 Metadata.push_back(llvm::MDNode::get(Context, OptString));
2993 }
2994 }
2995}
2996
2997void CodeGenModule::EmitModuleInitializers(clang::Module *Primary) {
2998 assert(Primary->isNamedModuleUnit() &&
2999 "We should only emit module initializers for named modules.");
3000
3001 // Emit the initializers in the order that sub-modules appear in the
3002 // source, first Global Module Fragments, if present.
3003 if (auto GMF = Primary->getGlobalModuleFragment()) {
3004 for (Decl *D : getContext().getModuleInitializers(GMF)) {
3005 if (isa<ImportDecl>(D))
3006 continue;
3007 assert(isa<VarDecl>(D) && "GMF initializer decl is not a var?");
3009 }
3010 }
3011 // Second any associated with the module, itself.
3012 for (Decl *D : getContext().getModuleInitializers(Primary)) {
3013 // Skip import decls, the inits for those are called explicitly.
3014 if (isa<ImportDecl>(D))
3015 continue;
3017 }
3018 // Third any associated with the Privat eMOdule Fragment, if present.
3019 if (auto PMF = Primary->getPrivateModuleFragment()) {
3020 for (Decl *D : getContext().getModuleInitializers(PMF)) {
3021 // Skip import decls, the inits for those are called explicitly.
3022 if (isa<ImportDecl>(D))
3023 continue;
3024 assert(isa<VarDecl>(D) && "PMF initializer decl is not a var?");
3026 }
3027 }
3028}
3029
3030void CodeGenModule::EmitModuleLinkOptions() {
3031 // Collect the set of all of the modules we want to visit to emit link
3032 // options, which is essentially the imported modules and all of their
3033 // non-explicit child modules.
3034 llvm::SetVector<clang::Module *> LinkModules;
3037
3038 // Seed the stack with imported modules.
3039 for (Module *M : ImportedModules) {
3040 // Do not add any link flags when an implementation TU of a module imports
3041 // a header of that same module.
3042 if (M->getTopLevelModuleName() == getLangOpts().CurrentModule &&
3043 !getLangOpts().isCompilingModule())
3044 continue;
3045 if (Visited.insert(M).second)
3046 Stack.push_back(M);
3047 }
3048
3049 // Find all of the modules to import, making a little effort to prune
3050 // non-leaf modules.
3051 while (!Stack.empty()) {
3052 clang::Module *Mod = Stack.pop_back_val();
3053
3054 bool AnyChildren = false;
3055
3056 // Visit the submodules of this module.
3057 for (const auto &SM : Mod->submodules()) {
3058 // Skip explicit children; they need to be explicitly imported to be
3059 // linked against.
3060 if (SM->IsExplicit)
3061 continue;
3062
3063 if (Visited.insert(SM).second) {
3064 Stack.push_back(SM);
3065 AnyChildren = true;
3066 }
3067 }
3068
3069 // We didn't find any children, so add this module to the list of
3070 // modules to link against.
3071 if (!AnyChildren) {
3072 LinkModules.insert(Mod);
3073 }
3074 }
3075
3076 // Add link options for all of the imported modules in reverse topological
3077 // order. We don't do anything to try to order import link flags with respect
3078 // to linker options inserted by things like #pragma comment().
3080 Visited.clear();
3081 for (Module *M : LinkModules)
3082 if (Visited.insert(M).second)
3083 addLinkOptionsPostorder(*this, M, MetadataArgs, Visited);
3084 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
3085 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
3086
3087 // Add the linker options metadata flag.
3088 auto *NMD = getModule().getOrInsertNamedMetadata("llvm.linker.options");
3089 for (auto *MD : LinkerOptionsMetadata)
3090 NMD->addOperand(MD);
3091}
3092
3093void CodeGenModule::EmitDeferred() {
3094 // Emit deferred declare target declarations.
3095 if (getLangOpts().OpenMP && !getLangOpts().OpenMPSimd)
3097
3098 // Emit code for any potentially referenced deferred decls. Since a
3099 // previously unused static decl may become used during the generation of code
3100 // for a static function, iterate until no changes are made.
3101
3102 if (!DeferredVTables.empty()) {
3103 EmitDeferredVTables();
3104
3105 // Emitting a vtable doesn't directly cause more vtables to
3106 // become deferred, although it can cause functions to be
3107 // emitted that then need those vtables.
3108 assert(DeferredVTables.empty());
3109 }
3110
3111 // Emit CUDA/HIP static device variables referenced by host code only.
3112 // Note we should not clear CUDADeviceVarODRUsedByHost since it is still
3113 // needed for further handling.
3114 if (getLangOpts().CUDA && getLangOpts().CUDAIsDevice)
3115 llvm::append_range(DeferredDeclsToEmit,
3116 getContext().CUDADeviceVarODRUsedByHost);
3117
3118 // Stop if we're out of both deferred vtables and deferred declarations.
3119 if (DeferredDeclsToEmit.empty())
3120 return;
3121
3122 // Grab the list of decls to emit. If EmitGlobalDefinition schedules more
3123 // work, it will not interfere with this.
3124 std::vector<GlobalDecl> CurDeclsToEmit;
3125 CurDeclsToEmit.swap(DeferredDeclsToEmit);
3126
3127 for (GlobalDecl &D : CurDeclsToEmit) {
3128 // We should call GetAddrOfGlobal with IsForDefinition set to true in order
3129 // to get GlobalValue with exactly the type we need, not something that
3130 // might had been created for another decl with the same mangled name but
3131 // different type.
3132 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
3134
3135 // In case of different address spaces, we may still get a cast, even with
3136 // IsForDefinition equal to true. Query mangled names table to get
3137 // GlobalValue.
3138 if (!GV)
3140
3141 // Make sure GetGlobalValue returned non-null.
3142 assert(GV);
3143
3144 // Check to see if we've already emitted this. This is necessary
3145 // for a couple of reasons: first, decls can end up in the
3146 // deferred-decls queue multiple times, and second, decls can end
3147 // up with definitions in unusual ways (e.g. by an extern inline
3148 // function acquiring a strong function redefinition). Just
3149 // ignore these cases.
3150 if (!GV->isDeclaration())
3151 continue;
3152
3153 // If this is OpenMP, check if it is legal to emit this global normally.
3154 if (LangOpts.OpenMP && OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(D))
3155 continue;
3156
3157 // Otherwise, emit the definition and move on to the next one.
3158 EmitGlobalDefinition(D, GV);
3159
3160 // If we found out that we need to emit more decls, do that recursively.
3161 // This has the advantage that the decls are emitted in a DFS and related
3162 // ones are close together, which is convenient for testing.
3163 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
3164 EmitDeferred();
3165 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
3166 }
3167 }
3168}
3169
3170void CodeGenModule::EmitVTablesOpportunistically() {
3171 // Try to emit external vtables as available_externally if they have emitted
3172 // all inlined virtual functions. It runs after EmitDeferred() and therefore
3173 // is not allowed to create new references to things that need to be emitted
3174 // lazily. Note that it also uses fact that we eagerly emitting RTTI.
3175
3176 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
3177 && "Only emit opportunistic vtables with optimizations");
3178
3179 for (const CXXRecordDecl *RD : OpportunisticVTables) {
3180 assert(getVTables().isVTableExternal(RD) &&
3181 "This queue should only contain external vtables");
3182 if (getCXXABI().canSpeculativelyEmitVTable(RD))
3183 VTables.GenerateClassData(RD);
3184 }
3185 OpportunisticVTables.clear();
3186}
3187
3189 for (const auto& [MangledName, VD] : DeferredAnnotations) {
3190 llvm::GlobalValue *GV = GetGlobalValue(MangledName);
3191 if (GV)
3192 AddGlobalAnnotations(VD, GV);
3193 }
3194 DeferredAnnotations.clear();
3195
3196 if (Annotations.empty())
3197 return;
3198
3199 // Create a new global variable for the ConstantStruct in the Module.
3200 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
3201 Annotations[0]->getType(), Annotations.size()), Annotations);
3202 auto *gv = new llvm::GlobalVariable(getModule(), Array->getType(), false,
3203 llvm::GlobalValue::AppendingLinkage,
3204 Array, "llvm.global.annotations");
3205 gv->setSection(AnnotationSection);
3206}
3207
3208llvm::Constant *CodeGenModule::EmitAnnotationString(StringRef Str) {
3209 llvm::Constant *&AStr = AnnotationStrings[Str];
3210 if (AStr)
3211 return AStr;
3212
3213 // Not found yet, create a new global.
3214 llvm::Constant *s = llvm::ConstantDataArray::getString(getLLVMContext(), Str);
3215 auto *gv = new llvm::GlobalVariable(
3216 getModule(), s->getType(), true, llvm::GlobalValue::PrivateLinkage, s,
3217 ".str", nullptr, llvm::GlobalValue::NotThreadLocal,
3218 ConstGlobalsPtrTy->getAddressSpace());
3219 gv->setSection(AnnotationSection);
3220 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3221 AStr = gv;
3222 return gv;
3223}
3224
3227 PresumedLoc PLoc = SM.getPresumedLoc(Loc);
3228 if (PLoc.isValid())
3229 return EmitAnnotationString(PLoc.getFilename());
3230 return EmitAnnotationString(SM.getBufferName(Loc));
3231}
3232
3235 PresumedLoc PLoc = SM.getPresumedLoc(L);
3236 unsigned LineNo = PLoc.isValid() ? PLoc.getLine() :
3237 SM.getExpansionLineNumber(L);
3238 return llvm::ConstantInt::get(Int32Ty, LineNo);
3239}
3240
3241llvm::Constant *CodeGenModule::EmitAnnotationArgs(const AnnotateAttr *Attr) {
3242 ArrayRef<Expr *> Exprs = {Attr->args_begin(), Attr->args_size()};
3243 if (Exprs.empty())
3244 return llvm::ConstantPointerNull::get(ConstGlobalsPtrTy);
3245
3246 llvm::FoldingSetNodeID ID;
3247 for (Expr *E : Exprs) {
3248 ID.Add(cast<clang::ConstantExpr>(E)->getAPValueResult());
3249 }
3250 llvm::Constant *&Lookup = AnnotationArgs[ID.ComputeHash()];
3251 if (Lookup)
3252 return Lookup;
3253
3255 LLVMArgs.reserve(Exprs.size());
3256 ConstantEmitter ConstEmiter(*this);
3257 llvm::transform(Exprs, std::back_inserter(LLVMArgs), [&](const Expr *E) {
3258 const auto *CE = cast<clang::ConstantExpr>(E);
3259 return ConstEmiter.emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(),
3260 CE->getType());
3261 });
3262 auto *Struct = llvm::ConstantStruct::getAnon(LLVMArgs);
3263 auto *GV = new llvm::GlobalVariable(getModule(), Struct->getType(), true,
3264 llvm::GlobalValue::PrivateLinkage, Struct,
3265 ".args");
3266 GV->setSection(AnnotationSection);
3267 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3268
3269 Lookup = GV;
3270 return GV;
3271}
3272
3273llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV,
3274 const AnnotateAttr *AA,
3275 SourceLocation L) {
3276 // Get the globals for file name, annotation, and the line number.
3277 llvm::Constant *AnnoGV = EmitAnnotationString(AA->getAnnotation()),
3278 *UnitGV = EmitAnnotationUnit(L),
3279 *LineNoCst = EmitAnnotationLineNo(L),
3280 *Args = EmitAnnotationArgs(AA);
3281
3282 llvm::Constant *GVInGlobalsAS = GV;
3283 if (GV->getAddressSpace() !=
3284 getDataLayout().getDefaultGlobalsAddressSpace()) {
3285 GVInGlobalsAS = llvm::ConstantExpr::getAddrSpaceCast(
3286 GV,
3287 llvm::PointerType::get(
3288 GV->getContext(), getDataLayout().getDefaultGlobalsAddressSpace()));
3289 }
3290
3291 // Create the ConstantStruct for the global annotation.
3292 llvm::Constant *Fields[] = {
3293 GVInGlobalsAS, AnnoGV, UnitGV, LineNoCst, Args,
3294 };
3295 return llvm::ConstantStruct::getAnon(Fields);
3296}
3297
3299 llvm::GlobalValue *GV) {
3300 assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
3301 // Get the struct elements for these annotations.
3302 for (const auto *I : D->specific_attrs<AnnotateAttr>())
3303 Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
3304}
3305
3307 SourceLocation Loc) const {
3308 const auto &NoSanitizeL = getContext().getNoSanitizeList();
3309 // NoSanitize by function name.
3310 if (NoSanitizeL.containsFunction(Kind, Fn->getName()))
3311 return true;
3312 // NoSanitize by location. Check "mainfile" prefix.
3313 auto &SM = Context.getSourceManager();
3314 FileEntryRef MainFile = *SM.getFileEntryRefForID(SM.getMainFileID());
3315 if (NoSanitizeL.containsMainFile(Kind, MainFile.getName()))
3316 return true;
3317
3318 // Check "src" prefix.
3319 if (Loc.isValid())
3320 return NoSanitizeL.containsLocation(Kind, Loc);
3321 // If location is unknown, this may be a compiler-generated function. Assume
3322 // it's located in the main file.
3323 return NoSanitizeL.containsFile(Kind, MainFile.getName());
3324}
3325
3327 llvm::GlobalVariable *GV,
3328 SourceLocation Loc, QualType Ty,
3329 StringRef Category) const {
3330 const auto &NoSanitizeL = getContext().getNoSanitizeList();
3331 if (NoSanitizeL.containsGlobal(Kind, GV->getName(), Category))
3332 return true;
3333 auto &SM = Context.getSourceManager();
3334 if (NoSanitizeL.containsMainFile(
3335 Kind, SM.getFileEntryRefForID(SM.getMainFileID())->getName(),
3336 Category))
3337 return true;
3338 if (NoSanitizeL.containsLocation(Kind, Loc, Category))
3339 return true;
3340
3341 // Check global type.
3342 if (!Ty.isNull()) {
3343 // Drill down the array types: if global variable of a fixed type is
3344 // not sanitized, we also don't instrument arrays of them.
3345 while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr()))
3346 Ty = AT->getElementType();
3348 // Only record types (classes, structs etc.) are ignored.
3349 if (Ty->isRecordType()) {
3350 std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy());
3351 if (NoSanitizeL.containsType(Kind, TypeStr, Category))
3352 return true;
3353 }
3354 }
3355 return false;
3356}
3357
3359 StringRef Category) const {
3360 const auto &XRayFilter = getContext().getXRayFilter();
3361 using ImbueAttr = XRayFunctionFilter::ImbueAttribute;
3362 auto Attr = ImbueAttr::NONE;
3363 if (Loc.isValid())
3364 Attr = XRayFilter.shouldImbueLocation(Loc, Category);
3365 if (Attr == ImbueAttr::NONE)
3366 Attr = XRayFilter.shouldImbueFunction(Fn->getName());
3367 switch (Attr) {
3368 case ImbueAttr::NONE:
3369 return false;
3370 case ImbueAttr::ALWAYS:
3371 Fn->addFnAttr("function-instrument", "xray-always");
3372 break;
3373 case ImbueAttr::ALWAYS_ARG1:
3374 Fn->addFnAttr("function-instrument", "xray-always");
3375 Fn->addFnAttr("xray-log-args", "1");
3376 break;
3377 case ImbueAttr::NEVER:
3378 Fn->addFnAttr("function-instrument", "xray-never");
3379 break;
3380 }
3381 return true;
3382}
3383
3386 SourceLocation Loc) const {
3387 const auto &ProfileList = getContext().getProfileList();
3388 // If the profile list is empty, then instrument everything.
3389 if (ProfileList.isEmpty())
3390 return ProfileList::Allow;
3391 CodeGenOptions::ProfileInstrKind Kind = getCodeGenOpts().getProfileInstr();
3392 // First, check the function name.
3393 if (auto V = ProfileList.isFunctionExcluded(Fn->getName(), Kind))
3394 return *V;
3395 // Next, check the source location.
3396 if (Loc.isValid())
3397 if (auto V = ProfileList.isLocationExcluded(Loc, Kind))
3398 return *V;
3399 // If location is unknown, this may be a compiler-generated function. Assume
3400 // it's located in the main file.
3401 auto &SM = Context.getSourceManager();
3402 if (auto MainFile = SM.getFileEntryRefForID(SM.getMainFileID()))
3403 if (auto V = ProfileList.isFileExcluded(MainFile->getName(), Kind))
3404 return *V;
3405 return ProfileList.getDefault(Kind);
3406}
3407
3410 SourceLocation Loc) const {
3411 auto V = isFunctionBlockedByProfileList(Fn, Loc);
3412 if (V != ProfileList::Allow)
3413 return V;
3414
3415 auto NumGroups = getCodeGenOpts().ProfileTotalFunctionGroups;
3416 if (NumGroups > 1) {
3417 auto Group = llvm::crc32(arrayRefFromStringRef(Fn->getName())) % NumGroups;
3418 if (Group != getCodeGenOpts().ProfileSelectedFunctionGroup)
3419 return ProfileList::Skip;
3420 }
3421 return ProfileList::Allow;
3422}
3423
3424bool CodeGenModule::MustBeEmitted(const ValueDecl *Global) {
3425 // Never defer when EmitAllDecls is specified.
3426 if (LangOpts.EmitAllDecls)
3427 return true;
3428
3429 const auto *VD = dyn_cast<VarDecl>(Global);
3430 if (VD &&
3431 ((CodeGenOpts.KeepPersistentStorageVariables &&
3432 (VD->getStorageDuration() == SD_Static ||
3433 VD->getStorageDuration() == SD_Thread)) ||
3434 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() == SD_Static &&
3435 VD->getType().isConstQualified())))
3436 return true;
3437
3439}
3440
3441bool CodeGenModule::MayBeEmittedEagerly(const ValueDecl *Global) {
3442 // In OpenMP 5.0 variables and function may be marked as
3443 // device_type(host/nohost) and we should not emit them eagerly unless we sure
3444 // that they must be emitted on the host/device. To be sure we need to have
3445 // seen a declare target with an explicit mentioning of the function, we know
3446 // we have if the level of the declare target attribute is -1. Note that we
3447 // check somewhere else if we should emit this at all.
3448 if (LangOpts.OpenMP >= 50 && !LangOpts.OpenMPSimd) {
3449 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr =
3450 OMPDeclareTargetDeclAttr::getActiveAttr(Global);
3451 if (!ActiveAttr || (*ActiveAttr)->getLevel() != (unsigned)-1)
3452 return false;
3453 }
3454
3455 if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
3457 // Implicit template instantiations may change linkage if they are later
3458 // explicitly instantiated, so they should not be emitted eagerly.
3459 return false;
3460 // Defer until all versions have been semantically checked.
3461 if (FD->hasAttr<TargetVersionAttr>() && !FD->isMultiVersion())
3462 return false;
3463 }
3464 if (const auto *VD = dyn_cast<VarDecl>(Global)) {
3465 if (Context.getInlineVariableDefinitionKind(VD) ==
3467 // A definition of an inline constexpr static data member may change
3468 // linkage later if it's redeclared outside the class.
3469 return false;
3470 if (CXX20ModuleInits && VD->getOwningModule() &&
3471 !VD->getOwningModule()->isModuleMapModule()) {
3472 // For CXX20, module-owned initializers need to be deferred, since it is
3473 // not known at this point if they will be run for the current module or
3474 // as part of the initializer for an imported one.
3475 return false;
3476 }
3477 }
3478 // If OpenMP is enabled and threadprivates must be generated like TLS, delay
3479 // codegen for global variables, because they may be marked as threadprivate.
3480 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
3481 getContext().getTargetInfo().isTLSSupported() && isa<VarDecl>(Global) &&
3482 !Global->getType().isConstantStorage(getContext(), false, false) &&
3483 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Global))
3484 return false;
3485
3486 return true;
3487}
3488
3490 StringRef Name = getMangledName(GD);
3491
3492 // The UUID descriptor should be pointer aligned.
3494
3495 // Look for an existing global.
3496 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
3497 return ConstantAddress(GV, GV->getValueType(), Alignment);
3498
3499 ConstantEmitter Emitter(*this);
3500 llvm::Constant *Init;
3501
3502 APValue &V = GD->getAsAPValue();
3503 if (!V.isAbsent()) {
3504 // If possible, emit the APValue version of the initializer. In particular,
3505 // this gets the type of the constant right.
3506 Init = Emitter.emitForInitializer(
3507 GD->getAsAPValue(), GD->getType().getAddressSpace(), GD->getType());
3508 } else {
3509 // As a fallback, directly construct the constant.
3510 // FIXME: This may get padding wrong under esoteric struct layout rules.
3511 // MSVC appears to create a complete type 'struct __s_GUID' that it
3512 // presumably uses to represent these constants.
3513 MSGuidDecl::Parts Parts = GD->getParts();
3514 llvm::Constant *Fields[4] = {
3515 llvm::ConstantInt::get(Int32Ty, Parts.Part1),
3516 llvm::ConstantInt::get(Int16Ty, Parts.Part2),
3517 llvm::ConstantInt::get(Int16Ty, Parts.Part3),
3518 llvm::ConstantDataArray::getRaw(
3519 StringRef(reinterpret_cast<char *>(Parts.Part4And5), 8), 8,
3520 Int8Ty)};
3521 Init = llvm::ConstantStruct::getAnon(Fields);
3522 }
3523
3524 auto *GV = new llvm::GlobalVariable(
3525 getModule(), Init->getType(),
3526 /*isConstant=*/true, llvm::GlobalValue::LinkOnceODRLinkage, Init, Name);
3527 if (supportsCOMDAT())
3528 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3529 setDSOLocal(GV);
3530
3531 if (!V.isAbsent()) {
3532 Emitter.finalize(GV);
3533 return ConstantAddress(GV, GV->getValueType(), Alignment);
3534 }
3535
3536 llvm::Type *Ty = getTypes().ConvertTypeForMem(GD->getType());
3537 return ConstantAddress(GV, Ty, Alignment);
3538}
3539
3541 const UnnamedGlobalConstantDecl *GCD) {
3542 CharUnits Alignment = getContext().getTypeAlignInChars(GCD->getType());
3543
3544 llvm::GlobalVariable **Entry = nullptr;
3545 Entry = &UnnamedGlobalConstantDeclMap[GCD];
3546 if (*Entry)
3547 return ConstantAddress(*Entry, (*Entry)->getValueType(), Alignment);
3548
3549 ConstantEmitter Emitter(*this);
3550 llvm::Constant *Init;
3551
3552 const APValue &V = GCD->getValue();
3553
3554 assert(!V.isAbsent());
3555 Init = Emitter.emitForInitializer(V, GCD->getType().getAddressSpace(),
3556 GCD->getType());
3557
3558 auto *GV = new llvm::GlobalVariable(getModule(), Init->getType(),
3559 /*isConstant=*/true,
3560 llvm::GlobalValue::PrivateLinkage, Init,
3561 ".constant");
3562 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3563 GV->setAlignment(Alignment.getAsAlign());
3564
3565 Emitter.finalize(GV);
3566
3567 *Entry = GV;
3568 return ConstantAddress(GV, GV->getValueType(), Alignment);
3569}
3570
3572 const TemplateParamObjectDecl *TPO) {
3573 StringRef Name = getMangledName(TPO);
3574 CharUnits Alignment = getNaturalTypeAlignment(TPO->getType());
3575
3576 if (llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name))
3577 return ConstantAddress(GV, GV->getValueType(), Alignment);
3578
3579 ConstantEmitter Emitter(*this);
3580 llvm::Constant *Init = Emitter.emitForInitializer(
3581 TPO->getValue(), TPO->getType().getAddressSpace(), TPO->getType());
3582
3583 if (!Init) {
3584 ErrorUnsupported(TPO, "template parameter object");
3585 return ConstantAddress::invalid();
3586 }
3587
3588 llvm::GlobalValue::LinkageTypes Linkage =
3590 ? llvm::GlobalValue::LinkOnceODRLinkage
3591 : llvm::GlobalValue::InternalLinkage;
3592 auto *GV = new llvm::GlobalVariable(getModule(), Init->getType(),
3593 /*isConstant=*/true, Linkage, Init, Name);
3594 setGVProperties(GV, TPO);
3595 if (supportsCOMDAT())
3596 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3597 Emitter.finalize(GV);
3598
3599 return ConstantAddress(GV, GV->getValueType(), Alignment);
3600}
3601
3603 const AliasAttr *AA = VD->getAttr<AliasAttr>();
3604 assert(AA && "No alias?");
3605
3606 CharUnits Alignment = getContext().getDeclAlign(VD);
3607 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
3608
3609 // See if there is already something with the target's name in the module.
3610 llvm::GlobalValue *Entry = GetGlobalValue(AA->getAliasee());
3611 if (Entry)
3612 return ConstantAddress(Entry, DeclTy, Alignment);
3613
3614 llvm::Constant *Aliasee;
3615 if (isa<llvm::FunctionType>(DeclTy))
3616 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
3617 GlobalDecl(cast<FunctionDecl>(VD)),
3618 /*ForVTable=*/false);
3619 else
3620 Aliasee = GetOrCreateLLVMGlobal(AA->getAliasee(), DeclTy, LangAS::Default,
3621 nullptr);
3622
3623 auto *F = cast<llvm::GlobalValue>(Aliasee);
3624 F->setLinkage(llvm::Function::ExternalWeakLinkage);
3625 WeakRefReferences.insert(F);
3626
3627 return ConstantAddress(Aliasee, DeclTy, Alignment);
3628}
3629
3630template <typename AttrT> static bool hasImplicitAttr(const ValueDecl *D) {
3631 if (!D)
3632 return false;
3633 if (auto *A = D->getAttr<AttrT>())
3634 return A->isImplicit();
3635 return D->isImplicit();
3636}
3637
3639 const auto *Global = cast<ValueDecl>(GD.getDecl());
3640
3641 // Weak references don't produce any output by themselves.
3642 if (Global->hasAttr<WeakRefAttr>())
3643 return;
3644
3645 // If this is an alias definition (which otherwise looks like a declaration)
3646 // emit it now.
3647 if (Global->hasAttr<AliasAttr>())
3648 return EmitAliasDefinition(GD);
3649
3650 // IFunc like an alias whose value is resolved at runtime by calling resolver.
3651 if (Global->hasAttr<IFuncAttr>())
3652 return emitIFuncDefinition(GD);
3653
3654 // If this is a cpu_dispatch multiversion function, emit the resolver.
3655 if (Global->hasAttr<CPUDispatchAttr>())
3656 return emitCPUDispatchDefinition(GD);
3657
3658 // If this is CUDA, be selective about which declarations we emit.
3659 // Non-constexpr non-lambda implicit host device functions are not emitted
3660 // unless they are used on device side.
3661 if (LangOpts.CUDA) {
3662 if (LangOpts.CUDAIsDevice) {
3663 const auto *FD = dyn_cast<FunctionDecl>(Global);
3664 if ((!Global->hasAttr<CUDADeviceAttr>() ||
3665 (LangOpts.OffloadImplicitHostDeviceTemplates && FD &&
3666 hasImplicitAttr<CUDAHostAttr>(FD) &&
3667 hasImplicitAttr<CUDADeviceAttr>(FD) && !FD->isConstexpr() &&
3668 !isLambdaCallOperator(FD) &&
3669 !getContext().CUDAImplicitHostDeviceFunUsedByDevice.count(FD))) &&
3670 !Global->hasAttr<CUDAGlobalAttr>() &&
3671 !Global->hasAttr<CUDAConstantAttr>() &&
3672 !Global->hasAttr<CUDASharedAttr>() &&
3673 !Global->getType()->isCUDADeviceBuiltinSurfaceType() &&
3674 !Global->getType()->isCUDADeviceBuiltinTextureType() &&
3675 !(LangOpts.HIPStdPar && isa<FunctionDecl>(Global) &&
3676 !Global->hasAttr<CUDAHostAttr>()))
3677 return;
3678 } else {
3679 // We need to emit host-side 'shadows' for all global
3680 // device-side variables because the CUDA runtime needs their
3681 // size and host-side address in order to provide access to
3682 // their device-side incarnations.
3683
3684 // So device-only functions are the only things we skip.
3685 if (isa<FunctionDecl>(Global) && !Global->hasAttr<CUDAHostAttr>() &&
3686 Global->hasAttr<CUDADeviceAttr>())
3687 return;
3688
3689 assert((isa<FunctionDecl>(Global) || isa<VarDecl>(Global)) &&
3690 "Expected Variable or Function");
3691 }
3692 }
3693
3694 if (LangOpts.OpenMP) {
3695 // If this is OpenMP, check if it is legal to emit this global normally.
3696 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
3697 return;
3698 if (auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) {
3699 if (MustBeEmitted(Global))
3701 return;
3702 }
3703 if (auto *DMD = dyn_cast<OMPDeclareMapperDecl>(Global)) {
3704 if (MustBeEmitted(Global))
3706 return;
3707 }
3708 }
3709
3710 // Ignore declarations, they will be emitted on their first use.
3711 if (const auto *FD = dyn_cast<FunctionDecl>(Global)) {
3712 // Update deferred annotations with the latest declaration if the function
3713 // function was already used or defined.
3714 if (FD->hasAttr<AnnotateAttr>()) {
3715 StringRef MangledName = getMangledName(GD);
3716 if (GetGlobalValue(MangledName))
3717 DeferredAnnotations[MangledName] = FD;
3718 }
3719
3720 // Forward declarations are emitted lazily on first use.
3721 if (!FD->doesThisDeclarationHaveABody()) {
3723 (!FD->isMultiVersion() ||
3724 !FD->getASTContext().getTargetInfo().getTriple().isAArch64()))
3725 return;
3726
3727 StringRef MangledName = getMangledName(GD);
3728
3729 // Compute the function info and LLVM type.
3731 llvm::Type *Ty = getTypes().GetFunctionType(FI);
3732
3733 GetOrCreateLLVMFunction(MangledName, Ty, GD, /*ForVTable=*/false,
3734 /*DontDefer=*/false);
3735 return;
3736 }
3737 } else {
3738 const auto *VD = cast<VarDecl>(Global);
3739 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global.");
3740 if (VD->isThisDeclarationADefinition() != VarDecl::Definition &&
3742 if (LangOpts.OpenMP) {
3743 // Emit declaration of the must-be-emitted declare target variable.
3744 if (std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
3745 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
3746
3747 // If this variable has external storage and doesn't require special
3748 // link handling we defer to its canonical definition.
3749 if (VD->hasExternalStorage() &&
3750 Res != OMPDeclareTargetDeclAttr::MT_Link)
3751 return;
3752
3753 bool UnifiedMemoryEnabled =
3755 if ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3756 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3757 !UnifiedMemoryEnabled) {
3758 (void)GetAddrOfGlobalVar(VD);
3759 } else {
3760 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
3761 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3762 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3763 UnifiedMemoryEnabled)) &&
3764 "Link clause or to clause with unified memory expected.");
3766 }
3767
3768 return;
3769 }
3770 }
3771 // If this declaration may have caused an inline variable definition to
3772 // change linkage, make sure that it's emitted.
3773 if (Context.getInlineVariableDefinitionKind(VD) ==
3776 return;
3777 }
3778 }
3779
3780 // Defer code generation to first use when possible, e.g. if this is an inline
3781 // function. If the global must always be emitted, do it eagerly if possible
3782 // to benefit from cache locality.
3783 if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
3784 // Emit the definition if it can't be deferred.
3785 EmitGlobalDefinition(GD);
3786 addEmittedDeferredDecl(GD);
3787 return;
3788 }
3789
3790 // If we're deferring emission of a C++ variable with an
3791 // initializer, remember the order in which it appeared in the file.
3792 if (getLangOpts().CPlusPlus && isa<VarDecl>(Global) &&
3793 cast<VarDecl>(Global)->hasInit()) {
3794 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
3795 CXXGlobalInits.push_back(nullptr);
3796 }
3797
3798 StringRef MangledName = getMangledName(GD);
3799 if (GetGlobalValue(MangledName) != nullptr) {
3800 // The value has already been used and should therefore be emitted.
3801 addDeferredDeclToEmit(GD);
3802 } else if (MustBeEmitted(Global)) {
3803 // The value must be emitted, but cannot be emitted eagerly.
3804 assert(!MayBeEmittedEagerly(Global));
3805 addDeferredDeclToEmit(GD);
3806 } else {
3807 // Otherwise, remember that we saw a deferred decl with this name. The
3808 // first use of the mangled name will cause it to move into
3809 // DeferredDeclsToEmit.
3810 DeferredDecls[MangledName] = GD;
3811 }
3812}
3813
3814// Check if T is a class type with a destructor that's not dllimport.
3816 if (const auto *RT = T->getBaseElementTypeUnsafe()->getAs<RecordType>())
3817 if (CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
3818 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
3819 return true;
3820
3821 return false;
3822}
3823
3824namespace {
3825 struct FunctionIsDirectlyRecursive
3826 : public ConstStmtVisitor<FunctionIsDirectlyRecursive, bool> {
3827 const StringRef Name;
3828 const Builtin::Context &BI;
3829 FunctionIsDirectlyRecursive(StringRef N, const Builtin::Context &C)
3830 : Name(N), BI(C) {}
3831
3832 bool VisitCallExpr(const CallExpr *E) {
3833 const FunctionDecl *FD = E->getDirectCallee();
3834 if (!FD)
3835 return false;
3836 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
3837 if (Attr && Name == Attr->getLabel())
3838 return true;
3839 unsigned BuiltinID = FD->getBuiltinID();
3840 if (!BuiltinID || !BI.isLibFunction(BuiltinID))
3841 return false;
3842 StringRef BuiltinName = BI.getName(BuiltinID);
3843 if (BuiltinName.starts_with("__builtin_") &&
3844 Name == BuiltinName.slice(strlen("__builtin_"), StringRef::npos)) {
3845 return true;
3846 }
3847 return false;
3848 }
3849
3850 bool VisitStmt(const Stmt *S) {
3851 for (const Stmt *Child : S->children())
3852 if (Child && this->Visit(Child))
3853 return true;
3854 return false;
3855 }
3856 };
3857
3858 // Make sure we're not referencing non-imported vars or functions.
3859 struct DLLImportFunctionVisitor
3860 : public RecursiveASTVisitor<DLLImportFunctionVisitor> {
3861 bool SafeToInline = true;
3862
3863 bool shouldVisitImplicitCode() const { return true; }
3864
3865 bool VisitVarDecl(VarDecl *VD) {
3866 if (VD->getTLSKind()) {
3867 // A thread-local variable cannot be imported.
3868 SafeToInline = false;
3869 return SafeToInline;
3870 }
3871
3872 // A variable definition might imply a destructor call.
3874 SafeToInline = !HasNonDllImportDtor(VD->getType());
3875
3876 return SafeToInline;
3877 }
3878
3879 bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
3880 if (const auto *D = E->getTemporary()->getDestructor())
3881 SafeToInline = D->hasAttr<DLLImportAttr>();
3882 return SafeToInline;
3883 }
3884
3885 bool VisitDeclRefExpr(DeclRefExpr *E) {
3886 ValueDecl *VD = E->getDecl();
3887 if (isa<FunctionDecl>(VD))
3888 SafeToInline = VD->hasAttr<DLLImportAttr>();
3889 else if (VarDecl *V = dyn_cast<VarDecl>(VD))
3890 SafeToInline = !V->hasGlobalStorage() || V->hasAttr<DLLImportAttr>();
3891 return SafeToInline;
3892 }
3893
3894 bool VisitCXXConstructExpr(CXXConstructExpr *E) {
3895 SafeToInline = E->getConstructor()->hasAttr<DLLImportAttr>();
3896 return SafeToInline;
3897 }
3898
3899 bool VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
3900 CXXMethodDecl *M = E->getMethodDecl();
3901 if (!M) {
3902 // Call through a pointer to member function. This is safe to inline.
3903 SafeToInline = true;
3904 } else {
3905 SafeToInline = M->hasAttr<DLLImportAttr>();
3906 }
3907 return SafeToInline;
3908 }
3909
3910 bool VisitCXXDeleteExpr(CXXDeleteExpr *E) {
3911 SafeToInline = E->getOperatorDelete()->hasAttr<DLLImportAttr>();
3912 return SafeToInline;
3913 }
3914
3915 bool VisitCXXNewExpr(CXXNewExpr *E) {
3916 SafeToInline = E->getOperatorNew()->hasAttr<DLLImportAttr>();
3917 return SafeToInline;
3918 }
3919 };
3920}
3921
3922// isTriviallyRecursive - Check if this function calls another
3923// decl that, because of the asm attribute or the other decl being a builtin,
3924// ends up pointing to itself.
3925bool
3926CodeGenModule::isTriviallyRecursive(const FunctionDecl *FD) {
3927 StringRef Name;
3928 if (getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
3929 // asm labels are a special kind of mangling we have to support.
3930 AsmLabelAttr *Attr = FD->getAttr<AsmLabelAttr>();
3931 if (!Attr)
3932 return false;
3933 Name = Attr->getLabel();
3934 } else {
3935 Name = FD->getName();
3936 }
3937
3938 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
3939 const Stmt *Body = FD->getBody();
3940 return Body ? Walker.Visit(Body) : false;
3941}
3942
3943bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) {
3944 if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage)
3945 return true;
3946
3947 const auto *F = cast<FunctionDecl>(GD.getDecl());
3948 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
3949 return false;
3950
3951 // We don't import function bodies from other named module units since that
3952 // behavior may break ABI compatibility of the current unit.
3953 if (const Module *M = F->getOwningModule();
3954 M && M->getTopLevelModule()->isNamedModule() &&
3955 getContext().getCurrentNamedModule() != M->getTopLevelModule() &&
3956 !F->hasAttr<AlwaysInlineAttr>())
3957 return false;
3958
3959 if (F->hasAttr<NoInlineAttr>())
3960 return false;
3961
3962 if (F->hasAttr<DLLImportAttr>() && !F->hasAttr<AlwaysInlineAttr>()) {
3963 // Check whether it would be safe to inline this dllimport function.
3964 DLLImportFunctionVisitor Visitor;
3965 Visitor.TraverseFunctionDecl(const_cast<FunctionDecl*>(F));
3966 if (!Visitor.SafeToInline)
3967 return false;
3968
3969 if (const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(F)) {
3970 // Implicit destructor invocations aren't captured in the AST, so the
3971 // check above can't see them. Check for them manually here.
3972 for (const Decl *Member : Dtor->getParent()->decls())
3973 if (isa<FieldDecl>(Member))
3974 if (HasNonDllImportDtor(cast<FieldDecl>(Member)->getType()))
3975 return false;
3976 for (const CXXBaseSpecifier &B : Dtor->getParent()->bases())
3977 if (HasNonDllImportDtor(B.getType()))
3978 return false;
3979 }
3980 }
3981
3982 // Inline builtins declaration must be emitted. They often are fortified
3983 // functions.
3984 if (F->isInlineBuiltinDeclaration())
3985 return true;
3986
3987 // PR9614. Avoid cases where the source code is lying to us. An available
3988 // externally function should have an equivalent function somewhere else,
3989 // but a function that calls itself through asm label/`__builtin_` trickery is
3990 // clearly not equivalent to the real implementation.
3991 // This happens in glibc's btowc and in some configure checks.
3992 return !isTriviallyRecursive(F);
3993}
3994
3995bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
3996 return CodeGenOpts.OptimizationLevel > 0;
3997}
3998
3999void CodeGenModule::EmitMultiVersionFunctionDefinition(GlobalDecl GD,
4000 llvm::GlobalValue *GV) {
4001 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4002
4003 if (FD->isCPUSpecificMultiVersion()) {
4004 auto *Spec = FD->getAttr<CPUSpecificAttr>();
4005 for (unsigned I = 0; I < Spec->cpus_size(); ++I)
4006 EmitGlobalFunctionDefinition(GD.getWithMultiVersionIndex(I), nullptr);
4007 } else if (auto *TC = FD->getAttr<TargetClonesAttr>()) {
4008 for (unsigned I = 0; I < TC->featuresStrs_size(); ++I)
4009 // AArch64 favors the default target version over the clone if any.
4010 if ((!TC->isDefaultVersion(I) || !getTarget().getTriple().isAArch64()) &&
4011 TC->isFirstOfVersion(I))
4012 EmitGlobalFunctionDefinition(GD.getWithMultiVersionIndex(I), nullptr);
4013 // Ensure that the resolver function is also emitted.
4014 GetOrCreateMultiVersionResolver(GD);
4015 } else
4016 EmitGlobalFunctionDefinition(GD, GV);
4017
4018 // Defer the resolver emission until we can reason whether the TU
4019 // contains a default target version implementation.
4021 AddDeferredMultiVersionResolverToEmit(GD);
4022}
4023
4024void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
4025 const auto *D = cast<ValueDecl>(GD.getDecl());
4026
4027 PrettyStackTraceDecl CrashInfo(const_cast<ValueDecl *>(D), D->getLocation(),
4028 Context.getSourceManager(),
4029 "Generating code for declaration");
4030
4031 if (const auto *FD = dyn_cast<FunctionDecl>(D)) {
4032 // At -O0, don't generate IR for functions with available_externally
4033 // linkage.
4034 if (!shouldEmitFunction(GD))
4035 return;
4036
4037 llvm::TimeTraceScope TimeScope("CodeGen Function", [&]() {
4038 std::string Name;
4039 llvm::raw_string_ostream OS(Name);
4040 FD->getNameForDiagnostic(OS, getContext().getPrintingPolicy(),
4041 /*Qualified=*/true);
4042 return Name;
4043 });
4044
4045 if (const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
4046 // Make sure to emit the definition(s) before we emit the thunks.
4047 // This is necessary for the generation of certain thunks.
4048 if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
4049 ABI->emitCXXStructor(GD);
4050 else if (FD->isMultiVersion())
4051 EmitMultiVersionFunctionDefinition(GD, GV);
4052 else
4053 EmitGlobalFunctionDefinition(GD, GV);
4054
4055 if (Method->isVirtual())
4056 getVTables().EmitThunks(GD);
4057
4058 return;
4059 }
4060
4061 if (FD->isMultiVersion())
4062 return EmitMultiVersionFunctionDefinition(GD, GV);
4063 return EmitGlobalFunctionDefinition(GD, GV);
4064 }
4065
4066 if (const auto *VD = dyn_cast<VarDecl>(D))
4067 return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
4068
4069 llvm_unreachable("Invalid argument to EmitGlobalDefinition()");
4070}
4071
4072static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old,
4073 llvm::Function *NewFn);
4074
4075static unsigned
4077 const CodeGenFunction::MultiVersionResolverOption &RO) {
4078 unsigned Priority = 0;
4079 unsigned NumFeatures = 0;
4080 for (StringRef Feat : RO.Conditions.Features) {
4081 Priority = std::max(Priority, TI.multiVersionSortPriority(Feat));
4082 NumFeatures++;
4083 }
4084
4085 if (!RO.Conditions.Architecture.empty())
4086 Priority = std::max(
4087 Priority, TI.multiVersionSortPriority(RO.Conditions.Architecture));
4088
4089 Priority += TI.multiVersionFeatureCost() * NumFeatures;
4090
4091 return Priority;
4092}
4093
4094// Multiversion functions should be at most 'WeakODRLinkage' so that a different
4095// TU can forward declare the function without causing problems. Particularly
4096// in the cases of CPUDispatch, this causes issues. This also makes sure we
4097// work with internal linkage functions, so that the same function name can be
4098// used with internal linkage in multiple TUs.
4099llvm::GlobalValue::LinkageTypes getMultiversionLinkage(CodeGenModule &CGM,
4100 GlobalDecl GD) {
4101 const FunctionDecl *FD = cast<FunctionDecl>(GD.getDecl());
4103 return llvm::GlobalValue::InternalLinkage;
4104 return llvm::GlobalValue::WeakODRLinkage;
4105}
4106
4109 TypeSourceInfo *TInfo = FD->getTypeSourceInfo();
4110 StorageClass SC = FD->getStorageClass();
4111 DeclarationName Name = FD->getNameInfo().getName();
4112
4113 FunctionDecl *NewDecl =
4114 FunctionDecl::Create(FD->getASTContext(), DeclCtx, FD->getBeginLoc(),
4115 FD->getEndLoc(), Name, TInfo->getType(), TInfo, SC);
4116
4117 NewDecl->setIsMultiVersion();
4118 NewDecl->addAttr(TargetVersionAttr::CreateImplicit(
4119 NewDecl->getASTContext(), "default", NewDecl->getSourceRange()));
4120
4121 return NewDecl;
4122}
4123
4124void CodeGenModule::emitMultiVersionFunctions() {
4125 std::vector<GlobalDecl> MVFuncsToEmit;
4126 MultiVersionFuncs.swap(MVFuncsToEmit);
4127 for (GlobalDecl GD : MVFuncsToEmit) {
4128 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4129 assert(FD && "Expected a FunctionDecl");
4130
4131 auto createFunction = [&](const FunctionDecl *Decl, unsigned MVIdx = 0) {
4132 GlobalDecl CurGD{Decl->isDefined() ? Decl->getDefinition() : Decl, MVIdx};
4133 StringRef MangledName = getMangledName(CurGD);
4134 llvm::Constant *Func = GetGlobalValue(MangledName);
4135 if (!Func) {
4136 if (Decl->isDefined()) {
4137 EmitGlobalFunctionDefinition(CurGD, nullptr);
4138 Func = GetGlobalValue(MangledName);
4139 } else {
4141 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
4142 Func = GetAddrOfFunction(CurGD, Ty, /*ForVTable=*/false,
4143 /*DontDefer=*/false, ForDefinition);
4144 }
4145 assert(Func && "This should have just been created");
4146 }
4147 return cast<llvm::Function>(Func);
4148 };
4149
4150 bool HasDefaultDecl = !FD->isTargetVersionMultiVersion();
4151 bool ShouldEmitResolver =
4152 !getContext().getTargetInfo().getTriple().isAArch64();
4154
4156 FD, [&](const FunctionDecl *CurFD) {
4158
4159 if (const auto *TA = CurFD->getAttr<TargetAttr>()) {
4160 TA->getAddedFeatures(Feats);
4161 llvm::Function *Func = createFunction(CurFD);
4162 Options.emplace_back(Func, TA->getArchitecture(), Feats);
4163 } else if (const auto *TVA = CurFD->getAttr<TargetVersionAttr>()) {
4164 bool HasDefaultDef = TVA->isDefaultVersion() &&
4165 CurFD->doesThisDeclarationHaveABody();
4166 HasDefaultDecl |= TVA->isDefaultVersion();
4167 ShouldEmitResolver |= (CurFD->isUsed() || HasDefaultDef);
4168 TVA->getFeatures(Feats);
4169 llvm::Function *Func = createFunction(CurFD);
4170 Options.emplace_back(Func, /*Architecture*/ "", Feats);
4171 } else if (const auto *TC = CurFD->getAttr<TargetClonesAttr>()) {
4172 ShouldEmitResolver |= CurFD->doesThisDeclarationHaveABody();
4173 for (unsigned I = 0; I < TC->featuresStrs_size(); ++I) {
4174 if (!TC->isFirstOfVersion(I))
4175 continue;
4176
4177 llvm::Function *Func = createFunction(CurFD, I);
4178 StringRef Architecture;
4179 Feats.clear();
4180 if (getTarget().getTriple().isAArch64())
4181 TC->getFeatures(Feats, I);
4182 else {
4183 StringRef Version = TC->getFeatureStr(I);
4184 if (Version.starts_with("arch="))
4185 Architecture = Version.drop_front(sizeof("arch=") - 1);
4186 else if (Version != "default")
4187 Feats.push_back(Version);
4188 }
4189 Options.emplace_back(Func, Architecture, Feats);
4190 }
4191 } else
4192 llvm_unreachable("unexpected MultiVersionKind");
4193 });
4194
4195 if (!ShouldEmitResolver)
4196 continue;
4197
4198 if (!HasDefaultDecl) {
4200 llvm::Function *Func = createFunction(NewFD);
4202 Options.emplace_back(Func, /*Architecture*/ "", Feats);
4203 }
4204
4205 llvm::Constant *ResolverConstant = GetOrCreateMultiVersionResolver(GD);
4206 if (auto *IFunc = dyn_cast<llvm::GlobalIFunc>(ResolverConstant)) {
4207 ResolverConstant = IFunc->getResolver();
4208 if (FD->isTargetClonesMultiVersion() ||
4210 std::string MangledName = getMangledNameImpl(
4211 *this, GD, FD, /*OmitMultiVersionMangling=*/true);
4212 if (!GetGlobalValue(MangledName + ".ifunc")) {
4214 llvm::FunctionType *DeclTy = getTypes().GetFunctionType(FI);
4215 // In prior versions of Clang, the mangling for ifuncs incorrectly
4216 // included an .ifunc suffix. This alias is generated for backward
4217 // compatibility. It is deprecated, and may be removed in the future.
4218 auto *Alias = llvm::GlobalAlias::create(
4219 DeclTy, 0, getMultiversionLinkage(*this, GD),
4220 MangledName + ".ifunc", IFunc, &getModule());
4221 SetCommonAttributes(FD, Alias);
4222 }
4223 }
4224 }
4225 llvm::Function *ResolverFunc = cast<llvm::Function>(ResolverConstant);
4226
4227 ResolverFunc->setLinkage(getMultiversionLinkage(*this, GD));
4228
4229 if (!ResolverFunc->hasLocalLinkage() && supportsCOMDAT())
4230 ResolverFunc->setComdat(
4231 getModule().getOrInsertComdat(ResolverFunc->getName()));
4232
4233 const TargetInfo &TI = getTarget();
4234 llvm::stable_sort(
4235 Options, [&TI](const CodeGenFunction::MultiVersionResolverOption &LHS,
4236 const CodeGenFunction::MultiVersionResolverOption &RHS) {
4237 return TargetMVPriority(TI, LHS) > TargetMVPriority(TI, RHS);
4238 });
4239 CodeGenFunction CGF(*this);
4240 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4241 }
4242
4243 // Ensure that any additions to the deferred decls list caused by emitting a
4244 // variant are emitted. This can happen when the variant itself is inline and
4245 // calls a function without linkage.
4246 if (!MVFuncsToEmit.empty())
4247 EmitDeferred();
4248
4249 // Ensure that any additions to the multiversion funcs list from either the
4250 // deferred decls or the multiversion functions themselves are emitted.
4251 if (!MultiVersionFuncs.empty())
4252 emitMultiVersionFunctions();
4253}
4254
4255void CodeGenModule::emitCPUDispatchDefinition(GlobalDecl GD) {
4256 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4257 assert(FD && "Not a FunctionDecl?");
4258 assert(FD->isCPUDispatchMultiVersion() && "Not a multiversion function?");
4259 const auto *DD = FD->getAttr<CPUDispatchAttr>();
4260 assert(DD && "Not a cpu_dispatch Function?");
4261
4263 llvm::FunctionType *DeclTy = getTypes().GetFunctionType(FI);
4264
4265 StringRef ResolverName = getMangledName(GD);
4266 UpdateMultiVersionNames(GD, FD, ResolverName);
4267
4268 llvm::Type *ResolverType;
4269 GlobalDecl ResolverGD;
4270 if (getTarget().supportsIFunc()) {
4271 ResolverType = llvm::FunctionType::get(
4272 llvm::PointerType::get(DeclTy,
4273 getTypes().getTargetAddressSpace(FD->getType())),
4274 false);
4275 }
4276 else {
4277 ResolverType = DeclTy;
4278 ResolverGD = GD;
4279 }
4280
4281 auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
4282 ResolverName, ResolverType, ResolverGD, /*ForVTable=*/false));
4283 ResolverFunc->setLinkage(getMultiversionLinkage(*this, GD));
4284 if (supportsCOMDAT())
4285 ResolverFunc->setComdat(
4286 getModule().getOrInsertComdat(ResolverFunc->getName()));
4287
4289 const TargetInfo &Target = getTarget();
4290 unsigned Index = 0;
4291 for (const IdentifierInfo *II : DD->cpus()) {
4292 // Get the name of the target function so we can look it up/create it.
4293 std::string MangledName = getMangledNameImpl(*this, GD, FD, true) +
4294 getCPUSpecificMangling(*this, II->getName());
4295
4296 llvm::Constant *Func = GetGlobalValue(MangledName);
4297
4298 if (!Func) {
4299 GlobalDecl ExistingDecl = Manglings.lookup(MangledName);
4300 if (ExistingDecl.getDecl() &&
4301 ExistingDecl.getDecl()->getAsFunction()->isDefined()) {
4302 EmitGlobalFunctionDefinition(ExistingDecl, nullptr);
4303 Func = GetGlobalValue(MangledName);
4304 } else {
4305 if (!ExistingDecl.getDecl())
4306 ExistingDecl = GD.getWithMultiVersionIndex(Index);
4307
4308 Func = GetOrCreateLLVMFunction(
4309 MangledName, DeclTy, ExistingDecl,
4310 /*ForVTable=*/false, /*DontDefer=*/true,
4311 /*IsThunk=*/false, llvm::AttributeList(), ForDefinition);
4312 }
4313 }
4314
4316 Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);
4317 llvm::transform(Features, Features.begin(),
4318 [](StringRef Str) { return Str.substr(1); });
4319 llvm::erase_if(Features, [&Target](StringRef Feat) {
4320 return !Target.validateCpuSupports(Feat);
4321 });
4322 Options.emplace_back(cast<llvm::Function>(Func), StringRef{}, Features);
4323 ++Index;
4324 }
4325
4326 llvm::stable_sort(
4327 Options, [](const CodeGenFunction::MultiVersionResolverOption &LHS,
4328 const CodeGenFunction::MultiVersionResolverOption &RHS) {
4329 return llvm::X86::getCpuSupportsMask(LHS.Conditions.Features) >
4330 llvm::X86::getCpuSupportsMask(RHS.Conditions.Features);
4331 });
4332
4333 // If the list contains multiple 'default' versions, such as when it contains
4334 // 'pentium' and 'generic', don't emit the call to the generic one (since we
4335 // always run on at least a 'pentium'). We do this by deleting the 'least
4336 // advanced' (read, lowest mangling letter).
4337 while (Options.size() > 1 &&
4338 llvm::all_of(llvm::X86::getCpuSupportsMask(
4339 (Options.end() - 2)->Conditions.Features),
4340 [](auto X) { return X == 0; })) {
4341 StringRef LHSName = (Options.end() - 2)->Function->getName();
4342 StringRef RHSName = (Options.end() - 1)->Function->getName();
4343 if (LHSName.compare(RHSName) < 0)
4344 Options.erase(Options.end() - 2);
4345 else
4346 Options.erase(Options.end() - 1);
4347 }
4348
4349 CodeGenFunction CGF(*this);
4350 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4351
4352 if (getTarget().supportsIFunc()) {
4353 llvm::GlobalValue::LinkageTypes Linkage = getMultiversionLinkage(*this, GD);
4354 auto *IFunc = cast<llvm::GlobalValue>(GetOrCreateMultiVersionResolver(GD));
4355
4356 // Fix up function declarations that were created for cpu_specific before
4357 // cpu_dispatch was known
4358 if (!isa<llvm::GlobalIFunc>(IFunc)) {
4359 assert(cast<llvm::Function>(IFunc)->isDeclaration());
4360 auto *GI = llvm::GlobalIFunc::create(DeclTy, 0, Linkage, "", ResolverFunc,
4361 &getModule());
4362 GI->takeName(IFunc);
4363 IFunc->replaceAllUsesWith(GI);
4364 IFunc->eraseFromParent();
4365 IFunc = GI;
4366 }
4367
4368 std::string AliasName = getMangledNameImpl(
4369 *this, GD, FD, /*OmitMultiVersionMangling=*/true);
4370 llvm::Constant *AliasFunc = GetGlobalValue(AliasName);
4371 if (!AliasFunc) {
4372 auto *GA = llvm::GlobalAlias::create(DeclTy, 0, Linkage, AliasName, IFunc,
4373 &getModule());
4374 SetCommonAttributes(GD, GA);
4375 }
4376 }
4377}
4378
4379/// Adds a declaration to the list of multi version functions if not present.
4380void CodeGenModule::AddDeferredMultiVersionResolverToEmit(GlobalDecl GD) {
4381 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4382 assert(FD && "Not a FunctionDecl?");
4383
4385 std::string MangledName =
4386 getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true);
4387 if (!DeferredResolversToEmit.insert(MangledName).second)
4388 return;
4389 }
4390 MultiVersionFuncs.push_back(GD);
4391}
4392
4393/// If a dispatcher for the specified mangled name is not in the module, create
4394/// and return an llvm Function with the specified type.
4395llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(GlobalDecl GD) {
4396 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4397 assert(FD && "Not a FunctionDecl?");
4398
4399 std::string MangledName =
4400 getMangledNameImpl(*this, GD, FD, /*OmitMultiVersionMangling=*/true);
4401
4402 // Holds the name of the resolver, in ifunc mode this is the ifunc (which has
4403 // a separate resolver).
4404 std::string ResolverName = MangledName;
4405 if (getTarget().supportsIFunc()) {
4406 switch (FD->getMultiVersionKind()) {
4408 llvm_unreachable("unexpected MultiVersionKind::None for resolver");
4412 ResolverName += ".ifunc";
4413 break;
4416 break;
4417 }
4418 } else if (FD->isTargetMultiVersion()) {
4419 ResolverName += ".resolver";
4420 }
4421
4422 // If the resolver has already been created, just return it.
4423 if (llvm::GlobalValue *ResolverGV = GetGlobalValue(ResolverName))
4424 return ResolverGV;
4425
4427 llvm::FunctionType *DeclTy = getTypes().GetFunctionType(FI);
4428
4429 // The resolver needs to be created. For target and target_clones, defer
4430 // creation until the end of the TU.
4432 AddDeferredMultiVersionResolverToEmit(GD);
4433
4434 // For cpu_specific, don't create an ifunc yet because we don't know if the
4435 // cpu_dispatch will be emitted in this translation unit.
4436 if (getTarget().supportsIFunc() && !FD->isCPUSpecificMultiVersion()) {
4437 llvm::Type *ResolverType = llvm::FunctionType::get(
4438 llvm::PointerType::get(DeclTy,
4439 getTypes().getTargetAddressSpace(FD->getType())),
4440 false);
4441 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4442 MangledName + ".resolver", ResolverType, GlobalDecl{},
4443 /*ForVTable=*/false);
4444 llvm::GlobalIFunc *GIF =
4445 llvm::GlobalIFunc::create(DeclTy, 0, getMultiversionLinkage(*this, GD),
4446 "", Resolver, &getModule());
4447 GIF->setName(ResolverName);
4448 SetCommonAttributes(FD, GIF);
4449
4450 return GIF;
4451 }
4452
4453 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4454 ResolverName, DeclTy, GlobalDecl{}, /*ForVTable=*/false);
4455 assert(isa<llvm::GlobalValue>(Resolver) &&
4456 "Resolver should be created for the first time");
4457 SetCommonAttributes(FD, cast<llvm::GlobalValue>(Resolver));
4458 return Resolver;
4459}
4460
4461/// GetOrCreateLLVMFunction - If the specified mangled name is not in the
4462/// module, create and return an llvm Function with the specified type. If there
4463/// is something in the module with the specified name, return it potentially
4464/// bitcasted to the right type.
4465///
4466/// If D is non-null, it specifies a decl that correspond to this. This is used
4467/// to set the attributes on the function when it is first created.
4468llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
4469 StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable,
4470 bool DontDefer, bool IsThunk, llvm::AttributeList ExtraAttrs,
4471 ForDefinition_t IsForDefinition) {
4472 const Decl *D = GD.getDecl();
4473
4474 // Any attempts to use a MultiVersion function should result in retrieving
4475 // the iFunc instead. Name Mangling will handle the rest of the changes.
4476 if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
4477 // For the device mark the function as one that should be emitted.
4478 if (getLangOpts().OpenMPIsTargetDevice && OpenMPRuntime &&
4479 !OpenMPRuntime->markAsGlobalTarget(GD) && FD->isDefined() &&
4480 !DontDefer && !IsForDefinition) {
4481 if (const FunctionDecl *FDDef = FD->getDefinition()) {
4482 GlobalDecl GDDef;
4483 if (const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
4484 GDDef = GlobalDecl(CD, GD.getCtorType());
4485 else if (const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
4486 GDDef = GlobalDecl(DD, GD.getDtorType());
4487 else
4488 GDDef = GlobalDecl(FDDef);
4489 EmitGlobal(GDDef);
4490 }
4491 }
4492
4493 if (FD->isMultiVersion()) {
4494 UpdateMultiVersionNames(GD, FD, MangledName);
4495 if (FD->getASTContext().getTargetInfo().getTriple().isAArch64() &&
4496 !FD->isUsed())
4497 AddDeferredMultiVersionResolverToEmit(GD);
4498 else if (!IsForDefinition)
4499 return GetOrCreateMultiVersionResolver(GD);
4500 }
4501 }
4502
4503 // Lookup the entry, lazily creating it if necessary.
4504 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
4505 if (Entry) {
4506 if (WeakRefReferences.erase(Entry)) {
4507 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
4508 if (FD && !FD->hasAttr<WeakAttr>())
4509 Entry->setLinkage(llvm::Function::ExternalLinkage);
4510 }
4511
4512 // Handle dropped DLL attributes.
4513 if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>() &&
4514 !shouldMapVisibilityToDLLExport(cast_or_null<NamedDecl>(D))) {
4515 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4516 setDSOLocal(Entry);
4517 }
4518
4519 // If there are two attempts to define the same mangled name, issue an
4520 // error.
4521 if (IsForDefinition && !Entry->isDeclaration()) {
4522 GlobalDecl OtherGD;
4523 // Check that GD is not yet in DiagnosedConflictingDefinitions is required
4524 // to make sure that we issue an error only once.
4525 if (lookupRepresentativeDecl(MangledName, OtherGD) &&
4526 (GD.getCanonicalDecl().getDecl() !=
4527 OtherGD.getCanonicalDecl().getDecl()) &&
4528 DiagnosedConflictingDefinitions.insert(GD).second) {
4529 getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name)
4530 << MangledName;
4531 getDiags().Report(OtherGD.getDecl()->getLocation(),
4532 diag::note_previous_definition);
4533 }
4534 }
4535
4536 if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
4537 (Entry->getValueType() == Ty)) {
4538 return Entry;
4539 }
4540
4541 // Make sure the result is of the correct type.
4542 // (If function is requested for a definition, we always need to create a new
4543 // function, not just return a bitcast.)
4544 if (!IsForDefinition)
4545 return Entry;
4546 }
4547
4548 // This function doesn't have a complete type (for example, the return
4549 // type is an incomplete struct). Use a fake type instead, and make
4550 // sure not to try to set attributes.
4551 bool IsIncompleteFunction = false;
4552
4553 llvm::FunctionType *FTy;
4554 if (isa<llvm::FunctionType>(Ty)) {
4555 FTy = cast<llvm::FunctionType>(Ty);
4556 } else {
4557 FTy = llvm::FunctionType::get(VoidTy, false);
4558 IsIncompleteFunction = true;
4559 }
4560
4561 llvm::Function *F =
4562 llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
4563 Entry ? StringRef() : MangledName, &getModule());
4564
4565 // Store the declaration associated with this function so it is potentially
4566 // updated by further declarations or definitions and emitted at the end.
4567 if (D && D->hasAttr<AnnotateAttr>())
4568 DeferredAnnotations[MangledName] = cast<ValueDecl>(D);
4569
4570 // If we already created a function with the same mangled name (but different
4571 // type) before, take its name and add it to the list of functions to be
4572 // replaced with F at the end of CodeGen.
4573 //
4574 // This happens if there is a prototype for a function (e.g. "int f()") and
4575 // then a definition of a different type (e.g. "int f(int x)").
4576 if (Entry) {
4577 F->takeName(Entry);
4578
4579 // This might be an implementation of a function without a prototype, in
4580 // which case, try to do special replacement of calls which match the new
4581 // prototype. The really key thing here is that we also potentially drop
4582 // arguments from the call site so as to make a direct call, which makes the
4583 // inliner happier and suppresses a number of optimizer warnings (!) about
4584 // dropping arguments.
4585 if (!Entry->use_empty()) {
4587 Entry->removeDeadConstantUsers();
4588 }
4589
4590 addGlobalValReplacement(Entry, F);
4591 }
4592
4593 assert(F->getName() == MangledName && "name was uniqued!");
4594 if (D)
4595 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
4596 if (ExtraAttrs.hasFnAttrs()) {
4597 llvm::AttrBuilder B(F->getContext(), ExtraAttrs.getFnAttrs());
4598 F->addFnAttrs(B);
4599 }
4600
4601 if (!DontDefer) {
4602 // All MSVC dtors other than the base dtor are linkonce_odr and delegate to
4603 // each other bottoming out with the base dtor. Therefore we emit non-base
4604 // dtors on usage, even if there is no dtor definition in the TU.
4605 if (isa_and_nonnull<CXXDestructorDecl>(D) &&
4606 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
4607 GD.getDtorType()))
4608 addDeferredDeclToEmit(GD);
4609
4610 // This is the first use or definition of a mangled name. If there is a
4611 // deferred decl with this name, remember that we need to emit it at the end
4612 // of the file.
4613 auto DDI = DeferredDecls.find(MangledName);
4614 if (DDI != DeferredDecls.end()) {
4615 // Move the potentially referenced deferred decl to the
4616 // DeferredDeclsToEmit list, and remove it from DeferredDecls (since we
4617 // don't need it anymore).
4618 addDeferredDeclToEmit(DDI->second);
4619 DeferredDecls.erase(DDI);
4620
4621 // Otherwise, there are cases we have to worry about where we're
4622 // using a declaration for which we must emit a definition but where
4623 // we might not find a top-level definition:
4624 // - member functions defined inline in their classes
4625 // - friend functions defined inline in some class
4626 // - special member functions with implicit definitions
4627 // If we ever change our AST traversal to walk into class methods,
4628 // this will be unnecessary.
4629 //
4630 // We also don't emit a definition for a function if it's going to be an
4631 // entry in a vtable, unless it's already marked as used.
4632 } else if (getLangOpts().CPlusPlus && D) {
4633 // Look for a declaration that's lexically in a record.
4634 for (const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
4635 FD = FD->getPreviousDecl()) {
4636 if (isa<CXXRecordDecl>(FD->getLexicalDeclContext())) {
4637 if (FD->doesThisDeclarationHaveABody()) {
4638 addDeferredDeclToEmit(GD.getWithDecl(FD));
4639 break;
4640 }
4641 }
4642 }
4643 }
4644 }
4645
4646 // Make sure the result is of the requested type.
4647 if (!IsIncompleteFunction) {
4648 assert(F->getFunctionType() == Ty);
4649 return F;
4650 }
4651
4652 return F;
4653}
4654
4655/// GetAddrOfFunction - Return the address of the given function. If Ty is
4656/// non-null, then this function will use the specified type if it has to
4657/// create it (this occurs when we see a definition of the function).
4658llvm::Constant *
4659CodeGenModule::GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty, bool ForVTable,
4660 bool DontDefer,
4661 ForDefinition_t IsForDefinition) {
4662 // If there was no specific requested type, just convert it now.
4663 if (!Ty) {
4664 const auto *FD = cast<FunctionDecl>(GD.getDecl());
4665 Ty = getTypes().ConvertType(FD->getType());
4666 }
4667
4668 // Devirtualized destructor calls may come through here instead of via
4669 // getAddrOfCXXStructor. Make sure we use the MS ABI base destructor instead
4670 // of the complete destructor when necessary.
4671 if (const auto *DD = dyn_cast<CXXDestructorDecl>(GD.getDecl())) {
4672 if (getTarget().getCXXABI().isMicrosoft() &&
4673 GD.getDtorType() == Dtor_Complete &&
4674 DD->getParent()->getNumVBases() == 0)
4675 GD = GlobalDecl(DD, Dtor_Base);
4676 }
4677
4678 StringRef MangledName = getMangledName(GD);
4679 auto *F = GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
4680 /*IsThunk=*/false, llvm::AttributeList(),
4681 IsForDefinition);
4682 // Returns kernel handle for HIP kernel stub function.
4683 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
4684 cast<FunctionDecl>(GD.getDecl())->hasAttr<CUDAGlobalAttr>()) {
4685 auto *Handle = getCUDARuntime().getKernelHandle(
4686 cast<llvm::Function>(F->stripPointerCasts()), GD);
4687 if (IsForDefinition)
4688 return F;
4689 return Handle;
4690 }
4691 return F;
4692}
4693
4695 llvm::GlobalValue *F =
4696 cast<llvm::GlobalValue>(GetAddrOfFunction(Decl)->stripPointerCasts());
4697
4698 return llvm::NoCFIValue::get(F);
4699}
4700
4701static const FunctionDecl *
4703 TranslationUnitDecl *TUDecl = C.getTranslationUnitDecl();
4705
4706 IdentifierInfo &CII = C.Idents.get(Name);
4707 for (const auto *Result : DC->lookup(&CII))
4708 if (const auto *FD = dyn_cast<FunctionDecl>(Result))
4709 return FD;
4710
4711 if (!C.getLangOpts().CPlusPlus)
4712 return nullptr;
4713
4714 // Demangle the premangled name from getTerminateFn()
4715 IdentifierInfo &CXXII =
4716 (Name == "_ZSt9terminatev" || Name == "?terminate@@YAXXZ")
4717 ? C.Idents.get("terminate")
4718 : C.Idents.get(Name);
4719
4720 for (const auto &N : {"__cxxabiv1", "std"}) {
4721 IdentifierInfo &NS = C.Idents.get(N);
4722 for (const auto *Result : DC->lookup(&NS)) {
4723 const NamespaceDecl *ND = dyn_cast<NamespaceDecl>(Result);
4724 if (auto *LSD = dyn_cast<LinkageSpecDecl>(Result))
4725 for (const auto *Result : LSD->lookup(&NS))
4726 if ((ND = dyn_cast<NamespaceDecl>(Result)))
4727 break;
4728
4729 if (ND)
4730 for (const auto *Result : ND->lookup(&CXXII))
4731 if (const auto *FD = dyn_cast<FunctionDecl>(Result))
4732 return FD;
4733 }
4734 }
4735
4736 return nullptr;
4737}
4738
4739/// CreateRuntimeFunction - Create a new runtime function with the specified
4740/// type and name.
4741llvm::FunctionCallee
4742CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name,
4743 llvm::AttributeList ExtraAttrs, bool Local,
4744 bool AssumeConvergent) {
4745 if (AssumeConvergent) {
4746 ExtraAttrs =
4747 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
4748 }
4749
4750 llvm::Constant *C =
4751 GetOrCreateLLVMFunction(Name, FTy, GlobalDecl(), /*ForVTable=*/false,
4752 /*DontDefer=*/false, /*IsThunk=*/false,
4753 ExtraAttrs);
4754
4755 if (auto *F = dyn_cast<llvm::Function>(C)) {
4756 if (F->empty()) {
4757 F->setCallingConv(getRuntimeCC());
4758
4759 // In Windows Itanium environments, try to mark runtime functions
4760 // dllimport. For Mingw and MSVC, don't. We don't really know if the user
4761 // will link their standard library statically or dynamically. Marking
4762 // functions imported when they are not imported can cause linker errors
4763 // and warnings.
4764 if (!Local && getTriple().isWindowsItaniumEnvironment() &&
4765 !getCodeGenOpts().LTOVisibilityPublicStd) {
4766 const FunctionDecl *FD = GetRuntimeFunctionDecl(Context, Name);
4767 if (!FD || FD->hasAttr<DLLImportAttr>()) {
4768 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
4769 F->setLinkage(llvm::GlobalValue::ExternalLinkage);
4770 }
4771 }
4772 setDSOLocal(F);
4773 }
4774 }
4775
4776 return {FTy, C};
4777}
4778
4779/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module,
4780/// create and return an llvm GlobalVariable with the specified type and address
4781/// space. If there is something in the module with the specified name, return
4782/// it potentially bitcasted to the right type.
4783///
4784/// If D is non-null, it specifies a decl that correspond to this. This is used
4785/// to set the attributes on the global when it is first created.
4786///
4787/// If IsForDefinition is true, it is guaranteed that an actual global with
4788/// type Ty will be returned, not conversion of a variable with the same
4789/// mangled name but some other type.
4790llvm::Constant *
4791CodeGenModule::GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty,
4792 LangAS AddrSpace, const VarDecl *D,
4793 ForDefinition_t IsForDefinition) {
4794 // Lookup the entry, lazily creating it if necessary.
4795 llvm::GlobalValue *Entry = GetGlobalValue(MangledName);
4796 unsigned TargetAS = getContext().getTargetAddressSpace(AddrSpace);
4797 if (Entry) {
4798 if (WeakRefReferences.erase(Entry)) {
4799 if (D && !D->hasAttr<WeakAttr>())
4800 Entry->setLinkage(llvm::Function::ExternalLinkage);
4801 }
4802
4803 // Handle dropped DLL attributes.
4804 if (D && !D->hasAttr<DLLImportAttr>() && !D->hasAttr<DLLExportAttr>() &&
4806 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4807
4808 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd && D)
4810
4811 if (Entry->getValueType() == Ty && Entry->getAddressSpace() == TargetAS)
4812 return Entry;
4813
4814 // If there are two attempts to define the same mangled name, issue an
4815 // error.
4816 if (IsForDefinition && !Entry->isDeclaration()) {
4817 GlobalDecl OtherGD;
4818 const VarDecl *OtherD;
4819
4820 // Check that D is not yet in DiagnosedConflictingDefinitions is required
4821 // to make sure that we issue an error only once.
4822 if (D && lookupRepresentativeDecl(MangledName, OtherGD) &&
4823 (D->getCanonicalDecl() != OtherGD.getCanonicalDecl().getDecl()) &&
4824 (OtherD = dyn_cast<VarDecl>(OtherGD.getDecl())) &&
4825 OtherD->hasInit() &&
4826 DiagnosedConflictingDefinitions.insert(D).second) {
4827 getDiags().Report(D->getLocation(), diag::err_duplicate_mangled_name)
4828 << MangledName;
4829 getDiags().Report(OtherGD.getDecl()->getLocation(),
4830 diag::note_previous_definition);
4831 }
4832 }
4833
4834 // Make sure the result is of the correct type.
4835 if (Entry->getType()->getAddressSpace() != TargetAS)
4836 return llvm::ConstantExpr::getAddrSpaceCast(
4837 Entry, llvm::PointerType::get(Ty->getContext(), TargetAS));
4838
4839 // (If global is requested for a definition, we always need to create a new
4840 // global, not just return a bitcast.)
4841 if (!IsForDefinition)
4842 return Entry;
4843 }
4844
4845 auto DAddrSpace = GetGlobalVarAddressSpace(D);
4846
4847 auto *GV = new llvm::GlobalVariable(
4848 getModule(), Ty, false, llvm::GlobalValue::ExternalLinkage, nullptr,
4849 MangledName, nullptr, llvm::GlobalVariable::NotThreadLocal,
4850 getContext().getTargetAddressSpace(DAddrSpace));
4851
4852 // If we already created a global with the same mangled name (but different
4853 // type) before, take its name and remove it from its parent.
4854 if (Entry) {
4855 GV->takeName(Entry);
4856
4857 if (!Entry->use_empty()) {
4858 Entry->replaceAllUsesWith(GV);
4859 }
4860
4861 Entry->eraseFromParent();
4862 }
4863
4864 // This is the first use or definition of a mangled name. If there is a
4865 // deferred decl with this name, remember that we need to emit it at the end
4866 // of the file.
4867 auto DDI = DeferredDecls.find(MangledName);
4868 if (DDI != DeferredDecls.end()) {
4869 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit
4870 // list, and remove it from DeferredDecls (since we don't need it anymore).
4871 addDeferredDeclToEmit(DDI->second);
4872 DeferredDecls.erase(DDI);
4873 }
4874
4875 // Handle things which are present even on external declarations.
4876 if (D) {
4877 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
4879
4880 // FIXME: This code is overly simple and should be merged with other global
4881 // handling.
4882 GV->setConstant(D->getType().isConstantStorage(getContext(), false, false));
4883
4884 GV->setAlignment(getContext().getDeclAlign(D).getAsAlign());
4885
4886 setLinkageForGV(GV, D);
4887
4888 if (D->getTLSKind()) {
4889 if (D->getTLSKind() == VarDecl::TLS_Dynamic)
4890 CXXThreadLocals.push_back(D);
4891 setTLSMode(GV, *D);
4892 }
4893
4894 setGVProperties(GV, D);
4895
4896 // If required by the ABI, treat declarations of static data members with
4897 // inline initializers as definitions.
4898 if (getContext().isMSStaticDataMemberInlineDefinition(D)) {
4899 EmitGlobalVarDefinition(D);
4900 }
4901
4902 // Emit section information for extern variables.
4903 if (D->hasExternalStorage()) {
4904 if (const SectionAttr *SA = D->getAttr<SectionAttr>())
4905 GV->setSection(SA->getName());
4906 }
4907
4908 // Handle XCore specific ABI requirements.
4909 if (getTriple().getArch() == llvm::Triple::xcore &&
4911 D->getType().isConstant(Context) &&
4913 GV->setSection(".cp.rodata");
4914
4915 // Handle code model attribute
4916 if (const auto *CMA = D->getAttr<CodeModelAttr>())
4917 GV->setCodeModel(CMA->getModel());
4918
4919 // Check if we a have a const declaration with an initializer, we may be
4920 // able to emit it as available_externally to expose it's value to the
4921 // optimizer.
4922 if (Context.getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
4923 D->getType().isConstQualified() && !GV->hasInitializer() &&
4924 !D->hasDefinition() && D->hasInit() && !D->hasAttr<DLLImportAttr>()) {
4925 const auto *Record =
4927 bool HasMutableFields = Record && Record->hasMutableFields();
4928 if (!HasMutableFields) {
4929 const VarDecl *InitDecl;
4930 const Expr *InitExpr = D->getAnyInitializer(InitDecl);
4931 if (InitExpr) {
4932 ConstantEmitter emitter(*this);
4933 llvm::Constant *Init = emitter.tryEmitForInitializer(*InitDecl);
4934 if (Init) {
4935 auto *InitType = Init->getType();
4936 if (GV->getValueType() != InitType) {
4937 // The type of the initializer does not match the definition.
4938 // This happens when an initializer has a different type from
4939 // the type of the global (because of padding at the end of a
4940 // structure for instance).
4941 GV->setName(StringRef());
4942 // Make a new global with the correct type, this is now guaranteed
4943 // to work.
4944 auto *NewGV = cast<llvm::GlobalVariable>(
4945 GetAddrOfGlobalVar(D, InitType, IsForDefinition)
4946 ->stripPointerCasts());
4947
4948 // Erase the old global, since it is no longer used.
4949 GV->eraseFromParent();
4950 GV = NewGV;
4951 } else {
4952 GV->setInitializer(Init);
4953 GV->setConstant(true);
4954 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
4955 }
4956 emitter.finalize(GV);
4957 }
4958 }
4959 }
4960 }
4961 }
4962
4963 if (D &&
4966 // External HIP managed variables needed to be recorded for transformation
4967 // in both device and host compilations.
4968 if (getLangOpts().CUDA && D && D->hasAttr<HIPManagedAttr>() &&
4969 D->hasExternalStorage())
4971 }
4972
4973 if (D)
4974 SanitizerMD->reportGlobal(GV, *D);
4975
4976 LangAS ExpectedAS =
4977 D ? D->getType().getAddressSpace()
4978 : (LangOpts.OpenCL ? LangAS::opencl_global : LangAS::Default);
4979 assert(getContext().getTargetAddressSpace(ExpectedAS) == TargetAS);
4980 if (DAddrSpace != ExpectedAS) {
4982 *this, GV, DAddrSpace, ExpectedAS,
4983 llvm::PointerType::get(getLLVMContext(), TargetAS));
4984 }
4985
4986 return GV;
4987}
4988
4989llvm::Constant *
4991 const Decl *D = GD.getDecl();
4992
4993 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
4994 return getAddrOfCXXStructor(GD, /*FnInfo=*/nullptr, /*FnType=*/nullptr,
4995 /*DontDefer=*/false, IsForDefinition);
4996
4997 if (isa<CXXMethodDecl>(D)) {
4998 auto FInfo =
4999 &getTypes().arrangeCXXMethodDeclaration(cast<CXXMethodDecl>(D));
5000 auto Ty = getTypes().GetFunctionType(*FInfo);
5001 return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
5002 IsForDefinition);
5003 }
5004
5005 if (isa<FunctionDecl>(D)) {
5007 llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
5008 return GetAddrOfFunction(GD, Ty, /*ForVTable=*/false, /*DontDefer=*/false,
5009 IsForDefinition);
5010 }
5011
5012 return GetAddrOfGlobalVar(cast<VarDecl>(D), /*Ty=*/nullptr, IsForDefinition);
5013}
5014
5016 StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage,
5017 llvm::Align Alignment) {
5018 llvm::GlobalVariable *GV = getModule().getNamedGlobal(Name);
5019 llvm::GlobalVariable *OldGV = nullptr;
5020
5021 if (GV) {
5022 // Check if the variable has the right type.
5023 if (GV->getValueType() == Ty)
5024 return GV;
5025
5026 // Because C++ name mangling, the only way we can end up with an already
5027 // existing global with the same name is if it has been declared extern "C".
5028 assert(GV->isDeclaration() && "Declaration has wrong type!");
5029 OldGV = GV;
5030 }
5031
5032 // Create a new variable.
5033 GV = new llvm::GlobalVariable(getModule(), Ty, /*isConstant=*/true,
5034 Linkage, nullptr, Name);
5035
5036 if (OldGV) {
5037 // Replace occurrences of the old variable if needed.
5038 GV->takeName(OldGV);
5039
5040 if (!OldGV->use_empty()) {
5041 OldGV->replaceAllUsesWith(GV);
5042 }
5043
5044 OldGV->eraseFromParent();
5045 }
5046
5047 if (supportsCOMDAT() && GV->isWeakForLinker() &&
5048 !GV->hasAvailableExternallyLinkage())
5049 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
5050
5051 GV->setAlignment(Alignment);
5052
5053 return GV;
5054}
5055
5056/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the
5057/// given global variable. If Ty is non-null and if the global doesn't exist,
5058/// then it will be created with the specified type instead of whatever the
5059/// normal requested type would be. If IsForDefinition is true, it is guaranteed
5060/// that an actual global with type Ty will be returned, not conversion of a
5061/// variable with the same mangled name but some other type.
5063 llvm::Type *Ty,
5064 ForDefinition_t IsForDefinition) {
5065 assert(D->hasGlobalStorage() && "Not a global variable");
5066 QualType ASTTy = D->getType();
5067 if (!Ty)
5068 Ty = getTypes().ConvertTypeForMem(ASTTy);
5069
5070 StringRef MangledName = getMangledName(D);
5071 return GetOrCreateLLVMGlobal(MangledName, Ty, ASTTy.getAddressSpace(), D,
5072 IsForDefinition);
5073}
5074
5075/// CreateRuntimeVariable - Create a new runtime global variable with the
5076/// specified type and name.
5077llvm::Constant *
5079 StringRef Name) {
5080 LangAS AddrSpace = getContext().getLangOpts().OpenCL ? LangAS::opencl_global
5082 auto *Ret = GetOrCreateLLVMGlobal(Name, Ty, AddrSpace, nullptr);
5083 setDSOLocal(cast<llvm::GlobalValue>(Ret->stripPointerCasts()));
5084 return Ret;
5085}
5086
5088 assert(!D->getInit() && "Cannot emit definite definitions here!");
5089
5090 StringRef MangledName = getMangledName(D);
5091 llvm::GlobalValue *GV = GetGlobalValue(MangledName);
5092
5093 // We already have a definition, not declaration, with the same mangled name.
5094 // Emitting of declaration is not required (and actually overwrites emitted
5095 // definition).
5096 if (GV && !GV->isDeclaration())
5097 return;
5098
5099 // If we have not seen a reference to this variable yet, place it into the
5100 // deferred declarations table to be emitted if needed later.
5101 if (!MustBeEmitted(D) && !GV) {
5102 DeferredDecls[MangledName] = D;
5103 return;
5104 }
5105
5106 // The tentative definition is the only definition.
5107 EmitGlobalVarDefinition(D);
5108}
5109
5111 EmitExternalVarDeclaration(D);
5112}
5113
5115 return Context.toCharUnitsFromBits(
5116 getDataLayout().getTypeStoreSizeInBits(Ty));
5117}
5118
5120 if (LangOpts.OpenCL) {
5122 assert(AS == LangAS::opencl_global ||
5126 AS == LangAS::opencl_local ||
5128 return AS;
5129 }
5130
5131 if (LangOpts.SYCLIsDevice &&
5132 (!D || D->getType().getAddressSpace() == LangAS::Default))
5133 return LangAS::sycl_global;
5134
5135 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
5136 if (D) {
5137 if (D->hasAttr<CUDAConstantAttr>())
5138 return LangAS::cuda_constant;
5139 if (D->hasAttr<CUDASharedAttr>())
5140 return LangAS::cuda_shared;
5141 if (D->hasAttr<CUDADeviceAttr>())
5142 return LangAS::cuda_device;
5143 if (D->getType().isConstQualified())
5144 return LangAS::cuda_constant;
5145 }
5146 return LangAS::cuda_device;
5147 }
5148
5149 if (LangOpts.OpenMP) {
5150 LangAS AS;
5151 if (OpenMPRuntime->hasAllocateAttributeForGlobalVar(D, AS))
5152 return AS;
5153 }
5155}
5156
5158 // OpenCL v1.2 s6.5.3: a string literal is in the constant address space.
5159 if (LangOpts.OpenCL)
5161 if (LangOpts.SYCLIsDevice)
5162 return LangAS::sycl_global;
5163 if (LangOpts.HIP && LangOpts.CUDAIsDevice && getTriple().isSPIRV())
5164 // For HIPSPV map literals to cuda_device (maps to CrossWorkGroup in SPIR-V)
5165 // instead of default AS (maps to Generic in SPIR-V). Otherwise, we end up
5166 // with OpVariable instructions with Generic storage class which is not
5167 // allowed (SPIR-V V1.6 s3.42.8). Also, mapping literals to SPIR-V
5168 // UniformConstant storage class is not viable as pointers to it may not be
5169 // casted to Generic pointers which are used to model HIP's "flat" pointers.
5170 return LangAS::cuda_device;
5171 if (auto AS = getTarget().getConstantAddressSpace())
5172 return *AS;
5173 return LangAS::Default;
5174}
5175
5176// In address space agnostic languages, string literals are in default address
5177// space in AST. However, certain targets (e.g. amdgcn) request them to be
5178// emitted in constant address space in LLVM IR. To be consistent with other
5179// parts of AST, string literal global variables in constant address space
5180// need to be casted to default address space before being put into address
5181// map and referenced by other part of CodeGen.
5182// In OpenCL, string literals are in constant address space in AST, therefore
5183// they should not be casted to default address space.
5184static llvm::Constant *
5186 llvm::GlobalVariable *GV) {
5187 llvm::Constant *Cast = GV;
5188 if (!CGM.getLangOpts().OpenCL) {
5189 auto AS = CGM.GetGlobalConstantAddressSpace();
5190 if (AS != LangAS::Default)
5192 CGM, GV, AS, LangAS::Default,
5193 llvm::PointerType::get(
5194 CGM.getLLVMContext(),
5196 }
5197 return Cast;
5198}
5199
5200template<typename SomeDecl>
5202 llvm::GlobalValue *GV) {
5203 if (!getLangOpts().CPlusPlus)
5204 return;
5205
5206 // Must have 'used' attribute, or else inline assembly can't rely on
5207 // the name existing.
5208 if (!D->template hasAttr<UsedAttr>())
5209 return;
5210
5211 // Must have internal linkage and an ordinary name.
5212 if (!D->getIdentifier() || D->getFormalLinkage() != Linkage::Internal)
5213 return;
5214
5215 // Must be in an extern "C" context. Entities declared directly within
5216 // a record are not extern "C" even if the record is in such a context.
5217 const SomeDecl *First = D->getFirstDecl();
5218 if (First->getDeclContext()->isRecord() || !First->isInExternCContext())
5219 return;
5220
5221 // OK, this is an internal linkage entity inside an extern "C" linkage
5222 // specification. Make a note of that so we can give it the "expected"
5223 // mangled name if nothing else is using that name.
5224 std::pair<StaticExternCMap::iterator, bool> R =
5225 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
5226
5227 // If we have multiple internal linkage entities with the same name
5228 // in extern "C" regions, none of them gets that name.
5229 if (!R.second)
5230 R.first->second = nullptr;
5231}
5232
5233static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D) {
5234 if (!CGM.supportsCOMDAT())
5235 return false;
5236
5237 if (D.hasAttr<SelectAnyAttr>())
5238 return