BSD 3 development

[unix-history] / usr / src / cmd / pcc / local2.c

diff --git a/usr/src/cmd/pcc/local2.c b/usr/src/cmd/pcc/local2.c
index bd5de34..ca4e7db 100644 (file)
--- a/usr/src/cmd/pcc/local2.c
+++ b/usr/src/cmd/pcc/local2.c
@@ -1,40 +1,61 @@
 # include "mfile2"
 # include "mfile2"

+# include "ctype.h"

 /* a lot of the machine dependent parts of the second pass */
 
 # define BITMASK(n) ((1L<<n)-1)
 
 /* a lot of the machine dependent parts of the second pass */
 
 # define BITMASK(n) ((1L<<n)-1)
 

+where(c){
+       fprintf( stderr, "%s, line %d: ", filename, lineno );
+       }
+

 lineid( l, fn ) char *fn; {
        /* identify line l and file fn */
 lineid( l, fn ) char *fn; {
        /* identify line l and file fn */

-       printf( "/      line %d, file %s\n", l, fn );
+       printf( "#      line %d, file %s\n", l, fn );

        }
 
        }
 

+

 eobl2(){
        OFFSZ spoff;    /* offset from stack pointer */
 eobl2(){
        OFFSZ spoff;    /* offset from stack pointer */

+#ifdef FORT
+       spoff = maxoff;
+       if( spoff >= AUTOINIT ) spoff -= AUTOINIT;
+       spoff /= SZCHAR;
+       SETOFF(spoff,4);
+       printf( "       .set    .F%d,%ld\n", ftnno, spoff );
+#else
+       extern int ftlab1, ftlab2;

 
        spoff = maxoff;
        if( spoff >= AUTOINIT ) spoff -= AUTOINIT;
        spoff /= SZCHAR;
 
        spoff = maxoff;
        if( spoff >= AUTOINIT ) spoff -= AUTOINIT;
        spoff /= SZCHAR;

-       SETOFF(spoff,2);
-       printf( "       .F%d = %Ld.\n", ftnno, spoff );
-       if( fltused ) {
-               fltused = 0;
-               printf( "       .globl  fltused\n" );
-               }
+       SETOFF(spoff,4);
+       printf( "L%d:\n", ftlab1);
+       if( spoff!=0 )
+               if( spoff < 64 )
+                       printf( "       subl2   $%ld,sp\n", spoff);
+               else
+                       printf( "       movab   -%ld(sp),sp\n", spoff);
+       printf( "       jbr     L%d\n", ftlab2);
+#endif
+       maxargs = -1;

        }
 
        }
 

