projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Integrate argcompat into insout; rename locals in insout
[unix-history] / usr / src / old / as.vax / ascode.c
diff --git a/usr/src/old/as.vax/ascode.c b/usr/src/old/as.vax/ascode.c
index e5d9c50..39ec4af 100644 (file)
--- a/usr/src/old/as.vax/ascode.c
+++ b/usr/src/old/as.vax/ascode.c
@@ -1,84 +1,88 @@
 /* Copyright (c) 1980 Regents of the University of California */
 /* Copyright (c) 1980 Regents of the University of California */
-static char sccsid[] = "@(#)ascode.c 4.1 %G%";
+static char sccsid[] = "@(#)ascode.c 4.4 %G%";
 #include <stdio.h>
 #include <stdio.h>
-#include <sys/types.h>
-#include <a.out.h>
 #include "as.h"
 #include "assyms.h"
 
 insout(op, ap, nact)
        struct arg *ap;
 {
 #include "as.h"
 #include "assyms.h"
 
 insout(op, ap, nact)
        struct arg *ap;
 {
-       int jxxflg;
-
+       int             jxxflg;
+       register        struct  instab  *ip;            /* the instruction */
+       register        struct  arg     *ap_walk;       /* actual param walk */
+       register        int     i;
+       register        int     ap_type;                /* actual param type */
+       register        int     ap_type_mask;           /* masked actual param */
        op &= 0xFF;
        jxxflg = nact;
        if (nact < 0)
                nact = -nact;
        if (passno == 1) {
        op &= 0xFF;
        jxxflg = nact;
        if (nact < 0)
                nact = -nact;
        if (passno == 1) {
-               register struct arg     *ap2;
-               register struct instab  *ip;
-               int                     i,nexp;
-               ip = itab[op];
-               nexp = ip->nargs;
-               if (nact < nexp)
-                       yyerror("Too few arguments");
-               if (nact > nexp) {
-                       yyerror("Too many arguments");
-                       nact = nexp;
-               }
-               /*
-                *      Check argument compatability with instruction template
-                */
-               for (ap2 = ap+nact, i = nact; --i >= 0;)
-                       argcompat(--ap2, ip->argtype[i], i+1);
-       }
+           ip = itab[op];
+           if (nact < ip->i_nargs)
+               yyerror("Too few arguments");
+           if (nact > ip->i_nargs) {
+               yyerror("Too many arguments");
+               nact = ip->i_nargs;
+           }
+           /*
+            *  Check argument compatability with instruction template
+            */
+           for (ap_walk = ap, i = 1; i <= nact; ap_walk++, i++){
+               ap_type = ap_walk->a_type;
+               ap_type_mask = ap_type & AMASK;
+               switch( (fetcharg(ip, i-1)) & AMASK){   /* type of fp */
+               case ACCB:
+                       if ( !((ap_type_mask == AEXP) || (ap_type_mask == AIMM)) ){
+                               yyerror("arg %d, branch displacement must be an expression",i);
+                               return;
+                       }
+                       break;
+               case ACCA:
+                       switch(ap_type_mask){
+                       case AREG:      yyerror("arg %d, addressing a register",i);
+                                       return;
+                       case AIMM:      if ( !(ap_type & ASTAR) ){
+                                        yyerror("arg %d, addressing an immediate operand",i);
+                                        return;
+                                       }
+                       }
+                       break;
+               case ACCM:
+               case ACCW:
+                       switch(ap_type_mask){
+                       case AIMM:      if (!(ap_type&ASTAR)) {
+                                        yyerror("arg %d, modifying a constant",i);
+                                        return;
+                                       }
+                       }
+                       break;
+               }       /* end of the switch on fp_type */
+               if (ap_type & AINDX) {
+                       if (ap_walk->a_areg2==0xF) {
+                               yyerror("arg %d, PC used as index",i);
+                               return;
+                       }
+                       switch(ap_type_mask){
+                       case AREG:      yyerror("arg %d, indexing the register file",i);
+                                       return;
+                       case AIMM:      yyerror("arg %d, indexing a constant",i);
+                                       return;
+                       case DECR:
+                       case INCR:      if (ap_walk->a_areg1==ap_walk->a_areg2) {
+                                               yyerror("arg %d, indexing with modified register",i);
+                                               return;
+                                       }
+                                       break;
+                       }       /* end of switch on ap_type_mask */
+               } /* end of AINDX */
+          }
+       } /* both passes here */
        if (jxxflg < 0)
                ijxout(op, ap, nact);
        else putins(op, ap, nact);
 }
 
        if (jxxflg < 0)
                ijxout(op, ap, nact);
        else putins(op, ap, nact);
 }
 
