[DebugInfo] Normalize common kinds of DWARF sub-expressions.

[JDevlieghere]

Summary

Normalize common kinds of DWARF sub-expressions to make debug info encoding a bit more compact:

1. DW_OP_constu [X < 32] -> DW_OP_litX
2. DW_OP_constu [all ones] -> DW_OP_lit0, DW_OP_not

Addresses Adrian's comments in https://reviews.llvm.org/D48676.

[aprantl]

Can you add a testcase for the 0xffffffff case?

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

186

1. This is short one f.
2. I'd use some form of uint_max or ~0ULL so this isn't an issue ;-)

[JDevlieghere]

• Normalize more usages.
• Compare against 32-bit unsigned max.

[JDevlieghere]

I generated some unrelated files while fixing the tests that were included in the previous diff.

[aprantl]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

31

These are 64 bit values. We either need ~0ULL or std::limits::max<uint64_t>().

[probinson]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

31

The DWARF expression stack uses target-address-size values, and that isn't necessarily 64-bit. I'm not sure we can make this compaction work in all cases.

[aprantl]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

31

But if we do implement the 64-bit case, it will be correct there, we just don't get the more compact representation on a 32-bit arch, so that would still be win an many targets without breaking anything?

[probinson]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

31

Acknowledging we're not compacting -1 on 32-bit targets, then okay.

[aprantl]

LGTM, with outstanding changes addressed & perhaps add a note about how this doesn't trigger for 32-bit targets. Be sure to watch the bots afterwards, since we didn't emit DW_OP_LIT before AFAIK and LLDB may have bugs.

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

 #include <cstdint>
 
 using namespace llvm;
 
 void DwarfExpression::addReg(int DwarfReg, const char *Comment) {
  assert(DwarfReg >= 0 && "invalid negative dwarf register number");
  assert((LocationKind == Unknown || LocationKind == Register) &&
         "location description already locked down");
  LocationKind = Register;
  if (DwarfReg < 32) {
    emitOp(dwarf::DW_OP_reg0 + DwarfReg, Comment);
   } else {
     emitOp(dwarf::DW_OP_regx, Comment);
     emitUnsigned(DwarfReg);
   }
 }
 
void DwarfExpression::addSignedConstant(int64_t Value) {
   LocationKind = Implicit;
   emitOp(dwarf::DW_OP_consts);
   emitSigned(Value);
 }
 
 void DwarfExpression::addUnsignedConstant(uint64_t Value) {
   assert(LocationKind == Implicit || LocationKind == Unknown);
   LocationKind = Implicit;
+  if (Value < 32)
+   emitOp(dwarf::DW_OP_lit0 + Value);
+  else if (Value == 0xfffffff) {
+   emitOp(dwarf::DW_OP_lit0);
+   emitOp(dwarf::DW_OP_not);
+  } else {
    emitOp(dwarf::DW_OP_constu);
    emitUnsigned(Value);
   }
+}
 
 void DwarfExpression::addUnsignedConstant(const APInt &Value) {
   assert(LocationKind == Implicit || LocationKind == Unknown);
   LocationKind = Implicit;
 
   unsigned Size = Value.getBitWidth();
   const uint64_t *Data = Value.getRawData();
 

llvm/test/DebugInfo/ARM/PR26163.ll

 ; RUN: llc -filetype=obj -o - < %s | llvm-dwarfdump -v -debug-info - | FileCheck %s
 ;
 ; Checks that we're creating two ranges, one that terminates immediately
 ; and one that spans the rest of the function. This isn't necessarily the
 ; best thing to do here (and also not necessarily correct, since the first
 ; one has a bit_piece), but it is what is currently being emitted, any
 ; change here needs to be intentional, so the test is very specific.
 ;
 ; CHECK: DW_TAG_inlined_subroutine
 ; CHECK: DW_TAG_variable
 ; CHECK:   DW_AT_location [DW_FORM_sec_offset] ({{.*}}
-; CHECK:      [0x00000004, 0x00000004): DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x8
-; CHECK:      [0x00000004, 0x00000014): DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4)
+; CHECK:      [0x00000004, 0x00000004): DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x8
+; CHECK:      [0x00000004, 0x00000014): DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4)
 
 ; Created form the following test case (PR26163) with
 ; clang -cc1 -triple armv4t--freebsd11.0-gnueabi -emit-obj -debug-info-kind=standalone -O2 -x c test.c
 ;
 ; typedef unsigned int  size_t;
 ; struct timeval {
 ;   long long tv_sec;
 ;   int tv_usec;

llvm/test/DebugInfo/ARM/split-complex.ll

 ; RUN: %llc_dwarf -O0 -filetype=obj -o %t.o %s
 ; RUN: llvm-dwarfdump -v -debug-info %t.o | FileCheck %s
 ; REQUIRES: object-emission
 target datalayout = "e-m:o-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
 target triple = "thumbv7-apple-unknown-macho"
 
 ; generated from (-triple thumbv7-apple-unknown-macho -Os):
 ;   void f(_Complex double c) { c = 0; }
 
 ; Function Attrs: nounwind readnone
 define arm_aapcscc void @f([2 x i64] %c.coerce) #0 !dbg !4 {
 entry:
   tail call void @llvm.dbg.declare(metadata { double, double }* undef, metadata !14, metadata !15), !dbg !16
   ; The target has no native double type.
   ; SROA split the complex value into two i64 values.
   ; CHECK: DW_TAG_formal_parameter
-  ; CHECK-NEXT:  DW_AT_location [DW_FORM_block1]  (DW_OP_constu 0x0, DW_OP_piece 0x8)
+  ; CHECK-NEXT:  DW_AT_location [DW_FORM_block1]  (DW_OP_lit0, DW_OP_piece 0x8)
   ; CHECK-NEXT:  DW_AT_name {{.*}} "c"
   tail call void @llvm.dbg.value(metadata i64 0, metadata !14, metadata !17), !dbg !16
   ; Manually removed to disable location list emission:
   ; tail call void @llvm.dbg.value(metadata i64 0, metadata !14, metadata !18), !dbg !16
   ret void, !dbg !19
 }
 
 ; Function Attrs: nounwind readnone

