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

debugger: more elf shuffling

Browse Source 
Also distinguish between debuglink and buildid.

Change-Id: I1b55d1df42576c004050d319f46fb8c2ced9c85f
Reviewed-by: hjk <qthjk@ovi.com>
This commit is contained in:
hjk
2012-06-06 16:08:59 +02:00
committed by hjk
parent 79de09f266
commit 92c7dce14f
7 changed files with 301 additions and 147 deletions
Download Patch File Download Diff File Expand all files Collapse all files

276
src/libs/utils/elfreader.cpp
View File

@@ -53,6 +53,28 @@ typedef quint32 qelfword_t;
typedef quintptr qelfoff_t; typedef quintptr qelfoff_t;
typedef quintptr qelfaddr_t; typedef quintptr qelfaddr_t;
enum {
PT_NULL = 0,
PT_LOAD = 1,
PT_DYNAMIC = 2,
PT_INTERP = 3,
PT_NOTE = 4,
PT_SHLIB = 5,
PT_PHDR = 6,
PT_TLS = 7,
PT_NUM = 8
};
template <typename T>
T get(const unsigned char *s, ElfReader::ElfEndian endian)
{
if (endian == ElfReader::ElfBigEndian)
return qFromBigEndian<T>(s);
else
return qFromLittleEndian<T>(s);
}
class RawElfSectionHeader class RawElfSectionHeader
{ {
public: public:
@@ -63,6 +85,44 @@ public:
qelfoff_t size; qelfoff_t size;
}; };
static void parseSectionHeader(const uchar *data, RawElfSectionHeader *sh, ElfReader::ElfEndian endian)
{
sh->name = get<qelfword_t>(data, endian);
data += sizeof(qelfword_t); // sh_name
sh->type = get<qelfword_t>(data, endian);
data += sizeof(qelfword_t); // sh_type
data += sizeof(qelfaddr_t); // sh_flags
sh->data = get<qelfaddr_t>(data, endian);
data += sizeof(qelfaddr_t); // sh_addr
sh->offset = get<qelfoff_t>(data, endian);
data += sizeof(qelfoff_t); // sh_offset
sh->size = get<qelfoff_t>(data, endian);
data += sizeof(qelfoff_t); // sh_size
}
class RawElfProgramHeader
{
public:
qelfword_t type;
qelfoff_t offset;
qelfword_t filesz;
qelfword_t memsz;
};
static void parseProgramHeader(const uchar *data, RawElfProgramHeader *sh, ElfReader::ElfEndian endian)
{
sh->type = get<qelfword_t>(data, endian);
data += sizeof(qelfword_t); // p_type
sh->offset = get<qelfoff_t>(data, endian);
data += sizeof(qelfoff_t); // p_offset
data += sizeof(qelfaddr_t); // p_vaddr
data += sizeof(qelfaddr_t); // p_paddr
sh->filesz = get<qelfword_t>(data, endian);
data += sizeof(qelfword_t); // p_filesz
sh->memsz = get<qelfword_t>(data, endian);
data += sizeof(qelfword_t); // p_memsz
}
class ElfMapper class ElfMapper
{ {
public: public:
@@ -91,44 +151,24 @@ public:
quint64 fdlen; quint64 fdlen;
}; };
template <typename T>
T get(const unsigned char *s, ElfReader::ElfEndian endian)
{
if (endian == ElfReader::ElfBigEndian)
return qFromBigEndian<T>(s);
else
return qFromLittleEndian<T>(s);
}
static void parseSectionHeader(const uchar *data, RawElfSectionHeader *sh, ElfReader::ElfEndian endian)
{
sh->name = get<qelfword_t>(data, endian);
data += sizeof(qelfword_t); // sh_name
sh->type = get<qelfword_t>(data, endian);
data += sizeof(qelfword_t); // sh_type
data += sizeof(qelfaddr_t); // sh_flags
sh->data = get<qelfaddr_t>(data, endian);
data += sizeof(qelfaddr_t); // sh_addr
sh->offset = get<qelfoff_t>(data, endian);
data += sizeof(qelfoff_t); // sh_offset
sh->size = get<qelfoff_t>(data, endian);
data += sizeof(qelfoff_t); // sh_size
}
ElfReader::ElfReader(const QString &binary) ElfReader::ElfReader(const QString &binary)
: m_binary(binary) : m_binary(binary)
{ {
} }
ElfHeaders ElfReader::readHeaders() ElfData ElfReader::readHeaders()
{ {
if (m_headers.headers.isEmpty()) readIt();
readIt(); return m_elfData;
return m_headers;
} }
ElfReader::Result ElfReader::readIt() ElfReader::Result ElfReader::readIt()
{ {
if (!m_elfData.sectionHeaders.isEmpty())
return Ok;
if (!m_elfData.programHeaders.isEmpty())
return Ok;
ElfMapper mapper(this); ElfMapper mapper(this);
if (!mapper.map()) if (!mapper.map())
return Corrupt; return Corrupt;
@@ -179,14 +219,17 @@ ElfReader::Result ElfReader::readIt()
+ sizeof(qelfhalf_t) // e_type + sizeof(qelfhalf_t) // e_type
+ sizeof(qelfhalf_t) // e_machine + sizeof(qelfhalf_t) // e_machine
+ sizeof(qelfword_t) // e_version + sizeof(qelfword_t) // e_version
+ sizeof(qelfaddr_t) // e_entry + sizeof(qelfaddr_t); // e_entry
+ sizeof(qelfoff_t); // e_phoff
qelfoff_t e_phoff = get<qelfoff_t>(data, m_endian);
data += sizeof(qelfoff_t); // e_phoff
qelfoff_t e_shoff = get<qelfoff_t>(data, m_endian); qelfoff_t e_shoff = get<qelfoff_t>(data, m_endian);
data += sizeof(qelfoff_t) // e_shoff data += sizeof(qelfoff_t) // e_shoff
+ sizeof(qelfword_t); // e_flags + sizeof(qelfword_t); // e_flags
qelfhalf_t e_shsize = get<qelfhalf_t>(data, m_endian); qelfhalf_t e_shsize = get<qelfhalf_t>(data, m_endian);
data += sizeof(qelfhalf_t); // e_ehsize
if (e_shsize > fdlen) { if (e_shsize > fdlen) {
m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)") m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)")
@@ -194,18 +237,21 @@ ElfReader::Result ElfReader::readIt()
return Corrupt; return Corrupt;
} }
data += sizeof(qelfhalf_t) // e_ehsize qelfhalf_t e_phentsize = get<qelfhalf_t>(data, m_endian);
+ sizeof(qelfhalf_t) // e_phentsize data += sizeof(qelfhalf_t); // e_phentsize
+ sizeof(qelfhalf_t); // e_phnum
qelfhalf_t e_phnum = get<qelfhalf_t>(data, m_endian);
data += sizeof(qelfhalf_t); // e_phnum
qelfhalf_t e_shentsize = get<qelfhalf_t>(data, m_endian); qelfhalf_t e_shentsize = get<qelfhalf_t>(data, m_endian);
data += sizeof(qelfhalf_t); // e_shentsize
if (e_shentsize % 4) { if (e_shentsize % 4) {
m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)") m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)")
.arg(m_binary).arg(QLatin1String("unexpected e_shentsize")); .arg(m_binary).arg(QLatin1String("unexpected e_shentsize"));
return Corrupt; return Corrupt;
} }
data += sizeof(qelfhalf_t); // e_shentsize
qelfhalf_t e_shnum = get<qelfhalf_t>(data, m_endian); qelfhalf_t e_shnum = get<qelfhalf_t>(data, m_endian);
data += sizeof(qelfhalf_t); // e_shnum data += sizeof(qelfhalf_t); // e_shnum
qelfhalf_t e_shtrndx = get<qelfhalf_t>(data, m_endian); qelfhalf_t e_shtrndx = get<qelfhalf_t>(data, m_endian);
@@ -222,85 +268,133 @@ ElfReader::Result ElfReader::readIt()
RawElfSectionHeader strtab; RawElfSectionHeader strtab;
qulonglong soff = e_shoff + e_shentsize * (e_shtrndx); qulonglong soff = e_shoff + e_shentsize * (e_shtrndx);
if ((soff + e_shentsize) > fdlen || soff % 4 || soff == 0) { // if ((soff + e_shentsize) > fdlen || soff % 4 || soff == 0) {
m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)") // m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)")
.arg(m_binary) // .arg(m_binary)
.arg(QLatin1String("shstrtab section header seems to be at %1")) // .arg(QLatin1String("shstrtab section header seems to be at %1"))
.arg(QString::number(soff, 16)); // .arg(QString::number(soff, 16));
return Corrupt; // return Corrupt;
} // }
parseSectionHeader(mapper.start + soff, &strtab, m_endian); if (e_shoff) {
const int stringTableFileOffset = strtab.offset; parseSectionHeader(mapper.start + soff, &strtab, m_endian);
const int stringTableFileOffset = strtab.offset;
if (quint32(stringTableFileOffset + e_shentsize) >= fdlen if (quint32(stringTableFileOffset + e_shentsize) >= fdlen
|| stringTableFileOffset == 0) { || stringTableFileOffset == 0) {
m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)")
.arg(m_binary)
.arg(QLatin1String("string table seems to be at %1"))
.arg(QString::number(soff, 16));
return Corrupt;
}
const uchar *s = mapper.start + e_shoff;
for (int i = 0; i < e_shnum; ++i) {
RawElfSectionHeader sh;
parseSectionHeader(s, &sh, m_endian);
if (sh.name == 0) {
s += e_shentsize;
continue;
}
if (stringTableFileOffset + sh.name > fdlen) {
m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)") m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)")
.arg(m_binary) .arg(m_binary)
.arg(QLatin1String("section name %2 of %3 behind end of file")) .arg(QLatin1String("string table seems to be at %1"))
.arg(i).arg(e_shnum); .arg(QString::number(soff, 16));
return Corrupt; return Corrupt;
} }
ElfHeader section; const uchar *s = mapper.start + e_shoff;
section.name = ((const char *)mapper.start) + stringTableFileOffset + sh.name; for (int i = 0; i < e_shnum; ++i) {
section.index = sh.name; RawElfSectionHeader sh;
section.offset = sh.offset; parseSectionHeader(s, &sh, m_endian);
section.size = sh.size; if (sh.name == 0) {
section.data = sh.data; s += e_shentsize;
if (section.name == ".gdb_index") continue;
m_headers.symbolsType = FastSymbols; }
else if (section.name == ".debug_info")
m_headers.symbolsType = PlainSymbols;
else if (section.name == ".gnu_debuglink")
m_headers.symbolsType = SeparateSymbols;
m_headers.headers.append(section);
s += e_shentsize; if (stringTableFileOffset + sh.name > fdlen) {
m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)")
.arg(m_binary)
.arg(QLatin1String("section name %2 of %3 behind end of file"))
.arg(i).arg(e_shnum);
return Corrupt;
}
ElfSectionHeader header;
header.name = ((const char *)mapper.start) + stringTableFileOffset + sh.name;
header.index = sh.name;
header.offset = sh.offset;
header.size = sh.size;
header.data = sh.data;
if (header.name == ".gdb_index") {
m_elfData.symbolsType = FastSymbols;
} else if (header.name == ".debug_info") {
m_elfData.symbolsType = PlainSymbols;
} else if (header.name == ".gnu_debuglink") {
m_elfData.debugLink = QByteArray((const char *)mapper.start
+ header.offset);
m_elfData.symbolsType = LinkedSymbols;
} else if (header.name == ".note.gnu.build-id") {
m_elfData.symbolsType = BuildIdSymbols;
if (header.size > 16)
m_elfData.buildId = QByteArray((const char *)mapper.start
+ header.offset + 16, header.size - 16).toHex();
}
m_elfData.sectionHeaders.append(header);
s += e_shentsize;
}
}
if (e_phoff) {
const uchar *s = mapper.start + e_phoff;
for (int i = 0; i < e_phnum; ++i) {
RawElfProgramHeader ph;
parseProgramHeader(s, &ph, m_endian);
ElfProgramHeader header;
header.type = ph.type;
header.offset = ph.offset;
header.filesz = ph.filesz;
header.memsz = ph.memsz;
m_elfData.programHeaders.append(header);
s += e_phentsize;
}
} }
return Ok; return Ok;
} }
QByteArray ElfReader::readSection(const QByteArray &name) QByteArray ElfReader::readSection(const QByteArray &name)
{ {
QByteArray contents; readIt();
if (m_headers.headers.isEmpty()) int i = m_elfData.indexOf(name);
readIt();
int i = m_headers.indexOf(name);
if (i == -1) if (i == -1)
return contents; return QByteArray();
ElfMapper mapper(this); ElfMapper mapper(this);
if (!mapper.map()) if (!mapper.map())
return contents; return QByteArray();
const ElfHeader &section = m_headers.headers.at(i); const ElfSectionHeader &section = m_elfData.sectionHeaders.at(i);
return QByteArray((const char *)mapper.start + section.offset, section.size);
contents = QByteArray((const char *)mapper.start + section.offset, section.size);
return contents;
} }
int ElfHeaders::indexOf(const QByteArray &name) const QByteArray ElfReader::readCoreName()
{ {
for (int i = 0, n = headers.size(); i != n; ++i) readIt();
if (headers.at(i).name == name)
ElfMapper mapper(this);
if (!mapper.map())
return QByteArray();
for (int i = 0, n = m_elfData.sectionHeaders.size(); i != n; ++i)
if (m_elfData.sectionHeaders.at(i).type == PT_NOTE) {
const ElfSectionHeader &header = m_elfData.sectionHeaders.at(i);
return QByteArray((const char *)mapper.start + header.offset + 0x40);
}
for (int i = 0, n = m_elfData.programHeaders.size(); i != n; ++i)
if (m_elfData.programHeaders.at(i).type == PT_NOTE) {
const ElfProgramHeader &header = m_elfData.programHeaders.at(i);
QByteArray ba((const char *)mapper.start + header.offset + 0xec);
return ba;
}
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 i;
return -1; return -1;
} }

