[LTO] Make processing of combined module more consistent

[vitalybuka]

Summary

1. Use stream 0 only for combined module. Previously if combined module was not processes ThinLTO used the stream for own output. However small changes in input, could trigger combined module and shuffle outputs making life of llvm::LTO client harder.

2. Always process combined module and write output to stream 0. Processing empty combined module is cheap and allows llvm::LTO users to avoid implementing processing which is already done in llvm::LTO.

[vitalybuka]

Peter, please take a look at general approach.
I will add a test.

[vitalybuka]

comment

[pcc]

I think this patch can be simplified with my suggestions below. Let me know if it works.

llvm/include/llvm/LTO/LTO.h

282–283

Change these to:

Module CombinedModule;
IRMover Mover;

and have them be initialized by the RegularLTOState constructor in the same way as LTO::linkRegularLTO is doing right now.

294

Remove this field.

llvm/lib/LTO/LTO.cpp

476

Make this code use RegularLTO.CombinedModule.{g,s}etTargetTriple() instead.

665–666

Remove this code.

742

I don't think you need to add 1 here. With my suggestions, module 0 will be the empty module.

757–758

Remove this line.

758–769

Remove all of this.

[pcc]

llvm/lib/LTO/LTO.cpp

1159–1162

Replace with RegularLTO.ParallelCodeGenParallelismLevel.

[mehdi_amini]

The commit message does not make much sense to me in the context of this C++ API: there is a non-negligible layer between the build and the build system rules and the LTO implementation, i.e. the linker.
Implementing a contract that makes it convenient for your build system in the implementation of the LTO "engine" behind this API looks like leaking abstractions to me.

[vitalybuka]

Addressed review comments

[vitalybuka]

In D41267#956380, @mehdi_amini wrote:

The commit message does not make much sense to me in the context of this C++ API: there is a non-negligible layer between the build and the build system rules and the LTO implementation, i.e. the linker.
Implementing a contract that makes it convenient for your build system in the implementation of the LTO "engine" behind this API looks like leaking abstractions to me.

Updated commit message.

llvm/include/llvm/LTO/LTO.h

282–283

abandoned

294

are you askin to merge RegularLTOState and ThinLTOState?

[vitalybuka]

Remove unchanged file

[pcc]

Please add a test that shows that we create an empty object file with the correct target triple.

llvm/include/llvm/LTO/LTO.h

294

No, I was talking about EmptyModuleTargetTriple which you have removed.

[vitalybuka]

Adding promised but forgotten test

[mehdi_amini]

However small changes in input, could trigger combined module and shuffle outputs making life of llvm::LTO harder.

Sorry but this is still loaded in assumption about the client, which seems dubious in general to me.

[vitalybuka]

In D41267#957200, @mehdi_amini wrote:

However small changes in input, could trigger combined module and shuffle outputs making life of llvm::LTO harder.

Sorry but this is still loaded in assumption about the client, which seems dubious in general to me.

At this point I am trying to solve problem is the gold plugin, however I'd expect this could be helpful for other clients as well.
Anyway why benefit of particular client without regressing behavior for the rest is a problem? Especially considering that the patch simplify implementation.

[vitalybuka]

tests

[vitalybuka]

updated comment

[pcc]

LGTM

llvm/test/ThinLTO/X86/empty-module.ll

6

This could be | count 0. Same for the other test that you added.

[vitalybuka]

use count 0

[pcc]

llvm/test/ThinLTO/X86/empty-module.ll

9

Remove this line.

[vitalybuka]

Remove unneeded line

[mehdi_amini]

In D41267#957237, @vitalybuka wrote:

In D41267#957200, @mehdi_amini wrote:

However small changes in input, could trigger combined module and shuffle outputs making life of llvm::LTO harder.

Sorry but this is still loaded in assumption about the client, which seems dubious in general to me.

At this point I am trying to solve problem is the gold plugin, however I'd expect this could be helpful for other clients as well.
Anyway why benefit of particular client without regressing behavior for the rest is a problem? Especially considering that the patch simplify implementation.

That a problem because it is a terrible way in general to design complex system: this is a sign of over-coupling components and leaking abstractions through implicit API contract.

[vitalybuka]

In D41267#957496, @mehdi_amini wrote:

In D41267#957237, @vitalybuka wrote:

In D41267#957200, @mehdi_amini wrote:

However small changes in input, could trigger combined module and shuffle outputs making life of llvm::LTO harder.

Sorry but this is still loaded in assumption about the client, which seems dubious in general to me.

At this point I am trying to solve problem is the gold plugin, however I'd expect this could be helpful for other clients as well.
Anyway why benefit of particular client without regressing behavior for the rest is a problem? Especially considering that the patch simplify implementation.

That a problem because it is a terrible way in general to design complex system: this is a sign of over-coupling components and leaking abstractions through implicit API contract.

I agree that implicit contract about streams order is not nice here, and we should consider to make it explicit.

[mehdi_amini]

In D41267#957510, @vitalybuka wrote:

I agree that implicit contract about streams order is not nice here, and we should consider to make it explicit.

That makes the system more rigid, and leave less room for improvements/innovation/etc.

