Abi AbiWidget::currentAbi() const
{
if (d->m_abi->currentIndex() > 0)
return Abi(d->m_abi->itemData(d->m_abi->currentIndex()).toString());
return Abi(static_cast<Abi::Architecture>(d->m_architectureComboBox->currentIndex()),
static_cast<Abi::OS>(d->m_osComboBox->currentIndex()),
static_cast<Abi::OSFlavor>(d->m_osFlavorComboBox->itemData(d->m_osFlavorComboBox->currentIndex()).toInt()),
static_cast<Abi::BinaryFormat>(d->m_binaryFormatComboBox->currentIndex()),
d->m_wordWidthComboBox->itemData(d->m_wordWidthComboBox->currentIndex()).toInt());
}
Abi Abi::hostAbi()
{
Architecture arch = QTC_CPU; // define set by qmake
OS os = UnknownOS;
OSFlavor subos = UnknownFlavor;
BinaryFormat format = UnknownFormat;
#if defined (Q_OS_WIN)
os = WindowsOS;
#if _MSC_VER == 1600
subos = WindowsMsvc2010Flavor;
#elif _MSC_VER == 1500
subos = WindowsMsvc2008Flavor;
#elif _MSC_VER == 1400
subos = WindowsMsvc2005Flavor;
#elif defined (mingw32)
subos = WindowsMSysFlavor;
#endif
format = PEFormat;
#elif defined (Q_OS_LINUX)
os = LinuxOS;
subos = GenericLinuxFlavor;
format = ElfFormat;
#elif defined (Q_OS_MAC)
os = MacOS;
subos = GenericMacFlavor;
format = MachOFormat;
#endif
return Abi(arch, os, subos, format, QSysInfo::WordSize);
}
QList<Abi> AbiWidget::supportedAbis() const
{
QList<Abi> result;
for (int i = 1; i < d->m_abi->count(); ++i)
result << Abi(d->m_abi->itemData(i).toString());
return result;
}
void GccToolChain::setCompilerCommand(const Utils::FileName &path)
{
if (path == m_compilerCommand)
return;
bool resetDisplayName = displayName() == defaultDisplayName();
m_compilerCommand = path;
Abi currentAbi = m_targetAbi;
m_supportedAbis = detectSupportedAbis();
m_targetAbi = Abi();
if (!m_supportedAbis.isEmpty()) {
if (m_supportedAbis.contains(currentAbi))
m_targetAbi = currentAbi;
else
m_targetAbi = m_supportedAbis.at(0);
}
if (resetDisplayName)
setDisplayName(defaultDisplayName()); // calls toolChainUpdated()!
else
toolChainUpdated();
}
static QList<Abi> parseCoffHeader(const QByteArray &data)
{
QList<Abi> result;
if (data.size() < 20)
return result;
Abi::Architecture arch = Abi::UnknownArchitecture;
Abi::OSFlavor flavor = Abi::UnknownFlavor;
int width = 0;
// Get machine field from COFF file header
quint16 machine = getLEUint16(data, 0);
switch (machine) {
case 0x8664: // x86_64
arch = Abi::X86Architecture;
width = 64;
break;
case 0x014c: // i386
arch = Abi::X86Architecture;
width = 32;
break;
case 0x0166: // MIPS, little endian
arch = Abi::MipsArchitecture;
width = 32;
break;
case 0x0200: // ia64
arch = Abi::ItaniumArchitecture;
width = 64;
break;
}
if (data.size() >= 68) {
// Get Major and Minor Image Version from optional header fields
quint32 image = getLEUint32(data, 64);
if (image == 1) { // Image is 1 for mingw and higher for MSVC (4.something in some encoding)
flavor = Abi::WindowsMSysFlavor;
} else {
switch (data.at(22)) {
case 8:
flavor = Abi::WindowsMsvc2005Flavor;
break;
case 9:
flavor = Abi::WindowsMsvc2008Flavor;
break;
case 10:
flavor = Abi::WindowsMsvc2010Flavor;
break;
default:
// Keep unknown flavor
break;
}
}
}
if (arch != Abi::UnknownArchitecture && width != 0)
result.append(Abi(arch, Abi::WindowsOS, flavor, Abi::PEFormat, width));
return result;
}
bool MsvcToolChain::fromMap(const QVariantMap &data)
{
if (!ToolChain::fromMap(data))
return false;
m_vcvarsBat = QDir::fromNativeSeparators(data.value(QLatin1String(varsBatKeyC)).toString());
m_varsBatArg = data.value(QLatin1String(varsBatArgKeyC)).toString();
const QString abiString = data.value(QLatin1String(supportedAbiKeyC)).toString();
m_abi = Abi(abiString);
return !m_vcvarsBat.isEmpty() && m_abi.isValid();
}
void GccToolChain::forceTo32Bit(bool f)
{
if (f == m_forcedTo32Bit)
return;
if (displayName() == defaultDisplayName())
setDisplayName(typeName());
m_forcedTo32Bit = f;
m_targetAbi = Abi(); // Invalidate ABI.
updateId();
targetAbi();
}
bool GccToolChain::fromMap(const QVariantMap &data)
{
if (!ToolChain::fromMap(data))
return false;
m_compilerCommand = Utils::FileName::fromString(data.value(QLatin1String(compilerCommandKeyC)).toString());
m_targetAbi = Abi(data.value(QLatin1String(targetAbiKeyC)).toString());
QStringList abiList = data.value(QLatin1String(supportedAbisKeyC)).toStringList();
m_supportedAbis.clear();
foreach (const QString &a, abiList) {
ProjectExplorer::Abi abi(a);
if (!abi.isValid())
continue;
m_supportedAbis.append(abi);
}
void GccToolChain::setCompilerPath(const QString &path)
{
if (path == m_compilerPath)
return;
if (displayName() == defaultDisplayName())
setDisplayName(typeName());
m_compilerPath = path;
m_targetAbi = Abi();
updateId();
if (m_compilerPath.isEmpty())
return;
targetAbi(); // update ABI information (and default display name)
}
Abi GccToolChain::targetAbi() const
{
if (!m_targetAbi.isValid()) {
Utils::Environment env = Utils::Environment::systemEnvironment();
addToEnvironment(env);
m_targetAbi = guessGccAbi(m_compilerPath, env.toStringList());
m_supports64Bit = (m_targetAbi.wordWidth() == 64);
if (m_targetAbi.wordWidth() == 64 && m_forcedTo32Bit)
m_targetAbi = Abi(m_targetAbi.architecture(), m_targetAbi.os(), m_targetAbi.osFlavor(),
m_targetAbi.binaryFormat(), 32);
if (displayName() == typeName())
setDisplayName(defaultDisplayName());
}
return m_targetAbi;
}
bool WinCEToolChain::fromMap(const QVariantMap &data)
{
if (!ToolChain::fromMap(data))
return false;
m_msvcVer = data.value(QLatin1String(msvcVerKeyC)).toString();
m_ceVer = data.value(QLatin1String(ceVerKeyC)).toString();
m_binPath = data.value(QLatin1String(binPathKeyC)).toString();
m_includePath = data.value(QLatin1String(includePathKeyC)).toString();
m_libPath = data.value(QLatin1String(libPathKeyC)).toString();
m_vcvarsBat = data.value(QLatin1String(vcVarsKeyC)).toString();
const QString abiString = data.value(QLatin1String(supportedAbiKeyC)).toString();
m_abi = Abi(abiString);
return isValid();
}
static Abi macAbiForCpu(quint32 type) {
switch (type) {
case 7: // CPU_TYPE_X86, CPU_TYPE_I386
return Abi(Abi::X86Architecture, Abi::MacOS, Abi::GenericMacFlavor, Abi::MachOFormat, 32);
case 0x01000000 + 7: // CPU_TYPE_X86_64
return Abi(Abi::X86Architecture, Abi::MacOS, Abi::GenericMacFlavor, Abi::MachOFormat, 64);
case 18: // CPU_TYPE_POWERPC
return Abi(Abi::PowerPCArchitecture, Abi::MacOS, Abi::GenericMacFlavor, Abi::MachOFormat, 32);
case 0x01000000 + 18: // CPU_TYPE_POWERPC64
return Abi(Abi::PowerPCArchitecture, Abi::MacOS, Abi::GenericMacFlavor, Abi::MachOFormat, 32);
case 12: // CPU_TYPE_ARM
return Abi(Abi::ArmArchitecture, Abi::MacOS, Abi::GenericMacFlavor, Abi::MachOFormat, 32);
case 0x01000000 + 12: // CPU_TYPE_ARM64
return Abi(Abi::ArmArchitecture, Abi::MacOS, Abi::GenericMacFlavor, Abi::MachOFormat, 64);
default:
return Abi();
}
}
QList<ToolChain *> WinCEToolChainFactory::autoDetect()
{
QList<ToolChain *> results;
// 1) Installed WinCEs
const QSettings vsRegistry(
#ifdef Q_OS_WIN64
QLatin1String("HKEY_LOCAL_MACHINE\\SOFTWARE\\Wow6432Node\\Microsoft\\VisualStudio\\SxS\\VC7"),
#else
QLatin1String("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VC7"),
#endif
QSettings::NativeFormat);
foreach (const QString &vsName, vsRegistry.allKeys()) {
// Scan for version major.minor
const int dotPos = vsName.indexOf(QLatin1Char('.'));
if (dotPos == -1)
continue;
const QString path = QDir::fromNativeSeparators(vsRegistry.value(vsName).toString());
const int version = vsName.left(dotPos).toInt();
// Check existence of various install scripts
const QString vcvars32bat = path + QLatin1String("bin/vcvars32.bat");
QFile cePlatforms(path + QLatin1String("vcpackages/WCE.VCPlatform.config"));
if (cePlatforms.exists()) {
const QString msvcVer = findMsvcVer(version);
cePlatforms.open(QIODevice::ReadOnly);
QXmlStreamReader platformReader(&cePlatforms);
// Rip through the config file getting all of the installed platforms.
while (!platformReader.atEnd()) {
platformReader.readNext();
if (platformReader.isStartElement()) {
if (platformReader.name() == QLatin1String("Platform")) {
Abi::Architecture theArch;
QString thePlat;
QString binPath;
QString includePath;
QString libPath;
QString ceVer;
if (parseSDK(platformReader, theArch, thePlat, ceVer, binPath, includePath, libPath)) {
WinCEToolChain *pChain = new WinCEToolChain(thePlat,
Abi(theArch, Abi::WindowsOS, Abi::WindowsCEFlavor, Abi::PEFormat, 32),
vcvars32bat,
msvcVer,
ceVer,
binPath,
includePath,
libPath,
true);
results.append(pChain);
}
}
}
}
}
}
return results;
}
Abi Abi::abiFromTargetTriplet(const QString &triple)
{
QString machine = triple.toLower();
if (machine.isEmpty())
return Abi();
QStringList parts = machine.split(QRegExp(QLatin1String("[ /-]")));
Abi::Architecture arch = Abi::UnknownArchitecture;
Abi::OS os = Abi::UnknownOS;
Abi::OSFlavor flavor = Abi::UnknownFlavor;
Abi::BinaryFormat format = Abi::UnknownFormat;
int width = 0;
int unknownCount = 0;
foreach (const QString &p, parts) {
if (p == QLatin1String("unknown") || p == QLatin1String("pc") || p == QLatin1String("none")
|| p == QLatin1String("gnu") || p == QLatin1String("uclibc")
|| p == QLatin1String("86_64") || p == QLatin1String("redhat")
|| p == QLatin1String("gnueabi") || p == QLatin1String("w64")) {
continue;
} else if (p == QLatin1String("i386") || p == QLatin1String("i486") || p == QLatin1String("i586")
|| p == QLatin1String("i686") || p == QLatin1String("x86")) {
arch = Abi::X86Architecture;
} else if (p.startsWith(QLatin1String("arm"))) {
arch = Abi::ArmArchitecture;
width = 32;
} else if (p == QLatin1String("mipsel")) {
arch = Abi::MipsArchitecture;
width = 32;
} else if (p == QLatin1String("x86_64") || p == QLatin1String("amd64")) {
arch = Abi::X86Architecture;
width = 64;
} else if (p == QLatin1String("powerpc64")) {
arch = Abi::PowerPCArchitecture;
width = 64;
} else if (p == QLatin1String("powerpc")) {
arch = Abi::PowerPCArchitecture;
width = 32;
} else if (p == QLatin1String("linux") || p == QLatin1String("linux6e")) {
os = Abi::LinuxOS;
if (flavor == Abi::UnknownFlavor)
flavor = Abi::GenericLinuxFlavor;
format = Abi::ElfFormat;
} else if (p.startsWith(QLatin1String("freebsd"))) {
os = Abi::BsdOS;
if (flavor == Abi::UnknownFlavor)
flavor = Abi::FreeBsdFlavor;
format = Abi::ElfFormat;
} else if (p == QLatin1String("mingw32") || p == QLatin1String("win32") || p == QLatin1String("mingw32msvc")) {
arch = Abi::X86Architecture;
os = Abi::WindowsOS;
flavor = Abi::WindowsMSysFlavor;
format = Abi::PEFormat;
} else if (p == QLatin1String("apple")) {
os = Abi::MacOS;
flavor = Abi::GenericMacFlavor;
format = Abi::MachOFormat;
} else if (p == QLatin1String("darwin10")) {
width = 64;
} else if (p == QLatin1String("darwin9")) {
width = 32;
} else if (p == QLatin1String("gnueabi")) {
format = Abi::ElfFormat;
} else {
++unknownCount;
}
}
return Abi(arch, os, flavor, format, width);
}
static QList<Abi> parseCoffHeader(const QByteArray &data)
{
QList<Abi> result;
if (data.size() < 20)
return result;
Abi::Architecture arch = Abi::UnknownArchitecture;
Abi::OSFlavor flavor = Abi::UnknownFlavor;
int width = 0;
// Get machine field from COFF file header
quint16 machine = getLEUint16(data, 0);
switch (machine) {
case 0x01c0: // ARM LE
case 0x01c2: // ARM or thumb
case 0x01c4: // ARMv7 thumb
arch = Abi::ArmArchitecture;
width = 32;
break;
case 0x8664: // x86_64
arch = Abi::X86Architecture;
width = 64;
break;
case 0x014c: // i386
arch = Abi::X86Architecture;
width = 32;
break;
case 0x0166: // MIPS, little endian
arch = Abi::MipsArchitecture;
width = 32;
break;
case 0x0200: // ia64
arch = Abi::ItaniumArchitecture;
width = 64;
break;
}
if (data.size() >= 24) {
// Get Major and Minor Image Version from optional header fields
quint8 minorLinker = data.at(23);
switch (data.at(22)) {
case 2:
case 3: // not yet reached:-)
flavor = Abi::WindowsMSysFlavor;
break;
case 8:
flavor = Abi::WindowsMsvc2005Flavor;
break;
case 9:
flavor = Abi::WindowsMsvc2008Flavor;
break;
case 10:
flavor = Abi::WindowsMsvc2010Flavor;
break;
case 11:
flavor = Abi::WindowsMsvc2012Flavor;
break;
case 12:
flavor = Abi::WindowsMsvc2013Flavor;
break;
default: // Keep unknown flavor
if (minorLinker != 0)
flavor = Abi::WindowsMSysFlavor; // MSVC seems to avoid using minor numbers
else
qWarning("%s: Unknown MSVC flavour encountered.", Q_FUNC_INFO);
break;
}
}
if (arch != Abi::UnknownArchitecture && width != 0)
result.append(Abi(arch, Abi::WindowsOS, flavor, Abi::PEFormat, width));
return result;
}
static QList<Abi> abiOf(const QByteArray &data)
{
QList<Abi> result;
if (data.size() <= 8)
return result;
if (data.size() >= 20
&& getUint8(data, 0) == 0x7f && getUint8(data, 1) == 'E' && getUint8(data, 2) == 'L'
&& getUint8(data, 3) == 'F') {
// ELF format:
bool isLE = (getUint8(data, 5) == 1);
quint16 machine = isLE ? getLEUint16(data, 18) : getBEUint16(data, 18);
quint8 osAbi = getUint8(data, 7);
Abi::OS os = Abi::UnixOS;
Abi::OSFlavor flavor = Abi::GenericUnixFlavor;
// http://www.sco.com/developers/gabi/latest/ch4.eheader.html#elfid
switch (osAbi) {
case 2: // NetBSD:
os = Abi::BsdOS;
flavor = Abi::NetBsdFlavor;
break;
case 3: // Linux:
case 0: // no extra info available: Default to Linux:
case 97: // ARM, also linux most of the time.
os = Abi::LinuxOS;
flavor = Abi::GenericLinuxFlavor;
break;
case 6: // Solaris:
os = Abi::UnixOS;
flavor = Abi::SolarisUnixFlavor;
break;
case 9: // FreeBSD:
os = Abi::BsdOS;
flavor = Abi::FreeBsdFlavor;
break;
case 12: // OpenBSD:
os = Abi::BsdOS;
flavor = Abi::OpenBsdFlavor;
}
switch (machine) {
case 3: // EM_386
result.append(Abi(Abi::X86Architecture, os, flavor, Abi::ElfFormat, 32));
break;
case 8: // EM_MIPS
result.append(Abi(Abi::MipsArchitecture, os, flavor, Abi::ElfFormat, 32));
break;
case 20: // EM_PPC
result.append(Abi(Abi::PowerPCArchitecture, os, flavor, Abi::ElfFormat, 32));
break;
case 21: // EM_PPC64
result.append(Abi(Abi::PowerPCArchitecture, os, flavor, Abi::ElfFormat, 64));
break;
case 40: // EM_ARM
result.append(Abi(Abi::ArmArchitecture, os, flavor, Abi::ElfFormat, 32));
break;
case 62: // EM_X86_64
result.append(Abi(Abi::X86Architecture, os, flavor, Abi::ElfFormat, 64));
break;
case 42: // EM_SH
result.append(Abi(Abi::ShArchitecture, os, flavor, Abi::ElfFormat, 32));
break;
case 50: // EM_IA_64
result.append(Abi(Abi::ItaniumArchitecture, os, flavor, Abi::ElfFormat, 64));
break;
default:
;
}
} else if (((getUint8(data, 0) == 0xce || getUint8(data, 0) == 0xcf)
&& getUint8(data, 1) == 0xfa && getUint8(data, 2) == 0xed && getUint8(data, 3) == 0xfe
)
||
(getUint8(data, 0) == 0xfe && getUint8(data, 1) == 0xed && getUint8(data, 2) == 0xfa
&& (getUint8(data, 3) == 0xce || getUint8(data, 3) == 0xcf)
)
) {
// Mach-O format (Mac non-fat binary, 32 and 64bit magic):
quint32 type = (getUint8(data, 1) == 0xfa) ? getLEUint32(data, 4) : getBEUint32(data, 4);
result.append(macAbiForCpu(type));
} else if ((getUint8(data, 0) == 0xbe && getUint8(data, 1) == 0xba
&& getUint8(data, 2) == 0xfe && getUint8(data, 3) == 0xca)
||
(getUint8(data, 0) == 0xca && getUint8(data, 1) == 0xfe
&& getUint8(data, 2) == 0xba && getUint8(data, 3) == 0xbe)
) {
// Mach-0 format Fat binary header:
bool isLE = (getUint8(data, 0) == 0xbe);
quint32 count = isLE ? getLEUint32(data, 4) : getBEUint32(data, 4);
int pos = 8;
for (quint32 i = 0; i < count; ++i) {
if (data.size() <= pos + 4)
break;
quint32 type = isLE ? getLEUint32(data, pos) : getBEUint32(data, pos);
result.append(macAbiForCpu(type));
pos += 20;
}
} else if (data.size() >= 64){
// Windows PE: values are LE (except for a few exceptions which we will not use here).
// MZ header first (ZM is also allowed, but rarely used)
const quint8 firstChar = getUint8(data, 0);
const quint8 secondChar = getUint8(data, 1);
if ((firstChar != 'M' || secondChar != 'Z') && (firstChar != 'Z' || secondChar != 'M'))
return result;
// Get PE/COFF header position from MZ header:
qint32 pePos = getLEUint32(data, 60);
if (pePos <= 0 || data.size() < pePos + 4 + 20) // PE magic bytes plus COFF header
return result;
if (getUint8(data, pePos) == 'P' && getUint8(data, pePos + 1) == 'E'
&& getUint8(data, pePos + 2) == 0 && getUint8(data, pePos + 3) == 0)
result = parseCoffHeader(data.mid(pePos + 4));
}
return result;
}
Abi AbiWidget::currentAbi() const
{
return Abi(d->m_abi->itemData(d->m_abi->currentIndex()).toString());
}
