[LTO] Emit DebugLoc for dead function in optimization remarks

[Enna1]

Summary

Currently, the dead functions information getting from optimizations remarks does not contain debug location, but knowing where these dead functions locate could be useful for debugging or for detecting dead code.

Cause in LTO::addRegularLTO() we use BitcodeModule::getLazyModule() to read the bitcode module, when we pass Function F to ore::NV(), F is not materialized, so F->getSubprogram() returns nullptr, and there is no debug location information of dead functions in optimizations remarks.

This patch call F->materialize() before we pass Function F to ore::NV(), then debug location information will be emitted for dead functions in optimization remarks.

[dblaikie]

Could you include a test case?

[Enna1]

Add test case.

[tejohnson]

llvm/lib/LTO/LTO.cpp

860

Were we eventually materializing these dead functions without this change? If not, this seems like a compile time degradation. Would it work to move the materialize call later, capture the OptimizationRemark in a variable, and guard the materialization by isEnabled() on the remark?

[Enna1]

llvm/lib/LTO/LTO.cpp

860

Thanks for your comment!
Yes, this will cause a compile time degradation, without this change these dead function will never be materialized.
To emit DebugLoc for dead function in optimization remarks, we must call F->materialize before ORE(F, nullptr); and ore::NV("Function", F).
I'm looking for a variable which indicates whether we enable emit OptimizationRemark or not, we can use such variable to guard the materialization.
Here are some solutions came up to me:

1. Check if Conf.RemarksFilename is empty, only materializing these dead functions when Conf.RemarksFilename is not empty.
2. In LTO::linkRegularLTO collect all dead functions, and in lto::finalizeOptimizationRemarks call materialize and OptimizationRemarkEmitter for all dead functions. This will introduce a variable to store all dead functions.

Thanks again!

[Enna1]

Addressed review comment.

[tejohnson]

lgtm

llvm/lib/LTO/LTO.cpp

860

Ah, it also looks like the Function will need to be materialized before the OptimizationRemark constructor call, which was what my suggested solution would have required. Your solution looks ok to me.

[Enna1]

In D109737#3003172, @tejohnson wrote:

lgtm

I don't have commit access, could you help to commit this patch? Thanks!

llvm/include/llvm/LTO/LTO.h

private:
   mutable bool CalledGetMaxTasks = false;
 
   // Use Optional to distinguish false from not yet initialized.
   Optional<bool> EnableSplitLTOUnit;
 
   // Identify symbols exported dynamically, and that therefore could be
   // referenced by a shared library not visible to the linker.
   DenseSet<GlobalValue::GUID> DynamicExportSymbols;
+
+  // Diagnostic optimization remarks file
+  std::unique_ptr<ToolOutputFile> DiagnosticOutputFile;
 };
 
 /// 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()
       : Prevailing(0), FinalDefinitionInLinkageUnit(0), VisibleToRegularObj(0),
         ExportDynamic(0), LinkerRedefined(0) {}

llvm/lib/LTO/LTO.cpp

 }
 
 Error LTO::linkRegularLTO(RegularLTOState::AddedModule Mod,
                           bool LivenessFromIndex) {
   std::vector<GlobalValue *> Keep;
   for (GlobalValue *GV : Mod.Keep) {
     if (LivenessFromIndex && !ThinLTO.CombinedIndex.isGUIDLive(GV->getGUID())) {
       if (Function *F = dyn_cast<Function>(GV)) {
+        if (DiagnosticOutputFile) {
+          if (Error Err = F->materialize())
+            return Err;
           OptimizationRemarkEmitter ORE(F, nullptr);
           ORE.emit(OptimizationRemark(DEBUG_TYPE, "deadfunction", F)
                    << ore::NV("Function", F)
                    << " not added to the combined module ");
         }
+      }
       continue;
     }
 
     if (!GV->hasAvailableExternallyLinkage()) {
       Keep.push_back(GV);
       continue;
     }
 

 Error LTO::runRegularLTO(AddStreamFn AddStream) {
   // Setup optimization remarks.
   auto DiagFileOrErr = lto::setupLLVMOptimizationRemarks(
       RegularLTO.CombinedModule->getContext(), Conf.RemarksFilename,
       Conf.RemarksPasses, Conf.RemarksFormat, Conf.RemarksWithHotness,
       Conf.RemarksHotnessThreshold);
   if (!DiagFileOrErr)
     return DiagFileOrErr.takeError();
+  DiagnosticOutputFile = std::move(*DiagFileOrErr);
 
   // Finalize linking of regular LTO modules containing summaries now that
   // we have computed liveness information.
   for (auto &M : RegularLTO.ModsWithSummaries)
     if (Error Err = linkRegularLTO(std::move(M),
                                    /*LivenessFromIndex=*/true))
       return Err;
 
Error LTO::runRegularLTO(AddStreamFn AddStream) {
 
   if (!RegularLTO.EmptyCombinedModule || Conf.AlwaysEmitRegularLTOObj) {
     if (Error Err =
             backend(Conf, AddStream, RegularLTO.ParallelCodeGenParallelismLevel,
                     *RegularLTO.CombinedModule, ThinLTO.CombinedIndex))
       return Err;
   }
 
-  return finalizeOptimizationRemarks(std::move(*DiagFileOrErr));
+  return finalizeOptimizationRemarks(std::move(DiagnosticOutputFile));
 }
 
 static const char *libcallRoutineNames[] = {
 #define HANDLE_LIBCALL(code, name) name,
 #include "llvm/IR/RuntimeLibcalls.def"
 #undef HANDLE_LIBCALL
 };
 

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

 ; RUN: llvm-lto2 run %t -r %t,main,px -r %t,live1, -r %t,live2,p -r %t,dead2,p \
 ; RUN:               %t2 -r %t2,live1,p -r %t2,live2, -r %t2,dead1,p -r %t2,dead2, -r %t2,odr, \
 ; RUN:               -save-temps -o %t3 -O0
 ; RUN: llvm-nm %t3.0 | FileCheck --check-prefix=FULL %s
 ; RUN: llvm-nm %t3.1 | FileCheck --check-prefix=THIN %s
 
 ; REMARK:      Pass:            lto
 ; REMARK-NEXT: Name:            deadfunction
+; REMARK-NEXT: DebugLoc:        { File: test.c, Line: 4, Column: 0 }
 ; REMARK-NEXT: Function:        dead2
 ; REMARK-NEXT: Args:
 ; REMARK-NEXT:   - Function:        dead2
+; REMARK-NEXT:     DebugLoc:        { File: test.c, Line: 4, Column: 0 }
 ; REMARK-NEXT:   - String:          ' not added to the combined module '
 
 ; FULL-NOT: dead
 ; FULL: U live1
 ; FULL: T live2
 ; FULL: T main
 
 ; THIN-NOT: dead

 }
 
 declare void @live1()
 
 define void @live2() {
   ret void
 }
 
-define void @dead2() {
+define void @dead2() !dbg !7 {
   ret void
 }
 
-!0 = !{i32 1, !"ThinLTO", i32 0}
-!llvm.module.flags = !{ !0 }
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, isOptimized: false, emissionKind: LineTablesOnly, enums: !2)
+!1 = !DIFile(filename: "test.c", directory: "/")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 2}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"ThinLTO", i32 0}
+!7 = distinct !DISubprogram(name: "dead2", scope: !1, file: !1, line: 4, type: !8, isLocal: false, isDefinition: true, scopeLine: 4, isOptimized: false, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !2)