[Lldb-commits] [lldb] [lldb-dap] Creating a dedicated Transport class for DAP communication. (PR #128972)
John Harrison via lldb-commits
lldb-commits at lists.llvm.org
Wed Feb 26 16:03:32 PST 2025
https://github.com/ashgti updated https://github.com/llvm/llvm-project/pull/128972
>From 397c479a8238a06e81c53c2735aa361ae12a5f42 Mon Sep 17 00:00:00 2001
From: John Harrison <harjohn at google.com>
Date: Wed, 26 Feb 2025 11:29:46 -0800
Subject: [PATCH] [lldb-dap] Creating a dedicated Transport mechnaism for
handling protocol communication.
This removes the previous 'OutputStream' and 'InputStream' objects and the new 'Transport' class takes on the responsibility of seriliaizing and encoding messages.
The new Protocol.h file has a dedicated namespace for POD style structures to represent the Debug Adapter Protocol messages.
---
lldb/tools/lldb-dap/CMakeLists.txt | 4 +-
lldb/tools/lldb-dap/DAP.cpp | 135 +++++---------------
lldb/tools/lldb-dap/DAP.h | 17 ++-
lldb/tools/lldb-dap/DAPLog.cpp | 20 +++
lldb/tools/lldb-dap/DAPLog.h | 33 +++++
lldb/tools/lldb-dap/IOStream.cpp | 65 ----------
lldb/tools/lldb-dap/IOStream.h | 42 -------
lldb/tools/lldb-dap/Protocol.cpp | 191 ++++++++++++++++++++++++++++
lldb/tools/lldb-dap/Protocol.h | 192 +++++++++++++++++++++++++++++
lldb/tools/lldb-dap/Transport.cpp | 110 +++++++++++++++++
lldb/tools/lldb-dap/Transport.h | 48 ++++++++
lldb/tools/lldb-dap/lldb-dap.cpp | 38 ++++--
12 files changed, 667 insertions(+), 228 deletions(-)
create mode 100644 lldb/tools/lldb-dap/DAPLog.cpp
create mode 100644 lldb/tools/lldb-dap/DAPLog.h
delete mode 100644 lldb/tools/lldb-dap/IOStream.cpp
delete mode 100644 lldb/tools/lldb-dap/IOStream.h
create mode 100644 lldb/tools/lldb-dap/Protocol.cpp
create mode 100644 lldb/tools/lldb-dap/Protocol.h
create mode 100644 lldb/tools/lldb-dap/Transport.cpp
create mode 100644 lldb/tools/lldb-dap/Transport.h
diff --git a/lldb/tools/lldb-dap/CMakeLists.txt b/lldb/tools/lldb-dap/CMakeLists.txt
index 8b3c520ec4360..cba20a53edcb3 100644
--- a/lldb/tools/lldb-dap/CMakeLists.txt
+++ b/lldb/tools/lldb-dap/CMakeLists.txt
@@ -23,18 +23,20 @@ add_lldb_tool(lldb-dap
Breakpoint.cpp
BreakpointBase.cpp
DAP.cpp
+ DAPLog.cpp
EventHelper.cpp
ExceptionBreakpoint.cpp
FifoFiles.cpp
FunctionBreakpoint.cpp
InstructionBreakpoint.cpp
- IOStream.cpp
JSONUtils.cpp
LLDBUtils.cpp
OutputRedirector.cpp
ProgressEvent.cpp
RunInTerminal.cpp
SourceBreakpoint.cpp
+ Transport.cpp
+ Protocol.cpp
Watchpoint.cpp
Handler/ResponseHandler.cpp
diff --git a/lldb/tools/lldb-dap/DAP.cpp b/lldb/tools/lldb-dap/DAP.cpp
index cd53e2aca3fb6..e23d9f4e910cc 100644
--- a/lldb/tools/lldb-dap/DAP.cpp
+++ b/lldb/tools/lldb-dap/DAP.cpp
@@ -7,10 +7,12 @@
//===----------------------------------------------------------------------===//
#include "DAP.h"
+#include "DAPLog.h"
#include "Handler/ResponseHandler.h"
#include "JSONUtils.h"
#include "LLDBUtils.h"
#include "OutputRedirector.h"
+#include "Protocol.h"
#include "lldb/API/SBBreakpoint.h"
#include "lldb/API/SBCommandInterpreter.h"
#include "lldb/API/SBCommandReturnObject.h"
@@ -29,6 +31,7 @@
#include "llvm/Support/Error.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/JSON.h"
#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <cassert>
@@ -50,6 +53,7 @@
#endif
using namespace lldb_dap;
+using namespace lldb_private;
namespace {
#ifdef _WIN32
@@ -61,11 +65,11 @@ const char DEV_NULL[] = "/dev/null";
namespace lldb_dap {
-DAP::DAP(std::string name, llvm::StringRef path, std::ofstream *log,
+DAP::DAP(llvm::StringRef name, llvm::StringRef path, std::ofstream *log,
lldb::IOObjectSP input, lldb::IOObjectSP output, ReplMode repl_mode,
std::vector<std::string> pre_init_commands)
- : name(std::move(name)), debug_adaptor_path(path), log(log),
- input(std::move(input)), output(std::move(output)),
+ : name(name), debug_adaptor_path(path), log(log),
+ transport(name, std::move(input), std::move(output)),
broadcaster("lldb-dap"), exception_breakpoints(),
pre_init_commands(std::move(pre_init_commands)),
focus_tid(LLDB_INVALID_THREAD_ID), stop_at_entry(false), is_attach(false),
@@ -237,65 +241,22 @@ void DAP::StopEventHandlers() {
}
}
-// Send the JSON in "json_str" to the "out" stream. Correctly send the
-// "Content-Length:" field followed by the length, followed by the raw
-// JSON bytes.
-void DAP::SendJSON(const std::string &json_str) {
- output.write_full("Content-Length: ");
- output.write_full(llvm::utostr(json_str.size()));
- output.write_full("\r\n\r\n");
- output.write_full(json_str);
-}
-
// Serialize the JSON value into a string and send the JSON packet to
// the "out" stream.
void DAP::SendJSON(const llvm::json::Value &json) {
- std::string json_str;
- llvm::raw_string_ostream strm(json_str);
- strm << json;
- static std::mutex mutex;
- std::lock_guard<std::mutex> locker(mutex);
- SendJSON(json_str);
-
- if (log) {
- auto now = std::chrono::duration<double>(
- std::chrono::system_clock::now().time_since_epoch());
- *log << llvm::formatv("{0:f9} {1} <-- ", now.count(), name).str()
- << std::endl
- << "Content-Length: " << json_str.size() << "\r\n\r\n"
- << llvm::formatv("{0:2}", json).str() << std::endl;
- }
-}
-
-// Read a JSON packet from the "in" stream.
-std::string DAP::ReadJSON() {
- std::string length_str;
- std::string json_str;
- int length;
-
- if (!input.read_expected(log, "Content-Length: "))
- return json_str;
-
- if (!input.read_line(log, length_str))
- return json_str;
-
- if (!llvm::to_integer(length_str, length))
- return json_str;
-
- if (!input.read_expected(log, "\r\n"))
- return json_str;
-
- if (!input.read_full(log, length, json_str))
- return json_str;
-
- if (log) {
- auto now = std::chrono::duration<double>(
- std::chrono::system_clock::now().time_since_epoch());
- *log << llvm::formatv("{0:f9} {1} --> ", now.count(), name).str()
- << std::endl
- << "Content-Length: " << length << "\r\n\r\n";
+ protocol::ProtocolMessage M;
+ llvm::json::Path::Root root;
+ if (!protocol::fromJSON(json, M, root)) {
+ if (log) {
+ std::string error;
+ llvm::raw_string_ostream OS(error);
+ root.printErrorContext(json, OS);
+ *log << "encoding failure: " << error << "\n";
+ }
}
- return json_str;
+ auto status = transport.Write(M);
+ if (status.Fail() && log)
+ *log << "transport failure: " << status.AsCString() << "\n";
}
// "OutputEvent": {
@@ -720,40 +681,13 @@ void DAP::SetTarget(const lldb::SBTarget target) {
}
}
-PacketStatus DAP::GetNextObject(llvm::json::Object &object) {
- std::string json = ReadJSON();
- if (json.empty())
- return PacketStatus::EndOfFile;
-
- llvm::StringRef json_sref(json);
- llvm::Expected<llvm::json::Value> json_value = llvm::json::parse(json_sref);
- if (!json_value) {
- auto error = json_value.takeError();
- if (log) {
- std::string error_str;
- llvm::raw_string_ostream strm(error_str);
- strm << error;
- *log << "error: failed to parse JSON: " << error_str << std::endl
- << json << std::endl;
- }
- return PacketStatus::JSONMalformed;
- }
-
- if (log) {
- *log << llvm::formatv("{0:2}", *json_value).str() << std::endl;
- }
-
- llvm::json::Object *object_ptr = json_value->getAsObject();
- if (!object_ptr) {
- if (log)
- *log << "error: json packet isn't a object" << std::endl;
- return PacketStatus::JSONNotObject;
- }
- object = *object_ptr;
- return PacketStatus::Success;
+llvm::Expected<protocol::ProtocolMessage> DAP::GetNextObject() {
+ return transport.Read();
}
-bool DAP::HandleObject(const llvm::json::Object &object) {
+bool DAP::HandleObject(const protocol::ProtocolMessage &M) {
+ llvm::json::Value v = toJSON(M);
+ llvm::json::Object object = *v.getAsObject();
const auto packet_type = GetString(object, "type");
if (packet_type == "request") {
const auto command = GetString(object, "command");
@@ -764,9 +698,8 @@ bool DAP::HandleObject(const llvm::json::Object &object) {
return true; // Success
}
- if (log)
- *log << "error: unhandled command \"" << command.data() << "\""
- << std::endl;
+ LLDB_LOG(GetLog(DAPLog::Protocol), "Unhandled command {0}", command);
+
return false; // Fail
}
@@ -805,6 +738,8 @@ bool DAP::HandleObject(const llvm::json::Object &object) {
return true;
}
+ LLDB_LOG(GetLog(DAPLog::Protocol), "Unsupported protocol message");
+
return false;
}
@@ -858,19 +793,13 @@ lldb::SBError DAP::Disconnect(bool terminateDebuggee) {
llvm::Error DAP::Loop() {
auto cleanup = llvm::make_scope_exit([this]() { StopEventHandlers(); });
while (!disconnecting) {
- llvm::json::Object object;
- lldb_dap::PacketStatus status = GetNextObject(object);
-
- if (status == lldb_dap::PacketStatus::EndOfFile) {
- break;
- }
+ auto next = GetNextObject();
- if (status != lldb_dap::PacketStatus::Success) {
- return llvm::createStringError(llvm::inconvertibleErrorCode(),
- "failed to send packet");
+ if (!next) {
+ return next.takeError();
}
- if (!HandleObject(object)) {
+ if (!HandleObject(*next)) {
return llvm::createStringError(llvm::inconvertibleErrorCode(),
"unhandled packet");
}
diff --git a/lldb/tools/lldb-dap/DAP.h b/lldb/tools/lldb-dap/DAP.h
index a7c7e5d9bbc19..aa86064e188a9 100644
--- a/lldb/tools/lldb-dap/DAP.h
+++ b/lldb/tools/lldb-dap/DAP.h
@@ -14,11 +14,12 @@
#include "FunctionBreakpoint.h"
#include "Handler/RequestHandler.h"
#include "Handler/ResponseHandler.h"
-#include "IOStream.h"
#include "InstructionBreakpoint.h"
#include "OutputRedirector.h"
#include "ProgressEvent.h"
+#include "Protocol.h"
#include "SourceBreakpoint.h"
+#include "Transport.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBCommandInterpreter.h"
#include "lldb/API/SBDebugger.h"
@@ -39,6 +40,7 @@
#include "llvm/Support/Error.h"
#include "llvm/Support/JSON.h"
#include "llvm/Support/Threading.h"
+#include <fstream>
#include <map>
#include <memory>
#include <mutex>
@@ -145,11 +147,10 @@ struct SendEventRequestHandler : public lldb::SBCommandPluginInterface {
};
struct DAP {
- std::string name;
+ llvm::StringRef name;
llvm::StringRef debug_adaptor_path;
std::ofstream *log;
- InputStream input;
- OutputStream output;
+ Transport transport;
lldb::SBFile in;
OutputRedirector out;
OutputRedirector err;
@@ -210,7 +211,7 @@ struct DAP {
// will contain that expression.
std::string last_nonempty_var_expression;
- DAP(std::string name, llvm::StringRef path, std::ofstream *log,
+ DAP(llvm::StringRef name, llvm::StringRef path, std::ofstream *log,
lldb::IOObjectSP input, lldb::IOObjectSP output, ReplMode repl_mode,
std::vector<std::string> pre_init_commands);
~DAP();
@@ -233,8 +234,6 @@ struct DAP {
// the "out" stream.
void SendJSON(const llvm::json::Value &json);
- std::string ReadJSON();
-
void SendOutput(OutputType o, const llvm::StringRef output);
void SendProgressEvent(uint64_t progress_id, const char *message,
@@ -307,8 +306,8 @@ struct DAP {
/// listeing for its breakpoint events.
void SetTarget(const lldb::SBTarget target);
- PacketStatus GetNextObject(llvm::json::Object &object);
- bool HandleObject(const llvm::json::Object &object);
+ llvm::Expected<protocol::ProtocolMessage> GetNextObject();
+ bool HandleObject(const protocol::ProtocolMessage &);
/// Disconnect the DAP session.
lldb::SBError Disconnect();
diff --git a/lldb/tools/lldb-dap/DAPLog.cpp b/lldb/tools/lldb-dap/DAPLog.cpp
new file mode 100644
index 0000000000000..73d256098d69d
--- /dev/null
+++ b/lldb/tools/lldb-dap/DAPLog.cpp
@@ -0,0 +1,20 @@
+#include "DAPLog.h"
+
+using namespace lldb_private;
+using namespace lldb_dap;
+
+static constexpr Log::Category g_categories[] = {
+ {{"transport"}, {"log DAP transport"}, DAPLog::Transport},
+ {{"protocol"}, {"log protocol handling"}, DAPLog::Protocol},
+};
+
+static Log::Channel g_log_channel(g_categories,
+ DAPLog::Transport | DAPLog::Protocol);
+
+template <> Log::Channel &lldb_private::LogChannelFor<DAPLog>() {
+ return g_log_channel;
+}
+
+void lldb_dap::InitializeDAPChannel() {
+ Log::Register("lldb-dap", g_log_channel);
+}
diff --git a/lldb/tools/lldb-dap/DAPLog.h b/lldb/tools/lldb-dap/DAPLog.h
new file mode 100644
index 0000000000000..c22cb53655dbf
--- /dev/null
+++ b/lldb/tools/lldb-dap/DAPLog.h
@@ -0,0 +1,33 @@
+//===-- DAPLog.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_UTILITY_LLDBLOG_H
+#define LLDB_UTILITY_LLDBLOG_H
+
+#include "lldb/Utility/Log.h"
+#include "llvm/ADT/BitmaskEnum.h"
+
+namespace lldb_dap {
+
+enum class DAPLog : lldb_private::Log::MaskType {
+ Transport = lldb_private::Log::ChannelFlag<0>,
+ Protocol = lldb_private::Log::ChannelFlag<1>,
+ LLVM_MARK_AS_BITMASK_ENUM(Protocol),
+};
+
+LLVM_ENABLE_BITMASK_ENUMS_IN_NAMESPACE();
+
+void InitializeDAPChannel();
+
+} // end namespace lldb_dap
+
+namespace lldb_private {
+template <> lldb_private::Log::Channel &LogChannelFor<lldb_dap::DAPLog>();
+} // namespace lldb_private
+
+#endif
diff --git a/lldb/tools/lldb-dap/IOStream.cpp b/lldb/tools/lldb-dap/IOStream.cpp
deleted file mode 100644
index c6f1bfaf3b799..0000000000000
--- a/lldb/tools/lldb-dap/IOStream.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-//===-- IOStream.cpp --------------------------------------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#include "IOStream.h"
-#include "lldb/Utility/IOObject.h"
-#include "lldb/Utility/Status.h"
-#include <fstream>
-#include <string>
-
-using namespace lldb_dap;
-
-bool OutputStream::write_full(llvm::StringRef str) {
- if (!descriptor)
- return false;
-
- size_t num_bytes = str.size();
- auto status = descriptor->Write(str.data(), num_bytes);
- return status.Success();
-}
-
-bool InputStream::read_full(std::ofstream *log, size_t length,
- std::string &text) {
- if (!descriptor)
- return false;
-
- std::string data;
- data.resize(length);
-
- auto status = descriptor->Read(data.data(), length);
- if (status.Fail())
- return false;
-
- text += data;
- return true;
-}
-
-bool InputStream::read_line(std::ofstream *log, std::string &line) {
- line.clear();
- while (true) {
- if (!read_full(log, 1, line))
- return false;
-
- if (llvm::StringRef(line).ends_with("\r\n"))
- break;
- }
- line.erase(line.size() - 2);
- return true;
-}
-
-bool InputStream::read_expected(std::ofstream *log, llvm::StringRef expected) {
- std::string result;
- if (!read_full(log, expected.size(), result))
- return false;
- if (expected != result) {
- if (log)
- *log << "Warning: Expected '" << expected.str() << "', got '" << result
- << "\n";
- }
- return true;
-}
diff --git a/lldb/tools/lldb-dap/IOStream.h b/lldb/tools/lldb-dap/IOStream.h
deleted file mode 100644
index e9fb8e11c92da..0000000000000
--- a/lldb/tools/lldb-dap/IOStream.h
+++ /dev/null
@@ -1,42 +0,0 @@
-//===-- IOStream.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_TOOLS_LLDB_DAP_IOSTREAM_H
-#define LLDB_TOOLS_LLDB_DAP_IOSTREAM_H
-
-#include "lldb/lldb-forward.h"
-#include "llvm/ADT/StringRef.h"
-#include <fstream>
-#include <string>
-
-namespace lldb_dap {
-
-struct InputStream {
- lldb::IOObjectSP descriptor;
-
- explicit InputStream(lldb::IOObjectSP descriptor)
- : descriptor(std::move(descriptor)) {}
-
- bool read_full(std::ofstream *log, size_t length, std::string &text);
-
- bool read_line(std::ofstream *log, std::string &line);
-
- bool read_expected(std::ofstream *log, llvm::StringRef expected);
-};
-
-struct OutputStream {
- lldb::IOObjectSP descriptor;
-
- explicit OutputStream(lldb::IOObjectSP descriptor)
- : descriptor(std::move(descriptor)) {}
-
- bool write_full(llvm::StringRef str);
-};
-} // namespace lldb_dap
-
-#endif
diff --git a/lldb/tools/lldb-dap/Protocol.cpp b/lldb/tools/lldb-dap/Protocol.cpp
new file mode 100644
index 0000000000000..6f8687ddb5a59
--- /dev/null
+++ b/lldb/tools/lldb-dap/Protocol.cpp
@@ -0,0 +1,191 @@
+//===-- Protocol.cpp --------------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "Protocol.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/JSON.h"
+#include <optional>
+#include <utility>
+
+namespace llvm {
+namespace json {
+bool fromJSON(const llvm::json::Value &Params, llvm::json::Value &V,
+ llvm::json::Path P) {
+ V = std::move(Params);
+ return true;
+}
+} // namespace json
+} // namespace llvm
+
+namespace lldb_dap {
+namespace protocol {
+
+enum class MessageType { request, response, event };
+
+bool fromJSON(const llvm::json::Value &Params, MessageType &M,
+ llvm::json::Path P) {
+ auto rawType = Params.getAsString();
+ if (!rawType) {
+ P.report("expected a string");
+ return false;
+ }
+ std::optional<MessageType> type =
+ llvm::StringSwitch<std::optional<MessageType>>(*rawType)
+ .Case("request", MessageType::request)
+ .Case("response", MessageType::response)
+ .Case("event", MessageType::event)
+ .Default(std::nullopt);
+ if (!type) {
+ P.report("unexpected value");
+ return false;
+ }
+ M = *type;
+ return true;
+}
+
+llvm::json::Value toJSON(const Request &R) {
+ llvm::json::Object Result{
+ {"type", "request"},
+ {"seq", R.seq},
+ {"command", R.command},
+ };
+ if (R.rawArguments)
+ Result.insert({"arguments", R.rawArguments});
+ return std::move(Result);
+}
+
+bool fromJSON(llvm::json::Value const &Params, Request &R, llvm::json::Path P) {
+ llvm::json::ObjectMapper O(Params, P);
+ MessageType type;
+ if (!O.map("type", type)) {
+ return false;
+ }
+ if (type != MessageType::request) {
+ P.field("type").report("expected to be 'request'");
+ return false;
+ }
+
+ return O && O.map("command", R.command) && O.map("seq", R.seq) &&
+ O.map("arguments", R.rawArguments);
+}
+
+llvm::json::Value toJSON(const Response &R) {
+ llvm::json::Object Result{{"type", "response"},
+ {"req", 0},
+ {"command", R.command},
+ {"request_seq", R.request_seq},
+ {"success", R.success}};
+
+ if (R.message)
+ Result.insert({"message", R.message});
+ if (R.rawBody)
+ Result.insert({"body", R.rawBody});
+
+ return std::move(Result);
+}
+
+bool fromJSON(llvm::json::Value const &Params, Response &R,
+ llvm::json::Path P) {
+ llvm::json::ObjectMapper O(Params, P);
+ MessageType type;
+ if (!O.map("type", type)) {
+ return false;
+ }
+ if (type != MessageType::response) {
+ P.field("type").report("expected to be 'response'");
+ return false;
+ }
+ return O && O.map("command", R.command) &&
+ O.map("request_seq", R.request_seq) && O.map("success", R.success) &&
+ O.mapOptional("message", R.message) &&
+ O.mapOptional("body", R.rawBody);
+}
+
+llvm::json::Value toJSON(const Event &E) {
+ llvm::json::Object Result{
+ {"type", "event"},
+ {"seq", 0},
+ {"event", E.event},
+ };
+ if (E.rawBody)
+ Result.insert({"body", E.rawBody});
+ if (E.statistics)
+ Result.insert({"statistics", E.statistics});
+ return std::move(Result);
+}
+
+bool fromJSON(llvm::json::Value const &Params, Event &E, llvm::json::Path P) {
+ llvm::json::ObjectMapper O(Params, P);
+ MessageType type;
+ if (!O.map("type", type)) {
+ return false;
+ }
+ if (type != MessageType::event) {
+ P.field("type").report("expected to be 'event'");
+ return false;
+ }
+
+ return O && O.map("event", E.event) && O.mapOptional("body", E.rawBody) &&
+ O.mapOptional("statistics", E.statistics);
+}
+
+bool fromJSON(const llvm::json::Value &Params, ProtocolMessage &PM,
+ llvm::json::Path P) {
+ llvm::json::ObjectMapper O(Params, P);
+ if (!O)
+ return false;
+
+ MessageType type;
+ if (!O.map("type", type))
+ return false;
+
+ switch (type) {
+ case MessageType::request: {
+ Request req;
+ if (!fromJSON(Params, req, P)) {
+ return false;
+ }
+ PM = std::move(req);
+ return true;
+ }
+ case MessageType::response: {
+ Response resp;
+ if (!fromJSON(Params, resp, P)) {
+ return false;
+ }
+ PM = std::move(resp);
+ return true;
+ }
+ case MessageType::event:
+ Event evt;
+ if (!fromJSON(Params, evt, P)) {
+ return false;
+ }
+ PM = std::move(evt);
+ return true;
+ }
+ llvm_unreachable("Unsupported protocol message");
+}
+
+llvm::json::Value toJSON(const ProtocolMessage &PM) {
+ if (auto const *Req = std::get_if<Request>(&PM)) {
+ return toJSON(*Req);
+ }
+ if (auto const *Resp = std::get_if<Response>(&PM)) {
+ return toJSON(*Resp);
+ }
+ if (auto const *Evt = std::get_if<Event>(&PM)) {
+ return toJSON(*Evt);
+ }
+ llvm_unreachable("Unsupported protocol message");
+}
+
+} // namespace protocol
+} // namespace lldb_dap
diff --git a/lldb/tools/lldb-dap/Protocol.h b/lldb/tools/lldb-dap/Protocol.h
new file mode 100644
index 0000000000000..abc058cd7ad97
--- /dev/null
+++ b/lldb/tools/lldb-dap/Protocol.h
@@ -0,0 +1,192 @@
+//===-- Protocol.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
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains POD structs based on the DAP specification at
+// https://microsoft.github.io/debug-adapter-protocol/specification
+//
+// This is not meant to be a complete implementation, new interfaces are added
+// when they're needed.
+//
+// Each struct has a toJSON and fromJSON function, that converts between
+// the struct and a JSON representation. (See JSON.h)
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_TOOLS_LLDB_DAP_PROTOCOL_H
+#define LLDB_TOOLS_LLDB_DAP_PROTOCOL_H
+
+#include "llvm/Support/JSON.h"
+#include <cstddef>
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <variant>
+
+namespace lldb_dap {
+namespace protocol {
+
+// MARK: Base Protocol
+
+// "Request": {
+// "allOf": [ { "$ref": "#/definitions/ProtocolMessage" }, {
+// "type": "object",
+// "description": "A client or debug adapter initiated request.",
+// "properties": {
+// "type": {
+// "type": "string",
+// "enum": [ "request" ]
+// },
+// "command": {
+// "type": "string",
+// "description": "The command to execute."
+// },
+// "arguments": {
+// "type": [ "array", "boolean", "integer", "null", "number" , "object",
+// "string" ], "description": "Object containing arguments for the
+// command."
+// }
+// },
+// "required": [ "type", "command" ]
+// }]
+// },
+struct Request {
+ int64_t seq;
+ std::string command;
+ std::optional<llvm::json::Value> rawArguments;
+};
+llvm::json::Value toJSON(const Request &);
+bool fromJSON(const llvm::json::Value &, Request &, llvm::json::Path);
+
+// "Event": {
+// "allOf": [ { "$ref": "#/definitions/ProtocolMessage" }, {
+// "type": "object",
+// "description": "A debug adapter initiated event.",
+// "properties": {
+// "type": {
+// "type": "string",
+// "enum": [ "event" ]
+// },
+// "event": {
+// "type": "string",
+// "description": "Type of event."
+// },
+// "body": {
+// "type": [ "array", "boolean", "integer", "null", "number" , "object",
+// "string" ], "description": "Event-specific information."
+// }
+// },
+// "required": [ "type", "event" ]
+// }]
+// },
+struct Event {
+ std::string event;
+ std::optional<llvm::json::Value> rawBody;
+
+ /// lldb-dap specific extension on the 'terminated' event specifically.
+ std::optional<llvm::json::Value> statistics;
+};
+llvm::json::Value toJSON(const Event &);
+bool fromJSON(const llvm::json::Value &, Event &, llvm::json::Path);
+
+// "Response" : {
+// "allOf" : [
+// {"$ref" : "#/definitions/ProtocolMessage"}, {
+// "type" : "object",
+// "description" : "Response for a request.",
+// "properties" : {
+// "type" : {"type" : "string", "enum" : ["response"]},
+// "request_seq" : {
+// "type" : "integer",
+// "description" : "Sequence number of the corresponding request."
+// },
+// "success" : {
+// "type" : "boolean",
+// "description" :
+// "Outcome of the request.\nIf true, the request was successful "
+// "and the `body` attribute may contain the result of the "
+// "request.\nIf the value is false, the attribute `message` "
+// "contains the error in short form and the `body` may contain "
+// "additional information (see `ErrorResponse.body.error`)."
+// },
+// "command" :
+// {"type" : "string", "description" : "The command requested."},
+// "message" : {
+// "type" : "string",
+// "description" :
+// "Contains the raw error in short form if `success` is "
+// "false.\nThis raw error might be interpreted by the client and
+// " "is not shown in the UI.\nSome predefined values exist.",
+// "_enum" : [ "cancelled", "notStopped" ],
+// "enumDescriptions" : [
+// "the request was cancelled.", "the request may be retried once
+// the "
+// "adapter is in a 'stopped' state."
+// ]
+// },
+// "body" : {
+// "type" : [
+// "array", "boolean", "integer", "null", "number", "object",
+// "string"
+// ],
+// "description" : "Contains request result if success is true and "
+// "error details if success is false."
+// }
+// },
+// "required" : [ "type", "request_seq", "success", "command" ]
+// }
+// ]
+// }
+struct Response {
+ int64_t request_seq;
+ bool success;
+ std::string command;
+ std::optional<std::string> message;
+ std::optional<llvm::json::Value> rawBody;
+};
+bool fromJSON(const llvm::json::Value &, Response &, llvm::json::Path);
+llvm::json::Value toJSON(const Response &);
+
+// A void response body for any response without a specific value.
+using VoidResponseBody = std::nullptr_t;
+
+// "ProtocolMessage": {
+// "type": "object",
+// "title": "Base Protocol",
+// "description": "Base class of requests, responses, and events.",
+// "properties": {
+// "seq": {
+// "type": "integer",
+// "description": "Sequence number of the message (also known as
+// message ID). The `seq` for the first message sent by a client or
+// debug adapter is 1, and for each subsequent message is 1 greater
+// than the previous message sent by that actor. `seq` can be used to
+// order requests, responses, and events, and to associate requests
+// with their corresponding responses. For protocol messages of type
+// `request` the sequence number can be used to cancel the request."
+// },
+// "type": {
+// "type": "string",
+// "description": "Message type.",
+// "_enum": [ "request", "response", "event" ]
+// }
+// },
+// "required": [ "seq", "type" ]
+// },
+// struct ProtocolMessage {
+// MessageType type;
+// int64_t seq;
+// };
+// enum class MessageType { request, event, response };
+using ProtocolMessage = std::variant<Request, Response, Event>;
+bool fromJSON(const llvm::json::Value &, ProtocolMessage &, llvm::json::Path);
+llvm::json::Value toJSON(const ProtocolMessage &);
+
+} // namespace protocol
+} // namespace lldb_dap
+
+#endif
diff --git a/lldb/tools/lldb-dap/Transport.cpp b/lldb/tools/lldb-dap/Transport.cpp
new file mode 100644
index 0000000000000..780b7902a8045
--- /dev/null
+++ b/lldb/tools/lldb-dap/Transport.cpp
@@ -0,0 +1,110 @@
+//===-- Transport.cpp -------------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===/
+
+#include "Transport.h"
+#include "DAPLog.h"
+#include "Protocol.h"
+#include "lldb/Utility/IOObject.h"
+#include "lldb/Utility/Status.h"
+#include "lldb/lldb-forward.h"
+#include "llvm/ADT/StringExtras.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
+#include <utility>
+
+using namespace llvm;
+using namespace lldb;
+using namespace lldb_private;
+using namespace lldb_dap::protocol;
+
+static Expected<std::string> ReadBytes(IOObjectSP &IO, size_t length) {
+ std::string data;
+ data.resize(length);
+
+ auto status = IO->Read(data.data(), length);
+ if (status.Fail())
+ return status.takeError();
+ // Return a slice of the amount read, which may be less than the requested
+ // length.
+ return data.substr(0, length);
+}
+
+static Expected<std::string> ReadUpTo(IOObjectSP &IO,
+ const std::string &delimiter) {
+ std::string buf;
+ while (!StringRef(buf).ends_with(delimiter)) {
+ auto byte = ReadBytes(IO, 1);
+ if (!byte)
+ return byte.takeError();
+ buf += *byte;
+ }
+ return buf.substr(0, buf.size() - delimiter.size());
+}
+
+static Error ReadExpected(IOObjectSP &IO, const std::string &expected) {
+ auto result = ReadBytes(IO, expected.size());
+ if (!result)
+ return result.takeError();
+ if (*result != expected)
+ return createStringError("expected %s, got %s", expected.c_str(),
+ result->c_str());
+ return Error::success();
+}
+
+namespace lldb_dap {
+
+Transport::Transport(StringRef client_name, IOObjectSP input, IOObjectSP output)
+ : m_client_name(client_name), m_input(std::move(input)),
+ m_output(std::move(output)) {}
+
+Status Transport::Write(const ProtocolMessage &M) {
+ if (!m_output || !m_output->IsValid())
+ return Status("transport output is closed");
+
+ std::string JSON = formatv("{0}", toJSON(M)).str();
+
+ LLDB_LOG(GetLog(DAPLog::Transport), "--> ({0}) {1}", m_client_name, JSON);
+
+ std::string Output;
+ raw_string_ostream OS(Output);
+ OS << "Content-Length: " << JSON.length() << "\r\n\r\n" << JSON;
+ size_t num_bytes = Output.size();
+ return m_output->Write(Output.data(), num_bytes);
+}
+
+Expected<ProtocolMessage> Transport::Read() {
+ if (!m_input || !m_input->IsValid())
+ return make_error<StringError>(inconvertibleErrorCode(),
+ "transport input is closed");
+
+ if (auto Err = ReadExpected(m_input, "Content-Length: "))
+ return std::move(Err);
+
+ auto rawLength = ReadUpTo(m_input, "\r\n\r\n");
+ if (!rawLength)
+ return rawLength.takeError();
+
+ size_t length;
+ if (!to_integer(*rawLength, length))
+ return createStringError("invalid content length %s", rawLength->c_str());
+
+ auto rawJSON = ReadBytes(m_input, length);
+ if (!rawJSON)
+ return rawJSON.takeError();
+ if (rawJSON->length() != length)
+ return createStringError(
+ std::errc::message_size,
+ "malformed request, expected %ld bytes, got %ld bytes", length,
+ rawJSON->length());
+
+ LLDB_LOG(GetLog(DAPLog::Transport), "<-- ({0}) {1}", m_client_name, *rawJSON);
+
+ return json::parse<protocol::ProtocolMessage>(*rawJSON);
+}
+
+} // namespace lldb_dap
diff --git a/lldb/tools/lldb-dap/Transport.h b/lldb/tools/lldb-dap/Transport.h
new file mode 100644
index 0000000000000..c6f7967eeb323
--- /dev/null
+++ b/lldb/tools/lldb-dap/Transport.h
@@ -0,0 +1,48 @@
+//===-- Transport.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Debug Adapter Protocol transport layer for encoding and decoding protocol
+// messages.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_TOOLS_LLDB_DAP_TRANSPORT_H
+#define LLDB_TOOLS_LLDB_DAP_TRANSPORT_H
+
+#include "Protocol.h"
+#include "lldb/lldb-forward.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace lldb_dap {
+
+/// A transport class that performs the Debug Adapter Protocol communication
+/// with the client.
+class Transport {
+public:
+ Transport(llvm::StringRef client_name, lldb::IOObjectSP input,
+ lldb::IOObjectSP output);
+ ~Transport() = default;
+
+ Transport(const Transport &rhs) = delete;
+ void operator=(const Transport &rhs) = delete;
+
+ /// Writes a Debug Adater Protocol message to the output stream.
+ lldb_private::Status Write(const protocol::ProtocolMessage &M);
+
+ /// Reads the next Debug Adater Protocol message from the input stream.
+ llvm::Expected<protocol::ProtocolMessage> Read();
+
+private:
+ llvm::StringRef m_client_name;
+ lldb::IOObjectSP m_input;
+ lldb::IOObjectSP m_output;
+};
+
+} // namespace lldb_dap
+
+#endif
diff --git a/lldb/tools/lldb-dap/lldb-dap.cpp b/lldb/tools/lldb-dap/lldb-dap.cpp
index d8b92831d5540..4a021ad8ad347 100644
--- a/lldb/tools/lldb-dap/lldb-dap.cpp
+++ b/lldb/tools/lldb-dap/lldb-dap.cpp
@@ -7,11 +7,9 @@
//===----------------------------------------------------------------------===//
#include "DAP.h"
+#include "DAPLog.h"
#include "EventHelper.h"
-#include "FifoFiles.h"
#include "Handler/RequestHandler.h"
-#include "JSONUtils.h"
-#include "LLDBUtils.h"
#include "RunInTerminal.h"
#include "lldb/API/SBStream.h"
#include "lldb/Host/Config.h"
@@ -38,9 +36,7 @@
#include "llvm/Support/Signals.h"
#include "llvm/Support/Threading.h"
#include "llvm/Support/raw_ostream.h"
-#include <algorithm>
#include <condition_variable>
-#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
@@ -415,6 +411,21 @@ serveConnection(const Socket::SocketProtocol &protocol, const std::string &name,
return llvm::Error::success();
}
+class DAPLogHandler : public lldb_private::LogHandler {
+public:
+ DAPLogHandler(std::shared_ptr<std::ofstream> stream) : m_stream(stream) {}
+
+ void Emit(llvm::StringRef message) override {
+ std::lock_guard<std::mutex> guard(m_mutex);
+ (*m_stream) << message.str();
+ m_stream->flush();
+ }
+
+private:
+ std::mutex m_mutex;
+ std::shared_ptr<std::ofstream> m_stream;
+};
+
int main(int argc, char *argv[]) {
llvm::InitLLVM IL(argc, argv, /*InstallPipeSignalExitHandler=*/false);
#if !defined(__APPLE__)
@@ -498,10 +509,21 @@ int main(int argc, char *argv[]) {
}
#endif
- std::unique_ptr<std::ofstream> log = nullptr;
+ InitializeDAPChannel();
+
+ // TODO(harjohn): Migrate 'log' to LLDB_LOG helpers.
+ std::shared_ptr<std::ofstream> log = nullptr;
const char *log_file_path = getenv("LLDBDAP_LOG");
- if (log_file_path)
- log = std::make_unique<std::ofstream>(log_file_path);
+ if (log_file_path) {
+ log = std::make_shared<std::ofstream>(log_file_path);
+
+ if (!lldb_private::Log::EnableLogChannel(
+ std::make_shared<DAPLogHandler>(log),
+ LLDB_LOG_OPTION_PREPEND_TIMESTAMP, "lldb-dap", {"all"},
+ llvm::errs())) {
+ return EXIT_FAILURE;
+ }
+ }
// Initialize LLDB first before we do anything.
lldb::SBError error = lldb::SBDebugger::InitializeWithErrorHandling();
More information about the lldb-commits
mailing list