Main Page | Class Hierarchy | Alphabetical List | Data Structures | Directories | File List | Data Fields | Globals
lcc / src

gen.c File Reference

#include "c.h"

Include dependency graph for gen.c:

Include dependency graph

Go to the source code of this file.

Defines

#define ck(i)   return (i) ? 0 : LBURG_MAX
#define readsreg(p)   (generic((p)->op)==INDIR && (p)->kids[0]->op==VREG+P)
#define relink(a, b)   ((b)->x.prev = (a), (a)->x.next = (b))
#define setsrc(d)

Functions

Symbol askfixedreg (Symbol)
Symbol askreg (Symbol rs, unsigned rmask[])
Symbol askreg (Symbol, unsigned *)
int askregvar (Symbol p, Symbol regs)
void blkcopy (int dreg, int doff, int sreg, int soff, int size, int tmp[])
void blkunroll (int, int, int, int, int, int, int[])
void blockbeg (Env *e)
void blockend (Env *e)
void docall (Node)
void dumpcover (Node, int, int)
void dumpregs (char *, char *, char *)
void dumprule (int)
void dumptree (Node)
void emit (Node p)
unsigned emitasm (Node, int)
Node gen (Node forest)
void genreload (Node, Symbol, int)
void genspill (Symbol, Node, Symbol)
Symbol getreg (Symbol s, unsigned mask[], Node p)
Symbol getreg (Symbol, unsigned *, Node)
int getregnum (Node p)
int getrule (Node, int)
void linearize (Node, Node)
int mayrecalc (Node p)
int mkactual (int align, int size)
void mkauto (Symbol p)
Symbol mkreg (char *fmt, int n, int mask, int set)
Symbol mkwildcard (Symbol *syms)
int move (Node p)
int moveself (Node)
int notarget (Node p)
void parseflags (int argc, char *argv[])
void prelabel (Node)
Node * prune (Node p, Node pp[])
Node * prune (Node, Node *)
void putreg (Symbol)
void ralloc (Node)
int range (Node p, int lo, int hi)
void reduce (Node, int)
unsigned regloc (Symbol p)
int reprune (Node *, int, int, Node)
int requate (Node)
Node reuse (Node, int)
void rewrite (Node)
void rtarget (Node p, int n, Symbol r)
void setreg (Node p, Symbol r)
void spill (unsigned mask, int n, Node here)
Symbol spillee (Symbol, unsigned mask[], Node)
void spillr (Symbol, Node)
int uses (Node, Regnode)

Variables

int argoffset
int bflag = 0
int dalign
int dflag = 0
unsigned(* emitter )(Node, int) = emitasm
int framesize
unsigned freemask [2]
Node head
int maxargoffset
int maxoffset
char NeedsReg []
int offset
int salign
int swap
unsigned tmask [2]
unsigned usedmask [2]
unsigned vmask [2]

Define Documentation

#define ck (  i   )     return (i) ? 0 : LBURG_MAX
 

Definition at line 251 of file gen.c.

Referenced by range().

#define readsreg (  p   )     (generic((p)->op)==INDIR && (p)->kids[0]->op==VREG+P)
 

Definition at line 4 of file gen.c.

Referenced by requate(), and spillr().

#define relink (  a,
b   )     ((b)->x.prev = (a), (a)->x.next = (b))
 

Definition at line 10 of file gen.c.

Referenced by AAS_UpdateEntity(), gen(), and linearize().

#define setsrc (  d   ) 
 

Value:

((d) && (d)->x.regnode && \
    (d)->x.regnode->set == src->x.regnode->set && \
    (d)->x.regnode->mask&src->x.regnode->mask)

Definition at line 6 of file gen.c.

Referenced by requate().

Function Documentation

Symbol askfixedreg (  Symbol   )  [static]
 

Definition at line 533 of file gen.c.

References freemask, Regnode::mask, n, r, Xsymbol::regnode, s, Regnode::set, Symbol, usedmask, and symbol::x.

Referenced by askreg().

00533                                     {
00534     Regnode r = s->x.regnode;
00535     int n = r->set;
00536 
00537     if (r->mask&~freemask[n])
00538         return NULL;
00539     else {
00540         freemask[n] &= ~r->mask;
00541         usedmask[n] |=  r->mask;
00542         return s;
00543     }
00544 }

Symbol askreg (  Symbol  rs,
unsigned  rmask[]
)  [static]
 

Definition at line 545 of file gen.c.

References askfixedreg(), i, Regnode::mask, NULL, r, Xsymbol::regnode, Regnode::set, Symbol, Xsymbol::wildcard, and symbol::x.

Referenced by askregvar(), and getreg().

00545                                                   {
00546     int i;
00547 
00548     if (rs->x.wildcard == NULL)
00549         return askfixedreg(rs);
00550     for (i = 31; i >= 0; i--) {
00551         Symbol r = rs->x.wildcard[i];
00552         if (r != NULL
00553         && !(r->x.regnode->mask&~rmask[r->x.regnode->set])
00554         && askfixedreg(r))
00555             return r;
00556     }
00557     return NULL;
00558 }

Here is the call graph for this function:

Symbol askreg (  Symbol  ,
unsigned * 
)  [static]
 

int askregvar (  Symbol  p,
Symbol  regs
) 
 

Definition at line 572 of file gen.c.

References askreg(), assert, debug, dumpregs(), isscalar, symbol::name, Xsymbol::name, p, r, Xsymbol::regnode, symbol::sclass, Symbol, symbol::temporary, symbol::type, Regnode::vbl, vmask, and symbol::x.

00572                                      {
00573     Symbol r;
00574 
00575     assert(p);
00576     if (p->sclass != REGISTER)
00577         return 0;
00578     else if (!isscalar(p->type)) {
00579         p->sclass = AUTO;
00580         return 0;
00581     }
00582     else if (p->temporary) {
00583         p->x.name = "?";
00584         return 1;
00585     }
00586     else if ((r = askreg(regs, vmask)) != NULL) {
00587         p->x.regnode = r->x.regnode;
00588         p->x.regnode->vbl = p;
00589         p->x.name = r->x.name;
00590         debug(dumpregs("(allocating %s to symbol %s)\n", p->x.name, p->name));
00591         return 1;
00592     }
00593     else {
00594         p->sclass = AUTO;
00595         return 0;
00596     }
00597 }

Here is the call graph for this function:

void blkcopy (  int  dreg,
int  doff,
int  sreg,
int  soff,
int  size,
int  tmp[]
) 
 

Definition at line 129 of file gen.c.

References assert, Xinterface::blkloop, blkunroll(), IR, and interface::x.

