forked from qt-creator/qt-creator
9f9c72302f
- Use the TreeItem/data pattern recently introduced with Breakpoints to remove the need of keeping track of id/object mapping. Opens possibility to have thread groups as intermediate level. - Use the ThreadHandler directly as model for the thread combobox to remove the need of manual combo box updates. - Move setting current thread from individual engines to central code. Change-Id: I030e21a4aa5ab30b0efbc84528d9cecf29cbbe30 Reviewed-by: David Schulz <david.schulz@qt.io>
414 lines
12 KiB
C++
414 lines
12 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 "threadshandler.h"
|
|
|
|
#include "debuggeractions.h"
|
|
#include "debuggercore.h"
|
|
#include "debuggerengine.h"
|
|
#include "debuggericons.h"
|
|
#include "debuggerprotocol.h"
|
|
#include "watchutils.h"
|
|
|
|
#include <utils/algorithm.h>
|
|
#include <utils/basetreeview.h>
|
|
#include <utils/qtcassert.h>
|
|
#include <utils/savedaction.h>
|
|
|
|
#include <QCoreApplication>
|
|
#include <QDebug>
|
|
#include <QIcon>
|
|
#include <QMenu>
|
|
|
|
using namespace Utils;
|
|
|
|
namespace Debugger {
|
|
namespace Internal {
|
|
|
|
////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// ThreadItem
|
|
//
|
|
///////////////////////////////////////////////////////////////////////
|
|
|
|
// ThreadItem
|
|
|
|
ThreadItem::ThreadItem(const ThreadsHandler *handler, const ThreadData &data)
|
|
: threadData(data), handler(handler)
|
|
{}
|
|
|
|
QVariant ThreadItem::data(int column, int role) const
|
|
{
|
|
switch (role) {
|
|
case Qt::DisplayRole:
|
|
if (column == 0)
|
|
return QString("#%1 %2").arg(threadData.id).arg(threadData.name);
|
|
return threadPart(column);
|
|
case Qt::ToolTipRole:
|
|
return threadToolTip();
|
|
case Qt::DecorationRole:
|
|
// Return icon that indicates whether this is the active stack frame.
|
|
if (column == 0)
|
|
return this == handler->currentThread() ? Icons::LOCATION.icon()
|
|
: Icons::EMPTY.icon();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
Qt::ItemFlags ThreadItem::flags(int column) const
|
|
{
|
|
return threadData.stopped ? TreeItem::flags(column) : Qt::ItemFlags({});
|
|
}
|
|
|
|
QString ThreadItem::threadToolTip() const
|
|
{
|
|
const char start[] = "<tr><td>";
|
|
const char sep[] = "</td><td>";
|
|
const char end[] = "</td>";
|
|
QString rc;
|
|
QTextStream str(&rc);
|
|
str << "<html><head/><body><table>"
|
|
<< start << ThreadsHandler::tr("Thread id:")
|
|
<< sep << threadData.id << end;
|
|
if (!threadData.targetId.isEmpty())
|
|
str << start << ThreadsHandler::tr("Target id:")
|
|
<< sep << threadData.targetId << end;
|
|
if (!threadData.groupId.isEmpty())
|
|
str << start << ThreadsHandler::tr("Group id:")
|
|
<< sep << threadData.groupId << end;
|
|
if (!threadData.name.isEmpty())
|
|
str << start << ThreadsHandler::tr("Name:")
|
|
<< sep << threadData.name << end;
|
|
if (!threadData.state.isEmpty())
|
|
str << start << ThreadsHandler::tr("State:")
|
|
<< sep << threadData.state << end;
|
|
if (!threadData.core.isEmpty())
|
|
str << start << ThreadsHandler::tr("Core:")
|
|
<< sep << threadData.core << end;
|
|
if (threadData.address) {
|
|
str << start << ThreadsHandler::tr("Stopped at:") << sep;
|
|
if (!threadData.function.isEmpty())
|
|
str << threadData.function << "<br>";
|
|
if (!threadData.fileName.isEmpty())
|
|
str << threadData.fileName << ':' << threadData.lineNumber << "<br>";
|
|
str << formatToolTipAddress(threadData.address);
|
|
}
|
|
str << "</table></body></html>";
|
|
return rc;
|
|
}
|
|
|
|
QVariant ThreadItem::threadPart(int column) const
|
|
{
|
|
switch (column) {
|
|
case ThreadData::IdColumn:
|
|
return threadData.id;
|
|
case ThreadData::FunctionColumn:
|
|
return threadData.function;
|
|
case ThreadData::FileColumn:
|
|
return threadData.fileName.isEmpty() ? threadData.module : threadData.fileName;
|
|
case ThreadData::LineColumn:
|
|
return threadData.lineNumber >= 0
|
|
? QString::number(threadData.lineNumber) : QString();
|
|
case ThreadData::AddressColumn:
|
|
return threadData.address > 0
|
|
? QLatin1String("0x") + QString::number(threadData.address, 16)
|
|
: QString();
|
|
case ThreadData::CoreColumn:
|
|
return threadData.core;
|
|
case ThreadData::StateColumn:
|
|
return threadData.state;
|
|
case ThreadData::TargetIdColumn:
|
|
if (threadData.targetId.startsWith(QLatin1String("Thread ")))
|
|
return threadData.targetId.mid(7);
|
|
return threadData.targetId;
|
|
case ThreadData::NameColumn:
|
|
return threadData.name;
|
|
case ThreadData::DetailsColumn:
|
|
return threadData.details;
|
|
case ThreadData::ComboNameColumn:
|
|
return QString::fromLatin1("#%1 %2").arg(threadData.id).arg(threadData.name);
|
|
}
|
|
return QVariant();
|
|
}
|
|
|
|
void ThreadItem::notifyRunning() // Clear state information.
|
|
{
|
|
threadData.address = 0;
|
|
threadData.function.clear();
|
|
threadData.fileName.clear();
|
|
threadData.frameLevel = -1;
|
|
threadData.state.clear();
|
|
threadData.lineNumber = -1;
|
|
threadData.stopped = false;
|
|
update();
|
|
}
|
|
|
|
void ThreadItem::notifyStopped()
|
|
{
|
|
threadData.stopped = true;
|
|
update();
|
|
}
|
|
|
|
void ThreadItem::mergeThreadData(const ThreadData &other)
|
|
{
|
|
if (!other.core.isEmpty())
|
|
threadData.core = other.core;
|
|
if (!other.fileName.isEmpty())
|
|
threadData.fileName = other.fileName;
|
|
if (!other.targetId.isEmpty())
|
|
threadData.targetId = other.targetId;
|
|
if (!other.name.isEmpty())
|
|
threadData.name = other.name;
|
|
if (other.frameLevel != -1)
|
|
threadData.frameLevel = other.frameLevel;
|
|
if (!other.function.isEmpty())
|
|
threadData.function = other.function;
|
|
if (other.address)
|
|
threadData.address = other.address;
|
|
if (!other.module.isEmpty())
|
|
threadData.module = other.module;
|
|
if (!other.details.isEmpty())
|
|
threadData.details = other.details;
|
|
if (!other.state.isEmpty())
|
|
threadData.state = other.state;
|
|
if (other.lineNumber != -1)
|
|
threadData.lineNumber = other.lineNumber;
|
|
update();
|
|
}
|
|
|
|
|
|
// ThreadsHandler
|
|
|
|
/*!
|
|
\class Debugger::Internal::ThreadData
|
|
\internal
|
|
\brief The ThreadData class contains information
|
|
about a single thread.
|
|
*/
|
|
|
|
/*!
|
|
\class Debugger::Internal::ThreadsHandler
|
|
\internal
|
|
\brief The ThreadsHandler class provides a model to
|
|
represent the running threads in a QTreeView or ComboBox.
|
|
*/
|
|
|
|
ThreadsHandler::ThreadsHandler(DebuggerEngine *engine)
|
|
: m_engine(engine)
|
|
{
|
|
setObjectName(QLatin1String("ThreadsModel"));
|
|
setHeader({
|
|
QLatin1String(" ") + tr("ID") + QLatin1String(" "),
|
|
tr("Address"), tr("Function"), tr("File"), tr("Line"), tr("State"),
|
|
tr("Name"), tr("Target ID"), tr("Details"), tr("Core"),
|
|
});
|
|
}
|
|
|
|
bool ThreadsHandler::setData(const QModelIndex &idx, const QVariant &data, int role)
|
|
{
|
|
if (role == BaseTreeView::ItemActivatedRole) {
|
|
const Thread thread = itemForIndexAtLevel<1>(idx);
|
|
m_engine->selectThread(thread);
|
|
return true;
|
|
}
|
|
|
|
if (role == BaseTreeView::ItemViewEventRole) {
|
|
ItemViewEvent ev = data.value<ItemViewEvent>();
|
|
|
|
if (ev.as<QContextMenuEvent>()) {
|
|
auto menu = new QMenu;
|
|
menu->addAction(action(SettingsDialog));
|
|
menu->popup(ev.globalPos());
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
int ThreadsHandler::currentThreadIndex() const
|
|
{
|
|
return rootItem()->indexOf(m_currentThread);
|
|
}
|
|
|
|
void ThreadsHandler::sort(int column, Qt::SortOrder order)
|
|
{
|
|
rootItem()->sortChildren([order, column](const ThreadItem *item1, const ThreadItem *item2) -> bool {
|
|
const QVariant v1 = item1->threadPart(column);
|
|
const QVariant v2 = item2->threadPart(column);
|
|
if (v1 == v2)
|
|
return false;
|
|
if (column == 0)
|
|
return (v1.toInt() < v2.toInt()) ^ (order == Qt::DescendingOrder);
|
|
// FIXME: Use correct toXXX();
|
|
return (v1.toString() < v2.toString()) ^ (order == Qt::DescendingOrder);
|
|
});
|
|
}
|
|
|
|
Thread ThreadsHandler::currentThread() const
|
|
{
|
|
return m_currentThread;
|
|
}
|
|
|
|
Thread ThreadsHandler::threadAt(int index) const
|
|
{
|
|
QTC_ASSERT(index >= 0 && index < rootItem()->childCount(), return Thread());
|
|
return rootItem()->childAt(index);
|
|
}
|
|
|
|
void ThreadsHandler::setCurrentThread(const Thread &thread)
|
|
{
|
|
if (thread == m_currentThread)
|
|
return;
|
|
|
|
if (!threadForId(thread->id())) {
|
|
qWarning("ThreadsHandler::setCurrentThreadId: No such thread %s.", qPrintable(thread->id()));
|
|
return;
|
|
}
|
|
|
|
m_currentThread = thread;
|
|
thread->update();
|
|
}
|
|
|
|
QString ThreadsHandler::pidForGroupId(const QString &groupId) const
|
|
{
|
|
return m_pidForGroupId[groupId];
|
|
}
|
|
|
|
void ThreadsHandler::notifyGroupCreated(const QString &groupId, const QString &pid)
|
|
{
|
|
m_pidForGroupId[groupId] = pid;
|
|
}
|
|
|
|
void ThreadsHandler::updateThread(const ThreadData &threadData)
|
|
{
|
|
if (Thread thread = threadForId(threadData.id))
|
|
thread->mergeThreadData(threadData);
|
|
else
|
|
rootItem()->appendChild(new ThreadItem(this, threadData));
|
|
}
|
|
|
|
void ThreadsHandler::removeThread(const QString &id)
|
|
{
|
|
if (Thread thread = threadForId(id))
|
|
destroyItem(thread);
|
|
}
|
|
|
|
void ThreadsHandler::removeAll()
|
|
{
|
|
rootItem()->removeChildren();
|
|
}
|
|
|
|
bool ThreadsHandler::notifyGroupExited(const QString &groupId)
|
|
{
|
|
QList<ThreadItem *> list;
|
|
forItemsAtLevel<1>([&list, groupId](ThreadItem *item) {
|
|
if (item->threadData.groupId == groupId)
|
|
list.append(item);
|
|
});
|
|
foreach (ThreadItem *item, list)
|
|
destroyItem(item);
|
|
|
|
m_pidForGroupId.remove(groupId);
|
|
return m_pidForGroupId.isEmpty();
|
|
}
|
|
|
|
Thread ThreadsHandler::threadForId(const QString &id) const
|
|
{
|
|
return findItemAtLevel<1>([id](const Thread &item) {
|
|
return item->threadData.id == id;
|
|
});
|
|
}
|
|
|
|
void ThreadsHandler::notifyRunning(const QString &id)
|
|
{
|
|
if (id.isEmpty() || id == "all")
|
|
forItemsAtLevel<1>([](const Thread &thread) { thread->notifyRunning(); });
|
|
else if (Thread thread = threadForId(id))
|
|
thread->notifyRunning();
|
|
}
|
|
|
|
void ThreadsHandler::notifyStopped(const QString &id)
|
|
{
|
|
if (id.isEmpty() || id == "all")
|
|
forItemsAtLevel<1>([](const Thread &thread) { thread->notifyStopped(); });
|
|
else if (Thread thread = threadForId(id))
|
|
thread->notifyStopped();
|
|
}
|
|
|
|
void ThreadsHandler::updateThreads(const GdbMi &data)
|
|
{
|
|
// ^done,threads=[{id="1",target-id="Thread 0xb7fdc710 (LWP 4264)",
|
|
// frame={level="0",addr="0x080530bf",func="testQString",args=[],
|
|
// file="/.../app.cpp",fullname="/../app.cpp",line="1175"},
|
|
// state="stopped",core="0"}],current-thread-id="1"
|
|
|
|
const QVector<GdbMi> &items = data["threads"].children();
|
|
for (const GdbMi &item : items) {
|
|
const GdbMi &frame = item["frame"];
|
|
ThreadData thread;
|
|
thread.id = item["id"].data();
|
|
thread.targetId = item["target-id"].data();
|
|
thread.details = item["details"].data();
|
|
thread.core = item["core"].data();
|
|
thread.state = item["state"].data();
|
|
thread.address = frame["addr"].toAddress();
|
|
thread.function = frame["func"].data();
|
|
thread.fileName = frame["fullname"].data();
|
|
thread.lineNumber = frame["line"].toInt();
|
|
thread.module = frame["from"].data();
|
|
thread.name = item["name"].data();
|
|
thread.stopped = thread.state != "running";
|
|
updateThread(thread);
|
|
}
|
|
|
|
const QString ¤tId = data["current-thread-id"].data();
|
|
m_currentThread = threadForId(currentId);
|
|
}
|
|
|
|
void ThreadsHandler::scheduleResetLocation()
|
|
{
|
|
m_resetLocationScheduled = true;
|
|
}
|
|
|
|
void ThreadsHandler::resetLocation()
|
|
{
|
|
if (m_resetLocationScheduled) {
|
|
m_resetLocationScheduled = false;
|
|
layoutChanged();
|
|
}
|
|
}
|
|
|
|
QAbstractItemModel *ThreadsHandler::model()
|
|
{
|
|
return this;
|
|
}
|
|
|
|
} // namespace Internal
|
|
} // namespace Debugger
|