<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>Parrot - The Parrot Bytecode (PBC) Format</title>
<link rel="stylesheet" type="text/css"
href="../../resources/parrot.css"
media="all">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
</head>
<body>
<div id="wrapper">
<div id="header">
<a href="http://www.parrot.org">
<img border=0 src="../../resources/parrot_logo.png" id="logo" alt="parrot">
</a>
</div> <!-- "header" -->
<div id="divider"></div>
<div id="mainbody">
<div id="breadcrumb">
<a href="../../html/index.html">Home</a> » <a href="../../html/developer.html">Developer Documentation</a> » The Parrot Bytecode (PBC) Format
</div>
<h1><a name="NAME"
>NAME</a></h1>
<p>docs/parrotbyte.pod - The Parrot Bytecode (PBC) Format</p>
<h1><a name="Format_of_the_Parrot_bytecode"
>Format of the Parrot bytecode</a></h1>
<p>The 18-byte header consists of:</p>
<pre> 0 7
+----------+----------+----------+----------+
| Parrot Magic = 0x 13155a1 |
+----------+----------+----------+----------+</pre>
<p><b>Magic</b> is stored in native byteorder. The loader uses the byteorder header to convert the Magic to verify. More specifically, ALL words (non-bytes) in the bytecode file are stored in native order, unless otherwise specified.</p>
<pre> 8 9 10 11
+----------+----------+----------+
| Wordsize | Byteorder| FloatType|
+----------+----------+----------+</pre>
<p>The <b>Wordsize</b> (or <code>opcode_t</code> size) must be 4 (32-bit) or 8 (64 bit). The bytecode loader is responsible for transforming the file into the VM native wordsize on the fly. For performance, a utility <em>pbc_dump</em> is provided to convert PBCs on disk if they cannot be recompiled. See <em><a href="../src/pbc_dump.c.html">src/pbc_dump.c</a></em> for more information.</p>
<p><b>Byteorder</b> currently supports two values: (0-Little Endian, 1-Big Endian)</p>
<p><b>FloatType</b> 0 is IEEE 754 8 byte double, FloatType 1 is i386 little endian 12 byte long double.</p>
<pre> 11 12 13 14 15 16
+----------+----------+----------+----------+----------+
| Major | Minor | Patch | BC Major | BC Minor |
+----------+----------+----------+----------+----------+</pre>
<p><b>Major</b>, <b>Minor</b>, <b>Patch</b> for the version of Parrot that wrote the bytecode file.</p>
<p><b>BC Major</b> and <b>BC Minor</b> are for the internal bytecode version.</p>
<pre> 16 17 18 19 20 21 22
+----------+----------+----------+----------+----------+----------+
| UUID type| UUID size| *UUID data |
+----------+----------+----------+----------+----------+----------+</pre>
<p>After the UUID type and size comes the UUID data pointer.</p>
<pre> 22*
+----------+----------+----------+----------+
| dir_format (1) |
+----------+----------+----------+----------+
| padding (0) |
+----------+----------+----------+----------+</pre>
<p><b>dir_format</b> has length opcode_t and value 1 for PBC FORMAT 1, defined in <em>packfile.h</em></p>
<h1><a name="PBC_FORMAT_1"
>PBC FORMAT 1</a></h1>
<p>All segments are aligned at a 16 byte boundary. All segments share a common header and are kept in directories, which itself is a PBC segment. All offsets and sizes are in native opcodes of the machine that produced the PBC.</p>
<p>After the PBC header, the first PBC directory follows at offset 24* starting with a:</p>
<h2><a name="Format_1_Segment_Header"
>Format 1 Segment Header</a></h2>
<pre> +----------+----------+----------+----------+
| total size in opcodes including this size |
+----------+----------+----------+----------+
| internal type (itype) |
+----------+----------+----------+----------+
| internal id (id) |
+----------+----------+----------+----------+
| size of opcodes following |
+----------+----------+----------+----------+</pre>
<p>The <b>size</b> entry may be followed by a stream of <b>size</b> opcodes (starting 16 byte aligned), which may of course be no opcode stream at all for size zero.</p>
<p>After this common segment header there can be segment specific data determined by the segment type. A segment without additional data, like the bytecode segment, is a <b>default</b> segment. No additional routines are required to unpack such a segment.</p>
<h2><a name="Directory_Segment"
>Directory Segment</a></h2>
<pre> +----------+----------+----------+----------+
| number of directory entries |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
| segment type |
+----------+----------+----------+----------+
| segment name ... |
| ... 0x00 padding |
+----------+----------+----------+----------+
| segment offset |
+----------+----------+----------+----------+
| segment op_count |
+----------+----------+----------+----------+</pre>
<p>The <b>op_count</b> at <b>offset</b> must match the segments <b>op_count</b> and is used to verify the PBCs integrity.</p>
<p>Currently these segment types are defined:</p>
<dl>
<dt><a name="0"
>0</a></dt>
Directory segment
<dt><a name="1"
>1</a></dt>
Unknown segment (conforms to a default segment)
<dt><a name="2"
>2</a></dt>
Fixup segment
<dt><a name="3"
>3</a></dt>
Constant table segment
<dt><a name="4"
>4</a></dt>
Bytecode segment
<dt><a name="5"
>5</a></dt>
Debug segment</dl>
<h2><a name="Segment_Names"
>Segment Names</a></h2>
<p>This is not determined yet.</p>
<h2><a name="Unknown_(default)_and_byte_code_segments"
>Unknown (default) and byte code segments</a></h2>
<p>These have only the common segment header and the opcode stream appended. The opcode stream is an <em>mmap()</em>ed memory region, if your operating system supports this (and if the PBC was read from a disk file). You have therefore to consider these data as readonly.</p>
<h2><a name="Fixup_segment"
>Fixup segment</a></h2>
<pre> +----------+----------+----------+----------+
| number of fixup entries |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
| fixup type (0) |
+----------+----------+----------+----------+
| label name ... |
| ... 0x00 padding |
+----------+----------+----------+----------+
| label offset |
+----------+----------+----------+----------+</pre>
<p>Fixup type <b>0</b>, known as enum_fixup_label, has a label symbol and an offset into the bytecode.</p>
<p>Fixup type <b>1</b>, known as enum_fixup_sub, has a label symbol that is the name of the "sub" and an offset into the constant table, referencing a Sub, Closure or Coroutine PMC.</p>
<h2><a name="Debug_Segment"
>Debug Segment</a></h2>
<p>The opcode stream will contain one line number per bytecode instruction. No information as to what file that line is from will be stored in this stream.</p>
<p>The header will start with a count of the number of source file to bytecode position mappings that are in the header.</p>
<pre> 0 (relative)
+----------+----------+----------+----------+
| number of source => bytecode mappings |
+----------+----------+----------+----------+</pre>
<p>A source to bytecode position mapping simply states that the bytecode that starts from the specified offset up until the offset in the next mapping, or if there is none up until the end of the bytecode, has it's source in location X.</p>
<p>A mapping always starts with the offset in the bytecode, followed by the type of the mapping.</p>
<pre> 0 (relative)
+----------+----------+----------+----------+
| bytecode offset |
+----------+----------+----------+----------+
4
+----------+----------+----------+----------+
| mapping type |
+----------+----------+----------+----------+</pre>
<p>There are 3 mapping types.</p>
<p>Type <b>0</b> means there is no source available for the bytecode starting at the given offset. No further data is stored with this type of mapping; the next mapping continues immediately after it.</p>
<p>Type <b>1</b> means the source is available in a file. An index into the constants table follows, which will point to a string containing the filename.</p>
<p>Type <b>2</b> means the source is available in a source segment. Another integer follows, which will specify which source file in the source segment to use.</p>
<p>Note that the ordering of the offsets into the bytecode must be sequential; a mapping for offset 100 cannot follow a mapping for offset 200, for example.</p>
<h2><a name="CONSTANT_TABLE_SEGMENT"
>CONSTANT TABLE SEGMENT</a></h2>
<pre> 0 (relative)
+----------+----------+----------+----------+
| Constant Count (N) |
+----------+----------+----------+----------+</pre>
<p>For each constant:</p>
<pre> +----------+----------+----------+----------+
| Constant Type (T) |
+----------+----------+----------+----------+
| |
| S bytes of constant content |
: appropriate for representing :
| a value of type T |
| |
+----------+----------+----------+----------+</pre>
<h2><a name="CONSTANTS"
>CONSTANTS</a></h2>
<p>For integer constants:</p>
<pre> << integer constants are represented as manifest constants in
the byte code stream currently, limiting them to 32 bit values. >></pre>
<p>For number constants (S is constant, and is equal to <code>sizeof(FLOATVAL)</code>):</p>
<pre> +----------+----------+----------+----------+
| |
| S' bytes of Data |
| |
+----------+----------+----------+----------+</pre>
<p>where</p>
<pre> S' = S + (S % 4) ? (4 - (S % 4)) : 0</pre>
<p>If S' > S, then the extra bytes are filled with zeros.</p>
<p>For string constants (S varies, and is the size of the particular string):</p>
<pre> 4, 4 + (16 + S'0), 4 + (16 + S'0) + (16 + S'1)
+----------+----------+----------+----------+
| Flags |
+----------+----------+----------+----------+
| Encoding |
+----------+----------+----------+----------+
| Type |
+----------+----------+----------+----------+
| Size (S) |
+----------+----------+----------+----------+
| |
: S' bytes of Data :
| |
+----------+----------+----------+----------+</pre>
<p>where</p>
<pre> S' = S + (S % 4) ? (4 - (S % 4)) : 0</pre>
<p>If S' > S, then the extra bytes are filled with zeros.</p>
<h2><a name="BYTE_CODE_SEGMENT"
>BYTE CODE SEGMENT</a></h2>
<p>The pieces that can be found in the byte code segment are as follows:</p>
<pre> +----------+----------+----------+----------+
| Operation Code |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
| Register Argument |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
| Integer Argument (Manifest Constant) |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
| String Argument (Constant Table Index) |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
| Number Argument (Constant Table Index) |
+----------+----------+----------+----------+
+----------+----------+----------+----------+
| PMC Argument (Constant Table Index) |
+----------+----------+----------+----------+</pre>
<p>The number of arguments and the type of each argument can usually be determined by consulting Parrot::Opcode, or programmatically by obtaining the op_info_t structure for the opcode in question.</p>
<p>There are currently 4 opcodes that can take a variable number of arguments: set_args, get_params, set_returns and get_results. These ops always have one required argument, which is a PMC constant. Calling the elements VTABLE function on this PMC will give the number of extra variable arguments that follow.</p>
<h2><a name="SOURCE_CODE_SEGMENT"
>SOURCE CODE SEGMENT</a></h2>
<p>Currently there are no utilities that use this segment, even though it is mentioned in some of the early Parrot documents.</p>
<h1><a name="SEE_ALSO"
>SEE ALSO</a></h1>
<p><em>packfile.c</em>, <em>packfile.h</em>, <em>packout.c</em>, <em>packdump.c</em>, <em>pf/*.c</em>, and the <b>pbc_dump</b> utility <em>pbc_dump.c</em>.</p>
</div> <!-- "mainbody" -->
<div id="divider"></div>
<div id="footer">
Copyright © 2002-2009, Parrot Foundation.
</div>
</div> <!-- "wrapper" -->
</body>
</html>
distrib
>
Mandriva
>
2010.0
>
i586
>
media
>
contrib-release
>
by-pkgid
>
cd14cddf3b3ceaf1193157472227757a
>
files
>
129