-argcompat(act, exp, i)
-       struct arg *act;
-       int exp,i;
-{
-       register        at,atm;
-
-       at = act->atype;
-       atm = at & AMASK;
-
-       if ( (exp & ACCB) && (!((atm == AEXP) || (atm == AIMM))) ){
-               yyerror("arg %d, branch displacement must be an expression",i);
-               return;
-       }
-       if ((exp & ACCA) && (atm == AREG)) {
-               yyerror("arg %d, addressing a register",i);
-               return;
-       }
-       if ((exp&ACCW) && (atm==AIMM) && !(at&ASTAR)) {
-               yyerror("arg %d, modifying a constant",i);
-               return;
-       }
-       if (at & AINDX) {
-               if (act->areg2==017) {
-                       yyerror("arg %d, PC used as index",i);
-                       return;
-               }
-               if (atm==AREG) {
-                       yyerror("arg %d, indexing the register file",i);
-                       return;
-               }
-               if (atm==AIMM) {
-                       yyerror("arg %d, indexing a constant",i);
-                       return;
-               }
-               if (((atm==ADECR) || (atm==AINCR)) && (act->areg1==act->areg2)) {
-                       yyerror("arg %d, indexing with modified register",i);
-                       return;
-               }
-       }
-}
-
 extern int d124;
        int len124[] =  {0,LEN1,LEN2,0,LEN4};
        char mod124[] = {0,0x00,0x20,0,0x40};
 extern int d124;
        int len124[] =  {0,LEN1,LEN2,0,LEN4};
        char mod124[] = {0,0x00,0x20,0,0x40};
@@ -99,57 +103,55 @@ putins(op, ap, n)
        if (passno == 2)
                goto PASS2;
 
        if (passno == 2)
                goto PASS2;
 
