Debug info for variables whose type is shrinked to bool

[NikolaPrica]

Summary

During the globalopt transformation, when shrinking variable type into boolean, debug information for static global variables is dispatched. As a result there is no DW_AT_location and the debugger is not able to read such variables.

[aprantl]

lib/Transforms/IPO/GlobalOpt.cpp

1604

I'm not familiar with this transformation: Do we need to add a DIExpression to mask out all but the first bit (i.e. can multiple bools be packed into the same uint32_t such that it could confuse debuggers)?

test/Transforms/GlobalOpt/static-global-boolean-dwarf.c

2 ↗

(On Diff #108641)

We shouldn't require a frontend to be available when running tests. Can you use thew output of clang -S -emit-llvm instead an run it through opt?

[NikolaPrica]

lib/Transforms/IPO/GlobalOpt.cpp

1604

The debug info which is provided here with addDebugInfo later generates address of the variable (DW_OP_addr: xxxx) in DW_AT_location. If we provide here metadata which is for 1byte variable the debugger would get confused because the enum type is written as 4-byte and he would try to read 4 bytes. This is just temporary fix until proper way to handle this is found.

[NikolaPrica]

Changing test file from .c to .ll

[NikolaPrica]

Sorry for spaming. First time using Phabricator. Uploaded wrong diff.

[probinson]

test/Transforms/GlobalOpt/static-global-boolean-dwarf.ll

2 ↗

(On Diff #109057)

It would be more usual to pipe the output of opt directly to llvm-dwarfdump, unless opt can't do that.
(It helps the tests run faster to avoid writing files unless you really have to.)

128 ↗

(On Diff #109057)

These checks verify that something named "foo" has debug info of some kind, but without verifying any details. I'd rather see verification of the location expression, and possibly the type, given that you are planning to change those in the future to describe the shrunk variable.

[aprantl]

lib/Transforms/IPO/GlobalOpt.cpp

1604

If I understood you correctly then the best way to represent this would be a DW_OP_LLVM_fragment /*offset*/0 /*bitsize*/1 (or 8?)
expression. This will get lowered into a DW_OP_bit_piece to tell the debugger that this location is describing of the first n bits of the variable.

[NikolaPrica]

This patch implements new DIExpression :

 val * (ValOther - ValInit) + ValInit:
 DW_OP_deref DW_OP_constu <ValMinus>
DW_OP_mul DW_OP_constu <ValInit> DW_OP_plus DW_OP_stack_value

The other expression which was suggested was :

// val * 42 | ((~val)&1) * 87
DW_OP_dup DW_OP_deref DW_OP_constu 42 DW_OP_mul DW_OP_swap
DW_OP_deref DW_OP_not DW_OP_lit1 DW_OP_and DW_OP_constu 87 DW_OP_mul
DW_OP_or DW_OP_stack_value

I have chosen to implement first because it is simpler.
I have also added simpler test also with concrete DW_AT_location description .

[aprantl]

In D35994#838113, @NikolaPrica wrote:

This patch implements new DIExpression :

val * (ValOther - ValInit) + ValInit:

If we are doing this expression, there should be an assertion in the code that ValInit < ValOther.

 DW_OP_deref DW_OP_constu <ValMinus>
DW_OP_mul DW_OP_constu <ValInit> DW_OP_plus DW_OP_stack_value

Why does Val need to be dereferenced?

If we use our concrete example with 42 and 87 again:

start: <val> // either 0 or 1
DW_OP_deref // not sure why this is needed, but let's assume we still have 0 or 1 on the stack
DW_OP_constu (87-42) // <0 or 1> <45>
DW_OP_mul // <0 or 45>
DW_OP_constu 42 // <0 or 45> <42>
DW_OP_plus // <42 or 87>
DW_OP_stack_value

Apart from the DW_OP_deref, this seems very good, I'm slightly worried about the assumption that the init value will always be the smaller one.
What happens if any of the two values is negative (because of the typeless DWARF <5 expression stack — not sure if this will be a problem).

The other expression which was suggested was :

// val * 42 | ((~val)&1) * 87
DW_OP_dup DW_OP_deref DW_OP_constu 42 DW_OP_mul DW_OP_swap
DW_OP_deref DW_OP_not DW_OP_lit1 DW_OP_and DW_OP_constu 87 DW_OP_mul
DW_OP_or DW_OP_stack_value

I have chosen to implement first because it is simpler.
I have also added simpler test also with concrete DW_AT_location description .

lib/Transforms/IPO/GlobalOpt.cpp

1641

typo: emit

[NikolaPrica]

val * (ValOther - ValInit) + ValInit:

If we are doing this expression, there should be an assertion in the code that ValInit < ValOther.

I have tested this for edge cases such as both negative values, LONG_MAX, LONG_INT etc and there was no problem for this values. Only flaw for this is ugly long DW_AT_location expression for long values.

 DW_OP_deref DW_OP_constu <ValMinus>
DW_OP_mul DW_OP_constu <ValInit> DW_OP_plus DW_OP_stack_value

Why does Val need to be dereferenced?

DW_OP_deref needs to be used because we have address of new variable on stack, not its value.

Apart from the DW_OP_deref, this seems very good, I'm slightly worried about the assumption that the init value will always be the smaller one.
What happens if any of the two values is negative (because of the typeless DWARF <5 expression stack — not sure if this will be a problem).

For dwarf versions lower than 4 gdb reads value of DW_AT_location expression as address giving message "Cannot access memory at address 0x1e". This may be a problem but it is still better than optimized-out?

[aprantl]

In D35994#854146, @NikolaPrica wrote:

val * (ValOther - ValInit) + ValInit:

If we are doing this expression, there should be an assertion in the code that ValInit < ValOther.

I have tested this for edge cases such as both negative values, LONG_MAX, LONG_INT etc and there was no problem for this values. Only flaw for this is ugly long DW_AT_location expression for long values.

Cool. Thanks for checking!

 DW_OP_deref DW_OP_constu <ValMinus>
DW_OP_mul DW_OP_constu <ValInit> DW_OP_plus DW_OP_stack_value

Why does Val need to be dereferenced?

DW_OP_deref needs to be used because we have address of new variable on stack, not its value.

Oh, because it is a global variable! Makes sense.

Apart from the DW_OP_deref, this seems very good, I'm slightly worried about the assumption that the init value will always be the smaller one.
What happens if any of the two values is negative (because of the typeless DWARF <5 expression stack — not sure if this will be a problem).

For dwarf versions lower than 4 gdb reads value of DW_AT_location expression as address giving message "Cannot access memory at address 0x1e". This may be a problem but it is still better than optimized-out?

That makes sense. I'm fine with not attempting to fix this.

test/Transforms/GlobalOpt/integer-bool-dwarf.ll

44

please strip out all non-essential attributes (everything in quotes)

[aprantl]

In fully-compliant mode we should just not emit any DWARF expression that ends with a DW_OP_stack_value in DWARF < 4. However, LLDB and GDB (at least the version Apple used to ship in Xcode) support a couple of expressions that are outside of the specification but do work in practice, so I'm reluctant to drop support for that by being stricter.
That said, Darwin has been using DWARF 4 for a while now, so an argument could be made that it is okay to regress on older deployment targets for the sake of correctness/standards compliance.

[NikolaPrica]

Updated test case

[dblaikie]

test/Transforms/GlobalOpt/integer-bool-dwarf.ll

84–92

Probably put these CHECK lines up the top, above the IR - that's where they usually go for test cases.

[NikolaPrica]

Updating test case.

lib/CodeGen/AsmPrinter/DwarfExpression.cpp

while (ExprCursor) {
     }
     case dwarf::DW_OP_plus_uconst:
       assert(LocationKind != Register);
       emitOp(dwarf::DW_OP_plus_uconst);
       emitUnsigned(Op->getArg(0));
       break;
     case dwarf::DW_OP_plus:
     case dwarf::DW_OP_minus:
+    case dwarf::DW_OP_mul:
       emitOp(Op->getOp());
       break;
     case dwarf::DW_OP_deref:
       assert(LocationKind != Register);
       if (LocationKind != Memory && isMemoryLocation(ExprCursor))
         // Turning this into a memory location description makes the deref
         // implicit.
         LocationKind = Memory;

lib/IR/DebugInfoMetadata.cpp

case dwarf::DW_OP_swap: {
       if (getNumElements() == 1)
         return false;
       break;
     }
     case dwarf::DW_OP_constu:
     case dwarf::DW_OP_plus_uconst:
     case dwarf::DW_OP_plus:
     case dwarf::DW_OP_minus:
+    case dwarf::DW_OP_mul:
     case dwarf::DW_OP_deref:
     case dwarf::DW_OP_xderef:
       break;
     }
   }
   return true;
 }
 

