Quick Search:

Mode

Context

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

Other Diffs

Ignore

Blank Lines Whitespace: Expand:

Diff

1.16
 
1.17
 
MAIN:ragge:20100919140135
 
code.c
_>5959                 return; /* text is written in prologue() */
 6060         if (s != lastloc)
 6161                 printf("        .%s\n", loctbl[s]);
<>62 -        printf("        .p2align %d\n", ispow2(talign(t, sp->ssue)));
  62+        printf("        .p2align %d\n", ispow2(talign(t, sp->sap)));
6363         n = sp->soname ? sp->soname : sp->sname;
 6464         if (sp->sclass == EXTDEF)
 6565                 printf("        .globl %s\n", n);
 6666         if (sp->slevel == 0) {
 6767 #ifdef USE_GAS
 6868                 printf("\t.type %s,@object\n", n);
 6969                 printf("\t.size %s," CONFMT "\n", n,
<>70 -                    tsize(sp->stype, sp->sdf, sp->ssue));
  70+                    tsize(sp->stype, sp->sdf, sp->sap));
7171 #endif
 7272                 printf("%s:\n", n);
 7373         } else
     
 !
102102                 printf("\t.globl %s\n", c);
 103103 #ifdef USE_GAS
 104104         printf("\t.type %s,@object\n", c);
<>105 -        printf("\t.size %s," CONFMT "\n", c, tsize(p->stype, p->sdf, p->ssue));
  105+        printf("\t.size %s," CONFMT "\n", c, tsize(p->stype, p->sdf, p->sap));
106106 #endif
 107107         printf("%s:\n", c);
 108108 }
     
 !
126126 
 127127         ty = cftnsp->stype - FTN;
 128128 
<>129 -        q = block(REG, NIL, NIL, INCREF(ty), 0, cftnsp->ssue);
  129+        q = block(REG, NIL, NIL, INCREF(ty), 0, cftnsp->sap);
130130         q->n_rval = V0;
<>131 -        p = tempnode(0, INCREF(ty), 0, cftnsp->ssue);
  131+        p = tempnode(0, INCREF(ty), 0, cftnsp->sap);
132132         tempnr = regno(p);
 133133         p = buildtree(ASSIGN, p, q);
 134134         ecomp(p);
 135135 
<>136 -        q = tempnode(tempnr, INCREF(ty), 0, cftnsp->ssue);
  136+        q = tempnode(tempnr, INCREF(ty), 0, cftnsp->sap);
137137         q = buildtree(UMUL, q, NIL);
 138138 
<>139 -        p = tempnode(rvnr, INCREF(ty), 0, cftnsp->ssue);
  139+        p = tempnode(rvnr, INCREF(ty), 0, cftnsp->sap);
140140         p = buildtree(UMUL, p, NIL);
 141141 
 142142         p = buildtree(ASSIGN, p, q);
 143143         ecomp(p);
 144144 
<>145 -        q = tempnode(rvnr, INCREF(ty), 0, cftnsp->ssue);
 146 -        p = block(REG, NIL, NIL, INCREF(ty), 0, cftnsp->ssue);
  145+        q = tempnode(rvnr, INCREF(ty), 0, cftnsp->sap);
  146+        p = block(REG, NIL, NIL, INCREF(ty), 0, cftnsp->sap);
147147         p->n_rval = V0;
 148148         p = buildtree(ASSIGN, p, q);
 149149         ecomp(p);
     
 !