-       dotp->xvalue += n+1;    /* 1 for the opcode, at least 1 per arg */
-       for (i=0; i<n; i++,ap++) {/* some args take more than 1 byte */
-           xtrab = 0;
-           a=ap->atype;
+       dotp->e_xvalue += n+1;          /* 1 for the opcode, at least 1 per arg */
+       for (i=0; i<n; i++,ap++) {      /* some args take more than 1 byte */
+           a = ap->a_atype;
            if (a & AINDX)
            if (a & AINDX)
-               dotp->xvalue++;
+               dotp->e_xvalue++;
            switch (a&~(AINDX|ASTAR)) {
                case AEXP: 
            switch (a&~(AINDX|ASTAR)) {
                case AEXP: 
-                       a = itab[op]->argtype[i];
+                       a = fetcharg(itab[op], i);
                        if (a == ACCB+TYPB)
                                break;
                        if (a==ACCB+TYPW){
                        if (a == ACCB+TYPB)
                                break;
                        if (a==ACCB+TYPW){
-                               dotp->xvalue++;
+                               dotp->e_xvalue++;
                                break;
                        }
                        /*
                         *      Reduces to PC relative
                         */
                                break;
                        }
                        /*
                         *      Reduces to PC relative
                         */
-                       xtrab++;
-                       dotp->xvalue += ap->dispsize;
+                       dotp->e_xvalue += ap->a_dispsize;
                        break;
                
                case ADISP: 
                        break;
                
                case ADISP: 
-                       xp=ap->xp;
-                       if ((xp->xtype&XTYPE)!=XABS || xp->xtype&XFORW){
-                               dotp->xvalue += ap->dispsize;
+                       xp=ap->a_xp;
+                       if ((xp->e_xtype&XTYPE)!=XABS || xp->e_xtype&XFORW){
+                               dotp->e_xvalue += ap->a_dispsize;
                                break;
                        }
                                break;
                        }
-                       if (xp->xvalue==0 && !(a&ASTAR))
+                       if (xp->e_xvalue==0 && !(a&ASTAR))
                                break;
                                break;
-                       dotp->xvalue++;
-                       if ((xp->xvalue<MINBYTE) || (xp->xvalue>MAXBYTE))
-                               dotp->xvalue++;
-                       if ((xp->xvalue<MINWORD) || (xp->xvalue>MAXWORD))
-                               dotp->xvalue += 2;
+                       dotp->e_xvalue++;
+                       if ((xp->e_xvalue<MINBYTE) || (xp->e_xvalue>MAXBYTE))
+                               dotp->e_xvalue++;
+                       if ((xp->e_xvalue<MINWORD) || (xp->e_xvalue>MAXWORD))
+                               dotp->e_xvalue += 2;
                        break;
 
                case AIMM: 
                        break;
 
                case AIMM: 
-                       if (ap->atype&ASTAR) a=TYPL;
+                       if (ap->a_atype&ASTAR) a=TYPL;
                        else {
                        else {
-                               a = itab[op]->argtype[i];
+                               a = fetcharg(itab[op], i);
                                if (a&ACCA)
                                        a = TYPL;
                                else
                                        a &= TYPMASK;
                                if (a&ACCA)
                                        a = TYPL;
                                else
                                        a &= TYPMASK;
-                               xp = ap->xp;
-                               if (   ((xp->xtype&XTYPE)==XABS)
-                                   && (!(xp->xtype&XFORW))
-                                   && (xp->xvalue>=0)
-                                   && (xp->xvalue<=63) 
-                                   && (xp->yvalue == 0)
+                               xp = ap->a_xp;
+                               if (   ((xp->e_xtype&XTYPE)==XABS)
+                                   && (!(xp->e_xtype&XFORW))
+                                   && (xp->e_xvalue>=0)
+                                   && (xp->e_xvalue<=63) 
+                                   && (xp->e_yvalue == 0)
                                    && (a != TYPD)
                                    && (a != TYPF)
                                )
                                    && (a != TYPD)
                                    && (a != TYPF)
                                )
@@ -158,23 +160,23 @@ putins(op, ap, n)
                        switch (a) {
                        case TYPD:
                        case TYPF:
                        switch (a) {
                        case TYPD:
                        case TYPF:
-                               if (   !(((xp->xtype&XTYPE)==XABS)
-                                   && (!(xp->xtype&XFORW))
+                               if (   !(((xp->e_xtype&XTYPE)==XABS)
+                                   && (!(xp->e_xtype&XFORW))
                                    && (slitflt(xp)))
                                ){
                                /* it is NOT short */
                                    && (slitflt(xp)))
                                ){
                                /* it is NOT short */
-                                       dotp->xvalue += ((a==TYPF)?
+                                       dotp->e_xvalue += ((a==TYPF)?
                                                4 : 8);
                                }
                                break;
                        case TYPQ: 
                                                4 : 8);
                                }
                                break;
                        case TYPQ: 
-                               dotp->xvalue += 8;break;
+                               dotp->e_xvalue += 8;break;
                        case TYPL:
                        case TYPL:
-                               dotp->xvalue += 4;break;
+                               dotp->e_xvalue += 4;break;
                        case TYPW: 
                        case TYPW: 
-                               dotp->xvalue += 2;break;
+                               dotp->e_xvalue += 2;break;
                        case TYPB: 
                        case TYPB: 
-                               dotp->xvalue += 1;break;
+                               dotp->e_xvalue += 1;break;
                        }       /*end of the switch on a*/
            }   /*end of the switch on the type*/
        }       /*end of looping for all arguments*/
                        }       /*end of the switch on a*/
            }   /*end of the switch on the type*/
        }       /*end of looping for all arguments*/
@@ -187,115 +189,115 @@ PASS2:
 #endif UNIX
 #ifdef VMS
        *vms_obj_ptr++ = -1; *vms_obj_ptr++ = (char)op;
 #endif UNIX
 #ifdef VMS
        *vms_obj_ptr++ = -1; *vms_obj_ptr++ = (char)op;
-       dotp->xvalue += 1;
+       dotp->e_xvalue += 1;
 #endif VMS
 
        for (i=0; i<n; i++,ap++) {/* now for the arguments */
 #endif VMS
 
        for (i=0; i<n; i++,ap++) {/* now for the arguments */
-               a=ap->atype;
-               xp=ap->xp;
+               a=ap->a_atype;
+               xp=ap->a_xp;
                xtrab=0;
                if (a&AINDX) {
 #ifdef UNIX
                xtrab=0;
                if (a&AINDX) {
 #ifdef UNIX
-                       { outb(0x40 | ap->areg2); }
+                       { outb(0x40 | ap->a_areg2); }
 #endif UNIX
 #ifdef VMS
                        { *vms_obj_ptr++ = -1;
 #endif UNIX
 #ifdef VMS
                        { *vms_obj_ptr++ = -1;
-                         *vms_obj_ptr++ = (0x40 | ap->areg2);
-                         dotp->xvalue += 1; }
+                         *vms_obj_ptr++ = (0x40 | ap->a_areg2);
+                         dotp->e_xvalue += 1; }
 #endif VMS
                        a &= ~AINDX;
                }
                if (a&ASTAR) {
 #endif VMS
                        a &= ~AINDX;
                }
                if (a&ASTAR) {
-                       ap->areg1 |= 0x10;
+                       ap->a_areg1 |= 0x10;
                        a &= ~ASTAR;
                }
                switch (a) {
                case AREG:              /* %r */
                        a &= ~ASTAR;
                }
                switch (a) {
                case AREG:              /* %r */
-                       ap->areg1 |= 0x50;
+                       ap->a_areg1 |= 0x50;
                        break; 
                case ABASE:             /* (%r) */
                        break; 
                case ABASE:             /* (%r) */
-                       ap->areg1 |= 0x60;
+                       ap->a_areg1 |= 0x60;
                        break; 
                case ADECR:             /* -(%r) */
                        break; 
                case ADECR:             /* -(%r) */
-                       ap->areg1 |= 0x70;
+                       ap->a_areg1 |= 0x70;
                        break; 
                        break; 
-               case AINCR:             /* (%r) */
-                       ap->areg1 |= 0x80;
+               case AINCR:             /* (%r)+ */
+                       ap->a_areg1 |= 0x80;
                        break;
                case AEXP: /* expr */
                        break;
                case AEXP: /* expr */
-                       a = itab[op]->argtype[i];
+                       a = fetcharg(itab[op], i);
                        if (a == ACCB+TYPB) {
                        if (a == ACCB+TYPB) {
-                               ap->areg1 = a = 
-                                       xp->xvalue - (dotp->xvalue + 1);
+                               ap->a_areg1 = a = 
+                                       xp->e_xvalue - (dotp->e_xvalue + 1);
                                if (a<MINBYTE || a>MAXBYTE)
                                        yyerror("Branch too far"); break;
                        }
                        if (a == ACCB+TYPW) {
                                if (a<MINBYTE || a>MAXBYTE)
                                        yyerror("Branch too far"); break;
                        }
                        if (a == ACCB+TYPW) {
-                               ap->areg1 = a = xp->xvalue
-                                       -= dotp->xvalue + 2;
-                               xp->xtype = XABS;
+                               ap->a_areg1 = a = xp->e_xvalue
+                                       -= dotp->e_xvalue + 2;
+                               xp->e_xtype = XABS;
                                if (a<MINWORD || a>MAXWORD) 
                                        yyerror("Branch too far");
                                if (a<MINWORD || a>MAXWORD) 
                                        yyerror("Branch too far");
-                               xp->xvalue = a>>8;
+                               xp->e_xvalue = a>>8;
                                xtrab = LEN1;
                                break;
                        }
                        /* reduces to expr(pc) mode */
                                xtrab = LEN1;
                                break;
                        }
                        /* reduces to expr(pc) mode */
-                       ap->areg1 |= (0xAF + mod124[ap->dispsize]);
-                       xtrab = len124[ap->dispsize]+PCREL;
+                       ap->a_areg1 |= (0xAF + mod124[ap->a_dispsize]);
+                       xtrab = len124[ap->a_dispsize]+PCREL;
                        break;
                
                case ADISP: /* expr(%r) */
                        break;
                
                case ADISP: /* expr(%r) */
-                       ap->areg1 |= 0xA0;
-                       if ((xp->xtype&XTYPE)!=XABS || xp->xtype&XFORW){
-                               ap->areg1 += mod124[ap->dispsize];
-                               xtrab=len124[ap->dispsize];
+                       ap->a_areg1 |= 0xA0;
+                       if ((xp->e_xtype&XTYPE)!=XABS || xp->e_xtype&XFORW){
+                               ap->a_areg1 += mod124[ap->a_dispsize];
+                               xtrab=len124[ap->a_dispsize];
                                break;
                        }
                                break;
                        }
-                       if (xp->xvalue==0 && !(ap->areg1&0x10)) {
-                               ap->areg1 ^= 0xC0;
+                       if (xp->e_xvalue==0 && !(ap->a_areg1&0x10)) {
+                               ap->a_areg1 ^= 0xC0;
                                break;
                        }
                        xtrab=LEN1;
                                break;
                        }
                        xtrab=LEN1;
-                       if ((xp->xvalue<MINBYTE) || (xp->xvalue>MAXBYTE)){
-                               ap->areg1 += 0x20;
+                       if ((xp->e_xvalue<MINBYTE) || (xp->e_xvalue>MAXBYTE)){
+                               ap->a_areg1 += 0x20;
                                xtrab=LEN2;
                        }
                                xtrab=LEN2;
                        }
-                       if ((xp->xvalue<MINWORD) || (xp->xvalue>MAXWORD)){
-                               ap->areg1 += 0x20;
+                       if ((xp->e_xvalue<MINWORD) || (xp->e_xvalue>MAXWORD)){
+                               ap->a_areg1 += 0x20;
                                xtrab=LEN4;
                        }
                        break;
                
                case AIMM:  /* $expr */
                                xtrab=LEN4;
                        }
                        break;
                
                case AIMM:  /* $expr */
-                       if (ap->atype&ASTAR)
+                       if (ap->a_atype&ASTAR)
                                a=TYPL;
                        else {
                                a=TYPL;
                        else {
-                               a = itab[op]->argtype[i];
+                               a = fetcharg(itab[op], i);
                                if (a&ACCA)
                                        a=TYPL;
                                else
                                        a &= TYPMASK;
                                if (a&ACCA)
                                        a=TYPL;
                                else
                                        a &= TYPMASK;
-                               if (    ( (xp->xtype&XTYPE) == XABS) 
-                                   && !(xp->xtype&XFORW)
-                                   &&  (xp->xvalue >= 0)
-                                   &&  (xp->xvalue <= 63)
-                                   &&  (xp->yvalue == 0)
+                               if (    ( (xp->e_xtype&XTYPE) == XABS) 
+                                   && !(xp->e_xtype&XFORW)
+                                   &&  (xp->e_xvalue >= 0)
+                                   &&  (xp->e_xvalue <= 63)
+                                   &&  (xp->e_yvalue == 0)
                                    &&  (a != TYPF)
                                    &&  (a != TYPD) ) {
                                    &&  (a != TYPF)
                                    &&  (a != TYPD) ) {
-                                       ap->areg1 = xp->xvalue;
+                                       ap->a_areg1 = xp->e_xvalue;
                                        break;
                                }
                        }
                                        break;
                                }
                        }
-                       ap->areg1 |= 0x8F;
+                       ap->a_areg1 |= 0x8F;
                        switch (a) {
                        case TYPD:
                        case TYPF:
                        switch (a) {
                        case TYPD:
                        case TYPF:
-                               if (   ((xp->xtype&XTYPE)==XABS)
-                                   && (!(xp->xtype&XFORW))
+                               if (   ((xp->e_xtype&XTYPE)==XABS)
+                                   && (!(xp->e_xtype&XFORW))
                                    && (slitflt(xp))
                                ){
                                    && (slitflt(xp))
                                ){
-                                       ap->areg1=extlitflt(xp);
+                                       ap->a_areg1=extlitflt(xp);
                                } else {
                                        xtrab = (a==TYPF) ? LEN4: LEN8;
                                }
                                } else {
                                        xtrab = (a==TYPF) ? LEN4: LEN8;
                                }
@@ -312,11 +314,11 @@ PASS2:
                 *      use the first byte to describe the argument
                 */
 #ifdef UNIX
                 *      use the first byte to describe the argument
                 */
 #ifdef UNIX
-               outb(ap->areg1);
+               outb(ap->a_areg1);
 #endif UNIX
 #ifdef VMS
 #endif UNIX
 #ifdef VMS
-               *vms_obj_ptr++ = -1; *vms_obj_ptr++ = (char)(ap->areg1);
-               dotp->xvalue += 1;
+               *vms_obj_ptr++ = -1; *vms_obj_ptr++ = (char)(ap->a_areg1);
+               dotp->e_xvalue += 1;
                if ((vms_obj_ptr-sobuf) > 400) {
                        write(objfil,sobuf,vms_obj_ptr-sobuf);
                        vms_obj_ptr=sobuf+1;
                if ((vms_obj_ptr-sobuf) > 400) {
                        write(objfil,sobuf,vms_obj_ptr-sobuf);
                        vms_obj_ptr=sobuf+1;
@@ -330,6 +332,6 @@ PASS2:
                         *      immediately follow the field xvalue, which
                         *      they do.
                         */
                         *      immediately follow the field xvalue, which
                         *      they do.
                         */
-                       outrel(&xp->xvalue, xtrab, xp->xtype, xp->xname);
+                       outrel(&xp->e_xvalue, xtrab, xp->e_xtype, xp->e_xname);
        }       /*end of the for to pick up all arguments*/
 }
        }       /*end of the for to pick up all arguments*/
 }
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.