*** /old/src/lib/pcc/mac2defs.h	Fri Jul 10 14:36:09 1981
--- /usr/src/lib/pcc/mac2defs.h	Sat Aug  3 08:21:19 1991
***************
*** 1,51 ****
! /*	PDP11 Registers */
  
! 	/* scratch registers */
! # define R0 0
! # define R1 1
  
! 	/* register variables */
! # define R2 2
! # define R3 3
! # define R4 4
  
! 	/* special purpose */
! # define R5 5	/* frame pointer */
! # define SP 6	/* stack pointer */
! # define PC 7	/* program counter */
  
! 	/* floating registers */
  
! # define FR0 8
! # define FR1 9
! # define FR2 10
! # define FR3 11
! # define FR4 12
! # define FR5 13
  
! # define SAVEREGION 8 /* number of bytes for save area */
  
! # define BYTEOFF(x) ((x)&01)
! # define wdal(k) (BYTEOFF(k)==0)
! # define BITOOR(x) ((x)>>3)  /* bit offset to oreg offset */
  
! # define REGSZ 14
  
! # define TMPREG R5
  
  
! # define STOARG(p)     /* just evaluate the arguments, and be done with it... */
! # define STOFARG(p)
! # define STOSTARG(p)
! # define genfcall(a,b) gencall(a,b)
! 
! 
! 	/* shape for constants between -128 and 127 */
! # define SCCON (SPECIAL+100)
! 	/* shape for constants between 0 and 32767 */
! # define SICON (SPECIAL+101)
! 
! # define MYREADER(p) myreader(p)
! extern int fltused;
! 	/* calls can be nested on the PDP-11 */
! # define NESTCALLS
--- 1,62 ----
! /*
!  * PDP11 Registers
!  */
  
! /*
!  * Scratch registers
!  */
! #define R0	0
! #define R1	1
  
! /*
!  * Register variables
!  */
! #define R2	2
! #define R3	3
! #define R4	4
  
! /*
!  * Special purpose registers
!  */
! #define R5	5	/* frame pointer */
! #define SP	6	/* stack pointer */
! #define PC	7	/* program counter */
  
! /* floating registers */
  
! #define FR0	8
! #define FR1	9
! #define FR2	10
! #define FR3	11
! #define FR4	12
! #define FR5	13
  
! #define REGSZ	14
! #define TMPREG	R5
  
! extern	int fregs;
! extern	int maxargs;
  
! #define BYTEOFF(x) ((x)&01)
! #define wdal(k)		(BYTEOFF(k)==0)		/* word align */
! #define BITOOR(x)	((x)>>3)		/* bit offset to oreg offset */
  
! /*
!  * Some macros used in store():
!  *	just evaluate the arguments, and be done with it...
!  */
! #define STOARG(p)
! #define STOFARG(p)
! #define STOSTARG(p)
! #define genfcall(a,b)	gencall(a,b)
  
+ /*
+  * Some short routines that get called an awful lot are actually macros.
+  */
+ #define	shltype(o, p) \
+ 	((o) == REG || (o) == NAME || (o) == ICON || \
+ 	 (o) == OREG || ((o) == UNARY MUL && shumul((p)->in.left)))
+ #define	ncopy(q, p)	((q)->in = (p)->in)
  
! #define MYREADER(p) myreader(p)
! int	optim2();
*** /old/src/lib/pcc/macdefs.h	Fri Jul 10 14:36:09 1981
--- /usr/src/lib/pcc/macdefs.h	Sun Aug  4 14:07:51 1991
***************
*** 1,67 ****
! # define makecc(val,i)  lastcon = i ? (val<<8)|lastcon : val  
  
! # define  ARGINIT 32 
! # define  AUTOINIT 48 
! # define  SZCHAR 8
! # define  SZINT 16
! # define  SZFLOAT 32
! # define  SZDOUBLE 64
! # define  SZLONG 32
! # define  SZSHORT 16
! # define SZPOINT 16
! # define ALCHAR 8
! # define ALINT 16
! # define ALFLOAT 16
! # define ALDOUBLE 16
! # define ALLONG 16
! # define ALSHORT 16
! # define ALPOINT 16
! # define ALSTRUCT 16
! # define  ALSTACK 16 
  
! /*	size in which constants are converted */
! /*	should be long if feasable */
  
! # define CONSZ long
! # define CONFMT "%Ld"
  
! /*	size in which offsets are kept
! /*	should be large enough to cover address space in bits
! */
  
! # define OFFSZ long
  
! /* 	character set macro */
  
! # define  CCTRANS(x) x
  
! /* register cookie for stack poINTer */
  
! # define  STKREG 5
  # define ARGREG 5
! 
! /*	maximum and minimum register variables */
! 
  # define MAXRVAR 4
  # define MINRVAR 2
  
! 	/* various standard pieces of code are used */
! # define STDPRTREE
! # define LABFMT "L%d"
  
! /* definition indicates automatics and/or temporaries
!    are on a negative growing stack */
  
! # define BACKAUTO
! # define BACKTEMP
! 
! # define RTOLBYTES
! # ifndef FORT
! # define ONEPASS
! # endif
! 
! # ifndef FORT
! # define EXIT dexit
! # endif
! 
! # define ENUMSIZE(high,low) INT
--- 1,68 ----
! #ifndef _MACDEFS_
! #define	_MACDEFS_
  
! #define makecc(val,i)  lastcon = i ? (val<<8)|lastcon : val  
  
! #define ARGINIT		32 
! #define AUTOINIT	0 
  
! /*
!  * Storage space requirements
!  */
! #define SZCHAR		8
! #define SZINT		16
! #define SZFLOAT		32
! #define SZDOUBLE	64
! #define SZLONG		32
! #define SZSHORT		16
! #define SZPOINT		16
  
! /*
!  * Alignment constraints
!  */
! #define ALCHAR		8
! #define ALINT		16
! #define ALFLOAT		16
! #define ALDOUBLE	16
! #define ALLONG		16
! #define ALSHORT		16
! #define ALPOINT		16
! #define ALSTRUCT	16
! #define ALSTACK		16
  
! typedef	long	CONSZ;		/* size in which constants are converted */
! typedef	long	OFFSZ;		/* size in which offsets are kept */
  
! #define CONFMT	"%ld"		/* format for printing constants */
! #define LABFMT	"L%d"		/* format for printing labels */
  
! #define CCTRANS(x) x		/* character set macro */
  
! /*
!  * Register cookies for stack pointer and argument pointer
!  */
  
! # define STKREG 5
  # define ARGREG 5
