[DebugInfo] Add DW_OP_LLVM_user extension point

[scott.linder]

Summary

The extension codespace for DWARF expressions (DW_OP_LLVM_{lo,hi}_user)
has shrunk over time, as no extension is ever "retired" in practice. To
facilitate future extensions, this patch reserves one open opcode as an extension
point (0xfe), which is followed by a ULEB128-encoded SubOperation, and
then by the subop's operands.

There is some prior-art, namely DW_OP_AARCH64_operation
(see https://github.com/ARM-software/abi-aa/blob/edd7460d87493fff124b8b5713acf71ffc06ee91/aadwarf64/aadwarf64.rst#45dwarf-expression-operations).

This version makes some different tradeoffs, opting to use a ULEB128 for
the subop encoding for future-proofing.

[scott.linder]

I've also submitted a proposal for a standard version of the operation (thread at https://lists.dwarfstd.org/pipermail/dwarf-discuss/2023-March/002199.html)

[dblaikie]

Would it make sense to remap the the sub-kinds into a bigger contiguous kind in the LLVM implementation? (I'm not sure, but curious - but probably not?)

llvm/include/llvm/BinaryFormat/Dwarf.def

893

Why is zero reserved? (other than to add a the nop op, so there's something to test before we have any USEROPs implemented?)

llvm/lib/BinaryFormat/Dwarf.cpp

175–208

Hmm, any chance we could condense these into a bigger macro (maybe another .def file) that stamps out all these operations, since we have to stamp these out for each kind of enum?)

[scott.linder]

llvm/include/llvm/BinaryFormat/Dwarf.def

893

It was because the encoding for official operations in DWARF completely skips over byte "0", i.e. Table 7.9 in https://dwarfstd.org/doc/DWARF5.pdf begins:

Table 7.9: DWARF operation encodings

Operation	No. of Operands	Operation Code	Notes
Reserved	0x01	-
Reserved	0x02	-
DW_OP_addr	0x03	1	constant address (size is target specific)

I don't see a particular reason to skip it, but there is also very little lost. I even considered reserving all of the 1-byte encodings, just so there is less of a "early users get a more compact encoding" effect.

I am also fine with just using 0 for the nop operation

llvm/lib/BinaryFormat/Dwarf.cpp

175–208

I'm not sure I understand what you mean; do you mean an improvement over the existing support that could land as NFC before my changes?

[dblaikie]

Seems OK to me - wouldn't mind a second set of eyes. @jmorse @aprantl

llvm/include/llvm/BinaryFormat/Dwarf.def

893

Ah, fair enough - yeah - maybe using zero would be nice then?

llvm/lib/BinaryFormat/Dwarf.cpp

175–208

Yep - though I'm not sure it's possible (macro can't have #include in it, I guess, so not sure - oh, maybe it'd be another .def file... which takes, via macro definitions, the various name spellings, and then stamps out the lookup/string/etc functions)

[aprantl]

Yeah, conceptually this seems fine to me. We already missed the opportunity to make the OPs ULEBs long ago....

llvm/include/llvm/BinaryFormat/Dwarf.h

#include "llvm/BinaryFormat/Dwarf.def"
   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_implicit_pointer = 0x1004, ///< Only used in LLVM metadata.
   DW_OP_LLVM_arg = 0x1005,              ///< Only used in LLVM metadata.
 };
 
+enum LlvmUserLocationAtom {
+#define HANDLE_DW_OP_LLVM_USEROP(ID, NAME) DW_OP_LLVM_##NAME = ID,
+#include "llvm/BinaryFormat/Dwarf.def"
+};
+
 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
 };
 
 enum DecimalSignEncoding {

 /// isn't known.
 ///
 /// @{
 StringRef TagString(unsigned Tag);
 StringRef ChildrenString(unsigned Children);
 StringRef AttributeString(unsigned Attribute);
 StringRef FormEncodingString(unsigned Encoding);
 StringRef OperationEncodingString(unsigned Encoding);
+StringRef SubOperationEncodingString(unsigned OpEncoding,
+                                     unsigned SubOpEncoding);
 StringRef AttributeEncodingString(unsigned Encoding);
 StringRef DecimalSignString(unsigned Sign);
 StringRef EndianityString(unsigned Endian);
 StringRef AccessibilityString(unsigned Access);
 StringRef DefaultedMemberString(unsigned DefaultedEncodings);
 StringRef VisibilityString(unsigned Visibility);
 StringRef VirtualityString(unsigned Virtuality);
 StringRef LanguageString(unsigned Language);

 ///
 /// \li \a getTag() returns \a DW_TAG_invalid on invalid input.
 /// \li \a getVirtuality() returns \a DW_VIRTUALITY_invalid on invalid input.
 /// \li \a getMacinfo() returns \a DW_MACINFO_invalid on invalid input.
 ///
 /// @{
 unsigned getTag(StringRef TagString);
 unsigned getOperationEncoding(StringRef OperationEncodingString);
+unsigned getSubOperationEncoding(unsigned OpEncoding,
+                                 StringRef SubOperationEncodingString);
 unsigned getVirtuality(StringRef VirtualityString);
 unsigned getLanguage(StringRef LanguageString);
 unsigned getCallingConvention(StringRef LanguageString);
 unsigned getAttributeEncoding(StringRef EncodingString);
 unsigned getMacinfo(StringRef MacinfoString);
 unsigned getMacro(StringRef MacroString);
 /// @}
 

llvm/include/llvm/BinaryFormat/Dwarf.def

 //===- llvm/Support/Dwarf.def - Dwarf definitions ---------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // Macros for running through Dwarf enumerators.
 //
 //===----------------------------------------------------------------------===//
 
 // TODO: Add other DW-based macros.
 #if !(                                                                         \
     defined HANDLE_DW_TAG || defined HANDLE_DW_AT || defined HANDLE_DW_FORM || \
-    defined HANDLE_DW_OP || defined HANDLE_DW_LANG || defined HANDLE_DW_ATE || \
+    defined HANDLE_DW_OP || defined HANDLE_DW_OP_LLVM_USEROP ||                    \
+    defined HANDLE_DW_LANG || defined HANDLE_DW_ATE ||                         \
     defined HANDLE_DW_VIRTUALITY || defined HANDLE_DW_DEFAULTED ||             \
     defined HANDLE_DW_CC || defined HANDLE_DW_LNS || defined HANDLE_DW_LNE ||  \
     defined HANDLE_DW_LNCT || defined HANDLE_DW_MACRO ||                       \
     defined HANDLE_DW_MACRO_GNU || defined HANDLE_MACRO_FLAG ||                \
     defined HANDLE_DW_RLE || defined HANDLE_DW_LLE ||                          \
     (defined HANDLE_DW_CFA && defined HANDLE_DW_CFA_PRED) ||                   \
     defined HANDLE_DW_APPLE_PROPERTY || defined HANDLE_DW_UT ||                \
     defined HANDLE_DWARF_SECTION || defined HANDLE_DW_IDX ||                   \

 #ifndef HANDLE_DW_FORM
 #define HANDLE_DW_FORM(ID, NAME, VERSION, VENDOR)
 #endif
 
 #ifndef HANDLE_DW_OP
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)
 #endif
 
