52#include "llvm/ADT/STLExtras.h"
53#include "llvm/ADT/StringExtras.h"
54#include "llvm/ADT/StringSwitch.h"
55#include "llvm/Analysis/TargetLibraryInfo.h"
56#include "llvm/BinaryFormat/ELF.h"
57#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
58#include "llvm/IR/AttributeMask.h"
59#include "llvm/IR/CallingConv.h"
60#include "llvm/IR/DataLayout.h"
61#include "llvm/IR/Intrinsics.h"
62#include "llvm/IR/LLVMContext.h"
63#include "llvm/IR/Module.h"
64#include "llvm/IR/ProfileSummary.h"
65#include "llvm/ProfileData/InstrProfReader.h"
66#include "llvm/ProfileData/SampleProf.h"
67#include "llvm/Support/CRC.h"
68#include "llvm/Support/CodeGen.h"
69#include "llvm/Support/CommandLine.h"
70#include "llvm/Support/ConvertUTF.h"
71#include "llvm/Support/ErrorHandling.h"
72#include "llvm/Support/TimeProfiler.h"
73#include "llvm/Support/xxhash.h"
74#include "llvm/TargetParser/RISCVISAInfo.h"
75#include "llvm/TargetParser/Triple.h"
76#include "llvm/TargetParser/X86TargetParser.h"
77#include "llvm/Transforms/Utils/BuildLibCalls.h"
81using namespace CodeGen;
84 "limited-coverage-experimental", llvm::cl::Hidden,
85 llvm::cl::desc(
"Emit limited coverage mapping information (experimental)"));
91 case TargetCXXABI::AppleARM64:
92 case TargetCXXABI::Fuchsia:
93 case TargetCXXABI::GenericAArch64:
94 case TargetCXXABI::GenericARM:
95 case TargetCXXABI::iOS:
96 case TargetCXXABI::WatchOS:
97 case TargetCXXABI::GenericMIPS:
98 case TargetCXXABI::GenericItanium:
99 case TargetCXXABI::WebAssembly:
100 case TargetCXXABI::XL:
102 case TargetCXXABI::Microsoft:
106 llvm_unreachable(
"invalid C++ ABI kind");
109static std::unique_ptr<TargetCodeGenInfo>
115 switch (Triple.getArch()) {
119 case llvm::Triple::le32:
121 case llvm::Triple::m68k:
123 case llvm::Triple::mips:
124 case llvm::Triple::mipsel:
125 if (Triple.getOS() == llvm::Triple::NaCl)
129 case llvm::Triple::mips64:
130 case llvm::Triple::mips64el:
133 case llvm::Triple::avr: {
137 unsigned NPR =
Target.getABI() ==
"avrtiny" ? 6 : 18;
138 unsigned NRR =
Target.getABI() ==
"avrtiny" ? 4 : 8;
142 case llvm::Triple::aarch64:
143 case llvm::Triple::aarch64_32:
144 case llvm::Triple::aarch64_be: {
146 if (
Target.getABI() ==
"darwinpcs")
147 Kind = AArch64ABIKind::DarwinPCS;
148 else if (Triple.isOSWindows())
150 else if (
Target.getABI() ==
"aapcs-soft")
151 Kind = AArch64ABIKind::AAPCSSoft;
156 case llvm::Triple::wasm32:
157 case llvm::Triple::wasm64: {
159 if (
Target.getABI() ==
"experimental-mv")
160 Kind = WebAssemblyABIKind::ExperimentalMV;
164 case llvm::Triple::arm:
165 case llvm::Triple::armeb:
166 case llvm::Triple::thumb:
167 case llvm::Triple::thumbeb: {
168 if (Triple.getOS() == llvm::Triple::Win32)
172 StringRef ABIStr =
Target.getABI();
173 if (ABIStr ==
"apcs-gnu")
174 Kind = ARMABIKind::APCS;
175 else if (ABIStr ==
"aapcs16")
176 Kind = ARMABIKind::AAPCS16_VFP;
177 else if (CodeGenOpts.
FloatABI ==
"hard" ||
179 (Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
180 Triple.getEnvironment() == llvm::Triple::MuslEABIHF ||
181 Triple.getEnvironment() == llvm::Triple::EABIHF)))
182 Kind = ARMABIKind::AAPCS_VFP;
187 case llvm::Triple::ppc: {
188 if (Triple.isOSAIX())
195 case llvm::Triple::ppcle: {
196 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
199 case llvm::Triple::ppc64:
200 if (Triple.isOSAIX())
203 if (Triple.isOSBinFormatELF()) {
205 if (
Target.getABI() ==
"elfv2")
206 Kind = PPC64_SVR4_ABIKind::ELFv2;
207 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
212 case llvm::Triple::ppc64le: {
213 assert(Triple.isOSBinFormatELF() &&
"PPC64 LE non-ELF not supported!");
215 if (
Target.getABI() ==
"elfv1")
216 Kind = PPC64_SVR4_ABIKind::ELFv1;
217 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
222 case llvm::Triple::nvptx:
223 case llvm::Triple::nvptx64:
226 case llvm::Triple::msp430:
229 case llvm::Triple::riscv32:
230 case llvm::Triple::riscv64: {
231 StringRef ABIStr =
Target.getABI();
232 unsigned XLen =
Target.getPointerWidth(LangAS::Default);
233 unsigned ABIFLen = 0;
234 if (ABIStr.ends_with(
"f"))
236 else if (ABIStr.ends_with(
"d"))
238 bool EABI = ABIStr.ends_with(
"e");
242 case llvm::Triple::systemz: {
243 bool SoftFloat = CodeGenOpts.
FloatABI ==
"soft";
244 bool HasVector = !SoftFloat &&
Target.getABI() ==
"vector";
248 case llvm::Triple::tce:
249 case llvm::Triple::tcele:
252 case llvm::Triple::x86: {
253 bool IsDarwinVectorABI = Triple.isOSDarwin();
254 bool IsWin32FloatStructABI = Triple.isOSWindows() && !Triple.isOSCygMing();
256 if (Triple.getOS() == llvm::Triple::Win32) {
258 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
259 CodeGenOpts.NumRegisterParameters);
262 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
263 CodeGenOpts.NumRegisterParameters, CodeGenOpts.
FloatABI ==
"soft");
266 case llvm::Triple::x86_64: {
267 StringRef ABI =
Target.getABI();
268 X86AVXABILevel AVXLevel = (ABI ==
"avx512" ? X86AVXABILevel::AVX512
269 : ABI ==
"avx" ? X86AVXABILevel::AVX
270 : X86AVXABILevel::None);
272 switch (Triple.getOS()) {
273 case llvm::Triple::Win32:
279 case llvm::Triple::hexagon:
281 case llvm::Triple::lanai:
283 case llvm::Triple::r600:
285 case llvm::Triple::amdgcn:
287 case llvm::Triple::sparc:
289 case llvm::Triple::sparcv9:
291 case llvm::Triple::xcore:
293 case llvm::Triple::arc:
295 case llvm::Triple::spir:
296 case llvm::Triple::spir64:
298 case llvm::Triple::spirv32:
299 case llvm::Triple::spirv64:
301 case llvm::Triple::ve:
303 case llvm::Triple::csky: {
304 bool IsSoftFloat = !
Target.hasFeature(
"hard-float-abi");
306 Target.hasFeature(
"fpuv2_df") ||
Target.hasFeature(
"fpuv3_df");
311 case llvm::Triple::bpfeb:
312 case llvm::Triple::bpfel:
314 case llvm::Triple::loongarch32:
315 case llvm::Triple::loongarch64: {
316 StringRef ABIStr =
Target.getABI();
317 unsigned ABIFRLen = 0;
318 if (ABIStr.ends_with(
"f"))
320 else if (ABIStr.ends_with(
"d"))
323 CGM,
Target.getPointerWidth(LangAS::Default), ABIFRLen);
329 if (!TheTargetCodeGenInfo)
331 return *TheTargetCodeGenInfo;
341 : Context(
C), LangOpts(
C.getLangOpts()), FS(FS), HeaderSearchOpts(HSO),
342 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
344 VMContext(M.getContext()), Types(*this), VTables(*this),
348 llvm::LLVMContext &LLVMContext = M.getContext();
349 VoidTy = llvm::Type::getVoidTy(LLVMContext);
350 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
351 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
352 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
353 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
354 HalfTy = llvm::Type::getHalfTy(LLVMContext);
355 BFloatTy = llvm::Type::getBFloatTy(LLVMContext);
356 FloatTy = llvm::Type::getFloatTy(LLVMContext);
357 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
363 C.toCharUnitsFromBits(
C.getTargetInfo().getMaxPointerWidth()).getQuantity();
365 C.toCharUnitsFromBits(
C.getTargetInfo().getIntAlign()).getQuantity();
367 llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getCharWidth());
368 IntTy = llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getIntWidth());
369 IntPtrTy = llvm::IntegerType::get(LLVMContext,
370 C.getTargetInfo().getMaxPointerWidth());
371 Int8PtrTy = llvm::PointerType::get(LLVMContext,
373 const llvm::DataLayout &DL = M.getDataLayout();
375 llvm::PointerType::get(LLVMContext, DL.getAllocaAddrSpace());
377 llvm::PointerType::get(LLVMContext, DL.getDefaultGlobalsAddressSpace());
394 createOpenCLRuntime();
396 createOpenMPRuntime();
403 if (LangOpts.
Sanitize.
has(SanitizerKind::Thread) ||
404 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
410 if (CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo ||
415 Block.GlobalUniqueCount = 0;
417 if (
C.getLangOpts().ObjC)
421 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
428 PGOReader = std::move(ReaderOrErr.get());
433 if (CodeGenOpts.CoverageMapping)
437 if (CodeGenOpts.UniqueInternalLinkageNames &&
438 !
getModule().getSourceFileName().empty()) {
439 std::string Path =
getModule().getSourceFileName();
442 if (Path.rfind(Entry.first, 0) != std::string::npos) {
443 Path = Entry.second + Path.substr(Entry.first.size());
446 ModuleNameHash = llvm::getUniqueInternalLinkagePostfix(Path);
451 getModule().addModuleFlag(llvm::Module::Error,
"NumRegisterParameters",
452 CodeGenOpts.NumRegisterParameters);
457void CodeGenModule::createObjCRuntime() {
474 llvm_unreachable(
"bad runtime kind");
477void CodeGenModule::createOpenCLRuntime() {
481void CodeGenModule::createOpenMPRuntime() {
485 case llvm::Triple::nvptx:
486 case llvm::Triple::nvptx64:
487 case llvm::Triple::amdgcn:
489 "OpenMP AMDGPU/NVPTX is only prepared to deal with device code.");
493 if (LangOpts.OpenMPSimd)
501void CodeGenModule::createCUDARuntime() {
505void CodeGenModule::createHLSLRuntime() {
510 Replacements[Name] =
C;
513void CodeGenModule::applyReplacements() {
514 for (
auto &I : Replacements) {
515 StringRef MangledName = I.first;
516 llvm::Constant *Replacement = I.second;
520 auto *OldF = cast<llvm::Function>(Entry);
521 auto *NewF = dyn_cast<llvm::Function>(Replacement);
523 if (
auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
524 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
526 auto *CE = cast<llvm::ConstantExpr>(Replacement);
527 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
528 CE->getOpcode() == llvm::Instruction::GetElementPtr);
529 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
534 OldF->replaceAllUsesWith(Replacement);
536 NewF->removeFromParent();
537 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
540 OldF->eraseFromParent();
545 GlobalValReplacements.push_back(std::make_pair(GV,
C));
548void CodeGenModule::applyGlobalValReplacements() {
549 for (
auto &I : GlobalValReplacements) {
550 llvm::GlobalValue *GV = I.first;
551 llvm::Constant *
C = I.second;
553 GV->replaceAllUsesWith(
C);
554 GV->eraseFromParent();
561 const llvm::Constant *
C;
562 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(GV))
563 C = GA->getAliasee();
564 else if (
auto *GI = dyn_cast<llvm::GlobalIFunc>(GV))
565 C = GI->getResolver();
569 const auto *AliaseeGV = dyn_cast<llvm::GlobalValue>(
C->stripPointerCasts());
573 const llvm::GlobalValue *FinalGV = AliaseeGV->getAliaseeObject();
582 bool IsIFunc,
const llvm::GlobalValue *Alias,
const llvm::GlobalValue *&GV,
583 const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames,
587 Diags.
Report(Location, diag::err_cyclic_alias) << IsIFunc;
591 if (GV->hasCommonLinkage()) {
593 if (Triple.getObjectFormat() == llvm::Triple::XCOFF) {
594 Diags.
Report(Location, diag::err_alias_to_common);
599 if (GV->isDeclaration()) {
600 Diags.
Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;
601 Diags.
Report(Location, diag::note_alias_requires_mangled_name)
602 << IsIFunc << IsIFunc;
605 for (
const auto &[
Decl, Name] : MangledDeclNames) {
606 if (
const auto *ND = dyn_cast<NamedDecl>(
Decl.getDecl())) {
607 if (ND->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>();
670 if (
const Attr *A = D->getDefiningAttr()) {
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);
733 Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
734 Alias->eraseFromParent();
739 DeferredDeclsToEmit.clear();
740 EmittedDeferredDecls.clear();
741 DeferredAnnotations.clear();
743 OpenMPRuntime->clear();
747 StringRef MainFile) {
750 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
751 if (MainFile.empty())
752 MainFile =
"<stdin>";
753 Diags.
Report(diag::warn_profile_data_unprofiled) << MainFile;
756 Diags.
Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
759 Diags.
Report(diag::warn_profile_data_missing) << Visited << Missing;
763static std::optional<llvm::GlobalValue::VisibilityTypes>
770 return llvm::GlobalValue::DefaultVisibility;
772 return llvm::GlobalValue::HiddenVisibility;
774 return llvm::GlobalValue::ProtectedVisibility;
776 llvm_unreachable(
"unknown option value!");
780 std::optional<llvm::GlobalValue::VisibilityTypes>
V) {
789 GV.setDSOLocal(
false);
790 GV.setVisibility(*
V);
795 if (!LO.VisibilityFromDLLStorageClass)
798 std::optional<llvm::GlobalValue::VisibilityTypes> DLLExportVisibility =
801 std::optional<llvm::GlobalValue::VisibilityTypes>
802 NoDLLStorageClassVisibility =
805 std::optional<llvm::GlobalValue::VisibilityTypes>
806 ExternDeclDLLImportVisibility =
809 std::optional<llvm::GlobalValue::VisibilityTypes>
810 ExternDeclNoDLLStorageClassVisibility =
813 for (llvm::GlobalValue &GV : M.global_values()) {
814 if (GV.hasAppendingLinkage() || GV.hasLocalLinkage())
817 if (GV.isDeclarationForLinker())
819 llvm::GlobalValue::DLLImportStorageClass
820 ? ExternDeclDLLImportVisibility
821 : ExternDeclNoDLLStorageClassVisibility);
824 llvm::GlobalValue::DLLExportStorageClass
825 ? DLLExportVisibility
826 : NoDLLStorageClassVisibility);
828 GV.setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
833 const llvm::Triple &Triple,
835 if (Triple.isAMDGPU() || Triple.isNVPTX())
837 return LangOpts.getStackProtector() == Mode;
843 EmitModuleInitializers(Primary);
845 DeferredDecls.insert(EmittedDeferredDecls.begin(),
846 EmittedDeferredDecls.end());
847 EmittedDeferredDecls.clear();
848 EmitVTablesOpportunistically();
849 applyGlobalValReplacements();
851 emitMultiVersionFunctions();
854 GlobalTopLevelStmtBlockInFlight.first) {
856 GlobalTopLevelStmtBlockInFlight.first->FinishFunction(TLSD->
getEndLoc());
857 GlobalTopLevelStmtBlockInFlight = {
nullptr,
nullptr};
863 EmitCXXModuleInitFunc(Primary);
865 EmitCXXGlobalInitFunc();
866 EmitCXXGlobalCleanUpFunc();
867 registerGlobalDtorsWithAtExit();
868 EmitCXXThreadLocalInitFunc();
870 if (llvm::Function *ObjCInitFunction =
ObjCRuntime->ModuleInitFunction())
873 if (llvm::Function *CudaCtorFunction = CUDARuntime->finalizeModule())
877 OpenMPRuntime->createOffloadEntriesAndInfoMetadata();
878 OpenMPRuntime->clear();
882 PGOReader->getSummary(
false).getMD(VMContext),
883 llvm::ProfileSummary::PSK_Instr);
890 EmitCtorList(GlobalCtors,
"llvm.global_ctors");
891 EmitCtorList(GlobalDtors,
"llvm.global_dtors");
893 EmitStaticExternCAliases();
899 CoverageMapping->emit();
900 if (CodeGenOpts.SanitizeCfiCrossDso) {
906 emitAtAvailableLinkGuard();
913 if (
getTarget().getTargetOpts().CodeObjectVersion !=
914 llvm::CodeObjectVersionKind::COV_None) {
915 getModule().addModuleFlag(llvm::Module::Error,
916 "amdhsa_code_object_version",
917 getTarget().getTargetOpts().CodeObjectVersion);
922 auto *MDStr = llvm::MDString::get(
927 getModule().addModuleFlag(llvm::Module::Error,
"amdgpu_printf_kind",
940 if (
auto *FD = dyn_cast<FunctionDecl>(D))
944 UsedArray.push_back(llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
948 llvm::ArrayType *ATy = llvm::ArrayType::get(
Int8PtrTy, UsedArray.size());
950 auto *GV =
new llvm::GlobalVariable(
951 getModule(), ATy,
false, llvm::GlobalValue::InternalLinkage,
952 llvm::ConstantArray::get(ATy, UsedArray),
"__clang_gpu_used_external");
955 if (LangOpts.HIP && !
getLangOpts().OffloadingNewDriver) {
958 auto *GV =
new llvm::GlobalVariable(
960 llvm::Constant::getNullValue(
Int8Ty),
968 if (CodeGenOpts.Autolink &&
969 (Context.
getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
970 EmitModuleLinkOptions();
985 if (!ELFDependentLibraries.empty() && !Context.
getLangOpts().CUDAIsDevice) {
986 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.dependent-libraries");
987 for (
auto *MD : ELFDependentLibraries)
991 if (CodeGenOpts.DwarfVersion) {
992 getModule().addModuleFlag(llvm::Module::Max,
"Dwarf Version",
993 CodeGenOpts.DwarfVersion);
996 if (CodeGenOpts.Dwarf64)
997 getModule().addModuleFlag(llvm::Module::Max,
"DWARF64", 1);
1001 getModule().setSemanticInterposition(
true);
1003 if (CodeGenOpts.EmitCodeView) {
1005 getModule().addModuleFlag(llvm::Module::Warning,
"CodeView", 1);
1007 if (CodeGenOpts.CodeViewGHash) {
1008 getModule().addModuleFlag(llvm::Module::Warning,
"CodeViewGHash", 1);
1010 if (CodeGenOpts.ControlFlowGuard) {
1012 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 2);
1013 }
else if (CodeGenOpts.ControlFlowGuardNoChecks) {
1015 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 1);
1017 if (CodeGenOpts.EHContGuard) {
1019 getModule().addModuleFlag(llvm::Module::Warning,
"ehcontguard", 1);
1023 getModule().addModuleFlag(llvm::Module::Warning,
"ms-kernel", 1);
1025 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
1030 getModule().addModuleFlag(llvm::Module::Error,
"StrictVTablePointers",1);
1032 llvm::Metadata *Ops[2] = {
1033 llvm::MDString::get(VMContext,
"StrictVTablePointers"),
1034 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1035 llvm::Type::getInt32Ty(VMContext), 1))};
1037 getModule().addModuleFlag(llvm::Module::Require,
1038 "StrictVTablePointersRequirement",
1039 llvm::MDNode::get(VMContext, Ops));
1045 getModule().addModuleFlag(llvm::Module::Warning,
"Debug Info Version",
1046 llvm::DEBUG_METADATA_VERSION);
1051 uint64_t WCharWidth =
1053 getModule().addModuleFlag(llvm::Module::Error,
"wchar_size", WCharWidth);
1056 getModule().addModuleFlag(llvm::Module::Warning,
1057 "zos_product_major_version",
1058 uint32_t(CLANG_VERSION_MAJOR));
1059 getModule().addModuleFlag(llvm::Module::Warning,
1060 "zos_product_minor_version",
1061 uint32_t(CLANG_VERSION_MINOR));
1062 getModule().addModuleFlag(llvm::Module::Warning,
"zos_product_patchlevel",
1063 uint32_t(CLANG_VERSION_PATCHLEVEL));
1065 getModule().addModuleFlag(llvm::Module::Error,
"zos_product_id",
1066 llvm::MDString::get(VMContext, ProductId));
1071 getModule().addModuleFlag(llvm::Module::Error,
"zos_cu_language",
1072 llvm::MDString::get(VMContext, lang_str));
1076 : std::time(
nullptr);
1077 getModule().addModuleFlag(llvm::Module::Max,
"zos_translation_time",
1078 static_cast<uint64_t
>(TT));
1081 getModule().addModuleFlag(llvm::Module::Error,
"zos_le_char_mode",
1082 llvm::MDString::get(VMContext,
"ascii"));
1086 if (
T.isARM() ||
T.isThumb()) {
1088 uint64_t EnumWidth = Context.
getLangOpts().ShortEnums ? 1 : 4;
1089 getModule().addModuleFlag(llvm::Module::Error,
"min_enum_size", EnumWidth);
1093 StringRef ABIStr =
Target.getABI();
1094 llvm::LLVMContext &Ctx = TheModule.getContext();
1095 getModule().addModuleFlag(llvm::Module::Error,
"target-abi",
1096 llvm::MDString::get(Ctx, ABIStr));
1101 const std::vector<std::string> &Features =
1104 llvm::RISCVISAInfo::parseFeatures(
T.isRISCV64() ? 64 : 32, Features);
1105 if (!errorToBool(ParseResult.takeError()))
1107 llvm::Module::AppendUnique,
"riscv-isa",
1109 Ctx, llvm::MDString::get(Ctx, (*ParseResult)->toString())));
1112 if (CodeGenOpts.SanitizeCfiCrossDso) {
1114 getModule().addModuleFlag(llvm::Module::Override,
"Cross-DSO CFI", 1);
1117 if (CodeGenOpts.WholeProgramVTables) {
1121 getModule().addModuleFlag(llvm::Module::Error,
"Virtual Function Elim",
1122 CodeGenOpts.VirtualFunctionElimination);
1125 if (LangOpts.
Sanitize.
has(SanitizerKind::CFIICall)) {
1126 getModule().addModuleFlag(llvm::Module::Override,
1127 "CFI Canonical Jump Tables",
1128 CodeGenOpts.SanitizeCfiCanonicalJumpTables);
1132 getModule().addModuleFlag(llvm::Module::Override,
"kcfi", 1);
1135 if (CodeGenOpts.PatchableFunctionEntryOffset)
1136 getModule().addModuleFlag(llvm::Module::Override,
"kcfi-offset",
1137 CodeGenOpts.PatchableFunctionEntryOffset);
1140 if (CodeGenOpts.CFProtectionReturn &&
1143 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-return",
1147 if (CodeGenOpts.CFProtectionBranch &&
1150 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-branch",
1154 if (CodeGenOpts.FunctionReturnThunks)
1155 getModule().addModuleFlag(llvm::Module::Override,
"function_return_thunk_extern", 1);
1157 if (CodeGenOpts.IndirectBranchCSPrefix)
1158 getModule().addModuleFlag(llvm::Module::Override,
"indirect_branch_cs_prefix", 1);
1170 LangOpts.getSignReturnAddressScope() !=
1172 getModule().addModuleFlag(llvm::Module::Override,
1173 "sign-return-address-buildattr", 1);
1174 if (LangOpts.
Sanitize.
has(SanitizerKind::MemtagStack))
1175 getModule().addModuleFlag(llvm::Module::Override,
1176 "tag-stack-memory-buildattr", 1);
1178 if (
T.isARM() ||
T.isThumb() ||
T.isAArch64()) {
1179 if (LangOpts.BranchTargetEnforcement)
1180 getModule().addModuleFlag(llvm::Module::Min,
"branch-target-enforcement",
1182 if (LangOpts.BranchProtectionPAuthLR)
1183 getModule().addModuleFlag(llvm::Module::Min,
"branch-protection-pauth-lr",
1185 if (LangOpts.GuardedControlStack)
1186 getModule().addModuleFlag(llvm::Module::Min,
"guarded-control-stack", 1);
1188 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address", 1);
1190 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address-all",
1193 getModule().addModuleFlag(llvm::Module::Min,
1194 "sign-return-address-with-bkey", 1);
1198 using namespace llvm::ELF;
1199 uint64_t PAuthABIVersion =
1200 (LangOpts.PointerAuthIntrinsics
1201 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INTRINSICS) |
1202 (LangOpts.PointerAuthCalls
1203 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_CALLS) |
1204 (LangOpts.PointerAuthReturns
1205 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_RETURNS) |
1206 (LangOpts.PointerAuthAuthTraps
1207 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_AUTHTRAPS) |
1208 (LangOpts.PointerAuthVTPtrAddressDiscrimination
1209 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRADDRDISCR) |
1210 (LangOpts.PointerAuthVTPtrTypeDiscrimination
1211 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRTYPEDISCR) |
1212 (LangOpts.PointerAuthInitFini
1213 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINI);
1214 static_assert(AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINI ==
1215 AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_LAST,
1216 "Update when new enum items are defined");
1217 if (PAuthABIVersion != 0) {
1218 getModule().addModuleFlag(llvm::Module::Error,
1219 "aarch64-elf-pauthabi-platform",
1220 AARCH64_PAUTH_PLATFORM_LLVM_LINUX);
1221 getModule().addModuleFlag(llvm::Module::Error,
1222 "aarch64-elf-pauthabi-version",
1228 if (CodeGenOpts.StackClashProtector)
1230 llvm::Module::Override,
"probe-stack",
1231 llvm::MDString::get(TheModule.getContext(),
"inline-asm"));
1233 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
1234 getModule().addModuleFlag(llvm::Module::Min,
"stack-probe-size",
1235 CodeGenOpts.StackProbeSize);
1238 llvm::LLVMContext &Ctx = TheModule.getContext();
1240 llvm::Module::Error,
"MemProfProfileFilename",
1244 if (LangOpts.CUDAIsDevice &&
getTriple().isNVPTX()) {
1248 getModule().addModuleFlag(llvm::Module::Override,
"nvvm-reflect-ftz",
1250 llvm::DenormalMode::IEEE);
1253 if (LangOpts.EHAsynch)
1254 getModule().addModuleFlag(llvm::Module::Warning,
"eh-asynch", 1);
1258 getModule().addModuleFlag(llvm::Module::Max,
"openmp", LangOpts.OpenMP);
1260 getModule().addModuleFlag(llvm::Module::Max,
"openmp-device",
1264 if (LangOpts.OpenCL || (LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())) {
1265 EmitOpenCLMetadata();
1273 llvm::Metadata *SPIRVerElts[] = {
1274 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1276 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1277 Int32Ty, (Version / 100 > 1) ? 0 : 2))};
1278 llvm::NamedMDNode *SPIRVerMD =
1279 TheModule.getOrInsertNamedMetadata(
"opencl.spir.version");
1280 llvm::LLVMContext &Ctx = TheModule.getContext();
1281 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
1289 if (uint32_t PLevel = Context.
getLangOpts().PICLevel) {
1290 assert(PLevel < 3 &&
"Invalid PIC Level");
1291 getModule().setPICLevel(
static_cast<llvm::PICLevel::Level
>(PLevel));
1293 getModule().setPIELevel(
static_cast<llvm::PIELevel::Level
>(PLevel));
1297 unsigned CM = llvm::StringSwitch<unsigned>(
getCodeGenOpts().CodeModel)
1298 .Case(
"tiny", llvm::CodeModel::Tiny)
1299 .Case(
"small", llvm::CodeModel::Small)
1300 .Case(
"kernel", llvm::CodeModel::Kernel)
1301 .Case(
"medium", llvm::CodeModel::Medium)
1302 .Case(
"large", llvm::CodeModel::Large)
1305 llvm::CodeModel::Model codeModel =
static_cast<llvm::CodeModel::Model
>(CM);
1308 if ((CM == llvm::CodeModel::Medium || CM == llvm::CodeModel::Large) &&
1310 llvm::Triple::x86_64) {
1316 if (CodeGenOpts.NoPLT)
1319 CodeGenOpts.DirectAccessExternalData !=
1320 getModule().getDirectAccessExternalData()) {
1321 getModule().setDirectAccessExternalData(
1322 CodeGenOpts.DirectAccessExternalData);
1324 if (CodeGenOpts.UnwindTables)
1325 getModule().setUwtable(llvm::UWTableKind(CodeGenOpts.UnwindTables));
1327 switch (CodeGenOpts.getFramePointer()) {
1332 getModule().setFramePointer(llvm::FramePointerKind::NonLeaf);
1335 getModule().setFramePointer(llvm::FramePointerKind::All);
1339 SimplifyPersonality();
1352 EmitVersionIdentMetadata();
1355 EmitCommandLineMetadata();
1363 getModule().setStackProtectorGuardSymbol(
1366 getModule().setStackProtectorGuardOffset(
1371 getModule().addModuleFlag(llvm::Module::Override,
"SkipRaxSetup", 1);
1373 getModule().addModuleFlag(llvm::Module::Override,
"RegCallv4", 1);
1375 if (
getContext().getTargetInfo().getMaxTLSAlign())
1376 getModule().addModuleFlag(llvm::Module::Error,
"MaxTLSAlign",
1377 getContext().getTargetInfo().getMaxTLSAlign());
1395void CodeGenModule::EmitOpenCLMetadata() {
1400 llvm::Metadata *OCLVerElts[] = {
1401 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1403 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1404 Int32Ty, (Version % 100) / 10))};
1405 llvm::NamedMDNode *OCLVerMD =
1406 TheModule.getOrInsertNamedMetadata(
"opencl.ocl.version");
1407 llvm::LLVMContext &Ctx = TheModule.getContext();
1408 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
1411void CodeGenModule::EmitBackendOptionsMetadata(
1414 getModule().addModuleFlag(llvm::Module::Min,
"SmallDataLimit",
1415 CodeGenOpts.SmallDataLimit);
1432 return TBAA->getTypeInfo(QTy);
1451 return TBAA->getAccessInfo(AccessType);
1458 return TBAA->getVTablePtrAccessInfo(VTablePtrType);
1464 return TBAA->getTBAAStructInfo(QTy);
1470 return TBAA->getBaseTypeInfo(QTy);
1476 return TBAA->getAccessTagInfo(Info);
1483 return TBAA->mergeTBAAInfoForCast(SourceInfo,
TargetInfo);
1491 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
1499 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
1505 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
1510 I->setMetadata(llvm::LLVMContext::MD_invariant_group,
1523 "cannot compile this %0 yet");
1524 std::string Msg =
Type;
1526 << Msg << S->getSourceRange();
1533 "cannot compile this %0 yet");
1534 std::string Msg =
Type;
1545 if (GV->hasLocalLinkage()) {
1546 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1560 Context.
getLangOpts().OpenMPIsTargetDevice && isa<VarDecl>(D) &&
1561 D->
hasAttr<OMPDeclareTargetDeclAttr>() &&
1562 D->
getAttr<OMPDeclareTargetDeclAttr>()->getDevType() !=
1563 OMPDeclareTargetDeclAttr::DT_NoHost &&
1565 GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
1569 if (GV->hasDLLExportStorageClass() || GV->hasDLLImportStorageClass()) {
1573 if (GV->hasDLLExportStorageClass()) {
1576 diag::err_hidden_visibility_dllexport);
1579 diag::err_non_default_visibility_dllimport);
1585 !GV->isDeclarationForLinker())
1590 llvm::GlobalValue *GV) {
1591 if (GV->hasLocalLinkage())
1594 if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
1598 if (GV->hasDLLImportStorageClass())
1601 const llvm::Triple &TT = CGM.
getTriple();
1603 if (TT.isWindowsGNUEnvironment()) {
1612 if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
1621 if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
1629 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
1633 if (!TT.isOSBinFormatELF())
1639 if (RM != llvm::Reloc::Static && !LOpts.PIE) {
1645 if (!(isa<llvm::Function>(GV) && GV->canBenefitFromLocalAlias()))
1647 return !(CGM.
getLangOpts().SemanticInterposition ||
1652 if (!GV->isDeclarationForLinker())
1658 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
1665 if (CGOpts.DirectAccessExternalData) {
1671 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
1672 if (!Var->isThreadLocal())
1681 if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
1697 const auto *D = dyn_cast<NamedDecl>(GD.
getDecl());
1699 if (
const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) {
1709 if (D->
hasAttr<DLLImportAttr>())
1710 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
1711 else if ((D->
hasAttr<DLLExportAttr>() ||
1713 !GV->isDeclarationForLinker())
1714 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
1738 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
1739 .Case(
"global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
1740 .Case(
"local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
1741 .Case(
"initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
1742 .Case(
"local-exec", llvm::GlobalVariable::LocalExecTLSModel);
1745llvm::GlobalVariable::ThreadLocalMode
1747 switch (CodeGenOpts.getDefaultTLSModel()) {
1749 return llvm::GlobalVariable::GeneralDynamicTLSModel;
1751 return llvm::GlobalVariable::LocalDynamicTLSModel;
1753 return llvm::GlobalVariable::InitialExecTLSModel;
1755 return llvm::GlobalVariable::LocalExecTLSModel;
1757 llvm_unreachable(
"Invalid TLS model!");
1761 assert(D.
getTLSKind() &&
"setting TLS mode on non-TLS var!");
1763 llvm::GlobalValue::ThreadLocalMode TLM;
1767 if (
const TLSModelAttr *
Attr = D.
getAttr<TLSModelAttr>()) {
1771 GV->setThreadLocalMode(TLM);
1777 return (Twine(
'.') + Twine(
Target.CPUSpecificManglingCharacter(Name))).str();
1781 const CPUSpecificAttr *
Attr,
1803 bool OmitMultiVersionMangling =
false) {
1805 llvm::raw_svector_ostream Out(Buffer);
1814 assert(II &&
"Attempt to mangle unnamed decl.");
1815 const auto *FD = dyn_cast<FunctionDecl>(ND);
1820 Out <<
"__regcall4__" << II->
getName();
1822 Out <<
"__regcall3__" << II->
getName();
1823 }
else if (FD && FD->hasAttr<CUDAGlobalAttr>() &&
1825 Out <<
"__device_stub__" << II->
getName();
1841 "Hash computed when not explicitly requested");
1845 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
1846 if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
1847 switch (FD->getMultiVersionKind()) {
1851 FD->getAttr<CPUSpecificAttr>(),
1855 auto *
Attr = FD->getAttr<TargetAttr>();
1857 Info.appendAttributeMangling(
Attr, Out);
1861 auto *
Attr = FD->getAttr<TargetVersionAttr>();
1863 Info.appendAttributeMangling(
Attr, Out);
1867 auto *
Attr = FD->getAttr<TargetClonesAttr>();
1874 llvm_unreachable(
"None multiversion type isn't valid here");
1884 return std::string(Out.str());
1887void CodeGenModule::UpdateMultiVersionNames(
GlobalDecl GD,
1889 StringRef &CurName) {
1896 std::string NonTargetName =
1904 "Other GD should now be a multiversioned function");
1914 if (OtherName != NonTargetName) {
1917 const auto ExistingRecord = Manglings.find(NonTargetName);
1918 if (ExistingRecord != std::end(Manglings))
1919 Manglings.remove(&(*ExistingRecord));
1920 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
1925 CurName = OtherNameRef;
1927 Entry->setName(OtherName);
1937 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.
getDecl())) {
1951 auto FoundName = MangledDeclNames.find(CanonicalGD);
1952 if (FoundName != MangledDeclNames.end())
1953 return FoundName->second;
1957 const auto *ND = cast<NamedDecl>(GD.
getDecl());
1969 assert(!isa<FunctionDecl>(ND) || !ND->hasAttr<CUDAGlobalAttr>() ||
1980 auto Result = Manglings.insert(std::make_pair(MangledName, GD));
1981 return MangledDeclNames[CanonicalGD] =
Result.first->first();
1990 llvm::raw_svector_ostream Out(Buffer);
1993 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.
getDecl()), Out);
1994 else if (
const auto *CD = dyn_cast<CXXConstructorDecl>(D))
1996 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(D))
1999 MangleCtx.
mangleBlock(cast<DeclContext>(D), BD, Out);
2001 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
2002 return Result.first->first();
2006 auto it = MangledDeclNames.begin();
2007 while (it != MangledDeclNames.end()) {
2008 if (it->second == Name)
2023 llvm::Constant *AssociatedData) {
2031 bool IsDtorAttrFunc) {
2032 if (CodeGenOpts.RegisterGlobalDtorsWithAtExit &&
2034 DtorsUsingAtExit[
Priority].push_back(Dtor);
2042void CodeGenModule::EmitCtorList(CtorList &Fns,
const char *GlobalName) {
2043 if (Fns.empty())
return;
2046 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(
VoidTy,
false);
2047 llvm::Type *CtorPFTy = llvm::PointerType::get(CtorFTy,
2048 TheModule.getDataLayout().getProgramAddressSpace());
2051 llvm::StructType *CtorStructTy = llvm::StructType::get(
2056 auto ctors = builder.beginArray(CtorStructTy);
2057 for (
const auto &I : Fns) {
2058 auto ctor = ctors.beginStruct(CtorStructTy);
2059 ctor.addInt(
Int32Ty, I.Priority);
2060 ctor.add(I.Initializer);
2061 if (I.AssociatedData)
2062 ctor.add(I.AssociatedData);
2065 ctor.finishAndAddTo(ctors);
2071 llvm::GlobalValue::AppendingLinkage);
2075 list->setAlignment(std::nullopt);
2080llvm::GlobalValue::LinkageTypes
2082 const auto *D = cast<FunctionDecl>(GD.
getDecl());
2086 if (
const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
2093 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
2094 if (!MDS)
return nullptr;
2096 return llvm::ConstantInt::get(
Int64Ty, llvm::MD5Hash(MDS->getString()));
2102 FnType->getReturnType(), FnType->getParamTypes(),
2103 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
2105 std::string OutName;
2106 llvm::raw_string_ostream Out(OutName);
2111 Out <<
".normalized";
2113 return llvm::ConstantInt::get(
Int32Ty,
2114 static_cast<uint32_t
>(llvm::xxHash64(OutName)));
2119 llvm::Function *F,
bool IsThunk) {
2121 llvm::AttributeList PAL;
2124 if (
CallingConv == llvm::CallingConv::X86_VectorCall &&
2128 Loc = D->getLocation();
2130 Error(
Loc,
"__vectorcall calling convention is not currently supported");
2132 F->setAttributes(PAL);
2133 F->setCallingConv(
static_cast<llvm::CallingConv::ID
>(
CallingConv));
2137 std::string ReadOnlyQual(
"__read_only");
2138 std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
2139 if (ReadOnlyPos != std::string::npos)
2141 TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);
2143 std::string WriteOnlyQual(
"__write_only");
2144 std::string::size_type WriteOnlyPos = TyName.find(WriteOnlyQual);
2145 if (WriteOnlyPos != std::string::npos)
2146 TyName.erase(WriteOnlyPos, WriteOnlyQual.size() + 1);
2148 std::string ReadWriteQual(
"__read_write");
2149 std::string::size_type ReadWritePos = TyName.find(ReadWriteQual);
2150 if (ReadWritePos != std::string::npos)
2151 TyName.erase(ReadWritePos, ReadWriteQual.size() + 1);
2184 assert(((FD && CGF) || (!FD && !CGF)) &&
2185 "Incorrect use - FD and CGF should either be both null or not!");
2211 for (
unsigned i = 0, e = FD->
getNumParams(); i != e; ++i) {
2214 argNames.push_back(llvm::MDString::get(VMContext, parm->
getName()));
2219 std::string typeQuals;
2223 const Decl *PDecl = parm;
2225 PDecl = TD->getDecl();
2226 const OpenCLAccessAttr *A = PDecl->
getAttr<OpenCLAccessAttr>();
2227 if (A && A->isWriteOnly())
2228 accessQuals.push_back(llvm::MDString::get(VMContext,
"write_only"));
2229 else if (A && A->isReadWrite())
2230 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_write"));
2232 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_only"));
2234 accessQuals.push_back(llvm::MDString::get(VMContext,
"none"));
2236 auto getTypeSpelling = [&](
QualType Ty) {
2237 auto typeName = Ty.getUnqualifiedType().getAsString(Policy);
2239 if (Ty.isCanonical()) {
2240 StringRef typeNameRef = typeName;
2242 if (typeNameRef.consume_front(
"unsigned "))
2243 return std::string(
"u") + typeNameRef.str();
2244 if (typeNameRef.consume_front(
"signed "))
2245 return typeNameRef.str();
2255 addressQuals.push_back(
2256 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(
2260 std::string typeName = getTypeSpelling(pointeeTy) +
"*";
2261 std::string baseTypeName =
2263 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2264 argBaseTypeNames.push_back(
2265 llvm::MDString::get(VMContext, baseTypeName));
2269 typeQuals =
"restrict";
2272 typeQuals += typeQuals.empty() ?
"const" :
" const";
2274 typeQuals += typeQuals.empty() ?
"volatile" :
" volatile";
2276 uint32_t AddrSpc = 0;
2281 addressQuals.push_back(
2282 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(AddrSpc)));
2286 std::string typeName = getTypeSpelling(ty);
2298 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2299 argBaseTypeNames.push_back(
2300 llvm::MDString::get(VMContext, baseTypeName));
2305 argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));
2309 Fn->setMetadata(
"kernel_arg_addr_space",
2310 llvm::MDNode::get(VMContext, addressQuals));
2311 Fn->setMetadata(
"kernel_arg_access_qual",
2312 llvm::MDNode::get(VMContext, accessQuals));
2313 Fn->setMetadata(
"kernel_arg_type",
2314 llvm::MDNode::get(VMContext, argTypeNames));
2315 Fn->setMetadata(
"kernel_arg_base_type",
2316 llvm::MDNode::get(VMContext, argBaseTypeNames));
2317 Fn->setMetadata(
"kernel_arg_type_qual",
2318 llvm::MDNode::get(VMContext, argTypeQuals));
2322 Fn->setMetadata(
"kernel_arg_name",
2323 llvm::MDNode::get(VMContext, argNames));
2333 if (!LangOpts.Exceptions)
return false;
2336 if (LangOpts.CXXExceptions)
return true;
2339 if (LangOpts.ObjCExceptions) {
2356 !isa<CXXConstructorDecl, CXXDestructorDecl>(MD);
2361 llvm::SetVector<const CXXRecordDecl *> MostBases;
2363 std::function<void (
const CXXRecordDecl *)> CollectMostBases;
2366 MostBases.insert(RD);
2368 CollectMostBases(B.getType()->getAsCXXRecordDecl());
2370 CollectMostBases(RD);
2371 return MostBases.takeVector();
2375 llvm::Function *F) {
2376 llvm::AttrBuilder B(F->getContext());
2378 if ((!D || !D->
hasAttr<NoUwtableAttr>()) && CodeGenOpts.UnwindTables)
2379 B.addUWTableAttr(llvm::UWTableKind(CodeGenOpts.UnwindTables));
2381 if (CodeGenOpts.StackClashProtector)
2382 B.addAttribute(
"probe-stack",
"inline-asm");
2384 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
2385 B.addAttribute(
"stack-probe-size",
2386 std::to_string(CodeGenOpts.StackProbeSize));
2389 B.addAttribute(llvm::Attribute::NoUnwind);
2391 if (D && D->
hasAttr<NoStackProtectorAttr>())
2393 else if (D && D->
hasAttr<StrictGuardStackCheckAttr>() &&
2395 B.addAttribute(llvm::Attribute::StackProtectStrong);
2397 B.addAttribute(llvm::Attribute::StackProtect);
2399 B.addAttribute(llvm::Attribute::StackProtectStrong);
2401 B.addAttribute(llvm::Attribute::StackProtectReq);
2407 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
2409 B.addAttribute(llvm::Attribute::NoInline);
2417 if (D->
hasAttr<ArmLocallyStreamingAttr>())
2418 B.addAttribute(
"aarch64_pstate_sm_body");
2421 if (
Attr->isNewZA())
2422 B.addAttribute(
"aarch64_new_za");
2423 if (
Attr->isNewZT0())
2424 B.addAttribute(
"aarch64_new_zt0");
2429 bool ShouldAddOptNone =
2430 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
2432 ShouldAddOptNone &= !D->
hasAttr<MinSizeAttr>();
2433 ShouldAddOptNone &= !D->
hasAttr<AlwaysInlineAttr>();
2436 if ((ShouldAddOptNone || D->
hasAttr<OptimizeNoneAttr>()) &&
2437 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2438 B.addAttribute(llvm::Attribute::OptimizeNone);
2441 B.addAttribute(llvm::Attribute::NoInline);
2446 B.addAttribute(llvm::Attribute::Naked);
2449 F->removeFnAttr(llvm::Attribute::OptimizeForSize);
2450 F->removeFnAttr(llvm::Attribute::MinSize);
2451 }
else if (D->
hasAttr<NakedAttr>()) {
2453 B.addAttribute(llvm::Attribute::Naked);
2454 B.addAttribute(llvm::Attribute::NoInline);
2455 }
else if (D->
hasAttr<NoDuplicateAttr>()) {
2456 B.addAttribute(llvm::Attribute::NoDuplicate);
2457 }
else if (D->
hasAttr<NoInlineAttr>() && !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2459 B.addAttribute(llvm::Attribute::NoInline);
2460 }
else if (D->
hasAttr<AlwaysInlineAttr>() &&
2461 !F->hasFnAttribute(llvm::Attribute::NoInline)) {
2463 B.addAttribute(llvm::Attribute::AlwaysInline);
2467 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
2468 B.addAttribute(llvm::Attribute::NoInline);
2472 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
2475 auto CheckRedeclForInline = [](
const FunctionDecl *Redecl) {
2476 return Redecl->isInlineSpecified();
2478 if (any_of(FD->
redecls(), CheckRedeclForInline))
2483 return any_of(Pattern->
redecls(), CheckRedeclForInline);
2485 if (CheckForInline(FD)) {
2486 B.addAttribute(llvm::Attribute::InlineHint);
2487 }
else if (CodeGenOpts.getInlining() ==
2490 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2491 B.addAttribute(llvm::Attribute::NoInline);
2498 if (!D->
hasAttr<OptimizeNoneAttr>()) {
2500 if (!ShouldAddOptNone)
2501 B.addAttribute(llvm::Attribute::OptimizeForSize);
2502 B.addAttribute(llvm::Attribute::Cold);
2505 B.addAttribute(llvm::Attribute::Hot);
2506 if (D->
hasAttr<MinSizeAttr>())
2507 B.addAttribute(llvm::Attribute::MinSize);
2514 F->setAlignment(llvm::Align(alignment));
2516 if (!D->
hasAttr<AlignedAttr>())
2517 if (LangOpts.FunctionAlignment)
2518 F->setAlignment(llvm::Align(1ull << LangOpts.FunctionAlignment));
2525 if (isa<CXXMethodDecl>(D) && F->getPointerAlignment(
getDataLayout()) < 2)
2526 F->setAlignment(std::max(llvm::Align(2), F->getAlign().valueOrOne()));
2531 if (CodeGenOpts.SanitizeCfiCrossDso &&
2532 CodeGenOpts.SanitizeCfiCanonicalJumpTables) {
2533 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
2544 auto *MD = dyn_cast<CXXMethodDecl>(D);
2547 llvm::Metadata *
Id =
2550 F->addTypeMetadata(0,
Id);
2557 if (isa_and_nonnull<NamedDecl>(D))
2560 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
2562 if (D && D->
hasAttr<UsedAttr>())
2565 if (
const auto *VD = dyn_cast_if_present<VarDecl>(D);
2567 ((CodeGenOpts.KeepPersistentStorageVariables &&
2568 (VD->getStorageDuration() ==
SD_Static ||
2569 VD->getStorageDuration() ==
SD_Thread)) ||
2570 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==
SD_Static &&
2571 VD->getType().isConstQualified())))
2575bool CodeGenModule::GetCPUAndFeaturesAttributes(
GlobalDecl GD,
2576 llvm::AttrBuilder &Attrs,
2577 bool SetTargetFeatures) {
2583 std::vector<std::string> Features;
2584 const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.
getDecl());
2586 const auto *TD = FD ? FD->
getAttr<TargetAttr>() :
nullptr;
2587 const auto *TV = FD ? FD->
getAttr<TargetVersionAttr>() :
nullptr;
2588 assert((!TD || !TV) &&
"both target_version and target specified");
2589 const auto *SD = FD ? FD->
getAttr<CPUSpecificAttr>() :
nullptr;
2590 const auto *TC = FD ? FD->
getAttr<TargetClonesAttr>() :
nullptr;
2591 bool AddedAttr =
false;
2592 if (TD || TV || SD || TC) {
2593 llvm::StringMap<bool> FeatureMap;
2597 for (
const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
2598 Features.push_back((Entry.getValue() ?
"+" :
"-") + Entry.getKey().str());
2606 Target.parseTargetAttr(TD->getFeaturesStr());
2628 if (!TargetCPU.empty()) {
2629 Attrs.addAttribute(
"target-cpu", TargetCPU);
2632 if (!TuneCPU.empty()) {
2633 Attrs.addAttribute(
"tune-cpu", TuneCPU);
2636 if (!Features.empty() && SetTargetFeatures) {
2637 llvm::erase_if(Features, [&](
const std::string& F) {
2640 llvm::sort(Features);
2641 Attrs.addAttribute(
"target-features", llvm::join(Features,
","));
2648void CodeGenModule::setNonAliasAttributes(
GlobalDecl GD,
2649 llvm::GlobalObject *GO) {
2654 if (
auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
2657 if (
auto *SA = D->
getAttr<PragmaClangBSSSectionAttr>())
2658 GV->addAttribute(
"bss-section", SA->getName());
2659 if (
auto *SA = D->
getAttr<PragmaClangDataSectionAttr>())
2660 GV->addAttribute(
"data-section", SA->getName());
2661 if (
auto *SA = D->
getAttr<PragmaClangRodataSectionAttr>())
2662 GV->addAttribute(
"rodata-section", SA->getName());
2663 if (
auto *SA = D->
getAttr<PragmaClangRelroSectionAttr>())
2664 GV->addAttribute(
"relro-section", SA->getName());
2667 if (
auto *F = dyn_cast<llvm::Function>(GO)) {
2670 if (
auto *SA = D->
getAttr<PragmaClangTextSectionAttr>())
2671 if (!D->
getAttr<SectionAttr>())
2672 F->setSection(SA->getName());
2674 llvm::AttrBuilder Attrs(F->getContext());
2675 if (GetCPUAndFeaturesAttributes(GD, Attrs)) {
2679 llvm::AttributeMask RemoveAttrs;
2680 RemoveAttrs.addAttribute(
"target-cpu");
2681 RemoveAttrs.addAttribute(
"target-features");
2682 RemoveAttrs.addAttribute(
"tune-cpu");
2683 F->removeFnAttrs(RemoveAttrs);
2684 F->addFnAttrs(Attrs);
2688 if (
const auto *CSA = D->
getAttr<CodeSegAttr>())
2689 GO->setSection(CSA->getName());
2690 else if (
const auto *SA = D->
getAttr<SectionAttr>())
2691 GO->setSection(SA->getName());
2704 F->setLinkage(llvm::Function::InternalLinkage);
2706 setNonAliasAttributes(GD, F);
2717 GV->
setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
2721 llvm::Function *F) {
2723 if (!LangOpts.
Sanitize.
has(SanitizerKind::CFIICall))
2728 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
2732 F->addTypeMetadata(0, MD);
2736 if (CodeGenOpts.SanitizeCfiCrossDso)
2738 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
2742 llvm::LLVMContext &Ctx = F->getContext();
2743 llvm::MDBuilder MDB(Ctx);
2744 F->setMetadata(llvm::LLVMContext::MD_kcfi_type,
2753 return llvm::all_of(Name, [](
const char &
C) {
2754 return llvm::isAlnum(
C) ||
C ==
'_' ||
C ==
'.';
2760 for (
auto &F : M.functions()) {
2762 bool AddressTaken = F.hasAddressTaken();
2763 if (!AddressTaken && F.hasLocalLinkage())
2764 F.eraseMetadata(llvm::LLVMContext::MD_kcfi_type);
2769 if (!AddressTaken || !F.isDeclaration())
2772 const llvm::ConstantInt *
Type;
2773 if (
const llvm::MDNode *MD = F.getMetadata(llvm::LLVMContext::MD_kcfi_type))
2774 Type = llvm::mdconst::extract<llvm::ConstantInt>(MD->getOperand(0));
2778 StringRef Name = F.getName();
2782 std::string
Asm = (
".weak __kcfi_typeid_" + Name +
"\n.set __kcfi_typeid_" +
2783 Name +
", " + Twine(
Type->getZExtValue()) +
"\n")
2785 M.appendModuleInlineAsm(
Asm);
2789void CodeGenModule::SetFunctionAttributes(
GlobalDecl GD, llvm::Function *F,
2790 bool IsIncompleteFunction,
2793 if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
2796 F->setAttributes(llvm::Intrinsic::getAttributes(
getLLVMContext(), IID));
2800 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
2802 if (!IsIncompleteFunction)
2809 if (!IsThunk &&
getCXXABI().HasThisReturn(GD) &&
2811 assert(!F->arg_empty() &&
2812 F->arg_begin()->getType()
2813 ->canLosslesslyBitCastTo(F->getReturnType()) &&
2814 "unexpected this return");
2815 F->addParamAttr(0, llvm::Attribute::Returned);
2825 if (!IsIncompleteFunction && F->isDeclaration())
2828 if (
const auto *CSA = FD->
getAttr<CodeSegAttr>())
2829 F->setSection(CSA->getName());
2830 else if (
const auto *SA = FD->
getAttr<SectionAttr>())
2831 F->setSection(SA->getName());
2833 if (
const auto *EA = FD->
getAttr<ErrorAttr>()) {
2835 F->addFnAttr(
"dontcall-error", EA->getUserDiagnostic());
2836 else if (EA->isWarning())
2837 F->addFnAttr(
"dontcall-warn", EA->getUserDiagnostic());
2843 bool HasBody = FD->
hasBody(FDBody);
2845 assert(HasBody &&
"Inline builtin declarations should always have an "
2847 if (shouldEmitFunction(FDBody))
2848 F->addFnAttr(llvm::Attribute::NoBuiltin);
2854 F->addFnAttr(llvm::Attribute::NoBuiltin);
2857 if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
2858 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2859 else if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
2860 if (MD->isVirtual())
2861 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2867 if (!CodeGenOpts.SanitizeCfiCrossDso ||
2868 !CodeGenOpts.SanitizeCfiCanonicalJumpTables)
2877 if (CodeGenOpts.InlineMaxStackSize !=
UINT_MAX)
2878 F->addFnAttr(
"inline-max-stacksize", llvm::utostr(CodeGenOpts.InlineMaxStackSize));
2880 if (
const auto *CB = FD->
getAttr<CallbackAttr>()) {
2884 llvm::LLVMContext &Ctx = F->getContext();
2885 llvm::MDBuilder MDB(Ctx);
2889 int CalleeIdx = *CB->encoding_begin();
2890 ArrayRef<int> PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());
2891 F->addMetadata(llvm::LLVMContext::MD_callback,
2892 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
2893 CalleeIdx, PayloadIndices,
2899 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
2900 "Only globals with definition can force usage.");
2901 LLVMUsed.emplace_back(GV);
2905 assert(!GV->isDeclaration() &&
2906 "Only globals with definition can force usage.");
2907 LLVMCompilerUsed.emplace_back(GV);
2911 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
2912 "Only globals with definition can force usage.");
2914 LLVMCompilerUsed.emplace_back(GV);
2916 LLVMUsed.emplace_back(GV);
2920 std::vector<llvm::WeakTrackingVH> &List) {
2927 UsedArray.resize(List.size());
2928 for (
unsigned i = 0, e = List.size(); i != e; ++i) {
2930 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
2931 cast<llvm::Constant>(&*List[i]), CGM.
Int8PtrTy);
2934 if (UsedArray.empty())
2936 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.
Int8PtrTy, UsedArray.size());
2938 auto *GV =
new llvm::GlobalVariable(
2939 CGM.
getModule(), ATy,
false, llvm::GlobalValue::AppendingLinkage,
2940 llvm::ConstantArray::get(ATy, UsedArray), Name);
2942 GV->setSection(
"llvm.metadata");
2945void CodeGenModule::emitLLVMUsed() {
2946 emitUsed(*
this,
"llvm.used", LLVMUsed);
2947 emitUsed(*
this,
"llvm.compiler.used", LLVMCompilerUsed);
2952 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
2961 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
2967 ELFDependentLibraries.push_back(
2968 llvm::MDNode::get(
C, llvm::MDString::get(
C, Lib)));
2975 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
C, MDOpts));
2990 if (
Visited.insert(Import).second)
3007 if (LL.IsFramework) {
3008 llvm::Metadata *Args[2] = {llvm::MDString::get(Context,
"-framework"),
3009 llvm::MDString::get(Context, LL.Library)};
3011 Metadata.push_back(llvm::MDNode::get(Context, Args));
3017 llvm::Metadata *Args[2] = {
3018 llvm::MDString::get(Context,
"lib"),
3019 llvm::MDString::get(Context, LL.Library),
3021 Metadata.push_back(llvm::MDNode::get(Context, Args));
3025 auto *OptString = llvm::MDString::get(Context, Opt);
3026 Metadata.push_back(llvm::MDNode::get(Context, OptString));
3031void CodeGenModule::EmitModuleInitializers(
clang::Module *Primary) {
3033 "We should only emit module initializers for named modules.");
3039 if (isa<ImportDecl>(D))
3041 assert(isa<VarDecl>(D) &&
"GMF initializer decl is not a var?");
3048 if (isa<ImportDecl>(D))
3056 if (isa<ImportDecl>(D))
3058 assert(isa<VarDecl>(D) &&
"PMF initializer decl is not a var?");
3064void CodeGenModule::EmitModuleLinkOptions() {
3068 llvm::SetVector<clang::Module *> LinkModules;
3073 for (
Module *M : ImportedModules) {
3076 if (M->getTopLevelModuleName() ==
getLangOpts().CurrentModule &&
3085 while (!Stack.empty()) {
3088 bool AnyChildren =
false;
3098 Stack.push_back(
SM);
3106 LinkModules.insert(Mod);
3115 for (
Module *M : LinkModules)
3118 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
3119 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
3122 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.linker.options");
3123 for (
auto *MD : LinkerOptionsMetadata)
3124 NMD->addOperand(MD);
3127void CodeGenModule::EmitDeferred() {
3136 if (!DeferredVTables.empty()) {
3137 EmitDeferredVTables();
3142 assert(DeferredVTables.empty());
3149 llvm::append_range(DeferredDeclsToEmit,
3153 if (DeferredDeclsToEmit.empty())
3158 std::vector<GlobalDecl> CurDeclsToEmit;
3159 CurDeclsToEmit.swap(DeferredDeclsToEmit);
3166 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
3184 if (!GV->isDeclaration())
3188 if (LangOpts.OpenMP && OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(D))
3192 EmitGlobalDefinition(D, GV);
3197 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
3199 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
3204void CodeGenModule::EmitVTablesOpportunistically() {
3210 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
3211 &&
"Only emit opportunistic vtables with optimizations");
3215 "This queue should only contain external vtables");
3216 if (
getCXXABI().canSpeculativelyEmitVTable(RD))
3219 OpportunisticVTables.clear();
3223 for (
const auto& [MangledName, VD] : DeferredAnnotations) {
3228 DeferredAnnotations.clear();
3230 if (Annotations.empty())
3234 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
3235 Annotations[0]->getType(), Annotations.size()), Annotations);
3236 auto *gv =
new llvm::GlobalVariable(
getModule(), Array->getType(),
false,
3237 llvm::GlobalValue::AppendingLinkage,
3238 Array,
"llvm.global.annotations");
3243 llvm::Constant *&AStr = AnnotationStrings[Str];
3248 llvm::Constant *
s = llvm::ConstantDataArray::getString(
getLLVMContext(), Str);
3249 auto *gv =
new llvm::GlobalVariable(
3250 getModule(),
s->getType(),
true, llvm::GlobalValue::PrivateLinkage,
s,
3251 ".str",
nullptr, llvm::GlobalValue::NotThreadLocal,
3254 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3271 SM.getExpansionLineNumber(L);
3272 return llvm::ConstantInt::get(
Int32Ty, LineNo);
3280 llvm::FoldingSetNodeID ID;
3281 for (
Expr *E : Exprs) {
3282 ID.Add(cast<clang::ConstantExpr>(E)->getAPValueResult());
3284 llvm::Constant *&Lookup = AnnotationArgs[ID.ComputeHash()];
3289 LLVMArgs.reserve(Exprs.size());
3291 llvm::transform(Exprs, std::back_inserter(LLVMArgs), [&](
const Expr *E) {
3292 const auto *CE = cast<clang::ConstantExpr>(E);
3293 return ConstEmiter.
emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(),
3296 auto *
Struct = llvm::ConstantStruct::getAnon(LLVMArgs);
3297 auto *GV =
new llvm::GlobalVariable(
getModule(),
Struct->getType(),
true,
3298 llvm::GlobalValue::PrivateLinkage,
Struct,
3301 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3308 const AnnotateAttr *AA,
3316 llvm::Constant *GVInGlobalsAS = GV;
3317 if (GV->getAddressSpace() !=
3319 GVInGlobalsAS = llvm::ConstantExpr::getAddrSpaceCast(
3321 llvm::PointerType::get(
3322 GV->getContext(),
getDataLayout().getDefaultGlobalsAddressSpace()));
3326 llvm::Constant *Fields[] = {
3327 GVInGlobalsAS, AnnoGV, UnitGV, LineNoCst, Args,
3329 return llvm::ConstantStruct::getAnon(Fields);
3333 llvm::GlobalValue *GV) {
3334 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
3344 if (NoSanitizeL.containsFunction(Kind, Fn->getName()))
3349 if (NoSanitizeL.containsMainFile(Kind, MainFile.
getName()))
3354 return NoSanitizeL.containsLocation(Kind,
Loc);
3357 return NoSanitizeL.containsFile(Kind, MainFile.
getName());
3361 llvm::GlobalVariable *GV,
3365 if (NoSanitizeL.containsGlobal(Kind, GV->getName(),
Category))
3368 if (NoSanitizeL.containsMainFile(
3369 Kind,
SM.getFileEntryRefForID(
SM.getMainFileID())->getName(),
3372 if (NoSanitizeL.containsLocation(Kind,
Loc,
Category))
3379 while (
auto AT = dyn_cast<ArrayType>(Ty.
getTypePtr()))
3380 Ty = AT->getElementType();
3385 if (NoSanitizeL.containsType(Kind, TypeStr,
Category))
3396 auto Attr = ImbueAttr::NONE;
3399 if (
Attr == ImbueAttr::NONE)
3400 Attr = XRayFilter.shouldImbueFunction(Fn->getName());
3402 case ImbueAttr::NONE:
3404 case ImbueAttr::ALWAYS:
3405 Fn->addFnAttr(
"function-instrument",
"xray-always");
3407 case ImbueAttr::ALWAYS_ARG1:
3408 Fn->addFnAttr(
"function-instrument",
"xray-always");
3409 Fn->addFnAttr(
"xray-log-args",
"1");
3411 case ImbueAttr::NEVER:
3412 Fn->addFnAttr(
"function-instrument",
"xray-never");
3436 if (
auto MainFile =
SM.getFileEntryRefForID(
SM.getMainFileID()))
3450 if (NumGroups > 1) {
3451 auto Group = llvm::crc32(arrayRefFromStringRef(Fn->getName())) % NumGroups;
3460 if (LangOpts.EmitAllDecls)
3463 const auto *VD = dyn_cast<VarDecl>(
Global);
3465 ((CodeGenOpts.KeepPersistentStorageVariables &&
3466 (VD->getStorageDuration() ==
SD_Static ||
3467 VD->getStorageDuration() ==
SD_Thread)) ||
3468 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==
SD_Static &&
3469 VD->getType().isConstQualified())))
3482 if (LangOpts.OpenMP >= 50 && !LangOpts.OpenMPSimd) {
3483 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr =
3484 OMPDeclareTargetDeclAttr::getActiveAttr(
Global);
3485 if (!ActiveAttr || (*ActiveAttr)->getLevel() != (
unsigned)-1)
3489 if (
const auto *FD = dyn_cast<FunctionDecl>(
Global)) {
3498 if (
const auto *VD = dyn_cast<VarDecl>(
Global)) {
3504 if (CXX20ModuleInits && VD->getOwningModule() &&
3505 !VD->getOwningModule()->isModuleMapModule()) {
3514 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
3517 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(
Global))
3530 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3534 llvm::Constant *
Init;
3537 if (!
V.isAbsent()) {
3548 llvm::Constant *Fields[4] = {
3552 llvm::ConstantDataArray::getRaw(
3553 StringRef(
reinterpret_cast<char *
>(Parts.
Part4And5), 8), 8,
3555 Init = llvm::ConstantStruct::getAnon(Fields);
3558 auto *GV =
new llvm::GlobalVariable(
3560 true, llvm::GlobalValue::LinkOnceODRLinkage,
Init, Name);
3562 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3565 if (!
V.isAbsent()) {
3578 llvm::GlobalVariable **Entry =
nullptr;
3579 Entry = &UnnamedGlobalConstantDeclMap[GCD];
3584 llvm::Constant *
Init;
3588 assert(!
V.isAbsent());
3592 auto *GV =
new llvm::GlobalVariable(
getModule(),
Init->getType(),
3594 llvm::GlobalValue::PrivateLinkage,
Init,
3596 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3610 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3614 llvm::Constant *
Init =
Emitter.emitForInitializer(
3622 llvm::GlobalValue::LinkageTypes
Linkage =
3624 ? llvm::GlobalValue::LinkOnceODRLinkage
3625 : llvm::GlobalValue::InternalLinkage;
3626 auto *GV =
new llvm::GlobalVariable(
getModule(),
Init->getType(),
3630 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3637 const AliasAttr *AA = VD->
getAttr<AliasAttr>();
3638 assert(AA &&
"No alias?");
3648 llvm::Constant *Aliasee;
3649 if (isa<llvm::FunctionType>(DeclTy))
3650 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
3657 auto *F = cast<llvm::GlobalValue>(Aliasee);
3658 F->setLinkage(llvm::Function::ExternalWeakLinkage);
3659 WeakRefReferences.insert(F);
3667 if (
auto *A = D->
getAttr<AttrT>())
3668 return A->isImplicit();
3676 if (
Global->hasAttr<WeakRefAttr>())
3681 if (
Global->hasAttr<AliasAttr>())
3682 return EmitAliasDefinition(GD);
3685 if (
Global->hasAttr<IFuncAttr>())
3686 return emitIFuncDefinition(GD);
3689 if (
Global->hasAttr<CPUDispatchAttr>())
3690 return emitCPUDispatchDefinition(GD);
3695 if (LangOpts.CUDA) {
3696 if (LangOpts.CUDAIsDevice) {
3697 const auto *FD = dyn_cast<FunctionDecl>(
Global);
3698 if ((!
Global->hasAttr<CUDADeviceAttr>() ||
3699 (LangOpts.OffloadImplicitHostDeviceTemplates && FD &&
3700 hasImplicitAttr<CUDAHostAttr>(FD) &&
3701 hasImplicitAttr<CUDADeviceAttr>(FD) && !FD->
isConstexpr() &&
3703 !
getContext().CUDAImplicitHostDeviceFunUsedByDevice.count(FD))) &&
3704 !
Global->hasAttr<CUDAGlobalAttr>() &&
3705 !
Global->hasAttr<CUDAConstantAttr>() &&
3706 !
Global->hasAttr<CUDASharedAttr>() &&
3707 !
Global->getType()->isCUDADeviceBuiltinSurfaceType() &&
3708 !
Global->getType()->isCUDADeviceBuiltinTextureType() &&
3709 !(LangOpts.HIPStdPar && isa<FunctionDecl>(
Global) &&
3710 !
Global->hasAttr<CUDAHostAttr>()))
3719 if (isa<FunctionDecl>(
Global) && !
Global->hasAttr<CUDAHostAttr>() &&
3720 Global->hasAttr<CUDADeviceAttr>())
3723 assert((isa<FunctionDecl>(
Global) || isa<VarDecl>(
Global)) &&
3724 "Expected Variable or Function");
3728 if (LangOpts.OpenMP) {
3730 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
3732 if (
auto *DRD = dyn_cast<OMPDeclareReductionDecl>(
Global)) {
3733 if (MustBeEmitted(
Global))
3737 if (
auto *DMD = dyn_cast<OMPDeclareMapperDecl>(
Global)) {
3738 if (MustBeEmitted(
Global))
3745 if (
const auto *FD = dyn_cast<FunctionDecl>(
Global)) {
3748 if (FD->
hasAttr<AnnotateAttr>()) {
3751 DeferredAnnotations[MangledName] = FD;
3767 GetOrCreateLLVMFunction(MangledName, Ty, GD,
false,
3772 const auto *VD = cast<VarDecl>(
Global);
3773 assert(VD->isFileVarDecl() &&
"Cannot emit local var decl as global.");
3776 if (LangOpts.OpenMP) {
3778 if (std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
3779 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
3783 if (VD->hasExternalStorage() &&
3784 Res != OMPDeclareTargetDeclAttr::MT_Link)
3787 bool UnifiedMemoryEnabled =
3789 if ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3790 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3791 !UnifiedMemoryEnabled) {
3794 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
3795 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3796 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3797 UnifiedMemoryEnabled)) &&
3798 "Link clause or to clause with unified memory expected.");
3817 if (MustBeEmitted(
Global) && MayBeEmittedEagerly(
Global)) {
3819 EmitGlobalDefinition(GD);
3820 addEmittedDeferredDecl(GD);
3827 cast<VarDecl>(
Global)->hasInit()) {
3828 DelayedCXXInitPosition[
Global] = CXXGlobalInits.size();
3829 CXXGlobalInits.push_back(
nullptr);
3835 addDeferredDeclToEmit(GD);
3836 }
else if (MustBeEmitted(
Global)) {
3838 assert(!MayBeEmittedEagerly(
Global));
3839 addDeferredDeclToEmit(GD);
3844 DeferredDecls[MangledName] = GD;
3851 if (
CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
3852 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
3859 struct FunctionIsDirectlyRecursive
3861 const StringRef Name;
3866 bool VisitCallExpr(
const CallExpr *E) {
3871 if (
Attr && Name ==
Attr->getLabel())
3876 StringRef BuiltinName = BI.
getName(BuiltinID);
3877 if (BuiltinName.starts_with(
"__builtin_") &&
3878 Name == BuiltinName.slice(strlen(
"__builtin_"), StringRef::npos)) {
3884 bool VisitStmt(
const Stmt *S) {
3885 for (
const Stmt *Child : S->children())
3886 if (Child && this->Visit(Child))
3893 struct DLLImportFunctionVisitor
3895 bool SafeToInline =
true;
3897 bool shouldVisitImplicitCode()
const {
return true; }
3899 bool VisitVarDecl(
VarDecl *VD) {
3902 SafeToInline =
false;
3903 return SafeToInline;
3910 return SafeToInline;
3915 SafeToInline = D->
hasAttr<DLLImportAttr>();
3916 return SafeToInline;
3921 if (isa<FunctionDecl>(VD))
3922 SafeToInline = VD->
hasAttr<DLLImportAttr>();
3923 else if (
VarDecl *
V = dyn_cast<VarDecl>(VD))
3924 SafeToInline = !
V->hasGlobalStorage() ||
V->hasAttr<DLLImportAttr>();
3925 return SafeToInline;
3930 return SafeToInline;
3937 SafeToInline =
true;
3939 SafeToInline = M->
hasAttr<DLLImportAttr>();
3941 return SafeToInline;
3946 return SafeToInline;
3951 return SafeToInline;
3960CodeGenModule::isTriviallyRecursive(
const FunctionDecl *FD) {
3962 if (
getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
3967 Name =
Attr->getLabel();
3972 FunctionIsDirectlyRecursive Walker(Name, Context.
BuiltinInfo);
3974 return Body ? Walker.Visit(Body) :
false;
3977bool CodeGenModule::shouldEmitFunction(
GlobalDecl GD) {
3981 const auto *F = cast<FunctionDecl>(GD.
getDecl());
3982 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
3987 if (
const Module *M = F->getOwningModule();
3988 M && M->getTopLevelModule()->isNamedModule() &&
3989 getContext().getCurrentNamedModule() != M->getTopLevelModule()) {
3999 if (!F->isTemplateInstantiation() || !F->hasAttr<AlwaysInlineAttr>()) {
4004 if (F->hasAttr<NoInlineAttr>())
4007 if (F->hasAttr<DLLImportAttr>() && !F->hasAttr<AlwaysInlineAttr>()) {
4009 DLLImportFunctionVisitor Visitor;
4010 Visitor.TraverseFunctionDecl(
const_cast<FunctionDecl*
>(F));
4011 if (!Visitor.SafeToInline)
4017 for (
const Decl *
Member : Dtor->getParent()->decls())
4018 if (isa<FieldDecl>(
Member))
4029 if (F->isInlineBuiltinDeclaration())
4037 return !isTriviallyRecursive(F);
4040bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
4041 return CodeGenOpts.OptimizationLevel > 0;
4044void CodeGenModule::EmitMultiVersionFunctionDefinition(
GlobalDecl GD,
4045 llvm::GlobalValue *GV) {
4046 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4049 auto *Spec = FD->
getAttr<CPUSpecificAttr>();
4050 for (
unsigned I = 0; I < Spec->cpus_size(); ++I)
4052 }
else if (
auto *TC = FD->
getAttr<TargetClonesAttr>()) {
4053 for (
unsigned I = 0; I < TC->featuresStrs_size(); ++I)
4056 TC->isFirstOfVersion(I))
4059 GetOrCreateMultiVersionResolver(GD);
4061 EmitGlobalFunctionDefinition(GD, GV);
4066 AddDeferredMultiVersionResolverToEmit(GD);
4069void CodeGenModule::EmitGlobalDefinition(
GlobalDecl GD, llvm::GlobalValue *GV) {
4070 const auto *D = cast<ValueDecl>(GD.
getDecl());
4074 "Generating code for declaration");
4076 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
4079 if (!shouldEmitFunction(GD))
4082 llvm::TimeTraceScope TimeScope(
"CodeGen Function", [&]() {
4084 llvm::raw_string_ostream OS(Name);
4090 if (
const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
4093 if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
4094 ABI->emitCXXStructor(GD);
4096 EmitMultiVersionFunctionDefinition(GD, GV);
4098 EmitGlobalFunctionDefinition(GD, GV);
4100 if (Method->isVirtual())
4107 return EmitMultiVersionFunctionDefinition(GD, GV);
4108 return EmitGlobalFunctionDefinition(GD, GV);
4111 if (
const auto *VD = dyn_cast<VarDecl>(D))
4112 return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
4114 llvm_unreachable(
"Invalid argument to EmitGlobalDefinition()");
4118 llvm::Function *NewFn);
4122 const CodeGenFunction::MultiVersionResolverOption &RO) {
4124 unsigned NumFeatures = 0;
4125 for (StringRef Feat : RO.Conditions.Features) {
4130 if (!RO.Conditions.Architecture.empty())
4148 return llvm::GlobalValue::InternalLinkage;
4149 return llvm::GlobalValue::WeakODRLinkage;
4163 NewDecl->
addAttr(TargetVersionAttr::CreateImplicit(
4169void CodeGenModule::emitMultiVersionFunctions() {
4170 std::vector<GlobalDecl> MVFuncsToEmit;
4171 MultiVersionFuncs.swap(MVFuncsToEmit);
4173 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4174 assert(FD &&
"Expected a FunctionDecl");
4181 if (
Decl->isDefined()) {
4182 EmitGlobalFunctionDefinition(CurGD,
nullptr);
4190 assert(
Func &&
"This should have just been created");
4192 return cast<llvm::Function>(
Func);
4196 bool ShouldEmitResolver =
4204 if (
const auto *TA = CurFD->
getAttr<TargetAttr>()) {
4205 TA->getAddedFeatures(Feats);
4206 llvm::Function *Func = createFunction(CurFD);
4207 Options.emplace_back(Func, TA->getArchitecture(), Feats);
4208 }
else if (
const auto *TVA = CurFD->
getAttr<TargetVersionAttr>()) {
4209 bool HasDefaultDef = TVA->isDefaultVersion() &&
4210 CurFD->doesThisDeclarationHaveABody();
4211 HasDefaultDecl |= TVA->isDefaultVersion();
4212 ShouldEmitResolver |= (CurFD->isUsed() || HasDefaultDef);
4213 TVA->getFeatures(Feats);
4214 llvm::Function *Func = createFunction(CurFD);
4215 Options.emplace_back(Func,
"", Feats);
4216 }
else if (
const auto *TC = CurFD->
getAttr<TargetClonesAttr>()) {
4217 ShouldEmitResolver |= CurFD->doesThisDeclarationHaveABody();
4218 for (unsigned I = 0; I < TC->featuresStrs_size(); ++I) {
4219 if (!TC->isFirstOfVersion(I))
4222 llvm::Function *Func = createFunction(CurFD, I);
4223 StringRef Architecture;
4225 if (getTarget().getTriple().isAArch64())
4226 TC->getFeatures(Feats, I);
4228 StringRef Version = TC->getFeatureStr(I);
4229 if (Version.starts_with(
"arch="))
4230 Architecture = Version.drop_front(sizeof(
"arch=") - 1);
4231 else if (Version !=
"default")
4232 Feats.push_back(Version);
4234 Options.emplace_back(Func, Architecture, Feats);
4237 llvm_unreachable(
"unexpected MultiVersionKind");
4240 if (!ShouldEmitResolver)
4243 if (!HasDefaultDecl) {
4245 llvm::Function *
Func = createFunction(NewFD);
4247 Options.emplace_back(
Func,
"", Feats);
4250 llvm::Constant *ResolverConstant = GetOrCreateMultiVersionResolver(GD);
4251 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(ResolverConstant)) {
4252 ResolverConstant = IFunc->getResolver();
4256 *
this, GD, FD,
true);
4263 auto *Alias = llvm::GlobalAlias::create(
4265 MangledName +
".ifunc", IFunc, &
getModule());
4270 llvm::Function *ResolverFunc = cast<llvm::Function>(ResolverConstant);
4275 ResolverFunc->setComdat(
4276 getModule().getOrInsertComdat(ResolverFunc->getName()));
4280 Options, [&TI](
const CodeGenFunction::MultiVersionResolverOption &LHS,
4281 const CodeGenFunction::MultiVersionResolverOption &RHS) {
4285 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4291 if (!MVFuncsToEmit.empty())
4296 if (!MultiVersionFuncs.empty())
4297 emitMultiVersionFunctions();
4300void CodeGenModule::emitCPUDispatchDefinition(
GlobalDecl GD) {
4301 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4302 assert(FD &&
"Not a FunctionDecl?");
4304 const auto *DD = FD->
getAttr<CPUDispatchAttr>();
4305 assert(DD &&
"Not a cpu_dispatch Function?");
4311 UpdateMultiVersionNames(GD, FD, ResolverName);
4313 llvm::Type *ResolverType;
4316 ResolverType = llvm::FunctionType::get(
4317 llvm::PointerType::get(DeclTy,
4326 auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
4327 ResolverName, ResolverType, ResolverGD,
false));
4330 ResolverFunc->setComdat(
4331 getModule().getOrInsertComdat(ResolverFunc->getName()));
4344 GlobalDecl ExistingDecl = Manglings.lookup(MangledName);
4347 EmitGlobalFunctionDefinition(ExistingDecl,
nullptr);
4353 Func = GetOrCreateLLVMFunction(
4354 MangledName, DeclTy, ExistingDecl,
4361 Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);
4362 llvm::transform(Features, Features.begin(),
4363 [](StringRef Str) { return Str.substr(1); });
4364 llvm::erase_if(Features, [&
Target](StringRef Feat) {
4365 return !
Target.validateCpuSupports(Feat);
4367 Options.emplace_back(cast<llvm::Function>(
Func), StringRef{}, Features);
4372 Options, [](
const CodeGenFunction::MultiVersionResolverOption &LHS,
4373 const CodeGenFunction::MultiVersionResolverOption &RHS) {
4374 return llvm::X86::getCpuSupportsMask(LHS.Conditions.Features) >
4375 llvm::X86::getCpuSupportsMask(RHS.Conditions.Features);
4382 while (Options.size() > 1 &&
4383 llvm::all_of(llvm::X86::getCpuSupportsMask(
4384 (Options.end() - 2)->Conditions.Features),
4385 [](
auto X) { return X == 0; })) {
4386 StringRef LHSName = (Options.end() - 2)->
Function->getName();
4387 StringRef RHSName = (Options.end() - 1)->
Function->getName();
4388 if (LHSName.compare(RHSName) < 0)
4389 Options.erase(Options.end() - 2);
4391 Options.erase(Options.end() - 1);
4395 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4399 auto *IFunc = cast<llvm::GlobalValue>(GetOrCreateMultiVersionResolver(GD));
4403 if (!isa<llvm::GlobalIFunc>(IFunc)) {
4404 assert(cast<llvm::Function>(IFunc)->isDeclaration());
4405 auto *GI = llvm::GlobalIFunc::create(DeclTy, 0,
Linkage,
"", ResolverFunc,
4407 GI->takeName(IFunc);
4408 IFunc->replaceAllUsesWith(GI);
4409 IFunc->eraseFromParent();
4414 *
this, GD, FD,
true);
4417 auto *GA = llvm::GlobalAlias::create(DeclTy, 0,
Linkage, AliasName, IFunc,
4425void CodeGenModule::AddDeferredMultiVersionResolverToEmit(
GlobalDecl GD) {
4426 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4427 assert(FD &&
"Not a FunctionDecl?");
4430 std::string MangledName =
4432 if (!DeferredResolversToEmit.insert(MangledName).second)
4435 MultiVersionFuncs.push_back(GD);
4440llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(
GlobalDecl GD) {
4441 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4442 assert(FD &&
"Not a FunctionDecl?");
4444 std::string MangledName =
4449 std::string ResolverName = MangledName;
4453 llvm_unreachable(
"unexpected MultiVersionKind::None for resolver");
4457 ResolverName +=
".ifunc";
4464 ResolverName +=
".resolver";
4468 if (llvm::GlobalValue *ResolverGV =
GetGlobalValue(ResolverName))
4477 AddDeferredMultiVersionResolverToEmit(GD);
4482 llvm::Type *ResolverType = llvm::FunctionType::get(
4483 llvm::PointerType::get(DeclTy,
4486 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4487 MangledName +
".resolver", ResolverType,
GlobalDecl{},
4489 llvm::GlobalIFunc *GIF =
4492 GIF->setName(ResolverName);
4498 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4500 assert(isa<llvm::GlobalValue>(Resolver) &&
4501 "Resolver should be created for the first time");
4513llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
4514 StringRef MangledName, llvm::Type *Ty,
GlobalDecl GD,
bool ForVTable,
4515 bool DontDefer,
bool IsThunk, llvm::AttributeList ExtraAttrs,
4521 if (
const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
4523 if (
getLangOpts().OpenMPIsTargetDevice && OpenMPRuntime &&
4524 !OpenMPRuntime->markAsGlobalTarget(GD) && FD->
isDefined() &&
4525 !DontDefer && !IsForDefinition) {
4528 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
4530 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
4539 UpdateMultiVersionNames(GD, FD, MangledName);
4542 AddDeferredMultiVersionResolverToEmit(GD);
4543 else if (!IsForDefinition)
4544 return GetOrCreateMultiVersionResolver(GD);
4551 if (WeakRefReferences.erase(Entry)) {
4552 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
4553 if (FD && !FD->
hasAttr<WeakAttr>())
4554 Entry->setLinkage(llvm::Function::ExternalLinkage);
4558 if (D && !D->
hasAttr<DLLImportAttr>() && !D->
hasAttr<DLLExportAttr>() &&
4560 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4566 if (IsForDefinition && !Entry->isDeclaration()) {
4573 DiagnosedConflictingDefinitions.insert(GD).second) {
4577 diag::note_previous_definition);
4581 if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
4582 (Entry->getValueType() == Ty)) {
4589 if (!IsForDefinition)
4596 bool IsIncompleteFunction =
false;
4598 llvm::FunctionType *FTy;
4599 if (isa<llvm::FunctionType>(Ty)) {
4600 FTy = cast<llvm::FunctionType>(Ty);
4602 FTy = llvm::FunctionType::get(
VoidTy,
false);
4603 IsIncompleteFunction =
true;
4607 llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
4608 Entry ? StringRef() : MangledName, &
getModule());
4612 if (D && D->
hasAttr<AnnotateAttr>())
4613 DeferredAnnotations[MangledName] = cast<ValueDecl>(D);
4630 if (!Entry->use_empty()) {
4632 Entry->removeDeadConstantUsers();
4638 assert(F->getName() == MangledName &&
"name was uniqued!");
4640 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
4641 if (ExtraAttrs.hasFnAttrs()) {
4642 llvm::AttrBuilder B(F->getContext(), ExtraAttrs.getFnAttrs());
4650 if (isa_and_nonnull<CXXDestructorDecl>(D) &&
4651 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
4653 addDeferredDeclToEmit(GD);
4658 auto DDI = DeferredDecls.find(MangledName);
4659 if (DDI != DeferredDecls.end()) {
4663 addDeferredDeclToEmit(DDI->second);
4664 DeferredDecls.erase(DDI);
4679 for (
const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
4692 if (!IsIncompleteFunction) {
4693 assert(F->getFunctionType() == Ty);
4709 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4716 if (
const auto *DD = dyn_cast<CXXDestructorDecl>(GD.
getDecl())) {
4719 DD->getParent()->getNumVBases() == 0)
4724 auto *F = GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
4725 false, llvm::AttributeList(),
4728 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
4729 cast<FunctionDecl>(GD.
getDecl())->hasAttr<CUDAGlobalAttr>()) {
4731 cast<llvm::Function>(F->stripPointerCasts()), GD);
4732 if (IsForDefinition)
4740 llvm::GlobalValue *F =
4743 return llvm::NoCFIValue::get(F);
4753 if (
const auto *FD = dyn_cast<FunctionDecl>(
Result))
4756 if (!
C.getLangOpts().CPlusPlus)
4761 (Name ==
"_ZSt9terminatev" || Name ==
"?terminate@@YAXXZ")
4762 ?
C.Idents.get(
"terminate")
4763 :
C.Idents.get(Name);
4765 for (
const auto &N : {
"__cxxabiv1",
"std"}) {
4769 if (
auto *LSD = dyn_cast<LinkageSpecDecl>(
Result))
4770 for (
const auto *
Result : LSD->lookup(&NS))
4771 if ((ND = dyn_cast<NamespaceDecl>(
Result)))
4776 if (
const auto *FD = dyn_cast<FunctionDecl>(
Result))
4788 llvm::AttributeList ExtraAttrs,
bool Local,
4789 bool AssumeConvergent) {
4790 if (AssumeConvergent) {
4792 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
4796 GetOrCreateLLVMFunction(Name, FTy,
GlobalDecl(),
false,
4800 if (
auto *F = dyn_cast<llvm::Function>(
C)) {
4809 if (!Local &&
getTriple().isWindowsItaniumEnvironment() &&
4812 if (!FD || FD->
hasAttr<DLLImportAttr>()) {
4813 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
4814 F->setLinkage(llvm::GlobalValue::ExternalLinkage);
4821 markRegisterParameterAttributes(F);
4847 if (WeakRefReferences.erase(Entry)) {
4848 if (D && !D->
hasAttr<WeakAttr>())
4849 Entry->setLinkage(llvm::Function::ExternalLinkage);
4853 if (D && !D->
hasAttr<DLLImportAttr>() && !D->
hasAttr<DLLExportAttr>() &&
4855 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4857 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd && D)
4860 if (Entry->getValueType() == Ty && Entry->getAddressSpace() == TargetAS)
4865 if (IsForDefinition && !Entry->isDeclaration()) {
4873 (OtherD = dyn_cast<VarDecl>(OtherGD.
getDecl())) &&
4875 DiagnosedConflictingDefinitions.insert(D).second) {
4879 diag::note_previous_definition);
4884 if (Entry->getType()->getAddressSpace() != TargetAS)
4885 return llvm::ConstantExpr::getAddrSpaceCast(
4886 Entry, llvm::PointerType::get(Ty->getContext(), TargetAS));
4890 if (!IsForDefinition)
4896 auto *GV =
new llvm::GlobalVariable(
4897 getModule(), Ty,
false, llvm::GlobalValue::ExternalLinkage,
nullptr,
4898 MangledName,
nullptr, llvm::GlobalVariable::NotThreadLocal,
4899 getContext().getTargetAddressSpace(DAddrSpace));
4904 GV->takeName(Entry);
4906 if (!Entry->use_empty()) {
4907 Entry->replaceAllUsesWith(GV);
4910 Entry->eraseFromParent();
4916 auto DDI = DeferredDecls.find(MangledName);
4917 if (DDI != DeferredDecls.end()) {
4920 addDeferredDeclToEmit(DDI->second);
4921 DeferredDecls.erase(DDI);
4926 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
4933 GV->setAlignment(
getContext().getDeclAlign(D).getAsAlign());
4939 CXXThreadLocals.push_back(D);
4947 if (
getContext().isMSStaticDataMemberInlineDefinition(D)) {
4948 EmitGlobalVarDefinition(D);
4953 if (
const SectionAttr *SA = D->
getAttr<SectionAttr>())
4954 GV->setSection(SA->getName());
4958 if (
getTriple().getArch() == llvm::Triple::xcore &&
4962 GV->setSection(
".cp.rodata");
4965 if (
const auto *CMA = D->
getAttr<CodeModelAttr>())
4966 GV->setCodeModel(CMA->getModel());
4971 if (Context.
getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
4977 if (!HasMutableFields) {
4984 auto *InitType =
Init->getType();
4985 if (GV->getValueType() != InitType) {
4990 GV->setName(StringRef());
4993 auto *NewGV = cast<llvm::GlobalVariable>(
4995 ->stripPointerCasts());
4998 GV->eraseFromParent();
5001 GV->setInitializer(
Init);
5002 GV->setConstant(
true);
5003 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
5023 SanitizerMD->reportGlobal(GV, *D);
5028 assert(
getContext().getTargetAddressSpace(ExpectedAS) == TargetAS);
5029 if (DAddrSpace != ExpectedAS) {
5031 *
this, GV, DAddrSpace, ExpectedAS,
5042 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
5044 false, IsForDefinition);
5046 if (isa<CXXMethodDecl>(D)) {
5054 if (isa<FunctionDecl>(D)) {
5065 StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes
Linkage,
5066 llvm::Align Alignment) {
5067 llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name);
5068 llvm::GlobalVariable *OldGV =
nullptr;
5072 if (GV->getValueType() == Ty)
5077 assert(GV->isDeclaration() &&
"Declaration has wrong type!");
5082 GV =
new llvm::GlobalVariable(
getModule(), Ty,
true,
5087 GV->takeName(OldGV);
5089 if (!OldGV->use_empty()) {
5090 OldGV->replaceAllUsesWith(GV);
5093 OldGV->eraseFromParent();
5097 !GV->hasAvailableExternallyLinkage())
5098 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
5100 GV->setAlignment(Alignment);
5132 setDSOLocal(cast<llvm::GlobalValue>(Ret->stripPointerCasts()));
5137 assert(!D->
getInit() &&
"Cannot emit definite definitions here!");
5145 if (GV && !GV->isDeclaration())
5150 if (!MustBeEmitted(D) && !GV) {
5151 DeferredDecls[MangledName] = D;
5156 EmitGlobalVarDefinition(D);
5160 EmitExternalVarDeclaration(D);
5169 if (LangOpts.OpenCL) {
5180 if (LangOpts.SYCLIsDevice &&
5184 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
5186 if (D->
hasAttr<CUDAConstantAttr>())
5188 if (D->
hasAttr<CUDASharedAttr>())
5190 if (D->
hasAttr<CUDADeviceAttr>())
5198 if (LangOpts.OpenMP) {
5200 if (OpenMPRuntime->hasAllocateAttributeForGlobalVar(D, AS))
5208 if (LangOpts.OpenCL)
5210 if (LangOpts.SYCLIsDevice)
5212 if (LangOpts.HIP && LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())
5220 if (
auto AS =
getTarget().getConstantAddressSpace())
5233static llvm::Constant *
5235 llvm::GlobalVariable *GV) {
5236 llvm::Constant *Cast = GV;
5242 llvm::PointerType::get(
5249template<
typename SomeDecl>
5251 llvm::GlobalValue *GV) {
5257 if (!D->template hasAttr<UsedAttr>())
5266 const SomeDecl *
First = D->getFirstDecl();
5267 if (
First->getDeclContext()->isRecord() || !
First->isInExternCContext())
5273 std::pair<StaticExternCMap::iterator, bool> R =
5274 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
5279 R.first->second =
nullptr;
5286 if (D.
hasAttr<SelectAnyAttr>())
5290 if (
auto *VD = dyn_cast<VarDecl>(&D))
5304 llvm_unreachable(
"No such linkage");
5312 llvm::GlobalObject &GO) {
5315 GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
5319void CodeGenModule::EmitGlobalVarDefinition(
const VarDecl *D,
5329 if (LangOpts.OpenMPIsTargetDevice && OpenMPRuntime &&
5330 OpenMPRuntime->emitTargetGlobalVariable(D))
5333 llvm::TrackingVH<llvm::Constant>
Init;
5334 bool NeedsGlobalCtor =
false;
5338 bool IsDefinitionAvailableExternally =
5340 bool NeedsGlobalDtor =
5341 !IsDefinitionAvailableExternally &&
5347 std::optional<ConstantEmitter> emitter;
5352 bool IsCUDASharedVar =
5357 bool IsCUDAShadowVar =
5359 (D->
hasAttr<CUDAConstantAttr>() || D->
hasAttr<CUDADeviceAttr>() ||
5360 D->
hasAttr<CUDASharedAttr>());
5361 bool IsCUDADeviceShadowVar =
5366 (IsCUDASharedVar || IsCUDAShadowVar || IsCUDADeviceShadowVar))
5367 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
5368 else if (D->
hasAttr<LoaderUninitializedAttr>())
5369 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
5370 else if (!InitExpr) {
5384 emitter.emplace(*
this);
5385 llvm::Constant *
Initializer = emitter->tryEmitForInitializer(*InitDecl);
5396 if (!IsDefinitionAvailableExternally)
5397 NeedsGlobalCtor =
true;
5408 DelayedCXXInitPosition.erase(D);
5415 assert(VarSize == CstSize &&
"Emitted constant has unexpected size");
5420 llvm::Type* InitType =
Init->getType();
5421 llvm::Constant *Entry =
5425 Entry = Entry->stripPointerCasts();
5428 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
5439 if (!GV || GV->getValueType() != InitType ||
5440 GV->getType()->getAddressSpace() !=
5444 Entry->setName(StringRef());
5447 GV = cast<llvm::GlobalVariable>(
5449 ->stripPointerCasts());
5452 llvm::Constant *NewPtrForOldDecl =
5453 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV,
5455 Entry->replaceAllUsesWith(NewPtrForOldDecl);
5458 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
5463 if (D->
hasAttr<AnnotateAttr>())
5476 if (LangOpts.CUDA) {
5477 if (LangOpts.CUDAIsDevice) {
5478 if (
Linkage != llvm::GlobalValue::InternalLinkage &&
5479 (D->
hasAttr<CUDADeviceAttr>() || D->
hasAttr<CUDAConstantAttr>() ||
5482 GV->setExternallyInitialized(
true);
5489 GV->setInitializer(
Init);
5491 emitter->finalize(GV);
5494 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
5498 if (
const SectionAttr *SA = D->
getAttr<SectionAttr>()) {
5501 GV->setConstant(
true);
5506 if (std::optional<CharUnits> AlignValFromAllocate =
5508 AlignVal = *AlignValFromAllocate;
5526 Linkage == llvm::GlobalValue::ExternalLinkage &&
5529 Linkage = llvm::GlobalValue::InternalLinkage;
5532 if (D->
hasAttr<DLLImportAttr>())
5533 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
5534 else if (D->
hasAttr<DLLExportAttr>())
5535 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
5537 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
5539 if (
Linkage == llvm::GlobalVariable::CommonLinkage) {
5541 GV->setConstant(
false);
5546 if (!GV->getInitializer()->isNullValue())
5547 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
5550 setNonAliasAttributes(D, GV);
5552 if (D->
getTLSKind() && !GV->isThreadLocal()) {
5554 CXXThreadLocals.push_back(D);
5561 if (NeedsGlobalCtor || NeedsGlobalDtor)
5562 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
5564 SanitizerMD->reportGlobal(GV, *D, NeedsGlobalCtor);
5569 DI->EmitGlobalVariable(GV, D);
5572void CodeGenModule::EmitExternalVarDeclaration(
const VarDecl *D) {
5577 llvm::Constant *GV =
5579 DI->EmitExternalVariable(
5580 cast<llvm::GlobalVariable>(GV->stripPointerCasts()), D);
5589 if ((NoCommon || D->
hasAttr<NoCommonAttr>()) && !D->
hasAttr<CommonAttr>())
5600 if (D->
hasAttr<SectionAttr>())
5606 if (D->
hasAttr<PragmaClangBSSSectionAttr>() ||
5607 D->
hasAttr<PragmaClangDataSectionAttr>() ||
5608 D->
hasAttr<PragmaClangRelroSectionAttr>() ||
5609 D->
hasAttr<PragmaClangRodataSectionAttr>())
5617 if (D->
hasAttr<WeakImportAttr>())
5627 if (D->
hasAttr<AlignedAttr>())
5636 if (FD->isBitField())
5638 if (FD->
hasAttr<AlignedAttr>())
5660llvm::GlobalValue::LinkageTypes
5664 return llvm::Function::InternalLinkage;
5667 return llvm::GlobalVariable::WeakAnyLinkage;
5671 return llvm::GlobalVariable::LinkOnceAnyLinkage;
5676 return llvm::GlobalValue::AvailableExternallyLinkage;
5690 return !Context.
getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
5691 : llvm::Function::InternalLinkage;
5705 return llvm::Function::ExternalLinkage;
5708 return D->
hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
5709 : llvm::Function::InternalLinkage;
5710 return llvm::Function::WeakODRLinkage;
5715 if (!
getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
5717 CodeGenOpts.NoCommon))
5718 return llvm::GlobalVariable::CommonLinkage;
5724 if (D->
hasAttr<SelectAnyAttr>())
5725 return llvm::GlobalVariable::WeakODRLinkage;
5729 return llvm::GlobalVariable::ExternalLinkage;
5732llvm::GlobalValue::LinkageTypes
5741 llvm::Function *newFn) {
5743 if (old->use_empty())
return;
5745 llvm::Type *newRetTy = newFn->getReturnType();
5748 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
5750 llvm::Value::use_iterator use = ui++;
5751 llvm::User *user = use->getUser();
5755 if (
auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
5756 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
5762 llvm::CallBase *callSite = dyn_cast<llvm::CallBase>(user);
5763 if (!callSite)
continue;
5764 if (!callSite->isCallee(&*use))
5769 if (callSite->getType() != newRetTy && !callSite->use_empty())
5774 llvm::AttributeList oldAttrs = callSite->getAttributes();
5777 unsigned newNumArgs = newFn->arg_size();
5778 if (callSite->arg_size() < newNumArgs)
5784 bool dontTransform =
false;
5785 for (llvm::Argument &A : newFn->args()) {
5786 if (callSite->getArgOperand(argNo)->getType() != A.getType()) {
5787 dontTransform =
true;
5792 newArgAttrs.push_back(oldAttrs.getParamAttrs(argNo));
5800 newArgs.append(callSite->arg_begin(), callSite->arg_begin() + argNo);
5804 callSite->getOperandBundlesAsDefs(newBundles);
5806 llvm::CallBase *newCall;
5807 if (isa<llvm::CallInst>(callSite)) {
5809 llvm::CallInst::Create(newFn, newArgs, newBundles,
"", callSite);
5811 auto *oldInvoke = cast<llvm::InvokeInst>(callSite);
5812 newCall = llvm::InvokeInst::Create(newFn, oldInvoke->getNormalDest(),
5813 oldInvoke->getUnwindDest(), newArgs,
5814 newBundles,
"", callSite);
5818 if (!newCall->getType()->isVoidTy())
5819 newCall->takeName(callSite);
5820 newCall->setAttributes(
5821 llvm::AttributeList::get(newFn->getContext(), oldAttrs.getFnAttrs(),
5822 oldAttrs.getRetAttrs(), newArgAttrs));
5823 newCall->setCallingConv(callSite->getCallingConv());
5826 if (!callSite->use_empty())
5827 callSite->replaceAllUsesWith(newCall);
5830 if (callSite->getDebugLoc())
5831 newCall->setDebugLoc(callSite->getDebugLoc());
5833 callSite->eraseFromParent();
5847 llvm::Function *NewFn) {
5849 if (!isa<llvm::Function>(Old))
return;
5868void CodeGenModule::EmitGlobalFunctionDefinition(
GlobalDecl GD,
5869 llvm::GlobalValue *GV) {
5870 const auto *D = cast<FunctionDecl>(GD.
getDecl());
5877 if (!GV || (GV->getValueType() != Ty))
5883 if (!GV->isDeclaration())
5890 auto *Fn = cast<llvm::Function>(GV);
5902 setNonAliasAttributes(GD, Fn);
5905 if (
const ConstructorAttr *CA = D->
getAttr<ConstructorAttr>())
5907 if (
const DestructorAttr *DA = D->
getAttr<DestructorAttr>())
5913void CodeGenModule::EmitAliasDefinition(
GlobalDecl GD) {
5914 const auto *D = cast<ValueDecl>(GD.
getDecl());
5915 const AliasAttr *AA = D->
getAttr<AliasAttr>();
5916 assert(AA &&
"Not an alias?");
5920 if (AA->getAliasee() == MangledName) {
5921 Diags.
Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
5928 if (Entry && !Entry->isDeclaration())
5931 Aliases.push_back(GD);
5937 llvm::Constant *Aliasee;
5938 llvm::GlobalValue::LinkageTypes
LT;
5939 if (isa<llvm::FunctionType>(DeclTy)) {
5940 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
5946 if (
const auto *VD = dyn_cast<VarDecl>(GD.
getDecl()))
5953 unsigned AS = Aliasee->getType()->getPointerAddressSpace();
5955 llvm::GlobalAlias::create(DeclTy, AS,
LT,
"", Aliasee, &
getModule());
5958 if (GA->getAliasee() == Entry) {
5959 Diags.
Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
5963 assert(Entry->isDeclaration());
5972 GA->takeName(Entry);
5974 Entry->replaceAllUsesWith(GA);
5975 Entry->eraseFromParent();
5977 GA->setName(MangledName);
5985 GA->setLinkage(llvm::Function::WeakAnyLinkage);
5988 if (
const auto *VD = dyn_cast<VarDecl>(D))
5989 if (VD->getTLSKind())
5995 if (isa<VarDecl>(D))
5997 DI->EmitGlobalAlias(cast<llvm::GlobalValue>(GA->getAliasee()->stripPointerCasts()), GD);
6000void CodeGenModule::emitIFuncDefinition(
GlobalDecl GD) {
6001 const auto *D = cast<ValueDecl>(GD.
getDecl());
6002 const IFuncAttr *IFA = D->
getAttr<IFuncAttr>();
6003 assert(IFA &&
"Not an ifunc?");
6007 if (IFA->getResolver() == MangledName) {
6008 Diags.
Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
6014 if (Entry && !Entry->isDeclaration()) {
6017 DiagnosedConflictingDefinitions.insert(GD).second) {
6021 diag::note_previous_definition);
6026 Aliases.push_back(GD);
6029 llvm::Type *ResolverTy = llvm::GlobalIFunc::getResolverFunctionType(DeclTy);
6030 llvm::Constant *Resolver =
6031 GetOrCreateLLVMFunction(IFA->getResolver(), ResolverTy, {},
6033 llvm::GlobalIFunc *GIF =
6034 llvm::GlobalIFunc::create(DeclTy, 0, llvm::Function::ExternalLinkage,
6037 if (GIF->getResolver() == Entry) {
6038 Diags.
Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
6041 assert(Entry->isDeclaration());
6050 GIF->takeName(Entry);
6052 Entry->replaceAllUsesWith(GIF);
6053 Entry->eraseFromParent();
6055 GIF->setName(MangledName);
6056 if (
auto *F = dyn_cast<llvm::Function>(Resolver)) {
6057 F->addFnAttr(llvm::Attribute::DisableSanitizerInstrumentation);
6064 return llvm::Intrinsic::getDeclaration(&
getModule(), (llvm::Intrinsic::ID)IID,
6068static llvm::StringMapEntry<llvm::GlobalVariable *> &
6071 bool &IsUTF16,
unsigned &StringLength) {
6072 StringRef String = Literal->getString();
6073 unsigned NumBytes = String.size();
6076 if (!Literal->containsNonAsciiOrNull()) {
6077 StringLength = NumBytes;
6078 return *Map.insert(std::make_pair(String,
nullptr)).first;
6085 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
6086 llvm::UTF16 *ToPtr = &ToBuf[0];
6088 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
6089 ToPtr + NumBytes, llvm::strictConversion);
6092 StringLength = ToPtr - &ToBuf[0];
6096 return *Map.insert(std::make_pair(
6097 StringRef(
reinterpret_cast<const char *
>(ToBuf.data()),
6098 (StringLength + 1) * 2),
6104 unsigned StringLength = 0;
6105 bool isUTF16 =
false;
6106 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
6111 if (
auto *
C = Entry.second)
6115 llvm::Constant *Zero = llvm::Constant::getNullValue(
Int32Ty);
6116 llvm::Constant *Zeros[] = { Zero, Zero };
6119 const llvm::Triple &Triple =
getTriple();
6122 const bool IsSwiftABI =
6123 static_cast<unsigned>(CFRuntime) >=
6128 if (!CFConstantStringClassRef) {
6129 const char *CFConstantStringClassName =
"__CFConstantStringClassReference";
6131 Ty = llvm::ArrayType::get(Ty, 0);
6133 switch (CFRuntime) {
6137 CFConstantStringClassName =
6138 Triple.isOSDarwin() ?
"$s15SwiftFoundation19_NSCFConstantStringCN"
6139 :
"$s10Foundation19_NSCFConstantStringCN";
6143 CFConstantStringClassName =
6144 Triple.isOSDarwin() ?
"$S15SwiftFoundation19_NSCFConstantStringCN"
6145 :
"$S10Foundation19_NSCFConstantStringCN";
6149 CFConstantStringClassName =
6150 Triple.isOSDarwin() ?
"__T015SwiftFoundation19_NSCFConstantStringCN"
6151 :
"__T010Foundation19_NSCFConstantStringCN";
6158 if (Triple.isOSBinFormatELF() || Triple.isOSBinFormatCOFF()) {
6159 llvm::GlobalValue *GV =
nullptr;
6161 if ((GV = dyn_cast<llvm::GlobalValue>(
C))) {
6168 if ((VD = dyn_cast<VarDecl>(
Result)))
6171 if (Triple.isOSBinFormatELF()) {
6173 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6175 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6176 if (!VD || !VD->
hasAttr<DLLExportAttr>())
6177 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6179 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6187 CFConstantStringClassRef =
6188 IsSwiftABI ? llvm::ConstantExpr::getPtrToInt(
C, Ty)
6189 : llvm::ConstantExpr::getGetElementPtr(Ty,
C, Zeros);
6194 auto *STy = cast<llvm::StructType>(
getTypes().ConvertType(CFTy));
6197 auto Fields = Builder.beginStruct(STy);
6200 Fields.add(cast<llvm::Constant>(CFConstantStringClassRef));
6204 Fields.addInt(
IntPtrTy, IsSwift4_1 ? 0x05 : 0x01);
6205 Fields.addInt(
Int64Ty, isUTF16 ? 0x07d0 : 0x07c8);
6207 Fields.addInt(
IntTy, isUTF16 ? 0x07d0 : 0x07C8);
6211 llvm::Constant *
C =
nullptr;
6214 reinterpret_cast<uint16_t *
>(
const_cast<char *
>(Entry.first().data())),
6215 Entry.first().size() / 2);
6216 C = llvm::ConstantDataArray::get(VMContext, Arr);
6218 C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
6224 new llvm::GlobalVariable(
getModule(),
C->getType(),
true,
6225 llvm::GlobalValue::PrivateLinkage,
C,
".str");
6226 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6236 if (Triple.isOSBinFormatMachO())
6237 GV->setSection(isUTF16 ?
"__TEXT,__ustring"
6238 :
"__TEXT,__cstring,cstring_literals");
6241 else if (Triple.isOSBinFormatELF())
6242 GV->setSection(
".rodata");
6245 llvm::Constant *Str =
6246 llvm::ConstantExpr::getGetElementPtr(GV->getValueType(), GV, Zeros);
6251 llvm::IntegerType *LengthTy =
6261 Fields.addInt(LengthTy, StringLength);
6269 GV = Fields.finishAndCreateGlobal(
"_unnamed_cfstring_", Alignment,
6271 llvm::GlobalVariable::PrivateLinkage);
6272 GV->addAttribute(
"objc_arc_inert");
6273 switch (Triple.getObjectFormat()) {
6274 case llvm::Triple::UnknownObjectFormat:
6275 llvm_unreachable(
"unknown file format");
6276 case llvm::Triple::DXContainer:
6277 case llvm::Triple::GOFF:
6278 case llvm::Triple::SPIRV:
6279 case llvm::Triple::XCOFF:
6280 llvm_unreachable(
"unimplemented");
6281 case llvm::Triple::COFF:
6282 case llvm::Triple::ELF:
6283 case llvm::Triple::Wasm:
6284 GV->setSection(
"cfstring");
6286 case llvm::Triple::MachO:
6287 GV->setSection(
"__DATA,__cfstring");
6296 return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
6300 if (ObjCFastEnumerationStateType.
isNull()) {
6310 for (
size_t i = 0; i < 4; ++i) {
6315 FieldTypes[i],
nullptr,
6327 return ObjCFastEnumerationStateType;
6341 assert(CAT &&
"String literal not of constant array type!");
6343 return llvm::ConstantDataArray::getString(VMContext, Str,
false);
6346 auto *AType = cast<llvm::ArrayType>(
getTypes().ConvertType(E->
getType()));
6347 llvm::Type *ElemTy = AType->getElementType();
6348 unsigned NumElements = AType->getNumElements();
6351 if (ElemTy->getPrimitiveSizeInBits() == 16) {
6353 Elements.reserve(NumElements);
6355 for(
unsigned i = 0, e = E->
getLength(); i != e; ++i)
6357 Elements.resize(NumElements);
6358 return llvm::ConstantDataArray::get(VMContext, Elements);
6361 assert(ElemTy->getPrimitiveSizeInBits() == 32);
6363 Elements.reserve(NumElements);
6365 for(
unsigned i = 0, e = E->
getLength(); i != e; ++i)
6367 Elements.resize(NumElements);
6368 return llvm::ConstantDataArray::get(VMContext, Elements);
6371static llvm::GlobalVariable *
6380 auto *GV =
new llvm::GlobalVariable(
6381 M,
C->getType(), !CGM.
getLangOpts().WritableStrings,
LT,
C, GlobalName,
6382 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
6384 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6385 if (GV->isWeakForLinker()) {
6386 assert(CGM.
supportsCOMDAT() &&
"Only COFF uses weak string literals");
6387 GV->setComdat(M.getOrInsertComdat(GV->getName()));
6403 llvm::GlobalVariable **Entry =
nullptr;
6404 if (!LangOpts.WritableStrings) {
6405 Entry = &ConstantStringMap[
C];
6406 if (
auto GV = *Entry) {
6407 if (uint64_t(Alignment.
getQuantity()) > GV->getAlignment())
6410 GV->getValueType(), Alignment);
6415 StringRef GlobalVariableName;
6416 llvm::GlobalValue::LinkageTypes
LT;
6421 if (
getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
6422 !LangOpts.WritableStrings) {
6423 llvm::raw_svector_ostream Out(MangledNameBuffer);
6425 LT = llvm::GlobalValue::LinkOnceODRLinkage;
6426 GlobalVariableName = MangledNameBuffer;
6428 LT = llvm::GlobalValue::PrivateLinkage;
6429 GlobalVariableName = Name;
6441 SanitizerMD->reportGlobal(GV, S->getStrTokenLoc(0),
"<string literal>");
6444 GV->getValueType(), Alignment);
6461 const std::string &Str,
const char *GlobalName) {
6462 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
6467 llvm::ConstantDataArray::getString(
getLLVMContext(), StrWithNull,
false);
6470 llvm::GlobalVariable **Entry =
nullptr;
6471 if (!LangOpts.WritableStrings) {
6472 Entry = &ConstantStringMap[
C];
6473 if (
auto GV = *Entry) {
6474 if (uint64_t(Alignment.
getQuantity()) > GV->getAlignment())
6477 GV->getValueType(), Alignment);
6483 GlobalName =
".str";
6486 GlobalName, Alignment);
6491 GV->getValueType(), Alignment);
6504 MaterializedType = E->
getType();
6508 auto InsertResult = MaterializedGlobalTemporaryMap.insert({E,
nullptr});
6509 if (!InsertResult.second) {
6512 if (!InsertResult.first->second) {
6517 InsertResult.first->second =
new llvm::GlobalVariable(
6518 getModule(),
Type,
false, llvm::GlobalVariable::InternalLinkage,
6522 llvm::cast<llvm::GlobalVariable>(
6523 InsertResult.first->second->stripPointerCasts())
6532 llvm::raw_svector_ostream Out(Name);
6554 std::optional<ConstantEmitter> emitter;
6555 llvm::Constant *InitialValue =
nullptr;
6556 bool Constant =
false;
6560 emitter.emplace(*
this);
6561 InitialValue = emitter->emitForInitializer(*
Value, AddrSpace,
6566 Type = InitialValue->getType();
6575 if (
Linkage == llvm::GlobalVariable::ExternalLinkage) {
6577 if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
6581 Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
6585 Linkage = llvm::GlobalVariable::InternalLinkage;
6589 auto *GV =
new llvm::GlobalVariable(
6591 nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
6592 if (emitter) emitter->finalize(GV);
6594 if (!llvm::GlobalValue::isLocalLinkage(
Linkage)) {
6596 if (GV->getDLLStorageClass() == llvm::GlobalVariable::DLLExportStorageClass)
6598 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
6602 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
6603 if (VD->getTLSKind())
6605 llvm::Constant *CV = GV;
6609 llvm::PointerType::get(
6615 llvm::Constant *&Entry = MaterializedGlobalTemporaryMap[E];
6617 Entry->replaceAllUsesWith(CV);
6618 llvm::cast<llvm::GlobalVariable>(Entry)->eraseFromParent();
6627void CodeGenModule::EmitObjCPropertyImplementations(
const
6640 if (!Getter || Getter->isSynthesizedAccessorStub())
6643 auto *Setter = PID->getSetterMethodDecl();
6644 if (!PD->
isReadOnly() && (!Setter || Setter->isSynthesizedAccessorStub()))
6655 if (ivar->getType().isDestructedType())
6704 getContext().getObjCIdType(),
nullptr, D,
true,
6722 EmitDeclContext(LSD);
6727 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
6730 std::unique_ptr<CodeGenFunction> &CurCGF =
6731 GlobalTopLevelStmtBlockInFlight.first;
6735 if (CurCGF && CXXGlobalInits.back() != CurCGF->CurFn) {
6743 std::string Name =
"__stmts__" + llvm::utostr(CXXGlobalInits.size());
6749 llvm::Function *Fn = llvm::Function::Create(
6750 FnTy, llvm::GlobalValue::InternalLinkage, Name, &
getModule());
6753 GlobalTopLevelStmtBlockInFlight.second = D;
6754 CurCGF->StartFunction(
GlobalDecl(), RetTy, Fn, FnInfo, Args,
6756 CXXGlobalInits.push_back(Fn);
6759 CurCGF->EmitStmt(D->
getStmt());
6762void CodeGenModule::EmitDeclContext(
const DeclContext *DC) {
6763 for (
auto *I : DC->
decls()) {
6769 if (
auto *OID = dyn_cast<ObjCImplDecl>(I)) {
6770 for (
auto *M : OID->methods())
6789 case Decl::CXXConversion:
6790 case Decl::CXXMethod:
6791 case Decl::Function:
6798 case Decl::CXXDeductionGuide:
6803 case Decl::Decomposition:
6804 case Decl::VarTemplateSpecialization:
6806 if (
auto *DD = dyn_cast<DecompositionDecl>(D))
6807 for (
auto *B : DD->bindings())
6808 if (
auto *HD = B->getHoldingVar())
6814 case Decl::IndirectField:
6818 case Decl::Namespace:
6819 EmitDeclContext(cast<NamespaceDecl>(D));
6821 case Decl::ClassTemplateSpecialization: {
6822 const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
6824 if (Spec->getSpecializationKind() ==
6826 Spec->hasDefinition())
6827 DI->completeTemplateDefinition(*Spec);
6829 case Decl::CXXRecord: {
6836 DI->completeUnusedClass(*CRD);
6839 for (
auto *I : CRD->
decls())
6840 if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
6845 case Decl::UsingShadow:
6846 case Decl::ClassTemplate:
6847 case Decl::VarTemplate:
6849 case Decl::VarTemplatePartialSpecialization:
6850 case Decl::FunctionTemplate:
6851 case Decl::TypeAliasTemplate:
6858 DI->EmitUsingDecl(cast<UsingDecl>(*D));
6860 case Decl::UsingEnum:
6862 DI->EmitUsingEnumDecl(cast<UsingEnumDecl>(*D));
6864 case Decl::NamespaceAlias:
6866 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
6868 case Decl::UsingDirective:
6870 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
6872 case Decl::CXXConstructor:
6875 case Decl::CXXDestructor:
6879 case Decl::StaticAssert:
6886 case Decl::ObjCInterface:
6887 case Decl::ObjCCategory:
6890 case Decl::ObjCProtocol: {
6891 auto *Proto = cast<ObjCProtocolDecl>(D);
6892 if (Proto->isThisDeclarationADefinition())
6897 case Decl::ObjCCategoryImpl:
6900 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
6903 case Decl::ObjCImplementation: {
6904 auto *OMD = cast<ObjCImplementationDecl>(D);
6905 EmitObjCPropertyImplementations(OMD);
6906 EmitObjCIvarInitializations(OMD);
6911 DI->getOrCreateInterfaceType(
getContext().getObjCInterfaceType(
6912 OMD->getClassInterface()), OMD->getLocation());
6915 case Decl::ObjCMethod: {
6916 auto *OMD = cast<ObjCMethodDecl>(D);
6922 case Decl::ObjCCompatibleAlias:
6923 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
6926 case Decl::PragmaComment: {
6927 const auto *PCD = cast<PragmaCommentDecl>(D);
6928 switch (PCD->getCommentKind()) {
6930 llvm_unreachable(
"unexpected pragma comment kind");
6945 case Decl::PragmaDetectMismatch: {
6946 const auto *PDMD = cast<PragmaDetectMismatchDecl>(D);
6951 case Decl::LinkageSpec:
6952 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
6955 case Decl::FileScopeAsm: {
6957 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
6960 if (LangOpts.OpenMPIsTargetDevice)
6963 if (LangOpts.SYCLIsDevice)
6965 auto *AD = cast<FileScopeAsmDecl>(D);
6966 getModule().appendModuleInlineAsm(AD->getAsmString()->getString());
6970 case Decl::TopLevelStmt:
6971 EmitTopLevelStmt(cast<TopLevelStmtDecl>(D));
6974 case Decl::Import: {
6975 auto *Import = cast<ImportDecl>(D);
6978 if (!ImportedModules.insert(Import->getImportedModule()))
6982 if (!Import->getImportedOwningModule()) {
6984 DI->EmitImportDecl(*Import);
6990 if (CXX20ModuleInits && Import->getImportedOwningModule() &&
6991 !Import->getImportedOwningModule()->isModuleMapModule())
7000 Visited.insert(Import->getImportedModule());
7001 Stack.push_back(Import->getImportedModule());
7003 while (!Stack.empty()) {
7005 if (!EmittedModuleInitializers.insert(Mod).second)
7015 if (Submodule->IsExplicit)
7018 if (
Visited.insert(Submodule).second)
7019 Stack.push_back(Submodule);
7026 EmitDeclContext(cast<ExportDecl>(D));
7029 case Decl::OMPThreadPrivate:
7033 case Decl::OMPAllocate:
7037 case Decl::OMPDeclareReduction:
7041 case Decl::OMPDeclareMapper:
7045 case Decl::OMPRequires:
7050 case Decl::TypeAlias:
7052 DI->EmitAndRetainType(
7053 getContext().getTypedefType(cast<TypedefNameDecl>(D)));
7065 DI->EmitAndRetainType(
getContext().getEnumType(cast<EnumDecl>(D)));
7068 case Decl::HLSLBuffer:
7076 assert(isa<TypeDecl>(D) &&
"Unsupported decl kind");
7083 if (!CodeGenOpts.CoverageMapping)
7086 case Decl::CXXConversion:
7087 case Decl::CXXMethod:
7088 case Decl::Function:
7089 case Decl::ObjCMethod:
7090 case Decl::CXXConstructor:
7091 case Decl::CXXDestructor: {
7092 if (!cast<FunctionDecl>(D)->doesThisDeclarationHaveABody())
7097 DeferredEmptyCoverageMappingDecls.try_emplace(D,
true);
7107 if (!CodeGenOpts.CoverageMapping)
7109 if (
const auto *Fn = dyn_cast<FunctionDecl>(D)) {
7110 if (Fn->isTemplateInstantiation())
7113 DeferredEmptyCoverageMappingDecls.insert_or_assign(D,
false);
7121 for (
const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
7124 const Decl *D = Entry.first;
7126 case Decl::CXXConversion:
7127 case Decl::CXXMethod:
7128 case Decl::Function:
7129 case Decl::ObjCMethod: {
7136 case Decl::CXXConstructor: {
7143 case Decl::CXXDestructor: {
7160 if (llvm::Function *F =
getModule().getFunction(
"main")) {
7161 if (!F->isDeclaration() && F->arg_size() == 0 && !F->isVarArg() &&
7163 auto *GA = llvm::GlobalAlias::create(
"__main_void", F);
7164 GA->setVisibility(llvm::GlobalValue::HiddenVisibility);
7173 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
7174 return llvm::ConstantInt::get(i64, PtrInt);
7178 llvm::NamedMDNode *&GlobalMetadata,
7180 llvm::GlobalValue *Addr) {
7181 if (!GlobalMetadata)
7183 CGM.
getModule().getOrInsertNamedMetadata(
"clang.global.decl.ptrs");
7186 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
7189 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.
getLLVMContext(), Ops));
7192bool CodeGenModule::CheckAndReplaceExternCIFuncs(llvm::GlobalValue *Elem,
7193 llvm::GlobalValue *CppFunc) {
7201 if (Elem == CppFunc)
7207 for (llvm::User *User : Elem->users()) {
7211 if (
auto *ConstExpr = dyn_cast<llvm::ConstantExpr>(User)) {
7212 if (ConstExpr->getOpcode() != llvm::Instruction::BitCast)
7215 for (llvm::User *CEUser : ConstExpr->users()) {
7216 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(CEUser)) {
7217 IFuncs.push_back(IFunc);
7222 CEs.push_back(ConstExpr);
7223 }
else if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(User)) {
7224 IFuncs.push_back(IFunc);
7236 for (llvm::GlobalIFunc *IFunc : IFuncs)
7237 IFunc->setResolver(
nullptr);
7238 for (llvm::ConstantExpr *ConstExpr : CEs)
7239 ConstExpr->destroyConstant();
7243 Elem->eraseFromParent();
7245 for (llvm::GlobalIFunc *IFunc : IFuncs) {
7250 llvm::FunctionType::get(IFunc->getType(),
false);
7251 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
7252 CppFunc->getName(), ResolverTy, {},
false);
7253 IFunc->setResolver(Resolver);
7263void CodeGenModule::EmitStaticExternCAliases() {
7266 for (
auto &I : StaticExternCValues) {
7268 llvm::GlobalValue *Val = I.second;
7276 llvm::GlobalValue *ExistingElem =
7277 getModule().getNamedValue(Name->getName());
7281 if (!ExistingElem || CheckAndReplaceExternCIFuncs(ExistingElem, Val))
7288 auto Res = Manglings.find(MangledName);
7289 if (Res == Manglings.end())
7291 Result = Res->getValue();
7302void CodeGenModule::EmitDeclMetadata() {
7303 llvm::NamedMDNode *GlobalMetadata =
nullptr;
7305 for (
auto &I : MangledDeclNames) {
7306 llvm::GlobalValue *Addr =
getModule().getNamedValue(I.second);
7316void CodeGenFunction::EmitDeclMetadata() {
7317 if (LocalDeclMap.empty())
return;
7322 unsigned DeclPtrKind = Context.getMDKindID(
"clang.decl.ptr");
7324 llvm::NamedMDNode *GlobalMetadata =
nullptr;
7326 for (
auto &I : LocalDeclMap) {
7327 const Decl *D = I.first;
7328 llvm::Value *Addr = I.second.emitRawPointer(*
this);
7329 if (
auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
7331 Alloca->setMetadata(
7332 DeclPtrKind, llvm::MDNode::get(
7333 Context, llvm::ValueAsMetadata::getConstant(DAddr)));
7334 }
else if (
auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
7341void CodeGenModule::EmitVersionIdentMetadata() {
7342 llvm::NamedMDNode *IdentMetadata =
7343 TheModule.getOrInsertNamedMetadata(
"llvm.ident");
7345 llvm::LLVMContext &Ctx = TheModule.getContext();
7347 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
7348 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
7351void CodeGenModule::EmitCommandLineMetadata() {
7352 llvm::NamedMDNode *CommandLineMetadata =
7353 TheModule.getOrInsertNamedMetadata(
"llvm.commandline");
7355 llvm::LLVMContext &Ctx = TheModule.getContext();
7357 llvm::Metadata *CommandLineNode[] = {llvm::MDString::get(Ctx, CommandLine)};
7358 CommandLineMetadata->addOperand(llvm::MDNode::get(Ctx, CommandLineNode));
7361void CodeGenModule::EmitCoverageFile() {
7362 llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata(
"llvm.dbg.cu");
7366 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata(
"llvm.gcov");
7367 llvm::LLVMContext &Ctx = TheModule.getContext();
7368 auto *CoverageDataFile =
7370 auto *CoverageNotesFile =
7372 for (
int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
7373 llvm::MDNode *CU = CUNode->getOperand(i);
7374 llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
7375 GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
7396 if (LangOpts.OpenMP && LangOpts.OpenMPSimd)
7398 for (
auto RefExpr : D->
varlists()) {
7399 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
7401 VD->getAnyInitializer() &&
7402 !VD->getAnyInitializer()->isConstantInitializer(
getContext(),
7409 VD, Addr, RefExpr->getBeginLoc(), PerformInit))
7410 CXXGlobalInits.push_back(InitFunction);
7415CodeGenModule::CreateMetadataIdentifierImpl(
QualType T, MetadataTypeMap &Map,
7419 FnType->getReturnType(), FnType->getParamTypes(),
7420 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
7422 llvm::Metadata *&InternalId = Map[
T.getCanonicalType()];
7427 std::string OutName;
7428 llvm::raw_string_ostream Out(OutName);
7433 Out <<
".normalized";
7447 return CreateMetadataIdentifierImpl(
T, MetadataIdMap,
"");
7452 return CreateMetadataIdentifierImpl(
T, VirtualMetadataIdMap,
".virtual");
7472 for (
auto &Param : FnType->param_types())
7477 GeneralizedParams, FnType->getExtProtoInfo());
7484 llvm_unreachable(
"Encountered unknown FunctionType");
7489 GeneralizedMetadataIdMap,
".generalized");
7496 return ((LangOpts.
Sanitize.
has(SanitizerKind::CFIVCall) &&
7498 (LangOpts.
Sanitize.
has(SanitizerKind::CFINVCall) &&
7500 (LangOpts.
Sanitize.
has(SanitizerKind::CFIDerivedCast) &&
7502 (LangOpts.
Sanitize.
has(SanitizerKind::CFIUnrelatedCast) &&
7509 llvm::Metadata *MD =
7511 VTable->addTypeMetadata(Offset.getQuantity(), MD);
7513 if (CodeGenOpts.SanitizeCfiCrossDso)
7515 VTable->addTypeMetadata(Offset.getQuantity(),
7516 llvm::ConstantAsMetadata::get(CrossDsoTypeId));
7519 llvm::Metadata *MD = llvm::MDString::get(
getLLVMContext(),
"all-vtables");
7520 VTable->addTypeMetadata(Offset.getQuantity(), MD);
7526 SanStats = std::make_unique<llvm::SanitizerStatReport>(&
getModule());
7536 auto *FTy = llvm::FunctionType::get(SamplerT, {
C->getType()},
false);
7551 bool forPointeeType) {
7562 if (
auto Align = TT->getDecl()->getMaxAlignment()) {
7592 if (
T.getQualifiers().hasUnaligned()) {
7594 }
else if (forPointeeType && !AlignForArray &&
7606 if (
unsigned MaxAlign =
getLangOpts().MaxTypeAlign) {
7619 if (NumAutoVarInit >= StopAfter) {
7622 if (!NumAutoVarInit) {
7625 "-ftrivial-auto-var-init-stop-after=%0 has been enabled to limit the "
7626 "number of times ftrivial-auto-var-init=%1 gets applied.");
7640 const Decl *D)
const {
7644 OS << (isa<VarDecl>(D) ?
".static." :
".intern.");
7646 OS << (isa<VarDecl>(D) ?
"__static__" :
"__intern__");
7652 assert(PLoc.
isValid() &&
"Source location is expected to be valid.");
7656 llvm::MD5::MD5Result
Result;
7657 for (
const auto &Arg : PreprocessorOpts.
Macros)
7658 Hash.update(Arg.first);
7662 llvm::sys::fs::UniqueID ID;
7663 if (llvm::sys::fs::getUniqueID(PLoc.
getFilename(), ID)) {
7665 assert(PLoc.
isValid() &&
"Source location is expected to be valid.");
7666 if (
auto EC = llvm::sys::fs::getUniqueID(PLoc.
getFilename(), ID))
7667 SM.getDiagnostics().Report(diag::err_cannot_open_file)
7670 OS << llvm::format(
"%x", ID.getFile()) << llvm::format(
"%x", ID.getDevice())
7671 <<
"_" << llvm::utohexstr(
Result.low(),
true, 8);
7678 assert(DeferredDeclsToEmit.empty() &&
7679 "Should have emitted all decls deferred to emit.");
7680 assert(NewBuilder->DeferredDecls.empty() &&
7681 "Newly created module should not have deferred decls");
7682 NewBuilder->DeferredDecls = std::move(DeferredDecls);
7683 assert(EmittedDeferredDecls.empty() &&
7684 "Still have (unmerged) EmittedDeferredDecls deferred decls");
7686 assert(NewBuilder->DeferredVTables.empty() &&
7687 "Newly created module should not have deferred vtables");
7688 NewBuilder->DeferredVTables = std::move(DeferredVTables);
7690 assert(NewBuilder->MangledDeclNames.empty() &&
7691 "Newly created module should not have mangled decl names");
7692 assert(NewBuilder->Manglings.empty() &&
7693 "Newly created module should not have manglings");
7694 NewBuilder->Manglings = std::move(Manglings);
7696 NewBuilder->WeakRefReferences = std::move(WeakRefReferences);
7698 NewBuilder->TBAA = std::move(TBAA);
7700 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)
llvm::GlobalValue::LinkageTypes getMultiversionLinkage(CodeGenModule &CGM, GlobalDecl GD)
static bool hasImplicitAttr(const ValueDecl *D)
static void emitUsed(CodeGenModule &CGM, StringRef Name, std::vector< llvm::WeakTrackingVH > &List)
static FunctionDecl * createDefaultTargetVersionFrom(const FunctionDecl *FD)
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 unsigned TargetMVPriority(const TargetInfo &TI, const CodeGenFunction::MultiVersionResolverOption &RO)
static void setVisibilityFromDLLStorageClass(const clang::LangOptions &LO, llvm::Module &M)
static std::string getCPUSpecificMangling(const CodeGenModule &CGM, 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 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)
void setLLVMVisibility(llvm::GlobalValue &GV, std::optional< llvm::GlobalValue::VisibilityTypes > V)
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 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.
Defines the clang::FileManager interface and associated types.
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()'.
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.
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.
llvm::DenseSet< const ValueDecl * > CUDAExternalDeviceDeclODRUsedByHost
Keep track of CUDA/HIP external kernels or device variables ODR-used by host code.
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.
CXXTemporary * getTemporary()
Represents a call to a C++ constructor.
CXXConstructorDecl * getConstructor() const
Get the constructor that this expression will (ultimately) call.
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.
FunctionDecl * getOperatorDelete() const
Represents a C++ destructor within a class.
Represents a call to a member function that may be written either with member call syntax (e....
CXXMethodDecl * getMethodDecl() const
Retrieve the declaration of the called method.
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)".
FunctionDecl * getOperatorNew() const
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
const CXXDestructorDecl * getDestructor() const
CallExpr - Represents a function call (C99 6.5.2.2, C++ [expr.call]).
FunctionDecl * getDirectCallee()
If the callee is a FunctionDecl, return it. Otherwise return null.
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.
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 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
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
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 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.
void EmitExternalDeclaration(const VarDecl *D)
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.
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.
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...
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys=std::nullopt)
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...
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.
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.
void RefreshTypeCacheForClass(const CXXRecordDecl *RD)
Remove stale types from the type cache when an inheritance model gets assigned to a class.
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)
llvm::Type * ConvertTypeForMem(QualType T, bool ForBitField=false)
ConvertTypeForMem - Convert type T into a llvm::Type.
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.
void addDecl(Decl *D)
Add the declaration D into this context.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
A reference to a declared variable, function, enum, etc.
Decl - This represents one declaration (or definition), e.g.
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.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
SourceLocation getBeginLoc() const LLVM_READONLY
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
The name of a declaration.
Represents a ValueDecl that came out of a declarator.
SourceLocation getBeginLoc() const LLVM_READONLY
TypeSourceInfo * getTypeSourceInfo() const
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...
void setIsMultiVersion(bool V=true)
Sets the multiversion state for this declaration and all of its redeclarations.
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.
StorageClass getStorageClass() const
Returns the storage class as written in the source.
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...
static FunctionDecl * Create(ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation NLoc, DeclarationName N, QualType T, TypeSourceInfo *TInfo, StorageClass SC, bool UsesFPIntrin=false, bool isInlineSpecified=false, bool hasWrittenPrototype=true, ConstexprSpecKind ConstexprKind=ConstexprSpecKind::Unspecified, Expr *TrailingRequiresClause=nullptr)
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
SourceRange getSourceRange() const override LLVM_READONLY
Source range that this declaration covers.
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.
DeclarationNameInfo getNameInfo() const
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.
StorageDuration getStorageDuration() const
Retrieve the storage duration for the materialized temporary.
Expr * getSubExpr() const
Retrieve the temporary-generating subexpression whose value will be materialized into a glvalue.
APValue * getOrCreateValue(bool MayCreate) const
Get the storage for the constant value of a materialized temporary of static storage duration.
ValueDecl * getExtendingDecl()
Get the declaration which triggered the lifetime-extension of this temporary, if any.
unsigned getManglingNumber() const
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.
bool isExternallyVisible() const
Represent a C++ namespace.
This represents '#pragma omp threadprivate ...' directive.
ObjCEncodeExpr, used for @encode in Objective-C.
QualType getEncodedType() const
propimpl_range property_impls() const
const ObjCInterfaceDecl * getClassInterface() const
void addInstanceMethod(ObjCMethodDecl *method)
ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...
init_iterator init_end()
init_end() - Retrieve an iterator past the last initializer.
init_iterator init_begin()
init_begin() - Retrieve an iterator to the first initializer.
unsigned getNumIvarInitializers() const
getNumArgs - Number of ivars which must be initialized.
void setHasDestructors(bool val)
void setHasNonZeroConstructors(bool val)
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.
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.
bool isConstant(const ASTContext &Ctx) const
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
virtual void completeDefinition()
Note that the definition of this type is now complete.
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.
Stmt - This represents one statement.
StringLiteral - This represents a string literal expression, e.g.
unsigned getLength() const
uint32_t getCodeUnit(size_t i) const
StringRef getString() const
unsigned getCharByteWidth() const
Represents the declaration of a struct/union/class/enum.
void startDefinition()
Starts the definition of this tag declaration.
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.
virtual unsigned multiVersionSortPriority(StringRef Name) const
unsigned getIntWidth() const
getIntWidth/Align - Return the size of 'signed int' and 'unsigned int' for this target,...
virtual unsigned multiVersionFeatureCost() const
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 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
A container of type source information.
QualType getType() const
Return the type wrapped by this type source info.
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 isReferenceType() const
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.
VarDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool hasFlexibleArrayInit(const ASTContext &Ctx) const
Whether this variable has a flexible array member initialized with one or more elements.
bool hasGlobalStorage() const
Returns true for all variables that do not have local storage.
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.
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
const Expr * getInit() const
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
@ TLS_Dynamic
TLS with a dynamic initializer.
@ DeclarationOnly
This declaration is only a declaration.
@ Definition
This declaration is definitely a definition.
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
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 > 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)
StorageClass
Storage classes.
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
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.
__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::PointerType * VoidPtrTy
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
DeclarationName getName() const
getName - Returns the embedded declaration name.
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
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.
Describes how types, statements, expressions, and declarations should be printed.
bool has(SanitizerMask K) const
Check if a certain (single) sanitizer is enabled.