! /*
!  * Maximum and minimum register variables
!  */
  # define MAXRVAR 4
  # define MINRVAR 2
  
! #define BACKAUTO		/* stack grows negatively for automatics */
! #define BACKTEMP		/* stack grows negatively for temporaries */
! #ifdef	vax
! #define FIELDOPS		/* show field hardware support on VAX */
! #endif
! #define RTOLBYTES		/* bytes are numbered from right to left */
  
! #define ENUMSIZE(high,low) INT	/* enums are always stored in full int */
  
! #define ADDROREG
! #define FIXDEF(p) outstab(p)
! #define FIXARG(p) fixarg(p)
! #ifndef ncopy
! #define	ncopy(q, p)	((q)->in = (p)->in)
! #endif
! #endif
*** /old/src/lib/pcc/order.c	Fri Jul 10 14:36:10 1981
--- /usr/src/lib/pcc/order.c	Sat Aug  3 09:41:06 1991
***************
*** 1,4 ****
! # include "mfile2"
  
  int fltused = 0;
  
--- 1,4 ----
! # include "pass2.h"
  
  int fltused = 0;
  
***************
*** 6,57 ****
  	/* should the assignment op p be stored,
  	   given that it lies as the right operand of o
  	   (or the left, if o==UNARY MUL) */
! 	return( shltype(p->left->op, p->left ) );
  
  	}
  
  deltest( p ) register NODE *p; {
  	/* should we delay the INCR or DECR operation p */
! 	if( p->op == INCR && p->left->op == REG && spsz( p->left->type, p->right->lval ) ){
  		/* STARREG */
  		return( 0 );
  		}
  
! 	p = p->left;
! 	if( p->op == UNARY MUL ) p = p->left;
! 	return( p->op == NAME || p->op == OREG || p->op == REG );
  	}
  
  mkadrs(p) register NODE *p; {
  	register o;
  
! 	o = p->op;
  
  	if( asgop(o) ){
! 		if( p->left->su >= p->right->su ){
! 			if( p->left->op == UNARY MUL ){
! 				if( p->left->su > 0 )
! 					SETSTO( p->left->left, INTEMP );
  				else {
! 					if( p->right->su > 0 ) SETSTO( p->right, INTEMP );
  					else cerror( "store finds both sides trivial" );
  					}
  				}
! 			else if( p->left->op == FLD && p->left->left->op == UNARY MUL ){
! 				SETSTO( p->left->left->left, INTEMP );
  				}
  			else { /* should be only structure assignment */
! 				SETSTO( p->left, INTEMP );
  				}
  			}
! 		else SETSTO( p->right, INTEMP );
  		}
  	else {
! 		if( p->left->su > p->right->su ){
! 			SETSTO( p->left, INTEMP );
  			}
  		else {
! 			SETSTO( p->right, INTEMP );
  			}
  		}
  	}
--- 6,67 ----
  	/* should the assignment op p be stored,
  	   given that it lies as the right operand of o
  	   (or the left, if o==UNARY MUL) */
! 	return( shltype(p->in.left->in.op, p->in.left ) );
  
  	}
  
  deltest( p ) register NODE *p; {
  	/* should we delay the INCR or DECR operation p */
! 	if( p->in.op == INCR && p->in.left->in.op == REG && spsz( p->in.left->in.type, p->in.right->tn.lval ) ){
  		/* STARREG */
  		return( 0 );
  		}
  
! 	p = p->in.left;
! 	if( p->in.op == UNARY MUL ) p = p->in.left;
! 	return( p->in.op == NAME || p->in.op == OREG || p->in.op == REG );
  	}
  
+ autoincr( p ) NODE *p; {
+ 	register NODE *q = p->in.left;
+ 
+ 	if( q->in.op == INCR && q->in.left->in.op == REG &&
+ 	    ISPTR(q->in.type) && p->in.type == DECREF(q->in.type) &&
+ 	    tlen(p) == q->in.right->tn.lval ) return(1);
+ 
+ 	return(0);
+ 	}
+ 
  mkadrs(p) register NODE *p; {
  	register o;
  
! 	o = p->in.op;
  
  	if( asgop(o) ){
! 		if( p->in.left->in.su >= p->in.right->in.su ){
! 			if( p->in.left->in.op == UNARY MUL ){
! 				if( p->in.left->in.su > 0 )
! 					SETSTO( p->in.left->in.left, INTEMP );
  				else {
! 					if( p->in.right->in.su > 0 ) SETSTO( p->in.right, INTEMP );
  					else cerror( "store finds both sides trivial" );
  					}
  				}
! 			else if( p->in.left->in.op == FLD && p->in.left->in.left->in.op == UNARY MUL ){
! 				SETSTO( p->in.left->in.left->in.left, INTEMP );
  				}
  			else { /* should be only structure assignment */
! 				SETSTO( p->in.left, INTEMP );
  				}
  			}
! 		else SETSTO( p->in.right, INTEMP );
  		}
  	else {
! 		if( p->in.left->in.su > p->in.right->in.su ){
! 			SETSTO( p->in.left, INTEMP );
  			}
  		else {
! 			SETSTO( p->in.right, INTEMP );
  			}
  		}
  	}
***************
*** 61,67 ****
  	/* offset of off, (from a register of r), if the
  	/* resulting thing had type t */
  
! 	/* return( 1 );  /* NO */
  	return(0);  /* YES */
  	}
  
--- 71,77 ----
  	/* offset of off, (from a register of r), if the
  	/* resulting thing had type t */
  
! 	/* if( r == R0 ) return( 1 );  /* NO */
  	return(0);  /* YES */
  	}
  
***************
*** 80,104 ****
  
  	register su;
  
! 	su = p->su;
  
! 	switch( p->type ){
  
  	case CHAR:
  	case UCHAR:
  		if( !(zap&ZCHAR) ) break;
! 		if( su == 0 ) p->su = su = 1;
  		break;
  
  	case LONG:
  	case ULONG:
  		if( !(zap&ZLONG) ) break;
! 		if( p->op == UNARY MUL && su == 0 ) p->su = su = 2;
  		break;
  
  	case FLOAT:
  		if( !(zap&ZFLOAT) ) break;
! 		if( su == 0 ) p->su = su = 1;
  
  		}
  
--- 90,114 ----
  
  	register su;
  
! 	su = p->in.su;
  
