Redo of Add terminateCommands to lldb-vscode protocol

[wallace]

Summary

This redoes https://reviews.llvm.org/D79726 and fixes two things.

• The logic that determines whether to automatically disconnect during the tear down is not very dumb compared to the original implementation. Each test will determine whether to do that or not.
• The terminate commands and terminate event were being sent after the disconnect response was sent to the IDE. That was not good, as VSCode stops the debug session as soon as it receives a disconnect response. Now, the terminate event and terminateEvents are being executed before the disconnect response is sent. This ensures that any connection between the IDE and lldb-vscode is alive while the terminate commands are executed. Besides, it also allows displaying the output of the terminate commands on the debug console, as it's still alive.

[aadsm]

Thank you for this! <3

[clayborg]

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

223–224

revert whitespace only change?

[wallace]

remove unwanted changes

[wallace]

.

[fhahn]

I noticed that it appears that lldb-api :: tools/lldb-vscode/attach/TestVSCode_attach.py is flaky and I noticed it failing spuriously relatively frequently

For example http://lab.llvm.org:8011/builders/lldb-aarch64-ubuntu/builds/5519 failed with

FAIL: lldb-api :: tools/lldb-vscode/attach/TestVSCode_attach.py (825 of 2068)
******************** TEST 'lldb-api :: tools/lldb-vscode/attach/TestVSCode_attach.py' FAILED ********************
Script:
--
/usr/bin/python3.6 /home/tcwg-buildslave/worker/lldb-cmake-aarch64/llvm-project/lldb/test/API/dotest.py --arch aarch64 -s /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/lldb-test-traces -S nm -u CXXFLAGS -u CFLAGS --env ARCHIVER=/usr/bin/ar --env OBJCOPY=/usr/bin/objcopy --env LLVM_LIBS_DIR=/home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/./lib --build-dir /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/lldb-test-build.noindex --lldb-module-cache-dir /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/lldb-test-build.noindex/module-cache-lldb/lldb-api --clang-module-cache-dir /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/lldb-test-build.noindex/module-cache-clang/lldb-api --executable /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/./bin/lldb --compiler /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/./bin/clang --dsymutil /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/./bin/dsymutil --filecheck /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/./bin/FileCheck --lldb-libs-dir /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/./lib /home/tcwg-buildslave/worker/lldb-cmake-aarch64/llvm-project/lldb/test/API/tools/lldb-vscode/attach -p TestVSCode_attach.py
--
Exit Code: 1

Command Output (stdout):
--
lldb version 11.0.0
  clang revision 72131423cc952ccbd6d8e021ff7c04fa22297fe3
  llvm revision 72131423cc952ccbd6d8e021ff7c04fa22297fe3
LLDB library dir: /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/bin
LLDB import library dir: /home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/./lib
Libc++ tests will not be run because: Compiling with -stdlib=libc++ fails with the error: <stdin>:1:10: fatal error: 'algorithm' file not found
#include <algorithm>
         ^~~~~~~~~~~
1 error generated.

Skipping following debug info categories: ['dsym', 'gmodules']
description: breakpoint 1.1
description: breakpoint 1.1

--
Command Output (stderr):
--

Session logs for test failures/errors/unexpected successes will go into directory '/home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/lldb-test-traces'
PASS: LLDB (/home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/bin/clang-11-aarch64) :: test_by_name (TestVSCode_attach.TestVSCode_attach)
UNSUPPORTED: LLDB (/home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/bin/clang-11-aarch64) :: test_by_name_waitFor (TestVSCode_attach.TestVSCode_attach) (requires one of darwin, macosx, ios, watchos, tvos, bridgeos) 
PASS: LLDB (/home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/bin/clang-11-aarch64) :: test_by_pid (TestVSCode_attach.TestVSCode_attach)
FAIL: LLDB (/home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/bin/clang-11-aarch64) :: test_commands (TestVSCode_attach.TestVSCode_attach)
CLEANUP ERROR: LLDB (/home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/bin/clang-11-aarch64) :: test_commands (TestVSCode_attach.TestVSCode_attach)
PASS: LLDB (/home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/bin/clang-11-aarch64) :: test_terminate_commands (TestVSCode_attach.TestVSCode_attach)
======================================================================
FAIL: test_commands (TestVSCode_attach.TestVSCode_attach)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/home/tcwg-buildslave/worker/lldb-cmake-aarch64/llvm-project/lldb/test/API/tools/lldb-vscode/attach/TestVSCode_attach.py", line 174, in test_commands
    self.continue_to_breakpoints(breakpoint_ids)
  File "/home/tcwg-buildslave/worker/lldb-cmake-aarch64/llvm-project/lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py", line 226, in continue_to_breakpoints
    self.verify_breakpoint_hit(breakpoint_ids)
  File "/home/tcwg-buildslave/worker/lldb-cmake-aarch64/llvm-project/lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py", line 85, in verify_breakpoint_hit
    self.assertTrue(False, "breakpoint not hit")
