Remove the dependency between lib/DebugInfoDWARF and MC

[rastogishubham]

Summary

lib/DebugInfoDWARF depends on MC and the dependency is only based on MCRegisterInfo. This patch is a refactoring of the DebugInfoDWARF code to make it so that lib/DebugInfoDWARF doesn't depend on MC

[aprantl]

I think this is a good change to make, I just have a couple of comments inline about the exact implementation.

lldb/source/Expression/DWARFExpression.cpp

73

Since a StringRef can be empty(), it usually doesn't make a lot of sense to wrap it inside of Optional. I would just use a plain StringRef.

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

124

Callback isn't a very descriptive name: What about GetNameForDWARFReg or something like that?

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

169

I am mildly surprised that = nullptr works. Should the default argument be a lambda or static function that returns llvm::None?

226

This type appears a lot of times. What about declaring it with a using directive or making it a class object instead?

llvm/lib/DebugInfo/DWARF/CMakeLists.txt

39

Very nice!

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

336

Would there any benefit of having DWARFContext own Callback instead of passing it through here everywhere?

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

288–289

@clayborg Would this be a regression? It seems to not be tested...

[aprantl]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

169

Ah I see, there's a constructor for std::function that explicitly takes a nullptr and you are checking the operator bool() before calling it.

[rastogishubham]

lldb/source/Expression/DWARFExpression.cpp

73

The reason I used an Optional is because in my mind the RegName for a register can be empty itself, maybe? The Optional tells me that there was no RegName or no LLVMRegNum found and helps me output any error messages if needed.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

336

Not sure what you mean, DWARFContext dows own Callback, but this is a static function which is not related to class DWARFContext, so Callback has to be passed as an argument

[clayborg]

Many of these changes involve modifying functions that are dumping some DWARF and the functions used to take a DIDumpOptions + MRI, but now take a DIDumpOptions + std::function<...>. We should add the callback into DIDumpOptions. I believe the "bool isEH" is also mainly needed for this function callback in order to make sure we get the right register number as sometimes DWARF register numbers differ from compiler register numbers found in .eh_frame.

So would adding more members to DIDumpOptions make these functions cleaner and easier to use?

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

457–459

I would suggest we add the std::function callback to the DIDumpOptions since any DWARF that needs to dump something could be able to use the mapping of register number to register name. If "bool isEH" is also only used for this, maybe we can add that to DIDumpOptions as well.

[rastogishubham]

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

457–459

I think this is a good suggestion and very do-able

[rastogishubham]

Added the std::function and isEH in struct DIDumpOptions instead of passing it around to every dump function as an argument

[clayborg]

llvm/include/llvm/DebugInfo/DIContext.h

205

Case should be "IsEH" according to llvm guidelines.

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

167–168

Do we want to just pass in DIDumpOptions here as well?

225–226

ditto

306–307

ditto

351–352

ditto

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

113

Seeing this is another reason we might want to pass in DIDumpOptions to this function. Then we wouldn't need to create a temp on here.

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

561–562

Use Expected<std::unique_ptr<MCRegisterInfo>> as the return value?

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

289

Was this not needed?

[aprantl]

I think this is looking good now. I have a few very minor comments, but otherwise this is good to go.

lldb/source/Expression/DWARFExpression.cpp

73

I guess that's technically correct, but it would be weird. Then we would print an empty string instead of the DWARF register number, which means there would be no record of that there was a register? I would probably just treat an empty string like a nullptr.

llvm/include/llvm/DebugInfo/DIContext.h

205

Can you swap the order between the fields? The bools may have a smaller alignment than the std::function and so the whole struct could be smaller if they are grouped together.

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

1243

I think the suggestion to pass IsEH in DumpOpts was well-intentioned, but it's not so elegant that we need to update it here. I don;t feel strongly enough about it to be bothered by it though.

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

249

Wouldn't it be more efficient to say

OS << '  ' << RegName << format("%+" PRId64, Operands[OpNum]);

?

[rastogishubham]

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

289

It seems like this is not tested, and the DICtx that owns the registerinfo doesn't do anything with it, so I just removed it

[MaskRay]

lldb/source/Expression/DWARFExpression.cpp

72

delete blank line

74

delete = nullptr

[rastogishubham]

Addressed @MaskRay comments.

Thanks for the review!

[aprantl]

LGTM!

[MaskRay]

This patch is not rebased on the top of main branch so it fails to apply. For such a patch we probably want to check pre-commit tests https://buildkite.com/llvm-project/diff-checks/builds/129386

llvm/include/llvm/DebugInfo/DIContext.h

203

also delete =nullptr here

[rastogishubham]

Removed nullptr and rebased

[rastogishubham]

@MaskRay if everything looks good can I consider this patch approved?

[rastogishubham]

I was not able to land this patch earlier because of some bot failures and then I got busy with some other stuff, this is just an update of the patch with merge conflicts resolved

[rastogishubham]

Fix the lldb test failures:

lldb-shell :: SymbolFile/DWARF/x86/DW_AT_loclists_base.s
lldb-shell :: SymbolFile/DWARF/x86/debug_loc.s
lldb-shell :: SymbolFile/DWARF/x86/debug_loc_and_loclists.s
lldb-shell :: SymbolFile/DWARF/x86/debug_loclists-dwo.s
lldb-shell :: SymbolFile/DWARF/x86/debug_loclists-dwp.s
lldb-shell :: SymbolFile/DWARF/x86/dwp.s
lldb-shell :: SymbolFile/DWARF/x86/unused-inlined-params.test
lldb-shell :: SymbolFile/NativePDB/inline_sites.test
lldb-shell :: SymbolFile/NativePDB/local-variables-registers.s
lldb-shell :: SymbolFile/NativePDB/nested-blocks-same-address.s

lldb/source/Expression/DWARFExpression.cpp

void DWARFExpression::UpdateValue(uint64_t const_value,
   m_data.SetData(
       DataBufferSP(new DataBufferHeap(&const_value, const_value_byte_size)));
   m_data.SetByteOrder(endian::InlHostByteOrder());
   m_data.SetAddressByteSize(addr_byte_size);
 }
 
 void DWARFExpression::DumpLocation(Stream *s, lldb::DescriptionLevel level,
                                    ABI *abi) const {
+  auto *MCRegInfo = abi ? &abi->GetMCRegisterInfo() : nullptr;
+  auto GetRegName = [&MCRegInfo](uint64_t DwarfRegNum,
+                                 bool IsEH) -> llvm::StringRef {
+    if (!MCRegInfo)
+      return {};
+    if (std::optional<unsigned> LLVMRegNum =
+            MCRegInfo->getLLVMRegNum(DwarfRegNum, IsEH))
+      if (const char *RegName = MCRegInfo->getName(*LLVMRegNum))
+        return llvm::StringRef(RegName);
+    return {};
+  };
+  llvm::DIDumpOptions DumpOpts;
+  DumpOpts.GetNameForDWARFReg = GetRegName;
   llvm::DWARFExpression(m_data.GetAsLLVM(), m_data.GetAddressByteSize())
-      .print(s->AsRawOstream(), llvm::DIDumpOptions(),
-             abi ? &abi->GetMCRegisterInfo() : nullptr, nullptr);
+      .print(s->AsRawOstream(), DumpOpts, nullptr);
 }
 
 RegisterKind DWARFExpression::GetRegisterKind() const { return m_reg_kind; }
 
 void DWARFExpression::SetRegisterKind(RegisterKind reg_kind) {
   m_reg_kind = reg_kind;
 }
 

lldb/source/Symbol/UnwindPlan.cpp

