# Nemiver-Handbuch

2008
Jonathon Jongsma
2009
Mario Blättermann (mariobl@gnome.org)
Nemiver-Projekt
Jonathon
Jongsma
GNOME
1.0
2007

Erste Version

2.0
2008

Aktualisierung für die Version 0.5.0

Dieses Handbuch beschreibt Version 0.5.0 von Nemiver.

## Rückmeldungen

Um einen Fehler zu melden oder einen Vorschlag zu Nemiver oder zu diesem Handbuch zu machen, besuchen Sie bitte die Nemiver-Projektwebseite.

Nemiver ist ein grafischer Debugger für die GNOME-Arbeitsumgebung.

## Überblick

Nemiver wird ständig weiterentwickelt, um einen unabhängig arbeitenden grafischen Debugger zur Verfügung zu stellen, der sich nahtlos in die GNOME-Arbeitsumgebung einfügt. Das gegenwärtige Backend benutzt den wohlbekannten GNU-Debugger gdb zum Debuggen von in C oder C++ geschriebenen Programmen.

### Ansichten

Nemiver wurde als universeller grafischer Arbeitsplatz entworfen, der über ein Plugin-System verschiedene Ansichten darstellen kann. Gegenwärtig ist die einzige bereitgestellte Ansicht die Debugging-Ansicht. In der Zukunft aber könnten Ansichten für das Speicher-Debugging mit valgrind oder für Profiling-Werkzeuge wie oprofile möglich sein.

## Erste Schritte

Dieser Abschnitt beschreibt den Start von Nemiver und gibt einen grundlegenden Überblick über die Anwendung.

### Nemiver starten

Sie können Nemiver auf folgende Arten starten:

Menü Anwendungen

  Wählen Sie Entwicklung Nemiver Debugger.

Befehlszeile

  Geben Sie `nemiver` ein und drücken Sie anschlieẞend die Eingabetaste.

  #### Zusätzliche Optionen für die Befehlszeile

  Durch Eingabe des Befehls `nemiver --help-all` erhalten Sie eine Liste aller Optionen, die Sie an Nemiver in einer Befehlszeile übergeben können.

### Das Nemiver-Fenster

Beim Start von Nemiver erscheint ein Fenster, welches wie folgt aussieht:

#### Nemiver-Fenster

Zeigt das Hauptfenster von Nemiver.

Das Nemiver-Fenster enthält die folgenden Elemente:

Menüleiste

  Die Menüs in der Menüleiste enthalten alle Befehle, die Sie für die Arbeit mit Nemiver benötigen.

Werkzeugleiste

  Die Werkzeugleiste enthält grundlegende Debugging-Aktionen, die Sie zur Ausführung oder schrittweisen Ausführung des zu debuggenden Programms benötigen.

Quellansicht-Reitermappe

  Wenn Quelldateien geöffnet sind, dann zeigt dieser Bereich die Quelldateien des zu debuggenden Programms.

Status-Reitermappe

  Die Status-Reitermappe enthält folgende Reiter zur Anzeige von Informationen über das zu debuggende Programm:

  Call Stack

    Displays the current state of the call stack of the program being debugged.

  Variablen

    Zeigt eine Liste aller lokalen Variablen und Funktionsparameter an, zusätzlich zu deren Werten und Typen.

  Ziel-Terminal

    If the program being debugged prints any output to the terminal, it will be displayed in this tab.

  Haltepunkte

    This tab displays a list of all breakpoints that have been set. You can view the source code of a particular breakpoint by double-clicking an item in the list or by right-clicking and selecting Go to Source from the menu. In addition, breakpoints can be deleted, enabled, or disabled in this tab. For more information about breakpoints, see .

  Register

    Dieser Reiter zeigt alle Register des Prozessors und deren Werte an. Weitere Informationen finden Sie in .

  Speicher

    Dieser Reiter zeigt den gegenwärtigen Status eines bestimmten Speicherbereichs an. Weitere Informationen finden Sie in .