AssertionError: False is not True : breakpoint not hit
Config=aarch64-/home/tcwg-buildslave/worker/lldb-cmake-aarch64/build/bin/clang-11
----------------------------------------------------------------------
Ran 5 tests in 27.063s

RESULT: FAILED (3 passes, 1 failures, 0 errors, 1 skipped, 0 expected failures, 0 unexpected successes)

--

Not sure if the failure is related to this patch, but it appears to be the most recent change.

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

def get_source_and_line(self, threadId=None, frameIndex=0):
         return ('', 0)
 
     def get_stdout(self, timeout=0.0):
         return self.vscode.get_output('stdout', timeout=timeout)
 
     def get_console(self, timeout=0.0):
         return self.vscode.get_output('console', timeout=timeout)
 
+    def collect_console(self, duration):
+        return self.vscode.collect_output('console', duration=duration)
+
     def get_local_as_int(self, name, threadId=None):
         value = self.vscode.get_local_variable_value(name, threadId=threadId)
         if value.startswith('0x'):
             return int(value, 16)
         elif value.startswith('0'):
             return int(value, 8)
         else:
             return int(value)
def continue_to_exit(self, exitCode=0):
                         "stopped_events = {}".format(stopped_events))
         self.assertEquals(stopped_events[0]['event'], 'exited',
                         'make sure program ran to completion')
         self.assertEquals(stopped_events[0]['body']['exitCode'], exitCode,
                         'exitCode == %i' % (exitCode))
 
     def attach(self, program=None, pid=None, waitFor=None, trace=None,
                initCommands=None, preRunCommands=None, stopCommands=None,
-               exitCommands=None, attachCommands=None, coreFile=None, disconnectAutomatically=True):
+               exitCommands=None, attachCommands=None, coreFile=None,
+               disconnectAutomatically=True, terminateCommands=None):
         '''Build the default Makefile target, create the VSCode debug adaptor,
            and attach to the process.
         '''
         # Make sure we disconnect and terminate the VSCode debug adaptor even
         # if we throw an exception during the test case.
         def cleanup():
             if disconnectAutomatically:
                 self.vscode.request_disconnect(terminateDebuggee=True)
             self.vscode.terminate()
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
         # Initialize and launch the program
         self.vscode.request_initialize()
         response = self.vscode.request_attach(
             program=program, pid=pid, waitFor=waitFor, trace=trace,
             initCommands=initCommands, preRunCommands=preRunCommands,
             stopCommands=stopCommands, exitCommands=exitCommands,
-            attachCommands=attachCommands, coreFile=coreFile)
+            attachCommands=attachCommands, terminateCommands=terminateCommands,
+            coreFile=coreFile)
         if not (response and response['success']):
             self.assertTrue(response['success'],
                             'attach failed (%s)' % (response['message']))
 
     def launch(self, program=None, args=None, cwd=None, env=None,
                stopOnEntry=False, disableASLR=True,
                disableSTDIO=False, shellExpandArguments=False,
                trace=False, initCommands=None, preRunCommands=None,
-               stopCommands=None, exitCommands=None,sourcePath=None,
-               debuggerRoot=None, launchCommands=None, sourceMap=None):
+               stopCommands=None, exitCommands=None, terminateCommands=None,
+               sourcePath=None, debuggerRoot=None, launchCommands=None,
+               sourceMap=None, disconnectAutomatically=True):
         '''Sending launch request to vscode
         '''
 
         # Make sure we disconnect and terminate the VSCode debug adapter,
         # if we throw an exception during the test case
         def cleanup():
