Quick Search:

Mode

Context

Displaying 3 lines of context. None | Less | More | Full

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.44
 
1.45
 
MAIN:ragge:20110407185015
 
local.c
_>136136 static NODE *
 137137 cmop(NODE *l, NODE *r)
 138138 {
<>139 -        return block(CM, l, r, INT, 0, MKAP(INT));
  139+        return block(CM, l, r, INT, 0, 0);
140140 }
 141141 
 142142 static NODE *
 143143 mkx(char *s, NODE *p)
 144144 {
<>145 -        p = block(XARG, p, NIL, INT, 0, MKAP(INT));
  145+        p = block(XARG, p, NIL, INT, 0, 0);
146146         p->n_name = s;
 147147         return p;
 148148 }
     
 !
191191 
 192192         s = ccopy(r = tempnode(0, INCREF(p->n_type), p->n_df, p->n_ap));
 193193         r = mkx("=a", r);
<>194 -        r = block(XASM, r, q, INT, 0, MKAP(INT));
  194+        r = block(XASM, r, q, INT, 0, 0);
195195 
 196196         /* Create the magic string */
 197197         s1 = ".byte 0x66\n\tleaq ";
     
 !
226226 
 227227         s = ccopy(r = tempnode(0, INCREF(p->n_type), p->n_df, p->n_ap));
 228228         r = mkx("=r", r);
<>229 -        r = block(XASM, r, q, INT, 0, MKAP(INT));
  229+        r = block(XASM, r, q, INT, 0, 0);
230230 
 231231         s1 = "movq %%fs:0,%0\n\taddq ";
 232232         s2 = "@GOTTPOFF(%%rip),%0";
     
 !
263263 stkblk(TWORD t)
 264264 {
 265265         int al, tsz, off, noff;
<>266 -        struct attr *bt;
267266         NODE *p;
 268267 
<>269 -        bt = MKAP(BTYPE(t));
 270 -        al = talign(t, bt);
 271 -        tsz = (int)tsize(t, 0, bt);
  268+        al = talign(t, 0);
  269+        tsz = (int)tsize(t, 0, 0);
272270 
 273271         noff = autooff + tsz;
 274272         SETOFF(noff, al);
 275273         off = -noff;
 276274         autooff = noff;
 277275 
<>278 -        p = block(REG, NIL, NIL, INCREF(t), 0, bt);
  276+        p = block(REG, NIL, NIL, INCREF(t), 0, 0);
279277         p->n_lval = 0;
 280278         p->n_rval = FPREG;
 281279         p = buildtree(UMUL, buildtree(PLUS, p, bcon(off/SZLDOUBLE)), NIL);
     
 !
393391         case UCALL:
 394392         case USTCALL:
 395393                 /* For now, always clear eax */
<>396 -                l = block(REG, NIL, NIL, INT, 0, MKAP(INT));
  394+                l = block(REG, NIL, NIL, INT, 0, 0);
397395                 regno(l) = RAX;
 398396                 p->n_right = clocal(buildtree(ASSIGN, l, bcon(0)));
 399397                 p->n_op -= (UCALL-CALL);
     
 !
449447                 }
 450448                 if (l->n_type < LONG) {
 451449                         /* float etc? */
<>452 -                        p->n_left = block(SCONV, l, NIL,
 453 -                            UNSIGNED, 0, MKAP(UNSIGNED));
  450+                        p->n_left = block(SCONV, l, NIL, UNSIGNED, 0, 0);
454451                         break;
 455452                 }
 456453                 /* if left is SCONV, cannot remove */
     
 !
508505                 }
 509506 
 510507                 if ((p->n_type & TMASK) == 0 && (l->n_type & TMASK) == 0 &&
<>511 -                    btattr[p->n_type].atypsz == btattr[l->n_type].atypsz) {
  508+                    tsize(p->n_type, p->n_df, p->n_ap) ==
  509+                    tsize(l->n_type, l->n_df, l->n_ap)) {
512510                         if (p->n_type != FLOAT && p->n_type != DOUBLE &&
 513511                             l->n_type != FLOAT && l->n_type != DOUBLE &&
 514512                             l->n_type != LDOUBLE && p->n_type != LDOUBLE) {
     
 !
579577                                 cerror("unknown type %d", m);
 580578                         }
 581579                         l->n_type = m;
<>582 -                        l->n_ap = MKAP(m);
  580+                        l->n_ap = NULL;
583581                         nfree(p);
 584582                         return l;
 585583                 } else if (l->n_op == FCON) {
     
 !
590588                         l->n_sp = NULL;
 591589                         l->n_op = ICON;
 592590                         l->n_type = m;
<>593 -                        l->n_ap = MKAP(m);
  591+                        l->n_ap = NULL;
594592                         nfree(p);
 595593                         return clocal(l);
 596594                 }
     
 !
