[ThinLTO] Drop dso_local if a GlobalVariable satisfies isDeclarationForLinker()

[MaskRay]

Summary

dso_local leads to direct access even if the definition is not within this compilation unit (it is
still in the same linkage unit). On ELF, such a relocation (e.g. R_X86_64_PC32) referencing a
STB_GLOBAL STV_DEFAULT object can cause a linker error in a -shared link.

If the linkage is changed to available_externally, the dso_local flag should be dropped, so that no
direct access will be generated.

The current behavior is benign, because -fpic does not assume dso_local
(clang/lib/CodeGen/CodeGenModule.cpp:shouldAssumeDSOLocal).
If we do that for -fno-semantic-interposition (D73865), there will be an
R_X86_64_PC32 linker error without this patch.

[tejohnson]

llvm/include/llvm/Transforms/Utils/FunctionImportUtils.h

42

Needs comment. Also, maybe something more specific like ClearDSOLocalOnDeclarations ? Better yet, something that communicates what the condition is like IsPic.

127–128

Is a consistent name for the variable.

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

218

It seems like we'd want to do the same thing here in the old LTO API whenever we have a TM (some of the callers of these routines do).

llvm/lib/Transforms/IPO/FunctionImport.cpp

1306–1307

document constant parameter, here and elsewhere (I see that is missing for the existing nullptr param, but better to not add more cases like that).

llvm/lib/Transforms/Utils/FunctionImportUtils.cpp

276

Needs comment.

[MaskRay]

Address comments

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

218

Added some comments.

May I ask what is the old LTO API? Are most functions in ThinLTOCodeGenerator.cpp related to the old LTO API?

I try passing ClearDSOLocalOnDeclarations as long as the information is available. llvm-lto.cpp:707 ThinGenerator.crossModuleImport(*TheModule, *Index, *Input); does not pass the information.

[tejohnson]

Needs tests (both llvm-lto and llvm-lto2 to cover both old and new LTO APIs, respectively. For llvm-lto you can trigger the modified code via the -thinlto-action=run option.

llvm/include/llvm/Transforms/Utils/FunctionImportUtils.h

127–128

That should have been "Use" a consistent name for variable btw. Please use "ClearDSOLocalOnDeclarations" for consistency.

llvm/lib/LTO/LTOBackend.cpp

556–557

Clang format

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

218

The old LTO API is used by linkers such as ld64 and Sony's proprietary linker and possibly others. I'm not sure if there are any that are ELF, but good to keep this up to date there as well since we still support both.

A few of these methods are only used for testing by llvm-lto, where we don't have a TM, so it's fine to skip it there.

llvm/lib/Transforms/Utils/FunctionImportUtils.cpp

276

s/is GV is/if GV is/

[MaskRay]

Address review comments

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

218

It seems that the D35702 logic does not apply to the old API. GlobalValueSummary::setDSOLocal is never called.

// lib/LTO/LTO.cpp
      if (Res.FinalDefinitionInLinkageUnit) {
        if (auto S = ThinLTO.CombinedIndex.findSummaryInModule(
                GUID, BM.getModuleIdentifier())) {
          S->setDSOLocal(true);
        }
      }

Nevertheless, I added

; RUN: llvm-lto -thinlto-action=run %t1.bc %t2.bc -thinlto-save-temps=%t5.
; RUN: llvm-dis < %t5.1.3.imported.bc | FileCheck %s --check-prefix=OLDAPI_SRC

[MaskRay]

Add proper old API tests to index-const-prop-gvref.ll
I can add dso_local to Inputs/index-const-prop-gvref.ll to exercise the code path for old API.

[MaskRay]

Ping :)

[tejohnson]

LGTM

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

218

I see. Good to have the fix / test in place in case it ever gets supported there.

llvm/include/llvm/Transforms/IPO/FunctionImport.h

public:
   /// The set contains an entry for every global value the module exports.
   using ExportSetTy = DenseSet<ValueInfo>;
 
   /// A function of this type is used to load modules referenced by the index.
   using ModuleLoaderTy =
       std::function<Expected<std::unique_ptr<Module>>(StringRef Identifier)>;
 
   /// Create a Function Importer.
-  FunctionImporter(const ModuleSummaryIndex &Index, ModuleLoaderTy ModuleLoader)
-      : Index(Index), ModuleLoader(std::move(ModuleLoader)) {}
+  FunctionImporter(const ModuleSummaryIndex &Index, ModuleLoaderTy ModuleLoader,
+                   bool ClearDSOLocalOnDeclarations)
+      : Index(Index), ModuleLoader(std::move(ModuleLoader)),
+        ClearDSOLocalOnDeclarations(ClearDSOLocalOnDeclarations) {}
 
   /// Import functions in Module \p M based on the supplied import list.
   Expected<bool> importFunctions(Module &M, const ImportMapTy &ImportList);
 
 private:
   /// The summaries index used to trigger importing.
   const ModuleSummaryIndex &Index;
 
   /// Factory function to load a Module for a given identifier
   ModuleLoaderTy ModuleLoader;
