2011-02-01 18:36:00 +01:00
|
|
|
/**************************************************************************
|
|
|
|
|
**
|
|
|
|
|
** This file is part of Qt Creator
|
|
|
|
|
**
|
|
|
|
|
** Copyright (c) 2011 Nokia Corporation and/or its subsidiary(-ies).
|
|
|
|
|
**
|
2011-11-02 15:59:12 +01:00
|
|
|
** Contact: Nokia Corporation (qt-info@nokia.com)
|
2011-02-01 18:36:00 +01:00
|
|
|
**
|
|
|
|
|
**
|
|
|
|
|
** GNU Lesser General Public License Usage
|
|
|
|
|
**
|
2011-04-13 08:42:33 +02:00
|
|
|
** This file may be used under the terms of the GNU Lesser General Public
|
|
|
|
|
** License version 2.1 as published by the Free Software Foundation and
|
|
|
|
|
** appearing in the file LICENSE.LGPL included in the packaging of this file.
|
|
|
|
|
** Please review the following information to ensure the GNU Lesser General
|
|
|
|
|
** Public License version 2.1 requirements will be met:
|
|
|
|
|
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
|
2011-02-01 18:36:00 +01:00
|
|
|
**
|
|
|
|
|
** In addition, as a special exception, Nokia gives you certain additional
|
2011-04-13 08:42:33 +02:00
|
|
|
** rights. These rights are described in the Nokia Qt LGPL Exception
|
2011-02-01 18:36:00 +01:00
|
|
|
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
|
|
|
|
|
**
|
2011-04-13 08:42:33 +02:00
|
|
|
** Other Usage
|
|
|
|
|
**
|
|
|
|
|
** Alternatively, this file may be used in accordance with the terms and
|
|
|
|
|
** conditions contained in a signed written agreement between you and Nokia.
|
|
|
|
|
**
|
2011-02-01 18:36:00 +01:00
|
|
|
** If you have questions regarding the use of this file, please contact
|
2011-11-02 15:59:12 +01:00
|
|
|
** Nokia at qt-info@nokia.com.
|
2011-02-01 18:36:00 +01:00
|
|
|
**
|
|
|
|
|
**************************************************************************/
|
|
|
|
|
|
|
|
|
|
#include "abi.h"
|
|
|
|
|
|
|
|
|
|
#include <QtCore/QCoreApplication>
|
2011-03-03 11:29:07 +01:00
|
|
|
#include <QtCore/QDebug>
|
2011-06-23 11:21:50 +02:00
|
|
|
#include <QtCore/QtEndian>
|
2011-02-01 18:36:00 +01:00
|
|
|
#include <QtCore/QFile>
|
|
|
|
|
#include <QtCore/QString>
|
|
|
|
|
#include <QtCore/QStringList>
|
|
|
|
|
#include <QtCore/QSysInfo>
|
|
|
|
|
|
2011-04-14 12:58:14 +02:00
|
|
|
/*!
|
|
|
|
|
\class ProjectExplorer::Abi
|
|
|
|
|
|
|
|
|
|
\brief Represents the Application Binary Interface (ABI) of a target platform.
|
|
|
|
|
|
|
|
|
|
\sa ProjectExplorer::ToolChain
|
|
|
|
|
*/
|
|
|
|
|
|
2011-02-01 18:36:00 +01:00
|
|
|
namespace ProjectExplorer {
|
|
|
|
|
|
2011-03-02 14:09:18 +01:00
|
|
|
// --------------------------------------------------------------------------
|
|
|
|
|
// Helpers
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
|
|
|
|
2011-08-31 15:09:18 +00:00
|
|
|
static quint8 getUint8(const QByteArray &data, int pos)
|
|
|
|
|
{
|
|
|
|
|
return static_cast<quint8>(data.at(pos));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static quint32 getLEUint32(const QByteArray &ba, int pos)
|
|
|
|
|
{
|
|
|
|
|
Q_ASSERT(ba.size() >= pos + 3);
|
|
|
|
|
return (static_cast<quint32>(static_cast<quint8>(ba.at(pos + 3))) << 24)
|
|
|
|
|
+ (static_cast<quint32>(static_cast<quint8>(ba.at(pos + 2)) << 16))
|
|
|
|
|
+ (static_cast<quint32>(static_cast<quint8>(ba.at(pos + 1))) << 8)
|
|
|
|
|
+ static_cast<quint8>(ba.at(pos));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static quint32 getBEUint32(const QByteArray &ba, int pos)
|
|
|
|
|
{
|
|
|
|
|
Q_ASSERT(ba.size() >= pos + 3);
|
|
|
|
|
return (static_cast<quint32>(static_cast<quint8>(ba.at(pos))) << 24)
|
|
|
|
|
+ (static_cast<quint32>(static_cast<quint8>(ba.at(pos + 1))) << 16)
|
|
|
|
|
+ (static_cast<quint32>(static_cast<quint8>(ba.at(pos + 2))) << 8)
|
|
|
|
|
+ static_cast<quint8>(ba.at(pos + 3));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static quint32 getLEUint16(const QByteArray &ba, int pos)
|
|
|
|
|
{
|
|
|
|
|
Q_ASSERT(ba.size() >= pos + 1);
|
|
|
|
|
return (static_cast<quint16>(static_cast<quint8>(ba.at(pos + 1))) << 8) + static_cast<quint8>(ba.at(pos));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static quint32 getBEUint16(const QByteArray &ba, int pos)
|
|
|
|
|
{
|
|
|
|
|
Q_ASSERT(ba.size() >= pos + 1);
|
|
|
|
|
return (static_cast<quint16>(static_cast<quint8>(ba.at(pos))) << 8) + static_cast<quint8>(ba.at(pos + 1));
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-02 14:09:18 +01:00
|
|
|
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);
|
|
|
|
|
default:
|
|
|
|
|
return Abi();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-03 11:29:07 +01:00
|
|
|
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
|
2011-08-31 15:09:18 +00:00
|
|
|
quint16 machine = getLEUint16(data, 0);
|
2011-03-03 11:29:07 +01:00
|
|
|
switch (machine) {
|
|
|
|
|
case 0x8664: // x86_64
|
|
|
|
|
arch = Abi::X86Architecture;
|
|
|
|
|
width = 64;
|
|
|
|
|
break;
|
|
|
|
|
case 0x014c: // i386
|
|
|
|
|
arch = Abi::X86Architecture;
|
|
|
|
|
width = 32;
|
|
|
|
|
break;
|
2011-07-11 14:22:28 +00:00
|
|
|
case 0x0166: // MIPS, little endian
|
2011-08-31 09:55:34 +00:00
|
|
|
arch = Abi::MipsArchitecture;
|
2011-07-11 14:22:28 +00:00
|
|
|
width = 32;
|
|
|
|
|
break;
|
2011-03-03 11:29:07 +01:00
|
|
|
case 0x0200: // ia64
|
|
|
|
|
arch = Abi::ItaniumArchitecture;
|
|
|
|
|
width = 64;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (data.size() >= 68) {
|
|
|
|
|
// Get Major and Minor Image Version from optional header fields
|
2011-08-31 15:09:18 +00:00
|
|
|
quint32 image = getLEUint32(data, 64);
|
2011-03-18 09:54:35 +01:00
|
|
|
if (image == 1) { // Image is 1 for mingw and higher for MSVC (4.something in some encoding)
|
2011-03-03 11:29:07 +01:00
|
|
|
flavor = Abi::WindowsMSysFlavor;
|
2011-03-18 09:54:35 +01:00
|
|
|
} 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;
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-03-03 11:29:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (arch != Abi::UnknownArchitecture && width != 0)
|
|
|
|
|
result.append(Abi(arch, Abi::WindowsOS, flavor, Abi::PEFormat, width));
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-02 14:09:18 +01:00
|
|
|
static QList<Abi> abiOf(const QByteArray &data)
|
|
|
|
|
{
|
|
|
|
|
QList<Abi> result;
|
2011-08-31 15:09:18 +00:00
|
|
|
if (data.size() <= 8)
|
|
|
|
|
return result;
|
2011-03-02 14:09:18 +01:00
|
|
|
|
|
|
|
|
if (data.size() >= 20
|
2011-08-31 15:09:18 +00:00
|
|
|
&& getUint8(data, 0) == 0x7f && getUint8(data, 1) == 'E' && getUint8(data, 2) == 'L'
|
|
|
|
|
&& getUint8(data, 3) == 'F') {
|
2011-03-02 14:09:18 +01:00
|
|
|
// ELF format:
|
2011-08-31 15:09:18 +00:00
|
|
|
bool isLE = (getUint8(data, 5) == 1);
|
|
|
|
|
quint16 machine = isLE ? getLEUint16(data, 18) : getBEUint16(data, 18);
|
|
|
|
|
quint8 osAbi = getUint8(data, 7);
|
2011-05-31 10:06:32 +00:00
|
|
|
|
|
|
|
|
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:
|
|
|
|
|
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;
|
|
|
|
|
}
|
2011-05-31 08:55:57 +00:00
|
|
|
|
2011-03-02 14:09:18 +01:00
|
|
|
switch (machine) {
|
|
|
|
|
case 3: // EM_386
|
2011-05-31 08:55:57 +00:00
|
|
|
result.append(Abi(Abi::X86Architecture, os, flavor, Abi::ElfFormat, 32));
|
2011-03-02 14:09:18 +01:00
|
|
|
break;
|
|
|
|
|
case 8: // EM_MIPS
|
2011-08-31 09:55:34 +00:00
|
|
|
result.append(Abi(Abi::MipsArchitecture, os, flavor, Abi::ElfFormat, 32));
|
2011-03-02 14:09:18 +01:00
|
|
|
break;
|
|
|
|
|
case 20: // EM_PPC
|
2011-05-31 08:55:57 +00:00
|
|
|
result.append(Abi(Abi::PowerPCArchitecture, os, flavor, Abi::ElfFormat, 32));
|
2011-03-02 14:09:18 +01:00
|
|
|
break;
|
|
|
|
|
case 21: // EM_PPC64
|
2011-05-31 08:55:57 +00:00
|
|
|
result.append(Abi(Abi::PowerPCArchitecture, os, flavor, Abi::ElfFormat, 64));
|
2011-03-02 14:09:18 +01:00
|
|
|
break;
|
2011-03-21 18:04:24 +01:00
|
|
|
case 40: // EM_ARM
|
2011-05-31 08:55:57 +00:00
|
|
|
result.append(Abi(Abi::ArmArchitecture, os, flavor, Abi::ElfFormat, 32));
|
2011-03-21 18:04:24 +01:00
|
|
|
break;
|
2011-03-02 14:09:18 +01:00
|
|
|
case 62: // EM_X86_64
|
2011-05-31 08:55:57 +00:00
|
|
|
result.append(Abi(Abi::X86Architecture, os, flavor, Abi::ElfFormat, 64));
|
2011-03-02 14:09:18 +01:00
|
|
|
break;
|
2011-09-22 14:26:10 +00:00
|
|
|
case 42: // EM_SH
|
|
|
|
|
result.append(Abi(Abi::ShArchitecture, os, flavor, Abi::ElfFormat, 32));
|
|
|
|
|
break;
|
2011-03-02 14:09:18 +01:00
|
|
|
case 50: // EM_IA_64
|
2011-05-31 08:55:57 +00:00
|
|
|
result.append(Abi(Abi::ItaniumArchitecture, os, flavor, Abi::ElfFormat, 64));
|
2011-03-02 14:09:18 +01:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
;;
|
|
|
|
|
}
|
2011-08-31 15:09:18 +00:00
|
|
|
} 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);
|
2011-03-02 14:09:18 +01:00
|
|
|
int pos = 8;
|
|
|
|
|
for (quint32 i = 0; i < count; ++i) {
|
|
|
|
|
if (data.size() <= pos + 4)
|
|
|
|
|
break;
|
|
|
|
|
|
2011-08-31 15:09:18 +00:00
|
|
|
quint32 type = isLE ? getLEUint32(data, pos) : getBEUint32(data, pos);
|
2011-03-02 14:09:18 +01:00
|
|
|
result.append(macAbiForCpu(type));
|
|
|
|
|
pos += 20;
|
|
|
|
|
}
|
2011-03-21 18:04:24 +01:00
|
|
|
} else if (data.size() >= 20
|
2011-08-31 15:09:18 +00:00
|
|
|
&& getUint8(data, 16) == 'E' && getUint8(data, 17) == 'P'
|
|
|
|
|
&& getUint8(data, 18) == 'O' && getUint8(data, 19) == 'C') {
|
2011-03-21 18:04:24 +01:00
|
|
|
result.append(Abi(Abi::ArmArchitecture, Abi::SymbianOS, Abi::SymbianDeviceFlavor, Abi::ElfFormat, 32));
|
2011-08-31 11:38:39 +00:00
|
|
|
} else if (data.size() >= 64){
|
2011-08-31 15:09:18 +00:00
|
|
|
// Windows PE: values are LE (except for a few exceptions which we will not use here).
|
2011-08-31 11:38:39 +00:00
|
|
|
|
2011-08-31 15:09:18 +00:00
|
|
|
// MZ header first (ZM is also allowed, but rarely used)
|
2011-09-12 15:48:43 +02:00
|
|
|
const quint8 firstChar = getUint8(data, 0);
|
|
|
|
|
const quint8 secondChar = getUint8(data, 1);
|
|
|
|
|
if ((firstChar != 'M' || secondChar != 'Z') && (firstChar != 'Z' || secondChar != 'M'))
|
|
|
|
|
return result;
|
2011-08-31 11:38:39 +00:00
|
|
|
|
|
|
|
|
// Get PE/COFF header position from MZ header:
|
2011-08-31 15:09:18 +00:00
|
|
|
qint32 pePos = getLEUint32(data, 60);
|
2011-08-31 11:38:39 +00:00
|
|
|
if (pePos <= 0 || data.size() < pePos + 4 + 20) // PE magic bytes plus COFF header
|
|
|
|
|
return result;
|
2011-08-31 15:09:18 +00:00
|
|
|
if (getUint8(data, pePos) == 'P' && getUint8(data, pePos + 1) == 'E'
|
|
|
|
|
&& getUint8(data, pePos + 2) == 0 && getUint8(data, pePos + 3) == 0)
|
2011-03-03 11:29:07 +01:00
|
|
|
result = parseCoffHeader(data.mid(pePos + 4));
|
2011-03-02 14:09:18 +01:00
|
|
|
}
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
|
|
|
// Abi
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
|
|
|
|
2011-02-01 18:36:00 +01:00
|
|
|
Abi::Abi(const Architecture &a, const OS &o,
|
2011-02-23 16:47:08 +01:00
|
|
|
const OSFlavor &of, const BinaryFormat &f, unsigned char w) :
|
2011-02-01 18:36:00 +01:00
|
|
|
m_architecture(a), m_os(o), m_osFlavor(of), m_binaryFormat(f), m_wordWidth(w)
|
|
|
|
|
{
|
|
|
|
|
switch (m_os) {
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::UnknownOS:
|
|
|
|
|
m_osFlavor = UnknownFlavor;
|
2011-02-01 18:36:00 +01:00
|
|
|
break;
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::LinuxOS:
|
|
|
|
|
if (m_osFlavor < GenericLinuxFlavor || m_osFlavor > MeegoLinuxFlavor)
|
|
|
|
|
m_osFlavor = UnknownFlavor;
|
2011-02-01 18:36:00 +01:00
|
|
|
break;
|
2011-05-31 10:06:32 +00:00
|
|
|
case ProjectExplorer::Abi::BsdOS:
|
|
|
|
|
m_osFlavor = FreeBsdFlavor;
|
2011-05-31 08:55:57 +00:00
|
|
|
break;
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::MacOS:
|
|
|
|
|
if (m_osFlavor < GenericMacFlavor || m_osFlavor > GenericMacFlavor)
|
|
|
|
|
m_osFlavor = UnknownFlavor;
|
2011-02-01 18:36:00 +01:00
|
|
|
break;
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::SymbianOS:
|
|
|
|
|
if (m_osFlavor < SymbianDeviceFlavor || m_osFlavor > SymbianEmulatorFlavor)
|
|
|
|
|
m_osFlavor = UnknownFlavor;
|
2011-02-01 18:36:00 +01:00
|
|
|
break;
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::UnixOS:
|
|
|
|
|
if (m_osFlavor < GenericUnixFlavor || m_osFlavor > GenericUnixFlavor)
|
|
|
|
|
m_osFlavor = UnknownFlavor;
|
2011-02-01 18:36:00 +01:00
|
|
|
break;
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::WindowsOS:
|
2011-03-18 09:54:35 +01:00
|
|
|
if (m_osFlavor < WindowsMsvc2005Flavor || m_osFlavor > WindowsCEFlavor)
|
2011-02-23 16:47:08 +01:00
|
|
|
m_osFlavor = UnknownFlavor;
|
2011-02-01 18:36:00 +01:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Abi::Abi(const QString &abiString) :
|
2011-02-23 16:47:08 +01:00
|
|
|
m_architecture(UnknownArchitecture), m_os(UnknownOS),
|
|
|
|
|
m_osFlavor(UnknownFlavor), m_binaryFormat(UnknownFormat), m_wordWidth(0)
|
2011-02-01 18:36:00 +01:00
|
|
|
{
|
|
|
|
|
QStringList abiParts = abiString.split(QLatin1Char('-'));
|
|
|
|
|
if (abiParts.count() >= 1) {
|
|
|
|
|
if (abiParts.at(0) == QLatin1String("unknown"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_architecture = UnknownArchitecture;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(0) == QLatin1String("arm"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_architecture = ArmArchitecture;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(0) == QLatin1String("x86"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_architecture = X86Architecture;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(0) == QLatin1String("mips"))
|
2011-08-31 09:55:34 +00:00
|
|
|
m_architecture = MipsArchitecture;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(0) == QLatin1String("ppc"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_architecture = PowerPCArchitecture;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(0) == QLatin1String("itanium"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_architecture = ItaniumArchitecture;
|
2011-09-22 14:26:10 +00:00
|
|
|
else if (abiParts.at(0) == QLatin1String("sh"))
|
|
|
|
|
m_architecture = ShArchitecture;
|
2011-02-01 18:36:00 +01:00
|
|
|
else
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (abiParts.count() >= 2) {
|
|
|
|
|
if (abiParts.at(1) == QLatin1String("unknown"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_os = UnknownOS;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(1) == QLatin1String("linux"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_os = LinuxOS;
|
2011-05-31 10:06:32 +00:00
|
|
|
else if (abiParts.at(1) == QLatin1String("bsd"))
|
|
|
|
|
m_os = BsdOS;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(1) == QLatin1String("macos"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_os = MacOS;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(1) == QLatin1String("symbian"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_os = SymbianOS;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(1) == QLatin1String("unix"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_os = UnixOS;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(1) == QLatin1String("windows"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_os = WindowsOS;
|
2011-02-01 18:36:00 +01:00
|
|
|
else
|
2011-04-14 12:58:14 +02:00
|
|
|
|
2011-02-01 18:36:00 +01:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (abiParts.count() >= 3) {
|
|
|
|
|
if (abiParts.at(2) == QLatin1String("unknown"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_osFlavor = UnknownFlavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("generic") && m_os == LinuxOS)
|
|
|
|
|
m_osFlavor = GenericLinuxFlavor;
|
2011-05-31 10:06:32 +00:00
|
|
|
else if (abiParts.at(2) == QLatin1String("freebsd") && m_os == BsdOS)
|
|
|
|
|
m_osFlavor = FreeBsdFlavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("netbsd") && m_os == BsdOS)
|
|
|
|
|
m_osFlavor = NetBsdFlavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("openbsd") && m_os == BsdOS)
|
|
|
|
|
m_osFlavor = OpenBsdFlavor;
|
2011-02-23 16:47:08 +01:00
|
|
|
else if (abiParts.at(2) == QLatin1String("maemo") && m_os == LinuxOS)
|
|
|
|
|
m_osFlavor = MaemoLinuxFlavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("meego") && m_os == LinuxOS)
|
|
|
|
|
m_osFlavor = MeegoLinuxFlavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("generic") && m_os == MacOS)
|
|
|
|
|
m_osFlavor = GenericMacFlavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("device") && m_os == SymbianOS)
|
|
|
|
|
m_osFlavor = SymbianDeviceFlavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("emulator") && m_os == SymbianOS)
|
|
|
|
|
m_osFlavor = SymbianEmulatorFlavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("generic") && m_os == UnixOS)
|
|
|
|
|
m_osFlavor = GenericUnixFlavor;
|
2011-05-31 10:06:32 +00:00
|
|
|
else if (abiParts.at(2) == QLatin1String("solaris") && m_os == UnixOS)
|
|
|
|
|
m_osFlavor = SolarisUnixFlavor;
|
2011-03-18 09:54:35 +01:00
|
|
|
else if (abiParts.at(2) == QLatin1String("msvc2005") && m_os == WindowsOS)
|
|
|
|
|
m_osFlavor = WindowsMsvc2005Flavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("msvc2008") && m_os == WindowsOS)
|
|
|
|
|
m_osFlavor = WindowsMsvc2008Flavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("msvc2010") && m_os == WindowsOS)
|
|
|
|
|
m_osFlavor = WindowsMsvc2010Flavor;
|
2011-02-23 16:47:08 +01:00
|
|
|
else if (abiParts.at(2) == QLatin1String("msys") && m_os == WindowsOS)
|
|
|
|
|
m_osFlavor = WindowsMSysFlavor;
|
|
|
|
|
else if (abiParts.at(2) == QLatin1String("ce") && m_os == WindowsOS)
|
|
|
|
|
m_osFlavor = WindowsCEFlavor;
|
2011-02-01 18:36:00 +01:00
|
|
|
else
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (abiParts.count() >= 4) {
|
|
|
|
|
if (abiParts.at(3) == QLatin1String("unknown"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_binaryFormat = UnknownFormat;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(3) == QLatin1String("elf"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_binaryFormat = ElfFormat;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(3) == QLatin1String("pe"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_binaryFormat = PEFormat;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(3) == QLatin1String("mach_o"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_binaryFormat = MachOFormat;
|
2011-02-01 18:36:00 +01:00
|
|
|
else if (abiParts.at(3) == QLatin1String("qml_rt"))
|
2011-02-23 16:47:08 +01:00
|
|
|
m_binaryFormat = RuntimeQmlFormat;
|
2011-02-01 18:36:00 +01:00
|
|
|
else
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (abiParts.count() >= 5) {
|
|
|
|
|
const QString &bits = abiParts.at(4);
|
|
|
|
|
if (!bits.endsWith(QLatin1String("bit")))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
bool ok = false;
|
|
|
|
|
int bitCount = bits.left(bits.count() - 3).toInt(&ok);
|
|
|
|
|
if (!ok)
|
|
|
|
|
return;
|
|
|
|
|
if (bitCount != 8 && bitCount != 16 && bitCount != 32 && bitCount != 64)
|
|
|
|
|
return;
|
|
|
|
|
m_wordWidth = bitCount;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QString Abi::toString() const
|
|
|
|
|
{
|
|
|
|
|
QStringList dn;
|
|
|
|
|
dn << toString(m_architecture);
|
|
|
|
|
dn << toString(m_os);
|
|
|
|
|
dn << toString(m_osFlavor);
|
|
|
|
|
dn << toString(m_binaryFormat);
|
|
|
|
|
dn << toString(m_wordWidth);
|
|
|
|
|
|
|
|
|
|
return dn.join(QLatin1String("-"));
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-10 14:43:44 +01:00
|
|
|
bool Abi::operator != (const Abi &other) const
|
|
|
|
|
{
|
|
|
|
|
return !operator ==(other);
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-01 18:36:00 +01:00
|
|
|
bool Abi::operator == (const Abi &other) const
|
|
|
|
|
{
|
|
|
|
|
return m_architecture == other.m_architecture
|
|
|
|
|
&& m_os == other.m_os
|
|
|
|
|
&& m_osFlavor == other.m_osFlavor
|
|
|
|
|
&& m_binaryFormat == other.m_binaryFormat
|
|
|
|
|
&& m_wordWidth == other.m_wordWidth;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool Abi::isCompatibleWith(const Abi &other) const
|
|
|
|
|
{
|
2011-03-28 15:25:50 +02:00
|
|
|
bool isCompat = (architecture() == other.architecture() || other.architecture() == Abi::UnknownArchitecture)
|
|
|
|
|
&& (os() == other.os() || other.os() == Abi::UnknownOS)
|
|
|
|
|
&& (osFlavor() == other.osFlavor() || other.osFlavor() == Abi::UnknownFlavor)
|
|
|
|
|
&& (binaryFormat() == other.binaryFormat() || other.binaryFormat() == Abi::UnknownFormat)
|
|
|
|
|
&& ((wordWidth() == other.wordWidth() && wordWidth() != 0) || other.wordWidth() == 0);
|
2011-09-09 09:51:58 +00:00
|
|
|
// *-linux-generic-* is compatible with *-linux-* (both ways): This is for the benefit of
|
|
|
|
|
// people building Qt themselves using e.g. a meego toolchain.
|
|
|
|
|
//
|
|
|
|
|
// We leave it to the specific targets to catch filter out the tool chains that do not
|
|
|
|
|
// work for them.
|
|
|
|
|
if (!isCompat && (architecture() == other.architecture() || other.architecture() == Abi::UnknownArchitecture)
|
2011-09-16 11:35:38 +00:00
|
|
|
&& ((os() == other.os()) && (os() == LinuxOS))
|
2011-09-09 09:51:58 +00:00
|
|
|
&& (osFlavor() == GenericLinuxFlavor || other.osFlavor() == GenericLinuxFlavor)
|
|
|
|
|
&& (binaryFormat() == other.binaryFormat() || other.binaryFormat() == Abi::UnknownFormat)
|
|
|
|
|
&& ((wordWidth() == other.wordWidth() && wordWidth() != 0) || other.wordWidth() == 0))
|
2011-03-28 15:25:50 +02:00
|
|
|
isCompat = true;
|
|
|
|
|
return isCompat;
|
2011-02-01 18:36:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool Abi::isValid() const
|
|
|
|
|
{
|
2011-02-23 16:47:08 +01:00
|
|
|
return m_architecture != UnknownArchitecture
|
|
|
|
|
&& m_os != UnknownOS
|
|
|
|
|
&& m_osFlavor != UnknownFlavor
|
|
|
|
|
&& m_binaryFormat != UnknownFormat
|
2011-02-01 18:36:00 +01:00
|
|
|
&& m_wordWidth != 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-09-06 14:24:13 +00:00
|
|
|
bool Abi::isNull() const
|
|
|
|
|
{
|
|
|
|
|
return m_architecture == UnknownArchitecture
|
|
|
|
|
&& m_os == UnknownOS
|
|
|
|
|
&& m_osFlavor == UnknownFlavor
|
|
|
|
|
&& m_binaryFormat == UnknownFormat
|
|
|
|
|
&& m_wordWidth == 0;
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-01 18:36:00 +01:00
|
|
|
QString Abi::toString(const Architecture &a)
|
|
|
|
|
{
|
|
|
|
|
switch (a) {
|
2011-02-23 16:47:08 +01:00
|
|
|
case ArmArchitecture:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("arm");
|
2011-02-23 16:47:08 +01:00
|
|
|
case X86Architecture:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("x86");
|
2011-08-31 09:55:34 +00:00
|
|
|
case MipsArchitecture:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("mips");
|
2011-02-23 16:47:08 +01:00
|
|
|
case PowerPCArchitecture:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("ppc");
|
2011-02-23 16:47:08 +01:00
|
|
|
case ItaniumArchitecture:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("itanium");
|
2011-09-22 14:26:10 +00:00
|
|
|
case ShArchitecture:
|
2011-09-23 11:57:11 +00:00
|
|
|
return QLatin1String("sh");
|
2011-02-23 16:47:08 +01:00
|
|
|
case UnknownArchitecture: // fall through!
|
2011-02-01 18:36:00 +01:00
|
|
|
default:
|
|
|
|
|
return QLatin1String("unknown");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QString Abi::toString(const OS &o)
|
|
|
|
|
{
|
|
|
|
|
switch (o) {
|
2011-02-23 16:47:08 +01:00
|
|
|
case LinuxOS:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("linux");
|
2011-05-31 10:06:32 +00:00
|
|
|
case BsdOS:
|
|
|
|
|
return QLatin1String("bsd");
|
2011-02-23 16:47:08 +01:00
|
|
|
case MacOS:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("macos");
|
2011-02-23 16:47:08 +01:00
|
|
|
case SymbianOS:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("symbian");
|
2011-02-23 16:47:08 +01:00
|
|
|
case UnixOS:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("unix");
|
2011-02-23 16:47:08 +01:00
|
|
|
case WindowsOS:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("windows");
|
2011-02-23 16:47:08 +01:00
|
|
|
case UnknownOS: // fall through!
|
2011-02-01 18:36:00 +01:00
|
|
|
default:
|
|
|
|
|
return QLatin1String("unknown");
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-23 16:47:08 +01:00
|
|
|
QString Abi::toString(const OSFlavor &of)
|
2011-02-01 18:36:00 +01:00
|
|
|
{
|
|
|
|
|
switch (of) {
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::GenericLinuxFlavor:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("generic");
|
2011-05-31 10:06:32 +00:00
|
|
|
case ProjectExplorer::Abi::FreeBsdFlavor:
|
|
|
|
|
return QLatin1String("freebsd");
|
|
|
|
|
case ProjectExplorer::Abi::NetBsdFlavor:
|
|
|
|
|
return QLatin1String("netbsd");
|
|
|
|
|
case ProjectExplorer::Abi::OpenBsdFlavor:
|
|
|
|
|
return QLatin1String("openbsd");
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::MaemoLinuxFlavor:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("maemo");
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::HarmattanLinuxFlavor:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("harmattan");
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::MeegoLinuxFlavor:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("meego");
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::GenericMacFlavor:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("generic");
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::SymbianDeviceFlavor:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("device");
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::SymbianEmulatorFlavor:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("emulator");
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::GenericUnixFlavor:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("generic");
|
2011-05-31 10:06:32 +00:00
|
|
|
case ProjectExplorer::Abi::SolarisUnixFlavor:
|
|
|
|
|
return QLatin1String("solaris");
|
2011-03-18 09:54:35 +01:00
|
|
|
case ProjectExplorer::Abi::WindowsMsvc2005Flavor:
|
|
|
|
|
return QLatin1String("msvc2005");
|
|
|
|
|
case ProjectExplorer::Abi::WindowsMsvc2008Flavor:
|
|
|
|
|
return QLatin1String("msvc2008");
|
|
|
|
|
case ProjectExplorer::Abi::WindowsMsvc2010Flavor:
|
|
|
|
|
return QLatin1String("msvc2010");
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::WindowsMSysFlavor:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("msys");
|
2011-02-23 16:47:08 +01:00
|
|
|
case ProjectExplorer::Abi::WindowsCEFlavor:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("ce");
|
2011-02-25 15:27:13 +01:00
|
|
|
case ProjectExplorer::Abi::UnknownFlavor: // fall through!
|
2011-02-01 18:36:00 +01:00
|
|
|
default:
|
|
|
|
|
return QLatin1String("unknown");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QString Abi::toString(const BinaryFormat &bf)
|
|
|
|
|
{
|
|
|
|
|
switch (bf) {
|
2011-02-23 16:47:08 +01:00
|
|
|
case ElfFormat:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("elf");
|
2011-02-23 16:47:08 +01:00
|
|
|
case PEFormat:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("pe");
|
2011-02-23 16:47:08 +01:00
|
|
|
case MachOFormat:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("mach_o");
|
2011-02-23 16:47:08 +01:00
|
|
|
case RuntimeQmlFormat:
|
2011-02-01 18:36:00 +01:00
|
|
|
return QLatin1String("qml_rt");
|
2011-02-23 16:47:08 +01:00
|
|
|
case UnknownFormat: // fall through!
|
2011-02-01 18:36:00 +01:00
|
|
|
default:
|
|
|
|
|
return QLatin1String("unknown");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
QString Abi::toString(int w)
|
|
|
|
|
{
|
|
|
|
|
if (w == 0)
|
|
|
|
|
return QLatin1String("unknown");
|
|
|
|
|
return QString::fromLatin1("%1bit").arg(w);
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-24 14:06:51 +00:00
|
|
|
QList<Abi::OSFlavor> Abi::flavorsForOs(const Abi::OS &o)
|
|
|
|
|
{
|
|
|
|
|
QList<OSFlavor> result;
|
|
|
|
|
switch (o) {
|
|
|
|
|
case BsdOS:
|
|
|
|
|
return result << FreeBsdFlavor << OpenBsdFlavor << NetBsdFlavor;
|
|
|
|
|
case LinuxOS:
|
|
|
|
|
return result << GenericLinuxFlavor << HarmattanLinuxFlavor << MaemoLinuxFlavor << MeegoLinuxFlavor;
|
|
|
|
|
case MacOS:
|
|
|
|
|
return result << GenericMacFlavor;
|
|
|
|
|
case SymbianOS:
|
|
|
|
|
return result << SymbianDeviceFlavor << SymbianEmulatorFlavor;
|
|
|
|
|
case UnixOS:
|
|
|
|
|
return result << GenericUnixFlavor << SolarisUnixFlavor;
|
|
|
|
|
case WindowsOS:
|
|
|
|
|
return result << WindowsMsvc2005Flavor << WindowsMsvc2008Flavor << WindowsMsvc2010Flavor
|
|
|
|
|
<< WindowsMSysFlavor << WindowsCEFlavor;
|
|
|
|
|
case UnknownOS:
|
|
|
|
|
return result << UnknownFlavor;
|
|
|
|
|
default:
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return result;
|
|
|
|
|
}
|
2011-02-01 18:36:00 +01:00
|
|
|
|
|
|
|
|
Abi Abi::hostAbi()
|
|
|
|
|
{
|
|
|
|
|
Architecture arch = QTC_CPU; // define set by qmake
|
2011-02-23 16:47:08 +01:00
|
|
|
OS os = UnknownOS;
|
|
|
|
|
OSFlavor subos = UnknownFlavor;
|
|
|
|
|
BinaryFormat format = UnknownFormat;
|
2011-02-01 18:36:00 +01:00
|
|
|
|
|
|
|
|
#if defined (Q_OS_WIN)
|
2011-02-23 16:47:08 +01:00
|
|
|
os = WindowsOS;
|
2011-03-18 09:54:35 +01:00
|
|
|
#if _MSC_VER == 1600
|
|
|
|
|
subos = WindowsMsvc2010Flavor;
|
|
|
|
|
#elif _MSC_VER == 1500
|
|
|
|
|
subos = WindowsMsvc2008Flavor;
|
|
|
|
|
#elif _MSC_VER == 1400
|
|
|
|
|
subos = WindowsMsvc2005Flavor;
|
|
|
|
|
#elif defined (mingw32)
|
|
|
|
|
subos = WindowsMSysFlavor;
|
|
|
|
|
#endif
|
2011-02-23 16:47:08 +01:00
|
|
|
format = PEFormat;
|
2011-02-01 18:36:00 +01:00
|
|
|
#elif defined (Q_OS_LINUX)
|
2011-02-23 16:47:08 +01:00
|
|
|
os = LinuxOS;
|
|
|
|
|
subos = GenericLinuxFlavor;
|
|
|
|
|
format = ElfFormat;
|
2011-02-01 18:36:00 +01:00
|
|
|
#elif defined (Q_OS_MAC)
|
2011-02-23 16:47:08 +01:00
|
|
|
os = MacOS;
|
|
|
|
|
subos = GenericMacFlavor;
|
|
|
|
|
format = MachOFormat;
|
2011-02-01 18:36:00 +01:00
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
return Abi(arch, os, subos, format, QSysInfo::WordSize);
|
|
|
|
|
}
|
|
|
|
|
|
2012-01-13 15:07:32 +01:00
|
|
|
QList<Abi> Abi::abisOfBinary(const Utils::FileName &path)
|
2011-02-01 18:36:00 +01:00
|
|
|
{
|
2011-03-21 18:04:24 +01:00
|
|
|
QList<Abi> tmp;
|
2011-02-01 18:36:00 +01:00
|
|
|
if (path.isEmpty())
|
2011-03-21 18:04:24 +01:00
|
|
|
return tmp;
|
2011-02-01 18:36:00 +01:00
|
|
|
|
2012-01-13 15:07:32 +01:00
|
|
|
QFile f(path.toString());
|
2011-02-01 18:36:00 +01:00
|
|
|
if (!f.exists())
|
2011-03-21 18:04:24 +01:00
|
|
|
return tmp;
|
2011-02-01 18:36:00 +01:00
|
|
|
|
|
|
|
|
f.open(QFile::ReadOnly);
|
|
|
|
|
QByteArray data = f.read(1024);
|
2011-03-02 14:09:18 +01:00
|
|
|
if (data.size() >= 67
|
2011-08-31 15:09:18 +00:00
|
|
|
&& getUint8(data, 0) == '!' && getUint8(data, 1) == '<' && getUint8(data, 2) == 'a'
|
|
|
|
|
&& getUint8(data, 3) == 'r' && getUint8(data, 4) == 'c' && getUint8(data, 5) == 'h'
|
|
|
|
|
&& getUint8(data, 6) == '>' && getUint8(data, 7) == 0x0a) {
|
2011-03-21 18:04:24 +01:00
|
|
|
// We got an ar file: possibly a static lib for ELF, PE or Mach-O
|
2011-03-02 14:09:18 +01:00
|
|
|
|
|
|
|
|
data = data.mid(8); // Cut of ar file magic
|
|
|
|
|
quint64 offset = 8;
|
|
|
|
|
|
|
|
|
|
while (!data.isEmpty()) {
|
2011-08-31 15:09:18 +00:00
|
|
|
if ((getUint8(data, 58) != 0x60 || getUint8(data, 59) != 0x0a)) {
|
2012-01-13 15:07:32 +01:00
|
|
|
qWarning() << path.toString() << ": Thought it was an ar-file, but it is not!";
|
2011-02-01 18:36:00 +01:00
|
|
|
break;
|
2011-03-02 14:09:18 +01:00
|
|
|
}
|
2011-02-01 18:36:00 +01:00
|
|
|
|
2011-03-02 14:09:18 +01:00
|
|
|
const QString fileName = QString::fromLocal8Bit(data.mid(0, 16));
|
|
|
|
|
quint64 fileNameOffset = 0;
|
|
|
|
|
if (fileName.startsWith(QLatin1String("#1/")))
|
|
|
|
|
fileNameOffset = fileName.mid(3).toInt();
|
|
|
|
|
const QString fileLength = QString::fromAscii(data.mid(48, 10));
|
2011-03-01 18:04:16 +01:00
|
|
|
|
2011-03-03 11:29:07 +01:00
|
|
|
int toSkip = 60 + fileNameOffset;
|
2011-03-02 14:09:18 +01:00
|
|
|
offset += fileLength.toInt() + 60 /* header */;
|
2011-05-06 17:56:21 +02:00
|
|
|
|
|
|
|
|
tmp.append(abiOf(data.mid(toSkip)));
|
|
|
|
|
if (tmp.isEmpty() && fileName == QLatin1String("/0 "))
|
|
|
|
|
tmp = parseCoffHeader(data.mid(toSkip, 20)); // This might be windws...
|
|
|
|
|
|
2011-03-21 18:04:24 +01:00
|
|
|
if (!tmp.isEmpty()
|
|
|
|
|
&& tmp.at(0).binaryFormat() != Abi::MachOFormat)
|
2011-02-01 18:36:00 +01:00
|
|
|
break;
|
2011-03-01 18:04:16 +01:00
|
|
|
|
2011-05-10 15:19:38 +02:00
|
|
|
offset += (offset % 2); // ar is 2 byte aligned
|
2011-04-11 12:47:31 +02:00
|
|
|
f.seek(offset);
|
2011-03-02 14:09:18 +01:00
|
|
|
data = f.read(1024);
|
2011-02-01 18:36:00 +01:00
|
|
|
}
|
2011-03-02 14:09:18 +01:00
|
|
|
} else {
|
2011-03-21 18:04:24 +01:00
|
|
|
tmp = abiOf(data);
|
2011-02-01 18:36:00 +01:00
|
|
|
}
|
2011-03-02 14:09:18 +01:00
|
|
|
f.close();
|
|
|
|
|
|
2011-03-21 18:04:24 +01:00
|
|
|
// Remove duplicates:
|
|
|
|
|
QList<Abi> result;
|
|
|
|
|
foreach (const Abi &a, tmp) {
|
|
|
|
|
if (!result.contains(a))
|
|
|
|
|
result.append(a);
|
|
|
|
|
}
|
|
|
|
|
|
2011-02-01 18:36:00 +01:00
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
} // namespace ProjectExplorer
|
2011-03-21 18:04:24 +01:00
|
|
|
|
|
|
|
|
// Unit tests:
|
|
|
|
|
#ifdef WITH_TESTS
|
|
|
|
|
# include <QTest>
|
|
|
|
|
# include <QtCore/QFileInfo>
|
|
|
|
|
|
|
|
|
|
# include "projectexplorer.h"
|
|
|
|
|
|
|
|
|
|
void ProjectExplorer::ProjectExplorerPlugin::testAbiOfBinary_data()
|
|
|
|
|
{
|
|
|
|
|
QTest::addColumn<QString>("file");
|
|
|
|
|
QTest::addColumn<QStringList>("abis");
|
|
|
|
|
|
|
|
|
|
QTest::newRow("no file")
|
|
|
|
|
<< QString()
|
|
|
|
|
<< (QStringList());
|
|
|
|
|
QTest::newRow("non existing file")
|
|
|
|
|
<< QString::fromLatin1("/does/not/exist")
|
|
|
|
|
<< (QStringList());
|
|
|
|
|
|
|
|
|
|
// Set up prefix for test data now that we can be sure to have some tests to run:
|
2012-01-09 16:30:33 +01:00
|
|
|
QString prefix = QString::fromLocal8Bit(qgetenv("QTC_TEST_EXTRADATALOCATION"));
|
2011-03-21 18:04:24 +01:00
|
|
|
if (prefix.isEmpty())
|
|
|
|
|
return;
|
2012-01-09 16:30:33 +01:00
|
|
|
prefix += QLatin1String("/projectexplorer/abi");
|
2011-06-24 12:08:29 +02:00
|
|
|
|
2011-03-21 18:04:24 +01:00
|
|
|
QFileInfo fi(prefix);
|
|
|
|
|
if (!fi.exists() || !fi.isDir())
|
|
|
|
|
return;
|
|
|
|
|
prefix = fi.absoluteFilePath();
|
|
|
|
|
|
|
|
|
|
QTest::newRow("text file")
|
|
|
|
|
<< QString::fromLatin1("%1/broken/text.txt").arg(prefix)
|
|
|
|
|
<< (QStringList());
|
|
|
|
|
|
|
|
|
|
QTest::newRow("static QtCore: win msvc2008")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/static/win-msvc2008-release.lib").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-windows-unknown-pe-32bit"));
|
2011-04-11 12:47:31 +02:00
|
|
|
QTest::newRow("static QtCore: win msvc2008 II")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/static/win-msvc2008-release2.lib").arg(prefix)
|
2011-04-11 12:47:31 +02:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-windows-unknown-pe-64bit"));
|
2011-03-21 18:04:24 +01:00
|
|
|
QTest::newRow("static QtCore: win msvc2008 (debug)")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/static/win-msvc2008-debug.lib").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-windows-unknown-pe-32bit"));
|
2011-05-06 17:56:21 +02:00
|
|
|
QTest::newRow("static QtCore: win mingw")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/static/win-mingw.a").arg(prefix)
|
2011-05-06 17:56:21 +02:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-windows-unknown-pe-32bit"));
|
2011-03-21 18:04:24 +01:00
|
|
|
QTest::newRow("static QtCore: mac (debug)")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/static/mac-32bit-debug.a").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-macos-generic-mach_o-32bit"));
|
|
|
|
|
QTest::newRow("static QtCore: linux 32bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/static/linux-32bit-release.a").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-linux-generic-elf-32bit"));
|
|
|
|
|
QTest::newRow("static QtCore: linux 64bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/static/linux-64bit-release.a").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-linux-generic-elf-64bit"));
|
|
|
|
|
|
|
|
|
|
QTest::newRow("static stdc++: mac fat")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/static/mac-fat.a").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-macos-generic-mach_o-32bit")
|
|
|
|
|
<< QString::fromLatin1("ppc-macos-generic-mach_o-32bit")
|
|
|
|
|
<< QString::fromLatin1("x86-macos-generic-mach_o-64bit"));
|
|
|
|
|
|
|
|
|
|
QTest::newRow("dynamic QtCore: symbian")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/symbian.dll").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("arm-symbian-device-elf-32bit"));
|
|
|
|
|
QTest::newRow("dynamic QtCore: win msvc2010 64bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/win-msvc2010-64bit.dll").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-windows-msvc2010-pe-64bit"));
|
|
|
|
|
QTest::newRow("dynamic QtCore: win msvc2008 32bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/win-msvc2008-32bit.dll").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-windows-msvc2008-pe-32bit"));
|
|
|
|
|
QTest::newRow("dynamic QtCore: win msvc2005 32bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/win-msvc2005-32bit.dll").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-windows-msvc2005-pe-32bit"));
|
|
|
|
|
QTest::newRow("dynamic QtCore: win msys 32bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/win-mingw-32bit.dll").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-windows-msys-pe-32bit"));
|
2011-07-11 14:22:28 +00:00
|
|
|
QTest::newRow("dynamic QtCore: wince msvc2005 32bit")
|
|
|
|
|
<< QString::fromLatin1("%1/dynamic/wince-32bit.dll").arg(prefix)
|
|
|
|
|
<< (QStringList() << QString::fromLatin1("mips-windows-msvc2005-pe-32bit"));
|
2011-03-23 15:25:38 +01:00
|
|
|
QTest::newRow("dynamic stdc++: mac fat")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/mac-fat.dylib").arg(prefix)
|
2011-03-21 18:04:24 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-macos-generic-mach_o-32bit")
|
|
|
|
|
<< QString::fromLatin1("ppc-macos-generic-mach_o-32bit")
|
|
|
|
|
<< QString::fromLatin1("x86-macos-generic-mach_o-64bit"));
|
2011-03-23 15:25:38 +01:00
|
|
|
QTest::newRow("dynamic QtCore: arm linux 32bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/arm-linux.so").arg(prefix)
|
2011-03-23 15:25:38 +01:00
|
|
|
<< (QStringList() << QString::fromLatin1("arm-linux-generic-elf-32bit"));
|
2011-08-31 15:20:28 +00:00
|
|
|
QTest::newRow("dynamic QtCore: arm linux 32bit (angstrom)")
|
|
|
|
|
<< QString::fromLatin1("%1/dynamic/arm-angstrom-linux.so").arg(prefix)
|
|
|
|
|
<< (QStringList() << QString::fromLatin1("arm-linux-generic-elf-32bit"));
|
2011-09-22 14:26:10 +00:00
|
|
|
QTest::newRow("dynamic QtCore: sh4 linux 32bit")
|
|
|
|
|
<< QString::fromLatin1("%1/dynamic/sh4-linux.so").arg(prefix)
|
|
|
|
|
<< (QStringList() << QString::fromLatin1("sh-linux-generic-elf-32bit"));
|
2011-04-06 10:04:57 +02:00
|
|
|
QTest::newRow("dynamic QtCore: mips linux 32bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/mips-linux.so").arg(prefix)
|
2011-04-06 10:04:57 +02:00
|
|
|
<< (QStringList() << QString::fromLatin1("mips-linux-generic-elf-32bit"));
|
2011-06-24 12:08:29 +02:00
|
|
|
QTest::newRow("dynamic QtCore: projectexplorer/abi/static/win-msvc2010-32bit.libppc be linux 32bit")
|
|
|
|
|
<< QString::fromLatin1("%1/dynamic/ppcbe-linux-32bit.so").arg(prefix)
|
|
|
|
|
<< (QStringList() << QString::fromLatin1("ppc-linux-generic-elf-32bit"));
|
2011-05-31 10:06:32 +00:00
|
|
|
QTest::newRow("dynamic QtCore: x86 freebsd 64bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/freebsd-elf-64bit.so").arg(prefix)
|
2011-05-31 10:06:32 +00:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-bsd-freebsd-elf-64bit"));
|
|
|
|
|
QTest::newRow("dynamic QtCore: x86 freebsd 64bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/freebsd-elf-64bit.so").arg(prefix)
|
2011-05-31 10:06:32 +00:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-bsd-freebsd-elf-64bit"));
|
|
|
|
|
QTest::newRow("dynamic QtCore: x86 freebsd 32bit")
|
2011-06-24 12:08:29 +02:00
|
|
|
<< QString::fromLatin1("%1/dynamic/freebsd-elf-32bit.so").arg(prefix)
|
2011-05-31 10:06:32 +00:00
|
|
|
<< (QStringList() << QString::fromLatin1("x86-bsd-freebsd-elf-32bit"));
|
2011-09-22 14:26:10 +00:00
|
|
|
|
|
|
|
|
QTest::newRow("executable: x86 win 32bit cygwin executable")
|
|
|
|
|
<< QString::fromLatin1("%1/executable/cygwin-32bit.exe").arg(prefix)
|
|
|
|
|
<< (QStringList() << QString::fromLatin1("x86-windows-msys-pe-32bit"));
|
2011-09-23 15:53:55 +00:00
|
|
|
QTest::newRow("executable: x86 win 32bit mingw executable")
|
|
|
|
|
<< QString::fromLatin1("%1/executable/mingw-32bit.exe").arg(prefix)
|
|
|
|
|
<< (QStringList() << QString::fromLatin1("x86-windows-msys-pe-32bit"));
|
2011-03-21 18:04:24 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ProjectExplorer::ProjectExplorerPlugin::testAbiOfBinary()
|
|
|
|
|
{
|
|
|
|
|
QFETCH(QString, file);
|
|
|
|
|
QFETCH(QStringList, abis);
|
|
|
|
|
|
2012-01-13 15:07:32 +01:00
|
|
|
QList<ProjectExplorer::Abi> result = Abi::abisOfBinary(Utils::FileName::fromString(file));
|
2011-03-21 18:04:24 +01:00
|
|
|
QCOMPARE(result.count(), abis.count());
|
|
|
|
|
for (int i = 0; i < abis.count(); ++i)
|
|
|
|
|
QCOMPARE(result.at(i).toString(), abis.at(i));
|
|
|
|
|
}
|
|
|
|
|
|
2011-05-24 14:06:51 +00:00
|
|
|
void ProjectExplorer::ProjectExplorerPlugin::testFlavorForOs()
|
|
|
|
|
{
|
|
|
|
|
QList<QList<ProjectExplorer::Abi::OSFlavor> > flavorLists;
|
|
|
|
|
for (int i = 0; i != static_cast<int>(Abi::UnknownOS); ++i)
|
|
|
|
|
flavorLists.append(Abi::flavorsForOs(static_cast<Abi::OS>(i)));
|
|
|
|
|
|
|
|
|
|
int foundCounter = 0;
|
|
|
|
|
for (int i = 0; i != Abi::UnknownFlavor; ++i) {
|
|
|
|
|
foundCounter = 0;
|
|
|
|
|
// make sure i is in exactly on of the flavor lists!
|
|
|
|
|
foreach (const QList<Abi::OSFlavor> &l, flavorLists) {
|
|
|
|
|
QVERIFY(!l.contains(Abi::UnknownFlavor));
|
|
|
|
|
if (l.contains(static_cast<Abi::OSFlavor>(i)))
|
|
|
|
|
++foundCounter;
|
|
|
|
|
}
|
|
|
|
|
QCOMPARE(foundCounter, 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-03-21 18:04:24 +01:00
|
|
|
#endif
|
