[DebugInfo] Support for DW_OP_implicit_pointer (DW_OP_LLVM_implicit_pointer)

[alok]

Summary

This patch (2/N) stems from D69787
It is suggested by @aprantl

Summary:

New dwarf operator DW_OP_LLVM_implicit_pointer is introduced (present only in LLVM IR)
This is needed ecause representation and specification (types of operands) of it a bit different that actual dwarf expression DW_OP_LLVM_implicit_pointer. while creating actual dwarf info it will be converted to DW_OP_LLVM_implicit_pointer.

Testing:

• llvm-as, llvm-dis
• check-llvm
• check-debuginfo (the debug info integration tests)

[jmorse]

llvm/docs/LangRef.rst

4828–4829

IMHO, "variable represented by first operand" should become something like "the DILocalVariable referred to by the instructions value/address operand". This would make it clear that we're referring to a metadata node, and that the "first operand" is of the containing debug intrinsic, not a dwarf operators operand.

llvm/lib/IR/DebugInfoMetadata.cpp

909

Shouldn't this also check that the expression has the offset argument, and (as I understand it) no other elements?

[alok]

llvm/docs/LangRef.rst

4828–4829

Thanks for your comment. It will be incorporated in next version.

[alok]

Update includes comments from @jmorse.

[aprantl]

Can you please add an assembler round-trip test to test/IR that runs llvm-as | llvm-dis | llvm-as - | llvm-dis ? There are a bunch of examples in that directory.

[alok]

In D70643#1769810, @aprantl wrote:

Can you please add an assembler round-trip test to test/IR that runs llvm-as | llvm-dis | llvm-as - | llvm-dis ? There are a bunch of examples in that directory.

Thanks @aprantl for your suggestion. Next version would have a testcase. Though the actual test case would need some changes from future patches, I would work-around that to just test the round-trip. Test case would be updated in future patch as needed.

[alok]

Updated to re-base and include a test case as suggested by @aprantl.

llvm/docs/LangRef.rst

- ``DW_OP_breg`` (or ``DW_OP_bregx``) represents a content on the provided
   ``AsmPrinter`` pass to describe call site parameter value which requires an
   expression over two registers.
 - ``DW_OP_LLVM_argN`` represents argument number N of the containing LLVM
   intrinsic. Where N can be any value from 0 to 7. For example in intrinsic
   ``call @llvm.dbg.someintrinsic(DILocalVariable("x"), DILocalVariable("y"),
   metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_LLVM_arg1, DW_OP_plus))``
   ``DW_OP_LLVM_arg0`` represents ``DILocalVariable("x")`` and
   ``DW_OP_LLVM_arg1`` represents ``DILocalVariable("y")``.
+- ``DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0 N`` can only appear at the
+  beginning of a ``DIExpression``, and it specifies the value of variable
+  represented by the ``DILocalVariable`` referred to by the instructions 
+  value/address operand at offset N.
 
 DWARF specifies three kinds of simple location descriptions: Register, memory,
 and implicit location descriptions.  Note that a location description is
 defined over certain ranges of a program, i.e the location of a variable may
 change over the course of the program. Register and memory location
 descriptions describe the *concrete location* of a source variable (in the
 sense that a debugger might modify its value), whereas *implicit locations*
 describe merely the actual *value* of a source variable which might not exist

llvm/include/llvm/BinaryFormat/Dwarf.h

#include "llvm/BinaryFormat/Dwarf.def"
   DW_FORM_lo_user = 0x1f00, ///< Not specified by DWARF.
 };
 
 enum LocationAtom {
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) DW_OP_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_OP_lo_user = 0xe0,
   DW_OP_hi_user = 0xff,