### Auswahl eines Programms zum Debuggen

Es gibt verschiedene Wege, mit dem Debuggen eines Programms zu beginnen. Nemiver ermöglicht Ihnen das Laden einer ausführbaren Datei oder einer Core-Datei, das Anhängen an einen laufenden Prozess oder die Verbindung zu einem entfernten Debugging-Server.

#### Debuggen eines ausführbaren Programms

##### Benutzung des Arbeitsplatzes

Um ein ausführbares Programm zum Debuggen auszuwählen, wählen Sie Datei Ausführen. Der folgende Dialog wird angezeigt:

###### Ausführen-Dialog

Zeigt den Dialog zur Auswahl eines auszuführenden Programms

In diesem Dialog können sie Folgendes auswählen: das zu debuggende Programm, eventuelle in der Befehlszeile an das auszuführende Programm zu übergebende Argumente, den Arbeitsordner, in welchem sich das auszuführende Programm befindet, sowie einige Umgebungsvariablen, die beim Debuggen des auszuführenden Programms gesetzt werden sollen.

##### Verwendung der Befehlszeile

To start an executable program to debug from the command line, simply specify the name of the executable. You can either give an absolute path to the executable, or if it is in the path, you can simply give the basename of the executable. For example, if `/usr/bin` is in your path, both of the following are valid:

- `nemiver /usr/bin/Programmname`

- `nemiver Programmname`

###### Übergabe von Optionen in der Befehlszeile

Falls Sie dem zu debuggenden Programm Befehlszeilenoptionen übergeben wollen, sollten Sie diese in Anführungszeichen setzen. So verhindern Sie, dass Nemiver diese verarbeitet: `nemiver "prognam --arg1 --arg2"`.

#### Anhängen an ein laufendes Programm

##### Benutzung des Arbeitsplatzes

Select the menu item File Attach to Running Program... , which should display the following dialog:

###### Anhängen-Dialog

Zeigt den Dialog zum Anhängen an ein laufendes Programm

Wählen Sie einen Prozess in der Liste aus und klicken Sie auf OK, um mit dem Debuggen des gewählten Programms zu beginnen. Die Anzeige in der Liste kann sehr umfangreich sein, deswegen können Sie die Ansicht filtern, um nur die für Sie interessanten einträge anzuzeigen. Geben Sie hierzu etwas Text in das Textfeld unterhalb der Liste ein.

##### Verwendung der Befehlszeile

To attach to a running program from the command line, use the `--attach` option. The `--attach` option accepts either a pid or a process name. So, for example, to debug the running process `foo` which has a pid of 1121, you could either type `nemiver --attach foo` or `nemiver --attach 1121`.

#### Laden einer Core-Datei

##### Benutzung des Arbeitsplatzes

Select the menu item File Load Core File... to bring up the following dialog, which will let you load a core file:

###### Dialog zum Laden einer Core-Datei

Zeigt den Dialog zum Laden einer Core-Datei

##### Verwendung der Befehlszeile

Core-Dateien können nicht über die Befehlszeile geladen werden.

#### Entferntes Debuggen

Nemiver ermöglicht Ihnen die Verbindung zu einem entfernten Debugging-Server.

##### Benutzung des Arbeitsplatzes

To connect to a remote debugging server, select File Connect to Remote Target...

Dialog zum entfernten Debuggen

Select the executable to load and the location where any shared libraries are located, and then fill in the details about connecting to the remote server.

##### Verwendung der Befehlszeile

Nemiver stellt keinen Weg bereit, eine Verbindung zu einem entfernten Server in einer Befehlszeile aufzubauen.

## Benutzung von Nemiver

Dieser Abschnitt beschreit, wie Sie Nemiver zum Debuggen Ihrer Anwendung einsetzen können.

### Grundlegende Debugging-Aktionen

