![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe2.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 pipe2.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 00000d0c * .text
4 00000000 .align 1
5 00000000 .globl _pipe_2
6 00000000 _pipe_2:
7 00026C3C 0000 .word L215
8 00026C3E #
9 00026C3E #
10 00026C3E # #include "fpp_defs.h"
11 00026C3E #
12 00026C3E #
13 00026C3E # /*****************************************************************************
14 00026C3E # *
15 00026C3E # * PIPELINE TEST #2 MONITOR
16 00026C3E # *
17 00026C3E # * This test will do:
18 00026C3E # *
19 00026C3E # * LNF(x), MULF(1), MULF(1), ADDF(0), MULF(1), STF
20 00026C3E # *
21 00026C3E # * where x is the fmacro1 LNF data.
22 00026C3E # *****************************************************************************/
23 00026C3E # pipe_2()
24 00026C3E # {
25 00026C3E 13 00a8 jbr L217
26 00026C41 L218:
27 00026C41 # asm(".globl _pipeline_2_t");
28 00026C41 .globl _pipeline_2_t
29 00026C41 # asm("_pipeline_2_t:"); /* entry address */
30 00026C41 _pipeline_2_t:
31 00026C41 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
32 00026C41 1d effffffff5 01 cmpl _cycle,$1
33 00026C48 21 15 jneq L219
34 00026C4A 5d efffffffec tstl _prt_hdrs
35 00026C50 31 0d jeql L219
36 00026C52 # {
37 00026C52 # writes(" PIPE_2 ");
38 00026C52 .data 1
39 00000d0c * L221:
40 00000d0c * 20504950455F322000 .ascii " PIPE_2 \0"
41 00000d15 * .text
42 00026C52 dd 8f00000d0c pushl $L221
43 00026C58 fe 08 efffffffdd callf $8,_writes
44 00026C5F # }
45 00026C5F # subtest = 1;
46 00026C5F L219:
47 00026C5F 0d 01 efffffffd6 movl $1,_subtest
48 00026C66 # pipe2_1(); /* data in REGs, no NOPs */
49 00026C66 fe 04 ef0000007f callf $4,_pipe2_1
50 00026C6D # subtest++; /* increment the subtest */
51 00026C6D 6d efffffffc9 incl _subtest
52 00026C73 # pipe2_2(); /* data in REGs, 1 NOP */
53 00026C73 fe 04 ef0000015e callf $4,_pipe2_2
54 00026C7A # subtest++; /* increment the subtest */
55 00026C7A 6d efffffffbc incl _subtest
56 00026C80 # pipe2_3(); /* data in REGs, 2 NOPs */
57 00026C80 fe 04 ef00000243 callf $4,_pipe2_3
58 00026C87 # subtest++; /* increment the subtest */
59 00026C87 6d efffffffaf incl _subtest
60 00026C8D # pipe2_4(); /* data in REGs, 3 NOPs */
61 00026C8D fe 04 ef0000032c callf $4,_pipe2_4
62 00026C94 # subtest++; /* increment the subtest */
63 00026C94 6d efffffffa2 incl _subtest
64 00026C9A # pipe2_5(); /* data in CACHE, no NOPs */
65 00026C9A fe 04 ef0000041b callf $4,_pipe2_5
66 00026CA1 # subtest++; /* increment the subtest */
67 00026CA1 6d efffffff95 incl _subtest
68 00026CA7 # pipe2_6(); /* data in CACHE, 1 NOP */
69 00026CA7 fe 04 ef000004f6 callf $4,_pipe2_6
70 00026CAE # subtest++; /* increment the subtest */
71 00026CAE 6d efffffff88 incl _subtest
72 00026CB4 # pipe2_7(); /* data in CACHE, 2 NOPs */
73 00026CB4 fe 04 ef000005d7 callf $4,_pipe2_7
74 00026CBB # subtest++; /* increment the subtest */
75 00026CBB 6d efffffff7b incl _subtest
76 00026CC1 # pipe2_8(); /* data in CACHE, 3 NOPs */
77 00026CC1 fe 04 ef000006bc callf $4,_pipe2_8
78 00026CC8 # subtest++; /* increment the subtest */
79 00026CC8 6d efffffff6e incl _subtest
80 00026CCE # pipe2_9(); /* data on STACK, no NOPs */
81 00026CCE fe 04 ef000007a7 callf $4,_pipe2_9
82 00026CD5 # subtest++; /* increment the subtest */
83 00026CD5 6d efffffff61 incl _subtest
84 00026CDB # pipe2_10(); /* data via FP no NOPs */
85 00026CDB fe 04 ef00000928 callf $4,_pipe2_10
86 00026CE2 # asm("jmp *return"); /* return to the test monitor */
87 00026CE2 71 ffffffff54 jmp *return
88 00026CE8 # }
89 00026CE8 40 ret#2
90 00026CE9 .set L215,0x0
91 00026CE9 L217:
92 00026CE9 13 ff55 jbr L218
93 00026CEC .data
94 00000d0c * .text
95 00026CEC .align 1
96 00026CEC .globl _pipe2_1
97 00026CEC _pipe2_1:
98 00026CEC 0000 .word L232
99 00026CEE #
100 00026CEE #
101 00026CEE #
102 00026CEE #
103 00026CEE #
104 00026CEE #
105 00026CEE # /************************************************************************
106 00026CEE # *
107 00026CEE # * SUBTEST 1
108 00026CEE # * data in registers, no NO-OPs
109 00026CEE # *
110 00026CEE # ************************************************************************/
111 00026CEE # pipe2_1()
112 00026CEE # {
113 00026CEE 13 00e4 jbr L234
114 00026CF1 L235:
115 00026CF1 # force_loop = FALSE; /* clear force_loop flag */
116 00026CF1 4d efffffff45 clrl _force_loop
117 00026CF7 # index = 0;
118 00026CF7 4d efffffff3f clrl _index
119 00026CFD # do
120 00026CFD L238:
121 00026CFD # {
122 00026CFD # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
123 00026CFD 0d efffffff39 50 movl _index,r0
124 00026D04 48 03 50 50 shll $3,r0,r0
125 00026D08 0d e000000000 efffffff29 movl _lnf_1_data(r0),_sgl_value_1
126 00026D13 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
127 00026D13 0d efffffff23 50 movl _index,r0
128 00026D1A 48 03 50 50 shll $3,r0,r0
129 00026D1E 0d e000000004 efffffff13 movl _lnf_1_data+4(r0),_sgl_expected
130 00026D29 # sgl_value_2 = 0x40800000; /* floating '1' */
131 00026D29 0d 8f40800000 efffffff08 movl $1082130432,_sgl_value_2
132 00026D34 # sgl_value_3 = 0; /* floating '0' */
133 00026D34 4d efffffff02 clrl _sgl_value_3
134 00026D3A # /*
135 00026D3A # * If LOOP ON ERROR is set, this is the loop for this subtest.
136 00026D3A # * The force loop flag is set after the first error.
137 00026D3A # */
138 00026D3A # asm("_pipe2_1_lp1:");
139 00026D3A _pipe2_1_lp1:
140 00026D3A # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
141 00026D3A 0d effffffefc 54 movl _sgl_value_1,r4
142 00026D41 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
143 00026D41 0d effffffef5 55 movl _sgl_value_2,r5
144 00026D48 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
145 00026D48 0d effffffeee 56 movl _sgl_value_3,r6
146 00026D4F # asm("lnf r4"); /* load (negate) the data */
147 00026D4F 16 54 lnf r4
148 00026D51 # asm("mulf r5"); /* multipy by '1' (twice) */
149 00026D51 e6 55 mulf r5
150 00026D53 # asm("mulf r5");
151 00026D53 e6 55 mulf r5
152 00026D55 # asm("addf r6"); /* add a '0' */
153 00026D55 c6 56 addf r6
154 00026D57 # asm("mulf r5"); /* multipy by '1' again */
155 00026D57 e6 55 mulf r5
156 00026D59 # asm("stf r7"); /* store the result */
157 00026D59 26 57 stf r7
158 00026D5B # if( force_loop );
159 00026D5B 5d effffffedb tstl _force_loop
160 00026D61 31 00 jeql L239
161 00026D63 # asm("brb _pipe2_1_lp1");; /* loop on the error */
162 00026D63 L239:
163 00026D63 11 d5 brb _pipe2_1_lp1
164 00026D65 # /*
165 00026D65 # * verify the results
166 00026D65 # */
167 00026D65 # asm("movl r7,_sgl_st_acc"); /* get the result */
168 00026D65 0d 57 effffffed0 movl r7,_sgl_st_acc
169 00026D6C # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
170 00026D6C 1d effffffeca effffffec5 cmpl _sgl_st_acc,_sgl_expected
171 00026D77 31 42 jeql L240
172 00026D79 # {
173 00026D79 # errcnt++; /* bump the error count */
174 00026D79 6d effffffebd incl _errcnt
175 00026D7F # if ( prt_error )
176 00026D7F 5d effffffeb7 tstl _prt_error
177 00026D85 31 0d jeql L241
178 00026D87 # print_pipe2_er("Reg. Data, no NO-OPS");
179 00026D87 .data 1
180 00000d15 * L243:
181 00000d15 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPS\0"
F204E4F2D4F505300
182 00000d2a * .text
183 00026D87 dd 8f00000d15 pushl $L243
184 00026D8D fe 08 ef00000a34 callf $8,_print_pipe2_er
185 00026D94 # if ( halt_flg ) /* halt on error? */
186 00026D94 L241:
187 00026D94 5d effffffea2 tstl _halt_flg
188 00026D9A 31 0d jeql L244
189 00026D9C # pipe2_er_hlt( subtest );
190 00026D9C dd effffffe9a pushl _subtest
191 00026DA2 fe 08 ef00000b2b callf $8,_pipe2_er_hlt
192 00026DA9 # if ( loop_on_err ) {
193 00026DA9 L244:
194 00026DA9 5d effffffe8d tstl _loop_on_err
195 00026DAF 31 0a jeql L246
196 00026DB1 # force_loop = TRUE; /* set the force loop flag */
197 00026DB1 0d 01 effffffe84 movl $1,_force_loop
198 00026DB8 # asm("brw _pipe2_1_lp1"); /* and loop */
199 00026DB8 13 ff7f brw _pipe2_1_lp1
200 00026DBB # }
201 00026DBB # } /* end of compare error */
202 00026DBB L246:
203 00026DBB # } while( index++ < max_lnf_1_index );
204 00026DBB L240:
205 00026DBB L237:
206 00026DBB 0d effffffe7b 50 movl _index,r0
207 00026DC2 6d effffffe74 incl _index
208 00026DC8 1d 50 effffffe6d cmpl r0,_max_lnf_1_index
209 00026DCF 81 03 13 ff29 jlss L238
210 00026DD4 L236:
211 00026DD4 # } /* end of subtest 1 */
212 00026DD4 40 ret#2
213 00026DD5 .set L232,0x0
214 00026DD5 L234:
215 00026DD5 13 ff19 jbr L235
216 00026DD8 .data
217 00000d0c * .text
218 00026DD8 .align 1
219 00026DD8 .globl _pipe2_2
220 00026DD8 _pipe2_2:
221 00026DD8 0000 .word L247
222 00026DDA #
223 00026DDA #
224 00026DDA #
225 00026DDA #
226 00026DDA #
227 00026DDA #
228 00026DDA # /************************************************************************
229 00026DDA # *
230 00026DDA # * SUBTEST 2
231 00026DDA # * data in registers, 1 NO-OP
232 00026DDA # *
233 00026DDA # ************************************************************************/
234 00026DDA # pipe2_2()
235 00026DDA # {
236 00026DDA 13 00e9 jbr L249
237 00026DDD L250:
238 00026DDD # force_loop = FALSE; /* clear force_loop flag */
239 00026DDD 4d effffffe59 clrl _force_loop
240 00026DE3 # index = 0;
241 00026DE3 4d effffffe53 clrl _index
242 00026DE9 # do
243 00026DE9 L253:
244 00026DE9 # {
245 00026DE9 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
246 00026DE9 0d effffffe4d 50 movl _index,r0
247 00026DF0 48 03 50 50 shll $3,r0,r0
248 00026DF4 0d e000000000 effffffe3d movl _lnf_1_data(r0),_sgl_value_1
249 00026DFF # sgl_expected = lnf_1_data[index].exp; /* get expected results */
250 00026DFF 0d effffffe37 50 movl _index,r0
251 00026E06 48 03 50 50 shll $3,r0,r0
252 00026E0A 0d e000000004 effffffe27 movl _lnf_1_data+4(r0),_sgl_expected
253 00026E15 # sgl_value_2 = 0x40800000; /* floating '1' */
254 00026E15 0d 8f40800000 effffffe1c movl $1082130432,_sgl_value_2
255 00026E20 # sgl_value_3 = 0; /* floating '0' */
256 00026E20 4d effffffe16 clrl _sgl_value_3
257 00026E26 # /*
258 00026E26 # * If LOOP ON ERROR is set, this is the loop for this subtest.
259 00026E26 # * The force loop flag is set after the first error.
260 00026E26 # */
261 00026E26 # asm("_pipe2_2_lp1:");
262 00026E26 _pipe2_2_lp1:
263 00026E26 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
264 00026E26 0d effffffe10 54 movl _sgl_value_1,r4
265 00026E2D # asm("movl _sgl_value_2,r5"); /* move data to r5 */
266 00026E2D 0d effffffe09 55 movl _sgl_value_2,r5
267 00026E34 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
268 00026E34 0d effffffe02 56 movl _sgl_value_3,r6
269 00026E3B # asm("lnf r4"); /* load (negate) the data */
270 00026E3B 16 54 lnf r4
271 00026E3D # asm("nop");
272 00026E3D 10 nop
273 00026E3E # asm("mulf r5"); /* multipy by '1' (twice) */
274 00026E3E e6 55 mulf r5
275 00026E40 # asm("nop");
276 00026E40 10 nop
277 00026E41 # asm("mulf r5");
278 00026E41 e6 55 mulf r5
279 00026E43 # asm("nop");
280 00026E43 10 nop
281 00026E44 # asm("addf r6"); /* add a '0' */
282 00026E44 c6 56 addf r6
283 00026E46 # asm("nop");
284 00026E46 10 nop
285 00026E47 # asm("mulf r5"); /* multipy by '1' again */
286 00026E47 e6 55 mulf r5
287 00026E49 # asm("nop");
288 00026E49 10 nop
289 00026E4A # asm("stf r7"); /* store the result */
290 00026E4A 26 57 stf r7
291 00026E4C # if( force_loop );
292 00026E4C 5d effffffdea tstl _force_loop
293 00026E52 31 00 jeql L254
294 00026E54 # asm("brb _pipe2_2_lp1");; /* loop on the error */
295 00026E54 L254:
296 00026E54 11 d0 brb _pipe2_2_lp1
297 00026E56 # /*
298 00026E56 # * verify the results
299 00026E56 # */
300 00026E56 # asm("movl r7,_sgl_st_acc"); /* get the result */
301 00026E56 0d 57 effffffddf movl r7,_sgl_st_acc
302 00026E5D # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
303 00026E5D 1d effffffdd9 effffffdd4 cmpl _sgl_st_acc,_sgl_expected
304 00026E68 31 42 jeql L255
305 00026E6A # {
306 00026E6A # errcnt++; /* bump the error count */
307 00026E6A 6d effffffdcc incl _errcnt
308 00026E70 # if ( prt_error )
309 00026E70 5d effffffdc6 tstl _prt_error
310 00026E76 31 0d jeql L256
311 00026E78 # print_pipe2_er("Reg. Data, 1 NO-OP");
312 00026E78 .data 1
313 00000d2a * L257:
314 00000d2a * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
04E4F2D4F5000
315 00000d3d * .text
316 00026E78 dd 8f00000d2a pushl $L257
317 00026E7E fe 08 ef00000943 callf $8,_print_pipe2_er
318 00026E85 # if ( halt_flg ) /* halt on error? */
319 00026E85 L256:
320 00026E85 5d effffffdb1 tstl _halt_flg
321 00026E8B 31 0d jeql L258
322 00026E8D # pipe2_er_hlt( subtest );
323 00026E8D dd effffffda9 pushl _subtest
324 00026E93 fe 08 ef00000a3a callf $8,_pipe2_er_hlt
325 00026E9A # if ( loop_on_err ) {
326 00026E9A L258:
327 00026E9A 5d effffffd9c tstl _loop_on_err
328 00026EA0 31 0a jeql L259
329 00026EA2 # force_loop = TRUE; /* set the force loop flag */
330 00026EA2 0d 01 effffffd93 movl $1,_force_loop
331 00026EA9 # asm("brw _pipe2_2_lp1"); /* and loop */
332 00026EA9 13 ff7a brw _pipe2_2_lp1
333 00026EAC # }
334 00026EAC # } /* end of compare error */
335 00026EAC L259:
336 00026EAC # } while( index++ < max_lnf_1_index );
337 00026EAC L255:
338 00026EAC L252:
339 00026EAC 0d effffffd8a 50 movl _index,r0
340 00026EB3 6d effffffd83 incl _index
341 00026EB9 1d 50 effffffd7c cmpl r0,_max_lnf_1_index
342 00026EC0 81 03 13 ff24 jlss L253
343 00026EC5 L251:
344 00026EC5 # } /* end of subtest 2 */
345 00026EC5 40 ret#2
346 00026EC6 .set L247,0x0
347 00026EC6 L249:
348 00026EC6 13 ff14 jbr L250
349 00026EC9 .data
350 00000d0c * .text
351 00026EC9 00 .align 1
352 00026ECA .globl _pipe2_3
353 00026ECA _pipe2_3:
354 00026ECA 0000 .word L260
355 00026ECC #
356 00026ECC #
357 00026ECC #
358 00026ECC #
359 00026ECC #
360 00026ECC #
361 00026ECC # /************************************************************************
362 00026ECC # *
363 00026ECC # * SUBTEST 3
364 00026ECC # * data in registers, 2 NO-OPs
365 00026ECC # *
366 00026ECC # ************************************************************************/
367 00026ECC # pipe2_3()
368 00026ECC # {
369 00026ECC 13 00ee jbr L262
370 00026ECF L263:
371 00026ECF # force_loop = FALSE; /* clear force_loop flag */
372 00026ECF 4d effffffd67 clrl _force_loop
373 00026ED5 # index = 0;
374 00026ED5 4d effffffd61 clrl _index
375 00026EDB # do
376 00026EDB L266:
377 00026EDB # {
378 00026EDB # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
379 00026EDB 0d effffffd5b 50 movl _index,r0
380 00026EE2 48 03 50 50 shll $3,r0,r0
381 00026EE6 0d e000000000 effffffd4b movl _lnf_1_data(r0),_sgl_value_1
382 00026EF1 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
383 00026EF1 0d effffffd45 50 movl _index,r0
384 00026EF8 48 03 50 50 shll $3,r0,r0
385 00026EFC 0d e000000004 effffffd35 movl _lnf_1_data+4(r0),_sgl_expected
386 00026F07 # sgl_value_2 = 0x40800000; /* floating '1' */
387 00026F07 0d 8f40800000 effffffd2a movl $1082130432,_sgl_value_2
388 00026F12 # sgl_value_3 = 0; /* floating '0' */
389 00026F12 4d effffffd24 clrl _sgl_value_3
390 00026F18 # /*
391 00026F18 # * If LOOP ON ERROR is set, this is the loop for this subtest.
392 00026F18 # * The force loop flag is set after the first error.
393 00026F18 # */
394 00026F18 # asm("_pipe2_3_lp1:");
395 00026F18 _pipe2_3_lp1:
396 00026F18 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
397 00026F18 0d effffffd1e 54 movl _sgl_value_1,r4
398 00026F1F # asm("movl _sgl_value_2,r5"); /* move data to r5 */
399 00026F1F 0d effffffd17 55 movl _sgl_value_2,r5
400 00026F26 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
401 00026F26 0d effffffd10 56 movl _sgl_value_3,r6
402 00026F2D # asm("lnf r4"); /* load (negate) the data */
403 00026F2D 16 54 lnf r4
404 00026F2F # asm("nop");
405 00026F2F 10 nop
406 00026F30 # asm("nop");
407 00026F30 10 nop
408 00026F31 # asm("mulf r5"); /* multipy by '1' (twice) */
409 00026F31 e6 55 mulf r5
410 00026F33 # asm("nop");
411 00026F33 10 nop
412 00026F34 # asm("nop");
413 00026F34 10 nop
414 00026F35 # asm("mulf r5");
415 00026F35 e6 55 mulf r5
416 00026F37 # asm("nop");
417 00026F37 10 nop
418 00026F38 # asm("nop");
419 00026F38 10 nop
420 00026F39 # asm("addf r6"); /* add a '0' */
421 00026F39 c6 56 addf r6
422 00026F3B # asm("nop");
423 00026F3B 10 nop
424 00026F3C # asm("nop");
425 00026F3C 10 nop
426 00026F3D # asm("mulf r5"); /* multipy by '1' again */
427 00026F3D e6 55 mulf r5
428 00026F3F # asm("nop");
429 00026F3F 10 nop
430 00026F40 # asm("nop");
431 00026F40 10 nop
432 00026F41 # asm("stf r7"); /* store the result */
433 00026F41 26 57 stf r7
434 00026F43 # if( force_loop );
435 00026F43 5d effffffcf3 tstl _force_loop
436 00026F49 31 00 jeql L267
437 00026F4B # asm("brb _pipe2_3_lp1");; /* loop on the error */
438 00026F4B L267:
439 00026F4B 11 cb brb _pipe2_3_lp1
440 00026F4D # /*
441 00026F4D # * verify the results
442 00026F4D # */
443 00026F4D # asm("movl r7,_sgl_st_acc"); /* get the result */
444 00026F4D 0d 57 effffffce8 movl r7,_sgl_st_acc
445 00026F54 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
446 00026F54 1d effffffce2 effffffcdd cmpl _sgl_st_acc,_sgl_expected
447 00026F5F 31 42 jeql L268
448 00026F61 # {
449 00026F61 # errcnt++; /* bump the error count */
450 00026F61 6d effffffcd5 incl _errcnt
451 00026F67 # if ( prt_error )
452 00026F67 5d effffffccf tstl _prt_error
453 00026F6D 31 0d jeql L269
454 00026F6F # print_pipe2_er("Reg. Data, 2 NO-OPS");
455 00026F6F .data 1
456 00000d3d * L270:
457 00000d3d * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPS\0"
04E4F2D4F505300
458 00000d51 * .text
459 00026F6F dd 8f00000d3d pushl $L270
460 00026F75 fe 08 ef0000084c callf $8,_print_pipe2_er
461 00026F7C # if ( halt_flg ) /* halt on error? */
462 00026F7C L269:
463 00026F7C 5d effffffcba tstl _halt_flg
464 00026F82 31 0d jeql L271
465 00026F84 # pipe2_er_hlt( subtest );
466 00026F84 dd effffffcb2 pushl _subtest
467 00026F8A fe 08 ef00000943 callf $8,_pipe2_er_hlt
468 00026F91 # if ( loop_on_err ) {
469 00026F91 L271:
470 00026F91 5d effffffca5 tstl _loop_on_err
471 00026F97 31 0a jeql L272
472 00026F99 # force_loop = TRUE; /* set the force loop flag */
473 00026F99 0d 01 effffffc9c movl $1,_force_loop
474 00026FA0 # asm("brw _pipe2_3_lp1"); /* and loop */
475 00026FA0 13 ff75 brw _pipe2_3_lp1
476 00026FA3 # }
477 00026FA3 # } /* end of compare error */
478 00026FA3 L272:
479 00026FA3 # } while( index++ < max_lnf_1_index );
480 00026FA3 L268:
481 00026FA3 L265:
482 00026FA3 0d effffffc93 50 movl _index,r0
483 00026FAA 6d effffffc8c incl _index
484 00026FB0 1d 50 effffffc85 cmpl r0,_max_lnf_1_index
485 00026FB7 81 03 13 ff1f jlss L266
486 00026FBC L264:
487 00026FBC # } /* end of subtest 3 */
488 00026FBC 40 ret#2
489 00026FBD .set L260,0x0
490 00026FBD L262:
491 00026FBD 13 ff0f jbr L263
492 00026FC0 .data
493 00000d0c * .text
494 00026FC0 .align 1
495 00026FC0 .globl _pipe2_4
496 00026FC0 _pipe2_4:
497 00026FC0 0000 .word L273
498 00026FC2 #
499 00026FC2 #
500 00026FC2 #
501 00026FC2 #
502 00026FC2 #
503 00026FC2 #
504 00026FC2 # /************************************************************************
505 00026FC2 # *
506 00026FC2 # * SUBTEST 4
507 00026FC2 # * data in registers, 3 NO-OPs
508 00026FC2 # *
509 00026FC2 # ************************************************************************/
510 00026FC2 # pipe2_4()
511 00026FC2 # {
512 00026FC2 13 00f3 jbr L275
513 00026FC5 L276:
514 00026FC5 # force_loop = FALSE; /* clear force_loop flag */
515 00026FC5 4d effffffc71 clrl _force_loop
516 00026FCB # index = 0;
517 00026FCB 4d effffffc6b clrl _index
518 00026FD1 # do
519 00026FD1 L279:
520 00026FD1 # {
521 00026FD1 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
522 00026FD1 0d effffffc65 50 movl _index,r0
523 00026FD8 48 03 50 50 shll $3,r0,r0
524 00026FDC 0d e000000000 effffffc55 movl _lnf_1_data(r0),_sgl_value_1
525 00026FE7 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
526 00026FE7 0d effffffc4f 50 movl _index,r0
527 00026FEE 48 03 50 50 shll $3,r0,r0
528 00026FF2 0d e000000004 effffffc3f movl _lnf_1_data+4(r0),_sgl_expected
529 00026FFD # sgl_value_2 = 0x40800000; /* floating '1' */
530 00026FFD 0d 8f40800000 effffffc34 movl $1082130432,_sgl_value_2
531 00027008 # sgl_value_3 = 0; /* floating '0' */
532 00027008 4d effffffc2e clrl _sgl_value_3
533 0002700E # /*
534 0002700E # * If LOOP ON ERROR is set, this is the loop for this subtest.
535 0002700E # * The force loop flag is set after the first error.
536 0002700E # */
537 0002700E # asm("_pipe2_4_lp1:");
538 0002700E _pipe2_4_lp1:
539 0002700E # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
540 0002700E 0d effffffc28 54 movl _sgl_value_1,r4
541 00027015 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
542 00027015 0d effffffc21 55 movl _sgl_value_2,r5
543 0002701C # asm("movl _sgl_value_3,r6"); /* move data to r6 */
544 0002701C 0d effffffc1a 56 movl _sgl_value_3,r6
545 00027023 # asm("lnf r4"); /* load (negate) the data */
546 00027023 16 54 lnf r4
547 00027025 # asm("nop");
548 00027025 10 nop
549 00027026 # asm("nop");
550 00027026 10 nop
551 00027027 # asm("nop");
552 00027027 10 nop
553 00027028 # asm("mulf r5"); /* multipy by '1' (twice) */
554 00027028 e6 55 mulf r5
555 0002702A # asm("nop");
556 0002702A 10 nop
557 0002702B # asm("nop");
558 0002702B 10 nop
559 0002702C # asm("nop");
560 0002702C 10 nop
561 0002702D # asm("mulf r5");
562 0002702D e6 55 mulf r5
563 0002702F # asm("nop");
564 0002702F 10 nop
565 00027030 # asm("nop");
566 00027030 10 nop
567 00027031 # asm("nop");
568 00027031 10 nop
569 00027032 # asm("addf r6"); /* add a '0' */
570 00027032 c6 56 addf r6
571 00027034 # asm("nop");
572 00027034 10 nop
573 00027035 # asm("nop");
574 00027035 10 nop
575 00027036 # asm("nop");
576 00027036 10 nop
577 00027037 # asm("mulf r5"); /* multipy by '1' again */
578 00027037 e6 55 mulf r5
579 00027039 # asm("nop");
580 00027039 10 nop
581 0002703A # asm("nop");
582 0002703A 10 nop
583 0002703B # asm("nop");
584 0002703B 10 nop
585 0002703C # asm("stf r7"); /* store the result */
586 0002703C 26 57 stf r7
587 0002703E # if( force_loop );
588 0002703E 5d effffffbf8 tstl _force_loop
589 00027044 31 00 jeql L280
590 00027046 # asm("brb _pipe2_4_lp1");; /* loop on the error */
591 00027046 L280:
592 00027046 11 c6 brb _pipe2_4_lp1
593 00027048 # /*
594 00027048 # * verify the results
595 00027048 # */
596 00027048 # asm("movl r7,_sgl_st_acc"); /* get the result */
597 00027048 0d 57 effffffbed movl r7,_sgl_st_acc
598 0002704F # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
599 0002704F 1d effffffbe7 effffffbe2 cmpl _sgl_st_acc,_sgl_expected
600 0002705A 31 42 jeql L281
601 0002705C # {
602 0002705C # errcnt++; /* bump the error count */
603 0002705C 6d effffffbda incl _errcnt
604 00027062 # if ( prt_error )
605 00027062 5d effffffbd4 tstl _prt_error
606 00027068 31 0d jeql L282
607 0002706A # print_pipe2_er("Reg. Data, 3 NO-OPS");
608 0002706A .data 1
609 00000d51 * L283:
610 00000d51 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPS\0"
04E4F2D4F505300
611 00000d65 * .text
612 0002706A dd 8f00000d51 pushl $L283
613 00027070 fe 08 ef00000751 callf $8,_print_pipe2_er
614 00027077 # if ( halt_flg ) /* halt on error? */
615 00027077 L282:
616 00027077 5d effffffbbf tstl _halt_flg
617 0002707D 31 0d jeql L284
618 0002707F # pipe2_er_hlt( subtest );
619 0002707F dd effffffbb7 pushl _subtest
620 00027085 fe 08 ef00000848 callf $8,_pipe2_er_hlt
621 0002708C # if ( loop_on_err ) {
622 0002708C L284:
623 0002708C 5d effffffbaa tstl _loop_on_err
624 00027092 31 0a jeql L285
625 00027094 # force_loop = TRUE; /* set the force loop flag */
626 00027094 0d 01 effffffba1 movl $1,_force_loop
627 0002709B # asm("brw _pipe2_4_lp1"); /* and loop */
628 0002709B 13 ff70 brw _pipe2_4_lp1
629 0002709E # }
630 0002709E # } /* end of compare error */
631 0002709E L285:
632 0002709E # } while( index++ < max_lnf_1_index );
633 0002709E L281:
634 0002709E L278:
635 0002709E 0d effffffb98 50 movl _index,r0
636 000270A5 6d effffffb91 incl _index
637 000270AB 1d 50 effffffb8a cmpl r0,_max_lnf_1_index
638 000270B2 81 03 13 ff1a jlss L279
639 000270B7 L277:
640 000270B7 # } /* end of subtest 4 */
641 000270B7 40 ret#2
642 000270B8 .set L273,0x0
643 000270B8 L275:
644 000270B8 13 ff0a jbr L276
645 000270BB .data
646 00000d0c * .text
647 000270BB 00 .align 1
648 000270BC .globl _pipe2_5
649 000270BC _pipe2_5:
650 000270BC 0000 .word L286
651 000270BE #
652 000270BE #
653 000270BE #
654 000270BE #
655 000270BE #
656 000270BE #
657 000270BE #
658 000270BE # /************************************************************************
659 000270BE # *
660 000270BE # * SUBTEST 5
661 000270BE # * data in Cache, no NO-OPs
662 000270BE # *
663 000270BE # ************************************************************************/
664 000270BE # pipe2_5()
665 000270BE # {
666 000270BE 13 00e0 jbr L288
667 000270C1 L289:
668 000270C1 # force_loop = FALSE; /* clear force_loop flag */
669 000270C1 4d effffffb75 clrl _force_loop
670 000270C7 # index = 0;
671 000270C7 4d effffffb6f clrl _index
672 000270CD # do
673 000270CD L292:
674 000270CD # {
675 000270CD # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
676 000270CD 0d effffffb69 50 movl _index,r0
677 000270D4 48 03 50 50 shll $3,r0,r0
678 000270D8 0d e000000000 effffffb59 movl _lnf_1_data(r0),_sgl_value_1
679 000270E3 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
680 000270E3 0d effffffb53 50 movl _index,r0
681 000270EA 48 03 50 50 shll $3,r0,r0
682 000270EE 0d e000000004 effffffb43 movl _lnf_1_data+4(r0),_sgl_expected
683 000270F9 # sgl_value_2 = 0x40800000; /* floating '1' */
684 000270F9 0d 8f40800000 effffffb38 movl $1082130432,_sgl_value_2
685 00027104 # sgl_value_3 = 0; /* floating '0' */
686 00027104 4d effffffb32 clrl _sgl_value_3
687 0002710A # /*
688 0002710A # * If LOOP ON ERROR is set, this is the loop for this subtest.
689 0002710A # * The force loop flag is set after the first error.
690 0002710A # */
691 0002710A # asm("_pipe2_5_lp1:");
692 0002710A _pipe2_5_lp1:
693 0002710A # asm("lnf _sgl_value_1"); /* load (negate) the data */
694 0002710A 16 effffffb2c lnf _sgl_value_1
695 00027110 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
696 00027110 e6 effffffb26 mulf _sgl_value_2
697 00027116 # asm("mulf _sgl_value_2");
698 00027116 e6 effffffb20 mulf _sgl_value_2
699 0002711C # asm("addf _sgl_value_3"); /* add a '0' */
700 0002711C c6 effffffb1a addf _sgl_value_3
701 00027122 # asm("mulf _sgl_value_2"); /* multipy by '1' again */
702 00027122 e6 effffffb14 mulf _sgl_value_2
703 00027128 # asm("stf _sgl_st_acc"); /* store the result */
704 00027128 26 effffffb0e stf _sgl_st_acc
705 0002712E # if( force_loop );
706 0002712E 5d effffffb08 tstl _force_loop
707 00027134 31 00 jeql L293
708 00027136 # asm("brb _pipe2_5_lp1");; /* loop on the error */
709 00027136 L293:
710 00027136 11 d2 brb _pipe2_5_lp1
711 00027138 # /*
712 00027138 # * verify the results
713 00027138 # */
714 00027138 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
715 00027138 1d effffffafe effffffaf9 cmpl _sgl_st_acc,_sgl_expected
716 00027143 31 42 jeql L294
717 00027145 # {
718 00027145 # errcnt++; /* bump the error count */
719 00027145 6d effffffaf1 incl _errcnt
720 0002714B # if ( prt_error )
721 0002714B 5d effffffaeb tstl _prt_error
722 00027151 31 0d jeql L295
723 00027153 # print_pipe2_er("Cache Data, no NO-OPS");
724 00027153 .data 1
725 00000d65 * L296:
726 00000d65 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPS\0"
E6F204E4F2D4F505300
727 00000d7b * .text
728 00027153 dd 8f00000d65 pushl $L296
729 00027159 fe 08 ef00000668 callf $8,_print_pipe2_er
730 00027160 # if ( halt_flg ) /* halt on error? */
731 00027160 L295:
732 00027160 5d effffffad6 tstl _halt_flg
733 00027166 31 0d jeql L297
734 00027168 # pipe2_er_hlt( subtest );
735 00027168 dd efffffface pushl _subtest
736 0002716E fe 08 ef0000075f callf $8,_pipe2_er_hlt
737 00027175 # if ( loop_on_err ) {
738 00027175 L297:
739 00027175 5d effffffac1 tstl _loop_on_err
740 0002717B 31 0a jeql L298
741 0002717D # force_loop = TRUE; /* set the force loop flag */
742 0002717D 0d 01 effffffab8 movl $1,_force_loop
743 00027184 # asm("brw _pipe2_5_lp1"); /* and loop */
744 00027184 13 ff83 brw _pipe2_5_lp1
745 00027187 # }
746 00027187 # } /* end of compare error */
747 00027187 L298:
748 00027187 # } while( index++ < max_lnf_1_index );
749 00027187 L294:
750 00027187 L291:
751 00027187 0d effffffaaf 50 movl _index,r0
752 0002718E 6d effffffaa8 incl _index
753 00027194 1d 50 effffffaa1 cmpl r0,_max_lnf_1_index
754 0002719B 81 03 13 ff2d jlss L292
755 000271A0 L290:
756 000271A0 # } /* end of subtest 5 */
757 000271A0 40 ret#2
758 000271A1 .set L286,0x0
759 000271A1 L288:
760 000271A1 13 ff1d jbr L289
761 000271A4 .data
762 00000d0c * .text
763 000271A4 .align 1
764 000271A4 .globl _pipe2_6
765 000271A4 _pipe2_6:
766 000271A4 0000 .word L299
767 000271A6 #
768 000271A6 #
769 000271A6 #
770 000271A6 #
771 000271A6 #
772 000271A6 #
773 000271A6 # /************************************************************************
774 000271A6 # *
775 000271A6 # * SUBTEST 6
776 000271A6 # * data in Cache, 1 NO-OP
777 000271A6 # *
778 000271A6 # ************************************************************************/
779 000271A6 # pipe2_6()
780 000271A6 # {
781 000271A6 13 00e5 jbr L301
782 000271A9 L302:
783 000271A9 # force_loop = FALSE; /* clear force_loop flag */
784 000271A9 4d effffffa8d clrl _force_loop
785 000271AF # index = 0;
786 000271AF 4d effffffa87 clrl _index
787 000271B5 # do
788 000271B5 L305:
789 000271B5 # {
790 000271B5 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
791 000271B5 0d effffffa81 50 movl _index,r0
792 000271BC 48 03 50 50 shll $3,r0,r0
793 000271C0 0d e000000000 effffffa71 movl _lnf_1_data(r0),_sgl_value_1
794 000271CB # sgl_expected = lnf_1_data[index].exp; /* get expected results */
795 000271CB 0d effffffa6b 50 movl _index,r0
796 000271D2 48 03 50 50 shll $3,r0,r0
797 000271D6 0d e000000004 effffffa5b movl _lnf_1_data+4(r0),_sgl_expected
798 000271E1 # sgl_value_2 = 0x40800000; /* floating '1' */
799 000271E1 0d 8f40800000 effffffa50 movl $1082130432,_sgl_value_2
800 000271EC # sgl_value_3 = 0; /* floating '0' */
801 000271EC 4d effffffa4a clrl _sgl_value_3
802 000271F2 # /*
803 000271F2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
804 000271F2 # * The force loop flag is set after the first error.
805 000271F2 # */
806 000271F2 # asm("_pipe2_6_lp1:");
807 000271F2 _pipe2_6_lp1:
808 000271F2 # asm("lnf _sgl_value_1"); /* load (negate) the data */
809 000271F2 16 effffffa44 lnf _sgl_value_1
810 000271F8 # asm("nop");
811 000271F8 10 nop
812 000271F9 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
813 000271F9 e6 effffffa3d mulf _sgl_value_2
814 000271FF # asm("nop");
815 000271FF 10 nop
816 00027200 # asm("mulf _sgl_value_2");
817 00027200 e6 effffffa36 mulf _sgl_value_2
818 00027206 # asm("nop");
819 00027206 10 nop
820 00027207 # asm("addf _sgl_value_3"); /* add a '0' */
821 00027207 c6 effffffa2f addf _sgl_value_3
822 0002720D # asm("nop");
823 0002720D 10 nop
824 0002720E # asm("mulf _sgl_value_2"); /* multipy by '1' again */
825 0002720E e6 effffffa28 mulf _sgl_value_2
826 00027214 # asm("nop");
827 00027214 10 nop
828 00027215 # asm("stf _sgl_st_acc"); /* store the result */
829 00027215 26 effffffa21 stf _sgl_st_acc
830 0002721B # if( force_loop );
831 0002721B 5d effffffa1b tstl _force_loop
832 00027221 31 00 jeql L306
833 00027223 # asm("brb _pipe2_6_lp1");; /* loop on the error */
834 00027223 L306:
835 00027223 11 cd brb _pipe2_6_lp1
836 00027225 # /*
837 00027225 # * verify the results
838 00027225 # */
839 00027225 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
840 00027225 1d effffffa11 effffffa0c cmpl _sgl_st_acc,_sgl_expected
841 00027230 31 42 jeql L307
842 00027232 # {
843 00027232 # errcnt++; /* bump the error count */
844 00027232 6d effffffa04 incl _errcnt
845 00027238 # if ( prt_error )
846 00027238 5d effffff9fe tstl _prt_error
847 0002723E 31 0d jeql L308
848 00027240 # print_pipe2_er("Cache Data, 1 NO-OP");
849 00027240 .data 1
850 00000d7b * L309:
851 00000d7b * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
1204E4F2D4F5000
852 00000d8f * .text
853 00027240 dd 8f00000d7b pushl $L309
854 00027246 fe 08 ef0000057b callf $8,_print_pipe2_er
855 0002724D # if ( halt_flg ) /* halt on error? */
856 0002724D L308:
857 0002724D 5d effffff9e9 tstl _halt_flg
858 00027253 31 0d jeql L310
859 00027255 # pipe2_er_hlt( subtest );
860 00027255 dd effffff9e1 pushl _subtest
861 0002725B fe 08 ef00000672 callf $8,_pipe2_er_hlt
862 00027262 # if ( loop_on_err ) {
863 00027262 L310:
864 00027262 5d effffff9d4 tstl _loop_on_err
865 00027268 31 0a jeql L311
866 0002726A # force_loop = TRUE; /* set the force loop flag */
867 0002726A 0d 01 effffff9cb movl $1,_force_loop
868 00027271 # asm("brw _pipe2_6_lp1"); /* and loop */
869 00027271 13 ff7e brw _pipe2_6_lp1
870 00027274 # }
871 00027274 # } /* end of compare error */
872 00027274 L311:
873 00027274 # } while( index++ < max_lnf_1_index );
874 00027274 L307:
875 00027274 L304:
876 00027274 0d effffff9c2 50 movl _index,r0
877 0002727B 6d effffff9bb incl _index
878 00027281 1d 50 effffff9b4 cmpl r0,_max_lnf_1_index
879 00027288 81 03 13 ff28 jlss L305
880 0002728D L303:
881 0002728D # } /* end of subtest 6 */
882 0002728D 40 ret#2
883 0002728E .set L299,0x0
884 0002728E L301:
885 0002728E 13 ff18 jbr L302
886 00027291 .data
887 00000d0c * .text
888 00027291 00 .align 1
889 00027292 .globl _pipe2_7
890 00027292 _pipe2_7:
891 00027292 0000 .word L312
892 00027294 #
893 00027294 #
894 00027294 #
895 00027294 #
896 00027294 #
897 00027294 #
898 00027294 # /************************************************************************
899 00027294 # *
900 00027294 # * SUBTEST 7
901 00027294 # * data in Cache, 2 NO-OPs
902 00027294 # *
903 00027294 # ************************************************************************/
904 00027294 # pipe2_7()
905 00027294 # {
906 00027294 13 00ea jbr L314
907 00027297 L315:
908 00027297 # force_loop = FALSE; /* clear force_loop flag */
909 00027297 4d effffff99f clrl _force_loop
910 0002729D # index = 0;
911 0002729D 4d effffff999 clrl _index
912 000272A3 # do
913 000272A3 L318:
914 000272A3 # {
915 000272A3 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
916 000272A3 0d effffff993 50 movl _index,r0
917 000272AA 48 03 50 50 shll $3,r0,r0
918 000272AE 0d e000000000 effffff983 movl _lnf_1_data(r0),_sgl_value_1
919 000272B9 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
920 000272B9 0d effffff97d 50 movl _index,r0
921 000272C0 48 03 50 50 shll $3,r0,r0
922 000272C4 0d e000000004 effffff96d movl _lnf_1_data+4(r0),_sgl_expected
923 000272CF # sgl_value_2 = 0x40800000; /* floating '1' */
924 000272CF 0d 8f40800000 effffff962 movl $1082130432,_sgl_value_2
925 000272DA # sgl_value_3 = 0; /* floating '0' */
926 000272DA 4d effffff95c clrl _sgl_value_3
927 000272E0 # /*
928 000272E0 # * If LOOP ON ERROR is set, this is the loop for this subtest.
929 000272E0 # * The force loop flag is set after the first error.
930 000272E0 # */
931 000272E0 # asm("_pipe2_7_lp1:");
932 000272E0 _pipe2_7_lp1:
933 000272E0 # asm("lnf _sgl_value_1"); /* load (negate) the data */
934 000272E0 16 effffff956 lnf _sgl_value_1
935 000272E6 # asm("nop");
936 000272E6 10 nop
937 000272E7 # asm("nop");
938 000272E7 10 nop
939 000272E8 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
940 000272E8 e6 effffff94e mulf _sgl_value_2
941 000272EE # asm("nop");
942 000272EE 10 nop
943 000272EF # asm("nop");
944 000272EF 10 nop
945 000272F0 # asm("mulf _sgl_value_2");
946 000272F0 e6 effffff946 mulf _sgl_value_2
947 000272F6 # asm("nop");
948 000272F6 10 nop
949 000272F7 # asm("nop");
950 000272F7 10 nop
951 000272F8 # asm("addf _sgl_value_3"); /* add a '0' */
952 000272F8 c6 effffff93e addf _sgl_value_3
953 000272FE # asm("nop");
954 000272FE 10 nop
955 000272FF # asm("nop");
956 000272FF 10 nop
957 00027300 # asm("mulf _sgl_value_2"); /* multipy by '1' again */
958 00027300 e6 effffff936 mulf _sgl_value_2
959 00027306 # asm("nop");
960 00027306 10 nop
961 00027307 # asm("nop");
962 00027307 10 nop
963 00027308 # asm("stf _sgl_st_acc"); /* store the result */
964 00027308 26 effffff92e stf _sgl_st_acc
965 0002730E # if( force_loop );
966 0002730E 5d effffff928 tstl _force_loop
967 00027314 31 00 jeql L319
968 00027316 # asm("brb _pipe2_7_lp1");; /* loop on the error */
969 00027316 L319:
970 00027316 11 c8 brb _pipe2_7_lp1
971 00027318 # /*
972 00027318 # * verify the results
973 00027318 # */
974 00027318 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
975 00027318 1d effffff91e effffff919 cmpl _sgl_st_acc,_sgl_expected
976 00027323 31 42 jeql L320
977 00027325 # {
978 00027325 # errcnt++; /* bump the error count */
979 00027325 6d effffff911 incl _errcnt
980 0002732B # if ( prt_error )
981 0002732B 5d effffff90b tstl _prt_error
982 00027331 31 0d jeql L321
983 00027333 # print_pipe2_er("Cache Data, 2 NO-OPS");
984 00027333 .data 1
985 00000d8f * L322:
986 00000d8f * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPS\0"
2204E4F2D4F505300
987 00000da4 * .text
988 00027333 dd 8f00000d8f pushl $L322
989 00027339 fe 08 ef00000488 callf $8,_print_pipe2_er
990 00027340 # if ( halt_flg ) /* halt on error? */
991 00027340 L321:
992 00027340 5d effffff8f6 tstl _halt_flg
993 00027346 31 0d jeql L323
994 00027348 # pipe2_er_hlt( subtest );
995 00027348 dd effffff8ee pushl _subtest
996 0002734E fe 08 ef0000057f callf $8,_pipe2_er_hlt
997 00027355 # if ( loop_on_err ) {
998 00027355 L323:
999 00027355 5d effffff8e1 tstl _loop_on_err
1000 0002735B 31 0a jeql L324
1001 0002735D # force_loop = TRUE; /* set the force loop flag */
1002 0002735D 0d 01 effffff8d8 movl $1,_force_loop
1003 00027364 # asm("brw _pipe2_7_lp1"); /* and loop */
1004 00027364 13 ff79 brw _pipe2_7_lp1
1005 00027367 # }
1006 00027367 # } /* end of compare error */
1007 00027367 L324:
1008 00027367 # } while( index++ < max_lnf_1_index );
1009 00027367 L320:
1010 00027367 L317:
1011 00027367 0d effffff8cf 50 movl _index,r0
1012 0002736E 6d effffff8c8 incl _index
1013 00027374 1d 50 effffff8c1 cmpl r0,_max_lnf_1_index
1014 0002737B 81 03 13 ff23 jlss L318
1015 00027380 L316:
1016 00027380 # } /* end of subtest 7 */
1017 00027380 40 ret#2
1018 00027381 .set L312,0x0
1019 00027381 L314:
1020 00027381 13 ff13 jbr L315
1021 00027384 .data
1022 00000d0c * .text
1023 00027384 .align 1
1024 00027384 .globl _pipe2_8
1025 00027384 _pipe2_8:
1026 00027384 0000 .word L325
1027 00027386 #
1028 00027386 #
1029 00027386 #
1030 00027386 #
1031 00027386 #
1032 00027386 #
1033 00027386 # /************************************************************************
1034 00027386 # *
1035 00027386 # * SUBTEST 8
1036 00027386 # * data in Cache, 3 NO-OPs
1037 00027386 # *
1038 00027386 # ************************************************************************/
1039 00027386 # pipe2_8()
1040 00027386 # {
1041 00027386 13 00ef jbr L327
1042 00027389 L328:
1043 00027389 # force_loop = FALSE; /* clear force_loop flag */
1044 00027389 4d effffff8ad clrl _force_loop
1045 0002738F # index = 0;
1046 0002738F 4d effffff8a7 clrl _index
1047 00027395 # do
1048 00027395 L331:
1049 00027395 # {
1050 00027395 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1051 00027395 0d effffff8a1 50 movl _index,r0
1052 0002739C 48 03 50 50 shll $3,r0,r0
1053 000273A0 0d e000000000 effffff891 movl _lnf_1_data(r0),_sgl_value_1
1054 000273AB # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1055 000273AB 0d effffff88b 50 movl _index,r0
1056 000273B2 48 03 50 50 shll $3,r0,r0
1057 000273B6 0d e000000004 effffff87b movl _lnf_1_data+4(r0),_sgl_expected
1058 000273C1 # sgl_value_2 = 0x40800000; /* floating '1' */
1059 000273C1 0d 8f40800000 effffff870 movl $1082130432,_sgl_value_2
1060 000273CC # sgl_value_3 = 0; /* floating '0' */
1061 000273CC 4d effffff86a clrl _sgl_value_3
1062 000273D2 # /*
1063 000273D2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1064 000273D2 # * The force loop flag is set after the first error.
1065 000273D2 # */
1066 000273D2 # asm("_pipe2_8_lp1:");
1067 000273D2 _pipe2_8_lp1:
1068 000273D2 # asm("lnf _sgl_value_1"); /* load (negate) the data */
1069 000273D2 16 effffff864 lnf _sgl_value_1
1070 000273D8 # asm("nop");
1071 000273D8 10 nop
1072 000273D9 # asm("nop");
1073 000273D9 10 nop
1074 000273DA # asm("nop");
1075 000273DA 10 nop
1076 000273DB # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
1077 000273DB e6 effffff85b mulf _sgl_value_2
1078 000273E1 # asm("nop");
1079 000273E1 10 nop
1080 000273E2 # asm("nop");
1081 000273E2 10 nop
1082 000273E3 # asm("nop");
1083 000273E3 10 nop
1084 000273E4 # asm("mulf _sgl_value_2");
1085 000273E4 e6 effffff852 mulf _sgl_value_2
1086 000273EA # asm("nop");
1087 000273EA 10 nop
1088 000273EB # asm("nop");
1089 000273EB 10 nop
1090 000273EC # asm("nop");
1091 000273EC 10 nop
1092 000273ED # asm("addf _sgl_value_3"); /* add a '0' */
1093 000273ED c6 effffff849 addf _sgl_value_3
1094 000273F3 # asm("nop");
1095 000273F3 10 nop
1096 000273F4 # asm("nop");
1097 000273F4 10 nop
1098 000273F5 # asm("nop");
1099 000273F5 10 nop
1100 000273F6 # asm("mulf _sgl_value_2"); /* multipy by '1' again */
1101 000273F6 e6 effffff840 mulf _sgl_value_2
1102 000273FC # asm("nop");
1103 000273FC 10 nop
1104 000273FD # asm("nop");
1105 000273FD 10 nop
1106 000273FE # asm("nop");
1107 000273FE 10 nop
1108 000273FF # asm("stf _sgl_st_acc"); /* store the result */
1109 000273FF 26 effffff837 stf _sgl_st_acc
1110 00027405 # if( force_loop );
1111 00027405 5d effffff831 tstl _force_loop
1112 0002740B 31 00 jeql L332
1113 0002740D # asm("brb _pipe2_8_lp1");; /* loop on the error */
1114 0002740D L332:
1115 0002740D 11 c3 brb _pipe2_8_lp1
1116 0002740F # /*
1117 0002740F # * verify the results
1118 0002740F # */
1119 0002740F # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
1120 0002740F 1d effffff827 effffff822 cmpl _sgl_st_acc,_sgl_expected
1121 0002741A 31 42 jeql L333
1122 0002741C # {
1123 0002741C # errcnt++; /* bump the error count */
1124 0002741C 6d effffff81a incl _errcnt
1125 00027422 # if ( prt_error )
1126 00027422 5d effffff814 tstl _prt_error
1127 00027428 31 0d jeql L334
1128 0002742A # print_pipe2_er("Cache Data, 3 NO-OPS");
1129 0002742A .data 1
1130 00000da4 * L335:
1131 00000da4 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPS\0"
3204E4F2D4F505300
1132 00000db9 * .text
1133 0002742A dd 8f00000da4 pushl $L335
1134 00027430 fe 08 ef00000391 callf $8,_print_pipe2_er
1135 00027437 # if ( halt_flg ) /* halt on error? */
1136 00027437 L334:
1137 00027437 5d effffff7ff tstl _halt_flg
1138 0002743D 31 0d jeql L336
1139 0002743F # pipe2_er_hlt( subtest );
1140 0002743F dd effffff7f7 pushl _subtest
1141 00027445 fe 08 ef00000488 callf $8,_pipe2_er_hlt
1142 0002744C # if ( loop_on_err ) {
1143 0002744C L336:
1144 0002744C 5d effffff7ea tstl _loop_on_err
1145 00027452 31 0a jeql L337
1146 00027454 # force_loop = TRUE; /* set the force loop flag */
1147 00027454 0d 01 effffff7e1 movl $1,_force_loop
1148 0002745B # asm("brw _pipe2_8_lp1"); /* and loop */
1149 0002745B 13 ff74 brw _pipe2_8_lp1
1150 0002745E # }
1151 0002745E # } /* end of compare error */
1152 0002745E L337:
1153 0002745E # } while( index++ < max_lnf_1_index );
1154 0002745E L333:
1155 0002745E L330:
1156 0002745E 0d effffff7d8 50 movl _index,r0
1157 00027465 6d effffff7d1 incl _index
1158 0002746B 1d 50 effffff7ca cmpl r0,_max_lnf_1_index
1159 00027472 81 03 13 ff1e jlss L331
1160 00027477 L329:
1161 00027477 # } /* end of subtest 8 */
1162 00027477 40 ret#2
1163 00027478 .set L325,0x0
1164 00027478 L327:
1165 00027478 13 ff0e jbr L328
1166 0002747B .data
1167 00000d0c * .text
1168 0002747B 00 .align 1
1169 0002747C .globl _pipe2_9
1170 0002747C _pipe2_9:
1171 0002747C 0000 .word L338
1172 0002747E #
1173 0002747E #
1174 0002747E #
1175 0002747E #
1176 0002747E #
1177 0002747E #
1178 0002747E # /*****************************************************************************
1179 0002747E # *
1180 0002747E # * SUBTEST 9
1181 0002747E # * data on the stack, no NO-OPs
1182 0002747E # *
1183 0002747E # *****************************************************************************/
1184 0002747E # pipe2_9()
1185 0002747E # {
1186 0002747E 13 0186 jbr L340
1187 00027481 L341:
1188 00027481 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1189 00027481 ed 6d effffff7b4 moval (r13),_pre_event_fp
1190 00027488 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1191 00027488 ed 6e effffff7ad moval (r14),_pre_event_sp
1192 0002748F # force_loop = FALSE; /* clear force_loop flag */
1193 0002748F 4d effffff7a7 clrl _force_loop
1194 00027495 # index = 0;
1195 00027495 4d effffff7a1 clrl _index
1196 0002749B # do
1197 0002749B L344:
1198 0002749B # {
1199 0002749B # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1200 0002749B 0d effffff79b 50 movl _index,r0
1201 000274A2 48 03 50 50 shll $3,r0,r0
1202 000274A6 0d e000000000 effffff78b movl _lnf_1_data(r0),_sgl_value_1
1203 000274B1 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1204 000274B1 0d effffff785 50 movl _index,r0
1205 000274B8 48 03 50 50 shll $3,r0,r0
1206 000274BC 0d e000000004 effffff775 movl _lnf_1_data+4(r0),_sgl_expected
1207 000274C7 # sgl_value_2 = 0x40800000; /* floating '1' */
1208 000274C7 0d 8f40800000 effffff76a movl $1082130432,_sgl_value_2
1209 000274D2 # sgl_value_3 = 0; /* floating '0' */
1210 000274D2 4d effffff764 clrl _sgl_value_3
1211 000274D8 # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1212 000274D8 ed effffff75e effffff759 moval _pointer_data,_sgl_value_4
1213 000274E3 # /*
1214 000274E3 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1215 000274E3 # * The force loop flag is set after the first error.
1216 000274E3 # */
1217 000274E3 # asm("_pipe2_9_lp1:");
1218 000274E3 _pipe2_9_lp1:
1219 000274E3 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1220 000274E3 ed effffff753 5e moval _pointer_data,r14
1221 000274EA # asm("movl _sgl_value_2,-(r14)"); /* push a '1' on the stack */
1222 000274EA 0d effffff74c 7e movl _sgl_value_2,-(r14)
1223 000274F1 # asm("movl _sgl_value_3,-(r14)"); /* push a '0' on the stack */
1224 000274F1 0d effffff745 7e movl _sgl_value_3,-(r14)
1225 000274F8 # asm("movl _sgl_value_2,-(r14)"); /* push 2 more '1's */
1226 000274F8 0d effffff73e 7e movl _sgl_value_2,-(r14)
1227 000274FF # asm("movl _sgl_value_2,-(r14)");
1228 000274FF 0d effffff737 7e movl _sgl_value_2,-(r14)
1229 00027506 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1230 00027506 0d effffff730 7e movl _sgl_value_1,-(r14)
1231 0002750D # /*
1232 0002750D # * now pop the data off the stack
1233 0002750D # */
1234 0002750D # asm("lnf (r14)+"); /* load (negate) the data */
1235 0002750D 16 8e lnf (r14)+
1236 0002750F # asm("mulf (r14)+"); /* multiply by '1' (twice) */
1237 0002750F e6 8e mulf (r14)+
1238 00027511 # asm("mulf (r14)+");
1239 00027511 e6 8e mulf (r14)+
1240 00027513 # asm("addf (r14)+"); /* add a '0' */
1241 00027513 c6 8e addf (r14)+
1242 00027515 # asm("mulf (r14)+"); /* multiply by '1' again */
1243 00027515 e6 8e mulf (r14)+
1244 00027517 # asm("stf r5"); /* store the result */
1245 00027517 26 55 stf r5
1246 00027519 # if( force_loop );
1247 00027519 5d effffff71d tstl _force_loop
1248 0002751F 31 00 jeql L345
1249 00027521 # asm("brb _pipe2_9_lp1");; /* loop on the error */
1250 00027521 L345:
1251 00027521 11 c0 brb _pipe2_9_lp1
1252 00027523 # /*
1253 00027523 # * verify the results
1254 00027523 # */
1255 00027523 # asm("movl r5,_sgl_st_acc"); /* get the result */
1256 00027523 0d 55 effffff712 movl r5,_sgl_st_acc
1257 0002752A # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1258 0002752A ed 6e effffff70b moval (r14),_sgl_value_5
1259 00027531 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1260 00027531 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1261 00027531 1d effffff705 effffff700 cmpl _sgl_st_acc,_sgl_expected
1262 0002753C 21 10 jneq L9999
1263 0002753E 1d effffff6f8 effffff6f3 cmpl _sgl_value_5,_sgl_value_4
1264 00027549 21 03 13 0091 jeql L346
1265 0002754E L9999:
1266 0002754E # {
1267 0002754E # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1268 0002754E 0d effffff6e8 5d movl _pre_event_fp,r13
1269 00027555 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1270 00027555 0d effffff6e1 5e movl _pre_event_sp,r14
1271 0002755C # errcnt++; /* bump the error count */
1272 0002755C 6d effffff6da incl _errcnt
1273 00027562 # if ( prt_error )
1274 00027562 5d effffff6d4 tstl _prt_error
1275 00027568 31 0d jeql L347
1276 0002756A # print_pipe2_er("POP Data from the STACK");
1277 0002756A .data 1
1278 00000db9 * L348:
1279 00000db9 * 504F5020446174612066726F6 .ascii "POP Data from the STACK\0"
D2074686520535441434B00
1280 00000dd1 * .text
1281 0002756A dd 8f00000db9 pushl $L348
1282 00027570 fe 08 ef00000251 callf $8,_print_pipe2_er
1283 00027577 # writes("final Stack Pointer = ");
1284 00027577 L347:
1285 00027577 .data 1
1286 00000dd1 * L349:
1287 00000dd1 * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
06F696E746572203D2000
1288 00000de8 * .text
1289 00027577 dd 8f00000dd1 pushl $L349
1290 0002757D fe 08 effffff6b8 callf $8,_writes
1291 00027584 # write32h( sgl_value_5 );
1292 00027584 dd effffff6b2 pushl _sgl_value_5
1293 0002758A fe 08 effffff6ab callf $8,_write32h
1294 00027591 # writes(", expected SP = ");
1295 00027591 .data 1
1296 00000de8 * L351:
1297 00000de8 * 2C20206578706563746564205 .ascii ", expected SP = \0"
350203D2000
1298 00000dfa * .text
1299 00027591 dd 8f00000de8 pushl $L351
1300 00027597 fe 08 effffff69e callf $8,_writes
1301 0002759E # write32h( sgl_value_4 );
1302 0002759E dd effffff698 pushl _sgl_value_4
1303 000275A4 fe 08 effffff691 callf $8,_write32h
1304 000275AB # writes(" \n");
1305 000275AB .data 1
1306 00000dfa * L352:
1307 00000dfa * 200A00 .ascii " \12\0"
1308 00000dfd * .text
1309 000275AB dd 8f00000dfa pushl $L352
1310 000275B1 fe 08 effffff684 callf $8,_writes
1311 000275B8 # if ( halt_flg ) /* halt on error? */
1312 000275B8 5d effffff67e tstl _halt_flg
1313 000275BE 31 0d jeql L353
1314 000275C0 # pipe2_er_hlt( subtest );
1315 000275C0 dd effffff676 pushl _subtest
1316 000275C6 fe 08 ef00000307 callf $8,_pipe2_er_hlt
1317 000275CD # if ( loop_on_err ) {
1318 000275CD L353:
1319 000275CD 5d effffff669 tstl _loop_on_err
1320 000275D3 31 0a jeql L354
1321 000275D5 # force_loop = TRUE; /* set the force loop flag */
1322 000275D5 0d 01 effffff660 movl $1,_force_loop
1323 000275DC # asm("brw _pipe2_9_lp1"); /* and loop */
1324 000275DC 13 ff04 brw _pipe2_9_lp1
1325 000275DF # }
1326 000275DF # } /* end of compare error */
1327 000275DF L354:
1328 000275DF # } while( index++ < max_lnf_1_index );
1329 000275DF L346:
1330 000275DF L343:
1331 000275DF 0d effffff657 50 movl _index,r0
1332 000275E6 6d effffff650 incl _index
1333 000275EC 1d 50 effffff649 cmpl r0,_max_lnf_1_index
1334 000275F3 81 03 13 fea3 jlss L344
1335 000275F8 L342:
1336 000275F8 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1337 000275F8 0d effffff63e 5d movl _pre_event_fp,r13
1338 000275FF # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1339 000275FF 0d effffff637 5e movl _pre_event_sp,r14
1340 00027606 # } /* end of subtest 9 */
1341 00027606 40 ret#2
1342 00027607 .set L338,0x0
1343 00027607 L340:
1344 00027607 13 fe77 jbr L341
1345 0002760A .data
1346 00000d0c * .text
1347 0002760A .align 1
1348 0002760A .globl _pipe2_10
1349 0002760A _pipe2_10:
1350 0002760A 0000 .word L355
1351 0002760C #
1352 0002760C #
1353 0002760C #
1354 0002760C #
1355 0002760C #
1356 0002760C #
1357 0002760C # /******************************************************************************
1358 0002760C # *
1359 0002760C # * SUBTEST 10
1360 0002760C # * get data via indexed FRAME pointer
1361 0002760C # *
1362 0002760C # * ADDR INDEX DATA
1363 0002760C # * pointer_data 4 <the STF result goes here>
1364 0002760C # * pointer_data-4 3 <operand data>
1365 0002760C # * pointer_data-16 0 point the frame pointer here
1366 0002760C # *
1367 0002760C # ******************************************************************************/
1368 0002760C # pipe2_10()
1369 0002760C # {
1370 0002760C 13 01b6 jbr L357
1371 0002760F L358:
1372 0002760F # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1373 0002760F ed 6d effffff626 moval (r13),_pre_event_fp
1374 00027616 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1375 00027616 ed 6e effffff61f moval (r14),_pre_event_sp
1376 0002761D # force_loop = FALSE; /* clear force_loop flag */
1377 0002761D 4d effffff619 clrl _force_loop
1378 00027623 # index = 0;
1379 00027623 4d effffff613 clrl _index
1380 00027629 # do
1381 00027629 L361:
1382 00027629 # {
1383 00027629 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1384 00027629 0d effffff60d 50 movl _index,r0
1385 00027630 48 03 50 50 shll $3,r0,r0
1386 00027634 0d e000000000 effffff5fd movl _lnf_1_data(r0),_sgl_value_1
1387 0002763F # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1388 0002763F 0d effffff5f7 50 movl _index,r0
1389 00027646 48 03 50 50 shll $3,r0,r0
1390 0002764A 0d e000000004 effffff5e7 movl _lnf_1_data+4(r0),_sgl_expected
1391 00027655 # sgl_value_2 = 0x40800000; /* floating '1' */
1392 00027655 0d 8f40800000 effffff5dc movl $1082130432,_sgl_value_2
1393 00027660 # sgl_value_3 = 0; /* floating '0' */
1394 00027660 4d effffff5d6 clrl _sgl_value_3
1395 00027666 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
1396 00027666 ed effffff5d0 effffff5cb moval _pointer_data,_sgl_value_4
1397 00027671 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1398 00027671 2c 04 effffff5c4 subl2 $4,_sgl_value_4
1399 00027678 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
1400 00027678 0d effffff5be fffffff5b9 movl _sgl_value_1,*_sgl_value_4
1401 00027683 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1402 00027683 2c 04 effffff5b2 subl2 $4,_sgl_value_4
1403 0002768A # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the operand data */
1404 0002768A 0d effffff5ac fffffff5a7 movl _sgl_value_2,*_sgl_value_4
1405 00027695 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1406 00027695 2c 04 effffff5a0 subl2 $4,_sgl_value_4
1407 0002769C # asm("movl _sgl_value_3,*_sgl_value_4"); /* set the operand data */
1408 0002769C 0d effffff59a fffffff595 movl _sgl_value_3,*_sgl_value_4
1409 000276A7 # sgl_value_4 -= 4; /* get FRAME PTR address */
1410 000276A7 2c 04 effffff58e subl2 $4,_sgl_value_4
1411 000276AE # /*
1412 000276AE # * If LOOP ON ERROR is set, this is the loop for this subtest.
1413 000276AE # * The force loop flag is set after the first error.
1414 000276AE # */
1415 000276AE # asm("_pipe2_10_lp1:");
1416 000276AE _pipe2_10_lp1:
1417 000276AE # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1418 000276AE 0d effffff588 5d movl _sgl_value_4,r13
1419 000276B5 # asm("movl $1,r1"); /* r1 index = 1 longwords */
1420 000276B5 0d 01 51 movl $1,r1
1421 000276B8 # asm("movl $2,r2"); /* r2 index = 2 longwords */
1422 000276B8 0d 02 52 movl $2,r2
1423 000276BB # asm("movl $3,r3"); /* r3 index = 3 longwords */
1424 000276BB 0d 03 53 movl $3,r3
1425 000276BE # asm("movl $4,r4"); /* r4 index = 4 longwords */
1426 000276BE 0d 04 54 movl $4,r4
1427 000276C1 # asm("lnf (r13)[r3]"); /* load -indexed by r3 */
1428 000276C1 16 436d lnf (r13)[r3]
1429 000276C4 # asm("mulf (r13)[r2]"); /* multiply by '1' (twice) */
1430 000276C4 e6 426d mulf (r13)[r2]
1431 000276C7 # asm("mulf (r13)[r2]");
1432 000276C7 e6 426d mulf (r13)[r2]
1433 000276CA # asm("addf (r13)[r1]"); /* add a '0' to it */
1434 000276CA c6 416d addf (r13)[r1]
1435 000276CD # asm("mulf (r13)[r2]"); /* multiply by '1' again */
1436 000276CD e6 426d mulf (r13)[r2]
1437 000276D0 # asm("stf (r13)[r4]"); /* store -indexed by r4 */
1438 000276D0 26 446d stf (r13)[r4]
1439 000276D3 # if( force_loop );
1440 000276D3 5d effffff563 tstl _force_loop
1441 000276D9 31 00 jeql L362
1442 000276DB # asm("brb _pipe2_10_lp1");; /* loop on the error */
1443 000276DB L362:
1444 000276DB 11 d1 brb _pipe2_10_lp1
1445 000276DD # /*
1446 000276DD # * verify the results
1447 000276DD # */
1448 000276DD # sgl_st_acc = pointer_data; /* move the stored result */
1449 000276DD 0d effffff559 effffff554 movl _pointer_data,_sgl_st_acc
1450 000276E8 # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1451 000276E8 ed 6d effffff54d moval (r13),_sgl_value_5
1452 000276EF # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1453 000276EF # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1454 000276EF 1d effffff547 effffff542 cmpl _sgl_st_acc,_sgl_expected
1455 000276FA 21 10 jneq L9998
1456 000276FC 1d effffff53a effffff535 cmpl _sgl_value_5,_sgl_value_4
1457 00027707 21 03 13 0091 jeql L363
1458 0002770C L9998:
1459 0002770C # {
1460 0002770C # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1461 0002770C 0d effffff52a 5d movl _pre_event_fp,r13
1462 00027713 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1463 00027713 0d effffff523 5e movl _pre_event_sp,r14
1464 0002771A # errcnt++; /* bump the error count */
1465 0002771A 6d effffff51c incl _errcnt
1466 00027720 # if ( prt_error )
1467 00027720 5d effffff516 tstl _prt_error
1468 00027726 31 0d jeql L364
1469 00027728 # print_pipe2_er("indexed FP addressing");
1470 00027728 .data 1
1471 00000dfd * L365:
1472 00000dfd * 696E646578656420465020616 .ascii "indexed FP addressing\0"
46472657373696E6700
1473 00000e13 * .text
1474 00027728 dd 8f00000dfd pushl $L365
1475 0002772E fe 08 ef00000093 callf $8,_print_pipe2_er
1476 00027735 # writes("final Frame Pointer = ");
1477 00027735 L364:
1478 00027735 .data 1
1479 00000e13 * L366:
1480 00000e13 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1481 00000e2a * .text
1482 00027735 dd 8f00000e13 pushl $L366
1483 0002773B fe 08 effffff4fa callf $8,_writes
1484 00027742 # writeh( sgl_value_5 );
1485 00027742 dd effffff4f4 pushl _sgl_value_5
1486 00027748 fe 08 effffff4ed callf $8,_writeh
1487 0002774F # writes(", expected FP = ");
1488 0002774F .data 1
1489 00000e2a * L368:
1490 00000e2a * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1491 00000e3c * .text
1492 0002774F dd 8f00000e2a pushl $L368
1493 00027755 fe 08 effffff4e0 callf $8,_writes
1494 0002775C # writeh( sgl_value_4 );
1495 0002775C dd effffff4da pushl _sgl_value_4
1496 00027762 fe 08 effffff4d3 callf $8,_writeh
1497 00027769 # writes(" \n");
1498 00027769 .data 1
1499 00000e3c * L369:
1500 00000e3c * 200A00 .ascii " \12\0"
1501 00000e3f * .text
1502 00027769 dd 8f00000e3c pushl $L369
1503 0002776F fe 08 effffff4c6 callf $8,_writes
1504 00027776 # if ( halt_flg ) /* halt on error? */
1505 00027776 5d effffff4c0 tstl _halt_flg
1506 0002777C 31 0d jeql L370
1507 0002777E # pipe2_er_hlt( subtest );
1508 0002777E dd effffff4b8 pushl _subtest
1509 00027784 fe 08 ef00000149 callf $8,_pipe2_er_hlt
1510 0002778B # if ( loop_on_err ) {
1511 0002778B L370:
1512 0002778B 5d effffff4ab tstl _loop_on_err
1513 00027791 31 0a jeql L371
1514 00027793 # force_loop = TRUE; /* set the force loop flag */
1515 00027793 0d 01 effffff4a2 movl $1,_force_loop
1516 0002779A # asm("brw _pipe2_10_lp1"); /* and loop */
1517 0002779A 13 ff11 brw _pipe2_10_lp1
1518 0002779D # }
1519 0002779D # } /* end of compare error */
1520 0002779D L371:
1521 0002779D # } while( index++ < max_lnf_1_index );
1522 0002779D L363:
1523 0002779D L360:
1524 0002779D 0d effffff499 50 movl _index,r0
1525 000277A4 6d effffff492 incl _index
1526 000277AA 1d 50 effffff48b cmpl r0,_max_lnf_1_index
1527 000277B1 81 03 13 fe73 jlss L361
1528 000277B6 L359:
1529 000277B6 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1530 000277B6 0d effffff480 5d movl _pre_event_fp,r13
1531 000277BD # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1532 000277BD 0d effffff479 5e movl _pre_event_sp,r14
1533 000277C4 # } /* end of subtest 10 */
1534 000277C4 40 ret#2
1535 000277C5 .set L355,0x0
1536 000277C5 L357:
1537 000277C5 13 fe47 jbr L358
1538 000277C8 .data
1539 00000d0c * .text
1540 000277C8 .align 1
1541 000277C8 .globl _print_pipe2_er
1542 000277C8 _print_pipe2_er:
1543 000277C8 0000 .word L372
1544 000277CA #
1545 000277CA #
1546 000277CA # /******************************************************************************
1547 000277CA # *
1548 000277CA # *
1549 000277CA # * print an error in the following form
1550 000277CA # *
1551 000277CA # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd
1552 000277CA # * expected Acc = xxxxxxxx
1553 000277CA # *
1554 000277CA # ******************************************************************************/
1555 000277CA # print_pipe2_er(msg)
1556 000277CA # char *msg;
1557 000277CA # {
1558 000277CA 13 0103 jbr L374
1559 000277CD L375:
1560 000277CD # writes(" \n"); /* start a new print line */
1561 000277CD .data 1
1562 00000e3f * L376:
1563 00000e3f * 200A00 .ascii " \12\0"
1564 00000e42 * .text
1565 000277CD dd 8f00000e3f pushl $L376
1566 000277D3 fe 08 effffff462 callf $8,_writes
1567 000277DA # writes("cycle: ");
1568 000277DA .data 1
1569 00000e42 * L377:
1570 00000e42 * 6379636C653A2000 .ascii "cycle: \0"
1571 00000e4a * .text
1572 000277DA dd 8f00000e42 pushl $L377
1573 000277E0 fe 08 effffff455 callf $8,_writes
1574 000277E7 # writed( cycle );
1575 000277E7 dd effffff44f pushl _cycle
1576 000277ED fe 08 effffff448 callf $8,_writed
1577 000277F4 # writes(" test ");
1578 000277F4 .data 1
1579 00000e4a * L379:
1580 00000e4a * 20746573742000 .ascii " test \0"
1581 00000e51 * .text
1582 000277F4 dd 8f00000e4a pushl $L379
1583 000277FA fe 08 effffff43b callf $8,_writes
1584 00027801 # writed( test_no );
1585 00027801 dd effffff435 pushl _test_no
1586 00027807 fe 08 effffff42e callf $8,_writed
1587 0002780E # writes(" (Pipe 2), subtest ");
1588 0002780E .data 1
1589 00000e51 * L380:
1590 00000e51 * 202028506970652032292C207 .ascii " (Pipe 2), subtest \0"
37562746573742000
1591 00000e66 * .text
1592 0002780E dd 8f00000e51 pushl $L380
1593 00027814 fe 08 effffff421 callf $8,_writes
1594 0002781B # writed( subtest );
1595 0002781B dd effffff41b pushl _subtest
1596 00027821 fe 08 effffff414 callf $8,_writed
1597 00027828 # writes(" error - ");
1598 00027828 .data 1
1599 00000e66 * L381:
1600 00000e66 * 206572726F72202D2000 .ascii " error - \0"
1601 00000e70 * .text
1602 00027828 dd 8f00000e66 pushl $L381
1603 0002782E fe 08 effffff407 callf $8,_writes
1604 00027835 # writes( msg );
1605 00027835 dd ad04 pushl 4(fp)
1606 00027838 fe 08 effffff3fd callf $8,_writes
1607 0002783F # writec('\n');
1608 0002783F dd 0a pushl $10
1609 00027841 fe 08 effffff3f4 callf $8,_writec
1610 00027848 # writes(" LNF (op1), MULF(1.0), MULF(1.0), ADD(0.0), MULF(1.0), STF\n");
1611 00027848 .data 1
1612 00000e70 * L383:
1613 00000e70 * 204C4E4620286F7031292C204 .ascii " LNF (op1), MULF(1.0), MULF(1.0), ADD(0.0), MULF(1.0), STF\12\0"
D554C4628312E30292C204D55
4C4628312E30292C204144442
8302E30292C204D554C462831
2E30292C205354460A00
1614 00000eac * .text
1615 00027848 dd 8f00000e70 pushl $L383
1616 0002784E fe 08 effffff3e7 callf $8,_writes
1617 00027855 # writes("operand = ");
1618 00027855 .data 1
1619 00000eac * L384:
1620 00000eac * 6F706572616E64203D2000 .ascii "operand = \0"
1621 00000eb7 * .text
1622 00027855 dd 8f00000eac pushl $L384
1623 0002785B fe 08 effffff3da callf $8,_writes
1624 00027862 # write32h( sgl_value_1 );
1625 00027862 dd effffff3d4 pushl _sgl_value_1
1626 00027868 fe 08 effffff3cd callf $8,_write32h
1627 0002786F # writes(", final Acc = ");
1628 0002786F .data 1
1629 00000eb7 * L385:
1630 00000eb7 * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
3203D2000
1631 00000ec8 * .text
1632 0002786F dd 8f00000eb7 pushl $L385
1633 00027875 fe 08 effffff3c0 callf $8,_writes
1634 0002787C # write32h( sgl_st_acc );
1635 0002787C dd effffff3ba pushl _sgl_st_acc
1636 00027882 fe 08 effffff3b3 callf $8,_write32h
1637 00027889 # writes(", data index = ");
1638 00027889 .data 1
1639 00000ec8 * L386:
1640 00000ec8 * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
1641 00000eda * .text
1642 00027889 dd 8f00000ec8 pushl $L386
1643 0002788F fe 08 effffff3a6 callf $8,_writes
1644 00027896 # writed( index );
1645 00027896 dd effffff3a0 pushl _index
1646 0002789C fe 08 effffff399 callf $8,_writed
1647 000278A3 # writec('\n');
1648 000278A3 dd 0a pushl $10
1649 000278A5 fe 08 effffff390 callf $8,_writec
1650 000278AC # writes(" expected Acc = ");
1651 000278AC .data 1
1652 00000eda * L387:
1653 00000eda * 2020202020202020202020202 .ascii " expected Acc = \0"
0202020202020657870656374
656420416363203D2000
1654 00000efd * .text
1655 000278AC dd 8f00000eda pushl $L387
1656 000278B2 fe 08 effffff383 callf $8,_writes
1657 000278B9 # write32h( sgl_expected );
1658 000278B9 dd effffff37d pushl _sgl_expected
1659 000278BF fe 08 effffff376 callf $8,_write32h
1660 000278C6 # writec('\n');
1661 000278C6 dd 0a pushl $10
1662 000278C8 fe 08 effffff36d callf $8,_writec
1663 000278CF # }
1664 000278CF 40 ret#2
1665 000278D0 .set L372,0x0
1666 000278D0 L374:
1667 000278D0 13 fefa jbr L375
1668 000278D3 .data
1669 00000d0c * .text
1670 000278D3 00 .align 1
1671 000278D4 .globl _pipe2_er_hlt
1672 000278D4 _pipe2_er_hlt:
1673 000278D4 0000 .word L388
1674 000278D6 #
1675 000278D6 #
1676 000278D6 #
1677 000278D6 #
1678 000278D6 #
1679 000278D6 # /******************************************************************************
1680 000278D6 # *
1681 000278D6 # * HALT ON ERROR ROUTINE
1682 000278D6 # *
1683 000278D6 # * halt with the necessary information saved in the registers
1684 000278D6 # *
1685 000278D6 # ******************************************************************************/
1686 000278D6 # pipe2_er_hlt( subtest )
1687 000278D6 # int subtest;
1688 000278D6 # {
1689 000278D6 11 6e jbr L390
1690 000278D8 L391:
1691 000278D8 # asm("movl _test_no,r0"); /* r0 = test number */
1692 000278D8 0d effffff35e 50 movl _test_no,r0
1693 000278DF # asm("movl _subtest,r1"); /* r1 = subtest number */
1694 000278DF 0d effffff357 51 movl _subtest,r1
1695 000278E6 # asm("movl $1,r2"); /* r2 = error code */
1696 000278E6 0d 01 52 movl $1,r2
1697 000278E9 # asm("movl _cycle,r3"); /* r3 = cycle count */
1698 000278E9 0d effffff34d 53 movl _cycle,r3
1699 000278F0 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1700 000278F0 0d effffff346 54 movl _sgl_value_1,r4
1701 000278F7 # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */
1702 000278F7 0d effffff33f 55 movl _sgl_st_acc,r5
1703 000278FE # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */
1704 000278FE 0d effffff338 56 movl _sgl_expected,r6
1705 00027905 # asm("movl _index,r7"); /* r7 = data index */
1706 00027905 0d effffff331 57 movl _index,r7
1707 0002790C # asm("movl _sgl_value_2,r8"); /* r8 = floating one */
1708 0002790C 0d effffff32a 58 movl _sgl_value_2,r8
1709 00027913 # asm("movl _sgl_value_3,r9"); /* r9 = floating zero */
1710 00027913 0d effffff323 59 movl _sgl_value_3,r9
1711 0002791A # if( subtest == 9 ) {
1712 0002791A 1d ad04 09 cmpl 4(fp),$9
1713 0002791E 21 10 jneq L392
1714 00027920 # asm("movl _sgl_value_5,r10"); /* r10= final SP value */
1715 00027920 0d effffff316 5a movl _sgl_value_5,r10
1716 00027927 # asm("movl _sgl_value_4,r11"); /* r11= expected SP value */
1717 00027927 0d effffff30f 5b movl _sgl_value_4,r11
1718 0002792E # } else
1719 0002792E 11 14 jbr L393
1720 00027930 L392:
1721 00027930 # if( subtest == 10 ) {
1722 00027930 1d ad04 0a cmpl 4(fp),$10
1723 00027934 21 0e jneq L394
1724 00027936 # asm("movl _sgl_value_5,r10"); /* r10= final FP value */
1725 00027936 0d effffff300 5a movl _sgl_value_5,r10
1726 0002793D # asm("movl _sgl_value_4,r11"); /* r11= expected FP value */
1727 0002793D 0d effffff2f9 5b movl _sgl_value_4,r11
1728 00027944 # };
1729 00027944 L394:
1730 00027944 L393:
1731 00027944 # asm(".globl _pipe2_1_hlt");
1732 00027944 .globl _pipe2_1_hlt
1733 00027944 # asm("_pipe2_1_hlt:"); /* PC after the halt */
1734 00027944 _pipe2_1_hlt:
1735 00027944 # asm("halt"); /* HALT ... */
1736 00027944 00 halt
1737 00027945 # } /* end of halt on error */
1738 00027945 40 ret#2
1739 00027946 .set L388,0x0
1740 00027946 L390:
1741 00027946 11 90 jbr L391
1742 00000d0c * .data
1742 00000d0c * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.