-  DW_OP_LLVM_fragment = 0x1000,    ///< Only used in LLVM metadata.
-  DW_OP_LLVM_convert = 0x1001,     ///< Only used in LLVM metadata.
-  DW_OP_LLVM_tag_offset = 0x1002,  ///< Only used in LLVM metadata.
-  DW_OP_LLVM_entry_value = 0x1003, ///< Only used in LLVM metadata.
-  DW_OP_LLVM_arg0 = 0x1004,        ///< Only used in LLVM metadata.
-  DW_OP_LLVM_arg1 = 0x1005,        ///< Only used in LLVM metadata.
-  DW_OP_LLVM_arg2 = 0x1006,        ///< Only used in LLVM metadata.
-  DW_OP_LLVM_arg3 = 0x1007,        ///< Only used in LLVM metadata.
-  DW_OP_LLVM_arg4 = 0x1008,        ///< Only used in LLVM metadata.
-  DW_OP_LLVM_arg5 = 0x1009,        ///< Only used in LLVM metadata.
-  DW_OP_LLVM_arg6 = 0x100a,        ///< Only used in LLVM metadata.
-  DW_OP_LLVM_arg7 = 0x100b,        ///< Only used in LLVM metadata.
+  DW_OP_LLVM_fragment = 0x1000,         ///< Only used in LLVM metadata.
+  DW_OP_LLVM_convert = 0x1001,          ///< Only used in LLVM metadata.
+  DW_OP_LLVM_tag_offset = 0x1002,       ///< Only used in LLVM metadata.
+  DW_OP_LLVM_entry_value = 0x1003,      ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg0 = 0x1004,             ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg1 = 0x1005,             ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg2 = 0x1006,             ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg3 = 0x1007,             ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg4 = 0x1008,             ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg5 = 0x1009,             ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg6 = 0x100a,             ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg7 = 0x100b,             ///< Only used in LLVM metadata.
+  DW_OP_LLVM_implicit_pointer = 0x100c, ///< Only used in LLVM metadata.
 };
 
 enum TypeKind : uint8_t {
 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) DW_ATE_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_ATE_lo_user = 0x80,
   DW_ATE_hi_user = 0xff
 };

llvm/lib/BinaryFormat/Dwarf.cpp

#include "llvm/BinaryFormat/Dwarf.def"
   case DW_OP_LLVM_arg4:
     return "DW_OP_LLVM_arg4";
   case DW_OP_LLVM_arg5:
     return "DW_OP_LLVM_arg5";
   case DW_OP_LLVM_arg6:
     return "DW_OP_LLVM_arg6";
   case DW_OP_LLVM_arg7:
     return "DW_OP_LLVM_arg7";
