maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "Add terminateCommands to lldb-vscode protocol" 

This reverts commit a3609b0ec6, because it
makes a number of lldb-vscode tests flaky.
This commit is contained in:
Pavel Labath 2020-05-20 10:08:09 +02:00
parent fb6986ef69
commit 2a227b36b0
9 changed files with 28 additions and 151 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -179,9 +179,6 @@ class VSCodeTestCaseBase(TestBase):
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'):
@ -242,15 +239,13 @@ class VSCodeTestCaseBase(TestBase):
def attach(self, program=None, pid=None, waitFor=None, trace=None,
initCommands=None, preRunCommands=None, stopCommands=None,
exitCommands=None, attachCommands=None, terminateCommands=None,
coreFile=None):
exitCommands=None, attachCommands=None, coreFile=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 self.vscode.debugging:
self.vscode.request_disconnect(terminateDebuggee=True)
self.vscode.terminate()
@ -262,8 +257,7 @@ class VSCodeTestCaseBase(TestBase):
program=program, pid=pid, waitFor=waitFor, trace=trace,
initCommands=initCommands, preRunCommands=preRunCommands,
stopCommands=stopCommands, exitCommands=exitCommands,
attachCommands=attachCommands, terminateCommands=terminateCommands,
coreFile=coreFile)
attachCommands=attachCommands, coreFile=coreFile)
if not (response and response['success']):
self.assertTrue(response['success'],
'attach failed (%s)' % (response['message']))
@ -272,16 +266,14 @@ class VSCodeTestCaseBase(TestBase):
stopOnEntry=False, disableASLR=True,
disableSTDIO=False, shellExpandArguments=False,
trace=False, initCommands=None, preRunCommands=None,
stopCommands=None, exitCommands=None, terminateCommands=None,
sourcePath=None, debuggerRoot=None, launchCommands=None,
sourceMap=None):
stopCommands=None, exitCommands=None,sourcePath=None,
debuggerRoot=None, launchCommands=None, sourceMap=None):
'''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 self.vscode.debugging:
self.vscode.request_disconnect(terminateDebuggee=True)
self.vscode.terminate()
@ -304,7 +296,6 @@ class VSCodeTestCaseBase(TestBase):
preRunCommands=preRunCommands,
stopCommands=stopCommands,
exitCommands=exitCommands,
terminateCommands=terminateCommands,
sourcePath=sourcePath,
debuggerRoot=debuggerRoot,
launchCommands=launchCommands,
@ -318,8 +309,7 @@ class VSCodeTestCaseBase(TestBase):
disableSTDIO=False, shellExpandArguments=False,
trace=False, initCommands=None, preRunCommands=None,
stopCommands=None, exitCommands=None,
terminateCommands=None, sourcePath=None,
debuggerRoot=None):
sourcePath=None, debuggerRoot=None):
'''Build the default Makefile target, create the VSCode debug adaptor,
and launch the process.
'''
@ -329,4 +319,4 @@ class VSCodeTestCaseBase(TestBase):
self.launch(program, args, cwd, env, stopOnEntry, disableASLR,
disableSTDIO, shellExpandArguments, trace,
initCommands, preRunCommands, stopCommands, exitCommands,
terminateCommands, sourcePath, debuggerRoot)
sourcePath, debuggerRoot)

44
lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py
View File

@ -10,7 +10,6 @@ import string
import subprocess
import sys
import threading
import time
def dump_memory(base_addr, data, num_per_line, outfile):
@ -121,7 +120,6 @@ class DebugCommunication(object):
self.configuration_done_sent = False
self.frame_scopes = {}
self.init_commands = init_commands
self.debugging = False
@classmethod
def encode_content(cls, s):
@ -150,15 +148,6 @@ class DebugCommunication(object):
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)
@ -219,13 +208,9 @@ class DebugCommunication(object):
self.breakpoint_events.append(packet)
# no need to add 'breakpoint' event packets to our packets list
return keepGoing
elif event == 'initialized':
self.debugging = True
elif event == 'terminated':
self.debugging = False
elif packet_type == 'response':
if packet['command'] == 'disconnect':
keepGoing = False
elif event == 'exited':
self.debugging = False
self.enqueue_recv_packet(packet)
return keepGoing
@ -465,8 +450,7 @@ class DebugCommunication(object):
def request_attach(self, program=None, pid=None, waitFor=None, trace=None,
initCommands=None, preRunCommands=None,
stopCommands=None, exitCommands=None,
attachCommands=None, terminateCommands=None,
coreFile=None):
attachCommands=None, coreFile=None):
args_dict = {}
if pid is not None:
args_dict['pid'] = pid
@ -485,8 +469,6 @@ class DebugCommunication(object):
args_dict['stopCommands'] = stopCommands
if exitCommands:
args_dict['exitCommands'] = exitCommands
if terminateCommands:
args_dict['terminateCommands'] = terminateCommands
if attachCommands:
args_dict['attachCommands'] = attachCommands
if coreFile:
@ -589,8 +571,7 @@ class DebugCommunication(object):
stopOnEntry=False, disableASLR=True,
disableSTDIO=False, shellExpandArguments=False,
trace=False, initCommands=None, preRunCommands=None,
stopCommands=None, exitCommands=None,
terminateCommands=None ,sourcePath=None,
stopCommands=None, exitCommands=None, sourcePath=None,
debuggerRoot=None, launchCommands=None, sourceMap=None):
args_dict = {
'program': program
@ -620,8 +601,6 @@ class DebugCommunication(object):
args_dict['stopCommands'] = stopCommands
if exitCommands:
args_dict['exitCommands'] = exitCommands
if terminateCommands:
args_dict['terminateCommands'] = terminateCommands
if sourcePath:
args_dict['sourcePath'] = sourcePath
if debuggerRoot:
@ -926,8 +905,7 @@ def run_vscode(dbg, args, options):
initCommands=options.initCmds,
preRunCommands=options.preRunCmds,
stopCommands=options.stopCmds,
exitCommands=options.exitCmds,
terminateCommands=options.terminateCmds)
exitCommands=options.exitCmds)
else:
response = dbg.request_launch(options.program,
args=args,
@ -938,8 +916,7 @@ def run_vscode(dbg, args, options):
initCommands=options.initCmds,
preRunCommands=options.preRunCmds,
stopCommands=options.stopCmds,
exitCommands=options.exitCmds,
terminateCommands=options.terminateCmds)
exitCommands=options.exitCmds)
if response['success']:
if options.sourceBreakpoints:
@ -1112,15 +1089,6 @@ def main():
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',

43
lldb/test/API/tools/lldb-vscode/attach/TestVSCode_attach.py
View File

@ -121,8 +121,8 @@ class TestVSCode_attach(lldbvscode_testcase.VSCodeTestCaseBase):
def test_commands(self):
'''
Tests the "initCommands", "preRunCommands", "stopCommands",
"exitCommands", "terminateCommands" and "attachCommands"
that can be passed during attach.
"exitCommands", and "attachCommands" that can be passed during
attach.
"initCommands" are a list of LLDB commands that get executed
before the targt is created.
@ -136,8 +136,6 @@ class TestVSCode_attach(lldbvscode_testcase.VSCodeTestCaseBase):
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")
@ -152,14 +150,13 @@ class TestVSCode_attach(lldbvscode_testcase.VSCodeTestCaseBase):
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,
terminateCommands=terminateCommands)
exitCommands=exitCommands)
# Get output from the console. This should contain both the
# "initCommands" and the "preRunCommands".
output = self.get_console()
@ -190,35 +187,5 @@ class TestVSCode_attach(lldbvscode_testcase.VSCodeTestCaseBase):
self.continue_to_exit()
# Get output from the console. This should contain both the
# "exitCommands" that were run after the second breakpoint was hit
# and the "terminateCommands" due to the debugging session ending
output = self.collect_console(duration=1.0)
output = self.get_console(timeout=1.0)
self.verify_commands('exitCommands', output, exitCommands)
self.verify_commands('terminateCommands', output, terminateCommands)
@skipIfWindows
@skipIfDarwin
@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)
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)