41
src/libs/utils/elfreader.h
View File

@@ -39,30 +39,28 @@
** **
****************************************************************************/ ****************************************************************************/
// This is essentially copied from Qt 5's
// qtbase/src/corelib/plugin/qelfparser_p.{h,cpp}
#ifndef UTILS_ELFREADER_H #ifndef UTILS_ELFREADER_H
#define UTILS_ELFREADER_H #define UTILS_ELFREADER_H
#include "utils_global.h" #include "utils_global.h"
#include <qendian.h> #include <qendian.h>
#include <qlist.h>
#include <qstring.h> #include <qstring.h>
#include <qvector.h>
namespace Utils { namespace Utils {
enum DebugSymbolsType enum DebugSymbolsType
{ {
UnknownSymbols, // Unknown. UnknownSymbols = 0, // Unknown.
NoSymbols, // No usable symbols. NoSymbols = 1, // No usable symbols.
SeparateSymbols, // Symbols mentioned, but not in binary. LinkedSymbols = 2, // Link to symols available.
PlainSymbols, // Ordinary symbols available. BuildIdSymbols = 4, // BuildId available.
FastSymbols // Dwarf index available. PlainSymbols = 8, // Ordinary symbols available.
FastSymbols = 16 // Dwarf index available.
}; };
class QTCREATOR_UTILS_EXPORT ElfHeader class ElfSectionHeader
{ {
public: public:
QByteArray name; QByteArray name;
@@ -73,15 +71,27 @@ public:
quint64 data; quint64 data;
}; };
class QTCREATOR_UTILS_EXPORT ElfHeaders class ElfProgramHeader
{ {
public: public:
ElfHeaders() : symbolsType(UnknownSymbols) {} quint32 type;
quint64 offset;
quint64 filesz;
quint64 memsz;
};
class QTCREATOR_UTILS_EXPORT ElfData
{
public:
ElfData() : symbolsType(UnknownSymbols) {}
int indexOf(const QByteArray &name) const; int indexOf(const QByteArray &name) const;
public: public:
QByteArray debugLink;
QByteArray buildId;
DebugSymbolsType symbolsType; DebugSymbolsType symbolsType;
QList<ElfHeader> headers; QVector<ElfSectionHeader> sectionHeaders;
QVector<ElfProgramHeader> programHeaders;
}; };
class QTCREATOR_UTILS_EXPORT ElfReader class QTCREATOR_UTILS_EXPORT ElfReader
@@ -91,9 +101,10 @@ public:
enum Result { Ok, NotElf, Corrupt }; enum Result { Ok, NotElf, Corrupt };
enum ElfEndian { ElfLittleEndian = 0, ElfBigEndian = 1 }; enum ElfEndian { ElfLittleEndian = 0, ElfBigEndian = 1 };
ElfHeaders readHeaders(); ElfData readHeaders();
QByteArray readSection(const QByteArray &sectionName); QByteArray readSection(const QByteArray &sectionName);
QString errorString() const { return m_errorString; } QString errorString() const { return m_errorString; }
QByteArray readCoreName();
private: private:
friend class ElfMapper; friend class ElfMapper;
@@ -102,7 +113,7 @@ private:
QString m_binary; QString m_binary;
QString m_errorString; QString m_errorString;
ElfEndian m_endian; ElfEndian m_endian;
ElfHeaders m_headers; ElfData m_elfData;
}; };
} // namespace Utils } // namespace Utils