+
+  /// See the comment of ClearDSOLocalOnDeclarations in
+  /// Utils/FunctionImportUtils.h.
+  bool ClearDSOLocalOnDeclarations;
 };
 
 /// The function importing pass
 class FunctionImportPass : public PassInfoMixin<FunctionImportPass> {
 public:
   PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
 };
 

llvm/include/llvm/Transforms/Utils/FunctionImportUtils.h

class FunctionImportGlobalProcessing {
   SetVector<GlobalValue *> *GlobalsToImport;
 
   /// Set to true if the given ModuleSummaryIndex contains any functions
   /// from this source module, in which case we must conservatively assume
   /// that any of its functions may be imported into another module
   /// as part of a different backend compilation process.
   bool HasExportedFunctions = false;
 
+  /// Set to true (only applicatable to ELF -fpic) if dso_local should be
+  /// dropped for a declaration.
+  ///
+  /// On ELF, the assembler is conservative and assumes a global default
+  /// visibility symbol can be interposable. No direct access relocation is
+  /// allowed, if the definition is not in the translation unit, even if the
+  /// definition is available in the linkage unit. Thus we need to clear
+  /// dso_local to disable direct access.
+  ///
+  /// This flag should not be set for -fno-pic or -fpie, which would
+  /// unnecessarily disable direct access.
+  bool ClearDSOLocalOnDeclarations;
+
   /// Set of llvm.*used values, in order to validate that we don't try
   /// to promote any non-renamable values.
   SmallPtrSet<GlobalValue *, 8> Used;
 
   /// Keep track of any COMDATs that require renaming (because COMDAT
   /// leader was promoted and renamed). Maps from original COMDAT to one
   /// with new name.
   DenseMap<const Comdat *, Comdat *> RenamedComdats;
#endif
 
   /// Get the new linkage for SGV that should be used in the linked destination
   /// module. Specifically, for ThinLTO importing or exporting it may need
   /// to be adjusted. When \p DoPromote is true then we must adjust the
   /// linkage for a required promotion of a local to global scope.
   GlobalValue::LinkageTypes getLinkage(const GlobalValue *SGV, bool DoPromote);
 
 public:
-  FunctionImportGlobalProcessing(
-      Module &M, const ModuleSummaryIndex &Index,
-      SetVector<GlobalValue *> *GlobalsToImport = nullptr)
-      : M(M), ImportIndex(Index), GlobalsToImport(GlobalsToImport) {
+  FunctionImportGlobalProcessing(Module &M, const ModuleSummaryIndex &Index,
+                                 SetVector<GlobalValue *> *GlobalsToImport,
+                                 bool ClearDSOLocalOnDeclarations)
+      : M(M), ImportIndex(Index), GlobalsToImport(GlobalsToImport),
+        ClearDSOLocalOnDeclarations(ClearDSOLocalOnDeclarations) {
     // If we have a ModuleSummaryIndex but no function to import,
     // then this is the primary module being compiled in a ThinLTO
     // backend compilation, and we need to see if it has functions that
     // may be exported to another backend compilation.
     if (!GlobalsToImport)
       HasExportedFunctions = ImportIndex.hasExportedFunctions(M);
 
 #ifndef NDEBUG
     // First collect those in the llvm.used set.
     collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ false);
     // Next collect those in the llvm.compiler.used set.
     collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ true);
 #endif
   }
 
   bool run();
 };
 
 /// Perform in-place global value handling on the given Module for
 /// exported local functions renamed and promoted for ThinLTO.
 bool renameModuleForThinLTO(
     Module &M, const ModuleSummaryIndex &Index,
+    bool ClearDSOLocalOnDeclarations,
     SetVector<GlobalValue *> *GlobalsToImport = nullptr);
 
 /// Compute synthetic function entry counts.
 void computeSyntheticCounts(ModuleSummaryIndex &Index);
 
 } // End llvm namespace
 
 #endif

llvm/lib/LTO/LTOBackend.cpp

Error lto::thinBackend(const Config &Conf, unsigned Task, AddStreamFn AddStream,
   if (Conf.CodeGenOnly) {
     codegen(Conf, TM.get(), AddStream, Task, Mod);
     return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
   }
 
   if (Conf.PreOptModuleHook && !Conf.PreOptModuleHook(Task, Mod))
     return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
 
-  renameModuleForThinLTO(Mod, CombinedIndex);
+  // When linking an ELF shared object, dso_local should be dropped. We
+  // conservatively do this for -fpic.
+  bool ClearDSOLocalOnDeclarations =
+      TM->getTargetTriple().isOSBinFormatELF() &&
+      TM->getRelocationModel() != Reloc::Static &&
+      Mod.getPIELevel() == PIELevel::Default;
+  renameModuleForThinLTO(Mod, CombinedIndex, ClearDSOLocalOnDeclarations);
 
   dropDeadSymbols(Mod, DefinedGlobals, CombinedIndex);
 
   thinLTOResolvePrevailingInModule(Mod, DefinedGlobals);
 
   if (Conf.PostPromoteModuleHook && !Conf.PostPromoteModuleHook(Task, Mod))
     return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
 
assert(Mod.getContext().isODRUniquingDebugTypes() &&
            "ODR Type uniquing should be enabled on the context");
     auto I = ModuleMap.find(Identifier);
     assert(I != ModuleMap.end());
     return I->second.getLazyModule(Mod.getContext(),
                                    /*ShouldLazyLoadMetadata=*/true,
                                    /*IsImporting*/ true);
   };
 
