[Dwarf] Support heterogeneous DW_{OP,AT}s needed for AMDGPU CFI

These are defined in the user range until standard versions of them get
adopted into dwarf, which is expected in DWARF6.

Some of these amount to reservations currently as no code to use them is
included. It would be very helpful to get them committed to avoid
conflicts necessitating encoding changes while we are in the process of
upstreaming.

Co-authored-by: Juan Martinez Fernandez <[email protected]>
Co-authored-by: Emma Pilkington <[email protected]>
(cherry picked from commit dc1c1aec483feba48fd0c0acd855c17d239d07ef)

Author: 3 people

llvm/include/llvm/BinaryFormat/Dwarf.h

@@ -1027,7 +1027,7 @@ LLVM_ABI StringRef FormatString(DwarfFormat Format);
 LLVM_ABI StringRef FormatString(bool IsDWARF64);
 LLVM_ABI StringRef RLEString(unsigned RLE);
 LLVM_ABI StringRef MemorySpaceString(unsigned MS);
-LLVM_ABI StringRef AddressSpaceString(unsigned AS, llvm::Triple TT);
+LLVM_ABI StringRef AddressSpaceString(unsigned AS, const llvm::Triple &TT);
 /// @}
 
 /// \defgroup DwarfConstantsParsing Dwarf constants parsing functions

llvm/include/llvm/Support/AMDGPUAddrSpace.h

@@ -133,6 +133,19 @@ enum : unsigned {
 };
 } // namespace DWARFAS
 
+namespace impl {
+// TODO: Move this into mapToDWARFAddrSpace when we switch to C++23
+// (see https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2647r1.html)
+static constexpr unsigned LLVMToDWARFAddrSpaceMapping[] = {
+    DWARFAS::GENERIC,     //< AMDGPUAS::FLAT_ADDRESS
+    DWARFAS::GLOBAL,      //< AMDGPUAS::GLOBAL_ADDRESS
+    DWARFAS::REGION,      //< AMDGPUAS::REGION_ADDRESS
+    DWARFAS::LOCAL,       //< AMDGPUAS::LOCAL_ADDRESS
+    DWARFAS::GLOBAL,      //< AMDGPUAS::CONSTANT_ADDRESS
+    DWARFAS::PRIVATE_LANE //< AMDGPUAS::PRIVATE_ADDRESS
+};
+} // end namespace impl
+
 /// If @p LLVMAddressSpace has a corresponding DWARF encoding,
 /// return it; otherwise return the sentinel value -1 to indicate
 /// no such mapping exists.
@@ -144,20 +157,12 @@ enum : unsigned {
 ///
 /// Note: This could return std::optional<int> but that would require
 /// an extra #include.
-inline int mapToDWARFAddrSpace(unsigned LLVMAddrSpace) {
-  static constexpr unsigned LLVMToDWARFAddrSpaceMapping[] = {
-      DWARFAS::GENERIC,     //< AMDGPUAS::FLAT_ADDRESS
-      DWARFAS::GLOBAL,      //< AMDGPUAS::GLOBAL_ADDRESS
-      DWARFAS::REGION,      //< AMDGPUAS::REGION_ADDRESS
-      DWARFAS::LOCAL,       //< AMDGPUAS::LOCAL_ADDRESS
-      DWARFAS::GLOBAL,      //< AMDGPUAS::CONSTANT_ADDRESS
-      DWARFAS::PRIVATE_LANE //< AMDGPUAS::PRIVATE_ADDRESS
-  };
-  static constexpr unsigned SizeOfLLVMToDWARFAddrSpaceMapping =
-      sizeof(LLVMToDWARFAddrSpaceMapping) /
-      sizeof(LLVMToDWARFAddrSpaceMapping[0]);
+constexpr int mapToDWARFAddrSpace(unsigned LLVMAddrSpace) {
+  constexpr unsigned SizeOfLLVMToDWARFAddrSpaceMapping =
+      sizeof(impl::LLVMToDWARFAddrSpaceMapping) /
+      sizeof(impl::LLVMToDWARFAddrSpaceMapping[0]);
   if (LLVMAddrSpace < SizeOfLLVMToDWARFAddrSpaceMapping)
-    return LLVMToDWARFAddrSpaceMapping[LLVMAddrSpace];
+    return impl::LLVMToDWARFAddrSpaceMapping[LLVMAddrSpace];
   return -1;
 }
 } // end namespace AMDGPU

llvm/lib/BinaryFormat/Dwarf.cpp

@@ -939,7 +939,7 @@ StringRef llvm::dwarf::MemorySpaceString(unsigned MS) {
   }
 }
 
