Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030912151401

Diff

Diff from 1.42 to:

Annotations

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

Annotated File View

ragge
1.42
1 /*      $Id: common.c,v 1.42 2003/09/12 15:14:01 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.37
74 char *ftitle;
75 int lineno;
ragge
1.1
76
ragge
1.10
77 #ifndef WHERE
78 #define WHERE(ch) fprintf(stderr, "%s, line %d: ", ftitle, lineno);
79 #endif
ragge
1.1
80
ragge
1.2
81 /*
82  * nonfatal error message
83  * the routine where is different for pass 1 and pass 2;
84  * it tells where the error took place
85  */
86 void
87 uerror(char *s, ...)
88 {
89         va_list ap;
ragge
1.1
90
ragge
1.2
91         va_start(aps);
ragge
1.1
92         ++nerrors;
ragge
1.10
93         WHERE('u');
ragge
1.2
94         vfprintf(stderrsap);
95         fprintf(stderr"\n");
96         if (nerrors > 30)
97                 cerror("too many errors");
98         va_end(ap);
99 }
100
101 /*
102  * compiler error: die
103  */
104 void
105 cerror(char *s, ...)
106 {
107         va_list ap;
ragge
1.1
108
ragge
1.2
109         va_start(aps);
ragge
1.10
110         WHERE('c');
ragge
1.2
111
112         /* give the compiler the benefit of the doubt */
113         if (nerrors && nerrors <= 30) {
114                 fprintf(stderr,
115                     "cannot recover from earlier errors: goodbye!\n");
116         } else {
117                 fprintf(stderr"compiler error: ");
118                 vfprintf(stderrsap);
119                 fprintf(stderr"\n");
120         }
121         va_end(ap);
ragge
1.1
122         EXIT(1);
ragge
1.2
123 }
ragge
1.1
124
ragge
1.2
125 /*
126  * warning
127  */
128 void
129 werror(char *s, ...)
130 {
131         va_list ap;
132
133         va_start(aps);
ragge
1.10
134         WHERE('w');
ragge
1.2
135         fprintf(stderr"warning: ");
136         vfprintf(stderrsap);
137         fprintf(stderr"\n");
138 }
ragge
1.1
139
ragge
1.37
140 #ifndef MKEXT
ragge
1.22
141 static NODE *freelink;
ragge
1.24
142 static int usednodes;
ragge
1.22
143
ragge
1.1
144 NODE *
ragge
1.2
145 talloc()
146 {
ragge
1.24
147         extern int inlnodecntrecovernodes;
148         register NODE *p;
149
150         if ((usednodes++ - inlnodecnt) > TREESZ)
ragge
1.25
151                 cerror("out of tree space; usednodes %d inlnodecnt %d",
152                     usednodesinlnodecnt);
ragge
1.1
153
ragge
1.24
154         if (recovernodes)
155                 inlnodecnt++;
ragge
1.22
156         if (freelink != NULL) {
157                 p = freelink;
158                 freelink = p->next;
159                 if (p->n_op != FREE)
ragge
1.23
160                         cerror("node not FREE: %p"p);
161                 if (nflag)
162                         printf("alloc node %p from freelist\n"p);
ragge
1.22
163                 return p;
164         }
165
ragge
1.24
166         p = permalloc(sizeof(NODE));
167         p->n_op = FREE;
168         if (nflag)
169                 printf("alloc node %p from memory\n"p);
170         return p;
ragge
1.2
171 }
ragge
1.1
172
ragge
1.2
173 /*
174  * ensure that all nodes have been freed
175  */
176 void
177 tcheck()
178 {
ragge
1.24
179         extern int inlnodecnt;
ragge
1.1
180
ragge
1.24
181         if (nerrors)
182                 return;
183
184         if ((usednodes - inlnodecnt) != 0)
185                 cerror("usednodes == %d, inlnodecnt %d"usednodesinlnodecnt);
ragge
1.2
186 }
ragge
1.1
187
ragge
1.2
188 /*
189  * free the tree p
190  */
191 void
192 tfree(NODE *p)
193 {
ragge
1.12
194         if (p->n_op != FREE)
ragge
1.22
195                 walkf(pnfree);
ragge
1.2
196 }
ragge
1.1
197
ragge
1.2
198 void
ragge
1.22
199 nfree(NODE *p)
ragge
1.2
200 {
ragge
1.24
201         extern int inlnodecntrecovernodes;
ragge
1.38
202 #ifdef PCC_DEBUG_NODES
ragge
1.31
203         NODE *q;
ragge
1.36
204 #endif
ragge
1.22
205
206         if (p != NULL) {
207                 if (p->n_op == FREE)
208                         cerror("freeing FREE node"p);
ragge
1.38
209 #ifdef PCC_DEBUG_NODES
ragge
1.22
210                 q = freelink;
211                 while (q != NULL) {
212                         if (q == p)
213                                 cerror("freeing free node %p"p);
214                         q = q->next;
215                 }
ragge
1.36
216 #endif
ragge
1.22
217
ragge
1.23
218                 if (nflag)
219                         printf("freeing node %p\n"p);
ragge
1.12
220                 p->n_op = FREE;
ragge
1.24
221                 p->next = freelink;
222                 freelink = p;
223                 usednodes--;
224                 if (recovernodes)
225                         inlnodecnt--;
ragge
1.22
226         } else
227                 cerror("freeing blank node!");
ragge
1.2
228 }
ragge
1.37
229 #endif
230
231 #ifdef MKEXT
232 #define coptype(o)      (dope[o]&TYFLG)
233 #else
ragge
1.34
234 int cdope(int);
ragge
1.37
235 #define coptype(o)      (cdope(o)&TYFLG)
236 #endif
ragge
1.34
237
ragge
1.2
238 void
239 fwalk(NODE *tint (*f)(NODE *, intint *, int *), int down)
240 {
ragge
1.1
241
242         int down1down2;
243
244         more:
245         down1 = down2 = 0;
246
ragge
1.2
247         (*f)(tdown, &down1, &down2);
ragge
1.1
248
ragge
1.34
249         switch (coptypet->n_op )) {
ragge
1.1
250
251         case BITYPE:
ragge
1.12
252                 fwalkt->n_leftfdown1 );
253                 t = t->n_right;
ragge
1.1
254                 down = down2;
255                 goto more;
256
257         case UTYPE:
ragge
1.12
258                 t = t->n_left;
ragge
1.1
259                 down = down1;
260                 goto more;
261
262         }
ragge
1.2
263 }
ragge
1.1
264
ragge
1.2
265 void
266 walkf(NODE *tvoid (*f)(NODE *))
267 {
268         int opty;
ragge
1.1
269
ragge
1.34
270         opty = coptype(t->n_op);
ragge
1.1
271
ragge
1.2
272         if (opty != LTYPE)
ragge
1.12
273                 walkft->n_leftf );
ragge
1.2
274         if (opty == BITYPE)
ragge
1.12
275                 walkft->n_rightf );
ragge
1.2
276         (*f)(t);
277 }
ragge
1.1
278
ragge
1.11
279 int dope[DSIZE];
ragge
1.1
280 char *opst[DSIZE];
281
ragge
1.2
282 struct dopest {
283         int dopeop;
284         char opst[8];
285         int dopeval;
286 indope[] = {
287         { NAME"NAME"LTYPE, },
ragge
1.40
288 /*      { STRING, "STRING", LTYPE, }, */
ragge
1.2
289         { REG"REG"LTYPE, },
290         { OREG"OREG"LTYPE, },
ragge
1.31
291         { TEMP"TEMP"LTYPE, },
ragge
1.2
292         { ICON"ICON"LTYPE, },
293         { FCON"FCON"LTYPE, },
294         { CCODES"CCODES"LTYPE, },
ragge
1.41
295         { UMINUS"U-"UTYPE, },
296         { UMUL"U*"UTYPE, },
297 /*      { UNARY AND, "U&", UTYPE, }, */
ragge
1.42
298         { UCALL"UCALL"UTYPE|CALLFLG, },
299         { UFORTCALL"UFCALL"UTYPE|CALLFLG, },
ragge
1.2
300         { COMPL"~"UTYPE, },
301         { FORCE"FORCE"UTYPE, },
302         { INIT"INIT"UTYPE, },
303         { SCONV"SCONV"UTYPE, },
304         { PCONV"PCONV"UTYPE, },
305         { PLUS"+"BITYPE|FLOFLG|SIMPFLG|COMMFLG, },
ragge
1.42
306 //      { ASG PLUS, "+=", BITYPE|ASGFLG|ASGOPFLG|FLOFLG|SIMPFLG|COMMFLG, },
ragge
1.2
307         { MINUS"-"BITYPE|FLOFLG|SIMPFLG, },
ragge
1.42
308 //      { ASG MINUS, "-=", BITYPE|FLOFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
ragge
1.2
309         { MUL"*"BITYPE|FLOFLG|MULFLG, },
ragge
1.42
310 //      { ASG MUL, "*=", BITYPE|FLOFLG|MULFLG|ASGFLG|ASGOPFLG, },
ragge
1.2
311         { AND"&"BITYPE|SIMPFLG|COMMFLG, },
ragge
1.42
312 //      { ASG AND, "&=", BITYPE|SIMPFLG|COMMFLG|ASGFLG|ASGOPFLG, },
ragge
1.2
313         { CM","BITYPE, },
314         { ASSIGN"="BITYPE|ASGFLG, },
315         { DIV"/"BITYPE|FLOFLG|MULFLG|DIVFLG, },
ragge
1.42
316 //      { ASG DIV, "/=", BITYPE|FLOFLG|MULFLG|DIVFLG|ASGFLG|ASGOPFLG, },
ragge
1.2
317         { MOD"%"BITYPE|DIVFLG, },
ragge
1.42
318 //      { ASG MOD, "%=", BITYPE|DIVFLG|ASGFLG|ASGOPFLG, },
ragge
1.2
319         { LS"<<"BITYPE|SHFFLG, },
ragge
1.42
320 //      { ASG LS, "<<=", BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
ragge
1.2
321         { RS">>"BITYPE|SHFFLG, },
ragge
1.42
322 //      { ASG RS, ">>=", BITYPE|SHFFLG|ASGFLG|ASGOPFLG, },
ragge
1.2
323         { OR"|"BITYPE|COMMFLG|SIMPFLG, },
ragge
1.42
324 //      { ASG OR, "|=", BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
ragge
1.2
325         { ER"^"BITYPE|COMMFLG|SIMPFLG, },
ragge
1.42
326 //      { ASG ER, "^=", BITYPE|COMMFLG|SIMPFLG|ASGFLG|ASGOPFLG, },
ragge
1.2
327         { INCR"++"BITYPE|ASGFLG, },
328         { DECR"--"BITYPE|ASGFLG, },
329         { STREF"->"BITYPE, },
330         { CALL"CALL"BITYPE|CALLFLG, },
331         { FORTCALL"FCALL"BITYPE|CALLFLG, },
332         { EQ"=="BITYPE|LOGFLG, },
333         { NE"!="BITYPE|LOGFLG, },
334         { LE"<="BITYPE|LOGFLG, },
335         { LT"<"BITYPE|LOGFLG, },
336         { GE">"BITYPE|LOGFLG, },
337         { GT">"BITYPE|LOGFLG, },
338         { UGT"UGT"BITYPE|LOGFLG, },
339         { UGE"UGE"BITYPE|LOGFLG, },
340         { ULT"ULT"BITYPE|LOGFLG, },
341         { ULE"ULE"BITYPE|LOGFLG, },
342         { CBRANCH"CBRANCH"BITYPE, },
343         { FLD"FLD"UTYPE, },
344         { PMCONV"PMCONV"BITYPE, },
345         { PVCONV"PVCONV"BITYPE, },
346         { RETURN"RETURN"BITYPE|ASGFLG|ASGOPFLG, },
ragge
1.40
347 /*      { CAST, "CAST", BITYPE|ASGFLG|ASGOPFLG, }, */
ragge
1.2
348         { GOTO"GOTO"UTYPE, },
349         { STASG"STASG"BITYPE|ASGFLG, },
350         { STARG"STARG"UTYPE, },
351         { STCALL"STCALL"BITYPE|CALLFLG, },
ragge
1.42
352         { USTCALL"USTCALL"UTYPE|CALLFLG, },
ragge
1.1
353
ragge
1.2
354         { -1,   "",     0 },
ragge
1.1
355 };
356
ragge
1.2
357 void
358 mkdope()
359 {
360         struct dopest *q;
ragge
1.1
361
362         forq = indopeq->dopeop >= 0; ++q ){
363                 dope[q->dopeop] = q->dopeval;
364                 opst[q->dopeop] = q->opst;
365         }
ragge
1.2
366 }
367
368 /*
369  * output a nice description of the type of t
370  */
371 void
ragge
1.35
372 tprint(TWORD tTWORD q)
ragge
1.2
373 {
ragge
1.1
374         static char * tnames[] = {
375                 "undef",
376                 "farg",
377                 "char",
ragge
1.29
378                 "uchar",
ragge
1.1
379                 "short",
ragge
1.29
380                 "ushort",
ragge
1.1
381                 "int",
ragge
1.29
382                 "unsigned",
ragge
1.1
383                 "long",
ragge
1.29
384                 "ulong",
ragge
1.9
385                 "longlong",
ragge
1.29
386                 "ulonglong",
ragge
1.1
387                 "float",
388                 "double",
ragge
1.29
389                 "ldouble",
ragge
1.1
390                 "strty",
391                 "unionty",
392                 "enumty",
393                 "moety",
ragge
1.29
394                 "void",
ragge
1.1
395                 "?""?"
396                 };
397
ragge
1.35
398         for(;; t = DECREF(t), q = DECREF(q)) {
399                 if (ISCON(q))
400                         putchar('C');
401                 if (ISVOL(q))
402                         putchar('V');
ragge
1.1
403
ragge
1.2
404                 if (ISPTR(t))
405                         printf("PTR ");
406                 else if (ISFTN(t))
407                         printf("FTN ");
408                 else if (ISARY(t))
409                         printf("ARY ");
ragge
1.1
410                 else {
ragge
1.35
411                         printf("%s%s%s"ISCON(q << TSHIFT) ? "const " : "",
412                             ISVOL(q << TSHIFT) ? "volatile " : ""tnames[t]);
ragge
1.1
413                         return;
414                 }
415         }
ragge
1.2
416 }
ragge
1.13
417
418 /*
ragge
1.14
419  * Return a number for internal labels.
420  */
421 int 
422 getlab()
423 {
424         static int crslab = 10;
425         return crslab++;
426 }
427
428 /*
ragge
1.13
429  * Memory allocation routines.
430  * Memory are allocated from the system in MEMCHUNKSZ blocks.
431  * permalloc() returns a bunch of memory that is never freed.
432  * Memory allocated through tmpalloc() will be released the
433  * next time a function is ended (via tmpfree()).
434  */
435
436 #define MEMCHUNKSZ 8192 /* 8k per allocation */
ragge
1.16
437 #define ROUNDUP(x) ((x) + (sizeof(int)-1)) & ~(sizeof(int)-1)
ragge
1.13
438
439 static char *allocpole;
440 static int allocleft;
ragge
1.17
441 static char *tmppole;
442 static int tmpleft;
ragge
1.18
443 int permallocsizetmpallocsizelostmem;
ragge
1.13
444
445 void *
446 permalloc(int size)
447 {
448         void *rv;
449
450 //printf("permalloc: allocpole %p allocleft %d size %d ", allocpole, allocleft, size);
451         if (size > MEMCHUNKSZ)
452                 cerror("permalloc");
ragge
1.20
453         if (size <= 0)
454                 cerror("permalloc2");
ragge
1.18
455         if (allocleft < size) {
ragge
1.13
456                 /* looses unused bytes */
ragge
1.18
457                 lostmem += allocleft;
ragge
1.17
458 //fprintf(stderr, "allocating perm\n");
ragge
1.13
459                 if ((allocpole = malloc(MEMCHUNKSZ)) == NULL)
460                         cerror("permalloc: out of memory");
461                 allocleft = MEMCHUNKSZ;
462         }
ragge
1.16
463         size = ROUNDUP(size);
ragge
1.13
464         rv = &allocpole[MEMCHUNKSZ-allocleft];
465 //printf("rv %p\n", rv);
466         allocleft -= size;
ragge
1.17
467         permallocsize += size;
ragge
1.13
468         return rv;
469 }
470
ragge
1.17
471 static char *tmplink;
472
ragge
1.13
473 void *
474 tmpalloc(int size)
475 {
ragge
1.17
476         void *rv;
477
478         if (size > MEMCHUNKSZ)
479                 cerror("tmpalloc");
ragge
1.20
480         if (size <= 0)
481                 cerror("tmpalloc2");
ragge
1.17
482 //printf("tmpalloc: tmppole %p tmpleft %d size %d ", tmppole, tmpleft, size);
483         if (tmpleft < size) {
484                 if ((tmppole = malloc(MEMCHUNKSZ)) == NULL)
485                         cerror("tmpalloc: out of memory");
486 //fprintf(stderr, "allocating tmp\n");
487                 tmpleft = MEMCHUNKSZ - sizeof(char *);
488                 *(char **)tmppole = tmplink;
489                 tmplink = tmppole;
490         }
491         size = ROUNDUP(size);
492         rv = &tmppole[MEMCHUNKSZ-tmpleft];
493 //printf("rv %p\n", rv);
494         tmpleft -= size;
495         tmpallocsize += size;
496         return rv;
ragge
1.13
497 }
498
499 void
500 tmpfree()
501 {
ragge
1.18
502         char *f, *of;
503
504         f = tmplink;
ragge
1.19
505         if (f == NULL)
506                 return;
507         if (*(char **)f == NULL) {
508                 tmpleft = MEMCHUNKSZ - sizeof(char *);
509                 return;
510         }
ragge
1.18
511         while (f != NULL) {
512                 of = f;
513                 f = *(char **)f;
514                 free(of);
515         }
516         tmplink = tmppole = NULL;
517         tmpleft = 0;
ragge
1.17
518 //fprintf(stderr, "freeing tmp\n");
ragge
1.13
519         /* XXX - nothing right now */
ragge
1.16
520 }
521
522 /*
523  * Allocate space on the permanent stack for a string of length len+1
524  * and copy it there.
525  * Return the new address.
526  */
527 char *
528 newstring(char *sint len)
529 {
530         char *u, *c;
531
532         len++;
533         if (allocleft < len) {
534                 u = c = permalloc(len);
535         } else {
536                 u = c = &allocpole[MEMCHUNKSZ-allocleft];
537                 allocleft -= ROUNDUP(len+1);
538         }
539         while (len--)
540                 *c++ = *s++;
541         return u;
ragge
1.13
542 }
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-08-20 20:32 +0200