! 	switch( p->in.type ){
  
  	case CHAR:
  	case UCHAR:
  		if( !(zap&ZCHAR) ) break;
! 		if( su == 0 ) p->in.su = su = 1;
  		break;
  
  	case LONG:
  	case ULONG:
  		if( !(zap&ZLONG) ) break;
! 		if( p->in.op == UNARY MUL && su == 0 ) p->in.su = su = 2;
  		break;
  
  	case FLOAT:
  		if( !(zap&ZFLOAT) ) break;
! 		if( su == 0 ) p->in.su = su = 1;
  
  		}
  
***************
*** 113,124 ****
  	register o, ty, sul, sur;
  	register nr;
  
! 	ty = optype( o=p->op);
! 	nr = szty( p->type );
! 	p->su = 0;
  
  	if( ty == LTYPE ) {
! 		if( p->type==FLOAT ) p->su = 1;
  		return;
  		}
  	else if( ty == UTYPE ){
--- 123,134 ----
  	register o, ty, sul, sur;
  	register nr;
  
! 	ty = optype( o=p->in.op);
! 	nr = szty( p->in.type );
! 	p->in.su = 0;
  
  	if( ty == LTYPE ) {
! 		if( p->in.type==FLOAT ) p->in.su = 1;
  		return;
  		}
  	else if( ty == UTYPE ){
***************
*** 125,138 ****
  		switch( o ) {
  		case UNARY CALL:
  		case UNARY STCALL:
! 			p->su = fregs;  /* all regs needed */
  			return;
  
  		case UNARY MUL:
! 			if( shumul( p->left ) ) return;
  
  		default:
! 			p->su = max( p->left->su, nr);
  			return;
  			}
  		}
--- 135,148 ----
  		switch( o ) {
  		case UNARY CALL:
  		case UNARY STCALL:
! 			p->in.su = fregs;  /* all regs needed */
  			return;
  
  		case UNARY MUL:
! 			if( shumul( p->in.left ) ) return;
  
  		default:
! 			p->in.su = max( p->in.left->in.su, nr);
  			return;
  			}
  		}
***************
*** 140,153 ****
  
  	/* If rhs needs n, lhs needs m, regular su computation */
  
! 	sul = p->left->su;
! 	sur = p->right->su;
  
  	if( o == ASSIGN ){
  		asop:  /* also used for +=, etc., to memory */
  		if( sul==0 ){
  			/* don't need to worry about the left side */
! 			p->su = max( sur, nr );
  			}
  		else {
  			/* right, left address, op */
--- 150,163 ----
  
  	/* If rhs needs n, lhs needs m, regular su computation */
  
! 	sul = p->in.left->in.su;
! 	sur = p->in.right->in.su;
  
  	if( o == ASSIGN ){
  		asop:  /* also used for +=, etc., to memory */
  		if( sul==0 ){
  			/* don't need to worry about the left side */
! 			p->in.su = max( sur, nr );
  			}
  		else {
  			/* right, left address, op */
***************
*** 154,164 ****
  			if( sur == 0 ){
  				/* just get the lhs address into a register, and mov */
  				/* the `nr' covers the case where value is in reg afterwards */
! 				p->su = max( sul, nr );
  				}
  			else {
  				/* right, left address, op */
! 				p->su = max( sur, nr+sul );
  				}
  			}
  		return;
--- 164,174 ----
  			if( sur == 0 ){
  				/* just get the lhs address into a register, and mov */
  				/* the `nr' covers the case where value is in reg afterwards */
! 				p->in.su = max( sul, nr );
  				}
  			else {
  				/* right, left address, op */
! 				p->in.su = max( sur, nr+sul );
  				}
  			}
  		return;
***************
*** 166,178 ****
  
  	if( o == CALL || o == STCALL ){
  		/* in effect, takes all free registers */
! 		p->su = fregs;
  		return;
  		}
  
  	if( o == STASG ){
  		/* right, then left */
! 		p->su = max( max( sul+nr, sur), fregs );
  		return;
  		}
  
--- 176,188 ----
  
  	if( o == CALL || o == STCALL ){
  		/* in effect, takes all free registers */
! 		p->in.su = fregs;
  		return;
  		}
  
  	if( o == STASG ){
  		/* right, then left */
! 		p->in.su = max( max( sul+nr, sur), fregs );
  		return;
  		}
  
***************
*** 181,190 ****
  		/* left then right, max(sul,sur+nr) */
  		/* right then left, max(sur,sul+nr) */
  		/* to hold both sides in regs: nr+nr */
! 		nr = szty( p->left->type );
! 		sul = zum( p->left, ZLONG|ZCHAR|ZFLOAT );
! 		sur = zum( p->right, ZLONG|ZCHAR|ZFLOAT );
! 		p->su = min( max(sul,sur+nr), max(sur,sul+nr) );
  		return;
  		}
  
--- 191,200 ----
  		/* left then right, max(sul,sur+nr) */
  		/* right then left, max(sur,sul+nr) */
  		/* to hold both sides in regs: nr+nr */
! 		nr = szty( p->in.left->in.type );
! 		sul = zum( p->in.left, ZLONG|ZCHAR|ZFLOAT );
! 		sur = zum( p->in.right, ZLONG|ZCHAR|ZFLOAT );
! 		p->in.su = min( max(sul,sur+nr), max(sur,sul+nr) );
  		return;
  		}
  
***************
*** 199,205 ****
  		case ASG DIV:
  		case ASG MOD:
  		case ASG MUL:
! 			if( p->type!=FLOAT && p->type!=DOUBLE ) nr = fregs;
  			goto gencase;
  
  		case ASG PLUS:
--- 209,215 ----
  		case ASG DIV:
  		case ASG MOD:
  		case ASG MUL:
! 			if( p->in.type!=FLOAT && p->in.type!=DOUBLE ) nr = fregs;
  			goto gencase;
  
  		case ASG PLUS:
***************
*** 206,228 ****
  		case ASG MINUS:
  		case ASG AND:  /* really bic */
  		case ASG OR:
! 			if( p->type == INT || p->type == UNSIGNED || ISPTR(p->type) ) goto asop;
  
  		gencase:
  		default:
! 			sur = zum( p->right, ZCHAR|ZLONG|ZFLOAT );
  			if( sur == 0 ){ /* easy case: if addressable,
  				do left value, op, store */
! 				if( sul == 0 ) p->su = nr;
  				/* harder: left adr, val, op, store */
! 				else p->su = max( sul, nr+1 );
  				}
  			else { /* do right, left adr, left value, op, store */
  				if( sul == 0 ){  /* right, left value, op, store */
! 					p->su = max( sur, nr+nr );
  					}
  				else {
! 					p->su = max( sur, max( sul+nr, 1+nr+nr ) );
  					}
  				}
  			return;