GetByteOrderAndAddrSize(Thread *thread) {
   return std::make_pair(arch.GetByteOrder(), arch.GetAddressByteSize());
 }
 
 static void DumpDWARFExpr(Stream &s, llvm::ArrayRef<uint8_t> expr, Thread *thread) {
   if (auto order_and_width = GetByteOrderAndAddrSize(thread)) {
     llvm::DataExtractor data(expr, order_and_width->first == eByteOrderLittle,
                              order_and_width->second);
     llvm::DWARFExpression(data, order_and_width->second, llvm::dwarf::DWARF32)
-        .print(s.AsRawOstream(), llvm::DIDumpOptions(), nullptr, nullptr);
+        .print(s.AsRawOstream(), llvm::DIDumpOptions(), nullptr);
   } else
     s.PutCString("dwarf-expr");
 }
 
 void UnwindPlan::Row::RegisterLocation::Dump(Stream &s,
                                              const UnwindPlan *unwind_plan,
                                              const UnwindPlan::Row *row,
                                              Thread *thread,

lldb/unittests/Symbol/PostfixExpressionTest.cpp

static std::string ParseAndGenerateDWARF(llvm::StringRef expr) {
 
   // print dwarf expression to comparable textual representation
   llvm::DataExtractor extractor(dwarf.GetString(), /*IsLittleEndian=*/true,
                                 addr_size);
 
   std::string result;
   llvm::raw_string_ostream os(result);
   llvm::DWARFExpression(extractor, addr_size, llvm::dwarf::DWARF32)
-      .print(os, llvm::DIDumpOptions(), nullptr, nullptr);
+      .print(os, llvm::DIDumpOptions(), nullptr);
   return std::move(os.str());
 }
 
 TEST(PostfixExpression, ToDWARF) {
   EXPECT_EQ("DW_OP_consts +0", ParseAndGenerateDWARF("0"));
 
   EXPECT_EQ("DW_OP_breg1 +0", ParseAndGenerateDWARF("R1"));
 

lldb/unittests/SymbolFile/NativePDB/PdbFPOProgramToDWARFExpressionTests.cpp

CheckValidProgramTranslation(llvm::StringRef fpo_program,
 
   // print dwarf expression to comparable textual representation
   llvm::DataExtractor extractor({stream.GetData(), stream.GetSize()},
                                 /*IsLittleEndian=*/true, /*AddressSize=*/4);
 
   std::string result;
   llvm::raw_string_ostream os(result);
   llvm::DWARFExpression(extractor, /*AddressSize=*/4, llvm::dwarf::DWARF32)
-      .print(os, llvm::DIDumpOptions(), nullptr, nullptr);
+      .print(os, llvm::DIDumpOptions(), nullptr);
 
   // actual check
   ASSERT_EQ(expected_dwarf_expression, os.str());
 }
 
 TEST(PDBFPOProgramToDWARFExpressionTests, SingleAssignmentRegisterRef) {
   CheckValidProgramTranslation("$T0 $ebp = ", "$T0", "DW_OP_breg6 +0");
 }

llvm/include/llvm/DebugInfo/DIContext.h

struct DIDumpOptions {
   uint8_t AddrSize = 4; // Address byte size to assume when extracting.
   bool ShowAddresses = true;
   bool ShowChildren = false;
   bool ShowParents = false;
   bool ShowForm = false;
   bool SummarizeTypes = false;
   bool Verbose = false;
   bool DisplayRawContents = false;
+  bool IsEH = false;
+  std::function<llvm::StringRef(uint64_t DwarfRegNum, bool IsEH)>
+      GetNameForDWARFReg;
 
   /// Return default option set for printing a single DIE without children.
   static DIDumpOptions getForSingleDIE() {
     DIDumpOptions Opts;
     Opts.ChildRecurseDepth = 0;
     Opts.ParentRecurseDepth = 0;
     return Opts;
   }
 

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Host.h"
 #include <cstdint>
 #include <memory>
 
 namespace llvm {
 
-class MCRegisterInfo;
 class MemoryBuffer;
 class AppleAcceleratorTable;
 class DWARFCompileUnit;
 class DWARFDebugAbbrev;
 class DWARFDebugAranges;
 class DWARFDebugFrame;
 class DWARFDebugLoc;
 class DWARFDebugMacro;
class DWARFContext : public DIContext {
   struct DWOFile {
     object::OwningBinary<object::ObjectFile> File;
     std::unique_ptr<DWARFContext> Context;
   };
   StringMap<std::weak_ptr<DWOFile>> DWOFiles;
   std::weak_ptr<DWOFile> DWP;
   bool CheckedForDWP = false;
   std::string DWPName;
-
-  std::unique_ptr<MCRegisterInfo> RegInfo;
-
   std::function<void(Error)> RecoverableErrorHandler =
       WithColor::defaultErrorHandler;
   std::function<void(Error)> WarningHandler = WithColor::defaultWarningHandler;
 
   /// Read compile units from the debug_info section (if necessary)
   /// and type units from the debug_types sections (if necessary)
   /// and store them in NormalUnits.
   void parseNormalUnits();
DWARFContext(std::unique_ptr<const DWARFObject> DObj,
                    WithColor::defaultWarningHandler);
   ~DWARFContext() override;
 
   DWARFContext(DWARFContext &) = delete;
   DWARFContext &operator=(DWARFContext &) = delete;
 
   const DWARFObject &getDWARFObj() const { return *DObj; }
 
   static bool classof(const DIContext *DICtx) {
     return DICtx->getKind() == CK_DWARF;
   }
 
   /// Dump a textual representation to \p OS. If any \p DumpOffsets are present,
   /// dump only the record at the specified offset.
   void dump(raw_ostream &OS, DIDumpOptions DumpOpts,
             std::array<std::optional<uint64_t>, DIDT_ID_Count> DumpOffsets);
 
static Error checkAddressSizeSupported(unsigned AddressSize,
     for (unsigned Size : DWARFContext::getSupportedAddressSizes())
       Stream << LS << Size;
     Stream << ')';
     return make_error<StringError>(Stream.str(), EC);
   }
 
   std::shared_ptr<DWARFContext> getDWOContext(StringRef AbsolutePath);
 
-  const MCRegisterInfo *getRegisterInfo() const { return RegInfo.get(); }
-
   function_ref<void(Error)> getRecoverableErrorHandler() {
     return RecoverableErrorHandler;
   }
 
   function_ref<void(Error)> getWarningHandler() { return WarningHandler; }
 
   enum class ProcessDebugRelocations { Process, Ignore };
 
public:
   static std::unique_ptr<DWARFContext>
   create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
          uint8_t AddrSize, bool isLittleEndian = sys::IsLittleEndianHost,
          std::function<void(Error)> RecoverableErrorHandler =
              WithColor::defaultErrorHandler,
          std::function<void(Error)> WarningHandler =
              WithColor::defaultWarningHandler);
 
-  /// Loads register info for the architecture of the provided object file.
-  /// Improves readability of dumped DWARF expressions. Requires the caller to
-  /// have initialized the relevant target descriptions.
-  Error loadRegisterInfo(const object::ObjectFile &Obj);
-
   /// Get address size from CUs.
   /// TODO: refactor compile_units() to make this const.
   uint8_t getCUAddrSize();
 
   Triple::ArchType getArch() const {
     return getDWARFObj().getFile()->getArch();
   }
 

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugFrame.h

public:
   ///
   /// \param MRI register information that helps emit register names insteead
   /// of raw register numbers.
   ///
   /// \param IsEH true if the DWARF Call Frame Information is from .eh_frame
   /// instead of from .debug_frame. This is needed for register number
   /// conversion because some register numbers differ between the two sections
   /// for certain architectures like x86.
-  void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const;
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const;
 
   bool operator==(const UnwindLocation &RHS) const;
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const UnwindLocation &R);
 
 /// A class that can track all registers with locations in a UnwindRow object.
 ///
 /// Register locations use a map where the key is the register number and the
 /// the value is a UnwindLocation.
public:
   ///
   /// \param MRI register information that helps emit register names insteead
   /// of raw register numbers.
   ///
   /// \param IsEH true if the DWARF Call Frame Information is from .eh_frame
   /// instead of from .debug_frame. This is needed for register number
   /// conversion because some register numbers differ between the two sections
   /// for certain architectures like x86.
-  void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH) const;
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const;
 
   /// Returns true if we have any register locations in this object.
   bool hasLocations() const { return !Locations.empty(); }
 
   size_t size() const { return Locations.size(); }
 
   bool operator==(const RegisterLocations &RHS) const {
     return Locations == RHS.Locations;
   }
public:
   ///
   /// \param IsEH true if the DWARF Call Frame Information is from .eh_frame
   /// instead of from .debug_frame. This is needed for register number
   /// conversion because some register numbers differ between the two sections
   /// for certain architectures like x86.
   ///
   /// \param IndentLevel specify the indent level as an integer. The UnwindRow
   /// will be output to the stream preceded by 2 * IndentLevel number of spaces.
-  void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts,
             unsigned IndentLevel = 0) const;
 };
 
 raw_ostream &operator<<(raw_ostream &OS, const UnwindRow &Row);
 
 class CFIProgram;
 class CIE;
 class FDE;
 
public:
   ///
   /// \param IsEH true if the DWARF Call Frame Information is from .eh_frame
   /// instead of from .debug_frame. This is needed for register number
   /// conversion because some register numbers differ between the two sections
   /// for certain architectures like x86.
   ///
   /// \param IndentLevel specify the indent level as an integer. The UnwindRow
   /// will be output to the stream preceded by 2 * IndentLevel number of spaces.
-  void dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts,
             unsigned IndentLevel = 0) const;
 
   /// Create an UnwindTable from a Common Information Entry (CIE).
   ///
   /// \param Cie The Common Information Entry to extract the table from. The
   /// CFIProgram is retrieved from the \a Cie object and used to create the
   /// UnwindTable.
   ///
   /// \returns An error if the DWARF Call Frame Information opcodes have state
CFIProgram(uint64_t CodeAlignmentFactor, int64_t DataAlignmentFactor,
         Arch(Arch) {}
 
   /// Parse and store a sequence of CFI instructions from Data,
   /// starting at *Offset and ending at EndOffset. *Offset is updated
   /// to EndOffset upon successful parsing, or indicates the offset
   /// where a problem occurred in case an error is returned.
   Error parse(DWARFDataExtractor Data, uint64_t *Offset, uint64_t EndOffset);
 
-  void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI,
-            bool IsEH, unsigned IndentLevel = 1) const;
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts,
+            unsigned IndentLevel = 1) const;
 
   void addInstruction(const Instruction &I) { Instructions.push_back(I); }
 
   /// Get a DWARF CFI call frame string for the given DW_CFA opcode.
   StringRef callFrameString(unsigned Opcode) const;
 
 private:
   std::vector<Instruction> Instructions;
   const uint64_t CodeAlignmentFactor;
private:
   static const char *operandTypeString(OperandType OT);
 
   /// Retrieve the array describing the types of operands according to the enum
   /// above. This is indexed by opcode.
   static ArrayRef<OperandType[MaxOperands]> getOperandTypes();
 
   /// Print \p Opcode's operand number \p OperandIdx which has value \p Operand.
   void printOperand(raw_ostream &OS, DIDumpOptions DumpOpts,
-                    const MCRegisterInfo *MRI, bool IsEH,
                     const Instruction &Instr, unsigned OperandIdx,
                     uint64_t Operand) const;
 };
 
 /// An entry in either debug_frame or eh_frame. This entry can be a CIE or an
 /// FDE.
 class FrameEntry {
 public:
   enum FrameKind { FK_CIE, FK_FDE };
 
   FrameEntry(FrameKind K, bool IsDWARF64, uint64_t Offset, uint64_t Length,
              uint64_t CodeAlign, int64_t DataAlign, Triple::ArchType Arch)
       : Kind(K), IsDWARF64(IsDWARF64), Offset(Offset), Length(Length),
         CFIs(CodeAlign, DataAlign, Arch) {}
 
   virtual ~FrameEntry() = default;
 
   FrameKind getKind() const { return Kind; }
   uint64_t getOffset() const { return Offset; }
   uint64_t getLength() const { return Length; }
   const CFIProgram &cfis() const { return CFIs; }
   CFIProgram &cfis() { return CFIs; }
 
   /// Dump the instructions in this CFI fragment
-  virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts,
-                    const MCRegisterInfo *MRI, bool IsEH) const = 0;
+  virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const = 0;
 
 protected:
   const FrameKind Kind;
 
   const bool IsDWARF64;
 
   /// Offset of this entry in the section.
   const uint64_t Offset;
public:
   std::optional<uint32_t> getPersonalityEncoding() const {
     return PersonalityEnc;
   }
 
   uint32_t getFDEPointerEncoding() const { return FDEPointerEncoding; }
 
   uint32_t getLSDAPointerEncoding() const { return LSDAPointerEncoding; }
 
-  void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI,
-            bool IsEH) const override;
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const override;
 
 private:
   /// The following fields are defined in section 6.4.1 of the DWARF standard v4
   const uint8_t Version;
   const SmallString<8> Augmentation;
   const uint8_t AddressSize;
   const uint8_t SegmentDescriptorSize;
   const uint64_t CodeAlignmentFactor;
