debugger: rework core adapter

The name of the binary is now read using the elfreader instead
of attaching gdb twice.

Change-Id: I7a75bc64278c4f43e7085d2e479b53173602c966
Reviewed-by: hjk <qthjk@ovi.com>

12 files changed, 172 insertions, 191 deletions

diff --git a/share/qtcreator/dumper/dumper.py b/share/qtcreator/dumper/dumper.py
index 3c8f3ab575..cace9693f5 100644
--- a/share/qtcreator/dumper/dumper.py
+++ b/share/qtcreator/dumper/dumper.py
@@ -1667,14 +1667,14 @@ class Dumper:
                 return
 
             # Is this derived from QObject?
-            try:
-                # If this access fails, it's not a QObject.
-                d = value["d_ptr"]["d"]
-                privateType = lookupType(self.ns + "QObjectPrivate").pointer()
-                objectName = d.cast(privateType).dereference()["objectName"]
-                self.putStringValue(objectName, 1)
-            except:
-                pass
+            #try:
+            #    # If this access fails, it's not a QObject.
+            #    d = value["d_ptr"]["d"]
+            #    privateType = lookupType(self.ns + "QObjectPrivate").pointer()
+            #    objectName = d.cast(privateType).dereference()["objectName"]
+            #    self.putStringValue(objectName, 1)
+            #except:
+            #    pass
 
         #warn("GENERIC STRUCT: %s" % type)
         #warn("INAME: %s " % self.currentIName)
