[lldb/qemu] Add emulator-args setting

[labath]

Summary

This setting allows the user to pass additional arguments to the qemu instance.
While we may want to introduce dedicated settings for the most common qemu
arguments (-cpu, for one), having this setting allows us to avoid creating a
setting for every possible argument.

[DavidSpickett]

LGTM.

Not clear what qemu options will be most useful yet and a catch all is always useful.

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

llvm::StringRef GetArchitecture() {
     return m_collection_sp->GetPropertyAtIndexAsString(
         nullptr, ePropertyArchitecture, "");
   }
 
   FileSpec GetEmulatorPath() {
     return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr,
                                                          ePropertyEmulatorPath);
   }
+
+  Args GetEmulatorArgs() {
+    Args result;
+    m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, ePropertyEmulatorArgs,
+                                              result);
+    return result;
+  }
 };
 
 static PluginProperties &GetGlobalProperties() {
   static PluginProperties g_settings;
   return g_settings;
 }
 
 llvm::StringRef PlatformQemuUser::GetPluginDescriptionStatic() {
lldb::ProcessSP PlatformQemuUser::DebugProcess(ProcessLaunchInfo &launch_info,
 
   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()});
+  Args args({qemu, "-g", socket_path});
+  args.AppendArguments(GetGlobalProperties().GetEmulatorArgs());
+  args.AppendArgument("--");
+  args.AppendArgument(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);

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.">;
+  def EmulatorArgs: Property<"emulator-args", "Args">,
+    Global,
+    DefaultStringValue<"">,
+    Desc<"Extra arguments to pass to the emulator.">;
 }

lldb/test/API/qemu/TestQemuLaunch.py

 @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" %
+        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):
+    def _run_and_get_state(self):
         self.build()
         exe = self.getBuildArtifact()
 
         # Create a target using our 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(
                 ["dump:" + self.getBuildArtifact("state.log")], 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)
+            return json.load(s)
+
+    def test_basic_launch(self):
+        state = self._run_and_get_state()
+
         self.assertEqual(state["program"], self.getBuildArtifact())
         self.assertEqual(state["args"],
                 ["dump:" + self.getBuildArtifact("state.log")])
 
     def test_stdio_pty(self):
         self.build()
         exe = self.getBuildArtifact()
 
def test_bad_emulator_path(self):
         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())
+
+    def test_extra_args(self):
+        self.set_emulator_setting("emulator-args", "-fake-arg fake-value")
+        state = self._run_and_get_state()
+
+        self.assertEqual(state["fake-arg"], "fake-value")

lldb/test/API/qemu/qemu.py

class FakeEmulator(MockGDBServer):
     def __init__(self, addr, state):
         super().__init__(UnixServerSocket(addr))
         self.responder = MyResponder(state)
 
 def main():
     parser = argparse.ArgumentParser(description=_description,
             formatter_class=argparse.RawDescriptionHelpFormatter)
     parser.add_argument('-g', metavar="unix-socket", required=True)
+    parser.add_argument('-fake-arg', dest="fake-arg")
     parser.add_argument('program', help="The program to 'emulate'.")
     parser.add_argument("args", nargs=argparse.REMAINDER)
     args = parser.parse_args()
 
     emulator = FakeEmulator(args.g, vars(args))
     emulator.run()
 
 if __name__ == "__main__":
     main()