For instance the C API LTO bindings intentionally specifies that the client needs to be prepared to receive a different number of objects than the number of modules it supplied. This allows ThinLTO to evolve toward different granularity of partitioning for instance.
Making the LTO API a 1-1 in term of matching the output files to the inputs modules would make this uneasy. Constraining the API a this level is really not great: if you feel that you need 1-1 matching for some client, it seems to me that it should be achieved by adding an intermediate layer that would take care of it instead of injecting it there.

lld/test/COFF/thinlto.ll

 ; REQUIRES: x86
 ; RUN: rm -fr %T/thinlto
 ; RUN: mkdir %T/thinlto
 ; RUN: opt -thinlto-bc -o %T/thinlto/main.obj %s
 ; RUN: opt -thinlto-bc -o %T/thinlto/foo.obj %S/Inputs/lto-dep.ll
 ; RUN: lld-link /lldsavetemps /out:%T/thinlto/main.exe /entry:main /subsystem:console %T/thinlto/main.obj %T/thinlto/foo.obj
-; RUN: llvm-nm %T/thinlto/main.exe.lto.obj | FileCheck %s
+; RUN: llvm-nm %T/thinlto/main.exe1.lto.obj | FileCheck %s
 
 ; CHECK-NOT: U foo
 
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc"
 
 define i32 @main() {
   call void @foo()
   ret i32 0
 }
 
 declare void @foo()

lld/test/ELF/lto/thinlto.ll

 ; REQUIRES: x86
 ; Basic ThinLTO tests.
 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
 
 ; First force single-threaded mode
 ; RUN: rm -f %t.lto.o %t1.lto.o
 ; RUN: ld.lld -save-temps --thinlto-jobs=1 -shared %t.o %t2.o -o %t
-; RUN: llvm-nm %t.lto.o | FileCheck %s --check-prefix=NM1
-; RUN: llvm-nm %t1.lto.o | FileCheck %s --check-prefix=NM2
+; RUN: llvm-nm %t1.lto.o | FileCheck %s --check-prefix=NM1
+; RUN: llvm-nm %t2.lto.o | FileCheck %s --check-prefix=NM2
 
 ; Next force multi-threaded mode
 ; RUN: rm -f %t2.lto.o %t21.lto.o
 ; RUN: ld.lld -save-temps --thinlto-jobs=2 -shared %t.o %t2.o -o %t2
-; RUN: llvm-nm %t2.lto.o | FileCheck %s --check-prefix=NM1
-; RUN: llvm-nm %t21.lto.o | FileCheck %s --check-prefix=NM2
+; RUN: llvm-nm %t21.lto.o | FileCheck %s --check-prefix=NM1
+; RUN: llvm-nm %t22.lto.o | FileCheck %s --check-prefix=NM2
 
 ; NM1: T f
 ; NM1-NOT: U g
 
 ; NM2: T g
 
 ; Then check without --thinlto-jobs (which currently default to hardware_concurrency)
 ; We just check that we don't crash or fail (as it's not sure which tests are

llvm/include/llvm/LTO/LTO.h

struct CommonResolution {
       unsigned Align = 0;
       /// Record if at least one instance of the common was marked as prevailing
       bool Prevailing = false;
     };
     std::map<std::string, CommonResolution> Commons;
 
     unsigned ParallelCodeGenParallelismLevel;
     LTOLLVMContext Ctx;
     std::unique_ptr<Module> CombinedModule;
     std::unique_ptr<IRMover> Mover;
 
     // This stores the information about a regular LTO module that we have added
     // to the link. It will either be linked immediately (for modules without
     // summaries) or after summary-based dead stripping (for modules with
     // summaries).
     struct AddedModule {
       std::unique_ptr<Module> M;
       std::vector<GlobalValue *> Keep;
     };
     std::vector<AddedModule> ModsWithSummaries;
   } RegularLTO;
 
   struct ThinLTOState {
     ThinLTOState(ThinBackend Backend);
 
     ThinBackend Backend;
     ModuleSummaryIndex CombinedIndex;
     MapVector<StringRef, BitcodeModule> ModuleMap;
     DenseMap<GlobalValue::GUID, StringRef> PrevailingModuleForGUID;
addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
                 const SymbolResolution *&ResI, const SymbolResolution *ResE);
   Error linkRegularLTO(RegularLTOState::AddedModule Mod,
                        bool LivenessFromIndex);
 
   Error addThinLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
                    const SymbolResolution *&ResI, const SymbolResolution *ResE);
 
   Error runRegularLTO(AddStreamFn AddStream);
