sys/src/cmd/7c/gc.h

   1 #include        "../cc/cc.h"
   2 #include        "../7c/7.out.h"
   3
   4 /*
   5  * 7c/alpha
   6  * DEC Alpha
   7  */
   8 #define SZ_CHAR         1
   9 #define SZ_SHORT        2
  10 #define SZ_INT          4
  11 #define SZ_LONG         4
  12 #define SZ_IND          4
  13 #define SZ_FLOAT        4
  14 #define SZ_VLONG        8
  15 #define SZ_DOUBLE       8
  16 #define FNX             100
  17
  18 typedef struct  Adr     Adr;
  19 typedef struct  Prog    Prog;
  20 typedef struct  Case    Case;
  21 typedef struct  C1      C1;
  22 typedef struct  Multab  Multab;
  23 typedef struct  Hintab  Hintab;
  24 typedef struct  Bits    Bits;
  25 typedef struct  Var     Var;
  26 typedef struct  Reg     Reg;
  27 typedef struct  Rgn     Rgn;
  28
  29 struct  Adr
  30 {
  31         union
  32         {
  33                 vlong   offset;
  34                 double  dval;
  35                 char    sval[NSNAME];
  36                 Ieee    ieee;
  37         };
  38         Sym*    sym;
  39         char    type;
  40         char    reg;
  41         char    name;
  42         char    etype;
  43 };
  44 #define A       ((Adr*)0)
  45
  46 #define INDEXED 9
  47 struct  Prog
  48 {
  49         Adr     from;
  50         Adr     to;
  51         Prog*   link;
  52         long    lineno;
  53         uchar   as;
  54         char    reg;
  55 };
  56 #define P       ((Prog*)0)
  57
  58 struct  Case
  59 {
  60         Case*   link;
  61         vlong   val;
  62         long    label;
  63         char    def;
  64         char isv;
  65 };
  66 #define C       ((Case*)0)
  67
  68 struct  C1
  69 {
  70         vlong   val;
  71         long    label;
  72 };
  73
  74 struct  Multab
  75 {
  76         long    val;
  77         char    code[20];
  78 };
  79
  80 struct  Hintab
  81 {
  82         ushort  val;
  83         char    hint[10];
  84 };
  85
  86 struct  Var
  87 {
  88         vlong   offset;
  89         Sym*    sym;
  90         char    name;
  91         char    etype;
  92 };
  93
  94 struct  Reg
  95 {
  96         long    pc;
  97         long    rpo;            /* reverse post ordering */
  98
  99         Bits    set;
 100         Bits    use1;
 101         Bits    use2;
 102
 103         Bits    refbehind;
 104         Bits    refahead;
 105         Bits    calbehind;
 106         Bits    calahead;
 107         Bits    regdiff;
 108         Bits    act;
 109
 110         long    regu;
 111         long    loop;           /* could be shorter */
 112
 113         union
 114         {
 115                 Reg*    log5;
 116                 long    active;
 117         };
 118         Reg*    p1;
 119         Reg*    p2;
 120         Reg*    p2link;
 121         Reg*    s1;
 122         Reg*    s2;
 123         Reg*    link;
 124         Prog*   prog;
 125 };
 126 #define R       ((Reg*)0)
 127
 128 #define NRGN    600
 129 struct  Rgn
 130 {
 131         Reg*    enter;
 132         short   cost;
 133         short   varno;
 134         short   regno;
 135 };
 136
 137 EXTERN long     breakpc;
 138 EXTERN long     nbreak;
 139 EXTERN Case*    cases;
 140 EXTERN Node     constnode;
 141 EXTERN Node     fconstnode;
 142 EXTERN long     continpc;
 143 EXTERN long     curarg;
 144 EXTERN long     cursafe;
 145 EXTERN Prog*    firstp;
 146 EXTERN Prog*    lastp;
 147 EXTERN long     maxargsafe;
 148 EXTERN int      mnstring;
 149 EXTERN Multab   multab[20];
 150 EXTERN int      hintabsize;
 151 EXTERN Node*    nodrat;
 152 EXTERN Node*    nodret;
 153 EXTERN Node*    nodsafe;
 154 EXTERN long     nrathole;
 155 EXTERN long     nstring;
 156 EXTERN Prog*    p;
 157 EXTERN long     pc;
 158 EXTERN Node     regnode;
 159 EXTERN char     string[NSNAME];
 160 EXTERN Sym*     symrathole;
 161 EXTERN Node     znode;
 162 EXTERN Prog     zprog;
 163 EXTERN char     reg[NREG+NREG];
 164 EXTERN long     exregoffset;
 165 EXTERN long     exfregoffset;
 166
 167 #define BLOAD(r)        band(bnot(r->refbehind), r->refahead)
 168 #define BSTORE(r)       band(bnot(r->calbehind), r->calahead)
 169 #define LOAD(r)         (~r->refbehind.b[z] & r->refahead.b[z])
 170 #define STORE(r)        (~r->calbehind.b[z] & r->calahead.b[z])
 171
 172 #define bset(a,n)       ((a).b[(n)/32]&(1L<<(n)%32))
 173
 174 #define CLOAD   4
 175 #define CREF    5
 176 #define CINF    1000
 177 #define LOOP    3
 178
 179 EXTERN  Rgn     region[NRGN];
 180 EXTERN  Rgn*    rgp;
 181 EXTERN  int     nregion;
 182 EXTERN  int     nvar;
 183
 184 EXTERN  Bits    externs;
 185 EXTERN  Bits    params;
 186 EXTERN  Bits    consts;
 187 EXTERN  Bits    addrs;
 188 EXTERN  Bits    zbits;
 189
 190 EXTERN  long    regbits;
 191 EXTERN  long    exregbits;
 192
 193 EXTERN  int     change;
 194 EXTERN  int     suppress;
 195
 196 EXTERN  Reg*    firstr;
 197 EXTERN  Reg*    lastr;
 198 EXTERN  Reg     zreg;
 199 EXTERN  Reg*    freer;
 200 EXTERN  Var     var[NVAR];
 201 EXTERN  long*   idom;
 202 EXTERN  Reg**   rpo2r;
 203 EXTERN  long    maxnr;
 204
 205 extern  char*   anames[];
 206 extern  Hintab  hintab[];
 207
 208 /*
 209  * sgen.c
 210  */
 211 void    codgen(Node*, Node*);
 212 void    gen(Node*);
 213 void    usedset(Node*, int);
 214 void    noretval(int);
 215 void    xcom(Node*);
 216 int     bcomplex(Node*, Node*);
 217
 218 /*
 219  * cgen.c
 220  */
 221 void    cgen(Node*, Node*);
 222 void    reglcgen(Node*, Node*, Node*);
 223 void    lcgen(Node*, Node*);
 224 void    bcgen(Node*, int);
 225 void    boolgen(Node*, int, Node*);
 226 void    sugen(Node*, Node*, long);
 227 void    layout(Node*, Node*, int, int, Node*);
 228
 229 /*
 230  * txt.c
 231  */
 232 void    ginit(void);
 233 void    gclean(void);
 234 void    nextpc(void);
 235 void    gargs(Node*, Node*, Node*);
 236 void    garg1(Node*, Node*, Node*, int, Node**);
 237 Node*   nodconst(long);
 238 Node*   nod32const(vlong);
 239 Node*   nodfconst(double);
 240 void    nodreg(Node*, Node*, int);
 241 void    regret(Node*, Node*);
 242 void    regalloc(Node*, Node*, Node*);
 243 void    regfree(Node*);
 244 void    regialloc(Node*, Node*, Node*);
 245 void    regsalloc(Node*, Node*);
 246 void    regaalloc1(Node*, Node*);
 247 void    regaalloc(Node*, Node*);
 248 void    regind(Node*, Node*);
 249 void    gprep(Node*, Node*);
 250 void    raddr(Node*, Prog*);
 251 void    naddr(Node*, Adr*);
 252 void    gmove(Node*, Node*);
 253 void    gins(int a, Node*, Node*);
 254 void    gopcode(int, Node*, Node*, Node*);
 255 int     samaddr(Node*, Node*);
 256 void    gbranch(int);
 257 void    patch(Prog*, long);
 258 int     bconst(Node*);
 259 int     sconst(Node*);
 260 int     bval(vlong);
 261 int     sval(long);
 262 void    gpseudo(int, Sym*, Node*);
 263
 264 /*
 265  * swt.c
 266  */
 267 int     swcmp(void*, void*);
 268 void    doswit(Node*);
 269 void    swit1(C1*, int, long, Node*);
 270 void    swit2(C1*, int, long, Node*, Node*);
 271 void    casf(void);
 272 void    bitload(Node*, Node*, Node*, Node*, Node*);
 273 void    bitstore(Node*, Node*, Node*, Node*, Node*);
 274 long    outstring(char*, long);
 275 int     vlog(Node*);
 276 int     mulcon(Node*, Node*);
 277 Multab* mulcon0(long);
 278 void    nullwarn(Node*, Node*);
 279 void    sextern(Sym*, Node*, long, long);
 280 void    gextern(Sym*, Node*, long, long);
 281 void    outcode(void);
 282 void    ieeedtod(Ieee*, double);
 283
 284 /*
 285  * list
 286  */
 287 void    listinit(void);
 288 int     Pconv(Fmt*);
 289 int     Aconv(Fmt*);
 290 int     Dconv(Fmt*);
 291 int     Sconv(Fmt*);
 292 int     Nconv(Fmt*);
 293 int     Bconv(Fmt*);
 294
 295 /*
 296  * reg.c
 297  */
 298 Reg*    rega(void);
 299 int     rcmp(void*, void*);
 300 void    regopt(Prog*);
 301 void    addmove(Reg*, int, int, int);
 302 Bits    mkvar(Adr*, int);
 303 void    prop(Reg*, Bits, Bits);
 304 void    loopit(Reg*, long);
 305 void    synch(Reg*, Bits);
 306 ulong   allreg(ulong, Rgn*);
 307 void    paint1(Reg*, int);
 308 ulong   paint2(Reg*, int);
 309 void    paint3(Reg*, int, long, int);
 310 void    addreg(Adr*, int);
 311
 312 /*
 313  * peep.c
 314  */
 315 void    peep(void);
 316 void    excise(Reg*);
 317 Reg*    uniqp(Reg*);
 318 Reg*    uniqs(Reg*);
 319 int     regtyp(Adr*);
 320 int     regzer(Adr*);
 321 int     anyvar(Adr*);
 322 int     subprop(Reg*);
 323 int     copyprop(Reg*);
 324 int     copy1(Adr*, Adr*, Reg*, int);
 325 int     copyu(Prog*, Adr*, Adr*);
 326
 327 int     copyas(Adr*, Adr*);
 328 int     copyau(Adr*, Adr*);
 329 int     copyau1(Prog*, Adr*);
 330 int     copysub(Adr*, Adr*, Adr*, int);
 331 int     copysub1(Prog*, Adr*, Adr*, int);
 332
 333 long    RtoB(int);
 334 long    FtoB(int);
 335 int     BtoR(long);
 336 int     BtoF(long);
 337
 338 #pragma varargck        type    "A"     int
 339 #pragma varargck        type    "B"     Bits
 340 #pragma varargck        type    "D"     Adr*
 341 #pragma varargck        type    "N"     Adr*
 342 #pragma varargck        type    "P"     Prog*
 343 #pragma varargck        type    "S"     char*