Debugging applications with the GNU Debugger Presenter: Prakash Varandani

Presenter: Prakash Varandani

When to use a debugger? Point-in-time debugging When a problem is easily reproducible. When the problem behavior can be predicted When a problem can be localized to a small period of time When system level problem determination tools do not help When the source code is readily available.

Point-in-time debugging

When a problem is easily reproducible.

When the problem behavior can be predicted

When a problem can be localized to a small period of time

When system level problem determination tools do not help

When the source code is readily available.

When not to use debugger? When causes of a problem span a long history and time. Problem is difficult to predict in nature. Problem is not reproducible at will.

When causes of a problem span a long history and time.

Problem is difficult to predict in nature.

Problem is not reproducible at will.

Why gdb? Easily available. Easy installation. Configurable. Support for various Object File Formats. Support for various architectures. Rich feature set. Open Source (Of Course).

Easily available.

Easy installation.

Configurable.

Support for various Object File Formats.

Support for various architectures.

Rich feature set.

Open Source (Of Course).

Compiling for Debugging. Compiling with the “-g” option: e.g. gcc –g stack.c –o stack Preprocessor information: e.g. gcc –dwarf-2 –g3 stack.c –o stack

Compiling with the “-g” option:

e.g. gcc –g stack.c –o stack

Preprocessor information:

e.g. gcc –dwarf-2 –g3 stack.c –o stack

Attaching a process Run a program directly through the debugger. Attach to a running process. Use a core file for post-mortem analysis.

Run a program directly through the debugger.

Attach to a running process.

Use a core file for post-mortem analysis.

Invoking gdb Executable program: gdb program Executable and core file: gdb program core. Executable and process: gdb program <pid>.

Executable program:

gdb program

Executable and core file:

gdb program core.

Executable and process:

gdb program <pid>.

Program’s arguments. (gdb) set args abc def (gdb) set args (gdb) run abc def Example 1:

(gdb) set args abc def

(gdb) set args

(gdb) run abc def

Example 1:

gdb files It is possible to start gdb without any process/executable/core file. Add an executable (gdb) file/exec-file <executable> Attach to a already running process (gdb) attach <pid> Add a core file (gdb) core-file <filename>

It is possible to start gdb without any process/executable/core file.

Add an executable

(gdb) file/exec-file <executable>

Attach to a already running process

(gdb) attach <pid>

Add a core file

(gdb) core-file <filename>

Setting breakpoints: (gdb) break function (gdb) break +/- offset (gdb) break linenum (gdb) break filename : linenum (gdb) break filename : function (gdb) break * address (gdb) break ... if cond Example 2:

(gdb) break function

(gdb) break +/- offset

(gdb) break linenum

(gdb) break filename : linenum

(gdb) break filename : function

(gdb) break * address

(gdb) break ... if cond

Example 2:

Setting breakpoints contd… (gdb) tbreak args (gdb) hbreak args (gdb) thbreak args (gdb) rbreak regex

(gdb) tbreak args

(gdb) hbreak args

(gdb) thbreak args

(gdb) rbreak regex

Watchpoints (gdb) watch expr (gdb) rwatch expr (gdb) awatch expr (gdb) info watchpoints (provides similar information as for info breakpoints)

(gdb) watch expr

(gdb) rwatch expr

(gdb) awatch expr

(gdb) info watchpoints

(provides similar information as

for info breakpoints)

Getting information about breakpoints info breakpoints [ n ] Breakpoint Numbers Type Disposition Enabled or Disabled Address What Example 4:

info breakpoints [ n ]

Breakpoint Numbers

Type

Disposition

Enabled or Disabled

Address

What

Example 4:

Breakpoints contd… Simple breakpoints stop the program every time they are hit. (gdb) condition bnum expression (gdb) condition bnum (gdb) ignore bnum count (gdb) commands [ bnum ] ... command-list ... end If bnum is not provided the commands refer to the last set breakpoint/watchpoint.

Simple breakpoints stop the program every time they are hit.

(gdb) condition bnum expression

(gdb) condition bnum

(gdb) ignore bnum count

(gdb) commands [ bnum ]

... command-list ...

end

If bnum is not provided the commands refer to the last set breakpoint/watchpoint.

Breakpoints contd... (gdb) clear (gdb) clear function (gdb) clear linenum (gdb) delete [breakpoints] [range...] (gdb) disable [breakpoints] [range...] (gdb) enable [breakpoints] once range (gdb) enable [breakpoints] delete range

(gdb) clear

