[LLDB] Add support for WebAssembly debugging

[paolosev]

Summary

This patch is a refactoring of https://reviews.llvm.org/D78801. As suggested, I have created a separate patch to more easily compare the implementations.
Even here, the goal is to use the GDB-remote protocol to connect to a Wasm engine that implements a GDB-remote stub that offers the ability to access the engine runtime internal state.

Here I am removing the interface IWasmProcess and the new class WasmProcessGDBRemote and moving most of the Wasm logic in ProcessGDBRemote.
I am still adding the new Unwind class UnwindWasm, which now however is in core and not in plugins code. Having a Unwind-derived class for Wasm unwinding seems to be the cleanest solution.

The advantage with this new design is that the required changes are smaller and isolated in a few places.
The drawback is that three 'core' classes (UnwindWasm, Value and DWARFExpression) have now a dependency on ProcessGDBRemote and/or ThreadGDBRemote. This could be avoided re-introducing a core interface like IWasmProcess. We could add a couple of virtual method bool IsWasmProcess() and IWasmProcess* AsWasmProcess() to Process, which would be overridden by ProcessGDBRemote. Then these classes could just query this interface, removing direct dependencies on GDBRemote.

I am also adding a new qSupported flag named "wasm" that should tell LLDB whether the remote supports Wasm debugging.

[• vwzm228]

Is there any progress about such patch and D78801？

I have implemented the debugging feature in our Wasm VM based on https://reviews.llvm.org/D78801, and it already work to attach, set breakpoint, step, show variable value, backtrace...

I am not sure if I need to change LLDB part to this one, or keep using D78801.

But if both patches wont be merged, I have to maintain a private LLDB version....

[paolosev]

In D78978#2481358, @vwzm228 wrote:

Is there any progress about such patch and D78801？

I have implemented the debugging feature in our Wasm VM based on https://reviews.llvm.org/D78801, and it already work to attach, set breakpoint, step, show variable value, backtrace...

I am not sure if I need to change LLDB part to this one, or keep using D78801.

But if both patches wont be merged, I have to maintain a private LLDB version....

