![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to chk_sgl_acc.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 / dmp4|
Return to chk_sgl_acc.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / dmp4 |
1.1 root 1:
2: #include "dmp_defs.h"
3:
4: /***********************************************************************
5: *
6: * Verify final single precision accumulator value
7: *
8: * This code makes the assumption that the PSL is unchanged by the
9: * instruction (specific PSL modifying instructions are checked elsewhere).
10: * The operand, if any will, be in sgl_value_1.
11: ***********************************************************************/
12: chk_sgl_acc()
13: {
14: sgl_ld_acc = dbl_ld_acc.m; /* move the data to */
15: sgl_st_acc = dbl_st_acc.m; /* the sgl data */
16: sgl_expected = dbl_expected.m; /* operands */
17: sgl_value_1 = dbl_value_1.m;
18: sgl_value_2 = dbl_value_2.m;
19: exp_psl = init_psl & 0xffffff7f; /* clear PSL's DBL bit */
20: if( sgl_st_acc != sgl_expected ) {
21: errcnt++;
22: if( prt_error )
23: prt_s_acc_e( bad_result_msg );
24: if( halt_flg )
25: hlt_s_acc_e( 1 ); /* error code 1 */
26: if( loop_on_err )
27: force_loop = TRUE; /* set loop flag */
28: }
29: else if( psl_val != exp_psl ) { /* check the final PSL */
30: errcnt++;
31: if( prt_error )
32: prt_s_acc_e( bad_psl_msg );
33: if( halt_flg )
34: hlt_s_acc_e( 2 ); /* error code 2 */
35: if( loop_on_err )
36: force_loop = TRUE; /* set loop flag */
37: }
38: else if( no_page_faults != exp_page_faults ) {
39: errcnt++;
40: if( prt_error )
41: prt_s_acc_e( trans_flt_cnt_msg );
42: if( halt_flg )
43: hlt_s_acc_e( 3 ); /* error code 3 */
44: if( loop_on_err )
45: force_loop = TRUE; /* set loop flag */
46: }
47: else /* check for corrupted registers */
48: {
49: reg_no = 0;
50: regs_ok = TRUE;
51: while( (reg_no <= 13) && (regs_ok) ) /* check 1st 13 regs */
52: if( store_regs[ reg_no ] == exp_regs[ reg_no ] )
53: reg_no++;
54: else
55: regs_ok = FALSE;
56: if( !regs_ok )
57: {
58: errcnt++;
59: if( prt_error )
60: prt_s_acc_e( reg_modified_msg );
61: if( halt_flg )
62: hlt_s_acc_e( 4 ); /* error code 4 */
63: if( loop_on_err )
64: force_loop = TRUE; /* set loop flag */
65: }
66: }
67: }
68:
69:
70:
71: /************************************************************************
72: * PRINT AN ERROR MESSAGE OF THE FORM
73: *
74: * cycle: xx. DMP test xx. <inst>. <error message>, index = xx
75: * addressing mode: <addressing mode description>
76: * inst buf= xx xx xx xx xx xx xx xx xx xx xx -page faults on byte(s) 0, x
77: * initial Acc = xxxxxxxx, final Acc = xxxxxxxx, xx page faults occurred
78: * operand = xxxxxxxx, expected Acc = xxxxxxxx, xx page faults expected
79: * initial PSL = xxxxxxxx, final PSL = xxxxxxxx, expected PSL = xxxxxxxx
80: ************************************************************************/
81: prt_s_acc_e( message )
82: char *message;
83: {
84: prt_dmp_er_msg( message ); /* print the error header */
85: writes("initial Acc = ");
86: write32h( sgl_ld_acc ); /* print initial Acc value */
87: writes(", final Acc = ");
88: write32h( sgl_st_acc ); /* print final Acc value */
89: writes(", ");
90: writed( no_page_faults ); /* print # page faults */
91: writes(" page faults occurred\n");
92: if( no_ops ) {
93: writes(" operand = ");
94: write32h( sgl_value_1 ); /* print the operand used */
95: writes(", ");
96: } else
97: writes(" "); /* align the expected Acc */
98: writes("expected Acc = ");
99: write32h( sgl_expected ); /* print the expected Acc */
100: writes(", ");
101: writed( exp_page_faults ); /* print # faults expected */
102: writes(" page faults expected\n");
103: if( psl_val != exp_psl )
104: {
105: writes("initial PSL = "); /* print PSL data */
106: write32h( init_psl );
107: writes(", final PSL = ");
108: write32h( psl_val );
109: writes(", expected PSL = ");
110: write32h( exp_psl );
111: writec('\n');
112: }
113: if( message == reg_modified_msg ) /* print modified register */
114: prt_reg_data(); /* print bad register */
115: }
116:
117:
118:
119:
120: /**************************************************************************
121: * Set up the registers and halt
122: **************************************************************************/
123: hlt_s_acc_e( code )
124: int code;
125: {
126: sgl_dummy1 = code;
127: asm("movl _test_no,r0"); /* r0 = test number */
128: asm("movl _addr_code,r1"); /* r1 = addr mode code */
129: asm("movl _sgl_dummy1,r2"); /* r2 = error code */
130: asm("movl _cycle,r3"); /* r3 = cycle count */
131: asm("movl _sgl_ld_acc,r4"); /* r4 = initial Acc. */
132: asm("movl _sgl_st_acc,r5"); /* r5 = final Acc. */
133: if( !no_ops )
134: sgl_value_1 = 0;
135: asm("movl _sgl_value_1,r6"); /* r6 = operand (or 0) */
136: if( code == 1 ) { /* data error? */
137: asm("movl _sgl_expected,r7"); /* r7 = expected Acc */
138: asm("movl _index,r8"); /* r8 = data index */
139: }
140: else if( code == 2 ) { /* PSL error? */
141: asm("movl _init_psl,r7"); /* r7 = initial PSL */
142: asm("movl _psl_val,r8"); /* r8 = final PSL value */
143: asm("movl _init_psl,r9"); /* r9 = expected PSL */
144: asm("movl _index,r10"); /* r10 = data index */
145: }
146: else if( code == 3 ) { /* page fault error? */
147: asm("movl _no_page_faults,r7"); /* r7 = # page faults */
148: asm("movl _exp_page_faults,r8"); /* r8 = # faults expected */
149: asm("movl _index,r9"); /* r9 = data index */
150: }
151: else if( code == 4 ) { /* register error? */
152: asm("movl _reg_no,r7"); /* r7 = bad register # */
153: asm("movl _store_regs[r7],r8"); /* r8 = final (bad) value */
154: asm("movl _exp_regs[r7],r9"); /* r9 = expected value */
155: asm("movl _index,r10"); /* r10 = data index */
156: }
157: asm(".globl _hlt_sgl_acc");
158: asm("_hlt_sgl_acc:");
159: asm("halt");
160: }
161:
162:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.