[lldb] Introduce PlatformQemuUser

[labath]

Summary

This adds a new platform class, whose job is to enable running
(debugging) executables under qemu.

(For general information about qemu, I recommend reading the RFC thread
on lldb-dev
https://lists.llvm.org/pipermail/lldb-dev/2021-October/017106.html.)

This initial patch implements the necessary boilerplate as well as the
minimal amount of functionality needed to actually be able to do
something useful (which, in this case means debugging a fully statically
linked executable).

The knobs necessary to emulate dynamically linked programs, as well as
to control other aspects of qemu operation (the emulated cpu, for
instance) will be added in subsequent patches. Same goes for the ability
to automatically bind to the executables of the emulated architecture.

Currently only two settings are available:

• architecture: the architecture that we should emulate
• emulator-path: the path to the emulator

Even though this patch is relatively small, it doesn't lack subtleties
that are worth calling out explicitly:

• named sockets: qemu supports tcp and unix socket connections, both of them in the "forward connect" mode (qemu listening, lldb connecting). Forward TCP connections are impossible to realise in a race-free way. This is the reason why I chose unix sockets as they have larger, more structured names, which can guarantee that there are no collisions between concurrent connection attempts.
• the above means that this code will not work on windows. I don't think that's an issue since user mode qemu does not support windows anyway.
• Right now, I am leaving the code enabled for windows, but maybe it would be better to disable it (otoh, disabling it means windows developers can't check they don't break it)
• qemu also does not support macOS, so one could contemplate disabling it there too. However, macOS does support named sockets, so one can even run the (mock) qemu tests there, and I think it'd be a shame to lose that.
• some things in this patch are called "Qemu" (the plugin folder, for instance), while others (e.g., the class) have "QemuUser" in their name. I did this intentionally to make room for a hypothetical system-mode qemu plugin. However, that may have been premature...

[mgorny]

lldb/packages/Python/lldbsuite/test/gdbclientutils.py

403

It's customary (read: PEP8) to use two empty lines between global-scope stuff like classes (and then one line between functions inside the class).

lldb/test/API/qemu/TestQemuLaunch.py

32

%r will use the repr() form, i.e. suitable for direct reuse in Python with the right escaping and so on.

43–44

Wouldn't it make sense to reverse these two? i.e. if it fails, then platform is unlikely to be correct, is it?

lldb/test/API/qemu/qemu.py

39

Oh no, trailing empty line!

[labath]

lldb/packages/Python/lldbsuite/test/gdbclientutils.py

403

Ok, sounds good.

lldb/test/API/qemu/TestQemuLaunch.py

32

good point. thanks.

43–44

Yeah, I suppose it does.

lldb/test/API/qemu/qemu.py

39

:P

[labath]

Address Michał's feedback.

[mgorny]

That said, I wonder if we should use some formatter (e.g. black) for Python files. While I can't really say I like black's coding style, it's quite popular and using some formatter would be consistent with using clang-format for C++ code.

[DavidSpickett]

qemu also does not support macOS

Do you mean qemu-user here?

I agree being able to run the tests there is nice.

[DavidSpickett]

lldb/packages/Python/lldbsuite/test/gdbclientutils.py

505

Is this something that happens every so often during testing and can be mostly ignored?

Just wondering if it's fatal to the test in which case, just remove the try/except and let this raise.

lldb/source/Plugins/Platform/Qemu/PlatformQemuProperties.td

11 ↗

(On Diff #389443)

Do we handle relative paths for this? My assumption would be yes and if the binary is on PATH we'd also find it.

If not, worth noting the caveats.

lldb/source/Plugins/Platform/Qemu/PlatformQemuUser.cpp

85 ↗

(On Diff #389443)

Is this where the sort of priority behaviour we talked about happens? Meaning qemu-user not claiming a program file unless specifically asked for. (I think that's what force=true would mean)

Not particularly bothered if it isn't, just trying to understand what the arguments mean.

lldb/source/Plugins/Platform/Qemu/PlatformQemuUser.h

46 ↗

(On Diff #389443)

Is this just boilerplate for now? Seems like it should somehow delegate/copy what PlatformLinux does.
(but I get that you can't make a new platform class without some implementation)

lldb/test/API/qemu/TestQemuLaunch.py

33

You can make this a bit neater by doing:

e.write("\n".join([
  "#! %s\n"%sys.executable,
  "import runpy",
  "import sys",
  "sys.path = %r\n"%sys.path,
  "runpy.run_path(%r, run_name='__main__')\n" % self.getSourcePath("qemu.py")])

Or if you want to write one string:

from textwrap import dedent
<...>
e.write(dedent("""\
<...>""".format(<args>))

Dedent will remove the common indentation from the lines. But you end up with all the formatting args at the end so it's not as straightforward to read.

Regardless of all that, adding spaces around the % would help the readability:

"sys.path = %r\n" % sys.path

45

Comment here that this is launching the fake qemu not a program file?

lldb/test/API/qemu/main.c

2

Comment here that this is never actually run? (I was confused why this would return 0 but you check for 0x47 above)

I assume something in the test framework expects there to be a sourcefile even if we don't need one.

lldb/test/API/qemu/qemu.py

23

Double space here.

[DavidSpickett]

some things in this patch are called "Qemu" (the plugin folder, for instance)

I wouldn't pay much attention to the qemu-system idea, it was just a hypothetical from me. Unless it's something that you would call a public API. Like the platform's name for example, but you've made that specific so that's fine.

Anything else can be shuffled around if qemu-system ever happens.

[labath]

In D114509#3151461, @DavidSpickett wrote:

qemu also does not support macOS

Do you mean qemu-user here?

Yes, definitely.

In D114509#3151581, @DavidSpickett wrote:

some things in this patch are called "Qemu" (the plugin folder, for instance)

I wouldn't pay much attention to the qemu-system idea, it was just a hypothetical from me. Unless it's something that you would call a public API. Like the platform's name for example, but you've made that specific so that's fine.

Anything else can be shuffled around if qemu-system ever happens.

OK, I've renamed everything into qemu-user. The platform name is pretty much the only user-visible name here, but I would say that is set in stone either.

lldb/packages/Python/lldbsuite/test/gdbclientutils.py

505

The trick here is that in the "normal" (gdb-client tests), this code gets executed on a separate thread. Raising an exception will not terminate the test. Or at least, not in a clean way, but instead if will confuse the hell out of everything. So instead, this just prints the exception (as does the try block below) and lets the main thread abort the test when it fails to connect.

lldb/source/Plugins/Platform/Qemu/PlatformQemuProperties.td

11 ↗

(On Diff #389443)

Relative paths work, but I'm not sure how much I want to advertise them. Searching the PATH does not currently work, but I like the idea. I can do it in a follow-up patch, where I wanted to automatically try to guess the emulator binary based on the selected architecture.

lldb/source/Plugins/Platform/Qemu/PlatformQemuUser.cpp

85 ↗

(On Diff #389443)

Pretty much yes. force=true gets passed when the user explicitly requests a platform (platform select, target create --platform, etc.). But there is still the negotiation that happens through the GetSupportedArchitectures function (so a bare "target create" would only select qemu-user if it is the currently selected platform and it matches the architecture of the file). I'm leaving the fancier selection logic to later patches.

lldb/source/Plugins/Platform/Qemu/PlatformQemuUser.h

46 ↗

(On Diff #389443)

Yeah, the idea is that this (and other functions) will eventually delegate to the host platform implementation.

lldb/test/API/qemu/main.c

2

I don't really need a source file, but I do need a realistic looking-executable so I can "run" it. A real qemu, will actually emulate the file, and respond accordingly, but that's not interesting for the tests here, as that is just standard gdb-remote stuff. The main thing that needs to be checked here is that qemu is being invoked with the right arguments.

I contemplated just yaml2obj-ing a small binary here, but the thing which made that difficult was that this should be a valid binary for the host OS (a linux binary on linux, a freebsd one on freebsd, etc). The easiest way to produce that is to use the compiler. The downside to that is that it makes it hard to produce foreign-architecture binaries, and that's a bridge I'll have to cross when I get there. I'm hoping I won't need many tests like that.

[labath]

feedback David

[labath]

In D114509#3151035, @mgorny wrote:

That said, I wonder if we should use some formatter (e.g. black) for Python files. While I can't really say I like black's coding style, it's quite popular and using some formatter would be consistent with using clang-format for C++ code.

lldb python files were formatted with autopep8 during the Great Reformat. I don't know what the output of black looks like, but autopep8 is not that good.

Overall I would be supportive of using (any) automated python formatter. I think the main thing missing is for some one to set up the integration.

[DavidSpickett]

LGTM

[labath]

Thanks for the review. I'm going to wait until the US folks get back before submitting this.

lldb/packages/Python/lldbsuite/test/gdbclientutils.py

class MockGDBServerResponder:
     Raised when we receive a packet for which there is no default action.
     Override the responder class to implement behavior suitable for the test at
     hand.
     """
     class UnexpectedPacketException(Exception):
         pass
 
 
-class ServerSocket:
+class ServerChannel:
     """
     A wrapper class for TCP or pty-based server.
     """
 
     def get_connect_address(self):
         """Get address for the client to connect to."""
 
     def get_connect_url(self):
class ServerChannel:
 
     def recv(self):
         """Receive a data packet from the connected client."""
 
     def sendall(self, data):
         """Send the data to the connected client."""
 
 
-class TCPServerSocket(ServerSocket):
-    def __init__(self):
-        family, type, proto, _, addr = socket.getaddrinfo(
-                "localhost", 0, proto=socket.IPPROTO_TCP)[0]
+class ServerSocket(ServerChannel):
+    def __init__(self, family, type, proto, addr):
         self._server_socket = socket.socket(family, type, proto)
         self._connection = None
 
         self._server_socket.bind(addr)
         self._server_socket.listen(1)
 
-    def get_connect_address(self):
-        return "[{}]:{}".format(*self._server_socket.getsockname())
-
-    def get_connect_url(self):
-        return "connect://" + self.get_connect_address()
-
     def close_server(self):
         self._server_socket.close()
 
     def accept(self):
         assert self._connection is None
         # accept() is stubborn and won't fail even when the socket is
         # shutdown, so we'll use a timeout
         self._server_socket.settimeout(30.0)
class ServerSocket(ServerChannel):
 
     def recv(self):
         assert self._connection is not None
         return self._connection.recv(4096)
 
     def sendall(self, data):
         assert self._connection is not None
         return self._connection.sendall(data)
 
 
-class PtyServerSocket(ServerSocket):
+class TCPServerSocket(ServerSocket):
+    def __init__(self):
+        family, type, proto, _, addr = socket.getaddrinfo(
+                "localhost", 0, proto=socket.IPPROTO_TCP)[0]
+        super().__init__(family, type, proto, addr)
+
+    def get_connect_address(self):
+        return "[{}]:{}".format(*self._server_socket.getsockname())
+
+    def get_connect_url(self):
+        return "connect://" + self.get_connect_address()
+
+
+class UnixServerSocket(ServerSocket):
+    def __init__(self, addr):
+        super().__init__(socket.AF_UNIX, socket.SOCK_STREAM, 0, addr)
+
+    def get_connect_address(self):
+        return self._server_socket.getsockname()
+
+    def get_connect_url(self):
+        return "unix-connect://" + self.get_connect_address()
+
+
+class PtyServerSocket(ServerChannel):
     def __init__(self):
         import pty
         import tty
         primary, secondary = pty.openpty()
         tty.setraw(primary)
         self._primary = io.FileIO(primary, 'r+b')
         self._secondary = io.FileIO(secondary, 'r+b')
 
def get_connect_url(self):
         return self._socket.get_connect_url()
 
     def run(self):
         # For testing purposes, we only need to worry about one client
         # connecting just one time.
         try:
             self._socket.accept()
         except:
+            traceback.print_exc()
             return
         self._shouldSendAck = True
         self._receivedData = ""
         self._receivedDataOffset = 0
         data = None
         try:
             while True:
                 data = seven.bitcast_to_string(self._socket.recv())

lldb/source/Plugins/Platform/CMakeLists.txt

 add_subdirectory(Android)
 add_subdirectory(FreeBSD)
 add_subdirectory(gdb-server)
 add_subdirectory(Linux)
 add_subdirectory(MacOSX)
 add_subdirectory(NetBSD)
 add_subdirectory(OpenBSD)
 add_subdirectory(POSIX)
+add_subdirectory(QemuUser)
 add_subdirectory(Windows)

lldb/source/Plugins/Platform/QemuUser/CMakeLists.txt

+lldb_tablegen(PlatformQemuUserProperties.inc -gen-lldb-property-defs
+  SOURCE PlatformQemuUserProperties.td
+  TARGET LLDBPluginPlatformQemuUserPropertiesGen)
+
+lldb_tablegen(PlatformQemuUserPropertiesEnum.inc -gen-lldb-property-enum-defs
+  SOURCE PlatformQemuUserProperties.td
+  TARGET LLDBPluginPlatformQemuUserPropertiesEnumGen)
+
+add_lldb_library(lldbPluginPlatformQemuUser PLUGIN
+  PlatformQemuUser.cpp
+
+  LINK_LIBS
+    lldbUtility
+  LINK_COMPONENTS
+    Support
+    )
+
+add_dependencies(lldbPluginPlatformQemuUser
+  LLDBPluginPlatformQemuUserPropertiesGen
+  LLDBPluginPlatformQemuUserPropertiesEnumGen)

lldb/source/Plugins/Platform/QemuUser/PlatformQemuUser.h

+//===-- PlatformQemuUser.h ------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Target/Platform.h"
+
+namespace lldb_private {
+
+class PlatformQemuUser : public Platform {
+public:
+  static void Initialize();
+  static void Terminate();
+
+  static llvm::StringRef GetPluginNameStatic() { return "qemu-user"; }
+  static llvm::StringRef GetPluginDescriptionStatic();
+
+  llvm::StringRef GetPluginName() override { return GetPluginNameStatic(); }
+  llvm::StringRef GetDescription() override {
+    return GetPluginDescriptionStatic();
+  }
+
+  UserIDResolver &GetUserIDResolver() override {
+    return HostInfo::GetUserIDResolver();
+  }
+
+  std::vector<ArchSpec> GetSupportedArchitectures() override;
+
+  lldb::ProcessSP DebugProcess(ProcessLaunchInfo &launch_info,
+                               Debugger &debugger, Target &target,
+                               Status &error) override;
+
+  lldb::ProcessSP Attach(ProcessAttachInfo &attach_info, Debugger &debugger,
+                         Target *target, Status &status) override {
+    status.SetErrorString("Not supported");
+    return nullptr;
+  }
+
+  bool IsConnected() const override { return true; }
+
+  void CalculateTrapHandlerSymbolNames() override {}
+
+  Environment GetEnvironment() override { return Host::GetEnvironment(); }
+
+private:
+  static lldb::PlatformSP CreateInstance(bool force, const ArchSpec *arch);
+  static void DebuggerInitialize(Debugger &debugger);
+
+  PlatformQemuUser() : Platform(/*is_host=*/false) {}
+};
+
+} // namespace lldb_private

lldb/source/Plugins/Platform/QemuUser/PlatformQemuUser.cpp

+//===-- PlatformQemuUser.cpp ----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "Plugins/Platform/QemuUser/PlatformQemuUser.h"
+#include "Plugins/Process/gdb-remote/ProcessGDBRemote.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Host/FileSystem.h"
+#include "lldb/Host/ProcessLaunchInfo.h"
+#include "lldb/Interpreter/OptionValueProperties.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Utility/Listener.h"
+#include "lldb/Utility/Log.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+LLDB_PLUGIN_DEFINE(PlatformQemuUser)
+
+#define LLDB_PROPERTIES_platformqemuuser
+#include "PlatformQemuUserProperties.inc"
+
+enum {
+#define LLDB_PROPERTIES_platformqemuuser
+#include "PlatformQemuUserPropertiesEnum.inc"
+};
+
+class PluginProperties : public Properties {
+public:
+  PluginProperties() {
+    m_collection_sp = std::make_shared<OptionValueProperties>(
+        ConstString(PlatformQemuUser::GetPluginNameStatic()));
+    m_collection_sp->Initialize(g_platformqemuuser_properties);
+  }
+
+  llvm::StringRef GetArchitecture() {
+    return m_collection_sp->GetPropertyAtIndexAsString(
+        nullptr, ePropertyArchitecture, "");
+  }
+
+  FileSpec GetEmulatorPath() {
+    return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr,
+                                                         ePropertyEmulatorPath);
+  }
+};
+
+static PluginProperties &GetGlobalProperties() {
+  static PluginProperties g_settings;
+  return g_settings;
+}
+
+llvm::StringRef PlatformQemuUser::GetPluginDescriptionStatic() {
+  return "Platform for debugging binaries under user mode qemu";
+}
+
+void PlatformQemuUser::Initialize() {
+  PluginManager::RegisterPlugin(
+      GetPluginNameStatic(), GetPluginDescriptionStatic(),
+      PlatformQemuUser::CreateInstance, PlatformQemuUser::DebuggerInitialize);
+}
+
+void PlatformQemuUser::Terminate() {
+  PluginManager::UnregisterPlugin(PlatformQemuUser::CreateInstance);
+}
+
+void PlatformQemuUser::DebuggerInitialize(Debugger &debugger) {
+  if (!PluginManager::GetSettingForPlatformPlugin(
+          debugger, ConstString(GetPluginNameStatic()))) {
+    PluginManager::CreateSettingForPlatformPlugin(
+        debugger, GetGlobalProperties().GetValueProperties(),
+        ConstString("Properties for the qemu-user platform plugin."),
+        /*is_global_property=*/true);
+  }
+}
+
+PlatformSP PlatformQemuUser::CreateInstance(bool force, const ArchSpec *arch) {
+  if (force)
+    return PlatformSP(new PlatformQemuUser());
+  return nullptr;
+}
+
+std::vector<ArchSpec> PlatformQemuUser::GetSupportedArchitectures() {
+  llvm::Triple triple = HostInfo::GetArchitecture().GetTriple();
+  triple.setEnvironment(llvm::Triple::UnknownEnvironment);
+  triple.setArchName(GetGlobalProperties().GetArchitecture());
+  if (triple.getArch() != llvm::Triple::UnknownArch)
+    return {ArchSpec(triple)};
+  return {};
+}
+
+static auto get_arg_range(const Args &args) {
+  return llvm::make_range(args.GetArgumentArrayRef().begin(),
+                          args.GetArgumentArrayRef().end());
+}
+
+lldb::ProcessSP PlatformQemuUser::DebugProcess(ProcessLaunchInfo &launch_info,
+                                               Debugger &debugger,
+                                               Target &target, Status &error) {
+  Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM);
+
+  std::string qemu = GetGlobalProperties().GetEmulatorPath().GetPath();
+
+  llvm::SmallString<0> socket_model, socket_path;
+  HostInfo::GetProcessTempDir().GetPath(socket_model);
+  llvm::sys::path::append(socket_model, "qemu-%%%%%%%%.socket");
+  do {
+    llvm::sys::fs::createUniquePath(socket_model, socket_path, false);
+  } while (FileSystem::Instance().Exists(socket_path));
+
+  Args args(
+      {qemu, "-g", socket_path, launch_info.GetExecutableFile().GetPath()});
+  for (size_t i = 1; i < launch_info.GetArguments().size(); ++i)
+    args.AppendArgument(launch_info.GetArguments()[i].ref());
+
+  LLDB_LOG(log, "{0} -> {1}", get_arg_range(launch_info.GetArguments()),
+           get_arg_range(args));
+
+  launch_info.SetArguments(args, true);
+  launch_info.SetLaunchInSeparateProcessGroup(true);
+  launch_info.GetFlags().Clear(eLaunchFlagDebug);
+  launch_info.SetMonitorProcessCallback(ProcessLaunchInfo::NoOpMonitorCallback,
+                                        false);
+
+  error = Host::LaunchProcess(launch_info);
+  if (error.Fail())
+    return nullptr;
+
+  ProcessSP process_sp = target.CreateProcess(
+      launch_info.GetListener(),
+      process_gdb_remote::ProcessGDBRemote::GetPluginNameStatic(), nullptr,
+      true);
+  ListenerSP listener_sp =
+      Listener::MakeListener("lldb.platform_qemu_user.debugprocess");
+  launch_info.SetHijackListener(listener_sp);
+  Process::ProcessEventHijacker hijacker(*process_sp, listener_sp);
+
+  error = process_sp->ConnectRemote(("unix-connect://" + socket_path).str());
+  if (error.Fail())
+    return nullptr;
+
+  process_sp->WaitForProcessToStop(llvm::None, nullptr, false, listener_sp);
+  return process_sp;
+}

lldb/source/Plugins/Platform/QemuUser/PlatformQemuUserProperties.td

+include "../../../../include/lldb/Core/PropertiesBase.td"
+
+let Definition = "platformqemuuser" in {
+  def Architecture: Property<"architecture", "String">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"Architecture to emulate.">;
+  def EmulatorPath: Property<"emulator-path", "FileSpec">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"Path to the emulator binary.">;
+}

lldb/test/API/qemu/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/qemu/TestQemuLaunch.py

+from __future__ import print_function
+import lldb
+import unittest
+import os
+import json
+import stat
+import sys
+from textwrap import dedent
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+from lldbsuite.test.gdbclientutils import *
+
+
+@skipIfRemote
+@skipIfWindows
+class TestQemuLaunch(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def set_emulator_setting(self, name, value):
+        self.runCmd("settings set platform.plugin.qemu-user.%s %s" %
+                (name, value))
+
+    def setUp(self):
+        super().setUp()
+        emulator = self.getBuildArtifact("qemu.py")
+        with os.fdopen(os.open(emulator, os.O_WRONLY|os.O_CREAT, stat.S_IRWXU),
+                "w") as e:
+
+            e.write(dedent("""\
+                    #! {exec!s}
+
+                    import runpy
+                    import sys
+
+                    sys.path = {path!r}
+                    runpy.run_path({source!r}, run_name='__main__')
+                    """).format(exec=sys.executable, path=sys.path,
+                        source=self.getSourcePath("qemu.py")))
+
+        self.set_emulator_setting("architecture", self.getArchitecture())
+        self.set_emulator_setting("emulator-path", emulator)
+
+    def test_basic_launch(self):
+        self.build()
+        exe = self.getBuildArtifact()
+
+        # Create a target using out platform
+        error = lldb.SBError()
+        target = self.dbg.CreateTarget(exe, '', 'qemu-user', False, error)
+        self.assertSuccess(error)
+        self.assertEqual(target.GetPlatform().GetName(), "qemu-user")
+
+        # "Launch" the process. Our fake qemu implementation will pretend it
+        # immediately exited.
+        process = target.LaunchSimple(
+                [self.getBuildArtifact("state.log"), "arg2", "arg3"], None, None)
+        self.assertIsNotNone(process)
+        self.assertEqual(process.GetState(), lldb.eStateExited)
+        self.assertEqual(process.GetExitStatus(), 0x47)
+
+        # Verify the qemu invocation parameters.
+        with open(self.getBuildArtifact("state.log")) as s:
+            state = json.load(s)
+        self.assertEqual(state["program"], self.getBuildArtifact())
+        self.assertEqual(state["rest"], ["arg2", "arg3"])
+
+    def test_bad_emulator_path(self):
+        self.set_emulator_setting("emulator-path",
+                self.getBuildArtifact("nonexistent.file"))
+
+        self.build()
+        exe = self.getBuildArtifact()
+
+        error = lldb.SBError()
+        target = self.dbg.CreateTarget(exe, '', 'qemu-user', False, error)
+        self.assertEqual(target.GetPlatform().GetName(), "qemu-user")
+        self.assertSuccess(error)
+        info = lldb.SBLaunchInfo([])
+        target.Launch(info, error)
+        self.assertTrue(error.Fail())
+        self.assertIn("doesn't exist", error.GetCString())

lldb/test/API/qemu/main.c

+// NB: This code will never be run, but we do need a realistic-looking
+// executable for the tests.
+int main() {}

lldb/test/API/qemu/qemu.py

+from textwrap import dedent
+import argparse
+import socket
+import json
+
+import use_lldb_suite
+from lldbsuite.test.gdbclientutils import *
+
+class MyResponder(MockGDBServerResponder):
+    def cont(self):
+        return "W47"
+
+class FakeEmulator(MockGDBServer):
+    def __init__(self, addr):
+        super().__init__(UnixServerSocket(addr))
+        self.responder = MyResponder()
+
+def main():
+    parser = argparse.ArgumentParser(description=dedent("""\
+            Implements a fake qemu for testing purposes. The executable program
+            is not actually run. Instead a very basic mock process is presented
+            to lldb. The emulated program must accept at least one argument.
+            This should be a path where the emulator will dump its state. This
+            allows us to check the invocation parameters.
+            """))
+    parser.add_argument('-g', metavar="unix-socket", required=True)
+    parser.add_argument('program', help="The program to 'emulate'.")
+    parser.add_argument('state_file', help="Where to dump the emulator state.")
+    parsed, rest = parser.parse_known_args()
+    with open(parsed.state_file, "w") as f:
+        json.dump({"program":parsed.program, "rest":rest}, f)
+
+    emulator = FakeEmulator(parsed.g)
+    emulator.run()
+
+if __name__ == "__main__":
+    main()