(gdb) clear function

(gdb) clear linenum

(gdb) delete [breakpoints] [range...]

(gdb) disable [breakpoints] [range...]

(gdb) enable [breakpoints] once range

(gdb) enable [breakpoints] delete range

Continuing and Stepping (gdb) continue [ignore-count] (gdb) step [count] (gdb) next [count] (gdb) finish (gdb) until (gdb) until location (gdb) stepi (gdb) nexti Example 5:

(gdb) continue [ignore-count]

(gdb) step [count]

(gdb) next [count]

(gdb) finish

(gdb) until

(gdb) until location

(gdb) stepi

(gdb) nexti

Example 5:

Examining the stack Frames: data associated with each function call like arguments, local variables, ra etc... The most recently created frame is called the innermost frame and the initial one is called the outermost frame. gdb assign numbers to the stack frames, 0 for the innermost and so on..

Frames: data associated with each function call like arguments, local variables, ra etc...

The most recently created frame is called the innermost frame and the initial one is called the outermost frame.

gdb assign numbers to the stack frames, 0 for the innermost and so on..

How we got there?.. backtraces backtrace, bt -> Print a backtrace of the entire stack. backtrace n , bt n -> print n innermost frames. backtrace - n , bt – n -> print n outermost frames. backtrace full -> Print the values of the local variables also.

backtrace, bt -> Print a backtrace of the entire stack.

backtrace n , bt n -> print n innermost frames.

backtrace - n , bt – n -> print n outermost frames.

backtrace full -> Print the values of the local variables also.

Controlling backtrace set backtrace past-main [on/off] to configure printing of system specific code. set backtrace past-entry [on/off] show backtrace past-entry set backtrace limit n set backtrace limit 0 (unlimited) show backtrace limit

set backtrace past-main [on/off]

to configure printing of system specific code.

set backtrace past-entry [on/off]

show backtrace past-entry

set backtrace limit n

set backtrace limit 0 (unlimited)

show backtrace limit

Selecting a frame (gdb) frame n, f n -> select frame n (gdb) frame addr , f addr -> useful when the program has multiple stacks (highly system specific). (gdb) up [n] -> for positive n move “n” frames towards the outermost frame. (gdb) down [n] -> for positive n move “n” frames towards the innermost frame. If n is not provided move one frame up or down.

(gdb) frame n, f n -> select frame n

(gdb) frame addr , f addr -> useful when the program has multiple stacks (highly system specific).

(gdb) up [n] -> for positive n move “n” frames towards the outermost frame.

(gdb) down [n] -> for positive n move “n” frames towards the innermost frame.

If n is not provided move one frame up or down.

Information about a frame (gdb) info frame This command prints a verbose description of the selected stack frame, including: the address of the frame the address of the next frame down (called by this frame) the address of the next frame up (caller of this frame) the language in which the source code corresponding to this frame is written the address of the frame's arguments the address of the frame's local variables the program counter saved in it (the address of execution in the caller frame) which registers were saved in the frame This information is useful when a stack format fail to fit the usual convention.

(gdb) info frame

This command prints a verbose description of the selected stack frame, including:

the address of the frame

the address of the next frame down (called by this frame)

the address of the next frame up (caller of this frame)

the language in which the source code corresponding to this frame is written

the address of the frame's arguments

the address of the frame's local variables

the program counter saved in it (the address of execution in the caller frame)

which registers were saved in the frame

This information is useful when a stack format fail to fit the usual convention.

Information about a frame ... (gdb) info frame addr , info f addr (gdb) info args (gdb) info locals

(gdb) info frame addr , info f addr

(gdb) info args

(gdb) info locals

Printing source lines (gdb) list linenum (gdb) list function (gdb) list (gdb) list – (gdb) list *address

(gdb) list linenum

(gdb) list function

(gdb) list

(gdb) list –

(gdb) list *address

Searching source files. (gdb) forward-search regexp following the last line printed, search for a match with regexp and print the first line found. (gdb) search regexp Same as forward-search. (gdb) reverse-search regexp Starting with the line one above the last line printed, search for a match with regexp and print the first line found.

(gdb) forward-search regexp

following the last line printed, search for a match with regexp and print the first line found.

(gdb) search regexp

Same as forward-search.

(gdb) reverse-search regexp

Starting with the line one above the last line printed,

search for a match with regexp and print the first line found.

Examining Data (gdb) print expr (gdb) print /f expr (gdb) print (gdb) print /f

(gdb) print expr