public:
 
   ~FDE() override = default;
 
   const CIE *getLinkedCIE() const { return LinkedCIE; }
   uint64_t getInitialLocation() const { return InitialLocation; }
   uint64_t getAddressRange() const { return AddressRange; }
   std::optional<uint64_t> getLSDAAddress() const { return LSDAAddress; }
 
-  void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI,
-            bool IsEH) const override;
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts) const override;
 
   static bool classof(const FrameEntry *FE) { return FE->getKind() == FK_FDE; }
 
 private:
   /// The following fields are defined in section 6.4.1 of the DWARFv3 standard.
   /// Note that CIE pointers in EH FDEs, unlike DWARF FDEs, contain relative
   /// offsets to the linked CIEs. See the following link for more info:
   /// https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
public:
   // it is a .debug_frame section. EHFrameAddress should be different
   // than zero for correct parsing of .eh_frame addresses when they
   // use a PC-relative encoding.
   DWARFDebugFrame(Triple::ArchType Arch,
                   bool IsEH = false, uint64_t EHFrameAddress = 0);
   ~DWARFDebugFrame();
 
   /// Dump the section data into the given stream.
-  void dump(raw_ostream &OS, DIDumpOptions DumpOpts, const MCRegisterInfo *MRI,
+  void dump(raw_ostream &OS, DIDumpOptions DumpOpts,
             std::optional<uint64_t> Offset) const;
 
   /// Parse the section from raw data. \p Data is assumed to contain the whole
   /// frame section contents to be parsed.
   Error parse(DWARFDataExtractor Data);
 
   /// Return whether the section has any entries.
   bool empty() const { return Entries.empty(); }

llvm/include/llvm/DebugInfo/DWARF/DWARFDebugLoc.h

virtual Error visitLocationList(
       function_ref<bool(const DWARFLocationEntry &)> Callback) const = 0;
 
   /// Dump the location list at the given \p Offset. The function returns true
   /// iff it has successfully reched the end of the list. This means that one
   /// can attempt to parse another list after the current one (\p Offset will be
   /// updated to point past the end of the current list).
   bool dumpLocationList(uint64_t *Offset, raw_ostream &OS,
                         std::optional<object::SectionedAddress> BaseAddr,
-                        const MCRegisterInfo *MRI, const DWARFObject &Obj,
-                        DWARFUnit *U, DIDumpOptions DumpOpts,
-                        unsigned Indent) const;
+                        const DWARFObject &Obj, DWARFUnit *U,
+                        DIDumpOptions DumpOpts, unsigned Indent) const;
 
   Error visitAbsoluteLocationList(
       uint64_t Offset, std::optional<object::SectionedAddress> BaseAddr,
       std::function<std::optional<object::SectionedAddress>(uint32_t)>
           LookupAddr,
       function_ref<bool(Expected<DWARFLocationExpression>)> Callback) const;
 
   const DWARFDataExtractor &getData() { return Data; }
private:
   /// the locations in which the variable is stored.
   LocationLists Locations;
 
 public:
   DWARFDebugLoc(DWARFDataExtractor Data)
       : DWARFLocationTable(std::move(Data)) {}
 
   /// Print the location lists found within the debug_loc section.
-  void dump(raw_ostream &OS, const MCRegisterInfo *RegInfo,
-            const DWARFObject &Obj, DIDumpOptions DumpOpts,
+  void dump(raw_ostream &OS, const DWARFObject &Obj, DIDumpOptions DumpOpts,
             std::optional<uint64_t> Offset) const;
 
   Error visitLocationList(
       uint64_t *Offset,
       function_ref<bool(const DWARFLocationEntry &)> Callback) const override;
 
 protected:
   void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
                     unsigned Indent, DIDumpOptions DumpOpts,
                     const DWARFObject &Obj) const override;
 };
 
 class DWARFDebugLoclists final : public DWARFLocationTable {
 public:
   DWARFDebugLoclists(DWARFDataExtractor Data, uint16_t Version)
       : DWARFLocationTable(std::move(Data)), Version(Version) {}
 
   Error visitLocationList(
       uint64_t *Offset,
       function_ref<bool(const DWARFLocationEntry &)> Callback) const override;
 
   /// Dump all location lists within the given range.
   void dumpRange(uint64_t StartOffset, uint64_t Size, raw_ostream &OS,
-                 const MCRegisterInfo *MRI, const DWARFObject &Obj,
-                 DIDumpOptions DumpOpts);
+                 const DWARFObject &Obj, DIDumpOptions DumpOpts);
 
 protected:
   void dumpRawEntry(const DWARFLocationEntry &Entry, raw_ostream &OS,
                     unsigned Indent, DIDumpOptions DumpOpts,
                     const DWARFObject &Obj) const override;
 
 private:
   uint16_t Version;

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

public:
     uint8_t getCode() const { return Opcode; }
     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, const MCRegisterInfo *RegInfo,
-               DWARFUnit *U, bool isEH) const;
+               const DWARFExpression *Expr, DWARFUnit *U) const;
 
     /// Verify \p Op. Does not affect the return of \a isError().
     static bool verify(const Operation &Op, DWARFUnit *U);
 
   private:
     bool extract(DataExtractor Data, uint8_t AddressSize, uint64_t Offset,
                  std::optional<dwarf::DwarfFormat> Format);
   };
DWARFExpression(DataExtractor Data, uint8_t AddressSize,
                   std::optional<dwarf::DwarfFormat> Format = std::nullopt)
       : Data(Data), AddressSize(AddressSize), Format(Format) {
     assert(AddressSize == 8 || AddressSize == 4 || AddressSize == 2);
   }
 
   iterator begin() const { return iterator(this, 0); }
   iterator end() const { return iterator(this, Data.getData().size()); }
 
-  void print(raw_ostream &OS, DIDumpOptions DumpOpts,
-             const MCRegisterInfo *RegInfo, DWARFUnit *U,
+  void print(raw_ostream &OS, DIDumpOptions DumpOpts, DWARFUnit *U,
              bool IsEH = false) const;
 
   /// Print the expression in a format intended to be compact and useful to a
   /// user, but not perfectly unambiguous, or capable of representing every
   /// valid DWARF expression. Returns true if the expression was sucessfully
   /// printed.
-  bool printCompact(raw_ostream &OS, const MCRegisterInfo &RegInfo);
+  bool printCompact(raw_ostream &OS,
+                    std::function<StringRef(uint64_t RegNum, bool IsEH)>
+                        GetNameForDWARFReg = nullptr);
 
   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 MCRegisterInfo *MRI, bool isEH);
+                                    const uint64_t Operands[2]);
 
 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/lib/DebugInfo/DWARF/CMakeLists.txt

add_llvm_component_library(LLVMDebugInfoDWARF
 
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo/DWARF
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/DebugInfo
 
   LINK_COMPONENTS
   BinaryFormat
   Object
-  MC
   Support
   )

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

 #include "llvm/DebugInfo/DWARF/DWARFGdbIndex.h"
 #include "llvm/DebugInfo/DWARF/DWARFListTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFRelocMap.h"
 #include "llvm/DebugInfo/DWARF/DWARFSection.h"
 #include "llvm/DebugInfo/DWARF/DWARFTypeUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnitIndex.h"
 #include "llvm/DebugInfo/DWARF/DWARFVerifier.h"
-#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/Decompressor.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/RelocationResolver.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Error.h"
case MacroDwoSection: {
     ParseAndDump(Data, /*IsMacro=*/true);
     break;
   }
   }
   return Macro;
 }
 
 static void dumpLoclistsSection(raw_ostream &OS, DIDumpOptions DumpOpts,
-                                DWARFDataExtractor Data,
-                                const MCRegisterInfo *MRI,
-                                const DWARFObject &Obj,
+                                DWARFDataExtractor Data, const DWARFObject &Obj,
                                 std::optional<uint64_t> DumpOffset) {
   uint64_t Offset = 0;
 
   while (Data.isValidOffset(Offset)) {
     DWARFListTableHeader Header(".debug_loclists", "locations");
     if (Error E = Header.extract(Data, &Offset)) {
       DumpOpts.RecoverableErrorHandler(std::move(E));
       return;
     }
 
     Header.dump(Data, OS, DumpOpts);
 
     uint64_t EndOffset = Header.length() + Header.getHeaderOffset();
     Data.setAddressSize(Header.getAddrSize());
     DWARFDebugLoclists Loc(Data, Header.getVersion());
     if (DumpOffset) {
       if (DumpOffset >= Offset && DumpOffset < EndOffset) {
         Offset = *DumpOffset;
-        Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/std::nullopt, MRI, Obj,
+        Loc.dumpLocationList(&Offset, OS, /*BaseAddr=*/std::nullopt, Obj,
                              nullptr, DumpOpts, /*Indent=*/0);
         OS << "\n";
         return;
       }
     } else {
-      Loc.dumpRange(Offset, EndOffset - Offset, OS, MRI, Obj, DumpOpts);
+      Loc.dumpRange(Offset, EndOffset - Offset, OS, Obj, DumpOpts);
     }
     Offset = EndOffset;
   }
 }
 
 static void dumpPubTableSection(raw_ostream &OS, DIDumpOptions DumpOpts,
                                 DWARFDataExtractor Data, bool GnuStyle) {
   DWARFDebugPubTable Table;
void DWARFContext::dump(
   }
 
   DIDumpOptions LLDumpOpts = DumpOpts;
   if (LLDumpOpts.Verbose)
     LLDumpOpts.DisplayRawContents = true;
 
   if (const auto *Off = shouldDump(Explicit, ".debug_loc", DIDT_ID_DebugLoc,
                                    DObj->getLocSection().Data)) {
-    getDebugLoc()->dump(OS, getRegisterInfo(), *DObj, LLDumpOpts, *Off);
+    getDebugLoc()->dump(OS, *DObj, LLDumpOpts, *Off);
   }
   if (const auto *Off =
           shouldDump(Explicit, ".debug_loclists", DIDT_ID_DebugLoclists,
                      DObj->getLoclistsSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLoclistsSection(), isLittleEndian(),
                             0);
-    dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off);
+    dumpLoclistsSection(OS, LLDumpOpts, Data, *DObj, *Off);
   }
   if (const auto *Off =
           shouldDump(ExplicitDWO, ".debug_loclists.dwo", DIDT_ID_DebugLoclists,
                      DObj->getLoclistsDWOSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLoclistsDWOSection(),
                             isLittleEndian(), 0);
-    dumpLoclistsSection(OS, LLDumpOpts, Data, getRegisterInfo(), *DObj, *Off);
+    dumpLoclistsSection(OS, LLDumpOpts, Data, *DObj, *Off);
   }
 
   if (const auto *Off =
           shouldDump(ExplicitDWO, ".debug_loc.dwo", DIDT_ID_DebugLoc,
                      DObj->getLocDWOSection().Data)) {
     DWARFDataExtractor Data(*DObj, DObj->getLocDWOSection(), isLittleEndian(),
                             4);
     DWARFDebugLoclists Loc(Data, /*Version=*/4);
     if (*Off) {
       uint64_t Offset = **Off;
       Loc.dumpLocationList(&Offset, OS,
-                           /*BaseAddr=*/std::nullopt, getRegisterInfo(), *DObj,
-                           nullptr, LLDumpOpts, /*Indent=*/0);
+                           /*BaseAddr=*/std::nullopt, *DObj, nullptr,
+                           LLDumpOpts,
+                           /*Indent=*/0);
       OS << "\n";
     } else {
-      Loc.dumpRange(0, Data.getData().size(), OS, getRegisterInfo(), *DObj,
-                    LLDumpOpts);
+      Loc.dumpRange(0, Data.getData().size(), OS, *DObj, LLDumpOpts);
     }
   }
 
   if (const std::optional<uint64_t> *Off =
           shouldDump(Explicit, ".debug_frame", DIDT_ID_DebugFrame,
                      DObj->getFrameSection().Data)) {
     if (Expected<const DWARFDebugFrame *> DF = getDebugFrame())
-      (*DF)->dump(OS, DumpOpts, getRegisterInfo(), *Off);
+      (*DF)->dump(OS, DumpOpts, *Off);
     else
       RecoverableErrorHandler(DF.takeError());
   }
 
   if (const std::optional<uint64_t> *Off =
           shouldDump(Explicit, ".eh_frame", DIDT_ID_DebugFrame,
                      DObj->getEHFrameSection().Data)) {
     if (Expected<const DWARFDebugFrame *> DF = getEHFrame())
-      (*DF)->dump(OS, DumpOpts, getRegisterInfo(), *Off);
+      (*DF)->dump(OS, DumpOpts, *Off);
     else
       RecoverableErrorHandler(DF.takeError());
   }
 
   if (shouldDump(Explicit, ".debug_macro", DIDT_ID_DebugMacro,
                  DObj->getMacroSection().Data)) {
     if (auto Macro = getDebugMacro())
       Macro->dump(OS);
DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
                      std::function<void(Error)> RecoverableErrorHandler,
                      std::function<void(Error)> WarningHandler) {
   auto DObj =
       std::make_unique<DWARFObjInMemory>(Sections, AddrSize, isLittleEndian);
   return std::make_unique<DWARFContext>(
       std::move(DObj), "", RecoverableErrorHandler, WarningHandler);
 }
 