diff --git a/src/libs/utils/elfreader.cpp b/src/libs/utils/elfreader.cpp
index 6ac1f5f77f..1bf20b81a9 100644
--- a/src/libs/utils/elfreader.cpp
+++ b/src/libs/utils/elfreader.cpp
@@ -48,28 +48,71 @@
 
 namespace Utils {
 
-
 typedef quint16  qelfhalf_t;
 typedef quint32  qelfword_t;
 typedef quintptr qelfoff_t;
 typedef quintptr qelfaddr_t;
 
-class ElfSectionHeader
+class RawElfSectionHeader
 {
 public:
     qelfword_t name;
     qelfword_t type;
+    qelfoff_t  data;
     qelfoff_t  offset;
     qelfoff_t  size;
 };
 
+class ElfMapper
+{
+public:
+    ElfMapper(const ElfReader *reader) : file(reader->m_binary) {}
+
+    bool map()
+    {
+        if (!file.open(QIODevice::ReadOnly))
+            return false;
+
+        fdlen = file.size();
+        start = file.map(0, fdlen);
+        if (start == 0) {
+            // Try reading the data into memory instead.
+            raw = file.readAll();
+            start = (uchar *)raw.constData();
+            fdlen = raw.size();
+        }
+        return true;
+    }
+
+public:
+    QFile file;
+    QByteArray raw;
+    uchar *start;
+    quint64 fdlen;
+};
+
 template <typename T>
-T read(const char *s, ElfReader::ElfEndian endian)
+T get(const unsigned char *s, ElfReader::ElfEndian endian)
 {
     if (endian == ElfReader::ElfBigEndian)
-        return qFromBigEndian<T>(reinterpret_cast<const uchar *>(s));
+        return qFromBigEndian<T>(s);
     else
-        return qFromLittleEndian<T>(reinterpret_cast<const uchar *>(s));
+        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)
@@ -77,31 +120,29 @@ ElfReader::ElfReader(const QString &binary)
 {
 }
 
-const char *ElfReader::parseSectionHeader(const char *data, ElfSectionHeader *sh)
+ElfHeaders ElfReader::readHeaders()
 {
-    sh->name = read<qelfword_t>(data, m_endian);
-    data += sizeof(qelfword_t); // sh_name
-    sh->type = read<qelfword_t>(data, m_endian);
-    data += sizeof(qelfword_t)  // sh_type
-         + sizeof(qelfaddr_t)   // sh_flags
-         + sizeof(qelfaddr_t);  // sh_addr
-    sh->offset = read<qelfoff_t>(data, m_endian);
-    data += sizeof(qelfoff_t);  // sh_offset
-    sh->size = read<qelfoff_t>(data, m_endian);
-    data += sizeof(qelfoff_t);  // sh_size
-    return data;
+    if (m_headers.isEmpty())
+        readIt();
+    return m_headers;
 }
 
-ElfReader::Result ElfReader::parse(const char *dataStart, quint64 fdlen,
-    ElfSections *sections)
+ElfReader::Result ElfReader::readIt()
 {
+    ElfMapper mapper(this);
+    if (!mapper.map())
+        return Corrupt;
+
+    const quint64 fdlen = mapper.fdlen;
+
     if (fdlen < 64) {
         m_errorString = QLibrary::tr("'%1' is not an ELF object (%2)")
             .arg(m_binary).arg(QLatin1String("file too small"));
         return NotElf;
     }
-    const char *data = dataStart;
-    if (strncmp(data, "\177ELF", 4) != 0) {
+
+    const uchar *data = mapper.start;
+    if (strncmp((const char *)data, "\177ELF", 4) != 0) {
         m_errorString = QLibrary::tr("'%1' is not an ELF object")
                 .arg(m_binary);
         return NotElf;
@@ -141,11 +182,11 @@ ElfReader::Result ElfReader::parse(const char *dataStart, quint64 fdlen,
          +  sizeof(qelfaddr_t)  // e_entry
          +  sizeof(qelfoff_t);  // e_phoff
 
-    qelfoff_t e_shoff = read<qelfoff_t>(data, m_endian);
+    qelfoff_t e_shoff = get<qelfoff_t>(data, m_endian);
     data += sizeof(qelfoff_t)    // e_shoff
          +  sizeof(qelfword_t);  // e_flags
 
-    qelfhalf_t e_shsize = read<qelfhalf_t>(data, m_endian);
+    qelfhalf_t e_shsize = get<qelfhalf_t>(data, m_endian);
 
     if (e_shsize > fdlen) {
         m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)")
@@ -157,7 +198,7 @@ ElfReader::Result ElfReader::parse(const char *dataStart, quint64 fdlen,
          +  sizeof(qelfhalf_t)  // e_phentsize
          +  sizeof(qelfhalf_t); // e_phnum
 
-    qelfhalf_t e_shentsize = read<qelfhalf_t>(data, m_endian);
+    qelfhalf_t e_shentsize = get<qelfhalf_t>(data, m_endian);
 
     if (e_shentsize % 4) {
         m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)")
@@ -165,9 +206,9 @@ ElfReader::Result ElfReader::parse(const char *dataStart, quint64 fdlen,
         return Corrupt;
     }
     data += sizeof(qelfhalf_t); // e_shentsize
-    qelfhalf_t e_shnum     = read<qelfhalf_t>(data, m_endian);
+    qelfhalf_t e_shnum     = get<qelfhalf_t>(data, m_endian);
     data += sizeof(qelfhalf_t); // e_shnum
-    qelfhalf_t e_shtrndx   = read<qelfhalf_t>(data, m_endian);
+    qelfhalf_t e_shtrndx   = get<qelfhalf_t>(data, m_endian);
     data += sizeof(qelfhalf_t); // e_shtrndx
 
     if (quint32(e_shnum * e_shentsize) > fdlen) {
@@ -178,7 +219,7 @@ ElfReader::Result ElfReader::parse(const char *dataStart, quint64 fdlen,
         return Corrupt;
     }
 
-    ElfSectionHeader strtab;
+    RawElfSectionHeader strtab;
     qulonglong soff = e_shoff + e_shentsize * (e_shtrndx);
 
     if ((soff + e_shentsize) > fdlen || soff % 4 || soff == 0) {
@@ -189,7 +230,7 @@ ElfReader::Result ElfReader::parse(const char *dataStart, quint64 fdlen,
         return Corrupt;
     }
 
-    parseSectionHeader(dataStart + soff, &strtab);
+    parseSectionHeader(mapper.start + soff, &strtab, m_endian);
     const int stringTableFileOffset = strtab.offset;
 
     if (quint32(stringTableFileOffset + e_shentsize) >= fdlen
@@ -201,15 +242,14 @@ ElfReader::Result ElfReader::parse(const char *dataStart, quint64 fdlen,
         return Corrupt;
     }
 
-    const char *s = dataStart + e_shoff;
+    const uchar *s = mapper.start + e_shoff;
     for (int i = 0; i < e_shnum; ++i) {
-        ElfSectionHeader sh;
-        parseSectionHeader(s, &sh);
+        RawElfSectionHeader sh;
+        parseSectionHeader(s, &sh, m_endian);
         if (sh.name == 0) {
             s += e_shentsize;
             continue;
         }
-        const char *shnam = dataStart + stringTableFileOffset + sh.name;
 
         if (stringTableFileOffset + sh.name > fdlen) {
             m_errorString = QLibrary::tr("'%1' is an invalid ELF object (%2)")
@@ -219,49 +259,50 @@ ElfReader::Result ElfReader::parse(const char *dataStart, quint64 fdlen,
             return Corrupt;
         }
 
-        if (sections) {
-            ElfSection section;
-            section.name = shnam;
-            section.index = strtab.name;
-            section.offset = strtab.offset;
-            section.size = strtab.size;
-            if (section.name == ".gdb_index")
-                sections->symbolsType = FastSymbols;
-            else if (section.name == ".debug_info")
-                sections->symbolsType = PlainSymbols;
-            else if (section.name == ".gnu_debuglink")
-                sections->symbolsType = SeparateSymbols;
-            sections->sections.append(section);
-        }
+        ElfHeader section;
+        section.name = ((const char *)mapper.start) + stringTableFileOffset + sh.name;
+        section.index = sh.name;
+        section.offset = sh.offset;
+        section.size = sh.size;
+        section.data = sh.data;
+        if (section.name == ".gdb_index")
+            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.append(section);
 
         s += e_shentsize;
     }
     return Ok;
 }
 
-ElfSections ElfReader::sections()
+QByteArray ElfReader::readSection(const QByteArray &name)
 {
-    ElfSections names;
+    QByteArray contents;
+    if (m_headers.isEmpty())
+        readIt();
+    int i = m_headers.indexOf(name);
+    if (i == -1)
+        return contents;
 
-    QFile file(m_binary);
-    if (!file.open(QIODevice::ReadOnly)) {
-        m_errorString = file.errorString();
-        return names;
-    }
+    ElfMapper mapper(this);
+    if (!mapper.map())
+        return contents;
 
-    QByteArray data;
-    const char *filedata = 0;
-    quint64 fdlen = file.size();
-    filedata = (char *) file.map(0, fdlen);
-    if (filedata == 0) {
-        // Try reading the data into memory instead.
-        data = file.readAll();
-        filedata = data.constData();
-        fdlen = data.size();
-    }
+    const ElfHeader &section = m_headers.at(i);
 
-    parse(filedata, fdlen, &names);
-    return names;
+    contents = QByteArray((const char *)mapper.start + section.offset, section.size);
+    return contents;
+}
+
+int ElfHeaders::indexOf(const QByteArray &name) const
+{
+    for (int i = 0, n = size(); i != n; ++i)
+        if (at(i).name == name)
+            return i;
+    return -1;
 }
 
 } // namespace Utils
diff --git a/src/libs/utils/elfreader.h b/src/libs/utils/elfreader.h
index 21810222f4..21378a7e26 100644
--- a/src/libs/utils/elfreader.h
+++ b/src/libs/utils/elfreader.h
@@ -53,9 +53,6 @@
 
 namespace Utils {
 
-class ElfSectionHeader;
-class ElfSections;
-
 enum DebugSymbolsType
 {
     UnknownSymbols,    // Unknown.
@@ -65,7 +62,7 @@ enum DebugSymbolsType
     FastSymbols        // Dwarf index available.
 };
 
-class QTCREATOR_UTILS_EXPORT ElfSection
+class QTCREATOR_UTILS_EXPORT ElfHeader
 {
 public:
     QByteArray name;
@@ -73,35 +70,38 @@ public:
     quint32 type;
     quint64 offset;
     quint64 size;
+    quint64 data;
+};
+
+class QTCREATOR_UTILS_EXPORT ElfHeaders : public QList<ElfHeader>
+{
+public:
+    ElfHeaders() : symbolsType(UnknownSymbols) {}
+    int indexOf(const QByteArray &name) const;
+
+public:
+    DebugSymbolsType symbolsType;
 };
 
 class QTCREATOR_UTILS_EXPORT ElfReader
 {
 public:
     explicit ElfReader(const QString &binary);
+    enum Result { Ok, NotElf, Corrupt };
 
     enum ElfEndian { ElfLittleEndian = 0, ElfBigEndian = 1 };
-    ElfSections sections();
+    ElfHeaders readHeaders();
+    QByteArray readSection(const QByteArray &sectionName);
     QString errorString() const { return m_errorString; }
 
 private:
-    enum Result { Ok, NotElf, Corrupt };
-
-    const char *parseSectionHeader(const char *s, ElfSectionHeader *sh);
-    Result parse(const char *dataStart, quint64 fdlen, ElfSections *sections);
+    friend class ElfMapper;
+    Result readIt();
 
     QString m_binary;
     QString m_errorString;
     ElfEndian m_endian;
-};
-
-class QTCREATOR_UTILS_EXPORT ElfSections
-{
-public:
-    ElfSections() : symbolsType(UnknownSymbols) {}
-
-    QList<ElfSection> sections;
-    DebugSymbolsType symbolsType;
+    ElfHeaders m_headers;
 };
 
 } // namespace Utils
diff --git a/src/plugins/debugger/gdb/codagdbadapter.cpp b/src/plugins/debugger/gdb/codagdbadapter.cpp
index 8c07bdee7b..5c2e5674d2 100644
--- a/src/plugins/debugger/gdb/codagdbadapter.cpp
+++ b/src/plugins/debugger/gdb/codagdbadapter.cpp
@@ -403,7 +403,7 @@ void CodaGdbAdapter::codaDeviceError(const QString  &errorString)
 {
     logMessage(errorString);
     if (state() == EngineSetupRequested) {
-        m_engine->handleAdapterStartFailed(errorString, QString());
+        m_engine->handleAdapterStartFailed(errorString);
     } else {
         m_engine->handleAdapterCrashed(errorString);
     }
@@ -1072,7 +1072,7 @@ void CodaGdbAdapter::startAdapter()
             const QString msg = QString::fromLatin1("Could not open serial device '%1': %2")
                                 .arg(parameters.remoteChannel, reason);
             logMessage(msg, LogError);
-            m_engine->handleAdapterStartFailed(msg, QString());
+            m_engine->handleAdapterStartFailed(msg);
             return;
         }
         setupDeviceSignals();
@@ -1104,7 +1104,7 @@ void CodaGdbAdapter::startAdapter()
         QString msg = QString::fromLatin1("Unable to start the gdb server at %1: %2.")
             .arg(m_gdbServerName).arg(m_gdbServer->errorString());
         logMessage(msg, LogError);
-        m_engine->handleAdapterStartFailed(msg, QString());
+        m_engine->handleAdapterStartFailed(msg);
         return;
     }
 
diff --git a/src/plugins/debugger/gdb/coregdbadapter.cpp b/src/plugins/debugger/gdb/coregdbadapter.cpp
index 9826332725..28849732e4 100644
--- a/src/plugins/debugger/gdb/coregdbadapter.cpp
+++ b/src/plugins/debugger/gdb/coregdbadapter.cpp
@@ -40,11 +40,14 @@
 #include "gdbengine.h"
 
 #include <utils/qtcassert.h>
+#include <utils/elfreader.h>
 
 #include <QDir>
 #include <QFileInfo>
 #include <QMessageBox>
 
+using namespace Utils;
+
 namespace Debugger {
 namespace Internal {
 
@@ -75,10 +78,25 @@ void CoreGdbAdapter::startAdapter()
     QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state());
     showMessage(_("TRYING TO START ADAPTER"));
 
-    QStringList args;
-    args.append(_("-ex"));
-    args.append(_("set auto-solib-add off"));
-    m_engine->startGdb(args);
+    if (m_executable.isEmpty()) {
+        // Read executable from core.
+        ElfReader reader(m_coreName);
+        QByteArray data = reader.readSection("note0");
+        m_executable = QByteArray(data.data() + 0x40);
+
+        // Strip off command line arguments. FIXME: make robust.
+        int idx = m_executable.indexOf(QLatin1Char(' '));
+        if (idx >= 0)
+            m_executable.truncate(idx);
+        if (m_executable.isEmpty()) {
+            showMessageBox(QMessageBox::Warning,
+                tr("Error Loading Symbols"),
+                tr("No executable to load symbols from specified."));
+            m_engine->notifyEngineSetupFailed();
+            return;
+        }
+    }
+    m_engine->startGdb();
 }
 
 void CoreGdbAdapter::handleGdbStartFailed()
@@ -87,82 +105,7 @@ void CoreGdbAdapter::handleGdbStartFailed()
 
 void CoreGdbAdapter::handleGdbStartDone()
 {
-    //if (m_executable.isEmpty()) {
-    //    showMessageBox(QMessageBox::Warning,
-    //        tr("Error Loading Symbols"),
-    //        tr("No executable to load symbols from specified."));
-    //}
-
-#ifdef Q_OS_LINUX
-    const bool canUseExeFromCore = true;
-#else
-    const bool canUseExeFromCore = false;
-#endif
-
-    if (!m_executable.isEmpty()) {
-        m_engine->notifyEngineSetupOk();
-    } else if (canUseExeFromCore) {
-        // Extra round trip to get executable name from core file.
-        // This is sometimes not the full name, so it can't be used
-        // as the generic solution.
-
-        // Quoting core name below fails in gdb 6.8-debian.
-        m_engine->postCommand("target core " + m_coreName,
-            CB(handleTemporaryTargetCore));
-    } else {
-        QString msg = tr("The name of the binary file cannot be extracted "
-            "from this core file.");
-        msg += _(" ");
-        msg += tr("Try to specify the binary using the "
-            "<i>Debug->Start Debugging->Attach to Core</i> dialog.");
-        showMessageBox(QMessageBox::Warning,
-            tr("Loading core file failed"), msg);
-        m_engine->notifyEngineSetupFailed();
-    }
-}
-
-void CoreGdbAdapter::handleTemporaryTargetCore(const GdbResponse &response)
-{
-    QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state());
-    if (response.resultClass != GdbResultDone) {
-        showMessage(tr("Attach to core failed."), StatusBar);
-        m_engine->notifyEngineSetupFailed();
-        return;
-    }
-
-    QByteArray console = response.consoleStreamOutput;
-    int pos1 = console.indexOf('`');
-    int pos2 = console.indexOf('\'');
-    if (pos1 == -1 || pos2 == -1) {
-        showMessage(tr("Attach to core failed."), StatusBar);
-        m_engine->notifyEngineSetupFailed();
-        return;
-    }
-
-    m_executable = QLatin1String(console.mid(pos1 + 1, pos2 - pos1 - 1));
-    // Strip off command line arguments. FIXME: make robust.
-    int idx = m_executable.indexOf(QLatin1Char(' '));
-    if (idx >= 0)
-        m_executable.truncate(idx);
-    if (m_executable.isEmpty()) {
-        m_engine->postCommand("detach");
-        m_engine->notifyEngineSetupFailed();
-        return;
-    }
-    m_executable = QFileInfo(startParameters().coreFile).absoluteDir()
-                   .absoluteFilePath(m_executable);
-    showMessage(tr("Attached to core temporarily."), StatusBar);
-    m_engine->postCommand("detach", CB(handleTemporaryDetach));
-}
-
-void CoreGdbAdapter::handleTemporaryDetach(const GdbResponse &response)
-{
-    QTC_ASSERT(state() == EngineSetupRequested, qDebug() << state());
-    if (response.resultClass == GdbResultDone) {
-        m_engine->notifyEngineSetupOk();
-    } else {
-        m_engine->notifyEngineSetupFailed();
-    }
+    m_engine->handleAdapterStarted();
 }
 
 void CoreGdbAdapter::setupInferior()
diff --git a/src/plugins/debugger/gdb/coregdbadapter.h b/src/plugins/debugger/gdb/coregdbadapter.h
index d2df00a84e..3aaa47e72d 100644
--- a/src/plugins/debugger/gdb/coregdbadapter.h
+++ b/src/plugins/debugger/gdb/coregdbadapter.h
@@ -69,8 +69,8 @@ private:
 
     AbstractGdbProcess *gdbProc() { return &m_gdbProc; }
 
-    void handleTemporaryDetach(const GdbResponse &response);
-    void handleTemporaryTargetCore(const GdbResponse &response);
+    //void handleTemporaryDetach(const GdbResponse &response);
+    //void handleTemporaryTargetCore(const GdbResponse &response);
     void handleFileExecAndSymbols(const GdbResponse &response);
     void handleTargetCore(const GdbResponse &response);
     void handleModulesList(const GdbResponse &response);
diff --git a/src/plugins/debugger/gdb/gdbengine.cpp b/src/plugins/debugger/gdb/gdbengine.cpp
index d127e1f78a..f50a2a6aaa 100644
--- a/src/plugins/debugger/gdb/gdbengine.cpp
+++ b/src/plugins/debugger/gdb/gdbengine.cpp
@@ -4747,7 +4747,7 @@ bool checkGdbConfiguration(const DebuggerStartParameters &sp, ConfigurationCheck
 // Starting up & shutting down
 //
 
-void GdbEngine::startGdb(const QStringList &args, const QString &settingsIdHint)
+void GdbEngine::startGdb(const QStringList &args)
 {
     const QByteArray tests = qgetenv("QTC_DEBUGGER_TESTS");
     foreach (const QByteArray &test, tests.split(','))
@@ -4788,7 +4788,7 @@ void GdbEngine::startGdb(const QStringList &args, const QString &settingsIdHint)
     if (!gdbProc()->waitForStarted()) {
         m_gdbAdapter->handleGdbStartFailed();
         const QString msg = errorMessage(QProcess::FailedToStart);
-        handleAdapterStartFailed(msg, settingsIdHint);
+        handleAdapterStartFailed(msg);
         return;
     }
 
@@ -5364,7 +5364,7 @@ void GdbEngine::checkForReleaseBuild()
 {
     QString binary = startParameters().executable;
     ElfReader reader(binary);
-    ElfSections sections = reader.sections();
+    ElfHeaders sections = reader.readHeaders();
     QString error = reader.errorString();
 
     showMessage(_("EXAMINING ") + binary);
@@ -5385,7 +5385,7 @@ void GdbEngine::checkForReleaseBuild()
     }
 
     QSet<QByteArray> seen;
-    foreach (const ElfSection &section, sections.sections) {
+    foreach (const ElfHeader &section, sections) {
         msg.append(section.name);
         msg.append(' ');
         if (interesting.contains(section.name))
@@ -5398,15 +5398,13 @@ void GdbEngine::checkForReleaseBuild()
         return;
     }
 
-    if (sections.sections.isEmpty()) {
+    if (sections.isEmpty()) {
         showMessage(_("NO SECTION HEADERS FOUND. IS THIS AN EXECUTABLE?"));
         return;
     }
 
-    foreach (const ElfSection &section, sections.sections) {
-        if (section.name == ".debug_info")
-            return;
-    }
+    if (sections.indexOf(".debug_info") >= 0)
+        return;
 
     QString warning;
     warning = tr("This does not seem to be a \"Debug\" build.\n"
diff --git a/src/plugins/debugger/gdb/gdbengine.h b/src/plugins/debugger/gdb/gdbengine.h
index 1bbfb1708f..038734f8ed 100644
--- a/src/plugins/debugger/gdb/gdbengine.h
+++ b/src/plugins/debugger/gdb/gdbengine.h
@@ -249,8 +249,7 @@ private: ////////// General State //////////
 private: ////////// Gdb Process Management //////////
 
     AbstractGdbAdapter *createAdapter();
-    void startGdb(const QStringList &args = QStringList(),
-                  const QString &settingsIdHint = QString());
+    void startGdb(const QStringList &args = QStringList());
     void handleGdbStart(const GdbResponse &response);
     void handleInferiorShutdown(const GdbResponse &response);
     void handleGdbExit(const GdbResponse &response);
diff --git a/src/plugins/debugger/gdb/localplaingdbadapter.cpp b/src/plugins/debugger/gdb/localplaingdbadapter.cpp
index c494f3ac64..04dcf3df76 100644
--- a/src/plugins/debugger/gdb/localplaingdbadapter.cpp
+++ b/src/plugins/debugger/gdb/localplaingdbadapter.cpp
@@ -83,7 +83,7 @@ void LocalPlainGdbAdapter::startAdapter()
 
     if (!m_outputCollector.listen()) {
         m_engine->handleAdapterStartFailed(tr("Cannot set up communication with child process: %1")
-                .arg(m_outputCollector.errorString()), QString());
+                .arg(m_outputCollector.errorString()));
         return;
     }
     gdbArgs.append(_("--tty=") + m_outputCollector.serverName());
diff --git a/src/plugins/debugger/gdb/termgdbadapter.cpp b/src/plugins/debugger/gdb/termgdbadapter.cpp
index 0d60863d27..dd5a570ecb 100644
--- a/src/plugins/debugger/gdb/termgdbadapter.cpp
+++ b/src/plugins/debugger/gdb/termgdbadapter.cpp
@@ -115,7 +115,7 @@ void TermGdbAdapter::startAdapter()
     if (!m_stubProc.start(startParameters().executable,
                          startParameters().processArgs)) {
         // Error message for user is delivered via a signal.
-        m_engine->handleAdapterStartFailed(QString(), QString());
+        m_engine->handleAdapterStartFailed(QString());
         return;
     }
 
diff --git a/src/plugins/debugger/moduleshandler.cpp b/src/plugins/debugger/moduleshandler.cpp
index fce0f406bd..794472b1e9 100644
--- a/src/plugins/debugger/moduleshandler.cpp
+++ b/src/plugins/debugger/moduleshandler.cpp
@@ -220,7 +220,7 @@ void ModulesModel::updateModule(const Module &module)
 {
     const int row = indexOfModule(module.modulePath);
     ElfReader reader(module.modulePath);
-    ElfSections sections = reader.sections();
+    ElfHeaders sections = reader.readHeaders();
     if (row == -1) {
         const int n = m_modules.size();
         beginInsertRows(QModelIndex(), n, n);
diff --git a/src/plugins/debugger/moduleshandler.h b/src/plugins/debugger/moduleshandler.h
index 7b064a9958..029fa5673a 100644
--- a/src/plugins/debugger/moduleshandler.h
+++ b/src/plugins/debugger/moduleshandler.h
@@ -90,7 +90,7 @@ public:
     quint64 startAddress;
     quint64 endAddress;
 
-    Utils::ElfSections sections;
+    Utils::ElfHeaders sections;
 };
 
 typedef QVector<Module> Modules;