52#include "llvm/ADT/STLExtras.h"
53#include "llvm/ADT/StringExtras.h"
54#include "llvm/ADT/StringSwitch.h"
55#include "llvm/Analysis/TargetLibraryInfo.h"
56#include "llvm/Frontend/OpenMP/OMPIRBuilder.h"
57#include "llvm/IR/AttributeMask.h"
58#include "llvm/IR/CallingConv.h"
59#include "llvm/IR/DataLayout.h"
60#include "llvm/IR/Intrinsics.h"
61#include "llvm/IR/LLVMContext.h"
62#include "llvm/IR/Module.h"
63#include "llvm/IR/ProfileSummary.h"
64#include "llvm/ProfileData/InstrProfReader.h"
65#include "llvm/ProfileData/SampleProf.h"
66#include "llvm/Support/CRC.h"
67#include "llvm/Support/CodeGen.h"
68#include "llvm/Support/CommandLine.h"
69#include "llvm/Support/ConvertUTF.h"
70#include "llvm/Support/ErrorHandling.h"
71#include "llvm/Support/RISCVISAInfo.h"
72#include "llvm/Support/TimeProfiler.h"
73#include "llvm/Support/xxhash.h"
74#include "llvm/TargetParser/Triple.h"
75#include "llvm/TargetParser/X86TargetParser.h"
79using namespace CodeGen;
82 "limited-coverage-experimental", llvm::cl::Hidden,
83 llvm::cl::desc(
"Emit limited coverage mapping information (experimental)"));
89 case TargetCXXABI::AppleARM64:
90 case TargetCXXABI::Fuchsia:
91 case TargetCXXABI::GenericAArch64:
92 case TargetCXXABI::GenericARM:
93 case TargetCXXABI::iOS:
94 case TargetCXXABI::WatchOS:
95 case TargetCXXABI::GenericMIPS:
96 case TargetCXXABI::GenericItanium:
97 case TargetCXXABI::WebAssembly:
98 case TargetCXXABI::XL:
100 case TargetCXXABI::Microsoft:
104 llvm_unreachable(
"invalid C++ ABI kind");
107static std::unique_ptr<TargetCodeGenInfo>
113 switch (Triple.getArch()) {
117 case llvm::Triple::le32:
119 case llvm::Triple::m68k:
121 case llvm::Triple::mips:
122 case llvm::Triple::mipsel:
123 if (Triple.getOS() == llvm::Triple::NaCl)
127 case llvm::Triple::mips64:
128 case llvm::Triple::mips64el:
131 case llvm::Triple::avr: {
135 unsigned NPR =
Target.getABI() ==
"avrtiny" ? 6 : 18;
136 unsigned NRR =
Target.getABI() ==
"avrtiny" ? 4 : 8;
140 case llvm::Triple::aarch64:
141 case llvm::Triple::aarch64_32:
142 case llvm::Triple::aarch64_be: {
144 if (
Target.getABI() ==
"darwinpcs")
145 Kind = AArch64ABIKind::DarwinPCS;
146 else if (Triple.isOSWindows())
152 case llvm::Triple::wasm32:
153 case llvm::Triple::wasm64: {
155 if (
Target.getABI() ==
"experimental-mv")
156 Kind = WebAssemblyABIKind::ExperimentalMV;
160 case llvm::Triple::arm:
161 case llvm::Triple::armeb:
162 case llvm::Triple::thumb:
163 case llvm::Triple::thumbeb: {
164 if (Triple.getOS() == llvm::Triple::Win32)
168 StringRef ABIStr =
Target.getABI();
169 if (ABIStr ==
"apcs-gnu")
170 Kind = ARMABIKind::APCS;
171 else if (ABIStr ==
"aapcs16")
172 Kind = ARMABIKind::AAPCS16_VFP;
173 else if (CodeGenOpts.
FloatABI ==
"hard" ||
175 (Triple.getEnvironment() == llvm::Triple::GNUEABIHF ||
176 Triple.getEnvironment() == llvm::Triple::MuslEABIHF ||
177 Triple.getEnvironment() == llvm::Triple::EABIHF)))
178 Kind = ARMABIKind::AAPCS_VFP;
183 case llvm::Triple::ppc: {
184 if (Triple.isOSAIX())
191 case llvm::Triple::ppcle: {
192 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
195 case llvm::Triple::ppc64:
196 if (Triple.isOSAIX())
199 if (Triple.isOSBinFormatELF()) {
201 if (
Target.getABI() ==
"elfv2")
202 Kind = PPC64_SVR4_ABIKind::ELFv2;
203 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
208 case llvm::Triple::ppc64le: {
209 assert(Triple.isOSBinFormatELF() &&
"PPC64 LE non-ELF not supported!");
211 if (
Target.getABI() ==
"elfv1")
212 Kind = PPC64_SVR4_ABIKind::ELFv1;
213 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
218 case llvm::Triple::nvptx:
219 case llvm::Triple::nvptx64:
222 case llvm::Triple::msp430:
225 case llvm::Triple::riscv32:
226 case llvm::Triple::riscv64: {
227 StringRef ABIStr =
Target.getABI();
228 unsigned XLen =
Target.getPointerWidth(LangAS::Default);
229 unsigned ABIFLen = 0;
230 if (ABIStr.ends_with(
"f"))
232 else if (ABIStr.ends_with(
"d"))
234 bool EABI = ABIStr.ends_with(
"e");
238 case llvm::Triple::systemz: {
239 bool SoftFloat = CodeGenOpts.
FloatABI ==
"soft";
240 bool HasVector = !SoftFloat &&
Target.getABI() ==
"vector";
244 case llvm::Triple::tce:
245 case llvm::Triple::tcele:
248 case llvm::Triple::x86: {
249 bool IsDarwinVectorABI = Triple.isOSDarwin();
250 bool IsWin32FloatStructABI = Triple.isOSWindows() && !Triple.isOSCygMing();
252 if (Triple.getOS() == llvm::Triple::Win32) {
254 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
255 CodeGenOpts.NumRegisterParameters);
258 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
259 CodeGenOpts.NumRegisterParameters, CodeGenOpts.
FloatABI ==
"soft");
262 case llvm::Triple::x86_64: {
263 StringRef ABI =
Target.getABI();
264 X86AVXABILevel AVXLevel = (ABI ==
"avx512" ? X86AVXABILevel::AVX512
265 : ABI ==
"avx" ? X86AVXABILevel::AVX
266 : X86AVXABILevel::None);
268 switch (Triple.getOS()) {
269 case llvm::Triple::Win32:
275 case llvm::Triple::hexagon:
277 case llvm::Triple::lanai:
279 case llvm::Triple::r600:
281 case llvm::Triple::amdgcn:
283 case llvm::Triple::sparc:
285 case llvm::Triple::sparcv9:
287 case llvm::Triple::xcore:
289 case llvm::Triple::arc:
291 case llvm::Triple::spir:
292 case llvm::Triple::spir64:
294 case llvm::Triple::spirv32:
295 case llvm::Triple::spirv64:
297 case llvm::Triple::ve:
299 case llvm::Triple::csky: {
300 bool IsSoftFloat = !
Target.hasFeature(
"hard-float-abi");
302 Target.hasFeature(
"fpuv2_df") ||
Target.hasFeature(
"fpuv3_df");
307 case llvm::Triple::bpfeb:
308 case llvm::Triple::bpfel:
310 case llvm::Triple::loongarch32:
311 case llvm::Triple::loongarch64: {
312 StringRef ABIStr =
Target.getABI();
313 unsigned ABIFRLen = 0;
314 if (ABIStr.ends_with(
"f"))
316 else if (ABIStr.ends_with(
"d"))
319 CGM,
Target.getPointerWidth(LangAS::Default), ABIFRLen);
325 if (!TheTargetCodeGenInfo)
327 return *TheTargetCodeGenInfo;
337 : Context(
C), LangOpts(
C.getLangOpts()), FS(FS), HeaderSearchOpts(HSO),
338 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
340 VMContext(M.getContext()), Types(*this), VTables(*this),
344 llvm::LLVMContext &LLVMContext = M.getContext();
345 VoidTy = llvm::Type::getVoidTy(LLVMContext);
346 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
347 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
348 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
349 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
350 HalfTy = llvm::Type::getHalfTy(LLVMContext);
351 BFloatTy = llvm::Type::getBFloatTy(LLVMContext);
352 FloatTy = llvm::Type::getFloatTy(LLVMContext);
353 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
359 C.toCharUnitsFromBits(
C.getTargetInfo().getMaxPointerWidth()).getQuantity();
361 C.toCharUnitsFromBits(
C.getTargetInfo().getIntAlign()).getQuantity();
363 llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getCharWidth());
364 IntTy = llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getIntWidth());
365 IntPtrTy = llvm::IntegerType::get(LLVMContext,
366 C.getTargetInfo().getMaxPointerWidth());
367 Int8PtrTy = llvm::PointerType::get(LLVMContext, 0);
368 const llvm::DataLayout &DL = M.getDataLayout();
370 llvm::PointerType::get(LLVMContext, DL.getAllocaAddrSpace());
372 llvm::PointerType::get(LLVMContext, DL.getDefaultGlobalsAddressSpace());
389 createOpenCLRuntime();
391 createOpenMPRuntime();
398 if (LangOpts.
Sanitize.
has(SanitizerKind::Thread) ||
399 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
405 if (CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo ||
410 Block.GlobalUniqueCount = 0;
412 if (
C.getLangOpts().ObjC)
416 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
423 PGOReader = std::move(ReaderOrErr.get());
428 if (CodeGenOpts.CoverageMapping)
432 if (CodeGenOpts.UniqueInternalLinkageNames &&
433 !
getModule().getSourceFileName().empty()) {
434 std::string Path =
getModule().getSourceFileName();
437 if (Path.rfind(Entry.first, 0) != std::string::npos) {
438 Path = Entry.second + Path.substr(Entry.first.size());
441 ModuleNameHash = llvm::getUniqueInternalLinkagePostfix(Path);
447void CodeGenModule::createObjCRuntime() {
464 llvm_unreachable(
"bad runtime kind");
467void CodeGenModule::createOpenCLRuntime() {
471void CodeGenModule::createOpenMPRuntime() {
475 case llvm::Triple::nvptx:
476 case llvm::Triple::nvptx64:
477 case llvm::Triple::amdgcn:
479 "OpenMP AMDGPU/NVPTX is only prepared to deal with device code.");
483 if (LangOpts.OpenMPSimd)
491void CodeGenModule::createCUDARuntime() {
495void CodeGenModule::createHLSLRuntime() {
500 Replacements[Name] =
C;
503void CodeGenModule::applyReplacements() {
504 for (
auto &I : Replacements) {
505 StringRef MangledName = I.first;
506 llvm::Constant *Replacement = I.second;
510 auto *OldF = cast<llvm::Function>(Entry);
511 auto *NewF = dyn_cast<llvm::Function>(Replacement);
513 if (
auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
514 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
516 auto *CE = cast<llvm::ConstantExpr>(Replacement);
517 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
518 CE->getOpcode() == llvm::Instruction::GetElementPtr);
519 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
524 OldF->replaceAllUsesWith(Replacement);
526 NewF->removeFromParent();
527 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
530 OldF->eraseFromParent();
535 GlobalValReplacements.push_back(std::make_pair(GV,
C));
538void CodeGenModule::applyGlobalValReplacements() {
539 for (
auto &I : GlobalValReplacements) {
540 llvm::GlobalValue *GV = I.first;
541 llvm::Constant *
C = I.second;
543 GV->replaceAllUsesWith(
C);
544 GV->eraseFromParent();
551 const llvm::Constant *
C;
552 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(GV))
553 C = GA->getAliasee();
554 else if (
auto *GI = dyn_cast<llvm::GlobalIFunc>(GV))
555 C = GI->getResolver();
559 const auto *AliaseeGV = dyn_cast<llvm::GlobalValue>(
C->stripPointerCasts());
563 const llvm::GlobalValue *FinalGV = AliaseeGV->getAliaseeObject();
572 bool IsIFunc,
const llvm::GlobalValue *Alias,
const llvm::GlobalValue *&GV,
573 const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames,
577 Diags.
Report(Location, diag::err_cyclic_alias) << IsIFunc;
581 if (GV->hasCommonLinkage()) {
583 if (Triple.getObjectFormat() == llvm::Triple::XCOFF) {
584 Diags.
Report(Location, diag::err_alias_to_common);
589 if (GV->isDeclaration()) {
590 Diags.
Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;
591 Diags.
Report(Location, diag::note_alias_requires_mangled_name)
592 << IsIFunc << IsIFunc;
595 for (
const auto &[
Decl, Name] : MangledDeclNames) {
596 if (
const auto *ND = dyn_cast<NamedDecl>(
Decl.getDecl())) {
597 if (ND->getName() == GV->getName()) {
598 Diags.
Report(Location, diag::note_alias_mangled_name_alternative)
602 (Twine(IsIFunc ?
"ifunc" :
"alias") +
"(\"" + Name +
"\")")
612 const auto *F = dyn_cast<llvm::Function>(GV);
614 Diags.
Report(Location, diag::err_alias_to_undefined)
615 << IsIFunc << IsIFunc;
619 llvm::FunctionType *FTy = F->getFunctionType();
620 if (!FTy->getReturnType()->isPointerTy()) {
621 Diags.
Report(Location, diag::err_ifunc_resolver_return);
635 if (GVar->hasAttribute(
"toc-data")) {
636 auto GVId = GVar->getName();
639 Diags.
Report(Location, diag::warn_toc_unsupported_type)
640 << GVId <<
"the variable has an alias";
642 llvm::AttributeSet CurrAttributes = GVar->getAttributes();
643 llvm::AttributeSet NewAttributes =
644 CurrAttributes.removeAttribute(GVar->getContext(),
"toc-data");
645 GVar->setAttributes(NewAttributes);
649void CodeGenModule::checkAliases() {
656 const auto *D = cast<ValueDecl>(GD.getDecl());
659 bool IsIFunc = D->hasAttr<IFuncAttr>();
660 if (
const Attr *A = D->getDefiningAttr()) {
661 Location = A->getLocation();
662 Range = A->getRange();
664 llvm_unreachable(
"Not an alias or ifunc?");
668 const llvm::GlobalValue *GV =
nullptr;
670 MangledDeclNames, Range)) {
676 if (
const llvm::GlobalVariable *GVar =
677 dyn_cast<const llvm::GlobalVariable>(GV))
681 llvm::Constant *Aliasee =
682 IsIFunc ? cast<llvm::GlobalIFunc>(Alias)->getResolver()
683 : cast<llvm::GlobalAlias>(Alias)->getAliasee();
685 llvm::GlobalValue *AliaseeGV;
686 if (
auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
687 AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));
689 AliaseeGV = cast<llvm::GlobalValue>(Aliasee);
691 if (
const SectionAttr *SA = D->getAttr<SectionAttr>()) {
692 StringRef AliasSection = SA->getName();
693 if (AliasSection != AliaseeGV->getSection())
694 Diags.
Report(SA->getLocation(), diag::warn_alias_with_section)
695 << AliasSection << IsIFunc << IsIFunc;
703 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {
704 if (GA->isInterposable()) {
705 Diags.
Report(Location, diag::warn_alias_to_weak_alias)
706 << GV->getName() << GA->getName() << IsIFunc;
707 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
708 GA->getAliasee(), Alias->getType());
711 cast<llvm::GlobalIFunc>(Alias)->setResolver(Aliasee);
713 cast<llvm::GlobalAlias>(Alias)->setAliasee(Aliasee);
723 Alias->replaceAllUsesWith(llvm::UndefValue::get(Alias->getType()));
724 Alias->eraseFromParent();
729 DeferredDeclsToEmit.clear();
730 EmittedDeferredDecls.clear();
731 DeferredAnnotations.clear();
733 OpenMPRuntime->clear();
737 StringRef MainFile) {
740 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
741 if (MainFile.empty())
742 MainFile =
"<stdin>";
743 Diags.
Report(diag::warn_profile_data_unprofiled) << MainFile;
746 Diags.
Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
749 Diags.
Report(diag::warn_profile_data_missing) << Visited << Missing;
753static std::optional<llvm::GlobalValue::VisibilityTypes>
760 return llvm::GlobalValue::DefaultVisibility;
762 return llvm::GlobalValue::HiddenVisibility;
764 return llvm::GlobalValue::ProtectedVisibility;
766 llvm_unreachable(
"unknown option value!");
770 std::optional<llvm::GlobalValue::VisibilityTypes>
V) {
779 GV.setDSOLocal(
false);
780 GV.setVisibility(*
V);
785 if (!LO.VisibilityFromDLLStorageClass)
788 std::optional<llvm::GlobalValue::VisibilityTypes> DLLExportVisibility =
791 std::optional<llvm::GlobalValue::VisibilityTypes>
792 NoDLLStorageClassVisibility =
795 std::optional<llvm::GlobalValue::VisibilityTypes>
796 ExternDeclDLLImportVisibility =
799 std::optional<llvm::GlobalValue::VisibilityTypes>
800 ExternDeclNoDLLStorageClassVisibility =
803 for (llvm::GlobalValue &GV : M.global_values()) {
804 if (GV.hasAppendingLinkage() || GV.hasLocalLinkage())
807 if (GV.isDeclarationForLinker())
809 llvm::GlobalValue::DLLImportStorageClass
810 ? ExternDeclDLLImportVisibility
811 : ExternDeclNoDLLStorageClassVisibility);
814 llvm::GlobalValue::DLLExportStorageClass
815 ? DLLExportVisibility
816 : NoDLLStorageClassVisibility);
818 GV.setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
823 const llvm::Triple &Triple,
825 if (Triple.isAMDGPU() || Triple.isNVPTX())
827 return LangOpts.getStackProtector() == Mode;
833 EmitModuleInitializers(Primary);
835 DeferredDecls.insert(EmittedDeferredDecls.begin(),
836 EmittedDeferredDecls.end());
837 EmittedDeferredDecls.clear();
838 EmitVTablesOpportunistically();
839 applyGlobalValReplacements();
841 emitMultiVersionFunctions();
844 GlobalTopLevelStmtBlockInFlight.first) {
846 GlobalTopLevelStmtBlockInFlight.first->FinishFunction(TLSD->
getEndLoc());
847 GlobalTopLevelStmtBlockInFlight = {
nullptr,
nullptr};
853 EmitCXXModuleInitFunc(Primary);
855 EmitCXXGlobalInitFunc();
856 EmitCXXGlobalCleanUpFunc();
857 registerGlobalDtorsWithAtExit();
858 EmitCXXThreadLocalInitFunc();
860 if (llvm::Function *ObjCInitFunction =
ObjCRuntime->ModuleInitFunction())
863 if (llvm::Function *CudaCtorFunction = CUDARuntime->finalizeModule())
867 OpenMPRuntime->createOffloadEntriesAndInfoMetadata();
868 OpenMPRuntime->clear();
872 PGOReader->getSummary(
false).getMD(VMContext),
873 llvm::ProfileSummary::PSK_Instr);
880 EmitCtorList(GlobalCtors,
"llvm.global_ctors");
881 EmitCtorList(GlobalDtors,
"llvm.global_dtors");
883 EmitStaticExternCAliases();
889 CoverageMapping->emit();
890 if (CodeGenOpts.SanitizeCfiCrossDso) {
896 emitAtAvailableLinkGuard();
903 if (
getTarget().getTargetOpts().CodeObjectVersion !=
904 llvm::CodeObjectVersionKind::COV_None) {
905 getModule().addModuleFlag(llvm::Module::Error,
906 "amdhsa_code_object_version",
907 getTarget().getTargetOpts().CodeObjectVersion);
912 auto *MDStr = llvm::MDString::get(
917 getModule().addModuleFlag(llvm::Module::Error,
"amdgpu_printf_kind",
930 if (
auto *FD = dyn_cast<FunctionDecl>(D))
934 UsedArray.push_back(llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
938 llvm::ArrayType *ATy = llvm::ArrayType::get(
Int8PtrTy, UsedArray.size());
940 auto *GV =
new llvm::GlobalVariable(
941 getModule(), ATy,
false, llvm::GlobalValue::InternalLinkage,
942 llvm::ConstantArray::get(ATy, UsedArray),
"__clang_gpu_used_external");
945 if (LangOpts.HIP && !
getLangOpts().OffloadingNewDriver) {
948 auto *GV =
new llvm::GlobalVariable(
950 llvm::Constant::getNullValue(
Int8Ty),
958 if (CodeGenOpts.Autolink &&
959 (Context.
getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
960 EmitModuleLinkOptions();
975 if (!ELFDependentLibraries.empty() && !Context.
getLangOpts().CUDAIsDevice) {
976 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.dependent-libraries");
977 for (
auto *MD : ELFDependentLibraries)
983 getModule().addModuleFlag(llvm::Module::Error,
"NumRegisterParameters",
984 CodeGenOpts.NumRegisterParameters);
986 if (CodeGenOpts.DwarfVersion) {
987 getModule().addModuleFlag(llvm::Module::Max,
"Dwarf Version",
988 CodeGenOpts.DwarfVersion);
991 if (CodeGenOpts.Dwarf64)
992 getModule().addModuleFlag(llvm::Module::Max,
"DWARF64", 1);
996 getModule().setSemanticInterposition(
true);
998 if (CodeGenOpts.EmitCodeView) {
1000 getModule().addModuleFlag(llvm::Module::Warning,
"CodeView", 1);
1002 if (CodeGenOpts.CodeViewGHash) {
1003 getModule().addModuleFlag(llvm::Module::Warning,
"CodeViewGHash", 1);
1005 if (CodeGenOpts.ControlFlowGuard) {
1007 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 2);
1008 }
else if (CodeGenOpts.ControlFlowGuardNoChecks) {
1010 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 1);
1012 if (CodeGenOpts.EHContGuard) {
1014 getModule().addModuleFlag(llvm::Module::Warning,
"ehcontguard", 1);
1018 getModule().addModuleFlag(llvm::Module::Warning,
"ms-kernel", 1);
1020 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
1025 getModule().addModuleFlag(llvm::Module::Error,
"StrictVTablePointers",1);
1027 llvm::Metadata *Ops[2] = {
1028 llvm::MDString::get(VMContext,
"StrictVTablePointers"),
1029 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1030 llvm::Type::getInt32Ty(VMContext), 1))};
1032 getModule().addModuleFlag(llvm::Module::Require,
1033 "StrictVTablePointersRequirement",
1034 llvm::MDNode::get(VMContext, Ops));
1040 getModule().addModuleFlag(llvm::Module::Warning,
"Debug Info Version",
1041 llvm::DEBUG_METADATA_VERSION);
1046 uint64_t WCharWidth =
1048 getModule().addModuleFlag(llvm::Module::Error,
"wchar_size", WCharWidth);
1051 getModule().addModuleFlag(llvm::Module::Warning,
1052 "zos_product_major_version",
1053 uint32_t(CLANG_VERSION_MAJOR));
1054 getModule().addModuleFlag(llvm::Module::Warning,
1055 "zos_product_minor_version",
1056 uint32_t(CLANG_VERSION_MINOR));
1057 getModule().addModuleFlag(llvm::Module::Warning,
"zos_product_patchlevel",
1058 uint32_t(CLANG_VERSION_PATCHLEVEL));
1060 getModule().addModuleFlag(llvm::Module::Error,
"zos_product_id",
1061 llvm::MDString::get(VMContext, ProductId));
1066 getModule().addModuleFlag(llvm::Module::Error,
"zos_cu_language",
1067 llvm::MDString::get(VMContext, lang_str));
1071 : std::time(
nullptr);
1072 getModule().addModuleFlag(llvm::Module::Max,
"zos_translation_time",
1073 static_cast<uint64_t
>(TT));
1076 getModule().addModuleFlag(llvm::Module::Error,
"zos_le_char_mode",
1077 llvm::MDString::get(VMContext,
"ascii"));
1081 if (T.isARM() || T.isThumb()) {
1083 uint64_t EnumWidth = Context.
getLangOpts().ShortEnums ? 1 : 4;
1084 getModule().addModuleFlag(llvm::Module::Error,
"min_enum_size", EnumWidth);
1088 StringRef ABIStr =
Target.getABI();
1089 llvm::LLVMContext &Ctx = TheModule.getContext();
1090 getModule().addModuleFlag(llvm::Module::Error,
"target-abi",
1091 llvm::MDString::get(Ctx, ABIStr));
1096 const std::vector<std::string> &Features =
1099 llvm::RISCVISAInfo::parseFeatures(T.isRISCV64() ? 64 : 32, Features);
1100 if (!errorToBool(ParseResult.takeError()))
1102 llvm::Module::AppendUnique,
"riscv-isa",
1104 Ctx, llvm::MDString::get(Ctx, (*ParseResult)->toString())));
1107 if (CodeGenOpts.SanitizeCfiCrossDso) {
1109 getModule().addModuleFlag(llvm::Module::Override,
"Cross-DSO CFI", 1);
1112 if (CodeGenOpts.WholeProgramVTables) {
1116 getModule().addModuleFlag(llvm::Module::Error,
"Virtual Function Elim",
1117 CodeGenOpts.VirtualFunctionElimination);
1120 if (LangOpts.
Sanitize.
has(SanitizerKind::CFIICall)) {
1121 getModule().addModuleFlag(llvm::Module::Override,
1122 "CFI Canonical Jump Tables",
1123 CodeGenOpts.SanitizeCfiCanonicalJumpTables);
1127 getModule().addModuleFlag(llvm::Module::Override,
"kcfi", 1);
1130 if (CodeGenOpts.PatchableFunctionEntryOffset)
1131 getModule().addModuleFlag(llvm::Module::Override,
"kcfi-offset",
1132 CodeGenOpts.PatchableFunctionEntryOffset);
1135 if (CodeGenOpts.CFProtectionReturn &&
1138 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-return",
1142 if (CodeGenOpts.CFProtectionBranch &&
1145 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-branch",
1149 if (CodeGenOpts.FunctionReturnThunks)
1150 getModule().addModuleFlag(llvm::Module::Override,
"function_return_thunk_extern", 1);
1152 if (CodeGenOpts.IndirectBranchCSPrefix)
1153 getModule().addModuleFlag(llvm::Module::Override,
"indirect_branch_cs_prefix", 1);
1165 LangOpts.getSignReturnAddressScope() !=
1167 getModule().addModuleFlag(llvm::Module::Override,
1168 "sign-return-address-buildattr", 1);
1169 if (LangOpts.
Sanitize.
has(SanitizerKind::MemtagStack))
1170 getModule().addModuleFlag(llvm::Module::Override,
1171 "tag-stack-memory-buildattr", 1);
1173 if (T.isARM() || T.isThumb() || T.isAArch64()) {
1174 if (LangOpts.BranchTargetEnforcement)
1175 getModule().addModuleFlag(llvm::Module::Min,
"branch-target-enforcement",
1177 if (LangOpts.BranchProtectionPAuthLR)
1178 getModule().addModuleFlag(llvm::Module::Min,
"branch-protection-pauth-lr",
1180 if (LangOpts.GuardedControlStack)
1181 getModule().addModuleFlag(llvm::Module::Min,
"guarded-control-stack", 1);
1183 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address", 1);
1185 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address-all",
1188 getModule().addModuleFlag(llvm::Module::Min,
1189 "sign-return-address-with-bkey", 1);
1192 if (CodeGenOpts.StackClashProtector)
1194 llvm::Module::Override,
"probe-stack",
1195 llvm::MDString::get(TheModule.getContext(),
"inline-asm"));
1197 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
1198 getModule().addModuleFlag(llvm::Module::Min,
"stack-probe-size",
1199 CodeGenOpts.StackProbeSize);
1202 llvm::LLVMContext &Ctx = TheModule.getContext();
1204 llvm::Module::Error,
"MemProfProfileFilename",
1208 if (LangOpts.CUDAIsDevice &&
getTriple().isNVPTX()) {
1212 getModule().addModuleFlag(llvm::Module::Override,
"nvvm-reflect-ftz",
1214 llvm::DenormalMode::IEEE);
1217 if (LangOpts.EHAsynch)
1218 getModule().addModuleFlag(llvm::Module::Warning,
"eh-asynch", 1);
1222 getModule().addModuleFlag(llvm::Module::Max,
"openmp", LangOpts.OpenMP);
1224 getModule().addModuleFlag(llvm::Module::Max,
"openmp-device",
1228 if (LangOpts.OpenCL || (LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())) {
1229 EmitOpenCLMetadata();
1237 llvm::Metadata *SPIRVerElts[] = {
1238 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1240 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1241 Int32Ty, (Version / 100 > 1) ? 0 : 2))};
1242 llvm::NamedMDNode *SPIRVerMD =
1243 TheModule.getOrInsertNamedMetadata(
"opencl.spir.version");
1244 llvm::LLVMContext &Ctx = TheModule.getContext();
1245 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
1253 if (uint32_t PLevel = Context.
getLangOpts().PICLevel) {
1254 assert(PLevel < 3 &&
"Invalid PIC Level");
1255 getModule().setPICLevel(
static_cast<llvm::PICLevel::Level
>(PLevel));
1257 getModule().setPIELevel(
static_cast<llvm::PIELevel::Level
>(PLevel));
1261 unsigned CM = llvm::StringSwitch<unsigned>(
getCodeGenOpts().CodeModel)
1262 .Case(
"tiny", llvm::CodeModel::Tiny)
1263 .Case(
"small", llvm::CodeModel::Small)
1264 .Case(
"kernel", llvm::CodeModel::Kernel)
1265 .Case(
"medium", llvm::CodeModel::Medium)
1266 .Case(
"large", llvm::CodeModel::Large)
1269 llvm::CodeModel::Model codeModel =
static_cast<llvm::CodeModel::Model
>(CM);
1272 if ((CM == llvm::CodeModel::Medium || CM == llvm::CodeModel::Large) &&
1274 llvm::Triple::x86_64) {
1280 if (CodeGenOpts.NoPLT)
1283 CodeGenOpts.DirectAccessExternalData !=
1284 getModule().getDirectAccessExternalData()) {
1285 getModule().setDirectAccessExternalData(
1286 CodeGenOpts.DirectAccessExternalData);
1288 if (CodeGenOpts.UnwindTables)
1289 getModule().setUwtable(llvm::UWTableKind(CodeGenOpts.UnwindTables));
1291 switch (CodeGenOpts.getFramePointer()) {
1296 getModule().setFramePointer(llvm::FramePointerKind::NonLeaf);
1299 getModule().setFramePointer(llvm::FramePointerKind::All);
1303 SimplifyPersonality();
1316 EmitVersionIdentMetadata();
1319 EmitCommandLineMetadata();
1327 getModule().setStackProtectorGuardSymbol(
1330 getModule().setStackProtectorGuardOffset(
1335 getModule().addModuleFlag(llvm::Module::Override,
"SkipRaxSetup", 1);
1337 getModule().addModuleFlag(llvm::Module::Override,
"RegCallv4", 1);
1339 if (
getContext().getTargetInfo().getMaxTLSAlign())
1340 getModule().addModuleFlag(llvm::Module::Error,
"MaxTLSAlign",
1341 getContext().getTargetInfo().getMaxTLSAlign());
1359void CodeGenModule::EmitOpenCLMetadata() {
1364 llvm::Metadata *OCLVerElts[] = {
1365 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1367 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1368 Int32Ty, (Version % 100) / 10))};
1369 llvm::NamedMDNode *OCLVerMD =
1370 TheModule.getOrInsertNamedMetadata(
"opencl.ocl.version");
1371 llvm::LLVMContext &Ctx = TheModule.getContext();
1372 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
1375void CodeGenModule::EmitBackendOptionsMetadata(
1378 getModule().addModuleFlag(llvm::Module::Min,
"SmallDataLimit",
1379 CodeGenOpts.SmallDataLimit);
1396 return TBAA->getTypeInfo(QTy);
1415 return TBAA->getAccessInfo(AccessType);
1422 return TBAA->getVTablePtrAccessInfo(VTablePtrType);
1428 return TBAA->getTBAAStructInfo(QTy);
1434 return TBAA->getBaseTypeInfo(QTy);
1440 return TBAA->getAccessTagInfo(Info);
1447 return TBAA->mergeTBAAInfoForCast(SourceInfo,
TargetInfo);
1455 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
1463 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
1469 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
1474 I->setMetadata(llvm::LLVMContext::MD_invariant_group,
1487 "cannot compile this %0 yet");
1488 std::string Msg =
Type;
1490 << Msg << S->getSourceRange();
1497 "cannot compile this %0 yet");
1498 std::string Msg =
Type;
1509 if (GV->hasLocalLinkage()) {
1510 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1524 Context.
getLangOpts().OpenMPIsTargetDevice && isa<VarDecl>(D) &&
1525 D->
hasAttr<OMPDeclareTargetDeclAttr>() &&
1526 D->
getAttr<OMPDeclareTargetDeclAttr>()->getDevType() !=
1527 OMPDeclareTargetDeclAttr::DT_NoHost &&
1529 GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
1533 if (GV->hasDLLExportStorageClass() || GV->hasDLLImportStorageClass()) {
1537 if (GV->hasDLLExportStorageClass()) {
1540 diag::err_hidden_visibility_dllexport);
1543 diag::err_non_default_visibility_dllimport);
1549 !GV->isDeclarationForLinker())
1554 llvm::GlobalValue *GV) {
1555 if (GV->hasLocalLinkage())
1558 if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
1562 if (GV->hasDLLImportStorageClass())
1565 const llvm::Triple &TT = CGM.
getTriple();
1567 if (TT.isWindowsGNUEnvironment()) {
1576 if (GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&
1585 if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
1593 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
1597 if (!TT.isOSBinFormatELF())
1603 if (RM != llvm::Reloc::Static && !LOpts.PIE) {
1609 if (!(isa<llvm::Function>(GV) && GV->canBenefitFromLocalAlias()))
1611 return !(CGM.
getLangOpts().SemanticInterposition ||
1616 if (!GV->isDeclarationForLinker())
1622 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
1629 if (CGOpts.DirectAccessExternalData) {
1635 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
1636 if (!Var->isThreadLocal())
1645 if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
1661 const auto *D = dyn_cast<NamedDecl>(GD.
getDecl());
1663 if (
const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) {
1673 if (D->
hasAttr<DLLImportAttr>())
1674 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
1675 else if ((D->
hasAttr<DLLExportAttr>() ||
1677 !GV->isDeclarationForLinker())
1678 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
1702 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
1703 .Case(
"global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
1704 .Case(
"local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
1705 .Case(
"initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
1706 .Case(
"local-exec", llvm::GlobalVariable::LocalExecTLSModel);
1709llvm::GlobalVariable::ThreadLocalMode
1711 switch (CodeGenOpts.getDefaultTLSModel()) {
1713 return llvm::GlobalVariable::GeneralDynamicTLSModel;
1715 return llvm::GlobalVariable::LocalDynamicTLSModel;
1717 return llvm::GlobalVariable::InitialExecTLSModel;
1719 return llvm::GlobalVariable::LocalExecTLSModel;
1721 llvm_unreachable(
"Invalid TLS model!");
1725 assert(D.
getTLSKind() &&
"setting TLS mode on non-TLS var!");
1727 llvm::GlobalValue::ThreadLocalMode TLM;
1731 if (
const TLSModelAttr *
Attr = D.
getAttr<TLSModelAttr>()) {
1735 GV->setThreadLocalMode(TLM);
1741 return (Twine(
'.') + Twine(
Target.CPUSpecificManglingCharacter(Name))).str();
1745 const CPUSpecificAttr *
Attr,
1767 bool OmitMultiVersionMangling =
false) {
1769 llvm::raw_svector_ostream Out(Buffer);
1778 assert(II &&
"Attempt to mangle unnamed decl.");
1779 const auto *FD = dyn_cast<FunctionDecl>(ND);
1784 Out <<
"__regcall4__" << II->
getName();
1786 Out <<
"__regcall3__" << II->
getName();
1787 }
else if (FD && FD->hasAttr<CUDAGlobalAttr>() &&
1789 Out <<
"__device_stub__" << II->
getName();
1805 "Hash computed when not explicitly requested");
1809 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
1810 if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
1811 switch (FD->getMultiVersionKind()) {
1815 FD->getAttr<CPUSpecificAttr>(),
1819 auto *
Attr = FD->getAttr<TargetAttr>();
1821 Info.appendAttributeMangling(
Attr, Out);
1825 auto *
Attr = FD->getAttr<TargetVersionAttr>();
1827 Info.appendAttributeMangling(
Attr, Out);
1831 auto *
Attr = FD->getAttr<TargetClonesAttr>();
1838 llvm_unreachable(
"None multiversion type isn't valid here");
1848 return std::string(Out.str());
1851void CodeGenModule::UpdateMultiVersionNames(
GlobalDecl GD,
1853 StringRef &CurName) {
1860 std::string NonTargetName =
1868 "Other GD should now be a multiversioned function");
1878 if (OtherName != NonTargetName) {
1881 const auto ExistingRecord = Manglings.find(NonTargetName);
1882 if (ExistingRecord != std::end(Manglings))
1883 Manglings.remove(&(*ExistingRecord));
1884 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
1889 CurName = OtherNameRef;
1891 Entry->setName(OtherName);
1901 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.
getDecl())) {
1915 auto FoundName = MangledDeclNames.find(CanonicalGD);
1916 if (FoundName != MangledDeclNames.end())
1917 return FoundName->second;
1921 const auto *ND = cast<NamedDecl>(GD.
getDecl());
1933 assert(!isa<FunctionDecl>(ND) || !ND->hasAttr<CUDAGlobalAttr>() ||
1944 auto Result = Manglings.insert(std::make_pair(MangledName, GD));
1945 return MangledDeclNames[CanonicalGD] =
Result.first->first();
1954 llvm::raw_svector_ostream Out(Buffer);
1957 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.
getDecl()), Out);
1958 else if (
const auto *CD = dyn_cast<CXXConstructorDecl>(D))
1960 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(D))
1963 MangleCtx.
mangleBlock(cast<DeclContext>(D), BD, Out);
1965 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
1966 return Result.first->first();
1970 auto it = MangledDeclNames.begin();
1971 while (it != MangledDeclNames.end()) {
1972 if (it->second == Name)
1987 llvm::Constant *AssociatedData) {
1995 bool IsDtorAttrFunc) {
1996 if (CodeGenOpts.RegisterGlobalDtorsWithAtExit &&
1998 DtorsUsingAtExit[
Priority].push_back(Dtor);
2006void CodeGenModule::EmitCtorList(CtorList &Fns,
const char *GlobalName) {
2007 if (Fns.empty())
return;
2010 llvm::FunctionType* CtorFTy = llvm::FunctionType::get(
VoidTy,
false);
2011 llvm::Type *CtorPFTy = llvm::PointerType::get(CtorFTy,
2012 TheModule.getDataLayout().getProgramAddressSpace());
2015 llvm::StructType *CtorStructTy = llvm::StructType::get(
2020 auto ctors = builder.beginArray(CtorStructTy);
2021 for (
const auto &I : Fns) {
2022 auto ctor = ctors.beginStruct(CtorStructTy);
2023 ctor.addInt(
Int32Ty, I.Priority);
2024 ctor.add(I.Initializer);
2025 if (I.AssociatedData)
2026 ctor.add(I.AssociatedData);
2029 ctor.finishAndAddTo(ctors);
2035 llvm::GlobalValue::AppendingLinkage);
2039 list->setAlignment(std::nullopt);
2044llvm::GlobalValue::LinkageTypes
2046 const auto *D = cast<FunctionDecl>(GD.
getDecl());
2050 if (
const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
2057 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
2058 if (!MDS)
return nullptr;
2060 return llvm::ConstantInt::get(
Int64Ty, llvm::MD5Hash(MDS->getString()));
2066 FnType->getReturnType(), FnType->getParamTypes(),
2067 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
2069 std::string OutName;
2070 llvm::raw_string_ostream Out(OutName);
2075 Out <<
".normalized";
2077 return llvm::ConstantInt::get(
Int32Ty,
2078 static_cast<uint32_t
>(llvm::xxHash64(OutName)));
2083 llvm::Function *F,
bool IsThunk) {
2085 llvm::AttributeList PAL;
2088 F->setAttributes(PAL);
2089 F->setCallingConv(
static_cast<llvm::CallingConv::ID
>(
CallingConv));
2093 std::string ReadOnlyQual(
"__read_only");
2094 std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
2095 if (ReadOnlyPos != std::string::npos)
2097 TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);
2099 std::string WriteOnlyQual(
"__write_only");
2100 std::string::size_type WriteOnlyPos = TyName.find(WriteOnlyQual);
2101 if (WriteOnlyPos != std::string::npos)
2102 TyName.erase(WriteOnlyPos, WriteOnlyQual.size() + 1);
2104 std::string ReadWriteQual(
"__read_write");
2105 std::string::size_type ReadWritePos = TyName.find(ReadWriteQual);
2106 if (ReadWritePos != std::string::npos)
2107 TyName.erase(ReadWritePos, ReadWriteQual.size() + 1);
2140 assert(((FD && CGF) || (!FD && !CGF)) &&
2141 "Incorrect use - FD and CGF should either be both null or not!");
2167 for (
unsigned i = 0, e = FD->
getNumParams(); i != e; ++i) {
2170 argNames.push_back(llvm::MDString::get(VMContext, parm->
getName()));
2175 std::string typeQuals;
2179 const Decl *PDecl = parm;
2181 PDecl = TD->getDecl();
2182 const OpenCLAccessAttr *A = PDecl->
getAttr<OpenCLAccessAttr>();
2183 if (A && A->isWriteOnly())
2184 accessQuals.push_back(llvm::MDString::get(VMContext,
"write_only"));
2185 else if (A && A->isReadWrite())
2186 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_write"));
2188 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_only"));
2190 accessQuals.push_back(llvm::MDString::get(VMContext,
"none"));
2192 auto getTypeSpelling = [&](
QualType Ty) {
2193 auto typeName = Ty.getUnqualifiedType().getAsString(Policy);
2195 if (Ty.isCanonical()) {
2196 StringRef typeNameRef = typeName;
2198 if (typeNameRef.consume_front(
"unsigned "))
2199 return std::string(
"u") + typeNameRef.str();
2200 if (typeNameRef.consume_front(
"signed "))
2201 return typeNameRef.str();
2211 addressQuals.push_back(
2212 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(
2216 std::string typeName = getTypeSpelling(pointeeTy) +
"*";
2217 std::string baseTypeName =
2219 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2220 argBaseTypeNames.push_back(
2221 llvm::MDString::get(VMContext, baseTypeName));
2225 typeQuals =
"restrict";
2228 typeQuals += typeQuals.empty() ?
"const" :
" const";
2230 typeQuals += typeQuals.empty() ?
"volatile" :
" volatile";
2232 uint32_t AddrSpc = 0;
2237 addressQuals.push_back(
2238 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(AddrSpc)));
2242 std::string typeName = getTypeSpelling(ty);
2254 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2255 argBaseTypeNames.push_back(
2256 llvm::MDString::get(VMContext, baseTypeName));
2261 argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));
2265 Fn->setMetadata(
"kernel_arg_addr_space",
2266 llvm::MDNode::get(VMContext, addressQuals));
2267 Fn->setMetadata(
"kernel_arg_access_qual",
2268 llvm::MDNode::get(VMContext, accessQuals));
2269 Fn->setMetadata(
"kernel_arg_type",
2270 llvm::MDNode::get(VMContext, argTypeNames));
2271 Fn->setMetadata(
"kernel_arg_base_type",
2272 llvm::MDNode::get(VMContext, argBaseTypeNames));
2273 Fn->setMetadata(
"kernel_arg_type_qual",
2274 llvm::MDNode::get(VMContext, argTypeQuals));
2278 Fn->setMetadata(
"kernel_arg_name",
2279 llvm::MDNode::get(VMContext, argNames));
2289 if (!LangOpts.Exceptions)
return false;
2292 if (LangOpts.CXXExceptions)
return true;
2295 if (LangOpts.ObjCExceptions) {
2312 !isa<CXXConstructorDecl, CXXDestructorDecl>(MD);
2317 llvm::SetVector<const CXXRecordDecl *> MostBases;
2319 std::function<void (
const CXXRecordDecl *)> CollectMostBases;
2322 MostBases.insert(RD);
2324 CollectMostBases(B.getType()->getAsCXXRecordDecl());
2326 CollectMostBases(RD);
2327 return MostBases.takeVector();
2331 llvm::Function *F) {
2332 llvm::AttrBuilder B(F->getContext());
2334 if ((!D || !D->
hasAttr<NoUwtableAttr>()) && CodeGenOpts.UnwindTables)
2335 B.addUWTableAttr(llvm::UWTableKind(CodeGenOpts.UnwindTables));
2337 if (CodeGenOpts.StackClashProtector)
2338 B.addAttribute(
"probe-stack",
"inline-asm");
2340 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
2341 B.addAttribute(
"stack-probe-size",
2342 std::to_string(CodeGenOpts.StackProbeSize));
2345 B.addAttribute(llvm::Attribute::NoUnwind);
2347 if (D && D->
hasAttr<NoStackProtectorAttr>())
2349 else if (D && D->
hasAttr<StrictGuardStackCheckAttr>() &&
2351 B.addAttribute(llvm::Attribute::StackProtectStrong);
2353 B.addAttribute(llvm::Attribute::StackProtect);
2355 B.addAttribute(llvm::Attribute::StackProtectStrong);
2357 B.addAttribute(llvm::Attribute::StackProtectReq);
2363 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
2365 B.addAttribute(llvm::Attribute::NoInline);
2373 if (D->
hasAttr<ArmLocallyStreamingAttr>())
2374 B.addAttribute(
"aarch64_pstate_sm_body");
2377 if (
Attr->isNewZA())
2378 B.addAttribute(
"aarch64_new_za");
2379 if (
Attr->isNewZT0())
2380 B.addAttribute(
"aarch64_new_zt0");
2385 bool ShouldAddOptNone =
2386 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
2388 ShouldAddOptNone &= !D->
hasAttr<MinSizeAttr>();
2389 ShouldAddOptNone &= !D->
hasAttr<AlwaysInlineAttr>();
2392 if ((ShouldAddOptNone || D->
hasAttr<OptimizeNoneAttr>()) &&
2393 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2394 B.addAttribute(llvm::Attribute::OptimizeNone);
2397 B.addAttribute(llvm::Attribute::NoInline);
2402 B.addAttribute(llvm::Attribute::Naked);
2405 F->removeFnAttr(llvm::Attribute::OptimizeForSize);
2406 F->removeFnAttr(llvm::Attribute::MinSize);
2407 }
else if (D->
hasAttr<NakedAttr>()) {
2409 B.addAttribute(llvm::Attribute::Naked);
2410 B.addAttribute(llvm::Attribute::NoInline);
2411 }
else if (D->
hasAttr<NoDuplicateAttr>()) {
2412 B.addAttribute(llvm::Attribute::NoDuplicate);
2413 }
else if (D->
hasAttr<NoInlineAttr>() && !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2415 B.addAttribute(llvm::Attribute::NoInline);
2416 }
else if (D->
hasAttr<AlwaysInlineAttr>() &&
2417 !F->hasFnAttribute(llvm::Attribute::NoInline)) {
2419 B.addAttribute(llvm::Attribute::AlwaysInline);
2423 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
2424 B.addAttribute(llvm::Attribute::NoInline);
2428 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
2431 auto CheckRedeclForInline = [](
const FunctionDecl *Redecl) {
2432 return Redecl->isInlineSpecified();
2434 if (any_of(FD->
redecls(), CheckRedeclForInline))
2439 return any_of(Pattern->
redecls(), CheckRedeclForInline);
2441 if (CheckForInline(FD)) {
2442 B.addAttribute(llvm::Attribute::InlineHint);
2443 }
else if (CodeGenOpts.getInlining() ==
2446 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2447 B.addAttribute(llvm::Attribute::NoInline);
2454 if (!D->
hasAttr<OptimizeNoneAttr>()) {
2456 if (!ShouldAddOptNone)
2457 B.addAttribute(llvm::Attribute::OptimizeForSize);
2458 B.addAttribute(llvm::Attribute::Cold);
2461 B.addAttribute(llvm::Attribute::Hot);
2462 if (D->
hasAttr<MinSizeAttr>())
2463 B.addAttribute(llvm::Attribute::MinSize);
2470 F->setAlignment(llvm::Align(alignment));
2472 if (!D->
hasAttr<AlignedAttr>())
2473 if (LangOpts.FunctionAlignment)
2474 F->setAlignment(llvm::Align(1ull << LangOpts.FunctionAlignment));
2481 if (isa<CXXMethodDecl>(D) && F->getPointerAlignment(
getDataLayout()) < 2)
2482 F->setAlignment(std::max(llvm::Align(2), F->getAlign().valueOrOne()));
2487 if (CodeGenOpts.SanitizeCfiCrossDso &&
2488 CodeGenOpts.SanitizeCfiCanonicalJumpTables) {
2489 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
2500 auto *MD = dyn_cast<CXXMethodDecl>(D);
2503 llvm::Metadata *
Id =
2506 F->addTypeMetadata(0,
Id);
2513 if (isa_and_nonnull<NamedDecl>(D))
2516 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
2518 if (D && D->
hasAttr<UsedAttr>())
2521 if (
const auto *VD = dyn_cast_if_present<VarDecl>(D);
2523 ((CodeGenOpts.KeepPersistentStorageVariables &&
2524 (VD->getStorageDuration() ==
SD_Static ||
2525 VD->getStorageDuration() ==
SD_Thread)) ||
2526 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==
SD_Static &&
2527 VD->getType().isConstQualified())))
2531bool CodeGenModule::GetCPUAndFeaturesAttributes(
GlobalDecl GD,
2532 llvm::AttrBuilder &Attrs,
2533 bool SetTargetFeatures) {
2539 std::vector<std::string> Features;
2540 const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.
getDecl());
2542 const auto *TD = FD ? FD->
getAttr<TargetAttr>() :
nullptr;
2543 const auto *TV = FD ? FD->
getAttr<TargetVersionAttr>() :
nullptr;
2544 assert((!TD || !TV) &&
"both target_version and target specified");
2545 const auto *SD = FD ? FD->
getAttr<CPUSpecificAttr>() :
nullptr;
2546 const auto *TC = FD ? FD->
getAttr<TargetClonesAttr>() :
nullptr;
2547 bool AddedAttr =
false;
2548 if (TD || TV || SD || TC) {
2549 llvm::StringMap<bool> FeatureMap;
2553 for (
const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
2554 Features.push_back((Entry.getValue() ?
"+" :
"-") + Entry.getKey().str());
2562 Target.parseTargetAttr(TD->getFeaturesStr());
2584 if (!TargetCPU.empty()) {
2585 Attrs.addAttribute(
"target-cpu", TargetCPU);
2588 if (!TuneCPU.empty()) {
2589 Attrs.addAttribute(
"tune-cpu", TuneCPU);
2592 if (!Features.empty() && SetTargetFeatures) {
2593 llvm::erase_if(Features, [&](
const std::string& F) {
2596 llvm::sort(Features);
2597 Attrs.addAttribute(
"target-features", llvm::join(Features,
","));
2604void CodeGenModule::setNonAliasAttributes(
GlobalDecl GD,
2605 llvm::GlobalObject *GO) {
2610 if (
auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
2613 if (
auto *SA = D->
getAttr<PragmaClangBSSSectionAttr>())
2614 GV->addAttribute(
"bss-section", SA->getName());
2615 if (
auto *SA = D->
getAttr<PragmaClangDataSectionAttr>())
2616 GV->addAttribute(
"data-section", SA->getName());
2617 if (
auto *SA = D->
getAttr<PragmaClangRodataSectionAttr>())
2618 GV->addAttribute(
"rodata-section", SA->getName());
2619 if (
auto *SA = D->
getAttr<PragmaClangRelroSectionAttr>())
2620 GV->addAttribute(
"relro-section", SA->getName());
2623 if (
auto *F = dyn_cast<llvm::Function>(GO)) {
2626 if (
auto *SA = D->
getAttr<PragmaClangTextSectionAttr>())
2627 if (!D->
getAttr<SectionAttr>())
2628 F->addFnAttr(
"implicit-section-name", SA->getName());
2630 llvm::AttrBuilder Attrs(F->getContext());
2631 if (GetCPUAndFeaturesAttributes(GD, Attrs)) {
2635 llvm::AttributeMask RemoveAttrs;
2636 RemoveAttrs.addAttribute(
"target-cpu");
2637 RemoveAttrs.addAttribute(
"target-features");
2638 RemoveAttrs.addAttribute(
"tune-cpu");
2639 F->removeFnAttrs(RemoveAttrs);
2640 F->addFnAttrs(Attrs);
2644 if (
const auto *CSA = D->
getAttr<CodeSegAttr>())
2645 GO->setSection(CSA->getName());
2646 else if (
const auto *SA = D->
getAttr<SectionAttr>())
2647 GO->setSection(SA->getName());
2660 F->setLinkage(llvm::Function::InternalLinkage);
2662 setNonAliasAttributes(GD, F);
2673 GV->
setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
2677 llvm::Function *F) {
2679 if (!LangOpts.
Sanitize.
has(SanitizerKind::CFIICall))
2684 if (isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())
2688 F->addTypeMetadata(0, MD);
2692 if (CodeGenOpts.SanitizeCfiCrossDso)
2694 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
2698 llvm::LLVMContext &Ctx = F->getContext();
2699 llvm::MDBuilder MDB(Ctx);
2700 F->setMetadata(llvm::LLVMContext::MD_kcfi_type,
2709 return llvm::all_of(Name, [](
const char &
C) {
2710 return llvm::isAlnum(
C) ||
C ==
'_' ||
C ==
'.';
2716 for (
auto &F : M.functions()) {
2718 bool AddressTaken = F.hasAddressTaken();
2719 if (!AddressTaken && F.hasLocalLinkage())
2720 F.eraseMetadata(llvm::LLVMContext::MD_kcfi_type);
2725 if (!AddressTaken || !F.isDeclaration())
2728 const llvm::ConstantInt *
Type;
2729 if (
const llvm::MDNode *MD = F.getMetadata(llvm::LLVMContext::MD_kcfi_type))
2730 Type = llvm::mdconst::extract<llvm::ConstantInt>(MD->getOperand(0));
2734 StringRef Name = F.getName();
2738 std::string
Asm = (
".weak __kcfi_typeid_" + Name +
"\n.set __kcfi_typeid_" +
2739 Name +
", " + Twine(
Type->getZExtValue()) +
"\n")
2741 M.appendModuleInlineAsm(
Asm);
2745void CodeGenModule::SetFunctionAttributes(
GlobalDecl GD, llvm::Function *F,
2746 bool IsIncompleteFunction,
2749 if (llvm::Intrinsic::ID IID = F->getIntrinsicID()) {
2752 F->setAttributes(llvm::Intrinsic::getAttributes(
getLLVMContext(), IID));
2756 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
2758 if (!IsIncompleteFunction)
2765 if (!IsThunk &&
getCXXABI().HasThisReturn(GD) &&
2767 assert(!F->arg_empty() &&
2768 F->arg_begin()->getType()
2769 ->canLosslesslyBitCastTo(F->getReturnType()) &&
2770 "unexpected this return");
2771 F->addParamAttr(0, llvm::Attribute::Returned);
2781 if (!IsIncompleteFunction && F->isDeclaration())
2784 if (
const auto *CSA = FD->
getAttr<CodeSegAttr>())
2785 F->setSection(CSA->getName());
2786 else if (
const auto *SA = FD->
getAttr<SectionAttr>())
2787 F->setSection(SA->getName());
2789 if (
const auto *EA = FD->
getAttr<ErrorAttr>()) {
2791 F->addFnAttr(
"dontcall-error", EA->getUserDiagnostic());
2792 else if (EA->isWarning())
2793 F->addFnAttr(
"dontcall-warn", EA->getUserDiagnostic());
2799 bool HasBody = FD->
hasBody(FDBody);
2801 assert(HasBody &&
"Inline builtin declarations should always have an "
2803 if (shouldEmitFunction(FDBody))
2804 F->addFnAttr(llvm::Attribute::NoBuiltin);
2810 F->addFnAttr(llvm::Attribute::NoBuiltin);
2813 if (isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))
2814 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2815 else if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
2816 if (MD->isVirtual())
2817 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
2823 if (!CodeGenOpts.SanitizeCfiCrossDso ||
2824 !CodeGenOpts.SanitizeCfiCanonicalJumpTables)
2833 if (CodeGenOpts.InlineMaxStackSize !=
UINT_MAX)
2834 F->addFnAttr(
"inline-max-stacksize", llvm::utostr(CodeGenOpts.InlineMaxStackSize));
2836 if (
const auto *CB = FD->
getAttr<CallbackAttr>()) {
2840 llvm::LLVMContext &Ctx = F->getContext();
2841 llvm::MDBuilder MDB(Ctx);
2845 int CalleeIdx = *CB->encoding_begin();
2846 ArrayRef<int> PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());
2847 F->addMetadata(llvm::LLVMContext::MD_callback,
2848 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
2849 CalleeIdx, PayloadIndices,
2855 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
2856 "Only globals with definition can force usage.");
2857 LLVMUsed.emplace_back(GV);
2861 assert(!GV->isDeclaration() &&
2862 "Only globals with definition can force usage.");
2863 LLVMCompilerUsed.emplace_back(GV);
2867 assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&
2868 "Only globals with definition can force usage.");
2870 LLVMCompilerUsed.emplace_back(GV);
2872 LLVMUsed.emplace_back(GV);
2876 std::vector<llvm::WeakTrackingVH> &List) {
2883 UsedArray.resize(List.size());
2884 for (
unsigned i = 0, e = List.size(); i != e; ++i) {
2886 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
2887 cast<llvm::Constant>(&*List[i]), CGM.
Int8PtrTy);
2890 if (UsedArray.empty())
2892 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.
Int8PtrTy, UsedArray.size());
2894 auto *GV =
new llvm::GlobalVariable(
2895 CGM.
getModule(), ATy,
false, llvm::GlobalValue::AppendingLinkage,
2896 llvm::ConstantArray::get(ATy, UsedArray), Name);
2898 GV->setSection(
"llvm.metadata");
2901void CodeGenModule::emitLLVMUsed() {
2902 emitUsed(*
this,
"llvm.used", LLVMUsed);
2903 emitUsed(*
this,
"llvm.compiler.used", LLVMCompilerUsed);
2908 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
2917 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
2923 ELFDependentLibraries.push_back(
2924 llvm::MDNode::get(
C, llvm::MDString::get(
C, Lib)));
2931 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
C, MDOpts));
2946 if (
Visited.insert(Import).second)
2963 if (LL.IsFramework) {
2964 llvm::Metadata *Args[2] = {llvm::MDString::get(Context,
"-framework"),
2965 llvm::MDString::get(Context, LL.Library)};
2967 Metadata.push_back(llvm::MDNode::get(Context, Args));
2973 llvm::Metadata *Args[2] = {
2974 llvm::MDString::get(Context,
"lib"),
2975 llvm::MDString::get(Context, LL.Library),
2977 Metadata.push_back(llvm::MDNode::get(Context, Args));
2981 auto *OptString = llvm::MDString::get(Context, Opt);
2982 Metadata.push_back(llvm::MDNode::get(Context, OptString));
2987void CodeGenModule::EmitModuleInitializers(
clang::Module *Primary) {
2989 "We should only emit module initializers for named modules.");
2995 if (isa<ImportDecl>(D))
2997 assert(isa<VarDecl>(D) &&
"GMF initializer decl is not a var?");
3004 if (isa<ImportDecl>(D))
3012 if (isa<ImportDecl>(D))
3014 assert(isa<VarDecl>(D) &&
"PMF initializer decl is not a var?");
3020void CodeGenModule::EmitModuleLinkOptions() {
3024 llvm::SetVector<clang::Module *> LinkModules;
3029 for (
Module *M : ImportedModules) {
3032 if (M->getTopLevelModuleName() ==
getLangOpts().CurrentModule &&
3041 while (!Stack.empty()) {
3044 bool AnyChildren =
false;
3054 Stack.push_back(
SM);
3062 LinkModules.insert(Mod);
3071 for (
Module *M : LinkModules)
3074 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
3075 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
3078 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.linker.options");
3079 for (
auto *MD : LinkerOptionsMetadata)
3080 NMD->addOperand(MD);
3083void CodeGenModule::EmitDeferred() {
3092 if (!DeferredVTables.empty()) {
3093 EmitDeferredVTables();
3098 assert(DeferredVTables.empty());
3105 llvm::append_range(DeferredDeclsToEmit,
3109 if (DeferredDeclsToEmit.empty())
3114 std::vector<GlobalDecl> CurDeclsToEmit;
3115 CurDeclsToEmit.swap(DeferredDeclsToEmit);
3122 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
3140 if (!GV->isDeclaration())
3144 if (LangOpts.OpenMP && OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(D))
3148 EmitGlobalDefinition(D, GV);
3153 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
3155 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
3160void CodeGenModule::EmitVTablesOpportunistically() {
3166 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
3167 &&
"Only emit opportunistic vtables with optimizations");
3171 "This queue should only contain external vtables");
3172 if (
getCXXABI().canSpeculativelyEmitVTable(RD))
3175 OpportunisticVTables.clear();
3179 for (
const auto& [MangledName, VD] : DeferredAnnotations) {
3184 DeferredAnnotations.clear();
3186 if (Annotations.empty())
3190 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
3191 Annotations[0]->getType(), Annotations.size()), Annotations);
3192 auto *gv =
new llvm::GlobalVariable(
getModule(), Array->getType(),
false,
3193 llvm::GlobalValue::AppendingLinkage,
3194 Array,
"llvm.global.annotations");
3199 llvm::Constant *&AStr = AnnotationStrings[Str];
3204 llvm::Constant *
s = llvm::ConstantDataArray::getString(
getLLVMContext(), Str);
3205 auto *gv =
new llvm::GlobalVariable(
3206 getModule(),
s->getType(),
true, llvm::GlobalValue::PrivateLinkage,
s,
3207 ".str",
nullptr, llvm::GlobalValue::NotThreadLocal,
3210 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3227 SM.getExpansionLineNumber(L);
3228 return llvm::ConstantInt::get(
Int32Ty, LineNo);
3236 llvm::FoldingSetNodeID ID;
3237 for (
Expr *E : Exprs) {
3238 ID.Add(cast<clang::ConstantExpr>(E)->getAPValueResult());
3240 llvm::Constant *&Lookup = AnnotationArgs[ID.ComputeHash()];
3245 LLVMArgs.reserve(Exprs.size());
3247 llvm::transform(Exprs, std::back_inserter(LLVMArgs), [&](
const Expr *E) {
3248 const auto *CE = cast<clang::ConstantExpr>(E);
3249 return ConstEmiter.
emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(),
3252 auto *
Struct = llvm::ConstantStruct::getAnon(LLVMArgs);
3253 auto *GV =
new llvm::GlobalVariable(
getModule(),
Struct->getType(),
true,
3254 llvm::GlobalValue::PrivateLinkage,
Struct,
3257 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3264 const AnnotateAttr *AA,
3272 llvm::Constant *GVInGlobalsAS = GV;
3273 if (GV->getAddressSpace() !=
3275 GVInGlobalsAS = llvm::ConstantExpr::getAddrSpaceCast(
3277 llvm::PointerType::get(
3278 GV->getContext(),
getDataLayout().getDefaultGlobalsAddressSpace()));
3282 llvm::Constant *Fields[] = {
3283 GVInGlobalsAS, AnnoGV, UnitGV, LineNoCst, Args,
3285 return llvm::ConstantStruct::getAnon(Fields);
3289 llvm::GlobalValue *GV) {
3290 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
3300 if (NoSanitizeL.containsFunction(Kind, Fn->getName()))
3305 if (NoSanitizeL.containsMainFile(Kind, MainFile.
getName()))
3310 return NoSanitizeL.containsLocation(Kind, Loc);
3313 return NoSanitizeL.containsFile(Kind, MainFile.
getName());
3317 llvm::GlobalVariable *GV,
3321 if (NoSanitizeL.containsGlobal(Kind, GV->getName(),
Category))
3324 if (NoSanitizeL.containsMainFile(
3325 Kind,
SM.getFileEntryRefForID(
SM.getMainFileID())->getName(),
3328 if (NoSanitizeL.containsLocation(Kind, Loc,
Category))
3335 while (
auto AT = dyn_cast<ArrayType>(Ty.
getTypePtr()))
3336 Ty = AT->getElementType();
3341 if (NoSanitizeL.containsType(Kind, TypeStr,
Category))
3352 auto Attr = ImbueAttr::NONE;
3355 if (
Attr == ImbueAttr::NONE)
3356 Attr = XRayFilter.shouldImbueFunction(Fn->getName());
3358 case ImbueAttr::NONE:
3360 case ImbueAttr::ALWAYS:
3361 Fn->addFnAttr(
"function-instrument",
"xray-always");
3363 case ImbueAttr::ALWAYS_ARG1:
3364 Fn->addFnAttr(
"function-instrument",
"xray-always");
3365 Fn->addFnAttr(
"xray-log-args",
"1");
3367 case ImbueAttr::NEVER:
3368 Fn->addFnAttr(
"function-instrument",
"xray-never");
3392 if (
auto MainFile =
SM.getFileEntryRefForID(
SM.getMainFileID()))
3406 if (NumGroups > 1) {
3407 auto Group = llvm::crc32(arrayRefFromStringRef(Fn->getName())) % NumGroups;
3414bool CodeGenModule::MustBeEmitted(
const ValueDecl *Global) {
3416 if (LangOpts.EmitAllDecls)
3419 const auto *VD = dyn_cast<VarDecl>(Global);
3421 ((CodeGenOpts.KeepPersistentStorageVariables &&
3422 (VD->getStorageDuration() ==
SD_Static ||
3423 VD->getStorageDuration() ==
SD_Thread)) ||
3424 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==
SD_Static &&
3425 VD->getType().isConstQualified())))
3431bool CodeGenModule::MayBeEmittedEagerly(
const ValueDecl *Global) {
3438 if (LangOpts.OpenMP >= 50 && !LangOpts.OpenMPSimd) {
3439 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr =
3440 OMPDeclareTargetDeclAttr::getActiveAttr(Global);
3441 if (!ActiveAttr || (*ActiveAttr)->getLevel() != (
unsigned)-1)
3445 if (
const auto *FD = dyn_cast<FunctionDecl>(Global)) {
3451 if (
const auto *VD = dyn_cast<VarDecl>(Global)) {
3457 if (CXX20ModuleInits && VD->getOwningModule() &&
3458 !VD->getOwningModule()->isModuleMapModule()) {
3467 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
3468 getContext().getTargetInfo().isTLSSupported() && isa<VarDecl>(Global) &&
3470 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(Global))
3483 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3487 llvm::Constant *
Init;
3490 if (!
V.isAbsent()) {
3501 llvm::Constant *Fields[4] = {
3505 llvm::ConstantDataArray::getRaw(
3506 StringRef(
reinterpret_cast<char *
>(Parts.
Part4And5), 8), 8,
3508 Init = llvm::ConstantStruct::getAnon(Fields);
3511 auto *GV =
new llvm::GlobalVariable(
3513 true, llvm::GlobalValue::LinkOnceODRLinkage,
Init, Name);
3515 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3518 if (!
V.isAbsent()) {
3531 llvm::GlobalVariable **Entry =
nullptr;
3532 Entry = &UnnamedGlobalConstantDeclMap[GCD];
3537 llvm::Constant *
Init;
3541 assert(!
V.isAbsent());
3545 auto *GV =
new llvm::GlobalVariable(
getModule(),
Init->getType(),
3547 llvm::GlobalValue::PrivateLinkage,
Init,
3549 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3563 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3567 llvm::Constant *
Init =
Emitter.emitForInitializer(
3575 llvm::GlobalValue::LinkageTypes
Linkage =
3577 ? llvm::GlobalValue::LinkOnceODRLinkage
3578 : llvm::GlobalValue::InternalLinkage;
3579 auto *GV =
new llvm::GlobalVariable(
getModule(),
Init->getType(),
3583 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
3590 const AliasAttr *AA = VD->
getAttr<AliasAttr>();
3591 assert(AA &&
"No alias?");
3601 llvm::Constant *Aliasee;
3602 if (isa<llvm::FunctionType>(DeclTy))
3603 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
3610 auto *F = cast<llvm::GlobalValue>(Aliasee);
3611 F->setLinkage(llvm::Function::ExternalWeakLinkage);
3612 WeakRefReferences.insert(F);
3620 if (
auto *A = D->
getAttr<AttrT>())
3621 return A->isImplicit();
3626 const auto *Global = cast<ValueDecl>(GD.
getDecl());
3629 if (Global->
hasAttr<WeakRefAttr>())
3634 if (Global->
hasAttr<AliasAttr>())
3635 return EmitAliasDefinition(GD);
3638 if (Global->
hasAttr<IFuncAttr>())
3639 return emitIFuncDefinition(GD);
3642 if (Global->
hasAttr<CPUDispatchAttr>())
3643 return emitCPUDispatchDefinition(GD);
3648 if (LangOpts.CUDA) {
3649 if (LangOpts.CUDAIsDevice) {
3650 const auto *FD = dyn_cast<FunctionDecl>(Global);
3651 if ((!Global->
hasAttr<CUDADeviceAttr>() ||
3652 (LangOpts.OffloadImplicitHostDeviceTemplates && FD &&
3653 hasImplicitAttr<CUDAHostAttr>(FD) &&
3654 hasImplicitAttr<CUDADeviceAttr>(FD) && !FD->
isConstexpr() &&
3656 !
getContext().CUDAImplicitHostDeviceFunUsedByDevice.count(FD))) &&
3657 !Global->
hasAttr<CUDAGlobalAttr>() &&
3658 !Global->
hasAttr<CUDAConstantAttr>() &&
3659 !Global->
hasAttr<CUDASharedAttr>() &&
3662 !(LangOpts.HIPStdPar && isa<FunctionDecl>(Global) &&
3663 !Global->
hasAttr<CUDAHostAttr>()))
3672 if (isa<FunctionDecl>(Global) && !Global->
hasAttr<CUDAHostAttr>() &&
3673 Global->
hasAttr<CUDADeviceAttr>())
3676 assert((isa<FunctionDecl>(Global) || isa<VarDecl>(Global)) &&
3677 "Expected Variable or Function");
3681 if (LangOpts.OpenMP) {
3683 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
3685 if (
auto *DRD = dyn_cast<OMPDeclareReductionDecl>(Global)) {
3686 if (MustBeEmitted(Global))
3690 if (
auto *DMD = dyn_cast<OMPDeclareMapperDecl>(Global)) {
3691 if (MustBeEmitted(Global))
3698 if (
const auto *FD = dyn_cast<FunctionDecl>(Global)) {
3701 if (FD->
hasAttr<AnnotateAttr>()) {
3704 DeferredAnnotations[MangledName] = FD;
3718 GetOrCreateLLVMFunction(MangledName, Ty, GD,
false,
3723 const auto *VD = cast<VarDecl>(Global);
3724 assert(VD->isFileVarDecl() &&
"Cannot emit local var decl as global.");
3727 if (LangOpts.OpenMP) {
3729 if (std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
3730 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
3734 if (VD->hasExternalStorage() &&
3735 Res != OMPDeclareTargetDeclAttr::MT_Link)
3738 bool UnifiedMemoryEnabled =
3740 if ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3741 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3742 !UnifiedMemoryEnabled) {
3745 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
3746 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
3747 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
3748 UnifiedMemoryEnabled)) &&
3749 "Link clause or to clause with unified memory expected.");
3768 if (MustBeEmitted(Global) && MayBeEmittedEagerly(Global)) {
3770 EmitGlobalDefinition(GD);
3771 addEmittedDeferredDecl(GD);
3778 cast<VarDecl>(Global)->hasInit()) {
3779 DelayedCXXInitPosition[Global] = CXXGlobalInits.size();
3780 CXXGlobalInits.push_back(
nullptr);
3786 addDeferredDeclToEmit(GD);
3787 }
else if (MustBeEmitted(Global)) {
3789 assert(!MayBeEmittedEagerly(Global));
3790 addDeferredDeclToEmit(GD);
3795 DeferredDecls[MangledName] = GD;
3802 if (
CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
3803 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
3810 struct FunctionIsDirectlyRecursive
3812 const StringRef Name;
3817 bool VisitCallExpr(
const CallExpr *E) {
3822 if (
Attr && Name ==
Attr->getLabel())
3827 StringRef BuiltinName = BI.
getName(BuiltinID);
3828 if (BuiltinName.starts_with(
"__builtin_") &&
3829 Name == BuiltinName.slice(strlen(
"__builtin_"), StringRef::npos)) {
3835 bool VisitStmt(
const Stmt *S) {
3836 for (
const Stmt *Child : S->children())
3837 if (Child && this->Visit(Child))
3844 struct DLLImportFunctionVisitor
3846 bool SafeToInline =
true;
3848 bool shouldVisitImplicitCode()
const {
return true; }
3850 bool VisitVarDecl(
VarDecl *VD) {
3853 SafeToInline =
false;
3854 return SafeToInline;
3861 return SafeToInline;
3866 SafeToInline = D->
hasAttr<DLLImportAttr>();
3867 return SafeToInline;
3872 if (isa<FunctionDecl>(VD))
3873 SafeToInline = VD->
hasAttr<DLLImportAttr>();
3874 else if (
VarDecl *
V = dyn_cast<VarDecl>(VD))
3875 SafeToInline = !
V->hasGlobalStorage() ||
V->hasAttr<DLLImportAttr>();
3876 return SafeToInline;
3881 return SafeToInline;
3888 SafeToInline =
true;
3890 SafeToInline = M->
hasAttr<DLLImportAttr>();
3892 return SafeToInline;
3897 return SafeToInline;
3902 return SafeToInline;
3911CodeGenModule::isTriviallyRecursive(
const FunctionDecl *FD) {
3913 if (
getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
3918 Name =
Attr->getLabel();
3923 FunctionIsDirectlyRecursive Walker(Name, Context.
BuiltinInfo);
3925 return Body ? Walker.Visit(Body) :
false;
3928bool CodeGenModule::shouldEmitFunction(
GlobalDecl GD) {
3932 const auto *F = cast<FunctionDecl>(GD.
getDecl());
3933 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
3938 if (
const Module *M = F->getOwningModule();
3939 M && M->getTopLevelModule()->isNamedModule() &&
3940 getContext().getCurrentNamedModule() != M->getTopLevelModule())
3943 if (F->hasAttr<NoInlineAttr>())
3946 if (F->hasAttr<DLLImportAttr>() && !F->hasAttr<AlwaysInlineAttr>()) {
3948 DLLImportFunctionVisitor Visitor;
3949 Visitor.TraverseFunctionDecl(
const_cast<FunctionDecl*
>(F));
3950 if (!Visitor.SafeToInline)
3956 for (
const Decl *
Member : Dtor->getParent()->decls())
3957 if (isa<FieldDecl>(
Member))
3968 if (F->isInlineBuiltinDeclaration())
3976 return !isTriviallyRecursive(F);
3979bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
3980 return CodeGenOpts.OptimizationLevel > 0;
3983void CodeGenModule::EmitMultiVersionFunctionDefinition(
GlobalDecl GD,
3984 llvm::GlobalValue *GV) {
3985 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
3988 auto *Spec = FD->
getAttr<CPUSpecificAttr>();
3989 for (
unsigned I = 0; I < Spec->cpus_size(); ++I)
3992 auto *Clone = FD->
getAttr<TargetClonesAttr>();
3993 for (
unsigned I = 0; I < Clone->featuresStrs_size(); ++I)
3994 if (Clone->isFirstOfVersion(I))
3997 GetOrCreateMultiVersionResolver(GD);
3998 }
else if (FD->
hasAttr<TargetVersionAttr>()) {
3999 GetOrCreateMultiVersionResolver(GD);
4001 EmitGlobalFunctionDefinition(GD, GV);
4004void CodeGenModule::EmitGlobalDefinition(
GlobalDecl GD, llvm::GlobalValue *GV) {
4005 const auto *D = cast<ValueDecl>(GD.
getDecl());
4009 "Generating code for declaration");
4011 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
4014 if (!shouldEmitFunction(GD))
4017 llvm::TimeTraceScope TimeScope(
"CodeGen Function", [&]() {
4019 llvm::raw_string_ostream OS(Name);
4025 if (
const auto *Method = dyn_cast<CXXMethodDecl>(D)) {
4028 if (isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))
4029 ABI->emitCXXStructor(GD);
4031 EmitMultiVersionFunctionDefinition(GD, GV);
4033 EmitGlobalFunctionDefinition(GD, GV);
4035 if (Method->isVirtual())
4042 return EmitMultiVersionFunctionDefinition(GD, GV);
4043 return EmitGlobalFunctionDefinition(GD, GV);
4046 if (
const auto *VD = dyn_cast<VarDecl>(D))
4047 return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
4049 llvm_unreachable(
"Invalid argument to EmitGlobalDefinition()");
4053 llvm::Function *NewFn);
4057 const CodeGenFunction::MultiVersionResolverOption &RO) {
4059 unsigned NumFeatures = 0;
4060 for (StringRef Feat : RO.Conditions.Features) {
4065 if (!RO.Conditions.Architecture.empty())
4083 return llvm::GlobalValue::InternalLinkage;
4084 return llvm::GlobalValue::WeakODRLinkage;
4087void CodeGenModule::emitMultiVersionFunctions() {
4088 std::vector<GlobalDecl> MVFuncsToEmit;
4089 MultiVersionFuncs.swap(MVFuncsToEmit);
4091 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4092 assert(FD &&
"Expected a FunctionDecl");
4104 EmitGlobalFunctionDefinition(CurGD,
nullptr);
4113 assert(
Func &&
"This should have just been created");
4116 const auto *TA = CurFD->
getAttr<TargetAttr>();
4118 TA->getAddedFeatures(Feats);
4119 Options.emplace_back(cast<llvm::Function>(
Func),
4120 TA->getArchitecture(), Feats);
4122 const auto *TVA = CurFD->
getAttr<TargetVersionAttr>();
4124 TVA->getFeatures(Feats);
4125 Options.emplace_back(cast<llvm::Function>(
Func),
4130 const auto *TC = FD->
getAttr<TargetClonesAttr>();
4131 for (
unsigned VersionIndex = 0; VersionIndex < TC->featuresStrs_size();
4133 if (!TC->isFirstOfVersion(VersionIndex))
4137 StringRef Version = TC->getFeatureStr(VersionIndex);
4142 EmitGlobalFunctionDefinition(CurGD,
nullptr);
4151 assert(
Func &&
"This should have just been created");
4154 StringRef Architecture;
4158 if (Version !=
"default") {
4160 Version.split(VerFeats,
"+");
4161 for (
auto &CurFeat : VerFeats)
4162 Feature.push_back(CurFeat.trim());
4165 if (Version.starts_with(
"arch="))
4166 Architecture = Version.drop_front(
sizeof(
"arch=") - 1);
4167 else if (Version !=
"default")
4168 Feature.push_back(Version);
4171 Options.emplace_back(cast<llvm::Function>(
Func), Architecture, Feature);
4174 assert(0 &&
"Expected a target or target_clones multiversion function");
4178 llvm::Constant *ResolverConstant = GetOrCreateMultiVersionResolver(GD);
4179 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(ResolverConstant)) {
4180 ResolverConstant = IFunc->getResolver();
4186 *
this, GD, FD,
true);
4190 auto *Alias = llvm::GlobalAlias::create(
4192 MangledName +
".ifunc", IFunc, &
getModule());
4196 llvm::Function *ResolverFunc = cast<llvm::Function>(ResolverConstant);
4201 ResolverFunc->setComdat(
4202 getModule().getOrInsertComdat(ResolverFunc->getName()));
4206 Options, [&TI](
const CodeGenFunction::MultiVersionResolverOption &LHS,
4207 const CodeGenFunction::MultiVersionResolverOption &RHS) {
4211 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4217 if (!MVFuncsToEmit.empty())
4222 if (!MultiVersionFuncs.empty())
4223 emitMultiVersionFunctions();
4226void CodeGenModule::emitCPUDispatchDefinition(
GlobalDecl GD) {
4227 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4228 assert(FD &&
"Not a FunctionDecl?");
4230 const auto *DD = FD->
getAttr<CPUDispatchAttr>();
4231 assert(DD &&
"Not a cpu_dispatch Function?");
4237 UpdateMultiVersionNames(GD, FD, ResolverName);
4239 llvm::Type *ResolverType;
4242 ResolverType = llvm::FunctionType::get(
4243 llvm::PointerType::get(DeclTy,
4252 auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
4253 ResolverName, ResolverType, ResolverGD,
false));
4256 ResolverFunc->setComdat(
4257 getModule().getOrInsertComdat(ResolverFunc->getName()));
4270 GlobalDecl ExistingDecl = Manglings.lookup(MangledName);
4273 EmitGlobalFunctionDefinition(ExistingDecl,
nullptr);
4279 Func = GetOrCreateLLVMFunction(
4280 MangledName, DeclTy, ExistingDecl,
4287 Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);
4288 llvm::transform(Features, Features.begin(),
4289 [](StringRef Str) { return Str.substr(1); });
4290 llvm::erase_if(Features, [&
Target](StringRef Feat) {
4291 return !
Target.validateCpuSupports(Feat);
4293 Options.emplace_back(cast<llvm::Function>(
Func), StringRef{}, Features);
4298 Options, [](
const CodeGenFunction::MultiVersionResolverOption &LHS,
4299 const CodeGenFunction::MultiVersionResolverOption &RHS) {
4300 return llvm::X86::getCpuSupportsMask(LHS.Conditions.Features) >
4301 llvm::X86::getCpuSupportsMask(RHS.Conditions.Features);
4308 while (Options.size() > 1 &&
4309 llvm::all_of(llvm::X86::getCpuSupportsMask(
4310 (Options.end() - 2)->Conditions.Features),
4311 [](
auto X) { return X == 0; })) {
4312 StringRef LHSName = (Options.end() - 2)->
Function->getName();
4313 StringRef RHSName = (Options.end() - 1)->
Function->getName();
4314 if (LHSName.compare(RHSName) < 0)
4315 Options.erase(Options.end() - 2);
4317 Options.erase(Options.end() - 1);
4321 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4325 auto *IFunc = cast<llvm::GlobalValue>(GetOrCreateMultiVersionResolver(GD));
4329 if (!isa<llvm::GlobalIFunc>(IFunc)) {
4330 assert(cast<llvm::Function>(IFunc)->isDeclaration());
4331 auto *GI = llvm::GlobalIFunc::create(DeclTy, 0,
Linkage,
"", ResolverFunc,
4333 GI->takeName(IFunc);
4334 IFunc->replaceAllUsesWith(GI);
4335 IFunc->eraseFromParent();
4340 *
this, GD, FD,
true);
4343 auto *GA = llvm::GlobalAlias::create(DeclTy, 0,
Linkage, AliasName, IFunc,
4352llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(
GlobalDecl GD) {
4353 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4354 assert(FD &&
"Not a FunctionDecl?");
4356 std::string MangledName =
4361 std::string ResolverName = MangledName;
4365 llvm_unreachable(
"unexpected MultiVersionKind::None for resolver");
4369 ResolverName +=
".ifunc";
4376 ResolverName +=
".resolver";
4380 if (llvm::GlobalValue *ResolverGV =
GetGlobalValue(ResolverName))
4389 MultiVersionFuncs.push_back(GD);
4394 llvm::Type *ResolverType = llvm::FunctionType::get(
4395 llvm::PointerType::get(DeclTy,
4398 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4399 MangledName +
".resolver", ResolverType,
GlobalDecl{},
4401 llvm::GlobalIFunc *GIF =
4404 GIF->setName(ResolverName);
4410 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4412 assert(isa<llvm::GlobalValue>(Resolver) &&
4413 "Resolver should be created for the first time");
4425llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
4426 StringRef MangledName, llvm::Type *Ty,
GlobalDecl GD,
bool ForVTable,
4427 bool DontDefer,
bool IsThunk, llvm::AttributeList ExtraAttrs,
4433 if (
const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
4435 if (
getLangOpts().OpenMPIsTargetDevice && OpenMPRuntime &&
4436 !OpenMPRuntime->markAsGlobalTarget(GD) && FD->
isDefined() &&
4437 !DontDefer && !IsForDefinition) {
4440 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
4442 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
4451 UpdateMultiVersionNames(GD, FD, MangledName);
4452 if (!IsForDefinition)
4453 return GetOrCreateMultiVersionResolver(GD);
4460 if (WeakRefReferences.erase(Entry)) {
4461 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
4462 if (FD && !FD->
hasAttr<WeakAttr>())
4463 Entry->setLinkage(llvm::Function::ExternalLinkage);
4467 if (D && !D->
hasAttr<DLLImportAttr>() && !D->
hasAttr<DLLExportAttr>() &&
4469 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4475 if (IsForDefinition && !Entry->isDeclaration()) {
4482 DiagnosedConflictingDefinitions.insert(GD).second) {
4486 diag::note_previous_definition);
4490 if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
4491 (Entry->getValueType() == Ty)) {
4498 if (!IsForDefinition)
4505 bool IsIncompleteFunction =
false;
4507 llvm::FunctionType *FTy;
4508 if (isa<llvm::FunctionType>(Ty)) {
4509 FTy = cast<llvm::FunctionType>(Ty);
4511 FTy = llvm::FunctionType::get(
VoidTy,
false);
4512 IsIncompleteFunction =
true;
4516 llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
4517 Entry ? StringRef() : MangledName, &
getModule());
4521 if (D && D->
hasAttr<AnnotateAttr>())
4522 DeferredAnnotations[MangledName] = cast<ValueDecl>(D);
4539 if (!Entry->use_empty()) {
4541 Entry->removeDeadConstantUsers();
4547 assert(F->getName() == MangledName &&
"name was uniqued!");
4549 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
4550 if (ExtraAttrs.hasFnAttrs()) {
4551 llvm::AttrBuilder B(F->getContext(), ExtraAttrs.getFnAttrs());
4559 if (isa_and_nonnull<CXXDestructorDecl>(D) &&
4560 getCXXABI().useThunkForDtorVariant(cast<CXXDestructorDecl>(D),
4562 addDeferredDeclToEmit(GD);
4567 auto DDI = DeferredDecls.find(MangledName);
4568 if (DDI != DeferredDecls.end()) {
4572 addDeferredDeclToEmit(DDI->second);
4573 DeferredDecls.erase(DDI);
4588 for (
const auto *FD = cast<FunctionDecl>(D)->getMostRecentDecl(); FD;
4601 if (!IsIncompleteFunction) {
4602 assert(F->getFunctionType() == Ty);
4618 const auto *FD = cast<FunctionDecl>(GD.
getDecl());
4625 if (
const auto *DD = dyn_cast<CXXDestructorDecl>(GD.
getDecl())) {
4628 DD->getParent()->getNumVBases() == 0)
4633 auto *F = GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
4634 false, llvm::AttributeList(),
4637 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
4638 cast<FunctionDecl>(GD.
getDecl())->hasAttr<CUDAGlobalAttr>()) {
4640 cast<llvm::Function>(F->stripPointerCasts()), GD);
4641 if (IsForDefinition)
4649 llvm::GlobalValue *F =
4652 return llvm::NoCFIValue::get(F);
4662 if (
const auto *FD = dyn_cast<FunctionDecl>(
Result))
4665 if (!
C.getLangOpts().CPlusPlus)
4670 (Name ==
"_ZSt9terminatev" || Name ==
"?terminate@@YAXXZ")
4671 ?
C.Idents.get(
"terminate")
4672 :
C.Idents.get(Name);
4674 for (
const auto &N : {
"__cxxabiv1",
"std"}) {
4678 if (
auto *LSD = dyn_cast<LinkageSpecDecl>(
Result))
4679 for (
const auto *
Result : LSD->lookup(&NS))
4680 if ((ND = dyn_cast<NamespaceDecl>(
Result)))
4685 if (
const auto *FD = dyn_cast<FunctionDecl>(
Result))
4697 llvm::AttributeList ExtraAttrs,
bool Local,
4698 bool AssumeConvergent) {
4699 if (AssumeConvergent) {
4701 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
4705 GetOrCreateLLVMFunction(Name, FTy,
GlobalDecl(),
false,
4709 if (
auto *F = dyn_cast<llvm::Function>(
C)) {
4718 if (!Local &&
getTriple().isWindowsItaniumEnvironment() &&
4721 if (!FD || FD->
hasAttr<DLLImportAttr>()) {
4722 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
4723 F->setLinkage(llvm::GlobalValue::ExternalLinkage);
4752 if (WeakRefReferences.erase(Entry)) {
4753 if (D && !D->
hasAttr<WeakAttr>())
4754 Entry->setLinkage(llvm::Function::ExternalLinkage);
4758 if (D && !D->
hasAttr<DLLImportAttr>() && !D->
hasAttr<DLLExportAttr>() &&
4760 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
4762 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd && D)
4765 if (Entry->getValueType() == Ty && Entry->getAddressSpace() == TargetAS)
4770 if (IsForDefinition && !Entry->isDeclaration()) {
4778 (OtherD = dyn_cast<VarDecl>(OtherGD.
getDecl())) &&
4780 DiagnosedConflictingDefinitions.insert(D).second) {
4784 diag::note_previous_definition);
4789 if (Entry->getType()->getAddressSpace() != TargetAS)
4790 return llvm::ConstantExpr::getAddrSpaceCast(
4791 Entry, llvm::PointerType::get(Ty->getContext(), TargetAS));
4795 if (!IsForDefinition)
4801 auto *GV =
new llvm::GlobalVariable(
4802 getModule(), Ty,
false, llvm::GlobalValue::ExternalLinkage,
nullptr,
4803 MangledName,
nullptr, llvm::GlobalVariable::NotThreadLocal,
4804 getContext().getTargetAddressSpace(DAddrSpace));
4809 GV->takeName(Entry);
4811 if (!Entry->use_empty()) {
4812 Entry->replaceAllUsesWith(GV);
4815 Entry->eraseFromParent();
4821 auto DDI = DeferredDecls.find(MangledName);
4822 if (DDI != DeferredDecls.end()) {
4825 addDeferredDeclToEmit(DDI->second);
4826 DeferredDecls.erase(DDI);
4831 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
4838 GV->setAlignment(
getContext().getDeclAlign(D).getAsAlign());
4844 CXXThreadLocals.push_back(D);
4852 if (
getContext().isMSStaticDataMemberInlineDefinition(D)) {
4853 EmitGlobalVarDefinition(D);
4858 if (
const SectionAttr *SA = D->
getAttr<SectionAttr>())
4859 GV->setSection(SA->getName());
4863 if (
getTriple().getArch() == llvm::Triple::xcore &&
4867 GV->setSection(
".cp.rodata");
4870 if (
const auto *CMA = D->
getAttr<CodeModelAttr>())
4871 GV->setCodeModel(CMA->getModel());
4876 if (Context.
getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
4882 if (!HasMutableFields) {
4889 auto *InitType =
Init->getType();
4890 if (GV->getValueType() != InitType) {
4895 GV->setName(StringRef());
4898 auto *NewGV = cast<llvm::GlobalVariable>(
4900 ->stripPointerCasts());
4903 GV->eraseFromParent();
4906 GV->setInitializer(
Init);
4907 GV->setConstant(
true);
4908 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
4928 SanitizerMD->reportGlobal(GV, *D);
4933 assert(
getContext().getTargetAddressSpace(ExpectedAS) == TargetAS);
4934 if (DAddrSpace != ExpectedAS) {
4936 *
this, GV, DAddrSpace, ExpectedAS,
4947 if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
4949 false, IsForDefinition);
4951 if (isa<CXXMethodDecl>(D)) {
4959 if (isa<FunctionDecl>(D)) {
4970 StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes
Linkage,
4971 llvm::Align Alignment) {
4972 llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name);
4973 llvm::GlobalVariable *OldGV =
nullptr;
4977 if (GV->getValueType() == Ty)
4982 assert(GV->isDeclaration() &&
"Declaration has wrong type!");
4987 GV =
new llvm::GlobalVariable(
getModule(), Ty,
true,
4992 GV->takeName(OldGV);
4994 if (!OldGV->use_empty()) {
4995 OldGV->replaceAllUsesWith(GV);
4998 OldGV->eraseFromParent();
5002 !GV->hasAvailableExternallyLinkage())
5003 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
5005 GV->setAlignment(Alignment);
5037 setDSOLocal(cast<llvm::GlobalValue>(Ret->stripPointerCasts()));
5042 assert(!D->
getInit() &&
"Cannot emit definite definitions here!");
5050 if (GV && !GV->isDeclaration())
5055 if (!MustBeEmitted(D) && !GV) {
5056 DeferredDecls[MangledName] = D;
5061 EmitGlobalVarDefinition(D);
5065 EmitExternalVarDeclaration(D);
5074 if (LangOpts.OpenCL) {
5085 if (LangOpts.SYCLIsDevice &&
5089 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
5091 if (D->
hasAttr<CUDAConstantAttr>())
5093 if (D->
hasAttr<CUDASharedAttr>())
5095 if (D->
hasAttr<CUDADeviceAttr>())
5103 if (LangOpts.OpenMP) {
5105 if (OpenMPRuntime->hasAllocateAttributeForGlobalVar(D, AS))
5113 if (LangOpts.OpenCL)
5115 if (LangOpts.SYCLIsDevice)
5117 if (LangOpts.HIP && LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())
5125 if (
auto AS =
getTarget().getConstantAddressSpace())
5138static llvm::Constant *
5140 llvm::GlobalVariable *GV) {
5141 llvm::Constant *Cast = GV;
5147 llvm::PointerType::get(
5154template<
typename SomeDecl>
5156 llvm::GlobalValue *GV) {
5162 if (!D->template hasAttr<UsedAttr>())
5171 const SomeDecl *
First = D->getFirstDecl();
5172 if (
First->getDeclContext()->isRecord() || !
First->isInExternCContext())
5178 std::pair<StaticExternCMap::iterator, bool> R =
5179 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
5184 R.first->second =
nullptr;
5191 if (D.
hasAttr<SelectAnyAttr>())
5195 if (
auto *VD = dyn_cast<VarDecl>(&D))
5209 llvm_unreachable(
"No such linkage");
5217 llvm::GlobalObject &GO) {
5220 GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
5224void CodeGenModule::EmitGlobalVarDefinition(
const VarDecl *D,
5234 if (LangOpts.OpenMPIsTargetDevice && OpenMPRuntime &&
5235 OpenMPRuntime->emitTargetGlobalVariable(D))
5238 llvm::TrackingVH<llvm::Constant>
Init;
5239 bool NeedsGlobalCtor =
false;
5243 bool IsDefinitionAvailableExternally =
5245 bool NeedsGlobalDtor =
5246 !IsDefinitionAvailableExternally &&
5252 std::optional<ConstantEmitter> emitter;
5257 bool IsCUDASharedVar =
5262 bool IsCUDAShadowVar =
5264 (D->
hasAttr<CUDAConstantAttr>() || D->
hasAttr<CUDADeviceAttr>() ||
5265 D->
hasAttr<CUDASharedAttr>());
5266 bool IsCUDADeviceShadowVar =
5271 (IsCUDASharedVar || IsCUDAShadowVar || IsCUDADeviceShadowVar))
5272 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
5273 else if (D->
hasAttr<LoaderUninitializedAttr>())
5274 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
5275 else if (!InitExpr) {
5289 emitter.emplace(*
this);
5290 llvm::Constant *
Initializer = emitter->tryEmitForInitializer(*InitDecl);
5301 if (!IsDefinitionAvailableExternally)
5302 NeedsGlobalCtor =
true;
5305 Init = llvm::UndefValue::get(
getTypes().ConvertType(T));
5313 DelayedCXXInitPosition.erase(D);
5320 assert(VarSize == CstSize &&
"Emitted constant has unexpected size");
5325 llvm::Type* InitType =
Init->getType();
5326 llvm::Constant *Entry =
5330 Entry = Entry->stripPointerCasts();
5333 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
5344 if (!GV || GV->getValueType() != InitType ||
5345 GV->getType()->getAddressSpace() !=
5349 Entry->setName(StringRef());
5352 GV = cast<llvm::GlobalVariable>(
5354 ->stripPointerCasts());
5357 llvm::Constant *NewPtrForOldDecl =
5358 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV,
5360 Entry->replaceAllUsesWith(NewPtrForOldDecl);
5363 cast<llvm::GlobalValue>(Entry)->eraseFromParent();
5368 if (D->
hasAttr<AnnotateAttr>())
5381 if (LangOpts.CUDA) {
5382 if (LangOpts.CUDAIsDevice) {
5383 if (
Linkage != llvm::GlobalValue::InternalLinkage &&
5384 (D->
hasAttr<CUDADeviceAttr>() || D->
hasAttr<CUDAConstantAttr>() ||
5387 GV->setExternallyInitialized(
true);
5394 GV->setInitializer(
Init);
5396 emitter->finalize(GV);
5399 GV->setConstant(!NeedsGlobalCtor && !NeedsGlobalDtor &&
5403 if (
const SectionAttr *SA = D->
getAttr<SectionAttr>()) {
5406 GV->setConstant(
true);
5411 if (std::optional<CharUnits> AlignValFromAllocate =
5413 AlignVal = *AlignValFromAllocate;
5431 Linkage == llvm::GlobalValue::ExternalLinkage &&
5434 Linkage = llvm::GlobalValue::InternalLinkage;
5437 if (D->
hasAttr<DLLImportAttr>())
5438 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
5439 else if (D->
hasAttr<DLLExportAttr>())
5440 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
5442 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
5444 if (
Linkage == llvm::GlobalVariable::CommonLinkage) {
5446 GV->setConstant(
false);
5451 if (!GV->getInitializer()->isNullValue())
5452 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
5455 setNonAliasAttributes(D, GV);
5457 if (D->
getTLSKind() && !GV->isThreadLocal()) {
5459 CXXThreadLocals.push_back(D);
5466 if (NeedsGlobalCtor || NeedsGlobalDtor)
5467 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
5469 SanitizerMD->reportGlobal(GV, *D, NeedsGlobalCtor);
5474 DI->EmitGlobalVariable(GV, D);
5477void CodeGenModule::EmitExternalVarDeclaration(
const VarDecl *D) {
5482 llvm::Constant *GV =
5484 DI->EmitExternalVariable(
5485 cast<llvm::GlobalVariable>(GV->stripPointerCasts()), D);
5494 if ((NoCommon || D->
hasAttr<NoCommonAttr>()) && !D->
hasAttr<CommonAttr>())
5505 if (D->
hasAttr<SectionAttr>())
5511 if (D->
hasAttr<PragmaClangBSSSectionAttr>() ||
5512 D->
hasAttr<PragmaClangDataSectionAttr>() ||
5513 D->
hasAttr<PragmaClangRelroSectionAttr>() ||
5514 D->
hasAttr<PragmaClangRodataSectionAttr>())
5522 if (D->
hasAttr<WeakImportAttr>())
5532 if (D->
hasAttr<AlignedAttr>())
5541 if (FD->isBitField())
5543 if (FD->
hasAttr<AlignedAttr>())
5565llvm::GlobalValue::LinkageTypes
5569 return llvm::Function::InternalLinkage;
5572 return llvm::GlobalVariable::WeakAnyLinkage;
5576 return llvm::GlobalVariable::LinkOnceAnyLinkage;
5581 return llvm::GlobalValue::AvailableExternallyLinkage;
5595 return !Context.
getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
5596 : llvm::Function::InternalLinkage;
5610 return llvm::Function::ExternalLinkage;
5613 return D->
hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
5614 : llvm::Function::InternalLinkage;
5615 return llvm::Function::WeakODRLinkage;
5620 if (!
getLangOpts().CPlusPlus && isa<VarDecl>(D) &&
5622 CodeGenOpts.NoCommon))
5623 return llvm::GlobalVariable::CommonLinkage;
5629 if (D->
hasAttr<SelectAnyAttr>())
5630 return llvm::GlobalVariable::WeakODRLinkage;
5634 return llvm::GlobalVariable::ExternalLinkage;
5637llvm::GlobalValue::LinkageTypes
5646 llvm::Function *newFn) {
5648 if (old->use_empty())
return;
5650 llvm::Type *newRetTy = newFn->getReturnType();
5653 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
5655 llvm::Value::use_iterator use = ui++;
5656 llvm::User *user = use->getUser();
5660 if (
auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
5661 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
5667 llvm::CallBase *callSite = dyn_cast<llvm::CallBase>(user);
5668 if (!callSite)
continue;
5669 if (!callSite->isCallee(&*use))
5674 if (callSite->getType() != newRetTy && !callSite->use_empty())
5679 llvm::AttributeList oldAttrs = callSite->getAttributes();
5682 unsigned newNumArgs = newFn->arg_size();
5683 if (callSite->arg_size() < newNumArgs)
5689 bool dontTransform =
false;
5690 for (llvm::Argument &A : newFn->args()) {
5691 if (callSite->getArgOperand(argNo)->getType() != A.getType()) {
5692 dontTransform =
true;
5697 newArgAttrs.push_back(oldAttrs.getParamAttrs(argNo));
5705 newArgs.append(callSite->arg_begin(), callSite->arg_begin() + argNo);
5709 callSite->getOperandBundlesAsDefs(newBundles);
5711 llvm::CallBase *newCall;
5712 if (isa<llvm::CallInst>(callSite)) {
5714 llvm::CallInst::Create(newFn, newArgs, newBundles,
"", callSite);
5716 auto *oldInvoke = cast<llvm::InvokeInst>(callSite);
5717 newCall = llvm::InvokeInst::Create(newFn, oldInvoke->getNormalDest(),
5718 oldInvoke->getUnwindDest(), newArgs,
5719 newBundles,
"", callSite);
5723 if (!newCall->getType()->isVoidTy())
5724 newCall->takeName(callSite);
5725 newCall->setAttributes(
5726 llvm::AttributeList::get(newFn->getContext(), oldAttrs.getFnAttrs(),
5727 oldAttrs.getRetAttrs(), newArgAttrs));
5728 newCall->setCallingConv(callSite->getCallingConv());
5731 if (!callSite->use_empty())
5732 callSite->replaceAllUsesWith(newCall);
5735 if (callSite->getDebugLoc())
5736 newCall->setDebugLoc(callSite->getDebugLoc());
5738 callSite->eraseFromParent();
5752 llvm::Function *NewFn) {
5754 if (!isa<llvm::Function>(Old))
return;
5773void CodeGenModule::EmitGlobalFunctionDefinition(
GlobalDecl GD,
5774 llvm::GlobalValue *GV) {
5775 const auto *D = cast<FunctionDecl>(GD.
getDecl());
5782 if (!GV || (GV->getValueType() != Ty))
5788 if (!GV->isDeclaration())
5795 auto *Fn = cast<llvm::Function>(GV);
5807 setNonAliasAttributes(GD, Fn);
5810 if (
const ConstructorAttr *CA = D->
getAttr<ConstructorAttr>())
5812 if (
const DestructorAttr *DA = D->
getAttr<DestructorAttr>())
5818void CodeGenModule::EmitAliasDefinition(
GlobalDecl GD) {
5819 const auto *D = cast<ValueDecl>(GD.
getDecl());
5820 const AliasAttr *AA = D->
getAttr<AliasAttr>();
5821 assert(AA &&
"Not an alias?");
5825 if (AA->getAliasee() == MangledName) {
5826 Diags.
Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
5833 if (Entry && !Entry->isDeclaration())
5836 Aliases.push_back(GD);
5842 llvm::Constant *Aliasee;
5843 llvm::GlobalValue::LinkageTypes
LT;
5844 if (isa<llvm::FunctionType>(DeclTy)) {
5845 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
5851 if (
const auto *VD = dyn_cast<VarDecl>(GD.
getDecl()))
5858 unsigned AS = Aliasee->getType()->getPointerAddressSpace();
5860 llvm::GlobalAlias::create(DeclTy, AS,
LT,
"", Aliasee, &
getModule());
5863 if (GA->getAliasee() == Entry) {
5864 Diags.
Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
5868 assert(Entry->isDeclaration());
5877 GA->takeName(Entry);
5879 Entry->replaceAllUsesWith(GA);
5880 Entry->eraseFromParent();
5882 GA->setName(MangledName);
5890 GA->setLinkage(llvm::Function::WeakAnyLinkage);
5893 if (
const auto *VD = dyn_cast<VarDecl>(D))
5894 if (VD->getTLSKind())
5900 if (isa<VarDecl>(D))
5902 DI->EmitGlobalAlias(cast<llvm::GlobalValue>(GA->getAliasee()->stripPointerCasts()), GD);
5905void CodeGenModule::emitIFuncDefinition(
GlobalDecl GD) {
5906 const auto *D = cast<ValueDecl>(GD.
getDecl());
5907 const IFuncAttr *IFA = D->
getAttr<IFuncAttr>();
5908 assert(IFA &&
"Not an ifunc?");
5912 if (IFA->getResolver() == MangledName) {
5913 Diags.
Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
5919 if (Entry && !Entry->isDeclaration()) {
5922 DiagnosedConflictingDefinitions.insert(GD).second) {
5926 diag::note_previous_definition);
5931 Aliases.push_back(GD);
5934 llvm::Type *ResolverTy = llvm::GlobalIFunc::getResolverFunctionType(DeclTy);
5935 llvm::Constant *Resolver =
5936 GetOrCreateLLVMFunction(IFA->getResolver(), ResolverTy, {},
5938 llvm::GlobalIFunc *GIF =
5939 llvm::GlobalIFunc::create(DeclTy, 0, llvm::Function::ExternalLinkage,
5942 if (GIF->getResolver() == Entry) {
5943 Diags.
Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
5946 assert(Entry->isDeclaration());
5955 GIF->takeName(Entry);
5957 Entry->replaceAllUsesWith(GIF);
5958 Entry->eraseFromParent();
5960 GIF->setName(MangledName);
5961 if (
auto *F = dyn_cast<llvm::Function>(Resolver)) {
5962 F->addFnAttr(llvm::Attribute::DisableSanitizerInstrumentation);
5969 return llvm::Intrinsic::getDeclaration(&
getModule(), (llvm::Intrinsic::ID)IID,
5973static llvm::StringMapEntry<llvm::GlobalVariable *> &
5976 bool &IsUTF16,
unsigned &StringLength) {
5977 StringRef String = Literal->getString();
5978 unsigned NumBytes = String.size();
5981 if (!Literal->containsNonAsciiOrNull()) {
5982 StringLength = NumBytes;
5983 return *Map.insert(std::make_pair(String,
nullptr)).first;
5990 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
5991 llvm::UTF16 *ToPtr = &ToBuf[0];
5993 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
5994 ToPtr + NumBytes, llvm::strictConversion);
5997 StringLength = ToPtr - &ToBuf[0];
6001 return *Map.insert(std::make_pair(
6002 StringRef(
reinterpret_cast<const char *
>(ToBuf.data()),
6003 (StringLength + 1) * 2),
6009 unsigned StringLength = 0;
6010 bool isUTF16 =
false;
6011 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
6016 if (
auto *
C = Entry.second)
6020 llvm::Constant *Zero = llvm::Constant::getNullValue(
Int32Ty);
6021 llvm::Constant *Zeros[] = { Zero, Zero };
6024 const llvm::Triple &Triple =
getTriple();
6027 const bool IsSwiftABI =
6028 static_cast<unsigned>(CFRuntime) >=
6033 if (!CFConstantStringClassRef) {
6034 const char *CFConstantStringClassName =
"__CFConstantStringClassReference";
6036 Ty = llvm::ArrayType::get(Ty, 0);
6038 switch (CFRuntime) {
6042 CFConstantStringClassName =
6043 Triple.isOSDarwin() ?
"$s15SwiftFoundation19_NSCFConstantStringCN"
6044 :
"$s10Foundation19_NSCFConstantStringCN";
6048 CFConstantStringClassName =
6049 Triple.isOSDarwin() ?
"$S15SwiftFoundation19_NSCFConstantStringCN"
6050 :
"$S10Foundation19_NSCFConstantStringCN";
6054 CFConstantStringClassName =
6055 Triple.isOSDarwin() ?
"__T015SwiftFoundation19_NSCFConstantStringCN"
6056 :
"__T010Foundation19_NSCFConstantStringCN";
6063 if (Triple.isOSBinFormatELF() || Triple.isOSBinFormatCOFF()) {
6064 llvm::GlobalValue *GV =
nullptr;
6066 if ((GV = dyn_cast<llvm::GlobalValue>(
C))) {
6073 if ((VD = dyn_cast<VarDecl>(
Result)))
6076 if (Triple.isOSBinFormatELF()) {
6078 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6080 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6081 if (!VD || !VD->
hasAttr<DLLExportAttr>())
6082 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6084 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6092 CFConstantStringClassRef =
6093 IsSwiftABI ? llvm::ConstantExpr::getPtrToInt(
C, Ty)
6094 : llvm::ConstantExpr::getGetElementPtr(Ty,
C, Zeros);
6099 auto *STy = cast<llvm::StructType>(
getTypes().ConvertType(CFTy));
6102 auto Fields = Builder.beginStruct(STy);
6105 Fields.add(cast<llvm::Constant>(CFConstantStringClassRef));
6109 Fields.addInt(
IntPtrTy, IsSwift4_1 ? 0x05 : 0x01);
6110 Fields.addInt(
Int64Ty, isUTF16 ? 0x07d0 : 0x07c8);
6112 Fields.addInt(
IntTy, isUTF16 ? 0x07d0 : 0x07C8);
6116 llvm::Constant *
C =
nullptr;
6119 reinterpret_cast<uint16_t *
>(
const_cast<char *
>(Entry.first().data())),
6120 Entry.first().size() / 2);
6121 C = llvm::ConstantDataArray::get(VMContext, Arr);
6123 C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
6129 new llvm::GlobalVariable(
getModule(),
C->getType(),
true,
6130 llvm::GlobalValue::PrivateLinkage,
C,
".str");
6131 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6141 if (Triple.isOSBinFormatMachO())
6142 GV->setSection(isUTF16 ?
"__TEXT,__ustring"
6143 :
"__TEXT,__cstring,cstring_literals");
6146 else if (Triple.isOSBinFormatELF())
6147 GV->setSection(
".rodata");
6150 llvm::Constant *Str =
6151 llvm::ConstantExpr::getGetElementPtr(GV->getValueType(), GV, Zeros);
6156 llvm::IntegerType *LengthTy =
6166 Fields.addInt(LengthTy, StringLength);
6174 GV = Fields.finishAndCreateGlobal(
"_unnamed_cfstring_", Alignment,
6176 llvm::GlobalVariable::PrivateLinkage);
6177 GV->addAttribute(
"objc_arc_inert");
6178 switch (Triple.getObjectFormat()) {
6179 case llvm::Triple::UnknownObjectFormat:
6180 llvm_unreachable(
"unknown file format");
6181 case llvm::Triple::DXContainer:
6182 case llvm::Triple::GOFF:
6183 case llvm::Triple::SPIRV:
6184 case llvm::Triple::XCOFF:
6185 llvm_unreachable(
"unimplemented");
6186 case llvm::Triple::COFF:
6187 case llvm::Triple::ELF:
6188 case llvm::Triple::Wasm:
6189 GV->setSection(
"cfstring");
6191 case llvm::Triple::MachO:
6192 GV->setSection(
"__DATA,__cfstring");
6201 return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
6205 if (ObjCFastEnumerationStateType.
isNull()) {
6215 for (
size_t i = 0; i < 4; ++i) {
6220 FieldTypes[i],
nullptr,
6232 return ObjCFastEnumerationStateType;
6246 assert(CAT &&
"String literal not of constant array type!");
6247 Str.resize(CAT->
getSize().getZExtValue());
6248 return llvm::ConstantDataArray::getString(VMContext, Str,
false);
6251 auto *AType = cast<llvm::ArrayType>(
getTypes().ConvertType(E->
getType()));
6252 llvm::Type *ElemTy = AType->getElementType();
6253 unsigned NumElements = AType->getNumElements();
6256 if (ElemTy->getPrimitiveSizeInBits() == 16) {
6258 Elements.reserve(NumElements);
6260 for(
unsigned i = 0, e = E->
getLength(); i != e; ++i)
6262 Elements.resize(NumElements);
6263 return llvm::ConstantDataArray::get(VMContext, Elements);
6266 assert(ElemTy->getPrimitiveSizeInBits() == 32);
6268 Elements.reserve(NumElements);
6270 for(
unsigned i = 0, e = E->
getLength(); i != e; ++i)
6272 Elements.resize(NumElements);
6273 return llvm::ConstantDataArray::get(VMContext, Elements);
6276static llvm::GlobalVariable *
6285 auto *GV =
new llvm::GlobalVariable(
6286 M,
C->getType(), !CGM.
getLangOpts().WritableStrings,
LT,
C, GlobalName,
6287 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
6289 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6290 if (GV->isWeakForLinker()) {
6291 assert(CGM.
supportsCOMDAT() &&
"Only COFF uses weak string literals");
6292 GV->setComdat(M.getOrInsertComdat(GV->getName()));
6308 llvm::GlobalVariable **Entry =
nullptr;
6309 if (!LangOpts.WritableStrings) {
6310 Entry = &ConstantStringMap[
C];
6311 if (
auto GV = *Entry) {
6312 if (uint64_t(Alignment.
getQuantity()) > GV->getAlignment())
6315 GV->getValueType(), Alignment);
6320 StringRef GlobalVariableName;
6321 llvm::GlobalValue::LinkageTypes
LT;
6326 if (
getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
6327 !LangOpts.WritableStrings) {
6328 llvm::raw_svector_ostream Out(MangledNameBuffer);
6330 LT = llvm::GlobalValue::LinkOnceODRLinkage;
6331 GlobalVariableName = MangledNameBuffer;
6333 LT = llvm::GlobalValue::PrivateLinkage;
6334 GlobalVariableName = Name;
6346 SanitizerMD->reportGlobal(GV, S->getStrTokenLoc(0),
"<string literal>");
6349 GV->getValueType(), Alignment);
6366 const std::string &Str,
const char *GlobalName) {
6367 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
6372 llvm::ConstantDataArray::getString(
getLLVMContext(), StrWithNull,
false);
6375 llvm::GlobalVariable **Entry =
nullptr;
6376 if (!LangOpts.WritableStrings) {
6377 Entry = &ConstantStringMap[
C];
6378 if (
auto GV = *Entry) {
6379 if (uint64_t(Alignment.
getQuantity()) > GV->getAlignment())
6382 GV->getValueType(), Alignment);
6388 GlobalName =
".str";
6391 GlobalName, Alignment);
6396 GV->getValueType(), Alignment);
6409 MaterializedType = E->
getType();
6413 auto InsertResult = MaterializedGlobalTemporaryMap.insert({E,
nullptr});
6414 if (!InsertResult.second) {
6417 if (!InsertResult.first->second) {
6422 InsertResult.first->second =
new llvm::GlobalVariable(
6423 getModule(),
Type,
false, llvm::GlobalVariable::InternalLinkage,
6427 llvm::cast<llvm::GlobalVariable>(
6428 InsertResult.first->second->stripPointerCasts())
6437 llvm::raw_svector_ostream Out(Name);
6459 std::optional<ConstantEmitter> emitter;
6460 llvm::Constant *InitialValue =
nullptr;
6461 bool Constant =
false;
6465 emitter.emplace(*
this);
6466 InitialValue = emitter->emitForInitializer(*
Value, AddrSpace,
6471 Type = InitialValue->getType();
6480 if (
Linkage == llvm::GlobalVariable::ExternalLinkage) {
6482 if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
6486 Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
6490 Linkage = llvm::GlobalVariable::InternalLinkage;
6494 auto *GV =
new llvm::GlobalVariable(
6496 nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
6497 if (emitter) emitter->finalize(GV);
6499 if (!llvm::GlobalValue::isLocalLinkage(
Linkage)) {
6501 if (GV->getDLLStorageClass() == llvm::GlobalVariable::DLLExportStorageClass)
6503 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
6507 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
6508 if (VD->getTLSKind())
6510 llvm::Constant *CV = GV;
6514 llvm::PointerType::get(
6520 llvm::Constant *&Entry = MaterializedGlobalTemporaryMap[E];
6522 Entry->replaceAllUsesWith(CV);
6523 llvm::cast<llvm::GlobalVariable>(Entry)->eraseFromParent();
6532void CodeGenModule::EmitObjCPropertyImplementations(
const
6545 if (!Getter || Getter->isSynthesizedAccessorStub())
6548 auto *Setter = PID->getSetterMethodDecl();
6549 if (!PD->
isReadOnly() && (!Setter || Setter->isSynthesizedAccessorStub()))
6560 if (ivar->getType().isDestructedType())
6609 getContext().getObjCIdType(),
nullptr, D,
true,
6627 EmitDeclContext(LSD);
6632 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
6635 std::unique_ptr<CodeGenFunction> &CurCGF =
6636 GlobalTopLevelStmtBlockInFlight.first;
6640 if (CurCGF && CXXGlobalInits.back() != CurCGF->CurFn) {
6648 std::string Name =
"__stmts__" + llvm::utostr(CXXGlobalInits.size());
6654 llvm::Function *Fn = llvm::Function::Create(
6655 FnTy, llvm::GlobalValue::InternalLinkage, Name, &
getModule());
6658 GlobalTopLevelStmtBlockInFlight.second = D;
6659 CurCGF->StartFunction(
GlobalDecl(), RetTy, Fn, FnInfo, Args,
6661 CXXGlobalInits.push_back(Fn);
6664 CurCGF->EmitStmt(D->
getStmt());
6667void CodeGenModule::EmitDeclContext(
const DeclContext *DC) {
6668 for (
auto *I : DC->
decls()) {
6674 if (
auto *OID = dyn_cast<ObjCImplDecl>(I)) {
6675 for (
auto *M : OID->methods())
6694 case Decl::CXXConversion:
6695 case Decl::CXXMethod:
6696 case Decl::Function:
6703 case Decl::CXXDeductionGuide:
6708 case Decl::Decomposition:
6709 case Decl::VarTemplateSpecialization:
6711 if (
auto *DD = dyn_cast<DecompositionDecl>(D))
6712 for (
auto *B : DD->bindings())
6713 if (
auto *HD = B->getHoldingVar())
6719 case Decl::IndirectField:
6723 case Decl::Namespace:
6724 EmitDeclContext(cast<NamespaceDecl>(D));
6726 case Decl::ClassTemplateSpecialization: {
6727 const auto *Spec = cast<ClassTemplateSpecializationDecl>(D);
6729 if (Spec->getSpecializationKind() ==
6731 Spec->hasDefinition())
6732 DI->completeTemplateDefinition(*Spec);
6734 case Decl::CXXRecord: {
6741 DI->completeUnusedClass(*CRD);
6744 for (
auto *I : CRD->
decls())
6745 if (isa<VarDecl>(I) || isa<CXXRecordDecl>(I))
6750 case Decl::UsingShadow:
6751 case Decl::ClassTemplate:
6752 case Decl::VarTemplate:
6754 case Decl::VarTemplatePartialSpecialization:
6755 case Decl::FunctionTemplate:
6756 case Decl::TypeAliasTemplate:
6763 DI->EmitUsingDecl(cast<UsingDecl>(*D));
6765 case Decl::UsingEnum:
6767 DI->EmitUsingEnumDecl(cast<UsingEnumDecl>(*D));
6769 case Decl::NamespaceAlias:
6771 DI->EmitNamespaceAlias(cast<NamespaceAliasDecl>(*D));
6773 case Decl::UsingDirective:
6775 DI->EmitUsingDirective(cast<UsingDirectiveDecl>(*D));
6777 case Decl::CXXConstructor:
6780 case Decl::CXXDestructor:
6784 case Decl::StaticAssert:
6791 case Decl::ObjCInterface:
6792 case Decl::ObjCCategory:
6795 case Decl::ObjCProtocol: {
6796 auto *Proto = cast<ObjCProtocolDecl>(D);
6797 if (Proto->isThisDeclarationADefinition())
6802 case Decl::ObjCCategoryImpl:
6805 ObjCRuntime->GenerateCategory(cast<ObjCCategoryImplDecl>(D));
6808 case Decl::ObjCImplementation: {
6809 auto *OMD = cast<ObjCImplementationDecl>(D);
6810 EmitObjCPropertyImplementations(OMD);
6811 EmitObjCIvarInitializations(OMD);
6816 DI->getOrCreateInterfaceType(
getContext().getObjCInterfaceType(
6817 OMD->getClassInterface()), OMD->getLocation());
6820 case Decl::ObjCMethod: {
6821 auto *OMD = cast<ObjCMethodDecl>(D);
6827 case Decl::ObjCCompatibleAlias:
6828 ObjCRuntime->RegisterAlias(cast<ObjCCompatibleAliasDecl>(D));
6831 case Decl::PragmaComment: {
6832 const auto *PCD = cast<PragmaCommentDecl>(D);
6833 switch (PCD->getCommentKind()) {
6835 llvm_unreachable(
"unexpected pragma comment kind");
6850 case Decl::PragmaDetectMismatch: {
6851 const auto *PDMD = cast<PragmaDetectMismatchDecl>(D);
6856 case Decl::LinkageSpec:
6857 EmitLinkageSpec(cast<LinkageSpecDecl>(D));
6860 case Decl::FileScopeAsm: {
6862 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
6865 if (LangOpts.OpenMPIsTargetDevice)
6868 if (LangOpts.SYCLIsDevice)
6870 auto *AD = cast<FileScopeAsmDecl>(D);
6871 getModule().appendModuleInlineAsm(AD->getAsmString()->getString());
6875 case Decl::TopLevelStmt:
6876 EmitTopLevelStmt(cast<TopLevelStmtDecl>(D));
6879 case Decl::Import: {
6880 auto *Import = cast<ImportDecl>(D);
6883 if (!ImportedModules.insert(Import->getImportedModule()))
6887 if (!Import->getImportedOwningModule()) {
6889 DI->EmitImportDecl(*Import);
6895 if (CXX20ModuleInits && Import->getImportedOwningModule() &&
6896 !Import->getImportedOwningModule()->isModuleMapModule())
6905 Visited.insert(Import->getImportedModule());
6906 Stack.push_back(Import->getImportedModule());
6908 while (!Stack.empty()) {
6910 if (!EmittedModuleInitializers.insert(Mod).second)
6920 if (Submodule->IsExplicit)
6923 if (
Visited.insert(Submodule).second)
6924 Stack.push_back(Submodule);
6931 EmitDeclContext(cast<ExportDecl>(D));
6934 case Decl::OMPThreadPrivate:
6938 case Decl::OMPAllocate:
6942 case Decl::OMPDeclareReduction:
6946 case Decl::OMPDeclareMapper:
6950 case Decl::OMPRequires:
6955 case Decl::TypeAlias:
6957 DI->EmitAndRetainType(
6958 getContext().getTypedefType(cast<TypedefNameDecl>(D)));
6970 DI->EmitAndRetainType(
getContext().getEnumType(cast<EnumDecl>(D)));
6973 case Decl::HLSLBuffer:
6981 assert(isa<TypeDecl>(D) &&
"Unsupported decl kind");
6988 if (!CodeGenOpts.CoverageMapping)
6991 case Decl::CXXConversion:
6992 case Decl::CXXMethod:
6993 case Decl::Function:
6994 case Decl::ObjCMethod:
6995 case Decl::CXXConstructor:
6996 case Decl::CXXDestructor: {
6997 if (!cast<FunctionDecl>(D)->doesThisDeclarationHaveABody())
7002 DeferredEmptyCoverageMappingDecls.try_emplace(D,
true);
7012 if (!CodeGenOpts.CoverageMapping)
7014 if (
const auto *Fn = dyn_cast<FunctionDecl>(D)) {
7015 if (Fn->isTemplateInstantiation())
7018 DeferredEmptyCoverageMappingDecls.insert_or_assign(D,
false);
7026 for (
const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
7029 const Decl *D = Entry.first;
7031 case Decl::CXXConversion:
7032 case Decl::CXXMethod:
7033 case Decl::Function:
7034 case Decl::ObjCMethod: {
7041 case Decl::CXXConstructor: {
7048 case Decl::CXXDestructor: {
7065 if (llvm::Function *F =
getModule().getFunction(
"main")) {
7066 if (!F->isDeclaration() && F->arg_size() == 0 && !F->isVarArg() &&
7068 auto *GA = llvm::GlobalAlias::create(
"__main_void", F);
7069 GA->setVisibility(llvm::GlobalValue::HiddenVisibility);
7078 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
7079 return llvm::ConstantInt::get(i64, PtrInt);
7083 llvm::NamedMDNode *&GlobalMetadata,
7085 llvm::GlobalValue *Addr) {
7086 if (!GlobalMetadata)
7088 CGM.
getModule().getOrInsertNamedMetadata(
"clang.global.decl.ptrs");
7091 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(Addr),
7094 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.
getLLVMContext(), Ops));
7097bool CodeGenModule::CheckAndReplaceExternCIFuncs(llvm::GlobalValue *Elem,
7098 llvm::GlobalValue *CppFunc) {
7106 if (Elem == CppFunc)
7112 for (llvm::User *User : Elem->users()) {
7116 if (
auto *ConstExpr = dyn_cast<llvm::ConstantExpr>(User)) {
7117 if (ConstExpr->getOpcode() != llvm::Instruction::BitCast)
7120 for (llvm::User *CEUser : ConstExpr->users()) {
7121 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(CEUser)) {
7122 IFuncs.push_back(IFunc);
7127 CEs.push_back(ConstExpr);
7128 }
else if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(User)) {
7129 IFuncs.push_back(IFunc);
7141 for (llvm::GlobalIFunc *IFunc : IFuncs)
7142 IFunc->setResolver(
nullptr);
7143 for (llvm::ConstantExpr *ConstExpr : CEs)
7144 ConstExpr->destroyConstant();
7148 Elem->eraseFromParent();
7150 for (llvm::GlobalIFunc *IFunc : IFuncs) {
7155 llvm::FunctionType::get(IFunc->getType(),
false);
7156 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
7157 CppFunc->getName(), ResolverTy, {},
false);
7158 IFunc->setResolver(Resolver);
7168void CodeGenModule::EmitStaticExternCAliases() {
7171 for (
auto &I : StaticExternCValues) {
7173 llvm::GlobalValue *Val = I.second;
7181 llvm::GlobalValue *ExistingElem =
7182 getModule().getNamedValue(Name->getName());
7186 if (!ExistingElem || CheckAndReplaceExternCIFuncs(ExistingElem, Val))
7193 auto Res = Manglings.find(MangledName);
7194 if (Res == Manglings.end())
7196 Result = Res->getValue();
7207void CodeGenModule::EmitDeclMetadata() {
7208 llvm::NamedMDNode *GlobalMetadata =
nullptr;
7210 for (
auto &I : MangledDeclNames) {
7211 llvm::GlobalValue *Addr =
getModule().getNamedValue(I.second);
7221void CodeGenFunction::EmitDeclMetadata() {
7222 if (LocalDeclMap.empty())
return;
7227 unsigned DeclPtrKind = Context.getMDKindID(
"clang.decl.ptr");
7229 llvm::NamedMDNode *GlobalMetadata =
nullptr;
7231 for (
auto &I : LocalDeclMap) {
7232 const Decl *D = I.first;
7233 llvm::Value *Addr = I.second.getPointer();
7234 if (
auto *Alloca = dyn_cast<llvm::AllocaInst>(Addr)) {
7236 Alloca->setMetadata(
7237 DeclPtrKind, llvm::MDNode::get(
7238 Context, llvm::ValueAsMetadata::getConstant(DAddr)));
7239 }
else if (
auto *GV = dyn_cast<llvm::GlobalValue>(Addr)) {
7246void CodeGenModule::EmitVersionIdentMetadata() {
7247 llvm::NamedMDNode *IdentMetadata =
7248 TheModule.getOrInsertNamedMetadata(
"llvm.ident");
7250 llvm::LLVMContext &Ctx = TheModule.getContext();
7252 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
7253 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
7256void CodeGenModule::EmitCommandLineMetadata() {
7257 llvm::NamedMDNode *CommandLineMetadata =
7258 TheModule.getOrInsertNamedMetadata(
"llvm.commandline");
7260 llvm::LLVMContext &Ctx = TheModule.getContext();
7262 llvm::Metadata *CommandLineNode[] = {llvm::MDString::get(Ctx, CommandLine)};
7263 CommandLineMetadata->addOperand(llvm::MDNode::get(Ctx, CommandLineNode));
7266void CodeGenModule::EmitCoverageFile() {
7267 llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata(
"llvm.dbg.cu");
7271 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata(
"llvm.gcov");
7272 llvm::LLVMContext &Ctx = TheModule.getContext();
7273 auto *CoverageDataFile =
7275 auto *CoverageNotesFile =
7277 for (
int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
7278 llvm::MDNode *CU = CUNode->getOperand(i);
7279 llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
7280 GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
7301 if (LangOpts.OpenMP && LangOpts.OpenMPSimd)
7303 for (
auto RefExpr : D->
varlists()) {
7304 auto *VD = cast<VarDecl>(cast<DeclRefExpr>(RefExpr)->getDecl());
7306 VD->getAnyInitializer() &&
7307 !VD->getAnyInitializer()->isConstantInitializer(
getContext(),
7314 VD, Addr, RefExpr->getBeginLoc(), PerformInit))
7315 CXXGlobalInits.push_back(InitFunction);
7320CodeGenModule::CreateMetadataIdentifierImpl(
QualType T, MetadataTypeMap &Map,
7324 FnType->getReturnType(), FnType->getParamTypes(),
7325 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
7332 std::string OutName;
7333 llvm::raw_string_ostream Out(OutName);
7338 Out <<
".normalized";
7352 return CreateMetadataIdentifierImpl(T, MetadataIdMap,
"");
7357 return CreateMetadataIdentifierImpl(T, VirtualMetadataIdMap,
".virtual");
7377 for (
auto &Param : FnType->param_types())
7382 GeneralizedParams, FnType->getExtProtoInfo());
7389 llvm_unreachable(
"Encountered unknown FunctionType");
7394 GeneralizedMetadataIdMap,
".generalized");
7401 return ((LangOpts.
Sanitize.
has(SanitizerKind::CFIVCall) &&
7403 (LangOpts.
Sanitize.
has(SanitizerKind::CFINVCall) &&
7405 (LangOpts.
Sanitize.
has(SanitizerKind::CFIDerivedCast) &&
7407 (LangOpts.
Sanitize.
has(SanitizerKind::CFIUnrelatedCast) &&
7414 llvm::Metadata *MD =
7416 VTable->addTypeMetadata(Offset.getQuantity(), MD);
7418 if (CodeGenOpts.SanitizeCfiCrossDso)
7420 VTable->addTypeMetadata(Offset.getQuantity(),
7421 llvm::ConstantAsMetadata::get(CrossDsoTypeId));
7424 llvm::Metadata *MD = llvm::MDString::get(
getLLVMContext(),
"all-vtables");
7425 VTable->addTypeMetadata(Offset.getQuantity(), MD);
7431 SanStats = std::make_unique<llvm::SanitizerStatReport>(&
getModule());
7441 auto *FTy = llvm::FunctionType::get(SamplerT, {
C->getType()},
false);
7456 bool forPointeeType) {
7467 if (
auto Align = TT->getDecl()->getMaxAlignment()) {
7499 }
else if (forPointeeType && !AlignForArray &&
7511 if (
unsigned MaxAlign =
getLangOpts().MaxTypeAlign) {
7524 if (NumAutoVarInit >= StopAfter) {
7527 if (!NumAutoVarInit) {
7530 "-ftrivial-auto-var-init-stop-after=%0 has been enabled to limit the "
7531 "number of times ftrivial-auto-var-init=%1 gets applied.");
7545 const Decl *D)
const {
7549 OS << (isa<VarDecl>(D) ?
".static." :
".intern.");
7551 OS << (isa<VarDecl>(D) ?
"__static__" :
"__intern__");
7557 assert(PLoc.
isValid() &&
"Source location is expected to be valid.");
7561 llvm::MD5::MD5Result
Result;
7562 for (
const auto &Arg : PreprocessorOpts.
Macros)
7563 Hash.update(Arg.first);
7567 llvm::sys::fs::UniqueID ID;
7568 if (llvm::sys::fs::getUniqueID(PLoc.
getFilename(), ID)) {
7570 assert(PLoc.
isValid() &&
"Source location is expected to be valid.");
7571 if (
auto EC = llvm::sys::fs::getUniqueID(PLoc.
getFilename(), ID))
7572 SM.getDiagnostics().Report(diag::err_cannot_open_file)
7575 OS << llvm::format(
"%x", ID.getFile()) << llvm::format(
"%x", ID.getDevice())
7576 <<
"_" << llvm::utohexstr(
Result.low(),
true, 8);
7583 assert(DeferredDeclsToEmit.empty() &&
7584 "Should have emitted all decls deferred to emit.");
7585 assert(NewBuilder->DeferredDecls.empty() &&
7586 "Newly created module should not have deferred decls");
7587 NewBuilder->DeferredDecls = std::move(DeferredDecls);
7588 assert(EmittedDeferredDecls.empty() &&
7589 "Still have (unmerged) EmittedDeferredDecls deferred decls");
7591 assert(NewBuilder->DeferredVTables.empty() &&
7592 "Newly created module should not have deferred vtables");
7593 NewBuilder->DeferredVTables = std::move(DeferredVTables);
7595 assert(NewBuilder->MangledDeclNames.empty() &&
7596 "Newly created module should not have mangled decl names");
7597 assert(NewBuilder->Manglings.empty() &&
7598 "Newly created module should not have manglings");
7599 NewBuilder->Manglings = std::move(Manglings);
7601 NewBuilder->WeakRefReferences = std::move(WeakRefReferences);
7603 NewBuilder->TBAA = std::move(TBAA);
7605 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 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
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 Address 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.
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 llvm::Value * performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, llvm::Value *V, LangAS SrcAddr, LangAS DestAddr, llvm::Type *DestTy, bool IsNonNull=false) const
Perform address space cast of an expression of pointer type.
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.
const llvm::APInt & getSize() const
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
SourceLocation getBeginLoc() const LLVM_READONLY
DeclContext * getLexicalDeclContext()
getLexicalDeclContext - The declaration context where this Decl was lexically declared (LexicalDC).
Represents a ValueDecl that came out of a declarator.
Concrete class used by the front-end to report problems and issues.
DiagnosticBuilder Report(SourceLocation Loc, unsigned DiagID)
Issue the message to the client.
unsigned getCustomDiagID(Level L, const char(&FormatString)[N])
Return an ID for a diagnostic with the specified format string and level.
This represents one expression.
Represents a member of a struct/union/class.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
StringRef getName() const
The name of this FileEntry.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Represents a function declaration or definition.
bool isTargetClonesMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-clones functional...
bool isMultiVersion() const
True if this function is considered a multiversioned function.
const ParmVarDecl * getParamDecl(unsigned i) const
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
bool isImmediateFunction() const
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
bool doesThisDeclarationHaveABody() const
Returns whether this specific declaration of the function has a body.
bool isInlineBuiltinDeclaration() const
Determine if this function provides an inline implementation of a builtin.
bool isConstexpr() const
Whether this is a (C++11) constexpr function or constexpr constructor.
FunctionDecl * getDefinition()
Get the definition for this declaration.
bool isTargetVersionMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-version functiona...
bool isReplaceableGlobalAllocationFunction(std::optional< unsigned > *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
bool isCPUDispatchMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the cpu_specific/cpu_dispatc...
TemplateSpecializationKind getTemplateSpecializationKind() const
Determine what kind of template instantiation this function represents.
bool doesDeclarationForceExternallyVisibleDefinition() const
For a function declaration in C or C++, determine whether this declaration causes the definition to b...
bool isTargetMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target functionality.
unsigned getNumParams() const
Return the number of parameters this function must have based on its FunctionType.
bool hasBody(const FunctionDecl *&Definition) const
Returns true if the function has a body.
bool isDefined(const FunctionDecl *&Definition, bool CheckForPendingFriendDefinition=false) const
Returns true if the function has a definition that does not need to be instantiated.
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
void getNameForDiagnostic(raw_ostream &OS, const PrintingPolicy &Policy, bool Qualified) const override
Appends a human-readable name for this declaration into the given stream.
Represents a K&R-style 'int foo()' function, which has no information available about its arguments.
Represents a prototype with parameter type info, e.g.
FunctionType - C99 6.7.5.3 - Function Declarators.
CallingConv getCallConv() const
GlobalDecl - represents a global declaration.
GlobalDecl getWithMultiVersionIndex(unsigned Index)
CXXCtorType getCtorType() const
GlobalDecl getWithKernelReferenceKind(KernelReferenceKind Kind)
GlobalDecl getCanonicalDecl() const
KernelReferenceKind getKernelReferenceKind() const
GlobalDecl getWithDecl(const Decl *D)
unsigned getMultiVersionIndex() const
CXXDtorType getDtorType() const
const Decl * getDecl() const
One of these records is kept for each identifier that is lexed.
StringRef getName() const
Return the actual identifier string.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
@ None
No signing for any function.
@ Swift5_0
Interoperability with the Swift 5.0 runtime.
@ Swift
Interoperability with the latest known version of the Swift runtime.
@ Swift4_2
Interoperability with the Swift 4.2 runtime.
@ Swift4_1
Interoperability with the Swift 4.1 runtime.
VisibilityFromDLLStorageClassKinds
@ Keep
Keep the IR-gen assigned visibility.
@ Protected
Override the IR-gen assigned visibility with protected visibility.
@ Default
Override the IR-gen assigned visibility with default visibility.
@ Hidden
Override the IR-gen assigned visibility with hidden visibility.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
bool isSignReturnAddressWithAKey() const
Check if return address signing uses AKey.
clang::ObjCRuntime ObjCRuntime
CoreFoundationABI CFRuntime
SanitizerSet Sanitize
Set of enabled sanitizers.
bool hasSignReturnAddress() const
Check if return address signing is enabled.
std::map< std::string, std::string, std::greater< std::string > > MacroPrefixMap
A prefix map for FILE, BASE_FILE and __builtin_FILE().
LangStandard::Kind LangStd
The used language standard.
bool isSignReturnAddressScopeAll() const
Check if leaf functions are also signed.
std::string CUID
The user provided compilation unit ID, if non-empty.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Visibility getVisibility() const
void setLinkage(Linkage L)
Linkage getLinkage() const
bool isVisibilityExplicit() const
Represents a linkage specification.
LinkageSpecLanguageIDs getLanguage() const
Return the language specified by this linkage specification.
Parts getParts() const
Get the decomposed parts of this declaration.
APValue & getAsAPValue() const
Get the value of this MSGuidDecl as an APValue.
MangleContext - Context for tracking state which persists across multiple calls to the C++ name mangl...
void mangleBlock(const DeclContext *DC, const BlockDecl *BD, raw_ostream &Out)
void mangleCtorBlock(const CXXConstructorDecl *CD, CXXCtorType CT, const BlockDecl *BD, raw_ostream &Out)
void mangleGlobalBlock(const BlockDecl *BD, const NamedDecl *ID, raw_ostream &Out)
bool shouldMangleDeclName(const NamedDecl *D)
void mangleName(GlobalDecl GD, raw_ostream &)
virtual void mangleCanonicalTypeName(QualType T, raw_ostream &, bool NormalizeIntegers=false)=0
Generates a unique string for an externally visible type for use with TBAA or type uniquing.
virtual void mangleStringLiteral(const StringLiteral *SL, raw_ostream &)=0
ManglerKind getKind() const
virtual void needsUniqueInternalLinkageNames()
virtual void mangleReferenceTemporary(const VarDecl *D, unsigned ManglingNumber, raw_ostream &)=0
void mangleDtorBlock(const CXXDestructorDecl *CD, CXXDtorType DT, const BlockDecl *BD, raw_ostream &Out)
Represents a prvalue temporary that is written into memory so that a reference can bind to it.
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
Qualifiers getQualifiers() const
Retrieve the set of qualifiers applied to this type.
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
QualType withCVRQualifiers(unsigned CVR) const
bool isConstQualified() const
Determine whether this type is const-qualified.
bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
bool hasUnaligned() const
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, 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
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.
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.
void EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts, DiagnosticsEngine &Diags)
GVALinkage
A more specific kind of linkage than enum Linkage.
@ GVA_AvailableExternally
std::string getClangVendor()
Retrieves the Clang vendor tag.
@ ICIS_NoInit
No in-class initializer.
CXXABI * CreateMicrosoftCXXABI(ASTContext &Ctx)
CXXABI * CreateItaniumCXXABI(ASTContext &Ctx)
Creates an instance of a C++ ABI class.
Linkage
Describes the different kinds of linkage (C++ [basic.link], C99 6.2.2) that an entity may have.
@ Internal
Internal linkage, which indicates that the entity can be referred to from within the translation unit...
@ Asm
Assembly: we accept this only so that we can preprocess it.
@ SD_Thread
Thread storage duration.
@ SD_Static
Static storage duration.
bool isLambdaCallOperator(const CXXMethodDecl *MD)
@ Result
The result type of a method or function.
StringRef languageToString(Language L)
@ Dtor_Base
Base object dtor.
@ Dtor_Complete
Complete object dtor.
LangAS
Defines the address space values used by the address space qualifier of QualType.
@ FirstTargetAddressSpace
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
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.