pkg-serializer.stanza

#use-added-syntax(fastio-serializer)
defpackage stz/pkg-serializer :
  import core
  import collections

  ;FastIO buffer utility.
  import stz/fastio-buffer
  import stz/fastio-runtime

  ;All included IRs
  import stz/typeset
  import stz/params
  import core/stack-trace
  import stz/visibility
  import stz/vm-ir
  import stz/el-ir
  import stz/dl-ir
  import stz/type-fargs
  import stz/basic-ops
  import stz/asm-ir with :
    prefix(AddOp, SubOp, MulOp, DivOp, ModOp, AndOp, OrOp, XorOp, ShlOp,
           ShrOp, AshrOp, EqOp, NeOp, LtOp, GtOp, LeOp, GeOp, UleOp,
           UltOp, UgtOp, UgeOp, NotOp, NegOp, NanEqOp, NanNeOp,
           DivModOp, BitSetOp, BitNotSetOp, LowestZeroBitCountOp,
           TestBitOp, TestAndSetBitOp, TestAndClearBitOp, SetBitOp, ClearBitOp,
           TypeofOp, XchgIns, SetIns, ConvertIns, InterpretIns, UnaOp, BinOp, VoidBinOp,
           DualOp, Load, Store, Call, Return, Goto, Break, Label, LinkLabel,
           ExLabel, Match, Dispatch, MethodDispatch, DefData, DefText, DefDirectives, DefExportLabel, DefByte,
           DefInt, DefLong, DefFloat, DefDouble, DefString, DefBytes, DefSpace, DefLabel, Comment,
           NoOp, LoadGoto, Safepoint, VarContext, NamedVar, VarMap) => asm-
  import stz/absolute-info
  import stz/trace-info
  import stz/el-trace-info

  ;Pkg imports
  import stz/pkg-ir
  import stz/pkg-errors

;============================================================
;======================= API ================================
;============================================================

;Read a .pkg file.
public defn deserialize-pkg (filename:String) -> Pkg :
  read-from-file(filename,
                 PkgSerializer(true),
                 deserialize-pkg)

;Read a .pkg file specifically for use by the REPL.
;Does not include the ASM instructions.
public defn deserialize-repl-pkg (filename:String) -> Pkg :
  read-from-file(filename,
                 PkgSerializer(false),
                 deserialize-pkg)

;Write a .pkg file.
public defn serialize-pkg (filename:String, pkg:Pkg) -> False :
  write-to-file(filename,
                PkgSerializer(true),
                serialize-pkg,
                pkg)

;============================================================
;================== Serializer Definition ===================
;============================================================

