# Copyright (C) 2001-2009, Parrot Foundation.

=head1 NAME

docs/debugger.pod - The Parrot Debugger

=head1 ABSTRACT

This document describes F<parrot_debugger>, the Parrot Debugger.

=head1 DESCRIPTION

Starting from version 0.0.6 Parrot has its own debugger, which is modeled after
Perl's one. Its name is F<parrot_debugger>, and is an interactive environment
that let you step through bytecode, set breakpoints, evaluate assembly
instructions and peek at the interpreter status.

A good (well, at least some) knowledge of the Parrot internals is obviously
required to read this document. Some familiarity with debugging principles is
also mandatory beyond this point.


=head1 BUILDING parrot_debugger

The debugger is built along with Parrot when you run 'make', but if you want to build 
*only* the debugger, then you can run:

  make parrot_debugger

Which will create a new parrot_debugger executable in the same directory as the parrot
executable.

=head1 THE DEBUGGER SHELL

To start the debugger type:

  parrot_debugger file.pbc

That is, F<parrot_debugger> takes exactly one argument, which is the Parrot file that
you're going to debug. This file may be Parrot bytecode (*.pbc), PASM source code (*.pasm)
or PIR (*.pir). F<parrot_debugger> will automatically load and disassemble the
bytecode file for you.

Note that you can't pass command line arguments to your program when you invoke
the debugger. See the C<run (r)> command below for this.

After the version banner, you'll see the friendly debugger prompt:

  (pdb)

F<parrot_debugger> is ready to receive commands and give output. To list the
available commands type 'h'. To quit the debugger type 'q'.

As with the Perl debugger, whenever it halts and shows you a line of code, it
is always the line it's I<about> to execute, not the one that it has just
executed.

=head1 DEBUGGER COMMANDS

Always remember that you can enter 'h' to get a list of commands (this document
may be outdated in respect to the actual debugger, so let it speak for itself).

Most commands can be shortened to their first letter. When available, this is
signaled by the letter in parentheses after the command name Thus, C<help (h)>
means that the command can be given as 'help' or just 'h'. On the other hand,
C<load> can only be given as 'load', verbatim.  Debugger commands are case
sensitive (LOAD is not a valid command) but Parrot register names are not.

A blank line always repeats the last command entered.

Also note that at this point in its development, F<parrot_debugger> has very
poor error checking on commands and their arguments, so type carefully or
something bad will happen. Feel free to report bugs, or better yet patch the
source code (see L</FILES> below).

=over 4

=item assign

Assign to a Parrot register. For example:

    (pdb)    a I0 42

        I0 = 42

    (pdb)    a N1 3.14

        N1 = 3.14

The first command sets I0 to 42 and the second sets N1 to 3.14. Register names are not
case sensitive, so you can use either i0 or I0 .

=item disassemble

Disassemble a loaded bytecode file. This will turn a file loaded with C<load>
into proper Parrot assembler.

=item load

Load a source code (assembler) file. The syntax is:

  load FILE

=item list (l)

List the source code. The syntax is:

  list [FROM] [NUM]

Both arguments are optional. By default C<FROM> is from where the last list
command ended (or the first line if this is the first invocation) and C<NUM> is
10. That is, it lists the source code ten lines at a time.

Note that the disassembled source code is not the same as the original source
code: labels take the names C<L1 .. Ln> and opcodes are fully qualified (eg.
C<set_i_ic> instead of just C<set>). See also C<eval (e)>.

Example:

  # lists the first three source code lines
  (pdb) l 1 3
  1  set_i_ic I1,0
  2  L3:  print_sc "fact of "
  3  print_i I1

=item run (r)

Run (or restart) the program. The syntax is:

  run [ARGUMENTS]

Any arguments you give are passed as command line arguments to the program (ie.
they populate P0).

After the program has ended, you can run it again with this command. See also
the C<continue (c)> command.

Example:

  (pdb) r
  Restarting
  fact of 0 is: 1
  fact of 1 is: 1
  fact of 2 is: 2
  fact of 3 is: 6
  fact of 4 is: 24
  fact of 5 is: 120
  fact of 6 is: 720
  Program exited.

=item break (b)

Add a breakpoint. The syntax is:

  b LINE [if CONDITION]

If you want a conditional breakpoint you should first specify the register that
is involved in the condition (at least one must be), the comparison and then
the third argument can be either another register or a constant, which must be
of the same type as the first register specified.

The command returns a number which is the breakpoint identifier. You should
note this number for the C<delete (d)> command (see below).

