clang-cl: Fix macro dumping

Previously, clang.exe was used to dump macro as clang-cl does not
support the MSVC way. Also, architecture was not detected correctly
because of the wrong assumption that clang-cl respects arch variables
set by the vcvarsall.bat

Change-Id: Ic6464c2bd90f1a2fceb2f8aa884721872179ff49
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

3 files changed, 34 insertions, 25 deletions

diff --git a/share/qbs/imports/qbs/Probes/ClangClProbe.qbs b/share/qbs/imports/qbs/Probes/ClangClProbe.qbs
index c7687f0e9..8205e92fa 100644
--- a/share/qbs/imports/qbs/Probes/ClangClProbe.qbs
+++ b/share/qbs/imports/qbs/Probes/ClangClProbe.qbs
@@ -39,7 +39,7 @@ PathProbe {
     property string compilerFilePath
     property string vcvarsallFilePath
     property stringList enableDefinesByLanguage
-    property string architecture
+    property string preferredArchitecture
     property string _nullDevice: qbs.nullDevice
     property string _pathListSeparator: qbs.pathListSeparator
 
@@ -48,6 +48,7 @@ PathProbe {
     property int versionMinor
     property int versionPatch
     property stringList includePaths
+    property string architecture
     property var buildEnv
     property var compilerDefinesByLanguage
 
@@ -57,9 +58,9 @@ PathProbe {
             languages = ["c"];
 
         var info = languages.contains("c")
-                ? Utilities.clangClCompilerInfo(compilerFilePath, architecture, vcvarsallFilePath, "c") : {};
+                ? Utilities.clangClCompilerInfo(compilerFilePath, preferredArchitecture, vcvarsallFilePath, "c") : {};
         var infoCpp = languages.contains("cpp")
-                ? Utilities.clangClCompilerInfo(compilerFilePath, architecture, vcvarsallFilePath, "cpp") : {};
+                ? Utilities.clangClCompilerInfo(compilerFilePath, preferredArchitecture, vcvarsallFilePath, "cpp") : {};
         found = (!languages.contains("c") ||
                  (!!info && !!info.macros && !!info.buildEnvironment))
              && (!languages.contains("cpp") ||
@@ -84,5 +85,6 @@ PathProbe {
                                                 [], _nullDevice,
                                                 _pathListSeparator, "", "");
         includePaths = defaultPaths.includePaths;
+        architecture = ModUtils.guessArchitecture(macros);
     }
 }
diff --git a/share/qbs/modules/cpp/windows-clang-cl.qbs b/share/qbs/modules/cpp/windows-clang-cl.qbs
index 2ac3f356a..d57f5a7ad 100644
--- a/share/qbs/modules/cpp/windows-clang-cl.qbs
+++ b/share/qbs/modules/cpp/windows-clang-cl.qbs
@@ -52,9 +52,11 @@ MsvcBaseModule {
         compilerFilePath: compilerPath
         vcvarsallFilePath: vcvarsallPath
         enableDefinesByLanguage: enableCompilerDefinesByLanguage
-        architecture: qbs.architecture
+        preferredArchitecture: qbs.architecture
     }
 
+    qbs.architecture: clangClProbe.found ? clangClProbe.architecture : original
+
     compilerVersionMajor: clangClProbe.versionMajor
     compilerVersionMinor: clangClProbe.versionMinor
     compilerVersionPatch: clangClProbe.versionPatch
diff --git a/src/lib/corelib/tools/msvcinfo.cpp b/src/lib/corelib/tools/msvcinfo.cpp
index 73d22d329..9ece7b8be 100644
--- a/src/lib/corelib/tools/msvcinfo.cpp
+++ b/src/lib/corelib/tools/msvcinfo.cpp
@@ -209,30 +209,32 @@ static QVariantMap getMsvcDefines(const QString &compilerFilePath,
 static QVariantMap getClangClDefines(
         const QString &compilerFilePath,
         const QProcessEnvironment &compilerEnv,
-        MSVC::CompilerLanguage language)
+        MSVC::CompilerLanguage language,
+        const QString &arch)
 {
 #ifdef Q_OS_WIN
     QFileInfo clInfo(compilerFilePath);
-    QFileInfo clangInfo(clInfo.absolutePath() + QLatin1String("/clang.exe"));
+    QFileInfo clangInfo(clInfo.absolutePath() + QLatin1String("/clang-cl.exe"));
     if (!clangInfo.exists())
         throw ErrorInfo(QStringLiteral("%1 does not exist").arg(clangInfo.absoluteFilePath()));
 
-    QString languageSwitch;
-    switch (language) {
-    case MSVC::CLanguage:
-        languageSwitch = QStringLiteral("c");
-        break;
-    case MSVC::CPlusPlusLanguage:
-        languageSwitch = QStringLiteral("c++");
-        break;
-    }
     QStringList args = {
-        QStringLiteral("-dM"),
-        QStringLiteral("-E"),
-        QStringLiteral("-x"),
-        languageSwitch,
-        QStringLiteral("NUL"),
+        QStringLiteral("/d1PP"), // dump macros
+        QStringLiteral("/E") // preprocess to stdout
     };
+
+    if (language == MSVC::CLanguage)
+        args.append(QStringLiteral("/TC"));
+    else if (language == MSVC::CPlusPlusLanguage)
+        args.append(QStringLiteral("/TP"));
+
+    if (arch == QLatin1String("x86"))
+        args.append(QStringLiteral("-m32"));
+    else if (arch == QLatin1String("x86_64"))
+        args.append(QStringLiteral("-m64"));
+
+    args.append(QStringLiteral("NUL")); // filename
+
     const auto lines = QString::fromLocal8Bit(
             runProcess(
                     clangInfo.absoluteFilePath(),
@@ -242,10 +244,8 @@ static QVariantMap getClangClDefines(
     QVariantMap result;
     for (const auto &line: lines) {
         static const auto defineString = QLatin1String("#define ");
-        if (!line.startsWith(defineString)) {
-            throw ErrorInfo(QStringLiteral("Unexpected compiler frontend output: ")
-                            + lines.join(QLatin1Char('\n')));
-        }
+        if (!line.startsWith(defineString))
+            continue;
         QStringView view(line.data() + defineString.size());
         const auto it = std::find(view.begin(), view.end(), QLatin1Char(' '));
         if (it == view.end()) {
@@ -256,11 +256,16 @@ static QVariantMap getClangClDefines(
         QStringView value(it + 1, view.end());
         result.insert(key.toString(), value.isEmpty() ? QVariant() : QVariant(value.toString()));
     }
+    if (result.isEmpty()) {
+        throw ErrorInfo(QStringLiteral("Cannot determine macroses from compiler frontend output: ")
+                        + lines.join(QLatin1Char('\n')));
+    }
     return result;
 #else
     Q_UNUSED(compilerFilePath);
     Q_UNUSED(compilerEnv);
     Q_UNUSED(language);
+    Q_UNUSED(arch);
     return {};
 #endif
 }
@@ -304,7 +309,7 @@ QVariantMap MSVC::compilerDefines(const QString &compilerFilePath,
 {
     const auto compilerName = QFileInfo(compilerFilePath).fileName().toLower();
     if (compilerName == QLatin1String("clang-cl.exe"))
-        return getClangClDefines(compilerFilePath, environment, language);
+        return getClangClDefines(compilerFilePath, environment, language, architecture);
     return getMsvcDefines(compilerFilePath, environment, language);
 }