This diff ass postRunCommands, which are the counterpart of the preRunCommands. TThey will be executed right after the target is launched or attached correctly, which means that the targets can assume that the target is running.
Differential Revision: https://reviews.llvm.org/D100340
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, terminateCommands=None):
+ disconnectAutomatically=True, terminateCommands=None,
+ postRunCommands=None):
'''Build the default Makefile target, create the VSCode debug adaptor,
and attach to the process.
'''
initCommands=initCommands, preRunCommands=preRunCommands,
stopCommands=stopCommands, exitCommands=exitCommands,
attachCommands=attachCommands, terminateCommands=terminateCommands,
- coreFile=coreFile)
+ coreFile=coreFile, postRunCommands=postRunCommands)
if not (response and response['success']):
self.assertTrue(response['success'],
'attach failed (%s)' % (response['message']))
stopCommands=None, exitCommands=None, terminateCommands=None,
sourcePath=None, debuggerRoot=None, launchCommands=None,
sourceMap=None, disconnectAutomatically=True, runInTerminal=False,
- expectFailure=False):
+ expectFailure=False, postRunCommands=None):
'''Sending launch request to vscode
'''
launchCommands=launchCommands,
sourceMap=sourceMap,
runInTerminal=runInTerminal,
- expectFailure=expectFailure)
+ expectFailure=expectFailure,
+ postRunCommands=postRunCommands)
if expectFailure:
return response
stopCommands=None, exitCommands=None,
terminateCommands=None, sourcePath=None,
debuggerRoot=None, runInTerminal=False,
- disconnectAutomatically=True):
+ disconnectAutomatically=True, postRunCommands=None):
'''Build the default Makefile target, create the VSCode debug adaptor,
and launch the process.
'''
disableSTDIO, shellExpandArguments, trace,
initCommands, preRunCommands, stopCommands, exitCommands,
terminateCommands, sourcePath, debuggerRoot, runInTerminal=runInTerminal,
- disconnectAutomatically=disconnectAutomatically)
+ disconnectAutomatically=disconnectAutomatically,
+ postRunCommands=postRunCommands)
initCommands=None, preRunCommands=None,
stopCommands=None, exitCommands=None,
attachCommands=None, terminateCommands=None,
- coreFile=None):
+ coreFile=None, postRunCommands=None):
args_dict = {}
if pid is not None:
args_dict['pid'] = pid
args_dict['attachCommands'] = attachCommands
if coreFile:
args_dict['coreFile'] = coreFile
+ if postRunCommands:
+ args_dict['postRunCommands'] = postRunCommands
command_dict = {
'command': 'attach',
'type': 'request',
stopCommands=None, exitCommands=None,
terminateCommands=None ,sourcePath=None,
debuggerRoot=None, launchCommands=None, sourceMap=None,
- runInTerminal=False, expectFailure=False):
+ runInTerminal=False, expectFailure=False,
+ postRunCommands=None):
args_dict = {
'program': program
}
args_dict['sourceMap'] = sourceMap
if runInTerminal:
args_dict['runInTerminal'] = runInTerminal
+ if postRunCommands:
+ args_dict['postRunCommands'] = postRunCommands
command_dict = {
'command': 'launch',
'type': 'request',
]
initCommands = ['target list', 'platform list']
preRunCommands = ['image list a.out', 'image dump sections a.out']
+ postRunCommands = ['help trace', 'help process trace']
stopCommands = ['frame variable', 'bt']
exitCommands = ['expr 2+3', 'expr 3+4']
terminateCommands = ['expr 4+2']
preRunCommands=preRunCommands,
stopCommands=stopCommands,
exitCommands=exitCommands,
- terminateCommands=terminateCommands)
+ terminateCommands=terminateCommands,
+ postRunCommands=postRunCommands)
# Get output from the console. This should contain both the
# "initCommands" and the "preRunCommands".
output = self.get_console()
self.verify_commands('initCommands', output, initCommands)
# Verify all "preRunCommands" were found in console output
self.verify_commands('preRunCommands', output, preRunCommands)
+ # Verify all "postRunCommands" were found in console output
+ self.verify_commands('postRunCommands', output, postRunCommands)
functions = ['main']
breakpoint_ids = self.set_function_breakpoints(functions)
program = self.getBuildArtifact("a.out")
initCommands = ['target list', 'platform list']
preRunCommands = ['image list a.out', 'image dump sections a.out']
+ postRunCommands = ['help trace', 'help process trace']
stopCommands = ['frame variable', 'bt']
exitCommands = ['expr 2+3', 'expr 3+4']
terminateCommands = ['expr 4+2']
self.build_and_launch(program,
initCommands=initCommands,
preRunCommands=preRunCommands,
+ postRunCommands=postRunCommands,
stopCommands=stopCommands,
exitCommands=exitCommands,
terminateCommands=terminateCommands)
self.verify_commands('initCommands', output, initCommands)
# Verify all "preRunCommands" were found in console output
self.verify_commands('preRunCommands', output, preRunCommands)
+ # Verify all "postRunCommands" were found in console output
+ self.verify_commands('postRunCommands', output, postRunCommands)
source = 'main.c'
first_line = line_number(source, '// breakpoint 1')
llvm::StringRef core_file = GetString(arguments, "coreFile");
g_vsc.stop_at_entry =
core_file.empty() ? GetBoolean(arguments, "stopOnEntry", false) : true;
+ std::vector<std::string> postRunCommands =
+ GetStrings(arguments, "postRunCommands");
const llvm::StringRef debuggerRoot = GetString(arguments, "debuggerRoot");
// This is a hack for loading DWARF in .o files on Mac where the .o files
if (error.Fail()) {
response["success"] = llvm::json::Value(false);
EmplaceSafeString(response, "message", std::string(error.GetCString()));
+ } else {
+ g_vsc.RunLLDBCommands("Running postRunCommands:", postRunCommands);
}
+
g_vsc.SendJSON(llvm::json::Value(std::move(response)));
if (error.Success()) {
SendProcessEvent(Attach);
g_vsc.SendJSON(CreateEventObject("initialized"));
- // SendThreadStoppedEvent();
}
}
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");
if (error.Fail()) {
response["success"] = llvm::json::Value(false);
EmplaceSafeString(response, "message", std::string(error.GetCString()));
+ } else {
+ g_vsc.RunLLDBCommands("Running postRunCommands:", postRunCommands);
}
+
g_vsc.SendJSON(llvm::json::Value(std::move(response)));
if (g_vsc.is_attach)
"description": "Commands executed just before the program is launched.",
"default": []
},
+ "postRunCommands": {
+ "type": "array",
+ "description": "Commands executed just as soon as the program is successfully launched when it's in a stopped state prior to any automatic continuation.",
+ "default": []
+ },
"launchCommands": {
"type": "array",
"description": "Custom commands that are executed instead of launching a process. A target will be created with the launch arguments prior to executing these commands. The commands may optionally create a new target and must perform a launch. A valid process must exist after these commands complete or the \"launch\" will fail.",
"description": "Commands executed just before the program is attached to.",
"default": []
},
+ "postRunCommands": {
+ "type": "array",
+ "description": "Commands executed just as soon as the program is successfully attached when it's in a stopped state prior to any automatic continuation.",
+ "default": []
+ },
"stopCommands": {
"type": "array",
"description": "Commands executed each time the program stops.",