This chapter contains a condensed list of PASM opcodes, PIR directives and instructions, and Parrot command-line options, sorted alphabetically for easy reference. Any PASM opcode is valid in PIR code, so if you're looking up PIR syntax, you should check Section 11.1, Section 11.2, and Section 11.3.
This excerpt is from Perl 6 and Parrot Essentials. This book is an unparalleled sneak-peek of what's coming in the widely-anticipated Perl 6. It uncovers groundbreaking new developments in Parrot--the interpreter engine that will execute code written in the new Perl 6 language and the most revolutionary change in the language itself--Apocalypse 12 on objects. It also includes expanded coverage of Apocalypse 5 (regular expressions) and Apocalypse 6 (subroutines).
We've followed a few conventions.
DEST is always the register where the result of
the operation is stored. Sometimes the original value of
DEST is one of the source values.
VAL indicates that the
actual value might be a literal integer, float, or string, or a
register containing an integer, float, string, or PMC. See the
.ops files for the combinations
allowed with a particular operation.
This is a summary of PIR directives. Directives are preprocessed by the Parrot interpreter. Since PIR and PASM run on the same interpreter, many of the directives listed here are also valid in PASM code.
Since Parrot is both an assembler
and a bytecode interpreter, it has options to control both
behaviors. Some options may have changed by the time you read this,
especially options related to debugging and optimization. The
have the latest details. Or just run
file is either an
source file or a Parrot bytecode file. Parrot creates an
Array object to hold the command-line
arguments and stores it
P5 on program start.
Assume PASM input on
stdin. When Parrot runs a source file with a
.pasm extension, it parses the file
as pure PASM code. This switch turns on PASM parsing (instead of
the default PIR parsing) when a source file is read from
Assume PBC file on
Parrot runs a bytecode file with a
.pbc extension, it immediately executes the file.
This option tells Parrot to immediately execute a bytecode file
piped in on
Turn on debugging output. The
switch takes an optional argument, which is a hex value of debug
bits. (The individual bits are shown in Table 11-3.) When
hexbits isn't specified, the
default debugging level is 0001. If
hexbits is separated from the
-d switch by whitespace, it has to
start with a number.
Table 11-3. Debug bits
$ parrot -d 0ffff . . .
Show debug option bits.
Print a short summary of options to
stdout and exit.
Act like an assembler. With this switch, Parrot won't run code
unless it's combined with the
switch. If the name of
outputfile ends with a
.pbc extension, Parrot writes a Parrot bytecode
.pasm extension, Parrot writes
a PASM source file, even if the input file was also PASM. This can
be handy to check various optimizations when you run Parrot with
If the extension is
equivalent, Parrot generates an object file from the JITed program
code, which can be used to create a standalone executable program.
This isn't available on all platforms yet; see
PLATFORMS for which platforms support this.
Immediately execute bytecode. This is the default unless
-o is present. The combination of
output.pbc writes a bytecode file and
executes the generated PBC.
-v switch (
-v) shows which
files are worked on and prints a summary of register usage and
optimization statistics. Two
-v) also prints a
line for each individual processing step.
Show output of macro expansions and quit.
Print the program version to
Turn on optimizations. The flags currently implemented are shown in Table 11-4.
Table 11-4. Optimizations
No optimization (default).
Optimizations without life info (e.g., branches and constants).
Optimizations with life info.
Optimize function call sequence.
Rearrange PASM registers with the most-used first.
The interpreter options are mainly for selecting which run-time core to use for interpreting bytecode. The current default is the computed goto core if it's available. Otherwise, the fast core is used.
Activate bounds checking. This also runs with the slow core as a side effect.
Run with the fast core.
Run the computed goto core (CGoto).
Run with the JIT core if available.
Activate profiling. This prints a summary of opcode usage and execution times after the program stops. It also runs within the slow core.
Run with the CGoto-Prederefed core.
Run with the Prederefed core.
Run with the Switched core.
Trace execution. This also turns on the slow core.
Turn on warnings.
Turn off DOD/GC. This is for debugging only.
Wait for a keypress before running.
Clean up allocated memory when the final interpreter is destroyed. Parrot destroys created interpreters (e.g., threads) on exit but doesn't normally free all memory for the last terminating interpreter, since the operating system will do this anyway. This can create false positives when Parrot is run with a memory leak detector. To prevent this, use this option.
If you enjoyed this excerpt, buy a copy of Perl 6 and Parrot Essentials
Copyright © 2009 O'Reilly Media, Inc.