--- 216,238 ----
  		case ASG MINUS:
  		case ASG AND:  /* really bic */
  		case ASG OR:
! 			if( p->in.type == INT || p->in.type == UNSIGNED || ISPTR(p->in.type) ) goto asop;
  
  		gencase:
  		default:
! 			sur = zum( p->in.right, ZCHAR|ZLONG|ZFLOAT );
  			if( sur == 0 ){ /* easy case: if addressable,
  				do left value, op, store */
! 				if( sul == 0 ) p->in.su = nr;
  				/* harder: left adr, val, op, store */
! 				else p->in.su = max( sul, nr+1 );
  				}
  			else { /* do right, left adr, left value, op, store */
  				if( sul == 0 ){  /* right, left value, op, store */
! 					p->in.su = max( sur, nr+nr );
  					}
  				else {
! 					p->in.su = max( sur, max( sul+nr, 1+nr+nr ) );
  					}
  				}
  			return;
***************
*** 235,246 ****
  	case QUEST:
  	case COLON:
  	case COMOP:
! 		p->su = max( max(sul,sur), nr);
  		return;
  		}
  
  	if( ( o==DIV || o==MOD || o==MUL )
! 	    && p->type!=FLOAT && p->type!=DOUBLE ) nr = fregs;
  	if( o==PLUS || o==MUL || o==OR || o==ER ){
  		/* AND is ruined by the hardware */
  		/* permute: get the harder on the left */
--- 245,256 ----
  	case QUEST:
  	case COLON:
  	case COMOP:
! 		p->in.su = max( max(sul,sur), nr);
  		return;
  		}
  
  	if( ( o==DIV || o==MOD || o==MUL )
! 	    && p->in.type!=FLOAT && p->in.type!=DOUBLE ) nr = fregs;
  	if( o==PLUS || o==MUL || o==OR || o==ER ){
  		/* AND is ruined by the hardware */
  		/* permute: get the harder on the left */
***************
*** 247,259 ****
  
  		register rt, lt;
  
! 		if( istnode( p->left ) || sul > sur ) goto noswap;  /* don't do it! */
  
  		/* look for a funny type on the left, one on the right */
  
  
! 		lt = p->left->type;
! 		rt = p->right->type;
  
  		if( rt == FLOAT && lt == DOUBLE ) goto swap;
  
--- 257,269 ----
  
  		register rt, lt;
  
! 		if( istnode( p->in.left ) || sul > sur ) goto noswap;  /* don't do it! */
  
  		/* look for a funny type on the left, one on the right */
  
  
! 		lt = p->in.left->in.type;
! 		rt = p->in.right->in.type;
  
  		if( rt == FLOAT && lt == DOUBLE ) goto swap;
  
***************
*** 262,272 ****
  		if( lt==LONG || lt==ULONG ){
  			if( rt==LONG || rt==ULONG ){
  				/* if one is a STARNM, swap */
! 				if( p->left->op == UNARY MUL && sul==0 ) goto noswap;
! 				if( p->right->op == UNARY MUL && p->left->op != UNARY MUL ) goto swap;
  				goto noswap;
  				}
! 			else if( p->left->op == UNARY MUL && sul == 0 ) goto noswap;
  			else goto swap;  /* put long on right, unless STARNM */
  			}
  
--- 272,282 ----
  		if( lt==LONG || lt==ULONG ){
  			if( rt==LONG || rt==ULONG ){
  				/* if one is a STARNM, swap */
! 				if( p->in.left->in.op == UNARY MUL && sul==0 ) goto noswap;
! 				if( p->in.right->in.op == UNARY MUL && p->in.left->in.op != UNARY MUL ) goto swap;
  				goto noswap;
  				}
! 			else if( p->in.left->in.op == UNARY MUL && sul == 0 ) goto noswap;
  			else goto swap;  /* put long on right, unless STARNM */
  			}
  
***************
*** 279,297 ****
  
  		swap:
  			ssu = sul;  sul = sur; sur = ssu;
! 			s = p->left;  p->left = p->right; p->right = s;
  			}
  		}
  	noswap:
  
! 	sur = zum( p->right, ZCHAR|ZLONG|ZFLOAT );
  	if( sur == 0 ){
  		/* get left value into a register, do op */
! 		p->su = max( nr, sul );
  		}
  	else {
  		/* do harder into a register, then easier */
! 		p->su = max( nr+nr, min( max( sul, nr+sur ), max( sur, nr+sul ) ) );
  		}
  	}
  
--- 289,307 ----
  
  		swap:
  			ssu = sul;  sul = sur; sur = ssu;
! 			s = p->in.left;  p->in.left = p->in.right; p->in.right = s;
  			}
  		}
  	noswap:
  
! 	sur = zum( p->in.right, ZCHAR|ZLONG|ZFLOAT );
  	if( sur == 0 ){
  		/* get left value into a register, do op */
! 		p->in.su = max( nr, sul );
  		}
  	else {
  		/* do harder into a register, then easier */
! 		p->in.su = max( nr+nr, min( max( sul, nr+sur ), max( sur, nr+sul ) ) );
  		}
  	}
  
***************
*** 301,320 ****
  	/* insure that the use of p gets done with register r; in effect, */
  	/* simulate offstar */
  
! 	if( p->op == FLD ){
! 		p->left->rall = p->rall;
! 		p = p->left;
  		}
  
! 	if( p->op != UNARY MUL ) return;  /* no more to do */
! 	p = p->left;
! 	if( p->op == UNARY MUL ){
! 		p->rall = r;
! 		p = p->left;
  		}
! 	if( p->op == PLUS && p->right->op == ICON ){
! 		p->rall = r;
! 		p = p->left;
  		}
  	rallo( p, r );
  	}
--- 311,330 ----
  	/* insure that the use of p gets done with register r; in effect, */
  	/* simulate offstar */
  
! 	if( p->in.op == FLD ){
! 		p->in.left->in.rall = p->in.rall;
! 		p = p->in.left;
  		}
  
! 	if( p->in.op != UNARY MUL ) return;  /* no more to do */
! 	p = p->in.left;
! 	if( p->in.op == UNARY MUL ){
! 		p->in.rall = r;
! 		p = p->in.left;
  		}
! 	if( p->in.op == PLUS && p->in.right->in.op == ICON ){
! 		p->in.rall = r;
! 		p = p->in.left;
  		}
  	rallo( p, r );
  	}
***************
*** 326,336 ****
  	if( radebug ) printf( "rallo( %o, %o )\n", p, down );
  
  	down2 = NOPREF;
