50#include "llvm/ADT/STLExtras.h"
51#include "llvm/ADT/StringExtras.h"
52#include "llvm/ADT/StringSwitch.h"
53#include "llvm/Analysis/TargetLibraryInfo.h"
54#include "llvm/BinaryFormat/ELF.h"
55#include "llvm/IR/AttributeMask.h"
56#include "llvm/IR/CallingConv.h"
57#include "llvm/IR/DataLayout.h"
58#include "llvm/IR/Intrinsics.h"
59#include "llvm/IR/LLVMContext.h"
60#include "llvm/IR/Module.h"
61#include "llvm/IR/ProfileSummary.h"
62#include "llvm/ProfileData/InstrProfReader.h"
63#include "llvm/ProfileData/SampleProf.h"
64#include "llvm/Support/CRC.h"
65#include "llvm/Support/CodeGen.h"
66#include "llvm/Support/CommandLine.h"
67#include "llvm/Support/ConvertUTF.h"
68#include "llvm/Support/ErrorHandling.h"
69#include "llvm/Support/TimeProfiler.h"
70#include "llvm/Support/xxhash.h"
71#include "llvm/TargetParser/RISCVISAInfo.h"
72#include "llvm/TargetParser/Triple.h"
73#include "llvm/TargetParser/X86TargetParser.h"
74#include "llvm/Transforms/Utils/BuildLibCalls.h"
79using namespace CodeGen;
82 "limited-coverage-experimental", llvm::cl::Hidden,
83 llvm::cl::desc(
"Emit limited coverage mapping information (experimental)"));
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:
100 case TargetCXXABI::Microsoft:
104 llvm_unreachable(
"invalid C++ ABI kind");
107static std::unique_ptr<TargetCodeGenInfo>
113 switch (Triple.getArch()) {
117 case llvm::Triple::m68k:
119 case llvm::Triple::mips:
120 case llvm::Triple::mipsel:
121 if (Triple.getOS() == llvm::Triple::NaCl)
125 case llvm::Triple::mips64:
126 case llvm::Triple::mips64el:
129 case llvm::Triple::avr: {
133 unsigned NPR =
Target.getABI() ==
"avrtiny" ? 6 : 18;
134 unsigned NRR =
Target.getABI() ==
"avrtiny" ? 4 : 8;
138 case llvm::Triple::aarch64:
139 case llvm::Triple::aarch64_32:
140 case llvm::Triple::aarch64_be: {
142 if (
Target.getABI() ==
"darwinpcs")
143 Kind = AArch64ABIKind::DarwinPCS;
144 else if (Triple.isOSWindows())
146 else if (
Target.getABI() ==
"aapcs-soft")
147 Kind = AArch64ABIKind::AAPCSSoft;
148 else if (
Target.getABI() ==
"pauthtest")
149 Kind = AArch64ABIKind::PAuthTest;
154 case llvm::Triple::wasm32:
155 case llvm::Triple::wasm64: {
157 if (
Target.getABI() ==
"experimental-mv")
158 Kind = WebAssemblyABIKind::ExperimentalMV;
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)
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" && Triple.isHardFloatABI()))
177 Kind = ARMABIKind::AAPCS_VFP;
182 case llvm::Triple::ppc: {
183 if (Triple.isOSAIX())
190 case llvm::Triple::ppcle: {
191 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
194 case llvm::Triple::ppc64:
195 if (Triple.isOSAIX())
198 if (Triple.isOSBinFormatELF()) {
200 if (
Target.getABI() ==
"elfv2")
201 Kind = PPC64_SVR4_ABIKind::ELFv2;
202 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
207 case llvm::Triple::ppc64le: {
208 assert(Triple.isOSBinFormatELF() &&
"PPC64 LE non-ELF not supported!");
210 if (
Target.getABI() ==
"elfv1")
211 Kind = PPC64_SVR4_ABIKind::ELFv1;
212 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
217 case llvm::Triple::nvptx:
218 case llvm::Triple::nvptx64:
221 case llvm::Triple::msp430:
224 case llvm::Triple::riscv32:
225 case llvm::Triple::riscv64: {
226 StringRef ABIStr =
Target.getABI();
227 unsigned XLen =
Target.getPointerWidth(LangAS::Default);
228 unsigned ABIFLen = 0;
229 if (ABIStr.ends_with(
"f"))
231 else if (ABIStr.ends_with(
"d"))
233 bool EABI = ABIStr.ends_with(
"e");
237 case llvm::Triple::systemz: {
238 bool SoftFloat = CodeGenOpts.
FloatABI ==
"soft";
239 bool HasVector = !SoftFloat &&
Target.getABI() ==
"vector";
243 case llvm::Triple::tce:
244 case llvm::Triple::tcele:
247 case llvm::Triple::x86: {
248 bool IsDarwinVectorABI = Triple.isOSDarwin();
249 bool IsWin32FloatStructABI = Triple.isOSWindows() && !Triple.isOSCygMing();
251 if (Triple.getOS() == llvm::Triple::Win32) {
253 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
254 CodeGenOpts.NumRegisterParameters);
257 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
258 CodeGenOpts.NumRegisterParameters, CodeGenOpts.
FloatABI ==
"soft");
261 case llvm::Triple::x86_64: {
262 StringRef ABI =
Target.getABI();
263 X86AVXABILevel AVXLevel = (ABI ==
"avx512" ? X86AVXABILevel::AVX512
264 : ABI ==
"avx" ? X86AVXABILevel::AVX
265 : X86AVXABILevel::None);
267 switch (Triple.getOS()) {
268 case llvm::Triple::Win32:
274 case llvm::Triple::hexagon:
276 case llvm::Triple::lanai:
278 case llvm::Triple::r600:
280 case llvm::Triple::amdgcn:
282 case llvm::Triple::sparc:
284 case llvm::Triple::sparcv9:
286 case llvm::Triple::xcore:
288 case llvm::Triple::arc:
290 case llvm::Triple::spir:
291 case llvm::Triple::spir64:
293 case llvm::Triple::spirv32:
294 case llvm::Triple::spirv64:
295 case llvm::Triple::spirv:
297 case llvm::Triple::dxil:
299 case llvm::Triple::ve:
301 case llvm::Triple::csky: {
302 bool IsSoftFloat = !
Target.hasFeature(
"hard-float-abi");
304 Target.hasFeature(
"fpuv2_df") ||
Target.hasFeature(
"fpuv3_df");
309 case llvm::Triple::bpfeb:
310 case llvm::Triple::bpfel:
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"))
318 else if (ABIStr.ends_with(
"d"))
321 CGM,
Target.getPointerWidth(LangAS::Default), ABIFRLen);
327 if (!TheTargetCodeGenInfo)
329 return *TheTargetCodeGenInfo;
339 : Context(
C), LangOpts(
C.getLangOpts()), FS(FS), HeaderSearchOpts(HSO),
340 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
342 VMContext(M.getContext()), VTables(*this), StackHandler(diags),
347 llvm::LLVMContext &LLVMContext = M.getContext();
348 VoidTy = llvm::Type::getVoidTy(LLVMContext);
349 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
350 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
351 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
352 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
353 HalfTy = llvm::Type::getHalfTy(LLVMContext);
354 BFloatTy = llvm::Type::getBFloatTy(LLVMContext);
355 FloatTy = llvm::Type::getFloatTy(LLVMContext);
356 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
362 C.toCharUnitsFromBits(
C.getTargetInfo().getMaxPointerWidth()).getQuantity();
364 C.toCharUnitsFromBits(
C.getTargetInfo().getIntAlign()).getQuantity();
366 llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getCharWidth());
367 IntTy = llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getIntWidth());
368 IntPtrTy = llvm::IntegerType::get(LLVMContext,
369 C.getTargetInfo().getMaxPointerWidth());
370 Int8PtrTy = llvm::PointerType::get(LLVMContext,
372 const llvm::DataLayout &DL = M.getDataLayout();
374 llvm::PointerType::get(LLVMContext, DL.getAllocaAddrSpace());
376 llvm::PointerType::get(LLVMContext, DL.getDefaultGlobalsAddressSpace());
393 createOpenCLRuntime();
395 createOpenMPRuntime();
402 if (LangOpts.
Sanitize.
hasOneOf(SanitizerKind::Thread | SanitizerKind::Type) ||
403 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
409 if (CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo ||
414 Block.GlobalUniqueCount = 0;
416 if (
C.getLangOpts().ObjC)
420 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
427 PGOReader = std::move(ReaderOrErr.get());
432 if (CodeGenOpts.CoverageMapping)
436 if (CodeGenOpts.UniqueInternalLinkageNames &&
437 !
getModule().getSourceFileName().empty()) {
441 if (
Path.rfind(Entry.first, 0) != std::string::npos) {
442 Path = Entry.second +
Path.substr(Entry.first.size());
445 ModuleNameHash = llvm::getUniqueInternalLinkagePostfix(
Path);
450 getModule().addModuleFlag(llvm::Module::Error,
"NumRegisterParameters",
451 CodeGenOpts.NumRegisterParameters);
456void CodeGenModule::createObjCRuntime() {
473 llvm_unreachable(
"bad runtime kind");
476void CodeGenModule::createOpenCLRuntime() {
480void CodeGenModule::createOpenMPRuntime() {
484 case llvm::Triple::nvptx:
485 case llvm::Triple::nvptx64:
486 case llvm::Triple::amdgcn:
488 "OpenMP AMDGPU/NVPTX is only prepared to deal with device code.");
492 if (LangOpts.OpenMPSimd)
500void CodeGenModule::createCUDARuntime() {
504void CodeGenModule::createHLSLRuntime() {
509 Replacements[Name] =
C;
512void CodeGenModule::applyReplacements() {
513 for (
auto &I : Replacements) {
514 StringRef MangledName = I.first;
515 llvm::Constant *Replacement = I.second;
519 auto *OldF = cast<llvm::Function>(Entry);
520 auto *NewF = dyn_cast<llvm::Function>(Replacement);
522 if (
auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
523 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
525 auto *CE = cast<llvm::ConstantExpr>(Replacement);
526 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
527 CE->getOpcode() == llvm::Instruction::GetElementPtr);
528 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
533 OldF->replaceAllUsesWith(Replacement);
535 NewF->removeFromParent();
536 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
539 OldF->eraseFromParent();
544 GlobalValReplacements.push_back(std::make_pair(GV,
C));
547void CodeGenModule::applyGlobalValReplacements() {
548 for (
auto &I : GlobalValReplacements) {
549 llvm::GlobalValue *GV = I.first;
550 llvm::Constant *
C = I.second;
552 GV->replaceAllUsesWith(
C);
553 GV->eraseFromParent();
560 const llvm::Constant *
C;
561 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(GV))
562 C = GA->getAliasee();
563 else if (
auto *GI = dyn_cast<llvm::GlobalIFunc>(GV))
564 C = GI->getResolver();
568 const auto *AliaseeGV = dyn_cast<llvm::GlobalValue>(
C->stripPointerCasts());
572 const llvm::GlobalValue *FinalGV = AliaseeGV->getAliaseeObject();
581 bool IsIFunc,
const llvm::GlobalValue *Alias,
const llvm::GlobalValue *&GV,
582 const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames,
586 Diags.
Report(Location, diag::err_cyclic_alias) << IsIFunc;
590 if (GV->hasCommonLinkage()) {
592 if (Triple.getObjectFormat() == llvm::Triple::XCOFF) {
593 Diags.
Report(Location, diag::err_alias_to_common);
598 if (GV->isDeclaration()) {
599 Diags.
Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;
600 Diags.
Report(Location, diag::note_alias_requires_mangled_name)
601 << IsIFunc << IsIFunc;
604 for (
const auto &[
Decl, Name] : MangledDeclNames) {
605 if (
const auto *ND = dyn_cast<NamedDecl>(
Decl.getDecl())) {
607 if (II && II->
getName() == GV->getName()) {
608 Diags.
Report(Location, diag::note_alias_mangled_name_alternative)
612 (Twine(IsIFunc ?
"ifunc" :
"alias") +
"(\"" + Name +
"\")")
622 const auto *F = dyn_cast<llvm::Function>(GV);
624 Diags.
Report(Location, diag::err_alias_to_undefined)
625 << IsIFunc << IsIFunc;
629 llvm::FunctionType *FTy = F->getFunctionType();
630 if (!FTy->getReturnType()->isPointerTy()) {
631 Diags.
Report(Location, diag::err_ifunc_resolver_return);
645 if (GVar->hasAttribute(
"toc-data")) {
646 auto GVId = GVar->getName();
649 Diags.
Report(Location, diag::warn_toc_unsupported_type)
650 << GVId <<
"the variable has an alias";
652 llvm::AttributeSet CurrAttributes = GVar->getAttributes();
653 llvm::AttributeSet NewAttributes =
654 CurrAttributes.removeAttribute(GVar->getContext(),
"toc-data");
655 GVar->setAttributes(NewAttributes);
659void CodeGenModule::checkAliases() {
666 const auto *
D = cast<ValueDecl>(GD.getDecl());
669 bool IsIFunc =
D->
hasAttr<IFuncAttr>();
671 Location = A->getLocation();
672 Range = A->getRange();
674 llvm_unreachable(
"Not an alias or ifunc?");
678 const llvm::GlobalValue *GV =
nullptr;
680 MangledDeclNames,
Range)) {
686 if (
const llvm::GlobalVariable *GVar =
687 dyn_cast<const llvm::GlobalVariable>(GV))
691 llvm::Constant *Aliasee =
692 IsIFunc ? cast<llvm::GlobalIFunc>(Alias)->getResolver()
693 : cast<llvm::GlobalAlias>(Alias)->getAliasee();
695 llvm::GlobalValue *AliaseeGV;
696 if (
auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
697 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
699 AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
701 if (
const SectionAttr *SA =
D->
getAttr<SectionAttr>()) {
702 StringRef AliasSection = SA->getName();
703 if (AliasSection != AliaseeGV->getSection())
704 Diags.
Report(SA->getLocation(), diag::warn_alias_with_section)
705 << AliasSection << IsIFunc << IsIFunc;
713 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {
714 if (GA->isInterposable()) {
715 Diags.
Report(Location, diag::warn_alias_to_weak_alias)
716 << GV->getName() << GA->getName() << IsIFunc;
717 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
718 GA->getAliasee(), Alias->getType());
721 cast<llvm::GlobalIFunc>(Alias)->setResolver(Aliasee);
723 cast<llvm::GlobalAlias>(Alias)->setAliasee(Aliasee);
729 cast<llvm::Function>(Aliasee)->addFnAttr(
730 llvm::Attribute::DisableSanitizerInstrumentation);
738 Alias->replaceAllUsesWith(llvm::PoisonValue::get(Alias->getType()));
739 Alias->eraseFromParent();
744 DeferredDeclsToEmit.clear();
745 EmittedDeferredDecls.clear();
746 DeferredAnnotations.clear();
748 OpenMPRuntime->clear();
752 StringRef MainFile) {
755 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
756 if (MainFile.empty())
757 MainFile =
"<stdin>";
758 Diags.
Report(diag::warn_profile_data_unprofiled) << MainFile;
761 Diags.
Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
764 Diags.
Report(diag::warn_profile_data_missing) << Visited << Missing;
768static std::optional<llvm::GlobalValue::VisibilityTypes>
775 return llvm::GlobalValue::DefaultVisibility;
777 return llvm::GlobalValue::HiddenVisibility;
779 return llvm::GlobalValue::ProtectedVisibility;
781 llvm_unreachable(
"unknown option value!");
786 std::optional<llvm::GlobalValue::VisibilityTypes>
V) {
795 GV.setDSOLocal(
false);
796 GV.setVisibility(*
V);
801 if (!LO.VisibilityFromDLLStorageClass)
804 std::optional<llvm::GlobalValue::VisibilityTypes> DLLExportVisibility =
807 std::optional<llvm::GlobalValue::VisibilityTypes>
808 NoDLLStorageClassVisibility =
811 std::optional<llvm::GlobalValue::VisibilityTypes>
812 ExternDeclDLLImportVisibility =
815 std::optional<llvm::GlobalValue::VisibilityTypes>
816 ExternDeclNoDLLStorageClassVisibility =
819 for (llvm::GlobalValue &GV : M.global_values()) {
820 if (GV.hasAppendingLinkage() || GV.hasLocalLinkage())
823 if (GV.isDeclarationForLinker())
825 llvm::GlobalValue::DLLImportStorageClass
826 ? ExternDeclDLLImportVisibility
827 : ExternDeclNoDLLStorageClassVisibility);
830 llvm::GlobalValue::DLLExportStorageClass
831 ? DLLExportVisibility
832 : NoDLLStorageClassVisibility);
834 GV.setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
839 const llvm::Triple &Triple,
841 if (Triple.isAMDGPU() || Triple.isNVPTX())
843 return LangOpts.getStackProtector() == Mode;
849 EmitModuleInitializers(Primary);
851 DeferredDecls.insert(EmittedDeferredDecls.begin(),
852 EmittedDeferredDecls.end());
853 EmittedDeferredDecls.clear();
854 EmitVTablesOpportunistically();
855 applyGlobalValReplacements();
857 emitMultiVersionFunctions();
860 GlobalTopLevelStmtBlockInFlight.first) {
862 GlobalTopLevelStmtBlockInFlight.first->FinishFunction(TLSD->
getEndLoc());
863 GlobalTopLevelStmtBlockInFlight = {
nullptr,
nullptr};
869 EmitCXXModuleInitFunc(Primary);
871 EmitCXXGlobalInitFunc();
872 EmitCXXGlobalCleanUpFunc();
873 registerGlobalDtorsWithAtExit();
874 EmitCXXThreadLocalInitFunc();
876 if (llvm::Function *ObjCInitFunction =
ObjCRuntime->ModuleInitFunction())
879 if (llvm::Function *CudaCtorFunction = CUDARuntime->finalizeModule())
883 OpenMPRuntime->createOffloadEntriesAndInfoMetadata();
884 OpenMPRuntime->clear();
888 PGOReader->getSummary(
false).getMD(VMContext),
889 llvm::ProfileSummary::PSK_Instr);
896 EmitCtorList(GlobalCtors,
"llvm.global_ctors");
897 EmitCtorList(GlobalDtors,
"llvm.global_dtors");
899 EmitStaticExternCAliases();
905 CoverageMapping->emit();
906 if (CodeGenOpts.SanitizeCfiCrossDso) {
912 emitAtAvailableLinkGuard();
920 if (
getTarget().getTargetOpts().CodeObjectVersion !=
921 llvm::CodeObjectVersionKind::COV_None) {
922 getModule().addModuleFlag(llvm::Module::Error,
923 "amdhsa_code_object_version",
924 getTarget().getTargetOpts().CodeObjectVersion);
929 auto *MDStr = llvm::MDString::get(
934 getModule().addModuleFlag(llvm::Module::Error,
"amdgpu_printf_kind",
947 if (
auto *FD = dyn_cast<FunctionDecl>(
D))
951 UsedArray.push_back(llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
955 llvm::ArrayType *ATy = llvm::ArrayType::get(
Int8PtrTy, UsedArray.size());
957 auto *GV =
new llvm::GlobalVariable(
958 getModule(), ATy,
false, llvm::GlobalValue::InternalLinkage,
959 llvm::ConstantArray::get(ATy, UsedArray),
"__clang_gpu_used_external");
962 if (LangOpts.HIP && !
getLangOpts().OffloadingNewDriver) {
965 auto *GV =
new llvm::GlobalVariable(
967 llvm::Constant::getNullValue(
Int8Ty),
975 if (CodeGenOpts.Autolink &&
976 (Context.
getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
977 EmitModuleLinkOptions();
992 if (!ELFDependentLibraries.empty() && !Context.
getLangOpts().CUDAIsDevice) {
993 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.dependent-libraries");
994 for (
auto *MD : ELFDependentLibraries)
998 if (CodeGenOpts.DwarfVersion) {
999 getModule().addModuleFlag(llvm::Module::Max,
"Dwarf Version",
1000 CodeGenOpts.DwarfVersion);
1003 if (CodeGenOpts.Dwarf64)
1004 getModule().addModuleFlag(llvm::Module::Max,
"DWARF64", 1);
1008 getModule().setSemanticInterposition(
true);
1010 if (CodeGenOpts.EmitCodeView) {
1012 getModule().addModuleFlag(llvm::Module::Warning,
"CodeView", 1);
1014 if (CodeGenOpts.CodeViewGHash) {
1015 getModule().addModuleFlag(llvm::Module::Warning,
"CodeViewGHash", 1);
1017 if (CodeGenOpts.ControlFlowGuard) {
1019 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 2);
1020 }
else if (CodeGenOpts.ControlFlowGuardNoChecks) {
1022 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 1);
1024 if (CodeGenOpts.EHContGuard) {
1026 getModule().addModuleFlag(llvm::Module::Warning,
"ehcontguard", 1);
1030 getModule().addModuleFlag(llvm::Module::Warning,
"ms-kernel", 1);
1032 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
1037 getModule().addModuleFlag(llvm::Module::Error,
"StrictVTablePointers",1);
1039 llvm::Metadata *Ops[2] = {
1040 llvm::MDString::get(VMContext,
"StrictVTablePointers"),
1041 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1042 llvm::Type::getInt32Ty(VMContext), 1))};
1044 getModule().addModuleFlag(llvm::Module::Require,
1045 "StrictVTablePointersRequirement",
1046 llvm::MDNode::get(VMContext, Ops));
1052 getModule().addModuleFlag(llvm::Module::Warning,
"Debug Info Version",
1053 llvm::DEBUG_METADATA_VERSION);
1058 uint64_t WCharWidth =
1060 getModule().addModuleFlag(llvm::Module::Error,
"wchar_size", WCharWidth);
1063 getModule().addModuleFlag(llvm::Module::Warning,
1064 "zos_product_major_version",
1065 uint32_t(CLANG_VERSION_MAJOR));
1066 getModule().addModuleFlag(llvm::Module::Warning,
1067 "zos_product_minor_version",
1068 uint32_t(CLANG_VERSION_MINOR));
1069 getModule().addModuleFlag(llvm::Module::Warning,
"zos_product_patchlevel",
1070 uint32_t(CLANG_VERSION_PATCHLEVEL));
1072 getModule().addModuleFlag(llvm::Module::Error,
"zos_product_id",
1073 llvm::MDString::get(VMContext, ProductId));
1078 getModule().addModuleFlag(llvm::Module::Error,
"zos_cu_language",
1079 llvm::MDString::get(VMContext, lang_str));
1083 : std::time(
nullptr);
1084 getModule().addModuleFlag(llvm::Module::Max,
"zos_translation_time",
1085 static_cast<uint64_t
>(TT));
1088 getModule().addModuleFlag(llvm::Module::Error,
"zos_le_char_mode",
1089 llvm::MDString::get(VMContext,
"ascii"));
1093 if (
T.isARM() ||
T.isThumb()) {
1095 uint64_t EnumWidth = Context.
getLangOpts().ShortEnums ? 1 : 4;
1096 getModule().addModuleFlag(llvm::Module::Error,
"min_enum_size", EnumWidth);
1100 StringRef ABIStr =
Target.getABI();
1101 llvm::LLVMContext &Ctx = TheModule.getContext();
1102 getModule().addModuleFlag(llvm::Module::Error,
"target-abi",
1103 llvm::MDString::get(Ctx, ABIStr));
1108 const std::vector<std::string> &Features =
1111 llvm::RISCVISAInfo::parseFeatures(
T.isRISCV64() ? 64 : 32, Features);
1112 if (!errorToBool(ParseResult.takeError()))
1114 llvm::Module::AppendUnique,
"riscv-isa",
1116 Ctx, llvm::MDString::get(Ctx, (*ParseResult)->toString())));
1119 if (CodeGenOpts.SanitizeCfiCrossDso) {
1121 getModule().addModuleFlag(llvm::Module::Override,
"Cross-DSO CFI", 1);
1124 if (CodeGenOpts.WholeProgramVTables) {
1128 getModule().addModuleFlag(llvm::Module::Error,
"Virtual Function Elim",
1129 CodeGenOpts.VirtualFunctionElimination);
1132 if (LangOpts.
Sanitize.
has(SanitizerKind::CFIICall)) {
1133 getModule().addModuleFlag(llvm::Module::Override,
1134 "CFI Canonical Jump Tables",
1135 CodeGenOpts.SanitizeCfiCanonicalJumpTables);
1138 if (CodeGenOpts.SanitizeCfiICallNormalizeIntegers) {
1139 getModule().addModuleFlag(llvm::Module::Override,
"cfi-normalize-integers",
1144 getModule().addModuleFlag(llvm::Module::Override,
"kcfi", 1);
1147 if (CodeGenOpts.PatchableFunctionEntryOffset)
1148 getModule().addModuleFlag(llvm::Module::Override,
"kcfi-offset",
1149 CodeGenOpts.PatchableFunctionEntryOffset);
1152 if (CodeGenOpts.CFProtectionReturn &&
1155 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-return",
1159 if (CodeGenOpts.CFProtectionBranch &&
1162 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-branch",
1165 auto Scheme = CodeGenOpts.getCFBranchLabelScheme();
1166 if (
Target.checkCFBranchLabelSchemeSupported(Scheme,
getDiags())) {
1168 Scheme =
Target.getDefaultCFBranchLabelScheme();
1170 llvm::Module::Error,
"cf-branch-label-scheme",
1176 if (CodeGenOpts.FunctionReturnThunks)
1177 getModule().addModuleFlag(llvm::Module::Override,
"function_return_thunk_extern", 1);
1179 if (CodeGenOpts.IndirectBranchCSPrefix)
1180 getModule().addModuleFlag(llvm::Module::Override,
"indirect_branch_cs_prefix", 1);
1192 LangOpts.getSignReturnAddressScope() !=
1194 getModule().addModuleFlag(llvm::Module::Override,
1195 "sign-return-address-buildattr", 1);
1196 if (LangOpts.
Sanitize.
has(SanitizerKind::MemtagStack))
1197 getModule().addModuleFlag(llvm::Module::Override,
1198 "tag-stack-memory-buildattr", 1);
1200 if (
T.isARM() ||
T.isThumb() ||
T.isAArch64()) {
1201 if (LangOpts.BranchTargetEnforcement)
1202 getModule().addModuleFlag(llvm::Module::Min,
"branch-target-enforcement",
1204 if (LangOpts.BranchProtectionPAuthLR)
1205 getModule().addModuleFlag(llvm::Module::Min,
"branch-protection-pauth-lr",
1207 if (LangOpts.GuardedControlStack)
1208 getModule().addModuleFlag(llvm::Module::Min,
"guarded-control-stack", 1);
1210 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address", 1);
1212 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address-all",
1215 getModule().addModuleFlag(llvm::Module::Min,
1216 "sign-return-address-with-bkey", 1);
1218 if (LangOpts.PointerAuthELFGOT)
1219 getModule().addModuleFlag(llvm::Module::Min,
"ptrauth-elf-got", 1);
1222 if (LangOpts.PointerAuthCalls)
1223 getModule().addModuleFlag(llvm::Module::Min,
"ptrauth-sign-personality",
1226 using namespace llvm::ELF;
1227 uint64_t PAuthABIVersion =
1228 (LangOpts.PointerAuthIntrinsics
1229 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INTRINSICS) |
1230 (LangOpts.PointerAuthCalls
1231 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_CALLS) |
1232 (LangOpts.PointerAuthReturns
1233 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_RETURNS) |
1234 (LangOpts.PointerAuthAuthTraps
1235 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_AUTHTRAPS) |
1236 (LangOpts.PointerAuthVTPtrAddressDiscrimination
1237 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRADDRDISCR) |
1238 (LangOpts.PointerAuthVTPtrTypeDiscrimination
1239 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRTYPEDISCR) |
1240 (LangOpts.PointerAuthInitFini
1241 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINI) |
1242 (LangOpts.PointerAuthInitFiniAddressDiscrimination
1243 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINIADDRDISC) |
1244 (LangOpts.PointerAuthELFGOT
1245 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_GOT) |
1246 (LangOpts.PointerAuthIndirectGotos
1247 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_GOTOS) |
1248 (LangOpts.PointerAuthTypeInfoVTPtrDiscrimination
1249 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_TYPEINFOVPTRDISCR) |
1250 (LangOpts.PointerAuthFunctionTypeDiscrimination
1251 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_FPTRTYPEDISCR);
1252 static_assert(AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_FPTRTYPEDISCR ==
1253 AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_LAST,
1254 "Update when new enum items are defined");
1255 if (PAuthABIVersion != 0) {
1256 getModule().addModuleFlag(llvm::Module::Error,
1257 "aarch64-elf-pauthabi-platform",
1258 AARCH64_PAUTH_PLATFORM_LLVM_LINUX);
1259 getModule().addModuleFlag(llvm::Module::Error,
1260 "aarch64-elf-pauthabi-version",
1266 if (CodeGenOpts.StackClashProtector)
1268 llvm::Module::Override,
"probe-stack",
1269 llvm::MDString::get(TheModule.getContext(),
"inline-asm"));
1271 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
1272 getModule().addModuleFlag(llvm::Module::Min,
"stack-probe-size",
1273 CodeGenOpts.StackProbeSize);
1276 llvm::LLVMContext &Ctx = TheModule.getContext();
1278 llvm::Module::Error,
"MemProfProfileFilename",
1282 if (LangOpts.CUDAIsDevice &&
getTriple().isNVPTX()) {
1286 getModule().addModuleFlag(llvm::Module::Override,
"nvvm-reflect-ftz",
1288 llvm::DenormalMode::IEEE);
1291 if (LangOpts.EHAsynch)
1292 getModule().addModuleFlag(llvm::Module::Warning,
"eh-asynch", 1);
1296 getModule().addModuleFlag(llvm::Module::Max,
"openmp", LangOpts.OpenMP);
1298 getModule().addModuleFlag(llvm::Module::Max,
"openmp-device",
1302 if (LangOpts.OpenCL || (LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())) {
1303 EmitOpenCLMetadata();
1311 llvm::Metadata *SPIRVerElts[] = {
1312 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1314 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1315 Int32Ty, (Version / 100 > 1) ? 0 : 2))};
1316 llvm::NamedMDNode *SPIRVerMD =
1317 TheModule.getOrInsertNamedMetadata(
"opencl.spir.version");
1318 llvm::LLVMContext &Ctx = TheModule.getContext();
1319 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
1327 if (uint32_t PLevel = Context.
getLangOpts().PICLevel) {
1328 assert(PLevel < 3 &&
"Invalid PIC Level");
1329 getModule().setPICLevel(
static_cast<llvm::PICLevel::Level
>(PLevel));
1331 getModule().setPIELevel(
static_cast<llvm::PIELevel::Level
>(PLevel));
1335 unsigned CM = llvm::StringSwitch<unsigned>(
getCodeGenOpts().CodeModel)
1336 .Case(
"tiny", llvm::CodeModel::Tiny)
1337 .Case(
"small", llvm::CodeModel::Small)
1338 .Case(
"kernel", llvm::CodeModel::Kernel)
1339 .Case(
"medium", llvm::CodeModel::Medium)
1340 .Case(
"large", llvm::CodeModel::Large)
1343 llvm::CodeModel::Model codeModel =
static_cast<llvm::CodeModel::Model
>(CM);
1346 if ((CM == llvm::CodeModel::Medium || CM == llvm::CodeModel::Large) &&
1348 llvm::Triple::x86_64) {
1354 if (CodeGenOpts.NoPLT)
1357 CodeGenOpts.DirectAccessExternalData !=
1358 getModule().getDirectAccessExternalData()) {
1359 getModule().setDirectAccessExternalData(
1360 CodeGenOpts.DirectAccessExternalData);
1362 if (CodeGenOpts.UnwindTables)
1363 getModule().setUwtable(llvm::UWTableKind(CodeGenOpts.UnwindTables));
1365 switch (CodeGenOpts.getFramePointer()) {
1370 getModule().setFramePointer(llvm::FramePointerKind::Reserved);
1373 getModule().setFramePointer(llvm::FramePointerKind::NonLeaf);
1376 getModule().setFramePointer(llvm::FramePointerKind::All);
1380 SimplifyPersonality();
1393 EmitVersionIdentMetadata();
1396 EmitCommandLineMetadata();
1404 getModule().setStackProtectorGuardSymbol(
1407 getModule().setStackProtectorGuardOffset(
1412 getModule().addModuleFlag(llvm::Module::Override,
"SkipRaxSetup", 1);
1414 getModule().addModuleFlag(llvm::Module::Override,
"RegCallv4", 1);
1416 if (
getContext().getTargetInfo().getMaxTLSAlign())
1417 getModule().addModuleFlag(llvm::Module::Error,
"MaxTLSAlign",
1418 getContext().getTargetInfo().getMaxTLSAlign());
1436 if (
getTriple().isPPC() && !MustTailCallUndefinedGlobals.empty()) {
1437 for (
auto &I : MustTailCallUndefinedGlobals) {
1438 if (!I.first->isDefined())
1439 getDiags().
Report(I.second, diag::err_ppc_impossible_musttail) << 2;
1443 if (!Entry || Entry->isWeakForLinker() ||
1444 Entry->isDeclarationForLinker())
1445 getDiags().
Report(I.second, diag::err_ppc_impossible_musttail) << 2;
1451void CodeGenModule::EmitOpenCLMetadata() {
1457 auto EmitVersion = [
this](StringRef MDName,
int Version) {
1458 llvm::Metadata *OCLVerElts[] = {
1459 llvm::ConstantAsMetadata::get(
1460 llvm::ConstantInt::get(
Int32Ty, Version / 100)),
1461 llvm::ConstantAsMetadata::get(
1462 llvm::ConstantInt::get(
Int32Ty, (Version % 100) / 10))};
1463 llvm::NamedMDNode *OCLVerMD = TheModule.getOrInsertNamedMetadata(MDName);
1464 llvm::LLVMContext &Ctx = TheModule.getContext();
1465 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
1468 EmitVersion(
"opencl.ocl.version", CLVersion);
1469 if (LangOpts.OpenCLCPlusPlus) {
1471 EmitVersion(
"opencl.cxx.version", LangOpts.OpenCLCPlusPlusVersion);
1475void CodeGenModule::EmitBackendOptionsMetadata(
1478 getModule().addModuleFlag(llvm::Module::Min,
"SmallDataLimit",
1479 CodeGenOpts.SmallDataLimit);
1496 return TBAA->getTypeInfo(QTy);
1515 return TBAA->getAccessInfo(AccessType);
1522 return TBAA->getVTablePtrAccessInfo(VTablePtrType);
1528 return TBAA->getTBAAStructInfo(QTy);
1534 return TBAA->getBaseTypeInfo(QTy);
1540 return TBAA->getAccessTagInfo(Info);
1547 return TBAA->mergeTBAAInfoForCast(SourceInfo,
TargetInfo);
1555 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
1563 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
1569 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
1574 I->setMetadata(llvm::LLVMContext::MD_invariant_group,
1587 "cannot compile this %0 yet");
1588 std::string Msg =
Type;
1590 << Msg << S->getSourceRange();
1597 "cannot compile this %0 yet");
1598 std::string Msg =
Type;
1603 llvm::function_ref<
void()> Fn) {
1614 if (GV->hasLocalLinkage()) {
1615 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1629 Context.
getLangOpts().OpenMPIsTargetDevice && isa<VarDecl>(
D) &&
1630 D->
hasAttr<OMPDeclareTargetDeclAttr>() &&
1631 D->
getAttr<OMPDeclareTargetDeclAttr>()->getDevType() !=
1632 OMPDeclareTargetDeclAttr::DT_NoHost &&
1634 GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
1638 if (GV->hasDLLExportStorageClass() || GV->hasDLLImportStorageClass()) {
1642 if (GV->hasDLLExportStorageClass()) {
1645 diag::err_hidden_visibility_dllexport);
1648 diag::err_non_default_visibility_dllimport);
1654 !GV->isDeclarationForLinker())
1659 llvm::GlobalValue *GV) {
1660 if (GV->hasLocalLinkage())
1663 if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
1667 if (GV->hasDLLImportStorageClass())
1670 const llvm::Triple &TT = CGM.
getTriple();
1672 if (TT.isWindowsGNUEnvironment()) {
1681 if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
1690 if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
1698 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
1702 if (!TT.isOSBinFormatELF())
1708 if (RM != llvm::Reloc::Static && !LOpts.PIE) {
1714 if (!(isa<llvm::Function>(GV) && GV->canBenefitFromLocalAlias()))
1716 return !(CGM.
getLangOpts().SemanticInterposition ||
1721 if (!GV->isDeclarationForLinker())
1727 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
1734 if (CGOpts.DirectAccessExternalData) {
1740 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
1741 if (!Var->isThreadLocal())
1750 if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
1766 const auto *
D = dyn_cast<NamedDecl>(GD.
getDecl());
1768 if (
const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(
D)) {
1777 if (
D &&
D->isExternallyVisible()) {
1779 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
1780 else if ((
D->
hasAttr<DLLExportAttr>() ||
1782 !GV->isDeclarationForLinker())
1783 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
1807 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
1808 .Case(
"global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
1809 .Case(
"local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
1810 .Case(
"initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
1811 .Case(
"local-exec", llvm::GlobalVariable::LocalExecTLSModel);
1814llvm::GlobalVariable::ThreadLocalMode
1816 switch (CodeGenOpts.getDefaultTLSModel()) {
1818 return llvm::GlobalVariable::GeneralDynamicTLSModel;
1820 return llvm::GlobalVariable::LocalDynamicTLSModel;
1822 return llvm::GlobalVariable::InitialExecTLSModel;
1824 return llvm::GlobalVariable::LocalExecTLSModel;
1826 llvm_unreachable(
"Invalid TLS model!");
1830 assert(
D.getTLSKind() &&
"setting TLS mode on non-TLS var!");
1832 llvm::GlobalValue::ThreadLocalMode TLM;
1836 if (
const TLSModelAttr *
Attr =
D.
getAttr<TLSModelAttr>()) {
1840 GV->setThreadLocalMode(TLM);
1846 return (Twine(
'.') + Twine(
Target.CPUSpecificManglingCharacter(Name))).str();
1850 const CPUSpecificAttr *
Attr,
1872 bool OmitMultiVersionMangling =
false) {
1874 llvm::raw_svector_ostream Out(Buffer);
1883 assert(II &&
"Attempt to mangle unnamed decl.");
1884 const auto *FD = dyn_cast<FunctionDecl>(ND);
1889 Out <<
"__regcall4__" << II->
getName();
1891 Out <<
"__regcall3__" << II->
getName();
1892 }
else if (FD && FD->hasAttr<CUDAGlobalAttr>() &&
1894 Out <<
"__device_stub__" << II->
getName();
1910 "Hash computed when not explicitly requested");
1914 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
1915 if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
1916 switch (FD->getMultiVersionKind()) {
1920 FD->getAttr<CPUSpecificAttr>(),
1924 auto *
Attr = FD->getAttr<TargetAttr>();
1925 assert(
Attr &&
"Expected TargetAttr to be present "
1926 "for attribute mangling");
1932 auto *
Attr = FD->getAttr<TargetVersionAttr>();
1933 assert(
Attr &&
"Expected TargetVersionAttr to be present "
1934 "for attribute mangling");
1940 auto *
Attr = FD->getAttr<TargetClonesAttr>();
1941 assert(
Attr &&
"Expected TargetClonesAttr to be present "
1942 "for attribute mangling");
1949 llvm_unreachable(
"None multiversion type isn't valid here");
1959 return std::string(Out.str());
1962void CodeGenModule::UpdateMultiVersionNames(
GlobalDecl GD,
1964 StringRef &CurName) {
1971 std::string NonTargetName =
1979 "Other GD should now be a multiversioned function");
1989 if (OtherName != NonTargetName) {
1992 const auto ExistingRecord = Manglings.find(NonTargetName);
1993 if (ExistingRecord != std::end(Manglings))
1994 Manglings.remove(&(*ExistingRecord));
1995 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
2000 CurName = OtherNameRef;
2002 Entry->setName(OtherName);
2012 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.
getDecl())) {
2026 auto FoundName = MangledDeclNames.find(CanonicalGD);
2027 if (FoundName != MangledDeclNames.end())
2028 return FoundName->second;
2032 const auto *ND = cast<NamedDecl>(GD.
getDecl());
2044 assert(!isa<FunctionDecl>(ND) || !ND->hasAttr<CUDAGlobalAttr>() ||
2064 auto Result = Manglings.insert(std::make_pair(MangledName, GD));
2065 return MangledDeclNames[CanonicalGD] =
Result.first->first();
2074 llvm::raw_svector_ostream Out(Buffer);
2077 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.
getDecl()), Out);
2078 else if (
const auto *CD = dyn_cast<CXXConstructorDecl>(
D))
2080 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(
D))
2085 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
2086 return Result.first->first();
2090 auto it = MangledDeclNames.begin();
2091 while (it != MangledDeclNames.end()) {
2092 if (it->second == Name)
2107 llvm::Constant *AssociatedData) {
2115 bool IsDtorAttrFunc) {
2116 if (CodeGenOpts.RegisterGlobalDtorsWithAtExit &&
2118 DtorsUsingAtExit[
Priority].push_back(Dtor);
2126void CodeGenModule::EmitCtorList(CtorList &Fns,
const char *GlobalName) {
2127 if (Fns.empty())
return;
2133 llvm::PointerType *PtrTy = llvm::PointerType::get(
2134 getLLVMContext(), TheModule.getDataLayout().getProgramAddressSpace());
2137 llvm::StructType *CtorStructTy = llvm::StructType::get(
Int32Ty, PtrTy, PtrTy);
2141 auto Ctors = Builder.beginArray(CtorStructTy);
2142 for (
const auto &I : Fns) {
2143 auto Ctor = Ctors.beginStruct(CtorStructTy);
2144 Ctor.addInt(
Int32Ty, I.Priority);
2145 if (InitFiniAuthSchema) {
2146 llvm::Constant *StorageAddress =
2148 ? llvm::ConstantExpr::getIntToPtr(
2149 llvm::ConstantInt::get(
2151 llvm::ConstantPtrAuth::AddrDiscriminator_CtorsDtors),
2155 I.Initializer, InitFiniAuthSchema.
getKey(), StorageAddress,
2156 llvm::ConstantInt::get(
2158 Ctor.add(SignedCtorPtr);
2160 Ctor.add(I.Initializer);
2162 if (I.AssociatedData)
2163 Ctor.add(I.AssociatedData);
2165 Ctor.addNullPointer(PtrTy);
2166 Ctor.finishAndAddTo(Ctors);
2169 auto List = Ctors.finishAndCreateGlobal(GlobalName,
getPointerAlign(),
2171 llvm::GlobalValue::AppendingLinkage);
2175 List->setAlignment(std::nullopt);
2180llvm::GlobalValue::LinkageTypes
2182 const auto *
D = cast<FunctionDecl>(GD.
getDecl());
2186 if (
const auto *Dtor = dyn_cast<CXXDestructorDecl>(
D))
2193 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
2194 if (!MDS)
return nullptr;
2196 return llvm::ConstantInt::get(
Int64Ty, llvm::MD5Hash(MDS->getString()));
2202 FnType->getReturnType(), FnType->getParamTypes(),
2203 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
2205 std::string OutName;
2206 llvm::raw_string_ostream Out(OutName);
2211 Out <<
".normalized";
2213 return llvm::ConstantInt::get(
Int32Ty,
2214 static_cast<uint32_t
>(llvm::xxHash64(OutName)));
2219 llvm::Function *F,
bool IsThunk) {
2221 llvm::AttributeList PAL;
2224 if (
CallingConv == llvm::CallingConv::X86_VectorCall &&
2230 Error(
Loc,
"__vectorcall calling convention is not currently supported");
2232 F->setAttributes(PAL);
2233 F->setCallingConv(
static_cast<llvm::CallingConv::ID
>(
CallingConv));
2237 std::string ReadOnlyQual(
"__read_only");
2238 std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
2239 if (ReadOnlyPos != std::string::npos)
2241 TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);
2243 std::string WriteOnlyQual(
"__write_only");
2244 std::string::size_type WriteOnlyPos = TyName.find(WriteOnlyQual);
2245 if (WriteOnlyPos != std::string::npos)
2246 TyName.erase(WriteOnlyPos, WriteOnlyQual.size() + 1);
2248 std::string ReadWriteQual(
"__read_write");
2249 std::string::size_type ReadWritePos = TyName.find(ReadWriteQual);
2250 if (ReadWritePos != std::string::npos)
2251 TyName.erase(ReadWritePos, ReadWriteQual.size() + 1);
2284 assert(((FD && CGF) || (!FD && !CGF)) &&
2285 "Incorrect use - FD and CGF should either be both null or not!");
2311 for (
unsigned i = 0, e = FD->
getNumParams(); i != e; ++i) {
2314 argNames.push_back(llvm::MDString::get(VMContext, parm->
getName()));
2319 std::string typeQuals;
2323 const Decl *PDecl = parm;
2325 PDecl = TD->getDecl();
2326 const OpenCLAccessAttr *A = PDecl->
getAttr<OpenCLAccessAttr>();
2327 if (A && A->isWriteOnly())
2328 accessQuals.push_back(llvm::MDString::get(VMContext,
"write_only"));
2329 else if (A && A->isReadWrite())
2330 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_write"));
2332 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_only"));
2334 accessQuals.push_back(llvm::MDString::get(VMContext,
"none"));
2336 auto getTypeSpelling = [&](
QualType Ty) {
2337 auto typeName = Ty.getUnqualifiedType().getAsString(Policy);
2339 if (Ty.isCanonical()) {
2340 StringRef typeNameRef = typeName;
2342 if (typeNameRef.consume_front(
"unsigned "))
2343 return std::string(
"u") + typeNameRef.str();
2344 if (typeNameRef.consume_front(
"signed "))
2345 return typeNameRef.str();
2355 addressQuals.push_back(
2356 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(
2360 std::string typeName = getTypeSpelling(pointeeTy) +
"*";
2361 std::string baseTypeName =
2363 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2364 argBaseTypeNames.push_back(
2365 llvm::MDString::get(VMContext, baseTypeName));
2369 typeQuals =
"restrict";
2372 typeQuals += typeQuals.empty() ?
"const" :
" const";
2374 typeQuals += typeQuals.empty() ?
"volatile" :
" volatile";
2376 uint32_t AddrSpc = 0;
2381 addressQuals.push_back(
2382 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(AddrSpc)));
2386 std::string typeName = getTypeSpelling(ty);
2398 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2399 argBaseTypeNames.push_back(
2400 llvm::MDString::get(VMContext, baseTypeName));
2405 argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));
2409 Fn->setMetadata(
"kernel_arg_addr_space",
2410 llvm::MDNode::get(VMContext, addressQuals));
2411 Fn->setMetadata(
"kernel_arg_access_qual",
2412 llvm::MDNode::get(VMContext, accessQuals));
2413 Fn->setMetadata(
"kernel_arg_type",
2414 llvm::MDNode::get(VMContext, argTypeNames));
2415 Fn->setMetadata(
"kernel_arg_base_type",
2416 llvm::MDNode::get(VMContext, argBaseTypeNames));
2417 Fn->setMetadata(
"kernel_arg_type_qual",
2418 llvm::MDNode::get(VMContext, argTypeQuals));
2422 Fn->setMetadata(
"kernel_arg_name",
2423 llvm::MDNode::get(VMContext, argNames));
2433 if (!LangOpts.Exceptions)
return false;
2436 if (LangOpts.CXXExceptions)
return true;
2439 if (LangOpts.ObjCExceptions) {
2456 !isa<CXXConstructorDecl, CXXDestructorDecl>(MD);
2461 llvm::SetVector<const CXXRecordDecl *> MostBases;
2463 std::function<void (
const CXXRecordDecl *)> CollectMostBases;
2466 MostBases.insert(RD);
2468 CollectMostBases(B.getType()->getAsCXXRecordDecl());
2470 CollectMostBases(RD);
2471 return MostBases.takeVector();
2475 llvm::Function *F) {
2476 llvm::AttrBuilder B(F->getContext());
2478 if ((!
D || !
D->
hasAttr<NoUwtableAttr>()) && CodeGenOpts.UnwindTables)
2479 B.addUWTableAttr(llvm::UWTableKind(CodeGenOpts.UnwindTables));
2481 if (CodeGenOpts.StackClashProtector)
2482 B.addAttribute(
"probe-stack",
"inline-asm");
2484 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
2485 B.addAttribute(
"stack-probe-size",
2486 std::to_string(CodeGenOpts.StackProbeSize));
2489 B.addAttribute(llvm::Attribute::NoUnwind);
2491 if (
D &&
D->
hasAttr<NoStackProtectorAttr>())
2493 else if (
D &&
D->
hasAttr<StrictGuardStackCheckAttr>() &&
2495 B.addAttribute(llvm::Attribute::StackProtectStrong);
2497 B.addAttribute(llvm::Attribute::StackProtect);
2499 B.addAttribute(llvm::Attribute::StackProtectStrong);
2501 B.addAttribute(llvm::Attribute::StackProtectReq);
2505 if (
getLangOpts().
HLSL && !F->hasFnAttribute(llvm::Attribute::NoInline))
2506 B.addAttribute(llvm::Attribute::AlwaysInline);
2510 else if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
2512 B.addAttribute(llvm::Attribute::NoInline);
2520 if (
D->
hasAttr<ArmLocallyStreamingAttr>())
2521 B.addAttribute(
"aarch64_pstate_sm_body");
2524 if (
Attr->isNewZA())
2525 B.addAttribute(
"aarch64_new_za");
2526 if (
Attr->isNewZT0())
2527 B.addAttribute(
"aarch64_new_zt0");
2532 bool ShouldAddOptNone =
2533 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
2535 ShouldAddOptNone &= !
D->
hasAttr<MinSizeAttr>();
2536 ShouldAddOptNone &= !
D->
hasAttr<AlwaysInlineAttr>();
2539 if (
getLangOpts().HLSL && !F->hasFnAttribute(llvm::Attribute::NoInline) &&
2541 B.addAttribute(llvm::Attribute::AlwaysInline);
2542 }
else if ((ShouldAddOptNone ||
D->
hasAttr<OptimizeNoneAttr>()) &&
2543 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2545 B.addAttribute(llvm::Attribute::OptimizeNone);
2548 B.addAttribute(llvm::Attribute::NoInline);
2553 B.addAttribute(llvm::Attribute::Naked);
2556 F->removeFnAttr(llvm::Attribute::OptimizeForSize);
2557 F->removeFnAttr(llvm::Attribute::MinSize);
2558 }
else if (
D->
hasAttr<NakedAttr>()) {
2560 B.addAttribute(llvm::Attribute::Naked);
2561 B.addAttribute(llvm::Attribute::NoInline);
2562 }
else if (
D->
hasAttr<NoDuplicateAttr>()) {
2563 B.addAttribute(llvm::Attribute::NoDuplicate);
2564 }
else if (
D->
hasAttr<NoInlineAttr>() &&
2565 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2567 B.addAttribute(llvm::Attribute::NoInline);
2568 }
else if (
D->
hasAttr<AlwaysInlineAttr>() &&
2569 !F->hasFnAttribute(llvm::Attribute::NoInline)) {
2571 B.addAttribute(llvm::Attribute::AlwaysInline);
2575 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
2576 B.addAttribute(llvm::Attribute::NoInline);
2580 if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
2583 auto CheckRedeclForInline = [](
const FunctionDecl *Redecl) {
2584 return Redecl->isInlineSpecified();
2586 if (any_of(FD->
redecls(), CheckRedeclForInline))
2591 return any_of(Pattern->
redecls(), CheckRedeclForInline);
2593 if (CheckForInline(FD)) {
2594 B.addAttribute(llvm::Attribute::InlineHint);
2595 }
else if (CodeGenOpts.getInlining() ==
2598 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2599 B.addAttribute(llvm::Attribute::NoInline);
2606 if (!
D->
hasAttr<OptimizeNoneAttr>()) {
2608 if (!ShouldAddOptNone)
2609 B.addAttribute(llvm::Attribute::OptimizeForSize);
2610 B.addAttribute(llvm::Attribute::Cold);
2613 B.addAttribute(llvm::Attribute::Hot);
2615 B.addAttribute(llvm::Attribute::MinSize);
2622 F->setAlignment(llvm::Align(alignment));
2625 if (LangOpts.FunctionAlignment)
2626 F->setAlignment(llvm::Align(1ull << LangOpts.FunctionAlignment));
2633 if (isa<CXXMethodDecl>(
D) && F->getPointerAlignment(
getDataLayout()) < 2)
2634 F->setAlignment(std::max(llvm::Align(2), F->getAlign().valueOrOne()));
2639 if (CodeGenOpts.SanitizeCfiCrossDso &&
2640 CodeGenOpts.SanitizeCfiCanonicalJumpTables) {
2641 if (
auto *FD = dyn_cast<FunctionDecl>(
D)) {
2652 auto *MD = dyn_cast<CXXMethodDecl>(
D);
2655 llvm::Metadata *
Id =
2658 F->addTypeMetadata(0,
Id);
2665 if (isa_and_nonnull<NamedDecl>(
D))
2668 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
2673 if (
const auto *VD = dyn_cast_if_present<VarDecl>(
D);
2675 ((CodeGenOpts.KeepPersistentStorageVariables &&
2676 (VD->getStorageDuration() ==
SD_Static ||
2677 VD->getStorageDuration() ==
SD_Thread)) ||
2678 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==
SD_Static &&
2679 VD->getType().isConstQualified())))
2683bool CodeGenModule::GetCPUAndFeaturesAttributes(
GlobalDecl GD,
2684 llvm::AttrBuilder &Attrs,
2685 bool SetTargetFeatures) {
2691 std::vector<std::string> Features;
2692 const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.
getDecl());
2694 const auto *TD = FD ? FD->
getAttr<TargetAttr>() :
nullptr;
2695 const auto *TV = FD ? FD->
getAttr<TargetVersionAttr>() :
nullptr;
2696 assert((!TD || !TV) &&
"both target_version and target specified");
2697 const auto *SD = FD ? FD->
getAttr<CPUSpecificAttr>() :
nullptr;
2698 const auto *TC = FD ? FD->
getAttr<TargetClonesAttr>() :
nullptr;
2699 bool AddedAttr =
false;
2700 if (TD || TV || SD || TC) {
2701 llvm::StringMap<bool> FeatureMap;
2705 for (
const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
2706 Features.push_back((Entry.getValue() ?
"+" :
"-") + Entry.getKey().str());
2714 Target.parseTargetAttr(TD->getFeaturesStr());
2736 if (!TargetCPU.empty()) {
2737 Attrs.addAttribute(
"target-cpu", TargetCPU);
2740 if (!TuneCPU.empty()) {
2741 Attrs.addAttribute(
"tune-cpu", TuneCPU);
2744 if (!Features.empty() && SetTargetFeatures) {
2745 llvm::erase_if(Features, [&](
const std::string& F) {
2748 llvm::sort(Features);
2749 Attrs.addAttribute(
"target-features", llvm::join(Features,
","));
2755 bool IsDefault =
false;
2757 IsDefault = TV->isDefaultVersion();
2758 TV->getFeatures(Feats);
2764 Attrs.addAttribute(
"fmv-features");
2766 }
else if (!Feats.empty()) {
2768 std::set<StringRef> OrderedFeats(Feats.begin(), Feats.end());
2769 std::string FMVFeatures;
2770 for (StringRef F : OrderedFeats)
2771 FMVFeatures.append(
"," + F.str());
2772 Attrs.addAttribute(
"fmv-features", FMVFeatures.substr(1));
2779void CodeGenModule::setNonAliasAttributes(
GlobalDecl GD,
2780 llvm::GlobalObject *GO) {
2785 if (
auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
2788 if (
auto *SA =
D->
getAttr<PragmaClangBSSSectionAttr>())
2789 GV->addAttribute(
"bss-section", SA->getName());
2790 if (
auto *SA =
D->
getAttr<PragmaClangDataSectionAttr>())
2791 GV->addAttribute(
"data-section", SA->getName());
2792 if (
auto *SA =
D->
getAttr<PragmaClangRodataSectionAttr>())
2793 GV->addAttribute(
"rodata-section", SA->getName());
2794 if (
auto *SA =
D->
getAttr<PragmaClangRelroSectionAttr>())
2795 GV->addAttribute(
"relro-section", SA->getName());
2798 if (
auto *F = dyn_cast<llvm::Function>(GO)) {
2801 if (
auto *SA =
D->
getAttr<PragmaClangTextSectionAttr>())
2803 F->setSection(SA->getName());
2805 llvm::AttrBuilder Attrs(F->getContext());
2806 if (GetCPUAndFeaturesAttributes(GD, Attrs)) {
2810 llvm::AttributeMask RemoveAttrs;
2811 RemoveAttrs.addAttribute(
"target-cpu");
2812 RemoveAttrs.addAttribute(
"target-features");
2813 RemoveAttrs.addAttribute(
"fmv-features");
2814 RemoveAttrs.addAttribute(
"tune-cpu");
2815 F->removeFnAttrs(RemoveAttrs);
2816 F->addFnAttrs(Attrs);
2820 if (
const auto *CSA =
D->
getAttr<CodeSegAttr>())
2821 GO->setSection(CSA->getName());
2822 else if (
const auto *SA =
D->
getAttr<SectionAttr>())
2823 GO->setSection(SA->getName());
2836 F->setLinkage(llvm::Function::InternalLinkage);
2838 setNonAliasAttributes(GD, F);
2849 GV->
setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
2853 llvm::Function *F) {
2855 if (!LangOpts.
Sanitize.
has(SanitizerKind::CFIICall))
2860 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
2864 F->addTypeMetadata(0, MD);
2868 if (CodeGenOpts.SanitizeCfiCrossDso)
2870 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
2874 llvm::LLVMContext &Ctx = F->getContext();
2875 llvm::MDBuilder MDB(Ctx);
2876 F->setMetadata(llvm::LLVMContext::MD_kcfi_type,
2885 return llvm::all_of(Name, [](
const char &
C) {
2886 return llvm::isAlnum(
C) ||
C ==
'_' ||
C ==
'.';
2892 for (
auto &F : M.functions()) {
2894 bool AddressTaken = F.hasAddressTaken();
2895 if (!AddressTaken && F.hasLocalLinkage())
2896 F.eraseMetadata(llvm::LLVMContext::MD_kcfi_type);
2901 if (!AddressTaken || !F.isDeclaration())
2904 const llvm::ConstantInt *
Type;
2905 if (
const llvm::MDNode *MD = F.getMetadata(llvm::LLVMContext::MD_kcfi_type))
2906 Type = llvm::mdconst::extract<llvm::ConstantInt>(MD->getOperand(0));
2910 StringRef Name = F.getName();
2914 std::string
Asm = (
".weak __kcfi_typeid_" + Name +
"\n.set __kcfi_typeid_" +
2915 Name +
", " + Twine(
Type->getZExtValue()) +
"\n")
2917 M.appendModuleInlineAsm(
Asm);
2921void CodeGenModule::SetFunctionAttributes(
GlobalDecl GD, llvm::Function *F,
2922 bool IsIncompleteFunction,
2925 if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
2928 F->setAttributes(llvm::Intrinsic::getAttributes(
getLLVMContext(), IID));
2932 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
2934 if (!IsIncompleteFunction)
2941 if (!IsThunk &&
getCXXABI().HasThisReturn(GD) &&
2943 assert(!F->arg_empty() &&
2944 F->arg_begin()->getType()
2945 ->canLosslesslyBitCastTo(F->getReturnType()) &&
2946 "unexpected this return");
2947 F->addParamAttr(0, llvm::Attribute::Returned);
2957 if (!IsIncompleteFunction && F->isDeclaration())
2960 if (
const auto *CSA = FD->
getAttr<CodeSegAttr>())
2961 F->setSection(CSA->getName());
2962 else if (
const auto *SA = FD->
getAttr<SectionAttr>())
2963 F->setSection(SA->getName());
2965 if (
const auto *EA = FD->
getAttr<ErrorAttr>()) {
2967 F->addFnAttr(
"dontcall-error", EA->getUserDiagnostic());
2968 else if (EA->isWarning())
2969 F->addFnAttr(
"dontcall-warn", EA->getUserDiagnostic());
2975 bool HasBody = FD->
hasBody(FDBody);
2977 assert(HasBody &&
"Inline builtin declarations should always have an "
2979 if (shouldEmitFunction(FDBody))
2980 F->addFnAttr(llvm::Attribute::NoBuiltin);
2986 F->addFnAttr(llvm::Attribute::NoBuiltin);
2989 if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
2990 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2991 else if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
2992 if (MD->isVirtual())
2993 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2999 if (!CodeGenOpts.SanitizeCfiCrossDso ||
3000 !CodeGenOpts.SanitizeCfiCanonicalJumpTables)
3009 if (CodeGenOpts.InlineMaxStackSize !=
UINT_MAX)
3010 F->addFnAttr(
"inline-max-stacksize", llvm::utostr(CodeGenOpts.InlineMaxStackSize));
3012 if (
const auto *CB = FD->
getAttr<CallbackAttr>()) {
3016 llvm::LLVMContext &Ctx = F->getContext();
3017 llvm::MDBuilder MDB(Ctx);
3021 int CalleeIdx = *CB->encoding_begin();
3022 ArrayRef<int> PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());
3023 F->addMetadata(llvm::LLVMContext::MD_callback,
3024 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
3025 CalleeIdx, PayloadIndices,
3031 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
3032 "Only globals with definition can force usage.");
3033 LLVMUsed.emplace_back(GV);
3037 assert(!GV->isDeclaration() &&
3038 "Only globals with definition can force usage.");
3039 LLVMCompilerUsed.emplace_back(GV);
3043 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
3044 "Only globals with definition can force usage.");
3046 LLVMCompilerUsed.emplace_back(GV);
3048 LLVMUsed.emplace_back(GV);
3052 std::vector<llvm::WeakTrackingVH> &List) {
3059 UsedArray.resize(List.size());
3060 for (
unsigned i = 0, e = List.size(); i != e; ++i) {
3062 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
3063 cast<llvm::Constant>(&*List[i]), CGM.
Int8PtrTy);
3066 if (UsedArray.empty())
3068 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.
Int8PtrTy, UsedArray.size());
3070 auto *GV =
new llvm::GlobalVariable(
3071 CGM.
getModule(), ATy,
false, llvm::GlobalValue::AppendingLinkage,
3072 llvm::ConstantArray::get(ATy, UsedArray), Name);
3074 GV->setSection(
"llvm.metadata");
3077void CodeGenModule::emitLLVMUsed() {
3078 emitUsed(*
this,
"llvm.used", LLVMUsed);
3079 emitUsed(*
this,
"llvm.compiler.used", LLVMCompilerUsed);
3084 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
3093 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
3099 ELFDependentLibraries.push_back(
3100 llvm::MDNode::get(
C, llvm::MDString::get(
C, Lib)));
3107 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
C, MDOpts));
3122 if (
Visited.insert(Import).second)
3139 if (LL.IsFramework) {
3140 llvm::Metadata *Args[2] = {llvm::MDString::get(Context,
"-framework"),
3141 llvm::MDString::get(Context, LL.Library)};
3143 Metadata.push_back(llvm::MDNode::get(Context, Args));
3149 llvm::Metadata *Args[2] = {
3150 llvm::MDString::get(Context,
"lib"),
3151 llvm::MDString::get(Context, LL.Library),
3153 Metadata.push_back(llvm::MDNode::get(Context, Args));
3157 auto *OptString = llvm::MDString::get(Context, Opt);
3158 Metadata.push_back(llvm::MDNode::get(Context, OptString));
3163void CodeGenModule::EmitModuleInitializers(
clang::Module *Primary) {
3165 "We should only emit module initializers for named modules.");
3171 if (isa<ImportDecl>(
D))
3173 assert(isa<VarDecl>(
D) &&
"GMF initializer decl is not a var?");
3180 if (isa<ImportDecl>(
D))
3188 if (isa<ImportDecl>(
D))
3190 assert(isa<VarDecl>(
D) &&
"PMF initializer decl is not a var?");
3196void CodeGenModule::EmitModuleLinkOptions() {
3200 llvm::SetVector<clang::Module *> LinkModules;
3205 for (
Module *M : ImportedModules) {
3208 if (M->getTopLevelModuleName() ==
getLangOpts().CurrentModule &&
3217 while (!Stack.empty()) {
3220 bool AnyChildren =
false;
3230 Stack.push_back(
SM);
3238 LinkModules.insert(Mod);
3247 for (
Module *M : LinkModules)
3250 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
3251 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
3254 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.linker.options");
3255 for (
auto *MD : LinkerOptionsMetadata)
3256 NMD->addOperand(MD);
3259void CodeGenModule::EmitDeferred() {
3268 if (!DeferredVTables.empty()) {
3269 EmitDeferredVTables();
3274 assert(DeferredVTables.empty());
3281 llvm::append_range(DeferredDeclsToEmit,
3285 if (DeferredDeclsToEmit.empty())
3290 std::vector<GlobalDecl> CurDeclsToEmit;
3291 CurDeclsToEmit.swap(DeferredDeclsToEmit);
3298 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
3316 if (!GV->isDeclaration())
3320 if (LangOpts.OpenMP && OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(
D))
3324 EmitGlobalDefinition(
D, GV);
3329 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
3331 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
3336void CodeGenModule::EmitVTablesOpportunistically() {
3342 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
3343 &&
"Only emit opportunistic vtables with optimizations");
3347 "This queue should only contain external vtables");
3348 if (
getCXXABI().canSpeculativelyEmitVTable(RD))
3351 OpportunisticVTables.clear();
3355 for (
const auto& [MangledName, VD] : DeferredAnnotations) {
3360 DeferredAnnotations.clear();
3362 if (Annotations.empty())
3366 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
3367 Annotations[0]->getType(), Annotations.size()), Annotations);
3368 auto *gv =
new llvm::GlobalVariable(
getModule(), Array->getType(),
false,
3369 llvm::GlobalValue::AppendingLinkage,
3370 Array,
"llvm.global.annotations");
3375 llvm::Constant *&AStr = AnnotationStrings[Str];
3380 llvm::Constant *
s = llvm::ConstantDataArray::getString(
getLLVMContext(), Str);
3381 auto *gv =
new llvm::GlobalVariable(
3382 getModule(),
s->getType(),
true, llvm::GlobalValue::PrivateLinkage,
s,
3383 ".str",
nullptr, llvm::GlobalValue::NotThreadLocal,
3386 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3403 SM.getExpansionLineNumber(L);
3404 return llvm::ConstantInt::get(
Int32Ty, LineNo);
3412 llvm::FoldingSetNodeID ID;
3413 for (
Expr *
E : Exprs) {
3414 ID.Add(cast<clang::ConstantExpr>(
E)->getAPValueResult());
3416 llvm::Constant *&Lookup = AnnotationArgs[ID.ComputeHash()];
3421 LLVMArgs.reserve(Exprs.size());
3423 llvm::transform(Exprs, std::back_inserter(LLVMArgs), [&](
const Expr *
E) {
3424 const auto *CE = cast<clang::ConstantExpr>(
E);
3425 return ConstEmiter.
emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(),
3428 auto *
Struct = llvm::ConstantStruct::getAnon(LLVMArgs);
3429 auto *GV =
new llvm::GlobalVariable(
getModule(),
Struct->getType(),
true,
3430 llvm::GlobalValue::PrivateLinkage,
Struct,
3433 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3440 const AnnotateAttr *AA,
3448 llvm::Constant *GVInGlobalsAS = GV;
3449 if (GV->getAddressSpace() !=
3451 GVInGlobalsAS = llvm::ConstantExpr::getAddrSpaceCast(
3453 llvm::PointerType::get(
3454 GV->getContext(),
getDataLayout().getDefaultGlobalsAddressSpace()));
3458 llvm::Constant *Fields[] = {
3459 GVInGlobalsAS, AnnoGV, UnitGV, LineNoCst, Args,
3461 return llvm::ConstantStruct::getAnon(Fields);
3465 llvm::GlobalValue *GV) {
3466 assert(
D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
3476 if (NoSanitizeL.containsFunction(Kind, Fn->getName()))
3481 if (NoSanitizeL.containsMainFile(Kind, MainFile.
getName()))
3486 return NoSanitizeL.containsLocation(Kind,
Loc);
3489 return NoSanitizeL.containsFile(Kind, MainFile.
getName());
3493 llvm::GlobalVariable *GV,
3497 if (NoSanitizeL.containsGlobal(Kind, GV->getName(),
Category))
3500 if (NoSanitizeL.containsMainFile(
3501 Kind,
SM.getFileEntryRefForID(
SM.getMainFileID())->getName(),
3504 if (NoSanitizeL.containsLocation(Kind,
Loc,
Category))
3511 while (
auto AT = dyn_cast<ArrayType>(Ty.
getTypePtr()))
3512 Ty = AT->getElementType();
3517 if (NoSanitizeL.containsType(Kind, TypeStr,
Category))
3528 auto Attr = ImbueAttr::NONE;
3531 if (
Attr == ImbueAttr::NONE)
3532 Attr = XRayFilter.shouldImbueFunction(Fn->getName());
3534 case ImbueAttr::NONE:
3536 case ImbueAttr::ALWAYS:
3537 Fn->addFnAttr(
"function-instrument",
"xray-always");
3539 case ImbueAttr::ALWAYS_ARG1:
3540 Fn->addFnAttr(
"function-instrument",
"xray-always");
3541 Fn->addFnAttr(
"xray-log-args",
"1");
3543 case ImbueAttr::NEVER:
3544 Fn->addFnAttr(
"function-instrument",
"xray-never");
3568 if (
auto MainFile =
SM.getFileEntryRefForID(
SM.getMainFileID()))
3582 if (NumGroups > 1) {
3583 auto Group = llvm::crc32(arrayRefFromStringRef(Fn->getName())) % NumGroups;
3592 if (LangOpts.EmitAllDecls)
3595 const auto *VD = dyn_cast<VarDecl>(
Global);
3597 ((CodeGenOpts.KeepPersistentStorageVariables &&
3598 (VD->getStorageDuration() ==
SD_Static ||
3599 VD->getStorageDuration() ==
SD_Thread)) ||
3600 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==
SD_Static &&
3601 VD->getType().isConstQualified())))
3614 if (LangOpts.OpenMP >= 50 && !LangOpts.OpenMPSimd) {
3615 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr =
3616 OMPDeclareTargetDeclAttr::getActiveAttr(
Global);
3617 if (!ActiveAttr || (*ActiveAttr)->getLevel() != (
unsigned)-1)
3621 if (
const auto *FD = dyn_cast<FunctionDecl>(
Global)) {
3630 if (
const auto *VD = dyn_cast<VarDecl>(
Global)) {
3636 if (CXX20ModuleInits && VD->getOwningModule() &&
3637 !VD->getOwningModule()->isModuleMapModule()) {
3646 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
3649 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(
Global))
3662 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3666 llvm::Constant *
Init;
3669 if (!
V.isAbsent()) {
3680 llvm::Constant *Fields[4] = {
3684 llvm::ConstantDataArray::getRaw(
3685 StringRef(
reinterpret_cast<char *
>(Parts.
Part4And5), 8), 8,
3687 Init = llvm::ConstantStruct::getAnon(Fields);
3690 auto *GV =
new llvm::GlobalVariable(
3692 true, llvm::GlobalValue::LinkOnceODRLinkage,
Init, Name);
3694 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3697 if (!
V.isAbsent()) {
3710 llvm::GlobalVariable **Entry =
nullptr;
3711 Entry = &UnnamedGlobalConstantDeclMap[GCD];
3716 llvm::Constant *
Init;
3720 assert(!
V.isAbsent());
3724 auto *GV =
new llvm::GlobalVariable(
getModule(),
Init->getType(),
3726 llvm::GlobalValue::PrivateLinkage,
Init,
3728 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3742 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3746 llvm::Constant *
Init =
Emitter.emitForInitializer(
3754 llvm::GlobalValue::LinkageTypes
Linkage =
3756 ? llvm::GlobalValue::LinkOnceODRLinkage
3757 : llvm::GlobalValue::InternalLinkage;
3758 auto *GV =
new llvm::GlobalVariable(
getModule(),
Init->getType(),
3762 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3769 const AliasAttr *AA = VD->
getAttr<AliasAttr>();
3770 assert(AA &&
"No alias?");
3780 llvm::Constant *Aliasee;
3781 if (isa<llvm::FunctionType>(DeclTy))
3782 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
3789 auto *F = cast<llvm::GlobalValue>(Aliasee);
3790 F->setLinkage(llvm::Function::ExternalWeakLinkage);
3791 WeakRefReferences.insert(F);
3800 return A->isImplicit();
3804bool CodeGenModule::shouldEmitCUDAGlobalVar(
const VarDecl *
Global)
const {
3805 assert(LangOpts.CUDA &&
"Should not be called by non-CUDA languages");
3810 return !LangOpts.CUDAIsDevice ||
Global->hasAttr<CUDADeviceAttr>() ||
3811 Global->hasAttr<CUDAConstantAttr>() ||
3812 Global->hasAttr<CUDASharedAttr>() ||
3813 Global->getType()->isCUDADeviceBuiltinSurfaceType() ||
3814 Global->getType()->isCUDADeviceBuiltinTextureType();
3821 if (
Global->hasAttr<WeakRefAttr>())
3826 if (
Global->hasAttr<AliasAttr>())
3827 return EmitAliasDefinition(GD);
3830 if (
Global->hasAttr<IFuncAttr>())
3831 return emitIFuncDefinition(GD);
3834 if (
Global->hasAttr<CPUDispatchAttr>())
3835 return emitCPUDispatchDefinition(GD);
3840 if (LangOpts.CUDA) {
3841 assert((isa<FunctionDecl>(
Global) || isa<VarDecl>(
Global)) &&
3842 "Expected Variable or Function");
3843 if (
const auto *VD = dyn_cast<VarDecl>(
Global)) {
3844 if (!shouldEmitCUDAGlobalVar(VD))
3846 }
else if (LangOpts.CUDAIsDevice) {
3847 const auto *FD = dyn_cast<FunctionDecl>(
Global);
3848 if ((!
Global->hasAttr<CUDADeviceAttr>() ||
3849 (LangOpts.OffloadImplicitHostDeviceTemplates &&
3850 hasImplicitAttr<CUDAHostAttr>(FD) &&
3851 hasImplicitAttr<CUDADeviceAttr>(FD) && !FD->
isConstexpr() &&
3853 !
getContext().CUDAImplicitHostDeviceFunUsedByDevice.count(FD))) &&
3854 !
Global->hasAttr<CUDAGlobalAttr>() &&
3855 !(LangOpts.HIPStdPar && isa<FunctionDecl>(
Global) &&
3856 !
Global->hasAttr<CUDAHostAttr>()))
3859 }
else if (!
Global->hasAttr<CUDAHostAttr>() &&
3860 Global->hasAttr<CUDADeviceAttr>())
3864 if (LangOpts.OpenMP) {
3866 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
3868 if (
auto *DRD = dyn_cast<OMPDeclareReductionDecl>(
Global)) {
3869 if (MustBeEmitted(
Global))
3873 if (
auto *DMD = dyn_cast<OMPDeclareMapperDecl>(
Global)) {
3874 if (MustBeEmitted(
Global))
3881 if (
const auto *FD = dyn_cast<FunctionDecl>(
Global)) {
3884 if (FD->
hasAttr<AnnotateAttr>()) {
3887 DeferredAnnotations[MangledName] = FD;
3902 GetOrCreateLLVMFunction(MangledName, Ty, GD,
false,
3907 const auto *VD = cast<VarDecl>(
Global);
3908 assert(VD->isFileVarDecl() &&
"Cannot emit local var decl as global.");
3911 if (LangOpts.OpenMP) {
3913 if (std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
3914 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
3918 if (VD->hasExternalStorage() &&
3919 Res != OMPDeclareTargetDeclAttr::MT_Link)
3922 bool UnifiedMemoryEnabled =
3924 if ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3925 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3926 !UnifiedMemoryEnabled) {
3929 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
3930 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3931 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3932 UnifiedMemoryEnabled)) &&
3933 "Link clause or to clause with unified memory expected.");
3952 if (MustBeEmitted(
Global) && MayBeEmittedEagerly(
Global)) {
3954 EmitGlobalDefinition(GD);
3955 addEmittedDeferredDecl(GD);
3962 cast<VarDecl>(
Global)->hasInit()) {
3963 DelayedCXXInitPosition[
Global] = CXXGlobalInits.size();
3964 CXXGlobalInits.push_back(
nullptr);
3970 addDeferredDeclToEmit(GD);
3971 }
else if (MustBeEmitted(
Global)) {
3973 assert(!MayBeEmittedEagerly(
Global));
3974 addDeferredDeclToEmit(GD);
3979 DeferredDecls[MangledName] = GD;
3986 if (
CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
3987 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
3994 struct FunctionIsDirectlyRecursive
3996 const StringRef Name;
4006 if (
Attr && Name ==
Attr->getLabel())
4011 StringRef BuiltinName = BI.
getName(BuiltinID);
4012 if (BuiltinName.starts_with(
"__builtin_") &&
4013 Name == BuiltinName.slice(strlen(
"__builtin_"), StringRef::npos)) {
4019 bool VisitStmt(
const Stmt *S) {
4020 for (
const Stmt *Child : S->children())
4021 if (Child && this->Visit(Child))
4028 struct DLLImportFunctionVisitor
4030 bool SafeToInline =
true;
4032 bool shouldVisitImplicitCode()
const {
return true; }
4034 bool VisitVarDecl(
VarDecl *VD) {
4037 SafeToInline =
false;
4038 return SafeToInline;
4045 return SafeToInline;
4049 if (
const auto *
D =
E->getTemporary()->getDestructor())
4050 SafeToInline =
D->
hasAttr<DLLImportAttr>();
4051 return SafeToInline;
4056 if (isa<FunctionDecl>(VD))
4057 SafeToInline = VD->
hasAttr<DLLImportAttr>();
4058 else if (
VarDecl *
V = dyn_cast<VarDecl>(VD))
4059 SafeToInline = !
V->hasGlobalStorage() ||
V->hasAttr<DLLImportAttr>();
4060 return SafeToInline;
4064 SafeToInline =
E->getConstructor()->hasAttr<DLLImportAttr>();
4065 return SafeToInline;
4072 SafeToInline =
true;
4074 SafeToInline = M->
hasAttr<DLLImportAttr>();
4076 return SafeToInline;
4080 SafeToInline =
E->getOperatorDelete()->hasAttr<DLLImportAttr>();
4081 return SafeToInline;
4085 SafeToInline =
E->getOperatorNew()->hasAttr<DLLImportAttr>();
4086 return SafeToInline;
4095CodeGenModule::isTriviallyRecursive(
const FunctionDecl *FD) {
4097 if (
getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
4102 Name =
Attr->getLabel();
4107 FunctionIsDirectlyRecursive Walker(Name, Context.
BuiltinInfo);
4109 return Body ? Walker.Visit(Body) :
false;
4112bool CodeGenModule::shouldEmitFunction(
GlobalDecl GD) {
4116 const auto *F = cast<FunctionDecl>(GD.
getDecl());
4119 if (F->isInlineBuiltinDeclaration())
4122 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
4127 if (
const Module *M = F->getOwningModule();
4128 M && M->getTopLevelModule()->isNamedModule() &&
4129 getContext().getCurrentNamedModule() != M->getTopLevelModule()) {
4139 if (!F->isTemplateInstantiation() || !F->hasAttr<AlwaysInlineAttr>()) {
4144 if (F->hasAttr<NoInlineAttr>())
4147 if (F->hasAttr<DLLImportAttr>() && !F->hasAttr<AlwaysInlineAttr>()) {
4149 DLLImportFunctionVisitor Visitor;
4150 Visitor.TraverseFunctionDecl(
const_cast<FunctionDecl*
>(F));
4151 if (!Visitor.SafeToInline)
4157 for (
const Decl *
Member : Dtor->getParent()->decls())
4158 if (isa<FieldDecl>(
Member))
4172 return !isTriviallyRecursive(F);
4175bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
4176 return CodeGenOpts.OptimizationLevel > 0;
4179void CodeGenModule::EmitMultiVersionFunctionDefinition(
GlobalDecl GD,
4180 llvm::GlobalValue *GV) {
4181 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4184 auto *Spec = FD->
getAttr<CPUSpecificAttr>();
4185 for (
unsigned I = 0; I < Spec->cpus_size(); ++I)
4187 }
else if (
auto *TC = FD->
getAttr<TargetClonesAttr>()) {
4188 for (
unsigned I = 0; I < TC->featuresStrs_size(); ++I)
4191 TC->isFirstOfVersion(I))
4194 GetOrCreateMultiVersionResolver(GD);
4196 EmitGlobalFunctionDefinition(GD, GV);
4201 AddDeferredMultiVersionResolverToEmit(GD);
4204void CodeGenModule::EmitGlobalDefinition(
GlobalDecl GD, llvm::GlobalValue *GV) {
4205 const auto *
D = cast<ValueDecl>(GD.
getDecl());
4209 "Generating code for declaration");
4211 if (
const auto *FD = dyn_cast<FunctionDecl>(
D)) {
4214 if (!shouldEmitFunction(GD))
4217 llvm::TimeTraceScope TimeScope(
"CodeGen Function", [&]() {
4219 llvm::raw_string_ostream OS(Name);
4225 if (
const auto *Method = dyn_cast<CXXMethodDecl>(
D)) {
4228 if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
4229 ABI->emitCXXStructor(GD);
4231 EmitMultiVersionFunctionDefinition(GD, GV);
4233 EmitGlobalFunctionDefinition(GD, GV);
4235 if (Method->isVirtual())
4242 return EmitMultiVersionFunctionDefinition(GD, GV);
4243 return EmitGlobalFunctionDefinition(GD, GV);
4246 if (
const auto *VD = dyn_cast<VarDecl>(
D))
4247 return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
4249 llvm_unreachable(
"Invalid argument to EmitGlobalDefinition()");
4253 llvm::Function *NewFn);
4256 const CodeGenFunction::FMVResolverOption &RO) {
4258 if (RO.Architecture)
4259 Features.push_back(*RO.Architecture);
4268static llvm::GlobalValue::LinkageTypes
4272 return llvm::GlobalValue::InternalLinkage;
4273 return llvm::GlobalValue::WeakODRLinkage;
4276void CodeGenModule::emitMultiVersionFunctions() {
4277 std::vector<GlobalDecl> MVFuncsToEmit;
4278 MultiVersionFuncs.swap(MVFuncsToEmit);
4280 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4281 assert(FD &&
"Expected a FunctionDecl");
4288 if (
Decl->isDefined()) {
4289 EmitGlobalFunctionDefinition(CurGD,
nullptr);
4297 assert(
Func &&
"This should have just been created");
4299 return cast<llvm::Function>(
Func);
4313 if (
const auto *TA = CurFD->
getAttr<TargetAttr>()) {
4314 assert(getTarget().getTriple().isX86() &&
"Unsupported target");
4315 TA->getX86AddedFeatures(Feats);
4316 llvm::Function *Func = createFunction(CurFD);
4317 Options.emplace_back(Func, Feats, TA->getX86Architecture());
4318 }
else if (
const auto *TVA = CurFD->
getAttr<TargetVersionAttr>()) {
4319 if (TVA->isDefaultVersion() && IsDefined)
4320 ShouldEmitResolver = true;
4321 llvm::Function *Func = createFunction(CurFD);
4322 char Delim = getTarget().getTriple().isAArch64() ?
'+' :
',';
4323 TVA->getFeatures(Feats, Delim);
4324 Options.emplace_back(Func, Feats);
4325 }
else if (
const auto *TC = CurFD->
getAttr<TargetClonesAttr>()) {
4327 ShouldEmitResolver = true;
4328 for (unsigned I = 0; I < TC->featuresStrs_size(); ++I) {
4329 if (!TC->isFirstOfVersion(I))
4332 llvm::Function *Func = createFunction(CurFD, I);
4334 if (getTarget().getTriple().isX86()) {
4335 TC->getX86Feature(Feats, I);
4336 Options.emplace_back(Func, Feats, TC->getX86Architecture(I));
4338 char Delim = getTarget().getTriple().isAArch64() ?
'+' :
',';
4339 TC->getFeatures(Feats, I, Delim);
4340 Options.emplace_back(Func, Feats);
4344 llvm_unreachable(
"unexpected MultiVersionKind");
4347 if (!ShouldEmitResolver)
4350 llvm::Constant *ResolverConstant = GetOrCreateMultiVersionResolver(GD);
4351 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(ResolverConstant)) {
4352 ResolverConstant = IFunc->getResolver();
4356 *
this, GD, FD,
true);
4363 auto *Alias = llvm::GlobalAlias::create(
4365 MangledName +
".ifunc", IFunc, &
getModule());
4370 llvm::Function *ResolverFunc = cast<llvm::Function>(ResolverConstant);
4375 ResolverFunc->setComdat(
4376 getModule().getOrInsertComdat(ResolverFunc->getName()));
4380 Options, [&TI](
const CodeGenFunction::FMVResolverOption &LHS,
4381 const CodeGenFunction::FMVResolverOption &RHS) {
4385 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4391 if (!MVFuncsToEmit.empty())
4396 if (!MultiVersionFuncs.empty())
4397 emitMultiVersionFunctions();
4401 llvm::Constant *New) {
4402 assert(cast<llvm::Function>(Old)->isDeclaration() &&
"Not a declaration");
4404 Old->replaceAllUsesWith(New);
4405 Old->eraseFromParent();
4408void CodeGenModule::emitCPUDispatchDefinition(
GlobalDecl GD) {
4409 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4410 assert(FD &&
"Not a FunctionDecl?");
4412 const auto *DD = FD->
getAttr<CPUDispatchAttr>();
4413 assert(DD &&
"Not a cpu_dispatch Function?");
4419 UpdateMultiVersionNames(GD, FD, ResolverName);
4421 llvm::Type *ResolverType;
4424 ResolverType = llvm::FunctionType::get(
4425 llvm::PointerType::get(DeclTy,
4434 auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
4435 ResolverName, ResolverType, ResolverGD,
false));
4438 ResolverFunc->setComdat(
4439 getModule().getOrInsertComdat(ResolverFunc->getName()));
4452 GlobalDecl ExistingDecl = Manglings.lookup(MangledName);
4455 EmitGlobalFunctionDefinition(ExistingDecl,
nullptr);
4461 Func = GetOrCreateLLVMFunction(
4462 MangledName, DeclTy, ExistingDecl,
4469 Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);
4470 llvm::transform(Features, Features.begin(),
4471 [](StringRef Str) { return Str.substr(1); });
4472 llvm::erase_if(Features, [&
Target](StringRef Feat) {
4473 return !
Target.validateCpuSupports(Feat);
4475 Options.emplace_back(cast<llvm::Function>(
Func), Features);
4479 llvm::stable_sort(Options, [](
const CodeGenFunction::FMVResolverOption &LHS,
4480 const CodeGenFunction::FMVResolverOption &RHS) {
4481 return llvm::X86::getCpuSupportsMask(LHS.Features) >
4482 llvm::X86::getCpuSupportsMask(RHS.Features);
4489 while (Options.size() > 1 && llvm::all_of(llvm::X86::getCpuSupportsMask(
4490 (Options.end() - 2)->Features),
4491 [](
auto X) { return X == 0; })) {
4492 StringRef LHSName = (Options.end() - 2)->
Function->getName();
4493 StringRef RHSName = (Options.end() - 1)->
Function->getName();
4494 if (LHSName.compare(RHSName) < 0)
4495 Options.erase(Options.end() - 2);
4497 Options.erase(Options.end() - 1);
4501 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4505 auto *IFunc = cast<llvm::GlobalValue>(GetOrCreateMultiVersionResolver(GD));
4506 unsigned AS = IFunc->getType()->getPointerAddressSpace();
4510 if (!isa<llvm::GlobalIFunc>(IFunc)) {
4511 auto *GI = llvm::GlobalIFunc::create(DeclTy, AS,
Linkage,
"",
4518 *
this, GD, FD,
true);
4521 auto *GA = llvm::GlobalAlias::create(DeclTy, AS,
Linkage, AliasName,
4529void CodeGenModule::AddDeferredMultiVersionResolverToEmit(
GlobalDecl GD) {
4530 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4531 assert(FD &&
"Not a FunctionDecl?");
4534 std::string MangledName =
4536 if (!DeferredResolversToEmit.insert(MangledName).second)
4539 MultiVersionFuncs.push_back(GD);
4545llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(
GlobalDecl GD) {
4546 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4547 assert(FD &&
"Not a FunctionDecl?");
4549 std::string MangledName =
4554 std::string ResolverName = MangledName;
4558 llvm_unreachable(
"unexpected MultiVersionKind::None for resolver");
4562 ResolverName +=
".ifunc";
4569 ResolverName +=
".resolver";
4572 bool ShouldReturnIFunc =
4582 if (ResolverGV && (isa<llvm::GlobalIFunc>(ResolverGV) || !ShouldReturnIFunc))
4591 AddDeferredMultiVersionResolverToEmit(GD);
4595 if (ShouldReturnIFunc) {
4597 llvm::Type *ResolverType =
4598 llvm::FunctionType::get(llvm::PointerType::get(DeclTy, AS),
false);
4599 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4600 MangledName +
".resolver", ResolverType,
GlobalDecl{},
4602 llvm::GlobalIFunc *GIF =
4605 GIF->setName(ResolverName);
4612 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4614 assert(isa<llvm::GlobalValue>(Resolver) && !ResolverGV &&
4615 "Resolver should be created for the first time");
4620bool CodeGenModule::shouldDropDLLAttribute(
const Decl *
D,
4621 const llvm::GlobalValue *GV)
const {
4622 auto SC = GV->getDLLStorageClass();
4623 if (SC == llvm::GlobalValue::DefaultStorageClass)
4626 return (((SC == llvm::GlobalValue::DLLImportStorageClass &&
4627 !MRD->
hasAttr<DLLImportAttr>()) ||
4628 (SC == llvm::GlobalValue::DLLExportStorageClass &&
4629 !MRD->
hasAttr<DLLExportAttr>())) &&
4640llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
4641 StringRef MangledName, llvm::Type *Ty,
GlobalDecl GD,
bool ForVTable,
4642 bool DontDefer,
bool IsThunk, llvm::AttributeList ExtraAttrs,
4646 std::string NameWithoutMultiVersionMangling;
4649 if (
const FunctionDecl *FD = cast_or_null<FunctionDecl>(
D)) {
4651 if (
getLangOpts().OpenMPIsTargetDevice && OpenMPRuntime &&
4652 !OpenMPRuntime->markAsGlobalTarget(GD) && FD->
isDefined() &&
4653 !DontDefer && !IsForDefinition) {
4656 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
4658 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
4667 UpdateMultiVersionNames(GD, FD, MangledName);
4668 if (!IsForDefinition) {
4674 AddDeferredMultiVersionResolverToEmit(GD);
4676 *
this, GD, FD,
true);
4678 return GetOrCreateMultiVersionResolver(GD);
4683 if (!NameWithoutMultiVersionMangling.empty())
4684 MangledName = NameWithoutMultiVersionMangling;
4689 if (WeakRefReferences.erase(Entry)) {
4691 if (FD && !FD->
hasAttr<WeakAttr>())
4692 Entry->setLinkage(llvm::Function::ExternalLinkage);
4696 if (
D && shouldDropDLLAttribute(
D, Entry)) {
4697 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4703 if (IsForDefinition && !Entry->isDeclaration()) {
4710 DiagnosedConflictingDefinitions.insert(GD).second) {
4714 diag::note_previous_definition);
4718 if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
4719 (Entry->getValueType() == Ty)) {
4726 if (!IsForDefinition)
4733 bool IsIncompleteFunction =
false;
4735 llvm::FunctionType *FTy;
4736 if (isa<llvm::FunctionType>(Ty)) {
4737 FTy = cast<llvm::FunctionType>(Ty);
4739 FTy = llvm::FunctionType::get(
VoidTy,
false);
4740 IsIncompleteFunction =
true;
4744 llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
4745 Entry ? StringRef() : MangledName, &
getModule());
4750 DeferredAnnotations[MangledName] = cast<ValueDecl>(
D);
4767 if (!Entry->use_empty()) {
4769 Entry->removeDeadConstantUsers();
4775 assert(F->getName() == MangledName &&
"name was uniqued!");
4777 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
4778 if (ExtraAttrs.hasFnAttrs()) {
4779 llvm::AttrBuilder B(F->getContext(), ExtraAttrs.getFnAttrs());
4787 if (isa_and_nonnull<CXXDestructorDecl>(
D) &&
4788 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(
D),
4790 addDeferredDeclToEmit(GD);
4795 auto DDI = DeferredDecls.find(MangledName);
4796 if (DDI != DeferredDecls.end()) {
4800 addDeferredDeclToEmit(DDI->second);
4801 DeferredDecls.erase(DDI);
4816 for (
const auto *FD = cast<FunctionDecl>(
D)->getMostRecentDecl(); FD;
4829 if (!IsIncompleteFunction) {
4830 assert(F->getFunctionType() == Ty);
4846 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4853 if (
const auto *DD = dyn_cast<CXXDestructorDecl>(GD.
getDecl())) {
4856 DD->getParent()->getNumVBases() == 0)
4861 auto *F = GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
4862 false, llvm::AttributeList(),
4865 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
4866 cast<FunctionDecl>(GD.
getDecl())->hasAttr<CUDAGlobalAttr>()) {
4868 cast<llvm::Function>(F->stripPointerCasts()), GD);
4869 if (IsForDefinition)
4877 llvm::GlobalValue *F =
4880 return llvm::NoCFIValue::get(F);
4890 if (
const auto *FD = dyn_cast<FunctionDecl>(
Result))
4893 if (!
C.getLangOpts().CPlusPlus)
4898 (Name ==
"_ZSt9terminatev" || Name ==
"?terminate@@YAXXZ")
4899 ?
C.Idents.get(
"terminate")
4900 :
C.Idents.get(Name);
4902 for (
const auto &N : {
"__cxxabiv1",
"std"}) {
4906 if (
auto *LSD = dyn_cast<LinkageSpecDecl>(
Result))
4907 for (
const auto *
Result : LSD->lookup(&NS))
4908 if ((ND = dyn_cast<NamespaceDecl>(
Result)))
4913 if (
const auto *FD = dyn_cast<FunctionDecl>(
Result))
4922 llvm::Function *F, StringRef Name) {
4928 if (!Local && CGM.
getTriple().isWindowsItaniumEnvironment() &&
4931 if (!FD || FD->
hasAttr<DLLImportAttr>()) {
4932 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
4933 F->setLinkage(llvm::GlobalValue::ExternalLinkage);
4940 llvm::AttributeList ExtraAttrs,
bool Local,
bool AssumeConvergent) {
4941 if (AssumeConvergent) {
4943 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
4951 llvm::Constant *
C = GetOrCreateLLVMFunction(
4953 false,
false, ExtraAttrs);
4955 if (
auto *F = dyn_cast<llvm::Function>(
C)) {
4971 llvm::AttributeList ExtraAttrs,
bool Local,
4972 bool AssumeConvergent) {
4973 if (AssumeConvergent) {
4975 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
4979 GetOrCreateLLVMFunction(Name, FTy,
GlobalDecl(),
false,
4983 if (
auto *F = dyn_cast<llvm::Function>(
C)) {
4992 markRegisterParameterAttributes(F);
5018 if (WeakRefReferences.erase(Entry)) {
5020 Entry->setLinkage(llvm::Function::ExternalLinkage);
5024 if (
D && shouldDropDLLAttribute(
D, Entry))
5025 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
5027 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd &&
D)
5030 if (Entry->getValueType() == Ty && Entry->getAddressSpace() == TargetAS)
5035 if (IsForDefinition && !Entry->isDeclaration()) {
5043 (OtherD = dyn_cast<VarDecl>(OtherGD.
getDecl())) &&
5045 DiagnosedConflictingDefinitions.insert(
D).second) {
5049 diag::note_previous_definition);
5054 if (Entry->getType()->getAddressSpace() != TargetAS)
5055 return llvm::ConstantExpr::getAddrSpaceCast(
5056 Entry, llvm::PointerType::get(Ty->getContext(), TargetAS));
5060 if (!IsForDefinition)
5066 auto *GV =
new llvm::GlobalVariable(
5067 getModule(), Ty,
false, llvm::GlobalValue::ExternalLinkage,
nullptr,
5068 MangledName,
nullptr, llvm::GlobalVariable::NotThreadLocal,
5069 getContext().getTargetAddressSpace(DAddrSpace));
5074 GV->takeName(Entry);
5076 if (!Entry->use_empty()) {
5077 Entry->replaceAllUsesWith(GV);
5080 Entry->eraseFromParent();
5086 auto DDI = DeferredDecls.find(MangledName);
5087 if (DDI != DeferredDecls.end()) {
5090 addDeferredDeclToEmit(DDI->second);
5091 DeferredDecls.erase(DDI);
5096 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
5101 GV->setConstant(
D->getType().isConstantStorage(
getContext(),
false,
false));
5103 GV->setAlignment(
getContext().getDeclAlign(
D).getAsAlign());
5107 if (
D->getTLSKind()) {
5109 CXXThreadLocals.push_back(
D);
5117 if (
getContext().isMSStaticDataMemberInlineDefinition(
D)) {
5118 EmitGlobalVarDefinition(
D);
5122 if (
D->hasExternalStorage()) {
5123 if (
const SectionAttr *SA =
D->
getAttr<SectionAttr>())
5124 GV->setSection(SA->getName());
5128 if (
getTriple().getArch() == llvm::Triple::xcore &&
5130 D->getType().isConstant(Context) &&
5132 GV->setSection(
".cp.rodata");
5135 if (
const auto *CMA =
D->
getAttr<CodeModelAttr>())
5136 GV->setCodeModel(CMA->getModel());
5141 if (Context.
getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
5142 D->getType().isConstQualified() && !GV->hasInitializer() &&
5143 !
D->hasDefinition() &&
D->hasInit() && !
D->
hasAttr<DLLImportAttr>()) {
5147 if (!HasMutableFields) {
5149 const Expr *InitExpr =
D->getAnyInitializer(InitDecl);
5154 auto *InitType =
Init->getType();
5155 if (GV->getValueType() != InitType) {
5160 GV->setName(StringRef());
5163 auto *NewGV = cast<llvm::GlobalVariable>(
5165 ->stripPointerCasts());
5168 GV->eraseFromParent();
5171 GV->setInitializer(
Init);
5172 GV->setConstant(
true);
5173 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
5188 D->hasExternalStorage())
5193 SanitizerMD->reportGlobal(GV, *
D);
5196 D ?
D->getType().getAddressSpace()
5198 assert(
getContext().getTargetAddressSpace(ExpectedAS) == TargetAS);
5199 if (DAddrSpace != ExpectedAS) {
5201 *
this, GV, DAddrSpace, ExpectedAS,
5212 if (isa<CXXConstructorDecl>(
D) || isa<CXXDestructorDecl>(
D))
5214 false, IsForDefinition);
5216 if (isa<CXXMethodDecl>(
D)) {
5224 if (isa<FunctionDecl>(
D)) {
5235 StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes
Linkage,
5236 llvm::Align Alignment) {
5237 llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name);
5238 llvm::GlobalVariable *OldGV =
nullptr;
5242 if (GV->getValueType() == Ty)
5247 assert(GV->isDeclaration() &&
"Declaration has wrong type!");
5252 GV =
new llvm::GlobalVariable(
getModule(), Ty,
true,
5257 GV->takeName(OldGV);
5259 if (!OldGV->use_empty()) {
5260 OldGV->replaceAllUsesWith(GV);
5263 OldGV->eraseFromParent();
5267 !GV->hasAvailableExternallyLinkage())
5268 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
5270 GV->setAlignment(Alignment);
5284 assert(
D->hasGlobalStorage() &&
"Not a global variable");
5302 setDSOLocal(cast<llvm::GlobalValue>(Ret->stripPointerCasts()));
5307 assert(!
D->getInit() &&
"Cannot emit definite definitions here!");
5315 if (GV && !GV->isDeclaration())
5320 if (!MustBeEmitted(
D) && !GV) {
5321 DeferredDecls[MangledName] =
D;
5326 EmitGlobalVarDefinition(
D);
5330 if (
auto const *
V = dyn_cast<const VarDecl>(
D))
5331 EmitExternalVarDeclaration(
V);
5332 if (
auto const *FD = dyn_cast<const FunctionDecl>(
D))
5333 EmitExternalFunctionDeclaration(FD);
5342 if (LangOpts.OpenCL) {
5353 if (LangOpts.SYCLIsDevice &&
5357 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
5359 if (
D->
hasAttr<CUDAConstantAttr>())
5365 if (
D->getType().isConstQualified())
5371 if (LangOpts.OpenMP) {
5373 if (OpenMPRuntime->hasAllocateAttributeForGlobalVar(
D, AS))
5381 if (LangOpts.OpenCL)
5383 if (LangOpts.SYCLIsDevice)
5385 if (LangOpts.HIP && LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())
5393 if (
auto AS =
getTarget().getConstantAddressSpace())
5406static llvm::Constant *
5408 llvm::GlobalVariable *GV) {
5409 llvm::Constant *Cast = GV;
5415 llvm::PointerType::get(
5422template<
typename SomeDecl>
5424 llvm::GlobalValue *GV) {
5430 if (!
D->template hasAttr<UsedAttr>())
5439 const SomeDecl *
First =
D->getFirstDecl();
5440 if (
First->getDeclContext()->isRecord() || !
First->isInExternCContext())
5446 std::pair<StaticExternCMap::iterator, bool> R =
5447 StaticExternCValues.insert(std::make_pair(
D->getIdentifier(), GV));
5452 R.first->second =
nullptr;
5463 if (
auto *VD = dyn_cast<VarDecl>(&
D))
5477 llvm_unreachable(
"No such linkage");
5485 llvm::GlobalObject &GO) {
5488 GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
5496void CodeGenModule::EmitGlobalVarDefinition(
const VarDecl *
D,
5506 if (LangOpts.OpenMPIsTargetDevice && OpenMPRuntime &&
5507 OpenMPRuntime->emitTargetGlobalVariable(
D))
5510 llvm::TrackingVH<llvm::Constant>
Init;
5511 bool NeedsGlobalCtor =
false;
5515 bool IsDefinitionAvailableExternally =
5517 bool NeedsGlobalDtor =
5518 !IsDefinitionAvailableExternally &&
5525 if (IsDefinitionAvailableExternally &&
5526 (!
D->hasConstantInitialization() ||
5530 !
D->getType().isConstantStorage(
getContext(),
true,
true)))
5534 const Expr *InitExpr =
D->getAnyInitializer(InitDecl);
5536 std::optional<ConstantEmitter> emitter;
5541 bool IsCUDASharedVar =
5546 bool IsCUDAShadowVar =
5550 bool IsCUDADeviceShadowVar =
5552 (
D->getType()->isCUDADeviceBuiltinSurfaceType() ||
5553 D->getType()->isCUDADeviceBuiltinTextureType());
5555 (IsCUDASharedVar || IsCUDAShadowVar || IsCUDADeviceShadowVar))
5556 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
5557 else if (
D->
hasAttr<LoaderUninitializedAttr>())
5558 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
5559 else if (!InitExpr) {
5573 emitter.emplace(*
this);
5574 llvm::Constant *
Initializer = emitter->tryEmitForInitializer(*InitDecl);
5577 if (
D->getType()->isReferenceType())
5582 if (!IsDefinitionAvailableExternally)
5583 NeedsGlobalCtor =
true;
5587 NeedsGlobalCtor =
false;
5599 DelayedCXXInitPosition.erase(
D);
5606 assert(VarSize == CstSize &&
"Emitted constant has unexpected size");
5611 llvm::Type* InitType =
Init->getType();
5612 llvm::Constant *Entry =
5616 Entry = Entry->stripPointerCasts();
5619 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
5630 if (!GV || GV->getValueType() != InitType ||
5631 GV->getType()->getAddressSpace() !=
5635 Entry->setName(StringRef());
5638 GV = cast<llvm::GlobalVariable>(
5640 ->stripPointerCasts());
5643 llvm::Constant *NewPtrForOldDecl =
5644 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV,
5646 Entry->replaceAllUsesWith(NewPtrForOldDecl);
5649 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
5667 if (LangOpts.CUDA) {
5668 if (LangOpts.CUDAIsDevice) {
5669 if (
Linkage != llvm::GlobalValue::InternalLinkage &&
5671 D->getType()->isCUDADeviceBuiltinSurfaceType() ||
5672 D->getType()->isCUDADeviceBuiltinTextureType()))
5673 GV->setExternallyInitialized(
true);
5683 GV->setInitializer(
Init);
5685 emitter->finalize(GV);
5688 GV->setConstant((
D->
hasAttr<CUDAConstantAttr>() && LangOpts.CUDAIsDevice) ||
5689 (!NeedsGlobalCtor && !NeedsGlobalDtor &&
5690 D->getType().isConstantStorage(
getContext(),
true,
true)));
5693 if (
const SectionAttr *SA =
D->
getAttr<SectionAttr>()) {
5696 GV->setConstant(
true);
5701 if (std::optional<CharUnits> AlignValFromAllocate =
5703 AlignVal = *AlignValFromAllocate;
5721 Linkage == llvm::GlobalValue::ExternalLinkage &&
5724 Linkage = llvm::GlobalValue::InternalLinkage;
5728 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
5729 else if (
D->
hasAttr<DLLExportAttr>())
5730 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
5732 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
5734 if (
Linkage == llvm::GlobalVariable::CommonLinkage) {
5736 GV->setConstant(
false);
5741 if (!GV->getInitializer()->isNullValue())
5742 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
5745 setNonAliasAttributes(
D, GV);
5747 if (
D->getTLSKind() && !GV->isThreadLocal()) {
5749 CXXThreadLocals.push_back(
D);
5756 if (NeedsGlobalCtor || NeedsGlobalDtor)
5757 EmitCXXGlobalVarDeclInitFunc(
D, GV, NeedsGlobalCtor);
5759 SanitizerMD->reportGlobal(GV, *
D, NeedsGlobalCtor);
5764 DI->EmitGlobalVariable(GV,
D);
5767void CodeGenModule::EmitExternalVarDeclaration(
const VarDecl *
D) {
5772 llvm::Constant *GV =
5774 DI->EmitExternalVariable(
5775 cast<llvm::GlobalVariable>(GV->stripPointerCasts()),
D);
5779void CodeGenModule::EmitExternalFunctionDeclaration(
const FunctionDecl *FD) {
5784 auto *
Fn = cast<llvm::Function>(
5785 GetOrCreateLLVMFunction(MangledName, Ty, FD,
false));
5786 if (!
Fn->getSubprogram())
5803 if (
D->getInit() ||
D->hasExternalStorage())
5813 if (
D->
hasAttr<PragmaClangBSSSectionAttr>() ||
5814 D->
hasAttr<PragmaClangDataSectionAttr>() ||
5815 D->
hasAttr<PragmaClangRelroSectionAttr>() ||
5816 D->
hasAttr<PragmaClangRodataSectionAttr>())
5820 if (
D->getTLSKind())
5843 if (FD->isBitField())
5845 if (FD->
hasAttr<AlignedAttr>())
5867llvm::GlobalValue::LinkageTypes
5871 return llvm::Function::InternalLinkage;
5874 return llvm::GlobalVariable::WeakAnyLinkage;
5878 return llvm::GlobalVariable::LinkOnceAnyLinkage;
5883 return llvm::GlobalValue::AvailableExternallyLinkage;
5897 return !Context.
getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
5898 : llvm::Function::InternalLinkage;
5912 return llvm::Function::ExternalLinkage;
5915 return D->
hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
5916 : llvm::Function::InternalLinkage;
5917 return llvm::Function::WeakODRLinkage;
5924 CodeGenOpts.NoCommon))
5925 return llvm::GlobalVariable::CommonLinkage;
5932 return llvm::GlobalVariable::WeakODRLinkage;
5936 return llvm::GlobalVariable::ExternalLinkage;
5939llvm::GlobalValue::LinkageTypes
5948 llvm::Function *newFn) {
5950 if (old->use_empty())
5953 llvm::Type *newRetTy = newFn->getReturnType();
5958 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
5960 llvm::User *user = ui->getUser();
5964 if (
auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
5965 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
5971 llvm::CallBase *callSite = dyn_cast<llvm::CallBase>(user);
5974 if (!callSite->isCallee(&*ui))
5979 if (callSite->getType() != newRetTy && !callSite->use_empty())
5984 llvm::AttributeList oldAttrs = callSite->getAttributes();
5987 unsigned newNumArgs = newFn->arg_size();
5988 if (callSite->arg_size() < newNumArgs)
5994 bool dontTransform =
false;
5995 for (llvm::Argument &A : newFn->args()) {
5996 if (callSite->getArgOperand(argNo)->getType() != A.getType()) {
5997 dontTransform =
true;
6002 newArgAttrs.push_back(oldAttrs.getParamAttrs(argNo));
6010 newArgs.append(callSite->arg_begin(), callSite->arg_begin() + argNo);
6014 callSite->getOperandBundlesAsDefs(newBundles);
6016 llvm::CallBase *newCall;
6017 if (isa<llvm::CallInst>(callSite)) {
6018 newCall = llvm::CallInst::Create(newFn, newArgs, newBundles,
"",
6019 callSite->getIterator());
6021 auto *oldInvoke = cast<llvm::InvokeInst>(callSite);
6022 newCall = llvm::InvokeInst::Create(
6023 newFn, oldInvoke->getNormalDest(), oldInvoke->getUnwindDest(),
6024 newArgs, newBundles,
"", callSite->getIterator());
6028 if (!newCall->getType()->isVoidTy())
6029 newCall->takeName(callSite);
6030 newCall->setAttributes(
6031 llvm::AttributeList::get(newFn->getContext(), oldAttrs.getFnAttrs(),
6032 oldAttrs.getRetAttrs(), newArgAttrs));
6033 newCall->setCallingConv(callSite->getCallingConv());
6036 if (!callSite->use_empty())
6037 callSite->replaceAllUsesWith(newCall);
6040 if (callSite->getDebugLoc())
6041 newCall->setDebugLoc(callSite->getDebugLoc());
6043 callSitesToBeRemovedFromParent.push_back(callSite);
6046 for (
auto *callSite : callSitesToBeRemovedFromParent) {
6047 callSite->eraseFromParent();
6061 llvm::Function *NewFn) {
6063 if (!isa<llvm::Function>(Old))
return;
6071 (LangOpts.CUDA && !shouldEmitCUDAGlobalVar(VD)))
6083void CodeGenModule::EmitGlobalFunctionDefinition(
GlobalDecl GD,
6084 llvm::GlobalValue *GV) {
6085 const auto *
D = cast<FunctionDecl>(GD.
getDecl());
6092 if (!GV || (GV->getValueType() != Ty))
6098 if (!GV->isDeclaration())
6105 auto *Fn = cast<llvm::Function>(GV);
6117 setNonAliasAttributes(GD, Fn);
6120 if (
const ConstructorAttr *CA =
D->
getAttr<ConstructorAttr>())
6122 if (
const DestructorAttr *DA =
D->
getAttr<DestructorAttr>())
6128void CodeGenModule::EmitAliasDefinition(
GlobalDecl GD) {
6129 const auto *
D = cast<ValueDecl>(GD.
getDecl());
6130 const AliasAttr *AA =
D->
getAttr<AliasAttr>();
6131 assert(AA &&
"Not an alias?");
6135 if (AA->getAliasee() == MangledName) {
6136 Diags.
Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
6143 if (Entry && !Entry->isDeclaration())
6146 Aliases.push_back(GD);
6152 llvm::Constant *Aliasee;
6153 llvm::GlobalValue::LinkageTypes
LT;
6154 if (isa<llvm::FunctionType>(DeclTy)) {
6155 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
6161 if (
const auto *VD = dyn_cast<VarDecl>(GD.
getDecl()))
6168 unsigned AS = Aliasee->getType()->getPointerAddressSpace();
6170 llvm::GlobalAlias::create(DeclTy, AS,
LT,
"", Aliasee, &
getModule());
6173 if (GA->getAliasee() == Entry) {
6174 Diags.
Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
6178 assert(Entry->isDeclaration());
6187 GA->takeName(Entry);
6189 Entry->replaceAllUsesWith(GA);
6190 Entry->eraseFromParent();
6192 GA->setName(MangledName);
6200 GA->setLinkage(llvm::Function::WeakAnyLinkage);
6203 if (
const auto *VD = dyn_cast<VarDecl>(
D))
6204 if (VD->getTLSKind())
6210 if (isa<VarDecl>(
D))
6212 DI->EmitGlobalAlias(cast<llvm::GlobalValue>(GA->getAliasee()->stripPointerCasts()), GD);
6215void CodeGenModule::emitIFuncDefinition(
GlobalDecl GD) {
6216 const auto *
D = cast<ValueDecl>(GD.
getDecl());
6217 const IFuncAttr *IFA =
D->
getAttr<IFuncAttr>();
6218 assert(IFA &&
"Not an ifunc?");
6222 if (IFA->getResolver() == MangledName) {
6223 Diags.
Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
6229 if (Entry && !Entry->isDeclaration()) {
6232 DiagnosedConflictingDefinitions.insert(GD).second) {
6236 diag::note_previous_definition);
6241 Aliases.push_back(GD);
6247 llvm::Constant *Resolver =
6248 GetOrCreateLLVMFunction(IFA->getResolver(),
VoidTy, {},
6252 llvm::GlobalIFunc *GIF = llvm::GlobalIFunc::create(
6253 DeclTy, AS, llvm::Function::ExternalLinkage,
"", Resolver, &
getModule());
6255 if (GIF->getResolver() == Entry) {
6256 Diags.
Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
6259 assert(Entry->isDeclaration());
6268 GIF->takeName(Entry);
6270 Entry->replaceAllUsesWith(GIF);
6271 Entry->eraseFromParent();
6273 GIF->setName(MangledName);
6279 return llvm::Intrinsic::getOrInsertDeclaration(&
getModule(),
6280 (llvm::Intrinsic::ID)IID, Tys);
6283static llvm::StringMapEntry<llvm::GlobalVariable *> &
6286 bool &IsUTF16,
unsigned &StringLength) {
6287 StringRef String = Literal->getString();
6288 unsigned NumBytes = String.size();
6291 if (!Literal->containsNonAsciiOrNull()) {
6292 StringLength = NumBytes;
6293 return *Map.insert(std::make_pair(String,
nullptr)).first;
6300 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
6301 llvm::UTF16 *ToPtr = &ToBuf[0];
6303 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
6304 ToPtr + NumBytes, llvm::strictConversion);
6307 StringLength = ToPtr - &ToBuf[0];
6311 return *Map.insert(std::make_pair(
6312 StringRef(
reinterpret_cast<const char *
>(ToBuf.data()),
6313 (StringLength + 1) * 2),
6319 unsigned StringLength = 0;
6320 bool isUTF16 =
false;
6321 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
6326 if (
auto *
C = Entry.second)
6331 const llvm::Triple &Triple =
getTriple();
6334 const bool IsSwiftABI =
6335 static_cast<unsigned>(CFRuntime) >=
6340 if (!CFConstantStringClassRef) {
6341 const char *CFConstantStringClassName =
"__CFConstantStringClassReference";
6343 Ty = llvm::ArrayType::get(Ty, 0);
6345 switch (CFRuntime) {
6349 CFConstantStringClassName =
6350 Triple.isOSDarwin() ?
"$s15SwiftFoundation19_NSCFConstantStringCN"
6351 :
"$s10Foundation19_NSCFConstantStringCN";
6355 CFConstantStringClassName =
6356 Triple.isOSDarwin() ?
"$S15SwiftFoundation19_NSCFConstantStringCN"
6357 :
"$S10Foundation19_NSCFConstantStringCN";
6361 CFConstantStringClassName =
6362 Triple.isOSDarwin() ?
"__T015SwiftFoundation19_NSCFConstantStringCN"
6363 :
"__T010Foundation19_NSCFConstantStringCN";
6370 if (Triple.isOSBinFormatELF() || Triple.isOSBinFormatCOFF()) {
6371 llvm::GlobalValue *GV =
nullptr;
6373 if ((GV = dyn_cast<llvm::GlobalValue>(
C))) {
6380 if ((VD = dyn_cast<VarDecl>(
Result)))
6383 if (Triple.isOSBinFormatELF()) {
6385 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6387 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6388 if (!VD || !VD->
hasAttr<DLLExportAttr>())
6389 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6391 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6399 CFConstantStringClassRef =
6400 IsSwiftABI ? llvm::ConstantExpr::getPtrToInt(
C, Ty) :
C;
6405 auto *STy = cast<llvm::StructType>(
getTypes().ConvertType(CFTy));
6408 auto Fields = Builder.beginStruct(STy);
6411 Fields.add(cast<llvm::Constant>(CFConstantStringClassRef));
6415 Fields.addInt(
IntPtrTy, IsSwift4_1 ? 0x05 : 0x01);
6416 Fields.addInt(
Int64Ty, isUTF16 ? 0x07d0 : 0x07c8);
6418 Fields.addInt(
IntTy, isUTF16 ? 0x07d0 : 0x07C8);
6422 llvm::Constant *
C =
nullptr;
6425 reinterpret_cast<uint16_t *
>(
const_cast<char *
>(Entry.first().data())),
6426 Entry.first().size() / 2);
6427 C = llvm::ConstantDataArray::get(VMContext, Arr);
6429 C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
6435 new llvm::GlobalVariable(
getModule(),
C->getType(),
true,
6436 llvm::GlobalValue::PrivateLinkage,
C,
".str");
6437 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6447 if (Triple.isOSBinFormatMachO())
6448 GV->setSection(isUTF16 ?
"__TEXT,__ustring"
6449 :
"__TEXT,__cstring,cstring_literals");
6452 else if (Triple.isOSBinFormatELF())
6453 GV->setSection(
".rodata");
6459 llvm::IntegerType *LengthTy =
6469 Fields.addInt(LengthTy, StringLength);
6477 GV = Fields.finishAndCreateGlobal(
"_unnamed_cfstring_", Alignment,
6479 llvm::GlobalVariable::PrivateLinkage);
6480 GV->addAttribute(
"objc_arc_inert");
6481 switch (Triple.getObjectFormat()) {
6482 case llvm::Triple::UnknownObjectFormat:
6483 llvm_unreachable(
"unknown file format");
6484 case llvm::Triple::DXContainer:
6485 case llvm::Triple::GOFF:
6486 case llvm::Triple::SPIRV:
6487 case llvm::Triple::XCOFF:
6488 llvm_unreachable(
"unimplemented");
6489 case llvm::Triple::COFF:
6490 case llvm::Triple::ELF:
6491 case llvm::Triple::Wasm:
6492 GV->setSection(
"cfstring");
6494 case llvm::Triple::MachO:
6495 GV->setSection(
"__DATA,__cfstring");
6504 return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
6508 if (ObjCFastEnumerationStateType.
isNull()) {
6510 D->startDefinition();
6518 for (
size_t i = 0; i < 4; ++i) {
6523 FieldTypes[i],
nullptr,
6531 D->completeDefinition();
6535 return ObjCFastEnumerationStateType;
6544 if (
E->getCharByteWidth() == 1) {
6549 assert(CAT &&
"String literal not of constant array type!");
6551 return llvm::ConstantDataArray::getString(VMContext, Str,
false);
6555 llvm::Type *ElemTy = AType->getElementType();
6556 unsigned NumElements = AType->getNumElements();
6559 if (ElemTy->getPrimitiveSizeInBits() == 16) {
6561 Elements.reserve(NumElements);
6563 for(
unsigned i = 0, e =
E->getLength(); i != e; ++i)
6564 Elements.push_back(
E->getCodeUnit(i));
6565 Elements.resize(NumElements);
6566 return llvm::ConstantDataArray::get(VMContext, Elements);
6569 assert(ElemTy->getPrimitiveSizeInBits() == 32);
6571 Elements.reserve(NumElements);
6573 for(
unsigned i = 0, e =
E->getLength(); i != e; ++i)
6574 Elements.push_back(
E->getCodeUnit(i));
6575 Elements.resize(NumElements);
6576 return llvm::ConstantDataArray::get(VMContext, Elements);
6579static llvm::GlobalVariable *
6588 auto *GV =
new llvm::GlobalVariable(
6589 M,
C->getType(), !CGM.
getLangOpts().WritableStrings,
LT,
C, GlobalName,
6590 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
6592 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6593 if (GV->isWeakForLinker()) {
6594 assert(CGM.
supportsCOMDAT() &&
"Only COFF uses weak string literals");
6595 GV->setComdat(M.getOrInsertComdat(GV->getName()));
6611 llvm::GlobalVariable **Entry =
nullptr;
6612 if (!LangOpts.WritableStrings) {
6613 Entry = &ConstantStringMap[
C];
6614 if (
auto GV = *Entry) {
6615 if (uint64_t(Alignment.
getQuantity()) > GV->getAlignment())
6618 GV->getValueType(), Alignment);
6623 StringRef GlobalVariableName;
6624 llvm::GlobalValue::LinkageTypes
LT;
6629 if (
getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
6630 !LangOpts.WritableStrings) {
6631 llvm::raw_svector_ostream Out(MangledNameBuffer);
6633 LT = llvm::GlobalValue::LinkOnceODRLinkage;
6634 GlobalVariableName = MangledNameBuffer;
6636 LT = llvm::GlobalValue::PrivateLinkage;
6637 GlobalVariableName = Name;
6649 SanitizerMD->reportGlobal(GV, S->getStrTokenLoc(0),
"<string literal>");
6652 GV->getValueType(), Alignment);
6669 const std::string &Str,
const char *GlobalName) {
6670 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
6675 llvm::ConstantDataArray::getString(
getLLVMContext(), StrWithNull,
false);
6678 llvm::GlobalVariable **Entry =
nullptr;
6679 if (!LangOpts.WritableStrings) {
6680 Entry = &ConstantStringMap[
C];
6681 if (
auto GV = *Entry) {
6682 if (uint64_t(Alignment.
getQuantity()) > GV->getAlignment())
6685 GV->getValueType(), Alignment);
6691 GlobalName =
".str";
6694 GlobalName, Alignment);
6699 GV->getValueType(), Alignment);
6704 assert((
E->getStorageDuration() ==
SD_Static ||
6705 E->getStorageDuration() ==
SD_Thread) &&
"not a global temporary");
6706 const auto *VD = cast<VarDecl>(
E->getExtendingDecl());
6711 if (
Init ==
E->getSubExpr())
6716 auto InsertResult = MaterializedGlobalTemporaryMap.insert({
E,
nullptr});
6717 if (!InsertResult.second) {
6720 if (!InsertResult.first->second) {
6725 InsertResult.first->second =
new llvm::GlobalVariable(
6726 getModule(),
Type,
false, llvm::GlobalVariable::InternalLinkage,
6730 llvm::cast<llvm::GlobalVariable>(
6731 InsertResult.first->second->stripPointerCasts())
6740 llvm::raw_svector_ostream Out(Name);
6742 VD,
E->getManglingNumber(), Out);
6745 if (
E->getStorageDuration() ==
SD_Static && VD->evaluateValue()) {
6751 Value =
E->getOrCreateValue(
false);
6762 std::optional<ConstantEmitter> emitter;
6763 llvm::Constant *InitialValue =
nullptr;
6764 bool Constant =
false;
6768 emitter.emplace(*
this);
6769 InitialValue = emitter->emitForInitializer(*
Value, AddrSpace,
6774 Type = InitialValue->getType();
6783 if (
Linkage == llvm::GlobalVariable::ExternalLinkage) {
6785 if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
6789 Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
6793 Linkage = llvm::GlobalVariable::InternalLinkage;
6797 auto *GV =
new llvm::GlobalVariable(
6799 nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
6800 if (emitter) emitter->finalize(GV);
6802 if (!llvm::GlobalValue::isLocalLinkage(
Linkage)) {
6804 if (GV->getDLLStorageClass() == llvm::GlobalVariable::DLLExportStorageClass)
6806 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
6810 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
6811 if (VD->getTLSKind())
6813 llvm::Constant *CV = GV;
6817 llvm::PointerType::get(
6823 llvm::Constant *&Entry = MaterializedGlobalTemporaryMap[
E];
6825 Entry->replaceAllUsesWith(CV);
6826 llvm::cast<llvm::GlobalVariable>(Entry)->eraseFromParent();
6835void CodeGenModule::EmitObjCPropertyImplementations(
const
6837 for (
const auto *PID :
D->property_impls()) {
6848 if (!Getter || Getter->isSynthesizedAccessorStub())
6851 auto *Setter = PID->getSetterMethodDecl();
6852 if (!PD->
isReadOnly() && (!Setter || Setter->isSynthesizedAccessorStub()))
6863 if (ivar->getType().isDestructedType())
6873 E =
D->init_end(); B !=
E; ++B) {
6896 D->addInstanceMethod(DTORMethod);
6898 D->setHasDestructors(
true);
6903 if (
D->getNumIvarInitializers() == 0 ||
6917 D->addInstanceMethod(CTORMethod);
6919 D->setHasNonZeroConstructors(
true);
6930 EmitDeclContext(LSD);
6935 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
6938 std::unique_ptr<CodeGenFunction> &CurCGF =
6939 GlobalTopLevelStmtBlockInFlight.first;
6943 if (CurCGF && CXXGlobalInits.back() != CurCGF->CurFn) {
6951 std::string Name =
"__stmts__" + llvm::utostr(CXXGlobalInits.size());
6957 llvm::Function *
Fn = llvm::Function::Create(
6958 FnTy, llvm::GlobalValue::InternalLinkage, Name, &
getModule());
6961 GlobalTopLevelStmtBlockInFlight.second =
D;
6962 CurCGF->StartFunction(
GlobalDecl(), RetTy, Fn, FnInfo, Args,
6964 CXXGlobalInits.push_back(Fn);
6967 CurCGF->EmitStmt(
D->getStmt());
6970void CodeGenModule::EmitDeclContext(
const DeclContext *DC) {
6971 for (
auto *I : DC->
decls()) {
6977 if (
auto *OID = dyn_cast<ObjCImplDecl>(I)) {
6978 for (
auto *M : OID->methods())
6997 case Decl::CXXConversion:
6998 case Decl::CXXMethod:
6999 case Decl::Function:
7006 case Decl::CXXDeductionGuide:
7011 case Decl::Decomposition:
7012 case Decl::VarTemplateSpecialization:
7014 if (
auto *DD = dyn_cast<DecompositionDecl>(
D))
7015 for (
auto *B : DD->bindings())
7016 if (
auto *HD = B->getHoldingVar())
7022 case Decl::IndirectField:
7026 case Decl::Namespace:
7027 EmitDeclContext(cast<NamespaceDecl>(
D));
7029 case Decl::ClassTemplateSpecialization: {
7030 const auto *Spec = cast<ClassTemplateSpecializationDecl>(
D);
7032 if (Spec->getSpecializationKind() ==
7034 Spec->hasDefinition())
7035 DI->completeTemplateDefinition(*Spec);
7037 case Decl::CXXRecord: {
7044 DI->completeUnusedClass(*CRD);
7047 for (
auto *I : CRD->
decls())
7048 if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
7053 case Decl::UsingShadow:
7054 case Decl::ClassTemplate:
7055 case Decl::VarTemplate:
7057 case Decl::VarTemplatePartialSpecialization:
7058 case Decl::FunctionTemplate:
7059 case Decl::TypeAliasTemplate:
7066 DI->EmitUsingDecl(cast<UsingDecl>(*
D));
7068 case Decl::UsingEnum:
7070 DI->EmitUsingEnumDecl(cast<UsingEnumDecl>(*
D));
7072 case Decl::NamespaceAlias:
7074 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*
D));
7076 case Decl::UsingDirective:
7078 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*
D));
7080 case Decl::CXXConstructor:
7083 case Decl::CXXDestructor:
7087 case Decl::StaticAssert:
7094 case Decl::ObjCInterface:
7095 case Decl::ObjCCategory:
7098 case Decl::ObjCProtocol: {
7099 auto *Proto = cast<ObjCProtocolDecl>(
D);
7100 if (Proto->isThisDeclarationADefinition())
7105 case Decl::ObjCCategoryImpl:
7108 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(
D));
7111 case Decl::ObjCImplementation: {
7112 auto *OMD = cast<ObjCImplementationDecl>(
D);
7113 EmitObjCPropertyImplementations(OMD);
7114 EmitObjCIvarInitializations(OMD);
7119 DI->getOrCreateInterfaceType(
getContext().getObjCInterfaceType(
7120 OMD->getClassInterface()), OMD->getLocation());
7123 case Decl::ObjCMethod: {
7124 auto *OMD = cast<ObjCMethodDecl>(
D);
7130 case Decl::ObjCCompatibleAlias:
7131 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(
D));
7134 case Decl::PragmaComment: {
7135 const auto *PCD = cast<PragmaCommentDecl>(
D);
7136 switch (PCD->getCommentKind()) {
7138 llvm_unreachable(
"unexpected pragma comment kind");
7153 case Decl::PragmaDetectMismatch: {
7154 const auto *PDMD = cast<PragmaDetectMismatchDecl>(
D);
7159 case Decl::LinkageSpec:
7160 EmitLinkageSpec(cast<LinkageSpecDecl>(
D));
7163 case Decl::FileScopeAsm: {
7165 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
7168 if (LangOpts.OpenMPIsTargetDevice)
7171 if (LangOpts.SYCLIsDevice)
7173 auto *AD = cast<FileScopeAsmDecl>(
D);
7174 getModule().appendModuleInlineAsm(AD->getAsmString()->getString());
7178 case Decl::TopLevelStmt:
7179 EmitTopLevelStmt(cast<TopLevelStmtDecl>(
D));
7182 case Decl::Import: {
7183 auto *Import = cast<ImportDecl>(
D);
7186 if (!ImportedModules.insert(Import->getImportedModule()))
7190 if (!Import->getImportedOwningModule()) {
7192 DI->EmitImportDecl(*Import);
7198 if (CXX20ModuleInits && Import->getImportedModule() &&
7199 Import->getImportedModule()->isNamedModule())
7208 Visited.insert(Import->getImportedModule());
7209 Stack.push_back(Import->getImportedModule());
7211 while (!Stack.empty()) {
7213 if (!EmittedModuleInitializers.insert(Mod).second)
7223 if (Submodule->IsExplicit)
7226 if (
Visited.insert(Submodule).second)
7227 Stack.push_back(Submodule);
7234 EmitDeclContext(cast<ExportDecl>(
D));
7237 case Decl::OMPThreadPrivate:
7241 case Decl::OMPAllocate:
7245 case Decl::OMPDeclareReduction:
7249 case Decl::OMPDeclareMapper:
7253 case Decl::OMPRequires:
7258 case Decl::TypeAlias:
7260 DI->EmitAndRetainType(
7261 getContext().getTypedefType(cast<TypedefNameDecl>(
D)));
7273 DI->EmitAndRetainType(
getContext().getEnumType(cast<EnumDecl>(
D)));
7276 case Decl::HLSLBuffer:
7284 assert(isa<TypeDecl>(
D) &&
"Unsupported decl kind");
7291 if (!CodeGenOpts.CoverageMapping)
7294 case Decl::CXXConversion:
7295 case Decl::CXXMethod:
7296 case Decl::Function:
7297 case Decl::ObjCMethod:
7298 case Decl::CXXConstructor:
7299 case Decl::CXXDestructor: {
7300 if (!cast<FunctionDecl>(
D)->doesThisDeclarationHaveABody())
7308 DeferredEmptyCoverageMappingDecls.try_emplace(
D,
true);
7318 if (!CodeGenOpts.CoverageMapping)
7320 if (
const auto *Fn = dyn_cast<FunctionDecl>(
D)) {
7321 if (Fn->isTemplateInstantiation())
7324 DeferredEmptyCoverageMappingDecls.insert_or_assign(
D,
false);
7332 for (
const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
7335 const Decl *
D = Entry.first;
7337 case Decl::CXXConversion:
7338 case Decl::CXXMethod:
7339 case Decl::Function:
7340 case Decl::ObjCMethod: {
7347 case Decl::CXXConstructor: {
7354 case Decl::CXXDestructor: {
7371 if (llvm::Function *F =
getModule().getFunction(
"main")) {
7372 if (!F->isDeclaration() && F->arg_size() == 0 && !F->isVarArg() &&
7374 auto *GA = llvm::GlobalAlias::create(
"__main_void", F);
7375 GA->setVisibility(llvm::GlobalValue::HiddenVisibility);
7384 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
7385 return llvm::ConstantInt::get(i64, PtrInt);
7389 llvm::NamedMDNode *&GlobalMetadata,
7391 llvm::GlobalValue *Addr) {
7392 if (!GlobalMetadata)
7394 CGM.
getModule().getOrInsertNamedMetadata(
"clang.global.decl.ptrs");
7397 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
7400 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.
getLLVMContext(), Ops));
7403bool CodeGenModule::CheckAndReplaceExternCIFuncs(llvm::GlobalValue *Elem,
7404 llvm::GlobalValue *CppFunc) {
7412 if (Elem == CppFunc)
7418 for (llvm::User *User : Elem->users()) {
7422 if (
auto *ConstExpr = dyn_cast<llvm::ConstantExpr>(User)) {
7423 if (ConstExpr->getOpcode() != llvm::Instruction::BitCast)
7426 for (llvm::User *CEUser : ConstExpr->users()) {
7427 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(CEUser)) {
7428 IFuncs.push_back(IFunc);
7433 CEs.push_back(ConstExpr);
7434 }
else if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(User)) {
7435 IFuncs.push_back(IFunc);
7447 for (llvm::GlobalIFunc *IFunc : IFuncs)
7448 IFunc->setResolver(
nullptr);
7449 for (llvm::ConstantExpr *ConstExpr : CEs)
7450 ConstExpr->destroyConstant();
7454 Elem->eraseFromParent();
7456 for (llvm::GlobalIFunc *IFunc : IFuncs) {
7461 llvm::FunctionType::get(IFunc->getType(),
false);
7462 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
7463 CppFunc->getName(), ResolverTy, {},
false);
7464 IFunc->setResolver(Resolver);
7474void CodeGenModule::EmitStaticExternCAliases() {
7477 for (
auto &I : StaticExternCValues) {
7479 llvm::GlobalValue *Val = I.second;
7487 llvm::GlobalValue *ExistingElem =
7488 getModule().getNamedValue(Name->getName());
7492 if (!ExistingElem || CheckAndReplaceExternCIFuncs(ExistingElem, Val))
7499 auto Res = Manglings.find(MangledName);
7500 if (Res == Manglings.end())
7502 Result = Res->getValue();
7513void CodeGenModule::EmitDeclMetadata() {
7514 llvm::NamedMDNode *GlobalMetadata =
nullptr;
7516 for (
auto &I : MangledDeclNames) {
7517 llvm::GlobalValue *Addr =
getModule().getNamedValue(I.second);
7527void CodeGenFunction::EmitDeclMetadata() {
7528 if (LocalDeclMap.empty())
return;
7533 unsigned DeclPtrKind = Context.getMDKindID(
"clang.decl.ptr");
7535 llvm::NamedMDNode *GlobalMetadata =
nullptr;
7537 for (
auto &I : LocalDeclMap) {
7538 const Decl *
D = I.first;
7539 llvm::Value *Addr = I.second.emitRawPointer(*
this);
7540 if (
auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
7542 Alloca->setMetadata(
7543 DeclPtrKind, llvm::MDNode::get(
7544 Context, llvm::ValueAsMetadata::getConstant(DAddr)));
7545 }
else if (
auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
7552void CodeGenModule::EmitVersionIdentMetadata() {
7553 llvm::NamedMDNode *IdentMetadata =
7554 TheModule.getOrInsertNamedMetadata(
"llvm.ident");
7556 llvm::LLVMContext &Ctx = TheModule.getContext();
7558 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
7559 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
7562void CodeGenModule::EmitCommandLineMetadata() {
7563 llvm::NamedMDNode *CommandLineMetadata =
7564 TheModule.getOrInsertNamedMetadata(
"llvm.commandline");
7566 llvm::LLVMContext &Ctx = TheModule.getContext();
7568 llvm::Metadata *CommandLineNode[] = {llvm::MDString::get(Ctx, CommandLine)};
7569 CommandLineMetadata->addOperand(llvm::MDNode::get(Ctx, CommandLineNode));
7572void CodeGenModule::EmitCoverageFile() {
7573 llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata(
"llvm.dbg.cu");
7577 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata(
"llvm.gcov");
7578 llvm::LLVMContext &Ctx = TheModule.getContext();
7579 auto *CoverageDataFile =
7581 auto *CoverageNotesFile =
7583 for (
int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
7584 llvm::MDNode *CU = CUNode->getOperand(i);
7585 llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
7586 GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
7607 if (LangOpts.OpenMP && LangOpts.OpenMPSimd)
7609 for (
auto RefExpr :
D->varlist()) {
7610 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
7612 VD->getAnyInitializer() &&
7613 !VD->getAnyInitializer()->isConstantInitializer(
getContext(),
7620 VD, Addr, RefExpr->getBeginLoc(), PerformInit))
7621 CXXGlobalInits.push_back(InitFunction);
7626CodeGenModule::CreateMetadataIdentifierImpl(
QualType T, MetadataTypeMap &Map,
7630 FnType->getReturnType(), FnType->getParamTypes(),
7631 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
7633 llvm::Metadata *&InternalId = Map[
T.getCanonicalType()];
7638 std::string OutName;
7639 llvm::raw_string_ostream Out(OutName);
7644 Out <<
".normalized";
7658 return CreateMetadataIdentifierImpl(
T, MetadataIdMap,
"");
7663 return CreateMetadataIdentifierImpl(
T, VirtualMetadataIdMap,
".virtual");
7683 for (
auto &Param : FnType->param_types())
7688 GeneralizedParams, FnType->getExtProtoInfo());
7695 llvm_unreachable(
"Encountered unknown FunctionType");
7700 GeneralizedMetadataIdMap,
".generalized");
7707 return ((LangOpts.
Sanitize.
has(SanitizerKind::CFIVCall) &&
7709 (LangOpts.
Sanitize.
has(SanitizerKind::CFINVCall) &&
7711 (LangOpts.
Sanitize.
has(SanitizerKind::CFIDerivedCast) &&
7713 (LangOpts.
Sanitize.
has(SanitizerKind::CFIUnrelatedCast) &&
7720 llvm::Metadata *MD =
7722 VTable->addTypeMetadata(Offset.getQuantity(), MD);
7724 if (CodeGenOpts.SanitizeCfiCrossDso)
7726 VTable->addTypeMetadata(Offset.getQuantity(),
7727 llvm::ConstantAsMetadata::get(CrossDsoTypeId));
7730 llvm::Metadata *MD = llvm::MDString::get(
getLLVMContext(),
"all-vtables");
7731 VTable->addTypeMetadata(Offset.getQuantity(), MD);
7737 SanStats = std::make_unique<llvm::SanitizerStatReport>(&
getModule());
7747 auto *FTy = llvm::FunctionType::get(SamplerT, {
C->getType()},
false);
7762 bool forPointeeType) {
7773 if (
auto Align = TT->getDecl()->getMaxAlignment()) {
7803 if (
T.getQualifiers().hasUnaligned()) {
7805 }
else if (forPointeeType && !AlignForArray &&
7817 if (
unsigned MaxAlign =
getLangOpts().MaxTypeAlign) {
7830 if (NumAutoVarInit >= StopAfter) {
7833 if (!NumAutoVarInit) {
7836 "-ftrivial-auto-var-init-stop-after=%0 has been enabled to limit the "
7837 "number of times ftrivial-auto-var-init=%1 gets applied.");
7851 const Decl *
D)
const {
7855 OS << (isa<VarDecl>(
D) ?
".static." :
".intern.");
7857 OS << (isa<VarDecl>(
D) ?
"__static__" :
"__intern__");
7863 assert(PLoc.
isValid() &&
"Source location is expected to be valid.");
7867 llvm::MD5::MD5Result
Result;
7868 for (
const auto &Arg : PreprocessorOpts.
Macros)
7869 Hash.update(Arg.first);
7873 llvm::sys::fs::UniqueID ID;
7874 if (llvm::sys::fs::getUniqueID(PLoc.
getFilename(), ID)) {
7876 assert(PLoc.
isValid() &&
"Source location is expected to be valid.");
7877 if (
auto EC = llvm::sys::fs::getUniqueID(PLoc.
getFilename(), ID))
7878 SM.getDiagnostics().Report(diag::err_cannot_open_file)
7881 OS << llvm::format(
"%x", ID.getFile()) << llvm::format(
"%x", ID.getDevice())
7882 <<
"_" << llvm::utohexstr(
Result.low(),
true, 8);
7889 assert(DeferredDeclsToEmit.empty() &&
7890 "Should have emitted all decls deferred to emit.");
7891 assert(NewBuilder->DeferredDecls.empty() &&
7892 "Newly created module should not have deferred decls");
7893 NewBuilder->DeferredDecls = std::move(DeferredDecls);
7894 assert(EmittedDeferredDecls.empty() &&
7895 "Still have (unmerged) EmittedDeferredDecls deferred decls");
7897 assert(NewBuilder->DeferredVTables.empty() &&
7898 "Newly created module should not have deferred vtables");
7899 NewBuilder->DeferredVTables = std::move(DeferredVTables);
7901 assert(NewBuilder->MangledDeclNames.empty() &&
7902 "Newly created module should not have mangled decl names");
7903 assert(NewBuilder->Manglings.empty() &&
7904 "Newly created module should not have manglings");
7905 NewBuilder->Manglings = std::move(Manglings);
7907 NewBuilder->WeakRefReferences = std::move(WeakRefReferences);
7909 NewBuilder->ABI->MangleCtx = std::move(ABI->MangleCtx);
Defines the clang::ASTContext interface.
ASTImporterLookupTable & LT
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines the Diagnostic-related interfaces.
Defines enum values for all the target-independent builtin functions.
static void AppendCPUSpecificCPUDispatchMangling(const CodeGenModule &CGM, const CPUSpecificAttr *Attr, unsigned CPUIndex, raw_ostream &Out)
static bool AllTrivialInitializers(CodeGenModule &CGM, ObjCImplementationDecl *D)
static const FunctionDecl * GetRuntimeFunctionDecl(ASTContext &C, StringRef Name)
static void checkAliasForTocData(llvm::GlobalVariable *GVar, const CodeGenOptions &CodeGenOpts, DiagnosticsEngine &Diags, SourceLocation Location)
static bool hasImplicitAttr(const ValueDecl *D)
static void emitUsed(CodeGenModule &CGM, StringRef Name, std::vector< llvm::WeakTrackingVH > &List)
static bool HasNonDllImportDtor(QualType T)
static llvm::Constant * GetPointerConstant(llvm::LLVMContext &Context, const void *Ptr)
Turns the given pointer into a constant.
static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S)
static llvm::GlobalValue::LinkageTypes getMultiversionLinkage(CodeGenModule &CGM, GlobalDecl GD)
static void setVisibilityFromDLLStorageClass(const clang::LangOptions &LO, llvm::Module &M)
static std::string getCPUSpecificMangling(const CodeGenModule &CGM, StringRef Name)
static void setWindowsItaniumDLLImport(CodeGenModule &CGM, bool Local, llvm::Function *F, StringRef Name)
static const char AnnotationSection[]
static bool isUniqueInternalLinkageDecl(GlobalDecl GD, CodeGenModule &CGM)
static QualType GeneralizeFunctionType(ASTContext &Ctx, QualType Ty)
static bool allowKCFIIdentifier(StringRef Name)
static bool shouldAssumeDSOLocal(const CodeGenModule &CGM, llvm::GlobalValue *GV)
static void replaceUsesOfNonProtoConstant(llvm::Constant *old, llvm::Function *newFn)
Replace the uses of a function that was declared with a non-proto type.
static llvm::Constant * castStringLiteralToDefaultAddressSpace(CodeGenModule &CGM, llvm::GlobalVariable *GV)
static bool needsDestructMethod(ObjCImplementationDecl *impl)
static bool isStackProtectorOn(const LangOptions &LangOpts, const llvm::Triple &Triple, clang::LangOptions::StackProtectorMode Mode)
static void removeImageAccessQualifier(std::string &TyName)
static llvm::StringMapEntry< llvm::GlobalVariable * > & GetConstantCFStringEntry(llvm::StringMap< llvm::GlobalVariable * > &Map, const StringLiteral *Literal, bool TargetIsLSB, bool &IsUTF16, unsigned &StringLength)
static uint64_t getFMVPriority(const TargetInfo &TI, const CodeGenFunction::FMVResolverOption &RO)
static void setLLVMVisibility(llvm::GlobalValue &GV, std::optional< llvm::GlobalValue::VisibilityTypes > V)
static llvm::GlobalVariable * GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT, CodeGenModule &CGM, StringRef GlobalName, CharUnits Alignment)
static bool hasUnwindExceptions(const LangOptions &LangOpts)
Determines whether the language options require us to model unwind exceptions.
static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod, SmallVectorImpl< llvm::MDNode * > &Metadata, llvm::SmallPtrSet< Module *, 16 > &Visited)
Add link options implied by the given module, including modules it depends on, using a postorder walk...
static llvm::cl::opt< bool > LimitedCoverage("limited-coverage-experimental", llvm::cl::Hidden, llvm::cl::desc("Emit limited coverage mapping information (experimental)"))
static CGCXXABI * createCXXABI(CodeGenModule &CGM)
static std::unique_ptr< TargetCodeGenInfo > createTargetCodeGenInfo(CodeGenModule &CGM)
static const llvm::GlobalValue * getAliasedGlobal(const llvm::GlobalValue *GV)
static bool shouldBeInCOMDAT(CodeGenModule &CGM, const Decl &D)
static std::string getMangledNameImpl(CodeGenModule &CGM, GlobalDecl GD, const NamedDecl *ND, bool OmitMultiVersionMangling=false)
static void setLinkageForGV(llvm::GlobalValue *GV, const NamedDecl *ND)
static unsigned ArgInfoAddressSpace(LangAS AS)
static void replaceDeclarationWith(llvm::GlobalValue *Old, llvm::Constant *New)
static QualType GeneralizeType(ASTContext &Ctx, QualType Ty)
static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, llvm::Function *NewFn)
ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we implement a function with...
static bool isVarDeclStrongDefinition(const ASTContext &Context, CodeGenModule &CGM, const VarDecl *D, bool NoCommon)
static std::optional< llvm::GlobalValue::VisibilityTypes > getLLVMVisibility(clang::LangOptions::VisibilityFromDLLStorageClassKinds K)
static bool requiresMemberFunctionPointerTypeMetadata(CodeGenModule &CGM, const CXXMethodDecl *MD)
static bool checkAliasedGlobal(const ASTContext &Context, DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector< GlobalDecl, StringRef > &MangledDeclNames, SourceRange AliasRange)
static void EmitGlobalDeclMetadata(CodeGenModule &CGM, llvm::NamedMDNode *&GlobalMetadata, GlobalDecl D, llvm::GlobalValue *Addr)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
llvm::DenseSet< const void * > Visited
llvm::MachO::Target Target
llvm::MachO::Record Record
Defines the clang::Module class, which describes a module in the source code.
static const RecordType * getRecordType(QualType QT)
Checks that the passed in QualType either is of RecordType or points to RecordType.
static const NamedDecl * getDefinition(const Decl *D)
Defines the SourceManager interface.
static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type)
Defines version macros and version-related utility functions for Clang.
__device__ __2f16 float __ockl_bool s
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
SourceManager & getSourceManager()
TranslationUnitDecl * getTranslationUnitDecl() const
const ConstantArrayType * getAsConstantArrayType(QualType T) const
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
@ Strong
Strong definition.
@ WeakUnknown
Weak for now, might become strong later in this TU.
const ProfileList & getProfileList() const
llvm::StringMap< SectionInfo > SectionInfos
QualType getTagDeclType(const TagDecl *Decl) const
Return the unique reference to the type for the specified TagDecl (struct/union/class/enum) decl.
QualType getMemberPointerType(QualType T, const Type *Cls) const
Return the uniqued reference to the type for a member pointer to the specified type in the specified ...
QualType getRecordType(const RecordDecl *Decl) const
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
CanQualType getCanonicalType(QualType T) const
Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...
bool shouldExternalize(const Decl *D) const
Whether a C++ static variable or CUDA/HIP kernel should be externalized.
FullSourceLoc getFullLoc(SourceLocation Loc) const
const XRayFunctionFilter & getXRayFilter() const
ArrayRef< Decl * > getModuleInitializers(Module *M)
Get the initializations to perform when importing a module, if any.
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
RecordDecl * buildImplicitRecord(StringRef Name, RecordDecl::TagKind TK=RecordDecl::TagKind::Struct) const
Create a new implicit TU-level CXXRecordDecl or RecordDecl declaration.
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
StringRef getCUIDHash() const
bool isMSStaticDataMemberInlineDefinition(const VarDecl *VD) const
Returns true if this is an inline-initialized static data member which is treated as a definition for...
Builtin::Context & BuiltinInfo
QualType getConstantArrayType(QualType EltTy, const llvm::APInt &ArySize, const Expr *SizeExpr, ArraySizeModifier ASM, unsigned IndexTypeQuals) const
Return the unique reference to the type for a constant array of the specified element type.
const LangOptions & getLangOpts() const
SelectorTable & Selectors
void forEachMultiversionedFunctionVersion(const FunctionDecl *FD, llvm::function_ref< void(FunctionDecl *)> Pred) const
Visits all versions of a multiversioned function with the passed predicate.
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
llvm::SetVector< const ValueDecl * > CUDAExternalDeviceDeclODRUsedByHost
Keep track of CUDA/HIP external kernels or device variables ODR-used by host code.
QualType getCFConstantStringType() const
Return the C structure type used to represent constant CFStrings.
const NoSanitizeList & getNoSanitizeList() const
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
CanQualType UnsignedLongTy
bool isAlignmentRequired(const Type *T) const
Determine if the alignment the type has was required using an alignment attribute.
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
int64_t toBits(CharUnits CharSize) const
Convert a size in characters to a size in bits.
const clang::PrintingPolicy & getPrintingPolicy() const
CharUnits getAlignOfGlobalVarInChars(QualType T, const VarDecl *VD) const
Return the alignment in characters that should be given to a global variable with type T.
GVALinkage GetGVALinkageForVariable(const VarDecl *VD) const
QualType getObjCIdType() const
Represents the Objective-CC id type.
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
unsigned getTypeAlignIfKnown(QualType T, bool NeedsPreferredAlignment=false) const
Return the alignment of a type, in bits, or 0 if the type is incomplete and we cannot determine the a...
QualType getFunctionType(QualType ResultTy, ArrayRef< QualType > Args, const FunctionProtoType::ExtProtoInfo &EPI) const
Return a normal function type with a typed argument list.
const TargetInfo & getTargetInfo() const
CharUnits toCharUnitsFromBits(int64_t BitSize) const
Convert a size in bits to a size in characters.
void getFunctionFeatureMap(llvm::StringMap< bool > &FeatureMap, const FunctionDecl *) const
TargetCXXABI::Kind getCXXABIKind() const
Return the C++ ABI kind that should be used.
ExternalASTSource * getExternalSource() const
Retrieve a pointer to the external AST source associated with this AST context, if any.
unsigned getTargetAddressSpace(LangAS AS) const
QualType getWideCharType() const
Return the type of wide characters.
InlineVariableDefinitionKind getInlineVariableDefinitionKind(const VarDecl *VD) const
Determine whether a definition of this inline variable should be treated as a weak or strong definiti...
Module * getCurrentNamedModule() const
Get module under construction, nullptr if this is not a C++20 module.
uint64_t getCharWidth() const
Return the size of the character type, in bits.
Attr - This represents one attribute.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
Holds information about both target-independent and target-specific builtins, allowing easy queries b...
bool isLibFunction(unsigned ID) const
Return true if this is a builtin for a libc/libm function, with a "__builtin_" prefix (e....
llvm::StringRef getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
Represents a base class of a C++ class.
Represents binding an expression to a temporary.
Represents a call to a C++ constructor.
Represents a C++ base or member initializer.
Expr * getInit() const
Get the initializer.
Represents a delete expression for memory deallocation and destructor calls, e.g.
Represents a C++ destructor within a class.
Represents a call to a member function that may be written either with member call syntax (e....
Represents a static or instance method of a struct/union/class.
bool isImplicitObjectMemberFunction() const
[C++2b][dcl.fct]/p7 An implicit object member function is a non-static member function without an exp...
const CXXRecordDecl * getParent() const
Return the parent of this method declaration, which is the class in which this method is defined.
Represents a new-expression for memory allocation and constructor calls, e.g: "new CXXNewExpr(foo)".
Represents a C++ struct/union/class.
bool hasMutableFields() const
Determine whether this class, or any of its class subobjects, contains a mutable field.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
bool hasDefinition() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
CanProxy< U > castAs() const
CharUnits - This is an opaque type for sizes expressed in character units.
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
static CharUnits One()
One - Construct a CharUnits quantity of one.
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
CodeGenOptions - Track various options which control how the code is optimized and passed to the back...
std::string RecordCommandLine
The string containing the commandline for the llvm.commandline metadata, if non-empty.
std::string FloatABI
The ABI to use for passing floating point arguments.
llvm::Reloc::Model RelocationModel
The name of the relocation model to use.
std::string CoverageNotesFile
The filename with path we use for coverage notes files.
std::string ProfileInstrumentUsePath
Name of the profile file to use as input for -fprofile-instr-use.
std::string MemoryProfileOutput
Name of the profile file to use as output for with -fmemory-profile.
std::vector< std::string > TocDataVarsUserSpecified
List of global variables explicitly specified by the user as toc-data.
std::string CoverageDataFile
The filename with path we use for coverage data files.
PointerAuthOptions PointerAuth
Configuration for pointer-signing.
llvm::DenormalMode FP32DenormalMode
The floating-point denormal mode to use, for float.
SanitizerSet SanitizeTrap
Set of sanitizer checks that trap rather than diagnose.
std::string ProfileRemappingFile
Name of the profile remapping file to apply to the profile data supplied by -fprofile-sample-use or -...
bool hasProfileClangUse() const
Check if Clang profile use is on.
std::string SymbolPartition
The name of the partition that symbols are assigned to, specified with -fsymbol-partition (see https:...
ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions.
virtual void appendAttributeMangling(TargetAttr *Attr, raw_ostream &Out) const
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
virtual void handleVarRegistration(const VarDecl *VD, llvm::GlobalVariable &Var)=0
Check whether a variable is a device variable and register it if true.
virtual llvm::GlobalValue * getKernelHandle(llvm::Function *Stub, GlobalDecl GD)=0
Get kernel handle by stub function.
virtual void internalizeDeviceSideVar(const VarDecl *D, llvm::GlobalValue::LinkageTypes &Linkage)=0
Adjust linkage of shadow variables in host compilation.
Implements C++ ABI-specific code generation functions.
virtual void EmitCXXConstructors(const CXXConstructorDecl *D)=0
Emit constructor variants required by this ABI.
virtual llvm::Constant * getAddrOfRTTIDescriptor(QualType Ty)=0
virtual void EmitCXXDestructors(const CXXDestructorDecl *D)=0
Emit destructor variants required by this ABI.
virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
virtual llvm::GlobalValue::LinkageTypes getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
MangleContext & getMangleContext()
Gets the mangle context.
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
void AddStringLiteralDebugInfo(llvm::GlobalVariable *GV, const StringLiteral *S)
DebugInfo isn't attached to string literals by default.
CGFunctionInfo - Class to encapsulate the information about a function definition.
void handleGlobalVarDefinition(const VarDecl *VD, llvm::GlobalVariable *Var)
void addBuffer(const HLSLBufferDecl *D)
llvm::Type * getSamplerType(const Type *T)
void emitDeferredTargetDecls() const
Emit deferred declare target variables marked for deferred emission.
virtual void emitDeclareTargetFunction(const FunctionDecl *FD, llvm::GlobalValue *GV)
Emit code for handling declare target functions in the runtime.
virtual ConstantAddress getAddrOfDeclareTargetVar(const VarDecl *VD)
Returns the address of the variable marked as declare target with link clause OR as declare target wi...
bool hasRequiresUnifiedSharedMemory() const
Return whether the unified_shared_memory has been specified.
virtual void emitDeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn)
Marks function Fn with properly mangled versions of vector functions.
virtual void registerTargetGlobalVariable(const VarDecl *VD, llvm::Constant *Addr)
Checks if the provided global decl GD is a declare target variable and registers it when emitting cod...
Class supports emissionof SIMD-only code.
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void GenerateObjCCtorDtorMethod(ObjCImplementationDecl *IMP, ObjCMethodDecl *MD, bool ctor)
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
void EmitCfiCheckStub()
Emit a stub for the cross-DSO CFI check function.
void EmitCfiCheckFail()
Emit a cross-DSO CFI failure handling function.
bool isTrivialInitializer(const Expr *Init)
Determine whether the given initializer is trivial in the sense that it requires no code to be genera...
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
void GenerateObjCSetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCSetter - Synthesize an Objective-C property setter function for the given property.
void GenerateObjCGetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCGetter - Synthesize an Objective-C property getter function.
llvm::LLVMContext & getLLVMContext()
void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo)
This class organizes the cross-function state that is used while generating LLVM code.
StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD)
ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD)
Get the address of a GUID.
void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const
Set visibility, dllimport/dllexport and dso_local.
void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD)
Create and attach type metadata for the given vtable.
void UpdateCompletedType(const TagDecl *TD)
llvm::MDNode * getTBAAAccessTagInfo(TBAAAccessInfo Info)
getTBAAAccessTagInfo - Get TBAA tag for a given memory access.
llvm::GlobalVariable::ThreadLocalMode GetDefaultLLVMTLSModel() const
Get LLVM TLS mode from CodeGenOptions.
void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
void setDSOLocal(llvm::GlobalValue *GV) const
llvm::MDNode * getTBAAStructInfo(QualType QTy)
CGHLSLRuntime & getHLSLRuntime()
Return a reference to the configured HLSL runtime.
llvm::Constant * EmitAnnotationArgs(const AnnotateAttr *Attr)
Emit additional args of the annotation.
llvm::Module & getModule() const
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)
Create or return a runtime function declaration with the specified type and name.
CGDebugInfo * getModuleDebugInfo()
bool NeedAllVtablesTypeId() const
Returns whether this module needs the "all-vtables" type identifier.
void addCompilerUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.compiler.used metadata.
CodeGenVTables & getVTables()
llvm::ConstantInt * CreateCrossDsoCfiTypeId(llvm::Metadata *MD)
Generate a cross-DSO type identifier for MD.
CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const
Return the store size, in character units, of the given LLVM type.
bool getExpressionLocationsEnabled() const
Return true if we should emit location information for expressions.
void addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C)
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
void setGVPropertiesAux(llvm::GlobalValue *GV, const NamedDecl *D) const
const ABIInfo & getABIInfo()
void EmitMainVoidAlias()
Emit an alias for "main" if it has no arguments (needed for wasm).
void DecorateInstructionWithInvariantGroup(llvm::Instruction *I, const CXXRecordDecl *RD)
Adds !invariant.barrier !tag to instruction.
DiagnosticsEngine & getDiags() const
bool isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn, SourceLocation Loc) const
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
llvm::Constant * getAddrOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the constructor/destructor of the given type.
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
llvm::Constant * EmitAnnotateAttr(llvm::GlobalValue *GV, const AnnotateAttr *AA, SourceLocation L)
Generate the llvm::ConstantStruct which contains the annotation information for a given GlobalValue.
llvm::GlobalValue::LinkageTypes getLLVMLinkageForDeclarator(const DeclaratorDecl *D, GVALinkage Linkage)
Returns LLVM linkage for a declarator.
TBAAAccessInfo mergeTBAAInfoForMemoryTransfer(TBAAAccessInfo DestInfo, TBAAAccessInfo SrcInfo)
mergeTBAAInfoForMemoryTransfer - Get merged TBAA information for the purposes of memory transfer call...
const LangOptions & getLangOpts() const
CGCUDARuntime & getCUDARuntime()
Return a reference to the configured CUDA runtime.
llvm::Constant * EmitAnnotationLineNo(SourceLocation L)
Emit the annotation line number.
QualType getObjCFastEnumerationStateType()
Retrieve the record type that describes the state of an Objective-C fast enumeration loop (for....
CharUnits getNaturalTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr, bool forPointeeType=false)
CodeGenTypes & getTypes()
bool shouldMapVisibilityToDLLExport(const NamedDecl *D) const
CGOpenCLRuntime & getOpenCLRuntime()
Return a reference to the configured OpenCL runtime.
const std::string & getModuleNameHash() const
const TargetInfo & getTarget() const
bool shouldEmitRTTI(bool ForEH=false)
void EmitGlobal(GlobalDecl D)
Emit code for a single global function or var decl.
llvm::Metadata * CreateMetadataIdentifierForType(QualType T)
Create a metadata identifier for the given type.
void addUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.used metadata.
void AppendLinkerOptions(StringRef Opts)
Appends Opts to the "llvm.linker.options" metadata value.
void EmitExternalDeclaration(const DeclaratorDecl *D)
void AddDependentLib(StringRef Lib)
Appends a dependent lib to the appropriate metadata value.
void Release()
Finalize LLVM code generation.
ProfileList::ExclusionType isFunctionBlockedByProfileList(llvm::Function *Fn, SourceLocation Loc) const
llvm::MDNode * getTBAABaseTypeInfo(QualType QTy)
getTBAABaseTypeInfo - Get metadata that describes the given base access type.
bool lookupRepresentativeDecl(StringRef MangledName, GlobalDecl &Result) const
void EmitOMPAllocateDecl(const OMPAllocateDecl *D)
Emit a code for the allocate directive.
void setGlobalVisibility(llvm::GlobalValue *GV, const NamedDecl *D) const
Set the visibility for the given LLVM GlobalValue.
llvm::GlobalValue::LinkageTypes getLLVMLinkageVarDefinition(const VarDecl *VD)
Returns LLVM linkage for a declarator.
bool HasHiddenLTOVisibility(const CXXRecordDecl *RD)
Returns whether the given record has hidden LTO visibility and therefore may participate in (single-m...
const llvm::DataLayout & getDataLayout() const
void Error(SourceLocation loc, StringRef error)
Emit a general error that something can't be done.
TBAAAccessInfo getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType)
getTBAAVTablePtrAccessInfo - Get the TBAA information that describes an access to a virtual table poi...
CGCXXABI & getCXXABI() const
ConstantAddress GetWeakRefReference(const ValueDecl *VD)
Get a reference to the target of VD.
llvm::Constant * GetFunctionStart(const ValueDecl *Decl)
static llvm::GlobalValue::VisibilityTypes GetLLVMVisibility(Visibility V)
void EmitTentativeDefinition(const VarDecl *D)
void EmitDeferredUnusedCoverageMappings()
Emit all the deferred coverage mappings for the uninstrumented functions.
void addUsedOrCompilerUsedGlobal(llvm::GlobalValue *GV)
Add a global to a list to be added to the llvm.compiler.used metadata.
CGOpenMPRuntime & getOpenMPRuntime()
Return a reference to the configured OpenMP runtime.
bool imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc, StringRef Category=StringRef()) const
Imbue XRay attributes to a function, applying the always/never attribute lists in the process.
llvm::Metadata * CreateMetadataIdentifierGeneralized(QualType T)
Create a metadata identifier for the generalization of the given type.
void EmitGlobalAnnotations()
Emit all the global annotations.
CharUnits getClassPointerAlignment(const CXXRecordDecl *CD)
Returns the assumed alignment of an opaque pointer to the given class.
const llvm::Triple & getTriple() const
SmallVector< const CXXRecordDecl *, 0 > getMostBaseClasses(const CXXRecordDecl *RD)
Return a vector of most-base classes for RD.
void AddDeferredUnusedCoverageMapping(Decl *D)
Stored a deferred empty coverage mapping for an unused and thus uninstrumented top level declaration.
void MaybeHandleStaticInExternC(const SomeDecl *D, llvm::GlobalValue *GV)
If the declaration has internal linkage but is inside an extern "C" linkage specification,...
void DecorateInstructionWithTBAA(llvm::Instruction *Inst, TBAAAccessInfo TBAAInfo)
DecorateInstructionWithTBAA - Decorate the instruction with a TBAA tag.
llvm::GlobalVariable::LinkageTypes getFunctionLinkage(GlobalDecl GD)
void AddGlobalDtor(llvm::Function *Dtor, int Priority=65535, bool IsDtorAttrFunc=false)
AddGlobalDtor - Add a function to the list that will be called when the module is unloaded.
llvm::Constant * CreateRuntimeVariable(llvm::Type *Ty, StringRef Name)
Create a new runtime global variable with the specified type and name.
void ConstructAttributeList(StringRef Name, const CGFunctionInfo &Info, CGCalleeInfo CalleeInfo, llvm::AttributeList &Attrs, unsigned &CallingConv, bool AttrOnCallSite, bool IsThunk)
Get the LLVM attributes and calling convention to use for a particular function type.
llvm::Constant * GetOrCreateLLVMGlobal(StringRef MangledName, llvm::Type *Ty, LangAS AddrSpace, const VarDecl *D, ForDefinition_t IsForDefinition=NotForDefinition)
GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, create and return an llvm...
TBAAAccessInfo getTBAAAccessInfo(QualType AccessType)
getTBAAAccessInfo - Get TBAA information that describes an access to an object of the given type.
void setFunctionLinkage(GlobalDecl GD, llvm::Function *F)
llvm::Constant * GetAddrOfGlobal(GlobalDecl GD, ForDefinition_t IsForDefinition=NotForDefinition)
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
ProfileList::ExclusionType isFunctionBlockedFromProfileInstr(llvm::Function *Fn, SourceLocation Loc) const
void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV)
Add global annotations that are set on D, for the global GV.
void setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const
Set the TLS mode for the given LLVM GlobalValue for the thread-local variable declaration D.
ConstantAddress GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name=".str")
Return a pointer to a constant array for the given string literal.
ASTContext & getContext() const
ConstantAddress GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO)
Get the address of a template parameter object.
void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D)
Emit a code for threadprivate directive.
ConstantAddress GetAddrOfUnnamedGlobalConstantDecl(const UnnamedGlobalConstantDecl *GCD)
Get the address of a UnnamedGlobalConstant.
TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, TBAAAccessInfo TargetInfo)
mergeTBAAInfoForCast - Get merged TBAA information for the purposes of type casts.
llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, ForDefinition_t IsForDefinition=NotForDefinition)
Return the llvm::Constant for the address of the given global variable.
llvm::SanitizerStatReport & getSanStats()
llvm::Constant * EmitAnnotationString(StringRef Str)
Emit an annotation string.
void EmitOMPDeclareMapper(const OMPDeclareMapperDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare mapper construct.
bool supportsCOMDAT() const
void RefreshTypeCacheForClass(const CXXRecordDecl *Class)
llvm::MDNode * getTBAATypeInfo(QualType QTy)
getTBAATypeInfo - Get metadata used to describe accesses to objects of the given type.
void EmitOMPRequiresDecl(const OMPRequiresDecl *D)
Emit a code for requires directive.
void HandleCXXStaticMemberVarInstantiation(VarDecl *VD)
Tell the consumer that this variable has been instantiated.
const TargetCodeGenInfo & getTargetCodeGenInfo()
const CodeGenOptions & getCodeGenOpts() const
StringRef getMangledName(GlobalDecl GD)
llvm::Constant * GetConstantArrayFromStringLiteral(const StringLiteral *E)
Return a constant array for the given string.
void SetCommonAttributes(GlobalDecl GD, llvm::GlobalValue *GV)
Set attributes which are common to any form of a global definition (alias, Objective-C method,...
std::optional< CharUnits > getOMPAllocateAlignment(const VarDecl *VD)
Return the alignment specified in an allocate directive, if present.
llvm::GlobalVariable * CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage, llvm::Align Alignment)
Will return a global variable of the given type.
CharUnits getNaturalPointeeTypeAlignment(QualType T, LValueBaseInfo *BaseInfo=nullptr, TBAAAccessInfo *TBAAInfo=nullptr)
TBAAAccessInfo mergeTBAAInfoForConditionalOperator(TBAAAccessInfo InfoA, TBAAAccessInfo InfoB)
mergeTBAAInfoForConditionalOperator - Get merged TBAA information for the purposes of conditional ope...
llvm::LLVMContext & getLLVMContext()
llvm::GlobalValue * GetGlobalValue(StringRef Ref)
void GenKernelArgMetadata(llvm::Function *FN, const FunctionDecl *FD=nullptr, CodeGenFunction *CGF=nullptr)
OpenCL v1.2 s5.6.4.6 allows the compiler to store kernel argument information in the program executab...
void CreateFunctionTypeMetadataForIcall(const FunctionDecl *FD, llvm::Function *F)
Create and attach type metadata to the given function.
void setKCFIType(const FunctionDecl *FD, llvm::Function *F)
Set type metadata to the given function.
void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO)
void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare reduction construct.
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys={})
void AddDetectMismatch(StringRef Name, StringRef Value)
Appends a detect mismatch command to the linker options.
void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const
llvm::Value * createOpenCLIntToSamplerConversion(const Expr *E, CodeGenFunction &CGF)
ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)
Returns a pointer to a global variable representing a temporary with static or thread storage duratio...
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
LangAS GetGlobalConstantAddressSpace() const
Return the AST address space of constant literal, which is used to emit the constant literal as globa...
LangAS GetGlobalVarAddressSpace(const VarDecl *D)
Return the AST address space of the underlying global variable for D, as determined by its declaratio...
void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)
Set the LLVM function attributes (sext, zext, etc).
void addReplacement(StringRef Name, llvm::Constant *C)
llvm::ConstantInt * CreateKCFITypeId(QualType T)
Generate a KCFI type identifier for T.
llvm::Constant * getConstantSignedPointer(llvm::Constant *Pointer, const PointerAuthSchema &Schema, llvm::Constant *StorageAddress, GlobalDecl SchemaDecl, QualType SchemaType)
Sign a constant pointer using the given scheme, producing a constant with the same IR type.
void AddGlobalCtor(llvm::Function *Ctor, int Priority=65535, unsigned LexOrder=~0U, llvm::Constant *AssociatedData=nullptr)
AddGlobalCtor - Add a function to the list that will be called before main() runs.
void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)
Set the LLVM function attributes which only apply to a function definition.
llvm::Metadata * CreateMetadataIdentifierForVirtualMemPtrType(QualType T)
Create a metadata identifier that is intended to be used to check virtual calls via a member function...
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
const GlobalDecl getMangledNameDecl(StringRef)
void ClearUnusedCoverageMapping(const Decl *D)
Remove the deferred empty coverage mapping as this declaration is actually instrumented.
void EmitTopLevelDecl(Decl *D)
Emit code for a single top level declaration.
llvm::Constant * EmitAnnotationUnit(SourceLocation Loc)
Emit the annotation's translation unit.
ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)
Returns a pointer to a character array containing the literal and a terminating '\0' character.
void printPostfixForExternalizedDecl(llvm::raw_ostream &OS, const Decl *D) const
Print the postfix for externalized static variable or kernels for single source offloading languages ...
void moveLazyEmissionStates(CodeGenModule *NewBuilder)
Move some lazily-emitted states to the NewBuilder.
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
void finalizeKCFITypes()
Emit KCFI type identifier constants and remove unused identifiers.
void setValueProfilingFlag(llvm::Module &M)
void setProfileVersion(llvm::Module &M)
void emitEmptyCounterMapping(const Decl *D, StringRef FuncName, llvm::GlobalValue::LinkageTypes Linkage)
Emit a coverage mapping range with a counter zero for an unused declaration.
CodeGenTBAA - This class organizes the cross-module state that is used while lowering AST types to LL...
This class organizes the cross-module state that is used while lowering AST types to LLVM types.
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
C++ methods have some special rules and also have implicit parameters.
const CGFunctionInfo & arrangeFreeFunctionType(CanQual< FunctionProtoType > Ty)
Arrange the argument and result information for a value of the given freestanding function type.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
unsigned getTargetAddressSpace(QualType T) const
void RefreshTypeCacheForClass(const CXXRecordDecl *RD)
Remove stale types from the type cache when an inheritance model gets assigned to a class.
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
void UpdateCompletedType(const TagDecl *TD)
UpdateCompletedType - When we find the full definition for a TagDecl, replace the 'opaque' type we pr...
const CGFunctionInfo & arrangeGlobalDeclaration(GlobalDecl GD)
void GenerateClassData(const CXXRecordDecl *RD)
GenerateClassData - Generate all the class data required to be generated upon definition of a KeyFunc...
void EmitThunks(GlobalDecl GD)
EmitThunks - Emit the associated thunks for the given global decl.
A specialization of Address that requires the address to be an LLVM Constant.
static ConstantAddress invalid()
llvm::Constant * tryEmitForInitializer(const VarDecl &D)
Try to emit the initiaizer of the given declaration as an abstract constant.
void finalize(llvm::GlobalVariable *global)
llvm::Constant * emitAbstract(const Expr *E, QualType T)
Emit the result of the given expression as an abstract constant, asserting that it succeeded.
The standard implementation of ConstantInitBuilder used in Clang.
Organizes the cross-function state that is used while generating code coverage mapping data.
FunctionArgList - Type for representing both the decl and type of parameters to a function.
bool hasDiagnostics()
Whether or not the stats we've gathered indicate any potential problems.
void reportDiagnostics(DiagnosticsEngine &Diags, StringRef MainFile)
Report potential problems we've found to Diags.
TargetCodeGenInfo - This class organizes various target-specific codegeneration issues,...
virtual void getDependentLibraryOption(llvm::StringRef Lib, llvm::SmallString< 24 > &Opt) const
Gets the linker options necessary to link a dependent library on this platform.
Address performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, Address Addr, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
const T & getABIInfo() const
virtual LangAS getGlobalVarAddressSpace(CodeGenModule &CGM, const VarDecl *D) const
Get target favored AST address space of a global variable for languages other than OpenCL and CUDA.
virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M) const
setTargetAttributes - Provides a convenient hook to handle extra target-specific attributes for the g...
virtual LangAS getASTAllocaAddressSpace() const
Get the AST address space for alloca.
virtual void emitTargetMetadata(CodeGen::CodeGenModule &CGM, const llvm::MapVector< GlobalDecl, StringRef > &MangledDeclNames) const
emitTargetMetadata - Provides a convenient hook to handle extra target-specific metadata for the give...
virtual void emitTargetGlobals(CodeGen::CodeGenModule &CGM) const
Provides a convenient hook to handle extra target-specific globals.
virtual void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value, llvm::SmallString< 32 > &Opt) const
Gets the linker options necessary to detect object file mismatches on this platform.
ConstStmtVisitor - This class implements a simple visitor for Stmt subclasses.
Represents the canonical version of C arrays with a specified constant size.
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
Stores additional source code information like skipped ranges which is required by the coverage mappi...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
A reference to a declared variable, function, enum, etc.
Decl - This represents one declaration (or definition), e.g.
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
SourceLocation getEndLoc() const LLVM_READONLY
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl,...
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
const Attr * getDefiningAttr() const
Return this declaration's defining attribute if it has one.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
SourceLocation getBeginLoc() const LLVM_READONLY
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
virtual Decl * getCanonicalDecl()
Retrieves the "canonical" declaration of the given declaration.
Represents a ValueDecl that came out of a declarator.
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
This represents one expression.
Represents a member of a struct/union/class.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
StringRef getName() const
The name of this FileEntry.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Represents a function declaration or definition.
bool isTargetClonesMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-clones functional...
bool isMultiVersion() const
True if this function is considered a multiversioned function.
const ParmVarDecl * getParamDecl(unsigned i) const
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
bool isImmediateFunction() const
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
bool isInlineBuiltinDeclaration() const
Determine if this function provides an inline implementation of a builtin.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
FunctionDecl * getDefinition()
Get the definition for this declaration.
bool isTargetVersionMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-version functiona...
bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
bool doesDeclarationForceExternallyVisibleDefinition() const
For a function declaration in C or C++, determine whether this declaration causes the definition to b...
bool isTargetMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target functionality.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Represents a prototype with parameter type info, e.g.
FunctionType - C99 6.7.5.3 - Function Declarators.
CallingConv getCallConv() const
GlobalDecl - represents a global declaration.
GlobalDecl getWithMultiVersionIndex(unsigned Index)
CXXCtorType getCtorType() const
GlobalDecl getWithKernelReferenceKind(KernelReferenceKind Kind)
GlobalDecl getCanonicalDecl() const
KernelReferenceKind getKernelReferenceKind() const
GlobalDecl getWithDecl(const Decl *D)
unsigned getMultiVersionIndex() const
CXXDtorType getDtorType() const
const Decl * getDecl() const
One of these records is kept for each identifier that is lexed.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
@ None
No signing for any function.
@ Swift5_0
Interoperability with the Swift 5.0 runtime.
@ Swift
Interoperability with the latest known version of the Swift runtime.
@ Swift4_2
Interoperability with the Swift 4.2 runtime.
@ Swift4_1
Interoperability with the Swift 4.1 runtime.
VisibilityFromDLLStorageClassKinds
@ Keep
Keep the IR-gen assigned visibility.
@ Protected
Override the IR-gen assigned visibility with protected visibility.
@ Default
Override the IR-gen assigned visibility with default visibility.
@ Hidden
Override the IR-gen assigned visibility with hidden visibility.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool isSignReturnAddressWithAKey() const
Check if return address signing uses AKey.
clang::ObjCRuntime ObjCRuntime
CoreFoundationABI CFRuntime
SanitizerSet Sanitize
Set of enabled sanitizers.
bool hasSignReturnAddress() const
Check if return address signing is enabled.
std::map< std::string, std::string, std::greater< std::string > > MacroPrefixMap
A prefix map for FILE, BASE_FILE and __builtin_FILE().
LangStandard::Kind LangStd
The used language standard.
bool isSignReturnAddressScopeAll() const
Check if leaf functions are also signed.
std::string CUID
The user provided compilation unit ID, if non-empty.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Visibility getVisibility() const
void setLinkage(Linkage L)
Linkage getLinkage() const
bool isVisibilityExplicit() const
Represents a linkage specification.
LinkageSpecLanguageIDs getLanguage() const
Return the language specified by this linkage specification.
Parts getParts() const
Get the decomposed parts of this declaration.
APValue & getAsAPValue() const
Get the value of this MSGuidDecl as an APValue.
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
void mangleBlock(const DeclContext *DC, const BlockDecl *BD, raw_ostream &Out)
void mangleCtorBlock(const CXXConstructorDecl *CD, CXXCtorType CT, const BlockDecl *BD, raw_ostream &Out)
void mangleGlobalBlock(const BlockDecl *BD, const NamedDecl *ID, raw_ostream &Out)
bool shouldMangleDeclName(const NamedDecl *D)
void mangleName(GlobalDecl GD, raw_ostream &)
virtual void mangleCanonicalTypeName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0
Generates a unique string for an externally visible type for use with TBAA or type uniquing.
virtual void mangleStringLiteral(const StringLiteral *SL, raw_ostream &)=0
ManglerKind getKind() const
virtual void needsUniqueInternalLinkageNames()
virtual void mangleReferenceTemporary(const VarDecl *D, unsigned ManglingNumber, raw_ostream &)=0
void mangleDtorBlock(const CXXDestructorDecl *CD, CXXDtorType DT, const BlockDecl *BD, raw_ostream &Out)
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
Describes a module or submodule.
bool isInterfaceOrPartition() const
bool isNamedModuleUnit() const
Is this a C++20 named module unit.
Module * Parent
The parent of this module.
Module * getPrivateModuleFragment() const
Get the Private Module Fragment (sub-module) for this module, it there is one.
llvm::SmallSetVector< Module *, 2 > Imports
The set of modules imported by this module, and on which this module depends.
Module * getGlobalModuleFragment() const
Get the Global Module Fragment (sub-module) for this module, it there is one.
llvm::iterator_range< submodule_iterator > submodules()
llvm::SmallVector< LinkLibrary, 2 > LinkLibraries
The set of libraries or frameworks to link against when an entity from this module is used.
bool isHeaderLikeModule() const
Is this module have similar semantics as headers.
bool UseExportAsModuleLinkName
Autolinking uses the framework name for linking purposes when this is false and the export_as name ot...
This represents a decl that may have a name.
IdentifierInfo * getIdentifier() const
Get the identifier that names this declaration, if there is one.
LinkageInfo getLinkageAndVisibility() const
Determines the linkage and visibility of this entity.
StringRef getName() const
Get the name of identifier for this declaration as a StringRef.
Linkage getFormalLinkage() const
Get the linkage from a semantic point of view.
Represent a C++ namespace.
This represents '#pragma omp threadprivate ...' directive.
ObjCEncodeExpr, used for @encode in Objective-C.
const ObjCInterfaceDecl * getClassInterface() const
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
Represents an ObjC class declaration.
ObjCIvarDecl * all_declared_ivar_begin()
all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...
ObjCIvarDecl - Represents an ObjC instance variable.
ObjCIvarDecl * getNextIvar()
ObjCMethodDecl - Represents an instance or class method declaration.
static ObjCMethodDecl * Create(ASTContext &C, SourceLocation beginLoc, SourceLocation endLoc, Selector SelInfo, QualType T, TypeSourceInfo *ReturnTInfo, DeclContext *contextDecl, bool isInstance=true, bool isVariadic=false, bool isPropertyAccessor=false, bool isSynthesizedAccessorStub=false, bool isImplicitlyDeclared=false, bool isDefined=false, ObjCImplementationControl impControl=ObjCImplementationControl::None, bool HasRelatedResultType=false)
Represents one property declaration in an Objective-C interface.
ObjCMethodDecl * getGetterMethodDecl() const
bool isReadOnly() const
isReadOnly - Return true iff the property has a setter.
The basic abstraction for the target Objective-C runtime.
bool hasUnwindExceptions() const
Does this runtime use zero-cost exceptions?
bool isGNUFamily() const
Is this runtime basically of the GNU family of runtimes?
@ MacOSX
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
@ GNUstep
'gnustep' is the modern non-fragile GNUstep runtime.
@ ObjFW
'objfw' is the Objective-C runtime included in ObjFW
@ iOS
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
@ GCC
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI
@ WatchOS
'watchos' is a variant of iOS for Apple's watchOS.
Represents a parameter to a function.
ParsedAttr - Represents a syntactic attribute.
bool isAddressDiscriminated() const
uint16_t getConstantDiscrimination() const
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::optional< uint64_t > SourceDateEpoch
If set, the UNIX timestamp specified by SOURCE_DATE_EPOCH.
std::vector< std::pair< std::string, bool > > Macros
Represents an unpacked "presumed" location which can be presented to the user.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
PrettyStackTraceDecl - If a crash occurs, indicate that it happened when doing something to a specifi...
std::optional< ExclusionType > isFunctionExcluded(StringRef FunctionName, CodeGenOptions::ProfileInstrKind Kind) const
std::optional< ExclusionType > isLocationExcluded(SourceLocation Loc, CodeGenOptions::ProfileInstrKind Kind) const
ExclusionType
Represents if an how something should be excluded from profiling.
@ Skip
Profiling is skipped using the skipprofile attribute.
@ Allow
Profiling is allowed.
ExclusionType getDefault(CodeGenOptions::ProfileInstrKind Kind) const
std::optional< ExclusionType > isFileExcluded(StringRef FileName, CodeGenOptions::ProfileInstrKind Kind) const
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
QualType withCVRQualifiers(unsigned CVR) const
bool isConstQualified() const
Determine whether this type is const-qualified.
bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Represents a struct/union/class.
field_range fields() const
A helper class that allows the use of isa/cast/dyncast to detect TagType objects of structs/unions/cl...
A class that does preorder or postorder depth-first traversal on the entire Clang AST and visits each...
decl_type * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
decl_type * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
Selector getSelector(unsigned NumArgs, const IdentifierInfo **IIV)
Can create any sort of selector.
Smart pointer class that efficiently represents Objective-C method names.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
A trivial tuple used to represent a source range.
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
Stmt - This represents one statement.
StringLiteral - This represents a string literal expression, e.g.
Represents the declaration of a struct/union/class/enum.
bool isMicrosoft() const
Is this ABI an MSVC-compatible ABI?
Exposes information about the current target.
TargetOptions & getTargetOpts() const
Retrieve the target options.
const llvm::Triple & getTriple() const
Returns the target triple of the primary target.
bool isReadOnlyFeature(StringRef Feature) const
Determine whether the given target feature is read only.
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
bool supportsIFunc() const
Identify whether this target supports IFuncs.
TargetCXXABI getCXXABI() const
Get the C++ ABI currently in use.
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
virtual uint64_t getFMVPriority(ArrayRef< StringRef > Features) const
virtual bool hasFeature(StringRef Feature) const
Determine whether the given target has the given feature.
std::vector< std::string > Features
The list of target specific features to enable or disable – this should be a list of strings starting...
std::string TuneCPU
If given, the name of the target CPU to tune code for.
std::string CPU
If given, the name of the target CPU to generate code for.
@ Hostcall
printf lowering scheme involving hostcalls, currently used by HIP programs by default
A template parameter object.
const APValue & getValue() const
A declaration that models statements at global scope.
The top declaration context.
static DeclContext * castToDeclContext(const TranslationUnitDecl *D)
const Type * getTypeForDecl() const
The base class of the type hierarchy.
CXXRecordDecl * getAsCXXRecordDecl() const
Retrieves the CXXRecordDecl that this type refers to, either because the type is a RecordType or beca...
bool isPointerType() const
const T * castAs() const
Member-template castAs<specific type>.
bool isCUDADeviceBuiltinSurfaceType() const
Check if the type is the CUDA device builtin surface type.
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
const Type * getBaseElementTypeUnsafe() const
Get the base element type of this type, potentially discarding type qualifiers.
bool isCUDADeviceBuiltinTextureType() const
Check if the type is the CUDA device builtin texture type.
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isObjCObjectPointerType() const
Linkage getLinkage() const
Determine the linkage of this type.
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
An artificial decl, representing a global anonymous constant value which is uniquified by value withi...
const APValue & getValue() const
Represent the declaration of a variable (in which case it is an lvalue) a function (in which case it ...
Represents a variable declaration or definition.
TLSKind getTLSKind() const
DefinitionKind isThisDeclarationADefinition(ASTContext &) const
Check whether this declaration is a definition.
bool hasFlexibleArrayInit(const ASTContext &Ctx) const
Whether this variable has a flexible array member initialized with one or more elements.
CharUnits getFlexibleArrayInitChars(const ASTContext &Ctx) const
If hasFlexibleArrayInit is true, compute the number of additional bytes necessary to store those elem...
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
@ TLS_Dynamic
TLS with a dynamic initializer.
@ DeclarationOnly
This declaration is only a declaration.
@ Definition
This declaration is definitely a definition.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
Defines the clang::TargetInfo interface.
std::unique_ptr< TargetCodeGenInfo > createARMTargetCodeGenInfo(CodeGenModule &CGM, ARMABIKind Kind)
std::unique_ptr< TargetCodeGenInfo > createM68kTargetCodeGenInfo(CodeGenModule &CGM)
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
std::unique_ptr< TargetCodeGenInfo > createBPFTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createMSP430TargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel)
std::unique_ptr< TargetCodeGenInfo > createWebAssemblyTargetCodeGenInfo(CodeGenModule &CGM, WebAssemblyABIKind K)
std::unique_ptr< TargetCodeGenInfo > createPPC64_SVR4_TargetCodeGenInfo(CodeGenModule &CGM, PPC64_SVR4_ABIKind Kind, bool SoftFloatABI)
std::unique_ptr< TargetCodeGenInfo > createMIPSTargetCodeGenInfo(CodeGenModule &CGM, bool IsOS32)
std::unique_ptr< TargetCodeGenInfo > createHexagonTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createNVPTXTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createSystemZTargetCodeGenInfo(CodeGenModule &CGM, bool HasVector, bool SoftFloatABI)
std::unique_ptr< TargetCodeGenInfo > createWinX86_32TargetCodeGenInfo(CodeGenModule &CGM, bool DarwinVectorABI, bool Win32StructABI, unsigned NumRegisterParameters)
std::unique_ptr< TargetCodeGenInfo > createAIXTargetCodeGenInfo(CodeGenModule &CGM, bool Is64Bit)
std::unique_ptr< TargetCodeGenInfo > createAMDGPUTargetCodeGenInfo(CodeGenModule &CGM)
CGObjCRuntime * CreateMacObjCRuntime(CodeGenModule &CGM)
X86AVXABILevel
The AVX ABI level for X86 targets.
std::unique_ptr< TargetCodeGenInfo > createTCETargetCodeGenInfo(CodeGenModule &CGM)
CGObjCRuntime * CreateGNUObjCRuntime(CodeGenModule &CGM)
Creates an instance of an Objective-C runtime class.
std::unique_ptr< TargetCodeGenInfo > createWindowsARMTargetCodeGenInfo(CodeGenModule &CGM, ARMABIKind K)
std::unique_ptr< TargetCodeGenInfo > createAVRTargetCodeGenInfo(CodeGenModule &CGM, unsigned NPR, unsigned NRR)
std::unique_ptr< TargetCodeGenInfo > createDirectXTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createARCTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createDefaultTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind Kind)
std::unique_ptr< TargetCodeGenInfo > createSPIRVTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createSparcV8TargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createVETargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createCommonSPIRTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createRISCVTargetCodeGenInfo(CodeGenModule &CGM, unsigned XLen, unsigned FLen, bool EABI)
std::unique_ptr< TargetCodeGenInfo > createWindowsAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind K)
std::unique_ptr< TargetCodeGenInfo > createSparcV9TargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createPNaClTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createX86_32TargetCodeGenInfo(CodeGenModule &CGM, bool DarwinVectorABI, bool Win32StructABI, unsigned NumRegisterParameters, bool SoftFloatABI)
std::unique_ptr< TargetCodeGenInfo > createLanaiTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createPPC32TargetCodeGenInfo(CodeGenModule &CGM, bool SoftFloatABI)
CGCUDARuntime * CreateNVCUDARuntime(CodeGenModule &CGM)
Creates an instance of a CUDA runtime class.
std::unique_ptr< TargetCodeGenInfo > createLoongArchTargetCodeGenInfo(CodeGenModule &CGM, unsigned GRLen, unsigned FLen)
std::unique_ptr< TargetCodeGenInfo > createPPC64TargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createWinX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel)
std::unique_ptr< TargetCodeGenInfo > createXCoreTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createCSKYTargetCodeGenInfo(CodeGenModule &CGM, unsigned FLen)
llvm::PointerUnion< const Decl *, const Expr * > DeclTy
The JSON file list parser is used to communicate input to InstallAPI.
CXXCtorType
C++ constructor types.
@ Ctor_Base
Base object ctor.
@ Ctor_Complete
Complete object ctor.
if(T->getSizeExpr()) TRY_TO(TraverseStmt(const_cast< Expr * >(T -> getSizeExpr())))
void EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts, DiagnosticsEngine &Diags)
GVALinkage
A more specific kind of linkage than enum Linkage.
@ GVA_AvailableExternally
std::string getClangVendor()
Retrieves the Clang vendor tag.
@ ICIS_NoInit
No in-class initializer.
CXXABI * CreateMicrosoftCXXABI(ASTContext &Ctx)
CXXABI * CreateItaniumCXXABI(ASTContext &Ctx)
Creates an instance of a C++ ABI class.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ Asm
Assembly: we accept this only so that we can preprocess it.
@ SD_Thread
Thread storage duration.
@ SD_Static
Static storage duration.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
StringRef languageToString(Language L)
@ Dtor_Base
Base object dtor.
@ Dtor_Complete
Complete object dtor.
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ FirstTargetAddressSpace
static const char * getCFBranchLabelSchemeFlagVal(const CFBranchLabelSchemeKind Scheme)
const FunctionProtoType * T
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ TSK_ExplicitInstantiationDefinition
This template specialization was instantiated from a template due to an explicit instantiation defini...
@ TSK_ImplicitInstantiation
This template specialization was implicitly instantiated from a template.
CallingConv
CallingConv - Specifies the calling convention that a function uses.
@ Struct
The "struct" keyword introduces the elaborated-type-specifier.
bool isExternallyVisible(Linkage L)
@ EST_None
no exception specification
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number,...
@ HiddenVisibility
Objects with "hidden" visibility are not seen by the dynamic linker.
@ DefaultVisibility
Objects with "default" visibility are seen by the dynamic linker and act like normal objects.
cl::opt< bool > SystemHeadersCoverage
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
llvm::CallingConv::ID RuntimeCC
llvm::IntegerType * Int64Ty
llvm::PointerType * ConstGlobalsPtrTy
void* in the address space for constant globals
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
llvm::IntegerType * CharTy
char
LangAS ASTAllocaAddressSpace
unsigned char PointerWidthInBits
The width of a pointer into the generic address space.
unsigned char IntAlignInBytes
llvm::Type * HalfTy
half, bfloat, float, double
unsigned char SizeSizeInBytes
llvm::CallingConv::ID getRuntimeCC() const
llvm::IntegerType * SizeTy
llvm::PointerType * GlobalsInt8PtrTy
llvm::IntegerType * Int32Ty
llvm::IntegerType * IntPtrTy
llvm::IntegerType * IntTy
int
llvm::IntegerType * Int16Ty
unsigned char PointerAlignInBytes
llvm::PointerType * Int8PtrTy
CharUnits getPointerAlign() const
llvm::PointerType * AllocaInt8PtrTy
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
bool hasSideEffects() const
Extra information about a function prototype.
static const LangStandard & getLangStandardForKind(Kind K)
Parts of a decomposed MSGuidDecl.
uint16_t Part2
...-89ab-...
uint32_t Part1
{01234567-...
uint16_t Part3
...-cdef-...
uint8_t Part4And5[8]
...-0123-456789abcdef}
A library or framework to link against when an entity from this module is used.
Contains information gathered from parsing the contents of TargetAttr.
PointerAuthSchema InitFiniPointers
The ABI for function addresses in .init_array and .fini_array.
Describes how types, statements, expressions, and declarations should be printed.
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.
bool hasOneOf(SanitizerMask K) const
Check if one or more sanitizers are enabled.