SBL(6)SBL(6)NAME
sbl - symbol table file
DESCRIPTION
A Limbo symbol table file provides type information for the module in
an associated Dis executable file, for use by debuggers and similar
applications. They are written by the Limbo compiler when given the -g
option. The files conventionally have a .sbl suffix; they need not be
stored in the same directory as the corresponding Dis file.
The file consists of a header followed by five tables:
header file-table pc-table type-table fn-table data-table
Each table starts with a line containing a decimal count of the items
in that table. The count can be zero. The following sections describe
the format of table items in each table. In the description, the fol‐
lowing terminals are used.
A string is a sequence of letters, digits, and the characters _, ., -,
and >. Letters are the Unicode characters a through z and A through Z,
and all Unicode characters with encoded values greater than A0 hexadec‐
imal.
An int is an optional minus sign followed by a sequence of digits, 0 to
9.
In the following description, the presence of a space is represented by
· and a newline by \n. There are no other spaces between syntactic
elements in the file format. Other special characters represent them‐
selves.
Header
The header consists of two items.
header:
magic\n
module\n
magic:
limbo .sbl 2.0
module:
string
There have been two previous versions of symbol table format, distin‐
guished by the number in magic. Version 1. was the original; version
1.1 added more references back to the source; and version 2.0 replaced
the original adt table by a type table and added support for Limbo's
pick construction. Only version 2.0 is described here; the others are
obsolete.
Module is the name of the module implemented in the Dis file. Symbol
file references to identifiers declared by the implementation module
are unqualified. A name referenced that is imported from any other
module is preceded by m-> where m is that module's identifier.
File table
The file table is a list of file names referenced by the rest of the
tables. Each file name is terminated by a newline character; within the
name, any character other than a newline is valid.
PC table
The PC table relates every instruction in the Dis file to the source
from which it was compiled. The table is indexed by Dis PC to obtain a
reference to the corresponding source. Each item consists of a source
description and a statement reference:
pc-item:
src stmt \n
src:
pos,pos·
pos:
file:opt line.opt char
file, line, char, stmt:
int
A source description src selects source text as a range of characters
within lines of a source file. File is an index into the file table
(origin 0); line and char are positions within that source file, with
line numbers starting at 1 and character positions at 0. If file or
line is omitted, it is assumed to have the previous value, or 0 if
there is no previous value.
Stmt is the `statement number' of the instruction. Despite its name,
the scope of a statement number is smaller than a Limbo statement: it
identifies a region marked by the compiler for treatment as a unit when
debugging. For instance, in a for statement, the initial expression,
increment, test, and body all have unique statement numbers. All
instructions compiled from the same region in a Limbo program have the
same statement number. The number is that of the innermost region that
contains the instruction.
Type table
The type table describes the Limbo adts used in the Dis file, both
locally declared and imported. Each entry describes a type:
type:
@ type-index \n
a adt-item
p adt-item tag-table
t size . id-table
m module \n src
A type
C type
F fn-name type
L type
R type
n
N
B
b
i
f
s
type-index:
int
Each leading character specifies a different Limbo type:
@ existing type referenced by type table index (not self-ref‐
erential)
A array of type
a adt without pick
B big
b byte
C chan of type
F fn returning type
f real
i int
L list of type
m module
N nil's type
n no type (eg, function with no return type)
p adt with pick
R ref type
s string
t tuple
A type-index is an offset in the type table, representing the corre‐
sponding type. Size is the size in bytes of a value of the given type.
The size of basic types is known and does not appear explicitly: big
and real are 64 bits; all others including strings and reference types
are 4 bytes. (Strings are represented internally by a pointer.)
Each id-table is preceded by a count of the number of entries, followed
by an id-item for each entry in the table:
id-table:
count \n id-items
id-item:
id-offset : id-name : src type \n
id-offset:
int
id-name:
string
count:
int
Id-offset is the number of bytes from the start of the enclosing object
to the value of the object identified by id-name.
An adt without a pick clause is described using an adt-item:
adt-item:
adt-name · src size \n id-table
adt-name:
string
size:
int
The id-table has an entry for every data element of adt-name.
If an adt has a pick clause, the adt's type table entry uses the p type
character. The invariant part of the adt is described by an adt-item
(with zero size) and the variant clause is described by a tag-table of
the following form:
tag-table:
count \n tag-items
tag-item:
name : src size \n id-table
| name : src \n
The tag-table describes the variants of a Limbo adt that includes a
pick clause. The name is the pick tag for the associated alternative.
If the size and id-table are missing, the given variant has the same
description as the previous one.
A tuple's id-table contains id-names of the form tn, where n is the
0-origin index of the item in the tuple.
Src is as previously defined above in the PC table section.
Fn table
The function table describes each function implemented by the Dis file.
fn-item:
fn-pc : fn-name \n args locals return
fn-pc:
int
fn-name:
string
args, locals:
id-table
return:
type
Fn-pc is the starting pc for the Dis instructions for fn-name. If the
function is a member of an adt, the member name is qualified by the adt
name, so that fn-name has the form `adt-name.member-name'. Within the
id-tables for args and locals, the id-offset fields give offsets rela‐
tive to the function's activation frame. Furthermore, no table entries
are made for args that are declared nil (unused).
Data table
The data table describes the global variables in the Dis file. It is an
id-table, with one entry for each global variable.
SEE ALSOlimbo(1), wm-deb(1), debug(2), dis(6)SBL(6)