GDBFrontend ist ein einfacher, flexibler und erweiterbarer GUI-Debugger.

Installation

Voraussetzungen

• GDB => 8.2 (mit Python3)
• Python3 => 3.6
• tmux

PIP-Paket (Python Wheel) [Empfohlen]

Sie können GDBFrontend mit pip installieren.

sudo python3 -m pip install gdbfrontend

Wenn es bereits installiert ist und Sie ein Upgrade durchführen:

sudo python3 -m pip install --upgrade gdbfrontend

Oder wenn Sie einen bestimmten GIT-Snapshot installieren möchten:

sudo python3 setup.py install

Und Sie können es ausführen:

gdbfrontend

Ausführen aus GIT

Sie können den neuesten Quellcode herunterladen und ausführen.

Sie können gdb-frontend mit den folgenden Befehlen ausführen:

git clone https://github.com/rohanrhu/gdb-frontend.git gdb-frontend
cd gdb-frontend
./gdbfrontend

Und Sie können es öffnen mit:

http://127.0.0.1:5550/

Sie können die GDB-Shell mit dem Befehl öffnen:

tmux a -t gdb-frontend

Arch Linux (AUR)

Sie können das Arch-Linux-Paket für Arch-basierte Distributionen installieren. (AUR-Paket)

yay -S gdb-frontend-bin

Und Sie können es ausführen:

gdbfrontend

Flatpak

Das Flatpak-Paket ist noch TODO.

Debuggen von Dockerisierten C/C++-Apps mit GDBFrontend

Folgen Sie diesem Tutorial, um zu erfahren, wie Sie Dockerisierte C/C++-Apps mit GDBFrontend debuggen.

Eingebettetes Debuggen mit GDBFrontend

Folgen Sie diesem kurzen Tutorial zum Debuggen eingebetteter Geräte mit GDBFrontend.

Debuggen von Python-C-Erweiterungen mit GDBFrontend

Folgen Sie diesem kurzen Tutorial zum Debuggen nativer C-Python-Erweiterungen mit GDBFrontend.

Wie entwickle ich GDBFrontend-Plugins?

GDBFrontend bietet leistungsstarke und erweiterbare APIs. Folgen Sie diesem kurzen Tutorial, um die Entwicklung von GDBFrontend-Plugins zu erlernen.

Wie integriere ich GDBFrontend in mein Makefile?

Folgen Sie diesem kurzen Tutorial für Integrationsideen für spezielle Entwicklungs-/Debugging-Anforderungen.

STM32-Debugging mit OpenOCD, GDB & GDBFrontend unter Linux

Folgen Sie diesem Tutorial zum Debuggen von STM32 mit OpenOCD und GDBFrontend.

Funktionen

Ausdrucks-Evaluator

GDBFrontend hat einen Ausdrucks-Evaluator, den Sie gleichzeitig mehrfach verwenden können.

Zeiger-Visualisierung

Verkettete-Listen-Visualisierung

Bedingte Haltepunkte

Klicken Sie mit der rechten Maustaste auf einen Haltepunkt, um seine Bedingung festzulegen.

Verbundene Ausdrücke

Ausdrücke aller Variablen, Member und Elemente sind im VariablesExplorer von GDBFrontend verbunden.

Prozessmanager

Sie können Prozesse mit dem Prozessmanager überwachen, filtern oder verwalten.

Array-Graph-Visualisierung

Erweiterte Zusammenarbeit

GDBFrontend bietet eine Reihe von Funktionen für die Zusammenarbeit, die als "Erweiterte Zusammenarbeit" bezeichnet werden.

Zusammenarbeits-Zeichnung

Die Zusammenarbeits-Zeichnung ist verfügbar, wenn Sie die Erweiterte Zusammenarbeit aktivieren. Klicken Sie auf Zeichnen oder verwenden Sie die Tastenkombination Strg + Umschalt + X zum Zeichnen und Strg + Umschalt + C zum Löschen aller Zeichnungen.