(gdb) print /f expr

(gdb) print

(gdb) print /f

Output formats x -> hexadecimal d -> signed decimal u -> unsigned decimal o -> octal t -> binary c -> character f -> floating point a -> address format

x -> hexadecimal

d -> signed decimal

u -> unsigned decimal

o -> octal

t -> binary

c -> character

f -> floating point

a -> address format

Examining memory (gdb) x /nfu addr (gdb) x addr n -> the repeat count. Default 1. f -> format for printing. Default x and changes eventually. u -> unit size, can be one of b -> byte h -> half word (2 bytes) w -> word (4 bytes) g -> giant word (8 bytes)

(gdb) x /nfu addr

(gdb) x addr

n -> the repeat count. Default 1.

f -> format for printing. Default x and changes eventually.

u -> unit size, can be one of

b -> byte

h -> half word (2 bytes)

w -> word (4 bytes)

g -> giant word (8 bytes)

Automatic display (gdb) display expr (gdb) display /f expr (gdb) undisplay dnums delete display dnums (gdb) disable display dnums (gdb) enable display dnums (gdb) display (gdb) info display

(gdb) display expr

(gdb) display /f expr

(gdb) undisplay dnums delete display dnums

(gdb) disable display dnums

(gdb) enable display dnums

(gdb) display

(gdb) info display

Assembly Language Disassembling a function: (gdb) disassemble main Dump of assembler code for function main: 0x00010754 <main+0>: save %sp, -120, %sp 0x00010758 <main+4>: mov 3, %o0 0x0001075c <main+8>: st %o0, [ %fp + -20 ] 0x00010760 <main+12>: ld [ %fp + -20 ], %o0 0x00010764 <main+16>: call 0x10718 <fun1> 0x00010768 <main+20>: nop 0x0001076c <main+24>: clr %i0 ! 0x0 0x00010770 <main+28>: b 0x10778 <main+36> 0x00010774 <main+32>: nop 0x00010778 <main+36>: ret 0x0001077c <main+40>: restore End of assembler dump.

Disassembling a function:

(gdb) disassemble main

Dump of assembler code for function main:

0x00010754 <main+0>: save %sp, -120, %sp

0x00010758 <main+4>: mov 3, %o0

0x0001075c <main+8>: st %o0, [ %fp + -20 ]

0x00010760 <main+12>: ld [ %fp + -20 ], %o0

0x00010764 <main+16>: call 0x10718 <fun1>

0x00010768 <main+20>: nop

0x0001076c <main+24>: clr %i0 ! 0x0

0x00010770 <main+28>: b 0x10778 <main+36>

0x00010774 <main+32>: nop

0x00010778 <main+36>: ret

0x0001077c <main+40>: restore

End of assembler dump.

Looking into the registers A single register: (gdb) p $eax $4 = 6 (gdb) p $ecx $5 = 1 All of them: (gdb) info registers eax 0x6 6 ecx 0x1 1 edx 0x4015c490 1075168400 ebx 0x4015afd8 1075163096 … …

A single register:

(gdb) p $eax

$4 = 6

(gdb) p $ecx

$5 = 1

All of them:

(gdb) info registers

eax 0x6 6

ecx 0x1 1

edx 0x4015c490 1075168400

ebx 0x4015afd8 1075163096

…

…

Signals (gdb) info signals (gdb) info handle (gdb) info signal sig (gdb) handle signal keywords keywords can be stop/nostop print/noprint pass(noignore)/nopass(ignore)

(gdb) info signals

(gdb) info handle

(gdb) info signal sig

(gdb) handle signal keywords

keywords can be

stop/nostop

print/noprint

pass(noignore)/nopass(ignore)

Altering Execution Assigning values to variables at runtime using print/set. Continuing at a different address Sending a signal Cancelling execution of a function Calling program functions

Assigning values to variables at runtime using print/set.

Continuing at a different address

Sending a signal

Cancelling execution of a function

Calling program functions

Canning the commands define command can accept upto 10 arguments viz. arg0 to arg9 document command dont-repeat help user-defined show user

define command

can accept upto 10 arguments viz. arg0 to arg9

document command

dont-repeat

help user-defined

show user

Command hooks run a sequence of commands when a particular command is executed. hook-<command> runs before <command> is executed. hookpost-<command> runs after command is executed. The pseudo command “stop”

run a sequence of commands when a particular command is executed.

hook-<command> runs before <command> is executed.

hookpost-<command> runs after command is executed.

The pseudo command “stop”