+#ifndef HANDLE_DW_OP_LLVM_USEROP
+#define HANDLE_DW_OP_LLVM_USEROP(ID, NAME)
+#endif
+
 #ifndef HANDLE_DW_LANG
 #define HANDLE_DW_LANG(ID, NAME, LOWER_BOUND, VERSION, VENDOR)
 #endif
 
 #ifndef HANDLE_DW_ATE
 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR)
 #endif
 

 HANDLE_DW_OP(0xf0, APPLE_uninit, 0, APPLE)
 // The GNU entry value extension.
 HANDLE_DW_OP(0xf3, GNU_entry_value, 0, GNU)
 HANDLE_DW_OP(0xf8, PGI_omp_thread_num, 0, PGI)
 // Extensions for Fission proposal.
 HANDLE_DW_OP(0xfb, GNU_addr_index, 0, GNU)
 HANDLE_DW_OP(0xfc, GNU_const_index, 0, GNU)
 
+// DW_OP_LLVM_user has two operands:
+//   (1) An unsigned LEB128 "LLVM Vendor Extension Opcode".
+//   (2) Zero or more literal operands, the number and type of which are
+//       implied by the opcode (1).
+// DW_OP_LLVM_user acts as an extension multiplexer, opening up the encoding
+// space to accommodate an infinite number of extensions. This better reflects
+// the de-facto permanent allocation of extensions.
+HANDLE_DW_OP(0xe9, LLVM_user, 0, LLVM)
+// "LLVM Vendor Extension" operations under the DW_OP_LLVM_user encoding
+// scheme. This list is authoritative and exhaustive. Once an operation is
+// registered here it cannot be removed nor have its encoding changed. The
+// encoding space must skip zero (which is reserved) and have no gaps.
+//
+// The DW_OP_LLVM_user DW_OP_LLVM_nop operation has no effect on the
+// location stack or any of its values. It is defined as a placeholder for
+// testing purposes.
+HANDLE_DW_OP_LLVM_USEROP(0x0001, nop)
+
 // DWARF languages.
 HANDLE_DW_LANG(0x0001, C89, 0, 2, DWARF)
 HANDLE_DW_LANG(0x0002, C, 0, 2, DWARF)
 HANDLE_DW_LANG(0x0003, Ada83, 1, 2, DWARF)
 HANDLE_DW_LANG(0x0004, C_plus_plus, 0, 2, DWARF)
 HANDLE_DW_LANG(0x0005, Cobol74, 1, 2, DWARF)
 HANDLE_DW_LANG(0x0006, Cobol85, 1, 2, DWARF)
 HANDLE_DW_LANG(0x0007, Fortran77, 1, 2, DWARF)

 HANDLE_DW_SECT(6, STR_OFFSETS)
 HANDLE_DW_SECT(7, MACRO)
 HANDLE_DW_SECT(8, RNGLISTS)
 
 #undef HANDLE_DW_TAG
 #undef HANDLE_DW_AT
 #undef HANDLE_DW_FORM
 #undef HANDLE_DW_OP