Synchronisierte Quellansicht

Mit der Erweiterten Zusammenarbeit werden alle Debugger-Clients bei der Quellansicht synchronisiert.

Ausdrucks-Hover-Popup-Variablen-Explorer

Erweiterbarkeit

GDBFrontend ist sehr erweiterbar und bietet leistungsstarke APIs. Einige Beispiele für die Erweiterbarkeit von GDBFrontend.

./gdbfrontend

$ gdbfrontend --help
GDBFrontend is a easy, flexible and extensionable gui debugger.

Options:
  --help, -h:                                   Shows this help message.
  --version, -v:                                Shows version.
  --gdb-args="ARGS", -G "ARGS":                 Specifies GDB command line arguments. (Optional)
  --gdb-executable=PATH, -g PATH:               Specifies GDB executable path (Default is "gdb" command on PATH environment variable.)
  --tmux-executable=PATH, -tmux PATH:           Specifies Tmux executable path (Default is "tmux" command on PATH environment variable.)
  --terminal-id=NAME, -t NAME:                  Specifies tmux terminal identifier name (Default is "gdb-frontend".)
  --credentials=USER:PASS, -c USER:PASS:        Specifies username and password for accessing to debugger.
  --host=IP, -H IP:                             Specifies current host address that you can access via for HTTP and WS servers.
  --listen=IP, -l IP:                           Specifies listen address for HTTP and WS servers.
  --port=PORT, -p PORT:                         Specifies HTTP port. (0 for random port.)
  --url-base=PATH, -u PATH:                     Specifies URL base path. (Default: /)
  --readonly, -r:                               Makes code editor readonly. (Notice: This option is not related to security.)
  --workdir, -w:                                Specifies working directory.
  --plugin-dir, -P:                             Specifies plugins directory.
  --dontopenuionstartup, -D:                    Avoids opening UI just after startup.
  --verbose, -V:                                Enables verbose output.

Optionen

--help, -h

Zeigt den Hilfetext an.

--version, -v

Zeigt die Version an.

--gdb-args="ARGS", -G "ARGS"

Gibt GDB-Kommandozeilenargumente an. (Optional)

--gdb-executable=PATH, -g PATH

Sie können den GDB-Ausführungspfad angeben, z. B. gdbfrontend --gdb-executable=/pfad/zu/gdb. (Optional)

--tmux-executable=PATH, -tmux PATH

Sie können den Tmux-Ausführungspfad angeben, z. B. gdbfrontend --tmux-executable=/pfad/zu/tmux. (Optional)

--terminal-id=PATH, -t PATH

Sie können die Tmux-Terminal-ID angeben, z. B. gdbfrontend --terminal-id=terminal-name. (Standard: gdb-frontend)

--credentials=USER:PASS, -c USER:PASS

Gibt Benutzername und Passwort für den Zugriff auf den Debugger an.

--host=IP, -H IP

Gibt die aktuelle Host-Adresse an, über die Sie auf HTTP- und WS-Server zugreifen können.

--listen=IP, -l IP

Gibt die Lauschadresse für HTTP- und WS-Server an.

--port=PORT, -p PORT

Gibt den HTTP-Port an. (0 für einen zufälligen Port.)

--url-base=PATH, -u PATH

Gibt den URL-Basispfad an. (Standard: /)

--readonly, -r

Macht den Code-Editor schreibgeschützt. (Hinweis: Diese Option hat nichts mit Sicherheit zu tun.)

--workdir, -w

Gibt das Arbeitsverzeichnis an.

--plugin-dir, -P

Gibt das Plugin-Verzeichnis an.

--dontopenuionstartup, -D

Verhindert das Öffnen der Benutzeroberfläche direkt nach dem Start.

--verbose, -V

Aktiviert die ausführliche Ausgabe.

GDB-Befehle