00129                                                                           {
00130     assert(size >= 0);
00131     if (size == 0)
00132         return;
00133     else if (size <= 2)
00134         blkunroll(size, dreg, doff, sreg, soff, size, tmp);
00135     else if (size == 3) {
00136         blkunroll(2, dreg, doff,   sreg, soff,   2, tmp);
00137         blkunroll(1, dreg, doff+2, sreg, soff+2, 1, tmp);
00138     }
00139     else if (size <= 16) {
00140         blkunroll(4, dreg, doff, sreg, soff, size&~3, tmp);
00141         blkcopy(dreg, doff+(size&~3),
00142                     sreg, soff+(size&~3), size&3, tmp);
00143     }
00144     else
00145         (*IR->x.blkloop)(dreg, doff, sreg, soff, size, tmp);
00146 }

Here is the call graph for this function:

void blkunroll (  int  ,
int  ,
int  ,
int  ,
int  ,
int  ,
int  []
)  [static]
 

Definition at line 147 of file gen.c.

References assert, Xinterface::blkfetch, Xinterface::blkstore, i, IR, k, Xinterface::max_unaligned_load, salign, and interface::x.

Referenced by blkcopy().

00147                                                                                           {
00148     int i;
00149 
00150     assert(IR->x.max_unaligned_load);
00151     if (k > IR->x.max_unaligned_load
00152     && (k > salign || k > dalign))
00153         k = IR->x.max_unaligned_load;
00154     for (i = 0; i+k < size; i += 2*k) {
00155         (*IR->x.blkfetch)(k, soff+i,   sreg, tmp[0]);
00156         (*IR->x.blkfetch)(k, soff+i+k, sreg, tmp[1]);
00157         (*IR->x.blkstore)(k, doff+i,   dreg, tmp[0]);
00158         (*IR->x.blkstore)(k, doff+i+k, dreg, tmp[1]);
00159     }
00160     if (i < size) {
00161         (*IR->x.blkfetch)(k, i+soff, sreg, tmp[0]);
00162         (*IR->x.blkstore)(k, i+doff, dreg, tmp[0]);
00163     }
00164 }

void blockbeg (  Env *  e  ) 
 

Definition at line 104 of file gen.c.

References e, freemask, Env::freemask, and Env::offset.

Referenced by asdl_init().

00104                       {
00105     e->offset = offset;
00106     e->freemask[IREG] = freemask[IREG];
00107     e->freemask[FREG] = freemask[FREG];
00108 }

void blockend (  Env *  e  ) 
 

Definition at line 109 of file gen.c.

References e, Env::freemask, freemask, maxoffset, Env::offset, and offset.

Referenced by asdl_init().

00109                       {
00110     if (offset > maxoffset)
00111         maxoffset = offset;
00112     offset = e->offset;
00113     freemask[IREG] = e->freemask[IREG];
00114     freemask[FREG] = e->freemask[FREG];
00115 }

void docall (  Node   )  [static]
 

Definition at line 122 of file gen.c.

References argoffset, intconst(), maxargoffset, Node, p, and node::syms.

Referenced by gen().

00122                            {
00123     p->syms[1] = p->syms[0];
00124     p->syms[0] = intconst(argoffset);
00125     if (argoffset > maxargoffset)
00126         maxargoffset = argoffset;
00127     argoffset = 0;
00128 }

Here is the call graph for this function:

void dumpcover (  Node  ,
int  ,
int 
)  [static]
 

Definition at line 307 of file gen.c.

References Xinterface::_kids, Xinterface::_nts, dumprule(), fprint(), getrule(), i, in, IR, Node, p, reuse(), stderr, and interface::x.

Referenced by rewrite().

00307                                               {
00308     int rulenum, i;
00309     short *nts;
00310     Node kids[10];
00311 
00312     p = reuse(p, nt);
00313     rulenum = getrule(p, nt);
00314     nts = IR->x._nts[rulenum];
00315     fprint(stderr, "dumpcover(%x) = ", p);
00316     for (i = 0; i < in; i++)
00317         fprint(stderr, " ");
00318     dumprule(rulenum);
00319     (*IR->x._kids)(p, rulenum, kids);
00320     for (i = 0; nts[i]; i++)
00321         dumpcover(kids[i], nts[i], in+1);
00322 }

Here is the call graph for this function:

void dumpregs (  char *  ,
char *  ,
char * 
)  [static]
 

Definition at line 814 of file gen.c.

References a, b, fprint(), freemask, and stderr.

Referenced by askregvar(), putreg(), and ralloc().

00814                                                   {
00815     fprint(stderr, msg, a, b);
00816     fprint(stderr, "(free[0]=%x)\n", freemask[0]);
00817     fprint(stderr, "(free[1]=%x)\n", freemask[1]);
00818 }

Here is the call graph for this function:

void dumprule (  int   )  [static]
 

Definition at line 324 of file gen.c.

References Xinterface::_isinstruction, Xinterface::_string, Xinterface::_templates, assert, fprint(), IR, stderr, and interface::x.

Referenced by dumpcover().

00324                                   {
00325     assert(rulenum);
00326     fprint(stderr, "%s / %s", IR->x._string[rulenum],
00327         IR->x._templates[rulenum]);
00328     if (!IR->x._isinstruction[rulenum])
00329         fprint(stderr, "\n");
00330 }

Here is the call graph for this function:

void dumptree (  Node   )  [static]
 

Definition at line 265 of file gen.c.

References ADD, ADDRF, ADDRG, ADDRL, ARG, ASGN, assert, BAND, BCOM, BOR, BXOR, CALL, CNST, CVF, CVI, CVP, CVU, DIV, EQ, fprint(), GE, generic, GT, INDIR, JUMP, node::kids, LABEL, LE, LSH, LT, MOD, MUL, symbol::name, NE, NEG, Node, node::op, opname(), optype, P, p, RET, RSH, stderr, SUB, node::syms, and VREG.

Referenced by dumptree(), genreload(), genspill(), and rewrite().

00265                              {
00266     if (p->op == VREG+P && p->syms[0]) {
00267         fprint(stderr, "VREGP(%s)", p->syms[0]->name);
00268         return;
00269     } else if (generic(p->op) == LOAD) {
00270         fprint(stderr, "LOAD(");
00271         dumptree(p->kids[0]);
00272         fprint(stderr, ")");
00273         return;
00274     }
00275     fprint(stderr, "%s(", opname(p->op));
00276     switch (generic(p->op)) {
00277     case CNST: case LABEL:
00278     case ADDRG: case ADDRF: case ADDRL:
00279         if (p->syms[0])
00280             fprint(stderr, "%s", p->syms[0]->name);
00281         break;
00282     case RET:
00283         if (p->kids[0])
00284             dumptree(p->kids[0]);
00285         break;
00286     case CVF: case CVI: case CVP: case CVU: case JUMP: 
00287     case ARG: case BCOM: case NEG: case INDIR:
00288         dumptree(p->kids[0]);
00289         break;
00290     case CALL:
00291         if (optype(p->op) != B) {
00292             dumptree(p->kids[0]);
00293             break;
00294         }
00295         /* else fall thru */
00296     case EQ: case NE: case GT: case GE: case LE: case LT:
00297     case ASGN: case BOR: case BAND: case BXOR: case RSH: case LSH:
00298     case ADD: case SUB:  case DIV: case MUL: case MOD:
00299         dumptree(p->kids[0]);
00300         fprint(stderr, ", ");
00301         dumptree(p->kids[1]);
00302         break;
00303     default: assert(0);
00304     }
00305     fprint(stderr, ")");
00306 }

