Omitting debug info function entry for functions that has no code.

[aaboud]

Summary

Stopped emitting function debug info if that function has no code (or alternatively, has no code associated with debug info).
Modified few LIT tests due to this change.

This patch is needed for "D11180" and should be committed first.

[aprantl]

I assume that a function without code will never get inlined, so this should not cause a problem with inlining.
David, could this affect overload resolution if it is a C++ method that is being eliminated?

[echristo]

Hmm? What's the motivation here?

-eric

[aaboud]

In D12426#235241, @echristo wrote:

Hmm? What's the motivation here?

-eric

As I said, we need this for the fix in D11180.
The example we are trying to fix is:
void f1() {

while (true) {
  struct nested {
    static void f2() {}
  };
  nested::f2();
}

}

Once we start supporting lexical block context for local types (i.e. the structure "nested" in the example), we assume that if a local type is needed, there must be a code in the lexical block containing that type or any of its nested blocks.
LexicalScopes component will handle any lexical block that contains code (directly or indirectly), but will skip those that does not have code.

In the above example (when compiled with "-inline") the lexical block "while" will contain no code, and thus will not be handled or emitted.
However, at endModule, we still try to emit an entry for the "nested::f2" function, even though there is no code associated to this function.
Doing that lead us trying to emit an entry for the structure "nested" because "f2" is a method in that structure, and there is where we will fail, because the lexical block "while" was not handled or created.

I discussed this with David, and suggested that we stop emitting such functions that has no association for source line, user will not be able to break in them anyway...

So, this is the reason for this patch.
Now the question would be: "is there any reason why we should not omit debug info for these functions?"

lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

DIE *DwarfCompileUnit::constructImportedEntityDIE(
   StringRef Name = Module->getName();
   if (!Name.empty())
     addString(*IMDie, dwarf::DW_AT_name, Name);
 
   return IMDie;
 }
 
 void DwarfCompileUnit::finishSubprogramDefinition(const DISubprogram *SP) {
-  DIE *D = getDIE(SP);
-  if (DIE *AbsSPDIE = DU->getAbstractSPDies().lookup(SP)) {
-    if (D)
+  if (DIE *D = getDIE(SP)) {
+    if (DIE *AbsSPDIE = DU->getAbstractSPDies().lookup(SP))
       // If this subprogram has an abstract definition, reference that
       addDIEEntry(*D, dwarf::DW_AT_abstract_origin, *AbsSPDIE);
-  } else {
-    if (!D && !includeMinimalInlineScopes())
-      // Lazily construct the subprogram if we didn't see either concrete or
-      // inlined versions during codegen. (except in -gmlt ^ where we want
-      // to omit these entirely)
-      D = getOrCreateSubprogramDIE(SP);
-    if (D)
+    else
       // And attach the attributes
       applySubprogramAttributesToDefinition(SP, *D);
   }
 }
 void DwarfCompileUnit::collectDeadVariables(const DISubprogram *SP) {
   assert(SP && "CU's subprogram list contains a non-subprogram");
   assert(SP->isDefinition() &&
          "CU's subprogram list contains a subprogram declaration");
   auto Variables = SP->getVariables();
   if (Variables.size() == 0)
     return;
 
   DIE *SPDIE = DU->getAbstractSPDies().lookup(SP);
   if (!SPDIE)
-    SPDIE = getDIE(SP);
+    return;
   assert(SPDIE);
   for (const DILocalVariable *DV : Variables) {
     DbgVariable NewVar(DV, /* IA */ nullptr, DD);
     auto VariableDie = constructVariableDIE(NewVar);
     applyVariableAttributes(NewVar, *VariableDie);
     SPDIE->addChild(std::move(VariableDie));
   }
 }

test/DebugInfo/X86/dbg-file-name.ll

 ; RUN: llc -enable-dwarf-directory -mtriple x86_64-apple-darwin10.0.0  < %s | FileCheck %s
 
 ; Radar 8884898
 ; CHECK: file 1 "simple.c"
 
 declare i32 @printf(i8*, ...) nounwind
 
 define i32 @main() nounwind {
-  ret i32 0
+  ret i32 0, !dbg !13
 }
 
 !llvm.dbg.cu = !{!2}
 !llvm.module.flags = !{!12}
 
 !1 = !DIFile(filename: "simple.c", directory: "/Users/manav/one/two")
 !2 = !DICompileUnit(language: DW_LANG_C89, producer: "LLVM build 00", isOptimized: true, emissionKind: 0, file: !10, enums: !11, retainedTypes: !11, subprograms: !9)
 !5 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !6 = !DISubprogram(name: "main", linkageName: "main", line: 9, isLocal: false, isDefinition: true, virtualIndex: 6, flags: DIFlagPrototyped, isOptimized: false, file: !10, scope: !1, type: !7, function: i32 ()* @main)
 !7 = !DISubroutineType(types: !8)
 !8 = !{!5}
 !9 = !{!6}
 !10 = !DIFile(filename: "simple.c", directory: "/Users/manav/one/two")
 !11 = !{}
 !12 = !{i32 1, !"Debug Info Version", i32 3}
+!13 = !DILocation(line: 10, scope: !6)

test/DebugInfo/X86/debug-dead-local-var.ll

 }
 
 attributes #0 = { nounwind readnone uwtable "less-precise-fpmad"="false" "no-frame-pointer-elim"="false" "no-infs-fp-math"="false" "no-nans-fp-math"="false" "stack-protector-buffer-size"="8" "unsafe-fp-math"="false" "use-soft-float"="false" }
 
 !llvm.dbg.cu = !{!0}
 !llvm.module.flags = !{!18, !19}
 !llvm.ident = !{!20}
 
