[LTO] Add a function `LTOCodeGenerator::getMergedModule`

[tianshilei1992]

Summary

One of the uses of LTOCodeGenerator is to take it as a middle+back end. Sometimes
it is very helpful to access, especially get information from the optimized module.
If the information can be changed in optimization, it cannot be get before the
module is added to LTOCodeGenerator. This patch adds a function
LTOCodeGenerator::getMergedModule to access the MergedModule.

[steven_wu]

The change is fine. Can you elaborate a bit more about your use case? Or at least add a test for it?

[steven_wu]

Few things to improve before commit:

• Drop the words like "in my case", "I", etc. from the commit message. Eg, In my case, after optimize is called, I need to access the underlying module to get information. can be rewritten as API can be used to access the underlying module to get information after optimized is called. It would sound much better.
• Please add a use-case of the API in test suite otherwise it can be removed as dead code. You can look into getting it used in llvm-lto tool and add a testcase to exercise the code path.

[tianshilei1992]

add an option in llvm-lto to dump linked module

[tianshilei1992]

add a test case

[steven_wu]

Thanks! LGTM now.

[tianshilei1992]

In D114201#3189304, @steven_wu wrote:

Thanks! LGTM now.

Thanks for your review!

[tianshilei1992]

Reopen to resolve building issues reported by build bolt.

[tianshilei1992]

I cannot reproduce the failure on my side. Will re-land the patch.

[tianshilei1992]

It seems like the root cause of link error reported in many BuildBolt is Module::dump is stripped in release mode. Probably should not use that function at the first place. Need to come up with another way to test.

[tianshilei1992]

@steven_wu Do you have any suggestion on how to test it in llvm-lto? I can't find a feasible use of the function in llvm-lto.

[tianshilei1992]

don't know how to test it

llvm/include/llvm/LTO/legacy/LTOCodeGenerator.h

struct LTOCodeGenerator {
 
   void setDiagnosticHandler(lto_diagnostic_handler_t, void *);
 
   LLVMContext &getContext() { return Context; }
 
   void resetMergedModule() { MergedModule.reset(); }
   void DiagnosticHandler(const DiagnosticInfo &DI);
 
+  Module &getMergedModule() { return *MergedModule; }
+
 private:
   /// Verify the merged module on first call.
   ///
   /// Sets \a HasVerifiedInput on first call and doesn't run again on the same
   /// input.
   void verifyMergedModuleOnce();
 
   bool compileOptimizedToFile(const char **Name);

llvm/test/tools/llvm-lto/dump.ll

+; RUN: llvm-as < %s > %t1
+; RUN: llvm-lto --dump-linked-module %t1 2>&1 | FileCheck %s
+
+; CHEKCK: target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+
+; CHECK: define void @f() {
+define void @f() {
+; CHECK-NEXT: entry:
+entry:
+; CHECK-NEXT: ret void
+  ret void
+; CHECK-NEXT: }
+}

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

static cl::opt<bool> SaveLinkedModuleFile(
     cl::desc("Write linked LTO module to file before optimize"),
     cl::cat(LTOCategory));
 
 static cl::opt<bool>
     SaveModuleFile("save-merged-module", cl::init(false),
                    cl::desc("Write merged LTO module to file before CodeGen"),
                    cl::cat(LTOCategory));
 
+static cl::opt<bool>
+    DumpLinkedModule("dump-linked-module", cl::init(false),
+                     cl::desc("Dump linked LTO module before optimize"),
+                     cl::cat(LTOCategory));
+
 static cl::list<std::string> InputFilenames(cl::Positional, cl::OneOrMore,
                                             cl::desc("<input bitcode files>"),
                                             cl::cat(LTOCategory));
 
 static cl::opt<std::string> OutputFilename("o", cl::init(""),
                                            cl::desc("Override output filename"),
                                            cl::value_desc("filename"),
                                            cl::cat(LTOCategory));
bool handleDiagnostics(const DiagnosticInfo &DI) override {
         break;
       case DS_Note:
         OS << "note";
         break;
       }
       if (!CurrentActivity.empty())
         OS << ' ' << CurrentActivity;
       OS << ": ";
-  
       DiagnosticPrinterRawOStream DP(OS);
       DI.print(DP);
       OS << '\n';
-  
       if (DI.getSeverity() == DS_Error)
         exit(1);
       return true;
     }
   };
   }
 
 static void error(const Twine &Msg) {
auto AddStream = [&](size_t Task) -> std::unique_ptr<CachedFileStream> {
       return std::make_unique<CachedFileStream>(std::move(S));
     };
 
     if (!CodeGen.compileOptimized(AddStream, Parallelism))
       // Diagnostic messages should have been printed by the handler.
       error("error compiling the code");
 
   } else {
+    if (DumpLinkedModule) {
+      if (SaveLinkedModuleFile)
+        error(": -dump-linked-module must be used without -dump-linked-module");
+
+      Module &M = CodeGen.getMergedModule();
+      M.dump();
+    }
+
     if (Parallelism != 1)
       error("-j must be specified together with -o");
 
     if (SaveModuleFile)
       error(": -save-merged-module must be specified with -o");
 
     const char *OutputName = nullptr;
     if (!CodeGen.compile_to_file(&OutputName))
       error("error compiling the code");
       // Diagnostic messages should have been printed by the handler.
 
     outs() << "Wrote native object file '" << OutputName << "'\n";
   }
 
   return 0;
 }