-Error DWARFContext::loadRegisterInfo(const object::ObjectFile &Obj) {
-  // Detect the architecture from the object file. We usually don't need OS
-  // info to lookup a target and create register info.
-  Triple TT;
-  TT.setArch(Triple::ArchType(Obj.getArch()));
-  TT.setVendor(Triple::UnknownVendor);
-  TT.setOS(Triple::UnknownOS);
-  std::string TargetLookupError;
-  const Target *TheTarget =
-      TargetRegistry::lookupTarget(TT.str(), TargetLookupError);
-  if (!TargetLookupError.empty())
-    return createStringError(errc::invalid_argument,
-                             TargetLookupError.c_str());
-  RegInfo.reset(TheTarget->createMCRegInfo(TT.str()));
-  return Error::success();
-}
-
 uint8_t DWARFContext::getCUAddrSize() {
   // In theory, different compile units may have different address byte
   // sizes, but for simplicity we just use the address byte size of the
   // first compile unit. In practice the address size field is repeated across
   // various DWARF headers (at least in version 5) to make it easier to dump
   // them independently, not to enable varying the address size.
   auto CUs = compile_units();
   return CUs.empty() ? 0 : (*CUs.begin())->getAddressByteSize();
 }

llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

 //===- DWARFDebugFrame.h - Parsing of .debug_frame ------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFDebugFrame.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFDataExtractor.h"
-#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/DataExtractor.h"
 #include "llvm/Support/Errc.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/raw_ostream.h"
 #include <algorithm>
 #include <cassert>
 #include <cinttypes>
 #include <cstdint>
 #include <optional>
 
 using namespace llvm;
 using namespace dwarf;
 
-static void printRegister(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
+static void printRegister(raw_ostream &OS, DIDumpOptions DumpOpts,
                           unsigned RegNum) {
-  if (MRI) {
-    if (std::optional<unsigned> LLVMRegNum = MRI->getLLVMRegNum(RegNum, IsEH)) {
-      if (const char *RegName = MRI->getName(*LLVMRegNum)) {
-        OS << RegName;
-        return;
-      }
-    }
-  }
+  if (DumpOpts.GetNameForDWARFReg) {
+    auto RegName = DumpOpts.GetNameForDWARFReg(RegNum, DumpOpts.IsEH);
+    if (!RegName.empty()) {
   OS << "reg" << RegNum;
 }
 
 UnwindLocation UnwindLocation::createUnspecified() { return {Unspecified}; }
 
 UnwindLocation UnwindLocation::createUndefined() { return {Undefined}; }
 
 UnwindLocation UnwindLocation::createSame() { return {Same}; }

 UnwindLocation UnwindLocation::createIsDWARFExpression(DWARFExpression Expr) {
   return {Expr, false};
 }
 
 UnwindLocation UnwindLocation::createAtDWARFExpression(DWARFExpression Expr) {
   return {Expr, true};
 }
 
-void UnwindLocation::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
-                          bool IsEH) const {
+void UnwindLocation::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   if (Dereference)
     OS << '[';
   switch (Kind) {
   case Unspecified:
     OS << "unspecified";
     break;
   case Undefined:
     OS << "undefined";
     break;
   case Same:
     OS << "same";
     break;
   case CFAPlusOffset:
     OS << "CFA";
     if (Offset == 0)
       break;
     if (Offset > 0)
       OS << "+";
     OS << Offset;
     break;
   case RegPlusOffset:
-    printRegister(OS, MRI, IsEH, RegNum);
+    printRegister(OS, DumpOpts, RegNum);
     if (Offset == 0 && !AddrSpace)
       break;
     if (Offset >= 0)
       OS << "+";
     OS << Offset;
     if (AddrSpace)
       OS << " in addrspace" << *AddrSpace;
     break;
-  case DWARFExpr:
-    Expr->print(OS, DIDumpOptions(), MRI, nullptr, IsEH);
+  case DWARFExpr: {
+    Expr->print(OS, DumpOpts, nullptr);
     break;
+  }
   case Constant:
     OS << Offset;
     break;
   }
   if (Dereference)
     OS << ']';
 }
 
 raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS,
                                      const UnwindLocation &UL) {
-  UL.dump(OS, nullptr, false);
+  auto DumpOpts = DIDumpOptions();
+  UL.dump(OS, DumpOpts);
   return OS;
 }
 
 bool UnwindLocation::operator==(const UnwindLocation &RHS) const {
   if (Kind != RHS.Kind)
     return false;
   switch (Kind) {
   case Unspecified:
   case Undefined:
   case Same:
     return true;
   case CFAPlusOffset:
     return Offset == RHS.Offset && Dereference == RHS.Dereference;
   case RegPlusOffset:
     return RegNum == RHS.RegNum && Offset == RHS.Offset &&
            Dereference == RHS.Dereference;
   case DWARFExpr:
     return *Expr == *RHS.Expr && Dereference == RHS.Dereference;
   case Constant:
     return Offset == RHS.Offset;
   }
   return false;
 }
 
-void RegisterLocations::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
-                             bool IsEH) const {
+void RegisterLocations::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   bool First = true;
   for (const auto &RegLocPair : Locations) {
     if (First)
       First = false;
     else
       OS << ", ";
-    printRegister(OS, MRI, IsEH, RegLocPair.first);
+    printRegister(OS, DumpOpts, RegLocPair.first);
     OS << '=';
-    RegLocPair.second.dump(OS, MRI, IsEH);
+    RegLocPair.second.dump(OS, DumpOpts);
   }
 }
 
 raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS,
                                      const RegisterLocations &RL) {
-  RL.dump(OS, nullptr, false);
+  auto DumpOpts = DIDumpOptions();
+  RL.dump(OS, DumpOpts);
   return OS;
 }
 
-void UnwindRow::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
+void UnwindRow::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
                      unsigned IndentLevel) const {
   OS.indent(2 * IndentLevel);
   if (hasAddress())
     OS << format("0x%" PRIx64 ": ", *Address);
   OS << "CFA=";
-  CFAValue.dump(OS, MRI, IsEH);
+  CFAValue.dump(OS, DumpOpts);
   if (RegLocs.hasLocations()) {
     OS << ": ";
-    RegLocs.dump(OS, MRI, IsEH);
+    RegLocs.dump(OS, DumpOpts);
   }
   OS << "\n";
 }
 
 raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS, const UnwindRow &Row) {
-  Row.dump(OS, nullptr, false, 0);
+  auto DumpOpts = DIDumpOptions();
+  Row.dump(OS, DumpOpts, 0);
   return OS;
 }
 
