[Debuginfo][GlobalISel] (3/7) Support for DW_OP_implicit_pointer for named and unnamed variables (second strategy).

[alok]

Summary

This patch stems from D84112.
This patch includes changes for GlobalISel.

llvm/include/llvm/CodeGen/GlobalISel/IRTranslator.h

 namespace llvm {
 
 class AllocaInst;
 class BasicBlock;
 class CallInst;
 class CallLowering;
 class Constant;
 class DataLayout;
+class DIBuilder;
 class FunctionLoweringInfo;
 class Instruction;
 class MachineBasicBlock;
 class MachineFunction;
 class MachineInstr;
 class MachineRegisterInfo;
 class OptimizationRemarkEmitter;
 class PHINode;

llvm/include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h

MachineInstrBuilder buildFIDbgValue(int FI, const MDNode *Variable,
                                       const MDNode *Expr);
 
   /// Build and insert a DBG_VALUE instructions specifying that \p Variable is
   /// given by \p C (suitably modified by \p Expr).
   MachineInstrBuilder buildConstDbgValue(const Constant &C,
                                          const MDNode *Variable,
                                          const MDNode *Expr);
 
+  /// Build and insert a DBG_VALUE instructions specifying that the dereferenced
+  /// value of \p Variable is given by \p V (suitably modified by \p Expr).
+  MachineInstrBuilder buildDerefDbgValue(const Value *V, const MDNode *Variable,
+                                         const MDNode *Expr);
+
+  /// Build and insert a DBG_VALUE instructions specifying that the dereferenced
+  /// value of \p Variable is given by \p V (suitably modified by \p Expr).
+  MachineInstrBuilder buildDerefDbgValue(const MDNode *DerefVar,
+                                         const MDNode *Variable,
+                                         const MDNode *Expr);
+
   /// Build and insert a DBG_LABEL instructions specifying that \p Label is
   /// given. Convert "llvm.dbg.label Label" to "DBG_LABEL Label".
   MachineInstrBuilder buildDbgLabel(const MDNode *Label);
 
   /// Build and insert \p Res = G_DYN_STACKALLOC \p Size, \p Align
   ///
   /// G_DYN_STACKALLOC does a dynamic stack allocation and writes the address of
   /// the allocated memory into \p Res.

llvm/lib/CodeGen/GlobalISel/IRTranslator.cpp

 #include "llvm/CodeGen/TargetLowering.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/CodeGen/TargetRegisterInfo.h"
 #include "llvm/CodeGen/TargetSubtargetInfo.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
+#include "llvm/IR/DIBuilder.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/InlineAsm.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Metadata.h"
+#include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/User.h"
 #include "llvm/IR/Value.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/CodeGen.h"
MIRBuilder.buildInstr(TargetOpcode::G_VASTART, {}, {getOrCreateVReg(*Ptr)})
                                                 MachineMemOperand::MOStore,
                                                 ListSize, Align(1)));
     return true;
   }
   case Intrinsic::dbg_value: {
     // This form of DBG_VALUE is target-independent.
     const DbgValueInst &DI = cast<DbgValueInst>(CI);
     const Value *V = DI.getValue();
+    const DIExpression *DE = DI.getExpression();
     assert(DI.getVariable()->isValidLocationForIntrinsic(
                MIRBuilder.getDebugLoc()) &&
            "Expected inlined-at fields to agree");
+    DILocalVariable *Var = DI.getVariable();
+    DILocalVariable *PtrVar = nullptr;
+    Module *Mod = const_cast<Module *>(CI.getModule());
+
+    DIBuilder DIB(*Mod, /*AllowUnresolved*/ false);
+
+    unsigned Level = DE->explicitPointerCount();
+    SmallVector<DILocalVariable *, 1> PtrVars;
+    if (Level > 0) {
+      DIScope *Scope = DI.getDebugLoc()->getScope();
+      DIType *Type = DI.getVariable()->getType();
+      PtrVar = Var;
+      unsigned Count = Level;
+      while (Count-- > 0) {
+        if (DIDerivedType *DT = dyn_cast<DIDerivedType>(Type))
+          Type = DT->getBaseType();
+        uint32_t AlignInBits = DI.getVariable()->getAlignInBytes();
+        Var = DIB.createImplicitTempVariable(Scope, Type, AlignInBits);
+        PtrVars.push_back(Var);
+      }
+      PtrVars.push_back(PtrVar);
+      Var = PtrVars[0];
+      SmallVector<uint64_t, 3> Ops;
+      DE = DIExpression::get(DE->getContext(), Ops);
+    } else {
+      Var = DI.getVariable();
+      DE = DI.getExpression();
+    }
+
     if (!V) {
       // Currently the optimizer can produce this; insert an undef to
       // help debugging.  Probably the optimizer should not do this.
-      MIRBuilder.buildIndirectDbgValue(0, DI.getVariable(), DI.getExpression());
+      MIRBuilder.buildIndirectDbgValue(0, Var, DE);
     } else if (const auto *CI = dyn_cast<Constant>(V)) {
-      MIRBuilder.buildConstDbgValue(*CI, DI.getVariable(), DI.getExpression());
+      MIRBuilder.buildConstDbgValue(*CI, DI.getVariable(), DE);
+    } else if (DE->isImplicitPointer()) {
+      MIRBuilder.buildDerefDbgValue(V, DI.getVariable(), DI.getExpression());
     } else {
       for (Register Reg : getOrCreateVRegs(*V)) {
         // FIXME: This does not handle register-indirect values at offset 0. The
         // direct/indirect thing shouldn't really be handled by something as
         // implicit as reg+noreg vs reg+imm in the first place, but it seems
         // pretty baked in right now.
-        MIRBuilder.buildDirectDbgValue(Reg, DI.getVariable(), DI.getExpression());
+        MIRBuilder.buildDirectDbgValue(Reg, Var, DE);
       }
     }
+    unsigned Count = 0;
+    if (Count++ < Level) {
+      SmallVector<uint64_t, 3> Ops;
+      Ops.push_back(dwarf::DW_OP_LLVM_implicit_pointer);
+      Ops.push_back(0);
+      DIExpression *DIExprNew = DIExpression::get(DE->getContext(), Ops);
+
+      MIRBuilder.buildDerefDbgValue(PtrVars[Count - 1], PtrVars[Count],
+                                    DIExprNew);
+    }
     return true;
   }
   case Intrinsic::uadd_with_overflow:
     return translateOverflowIntrinsic(CI, TargetOpcode::G_UADDO, MIRBuilder);
   case Intrinsic::sadd_with_overflow:
     return translateOverflowIntrinsic(CI, TargetOpcode::G_SADDO, MIRBuilder);
   case Intrinsic::usub_with_overflow:
     return translateOverflowIntrinsic(CI, TargetOpcode::G_USUBO, MIRBuilder);

