[lldb-vscode] Implement RestartRequest

[jgorbe]

Summary

This is an optional request, but supporting it makes the experience better when
re-launching a big binary that takes significant time to parse: instead of
tearing down and re-create the whole session we just need to kill the current
process and launch a new one.

Some non-obvious comments that might help review this change:

• After killing the process, we get an "exited" event for it. Because the process no longer exists some interesting things can occur that manifest as flaky failures if not dealt with:
  • EventIsProcessEvent relies on SBEvent::GetBroadcasterClass, which can crash if the broadcaster is no longer there: the event only holds a weak_ptr to its broadcaster, and GetBroadcasterClass uses it without checking.
    
    Other EventIs* functions look at the flavor of the EventData, so I have modified EventIsProcessEvent to do that.
  • We keep the PID of the old process so we can detect its "exited" event and not terminate the whole session. But sometimes the SBProcess we get from the event won't have a PID, for some reason.

• I have factored out the code to launch a process out to a new LaunchProcess function, so it can be used from both request_launch and request_restart.

• The restart_runInTerminal test has the same problem with debug builds as the original runInTerminal test: when attaching to the launcher instance of lldb-vscode it takes a long time to parse its debug info. I have used the same workaround to disable that particular test for debug builds.

[rupprecht]

lldb/tools/lldb-vscode/VSCode.h

146

std::optional<llvm::json::Object>? And then we can raise an error if the client calls restart and this is std::nullopt.

lldb/tools/lldb-vscode/lldb-vscode.cpp

602

Should we also set last_launch_or_attach_request here?

If the user runs:

1. Launch
2. Attach
3. Restart

I would expect that should fail because of the reasons restarting an attach will fail. But if we don't set last_launch_or_attach_request, it will pass, because we set it in (1).

[jgorbe]

Addressed review comments.

• Changed last_launch_or_attach_request to be a std::optional<llvm::json::Object> so we can check if it has been set. Also check for nullopt in request_restart.
• Made request_attach also set last_launch_or_attach_request.

[jgorbe]

lldb/tools/lldb-vscode/VSCode.h

146

Done, thanks!

lldb/tools/lldb-vscode/lldb-vscode.cpp

602

Yup, I missed that one, thanks for catching it! :)

[jgorbe]

Ping.

[labath]

Looks ok-ish, though I don't feel entirely comfortable approving lldb-vscode changes. @wallace, do you have any thoughts on this?

lldb/tools/lldb-vscode/VSCode.h

151

So, it's not possible to restart a process if it has already terminated? I.e., if the debugged process unexpectedly exits, the user will have to restart lldb-vscode from scratch (so he can e.g., set a breakpoint in before the exit).

lldb/tools/lldb-vscode/lldb-vscode.cpp

1982

I have no idea if that's a good idea or not, but I'm wondering if, instead of from the last attach request, we should be taking the arguments from lldb. So that if the user say changes the target.run-args setting, then the new restart request will take that into account...

[wallace]

lldb/source/API/SBProcess.cpp

772–773

+1

lldb/tools/lldb-vscode/lldb-vscode.cpp

1975

Kill actually detaches if lldb originally attached to the debuggee. The actual implementation says

/// Kills the process and shuts down all threads that were spawned to track
/// and monitor the process.
///
/// This function is not meant to be overridden by Process subclasses.
///
/// \param[in] force_kill
///     Whether lldb should force a kill (instead of a detach) from
///     the inferior process.  Normally if lldb launched a binary and
///     Destory is called, lldb kills it.  If lldb attached to a
///     running process and Destory is called, lldb detaches.  If
///     this behavior needs to be over-ridden, this is the bool that
///     can be used.
///
/// \return
///     Returns an error object.
Status Destroy(bool force_kill);

You could have the restart command reattach to the process instead of failing if the user originally attached.

What do you think of this?

[jgorbe]

lldb/tools/lldb-vscode/VSCode.h

151

I don't know if it's possible (as in, if the protocol allows it), but it's what lldb-vscode does.

It also matches the behavior I remember when I used Visual Studio back in the day: when the debugged process exits, the debugging session ends and the UI switches back to "editing" mode automatically. If you need to re-run, you hit F5 and run it again. It's usually not a big deal because the IDE keeps the list of breakpoints and will transparently start lldb-vscode and set everything up again when you click "Run". It's also what VS Code does when a debug adapter doesn't support the RestartRequest, it just kills the adapter and restarts everything transparently (which is how restart works on lldb-vscode so far).