Die grundlegenden Debugging-Aktionen sind über die Werkzeugleiste, im Menü Debug oder als Tastenkürzel verfügbar. Die am häufigsten benutzten Aktionen werden nachfolgend aufgelistet:

Fortsetzen

  Starts the program. The program will run until it hits a breakpoint or until the program ends, unless it is interrupted manually by the user by clicking Stop. This action can be activated from the keyboard with F5.

Next

  Executes the next statement, and stops when it reaches the next line in this file. Some debuggers may call this action "Step Over". This action can be activated from the keyboard with F6.

Step

  Executes the next statement, stepping into the function if possible. Some debuggers may call this action "Step In". This action can be activated from the keyboard with F7.

Step Out

  Finishes execution of the current function and stops when it returns to the calling function. This action can be activated from the keyboard with ShiftF7.

Restart

  Reloads the current executable and starts execution from the beginning. This action can be activated from the keyboard with ShiftF5.

Stop

  Manually interrupt execution of the program. This action is only available when the debugger is running the executable (e.g. after a user has clicked Continue). This action can be activated from the keyboard with F9.

By default, after loading an executable, Nemiver creates a breakpoint at `main()`, so when execution reaches `main()`, it will stop and wait for input. You can then step through the program, examine variables (see ), or set additional breakpoints (see ).

### Inspecting Variables

Nemiver displays a list of all local variables in the Variables tab of the Status Notebook. If you'd like to examine a different variable (or even an arbitrary expression), you can use the Variable Inspector. To bring up the Variable Inspector, select Debug Inspect a Variable. When the variable inspector comes up, you'll see a window that looks similar to the following:

Variable Inspector Dialog

You can type any variable name or a simple expression (such as `pFoo->bar`) into the input box, and if the variable is valid and in scope, it will be display details about that expression.

Alternately, if you select the name of a variable in the source editor, and then launch the Variable Inspector, it will attempt to display information about the selected variable name.

#### Tastenkürzel

You can also start the Variable Inspector by pressing F12.

Nemiver will also let you display a list of all global variables in an application in a separate dialog. To display the Global Variables dialog, select Debug Show Global Variables or press CtrlG.

Dialog der globalen Variablen

Bei einigen Programmen (insbesondere C++) kann das Auflisten aller globalen Variablen sehr lange Zeit in Anspruch nehmen.

### Festlegen von Haltepunkten

There are several different ways to set breakpoints in Nemiver. Nemiver automatically sets a breakpoint at `main()` when you first begin debugging a new executable. If you want to set additional breakpoints you can do one of the following:

- Click in the margin next to the line where you want the breakpoint to be set

- Place your cursor on a line where you want the breakpoint to be set and set the breakpoint by either selecting Debug Toggle Breakpoint at Cursor, or by pressing F8

- Set a breakpoint at a specific function name or at a specific location in a file by selecting Debug Set Breakpoint... or by pressing CtrlB. This will bring up a dialog that looks like the following:

  Dialog zum Festlegen von Haltepunkten

  You can specify a breakpoint at a particular location in a file, or by function name. If there are more than one function with the same name, Nemiver will display a list of all matching functions and ask you to pick the one you want.

#### Deaktivierte Haltepunkte

Breakpoints can be either enabled or disabled. The debugger will stop execution whenever it reaches an enabled breakpoint but will not be affected by any breakpoints in the disabled state. This allows you to temporarily remove a breakpoint without actually deleting it.

To disable or enable a breakpoint, click the checkbox next to the breakpoint number you want to enable or disable in the Breakpoints tab of the Status Notebook. Alternately, you can press ShiftF8 to enable or disable a breakpoint that is set on the line that the cursor is currently on.

Die folgenden Abbildungen verdeutlichen den Unterschied zwischen aktivierten und deaktivierten Haltepunkten im Quelltexteditor.

Ansicht eines aktivierten Haltepunktes

