llvm/test/DebugInfo/X86/instr-ref-selectiondag.ll

   1 ; RUN: llc %s -mtriple=x86_64-unknown-unknown -o - -stop-before=finalize-isel \
   2 ; RUN:   | FileCheck %s --check-prefix=NORMAL \
   3 ; RUN:     --implicit-check-not=debug-instr-number \
   4 ; RUN:     --implicit-check-not=DBG_INSTR_REF
   5 ; RUN: llc %s -mtriple=x86_64-unknown-unknown -o - -stop-before=finalize-isel \
   6 ; RUN:     -experimental-debug-variable-locations -verify-machineinstrs \
   7 ; RUN:   | FileCheck %s --check-prefix=INSTRREF \
   8 ; RUN:     --implicit-check-not=DBG_VALUE
   9 ; RUN: llc %s -mtriple=x86_64-unknown-unknown -o - -stop-before=finalize-isel \
  10 ; RUN:     -experimental-debug-variable-locations -verify-machineinstrs \
  11 ; RUN:     -fast-isel \
  12 ; RUN:   | FileCheck %s --check-prefix=FASTISEL-INSTRREF \
  13 ; RUN:     --implicit-check-not=DBG_VALUE
  14
  15 ; NORMAL: ![[SOCKS:[0-9]+]] = !DILocalVariable(name: "socks",
  16 ; NORMAL: ![[KNEES:[0-9]+]] = !DILocalVariable(name: "knees",
  17 ; INSTRREF: ![[SOCKS:[0-9]+]] = !DILocalVariable(name: "socks",
  18 ; INSTRREF: ![[KNEES:[0-9]+]] = !DILocalVariable(name: "knees",
  19 ; FASTISEL-INSTRREF: ![[SOCKS:[0-9]+]] = !DILocalVariable(name: "socks",
  20 ; FASTISEL-INSTRREF: ![[KNEES:[0-9]+]] = !DILocalVariable(name: "knees",
  21
  22 ; Test that SelectionDAG produces DBG_VALUEs normally, but DBG_INSTR_REFs when
  23 ; asked.
  24
  25 ; NORMAL-LABEL: name: foo
  26
  27 ; NORMAL:      %[[REG0:[0-9]+]]:gr32 = ADD32rr
  28 ; NORMAL-NEXT: DBG_VALUE %[[REG0]]
  29 ; NORMAL-NEXT: %[[REG1:[0-9]+]]:gr32 = ADD32rr
  30 ; NORMAL-NEXT: DBG_VALUE %[[REG1]]
  31
  32 ; Note that I'm baking in an assumption of one-based ordering here. We could
  33 ; capture and check for the instruction numbers, we'd rely on machine verifier
  34 ; ensuring there were no duplicates.
  35
  36 ; INSTRREF-LABEL: name: foo
  37
  38 ; INSTRREF:      ADD32rr
  39 ; INSTRREF-SAME: debug-instr-number 1
  40 ; INSTRREF-NEXT: DBG_INSTR_REF 1, 0
  41 ; INSTRREF-NEXT: ADD32rr
  42 ; INSTRREF-SAME: debug-instr-number 2
  43 ; INSTRREF-NEXT: DBG_INSTR_REF 2, 0
  44
  45 ; Test that fast-isel will produce DBG_INSTR_REFs too.
  46
  47 ; FASTISEL-INSTRREF-LABEL: name: foo
  48
  49 ; FASTISEL-INSTRREF:      ADD32rr
  50 ; FASTISEL-INSTRREF-SAME: debug-instr-number 1
  51 ; FASTISEL-INSTRREF-NEXT: DBG_INSTR_REF 1, 0
  52 ; FASTISEL-INSTRREF-NEXT: ADD32rr
  53 ; FASTISEL-INSTRREF-SAME: debug-instr-number 2
  54 ; FASTISEL-INSTRREF-NEXT: DBG_INSTR_REF 2, 0
  55
  56 @glob32 = global i32 0
  57 @glob16 = global i16 0
  58 @glob8 = global i8 0
  59
  60 declare void @llvm.dbg.value(metadata, metadata, metadata)
  61 declare void @llvm.dbg.declare(metadata, metadata, metadata)
  62
  63 define i32 @foo(i32 %bar, i32 %baz, i32 %qux) !dbg !7 {
  64 entry:
  65   %0 = add i32 %bar, %baz, !dbg !14
  66   call void @llvm.dbg.value(metadata i32 %0, metadata !13, metadata !DIExpression()), !dbg !14
  67   %1 = add i32 %0, %qux
  68   call void @llvm.dbg.value(metadata i32 %1, metadata !13, metadata !DIExpression()), !dbg !14
  69   ret i32 %1, !dbg !14
  70 }
  71
  72 ; In the code below, isel produces a large number of copies between subregisters
  73 ; to represent the gradually decreasing width of the argument. This gets
  74 ; optimized away into three stores, but it's an objective of the instruction
  75 ; referencing design that COPYs are not numbered: they move values, not define
  76 ; them. Test that nothing is numbered, and instead that appropriate
  77 ; substitutions with subregister details are recorded.
  78
  79 ; NORMAL-LABEL: name: bar
  80
  81 ; NORMAL:      DBG_VALUE $rdi
  82 ; NORMAL-NEXT: %0:gr64_with_sub_8bit = COPY $rdi
  83 ; NORMAL-NEXT: DBG_VALUE %0,
  84 ; NORMAL-NEXT: %1:gr32 = COPY %0.sub_32bit,
  85 ; NORMAL-NEXT: DBG_VALUE %1
  86 ; NORMAL:      %3:gr16 = COPY %0.sub_16bit,
  87 ; NORMAL-NEXT: DBG_VALUE %3
  88 ; NORMAL:      %5:gr8 = COPY %0.sub_8bit,
  89 ; NORMAL-NEXT: DBG_VALUE %5
  90
  91 ; INSTRREF-LABEL: name: bar
  92
  93 ;;
  94 ; INSTRREF:      debugValueSubstitutions:
  95 ; INSTRREF-NEXT: - { srcinst: 2, srcop: 0, dstinst: 1, dstop: 0, subreg: 6 }
  96 ; INSTRREF-NEXT: - { srcinst: 4, srcop: 0, dstinst: 3, dstop: 0, subreg: 4 }
  97 ; INSTRREF-NEXT: - { srcinst: 6, srcop: 0, dstinst: 5, dstop: 0, subreg: 1 }
  98
  99 ;; As a slight inefficiency today, multiple DBG_PHIs are created.
 100
 101 ; INSTRREF:      DBG_PHI $rdi, 5
 102 ; INSTRREF-NEXT: DBG_PHI $rdi, 3
 103 ; INSTRREF-NEXT: DBG_PHI $rdi, 1
 104 ;; Allow arguments to be specified by physreg DBG_VALUEs.
 105 ; INSTRREF-NEXT: DBG_VALUE $rdi
 106
 107 ;; Don't test the location of these instr-refs, only that the three non-argument
 108 ;; dbg.values become DBG_INSTR_REFs. We previously checked that these numbers
 109 ;; get substituted, with appropriate subregister qualifiers.
 110 ; INSTRREF:      DBG_INSTR_REF 2, 0
 111 ; INSTRREF:      DBG_INSTR_REF 4, 0
 112 ; INSTRREF:      DBG_INSTR_REF 6, 0
 113
 114 ;; In fast-isel, we get four DBG_INSTR_REFs (compared to three and one
 115 ;; DBG_VALUE with normal isel). We get additional substitutions as a result:
 116
 117 ; FASTISEL-INSTRREF:      debugValueSubstitutions:
 118 ; FASTISEL-INSTRREF-NEXT: - { srcinst: 3, srcop: 0, dstinst: 2, dstop: 0, subreg: 6 }
 119 ; FASTISEL-INSTRREF-NEXT: - { srcinst: 5, srcop: 0, dstinst: 4, dstop: 0, subreg: 6 }
 120 ; FASTISEL-INSTRREF-NEXT: - { srcinst: 6, srcop: 0, dstinst: 5, dstop: 0, subreg: 4 }
 121 ; FASTISEL-INSTRREF-NEXT  - { srcinst: 8, srcop: 0, dstinst: 7, dstop: 0, subreg: 6 }
 122 ; FASTISEL-INSTRREF-NEXT  - { srcinst: 9, srcop: 0, dstinst: 8, dstop: 0, subreg: 4 }
 123 ; FASTISEL-INSTRREF-NEXT  - { srcinst: 10, srcop: 0, dstinst: 9, dstop: 0, subreg: 1 }
 124
 125 ;; Those substitutions are anchored against these DBG_PHIs:
 126
 127 ; FASTISEL-INSTRREF:      DBG_PHI $rdi, 7
 128 ; FASTISEL-INSTRREF-NEXT: DBG_PHI $rdi, 4
 129 ; FASTISEL-INSTRREF-NEXT: DBG_PHI $rdi, 2
 130 ; FASTISEL-INSTRREF-NEXT: DBG_PHI $rdi, 1
 131
 132 ; FASTISEL-INSTRREF:      DBG_INSTR_REF 1, 0
 133 ; FASTISEL-INSTRREF:      DBG_INSTR_REF 3, 0
 134 ; FASTISEL-INSTRREF:      DBG_INSTR_REF 6, 0
 135 ; FASTISEL-INSTRREF:      DBG_INSTR_REF 10, 0
 136
 137 define i32 @bar(i64 %bar) !dbg !20 {
 138 entry:
 139   call void @llvm.dbg.value(metadata i64 %bar, metadata !21, metadata !DIExpression()), !dbg !22
 140   %0 = trunc i64 %bar to i32, !dbg !22
 141   call void @llvm.dbg.value(metadata i32 %0, metadata !21, metadata !DIExpression()), !dbg !22
 142   store i32 %0, i32 *@glob32, !dbg !22
 143   %1 = trunc i32 %0 to i16, !dbg !22
 144   call void @llvm.dbg.value(metadata i16 %1, metadata !21, metadata !DIExpression()), !dbg !22
 145   store i16 %1, i16 *@glob16, !dbg !22
 146   %2 = trunc i16 %1 to i8, !dbg !22
 147   call void @llvm.dbg.value(metadata i8 %2, metadata !21, metadata !DIExpression()), !dbg !22
 148   store i8 %2, i8 *@glob8, !dbg !22
 149   ret i32 0, !dbg !22
 150 }
 151
 152 ; Ensure that we can track copies back to physreg defs, and throw in a subreg
 153 ; substitution for fun. The call to @xyzzy defines $rax, which gets copied to
 154 ; a VReg, and then truncated by a subreg copy. We should be able to track
 155 ; through the copies and walk back to the physreg def, labelling the CALL
 156 ; instruction. We should also be able to do this even when the block layout is
 157 ; crazily ordered.
 158
 159 ; NORMAL-LABEL: name: baz
 160
 161 ; NORMAL:      CALL64pcrel32 target-flags(x86-plt) @xyzzy
 162 ; NORMAL:      %2:gr64 = COPY $rax,
 163 ; NORMAL:      %0:gr64 = COPY %2,
 164 ; NORMAL-LABEL: bb.1.slippers:
 165 ; NORMAL:      DBG_VALUE %1
 166 ; NORMAL-LABEL: bb.2.shoes:
 167 ; NORMAL:      %1:gr16 = COPY %0.sub_16bit
 168
 169 ; INSTRREF-LABEL: name: baz
 170
 171 ; INSTRREF:      debugValueSubstitutions:
 172 ; INSTRREF-NEXT:  - { srcinst: 2, srcop: 0, dstinst: 1, dstop: 6, subreg: 4 }
 173
 174 ; INSTRREF:      CALL64pcrel32 target-flags(x86-plt) @xyzzy, csr_64, implicit $rsp, implicit $ssp, implicit-def $rsp, implicit-def $ssp, implicit-def $rax, debug-instr-number 1
 175 ; INSTRREF:      DBG_INSTR_REF 2, 0
 176
 177 ;; Fast-isel produces the same arrangement, a DBG_INSTR_REF pointing back to
 178 ;; the call instruction. However: the operand numbers are different (6 for
 179 ;; normal isel, 4 for fast-isel). This isn't because of debug-info differences,
 180 ;; it's because normal isel implicit-defs the stack registers, and fast-isel
 181 ;; does not. The meaning is the same.
 182
 183 ; FASTISEL-INSTRREF-LABEL: name: baz
 184
 185 ; FASTISEL-INSTRREF:      debugValueSubstitutions:
 186 ; FASTISEL-INSTRREF-NEXT:  - { srcinst: 2, srcop: 0, dstinst: 1, dstop: 4, subreg: 4 }
 187
 188 ; FASTISEL-INSTRREF:      CALL64pcrel32 target-flags(x86-plt) @xyzzy, csr_64, implicit $rsp, implicit $ssp, implicit-def $rax, debug-instr-number 1
 189 ; FASTISEL-INSTRREF:      DBG_INSTR_REF 2, 0
 190
 191 declare i64 @xyzzy()
 192
 193 define i32 @baz() !dbg !30 {
 194 entry:
 195   %foo = call i64 @xyzzy(), !dbg !32
 196   br label %shoes
 197
 198 slippers:
 199   call void @llvm.dbg.value(metadata i16 %moo, metadata !31, metadata !DIExpression()), !dbg !32
 200   store i16 %moo, i16 *@glob16, !dbg !32
 201   ret i32 0, !dbg !32
 202
 203 shoes:
 204   %moo = trunc i64 %foo to i16
 205   br label %slippers
 206 }
 207
 208 ;; Test for dbg.declare of non-stack-slot Values. These turn up with NRVO and
 209 ;; other ABI scenarios where something is technically in memory, but we don't
 210 ;; refer to it relative to the stack pointer. We refer to these either with an
 211 ;; indirect DBG_VAUE, or a DBG_INSTR_REF with DW_OP_deref prepended.
 212 ;;
 213 ;; Test an inlined dbg.declare in a different scope + block, to test behaviours
 214 ;; where the debug intrinsic isn't in the first block. The normal-mode DBG_VALUE
 215 ;; is hoisted into the entry block for that. This is fine because the variable
 216 ;; location is never re-assigned. (FIXME: do we scope-trim / fail-to-propagate
 217 ;; these hoisted locations later?).
 218
 219 ; NORMAL-LABEL: name: qux
 220 ;
 221 ; NORMAL:      DBG_VALUE $rdi, 0, ![[SOCKS]], !DIExpression(),
 222 ; NORMAL-NEXT: %0:gr64 = COPY $rdi
 223 ; NORMAL-NEXT: DBG_VALUE %0, 0, ![[SOCKS]], !DIExpression(),
 224 ; NORMAL-NEXT: DBG_VALUE %0, 0, ![[KNEES]], !DIExpression(),
 225
 226 ;; In instruction referencing mode, the "real" argument becomes a DBG_VALUE,
 227 ;; but the hoisted variable location from the inlined scope is a DBG_INSTR_REF.
 228
 229 ; INSTRREF-LABEL: name: qux
 230
 231 ; INSTRREF:      DBG_PHI $rdi, 1
 232 ; INSTRREF-NEXT: DBG_VALUE $rdi, 0, ![[SOCKS]], !DIExpression(),
 233 ; INSTRREF-NEXT: %0:gr64 = COPY $rdi
 234 ; INSTRREF-NEXT: DBG_INSTR_REF 1, 0, ![[KNEES]], !DIExpression(DW_OP_deref),
 235
 236 ; In fast-isel mode, neither variable are hoisted or forwarded to a physreg.
 237
 238 ; FASTISEL-INSTRREF-LABEL: name: qux
 239
 240 ; FASTISEL-INSTRREF:      DBG_PHI $rdi, 2
 241 ; FASTISEL-INSTRREF-NEXT: DBG_PHI $rdi, 1
 242 ; FASTISEL-INSTRREF:      DBG_INSTR_REF 1, 0, ![[SOCKS]], !DIExpression(DW_OP_deref),
 243
 244 ; FASTISEL-INSTRREF-LABEL: bb.1.lala:
 245 ; FASTISEL-INSTRREF:      DBG_INSTR_REF 2, 0, ![[KNEES]], !DIExpression(DW_OP_deref),
 246 declare i64 @cheddar(i32 *%arg)
 247
 248 define void @qux(i32* noalias sret(i32) %agg.result) !dbg !40 {
 249 entry:
 250   call void @llvm.dbg.declare(metadata i32 *%agg.result, metadata !41, metadata !DIExpression()), !dbg !42
 251   %foo = call i64 @cheddar(i32 *%agg.result), !dbg !42
 252   br label %lala
 253
 254 lala:
 255   call void @llvm.dbg.declare(metadata i32 *%agg.result, metadata !45, metadata !DIExpression()), !dbg !44
 256   ret void, !dbg !44
 257 }
 258
 259
 260
 261 !llvm.dbg.cu = !{!0}
 262 !llvm.module.flags = !{!3, !4}
 263
 264 !0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
 265 !1 = !DIFile(filename: "exprconflict.c", directory: "/home/jmorse")
 266 !2 = !{}
 267 !3 = !{i32 2, !"Dwarf Version", i32 4}
 268 !4 = !{i32 2, !"Debug Info Version", i32 3}
 269 !7 = distinct !DISubprogram(name: "foo", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
 270 !8 = !DISubroutineType(types: !9)
 271 !9 = !{!10, !10}
 272 !10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
 273 !11 = !{!13}
 274 !13 = !DILocalVariable(name: "baz", scope: !7, file: !1, line: 6, type: !10)
 275 !14 = !DILocation(line: 1, scope: !7)
 276 !20 = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
 277 !21 = !DILocalVariable(name: "xyzzy", scope: !20, file: !1, line: 6, type: !10)
 278 !22 = !DILocation(line: 1, scope: !20)
 279 !30 = distinct !DISubprogram(name: "bar", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
 280 !31 = !DILocalVariable(name: "xyzzy", scope: !30, file: !1, line: 6, type: !10)
 281 !32 = !DILocation(line: 1, scope: !30)
 282 !40 = distinct !DISubprogram(name: "qux", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
 283 !41 = !DILocalVariable(name: "socks", scope: !40, file: !1, line: 6, type: !10)
 284 !42 = !DILocation(line: 1, scope: !40)
 285 !43 = distinct !DISubprogram(name: "inlined", scope: !1, file: !1, line: 5, type: !8, scopeLine: 5, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
 286 !44 = !DILocation(line: 0, scope: !43, inlinedAt: !42)
 287 !45 = !DILocalVariable(name: "knees", scope: !43, file: !1, line: 6, type: !10)