Die GDB-Befehle von GDBFrontend beginnen mit gf-.

gf-refresh

Aktualisiert alle Browser-Clients.

gf-theme [theme-name]

Wechselt zum gewünschten Thema. Zum Beispiel: gf-theme light, gf-theme red oder gf-theme default für das Standard-Thema.

gf-list-plugins

Listet alle GDBFrontend-Plugins im Plugin-Verzeichnis auf.

gf-load-plugin [plugin-name]

Lädt ein GDBFrontend-Plugin.

gf-unload-plugin [plugin-name]

Entlädt ein GDBFrontend-Plugin.

Tastenkürzel / Hotkeys

Die aktuellen Tastenkürzel sind unten aufgeführt.

Themen

GDBFrontend hat eingebaute Themen.

Um zwischen den Themen zu wechseln, verwenden Sie den Befehl gf-theme [THEME] in der GDB-Shell.

(gdb) gf-theme doki
(gdb) gf-theme sky
(gdb) gf-theme sakura
(gdb) gf-theme waifu
(gdb) gf-theme cyberpunk
(gdb) gf-theme dark
(gdb) gf-theme green
(gdb) gf-theme light
(gdb) gf-theme red

Um zurück zum Standard-Thema zu wechseln.

(gdb) gf-theme

Sie können sich auch das Plugin-Entwicklungs-Tutorial ansehen.

GDBFrontend Python-API

Sie können auf die Python-API von GDBFrontend über das Modul gdbfrontend zugreifen.

(gdb) python-interactive

>>> dir(gdbfrontend)

Zum Beispiel können Sie alle Client-Sockets wie folgt abrufen:

>>> gdbfrontend.api.globalvars.httpServer.ws_clients
{1: <server.GDBFrontendSocket object at 0x...>}

Oder Sie können alle Plugins abrufen:

>>> gdbfrontend.plugin.getAll()
['hello', 'theme_cyberpunk', 'theme_dark', 'theme_doki', 'theme_green', 'theme_light', 'theme_red', 'theme_sakura', 'theme_sky', 'theme_waifu']

Sicherheit beim Teilen von Sitzungen

Sie können die Option --credentials=USER:PASS verwenden, um Ihrer Debugger-Sitzung eine HTTP-Authentifizierung hinzuzufügen.

Browser-Kompatibilität

GDBFrontend wird hauptsächlich mit Tests auf Chromium-basierten Browsern entwickelt. Es wird auch mit anderen Browsern, insbesondere Firefox, ordnungsgemäß funktionieren. Falls Sie jedoch Probleme mit anderen Browsern haben, können Sie einen Fehlerbericht senden.

Fehlerbehebung

Blockieren der GDB-Shell / des Hauptthreads

Die meisten GDBFrontend-Funktionen sind threadsicher und arbeiten im Hauptthread von GDB. Wenn Sie also etwas ausführen, das die GDB-Shell blockiert, müssen die GDBFrontend-Funktionen warten, bis es beendet ist.

Sie erhalten diese Warnung, wenn eine threadsichere GDBFrontend-Funktion arbeiten muss und Sie den Hauptthread von GDB blockieren.

(gdb) shell
$ ...

Wenn Sie die Shell beenden, werden die blockierenden GDBFrontend-Funktionen weiterarbeiten.

Hinweis: Manchmal kann diese Warnung erscheinen, ohne dass Sie etwas in der GDB-Shell ausführen – das bedeutet, dass etwas (in der GDB-Ereignisschleife) lange dauert; ignorieren Sie die Warnung in diesem Fall einfach.

Zombie-Prozesse

GDBFrontend sendet SIGTERM an seine Unterprozesse, Ihre Anwendung und deren Unterprozesse. Wenn Ihre Anwendung neue Prozesse abspaltet und deren PGIDs setzt, kann es sein, dass GDBFrontend sie nicht schließt. In diesem Fall sollten Sie SIGKILL an Ihre Prozesse senden.