-struct hoptab { int opmask; char * opstring; } ioptab[]= {
+struct hoptab { int opmask; char * opstring; } ioptab[] = {

 
        ASG PLUS, "add",
        ASG MINUS, "sub",
 
        ASG PLUS, "add",
        ASG MINUS, "sub",

-       ASG OR, "bis",
-       ASG AND,        "bic",
-       ASG ER, "xor",

        ASG MUL, "mul",
        ASG DIV, "div",
        ASG MUL, "mul",
        ASG DIV, "div",

-       ASG MOD, "div",
-       ASG LS, "asl",
-       ASG RS, "asr",
-
+       ASG OR, "bis",
+       ASG ER, "xor",
+       ASG AND, "bic",
+       PLUS,   "add",
+       MINUS,  "sub",
+       MUL,    "mul",
+       DIV,    "div",
+       OR,     "bis",
+       ER,     "xor",
+       AND,    "bic",

        -1, ""    };
 
 hopcode( f, o ){
        -1, ""    };
 
 hopcode( f, o ){


@@ -45,7 +66,22 @@ hopcode( f, o ){
        for( q = ioptab;  q->opmask>=0; ++q ){
                if( q->opmask == o ){
                        printf( "%s", q->opstring );
        for( q = ioptab;  q->opmask>=0; ++q ){
                if( q->opmask == o ){
                        printf( "%s", q->opstring );

-                       if( f == 'F' ) printf( "f" );
+/* tbl
+                       if( f == 'F' ) printf( "e" );
+                       else if( f == 'D' ) printf( "d" );
+   tbl */
+/* tbl */
+                       switch( f ) {
+                               case 'L':
+                               case 'W':
+                               case 'B':
+                               case 'D':
+                               case 'F':
+                                       printf("%c", tolower(f));
+                                       break;
+
+                               }
+/* tbl */

                        return;
                        }
                }
                        return;
                        }
                }


@@ -53,236 +89,276 @@ hopcode( f, o ){
        }
 
 char *
        }
 
 char *

-rnames[]= {  /* keyed to register number tokens */
+rnames[] = {  /* keyed to register number tokens */

 
        "r0", "r1",
 
        "r0", "r1",

-       "r2", "r3", "r4",
-       "r5", "sp", "pc",
+       "r2", "r3", "r4", "r5",
+       "r6", "r7", "r8", "r9", "r10", "r11",
+       "ap", "fp", "sp", "pc",

 
 

-       "fr0", "fr1", "fr2", "fr3",
-       "fr4", "fr5",   /* not accumulators - used for temps */

        };
 
 int rstatus[] = {
        SAREG|STAREG, SAREG|STAREG,
        };
 
 int rstatus[] = {
        SAREG|STAREG, SAREG|STAREG,

-       SAREG|STAREG, SAREG|STAREG, SAREG|STAREG,       /* use as scratch if not reg var */
-       SAREG, SAREG, SAREG,
+       SAREG|STAREG, SAREG|STAREG, SAREG|STAREG, SAREG|STAREG,
+       SAREG, SAREG, SAREG, SAREG, SAREG, SAREG,
+       SAREG, SAREG, SAREG, SAREG,

 
 

-       SBREG|STBREG, SBREG|STBREG, SBREG|STBREG, SBREG|STBREG,
-       SBREG, SBREG,

        };
 
        };
 

-NODE *brnode;
-int brcase;
+tlen(p) NODE *p;
+{
+       switch(p->type) {
+               case CHAR:
+               case UCHAR:
+                       return(1);
+
+               case SHORT:
+               case USHORT:
+                       return(2);
+
+               case DOUBLE:
+                       return(8);
+
+               default:
+                       return(4);
+               }
+}
+
+mixtypes(p, q) NODE *p, *q;
+{
+       register tp, tq;
+
+       tp = p->type;
+       tq = q->type;
+
+       return( (tp==FLOAT || tp==DOUBLE) !=
+               (tq==FLOAT || tq==DOUBLE) );
+}
+
+prtype(n) NODE *n;
+{
+       switch (n->type)
+               {
+               case DOUBLE:
+                       printf("d");
+                       return;
+
+               case FLOAT:
+                       printf("f");
+                       return;
+
+               case LONG:
+               case ULONG:
+               case INT:
+               case UNSIGNED:
+                       printf("l");
+                       return;
+
+               case SHORT:
+               case USHORT:
+                       printf("w");
+                       return;
+
+               case CHAR:
+               case UCHAR:
+                       printf("b");
+                       return;

 
 

-int toff = 0; /* number of stack locations used for args */
+               default:
+                       if ( !ISPTR( n->type ) ) cerror("zzzcode- bad type");
+                       else {
+                               printf("l");
+                               return;
+                               }
+               }
+}

 
 

-zzzcode( p, c ) NODE *p; {
+zzzcode( p, c ) register NODE *p; {

        register m;
        register m;

+       CONSZ val;

        switch( c ){
 
        switch( c ){
 

-       case 'B':       /* output b if type is byte */
-               if( p->type == CHAR || p->type == UCHAR ) printf( "b" );
-               return;
-

        case 'N':  /* logical ops, turned into 0-1 */
                /* use register given by register 1 */
                cbgen( 0, m=getlab(), 'I' );
                deflab( p->label );
        case 'N':  /* logical ops, turned into 0-1 */
                /* use register given by register 1 */
                cbgen( 0, m=getlab(), 'I' );
                deflab( p->label );

-               printf( "       clr     %s\n", rnames[getlr( p, '1' )->rval] );
-               if( p->type == LONG || p->type == ULONG )
-                       printf( "       clr     %s\n", rnames[getlr( p, '1' )->rval + 1] );
+               printf( "       clrl    %s\n", rnames[getlr( p, '1' )->rval] );

                deflab( m );
                return;
 
        case 'I':
                deflab( m );
                return;
 
        case 'I':

-       case 'F':
+       case 'P':

                cbgen( p->op, p->label, c );
                return;
 
        case 'A':
                cbgen( p->op, p->label, c );
                return;
 
        case 'A':

-       case 'C':
-               /* logical operators for longs
-                  defer comparisons until branch occurs */
-
-               brnode = tcopy( p );
-               brcase = c;
-               return;
-
-       case 'H':  /* fix up unsigned shifts */
-               {       register NODE *q;
-                       register r, l;
-                       TWORD t;
-
-                       if( p->op == ASG LS ) return;
-                       if( p->op != ASG RS ) cerror( "ZH bad" );
-                       if( p->left->op != REG ) cerror( "SH left bad" );
-
-                       r = p->left->rval;
-                       t = p->left->type;
-                       l = (t==LONG || t == ULONG );
-
-                       if( t != UNSIGNED && t != UCHAR && t != ULONG ) return;  /* signed is ok */
-
-                       /* there are three cases:  right side is a constant,
-                               and has the shift value; right side is
-                               a temporary reg, and has the - shift value,
-                               and right side is something else: A1 has the
-                               - shift value then */
-
-                       /* in the case where the value is known (rhs a constant),
-                               the mask is just computed and put out... */
-
-                       if( p->right->op == ICON ){
-                               int s;
-                               s = p->right->lval;
-                               if( l ){
-                                       if( s >= 16 ){
-                                               printf( "       clr     r%d\n", r );
-                                               s -= 16;
-                                               ++r;
-                                               }
-                                       }
-                               if( s >= 16 ) printf( " clr     r%d\n", r );
-                               else {
-                                       m = 0100000;
-                                       m >>= s;  /* sign extends... */
-                                       m <<= 1;
-                                       printf( "       bic     $%o,r%d\n", m, r );
-                                       }
+               {
+               register NODE *l, *r;
+
+               if (xdebug) eprint(p, 0, &val, &val);
+               r = getlr(p, 'R');
+               if (optype(p->op) == LTYPE || p->op == UNARY MUL)
+                       {
+                       l = resc;
+                       l->type = (r->type==FLOAT || r->type==DOUBLE ? DOUBLE : INT);
+                       }
+               else
+                       l = getlr(p, 'L');
+               if (r->op == ICON  && r->name[0] == '\0')
+                       {
+                       if (r->lval == 0)
+                               {
+                               printf("clr");
+                               prtype(l);
+                               printf("        ");
+                               adrput(l);

                                return;
                                }
                                return;
                                }

+                       if (r->lval < 0 && r->lval >= -63)
+                               {
+                               printf("mneg");
+                               prtype(l);
+                               r->lval = -r->lval;
+                               goto ops;
+                               }
+                       r->type = (r->lval < 0 ?
+                                       (r->lval >= -128 ? CHAR
+                                       : (r->lval >= -32768 ? SHORT
+                                       : INT )) : r->type);
+                       r->type = (r->lval >= 0 ?
+                                       (r->lval <= 63 ? INT
+                                       : ( r->lval <= 127 ? CHAR
+                                       : (r->lval <= 255 ? UCHAR
+                                       : (r->lval <= 32767 ? SHORT
+                                       : (r->lval <= 65535 ? USHORT
+                                       : INT ))))) : r->type );
+                       }
+               if (l->op == REG && l->type != FLOAT && l->type != DOUBLE)
+                       l->type = INT;
+               if (!mixtypes(l,r))
+                       {
+                       if (tlen(l) == tlen(r))
+                               {
+                               printf("mov");
+                               prtype(l);
+                               goto ops;
+                               }
+                       else if (tlen(l) > tlen(r) && ISUNSIGNED(r->type))
+                               {
+                               printf("movz");
+                               }
+                       else
+                               {
+                               printf("cvt");
+                               }
+                       }
+               else
+                       {
+                       printf("cvt");
+                       }
+               prtype(r);
+               prtype(l);
+       ops:
+               printf("        ");
+               adrput(r);
+               printf(",");
+               adrput(l);
+               return;
+               }

 
 

-                       /* general case */
-
-                       if( istnode( p->right ) ) q = p->right;
-                       else q = getlr( p, '1' );  /* where -shift is stored */
-
-                       /* first, we store the shifted value on the stack */
-                       printf( "       mov     r%d,-(sp)\n", r );
-                       if( l ) printf( "       mov     r%d,-(sp)\n", r+1 );
-
-                       /* now, make a mask */
-
-                       printf( "       mov     $100000,r%d\n", r );
-                       if( l ) printf( "       clr     r%d\n", r+1 );
-                       
-                       /* shift (arithmetically ) */
-                       if( l ) expand( q, RNOP, "      ashc    AR" );
-                       else expand( q, RNOP, " ash     AR" );
-                       printf( ",r%d\n", r );
+       case 'C':       /* num words pushed on arg stack */
+               {
+               extern int gc_numbytes;
+               extern int xdebug;

 
 

-                       if( l ) printf( "       ashc    $1,r%d\n", r );
-                       else printf( "  asl     r%d\n", r );
+               if (xdebug) printf("->%d<-",gc_numbytes);

 
 

-                       /* now, we have a mask: use it to clear sp, and reload */
+               printf("$%d", gc_numbytes/(SZLONG/SZCHAR) );
+               return;
+               }

 
 

-                       if( l ){
-                               printf( "\tbic\tr%d,(sp)\n\tmov\t(sp)+,r%d\n", r+1, r+1 );
-                               }
-                       printf( "\tbic\tr%d,(sp)\n\tmov\t(sp)+,r%d\n", r, r );
-                       /* whew! */
+       case 'D':       /* INCR and DECR */
+               zzzcode(p->left, 'A');
+               printf("\n      ");
+
+       case 'E':       /* INCR and DECR, FOREFF */
+               if (p->right->lval == 1)
+                       {
+                       printf("%s", (p->op == INCR ? "inc" : "dec") );
+                       prtype(p->left);
+                       printf("        ");
+                       adrput(p->left);

                        return;
                        }
                        return;
                        }

+               printf("%s", (p->op == INCR ? "add" : "sub") );
+               prtype(p->left);
+               printf("2       ");
+               adrput(p->right);
+               printf(",");
+               adrput(p->left);
+               return;

 
 

-       case 'V':
-               /* sign extend or not -- register is one less than the
-                  left descendent */
+       case 'F':       /* register type of right operand */
+               {
+               register NODE *n;
+               extern int xdebug;
+               register int ty;

 
 

-               m = p->left->rval - 1;
+               n = getlr( p, 'R' );
+               ty = n->type;

 
 

-               if( ISUNSIGNED(p->type) ){
-                       printf( "       clr     r%d\n", m );
-                       }
-               else {
-                       printf( "       sxt     r%d\n", m );
-                       }
-               return;
+               if (xdebug) printf("->%d<-", ty);

 
 

-               /* stack management macros */
-       case '-':
-               if( toff ++ ) printf( "-" );
-               printf( "(sp)" );
+               if ( ty==DOUBLE) printf("d");
+               else if ( ty==FLOAT ) printf("f");
+               else printf("l");

                return;
                return;

+               }

 
 

-       case '4':
-               if( toff == 0 ) ++toff;  /* can't push doubles that way */
-               printf( "-(sp)" );
-               toff += 4;
-               return;
+       case 'L':       /* type of left operand */
+       case 'R':       /* type of right operand */
+               {
+               register NODE *n;
+               extern int xdebug;

 
 

-       case '~':
-               /* complimented CR */
-               p->right->lval = ~p->right->lval;
-               conput( getlr( p, 'R' ) );
-               p->right->lval = ~p->right->lval;
-               return;
+               n = getlr ( p, c);
+               if (xdebug) printf("->%d<-", n->type);

 
 

-       case 'M':
-               /* negated CR */
-               p->right->lval = -p->right->lval;
-               conput( getlr( p, 'R' ) );
-               p->right->lval = -p->right->lval;
+               prtype(n);

                return;
                return;

-
-       case 'L':  /* INIT for long constants */
-               {
-                       unsigned hi, lo;
-                       lo = p->left->lval & BITMASK(SZINT);
-                       hi = ( p->left->lval >> SZINT ) & BITMASK(SZINT);
-                       printf( "       %o; %o\n", hi, lo );
-                       return;

                }
 
                }
 

-       case 'T':
-               /* Truncate longs for type conversions:
-                   LONG|ULONG -> CHAR|UCHAR|INT|UNSIGNED
-                  increment offset to second word */
-
-               m = p->type;
-               p = p->left;
-               switch( p->op ){
-               case NAME:
-               case OREG:
-                       p->lval += SZINT/SZCHAR;
-                       return;
-               case REG:
-                       rfree( p->rval, p->type );
-                       p->rval += 1;
-                       p->type = m;
-                       rbusy( p->rval, p->type );
-                       return;
-               default:
-                       cerror( "Illegal ZT type conversion" );
-                       return;
+       case 'Z':       /* complement mask for bit instr */
+               printf("$%ld", ~p->right->lval);
+               return;

 
 

-                       }
+       case 'U':       /* 32 - n, for unsigned right shifts */
+               printf("$%d", 32 - p->right->lval );
+               return;

 
 

-       case 'U':
-               /* same as AL for exp under U* */
-               if( p->left->op == UNARY MUL ) {
-                       adrput( getlr( p->left, 'L' ) );
-                       return;
-                       }
-               cerror( "Illegal ZU" );
-               /* NO RETURN */
+       case 'T':       /* rounded structure length for arguments */
+               {
+               int size;

 
 

-       case 'W':       /* structure size */
-               if( p->op == STASG )
-                       printf( "%d", p->stsize);
-               else    cerror( "Not a structure" );
+               size = p->stsize;
+               SETOFF( size, 4);
+               printf("$%d", size);

                return;
                return;

+               }

 
        case 'S':  /* structure assignment */
                {
                        register NODE *l, *r;
 
        case 'S':  /* structure assignment */
                {
                        register NODE *l, *r;

-                       register size, count;
+                       register size;

 
                        if( p->op == STASG ){
                                l = p->left;
                                r = p->right;
 
                        if( p->op == STASG ){
                                l = p->left;
                                r = p->right;

+

                                }
                                }

-                       else if( p->op == STARG ){  /* store an arg onto the stack */
+                       else if( p->op == STARG ){  /* store an arg into a temporary */
+                               l = getlr( p, '3' );

                                r = p->left;
                                }
                        else cerror( "STASG bad" );
                                r = p->left;
                                }
                        else cerror( "STASG bad" );


@@ -292,23 +368,31 @@ zzzcode( p, c ) NODE *p; {
                        else if( r->op != OREG ) cerror( "STASG-r" );
 
                        size = p->stsize;
                        else if( r->op != OREG ) cerror( "STASG-r" );
 
                        size = p->stsize;

-                       count = size / 2;
-
-                       r->lval += size;
-                       if( p->op == STASG ) l->lval += size;
-
-                       while( count-- ){ /* simple load/store loop */
-                               r->lval -= 2;
-                               expand( r, FOREFF, "    mov     AR," );
-                               if( p->op == STASG ){
-                                       l->lval -= 2;
-                                       expand( l, FOREFF, "AR\n" );
-                                       }
-                               else {
-                                       printf( "-(sp)\n" );
-                                       }

 
 

-                               }
+                       if( size <= 0 || size > 65535 )
+                               cerror("structure size <0=0 or >65535");
+
+                       switch(size) {
+                               case 1:
+                                       printf("        movb    ");
+                                       break;
+                               case 2:
+                                       printf("        movw    ");
+                                       break;
+                               case 4:
+                                       printf("        movl    ");
+                                       break;
+                               case 8:
+                                       printf("        movq    ");
+                                       break;
+                               default:
+                                       printf("        movc3   $%d,", size);
+                                       break;
+                       }
+                       adrput(r);
+                       printf(",");
+                       adrput(l);
+                       printf("\n");

 
                        if( r->op == NAME ) r->op = ICON;
                        else if( r->op == OREG ) r->op = REG;
 
                        if( r->op == NAME ) r->op = ICON;
                        else if( r->op == OREG ) r->op = REG;


@@ -321,46 +405,28 @@ zzzcode( p, c ) NODE *p; {
                }
        }
 
                }
        }
 

-rmove( rt, rs, t ) TWORD t; {
-       printf( "       %s      %s,%s\n", (t==FLOAT||t==DOUBLE)?"movf":"mov", rnames[rs], rnames[rt] );
+rmove( rt, rs, t ){
+       printf( "       %s      %s,%s\n",
+               (t==FLOAT ? "movf" : (t==DOUBLE ? "movd" : "movl")),
+               rnames[rs], rnames[rt] );

        }
 
 struct respref
 respref[] = {
        INTAREG|INTBREG,        INTAREG|INTBREG,
        }
 
 struct respref
 respref[] = {
        INTAREG|INTBREG,        INTAREG|INTBREG,

-       INAREG|INBREG,  INAREG|INBREG|SOREG|STARREG|SNAME|STARNM|SCON,
+       INAREG|INBREG,  INAREG|INBREG|SOREG|STARREG|STARNM|SNAME|SCON,

        INTEMP, INTEMP,
        FORARG, FORARG,
        INTEMP, INTEMP,
        FORARG, FORARG,

-       INTAREG,        SOREG|SNAME,
+       INTEMP, INTAREG|INAREG|INTBREG|INBREG|SOREG|STARREG|STARNM,

        0,      0 };
 
 setregs(){ /* set up temporary registers */
        0,      0 };
 
 setregs(){ /* set up temporary registers */

-       register i;
-
-       /* use any unused variable registers as scratch registers */
-       fregs = maxtreg>=MINRVAR ? maxtreg + 1 : MINRVAR;
-       if( xdebug ){
-               /* -x changes number of free regs to 2, -xx to 3, etc. */
-               if( (xdebug+1) < fregs ) fregs = xdebug+1;
-               }
-       /* NOTE: for pdp11 fregs <= 4 for float regs */
-       if( fregs > 4 ) fregs = 4;
-       for( i=MINRVAR; i<=MAXRVAR; i++ )
-               rstatus[i] = i<fregs ? SAREG|STAREG : SAREG;
+       fregs = 6;      /* tbl- 6 free regs on VAX (0-5) */
+       ;

        }
 
        }
 

-szty(t) TWORD t; { /* size, in words, needed to hold thing of type t */
-       /* really is the number of registers to hold type t */
-       switch( t ) {
-
-       case LONG:
-       case ULONG:
-               return( SZLONG/SZINT );
-
-       default:
-               return(1);
-
-               }
+szty(t){ /* size, in registers, needed to hold thing of type t */
+       return( (t==DOUBLE||t==FLOAT) ? 2 : 1 );

        }
 
 rewfld( p ) NODE *p; {
        }
 
 rewfld( p ) NODE *p; {


@@ -368,71 +434,159 @@ rewfld( p ) NODE *p; {
        }
 
 callreg(p) NODE *p; {
        }
 
 callreg(p) NODE *p; {

-       return( (p->type==DOUBLE||p->type==FLOAT) ? FR0 : R0 );
+       return( R0 );

        }
 
        }
 

-shltype( o, p ) NODE *p; {
-       if( o == NAME|| o==REG || o == ICON || o == OREG ) return( 1 );
-       return( o==UNARY MUL && shumul(p->left) );
+base( p ) register NODE *p; {
+       register int o = p->op;
+
+       if( (o==ICON && p->name[0] != '\0')) return( 100 ); /* ie no base reg */
+       if( o==REG ) return( p->rval );
+    if( (o==PLUS || o==MINUS) && p->left->op == REG && p->right->op==ICON)
+               return( p->left->rval );
+    if( o==OREG && !R2TEST(p->rval) && (p->type==INT || p->type==UNSIGNED || ISPTR(p->type)) )
+               return( p->rval + 0200*1 );
+       if( o==INCR && p->left->op==REG ) return( p->left->rval + 0200*2 );
+       if( o==ASG MINUS && p->left->op==REG) return( p->left->rval + 0200*4 );
+       if( o==UNARY MUL && p->left->op==INCR && p->left->left->op==REG
+         && (p->type==INT || p->type==UNSIGNED || ISPTR(p->type)) )
+               return( p->left->left->rval + 0200*(1+2) );
+       return( -1 );

        }
 
        }
 

-flshape( p ) register NODE *p; {
-       register o = p->op;
-       if( o==NAME || o==REG || o==ICON || o==OREG ) return( 1 );
-       return( o==UNARY MUL && shumul(p->left)==STARNM );
-       }
+offset( p, tyl ) register NODE *p; int tyl; {

 
 

-shtemp( p ) register NODE *p; {
-       if( p->op == UNARY MUL ) p = p->left;
-       if( p->op == REG || p->op == OREG ) return( !istreg( p->rval ) );
-       return( p->op == NAME || p->op == ICON );
+       if( tyl==1 && p->op==REG && (p->type==INT || p->type==UNSIGNED) ) return( p->rval );
+       if( (p->op==LS && p->left->op==REG && (p->left->type==INT || p->left->type==UNSIGNED) &&
+             (p->right->op==ICON && p->right->name[0]=='\0')
+             && (1<<p->right->lval)==tyl))
+               return( p->left->rval );
+       return( -1 );

        }
 
        }
 

-spsz( t, v ) TWORD t; CONSZ v; {
+makeor2( p, q, b, o) register NODE *p, *q; register int b, o; {
+       register NODE *t;
+       register int i;
+       NODE *f;

 
 

-       /* is v the size to increment something of type t */
+       p->op = OREG;
+       f = p->left;    /* have to free this subtree later */

 
 

-       if( !ISPTR(t) ) return( 0 );
-       t = DECREF(t);
+       /* init base */
+       switch (q->op) {
+               case ICON:
+               case REG:
+               case OREG:
+                       t = q;
+                       break;

 
 

-       if( ISPTR(t) ) return( v == 2 );
+               case MINUS:
+                       q->right->lval = -q->right->lval;
+               case PLUS:
+                       t = q->right;
+                       break;

 
 

-       switch( t ){
+               case INCR:
+               case ASG MINUS:
+                       t = q->left;
+                       break;

 
 

-       case UCHAR:
-       case CHAR:
-               return( v == 1 );
+               case UNARY MUL:
+                       t = q->left->left;
+                       break;

 
 

-       case INT:
-       case UNSIGNED:
-               return( v == 2 );
+               default:
+                       cerror("illegal makeor2");
+       }

 
 

-       case FLOAT:
-               return( v == 4 );
+       p->lval = t->lval;
+       for(i=0; i<NCHNAM; ++i)
+               p->name[i] = t->name[i];

 
 

-       case DOUBLE:
-               return( v == 8 );
-               }
+       /* init offset */
+       p->rval = R2PACK( (b & 0177), o, (b>>7) );

 
 

-       return( 0 );
+       tfree(f);
+       return;
+       }
+
+canaddr( p ) NODE *p; {
+       register int o = p->op;
+
+       if( o==NAME || o==REG || o==ICON || o==OREG || (o==UNARY MUL && shumul(p->left)) ) return(1);
+       return(0);
+       }
+
+shltype( o, p ) register NODE *p; {
+       return( o== REG || o == NAME || o == ICON || o == OREG || ( o==UNARY MUL && shumul(p->left)) );
+       }
+
+flshape( p ) register NODE *p; {
+       return( p->op == REG || p->op == NAME || p->op == ICON ||
+               (p->op == OREG && (!R2TEST(p->rval) || tlen(p) == 1)) );
+       }
+
+shtemp( p ) register NODE *p; {
+       if( p->op == STARG ) p = p->left;
+       return( p->op==NAME || p->op ==ICON || p->op == OREG || (p->op==UNARY MUL && shumul(p->left)) );

        }
 
 shumul( p ) register NODE *p; {
        register o;
        }
 
 shumul( p ) register NODE *p; {
        register o;

+       extern int xdebug;
+
+       if (xdebug) {
+                printf("\nshumul:op=%d,lop=%d,rop=%d", p->op, p->left->op, p->right->op);
+               printf(" prname=%s,plty=%d, prlval=%D\n", p->right->name, p->left->type, p->right->lval);
+               }
+

 
        o = p->op;
 
        o = p->op;

-       if( o == NAME || o == OREG || o == ICON ) return( STARNM );
+       if( o == NAME || (o == OREG && !R2TEST(p->rval)) || o == ICON ) return( STARNM );

 
        if( ( o == INCR || o == ASG MINUS ) &&
            ( p->left->op == REG && p->right->op == ICON ) &&
 
        if( ( o == INCR || o == ASG MINUS ) &&
            ( p->left->op == REG && p->right->op == ICON ) &&

-           p->right->name[0] == '\0' &&
-           spsz( p->left->type, p->right->lval ) )
-               return( STARREG );
+           p->right->name[0] == '\0' )
+               {
+               switch (p->left->type)
+                       {
+                       case CHAR|PTR:
+                       case UCHAR|PTR:
+                               o = 1;
+                               break;
+
+                       case SHORT|PTR:
+                       case USHORT|PTR:
+                               o = 2;
+                               break;
+
+                       case INT|PTR:
+                       case UNSIGNED|PTR:
+                       case LONG|PTR:
+                       case ULONG|PTR:
+                       case FLOAT|PTR:
+                               o = 4;
+                               break;
+
+                       case DOUBLE|PTR:
+                               o = 8;
+                               break;
+
+                       default:
+                               if ( ISPTR(p->left->type) ) {
+                                       o = 4;
+                                       break;
+                                       }
+                               else return(0);
+                       }
+               return( p->right->lval == o ? STARREG : 0);
+               }

 
        return( 0 );
        }
 
 adrcon( val ) CONSZ val; {
 
        return( 0 );
        }
 
 adrcon( val ) CONSZ val; {

+       printf( "$" );

        printf( CONFMT, val );
        }
 
        printf( CONFMT, val );
        }
 


@@ -452,57 +606,16 @@ conput( p ) register NODE *p; {
                }
        }
 
                }
        }
 

-insput( p ) NODE *p; {
+insput( p ) register NODE *p; {

        cerror( "insput" );
        }
 
        cerror( "insput" );
        }
 

-upput( p ) NODE *p; {
-       /* output the address of the second word in the
-          pair pointed to by p (for LONGs)*/
-       CONSZ save;
-
-       if( p->op == FLD ){
-               p = p->left;
-               }
-
-       save = p->lval;
-       switch( p->op ){
-
-       case NAME:
-               p->lval += SZINT/SZCHAR;
-               acon( p );
-               break;
-
-       case ICON:
-               /* addressable value of the constant */
-               p->lval &= BITMASK(SZINT);
-               printf( "$" );
-               acon( p );
-               break;
-
-       case REG:
-               printf( "%s", rnames[p->rval+1] );
-               break;
-
-       case OREG:
-               p->lval += SZINT/SZCHAR;
-               if( p->rval == R5 ){  /* in the argument region */
-                       if( p->name[0] != '\0' ) werror( "bad arg temp" );
-                       }
-               if( p->lval != 0 || p->name[0] != '\0' ) acon( p );
-               printf( "(%s)", rnames[p->rval] );
-               break;
-
-       default:
-               cerror( "illegal upper address" );
-               break;
-
-               }
-       p->lval = save;
-
+upput( p ) register NODE *p; {
+       cerror( "upput" );

        }
 
 adrput( p ) register NODE *p; {
        }
 
 adrput( p ) register NODE *p; {

+       register int r;

        /* output an address, with offsets, from p */
 
        if( p->op == FLD ){
        /* output an address, with offsets, from p */
 
        if( p->op == FLD ){


@@ -516,16 +629,6 @@ adrput( p ) register NODE *p; {
 
        case ICON:
                /* addressable value of the constant */
 
        case ICON:
                /* addressable value of the constant */

-               if( szty( p->type ) == 2 ) {
-                       /* print the high order value */
-                       CONSZ save;
-                       save = p->lval;
-                       p->lval = ( p->lval >> SZINT ) & BITMASK(SZINT);
-                       printf( "$" );
-                       acon( p );
-                       p->lval = save;
-                       return;
-                       }

                printf( "$" );
                acon( p );
                return;
                printf( "$" );
                acon( p );
                return;


@@ -535,13 +638,26 @@ adrput( p ) register NODE *p; {
                return;
 
        case OREG:
                return;
 
        case OREG:

-               if( p->rval == R5 ){  /* in the argument region */
-                       if( p->name[0] != '\0' ) werror( "bad arg temp" );
+               r = p->rval;
+               if( R2TEST(r) ){ /* double indexing */
+                       register int flags;
+
+                       flags = R2UPK3(r);
+                       if( flags & 1 ) printf("*");
+                       if( flags & 4 ) printf("-");
+                       if( p->lval != 0 || p->name[0] != '\0' ) acon(p);
+                       if( R2UPK1(r) != 100) printf( "(%s)", rnames[R2UPK1(r)] );
+                       if( flags & 2 ) printf("+");
+                       printf( "[%s]", rnames[R2UPK2(r)] );
+                       return;
+                       }
+               if( r == AP ){  /* in the argument region */
+                       if( p->lval <= 0 || p->name[0] != '\0' ) werror( "bad arg temp" );

                        printf( CONFMT, p->lval );
                        printf( CONFMT, p->lval );

-                       printf( ".(r5)" );
+                       printf( "(ap)" );

                        return;
                        }
                        return;
                        }

-               if( p->lval != 0 || p->name[0] != '\0' ) acon( p );
+               if( p->lval != 0 || p->name[0] != '\0') acon( p );

                printf( "(%s)", rnames[p->rval] );
                return;
 
                printf( "(%s)", rnames[p->rval] );
                return;
 


@@ -552,29 +668,31 @@ adrput( p ) register NODE *p; {
                        adrput( p->left);
                        }
                else {  /* STARREG - really auto inc or dec */
                        adrput( p->left);
                        }
                else {  /* STARREG - really auto inc or dec */

-                       /* turn into OREG so replacement node will
-                          reflect the value of the expression */
-                       register i;
-                       register NODE *q, *l;
+                       register NODE *q;

 
 

-                       l = p->left;
-                       q = l->left;
-                       p->op = OREG;
-                       p->rall = q->rall;
-                       p->lval = q->lval;
-                       p->rval = q->rval;
-                       for( i=0; i<NCHNAM; i++ )
-                               p->name[i] = q->name[i];
-                       if( l->op == INCR ) {
-                               adrput( p );
+/* tbl
+                       p = p->left;
+                       p->left->op = OREG;
+                       if( p->op == INCR ) {
+                               adrput( p->left );

                                printf( "+" );
                                printf( "+" );

-                               p->lval -= l->right->lval;

                                }
                                }

-                       else {  /* l->op == ASG MINUS */
+                       else {

                                printf( "-" );
                                printf( "-" );

-                               adrput( p );
+                               adrput( p->left );

                                }
                                }

-                       tfree( l );
+   tbl */
+                       if( p->left->op!=INCR )
+                               printf("-");
+                       printf("(%s)", rnames[p->left->left->rval]); 
+                       if( p->left->op==INCR )
+                               printf("+");
+                       p->op = OREG;
+                       p->rval = p->left->left->rval;
+                       q = p->left;
+                       p->lval = (p->left->op == INCR ? -p->left->right->lval : 0);
+                       p->name[0] = '\0';
+                       tfree(q);

                }
                return;
 
                }
                return;
 


@@ -588,53 +706,106 @@ adrput( p ) register NODE *p; {
 
 acon( p ) register NODE *p; { /* print out a constant */
 
 
 acon( p ) register NODE *p; { /* print out a constant */
 

-       if( p->name[0] == '\0' ){       /* constant only */
+       if( p->name[0] == '\0' ){

                printf( CONFMT, p->lval);
                printf( CONFMT, p->lval);

-               printf( "." );

                }
                }

-       else if( p->lval == 0 ) {       /* name only */
+       else if( p->lval == 0 ) {

                printf( "%.8s", p->name );
                }
                printf( "%.8s", p->name );
                }

-       else {                          /* name + offset */
+       else {

                printf( "%.8s+", p->name );
                printf( CONFMT, p->lval );
                printf( "%.8s+", p->name );
                printf( CONFMT, p->lval );

-               printf( "." );

                }
        }
 
                }
        }
 

+/*
+aacon( p ) register NODE *p; { /* print out a constant */
+/*
+
+       if( p->name[0] == '\0' ){
+               printf( CONFMT, p->lval);
+               return( 0 );
+               }
+       else if( p->lval == 0 ) {
+               printf( "$%.8s", p->name );
+               return( 1 );
+               }
+       else {
+               printf( "$(" );
+               printf( CONFMT, p->lval );
+               printf( "+" );
+               printf( "%.8s)", p->name );
+               return(1);
+               }
+       }
+ */
+

 genscall( p, cookie ) register NODE *p; {
        /* structure valued call */
        return( gencall( p, cookie ) );
        }
 
 genscall( p, cookie ) register NODE *p; {
        /* structure valued call */
        return( gencall( p, cookie ) );
        }
 

+/* tbl */
+int gc_numbytes;
+/* tbl */
+

 gencall( p, cookie ) register NODE *p; {
        /* generate the call given by p */
 gencall( p, cookie ) register NODE *p; {
        /* generate the call given by p */

-       register temp;
+       register NODE *p1, *ptemp;
+       register temp, temp1;

        register m;
 
        if( p->right ) temp = argsize( p->right );
        else temp = 0;
 
        register m;
 
        if( p->right ) temp = argsize( p->right );
        else temp = 0;
 

-       if( p->right ){ /* generate args */
-               genargs( p->right );
+       if( p->op == STCALL || p->op == UNARY STCALL ){
+               /* set aside room for structure return */
+
+               if( p->stsize > temp ) temp1 = p->stsize;
+               else temp1 = temp;

                }
 
                }
 

-       if( !shltype( p->left->op, p->left ) ) {
-               order( p->left, INAREG|SOREG );
+       if( temp > maxargs ) maxargs = temp;
+       SETOFF(temp1,4);
+
+       if( p->right ){ /* make temp node, put offset in, and generate args */
+               ptemp = talloc();
+               ptemp->op = OREG;
+               ptemp->lval = -1;
+               ptemp->rval = SP;
+               ptemp->name[0] = '\0';
+               ptemp->rall = NOPREF;
+               ptemp->su = 0;
+               genargs( p->right, ptemp );
+               ptemp->op = FREE;

                }
 
                }
 

-       p->op = UNARY CALL;
-       m = match( p, INTAREG|INTBREG );
-       popargs( temp );
-       return(m != MDONE);
-       }
+       p1 = p->left;
+       if( p1->op != ICON ){
+               if( p1->op != REG ){
+                       if( p1->op != OREG || R2TEST(p1->rval) ){
+                               if( p1->op != NAME ){
+                                       order( p1, INAREG );
+                                       }
+                               }
+                       }
+               }

 
 

-popargs( size ) register size; {
-       /* pop arguments from stack */
+/*
+       if( p1->op == REG && p->rval == R5 ){
+               cerror( "call register overwrite" );
+               }
+ */
+/* tbl
+       setup gc_numbytes so reference to ZC works */

 
 

-       toff -= size/2;
-       if( toff == 0 && size >= 2 ) size -= 2;
-       switch( size ) {
+       gc_numbytes = temp;
+/* tbl */
+
+       p->op = UNARY CALL;
+       m = match( p, INTAREG|INTBREG );
+/* tbl
+       switch( temp ) {

        case 0:
                break;
        case 2:
        case 0:
                break;
        case 2:


@@ -644,87 +815,36 @@ popargs( size ) register size; {
                printf( "       cmp     (sp)+,(sp)+\n" );
                break;
        default:
                printf( "       cmp     (sp)+,(sp)+\n" );
                break;
        default:

-               printf( "       add     $%d.,sp\n", size);
+               printf( "       add     $%d,sp\n", temp);

                }
                }

+   tbl */
+       return(m != MDONE);

        }
 
        }
 

+/* tbl */

 char *
 ccbranches[] = {
 char *
 ccbranches[] = {

-       "       jeq     L%d\n",
-       "       jne     L%d\n",
-       "       jle     L%d\n",
-       "       jlt     L%d\n",
-       "       jge     L%d\n",
-       "       jgt     L%d\n",
-       "       jlos    L%d\n",
-       "       jlo     L%d\n",
-       "       jhis    L%d\n",
-       "       jhi     L%d\n",
-       };
-
-/*     long branch table
-
-   This table, when indexed by a logical operator,
-   selects a set of three logical conditions required
-   to generate long comparisons and branches.  A zero
-   entry indicates that no branch is required.
-   E.G.:  The <= operator would generate:
-       cmp     AL,AR
-       jlt     lable   / 1st entry LT -> lable
-       jgt     1f      / 2nd entry GT -> 1f
-       cmp     UL,UR
-       jlos    lable   / 3rd entry ULE -> lable
-   1:
- */
-
-int lbranches[][3] = {
-       /*EQ*/  0,      NE,     EQ,
-       /*NE*/  NE,     0,      NE,
-       /*LE*/  LT,     GT,     ULE,
-       /*LT*/  LT,     GT,     ULT,
-       /*GE*/  GT,     LT,     UGE,
-       /*GT*/  GT,     LT,     UGT,
-       /*ULE*/ ULT,    UGT,    ULE,
-       /*ULT*/ ULT,    UGT,    ULT,
-       /*UGE*/ UGT,    ULT,    UGE,
-       /*UGT*/ UGT,    ULT,    UGT,
+       "       jeql    L%d\n",
+       "       jneq    L%d\n",
+       "       jleq    L%d\n",
+       "       jlss    L%d\n",
+       "       jgeq    L%d\n",
+       "       jgtr    L%d\n",
+       "       jlequ   L%d\n",
+       "       jlssu   L%d\n",
+       "       jgequ   L%d\n",
+       "       jgtru   L%d\n",

        };
        };

-
-/* logical relations when compared in reverse order (cmp R,L) */
-extern short revrel[] ;
+/* tbl */

 
 cbgen( o, lab, mode ) { /*   printf conditional and unconditional branches */
 
 cbgen( o, lab, mode ) { /*   printf conditional and unconditional branches */

-       register *plb;
-       int lab1f;

 
 

-       if( o == 0 ) printf( "  jbr     L%d\n", lab );
-       else    if( o > UGT ) cerror( "bad conditional branch: %s", opst[o] );
+/* tbl */
+       if( o == 0 ) printf( "  jbr     L%d\n", lab );
+/* tbl */

        else {
        else {

-               switch( brcase ) {
-
-               case 'A':
-               case 'C':
-                       plb = lbranches[ o-EQ ];
-                       lab1f = getlab();
-                       expand( brnode, FORCC, brcase=='C' ? "\tcmp\tAL,AR\n" : "\ttst\tAR\n" );
-                       if( *plb != 0 )
-                               printf( ccbranches[*plb-EQ], lab);
-                       if( *++plb != 0 )
-                               printf( ccbranches[*plb-EQ], lab1f);
-                       expand( brnode, FORCC, brcase=='C' ? "\tcmp\tUL,UR\n" : "\ttst\tUR\n" );
-                       printf( ccbranches[*++plb-EQ], lab);
-                       deflab( lab1f );
-                       reclaim( brnode, RNULL, 0 );
-                       break;
-
-               default:
-                       if( mode=='F' ) o = revrel[ o-EQ ];
-                       printf( ccbranches[o-EQ], lab );
-                       break;
-                       }
-
-               brcase = 0;
-               brnode = 0;
+               if( o > UGT ) cerror( "bad conditional branch: %s", opst[o] );
+               printf( ccbranches[o-EQ], lab );

                }
        }
 
                }
        }
 


@@ -741,111 +861,6 @@ lastchance( p, cook ) NODE *p; {
        return(0);
        }
 
        return(0);
        }
 

-struct functbl {
-       int fop;
-       TWORD ftype;
-       char *func;
-       } opfunc[] = {
-       MUL,            LONG,   "lmul",
-       DIV,            LONG,   "ldiv",
-       MOD,            LONG,   "lrem",
-       ASG MUL,        LONG,   "almul",
-       ASG DIV,        LONG,   "aldiv",
-       ASG MOD,        LONG,   "alrem",
-       MUL,            ULONG,  "lmul",
-       DIV,            ULONG,  "uldiv",
-       MOD,            ULONG,  "ulrem",
-       ASG MUL,        ULONG,  "almul",
-       ASG DIV,        ULONG,  "auldiv",
-       ASG MOD,        ULONG,  "aulrem",
-       0,      0,      0 };
-
-hardops(p)  register NODE *p; {
-       /* change hard to do operators into function calls.
-          for pdp11 do long * / %      */
-       register NODE *q;
-       register struct functbl *f;
-       register o;
-       register TWORD t;
-
-       o = p->op;
-       t = p->type;
-       if( t!=LONG && t!=ULONG ) return;
-
-       for( f=opfunc; f->fop; f++ ) {
-               if( o==f->fop && t==f->ftype ) goto convert;
-               }
-       return;
-
-       /* need address of left node for ASG OP */
-       /* WARNING - this won't work for long in a REG */
-       convert:
-       if( asgop( o ) ) {
-               switch( p->left->op ) {
-
-               case UNARY MUL: /* convert to address */
-                       p->left->op = FREE;
-                       p->left = p->left->left;
-                       break;
-
-               case NAME:      /* convert to ICON pointer */
-                       p->left->op = ICON;
-                       p->left->type = INCREF( p->left->type );
-                       break;
-
-               case OREG:      /* convert OREG to address */
-                       p->left->op = REG;
-                       p->left->type = INCREF( p->left->type );
-                       if( p->left->lval != 0 ) {
-                               q = talloc();
-                               q->op = PLUS;
-                               q->rall = NOPREF;
-                               q->type = p->left->type;
-                               q->left = p->left;
-                               q->right = talloc();
-
-                               q->right->op = ICON;
-                               q->right->rall = NOPREF;
-                               q->right->type = INT;
-                               q->right->name[0] = '\0';
-                               q->right->lval = p->left->lval;
-                               q->right->rval = 0;
-
-                               p->left->lval = 0;
-                               p->left = q;
-                               }
-                       break;
-
-               default:
-                       cerror( "Bad address for hard ops" );
-                       /* NO RETURN */
-
-                       }
-               }
-
-       /* build comma op for args to function */
-       q = talloc();
-       q->op = CM;
-       q->rall = NOPREF;
-       q->type = INT;
-       q->left = p->left;
-       q->right = p->right;
-       p->op = CALL;
-       p->right = q;
-
-       /* put function name in left node of call */
-       p->left = q = talloc();
-       q->op = ICON;
-       q->rall = NOPREF;
-       q->type = INCREF( FTN + p->type );
-       strcpy( q->name, f->func );
-       q->lval = 0;
-       q->rval = 0;
-
-       return;
-
-       }
-

 optim2( p ) register NODE *p; {
        /* do local tree transformations and optimizations */
 
 optim2( p ) register NODE *p; {
        /* do local tree transformations and optimizations */
 


@@ -855,7 +870,7 @@ optim2( p ) register NODE *p; {
 
        case AND:
                /* commute L and R to eliminate compliments and constants */
 
        case AND:
                /* commute L and R to eliminate compliments and constants */

-               if( p->left->op==ICON || p->left->op==COMPL ) {
+               if( (p->left->op==ICON&&p->left->name[0]==0) || p->left->op==COMPL ) {

                        r = p->left;
                        p->left = p->right;
                        p->right = r;
                        r = p->left;
                        p->left = p->right;
                        p->right = r;


@@ -863,7 +878,7 @@ optim2( p ) register NODE *p; {
        case ASG AND:
                /* change meaning of AND to ~R&L - bic on pdp11 */
                r = p->right;
        case ASG AND:
                /* change meaning of AND to ~R&L - bic on pdp11 */
                r = p->right;

-               if( r->op==ICON ) { /* compliment constant */
+               if( r->op==ICON && r->name[0]==0 ) { /* compliment constant */

                        r->lval = ~r->lval;
                        }
                else if( r->op==COMPL ) { /* ~~A => A */
                        r->lval = ~r->lval;
                        }
                else if( r->op==COMPL ) { /* ~~A => A */


@@ -883,36 +898,12 @@ optim2( p ) register NODE *p; {
                }
        }
 
                }
        }
 

-myreader(p) register NODE *p; {
-       walkf( p, hardops );    /* convert ops to function calls */
-       canon( p );             /* expands r-vals for fileds */
-       walkf( p, optim2 );
-       toff = 0;  /* stack offset swindle */
-       }
-
-special( p, shape ) register NODE *p; {
-       /* special shape matching routine */
-
-       switch( shape ) {
-
-       case SCCON:
-               if( p->op == ICON && p->name[0]=='\0' && p->lval>= -128 && p->lval <=127 ) return( 1 );
-               break;
-
-       case SICON:
-               if( p->op == ICON && p->name[0]=='\0' && p->lval>= 0 && p->lval <=32767 ) return( 1 );
-               break;
-
-       default:
-               cerror( "bad special shape" );
-
-               }
-
-       return( 0 );
-       }

 
 # ifndef ONEPASS
 main( argc, argv ) char *argv[]; {
        return( mainp2( argc, argv ) );
        }
 # endif
 
 # ifndef ONEPASS
 main( argc, argv ) char *argv[]; {
        return( mainp2( argc, argv ) );
        }
 # endif

+
+
+