+            if disconnectAutomatically:
                 self.vscode.request_disconnect(terminateDebuggee=True)
             self.vscode.terminate()
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
 
         # Initialize and launch the program
         self.vscode.request_initialize()
         response = self.vscode.request_launch(
             program,
             args=args,
             cwd=cwd,
             env=env,
             stopOnEntry=stopOnEntry,
             disableASLR=disableASLR,
             disableSTDIO=disableSTDIO,
             shellExpandArguments=shellExpandArguments,
             trace=trace,
             initCommands=initCommands,
             preRunCommands=preRunCommands,
             stopCommands=stopCommands,
             exitCommands=exitCommands,
+            terminateCommands=terminateCommands,
             sourcePath=sourcePath,
             debuggerRoot=debuggerRoot,
             launchCommands=launchCommands,
             sourceMap=sourceMap)
         if not (response and response['success']):
             self.assertTrue(response['success'],
                             'launch failed (%s)' % (response['message']))
 
     def build_and_launch(self, program, args=None, cwd=None, env=None,
                          stopOnEntry=False, disableASLR=True,
                          disableSTDIO=False, shellExpandArguments=False,
                          trace=False, initCommands=None, preRunCommands=None,
                          stopCommands=None, exitCommands=None,
-                         sourcePath=None, debuggerRoot=None):
+                         terminateCommands=None, sourcePath=None,
+                         debuggerRoot=None):
         '''Build the default Makefile target, create the VSCode debug adaptor,
            and launch the process.
         '''
         self.build_and_create_debug_adaptor()
         self.assertTrue(os.path.exists(program), 'executable must exist')
 
         self.launch(program, args, cwd, env, stopOnEntry, disableASLR,
                     disableSTDIO, shellExpandArguments, trace,
                     initCommands, preRunCommands, stopCommands, exitCommands,
-                    sourcePath, debuggerRoot)
+                    terminateCommands, sourcePath, debuggerRoot)

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

 #!/usr/bin/env python
 
 import binascii
 import json
 import optparse
 import os
 import pprint
 import socket
 import string
 import subprocess
 import sys
 import threading
+import time
 
 
 def dump_memory(base_addr, data, num_per_line, outfile):
 
     data_len = len(data)
     hex_string = binascii.hexlify(data)
     addr = base_addr
     ascii_str = ''
def get_output(self, category, timeout=0.0, clear=True):
             self.output_condition.wait(timeout)
             if category in self.output:
                 output = self.output[category]
                 if clear:
                     del self.output[category]
         self.output_condition.release()
         return output
 
