![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe13.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 pipe13.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 00000db4 * .text
4 00000000 .align 1
5 00000000 .globl _pipe_13
6 00000000 _pipe_13:
7 0002E288 0000 .word L215
8 0002E28A # #include "fpp_defs.h"
9 0002E28A #
10 0002E28A #
11 0002E28A # /*****************************************************************************
12 0002E28A # *
13 0002E28A # * DBL PIPELINE TEST #13 MONITOR
14 0002E28A # *
15 0002E28A # * This test will do:
16 0002E28A # *
17 0002E28A # * LDD(1) MULD(x) MULD(1) SUBD(x) ADDD(x) STD
18 0002E28A # *
19 0002E28A # * where the x's are the LDD data patterns.
20 0002E28A # *****************************************************************************/
21 0002E28A # pipe_13()
22 0002E28A # {
23 0002E28A 13 009b jbr L217
24 0002E28D L218:
25 0002E28D # asm(".globl _pipeline_13_t");
26 0002E28D .globl _pipeline_13_t
27 0002E28D # asm("_pipeline_13_t:"); /* entry address */
28 0002E28D _pipeline_13_t:
29 0002E28D # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
30 0002E28D 1d effffffff5 01 cmpl _cycle,$1
31 0002E294 21 15 jneq L219
32 0002E296 5d efffffffec tstl _prt_hdrs
33 0002E29C 31 0d jeql L219
34 0002E29E # {
35 0002E29E # writes(" PIPE_13");
36 0002E29E .data 1
37 00000db4 * L221:
38 00000db4 * 20504950455F313300 .ascii " PIPE_13\0"
39 00000dbd * .text
40 0002E29E dd 8f00000db4 pushl $L221
41 0002E2A4 fe 08 efffffffdd callf $8,_writes
42 0002E2AB # }
43 0002E2AB # subtest = 1;
44 0002E2AB L219:
45 0002E2AB 0d 01 efffffffd6 movl $1,_subtest
46 0002E2B2 # pipe13_1(); /* data in REGs, no NOPs */
47 0002E2B2 fe 04 ef00000073 callf $4,_pipe13_1
48 0002E2B9 # subtest++; /* increment subtest num */
49 0002E2B9 6d efffffffc9 incl _subtest
50 0002E2BF # pipe13_2(); /* data in REGs, 1 NOP */
51 0002E2BF fe 04 ef000001a2 callf $4,_pipe13_2
52 0002E2C6 # subtest++; /* increment subtest num */
53 0002E2C6 6d efffffffbc incl _subtest
54 0002E2CC # pipe13_3(); /* data in REGs, 2 NOPs */
55 0002E2CC fe 04 ef000002d5 callf $4,_pipe13_3
56 0002E2D3 # subtest++; /* increment subtest num */
57 0002E2D3 6d efffffffaf incl _subtest
58 0002E2D9 # pipe13_4(); /* data in REGs, 3 NOPs */
59 0002E2D9 fe 04 ef0000040e callf $4,_pipe13_4
60 0002E2E0 # subtest++; /* increment subtest num */
61 0002E2E0 6d efffffffa2 incl _subtest
62 0002E2E6 # pipe13_5(); /* data in CACHE, no NOPs */
63 0002E2E6 fe 04 ef0000054b callf $4,_pipe13_5
64 0002E2ED # subtest++; /* increment subtest num */
65 0002E2ED 6d efffffff95 incl _subtest
66 0002E2F3 # pipe13_6(); /* data in CACHE, 1 NOP */
67 0002E2F3 fe 04 ef00000644 callf $4,_pipe13_6
68 0002E2FA # subtest++; /* increment subtest num */
69 0002E2FA 6d efffffff88 incl _subtest
70 0002E300 # pipe13_7(); /* data in CACHE, 2 NOPs */
71 0002E300 fe 04 ef00000741 callf $4,_pipe13_7
72 0002E307 # subtest++; /* increment subtest num */
73 0002E307 6d efffffff7b incl _subtest
74 0002E30D # pipe13_8(); /* data in CACHE, 3 NOPs */
75 0002E30D fe 04 ef00000844 callf $4,_pipe13_8
76 0002E314 # subtest++; /* increment subtest num */
77 0002E314 6d efffffff6e incl _subtest
78 0002E31A # pipe13_9(); /* data via F.P. 0 NOPs */
79 0002E31A fe 04 ef0000094b callf $4,_pipe13_9
80 0002E321 # asm("jmp *return"); /* return to the test monitor */
81 0002E321 71 ffffffff61 jmp *return
82 0002E327 # }
83 0002E327 40 ret#2
84 0002E328 .set L215,0x0
85 0002E328 L217:
86 0002E328 13 ff62 jbr L218
87 0002E32B .data
88 00000db4 * .text
89 0002E32B 00 .align 1
90 0002E32C .globl _pipe13_1
91 0002E32C _pipe13_1:
92 0002E32C 0000 .word L231
93 0002E32E #
94 0002E32E #
95 0002E32E #
96 0002E32E #
97 0002E32E #
98 0002E32E #
99 0002E32E #
100 0002E32E # /************************************************************************
101 0002E32E # *
102 0002E32E # * SUBTEST 1
103 0002E32E # * data in registers, no NO-OPs
104 0002E32E # *
105 0002E32E # ************************************************************************/
106 0002E32E # pipe13_1()
107 0002E32E # {
108 0002E32E 13 0133 jbr L233
109 0002E331 L234:
110 0002E331 # force_loop = FALSE; /* clear the force_loop flg */
111 0002E331 4d efffffff51 clrl _force_loop
112 0002E337 # index = 0;
113 0002E337 4d efffffff4b clrl _index
114 0002E33D # do
115 0002E33D L237:
116 0002E33D # {
117 0002E33D # sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */
118 0002E33D 0d efffffff45 50 movl _index,r0
119 0002E344 48 04 50 50 shll $4,r0,r0
120 0002E348 0d e000000000 efffffff35 movl _ldd_1_data(r0),_sgl_value_1
121 0002E353 # sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */
122 0002E353 0d efffffff2f 50 movl _index,r0
123 0002E35A 48 04 50 50 shll $4,r0,r0
124 0002E35E 0d e000000004 efffffff1f movl _ldd_1_data+4(r0),_sgl_value_2
125 0002E369 # sgl_value_7 = 0x40800000; /* get a dbl precision 1.0 */
126 0002E369 0d 8f40800000 efffffff14 movl $1082130432,_sgl_value_7
127 0002E374 # sgl_value_8 = 0;
128 0002E374 4d efffffff0e clrl _sgl_value_8
129 0002E37A # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
130 0002E37A 48 04 efffffff07 50 shll $4,_index,r0
131 0002E382 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
132 0002E389 0d a004 effffffefb movl 4(r0),_dbl_expected+4
133 0002E391 0d 60 effffffef0 movl (r0),_dbl_expected
134 0002E398 # /*
135 0002E398 # * If LOOP ON ERROR is set, this is the loop for this subtest.
136 0002E398 # * The force loop flag is set after the first error.
137 0002E398 # */
138 0002E398 # asm("_pipe13_1_lp1:");
139 0002E398 _pipe13_1_lp1:
140 0002E398 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
141 0002E398 0d effffffeea 54 movl _sgl_value_1,r4
142 0002E39F # asm("movl _sgl_value_2,r5");
143 0002E39F 0d effffffee3 55 movl _sgl_value_2,r5
144 0002E3A6 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r2/r3 */
145 0002E3A6 0d effffffedc 52 movl _sgl_value_7,r2
146 0002E3AD # asm("movl _sgl_value_8,r3");
147 0002E3AD 0d effffffed5 53 movl _sgl_value_8,r3
148 0002E3B4 # asm("ldd r2"); /* load a '1.0' ( 1 ) */
149 0002E3B4 07 52 ldd r2
150 0002E3B6 # asm("muld r4"); /* multiply by op. ( op ) */
151 0002E3B6 e7 54 muld r4
152 0002E3B8 # asm("muld r2"); /* multiply by 1.0 ( op ) */
153 0002E3B8 e7 52 muld r2
154 0002E3BA # asm("subd r4"); /* subtract the op. ( 0 ) */
155 0002E3BA d7 54 subd r4
156 0002E3BC # asm("addd r4"); /* add the op. ( op ) */
157 0002E3BC c7 54 addd r4
158 0002E3BE # asm("std r6"); /* store the result ( op ) */
159 0002E3BE 27 56 std r6
160 0002E3C0 # if( force_loop )
161 0002E3C0 5d effffffec2 tstl _force_loop
162 0002E3C6 31 02 jeql L238
163 0002E3C8 # asm("brb _pipe13_1_lp1");; /* run the loop again */
164 0002E3C8 11 ce brb _pipe13_1_lp1
165 0002E3CA L238:
166 0002E3CA # /*
167 0002E3CA # * verify the results
168 0002E3CA # */
169 0002E3CA # asm("movl r6,_sgl_value_3"); /* get the result */
170 0002E3CA 0d 56 effffffeb7 movl r6,_sgl_value_3
171 0002E3D1 # asm("movl r7,_sgl_value_4");
172 0002E3D1 0d 57 effffffeb0 movl r7,_sgl_value_4
173 0002E3D8 # dbl_st_acc.m = sgl_value_3;
174 0002E3D8 0d effffffeaa effffffea5 movl _sgl_value_3,_dbl_st_acc
175 0002E3E3 # dbl_st_acc.l = sgl_value_4;
176 0002E3E3 0d effffffe9f effffffe9e movl _sgl_value_4,_dbl_st_acc+4
177 0002E3EE # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
178 0002E3EE # (dbl_st_acc.l != dbl_expected.l) )
179 0002E3EE 1d effffffe94 effffffe8f cmpl _dbl_st_acc,_dbl_expected
180 0002E3F9 21 0d jneq L9999
181 0002E3FB 1d effffffe8b effffffe86 cmpl _dbl_st_acc+4,_dbl_expected+4
182 0002E406 31 42 jeql L239
183 0002E408 L9999:
184 0002E408 # {
185 0002E408 # errcnt++; /* bump the error count */
186 0002E408 6d effffffe7a incl _errcnt
187 0002E40E # if ( prt_error )
188 0002E40E 5d effffffe74 tstl _prt_error
189 0002E414 31 0d jeql L240
190 0002E416 # print_pipe13_er("Reg. Data, no NOPs");
191 0002E416 .data 1
192 00000dbd * L242:
193 00000dbd * 5265672E20446174612C206E6 .ascii "Reg. Data, no NOPs\0"
F204E4F507300
194 00000dd0 * .text
195 0002E416 dd 8f00000dbd pushl $L242
196 0002E41C fe 08 ef00000a4d callf $8,_print_pipe13_er
197 0002E423 # if ( halt_flg )
198 0002E423 L240:
199 0002E423 5d effffffe5f tstl _halt_flg
200 0002E429 31 0d jeql L243
201 0002E42B # pipe13_er_hlt( subtest );
202 0002E42B dd effffffe57 pushl _subtest
203 0002E431 fe 08 ef00000b86 callf $8,_pipe13_er_hlt
204 0002E438 # if ( loop_on_err ) {
205 0002E438 L243:
206 0002E438 5d effffffe4a tstl _loop_on_err
207 0002E43E 31 0a jeql L245
208 0002E440 # force_loop = TRUE; /* set the force loop flag */
209 0002E440 0d 01 effffffe41 movl $1,_force_loop
210 0002E447 # asm("brw _pipe13_1_lp1"); /* and loop */
211 0002E447 13 ff4e brw _pipe13_1_lp1
212 0002E44A # }
213 0002E44A # } /* end of compare error */
214 0002E44A L245:
215 0002E44A # } while( index++ < max_ldd_1_index );
216 0002E44A L239:
217 0002E44A L236:
218 0002E44A 0d effffffe38 50 movl _index,r0
219 0002E451 6d effffffe31 incl _index
220 0002E457 1d 50 effffffe2a cmpl r0,_max_ldd_1_index
221 0002E45E 81 03 13 feda jlss L237
222 0002E463 L235:
223 0002E463 # } /* end of subtest 1 */
224 0002E463 40 ret#2
225 0002E464 .set L231,0x0
226 0002E464 L233:
227 0002E464 13 feca jbr L234
228 0002E467 .data
229 00000db4 * .text
230 0002E467 00 .align 1
231 0002E468 .globl _pipe13_2
232 0002E468 _pipe13_2:
233 0002E468 0000 .word L246
234 0002E46A #
235 0002E46A #
236 0002E46A #
237 0002E46A #
238 0002E46A #
239 0002E46A #
240 0002E46A #
241 0002E46A # /************************************************************************
242 0002E46A # *
243 0002E46A # * SUBTEST 2
244 0002E46A # * data in registers, 1 NO-OP
245 0002E46A # *
246 0002E46A # ************************************************************************/
247 0002E46A # pipe13_2()
248 0002E46A # {
249 0002E46A 13 0138 jbr L248
250 0002E46D L249:
251 0002E46D # force_loop = FALSE; /* clear the force_loop flg */
252 0002E46D 4d effffffe15 clrl _force_loop
253 0002E473 # index = 0;
254 0002E473 4d effffffe0f clrl _index
255 0002E479 # do
256 0002E479 L252:
257 0002E479 # {
258 0002E479 # sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */
259 0002E479 0d effffffe09 50 movl _index,r0
260 0002E480 48 04 50 50 shll $4,r0,r0
261 0002E484 0d e000000000 effffffdf9 movl _ldd_1_data(r0),_sgl_value_1
262 0002E48F # sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */
263 0002E48F 0d effffffdf3 50 movl _index,r0
264 0002E496 48 04 50 50 shll $4,r0,r0
265 0002E49A 0d e000000004 effffffde3 movl _ldd_1_data+4(r0),_sgl_value_2
266 0002E4A5 # sgl_value_7 = 0x40800000; /* get a dbl precision 1.0 */
267 0002E4A5 0d 8f40800000 effffffdd8 movl $1082130432,_sgl_value_7
268 0002E4B0 # sgl_value_8 = 0;
269 0002E4B0 4d effffffdd2 clrl _sgl_value_8
270 0002E4B6 # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
271 0002E4B6 48 04 effffffdcb 50 shll $4,_index,r0
272 0002E4BE 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
273 0002E4C5 0d a004 effffffdbf movl 4(r0),_dbl_expected+4
274 0002E4CD 0d 60 effffffdb4 movl (r0),_dbl_expected
275 0002E4D4 # /*
276 0002E4D4 # * If LOOP ON ERROR is set, this is the loop for this subtest.
277 0002E4D4 # * The force loop flag is set after the first error.
278 0002E4D4 # */
279 0002E4D4 # asm("_pipe13_2_lp1:");
280 0002E4D4 _pipe13_2_lp1:
281 0002E4D4 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
282 0002E4D4 0d effffffdae 54 movl _sgl_value_1,r4
283 0002E4DB # asm("movl _sgl_value_2,r5");
284 0002E4DB 0d effffffda7 55 movl _sgl_value_2,r5
285 0002E4E2 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r4/r5 */
286 0002E4E2 0d effffffda0 52 movl _sgl_value_7,r2
287 0002E4E9 # asm("movl _sgl_value_8,r3");
288 0002E4E9 0d effffffd99 53 movl _sgl_value_8,r3
289 0002E4F0 # asm("ldd r2"); /* load a '1.0' ( 1 ) */
290 0002E4F0 07 52 ldd r2
291 0002E4F2 # asm("nop");
292 0002E4F2 10 nop
293 0002E4F3 # asm("muld r4"); /* multiply by op. ( op ) */
294 0002E4F3 e7 54 muld r4
295 0002E4F5 # asm("nop");
296 0002E4F5 10 nop
297 0002E4F6 # asm("muld r2"); /* multiply by 1.0 ( op ) */
298 0002E4F6 e7 52 muld r2
299 0002E4F8 # asm("nop");
300 0002E4F8 10 nop
301 0002E4F9 # asm("subd r4"); /* subtract the op. ( 0 ) */
302 0002E4F9 d7 54 subd r4
303 0002E4FB # asm("nop");
304 0002E4FB 10 nop
305 0002E4FC # asm("addd r4"); /* add the op. ( op ) */
306 0002E4FC c7 54 addd r4
307 0002E4FE # asm("nop");
308 0002E4FE 10 nop
309 0002E4FF # asm("std r6"); /* store the result ( op ) */
310 0002E4FF 27 56 std r6
311 0002E501 # if( force_loop )
312 0002E501 5d effffffd81 tstl _force_loop
313 0002E507 31 02 jeql L253
314 0002E509 # asm("brb _pipe13_2_lp1");; /* run the loop again */
315 0002E509 11 c9 brb _pipe13_2_lp1
316 0002E50B L253:
317 0002E50B # /*
318 0002E50B # * verify the results
319 0002E50B # */
320 0002E50B # asm("movl r6,_sgl_value_3"); /* get the result */
321 0002E50B 0d 56 effffffd76 movl r6,_sgl_value_3
322 0002E512 # asm("movl r7,_sgl_value_4");
323 0002E512 0d 57 effffffd6f movl r7,_sgl_value_4
324 0002E519 # dbl_st_acc.m = sgl_value_3;
325 0002E519 0d effffffd69 effffffd64 movl _sgl_value_3,_dbl_st_acc
326 0002E524 # dbl_st_acc.l = sgl_value_4;
327 0002E524 0d effffffd5e effffffd5d movl _sgl_value_4,_dbl_st_acc+4
328 0002E52F # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
329 0002E52F # (dbl_st_acc.l != dbl_expected.l) )
330 0002E52F 1d effffffd53 effffffd4e cmpl _dbl_st_acc,_dbl_expected
331 0002E53A 21 0d jneq L9998
332 0002E53C 1d effffffd4a effffffd45 cmpl _dbl_st_acc+4,_dbl_expected+4
333 0002E547 31 42 jeql L254
334 0002E549 L9998:
335 0002E549 # {
336 0002E549 # errcnt++; /* bump the error count */
337 0002E549 6d effffffd39 incl _errcnt
338 0002E54F # if ( prt_error )
339 0002E54F 5d effffffd33 tstl _prt_error
340 0002E555 31 0d jeql L255
341 0002E557 # print_pipe13_er("Reg. Data, 1 NOP");
342 0002E557 .data 1
343 00000dd0 * L256:
344 00000dd0 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NOP\0"
04E4F5000
345 00000de1 * .text
346 0002E557 dd 8f00000dd0 pushl $L256
347 0002E55D fe 08 ef0000090c callf $8,_print_pipe13_er
348 0002E564 # if ( halt_flg )
349 0002E564 L255:
350 0002E564 5d effffffd1e tstl _halt_flg
351 0002E56A 31 0d jeql L257
352 0002E56C # pipe13_er_hlt( subtest );
353 0002E56C dd effffffd16 pushl _subtest
354 0002E572 fe 08 ef00000a45 callf $8,_pipe13_er_hlt
355 0002E579 # if ( loop_on_err ) {
356 0002E579 L257:
357 0002E579 5d effffffd09 tstl _loop_on_err
358 0002E57F 31 0a jeql L258
359 0002E581 # force_loop = TRUE; /* set the force loop flag */
360 0002E581 0d 01 effffffd00 movl $1,_force_loop
361 0002E588 # asm("brw _pipe13_2_lp1"); /* and loop */
362 0002E588 13 ff49 brw _pipe13_2_lp1
363 0002E58B # }
364 0002E58B # } /* end of compare error */
365 0002E58B L258:
366 0002E58B # } while( index++ < max_ldd_1_index );
367 0002E58B L254:
368 0002E58B L251:
369 0002E58B 0d effffffcf7 50 movl _index,r0
370 0002E592 6d effffffcf0 incl _index
371 0002E598 1d 50 effffffce9 cmpl r0,_max_ldd_1_index
372 0002E59F 81 03 13 fed5 jlss L252
373 0002E5A4 L250:
374 0002E5A4 # } /* end of subtest 2 */
375 0002E5A4 40 ret#2
376 0002E5A5 .set L246,0x0
377 0002E5A5 L248:
378 0002E5A5 13 fec5 jbr L249
379 0002E5A8 .data
380 00000db4 * .text
381 0002E5A8 .align 1
382 0002E5A8 .globl _pipe13_3
383 0002E5A8 _pipe13_3:
384 0002E5A8 0000 .word L259
385 0002E5AA #
386 0002E5AA #
387 0002E5AA #
388 0002E5AA #
389 0002E5AA #
390 0002E5AA #
391 0002E5AA # /************************************************************************
392 0002E5AA # *
393 0002E5AA # * SUBTEST 3
394 0002E5AA # * data in registers, 2 NO-OPs
395 0002E5AA # *
396 0002E5AA # ************************************************************************/
397 0002E5AA # pipe13_3()
398 0002E5AA # {
399 0002E5AA 13 013d jbr L261
400 0002E5AD L262:
401 0002E5AD # force_loop = FALSE; /* clear the force_loop flg */
402 0002E5AD 4d effffffcd5 clrl _force_loop
403 0002E5B3 # index = 0;
404 0002E5B3 4d effffffccf clrl _index
405 0002E5B9 # do
406 0002E5B9 L265:
407 0002E5B9 # {
408 0002E5B9 # sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */
409 0002E5B9 0d effffffcc9 50 movl _index,r0
410 0002E5C0 48 04 50 50 shll $4,r0,r0
411 0002E5C4 0d e000000000 effffffcb9 movl _ldd_1_data(r0),_sgl_value_1
412 0002E5CF # sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */
413 0002E5CF 0d effffffcb3 50 movl _index,r0
414 0002E5D6 48 04 50 50 shll $4,r0,r0
415 0002E5DA 0d e000000004 effffffca3 movl _ldd_1_data+4(r0),_sgl_value_2
416 0002E5E5 # sgl_value_7 = 0x40800000; /* get a dbl precision 1.0 */
417 0002E5E5 0d 8f40800000 effffffc98 movl $1082130432,_sgl_value_7
418 0002E5F0 # sgl_value_8 = 0;
419 0002E5F0 4d effffffc92 clrl _sgl_value_8
420 0002E5F6 # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
421 0002E5F6 48 04 effffffc8b 50 shll $4,_index,r0
422 0002E5FE 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
423 0002E605 0d a004 effffffc7f movl 4(r0),_dbl_expected+4
424 0002E60D 0d 60 effffffc74 movl (r0),_dbl_expected
425 0002E614 # /*
426 0002E614 # * If LOOP ON ERROR is set, this is the loop for this subtest.
427 0002E614 # * The force loop flag is set after the first error.
428 0002E614 # */
429 0002E614 # asm("_pipe13_3_lp1:");
430 0002E614 _pipe13_3_lp1:
431 0002E614 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
432 0002E614 0d effffffc6e 54 movl _sgl_value_1,r4
433 0002E61B # asm("movl _sgl_value_2,r5");
434 0002E61B 0d effffffc67 55 movl _sgl_value_2,r5
435 0002E622 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r4/r5 */
436 0002E622 0d effffffc60 52 movl _sgl_value_7,r2
437 0002E629 # asm("movl _sgl_value_8,r3");
438 0002E629 0d effffffc59 53 movl _sgl_value_8,r3
439 0002E630 # asm("ldd r2"); /* load a '1.0' ( 1 ) */
440 0002E630 07 52 ldd r2
441 0002E632 # asm("nop");
442 0002E632 10 nop
443 0002E633 # asm("nop");
444 0002E633 10 nop
445 0002E634 # asm("muld r4"); /* multiply by op. ( op ) */
446 0002E634 e7 54 muld r4
447 0002E636 # asm("nop");
448 0002E636 10 nop
449 0002E637 # asm("nop");
450 0002E637 10 nop
451 0002E638 # asm("muld r2"); /* multiply by 1.0 ( op ) */
452 0002E638 e7 52 muld r2
453 0002E63A # asm("nop");
454 0002E63A 10 nop
455 0002E63B # asm("nop");
456 0002E63B 10 nop
457 0002E63C # asm("subd r4"); /* subtract the op. ( 0 ) */
458 0002E63C d7 54 subd r4
459 0002E63E # asm("nop");
460 0002E63E 10 nop
461 0002E63F # asm("nop");
462 0002E63F 10 nop
463 0002E640 # asm("addd r4"); /* add the op. ( op ) */
464 0002E640 c7 54 addd r4
465 0002E642 # asm("nop");
466 0002E642 10 nop
467 0002E643 # asm("nop");
468 0002E643 10 nop
469 0002E644 # asm("std r6"); /* store the result ( op ) */
470 0002E644 27 56 std r6
471 0002E646 # if( force_loop )
472 0002E646 5d effffffc3c tstl _force_loop
473 0002E64C 31 02 jeql L266
474 0002E64E # asm("brb _pipe13_3_lp1");; /* run the loop again */
475 0002E64E 11 c4 brb _pipe13_3_lp1
476 0002E650 L266:
477 0002E650 # /*
478 0002E650 # * verify the results
479 0002E650 # */
480 0002E650 # asm("movl r6,_sgl_value_3"); /* get the result */
481 0002E650 0d 56 effffffc31 movl r6,_sgl_value_3
482 0002E657 # asm("movl r7,_sgl_value_4");
483 0002E657 0d 57 effffffc2a movl r7,_sgl_value_4
484 0002E65E # dbl_st_acc.m = sgl_value_3;
485 0002E65E 0d effffffc24 effffffc1f movl _sgl_value_3,_dbl_st_acc
486 0002E669 # dbl_st_acc.l = sgl_value_4;
487 0002E669 0d effffffc19 effffffc18 movl _sgl_value_4,_dbl_st_acc+4
488 0002E674 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
489 0002E674 # (dbl_st_acc.l != dbl_expected.l) )
490 0002E674 1d effffffc0e effffffc09 cmpl _dbl_st_acc,_dbl_expected
491 0002E67F 21 0d jneq L9997
492 0002E681 1d effffffc05 effffffc00 cmpl _dbl_st_acc+4,_dbl_expected+4
493 0002E68C 31 42 jeql L267
494 0002E68E L9997:
495 0002E68E # {
496 0002E68E # errcnt++; /* bump the error count */
497 0002E68E 6d effffffbf4 incl _errcnt
498 0002E694 # if ( prt_error )
499 0002E694 5d effffffbee tstl _prt_error
500 0002E69A 31 0d jeql L268
501 0002E69C # print_pipe13_er("Reg. Data, 2 NOPs");
502 0002E69C .data 1
503 00000de1 * L269:
504 00000de1 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NOPs\0"
04E4F507300
505 00000df3 * .text
506 0002E69C dd 8f00000de1 pushl $L269
507 0002E6A2 fe 08 ef000007c7 callf $8,_print_pipe13_er
508 0002E6A9 # if ( halt_flg )
509 0002E6A9 L268:
510 0002E6A9 5d effffffbd9 tstl _halt_flg
511 0002E6AF 31 0d jeql L270
512 0002E6B1 # pipe13_er_hlt( subtest );
513 0002E6B1 dd effffffbd1 pushl _subtest
514 0002E6B7 fe 08 ef00000900 callf $8,_pipe13_er_hlt
515 0002E6BE # if ( loop_on_err ) {
516 0002E6BE L270:
517 0002E6BE 5d effffffbc4 tstl _loop_on_err
518 0002E6C4 31 0a jeql L271
519 0002E6C6 # force_loop = TRUE; /* set the force loop flag */
520 0002E6C6 0d 01 effffffbbb movl $1,_force_loop
521 0002E6CD # asm("brw _pipe13_3_lp1"); /* and loop */
522 0002E6CD 13 ff44 brw _pipe13_3_lp1
523 0002E6D0 # }
524 0002E6D0 # } /* end of compare error */
525 0002E6D0 L271:
526 0002E6D0 # } while( index++ < max_ldd_1_index );
527 0002E6D0 L267:
528 0002E6D0 L264:
529 0002E6D0 0d effffffbb2 50 movl _index,r0
530 0002E6D7 6d effffffbab incl _index
531 0002E6DD 1d 50 effffffba4 cmpl r0,_max_ldd_1_index
532 0002E6E4 81 03 13 fed0 jlss L265
533 0002E6E9 L263:
534 0002E6E9 # } /* end of subtest 3 */
535 0002E6E9 40 ret#2
536 0002E6EA .set L259,0x0
537 0002E6EA L261:
538 0002E6EA 13 fec0 jbr L262
539 0002E6ED .data
540 00000db4 * .text
541 0002E6ED 00 .align 1
542 0002E6EE .globl _pipe13_4
543 0002E6EE _pipe13_4:
544 0002E6EE 0000 .word L272
545 0002E6F0 #
546 0002E6F0 #
547 0002E6F0 #
548 0002E6F0 #
549 0002E6F0 #
550 0002E6F0 # /************************************************************************
551 0002E6F0 # *
552 0002E6F0 # * SUBTEST 4
553 0002E6F0 # * data in registers, 3 NO-OPs
554 0002E6F0 # *
555 0002E6F0 # ************************************************************************/
556 0002E6F0 # pipe13_4()
557 0002E6F0 # {
558 0002E6F0 13 0142 jbr L274
559 0002E6F3 L275:
560 0002E6F3 # force_loop = FALSE; /* clear the force_loop flg */
561 0002E6F3 4d effffffb8f clrl _force_loop
562 0002E6F9 # index = 0;
563 0002E6F9 4d effffffb89 clrl _index
564 0002E6FF # do
565 0002E6FF L278:
566 0002E6FF # {
567 0002E6FF # sgl_value_1 = ldd_1_data[index].ld.m; /* get the operand's MSW */
568 0002E6FF 0d effffffb83 50 movl _index,r0
569 0002E706 48 04 50 50 shll $4,r0,r0
570 0002E70A 0d e000000000 effffffb73 movl _ldd_1_data(r0),_sgl_value_1
571 0002E715 # sgl_value_2 = ldd_1_data[index].ld.l; /* get the operand's MSW */
572 0002E715 0d effffffb6d 50 movl _index,r0
573 0002E71C 48 04 50 50 shll $4,r0,r0
574 0002E720 0d e000000004 effffffb5d movl _ldd_1_data+4(r0),_sgl_value_2
575 0002E72B # sgl_value_7 = 0x40800000; /* get a dbl precision 1.0 */
576 0002E72B 0d 8f40800000 effffffb52 movl $1082130432,_sgl_value_7
577 0002E736 # sgl_value_8 = 0;
578 0002E736 4d effffffb4c clrl _sgl_value_8
579 0002E73C # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
580 0002E73C 48 04 effffffb45 50 shll $4,_index,r0
581 0002E744 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
582 0002E74B 0d a004 effffffb39 movl 4(r0),_dbl_expected+4
583 0002E753 0d 60 effffffb2e movl (r0),_dbl_expected
584 0002E75A # /*
585 0002E75A # * If LOOP ON ERROR is set, this is the loop for this subtest.
586 0002E75A # * The force loop flag is set after the first error.
587 0002E75A # */
588 0002E75A # asm("_pipe13_4_lp1:");
589 0002E75A _pipe13_4_lp1:
590 0002E75A # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
591 0002E75A 0d effffffb28 54 movl _sgl_value_1,r4
592 0002E761 # asm("movl _sgl_value_2,r5");
593 0002E761 0d effffffb21 55 movl _sgl_value_2,r5
594 0002E768 # asm("movl _sgl_value_7,r2"); /* move a '1.0' to r4/r5 */
595 0002E768 0d effffffb1a 52 movl _sgl_value_7,r2
596 0002E76F # asm("movl _sgl_value_8,r3");
597 0002E76F 0d effffffb13 53 movl _sgl_value_8,r3
598 0002E776 # asm("ldd r2"); /* load a '1.0' ( 1 ) */
599 0002E776 07 52 ldd r2
600 0002E778 # asm("nop");
601 0002E778 10 nop
602 0002E779 # asm("nop");
603 0002E779 10 nop
604 0002E77A # asm("nop");
605 0002E77A 10 nop
606 0002E77B # asm("muld r4"); /* multiply by op. ( op ) */
607 0002E77B e7 54 muld r4
608 0002E77D # asm("nop");
609 0002E77D 10 nop
610 0002E77E # asm("nop");
611 0002E77E 10 nop
612 0002E77F # asm("nop");
613 0002E77F 10 nop
614 0002E780 # asm("muld r2"); /* multiply by 1.0 ( op ) */
615 0002E780 e7 52 muld r2
616 0002E782 # asm("nop");
617 0002E782 10 nop
618 0002E783 # asm("nop");
619 0002E783 10 nop
620 0002E784 # asm("nop");
621 0002E784 10 nop
622 0002E785 # asm("subd r4"); /* subtract the op. ( 0 ) */
623 0002E785 d7 54 subd r4
624 0002E787 # asm("nop");
625 0002E787 10 nop
626 0002E788 # asm("nop");
627 0002E788 10 nop
628 0002E789 # asm("nop");
629 0002E789 10 nop
630 0002E78A # asm("addd r4"); /* add the op. ( op ) */
631 0002E78A c7 54 addd r4
632 0002E78C # asm("nop");
633 0002E78C 10 nop
634 0002E78D # asm("nop");
635 0002E78D 10 nop
636 0002E78E # asm("nop");
637 0002E78E 10 nop
638 0002E78F # asm("std r6"); /* store the result ( op ) */
639 0002E78F 27 56 std r6
640 0002E791 # if( force_loop )
641 0002E791 5d effffffaf1 tstl _force_loop
642 0002E797 31 02 jeql L279
643 0002E799 # asm("brb _pipe13_4_lp1");; /* run the loop again */
644 0002E799 11 bf brb _pipe13_4_lp1
645 0002E79B L279:
646 0002E79B # /*
647 0002E79B # * verify the results
648 0002E79B # */
649 0002E79B # asm("movl r6,_sgl_value_3"); /* get the result */
650 0002E79B 0d 56 effffffae6 movl r6,_sgl_value_3
651 0002E7A2 # asm("movl r7,_sgl_value_4");
652 0002E7A2 0d 57 effffffadf movl r7,_sgl_value_4
653 0002E7A9 # dbl_st_acc.m = sgl_value_3;
654 0002E7A9 0d effffffad9 effffffad4 movl _sgl_value_3,_dbl_st_acc
655 0002E7B4 # dbl_st_acc.l = sgl_value_4;
656 0002E7B4 0d efffffface effffffacd movl _sgl_value_4,_dbl_st_acc+4
657 0002E7BF # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
658 0002E7BF # (dbl_st_acc.l != dbl_expected.l) )
659 0002E7BF 1d effffffac3 effffffabe cmpl _dbl_st_acc,_dbl_expected
660 0002E7CA 21 0d jneq L9996
661 0002E7CC 1d effffffaba effffffab5 cmpl _dbl_st_acc+4,_dbl_expected+4
662 0002E7D7 31 42 jeql L280
663 0002E7D9 L9996:
664 0002E7D9 # {
665 0002E7D9 # errcnt++; /* bump the error count */
666 0002E7D9 6d effffffaa9 incl _errcnt
667 0002E7DF # if ( prt_error )
668 0002E7DF 5d effffffaa3 tstl _prt_error
669 0002E7E5 31 0d jeql L281
670 0002E7E7 # print_pipe13_er("Reg. Data, 3 NOPs");
671 0002E7E7 .data 1
672 00000df3 * L282:
673 00000df3 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NOPs\0"
04E4F507300
674 00000e05 * .text
675 0002E7E7 dd 8f00000df3 pushl $L282
676 0002E7ED fe 08 ef0000067c callf $8,_print_pipe13_er
677 0002E7F4 # if ( halt_flg )
678 0002E7F4 L281:
679 0002E7F4 5d effffffa8e tstl _halt_flg
680 0002E7FA 31 0d jeql L283
681 0002E7FC # pipe13_er_hlt( subtest );
682 0002E7FC dd effffffa86 pushl _subtest
683 0002E802 fe 08 ef000007b5 callf $8,_pipe13_er_hlt
684 0002E809 # if ( loop_on_err ) {
685 0002E809 L283:
686 0002E809 5d effffffa79 tstl _loop_on_err
687 0002E80F 31 0a jeql L284
688 0002E811 # force_loop = TRUE; /* set the force loop flag */
689 0002E811 0d 01 effffffa70 movl $1,_force_loop
690 0002E818 # asm("brw _pipe13_4_lp1"); /* and loop */
691 0002E818 13 ff3f brw _pipe13_4_lp1
692 0002E81B # }
693 0002E81B # } /* end of compare error */
694 0002E81B L284:
695 0002E81B # } while( index++ < max_ldd_1_index );
696 0002E81B L280:
697 0002E81B L277:
698 0002E81B 0d effffffa67 50 movl _index,r0
699 0002E822 6d effffffa60 incl _index
700 0002E828 1d 50 effffffa59 cmpl r0,_max_ldd_1_index
701 0002E82F 81 03 13 fecb jlss L278
702 0002E834 L276:
703 0002E834 # } /* end of subtest 4 */
704 0002E834 40 ret#2
705 0002E835 .set L272,0x0
706 0002E835 L274:
707 0002E835 13 febb jbr L275
708 0002E838 .data
709 00000db4 * .text
710 0002E838 .align 1
711 0002E838 .globl _pipe13_5
712 0002E838 _pipe13_5:
713 0002E838 0000 .word L285
714 0002E83A #
715 0002E83A #
716 0002E83A #
717 0002E83A #
718 0002E83A #
719 0002E83A #
720 0002E83A #
721 0002E83A #
722 0002E83A # /************************************************************************
723 0002E83A # *
724 0002E83A # * SUBTEST 5
725 0002E83A # * data in cache, no NO-OPs
726 0002E83A # *
727 0002E83A # ************************************************************************/
728 0002E83A # pipe13_5()
729 0002E83A # {
730 0002E83A 13 00fd jbr L287
731 0002E83D L288:
732 0002E83D # force_loop = FALSE; /* clear the force_loop flg */
733 0002E83D 4d effffffa45 clrl _force_loop
734 0002E843 # index = 0;
735 0002E843 4d effffffa3f clrl _index
736 0002E849 # do
737 0002E849 L291:
738 0002E849 # {
739 0002E849 # dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */
740 0002E849 48 04 effffffa38 50 shll $4,_index,r0
741 0002E851 0c 8f00000000 50 addl2 $_ldd_1_data,r0
742 0002E858 0d a004 effffffa2c movl 4(r0),_dbl_value_1+4
743 0002E860 0d 60 effffffa21 movl (r0),_dbl_value_1
744 0002E867 # dbl_value_2.m = 0x40800000; /* set the '1.0' operand */
745 0002E867 0d 8f40800000 effffffa16 movl $1082130432,_dbl_value_2
746 0002E872 # dbl_value_2.l = 0;
747 0002E872 4d effffffa14 clrl _dbl_value_2+4
748 0002E878 # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
749 0002E878 48 04 effffffa09 50 shll $4,_index,r0
750 0002E880 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
751 0002E887 0d a004 effffff9fd movl 4(r0),_dbl_expected+4
752 0002E88F 0d 60 effffff9f2 movl (r0),_dbl_expected
753 0002E896 # /*
754 0002E896 # * If LOOP ON ERROR is set, this is the loop for this subtest.
755 0002E896 # * The force loop flag is set after the first error.
756 0002E896 # */
757 0002E896 # asm("_pipe13_5_lp1:");
758 0002E896 _pipe13_5_lp1:
759 0002E896 # asm("ldd _dbl_value_2"); /* load a '1.0' ( 1 ) */
760 0002E896 07 effffff9ec ldd _dbl_value_2
761 0002E89C # asm("muld _dbl_value_1"); /* multiply by op. ( op ) */
762 0002E89C e7 effffff9e6 muld _dbl_value_1
763 0002E8A2 # asm("muld _dbl_value_2"); /* multiply by 1.0 ( op ) */
764 0002E8A2 e7 effffff9e0 muld _dbl_value_2
765 0002E8A8 # asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */
766 0002E8A8 d7 effffff9da subd _dbl_value_1
767 0002E8AE # asm("addd _dbl_value_1"); /* add the op. ( op ) */
768 0002E8AE c7 effffff9d4 addd _dbl_value_1
769 0002E8B4 # asm("std _dbl_st_acc"); /* store the result ( op ) */
770 0002E8B4 27 effffff9ce std _dbl_st_acc
771 0002E8BA # if( force_loop )
772 0002E8BA 5d effffff9c8 tstl _force_loop
773 0002E8C0 31 02 jeql L292
774 0002E8C2 # asm("brb _pipe13_5_lp1");; /* run the loop again */
775 0002E8C2 11 d2 brb _pipe13_5_lp1
776 0002E8C4 L292:
777 0002E8C4 # /*
778 0002E8C4 # * verify the results
779 0002E8C4 # */
780 0002E8C4 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
781 0002E8C4 # (dbl_st_acc.l != dbl_expected.l) )
782 0002E8C4 1d effffff9be effffff9b9 cmpl _dbl_st_acc,_dbl_expected
783 0002E8CF 21 0d jneq L9995
784 0002E8D1 1d effffff9b5 effffff9b0 cmpl _dbl_st_acc+4,_dbl_expected+4
785 0002E8DC 31 42 jeql L293
786 0002E8DE L9995:
787 0002E8DE # {
788 0002E8DE # errcnt++; /* bump the error count */
789 0002E8DE 6d effffff9a4 incl _errcnt
790 0002E8E4 # if ( prt_error )
791 0002E8E4 5d effffff99e tstl _prt_error
792 0002E8EA 31 0d jeql L294
793 0002E8EC # print_pipe13_er("Cache Data, no NOPs");
794 0002E8EC .data 1
795 00000e05 * L295:
796 00000e05 * 436163686520446174612C206 .ascii "Cache Data, no NOPs\0"
E6F204E4F507300
797 00000e19 * .text
798 0002E8EC dd 8f00000e05 pushl $L295
799 0002E8F2 fe 08 ef00000577 callf $8,_print_pipe13_er
800 0002E8F9 # if ( halt_flg )
801 0002E8F9 L294:
802 0002E8F9 5d effffff989 tstl _halt_flg
803 0002E8FF 31 0d jeql L296
804 0002E901 # pipe13_er_hlt( subtest );
805 0002E901 dd effffff981 pushl _subtest
806 0002E907 fe 08 ef000006b0 callf $8,_pipe13_er_hlt
807 0002E90E # if ( loop_on_err ) {
808 0002E90E L296:
809 0002E90E 5d effffff974 tstl _loop_on_err
810 0002E914 31 0a jeql L297
811 0002E916 # force_loop = TRUE; /* set the force loop flag */
812 0002E916 0d 01 effffff96b movl $1,_force_loop
813 0002E91D # asm("brw _pipe13_5_lp1"); /* and loop */
814 0002E91D 13 ff76 brw _pipe13_5_lp1
815 0002E920 # }
816 0002E920 # } /* end of compare error */
817 0002E920 L297:
818 0002E920 # } while( index++ < max_ldd_1_index );
819 0002E920 L293:
820 0002E920 L290:
821 0002E920 0d effffff962 50 movl _index,r0
822 0002E927 6d effffff95b incl _index
823 0002E92D 1d 50 effffff954 cmpl r0,_max_ldd_1_index
824 0002E934 81 03 13 ff10 jlss L291
825 0002E939 L289:
826 0002E939 # } /* end of subtest 5 */
827 0002E939 40 ret#2
828 0002E93A .set L285,0x0
829 0002E93A L287:
830 0002E93A 13 ff00 jbr L288
831 0002E93D .data
832 00000db4 * .text
833 0002E93D 00 .align 1
834 0002E93E .globl _pipe13_6
835 0002E93E _pipe13_6:
836 0002E93E 0000 .word L298
837 0002E940 #
838 0002E940 #
839 0002E940 #
840 0002E940 #
841 0002E940 #
842 0002E940 #
843 0002E940 #
844 0002E940 #
845 0002E940 # /************************************************************************
846 0002E940 # *
847 0002E940 # * SUBTEST 6
848 0002E940 # * data in cache, 1 NO-OP
849 0002E940 # *
850 0002E940 # ************************************************************************/
851 0002E940 # pipe13_6()
852 0002E940 # {
853 0002E940 13 0102 jbr L300
854 0002E943 L301:
855 0002E943 # force_loop = FALSE; /* clear the force_loop flg */
856 0002E943 4d effffff93f clrl _force_loop
857 0002E949 # index = 0;
858 0002E949 4d effffff939 clrl _index
859 0002E94F # do
860 0002E94F L304:
861 0002E94F # {
862 0002E94F # dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */
863 0002E94F 48 04 effffff932 50 shll $4,_index,r0
864 0002E957 0c 8f00000000 50 addl2 $_ldd_1_data,r0
865 0002E95E 0d a004 effffff926 movl 4(r0),_dbl_value_1+4
866 0002E966 0d 60 effffff91b movl (r0),_dbl_value_1
867 0002E96D # dbl_value_2.m = 0x40800000; /* set the '1.0' operand */
868 0002E96D 0d 8f40800000 effffff910 movl $1082130432,_dbl_value_2
869 0002E978 # dbl_value_2.l = 0;
870 0002E978 4d effffff90e clrl _dbl_value_2+4
871 0002E97E # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
872 0002E97E 48 04 effffff903 50 shll $4,_index,r0
873 0002E986 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
874 0002E98D 0d a004 effffff8f7 movl 4(r0),_dbl_expected+4
875 0002E995 0d 60 effffff8ec movl (r0),_dbl_expected
876 0002E99C # /*
877 0002E99C # * If LOOP ON ERROR is set, this is the loop for this subtest.
878 0002E99C # * The force loop flag is set after the first error.
879 0002E99C # */
880 0002E99C # asm("_pipe13_6_lp1:");
881 0002E99C _pipe13_6_lp1:
882 0002E99C # asm("ldd _dbl_value_2"); /* load a '1.0' ( 1 ) */
883 0002E99C 07 effffff8e6 ldd _dbl_value_2
884 0002E9A2 # asm("nop");
885 0002E9A2 10 nop
886 0002E9A3 # asm("muld _dbl_value_1"); /* multiply by op. ( op ) */
887 0002E9A3 e7 effffff8df muld _dbl_value_1
888 0002E9A9 # asm("nop");
889 0002E9A9 10 nop
890 0002E9AA # asm("muld _dbl_value_2"); /* multiply by 1.0 ( op ) */
891 0002E9AA e7 effffff8d8 muld _dbl_value_2
892 0002E9B0 # asm("nop");
893 0002E9B0 10 nop
894 0002E9B1 # asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */
895 0002E9B1 d7 effffff8d1 subd _dbl_value_1
896 0002E9B7 # asm("nop");
897 0002E9B7 10 nop
898 0002E9B8 # asm("addd _dbl_value_1"); /* add the op. ( op ) */
899 0002E9B8 c7 effffff8ca addd _dbl_value_1
900 0002E9BE # asm("nop");
901 0002E9BE 10 nop
902 0002E9BF # asm("std _dbl_st_acc"); /* store the result ( op ) */
903 0002E9BF 27 effffff8c3 std _dbl_st_acc
904 0002E9C5 # if( force_loop )
905 0002E9C5 5d effffff8bd tstl _force_loop
906 0002E9CB 31 02 jeql L305
907 0002E9CD # asm("brb _pipe13_6_lp1");; /* run the loop again */
908 0002E9CD 11 cd brb _pipe13_6_lp1
909 0002E9CF L305:
910 0002E9CF # /*
911 0002E9CF # * verify the results
912 0002E9CF # */
913 0002E9CF # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
914 0002E9CF # (dbl_st_acc.l != dbl_expected.l) )
915 0002E9CF 1d effffff8b3 effffff8ae cmpl _dbl_st_acc,_dbl_expected
916 0002E9DA 21 0d jneq L9994
917 0002E9DC 1d effffff8aa effffff8a5 cmpl _dbl_st_acc+4,_dbl_expected+4
918 0002E9E7 31 42 jeql L306
919 0002E9E9 L9994:
920 0002E9E9 # {
921 0002E9E9 # errcnt++; /* bump the error count */
922 0002E9E9 6d effffff899 incl _errcnt
923 0002E9EF # if ( prt_error )
924 0002E9EF 5d effffff893 tstl _prt_error
925 0002E9F5 31 0d jeql L307
926 0002E9F7 # print_pipe13_er("Cache Data, 1 NOP");
927 0002E9F7 .data 1
928 00000e19 * L308:
929 00000e19 * 436163686520446174612C203 .ascii "Cache Data, 1 NOP\0"
1204E4F5000
930 00000e2b * .text
931 0002E9F7 dd 8f00000e19 pushl $L308
932 0002E9FD fe 08 ef0000046c callf $8,_print_pipe13_er
933 0002EA04 # if ( halt_flg )
934 0002EA04 L307:
935 0002EA04 5d effffff87e tstl _halt_flg
936 0002EA0A 31 0d jeql L309
937 0002EA0C # pipe13_er_hlt( subtest );
938 0002EA0C dd effffff876 pushl _subtest
939 0002EA12 fe 08 ef000005a5 callf $8,_pipe13_er_hlt
940 0002EA19 # if ( loop_on_err ) {
941 0002EA19 L309:
942 0002EA19 5d effffff869 tstl _loop_on_err
943 0002EA1F 31 0a jeql L310
944 0002EA21 # force_loop = TRUE; /* set the force loop flag */
945 0002EA21 0d 01 effffff860 movl $1,_force_loop
946 0002EA28 # asm("brw _pipe13_6_lp1"); /* and loop */
947 0002EA28 13 ff71 brw _pipe13_6_lp1
948 0002EA2B # }
949 0002EA2B # } /* end of compare error */
950 0002EA2B L310:
951 0002EA2B # } while( index++ < max_ldd_1_index );
952 0002EA2B L306:
953 0002EA2B L303:
954 0002EA2B 0d effffff857 50 movl _index,r0
955 0002EA32 6d effffff850 incl _index
956 0002EA38 1d 50 effffff849 cmpl r0,_max_ldd_1_index
957 0002EA3F 81 03 13 ff0b jlss L304
958 0002EA44 L302:
959 0002EA44 # } /* end of subtest 6 */
960 0002EA44 40 ret#2
961 0002EA45 .set L298,0x0
962 0002EA45 L300:
963 0002EA45 13 fefb jbr L301
964 0002EA48 .data
965 00000db4 * .text
966 0002EA48 .align 1
967 0002EA48 .globl _pipe13_7
968 0002EA48 _pipe13_7:
969 0002EA48 0000 .word L311
970 0002EA4A #
971 0002EA4A #
972 0002EA4A #
973 0002EA4A #
974 0002EA4A #
975 0002EA4A #
976 0002EA4A #
977 0002EA4A # /************************************************************************
978 0002EA4A # *
979 0002EA4A # * SUBTEST 7
980 0002EA4A # * data in cache, 2 NO-OPs
981 0002EA4A # *
982 0002EA4A # ************************************************************************/
983 0002EA4A # pipe13_7()
984 0002EA4A # {
985 0002EA4A 13 0107 jbr L313
986 0002EA4D L314:
987 0002EA4D # force_loop = FALSE; /* clear the force_loop flg */
988 0002EA4D 4d effffff835 clrl _force_loop
989 0002EA53 # index = 0;
990 0002EA53 4d effffff82f clrl _index
991 0002EA59 # do
992 0002EA59 L317:
993 0002EA59 # {
994 0002EA59 # dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */
995 0002EA59 48 04 effffff828 50 shll $4,_index,r0
996 0002EA61 0c 8f00000000 50 addl2 $_ldd_1_data,r0
997 0002EA68 0d a004 effffff81c movl 4(r0),_dbl_value_1+4
998 0002EA70 0d 60 effffff811 movl (r0),_dbl_value_1
999 0002EA77 # dbl_value_2.m = 0x40800000; /* set the '1.0' operand */
1000 0002EA77 0d 8f40800000 effffff806 movl $1082130432,_dbl_value_2
1001 0002EA82 # dbl_value_2.l = 0;
1002 0002EA82 4d effffff804 clrl _dbl_value_2+4
1003 0002EA88 # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
1004 0002EA88 48 04 effffff7f9 50 shll $4,_index,r0
1005 0002EA90 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
1006 0002EA97 0d a004 effffff7ed movl 4(r0),_dbl_expected+4
1007 0002EA9F 0d 60 effffff7e2 movl (r0),_dbl_expected
1008 0002EAA6 # /*
1009 0002EAA6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1010 0002EAA6 # * The force loop flag is set after the first error.
1011 0002EAA6 # */
1012 0002EAA6 # asm("_pipe13_7_lp1:");
1013 0002EAA6 _pipe13_7_lp1:
1014 0002EAA6 # asm("ldd _dbl_value_2"); /* load a '1.0' ( 1 ) */
1015 0002EAA6 07 effffff7dc ldd _dbl_value_2
1016 0002EAAC # asm("nop");
1017 0002EAAC 10 nop
1018 0002EAAD # asm("nop");
1019 0002EAAD 10 nop
1020 0002EAAE # asm("muld _dbl_value_1"); /* multiply by op. ( op ) */
1021 0002EAAE e7 effffff7d4 muld _dbl_value_1
1022 0002EAB4 # asm("nop");
1023 0002EAB4 10 nop
1024 0002EAB5 # asm("nop");
1025 0002EAB5 10 nop
1026 0002EAB6 # asm("muld _dbl_value_2"); /* multiply by 1.0 ( op ) */
1027 0002EAB6 e7 effffff7cc muld _dbl_value_2
1028 0002EABC # asm("nop");
1029 0002EABC 10 nop
1030 0002EABD # asm("nop");
1031 0002EABD 10 nop
1032 0002EABE # asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */
1033 0002EABE d7 effffff7c4 subd _dbl_value_1
1034 0002EAC4 # asm("nop");
1035 0002EAC4 10 nop
1036 0002EAC5 # asm("nop");
1037 0002EAC5 10 nop
1038 0002EAC6 # asm("addd _dbl_value_1"); /* add the op. ( op ) */
1039 0002EAC6 c7 effffff7bc addd _dbl_value_1
1040 0002EACC # asm("nop");
1041 0002EACC 10 nop
1042 0002EACD # asm("nop");
1043 0002EACD 10 nop
1044 0002EACE # asm("std _dbl_st_acc"); /* store the result ( op ) */
1045 0002EACE 27 effffff7b4 std _dbl_st_acc
1046 0002EAD4 # if( force_loop )
1047 0002EAD4 5d effffff7ae tstl _force_loop
1048 0002EADA 31 02 jeql L318
1049 0002EADC # asm("brb _pipe13_7_lp1");; /* run the loop again */
1050 0002EADC 11 c8 brb _pipe13_7_lp1
1051 0002EADE L318:
1052 0002EADE # /*
1053 0002EADE # * verify the results
1054 0002EADE # */
1055 0002EADE # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1056 0002EADE # (dbl_st_acc.l != dbl_expected.l) )
1057 0002EADE 1d effffff7a4 effffff79f cmpl _dbl_st_acc,_dbl_expected
1058 0002EAE9 21 0d jneq L9993
1059 0002EAEB 1d effffff79b effffff796 cmpl _dbl_st_acc+4,_dbl_expected+4
1060 0002EAF6 31 42 jeql L319
1061 0002EAF8 L9993:
1062 0002EAF8 # {
1063 0002EAF8 # errcnt++; /* bump the error count */
1064 0002EAF8 6d effffff78a incl _errcnt
1065 0002EAFE # if ( prt_error )
1066 0002EAFE 5d effffff784 tstl _prt_error
1067 0002EB04 31 0d jeql L320
1068 0002EB06 # print_pipe13_er("Cache Data, 2 NOPs");
1069 0002EB06 .data 1
1070 00000e2b * L321:
1071 00000e2b * 436163686520446174612C203 .ascii "Cache Data, 2 NOPs\0"
2204E4F507300
1072 00000e3e * .text
1073 0002EB06 dd 8f00000e2b pushl $L321
1074 0002EB0C fe 08 ef0000035d callf $8,_print_pipe13_er
1075 0002EB13 # if ( halt_flg )
1076 0002EB13 L320:
1077 0002EB13 5d effffff76f tstl _halt_flg
1078 0002EB19 31 0d jeql L322
1079 0002EB1B # pipe13_er_hlt( subtest );
1080 0002EB1B dd effffff767 pushl _subtest
1081 0002EB21 fe 08 ef00000496 callf $8,_pipe13_er_hlt
1082 0002EB28 # if ( loop_on_err ) {
1083 0002EB28 L322:
1084 0002EB28 5d effffff75a tstl _loop_on_err
1085 0002EB2E 31 0a jeql L323
1086 0002EB30 # force_loop = TRUE; /* set the force loop flag */
1087 0002EB30 0d 01 effffff751 movl $1,_force_loop
1088 0002EB37 # asm("brw _pipe13_7_lp1"); /* and loop */
1089 0002EB37 13 ff6c brw _pipe13_7_lp1
1090 0002EB3A # }
1091 0002EB3A # } /* end of compare error */
1092 0002EB3A L323:
1093 0002EB3A # } while( index++ < max_ldd_1_index );
1094 0002EB3A L319:
1095 0002EB3A L316:
1096 0002EB3A 0d effffff748 50 movl _index,r0
1097 0002EB41 6d effffff741 incl _index
1098 0002EB47 1d 50 effffff73a cmpl r0,_max_ldd_1_index
1099 0002EB4E 81 03 13 ff06 jlss L317
1100 0002EB53 L315:
1101 0002EB53 # } /* end of subtest 7 */
1102 0002EB53 40 ret#2
1103 0002EB54 .set L311,0x0
1104 0002EB54 L313:
1105 0002EB54 13 fef6 jbr L314
1106 0002EB57 .data
1107 00000db4 * .text
1108 0002EB57 00 .align 1
1109 0002EB58 .globl _pipe13_8
1110 0002EB58 _pipe13_8:
1111 0002EB58 0000 .word L324
1112 0002EB5A #
1113 0002EB5A #
1114 0002EB5A #
1115 0002EB5A #
1116 0002EB5A #
1117 0002EB5A #
1118 0002EB5A #
1119 0002EB5A #
1120 0002EB5A # /************************************************************************
1121 0002EB5A # *
1122 0002EB5A # * SUBTEST 8
1123 0002EB5A # * data in cache, 3 NO-OPs
1124 0002EB5A # *
1125 0002EB5A # ************************************************************************/
1126 0002EB5A # pipe13_8()
1127 0002EB5A # {
1128 0002EB5A 13 010c jbr L326
1129 0002EB5D L327:
1130 0002EB5D # force_loop = FALSE; /* clear the force_loop flg */
1131 0002EB5D 4d effffff725 clrl _force_loop
1132 0002EB63 # index = 0;
1133 0002EB63 4d effffff71f clrl _index
1134 0002EB69 # do
1135 0002EB69 L330:
1136 0002EB69 # {
1137 0002EB69 # dbl_value_1 = ldd_1_data[index].ld; /* get the operand's MSW */
1138 0002EB69 48 04 effffff718 50 shll $4,_index,r0
1139 0002EB71 0c 8f00000000 50 addl2 $_ldd_1_data,r0
1140 0002EB78 0d a004 effffff70c movl 4(r0),_dbl_value_1+4
1141 0002EB80 0d 60 effffff701 movl (r0),_dbl_value_1
1142 0002EB87 # dbl_value_2.m = 0x40800000; /* set the '1.0' operand */
1143 0002EB87 0d 8f40800000 effffff6f6 movl $1082130432,_dbl_value_2
1144 0002EB92 # dbl_value_2.l = 0;
1145 0002EB92 4d effffff6f4 clrl _dbl_value_2+4
1146 0002EB98 # dbl_expected = ldd_1_data[index].exp; /* get the expected results */
1147 0002EB98 48 04 effffff6e9 50 shll $4,_index,r0
1148 0002EBA0 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
1149 0002EBA7 0d a004 effffff6dd movl 4(r0),_dbl_expected+4
1150 0002EBAF 0d 60 effffff6d2 movl (r0),_dbl_expected
1151 0002EBB6 # /*
1152 0002EBB6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1153 0002EBB6 # * The force loop flag is set after the first error.
1154 0002EBB6 # */
1155 0002EBB6 # asm("_pipe13_8_lp1:");
1156 0002EBB6 _pipe13_8_lp1:
1157 0002EBB6 # asm("ldd _dbl_value_2"); /* load a '1.0' ( 1 ) */
1158 0002EBB6 07 effffff6cc ldd _dbl_value_2
1159 0002EBBC # asm("nop");
1160 0002EBBC 10 nop
1161 0002EBBD # asm("nop");
1162 0002EBBD 10 nop
1163 0002EBBE # asm("nop");
1164 0002EBBE 10 nop
1165 0002EBBF # asm("muld _dbl_value_1"); /* multiply by op. ( op ) */
1166 0002EBBF e7 effffff6c3 muld _dbl_value_1
1167 0002EBC5 # asm("nop");
1168 0002EBC5 10 nop
1169 0002EBC6 # asm("nop");
1170 0002EBC6 10 nop
1171 0002EBC7 # asm("nop");
1172 0002EBC7 10 nop
1173 0002EBC8 # asm("muld _dbl_value_2"); /* multiply by 1.0 ( op ) */
1174 0002EBC8 e7 effffff6ba muld _dbl_value_2
1175 0002EBCE # asm("nop");
1176 0002EBCE 10 nop
1177 0002EBCF # asm("nop");
1178 0002EBCF 10 nop
1179 0002EBD0 # asm("nop");
1180 0002EBD0 10 nop
1181 0002EBD1 # asm("subd _dbl_value_1"); /* subtract the op. ( 0 ) */
1182 0002EBD1 d7 effffff6b1 subd _dbl_value_1
1183 0002EBD7 # asm("nop");
1184 0002EBD7 10 nop
1185 0002EBD8 # asm("nop");
1186 0002EBD8 10 nop
1187 0002EBD9 # asm("nop");
1188 0002EBD9 10 nop
1189 0002EBDA # asm("addd _dbl_value_1"); /* add the op. ( op ) */
1190 0002EBDA c7 effffff6a8 addd _dbl_value_1
1191 0002EBE0 # asm("nop");
1192 0002EBE0 10 nop
1193 0002EBE1 # asm("nop");
1194 0002EBE1 10 nop
1195 0002EBE2 # asm("nop");
1196 0002EBE2 10 nop
1197 0002EBE3 # asm("std _dbl_st_acc"); /* store the result ( op ) */
1198 0002EBE3 27 effffff69f std _dbl_st_acc
1199 0002EBE9 # if( force_loop )
1200 0002EBE9 5d effffff699 tstl _force_loop
1201 0002EBEF 31 02 jeql L331
1202 0002EBF1 # asm("brb _pipe13_8_lp1");; /* run the loop again */
1203 0002EBF1 11 c3 brb _pipe13_8_lp1
1204 0002EBF3 L331:
1205 0002EBF3 # /*
1206 0002EBF3 # * verify the results
1207 0002EBF3 # */
1208 0002EBF3 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1209 0002EBF3 # (dbl_st_acc.l != dbl_expected.l) )
1210 0002EBF3 1d effffff68f effffff68a cmpl _dbl_st_acc,_dbl_expected
1211 0002EBFE 21 0d jneq L9992
1212 0002EC00 1d effffff686 effffff681 cmpl _dbl_st_acc+4,_dbl_expected+4
1213 0002EC0B 31 42 jeql L332
1214 0002EC0D L9992:
1215 0002EC0D # {
1216 0002EC0D # errcnt++; /* bump the error count */
1217 0002EC0D 6d effffff675 incl _errcnt
1218 0002EC13 # if ( prt_error )
1219 0002EC13 5d effffff66f tstl _prt_error
1220 0002EC19 31 0d jeql L333
1221 0002EC1B # print_pipe13_er("Cache Data, 3 NOPs");
1222 0002EC1B .data 1
1223 00000e3e * L334:
1224 00000e3e * 436163686520446174612C203 .ascii "Cache Data, 3 NOPs\0"
3204E4F507300
1225 00000e51 * .text
1226 0002EC1B dd 8f00000e3e pushl $L334
1227 0002EC21 fe 08 ef00000248 callf $8,_print_pipe13_er
1228 0002EC28 # if ( halt_flg )
1229 0002EC28 L333:
1230 0002EC28 5d effffff65a tstl _halt_flg
1231 0002EC2E 31 0d jeql L335
1232 0002EC30 # pipe13_er_hlt( subtest );
1233 0002EC30 dd effffff652 pushl _subtest
1234 0002EC36 fe 08 ef00000381 callf $8,_pipe13_er_hlt
1235 0002EC3D # if ( loop_on_err ) {
1236 0002EC3D L335:
1237 0002EC3D 5d effffff645 tstl _loop_on_err
1238 0002EC43 31 0a jeql L336
1239 0002EC45 # force_loop = TRUE; /* set the force loop flag */
1240 0002EC45 0d 01 effffff63c movl $1,_force_loop
1241 0002EC4C # asm("brw _pipe13_8_lp1"); /* and loop */
1242 0002EC4C 13 ff67 brw _pipe13_8_lp1
1243 0002EC4F # }
1244 0002EC4F # } /* end of compare error */
1245 0002EC4F L336:
1246 0002EC4F # } while( index++ < max_ldd_1_index );
1247 0002EC4F L332:
1248 0002EC4F L329:
1249 0002EC4F 0d effffff633 50 movl _index,r0
1250 0002EC56 6d effffff62c incl _index
1251 0002EC5C 1d 50 effffff625 cmpl r0,_max_ldd_1_index
1252 0002EC63 81 03 13 ff01 jlss L330
1253 0002EC68 L328:
1254 0002EC68 # } /* end of subtest 8 */
1255 0002EC68 40 ret#2
1256 0002EC69 .set L324,0x0
1257 0002EC69 L326:
1258 0002EC69 13 fef1 jbr L327
1259 0002EC6C .data
1260 00000db4 * .text
1261 0002EC6C .align 1
1262 0002EC6C .globl _pipe13_9
1263 0002EC6C _pipe13_9:
1264 0002EC6C 0000 .word L337
1265 0002EC6E #
1266 0002EC6E #
1267 0002EC6E #
1268 0002EC6E #
1269 0002EC6E #
1270 0002EC6E #
1271 0002EC6E #
1272 0002EC6E # /******************************************************************************
1273 0002EC6E # *
1274 0002EC6E # * SUBTEST 9
1275 0002EC6E # *
1276 0002EC6E # * Get the data via the FRAME POINTER ( quad word indexed )
1277 0002EC6E # *
1278 0002EC6E # * ADDRESSES OF DATA OPERANDS INDEX DATA
1279 0002EC6E # * pointer_data,-4 ( FP+24 ) 3 the STF result goes here
1280 0002EC6E # * pointer_data-8,-12 ( FP+16 ) 2 <operand data>
1281 0002EC6E # * pointer_data-16,-20 ( FP+8 ) 1 < '1.0' data>
1282 0002EC6E # * pointer_data-24,-28 ( FP ) 0 point the frame pointer here
1283 0002EC6E # *
1284 0002EC6E # * NOTE: The double precision instructions are using Quad Word indexing.
1285 0002EC6E # ******************************************************************************/
1286 0002EC6E # pipe13_9()
1287 0002EC6E # {
1288 0002EC6E 13 01fc jbr L339
1289 0002EC71 L340:
1290 0002EC71 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1291 0002EC71 ed 6d effffff610 moval (r13),_pre_event_fp
1292 0002EC78 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1293 0002EC78 ed 6e effffff609 moval (r14),_pre_event_sp
1294 0002EC7F # force_loop = FALSE; /* clear force_loop flag */
1295 0002EC7F 4d effffff603 clrl _force_loop
1296 0002EC85 # index = 0;
1297 0002EC85 4d effffff5fd clrl _index
1298 0002EC8B # do
1299 0002EC8B L343:
1300 0002EC8B # {
1301 0002EC8B # sgl_value_1 = ldd_1_data[index].ld.m; /* get operand 1's MSW */
1302 0002EC8B 0d effffff5f7 50 movl _index,r0
1303 0002EC92 48 04 50 50 shll $4,r0,r0
1304 0002EC96 0d e000000000 effffff5e7 movl _ldd_1_data(r0),_sgl_value_1
1305 0002ECA1 # sgl_value_2 = ldd_1_data[index].ld.l; /* get operand 1's LSW */
1306 0002ECA1 0d effffff5e1 50 movl _index,r0
1307 0002ECA8 48 04 50 50 shll $4,r0,r0
1308 0002ECAC 0d e000000004 effffff5d1 movl _ldd_1_data+4(r0),_sgl_value_2
1309 0002ECB7 # sgl_value_7 = 0x40800000; /* get the '1.0' data */
1310 0002ECB7 0d 8f40800000 effffff5c6 movl $1082130432,_sgl_value_7
1311 0002ECC2 # sgl_value_8 = 0;
1312 0002ECC2 4d effffff5c0 clrl _sgl_value_8
1313 0002ECC8 # dbl_expected = ldd_1_data[index].exp; /* get expected results */
1314 0002ECC8 48 04 effffff5b9 50 shll $4,_index,r0
1315 0002ECD0 0c 8f00000008 50 addl2 $_ldd_1_data+8,r0
1316 0002ECD7 0d a004 effffff5ad movl 4(r0),_dbl_expected+4
1317 0002ECDF 0d 60 effffff5a2 movl (r0),_dbl_expected
1318 0002ECE6 # /*
1319 0002ECE6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1320 0002ECE6 # * The force loop flag is set after the first error.
1321 0002ECE6 # */
1322 0002ECE6 # asm("_pipe13_9_lp1:");
1323 0002ECE6 _pipe13_9_lp1:
1324 0002ECE6 # asm("moval _pointer_data,_sgl_value_9");/* get store data's addr */
1325 0002ECE6 ed effffff59c effffff597 moval _pointer_data,_sgl_value_9
1326 0002ECF1 # sgl_value_9 -= 8;
1327 0002ECF1 2c 08 effffff590 subl2 $8,_sgl_value_9
1328 0002ECF8 # asm("movl _sgl_value_2,*_sgl_value_9"); /* set the operand's LSW */
1329 0002ECF8 0d effffff58a fffffff585 movl _sgl_value_2,*_sgl_value_9
1330 0002ED03 # sgl_value_9 -= 4;
1331 0002ED03 2c 04 effffff57e subl2 $4,_sgl_value_9
1332 0002ED0A # asm("movl _sgl_value_1,*_sgl_value_9"); /* set the operand's MSW */
1333 0002ED0A 0d effffff578 fffffff573 movl _sgl_value_1,*_sgl_value_9
1334 0002ED15 # sgl_value_9 -= 4;
1335 0002ED15 2c 04 effffff56c subl2 $4,_sgl_value_9
1336 0002ED1C # asm("movl _sgl_value_8,*_sgl_value_9"); /* set '1.0' data's LSW */
1337 0002ED1C 0d effffff566 fffffff561 movl _sgl_value_8,*_sgl_value_9
1338 0002ED27 # sgl_value_9 -= 4;
1339 0002ED27 2c 04 effffff55a subl2 $4,_sgl_value_9
1340 0002ED2E # asm("movl _sgl_value_7,*_sgl_value_9"); /* set '1.0' data's MSW */
1341 0002ED2E 0d effffff554 fffffff54f movl _sgl_value_7,*_sgl_value_9
1342 0002ED39 # sgl_value_9 -= 8; /* get the FP addr to use */
1343 0002ED39 2c 08 effffff548 subl2 $8,_sgl_value_9
1344 0002ED40 # asm("movl _sgl_value_9,r13"); /* set the FRAME POINTER */
1345 0002ED40 0d effffff542 5d movl _sgl_value_9,r13
1346 0002ED47 # asm("movl $1,r5"); /* r5 index = 1 quadwords */
1347 0002ED47 0d 01 55 movl $1,r5
1348 0002ED4A # asm("movl $2,r6"); /* r6 index = 2 quadwords */
1349 0002ED4A 0d 02 56 movl $2,r6
1350 0002ED4D # asm("movl $3,r7"); /* r7 index = 3 quadwords */
1351 0002ED4D 0d 03 57 movl $3,r7
1352 0002ED50 # asm("ldd (r13)[r5]"); /* load a '1.0' ( 1 ) */
1353 0002ED50 07 456d ldd (r13)[r5]
1354 0002ED53 # asm("muld (r13)[r6]"); /* multiply by op. ( op ) */
1355 0002ED53 e7 466d muld (r13)[r6]
1356 0002ED56 # asm("muld (r13)[r5]"); /* multiply by 1.0 ( op ) */
1357 0002ED56 e7 456d muld (r13)[r5]
1358 0002ED59 # asm("subd (r13)[r6]"); /* subtract the op. ( 0 ) */
1359 0002ED59 d7 466d subd (r13)[r6]
1360 0002ED5C # asm("addd (r13)[r6]"); /* add the op. ( op ) */
1361 0002ED5C c7 466d addd (r13)[r6]
1362 0002ED5F # asm("std (r13)[r7]"); /* store the result ( op ) */
1363 0002ED5F 27 476d std (r13)[r7]
1364 0002ED62 # if( force_loop )
1365 0002ED62 5d effffff520 tstl _force_loop
1366 0002ED68 31 03 jeql L344
1367 0002ED6A # asm("brw _pipe13_9_lp1"); /* run the loop again */
1368 0002ED6A 13 ff79 brw _pipe13_9_lp1
1369 0002ED6D # /*
1370 0002ED6D # * verify the results
1371 0002ED6D # */
1372 0002ED6D # asm("moval (r13),_sgl_value_10"); /* save the frame pointer */
1373 0002ED6D L344:
1374 0002ED6D ed 6d effffff514 moval (r13),_sgl_value_10
1375 0002ED74 # asm("movl _pointer_data,_sgl_value_4"); /* save the LSW stored */
1376 0002ED74 0d effffff50e effffff509 movl _pointer_data,_sgl_value_4
1377 0002ED7F # asm("movl _pointer_data-4,_sgl_value_3"); /* and the MSW */
1378 0002ED7F 0d effffff4ff effffff4fe movl _pointer_data-4,_sgl_value_3
1379 0002ED8A # if( (sgl_value_3 != dbl_expected.m) || /* verify the result... */
1380 0002ED8A # (sgl_value_4 != dbl_expected.l) || /* verify the result... */
1381 0002ED8A # (sgl_value_10 != sgl_value_9) ) /* ... and the final FP */
1382 0002ED8A 1d effffff4f8 effffff4f3 cmpl _sgl_value_3,_dbl_expected
1383 0002ED95 21 1d jneq L9991
1384 0002ED97 1d effffff4eb effffff4ea cmpl _sgl_value_4,_dbl_expected+4
1385 0002EDA2 21 10 jneq L9991
1386 0002EDA4 1d effffff4de effffff4d9 cmpl _sgl_value_10,_sgl_value_9
1387 0002EDAF 21 03 13 0091 jeql L345
1388 0002EDB4 L9991:
1389 0002EDB4 # {
1390 0002EDB4 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1391 0002EDB4 0d effffff4ce 5d movl _pre_event_fp,r13
1392 0002EDBB # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1393 0002EDBB 0d effffff4c7 5e movl _pre_event_sp,r14
1394 0002EDC2 # errcnt++; /* bump the error count */
1395 0002EDC2 6d effffff4c0 incl _errcnt
1396 0002EDC8 # if ( prt_error ) {
1397 0002EDC8 5d effffff4ba tstl _prt_error
1398 0002EDCE 31 4e jeql L346
1399 0002EDD0 # print_pipe13_er("indexed FP addressing.\n");
1400 0002EDD0 .data 1
1401 00000e51 * L347:
1402 00000e51 * 696E646578656420465020616 .ascii "indexed FP addressing.\12\0"
46472657373696E672E0A00
1403 00000e69 * .text
1404 0002EDD0 dd 8f00000e51 pushl $L347
1405 0002EDD6 fe 08 ef00000093 callf $8,_print_pipe13_er
1406 0002EDDD # writes("final Frame Pointer = ");
1407 0002EDDD .data 1
1408 00000e69 * L348:
1409 00000e69 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1410 00000e80 * .text
1411 0002EDDD dd 8f00000e69 pushl $L348
1412 0002EDE3 fe 08 effffff49e callf $8,_writes
1413 0002EDEA # write32h( sgl_value_10 );
1414 0002EDEA dd effffff498 pushl _sgl_value_10
1415 0002EDF0 fe 08 effffff491 callf $8,_write32h
1416 0002EDF7 # writes(", expected FP = ");
1417 0002EDF7 .data 1
1418 00000e80 * L350:
1419 00000e80 * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1420 00000e92 * .text
1421 0002EDF7 dd 8f00000e80 pushl $L350
1422 0002EDFD fe 08 effffff484 callf $8,_writes
1423 0002EE04 # write32h( sgl_value_9 );
1424 0002EE04 dd effffff47e pushl _sgl_value_9
1425 0002EE0A fe 08 effffff477 callf $8,_write32h
1426 0002EE11 # writes(" \n");
1427 0002EE11 .data 1
1428 00000e92 * L351:
1429 00000e92 * 200A00 .ascii " \12\0"
1430 00000e95 * .text
1431 0002EE11 dd 8f00000e92 pushl $L351
1432 0002EE17 fe 08 effffff46a callf $8,_writes
1433 0002EE1E # }
1434 0002EE1E # if ( halt_flg )
1435 0002EE1E L346:
1436 0002EE1E 5d effffff464 tstl _halt_flg
1437 0002EE24 31 0d jeql L352
1438 0002EE26 # pipe13_er_hlt( subtest );
1439 0002EE26 dd effffff45c pushl _subtest
1440 0002EE2C fe 08 ef0000018b callf $8,_pipe13_er_hlt
1441 0002EE33 # if ( loop_on_err ) {
1442 0002EE33 L352:
1443 0002EE33 5d effffff44f tstl _loop_on_err
1444 0002EE39 31 0a jeql L353
1445 0002EE3B # force_loop = TRUE; /* set the force loop flag */
1446 0002EE3B 0d 01 effffff446 movl $1,_force_loop
1447 0002EE42 # asm("brw _pipe13_9_lp1"); /* and loop */
1448 0002EE42 13 fea1 brw _pipe13_9_lp1
1449 0002EE45 # }
1450 0002EE45 # } /* end of compare error */
1451 0002EE45 L353:
1452 0002EE45 # } while( index++ < max_ldd_1_index );
1453 0002EE45 L345:
1454 0002EE45 L342:
1455 0002EE45 0d effffff43d 50 movl _index,r0
1456 0002EE4C 6d effffff436 incl _index
1457 0002EE52 1d 50 effffff42f cmpl r0,_max_ldd_1_index
1458 0002EE59 81 03 13 fe2d jlss L343
1459 0002EE5E L341:
1460 0002EE5E # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1461 0002EE5E 0d effffff424 5d movl _pre_event_fp,r13
1462 0002EE65 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1463 0002EE65 0d effffff41d 5e movl _pre_event_sp,r14
1464 0002EE6C # } /* end of subtest 9 */
1465 0002EE6C 40 ret#2
1466 0002EE6D .set L337,0x0
1467 0002EE6D L339:
1468 0002EE6D 13 fe01 jbr L340
1469 0002EE70 .data
1470 00000db4 * .text
1471 0002EE70 .align 1
1472 0002EE70 .globl _print_pipe13_er
1473 0002EE70 _print_pipe13_er:
1474 0002EE70 0000 .word L354
1475 0002EE72 #
1476 0002EE72 #
1477 0002EE72 # /******************************************************************************
1478 0002EE72 # *
1479 0002EE72 # * ERROR ROUTINE
1480 0002EE72 # *
1481 0002EE72 # * print an error in the following form
1482 0002EE72 # *
1483 0002EE72 # *operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd
1484 0002EE72 # * expected Acc = xxxxxxxx xxxxxxxx
1485 0002EE72 # *
1486 0002EE72 # ******************************************************************************/
1487 0002EE72 # print_pipe13_er(msg)
1488 0002EE72 # char *msg;
1489 0002EE72 # {
1490 0002EE72 13 0145 jbr L356
1491 0002EE75 L357:
1492 0002EE75 # writes(" \n"); /* start a new print line */
1493 0002EE75 .data 1
1494 00000e95 * L358:
1495 00000e95 * 200A00 .ascii " \12\0"
1496 00000e98 * .text
1497 0002EE75 dd 8f00000e95 pushl $L358
1498 0002EE7B fe 08 effffff406 callf $8,_writes
1499 0002EE82 # writes("cycle: ");
1500 0002EE82 .data 1
1501 00000e98 * L359:
1502 00000e98 * 6379636C653A2000 .ascii "cycle: \0"
1503 00000ea0 * .text
1504 0002EE82 dd 8f00000e98 pushl $L359
1505 0002EE88 fe 08 effffff3f9 callf $8,_writes
1506 0002EE8F # writed( cycle );
1507 0002EE8F dd effffff3f3 pushl _cycle
1508 0002EE95 fe 08 effffff3ec callf $8,_writed
1509 0002EE9C # writes(" test ");
1510 0002EE9C .data 1
1511 00000ea0 * L361:
1512 00000ea0 * 20746573742000 .ascii " test \0"
1513 00000ea7 * .text
1514 0002EE9C dd 8f00000ea0 pushl $L361
1515 0002EEA2 fe 08 effffff3df callf $8,_writes
1516 0002EEA9 # writed( test_no );
1517 0002EEA9 dd effffff3d9 pushl _test_no
1518 0002EEAF fe 08 effffff3d2 callf $8,_writed
1519 0002EEB6 # writes(" (Pipe 13), subtest ");
1520 0002EEB6 .data 1
1521 00000ea7 * L362:
1522 00000ea7 * 20202850697065203133292C2 .ascii " (Pipe 13), subtest \0"
0737562746573742000
1523 00000ebd * .text
1524 0002EEB6 dd 8f00000ea7 pushl $L362
1525 0002EEBC fe 08 effffff3c5 callf $8,_writes
1526 0002EEC3 # writed( subtest );
1527 0002EEC3 dd effffff3bf pushl _subtest
1528 0002EEC9 fe 08 effffff3b8 callf $8,_writed
1529 0002EED0 # writes(" error - ");
1530 0002EED0 .data 1
1531 00000ebd * L363:
1532 00000ebd * 206572726F72202D2000 .ascii " error - \0"
1533 00000ec7 * .text
1534 0002EED0 dd 8f00000ebd pushl $L363
1535 0002EED6 fe 08 effffff3ab callf $8,_writes
1536 0002EEDD # writes( msg );
1537 0002EEDD dd ad04 pushl 4(fp)
1538 0002EEE0 fe 08 effffff3a1 callf $8,_writes
1539 0002EEE7 # writec('\n');
1540 0002EEE7 dd 0a pushl $10
1541 0002EEE9 fe 08 effffff398 callf $8,_writec
1542 0002EEF0 # writes(" LDD(1.0), MULD(op), MULD(1.0), SUBD(op), ADDD(op), STD\n");
1543 0002EEF0 .data 1
1544 00000ec7 * L365:
1545 00000ec7 * 204C444428312E30292C204D5 .ascii " LDD(1.0), MULD(op), MULD(1.0), SUBD(op), ADDD(op), STD\12\0"
54C44286F70292C204D554C44
28312E30292C2053554244286
F70292C2041444444286F7029
2C205354440A00
1546 00000f00 * .text
1547 0002EEF0 dd 8f00000ec7 pushl $L365
1548 0002EEF6 fe 08 effffff38b callf $8,_writes
1549 0002EEFD # writes("operand = ");
1550 0002EEFD .data 1
1551 00000f00 * L366:
1552 00000f00 * 6F706572616E64203D2000 .ascii "operand = \0"
1553 00000f0b * .text
1554 0002EEFD dd 8f00000f00 pushl $L366
1555 0002EF03 fe 08 effffff37e callf $8,_writes
1556 0002EF0A # write32h( dbl_ld_acc.m );
1557 0002EF0A dd effffff378 pushl _dbl_ld_acc
1558 0002EF10 fe 08 effffff371 callf $8,_write32h
1559 0002EF17 # writec(' ');
1560 0002EF17 dd 20 pushl $32
1561 0002EF19 fe 08 effffff368 callf $8,_writec
1562 0002EF20 # write32h( dbl_ld_acc.l );
1563 0002EF20 dd effffff366 pushl _dbl_ld_acc+4
1564 0002EF26 fe 08 effffff35b callf $8,_write32h
1565 0002EF2D # writes(", final Acc = ");
1566 0002EF2D .data 1
1567 00000f0b * L367:
1568 00000f0b * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
3203D2000
1569 00000f1c * .text
1570 0002EF2D dd 8f00000f0b pushl $L367
1571 0002EF33 fe 08 effffff34e callf $8,_writes
1572 0002EF3A # write32h( dbl_st_acc.m );
1573 0002EF3A dd effffff348 pushl _dbl_st_acc
1574 0002EF40 fe 08 effffff341 callf $8,_write32h
1575 0002EF47 # writec(' ');
1576 0002EF47 dd 20 pushl $32
1577 0002EF49 fe 08 effffff338 callf $8,_writec
1578 0002EF50 # write32h( dbl_st_acc.l );
1579 0002EF50 dd effffff336 pushl _dbl_st_acc+4
1580 0002EF56 fe 08 effffff32b callf $8,_write32h
1581 0002EF5D # writes(", index = ");
1582 0002EF5D .data 1
1583 00000f1c * L368:
1584 00000f1c * 2C202020696E646578203D200 .ascii ", index = \0"
0
1585 00000f29 * .text
1586 0002EF5D dd 8f00000f1c pushl $L368
1587 0002EF63 fe 08 effffff31e callf $8,_writes
1588 0002EF6A # writed( index );
1589 0002EF6A dd effffff318 pushl _index
1590 0002EF70 fe 08 effffff311 callf $8,_writed
1591 0002EF77 # writec('\n');
1592 0002EF77 dd 0a pushl $10
1593 0002EF79 fe 08 effffff308 callf $8,_writec
1594 0002EF80 # writes(" expected Acc = ");
1595 0002EF80 .data 1
1596 00000f29 * L369:
1597 00000f29 * 2020202020202020202020202 .ascii " expected Acc = \0"
0202020202020202020202020
2020206578706563746564204
16363203D2000
1598 00000f55 * .text
1599 0002EF80 dd 8f00000f29 pushl $L369
1600 0002EF86 fe 08 effffff2fb callf $8,_writes
1601 0002EF8D # write32h( dbl_expected.m );
1602 0002EF8D dd effffff2f5 pushl _dbl_expected
1603 0002EF93 fe 08 effffff2ee callf $8,_write32h
1604 0002EF9A # writec(' ');
1605 0002EF9A dd 20 pushl $32
1606 0002EF9C fe 08 effffff2e5 callf $8,_writec
1607 0002EFA3 # write32h( dbl_expected.l );
1608 0002EFA3 dd effffff2e3 pushl _dbl_expected+4
1609 0002EFA9 fe 08 effffff2d8 callf $8,_write32h
1610 0002EFB0 # writec('\n');
1611 0002EFB0 dd 0a pushl $10
1612 0002EFB2 fe 08 effffff2cf callf $8,_writec
1613 0002EFB9 # }
1614 0002EFB9 40 ret#2
1615 0002EFBA .set L354,0x0
1616 0002EFBA L356:
1617 0002EFBA 13 feb8 jbr L357
1618 0002EFBD .data
1619 00000db4 * .text
1620 0002EFBD 00 .align 1
1621 0002EFBE .globl _pipe13_er_hlt
1622 0002EFBE _pipe13_er_hlt:
1623 0002EFBE 0000 .word L370
1624 0002EFC0 #
1625 0002EFC0 #
1626 0002EFC0 #
1627 0002EFC0 #
1628 0002EFC0 #
1629 0002EFC0 # /******************************************************************************
1630 0002EFC0 # *
1631 0002EFC0 # * HALT ON ERROR ROUTINE
1632 0002EFC0 # *
1633 0002EFC0 # * halt with the necessary information saved in the registers
1634 0002EFC0 # *
1635 0002EFC0 # ******************************************************************************/
1636 0002EFC0 # pipe13_er_hlt( subtest )
1637 0002EFC0 # int subtest;
1638 0002EFC0 # {
1639 0002EFC0 11 75 jbr L372
1640 0002EFC2 L373:
1641 0002EFC2 # sgl_value_3 = dbl_st_acc.m;
1642 0002EFC2 0d effffff2c0 effffff2bb movl _dbl_st_acc,_sgl_value_3
1643 0002EFCD # sgl_value_4 = dbl_st_acc.l;
1644 0002EFCD 0d effffff2b9 effffff2b0 movl _dbl_st_acc+4,_sgl_value_4
1645 0002EFD8 # asm("movl _test_no,r0"); /* r0 = test number */
1646 0002EFD8 0d effffff2aa 50 movl _test_no,r0
1647 0002EFDF # asm("movl _subtest,r1"); /* r1 = subtest number */
1648 0002EFDF 0d effffff2a3 51 movl _subtest,r1
1649 0002EFE6 # asm("movl $1,r2"); /* r2 = error code */
1650 0002EFE6 0d 01 52 movl $1,r2
1651 0002EFE9 # asm("movl _cycle,r3"); /* r3 = cycle count */
1652 0002EFE9 0d effffff299 53 movl _cycle,r3
1653 0002EFF0 # asm("movl _sgl_value_1,r4"); /* r4 = MSW operand loaded */
1654 0002EFF0 0d effffff292 54 movl _sgl_value_1,r4
1655 0002EFF7 # asm("movl _sgl_value_2,r5"); /* r5 = LSW operand loaded */
1656 0002EFF7 0d effffff28b 55 movl _sgl_value_2,r5
1657 0002EFFE # asm("movl _sgl_value_3,r6"); /* r6 = MSW operand stored */
1658 0002EFFE 0d effffff284 56 movl _sgl_value_3,r6
1659 0002F005 # asm("movl _sgl_value_4,r7"); /* r7 = LSW operand stored */
1660 0002F005 0d effffff27d 57 movl _sgl_value_4,r7
1661 0002F00C # asm("movl _sgl_value_5,r8"); /* r8 = MSW operand expect */
1662 0002F00C 0d effffff276 58 movl _sgl_value_5,r8
1663 0002F013 # asm("movl _sgl_value_6,r9"); /* r9 = LSW operand expect */
1664 0002F013 0d effffff26f 59 movl _sgl_value_6,r9
1665 0002F01A # asm("movl _index,r10"); /* r10 = data index */
1666 0002F01A 0d effffff268 5a movl _index,r10
1667 0002F021 # if( subtest == 9 ) {
1668 0002F021 1d ad04 09 cmpl 4(fp),$9
1669 0002F025 21 0e jneq L374
1670 0002F027 # asm("movl _sgl_value_10,r11"); /* r11 = final FP value */
1671 0002F027 0d effffff25b 5b movl _sgl_value_10,r11
1672 0002F02E # asm("movl _sgl_value_9,r12"); /* r12 = expected FP value */
1673 0002F02E 0d effffff254 5c movl _sgl_value_9,r12
1674 0002F035 # };
1675 0002F035 L374:
1676 0002F035 # asm(".globl _pipe13_1_hlt");
1677 0002F035 .globl _pipe13_1_hlt
1678 0002F035 # asm("_pipe13_1_hlt:"); /* PC after the halt */
1679 0002F035 _pipe13_1_hlt:
1680 0002F035 # asm("halt"); /* HALT ... */
1681 0002F035 00 halt
1682 0002F036 # } /* end of halt on error */
1683 0002F036 40 ret#2
1684 0002F037 .set L370,0x0
1685 0002F037 L372:
1686 0002F037 11 89 jbr L373
1687 0002F039 .data
1687 0005D2C1 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.