-  FunctionImporter Importer(CombinedIndex, ModuleLoader);
+  FunctionImporter Importer(CombinedIndex, ModuleLoader,
+                            ClearDSOLocalOnDeclarations);
   if (Error Err = Importer.importFunctions(Mod, ImportList).takeError())
     return Err;
 
   if (Conf.PostImportModuleHook && !Conf.PostImportModuleHook(Task, Mod))
     return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
 
   if (!opt(Conf, TM.get(), Task, Mod, /*IsThinLTO=*/true,
            /*ExportSummary=*/nullptr, /*ImportSummary=*/&CombinedIndex))
     return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
 
   codegen(Conf, TM.get(), AddStream, Task, Mod);
   return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
 }

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

generateModuleMap(std::vector<std::unique_ptr<lto::InputFile>> &Modules) {
   for (auto &M : Modules) {
     assert(ModuleMap.find(M->getName()) == ModuleMap.end() &&
            "Expect unique Buffer Identifier");
     ModuleMap[M->getName()] = M.get();
   }
   return ModuleMap;
 }
 
-static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index) {
-  if (renameModuleForThinLTO(TheModule, Index))
+static void promoteModule(Module &TheModule, const ModuleSummaryIndex &Index,
+                          bool ClearDSOLocalOnDeclarations) {
+  if (renameModuleForThinLTO(TheModule, Index, ClearDSOLocalOnDeclarations))
     report_fatal_error("renameModuleForThinLTO failed");
 }
 
 namespace {
 class ThinLTODiagnosticInfo : public DiagnosticInfo {
   const Twine &Msg;
 public:
   ThinLTODiagnosticInfo(const Twine &DiagMsg,
static std::unique_ptr<Module> loadModuleFromInput(lto::InputFile *Input,
   }
   if (!Lazy)
     verifyLoadedModule(*ModuleOrErr.get());
   return std::move(*ModuleOrErr);
 }
 
 static void
 crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index,
-                      StringMap<lto::InputFile*> &ModuleMap,
-                      const FunctionImporter::ImportMapTy &ImportList) {
+                      StringMap<lto::InputFile *> &ModuleMap,
+                      const FunctionImporter::ImportMapTy &ImportList,
+                      bool ClearDSOLocalOnDeclarations) {
   auto Loader = [&](StringRef Identifier) {
     auto &Input = ModuleMap[Identifier];
     return loadModuleFromInput(Input, TheModule.getContext(),
                                /*Lazy=*/true, /*IsImporting*/ true);
   };
 
-  FunctionImporter Importer(Index, Loader);
+  FunctionImporter Importer(Index, Loader, ClearDSOLocalOnDeclarations);
   Expected<bool> Result = Importer.importFunctions(TheModule, ImportList);
   if (!Result) {
     handleAllErrors(Result.takeError(), [&](ErrorInfoBase &EIB) {
       SMDiagnostic Err = SMDiagnostic(TheModule.getModuleIdentifier(),
                                       SourceMgr::DK_Error, EIB.message());
       Err.print("ThinLTO", errs());
     });
     report_fatal_error("importFunctions failed");
ProcessThinLTOModule(Module &TheModule, ModuleSummaryIndex &Index,
                      const GVSummaryMapTy &DefinedGlobals,
                      const ThinLTOCodeGenerator::CachingOptions &CacheOptions,
                      bool DisableCodeGen, StringRef SaveTempsDir,
                      bool Freestanding, unsigned OptLevel, unsigned count) {
 
   // "Benchmark"-like optimization: single-source case
   bool SingleModule = (ModuleMap.size() == 1);
 
+  // When linking an ELF shared object, dso_local should be dropped. We
+  // conservatively do this for -fpic.
+  bool ClearDSOLocalOnDeclarations =
+      TM.getTargetTriple().isOSBinFormatELF() &&
+      TM.getRelocationModel() != Reloc::Static &&
+      TheModule.getPIELevel() == PIELevel::Default;
+
   if (!SingleModule) {
-    promoteModule(TheModule, Index);
+    promoteModule(TheModule, Index, ClearDSOLocalOnDeclarations);
 
     // Apply summary-based prevailing-symbol resolution decisions.
     thinLTOResolvePrevailingInModule(TheModule, DefinedGlobals);
 
     // Save temps: after promotion.
     saveTempBitcode(TheModule, SaveTempsDir, count, ".1.promoted.bc");
   }
 
   // Be friendly and don't nuke totally the module when the client didn't
   // supply anything to preserve.
   if (!ExportList.empty() || !GUIDPreservedSymbols.empty()) {
     // Apply summary-based internalization decisions.
     thinLTOInternalizeModule(TheModule, DefinedGlobals);
   }
 
   // Save internalized bitcode
   saveTempBitcode(TheModule, SaveTempsDir, count, ".2.internalized.bc");
 
   if (!SingleModule) {
-    crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
+    crossImportIntoModule(TheModule, Index, ModuleMap, ImportList,
+                          ClearDSOLocalOnDeclarations);
 
     // Save temps: after cross-module import.
     saveTempBitcode(TheModule, SaveTempsDir, count, ".3.imported.bc");
   }
 
   optimizeModule(TheModule, TM, OptLevel, Freestanding, &Index);
 
   saveTempBitcode(TheModule, SaveTempsDir, count, ".4.opt.bc");
thinLTOResolvePrevailingInModule(
       TheModule, ModuleToDefinedGVSummaries[ModuleIdentifier]);
 
   // Promote the exported values in the index, so that they are promoted
   // in the module.
   thinLTOInternalizeAndPromoteInIndex(
       Index, IsExported(ExportLists, GUIDPreservedSymbols),
       IsPrevailing(PrevailingCopy));
 
-  promoteModule(TheModule, Index);
+  // FIXME Set ClearDSOLocalOnDeclarations.
+  promoteModule(TheModule, Index, /*ClearDSOLocalOnDeclarations=*/false);
 }
 
 /**
  * Perform cross-module importing for the module identified by ModuleIdentifier.
  */
 void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
                                              ModuleSummaryIndex &Index,
                                              const lto::InputFile &File) {
void ThinLTOCodeGenerator::crossModuleImport(Module &TheModule,
 
   // Generate import/export list
   StringMap<FunctionImporter::ImportMapTy> ImportLists(ModuleCount);
   StringMap<FunctionImporter::ExportSetTy> ExportLists(ModuleCount);
   ComputeCrossModuleImport(Index, ModuleToDefinedGVSummaries, ImportLists,
                            ExportLists);
   auto &ImportList = ImportLists[TheModule.getModuleIdentifier()];
 
-  crossImportIntoModule(TheModule, Index, ModuleMap, ImportList);
+  // FIXME Set ClearDSOLocalOnDeclarations.
+  crossImportIntoModule(TheModule, Index, ModuleMap, ImportList,
+                        /*ClearDSOLocalOnDeclarations=*/false);
 }
 
 /**
  * Compute the list of summaries needed for importing into module.
  */
 void ThinLTOCodeGenerator::gatherImportedSummariesForModule(
     Module &TheModule, ModuleSummaryIndex &Index,
     std::map<std::string, GVSummaryMapTy> &ModuleToSummariesForIndex,
resolvePrevailingInIndex(Index, ResolvedODR, GUIDPreservedSymbols,
                            PrevailingCopy);
 
   // Promote the exported values in the index, so that they are promoted
   // in the module.
   thinLTOInternalizeAndPromoteInIndex(
       Index, IsExported(ExportLists, GUIDPreservedSymbols),
       IsPrevailing(PrevailingCopy));
 
-  promoteModule(TheModule, Index);
+  // FIXME Set ClearDSOLocalOnDeclarations.
+  promoteModule(TheModule, Index, /*ClearDSOLocalOnDeclarations=*/false);
 
   // Internalization
   thinLTOResolvePrevailingInModule(
       TheModule, ModuleToDefinedGVSummaries[ModuleIdentifier]);
 
   thinLTOInternalizeModule(TheModule,
                            ModuleToDefinedGVSummaries[ModuleIdentifier]);
 }

llvm/lib/Transforms/IPO/FunctionImport.cpp

for (GlobalAlias &GA : SrcModule->aliases()) {
       }
     }
 
     // Upgrade debug info after we're done materializing all the globals and we
     // have loaded all the required metadata!
     UpgradeDebugInfo(*SrcModule);
 
     // Link in the specified functions.
-    if (renameModuleForThinLTO(*SrcModule, Index, &GlobalsToImport))
+    if (renameModuleForThinLTO(*SrcModule, Index, ClearDSOLocalOnDeclarations,
+                               &GlobalsToImport))
       return true;
 
     if (PrintImports) {
       for (const auto *GV : GlobalsToImport)
         dbgs() << DestModule.getSourceFileName() << ": Import " << GV->getName()
                << " from " << SrcModule->getSourceFileName() << "\n";
     }
 
for (auto &I : *Index) {
     for (auto &S : I.second.SummaryList) {
       if (GlobalValue::isLocalLinkage(S->linkage()))
         S->setLinkage(GlobalValue::ExternalLinkage);
     }
   }
 
   // Next we need to promote to global scope and rename any local values that
   // are potentially exported to other modules.
-  if (renameModuleForThinLTO(M, *Index, nullptr)) {
+  if (renameModuleForThinLTO(M, *Index, /*clearDSOOnDeclarations=*/false,
+                             /*GlobalsToImport=*/nullptr)) {
     errs() << "Error renaming module\n";
     return false;
   }
 
   // Perform the import now.
   auto ModuleLoader = [&M](StringRef Identifier) {
     return loadFile(std::string(Identifier), M.getContext());
   };
-  FunctionImporter Importer(*Index, ModuleLoader);
+  FunctionImporter Importer(*Index, ModuleLoader,
+                            /*ClearDSOLocalOnDeclarations=*/false);
   Expected<bool> Result = Importer.importFunctions(M, ImportList);
 
   // FIXME: Probably need to propagate Errors through the pass manager.
   if (!Result) {
     logAllUnhandledErrors(Result.takeError(), errs(),
                           "Error importing module: ");
     return false;
   }

llvm/lib/Transforms/Utils/FunctionImportUtils.cpp

if (VI && ImportIndex.hasSyntheticEntryCounts()) {
               F->setEntryCount(Function::ProfileCount(FS->entryCount(),
                                                       Function::PCT_Synthetic));
               break;
             }
           }
         }
       }
     }
