https://github.com/JDevlieghere updated 
https://github.com/llvm/llvm-project/pull/151056

>From c9cea26faaede58bcc8a68eb91425fda21455983 Mon Sep 17 00:00:00 2001
From: Jonas Devlieghere <jo...@devlieghere.com>
Date: Mon, 28 Jul 2025 10:38:02 -0700
Subject: [PATCH 1/3] [lldb] Support DW_OP_WASM_location in DWARFExpression

Add support for DW_OP_WASM_location in DWARFExpression. This PR rebases #78977 
and cleans up the unit test.
---
 .../include/lldb/Expression/DWARFExpression.h |  12 +-
 lldb/source/Expression/DWARFExpression.cpp    |  10 +-
 .../ObjectFile/wasm/ObjectFileWasm.cpp        |   6 +-
 .../Plugins/SymbolFile/DWARF/CMakeLists.txt   |   1 +
 .../Plugins/SymbolFile/DWARF/DWARFUnit.cpp    |   4 +-
 .../Plugins/SymbolFile/DWARF/DWARFUnit.h      |   8 +-
 .../SymbolFile/DWARF/SymbolFileDWARF.cpp      |   4 +
 .../SymbolFile/DWARF/SymbolFileDWARF.h        |   3 +
 .../SymbolFile/DWARF/SymbolFileDWARFDwo.cpp   |   8 +-
 .../SymbolFile/DWARF/SymbolFileDWARFDwo.h     |   3 +-
 .../SymbolFile/DWARF/SymbolFileWasm.cpp       |  91 +++
 .../Plugins/SymbolFile/DWARF/SymbolFileWasm.h |  34 +
 lldb/source/Utility/WasmVirtualRegisters.h    |  53 ++
 lldb/unittests/Expression/CMakeLists.txt      |   2 +
 .../Expression/DWARFExpressionTest.cpp        | 579 +++++++++++++-----
 15 files changed, 649 insertions(+), 169 deletions(-)
 create mode 100644 lldb/source/Plugins/SymbolFile/DWARF/SymbolFileWasm.cpp
 create mode 100644 lldb/source/Plugins/SymbolFile/DWARF/SymbolFileWasm.h
 create mode 100644 lldb/source/Utility/WasmVirtualRegisters.h