Here is the call graph for this function:

void emit (  Node  p  ) 
 

Definition at line 368 of file gen.c.

References assert, Xnode::equatable, Xnode::inst, moveself(), Xnode::next, Node, p, Xnode::registered, requate(), and node::x.

Referenced by asdl_init().

00368                   {
00369     for (; p; p = p->x.next) {
00370         assert(p->x.registered);
00371         if (p->x.equatable && requate(p) || moveself(p))
00372             ;
00373         else
00374             (*emitter)(p, p->x.inst);
00375         p->x.emitted = 1;
00376     }
00377 }

Here is the call graph for this function:

unsigned emitasm (  Node  ,
int 
)  [static]
 

Definition at line 331 of file gen.c.

References Xinterface::_isinstruction, Xinterface::_kids, Xinterface::_nts, Xinterface::_templates, assert, Xinterface::emit2, Xnode::emitted, fputs(), framesize, getrule(), IR, Xnode::kids, node::kids, Xsymbol::name, NELEMS, Node, p, print(), putchar, reuse(), RX, stdout, node::syms, symbol::x, node::x, and interface::x.

00331                                         {
00332     int rulenum;
00333     short *nts;
00334     char *fmt;
00335     Node kids[10];
00336 
00337     p = reuse(p, nt);
00338     rulenum = getrule(p, nt);
00339     nts = IR->x._nts[rulenum];
00340     fmt = IR->x._templates[rulenum];
00341     assert(fmt);
00342     if (IR->x._isinstruction[rulenum] && p->x.emitted)
00343         print("%s", p->syms[RX]->x.name);
00344     else if (*fmt == '#')
00345         (*IR->x.emit2)(p);
00346     else {
00347         if (*fmt == '?') {
00348             fmt++;
00349             assert(p->kids[0]);
00350             if (p->syms[RX] == p->x.kids[0]->syms[RX])
00351                 while (*fmt++ != '\n')
00352                     ;
00353         }
00354         for ((*IR->x._kids)(p, rulenum, kids); *fmt; fmt++)
00355             if (*fmt != '%')
00356                 (void)putchar(*fmt);
00357             else if (*++fmt == 'F')
00358                 print("%d", framesize);
00359             else if (*fmt >= '0' && *fmt <= '9')
00360                 emitasm(kids[*fmt - '0'], nts[*fmt - '0']);
00361             else if (*fmt >= 'a' && *fmt < 'a' + NELEMS(p->syms))
00362                 fputs(p->syms[*fmt - 'a']->x.name, stdout);
00363             else
00364                 (void)putchar(*fmt);
00365     }
00366     return 0;
00367 }

Here is the call graph for this function:

Node gen (  Node  forest  ) 
 

Definition at line 479 of file gen.c.

References ASGN, assert, CALL, Xinterface::doarg, docall(), generic, head, i, IR, Xnode::kids, Xsymbol::lastuse, linearize(), node::link, Xnode::listed, LOAD, NeedsReg, NELEMS, Xnode::next, Node, opindex, opkind, p, Xnode::prev, Xnode::prevuse, prune(), putreg(), ralloc(), relink, rewrite(), Xinterface::rmap, RX, node::syms, symbol::x, node::x, and interface::x.

Referenced by asdl_init().

00479                       {
00480     int i;
00481     struct node sentinel;
00482     Node dummy, p;
00483 
00484     head = forest;
00485     for (p = forest; p; p = p->link) {
00486         assert(p->count == 0);
00487         if (generic(p->op) == CALL)
00488             docall(p);
00489         else if (   generic(p->op) == ASGN
00490         && generic(p->kids[1]->op) == CALL)
00491             docall(p->kids[1]);
00492         else if (generic(p->op) == ARG)
00493             (*IR->x.doarg)(p);
00494         rewrite(p);
00495         p->x.listed = 1;
00496     }
00497     for (p = forest; p; p = p->link)
00498         prune(p, &dummy);
00499     relink(&sentinel, &sentinel);
00500     for (p = forest; p; p = p->link)
00501         linearize(p, &sentinel);
00502     forest = sentinel.x.next;
00503     assert(forest);
00504     sentinel.x.next->x.prev = NULL;
00505     sentinel.x.prev->x.next = NULL;
00506     for (p = forest; p; p = p->x.next)
00507         for (i = 0; i < NELEMS(p->x.kids) && p->x.kids[i]; i++) {
00508             assert(p->x.kids[i]->syms[RX]);
00509             if (p->x.kids[i]->syms[RX]->temporary) {
00510                 p->x.kids[i]->x.prevuse =
00511                     p->x.kids[i]->syms[RX]->x.lastuse;
00512                 p->x.kids[i]->syms[RX]->x.lastuse = p->x.kids[i];
00513             }
00514         }
00515     for (p = forest; p; p = p->x.next) {
00516         ralloc(p);
00517         if (p->x.listed && NeedsReg[opindex(p->op)]
00518         && (*IR->x.rmap)(opkind(p->op))) {
00519             assert(generic(p->op) == CALL || generic(p->op) == LOAD);
00520             putreg(p->syms[RX]);
00521         }
00522     }
00523     return forest;
00524 }

Here is the call graph for this function:

void genreload (  Node  ,
Symbol  ,
int 
)  [static]
 

Definition at line 755 of file gen.c.

References ADDRL, debug, dumptree(), fprint(), i, INDIR, IR, node::kids, Xnode::kids, linearize(), Xsymbol::name, newnode(), Node, NULL, node::op, opkind, P, p, prune(), interface::ptrmetric, q, reprune(), rewrite(), metrics::size, sizeop, stderr, Symbol, symbol::x, and node::x.

Referenced by spillr().

00755                                                  {
00756     Node q;
00757     int ty;
00758 
00759     debug(fprint(stderr, "(replacing %x with a reload from %s)\n", p->x.kids[i], tmp->x.name));
00760     debug(fprint(stderr, "(genreload: "));
00761     debug(dumptree(p->x.kids[i]));
00762     debug(fprint(stderr, ")\n"));
00763     ty = opkind(p->x.kids[i]->op);
00764     q = newnode(ADDRL+P + sizeop(IR->ptrmetric.size), NULL, NULL, tmp);
00765     p->x.kids[i] = newnode(INDIR + ty, q, NULL, NULL);
00766     rewrite(p->x.kids[i]);
00767     prune(p->x.kids[i], &q);
00768     reprune(&p->kids[1], reprune(&p->kids[0], 0, i, p), i, p);
00769     prune(p, &q);
00770     linearize(p->x.kids[i], p);
00771 }

Here is the call graph for this function:

void genspill (  Symbol  ,
Node  ,
Symbol 
)  [static]
 

