Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:gmcgarry:20071222214626

Diff

Diff from 1.10 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/arch/mips/code.c

Annotated File View

gmcgarry
1.10
1 /*      $Id: code.c,v 1.10 2007/12/22 21:46:26 gmcgarry Exp $   */
ragge
1.1
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 /*
31  * MIPS port by Jan Enoksson (janeno-1@student.ltu.se) and
32  * Simon Olsson (simols-1@student.ltu.se) 2005.
33  */
34
gmcgarry
1.7
35 #include <assert.h>
36 #include "pass1.h"
ragge
1.1
37
38 /*
39  * cause the alignment to become a multiple of n
40  * never called for text segment.
41  */
42 void
43 defalign(int n)
44 {
gmcgarry
1.10
45         n = ispow2(n / SZCHAR);
46         if (n == -1)
47                 cerror("defalign: n != 2^i");
48         printf("\t.p2align %d\n"n);
ragge
1.1
49 }
50
51 /*
52  * define the current location as the name p->sname
53  * never called for text segment.
54  */
55 void
56 defnam(struct symtab *p)
57 {
58         char *c = p->sname;
59
60 #ifdef GCC_COMPAT
61         c = gcc_findname(p);
62 #endif
63         if (p->sclass == EXTDEF)
gmcgarry
1.4
64                 printf("\t.globl %s\n"c);
65 #ifdef USE_GAS
66         printf("\t.type %s,@object\n"c);
67         printf("\t.size %s," CONFMT "\n"ctsize(p->stypep->sdfp->ssue));
68 #endif
ragge
1.1
69         printf("%s:\n"c);
70 }
71
gmcgarry
1.7
72 static int rvnr;
73
ragge
1.1
74 /*
75  * code for the end of a function
76  * deals with struct return here
77  */
78 void
79 efcode()
80 {
gmcgarry
1.7
81         NODE *p, *q;
82         int tempnr;
83         int ty;
84
ragge
1.1
85         if (cftnsp->stype != STRTY+FTN && cftnsp->stype != UNIONTY+FTN)
86                 return;
gmcgarry
1.7
87
88         ty = cftnsp->stype - FTN;
89
90         q = block(REGNILNILINCREF(ty), 0cftnsp->ssue);
91         q->n_rval = V0;
92         p = tempnode(0INCREF(ty), 0cftnsp->ssue);
93         tempnr = p->n_lval;
94         p = buildtree(ASSIGNpq);
95         ecomp(p);
96
97         q = tempnode(tempnrINCREF(ty), 0cftnsp->ssue);
98         q = buildtree(UMULqNIL);
99
100         p = tempnode(rvnrINCREF(ty), 0cftnsp->ssue);
101         p = buildtree(UMULpNIL);
102
103         p = buildtree(ASSIGNpq);
104         ecomp(p);
105
106         q = tempnode(rvnrINCREF(ty), 0cftnsp->ssue);
107         p = block(REGNILNILINCREF(ty), 0cftnsp->ssue);
108         p->n_rval = V0;
109         p = buildtree(ASSIGNpq);
110         ecomp(p);
ragge
1.1
111 }
112
gmcgarry
1.9
113 /* Put a symbol in a temporary
114  * used by bfcode() and its helpers */
115 static void
116 putintemp(struct symtab *sym)
117 {
118         NODE *p;
119         spname = sym;
120         p = tempnode(0sym->stypesym->sdfsym->ssue);
121         p = buildtree(ASSIGNpbuildtree(NAME00));
122         sym->soffset = p->n_left->n_lval;
123         sym->sflags |= STNODE;
124         ecomp(p);
125 }
126
127 /* setup the hidden pointer to struct return parameter
128  * used by bfcode() */
129 static void
130 param_retptr(void)
131 {
132         NODE *p, *q;
133
134         p = tempnode(0PTR+STRTY0cftnsp->ssue);
135         rvnr = p->n_lval;
136         q = block(REGNILNILPTR+STRTY0cftnsp->ssue);
137         q->n_rval = A0;
138         p = buildtree(ASSIGNpq);
139         ecomp(p);
140 }
141
142 /* setup struct parameter
143  * push the registers out to memory
144  * used by bfcode() */
145 static void
146 param_struct(struct symtab *symint *regp)
147 {
148         int reg = *regp;
149         NODE *p, *q;
150         int navail;
151         int sz;
152         int off;
153         int num;
154         int i;
155
156         navail = nargregs - (reg - A0);
157         sz = tsize(sym->stypesym->sdfsym->ssue) / SZINT;
158         off = ARGINIT/SZINT + (reg - A0);
159         num = sz > navail ? navail : sz;
160         for (i = 0i < numi++) {
161                 q = block(REGNILNILINT0MKSUE(INT));
162                 q->n_rval = reg++;
163                 p = block(REGNILNILINT0MKSUE(INT));
164                 p->n_rval = FP;
165                 p = block(PLUSpbcon(4*off++), INT0MKSUE(INT));
166                 p = block(UMULpNILINT0MKSUE(INT));
167                 p = buildtree(ASSIGNpq);
168                 ecomp(p);
169         }
170
171         *regp = reg;
172 }
173
174 /* setup a 64-bit parameter (double/ldouble/longlong)
175  * used by bfcode() */
176 static void
177 param_64bit(struct symtab *symint *regpint dotemps)
178 {
179         int reg = *regp;
180         NODE *p, *q;
181         int navail;
182
183         /* alignment */
184         ++reg;
185         reg &= ~1;
186
187         navail = nargregs - (reg - A0);
188
gmcgarry
1.10
189         if (navail < 2) {
gmcgarry
1.9
190                 /* would have appeared half in registers/half
191                  * on the stack, but alignment ensures it
192                  * appears on the stack */
193                 if (dotemps)
194                         putintemp(sym);
gmcgarry
1.10
195                 *regp = reg;
196                 return;
197         }
198
199         q = block(REGNILNILsym->stypesym->sdfsym->ssue);
200         q->n_rval = A0A1 + (reg - A0);
201         if (dotemps) {
202                 p = tempnode(0sym->stypesym->sdfsym->ssue);
203                 sym->soffset = p->n_lval;
204                 sym->sflags |= STNODE;
gmcgarry
1.9
205         } else {
gmcgarry
1.10
206                 spname = sym;
207                 p = buildtree(NAME00);
gmcgarry
1.9
208         }
gmcgarry
1.10
209         p = buildtree(ASSIGNpq);
210         ecomp(p);
211         *regp = reg + 2;
gmcgarry
1.9
212 }
213
214 /* setup a 32-bit param on the stack
215  * used by bfcode() */
216 static void
217 param_32bit(struct symtab *symint *regpint dotemps)
218 {
219         NODE *p, *q;
220
221         q = block(REGNILNILsym->stypesym->sdfsym->ssue);
222         q->n_rval = (*regp)++;
223         if (dotemps) {
224                 p = tempnode(0sym->stypesym->sdfsym->ssue);
225                 sym->soffset = p->n_lval;
226                 sym->sflags |= STNODE;
227         } else {
228                 spname = sym;
229                 p = buildtree(NAME00);
230         }
231         p = buildtree(ASSIGNpq);
232         ecomp(p);
233 }
234
ragge
1.1
235 /*
gmcgarry
1.10
236  * XXX This is a hack.  We cannot have (l)doubles in more than one
237  * register class.  So we bounce them in and out of temps to
238  * move them in and out of the right registers.
239  */
240 static void
241 param_double(struct symtab *symint *regpint dotemps)
242 {
243         int reg = *regp;
244         NODE *p, *q, *t;
245         int navail;
246         int tmpnr;
247
248         /* alignment */
249         ++reg;
250         reg &= ~1;
251
252         navail = nargregs - (reg - A0);
253
254         if (navail < 2) {
255                 /* would have appeared half in registers/half
256                  * on the stack, but alignment ensures it
257                  * appears on the stack */
258                 if (dotemps)
259                         putintemp(sym);
260                 *regp = reg;
261                 return;
262         }
263
264         t = tempnode(0LONGLONG0MKSUE(LONGLONG));
265         tmpnr = t->n_lval;
266         q = block(REGNILNILLONGLONG0MKSUE(LONGLONG));
267         q->n_rval = A0A1 + (reg - A0);
268         p = buildtree(ASSIGNtq);
269         ecomp(p);
270
271         if (dotemps) {
272                 sym->soffset = tmpnr;
273                 sym->sflags |= STNODE;
274         } else {
275                 q = tempnode(tmpnrsym->stypesym->sdfsym->ssue);
276                 spname = sym;
277                 p = buildtree(NAME00);
278                 p = buildtree(ASSIGNpq);
279                 ecomp(p);
280         }
281         *regp = reg + 2;
282 }
283
284 /*
285  * XXX This is a hack.  We cannot have floats in more than one
286  * register class.  So we bounce them in and out of temps to
287  * move them in and out of the right registers.
288  */
289 static void
290 param_float(struct symtab *symint *regpint dotemps)
291 {
292         NODE *p, *q, *t;
293         int tmpnr;
294
295         t = tempnode(0INT0MKSUE(INT));
296         tmpnr = t->n_lval;
297         q = block(REGNILNILINT0MKSUE(INT));
298         q->n_rval = (*regp)++;
299         p = buildtree(ASSIGNtq);
300         ecomp(p);
301
302         if (dotemps) {
303                 sym->soffset = tmpnr;
304                 sym->sflags |= STNODE;
305         } else {
306                 q = tempnode(tmpnrsym->stypesym->sdfsym->ssue);
307                 spname = sym;
308                 p = buildtree(NAME00);
309                 p = buildtree(ASSIGNpq);
310                 ecomp(p);
311         }
312 }
313
314 /*
ragge
1.1
315  * code for the beginning of a function; a is an array of
316  * indices in symtab for the arguments; n is the number
317  */
318 void
gmcgarry
1.4
319 bfcode(struct symtab **spint cnt)
ragge
1.1
320 {
gmcgarry
1.9
321         union arglist *usym;
322         int lastreg = A0 + nargregs - 1;
323         int saveallargs = 0;
324         int ireg;
325
326         /*
327          * Detect if this function has ellipses and save all
328          * argument register onto stack.
329          */
330         usym = cftnsp->sdf->dfun;
331         while (usym && usym->type != TNULL) {
332                 if (usym->type == TELLIPSIS) {
333                         saveallargs = 1;
334                         break;
335                 }
336                 ++usym;
337         }
338
339         reg = A0;
ragge
1.1
340
gmcgarry
1.7
341         /* assign hidden return structure to temporary */
ragge
1.1
342         if (cftnsp->stype == STRTY+FTN || cftnsp->stype == UNIONTY+FTN) {
gmcgarry
1.9
343                 param_retptr();
344                 ++reg;
ragge
1.1
345         }
346
gmcgarry
1.4
347         /* recalculate the arg offset and create TEMP moves */
gmcgarry
1.9
348         for (i = 0i < cnti++) {
gmcgarry
1.7
349
gmcgarry
1.9
350                 if ((reg > lastreg) && !xtemps)
351                         break;
352                 else if (reg > lastreg
353                         putintemp(sp[i]);
354                 else if (sp[i]->stype == STRTY || sp[i]->stype == UNIONTY)
355                         param_struct(sp[i], &reg);
gmcgarry
1.10
356                 else if (DEUNSIGN(sp[i]->stype) == LONGLONG)
gmcgarry
1.9
357                         param_64bit(sp[i], &regxtemps && !saveallargs);
gmcgarry
1.10
358                 else if (sp[i]->stype == DOUBLE || sp[i]->stype == LDOUBLE)
359                         param_double(sp[i], &regxtemps && !saveallargs);
360                 else if (sp[i]->stype == FLOAT)
361                         param_float(sp[i], &regxtemps && !saveallargs);
gmcgarry
1.9
362                 else
363                         param_32bit(sp[i], &regxtemps && !saveallargs);
364         }
gmcgarry
1.7
365
gmcgarry
1.9
366         /* if saveallargs, save the rest of the args onto the stack */
367         if (!saveallargs)
368                 return;
369         while (reg <= lastreg) {
370                 NODE *p, *q;
371                 int off = ARGINIT/SZINT + (reg - A0);
372                 q = block(REGNILNILINT0MKSUE(INT));
373                 q->n_rval = reg++;
374                 p = block(REGNILNILINT0MKSUE(INT));
375                 p->n_rval = FP;
376                 p = block(PLUSpbcon(4*off), INT0MKSUE(INT));
377                 p = block(UMULpNILINT0MKSUE(INT));
378                 p = buildtree(ASSIGNpq);
379                 ecomp(p);
380         }
ragge
1.1
381
382 }
383
384
385 /*
386  * by now, the automatics and register variables are allocated
387  */
388 void
389 bccode()
390 {
391         SETOFF(autooffSZINT);
392 }
393
394 /* called just before final exit */
395 /* flag is 1 if errors, 0 if none */
396 void
397 ejobcode(int flag )
398 {
399 }
400
401 void
402 bjobcode()
403 {
gmcgarry
1.7
404         printf("\t.section .mdebug.abi32\n");
405         printf("\t.previous\n");
406         printf("\t.abicalls\n");
ragge
1.1
407 }
408
409 /*
410  * Print character t at position i in one string, until t == -1.
411  * Locctr & label is already defined.
412  */
413 void
414 bycode(int tint i)
415 {
gmcgarry
1.2
416         static int lastoctal = 0;
ragge
1.1
417
418         /* put byte i+1 in a string */
419
420         if (t < 0) {
421                 if (i != 0)
gmcgarry
1.10
422                         puts("\\000\"");
ragge
1.1
423         } else {
424                 if (i == 0)
gmcgarry
1.10
425                         printf("\t.ascii \"");
gmcgarry
1.2
426                 if (t == 0)
427                         return;
428                 else if (t == '\\' || t == '"') {
ragge
1.1
429                         lastoctal = 0;
430                         putchar('\\');
431                         putchar(t);
gmcgarry
1.10
432                 } else if (t == 011) {
433                         printf("\\t");
gmcgarry
1.2
434                 } else if (t == 012) {
435                         printf("\\n");
ragge
1.1
436                 } else if (t < 040 || t >= 0177) {
437                         lastoctal++;
438                         printf("\\%o",t);
439                 } else if (lastoctal && '0' <= t && t <= '9') {
440                         lastoctal = 0;
gmcgarry
1.10
441                         printf("\"\n\t.ascii \"%c"t);
ragge
1.1
442                 } else {        
443                         lastoctal = 0;
444                         putchar(t);
445                 }
446         }
447 }
448
449 /*
450  * return the alignment of field of type t
451  */
452 int
453 fldal(unsigned int t)
454 {
455         uerror("illegal field type");
456         return(ALINT);
457 }
458
459 /* fix up type of field p */
460 void
461 fldty(struct symtab *p)
462 {
463 }
464
stefan
1.5
465 /*
ragge
1.1
466  * XXX - fix genswitch.
467  */
stefan
1.5
468 int
469 mygenswitch(int numTWORD typestruct swents **pint n)
ragge
1.1
470 {
stefan
1.5
471         return 0;
ragge
1.1
472 }
gmcgarry
1.4
473
gmcgarry
1.9
474
475 /* setup call stack with a structure */
476 /* called from moveargs() */
477 static NODE *
478 movearg_struct(NODE *pNODE *parentint *regp)
479 {
480         int reg = *regp;
gmcgarry
1.10
481         NODE *l, *q, *t, *r;
482         int tmpnr;
gmcgarry
1.9
483         int navail;
484         int off;
485         int num;
486         int sz;
gmcgarry
1.10
487         int ty;
gmcgarry
1.9
488         int i;
489
490         navail = nargregs - (reg - A0);
491         sz = tsize(p->n_typep->n_dfp->n_sue) / SZINT;
492         num = sz > navail ? navail : sz;
493
gmcgarry
1.10
494         l = p->n_left;
495         nfree(p);
496         ty = l->n_type;
497         t = tempnode(0l->n_typel->n_dfl->n_sue);
498         tmpnr = t->n_lval;
499         l = buildtree(ASSIGNtl);
500
501         if (p != parent) {
gmcgarry
1.9
502                 q = parent->n_left;
gmcgarry
1.10
503         } else
gmcgarry
1.9
504                 q = NULL;
505
506         /* copy structure into registers */
507         for (i = 0i < numi++) {
gmcgarry
1.10
508                 t = tempnode(tmpnrty0MKSUE(PTR+ty));
gmcgarry
1.9
509                 t = block(SCONVtNILPTR+INT0MKSUE(PTR+INT));
510                 t = block(PLUStbcon(4*i), PTR+INT0MKSUE(PTR+INT));
511                 t = buildtree(UMULtNIL);
512
513                 r = block(REGNILNILINT0MKSUE(INT));
514                 r->n_rval = reg++;
515
516                 r = buildtree(ASSIGNrt);
517                 if (q == NULL)
518                         q = r;
gmcgarry
1.10
519                 else 
gmcgarry
1.9
520                         q = block(CMqrINT0MKSUE(INT));
521         }
522         off = ARGINIT/SZINT + nargregs;
523         for (i = numi < szi++) {
gmcgarry
1.10
524                 t = tempnode(tmpnrty0MKSUE(PTR+ty));
gmcgarry
1.9
525                 t = block(SCONVtNILPTR+INT0MKSUE(PTR+INT));
526                 t = block(PLUStbcon(4*i), PTR+INT0MKSUE(PTR+INT));
527                 t = buildtree(UMULtNIL);
528
529                 r = block(REGNILNILINT0MKSUE(INT));
530                 r->n_rval = FP;
531                 r = block(PLUSrbcon(4*off++), INT0MKSUE(INT));
532                 r = block(UMULrNILINT0MKSUE(INT));
533
534                 r = buildtree(ASSIGNrt);
535                 if (q == NULL)
536                         q = r;
537                 else
538                         q = block(CMqrINT0MKSUE(INT));
539         }
540
541         if (parent->n_op == CM) {
gmcgarry
1.10
542                 parent->n_left = q;
543                 q = l;
544         } else {
545                 q = block(CMqlINT0MKSUE(INT));
gmcgarry
1.9
546         }
547
548         *regp = reg;
549         return q;
550 }
551
552 /* setup call stack with 64-bit argument */
553 /* called from moveargs() */
554 static NODE *
555 movearg_64bit(NODE *pint *regp)
556 {
557         int reg = *regp;
558         NODE *q;
gmcgarry
1.10
559         int lastarg;
gmcgarry
1.9
560
561         /* alignment */
562         ++reg;
563         reg &= ~1;
564
gmcgarry
1.10
565         lastarg = A0 + nargregs - 1;
566         if (reg > lastarg) {
567                 *regp = reg;
568                 return block(FUNARGpNILp->n_typep->n_dfp->n_sue);
569         }
570
gmcgarry
1.9
571         q = block(REGNILNILp->n_typep->n_dfp->n_sue);
gmcgarry
1.10
572         q->n_rval = A0A1 + (reg - A0);
gmcgarry
1.9
573         q = buildtree(ASSIGNqp);
574
gmcgarry
1.10
575         *regp = reg + 2;
gmcgarry
1.9
576         return q;
577 }
578
579 /* setup call stack with 32-bit argument */
580 /* called from moveargs() */
581 static NODE *
582 movearg_32bit(NODE *pint *regp)
583 {
584         int reg = *regp;
585         NODE *q;
586
587         q = block(REGNILNILp->n_typep->n_dfp->n_sue);
588         q->n_rval = reg++;
589         q = buildtree(ASSIGNqp);
590
591         *regp = reg;
592         return q;
593 }
594
595 static NODE *
596 moveargs(NODE *pint *regp)
gmcgarry
1.4
597 {
gmcgarry
1.9
598         NODE *r, **rp;
599         int lastreg;
600         int reg;
gmcgarry
1.7
601
gmcgarry
1.9
602         if (p->n_op == CM) {
603                 p->n_left = moveargs(p->n_leftregp);
604                 r = p->n_right;
605                 rp = &p->n_right;
gmcgarry
1.4
606         } else {
gmcgarry
1.9
607                 r = p;
608                 rp = &p;
gmcgarry
1.7
609         }
gmcgarry
1.4
610
gmcgarry
1.9
611         lastreg = A0 + nargregs - 1;
612         reg = *regp;
613
614         if (reg > lastreg && r->n_op != STARG)
615                 *rp = block(FUNARGrNILr->n_typer->n_dfr->n_sue);
616         else if (r->n_op == STARG) {
617                 *rp = movearg_struct(rpregp);
gmcgarry
1.10
618         } else if (DEUNSIGN(r->n_type) == LONGLONG) {
gmcgarry
1.9
619                 *rp = movearg_64bit(rregp);
gmcgarry
1.10
620         } else if (r->n_type == DOUBLE || r->n_type == LDOUBLE) {
621                 /* XXX bounce in and out of temporary to change to longlong */
622                 NODE *t1 = tempnode(0LONGLONG0MKSUE(LONGLONG));
623                 int tmpnr = t1->n_lval;
624                 NODE *t2 = tempnode(tmpnrr->n_typer->n_dfr->n_sue);
625                 t1 =  movearg_64bit(t1regp);
626                 r = block(ASSIGNt2rr->n_typer->n_dfr->n_sue);
627                 if (p->n_op == CM) {
628                         p->n_left = buildtree(CMp->n_leftt1);
629                         p->n_right = r;
630                 } else {
631                         p = buildtree(CMt1r);
632                 }
633         } else if (r->n_type == FLOAT) {
634                 /* XXX bounce in and out of temporary to change to int */
635                 NODE *t1 = tempnode(0INT0MKSUE(INT));
636                 int tmpnr = t1->n_lval;
637                 NODE *t2 = tempnode(tmpnrr->n_typer->n_dfr->n_sue);
638                 t1 =  movearg_32bit(t1regp);
639                 r = block(ASSIGNt2rr->n_typer->n_dfr->n_sue);
640                 if (p->n_op == CM) {
641                         p->n_left = buildtree(CMp->n_leftt1);
642                         p->n_right = r;
643                 } else {
644                         p = buildtree(CMt1r);
645                 }
646         } else {
gmcgarry
1.9
647                 *rp = movearg_32bit(rregp);
gmcgarry
1.10
648         }
gmcgarry
1.9
649
650         return p;
gmcgarry
1.4
651 }
652
ragge
1.3
653 /*
654  * Called with a function call with arguments as argument.
655  * This is done early in buildtree() and only done once.
656  */
657 NODE *
658 funcode(NODE *p)
659 {
gmcgarry
1.4
660         int regnum = A0;
gmcgarry
1.7
661         NODE *l, *r, *t, *q;
662         int ty;
663
664         l = p->n_left;
665         r = p->n_right;
666
gmcgarry
1.9
667         /*
668          * if returning a structure, make the first argument
669          * a hidden pointer to return structure.
670          */
gmcgarry
1.7
671         ty = DECREF(l->n_type);
672         if (ty == STRTY+FTN || ty == UNIONTY+FTN) {
673                 ty = DECREF(l->n_type) - FTN;
674                 q = tempnode(0tyl->n_dfl->n_sue);
675                 q = buildtree(ADDROFqNIL);
676                 if (r->n_op != CM) {
677                         p->n_right = block(CMqrINCREF(ty),
678                             l->n_dfl->n_sue);
679                 } else {
680                         for (t = rt->n_left->n_op == CMt = t->n_left)
681                                 ;
682                         t->n_left = block(CMqt->n_leftINCREF(ty),
683                             l->n_dfl->n_sue);
684                 }
685         }
686
gmcgarry
1.9
687         p->n_right = moveargs(p->n_right, &regnum);
688
ragge
1.3
689         return p;
690 }
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-07-11 04:20 +0200