-void UnwindTable::dump(raw_ostream &OS, const MCRegisterInfo *MRI, bool IsEH,
+void UnwindTable::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
                        unsigned IndentLevel) const {
   for (const UnwindRow &Row : Rows)
-    Row.dump(OS, MRI, IsEH, IndentLevel);
+    Row.dump(OS, DumpOpts, IndentLevel);
 }
 
 raw_ostream &llvm::dwarf::operator<<(raw_ostream &OS, const UnwindTable &Rows) {
-  Rows.dump(OS, nullptr, false, 0);
+  auto DumpOpts = DIDumpOptions();
+  Rows.dump(OS, DumpOpts, 0);
   return OS;
 }
 
 Expected<UnwindTable> UnwindTable::create(const FDE *Fde) {
   const CIE *Cie = Fde->getLinkedCIE();
   if (Cie == nullptr)
     return createStringError(errc::invalid_argument,
                              "unable to get CIE for FDE at offset 0x%" PRIx64,

 #undef DECLARE_OP1
 #undef DECLARE_OP2
 
   return ArrayRef<OperandType[MaxOperands]>(&OpTypes[0], DW_CFA_restore + 1);
 }
 
 /// Print \p Opcode's operand number \p OperandIdx which has value \p Operand.
 void CFIProgram::printOperand(raw_ostream &OS, DIDumpOptions DumpOpts,
-                              const MCRegisterInfo *MRI, bool IsEH,
                               const Instruction &Instr, unsigned OperandIdx,
                               uint64_t Operand) const {
   assert(OperandIdx < MaxOperands);
   uint8_t Opcode = Instr.Opcode;
   OperandType Type = getOperandTypes()[Opcode][OperandIdx];
 
   switch (Type) {
   case OT_Unset: {
void CFIProgram::printOperand(raw_ostream &OS, DIDumpOptions DumpOpts,
   case OT_UnsignedFactDataOffset:
     if (DataAlignmentFactor)
       OS << format(" %" PRId64, Operand * DataAlignmentFactor);
     else
       OS << format(" %" PRId64 "*data_alignment_factor" , Operand);
     break;
   case OT_Register:
     OS << ' ';
-    printRegister(OS, MRI, IsEH, Operand);
+    printRegister(OS, DumpOpts, Operand);
     break;
   case OT_AddressSpace:
     OS << format(" in addrspace%" PRId64, Operand);
     break;
   case OT_Expression:
     assert(Instr.Expression && "missing DWARFExpression object");
     OS << " ";
-    Instr.Expression->print(OS, DumpOpts, MRI, nullptr, IsEH);
+    Instr.Expression->print(OS, DumpOpts, nullptr);
     break;
   }
 }
 
 void CFIProgram::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
-                      const MCRegisterInfo *MRI, bool IsEH,
                       unsigned IndentLevel) const {
   for (const auto &Instr : Instructions) {
     uint8_t Opcode = Instr.Opcode;
     OS.indent(2 * IndentLevel);
     OS << callFrameString(Opcode) << ":";
     for (unsigned i = 0; i < Instr.Ops.size(); ++i)
-      printOperand(OS, DumpOpts, MRI, IsEH, Instr, i, Instr.Ops[i]);
+      printOperand(OS, DumpOpts, Instr, i, Instr.Ops[i]);
     OS << '\n';
   }
 }
 
 // Returns the CIE identifier to be used by the requested format.
 // CIE ids for .debug_frame sections are defined in Section 7.24 of DWARFv5.
 // For CIE ID in .eh_frame sections see
 // https://refspecs.linuxfoundation.org/LSB_5.0.0/LSB-Core-generic/LSB-Core-generic/ehframechpt.html
 constexpr uint64_t getCIEId(bool IsDWARF64, bool IsEH) {
   if (IsEH)
     return 0;
   if (IsDWARF64)
     return DW64_CIE_ID;
   return DW_CIE_ID;
 }
 
-void CIE::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
-               const MCRegisterInfo *MRI, bool IsEH) const {
+void CIE::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   // A CIE with a zero length is a terminator entry in the .eh_frame section.
-  if (IsEH && Length == 0) {
+  if (DumpOpts.IsEH && Length == 0) {
     OS << format("%08" PRIx64, Offset) << " ZERO terminator\n";
     return;
   }
 
   OS << format("%08" PRIx64, Offset)
      << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length)
-     << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8,
-               getCIEId(IsDWARF64, IsEH))
+     << format(" %0*" PRIx64, IsDWARF64 && !DumpOpts.IsEH ? 16 : 8,
+               getCIEId(IsDWARF64, DumpOpts.IsEH))
      << " CIE\n"
      << "  Format:                " << FormatString(IsDWARF64) << "\n";
-  if (IsEH && Version != 1)
+  if (DumpOpts.IsEH && Version != 1)
     OS << "WARNING: unsupported CIE version\n";
   OS << format("  Version:               %d\n", Version)
      << "  Augmentation:          \"" << Augmentation << "\"\n";
   if (Version >= 4) {
     OS << format("  Address size:          %u\n", (uint32_t)AddressSize);
     OS << format("  Segment desc size:     %u\n",
                  (uint32_t)SegmentDescriptorSize);
   }
   OS << format("  Code alignment factor: %u\n", (uint32_t)CodeAlignmentFactor);
   OS << format("  Data alignment factor: %d\n", (int32_t)DataAlignmentFactor);
   OS << format("  Return address column: %d\n", (int32_t)ReturnAddressRegister);
   if (Personality)
     OS << format("  Personality Address: %016" PRIx64 "\n", *Personality);
   if (!AugmentationData.empty()) {
     OS << "  Augmentation data:    ";
     for (uint8_t Byte : AugmentationData)
       OS << ' ' << hexdigit(Byte >> 4) << hexdigit(Byte & 0xf);
     OS << "\n";
   }
   OS << "\n";
-  CFIs.dump(OS, DumpOpts, MRI, IsEH);
+  CFIs.dump(OS, DumpOpts);
   OS << "\n";
 
   if (Expected<UnwindTable> RowsOrErr = UnwindTable::create(this))
-    RowsOrErr->dump(OS, MRI, IsEH, 1);
+    RowsOrErr->dump(OS, DumpOpts, 1);
   else {
     DumpOpts.RecoverableErrorHandler(joinErrors(
         createStringError(errc::invalid_argument,
                           "decoding the CIE opcodes into rows failed"),
         RowsOrErr.takeError()));
   }
   OS << "\n";
 }
 
-void FDE::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
-               const MCRegisterInfo *MRI, bool IsEH) const {
+void FDE::dump(raw_ostream &OS, DIDumpOptions DumpOpts) const {
   OS << format("%08" PRIx64, Offset)
      << format(" %0*" PRIx64, IsDWARF64 ? 16 : 8, Length)
-     << format(" %0*" PRIx64, IsDWARF64 && !IsEH ? 16 : 8, CIEPointer)
+     << format(" %0*" PRIx64, IsDWARF64 && !DumpOpts.IsEH ? 16 : 8, CIEPointer)
      << " FDE cie=";
   if (LinkedCIE)
     OS << format("%08" PRIx64, LinkedCIE->getOffset());
   else
     OS << "<invalid offset>";
   OS << format(" pc=%08" PRIx64 "...%08" PRIx64 "\n", InitialLocation,
                InitialLocation + AddressRange);
   OS << "  Format:       " << FormatString(IsDWARF64) << "\n";
   if (LSDAAddress)
     OS << format("  LSDA Address: %016" PRIx64 "\n", *LSDAAddress);
-  CFIs.dump(OS, DumpOpts, MRI, IsEH);
+  CFIs.dump(OS, DumpOpts);
   OS << "\n";
 
   if (Expected<UnwindTable> RowsOrErr = UnwindTable::create(this))
-    RowsOrErr->dump(OS, MRI, IsEH, 1);
+    RowsOrErr->dump(OS, DumpOpts, 1);
   else {
     DumpOpts.RecoverableErrorHandler(joinErrors(
         createStringError(errc::invalid_argument,
                           "decoding the FDE opcodes into rows failed"),
         RowsOrErr.takeError()));
   }
   OS << "\n";
 }
auto It = partition_point(Entries, [=](const std::unique_ptr<FrameEntry> &E) {
     return E->getOffset() < Offset;
   });
   if (It != Entries.end() && (*It)->getOffset() == Offset)
     return It->get();
   return nullptr;
 }
 
 void DWARFDebugFrame::dump(raw_ostream &OS, DIDumpOptions DumpOpts,
-                           const MCRegisterInfo *MRI,
                            std::optional<uint64_t> Offset) const {
+  DumpOpts.IsEH = IsEH;
   if (Offset) {
     if (auto *Entry = getEntryAtOffset(*Offset))
-      Entry->dump(OS, DumpOpts, MRI, IsEH);
+      Entry->dump(OS, DumpOpts);
     return;
   }
 
   OS << "\n";
   for (const auto &Entry : Entries)
-    Entry->dump(OS, DumpOpts, MRI, IsEH);
+    Entry->dump(OS, DumpOpts);
 }

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

return DWARFLocationExpression{
         E.Loc};
   default:
     llvm_unreachable("unreachable locations list kind");
   }
 }
 
 static void dumpExpression(raw_ostream &OS, DIDumpOptions DumpOpts,
                            ArrayRef<uint8_t> Data, bool IsLittleEndian,
-                           unsigned AddressSize, const MCRegisterInfo *MRI,
-                           DWARFUnit *U) {
+                           unsigned AddressSize, DWARFUnit *U) {
   DWARFDataExtractor Extractor(Data, IsLittleEndian, AddressSize);
   // Note. We do not pass any format to DWARFExpression, even if the
   // corresponding unit is known. For now, there is only one operation,
   // DW_OP_call_ref, which depends on the format; it is rarely used, and
   // is unexpected in location tables.
-  DWARFExpression(Extractor, AddressSize).print(OS, DumpOpts, MRI, U);
+  DWARFExpression(Extractor, AddressSize).print(OS, DumpOpts, U);
 }
 
 bool DWARFLocationTable::dumpLocationList(
     uint64_t *Offset, raw_ostream &OS, std::optional<SectionedAddress> BaseAddr,
-    const MCRegisterInfo *MRI, const DWARFObject &Obj, DWARFUnit *U,
-    DIDumpOptions DumpOpts, unsigned Indent) const {
+    const DWARFObject &Obj, DWARFUnit *U, DIDumpOptions DumpOpts,
+    unsigned Indent) const {
   DWARFLocationInterpreter Interp(
       BaseAddr, [U](uint32_t Index) -> std::optional<SectionedAddress> {
         if (U)
           return U->getAddrOffsetSectionItem(Index);
         return std::nullopt;
       });
   OS << format("0x%8.8" PRIx64 ": ", *Offset);
   Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) {
Error E = visitLocationList(Offset, [&](const DWARFLocationEntry &E) {
     if (!Loc)
       consumeError(Loc.takeError());
 
     if (E.Kind != dwarf::DW_LLE_base_address &&
         E.Kind != dwarf::DW_LLE_base_addressx &&
         E.Kind != dwarf::DW_LLE_end_of_list) {
       OS << ": ";
       dumpExpression(OS, DumpOpts, E.Loc, Data.isLittleEndian(),
-                     Data.getAddressSize(), MRI, U);
+                     Data.getAddressSize(), U);
     }
     return true;
   });
   if (E) {
     DumpOpts.RecoverableErrorHandler(std::move(E));
     return false;
   }
   return true;
return visitLocationList(&Offset, [&](const DWARFLocationEntry &E) {
     if (!Loc)
       return Callback(Loc.takeError());
     if (*Loc)
       return Callback(**Loc);
     return true;
   });
 }
 