74
src/plugins/debugger/gdb/coregdbadapter.cpp
View File

@@ -39,12 +39,16 @@
#include "gdbmi.h" #include "gdbmi.h"
#include "gdbengine.h" #include "gdbengine.h"
#include <utils/qtcassert.h> #include <utils/consoleprocess.h>
#include <utils/elfreader.h> #include <utils/elfreader.h>
#include <utils/qtcassert.h>
#include <utils/qtcprocess.h>
#include <QDir> #include <QDir>
#include <QFileInfo> #include <QFileInfo>
#include <QMessageBox> #include <QMessageBox>
#include <QProcess>
#include <QTemporaryFile>
using namespace Utils; using namespace Utils;
@@ -61,28 +65,37 @@ namespace Internal {
// //
/////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////
static QByteArray coreName(const DebuggerStartParameters &sp)
{
QFileInfo fi(sp.coreFile);
return fi.absoluteFilePath().toLocal8Bit();
}
CoreGdbAdapter::CoreGdbAdapter(GdbEngine *engine) CoreGdbAdapter::CoreGdbAdapter(GdbEngine *engine)
: AbstractGdbAdapter(engine), : AbstractGdbAdapter(engine)
m_executable(startParameters().executable),
m_coreName(coreName(startParameters()))
{} {}
CoreGdbAdapter::~CoreGdbAdapter()
{
if (false && !m_tempCoreName.isEmpty()) {
QFile tmpFile(m_tempCoreName);
tmpFile.remove();
}
}
void CoreGdbAdapter::startAdapter() void CoreGdbAdapter::startAdapter()
{ {
QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state()); QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state());
showMessage(_("TRYING TO START ADAPTER")); showMessage(_("TRYING TO START ADAPTER"));
const DebuggerStartParameters &sp = startParameters();
m_executable = sp.executable;
QFileInfo fi(sp.coreFile);
m_coreName = fi.absoluteFilePath();
unpackCoreIfNeeded();
}
void CoreGdbAdapter::continueAdapterStart()
{
if (m_executable.isEmpty()) { if (m_executable.isEmpty()) {
// Read executable from core. // Read executable from core.
ElfReader reader(m_coreName); ElfReader reader(coreFileName());
QByteArray data = reader.readSection("note0"); m_executable = reader.readCoreName();
m_executable = QByteArray(data.data() + 0x40);
// Strip off command line arguments. FIXME: make robust. // Strip off command line arguments. FIXME: make robust.
int idx = m_executable.indexOf(QLatin1Char(' ')); int idx = m_executable.indexOf(QLatin1Char(' '));
@@ -128,14 +141,15 @@ void CoreGdbAdapter::setupInferior()
void CoreGdbAdapter::handleFileExecAndSymbols(const GdbResponse &response) void CoreGdbAdapter::handleFileExecAndSymbols(const GdbResponse &response)
{ {
QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state()); QTC_ASSERT(state() == InferiorSetupRequested, qDebug() << state());
QString core = coreFileName();
if (response.resultClass == GdbResultDone) { if (response.resultClass == GdbResultDone) {
showMessage(tr("Symbols found."), StatusBar); showMessage(tr("Symbols found."), StatusBar);
m_engine->postCommand("target core " + m_coreName, m_engine->postCommand("target core " + core.toLocal8Bit(),
CB(handleTargetCore)); CB(handleTargetCore));
return; return;
} }
QString msg = tr("No symbols found in core file <i>%1</i>.") QString msg = tr("No symbols found in core file <i>%1</i>.")
.arg(startParameters().coreFile); .arg(core);
msg += _(" "); msg += _(" ");
msg += tr("This can be caused by a path length limitation in the " msg += tr("This can be caused by a path length limitation in the "
"core file."); "core file.");
@@ -195,15 +209,35 @@ void CoreGdbAdapter::interruptInferior()
QTC_CHECK(false); QTC_CHECK(false);
} }
void CoreGdbAdapter::shutdownInferior()
{
m_engine->notifyInferiorShutdownOk();
}
void CoreGdbAdapter::shutdownAdapter() void CoreGdbAdapter::shutdownAdapter()
{ {
m_engine->notifyAdapterShutdownOk(); m_engine->notifyAdapterShutdownOk();
} }
void CoreGdbAdapter::unpackCoreIfNeeded()
{
if (!m_coreName.endsWith(QLatin1String(".lzo"))) {
continueAdapterStart();
return;
}
{
QString pattern = QDir::tempPath() + QLatin1String("/tmpcore-XXXXXX");
QTemporaryFile tmp(pattern, this);
tmp.open();
m_tempCoreName = tmp.fileName();
}
QProcess *process = new QProcess(this);
process->setWorkingDirectory(QDir::tempPath());
process->start("/usr/bin/lzop", QStringList() << "-o" << m_tempCoreName << "-x" << m_coreName);
connect(process, SIGNAL(finished(int)), SLOT(continueAdapterStart()));
}
QString CoreGdbAdapter::coreFileName() const
{
return m_tempCoreName.isEmpty() ? m_coreName : m_tempCoreName;
}
} // namespace Internal } // namespace Internal
} // namespace Debugger } // namespace Debugger