-    // Check the summaries to see if the symbol gets resolved to a known local
-    // definition.
-    if (VI && VI.isDSOLocal()) {
-      GV.setDSOLocal(true);
-      if (GV.hasDLLImportStorageClass())
-        GV.setDLLStorageClass(GlobalValue::DefaultStorageClass);
-    }
   }
 
   // We should always have a ValueInfo (i.e. GV in index) for definitions when
   // we are exporting, and also when importing that value.
   assert(VI || GV.isDeclaration() ||
          (isPerformingImport() && !doImportAsDefinition(&GV)));
 
   // Mark read/write-only variables which can be imported with specific
if (GV.hasLocalLinkage() && shouldPromoteLocalToGlobal(&GV, VI)) {
     // If we are renaming a COMDAT leader, ensure that we record the COMDAT
     // for later renaming as well. This is required for COFF.
     if (const auto *C = GV.getComdat())
       if (C->getName() == Name)
         RenamedComdats.try_emplace(C, M.getOrInsertComdat(GV.getName()));
   } else
     GV.setLinkage(getLinkage(&GV, /* DoPromote */ false));
 
+  // When ClearDSOLocalOnDeclarations is true, clear dso_local if GV is
+  // converted to a declaration, to disable direct access. Don't do this if GV
+  // is implicitly dso_local due to a non-default visibility.
+  if (ClearDSOLocalOnDeclarations && GV.isDeclarationForLinker() &&
+      !GV.isImplicitDSOLocal()) {
+    GV.setDSOLocal(false);
+  } else if (VI && VI.isDSOLocal()) {
+    // If all summaries are dso_local, symbol gets resolved to a known local
+    // definition.
+    GV.setDSOLocal(true);
+    if (GV.hasDLLImportStorageClass())
+      GV.setDLLStorageClass(GlobalValue::DefaultStorageClass);
+  }
+
   // Remove functions imported as available externally defs from comdats,
   // as this is a declaration for the linker, and will be dropped eventually.
   // It is illegal for comdats to contain declarations.
   auto *GO = dyn_cast<GlobalObject>(&GV);
   if (GO && GO->isDeclarationForLinker() && GO->hasComdat()) {
     // The IRMover should not have placed any imported declarations in
     // a comdat, so the only declaration that should be in a comdat
     // at this point would be a definition imported as available_externally.

 }
 
 bool FunctionImportGlobalProcessing::run() {
   processGlobalsForThinLTO();
   return false;
 }
 
 bool llvm::renameModuleForThinLTO(Module &M, const ModuleSummaryIndex &Index,
+                                  bool ClearDSOLocalOnDeclarations,
                                   SetVector<GlobalValue *> *GlobalsToImport) {
-  FunctionImportGlobalProcessing ThinLTOProcessing(M, Index, GlobalsToImport);
+  FunctionImportGlobalProcessing ThinLTOProcessing(M, Index, GlobalsToImport,
+                                                   ClearDSOLocalOnDeclarations);
   return ThinLTOProcessing.run();
 }

