![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mtpr.lst 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 mtpr.lst CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / d / macro4 |
1.1 root 1: 1 00000000 LL0:
2: 2 00000000 .data
3: 3 00000678 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _mtpr_tst
6: 6 00000000 _mtpr_tst:
7: 7 000259C4 0000 .word L215
8: 8 000259C6 #
9: 9 000259C6 # #include "fpp_defs.h"
10: 10 000259C6 #
11: 11 000259C6 # #define TBL_SIZE 1024 /* size of the prom table */
12: 12 000259C6 #
13: 13 000259C6 # /*****************************************************************************
14: 14 000259C6 # *
15: 15 000259C6 # * MTPR - TEST THE "READ TABLE DATA" MTPR INSTRUCTION
16: 16 000259C6 # *
17: 17 000259C6 # * This test checks the ability to use an MTPR to the Diagnostic Control
18: 18 000259C6 # * Register (DCR) to read an entry in the FPP tables.
19: 19 000259C6 # *
20: 20 000259C6 # * The instruction is:
21: 21 000259C6 # * MTPR $2048,$DCR
22: 22 000259C6 # * R0 = the table address to check
23: 23 000259C6 # *
24: 24 000259C6 # * The MTPR instruction will put the table data into R1.
25: 25 000259C6 # *
26: 26 000259C6 # *****************************************************************************/
27: 27 000259C6 # mtpr_tst()
28: 28 000259C6 # {
29: 29 000259C6 11 3a jbr L217
30: 30 000259C8 L218:
31: 31 000259C8 # asm(".globl _mtpr_t");
32: 32 000259C8 .globl _mtpr_t
33: 33 000259C8 # asm("_mtpr_t:"); /* entry address */
34: 34 000259C8 _mtpr_t:
35: 35 000259C8 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
36: 36 000259C8 1d effffffff6 01 cmpl _cycle,$1
37: 37 000259CF 21 15 jneq L219
38: 38 000259D1 5d efffffffed tstl _prt_hdrs
39: 39 000259D7 31 0d jeql L219
40: 40 000259D9 # writes(" MTPR");
41: 41 000259D9 .data 1
42: 42 00000678 * L221:
43: 43 00000678 * 204D54505200 .ascii " MTPR\0"
44: 44 0000067e * .text
45: 45 000259D9 dd 8f00000678 pushl $L221
46: 46 000259DF fe 08 efffffffde callf $8,_writes
47: 47 000259E6 # mtpr_1(); /* read w/ sgl accumulator */
48: 48 000259E6 L219:
49: 49 000259E6 fe 04 ef00000017 callf $4,_mtpr_1
50: 50 000259ED # mtpr_2(); /* read w/ dbl accumulator */
51: 51 000259ED fe 04 ef0000010a callf $4,_mtpr_2
52: 52 000259F4 # mtpr_3(); /* read during "sinf" */
53: 53 000259F4 fe 04 ef0000021b callf $4,_mtpr_3
54: 54 000259FB # asm("jmp *return"); /* return to the test monitor */
55: 55 000259FB 71 ffffffffc3 jmp *return
56: 56 00025A01 # }
57: 57 00025A01 40 ret#2
58: 58 00025A02 .set L215,0x0
59: 59 00025A02 L217:
60: 60 00025A02 11 c4 jbr L218
61: 61 00025A04 .data
62: 62 00000678 * .text
63: 63 00025A04 .align 1
64: 64 00025A04 .globl _mtpr_1
65: 65 00025A04 _mtpr_1:
66: 66 00025A04 0000 .word L225
67: 67 00025A06 #
68: 68 00025A06 #
69: 69 00025A06 #
70: 70 00025A06 # /************************************************************************
71: 71 00025A06 # *
72: 72 00025A06 # * SUBTEST 1 - Read the tables with a single precision accumulator
73: 73 00025A06 # *
74: 74 00025A06 # ************************************************************************/
75: 75 00025A06 # mtpr_1()
76: 76 00025A06 # {
77: 77 00025A06 13 00f2 jbr L227
78: 78 00025A09 L228:
79: 79 00025A09 # force_loop = FALSE;
80: 80 00025A09 4d efffffffb5 clrl _force_loop
81: 81 00025A0F # subtest = 1;
82: 82 00025A0F 0d 01 efffffffae movl $1,_subtest
83: 83 00025A16 # index = 0;
84: 84 00025A16 4d efffffffa8 clrl _index
85: 85 00025A1C # for( sgl_value_1 = 0; sgl_value_1 < TBL_SIZE; sgl_value_1++ ) {
86: 86 00025A1C 4d efffffffa2 clrl _sgl_value_1
87: 87 00025A22 L231:
88: 88 00025A22 1d efffffff9c 890400 cmpl _sgl_value_1,$1024
89: 89 00025A2B 91 03 13 00ca jgeq L230
90: 90 00025A30 # sgl_ld_acc = ldf_1_data[index].ld; /* get a sgl value */
91: 91 00025A30 0d efffffff8e 50 movl _index,r0
92: 92 00025A37 48 03 50 50 shll $3,r0,r0
93: 93 00025A3B 0d e000000000 efffffff7e movl _ldf_1_data(r0),_sgl_ld_acc
94: 94 00025A46 # sgl_expected = ldf_1_data[index].exp; /* & expected acc. */
95: 95 00025A46 0d efffffff78 50 movl _index,r0
96: 96 00025A4D 48 03 50 50 shll $3,r0,r0
97: 97 00025A51 0d e000000004 efffffff68 movl _ldf_1_data+4(r0),_sgl_expected
98: 98 00025A5C # /*
99: 99 00025A5C # * If LOOP ON ERROR is set, this is the loop for this subtest.
100: 100 00025A5C # * The force loop flag is set after the first error.
101: 101 00025A5C # */
102: 102 00025A5C # asm("_mtpr_1_lp1:");
103: 103 00025A5C _mtpr_1_lp1:
104: 104 00025A5C # asm("ldf _sgl_ld_acc"); /* load the accumulator */
105: 105 00025A5C 06 efffffff62 ldf _sgl_ld_acc
106: 106 00025A62 # asm("movl _sgl_value_1,r0"); /* move table address to r0 */
107: 107 00025A62 0d efffffff5c 50 movl _sgl_value_1,r0
108: 108 00025A69 # asm("clrl r1"); /* clear R1 */
109: 109 00025A69 4d 51 clrl r1
110: 110 00025A6B # asm("mtpr $0x800,$27"); /* read the table entry */
111: 111 00025A6B ad 890800 1b mtpr $0x800,$27
112: 112 00025A70 # asm("stf _sgl_st_acc"); /* save the accumulator */
113: 113 00025A70 26 efffffff4e stf _sgl_st_acc
114: 114 00025A76 # asm("movl r1,_sgl_value_2"); /* save the value read */
115: 115 00025A76 0d 51 efffffff47 movl r1,_sgl_value_2
116: 116 00025A7D # if( force_loop )
117: 117 00025A7D 5d efffffff41 tstl _force_loop
118: 118 00025A83 31 02 jeql L232
119: 119 00025A85 # asm("brb _mtpr_1_lp1");; /* loop on the error */
120: 120 00025A85 11 d5 brb _mtpr_1_lp1
121: 121 00025A87 L232:
122: 122 00025A87 # /*
123: 123 00025A87 # * end error loop
124: 124 00025A87 # */
125: 125 00025A87 # if( sgl_st_acc != sgl_expected ) { /* verify the accumulator */
126: 126 00025A87 1d efffffff37 efffffff32 cmpl _sgl_st_acc,_sgl_expected
127: 127 00025A92 31 41 jeql L233
128: 128 00025A94 # errcnt++; /* bump the error count */
129: 129 00025A94 6d efffffff2a incl _errcnt
130: 130 00025A9A # if( prt_error )
131: 131 00025A9A 5d efffffff24 tstl _prt_error
132: 132 00025AA0 31 0d jeql L234
133: 133 00025AA2 # print_mtpr_error(
134: 134 00025AA2 # " (SGL Accumulator) -THE ACC WAS MODIFIED");
135: 135 00025AA2 .data 1
136: 136 0000067e * L236:
137: 137 0000067e * 202853474C20416363756D756 .ascii " (SGL Accumulator) -THE ACC WAS MODIFIED\0"
138: C61746F7229202D5448452041
139: 434320574153204D4F4449464
140: 9454400
141: 138 000006a7 * .text
142: 139 00025AA2 dd 8f0000067e pushl $L236
143: 140 00025AA8 fe 08 ef000002eb callf $8,_print_mtpr_error
144: 141 00025AAF # if( halt_flg )
145: 142 00025AAF L234:
146: 143 00025AAF 5d efffffff0f tstl _halt_flg
147: 144 00025AB5 31 09 jeql L237
148: 145 00025AB7 # mtpr_er_halt( 2 );
149: 146 00025AB7 dd 02 pushl $2
150: 147 00025AB9 fe 08 ef000004a6 callf $8,_mtpr_er_halt
151: 148 00025AC0 # if( loop_on_err ) {
152: 149 00025AC0 L237:
153: 150 00025AC0 5d effffffefe tstl _loop_on_err
154: 151 00025AC6 31 0d jeql L239
155: 152 00025AC8 # force_loop = TRUE; /* set the force loop flag */
156: 153 00025AC8 0d 01 effffffef5 movl $1,_force_loop
157: 154 00025ACF # asm("jmp _mtpr_1_lp1"); /* and loop */
158: 155 00025ACF 71 efffffff87 jmp _mtpr_1_lp1
159: 156 00025AD5 # }
160: 157 00025AD5 # } /* end of compare error */
161: 158 00025AD5 L239:
162: 159 00025AD5 # if( ++index > max_ldf_1_index )
163: 160 00025AD5 L233:
164: 161 00025AD5 6d effffffee9 incl _index
165: 162 00025ADB 0d effffffee3 50 movl _index,r0
166: 163 00025AE2 1d 50 effffffedb cmpl r0,_max_ldf_1_index
167: 164 00025AE9 51 06 jleq L240
168: 165 00025AEB # index = 0; /* reset the Acc's index */
169: 166 00025AEB 4d effffffed3 clrl _index
170: 167 00025AF1 # }
171: 168 00025AF1 L240:
172: 169 00025AF1 L229:
173: 170 00025AF1 6d effffffecd incl _sgl_value_1
174: 171 00025AF7 13 ff28 jbr L231
175: 172 00025AFA L230:
176: 173 00025AFA # } /* end of subtest 1 */
177: 174 00025AFA 40 ret#2
178: 175 00025AFB .set L225,0x0
179: 176 00025AFB L227:
180: 177 00025AFB 13 ff0b jbr L228
181: 178 00025AFE .data
182: 179 00000678 * .text
183: 180 00025AFE .align 1
184: 181 00025AFE .globl _mtpr_2
185: 182 00025AFE _mtpr_2:
186: 183 00025AFE 0000 .word L241
187: 184 00025B00 #
188: 185 00025B00 #
189: 186 00025B00 #
190: 187 00025B00 #
191: 188 00025B00 #
192: 189 00025B00 # /************************************************************************
193: 190 00025B00 # *
194: 191 00025B00 # * SUBTEST 2 - Read the tables with a double precision accumulator
195: 192 00025B00 # *
196: 193 00025B00 # ************************************************************************/
197: 194 00025B00 # mtpr_2()
198: 195 00025B00 # {
199: 196 00025B00 13 010f jbr L243
200: 197 00025B03 L244:
201: 198 00025B03 # force_loop = FALSE;
202: 199 00025B03 4d effffffebb clrl _force_loop
203: 200 00025B09 # subtest = 2;
204: 201 00025B09 0d 02 effffffeb4 movl $2,_subtest
205: 202 00025B10 # index = 0;
206: 203 00025B10 4d effffffeae clrl _index
207: 204 00025B16 # for( sgl_value_1 = 0; sgl_value_1 < TBL_SIZE; sgl_value_1++ ) {
208: 205 00025B16 4d effffffea8 clrl _sgl_value_1
209: 206 00025B1C L247:
210: 207 00025B1C 1d effffffea2 890400 cmpl _sgl_value_1,$1024
211: 208 00025B25 91 03 13 00e7 jgeq L246
212: 209 00025B2A # dbl_ld_acc = ldd_1_data[index].ld; /* get a dbl value */
213: 210 00025B2A 48 04 effffffe93 50 shll $4,_index,r0
214: 211 00025B32 0c 8f00000000 50 addl2 $_ldd_1_data,r0
215: 212 00025B39 0d a004 effffffe87 movl 4(r0),_dbl_ld_acc+4
216: 213 00025B41 0d 60 effffffe7c movl (r0),_dbl_ld_acc
217: 214 00025B48 # dbl_expected = ldd_1_data[index].exp; /* & expected acc. */
218: 215 00025B48 48 04 effffffe75 50 shll $4,_index,r0
219: 216 00025B50 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
220: 217 00025B57 0d a004 effffffe69 movl 4(r0),_dbl_expected+4
221: 218 00025B5F 0d 60 effffffe5e movl (r0),_dbl_expected
222: 219 00025B66 # /*
223: 220 00025B66 # * If LOOP ON ERROR is set, this is the loop for this subtest.
224: 221 00025B66 # * The force loop flag is set after the first error.
225: 222 00025B66 # */
226: 223 00025B66 # asm("_mtpr_2_lp1:");
227: 224 00025B66 _mtpr_2_lp1:
228: 225 00025B66 # asm("ldd _dbl_ld_acc"); /* load the accumulator */
229: 226 00025B66 07 effffffe58 ldd _dbl_ld_acc
230: 227 00025B6C # asm("movl _sgl_value_1,r0"); /* move table address to r0 */
231: 228 00025B6C 0d effffffe52 50 movl _sgl_value_1,r0
232: 229 00025B73 # asm("clrl r1"); /* clear R1 */
233: 230 00025B73 4d 51 clrl r1
234: 231 00025B75 # asm("mtpr $0x800,$27"); /* read the table entry */
235: 232 00025B75 ad 890800 1b mtpr $0x800,$27
236: 233 00025B7A # asm("std _dbl_st_acc"); /* save the accumulator */
237: 234 00025B7A 27 effffffe44 std _dbl_st_acc
238: 235 00025B80 # asm("movl r1,_sgl_value_2"); /* save the value read */
239: 236 00025B80 0d 51 effffffe3d movl r1,_sgl_value_2
240: 237 00025B87 # if( force_loop )
241: 238 00025B87 5d effffffe37 tstl _force_loop
242: 239 00025B8D 31 02 jeql L248
243: 240 00025B8F # asm("brb _mtpr_2_lp1");; /* loop on the error */
244: 241 00025B8F 11 d5 brb _mtpr_2_lp1
245: 242 00025B91 L248:
246: 243 00025B91 # /*
247: 244 00025B91 # * end error loop
248: 245 00025B91 # */
249: 246 00025B91 # if( (dbl_st_acc.m != dbl_expected.m) || /* verify the acc. */
250: 247 00025B91 # (dbl_st_acc.l != dbl_expected.l) ) {
251: 248 00025B91 1d effffffe2d effffffe28 cmpl _dbl_st_acc,_dbl_expected
252: 249 00025B9C 21 0d jneq L9999
253: 250 00025B9E 1d effffffe24 effffffe1f cmpl _dbl_st_acc+4,_dbl_expected+4
254: 251 00025BA9 31 41 jeql L249
255: 252 00025BAB L9999:
256: 253 00025BAB # errcnt++; /* bump the error count */
257: 254 00025BAB 6d effffffe13 incl _errcnt
258: 255 00025BB1 # if( prt_error )
259: 256 00025BB1 5d effffffe0d tstl _prt_error
260: 257 00025BB7 31 0d jeql L250
261: 258 00025BB9 # print_mtpr_error(
262: 259 00025BB9 # " (DBL Accumulator) -THE ACC WAS MODIFIED");
263: 260 00025BB9 .data 1
264: 261 000006a7 * L251:
265: 262 000006a7 * 202844424C20416363756D756 .ascii " (DBL Accumulator) -THE ACC WAS MODIFIED\0"
266: C61746F7229202D5448452041
267: 434320574153204D4F4449464
268: 9454400
269: 263 000006d0 * .text
270: 264 00025BB9 dd 8f000006a7 pushl $L251
271: 265 00025BBF fe 08 ef000001d4 callf $8,_print_mtpr_error
272: 266 00025BC6 # if( halt_flg )
273: 267 00025BC6 L250:
274: 268 00025BC6 5d effffffdf8 tstl _halt_flg
275: 269 00025BCC 31 09 jeql L252
276: 270 00025BCE # mtpr_er_halt( 2 );
277: 271 00025BCE dd 02 pushl $2
278: 272 00025BD0 fe 08 ef0000038f callf $8,_mtpr_er_halt
279: 273 00025BD7 # if( loop_on_err ) {
280: 274 00025BD7 L252:
281: 275 00025BD7 5d effffffde7 tstl _loop_on_err
282: 276 00025BDD 31 0d jeql L253
283: 277 00025BDF # force_loop = TRUE; /* set the force loop flag */
284: 278 00025BDF 0d 01 effffffdde movl $1,_force_loop
285: 279 00025BE6 # asm("jmp _mtpr_2_lp1"); /* and loop */
286: 280 00025BE6 71 efffffff7a jmp _mtpr_2_lp1
287: 281 00025BEC # }
288: 282 00025BEC # } /* end of compare error */
289: 283 00025BEC L253:
290: 284 00025BEC # if( ++index > max_ldf_1_index )
291: 285 00025BEC L249:
292: 286 00025BEC 6d effffffdd2 incl _index
293: 287 00025BF2 0d effffffdcc 50 movl _index,r0
294: 288 00025BF9 1d 50 effffffdc4 cmpl r0,_max_ldf_1_index
295: 289 00025C00 51 06 jleq L254
296: 290 00025C02 # index = 0; /* reset the Acc's index */
297: 291 00025C02 4d effffffdbc clrl _index
298: 292 00025C08 # }
299: 293 00025C08 L254:
300: 294 00025C08 L245:
301: 295 00025C08 6d effffffdb6 incl _sgl_value_1
302: 296 00025C0E 13 ff0b jbr L247
303: 297 00025C11 L246:
304: 298 00025C11 # } /* end of subtest 2 */
305: 299 00025C11 40 ret#2
306: 300 00025C12 .set L241,0x0
307: 301 00025C12 L243:
308: 302 00025C12 13 feee jbr L244
309: 303 00025C15 .data
310: 304 00000678 * .text
311: 305 00025C15 00 .align 1
312: 306 00025C16 .globl _mtpr_3
313: 307 00025C16 _mtpr_3:
314: 308 00025C16 0000 .word L255
315: 309 00025C18 #
316: 310 00025C18 #
317: 311 00025C18 #
318: 312 00025C18 #
319: 313 00025C18 #
320: 314 00025C18 # /************************************************************************
321: 315 00025C18 # *
322: 316 00025C18 # * SUBTEST 3 - Read table data during a SINF function
323: 317 00025C18 # *
324: 318 00025C18 # * Read every 10th table entry while doing SINF's.
325: 319 00025C18 # * Read the entry once, read it again during a SINF, verify that the SINF
326: 320 00025C18 # * result is correct and that the same table data was read.
327: 321 00025C18 # ************************************************************************/
328: 322 00025C18 # mtpr_3()
329: 323 00025C18 # {
330: 324 00025C18 13 0178 jbr L257
331: 325 00025C1B L258:
332: 326 00025C1B # int max_index;
333: 327 00025C1B # force_loop = FALSE;
334: 328 00025C1B 4d effffffda3 clrl _force_loop
335: 329 00025C21 # subtest = 3;
336: 330 00025C21 0d 03 effffffd9c movl $3,_subtest
337: 331 00025C28 # max_index = TBL_SIZE / 10;
338: 332 00025C28 0d 8866 adc8 movl $102,-56(fp)
339: 333 00025C2D # if( max_index > max_sinf_1_index ) /* don't go over the SIN data */
340: 334 00025C2D 1d adc8 effffffd8f cmpl -56(fp),_max_sinf_1_index
341: 335 00025C35 51 08 jleq L259
342: 336 00025C37 # max_index = max_sinf_1_index; /* set the max index value */
343: 337 00025C37 0d effffffd87 adc8 movl _max_sinf_1_index,-56(fp)
344: 338 00025C3F # for( index = 0; index < max_sinf_1_index; index++ ) {
345: 339 00025C3F L259:
346: 340 00025C3F 4d effffffd7f clrl _index
347: 341 00025C45 L262:
348: 342 00025C45 1d effffffd79 effffffd74 cmpl _index,_max_sinf_1_index
349: 343 00025C50 91 03 13 013d jgeq L261
350: 344 00025C55 # sgl_value_1 = index * 10; /* get table entry to read */
351: 345 00025C55 5c 0a effffffd68 50 mull3 $10,_index,r0
352: 346 00025C5D 0d 50 effffffd60 movl r0,_sgl_value_1
353: 347 00025C64 # sgl_ld_acc = sinf_1_data[index].ld; /* get a sgl value */
354: 348 00025C64 0d effffffd5a 50 movl _index,r0
355: 349 00025C6B 48 03 50 50 shll $3,r0,r0
356: 350 00025C6F 0d e000000000 effffffd4a movl _sinf_1_data(r0),_sgl_ld_acc
357: 351 00025C7A # sgl_expected = sinf_1_data[index].exp; /* & expected acc. */
358: 352 00025C7A 0d effffffd44 50 movl _index,r0
359: 353 00025C81 48 03 50 50 shll $3,r0,r0
360: 354 00025C85 0d e000000004 effffffd34 movl _sinf_1_data+4(r0),_sgl_expected
361: 355 00025C90 # asm("movl _sgl_value_1,r0"); /* move table address to r0 */
362: 356 00025C90 0d effffffd2e 50 movl _sgl_value_1,r0
363: 357 00025C97 # asm("clrl r1"); /* clear R1 */
364: 358 00025C97 4d 51 clrl r1
365: 359 00025C99 # asm("mtpr $0x800,$27"); /* read the table entry */
366: 360 00025C99 ad 890800 1b mtpr $0x800,$27
367: 361 00025C9E # asm("movl r1,_sgl_value_3"); /* save the value read */
368: 362 00025C9E 0d 51 effffffd1f movl r1,_sgl_value_3
369: 363 00025CA5 # /*
370: 364 00025CA5 # * If LOOP ON ERROR is set, this is the loop for this subtest.
371: 365 00025CA5 # * The force loop flag is set after the first error.
372: 366 00025CA5 # */
373: 367 00025CA5 # asm("_mtpr_3_lp1:");
374: 368 00025CA5 _mtpr_3_lp1:
375: 369 00025CA5 # asm("ldf _sgl_ld_acc"); /* load the accumulator */
376: 370 00025CA5 06 effffffd19 ldf _sgl_ld_acc
377: 371 00025CAB # asm("movl _sgl_value_1,r0"); /* move table address to r0 */
378: 372 00025CAB 0d effffffd13 50 movl _sgl_value_1,r0
379: 373 00025CB2 # asm("clrl r1"); /* clear R1 */
380: 374 00025CB2 4d 51 clrl r1
381: 375 00025CB4 # asm("sinf"); /* start the SIN function */
382: 376 00025CB4 05 sinf
383: 377 00025CB5 # asm("mtpr $0x800,$27"); /* read the table entry */
384: 378 00025CB5 ad 890800 1b mtpr $0x800,$27
385: 379 00025CBA # asm("stf _sgl_st_acc"); /* save the accumulator */
386: 380 00025CBA 26 effffffd04 stf _sgl_st_acc
387: 381 00025CC0 # asm("movl r1,_sgl_value_2"); /* save the value read */
388: 382 00025CC0 0d 51 effffffcfd movl r1,_sgl_value_2
389: 383 00025CC7 # if( force_loop )
390: 384 00025CC7 5d effffffcf7 tstl _force_loop
391: 385 00025CCD 31 02 jeql L263
392: 386 00025CCF # asm("brb _mtpr_3_lp1");; /* loop on the error */
393: 387 00025CCF 11 d4 brb _mtpr_3_lp1
394: 388 00025CD1 L263:
395: 389 00025CD1 # /*
396: 390 00025CD1 # * end error loop
397: 391 00025CD1 # */
398: 392 00025CD1 # if( sgl_value_2 != sgl_value_3 ) { /* verify the data read */
399: 393 00025CD1 1d effffffced effffffce8 cmpl _sgl_value_2,_sgl_value_3
400: 394 00025CDC 31 41 jeql L264
401: 395 00025CDE # errcnt++; /* bump the error count */
402: 396 00025CDE 6d effffffce0 incl _errcnt
403: 397 00025CE4 # if( prt_error )
404: 398 00025CE4 5d effffffcda tstl _prt_error
405: 399 00025CEA 31 0d jeql L265
406: 400 00025CEC # print_mtpr_error( bad_tbl_entry_msg );
407: 401 00025CEC dd effffffcd2 pushl _bad_tbl_entry_msg
408: 402 00025CF2 fe 08 ef000000a1 callf $8,_print_mtpr_error
409: 403 00025CF9 # if( halt_flg )
410: 404 00025CF9 L265:
411: 405 00025CF9 5d effffffcc5 tstl _halt_flg
412: 406 00025CFF 31 09 jeql L266
413: 407 00025D01 # mtpr_er_halt( 1 );
414: 408 00025D01 dd 01 pushl $1
415: 409 00025D03 fe 08 ef0000025c callf $8,_mtpr_er_halt
416: 410 00025D0A # if( loop_on_err ) {
417: 411 00025D0A L266:
418: 412 00025D0A 5d effffffcb4 tstl _loop_on_err
419: 413 00025D10 31 0d jeql L267
420: 414 00025D12 # force_loop = TRUE; /* set the force loop flag */
421: 415 00025D12 0d 01 effffffcab movl $1,_force_loop
422: 416 00025D19 # asm("jmp _mtpr_3_lp1"); /* and loop */
423: 417 00025D19 71 efffffff86 jmp _mtpr_3_lp1
424: 418 00025D1F # }
425: 419 00025D1F # } /* end of table data compare error */
426: 420 00025D1F L267:
427: 421 00025D1F # if( sgl_st_acc != sgl_expected ) { /* verify the accumulator */
428: 422 00025D1F L264:
429: 423 00025D1F 1d effffffc9f effffffc9a cmpl _sgl_st_acc,_sgl_expected
430: 424 00025D2A 31 41 jeql L268
431: 425 00025D2C # errcnt++; /* bump the error count */
432: 426 00025D2C 6d effffffc92 incl _errcnt
433: 427 00025D32 # if( prt_error )
434: 428 00025D32 5d effffffc8c tstl _prt_error
435: 429 00025D38 31 0d jeql L269
436: 430 00025D3A # print_mtpr_error(" -BAD FINAL ACC");
437: 431 00025D3A .data 1
438: 432 000006d0 * L270:
439: 433 000006d0 * 20202D4241442046494E414C2 .ascii " -BAD FINAL ACC\0"
440: 041434300
441: 434 000006e1 * .text
442: 435 00025D3A dd 8f000006d0 pushl $L270
443: 436 00025D40 fe 08 ef00000053 callf $8,_print_mtpr_error
444: 437 00025D47 # if( halt_flg )
445: 438 00025D47 L269:
446: 439 00025D47 5d effffffc77 tstl _halt_flg
447: 440 00025D4D 31 09 jeql L271
448: 441 00025D4F # mtpr_er_halt( 3 );
449: 442 00025D4F dd 03 pushl $3
450: 443 00025D51 fe 08 ef0000020e callf $8,_mtpr_er_halt
451: 444 00025D58 # if( loop_on_err ) {
452: 445 00025D58 L271:
453: 446 00025D58 5d effffffc66 tstl _loop_on_err
454: 447 00025D5E 31 0d jeql L272
455: 448 00025D60 # force_loop = TRUE; /* set the force loop flag */
456: 449 00025D60 0d 01 effffffc5d movl $1,_force_loop
457: 450 00025D67 # asm("jmp _mtpr_3_lp1"); /* and loop */
458: 451 00025D67 71 efffffff38 jmp _mtpr_3_lp1
459: 452 00025D6D # }
460: 453 00025D6D # } /* end of SINF compare error */
461: 454 00025D6D L272:
462: 455 00025D6D # if( ++index > max_sinf_1_index )
463: 456 00025D6D L268:
464: 457 00025D6D 6d effffffc51 incl _index
465: 458 00025D73 0d effffffc4b 50 movl _index,r0
466: 459 00025D7A 1d 50 effffffc43 cmpl r0,_max_sinf_1_index
467: 460 00025D81 51 06 jleq L273
468: 461 00025D83 # index = 0; /* reset the Acc's index */
469: 462 00025D83 4d effffffc3b clrl _index
470: 463 00025D89 # }
471: 464 00025D89 L273:
472: 465 00025D89 L260:
473: 466 00025D89 6d effffffc35 incl _index
474: 467 00025D8F 13 feb3 jbr L262
475: 468 00025D92 L261:
476: 469 00025D92 # } /* end of subtest 3 */
477: 470 00025D92 40 ret#2
478: 471 00025D93 .set L255,0x0
479: 472 00025D93 L257:
480: 473 00025D93 3c 38 5d 5e subl3 $56,fp,sp
481: 474 00025D97 13 fe81 jbr L258
482: 475 00025D9A .data
483: 476 00000678 * .text
484: 477 00025D9A .align 1
485: 478 00025D9A .globl _print_mtpr_error
486: 479 00025D9A _print_mtpr_error:
487: 480 00025D9A 0000 .word L274
488: 481 00025D9C #
489: 482 00025D9C #
490: 483 00025D9C #
491: 484 00025D9C # /******************************************************************************
492: 485 00025D9C # *
493: 486 00025D9C # * Print an error message of the form:
494: 487 00025D9C # *
495: 488 00025D9C # * cycle: xx MTPR test xx, subtest xx <your message here>
496: 489 00025D9C # * table index = xxxxxxxx, table entry read = xxxxxxxx (2nd read)
497: 490 00025D9C # * expected entry = xxxxxxxx (1st read)
498: 491 00025D9C # * or
499: 492 00025D9C # * cycle: xx MTPR test xx, subtest xx <your message here>
500: 493 00025D9C # * table index = xxxxxxxx, table entry = xxxxxxxx
501: 494 00025D9C # * initial Acc = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx
502: 495 00025D9C # * expected Acc = xxxxxxxx xxxxxxxx
503: 496 00025D9C # ******************************************************************************/
504: 497 00025D9C # print_mtpr_error( msg )
505: 498 00025D9C # char *msg;
506: 499 00025D9C # {
507: 500 00025D9C 13 01c3 jbr L276
508: 501 00025D9F L277:
509: 502 00025D9F # writes(" \n"); /* start a new print line */
510: 503 00025D9F .data 1
511: 504 000006e1 * L278:
512: 505 000006e1 * 200A00 .ascii " \12\0"
513: 506 000006e4 * .text
514: 507 00025D9F dd 8f000006e1 pushl $L278
515: 508 00025DA5 fe 08 effffffc18 callf $8,_writes
516: 509 00025DAC # writes("cycle: ");
517: 510 00025DAC .data 1
518: 511 000006e4 * L279:
519: 512 000006e4 * 6379636C653A2000 .ascii "cycle: \0"
520: 513 000006ec * .text
521: 514 00025DAC dd 8f000006e4 pushl $L279
522: 515 00025DB2 fe 08 effffffc0b callf $8,_writes
523: 516 00025DB9 # writed( cycle );
524: 517 00025DB9 dd effffffc05 pushl _cycle
525: 518 00025DBF fe 08 effffffbfe callf $8,_writed
526: 519 00025DC6 # writes(" MTPR test ");
527: 520 00025DC6 .data 1
528: 521 000006ec * L281:
529: 522 000006ec * 20204D5450522074657374200 .ascii " MTPR test \0"
530: 0
531: 523 000006f9 * .text
532: 524 00025DC6 dd 8f000006ec pushl $L281
533: 525 00025DCC fe 08 effffffbf1 callf $8,_writes
534: 526 00025DD3 # writed( test_no );
535: 527 00025DD3 dd effffffbeb pushl _test_no
536: 528 00025DD9 fe 08 effffffbe4 callf $8,_writed
537: 529 00025DE0 # writes( msg );
538: 530 00025DE0 dd ad04 pushl 4(fp)
539: 531 00025DE3 fe 08 effffffbda callf $8,_writes
540: 532 00025DEA # writes("\ntable index = ");
541: 533 00025DEA .data 1
542: 534 000006f9 * L282:
543: 535 000006f9 * 0A7461626C6520696E6465782 .ascii "\12table index = \0"
544: 03D2000
545: 536 00000709 * .text
546: 537 00025DEA dd 8f000006f9 pushl $L282
547: 538 00025DF0 fe 08 effffffbcd callf $8,_writes
548: 539 00025DF7 # write32h( sgl_value_1 );
549: 540 00025DF7 dd effffffbc7 pushl _sgl_value_1
550: 541 00025DFD fe 08 effffffbc0 callf $8,_write32h
551: 542 00025E04 # if( msg == bad_tbl_entry_msg ) { /* bad data read? */
552: 543 00025E04 1d ad04 effffffbb8 cmpl 4(fp),_bad_tbl_entry_msg
553: 544 00025E0C 21 51 jneq L284
554: 545 00025E0E # writes(", table entry = ");
555: 546 00025E0E .data 1
556: 547 00000709 * L285:
557: 548 00000709 * 2C20207461626C6520656E747 .ascii ", table entry = \0"
558: 279203D2000
559: 549 0000071b * .text
560: 550 00025E0E dd 8f00000709 pushl $L285
561: 551 00025E14 fe 08 effffffba9 callf $8,_writes
562: 552 00025E1B # write32h( sgl_value_2 );
563: 553 00025E1B dd effffffba3 pushl _sgl_value_2
564: 554 00025E21 fe 08 effffffb9c callf $8,_write32h
565: 555 00025E28 # writes(" (2nd read)\n");
566: 556 00025E28 .data 1
567: 557 0000071b * L286:
568: 558 0000071b * 20202028326E6420726561642 .ascii " (2nd read)\12\0"
569: 90A00
570: 559 0000072a * .text
571: 560 00025E28 dd 8f0000071b pushl $L286
572: 561 00025E2E fe 08 effffffb8f callf $8,_writes
573: 562 00025E35 # writes(" entry expected = ");
574: 563 00025E35 .data 1
575: 564 0000072a * L287:
576: 565 0000072a * 2020202020202020202020202 .ascii " entry expected = \0"
577: 0202020202020202020656E74
578: 7279206578706563746564203
579: D2000
580: 566 00000752 * .text
581: 567 00025E35 dd 8f0000072a pushl $L287
582: 568 00025E3B fe 08 effffffb82 callf $8,_writes
583: 569 00025E42 # write32h( sgl_value_3 );
584: 570 00025E42 dd effffffb7c pushl _sgl_value_3
585: 571 00025E48 fe 08 effffffb75 callf $8,_write32h
586: 572 00025E4F # writes(" (1st read)\n");
587: 573 00025E4F .data 1
588: 574 00000752 * L288:
589: 575 00000752 * 2020202831737420726561642 .ascii " (1st read)\12\0"
590: 90A00
591: 576 00000761 * .text
592: 577 00025E4F dd 8f00000752 pushl $L288
593: 578 00025E55 fe 08 effffffb68 callf $8,_writes
594: 579 00025E5C # } else { /* bad accumulator error */
595: 580 00025E5C 13 0102 jbr L289
596: 581 00025E5F L284:
597: 582 00025E5F # writes(", table entry = ");
598: 583 00025E5F .data 1
599: 584 00000761 * L290:
600: 585 00000761 * 2C20207461626C6520656E747 .ascii ", table entry = \0"
601: 279203D2000
602: 586 00000773 * .text
603: 587 00025E5F dd 8f00000761 pushl $L290
604: 588 00025E65 fe 08 effffffb58 callf $8,_writes
605: 589 00025E6C # write32h( sgl_value_2 );
606: 590 00025E6C dd effffffb52 pushl _sgl_value_2
607: 591 00025E72 fe 08 effffffb4b callf $8,_write32h
608: 592 00025E79 # writes("\ninitial Acc = ");
609: 593 00025E79 .data 1
610: 594 00000773 * L291:
611: 595 00000773 * 0A696E697469616C204163632 .ascii "\12initial Acc = \0"
612: 03D2000
613: 596 00000783 * .text
614: 597 00025E79 dd 8f00000773 pushl $L291
615: 598 00025E7F fe 08 effffffb3e callf $8,_writes
616: 599 00025E86 # if( subtest == 2 ) { /* DBL precision? */
617: 600 00025E86 1d effffffb38 02 cmpl _subtest,$2
618: 601 00025E8D 31 03 13 0085 jneq L292
619: 602 00025E92 # write32h( dbl_ld_acc.m );
620: 603 00025E92 dd effffffb2c pushl _dbl_ld_acc
621: 604 00025E98 fe 08 effffffb25 callf $8,_write32h
622: 605 00025E9F # writec(' ');
623: 606 00025E9F dd 20 pushl $32
624: 607 00025EA1 fe 08 effffffb1c callf $8,_writec
625: 608 00025EA8 # write32h( dbl_ld_acc.l );
626: 609 00025EA8 dd effffffb1a pushl _dbl_ld_acc+4
627: 610 00025EAE fe 08 effffffb0f callf $8,_write32h
628: 611 00025EB5 # writes(", final Acc = ");
629: 612 00025EB5 .data 1
630: 613 00000783 * L294:
631: 614 00000783 * 2C2020202066696E616C20416 .ascii ", final Acc = \0"
632: 363203D2000
633: 615 00000795 * .text
634: 616 00025EB5 dd 8f00000783 pushl $L294
635: 617 00025EBB fe 08 effffffb02 callf $8,_writes
636: 618 00025EC2 # write32h( dbl_st_acc.m );
637: 619 00025EC2 dd effffffafc pushl _dbl_st_acc
638: 620 00025EC8 fe 08 effffffaf5 callf $8,_write32h
639: 621 00025ECF # writec(' ');
640: 622 00025ECF dd 20 pushl $32
641: 623 00025ED1 fe 08 effffffaec callf $8,_writec
642: 624 00025ED8 # write32h( dbl_st_acc.l );
643: 625 00025ED8 dd effffffaea pushl _dbl_st_acc+4
644: 626 00025EDE fe 08 effffffadf callf $8,_write32h
645: 627 00025EE5 # writes("\n expected Acc = ");
646: 628 00025EE5 .data 1
647: 629 00000795 * L295:
648: 630 00000795 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0"
649: 0202020202020202020202020
650: 2020202020202020206578706
651: 56374656420416363203D2000
652: 631 000007c7 * .text
653: 632 00025EE5 dd 8f00000795 pushl $L295
654: 633 00025EEB fe 08 effffffad2 callf $8,_writes
655: 634 00025EF2 # write32h( dbl_expected.m );
656: 635 00025EF2 dd effffffacc pushl _dbl_expected
657: 636 00025EF8 fe 08 effffffac5 callf $8,_write32h
658: 637 00025EFF # writec(' ');
659: 638 00025EFF dd 20 pushl $32
660: 639 00025F01 fe 08 effffffabc callf $8,_writec
661: 640 00025F08 # write32h( dbl_expected.l );
662: 641 00025F08 dd effffffaba pushl _dbl_expected+4
663: 642 00025F0E fe 08 effffffaaf callf $8,_write32h
664: 643 00025F15 # } else { /* SGL precision */
665: 644 00025F15 11 41 jbr L296
666: 645 00025F17 L292:
667: 646 00025F17 # write32h( sgl_ld_acc );
668: 647 00025F17 dd effffffaa7 pushl _sgl_ld_acc
669: 648 00025F1D fe 08 effffffaa0 callf $8,_write32h
670: 649 00025F24 # writes(", final Acc = ");
671: 650 00025F24 .data 1
672: 651 000007c7 * L297:
673: 652 000007c7 * 2C2020202066696E616C20416 .ascii ", final Acc = \0"
674: 363203D2000
675: 653 000007d9 * .text
676: 654 00025F24 dd 8f000007c7 pushl $L297
677: 655 00025F2A fe 08 effffffa93 callf $8,_writes
678: 656 00025F31 # write32h( sgl_st_acc );
679: 657 00025F31 dd effffffa8d pushl _sgl_st_acc
680: 658 00025F37 fe 08 effffffa86 callf $8,_write32h
681: 659 00025F3E # writes("\n expected Acc = ");
682: 660 00025F3E .data 1
683: 661 000007d9 * L298:
684: 662 000007d9 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0"
685: 0202020202020202020202020
686: 6578706563746564204163632
687: 03D2000
688: 663 00000802 * .text
689: 664 00025F3E dd 8f000007d9 pushl $L298
690: 665 00025F44 fe 08 effffffa79 callf $8,_writes
691: 666 00025F4B # write32h( sgl_expected );
692: 667 00025F4B dd effffffa73 pushl _sgl_expected
693: 668 00025F51 fe 08 effffffa6c callf $8,_write32h
694: 669 00025F58 # }
695: 670 00025F58 L296:
696: 671 00025F58 # writec('\n');
697: 672 00025F58 dd 0a pushl $10
698: 673 00025F5A fe 08 effffffa63 callf $8,_writec
699: 674 00025F61 # }
700: 675 00025F61 L289:
701: 676 00025F61 # }
702: 677 00025F61 40 ret#2
703: 678 00025F62 .set L274,0x0
704: 679 00025F62 L276:
705: 680 00025F62 13 fe3a jbr L277
706: 681 00025F65 .data
707: 682 00000678 * .text
708: 683 00025F65 00 .align 1
709: 684 00025F66 .globl _mtpr_er_halt
710: 685 00025F66 _mtpr_er_halt:
711: 686 00025F66 0000 .word L299
712: 687 00025F68 #
713: 688 00025F68 #
714: 689 00025F68 #
715: 690 00025F68 #
716: 691 00025F68 # /******************************************************************************
717: 692 00025F68 # *
718: 693 00025F68 # * halt with the failure information in registers
719: 694 00025F68 # *
720: 695 00025F68 # ******************************************************************************/
721: 696 00025F68 # mtpr_er_halt( code )
722: 697 00025F68 # int code; /* error code to halt with */
723: 698 00025F68 # {
724: 699 00025F68 13 00cc jbr L301
725: 700 00025F6B L302:
726: 701 00025F6B # sgl_dummy1 = code; /* get the halt code */
727: 702 00025F6B 0d ad04 effffffa51 movl 4(fp),_sgl_dummy1
728: 703 00025F73 # if( subtest != 2 ) { /* check for DBL accumulator */
729: 704 00025F73 1d effffffa4b 02 cmpl _subtest,$2
730: 705 00025F7A 31 33 jeql L303
731: 706 00025F7C # dbl_ld_acc.m = sgl_ld_acc; /* get the init Acc */
732: 707 00025F7C 0d effffffa42 effffffa3d movl _sgl_ld_acc,_dbl_ld_acc
733: 708 00025F87 # dbl_ld_acc.l = 0;
734: 709 00025F87 4d effffffa3b clrl _dbl_ld_acc+4
735: 710 00025F8D # dbl_st_acc.m = sgl_st_acc; /* get the final Acc */
736: 711 00025F8D 0d effffffa31 effffffa2c movl _sgl_st_acc,_dbl_st_acc
737: 712 00025F98 # dbl_st_acc.l = 0;
738: 713 00025F98 4d effffffa2a clrl _dbl_st_acc+4
739: 714 00025F9E # dbl_expected.m = sgl_expected; /* get the expected Acc */
740: 715 00025F9E 0d effffffa20 effffffa1b movl _sgl_expected,_dbl_expected
741: 716 00025FA9 # dbl_expected.l = 0;
742: 717 00025FA9 4d effffffa19 clrl _dbl_expected+4
743: 718 00025FAF # }
744: 719 00025FAF # asm("movl _test_no,r0"); /* r0 = test number */
745: 720 00025FAF L303:
746: 721 00025FAF 0d effffffa0f 50 movl _test_no,r0
747: 722 00025FB6 # asm("movl _subtest,r1"); /* r1 = subtest # */
748: 723 00025FB6 0d effffffa08 51 movl _subtest,r1
749: 724 00025FBD # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
750: 725 00025FBD 0d effffffa01 52 movl _sgl_dummy1,r2
751: 726 00025FC4 # asm("movl _cycle,r3"); /* r3 = cycle count */
752: 727 00025FC4 0d effffff9fa 53 movl _cycle,r3
753: 728 00025FCB # if( code == 2 ) { /* corrupted Acc */
754: 729 00025FCB 1d ad04 02 cmpl 4(fp),$2
755: 730 00025FCF 21 3a jneq L304
756: 731 00025FD1 # asm("movl _dbl_ld_acc,r4"); /* r4 = MS initial Acc */
757: 732 00025FD1 0d effffff9ed 54 movl _dbl_ld_acc,r4
758: 733 00025FD8 # asm("movl _dbl_ld_acc+4,r5"); /* r5 = LS initial Acc */
759: 734 00025FD8 0d effffff9ea 55 movl _dbl_ld_acc+4,r5
760: 735 00025FDF # asm("movl _dbl_st_acc,r6"); /* r6 = MS final Acc */
761: 736 00025FDF 0d effffff9df 56 movl _dbl_st_acc,r6
762: 737 00025FE6 # asm("movl _dbl_st_acc+4,r7"); /* r7 = LS final Acc */
763: 738 00025FE6 0d effffff9dc 57 movl _dbl_st_acc+4,r7
764: 739 00025FED # asm("movl _dbl_expected,r8"); /* r8 = MS expected */
765: 740 00025FED 0d effffff9d1 58 movl _dbl_expected,r8
766: 741 00025FF4 # asm("movl _dbl_expected+4,r9"); /* r9 = LS expected */
767: 742 00025FF4 0d effffff9ce 59 movl _dbl_expected+4,r9
768: 743 00025FFB # asm("movl _sgl_value_1,r10"); /* r10 = table addr. */
769: 744 00025FFB 0d effffff9c3 5a movl _sgl_value_1,r10
770: 745 00026002 # asm("movl _sgl_value_2,r11");; /* r11 = entry read */
771: 746 00026002 0d effffff9bc 5b movl _sgl_value_2,r11
772: 747 00026009 # } else { /* wrong data read or wrong final Acc */
773: 748 00026009 11 2a jbr L305
774: 749 0002600B L304:
775: 750 0002600B # asm("movl _sgl_value_1,r4"); /* r4 = table addr. */
776: 751 0002600B 0d effffff9b3 54 movl _sgl_value_1,r4
777: 752 00026012 # asm("movl _sgl_value_2,r5"); /* r5 = entry read */
778: 753 00026012 0d effffff9ac 55 movl _sgl_value_2,r5
779: 754 00026019 # asm("movl _sgl_value_3,r6"); /* r6 = expected entry */
780: 755 00026019 0d effffff9a5 56 movl _sgl_value_3,r6
781: 756 00026020 # asm("movl _sgl_ld_acc,r7"); /* r7 = initial Acc */
782: 757 00026020 0d effffff99e 57 movl _sgl_ld_acc,r7
783: 758 00026027 # asm("movl _sgl_st_acc,r8"); /* r8 = final Acc */
784: 759 00026027 0d effffff997 58 movl _sgl_st_acc,r8
785: 760 0002602E # asm("movl _sgl_expected,r9");; /* r9 = sgl expected */
786: 761 0002602E 0d effffff990 59 movl _sgl_expected,r9
787: 762 00026035 # };
788: 763 00026035 L305:
789: 764 00026035 # asm("halt");; /* HALT ... */
790: 765 00026035 00 halt
791: 766 00026036 # }
792: 767 00026036 40 ret#2
793: 768 00026037 .set L299,0x0
794: 769 00026037 L301:
795: 770 00026037 13 ff31 jbr L302
796: 771 0002603A .data
797: 771 0004B9FE .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.