global gdb_class gdb_cmd set gdb_class([list internals]) "{maintenance check-symtabs} {maintenance demangle} {maintenance dump-me} {maintenance print objfiles} {maintenance print psymbols} {maintenance print msymbols} {maintenance print symbols} {maintenance print type} {maintenance info sections} {maintenance info breakpoints}" set gdb_class([list status]) "{show remotedebug} {show remotebaud} {show version} {show commands} {show confirm} {show history filename} {show history size} {show history save} {show history expansion} {show editing} {show verbose} {show prompt} {show height} {show width} {show complaints} {show gnutarget} {show demangle-style} {show check range} {show check type} {show language} {show remotedevice} {show write} {show warranty} {show copying} {show user} {show paths} {show environment} {show args} {show symbol-reloading} {show radix} {show output-radix} {show input-radix} {show print asm-demangle} {show print sevenbit-strings} {show print demangle} {show print object} {show print vtbl} {show print symbol-filename} {show print max-symbolic-offset} {show print address} {show print array} {show print union} {show print pretty} {show print repeats} {show print null-stop} {show print elements} {show values} {show convenience} {show listsize} {show directories} {info set} {info terminal} {info files} {info target} {info sharedlibrary} {info warranty} {info copying} {info handle} {info signals} {info float} {info program} {info all-registers} {info registers} {info sources} {info types} {info functions} {info variables} {info display} {info address} {info line} {info source} {info threads} {info catch} {info args} {info locals} {info frame} {info stack} {info watchpoints} {info breakpoints}" set gdb_class([list support]) "{show confirm} {show history filename} {show history size} {show history save} {show history expansion} {show editing} {show verbose} {show prompt} {show height} {show width} {show complaints} {show demangle-style} {show check range} {show check type} {show language} {show write} {show symbol-reloading} {show radix} {show output-radix} {show input-radix} {show print asm-demangle} {show print sevenbit-strings} {show print demangle} {show print object} {show print vtbl} {show print address} {show print array} {show print union} {show print pretty} {show listsize} help quit source define document echo make shell {set confirm} {set history filename} {set history size} {set history save} {set history expansion} {set editing} {set verbose} {set prompt} {set height} {set width} {set complaints} {set demangle-style} {set check range} {set check type} {set language} {set write} {set symbol-reloading} {set radix} {set output-radix} {set input-radix} {set print asm-demangle} {set print sevenbit-strings} {set print demangle} {set print object} {set print vtbl} {set print address} {set print array} {set print union} {set print pretty} {set listsize} down-silently up-silently" set gdb_class([list running]) "{show args} {info handle} kill {target remote} {target kcore} {target core} {target child} {target exec} handle run continue jump until step next finish nexti stepi signal detach attach {unset environment} tty {set environment} {set args} {apply all}" set gdb_class([list aliases]) "ni si where {delete breakpoints} {disable breakpoints}" set gdb_class([list breakpoints]) "awatch rwatch watch catch break clear {delete display} {delete breakpoints} {disable display} {disable breakpoints} {enable display} {enable once} {enable delete} thbreak hbreak tbreak condition commands ignore" set gdb_class([list data]) "whatis ptype inspect print call {set remotedebug} {set remotebaud} {set confirm} {set history filename} {set history size} {set history save} {set history expansion} {set editing} {set verbose} {set prompt} {set height} {set width} {set complaints} {set gnutarget} {set demangle-style} {set check range} {set check type} {set language} {set remotedevice} {set write} {set environment} {set args} {set symbol-reloading} {set variable} {set radix} {set output-radix} {set input-radix} {set print asm-demangle} {set print sevenbit-strings} {set print demangle} {set print object} {set print vtbl} {set print symbol-filename} {set print max-symbolic-offset} {set print address} {set print array} {set print union} {set print pretty} {set print repeats} {set print null-stop} {set print elements} {set listsize} output printf display undisplay disassemble x {delete display} {disable display} {enable display}" set gdb_class([list stack]) "bt backtrace select-frame frame down up return" set gdb_class([list obscure]) "complete {remote } proc stop" set gdb_class([list files]) "{show gnutarget} cd pwd core-file section exec-file file sharedlibrary path load add-shared-symbol-files add-symbol-file symbol-file {set gnutarget} list reverse-search search forward-search directory" set gdb_cmd([list pwd]) {Print working directory. This is used for your program as well. } set gdb_cmd([list sharedlibrary]) {Load shared object library symbols for files matching REGEXP. } set gdb_cmd([list echo]) {Print a constant string. Give string as argument. C escape sequences may be used in the argument. No newline is added at the end of the argument; use "\n" if you want a newline to be printed. Since leading and trailing whitespace are ignored in command arguments, if you want to print some you must use "\" before leading whitespace to be printed or after trailing whitespace. } set gdb_cmd([list info files]) {Names of targets and files being debugged. Shows the entire stack of targets currently in use (including the exec-file, core-file, and process, if any), as well as the symbol file name. } set gdb_cmd([list whatis]) {Print data type of expression EXP. } set gdb_cmd([list info sources]) {Source files in the program. } set gdb_cmd([list set history expansion]) {Set history expansion on command input. Without an argument, history expansion is enabled. } set gdb_cmd([list break]) {Set breakpoint at specified line or function. Argument may be line number, function name, or "*" and an address. If line number is specified, break at start of code for that line. If function is specified, break at start of code for that function. If an address is specified, break at that exact address. With no arg, uses current execution address of selected stack frame. This is useful for breaking on return to a stack frame. Multiple breakpoints at one place are permitted, and useful if conditional. Do "help breakpoints" for info on other commands dealing with breakpoints. } set gdb_cmd([list show print union]) {Show printing of unions interior to structures. } set gdb_cmd([list info handle]) {What debugger does when program gets various signals. Specify a signal number as argument to print info on that signal only. } set gdb_cmd([list catch]) {Set breakpoints to catch exceptions that are raised. Argument may be a single exception to catch, multiple exceptions to catch, or the default exception "default". If no arguments are given, breakpoints are set at all exception handlers catch clauses within the current scope. A condition specified for the catch applies to all breakpoints set with this command Do "help breakpoints" for info on other commands dealing with breakpoints. } set gdb_cmd([list show print elements]) {Show limit on string chars or array elements to print. "set print elements 0" causes there to be no limit. } set gdb_cmd([list unset environment]) {Cancel environment variable VAR for the program. This does not affect the program until the next "run" command. } set gdb_cmd([list section]) {Change the base address of section SECTION of the exec file to ADDR. This can be used if the exec file does not contain section addresses, (such as in the a.out format), or when the addresses specified in the file itself are wrong. Each section must be changed separately. The ``info files'' command lists all the sections and their addresses. } set gdb_cmd([list show editing]) {Show editing of command lines as they are typed. Use "on" to enable to enable the editing, and "off" to disable it. Without an argument, command line editing is enabled. To edit, use EMACS-like or VI-like commands like control-P or ESC. } set gdb_cmd([list condition]) {Specify breakpoint number N to break only if COND is true. Usage is `condition N COND', where N is an integer and COND is an expression to be evaluated whenever breakpoint N is reached. } set gdb_cmd([list show user]) {Show definitions of user defined commands. Argument is the name of the user defined command. With no argument, show definitions of all user defined commands. } set gdb_cmd([list disable display]) {Disable some expressions to be displayed when program stops. Arguments are the code numbers of the expressions to stop displaying. No argument means disable all automatic-display expressions. Do "info display" to see current list of code numbers. } set gdb_cmd([list show copying]) {Conditions for redistributing copies of GDB. } set gdb_cmd([list info line]) {Core addresses of the code for a source line. Line can be specified as LINENUM, to list around that line in current file, FILE:LINENUM, to list around that line in that file, FUNCTION, to list around beginning of that function, FILE:FUNCTION, to distinguish among like-named static functions. Default is to describe the last source line that was listed. This sets the default address for "x" to the line's first instruction so that "x/i" suffices to start examining the machine code. The address is also stored as the value of "$_". } set gdb_cmd([list path]) {Add directory DIR(s) to beginning of search path for object files. $cwd in the path means the current working directory. This path is equivalent to the $PATH shell variable. It is a list of directories, separated by colons. These directories are searched to find fully linked executable files and separately compiled object files as needed. } set gdb_cmd([list set print object]) {Set printing of object's derived type based on vtable info. } set gdb_cmd([list maintenance print type]) {Print a type chain for a given symbol. For each node in a type chain, print the raw data for each member of the type structure, and the interpretation of the data. } set gdb_cmd([list info target]) {Names of targets and files being debugged. Shows the entire stack of targets currently in use (including the exec-file, core-file, and process, if any), as well as the symbol file name. } set gdb_cmd([list kill]) {Kill execution of program being debugged. } set gdb_cmd([list jump]) {Continue program being debugged at specified line or address. Give as argument either LINENUM or *ADDR, where ADDR is an expression for an address to start at. } set gdb_cmd([list set print symbol-filename]) {Set printing of source filename and line number with . } set gdb_cmd([list disable breakpoints]) {Disable some breakpoints. Arguments are breakpoint numbers with spaces in between. To disable all breakpoints, give no argument. A disabled breakpoint is not forgotten, but has no effect until reenabled. This command may be abbreviated "disable". } set gdb_cmd([list down-silently]) {Same as the `down' command, but does not print anything. This is useful in command scripts. } set gdb_cmd([list delete display]) {Cancel some expressions to be displayed when program stops. Arguments are the code numbers of the expressions to stop displaying. No argument means cancel all automatic-display expressions. Do "info display" to see current list of code numbers. } set gdb_cmd([list show history save]) {Show saving of the history record on exit. Use "on" to enable to enable the saving, and "off" to disable it. Without an argument, saving is enabled. } set gdb_cmd([list step]) {Step program until it reaches a different source line. Argument N means do this N times (or till program stops for another reason). } set gdb_cmd([list set check type]) {Set type checking. (on/warn/off/auto) } set gdb_cmd([list show remotedebug]) {Show debugging of remote protocol. When enabled, each packet sent or received with the remote target is displayed. } set gdb_cmd([list continue]) {Continue program being debugged, after signal or breakpoint. If proceeding from breakpoint, a number N may be used as an argument, which means to set the ignore count of that breakpoint to N - 1 (so that the breakpoint won't break until the Nth time it is reached). } set gdb_cmd([list info source]) {Information about the current source file. } set gdb_cmd([list set history size]) {Set the size of the command history, ie. the number of previous commands to keep a record of. } set gdb_cmd([list output]) {Like "print" but don't put in value history and don't print newline. This is useful in user-defined commands. } set gdb_cmd([list enable delete]) {Enable breakpoints and delete when hit. Give breakpoint numbers. If a breakpoint is hit while enabled in this fashion, it is deleted. } set gdb_cmd([list show print symbol-filename]) {Show printing of source filename and line number with . } set gdb_cmd([list directory]) {Add directory DIR to beginning of search path for source files. Forget cached info on source file locations and line positions. DIR can also be $cwd for the current working directory, or $cdir for the directory in which the source file was compiled into object code. With no argument, reset the search path to $cdir:$cwd, the default. } set gdb_cmd([list maintenance print objfiles]) {Print dump of current object file definitions. } set gdb_cmd([list show convenience]) {Debugger convenience ("$foo") variables. These variables are created when you assign them values; thus, "print $foo=1" gives "$foo" the value 1. Values may be any type. A few convenience variables are given values automatically: "$_"holds the last address examined with "x" or "info lines", "$__" holds the contents of the last address examined with "x". } set gdb_cmd([list show verbose]) {Show verbosity. } set gdb_cmd([list maintenance dump-me]) {Get fatal error; make debugger dump its core. GDB sets it's handling of SIGQUIT back to SIG_DFL and then sends itself a SIGQUIT signal. } set gdb_cmd([list target core]) {Use a core file as a target. Specify the filename of the core file. } set gdb_cmd([list set input-radix]) {Set default input radix for entering numbers. } set gdb_cmd([list show height]) {Show number of lines gdb thinks are in a page. } set gdb_cmd([list set width]) {Set number of characters gdb thinks are in a line. } set gdb_cmd([list info registers]) {List of integer registers and their contents, for selected stack frame. Register name as argument means describe only that register. } set gdb_cmd([list make]) {Run the ``make'' program using the rest of the line as arguments. } set gdb_cmd([list set demangle-style]) {Set the current C++ demangling style. Use `set demangle-style' without arguments for a list of demangling styles. } set gdb_cmd([list nexti]) {Step one instruction, but proceed through subroutine calls. Argument N means do this N times (or till program stops for another reason). } set gdb_cmd([list maintenance print psymbols]) {Print dump of current partial symbol definitions. Entries in the partial symbol table are dumped to file OUTFILE. If a SOURCE file is specified, dump only that file's partial symbols. } set gdb_cmd([list tty]) {Set terminal for future runs of program being debugged. } set gdb_cmd([list set print vtbl]) {Set printing of C++ virtual function tables. } set gdb_cmd([list show check type]) {Show type checking. (on/warn/off/auto) } set gdb_cmd([list show warranty]) {Various kinds of warranty you do not have. } set gdb_cmd([list info address]) {Describe where variable VAR is stored. } set gdb_cmd([list list]) {List specified function or line. With no argument, lists ten more lines after or around previous listing. "list -" lists the ten lines before a previous ten-line listing. One argument specifies a line, and ten lines are listed around that line. Two arguments with comma between specify starting and ending lines to list. Lines can be specified in these ways: LINENUM, to list around that line in current file, FILE:LINENUM, to list around that line in that file, FUNCTION, to list around beginning of that function, FILE:FUNCTION, to distinguish among like-named static functions. *ADDRESS, to list around the line containing that address. With two args if one is empty it stands for ten lines away from the other arg. } set gdb_cmd([list set height]) {Set number of lines gdb thinks are in a page. } set gdb_cmd([list show print array]) {Show prettyprinting of arrays. } set gdb_cmd([list ni]) {Step one instruction, but proceed through subroutine calls. Argument N means do this N times (or till program stops for another reason). } set gdb_cmd([list select-frame]) {Select a stack frame without printing anything. An argument specifies the frame to select. It can be a stack frame number or the address of the frame. } set gdb_cmd([list set language]) {Set the current source language. } set gdb_cmd([list finish]) {Execute until selected stack frame returns. Upon return, the value returned is printed and put in the value history. } set gdb_cmd([list show paths]) {Current search path for finding object files. $cwd in the path means the current working directory. This path is equivalent to the $PATH shell variable. It is a list of directories, separated by colons. These directories are searched to find fully linked executable files and separately compiled object files as needed. } set gdb_cmd([list info locals]) {Local variables of current stack frame. } set gdb_cmd([list set confirm]) {Set whether to confirm potentially dangerous operations. } set gdb_cmd([list set print max-symbolic-offset]) {Set the largest offset that will be printed in form. } set gdb_cmd([list proc]) {Set current process context } set gdb_cmd([list target exec]) {Use an executable file as a target. Specify the filename of the executable file. } set gdb_cmd([list maintenance demangle]) {Demangle a C++ mangled name. Call internal GDB demangler routine to demangle a C++ link name and prints the result. } set gdb_cmd([list set remotedevice]) {Set device for remote serial I/O. This device is used as the serial port when debugging using remote targets. } set gdb_cmd([list show listsize]) {Show number of source lines gdb will list by default. } set gdb_cmd([list set print union]) {Set printing of unions interior to structures. } set gdb_cmd([list show print repeats]) {Show threshold for repeated print elements. "set print repeats 0" causes all elements to be individually printed. } set gdb_cmd([list show print vtbl]) {Show printing of C++ virtual function tables. } set gdb_cmd([list show output-radix]) {Show default output radix for printing of values. } set gdb_cmd([list maintenance check-symtabs]) {Check consistency of psymtabs and symtabs. } set gdb_cmd([list help]) {Print list of commands. } set gdb_cmd([list where]) {Print backtrace of all stack frames, or innermost COUNT frames. With a negative argument, print outermost -COUNT frames. } set gdb_cmd([list set print asm-demangle]) {Set demangling of C++ names in disassembly listings. } set gdb_cmd([list show history filename]) {Show the filename in which to record the command history (the list of previous commands of which a record is kept). } set gdb_cmd([list show print address]) {Show printing of addresses. } set gdb_cmd([list show environment]) {The environment to give the program, or one variable's value. With an argument VAR, prints the value of environment variable VAR to give the program being debugged. With no arguments, prints the entire environment to be given to the program. } set gdb_cmd([list document]) {Document a user-defined command. Give command name as argument. Give documentation on following lines. End with a line of just "end". } set gdb_cmd([list ptype]) {Print definition of type TYPE. Argument may be a type name defined by typedef, or "struct STRUCT-TAG" or "class CLASS-NAME" or "union UNION-TAG" or "enum ENUM-TAG". The selected stack frame's lexical context is used to look up the name. } set gdb_cmd([list info float]) {Print the status of the floating point unit } set gdb_cmd([list info frame]) {All about selected stack frame, or frame at ADDR. } set gdb_cmd([list set remotebaud]) {Set baud rate for remote serial I/O. This value is used to set the speed of the serial port when debugging using remote targets. } set gdb_cmd([list set remotedebug]) {Set debugging of remote protocol. When enabled, each packet sent or received with the remote target is displayed. } set gdb_cmd([list apply all]) {Undefined command: "apply". Try "help". } set gdb_cmd([list set write]) {Set writing into executable and core files. } set gdb_cmd([list detach]) {Detach a process or file previously attached. If a process, it is no longer traced, and it continues its execution. If you were debugging a file, the file is closed and gdb no longer accesses it. } set gdb_cmd([list info args]) {Argument variables of current stack frame. } set gdb_cmd([list set variable]) {Evaluate expression EXP and assign result to variable VAR, using assignment syntax appropriate for the current language (VAR = EXP or VAR := EXP for example). VAR may be a debugger "convenience" variable (names starting with $), a register (a few standard names starting with $), or an actual variable in the program being debugged. EXP is any valid expression. This may usually be abbreviated to simply "set". } set gdb_cmd([list si]) {Step one instruction exactly. Argument N means do this N times (or till program stops for another reason). } set gdb_cmd([list show demangle-style]) {Show the current C++ demangling style. Use `set demangle-style' without arguments for a list of demangling styles. } set gdb_cmd([list show print null-stop]) {Show printing of char arrays to stop at first null char. } set gdb_cmd([list show directories]) {Current search path for finding source files. $cwd in the path means the current working directory. $cdir in the path means the compilation directory of the source file. } set gdb_cmd([list maintenance info sections]) {List the BFD sections of the exec and core files. } set gdb_cmd([list show print max-symbolic-offset]) {Show the largest offset that will be printed in form. } set gdb_cmd([list set editing]) {Set editing of command lines as they are typed. Use "on" to enable to enable the editing, and "off" to disable it. Without an argument, command line editing is enabled. To edit, use EMACS-like or VI-like commands like control-P or ESC. } set gdb_cmd([list set print sevenbit-strings]) {Set printing of 8-bit characters in strings as \nnn. } set gdb_cmd([list x]) {Examine memory: x/FMT ADDRESS. ADDRESS is an expression for the memory address to examine. FMT is a repeat count followed by a format letter and a size letter. Format letters are o(octal), x(hex), d(decimal), u(unsigned decimal), t(binary), f(float), a(address), i(instruction), c(char) and s(string). Size letters are b(byte), h(halfword), w(word), g(giant, 8 bytes). The specified number of objects of the specified size are printed according to the format. Defaults for format and size letters are those previously used. Default count is 1. Default address is following last thing printed with this command or "print". } set gdb_cmd([list load]) {Dynamically load FILE into the running program, and record its symbols for access from GDB. } set gdb_cmd([list undisplay]) {Cancel some expressions to be displayed when program stops. Arguments are the code numbers of the expressions to stop displaying. No argument means cancel all automatic-display expressions. "delete display" has the same effect as this command. Do "info display" to see current list of code numbers. } set gdb_cmd([list add-symbol-file]) {Usage: add-symbol-file FILE ADDR Load the symbols from FILE, assuming FILE has been dynamically loaded. ADDR is the starting address of the file's text. } set gdb_cmd([list define]) {Define a new command name. Command name is argument. Definition appears on following lines, one command per line. End with a line of just "end". Use the "document" command to give documentation for the new command. Commands defined in this way do not take arguments. } set gdb_cmd([list info signals]) {What debugger does when program gets various signals. Specify a signal number as argument to print info on that signal only. } set gdb_cmd([list down]) {Select and print stack frame called by this one. An argument says how many frames down to go. } set gdb_cmd([list maintenance info breakpoints]) {Status of all breakpoints, or breakpoint number NUMBER. The "Type" column indicates one of: breakpoint - normal breakpoint watchpoint - watchpoint longjmp - internal breakpoint used to step through longjmp() longjmp resume - internal breakpoint at the target of longjmp() until - internal breakpoint used by the "until" command finish - internal breakpoint used by the "finish" command The "Disp" column contains one of "keep", "del", or "dis" to indicate the disposition of the breakpoint after it gets hit. "dis" means that the breakpoint will be disabled. The "Address" and "What" columns indicate the address and file/line number respectively. Convenience variable "$_" and default examine address for "x" are set to the address of the last breakpoint listed. Convenience variable "$bpnum" contains the number of the last breakpoint set. } set gdb_cmd([list set args]) {Set arguments to give program being debugged when it is started. Follow this command with any number of args, to be passed to the program. } set gdb_cmd([list show remotebaud]) {Show baud rate for remote serial I/O. This value is used to set the speed of the serial port when debugging using remote targets. } set gdb_cmd([list show check range]) {Show range checking. (on/warn/off/auto) } set gdb_cmd([list set history save]) {Set saving of the history record on exit. Use "on" to enable to enable the saving, and "off" to disable it. Without an argument, saving is enabled. } set gdb_cmd([list set print repeats]) {Set threshold for repeated print elements. "set print repeats 0" causes all elements to be individually printed. } set gdb_cmd([list stop]) {There is no `stop' command, but you can set a hook on `stop'. This allows you to set a list of commands to be run each time execution of the program stops. } set gdb_cmd([list set print array]) {Set prettyprinting of arrays. } set gdb_cmd([list show radix]) {Show the default input and output number radices. Use 'show input-radix' or 'show output-radix' to independently show each. } set gdb_cmd([list show gnutarget]) {Show the current BFD target. Use `set gnutarget auto' to specify automatic detection. } set gdb_cmd([list info all-registers]) {List of all registers and their contents, for selected stack frame. Register name as argument means describe only that register. } set gdb_cmd([list up]) {Select and print stack frame that called this one. An argument says how many frames up to go. } set gdb_cmd([list set print address]) {Set printing of addresses. } set gdb_cmd([list return]) {Make selected stack frame return to its caller. Control remains in the debugger, but when you continue execution will resume in the frame above the one now selected. If an argument is given, it is an expression for the value to return. } set gdb_cmd([list delete breakpoints]) {Delete some breakpoints or auto-display expressions. Arguments are breakpoint numbers with spaces in between. To delete all breakpoints, give no argument. This command may be abbreviated "delete". } set gdb_cmd([list set history filename]) {Set the filename in which to record the command history (the list of previous commands of which a record is kept). } set gdb_cmd([list set print null-stop]) {Set printing of char arrays to stop at first null char. } set gdb_cmd([list set verbose]) {Set verbosity. } set gdb_cmd([list symbol-file]) {Load symbol table from executable file FILE. The `file' command can also load symbol tables, as well as setting the file to execute. } set gdb_cmd([list print]) {Print value of expression EXP. Variables accessible are those of the lexical environment of the selected stack frame, plus all those whose scope is global or an entire file. $NUM gets previous value number NUM. $ and $$ are the last two values. $$NUM refers to NUM'th value back from the last one. Names starting with $ refer to registers (with the values they would have if the program were to return to the stack frame now selected, restoring all registers saved by frames farther in) or else to debugger "convenience" variables (any such name not a known register). Use assignment expressions to give values to convenience variables. {TYPE}ADREXP refers to a datum of data type TYPE, located at address ADREXP. @ is a binary operator for treating consecutive data objects anywhere in memory as an array. FOO@NUM gives an array whose first element is FOO, whose second element is stored in the space following where FOO is stored, etc. FOO must be an expression whose value resides in memory. EXP may be preceded with /FMT, where FMT is a format letter but no count or size letter (see "x" command). } set gdb_cmd([list run]) {Start debugged program. You may specify arguments to give it. Args may include "*", or "[...]"; they are expanded using "sh". Input and output redirection with ">", "<", or ">>" are also allowed. With no arguments, uses arguments last specified (with "run" or "set args"). To cancel previous arguments and run with no arguments, use "set args" without arguments. } set gdb_cmd([list inspect]) {Same as "print" command, except that if you are running in the epoch environment, the value is printed in its own window. } set gdb_cmd([list set print demangle]) {Set demangling of encoded C++ names when displaying symbols. } set gdb_cmd([list search]) {Search for regular expression (see regex(3)) from last line listed. } set gdb_cmd([list show print pretty]) {Show prettyprinting of structures. } set gdb_cmd([list clear]) {Clear breakpoint at specified line or function. Argument may be line number, function name, or "*" and an address. If line number is specified, all breakpoints in that line are cleared. If function is specified, breakpoints at beginning of function are cleared. If an address is specified, breakpoints at that address are cleared. With no argument, clears all breakpoints in the line that the selected frame is executing in. See also the "delete" command which clears breakpoints by number. } set gdb_cmd([list show version]) {Show what version of GDB this is. } set gdb_cmd([list set environment]) {Set environment variable value to give the program. Arguments are VAR VALUE where VAR is variable name and VALUE is value. VALUES of environment variables are uninterpreted strings. This does not affect the program until the next "run" command. } set gdb_cmd([list tbreak]) {Set a temporary breakpoint. Args like "break" command. Like "break" except the breakpoint is only temporary, so it will be deleted when hit. Equivalent to "break" followed by using "enable delete" on the breakpoint number. } set gdb_cmd([list until]) {Execute until the program reaches a source line greater than the current or a specified line or address or function (same args as break command). Execution will also stop upon exit from the current stack frame. } set gdb_cmd([list watch]) {Set a watchpoint for an expression. A watchpoint stops execution of your program whenever the value of an expression changes. } set gdb_cmd([list shell]) {Execute the rest of the line as a shell command. With no arguments, run an inferior shell. } set gdb_cmd([list complete]) {List the completions for the rest of the line as a command. } set gdb_cmd([list info types]) {All type names, or those matching REGEXP. } set gdb_cmd([list info warranty]) {Various kinds of warranty you do not have. } set gdb_cmd([list info program]) {Execution status of the program. } set gdb_cmd([list reverse-search]) {Search backward for regular expression (see regex(3)) from last line listed. } set gdb_cmd([list awatch]) {Set a watchpoint for an expression. A watchpoint stops execution of your program whenever the value of an expression is either read or written. } set gdb_cmd([list show print asm-demangle]) {Show demangling of C++ names in disassembly listings. } set gdb_cmd([list set output-radix]) {Set default output radix for printing of values. } set gdb_cmd([list frame]) {Select and print a stack frame. With no argument, print the selected stack frame. (See also "info frame"). An argument specifies the frame to select. It can be a stack frame number or the address of the frame. With argument, nothing is printed if input is coming from a command file or a user-defined command. } set gdb_cmd([list hbreak]) {Set a hardware assisted breakpoint. Args like "break" command. Like "break" except the breakpoint requires hardware support, some target hardware may not have this support. } set gdb_cmd([list info functions]) {All function names, or those matching REGEXP. } set gdb_cmd([list backtrace]) {Print backtrace of all stack frames, or innermost COUNT frames. With a negative argument, print outermost -COUNT frames. } set gdb_cmd([list info sharedlibrary]) {Status of loaded shared object libraries. } set gdb_cmd([list info display]) {Expressions to display when program stops, with code numbers. } set gdb_cmd([list target remote]) {Use a remote computer via a serial line, using a gdb-specific protocol. Specify the serial device it is connected to (e.g. /dev/ttya). } set gdb_cmd([list target kcore]) {Use a core file as a target. Specify the filename of the core file. } set gdb_cmd([list handle]) {Specify how to handle a signal. Args are signal numbers and actions to apply to those signals. Signal numbers may be numeric (ex. 11) or symbolic (ex. SIGSEGV). Numeric ranges may be specified with the form LOW-HIGH (ex. 14-21). The special arg "all" is recognized to mean all signals except those used by the debugger, typically SIGTRAP and SIGINT. Recognized actions include "stop", "nostop", "print", "noprint", "pass", "nopass", "ignore", or "noignore". Stop means reenter debugger if this signal happens (implies print). Print means print a message if this signal happens. Pass means let program see this signal; otherwise program doesn't know. Ignore is a synonym for nopass and noignore is a synonym for pass. Pass and Stop may be combined. } set gdb_cmd([list info watchpoints]) {Synonym for ``info breakpoints''. } set gdb_cmd([list show symbol-reloading]) {Show dynamic symbol table reloading multiple times in one run. } set gdb_cmd([list enable once]) {Enable breakpoints for one hit. Give breakpoint numbers. If a breakpoint is hit while enabled in this fashion, it becomes disabled. } set gdb_cmd([list show print object]) {Show printing of object's derived type based on vtable info. } set gdb_cmd([list info breakpoints]) {Status of user-settable breakpoints, or breakpoint number NUMBER. The "Type" column indicates one of: breakpoint - normal breakpoint watchpoint - watchpoint The "Disp" column contains one of "keep", "del", or "dis" to indicate the disposition of the breakpoint after it gets hit. "dis" means that the breakpoint will be disabled. The "Address" and "What" columns indicate the address and file/line number respectively. Convenience variable "$_" and default examine address for "x" are set to the address of the last breakpoint listed. Convenience variable "$bpnum" contains the number of the last breakpoint set. } set gdb_cmd([list display]) {Print value of expression EXP each time the program stops. /FMT may be used before EXP as in the "print" command. /FMT "i" or "s" or including a size-letter is allowed, as in the "x" command, and then EXP is used to get the address to examine and examining is done as in the "x" command. With no argument, display all currently requested auto-display expressions. Use "undisplay" to cancel display requests previously made. } set gdb_cmd([list core-file]) {Use FILE as core dump for examining memory and registers. No arg means have no core file. This command has been superseded by the `target core' and `detach' commands. } set gdb_cmd([list set check range]) {Set range checking. (on/warn/off/auto) } set gdb_cmd([list info threads]) {IDs of currently known threads. } set gdb_cmd([list info catch]) {Exceptions that can be caught in the current stack frame. } set gdb_cmd([list forward-search]) {Search for regular expression (see regex(3)) from last line listed. } set gdb_cmd([list show width]) {Show number of characters gdb thinks are in a line. } set gdb_cmd([list commands]) {Set commands to be executed when a breakpoint is hit. Give breakpoint number as argument after "commands". With no argument, the targeted breakpoint is the last one set. The commands themselves follow starting on the next line. Type a line containing "end" to indicate the end of them. Give "silent" as the first line to make the breakpoint silent; then no output is printed when it is hit, except what the commands print. } set gdb_cmd([list set listsize]) {Set number of source lines gdb will list by default. } set gdb_cmd([list show language]) {Show the current source language. } set gdb_cmd([list maintenance print symbols]) {Print dump of current symbol definitions. Entries in the full symbol table are dumped to file OUTFILE. If a SOURCE file is specified, dump only that file's symbols. } set gdb_cmd([list show values]) {Elements of value history around item number IDX (or last ten). } set gdb_cmd([list target child]) {Unix child process (started by the "run" command). } set gdb_cmd([list show print demangle]) {Show demangling of encoded C++ names when displaying symbols. } set gdb_cmd([list call]) {Call a function in the program. The argument is the function name and arguments, in the notation of the current working language. The result is printed and saved in the value history, if it is not void. } set gdb_cmd([list maintenance print msymbols]) {Print dump of current minimal symbol definitions. Entries in the minimal symbol table are dumped to file OUTFILE. If a SOURCE file is specified, dump only that file's minimal symbols. } set gdb_cmd([list show history size]) {Show the size of the command history, ie. the number of previous commands to keep a record of. } set gdb_cmd([list info set]) {Show all GDB settings. } set gdb_cmd([list source]) {Read commands from a file named FILE. Note that the file ".gdbinit" is read automatically in this way when gdb is started. } set gdb_cmd([list ignore]) {Set ignore-count of breakpoint number N to COUNT. Usage is `ignore N COUNT'. } set gdb_cmd([list set gnutarget]) {Set the current BFD target. Use `set gnutarget auto' to specify automatic detection. } set gdb_cmd([list up-silently]) {Same as the `up' command, but does not print anything. This is useful in command scripts. } set gdb_cmd([list set print elements]) {Set limit on string chars or array elements to print. "set print elements 0" causes there to be no limit. } set gdb_cmd([list next]) {Step program, proceeding through subroutine calls. Like the "step" command as long as subroutine calls do not happen; when they do, the call is treated as one instruction. Argument N means do this N times (or till program stops for another reason). } set gdb_cmd([list cd]) {Set working directory to DIR for debugger and program being debugged. The change does not take effect for the program being debugged until the next time it is started. } set gdb_cmd([list file]) {Use FILE as program to be debugged. It is read for its symbols, for getting the contents of pure memory, and it is the program executed when you use the `run' command. If FILE cannot be found as specified, your execution directory path ($PATH) is searched for a command of that name. No arg means to have no executable file and no symbols. } set gdb_cmd([list attach]) {Attach to a process or file outside of GDB. This command attaches to another target, of the same type as your last `target' command (`info files' will show your target stack). The command may take as argument a process id or a device file. For a process id, you must have permission to send the process a signal, and it must have the same effective uid as the debugger. When using "attach", you should use the "file" command to specify the program running in the process, and to load its symbol table. } set gdb_cmd([list info variables]) {All global and static variable names, or those matching REGEXP. } set gdb_cmd([list bt]) {Print backtrace of all stack frames, or innermost COUNT frames. With a negative argument, print outermost -COUNT frames. } set gdb_cmd([list signal]) {Continue program giving it signal number SIGNUMBER. } set gdb_cmd([list show args]) {Show arguments to give program being debugged when it is started. Follow this command with any number of args, to be passed to the program. } set gdb_cmd([list set complaints]) {Set max number of complaints about incorrect symbols. } set gdb_cmd([list show confirm]) {Show whether to confirm potentially dangerous operations. } set gdb_cmd([list rwatch]) {Set a read watchpoint for an expression. A watchpoint stops execution of your program whenever the value of an expression is read. } set gdb_cmd([list thbreak]) {Set a temporary hardware assisted breakpoint. Args like "break" command. Like "hbreak" except the breakpoint is only temporary, so it will be deleted when hit. } set gdb_cmd([list printf]) {printf "printf format string", arg1, arg2, arg3, ..., argn This is useful for formatted output in user-defined commands. } set gdb_cmd([list disassemble]) {Disassemble a specified section of memory. Default is the function surrounding the pc of the selected frame. With a single argument, the function surrounding that address is dumped. Two arguments are taken as a range of memory to dump. } set gdb_cmd([list enable display]) {Enable some expressions to be displayed when program stops. Arguments are the code numbers of the expressions to resume displaying. No argument means enable all automatic-display expressions. Do "info display" to see current list of code numbers. } set gdb_cmd([list show print sevenbit-strings]) {Show printing of 8-bit characters in strings as \nnn. } set gdb_cmd([list info copying]) {Conditions for redistributing copies of GDB. } set gdb_cmd([list info terminal]) {Print inferior's saved terminal status. } set gdb_cmd([list info stack]) {Backtrace of the stack, or innermost COUNT frames. } set gdb_cmd([list quit]) {Exit gdb. } set gdb_cmd([list show commands]) {Show the the history of commands you typed. You can supply a command number to start with, or a `+' to start after the previous command number shown. } set gdb_cmd([list show prompt]) {Show gdb's prompt } set gdb_cmd([list remote ]) {Send a command to the remote monitor. } set gdb_cmd([list stepi]) {Step one instruction exactly. Argument N means do this N times (or till program stops for another reason). } set gdb_cmd([list show remotedevice]) {Show device for remote serial I/O. This device is used as the serial port when debugging using remote targets. } set gdb_cmd([list show input-radix]) {Show default input radix for entering numbers. } set gdb_cmd([list add-shared-symbol-files]) {Load the symbols from shared objects in the dynamic linker's link map. } set gdb_cmd([list show history expansion]) {Show history expansion on command input. Without an argument, history expansion is enabled. } set gdb_cmd([list set print pretty]) {Set prettyprinting of structures. } set gdb_cmd([list exec-file]) {Use FILE as program for getting contents of pure memory. If FILE cannot be found as specified, your execution directory path is searched for a command of that name. No arg means have no executable file. } set gdb_cmd([list show complaints]) {Show max number of complaints about incorrect symbols. } set gdb_cmd([list set symbol-reloading]) {Set dynamic symbol table reloading multiple times in one run. } set gdb_cmd([list set radix]) {Set default input and output number radices. Use 'set input-radix' or 'set output-radix' to independently set each. Without an argument, sets both radices back to the default value of 10. } set gdb_cmd([list show write]) {Show writing into executable and core files. } set gdb_cmd([list set prompt]) {Set gdb's prompt }