llvm/test/LTO/Resolution/X86/local-def-dllimport.ll

 ; RUN: opt -thinlto-bc -thinlto-split-lto-unit -o %t0.bc %s
 ; RUN: llvm-lto2 run -r %t0.bc,__imp_f,l \
 ; RUN:               -r %t0.bc,g,p \
 ; RUN:               -r %t0.bc,g,l \
 ; RUN:               -r %t0.bc,e,l \
 ; RUN:               -r %t0.bc,main,x \
 ; RUN:               -save-temps -o %t1 %t0.bc
 ; RUN: llvm-dis %t1.1.3.import.bc -o - | FileCheck %s
 source_filename = "test.cpp"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 $g = comdat any
 @g = global i8 42, comdat, !type !0
 
-; CHECK: define
-; CHECK-NOT: dllimport
-; CHECK-SAME: @f
+; CHECK: define available_externally dllimport i8* @f()
 define available_externally dllimport i8* @f() {
   ret i8* @g
 }
 
 define i8* @e() {
   ret i8* @g
 }
 
 define i32 @main() {
   %1 = call i8* @f()
   %2 = ptrtoint i8* %1 to i32
   ret i32 %2
 }
 !0 = !{i32 0, !"typeid"}

llvm/test/ThinLTO/X86/Inputs/index-const-prop-gvref.ll

 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