pkill -f gdb

Leistungstipps für den Ausdrucks-Evaluator

Wenn Sie den Ausdrucks-Evaluator mit sehr tief expandierten Variablen/Membern verwenden, kann die Leistung beim Scrollen und Bewegen des Evaluatorfensters für die Zeiger-Visualisierung beeinträchtigt werden. In diesem Fall können Sie für dieses Evaluatorfenster die Signal- und Slot-Kennzeichnungen deaktivieren.

GDB-bezogene Probleme und Tipps

• GDB gibt möglicherweise keine Quellen von dynamisch gelinkten Objekten aus, bis Sie einmal eine Zeile ausführen, die eine Funktion aus dem dynamisch gelinkten Objekt aufruft. Sie können einen Breakpoint auf eine Zeile setzen und diese einmal ausführen; danach werden Sie während der Sitzung die Quellen aus dem dynamisch gelinkten Objekt sehen.

Windows

Eigentlich kann gdb-frontend unter Windows ausgeführt werden, aber es gibt einige ernsthafte Probleme mit der Windows-Version von GDB, die die Verwendung von gdb-frontend unter Windows verhindern. Natürlich können Sie gdb-frontend unter WSL verwenden, wenn Sie Windows 10 nutzen.

Probleme mit Windows-GDB

• Der Hauptthread von GDB wird blockiert, während ein Prozess läuft. (gdb-frontend hat einen Unterbrechungsmechanismus, um dies zu beheben, aber er reicht noch nicht aus.)
• Die Eingabeaufforderung von Windows-GDB wird während der Ausführung des Prozesses blockiert, und es gibt einige Probleme beim Unterbrechen der Anwendung.

WSL

Sie können gdb-frontend auf WSL (Windows Subsystem for Linux) verwenden.

Probleme mit WSL

• Unter WSL 1 ist die Option für einen zufälligen Port nicht nutzbar, da das /proc/net/tcp-Interface auf WSL nicht funktioniert. (WSL 2 hat dieses Problem nicht.)

Versionierung

Seit v0.2.0-beta verwendet GDBFrontend eine neue Versionierungsstrategie.

Versionen lesen

In vX.Y.Z-STABILITY:

• X sind Major-Versionen, die sich langfristig mit großen Funktionen und Verbesserungen ändern.
• Y sind Main-Versionen, die neue Funktionen und Verbesserungen enthalten.
• Z sind Bugfix-Veröffentlichungen von Main-Versionen.
• STABILITY ist der Stabilitätsgrad der Veröffentlichung. (alpha, beta, rcN, stable)

Dokumentation

Die Dokumentation ist noch TODO.

API-Dokumentation

Die API-Dokumentation ist noch TODO.

Plugin-Entwicklung

Sie können das Plugin-Entwicklungs-Tutorial lesen.

Theme-Entwicklung

Themen werden als Plugins entwickelt.

Discord

Treten Sie der Discord-Community bei.

🎊 Mitwirken

Sie können mitwirken, indem Sie zum Projekt committen oder ein Plugin entwickeln. Alle Commits sind willkommen.

Mitwirkungsrichtlinien

❤️ Spenden

• Patreon
• GitHub Sponsors

Kryptowährungsspenden

Vorzugsweise wird das Spenden von USDT oder USDC empfohlen, aber Sie können jede der oben genannten Währungen spenden. 🥳

Lizenz

Copyright (C) 2019, Oğuzhan Eroğlu [email protected] (https://oguzhaneroglu.com/)

GNU General Public License v3 (GPL-3)

Sie dürfen die Software kopieren, verteilen und modifizieren, solange Sie Änderungen/Daten in den Quelldateien nachverfolgen. Alle Modifikationen an oder Software (einschließlich Compiler), die unter der GPL lizenziert ist, müssen ebenfalls unter der GPL zusammen mit Build- und Installationsanweisungen verfügbar gemacht werden.