ProjectExplorer: Retain original target triple for gcc toolchains

The target triple will be used by the Clang Static Analyzer.

Change-Id: Ibf33fef286a4d3ad3f40be4d6d5c9f35881d3d46
Reviewed-by: Tobias Hunger <tobias.hunger@theqtcompany.com>

src/plugins/android/androidtoolchain.cpp

@@ -234,7 +234,7 @@ void AndroidToolChain::setSecondaryToolChain(bool b)
     m_secondaryToolChain = b;
 }
 
-QList<Abi> AndroidToolChain::detectSupportedAbis() const
+GccToolChain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const
 {
     return QList<Abi>() << targetAbi();
 }

src/plugins/android/androidtoolchain.h

@@ -60,7 +60,7 @@ public:
     void setSecondaryToolChain(bool b);
 
 protected:
-    QList<ProjectExplorer::Abi> detectSupportedAbis() const override;
+    DetectedAbisResult detectSupportedAbis() const override;
 
 private:
     explicit AndroidToolChain(const ProjectExplorer::Abi &abi, const QString &ndkToolChainVersion, Detection d);

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -62,6 +62,7 @@ static const char compilerCommandKeyC[] = "ProjectExplorer.GccToolChain.Path";
 static const char compilerPlatformCodeGenFlagsKeyC[] = "ProjectExplorer.GccToolChain.PlatformCodeGenFlags";
 static const char compilerPlatformLinkerFlagsKeyC[] = "ProjectExplorer.GccToolChain.PlatformLinkerFlags";
 static const char targetAbiKeyC[] = "ProjectExplorer.GccToolChain.TargetAbi";
+static const char originalTargetTripleKeyC[] = "ProjectExplorer.GccToolChain.OriginalTargetTriple";
 static const char supportedAbisKeyC[] = "ProjectExplorer.GccToolChain.SupportedAbis";
 
 static QByteArray runGcc(const FileName &gcc, const QStringList &arguments, const QStringList &env)
@@ -214,19 +215,20 @@ static QList<Abi> guessGccAbi(const QString &m, const QByteArray &macros)
     return abiList;
 }
 
-static QList<Abi> guessGccAbi(const FileName &path, const QStringList &env,
-                              const QByteArray &macros,
-                              const QStringList &extraArgs = QStringList())
+
+static GccToolChain::DetectedAbisResult guessGccAbi(const FileName &path, const QStringList &env,
+                                                   const QByteArray &macros,
+                                                   const QStringList &extraArgs = QStringList())
 {
     if (path.isEmpty())
-        return QList<Abi>();
+        return GccToolChain::DetectedAbisResult();
 
     QStringList arguments = extraArgs;
     arguments << QLatin1String("-dumpmachine");
     QString machine = QString::fromLocal8Bit(runGcc(path, arguments, env)).trimmed();
     if (machine.isEmpty())
-        return QList<Abi>(); // no need to continue if running failed once...
-    return guessGccAbi(machine, macros);
+        return GccToolChain::DetectedAbisResult(); // no need to continue if running failed once...
+    return GccToolChain::DetectedAbisResult(guessGccAbi(machine, macros), machine);
 }
 
 static QString gccVersion(const FileName &path, const QStringList &env)
@@ -260,6 +262,11 @@ void GccToolChain::setSupportedAbis(const QList<Abi> &m_abis)
     m_supportedAbis = m_abis;
 }
 
+void GccToolChain::setOriginalTargetTriple(const QString &targetTriple)
+{
+    m_originalTargetTriple = targetTriple;
+}
+
 void GccToolChain::setMacroCache(const QStringList &allCxxflags, const QByteArray &macros) const
 {
     if (macros.isNull())
@@ -318,6 +325,11 @@ Abi GccToolChain::targetAbi() const
     return m_targetAbi;
 }
 