-StringRef llvm::dwarf::AddressSpaceString(unsigned AS, llvm::Triple TT) {
+StringRef llvm::dwarf::AddressSpaceString(unsigned AS, const llvm::Triple &TT) {
   switch (AS) {
 #define HANDLE_DW_ASPACE(ID, NAME)                                             \
   case DW_ASPACE_LLVM_##NAME:                                                  \

llvm/lib/DebugInfo/DWARF/DWARFExpressionPrinter.cpp

@@ -67,10 +67,8 @@ static bool printOp(const DWARFExpression::Operation *Op, raw_ostream &OS,
         (Op->getCode() >= DW_OP_reg0 && Op->getCode() <= DW_OP_reg31) ||
         Op->getCode() == DW_OP_bregx || Op->getCode() == DW_OP_regx ||
         Op->getCode() == DW_OP_regval_type ||
-        Op->getCode() == DW_OP_LLVM_call_frame_entry_reg ||
-        Op->getCode() == DW_OP_LLVM_aspace_bregx ||
-        (SubOpcode && (*SubOpcode == DW_OP_LLVM_call_frame_entry_reg ||
-                       *SubOpcode == DW_OP_LLVM_aspace_bregx))) {
+        SubOpcode == DW_OP_LLVM_call_frame_entry_reg ||
+        SubOpcode == DW_OP_LLVM_aspace_bregx) {
       if (prettyPrintRegisterOp(U, OS, DumpOpts, Op->getCode(),
                                 Op->getRawOperands()))
         return true;
@@ -100,22 +98,20 @@ static bool printOp(const DWARFExpression::Operation *Op, raw_ostream &OS,
     StringRef Name = OperationEncodingString(Op->getCode());
     assert(!Name.empty() && "DW_OP has no name!");
     OS << Name;
-  }
 
-  if (SubOpcode) {
-    StringRef SubName = SubOperationEncodingString(Op->getCode(), *SubOpcode);
-    assert(!SubName.empty() && "DW_OP SubOp has no name!");
-    OS << " " << SubName;
+    if (SubOpcode) {
+      StringRef SubName = SubOperationEncodingString(Op->getCode(), *SubOpcode);
+      assert(!SubName.empty() && "DW_OP SubOp has no name!");
+      OS << ' ' << SubName;
+    }
   }
 
   if ((Op->getCode() >= DW_OP_breg0 && Op->getCode() <= DW_OP_breg31) ||
       (Op->getCode() >= DW_OP_reg0 && Op->getCode() <= DW_OP_reg31) ||
       Op->getCode() == DW_OP_bregx || Op->getCode() == DW_OP_regx ||
       Op->getCode() == DW_OP_regval_type ||
-      Op->getCode() == DW_OP_LLVM_call_frame_entry_reg ||
-      Op->getCode() == DW_OP_LLVM_aspace_bregx ||
-      (SubOpcode && (*SubOpcode == DW_OP_LLVM_call_frame_entry_reg ||
-                     *SubOpcode == DW_OP_LLVM_aspace_bregx)))
+      SubOpcode == DW_OP_LLVM_call_frame_entry_reg ||
+      SubOpcode == DW_OP_LLVM_aspace_bregx)
     if (prettyPrintRegisterOp(U, OS, DumpOpts, Op->getCode(),
                               Op->getRawOperands()))
       return true;
@@ -127,8 +123,8 @@ static bool printOp(const DWARFExpression::Operation *Op, raw_ostream &OS,
       unsigned Signed = Size & DWARFExpression::Operation::SignBit;
 
       if (Size == DWARFExpression::Operation::SizeSubOpLEB) {
-        assert(Operand == 0);
-        assert(SubOpcode);
+        assert(Operand == 0 && "DW_OP SubOp must be the first operand");
+        assert(SubOpcode && "DW_OP SubOp description is inconsistent");
       } else if (Size == DWARFExpression::Operation::BaseTypeRef && U) {
         // For DW_OP_convert the operand may be 0 to indicate that conversion to
         // the generic type should be done. The same holds for
@@ -225,6 +221,19 @@ static bool printCompactDWARFExpr(
         nullptr) {
   SmallVector<PrintedExpr, 4> Stack;
 
+  auto UnknownOpcode = [](raw_ostream &OS, uint8_t Opcode,
+                          std::optional<unsigned> SubOpcode) -> bool {
+    // If we hit an unknown operand, we don't know its effect on the stack,
+    // so bail out on the whole expression.
+    OS << "<unknown op " << dwarf::OperationEncodingString(Opcode) << " ("
+       << (int)Opcode;
+    if (SubOpcode)
+      OS << ") subop " << dwarf::SubOperationEncodingString(Opcode, *SubOpcode)
+         << " (" << *SubOpcode;
+    OS << ")>";
+    return false;
+  };
+
   while (I != E) {
     const DWARFExpression::Operation &Op = *I;
     uint8_t Opcode = Op.getCode();
@@ -277,8 +286,10 @@ static bool printCompactDWARFExpr(
       break;
     }
     case dwarf::DW_OP_LLVM_user: {
-      assert(Op.getSubCode());
-      break;
+      std::optional<unsigned> SubOpcode = Op.getSubCode();
+      if (SubOpcode == dwarf::DW_OP_LLVM_nop)
+        break;
+      return UnknownOpcode(OS, Opcode, SubOpcode);
     }
     default:
       if (Opcode >= dwarf::DW_OP_reg0 && Opcode <= dwarf::DW_OP_reg31) {
@@ -302,11 +313,7 @@ static bool printCompactDWARFExpr(
         if (Offset)
           S << format("%+" PRId64, Offset);
       } else {
-        // If we hit an unknown operand, we don't know its effect on the stack,
-        // so bail out on the whole expression.
-        OS << "<unknown op " << dwarf::OperationEncodingString(Opcode) << " ("
-           << (int)Opcode << ")>";
-        return false;
+        return UnknownOpcode(OS, Opcode, std::nullopt);
       }
       break;
     }
@@ -346,8 +353,8 @@ bool prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS,
     SubOpcode = Operands[OpNum++];
 
   if (Opcode == DW_OP_bregx || Opcode == DW_OP_regx ||
-      Opcode == DW_OP_regval_type ||
-      (SubOpcode && *SubOpcode == DW_OP_LLVM_aspace_bregx))
+      Opcode == DW_OP_regval_type || SubOpcode == DW_OP_LLVM_aspace_bregx ||
+      SubOpcode == DW_OP_LLVM_call_frame_entry_reg)
     DwarfRegNum = Operands[OpNum++];
   else if (Opcode == DW_OP_LLVM_call_frame_entry_reg ||
            (SubOpcode && *SubOpcode == DW_OP_LLVM_call_frame_entry_reg))
@@ -360,9 +367,7 @@ bool prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS,
   auto RegName = DumpOpts.GetNameForDWARFReg(DwarfRegNum, DumpOpts.IsEH);
   if (!RegName.empty()) {
     if ((Opcode >= DW_OP_breg0 && Opcode <= DW_OP_breg31) ||
-        Opcode == DW_OP_bregx ||
-        (Opcode == DW_OP_LLVM_aspace_bregx ||
-         (SubOpcode && *SubOpcode == DW_OP_LLVM_aspace_bregx)))
+        Opcode == DW_OP_bregx || SubOpcode == DW_OP_LLVM_aspace_bregx)
       OS << ' ' << RegName << format("%+" PRId64, Operands[OpNum]);
     else
       OS << ' ' << RegName.data();

llvm/test/tools/llvm-dwarfdump/X86/heterogeneous-user-ops.s

@@ -0,0 +1,31 @@
+# RUN: llvm-mc %s -filetype=obj -triple=i686-pc-linux -o - | llvm-dwarfdump --debug-frame - | FileCheck %s
+
+# CHECK:      .eh_frame contents:
+# CHECK:      FDE
+# CHECK-NEXT: Format: DWARF32
+
+foo:
+ .cfi_startproc
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_form_aspace_address
+ .cfi_escape 0x10, 0x00, 0x02, 0xe9, 0x02
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_push_lane
+ .cfi_escape 0x10, 0x00, 0x02, 0xe9, 0x03
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_offset
+ .cfi_escape 0x10, 0x00, 0x02, 0xe9, 0x04
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_offset_uconst 0x0
+ .cfi_escape 0x10, 0x00, 0x03, 0xe9, 0x05, 0x00
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_bit_offset
+ .cfi_escape 0x10, 0x00, 0x02, 0xe9, 0x06
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_call_frame_entry_reg EAX
+ .cfi_escape 0x10, 0x00, 0x03, 0xe9, 0x07, 0x00
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_undefined
+ .cfi_escape 0x10, 0x00, 0x02, 0xe9, 0x08
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_aspace_bregx EAX+2
+ .cfi_escape 0x10, 0x00, 0x04, 0xe9, 0x09, 0x00, 0x02
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_piece_end
+ .cfi_escape 0x10, 0x00, 0x02, 0xe9, 0x0a
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_extend 0x0 0x0
+ .cfi_escape 0x10, 0x00, 0x04, 0xe9, 0x0b, 0x00, 0x00
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_select_bit_piece 0x0 0x0
+ .cfi_escape 0x10, 0x00, 0x04, 0xe9, 0x0c, 0x00, 0x00
+ .cfi_endproc

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp

@@ -141,3 +141,9 @@ TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_nop_OP_reg) {
 TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_LLVM_nop_OP_reg) {
   TestExprPrinter({DW_OP_LLVM_user, DW_OP_LLVM_nop, DW_OP_reg0}, "R0");
 }
+
+TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_LLVM_user_unknown_subop) {
+  TestExprPrinter({DW_OP_LLVM_user, DW_OP_LLVM_form_aspace_address},
+                  "<unknown op DW_OP_LLVM_user (233) subop "
+                  "DW_OP_LLVM_form_aspace_address (2)>");
+}