Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030707145715

Diff

Diff from 1.29 to:

Annotations

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

Annotated File View

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