155155 putintemp(struct symtab *sym)
 156156 {
 157157         NODE *p;
<>158 -        p = tempnode(0, sym->stype, sym->sdf, sym->ssue);
  158+        p = tempnode(0, sym->stype, sym->sdf, sym->sap);
159159         p = buildtree(ASSIGN, p, nametree(sym));
 160160         sym->soffset = regno(p->n_left);
 161161         sym->sflags |= STNODE;
     
 !
169169 {
 170170         NODE *p, *q;
 171171 
<>172 -        p = tempnode(0, PTR+STRTY, 0, cftnsp->ssue);
  172+        p = tempnode(0, PTR+STRTY, 0, cftnsp->sap);
173173         rvnr = regno(p);
<>174 -        q = block(REG, NIL, NIL, PTR+STRTY, 0, cftnsp->ssue);
  174+        q = block(REG, NIL, NIL, PTR+STRTY, 0, cftnsp->sap);
175175         q->n_rval = A0;
 176176         p = buildtree(ASSIGN, p, q);
 177177         ecomp(p);
     
 !
192192         int i;
 193193 
 194194         navail = nargregs - (reg - A0);
<>195 -        sz = tsize(sym->stype, sym->sdf, sym->ssue) / SZINT;
  195+        sz = tsize(sym->stype, sym->sdf, sym->sap) / SZINT;
196196         off = ARGINIT/SZINT + (reg - A0);
 197197         num = sz > navail ? navail : sz;
 198198         for (i = 0; i < num; i++) {
<>199 -                q = block(REG, NIL, NIL, INT, 0, MKSUE(INT));
  199+                q = block(REG, NIL, NIL, INT, 0, MKAP(INT));
200200                 q->n_rval = reg++;
<>201 -                p = block(REG, NIL, NIL, INT, 0, MKSUE(INT));
  201+                p = block(REG, NIL, NIL, INT, 0, MKAP(INT));
202202                 p->n_rval = FP;
<>203 -                p = block(PLUS, p, bcon(4*off++), INT, 0, MKSUE(INT));
 204 -                p = block(UMUL, p, NIL, INT, 0, MKSUE(INT));
  203+                p = block(PLUS, p, bcon(4*off++), INT, 0, MKAP(INT));
  204+                p = block(UMUL, p, NIL, INT, 0, MKAP(INT));
205205                 p = buildtree(ASSIGN, p, q);
 206206                 ecomp(p);
 207207         }
     
 !
234234                 return;
 235235         }
 236236 
<>237 -        q = block(REG, NIL, NIL, sym->stype, sym->sdf, sym->ssue);
  237+        q = block(REG, NIL, NIL, sym->stype, sym->sdf, sym->sap);
238238         q->n_rval = A0A1 + (reg - A0);
 239239         if (dotemps) {
<>240 -                p = tempnode(0, sym->stype, sym->sdf, sym->ssue);
  240+                p = tempnode(0, sym->stype, sym->sdf, sym->sap);
241241                 sym->soffset = regno(p);
 242242                 sym->sflags |= STNODE;
 243243         } else {
     
 !
255255 {
 256256         NODE *p, *q;
 257257 
<>258 -        q = block(REG, NIL, NIL, sym->stype, sym->sdf, sym->ssue);
  258+        q = block(REG, NIL, NIL, sym->stype, sym->sdf, sym->sap);
259259         q->n_rval = (*regp)++;
 260260         if (dotemps) {
<>261 -                p = tempnode(0, sym->stype, sym->sdf, sym->ssue);
  261+                p = tempnode(0, sym->stype, sym->sdf, sym->sap);
262262                 sym->soffset = regno(p);
 263263                 sym->sflags |= STNODE;
 264264         } else {
     
 !
297297                 return;
 298298         }
 299299 
<>300 -        t = tempnode(0, LONGLONG, 0, MKSUE(LONGLONG));
  300+        t = tempnode(0, LONGLONG, 0, MKAP(LONGLONG));
301301         tmpnr = regno(t);
<>302 -        q = block(REG, NIL, NIL, LONGLONG, 0, MKSUE(LONGLONG));
  302+        q = block(REG, NIL, NIL, LONGLONG, 0, MKAP(LONGLONG));
303303         q->n_rval = A0A1 + (reg - A0);
 304304         p = buildtree(ASSIGN, t, q);
 305305         ecomp(p);
     
 !
308308                 sym->soffset = tmpnr;
 309309                 sym->sflags |= STNODE;
 310310         } else {
<>311 -                q = tempnode(tmpnr, sym->stype, sym->sdf, sym->ssue);
  311+                q = tempnode(tmpnr, sym->stype, sym->sdf, sym->sap);
312312                 p = nametree(sym);
 313313                 p = buildtree(ASSIGN, p, q);
 314314                 ecomp(p);
     
 !
327327         NODE *p, *q, *t;
 328328         int tmpnr;
 329329 
<>330 -        t = tempnode(0, INT, 0, MKSUE(INT));
  330+        t = tempnode(0, INT, 0, MKAP(INT));
331331         tmpnr = regno(t);
<>332 -        q = block(REG, NIL, NIL, INT, 0, MKSUE(INT));
  332+        q = block(REG, NIL, NIL, INT, 0, MKAP(INT));
333333         q->n_rval = (*regp)++;
 334334         p = buildtree(ASSIGN, t, q);
 335335         ecomp(p);
     
 !
338338                 sym->soffset = tmpnr;
 339339                 sym->sflags |= STNODE;
 340340         } else {
<>341 -                q = tempnode(tmpnr, sym->stype, sym->sdf, sym->ssue);
  341+                q = tempnode(tmpnr, sym->stype, sym->sdf, sym->sap);
342342                 p = nametree(sym);
 343343                 p = buildtree(ASSIGN, p, q);
 344344                 ecomp(p);
     
 !
403403         while (reg <= lastreg) {
 404404                 NODE *p, *q;
 405405                 int off = ARGINIT/SZINT + (reg - A0);
<>406 -                q = block(REG, NIL, NIL, INT, 0, MKSUE(INT));
  406+                q = block(REG, NIL, NIL, INT, 0, MKAP(INT));
407407                 q->n_rval = reg++;
<>408 -                p = block(REG, NIL, NIL, INT, 0, MKSUE(INT));
  408+                p = block(REG, NIL, NIL, INT, 0, MKAP(INT));
409409                 p->n_rval = FP;
<>410 -                p = block(PLUS, p, bcon(4*off), INT, 0, MKSUE(INT));
 411 -                p = block(UMUL, p, NIL, INT, 0, MKSUE(INT));
  410+                p = block(PLUS, p, bcon(4*off), INT, 0, MKAP(INT));
  411+                p = block(UMUL, p, NIL, INT, 0, MKAP(INT));
412412                 p = buildtree(ASSIGN, p, q);
 413413                 ecomp(p);
 414414         }
     
 !
524524         int i;
 525525 
 526526         navail = nargregs - (reg - A0);
<>527 -        sz = tsize(p->n_type, p->n_df, p->n_sue) / SZINT;
  527+        sz = tsize(p->n_type, p->n_df, p->n_ap) / SZINT;
528528         num = sz > navail ? navail : sz;
 529529 
 530530         l = p->n_left;
 531531         nfree(p);
 532532         ty = l->n_type;
<>533 -        t = tempnode(0, l->n_type, l->n_df, l->n_sue);
  533+        t = tempnode(0, l->n_type, l->n_df, l->n_ap);
534534         tmpnr = regno(t);
 535535         l = buildtree(ASSIGN, t, l);
 536536 
     
 !
541541 
 542542         /* copy structure into registers */
 543543         for (i = 0; i < num; i++) {
<>544 -                t = tempnode(tmpnr, ty, 0, MKSUE(PTR+ty));
 545 -                t = block(SCONV, t, NIL, PTR+INT, 0, MKSUE(PTR+INT));
 546 -                t = block(PLUS, t, bcon(4*i), PTR+INT, 0, MKSUE(PTR+INT));
  544+                t = tempnode(tmpnr, ty, 0, MKAP(PTR+ty));
  545+                t = block(SCONV, t, NIL, PTR+INT, 0, MKAP(PTR+INT));
  546+                t = block(PLUS, t, bcon(4*i), PTR+INT, 0, MKAP(PTR+INT));
547547                 t = buildtree(UMUL, t, NIL);
 548548 
<>549 -                r = block(REG, NIL, NIL, INT, 0, MKSUE(INT));
  549+                r = block(REG, NIL, NIL, INT, 0, MKAP(INT));
550550                 r->n_rval = reg++;
 551551 
 552552                 r = buildtree(ASSIGN, r, t);
 553553                 if (q == NULL)
 554554                         q = r;
 555555                 else
<>556 -                        q = block(CM, q, r, INT, 0, MKSUE(INT));
  556+                        q = block(CM, q, r, INT, 0, MKAP(INT));
557557         }
 558558         off = ARGINIT/SZINT + nargregs;
 559559         for (i = num; i < sz; i++) {
<>560 -                t = tempnode(tmpnr, ty, 0, MKSUE(PTR+ty));
 561 -                t = block(SCONV, t, NIL, PTR+INT, 0, MKSUE(PTR+INT));
 562 -                t = block(PLUS, t, bcon(4*i), PTR+INT, 0, MKSUE(PTR+INT));
  560+                t = tempnode(tmpnr, ty, 0, MKAP(PTR+ty));
  561+                t = block(SCONV, t, NIL, PTR+INT, 0, MKAP(PTR+INT));
  562+                t = block(PLUS, t, bcon(4*i), PTR+INT, 0, MKAP(PTR+INT));
563563                 t = buildtree(UMUL, t, NIL);
 564564 
<>565 -                r = block(REG, NIL, NIL, INT, 0, MKSUE(INT));
  565+                r = block(REG, NIL, NIL, INT, 0, MKAP(INT));
566566                 r->n_rval = FP;
<>567 -                r = block(PLUS, r, bcon(4*off++), INT, 0, MKSUE(INT));
 568 -                r = block(UMUL, r, NIL, INT, 0, MKSUE(INT));
  567+                r = block(PLUS, r, bcon(4*off++), INT, 0, MKAP(INT));
  568+                r = block(UMUL, r, NIL, INT, 0, MKAP(INT));
569569 
 570570                 r = buildtree(ASSIGN, r, t);
 571571                 if (q == NULL)
 572572                         q = r;
 573573                 else
<>574 -                        q = block(CM, q, r, INT, 0, MKSUE(INT));
  574+                        q = block(CM, q, r, INT, 0, MKAP(INT));
575575         }
 576576 
 577577         if (parent->n_op == CM) {
 578578                 parent->n_left = q;
 579579                 q = l;
 580580         } else {
<>581 -                q = block(CM, q, l, INT, 0, MKSUE(INT));
  581+                q = block(CM, q, l, INT, 0, MKAP(INT));
582582         }
 583583 
 584584         *regp = reg;
     
 !
601601         lastarg = A0 + nargregs - 1;
 602602         if (reg > lastarg) {
 603603                 *regp = reg;
<>604 -                return block(FUNARG, p, NIL, p->n_type, p->n_df, p->n_sue);
  604+                return block(FUNARG, p, NIL, p->n_type, p->n_df, p->n_ap);
605605         }
 606606 
<>607 -        q = block(REG, NIL, NIL, p->n_type, p->n_df, p->n_sue);
  607+        q = block(REG, NIL, NIL, p->n_type, p->n_df, p->n_ap);
608608         q->n_rval = A0A1 + (reg - A0);
 609609         q = buildtree(ASSIGN, q, p);
 610610 
     
 !
620620         int reg = *regp;
 621621         NODE *q;
 622622 
<>623 -        q = block(REG, NIL, NIL, p->n_type, p->n_df, p->n_sue);
  623+        q = block(REG, NIL, NIL, p->n_type, p->n_df, p->n_ap);
624624         q->n_rval = reg++;
 625625         q = buildtree(ASSIGN, q, p);
 626626 
     
 !
648648         reg = *regp;
 649649 
 650650         if (reg > lastreg && r->n_op != STARG)
<>651 -                *rp = block(FUNARG, r, NIL, r->n_type, r->n_df, r->n_sue);
  651+                *rp = block(FUNARG, r, NIL, r->n_type, r->n_df, r->n_ap);
652652         else if (r->n_op == STARG) {
 653653                 *rp = movearg_struct(r, p, regp);
 654654         } else if (DEUNSIGN(r->n_type) == LONGLONG) {
 655655                 *rp = movearg_64bit(r, regp);
 656656         } else if (r->n_type == DOUBLE || r->n_type == LDOUBLE) {
 657657                 /* XXX bounce in and out of temporary to change to longlong */
<>658 -                NODE *t1 = tempnode(0, LONGLONG, 0, MKSUE(LONGLONG));
  658+                NODE *t1 = tempnode(0, LONGLONG, 0, MKAP(LONGLONG));
659659                 int tmpnr = regno(t1);
<>660 -                NODE *t2 = tempnode(tmpnr, r->n_type, r->n_df, r->n_sue);
  660+                NODE *t2 = tempnode(tmpnr, r->n_type, r->n_df, r->n_ap);
661661                 t1movearg_64bit(t1, regp);
<>662 -                r = block(ASSIGN, t2, r, r->n_type, r->n_df, r->n_sue);
  662+                r = block(ASSIGN, t2, r, r->n_type, r->n_df, r->n_ap);
663663                 if (p->n_op == CM) {
 664664                         p->n_left = buildtree(CM, p->n_left, t1);
 665665                         p->n_right = r;
     
 !
668668                 }
 669669         } else if (r->n_type == FLOAT) {
 670670                 /* XXX bounce in and out of temporary to change to int */
<>671 -                NODE *t1 = tempnode(0, INT, 0, MKSUE(INT));
  671+                NODE *t1 = tempnode(0, INT, 0, MKAP(INT));
672672                 int tmpnr = regno(t1);
<>673 -                NODE *t2 = tempnode(tmpnr, r->n_type, r->n_df, r->n_sue);
  673+                NODE *t2 = tempnode(tmpnr, r->n_type, r->n_df, r->n_ap);
674674                 t1movearg_32bit(t1, regp);
<>675 -                r = block(ASSIGN, t2, r, r->n_type, r->n_df, r->n_sue);
  675+                r = block(ASSIGN, t2, r, r->n_type, r->n_df, r->n_ap);
676676                 if (p->n_op == CM) {
 677677                         p->n_left = buildtree(CM, p->n_left, t1);
 678678                         p->n_right = r;
     
 !
707707         ty = DECREF(l->n_type);
 708708         if (ty == STRTY+FTN || ty == UNIONTY+FTN) {
 709709                 ty = DECREF(l->n_type) - FTN;
<>710 -                q = tempnode(0, ty, l->n_df, l->n_sue);
  710+                q = tempnode(0, ty, l->n_df, l->n_ap);
711711                 q = buildtree(ADDROF, q, NIL);
 712712                 if (r->n_op != CM) {
 713713                         p->n_right = block(CM, q, r, INCREF(ty),
<>714 -                            l->n_df, l->n_sue);
  714+                            l->n_df, l->n_ap);
715715                 } else {
 716716                         for (t = r; t->n_left->n_op == CM; t = t->n_left)
 717717                                 ;
 718718                         t->n_left = block(CM, q, t->n_left, INCREF(ty),
<>719 -                            l->n_df, l->n_sue);
  719+                            l->n_df, l->n_ap);
<_720720                 }
 721721         }
 722722 
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-27 06:10 +0100