Definition at line 726 of file gen.c.

References ADDRL, ASGN, assert, debug, dumptree(), fprint(), FUNC, INDIR, IR, linearize(), Xnode::listed, symbol::name, Xsymbol::name, NeedsReg, NEW0, newnode(), Xnode::next, Node, NULL, node::op, opindex, opkind, p, P, prune(), interface::ptrmetric, q, r, ralloc(), Xsymbol::regnode, rewrite(), Xinterface::rmap, s, symbol::sclass, metrics::size, sizeop, Xnode::spills, stderr, Symbol, interface::x, node::x, and symbol::x.

Referenced by spillr().

00726                                                       {
00727     Node p, q;
00728     Symbol s;
00729     unsigned ty;
00730 
00731     debug(fprint(stderr, "(spilling %s to local %s)\n", r->x.name, tmp->x.name));
00732     debug(fprint(stderr, "(genspill: "));
00733     debug(dumptree(last));
00734     debug(fprint(stderr, ")\n"));
00735     ty = opkind(last->op);
00736     NEW0(s, FUNC);
00737     s->sclass = REGISTER;
00738     s->name = s->x.name = r->x.name;
00739     s->x.regnode = r->x.regnode;
00740     q = newnode(ADDRL+P + sizeop(IR->ptrmetric.size), NULL, NULL, s);
00741     q = newnode(INDIR + ty, q, NULL, NULL);
00742     p = newnode(ADDRL+P + sizeop(IR->ptrmetric.size), NULL, NULL, tmp);
00743     p = newnode(ASGN + ty, p, q, NULL);
00744     p->x.spills = 1;
00745     rewrite(p);
00746     prune(p, &q);
00747     q = last->x.next;
00748     linearize(p, q);
00749     for (p = last->x.next; p != q; p = p->x.next) {
00750         ralloc(p);
00751         assert(!p->x.listed || !NeedsReg[opindex(p->op)] || !(*IR->x.rmap)(opkind(p->op)));
00752     }
00753 }

Here is the call graph for this function:

Symbol getreg (  Symbol  s,
unsigned  mask[],
Node  p
)  [static]
 

Definition at line 560 of file gen.c.

References askreg(), assert, Regnode::mask, mask, Node, p, r, Xsymbol::regnode, s, Regnode::set, spill(), spillee(), Symbol, Regnode::vbl, and symbol::x.

Referenced by ralloc().

00560                                                         {
00561     Symbol r = askreg(s, mask);
00562     if (r == NULL) {
00563         r = spillee(s, mask, p);
00564         assert(r && r->x.regnode);
00565         spill(r->x.regnode->mask, r->x.regnode->set, p);
00566         r = askreg(s, mask);
00567     }
00568     assert(r && r->x.regnode);
00569     r->x.regnode->vbl = NULL;
00570     return r;
00571 }

Here is the call graph for this function:

Symbol getreg (  Symbol  ,
unsigned *  ,
Node 
)  [static]
 

int getregnum (  Node  p  ) 
 

Definition at line 820 of file gen.c.

References assert, Node, Regnode::number, p, Xsymbol::regnode, RX, node::syms, and symbol::x.

00820                       {
00821     assert(p && p->syms[RX] && p->syms[RX]->x.regnode);
00822     return p->syms[RX]->x.regnode->number;
00823 }

int getrule (  Node  ,
int 
)  [static]
 

Definition at line 174 of file gen.c.

References Xinterface::_rule, assert, fprint(), IR, Node, node::op, opname(), p, src, Xnode::state, stderr, node::x, and interface::x.

Referenced by dumpcover(), emitasm(), ralloc(), and reduce().

00174                                    {
00175     int rulenum;
00176 
00177     assert(p);
00178     rulenum = (*IR->x._rule)(p->x.state, nt);
00179     if (!rulenum) {
00180         fprint(stderr, "(%x->op=%s at %w is corrupt.)\n", p, opname(p->op), &src);
00181         assert(0);
00182     }
00183     return rulenum;
00184 }

Here is the call graph for this function:

void linearize (  Node  ,
Node 
)  [static]
 

Definition at line 598 of file gen.c.

References debug, fprint(), i, Xnode::kids, NELEMS, next, Node, p, Xnode::prev, relink, stderr, and node::x.

Referenced by gen(), genreload(), and genspill().

00598                                          {
00599     int i;
00600 
00601     for (i = 0; i < NELEMS(p->x.kids) && p->x.kids[i]; i++)
00602         linearize(p->x.kids[i], next);
00603     relink(next->x.prev, p);
00604     relink(p, next);
00605     debug(fprint(stderr, "(listing %x)\n", p));
00606 }

Here is the call graph for this function:

int mayrecalc (  Node  p  ) 
 

Definition at line 219 of file gen.c.

References ADDRF, ADDRG, assert, CNST, symbol::cse, generic, Xnode::mayrecalc, Node, node::op, op, p, RX, node::syms, symbol::t, symbol::u, and node::x.

00219                       {
00220     int op;
00221 
00222     assert(p && p->syms[RX]);
00223     if (p->syms[RX]->u.t.cse == NULL)
00224         return 0;
00225     op = generic(p->syms[RX]->u.t.cse->op);
00226     if (op == CNST || op == ADDRF || op == ADDRG || op == ADDRL) {
00227         p->x.mayrecalc = 1;
00228         return 1;
00229     } else
00230         return 0;
00231 }

int mkactual (  int  align,
int  size
) 
 

Definition at line 116 of file gen.c.

References argoffset, n, and roundup.

00116                                   {
00117     int n = roundup(argoffset, align);
00118 
00119     argoffset = n + size;
00120     return n;
00121 }

void mkauto (  Symbol  p  ) 
 

Definition at line 98 of file gen.c.

References type::align, assert, Xsymbol::name, Xsymbol::offset, offset, p, roundup, symbol::sclass, type::size, stringd(), Symbol, symbol::type, and symbol::x.

00098                       {
00099     assert(p->sclass == AUTO);
00100     offset = roundup(offset + p->type->size, p->type->align);
00101     p->x.offset = -offset;
00102     p->x.name = stringd(-offset);
00103 }

Here is the call graph for this function:

Symbol mkreg (  char *  fmt,
int  n,
int  mask,
int  set
) 
 

Definition at line 79 of file gen.c.

References mask, Regnode::mask, n, Xsymbol::name, symbol::name, NEW0, Regnode::number, p, PERM, Xsymbol::regnode, Regnode::set, stringf(), Symbol, and symbol::x.

00079                                                   {
00080     Symbol p;
00081 
00082     NEW0(p, PERM);
00083     p->name = p->x.name = stringf(fmt, n);
00084     NEW0(p->x.regnode, PERM);
00085     p->x.regnode->number = n;
00086     p->x.regnode->mask = mask<<n;
00087     p->x.regnode->set = set;
00088     return p;
00089 }

Here is the call graph for this function:

Symbol mkwildcard (  Symbol *  syms  ) 
 

