Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20140601113352

Diff

Diff from 1.137 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/mip/pass2.h

Annotated File View

ragge
1.137
1 /*      $Id: pass2.h,v 1.137 2014/06/01 11:33:52 ragge Exp $    */
ragge
1.19
2 /*
3  * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * Redistributions of source code and documentation must retain the above
10  * copyright notice, this list of conditions and the following disclaimer.
11  * Redistributions in binary form must reproduce the above copyright
12  * notice, this list of conditionsand the following disclaimer in the
13  * documentation and/or other materials provided with the distribution.
14  * All advertising materials mentioning features or use of this software
15  * must display the following acknowledgement:
16  *      This product includes software developed or owned by Caldera
17  *      International, Inc.
18  * Neither the name of Caldera International, Inc. nor the names of other
19  * contributors may be used to endorse or promote products derived from
20  * this software without specific prior written permission.
21  *
22  * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
23  * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26  * DISCLAIMED.  IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
27  * FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OFLIABILITY, WHETHER IN CONTRACT,
31  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
32  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
33  * POSSIBILITY OF SUCH DAMAGE.
34  */
ragge
1.5
35 #include <sys/types.h>
36
ragge
1.55
37 #ifndef MKEXT
38 #include "external.h"
39 #else
mickey
1.114
40 typedef unsigned int bittype/* XXX - for basicblock */
41 #define BIT2BYTE(a)     (((a) + 31) / 32)
ragge
1.55
42 #endif
mickey
1.114
43 #include "manifest.h"
ragge
1.1
44
45 /* cookies, used as arguments to codgen */
46 #define FOREFF  01              /* compute for effects only */
47 #define INAREG  02              /* compute into a register */
ragge
1.75
48 #define INBREG  04              /* compute into a register */
49 #define INCREG  010             /* compute into a register */
50 #define INDREG  020             /* compute into a register */
51 #define INREGS  (INAREG|INBREG|INCREG|INDREG)
ragge
1.1
52 #define FORCC   040             /* compute for condition codes only */
ragge
1.111
53 #define QUIET   0100            /* tell geninsn() to not complain if fail */
ragge
1.1
54 #define INTEMP  010000          /* compute into a temporary location */
55 #define FORREW  040000          /* search the table for a rewrite rule */
ragge
1.115
56 #define INEREG  0x10000         /* compute into a register, > 16 bits */
57 #define INFREG  0x20000         /* compute into a register, > 16 bits */
58 #define INGREG  0x40000         /* compute into a register, > 16 bits */
ragge
1.1
59
60 /*
61  * OP descriptors,
62  * the ASG operator may be used on some of these
63  */
64 #define OPSIMP  010000          /* +, -, &, |, ^ */
65 #define OPCOMM  010002          /* +, &, |, ^ */
66 #define OPMUL   010004          /* *, / */
67 #define OPDIV   010006          /* /, % */
68 #define OPUNARY 010010          /* unary ops */
69 #define OPLEAF  010012          /* leaves */
70 #define OPANY   010014          /* any op... */
71 #define OPLOG   010016          /* logical ops */
72 #define OPFLOAT 010020          /* +, -, *, or / (for floats) */
73 #define OPSHFT  010022          /* <<, >> */
74 #define OPLTYPE 010024          /* leaf type nodes (e.g, NAME, ICON, etc.) */
75
76 /* shapes */
77 #define SANY    01              /* same as FOREFF */
78 #define SAREG   02              /* same as INAREG */
ragge
1.71
79 #define SBREG   04              /* same as INBREG */
ragge
1.75
80 #define SCREG   010             /* same as INCREG */
81 #define SDREG   020             /* same as INDREG */
ragge
1.1
82 #define SCC     040             /* same as FORCC */
ragge
1.18
83 #define SNAME   0100
84 #define SCON    0200
85 #define SFLD    0400
86 #define SOREG   01000
87 #define STARNM  02000
88 #define STARREG 04000
89 #define SWADD   040000
90 #define SPECIAL 0100000
91 #define SZERO   SPECIAL
92 #define SONE    (SPECIAL|1)
93 #define SMONE   (SPECIAL|2)
ragge
1.1
94 #define SCCON   (SPECIAL|3)     /* -256 <= constant < 256 */
95 #define SSCON   (SPECIAL|4)     /* -32768 <= constant < 32768 */
96 #define SSOREG  (SPECIAL|5)     /* non-indexed OREG */
ragge
1.87
97 #define MAXSPECIAL      (SPECIAL|5)
ragge
1.115
98 #define SEREG   0x10000         /* same as INEREG */
99 #define SFREG   0x20000         /* same as INFREG */
100 #define SGREG   0x40000         /* same as INGREG */
ragge
1.18
101
ragge
1.82
102 /* These are used in rstatus[] in conjunction with SxREG */
ragge
1.115
103 #define TEMPREG 01000
104 #define PERMREG 02000
ragge
1.82
105
ragge
1.38
106 /* tshape() return values */
107 #define SRNOPE  0               /* Cannot match any shape */
108 #define SRDIR   1               /* Direct match */
109 #define SROREG  2               /* Can convert into OREG */
110 #define SRREG   3               /* Must put into REG */
111
ragge
1.75
112 /* find*() return values */
ragge
1.77
113 #define FRETRY  -2
ragge
1.75
114 #define FFAIL   -1
115
ragge
1.32
116 /* INTEMP is carefully not conflicting with shapes */
ragge
1.1
117
118 /* types */
119 #define TCHAR           01      /* char */
120 #define TSHORT          02      /* short */
121 #define TINT            04      /* int */
122 #define TLONG           010     /* long */
123 #define TFLOAT          020     /* float */
124 #define TDOUBLE         040     /* double */
125 #define TPOINT          0100    /* pointer to something */
126 #define TUCHAR          0200    /* unsigned char */
127 #define TUSHORT         0400    /* unsigned short */
128 #define TUNSIGNED       01000   /* unsigned int */
129 #define TULONG          02000   /* unsigned long */
130 #define TPTRTO          04000   /* pointer to one of the above */
131 #define TANY            010000  /* matches anything within reason */
132 #define TSTRUCT         020000  /* structure or union */
ragge
1.4
133 #define TLONGLONG       040000  /* long long */
134 #define TULONGLONG      0100000 /* unsigned long long */
ragge
1.44
135 #define TLDOUBLE        0200000 /* long double; exceeds 16 bit */
ragge
1.51
136 #define TFTN            0400000 /* function pointer; exceeds 16 bit */
ragge
1.1
137
138 /* reclamation cookies */
139 #define RNULL           0       /* clobber result */
ragge
1.18
140 #define RLEFT           01
141 #define RRIGHT          02
142 #define RESC1           04
143 #define RESC2           010
144 #define RESC3           020
ragge
1.27
145 #define RDEST           040
ragge
1.18
146 #define RESCC           04000
ragge
1.1
147 #define RNOP            010000  /* DANGER: can cause loops.. */
148
149 /* needs */
ragge
1.115
150 #define NASL            0x0001  /* may share left register */
151 #define NASR            0x0002  /* may share right register */
152 #define NAREG           0x0004
153 #define NACOUNT         0x000c
154 #define NBSL            0x0010
155 #define NBSR            0x0020
156 #define NBREG           0x0040
157 #define NBCOUNT         0x00c0
158 #define NCSL            0x0100
159 #define NCSR            0x0200
160 #define NCREG           0x0400
161 #define NCCOUNT         0x0c00
162 #define NTEMP           0x1000
163 #define NTMASK          0x3000
164 #define NSPECIAL        0x4000  /* need special register treatment */
165 #define REWRITE         0x8000
166 #define NDSL            0x00010000      /* Above 16 bit */
167 #define NDSR            0x00020000      /* Above 16 bit */
168 #define NDREG           0x00040000      /* Above 16 bit */
169 #define NDCOUNT         0x000c0000
170 #define NESL            0x00100000      /* Above 16 bit */
171 #define NESR            0x00200000      /* Above 16 bit */
172 #define NEREG           0x00400000      /* Above 16 bit */
173 #define NECOUNT         0x00c00000
174 #define NFSL            0x01000000      /* Above 16 bit */
175 #define NFSR            0x02000000      /* Above 16 bit */
176 #define NFREG           0x04000000      /* Above 16 bit */
177 #define NFCOUNT         0x0c000000
178 #define NGSL            0x10000000      /* Above 16 bit */
179 #define NGSR            0x20000000      /* Above 16 bit */
ragge
1.127
180 #undef  NGREG   /* XXX - linux exposes NGREG to public */
ragge
1.115
181 #define NGREG           0x40000000      /* Above 16 bit */
182 #define NGCOUNT         0xc0000000
ragge
1.79
183
184 /* special treatment */
ragge
1.80
185 #define NLEFT           (0001)  /* left leg register (moveadd) */
186 #define NOLEFT          (0002)  /* avoid regs for left (addedge) */
187 #define NRIGHT          (0004)  /* right leg register */
188 #define NORIGHT         (0010)  /* avoid reg for right */
189 #define NEVER           (0020)  /* registers trashed (addalledges) */
190 #define NRES            (0040)  /* result register (moveadd) */
191 #define NMOVTO          (0100)  /* move between classes */
ragge
1.79
192
ragge
1.1
193
194 #define MUSTDO          010000  /* force register requirements */
195 #define NOPREF          020000  /* no preference for register assignment */
196
ragge
1.92
197 #define isreg(p)        (p->n_op == REG || p->n_op == TEMP)
ragge
1.1
198
199 extern  int fregs;
200
201 /* code tables */
202 extern  struct optab {
ragge
1.18
203         int     op;
204         int     visit;
205         int     lshape;
206         int     ltype;
207         int     rshape;
208         int     rtype;
209         int     needs;
210         int     rewrite;
211         char    *cstring;
ragge
1.1
212 table[];
213
ragge
1.70
214 /* Special needs for register allocations */
215 struct rspecial {
ragge
1.78
216         int opnum;
217 #if 0
218         int left;       /* left leg register */
219         int noleft;     /* avoid regs for left */
220         int right;      /* right leg register */
221         int noright;    /* avoid right leg register */
222         int *rmask;     /* array of destroyed registers */
223         int res;        /* Result ends up here */
224 //      void (*rew)(struct optab *, NODE *);    /* special rewrite */
225 #endif
ragge
1.70
226 };
227
ragge
1.116
228 struct p2env;
ragge
1.129
229 #define NRESC 4
ragge
1.1
230 extern  NODE resc[];
ragge
1.59
231 extern  int p2autooffp2maxautooff;
ragge
1.18
232
ragge
1.1
233 extern  NODE
ragge
1.2
234         *talloc(void),
235         *eread(void),
ragge
1.45
236         *mklnode(intCONSZintTWORD),
237         *mkbinode(intNODE *, NODE *, TWORD),
238         *mkunode(intNODE *, intTWORD),
ragge
1.2
239         *getlr(NODE *pint);
ragge
1.1
240
ragge
1.49
241 void eoftn(struct interpass_prolog *);
242 void prologue(struct interpass_prolog *);
ragge
1.87
243 void e2print(NODE *pint downint *aint *b);
ragge
1.22
244 void myoptim(struct interpass *);
ragge
1.24
245 void cbgen(int opint label);
ragge
1.27
246 int match(NODE *pint cookie);
gmcgarry
1.105
247 int acceptable(struct optab *);
ragge
1.29
248 int special(NODE *, int);
ragge
1.31
249 int setasg(NODE *, int);
250 int setuni(NODE *, int);
251 int sucomp(NODE *);
ragge
1.56
252 int nsucomp(NODE *);
ragge
1.96
253 int setorder(NODE *);
ragge
1.75
254 int geninsn(NODE *, int cookie);
ragge
1.33
255 void adrput(FILE *, NODE *);
256 void comperr(char *str, ...);
ragge
1.34
257 void genregs(NODE *p);
ragge
1.116
258 void ngenregs(struct p2env *);
ragge
1.41
259 NODE *store(NODE *);
ragge
1.45
260 struct interpass *ipnode(NODE *);
ragge
1.46
261 void deflab(int);
ragge
1.83
262 void rmove(intintTWORD);
ragge
1.78
263 int rspecial(struct optab *, int);
264 struct rspecial *nspecial(struct optab *q);
ragge
1.70
265 void printip(struct interpass *pole);
ragge
1.71
266 int findops(NODE *pint);
267 int findasg(NODE *pint);
268 int finduni(NODE *pint);
ragge
1.90
269 int findumul(NODE *pint);
ragge
1.71
270 int findleaf(NODE *pint);
271 int relops(NODE *p);
ragge
1.111
272 #ifdef FINDMOPS
273 int findmops(NODE *pint);
274 int treecmp(NODE *p1NODE *p2);
275 #endif
ragge
1.94
276 void offstar(NODE *pint shape);
ragge
1.80
277 int gclass(TWORD);
ragge
1.85
278 void lastcall(NODE *);
ragge
1.87
279 void myreader(struct interpass *pole);
ragge
1.91
280 int oregok(NODE *pint sharp);
ragge
1.97
281 void myormake(NODE *);
ragge
1.103
282 int *livecall(NODE *);
plunky
1.135
283 void prtreg(NODE *);
ragge
1.32
284 char *prcook(int);
ragge
1.108
285 int myxasm(struct interpass *ipNODE *p);
ragge
1.109
286 int xasmcode(char *s);
ragge
1.110
287 int freetemp(int k);
ragge
1.137
288 NODE *storenode(TWORD tint k);
289 void storemod(NODE *, int k);
ragge
1.110
290 int rewfld(NODE *p);
291 void canon(NODE *);
292 void mycanon(NODE *);
ragge
1.117
293 void oreg2(NODE *pvoid *);
ragge
1.111
294 int shumul(NODE *pint);
ragge
1.112
295 NODE *deluseless(NODE *p);
ragge
1.118
296 int getlab2(void);
ragge
1.126
297 int tshape(NODE *, int);
ragge
1.37
298 void conput(FILE *, NODE *);
ragge
1.126
299 int shtemp(NODE *p);
300 int ttype(TWORD tint tword);
301 void expand(NODE *, intchar *);
302 void hopcode(intint);
303 void adrcon(CONSZ);
304 void zzzcode(NODE *, int);
305 void insput(NODE *);
306 void upput(NODE *, int);
307 int tlen(NODE *p);
308 int setbin(NODE *);
309 int notoff(TWORDintCONSZchar *);
310 int fldexpand(NODE *, intchar **);
311 void p2tree(NODE *p); 
312 int flshape(NODE *p);
ragge
1.129
313 int ncnt(int needs);
314
ragge
1.1
315 extern  char *rnames[];
316
ragge
1.74
317 extern int classmask(int), tclassmask(int);
318 extern void cmapinit(void);
ragge
1.83
319 extern int aliasmap(int adjclassint regnum);
ragge
1.74
320 extern int regK[];
ragge
1.73
321 #define CLASSA  1
322 #define CLASSB  2
323 #define CLASSC  3
324 #define CLASSD  4
325 #define CLASSE  5
ragge
1.115
326 #define CLASSF  6
327 #define CLASSG  7
ragge
1.73
328
ragge
1.109
329 /* used when parsing xasm codes */
ragge
1.128
330 #define XASMVAL(x)      ((x) & 0377)            /* get val from codeword */
331 #define XASMVAL1(x)     (((x) >> 16) & 0377)    /* get val from codeword */
332 #define XASMVAL2(x)     (((x) >> 24) & 0377)    /* get val from codeword */
ragge
1.109
333 #define XASMASG         0x100   /* = */
334 #define XASMCONSTR      0x200   /* & */
335 #define XASMINOUT       0x400   /* + */
336 #define XASMALL         (XASMASG|XASMCONSTR|XASMINOUT)
337 #define XASMISINP(cw)   (((cw) & XASMASG) == 0)         /* input operand */
338 #define XASMISOUT(cw)   ((cw) & (XASMASG|XASMINOUT))    /* output operand */
339
ragge
1.88
340 /* routines to handle double indirection */
341 #ifdef R2REGS
342 void makeor2(NODE *pNODE *qintint);
343 int base(NODE *);
344 int offset(NODE *pint);
345 #endif
346
ragge
1.1
347 extern  int lineno;
plunky
1.131
348 extern  int ndebug;
349 extern  int b2debugc2debuge2debugf2debugg2debugo2debug;
350 extern  int r2debugs2debugt2debugu2debugx2debug;
351
gmcgarry
1.121
352 extern  int dope[];     /* a vector containing operator information */
353 extern  char *opst[];   /* a vector containing names for ops */
354
355 #ifdef PCC_DEBUG
356
357 static inline int
358 optype(int o)
359 {
360         if (o >= MAXOP+1)
361                 cerror("optype");
362         return (dope[o]&TYFLG);
363 }
364
365 static inline int
366 asgop(int o)
367 {
368         if (o >= MAXOP+1)
369                 cerror("asgop");
370         return (dope[o]&ASGFLG);
371 }
372
373 static inline int
374 logop(int o)
375 {
376         if (o >= MAXOP+1)
377                 cerror("logop");
378         return (dope[o]&LOGFLG);
379 }
380
381 static inline int
382 callop(int o)
383 {
384         if (o >= MAXOP+1)
385                 cerror("callop");
386         return (dope[o]&CALLFLG);
387 }
388
389 #else
390
ragge
1.16
391 #define optype(o)       (dope[o]&TYFLG)
392 #define asgop(o)        (dope[o]&ASGFLG) 
393 #define logop(o)        (dope[o]&LOGFLG)
394 #define callop(o)       (dope[o]&CALLFLG)
gmcgarry
1.121
395
396 #endif
ragge
1.16
397
ragge
1.18
398         /* macros for doing double indexing */
399 #define R2PACK(x,y,z)   (0200*((x)+1)+y+040000*z)
400 #define R2UPK1(x)       ((((x)>>7)-1)&0177)
401 #define R2UPK2(x)       ((x)&0177)
402 #define R2UPK3(x)       (x>>14)
403 #define R2TEST(x)       ((x)>=0200)
ragge
1.34
404
405 /*
406  * Layout of findops() return value:
ragge
1.113
407  *      bit 0 whether left shall go into a register.
408  *      bit 1 whether right shall go into a register.
409  *      bit 2 entry is only used for side effects.
410  *      bit 3 if condition codes are used.
ragge
1.89
411  *
ragge
1.113
412  * These values should be synced with FOREFF/FORCC.
ragge
1.34
413  */
414 #define LREG            001
ragge
1.113
415 #define RREG            002
416 #define RVEFF           004
417 #define RVCC            010
ragge
1.34
418 #define DORIGHT         020
ragge
1.75
419 #define SCLASS(v,x)     ((v) |= ((x) << 5))
420 #define TCLASS(x)       (((x) >> 5) & 7)
421 #define TBSH            8
ragge
1.34
422 #define TBLIDX(idx)     ((idx) >> TBSH)
423 #define MKIDX(tbl,mod)  (((tbl) << TBSH) | (mod))
424
ragge
1.48
425 #ifndef BREGS
426 #define BREGS   0
427 #define TBREGS  0
428 #endif
429 #define REGBIT(x) (1 << (x))
mickey
1.102
430 #ifndef PERMTYPE
431 #define PERMTYPE(a)     (INT)
432 #endif
ragge
1.48
433
ragge
1.122
434 /* Flags for the dataflow code */
435 /* do the live/dead analysis */
436 #define DO_LIVEDEAD  0x01
437 /* compute avail expressions */
438 #define DO_AVAILEXPR 0x02
439 /* Do an update on the live/dead. One variable only */
440 #define DO_UPDATELD  0x04
441 /* Do an update on available expressions, one variable has changed */
442 #define DO_UPDATEEX  0x08
443
ragge
1.61
444 void emit(struct interpass *);
ragge
1.116
445 void optimize(struct p2env *);
pj
1.50
446
447 struct basicblock {
ragge
1.55
448         DLIST_ENTRY(basicblockbbelem;
ragge
1.132
449         SLIST_HEAD(, cfgnodeparents;  /* CFG - parents to this node */
450         SLIST_HEAD(, cfgnodechild;    /* Children, usually max 2 of them */
ragge
1.69
451         int bbnum;      /* this basic block number */
pj
1.52
452         unsigned int dfnum/* DFS-number */
453         unsigned int dfparent/* Parent in DFS */
454         unsigned int semi;
455         unsigned int ancestor;
456         unsigned int idom;
457         unsigned int samedom;
ragge
1.55
458         bittype *bucket;
459         bittype *df;
460         bittype *dfchildren;
pj
1.62
461         bittype *Aorig;
462         bittype *Aphi;
pantzer
1.119
463         SLIST_HEAD(, phiinfophi;
ragge
1.122
464
ragge
1.124
465         bittype *gen, *killed, *in, *out;       /* Liveness analysis */
ragge
1.122
466
pj
1.50
467         struct interpass *first/* first element of basic block */
468         struct interpass *last;  /* last element of basic block */
469 };
470
471 struct labelinfo {
472         struct basicblock **arr;
gmcgarry
1.107
473         int size;
pj
1.50
474         unsigned int low;
475 };
476
pj
1.52
477 struct bblockinfo {
gmcgarry
1.107
478         int size;
pj
1.52
479         struct basicblock **arr;
480 };
481
pj
1.57
482 struct varinfo {
483         struct pvarinfo **arr;
pantzer
1.119
484         SLIST_HEAD(, varstack) *stack;
pj
1.57
485         int size;
486         int low;
487 };
488
489 struct pvarinfo {
490         struct pvarinfo *next;
491         struct basicblock *bb;
pantzer
1.119
492         TWORD n_type;
pj
1.57
493 };
494
pantzer
1.119
495 struct varstack {
496         SLIST_ENTRY(varstackvarstackelem;
497         int tmpregno;
498 };
499
500
pj
1.50
501 struct cfgnode {
ragge
1.55
502         SLIST_ENTRY(cfgnodecfgelem;
ragge
1.132
503         SLIST_ENTRY(cfgnodechld;
pj
1.50
504         struct basicblock *bblock;
505 };
506
pantzer
1.119
507 struct phiinfo {
508         SLIST_ENTRY(phiinfophielem;
509         int tmpregno;
510         int newtmpregno;
511         TWORD n_type;
512         int size;
513         int *intmpregno;
514 };
515
pj
1.58
516 /*
ragge
1.116
517  * Description of the pass2 environment.
518  * There will be only one of these structs.  It is used to keep
519  * all state descriptions during the compilation of a function
520  * in one place.
521  */
522 struct p2env {
523         struct interpass ipole;                 /* all statements */
524         struct interpass_prolog *ipp, *epp;     /* quick references */
ragge
1.123
525         struct bblockinfo bbinfo;
526         struct labelinfo labinfo;
ragge
1.116
527         struct basicblock bblocks;
528         int nbblocks;
529 };
530
531 extern struct p2env p2env;
532
533 /*
pj
1.58
534  * C compiler second pass extra defines.
535  */
ragge
1.63
536 #define PHI (MAXOP + 1)         /* Used in SSA trees */
FishEye: Open Source License registered to PCC.
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-12-21 02:10 +0100