feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Clang: Unify compiler options builders

Browse Source 
Make build command the same for all builders.
Minimize differences.

Change-Id: I1cfe5071b3afb4944ed178fff1e57d3aee45d8a9
Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
This commit is contained in:
Ivan Donchevskii
2017-09-11 14:08:00 +02:00
parent 736e568d94
commit 68a49c79da
15 changed files with 120 additions and 357 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
scripts/deployqt.py
View File

@@ -223,8 +223,6 @@ def deploy_libclang(install_dir, llvm_install_dir, chrpath_bin):
os.path.join(install_dir, 'bin'))) os.path.join(install_dir, 'bin')))
deployinfo.append((os.path.join(llvm_install_dir, 'bin', 'clang.exe'), deployinfo.append((os.path.join(llvm_install_dir, 'bin', 'clang.exe'),
clangbindirtarget)) clangbindirtarget))
deployinfo.append((os.path.join(llvm_install_dir, 'bin', 'clang-cl.exe'),
clangbindirtarget))
resourcetarget = os.path.join(clanglibdirtarget, 'clang') resourcetarget = os.path.join(clanglibdirtarget, 'clang')
else: else:
libsources = glob(os.path.join(llvm_install_dir, 'lib', 'libclang.so*')) libsources = glob(os.path.join(llvm_install_dir, 'lib', 'libclang.so*'))

47
src/plugins/clangcodemodel/clangutils.cpp
View File