+    def collect_output(self, category, duration, clear=True):
+        end_time = time.time() + duration
+        collected_output = ""
+        while end_time > time.time():
+            output = self.get_output(category, timeout=0.25, clear=clear)
+            if output:
+                collected_output += output
+        return collected_output if collected_output else None
+
     def enqueue_recv_packet(self, packet):
         self.recv_condition.acquire()
         self.recv_packets.append(packet)
         self.recv_condition.notify()
         self.recv_condition.release()
 
     def handle_recv_packet(self, packet):
         '''Called by the read thread that is waiting for all incoming packets
def handle_recv_packet(self, packet):
                 # Breakpoint events come in when a breakpoint has locations
                 # added or removed. Keep track of them so we can look for them
                 # in tests.
                 self.breakpoint_events.append(packet)
                 # no need to add 'breakpoint' event packets to our packets list
                 return keepGoing
         elif packet_type == 'response':
             if packet['command'] == 'disconnect':
                 keepGoing = False
         self.enqueue_recv_packet(packet)
         return keepGoing
 
     def send_packet(self, command_dict, set_sequence=True):
         '''Take the "command_dict" python dictionary and encode it as a JSON
            string and send the contents as a packet to the VSCode debug
            adaptor'''
         # Set the sequence ID for this command automatically
         if set_sequence:
def replay_packets(self, replay_file_path):
                     pprint.PrettyPrinter(indent=2).pprint(actual_response)
                 else:
                     print("error: didn't get a valid response")
                 mode = 'invalid'
 
     def request_attach(self, program=None, pid=None, waitFor=None, trace=None,
                        initCommands=None, preRunCommands=None,
                        stopCommands=None, exitCommands=None,
-                       attachCommands=None, coreFile=None):
+                       attachCommands=None, terminateCommands=None,
+                       coreFile=None):
         args_dict = {}
         if pid is not None:
             args_dict['pid'] = pid
         if program is not None:
             args_dict['program'] = program
         if waitFor is not None:
             args_dict['waitFor'] = waitFor
         if trace:
             args_dict['trace'] = trace
         args_dict['initCommands'] = self.init_commands
         if initCommands:
             args_dict['initCommands'].extend(initCommands)
         if preRunCommands:
             args_dict['preRunCommands'] = preRunCommands
         if stopCommands:
             args_dict['stopCommands'] = stopCommands
         if exitCommands:
             args_dict['exitCommands'] = exitCommands
+        if terminateCommands:
+            args_dict['terminateCommands'] = terminateCommands
         if attachCommands:
             args_dict['attachCommands'] = attachCommands
         if coreFile:
             args_dict['coreFile'] = coreFile
         command_dict = {
             'command': 'attach',
             'type': 'request',
             'arguments': args_dict
def request_initialize(self):
             if 'body' in response:
                 self.initialize_body = response['body']
         return response
 
     def request_launch(self, program, args=None, cwd=None, env=None,
                        stopOnEntry=False, disableASLR=True,
                        disableSTDIO=False, shellExpandArguments=False,
                        trace=False, initCommands=None, preRunCommands=None,
-                       stopCommands=None, exitCommands=None, sourcePath=None,
+                       stopCommands=None, exitCommands=None,
+                       terminateCommands=None ,sourcePath=None,
                        debuggerRoot=None, launchCommands=None, sourceMap=None):
         args_dict = {
             'program': program
         }
         if args:
             args_dict['args'] = args
         if cwd:
             args_dict['cwd'] = cwd
def request_launch(self, program, args=None, cwd=None, env=None,
         if initCommands:
             args_dict['initCommands'].extend(initCommands)
         if preRunCommands:
             args_dict['preRunCommands'] = preRunCommands
         if stopCommands:
             args_dict['stopCommands'] = stopCommands
         if exitCommands:
             args_dict['exitCommands'] = exitCommands
+        if terminateCommands:
+            args_dict['terminateCommands'] = terminateCommands
         if sourcePath:
             args_dict['sourcePath'] = sourcePath
         if debuggerRoot:
             args_dict['debuggerRoot'] = debuggerRoot
         if launchCommands:
             args_dict['launchCommands'] = launchCommands
         if sourceMap:
             args_dict['sourceMap'] = sourceMap
def run_vscode(dbg, args, options):
     if attach_options_specified(options):
         response = dbg.request_attach(program=options.program,
                                       pid=options.pid,
                                       waitFor=options.waitFor,
                                       attachCommands=options.attachCmds,
                                       initCommands=options.initCmds,
                                       preRunCommands=options.preRunCmds,
                                       stopCommands=options.stopCmds,
-                                      exitCommands=options.exitCmds)
+                                      exitCommands=options.exitCmds,
+                                      terminateCommands=options.terminateCmds)
     else:
         response = dbg.request_launch(options.program,
                                       args=args,
                                       env=options.envs,
                                       cwd=options.workingDir,
                                       debuggerRoot=options.debuggerRoot,
                                       sourcePath=options.sourcePath,
                                       initCommands=options.initCmds,
                                       preRunCommands=options.preRunCmds,
                                       stopCommands=options.stopCmds,
-                                      exitCommands=options.exitCmds)
+                                      exitCommands=options.exitCmds,
+                                      terminateCommands=options.terminateCmds)
 
     if response['success']:
         if options.sourceBreakpoints:
             source_to_lines = {}
             for file_line in options.sourceBreakpoints:
                 (path, line) = file_line.split(':')
                 if len(path) == 0 or len(line) == 0:
                     print('error: invalid source with line "%s"' %
parser.add_option(
         type='string',
         action='append',
         dest='exitCmds',
         default=[],
         help=('Specify a LLDB command that will be executed when the process '
               'exits. Can be specified more than once.'))
 
     parser.add_option(
+        '--terminateCommand',
+        type='string',
+        action='append',
+        dest='terminateCmds',
+        default=[],
+        help=('Specify a LLDB command that will be executed when the debugging '
+              'session is terminated. Can be specified more than once.'))
+
+    parser.add_option(
         '--env',
         type='string',
         action='append',
         dest='envs',
         default=[],
         help=('Specify environment variables to pass to the launched '
               'process.'))
 

lldb/test/API/tools/lldb-vscode/attach/TestVSCode_attach.py

def set_and_hit_breakpoint(self, continueToExit=True):
         # Set breakpoint in the thread function so we can step the threads
         breakpoint_ids = self.set_source_breakpoints(source, lines)
         self.assertEqual(len(breakpoint_ids), len(lines),
                          "expect correct number of breakpoints")
         self.continue_to_breakpoints(breakpoint_ids)
         if continueToExit:
             self.continue_to_exit()
 
-
     @skipIfWindows
     @skipIfNetBSD # Hangs on NetBSD as well
     @skipIfRemote
     def test_by_pid(self):
         '''
             Tests attaching to a process by process ID.
         '''
         self.build_and_create_debug_adaptor()
def test_by_name_waitFor(self):
         self.set_and_hit_breakpoint(continueToExit=True)
 
     @skipIfWindows
     @skipIfDarwin
     @skipIfNetBSD # Hangs on NetBSD as well
     def test_commands(self):
         '''
             Tests the "initCommands", "preRunCommands", "stopCommands",