lldb/tools/lldb-vscode/lldb-vscode.cpp

1975

I think it's something you *could* do, but it's not restarting. As I mention in a code comment above, I don't think "restart" is even well defined in the attach case.

As a user I would be really confused if I clicked on restart and the debugger deattached from the process, then immediately reattached, but nothing restarted. I can't think of a case where this would be useful.

Looking for some references, I started Visual Studio (not Code) and it simply grays out the "restart" button when attaching. Visual Studio Code, however, allows you to restart. I found this issue where someone asked for clarification on the meaning of Restart in the protocol and got this explanation:

"restart sequence" means:
terminate current debug session via the disconnect request and immediately start a new session via the launch or attach request

For the "launch" case "restart" can be used to pickup source changes that are not automatically picked up while the program is running.

For the "attach" case "restart" has no direct effect on the debug target because the debug target continues running. But it still might have an effect on debugging because the debug adapter is restarted and this could pick up changes to files that the debug adapter uses, e.g. source maps.

But I'm not very convinced by this because we're implementing RestartRequest, which means precisely that the adapter won't be restarted.

1982

I think the intended way to allow the user to modify the configuration is to use the optional arguments field in RestartRequest, which the client can use to send the latest version of the config.

https://microsoft.github.io/debug-adapter-protocol/specification#Requests_Restart

interface RestartRequest extends Request {
  command: 'restart';

  arguments?: RestartArguments;
}

Arguments for restart request.

interface RestartArguments {
  /**
   * The latest version of the `launch` or `attach` configuration.
   */
  arguments?: LaunchRequestArguments | AttachRequestArguments;
}

We can check if the restart request has arguments and only used the saved config if that's not the case. What do you think?

@wallace any opinions here? Is this kind of lldb state manipulation via console commands something that is expected to work correctly in lldb-vscode?

[wallace]

lgtm!

lldb/tools/lldb-vscode/lldb-vscode.cpp

1982

i think it's better to reuse the same arguments that the user passed using the vscode interface. Modifying them in the command line might seems counterintuitive.

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

def request_continue(self, threadId=None):
             'command': 'continue',
             'type': 'request',
             'arguments': args_dict
         }
         response = self.send_recv(command_dict)
         # Caller must still call wait_for_stopped.
         return response
 
