[Lldb-commits] [lldb] dd5505a - Revert "Make it possible for lldb to launch a remote binary with no local file."
Jim Ingham via lldb-commits
lldb-commits at lists.llvm.org
Tue Nov 16 16:46:27 PST 2021
Author: Jim Ingham
Date: 2021-11-16T16:46:21-08:00
New Revision: dd5505a8f2c75a903ec944b6e46aed2042610673
URL: https://github.com/llvm/llvm-project/commit/dd5505a8f2c75a903ec944b6e46aed2042610673
DIFF: https://github.com/llvm/llvm-project/commit/dd5505a8f2c75a903ec944b6e46aed2042610673.diff
LOG: Revert "Make it possible for lldb to launch a remote binary with no local file."
The reworking of the gdb client tests into the PlatformClientTestBase broke
the test for this. I did the mutatis mutandis for the move, but the test
still fails. Reverting till I have time to figure out why.
This reverts commit b715b79d54d5ca2d4e8c91089b8f6a9389d9dc48.
Added:
Modified:
lldb/source/Commands/CommandObjectProcess.cpp
lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
lldb/source/Target/Process.cpp
Removed:
lldb/test/API/functionalities/gdb_remote_client/TestNoLocalFile.py
################################################################################
diff --git a/lldb/source/Commands/CommandObjectProcess.cpp b/lldb/source/Commands/CommandObjectProcess.cpp
index 5fd1718e84840..8ce14f2a96d5e 100644
--- a/lldb/source/Commands/CommandObjectProcess.cpp
+++ b/lldb/source/Commands/CommandObjectProcess.cpp
@@ -159,12 +159,7 @@ class CommandObjectProcessLaunch : public CommandObjectProcessLaunchOrAttach {
// If our listener is nullptr, users aren't allows to launch
ModuleSP exe_module_sp = target->GetExecutableModule();
- // If the target already has an executable module, then use that. If it
- // doesn't then someone must be trying to launch using a path that will
- // make sense to the remote stub, but doesn't exist on the local host.
- // In that case use the ExecutableFile that was set in the target's
- // ProcessLaunchInfo.
- if (exe_module_sp == nullptr && !target->GetProcessLaunchInfo().GetExecutableFile()) {
+ if (exe_module_sp == nullptr) {
result.AppendError("no file in target, create a debug target using the "
"'target create' command");
return false;
@@ -224,17 +219,11 @@ class CommandObjectProcessLaunch : public CommandObjectProcessLaunchOrAttach {
if (!target_settings_argv0.empty()) {
m_options.launch_info.GetArguments().AppendArgument(
target_settings_argv0);
- if (exe_module_sp)
- m_options.launch_info.SetExecutableFile(
- exe_module_sp->GetPlatformFileSpec(), false);
- else
- m_options.launch_info.SetExecutableFile(target->GetProcessLaunchInfo().GetExecutableFile(), false);
+ m_options.launch_info.SetExecutableFile(
+ exe_module_sp->GetPlatformFileSpec(), false);
} else {
- if (exe_module_sp)
- m_options.launch_info.SetExecutableFile(
- exe_module_sp->GetPlatformFileSpec(), true);
- else
- m_options.launch_info.SetExecutableFile(target->GetProcessLaunchInfo().GetExecutableFile(), true);
+ m_options.launch_info.SetExecutableFile(
+ exe_module_sp->GetPlatformFileSpec(), true);
}
if (launch_args.GetArgumentCount() == 0) {
@@ -261,20 +250,11 @@ class CommandObjectProcessLaunch : public CommandObjectProcessLaunchOrAttach {
llvm::StringRef data = stream.GetString();
if (!data.empty())
result.AppendMessage(data);
- // If we didn't have a local executable, then we wouldn't have had an
- // executable module before launch.
- if (!exe_module_sp)
- exe_module_sp = target->GetExecutableModule();
- if (!exe_module_sp) {
- result.AppendWarning("Could not get executable module after launch.");
- } else {
-
- const char *archname =
- exe_module_sp->GetArchitecture().GetArchitectureName();
- result.AppendMessageWithFormat(
- "Process %" PRIu64 " launched: '%s' (%s)\n", process_sp->GetID(),
- exe_module_sp->GetFileSpec().GetPath().c_str(), archname);
- }
+ const char *archname =
+ exe_module_sp->GetArchitecture().GetArchitectureName();
+ result.AppendMessageWithFormat(
+ "Process %" PRIu64 " launched: '%s' (%s)\n", process_sp->GetID(),
+ exe_module_sp->GetFileSpec().GetPath().c_str(), archname);
result.SetStatus(eReturnStatusSuccessFinishResult);
result.SetDidChangeProcessState(true);
} else {
diff --git a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index 2233bf6758190..a666aeb8bb3f6 100644
--- a/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -677,133 +677,143 @@ Status ProcessGDBRemote::DoLaunch(lldb_private::Module *exe_module,
// LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
// ::LogSetLogFile ("/dev/stdout");
- error = EstablishConnectionIfNeeded(launch_info);
- if (error.Success()) {
- PseudoTerminal pty;
- const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
-
- PlatformSP platform_sp(GetTarget().GetPlatform());
- if (disable_stdio) {
- // set to /dev/null unless redirected to a file above
- if (!stdin_file_spec)
- stdin_file_spec.SetFile(FileSystem::DEV_NULL,
- FileSpec::Style::native);
- if (!stdout_file_spec)
- stdout_file_spec.SetFile(FileSystem::DEV_NULL,
- FileSpec::Style::native);
- if (!stderr_file_spec)
- stderr_file_spec.SetFile(FileSystem::DEV_NULL,
- FileSpec::Style::native);
- } else if (platform_sp && platform_sp->IsHost()) {
- // If the debugserver is local and we aren't disabling STDIO, lets use
- // a pseudo terminal to instead of relying on the 'O' packets for stdio
- // since 'O' packets can really slow down debugging if the inferior
- // does a lot of output.
- if ((!stdin_file_spec || !stdout_file_spec || !stderr_file_spec) &&
- !errorToBool(pty.OpenFirstAvailablePrimary(O_RDWR | O_NOCTTY))) {
- FileSpec secondary_name(pty.GetSecondaryName());
+ ObjectFile *object_file = exe_module->GetObjectFile();
+ if (object_file) {
+ error = EstablishConnectionIfNeeded(launch_info);
+ if (error.Success()) {
+ PseudoTerminal pty;
+ const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
+ PlatformSP platform_sp(GetTarget().GetPlatform());
+ if (disable_stdio) {
+ // set to /dev/null unless redirected to a file above
if (!stdin_file_spec)
- stdin_file_spec = secondary_name;
-
+ stdin_file_spec.SetFile(FileSystem::DEV_NULL,
+ FileSpec::Style::native);
if (!stdout_file_spec)
- stdout_file_spec = secondary_name;
-
+ stdout_file_spec.SetFile(FileSystem::DEV_NULL,
+ FileSpec::Style::native);
if (!stderr_file_spec)
- stderr_file_spec = secondary_name;
+ stderr_file_spec.SetFile(FileSystem::DEV_NULL,
+ FileSpec::Style::native);
+ } else if (platform_sp && platform_sp->IsHost()) {
+ // If the debugserver is local and we aren't disabling STDIO, lets use
+ // a pseudo terminal to instead of relying on the 'O' packets for stdio
+ // since 'O' packets can really slow down debugging if the inferior
+ // does a lot of output.
+ if ((!stdin_file_spec || !stdout_file_spec || !stderr_file_spec) &&
+ !errorToBool(pty.OpenFirstAvailablePrimary(O_RDWR | O_NOCTTY))) {
+ FileSpec secondary_name(pty.GetSecondaryName());
+
+ if (!stdin_file_spec)
+ stdin_file_spec = secondary_name;
+
+ if (!stdout_file_spec)
+ stdout_file_spec = secondary_name;
+
+ if (!stderr_file_spec)
+ stderr_file_spec = secondary_name;
+ }
+ LLDB_LOGF(
+ log,
+ "ProcessGDBRemote::%s adjusted STDIO paths for local platform "
+ "(IsHost() is true) using secondary: stdin=%s, stdout=%s, "
+ "stderr=%s",
+ __FUNCTION__,
+ stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
+ stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
+ stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
}
- LLDB_LOGF(
- log,
- "ProcessGDBRemote::%s adjusted STDIO paths for local platform "
- "(IsHost() is true) using secondary: stdin=%s, stdout=%s, "
- "stderr=%s",
- __FUNCTION__,
- stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
- stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
- stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
- }
- LLDB_LOGF(log,
- "ProcessGDBRemote::%s final STDIO paths after all "
- "adjustments: stdin=%s, stdout=%s, stderr=%s",
- __FUNCTION__,
- stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
- stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
- stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
-
- if (stdin_file_spec)
- m_gdb_comm.SetSTDIN(stdin_file_spec);
- if (stdout_file_spec)
- m_gdb_comm.SetSTDOUT(stdout_file_spec);
- if (stderr_file_spec)
- m_gdb_comm.SetSTDERR(stderr_file_spec);
-
- m_gdb_comm.SetDisableASLR(launch_flags & eLaunchFlagDisableASLR);
- m_gdb_comm.SetDetachOnError(launch_flags & eLaunchFlagDetachOnError);
-
- m_gdb_comm.SendLaunchArchPacket(
- GetTarget().GetArchitecture().GetArchitectureName());
-
- const char *launch_event_data = launch_info.GetLaunchEventData();
- if (launch_event_data != nullptr && *launch_event_data != '\0')
- m_gdb_comm.SendLaunchEventDataPacket(launch_event_data);
-
- if (working_dir) {
- m_gdb_comm.SetWorkingDir(working_dir);
- }
+ LLDB_LOGF(log,
+ "ProcessGDBRemote::%s final STDIO paths after all "
+ "adjustments: stdin=%s, stdout=%s, stderr=%s",
+ __FUNCTION__,
+ stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
+ stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
+ stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
- // Send the environment and the program + arguments after we connect
- m_gdb_comm.SendEnvironment(launch_info.GetEnvironment());
+ if (stdin_file_spec)
+ m_gdb_comm.SetSTDIN(stdin_file_spec);
+ if (stdout_file_spec)
+ m_gdb_comm.SetSTDOUT(stdout_file_spec);
+ if (stderr_file_spec)
+ m_gdb_comm.SetSTDERR(stderr_file_spec);
- {
- // Scope for the scoped timeout object
- GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm,
- std::chrono::seconds(10));
-
- int arg_packet_err = m_gdb_comm.SendArgumentsPacket(launch_info);
- if (arg_packet_err == 0) {
- std::string error_str;
- if (m_gdb_comm.GetLaunchSuccess(error_str)) {
- SetID(m_gdb_comm.GetCurrentProcessID());
+ m_gdb_comm.SetDisableASLR(launch_flags & eLaunchFlagDisableASLR);
+ m_gdb_comm.SetDetachOnError(launch_flags & eLaunchFlagDetachOnError);
+
+ m_gdb_comm.SendLaunchArchPacket(
+ GetTarget().GetArchitecture().GetArchitectureName());
+
+ const char *launch_event_data = launch_info.GetLaunchEventData();
+ if (launch_event_data != nullptr && *launch_event_data != '\0')
+ m_gdb_comm.SendLaunchEventDataPacket(launch_event_data);
+
+ if (working_dir) {
+ m_gdb_comm.SetWorkingDir(working_dir);
+ }
+
+ // Send the environment and the program + arguments after we connect
+ m_gdb_comm.SendEnvironment(launch_info.GetEnvironment());
+
+ {
+ // Scope for the scoped timeout object
+ GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm,
+ std::chrono::seconds(10));
+
+ int arg_packet_err = m_gdb_comm.SendArgumentsPacket(launch_info);
+ if (arg_packet_err == 0) {
+ std::string error_str;
+ if (m_gdb_comm.GetLaunchSuccess(error_str)) {
+ SetID(m_gdb_comm.GetCurrentProcessID());
+ } else {
+ error.SetErrorString(error_str.c_str());
+ }
} else {
- error.SetErrorString(error_str.c_str());
+ error.SetErrorStringWithFormat("'A' packet returned an error: %i",
+ arg_packet_err);
}
- } else {
- error.SetErrorStringWithFormat("'A' packet returned an error: %i",
- arg_packet_err);
}
- }
- if (GetID() == LLDB_INVALID_PROCESS_ID) {
- LLDB_LOGF(log, "failed to connect to debugserver: %s",
- error.AsCString());
- KillDebugserverProcess();
- return error;
- }
+ if (GetID() == LLDB_INVALID_PROCESS_ID) {
+ LLDB_LOGF(log, "failed to connect to debugserver: %s",
+ error.AsCString());
+ KillDebugserverProcess();
+ return error;
+ }
- StringExtractorGDBRemote response;
- if (m_gdb_comm.GetStopReply(response)) {
- SetLastStopPacket(response);
+ StringExtractorGDBRemote response;
+ if (m_gdb_comm.GetStopReply(response)) {
+ SetLastStopPacket(response);
- const ArchSpec &process_arch = m_gdb_comm.GetProcessArchitecture();
+ const ArchSpec &process_arch = m_gdb_comm.GetProcessArchitecture();
- if (process_arch.IsValid()) {
- GetTarget().MergeArchitecture(process_arch);
- } else {
- const ArchSpec &host_arch = m_gdb_comm.GetHostArchitecture();
- if (host_arch.IsValid())
- GetTarget().MergeArchitecture(host_arch);
- }
+ if (process_arch.IsValid()) {
+ GetTarget().MergeArchitecture(process_arch);
+ } else {
+ const ArchSpec &host_arch = m_gdb_comm.GetHostArchitecture();
+ if (host_arch.IsValid())
+ GetTarget().MergeArchitecture(host_arch);
+ }
- SetPrivateState(SetThreadStopInfo(response));
+ SetPrivateState(SetThreadStopInfo(response));
- if (!disable_stdio) {
- if (pty.GetPrimaryFileDescriptor() != PseudoTerminal::invalid_fd)
- SetSTDIOFileDescriptor(pty.ReleasePrimaryFileDescriptor());
+ if (!disable_stdio) {
+ if (pty.GetPrimaryFileDescriptor() != PseudoTerminal::invalid_fd)
+ SetSTDIOFileDescriptor(pty.ReleasePrimaryFileDescriptor());
+ }
}
+ } else {
+ LLDB_LOGF(log, "failed to connect to debugserver: %s", error.AsCString());
}
} else {
- LLDB_LOGF(log, "failed to connect to debugserver: %s", error.AsCString());
+ // Set our user ID to an invalid process ID.
+ SetID(LLDB_INVALID_PROCESS_ID);
+ error.SetErrorStringWithFormat(
+ "failed to get object file from '%s' for arch %s",
+ exe_module->GetFileSpec().GetFilename().AsCString(),
+ exe_module->GetArchitecture().GetArchitectureName());
}
return error;
}
diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp
index 3fbd6434e8683..519db0482e4ba 100644
--- a/lldb/source/Target/Process.cpp
+++ b/lldb/source/Target/Process.cpp
@@ -2493,125 +2493,118 @@ Status Process::Launch(ProcessLaunchInfo &launch_info) {
m_process_input_reader.reset();
Module *exe_module = GetTarget().GetExecutableModulePointer();
-
- // The "remote executable path" is hooked up to the local Executable
- // module. But we should be able to debug a remote process even if the
- // executable module only exists on the remote. However, there needs to
- // be a way to express this path, without actually having a module.
- // The way to do that is to set the ExecutableFile in the LaunchInfo.
- // Figure that out here:
-
- FileSpec exe_spec_to_use;
if (!exe_module) {
- if (!launch_info.GetExecutableFile()) {
- error.SetErrorString("executable module does not exist");
- return error;
- }
- exe_spec_to_use = launch_info.GetExecutableFile();
- } else
- exe_spec_to_use = exe_module->GetFileSpec();
-
- if (exe_module && FileSystem::Instance().Exists(exe_module->GetFileSpec())) {
+ error.SetErrorString("executable module does not exist");
+ return error;
+ }
+
+ char local_exec_file_path[PATH_MAX];
+ char platform_exec_file_path[PATH_MAX];
+ exe_module->GetFileSpec().GetPath(local_exec_file_path,
+ sizeof(local_exec_file_path));
+ exe_module->GetPlatformFileSpec().GetPath(platform_exec_file_path,
+ sizeof(platform_exec_file_path));
+ if (FileSystem::Instance().Exists(exe_module->GetFileSpec())) {
// Install anything that might need to be installed prior to launching.
// For host systems, this will do nothing, but if we are connected to a
// remote platform it will install any needed binaries
error = GetTarget().Install(&launch_info);
if (error.Fail())
return error;
- }
- // Listen and queue events that are broadcasted during the process launch.
- ListenerSP listener_sp(Listener::MakeListener("LaunchEventHijack"));
- HijackProcessEvents(listener_sp);
- auto on_exit = llvm::make_scope_exit([this]() { RestoreProcessEvents(); });
- if (PrivateStateThreadIsValid())
- PausePrivateStateThread();
+ // Listen and queue events that are broadcasted during the process launch.
+ ListenerSP listener_sp(Listener::MakeListener("LaunchEventHijack"));
+ HijackProcessEvents(listener_sp);
+ auto on_exit = llvm::make_scope_exit([this]() { RestoreProcessEvents(); });
- error = WillLaunch(exe_module);
- if (error.Success()) {
- const bool restarted = false;
- SetPublicState(eStateLaunching, restarted);
- m_should_detach = false;
+ if (PrivateStateThreadIsValid())
+ PausePrivateStateThread();
- if (m_public_run_lock.TrySetRunning()) {
- // Now launch using these arguments.
- error = DoLaunch(exe_module, launch_info);
- } else {
- // This shouldn't happen
- error.SetErrorString("failed to acquire process run lock");
- }
+ error = WillLaunch(exe_module);
+ if (error.Success()) {
+ const bool restarted = false;
+ SetPublicState(eStateLaunching, restarted);
+ m_should_detach = false;
- if (error.Fail()) {
- if (GetID() != LLDB_INVALID_PROCESS_ID) {
- SetID(LLDB_INVALID_PROCESS_ID);
- const char *error_string = error.AsCString();
- if (error_string == nullptr)
- error_string = "launch failed";
- SetExitStatus(-1, error_string);
+ if (m_public_run_lock.TrySetRunning()) {
+ // Now launch using these arguments.
+ error = DoLaunch(exe_module, launch_info);
+ } else {
+ // This shouldn't happen
+ error.SetErrorString("failed to acquire process run lock");
}
- } else {
- EventSP event_sp;
- // Now wait for the process to launch and return control to us, and then
- // call DidLaunch:
- StateType state = WaitForProcessStopPrivate(event_sp, seconds(10));
-
- if (state == eStateInvalid || !event_sp) {
- // We were able to launch the process, but we failed to catch the
- // initial stop.
- error.SetErrorString("failed to catch stop after launch");
- SetExitStatus(0, "failed to catch stop after launch");
- Destroy(false);
- } else if (state == eStateStopped || state == eStateCrashed) {
- DidLaunch();
-
- DynamicLoader *dyld = GetDynamicLoader();
- if (dyld)
- dyld->DidLaunch();
-
- GetJITLoaders().DidLaunch();
-
- SystemRuntime *system_runtime = GetSystemRuntime();
- if (system_runtime)
- system_runtime->DidLaunch();
-
- if (!m_os_up)
- LoadOperatingSystemPlugin(false);
-
- // We successfully launched the process and stopped, now it the
- // right time to set up signal filters before resuming.
- UpdateAutomaticSignalFiltering();
-
- // Note, the stop event was consumed above, but not handled. This
- // was done to give DidLaunch a chance to run. The target is either
- // stopped or crashed. Directly set the state. This is done to
- // prevent a stop message with a bunch of spurious output on thread
- // status, as well as not pop a ProcessIOHandler.
- // We are done with the launch hijack listener, and this stop should
- // go to the public state listener:
- RestoreProcessEvents();
- SetPublicState(state, false);
-
- if (PrivateStateThreadIsValid())
- ResumePrivateStateThread();
- else
- StartPrivateStateThread();
+ if (error.Fail()) {
+ if (GetID() != LLDB_INVALID_PROCESS_ID) {
+ SetID(LLDB_INVALID_PROCESS_ID);
+ const char *error_string = error.AsCString();
+ if (error_string == nullptr)
+ error_string = "launch failed";
+ SetExitStatus(-1, error_string);
+ }
+ } else {
+ EventSP event_sp;
+
+ // Now wait for the process to launch and return control to us, and then
+ // call DidLaunch:
+ StateType state = WaitForProcessStopPrivate(event_sp, seconds(10));
+
+ if (state == eStateInvalid || !event_sp) {
+ // We were able to launch the process, but we failed to catch the
+ // initial stop.
+ error.SetErrorString("failed to catch stop after launch");
+ SetExitStatus(0, "failed to catch stop after launch");
+ Destroy(false);
+ } else if (state == eStateStopped || state == eStateCrashed) {
+ DidLaunch();
+
+ DynamicLoader *dyld = GetDynamicLoader();
+ if (dyld)
+ dyld->DidLaunch();
+
+ GetJITLoaders().DidLaunch();
+
+ SystemRuntime *system_runtime = GetSystemRuntime();
+ if (system_runtime)
+ system_runtime->DidLaunch();
+
+ if (!m_os_up)
+ LoadOperatingSystemPlugin(false);
+
+ // We successfully launched the process and stopped, now it the
+ // right time to set up signal filters before resuming.
+ UpdateAutomaticSignalFiltering();
+
+ // Note, the stop event was consumed above, but not handled. This
+ // was done to give DidLaunch a chance to run. The target is either
+ // stopped or crashed. Directly set the state. This is done to
+ // prevent a stop message with a bunch of spurious output on thread
+ // status, as well as not pop a ProcessIOHandler.
+ // We are done with the launch hijack listener, and this stop should
+ // go to the public state listener:
+ RestoreProcessEvents();
+ SetPublicState(state, false);
+
+ if (PrivateStateThreadIsValid())
+ ResumePrivateStateThread();
+ else
+ StartPrivateStateThread();
- // Target was stopped at entry as was intended. Need to notify the
- // listeners about it.
- if (state == eStateStopped &&
- launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
+ // Target was stopped at entry as was intended. Need to notify the
+ // listeners about it.
+ if (state == eStateStopped &&
+ launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
+ HandlePrivateEvent(event_sp);
+ } else if (state == eStateExited) {
+ // We exited while trying to launch somehow. Don't call DidLaunch
+ // as that's not likely to work, and return an invalid pid.
HandlePrivateEvent(event_sp);
- } else if (state == eStateExited) {
- // We exited while trying to launch somehow. Don't call DidLaunch
- // as that's not likely to work, and return an invalid pid.
- HandlePrivateEvent(event_sp);
+ }
}
}
} else {
- std::string local_exec_file_path = exe_spec_to_use.GetPath();
error.SetErrorStringWithFormat("file doesn't exist: '%s'",
- local_exec_file_path.c_str());
+ local_exec_file_path);
}
return error;
diff --git a/lldb/test/API/functionalities/gdb_remote_client/TestNoLocalFile.py b/lldb/test/API/functionalities/gdb_remote_client/TestNoLocalFile.py
deleted file mode 100644
index fd9dc3ef592b1..0000000000000
--- a/lldb/test/API/functionalities/gdb_remote_client/TestNoLocalFile.py
+++ /dev/null
@@ -1,88 +0,0 @@
-import lldb
-from lldbsuite.test.lldbtest import *
-from lldbsuite.test.decorators import *
-from gdbclientutils import *
-
-
-class TestNoLocalFile(GDBRemoteTestBase):
- """ Test the case where there is NO local copy of the file
- being debugged. We shouldn't immediately error out, but
- rather lldb should ask debugserver if it knows about the file. """
-
-
- @skipIfXmlSupportMissing
- def test(self):
- self.absent_file = '/nosuch_dir/nosuch_subdir/nosuch_executable'
- self.a_packet_file = None
- class MyResponder(MockGDBServerResponder):
- def __init__(self, testcase):
- MockGDBServerResponder.__init__(self)
- self.after_launch = False
- self.testcase = testcase
- self.current_thread = 0
-
- def A(self, packet):
- # This is the main test, we want to see that lldb DID send the
- # A packet to get debugserver to load the file.
- # Skip the length and second length:
- a_arr = packet.split(",")
- self.testcase.a_packet_file = bytearray.fromhex(a_arr[2]).decode()
- return "OK"
-
- def qXferRead(self, obj, annex, offset, length):
- if annex == "target.xml":
- return """<?xml version="1.0"?>
- <target version="1.0">
- <architecture>i386:x86-64</architecture>
- <feature name="org.gnu.gdb.i386.core">
- <reg name="rip" bitsize="64" regnum="0" type="code_ptr" group="general"/>
- </feature>
- </target>""", False
- else:
- return None, False
-
- def qC(self):
- if not self.after_launch:
- return "QC0"
- return "0"
-
- def qfThreadInfo(self):
- if not self.after_launch:
- return "OK"
- return "m0"
-
- def qsThreadInfo(self):
- if not self.after_launch:
- return "OK"
- return "l"
-
- def qLaunchSuccess(self):
- return "OK"
-
- def qProcessInfo(self):
- return "$pid:10b70;parent-pid:10b20;real-uid:1f6;real-gid:14;effective-uid:1f6;effective-gid:14;cputype:1000007;cpusubtype:8;ptrsize:8;ostype:macosx;vendor:apple;endian:little;"
-
-
- error = lldb.SBError()
- self.server.responder = MyResponder(self)
- target = self.dbg.CreateTarget(None, "x86_64-apple-macosx", "remote-macosx", False, error)
- self.assertSuccess(error, "Made a valid target")
- launch_info = target.GetLaunchInfo()
- launch_info.SetExecutableFile(lldb.SBFileSpec(self.absent_file), True)
- flags = launch_info.GetLaunchFlags()
- flags |= lldb.eLaunchFlagStopAtEntry
- launch_info.SetLaunchFlags(flags)
-
- process = self.connect(target)
- self.assertTrue(process.IsValid(), "Process is valid")
-
- # We need to fetch the connected event:
- lldbutil.expect_state_changes(self, self.dbg.GetListener(), process, [lldb.eStateConnected])
-
- self.server.responder.after_launch = True
-
- process = target.Launch(launch_info, error)
- self.assertSuccess(error, "Successfully launched.")
- self.assertEqual(process.GetState(), lldb.eStateStopped, "Should be stopped at entry")
- self.assertIsNotNone(self.a_packet_file, "A packet was sent")
- self.assertEqual(self.absent_file, self.a_packet_file, "The A packet file was correct")
More information about the lldb-commits
mailing list