[LTO] Suppress emission of empty combined module by default

[khchen]

Summary

That unless the user requested an output object (--lto-obj-path), the an unused empty combined module is not emitted.

This changed is helpful for some target (ex. RISCV-V) which encoded the ABI info in IR module flags (target-abi). Empty unused module has no ABI info so the linker would get the linking error during merging incompatible ABIs. target-abi had discussed in http://lists.llvm.org/pipermail/llvm-dev/2020-January/138151.html.

[khchen]

sorry, my fault, there are two failing tests I need to fix first.

[khchen]

fixed linker-script-symbols-assign.ll, now lto would not generate empty module (%t2.lto.o)
fixed typo and format.

[tejohnson]

I know you said you needed to fix a few test failures, but I have some comments/questions on the first version of the patch anyway.

llvm/include/llvm/LTO/Config.h

71

Since this only applies to the regular LTO object, would be better to call this something more specific, like AlwaysEmitRegularLTOObj.

llvm/lib/LTO/LTOBackend.cpp

503 ↗

(On Diff #260574)

Just to clarify my assumption, you are doing this here rather than down in codegen because for ThinLTO modules we want to produce an object even when an empty module is explicitly linked for some reason?

Rather than that series of checks, I think it would be better to just include a flag on the RegularLTOState to indicate whether addRegularLTO was ever called. It's clearer and probably less fragile.

Also - what is the value of calling the hook if it is an empty default module that wasn't added by the link, and that we aren't going to code gen?

llvm/tools/gold/gold-plugin.cpp

1067

Why are all these changes needed, since you are addressing this within LTO to not emit the empty object file?

[khchen]

Hi @tejohnson
I'm very appreciate your help and comment,
because I'm not LTO expert, so if you have any good idea and concern in implementation
Please don't hesitate to correct me, thanks.

llvm/include/llvm/LTO/Config.h

71

okay, I will fix it.

llvm/lib/LTO/LTOBackend.cpp

503 ↗

(On Diff #260574)

Just to clarify my assumption, you are doing this here rather than down in codegen because for ThinLTO modules we want to produce an object even when an empty module is explicitly linked for some reason?

There are 3 tests got failed if moving this code into codegen,

1. LLVM :: ThinLTO/X86/empty_module_with_cache.ll

https://github.com/llvm/llvm-project/blob/master/llvm/test/ThinLTO/X86/empty_module_with_cache.ll#L4
In current caching mechanism, it should work even if the module is empty.

2. Clang :: CodeGen/thinlto_backend.ll

https://github.com/llvm/llvm-project/blob/master/clang/test/CodeGen/thinlto_backend.ll#L27
The output is empty file (not empty obj file) which llvm-nm can not recognize it.

3. LLVM :: tools/gold/X86/cache.ll

https://github.com/llvm/llvm-project/blob/master/llvm/test/tools/gold/X86/cache.ll#L27
after opt phase, %t2 (cache.ll.tmp2.o.4.opt.bc) is empty module, so there is no %t2 cache file.

Rather than that series of checks, I think it would be better to just include a flag on the RegularLTOState to indicate whether addRegularLTO was ever called. It's clearer and probably less fragile.

okay, I will try it.

Also - what is the value of calling the hook if it is an empty default module that wasn't added by the link, and that we aren't going to code gen?

Sorry, I don't understand the question, HookOnly is used to suppress codegen but still emit temp file for debugging, than the gold ld wasn't store empty Buf[Task] as file and link it.

llvm/tools/gold/gold-plugin.cpp

1067

original implementation always generates file including empty module which generate empty file. (not object file)

This implementation reference lld.
In https://reviews.llvm.org/D78035#inline-719821 as you mentioned we can "possibly make the Files array a tuple with another bool flag indicating whether the obj file buffer was empty." but I could not find a good place to store empty info when calling lto::backend.

any suggestion?

[tejohnson]

llvm/lib/LTO/LTOBackend.cpp

503 ↗

(On Diff #260574)

Sorry, I don't understand the question, HookOnly is used to suppress codegen but still emit temp file for debugging, than the gold ld wasn't store empty Buf[Task] as file and link it.

What I meant was that I don't think we need to execute the hook, if this is an empty combined module that doesn't correspond to any incoming linked module and that we aren't going to codegen. I.e. don't even call codegen in this case.

llvm/tools/gold/gold-plugin.cpp

1067

That was an alternate suggestion, instead of changing LTO, since you mentioned lld worked fine. Since you are suppressing the object file in LTO, is any change needed here? AddStream isn't called until down in codegen(), and with your change that isn't being executed. So presumably no change is needed here to prevent the empty object from being passed back to gold.

[khchen]

address @tejohnson's comments

[khchen]

llvm/tools/gold/gold-plugin.cpp

1067

You are right, thanks!

[tejohnson]

Thanks, the changes make more sense to me now with the gold plugin changes removed. I have some more comments below. Once this is cleaned up a bit more I will give it a quick test or so internally to make sure it doesn't break our flow (I don't think so but worth a check).

lld/test/ELF/lto/linker-script-symbols-assign.ll

6

Is this change still valid with your new approach of keeping a flag on the RegularLTO state object? Or is lld not even sending the object to LTO? If so, probably should check now that this file isn't created.

8

Looks like these orphan checks were left behind when a recent change updated the test...

llvm/include/llvm/LTO/Config.h

69

Suggest making the first sentence "Always emit a Regular LTO object even when it is empty because no Regular LTO modules were linked."

Also, s/usedful/useful/

llvm/lib/LTO/LTO.cpp

1030

Actually, do we even need to call backend() if (!EmptyCombinedModule || C.AlwaysEmitRegularLTOObj) ? It doesn't seem like there should be any need to create a TM or call opt in that case either. And as I note in backend(), there's no need to do the splitCodeGen handling either.

llvm/lib/LTO/LTOBackend.cpp

497 ↗

(On Diff #260881)

Move this check out a level and guard both this and the splitCodeGen call the same way (split codegen isn't commonly used, but it makes sense to be consistent - splitCodeGen will ultimately call codegen()).

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

2–3

Presumably %t2.0 is the empty combined module. Should it be emitted after your change? Oh I see, this is related to your llvm-lto2 change. I'll add a comment there.

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

1 ↗

(On Diff #260881)

"empty combined module"

However, I'm unsure what this new test is trying to check that is different than the existing empty-module.ll.

Are you trying to confirm that we emit an empty ThinLTO module (corresponding to %t2.bc) but not the empty combined module? If so, please clarify in description.

2 ↗

(On Diff #260881)

rm -f %t.*
probably better

9 ↗

(On Diff #260881)

rm -f %t3.*
?

14 ↗

(On Diff #260881)

Is there a missing FileCheck corresponding to these?

llvm/tools/llvm-lto2/llvm-lto2.cpp

289 ↗

(On Diff #260881)

Why this change? This is inconsistent with the linker behavior under the corresponding option (e.g. gold plugin's thinlto-index-only).

[khchen]

rebase master

[khchen]

1. Add empty combined module checking before call backend()
2. Appling new approach, some testcasess need to updated and deleted. In checking module empty approach, it can suppress emitting optimzed empty combined module, but in new approach, it still emit combined module. I thought new approach behavior is acceptable. This case happend in linker-script-symbols-assign.ll.
3. Delete llvm/test/ThinLTO/X86/empty-object.ll. I misunderstood -thinlto-distributed-indexes option meaning. I add this case just becasue becuase I modified llvm-lto2. I think testing in empty-module.ll is enough. This patch focus on empty combined module, I think we don't need to comfirm "empty ThinLTO module" still be emitted.

[khchen]

lld/test/ELF/lto/linker-script-symbols-assign.ll

6

In new approach this test passed because input bitcode is not empty, (it will be empty after opt phase).

llvm/lib/LTO/LTO.cpp

1030

Yes, you are right, we don't need to call backend()

[MaskRay]

lld/test/ELF/lto/linker-script-symbols-assign.ll

7

Use ;; for comments. For newer tests we are enforcing this rule.

lld/test/ELF/lto/thinlto-obj-path.ll

18

%T is currently deprecated. You can use rm -fr %t.dir && mkdir %t.dir/objpath

20

--save-temps

Unless the single dash option is prevailing (-pie -shared etc), we prefer double-dash long options.

[MaskRay]

lld/test/ELF/lto/thinlto-obj-path.ll

18

rm -fr %t.dir && mkdir -p %t.dir/objpath

[khchen]

1. Rebase on master branch.
2. update lld testcases

[khchen]

@MaskRay Thanks for your suggestion and reminder.

[tejohnson]

This looks good to me but let me give it some quick sanity checks internally today and will get back.

[tejohnson]

lgtm

Before you submit, please update the patch description to reflect the current behavior (e.g. that unless the user requested an output object, the an unused empty combined module is not emitted). Also the patch title could be more specific, e.g. [LTO] Suppress emission of empty combined module by default

[MaskRay]

That unless the user requested an output object (-lto-obj-path)

Use --lto-obj-path. -l is a very common and conflicting option.

lld/test/COFF/lto-obj-path.ll

14

Use either lld or lld-link

[khchen]

address @MaskRay's review feedback

[MaskRay]

lld/test/ELF/lto/linker-script-symbols-assign.ll

8

s/ld/lld/

[khchen]

s/ld/lld/

lld/COFF/LTO.cpp

static lto::Config createConfig() {
   else
     c.RelocModel = Reloc::PIC_;
   c.DisableVerify = true;
   c.DiagHandler = diagnosticHandler;
   c.OptLevel = config->ltoo;
   c.CPU = getCPUStr();
   c.MAttrs = getMAttrs();
   c.CGOptLevel = args::getCGOptLevel(config->ltoo);
+  c.AlwaysEmitRegularLTOObj = !config->ltoObjPath.empty();
 
   if (config->saveTemps)
     checkError(c.addSaveTemps(std::string(config->outputFile) + ".",
                               /*UseInputModulePath*/ true));
   return c;
 }
 
 BitcodeCompiler::BitcodeCompiler() {

lld/ELF/LTO.cpp

static lto::Config createConfig() {
   c.RemarksFormat = std::string(config->optRemarksFormat);
 
   c.SampleProfile = std::string(config->ltoSampleProfile);
   c.UseNewPM = config->ltoNewPassManager;
   c.DebugPassManager = config->ltoDebugPassManager;
   c.DwoDir = std::string(config->dwoDir);
 
   c.HasWholeProgramVisibility = config->ltoWholeProgramVisibility;
+  c.AlwaysEmitRegularLTOObj = !config->ltoObjPath.empty();
 
   c.TimeTraceEnabled = config->timeTraceEnabled;
   c.TimeTraceGranularity = config->timeTraceGranularity;
 
   c.CSIRProfile = std::string(config->ltoCSProfileFile);
   c.RunCSIRInstr = config->ltoCSProfileGenerate;
 
   if (config->emitLLVM) {
std::vector<InputFile *> BitcodeCompiler::compile() {
 
   if (!config->ltoObjPath.empty()) {
     saveBuffer(buf[0], config->ltoObjPath);
     for (unsigned i = 1; i != maxTasks; ++i)
       saveBuffer(buf[i], config->ltoObjPath + Twine(i));
   }
 
   if (config->saveTemps) {
+    if (!buf[0].empty())
       saveBuffer(buf[0], config->outputFile + ".lto.o");
     for (unsigned i = 1; i != maxTasks; ++i)
       saveBuffer(buf[i], config->outputFile + Twine(i) + ".lto.o");
   }
 
   if (config->ltoEmitAsm) {
     saveBuffer(buf[0], config->outputFile);
     for (unsigned i = 1; i != maxTasks; ++i)
       saveBuffer(buf[i], config->outputFile + Twine(i));

lld/test/COFF/lto-obj-path.ll

 ; REQUIRES: x86
 
 ; Test to ensure that thinlto-index-only with lto-obj-path creates
 ; the native object file.
 ; RUN: opt -module-summary %s -o %t1.obj
 ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.obj
 ; RUN: rm -f %t4.obj
 ; RUN: lld-link -thinlto-index-only -lto-obj-path:%t4.obj -out:t3.exe \
 ; RUN:     -entry:main %t1.obj %t2.obj
 ; RUN: llvm-readobj -h %t4.obj | FileCheck %s
 ; RUN: llvm-nm %t4.obj 2>&1 | FileCheck %s -check-prefix=SYMBOLS
 ; RUN: llvm-nm %t4.obj 2>&1 | count 1
 
+;; Ensure lld emits empty combined module if specific obj-path.
+; RUN: rm -fr %t.dir/objpath && mkdir -p %t.dir/objpath
+; RUN: lld-link /out:%t.dir/objpath/a.exe -lto-obj-path:%t4.obj \
+; RUN:     -entry:main %t1.obj %t2.obj -lldsavetemps
+; RUN: ls %t.dir/objpath/a.exe.lto.* | count 3
+
+;; Ensure lld does not emit empty combined module in default.
+; RUN: rm -fr %t.dir/objpath && mkdir -p %t.dir/objpath
+; RUN: lld-link /out:%t.dir/objpath/a.exe \
+; RUN:     -entry:main %t1.obj %t2.obj -lldsavetemps
+; RUN: ls %t.dir/objpath/a.exe.lto.* | count 2
+
 ; CHECK: Format: COFF-x86-64
 ; SYMBOLS: @feat.00
 
 target datalayout = "e-m:w-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.24215"
 
 declare void @g(...)
 
 define void @main() {
   call void (...) @g()
   ret void
 }

lld/test/COFF/pdb-thinlto.ll

define i32 @main() {
   call void @foo()
   ret i32 0
 }
 
 declare void @foo()
 
 ; CHECK:                           Modules
 ; CHECK: ============================================================
-; CHECK: Mod 0000 | `{{.*}}main.exe.lto.obj`:
-; CHECK: Obj: `{{.*}}main.exe.lto.obj`:
-; CHECK: Mod 0001 | `{{.*}}main.exe.lto.1.obj`:
+; CHECK: Mod 0000 | `{{.*}}main.exe.lto.1.obj`:
 ; CHECK: Obj: `{{.*}}main.exe.lto.1.obj`:
-; CHECK: Mod 0002 | `{{.*}}main.exe.lto.2.obj`:
+; CHECK: Mod 0001 | `{{.*}}main.exe.lto.2.obj`:
 ; CHECK: Obj: `{{.*}}main.exe.lto.2.obj`:
-; CHECK: Mod 0003 | `* Linker *`:
+; CHECK: Mod 0002 | `* Linker *`:

lld/test/ELF/lto/linker-script-symbols-assign.ll

 ; REQUIRES: x86
 ; RUN: llvm-as %s -o %t.o
 
+; RUN: rm -f %t2.*
 ; RUN: echo "foo = 1;" > %t.script
 ; RUN: ld.lld %t.o -o %t2 --script %t.script -save-temps
+;; Combined module is not empty, but it will be empty after optimization.
+;; Ensure lld still emits empty combined obj in this case.
 ; RUN: llvm-nm %t2.lto.o | count 0
 
-; CHECK-NOT: bar
-; CHECK-NOT: foo
-
 ; RUN: llvm-readobj --symbols %t2 | FileCheck %s --check-prefix=VAL
 ; VAL:       Symbol {
 ; VAL:        Name: foo
 ; VAL-NEXT:   Value: 0x1
 ; VAL-NEXT:   Size:
 ; VAL-NEXT:   Binding: Global
 ; VAL-NEXT:   Type: None
 ; VAL-NEXT:   Other:

lld/test/ELF/lto/thinlto-obj-path.ll

 ; REQUIRES: x86
 
 ; RUN: opt -module-summary %s -o %t1.o
 ; RUN: opt -module-summary %p/Inputs/thinlto.ll -o %t2.o
 
 ; Test to ensure that thinlto-index-only with obj-path creates the file.
 ; RUN: rm -f %t4.o
 ; RUN: ld.lld --plugin-opt=thinlto-index-only --plugin-opt=obj-path=%t4.o -shared %t1.o %t2.o -o /dev/null
 ; RUN: llvm-readobj -h %t4.o | FileCheck %s
 ; RUN: llvm-nm %t4.o 2>&1 | count 0
 
 ; Check that this also works without the --plugin-opt= prefix.
 ; RUN: rm -f %t4.o
 ; RUN: ld.lld -thinlto-index-only -lto-obj-path=%t4.o -shared %t1.o %t2.o -o /dev/null
 ; RUN: llvm-readobj -h %t4.o | FileCheck %s
 
+;; Ensure lld emits empty combined module if specific obj-path.
+; RUN: rm -fr %t.dir/objpath && mkdir -p %t.dir/objpath
+; RUN: ld.lld --plugin-opt=obj-path=%t4.o -shared %t1.o %t2.o -o %t.dir/objpath/a.out --save-temps
+; RUN: ls %t.dir/objpath/a.out*.lto.* | count 3
+
+;; Ensure lld does not emit empty combined module in default.
+; RUN: rm -fr %t.dir/objpath && mkdir -p %t.dir/objpath
+; RUN: ld.lld %t1.o %t2.o -o %t.dir/objpath/a.out --save-temps
+; RUN: ls %t.dir/objpath/a.out*.lto.* | count 2
+
 ; CHECK: Format: elf64-x86-64
 
 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 void @g(...)
 
 define void @f() {
 entry:
   call void (...) @g()
   ret void
 }

llvm/include/llvm/LTO/Config.h

struct Config {
 
   /// Run PGO context sensitive IR instrumentation.
   bool RunCSIRInstr = false;
 
   /// Asserts whether we can assume whole program visibility during the LTO
   /// link.
   bool HasWholeProgramVisibility = false;
 
+  /// Always emit a Regular LTO object even when it is empty because no Regular
+  /// LTO modules were linked. This option is useful for some build system which
+  /// want to know a priori all possible output files.
+  bool AlwaysEmitRegularLTOObj = false;
+
   /// If this field is set, the set of passes run in the middle-end optimizer
   /// will be the one specified by the string. Only works with the new pass
   /// manager as the old one doesn't have this ability.
   std::string OptPipeline;
 
   // If this field is set, it has the same effect of specifying an AA pipeline
   // identified by the string. Only works with the new pass manager, in
   // conjunction OptPipeline.

llvm/include/llvm/LTO/LTO.h

struct RegularLTOState {
     // 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;
+    bool EmptyCombinedModule = true;
   } RegularLTO;
 
   struct ThinLTOState {
     ThinLTOState(ThinBackend Backend);
 
     ThinBackend Backend;
     ModuleSummaryIndex CombinedIndex;
     MapVector<StringRef, BitcodeModule> ModuleMap;

llvm/lib/LTO/LTO.cpp

Error LTO::addModule(InputFile &Input, unsigned ModI,
   auto ModSyms = Input.module_symbols(ModI);
   addModuleToGlobalRes(ModSyms, {ResI, ResE},
                        LTOInfo->IsThinLTO ? ThinLTO.ModuleMap.size() + 1 : 0,
                        LTOInfo->HasSummary);
 
   if (LTOInfo->IsThinLTO)
     return addThinLTO(BM, ModSyms, ResI, ResE);
 
+  RegularLTO.EmptyCombinedModule = false;
   Expected<RegularLTOState::AddedModule> ModOrErr =
       addRegularLTO(BM, ModSyms, ResI, ResE);
   if (!ModOrErr)
     return ModOrErr.takeError();
 
   if (!LTOInfo->HasSummary)
     return linkRegularLTO(std::move(*ModOrErr), /*LivenessFromIndex=*/false);
 
if (!Conf.CodeGenOnly) {
     }
 
     RegularLTO.CombinedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
 
     if (Conf.PostInternalizeModuleHook &&
         !Conf.PostInternalizeModuleHook(0, *RegularLTO.CombinedModule))
       return Error::success();
   }
-  if (Error Err =
-          backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
-                  std::move(RegularLTO.CombinedModule), ThinLTO.CombinedIndex))
+
+  if (!RegularLTO.EmptyCombinedModule || Conf.AlwaysEmitRegularLTOObj) {
+    if (Error Err = backend(
+            Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
       return Err;
+  }
 
   return finalizeOptimizationRemarks(std::move(*DiagFileOrErr));
 }
 
 static const char *libcallRoutineNames[] = {
 #define HANDLE_LIBCALL(code, name) name,
 #include "llvm/IR/RuntimeLibcalls.def"
 #undef HANDLE_LIBCALL

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

 ; RUN: opt -module-summary -o %t.bc %s
 
-; 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 2>&1 | count 0
-
-; CHECK: Format: elf64-x86-64
+; RUN: rm -f %t2.*
+; RUN: llvm-lto2 run %t.bc -r %t.bc,foo,pl -o %t2 -thinlto-distributed-indexes -save-temps
+; Ensure lto does not emit empty combined module.
+; RUN: test ! -e %t2.0
+; Ensure empty combined module has only 2 temp files.
+; RUN: ls %t2.0.*.bc | count 2
 
 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"
 
 @foo = ifunc i32 (i32), i64 ()* @foo_ifunc
 
 define internal i64 @foo_ifunc() {
 entry:
   ret i64 0
 }

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

 ; RUN: llvm-bcanalyzer -dump %t.o.thinlto.bc | FileCheck %s --check-prefix=BACKEND1
 ; RUN: llvm-bcanalyzer -dump %t2.o.thinlto.bc | FileCheck %s --check-prefix=BACKEND2
 ; RUN: llvm-dis %t.o.thinlto.bc -o - | FileCheck %s --check-prefix=DIS1
 ; RUN: llvm-dis %t2.o.thinlto.bc -o - | FileCheck %s --check-prefix=DIS2
 ; RUN: not test -e %t3
 
 ; Ensure gold generates an index as well as a binary with save-temps in ThinLTO mode.
 ; First force single-threaded mode
+; RUN: rm -f %t4*
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold%shlibext \
 ; RUN:    -m elf_x86_64 \
 ; RUN:    --plugin-opt=save-temps \
 ; RUN:    --plugin-opt=thinlto \
 ; RUN:    --plugin-opt=jobs=1 \
 ; RUN:    -shared %t.o %t2.o -o %t4
 ; RUN: llvm-bcanalyzer -dump %t4.index.bc | FileCheck %s --check-prefix=COMBINED
 ; RUN: llvm-nm %t4 | FileCheck %s --check-prefix=NM
+; Ensure ld does not emit empty combined module in default.
+; RUN: ls %t4.o* | count 2
 
 ; Check with --no-map-whole-files
 ; RUN: %gold -plugin %llvmshlibdir/LLVMgold%shlibext \
 ; RUN:    -m elf_x86_64 \
 ; RUN:    --plugin-opt=save-temps \
 ; RUN:    --plugin-opt=thinlto \
 ; RUN:    --plugin-opt=jobs=1 \
 ; RUN:    --no-map-whole-files \

 ; 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.o1 | FileCheck %s --check-prefix=NM2
 ; RUN: llvm-nm %t5.o2 | FileCheck %s --check-prefix=NM2
+; Ensure ld emits empty combined module if specific obj-path.
+; RUN: ls %t5.o* | count 3
 
 ; 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 \

llvm/tools/gold/gold-plugin.cpp

static std::unique_ptr<LTO> createLTO(IndexWriteCallback OnIndexWrite,
   Conf.MAttrs = codegen::getMAttrs();
   Conf.RelocModel = RelocationModel;
   Conf.CodeModel = codegen::getExplicitCodeModel();
   Conf.CGOptLevel = getCGOptLevel();
   Conf.DisableVerify = options::DisableVerify;
   Conf.OptLevel = options::OptLevel;
   Conf.PTO.LoopVectorization = options::OptLevel > 1;
   Conf.PTO.SLPVectorization = options::OptLevel > 1;
+  Conf.AlwaysEmitRegularLTOObj = !options::obj_path.empty();
 
   if (options::thinlto_index_only) {
     std::string OldPrefix, NewPrefix;
     getThinLTOOldAndNewPrefix(OldPrefix, NewPrefix);
     Backend = createWriteIndexesThinBackend(OldPrefix, NewPrefix,
                                             options::thinlto_emit_imports_files,
                                             LinkedObjectsFile, OnIndexWrite);
   } else {
static std::vector<std::pair<SmallString<128>, bool>> runLTO() {
 
   auto AddStream =
       [&](size_t Task) -> std::unique_ptr<lto::NativeObjectStream> {
     Files[Task].second = !SaveTemps;
     int FD = getOutputFileName(Filename, /* TempOutFile */ !SaveTemps,
                                Files[Task].first, Task);
     return std::make_unique<lto::NativeObjectStream>(
         std::make_unique<llvm::raw_fd_ostream>(FD, true));
   };
 
   auto AddBuffer = [&](size_t Task, std::unique_ptr<MemoryBuffer> MB) {
     *AddStream(Task)->OS << MB->getBuffer();
   };
 
   NativeObjectCache Cache;
   if (!options::cache_dir.empty())
     Cache = check(localCache(options::cache_dir, AddBuffer));