+    def request_restart(self):
+        command_dict = {
+            'command': 'restart',
+            'type': 'request',
+        }
+        response = self.send_recv(command_dict)
+        # Caller must still call wait_for_stopped.
+        return response
+
     def request_disconnect(self, terminateDebuggee=None):
         args_dict = {}
         if terminateDebuggee is not None:
             if terminateDebuggee:
                 args_dict['terminateDebuggee'] = True
             else:
                 args_dict['terminateDebuggee'] = False
         command_dict = {

lldb/source/API/SBProcess.cpp

SBProcess::GetStructuredDataFromEvent(const lldb::SBEvent &event) {
   LLDB_INSTRUMENT_VA(event);
 
   return SBStructuredData(event.GetSP());
 }
 
 bool SBProcess::EventIsProcessEvent(const SBEvent &event) {
   LLDB_INSTRUMENT_VA(event);
 
-  return (event.GetBroadcasterClass() == SBProcess::GetBroadcasterClass()) &&
-         !EventIsStructuredDataEvent(event);
+  return Process::ProcessEventData::GetEventDataFromEvent(event.get()) !=
+         nullptr;
 }
 
 bool SBProcess::EventIsStructuredDataEvent(const lldb::SBEvent &event) {
   LLDB_INSTRUMENT_VA(event);
 
   EventSP event_sp = event.GetSP();
   EventData *event_data = event_sp ? event_sp->GetData() : nullptr;
   return event_data && (event_data->GetFlavor() ==

lldb/test/API/tools/lldb-vscode/restart/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/tools/lldb-vscode/restart/TestVSCode_restart.py

+"""
+Test lldb-vscode RestartRequest.
+"""
+
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import line_number
+import lldbvscode_testcase
+
+
+class TestVSCode_restart(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_basic_functionality(self):
+        '''
+            Tests the basic restarting functionality: set two breakpoints in
+            sequence, restart at the second, check that we hit the first one.
+        '''
+        line_A = line_number('main.c', '// breakpoint A')
+        line_B = line_number('main.c', '// breakpoint B')
+
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+        [bp_A, bp_B] = self.set_source_breakpoints('main.c', [line_A, line_B])
+
+        # Verify we hit A, then B.
+        self.vscode.request_configurationDone()
+        self.verify_breakpoint_hit([bp_A])
+        self.vscode.request_continue()
+        self.verify_breakpoint_hit([bp_B])
+
+        # Make sure i has been modified from its initial value of 0.
+        self.assertEquals(int(self.vscode.get_local_variable_value('i')),
+                          1234, 'i != 1234 after hitting breakpoint B')
+
+        # Restart then check we stop back at A and program state has been reset.
+        self.vscode.request_restart()
+        self.verify_breakpoint_hit([bp_A])
+        self.assertEquals(int(self.vscode.get_local_variable_value('i')),
+                          0, 'i != 0 after hitting breakpoint A on restart')
+
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_stopOnEntry(self):
+        '''
+            Check that the stopOnEntry setting is still honored after a restart.
+        '''
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program, stopOnEntry=True)
+        [bp_main] = self.set_function_breakpoints(['main'])
+        self.vscode.request_configurationDone()
+
+        # Once the "configuration done" event is sent, we should get a stopped
+        # event immediately because of stopOnEntry.
+        stopped_events = self.vscode.wait_for_stopped()
+        for stopped_event in stopped_events:
+            if 'body' in stopped_event:
+                body = stopped_event['body']
+                if 'reason' in body:
+                    reason = body['reason']
+                    self.assertNotEqual(
+                        reason, 'breakpoint',
+                        'verify stop isn\'t "main" breakpoint')
+
+        # Then, if we continue, we should hit the breakpoint at main.
+        self.vscode.request_continue()
+        self.verify_breakpoint_hit([bp_main])
+
+        # Restart and check that we still get a stopped event before reaching
+        # main.
+        self.vscode.request_restart()
+        stopped_events = self.vscode.wait_for_stopped()
+        for stopped_event in stopped_events:
+            if 'body' in stopped_event:
+                body = stopped_event['body']
+                if 'reason' in body:
+                    reason = body['reason']
+                    self.assertNotEqual(
+                        reason, 'breakpoint',
+                        'verify stop after restart isn\'t "main" breakpoint')
+

lldb/test/API/tools/lldb-vscode/restart/TestVSCode_restart_runInTerminal.py

+"""
+Test lldb-vscode RestartRequest.
+"""
+
+import os
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import line_number
+import lldbvscode_testcase
+
+
+class TestVSCode_restart_runInTerminal(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    def isTestSupported(self):
+        try:
+            # We skip this test for debug builds because it takes too long
+            # parsing lldb's own debug info. Release builds are fine.
+            # Checking the size of the lldb-vscode binary seems to be a decent
+            # proxy for a quick detection. It should be far less than 1 MB in
+            # Release builds.
+            return os.path.getsize(os.environ["LLDBVSCODE_EXEC"]) < 1000000
+        except:
+            return False
+
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_basic_functionality(self):
+        '''
+            Test basic restarting functionality when the process is running in
+            a terminal.
+        '''
+        if not self.isTestSupported():
+            return
+        line_A = line_number('main.c', '// breakpoint A')
+        line_B = line_number('main.c', '// breakpoint B')
+
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program, runInTerminal=True)
+        [bp_A, bp_B] = self.set_source_breakpoints('main.c', [line_A, line_B])
+
+        # Verify we hit A, then B.
+        self.vscode.request_configurationDone()
+        self.verify_breakpoint_hit([bp_A])
+        self.vscode.request_continue()
+        self.verify_breakpoint_hit([bp_B])
+
+        # Make sure i has been modified from its initial value of 0.
+        self.assertEquals(int(self.vscode.get_local_variable_value('i')),
+                          1234, 'i != 1234 after hitting breakpoint B')
+
+        # Restart.
+        self.vscode.request_restart()
+
+        # Finally, check we stop back at A and program state has been reset.
+        self.verify_breakpoint_hit([bp_A])
+        self.assertEquals(int(self.vscode.get_local_variable_value('i')),
+                          0, 'i != 0 after hitting breakpoint A on restart')
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_stopOnEntry(self):
+        '''
+            Check that stopOnEntry works correctly when using runInTerminal.
+        '''
+        if not self.isTestSupported():
+            return
+        line_A = line_number('main.c', '// breakpoint A')
+        line_B = line_number('main.c', '// breakpoint B')
+
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program, runInTerminal=True, stopOnEntry=True)
+        [bp_main] = self.set_function_breakpoints(['main'])
+        self.vscode.request_configurationDone()
+
+        # When using stopOnEntry, configurationDone doesn't result in a running
+        # process, we should immediately get a stopped event instead.
+        stopped_events = self.vscode.wait_for_stopped()
+        # We should be stopped at the entry point.
+        for stopped_event in stopped_events:
+            if 'body' in stopped_event:
+                body = stopped_event['body']
+                if 'reason' in body:
+                    reason = body['reason']
+                    self.assertNotEqual(
+                        reason, 'breakpoint',
+                        'verify stop isn\'t a breakpoint')
+
+        # Then, if we continue, we should hit the breakpoint at main.
+        self.vscode.request_continue()
+        self.verify_breakpoint_hit([bp_main])
+
+        # Restart and check that we still get a stopped event before reaching
+        # main.
+        self.vscode.request_restart()
+        stopped_events = self.vscode.wait_for_stopped()
+        for stopped_event in stopped_events:
+            if 'body' in stopped_event:
+                body = stopped_event['body']
+                if 'reason' in body:
+                    reason = body['reason']
+                    self.assertNotEqual(
+                        reason, 'breakpoint',
+                        'verify stop after restart isn\'t "main" breakpoint')
+

lldb/test/API/tools/lldb-vscode/restart/main.c

+#include <stdio.h>
+
+int main(int argc, char const *argv[], char const *envp[]) {
+  int i = 0;
+  printf("Do something\n"); // breakpoint A
+  printf("Do something else\n");
+  i = 1234;
+  return 0;  // breakpoint B
+}

lldb/tools/lldb-vscode/VSCode.h

struct VSCode {
   llvm::StringMap<SourceBreakpointMap> source_breakpoints;
   FunctionBreakpointMap function_breakpoints;
   std::vector<ExceptionBreakpoint> exception_breakpoints;
   std::vector<std::string> init_commands;
   std::vector<std::string> pre_run_commands;
   std::vector<std::string> exit_commands;
   std::vector<std::string> stop_commands;
   std::vector<std::string> terminate_commands;
+  // A copy of the last LaunchRequest or AttachRequest so we can reuse its
+  // arguments if we get a RestartRequest.
+  llvm::json::Object last_launch_or_attach_request;
   lldb::tid_t focus_tid;
   bool sent_terminated_event;
   bool stop_at_entry;
   bool is_attach;
+  // The process event thread normally responds to process exited events by
+  // shutting down the entire adapter. When we're restarting, we keep the id of
+  // the old process here so we can detect this case and keep running.
+  lldb::pid_t restarting_process_id;
   bool configuration_done_sent;
   uint32_t reverse_request_seq;
   std::map<std::string, RequestCallback> request_handlers;
   bool waiting_for_run_in_terminal;
   ProgressEventReporter progress_event_reporter;
   // Keep track of the last stop thread index IDs as threads won't go away
   // unless we send a "thread" event to indicate the thread exited.
   llvm::DenseSet<lldb::tid_t> thread_ids;

lldb/tools/lldb-vscode/VSCode.cpp

: broadcaster("lldb-vscode"),
       exception_breakpoints(
           {{"cpp_catch", "C++ Catch", lldb::eLanguageTypeC_plus_plus},
            {"cpp_throw", "C++ Throw", lldb::eLanguageTypeC_plus_plus},
            {"objc_catch", "Objective-C Catch", lldb::eLanguageTypeObjC},
            {"objc_throw", "Objective-C Throw", lldb::eLanguageTypeObjC},
            {"swift_catch", "Swift Catch", lldb::eLanguageTypeSwift},
            {"swift_throw", "Swift Throw", lldb::eLanguageTypeSwift}}),
       focus_tid(LLDB_INVALID_THREAD_ID), sent_terminated_event(false),
-      stop_at_entry(false), is_attach(false), configuration_done_sent(false),
-      reverse_request_seq(0), waiting_for_run_in_terminal(false),
+      stop_at_entry(false), is_attach(false),
+      restarting_process_id(LLDB_INVALID_PROCESS_ID),
+      configuration_done_sent(false), reverse_request_seq(0),
+      waiting_for_run_in_terminal(false),
       progress_event_reporter(
           [&](const ProgressEvent &event) { SendJSON(event.ToJSON()); }) {
   const char *log_file_path = getenv("LLDBVSCODE_LOG");
 #if defined(_WIN32)
   // Windows opens stdout and stdin in text mode which converts \n to 13,10
   // while the value is just 10 on Darwin/Linux. Setting the file mode to binary
   // fixes this.
   int result = _setmode(fileno(stdout), _O_BINARY);

lldb/tools/lldb-vscode/lldb-vscode.cpp

if (listener.WaitForEvent(1, event)) {
           case lldb::eStateStopped:
             // We launch and attach in synchronous mode then the first stop
             // event will not be delivered. If we use "launchCommands" during a
             // launch or "attachCommands" during an attach we might some process
             // stop events which we do not want to send an event for. We will
             // manually send a stopped event in request_configurationDone(...)
             // so don't send any before then.
             if (g_vsc.configuration_done_sent) {
-              // Only report a stopped event if the process was not restarted.
+              // Only report a stopped event if the process was not
+              // automatically restarted.
               if (!lldb::SBProcess::GetRestartedFromEvent(event)) {
                 SendStdOutStdErr(process);
                 SendThreadStoppedEvent();
               }
             }
             break;
           case lldb::eStateRunning:
             g_vsc.WillContinue();
             break;
-          case lldb::eStateExited: {
+          case lldb::eStateExited:
+            // When restarting, we can get an "exited" event for the process we
+            // just killed with the old PID, or even with no PID. In that case
+            // we don't have to terminate the session.
+            if (process.GetProcessID() == LLDB_INVALID_PROCESS_ID ||
+                process.GetProcessID() == g_vsc.restarting_process_id) {
+              g_vsc.restarting_process_id = LLDB_INVALID_PROCESS_ID;
+            } else {
               // Run any exit LLDB commands the user specified in the
               // launch.json
               g_vsc.RunExitCommands();
               SendProcessExitedEvent(process);
               SendTerminatedEvent();
               done = true;
-          } break;
+            }
+            break;
           }
         } else if ((event_mask & lldb::SBProcess::eBroadcastBitSTDOUT) ||
                    (event_mask & lldb::SBProcess::eBroadcastBitSTDERR)) {
           SendStdOutStdErr(process);
         }
       } else if (lldb::SBBreakpoint::EventIsBreakpointEvent(event)) {
         if (event_mask & lldb::SBTarget::eBroadcastBitBreakpointChanged) {
           auto event_type =

 // },
 // "AttachResponse": {
 //   "allOf": [ { "$ref": "#/definitions/Response" }, {
 //     "type": "object",
 //     "description": "Response to 'attach' request. This is just an
 //     acknowledgement, so no body field is required."
 //   }]
 // }
 void request_attach(const llvm::json::Object &request) {
   g_vsc.is_attach = true;
   llvm::json::Object response;
   lldb::SBError error;
   FillResponse(request, response);
   lldb::SBAttachInfo attach_info;
   auto arguments = request.getObject("arguments");
   const lldb::pid_t pid =
       GetUnsigned(arguments, "pid", LLDB_INVALID_PROCESS_ID);
void request_initialize(const llvm::json::Object &request) {
   body.try_emplace("supportsModulesRequest", true);
   // The set of additional module information exposed by the debug adapter.
   //   body.try_emplace("additionalModuleColumns"] = ColumnDescriptor
   // Checksum algorithms supported by the debug adapter.
   //   body.try_emplace("supportedChecksumAlgorithms"] = ChecksumAlgorithm
   // The debug adapter supports the RestartRequest. In this case a client
   // should not implement 'restart' by terminating and relaunching the adapter
   // but by calling the RestartRequest.
-  body.try_emplace("supportsRestartRequest", false);
+  body.try_emplace("supportsRestartRequest", true);
   // The debug adapter supports 'exceptionOptions' on the
   // setExceptionBreakpoints request.
   body.try_emplace("supportsExceptionOptions", true);
   // The debug adapter supports a 'format' attribute on the stackTraceRequest,
   // variablesRequest, and evaluateRequest.
   body.try_emplace("supportsValueFormattingOptions", true);
   // The debug adapter supports the exceptionInfo request.
   body.try_emplace("supportsExceptionInfoRequest", true);
#endif
   did_attach_message_success.wait();
   error = did_attach_message_success.get();
   if (error.Success())
     return llvm::Error::success();
   return llvm::createStringError(llvm::inconvertibleErrorCode(),
                                  error.GetCString());
 }
 
+// Takes a LaunchRequest object and launches the process, also handling
+// 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) {
+  lldb::SBError error;
+  auto arguments = request.getObject("arguments");
+  auto launchCommands = GetStrings(arguments, "launchCommands");
+
+  // Instantiate a launch info instance for the target.
+  auto launch_info = g_vsc.target.GetLaunchInfo();
+
+  // Grab the current working directory if there is one and set it in the
+  // launch info.
+  const auto cwd = GetString(arguments, "cwd");
+  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);
+
+  // Pass any environment variables along that the user specified.
+  auto envs = GetStrings(arguments, "env");
+  if (!envs.empty())
+    launch_info.SetEnvironmentEntries(MakeArgv(envs).data(), true);
+
+  auto flags = launch_info.GetLaunchFlags();
+
+  if (GetBoolean(arguments, "disableASLR", true))
+    flags |= lldb::eLaunchFlagDisableASLR;
+  if (GetBoolean(arguments, "disableSTDIO", false))
+    flags |= lldb::eLaunchFlagDisableSTDIO;
+  if (GetBoolean(arguments, "shellExpandArguments", false))
+    flags |= lldb::eLaunchFlagShellExpandArguments;
+  const bool detachOnError = GetBoolean(arguments, "detachOnError", false);
+  launch_info.SetDetachOnError(detachOnError);
+  launch_info.SetLaunchFlags(flags | lldb::eLaunchFlagDebug |
+                             lldb::eLaunchFlagStopAtEntry);
+  const uint64_t timeout_seconds = GetUnsigned(arguments, "timeout", 30);
+
+  if (GetBoolean(arguments, "runInTerminal", false)) {
+    if (llvm::Error err = request_runInTerminal(request))
+      error.SetErrorString(llvm::toString(std::move(err)).c_str());
+  } else if (launchCommands.empty()) {
+    // Disable async events so the launch will be successful when we return from
+    // the launch call and the launch will happen synchronously
+    g_vsc.debugger.SetAsync(false);
+    g_vsc.target.Launch(launch_info, error);
+    g_vsc.debugger.SetAsync(true);
+  } else {
+    g_vsc.RunLLDBCommands("Running launchCommands:", launchCommands);
+    // The custom commands might have created a new target so we should use the
+    // selected target after these commands are run.
+    g_vsc.target = g_vsc.debugger.GetSelectedTarget();
+    // Make sure the process is launched and stopped at the entry point before
+    // proceeding as the the launch commands are not run using the synchronous
+    // mode.
+    error = g_vsc.WaitForProcessToStop(timeout_seconds);
+  }
+  return error;
+}
+
 // "LaunchRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Launch request; value of command field is 'launch'.",
 //     "properties": {
 //       "command": {
 //         "type": "string",
 //         "enum": [ "launch" ]

 //   "allOf": [ { "$ref": "#/definitions/Response" }, {
 //     "type": "object",
 //     "description": "Response to 'launch' request. This is just an
 //                     acknowledgement, so no body field is required."
 //   }]
 // }
 void request_launch(const llvm::json::Object &request) {
   g_vsc.is_attach = false;
+  g_vsc.last_launch_or_attach_request = request;
   llvm::json::Object response;
-  lldb::SBError error;
   FillResponse(request, response);
   auto arguments = request.getObject("arguments");
   g_vsc.init_commands = GetStrings(arguments, "initCommands");
   g_vsc.pre_run_commands = GetStrings(arguments, "preRunCommands");
   g_vsc.stop_commands = GetStrings(arguments, "stopCommands");
   g_vsc.exit_commands = GetStrings(arguments, "exitCommands");
   g_vsc.terminate_commands = GetStrings(arguments, "terminateCommands");
-  auto launchCommands = GetStrings(arguments, "launchCommands");
   std::vector<std::string> postRunCommands =
       GetStrings(arguments, "postRunCommands");
   g_vsc.stop_at_entry = GetBoolean(arguments, "stopOnEntry", false);
   const llvm::StringRef debuggerRoot = GetString(arguments, "debuggerRoot");
-  const uint64_t timeout_seconds = GetUnsigned(arguments, "timeout", 30);
 
   // This is a hack for loading DWARF in .o files on Mac where the .o files
   // in the debug map of the main executable have relative paths which require
   // the lldb-vscode 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);
 
   // 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.
   g_vsc.RunInitCommands();
 
   SetSourceMapFromArguments(*arguments);
 
   lldb::SBError status;
   g_vsc.SetTarget(g_vsc.CreateTargetFromArguments(*arguments, status));
   if (status.Fail()) {
     response["success"] = llvm::json::Value(false);
     EmplaceSafeString(response, "message", status.GetCString());
     g_vsc.SendJSON(llvm::json::Value(std::move(response)));
     return;
   }
 
-  // Instantiate a launch info instance for the target.
-  auto launch_info = g_vsc.target.GetLaunchInfo();
-
-  // Grab the current working directory if there is one and set it in the
-  // launch info.
-  const auto cwd = GetString(arguments, "cwd");
-  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);
-
-  // Pass any environment variables along that the user specified.
-  auto envs = GetStrings(arguments, "env");
-  if (!envs.empty())
-    launch_info.SetEnvironmentEntries(MakeArgv(envs).data(), true);
-
-  auto flags = launch_info.GetLaunchFlags();
-
-  if (GetBoolean(arguments, "disableASLR", true))
-    flags |= lldb::eLaunchFlagDisableASLR;
-  if (GetBoolean(arguments, "disableSTDIO", false))
-    flags |= lldb::eLaunchFlagDisableSTDIO;
-  if (GetBoolean(arguments, "shellExpandArguments", false))
-    flags |= lldb::eLaunchFlagShellExpandArguments;
-  const bool detatchOnError = GetBoolean(arguments, "detachOnError", false);
-  launch_info.SetDetachOnError(detatchOnError);
-  launch_info.SetLaunchFlags(flags | lldb::eLaunchFlagDebug |
-                             lldb::eLaunchFlagStopAtEntry);
-
   // Run any pre run LLDB commands the user specified in the launch.json
   g_vsc.RunPreRunCommands();
 
-  if (GetBoolean(arguments, "runInTerminal", false)) {
-    if (llvm::Error err = request_runInTerminal(request))
-      error.SetErrorString(llvm::toString(std::move(err)).c_str());
-  } else if (launchCommands.empty()) {
-    // Disable async events so the launch will be successful when we return from
-    // the launch call and the launch will happen synchronously
-    g_vsc.debugger.SetAsync(false);
-    g_vsc.target.Launch(launch_info, error);
-    g_vsc.debugger.SetAsync(true);
-  } else {
-    g_vsc.RunLLDBCommands("Running launchCommands:", launchCommands);
-    // The custom commands might have created a new target so we should use the
-    // selected target after these commands are run.
-    g_vsc.target = g_vsc.debugger.GetSelectedTarget();
-    // Make sure the process is launched and stopped at the entry point before
-    // proceeding as the the launch commands are not run using the synchronous
-    // mode.
-    error = g_vsc.WaitForProcessToStop(timeout_seconds);
-  }
+  status = LaunchProcess(request);
 
-  if (error.Fail()) {
+  if (status.Fail()) {
     response["success"] = llvm::json::Value(false);
-    EmplaceSafeString(response, "message", std::string(error.GetCString()));
+    EmplaceSafeString(response, "message", std::string(status.GetCString()));
   } else {
     g_vsc.RunLLDBCommands("Running postRunCommands:", postRunCommands);
   }
 
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 
+  if (!status.Fail()) {
     if (g_vsc.is_attach)
-    SendProcessEvent(Attach); // this happens when doing runInTerminal
+      SendProcessEvent(Attach);  // this happens when doing runInTerminal
     else
       SendProcessEvent(Launch);
-  g_vsc.SendJSON(llvm::json::Value(CreateEventObject("initialized")));
+  }
+  g_vsc.SendJSON(CreateEventObject("initialized"));
 }
 
 // "NextRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Next request; value of command field is 'next'. The
 //                     request starts the debuggee to run again for one step.
 //                     The debug adapter first sends the NextResponse and then

 void request_pause(const llvm::json::Object &request) {
   llvm::json::Object response;
   FillResponse(request, response);
   lldb::SBProcess process = g_vsc.target.GetProcess();
   lldb::SBError error = process.Stop();
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
+
+// "RestartRequest": {
+//   "allOf": [ { "$ref": "#/definitions/Request" }, {
+//     "type": "object",
+//     "description": "Restarts a debug session. Clients should only call this
+//     request if the corresponding capability `supportsRestartRequest` is
+//     true.\nIf the capability is missing or has the value false, a typical
+//     client emulates `restart` by terminating the debug adapter first and then
+//     launching it anew.",
+//     "properties": {
+//       "command": {
+//         "type": "string",
+//         "enum": [ "restart" ]
+//       },
+//       "arguments": {
+//         "$ref": "#/definitions/RestartArguments"
+//       }
+//     },
+//     "required": [ "command" ]
+//   }]
+// },
+// "RestartArguments": {
+//   "type": "object",
+//   "description": "Arguments for `restart` request.",
+//   "properties": {
+//     "arguments": {
+//       "oneOf": [
+//         { "$ref": "#/definitions/LaunchRequestArguments" },
+//         { "$ref": "#/definitions/AttachRequestArguments" }
+//       ],
+//       "description": "The latest version of the `launch` or `attach`
+//       configuration."
+//     }
+//   }
+// },
+// "RestartResponse": {
+//   "allOf": [ { "$ref": "#/definitions/Response" }, {
+//     "type": "object",
+//     "description": "Response to `restart` request. This is just an
+//     acknowledgement, so no body field is required."
+//   }]
+// },
+void request_restart(const llvm::json::Object &request) {
+  llvm::json::Object response;
+  FillResponse(request, response);
+  // Check if we were in a "launch" session or an "attach" session.
+  //
+  // Restarting is not well defined when we started the session by attaching to
+  // an existing process, because we don't know how the process was started, so
+  // we don't support it.
+  //
+  // Note that when using runInTerminal we're technically attached, but it's an
+  // 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 `g_vsc.is_attach`.
+  if (GetString(g_vsc.last_launch_or_attach_request, "command") == "attach") {
+    response["success"] = llvm::json::Value(false);
+    EmplaceSafeString(response, "message",
+                      "Restarting an \"attach\" session is not supported.");
+    g_vsc.SendJSON(llvm::json::Value(std::move(response)));
+    return;
+  }
+
+  // Keep track of the old PID so when we get a "process exited" event from the
+  // killed process we can detect it and not shut down the whole session.
+  lldb::SBProcess process = g_vsc.target.GetProcess();
+  g_vsc.restarting_process_id = process.GetProcessID();
+
+  // Stop the current process if necessary. The logic here is similar to
+  // CommandObjectProcessLaunchOrAttach::StopProcessIfNecessary, except that
+  // we don't ask the user for confirmation.
+  g_vsc.debugger.SetAsync(false);
+  if (process.IsValid()) {
+    lldb::StateType state = process.GetState();
+    if (state != lldb::eStateConnected) {
+      process.Kill();
+    }
+    // Clear the list of thread ids to avoid sending "thread exited" events
+    // for threads of the process we are terminating.
+    g_vsc.thread_ids.clear();
+  }
+  g_vsc.debugger.SetAsync(true);
+  LaunchProcess(g_vsc.last_launch_or_attach_request);
+
+  // This is normally done after receiving a "configuration done" request.
+  // Because we're restarting, configuration has already happened so we can
+  // continue the process right away.
+  if (g_vsc.stop_at_entry) {
+    SendThreadStoppedEvent();
+  } else {
+    g_vsc.target.GetProcess().Continue();
+  }
+
+  g_vsc.SendJSON(llvm::json::Value(std::move(response)));
+}
+
 // "ScopesRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Scopes request; value of command field is 'scopes'. The
 //     request returns the variable scopes for a given stackframe ID.",
 //     "properties": {
 //       "command": {
 //         "type": "string",
void RegisterRequestCallbacks() {
   g_vsc.RegisterRequestCallback("configurationDone", request_configurationDone);
   g_vsc.RegisterRequestCallback("disconnect", request_disconnect);
   g_vsc.RegisterRequestCallback("evaluate", request_evaluate);
   g_vsc.RegisterRequestCallback("exceptionInfo", request_exceptionInfo);
   g_vsc.RegisterRequestCallback("initialize", request_initialize);
   g_vsc.RegisterRequestCallback("launch", request_launch);
   g_vsc.RegisterRequestCallback("next", request_next);
   g_vsc.RegisterRequestCallback("pause", request_pause);
+  g_vsc.RegisterRequestCallback("restart", request_restart);
   g_vsc.RegisterRequestCallback("scopes", request_scopes);
   g_vsc.RegisterRequestCallback("setBreakpoints", request_setBreakpoints);
   g_vsc.RegisterRequestCallback("setExceptionBreakpoints",
                                 request_setExceptionBreakpoints);
   g_vsc.RegisterRequestCallback("setFunctionBreakpoints",
                                 request_setFunctionBreakpoints);
   g_vsc.RegisterRequestCallback("setVariable", request_setVariable);
   g_vsc.RegisterRequestCallback("source", request_source);