qv4debugger.h - mozsearch

Enable keyboard shortcuts

// Copyright (C) 2016 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:significant

#ifndef QV4DEBUGGER_H

#define QV4DEBUGGER_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "qv4datacollector.h"

#include <private/qv4debugging_p.h>

#include <private/qv4function_p.h>

#include <private/qv4context_p.h>

#include <private/qv4persistent_p.h>

#include <private/qv4executablecompilationunit_p.h>

#include <private/qqmlrefcount_p.h>

#include <QtCore/qmutex.h>

#include <QtCore/qwaitcondition.h>

QT_BEGIN_NAMESPACE

class QV4DebugJob;

class QV4DataCollector;

class QV4Debugger : public QV4::Debugging::Debugger

    Q_OBJECT

public:

    struct BreakPoint {

        BreakPoint(const QString &fileName, int line);

        QString fileName;

        int lineNumber;

};

    enum State {

        Running,

        Paused

};

    enum Speed {

        FullThrottle = 0,

        StepOut,

        StepOver,

        StepIn,

        NotStepping = FullThrottle

};

    enum PauseReason {

        PauseRequest,

        BreakPointHit,

        Throwing,

        Step

};

    QV4Debugger(QV4::ExecutionEngine *engine);

    QV4::ExecutionEngine *engine() const;

    const QV4DataCollector *collector() const;

    QV4DataCollector *collector();

    void pause();

    void resume(Speed speed);

    State state() const;

    void addBreakPoint(const QString &fileName, int lineNumber,

                       const QString &condition = QString());

    void removeBreakPoint(const QString &fileName, int lineNumber);

    void setBreakOnThrow(bool onoff);

    void clearPauseRequest();

    // used for testing

    struct ExecutionState

        QString fileName;

        int lineNumber;

};

    ExecutionState currentExecutionState() const;

    qsizetype executableLinesCacheSize();

    QList<QV4::StackFrame> stackTrace(int frameLimit = -1) const;

    QList<QV4::Heap::ExecutionContext::ContextType> getScopeTypes(int frame = 0) const;

    QV4::Function *getFunction() const;

    void runInEngine(QV4DebugJob *job);

    int resolvedBreakpointLine(int requestedLine);

    // compile-time interface

    void maybeBreakAtInstruction() override;

    // execution hooks

    void enteringFunction() override;

    void leavingFunction(const QV4::ReturnedValue &retVal) override;

    void aboutToThrow() override;

    bool pauseAtNextOpportunity() const override;

Q_SIGNALS:

    void debuggerPaused(QV4Debugger *self, QV4Debugger::PauseReason reason);

    void scheduleJob();

private:

    // requires lock to be held

    void pauseAndWait(PauseReason reason);

    bool reallyHitTheBreakPoint(QV4::Function *function, const QString &filename, int linenr);

    struct ExecutableLine {

        int line;

        int functionStart; // first line of the function or binding it belongs to

        friend bool operator==(const ExecutableLine &a, const ExecutableLine &b)

            return a.line == b.line && a.functionStart == b.functionStart;

        friend bool operator<(const ExecutableLine &a, const ExecutableLine &b)

            return a.line < b.line || (a.line == b.line && a.functionStart < b.functionStart);

};

    struct ExecutableLines {

        QList<ExecutableLine> lines; // the lines that carry code, sorted

        QList<int> functionStarts;   // sorted

};

    static ExecutableLines collectExecutableLines(

            const QQmlRefPointer<QV4::CompiledData::CompilationUnit> &unit);

    static int firstLineAtOrAfter(const ExecutableLines &executable, int requestedLine);

    const ExecutableLines &executableLines(QV4::Function *function);

    void pruneExecutableLines();

    void runInEngine_havingLock(QV4DebugJob *job);

    void runJobUnpaused();

    QV4::ExecutionEngine *m_engine;

    QV4::CppStackFrame *m_currentFrame = 0;

    QMutex m_lock;

    QWaitCondition m_runningCondition;

    State m_state;

    Speed m_stepping;

    bool m_pauseRequested;

    bool m_haveBreakPoints;

    bool m_breakPointsChanged = false;

    bool m_breakOnThrow;

    struct BreakPointData {

        QString target; // as given by the client, possibly with a path

        QString condition;

};

    QHash<BreakPoint, BreakPointData> m_breakPoints;

    struct UnitLines {

        // Keeps another unit from reusing the address while it is cached. This is

        // the base unit: pinning the executable unit would keep the engine from

        // trimming it, so a reloaded ES module could come back stale. The type

        // loader still keeps the type of a pinned unit, so units are only

        // cached while their file has breakpoints.

        QQmlRefPointer<QV4::CompiledData::CompilationUnit> unit;

        ExecutableLines lines;

};

    QList<UnitLines> m_executableLines; // most recently used first

    QV4::PersistentValue m_returnedValue;

    QV4DebugJob *m_gatherSources;

    QV4DebugJob *m_runningJob;

    QV4DataCollector m_collector;

    QWaitCondition m_jobIsRunning;

};

QT_END_NAMESPACE

Q_DECLARE_METATYPE(QV4Debugger::PauseReason)

Q_DECLARE_METATYPE(QV4Debugger*)

#endif // QV4DEBUGGER_H