# Introduction to Software Engineering/Tools/Debugger

A debugger or debugging tool is a computer program that is used to test and debug other programs (the "target" program). The code to be examined might alternatively be running on an instruction set simulator (ISS), a technique that allows great power in its ability to halt when specific conditions are encountered but which will typically be somewhat slower than executing the code directly on the appropriate (or the same) processor. Some debuggers offer two modes of operation - full or partial simulation, to limit this impact.
A "crash" happens when the program cannot normally continue because of a programming bug. For example, the program might have tried to use an instruction not available on the current version of the CPU or attempted to access unavailable or protected memory. When the program "crashes" or reaches a preset condition, the debugger typically shows the position in the original code if it is a source-level debugger or symbolic debugger, commonly now seen in integrated development environments. If it is a low-level debugger or a machine-language debugger it shows the line in the disassembly (unless it also has online access to the original source code and can display the appropriate section of code from the assembly or compilation).
Typically, debuggers also offer more sophisticated functions such as running a program step by step (single-stepping or program animation), stopping (breaking) (pausing the program to examine the current state) at some event or specified instruction by means of a breakpoint, and tracking the values of some variables. Some debuggers have the ability to modify the state of the program while it is running, rather than merely to observe it. It may also be possible to continue execution at a different location in the program to bypass a crash or logical error.
The importance of a good debugger cannot be overstated. Indeed, the existence and quality of such a tool for a given language and platform can often be the deciding factor in its use, even if another language/platform is better-suited to the task.. The absence of a debugger, having once been accustomed to using one, has been said to "make you feel like a blind man in a dark room looking for a black cat that isn’t there". However, software can (and often does) behave differently running under a debugger than normally, due to the inevitable changes the presence of a debugger will make to a software program's internal timing. As a result, even with a good debugging tool, it is often very difficult to track down runtime problems in complex multi-threaded or distributed systems.
The same functionality which makes a debugger useful for eliminating bugs allows it to be used as a software cracking tool to evade copy protection, digital rights management, and other software protection features. It often also makes it useful as a general testing verification tool test coverage and performance analyzer, especially if instruction path lengths are shown.
Most current mainstream debugging engines, such as gdb and dbx provide console-based command line interfaces. Debugger front-ends are popular extensions to debugger engines that provide IDE integration, program animation, and visualization features. Some early mainframe debuggers such as IBM OLIVER (CICS interactive test/debug) and SIMON (Batch Interactive test/debug) provided this same functionality for the IBM System/360 and later operating systems, as long ago as the 1970s.

## Language dependency

Some debuggers operate on a single specific language while others can handle multiple languages transparently. For example if the main target program is written in COBOL but CALLs Assembler subroutines and also PL/1 subroutines, the debugger may dynamically switch modes to accommodate the changes in language as they occur.

## Memory protection

Some debuggers also incorporate memory protection to avoid storage violations such as buffer overflow. This may be extremely important in transaction processing environments where memory is dynamically allocated from memory 'pools' on a task by task basis.

## Hardware support for debugging

Most modern microprocessors have at least one of these features in their CPU design to make debugging easier:
* hardware support for single-stepping a program, such as the trap flag.
* An instruction set that meets the Popek and Goldberg virtualization requirements makes it easier to write debugger software that runs on the same CPU as the software being debugged; such a CPU can execute the inner loops of the program under test at full speed, and still remain under the control of the debugger.
* In-System Programming allows an external hardware debugger to re-program a system under test (for example, adding or removing instruction breakpoints). Many systems with such ISP support also have other hardware debug support.
* Hardware support for code and data breakpoints, such as address comparators and data value comparators or, with considerably more work involved, page fault hardware.
* JTAG access to hardware debug interfaces such as those on ARM architecture processors or using the Nexus command set. Processors used in embedded systems typically have extensive JTAG debug support.
* Microcontrollers with as few as six pins need to use low pin-count substitutes for JTAG, such as BDM, Spy-Bi-Wire, or DebugWire on the Atmel AVR. DebugWire, for example, uses bidirectional signaling on the RESET pin.

## List of debuggers