+#undef HANDLE_DW_OP_LLVM_USEROP
 #undef HANDLE_DW_LANG
 #undef HANDLE_DW_ATE
 #undef HANDLE_DW_VIRTUALITY
 #undef HANDLE_DW_DEFAULTED
 #undef HANDLE_DW_CC
 #undef HANDLE_DW_LNS
 #undef HANDLE_DW_LNE
 #undef HANDLE_DW_LNCT

llvm/include/llvm/DebugInfo/DWARF/DWARFExpression.h

enum Encoding : uint8_t {
       Size2 = 1,
       Size4 = 2,
       Size8 = 3,
       SizeLEB = 4,
       SizeAddr = 5,
       SizeRefAddr = 6,
       SizeBlock = 7, ///< Preceding operand contains block size
       BaseTypeRef = 8,
+      /// The operand is a ULEB128 encoded SubOpcode. This is only valid
+      /// for the first operand of an operation.
+      SizeSubOpLEB = 9,
       WasmLocationArg = 30,
       SignBit = 0x80,
       SignedSize1 = SignBit | Size1,
       SignedSize2 = SignBit | Size2,
       SignedSize4 = SignBit | Size4,
       SignedSize8 = SignBit | Size8,
       SignedSizeLEB = SignBit | SizeLEB,
       SizeNA = 0xFF ///< Unused operands get this encoding.
private:
     bool Error = false;
     uint64_t EndOffset;
     uint64_t Operands[MaxOperands];
     uint64_t OperandEndOffsets[MaxOperands];
 
   public:
     const Description &getDescription() const { return Desc; }
     uint8_t getCode() const { return Opcode; }
+    std::optional<unsigned> getSubCode() const;
     uint64_t getRawOperand(unsigned Idx) const { return Operands[Idx]; }
     uint64_t getOperandEndOffset(unsigned Idx) const {
       return OperandEndOffsets[Idx];
     }
     uint64_t getEndOffset() const { return EndOffset; }
     bool isError() const { return Error; }
     bool print(raw_ostream &OS, DIDumpOptions DumpOpts,
                const DWARFExpression *Expr, DWARFUnit *U) const;

llvm/lib/BinaryFormat/Dwarf.cpp

#include "llvm/BinaryFormat/Dwarf.def"
       .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_implicit_pointer", DW_OP_LLVM_implicit_pointer)
       .Case("DW_OP_LLVM_arg", DW_OP_LLVM_arg)
       .Default(0);
 }
 
