Return to mcom.c CVS log

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

Power 6/32 Unix version 1.21

/*		standard definition file				*/
/*		for 'C' diagnostic porgrams.				*/
/*									*/
/*									*/
#define		HIGH		31
#define		IPL		18
#define		PSWMASK		255
#define		T		16
#define		IV		32
#define		FU		64
#define		DV		128
#define		FLAGS		0x0000000f

extern long scoplp;
extern long force_lp;

asm(".set PSWMASK,0xf");

/*	constants definition for mcomplemented instructions test	*/
/*									*/
/*									*/

#define		MCOMB			0x29	  /*opcodes		*/ 
#define		MCOMW			0x2b
#define		MCOML			0x2d

#define		MAX_PATTERNS		4	   /*max test patterns	*/

#define		IDEST			0x11111111/*initialization	*/
						  /*for destination	*/

#define		S1			0	  /*source values	*/
#define		S2			0x55555555
#define		S3			0xaaaaaaaa
#define		S4			-1

#define		EB1			0x111111ff/*expected data*/
#define		EW1			0x1111ffff
#define		EL1			0xffffffff
#define		EB2			0x111111aa
#define		EW2			0x1111aaaa
#define		EL2			0xaaaaaaaa
#define		EB3			0x11111155
#define		EW3			0x11115555
#define		EL3			0x55555555
#define		EB4			0x11111100
#define		EW4			0x11110000
#define		EL4			0

#define		EB11			0x000000ff
#define		EW11			0x0000ffff
#define		EL11			0xffffffff
#define		EB22			0x555555aa
#define		EW22			0x5555aaaa
#define		EL22			0xaaaaaaaa
#define		EB33			0xaaaaaa55
#define		EW33			0xaaaa5555
#define		EL33			0x55555555
#define		EB44			0xffffff00
#define		EW44			0xffff0000
#define		EL44			0

	
#define		FLG1			6	   /*initial flag val*/
#define		FLG2			6
#define		FLG3			15
#define		FLG4			11


#define		EFLG1			9	   /*expected flag val*/
#define		EFLG2			9
#define		EFLG3			1
#define		EFLG4			5

#define		ERROR1			1	  /*error definitions	*/
#define		ERROR2			2
#define		ERROR3			3
#define		ERROR4			4
#define		ERROR5			5
						  /*error messages	*/
#define		EM1	"destination not equal to expected \n"
#define		EM2	"source altered by the instruction \n"
#define		EM3	"flags not equal to expected \n"



/*	Global variables for mcom test					*/
/*									*/
/*									*/

static short	index = 0;
static long	dest = 0;	/*destination location			*/
static long	source = 0;	/*source location			*/
static long	psw;		/*processor status word			*/

static short	flag_value[MAX_PATTERNS] = {FLG1,FLG2,FLG3,FLG4};
				/*flag values for initialization	*/

static long	error_count = 0;


static long	expb[MAX_PATTERNS] = {EB1,EB2,EB3,EB4};
				/*expected values			*/

static long	expb1[MAX_PATTERNS] = {EB11,EB22,EB33,EB44};

static long	expw[MAX_PATTERNS] = {EW1,EW2,EW3,EW4};
static long	expw1[MAX_PATTERNS] = {EW11,EW22,EW33,EW44};

static long	expl[MAX_PATTERNS] = {EL1,EL2,EL3,EL4};
static long	expl1[MAX_PATTERNS] = {EL11,EL22,EL33,EL44};

static short	exp_psw[MAX_PATTERNS] = {EFLG1,EFLG2,EFLG3,EFLG4};
				/*expected psw				*/

static long	src[MAX_PATTERNS] = {S1,S2,S3,S4};
				/*source values				*/


static char *title;
static char *msg;
static long op1, op2, *lptr, exp_dest;
static short init_flg;