@@ -70,46 +70,21 @@ QStringList createClangOptions(const ProjectPart::Ptr &pPart, const QString &fil
return createClangOptions(pPart, fileKind); return createClangOptions(pPart, fileKind);
} }
class LibClangOptionsBuilder : public ClangCompilerOptionsBuilder class LibClangOptionsBuilder final : public ClangCompilerOptionsBuilder
{ {
public: public:
static QStringList build(const ProjectPart::Ptr &projectPart, ProjectFile::Kind fileKind) LibClangOptionsBuilder(const ProjectPart &projectPart)
{
if (projectPart.isNull())
return QStringList();
LibClangOptionsBuilder optionsBuilder(*projectPart.data());
optionsBuilder.addWordWidth();
optionsBuilder.addTargetTriple();
optionsBuilder.addLanguageOption(fileKind);
optionsBuilder.addOptionsForLanguage(/*checkForBorlandExtensions*/ true);
optionsBuilder.enableExceptions();
optionsBuilder.addDefineToAvoidIncludingGccOrMinGwIntrinsics();
optionsBuilder.addDefineFloat128ForMingw();
optionsBuilder.addToolchainAndProjectDefines();
optionsBuilder.undefineCppLanguageFeatureMacrosForMsvc2015();
optionsBuilder.addPredefinedMacrosAndHeaderPathsOptions();
optionsBuilder.addWrappedQtHeadersIncludePath();
optionsBuilder.addHeaderPathOptions();
optionsBuilder.addDummyUiHeaderOnDiskIncludePath();
optionsBuilder.addProjectConfigFileInclude();
optionsBuilder.addMsvcCompatibilityVersion();
optionsBuilder.addExtraOptions();
return optionsBuilder.options();
}
private:
LibClangOptionsBuilder(const CppTools::ProjectPart &projectPart)
: ClangCompilerOptionsBuilder(projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR) : ClangCompilerOptionsBuilder(projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR)
{ {
} }
void addExtraOptions() final
{
addDummyUiHeaderOnDiskIncludePath();
ClangCompilerOptionsBuilder::addExtraOptions();
}
private:
void addDummyUiHeaderOnDiskIncludePath() void addDummyUiHeaderOnDiskIncludePath()
{ {
const QString path = ModelManagerSupportClang::instance()->dummyUiHeaderOnDiskDirPath(); const QString path = ModelManagerSupportClang::instance()->dummyUiHeaderOnDiskDirPath();
@@ -125,7 +100,9 @@ private:
*/ */
QStringList createClangOptions(const ProjectPart::Ptr &pPart, ProjectFile::Kind fileKind) QStringList createClangOptions(const ProjectPart::Ptr &pPart, ProjectFile::Kind fileKind)
{ {
return LibClangOptionsBuilder::build(pPart, fileKind); if (!pPart)
return QStringList();
return LibClangOptionsBuilder(*pPart).build(fileKind, CompilerOptionsBuilder::PchUsage::None);
} }
ProjectPart::Ptr projectPartForFile(const QString &filePath) ProjectPart::Ptr projectPartForFile(const QString &filePath)

32
src/plugins/clangpchmanager/projectupdater.cpp
View File

@@ -108,35 +108,9 @@ HeaderAndSources ProjectUpdater::headerAndSourcesFromProjectPart(
QStringList ProjectUpdater::compilerArguments(CppTools::ProjectPart *projectPart) QStringList ProjectUpdater::compilerArguments(CppTools::ProjectPart *projectPart)
{ {
using CppTools::ClangCompilerOptionsBuilder; using ClangCOBuilder = CppTools::ClangCompilerOptionsBuilder;
ClangCOBuilder builder(*projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR);
ClangCompilerOptionsBuilder builder(*projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR); return builder.build(CppTools::ProjectFile::CXXHeader, ClangCOBuilder::PchUsage::None);
builder.addWordWidth();
builder.addTargetTriple();
builder.addLanguageOption(CppTools::ProjectFile::CXXHeader);
builder.addOptionsForLanguage(/*checkForBorlandExtensions*/ true);
builder.enableExceptions();
builder.addDefineToAvoidIncludingGccOrMinGwIntrinsics();
builder.addDefineFloat128ForMingw();
builder.addToolchainAndProjectDefines();
builder.undefineCppLanguageFeatureMacrosForMsvc2015();
builder.addPredefinedMacrosAndHeaderPathsOptions();
builder.addWrappedQtHeadersIncludePath();
builder.addPrecompiledHeaderOptions(ClangCompilerOptionsBuilder::PchUsage::None);
builder.addHeaderPathOptions();
builder.addProjectConfigFileInclude();
builder.addMsvcCompatibilityVersion();
builder.add("-fmessage-length=0");
builder.add("-fmacro-backtrace-limit=0");
builder.add("-w");
builder.add("-ferror-limit=100000");
return builder.options();
} }
ClangBackEnd::V2::ProjectPartContainer ProjectUpdater::toProjectPartContainer( ClangBackEnd::V2::ProjectPartContainer ProjectUpdater::toProjectPartContainer(

27
src/plugins/clangrefactoring/clangqueryprojectsfindfilter.cpp
View File

@@ -155,31 +155,8 @@ Utils::SmallStringVector ClangQueryProjectsFindFilter::compilerArguments(CppTool
ClangCompilerOptionsBuilder builder(*projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR); ClangCompilerOptionsBuilder builder(*projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR);
builder.addWordWidth(); return Utils::SmallStringVector(builder.build(fileKind,
builder.addTargetTriple(); ClangCompilerOptionsBuilder::PchUsage::None));
builder.addLanguageOption(fileKind);
builder.addOptionsForLanguage(/*checkForBorlandExtensions*/ true);
builder.enableExceptions();
builder.addDefineToAvoidIncludingGccOrMinGwIntrinsics();
builder.addDefineFloat128ForMingw();
builder.addToolchainAndProjectDefines();
builder.undefineCppLanguageFeatureMacrosForMsvc2015();
builder.addPredefinedMacrosAndHeaderPathsOptions();
builder.addWrappedQtHeadersIncludePath();
builder.addPrecompiledHeaderOptions(ClangCompilerOptionsBuilder::PchUsage::None);
builder.addHeaderPathOptions();
builder.addProjectConfigFileInclude();
builder.addMsvcCompatibilityVersion();
builder.add("-fmessage-length=0");
builder.add("-fmacro-backtrace-limit=0");
builder.add("-w");
builder.add("-ferror-limit=1000000");
return Utils::SmallStringVector(builder.options());
} }
QWidget *ClangQueryProjectsFindFilter::widget() const QWidget *ClangQueryProjectsFindFilter::widget() const

8
src/plugins/clangrefactoring/refactoringengine.cpp
View File

@@ -64,12 +64,10 @@ void RefactoringEngine::startLocalRenaming(const CppTools::CursorInEditor &data,
QString filePath = data.filePath().toString(); QString filePath = data.filePath().toString();
QTextCursor textCursor = data.cursor(); QTextCursor textCursor = data.cursor();
Utils::SmallStringVector commandLine{ClangCompilerOptionsBuilder::build( ClangCompilerOptionsBuilder clangCOBuilder{*projectPart, CLANG_VERSION, CLANG_RESOURCE_DIR};
projectPart, Utils::SmallStringVector commandLine{clangCOBuilder.build(
fileKindInProjectPart(projectPart, filePath), fileKindInProjectPart(projectPart, filePath),
CppTools::getPchUsage(), CppTools::getPchUsage())};
CLANG_VERSION,
CLANG_RESOURCE_DIR)};
commandLine.push_back(filePath); commandLine.push_back(filePath);

2
src/plugins/clangstaticanalyzer/clangstaticanalyzerpreconfiguredsessiontests.cpp
View File

@@ -167,7 +167,7 @@ static QList<Target *> validTargets(Project *project)
const ToolChain * const toolchain = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID); const ToolChain * const toolchain = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
QTC_ASSERT(toolchain, return false); QTC_ASSERT(toolchain, return false);
bool hasClangExecutable; bool hasClangExecutable;
clangExecutableFromSettings(toolchain->typeId(), &hasClangExecutable); clangExecutableFromSettings(&hasClangExecutable);
if (!hasClangExecutable) { if (!hasClangExecutable) {
qWarning("Project \"%s\": Skipping target \"%s\" since no suitable clang was found for the toolchain.", qWarning("Project \"%s\": Skipping target \"%s\" since no suitable clang was found for the toolchain.",
qPrintable(projectFileName), qPrintable(projectFileName),

170
src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrol.cpp
View File

@@ -38,7 +38,7 @@
#include <coreplugin/progressmanager/futureprogress.h> #include <coreplugin/progressmanager/futureprogress.h>
#include <coreplugin/progressmanager/progressmanager.h> #include <coreplugin/progressmanager/progressmanager.h>
#include <cpptools/compileroptionsbuilder.h> #include <cpptools/clangcompileroptionsbuilder.h>
#include <cpptools/cppmodelmanager.h> #include <cpptools/cppmodelmanager.h>
#include <cpptools/cppprojectfile.h> #include <cpptools/cppprojectfile.h>
#include <cpptools/cpptoolsreuse.h> #include <cpptools/cpptoolsreuse.h>
@@ -161,8 +161,7 @@ static void prependTargetTripleIfNotIncludedAndNotEmpty(QStringList *arguments,
} }
// Removes (1) inputFile (2) -o <somePath>. // Removes (1) inputFile (2) -o <somePath>.
QStringList inputAndOutputArgumentsRemoved(const QString &inputFile, const QStringList &arguments, QStringList inputAndOutputArgumentsRemoved(const QString &inputFile, const QStringList &arguments)
bool isMsvc)
{ {
QStringList newArguments; QStringList newArguments;
@@ -174,9 +173,6 @@ QStringList inputAndOutputArgumentsRemoved(const QString &inputFile, const QStri
} else if (argument == QLatin1String("-o")) { } else if (argument == QLatin1String("-o")) {
skip = true; skip = true;
continue; continue;
} else if (isMsvc && argument == QLatin1String("-target")) {
skip = true;
continue;
} else if (QDir::fromNativeSeparators(argument) == inputFile) { } else if (QDir::fromNativeSeparators(argument) == inputFile) {
continue; // TODO: Let it in? continue; // TODO: Let it in?
} }
@@ -188,55 +184,11 @@ QStringList inputAndOutputArgumentsRemoved(const QString &inputFile, const QStri
return newArguments; return newArguments;
} }
static QString createLanguageOptionMsvc(ProjectFile::Kind fileKind) class ClangStaticAnalyzerOptionsBuilder final : public ClangCompilerOptionsBuilder
{
switch (fileKind) {
case ProjectFile::CHeader:
case ProjectFile::CSource:
return QLatin1String("/TC");
break;
case ProjectFile::CXXHeader:
case ProjectFile::CXXSource:
return QLatin1String("/TP");
break;
default:
break;
}
return QString();
}
class ClangStaticAnalyzerOptionsBuilder : public CompilerOptionsBuilder
{ {
public: public:
static QStringList build(const CppTools::ProjectPart &projectPart,
CppTools::ProjectFile::Kind fileKind,
PchUsage pchUsage)
{
ClangStaticAnalyzerOptionsBuilder optionsBuilder(projectPart);
optionsBuilder.addWordWidth();
optionsBuilder.addTargetTriple();
optionsBuilder.addLanguageOption(fileKind);
optionsBuilder.addOptionsForLanguage(false);
optionsBuilder.enableExceptions();
optionsBuilder.addDefineFloat128ForMingw();
optionsBuilder.addDefineToAvoidIncludingGccOrMinGwIntrinsics();
const Core::Id type = projectPart.toolchainType;
if (type != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID)
optionsBuilder.addMacros(projectPart.toolChainMacros);
optionsBuilder.addMacros(projectPart.projectMacros);
optionsBuilder.undefineClangVersionMacrosForMsvc();
optionsBuilder.undefineCppLanguageFeatureMacrosForMsvc2015();
optionsBuilder.addHeaderPathOptions();
optionsBuilder.addPrecompiledHeaderOptions(pchUsage);
optionsBuilder.addMsvcCompatibilityVersion();
return optionsBuilder.options();
}
ClangStaticAnalyzerOptionsBuilder(const CppTools::ProjectPart &projectPart) ClangStaticAnalyzerOptionsBuilder(const CppTools::ProjectPart &projectPart)
: CompilerOptionsBuilder(projectPart) : ClangCompilerOptionsBuilder(projectPart)
, m_isMsvcToolchain(m_projectPart.toolchainType , m_isMsvcToolchain(m_projectPart.toolchainType
== ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID)
, m_isMinGWToolchain(m_projectPart.toolchainType , m_isMinGWToolchain(m_projectPart.toolchainType
@@ -244,91 +196,28 @@ public:
{ {
} }
public: bool excludeHeaderPath(const QString &headerPath) const final
bool excludeHeaderPath(const QString &headerPath) const override
{ {
if (CompilerOptionsBuilder::excludeHeaderPath(headerPath))
return true;
if (m_isMinGWToolchain && headerPath.contains(m_projectPart.toolChainTargetTriple)) if (m_isMinGWToolchain && headerPath.contains(m_projectPart.toolChainTargetTriple))
return true; return true;
return false; return ClangCompilerOptionsBuilder::excludeHeaderPath(headerPath);
} }
void undefineClangVersionMacrosForMsvc() void addPredefinedHeaderPathsOptions() final
{ {
if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) { add("-undef");
static QStringList macroNames { if (m_isMsvcToolchain) {
"__clang__", // exclude default clang path to use msvc includes
"__clang_major__", add("-nostdinc");
"__clang_minor__", add("-nostdlibinc");
"__clang_patchlevel__",
"__clang_version__"
};
foreach (const QString &macroName, macroNames)
add(QLatin1String("/U") + macroName);
} }
} }
private: void addExtraOptions() final {}
void addTargetTriple() override
{
// For MSVC toolchains we use clang-cl.exe, so there is nothing to do here since
// 1) clang-cl.exe does not understand the "-triple" option
// 2) clang-cl.exe already hardcodes the right triple value (even if built with mingw)
if (!m_isMsvcToolchain)
CompilerOptionsBuilder::addTargetTriple();
}
void addLanguageOption(ProjectFile::Kind fileKind) override void addWrappedQtHeadersIncludePath() final
{ {
if (m_isMsvcToolchain) // Empty, analyzer doesn't need them
add(createLanguageOptionMsvc(fileKind));
else
CompilerOptionsBuilder::addLanguageOption(fileKind);
}
void addOptionsForLanguage(bool checkForBorlandExtensions) override
{
if (m_isMsvcToolchain)
return;
CompilerOptionsBuilder::addOptionsForLanguage(checkForBorlandExtensions);
}
QString includeOption() const override
{
if (m_isMsvcToolchain)
return QLatin1String("/FI");
return CompilerOptionsBuilder::includeOption();
}
QString includeDirOption() const override
{
if (m_isMsvcToolchain)
return QLatin1String("/I");
return CompilerOptionsBuilder::includeDirOption();
}
QString defineOption() const override
{
if (m_isMsvcToolchain)
return QLatin1String("/D");
return CompilerOptionsBuilder::defineOption();
}
QString undefineOption() const override
{
if (m_isMsvcToolchain)
return QLatin1String("/U");
return CompilerOptionsBuilder::undefineOption();
}
void enableExceptions() override
{
if (m_isMsvcToolchain)
add(QLatin1String("/EHsc"));
else
CompilerOptionsBuilder::enableExceptions();
} }
private: private:
@@ -383,7 +272,7 @@ static QStringList tweakedArguments(const ProjectPart &projectPart,
{ {
const bool isMsvc = projectPart.toolchainType const bool isMsvc = projectPart.toolchainType
== ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID; == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
QStringList newArguments = inputAndOutputArgumentsRemoved(filePath, arguments, isMsvc); QStringList newArguments = inputAndOutputArgumentsRemoved(filePath, arguments);
prependWordWidthArgumentIfNotIncluded(&newArguments, projectPart.toolChainWordWidth); prependWordWidthArgumentIfNotIncluded(&newArguments, projectPart.toolChainWordWidth);
if (!isMsvc) if (!isMsvc)
prependTargetTripleIfNotIncludedAndNotEmpty(&newArguments, targetTriple); prependTargetTripleIfNotIncludedAndNotEmpty(&newArguments, targetTriple);
@@ -434,7 +323,7 @@ static AnalyzeUnits unitsToAnalyzeFromProjectParts(const QVector<ProjectPart::Pt
AnalyzeUnits unitsToAnalyze; AnalyzeUnits unitsToAnalyze;
foreach (const ProjectPart::Ptr &projectPart, projectParts) { foreach (const ProjectPart::Ptr &projectPart, projectParts) {
if (!projectPart->selectedForBuilding) if (!projectPart->selectedForBuilding || !projectPart.data())
continue; continue;
foreach (const ProjectFile &file, projectPart->files) { foreach (const ProjectFile &file, projectPart->files) {
@@ -445,7 +334,7 @@ static AnalyzeUnits unitsToAnalyzeFromProjectParts(const QVector<ProjectPart::Pt
if (ProjectFile::isSource(file.kind)) { if (ProjectFile::isSource(file.kind)) {
const CompilerOptionsBuilder::PchUsage pchUsage = CppTools::getPchUsage(); const CompilerOptionsBuilder::PchUsage pchUsage = CppTools::getPchUsage();
const QStringList arguments const QStringList arguments
= ClangStaticAnalyzerOptionsBuilder::build(*projectPart.data(), file.kind, pchUsage); = ClangStaticAnalyzerOptionsBuilder(*projectPart).build(file.kind, pchUsage);
unitsToAnalyze << AnalyzeUnit(file.path, arguments); unitsToAnalyze << AnalyzeUnit(file.path, arguments);
} }
} }
@@ -501,21 +390,6 @@ static QDebug operator<<(QDebug debug, const AnalyzeUnits &analyzeUnits)
return debug; return debug;
} }
static QString executableForVersionCheck(Core::Id toolchainType, const QString &executable)
{
if (toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) {
const QString suffix = QLatin1String("-cl.exe");
if (executable.endsWith(suffix, Utils::HostOsInfo::fileNameCaseSensitivity())) {
QString modified = executable;
modified.chop(suffix.length());
modified.append(QLatin1String(".exe"));
return modified;
}
}
return executable;
}
void ClangStaticAnalyzerToolRunner::start() void ClangStaticAnalyzerToolRunner::start()
{ {
m_success = false; m_success = false;
@@ -532,8 +406,7 @@ void ClangStaticAnalyzerToolRunner::start()
// Check clang executable // Check clang executable
bool isValidClangExecutable; bool isValidClangExecutable;
const QString executable = clangExecutableFromSettings(m_toolChainType, const QString executable = clangExecutableFromSettings(&isValidClangExecutable);
&isValidClangExecutable);
if (!isValidClangExecutable) { if (!isValidClangExecutable) {
const QString errorMessage = tr("Clang Static Analyzer: Invalid executable \"%1\", stop.") const QString errorMessage = tr("Clang Static Analyzer: Invalid executable \"%1\", stop.")
.arg(executable); .arg(executable);
@@ -545,13 +418,12 @@ void ClangStaticAnalyzerToolRunner::start()
} }
// Check clang version // Check clang version
const QString versionCheckExecutable = executableForVersionCheck(m_toolChainType, executable); const ClangExecutableVersion version = clangExecutableVersion(executable);
const ClangExecutableVersion version = clangExecutableVersion(versionCheckExecutable);
if (!version.isValid()) { if (!version.isValid()) {
const QString warningMessage const QString warningMessage
= tr("Clang Static Analyzer: Running with possibly unsupported version, " = tr("Clang Static Analyzer: Running with possibly unsupported version, "
"could not determine version from executable \"%1\".") "could not determine version from executable \"%1\".")
.arg(versionCheckExecutable); .arg(executable);
appendMessage(warningMessage, Utils::StdErrFormat); appendMessage(warningMessage, Utils::StdErrFormat);
TaskHub::addTask(Task::Warning, warningMessage, Debugger::Constants::ANALYZERTASK_ID); TaskHub::addTask(Task::Warning, warningMessage, Debugger::Constants::ANALYZERTASK_ID);
TaskHub::requestPopup(); TaskHub::requestPopup();

2
src/plugins/clangstaticanalyzer/clangstaticanalyzerunittests.cpp
View File

@@ -58,7 +58,7 @@ void ClangStaticAnalyzerUnitTests::initTestCase()
if (!toolchain) if (!toolchain)
QSKIP("This test requires that there is a kit with a toolchain."); QSKIP("This test requires that there is a kit with a toolchain.");
bool hasClangExecutable; bool hasClangExecutable;
clangExecutableFromSettings(toolchain->typeId(), &hasClangExecutable); clangExecutableFromSettings(&hasClangExecutable);
if (!hasClangExecutable) if (!hasClangExecutable)
QSKIP("No clang suitable for analyzing found"); QSKIP("No clang suitable for analyzing found");

10
src/plugins/clangstaticanalyzer/clangstaticanalyzerutils.cpp
View File

@@ -50,7 +50,7 @@ static bool isFileExecutable(const QString &executablePath)
namespace ClangStaticAnalyzer { namespace ClangStaticAnalyzer {
namespace Internal { namespace Internal {
QString clangExecutableFromSettings(Core::Id toolchainType, bool *isValid) QString clangExecutableFromSettings(bool *isValid)
{ {
QString executable = ClangStaticAnalyzerSettings::instance()->clangExecutable(); QString executable = ClangStaticAnalyzerSettings::instance()->clangExecutable();
if (executable.isEmpty()) { if (executable.isEmpty()) {
@@ -62,14 +62,6 @@ QString clangExecutableFromSettings(Core::Id toolchainType, bool *isValid)
const Qt::CaseSensitivity caseSensitivity = Utils::HostOsInfo::fileNameCaseSensitivity(); const Qt::CaseSensitivity caseSensitivity = Utils::HostOsInfo::fileNameCaseSensitivity();
const bool hasSuffix = executable.endsWith(hostExeSuffix, caseSensitivity); const bool hasSuffix = executable.endsWith(hostExeSuffix, caseSensitivity);
if (toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) {
if (hasSuffix)
executable.chop(hostExeSuffix.length());
executable.append(QLatin1String("-cl"));
if (hasSuffix)
executable.append(hostExeSuffix);
}
const QFileInfo fileInfo = QFileInfo(executable); const QFileInfo fileInfo = QFileInfo(executable);
if (fileInfo.isAbsolute()) { if (fileInfo.isAbsolute()) {
if (!hasSuffix) if (!hasSuffix)

2
src/plugins/clangstaticanalyzer/clangstaticanalyzerutils.h
View File

@@ -41,7 +41,7 @@ namespace Internal {
bool isClangExecutableUsable(const QString &filePath, QString *errorMessage = 0); bool isClangExecutableUsable(const QString &filePath, QString *errorMessage = 0);
QString clangExecutableFromSettings(Core::Id toolchainType, bool *isValid); QString clangExecutableFromSettings(bool *isValid);
QString createFullLocationString(const Debugger::DiagnosticLocation &location); QString createFullLocationString(const Debugger::DiagnosticLocation &location);

117
src/plugins/cpptools/clangcompileroptionsbuilder.cpp
View File

@@ -26,7 +26,6 @@
#include "clangcompileroptionsbuilder.h" #include "clangcompileroptionsbuilder.h"
#include <coreplugin/icore.h> #include <coreplugin/icore.h>
#include <projectexplorer/projectexplorerconstants.h> #include <projectexplorer/projectexplorerconstants.h>
#include <utils/qtcassert.h> #include <utils/qtcassert.h>
@@ -37,6 +36,15 @@ namespace CppTools {
static QString creatorResourcePath() static QString creatorResourcePath()
{ {
#ifndef UNIT_TESTS
return Core::ICore::instance()->resourcePath();
#else
return QString();
#endif
}
static QString creatorLibexecPath()
{
#ifndef UNIT_TESTS #ifndef UNIT_TESTS
return Core::ICore::instance()->libexecPath(); return Core::ICore::instance()->libexecPath();
#else #else
@@ -44,40 +52,31 @@ static QString creatorResourcePath()
#endif #endif
} }
QStringList ClangCompilerOptionsBuilder::build(const CppTools::ProjectPart *projectPart, QStringList ClangCompilerOptionsBuilder::build(CppTools::ProjectFile::Kind fileKind,
CppTools::ProjectFile::Kind fileKind, PchUsage pchUsage)
PchUsage pchUsage,
const QString &clangVersion,
const QString &clangResourceDirectory)
{ {
if (projectPart) { addWordWidth();
ClangCompilerOptionsBuilder builder(*projectPart, clangVersion, clangResourceDirectory); addTargetTriple();
addLanguageOption(fileKind);
addOptionsForLanguage(/*checkForBorlandExtensions*/ true);
enableExceptions();
builder.addWordWidth(); addDefineFloat128ForMingw();
builder.addTargetTriple(); addToolchainAndProjectMacros();
builder.addLanguageOption(fileKind); undefineClangVersionMacrosForMsvc();
builder.addOptionsForLanguage(/*checkForBorlandExtensions*/ true); undefineCppLanguageFeatureMacrosForMsvc2015();
builder.enableExceptions();
builder.addDefineToAvoidIncludingGccOrMinGwIntrinsics(); addPredefinedHeaderPathsOptions();
builder.addDefineFloat128ForMingw(); addWrappedQtHeadersIncludePath();
builder.addToolchainAndProjectDefines(); addPrecompiledHeaderOptions(pchUsage);
builder.undefineCppLanguageFeatureMacrosForMsvc2015(); addHeaderPathOptions();
addProjectConfigFileInclude();
builder.addPredefinedMacrosAndHeaderPathsOptions(); addMsvcCompatibilityVersion();
builder.addWrappedQtHeadersIncludePath();
builder.addPrecompiledHeaderOptions(pchUsage);
builder.addHeaderPathOptions();
builder.addProjectConfigFileInclude();
builder.addMsvcCompatibilityVersion(); addExtraOptions();
builder.addExtraOptions(); return options();
return builder.options();
}
return QStringList();
} }
ClangCompilerOptionsBuilder::ClangCompilerOptionsBuilder(const CppTools::ProjectPart &projectPart, ClangCompilerOptionsBuilder::ClangCompilerOptionsBuilder(const CppTools::ProjectPart &projectPart,
@@ -91,47 +90,35 @@ ClangCompilerOptionsBuilder::ClangCompilerOptionsBuilder(const CppTools::Project
bool ClangCompilerOptionsBuilder::excludeHeaderPath(const QString &path) const bool ClangCompilerOptionsBuilder::excludeHeaderPath(const QString &path) const
{ {
if (m_projectPart.toolchainType == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) { if (m_projectPart.toolchainType == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID
if (path.contains("lib/gcc/i686-apple-darwin")) && path.contains("lib/gcc/i686-apple-darwin")) {
return true; return true;
} }
return CompilerOptionsBuilder::excludeHeaderPath(path); return CompilerOptionsBuilder::excludeHeaderPath(path);
} }
void ClangCompilerOptionsBuilder::addPredefinedMacrosAndHeaderPathsOptions() void ClangCompilerOptionsBuilder::addPredefinedHeaderPathsOptions()
{ {
if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID)
addPredefinedMacrosAndHeaderPathsOptionsForMsvc();
else
addPredefinedMacrosAndHeaderPathsOptionsForNonMsvc();
}
void ClangCompilerOptionsBuilder::addPredefinedMacrosAndHeaderPathsOptionsForMsvc()
{
add("-nostdinc");
add("-undef"); add("-undef");
} add("-nostdinc");
add("-nostdlibinc");
void ClangCompilerOptionsBuilder::addPredefinedMacrosAndHeaderPathsOptionsForNonMsvc() if (m_projectPart.toolchainType != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID)
{ add(includeDirOption() + clangIncludeDirectory());
static const QString resourceDir = clangIncludeDirectory();
if (QTC_GUARD(!resourceDir.isEmpty())) {
add("-nostdlibinc");
add("-I" + QDir::toNativeSeparators(resourceDir));
add("-undef");
}
} }
void ClangCompilerOptionsBuilder::addWrappedQtHeadersIncludePath() void ClangCompilerOptionsBuilder::addWrappedQtHeadersIncludePath()
{ {
static const QString wrappedQtHeadersPath = creatorResourcePath() static const QString resourcePath = creatorResourcePath();
+ "/cplusplus/wrappedQtHeaders"; static QString wrappedQtHeadersPath = resourcePath + "/cplusplus/wrappedQtHeaders";
QDir dir(wrappedQtHeadersPath);
QTC_ASSERT(QDir(wrappedQtHeadersPath).exists(), return;);
if (m_projectPart.qtVersion != CppTools::ProjectPart::NoQt) { if (m_projectPart.qtVersion != CppTools::ProjectPart::NoQt) {
const QString wrappedQtCoreHeaderPath = wrappedQtHeadersPath + "/QtCore"; const QString wrappedQtCoreHeaderPath = wrappedQtHeadersPath + "/QtCore";
add("-I" + QDir::toNativeSeparators(wrappedQtHeadersPath)); add(includeDirOption() + QDir::toNativeSeparators(wrappedQtHeadersPath));
add("-I" + QDir::toNativeSeparators(wrappedQtCoreHeaderPath)); add(includeDirOption() + QDir::toNativeSeparators(wrappedQtCoreHeaderPath));
} }
} }
@@ -154,12 +141,26 @@ void ClangCompilerOptionsBuilder::addExtraOptions()
QString ClangCompilerOptionsBuilder::clangIncludeDirectory() const QString ClangCompilerOptionsBuilder::clangIncludeDirectory() const
{ {
QDir dir(creatorResourcePath() + "/clang/lib/clang/" + m_clangVersion + "/include"); QDir dir(creatorLibexecPath() + "/clang/lib/clang/" + m_clangVersion + "/include");
if (!dir.exists() || !QFileInfo(dir, "stdint.h").exists()) if (!dir.exists() || !QFileInfo(dir, "stdint.h").exists())
dir = QDir(m_clangResourceDirectory); dir = QDir(m_clangResourceDirectory);
return QDir::toNativeSeparators(dir.canonicalPath());
}
return dir.canonicalPath(); void ClangCompilerOptionsBuilder::undefineClangVersionMacrosForMsvc()
{
if (m_projectPart.toolchainType == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) {
static QStringList macroNames {
"__clang__",
"__clang_major__",
"__clang_minor__",
"__clang_patchlevel__",
"__clang_version__"
};
foreach (const QString &macroName, macroNames)
add(undefineOption() + macroName);
}
} }
} // namespace CppTools } // namespace CppTools

27
src/plugins/cpptools/clangcompileroptionsbuilder.h
View File

@@ -34,33 +34,24 @@ namespace CppTools {
class CPPTOOLS_EXPORT ClangCompilerOptionsBuilder : public CompilerOptionsBuilder class CPPTOOLS_EXPORT ClangCompilerOptionsBuilder : public CompilerOptionsBuilder
{ {
public: public:
static QStringList build(const ProjectPart *projectPart, QStringList build(ProjectFile::Kind fileKind,
ProjectFile::Kind fileKind, PchUsage pchUsage);
PchUsage pchUsage,
const QString &clangVersion,
const QString &clangResourceDirectory);
ClangCompilerOptionsBuilder(const ProjectPart &projectPart, ClangCompilerOptionsBuilder(const ProjectPart &projectPart,
const QString &clangVersion, const QString &clangVersion = QString(),
const QString &clangResourceDirectory); const QString &clangResourceDirectory = QString());
virtual void addPredefinedHeaderPathsOptions();
virtual void addExtraOptions();
bool excludeHeaderPath(const QString &path) const override; bool excludeHeaderPath(const QString &path) const override;
void addPredefinedMacrosAndHeaderPathsOptions(); virtual void addWrappedQtHeadersIncludePath();
void addPredefinedMacrosAndHeaderPathsOptionsForMsvc();
void addPredefinedMacrosAndHeaderPathsOptionsForNonMsvc();
void addWrappedQtHeadersIncludePath();
void addProjectConfigFileInclude(); void addProjectConfigFileInclude();
void addExtraOptions(); void undefineClangVersionMacrosForMsvc();
private: private:
QString clangIncludeDirectory() const; QString clangIncludeDirectory() const;
private:
QString m_clangVersion; QString m_clangVersion;
QString m_clangResourceDirectory; QString m_clangResourceDirectory;
}; };

17
src/plugins/cpptools/compileroptionsbuilder.cpp
View File

@@ -125,7 +125,7 @@ void CompilerOptionsBuilder::addPrecompiledHeaderOptions(PchUsage pchUsage)
m_options.append(result); m_options.append(result);
} }
void CompilerOptionsBuilder::addToolchainAndProjectDefines() void CompilerOptionsBuilder::addToolchainAndProjectMacros()
{ {
addMacros(m_projectPart.toolChainMacros); addMacros(m_projectPart.toolChainMacros);
addMacros(m_projectPart.projectMacros); addMacros(m_projectPart.projectMacros);
@@ -258,21 +258,6 @@ void CompilerOptionsBuilder::addOptionsForLanguage(bool checkForBorlandExtension
m_options.append(opts); m_options.append(opts);
} }
void CompilerOptionsBuilder::addDefineToAvoidIncludingGccOrMinGwIntrinsics()
{
// In gcc headers, lots of built-ins are referenced that clang does not understand.
// Therefore, prevent the inclusion of the header that references them. Of course, this
// will break if code actually requires stuff from there, but that should be the less common
// case.
const Core::Id type = m_projectPart.toolchainType;
if (type == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID
|| type == ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID) {
addDefine({"_X86INTRIN_H_INCLUDED"});
addDefine({"BOOST_UUID_NO_SIMD"});
}
}
static QByteArray toMsCompatibilityVersionFormat(const QByteArray &mscFullVer) static QByteArray toMsCompatibilityVersionFormat(const QByteArray &mscFullVer)
{ {
return mscFullVer.left(2) return mscFullVer.left(2)

4
src/plugins/cpptools/compileroptionsbuilder.h
View File

@@ -54,13 +54,11 @@ public:
virtual void enableExceptions(); virtual void enableExceptions();
void addHeaderPathOptions(); void addHeaderPathOptions();
void addPrecompiledHeaderOptions(PchUsage pchUsage); void addPrecompiledHeaderOptions(PchUsage pchUsage);
void addToolchainAndProjectDefines(); void addToolchainAndProjectMacros();
void addMacros(const ProjectExplorer::Macros &macros); void addMacros(const ProjectExplorer::Macros &macros);
virtual void addLanguageOption(ProjectFile::Kind fileKind); virtual void addLanguageOption(ProjectFile::Kind fileKind);
virtual void addOptionsForLanguage(bool checkForBorlandExtensions = true); virtual void addOptionsForLanguage(bool checkForBorlandExtensions = true);
void addDefineToAvoidIncludingGccOrMinGwIntrinsics();
void addMsvcCompatibilityVersion(); void addMsvcCompatibilityVersion();
void undefineCppLanguageFeatureMacrosForMsvc2015(); void undefineCppLanguageFeatureMacrosForMsvc2015();

10
tests/unit/unittest/refactoringengine-test.cpp
View File

@@ -129,12 +129,12 @@ void RefactoringEngine::SetUp()
projectPart = CppTools::ProjectPart::Ptr(new CppTools::ProjectPart); projectPart = CppTools::ProjectPart::Ptr(new CppTools::ProjectPart);
projectPart->files.push_back(projectFile); projectPart->files.push_back(projectFile);
commandLine = Utils::SmallStringVector(ClangCompilerOptionsBuilder::build( ClangCompilerOptionsBuilder clangCOBuilder(*projectPart,
projectPart.data(),
projectFile.kind,
CppTools::CompilerOptionsBuilder::PchUsage::None,
CLANG_VERSION, CLANG_VERSION,
CLANG_RESOURCE_DIR)); CLANG_RESOURCE_DIR);
commandLine = Utils::SmallStringVector(clangCOBuilder.build(
projectFile.kind,
CppTools::CompilerOptionsBuilder::PchUsage::None));
commandLine.push_back(qStringFilePath); commandLine.push_back(qStringFilePath);
} }