mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-26 17:16:07 +00:00
Code Issues Projects Releases Wiki Activity

Revert "Add runToBinaryEntry option for lldb-vscode"

Browse Source 
This reverts commit f0c16f89124f2dc0630162ff9ea23934f5b2b75b because it
breaks linux and mac bots.
This commit is contained in:
Pavel Labath 2022-11-23 12:22:03 +01:00
parent 5cfc22cafe
commit 14aace34c3
7 changed files with 27 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -286,7 +286,7 @@ class VSCodeTestCaseBase(TestBase):
stopCommands=None, exitCommands=None, terminateCommands=None,
sourcePath=None, debuggerRoot=None, sourceInitFile=False, launchCommands=None,
sourceMap=None, disconnectAutomatically=True, runInTerminal=False,
expectFailure=False, postRunCommands=None, runToBinaryEntry=False):
expectFailure=False, postRunCommands=None):
'''Sending launch request to vscode
'''
@ -323,8 +323,7 @@ class VSCodeTestCaseBase(TestBase):
sourceMap=sourceMap,
runInTerminal=runInTerminal,
expectFailure=expectFailure,
postRunCommands=postRunCommands,
runToBinaryEntry=runToBinaryEntry)
postRunCommands=postRunCommands)
if expectFailure:
return response
@ -347,7 +346,7 @@ class VSCodeTestCaseBase(TestBase):
terminateCommands=None, sourcePath=None,
debuggerRoot=None, sourceInitFile=False, runInTerminal=False,
disconnectAutomatically=True, postRunCommands=None,
lldbVSCodeEnv=None, runToBinaryEntry=False):
lldbVSCodeEnv=None):
'''Build the default Makefile target, create the VSCode debug adaptor,
and launch the process.
'''
@ -360,5 +359,4 @@ class VSCodeTestCaseBase(TestBase):
terminateCommands, sourcePath, debuggerRoot, sourceInitFile,
runInTerminal=runInTerminal,
disconnectAutomatically=disconnectAutomatically,
postRunCommands=postRunCommands,
runToBinaryEntry=runToBinaryEntry)
postRunCommands=postRunCommands)

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

@ -650,7 +650,7 @@ class DebugCommunication(object):
terminateCommands=None ,sourcePath=None,
debuggerRoot=None, launchCommands=None, sourceMap=None,
runInTerminal=False, expectFailure=False,
postRunCommands=None, runToBinaryEntry=False):
postRunCommands=None):
args_dict = {
'program': program
}
@ -662,8 +662,6 @@ class DebugCommunication(object):
args_dict['env'] = env
if stopOnEntry:
args_dict['stopOnEntry'] = stopOnEntry
if runToBinaryEntry:
args_dict['runToBinaryEntry'] = runToBinaryEntry
if disableASLR:
args_dict['disableASLR'] = disableASLR
if disableSTDIO:

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

@ -78,29 +78,6 @@ class TestVSCode_launch(lldbvscode_testcase.VSCodeTestCaseBase):
reason, 'breakpoint',
'verify stop isn\'t "main" breakpoint')
@skipIfWindows
@skipIfRemote
def test_runToBinaryEntry(self):
'''
Tests the runToBinaryEntry option can successfully launch a simple
program and hit a breakpoint and does not interupt the launch.
'''
program = self.getBuildArtifact("a.out")
self.build_and_launch(program, runToBinaryEntry=True)
self.set_function_breakpoints(['main'])
stopped_events = self.continue_to_next_stop()
console_output = self.get_console()
self.assertIn("Process stopped successfully at the binary's entry point", console_output)
for stopped_event in stopped_events:
if 'body' in stopped_event:
body = stopped_event['body']
if 'reason' in body:
reason = body['reason']
self.assertTrue(
reason == 'breakpoint',
'verify successfully stop at "main" breakpoint')
@skipIfWindows
@skipIfRemote
def test_cwd(self):

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