! 	p->rall = down;
  	down1 = ( down &= ~MUSTDO );
  
! 	ty = optype( o = p->op );
! 	type = p->type;
  
  
  	if( type == DOUBLE || type == FLOAT ){
--- 336,346 ----
  	if( radebug ) printf( "rallo( %o, %o )\n", p, down );
  
  	down2 = NOPREF;
! 	p->in.rall = down;
  	down1 = ( down &= ~MUSTDO );
  
! 	ty = optype( o = p->in.op );
! 	type = p->in.type;
  
  
  	if( type == DOUBLE || type == FLOAT ){
***************
*** 355,368 ****
  			}
  		/* at least 3 regs free */
  		/* compute lhs in (r0,r1), address of left in r2 */
! 		p->left->rall = R1|MUSTDO;
! 		mkrall( p->left, R2|MUSTDO );
  		/* now, deal with right */
! 		if( fregs == 3 ) rallo( p->right, NOPREF );
  		else {
  			/* put address of long or value here */
! 			p->right->rall = R3|MUSTDO;
! 			mkrall( p->right, R3|MUSTDO );
  			}
  		return;
  
--- 365,378 ----
  			}
  		/* at least 3 regs free */
  		/* compute lhs in (r0,r1), address of left in r2 */
! 		p->in.left->in.rall = R1|MUSTDO;
! 		mkrall( p->in.left, R2|MUSTDO );
  		/* now, deal with right */
! 		if( fregs == 3 ) rallo( p->in.right, NOPREF );
  		else {
  			/* put address of long or value here */
! 			p->in.right->in.rall = R3|MUSTDO;
! 			mkrall( p->in.right, R3|MUSTDO );
  			}
  		return;
  
***************
*** 369,384 ****
  	case MUL:
  	case DIV:
  	case MOD:
! 		rallo( p->left, R1|MUSTDO );
  
  		if( fregs == 2 ){
! 			rallo( p->right, NOPREF );
  			return;
  			}
  		/* compute addresses, stay away from (r0,r1) */
  
! 		p->right->rall = (fregs==3) ? R2|MUSTDO : R3|MUSTDO ;
! 		mkrall( p->right, R2|MUSTDO );
  		return;
  
  	case CALL:
--- 379,394 ----
  	case MUL:
  	case DIV:
  	case MOD:
! 		rallo( p->in.left, R1|MUSTDO );
  
  		if( fregs == 2 ){
! 			rallo( p->in.right, NOPREF );
  			return;
  			}
  		/* compute addresses, stay away from (r0,r1) */
  
! 		p->in.right->in.rall = (fregs==3) ? R2|MUSTDO : R3|MUSTDO ;
! 		mkrall( p->in.right, R2|MUSTDO );
  		return;
  
  	case CALL:
***************
*** 401,445 ****
  
  		}
  
! 	if( ty != LTYPE ) rallo( p->left, down1 );
! 	if( ty == BITYPE ) rallo( p->right, down2 );
  
  	}
  
  offstar( p ) register NODE *p; {
! 	/* handle indirections */
! 
! 	if( p->op == UNARY MUL ) p = p->left;
! 
! 	if( p->op == PLUS || p->op == MINUS ){
! 		if( p->right->op == ICON ){
! 			order( p->left , INTAREG|INAREG );
  			return;
  			}
  		}
  	order( p, INTAREG|INAREG );
  	}
  
! setincr( p ) NODE *p; {
! 	return( 0 );	/* for the moment, don't bother */
  	}
  
  niceuty( p ) register NODE *p; {
  	register TWORD t;
  
! 	return( p->op == UNARY MUL && (t=p->type)!=CHAR &&
  		t!= UCHAR && t!= FLOAT &&
! 		shumul( p->left) != STARREG );
  	}
  setbin( p ) register NODE *p; {
  	register NODE *r, *l;
  
! 	r = p->right;
! 	l = p->left;
  
! 	if( p->right->su == 0 ){ /* rhs is addressable */
! 		if( logop( p->op ) ){
! 			if( l->op == UNARY MUL && l->type != FLOAT && shumul( l->left ) != STARREG ) offstar( l->left );
  			else order( l, INAREG|INTAREG|INBREG|INTBREG|INTEMP );
  			return( 1 );
  			}
--- 411,492 ----
  
  		}
  
! 	if( ty != LTYPE ) rallo( p->in.left, down1 );
! 	if( ty == BITYPE ) rallo( p->in.right, down2 );
  
  	}
  
  offstar( p ) register NODE *p; {
! 	if( p->in.op == PLUS ) {
! 		if( p->in.left->in.su == fregs ) {
! 			order( p->in.left, INTAREG|INAREG );
  			return;
+ 		} else if( p->in.right->in.su == fregs ) {
+ 			order( p->in.right, INTAREG|INAREG );
+ 			return;
+ 		}
+ 		if( p->in.left->in.op==LS && 
+ 		  (p->in.left->in.left->in.op!=REG || tlen(p->in.left->in.left)!=sizeof(int) ) ) {
+ 			order( p->in.left->in.left, INTAREG|INAREG );
+ 			return;
+ 		}
+ 		if( p->in.right->in.op==LS &&
+ 		  (p->in.right->in.left->in.op!=REG || tlen(p->in.right->in.left)!=sizeof(int) ) ) {
+ 			order( p->in.right->in.left, INTAREG|INAREG );
+ 			return;
+ 		}
+ 		if( p->in.type == (PTR|CHAR) || p->in.type == (PTR|UCHAR) ) {
+ 			if( p->in.left->in.op!=REG || tlen(p->in.left)!=sizeof(int) ) {
+ 				order( p->in.left, INTAREG|INAREG );
+ 				return;
  			}
+ 			else if( p->in.right->in.op!=REG || tlen(p->in.right)!=sizeof(int) ) {
+ 				order(p->in.right, INTAREG|INAREG);
+ 				return;
+ 			}
  		}
+ 	}
+ 	if( p->in.op == PLUS || p->in.op == MINUS ){
+ 		if( p->in.right->in.op == ICON ){
+ 			p = p->in.left;
+ 			order( p , INTAREG|INAREG);
+ 			return;
+ 			}
+ 		}
+ 
+ 	if( p->in.op == UNARY MUL && !canaddr(p) ) {
+ 		offstar( p->in.left );
+ 		return;
+ 	}
+ 
  	order( p, INTAREG|INAREG );
  	}
  
