[DebugInfo] Introduce a DW_OP_LLVM_convert_generic operation

[dstenb]

Summary

DW_OP_LLVM_convert is used to do sign- and zero extensions in
DIExpressions. When using DWARFv5, that LLVM operation is translated
into DWARFv5's DW_OP_convert operation.

DWARFv5 section 2.5.1.4 specifies the following for arithmetical and
logical operations:

"Operands of an operation with two operands must have the same type,
either the same base type or the generic type."

So when we have used DW_OP_LLVM_convert in an expression, we need to
make sure that any arithmetical and logical operations operating on that
element have operands of the same type. As we currently don't have a
good interface for detecting what type is on top of the stack, and we
add arithmetical and logical operations, e.g. appending expressions like
{DW_OP_constu 1, DW_OP_plus}, in many places, this patch attempts to
alleviate such cases by introduced a new operation,
DW_OP_LLVM_convert_generic, which converts the top of the stack back to
the generic type.

At least initially, I think we should use this operation after each
sign- and zero extension done using DW_OP_LLVM_convert, until we are
more type aware on the stack. That is done in a follow-up patch.

I added a new operation rather than making DW_OP_LLVM_convert having a
special mode that converts to the generic type, e.g. when the size
operand is 0, as I thought this would be clearer.

[djtodoro]

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

487

//<comment instead?

[aprantl]

Have you thought about doing this

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

487

I don't think that's a thing for non-doxygen comments.

The proper, if verbose, LLVM style is

/ ULEB128.
emitUnsigned(0);

[vsk]

Thanks, lgtm.

[dstenb]

In D76145#1924795, @aprantl wrote:

Have you thought about doing this

Thanks for the suggestions. As emitUnsigned() emit ULEB128 encoded data maybe I should just remove that comment.

[dstenb]

Rebase on top of D76423. Add a test that verifies that the operation is emitted correctly in location lists. Without D76423 this patch would simply emit a DW_OP_convert with the first base type in ExprRefedBaseTypes, rather than 0x0.

llvm/docs/LangRef.rst

 - ``DW_OP_LLVM_fragment, 16, 8`` specifies the offset and size (``16`` and ``8``
   here, respectively) of the variable fragment from the working expression. Note
   that contrary to DW_OP_bit_piece, the offset is describing the location
   within the described source variable.
 - ``DW_OP_LLVM_convert, 16, DW_ATE_signed`` specifies a bit size and encoding
   (``16`` and ``DW_ATE_signed`` here, respectively) to which the top of the
   expression stack is to be converted. Maps into a ``DW_OP_convert`` operation
   that references a base type constructed from the supplied values.
+- ``DW_OP_LLVM_convert_generic`` converts the top of the expression stack to
+  what's referred to in DWARF as the generic type; that is, with the size of an
+  address on the target machine and with unspecified signedness. Maps into a
+  ``DW_OP_convert`` operation with operand 0.
 - ``DW_OP_LLVM_tag_offset, tag_offset`` specifies that a memory tag should be
   optionally applied to the pointer. The memory tag is derived from the
   given tag offset in an implementation-defined manner.
 - ``DW_OP_swap`` swaps top two stack entries.
 - ``DW_OP_xderef`` provides extended dereference mechanism. The entry at the top
   of the stack is treated as an address. The second stack entry is treated as an
   address space identifier.
 - ``DW_OP_stack_value`` marks a constant value.

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_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_convert_generic = 0x1004, ///< 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_convert:
     return "DW_OP_LLVM_convert";
   case DW_OP_LLVM_fragment:
     return "DW_OP_LLVM_fragment";
   case DW_OP_LLVM_tag_offset:
     return "DW_OP_LLVM_tag_offset";
   case DW_OP_LLVM_entry_value:
     return "DW_OP_LLVM_entry_value";
