[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.

116

Is a consistent name for the variable.

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

214

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

1304

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

214

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

116

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

llvm/lib/LTO/LTOBackend.cpp

551

Clang format

llvm/lib/LTO/ThinLTOCodeGenerator.cpp

214

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

214

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

214

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 ClearDSOLocal)
+      : Index(Index), ModuleLoader(std::move(ModuleLoader)),
+        ClearDSOLocal(ClearDSOLocal) {}
 
   /// 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;
+
+  bool ClearDSOLocal;
 };
 
 /// 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;
 
+  bool ClearDSOLocal;
+
   /// 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 ClearDSOLocal)
+      : M(M), ImportIndex(Index), GlobalsToImport(GlobalsToImport),
+        ClearDSOLocal(ClearDSOLocal) {
     // 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,
+    Module &M, const ModuleSummaryIndex &Index, bool DropDSOLocal,
     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);
+  bool ClearDSOLocal = TM->getTargetTriple().isOSBinFormatELF() &&
+                       TM->getRelocationModel() != Reloc::Static &&
+                       Mod.getPIELevel() == PIELevel::Default;
+  renameModuleForThinLTO(Mod, CombinedIndex, ClearDSOLocal);
 
   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, ClearDSOLocal);
   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

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))
+  if (renameModuleForThinLTO(TheModule, Index, false))
     report_fatal_error("renameModuleForThinLTO failed");
 }
 
 namespace {
 class ThinLTODiagnosticInfo : public DiagnosticInfo {
   const Twine &Msg;
 public:
   ThinLTODiagnosticInfo(const Twine &DiagMsg,
crossImportIntoModule(Module &TheModule, const ModuleSummaryIndex &Index,
                       StringMap<lto::InputFile*> &ModuleMap,
                       const FunctionImporter::ImportMapTy &ImportList) {
   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, false);
   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");

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, ClearDSOLocal,
+                               &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, false, 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, 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));
 
+  if (ClearDSOLocal && 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 ClearDSOLocal,
                                   SetVector<GlobalValue *> *GlobalsToImport) {
-  FunctionImportGlobalProcessing ThinLTOProcessing(M, Index, GlobalsToImport);
+  FunctionImportGlobalProcessing ThinLTOProcessing(M, Index, GlobalsToImport,
+                                                   ClearDSOLocal);
   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/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, drop 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
 
 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, 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, false))
         return true;
     }
 
     if (Verbose)
       errs() << "Linking in '" << File << "'\n";
 
     bool Err = false;
     if (InternalizeLinkedSymbols) {