![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe11.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 pipe11.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 000005a8 * .text
4 00000000 .align 1
5 00000000 .globl _pipe_11
6 00000000 _pipe_11:
7 0002CF54 0000 .word L215
8 0002CF56 # #include "fpp_defs.h"
9 0002CF56 #
10 0002CF56 #
11 0002CF56 # /*****************************************************************************
12 0002CF56 # *
13 0002CF56 # * PIPELINE TEST #11 MONITOR
14 0002CF56 # *
15 0002CF56 # * This test will do a series of 2, 3, 4, 5, and 6 NEGFs.
16 0002CF56 # *
17 0002CF56 # *****************************************************************************/
18 0002CF56 # pipe_11()
19 0002CF56 # {
20 0002CF56 11 48 jbr L217
21 0002CF58 L218:
22 0002CF58 # asm(".globl _pipeline_11_t");
23 0002CF58 .globl _pipeline_11_t
24 0002CF58 # asm("_pipeline_11_t:"); /* entry address */
25 0002CF58 _pipeline_11_t:
26 0002CF58 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
27 0002CF58 1d effffffff6 01 cmpl _cycle,$1
28 0002CF5F 21 15 jneq L219
29 0002CF61 5d efffffffed tstl _prt_hdrs
30 0002CF67 31 0d jeql L219
31 0002CF69 # {
32 0002CF69 # writes(" PIPE_11");
33 0002CF69 .data 1
34 000005a8 * L221:
35 000005a8 * 20504950455F313100 .ascii " PIPE_11\0"
36 000005b1 * .text
37 0002CF69 dd 8f000005a8 pushl $L221
38 0002CF6F fe 08 efffffffde callf $8,_writes
39 0002CF76 # }
40 0002CF76 # pipe11_1(); /* do 2 NEGFs */
41 0002CF76 L219:
42 0002CF76 fe 04 ef00000025 callf $4,_pipe11_1
43 0002CF7D # pipe11_2(); /* do 3 NEGFs */
44 0002CF7D fe 04 ef000000e2 callf $4,_pipe11_2
45 0002CF84 # pipe11_3(); /* do 4 NEGFs */
46 0002CF84 fe 04 ef000001b3 callf $4,_pipe11_3
47 0002CF8B # pipe11_4(); /* do 5 NEGFs */
48 0002CF8B fe 04 ef00000272 callf $4,_pipe11_4
49 0002CF92 # pipe11_5(); /* do 6 NEGFs */
50 0002CF92 fe 04 ef00000345 callf $4,_pipe11_5
51 0002CF99 # asm("jmp *return"); /* return to the test monitor */
52 0002CF99 71 ffffffffb5 jmp *return
53 0002CF9F # }
54 0002CF9F 40 ret#2
55 0002CFA0 .set L215,0x0
56 0002CFA0 L217:
57 0002CFA0 11 b6 jbr L218
58 0002CFA2 .data
59 000005a8 * .text
60 0002CFA2 .align 1
61 0002CFA2 .globl _pipe11_1
62 0002CFA2 _pipe11_1:
63 0002CFA2 0000 .word L227
64 0002CFA4 #
65 0002CFA4 #
66 0002CFA4 #
67 0002CFA4 #
68 0002CFA4 #
69 0002CFA4 #
70 0002CFA4 # /************************************************************************
71 0002CFA4 # *
72 0002CFA4 # * SUBTEST 1 : 2 NEGFs
73 0002CFA4 # *
74 0002CFA4 # ************************************************************************/
75 0002CFA4 # pipe11_1()
76 0002CFA4 # {
77 0002CFA4 13 00bb jbr L229
78 0002CFA7 L230:
79 0002CFA7 # subtest = 1;
80 0002CFA7 0d 01 efffffffa6 movl $1,_subtest
81 0002CFAE # force_loop = FALSE;
82 0002CFAE 4d efffffffa0 clrl _force_loop
83 0002CFB4 # for( index = 0; index < max_ldf_1_index; index++ )
84 0002CFB4 4d efffffff9a clrl _index
85 0002CFBA L233:
86 0002CFBA 1d efffffff94 efffffff8f cmpl _index,_max_ldf_1_index
87 0002CFC5 91 03 13 0097 jgeq L232
88 0002CFCA # {
89 0002CFCA # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
90 0002CFCA 0d efffffff84 50 movl _index,r0
91 0002CFD1 48 03 50 50 shll $3,r0,r0
92 0002CFD5 0d e000000000 efffffff74 movl _ldf_1_data(r0),_sgl_value_1
93 0002CFE0 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
94 0002CFE0 0d efffffff6e 50 movl _index,r0
95 0002CFE7 48 03 50 50 shll $3,r0,r0
96 0002CFEB 0d e000000004 efffffff5e movl _ldf_1_data+4(r0),_sgl_expected
97 0002CFF6 # /*
98 0002CFF6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
99 0002CFF6 # * The force loop flag is set after the first error.
100 0002CFF6 # */
101 0002CFF6 # asm("_pipe11_1_lp1:");
102 0002CFF6 _pipe11_1_lp1:
103 0002CFF6 # asm("ldf _sgl_value_1"); /* load the operand */
104 0002CFF6 06 efffffff58 ldf _sgl_value_1
105 0002CFFC # asm("negf"); /* negate it ( twice ) */
106 0002CFFC b6 negf
107 0002CFFD # asm("negf");
108 0002CFFD b6 negf
109 0002CFFE # asm("stf _sgl_st_acc"); /* store the result */
110 0002CFFE 26 efffffff50 stf _sgl_st_acc
111 0002D004 # if( force_loop )
112 0002D004 5d efffffff4a tstl _force_loop
113 0002D00A 31 02 jeql L234
114 0002D00C # asm("brb _pipe11_1_lp1"); /* loop on an error */
115 0002D00C 11 e8 brb _pipe11_1_lp1
116 0002D00E # /*
117 0002D00E # * verify the results
118 0002D00E # */
119 0002D00E # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
120 0002D00E L234:
121 0002D00E 1d efffffff40 efffffff3b cmpl _sgl_st_acc,_sgl_expected
122 0002D019 31 3d jeql L235
123 0002D01B # errcnt++; /* bump the error count */
124 0002D01B 6d efffffff33 incl _errcnt
125 0002D021 # if( prt_error )
126 0002D021 5d efffffff2d tstl _prt_error
127 0002D027 31 09 jeql L236
128 0002D029 # pipe11_print( 2 ); /* print error msg -2 NEGFS*/
129 0002D029 dd 02 pushl $2
130 0002D02B fe 08 ef00000374 callf $8,_pipe11_print
131 0002D032 # if( halt_flg ) /* halt on error? */
132 0002D032 L236:
133 0002D032 5d efffffff1c tstl _halt_flg
134 0002D038 31 09 jeql L238
135 0002D03A # pipe11_halt( 2 ); /* error halt -2 NEGFS */
136 0002D03A dd 02 pushl $2
137 0002D03C fe 08 ef0000046b callf $8,_pipe11_halt
138 0002D043 # if( loop_on_err ) {
139 0002D043 L238:
140 0002D043 5d efffffff0b tstl _loop_on_err
141 0002D049 31 0d jeql L240
142 0002D04B # force_loop = TRUE; /* set the force loop flag */
143 0002D04B 0d 01 efffffff02 movl $1,_force_loop
144 0002D052 # asm("jmp _pipe11_1_lp1"); /* and loop */
145 0002D052 71 efffffff9e jmp _pipe11_1_lp1
146 0002D058 # }
147 0002D058 # }
148 0002D058 L240:
149 0002D058 # } /* end of FOR loop */
150 0002D058 L235:
151 0002D058 L231:
152 0002D058 6d effffffef6 incl _index
153 0002D05E 13 ff59 jbr L233
154 0002D061 L232:
155 0002D061 # } /* end of subtest 1 */
156 0002D061 40 ret#2
157 0002D062 .set L227,0x0
158 0002D062 L229:
159 0002D062 13 ff42 jbr L230
160 0002D065 .data
161 000005a8 * .text
162 0002D065 00 .align 1
163 0002D066 .globl _pipe11_2
164 0002D066 _pipe11_2:
165 0002D066 0000 .word L241
166 0002D068 #
167 0002D068 #
168 0002D068 #
169 0002D068 #
170 0002D068 #
171 0002D068 # /************************************************************************
172 0002D068 # *
173 0002D068 # * SUBTEST 2 : 3 NEGFs
174 0002D068 # *
175 0002D068 # ************************************************************************/
176 0002D068 # pipe11_2()
177 0002D068 # {
178 0002D068 13 00cf jbr L243
179 0002D06B L244:
180 0002D06B # subtest = 2;
181 0002D06B 0d 02 effffffee2 movl $2,_subtest
182 0002D072 # force_loop = FALSE;
183 0002D072 4d effffffedc clrl _force_loop
184 0002D078 # for( index = 0; index < max_ldf_1_index; index++ )
185 0002D078 4d effffffed6 clrl _index
186 0002D07E L247:
187 0002D07E 1d effffffed0 effffffecb cmpl _index,_max_ldf_1_index
188 0002D089 91 03 13 00ab jgeq L246
189 0002D08E # {
190 0002D08E # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
191 0002D08E 0d effffffec0 50 movl _index,r0
192 0002D095 48 03 50 50 shll $3,r0,r0
193 0002D099 0d e000000000 effffffeb0 movl _ldf_1_data(r0),_sgl_value_1
194 0002D0A4 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
195 0002D0A4 0d effffffeaa 50 movl _index,r0
196 0002D0AB 48 03 50 50 shll $3,r0,r0
197 0002D0AF 0d e000000004 effffffe9a movl _ldf_1_data+4(r0),_sgl_expected
198 0002D0BA # if( sgl_expected )
199 0002D0BA 5d effffffe94 tstl _sgl_expected
200 0002D0C0 31 0b jeql L248
201 0002D0C2 # sgl_expected ^= 0x80000000; /* negate exptd results */
202 0002D0C2 cc 8f80000000 effffffe87 xorl2 $-2147483648,_sgl_expected
203 0002D0CD # /*
204 0002D0CD # * If LOOP ON ERROR is set, this is the loop for this subtest.
205 0002D0CD # * The force loop flag is set after the first error.
206 0002D0CD # */
207 0002D0CD # asm("_pipe11_2_lp1:");
208 0002D0CD L248:
209 0002D0CD _pipe11_2_lp1:
210 0002D0CD # asm("ldf _sgl_value_1"); /* load the operand */
211 0002D0CD 06 effffffe81 ldf _sgl_value_1
212 0002D0D3 # asm("negf"); /* negate it ( 3 times ) */
213 0002D0D3 b6 negf
214 0002D0D4 # asm("negf");
215 0002D0D4 b6 negf
216 0002D0D5 # asm("negf");
217 0002D0D5 b6 negf
218 0002D0D6 # asm("stf _sgl_st_acc"); /* store the result */
219 0002D0D6 26 effffffe78 stf _sgl_st_acc
220 0002D0DC # if( force_loop )
221 0002D0DC 5d effffffe72 tstl _force_loop
222 0002D0E2 31 02 jeql L249
223 0002D0E4 # asm("brb _pipe11_2_lp1"); /* loop on an error */
224 0002D0E4 11 e7 brb _pipe11_2_lp1
225 0002D0E6 # /*
226 0002D0E6 # * verify the results
227 0002D0E6 # */
228 0002D0E6 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
229 0002D0E6 L249:
230 0002D0E6 1d effffffe68 effffffe63 cmpl _sgl_st_acc,_sgl_expected
231 0002D0F1 31 3d jeql L250
232 0002D0F3 # errcnt++; /* bump the error count */
233 0002D0F3 6d effffffe5b incl _errcnt
234 0002D0F9 # if( prt_error )
235 0002D0F9 5d effffffe55 tstl _prt_error
236 0002D0FF 31 09 jeql L251
237 0002D101 # pipe11_print( 3 ); /* print error msg -3 NEGFS*/
238 0002D101 dd 03 pushl $3
239 0002D103 fe 08 ef0000029c callf $8,_pipe11_print
240 0002D10A # if( halt_flg ) /* halt on error? */
241 0002D10A L251:
242 0002D10A 5d effffffe44 tstl _halt_flg
243 0002D110 31 09 jeql L252
244 0002D112 # pipe11_halt( 3 ); /* error halt -3 NEGFS */
245 0002D112 dd 03 pushl $3
246 0002D114 fe 08 ef00000393 callf $8,_pipe11_halt
247 0002D11B # if( loop_on_err ) {
248 0002D11B L252:
249 0002D11B 5d effffffe33 tstl _loop_on_err
250 0002D121 31 0d jeql L253
251 0002D123 # force_loop = TRUE; /* set the force loop flag */
252 0002D123 0d 01 effffffe2a movl $1,_force_loop
253 0002D12A # asm("jmp _pipe11_2_lp1"); /* and loop */
254 0002D12A 71 efffffff9d jmp _pipe11_2_lp1
255 0002D130 # }
256 0002D130 # }
257 0002D130 L253:
258 0002D130 # } /* end of FOR loop */
259 0002D130 L250:
260 0002D130 L245:
261 0002D130 6d effffffe1e incl _index
262 0002D136 13 ff45 jbr L247
263 0002D139 L246:
264 0002D139 # } /* end of subtest 2 */
265 0002D139 40 ret#2
266 0002D13A .set L241,0x0
267 0002D13A L243:
268 0002D13A 13 ff2e jbr L244
269 0002D13D .data
270 000005a8 * .text
271 0002D13D 00 .align 1
272 0002D13E .globl _pipe11_3
273 0002D13E _pipe11_3:
274 0002D13E 0000 .word L254
275 0002D140 #
276 0002D140 #
277 0002D140 #
278 0002D140 #
279 0002D140 #
280 0002D140 # /************************************************************************
281 0002D140 # *
282 0002D140 # * SUBTEST 3 : 4 NEGFs
283 0002D140 # *
284 0002D140 # ************************************************************************/
285 0002D140 # pipe11_3()
286 0002D140 # {
287 0002D140 13 00bd jbr L256
288 0002D143 L257:
289 0002D143 # subtest = 3;
290 0002D143 0d 03 effffffe0a movl $3,_subtest
291 0002D14A # force_loop = FALSE;
292 0002D14A 4d effffffe04 clrl _force_loop
293 0002D150 # for( index = 0; index < max_ldf_1_index; index++ )
294 0002D150 4d effffffdfe clrl _index
295 0002D156 L260:
296 0002D156 1d effffffdf8 effffffdf3 cmpl _index,_max_ldf_1_index
297 0002D161 91 03 13 0099 jgeq L259
298 0002D166 # {
299 0002D166 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
300 0002D166 0d effffffde8 50 movl _index,r0
301 0002D16D 48 03 50 50 shll $3,r0,r0
302 0002D171 0d e000000000 effffffdd8 movl _ldf_1_data(r0),_sgl_value_1
303 0002D17C # sgl_expected = ldf_1_data[index].exp; /* get expected results */
304 0002D17C 0d effffffdd2 50 movl _index,r0
305 0002D183 48 03 50 50 shll $3,r0,r0
306 0002D187 0d e000000004 effffffdc2 movl _ldf_1_data+4(r0),_sgl_expected
307 0002D192 # /*
308 0002D192 # * If LOOP ON ERROR is set, this is the loop for this subtest.
309 0002D192 # * The force loop flag is set after the first error.
310 0002D192 # */
311 0002D192 # asm("_pipe11_3_lp1:");
312 0002D192 _pipe11_3_lp1:
313 0002D192 # asm("ldf _sgl_value_1"); /* load the operand */
314 0002D192 06 effffffdbc ldf _sgl_value_1
315 0002D198 # asm("negf"); /* negate it ( 4 times ) */
316 0002D198 b6 negf
317 0002D199 # asm("negf");
318 0002D199 b6 negf
319 0002D19A # asm("negf");
320 0002D19A b6 negf
321 0002D19B # asm("negf");
322 0002D19B b6 negf
323 0002D19C # asm("stf _sgl_st_acc"); /* store the result */
324 0002D19C 26 effffffdb2 stf _sgl_st_acc
325 0002D1A2 # if( force_loop )
326 0002D1A2 5d effffffdac tstl _force_loop
327 0002D1A8 31 02 jeql L261
328 0002D1AA # asm("brb _pipe11_3_lp1"); /* loop on an error */
329 0002D1AA 11 e6 brb _pipe11_3_lp1
330 0002D1AC # /*
331 0002D1AC # * verify the results
332 0002D1AC # */
333 0002D1AC # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
334 0002D1AC L261:
335 0002D1AC 1d effffffda2 effffffd9d cmpl _sgl_st_acc,_sgl_expected
336 0002D1B7 31 3d jeql L262
337 0002D1B9 # errcnt++; /* bump the error count */
338 0002D1B9 6d effffffd95 incl _errcnt
339 0002D1BF # if( prt_error )
340 0002D1BF 5d effffffd8f tstl _prt_error
341 0002D1C5 31 09 jeql L263
342 0002D1C7 # pipe11_print( 4 ); /* print error msg -4 NEGFS*/
343 0002D1C7 dd 04 pushl $4
344 0002D1C9 fe 08 ef000001d6 callf $8,_pipe11_print
345 0002D1D0 # if( halt_flg ) /* halt on error? */
346 0002D1D0 L263:
347 0002D1D0 5d effffffd7e tstl _halt_flg
348 0002D1D6 31 09 jeql L264
349 0002D1D8 # pipe11_halt( 4 ); /* error halt -4 NEGFS */
350 0002D1D8 dd 04 pushl $4
351 0002D1DA fe 08 ef000002cd callf $8,_pipe11_halt
352 0002D1E1 # if( loop_on_err ) {
353 0002D1E1 L264:
354 0002D1E1 5d effffffd6d tstl _loop_on_err
355 0002D1E7 31 0d jeql L265
356 0002D1E9 # force_loop = TRUE; /* set the force loop flag */
357 0002D1E9 0d 01 effffffd64 movl $1,_force_loop
358 0002D1F0 # asm("jmp _pipe11_3_lp1"); /* and loop */
359 0002D1F0 71 efffffff9c jmp _pipe11_3_lp1
360 0002D1F6 # }
361 0002D1F6 # }
362 0002D1F6 L265:
363 0002D1F6 # } /* end of FOR loop */
364 0002D1F6 L262:
365 0002D1F6 L258:
366 0002D1F6 6d effffffd58 incl _index
367 0002D1FC 13 ff57 jbr L260
368 0002D1FF L259:
369 0002D1FF # } /* end of subtest 3 */
370 0002D1FF 40 ret#2
371 0002D200 .set L254,0x0
372 0002D200 L256:
373 0002D200 13 ff40 jbr L257
374 0002D203 .data
375 000005a8 * .text
376 0002D203 00 .align 1
377 0002D204 .globl _pipe11_4
378 0002D204 _pipe11_4:
379 0002D204 0000 .word L266
380 0002D206 #
381 0002D206 #
382 0002D206 #
383 0002D206 #
384 0002D206 #
385 0002D206 #
386 0002D206 # /************************************************************************
387 0002D206 # *
388 0002D206 # * SUBTEST 4 : 5 NEGFs
389 0002D206 # *
390 0002D206 # ************************************************************************/
391 0002D206 # pipe11_4()
392 0002D206 # {
393 0002D206 13 00d1 jbr L268
394 0002D209 L269:
395 0002D209 # subtest = 4;
396 0002D209 0d 04 effffffd44 movl $4,_subtest
397 0002D210 # force_loop = FALSE;
398 0002D210 4d effffffd3e clrl _force_loop
399 0002D216 # for( index = 0; index < max_ldf_1_index; index++ )
400 0002D216 4d effffffd38 clrl _index
401 0002D21C L272:
402 0002D21C 1d effffffd32 effffffd2d cmpl _index,_max_ldf_1_index
403 0002D227 91 03 13 00ad jgeq L271
404 0002D22C # {
405 0002D22C # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
406 0002D22C 0d effffffd22 50 movl _index,r0
407 0002D233 48 03 50 50 shll $3,r0,r0
408 0002D237 0d e000000000 effffffd12 movl _ldf_1_data(r0),_sgl_value_1
409 0002D242 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
410 0002D242 0d effffffd0c 50 movl _index,r0
411 0002D249 48 03 50 50 shll $3,r0,r0
412 0002D24D 0d e000000004 effffffcfc movl _ldf_1_data+4(r0),_sgl_expected
413 0002D258 # if( sgl_expected )
414 0002D258 5d effffffcf6 tstl _sgl_expected
415 0002D25E 31 0b jeql L273
416 0002D260 # sgl_expected ^= 0x80000000; /* negate exptd results */
417 0002D260 cc 8f80000000 effffffce9 xorl2 $-2147483648,_sgl_expected
418 0002D26B # /*
419 0002D26B # * If LOOP ON ERROR is set, this is the loop for this subtest.
420 0002D26B # * The force loop flag is set after the first error.
421 0002D26B # */
422 0002D26B # asm("_pipe11_4_lp1:");
423 0002D26B L273:
424 0002D26B _pipe11_4_lp1:
425 0002D26B # asm("ldf _sgl_value_1"); /* load the operand */
426 0002D26B 06 effffffce3 ldf _sgl_value_1
427 0002D271 # asm("negf"); /* negate it ( 5 times ) */
428 0002D271 b6 negf
429 0002D272 # asm("negf");
430 0002D272 b6 negf
431 0002D273 # asm("negf");
432 0002D273 b6 negf
433 0002D274 # asm("negf");
434 0002D274 b6 negf
435 0002D275 # asm("negf");
436 0002D275 b6 negf
437 0002D276 # asm("stf _sgl_st_acc"); /* store the result */
438 0002D276 26 effffffcd8 stf _sgl_st_acc
439 0002D27C # if( force_loop )
440 0002D27C 5d effffffcd2 tstl _force_loop
441 0002D282 31 02 jeql L274
442 0002D284 # asm("brb _pipe11_4_lp1"); /* loop on an error */
443 0002D284 11 e5 brb _pipe11_4_lp1
444 0002D286 # /*
445 0002D286 # * verify the results
446 0002D286 # */
447 0002D286 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
448 0002D286 L274:
449 0002D286 1d effffffcc8 effffffcc3 cmpl _sgl_st_acc,_sgl_expected
450 0002D291 31 3d jeql L275
451 0002D293 # errcnt++; /* bump the error count */
452 0002D293 6d effffffcbb incl _errcnt
453 0002D299 # if( prt_error )
454 0002D299 5d effffffcb5 tstl _prt_error
455 0002D29F 31 09 jeql L276
456 0002D2A1 # pipe11_print( 5 ); /* print error msg -5 NEGFS*/
457 0002D2A1 dd 05 pushl $5
458 0002D2A3 fe 08 ef000000fc callf $8,_pipe11_print
459 0002D2AA # if( halt_flg ) /* halt on error? */
460 0002D2AA L276:
461 0002D2AA 5d effffffca4 tstl _halt_flg
462 0002D2B0 31 09 jeql L277
463 0002D2B2 # pipe11_halt( 5 ); /* error halt -5 NEGFS */
464 0002D2B2 dd 05 pushl $5
465 0002D2B4 fe 08 ef000001f3 callf $8,_pipe11_halt
466 0002D2BB # if( loop_on_err ) {
467 0002D2BB L277:
468 0002D2BB 5d effffffc93 tstl _loop_on_err
469 0002D2C1 31 0d jeql L278
470 0002D2C3 # force_loop = TRUE; /* set the force loop flag */
471 0002D2C3 0d 01 effffffc8a movl $1,_force_loop
472 0002D2CA # asm("jmp _pipe11_4_lp1"); /* and loop */
473 0002D2CA 71 efffffff9b jmp _pipe11_4_lp1
474 0002D2D0 # }
475 0002D2D0 # }
476 0002D2D0 L278:
477 0002D2D0 # } /* end of FOR loop */
478 0002D2D0 L275:
479 0002D2D0 L270:
480 0002D2D0 6d effffffc7e incl _index
481 0002D2D6 13 ff43 jbr L272
482 0002D2D9 L271:
483 0002D2D9 # } /* end of subtest 4 */
484 0002D2D9 40 ret#2
485 0002D2DA .set L266,0x0
486 0002D2DA L268:
487 0002D2DA 13 ff2c jbr L269
488 0002D2DD .data
489 000005a8 * .text
490 0002D2DD 00 .align 1
491 0002D2DE .globl _pipe11_5
492 0002D2DE _pipe11_5:
493 0002D2DE 0000 .word L279
494 0002D2E0 #
495 0002D2E0 #
496 0002D2E0 #
497 0002D2E0 #
498 0002D2E0 #
499 0002D2E0 # /************************************************************************
500 0002D2E0 # *
501 0002D2E0 # * SUBTEST 5 : 6 NEGFs
502 0002D2E0 # *
503 0002D2E0 # ************************************************************************/
504 0002D2E0 # pipe11_5()
505 0002D2E0 # {
506 0002D2E0 13 00bf jbr L281
507 0002D2E3 L282:
508 0002D2E3 # subtest = 5;
509 0002D2E3 0d 05 effffffc6a movl $5,_subtest
510 0002D2EA # force_loop = FALSE;
511 0002D2EA 4d effffffc64 clrl _force_loop
512 0002D2F0 # for( index = 0; index < max_ldf_1_index; index++ )
513 0002D2F0 4d effffffc5e clrl _index
514 0002D2F6 L285:
515 0002D2F6 1d effffffc58 effffffc53 cmpl _index,_max_ldf_1_index
516 0002D301 91 03 13 009b jgeq L284
517 0002D306 # {
518 0002D306 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
519 0002D306 0d effffffc48 50 movl _index,r0
520 0002D30D 48 03 50 50 shll $3,r0,r0
521 0002D311 0d e000000000 effffffc38 movl _ldf_1_data(r0),_sgl_value_1
522 0002D31C # sgl_expected = ldf_1_data[index].exp; /* get expected results */
523 0002D31C 0d effffffc32 50 movl _index,r0
524 0002D323 48 03 50 50 shll $3,r0,r0
525 0002D327 0d e000000004 effffffc22 movl _ldf_1_data+4(r0),_sgl_expected
526 0002D332 # /*
527 0002D332 # * If LOOP ON ERROR is set, this is the loop for this subtest.
528 0002D332 # * The force loop flag is set after the first error.
529 0002D332 # */
530 0002D332 # asm("_pipe11_5_lp1:");
531 0002D332 _pipe11_5_lp1:
532 0002D332 # asm("ldf _sgl_value_1"); /* load the operand */
533 0002D332 06 effffffc1c ldf _sgl_value_1
534 0002D338 # asm("negf"); /* negate it ( 6 times ) */
535 0002D338 b6 negf
536 0002D339 # asm("negf");
537 0002D339 b6 negf
538 0002D33A # asm("negf");
539 0002D33A b6 negf
540 0002D33B # asm("negf");
541 0002D33B b6 negf
542 0002D33C # asm("negf");
543 0002D33C b6 negf
544 0002D33D # asm("negf");
545 0002D33D b6 negf
546 0002D33E # asm("stf _sgl_st_acc"); /* store the result */
547 0002D33E 26 effffffc10 stf _sgl_st_acc
548 0002D344 # if( force_loop )
549 0002D344 5d effffffc0a tstl _force_loop
550 0002D34A 31 02 jeql L286
551 0002D34C # asm("brb _pipe11_5_lp1"); /* loop on an error */
552 0002D34C 11 e4 brb _pipe11_5_lp1
553 0002D34E # /*
554 0002D34E # * verify the results
555 0002D34E # */
556 0002D34E # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
557 0002D34E L286:
558 0002D34E 1d effffffc00 effffffbfb cmpl _sgl_st_acc,_sgl_expected
559 0002D359 31 3d jeql L287
560 0002D35B # errcnt++; /* bump the error count */
561 0002D35B 6d effffffbf3 incl _errcnt
562 0002D361 # if( prt_error )
563 0002D361 5d effffffbed tstl _prt_error
564 0002D367 31 09 jeql L288
565 0002D369 # pipe11_print( 6 ); /* print error msg -6 NEGFS*/
566 0002D369 dd 06 pushl $6
567 0002D36B fe 08 ef00000034 callf $8,_pipe11_print
568 0002D372 # if( halt_flg ) /* halt on error? */
569 0002D372 L288:
570 0002D372 5d effffffbdc tstl _halt_flg
571 0002D378 31 09 jeql L289
572 0002D37A # pipe11_halt( 6 ); /* error halt -6 NEGFS */
573 0002D37A dd 06 pushl $6
574 0002D37C fe 08 ef0000012b callf $8,_pipe11_halt
575 0002D383 # if( loop_on_err ) {
576 0002D383 L289:
577 0002D383 5d effffffbcb tstl _loop_on_err
578 0002D389 31 0d jeql L290
579 0002D38B # force_loop = TRUE; /* set the force loop flag */
580 0002D38B 0d 01 effffffbc2 movl $1,_force_loop
581 0002D392 # asm("jmp _pipe11_5_lp1"); /* and loop */
582 0002D392 71 efffffff9a jmp _pipe11_5_lp1
583 0002D398 # }
584 0002D398 # }
585 0002D398 L290:
586 0002D398 # } /* end of FOR loop */
587 0002D398 L287:
588 0002D398 L283:
589 0002D398 6d effffffbb6 incl _index
590 0002D39E 13 ff55 jbr L285
591 0002D3A1 L284:
592 0002D3A1 # } /* end of subtest 5 */
593 0002D3A1 40 ret#2
594 0002D3A2 .set L279,0x0
595 0002D3A2 L281:
596 0002D3A2 13 ff3e jbr L282
597 0002D3A5 .data
598 000005a8 * .text
599 0002D3A5 00 .align 1
600 0002D3A6 .globl _pipe11_print
601 0002D3A6 _pipe11_print:
602 0002D3A6 0000 .word L291
603 0002D3A8 #
604 0002D3A8 #
605 0002D3A8 #
606 0002D3A8 #
607 0002D3A8 # /****************************************************************************
608 0002D3A8 # *
609 0002D3A8 # * PRINT AN ERROR MESSAGE
610 0002D3A8 # *
611 0002D3A8 # * cycle dd PIPELINE 11, subtest dd error
612 0002D3A8 # * LDF op, {NEGF}, STF
613 0002D3A8 # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = xxxxxxxx
614 0002D3A8 # * expected Acc = xxxxxxxx
615 0002D3A8 # ****************************************************************************/
616 0002D3A8 # pipe11_print( nop_count )
617 0002D3A8 # int nop_count; /* # of NEGF instructions */
618 0002D3A8 # {
619 0002D3A8 13 0100 jbr L293
620 0002D3AB L294:
621 0002D3AB # writes(" \n"); /* start a new print line */
622 0002D3AB .data 1
623 000005b1 * L295:
624 000005b1 * 200A00 .ascii " \12\0"
625 000005b4 * .text
626 0002D3AB dd 8f000005b1 pushl $L295
627 0002D3B1 fe 08 effffffb9c callf $8,_writes
628 0002D3B8 # writes("cycle: ");
629 0002D3B8 .data 1
630 000005b4 * L296:
631 000005b4 * 6379636C653A2000 .ascii "cycle: \0"
632 000005bc * .text
633 0002D3B8 dd 8f000005b4 pushl $L296
634 0002D3BE fe 08 effffffb8f callf $8,_writes
635 0002D3C5 # writed( cycle );
636 0002D3C5 dd effffffb89 pushl _cycle
637 0002D3CB fe 08 effffffb82 callf $8,_writed
638 0002D3D2 # writes(" (Pipe 11), subtest ");
639 0002D3D2 .data 1
640 000005bc * L298:
641 000005bc * 20202850697065203131292C2 .ascii " (Pipe 11), subtest \0"
0737562746573742000
642 000005d2 * .text
643 0002D3D2 dd 8f000005bc pushl $L298
644 0002D3D8 fe 08 effffffb75 callf $8,_writes
645 0002D3DF # writed( subtest );
646 0002D3DF dd effffffb6f pushl _subtest
647 0002D3E5 fe 08 effffffb68 callf $8,_writed
648 0002D3EC # writes(" error\n");
649 0002D3EC .data 1
650 000005d2 * L299:
651 000005d2 * 206572726F720A00 .ascii " error\12\0"
652 000005da * .text
653 0002D3EC dd 8f000005d2 pushl $L299
654 0002D3F2 fe 08 effffffb5b callf $8,_writes
655 0002D3F9 # writes(" LDF(op), NEGF");
656 0002D3F9 .data 1
657 000005da * L300:
658 000005da * 204C4446286F70292C204E454 .ascii " LDF(op), NEGF\0"
74600
659 000005e9 * .text
660 0002D3F9 dd 8f000005da pushl $L300
661 0002D3FF fe 08 effffffb4e callf $8,_writes
662 0002D406 # while( --nop_count )
663 0002D406 L301:
664 0002D406 7d ad04 decl 4(fp)
665 0002D409 31 0f jeql L302
666 0002D40B # writes(", NEGF");
667 0002D40B .data 1
668 000005e9 * L303:
669 000005e9 * 2C204E45474600 .ascii ", NEGF\0"
670 000005f0 * .text
671 0002D40B dd 8f000005e9 pushl $L303
672 0002D411 fe 08 effffffb3c callf $8,_writes
673 0002D418 11 ec jbr L301
674 0002D41A L302:
675 0002D41A # writes(", STF\n");
676 0002D41A .data 1
677 000005f0 * L304:
678 000005f0 * 2C205354460A00 .ascii ", STF\12\0"
679 000005f7 * .text
680 0002D41A dd 8f000005f0 pushl $L304
681 0002D420 fe 08 effffffb2d callf $8,_writes
682 0002D427 # writec('\n');
683 0002D427 dd 0a pushl $10
684 0002D429 fe 08 effffffb24 callf $8,_writec
685 0002D430 # writes("operand = ");
686 0002D430 .data 1
687 000005f7 * L306:
688 000005f7 * 6F706572616E64203D2000 .ascii "operand = \0"
689 00000602 * .text
690 0002D430 dd 8f000005f7 pushl $L306
691 0002D436 fe 08 effffffb17 callf $8,_writes
692 0002D43D # write32h( sgl_value_1 );
693 0002D43D dd effffffb11 pushl _sgl_value_1
694 0002D443 fe 08 effffffb0a callf $8,_write32h
695 0002D44A # writes(", final Acc = ");
696 0002D44A .data 1
697 00000602 * L308:
698 00000602 * 2C2020202066696E616C20416 .ascii ", final Acc = \0"
363203D2000
699 00000614 * .text
700 0002D44A dd 8f00000602 pushl $L308
701 0002D450 fe 08 effffffafd callf $8,_writes
702 0002D457 # write32h( sgl_st_acc );
703 0002D457 dd effffffaf7 pushl _sgl_st_acc
704 0002D45D fe 08 effffffaf0 callf $8,_write32h
705 0002D464 # writes(", data index = ");
706 0002D464 .data 1
707 00000614 * L309:
708 00000614 * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
709 00000626 * .text
710 0002D464 dd 8f00000614 pushl $L309
711 0002D46A fe 08 effffffae3 callf $8,_writes
712 0002D471 # writed( index );
713 0002D471 dd effffffadd pushl _index
714 0002D477 fe 08 effffffad6 callf $8,_writed
715 0002D47E # writec('\n');
716 0002D47E dd 0a pushl $10
717 0002D480 fe 08 effffffacd callf $8,_writec
718 0002D487 # writes(" expected Acc = ");
719 0002D487 .data 1
720 00000626 * L310:
721 00000626 * 2020202020202020202020202 .ascii " expected Acc = \0"
0202020202020206578706563
74656420416363203D2000
722 0000064a * .text
723 0002D487 dd 8f00000626 pushl $L310
724 0002D48D fe 08 effffffac0 callf $8,_writes
725 0002D494 # write32h( sgl_expected );
726 0002D494 dd effffffaba pushl _sgl_expected
727 0002D49A fe 08 effffffab3 callf $8,_write32h
728 0002D4A1 # writec('\n');
729 0002D4A1 dd 0a pushl $10
730 0002D4A3 fe 08 effffffaaa callf $8,_writec
731 0002D4AA # }
732 0002D4AA 40 ret#2
733 0002D4AB .set L291,0x0
734 0002D4AB L293:
735 0002D4AB 13 fefd jbr L294
736 0002D4AE .data
737 000005a8 * .text
738 0002D4AE .align 1
739 0002D4AE .globl _pipe11_halt
740 0002D4AE _pipe11_halt:
741 0002D4AE 0000 .word L311
742 0002D4B0 #
743 0002D4B0 #
744 0002D4B0 #
745 0002D4B0 # /****************************************************************************
746 0002D4B0 # *
747 0002D4B0 # * SET UP THE REGISTERS AND HALT
748 0002D4B0 # *
749 0002D4B0 # ****************************************************************************/
750 0002D4B0 # pipe11_halt( nop_count )
751 0002D4B0 # int nop_count; /* # of NEGF instructions */
752 0002D4B0 # {
753 0002D4B0 11 45 jbr L313
754 0002D4B2 L314:
755 0002D4B2 # sgl_dummy1 = nop_count;
756 0002D4B2 0d ad04 effffffa9a movl 4(fp),_sgl_dummy1
757 0002D4BA # asm("movl _test_no,r0"); /* r0 = test number */
758 0002D4BA 0d effffffa94 50 movl _test_no,r0
759 0002D4C1 # asm("movl _subtest,r1"); /* r1 = subtest number */
760 0002D4C1 0d effffffa8d 51 movl _subtest,r1
761 0002D4C8 # asm("movl $1,r2"); /* r2 = error code */
762 0002D4C8 0d 01 52 movl $1,r2
763 0002D4CB # asm("movl _cycle,r3"); /* r3 = cycle count */
764 0002D4CB 0d effffffa83 53 movl _cycle,r3
765 0002D4D2 # asm("movl _sgl_dummy1,r4"); /* r4 = # of NEGFS */
766 0002D4D2 0d effffffa7c 54 movl _sgl_dummy1,r4
767 0002D4D9 # asm("movl _sgl_value_1,r5"); /* r5 = sgl operand */
768 0002D4D9 0d effffffa75 55 movl _sgl_value_1,r5
769 0002D4E0 # asm("movl _sgl_st_acc,r6"); /* r6 = sgl stored */
770 0002D4E0 0d effffffa6e 56 movl _sgl_st_acc,r6
771 0002D4E7 # asm("movl _sgl_expected,r7"); /* r7 = sgl expected */
772 0002D4E7 0d effffffa67 57 movl _sgl_expected,r7
773 0002D4EE # asm("movl _index,r8"); /* r8 = data index */
774 0002D4EE 0d effffffa60 58 movl _index,r8
775 0002D4F5 # asm("halt"); /* HALT ... */
776 0002D4F5 00 halt
777 0002D4F6 # }
778 0002D4F6 40 ret#2
779 0002D4F7 .set L311,0x0
780 0002D4F7 L313:
781 0002D4F7 11 b9 jbr L314
782 0002D4F9 .data
782 0005A44D .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.