forked from qt-creator/qt-creator
e38410b76c
modernize-use-auto modernize-use-nullptr modernize-use-override modernize-use-using modernize-use-default-member-init modernize-use-equals-default Change-Id: I8d44d9405011a1878353baf9325f7af90b89db02 Reviewed-by: hjk <hjk@qt.io>
359 lines
11 KiB
C++
359 lines
11 KiB
C++
/****************************************************************************
|
|
**
|
|
** Copyright (C) 2016 The Qt Company Ltd.
|
|
** Contact: https://www.qt.io/licensing/
|
|
**
|
|
** This file is part of Qt Creator.
|
|
**
|
|
** Commercial License Usage
|
|
** Licensees holding valid commercial Qt licenses may use this file in
|
|
** accordance with the commercial license agreement provided with the
|
|
** Software or, alternatively, in accordance with the terms contained in
|
|
** a written agreement between you and The Qt Company. For licensing terms
|
|
** and conditions see https://www.qt.io/terms-conditions. For further
|
|
** information use the contact form at https://www.qt.io/contact-us.
|
|
**
|
|
** GNU General Public License Usage
|
|
** Alternatively, this file may be used under the terms of the GNU
|
|
** General Public License version 3 as published by the Free Software
|
|
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
|
|
** included in the packaging of this file. Please review the following
|
|
** information to ensure the GNU General Public License requirements will
|
|
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
|
|
**
|
|
****************************************************************************/
|
|
|
|
#include "elfreader.h"
|
|
#include "qtcassert.h"
|
|
|
|
#include <QDir>
|
|
#include <QDebug>
|
|
|
|
#include <new> // std::bad_alloc
|
|
|
|
namespace Utils {
|
|
|
|
quint16 getHalfWord(const unsigned char *&s, const ElfData &context)
|
|
{
|
|
quint16 res;
|
|
if (context.endian == Elf_ELFDATA2MSB)
|
|
res = qFromBigEndian<quint16>(s);
|
|
else
|
|
res = qFromLittleEndian<quint16>(s);
|
|
s += 2;
|
|
return res;
|
|
}
|
|
|
|
quint32 getWord(const unsigned char *&s, const ElfData &context)
|
|
{
|
|
quint32 res;
|
|
if (context.endian == Elf_ELFDATA2MSB)
|
|
res = qFromBigEndian<quint32>(s);
|
|
else
|
|
res = qFromLittleEndian<quint32>(s);
|
|
s += 4;
|
|
return res;
|
|
}
|
|
|
|
quint64 getAddress(const unsigned char *&s, const ElfData &context)
|
|
{
|
|
quint64 res;
|
|
if (context.elfclass == Elf_ELFCLASS32) {
|
|
if (context.endian == Elf_ELFDATA2MSB)
|
|
res = qFromBigEndian<quint32>(s);
|
|
else
|
|
res = qFromLittleEndian<quint32>(s);
|
|
s += 4;
|
|
} else {
|
|
if (context.endian == Elf_ELFDATA2MSB)
|
|
res = qFromBigEndian<quint64>(s);
|
|
else
|
|
res = qFromLittleEndian<quint64>(s);
|
|
s += 8;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
quint64 getOffset(const unsigned char *&s, const ElfData &context)
|
|
{
|
|
return getAddress(s, context);
|
|
}
|
|
|
|
static void parseSectionHeader(const uchar *s, ElfSectionHeader *sh, const ElfData &context)
|
|
{
|
|
sh->index = getWord(s, context);
|
|
sh->type = getWord(s, context);
|
|
sh->flags = getOffset(s, context);
|
|
sh->addr = getAddress(s, context);
|
|
sh->offset = getOffset(s, context);
|
|
sh->size = getOffset(s, context);
|
|
}
|
|
|
|
static void parseProgramHeader(const uchar *s, ElfProgramHeader *sh, const ElfData &context)
|
|
{
|
|
sh->type = getWord(s, context);
|
|
sh->offset = getOffset(s, context);
|
|
/* p_vaddr = */ getAddress(s, context);
|
|
/* p_paddr = */ getAddress(s, context);
|
|
sh->filesz = getWord(s, context);
|
|
sh->memsz = getWord(s, context);
|
|
}
|
|
|
|
ElfMapper::ElfMapper(const ElfReader *reader) : file(reader->m_binary) {}
|
|
|
|
bool ElfMapper::map()
|
|
{
|
|
if (!file.open(QIODevice::ReadOnly))
|
|
return false;
|
|
|
|
fdlen = file.size();
|
|
ustart = file.map(0, fdlen);
|
|
if (ustart == nullptr) {
|
|
// Try reading the data into memory instead.
|
|
try {
|
|
raw = file.readAll();
|
|
} catch (const std::bad_alloc &) {
|
|
return false;
|
|
}
|
|
start = raw.constData();
|
|
fdlen = raw.size();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
ElfReader::ElfReader(const QString &binary)
|
|
: m_binary(binary)
|
|
{
|
|
}
|
|
|
|
ElfData ElfReader::readHeaders()
|
|
{
|
|
readIt();
|
|
return m_elfData;
|
|
}
|
|
|
|
static inline QString msgInvalidElfObject(const QString &binary, const QString &why)
|
|
{
|
|
return ElfReader::tr("\"%1\" is an invalid ELF object (%2)")
|
|
.arg(QDir::toNativeSeparators(binary), why);
|
|
}
|
|
|
|
ElfReader::Result ElfReader::readIt()
|
|
{
|
|
if (!m_elfData.sectionHeaders.isEmpty())
|
|
return Ok;
|
|
if (!m_elfData.programHeaders.isEmpty())
|
|
return Ok;
|
|
|
|
ElfMapper mapper(this);
|
|
if (!mapper.map())
|
|
return Corrupt;
|
|
|
|
const quint64 fdlen = mapper.fdlen;
|
|
|
|
if (fdlen < 64) {
|
|
m_errorString = tr("\"%1\" is not an ELF object (file too small)").arg(QDir::toNativeSeparators(m_binary));
|
|
return NotElf;
|
|
}
|
|
|
|
if (strncmp(mapper.start, "\177ELF", 4) != 0) {
|
|
m_errorString = tr("\"%1\" is not an ELF object").arg(QDir::toNativeSeparators(m_binary));
|
|
return NotElf;
|
|
}
|
|
|
|
// 32 or 64 bit
|
|
m_elfData.elfclass = ElfClass(mapper.start[4]);
|
|
const bool is64Bit = m_elfData.elfclass == Elf_ELFCLASS64;
|
|
if (m_elfData.elfclass != Elf_ELFCLASS32 && m_elfData.elfclass != Elf_ELFCLASS64) {
|
|
m_errorString = msgInvalidElfObject(m_binary, tr("odd cpu architecture"));
|
|
return Corrupt;
|
|
}
|
|
|
|
// int bits = (data[4] << 5);
|
|
// If you remove this check to read ELF objects of a different arch,
|
|
// please make sure you modify the typedefs
|
|
// to match the _plugin_ architecture.
|
|
// if ((sizeof(void*) == 4 && bits != 32)
|
|
// || (sizeof(void*) == 8 && bits != 64)) {
|
|
// if (errorString)
|
|
// *errorString = QLibrary::tr("\"%1\" is an invalid ELF object (%2)")
|
|
// .arg(m_binary).arg(QLatin1String("wrong cpu architecture"));
|
|
// return Corrupt;
|
|
// }
|
|
|
|
// Read Endianess.
|
|
m_elfData.endian = ElfEndian(mapper.ustart[5]);
|
|
if (m_elfData.endian != Elf_ELFDATA2LSB && m_elfData.endian != Elf_ELFDATA2MSB) {
|
|
m_errorString = msgInvalidElfObject(m_binary, tr("odd endianness"));
|
|
return Corrupt;
|
|
}
|
|
|
|
const uchar *data = mapper.ustart + 16; // e_ident
|
|
m_elfData.elftype = ElfType(getHalfWord(data, m_elfData));
|
|
m_elfData.elfmachine = ElfMachine(getHalfWord(data, m_elfData));
|
|
/* e_version = */ getWord(data, m_elfData);
|
|
m_elfData.entryPoint = getAddress(data, m_elfData);
|
|
|
|
quint64 e_phoff = getOffset(data, m_elfData);
|
|
quint64 e_shoff = getOffset(data, m_elfData);
|
|
/* e_flags = */ getWord(data, m_elfData);
|
|
|
|
quint32 e_shsize = getHalfWord(data, m_elfData);
|
|
|
|
if (e_shsize > fdlen) {
|
|
m_errorString = msgInvalidElfObject(m_binary, tr("unexpected e_shsize"));
|
|
return Corrupt;
|
|
}
|
|
|
|
quint32 e_phentsize = getHalfWord(data, m_elfData);
|
|
QTC_CHECK(e_phentsize == (is64Bit ? 56 : 32));
|
|
quint32 e_phnum = getHalfWord(data, m_elfData);
|
|
|
|
quint32 e_shentsize = getHalfWord(data, m_elfData);
|
|
|
|
if (e_shentsize % 4) {
|
|
m_errorString = msgInvalidElfObject(m_binary, tr("unexpected e_shentsize"));
|
|
return Corrupt;
|
|
}
|
|
|
|
quint32 e_shnum = getHalfWord(data, m_elfData);
|
|
quint32 e_shtrndx = getHalfWord(data, m_elfData);
|
|
QTC_CHECK(data == mapper.ustart + (is64Bit ? 64 : 52));
|
|
|
|
if (quint64(e_shnum) * e_shentsize > fdlen) {
|
|
const QString reason = tr("announced %n sections, each %1 bytes, exceed file size", nullptr, e_shnum)
|
|
.arg(e_shentsize);
|
|
m_errorString = msgInvalidElfObject(m_binary, reason);
|
|
return Corrupt;
|
|
}
|
|
|
|
quint64 soff = e_shoff + e_shentsize * e_shtrndx;
|
|
|
|
// if ((soff + e_shentsize) > fdlen || soff % 4 || soff == 0) {
|
|
// m_errorString = QLibrary::tr("\"%1\" is an invalid ELF object (%2)")
|
|
// .arg(m_binary)
|
|
// .arg(QLatin1String("shstrtab section header seems to be at %1"))
|
|
// .arg(QString::number(soff, 16));
|
|
// return Corrupt;
|
|
// }
|
|
|
|
if (e_shoff) {
|
|
ElfSectionHeader strtab;
|
|
parseSectionHeader(mapper.ustart + soff, &strtab, m_elfData);
|
|
const quint64 stringTableFileOffset = strtab.offset;
|
|
|
|
if (quint32(stringTableFileOffset + e_shentsize) >= fdlen
|
|
|| stringTableFileOffset == 0) {
|
|
const QString reason = tr("string table seems to be at 0x%1").arg(soff, 0, 16);
|
|
m_errorString = msgInvalidElfObject(m_binary, reason);
|
|
return Corrupt;
|
|
}
|
|
|
|
for (quint32 i = 0; i < e_shnum; ++i) {
|
|
const uchar *s = mapper.ustart + e_shoff + i * e_shentsize;
|
|
ElfSectionHeader sh;
|
|
parseSectionHeader(s, &sh, m_elfData);
|
|
|
|
if (stringTableFileOffset + sh.index > fdlen) {
|
|
const QString reason = tr("section name %1 of %2 behind end of file")
|
|
.arg(i).arg(e_shnum);
|
|
m_errorString = msgInvalidElfObject(m_binary, reason);
|
|
return Corrupt;
|
|
}
|
|
|
|
sh.name = mapper.start + stringTableFileOffset + sh.index;
|
|
if (sh.name == ".gdb_index") {
|
|
m_elfData.symbolsType = FastSymbols;
|
|
} else if (sh.name == ".debug_info") {
|
|
m_elfData.symbolsType = PlainSymbols;
|
|
} else if (sh.name == ".gnu_debuglink") {
|
|
m_elfData.debugLink = QByteArray(mapper.start + sh.offset);
|
|
m_elfData.symbolsType = LinkedSymbols;
|
|
} else if (sh.name == ".note.gnu.build-id") {
|
|
m_elfData.symbolsType = BuildIdSymbols;
|
|
if (sh.size > 16)
|
|
m_elfData.buildId = QByteArray(mapper.start + sh.offset + 16,
|
|
sh.size - 16).toHex();
|
|
}
|
|
m_elfData.sectionHeaders.append(sh);
|
|
}
|
|
}
|
|
|
|
if (e_phoff) {
|
|
for (quint32 i = 0; i < e_phnum; ++i) {
|
|
const uchar *s = mapper.ustart + e_phoff + i * e_phentsize;
|
|
ElfProgramHeader ph;
|
|
parseProgramHeader(s, &ph, m_elfData);
|
|
m_elfData.programHeaders.append(ph);
|
|
}
|
|
}
|
|
return Ok;
|
|
}
|
|
|
|
QSharedPointer<ElfMapper> ElfReader::readSection(const QByteArray &name)
|
|
{
|
|
QSharedPointer<ElfMapper> mapper;
|
|
readIt();
|
|
int i = m_elfData.indexOf(name);
|
|
if (i == -1)
|
|
return mapper;
|
|
|
|
mapper.reset(new ElfMapper(this));
|
|
if (!mapper->map())
|
|
return mapper;
|
|
|
|
const ElfSectionHeader §ion = m_elfData.sectionHeaders.at(i);
|
|
mapper->start += section.offset;
|
|
mapper->fdlen = section.size;
|
|
return mapper;
|
|
}
|
|
|
|
static QByteArray cutout(const char *s)
|
|
{
|
|
QByteArray res(s, 80);
|
|
const int pos = res.indexOf('\0');
|
|
if (pos != -1)
|
|
res.resize(pos - 1);
|
|
return res;
|
|
}
|
|
|
|
QByteArray ElfReader::readCoreName(bool *isCore)
|
|
{
|
|
*isCore = false;
|
|
|
|
readIt();
|
|
|
|
ElfMapper mapper(this);
|
|
if (!mapper.map())
|
|
return QByteArray();
|
|
|
|
if (m_elfData.elftype != Elf_ET_CORE)
|
|
return QByteArray();
|
|
|
|
*isCore = true;
|
|
|
|
for (int i = 0, n = m_elfData.sectionHeaders.size(); i != n; ++i)
|
|
if (m_elfData.sectionHeaders.at(i).type == Elf_SHT_NOTE) {
|
|
const ElfSectionHeader &header = m_elfData.sectionHeaders.at(i);
|
|
return cutout(mapper.start + header.offset + 0x40);
|
|
}
|
|
|
|
for (int i = 0, n = m_elfData.programHeaders.size(); i != n; ++i)
|
|
if (m_elfData.programHeaders.at(i).type == Elf_PT_NOTE) {
|
|
const ElfProgramHeader &header = m_elfData.programHeaders.at(i);
|
|
return cutout(mapper.start + header.offset + 0xec);
|
|
}
|
|
|
|
return QByteArray();
|
|
}
|
|
|
|
int ElfData::indexOf(const QByteArray &name) const
|
|
{
|
|
for (int i = 0, n = sectionHeaders.size(); i != n; ++i)
|
|
if (sectionHeaders.at(i).name == name)
|
|
return i;
|
|
return -1;
|
|
}
|
|
|
|
} // namespace Utils
|