llvm/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp

if (auto *CI = dyn_cast<ConstantInt>(&C)) {
     // Insert %noreg if we didn't find a usable constant and had to drop it.
     MIB.addReg(0U);
   }
 
   MIB.addImm(0).addMetadata(Variable).addMetadata(Expr);
   return insertInstr(MIB);
 }
 
+MachineInstrBuilder MachineIRBuilder::buildDerefDbgValue(const Value *Derefval,
+                                                         const MDNode *Variable,
+                                                         const MDNode *Expr) {
+  assert(isa<DILocalVariable>(Variable) && "not a variable");
+  assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
+  assert(
+      cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(getDL()) &&
+      "Expected inlined-at fields to agree");
+  auto MIB = buildInstr(TargetOpcode::DBG_VALUE);
+  if (const auto *MDV = dyn_cast<llvm::MetadataAsValue>(Derefval)) {
+    if (const auto *LDV = dyn_cast<llvm::DIVariable>(MDV->getMetadata())) {
+      MIB.addImplicitPtrMetadata(LDV);
+    }
+  } else if (auto *CI = dyn_cast<ConstantInt>(Derefval)) {
+    if (CI->getBitWidth() > 64)
+      MIB.addCImm(CI);
+    else
+      MIB.addImm(CI->getZExtValue());
+  } else if (auto *CFP = dyn_cast<ConstantFP>(Derefval)) {
+    MIB.addFPImm(CFP);
+  } else {
+    // Insert %noreg if we didn't find a usable constant and had to drop it.
+    MIB.addReg(0U);
+  }
+
+  return MIB.addReg(0).addMetadata(Variable).addMetadata(Expr);
+}
+
+MachineInstrBuilder MachineIRBuilder::buildDerefDbgValue(const MDNode *DerefVar,
+                                                         const MDNode *Variable,
+                                                         const MDNode *Expr) {
+  assert(isa<DILocalVariable>(Variable) && "not a variable");
+  assert(cast<DIExpression>(Expr)->isValid() && "not an expression");
+  assert(
+      cast<DILocalVariable>(Variable)->isValidLocationForIntrinsic(getDL()) &&
+      "Expected inlined-at fields to agree");
+  auto MIB = buildInstr(TargetOpcode::DBG_VALUE);
+
+  MIB.addImplicitPtrMetadata(DerefVar);
+
+  return MIB.addReg(0).addMetadata(Variable).addMetadata(Expr);
+}
+
 MachineInstrBuilder MachineIRBuilder::buildDbgLabel(const MDNode *Label) {
   assert(isa<DILabel>(Label) && "not a label");
   assert(cast<DILabel>(Label)->isValidLocationForIntrinsic(State.DL) &&
          "Expected inlined-at fields to agree");
   auto MIB = buildInstr(TargetOpcode::DBG_LABEL);
 
   return MIB.addMetadata(Label);
 }

llvm/test/DebugInfo/X86/implicit_pointer_global.ll