Definition at line 90 of file gen.c.

References Xsymbol::name, symbol::name, NEW0, p, PERM, Symbol, Xsymbol::wildcard, and symbol::x.

00090                                 {
00091     Symbol p;
00092 
00093     NEW0(p, PERM);
00094     p->name = p->x.name = "wildcard";
00095     p->x.wildcard = syms;
00096     return p;
00097 }

int move (  Node  p  ) 
 

Definition at line 382 of file gen.c.

References Xnode::copy, Node, p, and node::x.

Referenced by AAS_BestReachableFromJumpPadArea(), AAS_ClientMovementHitBBox(), AAS_ClientMovementPrediction(), AAS_JumpReachRunStart(), AAS_PredictClientMovement(), AAS_Reachability_Jump(), AAS_Reachability_JumpPad(), AAS_Reachability_Teleport(), AAS_Reachability_WeaponJump(), AAS_ShowReachability(), AAS_TestMovementPrediction(), BotAimAtEnemy(), BotChangeViewAngle(), BotWalkInDirection(), Brush_Move(), CG_BubbleTrail(), CG_RailTrail(), CG_SwingAngles(), CSG_MakeHollow(), Drag_MouseMoved(), CXYWnd::DragDelta(), G_MoverPush(), G_MoverTeam(), G_TryPushingEntity(), G_TryPushingProxMine(), InitMover(), MoveSelection(), Reached_Train(), trap_AAS_PredictClientMovement(), UI_SwingAngles(), idSplineList::updateSelection(), idSplinePosition::updateSelection(), and idPointListInterface::updateSelection().

00382                  {
00383     p->x.copy = 1;
00384     return 1;
00385 }

int moveself (  Node   )  [static]
 

Definition at line 378 of file gen.c.

References Xnode::copy, Xnode::kids, Xsymbol::name, Node, p, node::syms, symbol::x, and node::x.

Referenced by emit(), and requate().

00378                             {
00379     return p->x.copy
00380     && p->syms[RX]->x.name == p->x.kids[0]->syms[RX]->x.name;
00381 }

int notarget (  Node  p  ) 
 

Definition at line 525 of file gen.c.

References Node, p, node::syms, Xsymbol::wildcard, and symbol::x.

00525                      {
00526     return p->syms[RX]->x.wildcard ? 0 : LBURG_MAX;
00527 }

void parseflags (  int  argc,
char *  argv[]
) 
 

Definition at line 165 of file gen.c.

References argv, bflag, dflag, i, and strcmp().

00165                                         {
00166     int i;
00167 
00168     for (i = 0; i < argc; i++)
00169         if (strcmp(argv[i], "-d") == 0)
00170             dflag = 1;
00171         else if (strcmp(argv[i], "-b") == 0)    /* omit */
00172             bflag = 1;          /* omit */
00173 }

Here is the call graph for this function:

void prelabel (  Node   )  [static]
 

Definition at line 421 of file gen.c.

References ADDRF, ADDRL, ASGN, symbol::c, CVI, CVP, CVU, F, generic, value::i, INDIR, IR, node::kids, LOAD, NeedsReg, Node, node::op, opindex, opkind, opsize, optype, p, Xinterface::rmap, rtarget(), symbol::sclass, setreg(), node::syms, Xinterface::target, symbol::u, symbol::v, VREG, and interface::x.

Referenced by rewrite().

00421                              {
00422     if (p == NULL)
00423         return;
00424     prelabel(p->kids[0]);
00425     prelabel(p->kids[1]);
00426     if (NeedsReg[opindex(p->op)])
00427         setreg(p, (*IR->x.rmap)(opkind(p->op)));
00428     switch (generic(p->op)) {
00429     case ADDRF: case ADDRL:
00430         if (p->syms[0]->sclass == REGISTER)
00431             p->op = VREG+P;
00432         break;
00433     case INDIR:
00434         if (p->kids[0]->op == VREG+P)
00435             setreg(p, p->kids[0]->syms[0]);
00436         break;
00437     case ASGN:
00438         if (p->kids[0]->op == VREG+P)
00439             rtarget(p, 1, p->kids[0]->syms[0]);
00440         break;
00441     case CVI: case CVU: case CVP:
00442         if (optype(p->op) != F
00443         &&  opsize(p->op) <= p->syms[0]->u.c.v.i)
00444             p->op = LOAD + opkind(p->op);
00445         break;
00446     }
00447     (IR->x.target)(p);
00448 }

Here is the call graph for this function:

Node* prune (  Node  p,
Node  pp[]
)  [static]
 

Definition at line 232 of file gen.c.

References debug, fprint(), Xnode::inst, node::kids, Xnode::kids, symbol::name, Node, p, prune(), RX, stderr, node::syms, symbol::temporary, Xsymbol::usecount, symbol::x, and node::x.

Referenced by gen(), gencode(), genreload(), and genspill().

00232                                       {
00233     if (p == NULL)
00234         return pp;
00235     p->x.kids[0] = p->x.kids[1] = p->x.kids[2] = NULL;
00236     if (p->x.inst == 0)
00237         return prune(p->kids[1], prune(p->kids[0], pp));
00238     else if (p->syms[RX] && p->syms[RX]->temporary
00239     && p->syms[RX]->x.usecount < 2) {
00240         p->x.inst = 0;
00241         debug(fprint(stderr, "(clobbering %s)\n", p->syms[RX]->name));
00242         return prune(p->kids[1], prune(p->kids[0], pp));
00243     }
00244     else {
00245         prune(p->kids[1], prune(p->kids[0], &p->x.kids[0]));
00246         *pp = p;
00247         return pp + 1;
00248     }
00249 }

Here is the call graph for this function:

Node* prune (  Node  ,
Node * 
)  [static]
 

Referenced by prune().

void putreg (  Symbol   )  [static]
 

Definition at line 528 of file gen.c.

References assert, debug, dumpregs(), freemask, Regnode::mask, Xsymbol::name, NULL, r, Xsymbol::regnode, Regnode::set, Symbol, and symbol::x.

Referenced by gen(), ralloc(), and spillr().

00528                              {
00529     assert(r && r->x.regnode);
00530     freemask[r->x.regnode->set] |= r->x.regnode->mask;
00531     debug(dumpregs("(freeing %s)\n", r->x.name, NULL));
00532 }

Here is the call graph for this function:

void ralloc (  Node   )  [static]
 

Definition at line 607 of file gen.c.

References Xinterface::_templates, assert, Xinterface::clobber, Xnode::copy, symbol::cse, debug, dumpregs(), Xnode::equatable, fprint(), getreg(), getrule(), i, Xnode::inst, IR, Xnode::kids, Xsymbol::lastuse, Regnode::mask, mask, Xsymbol::name, NeedsReg, NELEMS, Node, node::op, opindex, opkind, p, Xnode::prevuse, putreg(), q, r, Xnode::registered, Xsymbol::regnode, Xinterface::rmap, symbol::sclass, stderr, Symbol, node::syms, symbol::t, symbol::temporary, tmask, symbol::u, Xsymbol::wildcard, interface::x, symbol::x, and node::x.

