Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030729092515

Diff

Diff from 1.32 to:

Annotations

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

Annotated File View

ragge
1.32
1 /*      $Id: common.c,v 1.32 2003/07/29 09:25:15 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.1
67 #include "pass1.h"
ragge
1.32
68 #include "pass2.h"
ragge
1.1
69
70 # ifndef EXIT
71 # define EXIT exit
72 # endif
73
74 int nerrors = 0;  /* number of errors */
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.31
200         NODE *q;
ragge
1.22
201
202         if (p != NULL) {
203                 if (p->n_op == FREE)
204                         cerror("freeing FREE node"p);
205                 q = freelink;
206                 while (q != NULL) {
207                         if (q == p)
208                                 cerror("freeing free node %p"p);
209                         q = q->next;
210                 }
211
ragge
1.23
212                 if (nflag)
213                         printf("freeing node %p\n"p);
ragge
1.12
214                 p->n_op = FREE;
ragge
1.24
215                 p->next = freelink;
216                 freelink = p;
217                 usednodes--;
218                 if (recovernodes)
219                         inlnodecnt--;
ragge
1.22
220         } else
221                 cerror("freeing blank node!");
ragge
1.2
222 }
ragge
1.1
223
ragge
1.2
224 void
225 fwalk(NODE *tint (*f)(NODE *, intint *, int *), int down)
226 {
ragge
1.1
227
228         int down1down2;
229
230         more:
231         down1 = down2 = 0;
232
ragge
1.2
233         (*f)(tdown, &down1, &down2);
ragge
1.1
234
ragge
1.12
235         switch (optypet->n_op )) {
ragge
1.1
236
237         case BITYPE:
ragge
1.12
238                 fwalkt->n_leftfdown1 );
239                 t = t->n_right;
ragge
1.1
240                 down = down2;
241                 goto more;
242
243         case UTYPE:
ragge
1.12
244                 t = t->n_left;
ragge
1.1
245                 down = down1;
246                 goto more;
247
248         }
ragge
1.2
249 }
ragge
1.1
250
ragge
1.2
251 void
252 walkf(NODE *tvoid (*f)(NODE *))
253 {
254         int opty;
ragge
1.1
255
ragge
1.12
256         opty = optype(t->n_op);
ragge
1.1
257
ragge
1.2
258         if (opty != LTYPE)
ragge
1.12
259                 walkft->n_leftf );
ragge
1.2
260         if (opty == BITYPE)
ragge
1.12
261                 walkft->n_rightf );
ragge
1.2
262         (*f)(t);
263 }
ragge
1.1
264
ragge
1.11
265 int dope[DSIZE];
ragge
1.1
266 char *opst[DSIZE];
267
ragge
1.2
268 struct dopest {
269         int dopeop;
270         char opst[8];
271         int dopeval;
272 indope[] = {
273         { NAME"NAME"LTYPE, },
274         { STRING"STRING"LTYPE, },
275         { REG"REG"LTYPE, },
276         { OREG"OREG"LTYPE, },
ragge
1.31
277         { TEMP"TEMP"LTYPE, },
ragge
1.2
278         { ICON"ICON"LTYPE, },
279         { FCON"FCON"LTYPE, },
280         { CCODES"CCODES"LTYPE, },
281         { UNARY MINUS"U-"UTYPE, },
282         { UNARY MUL"U*"UTYPE, },
283         { UNARY AND"U&"UTYPE, },
284         { UNARY CALL"UCALL"UTYPE|CALLFLG, },
285         { UNARY FORTCALL"UFCALL"UTYPE|CALLFLG, },
286         { COMPL"~"UTYPE, },
287         { FORCE"FORCE"UTYPE, },
288         { INIT"INIT"UTYPE, },
289         { SCONV"SCONV"UTYPE, },
290         { PCONV"PCONV"UTYPE, },
291         { PLUS"+"BITYPE|FLOFLG|SIMPFLG|COMMFLG, },
292         { ASG PLUS"+="BITYPE|ASGFLG|ASGOPFLG|FLOFLG|SIMPFLG|COMMFLG, },
293         { MINUS"-"BITYPE|FLOFLG|SIMPFLG, },
294         { ASG MINUS"-="BITYPE|FLOFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
295         { MUL"*"BITYPE|FLOFLG|MULFLG, },
296         { ASG MUL"*="BITYPE|FLOFLG|MULFLG|ASGFLG|ASGOPFLG, },
297         { AND"&"BITYPE|SIMPFLG|COMMFLG, },
298         { ASG AND"&="BITYPE|SIMPFLG|COMMFLG|ASGFLG|ASGOPFLG, },
299         { CM","BITYPE, },
300         { ASSIGN"="BITYPE|ASGFLG, },
301         { DIV"/"BITYPE|FLOFLG|MULFLG|DIVFLG, },
302         { ASG DIV"/="BITYPE|FLOFLG|MULFLG|DIVFLG|ASGFLG|ASGOPFLG, },
303         { MOD"%"BITYPE|DIVFLG, },
304         { ASG MOD"%="BITYPE|DIVFLG|ASGFLG|ASGOPFLG, },
305         { LS"<<"BITYPE|SHFFLG, },
306         { ASG LS"<<="BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
307         { RS">>"BITYPE|SHFFLG, },
308         { ASG RS">>="BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
309         { OR"|"BITYPE|COMMFLG|SIMPFLG, },
310         { ASG OR"|="BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
311         { ER"^"BITYPE|COMMFLG|SIMPFLG, },
312         { ASG ER"^="BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
313         { INCR"++"BITYPE|ASGFLG, },
314         { DECR"--"BITYPE|ASGFLG, },
315         { STREF"->"BITYPE, },
316         { CALL"CALL"BITYPE|CALLFLG, },
317         { FORTCALL"FCALL"BITYPE|CALLFLG, },
318         { EQ"=="BITYPE|LOGFLG, },
319         { NE"!="BITYPE|LOGFLG, },
320         { LE"<="BITYPE|LOGFLG, },
321         { LT"<"BITYPE|LOGFLG, },
322         { GE">"BITYPE|LOGFLG, },
323         { GT">"BITYPE|LOGFLG, },
324         { UGT"UGT"BITYPE|LOGFLG, },
325         { UGE"UGE"BITYPE|LOGFLG, },
326         { ULT"ULT"BITYPE|LOGFLG, },
327         { ULE"ULE"BITYPE|LOGFLG, },
328         { CBRANCH"CBRANCH"BITYPE, },
329         { FLD"FLD"UTYPE, },
330         { PMCONV"PMCONV"BITYPE, },
331         { PVCONV"PVCONV"BITYPE, },
332         { RETURN"RETURN"BITYPE|ASGFLG|ASGOPFLG, },
333         { CAST"CAST"BITYPE|ASGFLG|ASGOPFLG, },
334         { GOTO"GOTO"UTYPE, },
335         { STASG"STASG"BITYPE|ASGFLG, },
336         { STARG"STARG"UTYPE, },
337         { STCALL"STCALL"BITYPE|CALLFLG, },
338         { UNARY STCALL"USTCALL"UTYPE|CALLFLG, },
ragge
1.1
339
ragge
1.2
340         { -1,   "",     0 },
ragge
1.1
341 };
342
ragge
1.2
343 void
344 mkdope()
345 {
346         struct dopest *q;
ragge
1.1
347
348         forq = indopeq->dopeop >= 0; ++q ){
349                 dope[q->dopeop] = q->dopeval;
350                 opst[q->dopeop] = q->opst;
351         }
ragge
1.2
352 }
353
354 /*
355  * output a nice description of the type of t
356  */
357 void
358 tprint(TWORD t)
359 {
ragge
1.1
360         static char * tnames[] = {
361                 "undef",
362                 "farg",
363                 "char",
ragge
1.29
364                 "uchar",
ragge
1.1
365                 "short",
ragge
1.29
366                 "ushort",
ragge
1.1
367                 "int",
ragge
1.29
368                 "unsigned",
ragge
1.1
369                 "long",
ragge
1.29
370                 "ulong",
ragge
1.9
371                 "longlong",
ragge
1.29
372                 "ulonglong",
ragge
1.1
373                 "float",
374                 "double",
ragge
1.29
375                 "ldouble",
ragge
1.1
376                 "strty",
377                 "unionty",
378                 "enumty",
379                 "moety",
ragge
1.29
380                 "void",
ragge
1.1
381                 "?""?"
382                 };
383
384         for(;; t = DECREF(t) ){
385
ragge
1.2
386                 if (ISPTR(t))
387                         printf("PTR ");
388                 else if (ISFTN(t))
389                         printf("FTN ");
390                 else if (ISARY(t))
391                         printf("ARY ");
ragge
1.1
392                 else {
ragge
1.2
393                         printf("%s"tnames[t]);
ragge
1.1
394                         return;
395                 }
396         }
ragge
1.2
397 }
ragge
1.13
398
399 /*
ragge
1.14
400  * Return a number for internal labels.
401  */
402 int 
403 getlab()
404 {
405         static int crslab = 10;
406         return crslab++;
407 }
408
409 /*
ragge
1.13
410  * Memory allocation routines.
411  * Memory are allocated from the system in MEMCHUNKSZ blocks.
412  * permalloc() returns a bunch of memory that is never freed.
413  * Memory allocated through tmpalloc() will be released the
414  * next time a function is ended (via tmpfree()).
415  */
416
417 #define MEMCHUNKSZ 8192 /* 8k per allocation */
ragge
1.16
418 #define ROUNDUP(x) ((x) + (sizeof(int)-1)) & ~(sizeof(int)-1)
ragge
1.13
419
420 static char *allocpole;
421 static int allocleft;
ragge
1.17
422 static char *tmppole;
423 static int tmpleft;
ragge
1.18
424 int permallocsizetmpallocsizelostmem;
ragge
1.13
425
426 void *
427 permalloc(int size)
428 {
429         void *rv;
430
431 //printf("permalloc: allocpole %p allocleft %d size %d ", allocpole, allocleft, size);
432         if (size > MEMCHUNKSZ)
433                 cerror("permalloc");
ragge
1.20
434         if (size <= 0)
435                 cerror("permalloc2");
ragge
1.18
436         if (allocleft < size) {
ragge
1.13
437                 /* looses unused bytes */
ragge
1.18
438                 lostmem += allocleft;
ragge
1.17
439 //fprintf(stderr, "allocating perm\n");
ragge
1.13
440                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
441                         cerror("permalloc: out of memory");
442                 allocleft = MEMCHUNKSZ;
443         }
ragge
1.16
444         size = ROUNDUP(size);
ragge
1.13
445         rv = &allocpole[MEMCHUNKSZ-allocleft];
446 //printf("rv %p\n", rv);
447         allocleft -= size;
ragge
1.17
448         permallocsize += size;
ragge
1.13
449         return rv;
450 }
451
ragge
1.17
452 static char *tmplink;
453
ragge
1.13
454 void *
455 tmpalloc(int size)
456 {
ragge
1.17
457         void *rv;
458
459         if (size > MEMCHUNKSZ)
460                 cerror("tmpalloc");
ragge
1.20
461         if (size <= 0)
462                 cerror("tmpalloc2");
ragge
1.17
463 //printf("tmpalloc: tmppole %p tmpleft %d size %d ", tmppole, tmpleft, size);
464         if (tmpleft < size) {
465                 if ((tmppole = malloc(MEMCHUNKSZ)) == NULL)
466                         cerror("tmpalloc: out of memory");
467 //fprintf(stderr, "allocating tmp\n");
468                 tmpleft = MEMCHUNKSZ - sizeof(char *);
469                 *(char **)tmppole = tmplink;
470                 tmplink = tmppole;
471         }
472         size = ROUNDUP(size);
473         rv = &tmppole[MEMCHUNKSZ-tmpleft];
474 //printf("rv %p\n", rv);
475         tmpleft -= size;
476         tmpallocsize += size;
477         return rv;
ragge
1.13
478 }
479
480 void
481 tmpfree()
482 {
ragge
1.18
483         char *f, *of;
484
485         f = tmplink;
ragge
1.19
486         if (f == NULL)
487                 return;
488         if (*(char **)f == NULL) {
489                 tmpleft = MEMCHUNKSZ - sizeof(char *);
490                 return;
491         }
ragge
1.18
492         while (f != NULL) {
493                 of = f;
494                 f = *(char **)f;
495                 free(of);
496         }
497         tmplink = tmppole = NULL;
498         tmpleft = 0;
ragge
1.17
499 //fprintf(stderr, "freeing tmp\n");
ragge
1.13
500         /* XXX - nothing right now */
ragge
1.16
501 }
502
503 /*
504  * Allocate space on the permanent stack for a string of length len+1
505  * and copy it there.
506  * Return the new address.
507  */
508 char *
509 newstring(char *sint len)
510 {
511         char *u, *c;
512
513         len++;
514         if (allocleft < len) {
515                 u = c = permalloc(len);
516         } else {
517                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
518                 allocleft -= ROUNDUP(len+1);
519         }
520         while (len--)
521                 *c++ = *s++;
522         return u;
ragge
1.13
523 }
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 18:24 +0200