reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

  492                                      F->getLinkage(), F->getName(),

include/llvm/IR/GlobalValue.h

  129     switch (getLinkage()) {
  429   bool isInterposable() const { return isInterposableLinkage(getLinkage()); }
  431   bool hasExternalLinkage() const { return isExternalLinkage(getLinkage()); }
  433     return isAvailableExternallyLinkage(getLinkage());
  435   bool hasLinkOnceLinkage() const { return isLinkOnceLinkage(getLinkage()); }
  437     return isLinkOnceODRLinkage(getLinkage());
  439   bool hasWeakLinkage() const { return isWeakLinkage(getLinkage()); }
  440   bool hasWeakAnyLinkage() const { return isWeakAnyLinkage(getLinkage()); }
  441   bool hasWeakODRLinkage() const { return isWeakODRLinkage(getLinkage()); }
  442   bool hasAppendingLinkage() const { return isAppendingLinkage(getLinkage()); }
  443   bool hasInternalLinkage() const { return isInternalLinkage(getLinkage()); }
  444   bool hasPrivateLinkage() const { return isPrivateLinkage(getLinkage()); }
  445   bool hasLocalLinkage() const { return isLocalLinkage(getLinkage()); }
  447     return isExternalWeakLinkage(getLinkage());
  449   bool hasCommonLinkage() const { return isCommonLinkage(getLinkage()); }
  451     return isValidDeclarationLinkage(getLinkage());
  463     return isDiscardableIfUnused(getLinkage());
  466   bool isWeakForLinker() const { return isWeakForLinker(getLinkage()); }

lib/Analysis/ModuleSummaryAnalysis.cpp

  460   GlobalValueSummary::GVFlags Flags(F.getLinkage(), NotEligibleForImport,
  577   GlobalValueSummary::GVFlags Flags(V.getLinkage(), NonRenamableLocal,
  616   GlobalValueSummary::GVFlags Flags(A.getLinkage(), NonRenamableLocal,

lib/Analysis/ScalarEvolution.cpp

  603       auto LT = GV->getLinkage();

lib/Bitcode/Writer/BitcodeWriter.cpp

  998   return getEncodedLinkage(GV.getLinkage());

lib/CodeGen/AsmPrinter/AsmPrinter.cpp

  396   GlobalValue::LinkageTypes Linkage = GV->getLinkage();
  666       F.getLinkage() != GlobalValue::InternalLinkage)

lib/CodeGen/GlobalMerge.cpp

  524       GlobalValue::LinkageTypes Linkage = Globals[k]->getLinkage();

lib/CodeGen/LowerEmuTLS.cpp

   43     to->setLinkage(from->getLinkage());

lib/CodeGen/PreISelIntrinsicLowering.cpp

   70     Fn->setLinkage(F.getLinkage());

lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 1892   switch (GO->getLinkage()) {

lib/ExecutionEngine/Orc/IndirectionUtils.cpp

  290                      F.getLinkage(), F.getName(), &Dst);
  327       GV.getLinkage(), nullptr, GV.getName(), nullptr,
  358                                    OrigA.getLinkage(), OrigA.getName(), &Dst);

lib/IR/AsmWriter.cpp

 3272   Out << getLinkageNameWithSpace(GV->getLinkage());
 3325   Out << getLinkageNameWithSpace(GIS->getLinkage());
 3434   Out << getLinkageNameWithSpace(F->getLinkage());

lib/IR/AutoUpgrade.cpp

  516       NewFn = Function::Create(fType, F->getLinkage(), F->getAddressSpace(),
  532       NewFn = Function::Create(fType, F->getLinkage(), F->getAddressSpace(),
  864   return new GlobalVariable(NewInit->getType(), false, GV->getLinkage(),

lib/IR/Core.cpp

 1829   switch (unwrap<GlobalValue>(Global)->getLinkage()) {

lib/IR/Globals.cpp

  161   return getGlobalIdentifier(getName(), getLinkage(),
  511   return create(Aliasee->getLinkage(), Name, Aliasee);

lib/IR/Verifier.cpp

  753   Assert(GlobalAlias::isValidLinkage(GA.getLinkage()),

lib/LTO/LTO.cpp

  729         GlobalValue::LinkageTypes OriginalLinkage = GV->getLinkage();

lib/LTO/LTOCodeGenerator.cpp

  450         ExternalSymbols.insert(std::make_pair(GV.getName(), GV.getLinkage()));

lib/Linker/IRMover.cpp

  709     NewGV->setLinkage(SGV->getLinkage());
  919       DstM, NewType, SrcGV->isConstant(), SrcGV->getLinkage(),

lib/Linker/LinkModules.cpp

   84     if (!SrcGV->hasName() || GlobalValue::isLocalLinkage(SrcGV->getLinkage()))

lib/ProfileData/InstrProf.cpp

  261     return getPGOFuncName(F.getName(), F.getLinkage(), FileName, Version);
  326   if (!GlobalValue::isLocalLinkage(FuncNameVar->getLinkage()))
  333   return createPGOFuncNameVar(*F.getParent(), F.getLinkage(), PGOFuncName);
 1061   GlobalValue::LinkageTypes Linkage = F.getLinkage();
 1099   if (!GlobalValue::isDiscardableIfUnused(F.getLinkage()))
 1104     assert(F.getLinkage() == GlobalValue::AvailableExternallyLinkage);

lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp

  306     auto NewF = Function::Create(NewFT, F->getLinkage(), F->getName());

lib/Target/BPF/BTFDebug.cpp

 1097     auto Linkage = Global.getLinkage();

lib/Target/NVPTX/NVPTXGenericToNVVM.cpp

   85           GV->getLinkage(),

lib/Target/PowerPC/PPCISelLowering.cpp

 5376                  << GV->getLinkage() << "\n");

lib/Target/WebAssembly/WebAssemblyAddMissingPrototypes.cpp

  126         Function::Create(NewType, F.getLinkage(), F.getName() + ".fixed_sig");

lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp

  317       MainWrapper->setLinkage(Main->getLinkage());

lib/Target/XCore/XCoreAsmPrinter.cpp

  123   switch (GV->getLinkage()) {

lib/Target/XCore/XCoreLowerThreadLocal.cpp

  196     new GlobalVariable(*M, NewType, GV->isConstant(), GV->getLinkage(),

lib/Transforms/Coroutines/CoroSplit.cpp

  663   auto savedLinkage = NewF->getLinkage();

lib/Transforms/IPO/ArgumentPromotion.cpp

  218   Function *NF = Function::Create(NFTy, F->getLinkage(), F->getAddressSpace(),

lib/Transforms/IPO/DeadArgumentElimination.cpp

  166   Function *NF = Function::Create(NFTy, Fn.getLinkage(), Fn.getAddressSpace());
  865   Function *NF = Function::Create(NFTy, F->getLinkage(), F->getAddressSpace());

lib/Transforms/IPO/ExtractGV.cpp

   40   switch(GV.getLinkage()) {

lib/Transforms/IPO/FunctionImport.cpp

  952     if (NewLinkage == GV.getLinkage())
  954     if (GlobalValue::isLocalLinkage(GV.getLinkage()) ||
  969         GlobalValue::isInterposableLinkage(GV.getLinkage())) {
  987                         << "` from " << GV.getLinkage() << " to " << NewLinkage
 1055   NewFn->setLinkage(GA->getLinkage());

lib/Transforms/IPO/GlobalOpt.cpp

 2798       Target->setLinkage(J->getLinkage());

lib/Transforms/IPO/LowerTypeTests.cpp

  879         GlobalAlias::create(NewTy->getElementType(I * 2), 0, GV->getLinkage(),
 1537             GlobalAlias::create(F->getValueType(), 0, F->getLinkage(), "",

lib/Transforms/IPO/MergeFunctions.cpp

  697     NewG = Function::Create(G->getFunctionType(), G->getLinkage(),
  770       G->getLinkage(), "", BitcastF, G->getParent());
  812     Function *NewF = Function::Create(F->getFunctionType(), F->getLinkage(),

lib/Transforms/IPO/WholeProgramDevirt.cpp

 1526       B.GV->getInitializer()->getType(), 0, B.GV->getLinkage(), "",

lib/Transforms/Instrumentation/AddressSanitizer.cpp

 2286     GlobalValue::LinkageTypes Linkage = G->getLinkage();
 2613   if (F.getLinkage() == GlobalValue::AvailableExternallyLinkage) return false;

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

  812             buildWrapperFunction(F, "", GA->getLinkage(), F->getFunctionType());
  840         Function *NewF = Function::Create(NewFT, F.getLinkage(),
  885               ? F.getLinkage()

lib/Transforms/Instrumentation/HWAddressSanitizer.cpp

 1316                                     GV->getLinkage(), "", Aliasee, &M);

lib/Transforms/Instrumentation/InstrProfiling.cpp

  746   GlobalValue::LinkageTypes Linkage = NamePtr->getLinkage();

lib/Transforms/Instrumentation/PGOInstrumentation.cpp

  688     assert(F.getLinkage() == GlobalValue::AvailableExternallyLinkage);
 1161               F.getLinkage() == GlobalValue::AvailableExternallyLinkage));

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

  576   if (F.getLinkage() == GlobalValue::AvailableExternallyLinkage)

lib/Transforms/Utils/CloneFunction.cpp

  253   Function *NewF = Function::Create(FTy, F->getLinkage(), F->getAddressSpace(),

lib/Transforms/Utils/CloneModule.cpp

   65                                             I->isConstant(), I->getLinkage(),
   77         Function::Create(cast<FunctionType>(I.getValueType()), I.getLinkage(),
  109                                    I->getLinkage(), I->getName(), New.get());

lib/Transforms/Utils/CtorUtils.cpp

   48       new GlobalVariable(CA->getType(), GCL->isConstant(), GCL->getLinkage(),

lib/Transforms/Utils/FunctionImportUtils.cpp

  118     return SGV->getLinkage();
  123     return SGV->getLinkage();
  125   switch (SGV->getLinkage()) {
  135     return SGV->getLinkage();
  143     return SGV->getLinkage();
  154     return SGV->getLinkage();
  186     return SGV->getLinkage();
  192     return SGV->getLinkage();
  197     return SGV->getLinkage();

tools/clang/lib/CodeGen/CGDecl.cpp

  342                                   OldGV->getLinkage(), Init, "",

tools/clang/lib/CodeGen/CGObjCMac.cpp

 7282   assert(GV->getLinkage() == L);
 7744   assert(Entry->getLinkage() == L);

tools/clang/lib/CodeGen/CodeGenPGO.cpp

   45   setFuncName(Fn->getName(), Fn->getLinkage());

tools/clang/lib/CodeGen/ItaniumCXXABI.cpp

 2225                                      false, var->getLinkage(),
 2537         llvm::GlobalVariable::isLinkOnceLinkage(Wrapper->getLinkage()) ||
 2538         llvm::GlobalVariable::isWeakODRLinkage(Wrapper->getLinkage()) ||
 2624       if (Wrapper->getLinkage() == llvm::Function::WeakODRLinkage)
 2653         Init = llvm::GlobalAlias::create(Var->getLinkage(), InitFnName.str(),

tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp

 2498                                  GV->getLinkage(), Zero, GuardName.str());
 2513   assert(GuardVar->getLinkage() == GV->getLinkage() &&
 2513   assert(GuardVar->getLinkage() == GV->getLinkage() &&

tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

 1202     if (!GlobalValue::isExternalLinkage(global_variable->getLinkage()))

unittests/Analysis/LazyCallGraphTest.cpp

 2071   Function &E = *Function::Create(D.getFunctionType(), D.getLinkage(), "e");