lint changes from donn@utah-cs.

SCCS-vsn: old/pcc/c2.vax/c2.h 4.9
SCCS-vsn: old/pcc/c2.vax/c20.c 4.9
SCCS-vsn: old/pcc/c2.vax/c21.c 4.15
SCCS-vsn: old/pcc/c2.vax/c22.c 4.3

diff --git a/usr/src/old/pcc/c2.vax/c2.h b/usr/src/old/pcc/c2.vax/c2.h
index 42d72dd..134f5bd 100644 (file)
--- a/usr/src/old/pcc/c2.vax/c2.h
+++ b/usr/src/old/pcc/c2.vax/c2.h
@@ -1,4 +1,4 @@
-/*     c2.h    4.8     85/01/16        */
+/*     c2.h    4.9     85/03/19        */

 
 /*
  * Header for object code improver
 
 /*
  * Header for object code improver


@@ -126,8 +126,13 @@ struct optab {
 } optab[];
 
 struct node {
 } optab[];
 
 struct node {

-       char    op;
-       char    subop;
+       union {
+               struct {
+                       char op_op;
+                       char op_subop;
+               } un_op;
+               short   un_combop;
+       } op_un;

        short   refc;
        struct  node    *forw;
        struct  node    *back;
        short   refc;
        struct  node    *forw;
        struct  node    *back;


@@ -138,9 +143,9 @@ struct node {
        short   seq;
 };
 
        short   seq;
 };
 

-struct {
-       short   combop;
-};
+#define op op_un.un_op.op_op
+#define subop op_un.un_op.op_subop
+#define combop op_un.un_combop

 
 char   line[512];
 struct node    first;
 
 char   line[512];
 struct node    first;


@@ -164,7 +169,7 @@ int nbj;
 int nfield;
 
 int    nchange;
 int nfield;
 
 int    nchange;

-int    isn;
+long   isn;

 int    debug;
 char   *lasta;
 char   *lastr;
 int    debug;
 char   *lasta;
 char   *lastr;


@@ -182,10 +187,16 @@ char      ccloc[C2_ASIZE];
 #define RT4 15
 #define        LABHS   127
 
 #define RT4 15
 #define        LABHS   127
 

-struct { char lbyte; };
-

 char *copy();
 long getnum();
 struct node *codemove();
 struct node *insertl();
 struct node *nonlab();
 char *copy();
 long getnum();
 struct node *codemove();
 struct node *insertl();
 struct node *nonlab();

+struct node *alloc();
+
+#ifdef notdef
+#define decref(p) \
+       ((p) && --(p)->refc <= 0 ? nrlab++, delnode(p) : 0)
+#define delnode(p) \
+       ((p)->back->forw = (p)->forw, (p)->forw->back = (p)->back)
+#endif notdef

diff --git a/usr/src/old/pcc/c2.vax/c20.c b/usr/src/old/pcc/c2.vax/c20.c
index eef1a77..a0ac96b 100644 (file)
--- a/usr/src/old/pcc/c2.vax/c20.c
+++ b/usr/src/old/pcc/c2.vax/c20.c
@@ -1,5 +1,5 @@
 #ifndef lint
 #ifndef lint

-static char sccsid[] = "@(#)c20.c      4.8 (Berkeley) %G%";
+static char sccsid[] = "@(#)c20.c      4.9 (Berkeley) %G%";

 #endif
 
 /*
 #endif
 
 /*


@@ -9,8 +9,10 @@ static char sccsid[] = "@(#)c20.c      4.8 (Berkeley) %G%";
 #include "c2.h"
 #include <stdio.h>
 #include <ctype.h>
 #include "c2.h"
 #include <stdio.h>
 #include <ctype.h>

+#include <sys/types.h>

 
 char _sibuf[BUFSIZ], _sobuf[BUFSIZ];
 
 char _sibuf[BUFSIZ], _sobuf[BUFSIZ];

+caddr_t sbrk();

 int ioflag;
 int fflag;
 long   isn     = 2000000;
 int ioflag;
 int fflag;
 long   isn     = 2000000;


@@ -19,23 +21,25 @@ struct optab *getline();
 long lgensym[10] =
   {100000L,200000L,300000L,400000L,500000L,600000L,700000L,800000L,900000L,1000000L};
 
 long lgensym[10] =
   {100000L,200000L,300000L,400000L,500000L,600000L,700000L,800000L,900000L,1000000L};
 

+#define ALLOCSIZE      4096
+

 struct node *
 alloc(an)
 {
        register int n;
 struct node *
 alloc(an)
 {
        register int n;

-       register char *p;
+       register struct node *p;

 
        n = an;
        n+=sizeof(char *)-1;
        n &= ~(sizeof(char *)-1);
        if (lasta+n >= lastr) {
 
        n = an;
        n+=sizeof(char *)-1;
        n &= ~(sizeof(char *)-1);
        if (lasta+n >= lastr) {

-               if (sbrk(2000) == -1) {
+               if ((int) sbrk(ALLOCSIZE) == -1) {

                        fprintf(stderr, "Optimizer: out of space\n");
                        exit(1);
                }
                        fprintf(stderr, "Optimizer: out of space\n");
                        exit(1);
                }

-               lastr += 2000;
+               lastr += ALLOCSIZE;

        }
        }

-       p = lasta;
+       p = (struct node *) lasta;

        lasta += n;
        return(p);
 }
        lasta += n;
        return(p);
 }


@@ -67,9 +71,9 @@ char **argv;
        }
        setbuf(stdin, _sibuf);
        setbuf(stdout, _sobuf);
        }
        setbuf(stdin, _sibuf);
        setbuf(stdout, _sobuf);

-       lasta = lastr = sbrk(2);
+       lasta = lastr = (char *) sbrk(2);

        opsetup();
        opsetup();

-       lasta = firstr = lastr = alloc(0);
+       lasta = firstr = lastr = (char *) alloc(0);

        maxiter = 0;
        do {
                isend = input();
        maxiter = 0;
        do {
                isend = input();


@@ -119,15 +123,15 @@ char **argv;
 input()
 {
        register struct node *p, *lastp;
 input()
 {
        register struct node *p, *lastp;

-       struct optab *op; register char *cp1;
+       struct optab *opp; register char *cp1;

        static struct optab F77JSW = {".long", T(JSW,1)};
 
        lastp = &first;
        for (;;) {
          top:
        static struct optab F77JSW = {".long", T(JSW,1)};
 
        lastp = &first;
        for (;;) {
          top:

-               op = getline();
-               if (debug && op==0) fprintf(stderr,"? %s\n",line);
-               switch (op->opcode&0377) {
+               opp = getline();
+               if (debug && opp==0) fprintf(stderr,"? %s\n",line);
+               switch (opp->opcode&0377) {

        
                case LABEL:
                        p = alloc(sizeof first);
        
                case LABEL:
                        p = alloc(sizeof first);


@@ -145,15 +149,15 @@ input()
        
                case LGEN:
                        if (*curlp!='L' && !locuse(curlp)) goto std;
        
                case LGEN:
                        if (*curlp!='L' && !locuse(curlp)) goto std;

-                       op= &F77JSW;
+                       opp= &F77JSW;

                case JBR:
                case JBR:

-                       if (op->opcode==T(JBR,RET) || op->opcode==T(JBR,RSB)) goto std;
+                       if (opp->opcode==T(JBR,RET) || opp->opcode==T(JBR,RSB)) goto std;

                case CBR:
                case JMP:
                case JSW:
                case SOBGEQ: case SOBGTR: case AOBLEQ: case AOBLSS: case ACB:
                        p = alloc(sizeof first);
                case CBR:
                case JMP:
                case JSW:
                case SOBGEQ: case SOBGTR: case AOBLEQ: case AOBLSS: case ACB:
                        p = alloc(sizeof first);

-                       p->combop = op->opcode; p->code=0; cp1=curlp;
+                       p->combop = opp->opcode; p->code=0; cp1=curlp;

                        if ((!isdigit(*cp1) || 0==(p->labno=locuse(cp1))) &&
                          (*cp1!='L' || 0==(p->labno = getnum(cp1+1)))) {/* jbs, etc.? */
                                while (*cp1++); while (*--cp1!=',' && cp1!=curlp);
                        if ((!isdigit(*cp1) || 0==(p->labno=locuse(cp1))) &&
                          (*cp1!='L' || 0==(p->labno = getnum(cp1+1)))) {/* jbs, etc.? */
                                while (*cp1++); while (*--cp1!=',' && cp1!=curlp);


@@ -169,7 +173,7 @@ input()
 
                case MOVA:
                        p=alloc(sizeof first);
 
                case MOVA:
                        p=alloc(sizeof first);

-                       p->combop=op->opcode; p->code=0; cp1=curlp+1;
+                       p->combop=opp->opcode; p->code=0; cp1=curlp+1;

                        if (cp1[-1]=='L' || isdigit(cp1[-1])) {
                                while (*cp1++!=','); *--cp1=0;
                                if (0!=(p->labno=locuse(curlp)) ||
                        if (cp1[-1]=='L' || isdigit(cp1[-1])) {
                                while (*cp1++!=','); *--cp1=0;
                                if (0!=(p->labno=locuse(curlp)) ||


@@ -186,9 +190,9 @@ input()
                case BSS:
                case DATA:
                        for (;;) {
                case BSS:
                case DATA:
                        for (;;) {

-                               printf("%s%c",line,(op->opcode==LABEL ? ':' : '\n'));
-                               if (op->opcode==TEXT) goto top;
-                               if (END==(op=getline())->opcode) {/* dangling .data is bad for you */
+                               printf("%s%c",line,(opp->opcode==LABEL ? ':' : '\n'));
+                               if (opp->opcode==TEXT) goto top;
+                               if (END==(opp=getline())->opcode) {/* dangling .data is bad for you */

                                        printf(".text\n");
                                        break;
                                }
                                        printf(".text\n");
                                        break;
                                }


@@ -197,7 +201,7 @@ input()
                std:
                default:
                        p = alloc(sizeof first);
                std:
                default:
                        p = alloc(sizeof first);

-                       p->combop = op->opcode;
+                       p->combop = opp->opcode;

                        p->labno = 0;
                        p->code = copy(curlp);
                        break;
                        p->labno = 0;
                        p->code = copy(curlp);
                        break;


@@ -205,16 +209,22 @@ input()
                }
                p->forw = 0;
                p->back = lastp;
                }
                p->forw = 0;
                p->back = lastp;

-               p->pop = op;
+               p->pop = opp;

                lastp->forw = p;
                lastp = p;
                p->ref = 0;
                if (p->op==CASE) {
                        char *lp; int ncase;
                        lp=curlp; while (*lp++); while (*--lp!='$'); ncase=getnum(lp+1);
                lastp->forw = p;
                lastp = p;
                p->ref = 0;
                if (p->op==CASE) {
                        char *lp; int ncase;
                        lp=curlp; while (*lp++); while (*--lp!='$'); ncase=getnum(lp+1);

-                       if (LABEL!=(getline())->opcode) abort(-2);
+                       if (LABEL!=(getline())->opcode) {
+                               fprintf(stderr, "c2: garbled 'case' instruction\n");
+                               exit(-2);
+                       }

                        do {
                        do {

-                               if (WGEN!=(getline())->opcode) abort(-3);
+                               if (WGEN!=(getline())->opcode) {
+                                       fprintf(stderr, "c2: garbled 'case' instruction\n");
+                                       exit(-3);
+                               }

                                p = alloc(sizeof first); p->combop = JSW; p->code = 0;
                                lp=curlp; while(*lp++!='-'); *--lp=0; p->labno=getnum(curlp+1);
                                if (isn<=p->labno) isn=1+p->labno;
                                p = alloc(sizeof first); p->combop = JSW; p->code = 0;
                                lp=curlp; while(*lp++!='-'); *--lp=0; p->labno=getnum(curlp+1);
                                if (isn<=p->labno) isn=1+p->labno;


@@ -222,9 +232,9 @@ input()
                                p->ref = 0; p->pop=0;
                        } while (--ncase>=0);
                }
                                p->ref = 0; p->pop=0;
                        } while (--ncase>=0);
                }

-               if (op->opcode==EROU)
+               if (opp->opcode==EROU)

                        return(1);
                        return(1);

-               if (op->opcode==END)
+               if (opp->opcode==END)

                        return(0);
        }
 }
                        return(0);
        }
 }


@@ -273,8 +283,6 @@ register char *p;
 locuse(p)
 register char *p;
 {
 locuse(p)
 register char *p;
 {

-       register c; int neg; register long n;
-

        if (!isdigit(p[0]) || p[1] != 'f' && p[1] != 'b' || p[2]) return(0);
        return (lgensym[p[0] - '0'] - (p[1] == 'b'));
 }
        if (!isdigit(p[0]) || p[1] != 'f' && p[1] != 'b' || p[2]) return(0);
        return (lgensym[p[0] - '0'] - (p[1] == 'b'));
 }


@@ -382,7 +390,7 @@ char *ap;
                while (*p++)
                        n++;
        }
                while (*p++)
                        n++;
        }