Referenced by gen(), and genspill().

00607                            {
00608     int i;
00609     unsigned mask[2];
00610 
00611     mask[0] = tmask[0];
00612     mask[1] = tmask[1];
00613     assert(p);
00614     debug(fprint(stderr, "(rallocing %x)\n", p));
00615     for (i = 0; i < NELEMS(p->x.kids) && p->x.kids[i]; i++) {
00616         Node kid = p->x.kids[i];
00617         Symbol r = kid->syms[RX];
00618         assert(r && kid->x.registered);
00619         if (r->sclass != REGISTER && r->x.lastuse == kid)
00620             putreg(r);
00621     }
00622     if (!p->x.registered && NeedsReg[opindex(p->op)]
00623     && (*IR->x.rmap)(opkind(p->op))) {
00624         Symbol sym = p->syms[RX], set = sym;
00625         assert(sym);
00626         if (sym->temporary)
00627             set = (*IR->x.rmap)(opkind(p->op));
00628         assert(set);
00629         if (set->sclass != REGISTER) {
00630             Symbol r;
00631             if (*IR->x._templates[getrule(p, p->x.inst)] == '?')
00632                 for (i = 1; i < NELEMS(p->x.kids) && p->x.kids[i]; i++) {
00633                     Symbol r = p->x.kids[i]->syms[RX];
00634                     assert(p->x.kids[i]->x.registered);
00635                     assert(r && r->x.regnode);
00636                     assert(sym->x.wildcard || sym != r);
00637                     mask[r->x.regnode->set] &= ~r->x.regnode->mask;
00638                 }
00639             r = getreg(set, mask, p);
00640             if (sym->temporary) {
00641                 Node q;
00642                 r->x.lastuse = sym->x.lastuse;
00643                 for (q = sym->x.lastuse; q; q = q->x.prevuse) {
00644                     q->syms[RX] = r;
00645                     q->x.registered = 1;
00646                     if (sym->u.t.cse && q->x.copy)
00647                         q->x.equatable = 1;
00648                 }
00649             } else {
00650                 p->syms[RX] = r;
00651                 r->x.lastuse = p;
00652             }
00653             debug(dumpregs("(allocating %s to node %x)\n", r->x.name, (char *) p));
00654         }
00655     }
00656     p->x.registered = 1;
00657     (*IR->x.clobber)(p);
00658 }

Here is the call graph for this function:

int range (  Node  p,
int  lo,
int  hi
) 
 

Definition at line 253 of file gen.c.

References ADDRF, ADDRL, symbol::c, ck, CNST, value::i, I, Node, Xsymbol::offset, node::op, value::p, P, p, s, specific, Symbol, node::syms, value::u, U, symbol::u, symbol::v, and symbol::x.

00253                                   {
00254     Symbol s = p->syms[0];
00255 
00256     switch (specific(p->op)) {
00257     case ADDRF+P:
00258     case ADDRL+P: ck(s->x.offset >= lo && s->x.offset <= hi);
00259     case CNST+I:  ck(s->u.c.v.i  >= lo && s->u.c.v.i  <= hi);
00260     case CNST+U:  ck(s->u.c.v.u  >= lo && s->u.c.v.u  <= hi);
00261     case CNST+P:  ck(s->u.c.v.p  == 0  && lo <= 0 && hi >= 0);
00262     }
00263     return LBURG_MAX;
00264 }

void reduce (  Node  ,
int 
)  [static]
 

Definition at line 185 of file gen.c.

References Xinterface::_isinstruction, Xinterface::_kids, Xinterface::_nts, assert, debug, fprint(), getrule(), i, Xnode::inst, IR, symbol::name, Node, p, reuse(), RX, stderr, node::syms, symbol::temporary, Xsymbol::usecount, symbol::x, node::x, and interface::x.

Referenced by rewrite().

00185                                    {
00186     int rulenum, i;
00187     short *nts;
00188     Node kids[10];
00189 
00190     p = reuse(p, nt);
00191     rulenum = getrule(p, nt);
00192     nts = IR->x._nts[rulenum];
00193     (*IR->x._kids)(p, rulenum, kids);
00194     for (i = 0; nts[i]; i++)
00195         reduce(kids[i], nts[i]);
00196     if (IR->x._isinstruction[rulenum]) {
00197         assert(p->x.inst == 0 || p->x.inst == nt);
00198         p->x.inst = nt;
00199         if (p->syms[RX] && p->syms[RX]->temporary) {
00200             debug(fprint(stderr, "(using %s)\n", p->syms[RX]->name));
00201             p->syms[RX]->x.usecount++;
00202         }
00203     }
00204 }

Here is the call graph for this function:

unsigned regloc (  Symbol  p  ) 
 

Definition at line 826 of file gen.c.

References assert, Regnode::number, p, Xsymbol::regnode, symbol::sclass, Regnode::set, Symbol, and symbol::x.

00826                           {
00827     assert(p && p->sclass == REGISTER && p->sclass == REGISTER && p->x.regnode);
00828     return p->x.regnode->set<<8 | p->x.regnode->number;
00829 }

int reprune (  Node *  ,
int  ,
int  ,
Node 
)  [static]
 

Definition at line 772 of file gen.c.

References debug, fprint(), Xnode::inst, IR, k, Xnode::kids, node::kids, n, Node, NULL, p, q, reprune(), stderr, Xinterface::target, interface::x, node::x, and x.

Referenced by genreload(), and reprune().

00772                                                    {
00773     struct node x, *q = *pp;
00774 
00775     if (q == NULL || k > n)
00776         return k;
00777     else if (q->x.inst == 0)
00778         return reprune(&q->kids[1],
00779             reprune(&q->kids[0], k, n, p), n, p);
00780     if (k == n) {
00781         debug(fprint(stderr, "(reprune changes %x from %x to %x)\n", pp, *pp, p->x.kids[n]));
00782         *pp = p->x.kids[n];
00783         x = *p;
00784         (IR->x.target)(&x);
00785     }
00786     return k + 1;
00787 }

Here is the call graph for this function:

int requate (  Node   )  [static]
 

Definition at line 386 of file gen.c.

References assert, CALL, Xnode::copy, debug, fprint(), generic, Xnode::kids, LABEL, moveself(), n, Xsymbol::name, Xnode::next, Node, node::op, p, q, readsreg, RX, setsrc, Xnode::spills, src, stderr, Symbol, node::syms, V, coord::x, symbol::x, and node::x.

Referenced by emit().

