add code navigation in disassembly view

lievenhey · lievenhey · commit c15dc71fe2b2 · 2022-01-26T15:26:33.000+01:00
this patch makes it possible to jump to another line / function by
clicking on a line like call test or jne test+0x5c
diff --git a/src/models/CMakeLists.txt b/src/models/CMakeLists.txt
@@ -17,6 +17,7 @@ add_library(models STATIC
     ../util.cpp
     callercalleeproxy.cpp
     frequencymodel.cpp
+    disassemblydelegate.cpp
 )
 
 target_link_libraries(models
diff --git a/src/models/disassemblydelegate.cpp b/src/models/disassemblydelegate.cpp
@@ -0,0 +1,38 @@
+/*
+    SPDX-FileCopyrightText: Lieven Hey <lieven.hey@kdab.com>
+    SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#include "disassemblydelegate.h"
+
+#include <QEvent>
+#include <QMouseEvent>
+
+#include "disassemblymodel.h"
+
+DisassemblyDelegate::DisassemblyDelegate(QObject* parent)
+    : QItemDelegate(parent)
+{
+}
+
+DisassemblyDelegate::~DisassemblyDelegate() = default;
+
+bool DisassemblyDelegate::editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& /*option*/,
+                                      const QModelIndex& index)
+{
+    if (event->type() != QMouseEvent::MouseButtonPress)
+        return false;
+
+    const QString functionName =
+        model->data(model->index(index.row(), DisassemblyModel::LinkedFunctionName), Qt::DisplayRole).toString();
+    if (functionName.isEmpty())
+        return false;
+
+    int funtionOffset =
+        model->data(model->index(index.row(), DisassemblyModel::LinkedFunctionOffset), Qt::DisplayRole).toInt();
+    emit gotoFunction(functionName, funtionOffset);
+
+    return true;
+}
diff --git a/src/models/disassemblydelegate.h b/src/models/disassemblydelegate.h
@@ -0,0 +1,24 @@
+/*
+    SPDX-FileCopyrightText: Lieven Hey <lieven.hey@kdab.com>
+    SPDX-FileCopyrightText: 2022 Klarälvdalens Datakonsult AB, a KDAB Group company, info@kdab.com
+
+    SPDX-License-Identifier: GPL-2.0-or-later
+*/
+
+#pragma once
+
+#include <QItemDelegate>
+
+class DisassemblyDelegate : public QItemDelegate
+{
+    Q_OBJECT
+public:
+    DisassemblyDelegate(QObject* parent = nullptr);
+    ~DisassemblyDelegate();
+
+    bool editorEvent(QEvent* event, QAbstractItemModel* model, const QStyleOptionViewItem& option,
+                     const QModelIndex& index) override;
+
+signals:
+    void gotoFunction(const QString& function, int offset);
+};
diff --git a/src/models/disassemblymodel.cpp b/src/models/disassemblymodel.cpp
@@ -22,6 +22,20 @@ void DisassemblyModel::clear()
     endResetModel();
 }
 