616614                 if (o == MOD && p->n_type != CHAR && p->n_type != SHORT)
 617615                         break;
 618616                 /* make it an int division by inserting conversions */
<>619 -                p->n_left = block(SCONV, p->n_left, NIL, INT, 0, MKAP(INT));
 620 -                p->n_right = block(SCONV, p->n_right, NIL, INT, 0, MKAP(INT));
 621 -                p = block(SCONV, p, NIL, p->n_type, 0, MKAP(p->n_type));
  617+                p->n_left = block(SCONV, p->n_left, NIL, INT, 0, 0);
  618+                p->n_right = block(SCONV, p->n_right, NIL, INT, 0, 0);
  619+                p = block(SCONV, p, NIL, p->n_type, 0, 0);
622620                 p->n_left->n_type = INT;
 623621                 break;
 624622 
     
 !
633631                 /* put return value in return reg */
 634632                 p->n_op = ASSIGN;
 635633                 p->n_right = p->n_left;
<>636 -                p->n_left = block(REG, NIL, NIL, p->n_type, 0, MKAP(INT));
  634+                p->n_left = block(REG, NIL, NIL, p->n_type, 0, 0);
637635                 t = p->n_type;
 638636                 if (ISITY(t))
 639637                         t = t - (FIMAG-FLOAT);
     
 !
646644                 /* shift count must be in a char */
 647645                 if (p->n_right->n_type == CHAR || p->n_right->n_type == UCHAR)
 648646                         break;
<>649 -                p->n_right = block(SCONV, p->n_right, NIL,
 650 -                    CHAR, 0, MKAP(CHAR));
  647+                p->n_right = block(SCONV, p->n_right, NIL, CHAR, 0, 0);
651648                 break;
 652649         }
 653650 #ifdef PCC_DEBUG
     
 !
675672                         sps.sflags = sps.sclass = 0;
 676673                         sps.sname = sps.soname = "";
 677674                         sps.slevel = 1;
<>678 -                        sps.sap = MKAP(LDOUBLE); /* alignment */
  675+                        sps.sap = NULL;
679676                         sps.soffset = dblxor;
 680677                         defloc(&sps);
 681678                         printf("\t.long 0,0x80000000,0,0\n");
     
 !
691688         /* XXX should let float constants follow */
 692689         sp = IALLOC(sizeof(struct symtab));
 693690         sp->sclass = STATIC;
<>694 -        sp->sap = MKAP(p->n_type);
  691+        sp->sap = NULL;
695692         sp->slevel = 1; /* fake numeric label */
 696693         sp->soffset = getlab();
 697694         sp->sflags = 0;
     
 !
778775         p = buildtree(AND, p, xbcon(-16, NULL, LONG));
 779776 
 780777         /* sub the size from sp */
<>781 -        sp = block(REG, NIL, NIL, p->n_type, 0, MKAP(LONG));
  778+        sp = block(REG, NIL, NIL, p->n_type, 0, 0);
782779         sp->n_lval = 0;
 783780         sp->n_rval = STKREG;
 784781         ecomp(buildtree(MINUSEQ, sp, p));
     
 !
12331230         tfree(f);
 12341231         tfree(a);
 12351232 
<>1236 -        f = block(REG, NIL, NIL, PTR+VOID, 0, MKAP(VOID));
  1233+        f = block(REG, NIL, NIL, PTR+VOID, 0, 0);
12371234         regno(f) = FPREG;
 12381235 
 12391236         while (nframes--)
<>1240 -                f = block(UMUL, f, NIL, PTR+VOID, 0, MKAP(VOID));
  1237+                f = block(UMUL, f, NIL, PTR+VOID, 0, 0);
12411238 
<>1242 -        f = block(PLUS, f, bcon(4), INCREF(PTR+VOID), 0, MKAP(VOID));
  1239+        f = block(PLUS, f, bcon(4), INCREF(PTR+VOID), 0, 0);
12431240         f = buildtree(UMUL, f, NIL);
 12441241 
 12451242         return f;
     
 !
12611258         tfree(f);
 12621259         tfree(a);
 12631260 
<>1264 -        f = block(REG, NIL, NIL, PTR+VOID, 0, MKAP(VOID));
  1261+        f = block(REG, NIL, NIL, PTR+VOID, 0, 0);
12651262         regno(f) = FPREG;
 12661263 
 12671264         while (nframes--)
<>1268 -                f = block(UMUL, f, NIL, PTR+VOID, 0, MKAP(VOID));
  1265+                f = block(UMUL, f, NIL, PTR+VOID, 0, 0);
<_12691266 
 12701267         return f;
 12711268 bad:
FishEye: Open Source License registered to PCC.
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-12-20 16:06 +0100