mcom()
{
	asm("movl	$2,_no_opr");	/* two operands in use */
	title = "** MCOM_L **\n";
	mcoml();
	title = "** MCOM_W **\n";
	mcomw();
	title = "** MCOM_B **\n";
	mcomb();
	asm("jmp *return");
}


static mcoml()
{
      for (index = 0; index < MAX_PATTERNS; index++)
	  {
           t_mcoml ();
      	   t_mcoml1();		/*one more test where			*/
				/* dest address = source address	*/
          }
}


static t_mcoml()
{

	for (;;)
	  { 
	   setjmp();
	   asm("mc1:	movab	mc1,_stpc");
	   op2 = dest = IDEST;		/* Init destination, source, & psw */
	   lptr = src + index;
	   op1 = source = *lptr;	/* do not use index */
	   init_flg = (short)flag_value[index];

	   asm("movl	$0x1,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("bispsw	_init_flg");
	   asm("mcoml	_source,_dest");
	   asm("movpsl	_psw");	/*save psw				*/
	   psw &= FLAGS;	/*mask out all bits except flag bits	*/
	   lptr = expl + index;
	   exp_dest = *lptr;
	   if (dest != exp_dest)
		{
		asm("movl	$1,_ercode");	/* error data miscompare */
		if (scoplp) longjmp();
	        error(dest,exp_dest,op1,op2);
		}
	   if (source != op1)
		{
		asm("movl	$3,_ercode");	/* error operand miscompare */
		if (scoplp) longjmp();
	        error(source,op1,op1,op2);
		}
	   if (psw != exp_psw[index])
		{
		asm("movl	$2,_ercode");	/* error flag miscompare */
		if (scoplp) longjmp();
	        error(psw,exp_psw[index],op1,op2);
		}
    	   else
		if (force_lp) longjmp();
		return(0);
          }
}


static t_mcoml1()
{
	for (;;)
	  { 
	   setjmp();
	   asm("mc2:	movab	mc2,_stpc");
           			/*initialize  source, & psw	*/
	   lptr = src + index;
	   op1 = source = *lptr;	/* do not use index */
	   init_flg = (short)flag_value[index];

	if (index==0) {
	   asm("movl	$0x2,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("bispsw	_init_flg");
	   asm("mcoml	_source,_source");	/* memory to memory */
	   asm("movpsl	_psw");	/*save psw				*/
	   	   }
	if (index==1) {
	   asm("movl	$0x3,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("movl	_source,r7");	/* load register */
	   asm("bispsw	_init_flg");
	   asm("mcoml	_source,r7");	/* memory to register */
	   asm("movl	r7,_source");	/* reload target address */
	   asm("movpsl	_psw");	/*save psw				*/
	   	   }
	if (index==2) {
	   asm("movl	$0x4,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("movl	_source,r6");	/* load register */
	   asm("bispsw	_init_flg");
	   asm("mcoml	r6,_source");	/* register to memory */
	   asm("movpsl	_psw");	/*save psw				*/
	   	   }
	if (index==3) {
	   asm("movl	$0x5,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("movl	_source,r6");	/* load register */
	   asm("movl	_source,r7");	/* load register */
	   asm("bispsw	_init_flg");
	   asm("mcoml	r6,r7");	/* register to register */
	   asm("movl	r7,_source");	/* reload target address */
	   asm("movpsl	_psw");	/*save psw				*/
	   	   }
	   psw &= FLAGS;	/*mask out all bits except flag bits	*/
	   lptr = expl1 + index;
	   exp_dest = *lptr;
	   if (source != exp_dest)
		{
		asm("movl	$1,_ercode");	/* error data miscompare */
		if (scoplp) longjmp();
	        error(source,exp_dest,op1,op1);
		}
	   if (psw != exp_psw[index])
		{
		asm("movl	$2,_ercode");	/* error flag miscompare */
		if (scoplp) longjmp();
	        error(psw,exp_psw[index],op1,op1);
		}
    	   else
		if (force_lp) longjmp();
		return(0);
          }
}



static mcomw()
{
      for (index = 0; index < MAX_PATTERNS; index++)
	  {
           t_mcomw();
      	   t_mcomw1();		/*one more test where			*/
				/* dest address = source address	*/
          }
}

static t_mcomw()
{

	for (;;)
	  { 
	   setjmp();
	   asm("mc3:	movab	mc3,_stpc");
	   op2 = dest = IDEST;		/* Init destination, source, & psw */
	   lptr = src + index;
	   op1 = source = *lptr;	/* do not use index */
	   init_flg = (short)flag_value[index];

	if (index==0) {
	   asm("movl	$0x6,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("bispsw	_init_flg");
	   asm("mcomw	_source+2,_dest+2");	/* memory to memory */
	   asm("movpsl	_psw");	/*save psw				*/
		      }
	if (index==1) {
	   asm("movl	$0x7,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("movl	_source,r6");	/* load register */
	   asm("movl	_dest,r7");	/* load register */
	   asm("bispsw	_init_flg");
	   asm("mcomw	r6,r7");		/* register to register */
	   asm("movpsl	_psw");	/*save psw				*/
	   asm("movw	r7,_dest+2");	/* reload memory location for check */
		      }
	if (index==2) {
	   asm("movl	$0x8,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("movl	_source,r6");	/* load register */
	   asm("bispsw	_init_flg");
	   asm("mcomw	r6,_dest+2");	/* register to memory */
	   asm("movpsl	_psw");	/*save psw				*/
		      }
	if (index==3) {
	   asm("movl	$0x9,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("movl	_dest,r7");	/* load register */
	   asm("bispsw	_init_flg");
	   asm("mcomw	_source+2,r7");	/* memory to register */
	   asm("movw	r7,_dest+2");	/* reload compare location */
	   asm("movpsl	_psw");	/*save psw				*/
		      }
	   psw &= FLAGS;	/*mask out all bits except flag bits	*/
	   lptr = expw + index;
	   exp_dest = *lptr;
	   if (dest != exp_dest)
		{
		asm("movl	$1,_ercode");	/* error data miscompare */
		if (scoplp) longjmp();
	        error(dest,exp_dest,op1,op2);
		}
	   if (source != op1)
		{
		asm("movl	$3,_ercode");	/* error operand miscompare */
		if (scoplp) longjmp();
	        error(source,op1,op1,op2);
		}
	   if (psw != exp_psw[index])
		{
		asm("movl	$2,_ercode");	/* error flag miscompare */
		if (scoplp) longjmp();
	        error(psw,exp_psw[index],op1,op2);
		}
    	   else
		if (force_lp) longjmp();
		return(0);
          }
}

static t_mcomw1()
{
	for ( ; ; )
	  { 
           			/*initialize  source, & psw	*/
	   setjmp();
	   asm("mc4:	movab	mc4,_stpc");
	   lptr = src + index;
	   op1 = source = *lptr;	/* do not use index */
	   init_flg = (short)flag_value[index];
	   asm("movl	$0xa,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("bispsw	_init_flg");
	   asm("mcomw	_source+2,_source+2");
	   asm("movpsl	_psw");	/*save psw				*/
	   psw &= FLAGS;	/*mask out all bits except flag bits	*/
	   lptr = expw1 + index;
	   exp_dest = *lptr;
	   if (source != exp_dest)
		{
		asm("movl	$1,_ercode");	/* error data miscompare */
		if (scoplp) longjmp();
	        error(source,exp_dest,op1,op1);
		}
	   if (psw != exp_psw[index])
		{
		asm("movl	$2,_ercode");	/* error flag miscompare */
		if (scoplp) longjmp();
	        error(psw,exp_psw[index],op1,op1);
		}
    	   else
		if (force_lp) longjmp();
		return(0);
          }
}


static mcomb()
{
      for (index = 0; index < MAX_PATTERNS; index++)
	  {
           t_mcomb();
      	   t_mcomb1();		/*one more test where			*/
				/* dest address = source address	*/
          }
}

static t_mcomb()
{
	for ( ; ; )
	  { 
	   setjmp();
	   asm("mc5:	movab	mc5,_stpc");
	   op2 = dest = IDEST;		/* Init destination, source, & psw */
	   lptr = src + index;
	   op1 = source = *lptr;	/* do not use index */
	   init_flg = (short)flag_value[index];

	if (index==0) {
	   asm("movl	$0xb,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("bispsw	_init_flg");
	   asm("mcomb	_source+3,_dest+3");	/* memory to memory */
	   asm("movpsl	_psw");	/*save psw				*/
	           }
	if (index==1) {
	   asm("movl	$0xc,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("bispsw	_init_flg");
	   asm("movl	_source,r6");		/* load data into reg */
	   asm("mcomb	r6,_dest+3");		/* register to memory */
	   asm("movpsl	_psw");	/*save psw				*/
	           }
	if (index==2) {
	   asm("movl	$0xd,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("bispsw	_init_flg");
	   asm("movl	_dest,r7");		/* load dest register */
	   asm("mcomb	_source+3,r7");		/* memory to register */
	   asm("movpsl	_psw");	/*save psw				*/
	   asm("movb	r7,_dest+3");		/* reload memory */
		   }
	if (index==3) {
	   asm("movl	$0xe,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("movl	_source,r6");		/* load data into reg */
	   asm("movl	_dest,r7");		/* load dest register */
	   asm("bispsw	_init_flg");
	   asm("mcomb	r6,r7");		/*  register to register */
	   asm("movpsl	_psw");	/*save psw				*/
	   asm("movb	r7,_dest+3");		/* reload memory */
		   }
	   psw &= FLAGS;	/*mask out all bits except flag bits	*/
	   lptr = expb + index;
	   exp_dest = *lptr;
	   if (dest != exp_dest)
		{
		asm("movl	$1,_ercode");	/* error data miscompare */
		if (scoplp) longjmp();
	        error(dest,exp_dest,op1,op2);
		}
	   if (source != op1)
		{
		asm("movl	$3,_ercode");	/* error operand miscompare */
		if (scoplp) longjmp();
	        error(source,op1,op1,op2);
		}
	   if (psw != exp_psw[index])
		{
		asm("movl	$2,_ercode");	/* error flag miscompare */
		if (scoplp) longjmp();
	        error(psw,exp_psw[index],op1,op2);
		}
    	   else
		if (force_lp) longjmp();
		return(0);
          }
}



static t_mcomb1()
{
	for (;;)
	  { 
	   setjmp();
	   asm("mc6:	movab	mc6,_stpc");
           			/*initialize  source, & psw	*/
	   lptr = src + index;
	   op1 = source = *lptr;	/* do not use index */
	   init_flg = (short)flag_value[index];
	   asm("movl	$0xf,_subtst");
	   asm("bicpsw	$PSWMASK");
	   asm("bispsw	_init_flg");
	   asm("mcomb	_source+3,_source+3");
	   asm("movpsl	_psw");	/*save psw				*/
	   psw &= FLAGS;	/*mask out all bits except flag bits	*/
	   lptr = expb1 + index;
	   exp_dest = *lptr;
	   if (source != exp_dest)
		{
		asm("movl	$1,_ercode");	/* error data miscompare */
		if (scoplp) longjmp();
	        error(source,exp_dest,op1,op1);
		}
	   if (psw != exp_psw[index])
		{
		asm("movl	$2,_ercode");	/* error flag miscompare */
		if (scoplp) longjmp();
	        error(psw,exp_psw[index],op1,op1);
		}
    	   else
		if (force_lp) longjmp();
		return(0);
          }
}

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