![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe8.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 pipe8.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"
/*****************************************************************************
*
* PIPELINE TEST #8 MONITOR
*
* This test will do:
*
* LDF(1), SUBF(2), MULF(x), ADDF(x), ADDF(x), STF
*
* where x is the fmacro1 LDF data.
*****************************************************************************/
pipe_8()
{
asm(".globl _pipeline_8_t");
asm("_pipeline_8_t:"); /* entry address */
if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
{
writes("\n PIPE_8 ");
}
subtest = 1;
pipe8_1(); /* data in REGs, no NOPs */
subtest++; /* increment subtest num */
pipe8_2(); /* data in REGs, 1 NOP */
subtest++; /* increment subtest num */
pipe8_3(); /* data in REGs, 2 NOPs */
subtest++; /* increment subtest num */
pipe8_4(); /* data in REGs, 3 NOPs */
subtest++; /* increment subtest num */
pipe8_5(); /* data in CACHE, no NOPs */
subtest++; /* increment subtest num */
pipe8_6(); /* data in CACHE, 1 NOP */
subtest++; /* increment subtest num */
pipe8_7(); /* data in CACHE, 2 NOPs */
subtest++; /* increment subtest num */
pipe8_8(); /* data in CACHE, 3 NOPs */
subtest++; /* increment subtest num */
pipe8_9(); /* data on STACK, no NOPs */
subtest++; /* increment subtest num */
pipe8_10(); /* data via FP no NOPs */
asm("jmp *return"); /* return to the test monitor */
}
/************************************************************************
*
* SUBTEST 1
* data in registers, no NO-OPs
*
************************************************************************/
pipe8_1()
{
force_loop = FALSE; /* clear force_loop flag */
index = 0;
do
{
sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
sgl_expected = ldf_1_data[index].exp; /* get expected results */
sgl_value_2 = 0x40800000; /* floating '1' */
sgl_value_3 = 0x41000000; /* floating '2' */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_pipe8_1_lp1:");
asm("movl _sgl_value_1,r4"); /* move the data to r4 */
asm("movl _sgl_value_2,r5"); /* move data to r5 */
asm("movl _sgl_value_3,r6"); /* move data to r6 */
asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
asm("subf r6"); /* minus 2.0 (-1.0 ) */
asm("mulf r4"); /* *'s the operand ( -op ) */
asm("addf r4"); /* + the operand ( 0 ) */
asm("addf r4"); /* + the operand ( +op ) */
asm("stf r7"); /* store the result */
if( force_loop )
asm("brb _pipe8_1_lp1");; /* loop on the error */
/*
* verify the results
*/
asm("movl r7,_sgl_st_acc"); /* get the result */
if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error )
print_pipe8_er("Reg. Data, no NO-OPs");
if ( halt_flg )
pipe8_er_hlt( subtest );
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("jmp _pipe8_1_lp1"); /* and loop */
}
} /* end of compare error */
} while( index++ < max_ldf_1_index );
} /* end of subtest 1 */
/************************************************************************
*
* SUBTEST 2
* data in registers, 1 NO-OP
*
************************************************************************/
pipe8_2()
{
force_loop = FALSE; /* clear force_loop flag */
index = 0;
do
{
sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
sgl_expected = ldf_1_data[index].exp; /* get expected results */
sgl_value_2 = 0x40800000; /* floating '1' */
sgl_value_3 = 0x41000000; /* floating '2' */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_pipe8_2_lp1:");
asm("movl _sgl_value_1,r4"); /* move the data to r4 */
asm("movl _sgl_value_2,r5"); /* move data to r5 */
asm("movl _sgl_value_3,r6"); /* move data to r6 */
asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
asm("nop");
asm("subf r6"); /* minus 2.0 (-1.0 ) */
asm("nop");
asm("mulf r4"); /* *'s the operand ( -op ) */
asm("nop");
asm("addf r4"); /* + the operand ( 0 ) */
asm("nop");
asm("addf r4"); /* + the operand ( +op ) */
asm("nop");
asm("stf r7"); /* store the result */
if( force_loop )
asm("brb _pipe8_2_lp1");; /* loop on the error */
/*
* verify the results
*/
asm("movl r7,_sgl_st_acc"); /* get the result */
if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error )
print_pipe8_er("Reg. Data, 1 NO-OP");
if ( halt_flg )
pipe8_er_hlt( subtest );
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("jmp _pipe8_2_lp1"); /* and loop */
}
} /* end of compare error */
} while( index++ < max_ldf_1_index );
} /* end of subtest 2 */
/************************************************************************
*
* SUBTEST 3
* data in registers, 2 NO-OPs
*
************************************************************************/
pipe8_3()
{
force_loop = FALSE; /* clear force_loop flag */
index = 0;
do
{
sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
sgl_expected = ldf_1_data[index].exp; /* get expected results */
sgl_value_2 = 0x40800000; /* floating '1' */
sgl_value_3 = 0x41000000; /* floating '2' */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_pipe8_3_lp1:");
asm("movl _sgl_value_1,r4"); /* move the data to r4 */
asm("movl _sgl_value_2,r5"); /* move data to r5 */
asm("movl _sgl_value_3,r6"); /* move data to r6 */
asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
asm("nop");
asm("nop");
asm("subf r6"); /* minus 2.0 (-1.0 ) */
asm("nop");
asm("nop");
asm("mulf r4"); /* *'s the operand ( -op ) */
asm("nop");
asm("nop");
asm("addf r4"); /* + the operand ( 0 ) */
asm("nop");
asm("nop");
asm("addf r4"); /* + the operand ( +op ) */
asm("nop");
asm("nop");
asm("stf r7"); /* store the result */
if( force_loop )
asm("brb _pipe8_3_lp1");; /* loop on the error */
/*
* verify the results
*/
asm("movl r7,_sgl_st_acc"); /* get the result */
if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error )
print_pipe8_er("Reg. Data, 2 NO-OPs");
if ( halt_flg )
pipe8_er_hlt( subtest );
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("jmp _pipe8_3_lp1"); /* and loop */
}
} /* end of compare error */
} while( index++ < max_ldf_1_index );
} /* end of subtest 3 */
/************************************************************************
*
* SUBTEST 4
* data in registers, 3 NO-OPs
*
************************************************************************/
pipe8_4()
{
force_loop = FALSE; /* clear force_loop flag */
index = 0;
do
{
sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
sgl_expected = ldf_1_data[index].exp; /* get expected results */
sgl_value_2 = 0x40800000; /* floating '1' */
sgl_value_3 = 0x41000000; /* floating '2' */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_pipe8_4_lp1:");
asm("movl _sgl_value_1,r4"); /* move the data to r4 */
asm("movl _sgl_value_2,r5"); /* move data to r5 */
asm("movl _sgl_value_3,r6"); /* move data to r6 */
asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
asm("nop");
asm("nop");
asm("nop");
asm("subf r6"); /* minus 2.0 (-1.0 ) */
asm("nop");
asm("nop");
asm("nop");
asm("mulf r4"); /* *'s the operand ( -op ) */
asm("nop");
asm("nop");
asm("nop");
asm("addf r4"); /* + the operand ( 0 ) */
asm("nop");
asm("nop");
asm("nop");
asm("addf r4"); /* + the operand ( +op ) */
asm("nop");
asm("nop");
asm("nop");
asm("stf r7"); /* store the result */
if( force_loop )
asm("brb _pipe8_4_lp1");; /* loop on the error */
/*
* verify the results
*/
asm("movl r7,_sgl_st_acc"); /* get the result */
if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error )
print_pipe8_er("Reg. Data, 3 NO-OPs");
if ( halt_flg )
pipe8_er_hlt( subtest );
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("jmp _pipe8_4_lp1"); /* and loop */
}
} /* end of compare error */
} while( index++ < max_ldf_1_index );
} /* end of subtest 4 */
/************************************************************************
*
* SUBTEST 5
* data in Cache, no NO-OPs
*
************************************************************************/
pipe8_5()
{
force_loop = FALSE; /* clear force_loop flag */
index = 0;
do
{
sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
sgl_expected = ldf_1_data[index].exp; /* get expected results */
sgl_value_2 = 0x40800000; /* floating '1' */
sgl_value_3 = 0x41000000; /* floating '2' */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_pipe8_5_lp1:");
asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
asm("addf _sgl_value_1"); /* + the operand ( +op ) */
asm("stf _sgl_st_acc"); /* store the result */
if( force_loop )
asm("brb _pipe8_5_lp1");; /* loop on the error */
/*
* verify the results
*/
if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error )
print_pipe8_er("Cache Data, no NO-OPs");
if ( halt_flg )
pipe8_er_hlt( subtest );
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("jmp _pipe8_5_lp1"); /* and loop */
}
} /* end of compare error */
} while( index++ < max_ldf_1_index );
} /* end of subtest 5 */
/************************************************************************
*
* SUBTEST 6
* data in Cache, 1 NO-OP
*
************************************************************************/
pipe8_6()
{
force_loop = FALSE; /* clear force_loop flag */
index = 0;
do
{
sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
sgl_expected = ldf_1_data[index].exp; /* get expected results */
sgl_value_2 = 0x40800000; /* floating '1' */
sgl_value_3 = 0x41000000; /* floating '2' */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_pipe8_6_lp1:");
asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
asm("nop");
asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
asm("nop");
asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
asm("nop");
asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
asm("nop");
asm("addf _sgl_value_1"); /* + the operand ( +op ) */
asm("nop");
asm("stf _sgl_st_acc"); /* store the result */
if( force_loop )
asm("brb _pipe8_6_lp1");; /* loop on the error */
/*
* verify the results
*/
if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error )
print_pipe8_er("Cache Data, 1 NO-OP");
if ( halt_flg )
pipe8_er_hlt( subtest );
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("jmp _pipe8_6_lp1"); /* and loop */
}
} /* end of compare error */
} while( index++ < max_ldf_1_index );
} /* end of subtest 6 */
/************************************************************************
*
* SUBTEST 7
* data in Cache, 2 NO-OPs
*
************************************************************************/
pipe8_7()
{
force_loop = FALSE; /* clear force_loop flag */
index = 0;
do
{
sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
sgl_expected = ldf_1_data[index].exp; /* get expected results */
sgl_value_2 = 0x40800000; /* floating '1' */
sgl_value_3 = 0x41000000; /* floating '2' */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_pipe8_7_lp1:");
asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
asm("nop");
asm("nop");
asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
asm("nop");
asm("nop");
asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
asm("nop");
asm("nop");
asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
asm("nop");
asm("nop");
asm("addf _sgl_value_1"); /* + the operand ( +op ) */
asm("nop");
asm("nop");
asm("stf _sgl_st_acc"); /* store the result */
if( force_loop )
asm("brb _pipe8_7_lp1");; /* loop on the error */
/*
* verify the results
*/
if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error )
print_pipe8_er("Cache Data, 2 NO-OPs");
if ( halt_flg )
pipe8_er_hlt( subtest );
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("jmp _pipe8_7_lp1"); /* and loop */
}
} /* end of compare error */
} while( index++ < max_ldf_1_index );
} /* end of subtest 7 */
/************************************************************************
*
* SUBTEST 8
* data in Cache, 3 NO-OPs
*
************************************************************************/
pipe8_8()
{
force_loop = FALSE; /* clear force_loop flag */
index = 0;
do
{
sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
sgl_expected = ldf_1_data[index].exp; /* get expected results */
sgl_value_2 = 0x40800000; /* floating '1' */
sgl_value_3 = 0x41000000; /* floating '2' */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_pipe8_8_lp1:");
asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
asm("nop");
asm("nop");
asm("nop");
asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
asm("nop");
asm("nop");
asm("nop");
asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
asm("nop");
asm("nop");
asm("nop");
asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
asm("nop");
asm("nop");
asm("nop");
asm("addf _sgl_value_1"); /* + the operand ( +op ) */
asm("nop");
asm("nop");
asm("nop");
asm("stf _sgl_st_acc"); /* store the result */
if( force_loop )
asm("brb _pipe8_8_lp1");; /* loop on the error */
/*
* verify the results
*/
if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
{
errcnt++; /* bump the error count */
if ( prt_error )
print_pipe8_er("Cache Data, 3 NO-OPs");
if ( halt_flg )
pipe8_er_hlt( subtest );
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("jmp _pipe8_8_lp1"); /* and loop */
}
} /* end of compare error */
} while( index++ < max_ldf_1_index );
} /* end of subtest 8 */
/*****************************************************************************
*
* SUBTEST 9
* data on the stack, no NO-OPs
*
*****************************************************************************/
pipe8_9()
{
asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
force_loop = FALSE; /* clear force_loop flag */
index = 0;
do
{
sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
sgl_expected = ldf_1_data[index].exp; /* get expected results */
sgl_value_2 = 0x40800000; /* floating '1' */
sgl_value_3 = 0x41000000; /* floating '2' */
asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_pipe8_9_lp1:");
asm("moval _pointer_data,r14"); /* set the stack pointer */
asm("movl _sgl_value_1,-(r14)"); /* push the operand */
asm("movl _sgl_value_1,-(r14)"); /* onto the stack */
asm("movl _sgl_value_1,-(r14)"); /* 3 times */
asm("movl _sgl_value_3,-(r14)"); /* push a '2' on the stack */
asm("movl _sgl_value_2,-(r14)"); /* push a '1' on the stack */
/*
* now pop the data off the stack
*/
asm("ldf (r14)+"); /* 1.0 to the ACC. ( 1.0 ) */
asm("subf (r14)+"); /* minus 2.0 (-1.0 ) */
asm("mulf (r14)+"); /* *'s the operand ( -op ) */
asm("addf (r14)+"); /* + the operand ( 0 ) */
asm("addf (r14)+"); /* + the operand ( +op ) */
asm("stf r5"); /* store the result */
if( force_loop )
asm("brb _pipe8_9_lp1");; /* loop on the error */
/*
* verify the results
*/
asm("movl r5,_sgl_st_acc"); /* get the result */
asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
if( (sgl_st_acc != sgl_expected) || /* verify the result... */
(sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
{
asm("movl _pre_event_fp,r13"); /* restore frame pointer */
asm("movl _pre_event_sp,r14"); /* restore stack pointer */
errcnt++; /* bump the error count */
if ( prt_error ) {
print_pipe8_er("POP data from the STACK");
writes("final Stack Pointer = ");
write32h( sgl_value_5 );
writes(", expected SP = ");
write32h( sgl_value_4 );
writes("\n");
}
if ( halt_flg )
pipe8_er_hlt( subtest );
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("jmp _pipe8_9_lp1"); /* and loop */
}
} /* end of compare error */
} while( index++ < max_ldf_1_index );
asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
} /* end of subtest 9 */
/******************************************************************************
*
* SUBTEST 10
* get data via indexed FRAME pointer
*
* ADDR INDEX DATA
* pointer_data 4 <the STF result goes here>
* pointer_data-4 3 <operand data>
* pointer_data-8 2 <floating 1.0>
* pointer_data-12 1 <floating 2.0>
* pointer_data-16 0 point the frame pointer here
*
******************************************************************************/
pipe8_10()
{
asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
force_loop = FALSE; /* clear force_loop flag */
index = 0;
do
{
sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
sgl_expected = ldf_1_data[index].exp; /* get expected results */
sgl_value_2 = 0x40800000; /* floating '1' */
sgl_value_3 = 0x41000000; /* floating '2' */
asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
asm("movl _sgl_value_2,*_sgl_value_4"); /* set the "1.0" data */
sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
asm("movl _sgl_value_3,*_sgl_value_4"); /* set the "2.0" data */
sgl_value_4 -= 4; /* get FRAME PTR address */
/*
* If LOOP ON ERROR is set, this is the loop for this subtest.
* The force loop flag is set after the first error.
*/
asm("_pipe8_10_lp1:");
asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
asm("movl $1,r1"); /* r1 index = 1 longwords */
asm("movl $2,r2"); /* r2 index = 2 longwords */
asm("movl $3,r3"); /* r3 index = 3 longwords */
asm("movl $4,r4"); /* r4 index = 4 longwords */
asm("ldf (r13)[r2]"); /* 1.0 to the ACC. ( 1.0 ) */
asm("subf (r13)[r1]"); /* minus 2.0 (-1.0 ) */
asm("mulf (r13)[r3]"); /* *'s the operand ( -op ) */
asm("addf (r13)[r3]"); /* + the operand ( 0 ) */
asm("addf (r13)[r3]"); /* + the operand ( +op ) */
asm("stf (r13)[r4]"); /* store -indexed by r4 */
if( force_loop )
asm("brb _pipe8_10_lp1"); /* loop on the error */
/*
* verify the results
*/
sgl_st_acc = pointer_data; /* move the stored result */
asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
if( (sgl_st_acc != sgl_expected) || /* verify the result... */
(sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
{
asm("movl _pre_event_fp,r13"); /* restore frame pointer */
asm("movl _pre_event_sp,r14"); /* restore stack pointer */
errcnt++; /* bump the error count */
if ( prt_error ) {
print_pipe8_er("indexed FP addressing");
writes("final Frame Pointer = ");
writeh( sgl_value_5 );
writes(", expected FP = ");
writeh( sgl_value_4 );
writes("\n");
}
if ( halt_flg )
pipe8_er_hlt( subtest );
if ( loop_on_err ) {
force_loop = TRUE; /* set the force loop flag */
asm("jmp _pipe8_10_lp1"); /* and loop */
}
} /* end of compare error */
} while( index++ < max_ldf_1_index );
asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
} /* end of subtest 10 */
/******************************************************************************
*
* ERROR ROUTINE
*
* print an error in the following form
*
* operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd
* expected Acc = xxxxxxxx
*
******************************************************************************/
print_pipe8_er(msg)
char *msg;
{
writes("\n"); /* start a new print line */
writes("cycle: ");
writed( cycle );
writes(" test ");
writed( test_no );
writes(" (Pipe 8), subtest ");
writed( subtest );
writes(" error - ");
writes( msg );
writec('\n');
writes(
"LDF(1.0), SUBF(2.0), MULF(op), ADDF(op), ADDF(op), STF\n");
writes("operand = ");
write32h( sgl_value_1 );
writes(", final Acc = ");
write32h( sgl_st_acc );
writes(", data index = ");
writed( index );
writec('\n');
writes(" expected Acc = ");
write32h( sgl_expected );
writec('\n');
}
/******************************************************************************
*
* HALT ON ERROR ROUTINE
*
* halt with the necessary information saved in the registers
*
******************************************************************************/
pipe8_er_hlt( subtest )
int subtest;
{
asm("movl _test_no,r0"); /* r0 = test number */
asm("movl _subtest,r1"); /* r1 = subtest number */
asm("movl $1,r2"); /* r2 = error code */
asm("movl _cycle,r3"); /* r3 = cycle count */
asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */
asm("movl _sgl_expected,r6"); /* r6 = sgl expected */
asm("movl _index,r7"); /* r7 = data index */
asm("movl _sgl_value_2,r8"); /* r8 = floating one */
asm("movl _sgl_value_3,r9"); /* r9 = floating two */
if( subtest == 9 ) {
asm("movl _sgl_value_3,r10"); /* r10 = final SP value */
asm("movl _sgl_value_2,r11"); /* r11 = expected SP value */
} else
if( subtest == 10 ) {
asm("movl _sgl_value_3,r10"); /* r10 = final FP value */
asm("movl _sgl_value_2,r11"); /* r11 = expected FP value */
};
asm(".globl _pipe8_1_hlt");
asm("_pipe8_1_hlt:"); /* PC after the halt */
asm("halt"); /* HALT ... */
} /* end of halt on error */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.