![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cmpf2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4|
Return to cmpf2.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
Power 6/32 Unix version 1.21
#include "fpp_defs.h"
/***************************************************************************
*
* CMPF2 -COMPARE 2 SGL OPERANDS TO EACH OTHER -IGNORE THE ACCUMULATOR
*
*****************************************************************************/
cmpf2()
{
asm(".globl _cmpf2_t");
asm("_cmpf2_t:"); /* entry address */
if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
writes(" CMPF2");
cmpf2_1(); /* register / register data */
cmpf2_2(); /* cache / cache data */
cmpf2_3(); /* cache / register data */
cmpf2_4(); /* register / cache data */
cmpf2_5(); /* acc. corruption test */
cmpf2_6(); /* register corruption test */
if( !no_fpp_wcs ) {
cmpf2_7(); /* pipelined entry test */
cmpf2_8(); /* pipelined exit test */
};
asm("jmp *return"); /* return to the test monitor */
}
/****************************************************************************
*
* SUBTEST 1 - CMPF2 test -register / register data
*
****************************************************************************/
cmpf2_1()
{
force_loop = FALSE;
subtest = 1;
index = 0;
do
{
sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
sgl_value_2 = cmpf_1_data[index].two;
sgl_expected = cmpf_1_data[index].flag; /* get expected results */
index2 = 0; /* clear Acc. data index */
do
{
sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
status_index = 0; /* clear the status index */
do
{
sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_cmpf2_1_lp1:");
asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */
asm("movl _sgl_value_2,r5"); /* move operand #2 to r5 */
asm("ldf r3"); /* load the accumulator */
asm("tstl _sgl_dummy1"); /* generate initial status */
asm("movpsl _init_psl"); /* save the initial status */
asm("cmpf2 r4,r5"); /* compare the operands */
asm("movpsl _psl_val"); /* save the final status */
asm("stf r6"); /* save the accumulator */
if( force_loop ) /* loop? */
asm("brb _cmpf2_1_lp1");; /* run the loop again */
asm("movl r6,_sgl_st_acc"); /* put the acc into cache */
exp_psl = init_psl; /* get the initial PSL */
exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
if( sgl_expected == ZERO )
exp_psl |= PSL_Z; /* expect the ZERO bit set */
if( sgl_expected == NEGATIVE )
exp_psl |= PSL_N; /* expect the NEG bit set */
if( psl_val != exp_psl ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error ) {
writes(" \n"); /* start a new print line */
writes("cycle: ");
writed( cycle );
writes(" CMPF2 test ");
writed( test_no );
writes(", subtest 1 (Reg./Reg. Data) - BAD FINAL PSL\n");
print_cmpf2_data();
writes(", data index = ");
writed( index );
writec('\n');
writes(" final Acc = ");
write32h( sgl_st_acc );
writes(", operand 2 = ");
write32h( sgl_value_2 );
writec('\n');
writes(" initial PSL = ");
write32h( init_psl );
writes(", final PSL = ");
write32h( psl_val );
writes(", expected PSL = ");
write32h( exp_psl );
writes(" \n");
}
if ( halt_flg )
cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("brw _cmpf2_1_lp1"); /* and loop */
}; /* end of loop-on-error */
} /* end of compare error */
} while( ++status_index < 3 );
} while( (index2 < 10) && (index2 < max_ldf_1_index) );
} while( index++ < max_cmpf_1_index );
} /* end of subtest 1 */
/****************************************************************************
*
* SUBTEST 2 - CMPF2 test - cache / cache data
*
****************************************************************************/
cmpf2_2()
{
force_loop = FALSE;
subtest = 2;
index = 0;
do
{
sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
sgl_value_2 = cmpf_1_data[index].two;
sgl_expected = cmpf_1_data[index].flag; /* get expected results */
index2 = 0; /* clear Acc. data index */
do
{
sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
status_index = 0; /* clear the status index */
do
{
sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_cmpf2_2_lp1:");
asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
asm("ldf _sgl_ld_acc"); /* load the accumulator */
asm("tstl _sgl_dummy1"); /* generate initial status */
asm("movpsl _init_psl"); /* save the initial status */
asm("cmpf2 _sgl_value_1,_sgl_value_2"); /* compare the data */
asm("movpsl _psl_val"); /* save the final status */
asm("stf _sgl_st_acc"); /* save the acc */
if( force_loop ) /* loop? */
asm("brb _cmpf2_2_lp1");; /* run the loop again */
exp_psl = init_psl; /* get the initial PSL */
exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
if( sgl_expected == ZERO )
exp_psl |= PSL_Z; /* expect the ZERO bit set */
if( sgl_expected == NEGATIVE )
exp_psl |= PSL_N; /* expect the NEG bit set */
if( psl_val != exp_psl ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error ) {
writes(" \n"); /* start a new print line */
writes("cycle: ");
writed( cycle );
writes(" CMPF2 test ");
writed( test_no );
writes(", subtest 2 (Cache/Cache Data) - BAD FINAL PSL\n");
print_cmpf2_data();
writes(", data index = ");
writed( index );
writec('\n');
writes(" final Acc = ");
write32h( sgl_st_acc );
writes(", operand 2 = ");
write32h( sgl_value_2 );
writec('\n');
writes(" initial PSL = ");
write32h( init_psl );
writes(", final PSL = ");
write32h( psl_val );
writes(", expected PSL = ");
write32h( exp_psl );
writes(" \n");
}
if ( halt_flg )
cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
if ( loop_on_err )
{
force_loop = TRUE; /* set the force loop flag */
asm("brw _cmpf2_2_lp1"); /* and loop */
}; /* end of loop-on-error */
} /* end of compare error */
} while( ++status_index < 3 );
} while( (index2 < 10) && (index2 < max_ldf_1_index) );
} while( index++ < max_cmpf_1_index );
} /* end of subtest 2 */
/****************************************************************************
*
* SUBTEST 3 - CMPF2 test - cache / register data
*
****************************************************************************/
cmpf2_3()
{
force_loop = FALSE;
subtest = 3;
index = 0;
do
{
sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
sgl_value_2 = cmpf_1_data[index].two;
sgl_expected = cmpf_1_data[index].flag; /* get expected results */
index2 = 0; /* clear Acc. data index */
do
{
sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
status_index = 0; /* clear the status index */
do
{
sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_cmpf2_3_lp1:");
asm("ldf _sgl_ld_acc"); /* load the accmulator */
asm("movl _sgl_value_2,r5"); /* move operand #2 to r5 */
asm("tstl _sgl_dummy1"); /* generate initial status */
asm("movpsl _init_psl"); /* save the initial status */
asm("cmpf2 _sgl_value_1,r5"); /* compare the data */
asm("movpsl _psl_val"); /* save the final status */
asm("stf _sgl_st_acc"); /* save the acc */
if( force_loop ) /* loop? */
asm("brb _cmpf2_3_lp1");; /* run the loop again */
exp_psl = init_psl; /* get the initial PSL */
exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
if( sgl_expected == ZERO )
exp_psl |= PSL_Z; /* expect the ZERO bit set */
if( sgl_expected == NEGATIVE )
exp_psl |= PSL_N; /* expect the NEG bit set */
if( psl_val != exp_psl ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error ) {
writes(" \n"); /* start a new print line */
writes("cycle: ");
writed( cycle );
writes(" CMPF2 test ");
writed( test_no );
writes(", subtest 3 (Cache/Reg. Data) - BAD FINAL PSL\n");
print_cmpf2_data();
writes(", data index = ");
writed( index );
writec('\n');
writes(" final Acc = ");
write32h( sgl_st_acc );
writes(", operand 2 = ");
write32h( sgl_value_2 );
writec('\n');
writes(" initial PSL = ");
write32h( init_psl );
writes(", final PSL = ");
write32h( psl_val );
writes(", expected PSL = ");
write32h( exp_psl );
writes(" \n");
}
if ( halt_flg )
cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
if ( loop_on_err )
{
force_loop = TRUE; /* set the force loop flag */
asm("brw _cmpf2_3_lp1"); /* and loop */
}; /* end of loop-on-error */
} /* end of compare error */
} while( ++status_index < 3 );
} while( (index2 < 10) && (index2 < max_ldf_1_index) );
} while( index++ < max_cmpf_1_index );
} /* end of subtest 3 */
/****************************************************************************
*
* SUBTEST 4 - CMPF2 test - register / cache data
*
****************************************************************************/
cmpf2_4()
{
force_loop = FALSE;
subtest = 4;
index = 0;
do
{
sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
sgl_value_2 = cmpf_1_data[index].two;
sgl_expected = cmpf_1_data[index].flag; /* get expected results */
index2 = 0; /* clear Acc. data index */
do
{
sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
status_index = 0; /* clear the status index */
do
{
sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_cmpf2_4_lp1:");
asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
asm("movl _sgl_value_1,r4"); /* move operand #1 to r4 */
asm("ldf r3"); /* load the accumulator */
asm("tstl _sgl_dummy1"); /* generate initial status */
asm("movpsl _init_psl"); /* save the initial status */
asm("cmpf2 r4,_sgl_value_2"); /* compare the data */
asm("movpsl _psl_val"); /* save the final status */
asm("stf _sgl_st_acc"); /* save the acc */
if( force_loop ) /* loop? */
asm("brb _cmpf2_4_lp1");; /* run the loop again */
exp_psl = init_psl; /* get the initial PSL */
exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
if( sgl_expected == ZERO )
exp_psl |= PSL_Z; /* expect the ZERO bit set */
if( sgl_expected == NEGATIVE )
exp_psl |= PSL_N; /* expect the NEG bit set */
if( psl_val != exp_psl ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error ) {
writes(" \n"); /* start a new print line */
writes("cycle: ");
writed( cycle );
writes(" CMPF2 test ");
writed( test_no );
writes(", subtest 4 (Reg./Cache Data) - BAD FINAL PSL\n");
print_cmpf2_data();
writes(", data index = ");
writed( index );
writec('\n');
writes(" final Acc = ");
write32h( sgl_st_acc );
writes(", operand 2 = ");
write32h( sgl_value_2 );
writec('\n');
writes(" initial PSL = ");
write32h( init_psl );
writes(", final PSL = ");
write32h( psl_val );
writes(", expected PSL = ");
write32h( exp_psl );
writes(" \n");
}
if ( halt_flg )
cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
if ( loop_on_err )
{
force_loop = TRUE; /* set the force loop flag */
asm("jmp _cmpf2_4_lp1"); /* and loop */
} /* end of loop-on-error */
} /* end of compare error */
} while( ++status_index < 3 );
} while( (index2 < 10) && (index2 < max_ldf_1_index) );
} while( index++ < max_cmpf_1_index );
} /* end of subtest 4 */
/************************************************************************
*
* SUBTEST 5 - Check for register corruption
*
************************************************************************/
cmpf2_5()
{
force_loop = FALSE; /* clear force_loop flg */
subtest = 5;
fill_reg_buf( load_regs ); /* get pattern for regs */
index = 0;
do
{
sgl_value_1 = cmpf_1_data[index].one; /* data to load */
sgl_value_2 = cmpf_1_data[index].two; /* data to compare */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_cmpf2_5_lp1:");
asm("ldf $0x40800000"); /* LOAD the accumulator */
asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
asm("cmpf2 _sgl_value_1,_sgl_value_2"); /* compare the data */
asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
asm("stf _sgl_st_acc"); /* save the acc */
if( force_loop ) /* loop? */
asm("brb _cmpf2_5_lp1");; /* run the loop again */
/*
* Now compare the stored register values to those that were loaded
*/
index2 = 0;
while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
index2++; /* check reg values */
if( index2 < 13 ) { /* error if index2 < 13 */
errcnt++; /* bump the error count */
if ( prt_error ) {
writes(" \n"); /* start a new print line */
writes("cycle: ");
writed( cycle );
writes(", CMPF2 test ");
writed( test_no );
writes(", subtest 5 - A REGISTER WAS MODIFIED\n");
print_cmpf2_data();
writec('\n');
writes(" final Acc = ");
write32h( sgl_st_acc );
writes(", operand 2 = ");
write32h( sgl_value_2 );
writec('\n');
writes("register ");
writed( index2 );
writes(" = ");
write32h( store_regs[ index2 ] );
writes(", should be = ");
write32h( load_regs[ index2 ] );
writes("\n");
}
if ( halt_flg )
cmpf2_er_halt( BAD_REG_HLT ); /* halt on the error */
if ( loop_on_err )
{
force_loop = TRUE; /* set the force loop flag */
asm("jmp _cmpf2_5_lp1"); /* and loop */
}; /* end of loop-on-error */
} /* end of compare error */
} while( index++ < max_cmpf_1_index );
} /* end of subtest 5 */
/****************************************************************************
*
* SUBTEST 6 - CMPF2 test Accumulator stability test
*
****************************************************************************/
cmpf2_6()
{
force_loop = FALSE;
subtest = 6;
index = 0;
do
{
sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
sgl_value_2 = cmpf_1_data[index].two;
index2 = 0; /* clear Acc. data index */
do
{
sgl_ld_acc = ldf_1_data[index2].ld; /* get the Accumulator data */
sgl_expected = ldf_1_data[index2++].exp; /* get expected Acc. */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_cmpf2_6_lp1:");
asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
asm("ldf r3"); /* load the accumulator */
asm("cmpf2 _sgl_value_1,_sgl_value_2");/* compare the operands */
asm("stf _sgl_st_acc"); /* store the accumulator */
if( force_loop ) /* loop? */
asm("brb _cmpf2_6_lp1");; /* run the loop again */
if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
errcnt++; /* bump the error count */
if ( prt_error ) {
writes(" \n"); /* start a new print line */
writes("cycle: ");
writed( cycle );
writes(" CMPF2 test ");
writed( test_no );
writes(", subtest 6 (Acc. Corr.) - THE ACC WAS MODIFIED\n");
print_cmpf2_data();
writes(", index = ");
writed( index );
writec('\n');
writes(" final Acc = ");
write32h( sgl_st_acc );
writes(", operand 2 = ");
write32h( sgl_value_2 );
writec('\n');
writes("expected Acc = ");
write32h( sgl_expected );
writec('\n');
}
if ( halt_flg ) /* halt on error? */
cmpf2_er_halt( BAD_ACC_HLT );
if ( loop_on_err )
{
force_loop = TRUE; /* set the force loop flag */
asm("jmp _cmpf2_6_lp1"); /* and loop */
}; /* end of loop-on-error */
} /* end of compare error */
} while( (index2 < 10) && (index2 < max_ldf_1_index) );
} while( index++ < max_cmpf_1_index );
} /* end of subtest 6 */
/****************************************************************************
*
* SUBTEST 7 - CMPF2 test - piped entry
*
****************************************************************************/
cmpf2_7()
{
force_loop = FALSE;
subtest = 7;
index = 0;
do
{
sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
sgl_value_2 = cmpf_1_data[index].two;
sgl_expected = cmpf_1_data[index].flag; /* get expected results */
index2 = 0; /* clear Acc. data index */
do
{
sgl_ld_acc = ldf_1_data[index2++].ld; /* get the Accumulator data */
status_index = 0; /* clear the status index */
do
{
sgl_dummy1 = status_array[status_index]; /* array = +, -, 0 */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_cmpf2_7_lp1:");
asm("movl $0,r0"); /* zero the reg */
asm("ldf r0"); /* load a zero in the acc */
asm("addf _sgl_ld_acc"); /* add initial data to acc */
asm("tstl _sgl_dummy1"); /* generate initial status */
asm("movpsl _init_psl"); /* save the initial status */
asm("cmpf2 _sgl_value_1,_sgl_value_2"); /* compare the data */
asm("movpsl _psl_val"); /* save the final status */
asm("stf _sgl_st_acc"); /* save the acc */
if( force_loop ) /* loop? */
asm("brb _cmpf2_7_lp1");; /* run the loop again */
exp_psl = init_psl; /* get the initial PSL */
exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */
if( sgl_expected == ZERO )
exp_psl |= PSL_Z; /* expect the ZERO bit set */
if( sgl_expected == NEGATIVE )
exp_psl |= PSL_N; /* expect the NEG bit set */
if( psl_val != exp_psl ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error ) {
writes(" \n"); /* start a new print line */
writes("cycle: ");
writed( cycle );
writes(" CMPF2 test ");
writed( test_no );
writes(", subtest 7 (Piped Entry) - BAD FINAL PSL\n");
print_cmpf2_data();
writes(", data index = ");
writed( index );
writec('\n');
writes(" final Acc = ");
write32h( sgl_st_acc );
writes(", operand 2 = ");
write32h( sgl_value_2 );
writec('\n');
writes(" initial PSL = ");
write32h( init_psl );
writes(", final PSL = ");
write32h( psl_val );
writes(", expected PSL = ");
write32h( exp_psl );
writes(" \n");
}
if ( halt_flg )
cmpf2_er_halt( BAD_PSL_HLT ); /* halt on the error */
if ( loop_on_err )
{
force_loop = TRUE; /* set the force loop flag */
asm("brw _cmpf2_7_lp1"); /* and loop */
}; /* end of loop-on-error */
} /* end of compare error */
} while( ++status_index < 3 );
} while( (index2 < 10) && (index2 < max_ldf_1_index) );
} while( index++ < max_cmpf_1_index );
} /* end of subtest 7 */
/****************************************************************************
*
* SUBTEST 8 - CMPF2 piped exit test
*
****************************************************************************/
cmpf2_8()
{
force_loop = FALSE;
subtest = 6;
index = 0;
do
{
sgl_value_1 = cmpf_1_data[index].one; /* get the data operands */
sgl_value_2 = cmpf_1_data[index].two;
index2 = 0; /* clear Acc. data index */
do
{
sgl_ld_acc = ldf_1_data[index2].ld; /* get the Accumulator data */
sgl_expected = ldf_1_data[index2++].exp; /* get expected Acc. */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_cmpf2_8_lp1:");
asm("movl $0,r0"); /* move a zero to r0 */
asm("movl _sgl_ld_acc,r3"); /* get the accmulator data */
asm("ldf r3"); /* load the accumulator */
asm("cmpf2 _sgl_value_1,_sgl_value_2");/* compare the operands */
asm("addf r0"); /* add a zero to the acc */
asm("stf _sgl_st_acc"); /* store the accumulator */
if( force_loop ) /* loop? */
asm("brb _cmpf2_8_lp1");; /* run the loop again */
if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
errcnt++; /* bump the error count */
if ( prt_error ) {
writes(" \n"); /* start a new print line */
writes("cycle: ");
writed( cycle );
writes(" CMPF2 test ");
writed( test_no );
writes(", subtest 8 (Piped Exit) - THE ACC WAS MODIFIED\n");
print_cmpf2_data();
writes(", data index = ");
writed( index );
writec('\n');
writes(" final Acc = ");
write32h( sgl_st_acc );
writes(", operand 2 = ");
write32h( sgl_value_2 );
writec('\n');
writes("expected Acc = ");
write32h( sgl_expected );
writec('\n');
}
if ( halt_flg ) /* halt on error? */
cmpf2_er_halt( BAD_ACC_HLT );
if ( loop_on_err )
{
force_loop = TRUE; /* set the force loop flag */
asm("jmp _cmpf2_8_lp1"); /* and loop */
}; /* end of loop-on-error */
} /* end of compare error */
} while( (index2 < 10) && (index2 < max_ldf_1_index) );
} while( index++ < max_cmpf_1_index );
} /* end of subtest 8 */
/**************************************************************************
*
* PRINT THE DATA AND STORE RESULTS
*
* initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
* operand = xxxxxxxx, expected = xxxxxxxx
**************************************************************************/
print_cmpf2_data()
{
writes(" initial Acc = ");
write32h( sgl_ld_acc );
writes(", operand 1 = ");
write32h( sgl_value_1 );
}
/**************************************************************************
*
* HALT ON ERROR ROUTINE
*
**************************************************************************/
cmpf2_er_halt( halt_code )
int halt_code;
{
sgl_dummy1 = halt_code; /* get the error type */
asm("movl _test_no,r0"); /* r0 = test number */
asm("movl _subtest,r1"); /* r1 = subtest number */
asm("movl _sgl_dummy1,r2"); /* r2 = error code */
asm("movl _cycle,r3"); /* r3 = cycle count */
asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
asm("movl _sgl_value_1,r5"); /* r5 = operand 1 */
asm("movl _sgl_value_2,r6"); /* r6 = operand 2 */
asm("movl _psl_val,r7"); /* r7 = actual PSL */
if( halt_code == BAD_ACC_HLT ) {
asm("movl _sgl_st_acc,r8"); /* r8 = actual value */
asm("movl _sgl_expected,r9"); /* r9 = expected value */
} else
if( halt_code == BAD_REG_HLT ) {
sgl_dummy1 = load_regs[index2];
sgl_dummy2 = store_regs[index2];
asm("movl _index2,r8"); /* r8 = bad register # */
asm("movl _sgl_dummy2,r9"); /* r9 = actual value */
asm("movl _sgl_dummy1,r10"); /* r10 = expected value */
} else
if( halt_code == BAD_PSL_HLT ) {
asm("movl _exp_psl,r7"); /* r8 = expected PSL */
asm("movl _index,r9"); /* r9 = data index */
};
asm("halt"); /* HALT ... */
}
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.