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