[LTO] Don't apply LTOPostLink module flag during writeMergedModule

[steven_wu]

Summary

For ld64 which uses legacy LTOCodeGenerator, it relies on
writeMergedModule to perform ld -r (generates a linked object file).
If all the inputs to ld -r is fullLTO bitcode, ld64 will linked the
bitcode module, internalize all the symbols and write out another
fullLTO bitcode object file. This bitcode file doesn't have all the
bitcode inputs and it should not have LTOPostLink module flag. It will
also cause error when this bitcode object file is linked with other LTO
object file.
Fix the issue by not applying LTOPostLink flag during writeMergedModule
function. The flag should only be added when all the bitcode are linked
and ready to be optimized.

rdar://problem/58462798

[steven_wu]

ping

[tejohnson]

lgtm

llvm/lib/LTO/LTOCodeGenerator.cpp

void LTOCodeGenerator::applyScopeRestrictions() {
   }
 
   // Update the llvm.compiler_used globals to force preserving libcalls and
   // symbols referenced from asm
   updateCompilerUsed(*MergedModule, *TargetMach, AsmUndefinedRefs);
 
   internalizeModule(*MergedModule, mustPreserveGV);
 
-  MergedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
-
   ScopeRestrictionsDone = true;
 }
 
 /// Restore original linkage for symbols that may have been internalized
 void LTOCodeGenerator::restoreLinkageForExternals() {
   if (!ShouldInternalize || !ShouldRestoreGlobalsLinkage)
     return;
 
bool LTOCodeGenerator::optimize(bool DisableVerify, bool DisableInline,
 
   // We always run the verifier once on the merged module, the `DisableVerify`
   // parameter only applies to subsequent verify.
   verifyMergedModuleOnce();
 
   // Mark which symbols can not be internalized
   this->applyScopeRestrictions();
 
+  // Write LTOPostLink flag for passes that require all the modules.
+  MergedModule->addModuleFlag(Module::Error, "LTOPostLink", 1);
+
   // Instantiate the pass manager to organize the passes.
   legacy::PassManager passes;
 
   // Add an appropriate DataLayout instance for this module...
   MergedModule->setDataLayout(TargetMach->createDataLayout());
 
   passes.add(
       createTargetTransformInfoWrapperPass(TargetMach->getTargetIRAnalysis()));

llvm/test/LTO/ARM/lto-linking-metadata.ll

 ; RUN: opt %s -o %t1.bc
 
-; RUN: llvm-lto %t1.bc -o %t1.save.opt -save-merged-module -O1 --exported-symbol=foo
+; RUN: llvm-lto %t1.bc -o %t1.save.opt -save-linked-module -save-merged-module -O1 --exported-symbol=foo
 ; RUN: llvm-dis < %t1.save.opt.merged.bc | FileCheck %s
+; RUN: llvm-dis < %t1.save.opt.linked.bc | FileCheck %s --check-prefix=CHECK-LINKED
 
 ; RUN: llvm-lto2 run %t1.bc -o %t.out.o -save-temps \
 ; RUN:     -r=%t1.bc,foo,pxl
 ; RUN: llvm-dis < %t.out.o.0.2.internalize.bc | FileCheck  %s
 
 target datalayout = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "armv7a-unknown-linux"
 
 define void @foo() {
 entry:
   ret void
 }
 
 ; CHECK: !llvm.module.flags = !{[[MD_NUM:![0-9]+]]}
 ; CHECK: [[MD_NUM]] = !{i32 1, !"LTOPostLink", i32 1}
+
+; CHECK-LINKED: @foo
+; CHECK-LINKED-NOT: LTOPostLink

llvm/tools/llvm-lto/llvm-lto.cpp

static cl::opt<std::string> ThinLTOSaveTempsPrefix(
     cl::desc("Save ThinLTO temp files using filenames created by adding "
              "suffixes to the given file path prefix."));
 
 static cl::opt<std::string> ThinLTOGeneratedObjectsDir(
     "thinlto-save-objects",
     cl::desc("Save ThinLTO generated object files using filenames created in "
              "the given directory."));
 
+static cl::opt<bool> SaveLinkedModuleFile(
+    "save-linked-module", cl::init(false),
+    cl::desc("Write linked LTO module to file before optimize"));
+
 static cl::opt<bool>
     SaveModuleFile("save-merged-module", cl::init(false),
                    cl::desc("Write merged LTO module to file before CodeGen"));
 
 static cl::list<std::string> InputFilenames(cl::Positional, cl::OneOrMore,
                                             cl::desc("<input bitcode files>"));
 
 static cl::opt<std::string> OutputFilename("o", cl::init(""),
if (!MAttrs.empty()) {
     std::string attrs = join(MAttrs, ",");
     CodeGen.setAttr(attrs);
   }
 
   if (auto FT = codegen::getExplicitFileType())
     CodeGen.setFileType(FT.getValue());
 
   if (!OutputFilename.empty()) {
+    if (SaveLinkedModuleFile) {
+      std::string ModuleFilename = OutputFilename;
+      ModuleFilename += ".linked.bc";
+      std::string ErrMsg;
+
+      if (!CodeGen.writeMergedModules(ModuleFilename))
+        error("writing linked module failed.");
+    }
+
     if (!CodeGen.optimize(DisableVerify, DisableInline, DisableGVNLoadPRE,
                           DisableLTOVectorization)) {
       // Diagnostic messages should have been printed by the handler.
       error("error optimizing the code");
     }
 
     if (SaveModuleFile) {
       std::string ModuleFilename = OutputFilename;