-       onp = np = alloc(n);
+       onp = np = (char *) alloc(n);

        p = ap;
        while (*np++ = *p++);
        if (na>1) {
        p = ap;
        while (*np++ = *p++);
        if (na>1) {


@@ -401,7 +409,7 @@ opsetup()
        register struct optab *optp, **ophp;
        register int i,t;
 
        register struct optab *optp, **ophp;
        register int i,t;
 

-       for(i=NREG+5;--i>=0;) regs[i]=alloc(C2_ASIZE);
+       for(i=NREG+5;--i>=0;) regs[i]=(char *) alloc(C2_ASIZE);

        for (optp = optab; optp->opstring[0]; optp++) {
                t=7; i=0; while (--t>=0) i+= i+optp->opstring[t];
                ophp = &ophash[i % OPHS];
        for (optp = optab; optp->opstring[0]; optp++) {
                t=7; i=0; while (--t>=0) i+= i+optp->opstring[t];
                ophp = &ophash[i % OPHS];


@@ -438,7 +446,7 @@ oplook()
 
 refcount()
 {
 
 refcount()
 {

-       register struct node *p, *lp;
+       register struct node *p, *lp, *tp;

        struct node *labhash[LABHS];
        register struct node **hp;
 
        struct node *labhash[LABHS];
        register struct node **hp;
 


@@ -461,10 +469,10 @@ refcount()
                                        break;
                        }
                        if (lp) {
                                        break;
                        }
                        if (lp) {

-                               hp = nonlab(lp)->back;
-                               if (hp!=lp) {
-                                       p->labno = hp->labno;
-                                       lp = hp;
+                               tp = nonlab(lp)->back;
+                               if (tp!=lp) {
+                                       p->labno = tp->labno;
+                                       lp = tp;

                                }
                                p->ref = lp;
                                lp->refc++;
                                }
                                p->ref = lp;
                                lp->refc++;


@@ -555,42 +563,39 @@ xjump(p1)
 register struct node *p1;
 {
        register struct node *p2, *p3;
 register struct node *p1;
 {
        register struct node *p2, *p3;

-       int nxj;

 
 

-       nxj = 0;

        if ((p2 = p1->ref)==0)
        if ((p2 = p1->ref)==0)

-               return(0);
+               return;

        for (;;) {
                while ((p1 = p1->back) && p1->op==LABEL);
                while ((p2 = p2->back) && p2->op==LABEL);
                if (!equop(p1, p2) || p1==p2)
        for (;;) {
                while ((p1 = p1->back) && p1->op==LABEL);
                while ((p2 = p2->back) && p2->op==LABEL);
                if (!equop(p1, p2) || p1==p2)

-                       return(nxj);
+                       return;

                p3 = insertl(p2);
                p1->combop = JBR;
                p1->pop=0;
                p1->ref = p3;
                p1->labno = p3->labno;
                p1->code = 0;
                p3 = insertl(p2);
                p1->combop = JBR;
                p1->pop=0;
                p1->ref = p3;
                p1->labno = p3->labno;
                p1->code = 0;

-               nxj++;

                nxjump++;
                nchange++;
        }
 }
 
 struct node *
                nxjump++;
                nchange++;
        }
 }
 
 struct node *

-insertl(op)
-register struct node *op;
+insertl(np)
+register struct node *np;

 {
        register struct node *lp;
 
 {
        register struct node *lp;
 

-       if (op->op == LABEL) {
-               op->refc++;
-               return(op);
+       if (np->op == LABEL) {
+               np->refc++;
+               return(np);

        }
        }

-       if (op->back->op == LABEL) {
-               op = op->back;
-               op->refc++;
-               return(op);
+       if (np->back->op == LABEL) {
+               np = np->back;
+               np->refc++;
+               return(np);

        }
        lp = alloc(sizeof first);
        lp->combop = LABEL;
        }
        lp = alloc(sizeof first);
        lp->combop = LABEL;


@@ -598,10 +603,10 @@ register struct node *op;
        lp->ref = 0;
        lp->code = 0;
        lp->refc = 1;
        lp->ref = 0;
        lp->code = 0;
        lp->refc = 1;

-       lp->back = op->back;
-       lp->forw = op;
-       op->back->forw = lp;
-       op->back = lp;
+       lp->back = np->back;
+       lp->forw = np;
+       np->back->forw = lp;
+       np->back = lp;

        return(lp);
 }
 
        return(lp);
 }
 

diff --git a/usr/src/old/pcc/c2.vax/c21.c b/usr/src/old/pcc/c2.vax/c21.c
index 4f42f3c..e0042b3 100644 (file)
--- a/usr/src/old/pcc/c2.vax/c21.c
+++ b/usr/src/old/pcc/c2.vax/c21.c
@@ -1,4 +1,6 @@
-static char sccsid[] = "@(#)c21.c 4.14 %G%";
+#ifndef lint
+static char sccsid[] = "@(#)c21.c 4.15 %G%";
+#endif

 /* char C21[] = {"@(#)c21.c 1.83 80/10/16 21:18:22 JFR"}; /* sccs ident */
 
 /*
 /* char C21[] = {"@(#)c21.c 1.83 80/10/16 21:18:22 JFR"}; /* sccs ident */
 
 /*


@@ -34,6 +36,7 @@ char *lastrand; /* last operand of instruction */
 struct node *bflow();
 struct node *bicopt();
 char *findcon();
 struct node *bflow();
 struct node *bicopt();
 char *findcon();

+char *strcpy();

 
 redun3(p,split) register struct node *p; int split; {
 /* check for 3 addr instr which should be 2 addr */
 
 redun3(p,split) register struct node *p; int split; {
 /* check for 3 addr instr which should be 2 addr */


@@ -207,7 +210,7 @@ bmove() {
                if (regs[RT1][0] != '$') goto std;
                if ((shcnt = getnum(&regs[RT1][1])) < 1 || shcnt > 3) goto std;
                if ((shfrom = isreg(regs[RT2])) >= 0)
                if (regs[RT1][0] != '$') goto std;
                if ((shcnt = getnum(&regs[RT1][1])) < 1 || shcnt > 3) goto std;
                if ((shfrom = isreg(regs[RT2])) >= 0)

-                       regfrom = copy(regs[RT2],"]");
+                       regfrom = copy(regs[RT2]);

                if ((shto = isreg(regs[RT3])) >= 0 && shto<NUSE)
                {
                        int     regnum;
                if ((shto = isreg(regs[RT3])) >= 0 && shto<NUSE)
                {
                        int     regnum;


@@ -236,6 +239,8 @@ bmove() {
                                        uses[shto] = NULL; splitrand(pf);
                                        cp2=regs[RT1]; while (*cp2++!='[');
                                        cp1=regfrom; while (*cp2++= *cp1++);
                                        uses[shto] = NULL; splitrand(pf);
                                        cp2=regs[RT1]; while (*cp2++!='[');
                                        cp1=regfrom; while (*cp2++= *cp1++);

+                                       *--cp2 = ']';
+                                       *++cp2 = '\0';

                                        newcode(pf);
                                }
                        }
                                        newcode(pf);
                                }
                        }


@@ -409,13 +414,12 @@ ashadd:
 
 rmove()
 {
 
 rmove()
 {

-       register struct node *p, *lastp;
+       register struct node *p;

        register int r;
        int r1;
 
        clearreg();
        for (p=first.forw; p!=0; p = p->forw) {
        register int r;
        int r1;
 
        clearreg();
        for (p=first.forw; p!=0; p = p->forw) {

-       lastp=p;

        if (debug) {
                if (*conloc) {
                        r1=conval[0];
        if (debug) {
                if (*conloc) {
                        r1=conval[0];


@@ -600,7 +604,7 @@ register struct node *p;
                        if (0<=(r2=isreg(lastrand)) && r2<NUSE) {
                                uses[r2]=uses[r]; uses[r]=0;
                        }
                        if (0<=(r2=isreg(lastrand)) && r2<NUSE) {
                                uses[r2]=uses[r]; uses[r]=0;
                        }

-                       redun3(p,0);
+                       (void) redun3(p,0);

                        newcode(p); redunm++; flow=r;
                } else if (p->op==MOV && p->forw->op!=EXTV && p->forw->op!=EXTZV) {
                        /* superfluous fetch */
                        newcode(p); redunm++; flow=r;
                } else if (p->op==MOV && p->forw->op!=EXTV && p->forw->op!=EXTZV) {
                        /* superfluous fetch */


@@ -626,7 +630,7 @@ register struct node *p;
                                if (0<=(r2=isreg(src)) && r2<NUSE) {
                                        uses[r2]=uses[r]; uses[r]=0;
                                }
                                if (0<=(r2=isreg(src)) && r2<NUSE) {
                                        uses[r2]=uses[r]; uses[r]=0;
                                }

-                               redun3(p,0);
+                               (void) redun3(p,0);

                                newcode(p); redunm++; flow=r;
                        } else splitrand(p);
                }
                                newcode(p); redunm++; flow=r;
                        } else splitrand(p);
                }


@@ -659,14 +663,18 @@ register struct node *p;
                        flow=r;
                }
        }
                        flow=r;
                }
        }

-       if (0<=(r=flow)) {olduse=uses[r]; uses[r]=0; *(short *)(regs[r])=0;}
+       if (0<=(r=flow)) {
+               olduse=uses[r];
+               uses[r]=0;
+               regs[r][0]=regs[r][1]=0;
+       }

                /* these two are here, rather than in bmove(),
                /* because I decided that it was better to go for 3-address code
                /* (save time) rather than fancy jbxx (save 1 byte)
                /* on sequences like  bisl2 $64,r0; movl r0,foo
                */
        if (p->op==BIC) {p=bicopt(p); splitrand(p); lastrand=byondrd(p);}
                /* these two are here, rather than in bmove(),
                /* because I decided that it was better to go for 3-address code
                /* (save time) rather than fancy jbxx (save 1 byte)
                /* on sequences like  bisl2 $64,r0; movl r0,foo
                */
        if (p->op==BIC) {p=bicopt(p); splitrand(p); lastrand=byondrd(p);}

-       if (p->op==BIS) {bixprep(p,JBSS);           lastrand=byondrd(p);}
+       if (p->op==BIS) {(void) bixprep(p,JBSS);    lastrand=byondrd(p);}

        /* now look for 'read' or 'modify' (read & write) uses */
        preg=regs+RT1; 
        while (*(cp1= *preg++)) {
        /* now look for 'read' or 'modify' (read & write) uses */
        preg=regs+RT1; 
        while (*(cp1= *preg++)) {


@@ -767,10 +775,10 @@ bitopt(p) register struct node *p; {
 }
 
 isfield(n) register long n; {/* -1 -> no; else -> position of low bit */
 }
 
 isfield(n) register long n; {/* -1 -> no; else -> position of low bit */

-       register int pos; register long t;
+       register int p; register long t;

        t= ((n-1)|n) +1;
        if (n!=0 && (0==t || 0<=ispow2(t))) {
        t= ((n-1)|n) +1;
        if (n!=0 && (0==t || 0<=ispow2(t))) {

-               pos=0; while(!(n&1)) {n >>= 1; ++pos;} return(pos);
+               p=0; while(!(n&1)) {n >>= 1; ++p;} return(p);

        } else return(-1);
 }
 
        } else return(-1);
 }
 


@@ -801,7 +809,7 @@ bicopt(p) register struct node *p; {
 */
        register char *cp1,*cp2; int r;
        char src[C2_ASIZE];
 */
        register char *cp1,*cp2; int r;
        char src[C2_ASIZE];

-       char lhssiz, subop;
+       char lhssiz, sop;

        if (!bixprep(p,JBCC)) return(p);
        if (f==0) {/* the BIC isolates low order bits */
                siz=pos; pos=0;
        if (!bixprep(p,JBCC)) return(p);
        if (f==0) {/* the BIC isolates low order bits */
                siz=pos; pos=0;


@@ -836,13 +844,13 @@ bicopt(p) register struct node *p; {
                                 * However, if the CVT is from a float or
                                 * double, forget it!
                                 */
                                 * However, if the CVT is from a float or
                                 * double, forget it!
                                 */

-                               subop = p->back->subop&0xF;     /* type of LHS of CVT/MOVZ */
+                               sop = p->back->subop&0xF;       /* type of LHS of CVT/MOVZ */

                                if (equstr(src,cp2) && okio(cp1)
                                if (equstr(src,cp2) && okio(cp1)

-                                 && subop != FFLOAT && subop != DFLOAT
-                                 && subop != GFLOAT && subop != HFLOAT
-                                 && ((!indexa(cp1) && !autoid(cp1)) || lhssiz == subop)
+                                 && sop != FFLOAT && sop != DFLOAT
+                                 && sop != GFLOAT && sop != HFLOAT
+                                 && ((!indexa(cp1) && !autoid(cp1)) || lhssiz == sop)

                                  && 0<=(r=isreg(cp2)) && r<NUSE
                                  && 0<=(r=isreg(cp2)) && r<NUSE

-                                 && bitsize[subop]>=(pos+siz)
+                                 && bitsize[sop]>=(pos+siz)

                                  && bitsize[p->back->subop>>4]>=(pos+siz)) {/* good CVT */
                                        cp1=regs[RT1]; cp2=src; while (*cp2++= *cp1++);
                                        delnode(p->back);
                                  && bitsize[p->back->subop>>4]>=(pos+siz)) {/* good CVT */
                                        cp1=regs[RT1]; cp2=src; while (*cp2++= *cp1++);
                                        delnode(p->back);


@@ -876,13 +884,16 @@ bicopt(p) register struct node *p; {
 jumpsw()
 {
        register struct node *p, *p1;
 jumpsw()
 {
        register struct node *p, *p1;

-       register t;
+       register struct node *tp;
+       long tl;
+       char *tcp;
+       int ti;

        int nj;
 
        int nj;
 

-       t = 0;
+       ti = 0;

        nj = 0;
        for (p=first.forw; p!=0; p = p->forw)
        nj = 0;
        for (p=first.forw; p!=0; p = p->forw)

-               p->seq = ++t;
+               p->seq = ++ti;

        for (p=first.forw; p!=0; p = p1) {
                p1 = p->forw;
                if (p->op == CBR && p1->op==JBR && p->ref && p1->ref
        for (p=first.forw; p!=0; p = p1) {
                p1 = p->forw;
                if (p->op == CBR && p1->op==JBR && p->ref && p1->ref


@@ -891,15 +902,17 @@ jumpsw()
                                continue;
                        p->subop = revbr[p->subop];
                        p->pop=0;
                                continue;
                        p->subop = revbr[p->subop];
                        p->pop=0;

-                       t = p1->ref;
+                       tp = p1->ref;

                        p1->ref = p->ref;
                        p1->ref = p->ref;

-                       p->ref = t;
-                       t = p1->labno;
+                       p->ref = tp;
+                       tl = p1->labno;

                        p1->labno = p->labno;
                        p1->labno = p->labno;

-                       p->labno = t;
+                       p->labno = tl;

 #ifdef COPYCODE
                        if (p->labno == 0) {
 #ifdef COPYCODE
                        if (p->labno == 0) {

-                               t = p1->code; p1->code = p->code; p->code = t;
+                               tcp = p1->code;
+                               p1->code = p->code;
+                               p->code = tcp;

                        }
 #endif
                        nrevbr++;
                        }
 #endif
                        nrevbr++;


@@ -960,11 +973,6 @@ addsob()
        }
 }
 
        }
 }
 

-abs(x)
-{
-       return(x<0? -x: x);
-}
-

 equop(p1, p2)
 register struct node *p1;
 struct node *p2;
 equop(p1, p2)
 register struct node *p1;
 struct node *p2;


@@ -975,6 +983,14 @@ struct node *p2;
                return(0);
        if (p1->op>0 && p1->op<MOV)
                return(0);
                return(0);
        if (p1->op>0 && p1->op<MOV)
                return(0);

+       switch (p1->combop) {
+       case EROU:      case JSW:       case TEXT:      case DATA:
+       case BSS:       case ALIGN:     case WGEN:      case END:
+               /*
+                * Consider all pseudo-ops to be unique.
+                */
+               return(0);
+       }

        if (p1->op==MOVA && p1->labno!=p2->labno) return(0);
        cp1 = p1->code;
        cp2 = p2->code;
        if (p1->op==MOVA && p1->labno!=p2->labno) return(0);
        cp1 = p1->code;
        cp2 = p2->code;


@@ -988,11 +1004,14 @@ struct node *p2;
        return(0);
 }
 
        return(0);
 }
 

+#ifndef delnode

 delnode(p) register struct node *p; {
        p->back->forw = p->forw;
        p->forw->back = p->back;
 }
 delnode(p) register struct node *p; {
        p->back->forw = p->forw;
        p->forw->back = p->back;
 }

+#endif

 
 

+#ifndef decref

 decref(p)
 register struct node *p;
 {
 decref(p)
 register struct node *p;
 {


@@ -1001,6 +1020,7 @@ register struct node *p;
                delnode(p);
        }
 }
                delnode(p);
        }
 }

+#endif

 
 struct node *
 nonlab(ap)
 
 struct node *
 nonlab(ap)


@@ -1020,9 +1040,13 @@ clearuse() {
 }
 
 clearreg() {
 }
 
 clearreg() {

-       register short **i;
-       for (i=regs+NREG; i>regs;) **--i=0;
-       conloc[0] = 0; ccloc[0] = 0;
+       register char **i;
+       for (i=regs; i<regs+NREG; ++i) {
+               **i = 0;
+               *(*i+1) = 0;
+       }
+       conloc[0] = 0;
+       ccloc[0] = 0;

 }
 
 savereg(ai, s, type)
 }
 
 savereg(ai, s, type)


@@ -1045,50 +1069,48 @@ register char *s;
 {
        register int i;
 
 {
        register int i;
 

-       source(s); /* handle addressing side effects */
+       (void) source(s); /* handle addressing side effects */

        if (!natural(s)) {
                /* wild store, everything except constants vanishes */
                for (i=NREG; --i>=0;)
        if (!natural(s)) {
                /* wild store, everything except constants vanishes */
                for (i=NREG; --i>=0;)

-                       if (regs[i][1] != '$') *(short *)(regs[i]) = 0;
+                       if (regs[i][1] != '$')
+                               regs[i][0] = regs[i][1] = 0;

                conloc[0] = 0; ccloc[0] = 0;
                return;
        }
        if ((i = isreg(s)) >= 0) {
                conloc[0] = 0; ccloc[0] = 0;
                return;
        }
        if ((i = isreg(s)) >= 0) {

-               *(short *)(regs[i]) = 0; /* if register destination, that reg is a goner */
+               /* if register destination, that reg is a goner */
+               regs[i][0] = regs[i][1] = 0;

                switch(type & 0xF){
                case DFLOAT:    /* clobber two at once */
                        /*FALLTHROUGH*/
                case GFLOAT:
                switch(type & 0xF){
                case DFLOAT:    /* clobber two at once */
                        /*FALLTHROUGH*/
                case GFLOAT:

-                       *(short *)(regs[i+1]) = 0;
+                       regs[i+1][0] = regs[i+1][1] = 0;

                        break;
                case HFLOAT:    /* clobber four at once */
                        break;
                case HFLOAT:    /* clobber four at once */

-                       *(short *)(regs[i+1]) = 0;
-                       *(short *)(regs[i+2]) = 0;
-                       *(short *)(regs[i+3]) = 0;
+                       regs[i+1][0] = regs[i+1][1] = 0;
+                       regs[i+2][0] = regs[i+2][1] = 0;
+                       regs[i+3][0] = regs[i+3][1] = 0;

                        break;
                }
                switch((type>>4)&0xF){
                case DFLOAT:    /* clobber two at once */
                        /*FALLTHROUGH*/
                case GFLOAT:
                        break;
                }
                switch((type>>4)&0xF){
                case DFLOAT:    /* clobber two at once */
                        /*FALLTHROUGH*/
                case GFLOAT:

-                       *(short *)(regs[i+1]) = 0;
+                       regs[i+1][0] = regs[i+1][1] = 0;

                        break;
                case HFLOAT:    /* clobber four at once */
                        break;
                case HFLOAT:    /* clobber four at once */

-                       *(short *)(regs[i+1]) = 0;
-                       *(short *)(regs[i+2]) = 0;
-                       *(short *)(regs[i+3]) = 0;
+                       regs[i+1][0] = regs[i+1][1] = 0;
+                       regs[i+2][0] = regs[i+2][1] = 0;
+                       regs[i+3][0] = regs[i+3][1] = 0;

                        break;
                }
                        break;
                }

-               /*
-               if (DFLOAT==(type&0xF) || DFLOAT==((type>>4)&0xF))
-                       *(short *)(regs[i+1]) = 0;
-               */

        }
        for (i=NREG; --i>=0;)
                if (regs[i][1]=='*' && equstr(s, regs[i]+2))
        }
        for (i=NREG; --i>=0;)
                if (regs[i][1]=='*' && equstr(s, regs[i]+2))

-                       *(short *)(regs[i]) = 0; /* previous indirection through destination is invalid */
+                       regs[i][0] = regs[i][1] = 0; /* previous indirection through destination is invalid */

        while ((i = findrand(s,0)) >= 0) /* previous values of destination are invalid */
        while ((i = findrand(s,0)) >= 0) /* previous values of destination are invalid */

-               *(short *)(regs[i]) = 0;
+               regs[i][0] = regs[i][1] = 0;

        if (*conloc && equstr(conloc, s))
                conloc[0] = 0;
        setcc(s, type); /* natural destinations set condition codes */
        if (*conloc && equstr(conloc, s))
                conloc[0] = 0;
        setcc(s, type); /* natural destinations set condition codes */


@@ -1151,8 +1173,10 @@ check()
 
        lp = &first;
        for (p=first.forw; p!=0; p = p->forw) {
 
        lp = &first;
        for (p=first.forw; p!=0; p = p->forw) {

-               if (p->back != lp)
-                       abort(-1);
+               if (p->back != lp) {
+                       fprintf(stderr, "c2: failed internal consistency check -- help!\n");
+                       exit(-1);
+               }

                lp = p;
        }
 }
                lp = p;
        }
 }


@@ -1172,8 +1196,12 @@ char *ap;
         || *(p2-2)=='+') {
                while (*p1 && *p1++!='r');
                if (isdigit(*p1++))
         || *(p2-2)=='+') {
                while (*p1 && *p1++!='r');
                if (isdigit(*p1++))

-                       if (isdigit(*p1)) *(short *)(regs[10+*p1-'0'])=0;
-                       else *(short *)(regs[*--p1-'0'])=0;
+                       if (isdigit(*p1))
+                               regs[10+*p1-'0'][0] = regs[10+*p1-'0'][1] = 0;
+                       else {
+                               --p1;
+                               regs[*p1-'0'][0] = regs[*p1-'0'][1] = 0;
+                       }

                return(1);
        }
        return(0);
                return(1);
        }
        return(0);


@@ -1191,7 +1219,7 @@ repladdr(p)
 struct node *p;
 {
        register r;
 struct node *p;
 {
        register r;

-       register char *p1, *p2;
+       register char *p1;

        char **preg; int nrepl;
 
        preg=regs+RT1; nrepl=0;
        char **preg; int nrepl;
 
        preg=regs+RT1; nrepl=0;


@@ -1309,7 +1337,7 @@ findcon(i, type)
        return(p);
 }
 
        return(p);
 }
 

-compare(op, acp1, acp2)
+compare(opc, acp1, acp2)

 char *acp1, *acp2;
 {
        register char *cp1, *cp2;
 char *acp1, *acp2;
 {
        register char *cp1, *cp2;


@@ -1333,30 +1361,28 @@ char *acp1, *acp2;
                if (*cp1++ != *cp2)
                        return(0);
        } while (*cp2++);
                if (*cp1++ != *cp2)
                        return(0);
        } while (*cp2++);

-       cp1 = n1;
-       cp2 = n2;
-       switch(op) {
+       switch(opc) {

 
        case JEQ:
 
        case JEQ:

-               return(cp1 == cp2);
+               return(n1 == n2);

        case JNE:
        case JNE:

-               return(cp1 != cp2);
+               return(n1 != n2);

        case JLE:
        case JLE:

-               return(((int)cp1) <= ((int)cp2));
+               return(n1 <= n2);

        case JGE:
        case JGE:

-               return(((int)cp1) >= ((int)cp2));
+               return(n1 >= n2);

        case JLT:
        case JLT:

-               return(((int)cp1) < ((int)cp2));
+               return(n1 < n2);

        case JGT:
        case JGT:

-               return(((int)cp1) > ((int)cp2));
+               return(n1 > n2);

        case JLO:
        case JLO:

-               return(cp1 < cp2);
+               return((unsigned) n1 < (unsigned) n2);

        case JHI:
        case JHI:

-               return(cp1 > cp2);
+               return((unsigned) n1 > (unsigned) n2);

        case JLOS:
        case JLOS:

-               return(cp1 <= cp2);
+               return((unsigned) n1 <= (unsigned) n2);

        case JHIS:
        case JHIS:

-               return(cp1 >= cp2);
+               return((unsigned) n1 >= (unsigned) n2);

        }
        return(0);
 }
        }
        return(0);
 }

diff --git a/usr/src/old/pcc/c2.vax/c22.c b/usr/src/old/pcc/c2.vax/c22.c
index f56f999..efecb80 100644 (file)
--- a/usr/src/old/pcc/c2.vax/c22.c
+++ b/usr/src/old/pcc/c2.vax/c22.c
@@ -1,6 +1,8 @@
-static char sccsid[] = "@(#)c22.c 4.2 %G%";
+#ifndef lint
+static char sccsid[] = "@(#)c22.c 4.3 %G%";
+#endif
+

 #include "c2.h"
 #include "c2.h"

-/* char c22[] = "@(#)c22.c 4.2 %G%"; */

 #define readonly
 
 readonly char revbr[] = {
 #define readonly
 
 readonly char revbr[] = {