-@b = global i32* @a, align 8
-@a = global i32 42, align 4
+@b = dso_local global i32* @a, align 8
+@a = dso_local global i32 42, align 4

llvm/test/ThinLTO/X86/funcimport_alwaysinline.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/funcimport_alwaysinline.ll -o %t2.bc
 
 ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.o -save-temps \
 ; RUN:     -r=%t1.bc,foo,plx \
 ; RUN:     -r=%t2.bc,main,plx \
 ; RUN:     -r=%t2.bc,foo,l \
 ; RUN:     -import-instr-limit=0
 ; RUN: llvm-dis %t.o.2.3.import.bc -o - | FileCheck %s --check-prefix=CHECK1
 ; RUN: llvm-dis %t.o.index.bc -o - | FileCheck %s --check-prefix=CHECK2
 
 ; foo() being always_inline should be imported irrespective of the
 ; instruction limit
-; CHECK1: define available_externally dso_local void @foo()
+; CHECK1: define available_externally void @foo()
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: alwaysinline nounwind uwtable
 define void @foo() #0 {
 entry:
   ret void
 }
 
 attributes #0 = { alwaysinline nounwind uwtable }
 ; CHECK2: ^2 = gv: (guid: {{.*}}, summaries: (function: (module: ^0, flags: (linkage: external, notEligibleToImport: 0, live: 1, dsoLocal: 1, canAutoHide: 0), insts: 1, funcFlags: (readNone: 0, readOnly: 0, noRecurse: 0, returnDoesNotAlias: 0, noInline: 0, alwaysInline: 1))))

llvm/test/ThinLTO/X86/index-const-prop-alias.ll

 ; RUN: llvm-dis %t4.1.3.import.bc -o - | FileCheck %s --check-prefix=PRESERVED
 
 ; When g.alias is preserved we can't internalize aliasee either
 ; RUN: llvm-lto2 run %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,ret_ptr,pl -r=%t1.bc,g.alias,l -r=%t1.bc,g,l \
 ; RUN:               %t2.bc -r=%t2.bc,g,pl -r=%t2.bc,g.alias,plx -save-temps -o %t5
 ; RUN: llvm-dis %t5.1.3.import.bc -o - | FileCheck %s --check-prefix=PRESERVED
 
 ; We currently don't support importing aliases
-; IMPORT:       @g.alias = external dso_local global i32
+; IMPORT:       @g.alias = external global i32
 ; IMPORT-NEXT:  @g = internal global i32 42, align 4 #0
 ; IMPORT:  attributes #0 = { "thinlto-internalize" }
 
 ; CODEGEN:      define dso_local i32 @main
 ; CODEGEN-NEXT:    ret i32 42
 
-; PRESERVED:      @g.alias = external dso_local global i32
-; PRESERVED-NEXT: @g = available_externally dso_local global i32 42, align 4
+; PRESERVED:      @g.alias = external global i32
+; PRESERVED-NEXT: @g = available_externally global i32 42, align 4
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @g.alias = external global i32
 @g = external global i32
 
 define i32 @main() {
   %v = load i32, i32* @g
   ret i32 %v
 }
 
 define i32* @ret_ptr() {
   ret i32* @g.alias
 }

llvm/test/ThinLTO/X86/index-const-prop-comdat.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-comdat.ll -o %t2.bc
 ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,g, -o %t3
 ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s
 
 ; Comdats are not internalized even if they are read only.
-; CHECK: @g = available_externally dso_local global i32 42 
+; CHECK: @g = available_externally global i32 42
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @g = external global i32
 
 define i32 @main() {
   %v = load i32, i32* @g
   ret i32 %v
 }

llvm/test/ThinLTO/X86/index-const-prop-dead.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc
 ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl \
 ; RUN:               %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,foo,pl -r=%t1.bc,g, -o %t3
 ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s
 
 ; Dead globals are converted to declarations by ThinLTO in dropDeadSymbols
 ; If we try to internalize such we'll get a broken module. 
-; CHECK: @g = external dso_local global i32
+; CHECK: @g = external global i32
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @g = external global i32
 
 ; We need at least one live symbol to enable dead stripping
 ; Otherwise ModuleSummaryIndex::isGlobalValueLive will always

llvm/test/ThinLTO/X86/index-const-prop-full-lto.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-full-lto.ll -o %t3.bc
 ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl \
 ; RUN:                 %t1.bc -r=%t1.bc,foo,l -r=%t1.bc,main,plx -r=%t1.bc,g, \
 ; RUN:                 %t3.bc -r=%t3.bc,foo,pl -r=%t3.bc,g, -o %t4
 ; RUN: llvm-dis %t4.2.3.import.bc -o - | FileCheck %s
 
 ; All references from functions in full LTO module are not constant.
 ; We cannot internalize @g