+  case DW_OP_LLVM_convert_generic:
+    return "DW_OP_LLVM_convert_generic";
   }
 }
 
 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_convert_generic", DW_OP_LLVM_convert_generic)
       .Default(0);
 }
 
 unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
   switch (Op) {
   default:
     return 0;
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
   auto &&Comments = DebugLocs.getComments(Entry);
   auto Comment = Comments.begin();
   auto End = Comments.end();
 
   // The expressions are inserted into a byte stream rather early (see
   // DwarfExpression::addExpression) so for those ops (e.g. DW_OP_convert) that
   // need to reference a base_type DIE the offset of that DIE is not yet known.
   // To deal with this we instead insert a placeholder early and then extract
-  // it here and replace it with the real reference.
+  // it here and replace it with the real reference. The value 0 is reserved
+  // for DWARF operations that refer to the generic type with a zero-valued
+  // operand, so just emit that as is.
   unsigned PtrSize = Asm->MAI->getCodePointerSize();
   DWARFDataExtractor Data(StringRef(DebugLocs.getBytes(Entry).data(),
                                     DebugLocs.getBytes(Entry).size()),
                           Asm->getDataLayout().isLittleEndian(), PtrSize);
   DWARFExpression Expr(Data, PtrSize);
 
   using Encoding = DWARFExpression::Operation::Encoding;
   uint64_t Offset = 0;
   for (auto &Op : Expr) {
     assert(Op.getCode() != dwarf::DW_OP_const_type &&
            "3 operand ops not yet supported");
     Streamer.EmitInt8(Op.getCode(), Comment != End ? *(Comment++) : "");
     Offset++;
     for (unsigned I = 0; I < 2; ++I) {
       if (Op.getDescription().Op[I] == Encoding::SizeNA)
         continue;
-      if (Op.getDescription().Op[I] == Encoding::BaseTypeRef) {
-        assert(Op.getRawOperand(I) &&
-               "BaseTypeRefs referring to the generic type are not supported");
+      if (Op.getDescription().Op[I] == Encoding::BaseTypeRef &&
+          Op.getRawOperand(I) > 0) {
         uint64_t Offset = CU->getBaseTypeDIE(Op.getRawOperand(I))->getOffset();
         assert(Offset < (1ULL << (ULEB128PadSize * 7)) && "Offset wont fit");
         Streamer.emitULEB128(Offset, "", ULEB128PadSize);
         // Make sure comments stay aligned.
         for (unsigned J = 0; J < ULEB128PadSize; ++J)
           if (Comment != End)
             Comment++;
       } else {

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

case dwarf::DW_OP_LLVM_convert: {
             emitLegacyZExt(PrevConvertOp->getArg(0));
           PrevConvertOp = None;
         } else {
           PrevConvertOp = Op;
         }
       }
       break;
     }
+    case dwarf::DW_OP_LLVM_convert_generic:
+      // In DWARF version 4 and earlier the stack elements are only of an
+      // unspecified type (what is referred to as the generic type in DWARF
+      // version 5), and earlier conversion operations on the stack have just
+      // been done using bit manipulation on that type, so nothing needs to be
+      // done here.
+      if (DwarfVersion >= 5) {
+        emitOp(dwarf::DW_OP_convert);
+        emitUnsigned(0);
+      }
+      break;
     case dwarf::DW_OP_stack_value:
       LocationKind = Implicit;
       break;
     case dwarf::DW_OP_swap:
       assert(!isRegisterLocation());
       emitOp(dwarf::DW_OP_swap);
       break;
     case dwarf::DW_OP_xderef:

llvm/lib/IR/DebugInfoMetadata.cpp

case dwarf::DW_OP_LLVM_entry_value: {
       // 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_convert:
+    case dwarf::DW_OP_LLVM_convert_generic:
     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:
     case dwarf::DW_OP_mod:

llvm/test/Assembler/diexpression.ll

 ; RUN: llvm-as < %s | llvm-dis | llvm-as | llvm-dis | FileCheck %s
 ; RUN: verify-uselistorder %s
 
 ; CHECK: !named = !{
 ; CHECK-SAME: !DIExpression(),
 ; CHECK-SAME: !DIExpression(DW_OP_deref),
 ; CHECK-SAME: !DIExpression(DW_OP_constu, 3, DW_OP_plus),
 ; CHECK-SAME: !DIExpression(DW_OP_LLVM_fragment, 3, 7),
 ; CHECK-SAME: !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 3, DW_OP_LLVM_fragment, 3, 7),
 ; CHECK-SAME: !DIExpression(DW_OP_constu, 2, DW_OP_swap, DW_OP_xderef),
 ; CHECK-SAME: !DIExpression(DW_OP_plus_uconst, 3)
 ; CHECK-SAME: !DIExpression(DW_OP_LLVM_convert, 16, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_signed)
-; CHECK-SAME: !DIExpression(DW_OP_LLVM_tag_offset, 1)}
+; CHECK-SAME: !DIExpression(DW_OP_LLVM_tag_offset, 1)
+; CHECK-SAME: !DIExpression(DW_OP_LLVM_convert_generic)}
 
-!named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8}
+!named = !{!0, !1, !2, !3, !4, !5, !6, !7, !8, !9}
 
 !0 = !DIExpression()
 !1 = !DIExpression(DW_OP_deref)
 !2 = !DIExpression(DW_OP_constu, 3, DW_OP_plus)
 !3 = !DIExpression(DW_OP_LLVM_fragment, 3, 7)
 !4 = !DIExpression(DW_OP_deref, DW_OP_plus_uconst, 3, DW_OP_LLVM_fragment, 3, 7)
 !5 = !DIExpression(DW_OP_constu, 2, DW_OP_swap, DW_OP_xderef)
 !6 = !DIExpression(DW_OP_plus_uconst, 3)
 !7 = !DIExpression(DW_OP_LLVM_convert, 16, DW_ATE_unsigned, DW_OP_LLVM_convert, 32, DW_ATE_signed)
 !8 = !DIExpression(DW_OP_LLVM_tag_offset, 1)
+!9 = !DIExpression(DW_OP_LLVM_convert_generic)

llvm/test/DebugInfo/X86/convert-generic.ll

+; RUN: %llc_dwarf -dwarf-version=5 -filetype=obj -O0 < %s | llvm-dwarfdump - \
+; RUN:   | FileCheck %s --check-prefix=DW5
+; RUN: %llc_dwarf -dwarf-version=4 -filetype=obj -O0 < %s | llvm-dwarfdump - \
+; RUN:   | FileCheck %s --check-prefix=DW4
+
+; Verify that for DWARFv5, the DW_OP_LLVM_convert_generic operation is
+; converted to a DW_OP_convert with the generic type specified. For earlier
+; DWARF versions nothing should be emitted for that operation.
+
+; DW5: DW_AT_location  (DW_OP_breg5 RDI+0, DW_OP_constu 0xffff, DW_OP_and, DW_OP_convert ({{.*}}) "DW_ATE_signed_16", DW_OP_convert ({{.*}}) "DW_ATE_signed_32", DW_OP_convert 0x0, DW_OP_constu 0x7b, DW_OP_minus, DW_OP_stack_value)
+; DW5-NEXT: DW_AT_name  ("local1")
+
+; DW5: DW_AT_location
+; DW5-NEXT: DW_OP_breg5 RDI+0, DW_OP_constu 0xffff, DW_OP_and, DW_OP_convert (0x00000027) "DW_ATE_signed_16", DW_OP_convert (0x0000002b) "DW_ATE_signed_32", DW_OP_convert 0x0, DW_OP_constu 0x7b, DW_OP_minus, DW_OP_stack_value
+; DW5-NEXT: DW_OP_consts +123, DW_OP_stack_value)
+; DW5-NEXT: DW_AT_name  ("local2")
+
+; DW4: DW_AT_location  (DW_OP_breg5 RDI+0, DW_OP_constu 0xffff, DW_OP_and, DW_OP_dup, DW_OP_constu 0xf, DW_OP_shr, DW_OP_lit0, DW_OP_not, DW_OP_mul, DW_OP_constu 0x10, DW_OP_shl, DW_OP_or, DW_OP_constu 0x7b, DW_OP_minus, DW_OP_stack_value)
+; DW4-NEXT: DW_AT_name  ("local1")
+
+; DW4: DW_AT_location
+; DW4-NEXT: DW_OP_breg5 RDI+0, DW_OP_constu 0xffff, DW_OP_and, DW_OP_dup, DW_OP_constu 0xf, DW_OP_shr, DW_OP_lit0, DW_OP_not, DW_OP_mul, DW_OP_constu 0x10, DW_OP_shl, DW_OP_or, DW_OP_constu 0x7b, DW_OP_minus, DW_OP_stack_value
+; DW4-NEXT: DW_OP_consts +123, DW_OP_stack_value)
+; DW4-NEXT: DW_AT_name  ("local2")
+
+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"
+
+@global = external dso_local local_unnamed_addr global i16, align 2
+
+; Function Attrs: norecurse nounwind readnone uwtable
+define dso_local signext i16 @fn1(i16 returned signext %param1) local_unnamed_addr #0 !dbg !7 {
+entry:
+  call void @llvm.dbg.value(metadata i16 %param1, metadata !13, metadata !DIExpression(DW_OP_LLVM_convert, 16, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_LLVM_convert_generic, DW_OP_constu, 123, DW_OP_minus, DW_OP_stack_value)), !dbg !15
+  ret i16 %param1, !dbg !16
+}
+
+; Function Attrs: nofree norecurse nounwind uwtable writeonly
+define dso_local void @fn2(i16 signext %param2) local_unnamed_addr !dbg !17 {
+entry:
+  call void @llvm.dbg.value(metadata i16 %param2, metadata !22, metadata !DIExpression(DW_OP_LLVM_convert, 16, DW_ATE_signed, DW_OP_LLVM_convert, 32, DW_ATE_signed, DW_OP_LLVM_convert_generic, DW_OP_constu, 123, DW_OP_minus, DW_OP_stack_value)), !dbg !23
+  store i16 %param2, i16* @global, align 2, !dbg !24
+  call void @llvm.dbg.value(metadata i32 123, metadata !22, metadata !DIExpression()), !dbg !23
+  ret void, !dbg !25
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+attributes #0 = { norecurse nounwind readnone uwtable }
+attributes #1 = { nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1, producer: "clang version 11.0.0", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, splitDebugInlining: false, nameTableKind: None)
+!1 = !DIFile(filename: "ext.c", directory: "/")
+!2 = !{}
+!3 = !{i32 7, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 11.0.0 "}
+!7 = distinct !DISubprogram(name: "fn1", scope: !1, file: !1, line: 3, type: !8, scopeLine: 3, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !11)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !10}
+!10 = !DIBasicType(name: "short", size: 16, encoding: DW_ATE_signed)
+!11 = !{!12, !13}
+!12 = !DILocalVariable(name: "param1", arg: 1, scope: !7, file: !1, line: 3, type: !10)
+!13 = !DILocalVariable(name: "local1", scope: !7, file: !1, line: 4, type: !14)
+!14 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!15 = !DILocation(line: 0, scope: !7)
+!16 = !DILocation(line: 5, scope: !7)
+!17 = distinct !DISubprogram(name: "fn2", scope: !1, file: !1, line: 8, type: !18, scopeLine: 8, flags: DIFlagPrototyped | DIFlagAllCallsDescribed, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !20)
+!18 = !DISubroutineType(types: !19)
+!19 = !{null, !10}
+!20 = !{!21, !22}
+!21 = !DILocalVariable(name: "param2", arg: 1, scope: !17, file: !1, line: 8, type: !10)
+!22 = !DILocalVariable(name: "local2", scope: !17, file: !1, line: 9, type: !14)
+!23 = !DILocation(line: 0, scope: !17)
+!24 = !DILocation(line: 10, scope: !17)
+!25 = !DILocation(line: 12, scope: !17)