-            "exitCommands", and "attachCommands" that can be passed during
-            attach.
+            "exitCommands", "terminateCommands" and "attachCommands"
+            that can be passed during attach.
 
             "initCommands" are a list of LLDB commands that get executed
             before the targt is created.
             "preRunCommands" are a list of LLDB commands that get executed
             after the target has been created and before the launch.
             "stopCommands" are a list of LLDB commands that get executed each
             time the program stops.
             "exitCommands" are a list of LLDB commands that get executed when
             the process exits
             "attachCommands" are a list of LLDB commands that get executed and
             must have a valid process in the selected target in LLDB after
             they are done executing. This allows custom commands to create any
             kind of debug session.
+            "terminateCommands" are a list of LLDB commands that get executed when
+            the debugger session terminates.
         '''
         self.build_and_create_debug_adaptor()
         program = self.getBuildArtifact("a.out")
         # Here we just create a target and launch the process as a way to test
         # if we are able to use attach commands to create any kind of a target
         # and use it for debugging
         attachCommands = [
             'target create -d "%s"' % (program),
             'process launch'
         ]
         initCommands = ['target list', 'platform list']
         preRunCommands = ['image list a.out', 'image dump sections a.out']
         stopCommands = ['frame variable', 'bt']
         exitCommands = ['expr 2+3', 'expr 3+4']
+        terminateCommands = ['expr 4+2']
         self.attach(program=program,
                     attachCommands=attachCommands,
                     initCommands=initCommands,
                     preRunCommands=preRunCommands,
                     stopCommands=stopCommands,
-                    exitCommands=exitCommands)
-
+                    exitCommands=exitCommands,
+                    terminateCommands=terminateCommands)
         # Get output from the console. This should contain both the
         # "initCommands" and the "preRunCommands".
         output = self.get_console()
         # Verify all "initCommands" were found in console output
         self.verify_commands('initCommands', output, initCommands)
         # Verify all "preRunCommands" were found in console output
         self.verify_commands('preRunCommands', output, preRunCommands)
 
def test_commands(self):
         self.vscode.wait_for_stopped()
         output = self.get_console(timeout=1.0)
         self.verify_commands('stopCommands', output, stopCommands)
 
         # Continue until the program exits
         self.continue_to_exit()
         # Get output from the console. This should contain both the
         # "exitCommands" that were run after the second breakpoint was hit
-        output = self.get_console(timeout=1.0)
+        # and the "terminateCommands" due to the debugging session ending
+        output = self.collect_console(duration=1.0)
         self.verify_commands('exitCommands', output, exitCommands)
+        self.verify_commands('terminateCommands', output, terminateCommands)
+
+    @skipIfWindows
+    @skipIfNetBSD # Hangs on NetBSD as well
+    def test_terminate_commands(self):
+        '''
+            Tests that the "terminateCommands", that can be passed during
+            attach, are run when the debugger is disconnected.
+        '''
+        self.build_and_create_debug_adaptor()
+        program = self.getBuildArtifact("a.out")
+        # Here we just create a target and launch the process as a way to test
+        # if we are able to use attach commands to create any kind of a target
+        # and use it for debugging
+        attachCommands = [
+            'target create -d "%s"' % (program),
+            'process launch'
+        ]
+        terminateCommands = ['expr 4+2']
+        self.attach(program=program,
+                    attachCommands=attachCommands,
+                    terminateCommands=terminateCommands,
+                    disconnectAutomatically=False)
+        self.get_console()
+        # Once it's disconnected the console should contain the
+        # "terminateCommands"
+        self.vscode.request_disconnect(terminateDebuggee=True)
+        output = self.collect_console(duration=1.0)
+        self.verify_commands('terminateCommands', output, terminateCommands)

lldb/test/API/tools/lldb-vscode/launch/TestVSCode_launch.py

def test_environment(self):
             self.assertTrue(found,
                             '"%s" must exist in program environment (%s)' % (
                                 var, lines))
 
     @skipIfWindows
     @skipIfRemote
     def test_commands(self):
         '''