00386                            {
00387     Symbol src = q->x.kids[0]->syms[RX];
00388     Symbol tmp = q->syms[RX];
00389     Node p;
00390     int n = 0;
00391 
00392     debug(fprint(stderr, "(requate(%x): tmp=%s src=%s)\n", q, tmp->x.name, src->x.name));
00393     for (p = q->x.next; p; p = p->x.next)
00394         if (p->x.copy && p->syms[RX] == src
00395         &&  p->x.kids[0]->syms[RX] == tmp)
00396             debug(fprint(stderr, "(requate arm 0 at %x)\n", p)),
00397             p->syms[RX] = tmp;
00398         else if (setsrc(p->syms[RX]) && !moveself(p) && !readsreg(p))
00399             return 0;
00400         else if (p->x.spills)
00401             return 0;
00402         else if (generic(p->op) == CALL && p->x.next)
00403             return 0;
00404         else if (p->op == LABEL+V && p->x.next)
00405             return 0;
00406         else if (p->syms[RX] == tmp && readsreg(p))
00407             debug(fprint(stderr, "(requate arm 5 at %x)\n", p)),
00408             n++;
00409         else if (p->syms[RX] == tmp)
00410             break;
00411     debug(fprint(stderr, "(requate arm 7 at %x)\n", p));
00412     assert(n > 0);
00413     for (p = q->x.next; p; p = p->x.next)
00414         if (p->syms[RX] == tmp && readsreg(p)) {
00415             p->syms[RX] = src;
00416             if (--n <= 0)
00417                 break;
00418         }
00419     return 1;
00420 }

Here is the call graph for this function:

Node reuse (  Node  ,
int 
)  [static]
 

Definition at line 205 of file gen.c.

References symbol::cse, generic, INDIR, node::kids, Xnode::mayrecalc, Node, node::op, P, p, r, Xnode::state, Symbol, node::syms, symbol::t, symbol::u, VREG, and node::x.

Referenced by dumpcover(), emitasm(), and reduce().

00205                                   {
00206     struct _state {
00207         short cost[1];
00208     };
00209     Symbol r = p->syms[RX];
00210 
00211     if (generic(p->op) == INDIR && p->kids[0]->op == VREG+P
00212     && r->u.t.cse && p->x.mayrecalc
00213     && ((struct _state*)r->u.t.cse->x.state)->cost[nt] == 0)
00214         return r->u.t.cse;
00215     else
00216         return p;
00217 }

void rewrite (  Node   )  [static]
 

Definition at line 470 of file gen.c.

References Xinterface::_label, assert, debug, dumpcover(), dumptree(), fprint(), Xnode::inst, IR, Node, p, prelabel(), reduce(), stderr, interface::x, and node::x.

Referenced by gen(), genreload(), and genspill().

00470                             {
00471     assert(p->x.inst == 0);
00472     prelabel(p);
00473     debug(dumptree(p));
00474     debug(fprint(stderr, "\n"));
00475     (*IR->x._label)(p);
00476     debug(dumpcover(p, 1, 0));
00477     reduce(p, 1);
00478 }

Here is the call graph for this function:

void rtarget (  Node  p,
int  n,
Symbol  r
) 
 

Definition at line 452 of file gen.c.

References assert, symbol::cse, debug, fprint(), Xnode::kids, node::kids, LOAD, n, Xsymbol::name, newnode(), Node, NULL, node::op, opkind, p, q, r, RX, symbol::sclass, setreg(), stderr, Symbol, node::syms, symbol::t, symbol::u, Xsymbol::wildcard, node::x, and symbol::x.

Referenced by prelabel().

00452                                       {
00453     Node q = p->kids[n];
00454 
00455     assert(q);
00456     assert(r);
00457     assert(r->sclass == REGISTER || !r->x.wildcard);
00458     assert(q->syms[RX]);
00459     if (r != q->syms[RX] && !q->syms[RX]->x.wildcard) {
00460         q = newnode(LOAD + opkind(q->op),
00461             q, NULL, q->syms[0]);
00462         if (r->u.t.cse == p->kids[n])
00463             r->u.t.cse = q;
00464         p->kids[n] = p->x.kids[n] = q;
00465         q->x.kids[0] = q->kids[0];
00466     }
00467     setreg(q, r);
00468     debug(fprint(stderr, "(targeting %x->x.kids[%d]=%x to %s)\n", p, n, p->kids[n], r->x.name));
00469 }

Here is the call graph for this function:

void setreg (  Node  p,
Symbol  r
) 
 

Definition at line 449 of file gen.c.

References Node, p, Symbol, and node::syms.

Referenced by prelabel(), and rtarget().

00449                               {
00450     p->syms[RX] = r;
00451 }

void spill (  unsigned  mask,
int  n,
Node  here
) 
 

Definition at line 788 of file gen.c.

References assert, freemask, i, Xnode::kids, Regnode::mask, mask, n, NELEMS, Xnode::next, Node, NULL, p, r, Xnode::registered, Xsymbol::regnode, RX, Regnode::set, spillr(), Xnode::spills, Symbol, node::syms, usedmask, symbol::x, and node::x.

Referenced by getreg().

00788                                             {
00789     int i;
00790     Node p;
00791 
00792     here->x.spills = 1;
00793     usedmask[n] |= mask;
00794     if (mask&~freemask[n]) {
00795 
00796         assert( /* It makes no sense for a node to clobber() its target. */
00797             here->x.registered == 0 || /* call isn't coming through clobber() */
00798             here->syms[RX] == NULL ||
00799             here->syms[RX]->x.regnode == NULL ||
00800             here->syms[RX]->x.regnode->set != n ||
00801             (here->syms[RX]->x.regnode->mask&mask) == 0
00802         );
00803 
00804         for (p = here; p; p = p->x.next)
00805             for (i = 0; i < NELEMS(p->x.kids) && p->x.kids[i]; i++) {
00806                 Symbol r = p->x.kids[i]->syms[RX];
00807                 assert(r);
00808                 if (p->x.kids[i]->x.registered && r->x.regnode->set == n
00809                 && r->x.regnode->mask&mask)
00810                     spillr(r, here);
00811             }
00812     }
00813 }

Here is the call graph for this function:

Symbol spillee (  Symbol  ,
unsigned  mask[],
Node 
)  [static]
 

Definition at line 659 of file gen.c.

References assert, i, mask, Xnode::next, Node, NULL, q, Xsymbol::regnode, ri, Symbol, tmask, uses(), Regnode::vbl, Xsymbol::wildcard, node::x, and symbol::x.

Referenced by getreg().

00659                                                               {
00660     Symbol bestreg = NULL;
00661     int bestdist = -1, i;
00662 
00663     assert(set);
00664     if (!set->x.wildcard)
00665         bestreg = set;
00666     else {
00667         for (i = 31; i >= 0; i--) {
00668             Symbol ri = set->x.wildcard[i];
00669             if (
00670                 ri != NULL &&
00671                 ri->x.lastuse &&
00672                 (ri->x.regnode->mask&tmask[ri->x.regnode->set]&mask[ri->x.regnode->set])
00673             ) {
00674                 Regnode rn = ri->x.regnode;
00675                 Node q = here;
00676                 int dist = 0;
00677                 for (; q && !uses(q, rn); q = q->x.next)
00678                     dist++;
00679                 if (q && dist > bestdist) {
00680                     bestdist = dist;
00681                     bestreg = ri;
00682                 }
00683             }
00684         }
00685     }
00686     assert(bestreg); /* Must be able to spill something. Reconfigure the register allocator
00687         to ensure that we can allocate a register for all nodes without spilling
00688         the node's necessary input regs. */ 
00689     assert(bestreg->x.regnode->vbl == NULL); /* Can't spill register variables because
00690         the reload site might be in other blocks. Reconfigure the register allocator
00691         to ensure that this register is never allocated to a variable. */
00692     return bestreg;
00693 }

