Return to xor.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / entry

Power 6/32 Unix version 1.2b

#define error_hdl2 error

#define C	0x1
#define V	0x2
#define Z	0x4
#define N	0x8

extern long scoplp;
extern long force_lp; 
extern long no_opr;
extern long opr;

/* Some globals */
static long flag_msk, mask, src, dest, psl;

	int ix;

/*	XOR instructions	*/

x_or()
{
	xorb2();
	xorb3();
	xorw2();
	xorw3();
	xorl2();
	xorl3();
	asm("jmp *return");
}

static xorb2()
{
	long exp_psw, no_op;
	char op_type;
	for (ix = 1; ix < 7; ix ++)

	{
	no_op = 2;
	op_type ='b';
	no_opr = 2;

	/* XOR 2 BYTE_OPERANDS	*/
	flag_msk = exp_psw = 0;
	flag_msk = N|V|C;		/* set N,V,C flag */
	exp_psw = Z|C;
	mask = 123;
	src = 123;
	xor(op_type,no_op,0,exp_psw);
	ix = ix + 1;			/* increment ix */

	flag_msk = exp_psw = 0;
	flag_msk = Z|V|C;		/* set Z,V,C flag */
	exp_psw = N|C;
	mask = 0x81;
	src = 3;
	xor(op_type,no_op,0x82,exp_psw);
	}
}

static xorb3()
{
	long exp_psw, no_op;
	char op_type;
	for (ix = 1; ix < 11; ix ++)
	{

	no_op = 3;
	no_opr = 3;
	op_type ='b';

	/* XOR 3 BYTE_OPERANDS	*/
	flag_msk = exp_psw = 0;
	flag_msk = N|V|C;		/* set N,V,C flag */
	exp_psw = Z|C;
	mask = 0xff;
	src = 0xff;
	xor(op_type,no_op,0,exp_psw);
	ix = ix + 1;			/* increment ix = execution counter */

	flag_msk = exp_psw = 0;
	flag_msk = Z|V|C;		/* set Z,V,C flag */
	exp_psw = N|C;
	mask = 0xaa;
	src = 1;
	xor(op_type,no_op,0xab,exp_psw);
	}
}

static xorw2()
{
	long exp_psw, no_op;
	char op_type;
	for (ix = 1; ix < 7; ix ++)
	{

	no_op = 2;
	no_opr = 2;
	op_type ='w';

	/* XOR 2 WORD_OPERANDS	*/
	flag_msk = exp_psw = 0;
	flag_msk = N|V|C;		/* set N,V,C flag */
	exp_psw = Z|C;
	mask = 0xffff;
	src = 0xffff;
	xor(op_type,no_op,0,exp_psw);
	ix = ix + 1;			/* increment ix = execution counter */

	flag_msk = exp_psw = 0;
	flag_msk = Z|V|C;		/* set Z,V,C flag */
	exp_psw = N|C;
	mask = 0xbbbb;
	src = 3;
	xor(op_type,no_op,0xbbb8,exp_psw);
	}
}

static xorw3()
{
	long exp_psw, no_op;
	char op_type;
	for (ix = 1; ix < 11; ix ++)
	{

	no_op = 3;
	no_opr = 3;
	op_type ='w';

	/* XOR 3 WORD_OPERANDS	*/
	flag_msk = exp_psw = 0;
	flag_msk = N|V|C;		/* set N,V,C flag */
	exp_psw = Z|C;
	mask = 0xff01;
	src = 0xff01;
	xor(op_type,no_op,0,exp_psw);
	ix = ix + 1;			/* increment ix = execution counter */

	flag_msk = exp_psw = 0;
	flag_msk = Z|V|C;		/* set Z,V,C flag */
	exp_psw = N|C;
	mask = 0xaa00;
	src = 0x7001;
	xor(op_type,no_op,0xda01,exp_psw);
	}
}

static xorl2()
{
	long exp_psw, no_op;
	char op_type;
	for (ix = 1; ix < 5; ix ++)
	{

	no_op = 2;
	no_opr = 2;
	op_type ='l';

	/* XOR 2 LONG_OPERANDS	*/
	flag_msk = exp_psw = 0;
	flag_msk = N|V|C;		/* set N,V,C flag */
	exp_psw = Z|C;
	mask = 0xffffabab;
	src = 0xffffabab;
	xor(op_type,no_op,0,exp_psw);
	ix = ix + 1;			/* increment ix = execution counter */

	flag_msk = exp_psw = 0;
	flag_msk = Z|V|C;		/* set Z,V,C flag */
	exp_psw = N|C;
	mask = 0xccccbbbb;
	src = 0x70000001;
	xor(op_type,no_op,0xbcccbbba,exp_psw);
	}
}