! setincr( p ) register NODE *p; {
! 	p = p->in.left;
! 	if( p->in.op == UNARY MUL ){
! 		offstar( p );
! 		return( 1 );
! 		}
! 	return( 0 );
  	}
  
  niceuty( p ) register NODE *p; {
  	register TWORD t;
  
! 	return( p->in.op == UNARY MUL && (t=p->in.type)!=CHAR &&
  		t!= UCHAR && t!= FLOAT &&
! 		shumul( p->in.left) != STARREG );
  	}
  setbin( p ) register NODE *p; {
  	register NODE *r, *l;
  
! 	r = p->in.right;
! 	l = p->in.left;
  
! 	if( p->in.right->in.su == 0 ){ /* rhs is addressable */
! 		if( logop( p->in.op ) ){
! 			if( l->in.op == UNARY MUL && l->in.type != FLOAT && shumul( l->in.left ) != STARREG ) offstar( l->in.left );
  			else order( l, INAREG|INTAREG|INBREG|INTBREG|INTEMP );
  			return( 1 );
  			}
***************
*** 453,464 ****
  	/* now, rhs is complicated: must do both sides into registers */
  	/* do the harder side first */
  
! 	if( logop( p->op ) ){
  		/* relational: do both sides into regs if need be */
  
! 		if( r->su > l->su ){
  			if( niceuty(r) ){
! 				offstar( r->left );
  				return( 1 );
  				}
  			else if( !istnode( r ) ){
--- 500,511 ----
  	/* now, rhs is complicated: must do both sides into registers */
  	/* do the harder side first */
  
! 	if( logop( p->in.op ) ){
  		/* relational: do both sides into regs if need be */
  
! 		if( r->in.su > l->in.su ){
  			if( niceuty(r) ){
! 				offstar( r->in.left );
  				return( 1 );
  				}
  			else if( !istnode( r ) ){
***************
*** 467,477 ****
  				}
  			}
  		if( niceuty(l) ){
! 			offstar( l->left );
  			return( 1 );
  			}
  		else if( niceuty(r) ){
! 			offstar( r->left );
  			return( 1 );
  			}
  		else if( !istnode( l ) ){
--- 514,524 ----
  				}
  			}
  		if( niceuty(l) ){
! 			offstar( l->in.left );
  			return( 1 );
  			}
  		else if( niceuty(r) ){
! 			offstar( r->in.left );
  			return( 1 );
  			}
  		else if( !istnode( l ) ){
***************
*** 482,496 ****
  			order( r, INTAREG|INAREG|INTBREG|INBREG|INTEMP );
  			return( 1 );
  			}
! 		cerror( "setbin can't deal with %s", opst[p->op] );
  		}
  
  	/* ordinary operator */
  
! 	if( !istnode(r) && r->su > l->su ){
  		/* if there is a chance of making it addressable, try it... */
  		if( niceuty(r) ){
! 			offstar( r->left );
  			return( 1 );  /* hopefully, it is addressable by now */
  			}
  		order( r, INTAREG|INAREG|INTBREG|INBREG|INTEMP );  /* anything goes on rhs */
--- 529,543 ----
  			order( r, INTAREG|INAREG|INTBREG|INBREG|INTEMP );
  			return( 1 );
  			}
! 		cerror( "setbin can't deal with %s", opst[p->in.op] );
  		}
  
  	/* ordinary operator */
  
! 	if( !istnode(r) && r->in.su > l->in.su ){
  		/* if there is a chance of making it addressable, try it... */
  		if( niceuty(r) ){
! 			offstar( r->in.left );
  			return( 1 );  /* hopefully, it is addressable by now */
  			}
  		order( r, INTAREG|INAREG|INTBREG|INBREG|INTEMP );  /* anything goes on rhs */
***************
*** 507,520 ****
  	}
  
  setstr( p ) register NODE *p; { /* structure assignment */
! 	if( p->right->op != REG ){
! 		order( p->right, INTAREG );
  		return(1);
  		}
! 	p = p->left;
! 	if( p->op != NAME && p->op != OREG ){
! 		if( p->op != UNARY MUL ) cerror( "bad setstr" );
! 		order( p->left, INTAREG );
  		return( 1 );
  		}
  	return( 0 );
--- 554,567 ----
  	}
  
  setstr( p ) register NODE *p; { /* structure assignment */
! 	if( p->in.right->in.op != REG ){
! 		order( p->in.right, INTAREG );
  		return(1);
  		}
! 	p = p->in.left;
! 	if( p->in.op != NAME && p->in.op != OREG ){
! 		if( p->in.op != UNARY MUL ) cerror( "bad setstr" );
! 		order( p->in.left, INTAREG );
  		return( 1 );
  		}
  	return( 0 );
***************
*** 523,550 ****
  setasg( p ) register NODE *p; {
  	/* setup for assignment operator */
  
! 	if( p->right->su != 0 && p->right->op != REG ) {
! 		if( p->right->op == UNARY MUL )
! 			offstar( p->right->left );
  		else
! 			order( p->right, INAREG|INBREG|SOREG|SNAME|SCON );
  		return(1);
  		}
! 	if( p->right->op != REG && ( p->type == FLOAT || p->type == DOUBLE ) ) {
! 		order( p->right, INBREG );
  		return(1);
  		}
! 	if( p->left->op == UNARY MUL && !tshape( p->left, STARREG|STARNM ) ){
! 		offstar( p->left->left );
  		return(1);
  		}
! 	if( p->left->op == FLD && p->left->left->op == UNARY MUL ){
! 		offstar( p->left->left->left );
  		return(1);
  		}
  	/* if things are really strange, get rhs into a register */
! 	if( p->right->op != REG ){
! 		order( p->right, INAREG|INBREG );
  		return( 1 );
  		}
  	return(0);
--- 570,597 ----
  setasg( p ) register NODE *p; {
  	/* setup for assignment operator */
  
! 	if( p->in.right->in.su != 0 && p->in.right->in.op != REG ) {
! 		if( p->in.right->in.op == UNARY MUL )
! 			offstar( p->in.right->in.left );
  		else
! 			order( p->in.right, INAREG|INBREG|SOREG|SNAME|SCON );
  		return(1);
  		}
! 	if( p->in.right->in.op != REG && ( p->in.type == FLOAT || p->in.type == DOUBLE ) ) {
! 		order( p->in.right, INBREG );
  		return(1);
  		}
! 	if( p->in.left->in.op == UNARY MUL && !tshape( p->in.left, STARREG|STARNM ) ){
! 		offstar( p->in.left->in.left );
  		return(1);
  		}
! 	if( p->in.left->in.op == FLD && p->in.left->in.left->in.op == UNARY MUL ){
! 		offstar( p->in.left->in.left->in.left );
  		return(1);
  		}
  	/* if things are really strange, get rhs into a register */
! 	if( p->in.right->in.op != REG ){
! 		order( p->in.right, INAREG|INBREG );
  		return( 1 );
  		}
  	return(0);
***************
*** 555,579 ****
  	register sul, sur;
  	register NODE *q, *p2;
  
! 	sul = p->left->su;
! 	sur = p->right->su;
  
! 	switch( p->op ){
  
  	case ASG PLUS:
  	case ASG OR:
  	case ASG MINUS:
! 		if( p->type != INT && p->type != UNSIGNED && !ISPTR(p->type) ) break;
! 		if( p->right->type == CHAR || p->right->type == UCHAR ){
! 			order( p->right, INAREG );
  			return( 1 );
  			}
  		break;
  
  	case ASG ER:
! 		if( sul == 0 || p->left->op == REG ){
! 			if( p->left->type == CHAR || p->left->type == UCHAR ) goto rew;  /* rewrite */
! 			order( p->right, INAREG|INBREG );
  			return( 1 );
  			}
  		goto leftadr;
--- 602,626 ----
  	register sul, sur;
  	register NODE *q, *p2;
  
! 	sul = p->in.left->in.su;
! 	sur = p->in.right->in.su;
  
! 	switch( p->in.op ){
  
  	case ASG PLUS:
  	case ASG OR:
  	case ASG MINUS:
! 		if( p->in.type != INT && p->in.type != UNSIGNED && !ISPTR(p->in.type) ) break;
! 		if( p->in.right->in.type == CHAR || p->in.right->in.type == UCHAR ){
! 			order( p->in.right, INAREG );
  			return( 1 );
  			}
  		break;
  
  	case ASG ER:
! 		if( sul == 0 || p->in.left->in.op == REG ){
! 			if( p->in.left->in.type == CHAR || p->in.left->in.type == UCHAR ) goto rew;  /* rewrite */
! 			order( p->in.right, INAREG|INBREG );
  			return( 1 );
  			}
  		goto leftadr;
***************
*** 587,631 ****
  
  		/* harder; make aleft address, val, op, and store */
  
! 		if( p->left->op == UNARY MUL ){
! 			offstar( p->left->left );
  			return( 1 );
  			}
! 		if( p->left->op == FLD && p->left->left->op == UNARY MUL ){
! 			offstar( p->left->left->left );
  			return( 1 );
  			}
  	rew:	/* rewrite, accounting for autoincrement and autodecrement */
  
! 		q = p->left;
! 		if( q->op == FLD ) q = q->left;
! 		if( q->op != UNARY MUL || shumul(q->left) != STARREG ) return(0); /* let reader.c do it */
  
  		/* mimic code from reader.c */
  
  		p2 = tcopy( p );
! 		p->op = ASSIGN;
! 		reclaim( p->right, RNULL, 0 );
! 		p->right = p2;
  
  		/* now, zap INCR on right, ASG MINUS on left */
  
! 		if( q->left->op == INCR ){
! 			q = p2->left;
! 			if( q->op == FLD ) q = q->left;
! 			if( q->left->op != INCR ) cerror( "bad incr rewrite" );
  			}
! 		else if( q->left->op != ASG MINUS )  cerror( " bad -= rewrite" );
  
! 		q->left->right->op = FREE;
! 		q->left->op = FREE;
! 		q->left = q->left->left;
  
  		/* now, resume reader.c rewriting code */
  
  		canon(p);
! 		rallo( p, p->rall );
! 		order( p2->left, INTBREG|INTAREG );
  		order( p2, INTBREG|INTAREG );
  		return( 1 );
  		}
--- 634,678 ----
  
  		/* harder; make aleft address, val, op, and store */
  
! 		if( p->in.left->in.op == UNARY MUL ){
! 			offstar( p->in.left->in.left );
  			return( 1 );
  			}
! 		if( p->in.left->in.op == FLD && p->in.left->in.left->in.op == UNARY MUL ){
! 			offstar( p->in.left->in.left->in.left );
  			return( 1 );
  			}
  	rew:	/* rewrite, accounting for autoincrement and autodecrement */
  
! 		q = p->in.left;
! 		if( q->in.op == FLD ) q = q->in.left;
! 		if( q->in.op != UNARY MUL || shumul(q->in.left) != STARREG ) return(0); /* let reader.c do it */
  
  		/* mimic code from reader.c */
  
  		p2 = tcopy( p );
! 		p->in.op = ASSIGN;
! 		reclaim( p->in.right, RNULL, 0 );
! 		p->in.right = p2;
  
  		/* now, zap INCR on right, ASG MINUS on left */
  
! 		if( q->in.left->in.op == INCR ){
! 			q = p2->in.left;
! 			if( q->in.op == FLD ) q = q->in.left;
! 			if( q->in.left->in.op != INCR ) cerror( "bad incr rewrite" );
  			}
! 		else if( q->in.left->in.op != ASG MINUS )  cerror( " bad -= rewrite" );
  
! 		q->in.left->in.right->in.op = FREE;
! 		q->in.left->in.op = FREE;
! 		q->in.left = q->in.left->in.left;
  
  		/* now, resume reader.c rewriting code */
  
  		canon(p);
! 		rallo( p, p->in.rall );
! 		order( p2->in.left, INTBREG|INTAREG );
  		order( p2, INTBREG|INTAREG );
  		return( 1 );
  		}
***************
*** 632,651 ****
  
  	/* harder case: do right, left address, left value, op, store */
  
! 	if( p->right->op == UNARY MUL ){
! 		offstar( p->right->left );
  		return( 1 );
  		}
  	/* sur> 0, since otherwise, done above */
! 	if( p->right->op == REG ) goto leftadr;  /* make lhs addressable */
! 	order( p->right, INAREG|INBREG );
  	return( 1 );
  	}
  
! int crslab = 10000;
  
  getlab(){
! 	return( crslab++ );
  	}
  
  deflab( l ){
--- 679,698 ----
  
  	/* harder case: do right, left address, left value, op, store */
  
! 	if( p->in.right->in.op == UNARY MUL ){
! 		offstar( p->in.right->in.left );
  		return( 1 );
  		}
  	/* sur> 0, since otherwise, done above */
! 	if( p->in.right->in.op == REG ) goto leftadr;  /* make lhs addressable */
! 	order( p->in.right, INAREG|INBREG );
  	return( 1 );
  	}
  
! int crslab = 32767;
  
  getlab(){
! 	return( crslab-- );
  	}
  
  deflab( l ){
***************
*** 652,696 ****
  	printf( "L%d:\n", l );
  	}
  
! genargs( p) register NODE *p; {
  	register size;
  
  	/* generate code for the arguments */
  
! 	/*  first, do the arguments on the right (last->first) */
! 	while( p->op == CM ){
! 		genargs( p->right );
! 		p->op = FREE;
! 		p = p->left;
  		}
  
! 	if( p->op == STARG ){ /* structure valued argument */
  
! 		size = p->stsize;
! 		if( p->left->op == ICON ){
! 			/* make into a name node */
! 			p->op = FREE;
! 			p= p->left;
! 			p->op = NAME;
  			}
  		else {
  			/* make it look beautiful... */
! 			p->op = UNARY MUL;
  			canon( p );  /* turn it into an oreg */
! 			if( p->op != OREG ){
! 				offstar( p->left );
  				canon( p );
- 				if( p->op != OREG ) cerror( "stuck starg" );
  				}
  			}
  
! 		p->lval += size;  /* end of structure */
! 		/* put on stack backwards */
! 		for( ; size>0; size -= 2 ){
! 			p->lval -= 2;
! 			expand( p, RNOP, "	mov	AR,Z-\n" );
! 			}
! 		reclaim( p, RNULL, 0 );
  		return;
  		}
  
--- 699,746 ----
  	printf( "L%d:\n", l );
  	}
  
! genargs( p ) register NODE *p; {
! 	register NODE *pasg;
! 	register align;
  	register size;
+ 	int count;
  
  	/* generate code for the arguments */
  
! 	/*  first, do the arguments on the right */
! 	while( p->in.op == CM ){
! 		genargs( p->in.right );
! 		p->in.op = FREE;
! 		p = p->in.left;
  		}
  
! 	if( p->in.op == STARG ){ /* structure valued argument */
  
! 		size = p->stn.stsize;
! 		align = p->stn.stalign;
! 		if( p->in.left->in.op == ICON ){
! 			p->in.op = FREE;
! 			p = p->in.left;
  			}
  		else {
  			/* make it look beautiful... */
! 			p->in.op = UNARY MUL;
  			canon( p );  /* turn it into an oreg */
! 			for( count = 0; p->in.op != OREG && count < 10; ++count ){
! 				offstar( p->in.left );
  				canon( p );
  				}
+ 			if( p->in.op != OREG ) cerror( "stuck starg" );
  			}
  
! 		pasg = talloc();
! 		pasg->in.op = STARG;
! 		pasg->in.rall = NOPREF;
! 		pasg->stn.stsize = size;
! 		pasg->stn.stalign = align;
! 		pasg->in.left = p;
! 
!  		order( pasg, FORARG );
  		return;
  		}
  
***************
*** 699,722 ****
  	order( p, FORARG );
  	}
  
  argsize( p ) register NODE *p; {
! 	register t;
  	t = 0;
! 	if( p->op == CM ){
! 		t = argsize( p->left );
! 		p = p->right;
  		}
! 	if( p->type == DOUBLE || p->type == FLOAT ){
  		SETOFF( t, 2 );
  		return( t+8 );
  		}
! 	else if( p->type == LONG || p->type == ULONG ) {
  		SETOFF( t, 2);
  		return( t+4 );
  		}
! 	else if( p->op == STARG ){
! 		SETOFF( t, p->stalign );  /* alignment */
! 		return( t + p->stsize );  /* size */
  		}
  	else {
  		SETOFF( t, 2 );
--- 749,773 ----
  	order( p, FORARG );
  	}
  
+ OFFSZ
  argsize( p ) register NODE *p; {
! 	OFFSZ t;
  	t = 0;
! 	if( p->in.op == CM ){
! 		t = argsize( p->in.left );
! 		p = p->in.right;
  		}
! 	if( p->in.type == DOUBLE || p->in.type == FLOAT ){
  		SETOFF( t, 2 );
  		return( t+8 );
  		}
! 	else if( p->in.type == LONG || p->in.type == ULONG ) {
  		SETOFF( t, 2);
  		return( t+4 );
  		}
! 	else if( p->in.op == STARG ){
! 		SETOFF( t, p->stn.stalign );  /* alignment */
! 		return( t + p->stn.stsize );  /* size */
  		}
  	else {
  		SETOFF( t, 2 );
*** /old/src/lib/pcc/table.c	Fri Jul 10 14:36:11 1981
--- /usr/src/lib/pcc/table.c	Tue Jul 30 14:11:48 1991
***************
*** 1,4 ****
! # include "mfile2"
  
  # define AWD SNAME|SOREG|SCON|STARNM|STARREG|SAREG
  # define LWD SNAME|SOREG|SCON|SAREG
--- 1,4 ----
! # include "pass2.h"
  
  # define AWD SNAME|SOREG|SCON|STARNM|STARREG|SAREG
  # define LWD SNAME|SOREG|SCON|SAREG
***************
*** 282,288 ****
  
  OPLOG,	FORCC,
  	AWD,	TCHAR|TUCHAR,
! 	SCCON,	TINT,				/* look for constants between -128 and 127 */
  		0,	RESCC,
  		"	cmpb	AL,AR\nZI",
  
--- 282,288 ----
  
  OPLOG,	FORCC,
  	AWD,	TCHAR|TUCHAR,
! 	SSCON,	TINT,				/* look for constants between -128 and 127 */
  		0,	RESCC,
  		"	cmpb	AL,AR\nZI",
  
***************
*** 506,512 ****
  
  ASG PLUS,	INAREG,
  	LWD,	TLONG|TULONG,
! 	SICON,	TINT|TLONG|TULONG,
  		0,	RLEFT,
  		"	add	UR,UL\n	adc	AL\n",
  
--- 506,512 ----
  
  ASG PLUS,	INAREG,
  	LWD,	TLONG|TULONG,
! 	SCCON,	TINT|TLONG|TULONG,
  		0,	RLEFT,
  		"	add	UR,UL\n	adc	AL\n",
  
***************
*** 530,536 ****
  
  ASG MINUS,	INAREG,
  	LWD,	TLONG|TULONG,
! 	SICON,	TINT|TLONG|TULONG,
  		0,	RLEFT,
  		"	sub	UR,UL\n	sbc	AL\n",
  
--- 530,536 ----
  
  ASG MINUS,	INAREG,
  	LWD,	TLONG|TULONG,
! 	SCCON,	TINT|TLONG|TULONG,
  		0,	RLEFT,
  		"	sub	UR,UL\n	sbc	AL\n",
  
