contrib/llvm-project/llvm/lib/Transforms/Utils/FunctionImportUtils.cpp

   1 //===- lib/Transforms/Utils/FunctionImportUtils.cpp - Importing utilities -===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // This file implements the FunctionImportGlobalProcessing class, used
  10 // to perform the necessary global value handling for function importing.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
  15 #include "llvm/IR/InstIterator.h"
  16 using namespace llvm;
  17
  18 /// Checks if we should import SGV as a definition, otherwise import as a
  19 /// declaration.
  20 bool FunctionImportGlobalProcessing::doImportAsDefinition(
  21     const GlobalValue *SGV, SetVector<GlobalValue *> *GlobalsToImport) {
  22
  23   // Only import the globals requested for importing.
  24   if (!GlobalsToImport->count(const_cast<GlobalValue *>(SGV)))
  25     return false;
  26
  27   assert(!isa<GlobalAlias>(SGV) &&
  28          "Unexpected global alias in the import list.");
  29
  30   // Otherwise yes.
  31   return true;
  32 }
  33
  34 bool FunctionImportGlobalProcessing::doImportAsDefinition(
  35     const GlobalValue *SGV) {
  36   if (!isPerformingImport())
  37     return false;
  38   return FunctionImportGlobalProcessing::doImportAsDefinition(SGV,
  39                                                               GlobalsToImport);
  40 }
  41
  42 bool FunctionImportGlobalProcessing::shouldPromoteLocalToGlobal(
  43     const GlobalValue *SGV) {
  44   assert(SGV->hasLocalLinkage());
  45   // Both the imported references and the original local variable must
  46   // be promoted.
  47   if (!isPerformingImport() && !isModuleExporting())
  48     return false;
  49
  50   if (isPerformingImport()) {
  51     assert((!GlobalsToImport->count(const_cast<GlobalValue *>(SGV)) ||
  52             !isNonRenamableLocal(*SGV)) &&
  53            "Attempting to promote non-renamable local");
  54     // We don't know for sure yet if we are importing this value (as either
  55     // a reference or a def), since we are simply walking all values in the
  56     // module. But by necessity if we end up importing it and it is local,
  57     // it must be promoted, so unconditionally promote all values in the
  58     // importing module.
  59     return true;
  60   }
  61
  62   // When exporting, consult the index. We can have more than one local
  63   // with the same GUID, in the case of same-named locals in different but
  64   // same-named source files that were compiled in their respective directories
  65   // (so the source file name and resulting GUID is the same). Find the one
  66   // in this module.
  67   auto Summary = ImportIndex.findSummaryInModule(
  68       SGV->getGUID(), SGV->getParent()->getModuleIdentifier());
  69   assert(Summary && "Missing summary for global value when exporting");
  70   auto Linkage = Summary->linkage();
  71   if (!GlobalValue::isLocalLinkage(Linkage)) {
  72     assert(!isNonRenamableLocal(*SGV) &&
  73            "Attempting to promote non-renamable local");
  74     return true;
  75   }
  76
  77   return false;
  78 }
  79
  80 #ifndef NDEBUG
  81 bool FunctionImportGlobalProcessing::isNonRenamableLocal(
  82     const GlobalValue &GV) const {
  83   if (!GV.hasLocalLinkage())
  84     return false;
  85   // This needs to stay in sync with the logic in buildModuleSummaryIndex.
  86   if (GV.hasSection())
  87     return true;
  88   if (Used.count(const_cast<GlobalValue *>(&GV)))
  89     return true;
  90   return false;
  91 }
  92 #endif
  93
  94 std::string FunctionImportGlobalProcessing::getName(const GlobalValue *SGV,
  95                                                     bool DoPromote) {
  96   // For locals that must be promoted to global scope, ensure that
  97   // the promoted name uniquely identifies the copy in the original module,
  98   // using the ID assigned during combined index creation. When importing,
  99   // we rename all locals (not just those that are promoted) in order to
 100   // avoid naming conflicts between locals imported from different modules.
 101   if (SGV->hasLocalLinkage() && (DoPromote || isPerformingImport()))
 102     return ModuleSummaryIndex::getGlobalNameForLocal(
 103         SGV->getName(),
 104         ImportIndex.getModuleHash(SGV->getParent()->getModuleIdentifier()));
 105   return SGV->getName();
 106 }
 107
 108 GlobalValue::LinkageTypes
 109 FunctionImportGlobalProcessing::getLinkage(const GlobalValue *SGV,
 110                                            bool DoPromote) {
 111   // Any local variable that is referenced by an exported function needs
 112   // to be promoted to global scope. Since we don't currently know which
 113   // functions reference which local variables/functions, we must treat
 114   // all as potentially exported if this module is exporting anything.
 115   if (isModuleExporting()) {
 116     if (SGV->hasLocalLinkage() && DoPromote)
 117       return GlobalValue::ExternalLinkage;
 118     return SGV->getLinkage();
 119   }
 120
 121   // Otherwise, if we aren't importing, no linkage change is needed.
 122   if (!isPerformingImport())
 123     return SGV->getLinkage();
 124
 125   switch (SGV->getLinkage()) {
 126   case GlobalValue::LinkOnceODRLinkage:
 127   case GlobalValue::ExternalLinkage:
 128     // External and linkonce definitions are converted to available_externally
 129     // definitions upon import, so that they are available for inlining
 130     // and/or optimization, but are turned into declarations later
 131     // during the EliminateAvailableExternally pass.
 132     if (doImportAsDefinition(SGV) && !isa<GlobalAlias>(SGV))
 133       return GlobalValue::AvailableExternallyLinkage;
 134     // An imported external declaration stays external.
 135     return SGV->getLinkage();
 136
 137   case GlobalValue::AvailableExternallyLinkage:
 138     // An imported available_externally definition converts
 139     // to external if imported as a declaration.
 140     if (!doImportAsDefinition(SGV))
 141       return GlobalValue::ExternalLinkage;
 142     // An imported available_externally declaration stays that way.
 143     return SGV->getLinkage();
 144
 145   case GlobalValue::LinkOnceAnyLinkage:
 146   case GlobalValue::WeakAnyLinkage:
 147     // Can't import linkonce_any/weak_any definitions correctly, or we might
 148     // change the program semantics, since the linker will pick the first
 149     // linkonce_any/weak_any definition and importing would change the order
 150     // they are seen by the linker. The module linking caller needs to enforce
 151     // this.
 152     assert(!doImportAsDefinition(SGV));
 153     // If imported as a declaration, it becomes external_weak.
 154     return SGV->getLinkage();
 155
 156   case GlobalValue::WeakODRLinkage:
 157     // For weak_odr linkage, there is a guarantee that all copies will be
 158     // equivalent, so the issue described above for weak_any does not exist,
 159     // and the definition can be imported. It can be treated similarly
 160     // to an imported externally visible global value.
 161     if (doImportAsDefinition(SGV) && !isa<GlobalAlias>(SGV))
 162       return GlobalValue::AvailableExternallyLinkage;
 163     else
 164       return GlobalValue::ExternalLinkage;
 165
 166   case GlobalValue::AppendingLinkage:
 167     // It would be incorrect to import an appending linkage variable,
 168     // since it would cause global constructors/destructors to be
 169     // executed multiple times. This should have already been handled
 170     // by linkIfNeeded, and we will assert in shouldLinkFromSource
 171     // if we try to import, so we simply return AppendingLinkage.
 172     return GlobalValue::AppendingLinkage;
 173
 174   case GlobalValue::InternalLinkage:
 175   case GlobalValue::PrivateLinkage:
 176     // If we are promoting the local to global scope, it is handled
 177     // similarly to a normal externally visible global.
 178     if (DoPromote) {
 179       if (doImportAsDefinition(SGV) && !isa<GlobalAlias>(SGV))
 180         return GlobalValue::AvailableExternallyLinkage;
 181       else
 182         return GlobalValue::ExternalLinkage;
 183     }
 184     // A non-promoted imported local definition stays local.
 185     // The ThinLTO pass will eventually force-import their definitions.
 186     return SGV->getLinkage();
 187
 188   case GlobalValue::ExternalWeakLinkage:
 189     // External weak doesn't apply to definitions, must be a declaration.
 190     assert(!doImportAsDefinition(SGV));
 191     // Linkage stays external_weak.
 192     return SGV->getLinkage();
 193
 194   case GlobalValue::CommonLinkage:
 195     // Linkage stays common on definitions.
 196     // The ThinLTO pass will eventually force-import their definitions.
 197     return SGV->getLinkage();
 198   }
 199
 200   llvm_unreachable("unknown linkage type");
 201 }
 202
 203 void FunctionImportGlobalProcessing::processGlobalForThinLTO(GlobalValue &GV) {
 204
 205   ValueInfo VI;
 206   if (GV.hasName()) {
 207     VI = ImportIndex.getValueInfo(GV.getGUID());
 208     // Set synthetic function entry counts.
 209     if (VI && ImportIndex.hasSyntheticEntryCounts()) {
 210       if (Function *F = dyn_cast<Function>(&GV)) {
 211         if (!F->isDeclaration()) {
 212           for (auto &S : VI.getSummaryList()) {
 213             FunctionSummary *FS = dyn_cast<FunctionSummary>(S->getBaseObject());
 214             if (FS->modulePath() == M.getModuleIdentifier()) {
 215               F->setEntryCount(Function::ProfileCount(FS->entryCount(),
 216                                                       Function::PCT_Synthetic));
 217               break;
 218             }
 219           }
 220         }
 221       }
 222     }
 223     // Check the summaries to see if the symbol gets resolved to a known local
 224     // definition.
 225     if (VI && VI.isDSOLocal()) {
 226       GV.setDSOLocal(true);
 227       if (GV.hasDLLImportStorageClass())
 228         GV.setDLLStorageClass(GlobalValue::DefaultStorageClass);
 229     }
 230   }
 231
 232   // Mark read/write-only variables which can be imported with specific
 233   // attribute. We can't internalize them now because IRMover will fail
 234   // to link variable definitions to their external declarations during
 235   // ThinLTO import. We'll internalize read-only variables later, after
 236   // import is finished. See internalizeGVsAfterImport.
 237   //
 238   // If global value dead stripping is not enabled in summary then
 239   // propagateConstants hasn't been run. We can't internalize GV
 240   // in such case.
 241   if (!GV.isDeclaration() && VI && ImportIndex.withGlobalValueDeadStripping()) {
 242     const auto &SL = VI.getSummaryList();
 243     auto *GVS = SL.empty() ? nullptr : dyn_cast<GlobalVarSummary>(SL[0].get());
 244     // At this stage "maybe" is "definitely"
 245     if (GVS && (GVS->maybeReadOnly() || GVS->maybeWriteOnly()))
 246       cast<GlobalVariable>(&GV)->addAttribute("thinlto-internalize");
 247   }
 248
 249   bool DoPromote = false;
 250   if (GV.hasLocalLinkage() &&
 251       ((DoPromote = shouldPromoteLocalToGlobal(&GV)) || isPerformingImport())) {
 252     // Save the original name string before we rename GV below.
 253     auto Name = GV.getName().str();
 254     // Once we change the name or linkage it is difficult to determine
 255     // again whether we should promote since shouldPromoteLocalToGlobal needs
 256     // to locate the summary (based on GUID from name and linkage). Therefore,
 257     // use DoPromote result saved above.
 258     GV.setName(getName(&GV, DoPromote));
 259     GV.setLinkage(getLinkage(&GV, DoPromote));
 260     if (!GV.hasLocalLinkage())
 261       GV.setVisibility(GlobalValue::HiddenVisibility);
 262
 263     // If we are renaming a COMDAT leader, ensure that we record the COMDAT
 264     // for later renaming as well. This is required for COFF.
 265     if (const auto *C = GV.getComdat())
 266       if (C->getName() == Name)
 267         RenamedComdats.try_emplace(C, M.getOrInsertComdat(GV.getName()));
 268   } else
 269     GV.setLinkage(getLinkage(&GV, /* DoPromote */ false));
 270
 271   // Remove functions imported as available externally defs from comdats,
 272   // as this is a declaration for the linker, and will be dropped eventually.
 273   // It is illegal for comdats to contain declarations.
 274   auto *GO = dyn_cast<GlobalObject>(&GV);
 275   if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) {
 276     // The IRMover should not have placed any imported declarations in
 277     // a comdat, so the only declaration that should be in a comdat
 278     // at this point would be a definition imported as available_externally.
 279     assert(GO->hasAvailableExternallyLinkage() &&
 280            "Expected comdat on definition (possibly available external)");
 281     GO->setComdat(nullptr);
 282   }
 283 }
 284
 285 void FunctionImportGlobalProcessing::processGlobalsForThinLTO() {
 286   for (GlobalVariable &GV : M.globals())
 287     processGlobalForThinLTO(GV);
 288   for (Function &SF : M)
 289     processGlobalForThinLTO(SF);
 290   for (GlobalAlias &GA : M.aliases())
 291     processGlobalForThinLTO(GA);
 292
 293   // Replace any COMDATS that required renaming (because the COMDAT leader was
 294   // promoted and renamed).
 295   if (!RenamedComdats.empty())
 296     for (auto &GO : M.global_objects())
 297       if (auto *C = GO.getComdat()) {
 298         auto Replacement = RenamedComdats.find(C);
 299         if (Replacement != RenamedComdats.end())
 300           GO.setComdat(Replacement->second);
 301       }
 302 }
 303
 304 bool FunctionImportGlobalProcessing::run() {
 305   processGlobalsForThinLTO();
 306   return false;
 307 }
 308
 309 bool llvm::renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index,
 310                                   SetVector<GlobalValue *> *GlobalsToImport) {
 311   FunctionImportGlobalProcessing ThinLTOProcessing(M, Index, GlobalsToImport);
 312   return ThinLTOProcessing.run();
 313 }