+QModelIndex DisassemblyModel::findIndexWithOffset(int offset)
+{
+    quint64 address = m_data.disassemblyLines[0].addr + offset;
+
+    const auto& found =
+        std::find_if(m_data.disassemblyLines.begin(), m_data.disassemblyLines.end(),
+                     [address](const DisassemblyOutput::DisassemblyLine& line) { return line.addr == address; });
+
+    if (found != m_data.disassemblyLines.end()) {
+        return index(std::distance(m_data.disassemblyLines.begin(), found), 0);
+    }
+    return {};
+}
+
 void DisassemblyModel::setDisassembly(const DisassemblyOutput& disassemblyOutput)
 {
     beginResetModel();
@@ -47,6 +61,14 @@ QVariant DisassemblyModel::headerData(int section, Qt::Orientation orientation,
     if (section == DisassemblyColumn)
         return tr("Assembly");
 
+    if (section == LinkedFunctionName) {
+        return tr("Linked Function Name");
+    }
+
+    if (section == LinkedFunctionOffset) {
+        return tr("Linked Function Offset");
+    }
+
     if (section - COLUMN_COUNT <= m_numTypes)
         return m_results.selfCosts.typeName(section - COLUMN_COUNT);
 
@@ -67,6 +89,12 @@ QVariant DisassemblyModel::data(const QModelIndex& index, int role) const
         if (index.column() == DisassemblyColumn)
             return data.disassembly;
 
+        if (index.column() == LinkedFunctionName)
+            return data.linkedFunctionName;
+
+        if (index.column() == LinkedFunctionOffset)
+            return data.linkedFunctionOffset;
+
         if (data.addr == 0) {
             return {};
         }
diff --git a/src/models/disassemblymodel.h b/src/models/disassemblymodel.h
@@ -23,6 +23,7 @@ class DisassemblyModel : public QAbstractTableModel
     void setResults(const Data::CallerCalleeResults& results);
 
     void clear();
+    QModelIndex findIndexWithOffset(int offset);
 
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     int columnCount(const QModelIndex &parent = QModelIndex()) const override;
@@ -33,6 +34,8 @@ class DisassemblyModel : public QAbstractTableModel
     enum Columns
     {
         DisassemblyColumn,
+        LinkedFunctionName,
+        LinkedFunctionOffset,
         COLUMN_COUNT
     };
 
diff --git a/src/models/disassemblyoutput.cpp b/src/models/disassemblyoutput.cpp
@@ -14,6 +14,39 @@
 #include <QRegularExpression>
 #include <QStandardPaths>
 
+namespace {
+DisassemblyOutput::LinkedFunction extractLinkedFunction(const QString& disassembly)
+{
+    DisassemblyOutput::LinkedFunction function = {};
+
+    const auto leftBracketIndex = disassembly.indexOf(QLatin1Char('<'));
+    const auto rightBracketIndex = disassembly.indexOf(QLatin1Char('>'));
+    if (leftBracketIndex != -1 && rightBracketIndex != -1) {
+        if (leftBracketIndex < rightBracketIndex) {
+            function.name = disassembly.mid(leftBracketIndex + 1, rightBracketIndex - leftBracketIndex - 1);
+
+            const auto atindex = function.name.indexOf(QLatin1Char('@'));
+            if (atindex > 0) {
+                function.name = function.name.left(atindex);
+            }
+
+            const auto plusIndex = function.name.indexOf(QLatin1Char('+'));
+            if (plusIndex > 0) {
+                bool ok;
+                // ignore 0x in offset
+                const auto& offsetStr = function.name.mid(plusIndex + 3);
+                function.name = function.name.left(plusIndex);
+                auto offset = offsetStr.toInt(&ok, 16);
+                if (ok) {
+                    function.offset = offset;
+                }
+            }
+        }
+    }
+    return function;
+}
+}
+
 static QVector<DisassemblyOutput::DisassemblyLine> objdumpParse(const QByteArray &output)
 {
     QVector<DisassemblyOutput::DisassemblyLine> disassemblyLines;
@@ -22,7 +55,7 @@ static QVector<DisassemblyOutput::DisassemblyLine> objdumpParse(const QByteArray
     QString asmLine;
     // detect lines like:
     // 4f616: 84 c0 test %al,%al
-    static const QRegularExpression disassemblyRegex(QStringLiteral("^    ([0-9a-f]{4,}):\t[0-9a-f ]{2,}"));
+    static const QRegularExpression disassemblyRegex(QStringLiteral("^[ ]+([0-9a-f]{4,}):\t[0-9a-f ]{2,}"));
     while (stream.readLineInto(&asmLine))
     {
         if (asmLine.isEmpty() || asmLine.startsWith(QLatin1String("Disassembly")))
@@ -51,7 +84,7 @@ static QVector<DisassemblyOutput::DisassemblyLine> objdumpParse(const QByteArray
             }
         }
 
-        disassemblyLines.push_back({addr, asmLine});
+        disassemblyLines.push_back({addr, asmLine, extractLinkedFunction(asmLine)});
     }
     return disassemblyLines;
 }
@@ -85,6 +118,7 @@ DisassemblyOutput DisassemblyOutput::disassemble(const QString& objdump, const Q
     auto toHex = [](quint64 addr) -> QString { return QLatin1String("0x") + QString::number(addr, 16); };
     const auto arguments = QStringList {QStringLiteral("-d"),
                                         QStringLiteral("-S"),
+                                        QStringLiteral("-C"),
                                         QStringLiteral("--start-address"),
                                         toHex(symbol.relAddr),
                                         QStringLiteral("--stop-address"),
diff --git a/src/models/disassemblyoutput.h b/src/models/disassemblyoutput.h
@@ -13,10 +13,17 @@
 
 struct DisassemblyOutput
 {
+    struct LinkedFunction
+    {
+        QString name;
+        int offset = 0; // offset from the entrypoint of the function
+    };
+
     struct DisassemblyLine
     {
         quint64 addr = 0;
         QString disassembly;
+        LinkedFunction linkedFunction;
     };
     QVector<DisassemblyLine> disassemblyLines;
 
diff --git a/src/resultsdisassemblypage.cpp b/src/resultsdisassemblypage.cpp
@@ -31,19 +31,39 @@
 
 #include "data.h"
 #include "models/costdelegate.h"
+#include "models/disassemblydelegate.h"
+#include "models/disassemblymodel.h"
 #include "models/hashmodel.h"
 #include "models/topproxy.h"
 #include "models/treemodel.h"
-#include "models/disassemblymodel.h"
 
 ResultsDisassemblyPage::ResultsDisassemblyPage(QWidget* parent)
     : QWidget(parent)
     , ui(new Ui::ResultsDisassemblyPage)
     , m_model(new DisassemblyModel(this))
     , m_costDelegate(new CostDelegate(DisassemblyModel::CostRole, DisassemblyModel::TotalCostRole, this))
+    , m_disassemblyDelegate(new DisassemblyDelegate(this))
 {
     ui->setupUi(this);
     ui->asmView->setModel(m_model);
+
+    connect(m_disassemblyDelegate, &DisassemblyDelegate::gotoFunction, this,
+            [this](const QString& functionName, int offset) {
+                if (m_curSymbol.symbol == functionName) {
+                    ui->asmView->scrollTo(m_model->findIndexWithOffset(offset),
+                                          QAbstractItemView::ScrollHint::PositionAtTop);
+                } else {
+                    const auto symbol = std::find_if(
+                        m_callerCalleeResults.entries.keyBegin(), m_callerCalleeResults.entries.keyEnd(),
+                        [functionName](const Data::Symbol& symbol) { return symbol.symbol == functionName; });
+
+                    if (symbol != m_callerCalleeResults.entries.keyEnd()) {
+                        setSymbol(*symbol);
+                        showDisassembly();
+                        emit jumpToCallerCallee(*symbol);
+                    }
+                }
+            });
 }
 
 ResultsDisassemblyPage::~ResultsDisassemblyPage() = default;
@@ -57,6 +77,9 @@ void ResultsDisassemblyPage::setupAsmViewModel()
 {
     ui->asmView->header()->setStretchLastSection(false);
     ui->asmView->header()->setSectionResizeMode(0, QHeaderView::Stretch);
+    ui->asmView->hideColumn(DisassemblyModel::LinkedFunctionName);
+    ui->asmView->hideColumn(DisassemblyModel::LinkedFunctionOffset);
+    ui->asmView->setItemDelegateForColumn(0, m_disassemblyDelegate);
     for (int col = 1; col < m_model->columnCount(); col++) {
         ui->asmView->setColumnWidth(col, 100);
         ui->asmView->header()->setSectionResizeMode(col, QHeaderView::Interactive);
diff --git a/src/resultsdisassemblypage.h b/src/resultsdisassemblypage.h
@@ -28,6 +28,7 @@ class QTreeView;
 class QStandardItemModel;
 class QTemporaryFile;
 class CostDelegate;
+class DisassemblyDelegate;
 struct DisassemblyOutput;
 class DisassemblyModel;
 
@@ -65,4 +66,5 @@ class ResultsDisassemblyPage : public QWidget
     Data::CallerCalleeResults m_callerCalleeResults;
     // Cost delegate
     CostDelegate* m_costDelegate;
+    DisassemblyDelegate* m_disassemblyDelegate;
 };

Original file line number	Diff line number	Diff line change
`@@ -17,6 +17,7 @@ add_library(models STATIC`
`17`	`17`	`../util.cpp`
`18`	`18`	`callercalleeproxy.cpp`
`19`	`19`	`frequencymodel.cpp`
	`20`	`+ disassemblydelegate.cpp`
`20`	`21`	`)`
`21`	`22`
`22`	`23`	`target_link_libraries(models`