11
src/plugins/debugger/gdb/coregdbadapter.h
View File

@@ -51,6 +51,7 @@ class CoreGdbAdapter : public AbstractGdbAdapter
public: public:
explicit CoreGdbAdapter(GdbEngine *engine); explicit CoreGdbAdapter(GdbEngine *engine);
~CoreGdbAdapter();
private: private:
DumperHandling dumperHandling() const { return DumperNotAvailable; } DumperHandling dumperHandling() const { return DumperNotAvailable; }
@@ -61,7 +62,6 @@ private:
void setupInferior(); void setupInferior();
void runEngine(); void runEngine();
void interruptInferior(); void interruptInferior();
void shutdownInferior();
void shutdownAdapter(); void shutdownAdapter();
Q_SLOT void loadSymbolsForStack(); Q_SLOT void loadSymbolsForStack();
@@ -69,15 +69,18 @@ private:
AbstractGdbProcess *gdbProc() { return &m_gdbProc; } AbstractGdbProcess *gdbProc() { return &m_gdbProc; }
//void handleTemporaryDetach(const GdbResponse &response);
//void handleTemporaryTargetCore(const GdbResponse &response);
void handleFileExecAndSymbols(const GdbResponse &response); void handleFileExecAndSymbols(const GdbResponse &response);
void handleTargetCore(const GdbResponse &response); void handleTargetCore(const GdbResponse &response);
void handleModulesList(const GdbResponse &response); void handleModulesList(const GdbResponse &response);
void unpackCoreIfNeeded();
QString coreFileName() const;
Q_SLOT void continueAdapterStart();
QString coreName() const;
QString m_executable; QString m_executable;
const QByteArray m_coreName; QString m_coreName;
LocalGdbProcess m_gdbProc; LocalGdbProcess m_gdbProc;
QString m_tempCoreName;
}; };
} // namespace Internal } // namespace Internal