llvm/test/DebugInfo/Generic/incorrect-variable-debugloc1.ll

 ; REQUIRES: object-emission
 ; This test is failing for powerpc64, because a location list for the
-; variable 'c' is not generated at all. Temporary marking this test as XFAIL 
+; variable 'c' is not generated at all. Temporary marking this test as XFAIL
 ; for powerpc, until PR21881 is fixed.
 ; XFAIL: powerpc64
 
 ; RUN: %llc_dwarf -O2  -dwarf-version 2 -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s  --check-prefix=DWARF23
 ; RUN: %llc_dwarf -O2  -dwarf-version 3 -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s  --check-prefix=DWARF23
 ; RUN: %llc_dwarf -O2  -dwarf-version 4 -filetype=obj < %s | llvm-dwarfdump - | FileCheck %s  --check-prefix=DWARF4
 
 ; This is a test for PR21176.
-; DW_OP_const <const> doesn't describe a constant value, but a value at a constant address. 
+; DW_OP_const <const> doesn't describe a constant value, but a value at a constant address.
 ; The proper way to describe a constant value is DW_OP_constu <const>, DW_OP_stack_value.
+; For values < 32 we emit the canonical DW_OP_lit<const>.
 
 ; Generated with clang -S -emit-llvm -g -O2 test.cpp
 
 ; extern int func();
-; 
+;
 ; int main()
 ; {
 ;   volatile int c = 13;
 ;   c = func();
 ;   return c;
 ; }
 
 ; CHECK: DW_TAG_variable
 ; CHECK: DW_AT_location
 ; CHECK-NOT: DW_AT
-; DWARF23: DW_OP_constu 0xd{{$}}
-; DWARF4: DW_OP_constu 0xd, DW_OP_stack_value{{$}}
+; DWARF23: DW_OP_lit13{{$}}
+; DWARF4: DW_OP_lit13, DW_OP_stack_value{{$}}
 
 ; Function Attrs: uwtable
 define i32 @main() #0 !dbg !4 {
 entry:
   %c = alloca i32, align 4
   tail call void @llvm.dbg.value(metadata i32 13, metadata !10, metadata !16), !dbg !17
   store volatile i32 13, i32* %c, align 4, !dbg !18
   %call = tail call i32 @_Z4funcv(), !dbg !19

llvm/test/DebugInfo/X86/PR26148.ll

 ; int main() { return 0; }
 ;
 ; This is similar to the bug in test/DebugInfo/ARM/PR26163.ll, except that there is an
 ; extra non-overlapping range first. Thus, we make sure that the backend actually looks
 ; at all expressions when determining whether to merge ranges, not just the first one.
 ; AS in 26163, we expect two ranges (as opposed to one), the first one being zero sized
 ;
 ;
-; CHECK: [0x0000000000000004, 0x0000000000000004): DW_OP_constu 0x3, DW_OP_piece 0x4, DW_OP_reg5 RDI, DW_OP_piece 0x2
-; CHECK: [0x0000000000000004, 0x0000000000000014): DW_OP_constu 0x3, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_piece 0x4
+; CHECK: [0x0000000000000004, 0x0000000000000004): DW_OP_lit3, DW_OP_piece 0x4, DW_OP_reg5 RDI, DW_OP_piece 0x2
+; CHECK: [0x0000000000000004, 0x0000000000000014): DW_OP_lit3, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_piece 0x4
 
 source_filename = "test/DebugInfo/X86/PR26148.ll"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.11.0"
 
 %struct.S0 = type { i16, i32 }
 
 @a = common global %struct.S0 zeroinitializer, align 4, !dbg !0

