Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/CodeGenModule_8cpp_source.html below:

clang: lib/CodeGen/CodeGenModule.cpp Source File

;

CodeGen;

, llvm::cl::Hidden,

llvm::cl::desc(

));

TargetCXXABI::AppleARM64:

TargetCXXABI::Fuchsia:

TargetCXXABI::GenericAArch64:

TargetCXXABI::GenericARM:

TargetCXXABI::iOS:

TargetCXXABI::WatchOS:

TargetCXXABI::GenericMIPS:

TargetCXXABI::GenericItanium:

TargetCXXABI::WebAssembly:

TargetCXXABI::XL:

TargetCXXABI::Microsoft:

llvm_unreachable(

);

std::unique_ptr<TargetCodeGenInfo>

(Triple.getArch()) {

llvm::Triple::m68k:

llvm::Triple::mips:

llvm::Triple::mipsel:

(Triple.getOS() == llvm::Triple::NaCl)

(Triple.getOS() == llvm::Triple::Win32)

llvm::Triple::mips64:

llvm::Triple::mips64el:

llvm::Triple::avr: {

NPR =

.getABI() ==

? 6 : 18;

NRR =

.getABI() ==

? 4 : 8;

llvm::Triple::aarch64:

llvm::Triple::aarch64_32:

llvm::Triple::aarch64_be: {

(

.getABI() ==

)

Kind = AArch64ABIKind::DarwinPCS;

(Triple.isOSWindows())

(

.getABI() ==

)

Kind = AArch64ABIKind::AAPCSSoft;

(

.getABI() ==

)

Kind = AArch64ABIKind::PAuthTest;

llvm::Triple::wasm32:

llvm::Triple::wasm64: {

(

.getABI() ==

)

Kind = WebAssemblyABIKind::ExperimentalMV;

llvm::Triple::arm:

llvm::Triple::armeb:

llvm::Triple::thumb:

llvm::Triple::thumbeb: {

(Triple.getOS() == llvm::Triple::Win32)

StringRef ABIStr =

.getABI();

(ABIStr ==

)

Kind = ARMABIKind::APCS;

(ABIStr ==

)

Kind = ARMABIKind::AAPCS16_VFP;

(CodeGenOpts.

==

||

(CodeGenOpts.

!=

&& Triple.isHardFloatABI()))

Kind = ARMABIKind::AAPCS_VFP;

llvm::Triple::ppc: {

(Triple.isOSAIX())

llvm::Triple::ppcle: {

IsSoftFloat = CodeGenOpts.

==

;

llvm::Triple::ppc64:

(Triple.isOSAIX())

(Triple.isOSBinFormatELF()) {

(

.getABI() ==

)

Kind = PPC64_SVR4_ABIKind::ELFv2;

IsSoftFloat = CodeGenOpts.

==

;

llvm::Triple::ppc64le: {

assert(Triple.isOSBinFormatELF() &&

);

(

.getABI() ==

)

Kind = PPC64_SVR4_ABIKind::ELFv1;

IsSoftFloat = CodeGenOpts.

==

;

llvm::Triple::nvptx:

llvm::Triple::nvptx64:

llvm::Triple::msp430:

llvm::Triple::riscv32:

llvm::Triple::riscv64: {

StringRef ABIStr =

.getABI();

XLen =

.getPointerWidth(LangAS::Default);

ABIFLen = 0;

(ABIStr.ends_with(

))

(ABIStr.ends_with(

))

EABI = ABIStr.ends_with(

);

llvm::Triple::systemz: {

SoftFloat = CodeGenOpts.

==

;

HasVector = !SoftFloat &&

.getABI() ==

;

llvm::Triple::tce:

llvm::Triple::tcele:

llvm::Triple::x86: {

IsDarwinVectorABI = Triple.isOSDarwin();

IsWin32FloatStructABI = Triple.isOSWindows() && !Triple.isOSCygMing();

(Triple.getOS() == llvm::Triple::Win32) {

CGM, IsDarwinVectorABI, IsWin32FloatStructABI,

CodeGenOpts.NumRegisterParameters);

CGM, IsDarwinVectorABI, IsWin32FloatStructABI,

CodeGenOpts.NumRegisterParameters, CodeGenOpts.

==

);

llvm::Triple::x86_64: {

StringRef ABI =

.getABI();

AVXLevel = (ABI ==

? X86AVXABILevel::AVX512

: ABI ==

? X86AVXABILevel::AVX

: X86AVXABILevel::None);

(Triple.getOS()) {

llvm::Triple::Win32:

llvm::Triple::hexagon:

llvm::Triple::lanai:

llvm::Triple::r600:

llvm::Triple::amdgcn:

llvm::Triple::sparc:

llvm::Triple::sparcv9:

llvm::Triple::xcore:

llvm::Triple::arc:

llvm::Triple::spir:

llvm::Triple::spir64:

llvm::Triple::spirv32:

llvm::Triple::spirv64:

llvm::Triple::spirv:

llvm::Triple::dxil:

llvm::Triple::ve:

llvm::Triple::csky: {

IsSoftFloat = !

.hasFeature(

);

.hasFeature(

) ||

.hasFeature(

);

llvm::Triple::bpfeb:

llvm::Triple::bpfel:

llvm::Triple::loongarch32:

llvm::Triple::loongarch64: {

StringRef ABIStr =

.getABI();

ABIFRLen = 0;

(ABIStr.ends_with(

))

(ABIStr.ends_with(

))

CGM,

.getPointerWidth(LangAS::Default), ABIFRLen);

(!TheTargetCodeGenInfo)

*TheTargetCodeGenInfo;

: Context(

), LangOpts(

.getLangOpts()), FS(FS), HeaderSearchOpts(HSO),

PreprocessorOpts(PPO), CodeGenOpts(CGO), TheModule(M), Diags(diags),

VMContext(M.getContext()), VTables(*this), StackHandler(diags),

llvm::LLVMContext &LLVMContext = M.getContext();

= llvm::Type::getVoidTy(LLVMContext);

= llvm::Type::getInt8Ty(LLVMContext);

= llvm::Type::getInt16Ty(LLVMContext);

= llvm::Type::getInt32Ty(LLVMContext);

= llvm::Type::getInt64Ty(LLVMContext);

= llvm::Type::getHalfTy(LLVMContext);

= llvm::Type::getBFloatTy(LLVMContext);

= llvm::Type::getFloatTy(LLVMContext);

= llvm::Type::getDoubleTy(LLVMContext);

.toCharUnitsFromBits(

.getTargetInfo().getMaxPointerWidth()).getQuantity();

.toCharUnitsFromBits(

.getTargetInfo().getIntAlign()).getQuantity();

llvm::IntegerType::get(LLVMContext,

.getTargetInfo().getCharWidth());

= llvm::IntegerType::get(LLVMContext,

.getTargetInfo().getIntWidth());

= llvm::IntegerType::get(LLVMContext,

.getTargetInfo().getMaxPointerWidth());

= llvm::PointerType::get(LLVMContext,

llvm::DataLayout &DL = M.getDataLayout();

llvm::PointerType::get(LLVMContext, DL.getAllocaAddrSpace());

llvm::PointerType::get(LLVMContext, DL.getDefaultGlobalsAddressSpace());

createOpenCLRuntime();

createOpenMPRuntime();

(LangOpts.

.

(SanitizerKind::Thread | SanitizerKind::Type) ||

(!CodeGenOpts.RelaxedAliasing && CodeGenOpts.OptimizationLevel > 0))

(CodeGenOpts.getDebugInfo() != llvm::codegenoptions::NoDebugInfo ||

Block.GlobalUniqueCount = 0;

(

.getLangOpts().ObjC)

ReaderOrErr = llvm::IndexedInstrProfReader::create(

PGOReader = std::move(ReaderOrErr.get());

(CodeGenOpts.CoverageMapping)

(CodeGenOpts.UniqueInternalLinkageNames &&

!

().getSourceFileName().empty()) {

(

.rfind(Entry.first, 0) != std::string::npos) {

= Entry.second +

.substr(Entry.first.size());

ModuleNameHash = llvm::getUniqueInternalLinkagePostfix(

);

().addModuleFlag(llvm::Module::Error,

,

CodeGenOpts.NumRegisterParameters);

CodeGenModule::createObjCRuntime() {

llvm_unreachable(

);

CodeGenModule::createOpenCLRuntime() {

CodeGenModule::createOpenMPRuntime() {

llvm::Triple::nvptx:

llvm::Triple::nvptx64:

llvm::Triple::amdgcn:

);

(LangOpts.OpenMPSimd)

CodeGenModule::createCUDARuntime() {

CodeGenModule::createHLSLRuntime() {

Replacements[Name] =

;

CodeGenModule::applyReplacements() {

(

&I : Replacements) {

StringRef MangledName = I.first;

llvm::Constant *Replacement = I.second;

*OldF = cast<llvm::Function>(Entry);

*NewF = dyn_cast<llvm::Function>(Replacement);

(

*Alias = dyn_cast<llvm::GlobalAlias>(Replacement)) {

NewF = dyn_cast<llvm::Function>(Alias->getAliasee());

*CE = cast<llvm::ConstantExpr>(Replacement);

assert(CE->getOpcode() == llvm::Instruction::BitCast ||

CE->getOpcode() == llvm::Instruction::GetElementPtr);

NewF = dyn_cast<llvm::Function>(CE->getOperand(0));

OldF->replaceAllUsesWith(Replacement);

NewF->removeFromParent();

OldF->getParent()->getFunctionList().insertAfter(OldF->getIterator(),

OldF->eraseFromParent();

GlobalValReplacements.push_back(std::make_pair(GV,

));

CodeGenModule::applyGlobalValReplacements() {

(

&I : GlobalValReplacements) {

llvm::GlobalValue *GV = I.first;

llvm::Constant *

= I.second;

GV->replaceAllUsesWith(

);

GV->eraseFromParent();

llvm::Constant *

;

(

*GA = dyn_cast<llvm::GlobalAlias>(GV))

= GA->getAliasee();

(

*GI = dyn_cast<llvm::GlobalIFunc>(GV))

= GI->getResolver();

*AliaseeGV = dyn_cast<llvm::GlobalValue>(

->stripPointerCasts());

llvm::GlobalValue *FinalGV = AliaseeGV->getAliaseeObject();

IsIFunc,

llvm::GlobalValue *Alias,

llvm::GlobalValue *&GV,

llvm::MapVector<GlobalDecl, StringRef> &MangledDeclNames,

Diags.

(Location, diag::err_cyclic_alias) << IsIFunc;

(GV->hasCommonLinkage()) {

(Triple.getObjectFormat() == llvm::Triple::XCOFF) {

Diags.

(Location, diag::err_alias_to_common);

(GV->isDeclaration()) {

Diags.

(Location, diag::err_alias_to_undefined) << IsIFunc << IsIFunc;

Diags.

(Location, diag::note_alias_requires_mangled_name)

<< IsIFunc << IsIFunc;

(

&[

, Name] : MangledDeclNames) {

(

*ND = dyn_cast<NamedDecl>(

.getDecl())) {

(II && II->

() == GV->getName()) {

Diags.

(Location, diag::note_alias_mangled_name_alternative)

(Twine(IsIFunc ?

:

) +

+ Name +

)

*F = dyn_cast<llvm::Function>(GV);

Diags.

(Location, diag::err_alias_to_undefined)

<< IsIFunc << IsIFunc;

llvm::FunctionType *FTy = F->getFunctionType();

(!FTy->getReturnType()->isPointerTy()) {

Diags.

(Location, diag::err_ifunc_resolver_return);

(GVar->hasAttribute(

)) {

GVId = GVar->getName();

Diags.

(Location, diag::warn_toc_unsupported_type)

<< GVId <<

;

llvm::AttributeSet CurrAttributes = GVar->getAttributes();

llvm::AttributeSet NewAttributes =

CurrAttributes.removeAttribute(GVar->getContext(),

);

GVar->setAttributes(NewAttributes);

CodeGenModule::checkAliases() {

*

= cast<ValueDecl>(GD.getDecl());

IsIFunc =

->

<IFuncAttr>();

Location = A->getLocation();

= A->getRange();

llvm_unreachable(

);

llvm::GlobalValue *GV =

;

MangledDeclNames,

)) {

(

llvm::GlobalVariable *GVar =

dyn_cast<const llvm::GlobalVariable>(GV))

llvm::Constant *Aliasee =

IsIFunc ? cast<llvm::GlobalIFunc>(Alias)->getResolver()

: cast<llvm::GlobalAlias>(Alias)->getAliasee();

llvm::GlobalValue *AliaseeGV;

(

CE = dyn_cast<llvm::ConstantExpr>(Aliasee))

AliaseeGV = cast<llvm::GlobalValue>(CE->getOperand(0));

AliaseeGV = cast<llvm::GlobalValue>(Aliasee);

(

SectionAttr *SA =

->

<SectionAttr>()) {

StringRef AliasSection = SA->getName();

(AliasSection != AliaseeGV->getSection())

Diags.

(SA->getLocation(), diag::warn_alias_with_section)

<< AliasSection << IsIFunc << IsIFunc;

(

*GA = dyn_cast<llvm::GlobalAlias>(AliaseeGV)) {

(GA->isInterposable()) {

Diags.

(Location, diag::warn_alias_to_weak_alias)

<< GV->getName() << GA->getName() << IsIFunc;

Aliasee = llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(

GA->getAliasee(), Alias->getType());

cast<llvm::GlobalIFunc>(Alias)->setResolver(Aliasee);

cast<llvm::GlobalAlias>(Alias)->setAliasee(Aliasee);

cast<llvm::Function>(Aliasee)->addFnAttr(

llvm::Attribute::DisableSanitizerInstrumentation);

Alias->replaceAllUsesWith(llvm::PoisonValue::get(Alias->getType()));

Alias->eraseFromParent();

DeferredDeclsToEmit.clear();

EmittedDeferredDecls.clear();

DeferredAnnotations.clear();

OpenMPRuntime->clear();

StringRef MainFile) {

(VisitedInMainFile > 0 && VisitedInMainFile == MissingInMainFile) {

(MainFile.empty())

MainFile =

;

Diags.

(diag::warn_profile_data_unprofiled) << MainFile;

Diags.

(diag::warn_profile_data_out_of_date) << Visited << Mismatched;

Diags.

(diag::warn_profile_data_missing) << Visited << Missing;

std::optional<llvm::GlobalValue::VisibilityTypes>

llvm::GlobalValue::DefaultVisibility;

llvm::GlobalValue::HiddenVisibility;

llvm::GlobalValue::ProtectedVisibility;

llvm_unreachable(

);

std::optional<llvm::GlobalValue::VisibilityTypes>

) {

GV.setDSOLocal(

);

GV.setVisibility(*

);

(!LO.VisibilityFromDLLStorageClass)

std::optional<llvm::GlobalValue::VisibilityTypes> DLLExportVisibility =

std::optional<llvm::GlobalValue::VisibilityTypes>

NoDLLStorageClassVisibility =

std::optional<llvm::GlobalValue::VisibilityTypes>

ExternDeclDLLImportVisibility =

std::optional<llvm::GlobalValue::VisibilityTypes>

ExternDeclNoDLLStorageClassVisibility =

(llvm::GlobalValue &GV : M.global_values()) {

(GV.hasAppendingLinkage() || GV.hasLocalLinkage())

(GV.isDeclarationForLinker())

llvm::GlobalValue::DLLImportStorageClass

? ExternDeclDLLImportVisibility

: ExternDeclNoDLLStorageClassVisibility);

llvm::GlobalValue::DLLExportStorageClass

? DLLExportVisibility

: NoDLLStorageClassVisibility);

GV.setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);

llvm::Triple &Triple,

(Triple.isAMDGPU() || Triple.isNVPTX())

LangOpts.getStackProtector() == Mode;

EmitModuleInitializers(Primary);

DeferredDecls.insert(EmittedDeferredDecls.begin(),

EmittedDeferredDecls.end());

EmittedDeferredDecls.clear();

EmitVTablesOpportunistically();

applyGlobalValReplacements();

emitMultiVersionFunctions();

(Context.

().IncrementalExtensions &&

GlobalTopLevelStmtBlockInFlight.first) {

GlobalTopLevelStmtBlockInFlight.first->FinishFunction(TLSD->

());

GlobalTopLevelStmtBlockInFlight = {

,

};

EmitCXXModuleInitFunc(Primary);

EmitCXXGlobalInitFunc();

EmitCXXGlobalCleanUpFunc();

registerGlobalDtorsWithAtExit();

EmitCXXThreadLocalInitFunc();

(llvm::Function *ObjCInitFunction =

->ModuleInitFunction())

(llvm::Function *CudaCtorFunction = CUDARuntime->finalizeModule())

OpenMPRuntime->createOffloadEntriesAndInfoMetadata();

OpenMPRuntime->clear();

PGOReader->getSummary(

).getMD(VMContext),

llvm::ProfileSummary::PSK_Instr);

EmitCtorList(GlobalCtors,

);

EmitCtorList(GlobalDtors,

);

EmitStaticExternCAliases();

CoverageMapping->emit();

(CodeGenOpts.SanitizeCfiCrossDso) {

(LangOpts.

.

(SanitizerKind::KCFI))

emitAtAvailableLinkGuard();

(

().getTargetOpts().CodeObjectVersion !=

llvm::CodeObjectVersionKind::COV_None) {

().addModuleFlag(llvm::Module::Error,

,

().getTargetOpts().CodeObjectVersion);

*MDStr = llvm::MDString::get(

().addModuleFlag(llvm::Module::Error,

,

(

*FD = dyn_cast<FunctionDecl>(

))

UsedArray.push_back(llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(

llvm::ArrayType *ATy = llvm::ArrayType::get(

, UsedArray.size());

*GV =

llvm::GlobalVariable(

(), ATy,

, llvm::GlobalValue::InternalLinkage,

llvm::ConstantArray::get(ATy, UsedArray),

);

(LangOpts.HIP && !

().OffloadingNewDriver) {

*GV =

llvm::GlobalVariable(

llvm::Constant::getNullValue(

),

(CodeGenOpts.Autolink &&

(Context.

().Modules || !LinkerOptionsMetadata.empty())) {

EmitModuleLinkOptions();

(!ELFDependentLibraries.empty() && !Context.

().CUDAIsDevice) {

*NMD =

().getOrInsertNamedMetadata(

);

(

*MD : ELFDependentLibraries)

(CodeGenOpts.DwarfVersion) {

().addModuleFlag(llvm::Module::Max,

,

CodeGenOpts.DwarfVersion);

(CodeGenOpts.Dwarf64)

().addModuleFlag(llvm::Module::Max,

, 1);

(Context.

().SemanticInterposition)

().setSemanticInterposition(

);

(CodeGenOpts.EmitCodeView) {

().addModuleFlag(llvm::Module::Warning,

, 1);

(CodeGenOpts.CodeViewGHash) {

().addModuleFlag(llvm::Module::Warning,

, 1);

(CodeGenOpts.ControlFlowGuard) {

().addModuleFlag(llvm::Module::Warning,

, 2);

}

(CodeGenOpts.ControlFlowGuardNoChecks) {

().addModuleFlag(llvm::Module::Warning,

, 1);

(CodeGenOpts.EHContGuard) {

().addModuleFlag(llvm::Module::Warning,

, 1);

().addModuleFlag(llvm::Module::Warning,

, 1);

(CodeGenOpts.OptimizationLevel > 0 && CodeGenOpts.StrictVTablePointers) {

().addModuleFlag(llvm::Module::Error,

,1);

llvm::Metadata *Ops[2] = {

llvm::MDString::get(VMContext,

),

llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(

llvm::Type::getInt32Ty(VMContext), 1))};

().addModuleFlag(llvm::Module::Require,

,

llvm::MDNode::get(VMContext, Ops));

().addModuleFlag(llvm::Module::Warning,

,

llvm::DEBUG_METADATA_VERSION);

uint64_t WCharWidth =

().addModuleFlag(llvm::Module::Error,

, WCharWidth);

().addModuleFlag(llvm::Module::Warning,

,

uint32_t(CLANG_VERSION_MAJOR));

().addModuleFlag(llvm::Module::Warning,

,

uint32_t(CLANG_VERSION_MINOR));

().addModuleFlag(llvm::Module::Warning,

,

uint32_t(CLANG_VERSION_PATCHLEVEL));

().addModuleFlag(llvm::Module::Error,

,

llvm::MDString::get(VMContext, ProductId));

().addModuleFlag(llvm::Module::Error,

,

llvm::MDString::get(VMContext, lang_str));

: std::time(

);

().addModuleFlag(llvm::Module::Max,

,

uint64_t

(TT));

().addModuleFlag(llvm::Module::Error,

,

llvm::MDString::get(VMContext,

));

(

.isARM() ||

.isThumb()) {

uint64_t EnumWidth = Context.

().ShortEnums ? 1 : 4;

().addModuleFlag(llvm::Module::Error,

, EnumWidth);

(

.isRISCV()) {

StringRef ABIStr =

.getABI();

llvm::LLVMContext &Ctx = TheModule.getContext();

().addModuleFlag(llvm::Module::Error,

,

llvm::MDString::get(Ctx, ABIStr));

std::vector<std::string> &Features =

llvm::RISCVISAInfo::parseFeatures(

.isRISCV64() ? 64 : 32, Features);

(!errorToBool(ParseResult.takeError()))

llvm::Module::AppendUnique,

,

Ctx, llvm::MDString::get(Ctx, (*ParseResult)->toString())));

(CodeGenOpts.SanitizeCfiCrossDso) {

().addModuleFlag(llvm::Module::Override,

, 1);

(CodeGenOpts.WholeProgramVTables) {

().addModuleFlag(llvm::Module::Error,

,

CodeGenOpts.VirtualFunctionElimination);

(LangOpts.

.

(SanitizerKind::CFIICall)) {

().addModuleFlag(llvm::Module::Override,

,

CodeGenOpts.SanitizeCfiCanonicalJumpTables);

(CodeGenOpts.SanitizeCfiICallNormalizeIntegers) {

().addModuleFlag(llvm::Module::Override,

,

(LangOpts.

.

(SanitizerKind::KCFI)) {

().addModuleFlag(llvm::Module::Override,

, 1);

(CodeGenOpts.PatchableFunctionEntryOffset)

().addModuleFlag(llvm::Module::Override,

,

CodeGenOpts.PatchableFunctionEntryOffset);

(CodeGenOpts.CFProtectionReturn &&

().addModuleFlag(llvm::Module::Min,

,

(CodeGenOpts.CFProtectionBranch &&

().addModuleFlag(llvm::Module::Min,

,

Scheme = CodeGenOpts.getCFBranchLabelScheme();

(

.checkCFBranchLabelSchemeSupported(Scheme,

())) {

Scheme =

.getDefaultCFBranchLabelScheme();

llvm::Module::Error,

,

(CodeGenOpts.FunctionReturnThunks)

().addModuleFlag(llvm::Module::Override,

, 1);

(CodeGenOpts.IndirectBranchCSPrefix)

().addModuleFlag(llvm::Module::Override,

, 1);

LangOpts.getSignReturnAddressScope() !=

().addModuleFlag(llvm::Module::Override,

, 1);

(LangOpts.

.

(SanitizerKind::MemtagStack))

().addModuleFlag(llvm::Module::Override,

, 1);

(

.isARM() ||

.isThumb() ||

.isAArch64()) {

(LangOpts.BranchTargetEnforcement)

().addModuleFlag(llvm::Module::Min,

,

(LangOpts.BranchProtectionPAuthLR)

().addModuleFlag(llvm::Module::Min,

,

(LangOpts.GuardedControlStack)

().addModuleFlag(llvm::Module::Min,

, 1);

().addModuleFlag(llvm::Module::Min,

, 1);

().addModuleFlag(llvm::Module::Min,

,

().addModuleFlag(llvm::Module::Min,

, 1);

(LangOpts.PointerAuthELFGOT)

().addModuleFlag(llvm::Module::Min,

, 1);

(LangOpts.PointerAuthCalls)

().addModuleFlag(llvm::Module::Min,

,

assert(

().isOSBinFormatELF());

llvm::ELF;

uint64_t PAuthABIVersion =

(LangOpts.PointerAuthIntrinsics

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INTRINSICS) |

(LangOpts.PointerAuthCalls

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_CALLS) |

(LangOpts.PointerAuthReturns

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_RETURNS) |

(LangOpts.PointerAuthAuthTraps

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_AUTHTRAPS) |

(LangOpts.PointerAuthVTPtrAddressDiscrimination

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRADDRDISCR) |

(LangOpts.PointerAuthVTPtrTypeDiscrimination

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_VPTRTYPEDISCR) |

(LangOpts.PointerAuthInitFini

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINI) |

(LangOpts.PointerAuthInitFiniAddressDiscrimination

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_INITFINIADDRDISC) |

(LangOpts.PointerAuthELFGOT

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_GOT) |

(LangOpts.PointerAuthIndirectGotos

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_GOTOS) |

(LangOpts.PointerAuthTypeInfoVTPtrDiscrimination

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_TYPEINFOVPTRDISCR) |

(LangOpts.PointerAuthFunctionTypeDiscrimination

<< AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_FPTRTYPEDISCR);

(AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_FPTRTYPEDISCR ==

AARCH64_PAUTH_PLATFORM_LLVM_LINUX_VERSION_LAST,

);

(PAuthABIVersion != 0) {

().addModuleFlag(llvm::Module::Error,

,

AARCH64_PAUTH_PLATFORM_LLVM_LINUX);

().addModuleFlag(llvm::Module::Error,

,

(CodeGenOpts.StackClashProtector)

llvm::Module::Override,

,

llvm::MDString::get(TheModule.getContext(),

));

(CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)

().addModuleFlag(llvm::Module::Min,

,

CodeGenOpts.StackProbeSize);

llvm::LLVMContext &Ctx = TheModule.getContext();

llvm::Module::Error,

,

(LangOpts.CUDAIsDevice &&

().isNVPTX()) {

().addModuleFlag(llvm::Module::Override,

,

llvm::DenormalMode::IEEE);

(LangOpts.EHAsynch)

().addModuleFlag(llvm::Module::Warning,

, 1);

(CodeGenOpts.ImportCallOptimization)

().addModuleFlag(llvm::Module::Warning,

,

().addModuleFlag(llvm::Module::Max,

, LangOpts.OpenMP);

().addModuleFlag(llvm::Module::Max,

,

(LangOpts.OpenCL || (LangOpts.CUDAIsDevice &&

().isSPIRV())) {

EmitOpenCLMetadata();

llvm::Metadata *SPIRVerElts[] = {

llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(

llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(

, (Version / 100 > 1) ? 0 : 2))};

llvm::NamedMDNode *SPIRVerMD =

TheModule.getOrInsertNamedMetadata(

);

llvm::LLVMContext &Ctx = TheModule.getContext();

SPIRVerMD->addOperand(llvm::MDNode::get(Ctx, SPIRVerElts));

(uint32_t PLevel = Context.

().PICLevel) {

assert(PLevel < 3 &&

);

().setPICLevel(

llvm::PICLevel::Level

(PLevel));

().setPIELevel(

llvm::PIELevel::Level

(PLevel));

CM = llvm::StringSwitch<unsigned>(

().CodeModel)

.Case(

, llvm::CodeModel::Tiny)

.Case(

, llvm::CodeModel::Small)

.Case(

, llvm::CodeModel::Kernel)

.Case(

, llvm::CodeModel::Medium)

.Case(

, llvm::CodeModel::Large)

llvm::CodeModel::Model codeModel =

llvm::CodeModel::Model

(CM);

((CM == llvm::CodeModel::Medium || CM == llvm::CodeModel::Large) &&

llvm::Triple::x86_64) {

(CodeGenOpts.NoPLT)

CodeGenOpts.DirectAccessExternalData !=

().getDirectAccessExternalData()) {

().setDirectAccessExternalData(

CodeGenOpts.DirectAccessExternalData);

(CodeGenOpts.UnwindTables)

().setUwtable(llvm::UWTableKind(CodeGenOpts.UnwindTables));

(CodeGenOpts.getFramePointer()) {

().setFramePointer(llvm::FramePointerKind::Reserved);

().setFramePointer(llvm::FramePointerKind::NonLeaf);

().setFramePointer(llvm::FramePointerKind::All);

SimplifyPersonality();

EmitVersionIdentMetadata();

EmitCommandLineMetadata();

().setStackProtectorGuardSymbol(

().setStackProtectorGuardOffset(

().addModuleFlag(llvm::Module::Override,

, 1);

().addModuleFlag(llvm::Module::Override,

, 1);

(

().getTargetInfo().getMaxTLSAlign())

().addModuleFlag(llvm::Module::Error,

,

().getTargetInfo().getMaxTLSAlign());

(

().isPPC() && !MustTailCallUndefinedGlobals.empty()) {

(

&I : MustTailCallUndefinedGlobals) {

(!I.first->isDefined())

().

(I.second, diag::err_ppc_impossible_musttail) << 2;

(!Entry || Entry->isWeakForLinker() ||

Entry->isDeclarationForLinker())

().

(I.second, diag::err_ppc_impossible_musttail) << 2;

CodeGenModule::EmitOpenCLMetadata() {

EmitVersion = [

](StringRef MDName,

Version) {

llvm::Metadata *OCLVerElts[] = {

llvm::ConstantAsMetadata::get(

llvm::ConstantInt::get(

, Version / 100)),

llvm::ConstantAsMetadata::get(

llvm::ConstantInt::get(

, (Version % 100) / 10))};

llvm::NamedMDNode *OCLVerMD = TheModule.getOrInsertNamedMetadata(MDName);

llvm::LLVMContext &Ctx = TheModule.getContext();

OCLVerMD->addOperand(llvm::MDNode::get(Ctx, OCLVerElts));

EmitVersion(

, CLVersion);

(LangOpts.OpenCLCPlusPlus) {

EmitVersion(

, LangOpts.OpenCLCPlusPlusVersion);

CodeGenModule::EmitBackendOptionsMetadata(

().addModuleFlag(llvm::Module::Min,

,

CodeGenOpts.SmallDataLimit);

TBAA->getTypeInfo(QTy);

TBAA->getAccessInfo(AccessType);

TBAA->getVTablePtrAccessInfo(VTablePtrType);

TBAA->getTBAAStructInfo(QTy);

TBAA->getBaseTypeInfo(QTy);

TBAA->getAccessTagInfo(Info);

TBAA->mergeTBAAInfoForCast(SourceInfo,

);

TBAA->mergeTBAAInfoForConditionalOperator(InfoA, InfoB);

TBAA->mergeTBAAInfoForConditionalOperator(DestInfo, SrcInfo);

Inst->setMetadata(llvm::LLVMContext::MD_tbaa, Tag);

I->setMetadata(llvm::LLVMContext::MD_invariant_group,

);

std::string Msg =

;

<< Msg << S->getSourceRange();

);

std::string Msg =

;

llvm::function_ref<

()> Fn) {

(GV->hasLocalLinkage()) {

GV->setVisibility(llvm::GlobalValue::DefaultVisibility);

Context.

().OpenMPIsTargetDevice && isa<VarDecl>(

) &&

->

<OMPDeclareTargetDeclAttr>() &&

->

<OMPDeclareTargetDeclAttr>()->getDevType() !=

OMPDeclareTargetDeclAttr::DT_NoHost &&

GV->setVisibility(llvm::GlobalValue::ProtectedVisibility);

(GV->hasDLLExportStorageClass() || GV->hasDLLImportStorageClass()) {

(GV->hasDLLExportStorageClass()) {

diag::err_hidden_visibility_dllexport);

diag::err_non_default_visibility_dllimport);

!GV->isDeclarationForLinker())

llvm::GlobalValue *GV) {

(GV->hasLocalLinkage())

(!GV->hasDefaultVisibility() && !GV->hasExternalWeakLinkage())

(GV->hasDLLImportStorageClass())

llvm::Triple &TT = CGM.

();

(TT.isWindowsGNUEnvironment()) {

(GV->isDeclarationForLinker() && isa<llvm::GlobalVariable>(GV) &&

(TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage())

(TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))

(!TT.isOSBinFormatELF())

(RM != llvm::Reloc::Static && !LOpts.PIE) {

(!(isa<llvm::Function>(GV) && GV->canBenefitFromLocalAlias()))

!(CGM.

().SemanticInterposition ||

(!GV->isDeclarationForLinker())

(RM == llvm::Reloc::PIC_ && GV->hasExternalWeakLinkage())

(CGOpts.DirectAccessExternalData) {

(

*Var = dyn_cast<llvm::GlobalVariable>(GV))

(!Var->isThreadLocal())

(isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)

*

= dyn_cast<NamedDecl>(GD.

());

(

*Dtor = dyn_cast_or_null<CXXDestructorDecl>(

)) {

(

&&

->isExternallyVisible()) {

(

->

<DLLImportAttr>())

GV->setDLLStorageClass(llvm::GlobalVariable::DLLImportStorageClass);

((

->

<DLLExportAttr>() ||

!GV->isDeclarationForLinker())

GV->setDLLStorageClass(llvm::GlobalVariable::DLLExportStorageClass);

llvm::StringSwitch<llvm::GlobalVariable::ThreadLocalMode>(S)

.Case(

, llvm::GlobalVariable::GeneralDynamicTLSModel)

.Case(

, llvm::GlobalVariable::LocalDynamicTLSModel)

.Case(

, llvm::GlobalVariable::InitialExecTLSModel)

.Case(

, llvm::GlobalVariable::LocalExecTLSModel);

llvm::GlobalVariable::ThreadLocalMode

(CodeGenOpts.getDefaultTLSModel()) {

llvm::GlobalVariable::GeneralDynamicTLSModel;

llvm::GlobalVariable::LocalDynamicTLSModel;

llvm::GlobalVariable::InitialExecTLSModel;

llvm::GlobalVariable::LocalExecTLSModel;

llvm_unreachable(

);

assert(

.getTLSKind() &&

);

llvm::GlobalValue::ThreadLocalMode TLM;

(

TLSModelAttr *

=

.

<TLSModelAttr>()) {

GV->setThreadLocalMode(TLM);

(Twine(

) + Twine(

.CPUSpecificManglingCharacter(Name))).str();

CPUSpecificAttr *

,

Out <<

;

OmitMultiVersionMangling =

) {

llvm::raw_svector_ostream Out(Buffer);

assert(II &&

);

*FD = dyn_cast<FunctionDecl>(ND);

Out <<

<< II->

();

Out <<

<< II->

();

}

(FD && FD->hasAttr<CUDAGlobalAttr>() &&

Out <<

<< II->

();

);

(

*FD = dyn_cast<FunctionDecl>(ND))

(FD->isMultiVersion() && !OmitMultiVersionMangling) {

(FD->getMultiVersionKind()) {

FD->getAttr<CPUSpecificAttr>(),

*

= FD->getAttr<TargetAttr>();

assert(

&&

);

*

= FD->getAttr<TargetVersionAttr>();

assert(

&&

);

*

= FD->getAttr<TargetClonesAttr>();

assert(

&&

);

llvm_unreachable(

);

std::string(Out.str());

CodeGenModule::UpdateMultiVersionNames(

GD,

StringRef &CurName) {

std::string NonTargetName =

);

(OtherName != NonTargetName) {

ExistingRecord = Manglings.find(NonTargetName);

(ExistingRecord != std::end(Manglings))

Manglings.remove(&(*ExistingRecord));

= Manglings.insert(std::make_pair(OtherName, OtherGD));

CurName = OtherNameRef;

Entry->setName(OtherName);

(

*CD = dyn_cast<CXXConstructorDecl>(CanonicalGD.

())) {

FoundName = MangledDeclNames.find(CanonicalGD);

(FoundName != MangledDeclNames.end())

FoundName->second;

*ND = cast<NamedDecl>(GD.

());

assert(!isa<FunctionDecl>(ND) || !ND->hasAttr<CUDAGlobalAttr>() ||

= Manglings.insert(std::make_pair(MangledName, GD));

MangledDeclNames[CanonicalGD] =

.first->first();

llvm::raw_svector_ostream Out(Buffer);

dyn_cast_or_null<VarDecl>(initializedGlobalDecl.

()), Out);

(

*CD = dyn_cast<CXXConstructorDecl>(

))

(

*DD = dyn_cast<CXXDestructorDecl>(

))

MangleCtx.

(cast<DeclContext>(

), BD, Out);

= Manglings.insert(std::make_pair(Out.str(), BD));

.first->first();

it = MangledDeclNames.begin();

(it != MangledDeclNames.end()) {

(it->second == Name)

().getNamedValue(Name);

llvm::Constant *AssociatedData) {

GlobalCtors.push_back(

(

, LexOrder, Ctor, AssociatedData));

IsDtorAttrFunc) {

(CodeGenOpts.RegisterGlobalDtorsWithAtExit &&

DtorsUsingAtExit[

].push_back(Dtor);

CodeGenModule::EmitCtorList(CtorList &Fns,

*GlobalName) {

(Fns.empty())

;

llvm::PointerType *PtrTy = llvm::PointerType::get(

(), TheModule.getDataLayout().getProgramAddressSpace());

llvm::StructType *CtorStructTy = llvm::StructType::get(

, PtrTy, PtrTy);

Ctors = Builder.beginArray(CtorStructTy);

(

&I : Fns) {

Ctor = Ctors.beginStruct(CtorStructTy);

Ctor.addInt(

, I.Priority);

(InitFiniAuthSchema) {

llvm::Constant *StorageAddress =

? llvm::ConstantExpr::getIntToPtr(

llvm::ConstantInt::get(

llvm::ConstantPtrAuth::AddrDiscriminator_CtorsDtors),

I.Initializer, InitFiniAuthSchema.

(), StorageAddress,

llvm::ConstantInt::get(

Ctor.add(SignedCtorPtr);

Ctor.add(I.Initializer);

(I.AssociatedData)

Ctor.add(I.AssociatedData);

Ctor.addNullPointer(PtrTy);

Ctor.finishAndAddTo(Ctors);

List = Ctors.finishAndCreateGlobal(GlobalName,

(),

llvm::GlobalValue::AppendingLinkage);

List->setAlignment(std::nullopt);

llvm::GlobalValue::LinkageTypes

*

= cast<FunctionDecl>(GD.

());

(

*Dtor = dyn_cast<CXXDestructorDecl>(

))

llvm::MDString *MDS = dyn_cast<llvm::MDString>(MD);

(!MDS)

;

llvm::ConstantInt::get(

, llvm::MD5Hash(MDS->getString()));

FnType->getReturnType(), FnType->getParamTypes(),

FnType->getExtProtoInfo().withExceptionSpec(

));

std::string OutName;

llvm::raw_string_ostream Out(OutName);

Out <<

;

llvm::ConstantInt::get(

,

uint32_t

(llvm::xxHash64(OutName)));

llvm::Function *F,

IsThunk) {

llvm::AttributeList PAL;

(

== llvm::CallingConv::X86_VectorCall &&

Error(

,

);

F->setAttributes(PAL);

F->setCallingConv(

llvm::CallingConv::ID

(

));

std::string ReadOnlyQual(

);

std::string::size_type ReadOnlyPos = TyName.find(ReadOnlyQual);

(ReadOnlyPos != std::string::npos)

TyName.erase(ReadOnlyPos, ReadOnlyQual.size() + 1);

std::string WriteOnlyQual(

);

std::string::size_type WriteOnlyPos = TyName.find(WriteOnlyQual);

(WriteOnlyPos != std::string::npos)

TyName.erase(WriteOnlyPos, WriteOnlyQual.size() + 1);

std::string ReadWriteQual(

);

std::string::size_type ReadWritePos = TyName.find(ReadWriteQual);

(ReadWritePos != std::string::npos)

TyName.erase(ReadWritePos, ReadWriteQual.size() + 1);

assert(((FD && CGF) || (!FD && !CGF)) &&

);

(

i = 0, e = FD->

(); i != e; ++i) {

argNames.push_back(llvm::MDString::get(VMContext, parm->

()));

std::string typeQuals;

*PDecl = parm;

PDecl = TD->getDecl();

OpenCLAccessAttr *A = PDecl->

<OpenCLAccessAttr>();

(A && A->isWriteOnly())

accessQuals.push_back(llvm::MDString::get(VMContext,

));

(A && A->isReadWrite())

accessQuals.push_back(llvm::MDString::get(VMContext,

));

accessQuals.push_back(llvm::MDString::get(VMContext,

));

accessQuals.push_back(llvm::MDString::get(VMContext,

));

getTypeSpelling = [&](

Ty) {

typeName = Ty.getUnqualifiedType().getAsString(Policy);

(Ty.isCanonical()) {

StringRef typeNameRef = typeName;

(typeNameRef.consume_front(

))

std::string(

) + typeNameRef.str();

(typeNameRef.consume_front(

))

typeNameRef.str();

addressQuals.push_back(

llvm::ConstantAsMetadata::get(CGF->

.getInt32(

std::string typeName = getTypeSpelling(pointeeTy) +

;

std::string baseTypeName =

argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));

argBaseTypeNames.push_back(

llvm::MDString::get(VMContext, baseTypeName));

typeQuals =

;

typeQuals += typeQuals.empty() ?

:

;

typeQuals += typeQuals.empty() ?

:

;

uint32_t AddrSpc = 0;

addressQuals.push_back(

llvm::ConstantAsMetadata::get(CGF->

.getInt32(AddrSpc)));

std::string typeName = getTypeSpelling(ty);

argTypeNames.push_back(llvm::MDString::get(VMContext, typeName));

argBaseTypeNames.push_back(

llvm::MDString::get(VMContext, baseTypeName));

typeQuals =

;

argTypeQuals.push_back(llvm::MDString::get(VMContext, typeQuals));

Fn->setMetadata(

,

llvm::MDNode::get(VMContext, addressQuals));

Fn->setMetadata(

,

llvm::MDNode::get(VMContext, accessQuals));

Fn->setMetadata(

,

llvm::MDNode::get(VMContext, argTypeNames));

Fn->setMetadata(

,

llvm::MDNode::get(VMContext, argBaseTypeNames));

Fn->setMetadata(

,

llvm::MDNode::get(VMContext, argTypeQuals));

Fn->setMetadata(

,

llvm::MDNode::get(VMContext, argNames));

(!LangOpts.Exceptions)

;

(LangOpts.CXXExceptions)

;

(LangOpts.ObjCExceptions) {

!isa<CXXConstructorDecl, CXXDestructorDecl>(MD);

llvm::SetVector<const CXXRecordDecl *> MostBases;

std::function<void (

*)> CollectMostBases;

MostBases.insert(RD);

CollectMostBases(B.getType()->getAsCXXRecordDecl());

CollectMostBases(RD);

MostBases.takeVector();

llvm::Function *F) {

llvm::AttrBuilder B(F->getContext());

((!

|| !

->

<NoUwtableAttr>()) && CodeGenOpts.UnwindTables)

B.addUWTableAttr(llvm::UWTableKind(CodeGenOpts.UnwindTables));

(CodeGenOpts.StackClashProtector)

B.addAttribute(

,

);

(CodeGenOpts.StackProbeSize && CodeGenOpts.StackProbeSize != 4096)

B.addAttribute(

,

std::to_string(CodeGenOpts.StackProbeSize));

B.addAttribute(llvm::Attribute::NoUnwind);

(

&&

->

<NoStackProtectorAttr>())

(

&&

->

<StrictGuardStackCheckAttr>() &&

B.addAttribute(llvm::Attribute::StackProtectStrong);

B.addAttribute(llvm::Attribute::StackProtect);

B.addAttribute(llvm::Attribute::StackProtectStrong);

B.addAttribute(llvm::Attribute::StackProtectReq);

(

().

&& !F->hasFnAttribute(llvm::Attribute::NoInline))

B.addAttribute(llvm::Attribute::AlwaysInline);

(!F->hasFnAttribute(llvm::Attribute::AlwaysInline) &&

B.addAttribute(llvm::Attribute::NoInline);

(

->

<ArmLocallyStreamingAttr>())

B.addAttribute(

);

(

->isNewZA())

B.addAttribute(

);

(

->isNewZT0())

B.addAttribute(

);

ShouldAddOptNone =

!CodeGenOpts.DisableO0ImplyOptNone && CodeGenOpts.OptimizationLevel == 0;

ShouldAddOptNone &= !

->

<MinSizeAttr>();

ShouldAddOptNone &= !

->

<AlwaysInlineAttr>();

(

().HLSL && !F->hasFnAttribute(llvm::Attribute::NoInline) &&

B.addAttribute(llvm::Attribute::AlwaysInline);

}

((ShouldAddOptNone ||

->

<OptimizeNoneAttr>()) &&

!F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {

B.addAttribute(llvm::Attribute::OptimizeNone);

B.addAttribute(llvm::Attribute::NoInline);

B.addAttribute(llvm::Attribute::Naked);

F->removeFnAttr(llvm::Attribute::OptimizeForSize);

F->removeFnAttr(llvm::Attribute::MinSize);

}

(

->

<NakedAttr>()) {

B.addAttribute(llvm::Attribute::Naked);

B.addAttribute(llvm::Attribute::NoInline);

}

(

->

<NoDuplicateAttr>()) {

B.addAttribute(llvm::Attribute::NoDuplicate);

}

(

->

<NoInlineAttr>() &&

!F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {

B.addAttribute(llvm::Attribute::NoInline);

}

(

->

<AlwaysInlineAttr>() &&

!F->hasFnAttribute(llvm::Attribute::NoInline)) {

B.addAttribute(llvm::Attribute::AlwaysInline);

(!F->hasFnAttribute(llvm::Attribute::AlwaysInline))

B.addAttribute(llvm::Attribute::NoInline);

(

*FD = dyn_cast<FunctionDecl>(

)) {

CheckRedeclForInline = [](

*Redecl) {

Redecl->isInlineSpecified();

(any_of(FD->

(), CheckRedeclForInline))

any_of(Pattern->

(), CheckRedeclForInline);

(CheckForInline(FD)) {

B.addAttribute(llvm::Attribute::InlineHint);

}

(CodeGenOpts.getInlining() ==

!F->hasFnAttribute(llvm::Attribute::AlwaysInline)) {

B.addAttribute(llvm::Attribute::NoInline);

(!

->

<OptimizeNoneAttr>()) {

(!ShouldAddOptNone)

B.addAttribute(llvm::Attribute::OptimizeForSize);

B.addAttribute(llvm::Attribute::Cold);

B.addAttribute(llvm::Attribute::Hot);

B.addAttribute(llvm::Attribute::MinSize);

F->setAlignment(llvm::Align(alignment));

(!

->

<AlignedAttr>())

(LangOpts.FunctionAlignment)

F->setAlignment(llvm::Align(1ull << LangOpts.FunctionAlignment));

(isa<CXXMethodDecl>(

) && F->getPointerAlignment(

()) < 2)

F->setAlignment(std::max(llvm::Align(2), F->getAlign().valueOrOne()));

(CodeGenOpts.SanitizeCfiCrossDso &&

CodeGenOpts.SanitizeCfiCanonicalJumpTables) {

(

*FD = dyn_cast<FunctionDecl>(

)) {

*MD = dyn_cast<CXXMethodDecl>(

);

llvm::Metadata *

=

F->addTypeMetadata(0,

);

(isa_and_nonnull<NamedDecl>(

))

GV->setVisibility(llvm::GlobalValue::DefaultVisibility);

(

*VD = dyn_cast_if_present<VarDecl>(

);

((CodeGenOpts.KeepPersistentStorageVariables &&

(VD->getStorageDuration() ==

||

VD->getStorageDuration() ==

)) ||

(CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==

&&

VD->getType().isConstQualified())))

CodeGenModule::GetCPUAndFeaturesAttributes(

GD,

llvm::AttrBuilder &Attrs,

SetTargetFeatures) {

std::vector<std::string> Features;

*FD = dyn_cast_or_null<FunctionDecl>(GD.

());

*TD = FD ? FD->

<TargetAttr>() :

;

*TV = FD ? FD->

<TargetVersionAttr>() :

;

assert((!TD || !TV) &&

);

*SD = FD ? FD->

<CPUSpecificAttr>() :

;

*TC = FD ? FD->

<TargetClonesAttr>() :

;

AddedAttr =

;

(TD || TV || SD || TC) {

llvm::StringMap<bool> FeatureMap;

(

llvm::StringMap<bool>::value_type &Entry : FeatureMap)

Features.push_back((Entry.getValue() ?

:

) + Entry.getKey().str());

.parseTargetAttr(TD->getFeaturesStr());

(!TargetCPU.empty()) {

Attrs.addAttribute(

, TargetCPU);

(!TuneCPU.empty()) {

Attrs.addAttribute(

, TuneCPU);

(!Features.empty() && SetTargetFeatures) {

llvm::erase_if(Features, [&](

std::string& F) {

llvm::sort(Features);

Attrs.addAttribute(

, llvm::join(Features,

));

IsDefault =

;

IsDefault = TV->isDefaultVersion();

TV->getFeatures(Feats);

Attrs.addAttribute(

);

}

(!Feats.empty()) {

std::set<StringRef> OrderedFeats(Feats.begin(), Feats.end());

std::string FMVFeatures;

(StringRef F : OrderedFeats)

FMVFeatures.append(

+ F.str());

Attrs.addAttribute(

, FMVFeatures.substr(1));

CodeGenModule::setNonAliasAttributes(

GD,

llvm::GlobalObject *GO) {

(

*GV = dyn_cast<llvm::GlobalVariable>(GO)) {

(

*SA =

->

<PragmaClangBSSSectionAttr>())

GV->addAttribute(

, SA->getName());

(

*SA =

->

<PragmaClangDataSectionAttr>())

GV->addAttribute(

, SA->getName());

(

*SA =

->

<PragmaClangRodataSectionAttr>())

GV->addAttribute(

, SA->getName());

(

*SA =

->

<PragmaClangRelroSectionAttr>())

GV->addAttribute(

, SA->getName());

(

*F = dyn_cast<llvm::Function>(GO)) {

(

*SA =

->

<PragmaClangTextSectionAttr>())

(!

->

<SectionAttr>())

F->setSection(SA->getName());

llvm::AttrBuilder Attrs(F->getContext());

(GetCPUAndFeaturesAttributes(GD, Attrs)) {

llvm::AttributeMask RemoveAttrs;

RemoveAttrs.addAttribute(

);

RemoveAttrs.addAttribute(

);

RemoveAttrs.addAttribute(

);

RemoveAttrs.addAttribute(

);

F->removeFnAttrs(RemoveAttrs);

F->addFnAttrs(Attrs);

(

*CSA =

->

<CodeSegAttr>())

GO->setSection(CSA->getName());

(

*SA =

->

<SectionAttr>())

GO->setSection(SA->getName());

F->setLinkage(llvm::Function::InternalLinkage);

setNonAliasAttributes(GD, F);

GV->

(llvm::GlobalValue::ExternalWeakLinkage);

llvm::Function *F) {

(!LangOpts.

.

(SanitizerKind::CFIICall))

(isa<CXXMethodDecl>(FD) && !cast<CXXMethodDecl>(FD)->isStatic())

F->addTypeMetadata(0, MD);

(CodeGenOpts.SanitizeCfiCrossDso)

F->addTypeMetadata(0, llvm::ConstantAsMetadata::get(CrossDsoTypeId));

llvm::LLVMContext &Ctx = F->getContext();

llvm::MDBuilder MDB(Ctx);

F->setMetadata(llvm::LLVMContext::MD_kcfi_type,

llvm::all_of(Name, [](

&

) {

llvm::isAlnum(

) ||

==

||

==

;

(

&F : M.functions()) {

AddressTaken = F.hasAddressTaken();

(!AddressTaken && F.hasLocalLinkage())

F.eraseMetadata(llvm::LLVMContext::MD_kcfi_type);

(!AddressTaken || !F.isDeclaration())

llvm::ConstantInt *

;

(

llvm::MDNode *MD = F.getMetadata(llvm::LLVMContext::MD_kcfi_type))

= llvm::mdconst::extract<llvm::ConstantInt>(MD->getOperand(0));

StringRef Name = F.getName();

std::string

= (

+ Name +

+

Name +

+ Twine(

->getZExtValue()) +

)

M.appendModuleInlineAsm(

);

CodeGenModule::SetFunctionAttributes(

GD, llvm::Function *F,

IsIncompleteFunction,

(llvm::Intrinsic::ID IID = F->getIntrinsicID()) {

F->setAttributes(llvm::Intrinsic::getAttributes(

(), IID));

*FD = cast<FunctionDecl>(GD.

());

(!IsIncompleteFunction)

(!IsThunk &&

().HasThisReturn(GD) &&

assert(!F->arg_empty() &&

F->arg_begin()->getType()

->canLosslesslyBitCastTo(F->getReturnType()) &&

);

F->addParamAttr(0, llvm::Attribute::Returned);

(!IsIncompleteFunction && F->isDeclaration())

(

*CSA = FD->

<CodeSegAttr>())

F->setSection(CSA->getName());

(

*SA = FD->

<SectionAttr>())

F->setSection(SA->getName());

(

*EA = FD->

<ErrorAttr>()) {

F->addFnAttr(

, EA->getUserDiagnostic());

(EA->isWarning())

F->addFnAttr(

, EA->getUserDiagnostic());

HasBody = FD->

(FDBody);

assert(HasBody &&

);

(shouldEmitFunction(FDBody))

F->addFnAttr(llvm::Attribute::NoBuiltin);

F->addFnAttr(llvm::Attribute::NoBuiltin);

(isa<CXXConstructorDecl>(FD) || isa<CXXDestructorDecl>(FD))

F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

(

*MD = dyn_cast<CXXMethodDecl>(FD))

(MD->isVirtual())

F->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

(!CodeGenOpts.SanitizeCfiCrossDso ||

!CodeGenOpts.SanitizeCfiCanonicalJumpTables)

(LangOpts.

.

(SanitizerKind::KCFI))

(CodeGenOpts.InlineMaxStackSize !=

)

F->addFnAttr(

, llvm::utostr(CodeGenOpts.InlineMaxStackSize));

(

*CB = FD->

<CallbackAttr>()) {

llvm::LLVMContext &Ctx = F->getContext();

llvm::MDBuilder MDB(Ctx);

CalleeIdx = *CB->encoding_begin();

PayloadIndices(CB->encoding_begin() + 1, CB->encoding_end());

F->addMetadata(llvm::LLVMContext::MD_callback,

*llvm::MDNode::get(Ctx, {MDB.createCallbackEncoding(

CalleeIdx, PayloadIndices,

assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&

);

LLVMUsed.emplace_back(GV);

assert(!GV->isDeclaration() &&

);

LLVMCompilerUsed.emplace_back(GV);

assert((isa<llvm::Function>(GV) || !GV->isDeclaration()) &&

);

LLVMCompilerUsed.emplace_back(GV);

LLVMUsed.emplace_back(GV);

std::vector<llvm::WeakTrackingVH> &List) {

UsedArray.resize(List.size());

(

i = 0, e = List.size(); i != e; ++i) {

llvm::ConstantExpr::getPointerBitCastOrAddrSpaceCast(

cast<llvm::Constant>(&*List[i]), CGM.

);

(UsedArray.empty())

llvm::ArrayType *ATy = llvm::ArrayType::get(CGM.

, UsedArray.size());

*GV =

llvm::GlobalVariable(

CGM.

(), ATy,

, llvm::GlobalValue::AppendingLinkage,

llvm::ConstantArray::get(ATy, UsedArray), Name);

GV->setSection(

);

CodeGenModule::emitLLVMUsed() {

(*

,

, LLVMUsed);

(*

,

, LLVMCompilerUsed);

LinkerOptionsMetadata.push_back(llvm::MDNode::get(

(), MDOpts));

LinkerOptionsMetadata.push_back(llvm::MDNode::get(

(), MDOpts));

ELFDependentLibraries.push_back(

llvm::MDNode::get(

, llvm::MDString::get(

, Lib)));

LinkerOptionsMetadata.push_back(llvm::MDNode::get(

, MDOpts));

(

.insert(Import).second)

(LL.IsFramework) {

llvm::Metadata *Args[2] = {llvm::MDString::get(Context,

),

llvm::MDString::get(Context, LL.Library)};

Metadata.push_back(llvm::MDNode::get(Context, Args));

llvm::Metadata *Args[2] = {

llvm::MDString::get(Context,

),

llvm::MDString::get(Context, LL.Library),

Metadata.push_back(llvm::MDNode::get(Context, Args));

*OptString = llvm::MDString::get(Context, Opt);

Metadata.push_back(llvm::MDNode::get(Context, OptString));

CodeGenModule::EmitModuleInitializers(

*Primary) {

);

(isa<ImportDecl>(

))

assert(isa<VarDecl>(

) &&

);

(isa<ImportDecl>(

))

(isa<ImportDecl>(

))

assert(isa<VarDecl>(

) &&

);

CodeGenModule::EmitModuleLinkOptions() {

llvm::SetVector<clang::Module *> LinkModules;

(

*M : ImportedModules) {

(M->getTopLevelModuleName() ==

().CurrentModule &&

(

.insert(M).second)

(!Stack.empty()) {

AnyChildren =

;

(

->IsExplicit)

Stack.push_back(

);

AnyChildren =

;

LinkModules.insert(Mod);

(

*M : LinkModules)

(

.insert(M).second)

std::reverse(MetadataArgs.begin(), MetadataArgs.end());

LinkerOptionsMetadata.append(MetadataArgs.begin(), MetadataArgs.end());

*NMD =

().getOrInsertNamedMetadata(

);

(

*MD : LinkerOptionsMetadata)

NMD->addOperand(MD);

CodeGenModule::EmitDeferred() {

(!DeferredVTables.empty()) {

EmitDeferredVTables();

assert(DeferredVTables.empty());

llvm::append_range(DeferredDeclsToEmit,

(DeferredDeclsToEmit.empty())

std::vector<GlobalDecl> CurDeclsToEmit;

CurDeclsToEmit.swap(DeferredDeclsToEmit);

llvm::GlobalValue *GV = dyn_cast<llvm::GlobalValue>(

(!GV->isDeclaration())

(LangOpts.OpenMP && OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(

))

EmitGlobalDefinition(

, GV);

(!DeferredVTables.empty() || !DeferredDeclsToEmit.empty()) {

assert(DeferredVTables.empty() && DeferredDeclsToEmit.empty());

CodeGenModule::EmitVTablesOpportunistically() {

assert((OpportunisticVTables.empty() || shouldOpportunisticallyEmitVTables())

&&

);

assert(

().isVTableExternal(RD) &&

);

(

().canSpeculativelyEmitVTable(RD))

OpportunisticVTables.clear();

(

& [MangledName, VD] : DeferredAnnotations) {

DeferredAnnotations.clear();

(Annotations.empty())

llvm::Constant *Array = llvm::ConstantArray::get(llvm::ArrayType::get(

Annotations[0]->getType(), Annotations.size()), Annotations);

*gv =

llvm::GlobalVariable(

(), Array->getType(),

,

llvm::GlobalValue::AppendingLinkage,

Array,

);

llvm::Constant *&AStr = AnnotationStrings[Str];

llvm::Constant *

= llvm::ConstantDataArray::getString(

(), Str);

*gv =

llvm::GlobalVariable(

(),

->getType(),

, llvm::GlobalValue::PrivateLinkage,

,

,

, llvm::GlobalValue::NotThreadLocal,

gv->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

.getExpansionLineNumber(L);

llvm::ConstantInt::get(

, LineNo);

llvm::FoldingSetNodeID ID;

(

*

: Exprs) {

ID.Add(cast<clang::ConstantExpr>(

)->getAPValueResult());

llvm::Constant *&Lookup = AnnotationArgs[ID.ComputeHash()];

LLVMArgs.reserve(Exprs.size());

llvm::transform(Exprs, std::back_inserter(LLVMArgs), [&](

*

) {

*CE = cast<clang::ConstantExpr>(

);

ConstEmiter.

(CE->getBeginLoc(), CE->getAPValueResult(),

*

= llvm::ConstantStruct::getAnon(LLVMArgs);

*GV =

llvm::GlobalVariable(

(),

->getType(),

,

llvm::GlobalValue::PrivateLinkage,

,

GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

AnnotateAttr *AA,

llvm::Constant *GVInGlobalsAS = GV;

(GV->getAddressSpace() !=

GVInGlobalsAS = llvm::ConstantExpr::getAddrSpaceCast(

llvm::PointerType::get(

GV->getContext(),

().getDefaultGlobalsAddressSpace()));

llvm::Constant *Fields[] = {

GVInGlobalsAS, AnnoGV, UnitGV, LineNoCst, Args,

llvm::ConstantStruct::getAnon(Fields);

llvm::GlobalValue *GV) {

assert(

->

<AnnotateAttr>() &&

);

(NoSanitizeL.containsFunction(Kind, Fn->getName()))

(NoSanitizeL.containsMainFile(Kind, MainFile.

()))

NoSanitizeL.containsLocation(Kind,

);

NoSanitizeL.containsFile(Kind, MainFile.

());

llvm::GlobalVariable *GV,

(NoSanitizeL.containsGlobal(Kind, GV->getName(),

))

(NoSanitizeL.containsMainFile(

Kind,

.getFileEntryRefForID(

.getMainFileID())->getName(),

(NoSanitizeL.containsLocation(Kind,

,

))

(

AT = dyn_cast<ArrayType>(Ty.

()))

Ty = AT->getElementType();

(NoSanitizeL.containsType(Kind, TypeStr,

))

= ImbueAttr::NONE;

(

== ImbueAttr::NONE)

= XRayFilter.shouldImbueFunction(Fn->getName());

ImbueAttr::NONE:

ImbueAttr::ALWAYS:

Fn->addFnAttr(

,

);

ImbueAttr::ALWAYS_ARG1:

Fn->addFnAttr(

,

);

Fn->addFnAttr(

,

);

ImbueAttr::NEVER:

Fn->addFnAttr(

,

);

(

MainFile =

.getFileEntryRefForID(

.getMainFileID()))

(NumGroups > 1) {

Group = llvm::crc32(arrayRefFromStringRef(Fn->getName())) % NumGroups;

(LangOpts.EmitAllDecls)

*VD = dyn_cast<VarDecl>(

);

((CodeGenOpts.KeepPersistentStorageVariables &&

(VD->getStorageDuration() ==

||

VD->getStorageDuration() ==

)) ||

(CodeGenOpts.KeepStaticConsts && VD->getStorageDuration() ==

&&

VD->getType().isConstQualified())))

(LangOpts.OpenMP >= 50 && !LangOpts.OpenMPSimd) {

std::optional<OMPDeclareTargetDeclAttr *> ActiveAttr =

OMPDeclareTargetDeclAttr::getActiveAttr(

);

(!ActiveAttr || (*ActiveAttr)->getLevel() != (

)-1)

(

*FD = dyn_cast<FunctionDecl>(

)) {

(

*VD = dyn_cast<VarDecl>(

)) {

(CXX20ModuleInits && VD->getOwningModule() &&

!VD->getOwningModule()->isModuleMapModule()) {

(LangOpts.OpenMP && LangOpts.OpenMPUseTLS &&

().getTargetInfo().isTLSSupported() && isa<VarDecl>(

) &&

!OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(

))

(llvm::GlobalVariable *GV =

().getNamedGlobal(Name))

llvm::Constant *

;

(!

.isAbsent()) {

llvm::Constant *Fields[4] = {

llvm::ConstantDataArray::getRaw(

StringRef(

*

(Parts.

), 8), 8,

= llvm::ConstantStruct::getAnon(Fields);

*GV =

llvm::GlobalVariable(

, llvm::GlobalValue::LinkOnceODRLinkage,

, Name);

GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));

(!

.isAbsent()) {

llvm::GlobalVariable **Entry =

;

Entry = &UnnamedGlobalConstantDeclMap[GCD];

llvm::Constant *

;

assert(!

.isAbsent());

*GV =

llvm::GlobalVariable(

(),

->getType(),

llvm::GlobalValue::PrivateLinkage,

,

GV->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

(llvm::GlobalVariable *GV =

().getNamedGlobal(Name))

llvm::Constant *

=

.emitForInitializer(

llvm::GlobalValue::LinkageTypes

=

? llvm::GlobalValue::LinkOnceODRLinkage

: llvm::GlobalValue::InternalLinkage;

*GV =

llvm::GlobalVariable(

(),

->getType(),

GV->setComdat(TheModule.getOrInsertComdat(GV->getName()));

AliasAttr *AA = VD->

<AliasAttr>();

assert(AA &&

);

llvm::Constant *Aliasee;

(isa<llvm::FunctionType>(DeclTy))

Aliasee = GetOrCreateLLVMFunction(AA->getAliasee(), DeclTy,

*F = cast<llvm::GlobalValue>(Aliasee);

F->setLinkage(llvm::Function::ExternalWeakLinkage);

WeakRefReferences.insert(F);

(

*A =

->

<AttrT>())

A->isImplicit();

CodeGenModule::shouldEmitCUDAGlobalVar(

*

)

{

assert(LangOpts.CUDA &&

);

!LangOpts.CUDAIsDevice ||

->hasAttr<CUDADeviceAttr>() ||

->hasAttr<CUDAConstantAttr>() ||

->hasAttr<CUDASharedAttr>() ||

->getType()->isCUDADeviceBuiltinSurfaceType() ||

->getType()->isCUDADeviceBuiltinTextureType();

(

->hasAttr<WeakRefAttr>())

(

->hasAttr<AliasAttr>())

EmitAliasDefinition(GD);

(

->hasAttr<IFuncAttr>())

emitIFuncDefinition(GD);

(

->hasAttr<CPUDispatchAttr>())

emitCPUDispatchDefinition(GD);

(LangOpts.CUDA) {

assert((isa<FunctionDecl>(

) || isa<VarDecl>(

)) &&

);

(

*VD = dyn_cast<VarDecl>(

)) {

(!shouldEmitCUDAGlobalVar(VD))

}

(LangOpts.CUDAIsDevice) {

*FD = dyn_cast<FunctionDecl>(

);

((!

->hasAttr<CUDADeviceAttr>() ||

(LangOpts.OffloadImplicitHostDeviceTemplates &&

hasImplicitAttr<CUDAHostAttr>(FD) &&

hasImplicitAttr<CUDADeviceAttr>(FD) && !FD->

() &&

!

().CUDAImplicitHostDeviceFunUsedByDevice.count(FD))) &&

!

->hasAttr<CUDAGlobalAttr>() &&

!(LangOpts.HIPStdPar && isa<FunctionDecl>(

) &&

!

->hasAttr<CUDAHostAttr>()))

}

(!

->hasAttr<CUDAHostAttr>() &&

->hasAttr<CUDADeviceAttr>())

(LangOpts.OpenMP) {

(OpenMPRuntime && OpenMPRuntime->emitTargetGlobal(GD))

(

*DRD = dyn_cast<OMPDeclareReductionDecl>(

)) {

(MustBeEmitted(

))

(

*DMD = dyn_cast<OMPDeclareMapperDecl>(

)) {

(MustBeEmitted(

))

(

*FD = dyn_cast<FunctionDecl>(

)) {

(FD->

<AnnotateAttr>()) {

DeferredAnnotations[MangledName] = FD;

GetOrCreateLLVMFunction(MangledName, Ty, GD,

,

*VD = cast<VarDecl>(

);

assert(VD->isFileVarDecl() &&

);

(LangOpts.OpenMP) {

(std::optional<OMPDeclareTargetDeclAttr::MapTypeTy> Res =

OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(VD)) {

(VD->hasExternalStorage() &&

Res != OMPDeclareTargetDeclAttr::MT_Link)

UnifiedMemoryEnabled =

((*Res == OMPDeclareTargetDeclAttr::MT_To ||

*Res == OMPDeclareTargetDeclAttr::MT_Enter) &&

!UnifiedMemoryEnabled) {

assert(((*Res == OMPDeclareTargetDeclAttr::MT_Link) ||

((*Res == OMPDeclareTargetDeclAttr::MT_To ||

*Res == OMPDeclareTargetDeclAttr::MT_Enter) &&

UnifiedMemoryEnabled)) &&

);

(MustBeEmitted(

) && MayBeEmittedEagerly(

)) {

EmitGlobalDefinition(GD);

addEmittedDeferredDecl(GD);

cast<VarDecl>(

)->hasInit()) {

DelayedCXXInitPosition[

] = CXXGlobalInits.size();

CXXGlobalInits.push_back(

);

addDeferredDeclToEmit(GD);

}

(MustBeEmitted(

)) {

assert(!MayBeEmittedEagerly(

));

addDeferredDeclToEmit(GD);

DeferredDecls[MangledName] = GD;

(

*RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))

(RD->getDestructor() && !RD->getDestructor()->hasAttr<DLLImportAttr>())

FunctionIsDirectlyRecursive

StringRef Name;

: Name(N), BI(

) {}

VisitCallExpr(

*

) {

AsmLabelAttr *

= FD->

<AsmLabelAttr>();

(

&& Name ==

->getLabel())

StringRef BuiltinName = BI.

(BuiltinID);

(BuiltinName.starts_with(

) &&

Name == BuiltinName.slice(strlen(

), StringRef::npos)) {

VisitStmt(

*S) {

(

*Child : S->children())

(Child && this->Visit(Child))

DLLImportFunctionVisitor

SafeToInline =

;

shouldVisitImplicitCode()

{

; }

VisitVarDecl(

*VD) {

SafeToInline =

;

SafeToInline;

SafeToInline;

(

*

=

->getTemporary()->getDestructor())

SafeToInline =

->

<DLLImportAttr>();

SafeToInline;

(isa<FunctionDecl>(VD))

SafeToInline = VD->

<DLLImportAttr>();

(

*

= dyn_cast<VarDecl>(VD))

SafeToInline = !

->hasGlobalStorage() ||

->hasAttr<DLLImportAttr>();

SafeToInline;

SafeToInline =

->getConstructor()->hasAttr<DLLImportAttr>();

SafeToInline;

SafeToInline =

;

SafeToInline = M->

<DLLImportAttr>();

SafeToInline;

SafeToInline =

->getOperatorDelete()->hasAttr<DLLImportAttr>();

SafeToInline;

SafeToInline =

->getOperatorNew()->hasAttr<DLLImportAttr>();

SafeToInline;

CodeGenModule::isTriviallyRecursive(

*FD) {

(

().getMangleContext().shouldMangleDeclName(FD)) {

AsmLabelAttr *

= FD->

<AsmLabelAttr>();

Name =

->getLabel();

FunctionIsDirectlyRecursive Walker(Name, Context.

);

Body ? Walker.Visit(Body) :

;

CodeGenModule::shouldEmitFunction(

GD) {

*F = cast<FunctionDecl>(GD.

());

(F->isInlineBuiltinDeclaration())

(CodeGenOpts.OptimizationLevel == 0 && !F->hasAttr<AlwaysInlineAttr>())

(

*M = F->getOwningModule();

M && M->getTopLevelModule()->isNamedModule() &&

().getCurrentNamedModule() != M->getTopLevelModule()) {

(!F->isTemplateInstantiation() || !F->hasAttr<AlwaysInlineAttr>()) {

(F->hasAttr<NoInlineAttr>())

(F->hasAttr<DLLImportAttr>() && !F->hasAttr<AlwaysInlineAttr>()) {

DLLImportFunctionVisitor Visitor;

Visitor.TraverseFunctionDecl(

*

(F));

(!Visitor.SafeToInline)

(

*

: Dtor->getParent()->decls())

(isa<FieldDecl>(

))

!isTriviallyRecursive(F);

CodeGenModule::shouldOpportunisticallyEmitVTables() {

CodeGenOpts.OptimizationLevel > 0;

CodeGenModule::EmitMultiVersionFunctionDefinition(

GD,

llvm::GlobalValue *GV) {

*FD = cast<FunctionDecl>(GD.

());

*Spec = FD->

<CPUSpecificAttr>();

(

I = 0; I < Spec->cpus_size(); ++I)

}

(

*TC = FD->

<TargetClonesAttr>()) {

(

I = 0; I < TC->featuresStrs_size(); ++I)

TC->isFirstOfVersion(I))

GetOrCreateMultiVersionResolver(GD);

EmitGlobalFunctionDefinition(GD, GV);

AddDeferredMultiVersionResolverToEmit(GD);

CodeGenModule::EmitGlobalDefinition(

GD, llvm::GlobalValue *GV) {

*

= cast<ValueDecl>(GD.

());

);

(

*FD = dyn_cast<FunctionDecl>(

)) {

(!shouldEmitFunction(GD))

llvm::TimeTraceScope TimeScope(

, [&]() {

llvm::raw_string_ostream OS(Name);

(

*Method = dyn_cast<CXXMethodDecl>(

)) {

(isa<CXXConstructorDecl>(Method) || isa<CXXDestructorDecl>(Method))

ABI->emitCXXStructor(GD);

EmitMultiVersionFunctionDefinition(GD, GV);

EmitGlobalFunctionDefinition(GD, GV);

(Method->isVirtual())

EmitMultiVersionFunctionDefinition(GD, GV);

EmitGlobalFunctionDefinition(GD, GV);

(

*VD = dyn_cast<VarDecl>(

))

EmitGlobalVarDefinition(VD, !VD->hasDefinition());

llvm_unreachable(

);

llvm::Function *NewFn);

CodeGenFunction::FMVResolverOption &RO) {

(RO.Architecture)

Features.push_back(*RO.Architecture);

llvm::GlobalValue::LinkageTypes

llvm::GlobalValue::InternalLinkage;

llvm::GlobalValue::WeakODRLinkage;

CodeGenModule::emitMultiVersionFunctions() {

std::vector<GlobalDecl> MVFuncsToEmit;

MultiVersionFuncs.swap(MVFuncsToEmit);

*FD = cast<FunctionDecl>(GD.

());

assert(FD &&

);

createFunction = [&](

*

,

MVIdx = 0) {

(

->isDefined()) {

EmitGlobalFunctionDefinition(CurGD,

);

assert(

&&

);

cast<llvm::Function>(

);

(

*TA = CurFD->

<TargetAttr>()) {

assert(getTarget().getTriple().isX86() &&

);

TA->getX86AddedFeatures(Feats);

llvm::Function *Func = createFunction(CurFD);

Options.emplace_back(Func, Feats, TA->getX86Architecture());

}

(

*TVA = CurFD->

<TargetVersionAttr>()) {

if (TVA->isDefaultVersion() && IsDefined)

ShouldEmitResolver = true;

llvm::Function *Func = createFunction(CurFD);

char Delim = getTarget().getTriple().isAArch64() ?

:

;

TVA->getFeatures(Feats, Delim);

Options.emplace_back(Func, Feats);

}

(

*TC = CurFD->

<TargetClonesAttr>()) {

ShouldEmitResolver = true;

for (unsigned I = 0; I < TC->featuresStrs_size(); ++I) {

if (!TC->isFirstOfVersion(I))

llvm::Function *Func = createFunction(CurFD, I);

if (getTarget().getTriple().isX86()) {

TC->getX86Feature(Feats, I);

Options.emplace_back(Func, Feats, TC->getX86Architecture(I));

char Delim = getTarget().getTriple().isAArch64() ?

:

;

TC->getFeatures(Feats, I, Delim);

Options.emplace_back(Func, Feats);

llvm_unreachable(

);

(!ShouldEmitResolver)

llvm::Constant *ResolverConstant = GetOrCreateMultiVersionResolver(GD);

(

*IFunc = dyn_cast<llvm::GlobalIFunc>(ResolverConstant)) {

ResolverConstant = IFunc->getResolver();

*

, GD, FD,

);

*Alias = llvm::GlobalAlias::create(

MangledName +

, IFunc, &

());

llvm::Function *ResolverFunc = cast<llvm::Function>(ResolverConstant);

ResolverFunc->setComdat(

().getOrInsertComdat(ResolverFunc->getName()));

Options, [&TI](

CodeGenFunction::FMVResolverOption &LHS,

CodeGenFunction::FMVResolverOption &RHS) {

CGF.EmitMultiVersionResolver(ResolverFunc, Options);

(!MVFuncsToEmit.empty())

(!MultiVersionFuncs.empty())

emitMultiVersionFunctions();

llvm::Constant *New) {

assert(cast<llvm::Function>(Old)->isDeclaration() &&

);

Old->replaceAllUsesWith(New);

Old->eraseFromParent();

CodeGenModule::emitCPUDispatchDefinition(

GD) {

*FD = cast<FunctionDecl>(GD.

());

assert(FD &&

);

*DD = FD->

<CPUDispatchAttr>();

assert(DD &&

);

UpdateMultiVersionNames(GD, FD, ResolverName);

llvm::Type *ResolverType;

ResolverType = llvm::FunctionType::get(

llvm::PointerType::get(DeclTy,

*ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(

ResolverName, ResolverType, ResolverGD,

));

ResolverFunc->setComdat(

().getOrInsertComdat(ResolverFunc->getName()));

ExistingDecl = Manglings.lookup(MangledName);

(ExistingDecl.

() &&

EmitGlobalFunctionDefinition(ExistingDecl,

);

(!ExistingDecl.

())

= GetOrCreateLLVMFunction(

MangledName, DeclTy, ExistingDecl,

.getCPUSpecificCPUDispatchFeatures(II->getName(), Features);

llvm::transform(Features, Features.begin(),

[](StringRef Str) { return Str.substr(1); });

llvm::erase_if(Features, [&

](StringRef Feat) {

!

.validateCpuSupports(Feat);

Options.emplace_back(cast<llvm::Function>(

), Features);

llvm::stable_sort(Options, [](

CodeGenFunction::FMVResolverOption &LHS,

CodeGenFunction::FMVResolverOption &RHS) {

llvm::X86::getCpuSupportsMask(LHS.Features) >

llvm::X86::getCpuSupportsMask(RHS.Features);

(Options.size() > 1 && llvm::all_of(llvm::X86::getCpuSupportsMask(

(Options.end() - 2)->Features),

[](

) { return X == 0; })) {

StringRef LHSName = (Options.end() - 2)->

->getName();

StringRef RHSName = (Options.end() - 1)->

->getName();

(LHSName.compare(RHSName) < 0)

Options.erase(Options.end() - 2);

Options.erase(Options.end() - 1);

CGF.EmitMultiVersionResolver(ResolverFunc, Options);

*IFunc = cast<llvm::GlobalValue>(GetOrCreateMultiVersionResolver(GD));

AS = IFunc->getType()->getPointerAddressSpace();

(!isa<llvm::GlobalIFunc>(IFunc)) {

*GI = llvm::GlobalIFunc::create(DeclTy, AS,

,

,

*

, GD, FD,

);

*GA = llvm::GlobalAlias::create(DeclTy, AS,

, AliasName,

CodeGenModule::AddDeferredMultiVersionResolverToEmit(

GD) {

*FD = cast<FunctionDecl>(GD.

());

assert(FD &&

);

std::string MangledName =

(!DeferredResolversToEmit.insert(MangledName).second)

MultiVersionFuncs.push_back(GD);

llvm::Constant *CodeGenModule::GetOrCreateMultiVersionResolver(

GD) {

*FD = cast<FunctionDecl>(GD.

());

assert(FD &&

);

std::string MangledName =

std::string ResolverName = MangledName;

llvm_unreachable(

);

ResolverName +=

;

ResolverName +=

;

ShouldReturnIFunc =

(ResolverGV && (isa<llvm::GlobalIFunc>(ResolverGV) || !ShouldReturnIFunc))

AddDeferredMultiVersionResolverToEmit(GD);

(ShouldReturnIFunc) {

llvm::Type *ResolverType =

llvm::FunctionType::get(llvm::PointerType::get(DeclTy, AS),

);

llvm::Constant *Resolver = GetOrCreateLLVMFunction(

MangledName +

, ResolverType,

{},

llvm::GlobalIFunc *GIF =

GIF->setName(ResolverName);

llvm::Constant *Resolver = GetOrCreateLLVMFunction(

ResolverName, DeclTy,

{},

);

assert(isa<llvm::GlobalValue>(Resolver) && !ResolverGV &&

);

CodeGenModule::shouldDropDLLAttribute(

*

,

llvm::GlobalValue *GV)

{

SC = GV->getDLLStorageClass();

(SC == llvm::GlobalValue::DefaultStorageClass)

(((SC == llvm::GlobalValue::DLLImportStorageClass &&

!MRD->

<DLLImportAttr>()) ||

(SC == llvm::GlobalValue::DLLExportStorageClass &&

!MRD->

<DLLExportAttr>())) &&

llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(

StringRef MangledName, llvm::Type *Ty,

GD,

ForVTable,

DontDefer,

IsThunk, llvm::AttributeList ExtraAttrs,

std::string NameWithoutMultiVersionMangling;

(

*FD = cast_or_null<FunctionDecl>(

)) {

(

().OpenMPIsTargetDevice && OpenMPRuntime &&

!OpenMPRuntime->markAsGlobalTarget(GD) && FD->

() &&

!DontDefer && !IsForDefinition) {

(

*CD = dyn_cast<CXXConstructorDecl>(FDDef))

(

*DD = dyn_cast<CXXDestructorDecl>(FDDef))

UpdateMultiVersionNames(GD, FD, MangledName);

(!IsForDefinition) {

AddDeferredMultiVersionResolverToEmit(GD);

*

, GD, FD,

);

GetOrCreateMultiVersionResolver(GD);

(!NameWithoutMultiVersionMangling.empty())

MangledName = NameWithoutMultiVersionMangling;

(WeakRefReferences.erase(Entry)) {

(FD && !FD->

<WeakAttr>())

Entry->setLinkage(llvm::Function::ExternalLinkage);

(

&& shouldDropDLLAttribute(

, Entry)) {

Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);

(IsForDefinition && !Entry->isDeclaration()) {

DiagnosedConflictingDefinitions.insert(GD).second) {

diag::note_previous_definition);

((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&

(Entry->getValueType() == Ty)) {

(!IsForDefinition)

IsIncompleteFunction =

;

llvm::FunctionType *FTy;

(isa<llvm::FunctionType>(Ty)) {

FTy = cast<llvm::FunctionType>(Ty);

FTy = llvm::FunctionType::get(

,

);

IsIncompleteFunction =

;

llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,

Entry ? StringRef() : MangledName, &

());

(

&&

->

<AnnotateAttr>())

DeferredAnnotations[MangledName] = cast<ValueDecl>(

);

(!Entry->use_empty()) {

Entry->removeDeadConstantUsers();

assert(F->getName() == MangledName &&

);

SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);

(ExtraAttrs.hasFnAttrs()) {

llvm::AttrBuilder B(F->getContext(), ExtraAttrs.getFnAttrs());

(isa_and_nonnull<CXXDestructorDecl>(

) &&

().useThunkForDtorVariant(cast<CXXDestructorDecl>(

),

addDeferredDeclToEmit(GD);

DDI = DeferredDecls.find(MangledName);

(DDI != DeferredDecls.end()) {

addDeferredDeclToEmit(DDI->second);

DeferredDecls.erase(DDI);

(

*FD = cast<FunctionDecl>(

)->getMostRecentDecl(); FD;

(!IsIncompleteFunction) {

assert(F->getFunctionType() == Ty);

*FD = cast<FunctionDecl>(GD.

());

(

*DD = dyn_cast<CXXDestructorDecl>(GD.

())) {

DD->getParent()->getNumVBases() == 0)

*F = GetOrCreateLLVMFunction(MangledName, Ty, GD, ForVTable, DontDefer,

, llvm::AttributeList(),

(LangOpts.CUDA && !LangOpts.CUDAIsDevice &&

cast<FunctionDecl>(GD.

())->hasAttr<CUDAGlobalAttr>()) {

cast<llvm::Function>(F->stripPointerCasts()), GD);

(IsForDefinition)

llvm::GlobalValue *F =

llvm::NoCFIValue::get(F);

(

*FD = dyn_cast<FunctionDecl>(

))

(!

.getLangOpts().CPlusPlus)

(Name ==

|| Name ==

)

?

.Idents.get(

)

:

.Idents.get(Name);

(

&N : {

,

}) {

(

*LSD = dyn_cast<LinkageSpecDecl>(

))

(

*

: LSD->lookup(&NS))

((ND = dyn_cast<NamespaceDecl>(

)))

(

*FD = dyn_cast<FunctionDecl>(

))

llvm::Function *F, StringRef Name) {

(!Local && CGM.

().isWindowsItaniumEnvironment() &&

(!FD || FD->

<DLLImportAttr>()) {

F->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);

F->setLinkage(llvm::GlobalValue::ExternalLinkage);

llvm::AttributeList ExtraAttrs,

Local,

AssumeConvergent) {

(AssumeConvergent) {

ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);

llvm::Constant *

= GetOrCreateLLVMFunction(

,

, ExtraAttrs);

(

*F = dyn_cast<llvm::Function>(

)) {

{ConvTy,

};

llvm::FunctionCallee

llvm::AttributeList ExtraAttrs,

Local,

AssumeConvergent) {

(AssumeConvergent) {

ExtraAttrs.addFnAttribute(VMContext, llvm::Attribute::Convergent);

llvm::Constant *

=

GetOrCreateLLVMFunction(Name, FTy,

(),

,

(

*F = dyn_cast<llvm::Function>(

)) {

markRegisterParameterAttributes(F);

(WeakRefReferences.erase(Entry)) {

Entry->setLinkage(llvm::Function::ExternalLinkage);

(

&& shouldDropDLLAttribute(

, Entry))

Entry->setDLLStorageClass(llvm::GlobalValue::DefaultStorageClass);

(LangOpts.OpenMP && !LangOpts.OpenMPSimd &&

)

(Entry->getValueType() == Ty && Entry->getAddressSpace() == TargetAS)

(IsForDefinition && !Entry->isDeclaration()) {

(OtherD = dyn_cast<VarDecl>(OtherGD.

())) &&

DiagnosedConflictingDefinitions.insert(

).second) {

diag::note_previous_definition);

(Entry->getType()->getAddressSpace() != TargetAS)

llvm::ConstantExpr::getAddrSpaceCast(

Entry, llvm::PointerType::get(Ty->getContext(), TargetAS));

(!IsForDefinition)