diff --git a/lldb/include/lldb/Expression/DWARFExpression.h 
b/lldb/include/lldb/Expression/DWARFExpression.h
index 37853c0b5a8fc..8fcc5d37b91c9 100644
--- a/lldb/include/lldb/Expression/DWARFExpression.h
+++ b/lldb/include/lldb/Expression/DWARFExpression.h
@@ -52,10 +52,10 @@ class DWARFExpression {
     GetVendorDWARFOpcodeSize(const DataExtractor &data,
                              const lldb::offset_t data_offset,
                              const uint8_t op) const = 0;
-    virtual bool ParseVendorDWARFOpcode(uint8_t op,
-                                        const DataExtractor &opcodes,
-                                        lldb::offset_t &offset,
-                                        Stack &stack) const = 0;
+    virtual bool
+    ParseVendorDWARFOpcode(uint8_t op, const DataExtractor &opcodes,
+                           lldb::offset_t &offset, RegisterContext *reg_ctx,
+                           lldb::RegisterKind reg_kind, Stack &stack) const = 
0;
 
     Delegate(const Delegate &) = delete;
     Delegate &operator=(const Delegate &) = delete;
@@ -163,6 +163,10 @@ class DWARFExpression {
 
   bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op) const;
 
+  static llvm::Error ReadRegisterValueAsScalar(RegisterContext *reg_ctx,
+                                               lldb::RegisterKind reg_kind,
+                                               uint32_t reg_num, Value &value);
+
 private:
   /// A data extractor capable of reading opcode bytes
   DataExtractor m_data;
diff --git a/lldb/source/Expression/DWARFExpression.cpp 
b/lldb/source/Expression/DWARFExpression.cpp
index 79bc6c87fa9c5..391e27704b63d 100644
--- a/lldb/source/Expression/DWARFExpression.cpp
+++ b/lldb/source/Expression/DWARFExpression.cpp
@@ -91,9 +91,10 @@ void DWARFExpression::SetRegisterKind(RegisterKind reg_kind) 
{
   m_reg_kind = reg_kind;
 }
 
-static llvm::Error ReadRegisterValueAsScalar(RegisterContext *reg_ctx,
-                                             lldb::RegisterKind reg_kind,
-                                             uint32_t reg_num, Value &value) {
+llvm::Error
+DWARFExpression::ReadRegisterValueAsScalar(RegisterContext *reg_ctx,
+                                           lldb::RegisterKind reg_kind,
+                                           uint32_t reg_num, Value &value) {
   if (reg_ctx == nullptr)
     return llvm::createStringError("no register context in frame");
 
@@ -2302,7 +2303,8 @@ llvm::Expected<Value> DWARFExpression::Evaluate(
 
     default:
       if (dwarf_cu) {
-        if (dwarf_cu->ParseVendorDWARFOpcode(op, opcodes, offset, stack)) {
+        if (dwarf_cu->ParseVendorDWARFOpcode(op, opcodes, offset, reg_ctx,
+                                             reg_kind, stack)) {
           break;
         }
       }
diff --git a/lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.cpp 
b/lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.cpp
index 67963a790a4fe..b1efd25949379 100644
--- a/lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.cpp
+++ b/lldb/source/Plugins/ObjectFile/wasm/ObjectFileWasm.cpp
@@ -376,9 +376,13 @@ DataExtractor ObjectFileWasm::ReadImageData(offset_t 
offset, uint32_t size) {
         DataBufferSP buffer_sp(data_up.release());
         data.SetData(buffer_sp, 0, buffer_sp->GetByteSize());
       }
+    } else if (offset < m_data.GetByteSize()) {
+      size =
+          std::min(static_cast<uint64_t>(size), m_data.GetByteSize() - offset);
+      return DataExtractor(m_data.GetDataStart() + offset, size, 
GetByteOrder(),
+                           GetAddressByteSize());
     }
   }
-
   data.SetByteOrder(GetByteOrder());
   return data;
 }
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt 
b/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt
index 212cc3610acfb..c3f1bb55e03be 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt
+++ b/lldb/source/Plugins/SymbolFile/DWARF/CMakeLists.txt
@@ -35,6 +35,7 @@ add_lldb_library(lldbPluginSymbolFileDWARF PLUGIN
   SymbolFileDWARF.cpp
   SymbolFileDWARFDwo.cpp
   SymbolFileDWARFDebugMap.cpp
+  SymbolFileWasm.cpp
   UniqueDWARFASTType.cpp
 
   LINK_COMPONENTS
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp 
b/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
index a66af5b126eb1..94fc2e83e899d 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp
@@ -736,9 +736,11 @@ DWARFUnit::GetVendorDWARFOpcodeSize(const DataExtractor 
&data,
 
 bool DWARFUnit::ParseVendorDWARFOpcode(uint8_t op, const DataExtractor 
&opcodes,
                                        lldb::offset_t &offset,
+                                       RegisterContext *reg_ctx,
+                                       lldb::RegisterKind reg_kind,
                                        std::vector<Value> &stack) const {
   return GetSymbolFileDWARF().ParseVendorDWARFOpcode(op, opcodes, offset,
-                                                     stack);
+                                                     reg_ctx, reg_kind, stack);
 }
 
 bool DWARFUnit::ParseDWARFLocationList(
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h 
b/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h
index f55400eeaa448..91a693860c55a 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h
+++ b/lldb/source/Plugins/SymbolFile/DWARF/DWARFUnit.h
@@ -164,9 +164,11 @@ class DWARFUnit : public DWARFExpression::Delegate, public 
UserID {
                                           const lldb::offset_t data_offset,
                                           const uint8_t op) const override;
 
-  bool ParseVendorDWARFOpcode(uint8_t op, const DataExtractor &opcodes,
-                              lldb::offset_t &offset,
-                              std::vector<Value> &stack) const override;
+  virtual bool ParseVendorDWARFOpcode(uint8_t op, const DataExtractor &opcodes,
+                                      lldb::offset_t &offset,
+                                      RegisterContext *reg_ctx,
+                                      lldb::RegisterKind reg_kind,
+                                      std::vector<Value> &stack) const 
override;
 
   bool ParseDWARFLocationList(const DataExtractor &data,
                               DWARFExpressionList &loc_list) const;
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp 
b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
index 4b4a58297ded4..41ab8d1b75b34 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
@@ -41,6 +41,7 @@
 
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h"
+#include "Plugins/SymbolFile/DWARF/SymbolFileWasm.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/CompileUnit.h"
@@ -327,6 +328,9 @@ llvm::StringRef 
SymbolFileDWARF::GetPluginDescriptionStatic() {
 }
 
 SymbolFile *SymbolFileDWARF::CreateInstance(ObjectFileSP objfile_sp) {
+  if (objfile_sp->GetArchitecture().GetTriple().isWasm())
+    return new SymbolFileWasm(std::move(objfile_sp),
+                              /*dwo_section_list*/ nullptr);
   return new SymbolFileDWARF(std::move(objfile_sp),
                              /*dwo_section_list*/ nullptr);
 }
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h 
b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
index 2dc862cccca14..56d8ccbd97e46 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
+++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h
@@ -329,6 +329,8 @@ class SymbolFileDWARF : public SymbolFileCommon {
 
   virtual bool ParseVendorDWARFOpcode(uint8_t op, const DataExtractor &opcodes,
                                       lldb::offset_t &offset,
+                                      RegisterContext *reg_ctx,
+                                      lldb::RegisterKind reg_kind,
                                       std::vector<Value> &stack) const {
     return false;
   }
@@ -556,6 +558,7 @@ class SymbolFileDWARF : public SymbolFileCommon {
   /// an index that identifies the .DWO or .o file.
   std::optional<uint64_t> m_file_index;
 };
+
 } // namespace dwarf
 } // namespace lldb_private::plugin
 
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp 
b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp
index c1829abe72933..52de3abca4b77 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp
+++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp
@@ -97,9 +97,11 @@ uint64_t SymbolFileDWARFDwo::GetDebugInfoSize(bool 
load_all_debug_info) {
 }
 
 bool SymbolFileDWARFDwo::ParseVendorDWARFOpcode(
-    uint8_t op, const lldb_private::DataExtractor &opcodes,
-    lldb::offset_t &offset, std::vector<lldb_private::Value> &stack) const {
-  return GetBaseSymbolFile().ParseVendorDWARFOpcode(op, opcodes, offset, 
stack);
+    uint8_t op, const DataExtractor &opcodes, lldb::offset_t &offset,
+    RegisterContext *reg_ctx, lldb::RegisterKind reg_kind,
+    std::vector<Value> &stack) const {
+  return GetBaseSymbolFile().ParseVendorDWARFOpcode(op, opcodes, offset,
+                                                    reg_ctx, reg_kind, stack);
 }
 
 llvm::DenseMap<const DWARFDebugInfoEntry *, Type *> &
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h 
b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h
index 75f5986f14014..1ab6494f8ef7f 100644
--- a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h
+++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h
@@ -50,7 +50,8 @@ class SymbolFileDWARFDwo : public SymbolFileDWARF {
   uint64_t GetDebugInfoSize(bool load_all_debug_info = false) override;
 
   bool ParseVendorDWARFOpcode(uint8_t op, const DataExtractor &opcodes,
-                              lldb::offset_t &offset,
+                              lldb::offset_t &offset, RegisterContext *reg_ctx,
+                              lldb::RegisterKind reg_kind,
                               std::vector<Value> &stack) const override;
 
   void FindGlobalVariables(ConstString name,
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileWasm.cpp 
b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileWasm.cpp
new file mode 100644
index 0000000000000..eee76a4411a77
--- /dev/null
+++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileWasm.cpp
@@ -0,0 +1,91 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 "SymbolFileWasm.h"
+#include "Plugins/SymbolFile/DWARF/LogChannelDWARF.h"
+#include "Utility/WasmVirtualRegisters.h"
+#include "lldb/Utility/LLDBLog.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::plugin::dwarf;
+
+SymbolFileWasm::SymbolFileWasm(ObjectFileSP objfile_sp,
+                               SectionList *dwo_section_list)
+    : SymbolFileDWARF(objfile_sp, dwo_section_list) {}
+
+SymbolFileWasm::~SymbolFileWasm() = default;
+
+lldb::offset_t
+SymbolFileWasm::GetVendorDWARFOpcodeSize(const DataExtractor &data,
+                                         const lldb::offset_t data_offset,
+                                         const uint8_t op) const {
+  if (op != llvm::dwarf::DW_OP_WASM_location)
+    return LLDB_INVALID_OFFSET;
+
+  lldb::offset_t offset = data_offset;
+  const uint8_t wasm_op = data.GetU8(&offset);
+  if (wasm_op == eWasmTagOperandStack)
+    data.GetU32(&offset);
+  else
+    data.GetULEB128(&offset);
+  return offset - data_offset;
+}
+
+bool SymbolFileWasm::ParseVendorDWARFOpcode(uint8_t op,
+                                            const DataExtractor &opcodes,
+                                            lldb::offset_t &offset,
+                                            RegisterContext *reg_ctx,
+                                            lldb::RegisterKind reg_kind,
+                                            std::vector<Value> &stack) const {
+  if (op != llvm::dwarf::DW_OP_WASM_location)
+    return false;
+
+  uint32_t index = 0;
+  uint8_t tag = eWasmTagNotAWasmLocation;
+
+  /// |DWARF Location Index | WebAssembly Construct |
+  /// |---------------------|-----------------------|
+  /// |0                    | Local                 |
+  /// |1 or 3               | Global                |
+  /// |2                    | Operand Stack         |
+  const uint8_t wasm_op = opcodes.GetU8(&offset);
+  switch (wasm_op) {
+  case 0: // LOCAL
+    index = opcodes.GetULEB128(&offset);
+    tag = eWasmTagLocal;
+    break;
+  case 1: // GLOBAL_FIXED
+    index = opcodes.GetULEB128(&offset);
+    tag = eWasmTagGlobal;
+    break;
+  case 2: // OPERAND_STACK
+    index = opcodes.GetULEB128(&offset);
+    tag = eWasmTagOperandStack;
+    break;
+  case 3: // GLOBAL_RELOC
+    index = opcodes.GetU32(&offset);
+    tag = eWasmTagGlobal;
+    break;
+  default:
+    return false;
+  }
+
+  const uint32_t reg_num = GetWasmRegister(tag, index);
+
+  Value tmp;
+  llvm::Error error = DWARFExpression::ReadRegisterValueAsScalar(
+      reg_ctx, reg_kind, reg_num, tmp);
+  if (error) {
+    LLDB_LOG_ERROR(GetLog(DWARFLog::DebugInfo), std::move(error), "{0}");
+    return false;
+  }
+
+  stack.push_back(tmp);
+  return true;
+}
diff --git a/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileWasm.h 
b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileWasm.h
new file mode 100644
index 0000000000000..0e0b742f53f18
--- /dev/null
+++ b/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileWasm.h
@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEWASM_H
+#define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEWASM_H
+
+#include "SymbolFileDWARF.h"
+
+namespace lldb_private::plugin {
+namespace dwarf {
+class SymbolFileWasm : public SymbolFileDWARF {
+public:
+  SymbolFileWasm(lldb::ObjectFileSP objfile_sp, SectionList *dwo_section_list);
+
+  ~SymbolFileWasm() override;
+
+  lldb::offset_t GetVendorDWARFOpcodeSize(const DataExtractor &data,
+                                          const lldb::offset_t data_offset,
+                                          const uint8_t op) const override;
+
+  bool ParseVendorDWARFOpcode(uint8_t op, const DataExtractor &opcodes,
+                              lldb::offset_t &offset, RegisterContext *reg_ctx,
+                              lldb::RegisterKind reg_kind,
+                              std::vector<Value> &stack) const override;
+};
+} // namespace dwarf
+} // namespace lldb_private::plugin
+
+#endif
diff --git a/lldb/source/Utility/WasmVirtualRegisters.h 
b/lldb/source/Utility/WasmVirtualRegisters.h
new file mode 100644
index 0000000000000..404a5ae35dc91
--- /dev/null
+++ b/lldb/source/Utility/WasmVirtualRegisters.h
@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 LLDB_SOURCE_UTILITY_WASM_VIRTUAL_REGISTERS_H
+#define LLDB_SOURCE_UTILITY_WASM_VIRTUAL_REGISTERS_H
+
+#include "lldb/lldb-private.h"
+
+namespace lldb_private {
+
+// LLDB doesn't have an address space to represents WebAssembly locals,
+// globals and operand stacks. We encode these elements into virtual
+// registers:
+//
+//   | tag: 2 bits | index: 30 bits |
+//
+// Where tag is:
+//    0: Not a Wasm location
+//    1: Local
+//    2: Global
+//    3: Operand stack value
+enum WasmVirtualRegisterKinds {
+  eWasmTagNotAWasmLocation = 0,
+  eWasmTagLocal = 1,
+  eWasmTagGlobal = 2,
+  eWasmTagOperandStack = 3,
+};
+
+static const uint32_t kWasmVirtualRegisterTagMask = 0x03;
+static const uint32_t kWasmVirtualRegisterIndexMask = 0x3fffffff;
+static const uint32_t kWasmVirtualRegisterTagShift = 30;
+
+inline uint32_t GetWasmVirtualRegisterTag(size_t reg) {
+  return (reg >> kWasmVirtualRegisterTagShift) & kWasmVirtualRegisterTagMask;
+}
+
+inline uint32_t GetWasmVirtualRegisterIndex(size_t reg) {
+  return reg & kWasmVirtualRegisterIndexMask;
+}
+
+inline uint32_t GetWasmRegister(uint8_t tag, uint32_t index) {
+  return ((tag & kWasmVirtualRegisterTagMask) << kWasmVirtualRegisterTagShift) 
|
+         (index & kWasmVirtualRegisterIndexMask);
+}
+
+} // namespace lldb_private
+
+#endif
diff --git a/lldb/unittests/Expression/CMakeLists.txt 
b/lldb/unittests/Expression/CMakeLists.txt
index 185b19f84cae7..533cdc673e6d1 100644
--- a/lldb/unittests/Expression/CMakeLists.txt
+++ b/lldb/unittests/Expression/CMakeLists.txt
@@ -8,6 +8,8 @@ add_lldb_unittest(ExpressionTests
   LINK_LIBS
     lldbCore
     lldbPluginObjectFileELF
+    lldbPluginObjectFileWasm
+    lldbPluginSymbolVendorWasm
     lldbPluginPlatformLinux
     lldbPluginExpressionParserClang
     lldbPluginTypeSystemClang
diff --git a/lldb/unittests/Expression/DWARFExpressionTest.cpp 
b/lldb/unittests/Expression/DWARFExpressionTest.cpp
index 819c9739dde7d..8b1b9336190a2 100644
--- a/lldb/unittests/Expression/DWARFExpressionTest.cpp
+++ b/lldb/unittests/Expression/DWARFExpressionTest.cpp
@@ -7,9 +7,12 @@
 
//===----------------------------------------------------------------------===//
 
 #include "lldb/Expression/DWARFExpression.h"
+#include "Plugins/ObjectFile/wasm/ObjectFileWasm.h"
 #include "Plugins/Platform/Linux/PlatformLinux.h"
 #include "Plugins/SymbolFile/DWARF/DWARFDebugInfo.h"
 #include "Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h"
+#include "Plugins/SymbolFile/DWARF/SymbolFileWasm.h"
+#include "Plugins/SymbolVendor/wasm/SymbolVendorWasm.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "TestingSupport/Symbol/YAMLModuleTester.h"
 #include "lldb/Core/Debugger.h"
@@ -18,27 +21,127 @@
 #include "lldb/Core/dwarf.h"
 #include "lldb/Host/HostInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/StreamString.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gtest/gtest.h"
 
-using namespace lldb_private;
 using namespace lldb_private::plugin::dwarf;
+using namespace lldb_private::wasm;
+using namespace lldb_private;
 using namespace llvm::dwarf;
 
+namespace {
+struct MockProcess : Process {
+  MockProcess(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp)
+      : Process(target_sp, listener_sp) {}
+
+  llvm::StringRef GetPluginName() override { return "mock process"; }
+
+  bool CanDebug(lldb::TargetSP target, bool plugin_specified_by_name) override 
{
+    return false;
+  };
+
+  Status DoDestroy() override { return {}; }
+
+  void RefreshStateAfterStop() override {}
+
+  bool DoUpdateThreadList(ThreadList &old_thread_list,
+                          ThreadList &new_thread_list) override {
+    return false;
+  };
+
+  size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
+                      Status &error) override {
+    for (size_t i = 0; i < size; ++i)
+      ((char *)buf)[i] = (vm_addr + i) & 0xff;
+    error.Clear();
+    return size;
+  }
+};
+
+class MockThread : public Thread {
+public:
+  MockThread(Process &process) : Thread(process, /*tid=*/1), m_reg_ctx_sp() {}
+  ~MockThread() override { DestroyThread(); }
+
+  void RefreshStateAfterStop() override {}
+
+  lldb::RegisterContextSP GetRegisterContext() override { return m_reg_ctx_sp; 
}
+
+  lldb::RegisterContextSP
+  CreateRegisterContextForFrame(StackFrame *frame) override {
+    return m_reg_ctx_sp;
+  }
+
+  bool CalculateStopInfo() override { return false; }
+
+  void SetRegisterContext(lldb::RegisterContextSP reg_ctx_sp) {
+    m_reg_ctx_sp = reg_ctx_sp;
+  }
+
+private:
+  lldb::RegisterContextSP m_reg_ctx_sp;
+};
+
+class MockRegisterContext : public RegisterContext {
+public:
+  MockRegisterContext(Thread &thread, const RegisterValue &reg_value)
+      : RegisterContext(thread, 0 /*concrete_frame_idx*/),
+        m_reg_value(reg_value) {}
+
+  void InvalidateAllRegisters() override {}
+
+  size_t GetRegisterCount() override { return 0; }
+
+  const RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override {
+    return &m_reg_info;
+  }
+
+  size_t GetRegisterSetCount() override { return 0; }
+
+  const RegisterSet *GetRegisterSet(size_t reg_set) override { return nullptr; 
}
+
+  lldb::ByteOrder GetByteOrder() override {
+    return lldb::ByteOrder::eByteOrderLittle;
+  }
+
+  bool ReadRegister(const RegisterInfo *reg_info,
+                    RegisterValue &reg_value) override {
+    reg_value = m_reg_value;
+    return true;
+  }
+
+  bool WriteRegister(const RegisterInfo *reg_info,
+                     const RegisterValue &reg_value) override {
+    return false;
+  }
+
+  uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
+                                               uint32_t num) override {
+    return num;
+  }
+
+private:
+  RegisterInfo m_reg_info;
+  RegisterValue m_reg_value;
+};
+} // namespace
+
 static llvm::Expected<Scalar> Evaluate(llvm::ArrayRef<uint8_t> expr,
                                        lldb::ModuleSP module_sp = {},
                                        DWARFUnit *unit = nullptr,
-                                       ExecutionContext *exe_ctx = nullptr) {
+                                       ExecutionContext *exe_ctx = nullptr,
+                                       RegisterContext *reg_ctx = nullptr) {
   DataExtractor extractor(expr.data(), expr.size(), lldb::eByteOrderLittle,
                           /*addr_size*/ 4);
 
-  llvm::Expected<Value> result =
-      DWARFExpression::Evaluate(exe_ctx, /*reg_ctx*/ nullptr, module_sp,
-                                extractor, unit, lldb::eRegisterKindLLDB,
-                                /*initial_value_ptr*/ nullptr,
-                                /*object_address_ptr*/ nullptr);
+  llvm::Expected<Value> result = DWARFExpression::Evaluate(
+      exe_ctx, reg_ctx, module_sp, extractor, unit, lldb::eRegisterKindLLDB,
+      /*initial_value_ptr=*/nullptr,
+      /*object_address_ptr=*/nullptr);
   if (!result)
     return result.takeError();
 
@@ -53,7 +156,7 @@ static llvm::Expected<Scalar> 
Evaluate(llvm::ArrayRef<uint8_t> expr,
     if (buf.GetByteSize() <= 8) {
       uint64_t val = 0;
       memcpy(&val, buf.GetBytes(), buf.GetByteSize());
-      return Scalar(llvm::APInt(buf.GetByteSize()*8, val, false));
+      return Scalar(llvm::APInt(buf.GetByteSize() * 8, val, false));
     }
   }
     [[fallthrough]];
@@ -65,8 +168,8 @@ static llvm::Expected<Scalar> 
Evaluate(llvm::ArrayRef<uint8_t> expr,
 
 class DWARFExpressionTester : public YAMLModuleTester {
 public:
-  DWARFExpressionTester(llvm::StringRef yaml_data, size_t cu_index) :
-      YAMLModuleTester(yaml_data, cu_index) {}
+  DWARFExpressionTester(llvm::StringRef yaml_data, size_t cu_index)
+      : YAMLModuleTester(yaml_data, cu_index) {}
 
   using YAMLModuleTester::YAMLModuleTester;
   llvm::Expected<Scalar> Eval(llvm::ArrayRef<uint8_t> expr) {
@@ -377,30 +480,6 @@ TEST(DWARFExpression, DW_OP_unknown) {
 TEST_F(DWARFExpressionMockProcessTest, DW_OP_deref) {
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit0, DW_OP_deref}), llvm::Failed());
 
-  struct MockProcess : Process {
-    MockProcess(lldb::TargetSP target_sp, lldb::ListenerSP listener_sp)
-        : Process(target_sp, listener_sp) {}
-
-    llvm::StringRef GetPluginName() override { return "mock process"; }
-    bool CanDebug(lldb::TargetSP target,
-                  bool plugin_specified_by_name) override {
-      return false;
-    };
-    Status DoDestroy() override { return {}; }
-    void RefreshStateAfterStop() override {}
-    bool DoUpdateThreadList(ThreadList &old_thread_list,
-                            ThreadList &new_thread_list) override {
-      return false;
-    };
-    size_t DoReadMemory(lldb::addr_t vm_addr, void *buf, size_t size,
-                        Status &error) override {
-      for (size_t i = 0; i < size; ++i)
-        ((char *)buf)[i] = (vm_addr + i) & 0xff;
-      error.Clear();
-      return size;
-    }
-  };
-
   // Set up a mock process.
   ArchSpec arch("i386-pc-linux");
   Platform::SetHostPlatform(
@@ -421,9 +500,9 @@ TEST_F(DWARFExpressionMockProcessTest, DW_OP_deref) {
 
   ExecutionContext exe_ctx(process_sp);
   // Implicit location: *0x4.
-  EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit4, DW_OP_deref, DW_OP_stack_value},
-                                {}, {}, &exe_ctx),
-                       llvm::HasValue(GetScalar(32, 0x07060504, false)));
+  EXPECT_THAT_EXPECTED(
+      Evaluate({DW_OP_lit4, DW_OP_deref, DW_OP_stack_value}, {}, {}, &exe_ctx),
+      llvm::HasValue(GetScalar(32, 0x07060504, false)));
   // Memory location: *(*0x4).
   // Evaluate returns LLDB_INVALID_ADDRESS for all load addresses.
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_lit4, DW_OP_deref}, {}, {}, &exe_ctx),
@@ -618,10 +697,12 @@ class CustomSymbolFileDWARF : public SymbolFileDWARF {
     return offset - data_offset;
   }
 
-  bool
-  ParseVendorDWARFOpcode(uint8_t op, const lldb_private::DataExtractor 
&opcodes,
-                         lldb::offset_t &offset,
-                         std::vector<lldb_private::Value> &stack) const final {
+  virtual bool ParseVendorDWARFOpcode(
+      uint8_t op, const lldb_private::DataExtractor &opcodes,
+      lldb::offset_t &offset,
+
+      RegisterContext *reg_ctx, lldb::RegisterKind reg_kind,
+      std::vector<lldb_private::Value> &stack) const override {
     if (op != DW_OP_WASM_location) {
       return false;
     }
@@ -647,13 +728,14 @@ class CustomSymbolFileDWARF : public SymbolFileDWARF {
 char CustomSymbolFileDWARF::ID;
 
 static auto testExpressionVendorExtensions(lldb::ModuleSP module_sp,
-                                           DWARFUnit &dwarf_unit) {
+                                           DWARFUnit &dwarf_unit,
+                                           RegisterContext *reg_ctx) {
   // Test that expression extensions can be evaluated, for example
   // DW_OP_WASM_location which is not currently handled by DWARFExpression:
   EXPECT_THAT_EXPECTED(Evaluate({DW_OP_WASM_location, 0x03, // WASM_GLOBAL:0x03
                                  0x04, 0x00, 0x00,          // index:u32
                                  0x00, DW_OP_stack_value},
-                                module_sp, &dwarf_unit),
+                                module_sp, &dwarf_unit, nullptr, reg_ctx),
                        llvm::HasValue(GetScalar(32, 42, false)));
 
   // Test that searches for opcodes work in the presence of extensions:
@@ -667,138 +749,331 @@ static auto 
testExpressionVendorExtensions(lldb::ModuleSP module_sp,
 
 TEST(DWARFExpression, Extensions) {
   const char *yamldata = R"(
---- !ELF
+--- !WASM
 FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_EXEC
-  Machine: EM_386
-DWARF:
-  debug_abbrev:
-    - Table:
-        - Code:            0x00000001
-          Tag:             DW_TAG_compile_unit
-          Children:        DW_CHILDREN_no
-  debug_info:
-    - Version:         4
-      AddrSize:        4
-      Entries:
-        - AbbrCode:        0x1
-        - AbbrCode:        0x0
+  Version:         0x1
+Sections:
+  - Type:            TYPE
+    Signatures:
+      - Index:           0
+        ParamTypes:
+          - I32
+        ReturnTypes:
+          - I32
+  - Type:            FUNCTION
+    FunctionTypes:   [ 0 ]
+  - Type:            TABLE
+    Tables:
+      - Index:           0
+        ElemType:        FUNCREF
+        Limits:
+          Flags:           [ HAS_MAX ]
+          Minimum:         0x1
+          Maximum:         0x1
+  - Type:            MEMORY
+    Memories:
+      - Flags:           [ HAS_MAX ]
+        Minimum:         0x100
+        Maximum:         0x100
+  - Type:            GLOBAL
+    Globals:
+      - Index:           0
+        Type:            I32
+        Mutable:         true
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           65536
+  - Type:            EXPORT
+    Exports:
+      - Name:            memory
+        Kind:            MEMORY
+        Index:           0
+      - Name:            square
+        Kind:            FUNCTION
+        Index:           0
+      - Name:            __indirect_function_table
+        Kind:            TABLE
+        Index:           0
+  - Type:            CODE
+    Functions:
+      - Index:           0
+        Locals:
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+        Body:            
2300210141102102200120026B21032003200036020C200328020C2104200328020C2105200420056C210620060F0B
+  - Type:            CUSTOM
+    Name:            name
+    FunctionNames:
+      - Index:           0
+        Name:            square
+    GlobalNames:
+      - Index:           0
+        Name:            __stack_pointer
+  - Type:            CUSTOM
+    Name:            .debug_abbrev
+    Payload:         
011101250E1305030E10171B0E110112060000022E01110112064018030E3A0B3B0B271949133F1900000305000218030E3A0B3B0B49130000042400030E3E0B0B0B000000
+  - Type:            CUSTOM
+    Name:            .debug_info
+    Payload:         
510000000400000000000401670000001D005E000000000000000A000000020000003C00000002020000003C00000004ED00039F5700000001014D0000000302910C0400000001014D000000000400000000050400
+  - Type:            CUSTOM
+    Name:            .debug_str
+    Payload:         
696E740076616C756500513A5C70616F6C6F7365764D5346545C6C6C766D2D70726F6A6563745C6C6C64625C746573745C4150495C66756E6374696F6E616C69746965735C6764625F72656D6F74655F636C69656E745C737175617265007371756172652E6300636C616E672076657273696F6E2031382E302E30202868747470733A2F2F6769746875622E636F6D2F6C6C766D2F6C6C766D2D70726F6A65637420373535303166353336323464653932616166636532663164613639386232343961373239336463372900
+  - Type:            CUSTOM
+    Name:            .debug_line
+    Payload:         
64000000040020000000010101FB0E0D000101010100000001000001007371756172652E6300000000000005020200000001000502250000000301050A0A010005022C00000005120601000502330000000510010005023A0000000503010005023E000000000101
 )";
 
-  SubsystemRAII<FileSystem, HostInfo, TypeSystemClang, ObjectFileELF,
-                CustomSymbolFileDWARF>
+  SubsystemRAII<FileSystem, HostInfo, ObjectFileWasm, SymbolVendorWasm>
       subsystems;
 
+  // Set up a wasm target.
+  ArchSpec arch("wasm32-unknown-unknown-wasm");
+  lldb::PlatformSP host_platform_sp =
+      platform_linux::PlatformLinux::CreateInstance(true, &arch);
+  ASSERT_TRUE(host_platform_sp);
+  Platform::SetHostPlatform(host_platform_sp);
+  lldb::DebuggerSP debugger_sp = Debugger::CreateInstance();
+  ASSERT_TRUE(debugger_sp);
+  lldb::TargetSP target_sp;
+  lldb::PlatformSP platform_sp;
+  debugger_sp->GetTargetList().CreateTarget(*debugger_sp, "", arch,
+                                            lldb_private::eLoadDependentsNo,
+                                            platform_sp, target_sp);
+  // Set up a mock process and thread.
+  lldb::ListenerSP listener_sp(Listener::MakeListener("dummy"));
+  lldb::ProcessSP process_sp =
+      std::make_shared<MockProcess>(target_sp, listener_sp);
+  ASSERT_TRUE(process_sp);
+  MockThread thread(*process_sp);
+  const uint32_t kExpectedValue = 42;
+  lldb::RegisterContextSP reg_ctx_sp = std::make_shared<MockRegisterContext>(
+      thread, RegisterValue(kExpectedValue));
+  thread.SetRegisterContext(reg_ctx_sp);
+
   llvm::Expected<TestFile> file = TestFile::fromYaml(yamldata);
   EXPECT_THAT_EXPECTED(file, llvm::Succeeded());
-
   auto module_sp = std::make_shared<Module>(file->moduleSpec());
-  auto &symfile =
-      *llvm::cast<CustomSymbolFileDWARF>(module_sp->GetSymbolFile());
-  auto *dwarf_unit = symfile.DebugInfo().GetUnitAtIndex(0);
+  auto obj_file_sp = module_sp->GetObjectFile()->shared_from_this();
+  SymbolFileWasm sym_file_wasm(obj_file_sp, nullptr);
+  auto *dwarf_unit = sym_file_wasm.DebugInfo().GetUnitAtIndex(0);
 
-  testExpressionVendorExtensions(module_sp, *dwarf_unit);
+  testExpressionVendorExtensions(module_sp, *dwarf_unit, reg_ctx_sp.get());
 }
 
-TEST(DWARFExpression, ExtensionsDWO) {
+TEST(DWARFExpression, ExtensionsSplitSymbols) {
   const char *skeleton_yamldata = R"(
---- !ELF
+--- !WASM
 FileHeader:
-  Class:   ELFCLASS64
-  Data:    ELFDATA2LSB
-  Type:    ET_EXEC
-  Machine: EM_386
-DWARF:
-  debug_abbrev:
-    - Table:
-        - Code:            0x00000001
-          Tag:             DW_TAG_skeleton_unit
-          Children:        DW_CHILDREN_no
-          Attributes:
-            - Attribute:       DW_AT_dwo_name
-              Form:            DW_FORM_string
-            - Attribute:       DW_AT_dwo_id
-              Form:            DW_FORM_data4
-  debug_info:
-    - Version:         4
-      AddrSize:        4
-      Entries:
-        - AbbrCode:        0x1
-          Values:
-            - CStr:           "dwo_unit"
-            - Value:           0x01020304
-        - AbbrCode:        0x0
+  Version:         0x1
+Sections:
+  - Type:            TYPE
+    Signatures:
+      - Index:           0
+        ParamTypes:
+          - I32
+        ReturnTypes:
+          - I32
+  - Type:            FUNCTION
+    FunctionTypes:   [ 0 ]
+  - Type:            TABLE
+    Tables:
+      - Index:           0
+        ElemType:        FUNCREF
+        Limits:
+          Flags:           [ HAS_MAX ]
+          Minimum:         0x1
+          Maximum:         0x1
+  - Type:            MEMORY
+    Memories:
+      - Flags:           [ HAS_MAX ]
+        Minimum:         0x100
+        Maximum:         0x100
+  - Type:            GLOBAL
+    Globals:
+      - Index:           0
+        Type:            I32
+        Mutable:         true
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           65536
+  - Type:            EXPORT
+    Exports:
+      - Name:            memory
+        Kind:            MEMORY
+        Index:           0
+      - Name:            square
+        Kind:            FUNCTION
+        Index:           0
+      - Name:            __indirect_function_table
+        Kind:            TABLE
+        Index:           0
+  - Type:            CODE
+    Functions:
+      - Index:           0
+        Locals:
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+        Body:            
2300210141102102200120026B21032003200036020C200328020C2104200328020C2105200420056C210620060F0B
+  - Type:            CUSTOM
+    Name:            name
+    FunctionNames:
+      - Index:           0
+        Name:            square
+    GlobalNames:
+      - Index:           0
+        Name:            __stack_pointer
+  - Type:            CUSTOM
+    Name:            external_debug_info
+    Payload:         167371756172652E7761736D2E64656275672E7761736D
 )";
 
-  // .dwo sections aren't currently supported by dwarfyaml. The dwo_yamldata
-  // contents where generated by roundtripping the following yaml through
-  // yaml2obj | obj2yaml and renaming the sections. This works because the
-  // structure of the .dwo and non-.dwo sections is identical.
-  //
-  // --- !ELF
-  // FileHeader:
-  //   Class:   ELFCLASS64
-  //   Data:    ELFDATA2LSB
-  //   Type:    ET_EXEC
-  //   Machine: EM_386
-  // DWARF:
-  //   debug_abbrev: #.dwo
-  //     - Table:
-  //         - Code:            0x00000001
-  //           Tag:             DW_TAG_compile_unit
-  //           Children:        DW_CHILDREN_no
-  //           Attributes:
-  //             - Attribute:       DW_AT_dwo_id
-  //               Form:            DW_FORM_data4
-  //   debug_info: #.dwo
-  //     - Version:         4
-  //       AddrSize:        4
-  //       Entries:
-  //         - AbbrCode:        0x1
-  //           Values:
-  //             - Value:           0x0120304
-  //         - AbbrCode:        0x0
-  const char *dwo_yamldata = R"(
---- !ELF
+  const char *sym_yamldata = R"(
+--- !WASM
 FileHeader:
-  Class:           ELFCLASS64
-  Data:            ELFDATA2LSB
-  Type:            ET_EXEC
-  Machine:         EM_386
+  Version:         0x1
 Sections:
-  - Name:            .debug_abbrev.dwo
-    Type:            SHT_PROGBITS
-    AddressAlign:    0x1
-    Content:         '0111007506000000'
-  - Name:            .debug_info.dwo
-    Type:            SHT_PROGBITS
-    AddressAlign:    0x1
-    Content:         0D00000004000000000004010403020100
+  - Type:            TYPE
+    Signatures:
+      - Index:           0
+        ParamTypes:
+          - I32
+        ReturnTypes:
+          - I32
+  - Type:            FUNCTION
+    FunctionTypes:   [ 0 ]
+  - Type:            TABLE
+    Tables:
+      - Index:           0
+        ElemType:        FUNCREF
+        Limits:
+          Flags:           [ HAS_MAX ]
+          Minimum:         0x1
+          Maximum:         0x1
+  - Type:            MEMORY
+    Memories:
+      - Flags:           [ HAS_MAX ]
+        Minimum:         0x100
+        Maximum:         0x100
+  - Type:            GLOBAL
+    Globals:
+      - Index:           0
+        Type:            I32
+        Mutable:         true
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           65536
+  - Type:            EXPORT
+    Exports:
+      - Name:            memory
+        Kind:            MEMORY
+        Index:           0
+      - Name:            square
+        Kind:            FUNCTION
+        Index:           0
+      - Name:            __indirect_function_table
+        Kind:            TABLE
+        Index:           0
+  - Type:            CODE
+    Functions:
+      - Index:           0
+        Locals:
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+          - Type:            I32
+            Count:           1
+        Body:            
2300210141102102200120026B21032003200036020C200328020C2104200328020C2105200420056C210620060F0B
+  - Type:            CUSTOM
+    Name:            name
+    FunctionNames:
+      - Index:           0
+        Name:            square
+    GlobalNames:
+      - Index:           0
+        Name:            __stack_pointer
+  - Type:            CUSTOM
+    Name:            .debug_abbrev
+    Payload:         
011101250E1305030E10171B0E110112060000022E01110112064018030E3A0B3B0B271949133F1900000305000218030E3A0B3B0B49130000042400030E3E0B0B0B000000
+  - Type:            CUSTOM
+    Name:            .debug_info
+    Payload:         
510000000400000000000401670000001D005E0000000000000004000000020000003C00000002020000003C00000004ED00039F5700000001014D0000000302910C5100000001014D000000000400000000050400
+  - Type:            CUSTOM
+    Name:            .debug_str
+    Payload:         
696E7400513A5C70616F6C6F7365764D5346545C6C6C766D2D70726F6A6563745C6C6C64625C746573745C4150495C66756E6374696F6E616C69746965735C6764625F72656D6F74655F636C69656E740076616C756500737175617265007371756172652E6300636C616E672076657273696F6E2031382E302E30202868747470733A2F2F6769746875622E636F6D2F6C6C766D2F6C6C766D2D70726F6A65637420373535303166353336323464653932616166636532663164613639386232343961373239336463372900
+  - Type:            CUSTOM
+    Name:            .debug_line
+    Payload:         
64000000040020000000010101FB0E0D000101010100000001000001007371756172652E6300000000000005020200000001000502250000000301050A0A010005022C00000005120601000502330000000510010005023A0000000503010005023E000000000101
 )";
 
-  SubsystemRAII<FileSystem, HostInfo, ObjectFileELF, CustomSymbolFileDWARF>
+  SubsystemRAII<FileSystem, HostInfo, ObjectFileWasm, SymbolVendorWasm>
       subsystems;
 
+  // Set up a wasm target.
+  ArchSpec arch("wasm32-unknown-unknown-wasm");
+  lldb::PlatformSP host_platform_sp =
+      platform_linux::PlatformLinux::CreateInstance(true, &arch);
+  ASSERT_TRUE(host_platform_sp);
+  Platform::SetHostPlatform(host_platform_sp);
+  lldb::DebuggerSP debugger_sp = Debugger::CreateInstance();
+  ASSERT_TRUE(debugger_sp);
+  lldb::TargetSP target_sp;
+  lldb::PlatformSP platform_sp;
+  debugger_sp->GetTargetList().CreateTarget(*debugger_sp, "", arch,
+                                            lldb_private::eLoadDependentsNo,
+                                            platform_sp, target_sp);
+  // Set up a mock process and thread.
+  lldb::ListenerSP listener_sp(Listener::MakeListener("dummy"));
+  lldb::ProcessSP process_sp =
+      std::make_shared<MockProcess>(target_sp, listener_sp);
+  ASSERT_TRUE(process_sp);
+  MockThread thread(*process_sp);
+  const uint32_t kExpectedValue = 42;
+  lldb::RegisterContextSP reg_ctx_sp = std::make_shared<MockRegisterContext>(
+      thread, RegisterValue(kExpectedValue));
+  thread.SetRegisterContext(reg_ctx_sp);
+
   llvm::Expected<TestFile> skeleton_file =
       TestFile::fromYaml(skeleton_yamldata);
   EXPECT_THAT_EXPECTED(skeleton_file, llvm::Succeeded());
-  llvm::Expected<TestFile> dwo_file = TestFile::fromYaml(dwo_yamldata);
-  EXPECT_THAT_EXPECTED(dwo_file, llvm::Succeeded());
-
   auto skeleton_module_sp =
       std::make_shared<Module>(skeleton_file->moduleSpec());
-  auto &skeleton_symfile =
-      *llvm::cast<CustomSymbolFileDWARF>(skeleton_module_sp->GetSymbolFile());
 
-  auto dwo_module_sp = std::make_shared<Module>(dwo_file->moduleSpec());
-  SymbolFileDWARFDwo dwo_symfile(
-      skeleton_symfile, dwo_module_sp->GetObjectFile()->shared_from_this(),
-      0x0120304);
-  auto *dwo_dwarf_unit = dwo_symfile.DebugInfo().GetUnitAtIndex(0);
+  llvm::Expected<TestFile> sym_file = TestFile::fromYaml(sym_yamldata);
+  EXPECT_THAT_EXPECTED(sym_file, llvm::Succeeded());
+  auto sym_module_sp = std::make_shared<Module>(sym_file->moduleSpec());
 
-  testExpressionVendorExtensions(dwo_module_sp, *dwo_dwarf_unit);
+  auto obj_file_sp = sym_module_sp->GetObjectFile()->shared_from_this();
+  SymbolFileWasm sym_file_wasm(obj_file_sp, nullptr);
+  auto *dwarf_unit = sym_file_wasm.DebugInfo().GetUnitAtIndex(0);
+
+  testExpressionVendorExtensions(sym_module_sp, *dwarf_unit, reg_ctx_sp.get());
 }
 
 TEST_F(DWARFExpressionMockProcessTest, DW_OP_piece_file_addr) {
@@ -828,12 +1103,12 @@ TEST_F(DWARFExpressionMockProcessTest, 
DW_OP_piece_file_addr) {
   uint8_t expr[] = {DW_OP_addr, 0x40, 0x0, 0x0, 0x0, DW_OP_piece, 1,
                     DW_OP_addr, 0x50, 0x0, 0x0, 0x0, DW_OP_piece, 1};
   DataExtractor extractor(expr, sizeof(expr), lldb::eByteOrderLittle,
-                          /*addr_size*/ 4);
+                          /*addr_size=*/4);
   llvm::Expected<Value> result = DWARFExpression::Evaluate(
-      &exe_ctx, /*reg_ctx*/ nullptr, /*module_sp*/ {}, extractor,
-      /*unit*/ nullptr, lldb::eRegisterKindLLDB,
-      /*initial_value_ptr*/ nullptr,
-      /*object_address_ptr*/ nullptr);
+      &exe_ctx, /*reg_ctx=*/nullptr, /*module_sp=*/{}, extractor,
+      /*unit=*/nullptr, lldb::eRegisterKindLLDB,
+      /*initial_value_ptr=*/nullptr,
+      /*object_address_ptr=*/nullptr);
 
   ASSERT_THAT_EXPECTED(result, llvm::Succeeded());
   ASSERT_EQ(result->GetValueType(), Value::ValueType::HostAddress);

>From fed4d8bae71299ed9985a00a129ee9bcdc59ff99 Mon Sep 17 00:00:00 2001
From: Jonas Devlieghere <jo...@devlieghere.com>
Date: Mon, 28 Jul 2025 12:53:21 -0700
Subject: [PATCH 2/3] [lldb] Implement RegisterContextWasm

This PR implements a register context for Wasm, which uses virtual
registers to resolve Wasm local, globals and stack values. The registers
are used to implement supprot for `DW_OP_WASM_location` in the DWARF
expression evaluator (#151010). This also adds a more comprehensive
test, showing that we can use this to show local variables.
---
 lldb/docs/resources/lldbgdbremote.md          |  77 ++++--
 .../Plugins/Process/wasm/CMakeLists.txt       |   1 +
 .../Plugins/Process/wasm/ProcessWasm.cpp      |  33 +++
 .../source/Plugins/Process/wasm/ProcessWasm.h |   8 +
 .../Process/wasm/RegisterContextWasm.cpp      | 109 +++++++++
 .../Process/wasm/RegisterContextWasm.h        |  69 ++++++
 .../Plugins/Process/wasm/ThreadWasm.cpp       |  17 ++
 lldb/source/Plugins/Process/wasm/ThreadWasm.h |   3 +
 .../gdb_remote_client/TestWasm.py             | 225 ++++++++++++-----
 .../gdb_remote_client/simple.c                |  10 +
 .../gdb_remote_client/simple.yaml             | 228 ++++++++++++++++++
 11 files changed, 697 insertions(+), 83 deletions(-)
 create mode 100644 lldb/source/Plugins/Process/wasm/RegisterContextWasm.cpp
 create mode 100644 lldb/source/Plugins/Process/wasm/RegisterContextWasm.h
 create mode 100644 lldb/test/API/functionalities/gdb_remote_client/simple.c
 create mode 100644 lldb/test/API/functionalities/gdb_remote_client/simple.yaml

diff --git a/lldb/docs/resources/lldbgdbremote.md 
b/lldb/docs/resources/lldbgdbremote.md
index 41628cffcc566..4199d12cccd6c 100644
--- a/lldb/docs/resources/lldbgdbremote.md
+++ b/lldb/docs/resources/lldbgdbremote.md
@@ -1998,22 +1998,6 @@ threads (live system debug) / cores (JTAG) in your 
program have
 stopped and allows LLDB to display and control your program
 correctly.
 
-## qWasmCallStack
-
-Get the Wasm call stack for the given thread id. This returns a hex-encoded
-list of PC values, one for each frame of the call stack. To match the Wasm
-specification, the addresses are encoded in little endian byte order, even if
-the endian of the Wasm runtime's host is not little endian.
-
-```
-send packet: $qWasmCallStack:202dbe040#08
-read packet: $9c01000000000040e501000000000040fe01000000000040#
-```
-
-**Priority to Implement:** Only required for Wasm support. This packed is
-supported by the [WAMR](https://github.com/bytecodealliance/wasm-micro-runtime)
-and [V8](https://v8.dev) Wasm runtimes.
-
 ## qWatchpointSupportInfo
 
 Get the number of hardware watchpoints available on the remote target.
@@ -2479,3 +2463,64 @@ omitting them will work fine; these numbers are always 
base 16.
 
 The length of the payload is not provided.  A reliable, 8-bit clean,
 transport layer is assumed.
+
+## Wasm Packets
+
+The packet below are supported by the
+[WAMR](https://github.com/bytecodealliance/wasm-micro-runtime) and
+[V8](https://v8.dev) Wasm runtimes.
+
+
+## qWasmCallStack
+
+Get the Wasm call stack for the given thread id. This returns a hex-encoded
+list of PC values, one for each frame of the call stack. To match the Wasm
+specification, the addresses are encoded in little endian byte order, even if
+the endian of the Wasm runtime's host is not little endian.
+
+```
+send packet: $qWasmCallStack:202dbe040#08
+read packet: $9c01000000000040e501000000000040fe01000000000040#
+```
+
+**Priority to Implement:** Only required for Wasm support. Necessary to show
+stack traces.
+
+## qWasmGlobal
+
+Get the value of a Wasm global variable for the given frame index at the given
+variable index. The indexes are encoded as base 10. The result is a hex-encoded
+address from where to read the value.
+
+send packet: $qWasmGlobal:0;2#cb
+read packet: $e0030100#b9
+
+**Priority to Implement:** Only required for Wasm support. Necessary to show
+variables.
+
+
+## qWasmLocal
+
+Get the value of a Wasm function argument or local variable for the given frame
+index at the given variable index. The indexes are encoded as base 10. The
+result is a hex-encoded address from where to read the value.
+
+
+send packet: $qWasmLocal:0;2#cb
+read packet: $e0030100#b9
+
+**Priority to Implement:** Only required for Wasm support. Necessary to show
+variables.
+
+
+## qWasmStackValue
+
+Get the value of a Wasm local variable from the Wasm operand stack, for the
+given frame index at the given variable index. The indexes are encoded as base
+10. The result is a hex-encoded address from where to read value.
+
+send packet: $qWasmStackValue:0;2#cb
+read packet: $e0030100#b9
+
+**Priority to Implement:** Only required for Wasm support. Necessary to show
+variables.
diff --git a/lldb/source/Plugins/Process/wasm/CMakeLists.txt 
b/lldb/source/Plugins/Process/wasm/CMakeLists.txt
index ff8a3c792ad53..779b97ec90d08 100644
--- a/lldb/source/Plugins/Process/wasm/CMakeLists.txt
+++ b/lldb/source/Plugins/Process/wasm/CMakeLists.txt
@@ -1,5 +1,6 @@
 add_lldb_library(lldbPluginProcessWasm PLUGIN
   ProcessWasm.cpp
+  RegisterContextWasm.cpp
   ThreadWasm.cpp
   UnwindWasm.cpp
 
diff --git a/lldb/source/Plugins/Process/wasm/ProcessWasm.cpp 
b/lldb/source/Plugins/Process/wasm/ProcessWasm.cpp
index 3ea3ea2a46847..4482677336ca4 100644
--- a/lldb/source/Plugins/Process/wasm/ProcessWasm.cpp
+++ b/lldb/source/Plugins/Process/wasm/ProcessWasm.cpp
@@ -131,3 +131,36 @@ ProcessWasm::GetWasmCallStack(lldb::tid_t tid) {
 
   return call_stack_pcs;
 }
+
+llvm::Expected<lldb::DataBufferSP>
+ProcessWasm::GetWasmVariable(WasmVirtualRegisterKinds kind, int frame_index,
+                             int index) {
+  StreamString packet;
+  switch (kind) {
+  case eWasmTagLocal:
+    packet.Printf("qWasmLocal:");
+    break;
+  case eWasmTagGlobal:
+    packet.Printf("qWasmGlobal:");
+    break;
+  case eWasmTagOperandStack:
+    packet.PutCString("qWasmStackValue:");
+    break;
+  case eWasmTagNotAWasmLocation:
+    return llvm::createStringError("not a Wasm location");
+  }
+  packet.Printf("%d;%d", frame_index, index);
+
+  StringExtractorGDBRemote response;
+  if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response) !=
+      GDBRemoteCommunication::PacketResult::Success)
+    return llvm::createStringError("failed to send Wasm variable");
+
+  if (!response.IsNormalResponse())
+    return llvm::createStringError("failed to get response for Wasm variable");
+
+  WritableDataBufferSP buffer_sp(
+      new DataBufferHeap(response.GetStringRef().size() / 2, 0));
+  response.GetHexBytes(buffer_sp->GetData(), '\xcc');
+  return buffer_sp;
+}
diff --git a/lldb/source/Plugins/Process/wasm/ProcessWasm.h 
b/lldb/source/Plugins/Process/wasm/ProcessWasm.h
index bab14a8be7dbe..22effe7340ed7 100644
--- a/lldb/source/Plugins/Process/wasm/ProcessWasm.h
+++ b/lldb/source/Plugins/Process/wasm/ProcessWasm.h
@@ -10,6 +10,7 @@
 #define LLDB_SOURCE_PLUGINS_PROCESS_WASM_PROCESSWASM_H
 
 #include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
+#include "Utility/WasmVirtualRegisters.h"
 
 namespace lldb_private {
 namespace wasm {
@@ -71,12 +72,19 @@ class ProcessWasm : public 
process_gdb_remote::ProcessGDBRemote {
   /// Retrieve the current call stack from the WebAssembly remote process.
   llvm::Expected<std::vector<lldb::addr_t>> GetWasmCallStack(lldb::tid_t tid);
 
+  /// Query the value of a WebAssembly variable from the WebAssembly
+  /// remote process.
+  llvm::Expected<lldb::DataBufferSP>
+  GetWasmVariable(WasmVirtualRegisterKinds kind, int frame_index, int index);
+
 protected:
   std::shared_ptr<process_gdb_remote::ThreadGDBRemote>
   CreateThread(lldb::tid_t tid) override;
 
 private:
   friend class UnwindWasm;
+  friend class ThreadWasm;
+
   process_gdb_remote::GDBRemoteDynamicRegisterInfoSP &GetRegisterInfo() {
     return m_register_info_sp;
   }
diff --git a/lldb/source/Plugins/Process/wasm/RegisterContextWasm.cpp 
b/lldb/source/Plugins/Process/wasm/RegisterContextWasm.cpp
new file mode 100644
index 0000000000000..b4681718cb688
--- /dev/null
+++ b/lldb/source/Plugins/Process/wasm/RegisterContextWasm.cpp
@@ -0,0 +1,109 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 "RegisterContextWasm.h"
+#include "Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h"
+#include "ProcessWasm.h"
+#include "ThreadWasm.h"
+#include "lldb/Utility/LLDBLog.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/RegisterValue.h"
+#include "llvm/Support/Error.h"
+#include <memory>
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_private::process_gdb_remote;
+using namespace lldb_private::wasm;
+
+RegisterContextWasm::RegisterContextWasm(
+    wasm::ThreadWasm &thread, uint32_t concrete_frame_idx,
+    GDBRemoteDynamicRegisterInfoSP reg_info_sp)
+    : GDBRemoteRegisterContext(thread, concrete_frame_idx, reg_info_sp, false,
+                               false) {}
+
+RegisterContextWasm::~RegisterContextWasm() = default;
+
+uint32_t RegisterContextWasm::ConvertRegisterKindToRegisterNumber(
+    lldb::RegisterKind kind, uint32_t num) {
+  return num;
+}
+
+size_t RegisterContextWasm::GetRegisterCount() {
+  // Wasm has no registers.
+  return 0;
+}
+
+const RegisterInfo *RegisterContextWasm::GetRegisterInfoAtIndex(size_t reg) {
+  uint32_t tag = GetWasmVirtualRegisterTag(reg);
+  if (tag == eWasmTagNotAWasmLocation)
+    return m_reg_info_sp->GetRegisterInfoAtIndex(
+        GetWasmVirtualRegisterIndex(reg));
+
+  auto it = m_register_map.find(reg);
+  if (it == m_register_map.end()) {
+    WasmVirtualRegisterKinds kind = static_cast<WasmVirtualRegisterKinds>(tag);
+    std::tie(it, std::ignore) = m_register_map.insert(
+        {reg, std::make_unique<WasmVirtualRegisterInfo>(
+                  kind, GetWasmVirtualRegisterIndex(reg))});
+  }
+  return it->second.get();
+}
+
+size_t RegisterContextWasm::GetRegisterSetCount() { return 0; }
+
+const RegisterSet *RegisterContextWasm::GetRegisterSet(size_t reg_set) {
+  // Wasm has no registers.
+  return nullptr;
+}
+
+bool RegisterContextWasm::ReadRegister(const RegisterInfo *reg_info,
+                                       RegisterValue &value) {
+  // The only real registers is the PC.
+  if (reg_info->name)
+    return GDBRemoteRegisterContext::ReadRegister(reg_info, value);
+
+  // Read the virtual registers.
+  ThreadWasm *thread = static_cast<ThreadWasm *>(&GetThread());
+  ProcessWasm *process = static_cast<ProcessWasm 
*>(thread->GetProcess().get());
+  if (!thread)
+    return false;
+
+  uint32_t frame_index = m_concrete_frame_idx;
+  WasmVirtualRegisterInfo *wasm_reg_info =
+      static_cast<WasmVirtualRegisterInfo *>(
+          const_cast<RegisterInfo *>(reg_info));
+
+  llvm::Expected<DataBufferSP> maybe_buffer = process->GetWasmVariable(
+      wasm_reg_info->kind, frame_index, wasm_reg_info->index);
+  if (!maybe_buffer) {
+    LLDB_LOG_ERROR(GetLog(LLDBLog::Process), maybe_buffer.takeError(),
+                   "Failed to read Wasm local: {0}");
+    return false;
+  }
+
+  DataBufferSP buffer_sp = *maybe_buffer;
+  DataExtractor reg_data(buffer_sp, process->GetByteOrder(),
+                         process->GetAddressByteSize());
+  wasm_reg_info->byte_size = buffer_sp->GetByteSize();
+  wasm_reg_info->encoding = lldb::eEncodingUint;
+
+  Status error = value.SetValueFromData(
+      *reg_info, reg_data, reg_info->byte_offset, /*partial_data_ok=*/false);
+  return error.Success();
+}
+
+void RegisterContextWasm::InvalidateAllRegisters() {}
+
+bool RegisterContextWasm::WriteRegister(const RegisterInfo *reg_info,
+                                        const RegisterValue &value) {
+  // The only real registers is the PC.
+  if (reg_info->name)
+    return GDBRemoteRegisterContext::WriteRegister(reg_info, value);
+  return false;
+}
diff --git a/lldb/source/Plugins/Process/wasm/RegisterContextWasm.h 
b/lldb/source/Plugins/Process/wasm/RegisterContextWasm.h
new file mode 100644
index 0000000000000..7e63eb85bc75c
--- /dev/null
+++ b/lldb/source/Plugins/Process/wasm/RegisterContextWasm.h
@@ -0,0 +1,69 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 LLDB_SOURCE_PLUGINS_PROCESS_WASM_REGISTERCONTEXTWASM_H
+#define LLDB_SOURCE_PLUGINS_PROCESS_WASM_REGISTERCONTEXTWASM_H
+
+#include "Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h"
+#include "ThreadWasm.h"
+#include "Utility/WasmVirtualRegisters.h"
+#include "lldb/lldb-private-types.h"
+#include <unordered_map>
+
+namespace lldb_private {
+namespace wasm {
+
+class RegisterContextWasm;
+
+typedef std::shared_ptr<RegisterContextWasm> RegisterContextWasmSP;
+
+struct WasmVirtualRegisterInfo : public RegisterInfo {
+  WasmVirtualRegisterKinds kind;
+  uint32_t index;
+
+  WasmVirtualRegisterInfo(WasmVirtualRegisterKinds kind, uint32_t index)
+      : RegisterInfo(), kind(kind), index(index) {}
+};
+
+class RegisterContextWasm
+    : public process_gdb_remote::GDBRemoteRegisterContext {
+public:
+  RegisterContextWasm(
+      wasm::ThreadWasm &thread, uint32_t concrete_frame_idx,
+      process_gdb_remote::GDBRemoteDynamicRegisterInfoSP reg_info_sp);
+
+  ~RegisterContextWasm() override;
+
+  uint32_t ConvertRegisterKindToRegisterNumber(lldb::RegisterKind kind,
+                                               uint32_t num) override;
+
+  void InvalidateAllRegisters() override;
+
+  size_t GetRegisterCount() override;
+
+  const RegisterInfo *GetRegisterInfoAtIndex(size_t reg) override;
+
+  size_t GetRegisterSetCount() override;
+
+  const RegisterSet *GetRegisterSet(size_t reg_set) override;
+
+  bool ReadRegister(const RegisterInfo *reg_info,
+                    RegisterValue &value) override;
+
+  bool WriteRegister(const RegisterInfo *reg_info,
+                     const RegisterValue &value) override;
+
+private:
+  std::unordered_map<size_t, std::unique_ptr<WasmVirtualRegisterInfo>>
+      m_register_map;
+};
+
+} // namespace wasm
+} // namespace lldb_private
+
+#endif
diff --git a/lldb/source/Plugins/Process/wasm/ThreadWasm.cpp 
b/lldb/source/Plugins/Process/wasm/ThreadWasm.cpp
index a6553ffffedaa..0666b75d4afe0 100644
--- a/lldb/source/Plugins/Process/wasm/ThreadWasm.cpp
+++ b/lldb/source/Plugins/Process/wasm/ThreadWasm.cpp
@@ -9,6 +9,7 @@
 #include "ThreadWasm.h"
 
 #include "ProcessWasm.h"
+#include "RegisterContextWasm.h"
 #include "UnwindWasm.h"
 #include "lldb/Target/Target.h"
 
@@ -32,3 +33,19 @@ llvm::Expected<std::vector<lldb::addr_t>> 
ThreadWasm::GetWasmCallStack() {
   }
   return llvm::createStringError("no process");
 }
+
+lldb::RegisterContextSP
+ThreadWasm::CreateRegisterContextForFrame(StackFrame *frame) {
+  uint32_t concrete_frame_idx = 0;
+  ProcessSP process_sp(GetProcess());
+  ProcessWasm *wasm_process = static_cast<ProcessWasm *>(process_sp.get());
+
+  if (frame)
+    concrete_frame_idx = frame->GetConcreteFrameIndex();
+
+  if (concrete_frame_idx == 0)
+    return std::make_shared<RegisterContextWasm>(
+        *this, concrete_frame_idx, wasm_process->GetRegisterInfo());
+
+  return GetUnwinder().CreateRegisterContextForFrame(frame);
+}
diff --git a/lldb/source/Plugins/Process/wasm/ThreadWasm.h 
b/lldb/source/Plugins/Process/wasm/ThreadWasm.h
index 1c90f58767bc8..c2f5762b30484 100644
--- a/lldb/source/Plugins/Process/wasm/ThreadWasm.h
+++ b/lldb/source/Plugins/Process/wasm/ThreadWasm.h
@@ -25,6 +25,9 @@ class ThreadWasm : public process_gdb_remote::ThreadGDBRemote 
{
   /// Retrieve the current call stack from the WebAssembly remote process.
   llvm::Expected<std::vector<lldb::addr_t>> GetWasmCallStack();
 
+  lldb::RegisterContextSP
+  CreateRegisterContextForFrame(StackFrame *frame) override;
+
 protected:
   Unwind &GetUnwinder() override;
 
diff --git a/lldb/test/API/functionalities/gdb_remote_client/TestWasm.py 
b/lldb/test/API/functionalities/gdb_remote_client/TestWasm.py
index 445f4222e2179..73c81efb79347 100644
--- a/lldb/test/API/functionalities/gdb_remote_client/TestWasm.py
+++ b/lldb/test/API/functionalities/gdb_remote_client/TestWasm.py
@@ -1,12 +1,15 @@
 import lldb
+import os
 import binascii
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test.decorators import *
 from lldbsuite.test.gdbclientutils import *
 from lldbsuite.test.lldbgdbclient import GDBRemoteTestBase
 
-LLDB_INVALID_ADDRESS = lldb.LLDB_INVALID_ADDRESS
-load_address = 0x400000000
+MODULE_ID = 4
+LOAD_ADDRESS = MODULE_ID << 32
+WASM_LOCAL_ADDR = 0x103E0
+
 
 def format_register_value(val):
     """
@@ -23,12 +26,59 @@ def format_register_value(val):
     return result
 
 
+class WasmStackFrame:
+    def __init__(self, address):
+        self._address = address
+
+    def __str__(self):
+        return format_register_value(LOAD_ADDRESS | self._address)
+
+
+class WasmCallStack:
+    def __init__(self, wasm_stack_frames):
+        self._wasm_stack_frames = wasm_stack_frames
+
+    def __str__(self):
+        result = ""
+        for frame in self._wasm_stack_frames:
+            result += str(frame)
+        return result
+
+
+class FakeMemory:
+    def __init__(self, start_addr, end_addr):
+        self._base_addr = start_addr
+        self._memory = bytearray(end_addr - start_addr)
+        self._memoryview = memoryview(self._memory)
+
+    def store_bytes(self, addr, bytes_obj):
+        assert addr > self._base_addr
+        assert addr < self._base_addr + len(self._memoryview)
+        offset = addr - self._base_addr
+        chunk = self._memoryview[offset : offset + len(bytes_obj)]
+        for i in range(len(bytes_obj)):
+            chunk[i] = bytes_obj[i]
+
+    def get_bytes(self, addr, length):
+        assert addr > self._base_addr
+        assert addr < self._base_addr + len(self._memoryview)
+
+        offset = addr - self._base_addr
+        return self._memoryview[offset : offset + length]
+
+    def contains(self, addr):
+        return addr - self._base_addr < len(self._memoryview)
+
+
 class MyResponder(MockGDBServerResponder):
-    current_pc = load_address + 0x0A
+    current_pc = LOAD_ADDRESS | 0x01AD
 
-    def __init__(self, obj_path, module_name=""):
+    def __init__(self, obj_path, module_name="", wasm_call_stacks=[], 
memory=None):
         self._obj_path = obj_path
         self._module_name = module_name or obj_path
+        self._wasm_call_stacks = wasm_call_stacks
+        self._call_stack_request_count = 0
+        self._memory = memory
         MockGDBServerResponder.__init__(self)
 
     def respond(self, packet):
@@ -36,6 +86,8 @@ def respond(self, packet):
             return self.qRegisterInfo(packet[13:])
         if packet.startswith("qWasmCallStack"):
             return self.qWasmCallStack()
+        if packet.startswith("qWasmLocal"):
+            return self.qWasmLocal(packet)
         return MockGDBServerResponder.respond(self, packet)
 
     def qSupported(self, client_supported):
@@ -71,28 +123,61 @@ def qXferRead(self, obj, annex, offset, length):
         if obj == "libraries":
             xml = (
                 '<library-list><library name="%s"><section 
address="%d"/></library></library-list>'
-                % (self._module_name, load_address)
+                % (self._module_name, LOAD_ADDRESS)
             )
             return xml, False
         else:
             return None, False
 
     def readMemory(self, addr, length):
-        if addr < load_address:
+        if self._memory and self._memory.contains(addr):
+            chunk = self._memory.get_bytes(addr, length)
+            return chunk.hex()
+        if addr < LOAD_ADDRESS:
             return "E02"
         result = ""
         with open(self._obj_path, mode="rb") as file:
             file_content = bytearray(file.read())
-            addr_from = addr - load_address
+            if addr >= LOAD_ADDRESS + len(file_content):
+                return "E03"
+            addr_from = addr - LOAD_ADDRESS
             addr_to = addr_from + min(length, len(file_content) - addr_from)
             for i in range(addr_from, addr_to):
                 result += format(file_content[i], "02x")
             file.close()
         return result
 
+    def setBreakpoint(self, packet):
+        bp_data = packet[1:].split(",")
+        self._bp_address = bp_data[1]
+        return "OK"
+
+    def qfThreadInfo(self):
+        return "m1"
+
+    def cont(self):
+        # Continue execution. Simulates running the Wasm engine until a 
breakpoint is hit.
+        return (
+            "T05thread-pcs:"
+            + format(int(self._bp_address, 16) & 0x3FFFFFFFFFFFFFFF, "x")
+            + ";thread:1"
+        )
+
     def qWasmCallStack(self):
-        # Return two 64-bit addresses: 0x40000000000001B3, 0x40000000000001FE
-        return "b301000000000040fe01000000000040"
+        if len(self._wasm_call_stacks) == 0:
+            return ""
+        result = str(self._wasm_call_stacks[self._call_stack_request_count])
+        self._call_stack_request_count += 1
+        return result
+
+    def qWasmLocal(self, packet):
+        # Format: qWasmLocal:frame_index;index
+        data = packet.split(":")
+        data = data[1].split(";")
+        frame_index, local_index = data
+        if frame_index == "0" and local_index == "2":
+            return format_register_value(WASM_LOCAL_ADDR)
+        return "E03"
 
 
 class TestWasm(GDBRemoteTestBase):
@@ -124,35 +209,35 @@ def 
test_load_module_with_embedded_symbols_from_remote(self):
         code_section = module.GetSectionAtIndex(0)
         self.assertEqual("code", code_section.GetName())
         self.assertEqual(
-            load_address | code_section.GetFileOffset(),
+            LOAD_ADDRESS | code_section.GetFileOffset(),
             code_section.GetLoadAddress(target),
         )
 
         debug_info_section = module.GetSectionAtIndex(1)
         self.assertEqual(".debug_info", debug_info_section.GetName())
         self.assertEqual(
-            load_address | debug_info_section.GetFileOffset(),
+            LOAD_ADDRESS | debug_info_section.GetFileOffset(),
             debug_info_section.GetLoadAddress(target),
         )
 
         debug_abbrev_section = module.GetSectionAtIndex(2)
         self.assertEqual(".debug_abbrev", debug_abbrev_section.GetName())
         self.assertEqual(
-            load_address | debug_abbrev_section.GetFileOffset(),
+            LOAD_ADDRESS | debug_abbrev_section.GetFileOffset(),
             debug_abbrev_section.GetLoadAddress(target),
         )
 
         debug_line_section = module.GetSectionAtIndex(3)
         self.assertEqual(".debug_line", debug_line_section.GetName())
         self.assertEqual(
-            load_address | debug_line_section.GetFileOffset(),
+            LOAD_ADDRESS | debug_line_section.GetFileOffset(),
             debug_line_section.GetLoadAddress(target),
         )
 
         debug_str_section = module.GetSectionAtIndex(4)
         self.assertEqual(".debug_str", debug_str_section.GetName())
         self.assertEqual(
-            load_address | debug_line_section.GetFileOffset(),
+            LOAD_ADDRESS | debug_line_section.GetFileOffset(),
             debug_line_section.GetLoadAddress(target),
         )
 
@@ -194,97 +279,103 @@ def 
test_load_module_with_stripped_symbols_from_remote(self):
         code_section = module.GetSectionAtIndex(0)
         self.assertEqual("code", code_section.GetName())
         self.assertEqual(
-            load_address | code_section.GetFileOffset(),
+            LOAD_ADDRESS | code_section.GetFileOffset(),
             code_section.GetLoadAddress(target),
         )
 
         debug_info_section = module.GetSectionAtIndex(1)
         self.assertEqual(".debug_info", debug_info_section.GetName())
         self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_info_section.GetLoadAddress(target)
+            lldb.LLDB_INVALID_ADDRESS, 
debug_info_section.GetLoadAddress(target)
         )
 
         debug_abbrev_section = module.GetSectionAtIndex(2)
         self.assertEqual(".debug_abbrev", debug_abbrev_section.GetName())
         self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_abbrev_section.GetLoadAddress(target)
+            lldb.LLDB_INVALID_ADDRESS, 
debug_abbrev_section.GetLoadAddress(target)
         )
 
         debug_line_section = module.GetSectionAtIndex(3)
         self.assertEqual(".debug_line", debug_line_section.GetName())
         self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_line_section.GetLoadAddress(target)
+            lldb.LLDB_INVALID_ADDRESS, 
debug_line_section.GetLoadAddress(target)
         )
 
         debug_str_section = module.GetSectionAtIndex(4)
         self.assertEqual(".debug_str", debug_str_section.GetName())
         self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_line_section.GetLoadAddress(target)
+            lldb.LLDB_INVALID_ADDRESS, 
debug_line_section.GetLoadAddress(target)
         )
 
     @skipIfAsan
     @skipIfXmlSupportMissing
-    def test_load_module_from_file(self):
-        """Test connecting to a WebAssembly engine via GDB-remote and loading 
a Wasm module from a file"""
-
-        yaml_path = "test_wasm_embedded_debug_sections.yaml"
-        yaml_base, ext = os.path.splitext(yaml_path)
+    def test_simple_wasm_debugging_session(self):
+        """Test connecting to a WebAssembly engine via GDB-remote, loading a
+        Wasm module with embedded DWARF symbols, setting a breakpoint and
+        checking the debuggee state"""
+
+        # simple.yaml was created by compiling simple.c to wasm and using
+        # obj2yaml on the output.
+        #
+        # $ clang -target wasm32 -nostdlib -Wl,--no-entry -Wl,--export-all -O0 
-g -o simple.wasm simple.c
+        # $ obj2yaml simple.wasm -o simple.yaml
+        yaml_path = "simple.yaml"
+        yaml_base, _ = os.path.splitext(yaml_path)
         obj_path = self.getBuildArtifact(yaml_base)
         self.yaml2obj(yaml_path, obj_path)
 
-        self.server.responder = MyResponder(obj_path)
+        # Create a fake call stack.
+        call_stacks = [
+            WasmCallStack(
+                [WasmStackFrame(0x019C), WasmStackFrame(0x01E5), 
WasmStackFrame(0x01FE)]
+            ),
+        ]
+
+        # Create fake memory for our wasm locals.
+        self.memory = FakeMemory(0x10000, 0x20000)
+        self.memory.store_bytes(
+            WASM_LOCAL_ADDR,
+            bytes.fromhex(
+                
"0000000000000000020000000100000000000000020000000100000000000000"
+            ),
+        )
+
+        self.server.responder = MyResponder(
+            obj_path, "test_wasm", call_stacks, self.memory
+        )
 
         target = self.dbg.CreateTarget("")
+        breakpoint = target.BreakpointCreateByName("add")
         process = self.connect(target, "wasm")
         lldbutil.expect_state_changes(
             self, self.dbg.GetListener(), process, [lldb.eStateStopped]
         )
 
+        location = breakpoint.GetLocationAtIndex(0)
+        self.assertTrue(location and location.IsEnabled(), 
VALID_BREAKPOINT_LOCATION)
+
         num_modules = target.GetNumModules()
         self.assertEqual(1, num_modules)
 
-        module = target.GetModuleAtIndex(0)
-        num_sections = module.GetNumSections()
-        self.assertEqual(5, num_sections)
-
-        code_section = module.GetSectionAtIndex(0)
-        self.assertEqual("code", code_section.GetName())
-        self.assertEqual(
-            load_address | code_section.GetFileOffset(),
-            code_section.GetLoadAddress(target),
-        )
-
-        debug_info_section = module.GetSectionAtIndex(1)
-        self.assertEqual(".debug_info", debug_info_section.GetName())
-        self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_info_section.GetLoadAddress(target)
-        )
-
-        debug_abbrev_section = module.GetSectionAtIndex(2)
-        self.assertEqual(".debug_abbrev", debug_abbrev_section.GetName())
-        self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_abbrev_section.GetLoadAddress(target)
-        )
-
-        debug_line_section = module.GetSectionAtIndex(3)
-        self.assertEqual(".debug_line", debug_line_section.GetName())
-        self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_line_section.GetLoadAddress(target)
-        )
-
-        debug_str_section = module.GetSectionAtIndex(4)
-        self.assertEqual(".debug_str", debug_str_section.GetName())
-        self.assertEqual(
-            LLDB_INVALID_ADDRESS, debug_line_section.GetLoadAddress(target)
-        )
-
         thread = process.GetThreadAtIndex(0)
         self.assertTrue(thread.IsValid())
 
-        frame = thread.GetFrameAtIndex(0)
-        self.assertTrue(frame.IsValid())
-        self.assertEqual(frame.GetPC(), 0x40000000000001B3)
-
-        frame = thread.GetFrameAtIndex(1)
-        self.assertTrue(frame.IsValid())
-        self.assertEqual(frame.GetPC(), 0x40000000000001FE)
+        # Check that our frames match our fake call stack.
+        frame0 = thread.GetFrameAtIndex(0)
+        self.assertTrue(frame0.IsValid())
+        self.assertEqual(frame0.GetPC(), LOAD_ADDRESS | 0x019C)
+        self.assertIn("add", frame0.GetFunctionName())
+
+        frame1 = thread.GetFrameAtIndex(1)
+        self.assertTrue(frame1.IsValid())
+        self.assertEqual(frame1.GetPC(), LOAD_ADDRESS | 0x01E5)
+        self.assertIn("main", frame1.GetFunctionName())
+
+        # Check that we can resolve local variables.
+        a = frame0.FindVariable("a")
+        self.assertTrue(a.IsValid())
+        self.assertEqual(a.GetValueAsUnsigned(), 1)
+
+        b = frame0.FindVariable("b")
+        self.assertTrue(b.IsValid())
+        self.assertEqual(b.GetValueAsUnsigned(), 2)
diff --git a/lldb/test/API/functionalities/gdb_remote_client/simple.c 
b/lldb/test/API/functionalities/gdb_remote_client/simple.c
new file mode 100644
index 0000000000000..62ca1fe4d0190
--- /dev/null
+++ b/lldb/test/API/functionalities/gdb_remote_client/simple.c
@@ -0,0 +1,10 @@
+int add(int a, int b) {
+  // Break here
+  return a + b;
+}
+
+int main() {
+  int i = 1;
+  int j = 2;
+  return add(i, j);
+}
diff --git a/lldb/test/API/functionalities/gdb_remote_client/simple.yaml 
b/lldb/test/API/functionalities/gdb_remote_client/simple.yaml
new file mode 100644
index 0000000000000..cf1b7d82d1f80
--- /dev/null
+++ b/lldb/test/API/functionalities/gdb_remote_client/simple.yaml
@@ -0,0 +1,228 @@
+--- !WASM
+FileHeader:
+  Version:         0x1
+Sections:
+  - Type:            TYPE
+    Signatures:
+      - Index:           0
+        ParamTypes:      []
+        ReturnTypes:     []
+      - Index:           1
+        ParamTypes:
+          - I32
+          - I32
+        ReturnTypes:
+          - I32
+      - Index:           2
+        ParamTypes:      []
+        ReturnTypes:
+          - I32
+  - Type:            FUNCTION
+    FunctionTypes:   [ 0, 1, 2, 1 ]
+  - Type:            TABLE
+    Tables:
+      - Index:           0
+        ElemType:        FUNCREF
+        Limits:
+          Flags:           [ HAS_MAX ]
+          Minimum:         0x1
+          Maximum:         0x1
+  - Type:            MEMORY
+    Memories:
+      - Minimum:         0x2
+  - Type:            GLOBAL
+    Globals:
+      - Index:           0
+        Type:            I32
+        Mutable:         true
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           66560
+      - Index:           1
+        Type:            I32
+        Mutable:         false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           1024
+      - Index:           2
+        Type:            I32
+        Mutable:         false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           1024
+      - Index:           3
+        Type:            I32
+        Mutable:         false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           1024
+      - Index:           4
+        Type:            I32
+        Mutable:         false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           66560
+      - Index:           5
+        Type:            I32
+        Mutable:         false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           1024
+      - Index:           6
+        Type:            I32
+        Mutable:         false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           66560
+      - Index:           7
+        Type:            I32
+        Mutable:         false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           131072
+      - Index:           8
+        Type:            I32
+        Mutable:         false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           0
+      - Index:           9
+        Type:            I32
+        Mutable:         false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           1
+      - Index:           10
+        Type:            I32
+        Mutable:         false
+        InitExpr:
+          Opcode:          I32_CONST
+          Value:           65536
+  - Type:            EXPORT
+    Exports:
+      - Name:            memory
+        Kind:            MEMORY
+        Index:           0
+      - Name:            __wasm_call_ctors
+        Kind:            FUNCTION
+        Index:           0
+      - Name:            add
+        Kind:            FUNCTION
+        Index:           1
+      - Name:            __original_main
+        Kind:            FUNCTION
+        Index:           2
+      - Name:            main
+        Kind:            FUNCTION
+        Index:           3
+      - Name:            __main_void
+        Kind:            FUNCTION
+        Index:           2
+      - Name:            __indirect_function_table
+        Kind:            TABLE
+        Index:           0
+      - Name:            __dso_handle
+        Kind:            GLOBAL
+        Index:           1
+      - Name:            __data_end
+        Kind:            GLOBAL
+        Index:           2
+      - Name:            __stack_low
+        Kind:            GLOBAL
+        Index:           3
+      - Name:            __stack_high
+        Kind:            GLOBAL
+        Index:           4
+      - Name:            __global_base
+        Kind:            GLOBAL
+        Index:           5
+      - Name:            __heap_base
+        Kind:            GLOBAL
+        Index:           6
+      - Name:            __heap_end
+        Kind:            GLOBAL
+        Index:           7
+      - Name:            __memory_base
+        Kind:            GLOBAL
+        Index:           8
+      - Name:            __table_base
+        Kind:            GLOBAL
+        Index:           9
+      - Name:            __wasm_first_page_end
+        Kind:            GLOBAL
+        Index:           10
+  - Type:            CODE
+    Functions:
+      - Index:           0
+        Locals:          []
+        Body:            0B
+      - Index:           1
+        Locals:
+          - Type:            I32
+            Count:           1
+        Body:            
23808080800041106B21022002200036020C20022001360208200228020C20022802086A0F0B
+      - Index:           2
+        Locals:
+          - Type:            I32
+            Count:           2
+        Body:            
23808080800041106B210020002480808080002000410036020C2000410136020820004102360204200028020820002802041081808080002101200041106A24808080800020010F0B
+      - Index:           3
+        Locals:          []
+        Body:            1082808080000F0B
+  - Type:            CUSTOM
+    Name:            .debug_abbrev
+    Payload:         
011101250E1305030E10171B0E110155170000022E01110112064018030E3A0B3B0B271949133F1900000305000218030E3A0B3B0B49130000042E01110112064018030E3A0B3B0B49133F1900000534000218030E3A0B3B0B49130000062400030E3E0B0B0B000000
+  - Type:            CUSTOM
+    Name:            .debug_info
+    Payload:         
940000000400000000000401620000001D0055000000000000000D000000000000000000000002050000002900000004ED00029F510000000101900000000302910C60000000010190000000030291085E00000001019000000000042F0000004C00000004ED00009F04000000010690000000050291080B0000000107900000000502910409000000010890000000000600000000050400
+  - Type:            CUSTOM
+    Name:            .debug_ranges
+    Payload:         050000002E0000002F0000007B0000000000000000000000
+  - Type:            CUSTOM
+    Name:            .debug_str
+    Payload:         
696E74006D61696E006A0069002F55736572732F6A6F6E61732F7761736D2D6D6963726F2D72756E74696D652F70726F647563742D6D696E692F706C6174666F726D732F64617277696E2F6275696C64006164640073696D706C652E630062006100636C616E672076657273696F6E2032322E302E306769742028676974406769746875622E636F6D3A4A4465766C696567686572652F6C6C766D2D70726F6A6563742E67697420343161363839613132323834633834623632383933393461356338306264636534383733656466302900
+  - Type:            CUSTOM
+    Name:            .debug_line
+    Payload:         
62000000040020000000010101FB0E0D0001010101000000010000010073696D706C652E6300000000000005020500000001050A0A08AE050E0658050C5805032002020001010005022F0000001705070A08BB75050E7505110658050A58050382020F000101
+  - Type:            CUSTOM
+    Name:            name
+    FunctionNames:
+      - Index:           0
+        Name:            __wasm_call_ctors
+      - Index:           1
+        Name:            add
+      - Index:           2
+        Name:            __original_main
+      - Index:           3
+        Name:            main
+    GlobalNames:
+      - Index:           0
+        Name:            __stack_pointer
+  - Type:            CUSTOM
+    Name:            producers
+    Languages:
+      - Name:            C11
+        Version:         ''
+    Tools:
+      - Name:            clang
+        Version:         '22.0.0git'
+  - Type:            CUSTOM
+    Name:            target_features
+    Features:
+      - Prefix:          USED
+        Name:            bulk-memory
+      - Prefix:          USED
+        Name:            bulk-memory-opt
+      - Prefix:          USED
+        Name:            call-indirect-overlong
+      - Prefix:          USED
+        Name:            multivalue
+      - Prefix:          USED
+        Name:            mutable-globals
+      - Prefix:          USED
+        Name:            nontrapping-fptoint
+      - Prefix:          USED
+        Name:            reference-types
+      - Prefix:          USED
+        Name:            sign-ext
+...

>From b35b16b725d24634a2d59e7057b308653752029e Mon Sep 17 00:00:00 2001
From: Jonas Devlieghere <jo...@devlieghere.com>
Date: Wed, 30 Jul 2025 07:30:44 -0700
Subject: [PATCH 3/3] Fix markdown

---
 lldb/docs/resources/lldbgdbremote.md | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/lldb/docs/resources/lldbgdbremote.md 
b/lldb/docs/resources/lldbgdbremote.md
index 4199d12cccd6c..36b95f1073ebc 100644
--- a/lldb/docs/resources/lldbgdbremote.md
+++ b/lldb/docs/resources/lldbgdbremote.md
@@ -2471,7 +2471,7 @@ The packet below are supported by the
 [V8](https://v8.dev) Wasm runtimes.
 
 
-## qWasmCallStack
+### qWasmCallStack
 
 Get the Wasm call stack for the given thread id. This returns a hex-encoded
 list of PC values, one for each frame of the call stack. To match the Wasm
@@ -2486,41 +2486,47 @@ read packet: 
$9c01000000000040e501000000000040fe01000000000040#
 **Priority to Implement:** Only required for Wasm support. Necessary to show
 stack traces.
 
-## qWasmGlobal
+### qWasmGlobal
 
 Get the value of a Wasm global variable for the given frame index at the given
 variable index. The indexes are encoded as base 10. The result is a hex-encoded
 address from where to read the value.
 
+```
 send packet: $qWasmGlobal:0;2#cb
 read packet: $e0030100#b9
+```
 
 **Priority to Implement:** Only required for Wasm support. Necessary to show
 variables.
 
 
-## qWasmLocal
+### qWasmLocal
 
 Get the value of a Wasm function argument or local variable for the given frame
 index at the given variable index. The indexes are encoded as base 10. The
 result is a hex-encoded address from where to read the value.
 
 
+```
 send packet: $qWasmLocal:0;2#cb
 read packet: $e0030100#b9
+```
 
 **Priority to Implement:** Only required for Wasm support. Necessary to show
 variables.
 
 
-## qWasmStackValue
+### qWasmStackValue
 
 Get the value of a Wasm local variable from the Wasm operand stack, for the
 given frame index at the given variable index. The indexes are encoded as base
 10. The result is a hex-encoded address from where to read value.
 
+```
 send packet: $qWasmStackValue:0;2#cb
 read packet: $e0030100#b9
+```
 
 **Priority to Implement:** Only required for Wasm support. Necessary to show
 variables.

_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits

Reply via email to