Aktivierter Haltepunkt

Ansicht eines deaktivierten Haltepunktes

Deaktivierter Haltepunkt

#### Öffnen von Quelldateien

Sometimes you don't know exactly the function name or line number where you want a breakpoint to be set, so you must open a source file to figure it out. You could just open arbitrary files from the filesystem, but Nemiver can also provide a list of source files that were used to build the executable and allow you to select from this list. When you select File Open Source File..., the following window should be displayed:

Zeigt den Dialog zum Öffnen von Quelldateien

To select an arbitrary file from the filesystem, choose the Select from Filesystem option. To select from a list of files that produced the executable, choose Select from Target Executable.

##### Bestimmen von Quelldateien für dynamisch geladene Module

If the target executable loads modules at runtime (e.g. using `dlopen()`), Nemiver will not be able to determine which files were used to build these modules until they are actually loaded.

### Fortgeschrittenes Debuggen

#### Register

The register editing widget is located in the Registers tab of the Status Notebook. Alternately, you can press AltF5 to jump directly to the correct tab.

The Register Editing Widget

This widget shows the current values of all of the CPU registers. You can edit the register values by clicking in the Value column and entering a new value. If the value for the register changed since the last time the debugger stopped, it will be highlighted in red.

#### Speicher

The memory widget allows you to view a section of memory directly. This enables you to get a lower-level view of what's happening while your program is running.

The Memory Editing Widget

To display a segment of memory in the memory view widget, enter a memory address in the Address field. If the address is valid for the program being debugged, the memory view will display the memory values starting at the specified address. Memory values can be displayed in byte format, word format (2 bytes), or long word format (4 bytes) by choosing an option from the Group By drop-down menu. The memory values will automatically be updated as you step through the program.

In addition to viewing the memory values, you can also use the memory widget to modify memory values. You can edit either the hex byte representation (the left-hand section of the memory widget), or the ASCII representation (the right-hand section of the memory widget). All changes will be applied immediately.

## Speichern und Wiederherstellen von Sitzungen

Nemiver can save your debugging sessions for you so that you can resume them at a later time. This includes saving information such as which executable is being debugged, what environment variables are set, what command-line options are passed to the executable, which files are open, and which breakpoints are set so that you can get back to where you left off last time as quickly as possible.

### Speichern von Sitzungen

Nemiver will save your session automatically on exit, so you don't even have to worry about it. However, if you want to explicitly save the session before closing Nemiver, you can do so by selecting File Save Session To Disk.

### Wiederaufnehmen gespeicherter Sitzungen

#### Benutzung des Arbeitsplatzes

Select File Resume Saved Session... and select a session from the list.

##### Sitzungsdialog

Zeigt den Dialog zum Wiederaufnehmen gespeicherter Sitzungen

#### In der Befehlszeile

If you know the session ID of the session you want to run, you can start that debugging session from the command line. For example, if you want to run session number 3, you can do so with the following command: `nemiver --session 3`.

## Info zu Nemiver

Nemiver wurde von Dodji Seketeli und Jonathon Jongsma geschrieben, mit zusätzlichen Beiträgen von vielen anderen. Weitere Informationen über Nemiver finden Sie auf der Nemiver-Projektwebseite.

Um einen Fehler zu melden oder einen Vorschlag zu dieser Anwendung oder zu diesem Handbuch zu machen, ziehen Sie den Abschnitt »Rückmeldungen« des GNOME Desktop-Benutzerhandbuchs zu Rate.

Dieses Programm ist freie Software. Sie können es unter den Bedingungen der GNU General Public License, wie von der Free Software Foundation veröffentlicht, weitergeben und/oder modifizieren, entweder gemäß Version 2 der Lizenz oder (nach Ihrer Option) jeder späteren Version. Eine Kopie der GNU General Public License finden Sie in der GPL, oder in der Datei COPYING, die im Quellcode dieses Programms enthalten ist.