* AppPuncher Debugger — for debugging Rich Internet Applications
* AQtime
* CA/EZTEST — was a CICS interactive test/debug software package
* CharmDebug — a Debugger for Charm++
* CodeView
* DBG — a PHP Debugger and Profiler
* dbx
* DDD (Data Display Debugger)
* Distributed Debugging Tool (Allinea DDT)
* DDTLite — Allinea DDTLite for Visual Studio 2008
* DEBUG — the built-in debugger of DOS and Microsoft Windows
* Debugger for MySQL
* Opera Dragonfly
* Dynamic debugging technique (DDT), and its octal counterpart Octal Debugging Technique
* Eclipse
* Embedded System Debug Plug-in for Eclipse
* FusionDebug
* gDEBugger OpenGL, OpenGL ES and OpenCL Debugger and Profiler. For Windows, Linux, Mac OS X and iPhone
* GNU Debugger (GDB), GNU Binutils
* Intel Debugger (IDB)
* Insight
* Parasoft Insure++
* iSYSTEM — In circuit debugger for Embedded Systems
* Interactive Disassembler (IDA Pro)
* Java Platform Debugger Architecture
* Jinx — a whole-system debugger for heisenbugs. It works transparently as a device driver.
* JSwat — open-source Java debugger
* LLDB
* MacsBug
* Nemiver — graphical C/C++ Debugger for the GNOME desktop environment
* OLIVER (CICS interactive test/debug) - a GUI equipped instruction set simulator (ISS)
* OllyDbg
* FlexTracer - shareware debugger for SQL statements
* Omniscient Debugger — Forward and backward debugger for Java
* pydbg
* IBM Rational Purify
* RealView Debugger — Commercial debugger produced for and designed by ARM
* sdb
* SIMMON (Simulation Monitor)
* SIMON (Batch Interactive test/debug) — a GUI equipped Instruction Set Simulator for batch
* SoftICE
* TimeMachine — Forward and backward debugger designed by Green Hills Software
* TotalView
* TRACE32 — In circuit debugger for Embedded Systems
* Turbo Debugger
* Ups — C, Fortran source level debugger
* Valgrind
* VB Watch Debugger — debugger for Visual Basic 6.0
* Microsoft Visual Studio Debugger
* WinDbg
* WonderLeak - A high performance Windows heap and handle allocation profiler.
* Xdebug — PHP debugger and profiler

## Debugger front-ends

Some of the most capable and popular debuggers only implement a simple command line interface (CLI) — often to maximize portability and minimize resource consumption. Debugging via a graphical user interface (GUI) can be considered easier and more productive though. This is the reason for GUI debugger front-ends, that allow users to monitor and control subservient CLI-only debuggers via graphical user interface. Some GUI debugger front-ends are designed to be compatible with a variety of CLI-only debuggers, while others are targeted at one specific debugger.

## List of debugger front-ends

* Many Integrated development environments come with integrated debuggers (or front-ends to standard debuggers).
** Many Eclipse perspectives, e.g. the Java Development Tools (JDT) , provide a debugger front-end.
* DDD is the standard front-end from the GNU Project. It is a complex tool that works with most common debuggers (GDB, jdb, Python debugger, Perl debugger, Tcl, and others) natively or with some external programs (for PHP).
* GDB (the GNU debugger) GUI
** Emacs — Emacs editor with built in support for the GNU Debugger acts as the frontend.
** KDbg — Part of the KDE development tools.
** Nemiver — A GDB frontend that integrates well in the GNOME desktop environment.
** xxgdb — X-window frontend for GDB and dbx debugger.
** Qt Creator — multi-platform frontend for GDB (debugging example).
** cgdb — ncurses terminal program that mimics vim key mapping.
** ccdebug— A graphical GDB frontend using the Qt toolkit.
** Padb — has a parallel front-end to GDB allowing it to target parallel applications.
** Allinea Distributed Debugging Tool — a parallel and distributed front-end to a modified version of GDB.
** Xcode — contains a GDB front-end as well.
** SlickEdit — contains a GDB front-end as well.
** Eclipse C/C++ Development Tools (CDT) — includes visual debugging tools based on GDB.

## References

* Jonathan B. Rosenberg, How Debuggers Work: Algorithms, Data Structures, and Architecture, John Wiley & Sons, ISBN 0-471-14966-7
* ↑ http://www.berniecode.com/blog/2007/03/08/how-to-debug-javascript-with-visual-web-developer-express/

## External links

* Debugging tools at Curlie
* Debugging Tools for Windows
* OpenRCE: Various Debugger Resources and Plug-ins
* Parallel computing development and debugging tools at Curlie