![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe8.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 pipe8.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 00000d5c * .text
4 00000000 .align 1
5 00000000 .globl _pipe_8
6 00000000 _pipe_8:
7 0002BC54 0000 .word L215
8 0002BC56 # #include "fpp_defs.h"
9 0002BC56 #
10 0002BC56 #
11 0002BC56 # /*****************************************************************************
12 0002BC56 # *
13 0002BC56 # * PIPELINE TEST #8 MONITOR
14 0002BC56 # *
15 0002BC56 # * This test will do:
16 0002BC56 # *
17 0002BC56 # * LDF(1), SUBF(2), MULF(x), ADDF(x), ADDF(x), STF
18 0002BC56 # *
19 0002BC56 # * where x is the fmacro1 LDF data.
20 0002BC56 # *****************************************************************************/
21 0002BC56 # pipe_8()
22 0002BC56 # {
23 0002BC56 13 00a8 jbr L217
24 0002BC59 L218:
25 0002BC59 # asm(".globl _pipeline_8_t");
26 0002BC59 .globl _pipeline_8_t
27 0002BC59 # asm("_pipeline_8_t:"); /* entry address */
28 0002BC59 _pipeline_8_t:
29 0002BC59 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
30 0002BC59 1d effffffff5 01 cmpl _cycle,$1
31 0002BC60 21 15 jneq L219
32 0002BC62 5d efffffffec tstl _prt_hdrs
33 0002BC68 31 0d jeql L219
34 0002BC6A # {
35 0002BC6A # writes("\n PIPE_8 ");
36 0002BC6A .data 1
37 00000d5c * L221:
38 00000d5c * 0A20504950455F382000 .ascii "\12 PIPE_8 \0"
39 00000d66 * .text
40 0002BC6A dd 8f00000d5c pushl $L221
41 0002BC70 fe 08 efffffffdd callf $8,_writes
42 0002BC77 # }
43 0002BC77 # subtest = 1;
44 0002BC77 L219:
45 0002BC77 0d 01 efffffffd6 movl $1,_subtest
46 0002BC7E # pipe8_1(); /* data in REGs, no NOPs */
47 0002BC7E fe 04 ef0000007f callf $4,_pipe8_1
48 0002BC85 # subtest++; /* increment subtest num */
49 0002BC85 6d efffffffc9 incl _subtest
50 0002BC8B # pipe8_2(); /* data in REGs, 1 NOP */
51 0002BC8B fe 04 ef00000166 callf $4,_pipe8_2
52 0002BC92 # subtest++; /* increment subtest num */
53 0002BC92 6d efffffffbc incl _subtest
54 0002BC98 # pipe8_3(); /* data in REGs, 2 NOPs */
55 0002BC98 fe 04 ef00000253 callf $4,_pipe8_3
56 0002BC9F # subtest++; /* increment subtest num */
57 0002BC9F 6d efffffffaf incl _subtest
58 0002BCA5 # pipe8_4(); /* data in REGs, 3 NOPs */
59 0002BCA5 fe 04 ef00000344 callf $4,_pipe8_4
60 0002BCAC # subtest++; /* increment subtest num */
61 0002BCAC 6d efffffffa2 incl _subtest
62 0002BCB2 # pipe8_5(); /* data in CACHE, no NOPs */
63 0002BCB2 fe 04 ef0000043b callf $4,_pipe8_5
64 0002BCB9 # subtest++; /* increment subtest num */
65 0002BCB9 6d efffffff95 incl _subtest
66 0002BCBF # pipe8_6(); /* data in CACHE, 1 NOP */
67 0002BCBF fe 04 ef0000051e callf $4,_pipe8_6
68 0002BCC6 # subtest++; /* increment subtest num */
69 0002BCC6 6d efffffff88 incl _subtest
70 0002BCCC # pipe8_7(); /* data in CACHE, 2 NOPs */
71 0002BCCC fe 04 ef00000607 callf $4,_pipe8_7
72 0002BCD3 # subtest++; /* increment subtest num */
73 0002BCD3 6d efffffff7b incl _subtest
74 0002BCD9 # pipe8_8(); /* data in CACHE, 3 NOPs */
75 0002BCD9 fe 04 ef000006f4 callf $4,_pipe8_8
76 0002BCE0 # subtest++; /* increment subtest num */
77 0002BCE0 6d efffffff6e incl _subtest
78 0002BCE6 # pipe8_9(); /* data on STACK, no NOPs */
79 0002BCE6 fe 04 ef000007e7 callf $4,_pipe8_9
80 0002BCED # subtest++; /* increment subtest num */
81 0002BCED 6d efffffff61 incl _subtest
82 0002BCF3 # pipe8_10(); /* data via FP no NOPs */
83 0002BCF3 fe 04 ef00000970 callf $4,_pipe8_10
84 0002BCFA # asm("jmp *return"); /* return to the test monitor */
85 0002BCFA 71 ffffffff54 jmp *return
86 0002BD00 # }
87 0002BD00 40 ret#2
88 0002BD01 .set L215,0x0
89 0002BD01 L217:
90 0002BD01 13 ff55 jbr L218
91 0002BD04 .data
92 00000d5c * .text
93 0002BD04 .align 1
94 0002BD04 .globl _pipe8_1
95 0002BD04 _pipe8_1:
96 0002BD04 0000 .word L232
97 0002BD06 #
98 0002BD06 #
99 0002BD06 #
100 0002BD06 #
101 0002BD06 #
102 0002BD06 #
103 0002BD06 # /************************************************************************
104 0002BD06 # *
105 0002BD06 # * SUBTEST 1
106 0002BD06 # * data in registers, no NO-OPs
107 0002BD06 # *
108 0002BD06 # ************************************************************************/
109 0002BD06 # pipe8_1()
110 0002BD06 # {
111 0002BD06 13 00ec jbr L234
112 0002BD09 L235:
113 0002BD09 # force_loop = FALSE; /* clear force_loop flag */
114 0002BD09 4d efffffff45 clrl _force_loop
115 0002BD0F # index = 0;
116 0002BD0F 4d efffffff3f clrl _index
117 0002BD15 # do
118 0002BD15 L238:
119 0002BD15 # {
120 0002BD15 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
121 0002BD15 0d efffffff39 50 movl _index,r0
122 0002BD1C 48 03 50 50 shll $3,r0,r0
123 0002BD20 0d e000000000 efffffff29 movl _ldf_1_data(r0),_sgl_value_1
124 0002BD2B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
125 0002BD2B 0d efffffff23 50 movl _index,r0
126 0002BD32 48 03 50 50 shll $3,r0,r0
127 0002BD36 0d e000000004 efffffff13 movl _ldf_1_data+4(r0),_sgl_expected
128 0002BD41 # sgl_value_2 = 0x40800000; /* floating '1' */
129 0002BD41 0d 8f40800000 efffffff08 movl $1082130432,_sgl_value_2
130 0002BD4C # sgl_value_3 = 0x41000000; /* floating '2' */
131 0002BD4C 0d 8f41000000 effffffefd movl $1090519040,_sgl_value_3
132 0002BD57 # /*
133 0002BD57 # * If LOOP ON ERROR is set, this is the loop for this subtest.
134 0002BD57 # * The force loop flag is set after the first error.
135 0002BD57 # */
136 0002BD57 # asm("_pipe8_1_lp1:");
137 0002BD57 _pipe8_1_lp1:
138 0002BD57 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
139 0002BD57 0d effffffef7 54 movl _sgl_value_1,r4
140 0002BD5E # asm("movl _sgl_value_2,r5"); /* move data to r5 */
141 0002BD5E 0d effffffef0 55 movl _sgl_value_2,r5
142 0002BD65 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
143 0002BD65 0d effffffee9 56 movl _sgl_value_3,r6
144 0002BD6C # asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
145 0002BD6C 06 55 ldf r5
146 0002BD6E # asm("subf r6"); /* minus 2.0 (-1.0 ) */
147 0002BD6E d6 56 subf r6
148 0002BD70 # asm("mulf r4"); /* *'s the operand ( -op ) */
149 0002BD70 e6 54 mulf r4
150 0002BD72 # asm("addf r4"); /* + the operand ( 0 ) */
151 0002BD72 c6 54 addf r4
152 0002BD74 # asm("addf r4"); /* + the operand ( +op ) */
153 0002BD74 c6 54 addf r4
154 0002BD76 # asm("stf r7"); /* store the result */
155 0002BD76 26 57 stf r7
156 0002BD78 # if( force_loop )
157 0002BD78 5d effffffed6 tstl _force_loop
158 0002BD7E 31 02 jeql L239
159 0002BD80 # asm("brb _pipe8_1_lp1");; /* loop on the error */
160 0002BD80 11 d5 brb _pipe8_1_lp1
161 0002BD82 L239:
162 0002BD82 # /*
163 0002BD82 # * verify the results
164 0002BD82 # */
165 0002BD82 # asm("movl r7,_sgl_st_acc"); /* get the result */
166 0002BD82 0d 57 effffffecb movl r7,_sgl_st_acc
167 0002BD89 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
168 0002BD89 1d effffffec5 effffffec0 cmpl _sgl_st_acc,_sgl_expected
169 0002BD94 31 45 jeql L240
170 0002BD96 # {
171 0002BD96 # errcnt++; /* bump the error count */
172 0002BD96 6d effffffeb8 incl _errcnt
173 0002BD9C # if ( prt_error )
174 0002BD9C 5d effffffeb2 tstl _prt_error
175 0002BDA2 31 0d jeql L241
176 0002BDA4 # print_pipe8_er("Reg. Data, no NO-OPs");
177 0002BDA4 .data 1
178 00000d66 * L243:
179 00000d66 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0"
F204E4F2D4F507300
180 00000d7b * .text
181 0002BDA4 dd 8f00000d66 pushl $L243
182 0002BDAA fe 08 ef00000a7f callf $8,_print_pipe8_er
183 0002BDB1 # if ( halt_flg )
184 0002BDB1 L241:
185 0002BDB1 5d effffffe9d tstl _halt_flg
186 0002BDB7 31 0d jeql L244
187 0002BDB9 # pipe8_er_hlt( subtest );
188 0002BDB9 dd effffffe95 pushl _subtest
189 0002BDBF fe 08 ef00000b76 callf $8,_pipe8_er_hlt
190 0002BDC6 # if ( loop_on_err ) {
191 0002BDC6 L244:
192 0002BDC6 5d effffffe88 tstl _loop_on_err
193 0002BDCC 31 0d jeql L246
194 0002BDCE # force_loop = TRUE; /* set the force loop flag */
195 0002BDCE 0d 01 effffffe7f movl $1,_force_loop
196 0002BDD5 # asm("jmp _pipe8_1_lp1"); /* and loop */
197 0002BDD5 71 efffffff7c jmp _pipe8_1_lp1
198 0002BDDB # }
199 0002BDDB # } /* end of compare error */
200 0002BDDB L246:
201 0002BDDB # } while( index++ < max_ldf_1_index );
202 0002BDDB L240:
203 0002BDDB L237:
204 0002BDDB 0d effffffe73 50 movl _index,r0
205 0002BDE2 6d effffffe6c incl _index
206 0002BDE8 1d 50 effffffe65 cmpl r0,_max_ldf_1_index
207 0002BDEF 81 03 13 ff21 jlss L238
208 0002BDF4 L236:
209 0002BDF4 # } /* end of subtest 1 */
210 0002BDF4 40 ret#2
211 0002BDF5 .set L232,0x0
212 0002BDF5 L234:
213 0002BDF5 13 ff11 jbr L235
214 0002BDF8 .data
215 00000d5c * .text
216 0002BDF8 .align 1
217 0002BDF8 .globl _pipe8_2
218 0002BDF8 _pipe8_2:
219 0002BDF8 0000 .word L247
220 0002BDFA #
221 0002BDFA #
222 0002BDFA #
223 0002BDFA #
224 0002BDFA #
225 0002BDFA #
226 0002BDFA # /************************************************************************
227 0002BDFA # *
228 0002BDFA # * SUBTEST 2
229 0002BDFA # * data in registers, 1 NO-OP
230 0002BDFA # *
231 0002BDFA # ************************************************************************/
232 0002BDFA # pipe8_2()
233 0002BDFA # {
234 0002BDFA 13 00f1 jbr L249
235 0002BDFD L250:
236 0002BDFD # force_loop = FALSE; /* clear force_loop flag */
237 0002BDFD 4d effffffe51 clrl _force_loop
238 0002BE03 # index = 0;
239 0002BE03 4d effffffe4b clrl _index
240 0002BE09 # do
241 0002BE09 L253:
242 0002BE09 # {
243 0002BE09 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
244 0002BE09 0d effffffe45 50 movl _index,r0
245 0002BE10 48 03 50 50 shll $3,r0,r0
246 0002BE14 0d e000000000 effffffe35 movl _ldf_1_data(r0),_sgl_value_1
247 0002BE1F # sgl_expected = ldf_1_data[index].exp; /* get expected results */
248 0002BE1F 0d effffffe2f 50 movl _index,r0
249 0002BE26 48 03 50 50 shll $3,r0,r0
250 0002BE2A 0d e000000004 effffffe1f movl _ldf_1_data+4(r0),_sgl_expected
251 0002BE35 # sgl_value_2 = 0x40800000; /* floating '1' */
252 0002BE35 0d 8f40800000 effffffe14 movl $1082130432,_sgl_value_2
253 0002BE40 # sgl_value_3 = 0x41000000; /* floating '2' */
254 0002BE40 0d 8f41000000 effffffe09 movl $1090519040,_sgl_value_3
255 0002BE4B # /*
256 0002BE4B # * If LOOP ON ERROR is set, this is the loop for this subtest.
257 0002BE4B # * The force loop flag is set after the first error.
258 0002BE4B # */
259 0002BE4B # asm("_pipe8_2_lp1:");
260 0002BE4B _pipe8_2_lp1:
261 0002BE4B # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
262 0002BE4B 0d effffffe03 54 movl _sgl_value_1,r4
263 0002BE52 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
264 0002BE52 0d effffffdfc 55 movl _sgl_value_2,r5
265 0002BE59 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
266 0002BE59 0d effffffdf5 56 movl _sgl_value_3,r6
267 0002BE60 # asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
268 0002BE60 06 55 ldf r5
269 0002BE62 # asm("nop");
270 0002BE62 10 nop
271 0002BE63 # asm("subf r6"); /* minus 2.0 (-1.0 ) */
272 0002BE63 d6 56 subf r6
273 0002BE65 # asm("nop");
274 0002BE65 10 nop
275 0002BE66 # asm("mulf r4"); /* *'s the operand ( -op ) */
276 0002BE66 e6 54 mulf r4
277 0002BE68 # asm("nop");
278 0002BE68 10 nop
279 0002BE69 # asm("addf r4"); /* + the operand ( 0 ) */
280 0002BE69 c6 54 addf r4
281 0002BE6B # asm("nop");
282 0002BE6B 10 nop
283 0002BE6C # asm("addf r4"); /* + the operand ( +op ) */
284 0002BE6C c6 54 addf r4
285 0002BE6E # asm("nop");
286 0002BE6E 10 nop
287 0002BE6F # asm("stf r7"); /* store the result */
288 0002BE6F 26 57 stf r7
289 0002BE71 # if( force_loop )
290 0002BE71 5d effffffddd tstl _force_loop
291 0002BE77 31 02 jeql L254
292 0002BE79 # asm("brb _pipe8_2_lp1");; /* loop on the error */
293 0002BE79 11 d0 brb _pipe8_2_lp1
294 0002BE7B L254:
295 0002BE7B # /*
296 0002BE7B # * verify the results
297 0002BE7B # */
298 0002BE7B # asm("movl r7,_sgl_st_acc"); /* get the result */
299 0002BE7B 0d 57 effffffdd2 movl r7,_sgl_st_acc
300 0002BE82 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
301 0002BE82 1d effffffdcc effffffdc7 cmpl _sgl_st_acc,_sgl_expected
302 0002BE8D 31 45 jeql L255
303 0002BE8F # {
304 0002BE8F # errcnt++; /* bump the error count */
305 0002BE8F 6d effffffdbf incl _errcnt
306 0002BE95 # if ( prt_error )
307 0002BE95 5d effffffdb9 tstl _prt_error
308 0002BE9B 31 0d jeql L256
309 0002BE9D # print_pipe8_er("Reg. Data, 1 NO-OP");
310 0002BE9D .data 1
311 00000d7b * L257:
312 00000d7b * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
04E4F2D4F5000
313 00000d8e * .text
314 0002BE9D dd 8f00000d7b pushl $L257
315 0002BEA3 fe 08 ef00000986 callf $8,_print_pipe8_er
316 0002BEAA # if ( halt_flg )
317 0002BEAA L256:
318 0002BEAA 5d effffffda4 tstl _halt_flg
319 0002BEB0 31 0d jeql L258
320 0002BEB2 # pipe8_er_hlt( subtest );
321 0002BEB2 dd effffffd9c pushl _subtest
322 0002BEB8 fe 08 ef00000a7d callf $8,_pipe8_er_hlt
323 0002BEBF # if ( loop_on_err ) {
324 0002BEBF L258:
325 0002BEBF 5d effffffd8f tstl _loop_on_err
326 0002BEC5 31 0d jeql L259
327 0002BEC7 # force_loop = TRUE; /* set the force loop flag */
328 0002BEC7 0d 01 effffffd86 movl $1,_force_loop
329 0002BECE # asm("jmp _pipe8_2_lp1"); /* and loop */
330 0002BECE 71 efffffff77 jmp _pipe8_2_lp1
331 0002BED4 # }
332 0002BED4 # } /* end of compare error */
333 0002BED4 L259:
334 0002BED4 # } while( index++ < max_ldf_1_index );
335 0002BED4 L255:
336 0002BED4 L252:
337 0002BED4 0d effffffd7a 50 movl _index,r0
338 0002BEDB 6d effffffd73 incl _index
339 0002BEE1 1d 50 effffffd6c cmpl r0,_max_ldf_1_index
340 0002BEE8 81 03 13 ff1c jlss L253
341 0002BEED L251:
342 0002BEED # } /* end of subtest 2 */
343 0002BEED 40 ret#2
344 0002BEEE .set L247,0x0
345 0002BEEE L249:
346 0002BEEE 13 ff0c jbr L250
347 0002BEF1 .data
348 00000d5c * .text
349 0002BEF1 00 .align 1
350 0002BEF2 .globl _pipe8_3
351 0002BEF2 _pipe8_3:
352 0002BEF2 0000 .word L260
353 0002BEF4 #
354 0002BEF4 #
355 0002BEF4 #
356 0002BEF4 #
357 0002BEF4 #
358 0002BEF4 #
359 0002BEF4 # /************************************************************************
360 0002BEF4 # *
361 0002BEF4 # * SUBTEST 3
362 0002BEF4 # * data in registers, 2 NO-OPs
363 0002BEF4 # *
364 0002BEF4 # ************************************************************************/
365 0002BEF4 # pipe8_3()
366 0002BEF4 # {
367 0002BEF4 13 00f6 jbr L262
368 0002BEF7 L263:
369 0002BEF7 # force_loop = FALSE; /* clear force_loop flag */
370 0002BEF7 4d effffffd57 clrl _force_loop
371 0002BEFD # index = 0;
372 0002BEFD 4d effffffd51 clrl _index
373 0002BF03 # do
374 0002BF03 L266:
375 0002BF03 # {
376 0002BF03 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
377 0002BF03 0d effffffd4b 50 movl _index,r0
378 0002BF0A 48 03 50 50 shll $3,r0,r0
379 0002BF0E 0d e000000000 effffffd3b movl _ldf_1_data(r0),_sgl_value_1
380 0002BF19 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
381 0002BF19 0d effffffd35 50 movl _index,r0
382 0002BF20 48 03 50 50 shll $3,r0,r0
383 0002BF24 0d e000000004 effffffd25 movl _ldf_1_data+4(r0),_sgl_expected
384 0002BF2F # sgl_value_2 = 0x40800000; /* floating '1' */
385 0002BF2F 0d 8f40800000 effffffd1a movl $1082130432,_sgl_value_2
386 0002BF3A # sgl_value_3 = 0x41000000; /* floating '2' */
387 0002BF3A 0d 8f41000000 effffffd0f movl $1090519040,_sgl_value_3
388 0002BF45 # /*
389 0002BF45 # * If LOOP ON ERROR is set, this is the loop for this subtest.
390 0002BF45 # * The force loop flag is set after the first error.
391 0002BF45 # */
392 0002BF45 # asm("_pipe8_3_lp1:");
393 0002BF45 _pipe8_3_lp1:
394 0002BF45 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
395 0002BF45 0d effffffd09 54 movl _sgl_value_1,r4
396 0002BF4C # asm("movl _sgl_value_2,r5"); /* move data to r5 */
397 0002BF4C 0d effffffd02 55 movl _sgl_value_2,r5
398 0002BF53 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
399 0002BF53 0d effffffcfb 56 movl _sgl_value_3,r6
400 0002BF5A # asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
401 0002BF5A 06 55 ldf r5
402 0002BF5C # asm("nop");
403 0002BF5C 10 nop
404 0002BF5D # asm("nop");
405 0002BF5D 10 nop
406 0002BF5E # asm("subf r6"); /* minus 2.0 (-1.0 ) */
407 0002BF5E d6 56 subf r6
408 0002BF60 # asm("nop");
409 0002BF60 10 nop
410 0002BF61 # asm("nop");
411 0002BF61 10 nop
412 0002BF62 # asm("mulf r4"); /* *'s the operand ( -op ) */
413 0002BF62 e6 54 mulf r4
414 0002BF64 # asm("nop");
415 0002BF64 10 nop
416 0002BF65 # asm("nop");
417 0002BF65 10 nop
418 0002BF66 # asm("addf r4"); /* + the operand ( 0 ) */
419 0002BF66 c6 54 addf r4
420 0002BF68 # asm("nop");
421 0002BF68 10 nop
422 0002BF69 # asm("nop");
423 0002BF69 10 nop
424 0002BF6A # asm("addf r4"); /* + the operand ( +op ) */
425 0002BF6A c6 54 addf r4
426 0002BF6C # asm("nop");
427 0002BF6C 10 nop
428 0002BF6D # asm("nop");
429 0002BF6D 10 nop
430 0002BF6E # asm("stf r7"); /* store the result */
431 0002BF6E 26 57 stf r7
432 0002BF70 # if( force_loop )
433 0002BF70 5d effffffcde tstl _force_loop
434 0002BF76 31 02 jeql L267
435 0002BF78 # asm("brb _pipe8_3_lp1");; /* loop on the error */
436 0002BF78 11 cb brb _pipe8_3_lp1
437 0002BF7A L267:
438 0002BF7A # /*
439 0002BF7A # * verify the results
440 0002BF7A # */
441 0002BF7A # asm("movl r7,_sgl_st_acc"); /* get the result */
442 0002BF7A 0d 57 effffffcd3 movl r7,_sgl_st_acc
443 0002BF81 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
444 0002BF81 1d effffffccd effffffcc8 cmpl _sgl_st_acc,_sgl_expected
445 0002BF8C 31 45 jeql L268
446 0002BF8E # {
447 0002BF8E # errcnt++; /* bump the error count */
448 0002BF8E 6d effffffcc0 incl _errcnt
449 0002BF94 # if ( prt_error )
450 0002BF94 5d effffffcba tstl _prt_error
451 0002BF9A 31 0d jeql L269
452 0002BF9C # print_pipe8_er("Reg. Data, 2 NO-OPs");
453 0002BF9C .data 1
454 00000d8e * L270:
455 00000d8e * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0"
04E4F2D4F507300
456 00000da2 * .text
457 0002BF9C dd 8f00000d8e pushl $L270
458 0002BFA2 fe 08 ef00000887 callf $8,_print_pipe8_er
459 0002BFA9 # if ( halt_flg )
460 0002BFA9 L269:
461 0002BFA9 5d effffffca5 tstl _halt_flg
462 0002BFAF 31 0d jeql L271
463 0002BFB1 # pipe8_er_hlt( subtest );
464 0002BFB1 dd effffffc9d pushl _subtest
465 0002BFB7 fe 08 ef0000097e callf $8,_pipe8_er_hlt
466 0002BFBE # if ( loop_on_err ) {
467 0002BFBE L271:
468 0002BFBE 5d effffffc90 tstl _loop_on_err
469 0002BFC4 31 0d jeql L272
470 0002BFC6 # force_loop = TRUE; /* set the force loop flag */
471 0002BFC6 0d 01 effffffc87 movl $1,_force_loop
472 0002BFCD # asm("jmp _pipe8_3_lp1"); /* and loop */
473 0002BFCD 71 efffffff72 jmp _pipe8_3_lp1
474 0002BFD3 # }
475 0002BFD3 # } /* end of compare error */
476 0002BFD3 L272:
477 0002BFD3 # } while( index++ < max_ldf_1_index );
478 0002BFD3 L268:
479 0002BFD3 L265:
480 0002BFD3 0d effffffc7b 50 movl _index,r0
481 0002BFDA 6d effffffc74 incl _index
482 0002BFE0 1d 50 effffffc6d cmpl r0,_max_ldf_1_index
483 0002BFE7 81 03 13 ff17 jlss L266
484 0002BFEC L264:
485 0002BFEC # } /* end of subtest 3 */
486 0002BFEC 40 ret#2
487 0002BFED .set L260,0x0
488 0002BFED L262:
489 0002BFED 13 ff07 jbr L263
490 0002BFF0 .data
491 00000d5c * .text
492 0002BFF0 .align 1
493 0002BFF0 .globl _pipe8_4
494 0002BFF0 _pipe8_4:
495 0002BFF0 0000 .word L273
496 0002BFF2 #
497 0002BFF2 #
498 0002BFF2 #
499 0002BFF2 #
500 0002BFF2 #
501 0002BFF2 #
502 0002BFF2 # /************************************************************************
503 0002BFF2 # *
504 0002BFF2 # * SUBTEST 4
505 0002BFF2 # * data in registers, 3 NO-OPs
506 0002BFF2 # *
507 0002BFF2 # ************************************************************************/
508 0002BFF2 # pipe8_4()
509 0002BFF2 # {
510 0002BFF2 13 00fb jbr L275
511 0002BFF5 L276:
512 0002BFF5 # force_loop = FALSE; /* clear force_loop flag */
513 0002BFF5 4d effffffc59 clrl _force_loop
514 0002BFFB # index = 0;
515 0002BFFB 4d effffffc53 clrl _index
516 0002C001 # do
517 0002C001 L279:
518 0002C001 # {
519 0002C001 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
520 0002C001 0d effffffc4d 50 movl _index,r0
521 0002C008 48 03 50 50 shll $3,r0,r0
522 0002C00C 0d e000000000 effffffc3d movl _ldf_1_data(r0),_sgl_value_1
523 0002C017 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
524 0002C017 0d effffffc37 50 movl _index,r0
525 0002C01E 48 03 50 50 shll $3,r0,r0
526 0002C022 0d e000000004 effffffc27 movl _ldf_1_data+4(r0),_sgl_expected
527 0002C02D # sgl_value_2 = 0x40800000; /* floating '1' */
528 0002C02D 0d 8f40800000 effffffc1c movl $1082130432,_sgl_value_2
529 0002C038 # sgl_value_3 = 0x41000000; /* floating '2' */
530 0002C038 0d 8f41000000 effffffc11 movl $1090519040,_sgl_value_3
531 0002C043 # /*
532 0002C043 # * If LOOP ON ERROR is set, this is the loop for this subtest.
533 0002C043 # * The force loop flag is set after the first error.
534 0002C043 # */
535 0002C043 # asm("_pipe8_4_lp1:");
536 0002C043 _pipe8_4_lp1:
537 0002C043 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
538 0002C043 0d effffffc0b 54 movl _sgl_value_1,r4
539 0002C04A # asm("movl _sgl_value_2,r5"); /* move data to r5 */
540 0002C04A 0d effffffc04 55 movl _sgl_value_2,r5
541 0002C051 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
542 0002C051 0d effffffbfd 56 movl _sgl_value_3,r6
543 0002C058 # asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
544 0002C058 06 55 ldf r5
545 0002C05A # asm("nop");
546 0002C05A 10 nop
547 0002C05B # asm("nop");
548 0002C05B 10 nop
549 0002C05C # asm("nop");
550 0002C05C 10 nop
551 0002C05D # asm("subf r6"); /* minus 2.0 (-1.0 ) */
552 0002C05D d6 56 subf r6
553 0002C05F # asm("nop");
554 0002C05F 10 nop
555 0002C060 # asm("nop");
556 0002C060 10 nop
557 0002C061 # asm("nop");
558 0002C061 10 nop
559 0002C062 # asm("mulf r4"); /* *'s the operand ( -op ) */
560 0002C062 e6 54 mulf r4
561 0002C064 # asm("nop");
562 0002C064 10 nop
563 0002C065 # asm("nop");
564 0002C065 10 nop
565 0002C066 # asm("nop");
566 0002C066 10 nop
567 0002C067 # asm("addf r4"); /* + the operand ( 0 ) */
568 0002C067 c6 54 addf r4
569 0002C069 # asm("nop");
570 0002C069 10 nop
571 0002C06A # asm("nop");
572 0002C06A 10 nop
573 0002C06B # asm("nop");
574 0002C06B 10 nop
575 0002C06C # asm("addf r4"); /* + the operand ( +op ) */
576 0002C06C c6 54 addf r4
577 0002C06E # asm("nop");
578 0002C06E 10 nop
579 0002C06F # asm("nop");
580 0002C06F 10 nop
581 0002C070 # asm("nop");
582 0002C070 10 nop
583 0002C071 # asm("stf r7"); /* store the result */
584 0002C071 26 57 stf r7
585 0002C073 # if( force_loop )
586 0002C073 5d effffffbdb tstl _force_loop
587 0002C079 31 02 jeql L280
588 0002C07B # asm("brb _pipe8_4_lp1");; /* loop on the error */
589 0002C07B 11 c6 brb _pipe8_4_lp1
590 0002C07D L280:
591 0002C07D # /*
592 0002C07D # * verify the results
593 0002C07D # */
594 0002C07D # asm("movl r7,_sgl_st_acc"); /* get the result */
595 0002C07D 0d 57 effffffbd0 movl r7,_sgl_st_acc
596 0002C084 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
597 0002C084 1d effffffbca effffffbc5 cmpl _sgl_st_acc,_sgl_expected
598 0002C08F 31 45 jeql L281
599 0002C091 # {
600 0002C091 # errcnt++; /* bump the error count */
601 0002C091 6d effffffbbd incl _errcnt
602 0002C097 # if ( prt_error )
603 0002C097 5d effffffbb7 tstl _prt_error
604 0002C09D 31 0d jeql L282
605 0002C09F # print_pipe8_er("Reg. Data, 3 NO-OPs");
606 0002C09F .data 1
607 00000da2 * L283:
608 00000da2 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0"
04E4F2D4F507300
609 00000db6 * .text
610 0002C09F dd 8f00000da2 pushl $L283
611 0002C0A5 fe 08 ef00000784 callf $8,_print_pipe8_er
612 0002C0AC # if ( halt_flg )
613 0002C0AC L282:
614 0002C0AC 5d effffffba2 tstl _halt_flg
615 0002C0B2 31 0d jeql L284
616 0002C0B4 # pipe8_er_hlt( subtest );
617 0002C0B4 dd effffffb9a pushl _subtest
618 0002C0BA fe 08 ef0000087b callf $8,_pipe8_er_hlt
619 0002C0C1 # if ( loop_on_err ) {
620 0002C0C1 L284:
621 0002C0C1 5d effffffb8d tstl _loop_on_err
622 0002C0C7 31 0d jeql L285
623 0002C0C9 # force_loop = TRUE; /* set the force loop flag */
624 0002C0C9 0d 01 effffffb84 movl $1,_force_loop
625 0002C0D0 # asm("jmp _pipe8_4_lp1"); /* and loop */
626 0002C0D0 71 efffffff6d jmp _pipe8_4_lp1
627 0002C0D6 # }
628 0002C0D6 # } /* end of compare error */
629 0002C0D6 L285:
630 0002C0D6 # } while( index++ < max_ldf_1_index );
631 0002C0D6 L281:
632 0002C0D6 L278:
633 0002C0D6 0d effffffb78 50 movl _index,r0
634 0002C0DD 6d effffffb71 incl _index
635 0002C0E3 1d 50 effffffb6a cmpl r0,_max_ldf_1_index
636 0002C0EA 81 03 13 ff12 jlss L279
637 0002C0EF L277:
638 0002C0EF # } /* end of subtest 4 */
639 0002C0EF 40 ret#2
640 0002C0F0 .set L273,0x0
641 0002C0F0 L275:
642 0002C0F0 13 ff02 jbr L276
643 0002C0F3 .data
644 00000d5c * .text
645 0002C0F3 00 .align 1
646 0002C0F4 .globl _pipe8_5
647 0002C0F4 _pipe8_5:
648 0002C0F4 0000 .word L286
649 0002C0F6 #
650 0002C0F6 #
651 0002C0F6 #
652 0002C0F6 #
653 0002C0F6 #
654 0002C0F6 #
655 0002C0F6 #
656 0002C0F6 # /************************************************************************
657 0002C0F6 # *
658 0002C0F6 # * SUBTEST 5
659 0002C0F6 # * data in Cache, no NO-OPs
660 0002C0F6 # *
661 0002C0F6 # ************************************************************************/
662 0002C0F6 # pipe8_5()
663 0002C0F6 # {
664 0002C0F6 13 00e8 jbr L288
665 0002C0F9 L289:
666 0002C0F9 # force_loop = FALSE; /* clear force_loop flag */
667 0002C0F9 4d effffffb55 clrl _force_loop
668 0002C0FF # index = 0;
669 0002C0FF 4d effffffb4f clrl _index
670 0002C105 # do
671 0002C105 L292:
672 0002C105 # {
673 0002C105 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
674 0002C105 0d effffffb49 50 movl _index,r0
675 0002C10C 48 03 50 50 shll $3,r0,r0
676 0002C110 0d e000000000 effffffb39 movl _ldf_1_data(r0),_sgl_value_1
677 0002C11B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
678 0002C11B 0d effffffb33 50 movl _index,r0
679 0002C122 48 03 50 50 shll $3,r0,r0
680 0002C126 0d e000000004 effffffb23 movl _ldf_1_data+4(r0),_sgl_expected
681 0002C131 # sgl_value_2 = 0x40800000; /* floating '1' */
682 0002C131 0d 8f40800000 effffffb18 movl $1082130432,_sgl_value_2
683 0002C13C # sgl_value_3 = 0x41000000; /* floating '2' */
684 0002C13C 0d 8f41000000 effffffb0d movl $1090519040,_sgl_value_3
685 0002C147 # /*
686 0002C147 # * If LOOP ON ERROR is set, this is the loop for this subtest.
687 0002C147 # * The force loop flag is set after the first error.
688 0002C147 # */
689 0002C147 # asm("_pipe8_5_lp1:");
690 0002C147 _pipe8_5_lp1:
691 0002C147 # asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
692 0002C147 06 effffffb07 ldf _sgl_value_2
693 0002C14D # asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
694 0002C14D d6 effffffb01 subf _sgl_value_3
695 0002C153 # asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
696 0002C153 e6 effffffafb mulf _sgl_value_1
697 0002C159 # asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
698 0002C159 c6 effffffaf5 addf _sgl_value_1
699 0002C15F # asm("addf _sgl_value_1"); /* + the operand ( +op ) */
700 0002C15F c6 effffffaef addf _sgl_value_1
701 0002C165 # asm("stf _sgl_st_acc"); /* store the result */
702 0002C165 26 effffffae9 stf _sgl_st_acc
703 0002C16B # if( force_loop )
704 0002C16B 5d effffffae3 tstl _force_loop
705 0002C171 31 02 jeql L293
706 0002C173 # asm("brb _pipe8_5_lp1");; /* loop on the error */
707 0002C173 11 d2 brb _pipe8_5_lp1
708 0002C175 L293:
709 0002C175 # /*
710 0002C175 # * verify the results
711 0002C175 # */
712 0002C175 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
713 0002C175 1d effffffad9 effffffad4 cmpl _sgl_st_acc,_sgl_expected
714 0002C180 31 45 jeql L294
715 0002C182 # {
716 0002C182 # errcnt++; /* bump the error count */
717 0002C182 6d effffffacc incl _errcnt
718 0002C188 # if ( prt_error )
719 0002C188 5d effffffac6 tstl _prt_error
720 0002C18E 31 0d jeql L295
721 0002C190 # print_pipe8_er("Cache Data, no NO-OPs");
722 0002C190 .data 1
723 00000db6 * L296:
724 00000db6 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0"
E6F204E4F2D4F507300
725 00000dcc * .text
726 0002C190 dd 8f00000db6 pushl $L296
727 0002C196 fe 08 ef00000693 callf $8,_print_pipe8_er
728 0002C19D # if ( halt_flg )
729 0002C19D L295:
730 0002C19D 5d effffffab1 tstl _halt_flg
731 0002C1A3 31 0d jeql L297
732 0002C1A5 # pipe8_er_hlt( subtest );
733 0002C1A5 dd effffffaa9 pushl _subtest
734 0002C1AB fe 08 ef0000078a callf $8,_pipe8_er_hlt
735 0002C1B2 # if ( loop_on_err ) {
736 0002C1B2 L297:
737 0002C1B2 5d effffffa9c tstl _loop_on_err
738 0002C1B8 31 0d jeql L298
739 0002C1BA # force_loop = TRUE; /* set the force loop flag */
740 0002C1BA 0d 01 effffffa93 movl $1,_force_loop
741 0002C1C1 # asm("jmp _pipe8_5_lp1"); /* and loop */
742 0002C1C1 71 efffffff80 jmp _pipe8_5_lp1
743 0002C1C7 # }
744 0002C1C7 # } /* end of compare error */
745 0002C1C7 L298:
746 0002C1C7 # } while( index++ < max_ldf_1_index );
747 0002C1C7 L294:
748 0002C1C7 L291:
749 0002C1C7 0d effffffa87 50 movl _index,r0
750 0002C1CE 6d effffffa80 incl _index
751 0002C1D4 1d 50 effffffa79 cmpl r0,_max_ldf_1_index
752 0002C1DB 81 03 13 ff25 jlss L292
753 0002C1E0 L290:
754 0002C1E0 # } /* end of subtest 5 */
755 0002C1E0 40 ret#2
756 0002C1E1 .set L286,0x0
757 0002C1E1 L288:
758 0002C1E1 13 ff15 jbr L289
759 0002C1E4 .data
760 00000d5c * .text
761 0002C1E4 .align 1
762 0002C1E4 .globl _pipe8_6
763 0002C1E4 _pipe8_6:
764 0002C1E4 0000 .word L299
765 0002C1E6 #
766 0002C1E6 #
767 0002C1E6 #
768 0002C1E6 #
769 0002C1E6 #
770 0002C1E6 #
771 0002C1E6 # /************************************************************************
772 0002C1E6 # *
773 0002C1E6 # * SUBTEST 6
774 0002C1E6 # * data in Cache, 1 NO-OP
775 0002C1E6 # *
776 0002C1E6 # ************************************************************************/
777 0002C1E6 # pipe8_6()
778 0002C1E6 # {
779 0002C1E6 13 00ed jbr L301
780 0002C1E9 L302:
781 0002C1E9 # force_loop = FALSE; /* clear force_loop flag */
782 0002C1E9 4d effffffa65 clrl _force_loop
783 0002C1EF # index = 0;
784 0002C1EF 4d effffffa5f clrl _index
785 0002C1F5 # do
786 0002C1F5 L305:
787 0002C1F5 # {
788 0002C1F5 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
789 0002C1F5 0d effffffa59 50 movl _index,r0
790 0002C1FC 48 03 50 50 shll $3,r0,r0
791 0002C200 0d e000000000 effffffa49 movl _ldf_1_data(r0),_sgl_value_1
792 0002C20B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
793 0002C20B 0d effffffa43 50 movl _index,r0
794 0002C212 48 03 50 50 shll $3,r0,r0
795 0002C216 0d e000000004 effffffa33 movl _ldf_1_data+4(r0),_sgl_expected
796 0002C221 # sgl_value_2 = 0x40800000; /* floating '1' */
797 0002C221 0d 8f40800000 effffffa28 movl $1082130432,_sgl_value_2
798 0002C22C # sgl_value_3 = 0x41000000; /* floating '2' */
799 0002C22C 0d 8f41000000 effffffa1d movl $1090519040,_sgl_value_3
800 0002C237 # /*
801 0002C237 # * If LOOP ON ERROR is set, this is the loop for this subtest.
802 0002C237 # * The force loop flag is set after the first error.
803 0002C237 # */
804 0002C237 # asm("_pipe8_6_lp1:");
805 0002C237 _pipe8_6_lp1:
806 0002C237 # asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
807 0002C237 06 effffffa17 ldf _sgl_value_2
808 0002C23D # asm("nop");
809 0002C23D 10 nop
810 0002C23E # asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
811 0002C23E d6 effffffa10 subf _sgl_value_3
812 0002C244 # asm("nop");
813 0002C244 10 nop
814 0002C245 # asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
815 0002C245 e6 effffffa09 mulf _sgl_value_1
816 0002C24B # asm("nop");
817 0002C24B 10 nop
818 0002C24C # asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
819 0002C24C c6 effffffa02 addf _sgl_value_1
820 0002C252 # asm("nop");
821 0002C252 10 nop
822 0002C253 # asm("addf _sgl_value_1"); /* + the operand ( +op ) */
823 0002C253 c6 effffff9fb addf _sgl_value_1
824 0002C259 # asm("nop");
825 0002C259 10 nop
826 0002C25A # asm("stf _sgl_st_acc"); /* store the result */
827 0002C25A 26 effffff9f4 stf _sgl_st_acc
828 0002C260 # if( force_loop )
829 0002C260 5d effffff9ee tstl _force_loop
830 0002C266 31 02 jeql L306
831 0002C268 # asm("brb _pipe8_6_lp1");; /* loop on the error */
832 0002C268 11 cd brb _pipe8_6_lp1
833 0002C26A L306:
834 0002C26A # /*
835 0002C26A # * verify the results
836 0002C26A # */
837 0002C26A # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
838 0002C26A 1d effffff9e4 effffff9df cmpl _sgl_st_acc,_sgl_expected
839 0002C275 31 45 jeql L307
840 0002C277 # {
841 0002C277 # errcnt++; /* bump the error count */
842 0002C277 6d effffff9d7 incl _errcnt
843 0002C27D # if ( prt_error )
844 0002C27D 5d effffff9d1 tstl _prt_error
845 0002C283 31 0d jeql L308
846 0002C285 # print_pipe8_er("Cache Data, 1 NO-OP");
847 0002C285 .data 1
848 00000dcc * L309:
849 00000dcc * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
1204E4F2D4F5000
850 00000de0 * .text
851 0002C285 dd 8f00000dcc pushl $L309
852 0002C28B fe 08 ef0000059e callf $8,_print_pipe8_er
853 0002C292 # if ( halt_flg )
854 0002C292 L308:
855 0002C292 5d effffff9bc tstl _halt_flg
856 0002C298 31 0d jeql L310
857 0002C29A # pipe8_er_hlt( subtest );
858 0002C29A dd effffff9b4 pushl _subtest
859 0002C2A0 fe 08 ef00000695 callf $8,_pipe8_er_hlt
860 0002C2A7 # if ( loop_on_err ) {
861 0002C2A7 L310:
862 0002C2A7 5d effffff9a7 tstl _loop_on_err
863 0002C2AD 31 0d jeql L311
864 0002C2AF # force_loop = TRUE; /* set the force loop flag */
865 0002C2AF 0d 01 effffff99e movl $1,_force_loop
866 0002C2B6 # asm("jmp _pipe8_6_lp1"); /* and loop */
867 0002C2B6 71 efffffff7b jmp _pipe8_6_lp1
868 0002C2BC # }
869 0002C2BC # } /* end of compare error */
870 0002C2BC L311:
871 0002C2BC # } while( index++ < max_ldf_1_index );
872 0002C2BC L307:
873 0002C2BC L304:
874 0002C2BC 0d effffff992 50 movl _index,r0
875 0002C2C3 6d effffff98b incl _index
876 0002C2C9 1d 50 effffff984 cmpl r0,_max_ldf_1_index
877 0002C2D0 81 03 13 ff20 jlss L305
878 0002C2D5 L303:
879 0002C2D5 # } /* end of subtest 6 */
880 0002C2D5 40 ret#2
881 0002C2D6 .set L299,0x0
882 0002C2D6 L301:
883 0002C2D6 13 ff10 jbr L302
884 0002C2D9 .data
885 00000d5c * .text
886 0002C2D9 00 .align 1
887 0002C2DA .globl _pipe8_7
888 0002C2DA _pipe8_7:
889 0002C2DA 0000 .word L312
890 0002C2DC #
891 0002C2DC #
892 0002C2DC #
893 0002C2DC #
894 0002C2DC #
895 0002C2DC #
896 0002C2DC # /************************************************************************
897 0002C2DC # *
898 0002C2DC # * SUBTEST 7
899 0002C2DC # * data in Cache, 2 NO-OPs
900 0002C2DC # *
901 0002C2DC # ************************************************************************/
902 0002C2DC # pipe8_7()
903 0002C2DC # {
904 0002C2DC 13 00f2 jbr L314
905 0002C2DF L315:
906 0002C2DF # force_loop = FALSE; /* clear force_loop flag */
907 0002C2DF 4d effffff96f clrl _force_loop
908 0002C2E5 # index = 0;
909 0002C2E5 4d effffff969 clrl _index
910 0002C2EB # do
911 0002C2EB L318:
912 0002C2EB # {
913 0002C2EB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
914 0002C2EB 0d effffff963 50 movl _index,r0
915 0002C2F2 48 03 50 50 shll $3,r0,r0
916 0002C2F6 0d e000000000 effffff953 movl _ldf_1_data(r0),_sgl_value_1
917 0002C301 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
918 0002C301 0d effffff94d 50 movl _index,r0
919 0002C308 48 03 50 50 shll $3,r0,r0
920 0002C30C 0d e000000004 effffff93d movl _ldf_1_data+4(r0),_sgl_expected
921 0002C317 # sgl_value_2 = 0x40800000; /* floating '1' */
922 0002C317 0d 8f40800000 effffff932 movl $1082130432,_sgl_value_2
923 0002C322 # sgl_value_3 = 0x41000000; /* floating '2' */
924 0002C322 0d 8f41000000 effffff927 movl $1090519040,_sgl_value_3
925 0002C32D # /*
926 0002C32D # * If LOOP ON ERROR is set, this is the loop for this subtest.
927 0002C32D # * The force loop flag is set after the first error.
928 0002C32D # */
929 0002C32D # asm("_pipe8_7_lp1:");
930 0002C32D _pipe8_7_lp1:
931 0002C32D # asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
932 0002C32D 06 effffff921 ldf _sgl_value_2
933 0002C333 # asm("nop");
934 0002C333 10 nop
935 0002C334 # asm("nop");
936 0002C334 10 nop
937 0002C335 # asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
938 0002C335 d6 effffff919 subf _sgl_value_3
939 0002C33B # asm("nop");
940 0002C33B 10 nop
941 0002C33C # asm("nop");
942 0002C33C 10 nop
943 0002C33D # asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
944 0002C33D e6 effffff911 mulf _sgl_value_1
945 0002C343 # asm("nop");
946 0002C343 10 nop
947 0002C344 # asm("nop");
948 0002C344 10 nop
949 0002C345 # asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
950 0002C345 c6 effffff909 addf _sgl_value_1
951 0002C34B # asm("nop");
952 0002C34B 10 nop
953 0002C34C # asm("nop");
954 0002C34C 10 nop
955 0002C34D # asm("addf _sgl_value_1"); /* + the operand ( +op ) */
956 0002C34D c6 effffff901 addf _sgl_value_1
957 0002C353 # asm("nop");
958 0002C353 10 nop
959 0002C354 # asm("nop");
960 0002C354 10 nop
961 0002C355 # asm("stf _sgl_st_acc"); /* store the result */
962 0002C355 26 effffff8f9 stf _sgl_st_acc
963 0002C35B # if( force_loop )
964 0002C35B 5d effffff8f3 tstl _force_loop
965 0002C361 31 02 jeql L319
966 0002C363 # asm("brb _pipe8_7_lp1");; /* loop on the error */
967 0002C363 11 c8 brb _pipe8_7_lp1
968 0002C365 L319:
969 0002C365 # /*
970 0002C365 # * verify the results
971 0002C365 # */
972 0002C365 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
973 0002C365 1d effffff8e9 effffff8e4 cmpl _sgl_st_acc,_sgl_expected
974 0002C370 31 45 jeql L320
975 0002C372 # {
976 0002C372 # errcnt++; /* bump the error count */
977 0002C372 6d effffff8dc incl _errcnt
978 0002C378 # if ( prt_error )
979 0002C378 5d effffff8d6 tstl _prt_error
980 0002C37E 31 0d jeql L321
981 0002C380 # print_pipe8_er("Cache Data, 2 NO-OPs");
982 0002C380 .data 1
983 00000de0 * L322:
984 00000de0 * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0"
2204E4F2D4F507300
985 00000df5 * .text
986 0002C380 dd 8f00000de0 pushl $L322
987 0002C386 fe 08 ef000004a3 callf $8,_print_pipe8_er
988 0002C38D # if ( halt_flg )
989 0002C38D L321:
990 0002C38D 5d effffff8c1 tstl _halt_flg
991 0002C393 31 0d jeql L323
992 0002C395 # pipe8_er_hlt( subtest );
993 0002C395 dd effffff8b9 pushl _subtest
994 0002C39B fe 08 ef0000059a callf $8,_pipe8_er_hlt
995 0002C3A2 # if ( loop_on_err ) {
996 0002C3A2 L323:
997 0002C3A2 5d effffff8ac tstl _loop_on_err
998 0002C3A8 31 0d jeql L324
999 0002C3AA # force_loop = TRUE; /* set the force loop flag */
1000 0002C3AA 0d 01 effffff8a3 movl $1,_force_loop
1001 0002C3B1 # asm("jmp _pipe8_7_lp1"); /* and loop */
1002 0002C3B1 71 efffffff76 jmp _pipe8_7_lp1
1003 0002C3B7 # }
1004 0002C3B7 # } /* end of compare error */
1005 0002C3B7 L324:
1006 0002C3B7 # } while( index++ < max_ldf_1_index );
1007 0002C3B7 L320:
1008 0002C3B7 L317:
1009 0002C3B7 0d effffff897 50 movl _index,r0
1010 0002C3BE 6d effffff890 incl _index
1011 0002C3C4 1d 50 effffff889 cmpl r0,_max_ldf_1_index
1012 0002C3CB 81 03 13 ff1b jlss L318
1013 0002C3D0 L316:
1014 0002C3D0 # } /* end of subtest 7 */
1015 0002C3D0 40 ret#2
1016 0002C3D1 .set L312,0x0
1017 0002C3D1 L314:
1018 0002C3D1 13 ff0b jbr L315
1019 0002C3D4 .data
1020 00000d5c * .text
1021 0002C3D4 .align 1
1022 0002C3D4 .globl _pipe8_8
1023 0002C3D4 _pipe8_8:
1024 0002C3D4 0000 .word L325
1025 0002C3D6 #
1026 0002C3D6 #
1027 0002C3D6 #
1028 0002C3D6 #
1029 0002C3D6 #
1030 0002C3D6 #
1031 0002C3D6 # /************************************************************************
1032 0002C3D6 # *
1033 0002C3D6 # * SUBTEST 8
1034 0002C3D6 # * data in Cache, 3 NO-OPs
1035 0002C3D6 # *
1036 0002C3D6 # ************************************************************************/
1037 0002C3D6 # pipe8_8()
1038 0002C3D6 # {
1039 0002C3D6 13 00f7 jbr L327
1040 0002C3D9 L328:
1041 0002C3D9 # force_loop = FALSE; /* clear force_loop flag */
1042 0002C3D9 4d effffff875 clrl _force_loop
1043 0002C3DF # index = 0;
1044 0002C3DF 4d effffff86f clrl _index
1045 0002C3E5 # do
1046 0002C3E5 L331:
1047 0002C3E5 # {
1048 0002C3E5 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1049 0002C3E5 0d effffff869 50 movl _index,r0
1050 0002C3EC 48 03 50 50 shll $3,r0,r0
1051 0002C3F0 0d e000000000 effffff859 movl _ldf_1_data(r0),_sgl_value_1
1052 0002C3FB # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1053 0002C3FB 0d effffff853 50 movl _index,r0
1054 0002C402 48 03 50 50 shll $3,r0,r0
1055 0002C406 0d e000000004 effffff843 movl _ldf_1_data+4(r0),_sgl_expected
1056 0002C411 # sgl_value_2 = 0x40800000; /* floating '1' */
1057 0002C411 0d 8f40800000 effffff838 movl $1082130432,_sgl_value_2
1058 0002C41C # sgl_value_3 = 0x41000000; /* floating '2' */
1059 0002C41C 0d 8f41000000 effffff82d movl $1090519040,_sgl_value_3
1060 0002C427 # /*
1061 0002C427 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1062 0002C427 # * The force loop flag is set after the first error.
1063 0002C427 # */
1064 0002C427 # asm("_pipe8_8_lp1:");
1065 0002C427 _pipe8_8_lp1:
1066 0002C427 # asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
1067 0002C427 06 effffff827 ldf _sgl_value_2
1068 0002C42D # asm("nop");
1069 0002C42D 10 nop
1070 0002C42E # asm("nop");
1071 0002C42E 10 nop
1072 0002C42F # asm("nop");
1073 0002C42F 10 nop
1074 0002C430 # asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
1075 0002C430 d6 effffff81e subf _sgl_value_3
1076 0002C436 # asm("nop");
1077 0002C436 10 nop
1078 0002C437 # asm("nop");
1079 0002C437 10 nop
1080 0002C438 # asm("nop");
1081 0002C438 10 nop
1082 0002C439 # asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
1083 0002C439 e6 effffff815 mulf _sgl_value_1
1084 0002C43F # asm("nop");
1085 0002C43F 10 nop
1086 0002C440 # asm("nop");
1087 0002C440 10 nop
1088 0002C441 # asm("nop");
1089 0002C441 10 nop
1090 0002C442 # asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
1091 0002C442 c6 effffff80c addf _sgl_value_1
1092 0002C448 # asm("nop");
1093 0002C448 10 nop
1094 0002C449 # asm("nop");
1095 0002C449 10 nop
1096 0002C44A # asm("nop");
1097 0002C44A 10 nop
1098 0002C44B # asm("addf _sgl_value_1"); /* + the operand ( +op ) */
1099 0002C44B c6 effffff803 addf _sgl_value_1
1100 0002C451 # asm("nop");
1101 0002C451 10 nop
1102 0002C452 # asm("nop");
1103 0002C452 10 nop
1104 0002C453 # asm("nop");
1105 0002C453 10 nop
1106 0002C454 # asm("stf _sgl_st_acc"); /* store the result */
1107 0002C454 26 effffff7fa stf _sgl_st_acc
1108 0002C45A # if( force_loop )
1109 0002C45A 5d effffff7f4 tstl _force_loop
1110 0002C460 31 02 jeql L332
1111 0002C462 # asm("brb _pipe8_8_lp1");; /* loop on the error */
1112 0002C462 11 c3 brb _pipe8_8_lp1
1113 0002C464 L332:
1114 0002C464 # /*
1115 0002C464 # * verify the results
1116 0002C464 # */
1117 0002C464 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
1118 0002C464 1d effffff7ea effffff7e5 cmpl _sgl_st_acc,_sgl_expected
1119 0002C46F 31 45 jeql L333
1120 0002C471 # {
1121 0002C471 # errcnt++; /* bump the error count */
1122 0002C471 6d effffff7dd incl _errcnt
1123 0002C477 # if ( prt_error )
1124 0002C477 5d effffff7d7 tstl _prt_error
1125 0002C47D 31 0d jeql L334
1126 0002C47F # print_pipe8_er("Cache Data, 3 NO-OPs");
1127 0002C47F .data 1
1128 00000df5 * L335:
1129 00000df5 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0"
3204E4F2D4F507300
1130 00000e0a * .text
1131 0002C47F dd 8f00000df5 pushl $L335
1132 0002C485 fe 08 ef000003a4 callf $8,_print_pipe8_er
1133 0002C48C # if ( halt_flg )
1134 0002C48C L334:
1135 0002C48C 5d effffff7c2 tstl _halt_flg
1136 0002C492 31 0d jeql L336
1137 0002C494 # pipe8_er_hlt( subtest );
1138 0002C494 dd effffff7ba pushl _subtest
1139 0002C49A fe 08 ef0000049b callf $8,_pipe8_er_hlt
1140 0002C4A1 # if ( loop_on_err ) {
1141 0002C4A1 L336:
1142 0002C4A1 5d effffff7ad tstl _loop_on_err
1143 0002C4A7 31 0d jeql L337
1144 0002C4A9 # force_loop = TRUE; /* set the force loop flag */
1145 0002C4A9 0d 01 effffff7a4 movl $1,_force_loop
1146 0002C4B0 # asm("jmp _pipe8_8_lp1"); /* and loop */
1147 0002C4B0 71 efffffff71 jmp _pipe8_8_lp1
1148 0002C4B6 # }
1149 0002C4B6 # } /* end of compare error */
1150 0002C4B6 L337:
1151 0002C4B6 # } while( index++ < max_ldf_1_index );
1152 0002C4B6 L333:
1153 0002C4B6 L330:
1154 0002C4B6 0d effffff798 50 movl _index,r0
1155 0002C4BD 6d effffff791 incl _index
1156 0002C4C3 1d 50 effffff78a cmpl r0,_max_ldf_1_index
1157 0002C4CA 81 03 13 ff16 jlss L331
1158 0002C4CF L329:
1159 0002C4CF # } /* end of subtest 8 */
1160 0002C4CF 40 ret#2
1161 0002C4D0 .set L325,0x0
1162 0002C4D0 L327:
1163 0002C4D0 13 ff06 jbr L328
1164 0002C4D3 .data
1165 00000d5c * .text
1166 0002C4D3 00 .align 1
1167 0002C4D4 .globl _pipe8_9
1168 0002C4D4 _pipe8_9:
1169 0002C4D4 0000 .word L338
1170 0002C4D6 #
1171 0002C4D6 #
1172 0002C4D6 #
1173 0002C4D6 #
1174 0002C4D6 #
1175 0002C4D6 #
1176 0002C4D6 # /*****************************************************************************
1177 0002C4D6 # *
1178 0002C4D6 # * SUBTEST 9
1179 0002C4D6 # * data on the stack, no NO-OPs
1180 0002C4D6 # *
1181 0002C4D6 # *****************************************************************************/
1182 0002C4D6 # pipe8_9()
1183 0002C4D6 # {
1184 0002C4D6 13 018e jbr L340
1185 0002C4D9 L341:
1186 0002C4D9 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1187 0002C4D9 ed 6d effffff774 moval (r13),_pre_event_fp
1188 0002C4E0 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1189 0002C4E0 ed 6e effffff76d moval (r14),_pre_event_sp
1190 0002C4E7 # force_loop = FALSE; /* clear force_loop flag */
1191 0002C4E7 4d effffff767 clrl _force_loop
1192 0002C4ED # index = 0;
1193 0002C4ED 4d effffff761 clrl _index
1194 0002C4F3 # do
1195 0002C4F3 L344:
1196 0002C4F3 # {
1197 0002C4F3 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1198 0002C4F3 0d effffff75b 50 movl _index,r0
1199 0002C4FA 48 03 50 50 shll $3,r0,r0
1200 0002C4FE 0d e000000000 effffff74b movl _ldf_1_data(r0),_sgl_value_1
1201 0002C509 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1202 0002C509 0d effffff745 50 movl _index,r0
1203 0002C510 48 03 50 50 shll $3,r0,r0
1204 0002C514 0d e000000004 effffff735 movl _ldf_1_data+4(r0),_sgl_expected
1205 0002C51F # sgl_value_2 = 0x40800000; /* floating '1' */
1206 0002C51F 0d 8f40800000 effffff72a movl $1082130432,_sgl_value_2
1207 0002C52A # sgl_value_3 = 0x41000000; /* floating '2' */
1208 0002C52A 0d 8f41000000 effffff71f movl $1090519040,_sgl_value_3
1209 0002C535 # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1210 0002C535 ed effffff719 effffff714 moval _pointer_data,_sgl_value_4
1211 0002C540 # /*
1212 0002C540 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1213 0002C540 # * The force loop flag is set after the first error.
1214 0002C540 # */
1215 0002C540 # asm("_pipe8_9_lp1:");
1216 0002C540 _pipe8_9_lp1:
1217 0002C540 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1218 0002C540 ed effffff70e 5e moval _pointer_data,r14
1219 0002C547 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1220 0002C547 0d effffff707 7e movl _sgl_value_1,-(r14)
1221 0002C54E # asm("movl _sgl_value_1,-(r14)"); /* onto the stack */
1222 0002C54E 0d effffff700 7e movl _sgl_value_1,-(r14)
1223 0002C555 # asm("movl _sgl_value_1,-(r14)"); /* 3 times */
1224 0002C555 0d effffff6f9 7e movl _sgl_value_1,-(r14)
1225 0002C55C # asm("movl _sgl_value_3,-(r14)"); /* push a '2' on the stack */
1226 0002C55C 0d effffff6f2 7e movl _sgl_value_3,-(r14)
1227 0002C563 # asm("movl _sgl_value_2,-(r14)"); /* push a '1' on the stack */
1228 0002C563 0d effffff6eb 7e movl _sgl_value_2,-(r14)
1229 0002C56A # /*
1230 0002C56A # * now pop the data off the stack
1231 0002C56A # */
1232 0002C56A # asm("ldf (r14)+"); /* 1.0 to the ACC. ( 1.0 ) */
1233 0002C56A 06 8e ldf (r14)+
1234 0002C56C # asm("subf (r14)+"); /* minus 2.0 (-1.0 ) */
1235 0002C56C d6 8e subf (r14)+
1236 0002C56E # asm("mulf (r14)+"); /* *'s the operand ( -op ) */
1237 0002C56E e6 8e mulf (r14)+
1238 0002C570 # asm("addf (r14)+"); /* + the operand ( 0 ) */
1239 0002C570 c6 8e addf (r14)+
1240 0002C572 # asm("addf (r14)+"); /* + the operand ( +op ) */
1241 0002C572 c6 8e addf (r14)+
1242 0002C574 # asm("stf r5"); /* store the result */
1243 0002C574 26 55 stf r5
1244 0002C576 # if( force_loop )
1245 0002C576 5d effffff6d8 tstl _force_loop
1246 0002C57C 31 02 jeql L345
1247 0002C57E # asm("brb _pipe8_9_lp1");; /* loop on the error */
1248 0002C57E 11 c0 brb _pipe8_9_lp1
1249 0002C580 L345:
1250 0002C580 # /*
1251 0002C580 # * verify the results
1252 0002C580 # */
1253 0002C580 # asm("movl r5,_sgl_st_acc"); /* get the result */
1254 0002C580 0d 55 effffff6cd movl r5,_sgl_st_acc
1255 0002C587 # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1256 0002C587 ed 6e effffff6c6 moval (r14),_sgl_value_5
1257 0002C58E # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1258 0002C58E # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1259 0002C58E 1d effffff6c0 effffff6bb cmpl _sgl_st_acc,_sgl_expected
1260 0002C599 21 10 jneq L9999
1261 0002C59B 1d effffff6b3 effffff6ae cmpl _sgl_value_5,_sgl_value_4
1262 0002C5A6 21 03 13 0094 jeql L346
1263 0002C5AB L9999:
1264 0002C5AB # {
1265 0002C5AB # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1266 0002C5AB 0d effffff6a3 5d movl _pre_event_fp,r13
1267 0002C5B2 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1268 0002C5B2 0d effffff69c 5e movl _pre_event_sp,r14
1269 0002C5B9 # errcnt++; /* bump the error count */
1270 0002C5B9 6d effffff695 incl _errcnt
1271 0002C5BF # if ( prt_error ) {
1272 0002C5BF 5d effffff68f tstl _prt_error
1273 0002C5C5 31 4e jeql L347
1274 0002C5C7 # print_pipe8_er("POP data from the STACK");
1275 0002C5C7 .data 1
1276 00000e0a * L348:
1277 00000e0a * 504F5020646174612066726F6 .ascii "POP data from the STACK\0"
D2074686520535441434B00
1278 00000e22 * .text
1279 0002C5C7 dd 8f00000e0a pushl $L348
1280 0002C5CD fe 08 ef0000025c callf $8,_print_pipe8_er
1281 0002C5D4 # writes("final Stack Pointer = ");
1282 0002C5D4 .data 1
1283 00000e22 * L349:
1284 00000e22 * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
06F696E746572203D2000
1285 00000e39 * .text
1286 0002C5D4 dd 8f00000e22 pushl $L349
1287 0002C5DA fe 08 effffff673 callf $8,_writes
1288 0002C5E1 # write32h( sgl_value_5 );
1289 0002C5E1 dd effffff66d pushl _sgl_value_5
1290 0002C5E7 fe 08 effffff666 callf $8,_write32h
1291 0002C5EE # writes(", expected SP = ");
1292 0002C5EE .data 1
1293 00000e39 * L351:
1294 00000e39 * 2C20206578706563746564205 .ascii ", expected SP = \0"
350203D2000
1295 00000e4b * .text
1296 0002C5EE dd 8f00000e39 pushl $L351
1297 0002C5F4 fe 08 effffff659 callf $8,_writes
1298 0002C5FB # write32h( sgl_value_4 );
1299 0002C5FB dd effffff653 pushl _sgl_value_4
1300 0002C601 fe 08 effffff64c callf $8,_write32h
1301 0002C608 # writes("\n");
1302 0002C608 .data 1
1303 00000e4b * L352:
1304 00000e4b * 0A00 .ascii "\12\0"
1305 00000e4d * .text
1306 0002C608 dd 8f00000e4b pushl $L352
1307 0002C60E fe 08 effffff63f callf $8,_writes
1308 0002C615 # }
1309 0002C615 # if ( halt_flg )
1310 0002C615 L347:
1311 0002C615 5d effffff639 tstl _halt_flg
1312 0002C61B 31 0d jeql L353
1313 0002C61D # pipe8_er_hlt( subtest );
1314 0002C61D dd effffff631 pushl _subtest
1315 0002C623 fe 08 ef00000312 callf $8,_pipe8_er_hlt
1316 0002C62A # if ( loop_on_err ) {
1317 0002C62A L353:
1318 0002C62A 5d effffff624 tstl _loop_on_err
1319 0002C630 31 0d jeql L354
1320 0002C632 # force_loop = TRUE; /* set the force loop flag */
1321 0002C632 0d 01 effffff61b movl $1,_force_loop
1322 0002C639 # asm("jmp _pipe8_9_lp1"); /* and loop */
1323 0002C639 71 efffffff01 jmp _pipe8_9_lp1
1324 0002C63F # }
1325 0002C63F # } /* end of compare error */
1326 0002C63F L354:
1327 0002C63F # } while( index++ < max_ldf_1_index );
1328 0002C63F L346:
1329 0002C63F L343:
1330 0002C63F 0d effffff60f 50 movl _index,r0
1331 0002C646 6d effffff608 incl _index
1332 0002C64C 1d 50 effffff601 cmpl r0,_max_ldf_1_index
1333 0002C653 81 03 13 fe9b jlss L344
1334 0002C658 L342:
1335 0002C658 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1336 0002C658 0d effffff5f6 5d movl _pre_event_fp,r13
1337 0002C65F # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1338 0002C65F 0d effffff5ef 5e movl _pre_event_sp,r14
1339 0002C666 # } /* end of subtest 9 */
1340 0002C666 40 ret#2
1341 0002C667 .set L338,0x0
1342 0002C667 L340:
1343 0002C667 13 fe6f jbr L341
1344 0002C66A .data
1345 00000d5c * .text
1346 0002C66A .align 1
1347 0002C66A .globl _pipe8_10
1348 0002C66A _pipe8_10:
1349 0002C66A 0000 .word L355
1350 0002C66C #
1351 0002C66C #
1352 0002C66C #
1353 0002C66C #
1354 0002C66C #
1355 0002C66C #
1356 0002C66C # /******************************************************************************
1357 0002C66C # *
1358 0002C66C # * SUBTEST 10
1359 0002C66C # * get data via indexed FRAME pointer
1360 0002C66C # *
1361 0002C66C # * ADDR INDEX DATA
1362 0002C66C # * pointer_data 4 <the STF result goes here>
1363 0002C66C # * pointer_data-4 3 <operand data>
1364 0002C66C # * pointer_data-8 2 <floating 1.0>
1365 0002C66C # * pointer_data-12 1 <floating 2.0>
1366 0002C66C # * pointer_data-16 0 point the frame pointer here
1367 0002C66C # *
1368 0002C66C # ******************************************************************************/
1369 0002C66C # pipe8_10()
1370 0002C66C # {
1371 0002C66C 13 01be jbr L357
1372 0002C66F L358:
1373 0002C66F # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1374 0002C66F ed 6d effffff5de moval (r13),_pre_event_fp
1375 0002C676 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1376 0002C676 ed 6e effffff5d7 moval (r14),_pre_event_sp
1377 0002C67D # force_loop = FALSE; /* clear force_loop flag */
1378 0002C67D 4d effffff5d1 clrl _force_loop
1379 0002C683 # index = 0;
1380 0002C683 4d effffff5cb clrl _index
1381 0002C689 # do
1382 0002C689 L361:
1383 0002C689 # {
1384 0002C689 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1385 0002C689 0d effffff5c5 50 movl _index,r0
1386 0002C690 48 03 50 50 shll $3,r0,r0
1387 0002C694 0d e000000000 effffff5b5 movl _ldf_1_data(r0),_sgl_value_1
1388 0002C69F # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1389 0002C69F 0d effffff5af 50 movl _index,r0
1390 0002C6A6 48 03 50 50 shll $3,r0,r0
1391 0002C6AA 0d e000000004 effffff59f movl _ldf_1_data+4(r0),_sgl_expected
1392 0002C6B5 # sgl_value_2 = 0x40800000; /* floating '1' */
1393 0002C6B5 0d 8f40800000 effffff594 movl $1082130432,_sgl_value_2
1394 0002C6C0 # sgl_value_3 = 0x41000000; /* floating '2' */
1395 0002C6C0 0d 8f41000000 effffff589 movl $1090519040,_sgl_value_3
1396 0002C6CB # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
1397 0002C6CB ed effffff583 effffff57e moval _pointer_data,_sgl_value_4
1398 0002C6D6 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1399 0002C6D6 2c 04 effffff577 subl2 $4,_sgl_value_4
1400 0002C6DD # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
1401 0002C6DD 0d effffff571 fffffff56c movl _sgl_value_1,*_sgl_value_4
1402 0002C6E8 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1403 0002C6E8 2c 04 effffff565 subl2 $4,_sgl_value_4
1404 0002C6EF # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the "1.0" data */
1405 0002C6EF 0d effffff55f fffffff55a movl _sgl_value_2,*_sgl_value_4
1406 0002C6FA # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1407 0002C6FA 2c 04 effffff553 subl2 $4,_sgl_value_4
1408 0002C701 # asm("movl _sgl_value_3,*_sgl_value_4"); /* set the "2.0" data */
1409 0002C701 0d effffff54d fffffff548 movl _sgl_value_3,*_sgl_value_4
1410 0002C70C # sgl_value_4 -= 4; /* get FRAME PTR address */
1411 0002C70C 2c 04 effffff541 subl2 $4,_sgl_value_4
1412 0002C713 # /*
1413 0002C713 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1414 0002C713 # * The force loop flag is set after the first error.
1415 0002C713 # */
1416 0002C713 # asm("_pipe8_10_lp1:");
1417 0002C713 _pipe8_10_lp1:
1418 0002C713 # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1419 0002C713 0d effffff53b 5d movl _sgl_value_4,r13
1420 0002C71A # asm("movl $1,r1"); /* r1 index = 1 longwords */
1421 0002C71A 0d 01 51 movl $1,r1
1422 0002C71D # asm("movl $2,r2"); /* r2 index = 2 longwords */
1423 0002C71D 0d 02 52 movl $2,r2
1424 0002C720 # asm("movl $3,r3"); /* r3 index = 3 longwords */
1425 0002C720 0d 03 53 movl $3,r3
1426 0002C723 # asm("movl $4,r4"); /* r4 index = 4 longwords */
1427 0002C723 0d 04 54 movl $4,r4
1428 0002C726 # asm("ldf (r13)[r2]"); /* 1.0 to the ACC. ( 1.0 ) */
1429 0002C726 06 426d ldf (r13)[r2]
1430 0002C729 # asm("subf (r13)[r1]"); /* minus 2.0 (-1.0 ) */
1431 0002C729 d6 416d subf (r13)[r1]
1432 0002C72C # asm("mulf (r13)[r3]"); /* *'s the operand ( -op ) */
1433 0002C72C e6 436d mulf (r13)[r3]
1434 0002C72F # asm("addf (r13)[r3]"); /* + the operand ( 0 ) */
1435 0002C72F c6 436d addf (r13)[r3]
1436 0002C732 # asm("addf (r13)[r3]"); /* + the operand ( +op ) */
1437 0002C732 c6 436d addf (r13)[r3]
1438 0002C735 # asm("stf (r13)[r4]"); /* store -indexed by r4 */
1439 0002C735 26 446d stf (r13)[r4]
1440 0002C738 # if( force_loop )
1441 0002C738 5d effffff516 tstl _force_loop
1442 0002C73E 31 02 jeql L362
1443 0002C740 # asm("brb _pipe8_10_lp1"); /* loop on the error */
1444 0002C740 11 d1 brb _pipe8_10_lp1
1445 0002C742 # /*
1446 0002C742 # * verify the results
1447 0002C742 # */
1448 0002C742 # sgl_st_acc = pointer_data; /* move the stored result */
1449 0002C742 L362:
1450 0002C742 0d effffff50c effffff507 movl _pointer_data,_sgl_st_acc
1451 0002C74D # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1452 0002C74D ed 6d effffff500 moval (r13),_sgl_value_5
1453 0002C754 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1454 0002C754 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1455 0002C754 1d effffff4fa effffff4f5 cmpl _sgl_st_acc,_sgl_expected
1456 0002C75F 21 10 jneq L9998
1457 0002C761 1d effffff4ed effffff4e8 cmpl _sgl_value_5,_sgl_value_4
1458 0002C76C 21 03 13 0094 jeql L363
1459 0002C771 L9998:
1460 0002C771 # {
1461 0002C771 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1462 0002C771 0d effffff4dd 5d movl _pre_event_fp,r13
1463 0002C778 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1464 0002C778 0d effffff4d6 5e movl _pre_event_sp,r14
1465 0002C77F # errcnt++; /* bump the error count */
1466 0002C77F 6d effffff4cf incl _errcnt
1467 0002C785 # if ( prt_error ) {
1468 0002C785 5d effffff4c9 tstl _prt_error
1469 0002C78B 31 4e jeql L364
1470 0002C78D # print_pipe8_er("indexed FP addressing");
1471 0002C78D .data 1
1472 00000e4d * L365:
1473 00000e4d * 696E646578656420465020616 .ascii "indexed FP addressing\0"
46472657373696E6700
1474 00000e63 * .text
1475 0002C78D dd 8f00000e4d pushl $L365
1476 0002C793 fe 08 ef00000096 callf $8,_print_pipe8_er
1477 0002C79A # writes("final Frame Pointer = ");
1478 0002C79A .data 1
1479 00000e63 * L366:
1480 00000e63 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1481 00000e7a * .text
1482 0002C79A dd 8f00000e63 pushl $L366
1483 0002C7A0 fe 08 effffff4ad callf $8,_writes
1484 0002C7A7 # writeh( sgl_value_5 );
1485 0002C7A7 dd effffff4a7 pushl _sgl_value_5
1486 0002C7AD fe 08 effffff4a0 callf $8,_writeh
1487 0002C7B4 # writes(", expected FP = ");
1488 0002C7B4 .data 1
1489 00000e7a * L368:
1490 00000e7a * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1491 00000e8c * .text
1492 0002C7B4 dd 8f00000e7a pushl $L368
1493 0002C7BA fe 08 effffff493 callf $8,_writes
1494 0002C7C1 # writeh( sgl_value_4 );
1495 0002C7C1 dd effffff48d pushl _sgl_value_4
1496 0002C7C7 fe 08 effffff486 callf $8,_writeh
1497 0002C7CE # writes("\n");
1498 0002C7CE .data 1
1499 00000e8c * L369:
1500 00000e8c * 0A00 .ascii "\12\0"
1501 00000e8e * .text
1502 0002C7CE dd 8f00000e8c pushl $L369
1503 0002C7D4 fe 08 effffff479 callf $8,_writes
1504 0002C7DB # }
1505 0002C7DB # if ( halt_flg )
1506 0002C7DB L364:
1507 0002C7DB 5d effffff473 tstl _halt_flg
1508 0002C7E1 31 0d jeql L370
1509 0002C7E3 # pipe8_er_hlt( subtest );
1510 0002C7E3 dd effffff46b pushl _subtest
1511 0002C7E9 fe 08 ef0000014c callf $8,_pipe8_er_hlt
1512 0002C7F0 # if ( loop_on_err ) {
1513 0002C7F0 L370:
1514 0002C7F0 5d effffff45e tstl _loop_on_err
1515 0002C7F6 31 0d jeql L371
1516 0002C7F8 # force_loop = TRUE; /* set the force loop flag */
1517 0002C7F8 0d 01 effffff455 movl $1,_force_loop
1518 0002C7FF # asm("jmp _pipe8_10_lp1"); /* and loop */
1519 0002C7FF 71 efffffff0e jmp _pipe8_10_lp1
1520 0002C805 # }
1521 0002C805 # } /* end of compare error */
1522 0002C805 L371:
1523 0002C805 # } while( index++ < max_ldf_1_index );
1524 0002C805 L363:
1525 0002C805 L360:
1526 0002C805 0d effffff449 50 movl _index,r0
1527 0002C80C 6d effffff442 incl _index
1528 0002C812 1d 50 effffff43b cmpl r0,_max_ldf_1_index
1529 0002C819 81 03 13 fe6b jlss L361
1530 0002C81E L359:
1531 0002C81E # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1532 0002C81E 0d effffff430 5d movl _pre_event_fp,r13
1533 0002C825 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1534 0002C825 0d effffff429 5e movl _pre_event_sp,r14
1535 0002C82C # } /* end of subtest 10 */
1536 0002C82C 40 ret#2
1537 0002C82D .set L355,0x0
1538 0002C82D L357:
1539 0002C82D 13 fe3f jbr L358
1540 0002C830 .data
1541 00000d5c * .text
1542 0002C830 .align 1
1543 0002C830 .globl _print_pipe8_er
1544 0002C830 _print_pipe8_er:
1545 0002C830 0000 .word L372
1546 0002C832 #
1547 0002C832 #
1548 0002C832 # /******************************************************************************
1549 0002C832 # *
1550 0002C832 # * ERROR ROUTINE
1551 0002C832 # *
1552 0002C832 # * print an error in the following form
1553 0002C832 # *
1554 0002C832 # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd
1555 0002C832 # * expected Acc = xxxxxxxx
1556 0002C832 # *
1557 0002C832 # ******************************************************************************/
1558 0002C832 # print_pipe8_er(msg)
1559 0002C832 # char *msg;
1560 0002C832 # {
1561 0002C832 13 0103 jbr L374
1562 0002C835 L375:
1563 0002C835 # writes("\n"); /* start a new print line */
1564 0002C835 .data 1
1565 00000e8e * L376:
1566 00000e8e * 0A00 .ascii "\12\0"
1567 00000e90 * .text
1568 0002C835 dd 8f00000e8e pushl $L376
1569 0002C83B fe 08 effffff412 callf $8,_writes
1570 0002C842 # writes("cycle: ");
1571 0002C842 .data 1
1572 00000e90 * L377:
1573 00000e90 * 6379636C653A2000 .ascii "cycle: \0"
1574 00000e98 * .text
1575 0002C842 dd 8f00000e90 pushl $L377
1576 0002C848 fe 08 effffff405 callf $8,_writes
1577 0002C84F # writed( cycle );
1578 0002C84F dd effffff3ff pushl _cycle
1579 0002C855 fe 08 effffff3f8 callf $8,_writed
1580 0002C85C # writes(" test ");
1581 0002C85C .data 1
1582 00000e98 * L379:
1583 00000e98 * 20746573742000 .ascii " test \0"
1584 00000e9f * .text
1585 0002C85C dd 8f00000e98 pushl $L379
1586 0002C862 fe 08 effffff3eb callf $8,_writes
1587 0002C869 # writed( test_no );
1588 0002C869 dd effffff3e5 pushl _test_no
1589 0002C86F fe 08 effffff3de callf $8,_writed
1590 0002C876 # writes(" (Pipe 8), subtest ");
1591 0002C876 .data 1
1592 00000e9f * L380:
1593 00000e9f * 202028506970652038292C207 .ascii " (Pipe 8), subtest \0"
37562746573742000
1594 00000eb4 * .text
1595 0002C876 dd 8f00000e9f pushl $L380
1596 0002C87C fe 08 effffff3d1 callf $8,_writes
1597 0002C883 # writed( subtest );
1598 0002C883 dd effffff3cb pushl _subtest
1599 0002C889 fe 08 effffff3c4 callf $8,_writed
1600 0002C890 # writes(" error - ");
1601 0002C890 .data 1
1602 00000eb4 * L381:
1603 00000eb4 * 206572726F72202D2000 .ascii " error - \0"
1604 00000ebe * .text
1605 0002C890 dd 8f00000eb4 pushl $L381
1606 0002C896 fe 08 effffff3b7 callf $8,_writes
1607 0002C89D # writes( msg );
1608 0002C89D dd ad04 pushl 4(fp)
1609 0002C8A0 fe 08 effffff3ad callf $8,_writes
1610 0002C8A7 # writec('\n');
1611 0002C8A7 dd 0a pushl $10
1612 0002C8A9 fe 08 effffff3a4 callf $8,_writec
1613 0002C8B0 # writes(
1614 0002C8B0 # "LDF(1.0), SUBF(2.0), MULF(op), ADDF(op), ADDF(op), STF\n");
1615 0002C8B0 .data 1
1616 00000ebe * L383:
1617 00000ebe * 4C444628312E30292C2053554 .ascii "LDF(1.0), SUBF(2.0), MULF(op), ADDF(op), ADDF(op), STF\12\0"
24628322E30292C204D554C46
286F70292C2041444446286F7
0292C202041444446286F7029
2C20205354460A00
1618 00000ef8 * .text
1619 0002C8B0 dd 8f00000ebe pushl $L383
1620 0002C8B6 fe 08 effffff397 callf $8,_writes
1621 0002C8BD # writes("operand = ");
1622 0002C8BD .data 1
1623 00000ef8 * L384:
1624 00000ef8 * 6F706572616E64203D2000 .ascii "operand = \0"
1625 00000f03 * .text
1626 0002C8BD dd 8f00000ef8 pushl $L384
1627 0002C8C3 fe 08 effffff38a callf $8,_writes
1628 0002C8CA # write32h( sgl_value_1 );
1629 0002C8CA dd effffff384 pushl _sgl_value_1
1630 0002C8D0 fe 08 effffff37d callf $8,_write32h
1631 0002C8D7 # writes(", final Acc = ");
1632 0002C8D7 .data 1
1633 00000f03 * L385:
1634 00000f03 * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
3203D2000
1635 00000f14 * .text
1636 0002C8D7 dd 8f00000f03 pushl $L385
1637 0002C8DD fe 08 effffff370 callf $8,_writes
1638 0002C8E4 # write32h( sgl_st_acc );
1639 0002C8E4 dd effffff36a pushl _sgl_st_acc
1640 0002C8EA fe 08 effffff363 callf $8,_write32h
1641 0002C8F1 # writes(", data index = ");
1642 0002C8F1 .data 1
1643 00000f14 * L386:
1644 00000f14 * 2C2020206461746120696E646 .ascii ", data index = \0"
578203D2000
1645 00000f26 * .text
1646 0002C8F1 dd 8f00000f14 pushl $L386
1647 0002C8F7 fe 08 effffff356 callf $8,_writes
1648 0002C8FE # writed( index );
1649 0002C8FE dd effffff350 pushl _index
1650 0002C904 fe 08 effffff349 callf $8,_writed
1651 0002C90B # writec('\n');
1652 0002C90B dd 0a pushl $10
1653 0002C90D fe 08 effffff340 callf $8,_writec
1654 0002C914 # writes(" expected Acc = ");
1655 0002C914 .data 1
1656 00000f26 * L387:
1657 00000f26 * 2020202020202020202020202 .ascii " expected Acc = \0"
0202020202020657870656374
656420416363203D2000
1658 00000f49 * .text
1659 0002C914 dd 8f00000f26 pushl $L387
1660 0002C91A fe 08 effffff333 callf $8,_writes
1661 0002C921 # write32h( sgl_expected );
1662 0002C921 dd effffff32d pushl _sgl_expected
1663 0002C927 fe 08 effffff326 callf $8,_write32h
1664 0002C92E # writec('\n');
1665 0002C92E dd 0a pushl $10
1666 0002C930 fe 08 effffff31d callf $8,_writec
1667 0002C937 # }
1668 0002C937 40 ret#2
1669 0002C938 .set L372,0x0
1670 0002C938 L374:
1671 0002C938 13 fefa jbr L375
1672 0002C93B .data
1673 00000d5c * .text
1674 0002C93B 00 .align 1
1675 0002C93C .globl _pipe8_er_hlt
1676 0002C93C _pipe8_er_hlt:
1677 0002C93C 0000 .word L388
1678 0002C93E #
1679 0002C93E #
1680 0002C93E #
1681 0002C93E #
1682 0002C93E #
1683 0002C93E # /******************************************************************************
1684 0002C93E # *
1685 0002C93E # * HALT ON ERROR ROUTINE
1686 0002C93E # *
1687 0002C93E # * halt with the necessary information saved in the registers
1688 0002C93E # *
1689 0002C93E # ******************************************************************************/
1690 0002C93E # pipe8_er_hlt( subtest )
1691 0002C93E # int subtest;
1692 0002C93E # {
1693 0002C93E 11 6e jbr L390
1694 0002C940 L391:
1695 0002C940 # asm("movl _test_no,r0"); /* r0 = test number */
1696 0002C940 0d effffff30e 50 movl _test_no,r0
1697 0002C947 # asm("movl _subtest,r1"); /* r1 = subtest number */
1698 0002C947 0d effffff307 51 movl _subtest,r1
1699 0002C94E # asm("movl $1,r2"); /* r2 = error code */
1700 0002C94E 0d 01 52 movl $1,r2
1701 0002C951 # asm("movl _cycle,r3"); /* r3 = cycle count */
1702 0002C951 0d effffff2fd 53 movl _cycle,r3
1703 0002C958 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1704 0002C958 0d effffff2f6 54 movl _sgl_value_1,r4
1705 0002C95F # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */
1706 0002C95F 0d effffff2ef 55 movl _sgl_st_acc,r5
1707 0002C966 # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */
1708 0002C966 0d effffff2e8 56 movl _sgl_expected,r6
1709 0002C96D # asm("movl _index,r7"); /* r7 = data index */
1710 0002C96D 0d effffff2e1 57 movl _index,r7
1711 0002C974 # asm("movl _sgl_value_2,r8"); /* r8 = floating one */
1712 0002C974 0d effffff2da 58 movl _sgl_value_2,r8
1713 0002C97B # asm("movl _sgl_value_3,r9"); /* r9 = floating two */
1714 0002C97B 0d effffff2d3 59 movl _sgl_value_3,r9
1715 0002C982 # if( subtest == 9 ) {
1716 0002C982 1d ad04 09 cmpl 4(fp),$9
1717 0002C986 21 10 jneq L392
1718 0002C988 # asm("movl _sgl_value_3,r10"); /* r10 = final SP value */
1719 0002C988 0d effffff2c6 5a movl _sgl_value_3,r10
1720 0002C98F # asm("movl _sgl_value_2,r11"); /* r11 = expected SP value */
1721 0002C98F 0d effffff2bf 5b movl _sgl_value_2,r11
1722 0002C996 # } else
1723 0002C996 11 14 jbr L393
1724 0002C998 L392:
1725 0002C998 # if( subtest == 10 ) {
1726 0002C998 1d ad04 0a cmpl 4(fp),$10
1727 0002C99C 21 0e jneq L394
1728 0002C99E # asm("movl _sgl_value_3,r10"); /* r10 = final FP value */
1729 0002C99E 0d effffff2b0 5a movl _sgl_value_3,r10
1730 0002C9A5 # asm("movl _sgl_value_2,r11"); /* r11 = expected FP value */
1731 0002C9A5 0d effffff2a9 5b movl _sgl_value_2,r11
1732 0002C9AC # };
1733 0002C9AC L394:
1734 0002C9AC L393:
1735 0002C9AC # asm(".globl _pipe8_1_hlt");
1736 0002C9AC .globl _pipe8_1_hlt
1737 0002C9AC # asm("_pipe8_1_hlt:"); /* PC after the halt */
1738 0002C9AC _pipe8_1_hlt:
1739 0002C9AC # asm("halt"); /* HALT ... */
1740 0002C9AC 00 halt
1741 0002C9AD # } /* end of halt on error */
1742 0002C9AD 40 ret#2
1743 0002C9AE .set L388,0x0
1744 0002C9AE L390:
1745 0002C9AE 11 90 jbr L391
1746 00000d5c * .data
1746 00000d5c * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.