[DebugInfo] Support more than 2 operands in DWARF operations

[scott.linder]

Summary

Update DWARFExpression::Operation and LVOperation to support more than
2 operands.

Take the opportunity to use a SmallVector, which will handle at least 2
operands without allocation anyway, and removes the static limit
completely.

As there is no longer the concept of an "unused operand", remove
Operation::Encoding::SizeNA. Any use of it is now replaced with explicit
checks for how many operands an operation has.

There are still places where the limit remains 2, namely in the
DWARFLinker and in DIExpressions, but these can be updated in later
patches as-needed.

There are no explicit tests as this is nearly NFC: no new operation is
added which makes use of the additional operand capacity yet. A future
patch adding a new DWARF extension point will include operations which
require the support.

[Orlando]

LGTM

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

69

Possibly worth adding a short comment along the lines of "Fill Op with Ops then Is.size() number of SizeNA entries". YMMV, maybe it's obvious, but it took me a minute to work out what was going on here.

[dblaikie]

Got any measurements of memory usage? (seems like this'd increase memory usage? Maybe try a self-host release build (optimizations causing more interesting locations and so more location operations) & see how peak memory usage in various compilation changes?)

[scott.linder]

In D147270#4241303, @dblaikie wrote:

Got any measurements of memory usage? (seems like this'd increase memory usage? Maybe try a self-host release build (optimizations causing more interesting locations and so more location operations) & see how peak memory usage in various compilation changes?)

I will run the tests you suggest and report back; I didn't initially because there are already 3-operand operations, and hence for completeness we will have to change at some point. The only remaining question in my mind is the approach to support it: either statically sized and compile-time evaluated (i.e. DWARFExpression::Operation) or dynamically sized (i.e. LVOperation). I will try to measure which approach better balances LLVM compile time, artifact size, compile time, etc.

[scott.linder]

Now that we are no longer contrained by constexpr, just use
SmallVector for everything.

Running 3 trials comparing release/llvm-dwarfdump rel-with-deb-info/llc
between this patch and trunk:

<stat>: <control> <patched> (<patched>/<control>)
instructions:u: 2053361427267 2053074326681 (0.999860)
Maximum resident set size: 5385686 5384477 (0.999776)
branches: 207788977127 208106839029 (1.001530)
branch-misses: 2480119693 2785843401 (1.123270)
User time: 254.363333 265.583333 (1.044110)

I haven't benchmarked LogicalView, but I suspect it should be similar.

[CarlosAlbertoEnciso]

@scott.linder: Sorry for my delay. As pointed out by @dblaikie, it would be interesting to see the memory usage, specially for the logical view. Thanks.

[scott.linder]

In D147270#4304833, @CarlosAlbertoEnciso wrote:

@scott.linder: Sorry for my delay. As pointed out by @dblaikie, it would be interesting to see the memory usage, specially for the logical view. Thanks.

Thank you for taking a look!

Is there a good target you have in mind for the benchmark? I seem to hit an assertion when dogfooding RelWithDebInfo binaries:

$ git log --oneline | head -1
0dec49cb3466 [mlir][vector] Remove unused variable `srcShape`.

$ build/bin/llvm-debuginfo-analyzer --print=symbols build-relwithdebinfo/bin/llvm-tblgen
llvm-debuginfo-analyzer: /home/slinder1/llvm-project/main/llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h:102: virtual v
oid llvm::logicalview::LVSymbol::setReference(llvm::logicalview::LVElement *): Assertion `(!Element || isa<LVSymbol>(Element)) &
& "Invalid element"' failed.
PLEASE submit a bug report to https://github.com/llvm/llvm-project/issues/ and include the crash backtrace.
Stack dump:
0.      Program arguments: build/bin/llvm-debuginfo-analyzer --print=symbols build-relwithdebinfo/bin/llvm-tblgen
 #0 0x0000000001ab6017 llvm::sys::PrintStackTrace(llvm::raw_ostream&, int) (build/bin/llvm-debuginfo-analyzer+0x1ab6017)
 #1 0x0000000001ab3dee llvm::sys::RunSignalHandlers() (build/bin/llvm-debuginfo-analyzer+0x1ab3dee)
 #2 0x0000000001ab668f SignalHandler(int) Signals.cpp:0:0
 #3 0x00007f9a91add420 __restore_rt (/lib/x86_64-linux-gnu/libpthread.so.0+0x14420)
 #4 0x00007f9a9136e00b raise /build/glibc-SzIz7B/glibc-2.31/signal/../sysdeps/unix/sysv/linux/raise.c:51:1
 #5 0x00007f9a9134d859 abort /build/glibc-SzIz7B/glibc-2.31/stdlib/abort.c:81:7
 #6 0x00007f9a9134d729 get_sysdep_segment_value /build/glibc-SzIz7B/glibc-2.31/intl/loadmsgcat.c:509:8
 #7 0x00007f9a9134d729 _nl_load_domain /build/glibc-SzIz7B/glibc-2.31/intl/loadmsgcat.c:970:34
 #8 0x00007f9a9135efd6 (/lib/x86_64-linux-gnu/libc.so.6+0x33fd6)
 #9 0x000000000189be81 llvm::logicalview::LVSymbol::setReference(llvm::logicalview::LVElement*) LVSymbol.cpp:0:0
#10 0x000000000191c9ee llvm::logicalview::LVELFReader::processOneDie(llvm::DWARFDie const&, llvm::logicalview::LVScope*, llvm::D
WARFDie&) (build/bin/llvm-debuginfo-analyzer+0x191c9ee)
#11 0x000000000191d6c9 llvm::logicalview::LVELFReader::traverseDieAndChildren(llvm::DWARFDie&, llvm::logicalview::LVScope*, llvm
::DWARFDie&) (build/bin/llvm-debuginfo-analyzer+0x191d6c9)
#12 0x000000000191d741 llvm::logicalview::LVELFReader::traverseDieAndChildren(llvm::DWARFDie&, llvm::logicalview::LVScope*, llvm
::DWARFDie&) (build/bin/llvm-debuginfo-analyzer+0x191d741)
#13 0x000000000191ef75 llvm::logicalview::LVELFReader::createScopes() (build/bin/llvm-debuginfo-analyzer+0x191ef75)
#14 0x000000000186507d llvm::logicalview::LVReader::doLoad() (build/bin/llvm-debuginfo-analyzer+0x186507d)
#15 0x00000000018a2768 llvm::logicalview::LVReaderHandler::createReader(llvm::StringRef, std::vector<std::unique_ptr<llvm::logic
alview::LVReader, std::default_delete<llvm::logicalview::LVReader>>, std::allocator<std::unique_ptr<llvm::logicalview::LVReader,
 std::default_delete<llvm::logicalview::LVReader>>>>&, llvm::PointerUnion<llvm::object::ObjectFile*, llvm::pdb::PDBFile*>&, llvm
::StringRef, llvm::StringRef) (build/bin/llvm-debuginfo-analyzer+0x18a2768)
#16 0x00000000018a505d llvm::logicalview::LVReaderHandler::handleObject(std::vector<std::unique_ptr<llvm::logicalview::LVReader,
 std::default_delete<llvm::logicalview::LVReader>>, std::allocator<std::unique_ptr<llvm::logicalview::LVReader, std::default_del
ete<llvm::logicalview::LVReader>>>>&, llvm::StringRef, llvm::object::Binary&) (build/bin/llvm-debuginfo-analyzer+0x18a505d)
#17 0x00000000018a4046 llvm::logicalview::LVReaderHandler::handleBuffer(std::vector<std::unique_ptr<llvm::logicalview::LVReader,
 std::default_delete<llvm::logicalview::LVReader>>, std::allocator<std::unique_ptr<llvm::logicalview::LVReader, std::default_del
ete<llvm::logicalview::LVReader>>>>&, llvm::StringRef, llvm::MemoryBufferRef, llvm::StringRef) (build/bin/llvm-debuginfo-analyze
r+0x18a4046)
#18 0x00000000018a4de5 llvm::logicalview::LVReaderHandler::handleFile(std::vector<std::unique_ptr<llvm::logicalview::LVReader, s
td::default_delete<llvm::logicalview::LVReader>>, std::allocator<std::unique_ptr<llvm::logicalview::LVReader, std::default_delet
e<llvm::logicalview::LVReader>>>>&, llvm::StringRef, llvm::StringRef) (build/bin/llvm-debuginfo-analyzer+0x18a4de5)
#19 0x00000000018a1fa7 llvm::logicalview::LVReaderHandler::createReaders() (build/bin/llvm-debuginfo-analyzer+0x18a1fa7)
#20 0x00000000018a1e2f llvm::logicalview::LVReaderHandler::process() (build/bin/llvm-debuginfo-analyzer+0x18a1e2f)
#21 0x0000000001441730 main (build/bin/llvm-debuginfo-analyzer+0x1441730)
#22 0x00007f9a9134f083 __libc_start_main /build/glibc-SzIz7B/glibc-2.31/csu/../csu/libc-start.c:342:3
#23 0x0000000001440bce _start (build/bin/llvm-debuginfo-analyzer+0x1440bce)
Aborted (core dumped)

I've also tried llc, clang, and llvm-debuginfo-analyzer itself, all hit the same assert. Is there something I might be doing wrong on my end?

[CarlosAlbertoEnciso]

In D147270#4327735, @scott.linder wrote:

Is there a good target you have in mind for the benchmark? I seem to hit an assertion when dogfooding RelWithDebInfo binaries:

$ build/bin/llvm-debuginfo-analyzer --print=symbols build-relwithdebinfo/bin/llvm-tblgen
llvm-debuginfo-analyzer: /home/slinder1/llvm-project/main/llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h:102: virtual v
oid llvm::logicalview::LVSymbol::setReference(llvm::logicalview::LVElement *): Assertion `(!Element || isa<LVSymbol>(Element)) &
& "Invalid element"' failed.

I've also tried `llc`, `clang`, and `llvm-debuginfo-analyzer` itself, all hit the same assert. Is there something I might be doing wrong on my end?

Sorry for my delay in answering but I was at the LLVM Euro 2023. Your command line is correct.

At Sony, we have managed to reproduce the same issue with a debug/checking build on a private project.

[scott.linder]

In D147270#4337447, @CarlosAlbertoEnciso wrote:

In D147270#4327735, @scott.linder wrote:

Is there a good target you have in mind for the benchmark? I seem to hit an assertion when dogfooding RelWithDebInfo binaries:

$ build/bin/llvm-debuginfo-analyzer --print=symbols build-relwithdebinfo/bin/llvm-tblgen
llvm-debuginfo-analyzer: /home/slinder1/llvm-project/main/llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h:102: virtual v
oid llvm::logicalview::LVSymbol::setReference(llvm::logicalview::LVElement *): Assertion `(!Element || isa<LVSymbol>(Element)) &
& "Invalid element"' failed.

I've also tried `llc`, `clang`, and `llvm-debuginfo-analyzer` itself, all hit the same assert. Is there something I might be doing wrong on my end?

Sorry for my delay in answering but I was at the LLVM Euro 2023. Your command line is correct.

At Sony, we have managed to reproduce the same issue with a debug/checking build on a private project.

Thank you for confirming!

I did a little digging and it seems like there is a faulty assumption in LVELFReader:

// We are assuming that DW_AT_specification, DW_AT_abstract_origin,
// DW_AT_type and DW_AT_extension do not appear at the same time
// in the same DIE.

This seems true for GCC, but not for Clang, at least for the simplest reproducer I could create:

$ cat a.cpp
struct S {
    static const int Arr[];
};
const int S::Arr[] = {
    0, 1, 2
};
$ gcc -g -c a.cpp -o a.o
$ build/bin/llvm-dwarfdump --debug-info a.o | grep -B1 -A2 DW_AT_specification
0x00000053:   DW_TAG_variable
                DW_AT_specification     (0x00000028 "Arr")
                DW_AT_decl_line (4)
                DW_AT_decl_column       (0x0b)
$ clang++ -g -c a.cpp -o a.o
$ build/bin/llvm-dwarfdump --debug-info a.o | grep -B1 -A2 DW_AT_specification
0x0000001e:   DW_TAG_variable
                DW_AT_specification     (0x0000003e "Arr")
                DW_AT_type      (0x00000068 "const int[3]")
                DW_AT_location  (DW_OP_addr 0x0)

It seems like the code could be adapted to track these independently, rather than assume only one is present? I can prepare a patch if that sounds reasonable to you!

Edit: This may also be a Clang bug. I haven't read the relevant DWARF sections with enough detail to say whether the DWARF itself is valid or not, but either way it seems nice to support it in llvm-debuginfo-analyzer, especially considering how much flexibility the tool already affords in terms of input

[scott.linder]

I took a stab at a patch to address the assertion at D150713

Likely there is room to generalize it even further, but I can at least run the tool over e.g. llc in RelWithDebInfo mode, so I can do the same benchmark as for llvm-dwarfdump:

<stat>: <control> <patched> (<patched>/<control>)
instructions:u: 1896657656701 1896827456117 (1.000090)
Maximum resident set size: 51082468 51082618 (1.000003)
branches: 205322657743 205394850877 (1.000352)
branch-misses: 3028996914 2954952928 (0.975555)
User time: 451.593333 453.516667 (1.004259)

It seems the two implementations are indistinguishable in this case (llvm-debuginfo-analyzer --print=symbols build-relwithdebinfo/bin/llc over three trials)

Let me know what you think!

[CarlosAlbertoEnciso]

In D147270#4346528, @scott.linder wrote:

I did a little digging and it seems like there is a faulty assumption in LVELFReader:

// We are assuming that DW_AT_specification, DW_AT_abstract_origin,
// DW_AT_type and DW_AT_extension do not appear at the same time
// in the same DIE.

Thanks very much for your analysis and for creating a small reproducible test.

This seems true for GCC, but not for Clang, at least for the simplest reproducer I could create:

$ cat a.cpp
struct S {
    static const int Arr[];
};
const int S::Arr[] = {
    0, 1, 2
};
$ gcc -g -c a.cpp -o a.o
$ build/bin/llvm-dwarfdump --debug-info a.o | grep -B1 -A2 DW_AT_specification
0x00000053:   DW_TAG_variable
                DW_AT_specification     (0x00000028 "Arr")
                DW_AT_decl_line (4)
                DW_AT_decl_column       (0x0b)
$ clang++ -g -c a.cpp -o a.o
$ build/bin/llvm-dwarfdump --debug-info a.o | grep -B1 -A2 DW_AT_specification
0x0000001e:   DW_TAG_variable
                DW_AT_specification     (0x0000003e "Arr")
                DW_AT_type      (0x00000068 "const int[3]")
                DW_AT_location  (DW_OP_addr 0x0)

It seems like the code could be adapted to track these independently, rather than assume only one is present? I can prepare a patch if that sounds reasonable to you!

I am happy with your proposal and a patch.

Edit: This may also be a Clang bug. I haven't read the relevant DWARF sections with enough detail to say whether the DWARF itself is valid or not, but either way it seems nice to support it in llvm-debuginfo-analyzer, especially considering how much flexibility the tool already affords in terms of input

I compiled your test case with the latest Clang:

0x0000001e:   DW_TAG_variable
                     DW_AT_specification	(0x00000031 "Arr")
                     DW_AT_type	(0x00000052 "const int[3]")
                     DW_AT_location	(DW_OP_addrx 0x0)
                     DW_AT_linkage_name	("_ZN1S3ArrE")

0x00000031:     DW_TAG_member
                       DW_AT_name	("Arr")
                       DW_AT_type	(0x0000003a "const int[]")
                       DW_AT_decl_file	("/data/projects/sandbox/pr-62716.cpp")
                       DW_AT_decl_line	(2)
                       DW_AT_external	(true)
                       DW_AT_declaration	(true)

From the DWARF section for DW_AT_specification:

A debugging information entry with a DW_AT_specification attribute does not need to duplicate information provided by the debugging information entry referenced by that specification attribute.

Clang:

• Added an extra entry for DW_AT_type which seems redundant in DIE (0x1e) as by following the DW_AT_specification we can get the type
• The referenced types are pointing to different DIEs (0x52 and 0x3a).

[CarlosAlbertoEnciso]

In D147270#4347572, @scott.linder wrote:

I took a stab at a patch to address the assertion at D150713

Many thanks.

Likely there is room to generalize it even further, but I can at least run the tool over e.g. llc in RelWithDebInfo mode, so I can do the same benchmark as for llvm-dwarfdump:

<stat>: <control> <patched> (<patched>/<control>)
instructions:u: 1896657656701 1896827456117 (1.000090)
Maximum resident set size: 51082468 51082618 (1.000003)
branches: 205322657743 205394850877 (1.000352)
branch-misses: 3028996914 2954952928 (0.975555)
User time: 451.593333 453.516667 (1.004259)

It seems the two implementations are indistinguishable in this case (llvm-debuginfo-analyzer --print=symbols build-relwithdebinfo/bin/llc over three trials)

Let me know what you think!

LGTM

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

 struct DIDumpOptions;
 class MCRegisterInfo;
 class raw_ostream;
 
 class DWARFExpression {
 public:
   class iterator;
 
-  /// This class represents an Operation in the Expression. Each operation can
-  /// have up to 2 oprerands.
+  /// This class represents an Operation in the Expression.
   ///
   /// An Operation can be in Error state (check with isError()). This
   /// means that it couldn't be decoded successfully and if it is the
   /// case, all others fields contain undefined values.
   class Operation {
   public:
     /// Size and signedness of expression operations' operands.
     enum Encoding : uint8_t {
       Size1 = 0,
       Size2 = 1,
       Size4 = 2,
       Size8 = 3,
       SizeLEB = 4,
       SizeAddr = 5,
       SizeRefAddr = 6,
       SizeBlock = 7, ///< Preceding operand contains block size
       BaseTypeRef = 8,
       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.
     };
 
     enum DwarfVersion : uint8_t {
       DwarfNA, ///< Serves as a marker for unused entries
       Dwarf2 = 2,
       Dwarf3,
       Dwarf4,
       Dwarf5
     };
 
     /// Description of the encoding of one expression Op.
     struct Description {
       DwarfVersion Version; ///< Dwarf version where the Op was introduced.
-      Encoding Op[2];       ///< Encoding for Op operands, or SizeNA.
+      SmallVector<Encoding> Op; ///< Encoding for Op operands.
 
-      Description(DwarfVersion Version = DwarfNA, Encoding Op1 = SizeNA,
-                  Encoding Op2 = SizeNA)
-          : Version(Version) {
-        Op[0] = Op1;
-        Op[1] = Op2;
-      }
+      template <typename... Ts>
+      Description(DwarfVersion Version, Ts... Op)
+          : Version(Version), Op{Op...} {}
+      Description() : Description(DwarfNA) {}
+      ~Description() = default;
     };
 
   private:
     friend class DWARFExpression::iterator;
     uint8_t Opcode; ///< The Op Opcode, DW_OP_<something>.
     Description Desc;
     bool Error = false;
     uint64_t EndOffset;
-    uint64_t Operands[2];
-    uint64_t OperandEndOffsets[2];
+    SmallVector<uint64_t> Operands;
+    SmallVector<uint64_t> OperandEndOffsets;
 
   public:
     const Description &getDescription() const { return Desc; }
     uint8_t getCode() const { return Opcode; }
+    uint64_t getNumOperands() const { return Operands.size(); }
+    ArrayRef<uint64_t> getRawOperands() const { return Operands; };
     uint64_t getRawOperand(unsigned Idx) const { return Operands[Idx]; }
+    ArrayRef<uint64_t> getOperandEndOffsets() const {
+      return OperandEndOffsets;
+    }
     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;
 
public:
   bool verify(DWARFUnit *U);
 
   bool operator==(const DWARFExpression &RHS) const;
 
   StringRef getData() const { return Data.getData(); }
 
   static bool prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS,
                                     DIDumpOptions DumpOpts, uint8_t Opcode,
-                                    const uint64_t Operands[2]);
+                                    const ArrayRef<uint64_t> Operands);
 
 private:
   DataExtractor Data;
   uint8_t AddressSize;
   std::optional<dwarf::DwarfFormat> Format;
 };
 
 inline bool operator==(const DWARFExpression::iterator &LHS,
                        const DWARFExpression::iterator &RHS) {
   return LHS.Expr == RHS.Expr && LHS.Offset == RHS.Offset;
 }
 }
 #endif

llvm/include/llvm/DebugInfo/LogicalView/Core/LVLocation.h

class LVOperation final {
   // To describe an operation:
   // OpCode
   // Operands[0]: First operand.
   // Operands[1]: Second operand.
   //   OP_bregx, OP_bit_piece, OP_[GNU_]const_type,
   //   OP_[GNU_]deref_type, OP_[GNU_]entry_value, OP_implicit_value,
   //   OP_[GNU_]implicit_pointer, OP_[GNU_]regval_type, OP_xderef_type.
   LVSmall Opcode = 0;
-  uint64_t Operands[2];
+  SmallVector<uint64_t> Operands;
 
 public:
   LVOperation() = delete;
-  LVOperation(LVSmall Opcode, LVUnsigned Operand1, LVUnsigned Operand2)
-      : Opcode(Opcode) {
-    Operands[0] = Operand1;
-    Operands[1] = Operand2;
-  }
+  LVOperation(LVSmall Opcode, ArrayRef<LVUnsigned> Operands)
+      : Opcode(Opcode), Operands(Operands) {}
   LVOperation(const LVOperation &) = delete;
   LVOperation &operator=(const LVOperation &) = delete;
   ~LVOperation() = default;
 
   LVSmall getOpcode() const { return Opcode; }
-  uint64_t getOperand1() const { return Operands[0]; }
-  uint64_t getOperand2() const { return Operands[1]; }
   std::string getOperandsDWARFInfo();
   std::string getOperandsCodeViewInfo();
 
   void print(raw_ostream &OS, bool Full = true) const;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() { print(dbgs()); }
 #endif
public:
   // We return:
   //   false: No locations or multiple locations.
   //   true: a single location.
   static bool calculateCoverage(LVLocations *Locations, unsigned &Factor,
                                 float &Percentage);
 
   virtual void addObject(LVAddress LowPC, LVAddress HighPC,
                          LVUnsigned SectionOffset, uint64_t LocDescOffset) {}
-  virtual void addObject(LVSmall Opcode, LVUnsigned Operand1,
-                         LVUnsigned Operand2) {}
+  virtual void addObject(LVSmall Opcode, ArrayRef<LVUnsigned> Operands) {}
 
   static void print(LVLocations *Locations, raw_ostream &OS, bool Full = true);
   void printInterval(raw_ostream &OS, bool Full = true) const;
   void printRaw(raw_ostream &OS, bool Full = true) const;
   virtual void printRawExtra(raw_ostream &OS, bool Full = true) const {}
 
   void print(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;

 public:
   LVLocationSymbol() : LVLocation() {}
   LVLocationSymbol(const LVLocationSymbol &) = delete;
   LVLocationSymbol &operator=(const LVLocationSymbol &) = delete;
   ~LVLocationSymbol() = default;
 
   void addObject(LVAddress LowPC, LVAddress HighPC, LVUnsigned SectionOffset,
                  uint64_t LocDescOffset) override;
-  void addObject(LVSmall Opcode, LVUnsigned Operand1,
-                 LVUnsigned Operand2) override;
+  void addObject(LVSmall Opcode, ArrayRef<LVUnsigned> Operands) override;
 
   void printRawExtra(raw_ostream &OS, bool Full = true) const override;
   void printExtra(raw_ostream &OS, bool Full = true) const override;
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_CORE_LVLOCATION_H

llvm/include/llvm/DebugInfo/LogicalView/Core/LVReader.h

#define LV_CREATE_OBJECT(KIND)                                                 \
   LV_CREATE_OBJECT(TypeEnumerator)
   LV_CREATE_OBJECT(TypeImport)
   LV_CREATE_OBJECT(TypeParam)
   LV_CREATE_OBJECT(TypeSubrange)
 
 #undef LV_CREATE_OBJECT
 
   // Operations creation.
-  LVOperation *createOperation(LVSmall OpCode, LVUnsigned Operand1,
-                               LVUnsigned Operand2) {
-    return new (AllocatedOperation.Allocate())
-        LVOperation(OpCode, Operand1, Operand2);
+  LVOperation *createOperation(LVSmall OpCode, ArrayRef<LVUnsigned> Operands) {
+    return new (AllocatedOperation.Allocate()) LVOperation(OpCode, Operands);
   }
 
   StringRef getFilename(LVObject *Object, size_t Index) const;
   StringRef getFilename() const { return InputFilename; }
   void setFilename(std::string Name) { InputFilename = std::move(Name); }
   StringRef getFileFormatName() const { return FileFormatName; }
 
   raw_ostream &outputStream() { return OS; }
#undef LV_CREATE_OBJECT
   }
 
   // Access to the scopes root.
   LVScopeRoot *getScopesRoot() const { return Root; }
 
   Error doPrint();
   Error doLoad();
 
-  virtual std::string getRegisterName(LVSmall Opcode, uint64_t Operands[2]) {
+  virtual std::string getRegisterName(LVSmall Opcode,
+                                      ArrayRef<uint64_t> Operands) {
     llvm_unreachable("Invalid instance reader.");
     return {};
   }
 
   LVSectionIndex getDotTextSectionIndex() const { return DotTextSectionIndex; }
   virtual LVSectionIndex getSectionIndex(LVScope *Scope) {
     return getDotTextSectionIndex();
   }

llvm/include/llvm/DebugInfo/LogicalView/Core/LVSymbol.h

public:
   void setValue(StringRef Value) override {
     ValueIndex = getStringPool().getIndex(Value);
   }
   size_t getValueIndex() const override { return ValueIndex; }
 
   // Add a Location Entry.
   void addLocationConstant(dwarf::Attribute Attr, LVUnsigned Constant,
                            uint64_t LocDescOffset);
-  void addLocationOperands(LVSmall Opcode, uint64_t Operand1,
-                           uint64_t Operand2);
+  void addLocationOperands(LVSmall Opcode, ArrayRef<uint64_t> Operands);
   void addLocation(dwarf::Attribute Attr, LVAddress LowPC, LVAddress HighPC,
                    LVUnsigned SectionOffset, uint64_t LocDescOffset,
                    bool CallSiteLocation = false);
 
   // Fill gaps in the location list.
   void fillLocationGaps();
 
   // Get all the locations associated with symbols.

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVCodeViewReader.h

public:
   LVScope *getScopeForModule(uint32_t Modi) {
     return Modi >= Modules.size() ? nullptr : Modules[Modi];
   }
 
   // Get the string representation for the CodeView symbols.
   static StringRef getSymbolKindName(SymbolKind Kind);
   static std::string formatRegisterId(RegisterId Register, CPUType CPU);
 
-  std::string getRegisterName(LVSmall Opcode, uint64_t Operands[2]) override;
+  std::string getRegisterName(LVSmall Opcode,
+                              ArrayRef<uint64_t> Operands) override;
 
   bool isSystemEntry(LVElement *Element, StringRef Name) const override;
 
   void print(raw_ostream &OS) const;
   void printRecords(raw_ostream &OS) const override {
     LogicalVisitor.printRecords(OS);
   };
 

llvm/include/llvm/DebugInfo/LogicalView/Readers/LVELFReader.h

public:
   void setCUBaseAddress(LVAddress Address) { CUBaseAddress = Address; }
   LVAddress getCUHighAddress() const { return CUHighAddress; }
   void setCUHighAddress(LVAddress Address) { CUHighAddress = Address; }
 
   const LVSymbols &GetSymbolsWithLocations() const {
     return SymbolsWithLocations;
   }
 
-  std::string getRegisterName(LVSmall Opcode, uint64_t Operands[2]) override;
+  std::string getRegisterName(LVSmall Opcode,
+                              ArrayRef<uint64_t> Operands) override;
 
   void print(raw_ostream &OS) const;
 
 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
   void dump() const { print(dbgs()); }
 #endif
 };
 
 } // end namespace logicalview
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVELFREADER_H

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::emitDebugLocEntry(ByteStreamer &Streamer,
 
   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");
     Streamer.emitInt8(Op.getCode(), Comment != End ? *(Comment++) : "");
     Offset++;
-    for (unsigned I = 0; I < 2; ++I) {
-      if (Op.getDescription().Op[I] == Encoding::SizeNA)
-        continue;
+    for (unsigned I = 0; I < Op.getDescription().Op.size(); ++I) {
       if (Op.getDescription().Op[I] == Encoding::BaseTypeRef) {
         unsigned Length =
           Streamer.emitDIERef(*CU->ExprRefedBaseTypes[Op.getRawOperand(I)].Die);
         // Make sure comments stay aligned.
         for (unsigned J = 0; J < Length; ++J)
           if (Comment != End)
             Comment++;
       } else {

llvm/lib/DWARFLinker/DWARFLinker.cpp

void DWARFLinker::DIECloner::cloneExpression(
     CompileUnit &Unit, SmallVectorImpl<uint8_t> &OutputBuffer,
     int64_t AddrRelocAdjustment, bool IsLittleEndian) {
   using Encoding = DWARFExpression::Operation::Encoding;
 
   uint8_t OrigAddressByteSize = Unit.getOrigUnit().getAddressByteSize();
 
   uint64_t OpOffset = 0;
   for (auto &Op : Expression) {
-    auto Description = Op.getDescription();
+    auto Desc = Op.getDescription();
     // DW_OP_const_type is variable-length and has 3
-    // operands. DWARFExpression thus far only supports 2.
-    auto Op0 = Description.Op[0];
-    auto Op1 = Description.Op[1];
-    if ((Op0 == Encoding::BaseTypeRef && Op1 != Encoding::SizeNA) ||
-        (Op1 == Encoding::BaseTypeRef && Op0 != Encoding::Size1))
+    // operands. Thus far we only support 2.
+    if ((Desc.Op.size() == 2 && Desc.Op[0] == Encoding::BaseTypeRef) ||
+        (Desc.Op.size() == 2 && Desc.Op[1] == Encoding::BaseTypeRef &&
+         Desc.Op[0] != Encoding::Size1))
       Linker.reportWarning("Unsupported DW_OP encoding.", File);
 
-    if ((Op0 == Encoding::BaseTypeRef && Op1 == Encoding::SizeNA) ||
-        (Op1 == Encoding::BaseTypeRef && Op0 == Encoding::Size1)) {
+    if ((Desc.Op.size() == 1 && Desc.Op[0] == Encoding::BaseTypeRef) ||
+        (Desc.Op.size() == 2 && Desc.Op[1] == Encoding::BaseTypeRef &&
+         Desc.Op[0] == 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.
       OutputBuffer.push_back(Op.getCode());
       uint64_t RefOffset;
-      if (Op1 == Encoding::SizeNA) {
+      if (Desc.Op.size() == 1) {
         RefOffset = Op.getRawOperand(0);
       } else {
         OutputBuffer.push_back(Op.getRawOperand(0));
         RefOffset = Op.getRawOperand(1);
       }
       uint32_t Offset = 0;
       // Look up the base type. For DW_OP_convert, the operand may be 0 to
       // instead indicate the generic type. The same holds for

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

 #include <cstdint>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 
 namespace llvm {
 
-typedef std::vector<DWARFExpression::Operation::Description> DescVector;
-
-static DescVector getDescriptions() {
-  DescVector Descriptions;
-  typedef DWARFExpression::Operation Op;
-  typedef Op::Description Desc;
 
+static std::vector<Desc> getOpDescriptions() {
+  std::vector<Desc> Descriptions;
   Descriptions.resize(0xff);
   Descriptions[DW_OP_addr] = Desc(Op::Dwarf2, Op::SizeAddr);
   Descriptions[DW_OP_deref] = Desc(Op::Dwarf2);
   Descriptions[DW_OP_const1u] = Desc(Op::Dwarf2, Op::Size1);
   Descriptions[DW_OP_const1s] = Desc(Op::Dwarf2, Op::SignedSize1);
   Descriptions[DW_OP_const2u] = Desc(Op::Dwarf2, Op::Size2);
   Descriptions[DW_OP_const2s] = Desc(Op::Dwarf2, Op::SignedSize2);
   Descriptions[DW_OP_const4u] = Desc(Op::Dwarf2, Op::Size4);
Descriptions[DW_OP_implicit_value] =
       Desc(Op::Dwarf3, Op::SizeLEB, Op::SizeBlock);
   Descriptions[DW_OP_stack_value] = Desc(Op::Dwarf3);
   Descriptions[DW_OP_WASM_location] =
       Desc(Op::Dwarf4, Op::SizeLEB, Op::WasmLocationArg);
   Descriptions[DW_OP_GNU_push_tls_address] = Desc(Op::Dwarf3);
   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_addrx] = Desc(Op::Dwarf5, Op::SizeLEB);
   Descriptions[DW_OP_constx] = Desc(Op::Dwarf5, 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);
-
   return Descriptions;
 }
 
-static DWARFExpression::Operation::Description getOpDesc(unsigned OpCode) {
-  // FIXME: Make this constexpr once all compilers are smart enough to do it.
-  static DescVector Descriptions = getDescriptions();
+static Desc getDescImpl(ArrayRef<Desc> Descriptions, unsigned Opcode) {
   // Handle possible corrupted or unsupported operation.
-  if (OpCode >= Descriptions.size())
+  if (Opcode >= Descriptions.size())
     return {};
-  return Descriptions[OpCode];
+  return Descriptions[Opcode];
+}
+
+static Desc getOpDesc(unsigned Opcode) {
+  static std::vector<Desc> Descriptions = getOpDescriptions();
+  return getDescImpl(Descriptions, Opcode);
 }
 
 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 < 2; ++Operand) {
+  Operands.resize(Desc.Op.size());
+  OperandEndOffsets.resize(Desc.Op.size());
+  for (unsigned Operand = 0; Operand < Desc.Op.size(); ++Operand) {
     unsigned Size = Desc.Op[Operand];
     unsigned Signed = Size & Operation::SignBit;
 
-    if (Size == Operation::SizeNA)
-      break;
-
     switch (Size & ~Operation::SignBit) {
     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);
bool DWARFExpression::Operation::extract(DataExtractor Data,
   }
 
   EndOffset = Offset;
   return true;
 }
 
 static void prettyPrintBaseTypeRef(DWARFUnit *U, raw_ostream &OS,
                                    DIDumpOptions DumpOpts,
-                                   const uint64_t Operands[2],
+                                   ArrayRef<uint64_t> Operands,
                                    unsigned Operand) {
-  assert(Operand < 2 && "operand out of bounds");
+  assert(Operand < Operands.size() && "operand out of bounds");
   auto Die = U->getDIEForOffset(U->getOffset() + Operands[Operand]);
   if (Die && Die.getTag() == dwarf::DW_TAG_base_type) {
     OS << " (";
     if (DumpOpts.Verbose)
       OS << format("0x%08" PRIx64 " -> ", Operands[Operand]);
     OS << format("0x%08" PRIx64 ")", U->getOffset() + Operands[Operand]);
     if (auto Name = dwarf::toString(Die.find(dwarf::DW_AT_name)))
       OS << " \"" << *Name << "\"";
   } else {
     OS << format(" <invalid base_type ref: 0x%" PRIx64 ">",
                  Operands[Operand]);
   }
 }
 
 bool DWARFExpression::prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS,
                                             DIDumpOptions DumpOpts,
                                             uint8_t Opcode,
-                                            const uint64_t Operands[2]) {
+                                            ArrayRef<uint64_t> Operands) {
   if (!DumpOpts.GetNameForDWARFReg)
     return false;
 
   uint64_t DwarfRegNum;
   unsigned OpNum = 0;
 
   if (Opcode == DW_OP_bregx || Opcode == DW_OP_regx ||
       Opcode == DW_OP_regval_type)
bool DWARFExpression::Operation::print(raw_ostream &OS, DIDumpOptions DumpOpts,
 
   if ((Opcode >= DW_OP_breg0 && Opcode <= DW_OP_breg31) ||
       (Opcode >= DW_OP_reg0 && Opcode <= DW_OP_reg31) ||
       Opcode == DW_OP_bregx || Opcode == DW_OP_regx ||
       Opcode == DW_OP_regval_type)
     if (prettyPrintRegisterOp(U, OS, DumpOpts, Opcode, Operands))
       return true;
 
-  for (unsigned Operand = 0; Operand < 2; ++Operand) {
+  for (unsigned Operand = 0; Operand < Desc.Op.size(); ++Operand) {
     unsigned Size = Desc.Op[Operand];
     unsigned Signed = Size & Operation::SignBit;
 
-    if (Size == Operation::SizeNA)
-      break;
-
     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);
for (auto &Op : *this) {
     }
 
     if (Op.getEndOffset() < Data.getData().size())
       OS << ", ";
   }
 }
 
 bool DWARFExpression::Operation::verify(const Operation &Op, DWARFUnit *U) {
-  for (unsigned Operand = 0; Operand < 2; ++Operand) {
+  for (unsigned Operand = 0; Operand < Op.Desc.Op.size(); ++Operand) {
     unsigned Size = Op.Desc.Op[Operand];
 
-    if (Size == Operation::SizeNA)
-      break;
-
     if (Size == Operation::BaseTypeRef) {
       // For DW_OP_convert the operand may be 0 to indicate that conversion to
       // the generic type should be done, so don't look up a base type in that
       // case. The same holds for DW_OP_reinterpret, which is currently not
       // supported.
       if (Op.Opcode == DW_OP_convert && Op.Operands[Operand] == 0)
         continue;
       auto Die = U->getDIEForOffset(U->getOffset() + Op.Operands[Operand]);

llvm/lib/DebugInfo/LogicalView/Core/LVLocation.cpp

 std::string LVOperation::getOperandsCodeViewInfo() {
   std::string String;
   raw_string_ostream Stream(String);
 
   // Get original CodeView operation code.
   uint16_t OperationCode = getCodeViewOperationCode(Opcode);
 
   switch (OperationCode) {
-  // Operands: [Offset, 0].
+  // Operands: [Offset].
   case codeview::SymbolKind::S_DEFRANGE_FRAMEPOINTER_REL:
     Stream << "frame_pointer_rel " << int(Operands[0]);
     break;
   case codeview::SymbolKind::S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE:
     Stream << "frame_pointer_rel_full_scope " << int(Operands[0]);
     break;
 
-  // Operands: [Register, 0].
+  // Operands: [Register].
   case codeview::SymbolKind::S_DEFRANGE_REGISTER:
     Stream << "register " << getReader().getRegisterName(Opcode, Operands);
     break;
   case codeview::SymbolKind::S_DEFRANGE_SUBFIELD_REGISTER:
     Stream << "subfield_register "
            << getReader().getRegisterName(Opcode, Operands);
     break;
 
   // Operands: [Register, Offset].
   case codeview::SymbolKind::S_DEFRANGE_REGISTER_REL:
     Stream << "register_rel " << getReader().getRegisterName(Opcode, Operands)
            << " offset " << int(Operands[1]);
     break;
 
-  // Operands: [Program, 0].
+  // Operands: [Program].
   case codeview::SymbolKind::S_DEFRANGE:
     Stream << "frame " << int(Operands[0]);
     break;
   case codeview::SymbolKind::S_DEFRANGE_SUBFIELD:
     Stream << "subfield " << int(Operands[0]);
     break;
 
   default:
void LVLocationSymbol::addObject(LVAddress LowPC, LVAddress HighPC,
   if (HighPC == LVAddress(UINT64_MAX))
     setIsDiscardedRange();
 
   // Update the location kind, using the DWARF attribute.
   setKind();
 }
 
 // Add a Location Record.
-void LVLocationSymbol::addObject(LVSmall Opcode, LVUnsigned Operand1,
-                                 LVUnsigned Operand2) {
+void LVLocationSymbol::addObject(LVSmall Opcode,
+                                 ArrayRef<LVUnsigned> Operands) {
   if (!Entries)
     Entries = std::make_unique<LVOperations>();
-  Entries->push_back(getReader().createOperation(Opcode, Operand1, Operand2));
+  Entries->push_back(getReader().createOperation(Opcode, Operands));
 }
 
 // Based on the DWARF attribute, define the location kind.
 void LVLocation::setKind() {
   switch (getAttr()) {
   case dwarf::DW_AT_data_member_location:
     setIsClassOffset();
     break;

llvm/lib/DebugInfo/LogicalView/Core/LVSymbol.cpp

void LVSymbol::addLocation(dwarf::Attribute Attr, LVAddress LowPC,
   CurrentLocation->addObject(LowPC, HighPC, SectionOffset, LocDescOffset);
   Locations->push_back(CurrentLocation);
 
   // Mark the symbol as having location information.
   setHasLocation();
 }
 
 // Add a Location Record.
-void LVSymbol::addLocationOperands(LVSmall Opcode, uint64_t Operand1,
-                                   uint64_t Operand2) {
+void LVSymbol::addLocationOperands(LVSmall Opcode,
+                                   ArrayRef<uint64_t> Operands) {
   if (CurrentLocation)
-    CurrentLocation->addObject(Opcode, Operand1, Operand2);
+    CurrentLocation->addObject(Opcode, Operands);
 }
 
 // Add a Location Entry.
 void LVSymbol::addLocationConstant(dwarf::Attribute Attr, LVUnsigned Constant,
                                    uint64_t LocDescOffset) {
   // Create a Location Entry, with the global information.
   addLocation(Attr,
               /*LowPC=*/0, /*HighPC=*/-1,
               /*SectionOffset=*/0, LocDescOffset);
 
   // Add records to Location Entry.
-  addLocationOperands(/*Opcode=*/LVLocationMemberOffset,
-                      /*Operand1=*/Constant, /*Operand2=*/0);
+  addLocationOperands(/*Opcode=*/LVLocationMemberOffset, {Constant});
 }
 
 LVLocations::iterator LVSymbol::addLocationGap(LVLocations::iterator Pos,
                                                LVAddress LowPC,
                                                LVAddress HighPC) {
   // Create a location entry for the gap.
   LVLocation *Gap = getReader().createLocationSymbol();
   Gap->setParent(this);
   Gap->setAttr(dwarf::DW_AT_location);
   Gap->addObject(LowPC, HighPC,
                  /*section_offset=*/0,
                  /*locdesc_offset=*/0);
 
   LVLocations::iterator Iter = Locations->insert(Pos, Gap);
 
   // Add gap to Location Entry.
-  Gap->addObject(/*op=*/dwarf::DW_OP_hi_user,
-                 /*opd1=*/0, /*opd2=*/0);
+  Gap->addObject(dwarf::DW_OP_hi_user, {});
 
   // Mark the entry as a gap.
   Gap->setIsGapEntry();
 
   return Iter;
 }
 
 void LVSymbol::fillLocationGaps() {

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

Error LVCodeViewReader::loadTargetInfo(const PDBFile &Pdb) {
   TT.setOS(Triple::Win32);
 
   StringRef TheFeature = "";
 
   return loadGenericTargetInfo(TT.str(), TheFeature);
 }
 
 std::string LVCodeViewReader::getRegisterName(LVSmall Opcode,
-                                              uint64_t Operands[2]) {
+                                              ArrayRef<uint64_t> Operands) {
   // Get Compilation Unit CPU Type.
   CPUType CPU = getCompileUnitCPUType();
   // For CodeView the register always is in Operands[0];
   RegisterId Register = (RegisterId(Operands[0]));
   return formatRegisterId(Register, CPU);
 }

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

if (LVSymbol *Symbol = LocalSymbol) {
     LocalSymbol = nullptr;
 
     // Add location debug location. Operands: [Offset, 0].
     dwarf::Attribute Attr =
         dwarf::Attribute(SymbolKind::S_DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE);
 
     uint64_t Operand1 = DefRangeFramePointerRelFullScope.Offset;
     Symbol->addLocation(Attr, 0, 0, 0, 0);
-    Symbol->addLocationOperands(LVSmall(Attr), Operand1, /*Operand2=*/0);
+    Symbol->addLocationOperands(LVSmall(Attr), {Operand1});
   }
 
   return Error::success();
 }
 
 // S_DEFRANGE_FRAMEPOINTER_REL
 Error LVSymbolVisitor::visitKnownRecord(
     CVSymbol &Record, DefRangeFramePointerRelSym &DefRangeFramePointerRel) {
dwarf::Attribute Attr =
         dwarf::Attribute(SymbolKind::S_DEFRANGE_FRAMEPOINTER_REL);
     uint64_t Operand1 = DefRangeFramePointerRel.Hdr.Offset;
 
     LocalVariableAddrRange Range = DefRangeFramePointerRel.Range;
     LVAddress Address =
         Reader->linearAddress(Range.ISectStart, Range.OffsetStart);
 
     Symbol->addLocation(Attr, Address, Address + Range.Range, 0, 0);
-    Symbol->addLocationOperands(LVSmall(Attr), Operand1, /*Operand2=*/0);
+    Symbol->addLocationOperands(LVSmall(Attr), {Operand1});
   }
 
   return Error::success();
 }
 
 // S_DEFRANGE_REGISTER_REL
 Error LVSymbolVisitor::visitKnownRecord(
     CVSymbol &Record, DefRangeRegisterRelSym &DefRangeRegisterRel) {
if (LVSymbol *Symbol = LocalSymbol) {
     uint64_t Operand1 = DefRangeRegisterRel.Hdr.Register;
     uint64_t Operand2 = DefRangeRegisterRel.Hdr.BasePointerOffset;
 
     LocalVariableAddrRange Range = DefRangeRegisterRel.Range;
     LVAddress Address =
         Reader->linearAddress(Range.ISectStart, Range.OffsetStart);
 
     Symbol->addLocation(Attr, Address, Address + Range.Range, 0, 0);
-    Symbol->addLocationOperands(LVSmall(Attr), Operand1, Operand2);
+    Symbol->addLocationOperands(LVSmall(Attr), {Operand1, Operand2});
   }
 
   return Error::success();
 }
 
 // S_DEFRANGE_REGISTER
 Error LVSymbolVisitor::visitKnownRecord(CVSymbol &Record,
                                         DefRangeRegisterSym &DefRangeRegister) {
if (LVSymbol *Symbol = LocalSymbol) {
     dwarf::Attribute Attr = dwarf::Attribute(SymbolKind::S_DEFRANGE_REGISTER);
     uint64_t Operand1 = DefRangeRegister.Hdr.Register;
 
     LocalVariableAddrRange Range = DefRangeRegister.Range;
     LVAddress Address =
         Reader->linearAddress(Range.ISectStart, Range.OffsetStart);
 
     Symbol->addLocation(Attr, Address, Address + Range.Range, 0, 0);
-    Symbol->addLocationOperands(LVSmall(Attr), Operand1, /*Operand2=*/0);
+    Symbol->addLocationOperands(LVSmall(Attr), {Operand1});
   }
 
   return Error::success();
 }
 
 // S_DEFRANGE_SUBFIELD_REGISTER
 Error LVSymbolVisitor::visitKnownRecord(
     CVSymbol &Record, DefRangeSubfieldRegisterSym &DefRangeSubfieldRegister) {
dwarf::Attribute Attr =
         dwarf::Attribute(SymbolKind::S_DEFRANGE_SUBFIELD_REGISTER);
     uint64_t Operand1 = DefRangeSubfieldRegister.Hdr.Register;
 
     LocalVariableAddrRange Range = DefRangeSubfieldRegister.Range;
     LVAddress Address =
         Reader->linearAddress(Range.ISectStart, Range.OffsetStart);
 
     Symbol->addLocation(Attr, Address, Address + Range.Range, 0, 0);
-    Symbol->addLocationOperands(LVSmall(Attr), Operand1, /*Operand2=*/0);
+    Symbol->addLocationOperands(LVSmall(Attr), {Operand1});
   }
 
   return Error::success();
 }
 
 // S_DEFRANGE_SUBFIELD
 Error LVSymbolVisitor::visitKnownRecord(CVSymbol &Record,
                                         DefRangeSubfieldSym &DefRangeSubfield) {
if (LVSymbol *Symbol = LocalSymbol) {
     dwarf::Attribute Attr = dwarf::Attribute(SymbolKind::S_DEFRANGE_SUBFIELD);
     uint64_t Operand1 = DefRangeSubfield.Program;
 
     LocalVariableAddrRange Range = DefRangeSubfield.Range;
     LVAddress Address =
         Reader->linearAddress(Range.ISectStart, Range.OffsetStart);
 
     Symbol->addLocation(Attr, Address, Address + Range.Range, 0, 0);
-    Symbol->addLocationOperands(LVSmall(Attr), Operand1, /*Operand2=*/0);
+    Symbol->addLocationOperands(LVSmall(Attr), {Operand1, /*Operand2=*/0});
   }
 
   return Error::success();
 }
 
 // S_DEFRANGE
 Error LVSymbolVisitor::visitKnownRecord(CVSymbol &Record,
                                         DefRangeSym &DefRange) {
if (LVSymbol *Symbol = LocalSymbol) {
     dwarf::Attribute Attr = dwarf::Attribute(SymbolKind::S_DEFRANGE);
     uint64_t Operand1 = DefRange.Program;
 
     LocalVariableAddrRange Range = DefRange.Range;
     LVAddress Address =
         Reader->linearAddress(Range.ISectStart, Range.OffsetStart);
 
     Symbol->addLocation(Attr, Address, Address + Range.Range, 0, 0);
-    Symbol->addLocationOperands(LVSmall(Attr), Operand1, /*Operand2=*/0);
+    Symbol->addLocationOperands(LVSmall(Attr), {Operand1, /*Operand2=*/0});
   }
 
   return Error::success();
 }
 
 // S_FRAMEPROC
 Error LVSymbolVisitor::visitKnownRecord(CVSymbol &Record,
                                         FrameProcSym &FrameProc) {

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

for (const DWARFDebugLine::Row &Row : Lines->Rows) {
       LLVM_DEBUG({
         dbgs() << "Address: " << hexValue(Line->getAddress())
                << " Line: " << Line->lineNumberAsString(/*ShowZero=*/true)
                << "\n";
       });
     }
 }
 
-std::string LVELFReader::getRegisterName(LVSmall Opcode, uint64_t Operands[2]) {
+std::string LVELFReader::getRegisterName(LVSmall Opcode,
+                                         ArrayRef<uint64_t> Operands) {
   // The 'prettyPrintRegisterOp' function uses the DWARFUnit to support
   // DW_OP_regval_type. At this point we are operating on a logical view
   // item, with no access to the underlying DWARF data used by LLVM.
   // We do not support DW_OP_regval_type here.
   if (Opcode == dwarf::DW_OP_regval_type)
     return {};
 
   std::string string;

 // Get the location information for the associated attribute.
 void LVELFReader::processLocationList(dwarf::Attribute Attr,
                                       const DWARFFormValue &FormValue,
                                       const DWARFDie &Die,
                                       uint64_t OffsetOnEntry,
                                       bool CallSiteLocation) {
 
   auto ProcessLocationExpression = [&](const DWARFExpression &Expression) {
-    // DW_OP_const_type is variable-length and has 3
-    // operands. DWARFExpression thus far only supports 2.
-    uint64_t Operands[2] = {0};
-    for (const DWARFExpression::Operation &Op : Expression) {
-      DWARFExpression::Operation::Description Description = Op.getDescription();
-      for (unsigned Operand = 0; Operand < 2; ++Operand) {
-        if (Description.Op[Operand] == DWARFExpression::Operation::SizeNA)
-          break;
-        Operands[Operand] = Op.getRawOperand(Operand);
-      }
-      CurrentSymbol->addLocationOperands(Op.getCode(), Operands[0],
-                                         Operands[1]);
-    }
+    for (const DWARFExpression::Operation &Op : Expression)
+      CurrentSymbol->addLocationOperands(Op.getCode(), Op.getRawOperands());
   };
 
   DWARFUnit *U = Die.getDwarfUnit();
   DWARFContext &DwarfContext = U->getContext();
   bool IsLittleEndian = DwarfContext.isLittleEndian();
   if (FormValue.isFormClass(DWARFFormValue::FC_Block) ||
       (DWARFAttribute::mayHaveLocationExpr(Attr) &&
        FormValue.isFormClass(DWARFFormValue::FC_Exprloc))) {