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

   1 //===- lib/Transforms/Utils/FunctionImportUtils.cpp - Importing utilities -===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the FunctionImportGlobalProcessing class, used
  11 // to perform the necessary global value handling for function importing.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
  16 #include "llvm/IR/InstIterator.h"
  17 using namespace llvm;
  18
  19 /// Checks if we should import SGV as a definition, otherwise import as a
  20 /// declaration.
  21 bool FunctionImportGlobalProcessing::doImportAsDefinition(
  22     const GlobalValue *SGV, SetVector<GlobalValue *> *GlobalsToImport) {
  23
  24   // Only import the globals requested for importing.
  25   if (!GlobalsToImport->count(const_cast<GlobalValue *>(SGV)))
  26     return false;
  27
  28   assert(!isa<GlobalAlias>(SGV) &&
  29          "Unexpected global alias in the import list.");
  30
  31   // Otherwise yes.
  32   return true;
  33 }
  34
  35 bool FunctionImportGlobalProcessing::doImportAsDefinition(
  36     const GlobalValue *SGV) {
  37   if (!isPerformingImport())
  38     return false;
  39   return FunctionImportGlobalProcessing::doImportAsDefinition(SGV,
  40                                                               GlobalsToImport);
  41 }
  42
  43 bool FunctionImportGlobalProcessing::shouldPromoteLocalToGlobal(
  44     const GlobalValue *SGV) {
  45   assert(SGV->hasLocalLinkage());
  46   // Both the imported references and the original local variable must
  47   // be promoted.
  48   if (!isPerformingImport() && !isModuleExporting())
  49     return false;
  50
  51   if (isPerformingImport()) {
  52     assert((!GlobalsToImport->count(const_cast<GlobalValue *>(SGV)) ||
  53             !isNonRenamableLocal(*SGV)) &&
  54            "Attempting to promote non-renamable local");
  55     // We don't know for sure yet if we are importing this value (as either
  56     // a reference or a def), since we are simply walking all values in the
  57     // module. But by necessity if we end up importing it and it is local,
  58     // it must be promoted, so unconditionally promote all values in the
  59     // importing module.
  60     return true;
  61   }
  62
  63   // When exporting, consult the index. We can have more than one local
  64   // with the same GUID, in the case of same-named locals in different but
  65   // same-named source files that were compiled in their respective directories
  66   // (so the source file name and resulting GUID is the same). Find the one
  67   // in this module.
  68   auto Summary = ImportIndex.findSummaryInModule(
  69       SGV->getGUID(), SGV->getParent()->getModuleIdentifier());
  70   assert(Summary && "Missing summary for global value when exporting");
  71   auto Linkage = Summary->linkage();
  72   if (!GlobalValue::isLocalLinkage(Linkage)) {
  73     assert(!isNonRenamableLocal(*SGV) &&
  74            "Attempting to promote non-renamable local");
  75     return true;
  76   }
  77
  78   return false;
  79 }
  80
  81 #ifndef NDEBUG
  82 bool FunctionImportGlobalProcessing::isNonRenamableLocal(
  83     const GlobalValue &GV) const {
  84   if (!GV.hasLocalLinkage())
  85     return false;
  86   // This needs to stay in sync with the logic in buildModuleSummaryIndex.
  87   if (GV.hasSection())
  88     return true;
  89   if (Used.count(const_cast<GlobalValue *>(&GV)))
  90     return true;
  91   return false;
  92 }
  93 #endif
  94
  95 std::string FunctionImportGlobalProcessing::getName(const GlobalValue *SGV,
  96                                                     bool DoPromote) {
  97   // For locals that must be promoted to global scope, ensure that
  98   // the promoted name uniquely identifies the copy in the original module,
  99   // using the ID assigned during combined index creation. When importing,
 100   // we rename all locals (not just those that are promoted) in order to
 101   // avoid naming conflicts between locals imported from different modules.
 102   if (SGV->hasLocalLinkage() && (DoPromote || isPerformingImport()))
 103     return ModuleSummaryIndex::getGlobalNameForLocal(
 104         SGV->getName(),
 105         ImportIndex.getModuleHash(SGV->getParent()->getModuleIdentifier()));
 106   return SGV->getName();
 107 }
 108
 109 GlobalValue::LinkageTypes
 110 FunctionImportGlobalProcessing::getLinkage(const GlobalValue *SGV,
 111                                            bool DoPromote) {
 112   // Any local variable that is referenced by an exported function needs
 113   // to be promoted to global scope. Since we don't currently know which
 114   // functions reference which local variables/functions, we must treat
 115   // all as potentially exported if this module is exporting anything.
 116   if (isModuleExporting()) {
 117     if (SGV->hasLocalLinkage() && DoPromote)
 118       return GlobalValue::ExternalLinkage;
 119     return SGV->getLinkage();
 120   }
 121
 122   // Otherwise, if we aren't importing, no linkage change is needed.
 123   if (!isPerformingImport())
 124     return SGV->getLinkage();
 125
 126   switch (SGV->getLinkage()) {
 127   case GlobalValue::LinkOnceAnyLinkage:
 128   case GlobalValue::LinkOnceODRLinkage:
 129   case GlobalValue::ExternalLinkage:
 130     // External and linkonce definitions are converted to available_externally
 131     // definitions upon import, so that they are available for inlining
 132     // and/or optimization, but are turned into declarations later
 133     // during the EliminateAvailableExternally pass.
 134     if (doImportAsDefinition(SGV) && !dyn_cast<GlobalAlias>(SGV))
 135       return GlobalValue::AvailableExternallyLinkage;
 136     // An imported external declaration stays external.
 137     return SGV->getLinkage();
 138
 139   case GlobalValue::AvailableExternallyLinkage:
 140     // An imported available_externally definition converts
 141     // to external if imported as a declaration.
 142     if (!doImportAsDefinition(SGV))
 143       return GlobalValue::ExternalLinkage;
 144     // An imported available_externally declaration stays that way.
 145     return SGV->getLinkage();
 146
 147   case GlobalValue::WeakAnyLinkage:
 148     // Can't import weak_any definitions correctly, or we might change the
 149     // program semantics, since the linker will pick the first weak_any
 150     // definition and importing would change the order they are seen by the
 151     // linker. The module linking caller needs to enforce 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) && !dyn_cast<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) && !dyn_cast<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   // Check the summaries to see if the symbol gets resolved to a known local
 206   // definition.
 207   if (GV.hasName()) {
 208     ValueInfo VI = ImportIndex.getValueInfo(GV.getGUID());
 209     if (VI && VI.isDSOLocal()) {
 210       GV.setDSOLocal(true);
 211       if (GV.hasDLLImportStorageClass())
 212         GV.setDLLStorageClass(GlobalValue::DefaultStorageClass);
 213     }
 214   }
 215
 216   bool DoPromote = false;
 217   if (GV.hasLocalLinkage() &&
 218       ((DoPromote = shouldPromoteLocalToGlobal(&GV)) || isPerformingImport())) {
 219     // Once we change the name or linkage it is difficult to determine
 220     // again whether we should promote since shouldPromoteLocalToGlobal needs
 221     // to locate the summary (based on GUID from name and linkage). Therefore,
 222     // use DoPromote result saved above.
 223     GV.setName(getName(&GV, DoPromote));
 224     GV.setLinkage(getLinkage(&GV, DoPromote));
 225     if (!GV.hasLocalLinkage())
 226       GV.setVisibility(GlobalValue::HiddenVisibility);
 227   } else
 228     GV.setLinkage(getLinkage(&GV, /* DoPromote */ false));
 229
 230   // Remove functions imported as available externally defs from comdats,
 231   // as this is a declaration for the linker, and will be dropped eventually.
 232   // It is illegal for comdats to contain declarations.
 233   auto *GO = dyn_cast_or_null<GlobalObject>(&GV);
 234   if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) {
 235     // The IRMover should not have placed any imported declarations in
 236     // a comdat, so the only declaration that should be in a comdat
 237     // at this point would be a definition imported as available_externally.
 238     assert(GO->hasAvailableExternallyLinkage() &&
 239            "Expected comdat on definition (possibly available external)");
 240     GO->setComdat(nullptr);
 241   }
 242 }
 243
 244 void FunctionImportGlobalProcessing::processGlobalsForThinLTO() {
 245   for (GlobalVariable &GV : M.globals())
 246     processGlobalForThinLTO(GV);
 247   for (Function &SF : M)
 248     processGlobalForThinLTO(SF);
 249   for (GlobalAlias &GA : M.aliases())
 250     processGlobalForThinLTO(GA);
 251 }
 252
 253 bool FunctionImportGlobalProcessing::run() {
 254   processGlobalsForThinLTO();
 255   return false;
 256 }
 257
 258 bool llvm::renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index,
 259                                   SetVector<GlobalValue *> *GlobalsToImport) {
 260   FunctionImportGlobalProcessing ThinLTOProcessing(M, Index, GlobalsToImport);
 261   return ThinLTOProcessing.run();
 262 }