+  case DW_OP_LLVM_implicit_pointer:
+    return "DW_OP_LLVM_implicit_pointer";
   }
 }
 
 unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
   return StringSwitch<unsigned>(OperationEncodingString)
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
   .Case("DW_OP_" #NAME, DW_OP_##NAME)
 #include "llvm/BinaryFormat/Dwarf.def"
       .Case("DW_OP_LLVM_convert", DW_OP_LLVM_convert)
       .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
       .Case("DW_OP_LLVM_tag_offset", DW_OP_LLVM_tag_offset)
       .Case("DW_OP_LLVM_entry_value", DW_OP_LLVM_entry_value)
       .Case("DW_OP_LLVM_arg0", DW_OP_LLVM_arg0)
       .Case("DW_OP_LLVM_arg1", DW_OP_LLVM_arg1)
       .Case("DW_OP_LLVM_arg2", DW_OP_LLVM_arg2)
       .Case("DW_OP_LLVM_arg3", DW_OP_LLVM_arg3)
       .Case("DW_OP_LLVM_arg4", DW_OP_LLVM_arg4)
       .Case("DW_OP_LLVM_arg5", DW_OP_LLVM_arg5)
       .Case("DW_OP_LLVM_arg6", DW_OP_LLVM_arg6)
       .Case("DW_OP_LLVM_arg7", DW_OP_LLVM_arg7)
+      .Case("DW_OP_LLVM_implicit_pointer", DW_OP_LLVM_implicit_pointer)
       .Default(0);
 }
 
 unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
   switch (Op) {
   default:
     return 0;
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \

llvm/lib/IR/AsmWriter.cpp

if (N->isValid()) {
     for (auto I = N->expr_op_begin(), E = N->expr_op_end(); I != E; ++I) {
       auto OpStr = dwarf::OperationEncodingString(I->getOp());
       assert(!OpStr.empty() && "Expected valid opcode");
 
       Out << FS << OpStr;
       if (I->getOp() == dwarf::DW_OP_LLVM_convert) {
         Out << FS << I->getArg(0);
         Out << FS << dwarf::AttributeEncodingString(I->getArg(1));
+      } else if (I->getOp() == dwarf::DW_OP_LLVM_implicit_pointer) {
+        Out << FS << dwarf::OperationEncodingString(I->getArg(0));
+        Out << FS << I->getArg(1);
       } else {
         for (unsigned A = 0, AE = I->getNumArgs(); A != AE; ++A)
           Out << FS << I->getArg(A);
       }
     }
   } else {
     for (const auto &I : N->getElements())
       Out << FS << I;

llvm/lib/IR/DebugInfoMetadata.cpp

unsigned DIExpression::ExprOperand::getSize() const {
 
   if (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31)
     return 2;
 
   switch (Op) {
   case dwarf::DW_OP_LLVM_convert:
   case dwarf::DW_OP_LLVM_fragment:
   case dwarf::DW_OP_bregx:
+  case dwarf::DW_OP_LLVM_implicit_pointer:
     return 3;
   case dwarf::DW_OP_constu:
   case dwarf::DW_OP_consts:
   case dwarf::DW_OP_deref_size:
   case dwarf::DW_OP_plus_uconst:
   case dwarf::DW_OP_LLVM_tag_offset:
   case dwarf::DW_OP_LLVM_entry_value:
   case dwarf::DW_OP_regx:
case dwarf::DW_OP_LLVM_entry_value: {
       // An entry value operator must appear at the beginning and the number of
       // operations it cover can currently only be 1, because we support only
       // entry values of a simple register location. One reason for this is that
       // we currently can't calculate the size of the resulting DWARF block for
       // other expressions.
       return I->get() == expr_op_begin()->get() && I->getArg(0) == 1 &&
              getNumElements() == 2;
     }
+    case dwarf::DW_OP_LLVM_implicit_pointer: {
+      // A DW_OP_LLVM_implicit_pointer operator must appear at the beginning
+      // and it has two arguments, DW_OP_LLVM_arg0 and offset N.
+      return (I == expr_op_begin()) &&
+             (I->getArg(0) == dwarf::DW_OP_LLVM_arg0) &&
+             (getNumElements() == 3);
+    }
     case dwarf::DW_OP_LLVM_convert:
     case dwarf::DW_OP_LLVM_tag_offset:
     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_div:

llvm/test/DebugInfo/LLVM_implicit_pointer.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+; CHECK: !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)
+
+;---------------------------
+;static const char *b = "opq";
+;volatile int v;
+;int main() {
+;  int var1 = 4;
+;  int *ptr1;
+;
+;  v++;
+;  ptr1 = &var1;
+;  v++;
+;
+;  return *ptr1 - 5;
+;}
+;---------------------------
+
+; ModuleID = 'LLVM_implicit_pointer.c'
+source_filename = "LLVM_implicit_pointer.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: nofree norecurse nounwind uwtable
+define dso_local i32 @main() local_unnamed_addr !dbg !12 {
+entry:
+  call void @llvm.dbg.value(metadata i32 4, metadata !16, metadata !DIExpression()), !dbg !19
+  %0 = load volatile i32, i32* @v, align 4, !dbg !20, !tbaa !21
+  %inc = add nsw i32 %0, 1, !dbg !20
+  store volatile i32 %inc, i32* @v, align 4, !dbg !20, !tbaa !21
+
+;  Intrinsic dbg.derefval is not yet introduced, 
+;  To test DW_OP_LLVM_implicit_pointer lets convert it to dbg.value
+;  It will be restored once dbg.derefval is introduced 
+;  call void @llvm.dbg.derefval(metadata !16, metadata !17, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !19
+
+  call void @llvm.dbg.value(metadata i32 4, metadata !17, metadata !DIExpression(DW_OP_LLVM_implicit_pointer, DW_OP_LLVM_arg0, 0)), !dbg !19
+
+  %1 = load volatile i32, i32* @v, align 4, !dbg !25, !tbaa !21
+  %inc1 = add nsw i32 %1, 1, !dbg !25
+  store volatile i32 %inc1, i32* @v, align 4, !dbg !25, !tbaa !21
+  ret i32 -1, !dbg !26
+}
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata)
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.derefval(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: 2, 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, splitDebugInlining: false, nameTableKind: None)
+!3 = !DIFile(filename: "LLVM_implicit_pointer.c", directory: "/dir", checksumkind: CSK_MD5, checksum: "218aaa8dc9f04b056b56d944d06383dd")
+!4 = !{}
+!5 = !{!0}
+!6 = !DIDerivedType(tag: DW_TAG_volatile_type, baseType: !7)
+!7 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!8 = !{i32 7, !"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: 3, type: !13, scopeLine: 3, flags: DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !2, retainedNodes: !15)
+!13 = !DISubroutineType(types: !14)
+!14 = !{!7}
+!15 = !{!16, !17}
+!16 = !DILocalVariable(name: "var1", scope: !12, file: !3, line: 4, type: !7)
+!17 = !DILocalVariable(name: "ptr1", scope: !12, file: !3, line: 5, type: !18)
+!18 = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: !7, size: 64)
+!19 = !DILocation(line: 0, scope: !12)
+!20 = !DILocation(line: 7, 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 = !DILocation(line: 9, column: 4, scope: !12)
+!26 = !DILocation(line: 11, column: 3, scope: !12)