-void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
-                         const DWARFObject &Obj, DIDumpOptions DumpOpts,
+void DWARFDebugLoc::dump(raw_ostream &OS, const DWARFObject &Obj,
+                         DIDumpOptions DumpOpts,
                          std::optional<uint64_t> DumpOffset) const {
   auto BaseAddr = std::nullopt;
   unsigned Indent = 12;
   if (DumpOffset) {
-    dumpLocationList(&*DumpOffset, OS, BaseAddr, MRI, Obj, nullptr, DumpOpts,
+    dumpLocationList(&*DumpOffset, OS, BaseAddr, Obj, nullptr, DumpOpts,
                      Indent);
   } else {
     uint64_t Offset = 0;
     StringRef Separator;
     bool CanContinue = true;
     while (CanContinue && Data.isValidOffset(Offset)) {
       OS << Separator;
       Separator = "\n";
 
-      CanContinue = dumpLocationList(&Offset, OS, BaseAddr, MRI, Obj, nullptr,
+      CanContinue = dumpLocationList(&Offset, OS, BaseAddr, Obj, nullptr,
                                      DumpOpts, Indent);
       OS << '\n';
     }
   }
 }
 
 Error DWARFDebugLoc::visitLocationList(
     uint64_t *Offset,
case dwarf::DW_LLE_start_length:
     DWARFFormValue::dumpAddressSection(Obj, OS, DumpOpts, Entry.SectionIndex);
     break;
   default:
     break;
   }
 }
 
 void DWARFDebugLoclists::dumpRange(uint64_t StartOffset, uint64_t Size,
-                                   raw_ostream &OS, const MCRegisterInfo *MRI,
-                                   const DWARFObject &Obj,
+                                   raw_ostream &OS, const DWARFObject &Obj,
                                    DIDumpOptions DumpOpts) {
   if (!Data.isValidOffsetForDataOfSize(StartOffset, Size))  {
     OS << "Invalid dump range\n";
     return;
   }
   uint64_t Offset = StartOffset;
   StringRef Separator;
   bool CanContinue = true;
   while (CanContinue && Offset < StartOffset + Size) {
     OS << Separator;
     Separator = "\n";
 
-    CanContinue = dumpLocationList(&Offset, OS, /*BaseAddr=*/std::nullopt, MRI,
-                                   Obj, nullptr, DumpOpts, /*Indent=*/12);
+    CanContinue = dumpLocationList(&Offset, OS, /*BaseAddr=*/std::nullopt, Obj,
+                                   nullptr, DumpOpts, /*Indent=*/12);
     OS << '\n';
   }
 }
 
 void llvm::ResolverError::log(raw_ostream &OS) const {
   OS << format("unable to resolve indirect address %u for: %s", Index,
                dwarf::LocListEncodingString(Kind).data());
 }
 
 char llvm::ResolverError::ID;

llvm/lib/DebugInfo/DWARF/DWARFDie.cpp

 }
 
 static void dumpLocationList(raw_ostream &OS, const DWARFFormValue &FormValue,
                              DWARFUnit *U, unsigned Indent,
                              DIDumpOptions DumpOpts) {
   assert(FormValue.isFormClass(DWARFFormValue::FC_SectionOffset) &&
          "bad FORM for location list");
   DWARFContext &Ctx = U->getContext();
-  const MCRegisterInfo *MRI = Ctx.getRegisterInfo();
   uint64_t Offset = *FormValue.getAsSectionOffset();
 
   if (FormValue.getForm() == DW_FORM_loclistx) {
     FormValue.dump(OS, DumpOpts);
 
     if (auto LoclistOffset = U->getLoclistOffset(Offset))
       Offset = *LoclistOffset;
     else
       return;
   }
-  U->getLocationTable().dumpLocationList(&Offset, OS, U->getBaseAddress(), MRI,
-                                         Ctx.getDWARFObj(), U, DumpOpts,
-                                         Indent);
+  U->getLocationTable().dumpLocationList(
+      &Offset, OS, U->getBaseAddress(), Ctx.getDWARFObj(), U, DumpOpts, Indent);
 }
 
 static void dumpLocationExpr(raw_ostream &OS, const DWARFFormValue &FormValue,
                              DWARFUnit *U, unsigned Indent,
                              DIDumpOptions DumpOpts) {
   assert((FormValue.isFormClass(DWARFFormValue::FC_Block) ||
           FormValue.isFormClass(DWARFFormValue::FC_Exprloc)) &&
          "bad FORM for location expression");
   DWARFContext &Ctx = U->getContext();
-  const MCRegisterInfo *MRI = Ctx.getRegisterInfo();
   ArrayRef<uint8_t> Expr = *FormValue.getAsBlock();
   DataExtractor Data(StringRef((const char *)Expr.data(), Expr.size()),
                      Ctx.isLittleEndian(), 0);
   DWARFExpression(Data, U->getAddressByteSize(), U->getFormParams().Format)
-      .print(OS, DumpOpts, MRI, U);
+      .print(OS, DumpOpts, U);
 }
 
 static DWARFDie resolveReferencedType(DWARFDie D, DWARFFormValue F) {
   return D.getAttributeValueAsReferencedDie(F).resolveTypeUnitReference();
 }
 
 static void dumpAttribute(raw_ostream &OS, const DWARFDie &Die,
                           const DWARFAttribute &AttrValue, unsigned Indent,

llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp

 //===-- DWARFExpression.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/DWARF/DWARFExpression.h"
 #include "llvm/DebugInfo/DWARF/DWARFUnit.h"
-#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/Support/Format.h"
 #include <cassert>
 #include <cstdint>
 #include <vector>
 
 using namespace llvm;
 using namespace dwarf;
 
if (Die && Die.getTag() == dwarf::DW_TAG_base_type) {
     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], const MCRegisterInfo *MRI, bool isEH) {
-  if (!MRI)
+bool DWARFExpression::prettyPrintRegisterOp(DWARFUnit *U, raw_ostream &OS,
+                                            DIDumpOptions DumpOpts,
+                                            uint8_t Opcode,
+                                            const uint64_t Operands[2]) {
+  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)
     DwarfRegNum = Operands[OpNum++];
   else if (Opcode >= DW_OP_breg0 && Opcode < DW_OP_bregx)
     DwarfRegNum = Opcode - DW_OP_breg0;
   else
     DwarfRegNum = Opcode - DW_OP_reg0;
 
-  if (std::optional<unsigned> LLVMRegNum =
-          MRI->getLLVMRegNum(DwarfRegNum, isEH)) {
-    if (const char *RegName = MRI->getName(*LLVMRegNum)) {
-      if ((Opcode >= DW_OP_breg0 && Opcode <= DW_OP_breg31) ||
-          Opcode == DW_OP_bregx)
-        OS << format(" %s%+" PRId64, RegName, Operands[OpNum]);
-      else
-        OS << ' ' << RegName;
+  auto RegName = DumpOpts.GetNameForDWARFReg(DwarfRegNum, DumpOpts.IsEH);
+  if (!RegName.empty()) {
+      OS << ' ' << RegName << format("%+" PRId64, Operands[OpNum]);
+      OS << ' ' << RegName.data();
 
-      if (Opcode == DW_OP_regval_type)
-        prettyPrintBaseTypeRef(U, OS, DumpOpts, Operands, 1);
-      return true;
-    }
-  }
 
   return false;
 }
 
 bool DWARFExpression::Operation::print(raw_ostream &OS, DIDumpOptions DumpOpts,
                                        const DWARFExpression *Expr,
-                                       const MCRegisterInfo *RegInfo,
-                                       DWARFUnit *U, bool isEH) const {
+                                       DWARFUnit *U) const {
   if (Error) {
     OS << "<decoding error>";
     return false;
   }
 
   StringRef Name = OperationEncodingString(Opcode);
   assert(!Name.empty() && "DW_OP has no name!");
   OS << Name;
 
   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, RegInfo, isEH))
