Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030804095510

Diff

Diff from 1.36 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/mip/common.c

Annotated File View

ragge
1.36
1 /*      $Id: common.c,v 1.36 2003/08/04 09:55:10 ragge Exp $    */
ragge
1.29
2 /*
3  * Copyright (c) 2003 Anders Magnusson (ragge@ludd.luth.se).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  * 3. The name of the author may not be used to endorse or promote products
15  *    derived from this software without specific prior written permission
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 /*
30  * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
31  *
32  * Redistribution and use in source and binary forms, with or without
33  * modification, are permitted provided that the following conditions
34  * are met:
35  *
36  * Redistributions of source code and documentation must retain the above
37  * copyright notice, this list of conditions and the following disclaimer.
38  * Redistributions in binary form must reproduce the above copyright
39  * notice, this list of conditionsand the following disclaimer in the
40  * documentation and/or other materials provided with the distribution.
41  * All advertising materials mentioning features or use of this software
42  * must display the following acknowledgement:
43  *      This product includes software developed or owned by Caldera
44  *      International, Inc.
45  * Neither the name of Caldera International, Inc. nor the names of other
46  * contributors may be used to endorse or promote products derived from
47  * this software without specific prior written permission.
48  *
49  * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
50  * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
51  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
52  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
53  * DISCLAIMED.  IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
54  * FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
55  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
56  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
57  * HOWEVER CAUSED AND ON ANY THEORY OFLIABILITY, WHETHER IN CONTRACT,
58  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
59  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
60  * POSSIBILITY OF SUCH DAMAGE.
61  */
ragge
1.1
62
ragge
1.2
63 #include <stdarg.h>
64 #include <stdlib.h>
ragge
1.10
65 #include <stdio.h>
ragge
1.2
66
ragge
1.32
67 #include "pass2.h"
ragge
1.1
68
69 # ifndef EXIT
70 # define EXIT exit
71 # endif
72
73 int nerrors = 0;  /* number of errors */
ragge
1.33
74 extern char *ftitle;
ragge
1.1
75
ragge
1.10
76 #ifndef WHERE
77 #define WHERE(ch) fprintf(stderr, "%s, line %d: ", ftitle, lineno);
78 #endif
ragge
1.1
79
ragge
1.2
80 /*
81  * nonfatal error message
82  * the routine where is different for pass 1 and pass 2;
83  * it tells where the error took place
84  */
85 void
86 uerror(char *s, ...)
87 {
88         va_list ap;
ragge
1.1
89
ragge
1.2
90         va_start(aps);
ragge
1.1
91         ++nerrors;
ragge
1.10
92         WHERE('u');
ragge
1.2
93         vfprintf(stderrsap);
94         fprintf(stderr"\n");
95         if (nerrors > 30)
96                 cerror("too many errors");
97         va_end(ap);
98 }
99
100 /*
101  * compiler error: die
102  */
103 void
104 cerror(char *s, ...)
105 {
106         va_list ap;
ragge
1.1
107
ragge
1.2
108         va_start(aps);
ragge
1.10
109         WHERE('c');
ragge
1.2
110
111         /* give the compiler the benefit of the doubt */
112         if (nerrors && nerrors <= 30) {
113                 fprintf(stderr,
114                     "cannot recover from earlier errors: goodbye!\n");
115         } else {
116                 fprintf(stderr"compiler error: ");
117                 vfprintf(stderrsap);
118                 fprintf(stderr"\n");
119         }
120         va_end(ap);
ragge
1.1
121         EXIT(1);
ragge
1.2
122 }
ragge
1.1
123
ragge
1.2
124 /*
125  * warning
126  */
127 void
128 werror(char *s, ...)
129 {
130         va_list ap;
131
132         va_start(aps);
ragge
1.10
133         WHERE('w');
ragge
1.2
134         fprintf(stderr"warning: ");
135         vfprintf(stderrsap);
136         fprintf(stderr"\n");
137 }
ragge
1.1
138
ragge
1.22
139 static NODE *freelink;
ragge
1.24
140 static int usednodes;
ragge
1.22
141
ragge
1.1
142 NODE *
ragge
1.2
143 talloc()
144 {
ragge
1.24
145         extern int inlnodecntrecovernodes;
146         register NODE *p;
147
148         if ((usednodes++ - inlnodecnt) > TREESZ)
ragge
1.25
149                 cerror("out of tree space; usednodes %d inlnodecnt %d",
150                     usednodesinlnodecnt);
ragge
1.1
151
ragge
1.24
152         if (recovernodes)
153                 inlnodecnt++;
ragge
1.22
154         if (freelink != NULL) {
155                 p = freelink;
156                 freelink = p->next;
157                 if (p->n_op != FREE)
ragge
1.23
158                         cerror("node not FREE: %p"p);
159                 if (nflag)
160                         printf("alloc node %p from freelist\n"p);
ragge
1.22
161                 return p;
162         }
163
ragge
1.24
164         p = permalloc(sizeof(NODE));
165         p->n_op = FREE;
166         if (nflag)
167                 printf("alloc node %p from memory\n"p);
168         return p;
ragge
1.2
169 }
ragge
1.1
170
ragge
1.2
171 /*
172  * ensure that all nodes have been freed
173  */
174 void
175 tcheck()
176 {
ragge
1.24
177         extern int inlnodecnt;
ragge
1.1
178
ragge
1.24
179         if (nerrors)
180                 return;
181
182         if ((usednodes - inlnodecnt) != 0)
183                 cerror("usednodes == %d, inlnodecnt %d"usednodesinlnodecnt);
ragge
1.2
184 }
ragge
1.1
185
ragge
1.2
186 /*
187  * free the tree p
188  */
189 void
190 tfree(NODE *p)
191 {
ragge
1.12
192         if (p->n_op != FREE)
ragge
1.22
193                 walkf(pnfree);
ragge
1.2
194 }
ragge
1.1
195
ragge
1.2
196 void
ragge
1.22
197 nfree(NODE *p)
ragge
1.2
198 {
ragge
1.24
199         extern int inlnodecntrecovernodes;
ragge
1.36
200 #ifdef PCC_DEBUG
ragge
1.31
201         NODE *q;
ragge
1.36
202 #endif
ragge
1.22
203
204         if (p != NULL) {
205                 if (p->n_op == FREE)
206                         cerror("freeing FREE node"p);
ragge
1.36
207 #ifdef PCC_DEBUG
ragge
1.22
208                 q = freelink;
209                 while (q != NULL) {
210                         if (q == p)
211                                 cerror("freeing free node %p"p);
212                         q = q->next;
213                 }
ragge
1.36
214 #endif
ragge
1.22
215
ragge
1.23
216                 if (nflag)
217                         printf("freeing node %p\n"p);
ragge
1.12
218                 p->n_op = FREE;
ragge
1.24
219                 p->next = freelink;
220                 freelink = p;
221                 usednodes--;
222                 if (recovernodes)
223                         inlnodecnt--;
ragge
1.22
224         } else
225                 cerror("freeing blank node!");
ragge
1.2
226 }
ragge
1.1
227
ragge
1.34
228 int cdope(int);
229 #define coptype(o)      (cdope(o)&TYFLG)
230
ragge
1.2
231 void
232 fwalk(NODE *tint (*f)(NODE *, intint *, int *), int down)
233 {
ragge
1.1
234
235         int down1down2;
236
237         more:
238         down1 = down2 = 0;
239
ragge
1.2
240         (*f)(tdown, &down1, &down2);
ragge
1.1
241
ragge
1.34
242         switch (coptypet->n_op )) {
ragge
1.1
243
244         case BITYPE:
ragge
1.12
245                 fwalkt->n_leftfdown1 );
246                 t = t->n_right;
ragge
1.1
247                 down = down2;
248                 goto more;
249
250         case UTYPE:
ragge
1.12
251                 t = t->n_left;
ragge
1.1
252                 down = down1;
253                 goto more;
254
255         }
ragge
1.2
256 }
ragge
1.1
257
ragge
1.2
258 void
259 walkf(NODE *tvoid (*f)(NODE *))
260 {
261         int opty;
ragge
1.1
262
ragge
1.34
263         opty = coptype(t->n_op);
ragge
1.1
264
ragge
1.2
265         if (opty != LTYPE)
ragge
1.12
266                 walkft->n_leftf );
ragge
1.2
267         if (opty == BITYPE)
ragge
1.12
268                 walkft->n_rightf );
ragge
1.2
269         (*f)(t);
270 }
ragge
1.1
271
ragge
1.11
272 int dope[DSIZE];
ragge
1.1
273 char *opst[DSIZE];
274
ragge
1.2
275 struct dopest {
276         int dopeop;
277         char opst[8];
278         int dopeval;
279 indope[] = {
280         { NAME"NAME"LTYPE, },
281         { STRING"STRING"LTYPE, },
282         { REG"REG"LTYPE, },
283         { OREG"OREG"LTYPE, },
ragge
1.31
284         { TEMP"TEMP"LTYPE, },
ragge
1.2
285         { ICON"ICON"LTYPE, },
286         { FCON"FCON"LTYPE, },
287         { CCODES"CCODES"LTYPE, },
288         { UNARY MINUS"U-"UTYPE, },
289         { UNARY MUL"U*"UTYPE, },
290         { UNARY AND"U&"UTYPE, },
291         { UNARY CALL"UCALL"UTYPE|CALLFLG, },
292         { UNARY FORTCALL"UFCALL"UTYPE|CALLFLG, },
293         { COMPL"~"UTYPE, },
294         { FORCE"FORCE"UTYPE, },
295         { INIT"INIT"UTYPE, },
296         { SCONV"SCONV"UTYPE, },
297         { PCONV"PCONV"UTYPE, },
298         { PLUS"+"BITYPE|FLOFLG|SIMPFLG|COMMFLG, },
299         { ASG PLUS"+="BITYPE|ASGFLG|ASGOPFLG|FLOFLG|SIMPFLG|COMMFLG, },
300         { MINUS"-"BITYPE|FLOFLG|SIMPFLG, },
301         { ASG MINUS"-="BITYPE|FLOFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
302         { MUL"*"BITYPE|FLOFLG|MULFLG, },
303         { ASG MUL"*="BITYPE|FLOFLG|MULFLG|ASGFLG|ASGOPFLG, },
304         { AND"&"BITYPE|SIMPFLG|COMMFLG, },
305         { ASG AND"&="BITYPE|SIMPFLG|COMMFLG|ASGFLG|ASGOPFLG, },
306         { CM","BITYPE, },
307         { ASSIGN"="BITYPE|ASGFLG, },
308         { DIV"/"BITYPE|FLOFLG|MULFLG|DIVFLG, },
309         { ASG DIV"/="BITYPE|FLOFLG|MULFLG|DIVFLG|ASGFLG|ASGOPFLG, },
310         { MOD"%"BITYPE|DIVFLG, },
311         { ASG MOD"%="BITYPE|DIVFLG|ASGFLG|ASGOPFLG, },
312         { LS"<<"BITYPE|SHFFLG, },
313         { ASG LS"<<="BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
314         { RS">>"BITYPE|SHFFLG, },
315         { ASG RS">>="BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
316         { OR"|"BITYPE|COMMFLG|SIMPFLG, },
317         { ASG OR"|="BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
318         { ER"^"BITYPE|COMMFLG|SIMPFLG, },
319         { ASG ER"^="BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
320         { INCR"++"BITYPE|ASGFLG, },
321         { DECR"--"BITYPE|ASGFLG, },
322         { STREF"->"BITYPE, },
323         { CALL"CALL"BITYPE|CALLFLG, },
324         { FORTCALL"FCALL"BITYPE|CALLFLG, },
325         { EQ"=="BITYPE|LOGFLG, },
326         { NE"!="BITYPE|LOGFLG, },
327         { LE"<="BITYPE|LOGFLG, },
328         { LT"<"BITYPE|LOGFLG, },
329         { GE">"BITYPE|LOGFLG, },
330         { GT">"BITYPE|LOGFLG, },
331         { UGT"UGT"BITYPE|LOGFLG, },
332         { UGE"UGE"BITYPE|LOGFLG, },
333         { ULT"ULT"BITYPE|LOGFLG, },
334         { ULE"ULE"BITYPE|LOGFLG, },
335         { CBRANCH"CBRANCH"BITYPE, },
336         { FLD"FLD"UTYPE, },
337         { PMCONV"PMCONV"BITYPE, },
338         { PVCONV"PVCONV"BITYPE, },
339         { RETURN"RETURN"BITYPE|ASGFLG|ASGOPFLG, },
340         { CAST"CAST"BITYPE|ASGFLG|ASGOPFLG, },
341         { GOTO"GOTO"UTYPE, },
342         { STASG"STASG"BITYPE|ASGFLG, },
343         { STARG"STARG"UTYPE, },
344         { STCALL"STCALL"BITYPE|CALLFLG, },
345         { UNARY STCALL"USTCALL"UTYPE|CALLFLG, },
ragge
1.1
346
ragge
1.2
347         { -1,   "",     0 },
ragge
1.1
348 };
349
ragge
1.2
350 void
351 mkdope()
352 {
353         struct dopest *q;
ragge
1.1
354
355         forq = indopeq->dopeop >= 0; ++q ){
356                 dope[q->dopeop] = q->dopeval;
357                 opst[q->dopeop] = q->opst;
358         }
ragge
1.2
359 }
360
361 /*
362  * output a nice description of the type of t
363  */
364 void
ragge
1.35
365 tprint(TWORD tTWORD q)
ragge
1.2
366 {
ragge
1.1
367         static char * tnames[] = {
368                 "undef",
369                 "farg",
370                 "char",
ragge
1.29
371                 "uchar",
ragge
1.1
372                 "short",
ragge
1.29
373                 "ushort",
ragge
1.1
374                 "int",
ragge
1.29
375                 "unsigned",
ragge
1.1
376                 "long",
ragge
1.29
377                 "ulong",
ragge
1.9
378                 "longlong",
ragge
1.29
379                 "ulonglong",
ragge
1.1
380                 "float",
381                 "double",
ragge
1.29
382                 "ldouble",
ragge
1.1
383                 "strty",
384                 "unionty",
385                 "enumty",
386                 "moety",
ragge
1.29
387                 "void",
ragge
1.1
388                 "?""?"
389                 };
390
ragge
1.35
391         for(;; t = DECREF(t), q = DECREF(q)) {
392                 if (ISCON(q))
393                         putchar('C');
394                 if (ISVOL(q))
395                         putchar('V');
ragge
1.1
396
ragge
1.2
397                 if (ISPTR(t))
398                         printf("PTR ");
399                 else if (ISFTN(t))
400                         printf("FTN ");
401                 else if (ISARY(t))
402                         printf("ARY ");
ragge
1.1
403                 else {
ragge
1.35
404                         printf("%s%s%s"ISCON(q << TSHIFT) ? "const " : "",
405                             ISVOL(q << TSHIFT) ? "volatile " : ""tnames[t]);
ragge
1.1
406                         return;
407                 }
408         }
ragge
1.2
409 }
ragge
1.13
410
411 /*
ragge
1.14
412  * Return a number for internal labels.
413  */
414 int 
415 getlab()
416 {
417         static int crslab = 10;
418         return crslab++;
419 }
420
421 /*
ragge
1.13
422  * Memory allocation routines.
423  * Memory are allocated from the system in MEMCHUNKSZ blocks.
424  * permalloc() returns a bunch of memory that is never freed.
425  * Memory allocated through tmpalloc() will be released the
426  * next time a function is ended (via tmpfree()).
427  */
428
429 #define MEMCHUNKSZ 8192 /* 8k per allocation */
ragge
1.16
430 #define ROUNDUP(x) ((x) + (sizeof(int)-1)) & ~(sizeof(int)-1)
ragge
1.13
431
432 static char *allocpole;
433 static int allocleft;
ragge
1.17
434 static char *tmppole;
435 static int tmpleft;
ragge
1.18
436 int permallocsizetmpallocsizelostmem;
ragge
1.13
437
438 void *
439 permalloc(int size)
440 {
441         void *rv;
442
443 //printf("permalloc: allocpole %p allocleft %d size %d ", allocpole, allocleft, size);
444         if (size > MEMCHUNKSZ)
445                 cerror("permalloc");
ragge
1.20
446         if (size <= 0)
447                 cerror("permalloc2");
ragge
1.18
448         if (allocleft < size) {
ragge
1.13
449                 /* looses unused bytes */
ragge
1.18
450                 lostmem += allocleft;
ragge
1.17
451 //fprintf(stderr, "allocating perm\n");
ragge
1.13
452                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
453                         cerror("permalloc: out of memory");
454                 allocleft = MEMCHUNKSZ;
455         }
ragge
1.16
456         size = ROUNDUP(size);
ragge
1.13
457         rv = &allocpole[MEMCHUNKSZ-allocleft];
458 //printf("rv %p\n", rv);
459         allocleft -= size;
ragge
1.17
460         permallocsize += size;
ragge
1.13
461         return rv;
462 }
463
ragge
1.17
464 static char *tmplink;
465
ragge
1.13
466 void *
467 tmpalloc(int size)
468 {
ragge
1.17
469         void *rv;
470
471         if (size > MEMCHUNKSZ)
472                 cerror("tmpalloc");
ragge
1.20
473         if (size <= 0)
474                 cerror("tmpalloc2");
ragge
1.17
475 //printf("tmpalloc: tmppole %p tmpleft %d size %d ", tmppole, tmpleft, size);
476         if (tmpleft < size) {
477                 if ((tmppole = malloc(MEMCHUNKSZ)) == NULL)
478                         cerror("tmpalloc: out of memory");
479 //fprintf(stderr, "allocating tmp\n");
480                 tmpleft = MEMCHUNKSZ - sizeof(char *);
481                 *(char **)tmppole = tmplink;
482                 tmplink = tmppole;
483         }
484         size = ROUNDUP(size);
485         rv = &tmppole[MEMCHUNKSZ-tmpleft];
486 //printf("rv %p\n", rv);
487         tmpleft -= size;
488         tmpallocsize += size;
489         return rv;
ragge
1.13
490 }
491
492 void
493 tmpfree()
494 {
ragge
1.18
495         char *f, *of;
496
497         f = tmplink;
ragge
1.19
498         if (f == NULL)
499                 return;
500         if (*(char **)f == NULL) {
501                 tmpleft = MEMCHUNKSZ - sizeof(char *);
502                 return;
503         }
ragge
1.18
504         while (f != NULL) {
505                 of = f;
506                 f = *(char **)f;
507                 free(of);
508         }
509         tmplink = tmppole = NULL;
510         tmpleft = 0;
ragge
1.17
511 //fprintf(stderr, "freeing tmp\n");
ragge
1.13
512         /* XXX - nothing right now */
ragge
1.16
513 }
514
515 /*
516  * Allocate space on the permanent stack for a string of length len+1
517  * and copy it there.
518  * Return the new address.
519  */
520 char *
521 newstring(char *sint len)
522 {
523         char *u, *c;
524
525         len++;
526         if (allocleft < len) {
527                 u = c = permalloc(len);
528         } else {
529                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
530                 allocleft -= ROUNDUP(len+1);
531         }
532         while (len--)
533                 *c++ = *s++;
534         return u;
ragge
1.13
535 }
FishEye: Open Source License registered to PCC.
Your maintenance has expired. You can renew your license at http://www.atlassian.com/fisheye/renew
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-10-01 22:25 +0200