16
src/plugins/debugger/gdb/gdbengine.cpp
View File

@@ -3518,7 +3518,7 @@ void GdbEngine::examineModules()
{ {
ModulesHandler *handler = modulesHandler(); ModulesHandler *handler = modulesHandler();
foreach (Module module, handler->modules()) { foreach (Module module, handler->modules()) {
if (module.sections.symbolsType == UnknownSymbols) if (module.elfData.symbolsType == UnknownSymbols)
handler->updateModule(module); handler->updateModule(module);
} }
} }
@@ -5364,7 +5364,7 @@ void GdbEngine::checkForReleaseBuild()
{ {
QString binary = startParameters().executable; QString binary = startParameters().executable;
ElfReader reader(binary); ElfReader reader(binary);
ElfHeaders sections = reader.readHeaders(); ElfData elfData = reader.readHeaders();
QString error = reader.errorString(); QString error = reader.errorString();
showMessage(_("EXAMINING ") + binary); showMessage(_("EXAMINING ") + binary);
@@ -5385,11 +5385,11 @@ void GdbEngine::checkForReleaseBuild()
} }
QSet<QByteArray> seen; QSet<QByteArray> seen;
foreach (const ElfHeader &section, sections.headers) { foreach (const ElfSectionHeader &header, elfData.sectionHeaders) {
msg.append(section.name); msg.append(header.name);
msg.append(' '); msg.append(' ');
if (interesting.contains(section.name)) if (interesting.contains(header.name))
seen.insert(section.name); seen.insert(header.name);
} }
showMessage(_(msg)); showMessage(_(msg));
@@ -5398,12 +5398,12 @@ void GdbEngine::checkForReleaseBuild()
return; return;
} }
if (sections.headers.isEmpty()) { if (elfData.sectionHeaders.isEmpty()) {
showMessage(_("NO SECTION HEADERS FOUND. IS THIS AN EXECUTABLE?")); showMessage(_("NO SECTION HEADERS FOUND. IS THIS AN EXECUTABLE?"));
return; return;
} }
if (sections.indexOf(".debug_info") >= 0) if (elfData.indexOf(".debug_info") >= 0)
return; return;
QString warning; QString warning;

