50#include "llvm/ADT/STLExtras.h"
51#include "llvm/ADT/StringExtras.h"
52#include "llvm/ADT/StringSwitch.h"
53#include "llvm/Analysis/TargetLibraryInfo.h"
54#include "llvm/BinaryFormat/ELF.h"
55#include "llvm/IR/AttributeMask.h"
56#include "llvm/IR/CallingConv.h"
57#include "llvm/IR/DataLayout.h"
58#include "llvm/IR/Intrinsics.h"
59#include "llvm/IR/LLVMContext.h"
60#include "llvm/IR/Module.h"
61#include "llvm/IR/ProfileSummary.h"
62#include "llvm/ProfileData/InstrProfReader.h"
63#include "llvm/ProfileData/SampleProf.h"
64#include "llvm/Support/CRC.h"
65#include "llvm/Support/CodeGen.h"
66#include "llvm/Support/CommandLine.h"
67#include "llvm/Support/ConvertUTF.h"
68#include "llvm/Support/ErrorHandling.h"
69#include "llvm/Support/TimeProfiler.h"
70#include "llvm/Support/xxhash.h"
71#include "llvm/TargetParser/RISCVISAInfo.h"
72#include "llvm/TargetParser/Triple.h"
73#include "llvm/TargetParser/X86TargetParser.h"
74#include "llvm/Transforms/Utils/BuildLibCalls.h"
82 "limited-coverage-experimental", llvm::cl::Hidden,
83 llvm::cl::desc(
"Emit limited coverage mapping information (experimental)"));
90 case TargetCXXABI::AppleARM64:
91 case TargetCXXABI::Fuchsia:
92 case TargetCXXABI::GenericAArch64:
93 case TargetCXXABI::GenericARM:
94 case TargetCXXABI::iOS:
95 case TargetCXXABI::WatchOS:
96 case TargetCXXABI::GenericMIPS:
97 case TargetCXXABI::GenericItanium:
98 case TargetCXXABI::WebAssembly:
99 case TargetCXXABI::XL:
101 case TargetCXXABI::Microsoft:
105 llvm_unreachable(
"invalid C++ ABI kind");
108static std::unique_ptr<TargetCodeGenInfo>
111 const llvm::Triple &Triple =
Target.getTriple();
114 switch (Triple.getArch()) {
118 case llvm::Triple::m68k:
120 case llvm::Triple::mips:
121 case llvm::Triple::mipsel:
122 if (Triple.getOS() == llvm::Triple::Win32)
126 case llvm::Triple::mips64:
127 case llvm::Triple::mips64el:
130 case llvm::Triple::avr: {
134 unsigned NPR =
Target.getABI() ==
"avrtiny" ? 6 : 18;
135 unsigned NRR =
Target.getABI() ==
"avrtiny" ? 4 : 8;
139 case llvm::Triple::aarch64:
140 case llvm::Triple::aarch64_32:
141 case llvm::Triple::aarch64_be: {
143 if (
Target.getABI() ==
"darwinpcs")
144 Kind = AArch64ABIKind::DarwinPCS;
145 else if (Triple.isOSWindows())
147 else if (
Target.getABI() ==
"aapcs-soft")
148 Kind = AArch64ABIKind::AAPCSSoft;
149 else if (
Target.getABI() ==
"pauthtest")
150 Kind = AArch64ABIKind::PAuthTest;
155 case llvm::Triple::wasm32:
156 case llvm::Triple::wasm64: {
158 if (
Target.getABI() ==
"experimental-mv")
159 Kind = WebAssemblyABIKind::ExperimentalMV;
163 case llvm::Triple::arm:
164 case llvm::Triple::armeb:
165 case llvm::Triple::thumb:
166 case llvm::Triple::thumbeb: {
167 if (Triple.getOS() == llvm::Triple::Win32)
171 StringRef ABIStr =
Target.getABI();
172 if (ABIStr ==
"apcs-gnu")
173 Kind = ARMABIKind::APCS;
174 else if (ABIStr ==
"aapcs16")
175 Kind = ARMABIKind::AAPCS16_VFP;
176 else if (CodeGenOpts.
FloatABI ==
"hard" ||
177 (CodeGenOpts.
FloatABI !=
"soft" && Triple.isHardFloatABI()))
178 Kind = ARMABIKind::AAPCS_VFP;
183 case llvm::Triple::ppc: {
184 if (Triple.isOSAIX())
191 case llvm::Triple::ppcle: {
196 case llvm::Triple::ppc64:
197 if (Triple.isOSAIX())
200 if (Triple.isOSBinFormatELF()) {
202 if (
Target.getABI() ==
"elfv2")
203 Kind = PPC64_SVR4_ABIKind::ELFv2;
204 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
209 case llvm::Triple::ppc64le: {
210 assert(Triple.isOSBinFormatELF() &&
"PPC64 LE non-ELF not supported!");
212 if (
Target.getABI() ==
"elfv1")
213 Kind = PPC64_SVR4_ABIKind::ELFv1;
214 bool IsSoftFloat = CodeGenOpts.
FloatABI ==
"soft";
219 case llvm::Triple::nvptx:
220 case llvm::Triple::nvptx64:
223 case llvm::Triple::msp430:
226 case llvm::Triple::riscv32:
227 case llvm::Triple::riscv64: {
228 StringRef ABIStr =
Target.getABI();
230 unsigned ABIFLen = 0;
231 if (ABIStr.ends_with(
"f"))
233 else if (ABIStr.ends_with(
"d"))
235 bool EABI = ABIStr.ends_with(
"e");
239 case llvm::Triple::systemz: {
240 bool SoftFloat = CodeGenOpts.
FloatABI ==
"soft";
241 bool HasVector = !SoftFloat &&
Target.getABI() ==
"vector";
245 case llvm::Triple::tce:
246 case llvm::Triple::tcele:
249 case llvm::Triple::x86: {
250 bool IsDarwinVectorABI = Triple.isOSDarwin();
251 bool IsWin32FloatStructABI = Triple.isOSWindows() && !Triple.isOSCygMing();
253 if (Triple.getOS() == llvm::Triple::Win32) {
255 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
256 CodeGenOpts.NumRegisterParameters);
259 CGM, IsDarwinVectorABI, IsWin32FloatStructABI,
260 CodeGenOpts.NumRegisterParameters, CodeGenOpts.
FloatABI ==
"soft");
263 case llvm::Triple::x86_64: {
264 StringRef ABI =
Target.getABI();
265 X86AVXABILevel AVXLevel = (ABI ==
"avx512" ? X86AVXABILevel::AVX512
266 : ABI ==
"avx" ? X86AVXABILevel::AVX
267 : X86AVXABILevel::None);
269 switch (Triple.getOS()) {
270 case llvm::Triple::UEFI:
271 case llvm::Triple::Win32:
277 case llvm::Triple::hexagon:
279 case llvm::Triple::lanai:
281 case llvm::Triple::r600:
283 case llvm::Triple::amdgcn:
285 case llvm::Triple::sparc:
287 case llvm::Triple::sparcv9:
289 case llvm::Triple::xcore:
291 case llvm::Triple::arc:
293 case llvm::Triple::spir:
294 case llvm::Triple::spir64:
296 case llvm::Triple::spirv32:
297 case llvm::Triple::spirv64:
298 case llvm::Triple::spirv:
300 case llvm::Triple::dxil:
302 case llvm::Triple::ve:
304 case llvm::Triple::csky: {
305 bool IsSoftFloat = !
Target.hasFeature(
"hard-float-abi");
307 Target.hasFeature(
"fpuv2_df") ||
Target.hasFeature(
"fpuv3_df");
312 case llvm::Triple::bpfeb:
313 case llvm::Triple::bpfel:
315 case llvm::Triple::loongarch32:
316 case llvm::Triple::loongarch64: {
317 StringRef ABIStr =
Target.getABI();
318 unsigned ABIFRLen = 0;
319 if (ABIStr.ends_with(
"f"))
321 else if (ABIStr.ends_with(
"d"))
330 if (!TheTargetCodeGenInfo)
332 return *TheTargetCodeGenInfo;
336 llvm::LLVMContext &Context,
340 if (Opts.AlignDouble || Opts.OpenCL || Opts.HLSL)
343 llvm::Triple Triple =
Target.getTriple();
344 llvm::DataLayout DL(
Target.getDataLayoutString());
345 auto Check = [&](
const char *Name, llvm::Type *Ty,
unsigned Alignment) {
346 llvm::Align DLAlign = DL.getABITypeAlign(Ty);
347 llvm::Align ClangAlign(Alignment / 8);
348 if (DLAlign != ClangAlign) {
349 llvm::errs() <<
"For target " << Triple.str() <<
" type " << Name
350 <<
" mapping to " << *Ty <<
" has data layout alignment "
351 << DLAlign.value() <<
" while clang specifies "
352 << ClangAlign.value() <<
"\n";
357 Check(
"bool", llvm::Type::getIntNTy(Context,
Target.BoolWidth),
359 Check(
"short", llvm::Type::getIntNTy(Context,
Target.ShortWidth),
361 Check(
"int", llvm::Type::getIntNTy(Context,
Target.IntWidth),
363 Check(
"long", llvm::Type::getIntNTy(Context,
Target.LongWidth),
366 if (Triple.getArch() != llvm::Triple::m68k)
367 Check(
"long long", llvm::Type::getIntNTy(Context,
Target.LongLongWidth),
370 if (
Target.hasInt128Type() && !
Target.getTargetOpts().ForceEnableInt128 &&
371 !Triple.isAMDGPU() && !Triple.isSPIRV() &&
372 Triple.getArch() != llvm::Triple::ve)
373 Check(
"__int128", llvm::Type::getIntNTy(Context, 128),
Target.Int128Align);
375 if (
Target.hasFloat16Type())
376 Check(
"half", llvm::Type::getFloatingPointTy(Context, *
Target.HalfFormat),
378 if (
Target.hasBFloat16Type())
379 Check(
"bfloat", llvm::Type::getBFloatTy(Context),
Target.BFloat16Align);
380 Check(
"float", llvm::Type::getFloatingPointTy(Context, *
Target.FloatFormat),
383 if (!Triple.isOSAIX()) {
385 llvm::Type::getFloatingPointTy(Context, *
Target.DoubleFormat),
388 llvm::Type::getFloatingPointTy(Context, *
Target.LongDoubleFormat),
391 if (
Target.hasFloat128Type())
392 Check(
"__float128", llvm::Type::getFP128Ty(Context),
Target.Float128Align);
393 if (
Target.hasIbm128Type())
394 Check(
"__ibm128", llvm::Type::getPPC_FP128Ty(Context),
Target.Ibm128Align);
396 Check(
"void*", llvm::PointerType::getUnqual(Context),
Target.PointerAlign);
407 : Context(
C), LangOpts(
C.
getLangOpts()), FS(FS), HeaderSearchOpts(HSO),
408 PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),
410 VMContext(M.
getContext()), VTables(*this), StackHandler(diags),
416 llvm::LLVMContext &LLVMContext = M.getContext();
417 VoidTy = llvm::Type::getVoidTy(LLVMContext);
418 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
419 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
420 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
421 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
422 HalfTy = llvm::Type::getHalfTy(LLVMContext);
423 BFloatTy = llvm::Type::getBFloatTy(LLVMContext);
424 FloatTy = llvm::Type::getFloatTy(LLVMContext);
425 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
431 C.toCharUnitsFromBits(
C.getTargetInfo().getMaxPointerWidth()).getQuantity();
433 C.toCharUnitsFromBits(
C.getTargetInfo().getIntAlign()).getQuantity();
435 llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getCharWidth());
436 IntTy = llvm::IntegerType::get(LLVMContext,
C.getTargetInfo().getIntWidth());
437 IntPtrTy = llvm::IntegerType::get(LLVMContext,
438 C.getTargetInfo().getMaxPointerWidth());
439 Int8PtrTy = llvm::PointerType::get(LLVMContext,
441 const llvm::DataLayout &DL = M.getDataLayout();
443 llvm::PointerType::get(LLVMContext, DL.getAllocaAddrSpace());
445 llvm::PointerType::get(LLVMContext, DL.getDefaultGlobalsAddressSpace());
462 createOpenCLRuntime();
464 createOpenMPRuntime();
471 if (LangOpts.Sanitize.hasOneOf(SanitizerKind::Thread | SanitizerKind::Type) ||
472 (!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))
478 if (CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo ||
479 CodeGenOpts.CoverageNotesFile.size() ||
480 CodeGenOpts.CoverageDataFile.size())
488 Block.GlobalUniqueCount = 0;
490 if (
C.getLangOpts().ObjC)
493 if (CodeGenOpts.hasProfileClangUse()) {
494 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(
495 CodeGenOpts.ProfileInstrumentUsePath, *FS,
496 CodeGenOpts.ProfileRemappingFile);
497 if (
auto E = ReaderOrErr.takeError()) {
498 unsigned DiagID = Diags.getCustomDiagID(
500 llvm::handleAllErrors(std::move(E), [&](
const llvm::ErrorInfoBase &EI) {
502 << CodeGenOpts.ProfileInstrumentUsePath << EI.message();
506 PGOReader = std::move(ReaderOrErr.get());
511 if (CodeGenOpts.CoverageMapping)
515 if (CodeGenOpts.UniqueInternalLinkageNames &&
516 !
getModule().getSourceFileName().empty()) {
517 std::string Path =
getModule().getSourceFileName();
519 for (
const auto &Entry : LangOpts.MacroPrefixMap)
520 if (Path.rfind(Entry.first, 0) != std::string::npos) {
521 Path = Entry.second + Path.substr(Entry.first.size());
524 ModuleNameHash = llvm::getUniqueInternalLinkagePostfix(Path);
528 if (Context.getTargetInfo().getTriple().getArch() == llvm::Triple::x86)
529 getModule().addModuleFlag(llvm::Module::Error,
"NumRegisterParameters",
530 CodeGenOpts.NumRegisterParameters);
539 const llvm::MemoryBuffer &FileBuffer = **BufOrErr;
540 for (llvm::line_iterator I(FileBuffer.getMemBufferRef(),
true), E;
542 this->MSHotPatchFunctions.push_back(std::string{*I});
544 auto &DE = Context.getDiagnostics();
547 "failed to open hotpatch functions file "
548 "(-fms-hotpatch-functions-file): %0 : %1");
550 << BufOrErr.getError().message();
555 this->MSHotPatchFunctions.push_back(FuncName);
557 llvm::sort(this->MSHotPatchFunctions);
560 if (!Context.getAuxTargetInfo())
566void CodeGenModule::createObjCRuntime() {
583 llvm_unreachable(
"bad runtime kind");
586void CodeGenModule::createOpenCLRuntime() {
590void CodeGenModule::createOpenMPRuntime() {
591 if (!LangOpts.OMPHostIRFile.empty() && !FS->exists(LangOpts.OMPHostIRFile))
592 Diags.Report(diag::err_omp_host_ir_file_not_found)
593 << LangOpts.OMPHostIRFile;
598 case llvm::Triple::nvptx:
599 case llvm::Triple::nvptx64:
600 case llvm::Triple::amdgcn:
601 case llvm::Triple::spirv64:
604 "OpenMP AMDGPU/NVPTX/SPIRV is only prepared to deal with device code.");
605 OpenMPRuntime.reset(
new CGOpenMPRuntimeGPU(*
this));
608 if (LangOpts.OpenMPSimd)
609 OpenMPRuntime.reset(
new CGOpenMPSIMDRuntime(*
this));
611 OpenMPRuntime.reset(
new CGOpenMPRuntime(*
this));
616void CodeGenModule::createCUDARuntime() {
620void CodeGenModule::createHLSLRuntime() {
621 HLSLRuntime.reset(
new CGHLSLRuntime(*
this));
625 Replacements[Name] =
C;
628void CodeGenModule::applyReplacements() {
629 for (
auto &I : Replacements) {
630 StringRef MangledName = I.first;
631 llvm::Constant *Replacement = I.second;
636 auto *NewF = dyn_cast<llvm::Function>(Replacement);
638 if (
auto *Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {
639 NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
642 assert(CE->getOpcode() == llvm::Instruction::BitCast ||
643 CE->getOpcode() == llvm::Instruction::GetElementPtr);
644 NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
649 OldF->replaceAllUsesWith(Replacement);
651 NewF->removeFromParent();
652 OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),
655 OldF->eraseFromParent();
660 GlobalValReplacements.push_back(std::make_pair(GV,
C));
663void CodeGenModule::applyGlobalValReplacements() {
664 for (
auto &I : GlobalValReplacements) {
665 llvm::GlobalValue *GV = I.first;
666 llvm::Constant *
C = I.second;
668 GV->replaceAllUsesWith(
C);
669 GV->eraseFromParent();
676 const llvm::Constant *
C;
677 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(GV))
678 C = GA->getAliasee();
679 else if (
auto *GI = dyn_cast<llvm::GlobalIFunc>(GV))
680 C = GI->getResolver();
684 const auto *AliaseeGV = dyn_cast<llvm::GlobalValue>(
C->stripPointerCasts());
688 const llvm::GlobalValue *FinalGV = AliaseeGV->getAliaseeObject();
697 bool IsIFunc,
const llvm::GlobalValue *Alias,
const llvm::GlobalValue *&GV,
698 const llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames,
702 Diags.
Report(Location, diag::err_cyclic_alias) << IsIFunc;
706 if (GV->hasCommonLinkage()) {
707 const llvm::Triple &Triple = Context.getTargetInfo().getTriple();
708 if (Triple.getObjectFormat() == llvm::Triple::XCOFF) {
709 Diags.
Report(Location, diag::err_alias_to_common);
714 if (GV->isDeclaration()) {
715 Diags.
Report(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;
716 Diags.
Report(Location, diag::note_alias_requires_mangled_name)
717 << IsIFunc << IsIFunc;
720 for (
const auto &[
Decl, Name] : MangledDeclNames) {
721 if (
const auto *ND = dyn_cast<NamedDecl>(
Decl.getDecl())) {
723 if (II && II->
getName() == GV->getName()) {
724 Diags.
Report(Location, diag::note_alias_mangled_name_alternative)
728 (Twine(IsIFunc ?
"ifunc" :
"alias") +
"(\"" + Name +
"\")")
738 const auto *F = dyn_cast<llvm::Function>(GV);
740 Diags.
Report(Location, diag::err_alias_to_undefined)
741 << IsIFunc << IsIFunc;
745 llvm::FunctionType *FTy = F->getFunctionType();
746 if (!FTy->getReturnType()->isPointerTy()) {
747 Diags.
Report(Location, diag::err_ifunc_resolver_return);
761 if (GVar->hasAttribute(
"toc-data")) {
762 auto GVId = GVar->getName();
765 Diags.
Report(Location, diag::warn_toc_unsupported_type)
766 << GVId <<
"the variable has an alias";
768 llvm::AttributeSet CurrAttributes = GVar->getAttributes();
769 llvm::AttributeSet NewAttributes =
770 CurrAttributes.removeAttribute(GVar->getContext(),
"toc-data");
771 GVar->setAttributes(NewAttributes);
775void CodeGenModule::checkAliases() {
780 DiagnosticsEngine &Diags =
getDiags();
781 for (
const GlobalDecl &GD : Aliases) {
783 SourceLocation Location;
785 bool IsIFunc = D->hasAttr<IFuncAttr>();
786 if (
const Attr *A = D->getDefiningAttr()) {
787 Location = A->getLocation();
788 Range = A->getRange();
790 llvm_unreachable(
"Not an alias or ifunc?");
794 const llvm::GlobalValue *GV =
nullptr;
796 MangledDeclNames, Range)) {
802 if (
const llvm::GlobalVariable *GVar =
803 dyn_cast<const llvm::GlobalVariable>(GV))
807 llvm::Constant *Aliasee =
811 llvm::GlobalValue *AliaseeGV;
812 if (
auto CE = dyn_cast<llvm::ConstantExpr>(Aliasee))
817 if (
const SectionAttr *SA = D->getAttr<SectionAttr>()) {
818 StringRef AliasSection = SA->getName();
819 if (AliasSection != AliaseeGV->getSection())
820 Diags.Report(SA->getLocation(), diag::warn_alias_with_section)
821 << AliasSection << IsIFunc << IsIFunc;
829 if (
auto *GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {
830 if (GA->isInterposable()) {
831 Diags.Report(Location, diag::warn_alias_to_weak_alias)
832 << GV->getName() << GA->getName() << IsIFunc;
833 Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
834 GA->getAliasee(), Alias->getType());
846 llvm::Attribute::DisableSanitizerInstrumentation);
851 for (
const GlobalDecl &GD : Aliases) {
854 Alias->replaceAllUsesWith(llvm::PoisonValue::get(Alias->getType()));
855 Alias->eraseFromParent();
860 DeferredDeclsToEmit.clear();
861 EmittedDeferredDecls.clear();
862 DeferredAnnotations.clear();
864 OpenMPRuntime->clear();
868 StringRef MainFile) {
871 if (VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {
872 if (MainFile.empty())
873 MainFile =
"<stdin>";
874 Diags.
Report(diag::warn_profile_data_unprofiled) << MainFile;
877 Diags.
Report(diag::warn_profile_data_out_of_date) << Visited << Mismatched;
880 Diags.
Report(diag::warn_profile_data_missing) << Visited << Missing;
884static std::optional<llvm::GlobalValue::VisibilityTypes>
891 return llvm::GlobalValue::DefaultVisibility;
893 return llvm::GlobalValue::HiddenVisibility;
895 return llvm::GlobalValue::ProtectedVisibility;
897 llvm_unreachable(
"unknown option value!");
902 std::optional<llvm::GlobalValue::VisibilityTypes>
V) {
911 GV.setDSOLocal(
false);
912 GV.setVisibility(*
V);
917 if (!LO.VisibilityFromDLLStorageClass)
920 std::optional<llvm::GlobalValue::VisibilityTypes> DLLExportVisibility =
923 std::optional<llvm::GlobalValue::VisibilityTypes>
924 NoDLLStorageClassVisibility =
927 std::optional<llvm::GlobalValue::VisibilityTypes>
928 ExternDeclDLLImportVisibility =
931 std::optional<llvm::GlobalValue::VisibilityTypes>
932 ExternDeclNoDLLStorageClassVisibility =
935 for (llvm::GlobalValue &GV : M.global_values()) {
936 if (GV.hasAppendingLinkage() || GV.hasLocalLinkage())
939 if (GV.isDeclarationForLinker())
941 llvm::GlobalValue::DLLImportStorageClass
942 ? ExternDeclDLLImportVisibility
943 : ExternDeclNoDLLStorageClassVisibility);
946 llvm::GlobalValue::DLLExportStorageClass
947 ? DLLExportVisibility
948 : NoDLLStorageClassVisibility);
950 GV.setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
955 const llvm::Triple &Triple,
959 return LangOpts.getStackProtector() == Mode;
965 EmitModuleInitializers(Primary);
967 DeferredDecls.insert_range(EmittedDeferredDecls);
968 EmittedDeferredDecls.clear();
969 EmitVTablesOpportunistically();
970 applyGlobalValReplacements();
972 emitMultiVersionFunctions();
974 if (Context.getLangOpts().IncrementalExtensions &&
975 GlobalTopLevelStmtBlockInFlight.first) {
977 GlobalTopLevelStmtBlockInFlight.first->FinishFunction(TLSD->
getEndLoc());
978 GlobalTopLevelStmtBlockInFlight = {
nullptr,
nullptr};
984 EmitCXXModuleInitFunc(Primary);
986 EmitCXXGlobalInitFunc();
987 EmitCXXGlobalCleanUpFunc();
988 registerGlobalDtorsWithAtExit();
989 EmitCXXThreadLocalInitFunc();
991 if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
993 if (Context.getLangOpts().CUDA && CUDARuntime) {
994 if (llvm::Function *CudaCtorFunction = CUDARuntime->finalizeModule())
998 OpenMPRuntime->createOffloadEntriesAndInfoMetadata();
999 OpenMPRuntime->clear();
1003 PGOReader->getSummary(
false).getMD(VMContext),
1004 llvm::ProfileSummary::PSK_Instr);
1005 if (PGOStats.hasDiagnostics())
1011 EmitCtorList(GlobalCtors,
"llvm.global_ctors");
1012 EmitCtorList(GlobalDtors,
"llvm.global_dtors");
1014 EmitStaticExternCAliases();
1019 if (CoverageMapping)
1020 CoverageMapping->emit();
1021 if (CodeGenOpts.SanitizeCfiCrossDso) {
1025 if (LangOpts.Sanitize.has(SanitizerKind::KCFI))
1027 emitAtAvailableLinkGuard();
1028 if (Context.getTargetInfo().getTriple().isWasm())
1035 if (
getTarget().getTargetOpts().CodeObjectVersion !=
1036 llvm::CodeObjectVersionKind::COV_None) {
1037 getModule().addModuleFlag(llvm::Module::Error,
1038 "amdhsa_code_object_version",
1039 getTarget().getTargetOpts().CodeObjectVersion);
1044 auto *MDStr = llvm::MDString::get(
1049 getModule().addModuleFlag(llvm::Module::Error,
"amdgpu_printf_kind",
1058 if (!Context.CUDAExternalDeviceDeclODRUsedByHost.empty()) {
1060 for (
auto D : Context.CUDAExternalDeviceDeclODRUsedByHost) {
1062 if (
auto *FD = dyn_cast<FunctionDecl>(D))
1066 UsedArray.push_back(llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
1070 llvm::ArrayType *ATy = llvm::ArrayType::get(
Int8PtrTy, UsedArray.size());
1072 auto *GV =
new llvm::GlobalVariable(
1073 getModule(), ATy,
false, llvm::GlobalValue::InternalLinkage,
1074 llvm::ConstantArray::get(ATy, UsedArray),
"__clang_gpu_used_external");
1080 auto *GV =
new llvm::GlobalVariable(
1082 llvm::Constant::getNullValue(
Int8Ty),
1091 if (CodeGenOpts.Autolink &&
1092 (Context.getLangOpts().Modules || !LinkerOptionsMetadata.empty())) {
1093 EmitModuleLinkOptions();
1108 if (!ELFDependentLibraries.empty() && !Context.getLangOpts().CUDAIsDevice) {
1109 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.dependent-libraries");
1110 for (
auto *MD : ELFDependentLibraries)
1111 NMD->addOperand(MD);
1114 if (CodeGenOpts.DwarfVersion) {
1115 getModule().addModuleFlag(llvm::Module::Max,
"Dwarf Version",
1116 CodeGenOpts.DwarfVersion);
1119 if (CodeGenOpts.Dwarf64)
1120 getModule().addModuleFlag(llvm::Module::Max,
"DWARF64", 1);
1122 if (Context.getLangOpts().SemanticInterposition)
1124 getModule().setSemanticInterposition(
true);
1126 if (CodeGenOpts.EmitCodeView) {
1128 getModule().addModuleFlag(llvm::Module::Warning,
"CodeView", 1);
1130 if (CodeGenOpts.CodeViewGHash) {
1131 getModule().addModuleFlag(llvm::Module::Warning,
"CodeViewGHash", 1);
1133 if (CodeGenOpts.ControlFlowGuard) {
1135 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 2);
1136 }
else if (CodeGenOpts.ControlFlowGuardNoChecks) {
1138 getModule().addModuleFlag(llvm::Module::Warning,
"cfguard", 1);
1140 if (CodeGenOpts.EHContGuard) {
1142 getModule().addModuleFlag(llvm::Module::Warning,
"ehcontguard", 1);
1144 if (Context.getLangOpts().Kernel) {
1146 getModule().addModuleFlag(llvm::Module::Warning,
"ms-kernel", 1);
1148 if (CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {
1153 getModule().addModuleFlag(llvm::Module::Error,
"StrictVTablePointers",1);
1155 llvm::Metadata *Ops[2] = {
1156 llvm::MDString::get(VMContext,
"StrictVTablePointers"),
1157 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1158 llvm::Type::getInt32Ty(VMContext), 1))};
1160 getModule().addModuleFlag(llvm::Module::Require,
1161 "StrictVTablePointersRequirement",
1162 llvm::MDNode::get(VMContext, Ops));
1168 getModule().addModuleFlag(llvm::Module::Warning,
"Debug Info Version",
1169 llvm::DEBUG_METADATA_VERSION);
1174 uint64_t WCharWidth =
1175 Context.getTypeSizeInChars(Context.getWideCharType()).getQuantity();
1176 getModule().addModuleFlag(llvm::Module::Error,
"wchar_size", WCharWidth);
1179 getModule().addModuleFlag(llvm::Module::Warning,
1180 "zos_product_major_version",
1181 uint32_t(CLANG_VERSION_MAJOR));
1182 getModule().addModuleFlag(llvm::Module::Warning,
1183 "zos_product_minor_version",
1184 uint32_t(CLANG_VERSION_MINOR));
1185 getModule().addModuleFlag(llvm::Module::Warning,
"zos_product_patchlevel",
1186 uint32_t(CLANG_VERSION_PATCHLEVEL));
1188 getModule().addModuleFlag(llvm::Module::Error,
"zos_product_id",
1189 llvm::MDString::get(VMContext, ProductId));
1194 getModule().addModuleFlag(llvm::Module::Error,
"zos_cu_language",
1195 llvm::MDString::get(VMContext, lang_str));
1197 time_t TT = PreprocessorOpts.SourceDateEpoch
1198 ? *PreprocessorOpts.SourceDateEpoch
1199 : std::time(
nullptr);
1200 getModule().addModuleFlag(llvm::Module::Max,
"zos_translation_time",
1201 static_cast<uint64_t
>(TT));
1204 getModule().addModuleFlag(llvm::Module::Error,
"zos_le_char_mode",
1205 llvm::MDString::get(VMContext,
"ascii"));
1208 llvm::Triple
T = Context.getTargetInfo().getTriple();
1209 if (
T.isARM() ||
T.isThumb()) {
1211 uint64_t EnumWidth = Context.getLangOpts().ShortEnums ? 1 : 4;
1212 getModule().addModuleFlag(llvm::Module::Error,
"min_enum_size", EnumWidth);
1216 StringRef ABIStr = Target.getABI();
1217 llvm::LLVMContext &Ctx = TheModule.getContext();
1218 getModule().addModuleFlag(llvm::Module::Error,
"target-abi",
1219 llvm::MDString::get(Ctx, ABIStr));
1224 const std::vector<std::string> &Features =
1227 llvm::RISCVISAInfo::parseFeatures(
T.isRISCV64() ? 64 : 32, Features);
1228 if (!errorToBool(ParseResult.takeError()))
1230 llvm::Module::AppendUnique,
"riscv-isa",
1232 Ctx, llvm::MDString::get(Ctx, (*ParseResult)->toString())));
1235 if (CodeGenOpts.SanitizeCfiCrossDso) {
1237 getModule().addModuleFlag(llvm::Module::Override,
"Cross-DSO CFI", 1);
1240 if (CodeGenOpts.WholeProgramVTables) {
1244 getModule().addModuleFlag(llvm::Module::Error,
"Virtual Function Elim",
1245 CodeGenOpts.VirtualFunctionElimination);
1248 if (LangOpts.Sanitize.has(SanitizerKind::CFIICall)) {
1249 getModule().addModuleFlag(llvm::Module::Override,
1250 "CFI Canonical Jump Tables",
1251 CodeGenOpts.SanitizeCfiCanonicalJumpTables);
1254 if (CodeGenOpts.SanitizeCfiICallNormalizeIntegers) {
1255 getModule().addModuleFlag(llvm::Module::Override,
"cfi-normalize-integers",
1259 if (!CodeGenOpts.UniqueSourceFileIdentifier.empty()) {
1261 llvm::Module::Append,
"Unique Source File Identifier",
1263 TheModule.getContext(),
1264 llvm::MDString::get(TheModule.getContext(),
1265 CodeGenOpts.UniqueSourceFileIdentifier)));
1268 if (LangOpts.Sanitize.has(SanitizerKind::KCFI)) {
1269 getModule().addModuleFlag(llvm::Module::Override,
"kcfi", 1);
1272 if (CodeGenOpts.PatchableFunctionEntryOffset)
1273 getModule().addModuleFlag(llvm::Module::Override,
"kcfi-offset",
1274 CodeGenOpts.PatchableFunctionEntryOffset);
1275 if (CodeGenOpts.SanitizeKcfiArity)
1276 getModule().addModuleFlag(llvm::Module::Override,
"kcfi-arity", 1);
1279 if (CodeGenOpts.CFProtectionReturn &&
1280 Target.checkCFProtectionReturnSupported(
getDiags())) {
1282 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-return",
1286 if (CodeGenOpts.CFProtectionBranch &&
1287 Target.checkCFProtectionBranchSupported(
getDiags())) {
1289 getModule().addModuleFlag(llvm::Module::Min,
"cf-protection-branch",
1292 auto Scheme = CodeGenOpts.getCFBranchLabelScheme();
1293 if (Target.checkCFBranchLabelSchemeSupported(Scheme,
getDiags())) {
1295 Scheme = Target.getDefaultCFBranchLabelScheme();
1297 llvm::Module::Error,
"cf-branch-label-scheme",
1303 if (CodeGenOpts.FunctionReturnThunks)
1304 getModule().addModuleFlag(llvm::Module::Override,
"function_return_thunk_extern", 1);
1306 if (CodeGenOpts.IndirectBranchCSPrefix)
1307 getModule().addModuleFlag(llvm::Module::Override,
"indirect_branch_cs_prefix", 1);
1318 if (Context.getTargetInfo().hasFeature(
"ptrauth") &&
1319 LangOpts.getSignReturnAddressScope() !=
1321 getModule().addModuleFlag(llvm::Module::Override,
1322 "sign-return-address-buildattr", 1);
1323 if (LangOpts.Sanitize.has(SanitizerKind::MemtagStack))
1324 getModule().addModuleFlag(llvm::Module::Override,
1325 "tag-stack-memory-buildattr", 1);
1327 if (
T.isARM() ||
T.isThumb() ||
T.isAArch64()) {
1335 if (LangOpts.BranchTargetEnforcement)
1336 getModule().addModuleFlag(llvm::Module::Min,
"branch-target-enforcement",
1338 if (LangOpts.BranchProtectionPAuthLR)
1339 getModule().addModuleFlag(llvm::Module::Min,
"branch-protection-pauth-lr",
1341 if (LangOpts.GuardedControlStack)
1342 getModule().addModuleFlag(llvm::Module::Min,
"guarded-control-stack", 2);
1343 if (LangOpts.hasSignReturnAddress())
1344 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address", 2);
1345 if (LangOpts.isSignReturnAddressScopeAll())
1346 getModule().addModuleFlag(llvm::Module::Min,
"sign-return-address-all",
1348 if (!LangOpts.isSignReturnAddressWithAKey())
1349 getModule().addModuleFlag(llvm::Module::Min,
1350 "sign-return-address-with-bkey", 2);
1352 if (LangOpts.PointerAuthELFGOT)
1353 getModule().addModuleFlag(llvm::Module::Min,
"ptrauth-elf-got", 1);
1356 if (LangOpts.PointerAuthCalls)
1357 getModule().addModuleFlag(llvm::Module::Min,
"ptrauth-sign-personality",
1360 using namespace llvm::ELF;
1361 uint64_t PAuthABIVersion =
1362 (LangOpts.PointerAuthIntrinsics
1363 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INTRINSICS) |
1364 (LangOpts.PointerAuthCalls
1365 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_CALLS) |
1366 (LangOpts.PointerAuthReturns
1367 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_RETURNS) |
1368 (LangOpts.PointerAuthAuthTraps
1369 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_AUTHTRAPS) |
1370 (LangOpts.PointerAuthVTPtrAddressDiscrimination
1371 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRADDRDISCR) |
1372 (LangOpts.PointerAuthVTPtrTypeDiscrimination
1373 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRTYPEDISCR) |
1374 (LangOpts.PointerAuthInitFini
1375 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINI) |
1376 (LangOpts.PointerAuthInitFiniAddressDiscrimination
1377 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINIADDRDISC) |
1378 (LangOpts.PointerAuthELFGOT
1379 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_GOT) |
1380 (LangOpts.PointerAuthIndirectGotos
1381 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_GOTOS) |
1382 (LangOpts.PointerAuthTypeInfoVTPtrDiscrimination
1383 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_TYPEINFOVPTRDISCR) |
1384 (LangOpts.PointerAuthFunctionTypeDiscrimination
1385 << AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_FPTRTYPEDISCR);
1386 static_assert(AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_FPTRTYPEDISCR ==
1387 AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_LAST,
1388 "Update when new enum items are defined");
1389 if (PAuthABIVersion != 0) {
1390 getModule().addModuleFlag(llvm::Module::Error,
1391 "aarch64-elf-pauthabi-platform",
1392 AARCH64_PAUTH_PLATFORM_LLVM_LINUX);
1393 getModule().addModuleFlag(llvm::Module::Error,
1394 "aarch64-elf-pauthabi-version",
1400 if (CodeGenOpts.StackClashProtector)
1402 llvm::Module::Override,
"probe-stack",
1403 llvm::MDString::get(TheModule.getContext(),
"inline-asm"));
1405 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
1406 getModule().addModuleFlag(llvm::Module::Min,
"stack-probe-size",
1407 CodeGenOpts.StackProbeSize);
1409 if (!CodeGenOpts.MemoryProfileOutput.empty()) {
1410 llvm::LLVMContext &Ctx = TheModule.getContext();
1412 llvm::Module::Error,
"MemProfProfileFilename",
1413 llvm::MDString::get(Ctx, CodeGenOpts.MemoryProfileOutput));
1416 if (LangOpts.CUDAIsDevice &&
getTriple().isNVPTX()) {
1420 getModule().addModuleFlag(llvm::Module::Override,
"nvvm-reflect-ftz",
1421 CodeGenOpts.FP32DenormalMode.Output !=
1422 llvm::DenormalMode::IEEE);
1425 if (LangOpts.EHAsynch)
1426 getModule().addModuleFlag(llvm::Module::Warning,
"eh-asynch", 1);
1429 if (CodeGenOpts.ImportCallOptimization)
1430 getModule().addModuleFlag(llvm::Module::Warning,
"import-call-optimization",
1434 if (CodeGenOpts.getWinX64EHUnwindV2() != llvm::WinX64EHUnwindV2Mode::Disabled)
1436 llvm::Module::Warning,
"winx64-eh-unwindv2",
1437 static_cast<unsigned>(CodeGenOpts.getWinX64EHUnwindV2()));
1441 getModule().addModuleFlag(llvm::Module::Max,
"openmp", LangOpts.OpenMP);
1443 getModule().addModuleFlag(llvm::Module::Max,
"openmp-device",
1447 if (LangOpts.OpenCL || (LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())) {
1448 EmitOpenCLMetadata();
1455 auto Version = LangOpts.getOpenCLCompatibleVersion();
1456 llvm::Metadata *SPIRVerElts[] = {
1457 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1459 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1460 Int32Ty, (Version / 100 > 1) ? 0 : 2))};
1461 llvm::NamedMDNode *SPIRVerMD =
1462 TheModule.getOrInsertNamedMetadata(
"opencl.spir.version");
1463 llvm::LLVMContext &Ctx = TheModule.getContext();
1464 SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));
1472 if (uint32_t PLevel = Context.getLangOpts().PICLevel) {
1473 assert(PLevel < 3 &&
"Invalid PIC Level");
1474 getModule().setPICLevel(
static_cast<llvm::PICLevel::Level
>(PLevel));
1475 if (Context.getLangOpts().PIE)
1476 getModule().setPIELevel(
static_cast<llvm::PIELevel::Level
>(PLevel));
1480 unsigned CM = llvm::StringSwitch<unsigned>(
getCodeGenOpts().CodeModel)
1481 .Case(
"tiny", llvm::CodeModel::Tiny)
1482 .Case(
"small", llvm::CodeModel::Small)
1483 .Case(
"kernel", llvm::CodeModel::Kernel)
1484 .Case(
"medium", llvm::CodeModel::Medium)
1485 .Case(
"large", llvm::CodeModel::Large)
1488 llvm::CodeModel::Model codeModel =
static_cast<llvm::CodeModel::Model
>(CM);
1491 if ((CM == llvm::CodeModel::Medium || CM == llvm::CodeModel::Large) &&
1492 Context.getTargetInfo().getTriple().getArch() ==
1493 llvm::Triple::x86_64) {
1499 if (CodeGenOpts.NoPLT)
1502 CodeGenOpts.DirectAccessExternalData !=
1503 getModule().getDirectAccessExternalData()) {
1504 getModule().setDirectAccessExternalData(
1505 CodeGenOpts.DirectAccessExternalData);
1507 if (CodeGenOpts.UnwindTables)
1508 getModule().setUwtable(llvm::UWTableKind(CodeGenOpts.UnwindTables));
1510 switch (CodeGenOpts.getFramePointer()) {
1515 getModule().setFramePointer(llvm::FramePointerKind::Reserved);
1518 getModule().setFramePointer(llvm::FramePointerKind::NonLeaf);
1521 getModule().setFramePointer(llvm::FramePointerKind::All);
1525 SimplifyPersonality();
1538 EmitVersionIdentMetadata();
1541 EmitCommandLineMetadata();
1549 getModule().setStackProtectorGuardSymbol(
1552 getModule().setStackProtectorGuardOffset(
1557 getModule().addModuleFlag(llvm::Module::Override,
"SkipRaxSetup", 1);
1559 getModule().addModuleFlag(llvm::Module::Override,
"RegCallv4", 1);
1561 if (
getContext().getTargetInfo().getMaxTLSAlign())
1562 getModule().addModuleFlag(llvm::Module::Error,
"MaxTLSAlign",
1563 getContext().getTargetInfo().getMaxTLSAlign());
1581 if (
getTriple().isPPC() && !MustTailCallUndefinedGlobals.empty()) {
1582 for (
auto &I : MustTailCallUndefinedGlobals) {
1583 if (!I.first->isDefined())
1584 getDiags().
Report(I.second, diag::err_ppc_impossible_musttail) << 2;
1588 if (!Entry || Entry->isWeakForLinker() ||
1589 Entry->isDeclarationForLinker())
1590 getDiags().
Report(I.second, diag::err_ppc_impossible_musttail) << 2;
1601 auto *ErrnoTBAAMD = TheModule.getOrInsertNamedMetadata(
ErrnoTBAAMDName);
1602 ErrnoTBAAMD->addOperand(IntegerNode);
1607void CodeGenModule::EmitOpenCLMetadata() {
1613 auto EmitVersion = [
this](StringRef MDName,
int Version) {
1614 llvm::Metadata *OCLVerElts[] = {
1615 llvm::ConstantAsMetadata::get(
1616 llvm::ConstantInt::get(
Int32Ty, Version / 100)),
1617 llvm::ConstantAsMetadata::get(
1618 llvm::ConstantInt::get(
Int32Ty, (Version % 100) / 10))};
1619 llvm::NamedMDNode *OCLVerMD = TheModule.getOrInsertNamedMetadata(MDName);
1620 llvm::LLVMContext &Ctx = TheModule.getContext();
1621 OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));
1624 EmitVersion(
"opencl.ocl.version", CLVersion);
1625 if (LangOpts.OpenCLCPlusPlus) {
1627 EmitVersion(
"opencl.cxx.version", LangOpts.OpenCLCPlusPlusVersion);
1631void CodeGenModule::EmitBackendOptionsMetadata(
1632 const CodeGenOptions &CodeGenOpts) {
1634 getModule().addModuleFlag(llvm::Module::Min,
"SmallDataLimit",
1635 CodeGenOpts.SmallDataLimit);
1652 return TBAA->getTypeInfo(QTy);
1671 return TBAA->getAccessInfo(AccessType);
1678 return TBAA->getVTablePtrAccessInfo(VTablePtrType);
1684 return TBAA->getTBAAStructInfo(QTy);
1690 return TBAA->getBaseTypeInfo(QTy);
1696 return TBAA->getAccessTagInfo(Info);
1703 return TBAA->mergeTBAAInfoForCast(SourceInfo,
TargetInfo);
1711 return TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);
1719 return TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);
1725 Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);
1730 I->setMetadata(llvm::LLVMContext::MD_invariant_group,
1743 "cannot compile this %0 yet");
1744 std::string Msg =
Type;
1753 "cannot compile this %0 yet");
1754 std::string Msg =
Type;
1759 llvm::function_ref<
void()> Fn) {
1760 StackHandler.runWithSufficientStackSpace(Loc, Fn);
1770 if (GV->hasLocalLinkage()) {
1771 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
1784 if (Context.getLangOpts().OpenMP &&
1785 Context.getLangOpts().OpenMPIsTargetDevice &&
isa<VarDecl>(D) &&
1786 D->
hasAttr<OMPDeclareTargetDeclAttr>() &&
1787 D->
getAttr<OMPDeclareTargetDeclAttr>()->getDevType() !=
1788 OMPDeclareTargetDeclAttr::DT_NoHost &&
1790 GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);
1795 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
1799 if (GV->hasDLLExportStorageClass() || GV->hasDLLImportStorageClass()) {
1803 if (GV->hasDLLExportStorageClass()) {
1806 diag::err_hidden_visibility_dllexport);
1809 diag::err_non_default_visibility_dllimport);
1815 !GV->isDeclarationForLinker())
1820 llvm::GlobalValue *GV) {
1821 if (GV->hasLocalLinkage())
1824 if (!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())
1828 if (GV->hasDLLImportStorageClass())
1831 const llvm::Triple &TT = CGM.
getTriple();
1833 if (TT.isOSCygMing()) {
1851 if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())
1859 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
1863 if (!TT.isOSBinFormatELF())
1869 if (RM != llvm::Reloc::Static && !LOpts.PIE) {
1877 return !(CGM.
getLangOpts().SemanticInterposition ||
1882 if (!GV->isDeclarationForLinker())
1888 if (RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())
1895 if (CGOpts.DirectAccessExternalData) {
1901 if (
auto *Var = dyn_cast<llvm::GlobalVariable>(GV))
1902 if (!Var->isThreadLocal())
1927 const auto *D = dyn_cast<NamedDecl>(GD.
getDecl());
1929 if (
const auto *Dtor = dyn_cast_or_null<CXXDestructorDecl>(D)) {
1939 if (D->
hasAttr<DLLImportAttr>())
1940 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
1941 else if ((D->
hasAttr<DLLExportAttr>() ||
1943 !GV->isDeclarationForLinker())
1944 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
1964 GV->setPartition(CodeGenOpts.SymbolPartition);
1968 return llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)
1969 .Case(
"global-dynamic", llvm::GlobalVariable::GeneralDynamicTLSModel)
1970 .Case(
"local-dynamic", llvm::GlobalVariable::LocalDynamicTLSModel)
1971 .Case(
"initial-exec", llvm::GlobalVariable::InitialExecTLSModel)
1972 .Case(
"local-exec", llvm::GlobalVariable::LocalExecTLSModel);
1975llvm::GlobalVariable::ThreadLocalMode
1977 switch (CodeGenOpts.getDefaultTLSModel()) {
1979 return llvm::GlobalVariable::GeneralDynamicTLSModel;
1981 return llvm::GlobalVariable::LocalDynamicTLSModel;
1983 return llvm::GlobalVariable::InitialExecTLSModel;
1985 return llvm::GlobalVariable::LocalExecTLSModel;
1987 llvm_unreachable(
"Invalid TLS model!");
1991 assert(D.
getTLSKind() &&
"setting TLS mode on non-TLS var!");
1993 llvm::GlobalValue::ThreadLocalMode TLM;
1997 if (
const TLSModelAttr *
Attr = D.
getAttr<TLSModelAttr>()) {
2001 GV->setThreadLocalMode(TLM);
2007 return (Twine(
'.') + Twine(
Target.CPUSpecificManglingCharacter(Name))).str();
2011 const CPUSpecificAttr *
Attr,
2033 bool OmitMultiVersionMangling =
false) {
2035 llvm::raw_svector_ostream Out(Buffer);
2044 assert(II &&
"Attempt to mangle unnamed decl.");
2045 const auto *FD = dyn_cast<FunctionDecl>(ND);
2050 Out <<
"__regcall4__" << II->
getName();
2052 Out <<
"__regcall3__" << II->
getName();
2053 }
else if (FD && FD->hasAttr<CUDAGlobalAttr>() &&
2055 Out <<
"__device_stub__" << II->
getName();
2057 DeviceKernelAttr::isOpenCLSpelling(
2058 FD->getAttr<DeviceKernelAttr>()) &&
2060 Out <<
"__clang_ocl_kern_imp_" << II->
getName();
2076 "Hash computed when not explicitly requested");
2080 if (
const auto *FD = dyn_cast<FunctionDecl>(ND))
2081 if (FD->isMultiVersion() && !OmitMultiVersionMangling) {
2082 switch (FD->getMultiVersionKind()) {
2086 FD->getAttr<CPUSpecificAttr>(),
2090 auto *
Attr = FD->getAttr<TargetAttr>();
2091 assert(
Attr &&
"Expected TargetAttr to be present "
2092 "for attribute mangling");
2098 auto *
Attr = FD->getAttr<TargetVersionAttr>();
2099 assert(
Attr &&
"Expected TargetVersionAttr to be present "
2100 "for attribute mangling");
2106 auto *
Attr = FD->getAttr<TargetClonesAttr>();
2107 assert(
Attr &&
"Expected TargetClonesAttr to be present "
2108 "for attribute mangling");
2115 llvm_unreachable(
"None multiversion type isn't valid here");
2125 return std::string(Out.str());
2128void CodeGenModule::UpdateMultiVersionNames(GlobalDecl GD,
2129 const FunctionDecl *FD,
2130 StringRef &CurName) {
2137 std::string NonTargetName =
2145 "Other GD should now be a multiversioned function");
2155 if (OtherName != NonTargetName) {
2158 const auto ExistingRecord = Manglings.find(NonTargetName);
2159 if (ExistingRecord != std::end(Manglings))
2160 Manglings.remove(&(*ExistingRecord));
2161 auto Result = Manglings.insert(std::make_pair(OtherName, OtherGD));
2166 CurName = OtherNameRef;
2168 Entry->setName(OtherName);
2178 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.
getDecl())) {
2192 auto FoundName = MangledDeclNames.find(CanonicalGD);
2193 if (FoundName != MangledDeclNames.end())
2194 return FoundName->second;
2231 auto Result = Manglings.insert(std::make_pair(MangledName, GD));
2232 return MangledDeclNames[CanonicalGD] =
Result.first->first();
2241 llvm::raw_svector_ostream Out(Buffer);
2244 dyn_cast_or_null<VarDecl>(initializedGlobalDecl.getDecl()), Out);
2245 else if (
const auto *CD = dyn_cast<CXXConstructorDecl>(D))
2247 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(D))
2252 auto Result = Manglings.insert(std::make_pair(Out.str(), BD));
2253 return Result.first->first();
2257 auto it = MangledDeclNames.begin();
2258 while (it != MangledDeclNames.end()) {
2259 if (it->second == Name)
2274 llvm::Constant *AssociatedData) {
2276 GlobalCtors.push_back(
Structor(Priority, LexOrder, Ctor, AssociatedData));
2282 bool IsDtorAttrFunc) {
2283 if (CodeGenOpts.RegisterGlobalDtorsWithAtExit &&
2285 DtorsUsingAtExit[Priority].push_back(Dtor);
2290 GlobalDtors.push_back(
Structor(Priority, ~0
U, Dtor,
nullptr));
2293void CodeGenModule::EmitCtorList(CtorList &Fns,
const char *GlobalName) {
2294 if (Fns.empty())
return;
2300 llvm::PointerType *PtrTy = llvm::PointerType::get(
2301 getLLVMContext(), TheModule.getDataLayout().getProgramAddressSpace());
2304 llvm::StructType *CtorStructTy = llvm::StructType::get(
Int32Ty, PtrTy, PtrTy);
2308 auto Ctors = Builder.beginArray(CtorStructTy);
2309 for (
const auto &I : Fns) {
2310 auto Ctor = Ctors.beginStruct(CtorStructTy);
2311 Ctor.addInt(
Int32Ty, I.Priority);
2312 if (InitFiniAuthSchema) {
2313 llvm::Constant *StorageAddress =
2315 ? llvm::ConstantExpr::getIntToPtr(
2316 llvm::ConstantInt::get(
2318 llvm::ConstantPtrAuth::AddrDiscriminator_CtorsDtors),
2322 I.Initializer, InitFiniAuthSchema.
getKey(), StorageAddress,
2323 llvm::ConstantInt::get(
2325 Ctor.add(SignedCtorPtr);
2327 Ctor.add(I.Initializer);
2329 if (I.AssociatedData)
2330 Ctor.add(I.AssociatedData);
2332 Ctor.addNullPointer(PtrTy);
2333 Ctor.finishAndAddTo(Ctors);
2336 auto List = Ctors.finishAndCreateGlobal(GlobalName,
getPointerAlign(),
2338 llvm::GlobalValue::AppendingLinkage);
2342 List->setAlignment(std::nullopt);
2347llvm::GlobalValue::LinkageTypes
2353 if (
const auto *Dtor = dyn_cast<CXXDestructorDecl>(D))
2360 llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);
2361 if (!MDS)
return nullptr;
2363 return llvm::ConstantInt::get(
Int64Ty, llvm::MD5Hash(MDS->getString()));
2370 const RecordDecl *UD = UT->getDecl()->getDefinitionOrSelf();
2371 if (!UD->
hasAttr<TransparentUnionAttr>())
2373 for (
const auto *it : UD->
fields()) {
2374 return it->getType();
2384 bool GeneralizePointers) {
2397 bool GeneralizePointers) {
2400 for (
auto &Param : FnType->param_types())
2401 GeneralizedParams.push_back(
2405 GeneralizeType(Ctx, FnType->getReturnType(), GeneralizePointers),
2406 GeneralizedParams, FnType->getExtProtoInfo());
2411 GeneralizeType(Ctx, FnType->getReturnType(), GeneralizePointers));
2413 llvm_unreachable(
"Encountered unknown FunctionType");
2421 FnType->getReturnType(), FnType->getParamTypes(),
2422 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
2424 std::string OutName;
2425 llvm::raw_string_ostream Out(OutName);
2433 Out <<
".normalized";
2435 Out <<
".generalized";
2437 return llvm::ConstantInt::get(
Int32Ty,
2438 static_cast<uint32_t
>(llvm::xxHash64(OutName)));
2443 llvm::Function *F,
bool IsThunk) {
2445 llvm::AttributeList PAL;
2448 if (
CallingConv == llvm::CallingConv::X86_VectorCall &&
2452 Loc = D->getLocation();
2454 Error(Loc,
"__vectorcall calling convention is not currently supported");
2456 F->setAttributes(PAL);
2457 F->setCallingConv(
static_cast<llvm::CallingConv::ID
>(
CallingConv));
2461 std::string ReadOnlyQual(
"__read_only");
2462 std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);
2463 if (ReadOnlyPos != std::string::npos)
2465 TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);
2467 std::string WriteOnlyQual(
"__write_only");
2468 std::string::size_type WriteOnlyPos = TyName.find(WriteOnlyQual);
2469 if (WriteOnlyPos != std::string::npos)
2470 TyName.erase(WriteOnlyPos, WriteOnlyQual.size() + 1);
2472 std::string ReadWriteQual(
"__read_write");
2473 std::string::size_type ReadWritePos = TyName.find(ReadWriteQual);
2474 if (ReadWritePos != std::string::npos)
2475 TyName.erase(ReadWritePos, ReadWriteQual.size() + 1);
2508 assert(((FD && CGF) || (!FD && !CGF)) &&
2509 "Incorrect use - FD and CGF should either be both null or not!");
2535 for (
unsigned i = 0, e = FD->
getNumParams(); i != e; ++i) {
2538 argNames.push_back(llvm::MDString::get(VMContext, parm->
getName()));
2543 std::string typeQuals;
2547 const Decl *PDecl = parm;
2549 PDecl = TD->getDecl();
2550 const OpenCLAccessAttr *A = PDecl->
getAttr<OpenCLAccessAttr>();
2551 if (A && A->isWriteOnly())
2552 accessQuals.push_back(llvm::MDString::get(VMContext,
"write_only"));
2553 else if (A && A->isReadWrite())
2554 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_write"));
2556 accessQuals.push_back(llvm::MDString::get(VMContext,
"read_only"));
2558 accessQuals.push_back(llvm::MDString::get(VMContext,
"none"));
2560 auto getTypeSpelling = [&](
QualType Ty) {
2561 auto typeName = Ty.getUnqualifiedType().getAsString(Policy);
2563 if (Ty.isCanonical()) {
2564 StringRef typeNameRef = typeName;
2566 if (typeNameRef.consume_front(
"unsigned "))
2567 return std::string(
"u") + typeNameRef.str();
2568 if (typeNameRef.consume_front(
"signed "))
2569 return typeNameRef.str();
2579 addressQuals.push_back(
2580 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(
2584 std::string typeName = getTypeSpelling(pointeeTy) +
"*";
2585 std::string baseTypeName =
2587 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2588 argBaseTypeNames.push_back(
2589 llvm::MDString::get(VMContext, baseTypeName));
2593 typeQuals =
"restrict";
2596 typeQuals += typeQuals.empty() ?
"const" :
" const";
2598 typeQuals += typeQuals.empty() ?
"volatile" :
" volatile";
2600 uint32_t AddrSpc = 0;
2605 addressQuals.push_back(
2606 llvm::ConstantAsMetadata::get(CGF->
Builder.getInt32(AddrSpc)));
2610 std::string typeName = getTypeSpelling(ty);
2622 argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));
2623 argBaseTypeNames.push_back(
2624 llvm::MDString::get(VMContext, baseTypeName));
2629 argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));
2633 Fn->setMetadata(
"kernel_arg_addr_space",
2634 llvm::MDNode::get(VMContext, addressQuals));
2635 Fn->setMetadata(
"kernel_arg_access_qual",
2636 llvm::MDNode::get(VMContext, accessQuals));
2637 Fn->setMetadata(
"kernel_arg_type",
2638 llvm::MDNode::get(VMContext, argTypeNames));
2639 Fn->setMetadata(
"kernel_arg_base_type",
2640 llvm::MDNode::get(VMContext, argBaseTypeNames));
2641 Fn->setMetadata(
"kernel_arg_type_qual",
2642 llvm::MDNode::get(VMContext, argTypeQuals));
2646 Fn->setMetadata(
"kernel_arg_name",
2647 llvm::MDNode::get(VMContext, argNames));
2657 if (!LangOpts.Exceptions)
return false;
2660 if (LangOpts.CXXExceptions)
return true;
2663 if (LangOpts.ObjCExceptions) {
2683SmallVector<const CXXRecordDecl *, 0>
2685 llvm::SetVector<const CXXRecordDecl *> MostBases;
2690 MostBases.insert(RD);
2692 CollectMostBases(B.getType()->getAsCXXRecordDecl());
2694 CollectMostBases(RD);
2695 return MostBases.takeVector();
2699 llvm::Function *F) {
2700 llvm::AttrBuilder B(F->getContext());
2702 if ((!D || !D->
hasAttr<NoUwtableAttr>()) && CodeGenOpts.UnwindTables)
2703 B.addUWTableAttr(llvm::UWTableKind(CodeGenOpts.UnwindTables));
2705 if (CodeGenOpts.StackClashProtector)
2706 B.addAttribute(
"probe-stack",
"inline-asm");
2708 if (CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)
2709 B.addAttribute(
"stack-probe-size",
2710 std::to_string(CodeGenOpts.StackProbeSize));
2713 B.addAttribute(llvm::Attribute::NoUnwind);
2715 if (D && D->
hasAttr<NoStackProtectorAttr>())
2717 else if (D && D->
hasAttr<StrictGuardStackCheckAttr>() &&
2719 B.addAttribute(llvm::Attribute::StackProtectStrong);
2721 B.addAttribute(llvm::Attribute::StackProtect);
2723 B.addAttribute(llvm::Attribute::StackProtectStrong);
2725 B.addAttribute(llvm::Attribute::StackProtectReq);
2729 if (
getLangOpts().
HLSL && !F->hasFnAttribute(llvm::Attribute::NoInline))
2730 B.addAttribute(llvm::Attribute::AlwaysInline);
2734 else if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&
2736 B.addAttribute(llvm::Attribute::NoInline);
2744 if (D->
hasAttr<ArmLocallyStreamingAttr>())
2745 B.addAttribute(
"aarch64_pstate_sm_body");
2748 if (
Attr->isNewZA())
2749 B.addAttribute(
"aarch64_new_za");
2750 if (
Attr->isNewZT0())
2751 B.addAttribute(
"aarch64_new_zt0");
2756 bool ShouldAddOptNone =
2757 !CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;
2759 ShouldAddOptNone &= !D->
hasAttr<MinSizeAttr>();
2760 ShouldAddOptNone &= !D->
hasAttr<AlwaysInlineAttr>();
2763 if (
getLangOpts().
HLSL && !F->hasFnAttribute(llvm::Attribute::NoInline) &&
2764 !D->
hasAttr<NoInlineAttr>()) {
2765 B.addAttribute(llvm::Attribute::AlwaysInline);
2766 }
else if ((ShouldAddOptNone || D->
hasAttr<OptimizeNoneAttr>()) &&
2767 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2769 B.addAttribute(llvm::Attribute::OptimizeNone);
2772 B.addAttribute(llvm::Attribute::NoInline);
2777 B.addAttribute(llvm::Attribute::Naked);
2780 F->removeFnAttr(llvm::Attribute::OptimizeForSize);
2781 F->removeFnAttr(llvm::Attribute::MinSize);
2782 }
else if (D->
hasAttr<NakedAttr>()) {
2784 B.addAttribute(llvm::Attribute::Naked);
2785 B.addAttribute(llvm::Attribute::NoInline);
2786 }
else if (D->
hasAttr<NoDuplicateAttr>()) {
2787 B.addAttribute(llvm::Attribute::NoDuplicate);
2788 }
else if (D->
hasAttr<NoInlineAttr>() &&
2789 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2791 B.addAttribute(llvm::Attribute::NoInline);
2792 }
else if (D->
hasAttr<AlwaysInlineAttr>() &&
2793 !F->hasFnAttribute(llvm::Attribute::NoInline)) {
2795 B.addAttribute(llvm::Attribute::AlwaysInline);
2799 if (!F->hasFnAttribute(llvm::Attribute::AlwaysInline))
2800 B.addAttribute(llvm::Attribute::NoInline);
2804 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
2807 auto CheckRedeclForInline = [](
const FunctionDecl *Redecl) {
2808 return Redecl->isInlineSpecified();
2810 if (any_of(FD->
redecls(), CheckRedeclForInline))
2815 return any_of(Pattern->
redecls(), CheckRedeclForInline);
2817 if (CheckForInline(FD)) {
2818 B.addAttribute(llvm::Attribute::InlineHint);
2819 }
else if (CodeGenOpts.getInlining() ==
2822 !F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {
2823 B.addAttribute(llvm::Attribute::NoInline);
2830 if (!D->
hasAttr<OptimizeNoneAttr>()) {
2832 if (!ShouldAddOptNone)
2833 B.addAttribute(llvm::Attribute::OptimizeForSize);
2834 B.addAttribute(llvm::Attribute::Cold);
2837 B.addAttribute(llvm::Attribute::Hot);
2838 if (D->
hasAttr<MinSizeAttr>())
2839 B.addAttribute(llvm::Attribute::MinSize);
2846 F->setAlignment(llvm::Align(alignment));
2848 if (!D->
hasAttr<AlignedAttr>())
2849 if (LangOpts.FunctionAlignment)
2850 F->setAlignment(llvm::Align(1ull << LangOpts.FunctionAlignment));
2858 F->setAlignment(std::max(llvm::Align(2), F->getAlign().valueOrOne()));
2863 if (CodeGenOpts.SanitizeCfiCrossDso &&
2864 CodeGenOpts.SanitizeCfiCanonicalJumpTables) {
2865 if (
auto *FD = dyn_cast<FunctionDecl>(D)) {
2873 if (CodeGenOpts.CallGraphSection) {
2874 if (
auto *FD = dyn_cast<FunctionDecl>(D))
2881 auto *MD = dyn_cast<CXXMethodDecl>(D);
2884 llvm::Metadata *Id =
2886 MD->getType(), std::nullopt,
Base));
2887 F->addTypeMetadata(0, Id);
2894 if (isa_and_nonnull<NamedDecl>(D))
2897 GV->setVisibility(llvm::GlobalValue::DefaultVisibility);
2899 if (D && D->
hasAttr<UsedAttr>())
2902 if (
const auto *VD = dyn_cast_if_present<VarDecl>(D);
2904 ((CodeGenOpts.KeepPersistentStorageVariables &&
2905 (VD->getStorageDuration() ==
SD_Static ||
2906 VD->getStorageDuration() ==
SD_Thread)) ||
2907 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==
SD_Static &&
2908 VD->getType().isConstQualified())))
2912bool CodeGenModule::GetCPUAndFeaturesAttributes(
GlobalDecl GD,
2913 llvm::AttrBuilder &Attrs,
2914 bool SetTargetFeatures) {
2920 std::vector<std::string> Features;
2921 const auto *FD = dyn_cast_or_null<FunctionDecl>(GD.
getDecl());
2924 const auto *TV = FD ? FD->
getAttr<TargetVersionAttr>() :
nullptr;
2925 assert((!TD || !TV) &&
"both target_version and target specified");
2928 bool AddedAttr =
false;
2929 if (TD || TV || SD || TC) {
2930 llvm::StringMap<bool> FeatureMap;
2934 for (
const llvm::StringMap<bool>::value_type &Entry : FeatureMap)
2935 Features.push_back((Entry.getValue() ?
"+" :
"-") + Entry.getKey().str());
2943 Target.parseTargetAttr(TD->getFeaturesStr());
2965 if (!TargetCPU.empty()) {
2966 Attrs.addAttribute(
"target-cpu", TargetCPU);
2969 if (!TuneCPU.empty()) {
2970 Attrs.addAttribute(
"tune-cpu", TuneCPU);
2973 if (!Features.empty() && SetTargetFeatures) {
2974 llvm::erase_if(Features, [&](
const std::string& F) {
2977 llvm::sort(Features);
2978 Attrs.addAttribute(
"target-features", llvm::join(Features,
","));
2983 llvm::SmallVector<StringRef, 8> Feats;
2984 bool IsDefault =
false;
2986 IsDefault = TV->isDefaultVersion();
2987 TV->getFeatures(Feats);
2993 Attrs.addAttribute(
"fmv-features");
2995 }
else if (!Feats.empty()) {
2997 std::set<StringRef> OrderedFeats(Feats.begin(), Feats.end());
2998 std::string FMVFeatures;
2999 for (StringRef F : OrderedFeats)
3000 FMVFeatures.append(
"," + F.str());
3001 Attrs.addAttribute(
"fmv-features", FMVFeatures.substr(1));
3008void CodeGenModule::setNonAliasAttributes(GlobalDecl GD,
3009 llvm::GlobalObject *GO) {
3014 if (
auto *GV = dyn_cast<llvm::GlobalVariable>(GO)) {
3017 if (
auto *SA = D->
getAttr<PragmaClangBSSSectionAttr>())
3018 GV->addAttribute(
"bss-section", SA->getName());
3019 if (
auto *SA = D->
getAttr<PragmaClangDataSectionAttr>())
3020 GV->addAttribute(
"data-section", SA->getName());
3021 if (
auto *SA = D->
getAttr<PragmaClangRodataSectionAttr>())
3022 GV->addAttribute(
"rodata-section", SA->getName());
3023 if (
auto *SA = D->
getAttr<PragmaClangRelroSectionAttr>())
3024 GV->addAttribute(
"relro-section", SA->getName());
3027 if (
auto *F = dyn_cast<llvm::Function>(GO)) {
3030 if (
auto *SA = D->
getAttr<PragmaClangTextSectionAttr>())
3031 if (!D->
getAttr<SectionAttr>())
3032 F->setSection(SA->getName());
3034 llvm::AttrBuilder Attrs(F->getContext());
3035 if (GetCPUAndFeaturesAttributes(GD, Attrs)) {
3039 llvm::AttributeMask RemoveAttrs;
3040 RemoveAttrs.addAttribute(
"target-cpu");
3041 RemoveAttrs.addAttribute(
"target-features");
3042 RemoveAttrs.addAttribute(
"fmv-features");
3043 RemoveAttrs.addAttribute(
"tune-cpu");
3044 F->removeFnAttrs(RemoveAttrs);
3045 F->addFnAttrs(Attrs);
3049 if (
const auto *CSA = D->
getAttr<CodeSegAttr>())
3050 GO->setSection(CSA->getName());
3051 else if (
const auto *SA = D->
getAttr<SectionAttr>())
3052 GO->setSection(SA->getName());
3065 F->setLinkage(llvm::Function::InternalLinkage);
3067 setNonAliasAttributes(GD, F);
3078 GV->
setLinkage(llvm::GlobalValue::ExternalWeakLinkage);
3082 llvm::MDNode *MD = F->getMetadata(llvm::LLVMContext::MD_type);
3083 return MD && MD->hasGeneralizedMDString();
3087 llvm::Function *F) {
3094 if (!F->hasLocalLinkage() ||
3095 F->getFunction().hasAddressTaken(
nullptr,
true,
3102 llvm::Function *F) {
3104 if (!LangOpts.Sanitize.has(SanitizerKind::CFIICall))
3115 F->addTypeMetadata(0, MD);
3124 if (CodeGenOpts.SanitizeCfiCrossDso)
3126 F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));
3130 llvm::CallBase *CB) {
3132 if (!CodeGenOpts.CallGraphSection || !CB->isIndirectCall())
3136 llvm::MDTuple *TypeTuple = llvm::MDTuple::get(
3137 getLLVMContext(), {llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
3140 llvm::MDTuple *MDN = llvm::MDNode::get(
getLLVMContext(), {TypeTuple});
3141 CB->setMetadata(llvm::LLVMContext::MD_callee_type, MDN);
3145 llvm::LLVMContext &Ctx = F->getContext();
3146 llvm::MDBuilder MDB(Ctx);
3147 llvm::StringRef Salt;
3150 if (
const auto &Info = FP->getExtraAttributeInfo())
3151 Salt = Info.CFISalt;
3153 F->setMetadata(llvm::LLVMContext::MD_kcfi_type,
3162 return llvm::all_of(Name, [](
const char &
C) {
3163 return llvm::isAlnum(
C) ||
C ==
'_' ||
C ==
'.';
3169 for (
auto &F : M.functions()) {
3171 bool AddressTaken = F.hasAddressTaken();
3172 if (!AddressTaken && F.hasLocalLinkage())
3173 F.eraseMetadata(llvm::LLVMContext::MD_kcfi_type);
3178 if (!AddressTaken || !F.isDeclaration())
3181 const llvm::ConstantInt *
Type;
3182 if (
const llvm::MDNode *MD = F.getMetadata(llvm::LLVMContext::MD_kcfi_type))
3183 Type = llvm::mdconst::extract<llvm::ConstantInt>(MD->getOperand(0));
3187 StringRef Name = F.getName();
3191 std::string
Asm = (
".weak __kcfi_typeid_" + Name +
"\n.set __kcfi_typeid_" +
3192 Name +
", " + Twine(
Type->getZExtValue()) +
"\n")
3194 M.appendModuleInlineAsm(
Asm);
3198void CodeGenModule::SetFunctionAttributes(
GlobalDecl GD, llvm::Function *F,
3199 bool IsIncompleteFunction,
3202 if (F->getIntrinsicID() != llvm::Intrinsic::not_intrinsic) {
3210 if (!IsIncompleteFunction)
3217 if (!IsThunk &&
getCXXABI().HasThisReturn(GD) &&
3219 assert(!F->arg_empty() &&
3220 F->arg_begin()->getType()
3221 ->canLosslesslyBitCastTo(F->getReturnType()) &&
3222 "unexpected this return");
3223 F->addParamAttr(0, llvm::Attribute::Returned);
3233 if (!IsIncompleteFunction && F->isDeclaration())
3236 if (
const auto *CSA = FD->
getAttr<CodeSegAttr>())
3237 F->setSection(CSA->getName());
3238 else if (
const auto *SA = FD->
getAttr<SectionAttr>())
3239 F->setSection(SA->getName());
3241 if (
const auto *EA = FD->
getAttr<ErrorAttr>()) {
3243 F->addFnAttr(
"dontcall-error", EA->getUserDiagnostic());
3244 else if (EA->isWarning())
3245 F->addFnAttr(
"dontcall-warn", EA->getUserDiagnostic());
3250 const FunctionDecl *FDBody;
3251 bool HasBody = FD->
hasBody(FDBody);
3253 assert(HasBody &&
"Inline builtin declarations should always have an "
3255 if (shouldEmitFunction(FDBody))
3256 F->addFnAttr(llvm::Attribute::NoBuiltin);
3262 F->addFnAttr(llvm::Attribute::NoBuiltin);
3266 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3267 else if (
const auto *MD = dyn_cast<CXXMethodDecl>(FD))
3268 if (MD->isVirtual())
3269 F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3275 if (!CodeGenOpts.SanitizeCfiCrossDso ||
3276 !CodeGenOpts.SanitizeCfiCanonicalJumpTables)
3279 if (CodeGenOpts.CallGraphSection)
3282 if (LangOpts.Sanitize.has(SanitizerKind::KCFI))
3288 if (CodeGenOpts.InlineMaxStackSize !=
UINT_MAX)
3289 F->addFnAttr(
"inline-max-stacksize", llvm::utostr(CodeGenOpts.InlineMaxStackSize));
3291 if (
const auto *CB = FD->
getAttr<CallbackAttr>()) {
3295 llvm::LLVMContext &Ctx = F->getContext();
3296 llvm::MDBuilder MDB(Ctx);
3300 int CalleeIdx = *CB->encoding_begin();
3301 ArrayRef<int> PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());
3302 F->addMetadata(llvm::LLVMContext::MD_callback,
3303 *llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(
3304 CalleeIdx, PayloadIndices,
3311 "Only globals with definition can force usage.");
3312 LLVMUsed.emplace_back(GV);
3316 assert(!GV->isDeclaration() &&
3317 "Only globals with definition can force usage.");
3318 LLVMCompilerUsed.emplace_back(GV);
3323 "Only globals with definition can force usage.");
3325 LLVMCompilerUsed.emplace_back(GV);
3327 LLVMUsed.emplace_back(GV);
3331 std::vector<llvm::WeakTrackingVH> &List) {
3338 UsedArray.resize(List.size());
3339 for (
unsigned i = 0, e = List.size(); i != e; ++i) {
3341 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(
3345 if (UsedArray.empty())
3347 llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.
Int8PtrTy, UsedArray.size());
3349 auto *GV =
new llvm::GlobalVariable(
3350 CGM.
getModule(), ATy,
false, llvm::GlobalValue::AppendingLinkage,
3351 llvm::ConstantArray::get(ATy, UsedArray), Name);
3353 GV->setSection(
"llvm.metadata");
3356void CodeGenModule::emitLLVMUsed() {
3357 emitUsed(*
this,
"llvm.used", LLVMUsed);
3358 emitUsed(*
this,
"llvm.compiler.used", LLVMCompilerUsed);
3363 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
3372 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
getLLVMContext(), MDOpts));
3378 ELFDependentLibraries.push_back(
3379 llvm::MDNode::get(
C, llvm::MDString::get(
C, Lib)));
3386 LinkerOptionsMetadata.push_back(llvm::MDNode::get(
C, MDOpts));
3395 if (Mod->
Parent && Visited.insert(Mod->
Parent).second) {
3401 if (Visited.insert(Import).second)
3418 if (LL.IsFramework) {
3419 llvm::Metadata *Args[2] = {llvm::MDString::get(Context,
"-framework"),
3420 llvm::MDString::get(Context, LL.Library)};
3422 Metadata.push_back(llvm::MDNode::get(Context, Args));
3428 llvm::Metadata *Args[2] = {
3429 llvm::MDString::get(Context,
"lib"),
3430 llvm::MDString::get(Context, LL.Library),
3432 Metadata.push_back(llvm::MDNode::get(Context, Args));
3436 auto *OptString = llvm::MDString::get(Context, Opt);
3437 Metadata.push_back(llvm::MDNode::get(Context, OptString));
3442void CodeGenModule::EmitModuleInitializers(
clang::Module *Primary) {
3444 "We should only emit module initializers for named modules.");
3452 assert(
isa<VarDecl>(D) &&
"GMF initializer decl is not a var?");
3469 assert(
isa<VarDecl>(D) &&
"PMF initializer decl is not a var?");
3475void CodeGenModule::EmitModuleLinkOptions() {
3479 llvm::SetVector<clang::Module *> LinkModules;
3480 llvm::SmallPtrSet<clang::Module *, 16> Visited;
3481 SmallVector<clang::Module *, 16> Stack;
3484 for (
Module *M : ImportedModules) {
3487 if (M->getTopLevelModuleName() ==
getLangOpts().CurrentModule &&
3490 if (Visited.insert(M).second)
3496 while (!Stack.empty()) {
3499 bool AnyChildren =
false;
3508 if (Visited.insert(
SM).second) {
3509 Stack.push_back(
SM);
3517 LinkModules.insert(Mod);
3524 SmallVector<llvm::MDNode *, 16> MetadataArgs;
3526 for (
Module *M : LinkModules)
3527 if (Visited.insert(M).second)
3529 std::reverse(MetadataArgs.begin(), MetadataArgs.end());
3530 LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());
3533 if (!LinkerOptionsMetadata.empty()) {
3534 auto *NMD =
getModule().getOrInsertNamedMetadata(
"llvm.linker.options");
3535 for (
auto *MD : LinkerOptionsMetadata)
3536 NMD->addOperand(MD);
3540void CodeGenModule::EmitDeferred() {
3549 if (!DeferredVTables.empty()) {
3550 EmitDeferredVTables();
3555 assert(DeferredVTables.empty());
3562 llvm::append_range(DeferredDeclsToEmit,
3566 if (DeferredDeclsToEmit.empty())
3571 std::vector<GlobalDecl> CurDeclsToEmit;
3572 CurDeclsToEmit.swap(DeferredDeclsToEmit);
3574 for (GlobalDecl &D : CurDeclsToEmit) {
3580 if (LangOpts.SYCLIsDevice && FD->
hasAttr<SYCLKernelEntryPointAttr>() &&
3584 if (!FD->
getAttr<SYCLKernelEntryPointAttr>()->isInvalidAttr()) {
3600 llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(
3618 if (!GV->isDeclaration())
3622 if (LangOpts.OpenMP && OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(D))
3626 EmitGlobalDefinition(D, GV);
3631 if (!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {
3633 assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());
3638void CodeGenModule::EmitVTablesOpportunistically() {
3644 assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())
3645 &&
"Only emit opportunistic vtables with optimizations");
3647 for (
const CXXRecordDecl *RD : OpportunisticVTables) {
3649 "This queue should only contain external vtables");
3650 if (
getCXXABI().canSpeculativelyEmitVTable(RD))
3651 VTables.GenerateClassData(RD);
3653 OpportunisticVTables.clear();
3657 for (
const auto& [MangledName, VD] : DeferredAnnotations) {
3662 DeferredAnnotations.clear();
3664 if (Annotations.empty())
3668 llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(
3669 Annotations[0]->
getType(), Annotations.size()), Annotations);
3670 auto *gv =
new llvm::GlobalVariable(
getModule(), Array->getType(),
false,
3671 llvm::GlobalValue::AppendingLinkage,
3672 Array,
"llvm.global.annotations");
3677 llvm::Constant *&AStr = AnnotationStrings[Str];
3682 llvm::Constant *
s = llvm::ConstantDataArray::getString(
getLLVMContext(), Str);
3683 auto *gv =
new llvm::GlobalVariable(
3684 getModule(),
s->getType(),
true, llvm::GlobalValue::PrivateLinkage,
s,
3685 ".str",
nullptr, llvm::GlobalValue::NotThreadLocal,
3688 gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3705 SM.getExpansionLineNumber(L);
3706 return llvm::ConstantInt::get(
Int32Ty, LineNo);
3714 llvm::FoldingSetNodeID ID;
3715 for (
Expr *E : Exprs) {
3718 llvm::Constant *&Lookup = AnnotationArgs[ID.ComputeHash()];
3723 LLVMArgs.reserve(Exprs.size());
3725 llvm::transform(Exprs, std::back_inserter(LLVMArgs), [&](
const Expr *E) {
3727 return ConstEmiter.
emitAbstract(CE->getBeginLoc(), CE->getAPValueResult(),
3730 auto *
Struct = llvm::ConstantStruct::getAnon(LLVMArgs);
3731 auto *GV =
new llvm::GlobalVariable(
getModule(),
Struct->getType(),
true,
3732 llvm::GlobalValue::PrivateLinkage,
Struct,
3735 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
3742 const AnnotateAttr *AA,
3750 llvm::Constant *GVInGlobalsAS = GV;
3751 if (GV->getAddressSpace() !=
3753 GVInGlobalsAS = llvm::ConstantExpr::getAddrSpaceCast(
3755 llvm::PointerType::get(
3756 GV->getContext(),
getDataLayout().getDefaultGlobalsAddressSpace()));
3760 llvm::Constant *Fields[] = {
3761 GVInGlobalsAS, AnnoGV, UnitGV, LineNoCst, Args,
3763 return llvm::ConstantStruct::getAnon(Fields);
3767 llvm::GlobalValue *GV) {
3768 assert(D->
hasAttr<AnnotateAttr>() &&
"no annotate attribute");
3778 if (NoSanitizeL.containsFunction(Kind, Fn->getName()))
3781 auto &
SM = Context.getSourceManager();
3783 if (NoSanitizeL.containsMainFile(Kind, MainFile.
getName()))
3788 return NoSanitizeL.containsLocation(Kind, Loc);
3791 return NoSanitizeL.containsFile(Kind, MainFile.
getName());
3795 llvm::GlobalVariable *GV,
3797 StringRef Category)
const {
3799 if (NoSanitizeL.containsGlobal(Kind, GV->getName(), Category))
3801 auto &
SM = Context.getSourceManager();
3802 if (NoSanitizeL.containsMainFile(
3803 Kind,
SM.getFileEntryRefForID(
SM.getMainFileID())->getName(),
3806 if (NoSanitizeL.containsLocation(Kind, Loc, Category))
3813 while (
auto AT = dyn_cast<ArrayType>(Ty.
getTypePtr()))
3814 Ty = AT->getElementType();
3819 if (NoSanitizeL.containsType(Kind, TypeStr, Category))
3827 StringRef Category)
const {
3830 auto Attr = ImbueAttr::NONE;
3832 Attr = XRayFilter.shouldImbueLocation(Loc, Category);
3833 if (
Attr == ImbueAttr::NONE)
3834 Attr = XRayFilter.shouldImbueFunction(Fn->getName());
3836 case ImbueAttr::NONE:
3838 case ImbueAttr::ALWAYS:
3839 Fn->addFnAttr(
"function-instrument",
"xray-always");
3841 case ImbueAttr::ALWAYS_ARG1:
3842 Fn->addFnAttr(
"function-instrument",
"xray-always");
3843 Fn->addFnAttr(
"xray-log-args",
"1");
3845 case ImbueAttr::NEVER:
3846 Fn->addFnAttr(
"function-instrument",
"xray-never");
3859 llvm::driver::ProfileInstrKind Kind =
getCodeGenOpts().getProfileInstr();
3869 auto &
SM = Context.getSourceManager();
3870 if (
auto MainFile =
SM.getFileEntryRefForID(
SM.getMainFileID()))
3884 if (NumGroups > 1) {
3885 auto Group = llvm::crc32(arrayRefFromStringRef(Fn->getName())) % NumGroups;
3894 if (LangOpts.EmitAllDecls)
3897 const auto *VD = dyn_cast<VarDecl>(
Global);
3899 ((CodeGenOpts.KeepPersistentStorageVariables &&
3900 (VD->getStorageDuration() ==
SD_Static ||
3901 VD->getStorageDuration() ==
SD_Thread)) ||
3902 (CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==
SD_Static &&
3903 VD->getType().isConstQualified())))
3916 if (LangOpts.OpenMP >= 50 && !LangOpts.OpenMPSimd) {
3917 std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr =
3918 OMPDeclareTargetDeclAttr::getActiveAttr(
Global);
3919 if (!ActiveAttr || (*ActiveAttr)->getLevel() != (
unsigned)-1)
3923 if (
const auto *FD = dyn_cast<FunctionDecl>(
Global)) {
3933 if (LangOpts.SYCLIsDevice && FD->
hasAttr<SYCLKernelEntryPointAttr>())
3936 if (
const auto *VD = dyn_cast<VarDecl>(
Global)) {
3937 if (Context.getInlineVariableDefinitionKind(VD) ==
3942 if (CXX20ModuleInits && VD->getOwningModule() &&
3943 !VD->getOwningModule()->isModuleMapModule()) {
3952 if (LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&
3955 !OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(
Global))
3968 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
3972 llvm::Constant *
Init;
3975 if (!
V.isAbsent()) {
3986 llvm::Constant *Fields[4] = {
3990 llvm::ConstantDataArray::getRaw(
3991 StringRef(
reinterpret_cast<char *
>(Parts.
Part4And5), 8), 8,
3993 Init = llvm::ConstantStruct::getAnon(Fields);
3996 auto *GV =
new llvm::GlobalVariable(
3998 true, llvm::GlobalValue::LinkOnceODRLinkage,
Init, Name);
4000 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
4003 if (!
V.isAbsent()) {
4016 llvm::GlobalVariable **Entry =
nullptr;
4017 Entry = &UnnamedGlobalConstantDeclMap[GCD];
4022 llvm::Constant *
Init;
4026 assert(!
V.isAbsent());
4030 auto *GV =
new llvm::GlobalVariable(
getModule(),
Init->getType(),
4032 llvm::GlobalValue::PrivateLinkage,
Init,
4034 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
4048 if (llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name))
4052 llvm::Constant *
Init =
Emitter.emitForInitializer(
4060 llvm::GlobalValue::LinkageTypes
Linkage =
4062 ? llvm::GlobalValue::LinkOnceODRLinkage
4063 : llvm::GlobalValue::InternalLinkage;
4064 auto *GV =
new llvm::GlobalVariable(
getModule(),
Init->getType(),
4068 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
4075 const AliasAttr *AA = VD->
getAttr<AliasAttr>();
4076 assert(AA &&
"No alias?");
4086 llvm::Constant *Aliasee;
4088 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,
4096 F->setLinkage(llvm::Function::ExternalWeakLinkage);
4097 WeakRefReferences.insert(F);
4105 if (
auto *A = D->
getAttr<AttrT>())
4106 return A->isImplicit();
4110bool CodeGenModule::shouldEmitCUDAGlobalVar(
const VarDecl *
Global)
const {
4111 assert(LangOpts.CUDA &&
"Should not be called by non-CUDA languages");
4116 return !LangOpts.CUDAIsDevice ||
Global->hasAttr<CUDADeviceAttr>() ||
4117 Global->hasAttr<CUDAConstantAttr>() ||
4118 Global->hasAttr<CUDASharedAttr>() ||
4119 Global->getType()->isCUDADeviceBuiltinSurfaceType() ||
4120 Global->getType()->isCUDADeviceBuiltinTextureType();
4127 if (
Global->hasAttr<WeakRefAttr>())
4132 if (
Global->hasAttr<AliasAttr>())
4133 return EmitAliasDefinition(GD);
4136 if (
Global->hasAttr<IFuncAttr>())
4137 return emitIFuncDefinition(GD);
4140 if (
Global->hasAttr<CPUDispatchAttr>())
4141 return emitCPUDispatchDefinition(GD);
4146 if (LangOpts.CUDA) {
4148 "Expected Variable or Function");
4149 if (
const auto *VD = dyn_cast<VarDecl>(
Global)) {
4150 if (!shouldEmitCUDAGlobalVar(VD))
4152 }
else if (LangOpts.CUDAIsDevice) {
4153 const auto *FD = dyn_cast<FunctionDecl>(
Global);
4154 if ((!
Global->hasAttr<CUDADeviceAttr>() ||
4155 (LangOpts.OffloadImplicitHostDeviceTemplates &&
4159 !
getContext().CUDAImplicitHostDeviceFunUsedByDevice.count(FD))) &&
4160 !
Global->hasAttr<CUDAGlobalAttr>() &&
4162 !
Global->hasAttr<CUDAHostAttr>()))
4165 }
else if (!
Global->hasAttr<CUDAHostAttr>() &&
4166 Global->hasAttr<CUDADeviceAttr>())
4170 if (LangOpts.OpenMP) {
4172 if (OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))
4174 if (
auto *DRD = dyn_cast<OMPDeclareReductionDecl>(
Global)) {
4175 if (MustBeEmitted(
Global))
4179 if (
auto *DMD = dyn_cast<OMPDeclareMapperDecl>(
Global)) {
4180 if (MustBeEmitted(
Global))
4187 if (
const auto *FD = dyn_cast<FunctionDecl>(
Global)) {
4188 if (DeviceKernelAttr::isOpenCLSpelling(FD->
getAttr<DeviceKernelAttr>()) &&
4194 if (FD->
hasAttr<AnnotateAttr>()) {
4197 DeferredAnnotations[MangledName] = FD;
4212 GetOrCreateLLVMFunction(MangledName, Ty, GD,
false,
4218 assert(VD->isFileVarDecl() &&
"Cannot emit local var decl as global.");
4220 !Context.isMSStaticDataMemberInlineDefinition(VD)) {
4221 if (LangOpts.OpenMP) {
4223 if (std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =
4224 OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {
4228 if (VD->hasExternalStorage() &&
4229 Res != OMPDeclareTargetDeclAttr::MT_Link)
4232 bool UnifiedMemoryEnabled =
4234 if ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
4235 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
4236 !UnifiedMemoryEnabled) {
4239 assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||
4240 ((*Res == OMPDeclareTargetDeclAttr::MT_To ||
4241 *Res == OMPDeclareTargetDeclAttr::MT_Enter) &&
4242 UnifiedMemoryEnabled)) &&
4243 "Link clause or to clause with unified memory expected.");
4252 if (Context.getInlineVariableDefinitionKind(VD) ==
4262 if (MustBeEmitted(
Global) && MayBeEmittedEagerly(
Global)) {
4264 EmitGlobalDefinition(GD);
4265 addEmittedDeferredDecl(GD);
4273 DelayedCXXInitPosition[
Global] = CXXGlobalInits.size();
4274 CXXGlobalInits.push_back(
nullptr);
4280 addDeferredDeclToEmit(GD);
4281 }
else if (MustBeEmitted(
Global)) {
4283 assert(!MayBeEmittedEagerly(
Global));
4284 addDeferredDeclToEmit(GD);
4289 DeferredDecls[MangledName] = GD;
4295 if (
const auto *RT =
4296 T->getBaseElementTypeUnsafe()->getAsCanonical<RecordType>())
4297 if (
auto *RD = dyn_cast<CXXRecordDecl>(RT->getDecl())) {
4298 RD = RD->getDefinitionOrSelf();
4299 if (RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())
4307 struct FunctionIsDirectlyRecursive
4308 :
public ConstStmtVisitor<FunctionIsDirectlyRecursive, bool> {
4309 const StringRef Name;
4310 const Builtin::Context &BI;
4311 FunctionIsDirectlyRecursive(StringRef N,
const Builtin::Context &
C)
4314 bool VisitCallExpr(
const CallExpr *E) {
4318 AsmLabelAttr *Attr = FD->
getAttr<AsmLabelAttr>();
4319 if (Attr && Name == Attr->getLabel())
4324 std::string BuiltinNameStr = BI.
getName(BuiltinID);
4325 StringRef BuiltinName = BuiltinNameStr;
4326 return BuiltinName.consume_front(
"__builtin_") && Name == BuiltinName;
4329 bool VisitStmt(
const Stmt *S) {
4330 for (
const Stmt *Child : S->
children())
4331 if (Child && this->Visit(Child))
4338 struct DLLImportFunctionVisitor
4339 :
public RecursiveASTVisitor<DLLImportFunctionVisitor> {
4340 bool SafeToInline =
true;
4342 bool shouldVisitImplicitCode()
const {
return true; }
4344 bool VisitVarDecl(VarDecl *VD) {
4347 SafeToInline =
false;
4348 return SafeToInline;
4355 return SafeToInline;
4358 bool VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
4360 SafeToInline = D->
hasAttr<DLLImportAttr>();
4361 return SafeToInline;
4364 bool VisitDeclRefExpr(DeclRefExpr *E) {
4367 SafeToInline = VD->
hasAttr<DLLImportAttr>();
4368 else if (VarDecl *
V = dyn_cast<VarDecl>(VD))
4369 SafeToInline = !
V->hasGlobalStorage() ||
V->hasAttr<DLLImportAttr>();
4370 return SafeToInline;
4373 bool VisitCXXConstructExpr(CXXConstructExpr *E) {
4375 return SafeToInline;
4378 bool VisitCXXMemberCallExpr(CXXMemberCallExpr *E) {
4382 SafeToInline =
true;
4384 SafeToInline = M->
hasAttr<DLLImportAttr>();
4386 return SafeToInline;
4389 bool VisitCXXDeleteExpr(CXXDeleteExpr *E) {
4391 return SafeToInline;
4394 bool VisitCXXNewExpr(CXXNewExpr *E) {
4396 return SafeToInline;
4405CodeGenModule::isTriviallyRecursive(
const FunctionDecl *FD) {
4407 if (
getCXXABI().getMangleContext().shouldMangleDeclName(FD)) {
4409 AsmLabelAttr *Attr = FD->
getAttr<AsmLabelAttr>();
4412 Name = Attr->getLabel();
4417 FunctionIsDirectlyRecursive Walker(Name, Context.BuiltinInfo);
4418 const Stmt *Body = FD->
getBody();
4419 return Body ? Walker.Visit(Body) :
false;
4422bool CodeGenModule::shouldEmitFunction(GlobalDecl GD) {
4429 if (F->isInlineBuiltinDeclaration())
4432 if (CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())
4437 if (
const Module *M = F->getOwningModule();
4438 M && M->getTopLevelModule()->isNamedModule() &&
4439 getContext().getCurrentNamedModule() != M->getTopLevelModule()) {
4449 if (!F->isTemplateInstantiation() || !F->hasAttr<AlwaysInlineAttr>()) {
4454 if (F->hasAttr<NoInlineAttr>())
4457 if (F->hasAttr<DLLImportAttr>() && !F->hasAttr<AlwaysInlineAttr>()) {
4459 DLLImportFunctionVisitor Visitor;
4460 Visitor.TraverseFunctionDecl(
const_cast<FunctionDecl*
>(F));
4461 if (!Visitor.SafeToInline)
4464 if (
const CXXDestructorDecl *Dtor = dyn_cast<CXXDestructorDecl>(F)) {
4467 for (
const Decl *
Member : Dtor->getParent()->decls())
4471 for (
const CXXBaseSpecifier &B : Dtor->getParent()->bases())
4482 return !isTriviallyRecursive(F);
4485bool CodeGenModule::shouldOpportunisticallyEmitVTables() {
4486 return CodeGenOpts.OptimizationLevel > 0;
4489void CodeGenModule::EmitMultiVersionFunctionDefinition(GlobalDecl GD,
4490 llvm::GlobalValue *GV) {
4494 auto *Spec = FD->
getAttr<CPUSpecificAttr>();
4495 for (
unsigned I = 0; I < Spec->cpus_size(); ++I)
4497 }
else if (
auto *TC = FD->
getAttr<TargetClonesAttr>()) {
4498 for (
unsigned I = 0; I < TC->featuresStrs_size(); ++I)
4499 if (TC->isFirstOfVersion(I))
4502 EmitGlobalFunctionDefinition(GD, GV);
4508 AddDeferredMultiVersionResolverToEmit(GD);
4510 GetOrCreateMultiVersionResolver(GD);
4514void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD, llvm::GlobalValue *GV) {
4517 PrettyStackTraceDecl CrashInfo(
const_cast<ValueDecl *
>(D), D->
getLocation(),
4518 Context.getSourceManager(),
4519 "Generating code for declaration");
4521 if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
4524 if (!shouldEmitFunction(GD))
4527 llvm::TimeTraceScope TimeScope(
"CodeGen Function", [&]() {
4529 llvm::raw_string_ostream
OS(Name);
4535 if (
const auto *
Method = dyn_cast<CXXMethodDecl>(D)) {
4539 ABI->emitCXXStructor(GD);
4541 EmitMultiVersionFunctionDefinition(GD, GV);
4543 EmitGlobalFunctionDefinition(GD, GV);
4552 return EmitMultiVersionFunctionDefinition(GD, GV);
4553 return EmitGlobalFunctionDefinition(GD, GV);
4556 if (
const auto *VD = dyn_cast<VarDecl>(D))
4557 return EmitGlobalVarDefinition(VD, !VD->hasDefinition());
4559 llvm_unreachable(
"Invalid argument to EmitGlobalDefinition()");
4563 llvm::Function *NewFn);
4579static llvm::GlobalValue::LinkageTypes
4583 return llvm::GlobalValue::InternalLinkage;
4584 return llvm::GlobalValue::WeakODRLinkage;
4587void CodeGenModule::emitMultiVersionFunctions() {
4588 std::vector<GlobalDecl> MVFuncsToEmit;
4589 MultiVersionFuncs.swap(MVFuncsToEmit);
4590 for (GlobalDecl GD : MVFuncsToEmit) {
4592 assert(FD &&
"Expected a FunctionDecl");
4594 auto createFunction = [&](
const FunctionDecl *
Decl,
unsigned MVIdx = 0) {
4595 GlobalDecl CurGD{
Decl->isDefined() ?
Decl->getDefinition() :
Decl, MVIdx};
4599 if (
Decl->isDefined()) {
4600 EmitGlobalFunctionDefinition(CurGD,
nullptr);
4608 assert(
Func &&
"This should have just been created");
4617 SmallVector<CodeGenFunction::FMVResolverOption, 10> Options;
4620 FD, [&](
const FunctionDecl *CurFD) {
4621 llvm::SmallVector<StringRef, 8> Feats;
4624 if (
const auto *TA = CurFD->
getAttr<TargetAttr>()) {
4626 TA->getX86AddedFeatures(Feats);
4627 llvm::Function *
Func = createFunction(CurFD);
4628 Options.emplace_back(
Func, Feats, TA->getX86Architecture());
4629 }
else if (
const auto *TVA = CurFD->
getAttr<TargetVersionAttr>()) {
4630 if (TVA->isDefaultVersion() && IsDefined)
4631 ShouldEmitResolver =
true;
4632 llvm::Function *
Func = createFunction(CurFD);
4634 TVA->getFeatures(Feats, Delim);
4635 Options.emplace_back(
Func, Feats);
4636 }
else if (
const auto *TC = CurFD->
getAttr<TargetClonesAttr>()) {
4637 for (
unsigned I = 0; I < TC->featuresStrs_size(); ++I) {
4638 if (!TC->isFirstOfVersion(I))
4640 if (TC->isDefaultVersion(I) && IsDefined)
4641 ShouldEmitResolver =
true;
4642 llvm::Function *
Func = createFunction(CurFD, I);
4645 TC->getX86Feature(Feats, I);
4646 Options.emplace_back(
Func, Feats, TC->getX86Architecture(I));
4649 TC->getFeatures(Feats, I, Delim);
4650 Options.emplace_back(
Func, Feats);
4654 llvm_unreachable(
"unexpected MultiVersionKind");
4657 if (!ShouldEmitResolver)
4660 llvm::Constant *ResolverConstant = GetOrCreateMultiVersionResolver(GD);
4661 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(ResolverConstant)) {
4662 ResolverConstant = IFunc->getResolver();
4666 *
this, GD, FD,
true);
4673 auto *Alias = llvm::GlobalAlias::create(
4675 MangledName +
".ifunc", IFunc, &
getModule());
4684 Options, [&TI](
const CodeGenFunction::FMVResolverOption &LHS,
4685 const CodeGenFunction::FMVResolverOption &RHS) {
4688 CodeGenFunction CGF(*
this);
4689 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4691 setMultiVersionResolverAttributes(ResolverFunc, GD);
4693 ResolverFunc->setComdat(
4694 getModule().getOrInsertComdat(ResolverFunc->getName()));
4700 if (!MVFuncsToEmit.empty())
4705 if (!MultiVersionFuncs.empty())
4706 emitMultiVersionFunctions();
4710 llvm::Constant *
New) {
4713 Old->replaceAllUsesWith(
New);
4714 Old->eraseFromParent();
4717void CodeGenModule::emitCPUDispatchDefinition(GlobalDecl GD) {
4719 assert(FD &&
"Not a FunctionDecl?");
4721 const auto *DD = FD->
getAttr<CPUDispatchAttr>();
4722 assert(DD &&
"Not a cpu_dispatch Function?");
4728 UpdateMultiVersionNames(GD, FD, ResolverName);
4730 llvm::Type *ResolverType;
4731 GlobalDecl ResolverGD;
4733 ResolverType = llvm::FunctionType::get(
4744 ResolverName, ResolverType, ResolverGD,
false));
4747 ResolverFunc->setComdat(
4748 getModule().getOrInsertComdat(ResolverFunc->getName()));
4750 SmallVector<CodeGenFunction::FMVResolverOption, 10> Options;
4753 for (
const IdentifierInfo *II : DD->cpus()) {
4761 GlobalDecl ExistingDecl = Manglings.lookup(MangledName);
4764 EmitGlobalFunctionDefinition(ExistingDecl,
nullptr);
4770 Func = GetOrCreateLLVMFunction(
4771 MangledName, DeclTy, ExistingDecl,
4777 llvm::SmallVector<StringRef, 32> Features;
4778 Target.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);
4779 llvm::transform(Features, Features.begin(),
4780 [](StringRef Str) { return Str.substr(1); });
4781 llvm::erase_if(Features, [&Target](StringRef Feat) {
4782 return !Target.validateCpuSupports(Feat);
4788 llvm::stable_sort(Options, [](
const CodeGenFunction::FMVResolverOption &LHS,
4789 const CodeGenFunction::FMVResolverOption &RHS) {
4790 return llvm::X86::getCpuSupportsMask(LHS.
Features) >
4791 llvm::X86::getCpuSupportsMask(RHS.
Features);
4798 while (Options.size() > 1 && llvm::all_of(llvm::X86::getCpuSupportsMask(
4799 (Options.end() - 2)->Features),
4800 [](
auto X) { return X == 0; })) {
4801 StringRef LHSName = (Options.end() - 2)->Function->getName();
4802 StringRef RHSName = (Options.end() - 1)->Function->getName();
4803 if (LHSName.compare(RHSName) < 0)
4804 Options.erase(Options.end() - 2);
4806 Options.erase(Options.end() - 1);
4809 CodeGenFunction CGF(*
this);
4810 CGF.EmitMultiVersionResolver(ResolverFunc, Options);
4811 setMultiVersionResolverAttributes(ResolverFunc, GD);
4816 unsigned AS = IFunc->getType()->getPointerAddressSpace();
4821 auto *GI = llvm::GlobalIFunc::create(DeclTy, AS,
Linkage,
"",
4828 *
this, GD, FD,
true);
4831 auto *GA = llvm::GlobalAlias::create(DeclTy, AS,
Linkage, AliasName,
4839void CodeGenModule::AddDeferredMultiVersionResolverToEmit(GlobalDecl GD) {
4841 assert(FD &&
"Not a FunctionDecl?");
4844 std::string MangledName =
4846 if (!DeferredResolversToEmit.insert(MangledName).second)
4849 MultiVersionFuncs.push_back(GD);
4855llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(GlobalDecl GD) {
4857 assert(FD &&
"Not a FunctionDecl?");
4859 std::string MangledName =
4864 std::string ResolverName = MangledName;
4868 llvm_unreachable(
"unexpected MultiVersionKind::None for resolver");
4872 ResolverName +=
".ifunc";
4879 ResolverName +=
".resolver";
4882 bool ShouldReturnIFunc =
4901 AddDeferredMultiVersionResolverToEmit(GD);
4905 if (ShouldReturnIFunc) {
4907 llvm::Type *ResolverType = llvm::FunctionType::get(
4909 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4910 MangledName +
".resolver", ResolverType, GlobalDecl{},
4912 llvm::GlobalIFunc *GIF =
4915 GIF->setName(ResolverName);
4922 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
4923 ResolverName, DeclTy, GlobalDecl{},
false);
4925 "Resolver should be created for the first time");
4930void CodeGenModule::setMultiVersionResolverAttributes(llvm::Function *Resolver,
4932 const NamedDecl *D = dyn_cast_or_null<NamedDecl>(GD.
getDecl());
4950bool CodeGenModule::shouldDropDLLAttribute(
const Decl *D,
4951 const llvm::GlobalValue *GV)
const {
4952 auto SC = GV->getDLLStorageClass();
4953 if (SC == llvm::GlobalValue::DefaultStorageClass)
4956 return (((SC == llvm::GlobalValue::DLLImportStorageClass &&
4957 !MRD->
hasAttr<DLLImportAttr>()) ||
4958 (SC == llvm::GlobalValue::DLLExportStorageClass &&
4959 !MRD->
hasAttr<DLLExportAttr>())) &&
4970llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(
4971 StringRef MangledName, llvm::Type *Ty, GlobalDecl GD,
bool ForVTable,
4972 bool DontDefer,
bool IsThunk, llvm::AttributeList ExtraAttrs,
4976 std::string NameWithoutMultiVersionMangling;
4977 if (
const FunctionDecl *FD = cast_or_null<FunctionDecl>(D)) {
4979 if (
getLangOpts().OpenMPIsTargetDevice && OpenMPRuntime &&
4980 !OpenMPRuntime->markAsGlobalTarget(GD) && FD->
isDefined() &&
4981 !DontDefer && !IsForDefinition) {
4984 if (
const auto *CD = dyn_cast<CXXConstructorDecl>(FDDef))
4986 else if (
const auto *DD = dyn_cast<CXXDestructorDecl>(FDDef))
4989 GDDef = GlobalDecl(FDDef);
4997 UpdateMultiVersionNames(GD, FD, MangledName);
4998 if (!IsForDefinition) {
5004 AddDeferredMultiVersionResolverToEmit(GD);
5006 *
this, GD, FD,
true);
5008 return GetOrCreateMultiVersionResolver(GD);
5013 if (!NameWithoutMultiVersionMangling.empty())
5014 MangledName = NameWithoutMultiVersionMangling;
5019 if (WeakRefReferences.erase(Entry)) {
5020 const FunctionDecl *FD = cast_or_null<FunctionDecl>(D);
5021 if (FD && !FD->
hasAttr<WeakAttr>())
5022 Entry->setLinkage(llvm::Function::ExternalLinkage);
5026 if (D && shouldDropDLLAttribute(D, Entry)) {
5027 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
5033 if (IsForDefinition && !Entry->isDeclaration()) {
5040 DiagnosedConflictingDefinitions.insert(GD).second) {
5044 diag::note_previous_definition);
5049 (Entry->getValueType() == Ty)) {
5056 if (!IsForDefinition)
5063 bool IsIncompleteFunction =
false;
5065 llvm::FunctionType *FTy;
5069 FTy = llvm::FunctionType::get(
VoidTy,
false);
5070 IsIncompleteFunction =
true;
5074 llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
5075 Entry ? StringRef() : MangledName, &
getModule());
5079 if (D && D->
hasAttr<AnnotateAttr>())
5097 if (!Entry->use_empty()) {
5099 Entry->removeDeadConstantUsers();
5105 assert(F->getName() == MangledName &&
"name was uniqued!");
5107 SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
5108 if (ExtraAttrs.hasFnAttrs()) {
5109 llvm::AttrBuilder B(F->getContext(), ExtraAttrs.getFnAttrs());
5117 if (isa_and_nonnull<CXXDestructorDecl>(D) &&
5120 addDeferredDeclToEmit(GD);
5125 auto DDI = DeferredDecls.find(MangledName);
5126 if (DDI != DeferredDecls.end()) {
5130 addDeferredDeclToEmit(DDI->second);
5131 DeferredDecls.erase(DDI);
5159 if (!IsIncompleteFunction) {
5160 assert(F->getFunctionType() == Ty);
5178 if (DeviceKernelAttr::isOpenCLSpelling(FD->
getAttr<DeviceKernelAttr>()) &&
5188 if (
const auto *DD = dyn_cast<CXXDestructorDecl>(GD.
getDecl())) {
5191 DD->getParent()->getNumVBases() == 0)
5196 auto *F = GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,
5197 false, llvm::AttributeList(),
5200 if (LangOpts.CUDA && !LangOpts.CUDAIsDevice &&
5204 if (IsForDefinition)
5212 llvm::GlobalValue *F =
5215 return llvm::NoCFIValue::get(F);
5224 for (
const auto *Result : DC->
lookup(&CII))
5225 if (
const auto *FD = dyn_cast<FunctionDecl>(Result))
5228 if (!
C.getLangOpts().CPlusPlus)
5233 (Name ==
"_ZSt9terminatev" || Name ==
"?terminate@@YAXXZ")
5234 ?
C.Idents.get(
"terminate")
5235 :
C.Idents.get(Name);
5237 for (
const auto &N : {
"__cxxabiv1",
"std"}) {
5239 for (
const auto *Result : DC->
lookup(&NS)) {
5241 if (
auto *LSD = dyn_cast<LinkageSpecDecl>(Result))
5242 for (
const auto *Result : LSD->lookup(&NS))
5243 if ((ND = dyn_cast<NamespaceDecl>(Result)))
5247 for (
const auto *Result : ND->
lookup(&CXXII))
5248 if (
const auto *FD = dyn_cast<FunctionDecl>(Result))
5257 llvm::Function *F, StringRef Name) {
5263 if (!Local && CGM.
getTriple().isWindowsItaniumEnvironment() &&
5266 if (!FD || FD->
hasAttr<DLLImportAttr>()) {
5267 F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
5268 F->setLinkage(llvm::GlobalValue::ExternalLinkage);
5275 llvm::AttributeList ExtraAttrs,
bool Local,
bool AssumeConvergent) {
5276 if (AssumeConvergent) {
5278 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
5281 QualType FTy = Context.getFunctionType(ReturnTy, ArgTys,
5286 llvm::Constant *
C = GetOrCreateLLVMFunction(
5288 false,
false, ExtraAttrs);
5290 if (
auto *F = dyn_cast<llvm::Function>(
C)) {
5306 llvm::AttributeList ExtraAttrs,
bool Local,
5307 bool AssumeConvergent) {
5308 if (AssumeConvergent) {
5310 ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);
5314 GetOrCreateLLVMFunction(Name, FTy,
GlobalDecl(),
false,
5318 if (
auto *F = dyn_cast<llvm::Function>(
C)) {
5327 markRegisterParameterAttributes(F);
5353 if (WeakRefReferences.erase(Entry)) {
5354 if (D && !D->
hasAttr<WeakAttr>())
5355 Entry->setLinkage(llvm::Function::ExternalLinkage);
5359 if (D && shouldDropDLLAttribute(D, Entry))
5360 Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);
5362 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd && D)
5365 if (Entry->getValueType() == Ty && Entry->getAddressSpace() == TargetAS)
5370 if (IsForDefinition && !Entry->isDeclaration()) {
5378 (OtherD = dyn_cast<VarDecl>(OtherGD.
getDecl())) &&
5380 DiagnosedConflictingDefinitions.insert(D).second) {
5384 diag::note_previous_definition);
5389 if (Entry->getType()->getAddressSpace() != TargetAS)
5390 return llvm::ConstantExpr::getAddrSpaceCast(
5391 Entry, llvm::PointerType::get(Ty->getContext(), TargetAS));
5395 if (!IsForDefinition)
5401 auto *GV =
new llvm::GlobalVariable(
5402 getModule(), Ty,
false, llvm::GlobalValue::ExternalLinkage,
nullptr,
5403 MangledName,
nullptr, llvm::GlobalVariable::NotThreadLocal,
5404 getContext().getTargetAddressSpace(DAddrSpace));
5409 GV->takeName(Entry);
5411 if (!Entry->use_empty()) {
5412 Entry->replaceAllUsesWith(GV);
5415 Entry->eraseFromParent();
5421 auto DDI = DeferredDecls.find(MangledName);
5422 if (DDI != DeferredDecls.end()) {
5425 addDeferredDeclToEmit(DDI->second);
5426 DeferredDecls.erase(DDI);
5431 if (LangOpts.OpenMP && !LangOpts.OpenMPSimd)
5438 GV->setAlignment(
getContext().getDeclAlign(D).getAsAlign());
5444 CXXThreadLocals.push_back(D);
5452 if (
getContext().isMSStaticDataMemberInlineDefinition(D)) {
5453 EmitGlobalVarDefinition(D);
5458 if (
const SectionAttr *SA = D->
getAttr<SectionAttr>())
5459 GV->setSection(SA->getName());
5463 if (
getTriple().getArch() == llvm::Triple::xcore &&
5467 GV->setSection(
".cp.rodata");
5470 if (
const auto *CMA = D->
getAttr<CodeModelAttr>())
5471 GV->setCodeModel(CMA->getModel());
5476 if (Context.getLangOpts().CPlusPlus && GV->hasExternalLinkage() &&
5480 Context.getBaseElementType(D->
getType())->getAsCXXRecordDecl();
5481 bool HasMutableFields =
Record &&
Record->hasMutableFields();
5482 if (!HasMutableFields) {
5489 auto *InitType =
Init->getType();
5490 if (GV->getValueType() != InitType) {
5495 GV->setName(StringRef());
5500 ->stripPointerCasts());
5503 GV->eraseFromParent();
5506 GV->setInitializer(
Init);
5507 GV->setConstant(
true);
5508 GV->setLinkage(llvm::GlobalValue::AvailableExternallyLinkage);
5528 SanitizerMD->reportGlobal(GV, *D);
5533 assert(
getContext().getTargetAddressSpace(ExpectedAS) == TargetAS);
5534 if (DAddrSpace != ExpectedAS) {
5536 *
this, GV, DAddrSpace,
5549 false, IsForDefinition);
5570 StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes
Linkage,
5571 llvm::Align Alignment) {
5572 llvm::GlobalVariable *GV =
getModule().getNamedGlobal(Name);
5573 llvm::GlobalVariable *OldGV =
nullptr;
5577 if (GV->getValueType() == Ty)
5582 assert(GV->isDeclaration() &&
"Declaration has wrong type!");
5587 GV =
new llvm::GlobalVariable(
getModule(), Ty,
true,
5592 GV->takeName(OldGV);
5594 if (!OldGV->use_empty()) {
5595 OldGV->replaceAllUsesWith(GV);
5598 OldGV->eraseFromParent();
5602 !GV->hasAvailableExternallyLinkage())
5603 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
5605 GV->setAlignment(Alignment);
5642 assert(!D->
getInit() &&
"Cannot emit definite definitions here!");
5650 if (GV && !GV->isDeclaration())
5655 if (!MustBeEmitted(D) && !GV) {
5656 DeferredDecls[MangledName] = D;
5661 EmitGlobalVarDefinition(D);
5666 if (
auto const *CD = dyn_cast<const CXXConstructorDecl>(D))
5668 else if (
auto const *DD = dyn_cast<const CXXDestructorDecl>(D))
5683 if (
const auto *VD = dyn_cast<VarDecl>(D)) {
5686 }
else if (
const auto *FD = dyn_cast<FunctionDecl>(D)) {
5688 if (!Fn->getSubprogram())
5694 return Context.toCharUnitsFromBits(
5699 if (LangOpts.OpenCL) {
5710 if (LangOpts.SYCLIsDevice &&
5714 if (LangOpts.CUDA && LangOpts.CUDAIsDevice) {
5716 if (D->
hasAttr<CUDAConstantAttr>())
5718 if (D->
hasAttr<CUDASharedAttr>())
5720 if (D->
hasAttr<CUDADeviceAttr>())
5728 if (LangOpts.OpenMP) {
5730 if (OpenMPRuntime->hasAllocateAttributeForGlobalVar(D, AS))
5738 if (LangOpts.OpenCL)
5740 if (LangOpts.SYCLIsDevice)
5742 if (LangOpts.HIP && LangOpts.CUDAIsDevice &&
getTriple().isSPIRV())
5750 if (
auto AS =
getTarget().getConstantAddressSpace())
5763static llvm::Constant *
5765 llvm::GlobalVariable *GV) {
5766 llvm::Constant *Cast = GV;
5772 llvm::PointerType::get(
5779template<
typename SomeDecl>
5781 llvm::GlobalValue *GV) {
5796 const SomeDecl *
First = D->getFirstDecl();
5797 if (
First->getDeclContext()->isRecord() || !
First->isInExternCContext())
5803 std::pair<StaticExternCMap::iterator, bool> R =
5804 StaticExternCValues.insert(std::make_pair(D->getIdentifier(), GV));
5809 R.first->second =
nullptr;
5816 if (D.
hasAttr<SelectAnyAttr>())
5820 if (
auto *VD = dyn_cast<VarDecl>(&D))
5834 llvm_unreachable(
"No such linkage");
5842 llvm::GlobalObject &GO) {
5845 GO.setComdat(TheModule.getOrInsertComdat(GO.getName()));
5853void CodeGenModule::EmitGlobalVarDefinition(
const VarDecl *D,
5868 if (LangOpts.OpenMPIsTargetDevice && OpenMPRuntime &&
5869 OpenMPRuntime->emitTargetGlobalVariable(D))
5872 llvm::TrackingVH<llvm::Constant>
Init;
5873 bool NeedsGlobalCtor =
false;
5877 bool IsDefinitionAvailableExternally =
5879 bool NeedsGlobalDtor =
5880 !IsDefinitionAvailableExternally &&
5887 if (IsDefinitionAvailableExternally &&
5898 std::optional<ConstantEmitter> emitter;
5903 bool IsCUDASharedVar =
5908 bool IsCUDAShadowVar =
5910 (D->
hasAttr<CUDAConstantAttr>() || D->
hasAttr<CUDADeviceAttr>() ||
5911 D->
hasAttr<CUDASharedAttr>());
5912 bool IsCUDADeviceShadowVar =
5917 (IsCUDASharedVar || IsCUDAShadowVar || IsCUDADeviceShadowVar)) {
5918 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
5922 Init = llvm::PoisonValue::get(
getTypes().ConvertType(ASTTy));
5924 }
else if (D->
hasAttr<LoaderUninitializedAttr>()) {
5925 Init = llvm::UndefValue::get(
getTypes().ConvertTypeForMem(ASTTy));
5926 }
else if (!InitExpr) {
5939 initializedGlobalDecl = GlobalDecl(D);
5940 emitter.emplace(*
this);
5941 llvm::Constant *
Initializer = emitter->tryEmitForInitializer(*InitDecl);
5949 if (!IsDefinitionAvailableExternally)
5950 NeedsGlobalCtor =
true;
5954 NeedsGlobalCtor =
false;
5966 DelayedCXXInitPosition.erase(D);
5973 assert(VarSize == CstSize &&
"Emitted constant has unexpected size");
5978 llvm::Type* InitType =
Init->getType();
5979 llvm::Constant *Entry =
5983 Entry = Entry->stripPointerCasts();
5986 auto *GV = dyn_cast<llvm::GlobalVariable>(Entry);
5997 if (!GV || GV->getValueType() != InitType ||
5998 GV->getType()->getAddressSpace() !=
6002 Entry->setName(StringRef());
6007 ->stripPointerCasts());
6010 llvm::Constant *NewPtrForOldDecl =
6011 llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(GV,
6013 Entry->replaceAllUsesWith(NewPtrForOldDecl);
6021 if (D->
hasAttr<AnnotateAttr>())
6034 if (LangOpts.CUDA) {
6035 if (LangOpts.CUDAIsDevice) {
6036 if (
Linkage != llvm::GlobalValue::InternalLinkage &&
6037 (D->
hasAttr<CUDADeviceAttr>() || D->
hasAttr<CUDAConstantAttr>() ||
6040 GV->setExternallyInitialized(
true);
6050 GV->setExternallyInitialized(
true);
6052 GV->setInitializer(
Init);
6059 emitter->finalize(GV);
6062 GV->setConstant((D->
hasAttr<CUDAConstantAttr>() && LangOpts.CUDAIsDevice) ||
6063 (!NeedsGlobalCtor && !NeedsGlobalDtor &&
6067 if (
const SectionAttr *SA = D->
getAttr<SectionAttr>()) {
6068 const ASTContext::SectionInfo &SI = Context.SectionInfos[SA->getName()];
6070 GV->setConstant(
true);
6075 if (std::optional<CharUnits> AlignValFromAllocate =
6077 AlignVal = *AlignValFromAllocate;
6095 Linkage == llvm::GlobalValue::ExternalLinkage &&
6096 Context.getTargetInfo().getTriple().isOSDarwin() &&
6098 Linkage = llvm::GlobalValue::InternalLinkage;
6104 Linkage = llvm::GlobalValue::ExternalLinkage;
6107 if (D->
hasAttr<DLLImportAttr>())
6108 GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);
6109 else if (D->
hasAttr<DLLExportAttr>())
6110 GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);
6112 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
6114 if (
Linkage == llvm::GlobalVariable::CommonLinkage) {
6116 GV->setConstant(
false);
6121 if (!GV->getInitializer()->isNullValue())
6122 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage);
6125 setNonAliasAttributes(D, GV);
6127 if (D->
getTLSKind() && !GV->isThreadLocal()) {
6129 CXXThreadLocals.push_back(D);
6136 if (NeedsGlobalCtor || NeedsGlobalDtor)
6137 EmitCXXGlobalVarDeclInitFunc(D, GV, NeedsGlobalCtor);
6139 SanitizerMD->reportGlobal(GV, *D, NeedsGlobalCtor);
6144 DI->EmitGlobalVariable(GV, D);
6152 if ((NoCommon || D->
hasAttr<NoCommonAttr>()) && !D->
hasAttr<CommonAttr>())
6163 if (D->
hasAttr<SectionAttr>())
6169 if (D->
hasAttr<PragmaClangBSSSectionAttr>() ||
6170 D->
hasAttr<PragmaClangDataSectionAttr>() ||
6171 D->
hasAttr<PragmaClangRelroSectionAttr>() ||
6172 D->
hasAttr<PragmaClangRodataSectionAttr>())
6180 if (D->
hasAttr<WeakImportAttr>())
6189 if (Context.getTargetInfo().getCXXABI().isMicrosoft()) {
6190 if (D->
hasAttr<AlignedAttr>())
6193 if (Context.isAlignmentRequired(VarType))
6197 for (
const FieldDecl *FD : RD->fields()) {
6198 if (FD->isBitField())
6200 if (FD->
hasAttr<AlignedAttr>())
6202 if (Context.isAlignmentRequired(FD->
getType()))
6214 if (Context.getTargetInfo().getTriple().isKnownWindowsMSVCEnvironment() &&
6215 Context.getTypeAlignIfKnown(D->
getType()) >
6222llvm::GlobalValue::LinkageTypes
6226 return llvm::Function::InternalLinkage;
6229 return llvm::GlobalVariable::WeakAnyLinkage;
6233 return llvm::GlobalVariable::LinkOnceAnyLinkage;
6238 return llvm::GlobalValue::AvailableExternallyLinkage;
6252 return !Context.getLangOpts().AppleKext ? llvm::Function::LinkOnceODRLinkage
6253 : llvm::Function::InternalLinkage;
6267 return llvm::Function::ExternalLinkage;
6270 return D->
hasAttr<CUDAGlobalAttr>() ? llvm::Function::ExternalLinkage
6271 : llvm::Function::InternalLinkage;
6272 return llvm::Function::WeakODRLinkage;
6279 CodeGenOpts.NoCommon))
6280 return llvm::GlobalVariable::CommonLinkage;
6286 if (D->
hasAttr<SelectAnyAttr>())
6287 return llvm::GlobalVariable::WeakODRLinkage;
6291 return llvm::GlobalVariable::ExternalLinkage;
6294llvm::GlobalValue::LinkageTypes
6303 llvm::Function *newFn) {
6305 if (old->use_empty())
6308 llvm::Type *newRetTy = newFn->getReturnType();
6313 for (llvm::Value::use_iterator ui = old->use_begin(), ue = old->use_end();
6315 llvm::User *user = ui->getUser();
6319 if (
auto *bitcast = dyn_cast<llvm::ConstantExpr>(user)) {
6320 if (bitcast->getOpcode() == llvm::Instruction::BitCast)
6326 llvm::CallBase *callSite = dyn_cast<llvm::CallBase>(user);
6329 if (!callSite->isCallee(&*ui))
6334 if (callSite->getType() != newRetTy && !callSite->use_empty())
6339 llvm::AttributeList oldAttrs = callSite->getAttributes();
6342 unsigned newNumArgs = newFn->arg_size();
6343 if (callSite->arg_size() < newNumArgs)
6349 bool dontTransform =
false;
6350 for (llvm::Argument &A : newFn->args()) {
6351 if (callSite->getArgOperand(argNo)->getType() != A.getType()) {
6352 dontTransform =
true;
6357 newArgAttrs.push_back(oldAttrs.getParamAttrs(argNo));
6365 newArgs.append(callSite->arg_begin(), callSite->arg_begin() + argNo);
6369 callSite->getOperandBundlesAsDefs(newBundles);
6371 llvm::CallBase *newCall;
6373 newCall = llvm::CallInst::Create(newFn, newArgs, newBundles,
"",
6374 callSite->getIterator());
6377 newCall = llvm::InvokeInst::Create(
6378 newFn, oldInvoke->getNormalDest(), oldInvoke->getUnwindDest(),
6379 newArgs, newBundles,
"", callSite->getIterator());
6383 if (!newCall->getType()->isVoidTy())
6384 newCall->takeName(callSite);
6385 newCall->setAttributes(
6386 llvm::AttributeList::get(newFn->getContext(), oldAttrs.getFnAttrs(),
6387 oldAttrs.getRetAttrs(), newArgAttrs));
6388 newCall->setCallingConv(callSite->getCallingConv());
6391 if (!callSite->use_empty())
6392 callSite->replaceAllUsesWith(newCall);
6395 if (callSite->getDebugLoc())
6396 newCall->setDebugLoc(callSite->getDebugLoc());
6398 callSitesToBeRemovedFromParent.push_back(callSite);
6401 for (
auto *callSite : callSitesToBeRemovedFromParent) {
6402 callSite->eraseFromParent();
6416 llvm::Function *NewFn) {
6426 (LangOpts.CUDA && !shouldEmitCUDAGlobalVar(VD)))
6438void CodeGenModule::EmitGlobalFunctionDefinition(
GlobalDecl GD,
6439 llvm::GlobalValue *GV) {
6447 if (!GV || (GV->getValueType() != Ty))
6453 if (!GV->isDeclaration())
6472 setNonAliasAttributes(GD, Fn);
6474 bool ShouldAddOptNone = !CodeGenOpts.DisableO0ImplyOptNone &&
6475 (CodeGenOpts.OptimizationLevel == 0) &&
6478 if (DeviceKernelAttr::isOpenCLSpelling(D->
getAttr<DeviceKernelAttr>())) {
6480 !D->
hasAttr<NoInlineAttr>() &&
6481 !Fn->hasFnAttribute(llvm::Attribute::NoInline) &&
6482 !D->
hasAttr<OptimizeNoneAttr>() &&
6483 !Fn->hasFnAttribute(llvm::Attribute::OptimizeNone) &&
6484 !ShouldAddOptNone) {
6485 Fn->addFnAttr(llvm::Attribute::AlwaysInline);
6491 auto GetPriority = [
this](
const auto *
Attr) ->
int {
6496 return Attr->DefaultPriority;
6499 if (
const ConstructorAttr *CA = D->
getAttr<ConstructorAttr>())
6501 if (
const DestructorAttr *DA = D->
getAttr<DestructorAttr>())
6507void CodeGenModule::EmitAliasDefinition(GlobalDecl GD) {
6509 const AliasAttr *AA = D->
getAttr<AliasAttr>();
6510 assert(AA &&
"Not an alias?");
6514 if (AA->getAliasee() == MangledName) {
6515 Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
6522 if (Entry && !Entry->isDeclaration())
6525 Aliases.push_back(GD);
6531 llvm::Constant *Aliasee;
6532 llvm::GlobalValue::LinkageTypes
LT;
6534 Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy, GD,
6540 if (
const auto *VD = dyn_cast<VarDecl>(GD.
getDecl()))
6547 unsigned AS = Aliasee->getType()->getPointerAddressSpace();
6549 llvm::GlobalAlias::create(DeclTy, AS, LT,
"", Aliasee, &
getModule());
6552 if (GA->getAliasee() == Entry) {
6553 Diags.Report(AA->getLocation(), diag::err_cyclic_alias) << 0;
6557 assert(Entry->isDeclaration());
6566 GA->takeName(Entry);
6568 Entry->replaceAllUsesWith(GA);
6569 Entry->eraseFromParent();
6571 GA->setName(MangledName);
6579 GA->setLinkage(llvm::Function::WeakAnyLinkage);
6582 if (
const auto *VD = dyn_cast<VarDecl>(D))
6583 if (VD->getTLSKind())
6594void CodeGenModule::emitIFuncDefinition(GlobalDecl GD) {
6596 const IFuncAttr *IFA = D->
getAttr<IFuncAttr>();
6597 assert(IFA &&
"Not an ifunc?");
6601 if (IFA->getResolver() == MangledName) {
6602 Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
6608 if (Entry && !Entry->isDeclaration()) {
6611 DiagnosedConflictingDefinitions.insert(GD).second) {
6612 Diags.Report(D->
getLocation(), diag::err_duplicate_mangled_name)
6615 diag::note_previous_definition);
6620 Aliases.push_back(GD);
6626 llvm::Constant *Resolver =
6627 GetOrCreateLLVMFunction(IFA->getResolver(),
VoidTy, {},
6631 llvm::GlobalIFunc *GIF = llvm::GlobalIFunc::create(
6632 DeclTy, AS, llvm::Function::ExternalLinkage,
"", Resolver, &
getModule());
6634 if (GIF->getResolver() == Entry) {
6635 Diags.Report(IFA->getLocation(), diag::err_cyclic_alias) << 1;
6638 assert(Entry->isDeclaration());
6647 GIF->takeName(Entry);
6649 Entry->replaceAllUsesWith(GIF);
6650 Entry->eraseFromParent();
6652 GIF->setName(MangledName);
6658 return llvm::Intrinsic::getOrInsertDeclaration(&
getModule(),
6659 (llvm::Intrinsic::ID)IID, Tys);
6662static llvm::StringMapEntry<llvm::GlobalVariable *> &
6665 bool &IsUTF16,
unsigned &StringLength) {
6666 StringRef String = Literal->getString();
6667 unsigned NumBytes = String.size();
6670 if (!Literal->containsNonAsciiOrNull()) {
6671 StringLength = NumBytes;
6672 return *Map.insert(std::make_pair(String,
nullptr)).first;
6679 const llvm::UTF8 *FromPtr = (
const llvm::UTF8 *)String.data();
6680 llvm::UTF16 *ToPtr = &ToBuf[0];
6682 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, &ToPtr,
6683 ToPtr + NumBytes, llvm::strictConversion);
6686 StringLength = ToPtr - &ToBuf[0];
6690 return *Map.insert(std::make_pair(
6691 StringRef(
reinterpret_cast<const char *
>(ToBuf.data()),
6692 (StringLength + 1) * 2),
6698 unsigned StringLength = 0;
6699 bool isUTF16 =
false;
6700 llvm::StringMapEntry<llvm::GlobalVariable *> &Entry =
6705 if (
auto *
C = Entry.second)
6710 const llvm::Triple &Triple =
getTriple();
6713 const bool IsSwiftABI =
6714 static_cast<unsigned>(CFRuntime) >=
6719 if (!CFConstantStringClassRef) {
6720 const char *CFConstantStringClassName =
"__CFConstantStringClassReference";
6722 Ty = llvm::ArrayType::get(Ty, 0);
6724 switch (CFRuntime) {
6728 CFConstantStringClassName =
6729 Triple.isOSDarwin() ?
"$s15SwiftFoundation19_NSCFConstantStringCN"
6730 :
"$s10Foundation19_NSCFConstantStringCN";
6734 CFConstantStringClassName =
6735 Triple.isOSDarwin() ?
"$S15SwiftFoundation19_NSCFConstantStringCN"
6736 :
"$S10Foundation19_NSCFConstantStringCN";
6740 CFConstantStringClassName =
6741 Triple.isOSDarwin() ?
"__T015SwiftFoundation19_NSCFConstantStringCN"
6742 :
"__T010Foundation19_NSCFConstantStringCN";
6749 if (Triple.isOSBinFormatELF() || Triple.isOSBinFormatCOFF()) {
6750 llvm::GlobalValue *GV =
nullptr;
6752 if ((GV = dyn_cast<llvm::GlobalValue>(
C))) {
6759 if ((VD = dyn_cast<VarDecl>(
Result)))
6762 if (Triple.isOSBinFormatELF()) {
6764 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6766 GV->setLinkage(llvm::GlobalValue::ExternalLinkage);
6767 if (!VD || !VD->
hasAttr<DLLExportAttr>())
6768 GV->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
6770 GV->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
6778 CFConstantStringClassRef =
6779 IsSwiftABI ? llvm::ConstantExpr::getPtrToInt(
C, Ty) :
C;
6782 QualType CFTy = Context.getCFConstantStringType();
6787 auto Fields = Builder.beginStruct(STy);
6796 Fields.addInt(
IntPtrTy, IsSwift4_1 ? 0x05 : 0x01);
6797 Fields.addInt(
Int64Ty, isUTF16 ? 0x07d0 : 0x07c8);
6799 Fields.addInt(
IntTy, isUTF16 ? 0x07d0 : 0x07C8);
6803 llvm::Constant *
C =
nullptr;
6806 reinterpret_cast<uint16_t *
>(
const_cast<char *
>(Entry.first().data())),
6807 Entry.first().size() / 2);
6808 C = llvm::ConstantDataArray::get(VMContext, Arr);
6810 C = llvm::ConstantDataArray::getString(VMContext, Entry.first());
6816 new llvm::GlobalVariable(
getModule(),
C->getType(),
true,
6817 llvm::GlobalValue::PrivateLinkage,
C,
".str");
6818 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6821 CharUnits Align = isUTF16 ? Context.getTypeAlignInChars(Context.ShortTy)
6822 : Context.getTypeAlignInChars(Context.CharTy);
6828 if (Triple.isOSBinFormatMachO())
6829 GV->setSection(isUTF16 ?
"__TEXT,__ustring"
6830 :
"__TEXT,__cstring,cstring_literals");
6833 else if (Triple.isOSBinFormatELF())
6834 GV->setSection(
".rodata");
6840 llvm::IntegerType *LengthTy =
6850 Fields.addInt(LengthTy, StringLength);
6858 GV = Fields.finishAndCreateGlobal(
"_unnamed_cfstring_", Alignment,
6860 llvm::GlobalVariable::PrivateLinkage);
6861 GV->addAttribute(
"objc_arc_inert");
6862 switch (Triple.getObjectFormat()) {
6863 case llvm::Triple::UnknownObjectFormat:
6864 llvm_unreachable(
"unknown file format");
6865 case llvm::Triple::DXContainer:
6866 case llvm::Triple::GOFF:
6867 case llvm::Triple::SPIRV:
6868 case llvm::Triple::XCOFF:
6869 llvm_unreachable(
"unimplemented");
6870 case llvm::Triple::COFF:
6871 case llvm::Triple::ELF:
6872 case llvm::Triple::Wasm:
6873 GV->setSection(
"cfstring");
6875 case llvm::Triple::MachO:
6876 GV->setSection(
"__DATA,__cfstring");
6885 return !CodeGenOpts.EmitCodeView || CodeGenOpts.DebugColumnInfo;
6889 if (ObjCFastEnumerationStateType.isNull()) {
6890 RecordDecl *D = Context.buildImplicitRecord(
"__objcFastEnumerationState");
6894 Context.UnsignedLongTy, Context.getPointerType(Context.getObjCIdType()),
6895 Context.getPointerType(Context.UnsignedLongTy),
6896 Context.getConstantArrayType(Context.UnsignedLongTy, llvm::APInt(32, 5),
6899 for (
size_t i = 0; i < 4; ++i) {
6904 FieldTypes[i],
nullptr,
6913 ObjCFastEnumerationStateType = Context.getCanonicalTagType(D);
6916 return ObjCFastEnumerationStateType;
6930 assert(CAT &&
"String literal not of constant array type!");
6932 return llvm::ConstantDataArray::getString(VMContext, Str,
false);
6936 llvm::Type *ElemTy = AType->getElementType();
6937 unsigned NumElements = AType->getNumElements();
6940 if (ElemTy->getPrimitiveSizeInBits() == 16) {
6942 Elements.reserve(NumElements);
6944 for(
unsigned i = 0, e = E->
getLength(); i != e; ++i)
6946 Elements.resize(NumElements);
6947 return llvm::ConstantDataArray::get(VMContext, Elements);
6950 assert(ElemTy->getPrimitiveSizeInBits() == 32);
6952 Elements.reserve(NumElements);
6954 for(
unsigned i = 0, e = E->
getLength(); i != e; ++i)
6956 Elements.resize(NumElements);
6957 return llvm::ConstantDataArray::get(VMContext, Elements);
6960static llvm::GlobalVariable *
6969 auto *GV =
new llvm::GlobalVariable(
6970 M,
C->getType(), !CGM.
getLangOpts().WritableStrings, LT,
C, GlobalName,
6971 nullptr, llvm::GlobalVariable::NotThreadLocal, AddrSpace);
6973 GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
6974 if (GV->isWeakForLinker()) {
6975 assert(CGM.
supportsCOMDAT() &&
"Only COFF uses weak string literals");
6976 GV->setComdat(M.getOrInsertComdat(GV->getName()));
6992 llvm::GlobalVariable **Entry =
nullptr;
6993 if (!LangOpts.WritableStrings) {
6994 Entry = &ConstantStringMap[
C];
6995 if (
auto GV = *Entry) {
6996 if (uint64_t(Alignment.
getQuantity()) > GV->getAlignment())
6999 GV->getValueType(), Alignment);
7004 StringRef GlobalVariableName;
7005 llvm::GlobalValue::LinkageTypes LT;
7010 if (
getCXXABI().getMangleContext().shouldMangleStringLiteral(S) &&
7011 !LangOpts.WritableStrings) {
7012 llvm::raw_svector_ostream Out(MangledNameBuffer);
7014 LT = llvm::GlobalValue::LinkOnceODRLinkage;
7015 GlobalVariableName = MangledNameBuffer;
7017 LT = llvm::GlobalValue::PrivateLinkage;
7018 GlobalVariableName = Name;
7030 SanitizerMD->reportGlobal(GV, S->
getStrTokenLoc(0),
"<string literal>");
7033 GV->getValueType(), Alignment);
7050 StringRef GlobalName) {
7051 StringRef StrWithNull(Str.c_str(), Str.size() + 1);
7056 llvm::ConstantDataArray::getString(
getLLVMContext(), StrWithNull,
false);
7059 llvm::GlobalVariable **Entry =
nullptr;
7060 if (!LangOpts.WritableStrings) {
7061 Entry = &ConstantStringMap[
C];
7062 if (
auto GV = *Entry) {
7063 if (uint64_t(Alignment.
getQuantity()) > GV->getAlignment())
7066 GV->getValueType(), Alignment);
7072 GlobalName, Alignment);
7077 GV->getValueType(), Alignment);
7090 MaterializedType = E->
getType();
7094 auto InsertResult = MaterializedGlobalTemporaryMap.insert({E,
nullptr});
7095 if (!InsertResult.second) {
7098 if (!InsertResult.first->second) {
7103 InsertResult.first->second =
new llvm::GlobalVariable(
7104 getModule(),
Type,
false, llvm::GlobalVariable::InternalLinkage,
7108 llvm::cast<llvm::GlobalVariable>(
7109 InsertResult.first->second->stripPointerCasts())
7118 llvm::raw_svector_ostream Out(Name);
7140 std::optional<ConstantEmitter> emitter;
7141 llvm::Constant *InitialValue =
nullptr;
7142 bool Constant =
false;
7146 emitter.emplace(*
this);
7147 InitialValue = emitter->emitForInitializer(*
Value, AddrSpace,
7152 Type = InitialValue->getType();
7161 if (
Linkage == llvm::GlobalVariable::ExternalLinkage) {
7163 if (VD->isStaticDataMember() && VD->getAnyInitializer(InitVD) &&
7167 Linkage = llvm::GlobalVariable::LinkOnceODRLinkage;
7171 Linkage = llvm::GlobalVariable::InternalLinkage;
7175 auto *GV =
new llvm::GlobalVariable(
7177 nullptr, llvm::GlobalVariable::NotThreadLocal, TargetAS);
7178 if (emitter) emitter->finalize(GV);
7180 if (!llvm::GlobalValue::isLocalLinkage(
Linkage)) {
7182 if (GV->getDLLStorageClass() == llvm::GlobalVariable::DLLExportStorageClass)
7184 GV->setDLLStorageClass(llvm::GlobalVariable::DefaultStorageClass);
7188 GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));
7189 if (VD->getTLSKind())
7191 llvm::Constant *CV = GV;
7194 *
this, GV, AddrSpace,
7195 llvm::PointerType::get(
7201 llvm::Constant *&Entry = MaterializedGlobalTemporaryMap[E];
7203 Entry->replaceAllUsesWith(CV);
7204 llvm::cast<llvm::GlobalVariable>(Entry)->eraseFromParent();
7213void CodeGenModule::EmitObjCPropertyImplementations(
const
7226 if (!Getter || Getter->isSynthesizedAccessorStub())
7229 auto *Setter = PID->getSetterMethodDecl();
7230 if (!PD->
isReadOnly() && (!Setter || Setter->isSynthesizedAccessorStub()))
7241 if (ivar->getType().isDestructedType())
7262void CodeGenModule::EmitObjCIvarInitializations(ObjCImplementationDecl *D) {
7275 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, DTORMethod,
false);
7290 getContext().getObjCIdType(),
nullptr, D,
true,
7296 CodeGenFunction(*this).GenerateObjCCtorDtorMethod(D, CTORMethod,
true);
7301void CodeGenModule::EmitLinkageSpec(
const LinkageSpecDecl *LSD) {
7308 EmitDeclContext(LSD);
7311void CodeGenModule::EmitTopLevelStmt(
const TopLevelStmtDecl *D) {
7313 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
7316 std::unique_ptr<CodeGenFunction> &CurCGF =
7317 GlobalTopLevelStmtBlockInFlight.first;
7321 if (CurCGF && CXXGlobalInits.back() != CurCGF->CurFn) {
7329 std::string Name =
"__stmts__" + llvm::utostr(CXXGlobalInits.size());
7330 FunctionArgList Args;
7332 const CGFunctionInfo &FnInfo =
7335 llvm::Function *
Fn = llvm::Function::Create(
7336 FnTy, llvm::GlobalValue::InternalLinkage, Name, &
getModule());
7338 CurCGF.reset(
new CodeGenFunction(*
this));
7339 GlobalTopLevelStmtBlockInFlight.second = D;
7340 CurCGF->StartFunction(GlobalDecl(), RetTy, Fn, FnInfo, Args,
7342 CXXGlobalInits.push_back(Fn);
7345 CurCGF->EmitStmt(D->
getStmt());
7348void CodeGenModule::EmitDeclContext(
const DeclContext *DC) {
7349 for (
auto *I : DC->
decls()) {
7355 if (
auto *OID = dyn_cast<ObjCImplDecl>(I)) {
7356 for (
auto *M : OID->methods())
7375 case Decl::CXXConversion:
7376 case Decl::CXXMethod:
7377 case Decl::Function:
7384 case Decl::CXXDeductionGuide:
7389 case Decl::Decomposition:
7390 case Decl::VarTemplateSpecialization:
7392 if (
auto *DD = dyn_cast<DecompositionDecl>(D))
7393 for (
auto *B : DD->flat_bindings())
7394 if (
auto *HD = B->getHoldingVar())
7401 case Decl::IndirectField:
7405 case Decl::Namespace:
7408 case Decl::ClassTemplateSpecialization: {
7411 if (Spec->getSpecializationKind() ==
7413 Spec->hasDefinition())
7414 DI->completeTemplateDefinition(*Spec);
7416 case Decl::CXXRecord: {
7420 DI->EmitAndRetainType(
7424 DI->completeUnusedClass(*CRD);
7427 for (
auto *I : CRD->
decls())
7433 case Decl::UsingShadow:
7434 case Decl::ClassTemplate:
7435 case Decl::VarTemplate:
7437 case Decl::VarTemplatePartialSpecialization:
7438 case Decl::FunctionTemplate:
7439 case Decl::TypeAliasTemplate:
7448 case Decl::UsingEnum:
7452 case Decl::NamespaceAlias:
7456 case Decl::UsingDirective:
7460 case Decl::CXXConstructor:
7463 case Decl::CXXDestructor:
7467 case Decl::StaticAssert:
7474 case Decl::ObjCInterface:
7475 case Decl::ObjCCategory:
7478 case Decl::ObjCProtocol: {
7480 if (Proto->isThisDeclarationADefinition())
7481 ObjCRuntime->GenerateProtocol(Proto);
7485 case Decl::ObjCCategoryImpl:
7491 case Decl::ObjCImplementation: {
7493 EmitObjCPropertyImplementations(OMD);
7494 EmitObjCIvarInitializations(OMD);
7495 ObjCRuntime->GenerateClass(OMD);
7499 DI->getOrCreateInterfaceType(
getContext().getObjCInterfaceType(
7500 OMD->getClassInterface()), OMD->getLocation());
7503 case Decl::ObjCMethod: {
7510 case Decl::ObjCCompatibleAlias:
7514 case Decl::PragmaComment: {
7516 switch (PCD->getCommentKind()) {
7518 llvm_unreachable(
"unexpected pragma comment kind");
7533 case Decl::PragmaDetectMismatch: {
7539 case Decl::LinkageSpec:
7543 case Decl::FileScopeAsm: {
7545 if (LangOpts.CUDA && LangOpts.CUDAIsDevice)
7548 if (LangOpts.OpenMPIsTargetDevice)
7551 if (LangOpts.SYCLIsDevice)
7554 getModule().appendModuleInlineAsm(AD->getAsmString());
7558 case Decl::TopLevelStmt:
7562 case Decl::Import: {
7566 if (!ImportedModules.insert(Import->getImportedModule()))
7570 if (!Import->getImportedOwningModule()) {
7572 DI->EmitImportDecl(*Import);
7578 if (CXX20ModuleInits && Import->getImportedModule() &&
7579 Import->getImportedModule()->isNamedModule())
7588 Visited.insert(Import->getImportedModule());
7589 Stack.push_back(Import->getImportedModule());
7591 while (!Stack.empty()) {
7593 if (!EmittedModuleInitializers.insert(Mod).second)
7596 for (
auto *D : Context.getModuleInitializers(Mod))
7603 if (Submodule->IsExplicit)
7606 if (Visited.insert(Submodule).second)
7607 Stack.push_back(Submodule);
7617 case Decl::OMPThreadPrivate:
7621 case Decl::OMPAllocate:
7625 case Decl::OMPDeclareReduction:
7629 case Decl::OMPDeclareMapper:
7633 case Decl::OMPRequires:
7638 case Decl::TypeAlias:
7640 DI->EmitAndRetainType(
getContext().getTypedefType(
7648 DI->EmitAndRetainType(
7655 DI->EmitAndRetainType(
7659 case Decl::HLSLRootSignature:
7662 case Decl::HLSLBuffer:
7666 case Decl::OpenACCDeclare:
7669 case Decl::OpenACCRoutine:
7684 if (!CodeGenOpts.CoverageMapping)
7687 case Decl::CXXConversion:
7688 case Decl::CXXMethod:
7689 case Decl::Function:
7690 case Decl::ObjCMethod:
7691 case Decl::CXXConstructor:
7692 case Decl::CXXDestructor: {
7701 DeferredEmptyCoverageMappingDecls.try_emplace(D,
true);
7711 if (!CodeGenOpts.CoverageMapping)
7713 if (
const auto *Fn = dyn_cast<FunctionDecl>(D)) {
7714 if (Fn->isTemplateInstantiation())
7717 DeferredEmptyCoverageMappingDecls.insert_or_assign(D,
false);
7725 for (
const auto &Entry : DeferredEmptyCoverageMappingDecls.takeVector()) {
7728 const Decl *D = Entry.first;
7730 case Decl::CXXConversion:
7731 case Decl::CXXMethod:
7732 case Decl::Function:
7733 case Decl::ObjCMethod: {
7740 case Decl::CXXConstructor: {
7747 case Decl::CXXDestructor: {
7764 if (llvm::Function *F =
getModule().getFunction(
"main")) {
7765 if (!F->isDeclaration() && F->arg_size() == 0 && !F->isVarArg() &&
7766 F->getReturnType()->isIntegerTy(Context.getTargetInfo().getIntWidth())) {
7767 auto *GA = llvm::GlobalAlias::create(
"__main_void", F);
7768 GA->setVisibility(llvm::GlobalValue::HiddenVisibility);
7777 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
7778 return llvm::ConstantInt::get(i64, PtrInt);
7782 llvm::NamedMDNode *&GlobalMetadata,
7784 llvm::GlobalValue *
Addr) {
7785 if (!GlobalMetadata)
7787 CGM.
getModule().getOrInsertNamedMetadata(
"clang.global.decl.ptrs");
7790 llvm::Metadata *Ops[] = {llvm::ConstantAsMetadata::get(
Addr),
7793 GlobalMetadata->addOperand(llvm::MDNode::get(CGM.
getLLVMContext(), Ops));
7796bool CodeGenModule::CheckAndReplaceExternCIFuncs(llvm::GlobalValue *Elem,
7797 llvm::GlobalValue *CppFunc) {
7799 llvm::SmallVector<llvm::GlobalIFunc *> IFuncs;
7802 llvm::SmallVector<llvm::ConstantExpr *> CEs;
7805 if (Elem == CppFunc)
7811 for (llvm::User *User : Elem->users()) {
7815 if (
auto *ConstExpr = dyn_cast<llvm::ConstantExpr>(User)) {
7816 if (ConstExpr->getOpcode() != llvm::Instruction::BitCast)
7819 for (llvm::User *CEUser : ConstExpr->users()) {
7820 if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(CEUser)) {
7821 IFuncs.push_back(IFunc);
7826 CEs.push_back(ConstExpr);
7827 }
else if (
auto *IFunc = dyn_cast<llvm::GlobalIFunc>(User)) {
7828 IFuncs.push_back(IFunc);
7840 for (llvm::GlobalIFunc *IFunc : IFuncs)
7841 IFunc->setResolver(
nullptr);
7842 for (llvm::ConstantExpr *ConstExpr : CEs)
7843 ConstExpr->destroyConstant();
7847 Elem->eraseFromParent();
7849 for (llvm::GlobalIFunc *IFunc : IFuncs) {
7854 llvm::FunctionType::get(IFunc->getType(),
false);
7855 llvm::Constant *Resolver = GetOrCreateLLVMFunction(
7856 CppFunc->getName(), ResolverTy, {},
false);
7857 IFunc->setResolver(Resolver);
7867void CodeGenModule::EmitStaticExternCAliases() {
7870 for (
auto &I : StaticExternCValues) {
7871 const IdentifierInfo *Name = I.first;
7872 llvm::GlobalValue *Val = I.second;
7880 llvm::GlobalValue *ExistingElem =
7885 if (!ExistingElem || CheckAndReplaceExternCIFuncs(ExistingElem, Val))
7892 auto Res = Manglings.find(MangledName);
7893 if (Res == Manglings.end())
7895 Result = Res->getValue();
7906void CodeGenModule::EmitDeclMetadata() {
7907 llvm::NamedMDNode *GlobalMetadata =
nullptr;
7909 for (
auto &I : MangledDeclNames) {
7910 llvm::GlobalValue *
Addr =
getModule().getNamedValue(I.second);
7920void CodeGenFunction::EmitDeclMetadata() {
7921 if (LocalDeclMap.empty())
return;
7926 unsigned DeclPtrKind = Context.getMDKindID(
"clang.decl.ptr");
7928 llvm::NamedMDNode *GlobalMetadata =
nullptr;
7930 for (
auto &I : LocalDeclMap) {
7931 const Decl *D = I.first;
7932 llvm::Value *
Addr = I.second.emitRawPointer(*
this);
7933 if (
auto *Alloca = dyn_cast<llvm::AllocaInst>(
Addr)) {
7935 Alloca->setMetadata(
7936 DeclPtrKind, llvm::MDNode::get(
7937 Context, llvm::ValueAsMetadata::getConstant(DAddr)));
7938 }
else if (
auto *GV = dyn_cast<llvm::GlobalValue>(
Addr)) {
7945void CodeGenModule::EmitVersionIdentMetadata() {
7946 llvm::NamedMDNode *IdentMetadata =
7947 TheModule.getOrInsertNamedMetadata(
"llvm.ident");
7949 llvm::LLVMContext &Ctx = TheModule.getContext();
7951 llvm::Metadata *IdentNode[] = {llvm::MDString::get(Ctx, Version)};
7952 IdentMetadata->addOperand(llvm::MDNode::get(Ctx, IdentNode));
7955void CodeGenModule::EmitCommandLineMetadata() {
7956 llvm::NamedMDNode *CommandLineMetadata =
7957 TheModule.getOrInsertNamedMetadata(
"llvm.commandline");
7959 llvm::LLVMContext &Ctx = TheModule.getContext();
7961 llvm::Metadata *CommandLineNode[] = {llvm::MDString::get(Ctx, CommandLine)};
7962 CommandLineMetadata->addOperand(llvm::MDNode::get(Ctx, CommandLineNode));
7965void CodeGenModule::EmitCoverageFile() {
7966 llvm::NamedMDNode *CUNode = TheModule.getNamedMetadata(
"llvm.dbg.cu");
7970 llvm::NamedMDNode *GCov = TheModule.getOrInsertNamedMetadata(
"llvm.gcov");
7971 llvm::LLVMContext &Ctx = TheModule.getContext();
7972 auto *CoverageDataFile =
7974 auto *CoverageNotesFile =
7976 for (
int i = 0, e = CUNode->getNumOperands(); i != e; ++i) {
7977 llvm::MDNode *CU = CUNode->getOperand(i);
7978 llvm::Metadata *Elts[] = {CoverageNotesFile, CoverageDataFile, CU};
7979 GCov->addOperand(llvm::MDNode::get(Ctx, Elts));
7992 LangOpts.ObjCRuntime.isGNUFamily())
7993 return ObjCRuntime->GetEHType(Ty);
8000 if (LangOpts.OpenMP && LangOpts.OpenMPSimd)
8002 for (
auto RefExpr : D->
varlist()) {
8005 VD->getAnyInitializer() &&
8006 !VD->getAnyInitializer()->isConstantInitializer(
getContext(),
8013 VD,
Addr, RefExpr->getBeginLoc(), PerformInit))
8014 CXXGlobalInits.push_back(InitFunction);
8019CodeGenModule::CreateMetadataIdentifierImpl(
QualType T, MetadataTypeMap &Map,
8023 FnType->getReturnType(), FnType->getParamTypes(),
8024 FnType->getExtProtoInfo().withExceptionSpec(
EST_None));
8026 llvm::Metadata *&InternalId = Map[
T.getCanonicalType()];
8031 std::string OutName;
8032 llvm::raw_string_ostream Out(OutName);
8037 Out <<
".normalized";
8060 return CreateMetadataIdentifierImpl(
T, MetadataIdMap,
"");
8065 return CreateMetadataIdentifierImpl(
T, VirtualMetadataIdMap,
".virtual");
8069 return CreateMetadataIdentifierImpl(
T, GeneralizedMetadataIdMap,
8077 return ((LangOpts.Sanitize.has(SanitizerKind::CFIVCall) &&
8078 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIVCall)) ||
8079 (LangOpts.Sanitize.has(SanitizerKind::CFINVCall) &&
8080 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFINVCall)) ||
8081 (LangOpts.Sanitize.has(SanitizerKind::CFIDerivedCast) &&
8082 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIDerivedCast)) ||
8083 (LangOpts.Sanitize.has(SanitizerKind::CFIUnrelatedCast) &&
8084 !CodeGenOpts.SanitizeTrap.has(SanitizerKind::CFIUnrelatedCast)));
8092 VTable->addTypeMetadata(Offset.getQuantity(), MD);
8094 if (CodeGenOpts.SanitizeCfiCrossDso)
8096 VTable->addTypeMetadata(Offset.getQuantity(),
8097 llvm::ConstantAsMetadata::get(CrossDsoTypeId));
8100 llvm::Metadata *MD = llvm::MDString::get(
getLLVMContext(),
"all-vtables");
8101 VTable->addTypeMetadata(Offset.getQuantity(), MD);
8107 SanStats = std::make_unique<llvm::SanitizerStatReport>(&
getModule());
8117 auto *FTy = llvm::FunctionType::get(SamplerT, {
C->getType()},
false);
8132 bool forPointeeType) {
8143 if (
auto Align = TT->getDecl()->getMaxAlignment()) {
8150 bool AlignForArray =
T->isArrayType();
8156 if (
T->isIncompleteType()) {
8173 if (
T.getQualifiers().hasUnaligned()) {
8175 }
else if (forPointeeType && !AlignForArray &&
8176 (RD =
T->getAsCXXRecordDecl())) {
8187 if (
unsigned MaxAlign =
getLangOpts().MaxTypeAlign) {
8200 if (NumAutoVarInit >= StopAfter) {
8203 if (!NumAutoVarInit) {
8206 "-ftrivial-auto-var-init-stop-after=%0 has been enabled to limit the "
8207 "number of times ftrivial-auto-var-init=%1 gets applied.");
8221 const Decl *D)
const {
8225 OS << (isa<VarDecl>(D) ?
".static." :
".intern.");
8227 OS << (isa<VarDecl>(D) ?
"__static__" :
"__intern__");
8233 assert(PLoc.
isValid() &&
"Source location is expected to be valid.");
8237 llvm::MD5::MD5Result
Result;
8238 for (
const auto &Arg : PreprocessorOpts.Macros)
8239 Hash.update(Arg.first);
8243 llvm::sys::fs::UniqueID ID;
8247 assert(PLoc.
isValid() &&
"Source location is expected to be valid.");
8251 SM.getDiagnostics().Report(diag::err_cannot_open_file)
8252 << PLoc.
getFilename() << Status.getError().message();
8254 ID = Status->getUniqueID();
8256 OS << llvm::format(
"%x", ID.getFile()) << llvm::format(
"%x", ID.getDevice())
8257 <<
"_" << llvm::utohexstr(
Result.low(),
true, 8);
8264 assert(DeferredDeclsToEmit.empty() &&
8265 "Should have emitted all decls deferred to emit.");
8266 assert(NewBuilder->DeferredDecls.empty() &&
8267 "Newly created module should not have deferred decls");
8268 NewBuilder->DeferredDecls = std::move(DeferredDecls);
8269 assert(EmittedDeferredDecls.empty() &&
8270 "Still have (unmerged) EmittedDeferredDecls deferred decls");
8272 assert(NewBuilder->DeferredVTables.empty() &&
8273 "Newly created module should not have deferred vtables");
8274 NewBuilder->DeferredVTables = std::move(DeferredVTables);
8276 assert(NewBuilder->MangledDeclNames.empty() &&
8277 "Newly created module should not have mangled decl names");
8278 assert(NewBuilder->Manglings.empty() &&
8279 "Newly created module should not have manglings");
8280 NewBuilder->Manglings = std::move(Manglings);
8282 NewBuilder->WeakRefReferences = std::move(WeakRefReferences);
8284 NewBuilder->ABI->MangleCtx = std::move(ABI->MangleCtx);
Defines the clang::ASTContext interface.
This file provides some common utility functions for processing Lambda related AST Constructs.
Defines the Diagnostic-related interfaces.
Defines enum values for all the target-independent builtin functions.
static bool shouldAssumeDSOLocal(const CIRGenModule &cgm, cir::CIRGlobalValueInterface gv)
static bool shouldBeInCOMDAT(CIRGenModule &cgm, const Decl &d)
static std::string getMangledNameImpl(CIRGenModule &cgm, GlobalDecl gd, const NamedDecl *nd)
static CIRGenCXXABI * createCXXABI(CIRGenModule &cgm)
static bool isVarDeclStrongDefinition(const ASTContext &astContext, CIRGenModule &cgm, const VarDecl *vd, bool noCommon)
static void setLinkageForGV(cir::GlobalOp &gv, const NamedDecl *nd)
static bool hasExistingGeneralizedTypeMD(llvm::Function *F)
static void AppendCPUSpecificCPUDispatchMangling(const CodeGenModule &CGM, const CPUSpecificAttr *Attr, unsigned CPUIndex, raw_ostream &Out)
static bool AllTrivialInitializers(CodeGenModule &CGM, ObjCImplementationDecl *D)
static const FunctionDecl * GetRuntimeFunctionDecl(ASTContext &C, StringRef Name)
static GlobalDecl getBaseVariantGlobalDecl(const NamedDecl *D)
static void checkAliasForTocData(llvm::GlobalVariable *GVar, const CodeGenOptions &CodeGenOpts, DiagnosticsEngine &Diags, SourceLocation Location)
static bool hasImplicitAttr(const ValueDecl *D)
static void emitUsed(CodeGenModule &CGM, StringRef Name, std::vector< llvm::WeakTrackingVH > &List)
static bool HasNonDllImportDtor(QualType T)
static llvm::Constant * GetPointerConstant(llvm::LLVMContext &Context, const void *Ptr)
Turns the given pointer into a constant.
static llvm::GlobalVariable::ThreadLocalMode GetLLVMTLSModel(StringRef S)
static llvm::GlobalValue::LinkageTypes getMultiversionLinkage(CodeGenModule &CGM, GlobalDecl GD)
static void setVisibilityFromDLLStorageClass(const clang::LangOptions &LO, llvm::Module &M)
static QualType GeneralizeTransparentUnion(QualType Ty)
static std::string getCPUSpecificMangling(const CodeGenModule &CGM, StringRef Name)
static void setWindowsItaniumDLLImport(CodeGenModule &CGM, bool Local, llvm::Function *F, StringRef Name)
static const char AnnotationSection[]
static bool isUniqueInternalLinkageDecl(GlobalDecl GD, CodeGenModule &CGM)
static bool allowKCFIIdentifier(StringRef Name)
static void replaceUsesOfNonProtoConstant(llvm::Constant *old, llvm::Function *newFn)
Replace the uses of a function that was declared with a non-proto type.
static llvm::Constant * castStringLiteralToDefaultAddressSpace(CodeGenModule &CGM, llvm::GlobalVariable *GV)
static void checkDataLayoutConsistency(const TargetInfo &Target, llvm::LLVMContext &Context, const LangOptions &Opts)
static QualType GeneralizeFunctionType(ASTContext &Ctx, QualType Ty, bool GeneralizePointers)
static bool needsDestructMethod(ObjCImplementationDecl *impl)
static bool isStackProtectorOn(const LangOptions &LangOpts, const llvm::Triple &Triple, clang::LangOptions::StackProtectorMode Mode)
static void removeImageAccessQualifier(std::string &TyName)
static llvm::StringMapEntry< llvm::GlobalVariable * > & GetConstantCFStringEntry(llvm::StringMap< llvm::GlobalVariable * > &Map, const StringLiteral *Literal, bool TargetIsLSB, bool &IsUTF16, unsigned &StringLength)
static void setLLVMVisibility(llvm::GlobalValue &GV, std::optional< llvm::GlobalValue::VisibilityTypes > V)
static llvm::GlobalVariable * GenerateStringLiteral(llvm::Constant *C, llvm::GlobalValue::LinkageTypes LT, CodeGenModule &CGM, StringRef GlobalName, CharUnits Alignment)
static bool hasUnwindExceptions(const LangOptions &LangOpts)
Determines whether the language options require us to model unwind exceptions.
static llvm::APInt getFMVPriority(const TargetInfo &TI, const CodeGenFunction::FMVResolverOption &RO)
static void addLinkOptionsPostorder(CodeGenModule &CGM, Module *Mod, SmallVectorImpl< llvm::MDNode * > &Metadata, llvm::SmallPtrSet< Module *, 16 > &Visited)
Add link options implied by the given module, including modules it depends on, using a postorder walk...
static llvm::cl::opt< bool > LimitedCoverage("limited-coverage-experimental", llvm::cl::Hidden, llvm::cl::desc("Emit limited coverage mapping information (experimental)"))
static CGCXXABI * createCXXABI(CodeGenModule &CGM)
static std::unique_ptr< TargetCodeGenInfo > createTargetCodeGenInfo(CodeGenModule &CGM)
static const llvm::GlobalValue * getAliasedGlobal(const llvm::GlobalValue *GV)
static QualType GeneralizeType(ASTContext &Ctx, QualType Ty, bool GeneralizePointers)
static constexpr auto ErrnoTBAAMDName
static unsigned ArgInfoAddressSpace(LangAS AS)
static void replaceDeclarationWith(llvm::GlobalValue *Old, llvm::Constant *New)
static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, llvm::Function *NewFn)
ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we implement a function with...
static std::optional< llvm::GlobalValue::VisibilityTypes > getLLVMVisibility(clang::LangOptions::VisibilityFromDLLStorageClassKinds K)
static bool requiresMemberFunctionPointerTypeMetadata(CodeGenModule &CGM, const CXXMethodDecl *MD)
static bool checkAliasedGlobal(const ASTContext &Context, DiagnosticsEngine &Diags, SourceLocation Location, bool IsIFunc, const llvm::GlobalValue *Alias, const llvm::GlobalValue *&GV, const llvm::MapVector< GlobalDecl, StringRef > &MangledDeclNames, SourceRange AliasRange)
static void EmitGlobalDeclMetadata(CodeGenModule &CGM, llvm::NamedMDNode *&GlobalMetadata, GlobalDecl D, llvm::GlobalValue *Addr)
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
Defines the C++ template declaration subclasses.
llvm::MachO::Target Target
llvm::MachO::Record Record
Defines the clang::Module class, which describes a module in the source code.
static bool hasAttr(const Decl *D, bool IgnoreImplicitAttr)
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()
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
void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const
Emit the Objective-CC type encoding for the given type T into S.
QualType getFunctionNoProtoType(QualType ResultTy, const FunctionType::ExtInfo &Info) const
Return a K&R style C function type like 'int()'.
bool shouldExternalize(const Decl *D) const
Whether a C++ static variable or CUDA/HIP kernel should be externalized.
const XRayFunctionFilter & getXRayFilter() const
bool DeclMustBeEmitted(const Decl *D)
Determines if the decl can be CodeGen'ed or deserialized from PCH lazily, only when used; this is onl...
QualType getPointerType(QualType T) const
Return the uniqued reference to the type for a pointer to the specified type.
StringRef getCUIDHash() const
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.
const NoSanitizeList & getNoSanitizeList() const
GVALinkage GetGVALinkageForFunction(const FunctionDecl *FD) const
CharUnits getDeclAlign(const Decl *D, bool ForAlignof=false) const
Return a conservative estimate of the alignment of the specified decl D.
CharUnits getAlignOfGlobalVarInChars(QualType T, const VarDecl *VD) const
Return the alignment in characters that should be given to a global variable with type T.
GVALinkage GetGVALinkageForVariable(const VarDecl *VD) const
CharUnits getTypeSizeInChars(QualType T) const
Return the size of the specified (complete) type T, in characters.
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.
CanQualType getCanonicalTagType(const TagDecl *TD) const
unsigned getTargetAddressSpace(LangAS AS) const
Module * getCurrentNamedModule() const
Get module under construction, nullptr if this is not a C++20 module.
Attr - This represents one attribute.
Represents a block literal declaration, which is like an unnamed FunctionDecl.
bool isLibFunction(unsigned ID) const
Return true if this is a builtin for a libc/libm function, with a "__builtin_" prefix (e....
std::string getName(unsigned ID) const
Return the identifier name for the specified builtin, e.g.
Represents a base class of a C++ class.
CXXTemporary * getTemporary()
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.
FunctionDecl * getOperatorDelete() const
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.
FunctionDecl * getOperatorNew() const
Represents a C++ struct/union/class.
unsigned getNumBases() const
Retrieves the number of base classes of this class.
bool hasDefinition() const
const CXXDestructorDecl * getDestructor() const
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 MSSecureHotPatchFunctionsFile
The name of a file that contains functions which will be compiled for hotpatching.
std::string RecordCommandLine
The string containing the commandline for the llvm.commandline metadata, if non-empty.
std::string FloatABI
The ABI to use for passing floating point arguments.
llvm::Reloc::Model RelocationModel
The name of the relocation model to use.
std::vector< std::string > TocDataVarsUserSpecified
List of global variables explicitly specified by the user as toc-data.
PointerAuthOptions PointerAuth
Configuration for pointer-signing.
std::vector< std::string > MSSecureHotPatchFunctionsList
A list of functions which will be compiled for hotpatching.
ABIInfo - Target specific hooks for defining how a type should be passed or returned from functions.
virtual void appendAttributeMangling(TargetAttr *Attr, raw_ostream &Out) const
Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...
virtual void handleVarRegistration(const VarDecl *VD, llvm::GlobalVariable &Var)=0
Check whether a variable is a device variable and register it if true.
virtual llvm::GlobalValue * getKernelHandle(llvm::Function *Stub, GlobalDecl GD)=0
Get kernel handle by stub function.
virtual void internalizeDeviceSideVar(const VarDecl *D, llvm::GlobalValue::LinkageTypes &Linkage)=0
Adjust linkage of shadow variables in host compilation.
Implements C++ ABI-specific code generation functions.
virtual void EmitCXXConstructors(const CXXConstructorDecl *D)=0
Emit constructor variants required by this ABI.
virtual llvm::Constant * getAddrOfRTTIDescriptor(QualType Ty)=0
virtual void EmitCXXDestructors(const CXXDestructorDecl *D)=0
Emit destructor variants required by this ABI.
virtual void setCXXDestructorDLLStorage(llvm::GlobalValue *GV, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
virtual llvm::GlobalValue::LinkageTypes getCXXDestructorLinkage(GVALinkage Linkage, const CXXDestructorDecl *Dtor, CXXDtorType DT) const
MangleContext & getMangleContext()
Gets the mangle context.
This class gathers all debug information during compilation and is responsible for emitting to llvm g...
void EmitExternalVariable(llvm::GlobalVariable *GV, const VarDecl *Decl)
Emit information about an external variable.
void EmitFunctionDecl(GlobalDecl GD, SourceLocation Loc, QualType FnType, llvm::Function *Fn=nullptr)
Emit debug info for a function declaration.
void AddStringLiteralDebugInfo(llvm::GlobalVariable *GV, const StringLiteral *S)
DebugInfo isn't attached to string literals by default.
CGFunctionInfo - Class to encapsulate the information about a function definition.
void handleGlobalVarDefinition(const VarDecl *VD, llvm::GlobalVariable *Var)
void addRootSignature(const HLSLRootSignatureDecl *D)
void addBuffer(const HLSLBufferDecl *D)
llvm::Type * getSamplerType(const Type *T)
void emitDeferredTargetDecls() const
Emit deferred declare target variables marked for deferred emission.
virtual void emitDeclareTargetFunction(const FunctionDecl *FD, llvm::GlobalValue *GV)
Emit code for handling declare target functions in the runtime.
virtual ConstantAddress getAddrOfDeclareTargetVar(const VarDecl *VD)
Returns the address of the variable marked as declare target with link clause OR as declare target wi...
bool hasRequiresUnifiedSharedMemory() const
Return whether the unified_shared_memory has been specified.
virtual void emitDeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn)
Marks function Fn with properly mangled versions of vector functions.
virtual void registerTargetGlobalVariable(const VarDecl *VD, llvm::Constant *Addr)
Checks if the provided global decl GD is a declare target variable and registers it when emitting cod...
CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...
void GenerateCode(GlobalDecl GD, llvm::Function *Fn, const CGFunctionInfo &FnInfo)
void EmitCfiCheckFail()
Emit a cross-DSO CFI failure handling function.
void GenerateObjCGetter(ObjCImplementationDecl *IMP, const ObjCPropertyImplDecl *PID)
GenerateObjCGetter - Synthesize an Objective-C property getter function.
void EmitCfiCheckStub()
Emit a stub for the cross-DSO CFI check function.
void GenerateObjCMethod(const ObjCMethodDecl *OMD)
Generate an Objective-C method.
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.
llvm::LLVMContext & getLLVMContext()
bool isTrivialInitializer(const Expr *Init)
Determine whether the given initializer is trivial in the sense that it requires no code to be genera...
This class organizes the cross-function state that is used while generating LLVM code.
StringRef getBlockMangledName(GlobalDecl GD, const BlockDecl *BD)
ConstantAddress GetAddrOfMSGuidDecl(const MSGuidDecl *GD)
Get the address of a GUID.
void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const
Set visibility, dllimport/dllexport and dso_local.
void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset, const CXXRecordDecl *RD)
Create and attach type metadata for the given vtable.
void UpdateCompletedType(const TagDecl *TD)
llvm::MDNode * getTBAAAccessTagInfo(TBAAAccessInfo Info)
getTBAAAccessTagInfo - Get TBAA tag for a given memory access.
llvm::GlobalVariable::ThreadLocalMode GetDefaultLLVMTLSModel() const
Get LLVM TLS mode from CodeGenOptions.
void SetInternalFunctionAttributes(GlobalDecl GD, llvm::Function *F, const CGFunctionInfo &FI)
Set the attributes on the LLVM function for the given decl and function info.
void setDSOLocal(llvm::GlobalValue *GV) const
llvm::MDNode * getTBAAStructInfo(QualType QTy)
CGHLSLRuntime & getHLSLRuntime()
Return a reference to the configured HLSL runtime.
llvm::Constant * EmitAnnotationArgs(const AnnotateAttr *Attr)
Emit additional args of the annotation.
llvm::Module & getModule() const
llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)
Create or return a runtime function declaration with the specified type and name.
llvm::ConstantInt * CreateKCFITypeId(QualType T, StringRef Salt)
Generate a KCFI type identifier for T.
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.
void createFunctionTypeMetadataForIcall(const FunctionDecl *FD, llvm::Function *F)
Create and attach type metadata to the given function.
bool getExpressionLocationsEnabled() const
Return true if we should emit location information for expressions.
void addGlobalValReplacement(llvm::GlobalValue *GV, llvm::Constant *C)
llvm::Constant * GetAddrOfRTTIDescriptor(QualType Ty, bool ForEH=false)
Get the address of the RTTI descriptor for the given type.
llvm::Constant * GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty=nullptr, bool ForVTable=false, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the given function.
void setGVPropertiesAux(llvm::GlobalValue *GV, const NamedDecl *D) const
const IntrusiveRefCntPtr< llvm::vfs::FileSystem > & getFileSystem() const
const ABIInfo & getABIInfo()
void EmitMainVoidAlias()
Emit an alias for "main" if it has no arguments (needed for wasm).
void DecorateInstructionWithInvariantGroup(llvm::Instruction *I, const CXXRecordDecl *RD)
Adds !invariant.barrier !tag to instruction.
DiagnosticsEngine & getDiags() const
bool isInNoSanitizeList(SanitizerMask Kind, llvm::Function *Fn, SourceLocation Loc) const
void runWithSufficientStackSpace(SourceLocation Loc, llvm::function_ref< void()> Fn)
Run some code with "sufficient" stack space.
llvm::Constant * getAddrOfCXXStructor(GlobalDecl GD, const CGFunctionInfo *FnInfo=nullptr, llvm::FunctionType *FnType=nullptr, bool DontDefer=false, ForDefinition_t IsForDefinition=NotForDefinition)
Return the address of the constructor/destructor of the given type.
void ErrorUnsupported(const Stmt *S, const char *Type)
Print out an error that codegen doesn't support the specified stmt yet.
llvm::Constant * EmitAnnotateAttr(llvm::GlobalValue *GV, const AnnotateAttr *AA, SourceLocation L)
Generate the llvm::ConstantStruct which contains the annotation information for a given GlobalValue.
void EmitOpenACCDeclare(const OpenACCDeclareDecl *D, CodeGenFunction *CGF=nullptr)
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 createIndirectFunctionTypeMD(const FunctionDecl *FD, llvm::Function *F)
Create and attach type metadata if the function is a potential indirect call target to support call g...
void AppendLinkerOptions(StringRef Opts)
Appends Opts to the "llvm.linker.options" metadata value.
void createCalleeTypeMetadataForIcall(const QualType &QT, llvm::CallBase *CB)
Create and attach type metadata to the given call.
void EmitExternalDeclaration(const DeclaratorDecl *D)
void AddDependentLib(StringRef Lib)
Appends a dependent lib to the appropriate metadata value.
void Release()
Finalize LLVM code generation.
ProfileList::ExclusionType isFunctionBlockedByProfileList(llvm::Function *Fn, SourceLocation Loc) const
llvm::MDNode * getTBAABaseTypeInfo(QualType QTy)
getTBAABaseTypeInfo - Get metadata that describes the given base access type.
bool lookupRepresentativeDecl(StringRef MangledName, GlobalDecl &Result) const
void EmitOMPAllocateDecl(const OMPAllocateDecl *D)
Emit a code for the allocate directive.
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.
SanitizerMetadata * getSanitizerMetadata()
llvm::Metadata * CreateMetadataIdentifierGeneralized(QualType T)
Create a metadata identifier for the generalization of the given type.
void EmitGlobalAnnotations()
Emit all the global annotations.
CharUnits getClassPointerAlignment(const CXXRecordDecl *CD)
Returns the assumed alignment of an opaque pointer to the given class.
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)
AtomicOptions getAtomicOpts()
Get the current Atomic options.
ConstantAddress GetAddrOfConstantCFString(const StringLiteral *Literal)
Return a pointer to a constant CFString object for the given string.
ProfileList::ExclusionType isFunctionBlockedFromProfileInstr(llvm::Function *Fn, SourceLocation Loc) const
void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV)
Add global annotations that are set on D, for the global GV.
void setTLSMode(llvm::GlobalValue *GV, const VarDecl &D) const
Set the TLS mode for the given LLVM GlobalValue for the thread-local variable declaration D.
ConstantAddress GetAddrOfConstantStringFromLiteral(const StringLiteral *S, StringRef Name=".str")
Return a pointer to a constant array for the given string literal.
ASTContext & getContext() const
ConstantAddress GetAddrOfTemplateParamObject(const TemplateParamObjectDecl *TPO)
Get the address of a template parameter object.
void EmitOMPThreadPrivateDecl(const OMPThreadPrivateDecl *D)
Emit a code for threadprivate directive.
ConstantAddress GetAddrOfUnnamedGlobalConstantDecl(const UnnamedGlobalConstantDecl *GCD)
Get the address of a UnnamedGlobalConstant.
TBAAAccessInfo mergeTBAAInfoForCast(TBAAAccessInfo SourceInfo, TBAAAccessInfo TargetInfo)
mergeTBAAInfoForCast - Get merged TBAA information for the purposes of type casts.
llvm::Constant * GetAddrOfGlobalVar(const VarDecl *D, llvm::Type *Ty=nullptr, ForDefinition_t IsForDefinition=NotForDefinition)
Return the llvm::Constant for the address of the given global variable.
llvm::SanitizerStatReport & getSanStats()
llvm::Constant * EmitAnnotationString(StringRef Str)
Emit an annotation string.
void EmitOMPDeclareMapper(const OMPDeclareMapperDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare mapper construct.
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 setKCFIType(const FunctionDecl *FD, llvm::Function *F)
Set type metadata to the given function.
void maybeSetTrivialComdat(const Decl &D, llvm::GlobalObject &GO)
void EmitOMPDeclareReduction(const OMPDeclareReductionDecl *D, CodeGenFunction *CGF=nullptr)
Emit a code for declare reduction construct.
llvm::Function * getIntrinsic(unsigned IID, ArrayRef< llvm::Type * > Tys={})
void AddDetectMismatch(StringRef Name, StringRef Value)
Appends a detect mismatch command to the linker options.
void setDLLImportDLLExport(llvm::GlobalValue *GV, GlobalDecl D) const
llvm::Value * createOpenCLIntToSamplerConversion(const Expr *E, CodeGenFunction &CGF)
ConstantAddress GetAddrOfGlobalTemporary(const MaterializeTemporaryExpr *E, const Expr *Inner)
Returns a pointer to a global variable representing a temporary with static or thread storage duratio...
llvm::Constant * EmitNullConstant(QualType T)
Return the result of value-initializing the given type, i.e.
LangAS GetGlobalConstantAddressSpace() const
Return the AST address space of constant literal, which is used to emit the constant literal as globa...
LangAS GetGlobalVarAddressSpace(const VarDecl *D)
Return the AST address space of the underlying global variable for D, as determined by its declaratio...
void SetLLVMFunctionAttributes(GlobalDecl GD, const CGFunctionInfo &Info, llvm::Function *F, bool IsThunk)
Set the LLVM function attributes (sext, zext, etc).
void EmitOpenACCRoutine(const OpenACCRoutineDecl *D, CodeGenFunction *CGF=nullptr)
void addReplacement(StringRef Name, llvm::Constant *C)
llvm::Constant * getConstantSignedPointer(llvm::Constant *Pointer, const PointerAuthSchema &Schema, llvm::Constant *StorageAddress, GlobalDecl SchemaDecl, QualType SchemaType)
Sign a constant pointer using the given scheme, producing a constant with the same IR type.
void AddGlobalCtor(llvm::Function *Ctor, int Priority=65535, unsigned LexOrder=~0U, llvm::Constant *AssociatedData=nullptr)
AddGlobalCtor - Add a function to the list that will be called before main() runs.
llvm::Metadata * CreateMetadataIdentifierForFnType(QualType T)
Create a metadata identifier for the given function type.
void SetLLVMFunctionAttributesForDefinition(const Decl *D, llvm::Function *F)
Set the LLVM function attributes which only apply to a function definition.
llvm::Metadata * CreateMetadataIdentifierForVirtualMemPtrType(QualType T)
Create a metadata identifier that is intended to be used to check virtual calls via a member function...
ConstantAddress GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *)
Return a pointer to a constant array for the given ObjCEncodeExpr node.
const GlobalDecl getMangledNameDecl(StringRef)
void ClearUnusedCoverageMapping(const Decl *D)
Remove the deferred empty coverage mapping as this declaration is actually instrumented.
void EmitTopLevelDecl(Decl *D)
Emit code for a single top level declaration.
llvm::Constant * EmitAnnotationUnit(SourceLocation Loc)
Emit the annotation's translation unit.
ConstantAddress GetAddrOfConstantCString(const std::string &Str, StringRef GlobalName=".str")
Returns a pointer to a character array containing the literal and a terminating '\0' character.
void printPostfixForExternalizedDecl(llvm::raw_ostream &OS, const Decl *D) const
Print the postfix for externalized static variable or kernels for single source offloading languages ...
void moveLazyEmissionStates(CodeGenModule *NewBuilder)
Move some lazily-emitted states to the NewBuilder.
llvm::ConstantInt * getSize(CharUnits numChars)
Emit the given number of characters as a value of type size_t.
void finalizeKCFITypes()
Emit KCFI type identifier constants and remove unused identifiers.
void setValueProfilingFlag(llvm::Module &M)
void setProfileVersion(llvm::Module &M)
void emitEmptyCounterMapping(const Decl *D, StringRef FuncName, llvm::GlobalValue::LinkageTypes Linkage)
Emit a coverage mapping range with a counter zero for an unused declaration.
CodeGenTBAA - This class organizes the cross-module state that is used while lowering AST types to LL...
This class organizes the cross-module state that is used while lowering AST types to LLVM types.
llvm::Type * ConvertType(QualType T)
ConvertType - Convert type T into a llvm::Type.
const CGFunctionInfo & arrangeCXXMethodDeclaration(const CXXMethodDecl *MD)
C++ methods have some special rules and also have implicit parameters.
const CGFunctionInfo & arrangeFreeFunctionType(CanQual< FunctionProtoType > Ty)
Arrange the argument and result information for a value of the given freestanding function type.
llvm::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
const CGFunctionInfo & arrangeBuiltinFunctionDeclaration(QualType resultType, const FunctionArgList &args)
A builtin function is a freestanding function using the default C conventions.
unsigned getTargetAddressSpace(QualType T) const
void RefreshTypeCacheForClass(const CXXRecordDecl *RD)
Remove stale types from the type cache when an inheritance model gets assigned to a class.
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
void UpdateCompletedType(const TagDecl *TD)
UpdateCompletedType - When we find the full definition for a TagDecl, replace the 'opaque' type we pr...
const CGFunctionInfo & arrangeGlobalDeclaration(GlobalDecl GD)
void 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.
bool hasDiagnostics()
Whether or not the stats we've gathered indicate any potential problems.
void reportDiagnostics(DiagnosticsEngine &Diags, StringRef MainFile)
Report potential problems we've found to Diags.
TargetCodeGenInfo - This class organizes various target-specific codegeneration issues,...
virtual void getDependentLibraryOption(llvm::StringRef Lib, llvm::SmallString< 24 > &Opt) const
Gets the linker options necessary to link a dependent library on this platform.
Address performAddrSpaceCast(CodeGen::CodeGenFunction &CGF, Address Addr, LangAS SrcAddr, llvm::Type *DestTy, bool IsNonNull=false) const
const T & getABIInfo() const
virtual LangAS getGlobalVarAddressSpace(CodeGenModule &CGM, const VarDecl *D) const
Get target favored AST address space of a global variable for languages other than OpenCL and CUDA.
virtual void setTargetAttributes(const Decl *D, llvm::GlobalValue *GV, CodeGen::CodeGenModule &M) const
setTargetAttributes - Provides a convenient hook to handle extra target-specific attributes for the g...
virtual LangAS getASTAllocaAddressSpace() const
Get the AST address space for alloca.
virtual void emitTargetMetadata(CodeGen::CodeGenModule &CGM, const llvm::MapVector< GlobalDecl, StringRef > &MangledDeclNames) const
emitTargetMetadata - Provides a convenient hook to handle extra target-specific metadata for the give...
virtual void emitTargetGlobals(CodeGen::CodeGenModule &CGM) const
Provides a convenient hook to handle extra target-specific globals.
virtual void getDetectMismatchOption(llvm::StringRef Name, llvm::StringRef Value, llvm::SmallString< 32 > &Opt) const
Gets the linker options necessary to detect object file mismatches on this platform.
Represents the canonical version of C arrays with a specified constant size.
uint64_t getZExtSize() const
Return the size zero-extended as a uint64_t.
Stores additional source code information like skipped ranges which is required by the coverage mappi...
DeclContext - This is used only as base class of specific decl types that can act as declaration cont...
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
void addDecl(Decl *D)
Add the declaration D into this context.
decl_range decls() const
decls_begin/decls_end - Iterate over the declarations stored in this context.
Decl - This represents one declaration (or definition), e.g.
Decl * getMostRecentDecl()
Retrieve the most recent declaration that declares the same entity as this declaration (which may be ...
SourceLocation getEndLoc() const LLVM_READONLY
ASTContext & getASTContext() const LLVM_READONLY
bool isImplicit() const
isImplicit - Indicates whether the declaration was implicitly generated by the implementation.
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
unsigned getMaxAlignment() const
getMaxAlignment - return the maximum alignment specified by attributes on this decl,...
bool isTemplated() const
Determine whether this declaration is a templated entity (whether it is.
bool isInExportDeclContext() const
Whether this declaration was exported in a lexical context.
FunctionDecl * getAsFunction() LLVM_READONLY
Returns the function itself, or the templated function if this is a function template.
llvm::iterator_range< specific_attr_iterator< T > > specific_attrs() const
SourceLocation getLocation() const
SourceLocation getBeginLoc() const LLVM_READONLY
TranslationUnitDecl * getTranslationUnitDecl()
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.
llvm::APSInt EvaluateKnownConstInt(const ASTContext &Ctx) const
EvaluateKnownConstInt - Call EvaluateAsRValue and return the folded integer.
Represents a member of a struct/union/class.
static FieldDecl * Create(const ASTContext &C, DeclContext *DC, SourceLocation StartLoc, SourceLocation IdLoc, const IdentifierInfo *Id, QualType T, TypeSourceInfo *TInfo, Expr *BW, bool Mutable, InClassInitStyle InitStyle)
A reference to a FileEntry that includes the name of the file as it was accessed by the FileManager's...
StringRef getName() const
The name of this FileEntry.
static FixItHint CreateReplacement(CharSourceRange RemoveRange, StringRef Code)
Create a code modification hint that replaces the given source range with the given code string.
Represents a function declaration or definition.
bool isTargetClonesMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-clones functional...
bool isMultiVersion() const
True if this function is considered a multiversioned function.
const ParmVarDecl * getParamDecl(unsigned i) const
Stmt * getBody(const FunctionDecl *&Definition) const
Retrieve the body (definition) of the function.
bool isImmediateFunction() const
unsigned getBuiltinID(bool ConsiderWrapperFunctions=false) const
Returns a value indicating whether this function corresponds to a builtin function.
bool isInlined() const
Determine whether this function should be inlined, because it is either marked "inline" or "constexpr...
bool isCPUSpecificMultiVersion() const
True if this function is a multiversioned processor specific function as a part of the cpu_specific/c...
FunctionDecl * getTemplateInstantiationPattern(bool ForDefinition=true) const
Retrieve the function declaration from which this function could be instantiated, if it is an instant...
bool isReplaceableGlobalAllocationFunction(UnsignedOrNone *AlignmentParam=nullptr, bool *IsNothrow=nullptr) const
Determines whether this function is one of the replaceable global allocation functions: void *operato...
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 * getMostRecentDecl()
Returns the most recent (re)declaration of this declaration.
redecl_range redecls() const
Returns an iterator range for all the redeclarations of the same decl.
FunctionDecl * getDefinition()
Get the definition for this declaration.
bool isTargetVersionMultiVersion() const
True if this function is a multiversioned dispatch function as a part of the target-version functiona...
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.
FunctionDecl * getPreviousDecl()
Return the previous declaration of this declaration or NULL if this is the first declaration.
MultiVersionKind getMultiVersionKind() const
Gets the kind of multiversioning attribute this declaration has.
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...
clang::ObjCRuntime ObjCRuntime
CoreFoundationABI CFRuntime
std::string CUID
The user provided compilation unit ID, if non-empty.
unsigned getOpenCLCompatibleVersion() const
Return the OpenCL version that kernel language is compatible with.
Visibility getVisibility() const
void setLinkage(Linkage L)
Linkage getLinkage() const
bool isVisibilityExplicit() const
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.
CXXCtorInitializer ** init_iterator
init_iterator - Iterates through the ivar initializer list.
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()
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?
@ MacOSX
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
@ GNUstep
'gnustep' is the modern non-fragile GNUstep runtime.
@ ObjFW
'objfw' is the Objective-C runtime included in ObjFW
@ iOS
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
@ GCC
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI
@ WatchOS
'watchos' is a variant of iOS for Apple's watchOS.
Represents a parameter to a function.
ParsedAttr - Represents a syntactic attribute.
bool isAddressDiscriminated() const
uint16_t getConstantDiscrimination() const
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
Represents an unpacked "presumed" location which can be presented to the user.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
ExclusionType getDefault(llvm::driver::ProfileInstrKind Kind) const
std::optional< ExclusionType > isFunctionExcluded(StringRef FunctionName, llvm::driver::ProfileInstrKind Kind) const
std::optional< ExclusionType > isFileExcluded(StringRef FileName, llvm::driver::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.
std::optional< ExclusionType > isLocationExcluded(SourceLocation Loc, llvm::driver::ProfileInstrKind Kind) const
A (possibly-)qualified type.
bool isVolatileQualified() const
Determine whether this type is volatile-qualified.
bool isRestrictQualified() const
Determine whether this type is restrict-qualified.
bool isNull() const
Return true if this QualType doesn't point to a type yet.
const Type * getTypePtr() const
Retrieves a pointer to the underlying (unqualified) type.
LangAS getAddressSpace() const
Return the address space of this type.
bool isConstant(const ASTContext &Ctx) const
QualType getCanonicalType() const
QualType getUnqualifiedType() const
Retrieve the unqualified variant of the given type, removing as little sugar as possible.
QualType withCVRQualifiers(unsigned CVR) const
bool isConstQualified() const
Determine whether this type is const-qualified.
bool isConstantStorage(const ASTContext &Ctx, bool ExcludeCtor, bool ExcludeDtor)
unsigned getCVRQualifiers() const
Retrieve the set of CVR (const-volatile-restrict) qualifiers applied to this type.
static std::string getAsString(SplitQualType split, const PrintingPolicy &Policy)
Represents a struct/union/class.
field_range fields() const
virtual void completeDefinition()
Note that the definition of this type is now complete.
Selector getSelector(unsigned NumArgs, const IdentifierInfo **IIV)
Can create any sort of selector.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
This class handles loading and caching of source files into memory.
A trivial tuple used to represent a source range.
Stmt - This represents one statement.
SourceRange getSourceRange() const LLVM_READONLY
SourceLocation tokens are not useful in isolation - they are low level value objects created/interpre...
SourceLocation getBeginLoc() const LLVM_READONLY
StringLiteral - This represents a string literal expression, e.g.
SourceLocation getStrTokenLoc(unsigned TokNum) const
Get one of the string literal token.
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.
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 llvm::APInt getFMVPriority(ArrayRef< StringRef > Features) const
bool supportsIFunc() const
Identify whether this target supports IFuncs.
unsigned getLongWidth() const
getLongWidth/Align - Return the size of 'signed long' and 'unsigned long' for this target,...
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 RecordType * getAsUnionType() const
NOTE: getAs*ArrayType are methods on ASTContext.
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
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.
bool isCUDADeviceBuiltinTextureType() const
Check if the type is the CUDA device builtin texture type.
bool isHLSLResourceRecord() const
bool isIncompleteType(NamedDecl **Def=nullptr) const
Types are partitioned into 3 broad categories (C99 6.2.5p1): object types, function types,...
bool isObjCObjectPointerType() const
const T * getAs() const
Member-template getAs<specific type>'.
bool isRecordType() const
bool isHLSLResourceRecordArray() 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...
bool hasConstantInitialization() const
Determine whether this variable has constant initialization.
VarDecl * getDefinition(ASTContext &)
Get the real (not just tentative) definition for this declaration.
LanguageLinkage getLanguageLinkage() const
Compute the language linkage.
QualType::DestructionKind needsDestruction(const ASTContext &Ctx) const
Would the destruction of this variable have any effect, and if so, what kind?
const Expr * getInit() const
bool hasExternalStorage() const
Returns true if a variable has extern or private_extern storage.
@ TLS_Dynamic
TLS with a dynamic initializer.
@ DeclarationOnly
This declaration is only a declaration.
@ Definition
This declaration is definitely a definition.
DefinitionKind hasDefinition(ASTContext &) const
Check whether this variable is defined in this translation unit.
TemplateSpecializationKind getTemplateSpecializationKind() const
If this variable is an instantiation of a variable template or a static data member of a class templa...
const Expr * getAnyInitializer() const
Get the initializer for this variable, no matter which declaration it is attached to.
Defines the clang::TargetInfo interface.
std::unique_ptr< TargetCodeGenInfo > createARMTargetCodeGenInfo(CodeGenModule &CGM, ARMABIKind Kind)
std::unique_ptr< TargetCodeGenInfo > createM68kTargetCodeGenInfo(CodeGenModule &CGM)
@ AttributedType
The l-value was considered opaque, so the alignment was determined from a type, but that type was an ...
@ Type
The l-value was considered opaque, so the alignment was determined from a type.
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
std::unique_ptr< TargetCodeGenInfo > createBPFTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createMSP430TargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createX86_64TargetCodeGenInfo(CodeGenModule &CGM, X86AVXABILevel AVXLevel)
std::unique_ptr< TargetCodeGenInfo > createWebAssemblyTargetCodeGenInfo(CodeGenModule &CGM, WebAssemblyABIKind K)
std::unique_ptr< TargetCodeGenInfo > createPPC64_SVR4_TargetCodeGenInfo(CodeGenModule &CGM, PPC64_SVR4_ABIKind Kind, bool SoftFloatABI)
std::unique_ptr< TargetCodeGenInfo > createMIPSTargetCodeGenInfo(CodeGenModule &CGM, bool IsOS32)
std::unique_ptr< TargetCodeGenInfo > createHexagonTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createNVPTXTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createSystemZTargetCodeGenInfo(CodeGenModule &CGM, bool HasVector, bool SoftFloatABI)
std::unique_ptr< TargetCodeGenInfo > createWinX86_32TargetCodeGenInfo(CodeGenModule &CGM, bool DarwinVectorABI, bool Win32StructABI, unsigned NumRegisterParameters)
std::unique_ptr< TargetCodeGenInfo > createAIXTargetCodeGenInfo(CodeGenModule &CGM, bool Is64Bit)
std::unique_ptr< TargetCodeGenInfo > createAMDGPUTargetCodeGenInfo(CodeGenModule &CGM)
CGObjCRuntime * CreateMacObjCRuntime(CodeGenModule &CGM)
X86AVXABILevel
The AVX ABI level for X86 targets.
std::unique_ptr< TargetCodeGenInfo > createTCETargetCodeGenInfo(CodeGenModule &CGM)
CGObjCRuntime * CreateGNUObjCRuntime(CodeGenModule &CGM)
Creates an instance of an Objective-C runtime class.
std::unique_ptr< TargetCodeGenInfo > createWindowsARMTargetCodeGenInfo(CodeGenModule &CGM, ARMABIKind K)
std::unique_ptr< TargetCodeGenInfo > createAVRTargetCodeGenInfo(CodeGenModule &CGM, unsigned NPR, unsigned NRR)
std::unique_ptr< TargetCodeGenInfo > createDirectXTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createARCTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createDefaultTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createAArch64TargetCodeGenInfo(CodeGenModule &CGM, AArch64ABIKind Kind)
std::unique_ptr< TargetCodeGenInfo > createSPIRVTargetCodeGenInfo(CodeGenModule &CGM)
std::unique_ptr< TargetCodeGenInfo > createWindowsMIPSTargetCodeGenInfo(CodeGenModule &CGM, bool IsOS32)
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 > 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)
@ OS
Indicates that the tracking object is a descendant of a referenced-counted OSObject,...
bool LT(InterpState &S, CodePtr OpPC)
llvm::PointerUnion< const Decl *, const Expr * > DeclTy
The JSON file list parser is used to communicate input to InstallAPI.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
CXXCtorType
C++ constructor types.
@ Ctor_Base
Base object ctor.
@ Ctor_Complete
Complete object ctor.
bool isa(CodeGen::Address addr)
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)
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
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...
@ Module
Module linkage, which indicates that the entity can be referred to from other translation units withi...
@ 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.
const FunctionProtoType * T
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
void EmbedObject(llvm::Module *M, const CodeGenOptions &CGOpts, llvm::vfs::FileSystem &VFS, DiagnosticsEngine &Diags)
static const char * getCFBranchLabelSchemeFlagVal(const CFBranchLabelSchemeKind Scheme)
TemplateSpecializationKind
Describes the kind of template specialization that a particular template specialization declaration r...
@ 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.
U cast(CodeGen::Address addr)
@ None
No keyword precedes the qualified type name.
@ Struct
The "struct" keyword introduces the elaborated-type-specifier.
bool isExternallyVisible(Linkage L)
@ EST_None
no exception specification
std::string getClangFullVersion()
Retrieves a string representing the complete clang version, which includes the clang version number,...
@ HiddenVisibility
Objects with "hidden" visibility are not seen by the dynamic linker.
@ DefaultVisibility
Objects with "default" visibility are seen by the dynamic linker and act like normal objects.
cl::opt< bool > SystemHeadersCoverage
int const char * function
__UINTPTR_TYPE__ uintptr_t
An unsigned integer type with the property that any valid pointer to void can be converted to this ty...
std::optional< StringRef > Architecture
llvm::SmallVector< StringRef, 8 > Features
llvm::CallingConv::ID RuntimeCC
llvm::IntegerType * Int64Ty
llvm::PointerType * ConstGlobalsPtrTy
void* in the address space for constant globals
llvm::IntegerType * Int8Ty
i8, i16, i32, and i64
llvm::IntegerType * CharTy
char
LangAS ASTAllocaAddressSpace
unsigned char PointerWidthInBits
The width of a pointer into the generic address space.
unsigned char IntAlignInBytes
llvm::Type * HalfTy
half, bfloat, float, double
unsigned char SizeSizeInBytes
llvm::CallingConv::ID getRuntimeCC() const
llvm::IntegerType * SizeTy
llvm::PointerType * GlobalsInt8PtrTy
llvm::IntegerType * Int32Ty
llvm::IntegerType * IntPtrTy
llvm::IntegerType * IntTy
int
llvm::IntegerType * Int16Ty
unsigned char PointerAlignInBytes
llvm::PointerType * Int8PtrTy
CharUnits getPointerAlign() const
llvm::PointerType * AllocaInt8PtrTy
EvalResult is a struct with detailed info about an evaluated expression.
APValue Val
Val - This is the value the expression can be folded to.
bool hasSideEffects() const
Return true if the evaluated expression has side effects.
Extra information about a function prototype.
static const LangStandard & getLangStandardForKind(Kind K)
uint16_t Part2
...-89ab-...
uint32_t Part1
{01234567-...
uint16_t Part3
...-cdef-...
uint8_t Part4And5[8]
...-0123-456789abcdef}
A library or framework to link against when an entity from this module is used.
Contains information gathered from parsing the contents of TargetAttr.
PointerAuthSchema InitFiniPointers
The ABI for function addresses in .init_array and .fini_array.
Describes how types, statements, expressions, and declarations should be printed.