diff options
Diffstat (limited to 'src/cmd/gc/go.h')
-rw-r--r-- | src/cmd/gc/go.h | 1279 |
1 files changed, 1279 insertions, 0 deletions
diff --git a/src/cmd/gc/go.h b/src/cmd/gc/go.h new file mode 100644 index 000000000..da0fb5146 --- /dev/null +++ b/src/cmd/gc/go.h @@ -0,0 +1,1279 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +#include <u.h> +#include <libc.h> +#include <bio.h> + +#undef OAPPEND + +// avoid <ctype.h> +#undef isblank +#define isblank goisblank + +#ifndef EXTERN +#define EXTERN extern +#endif + +#undef BUFSIZ + +enum +{ + NHUNK = 50000, + BUFSIZ = 8192, + NSYMB = 500, + NHASH = 1024, + STRINGSZ = 200, + YYMAXDEPTH = 500, + MAXALIGN = 7, + UINF = 100, + HISTSZ = 10, + + PRIME1 = 3, + + AUNK = 100, + + // these values are known by runtime + AMEM = 0, + ANOEQ, + ASTRING, + AINTER, + ANILINTER, + ASLICE, + AMEM8, + AMEM16, + AMEM32, + AMEM64, + AMEM128, + ANOEQ8, + ANOEQ16, + ANOEQ32, + ANOEQ64, + ANOEQ128, + + BADWIDTH = -1000000000, +}; + +extern vlong MAXWIDTH; + +/* + * note this is the representation + * of the compilers string literals, + * it is not the runtime representation + */ +typedef struct Strlit Strlit; +struct Strlit +{ + int32 len; + char s[3]; // variable +}; + +/* + * note this is the runtime representation + * of hashmap iterator. it is probably + * insafe to use it this way, but it puts + * all the changes in one place. + * only flag is referenced from go. + * actual placement does not matter as long + * as the size is >= actual size. + */ +typedef struct Hiter Hiter; +struct Hiter +{ + uchar data[8]; // return val from next + int32 elemsize; // size of elements in table */ + int32 changes; // number of changes observed last time */ + int32 i; // stack pointer in subtable_state */ + uchar last[8]; // last hash value returned */ + uchar h[8]; // the hash table */ + struct + { + uchar sub[8]; // pointer into subtable */ + uchar start[8]; // pointer into start of subtable */ + uchar end[8]; // pointer into end of subtable */ + uchar pad[8]; + } sub[4]; +}; + +enum +{ + Mpscale = 29, // safely smaller than bits in a long + Mpprec = 16, // Mpscale*Mpprec is max number of bits + Mpnorm = Mpprec - 1, // significant words in a normalized float + Mpbase = 1L << Mpscale, + Mpsign = Mpbase >> 1, + Mpmask = Mpbase - 1, + Mpdebug = 0, +}; + +typedef struct Mpint Mpint; +struct Mpint +{ + long a[Mpprec]; + uchar neg; + uchar ovf; +}; + +typedef struct Mpflt Mpflt; +struct Mpflt +{ + Mpint val; + short exp; +}; + +typedef struct Mpcplx Mpcplx; +struct Mpcplx +{ + Mpflt real; + Mpflt imag; +}; + +typedef struct Val Val; +struct Val +{ + short ctype; + union + { + short reg; // OREGISTER + short bval; // bool value CTBOOL + Mpint* xval; // int CTINT + Mpflt* fval; // float CTFLT + Mpcplx* cval; // float CTCPLX + Strlit* sval; // string CTSTR + } u; +}; + +typedef struct Pkg Pkg; +typedef struct Sym Sym; +typedef struct Node Node; +typedef struct NodeList NodeList; +typedef struct Type Type; +typedef struct Label Label; + +struct Type +{ + uchar etype; + uchar chan; + uchar recur; // to detect loops + uchar trecur; // to detect loops + uchar printed; + uchar embedded; // TFIELD embedded type + uchar siggen; + uchar funarg; + uchar copyany; + uchar local; // created in this file + uchar deferwidth; + uchar broke; + uchar isddd; // TFIELD is ... argument + uchar align; + + Node* nod; // canonical OTYPE node + Type* orig; // original type (type literal or predefined type) + int lineno; + + // TFUNCT + uchar thistuple; + uchar outtuple; + uchar intuple; + uchar outnamed; + + Type* method; + Type* xmethod; + + Sym* sym; + int32 vargen; // unique name for OTYPE/ONAME + + Node* nname; + vlong argwid; + + // most nodes + Type* type; + vlong width; // offset in TFIELD, width in all others + + // TFIELD + Type* down; // also used in TMAP + Strlit* note; // literal string annotation + + // TARRAY + int32 bound; // negative is dynamic array + + int32 maplineno; // first use of TFORW as map key + int32 embedlineno; // first use of TFORW as embedded type +}; +#define T ((Type*)0) + +struct Node +{ + uchar op; + uchar ullman; // sethi/ullman number + uchar addable; // type of addressability - 0 is not addressable + uchar trecur; // to detect loops + uchar etype; // op for OASOP, etype for OTYPE, exclam for export + uchar class; // PPARAM, PAUTO, PEXTERN, etc + uchar method; // OCALLMETH name + uchar embedded; // ODCLFIELD embedded type + uchar colas; // OAS resulting from := + uchar diag; // already printed error about this + uchar noescape; // ONAME never move to heap + uchar funcdepth; + uchar builtin; // built-in name, like len or close + uchar walkdef; + uchar typecheck; + uchar local; + uchar initorder; + uchar dodata; // compile literal assignment as data statement + uchar used; + uchar isddd; + uchar pun; // don't registerize variable ONAME + uchar readonly; + uchar implicit; // don't show in printout + + // most nodes + Node* left; + Node* right; + Type* type; + Type* realtype; // as determined by typecheck + NodeList* list; + NodeList* rlist; + Node* orig; // original form, for printing, and tracking copies of ONAMEs + + // for-body + NodeList* ninit; + Node* ntest; + Node* nincr; + NodeList* nbody; + + // if-body + NodeList* nelse; + + // cases + Node* ncase; + + // func + Node* nname; + Node* shortname; + NodeList* enter; + NodeList* exit; + NodeList* cvars; // closure params + NodeList* dcl; // autodcl for this func/closure + + // OLITERAL/OREGISTER + Val val; + + // ONAME + Node* ntype; + Node* defn; + Node* pack; // real package for import . names + Node* curfn; // function for local variables + + // ONAME func param with PHEAP + Node* heapaddr; // temp holding heap address of param + Node* stackparam; // OPARAM node referring to stack copy of param + Node* alloc; // allocation call + + // ONAME closure param with PPARAMREF + Node* outer; // outer PPARAMREF in nested closure + Node* closure; // ONAME/PHEAP <-> ONAME/PPARAMREF + + // OPACK + Pkg* pkg; + + Sym* sym; // various + int32 vargen; // unique name for OTYPE/ONAME + int32 lineno; + int32 endlineno; + vlong xoffset; + int32 stkdelta; // offset added by stack frame compaction phase. + int32 ostk; + int32 iota; +}; +#define N ((Node*)0) +EXTERN int32 walkgen; + +struct NodeList +{ + Node* n; + NodeList* next; + NodeList* end; +}; + +enum +{ + SymExport = 1<<0, + SymPackage = 1<<1, + SymExported = 1<<2, + SymUniq = 1<<3, + SymSiggen = 1<<4, +}; + +struct Sym +{ + ushort lexical; + uchar flags; + uchar sym; // huffman encoding in object file + Sym* link; + int32 npkg; // number of imported packages with this name + + // saved and restored by dcopy + Pkg* pkg; + char* name; // variable name + Node* def; // definition: ONAME OTYPE OPACK or OLITERAL + Label* label; // corresponding label (ephemeral) + int32 block; // blocknumber to catch redeclaration + int32 lastlineno; // last declaration for diagnostic +}; +#define S ((Sym*)0) + +EXTERN Sym* dclstack; + +struct Pkg +{ + char* name; + Strlit* path; + Sym* pathsym; + char* prefix; + Pkg* link; + char exported; // import line written in export data + char direct; // imported directly +}; + +typedef struct Iter Iter; +struct Iter +{ + int done; + Type* tfunc; + Type* t; + Node** an; + Node* n; +}; + +typedef struct Hist Hist; +struct Hist +{ + Hist* link; + char* name; + int32 line; + int32 offset; +}; +#define H ((Hist*)0) + +enum +{ + OXXX, + + // names + ONAME, + ONONAME, + OTYPE, + OPACK, + OLITERAL, + + // exprs + OADD, OSUB, OOR, OXOR, OADDSTR, + OADDR, + OANDAND, + OAPPEND, + OARRAY, + OARRAYBYTESTR, OARRAYRUNESTR, + OSTRARRAYBYTE, OSTRARRAYRUNE, + OAS, OAS2, OAS2MAPW, OAS2FUNC, OAS2RECV, OAS2MAPR, OAS2DOTTYPE, OASOP, + OBAD, + OCALL, OCALLFUNC, OCALLMETH, OCALLINTER, + OCAP, + OCLOSE, + OCLOSURE, + OCMPIFACE, OCMPSTR, + OCOMPLIT, OMAPLIT, OSTRUCTLIT, OARRAYLIT, + OCONV, OCONVIFACE, OCONVNOP, + OCOPY, + ODCL, ODCLFUNC, ODCLFIELD, ODCLCONST, ODCLTYPE, + ODOT, ODOTPTR, ODOTMETH, ODOTINTER, OXDOT, + ODOTTYPE, + ODOTTYPE2, + OEQ, ONE, OLT, OLE, OGE, OGT, + OIND, + OINDEX, OINDEXMAP, + OKEY, OPARAM, + OLEN, + OMAKE, OMAKECHAN, OMAKEMAP, OMAKESLICE, + OHMUL, ORRC, OLRC, // high-mul and rotate-carry + OMUL, ODIV, OMOD, OLSH, ORSH, OAND, OANDNOT, + ONEW, + ONOT, OCOM, OPLUS, OMINUS, + OOROR, + OPANIC, OPRINT, OPRINTN, + OPAREN, + OSEND, + OSLICE, OSLICEARR, OSLICESTR, + ORECOVER, + ORECV, + ORUNESTR, + OSELRECV, + OSELRECV2, + OIOTA, + OREAL, OIMAG, OCOMPLEX, + + // stmts + OBLOCK, + OBREAK, + OCASE, OXCASE, + OCONTINUE, + ODEFER, + OEMPTY, + OFALL, OXFALL, + OFOR, + OGOTO, + OIF, + OLABEL, + OPROC, + ORANGE, + ORETURN, + OSELECT, + OSWITCH, + OTYPESW, // l = r.(type) + + // types + OTCHAN, + OTMAP, + OTSTRUCT, + OTINTER, + OTFUNC, + OTARRAY, + OTPAREN, + + // misc + ODDD, + + // for back ends + OCMP, ODEC, OEXTEND, OINC, OREGISTER, OINDREG, + + OEND, +}; +enum +{ + Txxx, // 0 + + TINT8, TUINT8, // 1 + TINT16, TUINT16, + TINT32, TUINT32, + TINT64, TUINT64, + TINT, TUINT, TUINTPTR, + + TCOMPLEX64, // 12 + TCOMPLEX128, + + TFLOAT32, // 14 + TFLOAT64, + + TBOOL, // 16 + + TPTR32, TPTR64, // 17 + + TFUNC, // 19 + TARRAY, + T_old_DARRAY, + TSTRUCT, // 22 + TCHAN, + TMAP, + TINTER, // 25 + TFORW, + TFIELD, + TANY, + TSTRING, + TUNSAFEPTR, + + // pseudo-types for literals + TIDEAL, // 31 + TNIL, + TBLANK, + + // pseudo-type for frame layout + TFUNCARGS, + TCHANARGS, + TINTERMETH, + + NTYPE, +}; +enum +{ + CTxxx, + + CTINT, + CTFLT, + CTCPLX, + CTSTR, + CTBOOL, + CTNIL, +}; + +enum +{ + /* types of channel */ + /* must match ../../pkg/nreflect/type.go:/Chandir */ + Cxxx, + Crecv = 1<<0, + Csend = 1<<1, + Cboth = Crecv | Csend, +}; + +enum +{ + Pxxx, + + PEXTERN, // declaration context + PAUTO, + PPARAM, + PPARAMOUT, + PPARAMREF, // param passed by reference + PFUNC, + + PHEAP = 1<<7, +}; + +enum +{ + Etop = 1<<1, // evaluated at statement level + Erv = 1<<2, // evaluated in value context + Etype = 1<<3, + Ecall = 1<<4, // call-only expressions are ok + Efnstruct = 1<<5, // multivalue function returns are ok + Eiota = 1<<6, // iota is ok + Easgn = 1<<7, // assigning to expression + Eindir = 1<<8, // indirecting through expression + Eaddr = 1<<9, // taking address of expression + Eproc = 1<<10, // inside a go statement + Ecomplit = 1<<11, // type in composite literal +}; + +#define BITS 5 +#define NVAR (BITS*sizeof(uint32)*8) + +typedef struct Bits Bits; +struct Bits +{ + uint32 b[BITS]; +}; + +EXTERN Bits zbits; + +typedef struct Var Var; +struct Var +{ + vlong offset; + Sym* sym; + Sym* gotype; + Node* node; + int width; + char name; + char etype; + char addr; +}; + +EXTERN Var var[NVAR]; + +typedef struct Typedef Typedef; +struct Typedef +{ + char* name; + int etype; + int sameas; +}; + +extern Typedef typedefs[]; + +typedef struct Sig Sig; +struct Sig +{ + char* name; + Pkg* pkg; + Sym* isym; + Sym* tsym; + Type* type; + Type* mtype; + int32 offset; + Sig* link; +}; + +typedef struct Io Io; +struct Io +{ + char* infile; + Biobuf* bin; + int32 ilineno; + int nlsemi; + int eofnl; + int peekc; + int peekc1; // second peekc for ... + char* cp; // used for content when bin==nil + int importsafe; +}; + +typedef struct Dlist Dlist; +struct Dlist +{ + Type* field; +}; + +typedef struct Idir Idir; +struct Idir +{ + Idir* link; + char* dir; +}; + +/* + * argument passing to/from + * smagic and umagic + */ +typedef struct Magic Magic; +struct Magic +{ + int w; // input for both - width + int s; // output for both - shift + int bad; // output for both - unexpected failure + + // magic multiplier for signed literal divisors + int64 sd; // input - literal divisor + int64 sm; // output - multiplier + + // magic multiplier for unsigned literal divisors + uint64 ud; // input - literal divisor + uint64 um; // output - multiplier + int ua; // output - adder +}; + +typedef struct Prog Prog; + +struct Label +{ + uchar used; + Sym* sym; + Node* def; + NodeList* use; + Label* link; + + // for use during gen + Prog* gotopc; // pointer to unresolved gotos + Prog* labelpc; // pointer to code + Prog* breakpc; // pointer to code + Prog* continpc; // pointer to code +}; +#define L ((Label*)0) + +/* + * note this is the runtime representation + * of the compilers arrays. + * + * typedef struct + * { // must not move anything + * uchar array[8]; // pointer to data + * uchar nel[4]; // number of elements + * uchar cap[4]; // allocated number of elements + * } Array; + */ +EXTERN int Array_array; // runtime offsetof(Array,array) - same for String +EXTERN int Array_nel; // runtime offsetof(Array,nel) - same for String +EXTERN int Array_cap; // runtime offsetof(Array,cap) +EXTERN int sizeof_Array; // runtime sizeof(Array) + + +/* + * note this is the runtime representation + * of the compilers strings. + * + * typedef struct + * { // must not move anything + * uchar array[8]; // pointer to data + * uchar nel[4]; // number of elements + * } String; + */ +EXTERN int sizeof_String; // runtime sizeof(String) + +EXTERN Dlist dotlist[10]; // size is max depth of embeddeds + +EXTERN Io curio; +EXTERN Io pushedio; +EXTERN int32 lexlineno; +EXTERN int32 lineno; +EXTERN int32 prevlineno; +EXTERN char* pathname; +EXTERN Hist* hist; +EXTERN Hist* ehist; + +EXTERN char* infile; +EXTERN char* outfile; +EXTERN Biobuf* bout; +EXTERN int nerrors; +EXTERN int nsavederrors; +EXTERN int nsyntaxerrors; +EXTERN int safemode; +EXTERN char namebuf[NSYMB]; +EXTERN char lexbuf[NSYMB]; +EXTERN char litbuf[NSYMB]; +EXTERN char debug[256]; +EXTERN Sym* hash[NHASH]; +EXTERN Sym* importmyname; // my name for package +EXTERN Pkg* localpkg; // package being compiled +EXTERN Pkg* importpkg; // package being imported +EXTERN Pkg* structpkg; // package that declared struct, during import +EXTERN Pkg* builtinpkg; // fake package for builtins +EXTERN Pkg* gostringpkg; // fake pkg for Go strings +EXTERN Pkg* runtimepkg; // package runtime +EXTERN Pkg* stringpkg; // fake package for C strings +EXTERN Pkg* typepkg; // fake package for runtime type info +EXTERN Pkg* unsafepkg; // package unsafe +EXTERN Pkg* phash[128]; +EXTERN int tptr; // either TPTR32 or TPTR64 +extern char* runtimeimport; +extern char* unsafeimport; +EXTERN Idir* idirs; + +EXTERN Type* types[NTYPE]; +EXTERN Type* idealstring; +EXTERN Type* idealbool; +EXTERN uchar simtype[NTYPE]; +EXTERN uchar isptr[NTYPE]; +EXTERN uchar isforw[NTYPE]; +EXTERN uchar isint[NTYPE]; +EXTERN uchar isfloat[NTYPE]; +EXTERN uchar iscomplex[NTYPE]; +EXTERN uchar issigned[NTYPE]; +EXTERN uchar issimple[NTYPE]; + +EXTERN uchar okforeq[NTYPE]; +EXTERN uchar okforadd[NTYPE]; +EXTERN uchar okforand[NTYPE]; +EXTERN uchar okfornone[NTYPE]; +EXTERN uchar okforcmp[NTYPE]; +EXTERN uchar okforbool[NTYPE]; +EXTERN uchar okforcap[NTYPE]; +EXTERN uchar okforlen[NTYPE]; +EXTERN uchar okforarith[NTYPE]; +EXTERN uchar okforconst[NTYPE]; +EXTERN uchar* okfor[OEND]; +EXTERN uchar iscmp[OEND]; + +EXTERN Mpint* minintval[NTYPE]; +EXTERN Mpint* maxintval[NTYPE]; +EXTERN Mpflt* minfltval[NTYPE]; +EXTERN Mpflt* maxfltval[NTYPE]; + +EXTERN NodeList* xtop; +EXTERN NodeList* externdcl; +EXTERN NodeList* closures; +EXTERN NodeList* exportlist; +EXTERN NodeList* typelist; +EXTERN int dclcontext; // PEXTERN/PAUTO +EXTERN int incannedimport; +EXTERN int statuniqgen; // name generator for static temps +EXTERN int loophack; + +EXTERN int32 iota; +EXTERN NodeList* lastconst; +EXTERN Node* lasttype; +EXTERN int32 maxarg; +EXTERN int32 stksize; // stack size for current frame +EXTERN int32 blockgen; // max block number +EXTERN int32 block; // current block number +EXTERN int hasdefer; // flag that curfn has defer statetment + +EXTERN Node* curfn; + +EXTERN int widthptr; + +EXTERN Node* typesw; +EXTERN Node* nblank; + +extern int thechar; +extern char* thestring; +EXTERN char* hunk; +EXTERN int32 nhunk; +EXTERN int32 thunk; + +EXTERN int exporting; +EXTERN int erroring; +EXTERN int noargnames; + +EXTERN int funcdepth; +EXTERN int typecheckok; +EXTERN int packagequotes; +EXTERN int longsymnames; +EXTERN int compiling_runtime; + +/* + * y.tab.c + */ +int yyparse(void); + +/* + * align.c + */ +int argsize(Type *t); +void checkwidth(Type *t); +void defercheckwidth(void); +void dowidth(Type *t); +void resumecheckwidth(void); +uint32 rnd(uint32 o, uint32 r); +void typeinit(void); + +/* + * bits.c + */ +int Qconv(Fmt *fp); +Bits band(Bits a, Bits b); +int bany(Bits *a); +int beq(Bits a, Bits b); +int bitno(int32 b); +Bits blsh(uint n); +Bits bnot(Bits a); +int bnum(Bits a); +Bits bor(Bits a, Bits b); +int bset(Bits a, uint n); + +/* + * closure.c + */ +Node* closurebody(NodeList *body); +void closurehdr(Node *ntype); +void typecheckclosure(Node *func, int top); +Node* walkclosure(Node *func, NodeList **init); +void walkcallclosure(Node *n, NodeList **init); + +/* + * const.c + */ +int cmpslit(Node *l, Node *r); +int consttype(Node *n); +void convconst(Node *con, Type *t, Val *val); +void convlit(Node **np, Type *t); +void convlit1(Node **np, Type *t, int explicit); +void defaultlit(Node **np, Type *t); +void defaultlit2(Node **lp, Node **rp, int force); +void evconst(Node *n); +int isconst(Node *n, int ct); +Node* nodcplxlit(Val r, Val i); +Node* nodlit(Val v); +long nonnegconst(Node *n); +void overflow(Val v, Type *t); +int smallintconst(Node *n); +Val toint(Val v); +Mpflt* truncfltlit(Mpflt *oldv, Type *t); + +/* + * cplx.c + */ +void complexadd(int op, Node *nl, Node *nr, Node *res); +void complexbool(int op, Node *nl, Node *nr, int true, Prog *to); +void complexgen(Node *n, Node *res); +void complexminus(Node *nl, Node *res); +void complexmove(Node *f, Node *t); +void complexmul(Node *nl, Node *nr, Node *res); +int complexop(Node *n, Node *res); +void nodfconst(Node *n, Type *t, Mpflt* fval); + +/* + * dcl.c + */ +void addmethod(Sym *sf, Type *t, int local); +void addvar(Node *n, Type *t, int ctxt); +NodeList* checkarglist(NodeList *all, int input); +Node* colas(NodeList *left, NodeList *right); +void colasdefn(NodeList *left, Node *defn); +NodeList* constiter(NodeList *vl, Node *t, NodeList *cl); +Node* dclname(Sym *s); +void declare(Node *n, int ctxt); +Type* dostruct(NodeList *l, int et); +void dumpdcl(char *st); +Node* embedded(Sym *s); +Node* fakethis(void); +void funcbody(Node *n); +void funccompile(Node *n, int isclosure); +void funchdr(Node *n); +Type* functype(Node *this, NodeList *in, NodeList *out); +void ifacedcl(Node *n); +int isifacemethod(Type *f); +void markdcl(void); +Node* methodname(Node *n, Type *t); +Node* methodname1(Node *n, Node *t); +Sym* methodsym(Sym *nsym, Type *t0, int iface); +Node* newname(Sym *s); +Type* newtype(Sym *s); +Node* oldname(Sym *s); +void popdcl(void); +void poptodcl(void); +void redeclare(Sym *s, char *where); +void testdclstack(void); +Node* typedcl0(Sym *s); +Node* typedcl1(Node *n, Node *t, int local); +void typedcl2(Type *pt, Type *t); +Node* typenod(Type *t); +NodeList* variter(NodeList *vl, Node *t, NodeList *el); + +/* + * export.c + */ +void autoexport(Node *n, int ctxt); +void dumpexport(void); +int exportname(char *s); +void exportsym(Node *n); +void importconst(Sym *s, Type *t, Node *n); +void importmethod(Sym *s, Type *t); +Sym* importsym(Sym *s, int op); +void importtype(Type *pt, Type *t); +void importvar(Sym *s, Type *t, int ctxt); +Type* pkgtype(Sym *s); + +/* + * gen.c + */ +void allocparams(void); +void cgen_as(Node *nl, Node *nr); +void cgen_callmeth(Node *n, int proc); +void clearlabels(void); +void checklabels(void); +int dotoffset(Node *n, int *oary, Node **nn); +void gen(Node *n); +void genlist(NodeList *l); +Node* sysfunc(char *name); +void tempname(Node *n, Type *t); + +/* + * init.c + */ +void fninit(NodeList *n); +Node* renameinit(Node *n); + +/* + * lex.c + */ +void cannedimports(char *file, char *cp); +void importfile(Val *f, int line); +char* lexname(int lex); +void mkpackage(char* pkgname); +void unimportfile(void); +int32 yylex(void); +extern int windows; +extern int yylast; +extern int yyprev; + +/* + * mparith1.c + */ +int Bconv(Fmt *fp); +int Fconv(Fmt *fp); +void mpaddcfix(Mpint *a, vlong c); +void mpaddcflt(Mpflt *a, double c); +void mpatofix(Mpint *a, char *as); +void mpatoflt(Mpflt *a, char *as); +int mpcmpfixc(Mpint *b, vlong c); +int mpcmpfixfix(Mpint *a, Mpint *b); +int mpcmpfixflt(Mpint *a, Mpflt *b); +int mpcmpfltc(Mpflt *b, double c); +int mpcmpfltfix(Mpflt *a, Mpint *b); +int mpcmpfltflt(Mpflt *a, Mpflt *b); +void mpcomfix(Mpint *a); +void mpdivfixfix(Mpint *a, Mpint *b); +void mpmodfixfix(Mpint *a, Mpint *b); +void mpmovefixfix(Mpint *a, Mpint *b); +void mpmovefixflt(Mpflt *a, Mpint *b); +int mpmovefltfix(Mpint *a, Mpflt *b); +void mpmovefltflt(Mpflt *a, Mpflt *b); +void mpmulcfix(Mpint *a, vlong c); +void mpmulcflt(Mpflt *a, double c); +void mpsubfixfix(Mpint *a, Mpint *b); +void mpsubfltflt(Mpflt *a, Mpflt *b); + +/* + * mparith2.c + */ +void mpaddfixfix(Mpint *a, Mpint *b); +void mpandfixfix(Mpint *a, Mpint *b); +void mpandnotfixfix(Mpint *a, Mpint *b); +void mpdivfract(Mpint *a, Mpint *b); +void mpdivmodfixfix(Mpint *q, Mpint *r, Mpint *n, Mpint *d); +vlong mpgetfix(Mpint *a); +void mplshfixfix(Mpint *a, Mpint *b); +void mpmovecfix(Mpint *a, vlong c); +void mpmulfixfix(Mpint *a, Mpint *b); +void mpmulfract(Mpint *a, Mpint *b); +void mpnegfix(Mpint *a); +void mporfixfix(Mpint *a, Mpint *b); +void mprshfixfix(Mpint *a, Mpint *b); +void mpshiftfix(Mpint *a, int s); +int mptestfix(Mpint *a); +void mpxorfixfix(Mpint *a, Mpint *b); + +/* + * mparith3.c + */ +void mpaddfltflt(Mpflt *a, Mpflt *b); +void mpdivfltflt(Mpflt *a, Mpflt *b); +double mpgetflt(Mpflt *a); +void mpmovecflt(Mpflt *a, double c); +void mpmulfltflt(Mpflt *a, Mpflt *b); +void mpnegflt(Mpflt *a); +void mpnorm(Mpflt *a); +int mptestflt(Mpflt *a); +int sigfig(Mpflt *a); + +/* + * obj.c + */ +void Bputname(Biobuf *b, Sym *s); +int duint16(Sym *s, int off, uint16 v); +int duint32(Sym *s, int off, uint32 v); +int duint64(Sym *s, int off, uint64 v); +int duint8(Sym *s, int off, uint8 v); +int duintptr(Sym *s, int off, uint64 v); +int dsname(Sym *s, int off, char *dat, int ndat); +void dumpobj(void); +void ieeedtod(uint64 *ieee, double native); +Sym* stringsym(char*, int); + +/* + * print.c + */ +void exprfmt(Fmt *f, Node *n, int prec); +void exprlistfmt(Fmt *f, NodeList *l); + +/* + * range.c + */ +void typecheckrange(Node *n); +void walkrange(Node *n); + +/* + * reflect.c + */ +void dumptypestructs(void); +Type* methodfunc(Type *f, Type*); +Node* typename(Type *t); +Sym* typesym(Type *t); + +/* + * select.c + */ +void typecheckselect(Node *sel); +void walkselect(Node *sel); + +/* + * sinit.c + */ +void anylit(int, Node *n, Node *var, NodeList **init); +int gen_as_init(Node *n); +NodeList* initfix(NodeList *l); +int oaslit(Node *n, NodeList **init); +int stataddr(Node *nam, Node *n); + +/* + * subr.c + */ +int Econv(Fmt *fp); +int Jconv(Fmt *fp); +int Lconv(Fmt *fp); +int Nconv(Fmt *fp); +int Oconv(Fmt *fp); +int Sconv(Fmt *fp); +int Tconv(Fmt *fp); +int Tpretty(Fmt *fp, Type *t); +int Zconv(Fmt *fp); +Node* adddot(Node *n); +int adddot1(Sym *s, Type *t, int d, Type **save, int ignorecase); +Type* aindex(Node *b, Type *t); +int algtype(Type *t); +void argtype(Node *on, Type *t); +Node* assignconv(Node *n, Type *t, char *context); +int assignop(Type *src, Type *dst, char **why); +void badtype(int o, Type *tl, Type *tr); +int brcom(int a); +int brrev(int a); +NodeList* concat(NodeList *a, NodeList *b); +int convertop(Type *src, Type *dst, char **why); +int count(NodeList *l); +int cplxsubtype(int et); +void dump(char *s, Node *n); +void dumplist(char *s, NodeList *l); +int eqtype(Type *t1, Type *t2); +int eqtypenoname(Type *t1, Type *t2); +void errorexit(void); +void expandmeth(Sym *s, Type *t); +void fatal(char *fmt, ...); +void flusherrors(void); +void frame(int context); +Type* funcfirst(Iter *s, Type *t); +Type* funcnext(Iter *s); +void genwrapper(Type *rcvr, Type *method, Sym *newnam, int iface); +Type** getinarg(Type *t); +Type* getinargx(Type *t); +Type** getoutarg(Type *t); +Type* getoutargx(Type *t); +Type** getthis(Type *t); +Type* getthisx(Type *t); +int implements(Type *t, Type *iface, Type **missing, Type **have, int *ptr); +void importdot(Pkg *opkg, Node *pack); +int is64(Type *t); +int isblank(Node *n); +int isfixedarray(Type *t); +int isideal(Type *t); +int isinter(Type *t); +int isnil(Node *n); +int isnilinter(Type *t); +int isptrto(Type *t, int et); +int isslice(Type *t); +int istype(Type *t, int et); +void linehist(char *file, int32 off, int relative); +NodeList* list(NodeList *l, Node *n); +NodeList* list1(Node *n); +void listsort(NodeList**, int(*f)(Node*, Node*)); +Node* liststmt(NodeList *l); +NodeList* listtreecopy(NodeList *l); +Sym* lookup(char *name); +void* mal(int32 n); +Type* maptype(Type *key, Type *val); +Type* methtype(Type *t); +Pkg* mkpkg(Strlit *path); +Sym* ngotype(Node *n); +int noconv(Type *t1, Type *t2); +Node* nod(int op, Node *nleft, Node *nright); +Node* nodbool(int b); +void nodconst(Node *n, Type *t, int64 v); +Node* nodintconst(int64 v); +Node* nodfltconst(Mpflt *v); +Node* nodnil(void); +int parserline(void); +Sym* pkglookup(char *name, Pkg *pkg); +int powtwo(Node *n); +Type* ptrto(Type *t); +void* remal(void *p, int32 on, int32 n); +Sym* restrictlookup(char *name, Pkg *pkg); +Node* safeexpr(Node *n, NodeList **init); +void saveerrors(void); +Node* cheapexpr(Node *n, NodeList **init); +Node* localexpr(Node *n, Type *t, NodeList **init); +int32 setlineno(Node *n); +void setmaxarg(Type *t); +Type* shallow(Type *t); +int simsimtype(Type *t); +void smagic(Magic *m); +Type* sortinter(Type *t); +uint32 stringhash(char *p); +Strlit* strlit(char *s); +int structcount(Type *t); +Type* structfirst(Iter *s, Type **nn); +Type* structnext(Iter *s); +Node* syslook(char *name, int copy); +Type* tounsigned(Type *t); +Node* treecopy(Node *n); +Type* typ(int et); +uint32 typehash(Type *t); +void ullmancalc(Node *n); +void umagic(Magic *m); +void warn(char *fmt, ...); +void yyerror(char *fmt, ...); +void yyerrorl(int line, char *fmt, ...); + +/* + * swt.c + */ +void typecheckswitch(Node *n); +void walkswitch(Node *sw); + +/* + * typecheck.c + */ +int exportassignok(Type *t, char *desc); +int islvalue(Node *n); +Node* typecheck(Node **np, int top); +void typechecklist(NodeList *l, int top); +Node* typecheckdef(Node *n); +void resumetypecopy(void); +void copytype(Node *n, Type *t); +void defertypecopy(Node *n, Type *t); +void queuemethod(Node *n); + +/* + * unsafe.c + */ +Node* unsafenmagic(Node *n); + +/* + * walk.c + */ +Node* callnew(Type *t); +Node* chanfn(char *name, int n, Type *t); +Node* mkcall(char *name, Type *t, NodeList **init, ...); +Node* mkcall1(Node *fn, Type *t, NodeList **init, ...); +int vmatch1(Node *l, Node *r); +void walk(Node *fn); +void walkexpr(Node **np, NodeList **init); +void walkexprlist(NodeList *l, NodeList **init); +void walkexprlistsafe(NodeList *l, NodeList **init); +void walkstmt(Node **np); +void walkstmtlist(NodeList *l); + +/* + * arch-specific ggen.c/gsubr.c/gobj.c/pgen.c + */ +#define P ((Prog*)0) + +typedef struct Plist Plist; +struct Plist +{ + Node* name; + Prog* firstpc; + int recur; + Plist* link; +}; + +EXTERN Plist* plist; +EXTERN Plist* plast; + +EXTERN Prog* continpc; +EXTERN Prog* breakpc; +EXTERN Prog* pc; +EXTERN Prog* firstpc; +EXTERN Prog* retpc; + +EXTERN Node* nodfp; + +int anyregalloc(void); +void betypeinit(void); +void bgen(Node *n, int true, Prog *to); +void cgen(Node*, Node*); +void cgen_asop(Node *n); +void cgen_call(Node *n, int proc); +void cgen_callinter(Node *n, Node *res, int proc); +void cgen_ret(Node *n); +void clearfat(Node *n); +void compile(Node*); +void defframe(Prog*); +int dgostringptr(Sym*, int off, char *str); +int dgostrlitptr(Sym*, int off, Strlit*); +int dstringptr(Sym *s, int off, char *str); +int dsymptr(Sym *s, int off, Sym *x, int xoff); +int duintxx(Sym *s, int off, uint64 v, int wid); +void dumpdata(void); +void dumpfuncs(void); +void fixautoused(Prog*); +void gdata(Node*, Node*, int); +void gdatacomplex(Node*, Mpcplx*); +void gdatastring(Node*, Strlit*); +void genembedtramp(Type*, Type*, Sym*, int iface); +void ggloblnod(Node *nam, int32 width); +void ggloblsym(Sym *s, int32 width, int dupok); +Prog* gjmp(Prog*); +void gused(Node*); +int isfat(Type*); +void markautoused(Prog*); +Plist* newplist(void); +Node* nodarg(Type*, int); +void nopout(Prog*); +void patch(Prog*, Prog*); +Prog* unpatch(Prog*); +void zfile(Biobuf *b, char *p, int n); +void zhist(Biobuf *b, int line, vlong offset); +void zname(Biobuf *b, Sym *s, int t); +void data(void); +void text(void); + |