Unfortunately I have not received any more feedback for this patch, or the alternative version D78801, so I assumed it won't move forward :(
Meanwhile, I have created a personal fork (https://github.com/paolosevMSFT/llvm-project/tree/WasmDbg).

I still think that it would be very useful to add support for Wasm debugging to LLDB. Especially in scenarios where Wasm is not used as part of a web app, but server side (node.js) or running on micro runtime for IoT devices.
I know that there is the problem that LLDB does not support segmented address spaces, and so this patch requires a couple of tiny but smelly changes to core code.
From the mailing list I seem to remember that somebody was working to add support for segmented addresses, but I don't know what is the current state of the initiative.

I'd be happy to keep working on this, please let me know what I could do to progress toward an acceptable solution.

[dblaikie]

In D78978#2483327, @paolosev wrote:

In D78978#2481358, @vwzm228 wrote:

Is there any progress about such patch and D78801？

I have implemented the debugging feature in our Wasm VM based on https://reviews.llvm.org/D78801, and it already work to attach, set breakpoint, step, show variable value, backtrace...

I am not sure if I need to change LLDB part to this one, or keep using D78801.

But if both patches wont be merged, I have to maintain a private LLDB version....

Unfortunately I have not received any more feedback for this patch, or the alternative version D78801, so I assumed it won't move forward :(
Meanwhile, I have created a personal fork (https://github.com/paolosevMSFT/llvm-project/tree/WasmDbg).

I still think that it would be very useful to add support for Wasm debugging to LLDB. Especially in scenarios where Wasm is not used as part of a web app, but server side (node.js) or running on micro runtime for IoT devices.
I know that there is the problem that LLDB does not support segmented address spaces, and so this patch requires a couple of tiny but smelly changes to core code.
From the mailing list I seem to remember that somebody was working to add support for segmented addresses, but I don't know what is the current state of the initiative.

I'd be happy to keep working on this, please let me know what I could do to progress toward an acceptable solution.

Usually the thing is to ping the review thread at most weekly & maybe search around for specific reviewers to ask if you're met with a lot of silence.

[paolosev]

In D78978#2483354, @dblaikie wrote:

Usually the thing is to ping the review thread at most weekly & maybe search around for specific reviewers to ask if you're met with a lot of silence.

There was not a lot of feedback on this thread, but if you look at https://reviews.llvm.org/D78801, the discussion there was huge :)
But it's a good point! I'll post the same message there.

[aprantl]

What's the testing story for WASM going to be?

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

300

Nit:

/ WebAssembly-specific commands
/ \{
...
/// \}

Even better would be doxygen comments for all functions.

[paolosev]

In D78978#2488134, @aprantl wrote:

What's the testing story for WASM going to be?

Thanks for the feedback @aprantl!
This patch was also create to show a possible alternative to https://reviews.llvm.org/D78801, but D78801 has evolved since then and I should probably close/abandon this one.

I had not looked at the testing story for Wasm yet because it seemed that the changes to the core code could have been a showstopper, but we would need to test a process connected to LLDB through a GDBRemote connection.
I see that this is normally done using the lldbsuite package, GdbRemoteTestCaseBase, which actually launches the debuggee process.
We cannot do the same for Wasm, we cannot run a JS engine that implements a GDB Stub here. We should instead write code similar to GdbRemoteTestCaseBase that simulates a Wasm process, implementing a GDB stub, handling GDBRemote messages (both generic and Wasm-specific).
(This is the opposite of the work done to test the implementation of the GDB Stub in V8: there we had the process and we had to simulate the debugger).

Furthermore, we could also extend:

• test\Shell\Reproducer\TestGDBRemoteRepro.test
• test\API\functionalities\gdb_remote_client\TestGDBRemoteClient.py

with other Wasm-specific tests.

[aprantl]

Thanks for the explanation!

lldb/include/lldb/Target/UnwindWasm.h

+//===-- UnwindWasm.h --------------------------------------------*- 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 LLDB_TARGET_UNWINDWASM_H
+#define LLDB_TARGET_UNWINDWASM_H
+
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Unwind.h"
+#include <vector>
+
+namespace lldb_private {
+
+class UnwindWasm : public Unwind {
+public:
+  UnwindWasm(lldb_private::Thread &thread)
+      : Unwind(thread), m_frames(), m_unwind_complete(false) {}
+  ~UnwindWasm() override = default;
+
+protected:
+  void DoClear() override {
+    m_frames.clear();
+    m_unwind_complete = false;
+  }
+
+  uint32_t DoGetFrameCount() override;
+
+  bool DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
+                             lldb::addr_t &pc,
+                             bool &behaves_like_zeroth_frame) override;
+  lldb::RegisterContextSP
+  DoCreateRegisterContextForFrame(lldb_private::StackFrame *frame) override;
+
+private:
+  std::vector<lldb::addr_t> m_frames;
+  bool m_unwind_complete;
+
+  DISALLOW_COPY_AND_ASSIGN(UnwindWasm);
+};
+
+} // namespace lldb_private
+
+#endif // LLDB_TARGET_UNWINDWASM_H

lldb/source/Core/Value.cpp

 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-forward.h"
 #include "lldb/lldb-types.h"
 
+#include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
+
 #include <memory>
 #include <string>
 
 #include <inttypes.h>
 
 using namespace lldb;
 using namespace lldb_private;
 
if (address_type == eAddressTypeHost) {
       } else {
         // The execution context might have a NULL process, but it might have a
         // valid process in the exe_ctx->target, so use the
         // ExecutionContext::GetProcess accessor to ensure we get the process
         // if there is one.
         Process *process = exe_ctx->GetProcessPtr();
 
         if (process) {
-          const size_t bytes_read =
-              process->ReadMemory(address, dst, byte_size, error);
+          StackFrame *frame = exe_ctx->GetFramePtr();
+          size_t bytes_read = 0;
+
+          bool isWasm =
+              frame
+                  ? (frame->CalculateTarget()->GetArchitecture().GetMachine() ==
+                     llvm::Triple::wasm32)
+                  : false;
+          if (isWasm) {
+            int frame_index = frame->GetConcreteFrameIndex();
+            process_gdb_remote::ProcessGDBRemote *wasm_process =
+                static_cast<process_gdb_remote::ProcessGDBRemote *>(
+                    frame->CalculateProcess().get());
+            if (wasm_process->WasmReadMemory(frame_index, address, dst,
+                                             byte_size)) {
+              bytes_read = byte_size;
+            }
+          } else {
+            bytes_read = process->ReadMemory(address, dst, byte_size, error);
+          }
+
           if (bytes_read != byte_size)
             error.SetErrorStringWithFormat(
                 "read memory from 0x%" PRIx64 " failed (%u of %u bytes read)",
                 (uint64_t)address, (uint32_t)bytes_read, (uint32_t)byte_size);
         } else {
           error.SetErrorStringWithFormat("read memory from 0x%" PRIx64
                                          " failed (invalid process)",
                                          (uint64_t)address);

lldb/source/Expression/DWARFExpression.cpp

 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/StackID.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 
+#include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
 #include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static lldb::addr_t
 ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
                                 uint32_t index) {
case DW_OP_GNU_push_tls_address: {
               "No TLS data currently exists for this thread.");
         return false;
       }
 
       stack.back().GetScalar() = tls_load_addr;
       stack.back().SetValueType(Value::eValueTypeLoadAddress);
     } break;
 
+    case DW_OP_WASM_location: {
+      if (frame) {
+        const llvm::Triple::ArchType machine =
+            frame->CalculateTarget()->GetArchitecture().GetMachine();
+        if (machine == llvm::Triple::wasm32) {
+          process_gdb_remote::ProcessGDBRemote *wasm_process =
+              static_cast<process_gdb_remote::ProcessGDBRemote *>(
+                  frame->CalculateProcess().get());
+          int frame_index = frame->GetConcreteFrameIndex();
+          uint64_t wasm_op = opcodes.GetULEB128(&offset);
+          uint64_t index = opcodes.GetULEB128(&offset);
+          uint8_t buf[16];
+          size_t size = 0;
+          switch (wasm_op) {
+          case 0: // Local
+            if (!wasm_process->GetWasmLocal(frame_index, index, buf, 16,
+                                            size)) {
+              return false;
+            }
+            break;
+          case 1: // Global
+            if (!wasm_process->GetWasmGlobal(frame_index, index, buf, 16,
+                                             size)) {
+              return false;
+            }
+            break;
+          case 2: // Operand Stack
+            if (!wasm_process->GetWasmStackValue(frame_index, index, buf, 16,
+                                                 size)) {
+              return false;
+            }
+            break;
+          default:
+            return false;
+          }
+
+          if (size == sizeof(uint32_t)) {
+            uint32_t value;
+            memcpy(&value, buf, size);
+            stack.push_back(Scalar(value));
+          } else if (size == sizeof(uint64_t)) {
+            uint64_t value;
+            memcpy(&value, buf, size);
+            stack.push_back(Scalar(value));
+          } else
+            return false;
+        } else {
+          if (error_ptr)
+            error_ptr->SetErrorString("Invalid target architecture for "
+                                      "DW_OP_WASM_location opcode.");
+          return false;
+        }
+      } else {
+        if (error_ptr)
+          error_ptr->SetErrorString("Invalid stack frame in context for "
+                                    "DW_OP_WASM_location opcode.");
+        return false;
+      }
+    } break;
+
     // OPCODE: DW_OP_addrx (DW_OP_GNU_addr_index is the legacy name.)
     // OPERANDS: 1
     //      ULEB128: index to the .debug_addr section
     // DESCRIPTION: Pushes an address to the stack from the .debug_addr
     // section with the base address specified by the DW_AT_addr_base attribute
     // and the 0 based index is the ULEB128 encoded index.
     case DW_OP_addrx:
     case DW_OP_GNU_addr_index: {

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

public:
   bool HasFullVContSupport() { return GetVContSupported('A'); }
 
   bool HasAnyVContSupport() { return GetVContSupported('a'); }
 
   bool GetStopReply(StringExtractorGDBRemote &response);
 
   bool GetThreadStopInfo(lldb::tid_t tid, StringExtractorGDBRemote &response);
 
+  // WebAssembly-specific commands
+  bool GetWasmGlobal(int frame_index, int index, void *buf, size_t buffer_size,
+                     size_t &size);
+  bool GetWasmLocal(int frame_index, int index, void *buf, size_t buffer_size,
+                    size_t &size);
+  bool GetWasmStackValue(int frame_index, int index, void *buf,
+                         size_t buffer_size, size_t &size);
+  bool WasmReadMemory(int frame_index, lldb::addr_t vm_addr, void *buf,
+                      size_t buffer_size);
+  bool GetWasmCallStack(std::vector<lldb::addr_t> &call_stack_pcs);
+
   bool SupportsGDBStoppointPacket(GDBStoppointType type) {
     switch (type) {
     case eBreakpointSoftware:
       return m_supports_z0;
     case eBreakpointHardware:
       return m_supports_z1;
     case eWatchpointWrite:
       return m_supports_z2;
public:
   bool GetQPassSignalsSupported();
 
   bool GetAugmentedLibrariesSVR4ReadSupported();
 
   bool GetQXferFeaturesReadSupported();
 
   bool GetQXferMemoryMapReadSupported();
 
+  bool GetWasmFeaturesSupported();
+
   LazyBool SupportsAllocDeallocMemory() // const
   {
     // Uncomment this to have lldb pretend the debug server doesn't respond to
     // alloc/dealloc memory packets.
     // m_supports_alloc_dealloc_memory = lldb_private::eLazyBoolNo;
     return m_supports_alloc_dealloc_memory;
   }
 
protected:
   LazyBool m_supports_qXfer_features_read;
   LazyBool m_supports_qXfer_memory_map_read;
   LazyBool m_supports_augmented_libraries_svr4_read;
   LazyBool m_supports_jThreadExtendedInfo;
   LazyBool m_supports_jLoadedDynamicLibrariesInfos;
   LazyBool m_supports_jGetSharedCacheInfo;
   LazyBool m_supports_QPassSignals;
   LazyBool m_supports_error_string_reply;
+  LazyBool m_supports_wasm;
 
   bool m_supports_qProcessInfoPID : 1, m_supports_qfProcessInfo : 1,
       m_supports_qUserName : 1, m_supports_qGroupName : 1,
       m_supports_qThreadStopInfo : 1, m_supports_z0 : 1, m_supports_z1 : 1,
       m_supports_z2 : 1, m_supports_z3 : 1, m_supports_z4 : 1,
       m_supports_QEnvironment : 1, m_supports_QEnvironmentHexEncoded : 1,
       m_supports_qSymbol : 1, m_qSymbol_requests_done : 1,
       m_supports_qModuleInfo : 1, m_supports_jThreadsInfo : 1,

lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 
 bool GDBRemoteCommunicationClient::GetQXferMemoryMapReadSupported() {
   if (m_supports_qXfer_memory_map_read == eLazyBoolCalculate) {
     GetRemoteQSupported();
   }
   return m_supports_qXfer_memory_map_read == eLazyBoolYes;
 }
 
+bool GDBRemoteCommunicationClient::GetWasmFeaturesSupported() {
+  if (m_supports_wasm == eLazyBoolCalculate) {
+    GetRemoteQSupported();
+  }
+  return m_supports_wasm == eLazyBoolYes;
+}
+
 uint64_t GDBRemoteCommunicationClient::GetRemoteMaxPacketSize() {
   if (m_max_packet_size == 0) {
     GetRemoteQSupported();
   }
   return m_max_packet_size;
 }
 
 bool GDBRemoteCommunicationClient::QueryNoAckModeSupported() {

 void GDBRemoteCommunicationClient::GetRemoteQSupported() {
   // Clear out any capabilities we expect to see in the qSupported response
   m_supports_qXfer_auxv_read = eLazyBoolNo;
   m_supports_qXfer_libraries_read = eLazyBoolNo;
   m_supports_qXfer_libraries_svr4_read = eLazyBoolNo;
   m_supports_augmented_libraries_svr4_read = eLazyBoolNo;
   m_supports_qXfer_features_read = eLazyBoolNo;
   m_supports_qXfer_memory_map_read = eLazyBoolNo;
+  m_supports_wasm = eLazyBoolNo;
   m_max_packet_size = UINT64_MAX; // It's supposed to always be there, but if
                                   // not, we assume no limit
 
   // build the qSupported packet
   std::vector<std::string> features = {"xmlRegisters=i386,arm,mips,arc"};
   StreamString packet;
   packet.PutCString("qSupported");
   for (uint32_t i = 0; i < features.size(); ++i) {
if (SendPacketAndWaitForResponse(packet.GetString(), response,
     else
       m_supports_qEcho = eLazyBoolNo;
 
     if (::strstr(response_cstr, "QPassSignals+"))
       m_supports_QPassSignals = eLazyBoolYes;
     else
       m_supports_QPassSignals = eLazyBoolNo;
 
+    if (::strstr(response_cstr, "wasm+"))
+      m_supports_wasm = eLazyBoolYes;
+    else
+      m_supports_wasm = eLazyBoolNo;
+
     const char *packet_size_str = ::strstr(response_cstr, "PacketSize=");
     if (packet_size_str) {
       StringExtractorGDBRemote packet_response(packet_size_str +
                                                strlen("PacketSize="));
       m_max_packet_size =
           packet_response.GetHexMaxU64(/*little_endian=*/false, UINT64_MAX);
       if (m_max_packet_size == 0) {
         m_max_packet_size = UINT64_MAX; // Must have been a garbled response
if (SendPacketAndWaitForResponse(packet, response, false) ==
         return false;
     } else {
       m_supports_qThreadStopInfo = false;
     }
   }
   return false;
 }
 
+bool GDBRemoteCommunicationClient::GetWasmGlobal(int frame_index, int index,
+                                                 void *buf, size_t buffer_size,
+                                                 size_t &size) {
+  StreamString packet;
+  packet.PutCString("qWasmGlobal:");
+  packet.Printf("%d;%d", frame_index, index);
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) !=
+      PacketResult::Success) {
+    return false;
+  }
+
+  if (!response.IsNormalResponse()) {
+    return false;
+  }
+
+  DataBufferSP buffer_sp(
+      new DataBufferHeap(response.GetStringRef().size() / 2, 0));
+  response.GetHexBytes(buffer_sp->GetData(), '\xcc');
+  size = buffer_sp->GetByteSize();
+  if (size <= buffer_size) {
+    memcpy(buf, buffer_sp->GetBytes(), size);
+    return true;
+  }
+
+  return false;
+}
+
+bool GDBRemoteCommunicationClient::GetWasmLocal(int frame_index, int index,
+                                                void *buf, size_t buffer_size,
+                                                size_t &size) {
+  StreamString packet;
+  packet.Printf("qWasmLocal:");
+  packet.Printf("%d;%d", frame_index, index);
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) !=
+      PacketResult::Success) {
+    return false;
+  }
+
+  if (!response.IsNormalResponse()) {
+    return false;
+  }
+
+  DataBufferSP buffer_sp(
+      new DataBufferHeap(response.GetStringRef().size() / 2, 0));
+  response.GetHexBytes(buffer_sp->GetData(), '\xcc');
+  size = buffer_sp->GetByteSize();
+  if (size <= buffer_size) {
+    memcpy(buf, buffer_sp->GetBytes(), size);
+    return true;
+  }
+
+  return false;
+}
+
+bool GDBRemoteCommunicationClient::GetWasmStackValue(int frame_index, int index,
+                                                     void *buf,
+                                                     size_t buffer_size,
+                                                     size_t &size) {
+  StreamString packet;
+  packet.PutCString("qWasmStackValue:");
+  packet.Printf("%d;%d", frame_index, index);
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) !=
+      PacketResult::Success) {
+    return false;
+  }
+
+  if (!response.IsNormalResponse()) {
+    return false;
+  }
+
+  DataBufferSP buffer_sp(
+      new DataBufferHeap(response.GetStringRef().size() / 2, 0));
+  response.GetHexBytes(buffer_sp->GetData(), '\xcc');
+  size = buffer_sp->GetByteSize();
+  if (size <= buffer_size) {
+    memcpy(buf, buffer_sp->GetBytes(), size);
+    return true;
+  }
+
+  return false;
+}
+
+bool GDBRemoteCommunicationClient::WasmReadMemory(int frame_index,
+                                                  lldb::addr_t addr, void *buf,
+                                                  size_t buffer_size) {
+  char packet[64];
+  int packet_len = ::snprintf(
+      packet, sizeof(packet), "qWasmMem:%d;%" PRIx64 ";%" PRIx64, frame_index,
+      static_cast<uint64_t>(addr), static_cast<uint64_t>(buffer_size));
+  assert(packet_len + 1 < (int)sizeof(packet));
+  UNUSED_IF_ASSERT_DISABLED(packet_len);
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(packet, response, true) ==
+      PacketResult::Success) {
+    if (response.IsNormalResponse()) {
+      return buffer_size ==
+             response.GetHexBytes(llvm::MutableArrayRef<uint8_t>(
+                                      static_cast<uint8_t *>(buf), buffer_size),
+                                  '\xdd');
+    }
+  }
+  return false;
+}
+
+bool GDBRemoteCommunicationClient::GetWasmCallStack(
+    std::vector<lldb::addr_t> &call_stack_pcs) {
+  call_stack_pcs.clear();
+  StreamString packet;
+  packet.Printf("qWasmCallStack");
+  StringExtractorGDBRemote response;
+  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) !=
+      PacketResult::Success) {
+    return false;
+  }
+
+  if (!response.IsNormalResponse()) {
+    return false;
+  }
+
+  addr_t buf[1024 / sizeof(addr_t)];
+  size_t bytes = response.GetHexBytes(
+      llvm::MutableArrayRef<uint8_t>((uint8_t *)buf, sizeof(buf)), '\xdd');
+  if (bytes == 0) {
+    return false;
+  }
+
+  for (size_t i = 0; i < bytes / sizeof(addr_t); i++) {
+    call_stack_pcs.push_back(buf[i]);
+  }
+  return true;
+}
+
 uint8_t GDBRemoteCommunicationClient::SendGDBStoppointTypePacket(
     GDBStoppointType type, bool insert, addr_t addr, uint32_t length) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
   LLDB_LOGF(log, "GDBRemoteCommunicationClient::%s() %s at addr = 0x%" PRIx64,
             __FUNCTION__, insert ? "add" : "remove", addr);
 
   // Check if the stub is known not to support this breakpoint type
   if (!SupportsGDBStoppointPacket(type))

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

public:
   StructuredData::ObjectSP
   GetLoadedDynamicLibrariesInfos_sender(StructuredData::ObjectSP args);
 
   StructuredData::ObjectSP GetSharedCacheInfo() override;
 
   std::string HarmonizeThreadIdsForProfileData(
       StringExtractorGDBRemote &inputStringExtractor);
 
+  // Query remote GDBServer for Wasm information
+
+  bool IsWasmProcess() const;
+
+  bool GetWasmLocal(int frame_index, int index, void *buf, size_t buffer_size,
+                    size_t &size);
+
+  bool GetWasmGlobal(int frame_index, int index, void *buf, size_t buffer_size,
+                     size_t &size);
+
+  bool GetWasmStackValue(int frame_index, int index, void *buf,
+                         size_t buffer_size, size_t &size);
+
+  bool WasmReadMemory(int frame_index, lldb::addr_t addr, void *buf,
+                      size_t buffer_size);
+
+  bool GetWasmCallStack(std::vector<lldb::addr_t> &call_stack_pcs);
+
 protected:
+  friend class UnwindWasm;
   friend class ThreadGDBRemote;
   friend class GDBRemoteCommunicationClient;
   friend class GDBRemoteRegisterContext;
 
   /// Broadcaster event bits definitions.
   enum {
     eBroadcastBitAsyncContinue = (1 << 0),
     eBroadcastBitAsyncThreadShouldExit = (1 << 1),

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (thread_infos) {
             thread_infos->GetItemAtIndex(i)->GetAsDictionary();
         if (thread_dict)
           SetThreadStopInfo(thread_dict);
       }
     }
   }
 }
 
