Qnx: Fixing debugging on simulator to use correct debug symbols

BlackBerryConfiguration class has been rewritten to generate kit,
qtversion, toolchain and debugger for each available
<QtVersion,Architecture> pair.

This allows to use proper debug symbols i.e. target/qnx6/x86 for Simulator.

All kits, qtversions, toolchains and debuggers are claimed to be
autodetected.

Note it still requires to have matching version of the BB NDK Target and
simulator/device OS Image for proper debugging.

Task-number: QTCREATORBUG-10271

Change-Id: I522b761e7ad5c24736a8d19e0a1c8ea8c9fe9664
Reviewed-by: Nicolas Arnaud-Cormos <nicolas@kdab.com>
Reviewed-by: David Kaspar <dkaspar@blackberry.com>

4 files changed, 136 insertions, 152 deletions

diff --git a/src/plugins/qnx/blackberryconfiguration.cpp b/src/plugins/qnx/blackberryconfiguration.cpp
index 228df75549..63a21f9956 100644
--- a/src/plugins/qnx/blackberryconfiguration.cpp
+++ b/src/plugins/qnx/blackberryconfiguration.cpp
@@ -1,8 +1,8 @@
 /**************************************************************************
 **
-** Copyright (C) 2011 - 2013 Research In Motion
+** Copyright (C) 2011,2012,2013 BlackBerry Limited. All rights reserved.
 **
-** Contact: Research In Motion (blackberry-qt@qnx.com)
+** Contact: BlackBerry Limited (qt@blackberry.com)
 ** Contact: KDAB (info@kdab.com)
 **
 ** This file is part of Qt Creator.
@@ -92,11 +92,10 @@ BlackBerryConfiguration::BlackBerryConfiguration(const FileName &ndkEnvFile, boo
         m_gccCompiler = gccPath;
 
     if (deviceGdbPath.toFileInfo().exists())
-        m_deviceDebuger = deviceGdbPath;
+        m_deviceDebugger = deviceGdbPath;
 
     if (simulatorGdbPath.toFileInfo().exists())
-        m_simulatorDebuger = simulatorGdbPath;
-
+        m_simulatorDebugger = simulatorGdbPath;
 }
 
 QString BlackBerryConfiguration::ndkPath() const
@@ -121,15 +120,13 @@ bool BlackBerryConfiguration::isAutoDetected() const
 
 bool BlackBerryConfiguration::isActive() const
 {
-    BaseQtVersion *qt4Version = QtVersionManager::qtVersionForQMakeBinary(m_qmake4BinaryFile);
-    BaseQtVersion *qt5Version = QtVersionManager::qtVersionForQMakeBinary(m_qmake5BinaryFile);
-    return (qt4Version || qt5Version);
+    return !findRegisteredQtVersions().isEmpty();
 }
 
 bool BlackBerryConfiguration::isValid() const
 {
     return !((m_qmake4BinaryFile.isEmpty() && m_qmake5BinaryFile.isEmpty()) || m_gccCompiler.isEmpty()
-            || m_deviceDebuger.isEmpty() || m_simulatorDebuger.isEmpty());
+            || m_deviceDebugger.isEmpty() || m_simulatorDebugger.isEmpty());
 }
 
 FileName BlackBerryConfiguration::ndkEnvFile() const
@@ -154,12 +151,12 @@ FileName BlackBerryConfiguration::gccCompiler() const
 
 FileName BlackBerryConfiguration::deviceDebuger() const
 {
-    return m_deviceDebuger;
+    return m_deviceDebugger;
 }
 
 FileName BlackBerryConfiguration::simulatorDebuger() const
 {
-    return m_simulatorDebuger;
+    return m_simulatorDebugger;
 }
 
 FileName BlackBerryConfiguration::sysRoot() const
@@ -172,136 +169,87 @@ QMultiMap<QString, QString> BlackBerryConfiguration::qnxEnv() const
     return m_qnxEnv;
 }
 
-void BlackBerryConfiguration::setupConfigurationPerQtVersion(const FileName &qmakePath, GccToolChain *tc)
+void BlackBerryConfiguration::createConfigurationPerQtVersion(
+        const FileName &qmakePath, Qnx::QnxArchitecture arch)
 {
-    if (qmakePath.isEmpty() || !tc)
-        return;
-
-    BaseQtVersion *qtVersion = createQtVersion(qmakePath);
-    Kit *deviceKit = createKit(ArmLeV7, qtVersion, tc);
-    Kit *simulatorKit = createKit(X86, qtVersion, tc);
-    if (qtVersion && tc && deviceKit && simulatorKit) {
-        if (!qtVersion->qtAbis().isEmpty())
-            tc->setTargetAbi(qtVersion->qtAbis().first());
+    QnxAbstractQtVersion *version = createQtVersion(qmakePath, arch);
+    ToolChain *toolChain = createGccToolChain(version);
+    Kit *kit = createKit(version, toolChain);
+
+    if (version && toolChain && kit) {
         // register
-        QtVersionManager::addVersion(qtVersion);
-        ToolChainManager::registerToolChain(tc);
-        KitManager::registerKit(deviceKit);
-        KitManager::registerKit(simulatorKit);
+        QtVersionManager::addVersion(version);
+        ToolChainManager::registerToolChain(toolChain);
+        KitManager::registerKit(kit);
     }
 }
 
-BaseQtVersion *BlackBerryConfiguration::createQtVersion(const FileName &qmakePath)
+QnxAbstractQtVersion *BlackBerryConfiguration::createQtVersion(
+        const FileName &qmakePath, Qnx::QnxArchitecture arch)
 {
-    if (qmakePath.isEmpty())
-        return 0;
-
-    QString cpuDir = m_qnxEnv.value(QLatin1String("CPUVARDIR"));
-    BaseQtVersion *version = QtVersionManager::qtVersionForQMakeBinary(qmakePath);
-    if (version) {
-        if (!m_isAutoDetected)
-            QMessageBox::warning(0, tr("Qt Version Already Known"),
-                             tr("This Qt version was already registered."), QMessageBox::Ok);
-        return version;
-    }
-
-    version = new BlackBerryQtVersion(QnxUtils::cpudirToArch(cpuDir), qmakePath, m_isAutoDetected, QString(), m_ndkEnvFile.toString());
-    if (!version) {
-        if (!m_isAutoDetected)
-            QMessageBox::warning(0, tr("Invalid Qt Version"),
-                             tr("Unable to add BlackBerry Qt version."), QMessageBox::Ok);
-        return 0;
-    }
-
-    version->setDisplayName(QString::fromLatin1("Qt %1 BlackBerry 10 (%2)").arg(version->qtVersionString(), m_targetName));
+    QnxAbstractQtVersion *version = new BlackBerryQtVersion(
+            arch, qmakePath, true, QString(), m_ndkEnvFile.toString());
+    version->setDisplayName(tr("Qt %1 for %2 %3 - %4").arg(
+            version->qtVersionString(), version->platformDisplayName(),
+            version->archString(), m_targetName));
     return version;
 }
 
-GccToolChain *BlackBerryConfiguration::createGccToolChain()
+GccToolChain *BlackBerryConfiguration::createGccToolChain(QnxAbstractQtVersion *version)
 {
-    if ((m_qmake4BinaryFile.isEmpty() && m_qmake5BinaryFile.isEmpty()) || m_gccCompiler.isEmpty())
-        return 0;
-
-    foreach (ToolChain *tc, ToolChainManager::toolChains()) {
-        if (tc->compilerCommand() == m_gccCompiler) {
-            if (!m_isAutoDetected)
-                QMessageBox::warning(0, tr("Compiler Already Known"),
-                                 tr("This compiler was already registered."), QMessageBox::Ok);
-            return dynamic_cast<GccToolChain *>(tc);
-        }
-    }
-
-    GccToolChain* tc = new GccToolChain(QLatin1String(ProjectExplorer::Constants::GCC_TOOLCHAIN_ID), m_isAutoDetected ? ToolChain::AutoDetection : ToolChain::ManualDetection);
-    tc->setDisplayName(QString::fromLatin1("GCC BlackBerry 10 (%1)").arg(m_targetName));
-    tc->setCompilerCommand(m_gccCompiler);
-
-    return tc;
+    GccToolChain* toolChain = new GccToolChain(
+            QLatin1String(ProjectExplorer::Constants::GCC_TOOLCHAIN_ID), ToolChain::AutoDetection);
+    toolChain->setDisplayName(tr("QCC for Qt %1 for %2 %3 - %4").arg(
+            version->qtVersionString(), version->platformDisplayName(),
+            version->archString(), m_targetName));
+    toolChain->setCompilerCommand(m_gccCompiler);
+    QList<Abi> abis = version->qtAbis();
+    if (!abis.isEmpty())
+        toolChain->setTargetAbi(abis.first());
+    return toolChain;
 }
 
-Kit *BlackBerryConfiguration::createKit(QnxArchitecture arch, BaseQtVersion *qtVersion, GccToolChain *tc)
+Kit *BlackBerryConfiguration::createKit(QnxAbstractQtVersion *version, ToolChain *toolChain)
 {
-    if (!qtVersion || !tc || m_targetName.isEmpty())
-        return 0;
-
-    // Check if an identical kit already exists
-    foreach (Kit *kit, KitManager::kits()) {
-        if (QtKitInformation::qtVersion(kit) == qtVersion && ToolChainKitInformation::toolChain(kit) == tc
-                && DeviceTypeKitInformation::deviceTypeId(kit) == Constants::QNX_BB_OS_TYPE
-                && SysRootKitInformation::sysRoot(kit) == m_sysRoot) {
-            if ((arch == X86 && Qt4ProjectManager::QmakeKitInformation::mkspec(kit).toString() == QString::fromLatin1("blackberry-x86-qcc")
-                 && Debugger::DebuggerKitInformation::debuggerCommand(kit) == m_simulatorDebuger)
-                    || (arch == ArmLeV7 && Debugger::DebuggerKitInformation::debuggerCommand(kit) == m_deviceDebuger)) {
-                if (!m_isAutoDetected)
-                    QMessageBox::warning(0, tr("Kit Already Known"),
-                                     tr("This kit was already registered."), QMessageBox::Ok);
-                setSticky(kit);
-                return kit;
-            }
-        }
-    }
-
     Kit *kit = new Kit;
-    QtKitInformation::setQtVersion(kit, qtVersion);
-    ToolChainKitInformation::setToolChain(kit, tc);
+    bool isSimulator = version->architecture() == X86;
 
-    QString versionName = QString::fromLatin1("%1 - %2").arg(qtVersion->qtVersionString(), m_targetName);
+    QtKitInformation::setQtVersion(kit, version);
+    ToolChainKitInformation::setToolChain(kit, toolChain);
 
     Debugger::DebuggerItem debugger;
-    debugger.setCommand(arch == X86 ? m_simulatorDebuger : m_deviceDebuger);
+    debugger.setCommand(isSimulator ? m_simulatorDebugger : m_deviceDebugger);
     debugger.setEngineType(Debugger::GdbEngineType);
-    debugger.setDisplayName(arch == X86
-            ? tr("BlackBerry Debugger (%1) - Simulator").arg(versionName)
-            : tr("BlackBerry Debugger (%1) - Device").arg(versionName));
     debugger.setAutoDetected(true);
-    debugger.setAbi(tc->targetAbi());
+    debugger.setAbi(toolChain->targetAbi());
+    debugger.setDisplayName(tr("Debugger for Qt %1 for %2 %3 - %4").arg(
+            version->qtVersionString(), version->platformDisplayName(),
+            version->archString(), m_targetName));
     Debugger::DebuggerKitInformation::setDebugger(kit, debugger);
 
-    if (arch == X86) {
-        Qt4ProjectManager::QmakeKitInformation::setMkspec(kit, FileName::fromString(QString::fromLatin1("blackberry-x86-qcc")));
-        // TODO: Check if the name already exists(?)
-        kit->setDisplayName(tr("BlackBerry 10 (%1) - Simulator").arg(versionName));
-    } else {
-        kit->setDisplayName(tr("BlackBerry 10 (%1)").arg(versionName));
-    }
+    if (isSimulator)
+        Qt4ProjectManager::QmakeKitInformation::setMkspec(
+                 kit, FileName::fromString(QLatin1String("blackberry-x86-qcc")));
 
-    kit->setAutoDetected(m_isAutoDetected);
-    kit->setIconPath(FileName::fromString(QLatin1String(Constants::QNX_BB_CATEGORY_ICON)));
-    kit->setMutable(DeviceKitInformation::id(), true);
-    setSticky(kit);
     DeviceTypeKitInformation::setDeviceTypeId(kit, Constants::QNX_BB_OS_TYPE);
     SysRootKitInformation::setSysRoot(kit, m_sysRoot);
 
-    return kit;
-}
+    kit->setDisplayName(tr("%1 %2 - Qt %3 - %4").arg(
+            version->platformDisplayName(), isSimulator ? tr("Simulator") : tr("Device"),
+            version->qtVersionString(), m_targetName));
+    kit->setIconPath(FileName::fromString(QLatin1String(Constants::QNX_BB_CATEGORY_ICON)));
+
+    kit->setAutoDetected(true);
+    kit->setMutable(DeviceKitInformation::id(), true);
 
-void BlackBerryConfiguration::setSticky(Kit *kit)
-{
     kit->setSticky(QtKitInformation::id(), true);
     kit->setSticky(ToolChainKitInformation::id(), true);
     kit->setSticky(DeviceTypeKitInformation::id(), true);
     kit->setSticky(SysRootKitInformation::id(), true);
     kit->setSticky(Debugger::DebuggerKitInformation::id(), true);
     kit->setSticky(Qt4ProjectManager::QmakeKitInformation::id(), true);
+
+    return kit;
 }
 
 bool BlackBerryConfiguration::activate()
@@ -317,10 +265,10 @@ bool BlackBerryConfiguration::activate()
         if (m_gccCompiler.isEmpty())
             errorMessage += QLatin1Char('\n') + tr("- No GCC compiler found.");
 
-        if (m_deviceDebuger.isEmpty())
+        if (m_deviceDebugger.isEmpty())
             errorMessage += QLatin1Char('\n') + tr("- No GDB debugger found for BB10 Device.");
 
-        if (!m_simulatorDebuger.isEmpty())
+        if (!m_simulatorDebugger.isEmpty())
             errorMessage += QLatin1Char('\n') + tr("- No GDB debugger found for BB10 Simulator.");
 
         QMessageBox::warning(0, tr("Cannot Set up BB10 Configuration"),
@@ -328,43 +276,64 @@ bool BlackBerryConfiguration::activate()
         return false;
     }
 
-    if (isActive() && !m_isAutoDetected)
+    if (isActive())
         return true;
 
-    GccToolChain *tc = createGccToolChain();
-    if (!m_qmake4BinaryFile.isEmpty())
-        setupConfigurationPerQtVersion(m_qmake4BinaryFile, tc);
+    deactivate(); // cleaning-up artifacts autodetected by old QtCreator versions
 
-    if (!m_qmake5BinaryFile.isEmpty())
-        setupConfigurationPerQtVersion(m_qmake5BinaryFile, tc);
+    if (!m_qmake4BinaryFile.isEmpty()) {
+        createConfigurationPerQtVersion(m_qmake4BinaryFile, Qnx::ArmLeV7);
+        createConfigurationPerQtVersion(m_qmake4BinaryFile, Qnx::X86);
+    }
+
+    if (!m_qmake5BinaryFile.isEmpty()) {
+        createConfigurationPerQtVersion(m_qmake5BinaryFile, Qnx::ArmLeV7);
+        createConfigurationPerQtVersion(m_qmake5BinaryFile, Qnx::X86);
+    }
 
     return true;
 }
 
-void BlackBerryConfiguration::deactivate()
+QList<BaseQtVersion *> BlackBerryConfiguration::findRegisteredQtVersions() const
 {
-    BaseQtVersion *qt4Version = QtVersionManager::qtVersionForQMakeBinary(m_qmake4BinaryFile);
-    BaseQtVersion *qt5Version = QtVersionManager::qtVersionForQMakeBinary(m_qmake5BinaryFile);
-    if (qt4Version || qt5Version) {
-        foreach (Kit *kit, KitManager::kits()) {
-            if (qt4Version && qt4Version == QtKitInformation::qtVersion(kit))
-                KitManager::deregisterKit(kit);
+    QList<BaseQtVersion *> versions;
+    foreach (BaseQtVersion *version, QtVersionManager::versions()) {
+        if (version->type() == QLatin1String(Constants::QNX_BB_QT)) {
+            QnxAbstractQtVersion *qnxVersion = dynamic_cast<QnxAbstractQtVersion *>(version);
+            if (qnxVersion  &&  qnxVersion->isAutodetected()
+                    && (qnxVersion->qmakeCommand() == qmake4BinaryFile()
+                    || qnxVersion->qmakeCommand() == qmake5BinaryFile()))
+                versions << qnxVersion;
+        }
+    }
+    return versions;
+}
 
-            else if (qt5Version && qt5Version == QtKitInformation::qtVersion(kit))
+void BlackBerryConfiguration::deactivate()
+{
+    QList<BaseQtVersion *> versions = findRegisteredQtVersions();
+    QList<ToolChain *> toolChains;
+    foreach (Kit *kit, KitManager::kits()) {
+        if (kit->isAutoDetected()) {
+            BaseQtVersion *version = QtKitInformation::qtVersion(kit);
+            if (versions.contains(version)) {
+                ToolChain *toolChain = ToolChainKitInformation::toolChain(kit);
+                if (toolChain)
+                    toolChains << toolChain;
                 KitManager::deregisterKit(kit);
+            }
         }
+    }
 
-        if (qt4Version)
-            QtVersionManager::removeVersion(qt4Version);
-
-        if (qt5Version)
-            QtVersionManager::removeVersion(qt5Version);
+    // unable to deregistering debuggers because of missing API
 
-    }
+    foreach (ToolChain *toolChain, ToolChainManager::toolChains())
+        if (toolChain->isAutoDetected()
+                && (toolChains.contains(toolChain) || toolChain->compilerCommand() == m_gccCompiler))
+            ToolChainManager::deregisterToolChain(toolChain);
 
-    foreach (ToolChain *tc, ToolChainManager::toolChains())
-        if (tc->compilerCommand() == m_gccCompiler)
-            ToolChainManager::deregisterToolChain(tc);
+    foreach (BaseQtVersion *version, versions)
+        QtVersionManager::removeVersion(version);
 }
 
 } // namespace Internal
diff --git a/src/plugins/qnx/blackberryconfiguration.h b/src/plugins/qnx/blackberryconfiguration.h
index 32961201ce..a67a0dfd45 100644
--- a/src/plugins/qnx/blackberryconfiguration.h
+++ b/src/plugins/qnx/blackberryconfiguration.h
@@ -1,8 +1,8 @@
 /**************************************************************************
 **
-** Copyright (C) 2011 - 2013 Research In Motion
+** Copyright (C) 2011,2012,2013 BlackBerry Limited. All rights reserved.
 **
-** Contact: Research In Motion (blackberry-qt@qnx.com)
+** Contact: BlackBerry Limited (qt@blackberry.com)
 ** Contact: KDAB (info@kdab.com)
 **
 ** This file is part of Qt Creator.
@@ -37,17 +37,21 @@
 #include <utils/environment.h>
 #include <utils/fileutils.h>
 
-#include <qtsupport/baseqtversion.h>
-
 #include <projectexplorer/kit.h>
 #include <projectexplorer/gcctoolchain.h>
 
 #include <QObject>
 #include <QCoreApplication>
 
+namespace QtSupport {
+class BaseQtVersion;
+}
+
 namespace Qnx {
 namespace Internal {
 
+class QnxAbstractQtVersion;
+
 class BlackBerryConfiguration
 {
     Q_DECLARE_TR_FUNCTIONS(Qnx::Internal::BlackBerryConfiguration)
@@ -78,17 +82,19 @@ private:
     Utils::FileName m_qmake4BinaryFile;
     Utils::FileName m_qmake5BinaryFile;
     Utils::FileName m_gccCompiler;
-    Utils::FileName m_deviceDebuger;
-    Utils::FileName m_simulatorDebuger;
+    Utils::FileName m_deviceDebugger;
+    Utils::FileName m_simulatorDebugger;
     Utils::FileName m_sysRoot;
     QMultiMap<QString, QString> m_qnxEnv;
 
-    void setupConfigurationPerQtVersion(const Utils::FileName &qmakePath, ProjectExplorer::GccToolChain* tc);
-    QtSupport::BaseQtVersion* createQtVersion(const Utils::FileName &qmakePath);
-    ProjectExplorer::GccToolChain* createGccToolChain();
-    ProjectExplorer::Kit* createKit(QnxArchitecture arch, QtSupport::BaseQtVersion* qtVersion, ProjectExplorer::GccToolChain* tc);
-    void setSticky(ProjectExplorer::Kit* kit);
-
+    void createConfigurationPerQtVersion(
+            const Utils::FileName &qmakePath, Qnx::QnxArchitecture arch);
+    QnxAbstractQtVersion* createQtVersion(
+            const Utils::FileName &qmakePath, Qnx::QnxArchitecture arch);
+    ProjectExplorer::GccToolChain* createGccToolChain(QnxAbstractQtVersion *version);
+    ProjectExplorer::Kit* createKit(
+            QnxAbstractQtVersion* version, ProjectExplorer::ToolChain* toolChain);
+    QList<QtSupport::BaseQtVersion *> findRegisteredQtVersions() const;
 };
 
 } // namespace Internal
diff --git a/src/plugins/qnx/blackberryndksettingswidget.cpp b/src/plugins/qnx/blackberryndksettingswidget.cpp
index 8591234ea8..4b62773992 100644
--- a/src/plugins/qnx/blackberryndksettingswidget.cpp
+++ b/src/plugins/qnx/blackberryndksettingswidget.cpp
@@ -257,11 +257,9 @@ void BlackBerryNDKSettingsWidget::updateUi(QTreeWidgetItem *item, BlackBerryConf
     item->setFont(0, font);
     item->setFont(1, font);
 
-    m_ui->activateNdkTargetButton->setEnabled((!m_activatedTargets.contains(config))
-                                               && config->isAutoDetected());
-    m_ui->deactivateNdkTargetButton->setEnabled((m_activatedTargets.contains(config))
-                                                && m_activatedTargets.size() > 1
-                                                && config->isAutoDetected());
+    m_ui->activateNdkTargetButton->setEnabled(!m_activatedTargets.contains(config));
+    m_ui->deactivateNdkTargetButton->setEnabled(m_activatedTargets.contains(config)
+                                                && m_activatedTargets.size() > 1);
     m_ui->removeNdkButton->setEnabled(true);
 }
 
diff --git a/src/plugins/qnx/blackberryqtversion.cpp b/src/plugins/qnx/blackberryqtversion.cpp
index 0eeeef4f7f..5ef63c37bb 100644
--- a/src/plugins/qnx/blackberryqtversion.cpp
+++ b/src/plugins/qnx/blackberryqtversion.cpp
@@ -110,7 +110,18 @@ QMultiMap<QString, QString> BlackBerryQtVersion::environment() const
         return QMultiMap<QString, QString>();
 
     QString envFile = m_ndkEnvFile.isEmpty() ? QnxUtils::envFilePath(sdkPath()) : m_ndkEnvFile;
-    return QnxUtils::parseEnvironmentFile(envFile);
+    QMultiMap<QString,QString> result = QnxUtils::parseEnvironmentFile(envFile);
+    // BB NDK Host is having qmake executable which is using qt.conf file to specify
+    // base information. The qt.conf file is using 'CPUVARDIR' environment variable
+    // to provide correct information for both x86 and armle-v7 architectures.
+    // BlackBerryQtVersion represents as specific environment for each Qt4/Qt5
+    // and x86/armle-v7 combination. Therefore we need to explicitly specify
+    // CPUVARDIR to match expected architecture() otherwise qmake environment is
+    // always resolved to be for armle-v7 architecture only as it is specified
+    // BB NDK environment file.
+    result.replace(QLatin1String("CPUVARDIR"),
+            architecture() == X86 ? QLatin1String("x86") : QLatin1String("armle-v7"));
+    return result;
 }
 
 void BlackBerryQtVersion::setDefaultSdkPath()