@ -528,8 +528,7 @@ void VSCode::RegisterRequestCallback(std::string request,
request_handlers[request] = callback;
}
lldb::SBError VSCode::WaitForProcessToStop(uint32_t seconds,
uint32_t old_stop_id) {
lldb::SBError VSCode::WaitForProcessToStop(uint32_t seconds) {
lldb::SBError error;
lldb::SBProcess process = target.GetProcess();
if (!process.IsValid()) {
@ -539,33 +538,28 @@ lldb::SBError VSCode::WaitForProcessToStop(uint32_t seconds,
auto timeout_time =
std::chrono::steady_clock::now() + std::chrono::seconds(seconds);
while (std::chrono::steady_clock::now() < timeout_time) {
// Wait for stop id changed before checking for stopped state.
// This is needed to make sure we are not checking old stopped state in
// async mode.
if (old_stop_id > 0 && process.GetStopID() <= old_stop_id)
continue;
const auto state = process.GetState();
switch (state) {
case lldb::eStateAttaching:
case lldb::eStateConnected:
case lldb::eStateInvalid:
case lldb::eStateLaunching:
case lldb::eStateRunning:
case lldb::eStateStepping:
case lldb::eStateSuspended:
break;
case lldb::eStateDetached:
error.SetErrorString("process detached during launch or attach");
return error;
case lldb::eStateExited:
error.SetErrorString("process exited during launch or attach");
return error;
case lldb::eStateUnloaded:
error.SetErrorString("process unloaded during launch or attach");
return error;
case lldb::eStateCrashed:
case lldb::eStateStopped:
return lldb::SBError(); // Success!
case lldb::eStateAttaching:
case lldb::eStateConnected:
case lldb::eStateInvalid:
case lldb::eStateLaunching:
case lldb::eStateRunning:
case lldb::eStateStepping:
case lldb::eStateSuspended:
break;
case lldb::eStateDetached:
error.SetErrorString("process detached during launch or attach");
return error;
case lldb::eStateExited:
error.SetErrorString("process exited during launch or attach");
return error;
case lldb::eStateUnloaded:
error.SetErrorString("process unloaded during launch or attach");
return error;
case lldb::eStateCrashed:
case lldb::eStateStopped:
return lldb::SBError(); // Success!
}
std::this_thread::sleep_for(std::chrono::microseconds(250));
}

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

@ -144,7 +144,6 @@ struct VSCode {
lldb::tid_t focus_tid;
bool sent_terminated_event;
bool stop_at_entry;
bool run_to_binary_entry = false;
bool is_attach;
bool configuration_done_sent;
uint32_t reverse_request_seq;
@ -262,14 +261,9 @@ struct VSCode {
///
/// \param[in] seconds
/// The number of seconds to poll the process to wait until it is stopped.
/// \param[in] old_stop_id
/// Optional old stop id which we should only check for stopped state if
/// the new stop id is greater than it. This is needed if the previous state
/// is stopped so that we can ensure we are checking new stopped state not
/// the old one in async mode.
///
/// \return Error if waiting for the process fails, no error if succeeds.
lldb::SBError WaitForProcessToStop(uint32_t seconds, uint32_t old_stop_id = 0);
lldb::SBError WaitForProcessToStop(uint32_t seconds);
private:
// Send the JSON in "json_str" to the "out" stream. Correctly send the

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

@ -1610,68 +1610,6 @@ llvm::Error request_runInTerminal(const llvm::json::Object &launch_request) {
error.GetCString());
}
lldb::SBError RunToBinaryEntry() {
lldb::SBError error;
if (!g_vsc.run_to_binary_entry)
return error;
if (g_vsc.stop_at_entry) {
g_vsc.SendOutput(OutputType::Console,
"RunToBinaryEntry is ignored due to StopOnEntry\n");
return error;
}
lldb::SBTarget target = g_vsc.debugger.GetSelectedTarget();
if (!target.IsValid())
return error;
lldb::SBFileSpec exe_file = target.GetExecutable();
if (!exe_file.IsValid())
return error;
lldb::SBModule exe_module = target.FindModule(exe_file);
if (!exe_module.IsValid()) {
g_vsc.SendOutput(OutputType::Console,
"RunToBinaryEntry failed: invalid executable module\n");
return error;
}
lldb::SBAddress entry_point = exe_module.GetObjectFileEntryPointAddress();
if (!entry_point.IsValid()) {
g_vsc.SendOutput(OutputType::Console,
"RunToBinaryEntry failed: can't find entry point\n");
return error;
}
lldb::SBBreakpoint entry_breakpoint =
target.BreakpointCreateBySBAddress(entry_point);
if (!entry_breakpoint.IsValid() || entry_breakpoint.GetNumLocations() == 0) {
g_vsc.SendOutput(OutputType::Console,
"RunToBinaryEntry failed: can't resolve the entry point breakpoint\n");
return error;
}
uint32_t old_stop_id = target.GetProcess().GetStopID();
entry_breakpoint.SetOneShot(true);
error = target.GetProcess().Continue();
if (error.Fail())
return error;
const uint64_t timeout_seconds = 600;
error = g_vsc.WaitForProcessToStop(timeout_seconds, old_stop_id);
if (error.Fail())
return error;
// Successfully got a process stop; we still need to check if the stop is what
// we expected.
if (entry_breakpoint.GetHitCount() == 0)
g_vsc.SendOutput(OutputType::Telemetry,
"RunToBinaryEntry failed: process stopped not at the "
"binary's entry point\n");
else
g_vsc.SendOutput(OutputType::Telemetry,
"RunToBinaryEntry success: Process stopped successfully "
"at the binary's entry point\n");
return error;
}
// "LaunchRequest": {
// "allOf": [ { "$ref": "#/definitions/Request" }, {
// "type": "object",
@ -1721,7 +1659,6 @@ void request_launch(const llvm::json::Object &request) {
std::vector<std::string> postRunCommands =
GetStrings(arguments, "postRunCommands");
g_vsc.stop_at_entry = GetBoolean(arguments, "stopOnEntry", false);
g_vsc.run_to_binary_entry = GetBoolean(arguments, "runToBinaryEntry", false);
const llvm::StringRef debuggerRoot = GetString(arguments, "debuggerRoot");
const uint64_t timeout_seconds = GetUnsigned(arguments, "timeout", 30);
@ -1804,9 +1741,6 @@ void request_launch(const llvm::json::Object &request) {
error = g_vsc.WaitForProcessToStop(timeout_seconds);
}
if (error.Success())
error = RunToBinaryEntry();
if (error.Fail()) {
response["success"] = llvm::json::Value(false);
EmplaceSafeString(response, "message", std::string(error.GetCString()));

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

@ -157,11 +157,6 @@
"description": "Automatically stop after launch.",
"default": false
},
"runToBinaryEntry": {
"type": "boolean",
"description": "run to program entry one-shot breakpoint during launch to ensure dependency modules are loaded.",
"default": false
},
"disableASLR": {
"type": "boolean",
"description": "Enable or disable Address space layout randomization if the debugger supports it.",