[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/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 (Error Err = F->materialize())
+          return std::move(Err);
         OptimizationRemarkEmitter ORE(F, nullptr);
         ORE.emit(OptimizationRemark(DEBUG_TYPE, "deadfunction", F)
                  << ore::NV("Function", F)
                  << " not added to the combined module ");
       }
       continue;
     }
 

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)
 No newline at end of file