![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe16.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 pipe16.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 00000d34 * .text
4 00000000 .align 1
5 00000000 .globl _pipe_16
6 00000000 _pipe_16:
7 00031030 0000 .word L215
8 00031032 # #include "fpp_defs.h"
9 00031032 #
10 00031032 #
11 00031032 # /*****************************************************************************
12 00031032 # *
13 00031032 # * DBL PIPELINE TEST #16 MONITOR
14 00031032 # *
15 00031032 # * This test will do:
16 00031032 # *
17 00031032 # * LND(x) ADDD(x) SUBD(0) SUBD(x) STD
18 00031032 # *
19 00031032 # * where the x's are the LND data patterns.
20 00031032 # *****************************************************************************/
21 00031032 # pipe_16()
22 00031032 # {
23 00031032 13 009b jbr L217
24 00031035 L218:
25 00031035 # asm(".globl _pipeline_16_t");
26 00031035 .globl _pipeline_16_t
27 00031035 # asm("_pipeline_16_t:"); /* entry address */
28 00031035 _pipeline_16_t:
29 00031035 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
30 00031035 1d effffffff5 01 cmpl _cycle,$1
31 0003103C 21 15 jneq L219
32 0003103E 5d efffffffec tstl _prt_hdrs
33 00031044 31 0d jeql L219
34 00031046 # {
35 00031046 # writes(" PIPE_16");
36 00031046 .data 1
37 00000d34 * L221:
38 00000d34 * 20504950455F313600 .ascii " PIPE_16\0"
39 00000d3d * .text
40 00031046 dd 8f00000d34 pushl $L221
41 0003104C fe 08 efffffffdd callf $8,_writes
42 00031053 # }
43 00031053 # subtest = 1;
44 00031053 L219:
45 00031053 0d 01 efffffffd6 movl $1,_subtest
46 0003105A # pipe16_1(); /* data in REGs, no NOPs */
47 0003105A fe 04 ef00000073 callf $4,_pipe16_1
48 00031061 # subtest++; /* increment subtest num */
49 00031061 6d efffffffc9 incl _subtest
50 00031067 # pipe16_2(); /* data in REGs, 1 NOP */
51 00031067 fe 04 ef00000194 callf $4,_pipe16_2
52 0003106E # subtest++; /* increment subtest num */
53 0003106E 6d efffffffbc incl _subtest
54 00031074 # pipe16_3(); /* data in REGs, 2 NOPs */
55 00031074 fe 04 ef000002b9 callf $4,_pipe16_3
56 0003107B # subtest++; /* increment subtest num */
57 0003107B 6d efffffffaf incl _subtest
58 00031081 # pipe16_4(); /* data in REGs, 3 NOPs */
59 00031081 fe 04 ef000003e2 callf $4,_pipe16_4
60 00031088 # subtest++; /* increment subtest num */
61 00031088 6d efffffffa2 incl _subtest
62 0003108E # pipe16_5(); /* data in CACHE, no NOPs */
63 0003108E fe 04 ef0000050f callf $4,_pipe16_5
64 00031095 # subtest++; /* increment subtest num */
65 00031095 6d efffffff95 incl _subtest
66 0003109B # pipe16_6(); /* data in CACHE, 1 NOP */
67 0003109B fe 04 ef000005fc callf $4,_pipe16_6
68 000310A2 # subtest++; /* increment subtest num */
69 000310A2 6d efffffff88 incl _subtest
70 000310A8 # pipe16_7(); /* data in CACHE, 2 NOPs */
71 000310A8 fe 04 ef000006ed callf $4,_pipe16_7
72 000310AF # subtest++; /* increment subtest num */
73 000310AF 6d efffffff7b incl _subtest
74 000310B5 # pipe16_8(); /* data in CACHE, 3 NOPs */
75 000310B5 fe 04 ef000007e2 callf $4,_pipe16_8
76 000310BC # subtest++; /* increment subtest num */
77 000310BC 6d efffffff6e incl _subtest
78 000310C2 # pipe16_9(); /* data via F.P. 0 NOPs */
79 000310C2 fe 04 ef000008db callf $4,_pipe16_9
80 000310C9 # asm("jmp *return"); /* return to the test monitor */
81 000310C9 71 ffffffff61 jmp *return
82 000310CF # }
83 000310CF 40 ret#2
84 000310D0 .set L215,0x0
85 000310D0 L217:
86 000310D0 13 ff62 jbr L218
87 000310D3 .data
88 00000d34 * .text
89 000310D3 00 .align 1
90 000310D4 .globl _pipe16_1
91 000310D4 _pipe16_1:
92 000310D4 0000 .word L231
93 000310D6 #
94 000310D6 #
95 000310D6 #
96 000310D6 #
97 000310D6 #
98 000310D6 #
99 000310D6 #
100 000310D6 # /************************************************************************
101 000310D6 # *
102 000310D6 # * SUBTEST 1
103 000310D6 # * data in registers, no NO-OPs
104 000310D6 # *
105 000310D6 # ************************************************************************/
106 000310D6 # pipe16_1()
107 000310D6 # {
108 000310D6 13 0126 jbr L233
109 000310D9 L234:
110 000310D9 # force_loop = FALSE; /* clear the force_loop flg */
111 000310D9 4d efffffff51 clrl _force_loop
112 000310DF # index = 0;
113 000310DF 4d efffffff4b clrl _index
114 000310E5 # do
115 000310E5 L237:
116 000310E5 # {
117 000310E5 # sgl_value_1 = lnd_1_data[index].ld.m; /* get the operand's MSW */
118 000310E5 0d efffffff45 50 movl _index,r0
119 000310EC 48 04 50 50 shll $4,r0,r0
120 000310F0 0d e000000000 efffffff35 movl _lnd_1_data(r0),_sgl_value_1
121 000310FB # sgl_value_2 = lnd_1_data[index].ld.l; /* get the operand's MSW */
122 000310FB 0d efffffff2f 50 movl _index,r0
123 00031102 48 04 50 50 shll $4,r0,r0
124 00031106 0d e000000004 efffffff1f movl _lnd_1_data+4(r0),_sgl_value_2
125 00031111 # sgl_value_7 = 0; /* get a '0.0' */
126 00031111 4d efffffff19 clrl _sgl_value_7
127 00031117 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
128 00031117 48 04 efffffff12 50 shll $4,_index,r0
129 0003111F 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
130 00031126 0d a004 efffffff06 movl 4(r0),_dbl_expected+4
131 0003112E 0d 60 effffffefb movl (r0),_dbl_expected
132 00031135 # /*
133 00031135 # * If LOOP ON ERROR is set, this is the loop for this subtest.
134 00031135 # * The force loop flag is set after the first error.
135 00031135 # */
136 00031135 # asm("_pipe16_1_lp1:");
137 00031135 _pipe16_1_lp1:
138 00031135 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
139 00031135 0d effffffef5 54 movl _sgl_value_1,r4
140 0003113C # asm("movl _sgl_value_2,r5");
141 0003113C 0d effffffeee 55 movl _sgl_value_2,r5
142 00031143 # asm("movl _sgl_value_7,r2"); /* move a '0.0' to r2/r3 */
143 00031143 0d effffffee7 52 movl _sgl_value_7,r2
144 0003114A # asm("movl _sgl_value_7,r3");
145 0003114A 0d effffffee0 53 movl _sgl_value_7,r3
146 00031151 # asm("lnd r4"); /* load the operand (-op ) */
147 00031151 17 54 lnd r4
148 00031153 # asm("addd r4"); /* add the operand ( 0 ) */
149 00031153 c7 54 addd r4
150 00031155 # asm("subd r2"); /* subtract a '0.0' ( 0 ) */
151 00031155 d7 52 subd r2
152 00031157 # asm("subd r4"); /* subtract the op (-op ) */
153 00031157 d7 54 subd r4
154 00031159 # asm("std r6"); /* store the result (-op ) */
155 00031159 27 56 std r6
156 0003115B # if( force_loop )
157 0003115B 5d effffffecf tstl _force_loop
158 00031161 31 02 jeql L238
159 00031163 # asm("brb _pipe16_1_lp1");; /* run the loop again */
160 00031163 11 d0 brb _pipe16_1_lp1
161 00031165 L238:
162 00031165 # /*
163 00031165 # * verify the results
164 00031165 # */
165 00031165 # asm("movl r6,_sgl_value_3"); /* get the result */
166 00031165 0d 56 effffffec4 movl r6,_sgl_value_3
167 0003116C # asm("movl r7,_sgl_value_4");
168 0003116C 0d 57 effffffebd movl r7,_sgl_value_4
169 00031173 # dbl_st_acc.m = sgl_value_3;
170 00031173 0d effffffeb7 effffffeb2 movl _sgl_value_3,_dbl_st_acc
171 0003117E # dbl_st_acc.l = sgl_value_4;
172 0003117E 0d effffffeac effffffeab movl _sgl_value_4,_dbl_st_acc+4
173 00031189 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
174 00031189 # (dbl_st_acc.l != dbl_expected.l) )
175 00031189 1d effffffea1 effffffe9c cmpl _dbl_st_acc,_dbl_expected
176 00031194 21 0d jneq L9999
177 00031196 1d effffffe98 effffffe93 cmpl _dbl_st_acc+4,_dbl_expected+4
178 000311A1 31 42 jeql L239
179 000311A3 L9999:
180 000311A3 # {
181 000311A3 # errcnt++; /* bump the error count */
182 000311A3 6d effffffe87 incl _errcnt
183 000311A9 # if ( prt_error )
184 000311A9 5d effffffe81 tstl _prt_error
185 000311AF 31 0d jeql L240
186 000311B1 # print_pipe16_er("Reg. Data, no NOPs");
187 000311B1 .data 1
188 00000d3d * L242:
189 00000d3d * 5265672E20446174612C206E6 .ascii "Reg. Data, no NOPs\0"
F204E4F507300
190 00000d50 * .text
191 000311B1 dd 8f00000d3d pushl $L242
192 000311B7 fe 08 ef000009dc callf $8,_print_pipe16_er
193 000311BE # if ( halt_flg ) /* halt on error? */
194 000311BE L240:
195 000311BE 5d effffffe6c tstl _halt_flg
196 000311C4 31 0d jeql L243
197 000311C6 # pipe16_er_hlt( subtest );
198 000311C6 dd effffffe64 pushl _subtest
199 000311CC fe 08 ef00000b15 callf $8,_pipe16_er_hlt
200 000311D3 # if ( loop_on_err ) {
201 000311D3 L243:
202 000311D3 5d effffffe57 tstl _loop_on_err
203 000311D9 31 0a jeql L245
204 000311DB # force_loop = TRUE; /* set the force loop flag */
205 000311DB 0d 01 effffffe4e movl $1,_force_loop
206 000311E2 # asm("brw _pipe16_1_lp1"); /* and loop */
207 000311E2 13 ff50 brw _pipe16_1_lp1
208 000311E5 # }
209 000311E5 # } /* end of compare error */
210 000311E5 L245:
211 000311E5 # } while( index++ < max_lnd_1_index );
212 000311E5 L239:
213 000311E5 L236:
214 000311E5 0d effffffe45 50 movl _index,r0
215 000311EC 6d effffffe3e incl _index
216 000311F2 1d 50 effffffe37 cmpl r0,_max_lnd_1_index
217 000311F9 81 03 13 fee7 jlss L237
218 000311FE L235:
219 000311FE # } /* end of subtest 1 */
220 000311FE 40 ret#2
221 000311FF .set L231,0x0
222 000311FF L233:
223 000311FF 13 fed7 jbr L234
224 00031202 .data
225 00000d34 * .text
226 00031202 .align 1
227 00031202 .globl _pipe16_2
228 00031202 _pipe16_2:
229 00031202 0000 .word L246
230 00031204 #
231 00031204 #
232 00031204 #
233 00031204 #
234 00031204 #
235 00031204 #
236 00031204 #
237 00031204 #
238 00031204 # /************************************************************************
239 00031204 # *
240 00031204 # * SUBTEST 2
241 00031204 # * data in registers, 1 NO-OP
242 00031204 # *
243 00031204 # ************************************************************************/
244 00031204 # pipe16_2()
245 00031204 # {
246 00031204 13 012a jbr L248
247 00031207 L249:
248 00031207 # force_loop = FALSE; /* clear the force_loop flg */
249 00031207 4d effffffe23 clrl _force_loop
250 0003120D # index = 0;
251 0003120D 4d effffffe1d clrl _index
252 00031213 # do
253 00031213 L252:
254 00031213 # {
255 00031213 # sgl_value_1 = lnd_1_data[index].ld.m; /* get the operand's MSW */
256 00031213 0d effffffe17 50 movl _index,r0
257 0003121A 48 04 50 50 shll $4,r0,r0
258 0003121E 0d e000000000 effffffe07 movl _lnd_1_data(r0),_sgl_value_1
259 00031229 # sgl_value_2 = lnd_1_data[index].ld.l; /* get the operand's MSW */
260 00031229 0d effffffe01 50 movl _index,r0
261 00031230 48 04 50 50 shll $4,r0,r0
262 00031234 0d e000000004 effffffdf1 movl _lnd_1_data+4(r0),_sgl_value_2
263 0003123F # sgl_value_7 = 0; /* get a '0.0' */
264 0003123F 4d effffffdeb clrl _sgl_value_7
265 00031245 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
266 00031245 48 04 effffffde4 50 shll $4,_index,r0
267 0003124D 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
268 00031254 0d a004 effffffdd8 movl 4(r0),_dbl_expected+4
269 0003125C 0d 60 effffffdcd movl (r0),_dbl_expected
270 00031263 # /*
271 00031263 # * If LOOP ON ERROR is set, this is the loop for this subtest.
272 00031263 # * The force loop flag is set after the first error.
273 00031263 # */
274 00031263 # asm("_pipe16_2_lp1:");
275 00031263 _pipe16_2_lp1:
276 00031263 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
277 00031263 0d effffffdc7 54 movl _sgl_value_1,r4
278 0003126A # asm("movl _sgl_value_2,r5");
279 0003126A 0d effffffdc0 55 movl _sgl_value_2,r5
280 00031271 # asm("movl _sgl_value_7,r2"); /* move a '0.0' to r2/r3 */
281 00031271 0d effffffdb9 52 movl _sgl_value_7,r2
282 00031278 # asm("movl _sgl_value_7,r3");
283 00031278 0d effffffdb2 53 movl _sgl_value_7,r3
284 0003127F # asm("lnd r4"); /* load the operand (-op ) */
285 0003127F 17 54 lnd r4
286 00031281 # asm("nop");
287 00031281 10 nop
288 00031282 # asm("addd r4"); /* add the operand ( 0 ) */
289 00031282 c7 54 addd r4
290 00031284 # asm("nop");
291 00031284 10 nop
292 00031285 # asm("subd r2"); /* subtract a '0.0' ( 0 ) */
293 00031285 d7 52 subd r2
294 00031287 # asm("nop");
295 00031287 10 nop
296 00031288 # asm("subd r4"); /* subtract the op (-op ) */
297 00031288 d7 54 subd r4
298 0003128A # asm("nop");
299 0003128A 10 nop
300 0003128B # asm("std r6"); /* store the result (-op ) */
301 0003128B 27 56 std r6
302 0003128D # if( force_loop )
303 0003128D 5d effffffd9d tstl _force_loop
304 00031293 31 02 jeql L253
305 00031295 # asm("brb _pipe16_2_lp1");; /* run the loop again */
306 00031295 11 cc brb _pipe16_2_lp1
307 00031297 L253:
308 00031297 # /*
309 00031297 # * verify the results
310 00031297 # */
311 00031297 # asm("movl r6,_sgl_value_3"); /* get the result */
312 00031297 0d 56 effffffd92 movl r6,_sgl_value_3
313 0003129E # asm("movl r7,_sgl_value_4");
314 0003129E 0d 57 effffffd8b movl r7,_sgl_value_4
315 000312A5 # dbl_st_acc.m = sgl_value_3;
316 000312A5 0d effffffd85 effffffd80 movl _sgl_value_3,_dbl_st_acc
317 000312B0 # dbl_st_acc.l = sgl_value_4;
318 000312B0 0d effffffd7a effffffd79 movl _sgl_value_4,_dbl_st_acc+4
319 000312BB # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
320 000312BB # (dbl_st_acc.l != dbl_expected.l) )
321 000312BB 1d effffffd6f effffffd6a cmpl _dbl_st_acc,_dbl_expected
322 000312C6 21 0d jneq L9998
323 000312C8 1d effffffd66 effffffd61 cmpl _dbl_st_acc+4,_dbl_expected+4
324 000312D3 31 42 jeql L254
325 000312D5 L9998:
326 000312D5 # {
327 000312D5 # errcnt++; /* bump the error count */
328 000312D5 6d effffffd55 incl _errcnt
329 000312DB # if ( prt_error )
330 000312DB 5d effffffd4f tstl _prt_error
331 000312E1 31 0d jeql L255
332 000312E3 # print_pipe16_er("Reg. Data, 1 NOP");
333 000312E3 .data 1
334 00000d50 * L256:
335 00000d50 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NOP\0"
04E4F5000
336 00000d61 * .text
337 000312E3 dd 8f00000d50 pushl $L256
338 000312E9 fe 08 ef000008aa callf $8,_print_pipe16_er
339 000312F0 # if ( halt_flg ) /* halt on error? */
340 000312F0 L255:
341 000312F0 5d effffffd3a tstl _halt_flg
342 000312F6 31 0d jeql L257
343 000312F8 # pipe16_er_hlt( subtest );
344 000312F8 dd effffffd32 pushl _subtest
345 000312FE fe 08 ef000009e3 callf $8,_pipe16_er_hlt
346 00031305 # if ( force_loop ) { /* loop on error? */
347 00031305 L257:
348 00031305 5d effffffd25 tstl _force_loop
349 0003130B 31 0a jeql L258
350 0003130D # force_loop = TRUE; /* set the force loop flag */
351 0003130D 0d 01 effffffd1c movl $1,_force_loop
352 00031314 # asm("brw _pipe16_2_lp1"); /* and loop */
353 00031314 13 ff4c brw _pipe16_2_lp1
354 00031317 # }
355 00031317 # } /* end of compare error */
356 00031317 L258:
357 00031317 # } while( index++ < max_lnd_1_index );
358 00031317 L254:
359 00031317 L251:
360 00031317 0d effffffd13 50 movl _index,r0
361 0003131E 6d effffffd0c incl _index
362 00031324 1d 50 effffffd05 cmpl r0,_max_lnd_1_index
363 0003132B 81 03 13 fee3 jlss L252
364 00031330 L250:
365 00031330 # } /* end of subtest 2 */
366 00031330 40 ret#2
367 00031331 .set L246,0x0
368 00031331 L248:
369 00031331 13 fed3 jbr L249
370 00031334 .data
371 00000d34 * .text
372 00031334 .align 1
373 00031334 .globl _pipe16_3
374 00031334 _pipe16_3:
375 00031334 0000 .word L259
376 00031336 #
377 00031336 #
378 00031336 #
379 00031336 #
380 00031336 #
381 00031336 #
382 00031336 #
383 00031336 #
384 00031336 # /************************************************************************
385 00031336 # *
386 00031336 # * SUBTEST 3
387 00031336 # * data in registers, 2 NO-OPs
388 00031336 # *
389 00031336 # ************************************************************************/
390 00031336 # pipe16_3()
391 00031336 # {
392 00031336 13 012e jbr L261
393 00031339 L262:
394 00031339 # force_loop = FALSE; /* clear the force_loop flg */
395 00031339 4d effffffcf1 clrl _force_loop
396 0003133F # index = 0;
397 0003133F 4d effffffceb clrl _index
398 00031345 # do
399 00031345 L265:
400 00031345 # {
401 00031345 # sgl_value_1 = lnd_1_data[index].ld.m; /* get the operand's MSW */
402 00031345 0d effffffce5 50 movl _index,r0
403 0003134C 48 04 50 50 shll $4,r0,r0
404 00031350 0d e000000000 effffffcd5 movl _lnd_1_data(r0),_sgl_value_1
405 0003135B # sgl_value_2 = lnd_1_data[index].ld.l; /* get the operand's MSW */
406 0003135B 0d effffffccf 50 movl _index,r0
407 00031362 48 04 50 50 shll $4,r0,r0
408 00031366 0d e000000004 effffffcbf movl _lnd_1_data+4(r0),_sgl_value_2
409 00031371 # sgl_value_7 = 0; /* get a '0.0' */
410 00031371 4d effffffcb9 clrl _sgl_value_7
411 00031377 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
412 00031377 48 04 effffffcb2 50 shll $4,_index,r0
413 0003137F 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
414 00031386 0d a004 effffffca6 movl 4(r0),_dbl_expected+4
415 0003138E 0d 60 effffffc9b movl (r0),_dbl_expected
416 00031395 # /*
417 00031395 # * If LOOP ON ERROR is set, this is the loop for this subtest.
418 00031395 # * The force loop flag is set after the first error.
419 00031395 # */
420 00031395 # asm("_pipe16_3_lp1:");
421 00031395 _pipe16_3_lp1:
422 00031395 # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
423 00031395 0d effffffc95 54 movl _sgl_value_1,r4
424 0003139C # asm("movl _sgl_value_2,r5");
425 0003139C 0d effffffc8e 55 movl _sgl_value_2,r5
426 000313A3 # asm("movl _sgl_value_7,r2"); /* move a '0.0' to r2/r3 */
427 000313A3 0d effffffc87 52 movl _sgl_value_7,r2
428 000313AA # asm("movl _sgl_value_7,r3");
429 000313AA 0d effffffc80 53 movl _sgl_value_7,r3
430 000313B1 # asm("lnd r4"); /* load the operand (-op ) */
431 000313B1 17 54 lnd r4
432 000313B3 # asm("nop");
433 000313B3 10 nop
434 000313B4 # asm("nop");
435 000313B4 10 nop
436 000313B5 # asm("addd r4"); /* add the operand ( 0 ) */
437 000313B5 c7 54 addd r4
438 000313B7 # asm("nop");
439 000313B7 10 nop
440 000313B8 # asm("nop");
441 000313B8 10 nop
442 000313B9 # asm("subd r2"); /* subtract a '0.0' ( 0 ) */
443 000313B9 d7 52 subd r2
444 000313BB # asm("nop");
445 000313BB 10 nop
446 000313BC # asm("nop");
447 000313BC 10 nop
448 000313BD # asm("subd r4"); /* subtract the op (-op ) */
449 000313BD d7 54 subd r4
450 000313BF # asm("nop");
451 000313BF 10 nop
452 000313C0 # asm("nop");
453 000313C0 10 nop
454 000313C1 # asm("std r6"); /* store the result (-op ) */
455 000313C1 27 56 std r6
456 000313C3 # if( force_loop )
457 000313C3 5d effffffc67 tstl _force_loop
458 000313C9 31 02 jeql L266
459 000313CB # asm("brb _pipe16_3_lp1");; /* run the loop again */
460 000313CB 11 c8 brb _pipe16_3_lp1
461 000313CD L266:
462 000313CD # /*
463 000313CD # * verify the results
464 000313CD # */
465 000313CD # asm("movl r6,_sgl_value_3"); /* get the result */
466 000313CD 0d 56 effffffc5c movl r6,_sgl_value_3
467 000313D4 # asm("movl r7,_sgl_value_4");
468 000313D4 0d 57 effffffc55 movl r7,_sgl_value_4
469 000313DB # dbl_st_acc.m = sgl_value_3;
470 000313DB 0d effffffc4f effffffc4a movl _sgl_value_3,_dbl_st_acc
471 000313E6 # dbl_st_acc.l = sgl_value_4;
472 000313E6 0d effffffc44 effffffc43 movl _sgl_value_4,_dbl_st_acc+4
473 000313F1 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
474 000313F1 # (dbl_st_acc.l != dbl_expected.l) )
475 000313F1 1d effffffc39 effffffc34 cmpl _dbl_st_acc,_dbl_expected
476 000313FC 21 0d jneq L9997
477 000313FE 1d effffffc30 effffffc2b cmpl _dbl_st_acc+4,_dbl_expected+4
478 00031409 31 42 jeql L267
479 0003140B L9997:
480 0003140B # {
481 0003140B # errcnt++; /* bump the error count */
482 0003140B 6d effffffc1f incl _errcnt
483 00031411 # if ( prt_error )
484 00031411 5d effffffc19 tstl _prt_error
485 00031417 31 0d jeql L268
486 00031419 # print_pipe16_er("Reg. Data, 2 NOPs");
487 00031419 .data 1
488 00000d61 * L269:
489 00000d61 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NOPs\0"
04E4F507300
490 00000d73 * .text
491 00031419 dd 8f00000d61 pushl $L269
492 0003141F fe 08 ef00000774 callf $8,_print_pipe16_er
493 00031426 # if ( halt_flg ) /* halt on error? */
494 00031426 L268:
495 00031426 5d effffffc04 tstl _halt_flg
496 0003142C 31 0d jeql L270
497 0003142E # pipe16_er_hlt( subtest );
498 0003142E dd effffffbfc pushl _subtest
499 00031434 fe 08 ef000008ad callf $8,_pipe16_er_hlt
500 0003143B # if ( loop_on_err ) {
501 0003143B L270:
502 0003143B 5d effffffbef tstl _loop_on_err
503 00031441 31 0a jeql L271
504 00031443 # force_loop = TRUE; /* set the force loop flag */
505 00031443 0d 01 effffffbe6 movl $1,_force_loop
506 0003144A # asm("brw _pipe16_3_lp1"); /* and loop */
507 0003144A 13 ff48 brw _pipe16_3_lp1
508 0003144D # }
509 0003144D # } /* end of compare error */
510 0003144D L271:
511 0003144D # } while( index++ < max_lnd_1_index );
512 0003144D L267:
513 0003144D L264:
514 0003144D 0d effffffbdd 50 movl _index,r0
515 00031454 6d effffffbd6 incl _index
516 0003145A 1d 50 effffffbcf cmpl r0,_max_lnd_1_index
517 00031461 81 03 13 fedf jlss L265
518 00031466 L263:
519 00031466 # } /* end of subtest 7 */
520 00031466 40 ret#2
521 00031467 .set L259,0x0
522 00031467 L261:
523 00031467 13 fecf jbr L262
524 0003146A .data
525 00000d34 * .text
526 0003146A .align 1
527 0003146A .globl _pipe16_4
528 0003146A _pipe16_4:
529 0003146A 0000 .word L272
530 0003146C #
531 0003146C #
532 0003146C #
533 0003146C #
534 0003146C #
535 0003146C #
536 0003146C #
537 0003146C # /************************************************************************
538 0003146C # *
539 0003146C # * SUBTEST 4
540 0003146C # * data in registers, 3 NO-OPs
541 0003146C # *
542 0003146C # ************************************************************************/
543 0003146C # pipe16_4()
544 0003146C # {
545 0003146C 13 0132 jbr L274
546 0003146F L275:
547 0003146F # force_loop = FALSE; /* clear the force_loop flg */
548 0003146F 4d effffffbbb clrl _force_loop
549 00031475 # index = 0;
550 00031475 4d effffffbb5 clrl _index
551 0003147B # do
552 0003147B L278:
553 0003147B # {
554 0003147B # sgl_value_1 = lnd_1_data[index].ld.m; /* get the operand's MSW */
555 0003147B 0d effffffbaf 50 movl _index,r0
556 00031482 48 04 50 50 shll $4,r0,r0
557 00031486 0d e000000000 effffffb9f movl _lnd_1_data(r0),_sgl_value_1
558 00031491 # sgl_value_2 = lnd_1_data[index].ld.l; /* get the operand's MSW */
559 00031491 0d effffffb99 50 movl _index,r0
560 00031498 48 04 50 50 shll $4,r0,r0
561 0003149C 0d e000000004 effffffb89 movl _lnd_1_data+4(r0),_sgl_value_2
562 000314A7 # sgl_value_7 = 0; /* get a '0.0' */
563 000314A7 4d effffffb83 clrl _sgl_value_7
564 000314AD # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
565 000314AD 48 04 effffffb7c 50 shll $4,_index,r0
566 000314B5 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
567 000314BC 0d a004 effffffb70 movl 4(r0),_dbl_expected+4
568 000314C4 0d 60 effffffb65 movl (r0),_dbl_expected
569 000314CB # /*
570 000314CB # * If LOOP ON ERROR is set, this is the loop for this subtest.
571 000314CB # * The force loop flag is set after the first error.
572 000314CB # */
573 000314CB # asm("_pipe16_4_lp1:");
574 000314CB _pipe16_4_lp1:
575 000314CB # asm("movl _sgl_value_1,r4"); /* move the data to r4/r5 */
576 000314CB 0d effffffb5f 54 movl _sgl_value_1,r4
577 000314D2 # asm("movl _sgl_value_2,r5");
578 000314D2 0d effffffb58 55 movl _sgl_value_2,r5
579 000314D9 # asm("movl _sgl_value_7,r2"); /* move a '0.0' to r2/r3 */
580 000314D9 0d effffffb51 52 movl _sgl_value_7,r2
581 000314E0 # asm("movl _sgl_value_7,r3");
582 000314E0 0d effffffb4a 53 movl _sgl_value_7,r3
583 000314E7 # asm("lnd r4"); /* load the operand (-op ) */
584 000314E7 17 54 lnd r4
585 000314E9 # asm("nop");
586 000314E9 10 nop
587 000314EA # asm("nop");
588 000314EA 10 nop
589 000314EB # asm("nop");
590 000314EB 10 nop
591 000314EC # asm("addd r4"); /* add the operand ( 0 ) */
592 000314EC c7 54 addd r4
593 000314EE # asm("nop");
594 000314EE 10 nop
595 000314EF # asm("nop");
596 000314EF 10 nop
597 000314F0 # asm("nop");
598 000314F0 10 nop
599 000314F1 # asm("subd r2"); /* subtract a '0.0' ( 0 ) */
600 000314F1 d7 52 subd r2
601 000314F3 # asm("nop");
602 000314F3 10 nop
603 000314F4 # asm("nop");
604 000314F4 10 nop
605 000314F5 # asm("nop");
606 000314F5 10 nop
607 000314F6 # asm("subd r4"); /* subtract the op (-op ) */
608 000314F6 d7 54 subd r4
609 000314F8 # asm("nop");
610 000314F8 10 nop
611 000314F9 # asm("nop");
612 000314F9 10 nop
613 000314FA # asm("nop");
614 000314FA 10 nop
615 000314FB # asm("std r6"); /* store the result (-op ) */
616 000314FB 27 56 std r6
617 000314FD # if( force_loop )
618 000314FD 5d effffffb2d tstl _force_loop
619 00031503 31 02 jeql L279
620 00031505 # asm("brb _pipe16_4_lp1");; /* run the loop again */
621 00031505 11 c4 brb _pipe16_4_lp1
622 00031507 L279:
623 00031507 # /*
624 00031507 # * verify the results
625 00031507 # */
626 00031507 # asm("movl r6,_sgl_value_3"); /* get the result */
627 00031507 0d 56 effffffb22 movl r6,_sgl_value_3
628 0003150E # asm("movl r7,_sgl_value_4");
629 0003150E 0d 57 effffffb1b movl r7,_sgl_value_4
630 00031515 # dbl_st_acc.m = sgl_value_3;
631 00031515 0d effffffb15 effffffb10 movl _sgl_value_3,_dbl_st_acc
632 00031520 # dbl_st_acc.l = sgl_value_4;
633 00031520 0d effffffb0a effffffb09 movl _sgl_value_4,_dbl_st_acc+4
634 0003152B # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
635 0003152B # (dbl_st_acc.l != dbl_expected.l) )
636 0003152B 1d effffffaff effffffafa cmpl _dbl_st_acc,_dbl_expected
637 00031536 21 0d jneq L9996
638 00031538 1d effffffaf6 effffffaf1 cmpl _dbl_st_acc+4,_dbl_expected+4
639 00031543 31 42 jeql L280
640 00031545 L9996:
641 00031545 # {
642 00031545 # errcnt++; /* bump the error count */
643 00031545 6d effffffae5 incl _errcnt
644 0003154B # if ( prt_error )
645 0003154B 5d effffffadf tstl _prt_error
646 00031551 31 0d jeql L281
647 00031553 # print_pipe16_er("Reg. Data, 3 NOPs");
648 00031553 .data 1
649 00000d73 * L282:
650 00000d73 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NOPs\0"
04E4F507300
651 00000d85 * .text
652 00031553 dd 8f00000d73 pushl $L282
653 00031559 fe 08 ef0000063a callf $8,_print_pipe16_er
654 00031560 # if ( halt_flg ) /* halt on error? */
655 00031560 L281:
656 00031560 5d effffffaca tstl _halt_flg
657 00031566 31 0d jeql L283
658 00031568 # pipe16_er_hlt( subtest );
659 00031568 dd effffffac2 pushl _subtest
660 0003156E fe 08 ef00000773 callf $8,_pipe16_er_hlt
661 00031575 # if ( loop_on_err ) {
662 00031575 L283:
663 00031575 5d effffffab5 tstl _loop_on_err
664 0003157B 31 0a jeql L284
665 0003157D # force_loop = TRUE; /* set the force loop flag */
666 0003157D 0d 01 effffffaac movl $1,_force_loop
667 00031584 # asm("brw _pipe16_4_lp1"); /* and loop */
668 00031584 13 ff44 brw _pipe16_4_lp1
669 00031587 # }
670 00031587 # } /* end of compare error */
671 00031587 L284:
672 00031587 # } while( index++ < max_lnd_1_index );
673 00031587 L280:
674 00031587 L277:
675 00031587 0d effffffaa3 50 movl _index,r0
676 0003158E 6d effffffa9c incl _index
677 00031594 1d 50 effffffa95 cmpl r0,_max_lnd_1_index
678 0003159B 81 03 13 fedb jlss L278
679 000315A0 L276:
680 000315A0 # } /* end of subtest 4 */
681 000315A0 40 ret#2
682 000315A1 .set L272,0x0
683 000315A1 L274:
684 000315A1 13 fecb jbr L275
685 000315A4 .data
686 00000d34 * .text
687 000315A4 .align 1
688 000315A4 .globl _pipe16_5
689 000315A4 _pipe16_5:
690 000315A4 0000 .word L285
691 000315A6 #
692 000315A6 #
693 000315A6 #
694 000315A6 #
695 000315A6 #
696 000315A6 #
697 000315A6 #
698 000315A6 # /************************************************************************
699 000315A6 # *
700 000315A6 # * SUBTEST 5
701 000315A6 # * data in cache, no NO-OPs
702 000315A6 # *
703 000315A6 # ************************************************************************/
704 000315A6 # pipe16_5()
705 000315A6 # {
706 000315A6 13 00f2 jbr L287
707 000315A9 L288:
708 000315A9 # force_loop = FALSE; /* clear the force_loop flg */
709 000315A9 4d effffffa81 clrl _force_loop
710 000315AF # index = 0;
711 000315AF 4d effffffa7b clrl _index
712 000315B5 # do
713 000315B5 L291:
714 000315B5 # {
715 000315B5 # dbl_value_1 = lnd_1_data[index].ld; /* get the operand */
716 000315B5 48 04 effffffa74 50 shll $4,_index,r0
717 000315BD 0c 8f00000000 50 addl2 $_lnd_1_data,r0
718 000315C4 0d a004 effffffa68 movl 4(r0),_dbl_value_1+4
719 000315CC 0d 60 effffffa5d movl (r0),_dbl_value_1
720 000315D3 # dbl_value_2.m = 0; /* set the '0.0' operand */
721 000315D3 4d effffffa57 clrl _dbl_value_2
722 000315D9 # dbl_value_2.l = 0;
723 000315D9 4d effffffa55 clrl _dbl_value_2+4
724 000315DF # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
725 000315DF 48 04 effffffa4a 50 shll $4,_index,r0
726 000315E7 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
727 000315EE 0d a004 effffffa3e movl 4(r0),_dbl_expected+4
728 000315F6 0d 60 effffffa33 movl (r0),_dbl_expected
729 000315FD # /*
730 000315FD # * If LOOP ON ERROR is set, this is the loop for this subtest.
731 000315FD # * The force loop flag is set after the first error.
732 000315FD # */
733 000315FD # asm("_pipe16_5_lp1:");
734 000315FD _pipe16_5_lp1:
735 000315FD # asm("lnd _dbl_value_1"); /* load a the op (-op ) */
736 000315FD 17 effffffa2d lnd _dbl_value_1
737 00031603 # asm("addd _dbl_value_1"); /* add the operand ( 0 ) */
738 00031603 c7 effffffa27 addd _dbl_value_1
739 00031609 # asm("subd _dbl_value_2"); /* subtract a '0.0' ( 0 ) */
740 00031609 d7 effffffa21 subd _dbl_value_2
741 0003160F # asm("subd _dbl_value_1"); /* subtract the op. (-op ) */
742 0003160F d7 effffffa1b subd _dbl_value_1
743 00031615 # asm("std _dbl_st_acc"); /* store the result (-op ) */
744 00031615 27 effffffa15 std _dbl_st_acc
745 0003161B # if( force_loop )
746 0003161B 5d effffffa0f tstl _force_loop
747 00031621 31 02 jeql L292
748 00031623 # asm("brb _pipe16_5_lp1");; /* run the loop again */
749 00031623 11 d8 brb _pipe16_5_lp1
750 00031625 L292:
751 00031625 # /*
752 00031625 # * verify the results
753 00031625 # */
754 00031625 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
755 00031625 # (dbl_st_acc.l != dbl_expected.l) )
756 00031625 1d effffffa05 effffffa00 cmpl _dbl_st_acc,_dbl_expected
757 00031630 21 0d jneq L9995
758 00031632 1d effffff9fc effffff9f7 cmpl _dbl_st_acc+4,_dbl_expected+4
759 0003163D 31 42 jeql L293
760 0003163F L9995:
761 0003163F # {
762 0003163F # errcnt++; /* bump the error count */
763 0003163F 6d effffff9eb incl _errcnt
764 00031645 # if ( prt_error )
765 00031645 5d effffff9e5 tstl _prt_error
766 0003164B 31 0d jeql L294
767 0003164D # print_pipe16_er("Cache Data, no NOPs");
768 0003164D .data 1
769 00000d85 * L295:
770 00000d85 * 436163686520446174612C206 .ascii "Cache Data, no NOPs\0"
E6F204E4F507300
771 00000d99 * .text
772 0003164D dd 8f00000d85 pushl $L295
773 00031653 fe 08 ef00000540 callf $8,_print_pipe16_er
774 0003165A # if ( halt_flg ) /* halt on error? */
775 0003165A L294:
776 0003165A 5d effffff9d0 tstl _halt_flg
777 00031660 31 0d jeql L296
778 00031662 # pipe16_er_hlt( subtest );
779 00031662 dd effffff9c8 pushl _subtest
780 00031668 fe 08 ef00000679 callf $8,_pipe16_er_hlt
781 0003166F # if ( loop_on_err ) {
782 0003166F L296:
783 0003166F 5d effffff9bb tstl _loop_on_err
784 00031675 31 0a jeql L297
785 00031677 # force_loop = TRUE; /* set the force loop flag */
786 00031677 0d 01 effffff9b2 movl $1,_force_loop
787 0003167E # asm("brw _pipe16_5_lp1"); /* and loop */
788 0003167E 13 ff7c brw _pipe16_5_lp1
789 00031681 # }
790 00031681 # } /* end of compare error */
791 00031681 L297:
792 00031681 # } while( index++ < max_lnd_1_index );
793 00031681 L293:
794 00031681 L290:
795 00031681 0d effffff9a9 50 movl _index,r0
796 00031688 6d effffff9a2 incl _index
797 0003168E 1d 50 effffff99b cmpl r0,_max_lnd_1_index
798 00031695 81 03 13 ff1b jlss L291
799 0003169A L289:
800 0003169A # } /* end of subtest 5 */
801 0003169A 40 ret#2
802 0003169B .set L285,0x0
803 0003169B L287:
804 0003169B 13 ff0b jbr L288
805 0003169E .data
806 00000d34 * .text
807 0003169E .align 1
808 0003169E .globl _pipe16_6
809 0003169E _pipe16_6:
810 0003169E 0000 .word L298
811 000316A0 #
812 000316A0 #
813 000316A0 #
814 000316A0 #
815 000316A0 #
816 000316A0 #
817 000316A0 #
818 000316A0 #
819 000316A0 # /************************************************************************
820 000316A0 # *
821 000316A0 # * SUBTEST 6
822 000316A0 # * data in cache, 1 NO-OP
823 000316A0 # *
824 000316A0 # ************************************************************************/
825 000316A0 # pipe16_6()
826 000316A0 # {
827 000316A0 13 00f6 jbr L300
828 000316A3 L301:
829 000316A3 # force_loop = FALSE; /* clear the force_loop flg */
830 000316A3 4d effffff987 clrl _force_loop
831 000316A9 # index = 0;
832 000316A9 4d effffff981 clrl _index
833 000316AF # do
834 000316AF L304:
835 000316AF # {
836 000316AF # dbl_value_1 = lnd_1_data[index].ld; /* get the operand */
837 000316AF 48 04 effffff97a 50 shll $4,_index,r0
838 000316B7 0c 8f00000000 50 addl2 $_lnd_1_data,r0
839 000316BE 0d a004 effffff96e movl 4(r0),_dbl_value_1+4
840 000316C6 0d 60 effffff963 movl (r0),_dbl_value_1
841 000316CD # dbl_value_2.m = 0; /* set the '0.0' operand */
842 000316CD 4d effffff95d clrl _dbl_value_2
843 000316D3 # dbl_value_2.l = 0;
844 000316D3 4d effffff95b clrl _dbl_value_2+4
845 000316D9 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
846 000316D9 48 04 effffff950 50 shll $4,_index,r0
847 000316E1 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
848 000316E8 0d a004 effffff944 movl 4(r0),_dbl_expected+4
849 000316F0 0d 60 effffff939 movl (r0),_dbl_expected
850 000316F7 # /*
851 000316F7 # * If LOOP ON ERROR is set, this is the loop for this subtest.
852 000316F7 # * The force loop flag is set after the first error.
853 000316F7 # */
854 000316F7 # asm("_pipe16_6_lp1:");
855 000316F7 _pipe16_6_lp1:
856 000316F7 # asm("lnd _dbl_value_1"); /* load a the op (-op ) */
857 000316F7 17 effffff933 lnd _dbl_value_1
858 000316FD # asm("nop");
859 000316FD 10 nop
860 000316FE # asm("addd _dbl_value_1"); /* add the operand ( 0 ) */
861 000316FE c7 effffff92c addd _dbl_value_1
862 00031704 # asm("nop");
863 00031704 10 nop
864 00031705 # asm("subd _dbl_value_2"); /* subtract a '0.0' ( 0 ) */
865 00031705 d7 effffff925 subd _dbl_value_2
866 0003170B # asm("nop");
867 0003170B 10 nop
868 0003170C # asm("subd _dbl_value_1"); /* subtract the op. (-op ) */
869 0003170C d7 effffff91e subd _dbl_value_1
870 00031712 # asm("nop");
871 00031712 10 nop
872 00031713 # asm("std _dbl_st_acc"); /* store the result (-op ) */
873 00031713 27 effffff917 std _dbl_st_acc
874 00031719 # if( force_loop )
875 00031719 5d effffff911 tstl _force_loop
876 0003171F 31 02 jeql L305
877 00031721 # asm("brb _pipe16_6_lp1");; /* run the loop again */
878 00031721 11 d4 brb _pipe16_6_lp1
879 00031723 L305:
880 00031723 # /*
881 00031723 # * verify the results
882 00031723 # */
883 00031723 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
884 00031723 # (dbl_st_acc.l != dbl_expected.l) )
885 00031723 1d effffff907 effffff902 cmpl _dbl_st_acc,_dbl_expected
886 0003172E 21 0d jneq L9994
887 00031730 1d effffff8fe effffff8f9 cmpl _dbl_st_acc+4,_dbl_expected+4
888 0003173B 31 42 jeql L306
889 0003173D L9994:
890 0003173D # {
891 0003173D # errcnt++; /* bump the error count */
892 0003173D 6d effffff8ed incl _errcnt
893 00031743 # if ( prt_error )
894 00031743 5d effffff8e7 tstl _prt_error
895 00031749 31 0d jeql L307
896 0003174B # print_pipe16_er("Cache Data, 1 NOP");
897 0003174B .data 1
898 00000d99 * L308:
899 00000d99 * 436163686520446174612C203 .ascii "Cache Data, 1 NOP\0"
1204E4F5000
900 00000dab * .text
901 0003174B dd 8f00000d99 pushl $L308
902 00031751 fe 08 ef00000442 callf $8,_print_pipe16_er
903 00031758 # if ( halt_flg ) /* halt on error? */
904 00031758 L307:
905 00031758 5d effffff8d2 tstl _halt_flg
906 0003175E 31 0d jeql L309
907 00031760 # pipe16_er_hlt( subtest );
908 00031760 dd effffff8ca pushl _subtest
909 00031766 fe 08 ef0000057b callf $8,_pipe16_er_hlt
910 0003176D # if ( loop_on_err ) {
911 0003176D L309:
912 0003176D 5d effffff8bd tstl _loop_on_err
913 00031773 31 0a jeql L310
914 00031775 # force_loop = TRUE; /* set the force loop flag */
915 00031775 0d 01 effffff8b4 movl $1,_force_loop
916 0003177C # asm("brw _pipe16_6_lp1"); /* and loop */
917 0003177C 13 ff78 brw _pipe16_6_lp1
918 0003177F # }
919 0003177F # } /* end of compare error */
920 0003177F L310:
921 0003177F # } while( index++ < max_lnd_1_index );
922 0003177F L306:
923 0003177F L303:
924 0003177F 0d effffff8ab 50 movl _index,r0
925 00031786 6d effffff8a4 incl _index
926 0003178C 1d 50 effffff89d cmpl r0,_max_lnd_1_index
927 00031793 81 03 13 ff17 jlss L304
928 00031798 L302:
929 00031798 # } /* end of subtest 6 */
930 00031798 40 ret#2
931 00031799 .set L298,0x0
932 00031799 L300:
933 00031799 13 ff07 jbr L301
934 0003179C .data
935 00000d34 * .text
936 0003179C .align 1
937 0003179C .globl _pipe16_7
938 0003179C _pipe16_7:
939 0003179C 0000 .word L311
940 0003179E #
941 0003179E #
942 0003179E #
943 0003179E #
944 0003179E #
945 0003179E #
946 0003179E #
947 0003179E #
948 0003179E # /************************************************************************
949 0003179E # *
950 0003179E # * SUBTEST 7
951 0003179E # * data in cache, 2 NO-OPs
952 0003179E # *
953 0003179E # ************************************************************************/
954 0003179E # pipe16_7()
955 0003179E # {
956 0003179E 13 00fa jbr L313
957 000317A1 L314:
958 000317A1 # force_loop = FALSE; /* clear the force_loop flg */
959 000317A1 4d effffff889 clrl _force_loop
960 000317A7 # index = 0;
961 000317A7 4d effffff883 clrl _index
962 000317AD # do
963 000317AD L317:
964 000317AD # {
965 000317AD # dbl_value_1 = lnd_1_data[index].ld; /* get the operand */
966 000317AD 48 04 effffff87c 50 shll $4,_index,r0
967 000317B5 0c 8f00000000 50 addl2 $_lnd_1_data,r0
968 000317BC 0d a004 effffff870 movl 4(r0),_dbl_value_1+4
969 000317C4 0d 60 effffff865 movl (r0),_dbl_value_1
970 000317CB # dbl_value_2.m = 0; /* set the '0.0' operand */
971 000317CB 4d effffff85f clrl _dbl_value_2
972 000317D1 # dbl_value_2.l = 0;
973 000317D1 4d effffff85d clrl _dbl_value_2+4
974 000317D7 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
975 000317D7 48 04 effffff852 50 shll $4,_index,r0
976 000317DF 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
977 000317E6 0d a004 effffff846 movl 4(r0),_dbl_expected+4
978 000317EE 0d 60 effffff83b movl (r0),_dbl_expected
979 000317F5 # /*
980 000317F5 # * If LOOP ON ERROR is set, this is the loop for this subtest.
981 000317F5 # * The force loop flag is set after the first error.
982 000317F5 # */
983 000317F5 # asm("_pipe16_7_lp1:");
984 000317F5 _pipe16_7_lp1:
985 000317F5 # asm("lnd _dbl_value_1"); /* load a the op (-op ) */
986 000317F5 17 effffff835 lnd _dbl_value_1
987 000317FB # asm("nop");
988 000317FB 10 nop
989 000317FC # asm("nop");
990 000317FC 10 nop
991 000317FD # asm("addd _dbl_value_1"); /* add the operand ( 0 ) */
992 000317FD c7 effffff82d addd _dbl_value_1
993 00031803 # asm("nop");
994 00031803 10 nop
995 00031804 # asm("nop");
996 00031804 10 nop
997 00031805 # asm("subd _dbl_value_2"); /* subtract a '0.0' ( 0 ) */
998 00031805 d7 effffff825 subd _dbl_value_2
999 0003180B # asm("nop");
1000 0003180B 10 nop
1001 0003180C # asm("nop");
1002 0003180C 10 nop
1003 0003180D # asm("subd _dbl_value_1"); /* subtract the op. (-op ) */
1004 0003180D d7 effffff81d subd _dbl_value_1
1005 00031813 # asm("nop");
1006 00031813 10 nop
1007 00031814 # asm("nop");
1008 00031814 10 nop
1009 00031815 # asm("std _dbl_st_acc"); /* store the result (-op ) */
1010 00031815 27 effffff815 std _dbl_st_acc
1011 0003181B # if( force_loop )
1012 0003181B 5d effffff80f tstl _force_loop
1013 00031821 31 02 jeql L318
1014 00031823 # asm("brb _pipe16_7_lp1");; /* run the loop again */
1015 00031823 11 d0 brb _pipe16_7_lp1
1016 00031825 L318:
1017 00031825 # /*
1018 00031825 # * verify the results
1019 00031825 # */
1020 00031825 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1021 00031825 # (dbl_st_acc.l != dbl_expected.l) )
1022 00031825 1d effffff805 effffff800 cmpl _dbl_st_acc,_dbl_expected
1023 00031830 21 0d jneq L9993
1024 00031832 1d effffff7fc effffff7f7 cmpl _dbl_st_acc+4,_dbl_expected+4
1025 0003183D 31 42 jeql L319
1026 0003183F L9993:
1027 0003183F # {
1028 0003183F # errcnt++; /* bump the error count */
1029 0003183F 6d effffff7eb incl _errcnt
1030 00031845 # if ( prt_error )
1031 00031845 5d effffff7e5 tstl _prt_error
1032 0003184B 31 0d jeql L320
1033 0003184D # print_pipe16_er("Cache Data, 2 NOPs");
1034 0003184D .data 1
1035 00000dab * L321:
1036 00000dab * 436163686520446174612C203 .ascii "Cache Data, 2 NOPs\0"
2204E4F507300
1037 00000dbe * .text
1038 0003184D dd 8f00000dab pushl $L321
1039 00031853 fe 08 ef00000340 callf $8,_print_pipe16_er
1040 0003185A # if ( halt_flg ) /* halt on error? */
1041 0003185A L320:
1042 0003185A 5d effffff7d0 tstl _halt_flg
1043 00031860 31 0d jeql L322
1044 00031862 # pipe16_er_hlt( subtest );
1045 00031862 dd effffff7c8 pushl _subtest
1046 00031868 fe 08 ef00000479 callf $8,_pipe16_er_hlt
1047 0003186F # if ( loop_on_err ) {
1048 0003186F L322:
1049 0003186F 5d effffff7bb tstl _loop_on_err
1050 00031875 31 0a jeql L323
1051 00031877 # force_loop = TRUE; /* set the force loop flag */
1052 00031877 0d 01 effffff7b2 movl $1,_force_loop
1053 0003187E # asm("brw _pipe16_7_lp1"); /* and loop */
1054 0003187E 13 ff74 brw _pipe16_7_lp1
1055 00031881 # }
1056 00031881 # } /* end of compare error */
1057 00031881 L323:
1058 00031881 # } while( index++ < max_lnd_1_index );
1059 00031881 L319:
1060 00031881 L316:
1061 00031881 0d effffff7a9 50 movl _index,r0
1062 00031888 6d effffff7a2 incl _index
1063 0003188E 1d 50 effffff79b cmpl r0,_max_lnd_1_index
1064 00031895 81 03 13 ff13 jlss L317
1065 0003189A L315:
1066 0003189A # } /* end of subtest 7 */
1067 0003189A 40 ret#2
1068 0003189B .set L311,0x0
1069 0003189B L313:
1070 0003189B 13 ff03 jbr L314
1071 0003189E .data
1072 00000d34 * .text
1073 0003189E .align 1
1074 0003189E .globl _pipe16_8
1075 0003189E _pipe16_8:
1076 0003189E 0000 .word L324
1077 000318A0 #
1078 000318A0 #
1079 000318A0 #
1080 000318A0 #
1081 000318A0 #
1082 000318A0 #
1083 000318A0 #
1084 000318A0 # /************************************************************************
1085 000318A0 # *
1086 000318A0 # * SUBTEST 8
1087 000318A0 # * data in cache, 3 NO-OPs
1088 000318A0 # *
1089 000318A0 # ************************************************************************/
1090 000318A0 # pipe16_8()
1091 000318A0 # {
1092 000318A0 13 00fe jbr L326
1093 000318A3 L327:
1094 000318A3 # force_loop = FALSE; /* clear the force_loop flg */
1095 000318A3 4d effffff787 clrl _force_loop
1096 000318A9 # index = 0;
1097 000318A9 4d effffff781 clrl _index
1098 000318AF # do
1099 000318AF L330:
1100 000318AF # {
1101 000318AF # dbl_value_1 = lnd_1_data[index].ld; /* get the operand */
1102 000318AF 48 04 effffff77a 50 shll $4,_index,r0
1103 000318B7 0c 8f00000000 50 addl2 $_lnd_1_data,r0
1104 000318BE 0d a004 effffff76e movl 4(r0),_dbl_value_1+4
1105 000318C6 0d 60 effffff763 movl (r0),_dbl_value_1
1106 000318CD # dbl_value_2.m = 0; /* set the '0.0' operand */
1107 000318CD 4d effffff75d clrl _dbl_value_2
1108 000318D3 # dbl_value_2.l = 0;
1109 000318D3 4d effffff75b clrl _dbl_value_2+4
1110 000318D9 # dbl_expected = lnd_1_data[index].exp; /* get the expected results */
1111 000318D9 48 04 effffff750 50 shll $4,_index,r0
1112 000318E1 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
1113 000318E8 0d a004 effffff744 movl 4(r0),_dbl_expected+4
1114 000318F0 0d 60 effffff739 movl (r0),_dbl_expected
1115 000318F7 # /*
1116 000318F7 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1117 000318F7 # * The force loop flag is set after the first error.
1118 000318F7 # */
1119 000318F7 # asm("_pipe16_8_lp1:");
1120 000318F7 _pipe16_8_lp1:
1121 000318F7 # asm("lnd _dbl_value_1"); /* load a the op (-op ) */
1122 000318F7 17 effffff733 lnd _dbl_value_1
1123 000318FD # asm("nop");
1124 000318FD 10 nop
1125 000318FE # asm("nop");
1126 000318FE 10 nop
1127 000318FF # asm("nop");
1128 000318FF 10 nop
1129 00031900 # asm("addd _dbl_value_1"); /* add the operand ( 0 ) */
1130 00031900 c7 effffff72a addd _dbl_value_1
1131 00031906 # asm("nop");
1132 00031906 10 nop
1133 00031907 # asm("nop");
1134 00031907 10 nop
1135 00031908 # asm("nop");
1136 00031908 10 nop
1137 00031909 # asm("subd _dbl_value_2"); /* subtract a '0.0' ( 0 ) */
1138 00031909 d7 effffff721 subd _dbl_value_2
1139 0003190F # asm("nop");
1140 0003190F 10 nop
1141 00031910 # asm("nop");
1142 00031910 10 nop
1143 00031911 # asm("nop");
1144 00031911 10 nop
1145 00031912 # asm("subd _dbl_value_1"); /* subtract the op. (-op ) */
1146 00031912 d7 effffff718 subd _dbl_value_1
1147 00031918 # asm("nop");
1148 00031918 10 nop
1149 00031919 # asm("nop");
1150 00031919 10 nop
1151 0003191A # asm("nop");
1152 0003191A 10 nop
1153 0003191B # asm("std _dbl_st_acc"); /* store the result (-op ) */
1154 0003191B 27 effffff70f std _dbl_st_acc
1155 00031921 # if( force_loop )
1156 00031921 5d effffff709 tstl _force_loop
1157 00031927 31 02 jeql L331
1158 00031929 # asm("brb _pipe16_8_lp1");; /* run the loop again */
1159 00031929 11 cc brb _pipe16_8_lp1
1160 0003192B L331:
1161 0003192B # /*
1162 0003192B # * verify the results
1163 0003192B # */
1164 0003192B # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1165 0003192B # (dbl_st_acc.l != dbl_expected.l) )
1166 0003192B 1d effffff6ff effffff6fa cmpl _dbl_st_acc,_dbl_expected
1167 00031936 21 0d jneq L9992
1168 00031938 1d effffff6f6 effffff6f1 cmpl _dbl_st_acc+4,_dbl_expected+4
1169 00031943 31 42 jeql L332
1170 00031945 L9992:
1171 00031945 # {
1172 00031945 # errcnt++; /* bump the error count */
1173 00031945 6d effffff6e5 incl _errcnt
1174 0003194B # if ( prt_error )
1175 0003194B 5d effffff6df tstl _prt_error
1176 00031951 31 0d jeql L333
1177 00031953 # print_pipe16_er("Cache Data, 3 NOPs");
1178 00031953 .data 1
1179 00000dbe * L334:
1180 00000dbe * 436163686520446174612C203 .ascii "Cache Data, 3 NOPs\0"
3204E4F507300
1181 00000dd1 * .text
1182 00031953 dd 8f00000dbe pushl $L334
1183 00031959 fe 08 ef0000023a callf $8,_print_pipe16_er
1184 00031960 # if ( halt_flg ) /* halt on error? */
1185 00031960 L333:
1186 00031960 5d effffff6ca tstl _halt_flg
1187 00031966 31 0d jeql L335
1188 00031968 # pipe16_er_hlt( subtest );
1189 00031968 dd effffff6c2 pushl _subtest
1190 0003196E fe 08 ef00000373 callf $8,_pipe16_er_hlt
1191 00031975 # if ( loop_on_err ) {
1192 00031975 L335:
1193 00031975 5d effffff6b5 tstl _loop_on_err
1194 0003197B 31 0a jeql L336
1195 0003197D # force_loop = TRUE; /* set the force loop flag */
1196 0003197D 0d 01 effffff6ac movl $1,_force_loop
1197 00031984 # asm("brw _pipe16_8_lp1"); /* and loop */
1198 00031984 13 ff70 brw _pipe16_8_lp1
1199 00031987 # }
1200 00031987 # } /* end of compare error */
1201 00031987 L336:
1202 00031987 # } while( index++ < max_lnd_1_index );
1203 00031987 L332:
1204 00031987 L329:
1205 00031987 0d effffff6a3 50 movl _index,r0
1206 0003198E 6d effffff69c incl _index
1207 00031994 1d 50 effffff695 cmpl r0,_max_lnd_1_index
1208 0003199B 81 03 13 ff0f jlss L330
1209 000319A0 L328:
1210 000319A0 # } /* end of subtest 8 */
1211 000319A0 40 ret#2
1212 000319A1 .set L324,0x0
1213 000319A1 L326:
1214 000319A1 13 feff jbr L327
1215 000319A4 .data
1216 00000d34 * .text
1217 000319A4 .align 1
1218 000319A4 .globl _pipe16_9
1219 000319A4 _pipe16_9:
1220 000319A4 0000 .word L337
1221 000319A6 #
1222 000319A6 #
1223 000319A6 #
1224 000319A6 #
1225 000319A6 #
1226 000319A6 #
1227 000319A6 #
1228 000319A6 #
1229 000319A6 #
1230 000319A6 # /******************************************************************************
1231 000319A6 # *
1232 000319A6 # * SUBTEST 9
1233 000319A6 # *
1234 000319A6 # * Get the data via the FRAME POINTER ( quad word indexed )
1235 000319A6 # *
1236 000319A6 # * ADDRESSES OF DATA OPERANDS INDEX DATA
1237 000319A6 # * pointer_data,-4 ( FP+24 ) 3 the STF result goes here
1238 000319A6 # * pointer_data-8,-12 ( FP+16 ) 2 <operand data>
1239 000319A6 # * pointer_data-16,-20 ( FP+8 ) 1 < '0.0' data>
1240 000319A6 # * pointer_data-24,-28 ( FP ) 0 point the frame pointer here
1241 000319A6 # *
1242 000319A6 # * NOTE: The double precision instructions are using Quad Word indexing.
1243 000319A6 # ******************************************************************************/
1244 000319A6 # pipe16_9()
1245 000319A6 # {
1246 000319A6 13 01ee jbr L339
1247 000319A9 L340:
1248 000319A9 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1249 000319A9 ed 6d effffff680 moval (r13),_pre_event_fp
1250 000319B0 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1251 000319B0 ed 6e effffff679 moval (r14),_pre_event_sp
1252 000319B7 # force_loop = FALSE; /* clear force_loop flag */
1253 000319B7 4d effffff673 clrl _force_loop
1254 000319BD # index = 0;
1255 000319BD 4d effffff66d clrl _index
1256 000319C3 # do
1257 000319C3 L343:
1258 000319C3 # {
1259 000319C3 # sgl_value_1 = lnd_1_data[index].ld.m; /* get operand 1's MSW */
1260 000319C3 0d effffff667 50 movl _index,r0
1261 000319CA 48 04 50 50 shll $4,r0,r0
1262 000319CE 0d e000000000 effffff657 movl _lnd_1_data(r0),_sgl_value_1
1263 000319D9 # sgl_value_2 = lnd_1_data[index].ld.l; /* get operand 1's LSW */
1264 000319D9 0d effffff651 50 movl _index,r0
1265 000319E0 48 04 50 50 shll $4,r0,r0
1266 000319E4 0d e000000004 effffff641 movl _lnd_1_data+4(r0),_sgl_value_2
1267 000319EF # sgl_value_7 = 0; /* get the '0.0' data */
1268 000319EF 4d effffff63b clrl _sgl_value_7
1269 000319F5 # dbl_expected = lnd_1_data[index].exp; /* get expected results */
1270 000319F5 48 04 effffff634 50 shll $4,_index,r0
1271 000319FD 0c 8f00000008 50 addl2 $_lnd_1_data+8,r0
1272 00031A04 0d a004 effffff628 movl 4(r0),_dbl_expected+4
1273 00031A0C 0d 60 effffff61d movl (r0),_dbl_expected
1274 00031A13 # /*
1275 00031A13 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1276 00031A13 # * The force loop flag is set after the first error.
1277 00031A13 # */
1278 00031A13 # asm("_pipe16_9_lp1:");
1279 00031A13 _pipe16_9_lp1:
1280 00031A13 # asm("moval _pointer_data,_sgl_value_9");/* get store data's addr */
1281 00031A13 ed effffff617 effffff612 moval _pointer_data,_sgl_value_9
1282 00031A1E # sgl_value_9 -= 8;
1283 00031A1E 2c 08 effffff60b subl2 $8,_sgl_value_9
1284 00031A25 # asm("movl _sgl_value_2,*_sgl_value_9"); /* set the operand's LSW */
1285 00031A25 0d effffff605 fffffff600 movl _sgl_value_2,*_sgl_value_9
1286 00031A30 # sgl_value_9 -= 4;
1287 00031A30 2c 04 effffff5f9 subl2 $4,_sgl_value_9
1288 00031A37 # asm("movl _sgl_value_1,*_sgl_value_9"); /* set the operand's MSW */
1289 00031A37 0d effffff5f3 fffffff5ee movl _sgl_value_1,*_sgl_value_9
1290 00031A42 # sgl_value_9 -= 4;
1291 00031A42 2c 04 effffff5e7 subl2 $4,_sgl_value_9
1292 00031A49 # asm("movl _sgl_value_7,*_sgl_value_9"); /* set '0.0' data's LSW */
1293 00031A49 0d effffff5e1 fffffff5dc movl _sgl_value_7,*_sgl_value_9
1294 00031A54 # sgl_value_9 -= 4;
1295 00031A54 2c 04 effffff5d5 subl2 $4,_sgl_value_9
1296 00031A5B # asm("movl _sgl_value_7,*_sgl_value_9"); /* set '0.0' data's MSW */
1297 00031A5B 0d effffff5cf fffffff5ca movl _sgl_value_7,*_sgl_value_9
1298 00031A66 # sgl_value_9 -= 8; /* get the FP addr to use */
1299 00031A66 2c 08 effffff5c3 subl2 $8,_sgl_value_9
1300 00031A6D # asm("movl _sgl_value_9,r13"); /* set the FRAME POINTER */
1301 00031A6D 0d effffff5bd 5d movl _sgl_value_9,r13
1302 00031A74 # asm("movl $1,r5"); /* r5 index = 1 quadwords */
1303 00031A74 0d 01 55 movl $1,r5
1304 00031A77 # asm("movl $2,r6"); /* r6 index = 2 quadwords */
1305 00031A77 0d 02 56 movl $2,r6
1306 00031A7A # asm("movl $3,r7"); /* r7 index = 3 quadwords */
1307 00031A7A 0d 03 57 movl $3,r7
1308 00031A7D # asm("lnd (r13)[r6]"); /* load the operand ( -op ) */
1309 00031A7D 17 466d lnd (r13)[r6]
1310 00031A80 # asm("addd (r13)[r6]"); /* add the operand ( 0 ) */
1311 00031A80 c7 466d addd (r13)[r6]
1312 00031A83 # asm("subd (r13)[r5]"); /* subtract a '0.0' ( 0 ) */
1313 00031A83 d7 456d subd (r13)[r5]
1314 00031A86 # asm("subd (r13)[r6]"); /* subtract the op. ( -op ) */
1315 00031A86 d7 466d subd (r13)[r6]
1316 00031A89 # asm("std (r13)[r7]"); /* store the result ( -op ) */
1317 00031A89 27 476d std (r13)[r7]
1318 00031A8C # if( force_loop )
1319 00031A8C 5d effffff59e tstl _force_loop
1320 00031A92 31 03 jeql L344
1321 00031A94 # asm("brw _pipe16_9_lp1");; /* run the loop again */
1322 00031A94 13 ff7c brw _pipe16_9_lp1
1323 00031A97 L344:
1324 00031A97 # /*
1325 00031A97 # * verify the results
1326 00031A97 # */
1327 00031A97 # asm("moval (r13),_sgl_value_10"); /* save the frame pointer */
1328 00031A97 ed 6d effffff592 moval (r13),_sgl_value_10
1329 00031A9E # asm("movl _pointer_data,_sgl_value_4"); /* save the LSW stored */
1330 00031A9E 0d effffff58c effffff587 movl _pointer_data,_sgl_value_4
1331 00031AA9 # asm("movl _pointer_data-4,_sgl_value_3"); /* and the MSW */
1332 00031AA9 0d effffff57d effffff57c movl _pointer_data-4,_sgl_value_3
1333 00031AB4 # if( (sgl_value_3 != dbl_expected.m) || /* verify the result... */
1334 00031AB4 # (sgl_value_4 != dbl_expected.l) || /* verify the result... */
1335 00031AB4 # (sgl_value_10 != sgl_value_9) ) /* ... and the final FP */
1336 00031AB4 1d effffff576 effffff571 cmpl _sgl_value_3,_dbl_expected
1337 00031ABF 21 1d jneq L9991
1338 00031AC1 1d effffff569 effffff568 cmpl _sgl_value_4,_dbl_expected+4
1339 00031ACC 21 10 jneq L9991
1340 00031ACE 1d effffff55c effffff557 cmpl _sgl_value_10,_sgl_value_9
1341 00031AD9 21 03 13 0091 jeql L345
1342 00031ADE L9991:
1343 00031ADE # {
1344 00031ADE # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1345 00031ADE 0d effffff54c 5d movl _pre_event_fp,r13
1346 00031AE5 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1347 00031AE5 0d effffff545 5e movl _pre_event_sp,r14
1348 00031AEC # errcnt++; /* bump the error count */
1349 00031AEC 6d effffff53e incl _errcnt
1350 00031AF2 # if ( prt_error ) {
1351 00031AF2 5d effffff538 tstl _prt_error
1352 00031AF8 31 4e jeql L346
1353 00031AFA # print_pipe16_er("indexed FP addressing");
1354 00031AFA .data 1
1355 00000dd1 * L347:
1356 00000dd1 * 696E646578656420465020616 .ascii "indexed FP addressing\0"
46472657373696E6700
1357 00000de7 * .text
1358 00031AFA dd 8f00000dd1 pushl $L347
1359 00031B00 fe 08 ef00000093 callf $8,_print_pipe16_er
1360 00031B07 # writes("final Frame Pointer = ");
1361 00031B07 .data 1
1362 00000de7 * L348:
1363 00000de7 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1364 00000dfe * .text
1365 00031B07 dd 8f00000de7 pushl $L348
1366 00031B0D fe 08 effffff51c callf $8,_writes
1367 00031B14 # writeh( sgl_value_10 );
1368 00031B14 dd effffff516 pushl _sgl_value_10
1369 00031B1A fe 08 effffff50f callf $8,_writeh
1370 00031B21 # writes(", expected FP = ");
1371 00031B21 .data 1
1372 00000dfe * L350:
1373 00000dfe * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1374 00000e10 * .text
1375 00031B21 dd 8f00000dfe pushl $L350
1376 00031B27 fe 08 effffff502 callf $8,_writes
1377 00031B2E # writeh( sgl_value_9 );
1378 00031B2E dd effffff4fc pushl _sgl_value_9
1379 00031B34 fe 08 effffff4f5 callf $8,_writeh
1380 00031B3B # writes("\n");
1381 00031B3B .data 1
1382 00000e10 * L351:
1383 00000e10 * 0A00 .ascii "\12\0"
1384 00000e12 * .text
1385 00031B3B dd 8f00000e10 pushl $L351
1386 00031B41 fe 08 effffff4e8 callf $8,_writes
1387 00031B48 # }
1388 00031B48 # if ( halt_flg ) /* halt on error? */
1389 00031B48 L346:
1390 00031B48 5d effffff4e2 tstl _halt_flg
1391 00031B4E 31 0d jeql L352
1392 00031B50 # pipe16_er_hlt( subtest );
1393 00031B50 dd effffff4da pushl _subtest
1394 00031B56 fe 08 ef0000018b callf $8,_pipe16_er_hlt
1395 00031B5D # if ( loop_on_err ) {
1396 00031B5D L352:
1397 00031B5D 5d effffff4cd tstl _loop_on_err
1398 00031B63 31 0a jeql L353
1399 00031B65 # force_loop = TRUE; /* set the force loop flag */
1400 00031B65 0d 01 effffff4c4 movl $1,_force_loop
1401 00031B6C # asm("brw _pipe16_9_lp1"); /* and loop */
1402 00031B6C 13 fea4 brw _pipe16_9_lp1
1403 00031B6F # }
1404 00031B6F # } /* end of compare error */
1405 00031B6F L353:
1406 00031B6F # } while( index++ < max_lnd_1_index );
1407 00031B6F L345:
1408 00031B6F L342:
1409 00031B6F 0d effffff4bb 50 movl _index,r0
1410 00031B76 6d effffff4b4 incl _index
1411 00031B7C 1d 50 effffff4ad cmpl r0,_max_lnd_1_index
1412 00031B83 81 03 13 fe3b jlss L343
1413 00031B88 L341:
1414 00031B88 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1415 00031B88 0d effffff4a2 5d movl _pre_event_fp,r13
1416 00031B8F # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1417 00031B8F 0d effffff49b 5e movl _pre_event_sp,r14
1418 00031B96 # } /* end of subtest 9 */
1419 00031B96 40 ret#2
1420 00031B97 .set L337,0x0
1421 00031B97 L339:
1422 00031B97 13 fe0f jbr L340
1423 00031B9A .data
1424 00000d34 * .text
1425 00031B9A .align 1
1426 00031B9A .globl _print_pipe16_er
1427 00031B9A _print_pipe16_er:
1428 00031B9A 0000 .word L354
1429 00031B9C #
1430 00031B9C #
1431 00031B9C # /******************************************************************************
1432 00031B9C # *
1433 00031B9C # * ERROR ROUTINE
1434 00031B9C # *
1435 00031B9C # * print an error in the following form
1436 00031B9C # *
1437 00031B9C # *operand = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd
1438 00031B9C # * expected Acc = xxxxxxxx xxxxxxxx
1439 00031B9C # *
1440 00031B9C # ******************************************************************************/
1441 00031B9C # print_pipe16_er(msg)
1442 00031B9C # char *msg;
1443 00031B9C # {
1444 00031B9C 13 0145 jbr L356
1445 00031B9F L357:
1446 00031B9F # writes("\n"); /* start a new print line */
1447 00031B9F .data 1
1448 00000e12 * L358:
1449 00000e12 * 0A00 .ascii "\12\0"
1450 00000e14 * .text
1451 00031B9F dd 8f00000e12 pushl $L358
1452 00031BA5 fe 08 effffff484 callf $8,_writes
1453 00031BAC # writes("cycle: ");
1454 00031BAC .data 1
1455 00000e14 * L359:
1456 00000e14 * 6379636C653A2000 .ascii "cycle: \0"
1457 00000e1c * .text
1458 00031BAC dd 8f00000e14 pushl $L359
1459 00031BB2 fe 08 effffff477 callf $8,_writes
1460 00031BB9 # writed( cycle );
1461 00031BB9 dd effffff471 pushl _cycle
1462 00031BBF fe 08 effffff46a callf $8,_writed
1463 00031BC6 # writes(" test ");
1464 00031BC6 .data 1
1465 00000e1c * L361:
1466 00000e1c * 20746573742000 .ascii " test \0"
1467 00000e23 * .text
1468 00031BC6 dd 8f00000e1c pushl $L361
1469 00031BCC fe 08 effffff45d callf $8,_writes
1470 00031BD3 # writed( test_no );
1471 00031BD3 dd effffff457 pushl _test_no
1472 00031BD9 fe 08 effffff450 callf $8,_writed
1473 00031BE0 # writes(" (Pipe 16), subtest ");
1474 00031BE0 .data 1
1475 00000e23 * L362:
1476 00000e23 * 20202850697065203136292C2 .ascii " (Pipe 16), subtest \0"
0737562746573742000
1477 00000e39 * .text
1478 00031BE0 dd 8f00000e23 pushl $L362
1479 00031BE6 fe 08 effffff443 callf $8,_writes
1480 00031BED # writed( subtest );
1481 00031BED dd effffff43d pushl _subtest
1482 00031BF3 fe 08 effffff436 callf $8,_writed
1483 00031BFA # writes(" error - ");
1484 00031BFA .data 1
1485 00000e39 * L363:
1486 00000e39 * 206572726F72202D2000 .ascii " error - \0"
1487 00000e43 * .text
1488 00031BFA dd 8f00000e39 pushl $L363
1489 00031C00 fe 08 effffff429 callf $8,_writes
1490 00031C07 # writes( msg );
1491 00031C07 dd ad04 pushl 4(fp)
1492 00031C0A fe 08 effffff41f callf $8,_writes
1493 00031C11 # writec('\n');
1494 00031C11 dd 0a pushl $10
1495 00031C13 fe 08 effffff416 callf $8,_writec
1496 00031C1A # writes(" LND(op), ADDD(op), SUBD(0.0), SUBD(op), STD\n");
1497 00031C1A .data 1
1498 00000e43 * L365:
1499 00000e43 * 204C4E44286F70292C2041444 .ascii " LND(op), ADDD(op), SUBD(0.0), SUBD(op), STD\12\0"
444286F70292C205355424428
302E30292C2053554244286F7
0292C205354440A00
1500 00000e71 * .text
1501 00031C1A dd 8f00000e43 pushl $L365
1502 00031C20 fe 08 effffff409 callf $8,_writes
1503 00031C27 # writes("operand = ");
1504 00031C27 .data 1
1505 00000e71 * L366:
1506 00000e71 * 6F706572616E64203D2000 .ascii "operand = \0"
1507 00000e7c * .text
1508 00031C27 dd 8f00000e71 pushl $L366
1509 00031C2D fe 08 effffff3fc callf $8,_writes
1510 00031C34 # write32h( dbl_ld_acc.m );
1511 00031C34 dd effffff3f6 pushl _dbl_ld_acc
1512 00031C3A fe 08 effffff3ef callf $8,_write32h
1513 00031C41 # writec(' ');
1514 00031C41 dd 20 pushl $32
1515 00031C43 fe 08 effffff3e6 callf $8,_writec
1516 00031C4A # write32h( dbl_ld_acc.l );
1517 00031C4A dd effffff3e4 pushl _dbl_ld_acc+4
1518 00031C50 fe 08 effffff3d9 callf $8,_write32h
1519 00031C57 # writes(", final Acc = ");
1520 00031C57 .data 1
1521 00000e7c * L368:
1522 00000e7c * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
3203D2000
1523 00000e8d * .text
1524 00031C57 dd 8f00000e7c pushl $L368
1525 00031C5D fe 08 effffff3cc callf $8,_writes
1526 00031C64 # write32h( dbl_st_acc.m );
1527 00031C64 dd effffff3c6 pushl _dbl_st_acc
1528 00031C6A fe 08 effffff3bf callf $8,_write32h
1529 00031C71 # writec(' ');
1530 00031C71 dd 20 pushl $32
1531 00031C73 fe 08 effffff3b6 callf $8,_writec
1532 00031C7A # write32h( dbl_st_acc.l );
1533 00031C7A dd effffff3b4 pushl _dbl_st_acc+4
1534 00031C80 fe 08 effffff3a9 callf $8,_write32h
1535 00031C87 # writes(", index = ");
1536 00031C87 .data 1
1537 00000e8d * L369:
1538 00000e8d * 2C202020696E646578203D200 .ascii ", index = \0"
0
1539 00000e9a * .text
1540 00031C87 dd 8f00000e8d pushl $L369
1541 00031C8D fe 08 effffff39c callf $8,_writes
1542 00031C94 # writed( index );
1543 00031C94 dd effffff396 pushl _index
1544 00031C9A fe 08 effffff38f callf $8,_writed
1545 00031CA1 # writec('\n');
1546 00031CA1 dd 0a pushl $10
1547 00031CA3 fe 08 effffff386 callf $8,_writec
1548 00031CAA # writes(" expected Acc = ");
1549 00031CAA .data 1
1550 00000e9a * L370:
1551 00000e9a * 2020202020202020202020202 .ascii " expected Acc = \0"
0202020202020202020202020
2020206578706563746564204
16363203D2000
1552 00000ec6 * .text
1553 00031CAA dd 8f00000e9a pushl $L370
1554 00031CB0 fe 08 effffff379 callf $8,_writes
1555 00031CB7 # write32h( dbl_expected.m );
1556 00031CB7 dd effffff373 pushl _dbl_expected
1557 00031CBD fe 08 effffff36c callf $8,_write32h
1558 00031CC4 # writec(' ');
1559 00031CC4 dd 20 pushl $32
1560 00031CC6 fe 08 effffff363 callf $8,_writec
1561 00031CCD # write32h( dbl_expected.l );
1562 00031CCD dd effffff361 pushl _dbl_expected+4
1563 00031CD3 fe 08 effffff356 callf $8,_write32h
1564 00031CDA # writec('\n');
1565 00031CDA dd 0a pushl $10
1566 00031CDC fe 08 effffff34d callf $8,_writec
1567 00031CE3 # }
1568 00031CE3 40 ret#2
1569 00031CE4 .set L354,0x0
1570 00031CE4 L356:
1571 00031CE4 13 feb8 jbr L357
1572 00031CE7 .data
1573 00000d34 * .text
1574 00031CE7 00 .align 1
1575 00031CE8 .globl _pipe16_er_hlt
1576 00031CE8 _pipe16_er_hlt:
1577 00031CE8 0000 .word L371
1578 00031CEA #
1579 00031CEA #
1580 00031CEA #
1581 00031CEA #
1582 00031CEA #
1583 00031CEA # /******************************************************************************
1584 00031CEA # *
1585 00031CEA # * HALT ON ERROR ROUTINE
1586 00031CEA # *
1587 00031CEA # * halt with the necessary information saved in the registers
1588 00031CEA # *
1589 00031CEA # ******************************************************************************/
1590 00031CEA # pipe16_er_hlt( subtest )
1591 00031CEA # int subtest;
1592 00031CEA # {
1593 00031CEA 11 75 jbr L373
1594 00031CEC L374:
1595 00031CEC # sgl_value_3 = dbl_st_acc.m;
1596 00031CEC 0d effffff33e effffff339 movl _dbl_st_acc,_sgl_value_3
1597 00031CF7 # sgl_value_4 = dbl_st_acc.l;
1598 00031CF7 0d effffff337 effffff32e movl _dbl_st_acc+4,_sgl_value_4
1599 00031D02 # asm("movl _test_no,r0"); /* r0 = test number */
1600 00031D02 0d effffff328 50 movl _test_no,r0
1601 00031D09 # asm("movl _subtest,r1"); /* r1 = subtest number */
1602 00031D09 0d effffff321 51 movl _subtest,r1
1603 00031D10 # asm("movl $1,r2"); /* r2 = error code */
1604 00031D10 0d 01 52 movl $1,r2
1605 00031D13 # asm("movl _cycle,r3"); /* r3 = cycle count */
1606 00031D13 0d effffff317 53 movl _cycle,r3
1607 00031D1A # asm("movl _sgl_value_1,r4"); /* r4 = MSW operand loaded */
1608 00031D1A 0d effffff310 54 movl _sgl_value_1,r4
1609 00031D21 # asm("movl _sgl_value_2,r5"); /* r5 = LSW operand loaded */
1610 00031D21 0d effffff309 55 movl _sgl_value_2,r5
1611 00031D28 # asm("movl _sgl_value_3,r6"); /* r6 = MSW operand stored */
1612 00031D28 0d effffff302 56 movl _sgl_value_3,r6
1613 00031D2F # asm("movl _sgl_value_4,r7"); /* r7 = LSW operand stored */
1614 00031D2F 0d effffff2fb 57 movl _sgl_value_4,r7
1615 00031D36 # asm("movl _sgl_value_5,r8"); /* r8 = MSW operand expect */
1616 00031D36 0d effffff2f4 58 movl _sgl_value_5,r8
1617 00031D3D # asm("movl _sgl_value_6,r9"); /* r9 = LSW operand expect */
1618 00031D3D 0d effffff2ed 59 movl _sgl_value_6,r9
1619 00031D44 # asm("movl _index,r10"); /* r10 = data index */
1620 00031D44 0d effffff2e6 5a movl _index,r10
1621 00031D4B # if( subtest == 9 ) {
1622 00031D4B 1d ad04 09 cmpl 4(fp),$9
1623 00031D4F 21 0e jneq L375
1624 00031D51 # asm("movl _sgl_value_10,r11"); /* r11 = final FP value */
1625 00031D51 0d effffff2d9 5b movl _sgl_value_10,r11
1626 00031D58 # asm("movl _sgl_value_9,r12"); /* r12 = expected FP value */
1627 00031D58 0d effffff2d2 5c movl _sgl_value_9,r12
1628 00031D5F # };
1629 00031D5F L375:
1630 00031D5F # asm(".globl _pipe16_1_hlt");
1631 00031D5F .globl _pipe16_1_hlt
1632 00031D5F # asm("_pipe16_1_hlt:"); /* PC after the halt */
1633 00031D5F _pipe16_1_hlt:
1634 00031D5F # asm("halt"); /* HALT ... */
1635 00031D5F 00 halt
1636 00031D60 # } /* end of halt on error */
1637 00031D60 40 ret#2
1638 00031D61 .set L371,0x0
1639 00031D61 L373:
1640 00031D61 11 89 jbr L374
1641 00031D63 .data
1641 00062D93 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.