![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe20.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 pipe20.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 000006bc * .text
4 00000000 .align 1
5 00000000 .globl _pipe_20
6 00000000 _pipe_20:
7 00033264 0000 .word L215
8 00033266 # #include "fpp_defs.h"
9 00033266 #
10 00033266 #
11 00033266 # /*****************************************************************************
12 00033266 # *
13 00033266 # * DBL PIPELINE TEST #20 MONITOR
14 00033266 # *
15 00033266 # * This test will do a series of 2, 3, 4, 5, and 6 NEGDs.
16 00033266 # * The data used will be the LDD data patterns.
17 00033266 # *
18 00033266 # *****************************************************************************/
19 00033266 # pipe_20()
20 00033266 # {
21 00033266 11 48 jbr L217
22 00033268 L218:
23 00033268 # asm(".globl _pipeline_20_t");
24 00033268 .globl _pipeline_20_t
25 00033268 # asm("_pipeline_20_t:"); /* entry address */
26 00033268 _pipeline_20_t:
27 00033268 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
28 00033268 1d effffffff6 01 cmpl _cycle,$1
29 0003326F 21 15 jneq L219
30 00033271 5d efffffffed tstl _prt_hdrs
31 00033277 31 0d jeql L219
32 00033279 # writes(" PIPE_20");
33 00033279 .data 1
34 000006bc * L221:
35 000006bc * 20504950455F323000 .ascii " PIPE_20\0"
36 000006c5 * .text
37 00033279 dd 8f000006bc pushl $L221
38 0003327F fe 08 efffffffde callf $8,_writes
39 00033286 # pipe20_1(); /* 2 NOPs */
40 00033286 L219:
41 00033286 fe 04 ef00000025 callf $4,_pipe20_1
42 0003328D # pipe20_2(); /* 3 NOPs */
43 0003328D fe 04 ef000000fe callf $4,_pipe20_2
44 00033294 # pipe20_3(); /* 4 NOPs */
45 00033294 fe 04 ef000001eb callf $4,_pipe20_3
46 0003329B # pipe20_4(); /* 5 NOPs */
47 0003329B fe 04 ef000002c6 callf $4,_pipe20_4
48 000332A2 # pipe20_5(); /* 6 NOPs */
49 000332A2 fe 04 ef000003b5 callf $4,_pipe20_5
50 000332A9 # asm("jmp *return"); /* return to the test monitor */
51 000332A9 71 ffffffffb5 jmp *return
52 000332AF # }
53 000332AF 40 ret#2
54 000332B0 .set L215,0x0
55 000332B0 L217:
56 000332B0 11 b6 jbr L218
57 000332B2 .data
58 000006bc * .text
59 000332B2 .align 1
60 000332B2 .globl _pipe20_1
61 000332B2 _pipe20_1:
62 000332B2 0000 .word L227
63 000332B4 #
64 000332B4 #
65 000332B4 #
66 000332B4 #
67 000332B4 #
68 000332B4 # /************************************************************************
69 000332B4 # *
70 000332B4 # * SUBTEST 1 : 2 NEGDs
71 000332B4 # *
72 000332B4 # ************************************************************************/
73 000332B4 # pipe20_1()
74 000332B4 # {
75 000332B4 13 00d8 jbr L229
76 000332B7 L230:
77 000332B7 # subtest = 1;
78 000332B7 0d 01 efffffffa6 movl $1,_subtest
79 000332BE # force_loop = FALSE;
80 000332BE 4d efffffffa0 clrl _force_loop
81 000332C4 # for( index = 0; index < max_ldd_1_index; index++ )
82 000332C4 4d efffffff9a clrl _index
83 000332CA L233:
84 000332CA 1d efffffff94 efffffff8f cmpl _index,_max_ldd_1_index
85 000332D5 91 03 13 00b4 jgeq L232
86 000332DA # {
87 000332DA # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
88 000332DA 48 04 efffffff83 50 shll $4,_index,r0
89 000332E2 0c 8f00000000 50 addl2 $_ldd_1_data,r0
90 000332E9 0d a004 efffffff77 movl 4(r0),_dbl_value_1+4
91 000332F1 0d 60 efffffff6c movl (r0),_dbl_value_1
92 000332F8 # dbl_expected = ldd_1_data[index].exp; /* get expected results */
93 000332F8 48 04 efffffff65 50 shll $4,_index,r0
94 00033300 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
95 00033307 0d a004 efffffff59 movl 4(r0),_dbl_expected+4
96 0003330F 0d 60 efffffff4e movl (r0),_dbl_expected
97 00033316 # /*
98 00033316 # * If LOOP ON ERROR is set, this is the loop for this subtest.
99 00033316 # * The force loop flag is set after the first error.
100 00033316 # */
101 00033316 # asm("_pipe20_1_lp1:");
102 00033316 _pipe20_1_lp1:
103 00033316 # asm("ldd _dbl_value_1"); /* load the operand */
104 00033316 07 efffffff48 ldd _dbl_value_1
105 0003331C # asm("negd"); /* negate it ( twice ) */
106 0003331C b7 negd
107 0003331D # asm("negd");
108 0003331D b7 negd
109 0003331E # asm("std _dbl_st_acc"); /* store the result */
110 0003331E 27 efffffff40 std _dbl_st_acc
111 00033324 # if( force_loop )
112 00033324 5d efffffff3a tstl _force_loop
113 0003332A 31 02 jeql L234
114 0003332C # asm("brb _pipe20_1_lp1"); /* loop on an error */
115 0003332C 11 e8 brb _pipe20_1_lp1
116 0003332E # /*
117 0003332E # * verify the results
118 0003332E # */
119 0003332E # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
120 0003332E L234:
121 0003332E # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
122 0003332E 1d efffffff30 efffffff2b cmpl _dbl_st_acc,_dbl_expected
123 00033339 21 0d jneq L9999
124 0003333B 1d efffffff27 efffffff22 cmpl _dbl_st_acc+4,_dbl_expected+4
125 00033346 31 3d jeql L235
126 00033348 L9999:
127 00033348 # errcnt++; /* bump the error count */
128 00033348 6d efffffff16 incl _errcnt
129 0003334E # if( prt_error )
130 0003334E 5d efffffff10 tstl _prt_error
131 00033354 31 09 jeql L236
132 00033356 # pipe20_print( 2 ); /* print error msg -2 NOPs */
133 00033356 dd 02 pushl $2
134 00033358 fe 08 ef000003e3 callf $8,_pipe20_print
135 0003335F # if( halt_flg ) /* halt on error? */
136 0003335F L236:
137 0003335F 5d effffffeff tstl _halt_flg
138 00033365 31 09 jeql L238
139 00033367 # pipe20_halt( 2 ); /* error halt -2 NOPs */
140 00033367 dd 02 pushl $2
141 00033369 fe 08 ef0000050a callf $8,_pipe20_halt
142 00033370 # if( loop_on_err ) {
143 00033370 L238:
144 00033370 5d effffffeee tstl _loop_on_err
145 00033376 31 0d jeql L240
146 00033378 # force_loop = TRUE; /* set the force loop flag */
147 00033378 0d 01 effffffee5 movl $1,_force_loop
148 0003337F # asm("jmp _pipe20_1_lp1"); /* and loop */
149 0003337F 71 efffffff91 jmp _pipe20_1_lp1
150 00033385 # }
151 00033385 # }
152 00033385 L240:
153 00033385 # } /* end of FOR loop */
154 00033385 L235:
155 00033385 L231:
156 00033385 6d effffffed9 incl _index
157 0003338B 13 ff3c jbr L233
158 0003338E L232:
159 0003338E # } /* end of subtest 1 */
160 0003338E 40 ret#2
161 0003338F .set L227,0x0
162 0003338F L229:
163 0003338F 13 ff25 jbr L230
164 00033392 .data
165 000006bc * .text
166 00033392 .align 1
167 00033392 .globl _pipe20_2
168 00033392 _pipe20_2:
169 00033392 0000 .word L241
170 00033394 #
171 00033394 #
172 00033394 #
173 00033394 #
174 00033394 #
175 00033394 # /************************************************************************
176 00033394 # *
177 00033394 # * SUBTEST 2 : 3 NEGDs
178 00033394 # *
179 00033394 # ************************************************************************/
180 00033394 # pipe20_2()
181 00033394 # {
182 00033394 13 00ec jbr L243
183 00033397 L244:
184 00033397 # subtest = 2;
185 00033397 0d 02 effffffec6 movl $2,_subtest
186 0003339E # force_loop = FALSE;
187 0003339E 4d effffffec0 clrl _force_loop
188 000333A4 # for( index = 0; index < max_ldd_1_index; index++ )
189 000333A4 4d effffffeba clrl _index
190 000333AA L247:
191 000333AA 1d effffffeb4 effffffeaf cmpl _index,_max_ldd_1_index
192 000333B5 91 03 13 00c8 jgeq L246
193 000333BA # {
194 000333BA # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
195 000333BA 48 04 effffffea3 50 shll $4,_index,r0
196 000333C2 0c 8f00000000 50 addl2 $_ldd_1_data,r0
197 000333C9 0d a004 effffffe97 movl 4(r0),_dbl_value_1+4
198 000333D1 0d 60 effffffe8c movl (r0),_dbl_value_1
199 000333D8 # dbl_expected = ldd_1_data[index].exp; /* get expected results */
200 000333D8 48 04 effffffe85 50 shll $4,_index,r0
201 000333E0 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
202 000333E7 0d a004 effffffe79 movl 4(r0),_dbl_expected+4
203 000333EF 0d 60 effffffe6e movl (r0),_dbl_expected
204 000333F6 # if( dbl_expected.m )
205 000333F6 5d effffffe68 tstl _dbl_expected
206 000333FC 31 0b jeql L248
207 000333FE # dbl_expected.m ^= 0x80000000; /* negate exptd results */
208 000333FE cc 8f80000000 effffffe5b xorl2 $-2147483648,_dbl_expected
209 00033409 # /*
210 00033409 # * If LOOP ON ERROR is set, this is the loop for this subtest.
211 00033409 # * The force loop flag is set after the first error.
212 00033409 # */
213 00033409 # asm("_pipe20_2_lp1:");
214 00033409 L248:
215 00033409 _pipe20_2_lp1:
216 00033409 # asm("ldd _dbl_value_1"); /* load the operand */
217 00033409 07 effffffe55 ldd _dbl_value_1
218 0003340F # asm("negd"); /* negate it ( 3 times ) */
219 0003340F b7 negd
220 00033410 # asm("negd");
221 00033410 b7 negd
222 00033411 # asm("negd");
223 00033411 b7 negd
224 00033412 # asm("std _dbl_st_acc"); /* store the result */
225 00033412 27 effffffe4c std _dbl_st_acc
226 00033418 # if( force_loop )
227 00033418 5d effffffe46 tstl _force_loop
228 0003341E 31 02 jeql L249
229 00033420 # asm("brb _pipe20_2_lp1"); /* loop on an error */
230 00033420 11 e7 brb _pipe20_2_lp1
231 00033422 # /*
232 00033422 # * verify the results
233 00033422 # */
234 00033422 # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
235 00033422 L249:
236 00033422 # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
237 00033422 1d effffffe3c effffffe37 cmpl _dbl_st_acc,_dbl_expected
238 0003342D 21 0d jneq L9998
239 0003342F 1d effffffe33 effffffe2e cmpl _dbl_st_acc+4,_dbl_expected+4
240 0003343A 31 3d jeql L250
241 0003343C L9998:
242 0003343C # errcnt++; /* bump the error count */
243 0003343C 6d effffffe22 incl _errcnt
244 00033442 # if( prt_error )
245 00033442 5d effffffe1c tstl _prt_error
246 00033448 31 09 jeql L251
247 0003344A # pipe20_print( 3 ); /* print error msg -3 NOPs */
248 0003344A dd 03 pushl $3
249 0003344C fe 08 ef000002ef callf $8,_pipe20_print
250 00033453 # if( halt_flg ) /* halt on error? */
251 00033453 L251:
252 00033453 5d effffffe0b tstl _halt_flg
253 00033459 31 09 jeql L252
254 0003345B # pipe20_halt( 3 ); /* error halt -3 NOPs */
255 0003345B dd 03 pushl $3
256 0003345D fe 08 ef00000416 callf $8,_pipe20_halt
257 00033464 # if( loop_on_err ) {
258 00033464 L252:
259 00033464 5d effffffdfa tstl _loop_on_err
260 0003346A 31 0d jeql L253
261 0003346C # force_loop = TRUE; /* set the force loop flag */
262 0003346C 0d 01 effffffdf1 movl $1,_force_loop
263 00033473 # asm("jmp _pipe20_2_lp1"); /* and loop */
264 00033473 71 efffffff90 jmp _pipe20_2_lp1
265 00033479 # }
266 00033479 # }
267 00033479 L253:
268 00033479 # } /* end of FOR loop */
269 00033479 L250:
270 00033479 L245:
271 00033479 6d effffffde5 incl _index
272 0003347F 13 ff28 jbr L247
273 00033482 L246:
274 00033482 # } /* end of subtest 2 */
275 00033482 40 ret#2
276 00033483 .set L241,0x0
277 00033483 L243:
278 00033483 13 ff11 jbr L244
279 00033486 .data
280 000006bc * .text
281 00033486 .align 1
282 00033486 .globl _pipe20_3
283 00033486 _pipe20_3:
284 00033486 0000 .word L254
285 00033488 #
286 00033488 #
287 00033488 #
288 00033488 #
289 00033488 #
290 00033488 # /************************************************************************
291 00033488 # *
292 00033488 # * SUBTEST 3 : 4 NEGDs
293 00033488 # *
294 00033488 # ************************************************************************/
295 00033488 # pipe20_3()
296 00033488 # {
297 00033488 13 00da jbr L256
298 0003348B L257:
299 0003348B # subtest = 3;
300 0003348B 0d 03 effffffdd2 movl $3,_subtest
301 00033492 # force_loop = FALSE;
302 00033492 4d effffffdcc clrl _force_loop
303 00033498 # for( index = 0; index < max_ldd_1_index; index++ )
304 00033498 4d effffffdc6 clrl _index
305 0003349E L260:
306 0003349E 1d effffffdc0 effffffdbb cmpl _index,_max_ldd_1_index
307 000334A9 91 03 13 00b6 jgeq L259
308 000334AE # {
309 000334AE # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
310 000334AE 48 04 effffffdaf 50 shll $4,_index,r0
311 000334B6 0c 8f00000000 50 addl2 $_ldd_1_data,r0
312 000334BD 0d a004 effffffda3 movl 4(r0),_dbl_value_1+4
313 000334C5 0d 60 effffffd98 movl (r0),_dbl_value_1
314 000334CC # dbl_expected = ldd_1_data[index].exp; /* get expected results */
315 000334CC 48 04 effffffd91 50 shll $4,_index,r0
316 000334D4 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
317 000334DB 0d a004 effffffd85 movl 4(r0),_dbl_expected+4
318 000334E3 0d 60 effffffd7a movl (r0),_dbl_expected
319 000334EA # /*
320 000334EA # * If LOOP ON ERROR is set, this is the loop for this subtest.
321 000334EA # * The force loop flag is set after the first error.
322 000334EA # */
323 000334EA # asm("_pipe20_3_lp1:");
324 000334EA _pipe20_3_lp1:
325 000334EA # asm("ldd _dbl_value_1"); /* load the operand */
326 000334EA 07 effffffd74 ldd _dbl_value_1
327 000334F0 # asm("negd"); /* negate it ( 4 times ) */
328 000334F0 b7 negd
329 000334F1 # asm("negd");
330 000334F1 b7 negd
331 000334F2 # asm("negd");
332 000334F2 b7 negd
333 000334F3 # asm("negd");
334 000334F3 b7 negd
335 000334F4 # asm("std _dbl_st_acc"); /* store the result */
336 000334F4 27 effffffd6a std _dbl_st_acc
337 000334FA # if( force_loop )
338 000334FA 5d effffffd64 tstl _force_loop
339 00033500 31 02 jeql L261
340 00033502 # asm("brb _pipe20_3_lp1"); /* loop on an error */
341 00033502 11 e6 brb _pipe20_3_lp1
342 00033504 # /*
343 00033504 # * verify the results
344 00033504 # */
345 00033504 # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
346 00033504 L261:
347 00033504 # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
348 00033504 1d effffffd5a effffffd55 cmpl _dbl_st_acc,_dbl_expected
349 0003350F 21 0d jneq L9997
350 00033511 1d effffffd51 effffffd4c cmpl _dbl_st_acc+4,_dbl_expected+4
351 0003351C 31 3d jeql L262
352 0003351E L9997:
353 0003351E # errcnt++; /* bump the error count */
354 0003351E 6d effffffd40 incl _errcnt
355 00033524 # if( prt_error )
356 00033524 5d effffffd3a tstl _prt_error
357 0003352A 31 09 jeql L263
358 0003352C # pipe20_print( 4 ); /* print error msg -4 NOPs */
359 0003352C dd 04 pushl $4
360 0003352E fe 08 ef0000020d callf $8,_pipe20_print
361 00033535 # if( halt_flg ) /* halt on error? */
362 00033535 L263:
363 00033535 5d effffffd29 tstl _halt_flg
364 0003353B 31 09 jeql L264
365 0003353D # pipe20_halt( 4 ); /* error halt -4 NOPs */
366 0003353D dd 04 pushl $4
367 0003353F fe 08 ef00000334 callf $8,_pipe20_halt
368 00033546 # if( loop_on_err ) {
369 00033546 L264:
370 00033546 5d effffffd18 tstl _loop_on_err
371 0003354C 31 0d jeql L265
372 0003354E # force_loop = TRUE; /* set the force loop flag */
373 0003354E 0d 01 effffffd0f movl $1,_force_loop
374 00033555 # asm("jmp _pipe20_3_lp1"); /* and loop */
375 00033555 71 efffffff8f jmp _pipe20_3_lp1
376 0003355B # }
377 0003355B # }
378 0003355B L265:
379 0003355B # } /* end of FOR loop */
380 0003355B L262:
381 0003355B L258:
382 0003355B 6d effffffd03 incl _index
383 00033561 13 ff3a jbr L260
384 00033564 L259:
385 00033564 # } /* end of subtest 3 */
386 00033564 40 ret#2
387 00033565 .set L254,0x0
388 00033565 L256:
389 00033565 13 ff23 jbr L257
390 00033568 .data
391 000006bc * .text
392 00033568 .align 1
393 00033568 .globl _pipe20_4
394 00033568 _pipe20_4:
395 00033568 0000 .word L266
396 0003356A #
397 0003356A #
398 0003356A #
399 0003356A #
400 0003356A #
401 0003356A #
402 0003356A # /************************************************************************
403 0003356A # *
404 0003356A # * SUBTEST 4 : 5 NEGDs
405 0003356A # *
406 0003356A # ************************************************************************/
407 0003356A # pipe20_4()
408 0003356A # {
409 0003356A 13 00ee jbr L268
410 0003356D L269:
411 0003356D # subtest = 4;
412 0003356D 0d 04 effffffcf0 movl $4,_subtest
413 00033574 # force_loop = FALSE;
414 00033574 4d effffffcea clrl _force_loop
415 0003357A # for( index = 0; index < max_ldd_1_index; index++ )
416 0003357A 4d effffffce4 clrl _index
417 00033580 L272:
418 00033580 1d effffffcde effffffcd9 cmpl _index,_max_ldd_1_index
419 0003358B 91 03 13 00ca jgeq L271
420 00033590 # {
421 00033590 # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
422 00033590 48 04 effffffccd 50 shll $4,_index,r0
423 00033598 0c 8f00000000 50 addl2 $_ldd_1_data,r0
424 0003359F 0d a004 effffffcc1 movl 4(r0),_dbl_value_1+4
425 000335A7 0d 60 effffffcb6 movl (r0),_dbl_value_1
426 000335AE # dbl_expected = ldd_1_data[index].exp; /* get expected results */
427 000335AE 48 04 effffffcaf 50 shll $4,_index,r0
428 000335B6 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
429 000335BD 0d a004 effffffca3 movl 4(r0),_dbl_expected+4
430 000335C5 0d 60 effffffc98 movl (r0),_dbl_expected
431 000335CC # if( dbl_expected.m )
432 000335CC 5d effffffc92 tstl _dbl_expected
433 000335D2 31 0b jeql L273
434 000335D4 # dbl_expected.m ^= 0x80000000; /* negate exptd results */
435 000335D4 cc 8f80000000 effffffc85 xorl2 $-2147483648,_dbl_expected
436 000335DF # /*
437 000335DF # * If LOOP ON ERROR is set, this is the loop for this subtest.
438 000335DF # * The force loop flag is set after the first error.
439 000335DF # */
440 000335DF # asm("_pipe20_4_lp1:");
441 000335DF L273:
442 000335DF _pipe20_4_lp1:
443 000335DF # asm("ldd _dbl_value_1"); /* load the operand */
444 000335DF 07 effffffc7f ldd _dbl_value_1
445 000335E5 # asm("negd"); /* negate it ( 5 times ) */
446 000335E5 b7 negd
447 000335E6 # asm("negd");
448 000335E6 b7 negd
449 000335E7 # asm("negd");
450 000335E7 b7 negd
451 000335E8 # asm("negd");
452 000335E8 b7 negd
453 000335E9 # asm("negd");
454 000335E9 b7 negd
455 000335EA # asm("std _dbl_st_acc"); /* store the result */
456 000335EA 27 effffffc74 std _dbl_st_acc
457 000335F0 # if( force_loop )
458 000335F0 5d effffffc6e tstl _force_loop
459 000335F6 31 02 jeql L274
460 000335F8 # asm("brb _pipe20_4_lp1"); /* loop on an error */
461 000335F8 11 e5 brb _pipe20_4_lp1
462 000335FA # /*
463 000335FA # * verify the results
464 000335FA # */
465 000335FA # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
466 000335FA L274:
467 000335FA # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
468 000335FA 1d effffffc64 effffffc5f cmpl _dbl_st_acc,_dbl_expected
469 00033605 21 0d jneq L9996
470 00033607 1d effffffc5b effffffc56 cmpl _dbl_st_acc+4,_dbl_expected+4
471 00033612 31 3d jeql L275
472 00033614 L9996:
473 00033614 # errcnt++; /* bump the error count */
474 00033614 6d effffffc4a incl _errcnt
475 0003361A # if( prt_error )
476 0003361A 5d effffffc44 tstl _prt_error
477 00033620 31 09 jeql L276
478 00033622 # pipe20_print( 5 ); /* print error msg -5 NOPs */
479 00033622 dd 05 pushl $5
480 00033624 fe 08 ef00000117 callf $8,_pipe20_print
481 0003362B # if( halt_flg ) /* halt on error? */
482 0003362B L276:
483 0003362B 5d effffffc33 tstl _halt_flg
484 00033631 31 09 jeql L277
485 00033633 # pipe20_halt( 5 ); /* error halt -5 NOPs */
486 00033633 dd 05 pushl $5
487 00033635 fe 08 ef0000023e callf $8,_pipe20_halt
488 0003363C # if( loop_on_err ) {
489 0003363C L277:
490 0003363C 5d effffffc22 tstl _loop_on_err
491 00033642 31 0d jeql L278
492 00033644 # force_loop = TRUE; /* set the force loop flag */
493 00033644 0d 01 effffffc19 movl $1,_force_loop
494 0003364B # asm("jmp _pipe20_4_lp1"); /* and loop */
495 0003364B 71 efffffff8e jmp _pipe20_4_lp1
496 00033651 # }
497 00033651 # }
498 00033651 L278:
499 00033651 # } /* end of FOR loop */
500 00033651 L275:
501 00033651 L270:
502 00033651 6d effffffc0d incl _index
503 00033657 13 ff26 jbr L272
504 0003365A L271:
505 0003365A # } /* end of subtest 4 */
506 0003365A 40 ret#2
507 0003365B .set L266,0x0
508 0003365B L268:
509 0003365B 13 ff0f jbr L269
510 0003365E .data
511 000006bc * .text
512 0003365E .align 1
513 0003365E .globl _pipe20_5
514 0003365E _pipe20_5:
515 0003365E 0000 .word L279
516 00033660 #
517 00033660 #
518 00033660 #
519 00033660 #
520 00033660 #
521 00033660 # /************************************************************************
522 00033660 # *
523 00033660 # * SUBTEST 5 : 6 NEGDs
524 00033660 # *
525 00033660 # ************************************************************************/
526 00033660 # pipe20_5()
527 00033660 # {
528 00033660 13 00dc jbr L281
529 00033663 L282:
530 00033663 # subtest = 5;
531 00033663 0d 05 effffffbfa movl $5,_subtest
532 0003366A # force_loop = FALSE;
533 0003366A 4d effffffbf4 clrl _force_loop
534 00033670 # for( index = 0; index < max_ldd_1_index; index++ )
535 00033670 4d effffffbee clrl _index
536 00033676 L285:
537 00033676 1d effffffbe8 effffffbe3 cmpl _index,_max_ldd_1_index
538 00033681 91 03 13 00b8 jgeq L284
539 00033686 # {
540 00033686 # dbl_value_1 = ldd_1_data[index].ld; /* get operand 1 */
541 00033686 48 04 effffffbd7 50 shll $4,_index,r0
542 0003368E 0c 8f00000000 50 addl2 $_ldd_1_data,r0
543 00033695 0d a004 effffffbcb movl 4(r0),_dbl_value_1+4
544 0003369D 0d 60 effffffbc0 movl (r0),_dbl_value_1
545 000336A4 # dbl_expected = ldd_1_data[index].exp; /* get expected results */
546 000336A4 48 04 effffffbb9 50 shll $4,_index,r0
547 000336AC 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
548 000336B3 0d a004 effffffbad movl 4(r0),_dbl_expected+4
549 000336BB 0d 60 effffffba2 movl (r0),_dbl_expected
550 000336C2 # /*
551 000336C2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
552 000336C2 # * The force loop flag is set after the first error.
553 000336C2 # */
554 000336C2 # asm("_pipe20_5_lp1:");
555 000336C2 _pipe20_5_lp1:
556 000336C2 # asm("ldd _dbl_value_1"); /* load the operand */
557 000336C2 07 effffffb9c ldd _dbl_value_1
558 000336C8 # asm("negd"); /* negate it ( 6 times ) */
559 000336C8 b7 negd
560 000336C9 # asm("negd");
561 000336C9 b7 negd
562 000336CA # asm("negd");
563 000336CA b7 negd
564 000336CB # asm("negd");
565 000336CB b7 negd
566 000336CC # asm("negd");
567 000336CC b7 negd
568 000336CD # asm("negd");
569 000336CD b7 negd
570 000336CE # asm("std _dbl_st_acc"); /* store the result */
571 000336CE 27 effffffb90 std _dbl_st_acc
572 000336D4 # if( force_loop )
573 000336D4 5d effffffb8a tstl _force_loop
574 000336DA 31 02 jeql L286
575 000336DC # asm("brb _pipe20_5_lp1"); /* loop on an error */
576 000336DC 11 e4 brb _pipe20_5_lp1
577 000336DE # /*
578 000336DE # * verify the results
579 000336DE # */
580 000336DE # if( (dbl_st_acc.m != dbl_expected.m) || /* COMPARE the stored */
581 000336DE L286:
582 000336DE # (dbl_st_acc.l != dbl_expected.l) ) { /* to the expected */
583 000336DE 1d effffffb80 effffffb7b cmpl _dbl_st_acc,_dbl_expected
584 000336E9 21 0d jneq L9995
585 000336EB 1d effffffb77 effffffb72 cmpl _dbl_st_acc+4,_dbl_expected+4
586 000336F6 31 3d jeql L287
587 000336F8 L9995:
588 000336F8 # errcnt++; /* bump the error count */
589 000336F8 6d effffffb66 incl _errcnt
590 000336FE # if( prt_error )
591 000336FE 5d effffffb60 tstl _prt_error
592 00033704 31 09 jeql L288
593 00033706 # pipe20_print( 6 ); /* print error msg -6 NOPs */
594 00033706 dd 06 pushl $6
595 00033708 fe 08 ef00000033 callf $8,_pipe20_print
596 0003370F # if( halt_flg ) /* halt on error? */
597 0003370F L288:
598 0003370F 5d effffffb4f tstl _halt_flg
599 00033715 31 09 jeql L289
600 00033717 # pipe20_halt( 6 ); /* error halt -6 NOPs */
601 00033717 dd 06 pushl $6
602 00033719 fe 08 ef0000015a callf $8,_pipe20_halt
603 00033720 # if( loop_on_err ) {
604 00033720 L289:
605 00033720 5d effffffb3e tstl _loop_on_err
606 00033726 31 0d jeql L290
607 00033728 # force_loop = TRUE; /* set the force loop flag */
608 00033728 0d 01 effffffb35 movl $1,_force_loop
609 0003372F # asm("jmp _pipe20_5_lp1"); /* and loop */
610 0003372F 71 efffffff8d jmp _pipe20_5_lp1
611 00033735 # }
612 00033735 # }
613 00033735 L290:
614 00033735 # } /* end of FOR loop */
615 00033735 L287:
616 00033735 L283:
617 00033735 6d effffffb29 incl _index
618 0003373B 13 ff38 jbr L285
619 0003373E L284:
620 0003373E # } /* end of subtest 5 */
621 0003373E 40 ret#2
622 0003373F .set L279,0x0
623 0003373F L281:
624 0003373F 13 ff21 jbr L282
625 00033742 .data
626 000006bc * .text
627 00033742 .align 1
628 00033742 .globl _pipe20_print
629 00033742 _pipe20_print:
630 00033742 0000 .word L291
631 00033744 #
632 00033744 #
633 00033744 #
634 00033744 #
635 00033744 # /****************************************************************************
636 00033744 # *
637 00033744 # * PRINT AN ERROR MESSAGE
638 00033744 # *
639 00033744 # * cycle dd PIPELINE 20, subtest dd error
640 00033744 # * LDD op, {NEGD}, STD
641 00033744 # * operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd
642 00033744 # * expected Acc = xxxxxxxx xxxxxxxx
643 00033744 # *
644 00033744 # ****************************************************************************/
645 00033744 # pipe20_print( nop_count )
646 00033744 # int nop_count; /* # of NOP instructions */
647 00033744 # {
648 00033744 13 0130 jbr L293
649 00033747 L294:
650 00033747 # writes(" \n"); /* start a new print line */
651 00033747 .data 1
652 000006c5 * L295:
653 000006c5 * 200A00 .ascii " \12\0"
654 000006c8 * .text
655 00033747 dd 8f000006c5 pushl $L295
656 0003374D fe 08 effffffb10 callf $8,_writes
657 00033754 # writes("cycle: ");
658 00033754 .data 1
659 000006c8 * L296:
660 000006c8 * 6379636C653A2000 .ascii "cycle: \0"
661 000006d0 * .text
662 00033754 dd 8f000006c8 pushl $L296
663 0003375A fe 08 effffffb03 callf $8,_writes
664 00033761 # writed( cycle );
665 00033761 dd effffffafd pushl _cycle
666 00033767 fe 08 effffffaf6 callf $8,_writed
667 0003376E # writes(" PIPELINE 20, subtest ");
668 0003376E .data 1
669 000006d0 * L298:
670 000006d0 * 2020504950454C494E4520323 .ascii " PIPELINE 20, subtest \0"
02C20737562746573742000
671 000006e8 * .text
672 0003376E dd 8f000006d0 pushl $L298
673 00033774 fe 08 effffffae9 callf $8,_writes
674 0003377B # writed( subtest );
675 0003377B dd effffffae3 pushl _subtest
676 00033781 fe 08 effffffadc callf $8,_writed
677 00033788 # writes(" error\n");
678 00033788 .data 1
679 000006e8 * L299:
680 000006e8 * 206572726F720A00 .ascii " error\12\0"
681 000006f0 * .text
682 00033788 dd 8f000006e8 pushl $L299
683 0003378E fe 08 effffffacf callf $8,_writes
684 00033795 # writes(" LDD(op), NEGD");
685 00033795 .data 1
686 000006f0 * L300:
687 000006f0 * 204C4444286F70292C204E454 .ascii " LDD(op), NEGD\0"
74400
688 000006ff * .text
689 00033795 dd 8f000006f0 pushl $L300
690 0003379B fe 08 effffffac2 callf $8,_writes
691 000337A2 # while( --nop_count )
692 000337A2 L301:
693 000337A2 7d ad04 decl 4(fp)
694 000337A5 31 0f jeql L302
695 000337A7 # writes(", NEGD");
696 000337A7 .data 1
697 000006ff * L303:
698 000006ff * 2C204E45474400 .ascii ", NEGD\0"
699 00000706 * .text
700 000337A7 dd 8f000006ff pushl $L303
701 000337AD fe 08 effffffab0 callf $8,_writes
702 000337B4 11 ec jbr L301
703 000337B6 L302:
704 000337B6 # writes(", STD\n");
705 000337B6 .data 1
706 00000706 * L304:
707 00000706 * 2C205354440A00 .ascii ", STD\12\0"
708 0000070d * .text
709 000337B6 dd 8f00000706 pushl $L304
710 000337BC fe 08 effffffaa1 callf $8,_writes
711 000337C3 # writes("operand = ");
712 000337C3 .data 1
713 0000070d * L305:
714 0000070d * 6F706572616E64203D2000 .ascii "operand = \0"
715 00000718 * .text
716 000337C3 dd 8f0000070d pushl $L305
717 000337C9 fe 08 effffffa94 callf $8,_writes
718 000337D0 # write32h( dbl_value_1.m );
719 000337D0 dd effffffa8e pushl _dbl_value_1
720 000337D6 fe 08 effffffa87 callf $8,_write32h
721 000337DD # writec(' ');
722 000337DD dd 20 pushl $32
723 000337DF fe 08 effffffa7e callf $8,_writec
724 000337E6 # write32h( dbl_value_1.l );
725 000337E6 dd effffffa7c pushl _dbl_value_1+4
726 000337EC fe 08 effffffa71 callf $8,_write32h
727 000337F3 # writes(", final Acc = ");
728 000337F3 .data 1
729 00000718 * L308:
730 00000718 * 2C202066696E616C204163632 .ascii ", final Acc = \0"
03D2000
731 00000728 * .text
732 000337F3 dd 8f00000718 pushl $L308
733 000337F9 fe 08 effffffa64 callf $8,_writes
734 00033800 # write32h( dbl_st_acc.m );
735 00033800 dd effffffa5e pushl _dbl_st_acc
736 00033806 fe 08 effffffa57 callf $8,_write32h
737 0003380D # writec(' ');
738 0003380D dd 20 pushl $32
739 0003380F fe 08 effffffa4e callf $8,_writec
740 00033816 # write32h( dbl_st_acc.l );
741 00033816 dd effffffa4c pushl _dbl_st_acc+4
742 0003381C fe 08 effffffa41 callf $8,_write32h
743 00033823 # writes(", index = ");
744 00033823 .data 1
745 00000728 * L309:
746 00000728 * 2C202020696E646578203D200 .ascii ", index = \0"
0
747 00000735 * .text
748 00033823 dd 8f00000728 pushl $L309
749 00033829 fe 08 effffffa34 callf $8,_writes
750 00033830 # writed( index );
751 00033830 dd effffffa2e pushl _index
752 00033836 fe 08 effffffa27 callf $8,_writed
753 0003383D # writes("\n expected Acc = ");
754 0003383D .data 1
755 00000735 * L310:
756 00000735 * 0A20202020202020202020202 .ascii "\12 expected Acc = \0"
0202020202020202020202020
2020206578706563746564204
16363203D2000
757 00000761 * .text
758 0003383D dd 8f00000735 pushl $L310
759 00033843 fe 08 effffffa1a callf $8,_writes
760 0003384A # write32h( dbl_expected.m );
761 0003384A dd effffffa14 pushl _dbl_expected
762 00033850 fe 08 effffffa0d callf $8,_write32h
763 00033857 # writec(' ');
764 00033857 dd 20 pushl $32
765 00033859 fe 08 effffffa04 callf $8,_writec
766 00033860 # write32h( dbl_expected.l );
767 00033860 dd effffffa02 pushl _dbl_expected+4
768 00033866 fe 08 effffff9f7 callf $8,_write32h
769 0003386D # writec('\n');
770 0003386D dd 0a pushl $10
771 0003386F fe 08 effffff9ee callf $8,_writec
772 00033876 # }
773 00033876 40 ret#2
774 00033877 .set L291,0x0
775 00033877 L293:
776 00033877 13 fecd jbr L294
777 0003387A .data
778 000006bc * .text
779 0003387A .align 1
780 0003387A .globl _pipe20_halt
781 0003387A _pipe20_halt:
782 0003387A 0000 .word L311
783 0003387C #
784 0003387C #
785 0003387C #
786 0003387C # /****************************************************************************
787 0003387C # *
788 0003387C # * SET UP THE REGISTERS AND HALT
789 0003387C # *
790 0003387C # ****************************************************************************/
791 0003387C # pipe20_halt( nop_count )
792 0003387C # int nop_count; /* # of NOP instructions */
793 0003387C # {
794 0003387C 13 009c jbr L313
795 0003387F L314:
796 0003387F # sgl_dummy1 = nop_count;
797 0003387F 0d ad04 effffff9dd movl 4(fp),_sgl_dummy1
798 00033887 # sgl_value_1 = dbl_value_1.m;
799 00033887 0d effffff9d7 effffff9d2 movl _dbl_value_1,_sgl_value_1
800 00033892 # sgl_value_2 = dbl_value_1.l;
801 00033892 0d effffff9d0 effffff9c7 movl _dbl_value_1+4,_sgl_value_2
802 0003389D # sgl_value_3 = dbl_st_acc.m;
803 0003389D 0d effffff9c1 effffff9bc movl _dbl_st_acc,_sgl_value_3
804 000338A8 # sgl_value_4 = dbl_st_acc.l;
805 000338A8 0d effffff9ba effffff9b1 movl _dbl_st_acc+4,_sgl_value_4
806 000338B3 # sgl_value_5 = dbl_expected.m;
807 000338B3 0d effffff9ab effffff9a6 movl _dbl_expected,_sgl_value_5
808 000338BE # sgl_value_6 = dbl_expected.l;
809 000338BE 0d effffff9a4 effffff99b movl _dbl_expected+4,_sgl_value_6
810 000338C9 # asm("movl _test_no,r0"); /* r0 = test number */
811 000338C9 0d effffff995 50 movl _test_no,r0
812 000338D0 # asm("movl _subtest,r1"); /* r1 = subtest number */
813 000338D0 0d effffff98e 51 movl _subtest,r1
814 000338D7 # asm("movl $1,r2"); /* r2 = error code */
815 000338D7 0d 01 52 movl $1,r2
816 000338DA # asm("movl _cycle,r3"); /* r3 = cycle count */
817 000338DA 0d effffff984 53 movl _cycle,r3
818 000338E1 # asm("movl _sgl_dummy1,r4"); /* r4 = # of NEGDS */
819 000338E1 0d effffff97d 54 movl _sgl_dummy1,r4
820 000338E8 # asm("movl _sgl_value_1,r5"); /* r5 = MS operand */
821 000338E8 0d effffff976 55 movl _sgl_value_1,r5
822 000338EF # asm("movl _sgl_value_2,r6"); /* r6 = LS operand */
823 000338EF 0d effffff96f 56 movl _sgl_value_2,r6
824 000338F6 # asm("movl _sgl_value_3,r7"); /* r7 = MS stored */
825 000338F6 0d effffff968 57 movl _sgl_value_3,r7
826 000338FD # asm("movl _sgl_value_4,r8"); /* r8 = LS stored */
827 000338FD 0d effffff961 58 movl _sgl_value_4,r8
828 00033904 # asm("movl _sgl_value_5,r9"); /* r9 = MS expected */
829 00033904 0d effffff95a 59 movl _sgl_value_5,r9
830 0003390B # asm("movl _sgl_value_6,r10"); /* r10 = LS expected */
831 0003390B 0d effffff953 5a movl _sgl_value_6,r10
832 00033912 # asm("movl _index,r11"); /* r11 = data index */
833 00033912 0d effffff94c 5b movl _index,r11
834 00033919 # asm("halt"); /* HALT ... */
835 00033919 00 halt
836 0003391A # }
837 0003391A 40 ret#2
838 0003391B .set L311,0x0
839 0003391B L313:
840 0003391B 13 ff61 jbr L314
841 0003391E .data
841 00066B82 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.