Debugger: Transform DebuggerRunParameters::startMode

The focus is on DebuggerRunParameters and DebuggerRunTool
API change. The rest is an adaptation.

The pattern would be:
1. Move a setter from DebuggerRunTool into DebuggerRunParameters.
2. Provide a corresponding getter.
3. Prefix a field with "m_".
4. Move the field into private section.

Transform only one field in this patch to avoid giant change.
Most probably one patch for one transformation could be optimal.

Task-number: QTCREATORBUG-29168
Change-Id: Idc46fc78a16889f4de09c8718d1bc9ad28ad3df1
Reviewed-by: hjk <[email protected]>

23 files changed, 141 insertions, 116 deletions

diff --git a/src/plugins/android/androiddebugsupport.cpp b/src/plugins/android/androiddebugsupport.cpp
index 3c39cfd2b5f..c1aa3a8a5a3 100644
--- a/src/plugins/android/androiddebugsupport.cpp
+++ b/src/plugins/android/androiddebugsupport.cpp
@@ -92,7 +92,8 @@ public:
 
         Target *target = runControl->target();
         Kit *kit = target->kit();
-        setStartMode(AttachToRemoteServer);
+        DebuggerRunParameters &rp = runParameters();
+        rp.setStartMode(AttachToRemoteServer);
         const QString packageName = Internal::packageName(target);
         setRunControlName(packageName);
         setUseContinueInsteadOfRun(true);
diff --git a/src/plugins/baremetal/debugservers/gdb/gdbserverprovider.cpp b/src/plugins/baremetal/debugservers/gdb/gdbserverprovider.cpp
index be347186ec6..bebac2edd36 100644
--- a/src/plugins/baremetal/debugservers/gdb/gdbserverprovider.cpp
+++ b/src/plugins/baremetal/debugservers/gdb/gdbserverprovider.cpp
@@ -142,15 +142,16 @@ bool GdbServerProvider::aboutToRun(DebuggerRunTool *runTool, QString &errorMessa
     ProcessRunData inferior;
     inferior.command.setExecutable(bin);
     inferior.command.setArguments(runnable.command.arguments());
+    DebuggerRunParameters &rp = runTool->runParameters();
     runTool->setInferior(inferior);
     runTool->setSymbolFile(bin);
-    runTool->setStartMode(AttachToRemoteServer);
+    rp.setStartMode(AttachToRemoteServer);
     runTool->setCommandsAfterConnect(initCommands()); // .. and here?
     runTool->setCommandsForReset(resetCommands());
     runTool->setRemoteChannel(channelString());
     runTool->setUseContinueInsteadOfRun(true);
     runTool->setUseExtendedRemote(useExtendedRemote());
-    runTool->runParameters().peripheralDescriptionFile = m_peripheralDescriptionFile;
+    rp.peripheralDescriptionFile = m_peripheralDescriptionFile;
     return true;
 }
 
diff --git a/src/plugins/baremetal/debugservers/uvsc/uvscserverprovider.cpp b/src/plugins/baremetal/debugservers/uvsc/uvscserverprovider.cpp
index b4d2c0d1f2e..b4d63413d58 100644
--- a/src/plugins/baremetal/debugservers/uvsc/uvscserverprovider.cpp
+++ b/src/plugins/baremetal/debugservers/uvsc/uvscserverprovider.cpp
@@ -184,13 +184,14 @@ bool UvscServerProvider::aboutToRun(DebuggerRunTool *runTool, QString &errorMess
 
     ProcessRunData inferior;
     inferior.command.setExecutable(bin);
-    runTool->runParameters().peripheralDescriptionFile = peripheralDescriptionFile;
-    runTool->runParameters().uVisionProjectFilePath = projFilePath;
-    runTool->runParameters().uVisionOptionsFilePath = optFilePath;
-    runTool->runParameters().uVisionSimulator = isSimulator();
+    DebuggerRunParameters &rp = runTool->runParameters();
+    rp.peripheralDescriptionFile = peripheralDescriptionFile;
+    rp.uVisionProjectFilePath = projFilePath;
+    rp.uVisionOptionsFilePath = optFilePath;
+    rp.uVisionSimulator = isSimulator();
     runTool->setInferior(inferior);
     runTool->setSymbolFile(bin);
-    runTool->setStartMode(AttachToRemoteServer);
+    rp.setStartMode(AttachToRemoteServer);
     runTool->setRemoteChannel(channelString());
     runTool->setUseContinueInsteadOfRun(true);
     return true;
diff --git a/src/plugins/boot2qt/qdbdevicedebugsupport.cpp b/src/plugins/boot2qt/qdbdevicedebugsupport.cpp
index 5538231b228..dc48b7d6af2 100644
--- a/src/plugins/boot2qt/qdbdevicedebugsupport.cpp
+++ b/src/plugins/boot2qt/qdbdevicedebugsupport.cpp
@@ -117,8 +117,9 @@ public:
             auto worker = new DebuggerRunTool(runControl);
             worker->setId("QdbDeviceDebugSupport");
 
+            DebuggerRunParameters &rp = worker->runParameters();
             worker->setupPortsGatherer();
-            worker->setStartMode(Debugger::AttachToRemoteServer);
+            rp.setStartMode(Debugger::AttachToRemoteServer);
             worker->setCloseMode(KillAndExitMonitorAtClose);
             worker->setUseContinueInsteadOfRun(true);
             worker->setContinueAfterAttach(true);
diff --git a/src/plugins/debugger/cdb/cdbengine.cpp b/src/plugins/debugger/cdb/cdbengine.cpp
index 009be94f88f..618b8e4385b 100644
--- a/src/plugins/debugger/cdb/cdbengine.cpp
+++ b/src/plugins/debugger/cdb/cdbengine.cpp
@@ -284,11 +284,11 @@ void CdbEngine::setupEngine()
         m_effectiveStartMode = AttachToLocalProcess;
         sp.inferior.command = {};
         sp.attachPID = ProcessHandle(applicationPid());
-        sp.startMode = AttachToLocalProcess;
+        sp.setStartMode(AttachToLocalProcess);
         sp.useTerminal = false; // Force no terminal.
         showMessage(QString("Attaching to %1...").arg(sp.attachPID.pid()), LogMisc);
     } else {
-        m_effectiveStartMode = sp.startMode;
+        m_effectiveStartMode = sp.startMode();
     }
 
     // Start engine which will run until initial breakpoint:
@@ -330,7 +330,7 @@ void CdbEngine::setupEngine()
     CommandLine debugger{sp.debugger.command};
 
     m_extensionFileName = extensionFi.fileName();