;Definition of the PkgSerializer.
defserializer PkgSerializer (include-asm?:True|False) :

  ;Start from the pkg definition.
  entry-points: (pkg)

  ;Include the primitives.
  include "serializer-primitives.spec"

  ;==========================================================
  ;====================== Pkg ===============================
  ;==========================================================
  defunion pkg (Pkg) :
    StdPkg: choose-stdpkg
    FastPkg: (stanza-version:stanza-version, packageio:packageio, exps:tuple(etexp))

  ;Choice between which stdpkg we want.
  defatom choose-stdpkg (p:StdPkg) :
    writer :
      #write[stdpkg](p)
    reader :
      if include-asm? :
        #read[stdpkg]
      else :
        ;Pkg for REPL specifically. Assembly instructions are
        ;not deserialized.
        val version = #read[stanza-version]
        val vmp = #read[vmpackage]
        #skip[opt(tuple(ins))]
        #skip[opt(tuple(vmdata))]
        StdPkg(version, vmp, false, false)        
    skip :
      #skip[stdpkg]

  deftype stdpkg (StdPkg) :
    stanza-version:stanza-version
    vmp:vmpackage
    asm?:opt(tuple(ins))
    datas?:opt(tuple(vmdata))

  ;==========================================================
  ;====================== Literals ==========================
  ;==========================================================

  defatom empty-vmtype (x:VMTypeObject) :
    writer : (#write[vmimm as CodeId](id(x)))
    reader : (VMTypeObject(#read[vmimm as CodeId]))
    skip : (#skip[vmimm])
    
  defatom empty-vmclosure (x:VMClosure) :
    writer : (#write[vmimm as CodeId](id(x)))
    reader : (VMClosure(#read[vmimm as CodeId]))
    skip : (#skip[vmimm])

  defatom interned-const (x:VMInternedConst) :
    writer : (#write[vmimm as ConstId](id(x)))
    reader : (VMInternedConst(#read[vmimm as ConstId]))
    skip : (#skip[vmimm])

  defunion lit (?) :
    Char : char
    Byte : byte
    Int : int
    Long : long
    Float : float
    Double : double
    String : string
    Symbol : symbol
    True|False : bool
    List : list(lit)
    VMTypeObject : empty-vmtype
    VMClosure : empty-vmclosure
    VMInternedConst : interned-const

  ;==========================================================
  ;======================= PackageIO ========================
  ;==========================================================
  deftype importprefix (ImportPrefix) :
    names:opt(tuple(symbol))
    prefix:string

  deftype importedpackage (ImportedPackage) :
    package-name:symbol
    forward:bool
    only:opt(tuple(symbol))
    prefix:tuple(importprefix)

  deftype packageio (PackageIO) :
    package:symbol
    imported-packages:tuple(importedpackage)
    forwarded-imports:tuple(symbol)
    direct-imports:tuple(symbol)
    imports:tuple(dimport)
    exports:tuple(dexport)
    documentation?:opt(string)

  deftype dexport (Export) :
    n:int
    visibility:visibility
    rec:drec
    info:opt(absinfo)
    documentation?:opt(string)

  deftype dimport (Import) : (n:int, rec:drec, transient?:bool)

  defunion visibility (Visibility) :
    Private: enum
    Protected: enum
    Public: enum

  ;==========================================================
  ;=============== Function Arguments =======================
  ;==========================================================

  defcombinator farg (item:T) (a:FArg<T>) :
    writer :
      match(a) :
        (a:PositionalArg<T>) :
          #write[byte](0Y)
          #write[bool](optional?(a))
          #write[item](type(a))
        (a:KeywordArg<T>) :
          #write[byte](1Y)
          #write[symbol](name(a))
          #write[bool](optional?(a))
          #write[item](type(a))
        (a:VarArg<T>) :
          #write[byte](2Y)
          #write[symbol](name(a))
          #write[item](type(a))
        (a:RestArg<T>) :
          #write[byte](3Y)
          #write[item](type(a))
    reader :
      switch(#read[byte]) :
        0Y :
          PositionalArg<T>(#read[bool], #read[item])
        1Y :
          KeywordArg<T>(#read[symbol], #read[bool], #read[item])
        2Y :
          VarArg<T>(#read[symbol], #read[item])
        3Y :
          RestArg<T>(#read[item])
        else :
          #error
    skip :
      switch(#read[byte]) :
        0Y :
          #skip[bool]
          #skip[item]
        1Y :
          #skip[symbol]
          #skip[bool]
          #skip[item]
        2Y :
          #skip[symbol]
          #skip[item]
        else :
          #error

  ;==========================================================
  ;========================= DTypes =========================
  ;==========================================================
  defunion dtype (DType) :
    DByte: ()
    DInt: ()
    DLong: ()
    DFloat: ()
    DDouble: ()
    DUnknown: ()
    DPtrT: (type:dtype)
    DFnT: (a:tuple(dtype), r:opt(dtype), b:dtype)
    DStructT: (id:drecid as TypeId, targs:tuple(dtype))
    DOf: (id:drecid as TypeId, targs:tuple(dtype))
    DTVar: (index:int)
    DCap: (tvar:dtype as DTVar)
    DAnd: (types:tuple(dtype))
    DOr: (types:tuple(dtype))
    DTop: ()
    DBot: ()
    DTuple: (types:tuple(dtype))
    DArrow: (a1:tuple(dtype), a2:dtype)

  ;==========================================================
  ;====================== DRecords ==========================
  ;==========================================================
  defunion drecid (RecId) :
    ValId: (package:symbol, name:symbol)
    TypeId: (package:symbol, name:symbol)
    FnId: (package:symbol, name:symbol, ntargs:int, ncargs:int, a1:tuple(farg(dtype)))

  defunion drec (Rec) :
    ValRec: (id:drecid as ValId, type:dtype, mutable?:bool, lostanza?:bool)
    FnRec: (id:drecid as FnId, a2:dtype, lostanza?:bool, tail?:bool)
    MultiRec: (id:drecid as FnId, a2:dtype)
    ExternFnRec: (id:drecid as FnId, a2:dtype, lbl:opt(symbol))
    ExternRec: (id:drecid as ValId, type:dtype, lbl:symbol)
    StructRec: (id:drecid as TypeId, ntargs:int, parent:opt(dtype), base:tuple(structfield), items:opt(structfield))
    TypeRec: (id:drecid as TypeId, ntargs:int, parent:opt(dtype), children:tuple(child))
    TypeDecl: (id:drecid as TypeId, ntargs:int, parent:opt(dtype), children:tuple(child))

  deftype structfield (StructField) : (name:symbol, type:dtype, mutable?:bool)

  deftype child (Child) : (id:drecid as TypeId, ntargs:int, parent:dtype as DOf)

  ;==========================================================
  ;===================== EL Datastructure ===================
  ;==========================================================
  defunion etexp (ETExp) :
    EDefGlobal: (n:int, type:etype, mutable?:bool, lostanza?:bool)
    EDefn: (n:int, func:efunction, lostanza?:bool)
    EDefClosure: (n:int, closure:int, ntargs:int, nargs:int, func:efunction)
    EDefmulti: (n:int, targs:tuple(efntarg), args:tuple(efnarg), ret:etype, dispatch:opt(dispatchmask), info:traceinfo)
    EDefmethod: (n:int, multi:int, targs:tuple(etype), func:efunction as EFn, lostanza?:bool, dispatch:opt(dispatchmask))
    EDefStruct: (n:int, parent:opt(etype), base:tuple(efield), items:opt(efield))
    EExternFn: (n:int, lbl:opt(symbol), func:efunction as EFn)
    EExtern: (n:int, lbl:symbol, type:etype)
    EInit: (body:ebody, lostanza?:bool)
    EDefType: (n:int, parent:opt(etype), children:tuple(int))
    EDefObject: (n:int, parent:etype, ntargs:int, nargs:int, methods:tuple(int))
    EDefTypeObject: (n:int, nargs:int, type:etype)

  deftype dispatchmask (DispatchMask) :
    dispatch:tuple(bool)
    indices:tuple(int)

  defunion etype (EType) :
    EByte: ()
    EInt: ()
    ELong: ()
    EFloat: ()
    EDouble: ()
    EUnknown: ()
    EPtrT: ()
    EFnT: (a:tuple(etype), r:opt(etype), b:etype)
    EStructT: (n:int)
    EOf: (n:int)
    ETVar: (n:int)
    EAnd: (a:etype, b:etype)
    EOr: (a:etype, b:etype)
    ETop: ()
    EBot: ()

  deftype efield (EDefField) : (mutable?:bool, name:symbol, type:etype)

  defunion efunction (EFunction) :
    EMultifn: (funcs:tuple(efunction as EFn))
    EFn: (tail?:bool, targs:tuple(efntarg), args:tuple(efnarg), ret:etype, body:ebody, info:traceinfo)

  deftype efnarg (EFnArg) : (n:int, arg:farg(etype), debug-name:opt(string))

  deftype efntarg (EFnTArg) : (n:int, debug-name:opt(string))

  deftype elocal (ELocal) :
    n:int
    type:etype
    mutable?:bool
    debug-name:opt(string)

  deftype elocaltype (ELocalType) : (n:int)

  deftype elocalfn (ELocalFn) : (n:int, func:efunction, debug-name:opt(string))

  deftype elocalobj (ELocalObj) : (n:int, type:etype, methods:tuple(emethod))

  deftype emethod (EMethod) : (n:int, multi:int, targs:tuple(etype), thisn:int, func:efunction as EFn, dispatch:opt(dispatchmask))

  deftype ebody (EBody) : (locals:tuple(elocal), localtypes:tuple(elocaltype), localfns:tuple(elocalfn), localobjs:tuple(elocalobj), ins:tuple(eins))

  defunion eimm (EImm) :
    ELSLiteral: (value:lit)
    ELiteral: (value:lit)
    EVar: (n:int, info:traceinfo, name:opt(string))
    ECurry: (x:eimm as EVar, targs:tuple(etype))
    ESizeof: (type:etype)
    ETagof: (n:int)
    EConstClosure: (n:int)
    EConstType: (n:int)
    EMix: (funcs:tuple(eimm as EInstFn))
    EInstFn: (n:int, name:opt(string), info:traceinfo, pattern:argpattern, capvars:tuple(etype),
              a1:tuple(etype), a2:etype)

  deftype argpattern (ArgPattern) :
    num-args:int
    args:tuple(farg(argusage))  

  defunion argusage (ArgUsage) :
    GivenArg: (index:int)
    MissingArg: ()
    GivenArgs: (indices:tuple(int))

  defunion eloc (ELoc) :
    EVarLoc: (n:int)
    EDeref: (y:eimm)
    EDeptr: (y:eimm)
    EField: (loc:eloc, n:int, index:int)
    ESlot: (loc:eloc, type:etype, index:eimm)

  deftype etvarloc (ETVarLoc) : (n:int)

  defunion eins (EIns) :
    EDef: (x:eloc as EVarLoc, y:opt(eimm), info:traceinfo)
    EInitClosures: (xs:tuple(eloc as EVarLoc), info:traceinfo)
    ENew: (x:eloc as EVarLoc, n:int, info:traceinfo)
    ETuple: (x:eloc as EVarLoc, ys:tuple(eimm), info:traceinfo)
    EVoidTuple: (x:eloc as EVarLoc, length:int, info:traceinfo)
    ETupleGet: (x:eloc as EVarLoc, y:eimm, index:int, info:traceinfo)
    ETupleSet: (y:eimm, index:int, z:eimm)
    EObject: (x:eloc as EVarLoc, n:int, ys:tuple(eimm), info:traceinfo)
    EArray: (x:eloc as EVarLoc, n:int, ys:tuple(eimm), info:traceinfo)
    EStruct: (x:eloc as EVarLoc, n:int, ys:tuple(eimm))
    EPtr: (x:eloc as EVarLoc, loc:eloc)
    ELoad: (x:eloc as EVarLoc, xtype:etype, loc:eloc)
    EStore: (loc:eloc, y:eimm, ytype:etype, info:traceinfo)
    ELabel: (n:int)
    ETCall: (f:eimm, ys:tuple(eimm), calltype:calltype, info:traceinfo)
    ECall: (x:opt(eloc as EVarLoc), f:eimm, ys:tuple(eimm), calltype:calltype, info:traceinfo)
    EDump: (ys:tuple(eimm))
    EInterpret: (x:eloc as EVarLoc, y:eimm)
    EConv: (x:eloc as EVarLoc, y:eimm)
    EGoto: (n:int)
    EPrim: (x:opt(eloc as EVarLoc), op:eop, ys:tuple(eimm), info:traceinfo)
    EIf: (n1:int, n2:int, op:opt(eop), ys:tuple(eimm))
    EMatch: (ys:tuple(eimm), branches:tuple(ebranch), info:traceinfo)
    EDispatch: (ys:tuple(eimm), branches:tuple(ebranch), info:traceinfo)
    ECheckLength: (y:eimm, length:int, info:traceinfo)
    ECheck: (y:eimm, type:etype, ctxt:error-ctxt, info:traceinfo)
    ECheckSet: (y:eimm, name:opt(string), info:traceinfo)
    EReturn: (y:eimm)
    ETDef: (x:etvarloc, y:union(eimm,etype))
    ESafepoint: (group-id:int, info:traceinfo)
    EEnd: (info:traceinfo)
    ETypeof: (n1:int, n2:int, type:etype, y:eimm)

  deftype ebranch (EBranch) : (types:tuple(etype), n:int, info:traceinfo)

  defunion calltype (CallType) :
    CallGuarded: (a1:tuple(etype), a2:etype)
    CallC: ()
    CallStanza: ()
    CallPtr: ()

  defunion eop (EOp) :
    IntAddOp: ()
    IntSubOp: ()
    IntMulOp: ()
    IntDivOp: ()
    IntModOp: ()
    IntAndOp: ()
    IntOrOp: ()
    IntXorOp: ()
    IntNotOp: ()
    IntShlOp: ()
    IntShrOp: ()
    IntAshrOp: ()
    IntLtOp: ()
    IntGtOp: ()
    IntLeOp: ()
    IntGeOp: ()
    IntNegOp: ()
    RefEqOp: ()
    RefNeOp: ()
    AddOp: ()
    SubOp: ()
    MulOp: ()
    DivOp: ()
    ModOp: ()
    AndOp: ()
    OrOp: ()
    XorOp: ()
    NotOp: ()
    ShlOp: ()
    ShrOp: ()
    AshrOp: ()
    NegOp: ()
    EqOp: ()
    NeOp: ()
    LtOp: ()
    GtOp: ()
    LeOp: ()
    GeOp: ()
    UleOp: ()
    UltOp: ()
    UgtOp: ()
    UgeOp: ()
    LowestZeroBitCountOp: ()
    TestBitOp: ()
    TestAndSetBitOp: ()
    TestAndClearBitOp: ()
    SetBitOp: ()
    ClearBitOp: ()
    FlushVMOp: ()
    GCOp: ()
    PrintStackTraceOp: ()
    CollectStackTraceOp: ()
    EnterStackOp: ()
    YieldOp: ()
    CRSPOp: ()

  defunion error-ctxt (CastErrorContext) :
    CastContext: ()
    ArgContext: ()
    ReturnContext: ()
    DefContext: ()
    SetContext: ()
    FuncContext: ()
    DetupleContext: ()
    GetVarContext: ()
    BranchContext: ()

  ;==========================================================
  ;=================== VM Datastructure =====================
  ;==========================================================
  deftype vmpackage (VMPackage) :
    packageio:packageio
    init:opt(int)
    globals:tuple(vmglobal)
    datas:tuple(vmdata)
    consts:tuple(vmconst)
    classes:tuple(vmclass)
    funcs:tuple(vmdefn)
    methods:tuple(vmmethod)
    externs:tuple(vmextern)
    extern-defns:tuple(vmexterndefn)
    debug-name-table:debug-name-table
    debug-table:debug-info-table
    safepoint-table:safepoint-table

  deftype debug-name-table (VMDebugNameTable) :
    entries: tuple(debug-name)

  deftype debug-name (VMDebugName) :
    id:int
    global?:bool
    name:string

  deftype safepoint-table (VMSafepointTable) :
    files:tuple(file-safepoints)
    
  deftype file-safepoints (VMFileSafepoints) :
    base:string
    filename:string
    entries:tuple(safepoint-info)

  deftype safepoint-info (VMSafepointInfo) :
    id:int
    line:int
    column:int
    group:int

  deftype debug-info-table (VMDebugInfoTable) :
    entries:tuple(debug-info)

  deftype debug-info (VMDebugInfo) :
    id:int
    name:opt(string)
    info:opt(absinfo)

  defunion vmimm (VMImm) :
    Local: (index:int)
    NumConst: (value:lit)
    Marker: (typeid:int)
    Tag: (typeid:int)
    CodeId: (id:int)
    ExternId: (id:int)
    ExternDefnId: (id:int)
    GlobalId: (id:int)
    DataId: (id:int)
    ConstId: (id:int)
    VoidMarker: ()

  defunion vmtype (VMType) :
    VMByte: ()
    VMInt: ()
    VMLong: ()
    VMFloat: ()
    VMDouble: ()
    VMRef: ()

  defunion vmfunc (VMFunction) :
    VMMultifn: (arg:int, funcs:tuple(func-entry), default:vmfunc as VMFunc)
    VMFunc: (args:tuple(func-arg), defs:tuple(vmdef), ins:tuple(vmins), debug-name-table:debug-name-table)

  defunion func-arg (Local|VMType) :
    Local: vmimm as Local
    VMType: vmtype

  deftype func-entry (KeyValue<Int,VMFunc>) : keyvalue(int,vmfunc as VMFunc)

  deftype vmextern (VMExtern) : (id:int, name:symbol)

  deftype vmglobal (VMGlobal) : (id:int, size:int, roots:tuple(int))

  deftype vmdata (VMData) : (id:int, data:bytearray)

  deftype vmconst (VMConst) : (id:int, value:lit)

  deftype vmdef (VMDef) : (id:int, type:vmtype, local:int)

  deftype vmdefn (VMDefn) : (id:int, dependencies:tuple(int), func:vmfunc)

  deftype vmexterndefn (VMExternDefn) : (lbl:opt(symbol), fid:int, a1:tuple(vmtype), a2:vmtype)

  deftype vmmethod (VMMethod) : (instance?:bool, multi:int, types:tuple(typeset), fid:int)

  defunion vmclass (VMClass) :
    VMArrayClass: (id:int, name:string, dependencies:tuple(int), parents:tuple(int),
                   base-size:int, item-size:int, base-roots:tuple(int), item-roots:tuple(int),
                   base-root-names:tuple(symbol), item-root-names:tuple(symbol))
    VMLeafClass: (id:int, name:string, dependencies:tuple(int), parents:tuple(int), size:int,
                  roots:tuple(int), root-names:tuple(symbol))
    VMAbstractClass: (id:int, parents:tuple(int), children:tuple(int))

  defunion vmins (VMIns) :
    CallIns: (xs:tuple(func-arg), f:vmimm, ys:tuple(vmimm), trace-entry:opt(trace-entry))
    CallClosureIns: (xs:tuple(func-arg), f:vmimm, ys:tuple(vmimm), trace-entry:opt(trace-entry))
    TCallIns: (f:vmimm, ys:tuple(vmimm))
    TCallClosureIns: (f:vmimm, ys:tuple(vmimm))
    CallCIns: (xs:tuple(func-arg), f:vmimm, ys:tuple(vmimm), trace-entry:opt(trace-entry))
    YieldIns: (enter?:bool, xs:tuple(func-arg), f:vmimm, ys:tuple(vmimm), trace-entry:opt(trace-entry))
    SetIns: (x:vmimm as Local, y:vmimm)
    Op0Ins: (x:opt(vmimm as Local), op:vmop)
    Op1Ins: (x:opt(vmimm as Local), op:vmop, y:vmimm)
    Op2Ins: (x:opt(vmimm as Local), op:vmop, y:vmimm, z:vmimm)
    LabelIns: (n:int)
    GotoIns: (n:int)
    Branch0Ins: (n1:int, n2:int, op:vmop)
    Branch1Ins: (n1:int, n2:int, op:opt(vmop), x:vmimm)
    Branch2Ins: (n1:int, n2:int, op:vmop, x:vmimm, y:vmimm)
    DispatchIns: (ys:tuple(vmimm), branches:tuple(vmbranch), default:int, amb:int)
    MatchIns: (ys:tuple(vmimm), branches:tuple(vmbranch), default:int)
    MethodDispatchIns: (multi:int, ys:tuple(vmimm), zs:tuple(vmimm), default:int, amb:int)
    AllocIns: (xs:tuple(vmimm as Local), types:tuple(int), sizes:tuple(vmimm), trace-entry:opt(trace-entry))
    StoreIns: (x:vmimm, y:opt(vmimm), offset:int, z:vmimm, class:opt(int))
    StoreWithBarrierIns: (x:vmimm, y:opt(vmimm), offset:int, z:vmimm, class:int)
    LoadIns: (x:vmimm as Local, y:vmimm, z:opt(vmimm), offset:int, class:opt(int))
    ReturnIns: (xs:tuple(vmimm))
    DumpIns: (xs:tuple(vmimm as Local))
    RecordLiveIns: (live:tuple(vmimm as Local))
    LiveIns: (xs:tuple(vmimm))
    CommentIns: (message:string)
    UnreachableIns: ()
    SafepointIns: (id:int, trace-entry!:trace-entry)

  deftype vmbranch (VMBranch) : (types:tuple(typeset), n:int)

  defunion vmop (VMOp) :
    IntAddOp: ()
    IntSubOp: ()
    IntMulOp: ()
    IntDivOp: ()
    IntModOp: ()
    IntAndOp: ()
    IntOrOp: ()
    IntXorOp: ()
    IntNotOp: ()
    IntShlOp: ()
    IntShrOp: ()
    IntAshrOp: ()
    IntLtOp: ()
    IntGtOp: ()
    IntLeOp: ()
    IntGeOp: ()
    IntNegOp: ()
    RefEqOp: ()
    RefNeOp: ()
    AddOp: ()
    SubOp: ()
    MulOp: ()
    DivOp: ()
    ModOp: ()
    AndOp: ()
    OrOp: ()
    XorOp: ()
    NotOp: ()
    ShlOp: ()
    ShrOp: ()
    AshrOp: ()
    NegOp: ()
    EqOp: ()
    NeOp: ()
    LtOp: ()
    GtOp: ()
    LeOp: ()
    GeOp: ()
    UleOp: ()
    UltOp: ()
    UgtOp: ()
    UgeOp: ()
    LowestZeroBitCountOp: ()
    TestBitOp: ()
    TestAndSetBitOp: ()
    TestAndClearBitOp: ()
    SetBitOp: ()
    ClearBitOp: ()
    FlushVMOp: ()
    GCOp: ()
    PrintStackTraceOp: ()
    CollectStackTraceOp: ()
    InstanceofOp: (type:typeset)
    TagOp: (type:int)
    DetagOp: (type:int)
    ConvOp: ()
    InterpretOp: ()
    DerefOp: ()
    CRSPOp: ()

  deftype trace-entry (StackTraceInfo) : (package:symbol, signature:opt(string), info:opt(absinfo))

  ;==========================================================
  ;================== Assembly Types ========================
  ;==========================================================
  defunion asm-type (ASMType) :
    ByteT: ()
    IntT: ()
    LongT: ()
    FloatT: ()
    DoubleT: ()

  ;==========================================================
  ;================ Assembly Operations =====================
  ;==========================================================
  defunion op (Op) :
    asm-AddOp: ()
    asm-SubOp: ()
    asm-MulOp: ()
    asm-DivOp: ()
    asm-ModOp: ()
    asm-AndOp: ()
    asm-OrOp: ()
    asm-XorOp: ()
    asm-ShlOp: ()
    asm-ShrOp: ()
    asm-AshrOp: ()
    asm-EqOp: ()
    asm-NeOp: ()
    asm-LtOp: ()
    asm-GtOp: ()
    asm-LeOp: ()
    asm-GeOp: ()
    asm-UleOp: ()
    asm-UltOp: ()
    asm-UgtOp: ()
    asm-UgeOp: ()
    asm-NotOp: ()
    asm-NegOp: ()
    asm-NanEqOp: ()
    asm-NanNeOp: ()
    asm-DivModOp: ()
    asm-BitSetOp: ()
    asm-BitNotSetOp: ()
    asm-LowestZeroBitCountOp: ()
    asm-TestBitOp: ()
    asm-TestAndSetBitOp: ()
    asm-TestAndClearBitOp: ()
    asm-SetBitOp: ()
    asm-ClearBitOp: ()
    asm-TypeofOp: (tag:typeset)

  ;==========================================================
  ;================= Assembly Immediates ====================
  ;==========================================================
  defunion imm (Imm) :
    IntImm: (value:lit as Byte|Int|Long)
    Mem: (n:int, offset:int)
    ExMem: (lbl:symbol, offset:int)
    LocalMem: (n:int)
    TagImm: (n:int, marker?:bool)
    LinkId: (id:int)
    StackMap: (size:int, indices:tuple(int))
    RegSP: ()
    Reg: (n:int)
    FReg: (n:int)

  deftype loc (Loc) : imm as Loc

  ;==========================================================
  ;================ Assembly Instructions ===================
  ;==========================================================
  defunion ins (Ins) :
    asm-VarContext: (id:int, entries:tuple(named-var))
    asm-XchgIns: (x:loc, y:loc)
    asm-SetIns: (type:asm-type, x:loc, y:imm)
    asm-ConvertIns: (xtype:asm-type, x:loc, ytype:asm-type, y:imm)
    asm-InterpretIns: (xtype:asm-type, x:loc, ytype:asm-type, y:imm)
    asm-NoOp: ()
    asm-UnaOp: (type:asm-type, x:loc, op:op, y:imm)
    asm-BinOp: (type:asm-type, x:loc, op:op, y:imm, z:imm)
    asm-VoidBinOp: (type:asm-type, op:op, y:imm, z:imm)
    asm-DualOp: (type:asm-type, x1:loc, x2:loc, op:op, y:imm, z:imm)
    asm-Load: (type:asm-type, x:loc, y:imm, offset:int)
    asm-Store: (type:asm-type, x:imm, y:imm, offset:int)
    asm-Call: (x:imm)
    asm-Return: ()
    asm-Goto: (x:imm)
    asm-LoadGoto: (x:imm)
    asm-Break: (type:asm-type, x:imm, op:op, y:imm, z:imm)
    asm-Label: (n:int, trace-entry:opt(trace-entry))
    asm-Safepoint: (id:int, trace-entry:trace-entry, varmap:var-map)
    asm-LinkLabel: (id:int)
    asm-ExLabel: (name:symbol)
    asm-Match: (xs:list(imm), branches:list(branch), no-branch:imm)
    asm-Dispatch: (xs:list(imm), branches:list(branch), no-branch:imm, amb-branch:imm)
    asm-MethodDispatch: (multi:int, num-header-args:int, no-branch:imm, amb-branch:imm)
    asm-DefData: ()
    asm-DefText: ()
    asm-DefDirectives: ()
    asm-DefExportLabel: (value:symbol)
    asm-DefByte: (value:byte)
    asm-DefInt: (value:int)
    asm-DefLong: (value:long)
    asm-DefFloat: (value:float)
    asm-DefDouble: (value:double)
    asm-DefString: (value:string)
    asm-DefBytes: (value:bytearray)
    asm-DefSpace: (size:int)
    asm-DefLabel: (n:int)
    asm-Comment: (msg:string)

  defunion named-var (asm-NamedVar) :
    asm-NamedVar: (stack-offset:int, name:string)

  defunion var-map (asm-VarMap) :
    asm-VarMap: (context:int, vars:tuple(int))

  deftype branch (Branch) : (tags:list(typeset), dst:imm)

  ;==========================================================
  ;======================= Typeset ==========================
  ;==========================================================
  defunion typeset (TypeSet) :
    AndType: (types:tuple(typeset))
    OrType: (types:tuple(typeset))
    SingleType: (type:int)
    TopType: ()

  ;==========================================================
  ;=================== Version Check ========================
  ;==========================================================
  defatom stanza-version (xs:Tuple<Int>) :
    writer :
      #write[tuple(int)](xs)
    reader :      
      val xs = #read[tuple(int)]
      if not valid-stanza-version-format?(xs) :
        #error
      if xs != STANZA-VERSION :
        throw(WrongPkgVersion(false, xs, STANZA-VERSION))
      xs
    skip :
      #skip[tuple(int)]

  ;==========================================================
  ;===================== Atoms ==============================
  ;==========================================================

  deftype absinfo (AbsoluteFileInfo) :
    base:string
    filename:string
    line:int
    column:int

  defunion traceinfo (TraceInfo) :
    StackTraceInfo: trace-entry
    AbsoluteFileInfo: absinfo
    False: bool as False