ref: b548687a8ed1d0a159c9d3f3f921d93bbb56908e
dir: /appl/cmd/limbo/limbo.m/
include "sys.m";
include "math.m";
include "string.m";
include "bufio.m";
include "isa.m";
include "workdir.m";
# internal dis ops
IEXC: con MAXDIS;
IEXC0: con (MAXDIS+1);
INOOP: con (MAXDIS+2);
# temporary
LDT: con 1;
STemp: con NREG * IBY2WD;
RTemp: con STemp + IBY2WD;
DTemp: con RTemp + IBY2WD;
MaxTemp: con DTemp + IBY2WD;
MaxReg: con 1 << 16;
MaxAlign: con IBY2LG;
StrSize: con 256;
MaxIncPath: con 32; # max directories in include path
MaxScope: con 64; # max nested {}
MaxInclude: con 32; # max nested include ""
ScopeBuiltin,
ScopeNils,
ScopeGlobal: con iota;
Line: type int;
PosBits: con 10;
PosMask: con (1 << PosBits) - 1;
Src: adt
{
start: Line;
stop: Line;
};
File: adt
{
name: string;
abs: int; # absolute line of start of the part of file
off: int; # offset to line in the file
in: int; # absolute line where included
act: string; # name of real file with #line fake file
actoff: int; # offset from fake line to real line
sbl: int; # symbol file number
};
Val: adt
{
idval: ref Sym;
ival: big;
rval: real;
};
Tok: adt
{
src: Src;
v: Val;
};
#
# addressing modes
#
Aimm, # immediate
Amp, # global
Ampind, # global indirect
Afp, # activation frame
Afpind, # frame indirect
Apc, # branch
Adesc, # type descriptor immediate
Aoff, # offset in module description table
Anoff, # above encoded as a -ve
Aerr, # error
Anone, # no operand
Aldt, # linkage descriptor table immediate
Aend: con byte iota;
Addr: adt
{
reg: int;
offset: int;
decl: cyclic ref Decl;
};
Inst: adt
{
src: Src;
op: int; # could be a byte
pc: int;
reach: byte; # could a control path reach this instruction?
sm: byte; # operand addressing modes
mm: byte;
dm: byte;
s: cyclic Addr; # operands
m: cyclic Addr;
d: cyclic Addr;
branch: cyclic ref Inst; # branch destination
next: cyclic ref Inst;
block: int; # blocks nested inside
};
Case: adt
{
nlab: int;
nsnd: int;
offset: int; # offset in mp
labs: cyclic array of Label;
wild: cyclic ref Node; # if nothing matches
iwild: cyclic ref Inst;
};
Label: adt
{
node: cyclic ref Node;
isptr: int; # true if the labelled alt channel is a pointer
start: cyclic ref Node; # value in range [start, stop) => code
stop: cyclic ref Node;
inst: cyclic ref Inst;
};
#
# storage classes
#
Dtype,
Dfn,
Dglobal,
Darg,
Dlocal,
Dconst,
Dfield,
Dtag, # pick tags
Dimport, # imported identifier
Dunbound, # unbound identified
Dundef,
Dwundef, # undefined, but don't whine
Dend: con iota;
Decl: adt
{
src: Src; # where declaration
sym: cyclic ref Sym; # name
store: int; # storage class
nid: byte; # block grouping for locals
inline: byte; # inline function
handler: byte; # fn has exception handler(s)
das: byte; # declared with :=
dot: cyclic ref Decl; # parent adt or module
ty: cyclic ref Type;
refs: int; # number of references
offset: int;
tag: int; # union tag
scope: int; # in which it was declared
next: cyclic ref Decl; # list in same scope, field or argument list, etc.
old: cyclic ref Decl; # declaration of the symbol in enclosing scope
eimport: cyclic ref Node; # expr from which imported
importid: cyclic ref Decl; # identifier imported
timport: cyclic ref Decl; # stack of identifiers importing a type
init: cyclic ref Node; # data initialization
tref: int; # 1 => is a tmp; >=2 => tmp in use
cycle: byte; # can create a cycle
cyc: byte; # so labelled in source
cycerr: byte; # delivered an error message for cycle?
implicit: byte; # implicit first argument in an adt?
iface: cyclic ref Decl; # used external declarations in a module
locals: cyclic ref Decl; # locals for a function
link: cyclic ref Decl; # pointer to parent function or function argument or local share or parent type dec
pc: cyclic ref Inst; # start of function
# endpc: cyclic ref Inst; # limit of function - unused
# should be able to move this to Type
desc: ref Desc; # heap descriptor
};
Desc: adt
{
id: int; # dis type identifier
used: int; # actually used in output?
map: array of byte; # byte map of pointers
size: int; # length of the object
nmap: int; # length of good bytes in map
next: cyclic ref Desc;
};
Dlist: adt
{
d: ref Decl;
next: cyclic ref Dlist;
};
Except: adt
{
p1: ref Inst; # first pc covered
p2: ref Inst; # last pc not covered
c: ref Case; # exception case instructions
d: ref Decl; # exception definition if any
zn: ref Node; # list of nodes to zero in handler
desc: ref Desc; # descriptor map for above
ne: int; # number of exceptions (ie not strings) in case
next: cyclic ref Except;
};
Sym: adt
{
token: int;
name: string;
hash: int;
next: cyclic ref Sym;
decl: cyclic ref Decl;
unbound: cyclic ref Decl; # place holder for unbound symbols
};
#
# ops for nodes
#
Oadd,
Oaddas,
Oadr,
Oadtdecl,
Oalt,
Oand,
Oandand,
Oandas,
Oarray,
Oas,
Obreak,
Ocall,
Ocase,
Ocast,
Ochan,
Ocomma,
Ocomp,
Ocondecl,
Ocons,
Oconst,
Ocont,
Odas,
Odec,
Odiv,
Odivas,
Odo,
Odot,
Oelem,
Oeq,
Oexcept,
Oexdecl,
Oexit,
Oexp,
Oexpas,
Oexstmt,
Ofielddecl,
Ofnptr,
Ofor,
Ofunc,
Ogeq,
Ogt,
Ohd,
Oif,
Oimport,
Oinc,
Oind,
Oindex,
Oinds,
Oindx,
Oinv,
Ojmp,
Olabel,
Olen,
Oleq,
Oload,
Olsh,
Olshas,
Olt,
Omdot,
Omod,
Omodas,
Omoddecl,
Omul,
Omulas,
Oname,
Oneg,
Oneq,
Onot,
Onothing,
Oor,
Ooras,
Ooror,
Opick,
Opickdecl,
Opredec,
Opreinc,
Oraise,
Orange,
Orcv,
Oref,
Oret,
Orsh,
Orshas,
Oscope,
Oself,
Oseq,
Oslice,
Osnd,
Ospawn,
Osub,
Osubas,
Otagof,
Otl,
Otuple,
Otype,
Otypedecl,
Oused,
Ovardecl,
Ovardecli,
Owild,
Oxor,
Oxoras,
Oend: con iota + 1;
#
# moves
#
Mas,
Mcons,
Mhd,
Mtl,
Mend: con iota;
#
# addressability
#
Rreg, # v(fp)
Rmreg, # v(mp)
Roff, # $v
Rnoff, # $v encoded as -ve
Rdesc, # $v
Rdescp, # $v
Rconst, # $v
Ralways, # preceeding are always addressable
Radr, # v(v(fp))
Rmadr, # v(v(mp))
Rcant, # following are not quite addressable
Rpc, # branch address
Rmpc, # cross module branch address
Rareg, # $v(fp)
Ramreg, # $v(mp)
Raadr, # $v(v(fp))
Ramadr, # $v(v(mp))
Rldt, # $v
Rend: con byte iota;
Const: adt
{
val: big;
rval: real;
};
PARENS: con 1;
TEMP: con 2;
FNPTRA: con 8; # argument 4->8
FNPTR2: con 16; # 2nd parameter 8->16
FNPTRN: con 32; # use -ve offset 16->32
FNPTR: con FNPTRA|FNPTR2|FNPTRN;
Node: adt
{
src: Src;
op: int;
addable: byte;
flags: byte;
temps: byte;
left: cyclic ref Node;
right: cyclic ref Node;
ty: cyclic ref Type;
decl: cyclic ref Decl;
c: ref Const; # for Oconst
};
#
# types visible to limbo
#
Tnone,
Tadt,
Tadtpick, # pick case of an adt
Tarray,
Tbig, # 64 bit int
Tbyte, # 8 bit unsigned int
Tchan,
Treal,
Tfn,
Tint, # 32 bit int
Tlist,
Tmodule,
Tref,
Tstring,
Ttuple,
Texception,
Tfix,
Tpoly,
#
# internal use types
#
Tainit, # array initializers
Talt, # alt channels
Tany, # type of nil
Tarrow, # unresolved ty->ty types
Tcase, # case labels
Tcasel, # case big labels
Tcasec, # case string labels
Tdot, # unresolved ty.id types
Terror,
Tgoto, # goto labels
Tid, # id with unknown type
Tiface, # module interface
Texcept, # exception handler tables
Tinst, # instantiated adt
Tend: con iota;
#
# marks for various phases of verifing types
#
OKbind, # type decls are bound
OKverify, # type looks ok
OKsized, # started figuring size
OKref, # recorded use of type
OKclass, # equivalence class found
OKcyc, # checked for cycles
OKcycsize, # checked for cycles and size
OKmodref: # started checking for a module handle
con byte 1 << iota;
OKmask: con byte 16rff;
#
# recursive marks
#
TReq,
TRcom,
TRcyc,
TRvis:
con byte 1 << iota;
# type flags
FULLARGS: con byte 1; # all hidden args added
INST: con byte 2; # instantiated adt
CYCLIC: con byte 4; # cyclic type
POLY: con byte 8; # polymorphic types inside
NOPOLY: con byte 16; # no polymorphic types inside
# must put some picks in here
Type: adt
{
src: Src;
kind: int;
ok: byte; # set when type is verified
varargs: byte; # if a function, ends with vargs?
linkall: byte; # put all iface fns in external linkage?
rec: byte; # in the middle of recursive type
pr: byte; # in the middle of printing a recursive type
cons: byte; # exception constant
flags: byte;
sbl: int; # slot in .sbl adt table
sig: int; # signature for dynamic type check
size: int; # storage required, in bytes
align: int; # alignment in bytes
decl: cyclic ref Decl;
tof: cyclic ref Type;
ids: cyclic ref Decl;
tags: cyclic ref Decl;# tagged fields in an adt
polys: cyclic ref Decl;# polymorphic fields in fn or adt
cse: cyclic ref Case;# case or goto labels
teq: cyclic ref Type;# temporary equiv class for equiv checking
tcom: cyclic ref Type;# temporary equiv class for compat checking
eq: cyclic ref Teq; # real equiv class
eraises: cyclic ref Node; # for Tfn only
val: cyclic ref Node; # for Tfix, Tfn, Tadt only
tlist: cyclic ref Typelist; # for Tinst only
tmap: cyclic ref Tpair; # for Tadt only
};
#
# type equivalence classes
#
Teq: adt
{
id: int; # for signing
ty: cyclic ref Type;# an instance of the class
eq: cyclic ref Teq; # used to link eq sets
};
Tattr: adt
{
isptr: int;
refable: int;
conable: int;
isbig: int;
vis: int; # type visible to users
};
Tpair: adt
{
t1: cyclic ref Type;
t2: cyclic ref Type;
nxt: cyclic ref Tpair;
};
Typelist: adt
{
t: cyclic ref Type;
nxt: cyclic ref Typelist;
};
Sother, Sloop, Sscope : con iota;