-    const bool isRemote = sp.startMode == AttachToRemoteServer;
+    const bool isRemote = sp.startMode() == AttachToRemoteServer;
     if (isRemote) { // Must be first
         debugger.addArgs({"-remote", sp.remoteChannel});
     } else {
@@ -357,7 +357,7 @@ void CdbEngine::setupEngine()
 
     debugger.addArgs(s.cdbAdditionalArguments(), CommandLine::Raw);
 
-    switch (sp.startMode) {
+    switch (sp.startMode()) {
     case StartInternal:
     case StartExternal:
         debugger.addArg(sp.inferior.command.executable().toUserOutput());
@@ -369,9 +369,10 @@ void CdbEngine::setupEngine()
     case AttachToLocalProcess:
     case AttachToCrashedProcess:
         debugger.addArgs({"-p", QString::number(sp.attachPID.pid())});
-        if (sp.startMode == AttachToCrashedProcess) {
+        if (sp.startMode() == AttachToCrashedProcess) {
             debugger.addArgs({"-e", sp.crashParameter, "-g"});
         } else {
+            // TODO: Dead branch?
             if (usesTerminal())
                 debugger.addArgs({"-pr", "-pb"});
         }
@@ -380,7 +381,7 @@ void CdbEngine::setupEngine()
         debugger.addArgs({"-z", sp.coreFile.path()});
         break;
     default:
-        handleSetupFailure(QString("Internal error: Unsupported start mode %1.").arg(sp.startMode));
+        handleSetupFailure(QString("Internal error: Unsupported start mode %1.").arg(sp.startMode()));
         return;
     }
 
@@ -425,7 +426,7 @@ void CdbEngine::processStarted()
     showMessage(QString("%1 running as %2").arg(execPath.toUserOutput()).arg(pid), LogMisc);
     m_hasDebuggee = true;
     m_initialSessionIdleHandled = false;
-    if (runParameters().startMode == AttachToRemoteServer) {
+    if (runParameters().startMode() == AttachToRemoteServer) {
         // We do not get an 'idle' in a remote session, but are accessible
         m_accessible = true;
         runCommand({".load " + m_extensionFileName, NoFlags});
@@ -444,7 +445,7 @@ void CdbEngine::handleInitialSessionIdle()
     // (attemptBreakpointSynchronization() will be directly called then)
     if (rp.breakOnMain) {
         BreakpointParameters bp(BreakpointAtMain);
-        if (rp.startMode == StartInternal || rp.startMode == StartExternal) {
+        if (rp.startMode() == StartInternal || rp.startMode() == StartExternal) {
             const QString &moduleFileName = rp.inferior.command.executable().fileName();
             bp.module = moduleFileName.left(moduleFileName.indexOf('.'));
         }
@@ -485,7 +486,7 @@ void CdbEngine::handleInitialSessionIdle()
         // Fails for core dumps.
         if (response.resultClass == ResultDone)
             notifyInferiorPid(response.data.toProcessHandle());
-        if (response.resultClass == ResultDone || runParameters().startMode == AttachToCore) {
+        if (response.resultClass == ResultDone || runParameters().startMode() == AttachToCore) {
             STATE_DEBUG(state(), Q_FUNC_INFO, __LINE__, "notifyEngineSetupOk")
                     notifyEngineSetupOk();
             runEngine();
@@ -563,7 +564,7 @@ void CdbEngine::runEngine()
 //        runCommand({"bm /( QtCored4!qFatal", BuiltinCommand}); // 'bm': All overloads.
 //        runCommand({"bm /( Qt5Cored!QMessageLogger::fatal", BuiltinCommand});
 //    }
-    if (runParameters().startMode == AttachToCore) {
+    if (runParameters().startMode() == AttachToCore) {
         QTC_ASSERT(!m_coreStopReason.isNull(), return; );
         notifyEngineRunOkAndInferiorUnrunnable();
         processStop(*m_coreStopReason, false);
@@ -588,7 +589,7 @@ void CdbEngine::shutdownInferior()
             qDebug("notifyInferiorShutdownFinished");
         STATE_DEBUG(state(), Q_FUNC_INFO, __LINE__, "notifyInferiorShutdownFinished")
     } else if (m_accessible) { // except console.
-        if (runParameters().startMode == AttachToLocalProcess || runParameters().startMode == AttachToCrashedProcess)
+        if (runParameters().startMode() == AttachToLocalProcess || runParameters().startMode() == AttachToCrashedProcess)
             detachDebugger();
         STATE_DEBUG(state(), Q_FUNC_INFO, __LINE__, "notifyInferiorShutdownFinished")
     } else {
@@ -633,7 +634,7 @@ void CdbEngine::shutdownEngine()
     // Go for kill if there are commands pending.
     if (m_accessible && !commandsPending()) {
         // detach (except console): Wait for debugger to finish.
-        if (runParameters().startMode == AttachToLocalProcess || runParameters().startMode == AttachToCrashedProcess)
+        if (runParameters().startMode() == AttachToLocalProcess || runParameters().startMode() == AttachToCrashedProcess)
             detachDebugger();
         // Remote requires a bit more force to quit.
         if (m_effectiveStartMode == AttachToRemoteServer) {
@@ -1766,7 +1767,7 @@ void CdbEngine::processStop(const GdbMi &stopReason, bool conditionalBreakPointT
     }
     // Notify about state and send off command sequence to get stack, etc.
     if (stopFlags & StopNotifyStop) {
-        if (runParameters().startMode != AttachToCore) {
+        if (runParameters().startMode() != AttachToCore) {
             if (state() == InferiorStopRequested) {
                 STATE_DEBUG(state(), Q_FUNC_INFO, __LINE__, "notifyInferiorStopOk")
                         notifyInferiorStopOk();
@@ -2027,7 +2028,7 @@ void CdbEngine::handleSessionIdle(const QString &message)
     if (!m_initialSessionIdleHandled) { // Temporary stop at beginning
         handleInitialSessionIdle();
         // Store stop reason to be handled in runEngine().
-        if (runParameters().startMode == AttachToCore) {
+        if (runParameters().startMode() == AttachToCore) {
             m_coreStopReason.reset(new GdbMi);
             m_coreStopReason->fromString(message);
         }
@@ -2746,7 +2747,7 @@ void CdbEngine::setupScripting(const DebuggerResponse &response)
     }
 
 
-    if (runParameters().startMode == AttachToRemoteServer) {
+    if (runParameters().startMode() == AttachToRemoteServer) {
         FilePath dumperPath = Core::ICore::resourcePath("debugger");
         const FilePath loadOrderFile = dumperPath / "loadorder.txt";
         const expected_str<QByteArray> toLoad = loadOrderFile.fileContents();
diff --git a/src/plugins/debugger/dap/gdbdapengine.cpp b/src/plugins/debugger/dap/gdbdapengine.cpp
index ff20d622b56..7c072fb5cc0 100644
--- a/src/plugins/debugger/dap/gdbdapengine.cpp
+++ b/src/plugins/debugger/dap/gdbdapengine.cpp
@@ -125,7 +125,7 @@ void GdbDapEngine::handleDapInitialize()
 
 bool GdbDapEngine::isLocalAttachEngine() const
 {
-    return runParameters().startMode == AttachToLocalProcess;
+    return runParameters().startMode() == AttachToLocalProcess;
 }
 
 void GdbDapEngine::handleDapConfigurationDone()
diff --git a/src/plugins/debugger/dap/lldbdapengine.cpp b/src/plugins/debugger/dap/lldbdapengine.cpp
index d767ab723ae..815d6d67870 100644
--- a/src/plugins/debugger/dap/lldbdapengine.cpp
+++ b/src/plugins/debugger/dap/lldbdapengine.cpp
@@ -194,7 +194,7 @@ void LldbDapEngine::handleDapInitialize()
 
 bool LldbDapEngine::isLocalAttachEngine() const
 {
-    return runParameters().startMode == AttachToLocalProcess;
+    return runParameters().startMode() == AttachToLocalProcess;
 }
 
 void LldbDapEngine::handleDapConfigurationDone()
diff --git a/src/plugins/debugger/dap/pydapengine.cpp b/src/plugins/debugger/dap/pydapengine.cpp
index 43a58bac9b1..a6db8d899c2 100644
--- a/src/plugins/debugger/dap/pydapengine.cpp
+++ b/src/plugins/debugger/dap/pydapengine.cpp
@@ -285,7 +285,7 @@ bool PyDapEngine::acceptsBreakpoint(const BreakpointParameters &bp) const
 
 bool PyDapEngine::isLocalAttachEngine() const
 {
-    return runParameters().startMode == AttachToLocalProcess;
+    return runParameters().startMode() == AttachToLocalProcess;
 }
 
 const QLoggingCategory &PyDapEngine::logCategory()
diff --git a/src/plugins/debugger/debuggerdialogs.cpp b/src/plugins/debugger/debuggerdialogs.cpp
index abfa5670f3b..daa8fa5542b 100644
--- a/src/plugins/debugger/debuggerdialogs.cpp
+++ b/src/plugins/debugger/debuggerdialogs.cpp
@@ -428,10 +428,10 @@ void StartApplicationDialog::run(bool attachRemote)
         debugger->setInferiorEnvironment(k->runEnvironment());
 
     if (!attachRemote)
-        debugger->setStartMode(isLocal ? StartExternal : StartRemoteProcess);
+        debugger->runParameters().setStartMode(isLocal ? StartExternal : StartRemoteProcess);
 
     if (attachRemote) {
-        debugger->setStartMode(AttachToRemoteServer);
+        debugger->runParameters().setStartMode(AttachToRemoteServer);
         debugger->setCloseMode(KillAtClose);
         debugger->setUseContinueInsteadOfRun(true);
         debugger->setRunControlName(Tr::tr("Attach to %1").arg(debugger->remoteChannel()));
@@ -577,7 +577,7 @@ void runAttachToQmlPortDialog()
 
     SshParameters sshParameters = device->sshParameters();
     debugger->setRemoteChannel(sshParameters.host(), sshParameters.port());
-    debugger->setStartMode(AttachToQmlServer);
+    debugger->runParameters().setStartMode(AttachToQmlServer);
 
     runControl->start();
 }
@@ -713,7 +713,8 @@ void runStartRemoteCdbSessionDialog(Kit *kit)
     runControl->setKit(kit);
 
     auto debugger = new DebuggerRunTool(runControl);
-    debugger->setStartMode(AttachToRemoteServer);
+    DebuggerRunParameters &rp = debugger->runParameters();
+    rp.setStartMode(AttachToRemoteServer);
     debugger->setCloseMode(KillAtClose);
     debugger->setRemoteChannel(dlg.connection());
 
diff --git a/src/plugins/debugger/debuggerengine.cpp b/src/plugins/debugger/debuggerengine.cpp
index a1a8dd95c33..32771435760 100644
--- a/src/plugins/debugger/debuggerengine.cpp
+++ b/src/plugins/debugger/debuggerengine.cpp
@@ -47,6 +47,7 @@
 #include <projectexplorer/devicesupport/devicemanager.h>
 #include <projectexplorer/project.h>
 #include <projectexplorer/projectexplorer.h>
+#include <projectexplorer/projectmanager.h>
 #include <projectexplorer/qmldebugcommandlinearguments.h>
 #include <projectexplorer/sysrootkitaspect.h>
 #include <projectexplorer/toolchainkitaspect.h>
@@ -263,7 +264,7 @@ Result DebuggerRunParameters::fixupParameters(ProjectExplorer::RunControl *runCo
         } else {
             service = QmlDebuggerServices;
         }
-        if (startMode != AttachToLocalProcess && startMode != AttachToCrashedProcess) {
+        if (m_startMode != AttachToLocalProcess && m_startMode != AttachToCrashedProcess) {
             const QString qmlarg = isCppDebugging() && nativeMixedEnabled
                                  ? qmlDebugNativeArguments(service, false)
                                  : qmlDebugTcpArguments(service, qmlServer);
@@ -271,8 +272,8 @@ Result DebuggerRunParameters::fixupParameters(ProjectExplorer::RunControl *runCo
         }
     }
 
-    if (startMode == NoStartMode)
-        startMode = StartInternal;
+    if (m_startMode == NoStartMode)
+        m_startMode = StartInternal;
 
     if (breakOnMainNextTime) {
         breakOnMain = true;
@@ -302,6 +303,30 @@ Result DebuggerRunParameters::fixupParameters(ProjectExplorer::RunControl *runCo
     return Result::Ok;
 }
 
+void DebuggerRunParameters::setStartMode(DebuggerStartMode startMode)
+{
+    m_startMode = startMode;
+    if (startMode != AttachToQmlServer)
+        return;
+
+    cppEngineType = NoEngineType;
+    isQmlDebugging = true;
+    closeMode = KillAtClose;
+
+    // FIXME: This is horribly wrong.
+    // get files from all the projects in the session
+    QList<Project *> projects = ProjectManager::projects();
+    if (Project *startupProject = ProjectManager::startupProject()) {
+        // startup project first
+        projects.removeOne(startupProject);
+        projects.insert(0, startupProject);
+    }
+    for (Project *project : std::as_const(projects))
+        projectSourceFiles.append(project->files(Project::SourceFiles));
+    if (!projects.isEmpty())
+        projectSourceDirectory = projects.first()->projectDirectory();
+}
+
 bool DebuggerRunParameters::isCppDebugging() const
 {
     return cppEngineType == GdbEngineType
@@ -1736,7 +1761,7 @@ void DebuggerEnginePrivate::updateState()
     m_threadsHandler.threadSwitcher()->setEnabled(threadsEnabled);
     m_threadLabel->setEnabled(threadsEnabled);
 
-    const bool isCore = m_engine->runParameters().startMode == AttachToCore;
+    const bool isCore = m_engine->runParameters().startMode() == AttachToCore;
     const bool stopped = state == InferiorStopOk;
     const bool detachable = stopped && !isCore;
     m_detachAction.setEnabled(detachable);
@@ -2180,7 +2205,7 @@ void DebuggerEngine::notifyInferiorPid(const ProcessHandle &pid)
     d->m_inferiorPid = pid;
     if (pid.isValid()) {
         showMessage(Tr::tr("Taking notice of pid %1").arg(pid.pid()));
-        DebuggerStartMode sm = runParameters().startMode;
+        const DebuggerStartMode sm = runParameters().startMode();
         if (sm == StartInternal || sm == StartExternal || sm == AttachToLocalProcess)
             d->m_inferiorPid.activate();
     }
@@ -2862,7 +2887,7 @@ QString DebuggerEngine::formatStartParameters() const
     const DebuggerRunParameters &sp = d->m_runParameters;
     QString rc;
     QTextStream str(&rc);
-    str << "Start parameters: '" << sp.displayName << "' mode: " << sp.startMode
+    str << "Start parameters: '" << sp.displayName << "' mode: " << sp.startMode()
         << "\nABI: " << sp.toolChainAbi.toString() << '\n';
     str << "Languages: ";
     if (sp.isCppDebugging())
@@ -3006,7 +3031,7 @@ void CppDebuggerEngine::validateRunParameters(DebuggerRunParameters &rp)
         }
         if (warnOnRelease
                 && rp.cppEngineType == CdbEngineType
-                && rp.startMode != AttachToRemoteServer) {
+                && rp.startMode() != AttachToRemoteServer) {
             QTC_ASSERT(!rp.symbolFile.isEmpty(), return);
             if (!rp.symbolFile.exists() && !rp.symbolFile.endsWith(".exe"))
                 rp.symbolFile = rp.symbolFile.stringAppended(".exe");
diff --git a/src/plugins/debugger/debuggerengine.h b/src/plugins/debugger/debuggerengine.h
index 927668f751e..064b38ccfc5 100644
--- a/src/plugins/debugger/debuggerengine.h
+++ b/src/plugins/debugger/debuggerengine.h
@@ -81,7 +81,9 @@ public:
 
     Utils::Result fixupParameters(ProjectExplorer::RunControl *runControl);
 
-    DebuggerStartMode startMode = NoStartMode;
+    void setStartMode(DebuggerStartMode startMode);
+    DebuggerStartMode startMode() const { return m_startMode; }
+
     DebuggerCloseMode closeMode = KillAtClose;
 
     Utils::ProcessRunData inferior;
@@ -187,6 +189,9 @@ public:
     Utils::FilePath uVisionProjectFilePath;
     Utils::FilePath uVisionOptionsFilePath;
     bool uVisionSimulator = false;
+
+private:
+    DebuggerStartMode m_startMode = NoStartMode;
 };
 
 namespace Internal {
diff --git a/src/plugins/debugger/debuggerplugin.cpp b/src/plugins/debugger/debuggerplugin.cpp
index 27d499b3b2a..8e1ee39f2f4 100644
--- a/src/plugins/debugger/debuggerplugin.cpp
+++ b/src/plugins/debugger/debuggerplugin.cpp
@@ -1393,28 +1393,29 @@ bool DebuggerPluginPrivate::parseArgument(QStringList::const_iterator &it,
         auto runControl = new RunControl(ProjectExplorer::Constants::DEBUG_RUN_MODE);
         runControl->setKit(kit);
         auto debugger = new DebuggerRunTool(runControl);
+        DebuggerRunParameters &rp = debugger->runParameters();
         debugger->setInferiorExecutable(executable);
         if (!sysRoot.isEmpty())
             debugger->setSysRoot(FilePath::fromUserInput(sysRoot));
         if (pid) {
-            debugger->setStartMode(AttachToLocalProcess);
+            rp.setStartMode(AttachToLocalProcess);
             debugger->setCloseMode(DetachAtClose);
             debugger->setAttachPid(pid);
             debugger->setRunControlName(Tr::tr("Process %1").arg(pid));
             debugger->setStartMessage(Tr::tr("Attaching to local process %1.").arg(pid));
         } else if (startMode == AttachToRemoteServer) {
-            debugger->setStartMode(AttachToRemoteServer);
+            rp.setStartMode(AttachToRemoteServer);
             debugger->setRemoteChannel(remoteChannel);
             debugger->setRunControlName(Tr::tr("Remote: \"%1\"").arg(remoteChannel));
             debugger->setStartMessage(Tr::tr("Attaching to remote server %1.").arg(remoteChannel));
         } else if (startMode == AttachToCore) {
-            debugger->setStartMode(AttachToCore);
+            rp.setStartMode(AttachToCore);
             debugger->setCloseMode(DetachAtClose);
             debugger->setCoreFilePath(coreFile);
             debugger->setRunControlName(Tr::tr("Core file \"%1\"").arg(coreFile.toUserOutput()));
             debugger->setStartMessage(Tr::tr("Attaching to core file %1.").arg(coreFile.toUserOutput()));
         } else {
-            debugger->setStartMode(StartExternal);
+            rp.setStartMode(StartExternal);
             debugger->setRunControlName(Tr::tr("Executable file \"%1\"").arg(executable.toUserOutput()));
             debugger->setStartMessage(Tr::tr("Debugging file %1.").arg(executable.toUserOutput()));
         }
@@ -1438,7 +1439,8 @@ bool DebuggerPluginPrivate::parseArgument(QStringList::const_iterator &it,
         auto runControl = new RunControl(ProjectExplorer::Constants::DEBUG_RUN_MODE);
         runControl->setKit(findUniversalCdbKit());
         auto debugger = new DebuggerRunTool(runControl);
-        debugger->setStartMode(AttachToCrashedProcess);
+        DebuggerRunParameters &rp = debugger->runParameters();
+        rp.setStartMode(AttachToCrashedProcess);
         debugger->setCrashParameter(it->section(':', 0, 0));
         debugger->setAttachPid(pid);
         debugger->setRunControlName(Tr::tr("Crashed process %1").arg(pid));
@@ -1621,9 +1623,10 @@ void DebuggerPluginPrivate::attachToLastCore()
     runControl->setDisplayName(Tr::tr("Last Core file \"%1\"").arg(lastCore.coreFile.toString()));
 
     auto debugger = new DebuggerRunTool(runControl);
+    DebuggerRunParameters &rp = debugger->runParameters();
     debugger->setInferiorExecutable(lastCore.binary);
     debugger->setCoreFilePath(lastCore.coreFile);
-    debugger->setStartMode(AttachToCore);
+    rp.setStartMode(AttachToCore);
     debugger->setCloseMode(DetachAtClose);
 
     runControl->start();
@@ -1669,9 +1672,10 @@ void DebuggerPluginPrivate::attachToRunningApplication()
         runControl->requestDebugChannel();
 
         auto debugger = new DebuggerRunTool(runControl);
+        DebuggerRunParameters &rp = debugger->runParameters();
         debugger->setId("AttachToRunningProcess");
         debugger->setUseDebugServer(ProcessHandle(processInfo.processId), false, false);
-        debugger->setStartMode(AttachToRemoteProcess);
+        rp.setStartMode(AttachToRemoteProcess);
         debugger->setCloseMode(DetachAtClose);
         debugger->setUseContinueInsteadOfRun(true);
         debugger->setContinueAfterAttach(false);
@@ -1738,9 +1742,10 @@ RunControl *DebuggerPluginPrivate::attachToRunningProcess(Kit *kit,
     runControl->setDisplayName(Tr::tr("Process %1").arg(processInfo.processId));
 
     auto debugger = new DebuggerRunTool(runControl);
+    DebuggerRunParameters &rp = debugger->runParameters();
     debugger->setAttachPid(ProcessHandle(processInfo.processId));
     debugger->setInferiorExecutable(device->filePath(processInfo.executable));
-    debugger->setStartMode(AttachToLocalProcess);
+    rp.setStartMode(AttachToLocalProcess);
     debugger->setCloseMode(DetachAtClose);
     debugger->setContinueAfterAttach(contAfterAttach);
 
@@ -2291,9 +2296,10 @@ void DebuggerPlugin::attachExternalApplication(RunControl *rc)
     runControl->setDisplayName(Tr::tr("Process %1").arg(pid.pid()));
 
     auto debugger = new DebuggerRunTool(runControl);
+    DebuggerRunParameters &rp = debugger->runParameters();
     debugger->setInferiorExecutable(rc->targetFilePath());
     debugger->setAttachPid(pid);
-    debugger->setStartMode(AttachToLocalProcess);
+    rp.setStartMode(AttachToLocalProcess);
     debugger->setCloseMode(DetachAtClose);
 
     runControl->start();
diff --git a/src/plugins/debugger/debuggerruncontrol.cpp b/src/plugins/debugger/debuggerruncontrol.cpp
index 776ef7703ab..a390a836d02 100644
--- a/src/plugins/debugger/debuggerruncontrol.cpp
+++ b/src/plugins/debugger/debuggerruncontrol.cpp
@@ -103,29 +103,6 @@ public:
 
 } // namespace Internal
 
-void DebuggerRunTool::setStartMode(DebuggerStartMode startMode)
-{
-    m_runParameters.startMode = startMode;
-    if (startMode == AttachToQmlServer) {
-        m_runParameters.cppEngineType = NoEngineType;
-        m_runParameters.isQmlDebugging = true;
-        m_runParameters.closeMode = KillAtClose;
-
-        // FIXME: This is horribly wrong.
-        // get files from all the projects in the session
-        QList<Project *> projects = ProjectManager::projects();
-        if (Project *startupProject = ProjectManager::startupProject()) {
-            // startup project first
-            projects.removeOne(startupProject);
-            projects.insert(0, startupProject);
-        }
-        for (Project *project : std::as_const(projects))
-            m_runParameters.projectSourceFiles.append(project->files(Project::SourceFiles));
-        if (!projects.isEmpty())
-            m_runParameters.projectSourceDirectory = projects.first()->projectDirectory();
-    }
-}
-
 void DebuggerRunTool::setCloseMode(DebuggerCloseMode closeMode)
 {
     m_runParameters.closeMode = closeMode;
@@ -393,8 +370,8 @@ void DebuggerRunTool::startTerminalIfNeededAndContinueStartup()
 
     // CDB has a built-in console that might be preferred by some.
     const bool useCdbConsole = m_runParameters.cppEngineType == CdbEngineType
-            && (m_runParameters.startMode == StartInternal
-                || m_runParameters.startMode == StartExternal)
+            && (m_runParameters.startMode() == StartInternal
+                || m_runParameters.startMode() == StartExternal)
             && settings().useCdbConsole();
     if (useCdbConsole)
         m_runParameters.useTerminal = false;
@@ -457,7 +434,7 @@ void DebuggerRunTool::continueAfterTerminalStart()
     }
 
     // User canceled input dialog asking for executable when working on library project.
-    if (m_runParameters.startMode == StartInternal
+    if (m_runParameters.startMode() == StartInternal
             && m_runParameters.inferior.command.isEmpty()
             && m_runParameters.interpreter.isEmpty()) {
         reportFailure(Tr::tr("No executable specified."));
@@ -601,7 +578,7 @@ void DebuggerRunTool::continueAfterDebugServerStart()
                 rc->resetDataForAttachToCore();
                 auto name = QString(Tr::tr("%1 - Snapshot %2").arg(runControl()->displayName()).arg(++d->snapshotCounter));
                 auto debugger = new DebuggerRunTool(rc);
-                debugger->setStartMode(AttachToCore);
+                debugger->runParameters().setStartMode(AttachToCore);
                 debugger->setCloseMode(DetachAtClose);
                 debugger->setRunControlName(name);
                 debugger->setCoreFilePath(FilePath::fromString(coreFile), true);
@@ -612,7 +589,7 @@ void DebuggerRunTool::continueAfterDebugServerStart()
         }
     }
 
-    if (m_runParameters.startMode != AttachToCore) {
+    if (m_runParameters.startMode() != AttachToCore) {
         QStringList unhandledIds;
         bool hasQmlBreakpoints = false;
         for (const GlobalBreakpoint &gbp : BreakpointManager::globalBreakpoints()) {
diff --git a/src/plugins/debugger/debuggerruncontrol.h b/src/plugins/debugger/debuggerruncontrol.h
index 7d13e826f96..f26d6369bc6 100644
--- a/src/plugins/debugger/debuggerruncontrol.h
+++ b/src/plugins/debugger/debuggerruncontrol.h
@@ -41,7 +41,6 @@ public:
 
     void addExpectedSignal(const QString &signal);
 
-    void setStartMode(DebuggerStartMode startMode);
     void setCloseMode(DebuggerCloseMode closeMode);
 
     void setAttachPid(Utils::ProcessHandle pid);
diff --git a/src/plugins/debugger/gdb/gdbengine.cpp b/src/plugins/debugger/gdb/gdbengine.cpp
index 1efb8e5081d..8104b5e8496 100644
--- a/src/plugins/debugger/gdb/gdbengine.cpp
+++ b/src/plugins/debugger/gdb/gdbengine.cpp
@@ -971,7 +971,7 @@ void GdbEngine::handleResultRecord(DebuggerResponse *response)
         Abi abi = rp.toolChainAbi;
         if (abi.os() == Abi::WindowsOS
             && cmd.function.startsWith("attach")
-            && (rp.startMode == AttachToLocalProcess || usesTerminal()))
+            && (rp.startMode() == AttachToLocalProcess || usesTerminal()))
         {
             // Ignore spurious 'running' responses to 'attach'.
         } else {
@@ -1708,7 +1708,7 @@ void GdbEngine::setLinuxOsAbi()
 void GdbEngine::detachDebugger()
 {
     CHECK_STATE(InferiorStopOk);
-    QTC_CHECK(runParameters().startMode != AttachToCore);
+    QTC_CHECK(runParameters().startMode() != AttachToCore);
     DebuggerCommand cmd("detach", NativeCommand | ExitRequest);
     cmd.callback = [this](const DebuggerResponse &) {
         CHECK_STATE(InferiorStopOk);
@@ -1762,7 +1762,7 @@ bool GdbEngine::hasCapability(unsigned cap) const
         return true;
     }
 
-    if (runParameters().startMode == AttachToCore)
+    if (runParameters().startMode() == AttachToCore)
         return false;
 
     return cap & (JumpToLineCapability
@@ -2545,7 +2545,7 @@ void GdbEngine::handleTracepointModified(const GdbMi &data)
 
 bool GdbEngine::acceptsBreakpoint(const BreakpointParameters &bp) const
 {
-    if (runParameters().startMode == AttachToCore)
+    if (runParameters().startMode() == AttachToCore)
         return false;
     if (bp.isCppBreakpoint())
         return true;
@@ -4296,7 +4296,7 @@ void GdbEngine::resetCommandQueue()
 
 bool GdbEngine::usesExecInterrupt() const
 {
-    DebuggerStartMode mode = runParameters().startMode;
+    const DebuggerStartMode mode = runParameters().startMode();
     return (mode == AttachToRemoteServer || mode == AttachToRemoteProcess)
             && usesTargetAsync();
 }
@@ -4388,18 +4388,18 @@ bool GdbEngine::isPlainEngine() const
 
 bool GdbEngine::isCoreEngine() const
 {
-    return runParameters().startMode == AttachToCore;
+    return runParameters().startMode() == AttachToCore;
 }
 
 bool GdbEngine::isRemoteEngine() const
 {
-    DebuggerStartMode startMode = runParameters().startMode;
+    const DebuggerStartMode startMode = runParameters().startMode();
     return startMode == StartRemoteProcess || startMode == AttachToRemoteServer;
 }
 
 bool GdbEngine::isLocalAttachEngine() const
 {
-    return runParameters().startMode == AttachToLocalProcess;
+    return runParameters().startMode() == AttachToLocalProcess;
 }
 
 bool GdbEngine::isTermEngine() const
@@ -4417,7 +4417,7 @@ void GdbEngine::claimInitialBreakpoints()
     CHECK_STATE(EngineRunRequested);
 
     const DebuggerRunParameters &rp = runParameters();
-    if (rp.startMode != AttachToCore) {
+    if (rp.startMode() != AttachToCore) {
         showStatusMessage(Tr::tr("Setting breakpoints..."));
         showMessage(Tr::tr("Setting breakpoints..."));
         BreakpointManager::claimBreakpointsForEngine(this);
@@ -4464,7 +4464,7 @@ void GdbEngine::setupInferior()
         runCommand(cmd);
     }
 
-    if (rp.startMode == AttachToRemoteProcess) {
+    if (rp.startMode() == AttachToRemoteProcess) {
 
         handleInferiorPrepared();
 
@@ -4596,7 +4596,7 @@ void GdbEngine::runEngine()
 
     const DebuggerRunParameters &rp = runParameters();
 
-    if (rp.startMode == AttachToRemoteProcess) {
+    if (rp.startMode() == AttachToRemoteProcess) {
 
         claimInitialBreakpoints();
         notifyEngineRunAndInferiorStopOk();
@@ -4689,7 +4689,7 @@ void GdbEngine::handleLocalAttach(const DebuggerResponse &response)
     }
     case ResultError:
         if (response.data["msg"].data() == "ptrace: Operation not permitted.") {
-            QString msg = msgPtraceError(runParameters().startMode);
+            const QString msg = msgPtraceError(runParameters().startMode());
             showStatusMessage(Tr::tr("Failed to attach to application: %1").arg(msg));
             AsynchronousMessageBox::warning(Tr::tr("Debugger Error"), msg);
             notifyEngineIll();
@@ -4720,7 +4720,7 @@ void GdbEngine::handleRemoteAttach(const DebuggerResponse &response)
     }
     case ResultError:
         if (response.data["msg"].data() == "ptrace: Operation not permitted.") {
-            notifyInferiorSetupFailedHelper(msgPtraceError(runParameters().startMode));
+            notifyInferiorSetupFailedHelper(msgPtraceError(runParameters().startMode()));
             break;
         }
         notifyInferiorSetupFailedHelper(response.data["msg"].data());
@@ -4737,7 +4737,7 @@ void GdbEngine::interruptInferior2()
 
         interruptLocalInferior(runParameters().attachPID.pid());
 
-    } else if (isRemoteEngine() || runParameters().startMode == AttachToRemoteProcess
+    } else if (isRemoteEngine() || runParameters().startMode() == AttachToRemoteProcess
                || !m_gdbProc.commandLine().executable().isLocal()) {
 
         CHECK_STATE(InferiorStopRequested);
@@ -5043,7 +5043,7 @@ void GdbEngine::handleStubAttached(const DebuggerResponse &response, qint64 main
         break;
     case ResultError:
         if (response.data["msg"].data() == "ptrace: Operation not permitted.") {
-            notifyInferiorSetupFailedHelper(msgPtraceError(runParameters().startMode));
+            notifyInferiorSetupFailedHelper(msgPtraceError(runParameters().startMode()));
             break;
         }
         showMessage(response.data["msg"].data());
diff --git a/src/plugins/debugger/lldb/lldbengine.cpp b/src/plugins/debugger/lldb/lldbengine.cpp
index c1d208dcf8c..b67c8860eda 100644
--- a/src/plugins/debugger/lldb/lldbengine.cpp
+++ b/src/plugins/debugger/lldb/lldbengine.cpp
@@ -267,7 +267,7 @@ void LldbEngine::handleLldbStarted()
     cmd2.arg("executable", executable.path());
     cmd2.arg("breakonmain", rp.breakOnMain);
     cmd2.arg("useterminal", usesTerminal());
-    cmd2.arg("startmode", rp.startMode);
+    cmd2.arg("startmode", rp.startMode());
     cmd2.arg("nativemixed", isNativeMixedActive());
     cmd2.arg("workingdirectory", inferior.workingDirectory.path());
     cmd2.arg("deviceUuid", rp.deviceUuid);
@@ -300,24 +300,24 @@ void LldbEngine::handleLldbStarted()
         cmd2.arg("startmode", DebuggerStartMode::AttachToLocalProcess);
         cmd2.arg("attachpid", attachedPID);
     } else {
-        cmd2.arg("startmode", rp.startMode);
-        if (rp.startMode != StartInternal) {
+        cmd2.arg("startmode", rp.startMode());
+        if (rp.startMode() != StartInternal) {
             // it is better not to check the start mode on the python sid (as we would have to duplicate the
             // enum values), and thus we assume that if the rp.attachPID is valid we really have to attach
             QTC_CHECK(
                 rp.attachPID.isValid()
-                && (rp.startMode == AttachToRemoteProcess || rp.startMode == AttachToLocalProcess
-                    || rp.startMode == AttachToRemoteServer || rp.startMode == AttachToIosDevice));
+                && (rp.startMode() == AttachToRemoteProcess || rp.startMode() == AttachToLocalProcess
+                    || rp.startMode() == AttachToRemoteServer || rp.startMode() == AttachToIosDevice));
             cmd2.arg("attachpid", rp.attachPID.pid());
             cmd2.arg("sysroot", rp.deviceSymbolsRoot.isEmpty() ? rp.sysRoot.toString()
                                                                : rp.deviceSymbolsRoot);
-            cmd2.arg("remotechannel", ((rp.startMode == AttachToRemoteProcess
-                                       || rp.startMode == AttachToRemoteServer)
+            cmd2.arg("remotechannel", ((rp.startMode() == AttachToRemoteProcess
+                                        || rp.startMode() == AttachToRemoteServer)
                                       ? rp.remoteChannel : QString()));
             QTC_CHECK(
                 !rp.continueAfterAttach
-                || (rp.startMode == AttachToRemoteProcess || rp.startMode == AttachToLocalProcess
-                    || rp.startMode == AttachToRemoteServer || rp.startMode == AttachToIosDevice));
+                || (rp.startMode() == AttachToRemoteProcess || rp.startMode() == AttachToLocalProcess
+                    || rp.startMode() == AttachToRemoteServer || rp.startMode() == AttachToIosDevice));
             m_continueAtNextSpontaneousStop = false;
         }
     }
@@ -359,7 +359,7 @@ void LldbEngine::runEngine()
     QTC_ASSERT(state() == EngineRunRequested, qDebug() << state(); return);
     showStatusMessage(Tr::tr("Running requested..."), 5000);
     DebuggerCommand cmd("runEngine");
-    if (rp.startMode == AttachToCore)
+    if (rp.startMode() == AttachToCore)
         cmd.arg("coreFile", rp.coreFile.path());
     runCommand(cmd);
 }
@@ -503,7 +503,7 @@ void LldbEngine::selectThread(const Thread &thread)
 
 bool LldbEngine::acceptsBreakpoint(const BreakpointParameters &bp) const
 {
-    if (runParameters().startMode == AttachToCore)
+    if (runParameters().startMode() == AttachToCore)
         return false;
     if (bp.isCppBreakpoint())
         return true;
@@ -933,7 +933,7 @@ void LldbEngine::handleStateNotification(const GdbMi &item)
         continueInferior();
     } else if (newState == "enginerunokandinferiorunrunnable") {
         notifyEngineRunOkAndInferiorUnrunnable();
-        if (runParameters().startMode == AttachToCore)
+        if (runParameters().startMode() == AttachToCore)
             handleAttachedToCore();
     } else if (newState == "inferiorshutdownfinished")
         notifyInferiorShutdownFinished();
@@ -1134,7 +1134,7 @@ bool LldbEngine::hasCapability(unsigned cap) const
         | AdditionalQmlStackCapability))
         return true;
 
-    if (runParameters().startMode == AttachToCore)
+    if (runParameters().startMode() == AttachToCore)
         return false;
 
     //return cap == SnapshotCapability;
diff --git a/src/plugins/debugger/loadcoredialog.cpp b/src/plugins/debugger/loadcoredialog.cpp
index 78dfe4d9ef0..a992b210b39 100644
--- a/src/plugins/debugger/loadcoredialog.cpp
+++ b/src/plugins/debugger/loadcoredialog.cpp
@@ -350,9 +350,10 @@ void runAttachToCoreDialog()
     runControl->setDisplayName(Tr::tr("Core file \"%1\"").arg(dlg.coreFile().toUserOutput()));
 
     auto debugger = new DebuggerRunTool(runControl);
+    DebuggerRunParameters &rp = debugger->runParameters();
     debugger->setInferiorExecutable(dlg.symbolFileCopy());
     debugger->setCoreFilePath(dlg.coreFileCopy());
-    debugger->setStartMode(AttachToCore);
+    rp.setStartMode(AttachToCore);
     debugger->setCloseMode(DetachAtClose);
     debugger->setOverrideStartScript(dlg.overrideStartScript());
     const FilePath sysRoot = dlg.sysRoot();
diff --git a/src/plugins/debugger/qml/qmlengine.cpp b/src/plugins/debugger/qml/qmlengine.cpp
index 4c882796244..9c5b1119d21 100644
--- a/src/plugins/debugger/qml/qmlengine.cpp
+++ b/src/plugins/debugger/qml/qmlengine.cpp
@@ -546,7 +546,7 @@ void QmlEngine::setupEngine()
 
     if (isPrimaryEngine()) {
         // QML only.
-        const DebuggerStartMode startMode = runParameters().startMode;
+        const DebuggerStartMode startMode = runParameters().startMode();
         if (startMode == AttachToQmlServer || startMode == AttachToRemoteServer)
             tryToConnect();
         else if (startMode == AttachToRemoteProcess)
diff --git a/src/plugins/ios/iosrunner.cpp b/src/plugins/ios/iosrunner.cpp
index 348bbe35781..1b68c7976a3 100644
--- a/src/plugins/ios/iosrunner.cpp
+++ b/src/plugins/ios/iosrunner.cpp
@@ -921,13 +921,14 @@ IosDebugSupport::IosDebugSupport(RunControl *runControl)
         addStartDependency(m_deviceCtlRunner);
     }
 
+    DebuggerRunParameters &rp = runParameters();
     if (device()->type() == Ios::Constants::IOS_DEVICE_TYPE) {
         if (dev->handler() == IosDevice::Handler::DeviceCtl) {
             QTC_CHECK(IosDeviceManager::isDeviceCtlDebugSupported());
-            setStartMode(AttachToIosDevice);
+            rp.setStartMode(AttachToIosDevice);
             setDeviceUuid(dev->uniqueInternalDeviceId());
         } else {
-            setStartMode(AttachToRemoteProcess);
+            rp.setStartMode(AttachToRemoteProcess);
         }
         setIosPlatform("remote-ios");
         const expected_str<FilePath> deviceSdk = findDeviceSdk(dev);
@@ -937,7 +938,7 @@ IosDebugSupport::IosDebugSupport(RunControl *runControl)
         else
             setDeviceSymbolsRoot(deviceSdk->path());
     } else {
-        setStartMode(AttachToLocalProcess);
+        rp.setStartMode(AttachToLocalProcess);
         setIosPlatform("ios-simulator");
     }
 }
@@ -1003,7 +1004,7 @@ void IosDebugSupport::start()
         QTC_ASSERT(isListening, return);
         qmlServer.setHost(server.serverAddress().toString());
         if (!cppDebug)
-            setStartMode(AttachToRemoteServer);
+            runParameters().setStartMode(AttachToRemoteServer);
     }
 
     if (qmlServerPort.isValid())
diff --git a/src/plugins/qnx/qnxdebugsupport.cpp b/src/plugins/qnx/qnxdebugsupport.cpp
index 9d140a6ac19..4ba2600983a 100644
--- a/src/plugins/qnx/qnxdebugsupport.cpp
+++ b/src/plugins/qnx/qnxdebugsupport.cpp
@@ -146,7 +146,8 @@ void showAttachToProcessDialog()
         debugger->addStartDependency(pdebugRunner);
     }
 
-    debugger->setStartMode(AttachToRemoteServer);
+    DebuggerRunParameters &rp = debugger->runParameters();
+    rp.setStartMode(AttachToRemoteServer);
     debugger->setCloseMode(DetachAtClose);
     debugger->setSymbolFile(localExecutable);
     debugger->setAttachPid(pid);
@@ -201,7 +202,8 @@ public:
 
             Kit *k = runControl->kit();
 
-            debugger->setStartMode(AttachToRemoteServer);
+            DebuggerRunParameters &rp = debugger->runParameters();
+            rp.setStartMode(AttachToRemoteServer);
             debugger->setCloseMode(KillAtClose);
             debugger->setUseCtrlCStub(true);
             debugger->setSolibSearchPath(FileUtils::toFilePathList(searchPaths(k)));
diff --git a/src/plugins/qtapplicationmanager/appmanagerruncontrol.cpp b/src/plugins/qtapplicationmanager/appmanagerruncontrol.cpp
index 0eebb6984eb..807ba7b8b01 100644
--- a/src/plugins/qtapplicationmanager/appmanagerruncontrol.cpp
+++ b/src/plugins/qtapplicationmanager/appmanagerruncontrol.cpp
@@ -152,7 +152,8 @@ private:
             return;
         }
 
-        setStartMode(Debugger::AttachToRemoteServer);
+        Debugger::DebuggerRunParameters &rp = runParameters();
+        rp.setStartMode(Debugger::AttachToRemoteServer);
         setCloseMode(Debugger::KillAndExitMonitorAtClose);
 
         if (isQmlDebugging())
diff --git a/src/plugins/remotelinux/remotelinuxdebugsupport.cpp b/src/plugins/remotelinux/remotelinuxdebugsupport.cpp
index b2f738b256c..c6c41ef026f 100644
--- a/src/plugins/remotelinux/remotelinuxdebugsupport.cpp
+++ b/src/plugins/remotelinux/remotelinuxdebugsupport.cpp
@@ -46,13 +46,14 @@ public:
     {
         setProducer([](RunControl *rc) {
             auto debugger = new DebuggerRunTool(rc, DebuggerRunTool::DoNotAllowTerminal);
+            DebuggerRunParameters &rp = debugger->runParameters();
             debugger->setId("RemoteLinuxDebugWorker");
 
             debugger->setupPortsGatherer();
             debugger->addQmlServerInferiorCommandLineArgumentIfNeeded();
             debugger->setUseDebugServer({}, true, true);
 
-            debugger->setStartMode(AttachToRemoteServer);
+            rp.setStartMode(AttachToRemoteServer);
             debugger->setCloseMode(KillAndExitMonitorAtClose);
             debugger->setUseExtendedRemote(true);
 
diff --git a/src/plugins/valgrind/memchecktool.cpp b/src/plugins/valgrind/memchecktool.cpp
index 97ebcbba1e3..a44b6f1f4ee 100644
--- a/src/plugins/valgrind/memchecktool.cpp
+++ b/src/plugins/valgrind/memchecktool.cpp
@@ -188,7 +188,8 @@ const FilePaths MemcheckToolRunner::suppressionFiles() const
 void MemcheckToolRunner::startDebugger(qint64 valgrindPid)
 {
     auto debugger = new Debugger::DebuggerRunTool(runControl());
-    debugger->setStartMode(Debugger::AttachToRemoteServer);
+    DebuggerRunParameters &rp = debugger->runParameters();
+    rp.setStartMode(Debugger::AttachToRemoteServer);
     debugger->setRunControlName(QString("VGdb %1").arg(valgrindPid));
     debugger->setRemoteChannel(QString("| vgdb --pid=%1").arg(valgrindPid));
     debugger->setUseContinueInsteadOfRun(true);