+; RUN: llc %s -global-isel -O2 -filetype=obj -o %t.o
+; RUN: llvm-dwarfdump  %t.o | FileCheck %s
+
+; CHECK-LABEL:       DW_TAG_inlined_subroutine
+
+; Test if More than 2 member location list is printed (for pointer pointing to aggregate)
+; CHECK-LABEL:   DW_TAG_formal_parameter
+; CHECK-NEXT:    DW_AT_location
+; CHECK-NEXT:     : DW_OP_implicit_pointer [[DIE1:0x.+]] +0
+; CHECK-NEXT:     : DW_OP_implicit_pointer [[DIE2:0x.+]] +0)
+; CHECK-NEXT:    DW_AT_abstract_origin       ({{0x.+}} "ptr")
+
+; Below is the original test case this IR is generated from
+;---------------------------
+;static const char *b = "opq";
+;volatile int v;
+;static inline void foo(int *ptr) {
+;  (*ptr)++;
+;  v++;
+;  ptr++;
+;  (*ptr)++;
+;  v++;
+;}
+;
+;int main() {
+;  int arr[2] = {1, 2};
+;  v++;
+;  foo(arr);
+;  return arr[0] + arr[1] - 5;
+;}
+;---------------------------
+
+; ModuleID = 'dwarfdump-implicit_pointer_sroa_inline.c'
+source_filename = "dwarfdump-implicit_pointer_sroa_inline.c"
+target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@v = common dso_local global i32 0, align 4, !dbg !0
+
+; Function Attrs: nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr #0 !dbg !12 {
+entry:
+  %0 = load volatile i32, i32* @v, align 4, !dbg !20
+  %inc = add nsw i32 %0, 1, !dbg !20
+  store volatile i32 %inc, i32* @v, align 4, !dbg !20
+  call void @llvm.dbg.value(metadata i32 2, metadata !25, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !31
+  %1 = load volatile i32, i32* @v, align 4, !dbg !33
+  %inc1.i = add nsw i32 %1, 1, !dbg !33
+  store volatile i32 %inc1.i, i32* @v, align 4, !dbg !33
+  call void @llvm.dbg.value(metadata i32 3, metadata !25, metadata !DIExpression(DW_OP_LLVM_explicit_pointer)), !dbg !34
+  %2 = load volatile i32, i32* @v, align 4, !dbg !34
+  %inc3.i = add nsw i32 %2, 1, !dbg !34
+  store volatile i32 %inc3.i, i32* @v, align 4, !dbg !34
+  ret i32 0, !dbg !35
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+
+!llvm.dbg.cu = !{!2}
+!llvm.module.flags = !{!8, !9, !10}
+!llvm.ident = !{!11}
+
+!0 = !DIGlobalVariableExpression(var: !1, expr: !DIExpression())
+!1 = distinct !DIGlobalVariable(name: "v", scope: !2, file: !3, line: 14, type: !6, isLocal: false, isDefinition: true)
+!2 = distinct !DICompileUnit(language: DW_LANG_C99, file: !3, producer: "clang version 10.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !4, globals: !5, nameTableKind: None)
+!3 = !DIFile(filename: "dwarfdump-implicit_pointer_sroa_inline.c", directory: "/dir", checksumkind: CSK_MD5, checksum: "f9bbaee6b152b3bc05125796b573408a")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 2, !"Dwarf Version", i32 5}
+!9 = !{i32 2, !"Debug Info Version", i32 3}
+!10 = !{i32 1, !"wchar_size", i32 4}
+!11 = !{!"clang version 10.0.0"}
+!12 = distinct !DISubprogram(name: "main", scope: !3, file: !3, line: 23, type: !13, scopeLine: 23, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7}
+!15 = !{!16}
+!16 = !DILocalVariable(name: "arr", scope: !12, file: !3, line: 24, type: !17)
+!17 = !DICompositeType(tag: DW_TAG_array_type, baseType: !7, size: 64, elements: !18)
+!18 = !{!19}
+!19 = !DISubrange(count: 2)
+!20 = !DILocation(line: 25, column: 4, scope: !12)
+!21 = !{!22, !22, i64 0}
+!22 = !{!"int", !23, i64 0}
+!23 = !{!"omnipotent char", !24, i64 0}
+!24 = !{!"Simple C/C++ TBAA"}
+!25 = !DILocalVariable(name: "ptr", arg: 1, scope: !26, file: !3, line: 15, type: !29)
+!26 = distinct !DISubprogram(name: "foo", scope: !3, file: !3, line: 15, type: !27, scopeLine: 15, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagLocalToUnit | DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !30)
+!27 = !DISubroutineType(types: !28)
+!28 = !{null, !29}
+!29 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!30 = !{!25}
+!31 = !DILocation(line: 0, scope: !26, inlinedAt: !32)
+!32 = distinct !DILocation(line: 26, column: 3, scope: !12)
+!33 = !DILocation(line: 17, column: 4, scope: !26, inlinedAt: !32)
+!34 = !DILocation(line: 20, column: 4, scope: !26, inlinedAt: !32)
+!35 = !DILocation(line: 27, column: 3, scope: !12)