+static StringRef LlvmUserOperationEncodingString(unsigned Encoding) {
+  switch (Encoding) {
+  default:
+    llvm_unreachable("unhandled DWARF operation with LLVM user op");
+#define HANDLE_DW_OP_LLVM_USEROP(ID, NAME)                                     \
+  case DW_OP_LLVM_##NAME:                                                      \
+    return "DW_OP_LLVM_" #NAME;
+#include "llvm/BinaryFormat/Dwarf.def"
+  }
+}
+
+static unsigned
+getLlvmUserOperationEncoding(StringRef LlvmUserOperationEncodingString) {
+  unsigned E = StringSwitch<unsigned>(LlvmUserOperationEncodingString)
+#define HANDLE_DW_OP_LLVM_USEROP(ID, NAME) .Case(#NAME, DW_OP_LLVM_##NAME)
+#include "llvm/BinaryFormat/Dwarf.def"
+                   .Default(0);
+  assert(E && "unhandled DWARF operation string with LLVM user op");
+  return E;
+}
+
+StringRef llvm::dwarf::SubOperationEncodingString(unsigned OpEncoding,
+                                                  unsigned SubOpEncoding) {
+  assert(OpEncoding == DW_OP_LLVM_user);
+  return LlvmUserOperationEncodingString(SubOpEncoding);
+}
+
+unsigned
+llvm::dwarf::getSubOperationEncoding(unsigned OpEncoding,
+                                     StringRef SubOperationEncodingString) {
+  assert(OpEncoding == DW_OP_LLVM_user);
+  return getLlvmUserOperationEncoding(SubOperationEncodingString);
+}
+
 unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
   switch (Op) {
   default:
     return 0;
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
   case DW_OP_##NAME:                                                           \
     return VERSION;
 #include "llvm/BinaryFormat/Dwarf.def"

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

DWARFDataExtractor Data(StringRef(DebugLocs.getBytes(Entry).data(),
                           Asm->getDataLayout().isLittleEndian(), PtrSize);
   DWARFExpression Expr(Data, PtrSize, Asm->OutContext.getDwarfFormat());
 
   using Encoding = DWARFExpression::Operation::Encoding;
   uint64_t Offset = 0;
   for (const auto &Op : Expr) {
     assert(Op.getCode() != dwarf::DW_OP_const_type &&
            "3 operand ops not yet supported");
+    assert(!Op.getSubCode() && "SubOps not yet supported");
     Streamer.emitInt8(Op.getCode(), Comment != End ? *(Comment++) : "");
     Offset++;
     for (unsigned I = 0; I < DWARFExpression::Operation::MaxOperands; ++I) {
       if (Op.getDescription().Op[I] == Encoding::SizeNA)
         continue;
       if (Op.getDescription().Op[I] == Encoding::BaseTypeRef) {
         unsigned Length =
           Streamer.emitDIERef(*CU->ExprRefedBaseTypes[Op.getRawOperand(I)].Die);

llvm/lib/DWARFLinker/DWARFLinker.cpp

for (auto &Op : Expression) {
     if ((Op0 == Encoding::BaseTypeRef && Op1 == Encoding::SizeNA) ||
         (Op1 == Encoding::BaseTypeRef && Op0 == Encoding::Size1)) {
       // This code assumes that the other non-typeref operand fits into 1 byte.
       assert(OpOffset < Op.getEndOffset());
       uint32_t ULEBsize = Op.getEndOffset() - OpOffset - 1;
       assert(ULEBsize <= 16);
 
       // Copy over the operation.
+      assert(!Op.getSubCode() && "SubOps not yet supported");
       OutputBuffer.push_back(Op.getCode());
       uint64_t RefOffset;
       if (Op1 == Encoding::SizeNA) {
         RefOffset = Op.getRawOperand(0);
       } else {
         OutputBuffer.push_back(Op.getRawOperand(0));
         RefOffset = Op.getRawOperand(1);
       }

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

static constexpr auto Descriptions = []() {
     Descriptions[DW_OP_addrx] = Desc(Op::Dwarf4, Op::SizeLEB);
     Descriptions[DW_OP_GNU_addr_index] = Desc(Op::Dwarf4, Op::SizeLEB);
     Descriptions[DW_OP_GNU_const_index] = Desc(Op::Dwarf4, Op::SizeLEB);
     Descriptions[DW_OP_GNU_entry_value] = Desc(Op::Dwarf4, Op::SizeLEB);
     Descriptions[DW_OP_convert] = Desc(Op::Dwarf5, Op::BaseTypeRef);
     Descriptions[DW_OP_entry_value] = Desc(Op::Dwarf5, Op::SizeLEB);
     Descriptions[DW_OP_regval_type] =
         Desc(Op::Dwarf5, Op::SizeLEB, Op::BaseTypeRef);
+    // This Description acts as a marker that getSubOpDesc must be called
+    // to fetch the final Description for the operation. Each such final
+    // Description must share the same first SizeSubOpLEB operand.
+    Descriptions[DW_OP_LLVM_user] = Desc(Op::Dwarf5, Op::SizeSubOpLEB);
     return Descriptions;
   }();
   return getOpDescImpl(Descriptions, Opcode);
 }
 
+static Desc getSubOpDesc(unsigned Opcode, unsigned SubOpcode) {
+  static constexpr unsigned LlvmUserDescriptionsSize = 1
+#define HANDLE_DW_OP_LLVM_USEROP(ID, NAME) +1
+#include "llvm/BinaryFormat/Dwarf.def"
+      ;
+  static constexpr auto LlvmUserDescriptions = []() {
+    std::array<Desc, LlvmUserDescriptionsSize> Descriptions;
+    Descriptions[DW_OP_LLVM_nop] = Desc(Op::Dwarf5, Op::SizeSubOpLEB);
+    return Descriptions;
+  }();
+  assert(Opcode == DW_OP_LLVM_user);
+  return getOpDescImpl(LlvmUserDescriptions, SubOpcode);
+}
+
 bool DWARFExpression::Operation::extract(DataExtractor Data,
                                          uint8_t AddressSize, uint64_t Offset,
                                          std::optional<DwarfFormat> Format) {
   EndOffset = Offset;
   Opcode = Data.getU8(&Offset);
 
   Desc = getOpDesc(Opcode);
   if (Desc.Version == Operation::DwarfNA)
     return false;
 
   for (unsigned Operand = 0; Operand < MaxOperands; ++Operand) {
     unsigned Size = Desc.Op[Operand];
     unsigned Signed = Size & Operation::SignBit;
 
     if (Size == Operation::SizeNA)
       break;
 
     switch (Size & ~Operation::SignBit) {
+    case Operation::SizeSubOpLEB:
+      assert(Operand == 0 && "SubOp operand must be the first operand");
+      Operands[Operand] = Data.getULEB128(&Offset);
+      Desc = getSubOpDesc(Opcode, Operands[Operand]);
+      if (Desc.Version == Operation::DwarfNA)
+        return false;
+      assert(Desc.Op[Operand] == Operation::SizeSubOpLEB &&
+             "SizeSubOpLEB Description must begin with SizeSubOpLEB operand");
+      break;
     case Operation::Size1:
       Operands[Operand] = Data.getU8(&Offset);
       if (Signed)
         Operands[Operand] = (int8_t)Operands[Operand];
       break;
     case Operation::Size2:
       Operands[Operand] = Data.getU16(&Offset);
       if (Signed)
if (!RegName.empty()) {
     if (Opcode == DW_OP_regval_type)
       prettyPrintBaseTypeRef(U, OS, DumpOpts, Operands, 1);
     return true;
   }
 
   return false;
 }
 
+std::optional<unsigned> DWARFExpression::Operation::getSubCode() const {
+  if (Desc.Op[0] != Operation::SizeSubOpLEB)
+    return std::nullopt;
+  return Operands[0];
+}
+
 bool DWARFExpression::Operation::print(raw_ostream &OS, DIDumpOptions DumpOpts,
                                        const DWARFExpression *Expr,
                                        DWARFUnit *U) const {
   if (Error) {
     OS << "<decoding error>";
     return false;
   }
 
bool DWARFExpression::Operation::print(raw_ostream &OS, DIDumpOptions DumpOpts,
 
   for (unsigned Operand = 0; Operand < MaxOperands; ++Operand) {
     unsigned Size = Desc.Op[Operand];
     unsigned Signed = Size & Operation::SignBit;
 
     if (Size == Operation::SizeNA)
       break;
 
-    if (Size == Operation::BaseTypeRef && U) {
+    if (Size == Operation::SizeSubOpLEB) {
+      StringRef SubName = SubOperationEncodingString(Opcode, Operands[Operand]);
+      assert(!SubName.empty() && "DW_OP SubOp has no name!");
+      OS << " " << SubName;
+    } else if (Size == 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 DW_OP_reinterpret,
       // which is currently not supported.
       if (Opcode == DW_OP_convert && Operands[Operand] == 0)
         OS << " 0x0";
       else
         prettyPrintBaseTypeRef(U, OS, DumpOpts, Operands, Operand);
     } else if (Size == Operation::WasmLocationArg) {
case dwarf::DW_OP_stack_value: {
       // variable, rather than the address of the variable in memory.
       assert(!Stack.empty());
       Stack.back().Kind = PrintedExpr::Value;
       break;
     }
     case dwarf::DW_OP_nop: {
       break;
     }
+    case dwarf::DW_OP_LLVM_user: {
+      assert(Op.getSubCode() && *Op.getSubCode() == dwarf::DW_OP_LLVM_nop);
+      break;
+    }
     default:
       if (Opcode >= dwarf::DW_OP_reg0 && Opcode <= dwarf::DW_OP_reg31) {
         // DW_OP_reg<N>: A register, with the register num implied by the
         // opcode. Printed as the plain register name.
         uint64_t DwarfRegNum = Opcode - dwarf::DW_OP_reg0;
         auto RegName = GetNameForDWARFReg(DwarfRegNum, false);
         if (RegName.empty())
           return false;

llvm/lib/DebugInfo/LogicalView/Readers/LVELFReader.cpp

auto ProcessLocationExpression = [&](const DWARFExpression &Expression) {
     for (const DWARFExpression::Operation &Op : Expression) {
       DWARFExpression::Operation::Description Description = Op.getDescription();
       for (unsigned Operand = 0;
            Operand < DWARFExpression::Operation::MaxOperands; ++Operand) {
         if (Description.Op[Operand] == DWARFExpression::Operation::SizeNA)
           break;
         Operands[Operand] = Op.getRawOperand(Operand);
       }
+      assert(!Op.getSubCode() && "SubOps not yet supported");
       CurrentSymbol->addLocationOperands(Op.getCode(), Operands);
     }
   };
 
   DWARFUnit *U = Die.getDwarfUnit();
   DWARFContext &DwarfContext = U->getContext();
   bool IsLittleEndian = DwarfContext.isLittleEndian();
   if (FormValue.isFormClass(DWARFFormValue::FC_Block) ||

llvm/test/tools/llvm-dwarfdump/X86/DW_OP_LLVM_user.s

+# RUN: llvm-mc %s -filetype=obj -triple=i686-pc-linux -o %t
+# RUN: llvm-dwarfdump -v %t | FileCheck %s
+
+# FIXME: Is there a better approach than using `DW_CFA_expression EAX <op>`?
+
+# CHECK:      .eh_frame contents:
+# CHECK:      FDE
+# CHECK-NEXT: Format: DWARF32
+
+foo:
+ .cfi_startproc
+ # CHECK-NEXT: DW_CFA_expression: EAX <decoding error> e9 00
+ .cfi_escape 0x10, 0x00, 0x02, 0xe9, 0x00
+ # CHECK-NEXT: DW_CFA_expression: EAX DW_OP_LLVM_user DW_OP_LLVM_nop
+ .cfi_escape 0x10, 0x00, 0x02, 0xe9, 0x01
+ .cfi_endproc

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp

TestExprPrinter(
       {DW_OP_entry_value, 0x02, DW_OP_breg13, 0x10, DW_OP_stack_value},
       "entry([SP+16])");
 }
 
 TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_nop) {
   TestExprPrinter({DW_OP_nop}, "<stack of size 0, expected 1>");
 }
 
+TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_LLVM_nop) {
+  TestExprPrinter({DW_OP_LLVM_user, DW_OP_LLVM_nop},
+                  "<stack of size 0, expected 1>");
+}
+
 TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_nop_OP_reg) {
   TestExprPrinter({DW_OP_nop, DW_OP_reg0}, "R0");
 }
+
+TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_LLVM_nop_OP_reg) {
+  TestExprPrinter({DW_OP_LLVM_user, DW_OP_LLVM_nop, DW_OP_reg0}, "R0");
+}