static xorl3()
{
	long  exp_psw, no_op;
	char op_type;
	for (ix = 1; ix < 10; ix ++)
	{

	no_op = 3;
	no_opr = 3;
	op_type ='l';

	/* XOR 3 LONG_OPERANDS	*/
	flag_msk = exp_psw = 0;
	flag_msk = N|V|C;		/* set N,V,C flag */
	exp_psw = Z|C;
	mask = 0xffffff01;
	src = 0xffffff01;
	xor(op_type,no_op,0,exp_psw);
	ix = ix + 1;			/* increment ix = execution counter */

	flag_msk = exp_psw = 0;
	flag_msk = Z|V|C;		/* set Z,V,C flag */
	exp_psw = N|C;
	mask = 0xddddaa00;
	src = 0x7001dddd;
	xor(op_type,no_op,0xaddc77dd,exp_psw);
	}

}

/* This routine execute XORB2,XORB3,XORW2,XORW3,XORL2,XORL3 instructions */

static xor(op_type,no_op,exp_reslt,exp_psw)
long  exp_reslt,  exp_psw, no_op;
char op_type;
{	
	long  op1, op2, psw;
	char *msg1, *msg2;

	flag_msk = flag_msk << 16;
	op1 = mask;
	op2 = src;
	for(;;)
	{

	if (op_type == 'b')
		{
		if (no_op==2)
			{
			asm("bicpsw $0xf");	/* clear all flags */
			asm("bispsw _flag_msk");

asm(".globl _xorbb2");
asm("_xorbb2:");

			if (ix==1){
			setjmp();
			asm("x1:	movab	x1,_stpc");
			asm("movl	$1,_subtst");
			asm("xorb2  _mask+3,_src+3"); /* mem to mem */
			asm("movpsl _psl");
			dest = src;
				  }
			if (ix==2){
			setjmp();
			asm("x2:	movab	x2,_stpc");
			asm("movl	$2,_subtst");
			exp_psw = C;
			asm("movl   _mask,r6"); /* load source reg */
			asm("movl   _src,r7");	/* load dest reg */
			asm("xorb2  r6,r7"); 	/* reg to reg */
			asm("movpsl _psl");
			asm("movl   r7,_src");  /* reload dest loc */
			dest = src;
				  }
			if (ix==3){
			setjmp();
			asm("x3:	movab	x3,_stpc");
			asm("movl	$3,_subtst");
			asm("movl   _mask,r6"); /* load source reg */
			asm("xorb2  r6,_src+3"); /* reg to mem */
			asm("movpsl _psl");
			dest = src;
				  }
			if (ix==4){
			setjmp();
			asm("x4:	movab	x4,_stpc");
			asm("movl	$4,_subtst");
			asm("movl   _src,r7");	/* load dest reg */
			asm("xorb2  _mask+3,r7"); /* mem to reg */
			asm("movpsl _psl");
			asm("movl   r7,_src");  /* reload dest loc */
			asm("andl2  $0xff,_src");
			dest = src;
				  }
			if (ix==5){
			setjmp();
			asm("x5:	movab	x5,_stpc");
			asm("movl	$5,_subtst");
			asm("xorb2  $123,_src+3"); /* data to mem */
			asm("movpsl _psl");
			dest = src;
				  }
			if (ix==6){
			setjmp();
			asm("x6:	movab	x6,_stpc");
			asm("movl	$6,_subtst");
			asm("movl   _src,r7");	/* load dest reg */
			asm("xorb2  $-0x7f,r7"); /* data to reg */
			asm("movpsl _psl");
			asm("movl   r7,_src");	/* load dest reg */
			asm("andl2  $0xff,_src");
			dest = src;
				  }
			}
		    else
			{
			asm("bicpsw $0xf");	/* clear all flags */
			asm("bispsw _flag_msk");
asm(".globl _xorbb3");
asm("_xorbb3:");
			if (ix==1){
			setjmp();
			asm("x7:	movab	x7,_stpc");
			asm("movl	$7,_subtst");
			asm("xorb3  _mask+3,_src+3,_dest+3"); /* mem mem mem */
			asm("movpsl _psl");
				  }
			if (ix==2){
			setjmp();
			asm("x8:	movab	x8,_stpc");
			asm("movl	$8,_subtst");
			asm("movb   _dest,r7");	/* load dest reg */
			asm("xorb3  _mask+3,_src+3,r7"); /* mem mem reg */
			asm("movpsl _psl");
			asm("movl   r7,_dest");	/* load dest location */
			asm("andl2  $0xff,_dest");
				  }
			if (ix==3){
			setjmp();
			asm("x9:	movab	x9,_stpc");
			asm("movl	$9,_subtst");
			exp_psw = N|C;
			asm("movl  _src,r6");	/* load src reg */
			asm("xorb3  _mask+3,r6,_dest+3"); /* mem reg mem */
			asm("movpsl _psl");
			asm("movl   r6,_src");	/* load src location */
				  }
			if (ix==4){
			setjmp();
			asm("x10:	movab	x10,_stpc");
			asm("movl	$0xa,_subtst");
			asm("xorb3  _mask+3,$0x1,_dest+3"); /* mem data mem */
			asm("movpsl _psl");
				  }
			if (ix==5){
			setjmp();
			asm("x11:	movab	x11,_stpc");
			asm("movl	$0xb,_subtst");
			asm("xorb3  $-1,$-1,_dest+3"); /* data data mem */
			asm("movpsl _psl");
				  }
			if (ix==6){
			setjmp();
			asm("x12:	movab	x12,_stpc");
			asm("movl	$0xc,_subtst");
			asm("movl  _src,r6");	/* load src reg */
			asm("xorb3  $-0x56,r6,_dest+3"); /* data reg mem */
			asm("movpsl _psl");
			asm("movl   r6,_src");	/* load src location */
				  }
			if (ix==7){
			setjmp();
			asm("x13:	movab	x13,_stpc");
			asm("movl	$0xd,_subtst");
			exp_psw = N|C;
			asm("movl  _src,r6");	/* load src reg */
			asm("movl   _dest,r7");	/* load dest reg */
			asm("xorb3  $-1,r6,r7"); /* data reg reg */
			asm("movpsl _psl");
			asm("movl   r6,_src");	/* load src location */
			asm("movl   r7,_dest");	/* load dest location */
			asm("andl2  $0xff,_dest");
			          }
			if (ix==8){
			setjmp();
			asm("x14:	movab	x14,_stpc");
			asm("movl	$0xe,_subtst");
			exp_psw = C;
			asm("movl  _mask,r5");	/* load mask reg */
			asm("movl   _dest,r7");	/* load dest reg */
			asm("xorb3  r5,$0x1,r7"); /* reg data reg */
			asm("movpsl _psl");
			asm("movl   r5,_mask");	/* load mask location */
			asm("movl   r7,_dest");	/* load dest location */
			asm("andl2  $0xff,_dest");
				  }
			if (ix==9){
			setjmp();
			asm("x15:	movab	x15,_stpc");
			asm("movl	$0xf,_subtst");
			asm("movl  _mask,r5");	/* load mask reg */
			asm("movl  _src,r6");	/* load src reg */
			asm("movl   _dest,r7");	/* load dest reg */
			asm("xorb3  r5,r6,r7"); /* reg reg reg */
			asm("movpsl _psl");
			asm("movl   r5,_mask");	/* load mask location */
			asm("movl   r6,_src");	/* load src location */
			asm("movl   r7,_dest");	/* load dest location */
			asm("andl2  $0xff,_dest");
				  }
			if (ix==10){
			setjmp();
			asm("x16:	movab	x16,_stpc");
			asm("movl	$0x10,_subtst");
			exp_psw = C;
			asm("movl  _mask,r5");	/* load mask reg */
			asm("movl  _src,r6");	/* load src reg */
			asm("xorb3  r5,r6,_dest+3"); /* reg reg mem */
			asm("movpsl _psl");
			asm("movl   r5,_mask");	/* load mask location */
			asm("movl   r6,_src");	/* load src location */
				  }
			} 
		}
	   else if (op_type == 'w')
			{
			op1 = mask;
			op2 = src;
			if (no_op==2)
				{
				asm("bicpsw $0xf");	/* clear all flags */
				asm("bispsw _flag_msk");
asm(".globl _xorwd2");
asm("_xorwd2:");
				if (ix==1){
				setjmp();
				asm("x17:	movab	x17,_stpc");
				asm("movl	$0x11,_subtst");
				asm("xorw2  _mask+2,_src+2"); /* mem to mem */
				asm("movpsl _psl");
				dest = src;
					  }
				if (ix==2){
				setjmp();
				asm("x18:	movab	x18,_stpc");
				asm("movl	$0x12,_subtst");
				exp_psw = C;
				asm("movl   _mask,r6"); /* load source reg */
				asm("movl   _src,r7");	/* load dest reg */
				asm("xorw2  r6,r7"); /* reg to reg */
				asm("movpsl _psl");
				asm("movl   r7,_src");  /* reload dest loc */
				asm("andl2  $0xffff,_src");
				dest = src;
					  }
				if (ix==3){
				setjmp();
				asm("x19:	movab	x19,_stpc");
				asm("movl	$0x13,_subtst");
				exp_psw = N|C;
				asm("movl   _mask,r6"); /* load source reg */
				asm("xorw2  r6,_src+2"); /* reg to mem */
				asm("movpsl _psl");
				dest = src;
					  }
				if (ix==4){
				setjmp();
				asm("x20:	movab	x20,_stpc");
				asm("movl	$0x14,_subtst");
				asm("movl   _src,r7");	/* load dest reg */
				asm("xorw2  _mask+2,r7"); /* mem to reg */
				asm("movpsl _psl");
				asm("movl   r7,_src");  /* reload dest loc */
				asm("andl2  $0xffff,_src");
				dest = src;
					  }
				if (ix==5){
				setjmp();
				asm("x21:	movab	x21,_stpc");
				asm("movl	$0x15,_subtst");
				asm("xorw2  $-0x0001,_src+2"); /*  data to mem */
				asm("movpsl _psl");
				dest = src;
					  }
				if (ix==6){
				setjmp();
				asm("x22:	movab	x22,_stpc");
				asm("movl	$0x16,_subtst");
				asm("movl   _src,r7");	/* load dest reg */
				asm("xorw2  $-0x4445,r7"); /* data to reg */
				asm("movpsl _psl");
				asm("movl   r7,_src");  /* reload dest loc */
				asm("andl2  $0xffff,_src");
				dest = src;
					  }
				}
		    	   else
				{
				asm("bicpsw $0xf");	/* clear all flags */
				asm("bispsw _flag_msk");
asm(".globl _xorwd3");
asm("_xorwd3:");
				if (ix==1){
				setjmp();
				asm("x23:	movab	x23,_stpc");
				asm("movl	$0x17,_subtst");
				asm("xorw3  _mask+2,_src+2,_dest+2"); /*mem mem mem*/
				asm("movpsl _psl");
					  }
				if (ix==2){
				setjmp();
				asm("x24:	movab	x24,_stpc");
				asm("movl	$0x18,_subtst");
				asm("movl  _src,r6");	/* load src reg */
				asm("xorw3  _mask+2,r6,_dest+2"); /*mem reg mem*/
				asm("movpsl _psl");
				asm("movl  r6,_src");	/* load src location */
					  }
				if (ix==3){
				setjmp();
				asm("x25:	movab	x25,_stpc");
				asm("movl	$0x19,_subtst");
				asm("xorw3  _mask+2,$-0x00ff,_dest+2"); /*mem dat mem*/
				asm("movpsl _psl");
					  }
				if (ix==4){
				setjmp();
				asm("x26:	movab	x26,_stpc");
				asm("movl	$0x1a,_subtst");
				asm("xorw3  $-0x5600,$0x7001,_dest+2"); /*lit dat mem*/
				asm("movpsl _psl");
					  }
				if (ix==5){
				setjmp();
				asm("x27:	movab	x27,_stpc");
				asm("movl	$0x1b,_subtst");
				asm("movl  _dest,r7");	/* load dest reg */
				asm("xorw3  _mask+2,_src+2,r7"); /*mem mem reg */
				asm("movpsl _psl");
				asm("movl  r7,_dest");	/* load dest location */
				asm("andl2  $0xffff,_dest");
					  }
				if (ix==6){
				setjmp();
				asm("x28:	movab	x28,_stpc");
				asm("movl	$0x1c,_subtst");
				asm("movl  _src,r6");	/* load src reg */
				asm("xorw3  $-0x5600,r6,_dest+2"); /*lit reg mem*/
				asm("movpsl _psl");
				asm("movl  r6,_src");	/* load src location */
					  }
				if (ix==7){
				setjmp();
				asm("x29:	movab	x29,_stpc");
				asm("movl	$0x1d,_subtst");
				exp_psw = N|C;
				asm("movl  _src,r6");	/* load src reg */
				asm("movl  _dest,r7");	/* load dest reg */
				asm("xorw3  $-0x00ff,r6,r7"); /*dat reg reg*/
				asm("movpsl _psl");
				asm("movl  r6,_src");	/* load src location */
				asm("movl  r7,_dest");	/* load dest location */
				asm("andl2  $0xffff,_dest");
					  }
				if (ix==8){
				setjmp();
				asm("x30:	movab	x30,_stpc");
				asm("movl	$0x1e,_subtst");
				exp_psw = C;
				asm("movl  _mask,r5");	/* load mask reg */
				asm("movl  _dest,r7");	/* load dest reg */
				asm("xorw3  r5,$0x7001,r7"); /*reg dat reg*/
				asm("movpsl _psl");
				asm("movl  r5,_mask");	/* load mask location */
				asm("movl  r7,_dest");	/* load dest location */
				asm("andl2  $0xffff,_dest");
					  }
				if (ix==9){
				setjmp();
				asm("x31:	movab	x31,_stpc");
				asm("movl	$0x1f,_subtst");
				asm("movl  _mask,r5");	/* load mask reg */
				asm("movl  _src,r6");	/* load src reg */
				asm("movl  _dest,r7");	/* load dest reg */
				asm("xorw3  r5,r6,r7"); /*reg reg reg*/
				asm("movpsl _psl");
				asm("movl  r5,_mask");	/* load mask location */
				asm("movl  r6,_src");	/* load src location */
				asm("movl  r7,_dest");	/* load dest location */
				asm("andl2  $0xffff,_dest");
					  }
				if (ix==10){
				setjmp();
				asm("x32:	movab	x32,_stpc");
				asm("movl	$0x20,_subtst");
				exp_psw = C;
				asm("movl  _mask,r5");	/* load mask reg */
				asm("movl  _src,r6");	/* load src reg */
				asm("xorw3  r5,r6,_dest+2"); /*reg reg mem*/
				asm("movpsl _psl");
				asm("movl  r5,_mask");	/* load mask location */
				asm("movl  r6,_src");	/* load src location */
					  }
				} 
			}
		    else
			{
			if (no_op==2)
				{
				asm("bicpsw $0xf");	/* clear all flags */
				asm("bispsw _flag_msk");
asm(".globl _xorlw2");
asm("_xorlw2:");
			   if (ix==1)	{
				setjmp();
				asm("x33:	movab	x33,_stpc");
				asm("movl	$0x21,_subtst");
				asm("xorl2  _mask,_src"); /* mem to mem */
				asm("movpsl _psl");
				dest = src;
					}
			   if (ix==2)	{
				setjmp();
				asm("x34:	movab	x34,_stpc");
				asm("movl	$0x22,_subtst");
				asm("movl  _mask,r5");	/* load mask reg */
				asm("movl  _src,r6");	/* load src reg */
				asm("xorl2  r5,r6"); /* reg to reg */
				asm("movpsl _psl");
				asm("movl  r5,_mask");	/* load mask location */
				asm("movl  r6,_src");	/* load src location */
				dest = src;
					}
			   if (ix==3)	{
				setjmp();
				asm("x35:	movab	x35,_stpc");
				asm("movl	$0x23,_subtst");
				asm("movl  _mask,r5");	/* load mask reg */
				asm("xorl2  r5,_src"); /* reg to mem */
				asm("movpsl _psl");
				asm("movl  r5,_mask");	/* load mask location */
				dest = src;
					}
			   if (ix==4)	{
				setjmp();
				asm("x36:	movab	x36,_stpc");
				asm("movl	$0x24,_subtst");
				asm("movl  _src,r6");	/* load src reg */
				asm("xorl2  $0xccccbbbb,r6"); /* data to reg */
				asm("movpsl _psl");
				asm("movl  r6,_src");	/* load src location */
				dest = src;
					}
				}
		    	   else
				{
				asm("bicpsw $0xf");	/* clear all flags */
				asm("bispsw _flag_msk");
asm(".globl _xorlw3");
asm("_xorlw3:");
			     if (ix==1) {
				setjmp();
				asm("x37:	movab	x37,_stpc");
				asm("movl	$0x25,_subtst");
				asm("xorl3  _mask,_src,_dest"); /*mem mem mem*/
				asm("movpsl _psl");
					} 
			     if (ix==2) {
				setjmp();
				asm("x38:	movab	x38,_stpc");
				asm("movl	$0x26,_subtst");
				asm("movl  _mask,r5");	/* load mask reg */
				asm("movl  _src,r6");	/* load src reg */
				asm("movl  _dest,r7");	/* load dest reg */
				asm("xorl3  r5,r6,r7"); /* reg reg reg */
				asm("movpsl _psl");
				asm("movl  r5,_mask");	/* load mask location */
				asm("movl  r6,_src");	/* load src location */
				asm("movl  r7,_dest");	/* load dest location */
					} 
			     if (ix==3) {
				setjmp();
				asm("x39:	movab	x39,_stpc");
				asm("movl	$0x27,_subtst");
				asm("movl  _mask,r5");	/* load mask reg */
				asm("movl  _src,r6");	/* load src reg */
				asm("xorl3  r5,r6,_dest"); /* reg reg mem */
				asm("movpsl _psl");
				asm("movl  r5,_mask");	/* load mask location */
				asm("movl  r6,_src");	/* load src location */
					} 
			     if (ix==4) {
				setjmp();
				asm("x40:	movab	x40,_stpc");
				asm("movl	$0x28,_subtst");
				asm("movl  _src,r6");	/* load src reg */
				asm("xorl3  $0xddddaa00,r6,_dest"); /* dat reg mem */
				asm("movpsl _psl");
				asm("movl  r6,_src");	/* load src location */
					} 
			     if (ix==5) {
				setjmp();
				asm("x41:	movab	x41,_stpc");
				asm("movl	$0x29,_subtst");
				asm("movl  _mask,r5");	/* load mask reg */
				asm("xorl3  r5,$0xffffff01,_dest"); /* reg dat mem */
				asm("movpsl _psl");
				asm("movl  r5,_mask");	/* load mask location */
					} 
			     if (ix==6) {
				setjmp();
				asm("x42:	movab	x42,_stpc");
				asm("movl	$0x2a,_subtst");
				asm("movl  _src,r6");	/* load src reg */
				asm("movl  _dest,r7");	/* load dest reg */
				asm("xorl3  $0xddddaa00,r6,r7"); /* dat reg reg */
				asm("movpsl _psl");
				asm("movl  r6,_src");	/* load src location */
				asm("movl  r7,_dest");	/* load dest location */
					} 
			     if (ix==7) {
				setjmp();
				asm("x43:	movab	x43,_stpc");
				asm("movl	$0x2b,_subtst");
				asm("movl  _mask,r5");	/* load mask reg */
				asm("movl  _dest,r7");	/* load dest reg */
				asm("xorl3  r5,$0xffffff01,r7"); /* reg dat reg */
				asm("movpsl _psl");
				asm("movl  r5,_mask");	/* load mask location */
				asm("movl  r7,_dest");	/* load dest location */
					} 
			     if (ix==8) {
				setjmp();
				asm("x44:	movab	x44,_stpc");
				asm("movl	$0x2c,_subtst");
				asm("movl  _dest,r7");	/* load dest reg */
				asm("xorl3  $0xddddaa00,$0x7001dddd,r7"); /* dat dat reg */
				asm("movpsl _psl");
				asm("movl  r7,_dest");	/* load dest location */
					} 
			     if (ix==9) {
				setjmp();
				asm("x45:	movab	x45,_stpc");
				asm("movl	$0x2d,_subtst");
				asm("xorl3  $0xffffff01,$0xffffff01,_dest"); /* dat dat mem */
				asm("movpsl _psl");
					} 
			     if (ix==10) {
				setjmp();
				asm("x46:	movab	x46,_stpc");
				asm("movl	$0x2e,_subtst");
				asm("xorl3  _mask,_src,_dest"); /*mem mem mem*/
				asm("movpsl _psl");
					} 
			}
		}

	psw = psl & 0xf;

	/* check flags */
	if (psw != exp_psw)
		{
		asm("movl	$2,_ercode");
		if (scoplp) longjmp();
		error_hdl2(psw,exp_psw,op1,op2);
		}
	if (mask != op1)
		{
		asm("movl	$3,_ercode");
		if ( scoplp) longjmp();
		error_hdl2(mask,op1,op1,op2);
		}
	if (no_op==3)
		{
		if (src != op2)
			{
		asm("movl	$3,_ercode");
		if ( scoplp) longjmp();
		error_hdl2(src,op2,op1,op2);
			}
		}
	if (dest != exp_reslt)
		{
		asm("movl	$1,_ercode");
		if ( scoplp) longjmp();
		error_hdl2(dest,exp_reslt,op1,op2);
		if ( force_lp) longjmp();
		}
      	break;
   }
}

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.