+QString GccToolChain::originalTargetTriple() const
+{
+    return m_originalTargetTriple;
+}
+
 QString GccToolChain::version() const
 {
     if (m_version.isEmpty())
@@ -620,7 +632,9 @@ void GccToolChain::resetToolChain(const FileName &path)
     setCompilerCommand(path);
 
     Abi currentAbi = m_targetAbi;
-    m_supportedAbis = detectSupportedAbis();
+    const DetectedAbisResult detectedAbis = detectSupportedAbis();
+    m_supportedAbis = detectedAbis.supportedAbis;
+    m_originalTargetTriple = detectedAbis.originalTargetTriple;
 
     m_targetAbi = Abi();
     if (!m_supportedAbis.isEmpty()) {
@@ -687,6 +701,7 @@ QVariantMap GccToolChain::toMap() const
     data.insert(QLatin1String(compilerPlatformCodeGenFlagsKeyC), m_platformCodeGenFlags);
     data.insert(QLatin1String(compilerPlatformLinkerFlagsKeyC), m_platformLinkerFlags);
     data.insert(QLatin1String(targetAbiKeyC), m_targetAbi.toString());
+    data.insert(QLatin1String(originalTargetTripleKeyC), m_originalTargetTriple);
     QStringList abiList = Utils::transform(m_supportedAbis, &Abi::toString);
     data.insert(QLatin1String(supportedAbisKeyC), abiList);
     return data;
@@ -701,6 +716,7 @@ bool GccToolChain::fromMap(const QVariantMap &data)
     m_platformCodeGenFlags = data.value(QLatin1String(compilerPlatformCodeGenFlagsKeyC)).toStringList();
     m_platformLinkerFlags = data.value(QLatin1String(compilerPlatformLinkerFlagsKeyC)).toStringList();
     m_targetAbi = Abi(data.value(QLatin1String(targetAbiKeyC)).toString());
+    m_originalTargetTriple = data.value(QLatin1String(originalTargetTripleKeyC)).toString();
     QStringList abiList = data.value(QLatin1String(supportedAbisKeyC)).toStringList();
     m_supportedAbis.clear();
     foreach (const QString &a, abiList) {
@@ -730,11 +746,14 @@ ToolChainConfigWidget *GccToolChain::configurationWidget()
 
 void GccToolChain::updateSupportedAbis() const
 {
-    if (m_supportedAbis.isEmpty())
-        m_supportedAbis = detectSupportedAbis();
+    if (m_supportedAbis.isEmpty()) {
+        const DetectedAbisResult detected = detectSupportedAbis();
+        m_supportedAbis = detected.supportedAbis;
+        m_originalTargetTriple = detected.originalTargetTriple;
+    }
 }
 
-QList<Abi> GccToolChain::detectSupportedAbis() const
+GccToolChain::DetectedAbisResult GccToolChain::detectSupportedAbis() const
 {
     Environment env = Environment::systemEnvironment();
     addToEnvironment(env);
@@ -827,7 +846,10 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(const QString &comp
     GccToolChain::addCommandPathToEnvironment(compilerPath, systemEnvironment);
     QByteArray macros
             = gccPredefinedMacros(compilerPath, gccPredefinedMacrosOptions(), systemEnvironment.toStringList());
-    QList<Abi> abiList = guessGccAbi(compilerPath, systemEnvironment.toStringList(), macros);
+    const GccToolChain::DetectedAbisResult detectedAbis = guessGccAbi(compilerPath,
+                                                                      systemEnvironment.toStringList(),
+                                                                      macros);
+    QList<Abi> abiList = detectedAbis.supportedAbis;
     if (!abiList.contains(requiredAbi)) {
         if (requiredAbi.wordWidth() != 64
                 || !abiList.contains(Abi(requiredAbi.architecture(), requiredAbi.os(), requiredAbi.osFlavor(),
@@ -844,6 +866,7 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(const QString &comp
         tc->setCompilerCommand(compilerPath);
         tc->setSupportedAbis(abiList);
         tc->setTargetAbi(abi);
+        tc->setOriginalTargetTriple(detectedAbis.originalTargetTriple);
         tc->setDisplayName(tc->defaultDisplayName()); // reset displayname
 
         result.append(tc.take());
@@ -902,6 +925,7 @@ void GccToolChainConfigWidget::applyImpl()
     tc->setCompilerCommand(m_compilerCommand->fileName());
     tc->setSupportedAbis(m_abiWidget->supportedAbis());
     tc->setTargetAbi(m_abiWidget->currentAbi());
+    tc->setOriginalTargetTriple(tc->detectSupportedAbis().originalTargetTriple);
     tc->setDisplayName(displayName); // reset display name
     tc->setPlatformCodeGenFlags(splitString(m_platformCodeGenFlagsLineEdit->text()));
     tc->setPlatformLinkerFlags(splitString(m_platformLinkerFlagsLineEdit->text()));
@@ -975,7 +999,7 @@ void GccToolChainConfigWidget::handleCompilerCommandChange()
         QStringList args = gccPredefinedMacrosOptions() + splitString(m_platformCodeGenFlagsLineEdit->text());
         m_macros = gccPredefinedMacros(path, args, env.toStringList());
         abiList = guessGccAbi(path, env.toStringList(), m_macros,
-                              splitString(m_platformCodeGenFlagsLineEdit->text()));
+                              splitString(m_platformCodeGenFlagsLineEdit->text())).supportedAbis;
     }
     m_abiWidget->setEnabled(haveCompiler);
 

src/plugins/projectexplorer/gcctoolchain.h

@@ -54,6 +54,7 @@ public:
     GccToolChain(Core::Id typeId, Detection d);
     QString typeDisplayName() const override;
     Abi targetAbi() const override;
+    QString originalTargetTriple() const override;
     QString version() const;
     QList<Abi> supportedAbis() const;
     void setTargetAbi(const Abi &);
@@ -89,6 +90,19 @@ public:
 
     static void addCommandPathToEnvironment(const Utils::FileName &command, Utils::Environment &env);
 
+    class DetectedAbisResult {
+    public:
+        DetectedAbisResult() = default;
+        DetectedAbisResult(const QList<Abi> &supportedAbis,
+                           const QString &originalTargetTriple = QString())
+            : supportedAbis(supportedAbis)
+            , originalTargetTriple(originalTargetTriple)
+        {}
+
+        QList<Abi> supportedAbis;
+        QString originalTargetTriple;
+    };
+
 protected:
     typedef QList<QPair<QStringList, QByteArray> > GccCache;
 
@@ -98,13 +112,14 @@ protected:
 
     void setCompilerCommand(const Utils::FileName &path);
     void setSupportedAbis(const QList<Abi> &m_abis);
+    void setOriginalTargetTriple(const QString &targetTriple);
     void setMacroCache(const QStringList &allCxxflags, const QByteArray &macroCache) const;
     QByteArray macroCache(const QStringList &allCxxflags) const;
 
     virtual QString defaultDisplayName() const;
     virtual CompilerFlags defaultCompilerFlags() const;
 
-    virtual QList<Abi> detectSupportedAbis() const;
+    virtual DetectedAbisResult detectSupportedAbis() const;
     virtual QString detectVersion() const;
 
     // Reinterpret options for compiler drivers inheriting from GccToolChain (e.g qcc) to apply -Wp option
@@ -139,6 +154,7 @@ private:
 
     Abi m_targetAbi;
     mutable QList<Abi> m_supportedAbis;
+    mutable QString m_originalTargetTriple;
     mutable QList<HeaderPath> m_headerPaths;
     mutable QString m_version;
 

src/plugins/projectexplorer/toolchain.h

@@ -80,6 +80,7 @@ public:
     Core::Id typeId() const;
     virtual QString typeDisplayName() const = 0;
     virtual Abi targetAbi() const = 0;
+    virtual QString originalTargetTriple() const { return QString(); }
 
     virtual bool isValid() const = 0;
 

src/plugins/qnx/qnxtoolchain.cpp

@@ -116,7 +116,7 @@ void QnxToolChain::setNdkPath(const QString &ndkPath)
 }
 
 // qcc doesn't support a "-dumpmachine" option to get supported abis
-QList<Abi> QnxToolChain::detectSupportedAbis() const
+GccToolChain::DetectedAbisResult QnxToolChain::detectSupportedAbis() const
 {
     return qccSupportedAbis();
 }

src/plugins/qnx/qnxtoolchain.h

@@ -51,7 +51,7 @@ public:
     void setNdkPath(const QString &ndkPath);
 
 protected:
-    virtual QList<ProjectExplorer::Abi> detectSupportedAbis() const override;
+    virtual DetectedAbisResult detectSupportedAbis() const override;
 
     QStringList reinterpretOptions(const QStringList &args) const override;