+// WebAssembly features
+
+bool ProcessGDBRemote::IsWasmProcess() const {
+  return GetTarget().GetArchitecture().GetMachine() == llvm::Triple::wasm32;
+}
+
+bool ProcessGDBRemote::GetWasmLocal(int frame_index, int index, void *buf,
+                                    size_t buffer_size, size_t &size) {
+  if (!m_gdb_comm.GetWasmFeaturesSupported())
+    return false;
+  return GetGDBRemote().GetWasmLocal(frame_index, index, buf, buffer_size,
+                                     size);
+}
+
+bool ProcessGDBRemote::GetWasmGlobal(int frame_index, int index, void *buf,
+                                     size_t buffer_size, size_t &size) {
+  if (!m_gdb_comm.GetWasmFeaturesSupported())
+    return false;
+  return GetGDBRemote().GetWasmGlobal(frame_index, index, buf, buffer_size,
+                                      size);
+}
+
+bool ProcessGDBRemote::GetWasmStackValue(int frame_index, int index, void *buf,
+                                         size_t buffer_size, size_t &size) {
+  if (!m_gdb_comm.GetWasmFeaturesSupported())
+    return false;
+  return GetGDBRemote().GetWasmStackValue(frame_index, index, buf, buffer_size,
+                                          size);
+}
+
+bool ProcessGDBRemote::WasmReadMemory(int frame_index, lldb::addr_t addr,
+                                      void *buf, size_t buffer_size) {
+  if (!m_gdb_comm.GetWasmFeaturesSupported())
+    return false;
+  return GetGDBRemote().WasmReadMemory(frame_index, addr, buf, buffer_size);
+}
+
+bool ProcessGDBRemote::GetWasmCallStack(
+    std::vector<lldb::addr_t> &call_stack_pcs) {
+  if (!m_gdb_comm.GetWasmFeaturesSupported())
+    return false;
+  return GetGDBRemote().GetWasmCallStack(call_stack_pcs);
+}
+
 // Process Memory
 size_t ProcessGDBRemote::DoReadMemory(addr_t addr, void *buf, size_t size,
                                       Status &error) {
+  if (addr < 0x100000000 && IsWasmProcess() &&
+      m_gdb_comm.GetWasmFeaturesSupported()) {
+    if (WasmReadMemory(0 /*frame_index*/, addr, buf, size)) {
+      return size;
+    }
+    return 0;
+  }
+
   GetMaxMemorySize();
   bool binary_memory_read = m_gdb_comm.GetxPacketSupported();
   // M and m packets take 2 bytes for 1 byte of memory
   size_t max_memory_size =
       binary_memory_read ? m_max_memory_size : m_max_memory_size / 2;
   if (size > max_memory_size) {
     // Keep memory read sizes down to a sane limit. This function will be
     // called multiple times in order to complete the task by

lldb/source/Target/CMakeLists.txt

add_lldb_library(lldbTarget
   ThreadPlanStepThrough.cpp
   ThreadPlanStepUntil.cpp
   ThreadPlanTracer.cpp
   ThreadPlanStack.cpp
   ThreadSpec.cpp
   UnixSignals.cpp
   UnwindAssembly.cpp
   UnwindLLDB.cpp
+  UnwindWasm.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbExpression
     lldbHost
     lldbInterpreter
     lldbSymbol

lldb/source/Target/Thread.cpp

 #include "lldb/Target/ThreadPlanStepInstruction.h"
 #include "lldb/Target/ThreadPlanStepOut.h"
 #include "lldb/Target/ThreadPlanStepOverBreakpoint.h"
 #include "lldb/Target/ThreadPlanStepOverRange.h"
 #include "lldb/Target/ThreadPlanStepThrough.h"
 #include "lldb/Target/ThreadPlanStepUntil.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Target/UnwindLLDB.h"
+#include "lldb/Target/UnwindWasm.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-enumerations.h"
 
 #include <memory>

 size_t Thread::GetStackFrameStatus(Stream &strm, uint32_t first_frame,
                                    uint32_t num_frames, bool show_frame_info,
                                    uint32_t num_frames_with_source) {
   return GetStackFrameList()->GetStatus(
       strm, first_frame, num_frames, show_frame_info, num_frames_with_source);
 }
 
 Unwind &Thread::GetUnwinder() {
-  if (!m_unwinder_up)
+  if (!m_unwinder_up) {
+    if (CalculateTarget()->GetArchitecture().GetMachine() ==
+        llvm::Triple::wasm32)
+      m_unwinder_up.reset(new UnwindWasm(*this));
+    else
       m_unwinder_up.reset(new UnwindLLDB(*this));
+  }
   return *m_unwinder_up;
 }
 
 void Thread::Flush() {
   ClearStackFrames();
   m_reg_context_sp.reset();
 }
 

lldb/source/Target/UnwindWasm.cpp

+//===-- UnwindWasm.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 "lldb/Target/UnwindWasm.h"
+#include "lldb/Target/Thread.h"
+
+#include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
+#include "Plugins/Process/gdb-remote/ThreadGDBRemote.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace process_gdb_remote;
+
+class WasmGDBRemoteRegisterContext : public GDBRemoteRegisterContext {
+public:
+  WasmGDBRemoteRegisterContext(ThreadGDBRemote &thread,
+                               uint32_t concrete_frame_idx,
+                               GDBRemoteDynamicRegisterInfo &reg_info,
+                               uint64_t pc)
+      : GDBRemoteRegisterContext(thread, concrete_frame_idx, reg_info, false,
+                                 false) {
+    PrivateSetRegisterValue(0, pc);
+  }
+};
+
+lldb::RegisterContextSP
+UnwindWasm::DoCreateRegisterContextForFrame(lldb_private::StackFrame *frame) {
+  if (m_frames.size() <= frame->GetFrameIndex()) {
+    return lldb::RegisterContextSP();
+  }
+
+  ThreadSP thread = frame->GetThread();
+  ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *>(thread.get());
+  ProcessGDBRemote *gdb_process =
+      static_cast<ProcessGDBRemote *>(thread->GetProcess().get());
+  std::shared_ptr<GDBRemoteRegisterContext> reg_ctx_sp =
+      std::make_shared<WasmGDBRemoteRegisterContext>(
+          *gdb_thread, frame->GetConcreteFrameIndex(),
+          gdb_process->m_register_info, m_frames[frame->GetFrameIndex()]);
+  return reg_ctx_sp;
+}
+
+uint32_t UnwindWasm::DoGetFrameCount() {
+  if (!m_unwind_complete) {
+    m_unwind_complete = true;
+    m_frames.clear();
+
+    ProcessGDBRemote *gdb_process =
+        static_cast<ProcessGDBRemote *>(GetThread().GetProcess().get());
+    if (!gdb_process->GetWasmCallStack(m_frames))
+      return 0;
+  }
+  return m_frames.size();
+}
+
+bool UnwindWasm::DoGetFrameInfoAtIndex(uint32_t frame_idx, lldb::addr_t &cfa,
+                                       lldb::addr_t &pc,
+                                       bool &behaves_like_zeroth_frame) {
+  if (m_frames.size() == 0) {
+    DoGetFrameCount();
+  }
+
+  if (frame_idx < m_frames.size()) {
+    behaves_like_zeroth_frame = (frame_idx == 0);
+    cfa = 0;
+    pc = m_frames[frame_idx];
+    return true;
+  }
+  return false;
+}
 No newline at end of file