-!0 = !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.5.0 (trunk 209255) (llvm/trunk 209253)", isOptimized: true, emissionKind: 1, file: !1, enums: !2, retainedTypes: !2, subprograms: !3, globals: !2, imports: !2)
+!0 = !DICompileUnit(language: DW_LANG_C99, producer: "clang version 3.5.0 (trunk 209255) (llvm/trunk 209253)", isOptimized: true, emissionKind: 1, file: !1, enums: !2, retainedTypes: !22, subprograms: !3, globals: !2, imports: !2)
 !1 = !DIFile(filename: "debug-dead-local-var.c", directory: "/usr/local/google/home/echristo")
 !2 = !{}
 !3 = !{!4, !9}
 !4 = !DISubprogram(name: "bar", line: 11, isLocal: false, isDefinition: true, virtualIndex: 6, isOptimized: true, scopeLine: 11, file: !1, scope: !5, type: !6, function: i32 ()* @bar, variables: !2)
 !5 = !DIFile(filename: "debug-dead-local-var.c", directory: "/usr/local/google/home/echristo")
 !6 = !DISubroutineType(types: !7)
 !7 = !{!8}
 !8 = !DIBasicType(tag: DW_TAG_base_type, name: "int", size: 32, align: 32, encoding: DW_ATE_signed)
 !9 = !DISubprogram(name: "foo", line: 6, isLocal: true, isDefinition: true, virtualIndex: 6, isOptimized: true, scopeLine: 6, file: !1, scope: !5, type: !10, variables: !12)
 !10 = !DISubroutineType(types: !11)
 !11 = !{null}
 !12 = !{!13}
 !13 = !DILocalVariable(tag: DW_TAG_auto_variable, name: "xyz", line: 8, scope: !9, file: !5, type: !14)
 !14 = !DICompositeType(tag: DW_TAG_structure_type, name: "X", line: 8, size: 64, align: 32, file: !1, scope: !9, elements: !15)
 !15 = !{!16, !17}
 !16 = !DIDerivedType(tag: DW_TAG_member, name: "a", line: 8, size: 32, align: 32, file: !1, scope: !14, baseType: !8)
 !17 = !DIDerivedType(tag: DW_TAG_member, name: "b", line: 8, size: 32, align: 32, offset: 32, file: !1, scope: !14, baseType: !8)
 !18 = !{i32 2, !"Dwarf Version", i32 4}
 !19 = !{i32 2, !"Debug Info Version", i32 3}
 !20 = !{!"clang version 3.5.0 (trunk 209255) (llvm/trunk 209253)"}
 !21 = !DILocation(line: 13, scope: !4)
+!22 = !{!14}
 No newline at end of file

test/DebugInfo/cross-cu-linkonce-distinct.ll

 ; int (*x)(int) = &func;
 ; $ cat b.cpp
 ; inline int func(int i) {
 ;   return i * 2;
 ; }
 ; int (*y)(int) = &func;
 
 ; CHECK: DW_TAG_compile_unit
-; CHECK:   DW_TAG_subprogram
-; CHECK-NOT: DW_TAG
-; CHECK:     DW_AT_name {{.*}} "func"
-; CHECK: DW_TAG_compile_unit
 
-; FIXME: Maybe we should drop the subprogram here - since the function was
+; Check that the subprogram is dropped in this CU - since the function was
 ; emitted in one CU, due to linkonce_odr uniquing. We certainly don't emit the
 ; subprogram here if the source location for this definition is the same (see
 ; test/DebugInfo/cross-cu-linkonce.ll), though it's very easy to tickle that
 ; into failing even without duplicating the source as has been done in this
 ; case (two cpp files in different directories, including the same header that
 ; contains an inline function - clang will produce distinct subprogram metadata
 ; that won't deduplicate owing to the file location information containing the
 ; directory of the source file even though the file name is absolute, not
 ; relative)
 
-; CHECK: DW_TAG_subprogram
+; CHECK-NOT: DW_TAG_subprogram
+
+; CHECK: DW_TAG_compile_unit
+; CHECK:   DW_TAG_subprogram
+; CHECK-NOT: DW_TAG
+; CHECK:     DW_AT_name {{.*}} "func"
 
 @x = global i32 (i32)* @_Z4funci, align 8
 @y = global i32 (i32)* @_Z4funci, align 8
 
 ; Function Attrs: inlinehint nounwind uwtable
 define linkonce_odr i32 @_Z4funci(i32 %i) #0 {
   %1 = alloca i32, align 4
   store i32 %i, i32* %1, align 4

test/DebugInfo/nodebug.ll

 ; inline __attribute__((always_inline)) void f1() {
 ;   i = 3;
 ; }
 ;
 ; __attribute__((nodebug)) void f2() {
 ;   f1();
 ; }
 
-; Check that there's only one DW_TAG_subprogram, nothing for the 'f2' function.
-; CHECK: DW_TAG_subprogram
-; CHECK-NOT: DW_TAG
-; CHECK:   DW_AT_name {{.*}} "f1"
+; Check that there is no DW_TAG_subprogram, nothing for the 'f2' function.
+; Note: No debug info was emitted for 'f1' function because it has no code.
 ; CHECK-NOT: DW_TAG_subprogram
 
 @i = external global i32
 
 ; Function Attrs: uwtable
 define void @_Z2f2v() #0 {
 entry:
   store i32 3, i32* @i, align 4, !dbg !11