+    if (prettyPrintRegisterOp(U, OS, DumpOpts, Opcode, Operands))
       return true;
 
   for (unsigned Operand = 0; Operand < 2; ++Operand) {
     unsigned Size = Desc.Op[Operand];
     unsigned Signed = Size & Operation::SignBit;
 
     if (Size == Operation::SizeNA)
       break;
if (Size == Operation::BaseTypeRef && U) {
                Opcode != DW_OP_GNU_entry_value)
         OS << format(" 0x%" PRIx64, Operands[Operand]);
     }
   }
   return true;
 }
 
 void DWARFExpression::print(raw_ostream &OS, DIDumpOptions DumpOpts,
-                            const MCRegisterInfo *RegInfo, DWARFUnit *U,
-                            bool IsEH) const {
+                            DWARFUnit *U, bool IsEH) const {
   uint32_t EntryValExprSize = 0;
   uint64_t EntryValStartOffset = 0;
   if (Data.getData().empty())
     OS << "<empty>";
 
   for (auto &Op : *this) {
-    if (!Op.print(OS, DumpOpts, this, RegInfo, U, IsEH)) {
+    DumpOpts.IsEH = IsEH;
+    if (!Op.print(OS, DumpOpts, this, U)) {
       uint64_t FailOffset = Op.getEndOffset();
       while (FailOffset < Data.getData().size())
         OS << format(" %02x", Data.getU8(&FailOffset));
       return;
     }
 
     if (Op.getCode() == DW_OP_entry_value ||
         Op.getCode() == DW_OP_GNU_entry_value) {
enum ExprKind {
     Value,
   };
   ExprKind Kind;
   SmallString<16> String;
 
   PrintedExpr(ExprKind K = Address) : Kind(K) {}
 };
 
-static bool printCompactDWARFExpr(raw_ostream &OS, DWARFExpression::iterator I,
-                                  const DWARFExpression::iterator E,
-                                  const MCRegisterInfo &MRI) {
+static bool printCompactDWARFExpr(
+    raw_ostream &OS, DWARFExpression::iterator I,
+    std::function<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg =
+        nullptr) {
   SmallVector<PrintedExpr, 4> Stack;
 
   while (I != E) {
     const DWARFExpression::Operation &Op = *I;
     uint8_t Opcode = Op.getCode();
     switch (Opcode) {
     case dwarf::DW_OP_regx: {
       // DW_OP_regx: A register, with the register num given as an operand.
       // Printed as the plain register name.
       uint64_t DwarfRegNum = Op.getRawOperand(0);
-      std::optional<unsigned> LLVMRegNum =
-          MRI.getLLVMRegNum(DwarfRegNum, false);
-      if (!LLVMRegNum) {
-        OS << "<unknown register " << DwarfRegNum << ">";
+      auto RegName = GetNameForDWARFReg(DwarfRegNum, false);
+      if (RegName.empty())
         return false;
-      }
       raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String);
-      S << MRI.getName(*LLVMRegNum);
+      S << RegName;
       break;
     }
     case dwarf::DW_OP_bregx: {
       int DwarfRegNum = Op.getRawOperand(0);
       int64_t Offset = Op.getRawOperand(1);
-      std::optional<unsigned> LLVMRegNum =
-          MRI.getLLVMRegNum(DwarfRegNum, false);
-      if (!LLVMRegNum) {
-        OS << "<unknown register " << DwarfRegNum << ">";
+      auto RegName = GetNameForDWARFReg(DwarfRegNum, false);
+      if (RegName.empty())
         return false;
-      }
       raw_svector_ostream S(Stack.emplace_back().String);
-      S << MRI.getName(*LLVMRegNum);
+      S << RegName;
       if (Offset)
         S << format("%+" PRId64, Offset);
       break;
     }
     case dwarf::DW_OP_entry_value:
     case dwarf::DW_OP_GNU_entry_value: {
       // DW_OP_entry_value contains a sub-expression which must be rendered
       // separately.
       uint64_t SubExprLength = Op.getRawOperand(0);
       DWARFExpression::iterator SubExprEnd = I.skipBytes(SubExprLength);
       ++I;
       raw_svector_ostream S(Stack.emplace_back().String);
       S << "entry(";
-      printCompactDWARFExpr(S, I, SubExprEnd, MRI);
+      printCompactDWARFExpr(S, I, SubExprEnd, GetNameForDWARFReg);
       S << ")";
       I = SubExprEnd;
       continue;
     }
     case dwarf::DW_OP_stack_value: {
       // The top stack entry should be treated as the actual value of tne
       // variable, rather than the address of the variable in memory.
       assert(!Stack.empty());
       Stack.back().Kind = PrintedExpr::Value;
       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;
-        std::optional<unsigned> LLVMRegNum =
-            MRI.getLLVMRegNum(DwarfRegNum, false);
-        if (!LLVMRegNum) {
-          OS << "<unknown register " << DwarfRegNum << ">";
+        auto RegName = GetNameForDWARFReg(DwarfRegNum, false);
+        if (RegName.empty())
           return false;
-        }
         raw_svector_ostream S(Stack.emplace_back(PrintedExpr::Value).String);
-        S << MRI.getName(*LLVMRegNum);
+        S << RegName;
       } else if (Opcode >= dwarf::DW_OP_breg0 &&
                  Opcode <= dwarf::DW_OP_breg31) {
         int DwarfRegNum = Opcode - dwarf::DW_OP_breg0;
         int64_t Offset = Op.getRawOperand(0);
-        std::optional<unsigned> LLVMRegNum =
-            MRI.getLLVMRegNum(DwarfRegNum, false);
-        if (!LLVMRegNum) {
-          OS << "<unknown register " << DwarfRegNum << ">";
+        auto RegName = GetNameForDWARFReg(DwarfRegNum, false);
+        if (RegName.empty())
           return false;
-        }
         raw_svector_ostream S(Stack.emplace_back().String);
-        S << MRI.getName(*LLVMRegNum);
+        S << RegName;
         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;
       }
       break;
     }
     ++I;
   }
 
   assert(Stack.size() == 1 && "expected one value on stack");
 
   if (Stack.front().Kind == PrintedExpr::Address)
     OS << "[" << Stack.front().String << "]";
   else
     OS << Stack.front().String;
 
   return true;
 }
 
-bool DWARFExpression::printCompact(raw_ostream &OS, const MCRegisterInfo &MRI) {
-  return printCompactDWARFExpr(OS, begin(), end(), MRI);
+bool DWARFExpression::printCompact(
+    raw_ostream &OS,
+    std::function<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg) {
+  return printCompactDWARFExpr(OS, begin(), end(), GetNameForDWARFReg);
 }
 
 bool DWARFExpression::operator==(const DWARFExpression &RHS) const {
   if (AddressSize != RHS.AddressSize || Format != RHS.Format)
     return false;
   return Data.getData() == RHS.Data.getData();
 }
 
 } // namespace llvm

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

std::string LVELFReader::getRegisterName(LVSmall Opcode, uint64_t Operands[2]) {
   // 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;
   raw_string_ostream Stream(string);
   DIDumpOptions DumpOpts;
+  auto *MCRegInfo = MRI.get();
+  auto GetRegName = [&MCRegInfo](uint64_t DwarfRegNum, bool IsEH) -> StringRef {
+    if (!MCRegInfo)
+      return {};
+    if (std::optional<unsigned> LLVMRegNum =
+            MCRegInfo->getLLVMRegNum(DwarfRegNum, IsEH))
+      if (const char *RegName = MCRegInfo->getName(*LLVMRegNum))
+        return StringRef(RegName);
+    return {};
+  };
+  DumpOpts.GetNameForDWARFReg = GetRegName;
   DWARFExpression::prettyPrintRegisterOp(/*U=*/nullptr, Stream, DumpOpts,
-                                         Opcode, Operands, MRI.get(),
-                                         /*isEH=*/false);
+                                         Opcode, Operands);
   return Stream.str();
 }
 
 Error LVELFReader::createScopes() {
   LLVM_DEBUG({
     W.startLine() << "\n";
     W.printString("File", Obj.getFileName().str());
     W.printString("Format", FileFormatName);

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

 #include "llvm-dwarfdump.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/DWARF/DWARFAcceleratorTable.h"
 #include "llvm/DebugInfo/DWARF/DWARFCompileUnit.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
+#include "llvm/MC/MCRegisterInfo.h"
+#include "llvm/MC/TargetRegistry.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/Format.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
static bool filterArch(ObjectFile &Obj) {
   }
   return false;
 }
 
 using HandlerFn = std::function<bool(ObjectFile &, DWARFContext &DICtx,
                                      const Twine &, raw_ostream &)>;
 
 /// Print only DIEs that have a certain name.
-static bool filterByName(const StringSet<> &Names, DWARFDie Die,
-                         StringRef NameRef, raw_ostream &OS) {
+static bool filterByName(
+    const StringSet<> &Names, DWARFDie Die, StringRef NameRef, raw_ostream &OS,
+    std::function<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg) {
   DIDumpOptions DumpOpts = getDumpOpts(Die.getDwarfUnit()->getContext());
+  DumpOpts.GetNameForDWARFReg = GetNameForDWARFReg;
   std::string Name =
       (IgnoreCase && !UseRegex) ? NameRef.lower() : NameRef.str();
   if (UseRegex) {
     // Match regular expression.
     for (auto Pattern : Names.keys()) {
       Regex RE(Pattern, IgnoreCase ? Regex::IgnoreCase : Regex::NoFlags);
       std::string Error;
       if (!RE.isValid(Error)) {
if (UseRegex) {
     // Match full text.
     Die.dump(OS, 0, DumpOpts);
     return true;
   }
   return false;
 }
 
 /// Print only DIEs that have a certain name.
-static void filterByName(const StringSet<> &Names,
-                         DWARFContext::unit_iterator_range CUs,
-                         raw_ostream &OS) {
+static void filterByName(
+    const StringSet<> &Names, DWARFContext::unit_iterator_range CUs,
+    raw_ostream &OS,
+    std::function<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg) {
   for (const auto &CU : CUs)
     for (const auto &Entry : CU->dies()) {
       DWARFDie Die = {CU.get(), &Entry};
       if (const char *Name = Die.getName(DINameKind::ShortName))
-        if (filterByName(Names, Die, Name, OS))
+        if (filterByName(Names, Die, Name, OS, GetNameForDWARFReg))
           continue;
       if (const char *Name = Die.getName(DINameKind::LinkageName))
-        filterByName(Names, Die, Name, OS);
+        filterByName(Names, Die, Name, OS, GetNameForDWARFReg);
     }
 }
 
 static void getDies(DWARFContext &DICtx, const AppleAcceleratorTable &Accel,
                     StringRef Name, SmallVectorImpl<DWARFDie> &Dies) {
   for (const auto &Entry : Accel.equal_range(Name)) {
     if (std::optional<uint64_t> Off = Entry.getDIESectionOffset()) {
       if (DWARFDie Die = DICtx.getDIEForOffset(*Off))
static void getDies(DWARFContext &DICtx, const DWARFDebugNames &Accel,
                     StringRef Name, SmallVectorImpl<DWARFDie> &Dies) {
   for (const auto &Entry : Accel.equal_range(Name)) {
     if (DWARFDie Die = toDie(Entry, DICtx))
       Dies.push_back(Die);
   }
 }
 
 /// Print only DIEs that have a certain name.
-static void filterByAccelName(ArrayRef<std::string> Names, DWARFContext &DICtx,
-                              raw_ostream &OS) {
+static void filterByAccelName(
+    ArrayRef<std::string> Names, DWARFContext &DICtx, raw_ostream &OS,
+    std::function<StringRef(uint64_t RegNum, bool IsEH)> GetNameForDWARFReg) {
   SmallVector<DWARFDie, 4> Dies;
   for (const auto &Name : Names) {
     getDies(DICtx, DICtx.getAppleNames(), Name, Dies);
     getDies(DICtx, DICtx.getAppleTypes(), Name, Dies);
     getDies(DICtx, DICtx.getAppleNamespaces(), Name, Dies);
     getDies(DICtx, DICtx.getDebugNames(), Name, Dies);
   }
   llvm::sort(Dies);
   Dies.erase(std::unique(Dies.begin(), Dies.end()), Dies.end());
 
   DIDumpOptions DumpOpts = getDumpOpts(DICtx);
+  DumpOpts.GetNameForDWARFReg = GetNameForDWARFReg;
   for (DWARFDie Die : Dies)
     Die.dump(OS, 0, DumpOpts);
 }
 
 /// Handle the --lookup option and dump the DIEs and line info for the given
 /// address.
 /// TODO: specified Address for --lookup option could relate for several
 /// different sections(in case not-linked object file). llvm-dwarfdump
static bool collectObjectSources(ObjectFile &Obj, DWARFContext &DICtx,
   llvm::sort(Sources);
   Sources.erase(std::unique(Sources.begin(), Sources.end()), Sources.end());
 
   for (StringRef Name : Sources)
     OS << Name << "\n";
   return Result;
 }
 
+static std::unique_ptr<MCRegisterInfo>
+createRegInfo(const object::ObjectFile &Obj) {
+  std::unique_ptr<MCRegisterInfo> MCRegInfo;
+  Triple TT;
+  TT.setArch(Triple::ArchType(Obj.getArch()));
+  TT.setVendor(Triple::UnknownVendor);
+  TT.setOS(Triple::UnknownOS);
+  std::string TargetLookupError;
+  const Target *TheTarget =
+      TargetRegistry::lookupTarget(TT.str(), TargetLookupError);
+  if (!TargetLookupError.empty())
+    return nullptr;
+  MCRegInfo.reset(TheTarget->createMCRegInfo(TT.str()));
+  return MCRegInfo;
+}
+
 static bool dumpObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
                            const Twine &Filename, raw_ostream &OS) {
-  logAllUnhandledErrors(DICtx.loadRegisterInfo(Obj), errs(),
-                        Filename.str() + ": ");
+
+  auto MCRegInfo = createRegInfo(Obj);
+  if (!MCRegInfo)
+    logAllUnhandledErrors(createStringError(inconvertibleErrorCode(),
+                                            "Error in creating MCRegInfo"),
+                          errs(), Filename.str() + ": ");
+
+  auto GetRegName = [&MCRegInfo](uint64_t DwarfRegNum, bool IsEH) -> StringRef {
+    if (!MCRegInfo)
+      return {};
+    if (std::optional<unsigned> LLVMRegNum =
+            MCRegInfo->getLLVMRegNum(DwarfRegNum, IsEH))
+      if (const char *RegName = MCRegInfo->getName(*LLVMRegNum))
+        return StringRef(RegName);
+    return {};
+  };
+
   // The UUID dump already contains all the same information.
   if (!(DumpType & DIDT_UUID) || DumpType == DIDT_All)
     OS << Filename << ":\tfile format " << Obj.getFileFormatName() << '\n';
 
   // Handle the --lookup option.
   if (Lookup)
     return lookup(Obj, DICtx, Lookup, OS);
 
   // Handle the --name option.
   if (!Name.empty()) {
     StringSet<> Names;
     for (auto name : Name)
       Names.insert((IgnoreCase && !UseRegex) ? StringRef(name).lower() : name);
 
-    filterByName(Names, DICtx.normal_units(), OS);
-    filterByName(Names, DICtx.dwo_units(), OS);
+    filterByName(Names, DICtx.normal_units(), OS, GetRegName);
+    filterByName(Names, DICtx.dwo_units(), OS, GetRegName);
     return true;
   }
 
   // Handle the --find option and lower it to --debug-info=<offset>.
   if (!Find.empty()) {
-    filterByAccelName(Find, DICtx, OS);
+    filterByAccelName(Find, DICtx, OS, GetRegName);
     return true;
   }
 
   // Dump the complete DWARF structure.
-  DICtx.dump(OS, getDumpOpts(DICtx), DumpOffsets);
+  auto DumpOpts = getDumpOpts(DICtx);
+  DumpOpts.GetNameForDWARFReg = GetRegName;
+  DICtx.dump(OS, DumpOpts, DumpOffsets);
   return true;
 }
 
 static bool verifyObjectFile(ObjectFile &Obj, DWARFContext &DICtx,
                              const Twine &Filename, raw_ostream &OS) {
   // Verify the DWARF and exit with non-zero exit status if verification
   // fails.
   raw_ostream &stream = Quiet ? nulls() : OS;

llvm/tools/llvm-gsymutil/llvm-gsymutil.cpp

for (const object::SectionRef &Sect : Obj.sections()) {
     const uint64_t StartAddr = Sect.getAddress();
     TextRanges.insert(AddressRange(StartAddr, StartAddr + Size));
   }
 
   // Make sure there is DWARF to convert first.
   std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(Obj);
   if (!DICtx)
     return createStringError(std::errc::invalid_argument,
                              "unable to create DWARF context");
-  logAllUnhandledErrors(DICtx->loadRegisterInfo(Obj), OS, "DwarfTransformer: ");
 
   // Make a DWARF transformer object and populate the ranges of the code
   // so we don't end up adding invalid functions to GSYM data.
   DwarfTransformer DT(*DICtx, OS, Gsym);
   if (!TextRanges.empty())
     Gsym.SetValidTextRanges(TextRanges);
 
   // Convert all DWARF to GSYM.
   if (auto Err = DT.convert(ThreadCount))

llvm/tools/llvm-objdump/SourcePrinter.h

 //===-- SourcePrinter.h -  source interleaving utilities --------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TOOLS_LLVM_OBJDUMP_SOURCEPRINTER_H
 #define LLVM_TOOLS_LLVM_OBJDUMP_SOURCEPRINTER_H
 
 #include "llvm/ADT/IndexedMap.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/DebugInfo/DWARF/DWARFContext.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
+#include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/Support/FormattedStream.h"
 #include <unordered_map>
 #include <vector>
 
 namespace llvm {
 namespace objdump {
 

llvm/tools/llvm-objdump/SourcePrinter.cpp

return LocExpr.Range->SectionIndex == Addr.SectionIndex &&
          LocExpr.Range->LowPC <= Addr.Address &&
          LocExpr.Range->HighPC > Addr.Address;
 }
 
 void LiveVariable::print(raw_ostream &OS, const MCRegisterInfo &MRI) const {
   DataExtractor Data({LocExpr.Expr.data(), LocExpr.Expr.size()},
                      Unit->getContext().isLittleEndian(), 0);
   DWARFExpression Expression(Data, Unit->getAddressByteSize());
-  Expression.printCompact(OS, MRI);
+
+  auto GetRegName = [&MRI, &OS](uint64_t DwarfRegNum, bool IsEH) -> StringRef {
+    if (std::optional<unsigned> LLVMRegNum =
+            MRI.getLLVMRegNum(DwarfRegNum, IsEH))
+      if (const char *RegName = MRI.getName(*LLVMRegNum))
+        return StringRef(RegName);
+    OS << "<unknown register " << DwarfRegNum << ">";
+    return {};
+  };
+
+  Expression.printCompact(OS, GetRegName);
 }
 
 void LiveVariablePrinter::addVariable(DWARFDie FuncDie, DWARFDie VarDie) {
   uint64_t FuncLowPC, FuncHighPC, SectionIndex;
   FuncDie.getLowAndHighPC(FuncLowPC, FuncHighPC, SectionIndex);
   const char *VarName = VarDie.getName(DINameKind::ShortName);
   DWARFUnit *U = VarDie.getDwarfUnit();
 

llvm/tools/llvm-readobj/DwarfCFIEHPrinter.h

if (const dwarf::CIE *CIE = dyn_cast<dwarf::CIE>(&Entry)) {
           "address_range: 0x%" PRIx64 " (end : 0x%" PRIx64 ")\n",
           FDE->getAddressRange(),
           FDE->getInitialLocation() + FDE->getAddressRange());
     }
 
     W.getOStream() << "\n";
     W.startLine() << "Program:\n";
     W.indent();
-    Entry.cfis().dump(W.getOStream(), DIDumpOptions(), nullptr,
-                      W.getIndentLevel());
+    auto DumpOpts = DIDumpOptions();
+    DumpOpts.IsEH = true;
+    Entry.cfis().dump(W.getOStream(), DumpOpts, W.getIndentLevel());
     W.unindent();
     W.unindent();
     W.getOStream() << "\n";
   }
 
   W.unindent();
 }
 } // namespace DwarfCFIEH
 } // namespace llvm
 
 #endif

llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp

return dwarf::CIE(IsDWARF64, Offset, Length,
                     /*PersonalityEnc=*/std::nullopt,
                     /*Arch=*/Triple::x86_64);
 }
 
 void expectDumpResult(const dwarf::CIE &TestCIE, bool IsEH,
                       StringRef ExpectedFirstLine) {
   std::string Output;
   raw_string_ostream OS(Output);
-  TestCIE.dump(OS, DIDumpOptions(), /*MRI=*/nullptr, IsEH);
+  auto DumpOpts = DIDumpOptions();
+  DumpOpts.IsEH = IsEH;
+  TestCIE.dump(OS, DumpOpts);
   OS.flush();
   StringRef FirstLine = StringRef(Output).split('\n').first;
   EXPECT_EQ(FirstLine, ExpectedFirstLine);
 }
 
 void expectDumpResult(const dwarf::FDE &TestFDE, bool IsEH,
                       StringRef ExpectedFirstLine) {
   std::string Output;
   raw_string_ostream OS(Output);
-  TestFDE.dump(OS, DIDumpOptions(), /*MRI=*/nullptr, IsEH);
+  auto DumpOpts = DIDumpOptions();
+  DumpOpts.IsEH = IsEH;
+  TestFDE.dump(OS, DumpOpts);
   OS.flush();
   StringRef FirstLine = StringRef(Output).split('\n').first;
   EXPECT_EQ(FirstLine, ExpectedFirstLine);
 }
 
 TEST(DWARFDebugFrame, DumpDWARF32CIE) {
   dwarf::CIE TestCIE = createCIE(/*IsDWARF64=*/false,
                                  /*Offset=*/0x1111abcd,

llvm/unittests/DebugInfo/DWARF/DWARFExpressionCompactPrinterTest.cpp

if (!MRI)
     GTEST_SKIP();
 
   // Print the expression, passing in the subprogram DIE, and check that the
   // result is as expected.
   std::string Result;
   raw_string_ostream OS(Result);
   DataExtractor DE(ExprData, true, 8);
   DWARFExpression Expr(DE, 8);
-  Expr.printCompact(OS, *MRI);
+
+  auto GetRegName = [&](uint64_t DwarfRegNum, bool IsEH) -> StringRef {
+    if (std::optional<unsigned> LLVMRegNum =
+            this->MRI->getLLVMRegNum(DwarfRegNum, IsEH))
+      if (const char *RegName = this->MRI->getName(*LLVMRegNum))
+        return llvm::StringRef(RegName);
+    OS << "<unknown register " << DwarfRegNum << ">";
+    return {};
+  };
+
+  Expr.printCompact(OS, GetRegName);
   EXPECT_EQ(OS.str(), Expected);
 }
 
 TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_reg0) {
   TestExprPrinter({DW_OP_reg0}, "R0");
 }
 
 TEST_F(DWARFExpressionCompactPrinterTest, Test_OP_reg10) {