lib/Transforms/IPO/GlobalOpt.cpp

 #include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/ValueHandle.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/raw_ostream.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/Utils/CtorUtils.h"
 #include "llvm/Transforms/Utils/Evaluator.h"
GlobalVariable *NewGV = new GlobalVariable(Type::getInt1Ty(GV->getContext()),
                                              GV->getName()+".b",
                                              GV->getThreadLocalMode(),
                                              GV->getType()->getAddressSpace());
   NewGV->copyAttributesFrom(GV);
   GV->getParent()->getGlobalList().insert(GV->getIterator(), NewGV);
 
   Constant *InitVal = GV->getInitializer();
   assert(InitVal->getType() != Type::getInt1Ty(GV->getContext()) &&
          "No reason to shrink to bool!");
 
+  SmallVector<DIGlobalVariableExpression *, 1> GVs;
+  GV->getDebugInfo(GVs);
+
   // If initialized to zero and storing one into the global, we can use a cast
   // instead of a select to synthesize the desired value.
   bool IsOneZero = false;
-  if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal))
+  if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)){
     IsOneZero = InitVal->isNullValue() && CI->isOne();
 
+    ConstantInt *CIInit = dyn_cast<ConstantInt>(GV->getInitializer());
+    uint64_t ValInit = CIInit->getZExtValue();
+    uint64_t ValOther = CI->getZExtValue();
+    uint64_t ValMinus = ValOther - ValInit;
+
+    for(auto *GVe : GVs){
+      DIGlobalVariable *DGV = GVe->getVariable();
+      DIExpression *E = GVe->getExpression();
+
+      // val * (ValOther - ValInit) + ValInit:
+      // DW_OP_deref DW_OP_constu <ValMinus>
+      // DW_OP_mul DW_OP_constu <ValInit> DW_OP_plus DW_OP_stack_value
+      E = DIExpression::get(NewGV->getContext(),
+                           {dwarf::DW_OP_deref,
+                            dwarf::DW_OP_constu,
+                            ValMinus,
+                            dwarf::DW_OP_mul,
+                            dwarf::DW_OP_constu,
+                            ValInit,
+                            dwarf::DW_OP_plus,
+                            dwarf::DW_OP_stack_value});
+      DIGlobalVariableExpression *DGVE =
+        DIGlobalVariableExpression::get(NewGV->getContext(), DGV, E);
+      NewGV->addDebugInfo(DGVE);
+    }
+  } else {
+    // FIXME: This will only emit address for debugger on which will
+    // be written only 0 or 1.
+    for(auto *GV : GVs)
+      NewGV->addDebugInfo(GV);
+  }
+
   while (!GV->use_empty()) {
     Instruction *UI = cast<Instruction>(GV->user_back());
     if (StoreInst *SI = dyn_cast<StoreInst>(UI)) {
       // Change the store into a boolean store.
       bool StoringOther = SI->getOperand(0) == OtherVal;
       // Only do this if we weren't storing a loaded value.
       Value *StoreVal;
       if (StoringOther || SI->getOperand(0) == InitVal) {

test/Transforms/GlobalOpt/integer-bool-dwarf.ll

+;RUN: opt -globalopt -f %s | llc -filetype=obj -o -| llvm-dwarfdump - | FileCheck %s
+
+;CHECK: DW_AT_name [DW_FORM_strp] {{.*}} "foo"
+;CHECK-NEXT: DW_AT_type {{.*}}
+;CHECK-NEXT: DW_AT_decl_file {{.*}}
+;CHECK-NEXT: DW_AT_decl_line {{.*}}
+;CHECK-NEXT: DW_AT_location [DW_FORM_exprloc] (<0x11> 03 {{.*}} 06 10 6f 1e 10 00 22 9f )
+;                 DW_OP_addr <addr> DW_OP_deref DW_OP_constu <111> DW_OP_mul
+;                 DW_OP_constu <0>
+;                 DW_OP_plus
+;                 DW_OP_stack_value
+
+source_filename = "integer-bool-dwarf.c"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@foo = internal global i32 0, align 4, !dbg !0
+
+; Function Attrs: noinline nounwind optnone uwtable
+define void @set1() #0 !dbg !11 {
+entry:
+  store i32 111, i32* @foo, align 4, !dbg !14
+  ret void, !dbg !15
+}
+
+; Function Attrs: noinline nounwind optnone uwtable
+define void @set2() #0 !dbg !16 {
+entry:
+  store i32 0, i32* @foo, align 4, !dbg !17
+  ret void, !dbg !18
+}
+
+; Function Attrs: noinline nounwind optnone uwtable
+define i32 @get() #0 !dbg !19 {
+entry:
+  %A = alloca i32, align 4
+  %C = alloca i32, align 4
+  call void @llvm.dbg.declare(metadata i32* %A, metadata !22, metadata !23), !dbg !24
+  %0 = load i32, i32* @foo, align 4, !dbg !25
+  store i32 %0, i32* %A, align 4, !dbg !24
+  call void @llvm.dbg.declare(metadata i32* %C, metadata !26, metadata !23), !dbg !27
+  %1 = load i32, i32* %A, align 4, !dbg !28
+  %cmp = icmp slt i32 %1, 2, !dbg !29
+  %conv = zext i1 %cmp to i32, !dbg !29
+  store i32 %conv, i32* %C, align 4, !dbg !27
+  %2 = load i32, i32* %C, align 4, !dbg !30
+  ret i32 %2, !dbg !31
+}
+
+; Function Attrs: nounwind readnone speculatable
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { noinline nounwind optnone uwtable }
+attributes #1 = { nounwind readnone speculatable }
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!7, !8, !9}
+!llvm.ident = !{!10}
+
+!0 = !DIGlobalVariableExpression(var: !1)
+!1 = distinct !DIGlobalVariable(name: "foo", scope: !2, file: !3, line: 1, type: !6, isLocal: true, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 5.0.0 ", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5)
+!3 = !DIFile(filename: "/tmp/integer-bool-dwarf.c", directory: "/tmp")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!7 = !{i32 2, !"Dwarf Version", i32 4}
+!8 = !{i32 2, !"Debug Info Version", i32 3}
+!9 = !{i32 1, !"wchar_size", i32 4}
+!10 = !{!"clang version 5.0.0 "}
+!11 = distinct !DISubprogram(name: "set1", scope: !3, file: !3, line: 3, type: !12, isLocal: false, isDefinition: true, scopeLine: 4, isOptimized: false, unit: !2, variables: !4)
+!12 = !DISubroutineType(types: !13)
+!13 = !{null}
+!14 = !DILocation(line: 5, column: 13, scope: !11)
+!15 = !DILocation(line: 6, column: 1, scope: !11)
+!16 = distinct !DISubprogram(name: "set2", scope: !3, file: !3, line: 8, type: !12, isLocal: false, isDefinition: true, scopeLine: 9, isOptimized: false, unit: !2, variables: !4)
+!17 = !DILocation(line: 10, column: 13, scope: !16)
+!18 = !DILocation(line: 11, column: 1, scope: !16)
+!19 = distinct !DISubprogram(name: "get", scope: !3, file: !3, line: 13, type: !20, isLocal: false, isDefinition: true, scopeLine: 14, isOptimized: false, unit: !2, variables: !4)
+!20 = !DISubroutineType(types: !21)
+!21 = !{!6}
+!22 = !DILocalVariable(name: "A", scope: !19, file: !3, line: 15, type: !6)
+!23 = !DIExpression()
+!24 = !DILocation(line: 15, column: 13, scope: !19)
+!25 = !DILocation(line: 15, column: 17, scope: !19)
+!26 = !DILocalVariable(name: "C", scope: !19, file: !3, line: 16, type: !6)
+!27 = !DILocation(line: 16, column: 13, scope: !19)
+!28 = !DILocation(line: 16, column: 18, scope: !19)
+!29 = !DILocation(line: 16, column: 19, scope: !19)
+!30 = !DILocation(line: 17, column: 16, scope: !19)
+!31 = !DILocation(line: 17, column: 9, scope: !19)
+