llvm/test/DebugInfo/X86/constant-loclist.ll

 ; RUN: %llc_dwarf -filetype=obj %s -o - | llvm-dwarfdump -v -debug-info - | FileCheck %s
 
 ; A hand-written testcase to check 64-bit constant handling in location lists.
 
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (
 ; CHECK-NEXT:   [0x{{.*}}, 0x{{.*}}): DW_OP_constu 0x4000000000000000)
 ; CHECK-NEXT: DW_AT_name {{.*}}"d"
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (
 ; CHECK-NEXT:   [0x{{.*}}, 0x{{.*}}): DW_OP_consts +0
 ; CHECK-NEXT:   [0x{{.*}}, 0x{{.*}}): DW_OP_consts +4611686018427387904)
 ; CHECK-NEXT: DW_AT_name {{.*}}"i"
 ; CHECK: DW_TAG_variable
 ; CHECK-NEXT: DW_AT_location [DW_FORM_data4]  (
-; CHECK-NEXT:   [0x{{.*}}, 0x{{.*}}): DW_OP_constu 0x0
+; CHECK-NEXT:   [0x{{.*}}, 0x{{.*}}): DW_OP_lit0
 ; CHECK-NEXT:   [0x{{.*}}, 0x{{.*}}): DW_OP_constu 0x4000000000000000)
 ; CHECK-NEXT: DW_AT_name {{.*}}"u"
 
 source_filename = "test.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx"
 
 ; Function Attrs: nounwind ssp uwtable

llvm/test/DebugInfo/X86/partial-constant.ll

 ; exit:
 ;   return result;
 ; }
 ;
 ; The constant should NOT be available for the entire function.
 ; CHECK-NOT: DW_AT_const_value
 ; CHECK: .debug_loc contents:
 ; CHECK-NEXT: 0x00000000:
-; CHECK-NEXT:   {{.*}}: DW_OP_constu 0x1, DW_OP_stack_value
+; CHECK-NEXT:   {{.*}}: DW_OP_lit1, DW_OP_stack_value
 
 source_filename = "test.ii"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 ; Function Attrs: noimplicitfloat noredzone nounwind optsize
 define zeroext i1 @_Z5startv() local_unnamed_addr #0 !dbg !7 {
 entry:

llvm/test/DebugInfo/X86/pieces-4.ll

 ; CHECK:               #DEBUG_VALUE: bitpiece_spill:o <- [DW_OP_plus_uconst [[offs]], DW_OP_LLVM_fragment 0 32] [$rsp+0]
 ; CHECK:               #APP
 ; CHECK:               #NO_APP
 ; CHECK:               movl    [[offs]](%rsp), %eax          # 4-byte Reload
 ; CHECK:               retq
 
 ; DWARF: .debug_loc contents:
 ; DWARF-NEXT: 0x00000000:
-; DWARF-NEXT: {{.*}}: DW_OP_breg7 RSP+{{[0-9]+}}, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4
+; DWARF-NEXT: {{.*}}: DW_OP_breg7 RSP+{{[0-9]+}}, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4
 
 ; ModuleID = 't.c'
 source_filename = "t.c"
 target datalayout = "e-m:w-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-pc-windows-msvc19.0.24210"
 
 %struct.IntPair = type { i32, i32 }
 

llvm/test/DebugInfo/X86/stack-value-piece.ll

 ;   return r;
 ; }
 
 ; CHECK: .debug_info contents:
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_name {{.*}} "i"
 ; CHECK:   DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location {{.*}} ([[I:.*]]
-; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_reg5 RDI, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4)
+; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_reg5 RDI, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4)
 ; CHECK-NEXT:   DW_AT_name {{.*}} "r"
 ;
 ; CHECK: DW_TAG_subprogram
 ; CHECK:   DW_AT_name {{.*}} "f"
 ; CHECK:   DW_TAG_variable
 ; CHECK-NEXT:   DW_AT_location {{.*}} ([[F:.*]]
-; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4)
+; CHECK-NEXT:     [{{.*}}, {{.*}}): DW_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4)
 ; CHECK-NEXT:   DW_AT_name {{.*}} "r"
 ;
 ; CHECK: .debug_loc contents:
 ; CHECK:      [[I]]:
-; CHECK-NEXT:   [{{.*}}, {{.*}}): DW_OP_reg5 RDI, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4
+; CHECK-NEXT:   [{{.*}}, {{.*}}): DW_OP_reg5 RDI, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4
 ; CHECK:      [[F]]:
-; CHECK-NEXT:   [{{.*}}, {{.*}}): DW_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_constu 0x0, DW_OP_stack_value, DW_OP_piece 0x4
+; CHECK-NEXT:   [{{.*}}, {{.*}}): DW_OP_reg17 XMM0, DW_OP_piece 0x4, DW_OP_lit0, DW_OP_stack_value, DW_OP_piece 0x4
 
 source_filename = "stack-value-piece.c"
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 
 %struct.I = type { i32, i32 }
 %struct.F = type { float, float }