Here is the call graph for this function:

void spillr (  Symbol  ,
Node 
)  [static]
 

Definition at line 707 of file gen.c.

References assert, genreload(), genspill(), i, k, Xnode::kids, Xsymbol::lastuse, NELEMS, newtemp(), Xnode::next, Node, node::op, opsize, optype, p, Xnode::prevuse, putreg(), r, readsreg, Xnode::registered, RX, Symbol, node::syms, node::x, and symbol::x.

Referenced by spill().

00707                                         {
00708     int i;
00709     Symbol tmp;
00710     Node p = r->x.lastuse;
00711     assert(p);
00712     while (p->x.prevuse)
00713         assert(r == p->syms[RX]),
00714         p = p->x.prevuse;
00715     assert(p->x.registered && !readsreg(p));
00716     tmp = newtemp(AUTO, optype(p->op), opsize(p->op));
00717     genspill(r, p, tmp);
00718     for (p = here->x.next; p; p = p->x.next)
00719         for (i = 0; i < NELEMS(p->x.kids) && p->x.kids[i]; i++) {
00720             Node k = p->x.kids[i];
00721             if (k->x.registered && k->syms[RX] == r)
00722                 genreload(p, tmp, i);
00723         }
00724     putreg(r);
00725 }

Here is the call graph for this function:

int uses (  Node  ,
Regnode 
)  [static]
 

Definition at line 694 of file gen.c.

References i, Xnode::kids, Regnode::mask, NELEMS, Node, p, Xnode::registered, Xsymbol::regnode, Regnode::set, node::syms, symbol::x, and node::x.

Referenced by spillee().

00694                                     {
00695     int i;
00696 
00697     for (i = 0; i < NELEMS(p->x.kids); i++)
00698         if (
00699             p->x.kids[i] &&
00700             p->x.kids[i]->x.registered &&
00701             rn->set == p->x.kids[i]->syms[RX]->x.regnode->set &&
00702             (rn->mask&p->x.kids[i]->syms[RX]->x.regnode->mask)
00703         )
00704             return 1;
00705     return 0;
00706 }

Variable Documentation

int argoffset
 

Definition at line 45 of file gen.c.

Referenced by docall(), gen02(), and mkactual().

int bflag = 0
 

Definition at line 50 of file gen.c.

Referenced by parseflags().

int dalign
 

Definition at line 49 of file gen.c.

int dflag = 0
 

Definition at line 51 of file gen.c.

Referenced by parseflags().

unsigned(* emitter)(Node, int) = emitasm
 

Definition at line 55 of file gen.c.

int framesize
 

Definition at line 44 of file gen.c.

Referenced by emitasm().

unsigned freemask[2]
 

Definition at line 75 of file gen.c.

Referenced by askfixedreg(), blockbeg(), blockend(), dumpregs(), putreg(), and spill().

Node head
 

Definition at line 73 of file gen.c.

Referenced by CG_Player(), CG_PlayerAngles(), ChopBrushes(), gen(), Heading(), Info_NextPair(), Map_RestoreBetween(), S_Respatialize(), swstmt(), UI_DrawPlayer(), UI_DrawPlayerModel(), UI_OpponentLeaderModel(), and UI_PlayerAngles().

int maxargoffset
 

Definition at line 47 of file gen.c.

Referenced by docall(), and gen02().

int maxoffset
 

Definition at line 42 of file gen.c.

Referenced by blockend().

char NeedsReg[] [static]
 

Initial value:

 {
    0,                      
    1,                      
    0, 0,                   
    1,                      
    0, 0, 1, 1,             
    1, 0, 1, 1,             
    1,                      
    1,                      
    0,                      
    1, 1, 1,                
    1, 1, 1, 1, 1,          
    1, 1, 1, 1,             
    1, 1,                   
    0, 0, 0, 0, 0, 0,       
    0, 0                   
}

Definition at line 56 of file gen.c.

Referenced by gen(), genspill(), prelabel(), and ralloc().

int offset
 

Definition at line 40 of file gen.c.

Referenced by AAS_LoadAASFile(), AAS_LoadAASLump(), audioDeviceIOProc(), blockend(), CG_AddLagometerFrameInfo(), CG_MachineGunEjectBrass(), CG_MakeExplosion(), CG_PlasmaTrail(), CG_ShotgunEjectBrass(), CM_PositionTestInPatchCollide(), CM_TestBoundingBoxInCapsule(), CM_TestCapsuleInCapsule(), CM_Trace(), CM_TraceBoundingBoxThroughCapsule(), CM_TraceCapsuleThroughCapsule(), CM_TracePointThroughPatchCollide(), CM_TraceThroughPatchCollide(), CM_TraceThroughTree(), CM_TransformedBoxTrace(), ColinearEdge(), do_field(), DumpPACKDirectory(), emitSymbol(), FS_Seek(), GetConfigString(), HL_LoadBSPFile(), HL_LoadMapFromBSP(), Huff_Compress(), Huff_Decompress(), Huff_getBit(), Huff_offsetReceive(), Huff_offsetTransmit(), Huff_putBit(), Item_TextField_Paint(), LoadFile(), mkauto(), PakLoadAnyFile(), Q1_LoadBSPFile(), Q1_LoadMapFromBSP(), Q2_LoadBSPFile(), Q2_LoadMapFromBSP(), R_MergedHeightPoints(), R_MergedWidthPoints(), RB_CalcDeformVertexes(), RB_CalcMoveVertexes(), ReadPACKDirectory(), ReadQuakeFile(), recurseQuad(), S_Callback(), Sin_LoadBSPFile(), Sin_LoadMapFromBSP(), SpawnModelOnVictoryPad(), Sys_StreamSeek(), trap_FS_Seek(), and UI_BinaryServerInsertion().

int salign
 

Definition at line 49 of file gen.c.

Referenced by blkunroll().

int swap
 

Definition at line 53 of file gen.c.

unsigned tmask[2]
 

Definition at line 77 of file gen.c.

Referenced by ralloc(), and spillee().

unsigned usedmask[2]
 

Definition at line 76 of file gen.c.

Referenced by askfixedreg(), and spill().

unsigned vmask[2]
 

Definition at line 78 of file gen.c.

Referenced by askregvar().

Generated on Thu Aug 25 15:54:32 2005 for Quake III Arena by  doxygen 1.3.9.1