Software Engineering on Unix

Why use a debugger?

• Allows you to inspect internals of program
• Makes it much easier to find bugs

Why use the GNU debugger?

• Because you like command line interfaces
• Because you need all the functionality
• Front ends exist. You might consider using them. ddd is one. There are others.

How to start

• Compile source with -g option for symbol names
• Strange interaction with -O option
• Run: gdb executable-name
  • Starts gdb and loads program but doesn't run
• Run: gdb executable-name corefile
  • Starts gdb and loads program state from corefile
• Run: gdb executable-name processid
  • Starts gdb and attaches to the running process with pid processid

Listing source code

• Use the list command
• With no args, lists current location
• list [filename:]function
• list [filename:]lineno
• If you use it inside emacs, this is done somewhat automatically.

Running and stepping through programs

• run [args] -- starts execution until breakpoint or exception
• cont -- continues execution until break or exception
• set args argument-list -- sets arguments for all subsequent run's
• set environment var value -- sets the environmental variable var to value
• next -- executes next line of current function
• step -- executes next line of current function and enters functions
• Can be abbreviated n and s
• After n, s, or break, line shown is line to be executed next
• After a signal is caught, the line shown is the line being executed when the signal was caught
• Pressing return executes last command

Frames

• Each function on the stack has a frame which contains its arguments and local variables
• The frame stack shows the current nesting of function calls
• where and bt show a "backtrace" of the stack frame
• up and down allow you to move within the stack frame
• frame selects a frame by number
• up moves to the caller, down moves back down
• Commands like where and print act on functions in the current frame

Breakpoints and watchpoints

• Stops before the breakpoint line gets executed (or stops before first statement of function)
• break [filename:]lineno
• break [filename:]functionname
• Examples:

  	break foo.c:30
  	break 24
  	break main
  	

• break +-offset
• Conditional breaks
  • break ... if expression
  • Example:

    break 12 if newmem == 0

• tbreak -- same as break but disabled after being hit
• clear linenumber/function -- clears all breakpoints on that line or at the start of that function
• info breakpoints -- lists the breakpoints
• delete breakpoint -- deletes a specific breakpoint
• watch expression
  • Breaks execution when the expression changes value
  • Very slow, but useful
  • Example (watchme.c)

    	break main
    	run
    	watch x > 30
    	cont
    	

Getting info about the state of execution

• info - gives listing of subcommands
• info breakpoints - lists all breakpoints
• info local - lists local variables in current frame
• info args - lists args in current frame

Inspecting and modifying data

• Inspecting data: print expression
• Modifying data: set var = value
• Example:

  		print y
  		set y = 5
  		print y
  	

• Use print to call functions with side effects:

  	print frob_value(bar)
  	

Core Files

• Contain the state a program was in when it caught a signal, including stack, heap, registers, etc.
• Allows for post-mortem inspection.
• Dumping of corefiles can be turned on and off
• For Bourne shells (sh and bash)
  • ulimit -c unlimited -- turns on core files
  • ulimit -c 0 -- turns off core file generation
  • ulimit -c 50000 -- max corefile is 50k
• For C shells (csh and tcsh)
  • limit coredumpsize unlimited -- turns on core files
  • limit coredumpsize 0 -- turns off core file generation
  • limit coredumpsize 50k -- max corefile is 50k

Getting more help

• Do help to get listing of topics
• help command gives help on a command or topic
• Info files.