-  Error runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
-                   bool HasRegularLTO);
+  Error runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache);
 
   mutable bool CalledGetMaxTasks = false;
 };
 
 /// The resolution for a symbol. The linker must provide a SymbolResolution for
 /// each global symbol based on its internal resolution of that symbol.
 struct SymbolResolution {
   SymbolResolution()

llvm/lib/LTO/LTO.cpp

 
 StringRef InputFile::getName() const {
   return Mods[0].getModuleIdentifier();
 }
 
 LTO::RegularLTOState::RegularLTOState(unsigned ParallelCodeGenParallelismLevel,
                                       Config &Conf)
     : ParallelCodeGenParallelismLevel(ParallelCodeGenParallelismLevel),
-      Ctx(Conf) {}
+      Ctx(Conf), CombinedModule(llvm::make_unique<Module>("ld-temp.o", Ctx)),
+      Mover(llvm::make_unique<IRMover>(*CombinedModule)) {}
 
 LTO::ThinLTOState::ThinLTOState(ThinBackend Backend) : Backend(Backend) {
   if (!Backend)
     this->Backend =
         createInProcessThinBackend(llvm::heavyweight_hardware_concurrency());
 }
 
 LTO::LTO(Config Conf, ThinBackend Backend,

 
 Error LTO::add(std::unique_ptr<InputFile> Input,
                ArrayRef<SymbolResolution> Res) {
   assert(!CalledGetMaxTasks);
 
   if (Conf.ResolutionFile)
     writeToResolutionFile(*Conf.ResolutionFile, Input.get(), Res);
 
+  if (RegularLTO.CombinedModule->getTargetTriple().empty())
+    RegularLTO.CombinedModule->setTargetTriple(Input->getTargetTriple());
+
   const SymbolResolution *ResI = Res.begin();
   for (unsigned I = 0; I != Input->Mods.size(); ++I)
     if (Error Err = addModule(*Input, I, ResI, Res.end()))
       return Err;
 
   assert(ResI == Res.end());
   return Error::success();
 }
LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
   if (!M.getComdatSymbolTable().empty())
     for (GlobalValue &GV : M.global_values())
       handleNonPrevailingComdat(GV, NonPrevailingComdats);
   assert(MsymI == MsymE);
   return std::move(Mod);
 }
 
 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
                           bool LivenessFromIndex) {
-  if (!RegularLTO.CombinedModule) {
-    RegularLTO.CombinedModule =
-        llvm::make_unique<Module>("ld-temp.o", RegularLTO.Ctx);
-    RegularLTO.Mover = llvm::make_unique<IRMover>(*RegularLTO.CombinedModule);
-  }
-
   std::vector<GlobalValue *> Keep;
   for (GlobalValue *GV : Mod.Keep) {
     if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID()))
       continue;
 
     if (!GV->hasAvailableExternallyLinkage()) {
       Keep.push_back(GV);
       continue;
     }