-            Tests the "initCommands", "preRunCommands", "stopCommands" and
-            "exitCommands" that can be passed during launch.
+            Tests the "initCommands", "preRunCommands", "stopCommands",
+            "terminateCommands" and "exitCommands" that can be passed during
+            launch.
 
             "initCommands" are a list of LLDB commands that get executed
             before the targt is created.
             "preRunCommands" are a list of LLDB commands that get executed
             after the target has been created and before the launch.
             "stopCommands" are a list of LLDB commands that get executed each
             time the program stops.
             "exitCommands" are a list of LLDB commands that get executed when
             the process exits
+            "terminateCommands" are a list of LLDB commands that get executed when
+            the debugger session terminates.
         '''
         program = self.getBuildArtifact("a.out")
         initCommands = ['target list', 'platform list']
         preRunCommands = ['image list a.out', 'image dump sections a.out']
         stopCommands = ['frame variable', 'bt']
         exitCommands = ['expr 2+3', 'expr 3+4']
+        terminateCommands = ['expr 4+2']
         self.build_and_launch(program,
                               initCommands=initCommands,
                               preRunCommands=preRunCommands,
                               stopCommands=stopCommands,
-                              exitCommands=exitCommands)
+                              exitCommands=exitCommands,
+                              terminateCommands=terminateCommands)
 
         # Get output from the console. This should contain both the
         # "initCommands" and the "preRunCommands".
         output = self.get_console()
         # Verify all "initCommands" were found in console output
         self.verify_commands('initCommands', output, initCommands)
         # Verify all "preRunCommands" were found in console output
         self.verify_commands('preRunCommands', output, preRunCommands)
def test_commands(self):
         self.continue_to_breakpoints(breakpoint_ids)
         output = self.get_console(timeout=1.0)
         self.verify_commands('stopCommands', output, stopCommands)
 
         # Continue until the program exits
         self.continue_to_exit()
         # Get output from the console. This should contain both the
         # "exitCommands" that were run after the second breakpoint was hit
-        output = self.get_console(timeout=1.0)
+        # and the "terminateCommands" due to the debugging session ending
+        output = self.collect_console(duration=1.0)
         self.verify_commands('exitCommands', output, exitCommands)
+        self.verify_commands('terminateCommands', output, terminateCommands)
 
     @skipIfWindows
     @skipIfRemote
     def test_extra_launch_commands(self):
         '''
             Tests the "luanchCommands" with extra launching settings
         '''
         self.build_and_create_debug_adaptor()
def test_extra_launch_commands(self):
         self.verify_commands('stopCommands', output, stopCommands)
 
         # Continue until the program exits
         self.continue_to_exit()
         # Get output from the console. This should contain both the
         # "exitCommands" that were run after the second breakpoint was hit
         output = self.get_console(timeout=1.0)
         self.verify_commands('exitCommands', output, exitCommands)
+
+    @skipIfWindows
+    @skipIfNetBSD # Hangs on NetBSD as well
+    def test_terminate_commands(self):
+        '''
+            Tests that the "terminateCommands", that can be passed during
+            launch, are run when the debugger is disconnected.
+        '''
+        self.build_and_create_debug_adaptor()
+        program = self.getBuildArtifact("a.out")
+        
+        terminateCommands = ['expr 4+2']
+        self.launch(program=program,
+                    terminateCommands=terminateCommands)
+        self.get_console()
+        # Once it's disconnected the console should contain the
+        # "terminateCommands"
+        self.vscode.request_disconnect(terminateDebuggee=True)
+        output = self.collect_console(duration=1.0)
+        self.verify_commands('terminateCommands', output, terminateCommands)

lldb/tools/lldb-vscode/README.md

- [Example configurations](#example-configurations)
     - [Attach to process using process ID](#attach-using-pid)
     - [Attach to process by name](#attach-by-name)
     - [Loading a core file](#loading-a-core-file)
 
 # Introduction
 
 The `lldb-vscode` tool creates a command line tool that implements the [Visual
 Studio Code Debug API](https://code.visualstudio.com/docs/extensionAPI/api-debugging).
-It can be installed as an extension for the Visual Studio Code and Nuclide IDE. 
+It can be installed as an extension for the Visual Studio Code and Nuclide IDE.
 The protocol is easy to run remotely and also can allow other tools and IDEs to
-get a full featured debugger with a well defined protocol. 
+get a full featured debugger with a well defined protocol.
 
 # Installation for Visual Studio Code
 
 Installing the plug-in involves creating a directory in the `~/.vscode/extensions` folder and copying the package.json file that is in the same directory as this
-documentation into it, and copying to symlinking a lldb-vscode binary into 
+documentation into it, and copying to symlinking a lldb-vscode binary into
 the `bin` directory inside the plug-in directory.
 
 If you want to make a stand alone plug-in that you can send to others on unix systems:
 
 ```
 $ mkdir -p ~/.vscode/extensions/llvm-org.lldb-vscode-0.1.0/bin
 $ cp package.json ~/.vscode/extensions/llvm-org.lldb-vscode-0.1.0
 $ cd ~/.vscode/extensions/llvm-org.lldb-vscode-0.1.0/bin

 |**args**           |[string]|| An array of command line argument strings to be passed to the program being launched.
 |**cwd**            |string| | The program working directory.
 |**env**            |dictionary| | 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.
 |**stopOnEntry**    |boolean| | Whether to stop program immediately after launching.
 |**initCommands**   |[string]| | LLDB commands executed upon debugger startup prior to creating the LLDB target. Commands and command output will be sent to the debugger console when they are executed.
 |**preRunCommands** |[string]| | LLDB commands executed just before launching after the LLDB target has been created. Commands and command output will be sent to the debugger console when they are executed.
 |**stopCommands**   |[string]| | LLDB commands executed just after each stop. Commands and command output will be sent to the debugger console when they are executed.
 |**exitCommands**   |[string]| | LLDB commands executed when the program exits. Commands and command output will be sent to the debugger console when they are executed.
+|**terminateCommands** |[string]| | LLDB commands executed when the debugging session ends. Commands and command output will be sent to the debugger console when they are executed.
 |**sourceMap**      |[string[2]]| | Specify an array of path re-mappings. Each element in the array must be a two element array containing a source and destination pathname.
 |**debuggerRoot**   | string| |Specify a working directory to use when launching lldb-vscode. If the debug information in your executable contains relative paths, this option can be used so that `lldb-vscode` can find source files and object files that have relative paths.
 
 ## Attaching Settings
 
 When attaching to a process using LLDB you can attach in a few ways
 
 1. Attach to an existing process using the process ID

 |**program**        |string  | | Path to the executable to attach to. This value is optional but can help to resolve breakpoints prior the attaching to the program.
 |**pid**            |number  | | The process id of the process you wish to attach to. If **pid** is omitted, the debugger will attempt to attach to the program by finding a process whose file name matches the file name from **porgram**. Setting this value to `${command:pickMyProcess}` will allow interactive process selection in the IDE.
 |**stopOnEntry**    |boolean| | Whether to stop program immediately after launching.
 |**waitFor**        |boolean | | Wait for the process to launch.
 |**initCommands**   |[string]| | LLDB commands executed upon debugger startup prior to creating the LLDB target. Commands and command output will be sent to the debugger console when they are executed.
 |**preRunCommands** |[string]| | LLDB commands executed just before launching after the LLDB target has been created. Commands and command output will be sent to the debugger console when they are executed.
 |**stopCommands**   |[string]| | LLDB commands executed just after each stop. Commands and command output will be sent to the debugger console when they are executed.
 |**exitCommands**   |[string]| | LLDB commands executed when the program exits. Commands and command output will be sent to the debugger console when they are executed.
+|**terminateCommands** |[string]| | LLDB commands executed when the debugging session ends. Commands and command output will be sent to the debugger console when they are executed.
 |**attachCommands** |[string]| | LLDB commands that will be executed after **preRunCommands** which take place of the code that normally does the attach. The commands can create a new target and attach or launch it however desired. This allows custom launch and attach configurations. Core files can use `target create --core /path/to/core` to attach to core files.
 
 
 ## Example configurations
 
 ### Launching
 
 This will launch `/tmp/a.out` with arguments `one`, `two`, and `three` and

lldb/tools/lldb-vscode/VSCode.h

struct VSCode {
   llvm::DenseMap<int64_t, SourceReference> source_map;
   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;
   lldb::tid_t focus_tid;
   bool sent_terminated_event;
   bool stop_at_entry;
   bool is_attach;
   // 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;
   VSCode();
struct VSCode {
 
   void RunLLDBCommands(llvm::StringRef prefix,
                        const std::vector<std::string> &commands);
 
   void RunInitCommands();
   void RunPreRunCommands();
   void RunStopCommands();
   void RunExitCommands();
+  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
   ///     function failed to create the target.

lldb/tools/lldb-vscode/VSCode.cpp

 void VSCode::RunStopCommands() {
   RunLLDBCommands("Running stopCommands:", stop_commands);
 }
 
 void VSCode::RunExitCommands() {
   RunLLDBCommands("Running exitCommands:", exit_commands);
 }
 
+void VSCode::RunTerminateCommands() {
+  RunLLDBCommands("Running terminateCommands:", terminate_commands);
+}
+
 lldb::SBTarget VSCode::CreateTargetFromArguments(
     const llvm::json::Object &arguments,
     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 differ from the host. Setting exe path
   // in launch info is useless because Target.Launch() will not change
   // architecture and platform, therefore they should be known at the target

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

void SendThreadExitedEvent(lldb::tid_t tid) {
   g_vsc.SendJSON(llvm::json::Value(std::move(event)));
 }
 
 // Send a "terminated" event to indicate the process is done being
 // debugged.
 void SendTerminatedEvent() {
   if (!g_vsc.sent_terminated_event) {
     g_vsc.sent_terminated_event = true;
+    g_vsc.RunTerminateCommands();
     // Send a "terminated" event
     llvm::json::Object event(CreateEventObject("terminated"));
     g_vsc.SendJSON(llvm::json::Value(std::move(event)));
   }
 }
 
 // Send a thread stopped event for all threads as long as the process
 // is stopped.
void request_attach(const llvm::json::Object &request) {
   if (pid != LLDB_INVALID_PROCESS_ID)
     attach_info.SetProcessID(pid);
   const auto wait_for = GetBoolean(arguments, "waitFor", false);
   attach_info.SetWaitForLaunch(wait_for, false /*async*/);
   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 attachCommands = GetStrings(arguments, "attachCommands");
   llvm::StringRef core_file = GetString(arguments, "coreFile");
   g_vsc.stop_at_entry =
       core_file.empty() ? GetBoolean(arguments, "stopOnEntry", false) : true;
   const llvm::StringRef debuggerRoot = GetString(arguments, "debuggerRoot");
 
   // 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
void request_disconnect(const llvm::json::Object &request) {
   FillResponse(request, response);
   auto arguments = request.getObject("arguments");
 
   bool defaultTerminateDebuggee = g_vsc.is_attach ? false : true;
   bool terminateDebuggee =
       GetBoolean(arguments, "terminateDebuggee", defaultTerminateDebuggee);
   lldb::SBProcess process = g_vsc.target.GetProcess();
   auto state = process.GetState();
-
   switch (state) {
   case lldb::eStateInvalid:
   case lldb::eStateUnloaded:
   case lldb::eStateDetached:
   case lldb::eStateExited:
     break;
   case lldb::eStateConnected:
   case lldb::eStateAttaching:
   case lldb::eStateLaunching:
   case lldb::eStateStepping:
   case lldb::eStateCrashed:
   case lldb::eStateSuspended:
   case lldb::eStateStopped:
   case lldb::eStateRunning:
     g_vsc.debugger.SetAsync(false);
     lldb::SBError error = terminateDebuggee ? process.Kill() : process.Detach();
     if (!error.Success())
       response.try_emplace("error", error.GetCString());
     g_vsc.debugger.SetAsync(true);
     break;
   }
-  g_vsc.SendJSON(llvm::json::Value(std::move(response)));
   SendTerminatedEvent();
+  g_vsc.SendJSON(llvm::json::Value(std::move(response)));
   if (g_vsc.event_thread.joinable()) {
     g_vsc.broadcaster.BroadcastEventByType(eBroadcastBitStopEventThread);
     g_vsc.event_thread.join();
   }
 }
 
 void request_exceptionInfo(const llvm::json::Object &request) {
   llvm::json::Object response;
void request_launch(const llvm::json::Object &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");
   g_vsc.stop_at_entry = GetBoolean(arguments, "stopOnEntry", false);
   const llvm::StringRef debuggerRoot = GetString(arguments, "debuggerRoot");
 
   // 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.