[DebugInfo] Don't turn dbg.declare into DBG_VALUE for static allocas

[rnk]

Summary

We already have information about static alloca stack locations in our
side table. Emitting instructions for them is inefficient, and it only
happens when the address of the alloca has been materialized within the
current block, which isn't often.

[aprantl]

Code LGTM, I have some comments for the testcases inline.

llvm/test/DebugInfo/WebAssembly/dbg-declare.ll

3 ↗

(On Diff #109011)

When removing the check for the DEBUG_VALUE, could you add a check for the actual variable location being emitted via the MMI side table? llc -filetype=obj | llvm-dwarfdump - and a check for a DW_AT_name / DW_AT_location pair should do the trick.

llvm/test/DebugInfo/X86/dbg-declare-alloca.ll

7 ↗

(On Diff #109011)

I would prefer something that checks the dwarf or assembler output for an actual debug location to avoid future bitrot.

31 ↗

(On Diff #109011)

We usually strip out all non-essential attributes. (Usually at least everything in quotes :-)

llvm/test/DebugInfo/X86/dbg-declare.ll

5 ↗

(On Diff #109011)

ditto here, checking that we still emit the location would be even better

[rnk]

llvm/test/DebugInfo/WebAssembly/dbg-declare.ll

3 ↗

(On Diff #109011)

llvm-dwarfdump doesn't appear to know how to parse wasm object files, so I can't add that check. I can add the DW_AT_location checks to the other tests, though.

[aprantl]

llvm/test/DebugInfo/WebAssembly/dbg-declare.ll

3 ↗

(On Diff #109011)

Sorry, I overlooked that this was WebAssembly. Makes sense, thanks!

[rnk]

• add more fbreg dwarfdump tests

llvm/trunk/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp

case Intrinsic::dbg_declare: {
 
     // Check if address has undef value.
     if (isa<UndefValue>(Address) ||
         (Address->use_empty() && !isa<Argument>(Address))) {
       DEBUG(dbgs() << "Dropping debug info for " << DI << "\n");
       return nullptr;
     }
 
+    // Static allocas are handled more efficiently in the variable frame index
+    // side table.
+    const auto *AI =
+        dyn_cast<AllocaInst>(Address->stripInBoundsConstantOffsets());
+    if (AI && AI->isStaticAlloca() && FuncInfo.StaticAllocaMap.count(AI))
+      return nullptr;
+
     // Byval arguments with frame indices were already handled after argument
     // lowering and before isel.
     const auto *Arg =
         dyn_cast<Argument>(Address->stripInBoundsConstantOffsets());
     if (Arg && FuncInfo.getArgumentFrameIndex(Arg) != INT_MAX)
       return nullptr;
 
     SDValue &N = NodeMap[Address];

llvm/trunk/test/DebugInfo/COFF/local-variables.ll

 ; ASM: .seh_proc f
 ; ASM: # BB#0:                                 # %entry
 ; ASM:         subq    $56, %rsp
 ; ASM:         movl    %ecx, 52(%rsp)
 ; ASM: [[prologue_end:\.Ltmp.*]]:
 ; ASM:         .cv_loc 0 1 8 7                 # t.cpp:8:7
 ; ASM:         testl   %ecx, %ecx
 ; ASM:         je      .LBB0_2
-; ASM: [[if_start:\.Ltmp.*]]:
 ; ASM: # BB#1:                                 # %if.then
+; ASM: [[if_start:\.Ltmp.*]]:
 ; ASM:         .cv_loc 0 1 9 9                 # t.cpp:9:9
 ; ASM:         movl    $42, 40(%rsp)
 ; ASM: [[inline_site1:\.Ltmp.*]]:
 ; ASM:         .cv_inline_site_id 1 within 0 inlined_at 1 10 5
 ; ASM:         .cv_loc 1 1 4 7                 # t.cpp:4:7
 ; ASM:         movl    $3, 44(%rsp)
 ; ASM:         leaq    44(%rsp), %rcx
 ; ASM:         .cv_loc 1 1 5 3                 # t.cpp:5:3

llvm/trunk/test/DebugInfo/WebAssembly/dbg-declare.ll

 ; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown-wasm | FileCheck %s
 ; RUN: llc < %s -verify-machineinstrs -mtriple=wasm32-unknown-unknown-wasm -fast-isel | FileCheck --check-prefix=CHECK-FAST %s
-; CHECK: #DEBUG_VALUE: decode:i <- [%vreg
-; CHECK: #DEBUG_VALUE: decode:v <- [%vreg
+
 ; CHECK: DW_TAG_variable
 ; CHECK-FAST: DW_TAG_variable
 
 ; Test that llvm.dbg.declare() instrinsics do not crash the backend
 
 source_filename = "test/DebugInfo/WebAssembly/dbg-declare.ll"
 target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128"
 target triple = "wasm32-unknown-unknown-wasm"

llvm/trunk/test/DebugInfo/X86/array.ll

 ; ModuleID = 'array.c'
 ;
 ; From (clang -g -c -O1):
 ;
 ; void f(int* p) {
 ;   p[0] = 42;
 ; }
 ;
 ; int main(int argc, char** argv) {
 ;   int array[4] = { 0, 1, 2, 3 };
 ;   f(array);
 ;   return array[0];
 ; }
 ;
 ; RUN: llc -filetype=asm %s -o - | FileCheck %s
-; Test that we only emit register-indirect locations for the array array.
-; rdar://problem/14874886
-;
-; CHECK-NOT: ##DEBUG_VALUE: main:array <- %R{{.*}}
+; RUN: llc -filetype=obj %s -o - | llvm-dwarfdump - --debug-dump=info | FileCheck %s --check-prefix=DWARF
+
+; CHECK-LABEL: _main:
+; CHECK: movaps {{.*}}, (%rsp)
 ; CHECK: movq    %rsp, %rdi
-; CHECK-NOT: ##DEBUG_VALUE: main:array <- %R{{.*}}
-; CHECK:     ##DEBUG_VALUE: main:array <- [%RDI+0]
-; CHECK-NOT: ##DEBUG_VALUE: main:array <- %R{{.*}}
+; CHECK: callq _f
+
+; DWARF: DW_TAG_variable
+;   "<0x2> 91 00" means fbreg 0, i.e. offset RSP+0.
+; DWARF-NEXT:              DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 00 )
+; DWARF-NEXT:              DW_AT_name [DW_FORM_strp]     ( {{.*}} = "array")
+
 ; ModuleID = '/tmp/array.c'
 source_filename = "/tmp/array.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 @main.array = private unnamed_addr constant [4 x i32] [i32 0, i32 1, i32 2, i32 3], align 16
 
 ; Function Attrs: nounwind ssp uwtable

llvm/trunk/test/DebugInfo/X86/dbg-declare-alloca.ll

+; RUN: llc < %s | FileCheck %s
+; RUN: llc < %s -filetype=obj | llvm-dwarfdump - -debug-dump=info | FileCheck %s --check-prefix=DWARF
+
+; This should use the frame index side table for allocas, not DBG_VALUE
+; instructions. For SDAG ISel, this test would see an SDNode materializing the
+; argument to escape_foo and we'd get DBG_VALUE MachineInstr.
+
+; CHECK-LABEL: use_dbg_declare:
+; CHECK-NOT: #DEBUG_VALUE
+
+;   "<0x2> 91 00" means "fbreg uleb(0)", i.e. RSP+0.
+; DWARF: DW_TAG_variable
+; DWARF-NEXT:              DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 00 )
+; DWARF-NEXT:              DW_AT_name [DW_FORM_strp]     ( {{.*}} = "o")
+
+
+; ModuleID = 't.c'
+source_filename = "t.c"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64--linux"
+
+%struct.Foo = type { i32 }
+
+; Function Attrs: noinline nounwind uwtable
+define void @use_dbg_declare() #0 !dbg !7 {
+entry:
+  %o = alloca %struct.Foo, align 4
+  call void @llvm.dbg.declare(metadata %struct.Foo* %o, metadata !10, metadata !15), !dbg !16
+  call void @escape_foo(%struct.Foo* %o), !dbg !17
+  ret void, !dbg !18
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+declare void @escape_foo(%struct.Foo*)
+
+attributes #0 = { noinline nounwind uwtable }
+attributes #1 = { nounwind readnone speculatable }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 6.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
+!1 = !DIFile(filename: "t.c", directory: "C:\5Csrc\5Cllvm-project\5Cbuild")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 6.0.0 "}
+!7 = distinct !DISubprogram(name: "use_dbg_declare", scope: !1, file: !1, line: 3, type: !8, isLocal: false, isDefinition: true, scopeLine: 3, flags: DIFlagPrototyped, isOptimized: false, unit: !0, variables: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{null}
+!10 = !DILocalVariable(name: "o", scope: !7, file: !1, line: 4, type: !11)
+!11 = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "Foo", file: !1, line: 1, size: 32, elements: !12)
+!12 = !{!13}
+!13 = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: !11, file: !1, line: 1, baseType: !14, size: 32)
+!14 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!15 = !DIExpression()
+!16 = !DILocation(line: 4, column: 14, scope: !7)
+!17 = !DILocation(line: 5, column: 3, scope: !7)
+!18 = !DILocation(line: 6, column: 1, scope: !7)

llvm/trunk/test/DebugInfo/X86/dbg-declare.ll

-; RUN: llc < %s -O0 -mtriple x86_64-apple-darwin
+; RUN: llc < %s -O0 -mtriple x86_64-apple-darwin | FileCheck %s
+; RUN: llc < %s -O0 -mtriple x86_64-apple-darwin -filetype=obj \
+; RUN:     | llvm-dwarfdump - -debug-dump=info | FileCheck %s --check-prefix=DWARF
 ; <rdar://problem/11134152>
 
+; CHECK-LABEL: _foo:
+; CHECK-NOT: #DEBUG_VALUE
+
+; "[DW_FORM_exprloc] <0x2> 91 XX" means fbreg uleb(XX)
+; DWARF-LABEL: DW_TAG_formal_parameter
+; DWARF-NEXT:              DW_AT_location [DW_FORM_exprloc]      (<0x2> 91 70 )
+; DWARF-NEXT:              DW_AT_name [DW_FORM_strp]     ( {{.*}} = "x")
+
+; FIXME: There is no debug info to describe "a".
+
 define i32 @foo(i32* %x) nounwind uwtable ssp !dbg !5 {
 entry:
   %x.addr = alloca i32*, align 8
   %saved_stack = alloca i8*
   %cleanup.dest.slot = alloca i32
   store i32* %x, i32** %x.addr, align 8
   call void @llvm.dbg.declare(metadata i32** %x.addr, metadata !14, metadata !DIExpression()), !dbg !15
   %0 = load i32*, i32** %x.addr, align 8, !dbg !16