28
src/plugins/debugger/moduleshandler.cpp
View File

@@ -113,6 +113,14 @@ QVariant ModulesModel::data(const QModelIndex &index, int role) const
case 1: case 1:
if (role == Qt::DisplayRole) if (role == Qt::DisplayRole)
return module.modulePath; return module.modulePath;
if (role == Qt::ToolTipRole) {
QString msg;
if (!module.elfData.buildId.isEmpty())
msg += QString::fromLatin1("Build Id: " + module.elfData.buildId);
if (!module.elfData.debugLink.isEmpty())
msg += QString::fromLatin1("Debug Link: " + module.elfData.debugLink);
return msg;
}
break; break;
case 2: case 2:
if (role == Qt::DisplayRole) if (role == Qt::DisplayRole)
@@ -124,7 +132,7 @@ QVariant ModulesModel::data(const QModelIndex &index, int role) const
break; break;
case 3: case 3:
if (role == Qt::DisplayRole) if (role == Qt::DisplayRole)
switch (module.sections.symbolsType) { switch (module.elfData.symbolsType) {
case UnknownSymbols: case UnknownSymbols:
return ModulesHandler::tr("unknown"); return ModulesHandler::tr("unknown");
case NoSymbols: case NoSymbols:
@@ -133,11 +141,13 @@ QVariant ModulesModel::data(const QModelIndex &index, int role) const
return ModulesHandler::tr("plain"); return ModulesHandler::tr("plain");
case FastSymbols: case FastSymbols:
return ModulesHandler::tr("fast"); return ModulesHandler::tr("fast");
case SeparateSymbols: case LinkedSymbols:
return ModulesHandler::tr("separate"); return ModulesHandler::tr("debuglnk");
case BuildIdSymbols:
return ModulesHandler::tr("buildid");
} }
else if (role == Qt::ToolTipRole) else if (role == Qt::ToolTipRole)
switch (module.sections.symbolsType) { switch (module.elfData.symbolsType) {
case UnknownSymbols: case UnknownSymbols:
return ModulesHandler::tr( return ModulesHandler::tr(
"It is unknown whether this module contains debug " "It is unknown whether this module contains debug "
@@ -158,7 +168,8 @@ QVariant ModulesModel::data(const QModelIndex &index, int role) const
"This module contains debug information.\nStepping " "This module contains debug information.\nStepping "
"into the module or setting breakpoints by file and " "into the module or setting breakpoints by file and "
"is expected to work."); "is expected to work.");
case SeparateSymbols: case LinkedSymbols:
case BuildIdSymbols:
return ModulesHandler::tr( return ModulesHandler::tr(
"This module does not contains debug information " "This module does not contains debug information "
"itself, but contains a reference to external " "itself, but contains a reference to external "
@@ -220,16 +231,17 @@ void ModulesModel::updateModule(const Module &module)
{ {
const int row = indexOfModule(module.modulePath); const int row = indexOfModule(module.modulePath);
ElfReader reader(module.modulePath); ElfReader reader(module.modulePath);
ElfHeaders sections = reader.readHeaders(); ElfData elfData = reader.readHeaders();
if (row == -1) { if (row == -1) {
const int n = m_modules.size(); const int n = m_modules.size();
beginInsertRows(QModelIndex(), n, n); beginInsertRows(QModelIndex(), n, n);
m_modules.push_back(module); m_modules.push_back(module);
m_modules.back().sections = sections; m_modules.back().elfData = elfData;
endInsertRows(); endInsertRows();
} else { } else {
m_modules[row] = module; m_modules[row] = module;
m_modules[row].sections = sections; m_modules[row].elfData = elfData;
dataChanged(index(row, 0, QModelIndex()), index(row, 4, QModelIndex())); dataChanged(index(row, 0, QModelIndex()), index(row, 4, QModelIndex()));
} }
} }

2
src/plugins/debugger/moduleshandler.h
View File

@@ -90,7 +90,7 @@ public:
quint64 startAddress; quint64 startAddress;
quint64 endAddress; quint64 endAddress;
Utils::ElfHeaders sections; Utils::ElfData elfData;
}; };
typedef QVector<Module> Modules; typedef QVector<Module> Modules;