Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20140603201950

Diff

Diff from 1.11 to:

Annotations

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

Annotated File View

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