-; CHECK: @g = available_externally dso_local global i32 42
+; CHECK: @g = available_externally global i32 42
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare i32 @foo()
 @g = external global i32
 
 define i32 @main() {
   %v = call i32 @foo()
   %v2 = load i32, i32* @g
   %v3 = add i32 %v, %v2
   ret i32 %v3
 }

llvm/test/ThinLTO/X86/index-const-prop-gvref-pie.ll

+;; The same as index-const-prop-gvref.ll, except for PIE.
 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-gvref.ll -o %t2.bc
 ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,b,pl -r=%t2.bc,a,pl \
-; RUN:               %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,a, -r=%t1.bc,b, -o %t3
-; RUN: llvm-dis %t3.1.3.import.bc -o - | FileCheck %s --check-prefix=SRC
+; RUN:   %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,a, -r=%t1.bc,b, -o %t3
 ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s --check-prefix=DEST
 
-; No variable in the source module should have been internalized
-; SRC:      @b = dso_local global i32* @a
-; SRC-NEXT: @a = dso_local global i32 42
-
-; We can't internalize globals referenced by other live globals
+;; For PIE, keep dso_local for declarations to enable direct access.
 ; DEST:      @b = external dso_local global i32*
 ; DEST-NEXT: @a = available_externally dso_local global i32 42, align 4
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @a = external global i32
 @b = external global i32*
 
 define i32 @main() {
-  %p = load i32*, i32** @b, align 8  
+  %p = load i32*, i32** @b, align 8
   store i32 33, i32* %p, align 4
   %v = load i32, i32* @a, align 4
   ret i32 %v
 }
+
+!llvm.module.flags = !{!0}
+
+!0 = !{i32 7, !"PIE Level", i32 2}
+!1 = !{i32 7, !"PIC Level", i32 2}

llvm/test/ThinLTO/X86/index-const-prop-gvref.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-gvref.ll -o %t2.bc
-; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,b,pl -r=%t2.bc,a,pl \
-; RUN:               %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,a, -r=%t1.bc,b, -o %t3
+; RUN: llvm-lto2 run -relocation-model=static -save-temps %t2.bc -r=%t2.bc,b,pl -r=%t2.bc,a,pl \
+; RUN:   %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,a, -r=%t1.bc,b, -o %t3
 ; RUN: llvm-dis %t3.1.3.import.bc -o - | FileCheck %s --check-prefix=SRC
 ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s --check-prefix=DEST
 
+;; When producing an ELF DSO, clear dso_local for declarations to avoid direct access.
+; RUN: llvm-lto2 run -relocation-model=pic -save-temps %t2.bc -r=%t2.bc,b,pl -r=%t2.bc,a,pl \
+; RUN:   %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,a, -r=%t1.bc,b, -o %t4
+; RUN: llvm-dis %t4.1.3.import.bc -o - | FileCheck %s --check-prefix=SRC
+; RUN: llvm-dis %t4.2.3.import.bc -o - | FileCheck %s --check-prefix=DEST_DSO
+
 ; No variable in the source module should have been internalized
 ; SRC:      @b = dso_local global i32* @a
 ; SRC-NEXT: @a = dso_local global i32 42
 
 ; We can't internalize globals referenced by other live globals
-; DEST:      @b = external dso_local global i32*
-; DEST-NEXT: @a = available_externally dso_local global i32 42, align 4
+; DEST:          @b = external dso_local global i32*
+; DEST-NEXT:     @a = available_externally dso_local global i32 42, align 4
+; DEST_DSO:      @b = external global i32*
+; DEST_DSO-NEXT: @a = available_externally global i32 42, align 4
+
+;; Test old API.
+;; When producing an ELF DSO, clear dso_local for declarations to avoid direct access.
+; RUN: llvm-lto -thinlto-action=run %t2.bc %t1.bc -relocation-model=static -thinlto-save-temps=%t5.
+; RUN: llvm-dis < %t5.0.3.imported.bc | FileCheck %s --check-prefix=OLDAPI_SRC
+; RUN: llvm-dis < %t5.1.3.imported.bc | FileCheck %s --check-prefix=OLDAPI_DST
+; RUN: llvm-lto -thinlto-action=run %t2.bc %t1.bc -relocation-model=pic -thinlto-save-temps=%t6.
+; RUN: llvm-dis < %t6.0.3.imported.bc | FileCheck %s --check-prefix=OLDAPI_SRC
+; RUN: llvm-dis < %t6.1.3.imported.bc | FileCheck %s --check-prefix=OLDAPI_DST_DSO
+
+; OLDAPI_SRC:      @b = internal global i32* @a, align 8
+; OLDAPI_SRC-NEXT: @a = dso_local global i32 42, align 4
+; OLDAPI_DST:      @b = external dso_local global i32*
+; OLDAPI_DST-NEXT: @a = available_externally dso_local global i32 42, align 4
+; OLDAPI_DST_DSO:      @b = external global i32*
+; OLDAPI_DST_DSO-NEXT: @a = available_externally global i32 42, align 4
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @a = external global i32
 @b = external global i32*
 
 define i32 @main() {
   %p = load i32*, i32** @b, align 8  
   store i32 33, i32* %p, align 4
   %v = load i32, i32* @a, align 4
   ret i32 %v
 }

