Using the graphical interface of debug

• The ``Command pane'' keeps a log of all the events as they occur. Process output is also displayed here. This pane allows you to enter commands as if you were using the command line version of the debugger.

• The ``Disassembly pane'' displays the disassembly of the current function. The pane is updated whenever the thread or process stops.

• The ``Event pane'' displays events (breakpoints, watchpoints, system call events, etc.). Deleting, disabling, enabling, and editing events is done from the window containing this pane.

• The ``Process pane'' displays the processes and threads under the debugger's control and indicates which process or thread is current.

• The ``Registers pane'' displays the values of the machine registers for the current thread or process. It is updated whenever the thread or process stops.

• The ``Source pane'' displays the program's source. Whenever the process or thread stops, the source pane is updated to display the current line in the current file. You may also examine other files, and set and delete breakpoints. A Secondary Source pane is just like the Source pane, in that it allows you to view and edit the program's source. The Secondary Source pane is displayed when you bring up a Secondary Source Window using the ``New Source'' option. Unlike the Source pane, however, the display in a Secondary Source pane is not updated when the current location changes.

• The ``Stack pane'' displays the stack trace for the current process or thread. It is updated each time the current process or thread stops.

• The ``Status pane'' keeps track of the current process or thread for whatever window it belongs to. It displays the state of that process or thread and its location, if it is stopped.

• The ``Symbol pane'' displays the symbols for the current process or thread. It is updated each time the current process or thread stops.

The debugger's informational panes are arranged in a set of windows, as described by the configuration provided by the user. Each window set contains at least one instance of each of the debugger's panes (except for the Status pane, which is not required). If no user configuration is provided, the debugger arranges its panes into a set of six windows:

• A Source window, containing a ``Status pane'', ``Stack pane'', and ``Source pane'',

• A Command window, containing a ``Status pane'' and ``Command pane'',

• A Disassembly window, containing a ``Status pane'', ``Registers pane'', and ``Disassembly pane'',

• An Event window, containing a ``Status pane'' and an ``Event pane'',

• A Process window, containing a ``Process pane'', and

• A Symbols window, containing a ``Status pane'' and a ``Symbol pane''.

Each window set controls a subset of the processes and threads being debugged, and each thread or process belongs to exactly one window set. Multiple window sets can be created in any one debugging session. If you are debugging only one single-threaded process, you will not need more than one window set, but if you are debugging multiple threads or processes, you may wish to debug each thread or process in a separate window set. Window sets are created by the ``New Window Set'' option, which, in the default configuration, is in the ``File menu'' in the Source and Process windows.

Each window contains a menu bar providing access to a series of menus. The number and names of the menus in the menu bar and the contents of each menu are configurable by the user. The options available under each menu button provide commands to control the state of the processes and threads, options to change the information displayed, and more. See the sections for the individual buttons for details.

By default, the debugger arranges its available options into the following menus (not all menus are available in all windows):

• ``File menu''

• ``Debug menu''

• ``Edit menu''

• ``View menu''

• ``Control menu''

• ``Event menu''

• ``Properties menu''

• ``Help menu''

Each window may also contain one or more button bars. Each Button Bar can contain multiple panels of buttons. To access different button panels, click SELECT on the Next Panel button (the first button in any Button Bar that contains multiple panels). Button Bars may be located at the top of the window (right under the menu buttons, in windows that do not have a ``Status pane'' or under the Status pane, in windows that have one) or at the bottom of the window, or at both the top and bottom of the window. The Button Bar contains a selection of buttons chosen from the other pulldown menus and provides a quick way to get at the most frequently used debugger commands. The contents and location of the Button Bar(s) for each window are configurable by the user both statically, through the normal configuration mechanism (see ``Configuration'') and dynamically, while the debugger is running (see ``Button Configuration'').

Finally, each pane may provide a popup menu of actions frequently executed from that pane. The popup menu is accessed by moving the pointer over the pane and clicking MENU. Whether or not a pane provides a popup menu, and which options are available from that menu, are completely configurable (see ``Configuration'').

You may resize any window. You may also redistribute the space within the window. To do that, click SELECT on the "sash" (a small square) appearing in the right hand border at the point where any two panes meet. By dragging the sash up or down, you increase or decrease the size of the two panes relative to each other. Note that there is no sash between the ``Status pane'' and any other pane.

Several aspects of the behavior and look of the debugger can be customized using the options in the ``Properties menu''. Several of these properties can also be set as application resources in the standard X window system resource files, such as the .Xdefaults file in the user's HOME directory. See ``Customization'' for details. Many of the customizable resources can also be set using command line options (see ``Invoking the debugger'').