return make_error<StringError>(
         inconvertibleErrorCode());
 
   return Error::success();
 }
 
 unsigned LTO::getMaxTasks() const {
   CalledGetMaxTasks = true;
   return RegularLTO.ParallelCodeGenParallelismLevel + ThinLTO.ModuleMap.size();
 }
 
 Error LTO::run(AddStreamFn AddStream, NativeObjectCache Cache) {
   // Compute "dead" symbols, we don't want to import/export these!
   DenseSet<GlobalValue::GUID> GUIDPreservedSymbols;
   for (auto &Res : GlobalResolutions) {
     if (Res.second.VisibleOutsideSummary &&
         // IRName will be defined if we have seen the prevailing copy of
         // this value. If not, no need to preserve any ThinLTO copies.
         !Res.second.IRName.empty())
       GUIDPreservedSymbols.insert(GlobalValue::getGUID(
           GlobalValue::dropLLVMManglingEscape(Res.second.IRName)));
   }
 
   computeDeadSymbols(ThinLTO.CombinedIndex, GUIDPreservedSymbols);
 
-  // Save the status of having a regularLTO combined module, as
-  // this is needed for generating the ThinLTO Task ID, and
-  // the CombinedModule will be moved at the end of runRegularLTO.
-  bool HasRegularLTO = RegularLTO.CombinedModule != nullptr ||
-                       !RegularLTO.ModsWithSummaries.empty();
-  // Invoke regular LTO if there was a regular LTO module to start with.
-  if (HasRegularLTO)
-    if (auto E = runRegularLTO(AddStream))
-      return E;
-  return runThinLTO(AddStream, Cache, HasRegularLTO);
+  return runThinLTO(AddStream, Cache);
 }
 
 Error LTO::runRegularLTO(AddStreamFn AddStream) {
   for (auto &M : RegularLTO.ModsWithSummaries)
     if (Error Err = linkRegularLTO(std::move(M),
                                    /*LivenessFromIndex=*/true))
       return Err;
 
   // Make sure commons have the right size/alignment: we kept the largest from
   // all the prevailing when adding the inputs, and we apply it here.
   const DataLayout &DL = RegularLTO.CombinedModule->getDataLayout();
   for (auto &I : RegularLTO.Commons) {
     if (!I.second.Prevailing)
       // Don't do anything if no instance of this common was prevailing.
       continue;
     GlobalVariable *OldGV = RegularLTO.CombinedModule->getNamedGlobal(I.first);
     if (OldGV && DL.getTypeAllocSize(OldGV->getValueType()) == I.second.Size) {
return [=](Config &Conf, ModuleSummaryIndex &CombinedIndex,
              const StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,
              AddStreamFn AddStream, NativeObjectCache Cache) {
     return llvm::make_unique<WriteIndexesThinBackend>(
         Conf, CombinedIndex, ModuleToDefinedGVSummaries, OldPrefix, NewPrefix,
         ShouldEmitImportsFiles, LinkedObjectsFile);
   };
 }
 
-Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache,
-                      bool HasRegularLTO) {
+Error LTO::runThinLTO(AddStreamFn AddStream, NativeObjectCache Cache) {
   if (ThinLTO.ModuleMap.empty())
     return Error::success();
 
   if (Conf.CombinedIndexHook && !Conf.CombinedIndexHook(ThinLTO.CombinedIndex))
     return Error::success();
 
   // Collect for each module the list of function it defines (GUID ->
   // Summary).
auto recordNewLinkage = [&](StringRef ModuleIdentifier,
     ResolvedODR[ModuleIdentifier][GUID] = NewLinkage;
   };
   thinLTOResolveWeakForLinkerInIndex(ThinLTO.CombinedIndex, isPrevailing,
                                      recordNewLinkage);
 
   std::unique_ptr<ThinBackendProc> BackendProc =
       ThinLTO.Backend(Conf, ThinLTO.CombinedIndex, ModuleToDefinedGVSummaries,
                       AddStream, Cache);
 
-  // Task numbers start at ParallelCodeGenParallelismLevel if an LTO
-  // module is present, as tasks 0 through ParallelCodeGenParallelismLevel-1
-  // are reserved for parallel code generation partitions.
-  unsigned Task =
-      HasRegularLTO ? RegularLTO.ParallelCodeGenParallelismLevel : 0;
+  // Tasks 0 through ParallelCodeGenParallelismLevel-1 are reserved for combined
+  // module and parallel code generation partitions.
+  unsigned Task = RegularLTO.ParallelCodeGenParallelismLevel;
   for (auto &Mod : ThinLTO.ModuleMap) {
     if (Error E = BackendProc->start(Task, Mod.second, ImportLists[Mod.first],
                                      ExportLists[Mod.first],
                                      ResolvedODR[Mod.first], ThinLTO.ModuleMap))
       return E;
     ++Task;
   }
 

llvm/test/LTO/Resolution/X86/dead-strip-alias.ll

 ; RUN: opt -module-summary -o %t %s
 ; RUN: opt -module-summary -o %t2 %S/Inputs/dead-strip-alias.ll
 ; RUN: llvm-lto2 run %t -r %t,main,px -r %t,alias,p -r %t,external, \
 ; RUN:               %t2 -r %t2,external,p \
 ; RUN: -save-temps -o %t3
-; RUN: llvm-nm %t3.1 | FileCheck %s
+; RUN: llvm-nm %t3.2 | FileCheck %s
 
 ; CHECK: D external
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @alias = alias i8*, i8** @internal
 
 @internal = internal global i8* @external
 @external = external global i8
 
 define i8** @main() {
   ret i8** @alias
 }

llvm/test/LTO/Resolution/X86/ifunc.ll

 ; RUN: opt -module-summary -o %t.bc %s
 ; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,pl -o %t2
-; RUN: llvm-nm %t2.0 | FileCheck %s
+; RUN: llvm-nm %t2.1 | FileCheck %s
 ; CHECK: T foo
 ; CHECK: t foo_ifunc
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @foo = ifunc i32 (i32), i64 ()* @foo_ifunc
 
 define internal i64 @foo_ifunc() {
 entry:
   ret i64 0
 }

llvm/test/LTO/Resolution/X86/linker-redef-thin.ll

 ; RUN: opt -module-summary %s -o %t.o
 ; RUN: llvm-lto2 run -o %t1.o %t.o -r %t.o,patatino,pr
-; RUN: llvm-readobj -t %t1.o.0 | FileCheck %s
+; RUN: llvm-readobj -t %t1.o.1 | FileCheck %s
 
 ; CHECK: Name: patatino
 ; CHECK-NEXT: Value:
 ; CHECK-NEXT: Size:
 ; CHECK-NEXT: Binding: Weak
 ; CHECK-NEXT: Type: Function
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @patatino() {
   ret void
 }

llvm/test/LTO/Resolution/X86/linkonce.ll

 ; RUN: opt -module-summary -o %t %s
 ; RUN: llvm-lto2 run %t -O0 -r %t,foo,px -o %t2
-; RUN: llvm-nm %t2.0 | FileCheck %s
+; RUN: llvm-nm %t2.1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK: W foo
 define linkonce_odr void @foo() {
   ret void
 }

llvm/test/LTO/Resolution/X86/load-sample-prof-icp.ll

 ; Test that llvm-lto2 handles the -lto-sample-profile-file option and pass
 ; down to the ICP correctly.
 ;
 ; RUN: opt -module-summary < %s -o %t.bc
 ; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps \
 ; RUN:   -r %t.bc,test,px -r %t.bc,bar,x \
 ; RUN:   -lto-sample-profile-file=%S/Inputs/load-sample-prof-icp.prof
-; RUN: llvm-dis %t.out.0.4.opt.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.out.1.4.opt.bc -o - | FileCheck %s
 ; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps \
 ; RUN:   -r %t.bc,test,px -r %t.bc,bar,x -use-new-pm \
 ; RUN:   -lto-sample-profile-file=%S/Inputs/load-sample-prof-icp.prof
-; RUN: llvm-dis %t.out.0.4.opt.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.out.1.4.opt.bc -o - | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK-LABEL: @test
 ; Checks that the call instruction is promoted to direct call and has
 ; profile count annotated on the direct call.
 define void @test(void ()*) !dbg !7 {

llvm/test/LTO/Resolution/X86/load-sample-prof.ll

 ; Test that llvm-lto2 handles the -lto-sample-profile-file option
 ;
 ; RUN: opt -module-summary < %s -o %t.bc
 ; RUN: llvm-lto2 run -o %t.out %t.bc -save-temps \
 ; RUN:   -r %t.bc,foo,px -r %t.bc,bar,x \
 ; RUN:   -lto-sample-profile-file=%S/Inputs/load-sample-prof.prof
-; RUN: llvm-dis %t.out.0.4.opt.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.out.1.4.opt.bc -o - | FileCheck %s
 ;
 ; CHECK: !prof
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @foo() local_unnamed_addr !dbg !7 {
 entry:

llvm/test/LTO/Resolution/X86/mod-asm-used.ll

 ; RUN: opt -module-summary -o %t.bc %s
 ; RUN: opt -module-summary -o %t2.bc %S/Inputs/mod-asm-used.ll
 ; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,l %t2.bc -r %t2.bc,foo,pl -o %t3
-; RUN: llvm-nm %t3.1 | FileCheck %s
+; RUN: llvm-nm %t3.* | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; CHECK: D foo
 module asm ".quad foo"

llvm/test/ThinLTO/X86/deadstrip.ll

 ; RUN:   -r %t1.bc,_dead_func,pl \
 ; RUN:   -r %t1.bc,_baz,l \
 ; RUN:   -r %t1.bc,_boo,l \
 ; RUN:   -r %t2.bc,_baz,pl \
 ; RUN:   -r %t2.bc,_boo,pl \
 ; RUN:   -r %t2.bc,_dead_func,l \
 ; RUN:   -r %t2.bc,_another_dead_func,pl
 ; RUN: llvm-dis < %t.out.0.3.import.bc | FileCheck %s --check-prefix=LTO2
-; RUN: llvm-dis < %t.out.1.3.import.bc | FileCheck %s --check-prefix=LTO2-CHECK2
+; RUN: llvm-dis < %t.out.2.3.import.bc | FileCheck %s --check-prefix=LTO2-CHECK2
 ; RUN: llvm-nm %t.out.1 | FileCheck %s --check-prefix=CHECK2-NM
 
 ; RUN: llvm-bcanalyzer -dump %t.out.index.bc | FileCheck %s --check-prefix=COMBINED
 ; Live, NotEligibleForImport, Internal
 ; COMBINED-DAG: <COMBINED {{.*}} op2=55
 ; Live, Internal
 ; COMBINED-DAG: <COMBINED {{.*}} op2=39
 ; Live, Local, External

llvm/test/ThinLTO/X86/debuginfo-compositetype-import.ll

 ; Test to ensure DICompositeType are imported as type declarations
 ; for ThinLTO
 
 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/debuginfo-compositetype-import.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t1.bc %t2.bc
 
 ; By default, composite types are imported as type declarations
 ; RUN: llvm-lto -thinlto-action=import %t2.bc -thinlto-index=%t.index.bc -o - | llvm-dis -o - | FileCheck %s
 ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.out -save-temps \
 ; RUN:   -r %t2.bc,main,plx \
 ; RUN:   -r %t2.bc,foo,l \
 ; RUN:   -r %t1.bc,foo,pl
-; RUN: llvm-dis < %t.out.1.3.import.bc | FileCheck %s
+; RUN: llvm-dis < %t.out.2.3.import.bc | FileCheck %s
 
 ; CHECK: distinct !DICompositeType(tag: DW_TAG_enumeration_type, name: "enum", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 50, size: 32, flags: DIFlagFwdDecl, identifier: "enum")
 ; CHECK: distinct !DICompositeType(tag: DW_TAG_class_type, name: "class", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 728, size: 448, flags: DIFlagFwdDecl, identifier: "class")
 ; CHECK: distinct !DICompositeType(tag: DW_TAG_structure_type, name: "struct", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 309, size: 128, flags: DIFlagFwdDecl, identifier: "list")
 ; CHECK: distinct !DICompositeType(tag: DW_TAG_union_type, file: !{{[0-9]+}}, line: 115, size: 384, flags: DIFlagFwdDecl, identifier: "union")
 
 ; Ensure that full type definitions of composite types are imported if requested
 ; RUN: llvm-lto -import-full-type-definitions -thinlto-action=import %t2.bc -thinlto-index=%t.index.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=FULL
 ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.out -save-temps \
 ; RUN:   -import-full-type-definitions \
 ; RUN:   -r %t2.bc,main,plx \
 ; RUN:   -r %t2.bc,foo,l \
 ; RUN:   -r %t1.bc,foo,pl
-; RUN: llvm-dis < %t.out.1.3.import.bc | FileCheck %s --check-prefix=FULL
+; RUN: llvm-dis < %t.out.2.3.import.bc | FileCheck %s --check-prefix=FULL
 
 ; FULL: distinct !DICompositeType(tag: DW_TAG_enumeration_type, name: "enum", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 50, size: 32, elements: !{{[0-9]+}}, identifier: "enum")
 ; FULL: distinct !DICompositeType(tag: DW_TAG_class_type, name: "class", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 728, size: 448, elements: !{{[0-9]+}}, identifier: "class")
 ; FULL: distinct !DICompositeType(tag: DW_TAG_structure_type, name: "struct", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: 309, baseType: !{{[0-9]+}}, size: 128, offset: 64, elements: !{{[0-9]+}}, vtableHolder: !{{[0-9]+}}, templateParams: !{{[0-9]+}}, identifier: "list")
 ; FULL: distinct !DICompositeType(tag: DW_TAG_union_type, file: !{{[0-9]+}}, line: 115, size: 384, elements: !{{[0-9]+}}, identifier: "union")
 
 ; ModuleID = 'debuginfo-compositetype-import.c'
 source_filename = "debuginfo-compositetype-import.c"

llvm/test/ThinLTO/X86/distributed_import.ll

 ; Make sure importing occurs as expected
 ; RUN: cp %t1.bc.sv %t1.bc
 ; RUN: cp %t2.bc.sv %t2.bc
 ; RUN: opt -function-import -summary-file %t2.bc.thinlto.bc %t2.bc -o %t2.out
 ; RUN: llvm-dis -o - %t2.out | FileCheck %s
 
 ; CHECK: @G.llvm.
 
+target triple = "x86_64-unknown-linux-gnu"
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 declare i32 @g(...)
 
 define void @f() {
 entry:
   call i32 (...) @g()
   ret void

llvm/test/ThinLTO/X86/empty-module.ll

 ; RUN: opt -module-summary -o %t.bc %s
-; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,pl -o %t2
-; RUN: llvm-nm %t2.0 | FileCheck %s
-; CHECK: T foo
-; CHECK: t foo_ifunc
+
+; RUN: rm -f %t2.0
+; RUN: llvm-lto2 run  %t.bc -r %t.bc,foo,pl -o %t2 -thinlto-distributed-indexes 
+; RUN: llvm-readobj -h %t2.0 | FileCheck %s
+; RUN: llvm-nm %t2.0 | count 0
+
+; CHECK: Format: ELF64-x86-64
+; NOSYM: 0
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @foo = ifunc i32 (i32), i64 ()* @foo_ifunc
 
 define internal i64 @foo_ifunc() {
 entry:
   ret i64 0
 }

llvm/test/ThinLTO/X86/funcimport2.ll

 ; Do setup work for all below tests: generate bitcode and combined index
 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/funcimport2.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: llvm-dis %t.o.1.3.import.bc -o - | FileCheck %s
+; RUN: llvm-dis %t.o.2.3.import.bc -o - | FileCheck %s
 ; CHECK: define available_externally dso_local void @foo()
 
 ; We shouldn't do any importing at -O0
 ; rm -f %t.o.1.3.import.bc
 ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.o -save-temps \
 ; RUN:     -O0 \
 ; RUN:     -r=%t1.bc,_foo,plx \
 ; RUN:     -r=%t2.bc,_main,plx \
 ; RUN:     -r=%t2.bc,_foo,l
-; RUN: llvm-dis %t.o.1.3.import.bc -o - | FileCheck %s --check-prefix=CHECKO0
+; RUN: llvm-dis %t.o.2.3.import.bc -o - | FileCheck %s --check-prefix=CHECKO0
 ; CHECKO0: declare dso_local void @foo(...)
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 define void @foo() #0 {
 entry:
   ret void
 }

llvm/test/ThinLTO/X86/internalize.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t.index.bc %t1.bc
 ; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t.index.bc %t1.bc -o - | llvm-dis -o - | FileCheck %s --check-prefix=REGULAR
 ; RUN: llvm-lto -thinlto-action=internalize -thinlto-index %t.index.bc %t1.bc -o -  --exported-symbol=foo | llvm-dis -o - | FileCheck %s --check-prefix=INTERNALIZE
 
 ; RUN: llvm-lto2 run %t1.bc -o %t.o -save-temps \
 ; RUN:     -r=%t1.bc,_foo,pxl \
 ; RUN:     -r=%t1.bc,_bar,pl \
 ; RUN:     -r=%t1.bc,_linkonce_func,pl
-; RUN: llvm-dis < %t.o.0.2.internalize.bc | FileCheck  %s --check-prefix=INTERNALIZE2
+; RUN: llvm-dis < %t.o.1.2.internalize.bc | FileCheck  %s --check-prefix=INTERNALIZE2
 
 
 ; REGULAR: define void @foo
 ; REGULAR: define void @bar
 ; REGULAR: define linkonce void @linkonce_func()
 ; INTERNALIZE: define void @foo
 ; INTERNALIZE: define internal void @bar
 ; INTERNALIZE: define internal void @linkonce_func()

llvm/test/ThinLTO/X86/module_asm2.ll

 ; RUN:     -r=%t1.bc,callglobalfunc,plx \
 ; RUN:     -r=%t1.bc,callweakfunc,plx \
 ; RUN:     -r=%t2.bc,main,plx \
 ; RUN:     -r=%t2.bc,func1,l \
 ; RUN:     -r=%t2.bc,func2,l \
 ; RUN:     -r=%t2.bc,func3,l \
 ; RUN:     -r=%t2.bc,callglobalfunc,l \
 ; RUN:     -r=%t2.bc,callweakfunc,l
-; RUN: llvm-nm %t.o.0 | FileCheck  %s --check-prefix=NM0
-; RUN: llvm-nm %t.o.1 | FileCheck  %s --check-prefix=NM1
+; RUN: llvm-nm %t.o.1 | FileCheck  %s --check-prefix=NM0
+; RUN: llvm-nm %t.o.2 | FileCheck  %s --check-prefix=NM1
 
 ; Check that local values b and x, which are referenced on
 ; llvm.used and llvm.compiler.used, respectively, are not promoted.
 ; Similarly, foo which is defined in module level asm should not be
 ; promoted.
 ; NM0-DAG: d b
 ; NM0-DAG: d x
 ; NM0-DAG: t foo

llvm/test/ThinLTO/X86/module_asm_glob.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/module_asm.ll -o %t2.bc
 
 ; RUN: llvm-lto -thinlto-action=run -exported-symbol=main %t1.bc %t2.bc
 ; RUN: llvm-nm %t1.bc.thinlto.o | FileCheck  %s --check-prefix=NM0
 ; RUN: llvm-nm %t2.bc.thinlto.o | FileCheck  %s --check-prefix=NM1
 
 ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.o -save-temps \
 ; RUN:     -r=%t1.bc,foo,lx \
 ; RUN:     -r=%t1.bc,foo,plx \
 ; RUN:     -r=%t1.bc,_simplefunction,pl \
 ; RUN:     -r=%t2.bc,main,plx \
 ; RUN:     -r=%t2.bc,_simplefunction,l
-; RUN: llvm-nm %t.o.0 | FileCheck  %s --check-prefix=NM0
-; RUN: llvm-nm %t.o.1 | FileCheck  %s --check-prefix=NM1
+; RUN: llvm-nm %t.o.1 | FileCheck  %s --check-prefix=NM0
+; RUN: llvm-nm %t.o.2 | FileCheck  %s --check-prefix=NM1
 
 ; NM0: T foo
 ; NM1-NOT: foo
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 module asm "\09.text"

llvm/test/ThinLTO/X86/personality-local.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %S/Inputs/personality-local.ll -o %t2.bc
 
 ; RUN: llvm-lto2 run -o %t.o %t1.bc %t2.bc -save-temps \
 ; RUN:   -r %t2.bc,foo,p \
 ; RUN:   -r %t1.bc,foo,l \
 ; RUN:   -r %t1.bc,bar,p \
 ; RUN:   -r %t1.bc,main,xp
-; RUN: llvm-readobj -t %t.o.1 | FileCheck %s
+; RUN: llvm-readobj -t %t.o.2 | FileCheck %s
 
 ; CHECK:      Symbol {
 ; CHECK:        Name: foo
 ; CHECK-NEXT:   Value: 0x0
 ; CHECK-NEXT:   Size: 1
 ; CHECK-NEXT:   Binding: Global
 ; CHECK-NEXT:   Type: Function
 ; CHECK-NEXT:   Other: 0

llvm/test/ThinLTO/X86/personality.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %S/Inputs/personality.ll -o %t2.bc
 
 ; RUN: llvm-lto2 run -o %t.o %t1.bc %t2.bc -save-temps \
 ; RUN:   -r %t2.bc,bar,p \
 ; RUN:   -r %t2.bc,personality_routine,p \
 ; RUN:   -r %t2.bc,personality_routine2,p \
 ; RUN:   -r %t2.bc,personality_routine3,p \
 ; RUN:   -r %t1.bc,foo,p \
 ; RUN:   -r %t1.bc,foo2,p \
 ; RUN:   -r %t1.bc,foo3,p \
 ; RUN:   -r %t1.bc,personality_routine,l \
 ; RUN:   -r %t1.bc,personality_routine2,l \
 ; RUN:   -r %t1.bc,personality_routine3,l \
 ; RUN:   -r %t1.bc,main,xp \
 ; RUN:   -r %t1.bc,bar,l
-; RUN: llvm-readobj -t %t.o.1 | FileCheck %s --check-prefix=BINDING
+; RUN: llvm-readobj -t %t.o.2 | FileCheck %s --check-prefix=BINDING
 
 ; BINDING:     Symbol {
 ; BINDING:       Name: personality_routine
 ; BINDING-NEXT:  Value:
 ; BINDING-NEXT:  Size:
 ; BINDING-NEXT:  Binding: Global
 ; BINDING-NEXT:  Type: Function
 ; BINDING-NEXT:  Other [

llvm/test/ThinLTO/X86/reference_non_importable.ll

 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/reference_non_importable.ll -o %t2.bc
 
 ; RUN: llvm-lto2 run %t1.bc %t2.bc -o %t.o -save-temps \
 ; RUN:     -r=%t1.bc,_foo,pxl \
 ; RUN:     -r=%t1.bc,_b,pxl \
 ; RUN:     -r=%t2.bc,_main,pxl \
 ; RUN:     -r=%t2.bc,_foo,xl
 
 
 
 
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 ; We shouldn't promote the private because it has a section
-; RUN: llvm-dis < %t.o.0.2.internalize.bc | FileCheck  %s --check-prefix=PROMOTE
+; RUN: llvm-dis < %t.o.1.2.internalize.bc | FileCheck  %s --check-prefix=PROMOTE
 ; PROMOTE: @a = private global i8 0, section "__TEXT,__cstring,cstring_literals"
 @a = private global i8 0, section "__TEXT,__cstring,cstring_literals"
 @b = global i8 *@a
 
 
 ; We want foo to be imported in the main module!
-; RUN: llvm-dis < %t.o.1.3.import.bc  | FileCheck  %s --check-prefix=IMPORT
+; RUN: llvm-dis < %t.o.2.3.import.bc  | FileCheck  %s --check-prefix=IMPORT
 ; IMPORT: define available_externally dso_local i8** @foo()
 define i8 **@foo() {
   ret i8 **@b
 }

llvm/test/Transforms/FunctionImport/funcimport_var.ll

 ; This test makes sure a static var is not selected as a callee target
 ; (which will crash compilation).
 ; RUN: opt -module-summary %s -o %t.bc
 ; RUN: opt -module-summary %p/Inputs/funcimport_var2.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto -thinlto-action=thinlink -o %t3 %t.bc %t2.bc
 ; RUN: llvm-lto -thinlto -thinlto-action=import -thinlto-index=%t3 %t.bc %t2.bc
 ; RUN: llvm-lto -thinlto -thinlto-action=run %t.bc %t2.bc
 ; RUN: llvm-nm %t.bc.thinlto.o | FileCheck %s
 ; RUN: llvm-lto2 run %t.bc %t2.bc -o %t.out \
 ; RUN:   -r %t.bc,_Z4LinkPKcS0_,plx \
 ; RUN:   -r %t.bc,link,l \
 ; RUN:   -r %t2.bc,get_link,plx
-; RUN: llvm-nm %t.out.0 | FileCheck %s
+; RUN: llvm-nm %t.out.1 | FileCheck %s
 ; CHECK: U link
 
 ; REQUIRES: x86-registered-target
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define i32 @_Z4LinkPKcS0_(i8*, i8*) local_unnamed_addr  {
   %3 = tail call i32 @link(i8* %0, i8* %1) #2
   ret i32 %3
 }
 
 ; Function Attrs: nounwind
 declare i32 @link(i8*, i8*) local_unnamed_addr 

llvm/test/Transforms/PGOProfile/thinlto_samplepgo_icp2.ll

 ; Use -import-instr-limit=5 so that we don't import _ZL3barv, which would
 ; hide the problem.
 ; RUN: llvm-lto2 run -save-temps -import-instr-limit=5 -o %t3 %t.bc %t2a.bc %t2b.bc -r %t.bc,fptr,plx -r %t.bc,main,plx -r %t2a.bc,_ZL3barv,l -r %t2b.bc,_ZL3barv,pl -print-imports 2>&1 | FileCheck %s --check-prefix=IMPORTS2
 ; IMPORTS2-NOT: Import _ZL3barv
 ; IMPORTS2: Import _ZL3foov.llvm.0
 ; IMPORTS2-NOT: Import _ZL3barv
 ; RUN: llvm-nm %t3.2 | FileCheck %s --check-prefix=NM
 ; NM: _ZL3barv
-; RUN: llvm-dis < %t3.2.2.internalize.bc | FileCheck %s --check-prefix=INTERNALIZE
+; RUN: llvm-dis < %t3.3.2.internalize.bc | FileCheck %s --check-prefix=INTERNALIZE
 ; INTERNALIZE: define dso_local void @_ZL3barv
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 @fptr = local_unnamed_addr global void ()* null, align 8
 
 ; Function Attrs: norecurse uwtable

llvm/test/tools/gold/X86/thinlto.ll

 ; Test --plugin-opt=obj-path to ensure unique object files generated.
 ; RUN: rm -f %t5.o %t5.o1
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold%shlibext \
 ; RUN:    -m elf_x86_64 \
 ; RUN:    --plugin-opt=thinlto \
 ; RUN:    --plugin-opt=jobs=2 \
 ; RUN:    --plugin-opt=obj-path=%t5.o \
 ; RUN:    -shared %t.o %t2.o -o %t4
-; RUN: llvm-nm %t5.o | FileCheck %s --check-prefix=NM2
 ; RUN: llvm-nm %t5.o1 | FileCheck %s --check-prefix=NM2
+; RUN: llvm-nm %t5.o2 | FileCheck %s --check-prefix=NM2
+
+; Test to ensure that thinlto-index-only with obj-path creates the file.
+; RUN: rm -f %t5.o %t5.o1
+; RUN: %gold -plugin %llvmshlibdir/LLVMgold%shlibext \
+; RUN:    -m elf_x86_64 \
+; RUN:    --plugin-opt=thinlto \
+; RUN:    --plugin-opt=jobs=2 \
+; RUN:    --plugin-opt=thinlto-index-only \
+; RUN:    --plugin-opt=obj-path=%t5.o \
+; RUN:    -shared %t.o %t2.o -o %t4
+; RUN: llvm-readobj -h %t5.o | FileCheck %s --check-prefix=FORMAT
+; RUN: llvm-nm %t5.o | count 0
 
 ; NM: T f
 ; NM2: T {{f|g}}
+; FORMAT: Format: ELF64-x86-64
 
 ; The backend index for this module contains summaries from itself and
 ; Inputs/thinlto.ll, as it imports from the latter.
 ; BACKEND1: <MODULE_STRTAB_BLOCK
 ; BACKEND1-NEXT: <ENTRY {{.*}} record string = '{{.*}}/test/tools/gold/X86/Output/thinlto.ll.tmp{{.*}}.o'
 ; BACKEND1-NEXT: <ENTRY {{.*}} record string = '{{.*}}/test/tools/gold/X86/Output/thinlto.ll.tmp{{.*}}.o'
 ; BACKEND1-NEXT: </MODULE_STRTAB_BLOCK
 ; BACKEND1-NEXT: <GLOBALVAL_SUMMARY_BLOCK