![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe17.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 pipe17.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 00000d20 * .text
4 00000000 .align 1
5 00000000 .globl _pipe_17
6 00000000 _pipe_17:
7 00031D64 0000 .word L215
8 00031D66 # #include "fpp_defs.h"
9 00031D66 #
10 00031D66 #
11 00031D66 # /*****************************************************************************
12 00031D66 # *
13 00031D66 # * DBL PIPELINE TEST #17 MONITOR
14 00031D66 # *
15 00031D66 # * This test will do:
16 00031D66 # *
17 00031D66 # * CVLD(x) ADDD(0) MULD(1) STD
18 00031D66 # *
19 00031D66 # * where the x's are the CVLD data patterns.
20 00031D66 # *****************************************************************************/
21 00031D66 # pipe_17()
22 00031D66 # {
23 00031D66 13 009b jbr L217
24 00031D69 L218:
25 00031D69 # asm(".globl _pipeline_17_t");
26 00031D69 .globl _pipeline_17_t
27 00031D69 # asm("_pipeline_17_t:"); /* entry address */
28 00031D69 _pipeline_17_t:
29 00031D69 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
30 00031D69 1d effffffff5 01 cmpl _cycle,$1
31 00031D70 21 15 jneq L219
32 00031D72 5d efffffffec tstl _prt_hdrs
33 00031D78 31 0d jeql L219
34 00031D7A # {
35 00031D7A # writes(" PIPE_17");
36 00031D7A .data 1
37 00000d20 * L221:
38 00000d20 * 20504950455F313700 .ascii " PIPE_17\0"
39 00000d29 * .text
40 00031D7A dd 8f00000d20 pushl $L221
41 00031D80 fe 08 efffffffdd callf $8,_writes
42 00031D87 # }
43 00031D87 # subtest = 1;
44 00031D87 L219:
45 00031D87 0d 01 efffffffd6 movl $1,_subtest
46 00031D8E # pipe17_1(); /* data in REGs, no NOPs */
47 00031D8E fe 04 ef00000073 callf $4,_pipe17_1
48 00031D95 # subtest++; /* increment subtest num */
49 00031D95 6d efffffffc9 incl _subtest
50 00031D9B # pipe17_2(); /* data in REGs, 1 NOP */
51 00031D9B fe 04 ef0000018c callf $4,_pipe17_2
52 00031DA2 # subtest++; /* increment subtest num */
53 00031DA2 6d efffffffbc incl _subtest
54 00031DA8 # pipe17_3(); /* data in REGs, 2 NOPs */
55 00031DA8 fe 04 ef000002a7 callf $4,_pipe17_3
56 00031DAF # subtest++; /* increment subtest num */
57 00031DAF 6d efffffffaf incl _subtest
58 00031DB5 # pipe17_4(); /* data in REGs, 3 NOPs */
59 00031DB5 fe 04 ef000003c6 callf $4,_pipe17_4
60 00031DBC # subtest++; /* increment subtest num */
61 00031DBC 6d efffffffa2 incl _subtest
62 00031DC2 # pipe17_5(); /* data in CACHE, no NOPs */
63 00031DC2 fe 04 ef000004e7 callf $4,_pipe17_5
64 00031DC9 # subtest++; /* increment subtest num */
65 00031DC9 6d efffffff95 incl _subtest
66 00031DCF # pipe17_6(); /* data in CACHE, 1 NOP */
67 00031DCF fe 04 ef000005d4 callf $4,_pipe17_6
68 00031DD6 # subtest++; /* increment subtest num */
69 00031DD6 6d efffffff88 incl _subtest
70 00031DDC # pipe17_7(); /* data in CACHE, 2 NOPs */
71 00031DDC fe 04 ef000006c5 callf $4,_pipe17_7
72 00031DE3 # subtest++; /* increment subtest num */
73 00031DE3 6d efffffff7b incl _subtest
74 00031DE9 # pipe17_8(); /* data in CACHE, 3 NOPs */
75 00031DE9 fe 04 ef000007b8 callf $4,_pipe17_8
76 00031DF0 # subtest++; /* increment subtest num */
77 00031DF0 6d efffffff6e incl _subtest
78 00031DF6 # pipe17_9(); /* data via F.P. 0 NOPs */
79 00031DF6 fe 04 ef000008af callf $4,_pipe17_9
80 00031DFD # asm("jmp *return"); /* return to the test monitor */
81 00031DFD 71 ffffffff61 jmp *return
82 00031E03 # }
83 00031E03 40 ret#2
84 00031E04 .set L215,0x0
85 00031E04 L217:
86 00031E04 13 ff62 jbr L218
87 00031E07 .data
88 00000d20 * .text
89 00031E07 00 .align 1
90 00031E08 .globl _pipe17_1
91 00031E08 _pipe17_1:
92 00031E08 0000 .word L231
93 00031E0A #
94 00031E0A #
95 00031E0A #
96 00031E0A #
97 00031E0A #
98 00031E0A #
99 00031E0A #
100 00031E0A # /************************************************************************
101 00031E0A # *
102 00031E0A # * SUBTEST 1
103 00031E0A # * data in registers, no NO-OPs
104 00031E0A # *
105 00031E0A # ************************************************************************/
106 00031E0A # pipe17_1()
107 00031E0A # {
108 00031E0A 13 011d jbr L233
109 00031E0D L234:
110 00031E0D # force_loop = FALSE; /* clear the force_loop flg */
111 00031E0D 4d efffffff51 clrl _force_loop
112 00031E13 # index = 0;
113 00031E13 4d efffffff4b clrl _index
114 00031E19 # do
115 00031E19 L237:
116 00031E19 # {
117 00031E19 # sgl_value_1 = cvld_1_data[index].ld; /* get the integer operand */
118 00031E19 5c 0c efffffff44 50 mull3 $12,_index,r0
119 00031E21 0d e000000000 efffffff38 movl _cvld_1_data(r0),_sgl_value_1
120 00031E2C # sgl_value_7 = 0x40800000; /* get a '1.0' ( MSW ) */
121 00031E2C 0d 8f40800000 efffffff2d movl $1082130432,_sgl_value_7
122 00031E37 # sgl_value_8 = 0; /* get a 0 */
123 00031E37 4d efffffff27 clrl _sgl_value_8
124 00031E3D # dbl_expected = cvld_1_data[index].exp; /* get the expected results */
125 00031E3D 5c 0c efffffff20 50 mull3 $12,_index,r0
126 00031E45 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0
127 00031E4C 0d a004 efffffff14 movl 4(r0),_dbl_expected+4
128 00031E54 0d 60 efffffff09 movl (r0),_dbl_expected
129 00031E5B # /*
130 00031E5B # * If LOOP ON ERROR is set, this is the loop for this subtest.
131 00031E5B # * The force loop flag is set after the first error.
132 00031E5B # */
133 00031E5B # asm("_pipe17_1_lp1:");
134 00031E5B _pipe17_1_lp1:
135 00031E5B # asm("movl _sgl_value_1,r1"); /* move the data to r1 */
136 00031E5B 0d efffffff03 51 movl _sgl_value_1,r1
137 00031E62 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r2/r3 */
138 00031E62 0d effffffefc 52 movl _sgl_value_7,r2
139 00031E69 # asm("movl _sgl_value_8,r3");
140 00031E69 0d effffffef5 53 movl _sgl_value_8,r3
141 00031E70 # asm("movl _sgl_value_8,r4"); /* move a '0.0' to r4/r5 */
142 00031E70 0d effffffeee 54 movl _sgl_value_8,r4
143 00031E77 # asm("movl _sgl_value_8,r5");
144 00031E77 0d effffffee7 55 movl _sgl_value_8,r5
145 00031E7E # asm("cvld r1"); /* convert the int. ( op ) */
146 00031E7E 77 51 cvld r1
147 00031E80 # asm("addd r4"); /* add a '0.0' ( op ) */
148 00031E80 c7 54 addd r4
149 00031E82 # asm("muld r2"); /* multiply by 1.0 ( op ) */
150 00031E82 e7 52 muld r2
151 00031E84 # asm("std r6"); /* store the result ( op ) */
152 00031E84 27 56 std r6
153 00031E86 # if( force_loop )
154 00031E86 5d effffffed8 tstl _force_loop
155 00031E8C 31 02 jeql L238
156 00031E8E # asm("brb _pipe17_1_lp1");; /* run the loop again */
157 00031E8E 11 cb brb _pipe17_1_lp1
158 00031E90 L238:
159 00031E90 # /*
160 00031E90 # * verify the results
161 00031E90 # */
162 00031E90 # asm("movl r6,_sgl_value_3"); /* get the result */
163 00031E90 0d 56 effffffecd movl r6,_sgl_value_3
164 00031E97 # asm("movl r7,_sgl_value_4");
165 00031E97 0d 57 effffffec6 movl r7,_sgl_value_4
166 00031E9E # dbl_st_acc.m = sgl_value_3;
167 00031E9E 0d effffffec0 effffffebb movl _sgl_value_3,_dbl_st_acc
168 00031EA9 # dbl_st_acc.l = sgl_value_4;
169 00031EA9 0d effffffeb5 effffffeb4 movl _sgl_value_4,_dbl_st_acc+4
170 00031EB4 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
171 00031EB4 # (dbl_st_acc.l != dbl_expected.l) )
172 00031EB4 1d effffffeaa effffffea5 cmpl _dbl_st_acc,_dbl_expected
173 00031EBF 21 0d jneq L9999
174 00031EC1 1d effffffea1 effffffe9c cmpl _dbl_st_acc+4,_dbl_expected+4
175 00031ECC 31 42 jeql L239
176 00031ECE L9999:
177 00031ECE # {
178 00031ECE # errcnt++; /* bump the error count */
179 00031ECE 6d effffffe90 incl _errcnt
180 00031ED4 # if ( prt_error )
181 00031ED4 5d effffffe8a tstl _prt_error
182 00031EDA 31 0d jeql L240
183 00031EDC # print_pipe17_er("Reg. Data, no NOPs");
184 00031EDC .data 1
185 00000d29 * L242:
186 00000d29 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NOPs\0"
F204E4F507300
187 00000d3c * .text
188 00031EDC dd 8f00000d29 pushl $L242
189 00031EE2 fe 08 ef000009cf callf $8,_print_pipe17_er
190 00031EE9 # if ( halt_flg ) /* halt on error? */
191 00031EE9 L240:
192 00031EE9 5d effffffe75 tstl _halt_flg
193 00031EEF 31 0d jeql L243
194 00031EF1 # pipe17_er_hlt( subtest );
195 00031EF1 dd effffffe6d pushl _subtest
196 00031EF7 fe 08 ef00000b08 callf $8,_pipe17_er_hlt
197 00031EFE # if ( loop_on_err ) {
198 00031EFE L243:
199 00031EFE 5d effffffe60 tstl _loop_on_err
200 00031F04 31 0a jeql L245
201 00031F06 # force_loop = TRUE; /* set the force loop flag */
202 00031F06 0d 01 effffffe57 movl $1,_force_loop
203 00031F0D # asm("brw _pipe17_1_lp1"); /* and loop */
204 00031F0D 13 ff4b brw _pipe17_1_lp1
205 00031F10 # }
206 00031F10 # } /* end of compare error */
207 00031F10 L245:
208 00031F10 # } while( index++ < max_cvld_1_index );
209 00031F10 L239:
210 00031F10 L236:
211 00031F10 0d effffffe4e 50 movl _index,r0
212 00031F17 6d effffffe47 incl _index
213 00031F1D 1d 50 effffffe40 cmpl r0,_max_cvld_1_index
214 00031F24 81 03 13 fef0 jlss L237
215 00031F29 L235:
216 00031F29 # } /* end of subtest 1 */
217 00031F29 40 ret#2
218 00031F2A .set L231,0x0
219 00031F2A L233:
220 00031F2A 13 fee0 jbr L234
221 00031F2D .data
222 00000d20 * .text
223 00031F2D 00 .align 1
224 00031F2E .globl _pipe17_2
225 00031F2E _pipe17_2:
226 00031F2E 0000 .word L246
227 00031F30 #
228 00031F30 #
229 00031F30 #
230 00031F30 #
231 00031F30 #
232 00031F30 #
233 00031F30 #
234 00031F30 # /************************************************************************
235 00031F30 # *
236 00031F30 # * SUBTEST 2
237 00031F30 # * data in registers, 1 NO-OP
238 00031F30 # *
239 00031F30 # ************************************************************************/
240 00031F30 # pipe17_2()
241 00031F30 # {
242 00031F30 13 0120 jbr L248
243 00031F33 L249:
244 00031F33 # force_loop = FALSE; /* clear the force_loop flg */
245 00031F33 4d effffffe2b clrl _force_loop
246 00031F39 # index = 0;
247 00031F39 4d effffffe25 clrl _index
248 00031F3F # do
249 00031F3F L252:
250 00031F3F # {
251 00031F3F # sgl_value_1 = cvld_1_data[index].ld; /* get the integer operand */
252 00031F3F 5c 0c effffffe1e 50 mull3 $12,_index,r0
253 00031F47 0d e000000000 effffffe12 movl _cvld_1_data(r0),_sgl_value_1
254 00031F52 # sgl_value_7 = 0x40800000; /* get a '1.0' ( MSW ) */
255 00031F52 0d 8f40800000 effffffe07 movl $1082130432,_sgl_value_7
256 00031F5D # sgl_value_8 = 0; /* get a 0 */
257 00031F5D 4d effffffe01 clrl _sgl_value_8
258 00031F63 # dbl_expected = cvld_1_data[index].exp; /* get the expected results */
259 00031F63 5c 0c effffffdfa 50 mull3 $12,_index,r0
260 00031F6B 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0
261 00031F72 0d a004 effffffdee movl 4(r0),_dbl_expected+4
262 00031F7A 0d 60 effffffde3 movl (r0),_dbl_expected
263 00031F81 # /*
264 00031F81 # * If LOOP ON ERROR is set, this is the loop for this subtest.
265 00031F81 # * The force loop flag is set after the first error.
266 00031F81 # */
267 00031F81 # asm("_pipe17_2_lp1:");
268 00031F81 _pipe17_2_lp1:
269 00031F81 # asm("movl _sgl_value_1,r1"); /* move the data to r1 */
270 00031F81 0d effffffddd 51 movl _sgl_value_1,r1
271 00031F88 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r2/r3 */
272 00031F88 0d effffffdd6 52 movl _sgl_value_7,r2
273 00031F8F # asm("movl _sgl_value_8,r3");
274 00031F8F 0d effffffdcf 53 movl _sgl_value_8,r3
275 00031F96 # asm("movl _sgl_value_8,r4"); /* move a '0.0' to r4/r5 */
276 00031F96 0d effffffdc8 54 movl _sgl_value_8,r4
277 00031F9D # asm("movl _sgl_value_8,r5");
278 00031F9D 0d effffffdc1 55 movl _sgl_value_8,r5
279 00031FA4 # asm("cvld r1"); /* convert the int. ( op ) */
280 00031FA4 77 51 cvld r1
281 00031FA6 # asm("nop");
282 00031FA6 10 nop
283 00031FA7 # asm("addd r4"); /* add a '0.0' ( op ) */
284 00031FA7 c7 54 addd r4
285 00031FA9 # asm("nop");
286 00031FA9 10 nop
287 00031FAA # asm("muld r2"); /* multiply by 1.0 ( op ) */
288 00031FAA e7 52 muld r2
289 00031FAC # asm("nop");
290 00031FAC 10 nop
291 00031FAD # asm("std r6"); /* store the result ( op ) */
292 00031FAD 27 56 std r6
293 00031FAF # if( force_loop )
294 00031FAF 5d effffffdaf tstl _force_loop
295 00031FB5 31 02 jeql L253
296 00031FB7 # asm("brb _pipe17_2_lp1");; /* run the loop again */
297 00031FB7 11 c8 brb _pipe17_2_lp1
298 00031FB9 L253:
299 00031FB9 # /*
300 00031FB9 # * verify the results
301 00031FB9 # */
302 00031FB9 # asm("movl r6,_sgl_value_3"); /* get the result */
303 00031FB9 0d 56 effffffda4 movl r6,_sgl_value_3
304 00031FC0 # asm("movl r7,_sgl_value_4");
305 00031FC0 0d 57 effffffd9d movl r7,_sgl_value_4
306 00031FC7 # dbl_st_acc.m = sgl_value_3;
307 00031FC7 0d effffffd97 effffffd92 movl _sgl_value_3,_dbl_st_acc
308 00031FD2 # dbl_st_acc.l = sgl_value_4;
309 00031FD2 0d effffffd8c effffffd8b movl _sgl_value_4,_dbl_st_acc+4
310 00031FDD # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
311 00031FDD # (dbl_st_acc.l != dbl_expected.l) )
312 00031FDD 1d effffffd81 effffffd7c cmpl _dbl_st_acc,_dbl_expected
313 00031FE8 21 0d jneq L9998
314 00031FEA 1d effffffd78 effffffd73 cmpl _dbl_st_acc+4,_dbl_expected+4
315 00031FF5 31 42 jeql L254
316 00031FF7 L9998:
317 00031FF7 # {
318 00031FF7 # errcnt++; /* bump the error count */
319 00031FF7 6d effffffd67 incl _errcnt
320 00031FFD # if ( prt_error )
321 00031FFD 5d effffffd61 tstl _prt_error
322 00032003 31 0d jeql L255
323 00032005 # print_pipe17_er("Reg. Data, 1 NOP");
324 00032005 .data 1
325 00000d3c * L256:
326 00000d3c * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NOP\0"
04E4F5000
327 00000d4d * .text
328 00032005 dd 8f00000d3c pushl $L256
329 0003200B fe 08 ef000008a6 callf $8,_print_pipe17_er
330 00032012 # if ( halt_flg ) /* halt on error? */
331 00032012 L255:
332 00032012 5d effffffd4c tstl _halt_flg
333 00032018 31 0d jeql L257
334 0003201A # pipe17_er_hlt( subtest );
335 0003201A dd effffffd44 pushl _subtest
336 00032020 fe 08 ef000009df callf $8,_pipe17_er_hlt
337 00032027 # if ( loop_on_err ) {
338 00032027 L257:
339 00032027 5d effffffd37 tstl _loop_on_err
340 0003202D 31 0a jeql L258
341 0003202F # force_loop = TRUE; /* set the force loop flag */
342 0003202F 0d 01 effffffd2e movl $1,_force_loop
343 00032036 # asm("brw _pipe17_2_lp1"); /* and loop */
344 00032036 13 ff48 brw _pipe17_2_lp1
345 00032039 # }
346 00032039 # } /* end of compare error */
347 00032039 L258:
348 00032039 # } while( index++ < max_cvld_1_index );
349 00032039 L254:
350 00032039 L251:
351 00032039 0d effffffd25 50 movl _index,r0
352 00032040 6d effffffd1e incl _index
353 00032046 1d 50 effffffd17 cmpl r0,_max_cvld_1_index
354 0003204D 81 03 13 feed jlss L252
355 00032052 L250:
356 00032052 # } /* end of subtest 2 */
357 00032052 40 ret#2
358 00032053 .set L246,0x0
359 00032053 L248:
360 00032053 13 fedd jbr L249
361 00032056 .data
362 00000d20 * .text
363 00032056 .align 1
364 00032056 .globl _pipe17_3
365 00032056 _pipe17_3:
366 00032056 0000 .word L259
367 00032058 #
368 00032058 #
369 00032058 #
370 00032058 #
371 00032058 #
372 00032058 #
373 00032058 #
374 00032058 # /************************************************************************
375 00032058 # *
376 00032058 # * SUBTEST 3
377 00032058 # * data in registers, 2 NO-OPs
378 00032058 # *
379 00032058 # ************************************************************************/
380 00032058 # pipe17_3()
381 00032058 # {
382 00032058 13 0123 jbr L261
383 0003205B L262:
384 0003205B # force_loop = FALSE; /* clear the force_loop flg */
385 0003205B 4d effffffd03 clrl _force_loop
386 00032061 # index = 0;
387 00032061 4d effffffcfd clrl _index
388 00032067 # do
389 00032067 L265:
390 00032067 # {
391 00032067 # sgl_value_1 = cvld_1_data[index].ld; /* get the integer operand */
392 00032067 5c 0c effffffcf6 50 mull3 $12,_index,r0
393 0003206F 0d e000000000 effffffcea movl _cvld_1_data(r0),_sgl_value_1
394 0003207A # sgl_value_7 = 0x40800000; /* get a '1.0' ( MSW ) */
395 0003207A 0d 8f40800000 effffffcdf movl $1082130432,_sgl_value_7
396 00032085 # sgl_value_8 = 0; /* get a 0 */
397 00032085 4d effffffcd9 clrl _sgl_value_8
398 0003208B # dbl_expected = cvld_1_data[index].exp; /* get the expected results */
399 0003208B 5c 0c effffffcd2 50 mull3 $12,_index,r0
400 00032093 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0
401 0003209A 0d a004 effffffcc6 movl 4(r0),_dbl_expected+4
402 000320A2 0d 60 effffffcbb movl (r0),_dbl_expected
403 000320A9 # /*
404 000320A9 # * If LOOP ON ERROR is set, this is the loop for this subtest.
405 000320A9 # * The force loop flag is set after the first error.
406 000320A9 # */
407 000320A9 # asm("_pipe17_3_lp1:");
408 000320A9 _pipe17_3_lp1:
409 000320A9 # asm("movl _sgl_value_1,r1"); /* move the data to r1 */
410 000320A9 0d effffffcb5 51 movl _sgl_value_1,r1
411 000320B0 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r2/r3 */
412 000320B0 0d effffffcae 52 movl _sgl_value_7,r2
413 000320B7 # asm("movl _sgl_value_8,r3");
414 000320B7 0d effffffca7 53 movl _sgl_value_8,r3
415 000320BE # asm("movl _sgl_value_8,r4"); /* move a '0.0' to r4/r5 */
416 000320BE 0d effffffca0 54 movl _sgl_value_8,r4
417 000320C5 # asm("movl _sgl_value_8,r5");
418 000320C5 0d effffffc99 55 movl _sgl_value_8,r5
419 000320CC # asm("cvld r1"); /* convert the int. ( op ) */
420 000320CC 77 51 cvld r1
421 000320CE # asm("nop");
422 000320CE 10 nop
423 000320CF # asm("nop");
424 000320CF 10 nop
425 000320D0 # asm("addd r4"); /* add a '0.0' ( op ) */
426 000320D0 c7 54 addd r4
427 000320D2 # asm("nop");
428 000320D2 10 nop
429 000320D3 # asm("nop");
430 000320D3 10 nop
431 000320D4 # asm("muld r2"); /* multiply by 1.0 ( op ) */
432 000320D4 e7 52 muld r2
433 000320D6 # asm("nop");
434 000320D6 10 nop
435 000320D7 # asm("nop");
436 000320D7 10 nop
437 000320D8 # asm("std r6"); /* store the result ( op ) */
438 000320D8 27 56 std r6
439 000320DA # if( force_loop )
440 000320DA 5d effffffc84 tstl _force_loop
441 000320E0 31 02 jeql L266
442 000320E2 # asm("brb _pipe17_3_lp1");; /* run the loop again */
443 000320E2 11 c5 brb _pipe17_3_lp1
444 000320E4 L266:
445 000320E4 # /*
446 000320E4 # * verify the results
447 000320E4 # */
448 000320E4 # asm("movl r6,_sgl_value_3"); /* get the result */
449 000320E4 0d 56 effffffc79 movl r6,_sgl_value_3
450 000320EB # asm("movl r7,_sgl_value_4");
451 000320EB 0d 57 effffffc72 movl r7,_sgl_value_4
452 000320F2 # dbl_st_acc.m = sgl_value_3;
453 000320F2 0d effffffc6c effffffc67 movl _sgl_value_3,_dbl_st_acc
454 000320FD # dbl_st_acc.l = sgl_value_4;
455 000320FD 0d effffffc61 effffffc60 movl _sgl_value_4,_dbl_st_acc+4
456 00032108 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
457 00032108 # (dbl_st_acc.l != dbl_expected.l) )
458 00032108 1d effffffc56 effffffc51 cmpl _dbl_st_acc,_dbl_expected
459 00032113 21 0d jneq L9997
460 00032115 1d effffffc4d effffffc48 cmpl _dbl_st_acc+4,_dbl_expected+4
461 00032120 31 42 jeql L267
462 00032122 L9997:
463 00032122 # {
464 00032122 # errcnt++; /* bump the error count */
465 00032122 6d effffffc3c incl _errcnt
466 00032128 # if ( prt_error )
467 00032128 5d effffffc36 tstl _prt_error
468 0003212E 31 0d jeql L268
469 00032130 # print_pipe17_er("Reg. Data, 2 NOPs");
470 00032130 .data 1
471 00000d4d * L269:
472 00000d4d * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NOPs\0"
04E4F507300
473 00000d5f * .text
474 00032130 dd 8f00000d4d pushl $L269
475 00032136 fe 08 ef0000077b callf $8,_print_pipe17_er
476 0003213D # if ( halt_flg ) /* halt on error? */
477 0003213D L268:
478 0003213D 5d effffffc21 tstl _halt_flg
479 00032143 31 0d jeql L270
480 00032145 # pipe17_er_hlt( subtest );
481 00032145 dd effffffc19 pushl _subtest
482 0003214B fe 08 ef000008b4 callf $8,_pipe17_er_hlt
483 00032152 # if ( loop_on_err ) {
484 00032152 L270:
485 00032152 5d effffffc0c tstl _loop_on_err
486 00032158 31 0a jeql L271
487 0003215A # force_loop = TRUE; /* set the force loop flag */
488 0003215A 0d 01 effffffc03 movl $1,_force_loop
489 00032161 # asm("brw _pipe17_3_lp1"); /* and loop */
490 00032161 13 ff45 brw _pipe17_3_lp1
491 00032164 # }
492 00032164 # } /* end of compare error */
493 00032164 L271:
494 00032164 # } while( index++ < max_cvld_1_index );
495 00032164 L267:
496 00032164 L264:
497 00032164 0d effffffbfa 50 movl _index,r0
498 0003216B 6d effffffbf3 incl _index
499 00032171 1d 50 effffffbec cmpl r0,_max_cvld_1_index
500 00032178 81 03 13 feea jlss L265
501 0003217D L263:
502 0003217D # } /* end of subtest 3 */
503 0003217D 40 ret#2
504 0003217E .set L259,0x0
505 0003217E L261:
506 0003217E 13 feda jbr L262
507 00032181 .data
508 00000d20 * .text
509 00032181 00 .align 1
510 00032182 .globl _pipe17_4
511 00032182 _pipe17_4:
512 00032182 0000 .word L272
513 00032184 #
514 00032184 #
515 00032184 #
516 00032184 #
517 00032184 #
518 00032184 #
519 00032184 #
520 00032184 # /************************************************************************
521 00032184 # *
522 00032184 # * SUBTEST 4
523 00032184 # * data in registers, 3 NO-OPs
524 00032184 # *
525 00032184 # ************************************************************************/
526 00032184 # pipe17_4()
527 00032184 # {
528 00032184 13 0126 jbr L274
529 00032187 L275:
530 00032187 # force_loop = FALSE; /* clear the force_loop flg */
531 00032187 4d effffffbd7 clrl _force_loop
532 0003218D # index = 0;
533 0003218D 4d effffffbd1 clrl _index
534 00032193 # do
535 00032193 L278:
536 00032193 # {
537 00032193 # sgl_value_1 = cvld_1_data[index].ld; /* get the integer operand */
538 00032193 5c 0c effffffbca 50 mull3 $12,_index,r0
539 0003219B 0d e000000000 effffffbbe movl _cvld_1_data(r0),_sgl_value_1
540 000321A6 # sgl_value_7 = 0x40800000; /* get a '1.0' ( MSW ) */
541 000321A6 0d 8f40800000 effffffbb3 movl $1082130432,_sgl_value_7
542 000321B1 # sgl_value_8 = 0; /* get a 0 */
543 000321B1 4d effffffbad clrl _sgl_value_8
544 000321B7 # dbl_expected = cvld_1_data[index].exp; /* get the expected results */
545 000321B7 5c 0c effffffba6 50 mull3 $12,_index,r0
546 000321BF 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0
547 000321C6 0d a004 effffffb9a movl 4(r0),_dbl_expected+4
548 000321CE 0d 60 effffffb8f movl (r0),_dbl_expected
549 000321D5 # /*
550 000321D5 # * If LOOP ON ERROR is set, this is the loop for this subtest.
551 000321D5 # * The force loop flag is set after the first error.
552 000321D5 # */
553 000321D5 # asm("_pipe17_4_lp1:");
554 000321D5 _pipe17_4_lp1:
555 000321D5 # asm("movl _sgl_value_1,r1"); /* move the data to r1 */
556 000321D5 0d effffffb89 51 movl _sgl_value_1,r1
557 000321DC # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r2/r3 */
558 000321DC 0d effffffb82 52 movl _sgl_value_7,r2
559 000321E3 # asm("movl _sgl_value_8,r3");
560 000321E3 0d effffffb7b 53 movl _sgl_value_8,r3
561 000321EA # asm("movl _sgl_value_8,r4"); /* move a '0.0' to r4/r5 */
562 000321EA 0d effffffb74 54 movl _sgl_value_8,r4
563 000321F1 # asm("movl _sgl_value_8,r5");
564 000321F1 0d effffffb6d 55 movl _sgl_value_8,r5
565 000321F8 # asm("cvld r1"); /* convert the int. ( op ) */
566 000321F8 77 51 cvld r1
567 000321FA # asm("nop");
568 000321FA 10 nop
569 000321FB # asm("nop");
570 000321FB 10 nop
571 000321FC # asm("nop");
572 000321FC 10 nop
573 000321FD # asm("addd r4"); /* add a '0.0' ( op ) */
574 000321FD c7 54 addd r4
575 000321FF # asm("nop");
576 000321FF 10 nop
577 00032200 # asm("nop");
578 00032200 10 nop
579 00032201 # asm("nop");
580 00032201 10 nop
581 00032202 # asm("muld r2"); /* multiply by 1.0 ( op ) */
582 00032202 e7 52 muld r2
583 00032204 # asm("nop");
584 00032204 10 nop
585 00032205 # asm("nop");
586 00032205 10 nop
587 00032206 # asm("nop");
588 00032206 10 nop
589 00032207 # asm("std r6"); /* store the result ( op ) */
590 00032207 27 56 std r6
591 00032209 # if( force_loop )
592 00032209 5d effffffb55 tstl _force_loop
593 0003220F 31 02 jeql L279
594 00032211 # asm("brb _pipe17_4_lp1");; /* run the loop again */
595 00032211 11 c2 brb _pipe17_4_lp1
596 00032213 L279:
597 00032213 # /*
598 00032213 # * verify the results
599 00032213 # */
600 00032213 # asm("movl r6,_sgl_value_3"); /* get the result */
601 00032213 0d 56 effffffb4a movl r6,_sgl_value_3
602 0003221A # asm("movl r7,_sgl_value_4");
603 0003221A 0d 57 effffffb43 movl r7,_sgl_value_4
604 00032221 # dbl_st_acc.m = sgl_value_3;
605 00032221 0d effffffb3d effffffb38 movl _sgl_value_3,_dbl_st_acc
606 0003222C # dbl_st_acc.l = sgl_value_4;
607 0003222C 0d effffffb32 effffffb31 movl _sgl_value_4,_dbl_st_acc+4
608 00032237 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
609 00032237 # (dbl_st_acc.l != dbl_expected.l) )
610 00032237 1d effffffb27 effffffb22 cmpl _dbl_st_acc,_dbl_expected
611 00032242 21 0d jneq L9996
612 00032244 1d effffffb1e effffffb19 cmpl _dbl_st_acc+4,_dbl_expected+4
613 0003224F 31 42 jeql L280
614 00032251 L9996:
615 00032251 # {
616 00032251 # errcnt++; /* bump the error count */
617 00032251 6d effffffb0d incl _errcnt
618 00032257 # if ( prt_error )
619 00032257 5d effffffb07 tstl _prt_error
620 0003225D 31 0d jeql L281
621 0003225F # print_pipe17_er("Reg. Data, 3 NOPs");
622 0003225F .data 1
623 00000d5f * L282:
624 00000d5f * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NOPs\0"
04E4F507300
625 00000d71 * .text
626 0003225F dd 8f00000d5f pushl $L282
627 00032265 fe 08 ef0000064c callf $8,_print_pipe17_er
628 0003226C # if ( halt_flg ) /* halt on error? */
629 0003226C L281:
630 0003226C 5d effffffaf2 tstl _halt_flg
631 00032272 31 0d jeql L283
632 00032274 # pipe17_er_hlt( subtest );
633 00032274 dd effffffaea pushl _subtest
634 0003227A fe 08 ef00000785 callf $8,_pipe17_er_hlt
635 00032281 # if ( loop_on_err ) {
636 00032281 L283:
637 00032281 5d effffffadd tstl _loop_on_err
638 00032287 31 0a jeql L284
639 00032289 # force_loop = TRUE; /* set the force loop flag */
640 00032289 0d 01 effffffad4 movl $1,_force_loop
641 00032290 # asm("brw _pipe17_4_lp1"); /* and loop */
642 00032290 13 ff42 brw _pipe17_4_lp1
643 00032293 # }
644 00032293 # } /* end of compare error */
645 00032293 L284:
646 00032293 # } while( index++ < max_cvld_1_index );
647 00032293 L280:
648 00032293 L277:
649 00032293 0d effffffacb 50 movl _index,r0
650 0003229A 6d effffffac4 incl _index
651 000322A0 1d 50 effffffabd cmpl r0,_max_cvld_1_index
652 000322A7 81 03 13 fee7 jlss L278
653 000322AC L276:
654 000322AC # } /* end of subtest 4 */
655 000322AC 40 ret#2
656 000322AD .set L272,0x0
657 000322AD L274:
658 000322AD 13 fed7 jbr L275
659 000322B0 .data
660 00000d20 * .text
661 000322B0 .align 1
662 000322B0 .globl _pipe17_5
663 000322B0 _pipe17_5:
664 000322B0 0000 .word L285
665 000322B2 #
666 000322B2 #
667 000322B2 #
668 000322B2 #
669 000322B2 #
670 000322B2 #
671 000322B2 #
672 000322B2 # /************************************************************************
673 000322B2 # *
674 000322B2 # * SUBTEST 5
675 000322B2 # * data in cache, no NO-OPs
676 000322B2 # *
677 000322B2 # ************************************************************************/
678 000322B2 # pipe17_5()
679 000322B2 # {
680 000322B2 13 00f2 jbr L287
681 000322B5 L288:
682 000322B5 # force_loop = FALSE; /* clear the force_loop flg */
683 000322B5 4d effffffaa9 clrl _force_loop
684 000322BB # index = 0;
685 000322BB 4d effffffaa3 clrl _index
686 000322C1 # do
687 000322C1 L291:
688 000322C1 # {
689 000322C1 # sgl_value_1 = cvld_1_data[index].ld; /* get the operand */
690 000322C1 5c 0c effffffa9c 50 mull3 $12,_index,r0
691 000322C9 0d e000000000 effffffa90 movl _cvld_1_data(r0),_sgl_value_1
692 000322D4 # dbl_value_1.m = 0x40800000; /* set the '1.0' operand */
693 000322D4 0d 8f40800000 effffffa85 movl $1082130432,_dbl_value_1
694 000322DF # dbl_value_1.l = 0;
695 000322DF 4d effffffa83 clrl _dbl_value_1+4
696 000322E5 # dbl_value_2.m = 0; /* set the '0.0' operand */
697 000322E5 4d effffffa79 clrl _dbl_value_2
698 000322EB # dbl_value_2.l = 0;
699 000322EB 4d effffffa77 clrl _dbl_value_2+4
700 000322F1 # dbl_expected = cvld_1_data[index].exp; /* get the expected results */
701 000322F1 5c 0c effffffa6c 50 mull3 $12,_index,r0
702 000322F9 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0
703 00032300 0d a004 effffffa60 movl 4(r0),_dbl_expected+4
704 00032308 0d 60 effffffa55 movl (r0),_dbl_expected
705 0003230F # /*
706 0003230F # * If LOOP ON ERROR is set, this is the loop for this subtest.
707 0003230F # * The force loop flag is set after the first error.
708 0003230F # */
709 0003230F # asm("_pipe17_5_lp1:");
710 0003230F _pipe17_5_lp1:
711 0003230F # asm("cvld _sgl_value_1"); /* convert the int. ( op ) */
712 0003230F 77 effffffa4f cvld _sgl_value_1
713 00032315 # asm("addd _dbl_value_2"); /* add a '0.0' ( 0 ) */
714 00032315 c7 effffffa49 addd _dbl_value_2
715 0003231B # asm("muld _dbl_value_1"); /* multiply by 1.0 ( 0 ) */
716 0003231B e7 effffffa43 muld _dbl_value_1
717 00032321 # asm("std _dbl_st_acc"); /* store the result (-op ) */
718 00032321 27 effffffa3d std _dbl_st_acc
719 00032327 # if( force_loop )
720 00032327 5d effffffa37 tstl _force_loop
721 0003232D 31 02 jeql L292
722 0003232F # asm("brb _pipe17_5_lp1");; /* run the loop again */
723 0003232F 11 de brb _pipe17_5_lp1
724 00032331 L292:
725 00032331 # /*
726 00032331 # * verify the results
727 00032331 # */
728 00032331 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
729 00032331 # (dbl_st_acc.l != dbl_expected.l) )
730 00032331 1d effffffa2d effffffa28 cmpl _dbl_st_acc,_dbl_expected
731 0003233C 21 0d jneq L9995
732 0003233E 1d effffffa24 effffffa1f cmpl _dbl_st_acc+4,_dbl_expected+4
733 00032349 31 42 jeql L293
734 0003234B L9995:
735 0003234B # {
736 0003234B # errcnt++; /* bump the error count */
737 0003234B 6d effffffa13 incl _errcnt
738 00032351 # if ( prt_error )
739 00032351 5d effffffa0d tstl _prt_error
740 00032357 31 0d jeql L294
741 00032359 # print_pipe17_er("Cache Data, no NOPs");
742 00032359 .data 1
743 00000d71 * L295:
744 00000d71 * 436163686520446174612C206 .ascii "Cache Data, no NOPs\0"
E6F204E4F507300
745 00000d85 * .text
746 00032359 dd 8f00000d71 pushl $L295
747 0003235F fe 08 ef00000552 callf $8,_print_pipe17_er
748 00032366 # if ( halt_flg ) /* halt on error? */
749 00032366 L294:
750 00032366 5d effffff9f8 tstl _halt_flg
751 0003236C 31 0d jeql L296
752 0003236E # pipe17_er_hlt( subtest );
753 0003236E dd effffff9f0 pushl _subtest
754 00032374 fe 08 ef0000068b callf $8,_pipe17_er_hlt
755 0003237B # if ( loop_on_err ) {
756 0003237B L296:
757 0003237B 5d effffff9e3 tstl _loop_on_err
758 00032381 31 0a jeql L297
759 00032383 # force_loop = TRUE; /* set the force loop flag */
760 00032383 0d 01 effffff9da movl $1,_force_loop
761 0003238A # asm("brw _pipe17_5_lp1"); /* and loop */
762 0003238A 13 ff82 brw _pipe17_5_lp1
763 0003238D # }
764 0003238D # } /* end of compare error */
765 0003238D L297:
766 0003238D # } while( index++ < max_cvld_1_index );
767 0003238D L293:
768 0003238D L290:
769 0003238D 0d effffff9d1 50 movl _index,r0
770 00032394 6d effffff9ca incl _index
771 0003239A 1d 50 effffff9c3 cmpl r0,_max_cvld_1_index
772 000323A1 81 03 13 ff1b jlss L291
773 000323A6 L289:
774 000323A6 # } /* end of subtest 5 */
775 000323A6 40 ret#2
776 000323A7 .set L285,0x0
777 000323A7 L287:
778 000323A7 13 ff0b jbr L288
779 000323AA .data
780 00000d20 * .text
781 000323AA .align 1
782 000323AA .globl _pipe17_6
783 000323AA _pipe17_6:
784 000323AA 0000 .word L298
785 000323AC #
786 000323AC #
787 000323AC #
788 000323AC #
789 000323AC #
790 000323AC #
791 000323AC #
792 000323AC #
793 000323AC # /************************************************************************
794 000323AC # *
795 000323AC # * SUBTEST 6
796 000323AC # * data in cache, 1 NO-OP
797 000323AC # *
798 000323AC # ************************************************************************/
799 000323AC # pipe17_6()
800 000323AC # {
801 000323AC 13 00f5 jbr L300
802 000323AF L301:
803 000323AF # force_loop = FALSE; /* clear the force_loop flg */
804 000323AF 4d effffff9af clrl _force_loop
805 000323B5 # index = 0;
806 000323B5 4d effffff9a9 clrl _index
807 000323BB # do
808 000323BB L304:
809 000323BB # {
810 000323BB # sgl_value_1 = cvld_1_data[index].ld; /* get the operand */
811 000323BB 5c 0c effffff9a2 50 mull3 $12,_index,r0
812 000323C3 0d e000000000 effffff996 movl _cvld_1_data(r0),_sgl_value_1
813 000323CE # dbl_value_1.m = 0x40800000; /* set the '1.0' operand */
814 000323CE 0d 8f40800000 effffff98b movl $1082130432,_dbl_value_1
815 000323D9 # dbl_value_1.l = 0;
816 000323D9 4d effffff989 clrl _dbl_value_1+4
817 000323DF # dbl_value_2.m = 0; /* set the '0.0' operand */
818 000323DF 4d effffff97f clrl _dbl_value_2
819 000323E5 # dbl_value_2.l = 0;
820 000323E5 4d effffff97d clrl _dbl_value_2+4
821 000323EB # dbl_expected = cvld_1_data[index].exp; /* get the expected results */
822 000323EB 5c 0c effffff972 50 mull3 $12,_index,r0
823 000323F3 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0
824 000323FA 0d a004 effffff966 movl 4(r0),_dbl_expected+4
825 00032402 0d 60 effffff95b movl (r0),_dbl_expected
826 00032409 # /*
827 00032409 # * If LOOP ON ERROR is set, this is the loop for this subtest.
828 00032409 # * The force loop flag is set after the first error.
829 00032409 # */
830 00032409 # asm("_pipe17_6_lp1:");
831 00032409 _pipe17_6_lp1:
832 00032409 # asm("cvld _sgl_value_1"); /* convert the int. ( op ) */
833 00032409 77 effffff955 cvld _sgl_value_1
834 0003240F # asm("nop");
835 0003240F 10 nop
836 00032410 # asm("addd _dbl_value_2"); /* add a '0.0' ( 0 ) */
837 00032410 c7 effffff94e addd _dbl_value_2
838 00032416 # asm("nop");
839 00032416 10 nop
840 00032417 # asm("muld _dbl_value_1"); /* multiply by 1.0 ( 0 ) */
841 00032417 e7 effffff947 muld _dbl_value_1
842 0003241D # asm("nop");
843 0003241D 10 nop
844 0003241E # asm("std _dbl_st_acc"); /* store the result (-op ) */
845 0003241E 27 effffff940 std _dbl_st_acc
846 00032424 # if( force_loop )
847 00032424 5d effffff93a tstl _force_loop
848 0003242A 31 02 jeql L305
849 0003242C # asm("brb _pipe17_6_lp1");; /* run the loop again */
850 0003242C 11 db brb _pipe17_6_lp1
851 0003242E L305:
852 0003242E # /*
853 0003242E # * verify the results
854 0003242E # */
855 0003242E # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
856 0003242E # (dbl_st_acc.l != dbl_expected.l) )
857 0003242E 1d effffff930 effffff92b cmpl _dbl_st_acc,_dbl_expected
858 00032439 21 0d jneq L9994
859 0003243B 1d effffff927 effffff922 cmpl _dbl_st_acc+4,_dbl_expected+4
860 00032446 31 42 jeql L306
861 00032448 L9994:
862 00032448 # {
863 00032448 # errcnt++; /* bump the error count */
864 00032448 6d effffff916 incl _errcnt
865 0003244E # if ( prt_error )
866 0003244E 5d effffff910 tstl _prt_error
867 00032454 31 0d jeql L307
868 00032456 # print_pipe17_er("Cache Data, 1 NOP");
869 00032456 .data 1
870 00000d85 * L308:
871 00000d85 * 436163686520446174612C203 .ascii "Cache Data, 1 NOP\0"
1204E4F5000
872 00000d97 * .text
873 00032456 dd 8f00000d85 pushl $L308
874 0003245C fe 08 ef00000455 callf $8,_print_pipe17_er
875 00032463 # if ( halt_flg ) /* halt on error? */
876 00032463 L307:
877 00032463 5d effffff8fb tstl _halt_flg
878 00032469 31 0d jeql L309
879 0003246B # pipe17_er_hlt( subtest );
880 0003246B dd effffff8f3 pushl _subtest
881 00032471 fe 08 ef0000058e callf $8,_pipe17_er_hlt
882 00032478 # if ( loop_on_err ) {
883 00032478 L309:
884 00032478 5d effffff8e6 tstl _loop_on_err
885 0003247E 31 0a jeql L310
886 00032480 # force_loop = TRUE; /* set the force loop flag */
887 00032480 0d 01 effffff8dd movl $1,_force_loop
888 00032487 # asm("brw _pipe17_6_lp1"); /* and loop */
889 00032487 13 ff7f brw _pipe17_6_lp1
890 0003248A # }
891 0003248A # } /* end of compare error */
892 0003248A L310:
893 0003248A # } while( index++ < max_cvld_1_index );
894 0003248A L306:
895 0003248A L303:
896 0003248A 0d effffff8d4 50 movl _index,r0
897 00032491 6d effffff8cd incl _index
898 00032497 1d 50 effffff8c6 cmpl r0,_max_cvld_1_index
899 0003249E 81 03 13 ff18 jlss L304
900 000324A3 L302:
901 000324A3 # } /* end of subtest 6 */
902 000324A3 40 ret#2
903 000324A4 .set L298,0x0
904 000324A4 L300:
905 000324A4 13 ff08 jbr L301
906 000324A7 .data
907 00000d20 * .text
908 000324A7 00 .align 1
909 000324A8 .globl _pipe17_7
910 000324A8 _pipe17_7:
911 000324A8 0000 .word L311
912 000324AA #
913 000324AA #
914 000324AA #
915 000324AA #
916 000324AA #
917 000324AA #
918 000324AA #
919 000324AA #
920 000324AA # /************************************************************************
921 000324AA # *
922 000324AA # * SUBTEST 7
923 000324AA # * data in cache, 2 NO-OPs
924 000324AA # *
925 000324AA # ************************************************************************/
926 000324AA # pipe17_7()
927 000324AA # {
928 000324AA 13 00f8 jbr L313
929 000324AD L314:
930 000324AD # force_loop = FALSE; /* clear the force_loop flg */
931 000324AD 4d effffff8b1 clrl _force_loop
932 000324B3 # index = 0;
933 000324B3 4d effffff8ab clrl _index
934 000324B9 # do
935 000324B9 L317:
936 000324B9 # {
937 000324B9 # sgl_value_1 = cvld_1_data[index].ld; /* get the operand */
938 000324B9 5c 0c effffff8a4 50 mull3 $12,_index,r0
939 000324C1 0d e000000000 effffff898 movl _cvld_1_data(r0),_sgl_value_1
940 000324CC # dbl_value_1.m = 0x40800000; /* set the '1.0' operand */
941 000324CC 0d 8f40800000 effffff88d movl $1082130432,_dbl_value_1
942 000324D7 # dbl_value_1.l = 0;
943 000324D7 4d effffff88b clrl _dbl_value_1+4
944 000324DD # dbl_value_2.m = 0; /* set the '0.0' operand */
945 000324DD 4d effffff881 clrl _dbl_value_2
946 000324E3 # dbl_value_2.l = 0;
947 000324E3 4d effffff87f clrl _dbl_value_2+4
948 000324E9 # dbl_expected = cvld_1_data[index].exp; /* get the expected results */
949 000324E9 5c 0c effffff874 50 mull3 $12,_index,r0
950 000324F1 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0
951 000324F8 0d a004 effffff868 movl 4(r0),_dbl_expected+4
952 00032500 0d 60 effffff85d movl (r0),_dbl_expected
953 00032507 # /*
954 00032507 # * If LOOP ON ERROR is set, this is the loop for this subtest.
955 00032507 # * The force loop flag is set after the first error.
956 00032507 # */
957 00032507 # asm("_pipe17_7_lp1:");
958 00032507 _pipe17_7_lp1:
959 00032507 # asm("cvld _sgl_value_1"); /* convert the int. ( op ) */
960 00032507 77 effffff857 cvld _sgl_value_1
961 0003250D # asm("nop");
962 0003250D 10 nop
963 0003250E # asm("nop");
964 0003250E 10 nop
965 0003250F # asm("addd _dbl_value_2"); /* add a '0.0' ( 0 ) */
966 0003250F c7 effffff84f addd _dbl_value_2
967 00032515 # asm("nop");
968 00032515 10 nop
969 00032516 # asm("nop");
970 00032516 10 nop
971 00032517 # asm("muld _dbl_value_1"); /* multiply by 1.0 ( 0 ) */
972 00032517 e7 effffff847 muld _dbl_value_1
973 0003251D # asm("nop");
974 0003251D 10 nop
975 0003251E # asm("nop");
976 0003251E 10 nop
977 0003251F # asm("std _dbl_st_acc"); /* store the result (-op ) */
978 0003251F 27 effffff83f std _dbl_st_acc
979 00032525 # if( force_loop )
980 00032525 5d effffff839 tstl _force_loop
981 0003252B 31 02 jeql L318
982 0003252D # asm("brb _pipe17_7_lp1");; /* run the loop again */
983 0003252D 11 d8 brb _pipe17_7_lp1
984 0003252F L318:
985 0003252F # /*
986 0003252F # * verify the results
987 0003252F # */
988 0003252F # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
989 0003252F # (dbl_st_acc.l != dbl_expected.l) )
990 0003252F 1d effffff82f effffff82a cmpl _dbl_st_acc,_dbl_expected
991 0003253A 21 0d jneq L9993
992 0003253C 1d effffff826 effffff821 cmpl _dbl_st_acc+4,_dbl_expected+4
993 00032547 31 42 jeql L319
994 00032549 L9993:
995 00032549 # {
996 00032549 # errcnt++; /* bump the error count */
997 00032549 6d effffff815 incl _errcnt
998 0003254F # if ( prt_error )
999 0003254F 5d effffff80f tstl _prt_error
1000 00032555 31 0d jeql L320
1001 00032557 # print_pipe17_er("Cache Data, 2 NOPs");
1002 00032557 .data 1
1003 00000d97 * L321:
1004 00000d97 * 436163686520446174612C203 .ascii "Cache Data, 2 NOPs\0"
2204E4F507300
1005 00000daa * .text
1006 00032557 dd 8f00000d97 pushl $L321
1007 0003255D fe 08 ef00000354 callf $8,_print_pipe17_er
1008 00032564 # if ( halt_flg ) /* halt on error? */
1009 00032564 L320:
1010 00032564 5d effffff7fa tstl _halt_flg
1011 0003256A 31 0d jeql L322
1012 0003256C # pipe17_er_hlt( subtest );
1013 0003256C dd effffff7f2 pushl _subtest
1014 00032572 fe 08 ef0000048d callf $8,_pipe17_er_hlt
1015 00032579 # if ( loop_on_err ) {
1016 00032579 L322:
1017 00032579 5d effffff7e5 tstl _loop_on_err
1018 0003257F 31 0a jeql L323
1019 00032581 # force_loop = TRUE; /* set the force loop flag */
1020 00032581 0d 01 effffff7dc movl $1,_force_loop
1021 00032588 # asm("brw _pipe17_7_lp1"); /* and loop */
1022 00032588 13 ff7c brw _pipe17_7_lp1
1023 0003258B # }
1024 0003258B # } /* end of compare error */
1025 0003258B L323:
1026 0003258B # } while( index++ < max_cvld_1_index );
1027 0003258B L319:
1028 0003258B L316:
1029 0003258B 0d effffff7d3 50 movl _index,r0
1030 00032592 6d effffff7cc incl _index
1031 00032598 1d 50 effffff7c5 cmpl r0,_max_cvld_1_index
1032 0003259F 81 03 13 ff15 jlss L317
1033 000325A4 L315:
1034 000325A4 # } /* end of subtest 7 */
1035 000325A4 40 ret#2
1036 000325A5 .set L311,0x0
1037 000325A5 L313:
1038 000325A5 13 ff05 jbr L314
1039 000325A8 .data
1040 00000d20 * .text
1041 000325A8 .align 1
1042 000325A8 .globl _pipe17_8
1043 000325A8 _pipe17_8:
1044 000325A8 0000 .word L324
1045 000325AA #
1046 000325AA #
1047 000325AA #
1048 000325AA #
1049 000325AA #
1050 000325AA #
1051 000325AA #
1052 000325AA # /************************************************************************
1053 000325AA # *
1054 000325AA # * SUBTEST 8
1055 000325AA # * data in cache, 3 NO-OPs
1056 000325AA # *
1057 000325AA # ************************************************************************/
1058 000325AA # pipe17_8()
1059 000325AA # {
1060 000325AA 13 00fb jbr L326
1061 000325AD L327:
1062 000325AD # force_loop = FALSE; /* clear the force_loop flg */
1063 000325AD 4d effffff7b1 clrl _force_loop
1064 000325B3 # index = 0;
1065 000325B3 4d effffff7ab clrl _index
1066 000325B9 # do
1067 000325B9 L330:
1068 000325B9 # {
1069 000325B9 # sgl_value_1 = cvld_1_data[index].ld; /* get the operand */
1070 000325B9 5c 0c effffff7a4 50 mull3 $12,_index,r0
1071 000325C1 0d e000000000 effffff798 movl _cvld_1_data(r0),_sgl_value_1
1072 000325CC # dbl_value_1.m = 0x40800000; /* set the '1.0' operand */
1073 000325CC 0d 8f40800000 effffff78d movl $1082130432,_dbl_value_1
1074 000325D7 # dbl_value_1.l = 0;
1075 000325D7 4d effffff78b clrl _dbl_value_1+4
1076 000325DD # dbl_value_2.m = 0; /* set the '0.0' operand */
1077 000325DD 4d effffff781 clrl _dbl_value_2
1078 000325E3 # dbl_value_2.l = 0;
1079 000325E3 4d effffff77f clrl _dbl_value_2+4
1080 000325E9 # dbl_expected = cvld_1_data[index].exp; /* get the expected results */
1081 000325E9 5c 0c effffff774 50 mull3 $12,_index,r0
1082 000325F1 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0
1083 000325F8 0d a004 effffff768 movl 4(r0),_dbl_expected+4
1084 00032600 0d 60 effffff75d movl (r0),_dbl_expected
1085 00032607 # /*
1086 00032607 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1087 00032607 # * The force loop flag is set after the first error.
1088 00032607 # */
1089 00032607 # asm("_pipe17_8_lp1:");
1090 00032607 _pipe17_8_lp1:
1091 00032607 # asm("cvld _sgl_value_1"); /* convert the int. ( op ) */
1092 00032607 77 effffff757 cvld _sgl_value_1
1093 0003260D # asm("nop");
1094 0003260D 10 nop
1095 0003260E # asm("nop");
1096 0003260E 10 nop
1097 0003260F # asm("nop");
1098 0003260F 10 nop
1099 00032610 # asm("addd _dbl_value_2"); /* add a '0.0' ( 0 ) */
1100 00032610 c7 effffff74e addd _dbl_value_2
1101 00032616 # asm("nop");
1102 00032616 10 nop
1103 00032617 # asm("nop");
1104 00032617 10 nop
1105 00032618 # asm("nop");
1106 00032618 10 nop
1107 00032619 # asm("muld _dbl_value_1"); /* multiply by 1.0 ( 0 ) */
1108 00032619 e7 effffff745 muld _dbl_value_1
1109 0003261F # asm("nop");
1110 0003261F 10 nop
1111 00032620 # asm("nop");
1112 00032620 10 nop
1113 00032621 # asm("nop");
1114 00032621 10 nop
1115 00032622 # asm("std _dbl_st_acc"); /* store the result (-op ) */
1116 00032622 27 effffff73c std _dbl_st_acc
1117 00032628 # if( force_loop )
1118 00032628 5d effffff736 tstl _force_loop
1119 0003262E 31 02 jeql L331
1120 00032630 # asm("brb _pipe17_8_lp1");; /* run the loop again */
1121 00032630 11 d5 brb _pipe17_8_lp1
1122 00032632 L331:
1123 00032632 # /*
1124 00032632 # * verify the results
1125 00032632 # */
1126 00032632 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1127 00032632 # (dbl_st_acc.l != dbl_expected.l) )
1128 00032632 1d effffff72c effffff727 cmpl _dbl_st_acc,_dbl_expected
1129 0003263D 21 0d jneq L9992
1130 0003263F 1d effffff723 effffff71e cmpl _dbl_st_acc+4,_dbl_expected+4
1131 0003264A 31 42 jeql L332
1132 0003264C L9992:
1133 0003264C # {
1134 0003264C # errcnt++; /* bump the error count */
1135 0003264C 6d effffff712 incl _errcnt
1136 00032652 # if ( prt_error )
1137 00032652 5d effffff70c tstl _prt_error
1138 00032658 31 0d jeql L333
1139 0003265A # print_pipe17_er("Cache Data, 3 NOPs");
1140 0003265A .data 1
1141 00000daa * L334:
1142 00000daa * 436163686520446174612C203 .ascii "Cache Data, 3 NOPs\0"
3204E4F507300
1143 00000dbd * .text
1144 0003265A dd 8f00000daa pushl $L334
1145 00032660 fe 08 ef00000251 callf $8,_print_pipe17_er
1146 00032667 # if ( halt_flg ) /* halt on error? */
1147 00032667 L333:
1148 00032667 5d effffff6f7 tstl _halt_flg
1149 0003266D 31 0d jeql L335
1150 0003266F # pipe17_er_hlt( subtest );
1151 0003266F dd effffff6ef pushl _subtest
1152 00032675 fe 08 ef0000038a callf $8,_pipe17_er_hlt
1153 0003267C # if ( loop_on_err ) {
1154 0003267C L335:
1155 0003267C 5d effffff6e2 tstl _loop_on_err
1156 00032682 31 0a jeql L336
1157 00032684 # force_loop = TRUE; /* set the force loop flag */
1158 00032684 0d 01 effffff6d9 movl $1,_force_loop
1159 0003268B # asm("brw _pipe17_8_lp1"); /* and loop */
1160 0003268B 13 ff79 brw _pipe17_8_lp1
1161 0003268E # }
1162 0003268E # } /* end of compare error */
1163 0003268E L336:
1164 0003268E # } while( index++ < max_cvld_1_index );
1165 0003268E L332:
1166 0003268E L329:
1167 0003268E 0d effffff6d0 50 movl _index,r0
1168 00032695 6d effffff6c9 incl _index
1169 0003269B 1d 50 effffff6c2 cmpl r0,_max_cvld_1_index
1170 000326A2 81 03 13 ff12 jlss L330
1171 000326A7 L328:
1172 000326A7 # } /* end of subtest 8 */
1173 000326A7 40 ret#2
1174 000326A8 .set L324,0x0
1175 000326A8 L326:
1176 000326A8 13 ff02 jbr L327
1177 000326AB .data
1178 00000d20 * .text
1179 000326AB 00 .align 1
1180 000326AC .globl _pipe17_9
1181 000326AC _pipe17_9:
1182 000326AC 0000 .word L337
1183 000326AE #
1184 000326AE #
1185 000326AE #
1186 000326AE #
1187 000326AE #
1188 000326AE #
1189 000326AE #
1190 000326AE # /******************************************************************************
1191 000326AE # *
1192 000326AE # * SUBTEST 9
1193 000326AE # *
1194 000326AE # * Get the data via the FRAME POINTER ( indexed )
1195 000326AE # *
1196 000326AE # * ADDRESSES OF DATA OPERANDS INDEX DATA
1197 000326AE # * pointer_data,-4 (FP+32) 4 the STF result goes here
1198 000326AE # * pointer_data-8,-12 (FP+24) 3 < '0.0' data >
1199 000326AE # * pointer_data-16 (FP+20) 5(sgl) <operand data>
1200 000326AE # * pointer_data-20 (FP+16) 2 < unused >
1201 000326AE # * pointer_data-24,-28 (FP+8 ) 1 < '1.0' data >
1202 000326AE # * pointer_data-32,-36 ( FP ) 0 point the frame pointer here
1203 000326AE # *
1204 000326AE # * NOTE: The double precision instructions are using Quad Word indexing.
1205 000326AE # * The Convert Long To Double uses longword indexing.
1206 000326AE # ******************************************************************************/
1207 000326AE # pipe17_9()
1208 000326AE # {
1209 000326AE 13 0204 jbr L339
1210 000326B1 L340:
1211 000326B1 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1212 000326B1 ed 6d effffff6ac moval (r13),_pre_event_fp
1213 000326B8 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1214 000326B8 ed 6e effffff6a5 moval (r14),_pre_event_sp
1215 000326BF # force_loop = FALSE; /* clear force_loop flag */
1216 000326BF 4d effffff69f clrl _force_loop
1217 000326C5 # index = 0;
1218 000326C5 4d effffff699 clrl _index
1219 000326CB # do
1220 000326CB L343:
1221 000326CB # {
1222 000326CB # sgl_value_1 = cvld_1_data[index].ld; /* get the integer operand */
1223 000326CB 5c 0c effffff692 50 mull3 $12,_index,r0
1224 000326D3 0d e000000000 effffff686 movl _cvld_1_data(r0),_sgl_value_1
1225 000326DE # sgl_value_7 = 0x40800000; /* get MSW of '1.0' */
1226 000326DE 0d 8f40800000 effffff67b movl $1082130432,_sgl_value_7
1227 000326E9 # sgl_value_8 = 0; /* get a 0 */
1228 000326E9 4d effffff675 clrl _sgl_value_8
1229 000326EF # dbl_expected = cvld_1_data[index].exp; /* get expected results */
1230 000326EF 5c 0c effffff66e 50 mull3 $12,_index,r0
1231 000326F7 0c 8f00000004 50 addl2 $_cvld_1_data+4,r0
1232 000326FE 0d a004 effffff662 movl 4(r0),_dbl_expected+4
1233 00032706 0d 60 effffff657 movl (r0),_dbl_expected
1234 0003270D # /*
1235 0003270D # * If LOOP ON ERROR is set, this is the loop for this subtest.
1236 0003270D # * The force loop flag is set after the first error.
1237 0003270D # */
1238 0003270D # asm("_pipe17_9_lp1:");
1239 0003270D _pipe17_9_lp1:
1240 0003270D # asm("moval _pointer_data,_sgl_value_9");/* get store data's addr */
1241 0003270D ed effffff651 effffff64c moval _pointer_data,_sgl_value_9
1242 00032718 # sgl_value_9 -= 8;
1243 00032718 2c 08 effffff645 subl2 $8,_sgl_value_9
1244 0003271F # asm("movl _sgl_value_8,*_sgl_value_9"); /* set the '0.0's LSW */
1245 0003271F 0d effffff63f fffffff63a movl _sgl_value_8,*_sgl_value_9
1246 0003272A # sgl_value_9 -= 4;
1247 0003272A 2c 04 effffff633 subl2 $4,_sgl_value_9
1248 00032731 # asm("movl _sgl_value_8,*_sgl_value_9"); /* set the '0.0's MSW */
1249 00032731 0d effffff62d fffffff628 movl _sgl_value_8,*_sgl_value_9
1250 0003273C # sgl_value_9 -= 4;
1251 0003273C 2c 04 effffff621 subl2 $4,_sgl_value_9
1252 00032743 # asm("movl _sgl_value_1,*_sgl_value_9"); /* set the integer op. */
1253 00032743 0d effffff61b fffffff616 movl _sgl_value_1,*_sgl_value_9
1254 0003274E # sgl_value_9 -= 4;
1255 0003274E 2c 04 effffff60f subl2 $4,_sgl_value_9
1256 00032755 # asm("movl _sgl_value_8,*_sgl_value_9"); /* < unused data addr. > */
1257 00032755 0d effffff609 fffffff604 movl _sgl_value_8,*_sgl_value_9
1258 00032760 # sgl_value_9 -= 4;
1259 00032760 2c 04 effffff5fd subl2 $4,_sgl_value_9
1260 00032767 # asm("movl _sgl_value_8,*_sgl_value_9"); /* set the '1.0's LSW */
1261 00032767 0d effffff5f7 fffffff5f2 movl _sgl_value_8,*_sgl_value_9
1262 00032772 # sgl_value_9 -= 4;
1263 00032772 2c 04 effffff5eb subl2 $4,_sgl_value_9
1264 00032779 # asm("movl _sgl_value_7,*_sgl_value_9"); /* set the '1.0's MSW */
1265 00032779 0d effffff5e5 fffffff5e0 movl _sgl_value_7,*_sgl_value_9
1266 00032784 # sgl_value_9 -= 8; /* get the FP addr to use */
1267 00032784 2c 08 effffff5d9 subl2 $8,_sgl_value_9
1268 0003278B # asm("movl _sgl_value_9,r13"); /* set the FRAME POINTER */
1269 0003278B 0d effffff5d3 5d movl _sgl_value_9,r13
1270 00032792 # asm("movl $1,r2"); /* r2 index = 1 quadwords */
1271 00032792 0d 01 52 movl $1,r2
1272 00032795 # asm("movl $3,r3"); /* r3 index = 3 quadwords */
1273 00032795 0d 03 53 movl $3,r3
1274 00032798 # asm("movl $4,r4"); /* r4 index = 4 quadwords */
1275 00032798 0d 04 54 movl $4,r4
1276 0003279B # asm("movl $5,r5"); /* r5 index = 5 longwords */
1277 0003279B 0d 05 55 movl $5,r5
1278 0003279E # asm("cvld (r13)[r5]"); /* convert the int. ( op ) */
1279 0003279E 77 456d cvld (r13)[r5]
1280 000327A1 # asm("addd (r13)[r3]"); /* add a '0.0' ( op ) */
1281 000327A1 c7 436d addd (r13)[r3]
1282 000327A4 # asm("muld (r13)[r2]"); /* multiply by '1.0' ( op ) */
1283 000327A4 e7 426d muld (r13)[r2]
1284 000327A7 # asm("std (r13)[r4]"); /* store the result ( op ) */
1285 000327A7 27 446d std (r13)[r4]
1286 000327AA # if( force_loop )
1287 000327AA 5d effffff5b4 tstl _force_loop
1288 000327B0 31 03 jeql L344
1289 000327B2 # asm("brw _pipe17_9_lp1");; /* run the loop again */
1290 000327B2 13 ff58 brw _pipe17_9_lp1
1291 000327B5 L344:
1292 000327B5 # /*
1293 000327B5 # * verify the results
1294 000327B5 # */
1295 000327B5 # asm("moval (r13),_sgl_value_10"); /* save the frame pointer */
1296 000327B5 ed 6d effffff5a8 moval (r13),_sgl_value_10
1297 000327BC # asm("movl _pointer_data,_sgl_value_4"); /* save the LSW stored */
1298 000327BC 0d effffff5a2 effffff59d movl _pointer_data,_sgl_value_4
1299 000327C7 # asm("movl _pointer_data-4,_sgl_value_3"); /* and the MSW */
1300 000327C7 0d effffff593 effffff592 movl _pointer_data-4,_sgl_value_3
1301 000327D2 # if( (sgl_value_3 != dbl_expected.m) || /* verify the result... */
1302 000327D2 # (sgl_value_4 != dbl_expected.l) || /* verify the result... */
1303 000327D2 # (sgl_value_10 != sgl_value_9) ) /* ... and the final FP */
1304 000327D2 1d effffff58c effffff587 cmpl _sgl_value_3,_dbl_expected
1305 000327DD 21 1d jneq L9991
1306 000327DF 1d effffff57f effffff57e cmpl _sgl_value_4,_dbl_expected+4
1307 000327EA 21 10 jneq L9991
1308 000327EC 1d effffff572 effffff56d cmpl _sgl_value_10,_sgl_value_9
1309 000327F7 21 03 13 0091 jeql L345
1310 000327FC L9991:
1311 000327FC # {
1312 000327FC # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1313 000327FC 0d effffff562 5d movl _pre_event_fp,r13
1314 00032803 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1315 00032803 0d effffff55b 5e movl _pre_event_sp,r14
1316 0003280A # errcnt++; /* bump the error count */
1317 0003280A 6d effffff554 incl _errcnt
1318 00032810 # if ( prt_error ) {
1319 00032810 5d effffff54e tstl _prt_error
1320 00032816 31 4e jeql L346
1321 00032818 # print_pipe17_er("indexed FP addressing");
1322 00032818 .data 1
1323 00000dbd * L347:
1324 00000dbd * 696E646578656420465020616 .ascii "indexed FP addressing\0"
46472657373696E6700
1325 00000dd3 * .text
1326 00032818 dd 8f00000dbd pushl $L347
1327 0003281E fe 08 ef00000093 callf $8,_print_pipe17_er
1328 00032825 # writes("final Frame Pointer = ");
1329 00032825 .data 1
1330 00000dd3 * L348:
1331 00000dd3 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1332 00000dea * .text
1333 00032825 dd 8f00000dd3 pushl $L348
1334 0003282B fe 08 effffff532 callf $8,_writes
1335 00032832 # write32h( sgl_value_10 );
1336 00032832 dd effffff52c pushl _sgl_value_10
1337 00032838 fe 08 effffff525 callf $8,_write32h
1338 0003283F # writes(", expected FP = ");
1339 0003283F .data 1
1340 00000dea * L350:
1341 00000dea * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1342 00000dfc * .text
1343 0003283F dd 8f00000dea pushl $L350
1344 00032845 fe 08 effffff518 callf $8,_writes
1345 0003284C # write32h( sgl_value_9 );
1346 0003284C dd effffff512 pushl _sgl_value_9
1347 00032852 fe 08 effffff50b callf $8,_write32h
1348 00032859 # writes("\n");
1349 00032859 .data 1
1350 00000dfc * L351:
1351 00000dfc * 0A00 .ascii "\12\0"
1352 00000dfe * .text
1353 00032859 dd 8f00000dfc pushl $L351
1354 0003285F fe 08 effffff4fe callf $8,_writes
1355 00032866 # }
1356 00032866 # if ( halt_flg ) /* halt on error? */
1357 00032866 L346:
1358 00032866 5d effffff4f8 tstl _halt_flg
1359 0003286C 31 0d jeql L352
1360 0003286E # pipe17_er_hlt( subtest );
1361 0003286E dd effffff4f0 pushl _subtest
1362 00032874 fe 08 ef0000018b callf $8,_pipe17_er_hlt
1363 0003287B # if ( loop_on_err ) {
1364 0003287B L352:
1365 0003287B 5d effffff4e3 tstl _loop_on_err
1366 00032881 31 0a jeql L353
1367 00032883 # force_loop = TRUE; /* set the force loop flag */
1368 00032883 0d 01 effffff4da movl $1,_force_loop
1369 0003288A # asm("brw _pipe17_9_lp1"); /* and loop */
1370 0003288A 13 fe80 brw _pipe17_9_lp1
1371 0003288D # }
1372 0003288D # } /* end of compare error */
1373 0003288D L353:
1374 0003288D # } while( index++ < max_cvld_1_index );
1375 0003288D L345:
1376 0003288D L342:
1377 0003288D 0d effffff4d1 50 movl _index,r0
1378 00032894 6d effffff4ca incl _index
1379 0003289A 1d 50 effffff4c3 cmpl r0,_max_cvld_1_index
1380 000328A1 81 03 13 fe25 jlss L343
1381 000328A6 L341:
1382 000328A6 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1383 000328A6 0d effffff4b8 5d movl _pre_event_fp,r13
1384 000328AD # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1385 000328AD 0d effffff4b1 5e movl _pre_event_sp,r14
1386 000328B4 # } /* end of subtest 9 */
1387 000328B4 40 ret#2
1388 000328B5 .set L337,0x0
1389 000328B5 L339:
1390 000328B5 13 fdf9 jbr L340
1391 000328B8 .data
1392 00000d20 * .text
1393 000328B8 .align 1
1394 000328B8 .globl _print_pipe17_er
1395 000328B8 _print_pipe17_er:
1396 000328B8 0000 .word L354
1397 000328BA #
1398 000328BA #
1399 000328BA # /******************************************************************************
1400 000328BA # *
1401 000328BA # * ERROR ROUTINE
1402 000328BA # *
1403 000328BA # * print an error in the following form
1404 000328BA # *
1405 000328BA # *operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd
1406 000328BA # * expected Acc = xxxxxxxx xxxxxxxx
1407 000328BA # *
1408 000328BA # ******************************************************************************/
1409 000328BA # print_pipe17_er(msg)
1410 000328BA # char *msg;
1411 000328BA # {
1412 000328BA 13 0145 jbr L356
1413 000328BD L357:
1414 000328BD # writes("\n"); /* start a new print line */
1415 000328BD .data 1
1416 00000dfe * L358:
1417 00000dfe * 0A00 .ascii "\12\0"
1418 00000e00 * .text
1419 000328BD dd 8f00000dfe pushl $L358
1420 000328C3 fe 08 effffff49a callf $8,_writes
1421 000328CA # writes("cycle: ");
1422 000328CA .data 1
1423 00000e00 * L359:
1424 00000e00 * 6379636C653A2000 .ascii "cycle: \0"
1425 00000e08 * .text
1426 000328CA dd 8f00000e00 pushl $L359
1427 000328D0 fe 08 effffff48d callf $8,_writes
1428 000328D7 # writed( cycle );
1429 000328D7 dd effffff487 pushl _cycle
1430 000328DD fe 08 effffff480 callf $8,_writed
1431 000328E4 # writes(" test ");
1432 000328E4 .data 1
1433 00000e08 * L361:
1434 00000e08 * 20746573742000 .ascii " test \0"
1435 00000e0f * .text
1436 000328E4 dd 8f00000e08 pushl $L361
1437 000328EA fe 08 effffff473 callf $8,_writes
1438 000328F1 # writed( test_no );
1439 000328F1 dd effffff46d pushl _test_no
1440 000328F7 fe 08 effffff466 callf $8,_writed
1441 000328FE # writes(" (Pipe 17), subtest ");
1442 000328FE .data 1
1443 00000e0f * L362:
1444 00000e0f * 20202850697065203137292C2 .ascii " (Pipe 17), subtest \0"
0737562746573742000
1445 00000e25 * .text
1446 000328FE dd 8f00000e0f pushl $L362
1447 00032904 fe 08 effffff459 callf $8,_writes
1448 0003290B # writed( subtest );
1449 0003290B dd effffff453 pushl _subtest
1450 00032911 fe 08 effffff44c callf $8,_writed
1451 00032918 # writes(" error - ");
1452 00032918 .data 1
1453 00000e25 * L363:
1454 00000e25 * 206572726F72202D2000 .ascii " error - \0"
1455 00000e2f * .text
1456 00032918 dd 8f00000e25 pushl $L363
1457 0003291E fe 08 effffff43f callf $8,_writes
1458 00032925 # writes( msg );
1459 00032925 dd ad04 pushl 4(fp)
1460 00032928 fe 08 effffff435 callf $8,_writes
1461 0003292F # writec('\n');
1462 0003292F dd 0a pushl $10
1463 00032931 fe 08 effffff42c callf $8,_writec
1464 00032938 # writes(" CVLD(op), ADDD(0.0), MULD(1.0), STD\n");
1465 00032938 .data 1
1466 00000e2f * L365:
1467 00000e2f * 2043564C44286F70292C20414 .ascii " CVLD(op), ADDD(0.0), MULD(1.0), STD\12\0"
4444428302E30292C204D554C
4428312E30292C205354440A0
0
1468 00000e55 * .text
1469 00032938 dd 8f00000e2f pushl $L365
1470 0003293E fe 08 effffff41f callf $8,_writes
1471 00032945 # writes("operand = ");
1472 00032945 .data 1
1473 00000e55 * L366:
1474 00000e55 * 6F706572616E64203D2000 .ascii "operand = \0"
1475 00000e60 * .text
1476 00032945 dd 8f00000e55 pushl $L366
1477 0003294B fe 08 effffff412 callf $8,_writes
1478 00032952 # write32h( dbl_ld_acc.m );
1479 00032952 dd effffff40c pushl _dbl_ld_acc
1480 00032958 fe 08 effffff405 callf $8,_write32h
1481 0003295F # writec(' ');
1482 0003295F dd 20 pushl $32
1483 00032961 fe 08 effffff3fc callf $8,_writec
1484 00032968 # write32h( dbl_ld_acc.l );
1485 00032968 dd effffff3fa pushl _dbl_ld_acc+4
1486 0003296E fe 08 effffff3ef callf $8,_write32h
1487 00032975 # writes(", final Acc = ");
1488 00032975 .data 1
1489 00000e60 * L367:
1490 00000e60 * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
3203D2000
1491 00000e71 * .text
1492 00032975 dd 8f00000e60 pushl $L367
1493 0003297B fe 08 effffff3e2 callf $8,_writes
1494 00032982 # write32h( dbl_st_acc.m );
1495 00032982 dd effffff3dc pushl _dbl_st_acc
1496 00032988 fe 08 effffff3d5 callf $8,_write32h
1497 0003298F # writec(' ');
1498 0003298F dd 20 pushl $32
1499 00032991 fe 08 effffff3cc callf $8,_writec
1500 00032998 # write32h( dbl_st_acc.l );
1501 00032998 dd effffff3ca pushl _dbl_st_acc+4
1502 0003299E fe 08 effffff3bf callf $8,_write32h
1503 000329A5 # writes(", index = ");
1504 000329A5 .data 1
1505 00000e71 * L368:
1506 00000e71 * 2C202020696E646578203D200 .ascii ", index = \0"
0
1507 00000e7e * .text
1508 000329A5 dd 8f00000e71 pushl $L368
1509 000329AB fe 08 effffff3b2 callf $8,_writes
1510 000329B2 # writed( index );
1511 000329B2 dd effffff3ac pushl _index
1512 000329B8 fe 08 effffff3a5 callf $8,_writed
1513 000329BF # writec('\n');
1514 000329BF dd 0a pushl $10
1515 000329C1 fe 08 effffff39c callf $8,_writec
1516 000329C8 # writes(" expected Acc = ");
1517 000329C8 .data 1
1518 00000e7e * L369:
1519 00000e7e * 2020202020202020202020202 .ascii " expected Acc = \0"
0202020202020202020202020
2020206578706563746564204
16363203D2000
1520 00000eaa * .text
1521 000329C8 dd 8f00000e7e pushl $L369
1522 000329CE fe 08 effffff38f callf $8,_writes
1523 000329D5 # write32h( dbl_expected.m );
1524 000329D5 dd effffff389 pushl _dbl_expected
1525 000329DB fe 08 effffff382 callf $8,_write32h
1526 000329E2 # writec(' ');
1527 000329E2 dd 20 pushl $32
1528 000329E4 fe 08 effffff379 callf $8,_writec
1529 000329EB # write32h( dbl_expected.l );
1530 000329EB dd effffff377 pushl _dbl_expected+4
1531 000329F1 fe 08 effffff36c callf $8,_write32h
1532 000329F8 # writec('\n');
1533 000329F8 dd 0a pushl $10
1534 000329FA fe 08 effffff363 callf $8,_writec
1535 00032A01 # }
1536 00032A01 40 ret#2
1537 00032A02 .set L354,0x0
1538 00032A02 L356:
1539 00032A02 13 feb8 jbr L357
1540 00032A05 .data
1541 00000d20 * .text
1542 00032A05 00 .align 1
1543 00032A06 .globl _pipe17_er_hlt
1544 00032A06 _pipe17_er_hlt:
1545 00032A06 0000 .word L370
1546 00032A08 #
1547 00032A08 #
1548 00032A08 #
1549 00032A08 #
1550 00032A08 #
1551 00032A08 # /******************************************************************************
1552 00032A08 # *
1553 00032A08 # * HALT ON ERROR ROUTINE
1554 00032A08 # *
1555 00032A08 # * halt with the necessary information saved in the registers
1556 00032A08 # *
1557 00032A08 # ******************************************************************************/
1558 00032A08 # pipe17_er_hlt( subtest )
1559 00032A08 # int subtest;
1560 00032A08 # {
1561 00032A08 11 75 jbr L372
1562 00032A0A L373:
1563 00032A0A # sgl_value_3 = dbl_st_acc.m;
1564 00032A0A 0d effffff354 effffff34f movl _dbl_st_acc,_sgl_value_3
1565 00032A15 # sgl_value_4 = dbl_st_acc.l;
1566 00032A15 0d effffff34d effffff344 movl _dbl_st_acc+4,_sgl_value_4
1567 00032A20 # asm("movl _test_no,r0"); /* r0 = test number */
1568 00032A20 0d effffff33e 50 movl _test_no,r0
1569 00032A27 # asm("movl _subtest,r1"); /* r1 = subtest number */
1570 00032A27 0d effffff337 51 movl _subtest,r1
1571 00032A2E # asm("movl $1,r2"); /* r2 = error code */
1572 00032A2E 0d 01 52 movl $1,r2
1573 00032A31 # asm("movl _cycle,r3"); /* r3 = cycle count */
1574 00032A31 0d effffff32d 53 movl _cycle,r3
1575 00032A38 # asm("movl _sgl_value_1,r4"); /* r4 = MSW operand loaded */
1576 00032A38 0d effffff326 54 movl _sgl_value_1,r4
1577 00032A3F # asm("movl _sgl_value_2,r5"); /* r5 = LSW operand loaded */
1578 00032A3F 0d effffff31f 55 movl _sgl_value_2,r5
1579 00032A46 # asm("movl _sgl_value_3,r6"); /* r6 = MSW operand stored */
1580 00032A46 0d effffff318 56 movl _sgl_value_3,r6
1581 00032A4D # asm("movl _sgl_value_4,r7"); /* r7 = LSW operand stored */
1582 00032A4D 0d effffff311 57 movl _sgl_value_4,r7
1583 00032A54 # asm("movl _sgl_value_5,r8"); /* r8 = MSW operand expect */
1584 00032A54 0d effffff30a 58 movl _sgl_value_5,r8
1585 00032A5B # asm("movl _sgl_value_6,r9"); /* r9 = LSW operand expect */
1586 00032A5B 0d effffff303 59 movl _sgl_value_6,r9
1587 00032A62 # asm("movl _index,r10"); /* r10 = data index */
1588 00032A62 0d effffff2fc 5a movl _index,r10
1589 00032A69 # if( subtest == 9 ) {
1590 00032A69 1d ad04 09 cmpl 4(fp),$9
1591 00032A6D 21 0e jneq L374
1592 00032A6F # asm("movl _sgl_value_10,r11"); /* r11 = final FP value */
1593 00032A6F 0d effffff2ef 5b movl _sgl_value_10,r11
1594 00032A76 # asm("movl _sgl_value_9,r12"); /* r12 = expected FP value */
1595 00032A76 0d effffff2e8 5c movl _sgl_value_9,r12
1596 00032A7D # };
1597 00032A7D L374:
1598 00032A7D # asm(".globl _pipe17_1_hlt");
1599 00032A7D .globl _pipe17_1_hlt
1600 00032A7D # asm("_pipe17_1_hlt:"); /* PC after the halt */
1601 00032A7D _pipe17_1_hlt:
1602 00032A7D # asm("halt"); /* HALT ... */
1603 00032A7D 00 halt
1604 00032A7E # } /* end of halt on error */
1605 00032A7E 40 ret#2
1606 00032A7F .set L370,0x0
1607 00032A7F L372:
1608 00032A7F 11 89 jbr L373
1609 00032A81 .data
1609 000647E5 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.