[Lldb-commits] [lldb] a0aa5f8 - [lldb-dap] Refactoring lldb-dap 'launch' request to use typed RequestHandler<>. (#133624)
via lldb-commits
lldb-commits at lists.llvm.org
Fri Apr 25 09:50:46 PDT 2025
Author: John Harrison
Date: 2025-04-25T09:50:42-07:00
New Revision: a0aa5f8933043c0939c3a8f301fed655be2a3732
URL: https://github.com/llvm/llvm-project/commit/a0aa5f8933043c0939c3a8f301fed655be2a3732
DIFF: https://github.com/llvm/llvm-project/commit/a0aa5f8933043c0939c3a8f301fed655be2a3732.diff
LOG: [lldb-dap] Refactoring lldb-dap 'launch' request to use typed RequestHandler<>. (#133624)
This converts a number of json::Value's into well defined types that are
used throughout lldb-dap and updates the 'launch' command to use the new
well defined types.
---------
Co-authored-by: Jonas Devlieghere <jonas at devlieghere.com>
Added:
Modified:
lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py
lldb/packages/Python/lldbsuite/test/tools/lldb-dap/lldbdap_testcase.py
lldb/test/API/tools/lldb-dap/launch/TestDAP_launch.py
lldb/tools/lldb-dap/DAP.cpp
lldb/tools/lldb-dap/DAP.h
lldb/tools/lldb-dap/Handler/AttachRequestHandler.cpp
lldb/tools/lldb-dap/Handler/LaunchRequestHandler.cpp
lldb/tools/lldb-dap/Handler/RequestHandler.cpp
lldb/tools/lldb-dap/Handler/RequestHandler.h
lldb/tools/lldb-dap/Handler/RestartRequestHandler.cpp
lldb/tools/lldb-dap/JSONUtils.cpp
lldb/tools/lldb-dap/JSONUtils.h
lldb/tools/lldb-dap/LLDBUtils.cpp
lldb/tools/lldb-dap/Protocol/ProtocolRequests.cpp
lldb/tools/lldb-dap/Protocol/ProtocolRequests.h
Removed:
################################################################################
diff --git a/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py b/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py
index dadf6b1f8774c..0f8a84461c9e7 100644
--- a/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py
+++ b/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/dap_server.py
@@ -860,7 +860,8 @@ def request_launch(
args_dict["enableAutoVariableSummaries"] = enableAutoVariableSummaries
args_dict["enableSyntheticChildDebugging"] = enableSyntheticChildDebugging
args_dict["displayExtendedBacktrace"] = displayExtendedBacktrace
- args_dict["commandEscapePrefix"] = commandEscapePrefix
+ if commandEscapePrefix:
+ args_dict["commandEscapePrefix"] = commandEscapePrefix
command_dict = {"command": "launch", "type": "request", "arguments": args_dict}
response = self.send_recv(command_dict)
diff --git a/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/lldbdap_testcase.py b/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/lldbdap_testcase.py
index b5b55b336d535..2671d65031203 100644
--- a/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/lldbdap_testcase.py
+++ b/lldb/packages/Python/lldbsuite/test/tools/lldb-dap/lldbdap_testcase.py
@@ -453,7 +453,8 @@ def cleanup():
if not (response and response["success"]):
self.assertTrue(
- response["success"], "launch failed (%s)" % (response["message"])
+ response["success"],
+ "launch failed (%s)" % (response["body"]["error"]["format"]),
)
return response
diff --git a/lldb/test/API/tools/lldb-dap/launch/TestDAP_launch.py b/lldb/test/API/tools/lldb-dap/launch/TestDAP_launch.py
index 4303f2d3a5193..e20a9db377f7f 100644
--- a/lldb/test/API/tools/lldb-dap/launch/TestDAP_launch.py
+++ b/lldb/test/API/tools/lldb-dap/launch/TestDAP_launch.py
@@ -27,6 +27,34 @@ def test_default(self):
lines = output.splitlines()
self.assertIn(program, lines[0], "make sure program path is in first argument")
+ def test_failing_launch_program(self):
+ """
+ Tests launching with an invalid program.
+ """
+ program = self.getBuildArtifact("a.out")
+ self.create_debug_adapter()
+ response = self.launch(program, expectFailure=True)
+ self.assertFalse(response["success"])
+ self.assertEqual(
+ "'{0}' does not exist".format(program), response["body"]["error"]["format"]
+ )
+
+ def test_failing_launch_commands_and_run_in_terminal(self):
+ """
+ Tests launching with an invalid program.
+ """
+ program = self.getBuildArtifact("a.out")
+ self.create_debug_adapter()
+ response = self.launch(
+ program, launchCommands=["a b c"], runInTerminal=True, expectFailure=True
+ )
+ self.assertFalse(response["success"])
+ self.assertTrue(self.get_dict_value(response, ["body", "error", "showUser"]))
+ self.assertEqual(
+ "launchCommands and runInTerminal are mutually exclusive",
+ self.get_dict_value(response, ["body", "error", "format"]),
+ )
+
@skipIfWindows
def test_termination(self):
"""
@@ -42,7 +70,9 @@ def test_termination(self):
self.dap_server.request_disconnect()
# Wait until the underlying lldb-dap process dies.
- self.dap_server.process.wait(timeout=lldbdap_testcase.DAPTestCaseBase.timeoutval)
+ self.dap_server.process.wait(
+ timeout=lldbdap_testcase.DAPTestCaseBase.timeoutval
+ )
# Check the return code
self.assertEqual(self.dap_server.process.poll(), 0)
@@ -460,7 +490,7 @@ def test_failing_launch_commands(self):
self.assertFalse(response["success"])
self.assertRegex(
- response["message"],
+ response["body"]["error"]["format"],
r"Failed to run launch commands\. See the Debug Console for more details",
)
diff --git a/lldb/tools/lldb-dap/DAP.cpp b/lldb/tools/lldb-dap/DAP.cpp
index 7657ab5b564a1..185b475cfcad6 100644
--- a/lldb/tools/lldb-dap/DAP.cpp
+++ b/lldb/tools/lldb-dap/DAP.cpp
@@ -660,9 +660,7 @@ void DAP::RunTerminateCommands() {
configuration.terminateCommands);
}
-lldb::SBTarget
-DAP::CreateTargetFromArguments(const llvm::json::Object &arguments,
- lldb::SBError &error) {
+lldb::SBTarget DAP::CreateTarget(lldb::SBError &error) {
// Grab the name of the program we need to debug and create a target using
// the given program as an argument. Executable file can be a source of target
// architecture and platform, if they
diff er from the host. Setting exe path
@@ -671,25 +669,15 @@ DAP::CreateTargetFromArguments(const llvm::json::Object &arguments,
// creation. We also use target triple and platform from the launch
// configuration, if given, since in some cases ELF file doesn't contain
// enough information to determine correct arch and platform (or ELF can be
- // omitted at all), so it is good to leave the user an apportunity to specify
+ // omitted at all), so it is good to leave the user an opportunity to specify
// those. Any of those three can be left empty.
- const llvm::StringRef target_triple =
- GetString(arguments, "targetTriple").value_or("");
- const llvm::StringRef platform_name =
- GetString(arguments, "platformName").value_or("");
- const llvm::StringRef program = GetString(arguments, "program").value_or("");
auto target = this->debugger.CreateTarget(
- program.data(), target_triple.data(), platform_name.data(),
+ configuration.program.value_or("").data(),
+ configuration.targetTriple.value_or("").data(),
+ configuration.platformName.value_or("").data(),
true, // Add dependent modules.
error);
- if (error.Fail()) {
- // Update message if there was an error.
- error.SetErrorStringWithFormat(
- "Could not create a target for a program '%s': %s.", program.data(),
- error.GetCString());
- }
-
return target;
}
@@ -945,7 +933,7 @@ llvm::Error DAP::Loop() {
return queue_reader.get();
}
-lldb::SBError DAP::WaitForProcessToStop(uint32_t seconds) {
+lldb::SBError DAP::WaitForProcessToStop(std::chrono::seconds seconds) {
lldb::SBError error;
lldb::SBProcess process = target.GetProcess();
if (!process.IsValid()) {
@@ -980,8 +968,8 @@ lldb::SBError DAP::WaitForProcessToStop(uint32_t seconds) {
}
std::this_thread::sleep_for(std::chrono::microseconds(250));
}
- error.SetErrorStringWithFormat("process failed to stop within %u seconds",
- seconds);
+ error.SetErrorStringWithFormat("process failed to stop within %lld seconds",
+ seconds.count());
return error;
}
@@ -1178,6 +1166,36 @@ bool SendEventRequestHandler::DoExecute(lldb::SBDebugger debugger,
return true;
}
+void DAP::ConfigureSourceMaps() {
+ if (configuration.sourceMap.empty() && !configuration.sourcePath)
+ return;
+
+ std::string sourceMapCommand;
+ llvm::raw_string_ostream strm(sourceMapCommand);
+ strm << "settings set target.source-map ";
+
+ if (!configuration.sourceMap.empty()) {
+ for (const auto &kv : configuration.sourceMap) {
+ strm << "\"" << kv.first << "\" \"" << kv.second << "\" ";
+ }
+ } else if (configuration.sourcePath) {
+ strm << "\".\" \"" << *configuration.sourcePath << "\"";
+ }
+
+ RunLLDBCommands("Setting source map:", {sourceMapCommand});
+}
+
+void DAP::SetConfiguration(const protocol::Configuration &config,
+ bool is_attach) {
+ configuration = config;
+ this->is_attach = is_attach;
+
+ if (configuration.customFrameFormat)
+ SetFrameFormat(*configuration.customFrameFormat);
+ if (configuration.customThreadFormat)
+ SetThreadFormat(*configuration.customThreadFormat);
+}
+
void DAP::SetFrameFormat(llvm::StringRef format) {
if (format.empty())
return;
diff --git a/lldb/tools/lldb-dap/DAP.h b/lldb/tools/lldb-dap/DAP.h
index 727e5c00623e8..f5cc41bf646bb 100644
--- a/lldb/tools/lldb-dap/DAP.h
+++ b/lldb/tools/lldb-dap/DAP.h
@@ -35,6 +35,7 @@
#include "lldb/lldb-types.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/FunctionExtras.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
@@ -175,9 +176,9 @@ struct DAP {
llvm::once_flag init_exception_breakpoints_flag;
// Map step in target id to list of function targets that user can choose.
llvm::DenseMap<lldb::addr_t, std::string> step_in_targets;
- // A copy of the last LaunchRequest or AttachRequest so we can reuse its
- // arguments if we get a RestartRequest.
- std::optional<llvm::json::Object> last_launch_or_attach_request;
+ // A copy of the last LaunchRequest so we can reuse its arguments if we get a
+ // RestartRequest. Restarting an AttachRequest is not supported.
+ std::optional<protocol::LaunchRequestArguments> last_launch_request;
lldb::tid_t focus_tid;
bool disconnecting = false;
llvm::once_flag terminated_event_flag;
@@ -199,7 +200,6 @@ struct DAP {
llvm::SmallDenseMap<int64_t, std::unique_ptr<ResponseHandler>>
inflight_reverse_requests;
ReplMode repl_mode;
-
lldb::SBFormat frame_format;
lldb::SBFormat thread_format;
// This is used to allow request_evaluate to handle empty expressions
@@ -248,6 +248,12 @@ struct DAP {
/// Stop event handler threads.
void StopEventHandlers();
+ /// Configures the debug adapter for launching/attaching.
+ void SetConfiguration(const protocol::Configuration &confing, bool is_attach);
+
+ /// Configure source maps based on the current `DAPConfiguration`.
+ void ConfigureSourceMaps();
+
/// Serialize the JSON value into a string and send the JSON packet to the
/// "out" stream.
void SendJSON(const llvm::json::Value &json);
@@ -311,8 +317,6 @@ struct DAP {
void RunTerminateCommands();
/// Create a new SBTarget object from the given request arguments.
- /// \param[in] arguments
- /// Launch configuration arguments.
///
/// \param[out] error
/// An SBError object that will contain an error description if
@@ -320,8 +324,7 @@ struct DAP {
///
/// \return
/// An SBTarget object.
- lldb::SBTarget CreateTargetFromArguments(const llvm::json::Object &arguments,
- lldb::SBError &error);
+ lldb::SBTarget CreateTarget(lldb::SBError &error);
/// Set given target object as a current target for lldb-dap and start
/// listeing for its breakpoint events.
@@ -395,7 +398,7 @@ struct DAP {
/// The number of seconds to poll the process to wait until it is stopped.
///
/// \return Error if waiting for the process fails, no error if succeeds.
- lldb::SBError WaitForProcessToStop(uint32_t seconds);
+ lldb::SBError WaitForProcessToStop(std::chrono::seconds seconds);
void SetFrameFormat(llvm::StringRef format);
diff --git a/lldb/tools/lldb-dap/Handler/AttachRequestHandler.cpp b/lldb/tools/lldb-dap/Handler/AttachRequestHandler.cpp
index 5e622f3d3dcd4..3ef87cbef873c 100644
--- a/lldb/tools/lldb-dap/Handler/AttachRequestHandler.cpp
+++ b/lldb/tools/lldb-dap/Handler/AttachRequestHandler.cpp
@@ -43,10 +43,8 @@ namespace lldb_dap {
// acknowledgement, so no body field is required."
// }]
// }
-
void AttachRequestHandler::operator()(const llvm::json::Object &request) const {
dap.is_attach = true;
- dap.last_launch_or_attach_request = request;
llvm::json::Object response;
lldb::SBError error;
FillResponse(request, response);
@@ -65,6 +63,7 @@ void AttachRequestHandler::operator()(const llvm::json::Object &request) const {
attach_info.SetWaitForLaunch(wait_for, false /*async*/);
dap.configuration.initCommands = GetStrings(arguments, "initCommands");
dap.configuration.preRunCommands = GetStrings(arguments, "preRunCommands");
+ dap.configuration.postRunCommands = GetStrings(arguments, "postRunCommands");
dap.configuration.stopCommands = GetStrings(arguments, "stopCommands");
dap.configuration.exitCommands = GetStrings(arguments, "exitCommands");
dap.configuration.terminateCommands =
@@ -76,7 +75,6 @@ void AttachRequestHandler::operator()(const llvm::json::Object &request) const {
dap.stop_at_entry = core_file.empty()
? GetBoolean(arguments, "stopOnEntry").value_or(false)
: true;
- dap.configuration.postRunCommands = GetStrings(arguments, "postRunCommands");
const llvm::StringRef debuggerRoot =
GetString(arguments, "debuggerRoot").value_or("");
dap.configuration.enableAutoVariableSummaries =
@@ -87,6 +85,9 @@ void AttachRequestHandler::operator()(const llvm::json::Object &request) const {
GetBoolean(arguments, "displayExtendedBacktrace").value_or(false);
dap.configuration.commandEscapePrefix =
GetString(arguments, "commandEscapePrefix").value_or("`");
+ dap.configuration.program = GetString(arguments, "program");
+ dap.configuration.targetTriple = GetString(arguments, "targetTriple");
+ dap.configuration.platformName = GetString(arguments, "platformName");
dap.SetFrameFormat(GetString(arguments, "customFrameFormat").value_or(""));
dap.SetThreadFormat(GetString(arguments, "customThreadFormat").value_or(""));
@@ -110,7 +111,7 @@ void AttachRequestHandler::operator()(const llvm::json::Object &request) const {
SetSourceMapFromArguments(*arguments);
lldb::SBError status;
- dap.SetTarget(dap.CreateTargetFromArguments(*arguments, status));
+ dap.SetTarget(dap.CreateTarget(status));
if (status.Fail()) {
response["success"] = llvm::json::Value(false);
EmplaceSafeString(response, "message", status.GetCString());
@@ -180,7 +181,7 @@ void AttachRequestHandler::operator()(const llvm::json::Object &request) const {
// Make sure the process is attached and stopped before proceeding as the
// the launch commands are not run using the synchronous mode.
- error = dap.WaitForProcessToStop(timeout_seconds);
+ error = dap.WaitForProcessToStop(std::chrono::seconds(timeout_seconds));
}
if (error.Success() && core_file.empty()) {
diff --git a/lldb/tools/lldb-dap/Handler/LaunchRequestHandler.cpp b/lldb/tools/lldb-dap/Handler/LaunchRequestHandler.cpp
index 5f14cb074e37e..3e4532e754ec6 100644
--- a/lldb/tools/lldb-dap/Handler/LaunchRequestHandler.cpp
+++ b/lldb/tools/lldb-dap/Handler/LaunchRequestHandler.cpp
@@ -9,71 +9,26 @@
#include "DAP.h"
#include "EventHelper.h"
#include "JSONUtils.h"
+#include "LLDBUtils.h"
+#include "Protocol/ProtocolRequests.h"
#include "RequestHandler.h"
+#include "llvm/Support/Error.h"
#include "llvm/Support/FileSystem.h"
+using namespace llvm;
+using namespace lldb_dap::protocol;
+
namespace lldb_dap {
-// "LaunchRequest": {
-// "allOf": [ { "$ref": "#/definitions/Request" }, {
-// "type": "object",
-// "description": "Launch request; value of command field is 'launch'.",
-// "properties": {
-// "command": {
-// "type": "string",
-// "enum": [ "launch" ]
-// },
-// "arguments": {
-// "$ref": "#/definitions/LaunchRequestArguments"
-// }
-// },
-// "required": [ "command", "arguments" ]
-// }]
-// },
-// "LaunchRequestArguments": {
-// "type": "object",
-// "description": "Arguments for 'launch' request.",
-// "properties": {
-// "noDebug": {
-// "type": "boolean",
-// "description": "If noDebug is true the launch request should launch
-// the program without enabling debugging."
-// }
-// }
-// },
-// "LaunchResponse": {
-// "allOf": [ { "$ref": "#/definitions/Response" }, {
-// "type": "object",
-// "description": "Response to 'launch' request. This is just an
-// acknowledgement, so no body field is required."
-// }]
-// }
-void LaunchRequestHandler::operator()(const llvm::json::Object &request) const {
- dap.is_attach = false;
- dap.last_launch_or_attach_request = request;
- llvm::json::Object response;
- FillResponse(request, response);
- const auto *arguments = request.getObject("arguments");
- dap.configuration.initCommands = GetStrings(arguments, "initCommands");
- dap.configuration.preRunCommands = GetStrings(arguments, "preRunCommands");
- dap.configuration.stopCommands = GetStrings(arguments, "stopCommands");
- dap.configuration.exitCommands = GetStrings(arguments, "exitCommands");
- dap.configuration.terminateCommands =
- GetStrings(arguments, "terminateCommands");
- dap.configuration.postRunCommands = GetStrings(arguments, "postRunCommands");
- dap.stop_at_entry = GetBoolean(arguments, "stopOnEntry").value_or(false);
- const llvm::StringRef debuggerRoot =
- GetString(arguments, "debuggerRoot").value_or("");
- dap.configuration.enableAutoVariableSummaries =
- GetBoolean(arguments, "enableAutoVariableSummaries").value_or(false);
- dap.configuration.enableSyntheticChildDebugging =
- GetBoolean(arguments, "enableSyntheticChildDebugging").value_or(false);
- dap.configuration.displayExtendedBacktrace =
- GetBoolean(arguments, "displayExtendedBacktrace").value_or(false);
- dap.configuration.commandEscapePrefix =
- GetString(arguments, "commandEscapePrefix").value_or("`");
- dap.SetFrameFormat(GetString(arguments, "customFrameFormat").value_or(""));
- dap.SetThreadFormat(GetString(arguments, "customThreadFormat").value_or(""));
+/// Launch request; value of command field is 'launch'.
+Error LaunchRequestHandler::Run(const LaunchRequestArguments &arguments) const {
+ dap.SetConfiguration(arguments.configuration, /*is_attach=*/false);
+ dap.last_launch_request = arguments;
+ dap.stop_at_entry = arguments.stopOnEntry;
+
+ if (!arguments.launchCommands.empty() && arguments.runInTerminal)
+ return make_error<DAPError>(
+ "launchCommands and runInTerminal are mutually exclusive");
PrintWelcomeMessage();
@@ -81,55 +36,44 @@ void LaunchRequestHandler::operator()(const llvm::json::Object &request) const {
// in the debug map of the main executable have relative paths which
// require the lldb-dap binary to have its working directory set to that
// relative root for the .o files in order to be able to load debug info.
- if (!debuggerRoot.empty())
- llvm::sys::fs::set_current_path(debuggerRoot);
+ const std::string debugger_root = dap.configuration.debuggerRoot.value_or("");
+ if (!debugger_root.empty())
+ sys::fs::set_current_path(debugger_root);
// Run any initialize LLDB commands the user specified in the launch.json.
// This is run before target is created, so commands can't do anything with
// the targets - preRunCommands are run with the target.
- if (llvm::Error err = dap.RunInitCommands()) {
- response["success"] = false;
- EmplaceSafeString(response, "message", llvm::toString(std::move(err)));
- dap.SendJSON(llvm::json::Value(std::move(response)));
- return;
- }
+ if (Error err = dap.RunInitCommands())
+ return err;
- SetSourceMapFromArguments(*arguments);
+ dap.ConfigureSourceMaps();
- lldb::SBError status;
- dap.SetTarget(dap.CreateTargetFromArguments(*arguments, status));
- if (status.Fail()) {
- response["success"] = llvm::json::Value(false);
- EmplaceSafeString(response, "message", status.GetCString());
- dap.SendJSON(llvm::json::Value(std::move(response)));
- return;
- }
+ lldb::SBError error;
+ lldb::SBTarget target = dap.CreateTarget(error);
+ if (error.Fail())
+ return ToError(error);
+
+ dap.SetTarget(target);
// Run any pre run LLDB commands the user specified in the launch.json
- if (llvm::Error err = dap.RunPreRunCommands()) {
- response["success"] = false;
- EmplaceSafeString(response, "message", llvm::toString(std::move(err)));
- dap.SendJSON(llvm::json::Value(std::move(response)));
- return;
- }
+ if (Error err = dap.RunPreRunCommands())
+ return err;
- status = LaunchProcess(request);
+ if (Error err = LaunchProcess(arguments))
+ return err;
- if (status.Fail()) {
- response["success"] = llvm::json::Value(false);
- EmplaceSafeString(response, "message", std::string(status.GetCString()));
- } else {
- dap.RunPostRunCommands();
- }
+ dap.RunPostRunCommands();
- dap.SendJSON(llvm::json::Value(std::move(response)));
+ return Error::success();
+}
- if (!status.Fail()) {
- if (dap.is_attach)
- SendProcessEvent(dap, Attach); // this happens when doing runInTerminal
- else
- SendProcessEvent(dap, Launch);
+void LaunchRequestHandler::PostRun() const {
+ if (dap.target.GetProcess().IsValid()) {
+ // Attach happens when launching with runInTerminal.
+ SendProcessEvent(dap, dap.is_attach ? Attach : Launch);
}
+
dap.SendJSON(CreateEventObject("initialized"));
}
+
} // namespace lldb_dap
diff --git a/lldb/tools/lldb-dap/Handler/RequestHandler.cpp b/lldb/tools/lldb-dap/Handler/RequestHandler.cpp
index be9273963654a..b7d3c8ced69f1 100644
--- a/lldb/tools/lldb-dap/Handler/RequestHandler.cpp
+++ b/lldb/tools/lldb-dap/Handler/RequestHandler.cpp
@@ -10,9 +10,11 @@
#include "DAP.h"
#include "Handler/ResponseHandler.h"
#include "JSONUtils.h"
-#include "LLDBUtils.h"
#include "Protocol/ProtocolBase.h"
+#include "Protocol/ProtocolRequests.h"
#include "RunInTerminal.h"
+#include "lldb/API/SBDefines.h"
+#include "lldb/API/SBEnvironment.h"
#include "llvm/Support/Error.h"
#include <mutex>
@@ -37,14 +39,12 @@ MakeArgv(const llvm::ArrayRef<std::string> &strs) {
return argv;
}
-static uint32_t SetLaunchFlag(uint32_t flags, const llvm::json::Object *obj,
- llvm::StringRef key, lldb::LaunchFlags mask) {
- if (const auto opt_value = GetBoolean(obj, key)) {
- if (*opt_value)
- flags |= mask;
- else
- flags &= ~mask;
- }
+static uint32_t SetLaunchFlag(uint32_t flags, bool flag,
+ lldb::LaunchFlags mask) {
+ if (flag)
+ flags |= mask;
+ else
+ flags &= ~mask;
return flags;
}
@@ -99,14 +99,18 @@ void BaseRequestHandler::SetSourceMapFromArguments(
}
}
-static llvm::Error RunInTerminal(DAP &dap,
- const llvm::json::Object &launch_request,
- const uint64_t timeout_seconds) {
+static llvm::Error
+RunInTerminal(DAP &dap, const protocol::LaunchRequestArguments &arguments) {
if (!dap.clientFeatures.contains(
protocol::eClientFeatureRunInTerminalRequest))
return llvm::make_error<DAPError>("Cannot use runInTerminal, feature is "
"not supported by the connected client");
+ if (!arguments.configuration.program ||
+ arguments.configuration.program->empty())
+ return llvm::make_error<DAPError>(
+ "program must be set to when using runInTerminal");
+
dap.is_attach = true;
lldb::SBAttachInfo attach_info;
@@ -122,8 +126,10 @@ static llvm::Error RunInTerminal(DAP &dap,
#if !defined(_WIN32)
debugger_pid = getpid();
#endif
+
llvm::json::Object reverse_request = CreateRunInTerminalReverseRequest(
- launch_request, comm_file.m_path, debugger_pid);
+ *arguments.configuration.program, arguments.args, arguments.env,
+ arguments.cwd.value_or(""), comm_file.m_path, debugger_pid);
dap.SendReverseRequest<LogFailureResponseHandler>("runInTerminal",
std::move(reverse_request));
@@ -194,74 +200,74 @@ void BaseRequestHandler::Run(const Request &request) {
// mark the response as cancelled.
}
-lldb::SBError
-BaseRequestHandler::LaunchProcess(const llvm::json::Object &request) const {
- lldb::SBError error;
- const auto *arguments = request.getObject("arguments");
- auto launchCommands = GetStrings(arguments, "launchCommands");
+llvm::Error BaseRequestHandler::LaunchProcess(
+ const protocol::LaunchRequestArguments &arguments) const {
+ auto launchCommands = arguments.launchCommands;
// Instantiate a launch info instance for the target.
auto launch_info = dap.target.GetLaunchInfo();
// Grab the current working directory if there is one and set it in the
// launch info.
- const auto cwd = GetString(arguments, "cwd").value_or("");
+ const auto cwd = arguments.cwd.value_or("");
if (!cwd.empty())
launch_info.SetWorkingDirectory(cwd.data());
// Extract any extra arguments and append them to our program arguments for
// when we launch
- auto args = GetStrings(arguments, "args");
- if (!args.empty())
- launch_info.SetArguments(MakeArgv(args).data(), true);
+ if (!arguments.args.empty())
+ launch_info.SetArguments(MakeArgv(arguments.args).data(), true);
// Pass any environment variables along that the user specified.
- const auto envs = GetEnvironmentFromArguments(*arguments);
- launch_info.SetEnvironment(envs, true);
+ if (!arguments.env.empty()) {
+ lldb::SBEnvironment env;
+ for (const auto &kv : arguments.env)
+ env.Set(kv.first().data(), kv.second.c_str(), true);
+ launch_info.SetEnvironment(env, true);
+ }
- auto flags = launch_info.GetLaunchFlags();
+ launch_info.SetDetachOnError(arguments.detachOnError);
+ launch_info.SetShellExpandArguments(arguments.shellExpandArguments);
- flags = SetLaunchFlag(flags, arguments, "disableASLR",
- lldb::eLaunchFlagDisableASLR);
- flags = SetLaunchFlag(flags, arguments, "disableSTDIO",
+ auto flags = launch_info.GetLaunchFlags();
+ flags =
+ SetLaunchFlag(flags, arguments.disableASLR, lldb::eLaunchFlagDisableASLR);
+ flags = SetLaunchFlag(flags, arguments.disableSTDIO,
lldb::eLaunchFlagDisableSTDIO);
- flags = SetLaunchFlag(flags, arguments, "shellExpandArguments",
- lldb::eLaunchFlagShellExpandArguments);
-
- const bool detachOnError =
- GetBoolean(arguments, "detachOnError").value_or(false);
- launch_info.SetDetachOnError(detachOnError);
launch_info.SetLaunchFlags(flags | lldb::eLaunchFlagDebug |
lldb::eLaunchFlagStopAtEntry);
- const auto timeout_seconds =
- GetInteger<uint64_t>(arguments, "timeout").value_or(30);
- if (GetBoolean(arguments, "runInTerminal").value_or(false)) {
- if (llvm::Error err = RunInTerminal(dap, request, timeout_seconds))
- error.SetErrorString(llvm::toString(std::move(err)).c_str());
+ if (arguments.runInTerminal) {
+ if (llvm::Error err = RunInTerminal(dap, arguments))
+ return err;
} else if (launchCommands.empty()) {
+ lldb::SBError error;
// Disable async events so the launch will be successful when we return from
// the launch call and the launch will happen synchronously
dap.debugger.SetAsync(false);
dap.target.Launch(launch_info, error);
dap.debugger.SetAsync(true);
+ if (error.Fail())
+ return llvm::make_error<DAPError>(error.GetCString());
} else {
// Set the launch info so that run commands can access the configured
// launch details.
dap.target.SetLaunchInfo(launch_info);
- if (llvm::Error err = dap.RunLaunchCommands(launchCommands)) {
- error.SetErrorString(llvm::toString(std::move(err)).c_str());
- return error;
- }
+ if (llvm::Error err = dap.RunLaunchCommands(launchCommands))
+ return err;
+
// The custom commands might have created a new target so we should use the
// selected target after these commands are run.
dap.target = dap.debugger.GetSelectedTarget();
// Make sure the process is launched and stopped at the entry point before
// proceeding as the launch commands are not run using the synchronous
// mode.
- error = dap.WaitForProcessToStop(timeout_seconds);
+ lldb::SBError error = dap.WaitForProcessToStop(arguments.timeout);
+ if (error.Fail())
+ return llvm::make_error<DAPError>(error.GetCString());
}
- return error;
+
+ return llvm::Error::success();
}
void BaseRequestHandler::PrintWelcomeMessage() const {
diff --git a/lldb/tools/lldb-dap/Handler/RequestHandler.h b/lldb/tools/lldb-dap/Handler/RequestHandler.h
index e13f7a3749e00..6a641c14397d6 100644
--- a/lldb/tools/lldb-dap/Handler/RequestHandler.h
+++ b/lldb/tools/lldb-dap/Handler/RequestHandler.h
@@ -71,7 +71,8 @@ class BaseRequestHandler {
// runInTerminal if applicable. It doesn't do any of the additional
// initialization and bookkeeping stuff that is needed for `request_launch`.
// This way we can reuse the process launching logic for RestartRequest too.
- lldb::SBError LaunchProcess(const llvm::json::Object &request) const;
+ llvm::Error
+ LaunchProcess(const protocol::LaunchRequestArguments &request) const;
// Check if the step-granularity is `instruction`.
bool HasInstructionGranularity(const llvm::json::Object &request) const;
@@ -163,12 +164,21 @@ class RequestHandler : public BaseRequestHandler {
}
dap.Send(response);
+
+ PostRun();
};
virtual Resp Run(const Args &) const = 0;
+ /// A hook for a request handler to run additional operations after the
+ /// request response is sent but before the next request handler.
+ virtual void PostRun() const {};
+
protocol::ErrorResponseBody ToResponse(llvm::Error err) const {
protocol::ErrorMessage error_message;
+ // Default to showing the user errors unless otherwise specified by a
+ // DAPError.
+ error_message.showUser = true;
error_message.sendTelemetry = false;
if (llvm::Error unhandled = llvm::handleErrors(
std::move(err), [&](const DAPError &E) -> llvm::Error {
@@ -178,8 +188,9 @@ class RequestHandler : public BaseRequestHandler {
error_message.url = E.getURL();
error_message.urlLabel = E.getURLLabel();
return llvm::Error::success();
- }))
+ })) {
error_message.format = llvm::toString(std::move(unhandled));
+ }
protocol::ErrorResponseBody body;
body.error = error_message;
return body;
@@ -273,11 +284,15 @@ class InitializeRequestHandler
Run(const protocol::InitializeRequestArguments &args) const override;
};
-class LaunchRequestHandler : public LegacyRequestHandler {
+class LaunchRequestHandler
+ : public RequestHandler<protocol::LaunchRequestArguments,
+ protocol::LaunchResponseBody> {
public:
- using LegacyRequestHandler::LegacyRequestHandler;
+ using RequestHandler::RequestHandler;
static llvm::StringLiteral GetCommand() { return "launch"; }
- void operator()(const llvm::json::Object &request) const override;
+ llvm::Error
+ Run(const protocol::LaunchRequestArguments &arguments) const override;
+ void PostRun() const override;
};
class RestartRequestHandler : public LegacyRequestHandler {
diff --git a/lldb/tools/lldb-dap/Handler/RestartRequestHandler.cpp b/lldb/tools/lldb-dap/Handler/RestartRequestHandler.cpp
index c8f43b7a76e8b..e6f2d9ec669cb 100644
--- a/lldb/tools/lldb-dap/Handler/RestartRequestHandler.cpp
+++ b/lldb/tools/lldb-dap/Handler/RestartRequestHandler.cpp
@@ -9,9 +9,10 @@
#include "DAP.h"
#include "EventHelper.h"
#include "JSONUtils.h"
+#include "Protocol/ProtocolRequests.h"
#include "RequestHandler.h"
-#include "lldb/API/SBListener.h"
-#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/raw_ostream.h"
namespace lldb_dap {
@@ -60,7 +61,7 @@ void RestartRequestHandler::operator()(
const llvm::json::Object &request) const {
llvm::json::Object response;
FillResponse(request, response);
- if (!dap.last_launch_or_attach_request) {
+ if (!dap.target.GetProcess().IsValid()) {
response["success"] = llvm::json::Value(false);
EmplaceSafeString(response, "message",
"Restart request received but no process was launched.");
@@ -77,7 +78,7 @@ void RestartRequestHandler::operator()(
// implementation detail. The adapter *did* launch the process in response to
// a "launch" command, so we can still stop it and re-run it. This is why we
// don't just check `dap.is_attach`.
- if (GetString(*dap.last_launch_or_attach_request, "command") == "attach") {
+ if (!dap.last_launch_request) {
response["success"] = llvm::json::Value(false);
EmplaceSafeString(response, "message",
"Restarting an \"attach\" session is not supported.");
@@ -85,15 +86,30 @@ void RestartRequestHandler::operator()(
return;
}
- // The optional `arguments` field in RestartRequest can contain an updated
- // version of the launch arguments. If there's one, use it.
- const auto *restart_arguments = request.getObject("arguments");
- if (restart_arguments) {
- const auto *launch_request_arguments =
- restart_arguments->getObject("arguments");
- if (launch_request_arguments) {
- (*dap.last_launch_or_attach_request)["arguments"] =
- llvm::json::Value(llvm::json::Object(*launch_request_arguments));
+ const llvm::json::Object *arguments = request.getObject("arguments");
+ if (arguments) {
+ // The optional `arguments` field in RestartRequest can contain an updated
+ // version of the launch arguments. If there's one, use it.
+ if (const llvm::json::Value *restart_arguments =
+ arguments->get("arguments")) {
+ protocol::LaunchRequestArguments updated_arguments;
+ llvm::json::Path::Root root;
+ if (!fromJSON(*restart_arguments, updated_arguments, root)) {
+ response["success"] = llvm::json::Value(false);
+ EmplaceSafeString(
+ response, "message",
+ llvm::formatv("Failed to parse updated launch arguments: {0}",
+ llvm::toString(root.getError()))
+ .str());
+ dap.SendJSON(llvm::json::Value(std::move(response)));
+ return;
+ }
+ dap.last_launch_request = updated_arguments;
+ // Update DAP configuration based on the latest copy of the launch
+ // arguments.
+ dap.SetConfiguration(updated_arguments.configuration, false);
+ dap.stop_at_entry = updated_arguments.stopOnEntry;
+ dap.ConfigureSourceMaps();
}
}
@@ -116,7 +132,15 @@ void RestartRequestHandler::operator()(
dap.thread_ids.clear();
}
dap.debugger.SetAsync(true);
- LaunchProcess(*dap.last_launch_or_attach_request);
+
+ // FIXME: Should we run 'preRunCommands'?
+ // FIXME: Should we add a 'preRestartCommands'?
+ if (llvm::Error err = LaunchProcess(*dap.last_launch_request)) {
+ response["success"] = llvm::json::Value(false);
+ EmplaceSafeString(response, "message", llvm::toString(std::move(err)));
+ dap.SendJSON(llvm::json::Value(std::move(response)));
+ return;
+ }
// This is normally done after receiving a "configuration done" request.
// Because we're restarting, configuration has already happened so we can
@@ -129,4 +153,5 @@ void RestartRequestHandler::operator()(
dap.SendJSON(llvm::json::Value(std::move(response)));
}
+
} // namespace lldb_dap
diff --git a/lldb/tools/lldb-dap/JSONUtils.cpp b/lldb/tools/lldb-dap/JSONUtils.cpp
index 4b8e43cf23960..e4351c0f86cf4 100644
--- a/lldb/tools/lldb-dap/JSONUtils.cpp
+++ b/lldb/tools/lldb-dap/JSONUtils.cpp
@@ -1423,47 +1423,39 @@ llvm::json::Value CreateCompileUnit(lldb::SBCompileUnit &unit) {
/// See
/// https://microsoft.github.io/debug-adapter-protocol/specification#Reverse_Requests_RunInTerminal
-llvm::json::Object
-CreateRunInTerminalReverseRequest(const llvm::json::Object &launch_request,
- llvm::StringRef comm_file,
- lldb::pid_t debugger_pid) {
+llvm::json::Object CreateRunInTerminalReverseRequest(
+ llvm::StringRef program, const std::vector<std::string> &args,
+ const llvm::StringMap<std::string> env, llvm::StringRef cwd,
+ llvm::StringRef comm_file, lldb::pid_t debugger_pid) {
llvm::json::Object run_in_terminal_args;
// This indicates the IDE to open an embedded terminal, instead of opening
// the terminal in a new window.
run_in_terminal_args.try_emplace("kind", "integrated");
- const auto *launch_request_arguments = launch_request.getObject("arguments");
// The program path must be the first entry in the "args" field
- std::vector<std::string> args = {DAP::debug_adapter_path.str(), "--comm-file",
- comm_file.str()};
+ std::vector<std::string> req_args = {DAP::debug_adapter_path.str(),
+ "--comm-file", comm_file.str()};
if (debugger_pid != LLDB_INVALID_PROCESS_ID) {
- args.push_back("--debugger-pid");
- args.push_back(std::to_string(debugger_pid));
+ req_args.push_back("--debugger-pid");
+ req_args.push_back(std::to_string(debugger_pid));
}
- args.push_back("--launch-target");
- args.push_back(
- GetString(launch_request_arguments, "program").value_or("").str());
- std::vector<std::string> target_args =
- GetStrings(launch_request_arguments, "args");
- args.insert(args.end(), target_args.begin(), target_args.end());
+ req_args.push_back("--launch-target");
+ req_args.push_back(program.str());
+ req_args.insert(req_args.end(), args.begin(), args.end());
run_in_terminal_args.try_emplace("args", args);
- const auto cwd = GetString(launch_request_arguments, "cwd").value_or("");
if (!cwd.empty())
run_in_terminal_args.try_emplace("cwd", cwd);
- auto envs = GetEnvironmentFromArguments(*launch_request_arguments);
- llvm::json::Object env_json;
- for (size_t index = 0, env_count = envs.GetNumValues(); index < env_count;
- index++) {
- llvm::StringRef key = envs.GetNameAtIndex(index);
- llvm::StringRef value = envs.GetValueAtIndex(index);
-
- if (!key.empty())
- env_json.try_emplace(key, value);
+ if (!env.empty()) {
+ llvm::json::Object env_json;
+ for (const auto &kv : env) {
+ if (!kv.first().empty())
+ env_json.try_emplace(kv.first(), kv.second);
+ }
+ run_in_terminal_args.try_emplace("env",
+ llvm::json::Value(std::move(env_json)));
}
- run_in_terminal_args.try_emplace("env",
- llvm::json::Value(std::move(env_json)));
return run_in_terminal_args;
}
diff --git a/lldb/tools/lldb-dap/JSONUtils.h b/lldb/tools/lldb-dap/JSONUtils.h
index b8c53353bf42d..3eb445d8c2f40 100644
--- a/lldb/tools/lldb-dap/JSONUtils.h
+++ b/lldb/tools/lldb-dap/JSONUtils.h
@@ -18,6 +18,7 @@
#include "lldb/API/SBType.h"
#include "lldb/API/SBValue.h"
#include "lldb/lldb-types.h"
+#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/JSON.h"
#include <cstdint>
@@ -563,9 +564,17 @@ llvm::json::Value CreateCompileUnit(lldb::SBCompileUnit &unit);
/// Create a runInTerminal reverse request object
///
-/// \param[in] launch_request
-/// The original launch_request object whose fields are used to construct
-/// the reverse request object.
+/// \param[in] program
+/// Path to the program to run in the terminal.
+///
+/// \param[in] args
+/// The arguments for the program.
+///
+/// \param[in] env
+/// The environment variables to set in the terminal.
+///
+/// \param[in] cwd
+/// The working directory for the run in terminal request.
///
/// \param[in] comm_file
/// The fifo file used to communicate the with the target launcher.
@@ -578,10 +587,10 @@ llvm::json::Value CreateCompileUnit(lldb::SBCompileUnit &unit);
/// \return
/// A "runInTerminal" JSON object that follows the specification outlined by
/// Microsoft.
-llvm::json::Object
-CreateRunInTerminalReverseRequest(const llvm::json::Object &launch_request,
- llvm::StringRef comm_file,
- lldb::pid_t debugger_pid);
+llvm::json::Object CreateRunInTerminalReverseRequest(
+ llvm::StringRef program, const std::vector<std::string> &args,
+ const llvm::StringMap<std::string> env, llvm::StringRef cwd,
+ llvm::StringRef comm_file, lldb::pid_t debugger_pid);
/// Create a "Terminated" JSON object that contains statistics
///
diff --git a/lldb/tools/lldb-dap/LLDBUtils.cpp b/lldb/tools/lldb-dap/LLDBUtils.cpp
index f096477cc7b49..eaae433e7b020 100644
--- a/lldb/tools/lldb-dap/LLDBUtils.cpp
+++ b/lldb/tools/lldb-dap/LLDBUtils.cpp
@@ -7,11 +7,19 @@
//===----------------------------------------------------------------------===//
#include "LLDBUtils.h"
-#include "DAP.h"
#include "JSONUtils.h"
+#include "lldb/API/SBCommandInterpreter.h"
+#include "lldb/API/SBCommandReturnObject.h"
+#include "lldb/API/SBDebugger.h"
+#include "lldb/API/SBFrame.h"
#include "lldb/API/SBStringList.h"
-
+#include "lldb/API/SBThread.h"
+#include "lldb/lldb-enumerations.h"
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/Support/JSON.h"
+#include "llvm/Support/raw_ostream.h"
#include <mutex>
+#include <system_error>
namespace lldb_dap {
diff --git a/lldb/tools/lldb-dap/Protocol/ProtocolRequests.cpp b/lldb/tools/lldb-dap/Protocol/ProtocolRequests.cpp
index ee7c653ee9f1b..a49efde390871 100644
--- a/lldb/tools/lldb-dap/Protocol/ProtocolRequests.cpp
+++ b/lldb/tools/lldb-dap/Protocol/ProtocolRequests.cpp
@@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "Protocol/ProtocolRequests.h"
+#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/JSON.h"
@@ -14,6 +15,129 @@
using namespace llvm;
+// The 'env' field is either an object as a map of strings or as an array of
+// strings formatted like 'key=value'.
+static bool parseEnv(const json::Value &Params, StringMap<std::string> &env,
+ json::Path P) {
+ const json::Object *O = Params.getAsObject();
+ if (!O) {
+ P.report("expected object");
+ return false;
+ }
+
+ const json::Value *value = O->get("env");
+ if (!value)
+ return true;
+
+ if (const json::Object *env_obj = value->getAsObject()) {
+ for (const auto &kv : *env_obj) {
+ const std::optional<StringRef> value = kv.second.getAsString();
+ if (!value) {
+ P.field("env").field(kv.first).report("expected string value");
+ return false;
+ }
+ env.insert({kv.first.str(), value->str()});
+ }
+ return true;
+ }
+
+ if (const json::Array *env_arr = value->getAsArray()) {
+ for (size_t i = 0; i < env_arr->size(); ++i) {
+ const std::optional<StringRef> value = (*env_arr)[i].getAsString();
+ if (!value) {
+ P.field("env").index(i).report("expected string");
+ return false;
+ }
+ std::pair<StringRef, StringRef> kv = value->split("=");
+ env.insert({kv.first, kv.second.str()});
+ }
+
+ return true;
+ }
+
+ P.field("env").report("invalid format, expected array or object");
+ return false;
+}
+
+static bool parseTimeout(const json::Value &Params, std::chrono::seconds &S,
+ json::Path P) {
+ const json::Object *O = Params.getAsObject();
+ if (!O) {
+ P.report("expected object");
+ return false;
+ }
+
+ const json::Value *value = O->get("timeout");
+ if (!value)
+ return true;
+ std::optional<double> timeout = value->getAsNumber();
+ if (!timeout) {
+ P.field("timeout").report("expected number");
+ return false;
+ }
+
+ S = std::chrono::duration_cast<std::chrono::seconds>(
+ std::chrono::duration<double>(*value->getAsNumber()));
+ return true;
+}
+
+static bool
+parseSourceMap(const json::Value &Params,
+ std::vector<std::pair<std::string, std::string>> &sourceMap,
+ json::Path P) {
+ const json::Object *O = Params.getAsObject();
+ if (!O) {
+ P.report("expected object");
+ return false;
+ }
+
+ const json::Value *value = O->get("sourceMap");
+ if (!value)
+ return true;
+
+ if (const json::Object *map_obj = value->getAsObject()) {
+ for (const auto &kv : *map_obj) {
+ const std::optional<StringRef> value = kv.second.getAsString();
+ if (!value) {
+ P.field("sourceMap").field(kv.first).report("expected string value");
+ return false;
+ }
+ sourceMap.emplace_back(std::make_pair(kv.first.str(), value->str()));
+ }
+ return true;
+ }
+
+ if (const json::Array *env_arr = value->getAsArray()) {
+ for (size_t i = 0; i < env_arr->size(); ++i) {
+ const json::Array *kv = (*env_arr)[i].getAsArray();
+ if (!kv) {
+ P.field("sourceMap").index(i).report("expected array");
+ return false;
+ }
+ if (kv->size() != 2) {
+ P.field("sourceMap").index(i).report("expected array of pairs");
+ return false;
+ }
+ const std::optional<StringRef> first = (*kv)[0].getAsString();
+ if (!first) {
+ P.field("sourceMap").index(0).report("expected string");
+ return false;
+ }
+ const std::optional<StringRef> second = (*kv)[1].getAsString();
+ if (!second) {
+ P.field("sourceMap").index(1).report("expected string");
+ return false;
+ }
+ sourceMap.emplace_back(std::make_pair(*first, second->str()));
+ }
+
+ return true;
+ }
+
+ P.report("invalid format, expected array or object");
+ return false;
+}
+
namespace lldb_dap::protocol {
bool fromJSON(const llvm::json::Value &Params, CancelArguments &CA,
@@ -31,8 +155,7 @@ bool fromJSON(const json::Value &Params, DisconnectArguments &DA,
O.map("suspendDebuggee", DA.suspendDebuggee);
}
-bool fromJSON(const llvm::json::Value &Params, PathFormat &PF,
- llvm::json::Path P) {
+bool fromJSON(const json::Value &Params, PathFormat &PF, json::Path P) {
auto rawPathFormat = Params.getAsString();
if (!rawPathFormat) {
P.report("expected a string");
@@ -53,7 +176,7 @@ bool fromJSON(const llvm::json::Value &Params, PathFormat &PF,
return true;
}
-static const llvm::StringMap<ClientFeature> ClientFeatureByKey{
+static const StringMap<ClientFeature> ClientFeatureByKey{
{"supportsVariableType", eClientFeatureVariableType},
{"supportsVariablePaging", eClientFeatureVariablePaging},
{"supportsRunInTerminalRequest", eClientFeatureRunInTerminalRequest},
@@ -66,8 +189,8 @@ static const llvm::StringMap<ClientFeature> ClientFeatureByKey{
{"supportsStartDebuggingRequest", eClientFeatureStartDebuggingRequest},
{"supportsANSIStyling", eClientFeatureANSIStyling}};
-bool fromJSON(const llvm::json::Value &Params, InitializeRequestArguments &IRA,
- llvm::json::Path P) {
+bool fromJSON(const json::Value &Params, InitializeRequestArguments &IRA,
+ json::Path P) {
json::ObjectMapper OM(Params, P);
if (!OM)
return false;
@@ -98,6 +221,46 @@ bool fromJSON(const llvm::json::Value &Params, InitializeRequestArguments &IRA,
OM.map("$__lldb_sourceInitFile", IRA.lldbExtSourceInitFile);
}
+bool fromJSON(const json::Value &Params, Configuration &C, json::Path P) {
+ json::ObjectMapper O(Params, P);
+ return O.map("debuggerRoot", C.debuggerRoot) &&
+ O.mapOptional("enableAutoVariableSummaries",
+ C.enableAutoVariableSummaries) &&
+ O.mapOptional("enableSyntheticChildDebugging",
+ C.enableSyntheticChildDebugging) &&
+ O.mapOptional("displayExtendedBacktrace",
+ C.displayExtendedBacktrace) &&
+ O.mapOptional("commandEscapePrefix", C.commandEscapePrefix) &&
+ O.map("customFrameFormat", C.customFrameFormat) &&
+ O.map("customThreadFormat", C.customThreadFormat) &&
+ O.map("sourcePath", C.sourcePath) &&
+ O.mapOptional("initCommands", C.initCommands) &&
+ O.mapOptional("preRunCommands", C.preRunCommands) &&
+ O.mapOptional("postRunCommands", C.postRunCommands) &&
+ O.mapOptional("stopCommands", C.stopCommands) &&
+ O.mapOptional("exitCommands", C.exitCommands) &&
+ O.mapOptional("terminateCommands", C.terminateCommands) &&
+ O.map("program", C.program) && O.map("targetTriple", C.targetTriple) &&
+ O.map("platformName", C.platformName) &&
+ parseSourceMap(Params, C.sourceMap, P);
+}
+
+bool fromJSON(const json::Value &Params, LaunchRequestArguments &LRA,
+ json::Path P) {
+ json::ObjectMapper O(Params, P);
+ return O && fromJSON(Params, LRA.configuration, P) &&
+ O.mapOptional("noDebug", LRA.noDebug) &&
+ O.mapOptional("launchCommands", LRA.launchCommands) &&
+ O.map("cwd", LRA.cwd) && O.mapOptional("args", LRA.args) &&
+ O.mapOptional("detachOnError", LRA.detachOnError) &&
+ O.mapOptional("disableASLR", LRA.disableASLR) &&
+ O.mapOptional("disableSTDIO", LRA.disableSTDIO) &&
+ O.mapOptional("shellExpandArguments", LRA.shellExpandArguments) &&
+ O.mapOptional("stopOnEntry", LRA.stopOnEntry) &&
+ O.mapOptional("runInTerminal", LRA.runInTerminal) &&
+ parseEnv(Params, LRA.env, P) && parseTimeout(Params, LRA.timeout, P);
+}
+
bool fromJSON(const json::Value &Params, SourceArguments &SA, json::Path P) {
json::ObjectMapper O(Params, P);
return O && O.map("source", SA.source) &&
diff --git a/lldb/tools/lldb-dap/Protocol/ProtocolRequests.h b/lldb/tools/lldb-dap/Protocol/ProtocolRequests.h
index 50c16c15cef32..fcb5dbddb2e28 100644
--- a/lldb/tools/lldb-dap/Protocol/ProtocolRequests.h
+++ b/lldb/tools/lldb-dap/Protocol/ProtocolRequests.h
@@ -24,7 +24,9 @@
#include "Protocol/ProtocolTypes.h"
#include "lldb/lldb-defines.h"
#include "llvm/ADT/DenseSet.h"
+#include "llvm/ADT/StringMap.h"
#include "llvm/Support/JSON.h"
+#include <chrono>
#include <cstdint>
#include <optional>
#include <string>
@@ -212,8 +214,86 @@ struct Configuration {
/// LLDB commands executed when the debugging session ends.
std::vector<std::string> terminateCommands;
+
+ /// Path to the executable.
+ ///
+ /// *NOTE:* When launching, either `launchCommands` or `program` must be
+ /// configured. If both are configured then `launchCommands` takes priority.
+ std::optional<std::string> program;
+
+ /// Target triple for the program (arch-vendor-os). If not set, inferred from
+ /// the binary.
+ std::optional<std::string> targetTriple;
+
+ /// Specify name of the platform to use for this target, creating the platform
+ /// if necessary.
+ std::optional<std::string> platformName;
};
+/// lldb-dap specific launch arguments.
+struct LaunchRequestArguments {
+ /// Common lldb-dap configuration values for launching/attaching operations.
+ Configuration configuration;
+
+ /// If true, the launch request should launch the program without enabling
+ /// debugging.
+ bool noDebug = false;
+
+ /// Launch specific operations.
+ /// @{
+
+ /// LLDB commands executed to launch the program.
+ ///
+ /// *NOTE:* Either launchCommands or program must be configured.
+ ///
+ /// If set, takes priority over the 'program' when launching the target.
+ std::vector<std::string> launchCommands;
+
+ /// The program working directory.
+ std::optional<std::string> cwd;
+
+ /// An array of command line argument strings to be passed to the program
+ /// being launched.
+ std::vector<std::string> args;
+
+ /// Environment variables to set when launching the program. The format of
+ /// each environment variable string is "VAR=VALUE" for environment variables
+ /// with values or just "VAR" for environment variables with no values.
+ llvm::StringMap<std::string> env;
+
+ /// If set, then the client stub should detach rather than killing the debugee
+ /// if it loses connection with lldb.
+ bool detachOnError = false;
+
+ /// Disable ASLR (Address Space Layout Randomization) when launching the
+ /// process.
+ bool disableASLR = true;
+
+ /// Do not set up for terminal I/O to go to running process.
+ bool disableSTDIO = false;
+
+ /// Set whether to shell expand arguments to the process when launching.
+ bool shellExpandArguments = false;
+
+ /// Stop at the entry point of the program when launching a process.
+ bool stopOnEntry = false;
+
+ /// Launch the program inside an integrated terminal in the IDE. Useful for
+ /// debugging interactive command line programs.
+ bool runInTerminal = false;
+
+ /// Optional timeout for `runInTerminal` requests.
+ std::chrono::seconds timeout = std::chrono::seconds(30);
+
+ /// @}
+};
+bool fromJSON(const llvm::json::Value &, LaunchRequestArguments &,
+ llvm::json::Path);
+
+/// Response to `launch` request. This is just an acknowledgement, so no body
+/// field is required.
+using LaunchResponseBody = VoidResponse;
+
/// Arguments for `source` request.
struct SourceArguments {
/// Specifies the source content to load. Either `source.path` or
More information about the lldb-commits
mailing list