Example:

  # sets a breakpoint on line 10 (will be breakpoint 0)
  (pdb) b 10
  Breakpoint 0 at line 10

  # another breakpoint on line 11 (will be breakpoint 1)
  (pdb) b 11
  Breakpoint 1 at line 11

  # break at line 4 if I16 is less than or equal to 123456
  (pdb) b 4 if I16 <= 123456
  Breakpoint 2 at line 4

  # break at line 4 if N27 is greater than 5.23
  (pdb) b 5 if N27 > 5.23
  Breakpoint 3 at line 5

  # break at line 4 if S2 is equal to S13
  (pdb) b 6 if S2 == S13
  Breakpoint 4 at line 6

  # break at line 4 if S5 is equal to "stop"
  (pdb) b 7 if S2 == "stop"
  Breakpoint 5 at line 7

=item watch (w)

Add a watchpoint. The syntax is:

  w CONDITION

The condition has the same format as in C<break>

=item delete (d)

Delete a breakpoint. The syntax is:

  d NUM

The C<NUM> argument is the breakpoint number (from 0 to N) as emitted by the
C<break (b)> command. It is NOT the line that has the breakpoint.

Example:

  # delete the first breakpoint (was on line 10, see example above)
  (pdb) d 0

=item disable

Disable a breakpoint. The syntax is the same as for the C<delete> command.
Disabled breakpoints can be re-enabled with C<enable>.

=item enable

Re-enable a disabled breakpoint. The syntax is:

  enable [NUM]

where C<NUM> is the number of the breakpoint.

=item continue (c)

Continue the program execution. The syntax of this command is:

  continue [NUM]

Without arguments, the command just runs the source code until a breakpoint is
found (or until the end of the program).

If you specify a number, it will skip the next C<NUM> breakpoints it
encounters.

When the program has ended, continue will do nothing. Use C<run (r)> to execute
it again.

=item next (n)

Run the next instruction. The syntax is:

  next [NUM]

C<NUM> defaults to 1, but you can give a number of instructions to execute
before stopping again.

=item eval (e)

The eval command is currently unimplemeneted.

Run an instruction. The syntax is:

  eval INSTRUCTION


Example:

  (pdb) e set I0, 42

  (pdb) e print I0
  42

  (pdb) p i
  I0 =           42
  I1 =            0
  ...

=item trace (t)

Trace the next instruction. The syntax is:

  trace [NUM]

It executes the next C<NUM> instructions (default is 1) just as C<next (n)>
does, but printing additional trace information. This is the same as the
information you get when running Parrot with the C<-t> option.

Example:

  # executes 2 instructions and trace them
  (pdb) t 2
  PC=0; OP=67 (set_i_ic); ARGS=(I1=0, 0)
  PC=3; OP=24 (print_sc); ARGS=("fact of ")
  fact of
  3  print_i I1

=item print (p)

Print the interpreter registers. Register names are not case sensitive. The syntax is:

  print VALUE

C<VALUE> may be:

=over 4

=item A register name: C<I3>

Prints out the single register specified.

=item A register type: C<i>, C<n>, C<s>, or C<p>

Prints out all registers of the given type

=item An aggregate key: C<P0[1]>

Looks up the given (integer- or string-valued) key in a PMC register.

=back

For PMC registers, the command will print the number, the class of the PMC (in
square brackets) and its string representation (when available). It prints
<PMCNULL> for uninitialized PMC registers.

Examples:

  # prints the content of I2
  (pdb) p i2
  I2 =              0

  # prints the content of P0
  (pdb) p P0
  P0 = [ResizablePMCArray]

  # prints the content of all string registers
  (pdb) p s
   S0 = Just
   S1 = Another
   S2 = Parrot
   S3 = Hacker

=item info

Print interpreter information.

Example:

  (pdb) info
  Total memory allocated = 81936
  GC mark runs = 6
  GC collect runs = 0
  Active PMCs = 8197
  Active buffers = 7
  Total PMCs = 21840
  Total buffers = 48
  Header allocations since last collect = 0
  Memory allocations since last collect = 2

=item quit (q)

Exit the debugger.

=item help (h)

Prints information about debugger commands. The syntax is:

  help [COMMAND]

If C<COMMAND> is omitted, prints a list of the available commands.

=back

=head1 FILES

=over 4

=item src/parrot_debugger.c

This is the file that will produce the executable.  Nothing fancy here, it
mostly consists of the C<main> function.

=item src/debug.c

Most of the debugger is implemented here.  You may want to start from the
C<PDB_run_command> function and go down from there for the real meat.

=item src/embed.c

C<Parrot_debug>, the function which launches the debugger, is implemented here.

=item include/parrot/debugger.h

This defines all the PDB structures, which hold data used by the debugger.

=back

=head1 HISTORY

=over 4

=item Version 1.0

First version (SVN debug.c revision 1.24), authored by Aldo Calpini

=back

