Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20080622152459

Diff

Diff from 1.5 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/arch/nova/local2.c

Annotated File View

ragge
1.5
1 /*      $Id: local2.c,v 1.5 2008/06/22 15:24:59 ragge Exp $     */
ragge
1.1
2 /*
3  * Copyright (c) 2006 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 # include "pass2.h"
31 # include <ctype.h>
32 # include <string.h>
33
34 void acon(NODE *p);
35 int argsize(NODE *p);
36
37 void
38 deflab(int label)
39 {
40         printf(LABFMT ":\n"label);
41 }
42
43 static int prolnum;
44 static struct ldq {
45         struct ldq *next;
46         int val;
47         int lab;
48         char *name;
49 } *ldq;
50
51
52 void
53 prologue(struct interpass_prolog *ipp)
54 {
55         int ij;
56
57         for (i = ipp->ipp_regsj = 0ii >>= 1)
58                 if (i&1)
59                         j++;
60         printf(".LP%d:  .word 0%o\n"prolnumj);
61         if (ipp->ipp_vis)
62                 printf("        .globl %s\n"ipp->ipp_name);
63         printf("%s:\n"ipp->ipp_name);
64         printf("        sta 3,@40\n");  /* save ret pc on stack */
65         printf("        lda 2,.LP%d-.,1\n"prolnum);
66         printf("        jsr @45\n");
67         prolnum++;
68 }
69
70 void
71 eoftn(struct interpass_prolog *ipp)
72 {
73         int ij;
74
75         if (ipp->ipp_ip.ip_lbl == 0)
76                 return/* no code needs to be generated */
77
78         /* return from function code */
79         for (i = ipp->ipp_regsj = 0i ; i >>= 1)
80                 if (i & 1)
81                         j++;
82         printf("        lda 2,.LP%d-.,1\n"prolnum);
83         printf("        jmp @46\n");
84         printf(".LP%d:  .word 0%o\n"prolnumj);
85         prolnum++;
86         while (ldq) {
87                 printf(".LP%d:  .word 0%o"ldq->labldq->val);
88                 if (ldq->name && *ldq->name)
89                         printf("+%s"ldq->name);
90                 printf("\n");
91                 ldq = ldq->next;
92         }
93 }
94
95 /*
96  * add/sub/...
97  *
98  * Param given:
99  */
100 void
101 hopcode(int fint o)
102 {
103         char *str = 0;
104
105         switch (o) {
106         case PLUS:
107                 str = "add";
108                 break;
109         case MINUS:
110                 str = "sub";
111                 break;
112         case AND:
113                 str = "and";
114                 break;
115         case OR:
116                 cerror("hopcode OR");
117                 break;
118         case ER:
119                 cerror("hopcode xor");
120                 str = "xor";
121                 break;
122         default:
123                 comperr("hopcode2: %d"o);
124                 str = 0/* XXX gcc */
125         }
126         printf("%s%c"strf);
127 }
128
129 #if 0
130 /*
131  * Return type size in bytes.  Used by R2REGS, arg 2 to offset().
132  */
133 int
134 tlen(pNODE *p;
135 {
136         switch(p->n_type) {
137                 case CHAR:
138                 case UCHAR:
139                         return(1);
140
141                 case SHORT:
142                 case USHORT:
143                         return(SZSHORT/SZCHAR);
144
145                 case DOUBLE:
146                         return(SZDOUBLE/SZCHAR);
147
148                 case INT:
149                 case UNSIGNED:
150                 case LONG:
151                 case ULONG:
152                         return(SZINT/SZCHAR);
153
154                 case LONGLONG:
155                 case ULONGLONG:
156                         return SZLONGLONG/SZCHAR;
157
158                 default:
159                         if (!ISPTR(p->n_type))
160                                 comperr("tlen type %d not pointer");
161                         return SZPOINT(p->n_type)/SZCHAR;
162                 }
163 }
164 #endif
165
stefan
1.4
166 int
167 fldexpand(NODE *pint cookiechar **cp)
168 {
169         return 0;
170 }
171
ragge
1.1
172 #if 0
173 /*
174  * Assign to a bitfield.
175  * Clumsy at least, but what to do?
176  */
177 static void
178 bfasg(NODE *p)
179 {
180         NODE *fn = p->n_left;
181         int shift = UPKFOFF(fn->n_rval);
182         int fsz = UPKFSZ(fn->n_rval);
183         int andvaltch = 0;
184
185         /* get instruction size */
186         switch (p->n_type) {
187         case CHARcase UCHARtch = 'b'break;
188         case SHORTcase USHORTtch = 'w'break;
189         case INTcase UNSIGNEDtch = 'l'break;
190         defaultcomperr("bfasg");
191         }
192
193         /* put src into a temporary reg */
194         fprintf(stdout"       mov%c "tch);
195         adrput(stdoutgetlr(p'R'));
196         fprintf(stdout",");
197         adrput(stdoutgetlr(p'1'));
198         fprintf(stdout"\n");
199
200         /* AND away the bits from dest */
201         andval = ~(((1 << fsz) - 1) << shift);
202         fprintf(stdout"       and%c $%d,"tchandval);
203         adrput(stdoutfn->n_left);
204         fprintf(stdout"\n");
205
206         /* AND away unwanted bits from src */
207         andval = ((1 << fsz) - 1);
208         fprintf(stdout"       and%c $%d,"tchandval);
209         adrput(stdoutgetlr(p'1'));
210         fprintf(stdout"\n");
211
212         /* SHIFT left src number of bits */
213         if (shift) {
214                 fprintf(stdout"       sal%c $%d,"tchshift);
215                 adrput(stdoutgetlr(p'1'));
216                 fprintf(stdout"\n");
217         }
218
219         /* OR in src to dest */
220         fprintf(stdout"       or%c "tch);
221         adrput(stdoutgetlr(p'1'));
222         fprintf(stdout",");
223         adrput(stdoutfn->n_left);
224         fprintf(stdout"\n");
225 }
226 #endif
227
228 #if 0
229 /*
230  * Push a structure on stack as argument.
231  * the scratch registers are already free here
232  */
233 static void
234 starg(NODE *p)
235 {
236         FILE *fp = stdout;
237
238         fprintf(fp"   subl $%d,%%esp\n"p->n_stsize);
239         fprintf(fp"   pushl $%d\n"p->n_stsize);
240         expand(p0"  pushl AL\n");
241         expand(p0"  leal 8(%esp),A1\n");
242         expand(p0"  pushl A1\n");
243         fprintf(fp"   call memcpy\n");
244         fprintf(fp"   addl $12,%%esp\n");
245 }
246 #endif
247
248 void
249 zzzcode(NODE *pint c)
250 {
251         struct ldq *ld;
252
253         switch (c) {
254         case 'A'/* print out a skip ending if any numbers in queue */
255                 if (ldq == NULL)
256                         return;
257                 printf(",skp\n.LP%d:    .word 0%o"ldq->labldq->val);
258                 if (ldq->name && *ldq->name)
259                         printf("+%s"ldq->name);
260                 printf("\n");
261                 ldq = ldq->next;
262                 break;
263
264         case 'B'/* print a label for later load */
265                 ld = tmpalloc(sizeof(struct ldq));
266                 ld->val = p->n_lval;
267                 ld->name = p->n_name;
268                 ld->lab = prolnum++;
269                 ld->next = ldq;
270                 ldq = ld;
271                 printf(".LP%d-."ld->lab);
272                 break;
273
274         case 'C'/* fix reference to external variable via indirection */
275                 zzzcode(p->n_left'B');
276                 break;
277
278         case 'D'/* fix reference to external variable via indirection */
279                 zzzcode(p'B');
280                 break;
281
282         default:
283                 comperr("zzzcode %c"c);
284         }
285 }
286
287 /*ARGSUSED*/
288 int
289 rewfld(NODE *p)
290 {
291         return(1);
292 }
293
294 int canaddr(NODE *);
295 int
296 canaddr(NODE *p)
297 {
298         int o = p->n_op;
299
300         if (o==NAME || o==REG || o==ICON || o==OREG ||
301             (o==UMUL && shumul(p->n_left)))
302                 return(1);
303         return(0);
304 }
305
306 /*
307  * Does the bitfield shape match?
308  */
309 int
310 flshape(NODE *p)
311 {
312         int o = p->n_op;
313
314 cerror("flshape");
315         if (o == OREG || o == REG || o == NAME)
316                 return SRDIR/* Direct match */
317         if (o == UMUL && shumul(p->n_left))
318                 return SROREG/* Convert into oreg */
319         return SRREG/* put it into a register */
320 }
321
322 /* INTEMP shapes must not contain any temporary registers */
323 /* XXX should this go away now? */
324 int
325 shtemp(NODE *p)
326 {
327         return 0;
328 #if 0
329         int r;
330
331         if (p->n_op == STARG )
332                 p = p->n_left;
333
334         switch (p->n_op) {
335         case REG:
336                 return (!istreg(p->n_rval));
337
338         case OREG:
339                 r = p->n_rval;
340                 if (R2TEST(r)) {
341                         if (istreg(R2UPK1(r)))
342                                 return(0);
343                         r = R2UPK2(r);
344                 }
345                 return (!istreg(r));
346
347         case UMUL:
348                 p = p->n_left;
349                 return (p->n_op != UMUL && shtemp(p));
350         }
351
352         if (optype(p->n_op) != LTYPE)
353                 return(0);
354         return(1);
355 #endif
356 }
357
358 void
359 adrcon(CONSZ val)
360 {
361         printf("$" CONFMTval);
362 }
363
364 /*
365  * Conput should only be used by e2print on Nova.
366  */
367 void
368 conput(FILE *fpNODE *p)
369 {
370         int val = p->n_lval;
371
372         switch (p->n_op) {
373         case ICON:
374                 if (p->n_name[0] != '\0') {
375                         fprintf(fp"%s"p->n_name);
376                         if (val)
377                                 fprintf(fp"+%d"val);
378                 } else
379                         fprintf(fp"%d"val);
380                 return;
381
382         default:
383                 comperr("illegal conput, p %p"p);
384         }
385 }
386
387 /*ARGSUSED*/
388 void
389 insput(NODE *p)
390 {
391         comperr("insput");
392 }
393
394 /*
395  * Write out the upper address, like the upper register of a 2-register
396  * reference, or the next memory location.
397  */
398 void
399 upput(NODE *pint size)
400 {
401 comperr("upput");
402 #if 0
403         size /= SZCHAR;
404         switch (p->n_op) {
405         case REG:
406                 fprintf(stdout"%%%s", &rnames[p->n_rval][3]);
407                 break;
408
409         case NAME:
410         case OREG:
411                 p->n_lval += size;
412                 adrput(stdoutp);
413                 p->n_lval -= size;
414                 break;
415         case ICON:
416                 fprintf(stdout"$" CONFMTp->n_lval >> 32);
417                 break;
418         default:
419                 comperr("upput bad op %d size %d"p->n_opsize);
420         }
421 #endif
422 }
423
424 void
425 adrput(FILE *ioNODE *p)
426 {
427         /* output an address, with offsets, from p */
428
429         if (p->n_op == FLD)
430                 p = p->n_left;
431
432         switch (p->n_op) {
433
434         case NAME:
435                 if (p->n_name[0] != '\0')
436                         fputs(p->n_nameio);
437                 if (p->n_lval != 0)
438                         fprintf(io"+" CONFMTp->n_lval);
439                 return;
440
441         case OREG:
442                 printf("%d,%s", (int)p->n_lvalrnames[p->n_rval]);
443                 return;
444
445         case ICON:
446                 /* addressable value of the constant */
447                 fputc('$'io);
448                 conput(iop);
449                 return;
450
451         case MOVE:
452         case REG:
453                 switch (p->n_type) {
454                 case LONGLONG:
455                 case ULONGLONG:
456                         fprintf(io"%%%c%c%c"rnames[p->n_rval][0],
457                             rnames[p->n_rval][1], rnames[p->n_rval][2]);
458                         break;
459                 case SHORT:
460                 case USHORT:
461                         fprintf(io"%%%s", &rnames[p->n_rval][2]);
462                         break;
463                 default:
464                         fprintf(io"%s"rnames[p->n_rval]);
465                 }
466                 return;
467
468         default:
469                 comperr("illegal address, op %d, node %p"p->n_opp);
470                 return;
471
472         }
473 }
474
475 /*   printf conditional and unconditional branches */
476 void
477 cbgen(int oint lab)
478 {
479         comperr("cbgen");
480 }
481
482 void
483 myreader(struct interpass *ipole)
484 {
485         if (x2debug)
486                 printip(ipole);
487 }
488
489 void
490 mycanon(NODE *p)
491 {
492 }
493
494 void
495 myoptim(struct interpass *ip)
496 {
497 }
498
499 void
500 rmove(int sint dTWORD t)
501 {
502         comperr("rmove");
503 }
504
505 /*
506  * For class c, find worst-case displacement of the number of
507  * registers in the array r[] indexed by class.
508  * Return true if we always can find a color.
509  */
510 int
511 COLORMAP(int cint *r)
512 {
513         int num;
514
515         switch (c) {
516         case CLASSA:
517                 num = r[CLASSB] + r[CLASSA];
518                 return num < 4;
519         case CLASSB:
520                 num = r[CLASSB] + r[CLASSA];
521                 return num < 2;
522         case CLASSC:
523                 return r[CLASSC] < CREGCNT;
524         case CLASSD:
525                 return r[CLASSD] < DREGCNT;
526         }
527         return 0/* XXX gcc */
528 }
529
530 char *rnames[] = {
531         "0""1""2""3",
532         "050""051""052""053""054""055""056""057",
533         "060""061""062""063""064""065""066""067",
534         "070""071""072""073""074""075""076""077",
535         "041""040"
536 };
537
538 /*
539  * Return a class suitable for a specific type.
540  */
541 int
542 gclass(TWORD t)
543 {
544         return CLASSA;
545 }
546
547 /*
548  * Calculate argument sizes.
549  */
550 void
551 lastcall(NODE *p)
552 {
553 }
554
555 /*
556  * Special shapes.
557  */
558 int
559 special(NODE *pint shape)
560 {
561         return SRNOPE;
562 }
gmcgarry
1.3
563
564 /*
565  * Target-dependent command-line options.
566  */
567 void
568 mflags(char *str)
569 {
570 }
ragge
1.5
571 /*
572  * Do something target-dependent for xasm arguments.
573  * Supposed to find target-specific constraints and rewrite them.
574  */
575 int
576 myxasm(struct interpass *ipNODE *p)
577 {
578         return 0;
579 }
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 05:04 +0100