llvm/test/ThinLTO/X86/index-const-prop-ldst.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-define-g.ll -o %t2.bc
 ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,g,pl %t1.bc -r=%t1.bc,main,plx -r=%t1.bc,g, -o %t3
 ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s
 
 ; The 'store' instruction in @main should prevent internalization
 ; even when there is 'load' instruction before it.
-; CHECK: @g = available_externally dso_local global i32 42
+; CHECK: @g = available_externally global i32 42
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @g = external global i32
 
 define i32 @main() {
   %v = load i32, i32* @g
   %q = add i32 %v, 1
   store i32 %q, i32* @g
   
   ret i32 %v
 }

llvm/test/ThinLTO/X86/index-const-prop-linkage.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop-linkage.ll -o %t2.bc
 ; RUN: llvm-lto2 run -save-temps %t2.bc -r=%t2.bc,foo,pl -r=%t2.bc,g1,pl -r=%t2.bc,g2,pl -r=%t2.bc,g3, \
 ; RUN:                           %t1.bc -r=%t1.bc,foo, -r=%t1.bc,main,plx -r=%t1.bc,g2,  -o %t3
 ; RUN: llvm-dis %t3.2.3.import.bc -o - | FileCheck %s
 
 ; Check that we never internalize anything with:
 ; - appending linkage
 ; - common linkage
 ; - available_externally linkage
 ; - reference from @llvm.used
 ; CHECK:      @llvm.used = appending global [1 x i32*] [i32* @g2]
 ; CHECK-NEXT: @g1 = external dso_local global i32, align 4
-; CHECK-NEXT: @g2 = available_externally dso_local global i32 42, align 4
+; CHECK-NEXT: @g2 = available_externally global i32 42, align 4
 ; CHECK-NEXT: @g3 = available_externally global i32 42, align 4
 
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 declare i32 @foo()
 @g2 = external global i32
 @llvm.used = appending global [1 x i32*] [i32* @g2]
 
 define i32 @main() {
   %v = call i32 @foo()
   ret i32 %v
 }

llvm/test/ThinLTO/X86/index-const-prop2.ll

 
 ; Write only variables are imported with a zero initializer.
 ; IMPORT-WRITEONLY:  @gFoo.llvm.0 = internal unnamed_addr global i32 0
 ; IMPORT-WRITEONLY:  @gBar = internal local_unnamed_addr global i32 0
 
 ; CODEGEN:        i32 @main()
 ; CODEGEN-NEXT:     ret i32 3
 
-; IMPORT2: @gBar = available_externally dso_local local_unnamed_addr global i32 2, align 4
+; IMPORT2: @gBar = available_externally local_unnamed_addr global i32 2, align 4
 
 ; CODEGEN2:      i32 @main2
 ; CODEGEN2-NEXT:   %1 = tail call i32 @rand()
 ; CODEGEN2-NEXT:   %2 = tail call i32 @rand()
 ; CODEGEN2-NEXT:   ret i32 0
 
 ; CODEGEN2-SRC:       void @baz()
 ; CODEGEN2-SRC-NEXT:    %1 = tail call i32 @rand()

llvm/tools/llvm-link/llvm-link.cpp

if (Verbose)
       errs() << "Importing " << FunctionName << " from " << FileName << "\n";
 
     auto &Entry = ImportList[FileName];
     Entry.insert(F->getGUID());
   }
   auto CachedModuleLoader = [&](StringRef Identifier) {
     return ModuleLoaderCache.takeModule(std::string(Identifier));
   };
-  FunctionImporter Importer(*Index, CachedModuleLoader);
+  FunctionImporter Importer(*Index, CachedModuleLoader,
+                            /*ClearDSOLocalOnDeclarations=*/false);
   ExitOnErr(Importer.importFunctions(DestModule, ImportList));
 
   return true;
 }
 
 static bool linkFiles(const char *argv0, LLVMContext &Context, Linker &L,
                       const cl::list<std::string> &Files,
                       unsigned Flags) {
if (!SummaryIndex.empty()) {
       for (auto &I : *Index) {
         for (auto &S : I.second.SummaryList) {
           if (GlobalValue::isLocalLinkage(S->linkage()))
             S->setLinkage(GlobalValue::ExternalLinkage);
         }
       }
 
       // Promotion
-      if (renameModuleForThinLTO(*M, *Index))
+      if (renameModuleForThinLTO(*M, *Index,
+                                 /*ClearDSOLocalOnDeclarations=*/false))
         return true;
     }
 
     if (Verbose)
       errs() << "Linking in '" << File << "'\n";
 
     bool Err = false;
     if (InternalizeLinkedSymbols) {