41
lldb/test/API/tools/lldb-vscode/launch/TestVSCode_launch.py
View File

@ -294,9 +294,8 @@ class TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
@skipIfRemote
def test_commands(self):
'''
Tests the "initCommands", "preRunCommands", "stopCommands",
"terminateCommands" and "exitCommands" that can be passed during
launch.
Tests the "initCommands", "preRunCommands", "stopCommands" and
"exitCommands" that can be passed during launch.
"initCommands" are a list of LLDB commands that get executed
before the targt is created.
@ -306,21 +305,17 @@ class TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
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,
terminateCommands=terminateCommands)
exitCommands=exitCommands)
# Get output from the console. This should contain both the
# "initCommands" and the "preRunCommands".
@ -359,10 +354,8 @@ class TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
self.continue_to_exit()
# Get output from the console. This should contain both the
# "exitCommands" that were run after the second breakpoint was hit
# and the "terminateCommands" due to the debugging session ending
output = self.collect_console(duration=1.0)
output = self.get_console(timeout=1.0)
self.verify_commands('exitCommands', output, exitCommands)
self.verify_commands('terminateCommands', output, terminateCommands)
@skipIfWindows
@skipIfRemote
@ -427,29 +420,3 @@ class TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
# "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")
# 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.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)

2
lldb/tools/lldb-vscode/README.md
View File

@ -86,7 +86,6 @@ file that defines how your program will be run. The JSON configuration file can
|**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.
@ -113,7 +112,6 @@ The JSON configuration file can contain the following `lldb-vscode` specific lau
|**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.

4
lldb/tools/lldb-vscode/VSCode.cpp
View File

@ -309,10 +309,6 @@ 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) {

2
lldb/tools/lldb-vscode/VSCode.h
View File

@ -86,7 +86,6 @@ struct VSCode {
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;
@ -133,7 +132,6 @@ struct VSCode {
void RunPreRunCommands();
void RunStopCommands();
void RunExitCommands();
void RunTerminateCommands();
/// Create a new SBTarget object from the given request arguments.
/// \param[in] arguments

4
lldb/tools/lldb-vscode/lldb-vscode.cpp
View File

@ -174,7 +174,6 @@ void SendThreadExitedEvent(lldb::tid_t tid) {
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)));
@ -530,7 +529,6 @@ void request_attach(const llvm::json::Object &request) {
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 =
@ -774,6 +772,7 @@ void request_disconnect(const llvm::json::Object &request) {
bool terminateDebuggee = GetBoolean(arguments, "terminateDebuggee", false);
lldb::SBProcess process = g_vsc.target.GetProcess();
auto state = process.GetState();
switch (state) {
case lldb::eStateInvalid:
case lldb::eStateUnloaded:
@ -1366,7 +1365,6 @@ void request_launch(const llvm::json::Object &request) {
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");

5
lldb/tools/lldb-vscode/package.json
View File

@ -151,11 +151,6 @@
"default": []
},
"exitCommands": {
"type": "array",
"description": "Commands executed when the program exits.",
"default": []
},
"terminateCommands": {
"type": "array",
"description": "Commands executed at the end of debugging session.",
"default": []