![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe14.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 pipe14.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 00000fe4 * .text
4 00000000 .align 1
5 00000000 .globl _pipe_14
6 00000000 _pipe_14:
7 0002F03C 0000 .word L215
8 0002F03E # #include "fpp_defs.h"
9 0002F03E #
10 0002F03E #
11 0002F03E # /*****************************************************************************
12 0002F03E # *
13 0002F03E # * DBL PIPELINE TEST #14 MONITOR
14 0002F03E # *
15 0002F03E # * This test will do:
16 0002F03E # *
17 0002F03E # * LDD(0) ADDD(op1) DIVD(op2) MULD(1) STD
18 0002F03E # *
19 0002F03E # * where 'op1' and 'op2' are the DIVD data patterns.
20 0002F03E # *****************************************************************************/
21 0002F03E # pipe_14()
22 0002F03E # {
23 0002F03E 13 009b jbr L217
24 0002F041 L218:
25 0002F041 # asm(".globl _pipeline_14_t");
26 0002F041 .globl _pipeline_14_t
27 0002F041 # asm("_pipeline_14_t:"); /* entry address */
28 0002F041 _pipeline_14_t:
29 0002F041 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
30 0002F041 1d effffffff5 01 cmpl _cycle,$1
31 0002F048 21 15 jneq L219
32 0002F04A 5d efffffffec tstl _prt_hdrs
33 0002F050 31 0d jeql L219
34 0002F052 # {
35 0002F052 # writes(" PIPE_14");
36 0002F052 .data 1
37 00000fe4 * L221:
38 00000fe4 * 20504950455F313400 .ascii " PIPE_14\0"
39 00000fed * .text
40 0002F052 dd 8f00000fe4 pushl $L221
41 0002F058 fe 08 efffffffdd callf $8,_writes
42 0002F05F # }
43 0002F05F # subtest = 1;
44 0002F05F L219:
45 0002F05F 0d 01 efffffffd6 movl $1,_subtest
46 0002F066 # pipe14_1(); /* data in REGs, no NOPs */
47 0002F066 fe 04 ef00000073 callf $4,_pipe14_1
48 0002F06D # subtest++; /* increment subtest num */
49 0002F06D 6d efffffffc9 incl _subtest
50 0002F073 # pipe14_2(); /* data in REGs, 1 NOP */
51 0002F073 fe 04 ef000001dc callf $4,_pipe14_2
52 0002F07A # subtest++; /* increment subtest num */
53 0002F07A 6d efffffffbc incl _subtest
54 0002F080 # pipe14_3(); /* data in REGs, 2 NOPs */
55 0002F080 fe 04 ef00000349 callf $4,_pipe14_3
56 0002F087 # subtest++; /* increment subtest num */
57 0002F087 6d efffffffaf incl _subtest
58 0002F08D # pipe14_4(); /* data in REGs, 3 NOPs */
59 0002F08D fe 04 ef000004ba callf $4,_pipe14_4
60 0002F094 # subtest++; /* increment subtest num */
61 0002F094 6d efffffffa2 incl _subtest
62 0002F09A # pipe14_5(); /* data in CACHE, no NOPs */
63 0002F09A fe 04 ef0000062f callf $4,_pipe14_5
64 0002F0A1 # subtest++; /* increment subtest num */
65 0002F0A1 6d efffffff95 incl _subtest
66 0002F0A7 # pipe14_6(); /* data in CACHE, 1 NOP */
67 0002F0A7 fe 04 ef0000074c callf $4,_pipe14_6
68 0002F0AE # subtest++; /* increment subtest num */
69 0002F0AE 6d efffffff88 incl _subtest
70 0002F0B4 # pipe14_7(); /* data in CACHE, 2 NOPs */
71 0002F0B4 fe 04 ef0000086d callf $4,_pipe14_7
72 0002F0BB # subtest++; /* increment subtest num */
73 0002F0BB 6d efffffff7b incl _subtest
74 0002F0C1 # pipe14_8(); /* data in CACHE, 3 NOPs */
75 0002F0C1 fe 04 ef00000992 callf $4,_pipe14_8
76 0002F0C8 # subtest++; /* increment subtest num */
77 0002F0C8 6d efffffff6e incl _subtest
78 0002F0CE # pipe14_9(); /* data via F.P. 0 NOPs */
79 0002F0CE fe 04 ef00000abb callf $4,_pipe14_9
80 0002F0D5 # asm("jmp *return"); /* return to the test monitor */
81 0002F0D5 71 ffffffff61 jmp *return
82 0002F0DB # }
83 0002F0DB 40 ret#2
84 0002F0DC .set L215,0x0
85 0002F0DC L217:
86 0002F0DC 13 ff62 jbr L218
87 0002F0DF .data
88 00000fe4 * .text
89 0002F0DF 00 .align 1
90 0002F0E0 .globl _pipe14_1
91 0002F0E0 _pipe14_1:
92 0002F0E0 0000 .word L231
93 0002F0E2 #
94 0002F0E2 #
95 0002F0E2 #
96 0002F0E2 #
97 0002F0E2 #
98 0002F0E2 #
99 0002F0E2 #
100 0002F0E2 # /************************************************************************
101 0002F0E2 # *
102 0002F0E2 # * SUBTEST 1
103 0002F0E2 # * data in registers, no NO-OPs
104 0002F0E2 # *
105 0002F0E2 # ************************************************************************/
106 0002F0E2 # pipe14_1()
107 0002F0E2 # {
108 0002F0E2 13 016d jbr L233
109 0002F0E5 L234:
110 0002F0E5 # force_loop = FALSE; /* clear the force_loop flg */
111 0002F0E5 4d efffffff51 clrl _force_loop
112 0002F0EB # index = 0;
113 0002F0EB 4d efffffff4b clrl _index
114 0002F0F1 # do
115 0002F0F1 L237:
116 0002F0F1 # {
117 0002F0F1 # sgl_value_1 = divd_1_data[index].op_1.m; /* get op_1's MSW */
118 0002F0F1 5c 18 efffffff44 50 mull3 $24,_index,r0
119 0002F0F9 0d e000000000 efffffff38 movl _divd_1_data(r0),_sgl_value_1
120 0002F104 # sgl_value_2 = divd_1_data[index].op_1.l; /* get op_1's LSW */
121 0002F104 5c 18 efffffff31 50 mull3 $24,_index,r0
122 0002F10C 0d e000000004 efffffff25 movl _divd_1_data+4(r0),_sgl_value_2
123 0002F117 # sgl_value_3 = divd_1_data[index].op_2.m; /* get op_2's MSW */
124 0002F117 5c 18 efffffff1e 50 mull3 $24,_index,r0
125 0002F11F 0d e000000008 efffffff12 movl _divd_1_data+8(r0),_sgl_value_3
126 0002F12A # sgl_value_4 = divd_1_data[index].op_2.l; /* get op_2's LSW */
127 0002F12A 5c 18 efffffff0b 50 mull3 $24,_index,r0
128 0002F132 0d e00000000c effffffeff movl _divd_1_data+12(r0),_sgl_value_4
129 0002F13D # sgl_value_7 = 0x40800000; /* get dbl precision 1.0 */
130 0002F13D 0d 8f40800000 effffffef4 movl $1082130432,_sgl_value_7
131 0002F148 # sgl_value_8 = 0;
132 0002F148 4d effffffeee clrl _sgl_value_8
133 0002F14E # dbl_expected = divd_1_data[index].exp; /* get expected results */
134 0002F14E 5c 18 effffffee7 50 mull3 $24,_index,r0
135 0002F156 0c 8f00000010 50 addl2 $_divd_1_data+16,r0
136 0002F15D 0d a004 effffffedb movl 4(r0),_dbl_expected+4
137 0002F165 0d 60 effffffed0 movl (r0),_dbl_expected
138 0002F16C # /*
139 0002F16C # * If LOOP ON ERROR is set, this is the loop for this subtest.
140 0002F16C # * The force loop flag is set after the first error.
141 0002F16C # */
142 0002F16C # asm("_pipe14_1_lp1:");
143 0002F16C _pipe14_1_lp1:
144 0002F16C # asm("movl _sgl_value_1,r0"); /* move operand 1 to r0/r1 */
145 0002F16C 0d effffffeca 50 movl _sgl_value_1,r0
146 0002F173 # asm("movl _sgl_value_2,r1");
147 0002F173 0d effffffec3 51 movl _sgl_value_2,r1
148 0002F17A # asm("movl _sgl_value_3,r2"); /* move operand 2 to r2/r3 */
149 0002F17A 0d effffffebc 52 movl _sgl_value_3,r2
150 0002F181 # asm("movl _sgl_value_4,r3");
151 0002F181 0d effffffeb5 53 movl _sgl_value_4,r3
152 0002F188 # asm("movl _sgl_value_7,r4"); /* move a '1.0' to r4/r5 */
153 0002F188 0d effffffeae 54 movl _sgl_value_7,r4
154 0002F18F # asm("movl _sgl_value_8,r5");
155 0002F18F 0d effffffea7 55 movl _sgl_value_8,r5
156 0002F196 # asm("movl _sgl_value_8,r8"); /* move a '0.0' to r8/r9 */
157 0002F196 0d effffffea0 58 movl _sgl_value_8,r8
158 0002F19D # asm("movl _sgl_value_8,r9");
159 0002F19D 0d effffffe99 59 movl _sgl_value_8,r9
160 0002F1A4 # asm("ldd r8"); /* load a '0.0' ( 0 ) */
161 0002F1A4 07 58 ldd r8
162 0002F1A6 # asm("addd r0"); /* add operand 1 ( op1 ) */
163 0002F1A6 c7 50 addd r0
164 0002F1A8 # asm("divd r2"); /* div by operand 2 ( exp ) */
165 0002F1A8 f7 52 divd r2
166 0002F1AA # asm("muld r4"); /* multiply by 1.0 ( exp ) */
167 0002F1AA e7 54 muld r4
168 0002F1AC # asm("std r6"); /* store the result ( exp ) */
169 0002F1AC 27 56 std r6
170 0002F1AE # if( force_loop )
171 0002F1AE 5d effffffe88 tstl _force_loop
172 0002F1B4 31 02 jeql L238
173 0002F1B6 # asm("brb _pipe14_1_lp1");; /* run the loop again */
174 0002F1B6 11 b4 brb _pipe14_1_lp1
175 0002F1B8 L238:
176 0002F1B8 # /*
177 0002F1B8 # * verify the results
178 0002F1B8 # */
179 0002F1B8 # asm("movl r6,_sgl_value_5"); /* get the result */
180 0002F1B8 0d 56 effffffe7d movl r6,_sgl_value_5
181 0002F1BF # asm("movl r7,_sgl_value_6");
182 0002F1BF 0d 57 effffffe76 movl r7,_sgl_value_6
183 0002F1C6 # dbl_st_acc.m = sgl_value_5;
184 0002F1C6 0d effffffe70 effffffe6b movl _sgl_value_5,_dbl_st_acc
185 0002F1D1 # dbl_st_acc.l = sgl_value_6;
186 0002F1D1 0d effffffe65 effffffe64 movl _sgl_value_6,_dbl_st_acc+4
187 0002F1DC # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
188 0002F1DC # (dbl_st_acc.l != dbl_expected.l) )
189 0002F1DC 1d effffffe5a effffffe55 cmpl _dbl_st_acc,_dbl_expected
190 0002F1E7 21 0d jneq L9999
191 0002F1E9 1d effffffe51 effffffe4c cmpl _dbl_st_acc+4,_dbl_expected+4
192 0002F1F4 31 42 jeql L239
193 0002F1F6 L9999:
194 0002F1F6 # {
195 0002F1F6 # errcnt++; /* bump the error count */
196 0002F1F6 6d effffffe40 incl _errcnt
197 0002F1FC # if ( prt_error )
198 0002F1FC 5d effffffe3a tstl _prt_error
199 0002F202 31 0d jeql L240
200 0002F204 # print_pipe14_er("Reg. Data, no NOPs");
201 0002F204 .data 1
202 00000fed * L242:
203 00000fed * 5265672E20446174612C206E6 .ascii "Reg. Data, no NOPs\0"
F204E4F507300
204 00001000 * .text
205 0002F204 dd 8f00000fed pushl $L242
206 0002F20A fe 08 ef00000bef callf $8,_print_pipe14_er
207 0002F211 # if ( halt_flg ) /* halt on error? */
208 0002F211 L240:
209 0002F211 5d effffffe25 tstl _halt_flg
210 0002F217 31 0d jeql L243
211 0002F219 # pipe14_er_hlt( subtest );
212 0002F219 dd effffffe1d pushl _subtest
213 0002F21F fe 08 ef00000d58 callf $8,_pipe14_er_hlt
214 0002F226 # if ( loop_on_err ) {
215 0002F226 L243:
216 0002F226 5d effffffe10 tstl _loop_on_err
217 0002F22C 31 0a jeql L245
218 0002F22E # force_loop = TRUE; /* set the force loop flag */
219 0002F22E 0d 01 effffffe07 movl $1,_force_loop
220 0002F235 # asm("brw _pipe14_1_lp1"); /* and loop */
221 0002F235 13 ff34 brw _pipe14_1_lp1
222 0002F238 # }
223 0002F238 # } /* end of compare error */
224 0002F238 L245:
225 0002F238 # } while( index++ < max_divd_1_index );
226 0002F238 L239:
227 0002F238 L236:
228 0002F238 0d effffffdfe 50 movl _index,r0
229 0002F23F 6d effffffdf7 incl _index
230 0002F245 1d 50 effffffdf0 cmpl r0,_max_divd_1_index
231 0002F24C 81 03 13 fea0 jlss L237
232 0002F251 L235:
233 0002F251 # } /* end of subtest 1 */
234 0002F251 40 ret#2
235 0002F252 .set L231,0x0
236 0002F252 L233:
237 0002F252 13 fe90 jbr L234
238 0002F255 .data
239 00000fe4 * .text
240 0002F255 00 .align 1
241 0002F256 .globl _pipe14_2
242 0002F256 _pipe14_2:
243 0002F256 0000 .word L246
244 0002F258 #
245 0002F258 #
246 0002F258 #
247 0002F258 #
248 0002F258 #
249 0002F258 #
250 0002F258 #
251 0002F258 #
252 0002F258 #
253 0002F258 # /************************************************************************
254 0002F258 # *
255 0002F258 # * SUBTEST 2
256 0002F258 # * data in registers, no NO-OPs
257 0002F258 # *
258 0002F258 # ************************************************************************/
259 0002F258 # pipe14_2()
260 0002F258 # {
261 0002F258 13 0171 jbr L248
262 0002F25B L249:
263 0002F25B # force_loop = FALSE; /* clear the force_loop flg */
264 0002F25B 4d effffffddb clrl _force_loop
265 0002F261 # index = 0;
266 0002F261 4d effffffdd5 clrl _index
267 0002F267 # do
268 0002F267 L252:
269 0002F267 # {
270 0002F267 # sgl_value_1 = divd_1_data[index].op_1.m; /* get op_1's MSW */
271 0002F267 5c 18 effffffdce 50 mull3 $24,_index,r0
272 0002F26F 0d e000000000 effffffdc2 movl _divd_1_data(r0),_sgl_value_1
273 0002F27A # sgl_value_2 = divd_1_data[index].op_1.l; /* get op_1's LSW */
274 0002F27A 5c 18 effffffdbb 50 mull3 $24,_index,r0
275 0002F282 0d e000000004 effffffdaf movl _divd_1_data+4(r0),_sgl_value_2
276 0002F28D # sgl_value_3 = divd_1_data[index].op_2.m; /* get op_2's MSW */
277 0002F28D 5c 18 effffffda8 50 mull3 $24,_index,r0
278 0002F295 0d e000000008 effffffd9c movl _divd_1_data+8(r0),_sgl_value_3
279 0002F2A0 # sgl_value_4 = divd_1_data[index].op_2.l; /* get op_2's LSW */
280 0002F2A0 5c 18 effffffd95 50 mull3 $24,_index,r0
281 0002F2A8 0d e00000000c effffffd89 movl _divd_1_data+12(r0),_sgl_value_4
282 0002F2B3 # sgl_value_7 = 0x40800000; /* get dbl precision 1.0 */
283 0002F2B3 0d 8f40800000 effffffd7e movl $1082130432,_sgl_value_7
284 0002F2BE # sgl_value_8 = 0;
285 0002F2BE 4d effffffd78 clrl _sgl_value_8
286 0002F2C4 # dbl_expected = divd_1_data[index].exp; /* get expected results */
287 0002F2C4 5c 18 effffffd71 50 mull3 $24,_index,r0
288 0002F2CC 0c 8f00000010 50 addl2 $_divd_1_data+16,r0
289 0002F2D3 0d a004 effffffd65 movl 4(r0),_dbl_expected+4
290 0002F2DB 0d 60 effffffd5a movl (r0),_dbl_expected
291 0002F2E2 # /*
292 0002F2E2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
293 0002F2E2 # * The force loop flag is set after the first error.
294 0002F2E2 # */
295 0002F2E2 # asm("_pipe14_2_lp1:");
296 0002F2E2 _pipe14_2_lp1:
297 0002F2E2 # asm("movl _sgl_value_1,r0"); /* move operand 1 to r0/r1 */
298 0002F2E2 0d effffffd54 50 movl _sgl_value_1,r0
299 0002F2E9 # asm("movl _sgl_value_2,r1");
300 0002F2E9 0d effffffd4d 51 movl _sgl_value_2,r1
301 0002F2F0 # asm("movl _sgl_value_3,r2"); /* move operand 2 to r2/r3 */
302 0002F2F0 0d effffffd46 52 movl _sgl_value_3,r2
303 0002F2F7 # asm("movl _sgl_value_4,r3");
304 0002F2F7 0d effffffd3f 53 movl _sgl_value_4,r3
305 0002F2FE # asm("movl _sgl_value_7,r4"); /* move a '1.0' to r4/r5 */
306 0002F2FE 0d effffffd38 54 movl _sgl_value_7,r4
307 0002F305 # asm("movl _sgl_value_8,r5");
308 0002F305 0d effffffd31 55 movl _sgl_value_8,r5
309 0002F30C # asm("movl _sgl_value_8,r8"); /* move a '0.0' to r8/r9 */
310 0002F30C 0d effffffd2a 58 movl _sgl_value_8,r8
311 0002F313 # asm("movl _sgl_value_8,r9");
312 0002F313 0d effffffd23 59 movl _sgl_value_8,r9
313 0002F31A # asm("ldd r8"); /* load a '0.0' ( 0 ) */
314 0002F31A 07 58 ldd r8
315 0002F31C # asm("nop");
316 0002F31C 10 nop
317 0002F31D # asm("addd r0"); /* add operand 1 ( op1 ) */
318 0002F31D c7 50 addd r0
319 0002F31F # asm("nop");
320 0002F31F 10 nop
321 0002F320 # asm("divd r2"); /* div by operand 2 ( exp ) */
322 0002F320 f7 52 divd r2
323 0002F322 # asm("nop");
324 0002F322 10 nop
325 0002F323 # asm("muld r4"); /* multiply by 1.0 ( exp ) */
326 0002F323 e7 54 muld r4
327 0002F325 # asm("nop");
328 0002F325 10 nop
329 0002F326 # asm("std r6"); /* store the result ( exp ) */
330 0002F326 27 56 std r6
331 0002F328 # if( force_loop )
332 0002F328 5d effffffd0e tstl _force_loop
333 0002F32E 31 02 jeql L253
334 0002F330 # asm("brb _pipe14_2_lp1");; /* run the loop again */
335 0002F330 11 b0 brb _pipe14_2_lp1
336 0002F332 L253:
337 0002F332 # /*
338 0002F332 # * verify the results
339 0002F332 # */
340 0002F332 # asm("movl r6,_sgl_value_5"); /* get the result */
341 0002F332 0d 56 effffffd03 movl r6,_sgl_value_5
342 0002F339 # asm("movl r7,_sgl_value_6");
343 0002F339 0d 57 effffffcfc movl r7,_sgl_value_6
344 0002F340 # dbl_st_acc.m = sgl_value_5;
345 0002F340 0d effffffcf6 effffffcf1 movl _sgl_value_5,_dbl_st_acc
346 0002F34B # dbl_st_acc.l = sgl_value_6;
347 0002F34B 0d effffffceb effffffcea movl _sgl_value_6,_dbl_st_acc+4
348 0002F356 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
349 0002F356 # (dbl_st_acc.l != dbl_expected.l) )
350 0002F356 1d effffffce0 effffffcdb cmpl _dbl_st_acc,_dbl_expected
351 0002F361 21 0d jneq L9998
352 0002F363 1d effffffcd7 effffffcd2 cmpl _dbl_st_acc+4,_dbl_expected+4
353 0002F36E 31 42 jeql L254
354 0002F370 L9998:
355 0002F370 # {
356 0002F370 # errcnt++; /* bump the error count */
357 0002F370 6d effffffcc6 incl _errcnt
358 0002F376 # if ( prt_error )
359 0002F376 5d effffffcc0 tstl _prt_error
360 0002F37C 31 0d jeql L255
361 0002F37E # print_pipe14_er("Reg. Data, 1 NOP");
362 0002F37E .data 1
363 00001000 * L256:
364 00001000 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NOP\0"
04E4F5000
365 00001011 * .text
366 0002F37E dd 8f00001000 pushl $L256
367 0002F384 fe 08 ef00000a75 callf $8,_print_pipe14_er
368 0002F38B # if ( halt_flg ) /* halt on error? */
369 0002F38B L255:
370 0002F38B 5d effffffcab tstl _halt_flg
371 0002F391 31 0d jeql L257
372 0002F393 # pipe14_er_hlt( subtest );
373 0002F393 dd effffffca3 pushl _subtest
374 0002F399 fe 08 ef00000bde callf $8,_pipe14_er_hlt
375 0002F3A0 # if ( loop_on_err ) {
376 0002F3A0 L257:
377 0002F3A0 5d effffffc96 tstl _loop_on_err
378 0002F3A6 31 0a jeql L258
379 0002F3A8 # force_loop = TRUE; /* set the force loop flag */
380 0002F3A8 0d 01 effffffc8d movl $1,_force_loop
381 0002F3AF # asm("brw _pipe14_2_lp1"); /* and loop */
382 0002F3AF 13 ff30 brw _pipe14_2_lp1
383 0002F3B2 # }
384 0002F3B2 # } /* end of compare error */
385 0002F3B2 L258:
386 0002F3B2 # } while( index++ < max_divd_1_index );
387 0002F3B2 L254:
388 0002F3B2 L251:
389 0002F3B2 0d effffffc84 50 movl _index,r0
390 0002F3B9 6d effffffc7d incl _index
391 0002F3BF 1d 50 effffffc76 cmpl r0,_max_divd_1_index
392 0002F3C6 81 03 13 fe9c jlss L252
393 0002F3CB L250:
394 0002F3CB # } /* end of subtest 2 */
395 0002F3CB 40 ret#2
396 0002F3CC .set L246,0x0
397 0002F3CC L248:
398 0002F3CC 13 fe8c jbr L249
399 0002F3CF .data
400 00000fe4 * .text
401 0002F3CF 00 .align 1
402 0002F3D0 .globl _pipe14_3
403 0002F3D0 _pipe14_3:
404 0002F3D0 0000 .word L259
405 0002F3D2 #
406 0002F3D2 #
407 0002F3D2 #
408 0002F3D2 #
409 0002F3D2 #
410 0002F3D2 #
411 0002F3D2 #
412 0002F3D2 # /************************************************************************
413 0002F3D2 # *
414 0002F3D2 # * SUBTEST 3
415 0002F3D2 # * data in registers, 2 NO-OPs
416 0002F3D2 # *
417 0002F3D2 # ************************************************************************/
418 0002F3D2 # pipe14_3()
419 0002F3D2 # {
420 0002F3D2 13 0175 jbr L261
421 0002F3D5 L262:
422 0002F3D5 # force_loop = FALSE; /* clear the force_loop flg */
423 0002F3D5 4d effffffc61 clrl _force_loop
424 0002F3DB # index = 0;
425 0002F3DB 4d effffffc5b clrl _index
426 0002F3E1 # do
427 0002F3E1 L265:
428 0002F3E1 # {
429 0002F3E1 # sgl_value_1 = divd_1_data[index].op_1.m; /* get op_1's MSW */
430 0002F3E1 5c 18 effffffc54 50 mull3 $24,_index,r0
431 0002F3E9 0d e000000000 effffffc48 movl _divd_1_data(r0),_sgl_value_1
432 0002F3F4 # sgl_value_2 = divd_1_data[index].op_1.l; /* get op_1's LSW */
433 0002F3F4 5c 18 effffffc41 50 mull3 $24,_index,r0
434 0002F3FC 0d e000000004 effffffc35 movl _divd_1_data+4(r0),_sgl_value_2
435 0002F407 # sgl_value_3 = divd_1_data[index].op_2.m; /* get op_2's MSW */
436 0002F407 5c 18 effffffc2e 50 mull3 $24,_index,r0
437 0002F40F 0d e000000008 effffffc22 movl _divd_1_data+8(r0),_sgl_value_3
438 0002F41A # sgl_value_4 = divd_1_data[index].op_2.l; /* get op_2's LSW */
439 0002F41A 5c 18 effffffc1b 50 mull3 $24,_index,r0
440 0002F422 0d e00000000c effffffc0f movl _divd_1_data+12(r0),_sgl_value_4
441 0002F42D # sgl_value_7 = 0x40800000; /* get dbl precision 1.0 */
442 0002F42D 0d 8f40800000 effffffc04 movl $1082130432,_sgl_value_7
443 0002F438 # sgl_value_8 = 0;
444 0002F438 4d effffffbfe clrl _sgl_value_8
445 0002F43E # dbl_expected = divd_1_data[index].exp; /* get expected results */
446 0002F43E 5c 18 effffffbf7 50 mull3 $24,_index,r0
447 0002F446 0c 8f00000010 50 addl2 $_divd_1_data+16,r0
448 0002F44D 0d a004 effffffbeb movl 4(r0),_dbl_expected+4
449 0002F455 0d 60 effffffbe0 movl (r0),_dbl_expected
450 0002F45C # /*
451 0002F45C # * If LOOP ON ERROR is set, this is the loop for this subtest.
452 0002F45C # * The force loop flag is set after the first error.
453 0002F45C # */
454 0002F45C # asm("_pipe14_3_lp1:");
455 0002F45C _pipe14_3_lp1:
456 0002F45C # asm("movl _sgl_value_1,r0"); /* move operand 1 to r0/r1 */
457 0002F45C 0d effffffbda 50 movl _sgl_value_1,r0
458 0002F463 # asm("movl _sgl_value_2,r1");
459 0002F463 0d effffffbd3 51 movl _sgl_value_2,r1
460 0002F46A # asm("movl _sgl_value_3,r2"); /* move operand 2 to r2/r3 */
461 0002F46A 0d effffffbcc 52 movl _sgl_value_3,r2
462 0002F471 # asm("movl _sgl_value_4,r3");
463 0002F471 0d effffffbc5 53 movl _sgl_value_4,r3
464 0002F478 # asm("movl _sgl_value_7,r4"); /* move a '1.0' to r4/r5 */
465 0002F478 0d effffffbbe 54 movl _sgl_value_7,r4
466 0002F47F # asm("movl _sgl_value_8,r5");
467 0002F47F 0d effffffbb7 55 movl _sgl_value_8,r5
468 0002F486 # asm("movl _sgl_value_8,r8"); /* move a '0.0' to r8/r9 */
469 0002F486 0d effffffbb0 58 movl _sgl_value_8,r8
470 0002F48D # asm("movl _sgl_value_8,r9");
471 0002F48D 0d effffffba9 59 movl _sgl_value_8,r9
472 0002F494 # asm("ldd r8"); /* load a '0.0' ( 0 ) */
473 0002F494 07 58 ldd r8
474 0002F496 # asm("nop");
475 0002F496 10 nop
476 0002F497 # asm("nop");
477 0002F497 10 nop
478 0002F498 # asm("addd r0"); /* add operand 1 ( op1 ) */
479 0002F498 c7 50 addd r0
480 0002F49A # asm("nop");
481 0002F49A 10 nop
482 0002F49B # asm("nop");
483 0002F49B 10 nop
484 0002F49C # asm("divd r2"); /* div by operand 2 ( exp ) */
485 0002F49C f7 52 divd r2
486 0002F49E # asm("nop");
487 0002F49E 10 nop
488 0002F49F # asm("nop");
489 0002F49F 10 nop
490 0002F4A0 # asm("muld r4"); /* multiply by 1.0 ( exp ) */
491 0002F4A0 e7 54 muld r4
492 0002F4A2 # asm("nop");
493 0002F4A2 10 nop
494 0002F4A3 # asm("nop");
495 0002F4A3 10 nop
496 0002F4A4 # asm("std r6"); /* store the result ( exp ) */
497 0002F4A4 27 56 std r6
498 0002F4A6 # if( force_loop )
499 0002F4A6 5d effffffb90 tstl _force_loop
500 0002F4AC 31 02 jeql L266
501 0002F4AE # asm("brb _pipe14_3_lp1");; /* run the loop again */
502 0002F4AE 11 ac brb _pipe14_3_lp1
503 0002F4B0 L266:
504 0002F4B0 # /*
505 0002F4B0 # * verify the results
506 0002F4B0 # */
507 0002F4B0 # asm("movl r6,_sgl_value_5"); /* get the result */
508 0002F4B0 0d 56 effffffb85 movl r6,_sgl_value_5
509 0002F4B7 # asm("movl r7,_sgl_value_6");
510 0002F4B7 0d 57 effffffb7e movl r7,_sgl_value_6
511 0002F4BE # dbl_st_acc.m = sgl_value_5;
512 0002F4BE 0d effffffb78 effffffb73 movl _sgl_value_5,_dbl_st_acc
513 0002F4C9 # dbl_st_acc.l = sgl_value_6;
514 0002F4C9 0d effffffb6d effffffb6c movl _sgl_value_6,_dbl_st_acc+4
515 0002F4D4 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
516 0002F4D4 # (dbl_st_acc.l != dbl_expected.l) )
517 0002F4D4 1d effffffb62 effffffb5d cmpl _dbl_st_acc,_dbl_expected
518 0002F4DF 21 0d jneq L9997
519 0002F4E1 1d effffffb59 effffffb54 cmpl _dbl_st_acc+4,_dbl_expected+4
520 0002F4EC 31 42 jeql L267
521 0002F4EE L9997:
522 0002F4EE # {
523 0002F4EE # errcnt++; /* bump the error count */
524 0002F4EE 6d effffffb48 incl _errcnt
525 0002F4F4 # if ( prt_error )
526 0002F4F4 5d effffffb42 tstl _prt_error
527 0002F4FA 31 0d jeql L268
528 0002F4FC # print_pipe14_er("Reg. Data, 2 NOPs");
529 0002F4FC .data 1
530 00001011 * L269:
531 00001011 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NOPs\0"
04E4F507300
532 00001023 * .text
533 0002F4FC dd 8f00001011 pushl $L269
534 0002F502 fe 08 ef000008f7 callf $8,_print_pipe14_er
535 0002F509 # if ( halt_flg ) /* halt on error? */
536 0002F509 L268:
537 0002F509 5d effffffb2d tstl _halt_flg
538 0002F50F 31 0d jeql L270
539 0002F511 # pipe14_er_hlt( subtest );
540 0002F511 dd effffffb25 pushl _subtest
541 0002F517 fe 08 ef00000a60 callf $8,_pipe14_er_hlt
542 0002F51E # if ( loop_on_err ) {
543 0002F51E L270:
544 0002F51E 5d effffffb18 tstl _loop_on_err
545 0002F524 31 0a jeql L271
546 0002F526 # force_loop = TRUE; /* set the force loop flag */
547 0002F526 0d 01 effffffb0f movl $1,_force_loop
548 0002F52D # asm("brw _pipe14_3_lp1"); /* and loop */
549 0002F52D 13 ff2c brw _pipe14_3_lp1
550 0002F530 # }
551 0002F530 # } /* end of compare error */
552 0002F530 L271:
553 0002F530 # } while( index++ < max_divd_1_index );
554 0002F530 L267:
555 0002F530 L264:
556 0002F530 0d effffffb06 50 movl _index,r0
557 0002F537 6d effffffaff incl _index
558 0002F53D 1d 50 effffffaf8 cmpl r0,_max_divd_1_index
559 0002F544 81 03 13 fe98 jlss L265
560 0002F549 L263:
561 0002F549 # } /* end of subtest 3 */
562 0002F549 40 ret#2
563 0002F54A .set L259,0x0
564 0002F54A L261:
565 0002F54A 13 fe88 jbr L262
566 0002F54D .data
567 00000fe4 * .text
568 0002F54D 00 .align 1
569 0002F54E .globl _pipe14_4
570 0002F54E _pipe14_4:
571 0002F54E 0000 .word L272
572 0002F550 #
573 0002F550 #
574 0002F550 #
575 0002F550 #
576 0002F550 #
577 0002F550 #
578 0002F550 #
579 0002F550 # /************************************************************************
580 0002F550 # *
581 0002F550 # * SUBTEST 4
582 0002F550 # * data in registers, 3 NO-OPs
583 0002F550 # *
584 0002F550 # ************************************************************************/
585 0002F550 # pipe14_4()
586 0002F550 # {
587 0002F550 13 0179 jbr L274
588 0002F553 L275:
589 0002F553 # force_loop = FALSE; /* clear the force_loop flg */
590 0002F553 4d effffffae3 clrl _force_loop
591 0002F559 # index = 0;
592 0002F559 4d effffffadd clrl _index
593 0002F55F # do
594 0002F55F L278:
595 0002F55F # {
596 0002F55F # sgl_value_1 = divd_1_data[index].op_1.m; /* get op_1's MSW */
597 0002F55F 5c 18 effffffad6 50 mull3 $24,_index,r0
598 0002F567 0d e000000000 effffffaca movl _divd_1_data(r0),_sgl_value_1
599 0002F572 # sgl_value_2 = divd_1_data[index].op_1.l; /* get op_1's LSW */
600 0002F572 5c 18 effffffac3 50 mull3 $24,_index,r0
601 0002F57A 0d e000000004 effffffab7 movl _divd_1_data+4(r0),_sgl_value_2
602 0002F585 # sgl_value_3 = divd_1_data[index].op_2.m; /* get op_2's MSW */
603 0002F585 5c 18 effffffab0 50 mull3 $24,_index,r0
604 0002F58D 0d e000000008 effffffaa4 movl _divd_1_data+8(r0),_sgl_value_3
605 0002F598 # sgl_value_4 = divd_1_data[index].op_2.l; /* get op_2's LSW */
606 0002F598 5c 18 effffffa9d 50 mull3 $24,_index,r0
607 0002F5A0 0d e00000000c effffffa91 movl _divd_1_data+12(r0),_sgl_value_4
608 0002F5AB # sgl_value_7 = 0x40800000; /* get dbl precision 1.0 */
609 0002F5AB 0d 8f40800000 effffffa86 movl $1082130432,_sgl_value_7
610 0002F5B6 # sgl_value_8 = 0;
611 0002F5B6 4d effffffa80 clrl _sgl_value_8
612 0002F5BC # dbl_expected = divd_1_data[index].exp; /* get expected results */
613 0002F5BC 5c 18 effffffa79 50 mull3 $24,_index,r0
614 0002F5C4 0c 8f00000010 50 addl2 $_divd_1_data+16,r0
615 0002F5CB 0d a004 effffffa6d movl 4(r0),_dbl_expected+4
616 0002F5D3 0d 60 effffffa62 movl (r0),_dbl_expected
617 0002F5DA # /*
618 0002F5DA # * If LOOP ON ERROR is set, this is the loop for this subtest.
619 0002F5DA # * The force loop flag is set after the first error.
620 0002F5DA # */
621 0002F5DA # asm("_pipe14_4_lp1:");
622 0002F5DA _pipe14_4_lp1:
623 0002F5DA # asm("movl _sgl_value_1,r0"); /* move operand 1 to r0/r1 */
624 0002F5DA 0d effffffa5c 50 movl _sgl_value_1,r0
625 0002F5E1 # asm("movl _sgl_value_2,r1");
626 0002F5E1 0d effffffa55 51 movl _sgl_value_2,r1
627 0002F5E8 # asm("movl _sgl_value_3,r2"); /* move operand 2 to r2/r3 */
628 0002F5E8 0d effffffa4e 52 movl _sgl_value_3,r2
629 0002F5EF # asm("movl _sgl_value_4,r3");
630 0002F5EF 0d effffffa47 53 movl _sgl_value_4,r3
631 0002F5F6 # asm("movl _sgl_value_7,r4"); /* move a '1.0' to r4/r5 */
632 0002F5F6 0d effffffa40 54 movl _sgl_value_7,r4
633 0002F5FD # asm("movl _sgl_value_8,r5");
634 0002F5FD 0d effffffa39 55 movl _sgl_value_8,r5
635 0002F604 # asm("movl _sgl_value_8,r8"); /* move a '0.0' to r8/r9 */
636 0002F604 0d effffffa32 58 movl _sgl_value_8,r8
637 0002F60B # asm("movl _sgl_value_8,r9");
638 0002F60B 0d effffffa2b 59 movl _sgl_value_8,r9
639 0002F612 # asm("ldd r8"); /* load a '0.0' ( 0 ) */
640 0002F612 07 58 ldd r8
641 0002F614 # asm("nop");
642 0002F614 10 nop
643 0002F615 # asm("nop");
644 0002F615 10 nop
645 0002F616 # asm("nop");
646 0002F616 10 nop
647 0002F617 # asm("addd r0"); /* add operand 1 ( op1 ) */
648 0002F617 c7 50 addd r0
649 0002F619 # asm("nop");
650 0002F619 10 nop
651 0002F61A # asm("nop");
652 0002F61A 10 nop
653 0002F61B # asm("nop");
654 0002F61B 10 nop
655 0002F61C # asm("divd r2"); /* div by operand 2 ( exp ) */
656 0002F61C f7 52 divd r2
657 0002F61E # asm("nop");
658 0002F61E 10 nop
659 0002F61F # asm("nop");
660 0002F61F 10 nop
661 0002F620 # asm("nop");
662 0002F620 10 nop
663 0002F621 # asm("muld r4"); /* multiply by 1.0 ( exp ) */
664 0002F621 e7 54 muld r4
665 0002F623 # asm("nop");
666 0002F623 10 nop
667 0002F624 # asm("nop");
668 0002F624 10 nop
669 0002F625 # asm("nop");
670 0002F625 10 nop
671 0002F626 # asm("std r6"); /* store the result ( exp ) */
672 0002F626 27 56 std r6
673 0002F628 # if( force_loop )
674 0002F628 5d effffffa0e tstl _force_loop
675 0002F62E 31 02 jeql L279
676 0002F630 # asm("brb _pipe14_4_lp1");; /* run the loop again */
677 0002F630 11 a8 brb _pipe14_4_lp1
678 0002F632 L279:
679 0002F632 # /*
680 0002F632 # * verify the results
681 0002F632 # */
682 0002F632 # asm("movl r6,_sgl_value_5"); /* get the result */
683 0002F632 0d 56 effffffa03 movl r6,_sgl_value_5
684 0002F639 # asm("movl r7,_sgl_value_6");
685 0002F639 0d 57 effffff9fc movl r7,_sgl_value_6
686 0002F640 # dbl_st_acc.m = sgl_value_5;
687 0002F640 0d effffff9f6 effffff9f1 movl _sgl_value_5,_dbl_st_acc
688 0002F64B # dbl_st_acc.l = sgl_value_6;
689 0002F64B 0d effffff9eb effffff9ea movl _sgl_value_6,_dbl_st_acc+4
690 0002F656 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
691 0002F656 # (dbl_st_acc.l != dbl_expected.l) )
692 0002F656 1d effffff9e0 effffff9db cmpl _dbl_st_acc,_dbl_expected
693 0002F661 21 0d jneq L9996
694 0002F663 1d effffff9d7 effffff9d2 cmpl _dbl_st_acc+4,_dbl_expected+4
695 0002F66E 31 42 jeql L280
696 0002F670 L9996:
697 0002F670 # {
698 0002F670 # errcnt++; /* bump the error count */
699 0002F670 6d effffff9c6 incl _errcnt
700 0002F676 # if ( prt_error )
701 0002F676 5d effffff9c0 tstl _prt_error
702 0002F67C 31 0d jeql L281
703 0002F67E # print_pipe14_er("Reg. Data, 3 NOPs");
704 0002F67E .data 1
705 00001023 * L282:
706 00001023 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NOPs\0"
04E4F507300
707 00001035 * .text
708 0002F67E dd 8f00001023 pushl $L282
709 0002F684 fe 08 ef00000775 callf $8,_print_pipe14_er
710 0002F68B # if ( halt_flg ) /* halt on error? */
711 0002F68B L281:
712 0002F68B 5d effffff9ab tstl _halt_flg
713 0002F691 31 0d jeql L283
714 0002F693 # pipe14_er_hlt( subtest );
715 0002F693 dd effffff9a3 pushl _subtest
716 0002F699 fe 08 ef000008de callf $8,_pipe14_er_hlt
717 0002F6A0 # if ( loop_on_err ) {
718 0002F6A0 L283:
719 0002F6A0 5d effffff996 tstl _loop_on_err
720 0002F6A6 31 0a jeql L284
721 0002F6A8 # force_loop = TRUE; /* set the force loop flag */
722 0002F6A8 0d 01 effffff98d movl $1,_force_loop
723 0002F6AF # asm("brw _pipe14_4_lp1"); /* and loop */
724 0002F6AF 13 ff28 brw _pipe14_4_lp1
725 0002F6B2 # }
726 0002F6B2 # } /* end of compare error */
727 0002F6B2 L284:
728 0002F6B2 # } while( index++ < max_divd_1_index );
729 0002F6B2 L280:
730 0002F6B2 L277:
731 0002F6B2 0d effffff984 50 movl _index,r0
732 0002F6B9 6d effffff97d incl _index
733 0002F6BF 1d 50 effffff976 cmpl r0,_max_divd_1_index
734 0002F6C6 81 03 13 fe94 jlss L278
735 0002F6CB L276:
736 0002F6CB # } /* end of subtest 4 */
737 0002F6CB 40 ret#2
738 0002F6CC .set L272,0x0
739 0002F6CC L274:
740 0002F6CC 13 fe84 jbr L275
741 0002F6CF .data
742 00000fe4 * .text
743 0002F6CF 00 .align 1
744 0002F6D0 .globl _pipe14_5
745 0002F6D0 _pipe14_5:
746 0002F6D0 0000 .word L285
747 0002F6D2 #
748 0002F6D2 #
749 0002F6D2 #
750 0002F6D2 #
751 0002F6D2 #
752 0002F6D2 #
753 0002F6D2 #
754 0002F6D2 # /************************************************************************
755 0002F6D2 # *
756 0002F6D2 # * SUBTEST 5
757 0002F6D2 # * data in cache, no NO-OPs
758 0002F6D2 # *
759 0002F6D2 # ************************************************************************/
760 0002F6D2 # pipe14_5()
761 0002F6D2 # {
762 0002F6D2 13 0121 jbr L287
763 0002F6D5 L288:
764 0002F6D5 # force_loop = FALSE; /* clear the force_loop flg */
765 0002F6D5 4d effffff961 clrl _force_loop
766 0002F6DB # index = 0;
767 0002F6DB 4d effffff95b clrl _index
768 0002F6E1 # do
769 0002F6E1 L291:
770 0002F6E1 # {
771 0002F6E1 # dbl_value_1 = divd_1_data[index].op_1; /* get dbl operand # 1 */
772 0002F6E1 5c 18 effffff954 50 mull3 $24,_index,r0
773 0002F6E9 0c 8f00000000 50 addl2 $_divd_1_data,r0
774 0002F6F0 0d a004 effffff948 movl 4(r0),_dbl_value_1+4
775 0002F6F8 0d 60 effffff93d movl (r0),_dbl_value_1
776 0002F6FF # dbl_value_2 = divd_1_data[index].op_2; /* get dbl operand # 2 */
777 0002F6FF 5c 18 effffff936 50 mull3 $24,_index,r0
778 0002F707 0c 8f00000008 50 addl2 $_divd_1_data+8,r0
779 0002F70E 0d a004 effffff92a movl 4(r0),_dbl_value_2+4
780 0002F716 0d 60 effffff91f movl (r0),_dbl_value_2
781 0002F71D # dbl_expected = divd_1_data[index].exp; /* get expected results */
782 0002F71D 5c 18 effffff918 50 mull3 $24,_index,r0
783 0002F725 0c 8f00000010 50 addl2 $_divd_1_data+16,r0
784 0002F72C 0d a004 effffff90c movl 4(r0),_dbl_expected+4
785 0002F734 0d 60 effffff901 movl (r0),_dbl_expected
786 0002F73B # dbl_dummy1.m = 0x40800000; /* get dbl precision 1.0 */
787 0002F73B 0d 8f40800000 effffff8f6 movl $1082130432,_dbl_dummy1
788 0002F746 # dbl_dummy1.l = 0;
789 0002F746 4d effffff8f4 clrl _dbl_dummy1+4
790 0002F74C # dbl_dummy2.m = 0; /* get dbl precision 0.0 */
791 0002F74C 4d effffff8ea clrl _dbl_dummy2
792 0002F752 # dbl_dummy2.l = 0;
793 0002F752 4d effffff8e8 clrl _dbl_dummy2+4
794 0002F758 # /*
795 0002F758 # * If LOOP ON ERROR is set, this is the loop for this subtest.
796 0002F758 # * The force loop flag is set after the first error.
797 0002F758 # */
798 0002F758 # asm("_pipe14_5_lp1:");
799 0002F758 _pipe14_5_lp1:
800 0002F758 # asm("ldd _dbl_dummy2"); /* load a '0.0' ( 0 ) */
801 0002F758 07 effffff8de ldd _dbl_dummy2
802 0002F75E # asm("addd _dbl_value_1"); /* add operand 1 ( op1 ) */
803 0002F75E c7 effffff8d8 addd _dbl_value_1
804 0002F764 # asm("divd _dbl_value_2"); /* div by operand 2 ( exp ) */
805 0002F764 f7 effffff8d2 divd _dbl_value_2
806 0002F76A # asm("muld _dbl_dummy1"); /* multiply by 1.0 ( exp ) */
807 0002F76A e7 effffff8cc muld _dbl_dummy1
808 0002F770 # asm("std _dbl_st_acc"); /* store the result ( exp ) */
809 0002F770 27 effffff8c6 std _dbl_st_acc
810 0002F776 # if( force_loop )
811 0002F776 5d effffff8c0 tstl _force_loop
812 0002F77C 31 02 jeql L292
813 0002F77E # asm("brb _pipe14_5_lp1");; /* run the loop again */
814 0002F77E 11 d8 brb _pipe14_5_lp1
815 0002F780 L292:
816 0002F780 # /*
817 0002F780 # * verify the results
818 0002F780 # */
819 0002F780 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
820 0002F780 # (dbl_st_acc.l != dbl_expected.l) )
821 0002F780 1d effffff8b6 effffff8b1 cmpl _dbl_st_acc,_dbl_expected
822 0002F78B 21 0d jneq L9995
823 0002F78D 1d effffff8ad effffff8a8 cmpl _dbl_st_acc+4,_dbl_expected+4
824 0002F798 31 42 jeql L293
825 0002F79A L9995:
826 0002F79A # {
827 0002F79A # errcnt++; /* bump the error count */
828 0002F79A 6d effffff89c incl _errcnt
829 0002F7A0 # if ( prt_error )
830 0002F7A0 5d effffff896 tstl _prt_error
831 0002F7A6 31 0d jeql L294
832 0002F7A8 # print_pipe14_er("Cache Data, no NOPs");
833 0002F7A8 .data 1
834 00001035 * L295:
835 00001035 * 436163686520446174612C206 .ascii "Cache Data, no NOPs\0"
E6F204E4F507300
836 00001049 * .text
837 0002F7A8 dd 8f00001035 pushl $L295
838 0002F7AE fe 08 ef0000064b callf $8,_print_pipe14_er
839 0002F7B5 # if ( halt_flg ) /* halt on error? */
840 0002F7B5 L294:
841 0002F7B5 5d effffff881 tstl _halt_flg
842 0002F7BB 31 0d jeql L296
843 0002F7BD # pipe14_er_hlt( subtest );
844 0002F7BD dd effffff879 pushl _subtest
845 0002F7C3 fe 08 ef000007b4 callf $8,_pipe14_er_hlt
846 0002F7CA # if ( loop_on_err ) {
847 0002F7CA L296:
848 0002F7CA 5d effffff86c tstl _loop_on_err
849 0002F7D0 31 0a jeql L297
850 0002F7D2 # force_loop = TRUE; /* set the force loop flag */
851 0002F7D2 0d 01 effffff863 movl $1,_force_loop
852 0002F7D9 # asm("brw _pipe14_5_lp1"); /* and loop */
853 0002F7D9 13 ff7c brw _pipe14_5_lp1
854 0002F7DC # }
855 0002F7DC # } /* end of compare error */
856 0002F7DC L297:
857 0002F7DC # } while( index++ < max_divd_1_index );
858 0002F7DC L293:
859 0002F7DC L290:
860 0002F7DC 0d effffff85a 50 movl _index,r0
861 0002F7E3 6d effffff853 incl _index
862 0002F7E9 1d 50 effffff84c cmpl r0,_max_divd_1_index
863 0002F7F0 81 03 13 feec jlss L291
864 0002F7F5 L289:
865 0002F7F5 # } /* end of subtest 5 */
866 0002F7F5 40 ret#2
867 0002F7F6 .set L285,0x0
868 0002F7F6 L287:
869 0002F7F6 13 fedc jbr L288
870 0002F7F9 .data
871 00000fe4 * .text
872 0002F7F9 00 .align 1
873 0002F7FA .globl _pipe14_6
874 0002F7FA _pipe14_6:
875 0002F7FA 0000 .word L298
876 0002F7FC #
877 0002F7FC #
878 0002F7FC #
879 0002F7FC #
880 0002F7FC #
881 0002F7FC #
882 0002F7FC #
883 0002F7FC # /************************************************************************
884 0002F7FC # *
885 0002F7FC # * SUBTEST 6
886 0002F7FC # * data in cache, 1 NO-OP
887 0002F7FC # *
888 0002F7FC # ************************************************************************/
889 0002F7FC # pipe14_6()
890 0002F7FC # {
891 0002F7FC 13 0125 jbr L300
892 0002F7FF L301:
893 0002F7FF # force_loop = FALSE; /* clear the force_loop flg */
894 0002F7FF 4d effffff837 clrl _force_loop
895 0002F805 # index = 0;
896 0002F805 4d effffff831 clrl _index
897 0002F80B # do
898 0002F80B L304:
899 0002F80B # {
900 0002F80B # dbl_value_1 = divd_1_data[index].op_1; /* get dbl operand # 1 */
901 0002F80B 5c 18 effffff82a 50 mull3 $24,_index,r0
902 0002F813 0c 8f00000000 50 addl2 $_divd_1_data,r0
903 0002F81A 0d a004 effffff81e movl 4(r0),_dbl_value_1+4
904 0002F822 0d 60 effffff813 movl (r0),_dbl_value_1
905 0002F829 # dbl_value_2 = divd_1_data[index].op_2; /* get dbl operand # 2 */
906 0002F829 5c 18 effffff80c 50 mull3 $24,_index,r0
907 0002F831 0c 8f00000008 50 addl2 $_divd_1_data+8,r0
908 0002F838 0d a004 effffff800 movl 4(r0),_dbl_value_2+4
909 0002F840 0d 60 effffff7f5 movl (r0),_dbl_value_2
910 0002F847 # dbl_expected = divd_1_data[index].exp; /* get expected results */
911 0002F847 5c 18 effffff7ee 50 mull3 $24,_index,r0
912 0002F84F 0c 8f00000010 50 addl2 $_divd_1_data+16,r0
913 0002F856 0d a004 effffff7e2 movl 4(r0),_dbl_expected+4
914 0002F85E 0d 60 effffff7d7 movl (r0),_dbl_expected
915 0002F865 # dbl_dummy1.m = 0x40800000; /* get dbl precision 1.0 */
916 0002F865 0d 8f40800000 effffff7cc movl $1082130432,_dbl_dummy1
917 0002F870 # dbl_dummy1.l = 0;
918 0002F870 4d effffff7ca clrl _dbl_dummy1+4
919 0002F876 # dbl_dummy2.m = 0; /* get dbl precision 0.0 */
920 0002F876 4d effffff7c0 clrl _dbl_dummy2
921 0002F87C # dbl_dummy2.l = 0;
922 0002F87C 4d effffff7be clrl _dbl_dummy2+4
923 0002F882 # /*
924 0002F882 # * If LOOP ON ERROR is set, this is the loop for this subtest.
925 0002F882 # * The force loop flag is set after the first error.
926 0002F882 # */
927 0002F882 # asm("_pipe14_6_lp1:");
928 0002F882 _pipe14_6_lp1:
929 0002F882 # asm("ldd _dbl_dummy2"); /* load a '0.0' ( 0 ) */
930 0002F882 07 effffff7b4 ldd _dbl_dummy2
931 0002F888 # asm("nop");
932 0002F888 10 nop
933 0002F889 # asm("addd _dbl_value_1"); /* add operand 1 ( op1 ) */
934 0002F889 c7 effffff7ad addd _dbl_value_1
935 0002F88F # asm("nop");
936 0002F88F 10 nop
937 0002F890 # asm("divd _dbl_value_2"); /* div by operand 2 ( exp ) */
938 0002F890 f7 effffff7a6 divd _dbl_value_2
939 0002F896 # asm("nop");
940 0002F896 10 nop
941 0002F897 # asm("muld _dbl_dummy1"); /* multiply by 1.0 ( exp ) */
942 0002F897 e7 effffff79f muld _dbl_dummy1
943 0002F89D # asm("nop");
944 0002F89D 10 nop
945 0002F89E # asm("std _dbl_st_acc"); /* store the result ( exp ) */
946 0002F89E 27 effffff798 std _dbl_st_acc
947 0002F8A4 # if( force_loop )
948 0002F8A4 5d effffff792 tstl _force_loop
949 0002F8AA 31 02 jeql L305
950 0002F8AC # asm("brb _pipe14_6_lp1");; /* run the loop again */
951 0002F8AC 11 d4 brb _pipe14_6_lp1
952 0002F8AE L305:
953 0002F8AE # /*
954 0002F8AE # * verify the results
955 0002F8AE # */
956 0002F8AE # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
957 0002F8AE # (dbl_st_acc.l != dbl_expected.l) )
958 0002F8AE 1d effffff788 effffff783 cmpl _dbl_st_acc,_dbl_expected
959 0002F8B9 21 0d jneq L9994
960 0002F8BB 1d effffff77f effffff77a cmpl _dbl_st_acc+4,_dbl_expected+4
961 0002F8C6 31 42 jeql L306
962 0002F8C8 L9994:
963 0002F8C8 # {
964 0002F8C8 # errcnt++; /* bump the error count */
965 0002F8C8 6d effffff76e incl _errcnt
966 0002F8CE # if ( prt_error )
967 0002F8CE 5d effffff768 tstl _prt_error
968 0002F8D4 31 0d jeql L307
969 0002F8D6 # print_pipe14_er("Cache Data, 1 NOP");
970 0002F8D6 .data 1
971 00001049 * L308:
972 00001049 * 436163686520446174612C203 .ascii "Cache Data, 1 NOP\0"
1204E4F5000
973 0000105b * .text
974 0002F8D6 dd 8f00001049 pushl $L308
975 0002F8DC fe 08 ef0000051d callf $8,_print_pipe14_er
976 0002F8E3 # if ( halt_flg ) /* halt on error? */
977 0002F8E3 L307:
978 0002F8E3 5d effffff753 tstl _halt_flg
979 0002F8E9 31 0d jeql L309
980 0002F8EB # pipe14_er_hlt( subtest );
981 0002F8EB dd effffff74b pushl _subtest
982 0002F8F1 fe 08 ef00000686 callf $8,_pipe14_er_hlt
983 0002F8F8 # if ( loop_on_err ) {
984 0002F8F8 L309:
985 0002F8F8 5d effffff73e tstl _loop_on_err
986 0002F8FE 31 0a jeql L310
987 0002F900 # force_loop = TRUE; /* set the force loop flag */
988 0002F900 0d 01 effffff735 movl $1,_force_loop
989 0002F907 # asm("brw _pipe14_6_lp1"); /* and loop */
990 0002F907 13 ff78 brw _pipe14_6_lp1
991 0002F90A # }
992 0002F90A # } /* end of compare error */
993 0002F90A L310:
994 0002F90A # } while( index++ < max_divd_1_index );
995 0002F90A L306:
996 0002F90A L303:
997 0002F90A 0d effffff72c 50 movl _index,r0
998 0002F911 6d effffff725 incl _index
999 0002F917 1d 50 effffff71e cmpl r0,_max_divd_1_index
1000 0002F91E 81 03 13 fee8 jlss L304
1001 0002F923 L302:
1002 0002F923 # } /* end of subtest 6 */
1003 0002F923 40 ret#2
1004 0002F924 .set L298,0x0
1005 0002F924 L300:
1006 0002F924 13 fed8 jbr L301
1007 0002F927 .data
1008 00000fe4 * .text
1009 0002F927 00 .align 1
1010 0002F928 .globl _pipe14_7
1011 0002F928 _pipe14_7:
1012 0002F928 0000 .word L311
1013 0002F92A #
1014 0002F92A #
1015 0002F92A #
1016 0002F92A #
1017 0002F92A #
1018 0002F92A #
1019 0002F92A #
1020 0002F92A #
1021 0002F92A # /************************************************************************
1022 0002F92A # *
1023 0002F92A # * SUBTEST 7
1024 0002F92A # * data in cache, 2 NO-OPs
1025 0002F92A # *
1026 0002F92A # ************************************************************************/
1027 0002F92A # pipe14_7()
1028 0002F92A # {
1029 0002F92A 13 0129 jbr L313
1030 0002F92D L314:
1031 0002F92D # force_loop = FALSE; /* clear the force_loop flg */
1032 0002F92D 4d effffff709 clrl _force_loop
1033 0002F933 # index = 0;
1034 0002F933 4d effffff703 clrl _index
1035 0002F939 # do
1036 0002F939 L317:
1037 0002F939 # {
1038 0002F939 # dbl_value_1 = divd_1_data[index].op_1; /* get dbl operand # 1 */
1039 0002F939 5c 18 effffff6fc 50 mull3 $24,_index,r0
1040 0002F941 0c 8f00000000 50 addl2 $_divd_1_data,r0
1041 0002F948 0d a004 effffff6f0 movl 4(r0),_dbl_value_1+4
1042 0002F950 0d 60 effffff6e5 movl (r0),_dbl_value_1
1043 0002F957 # dbl_value_2 = divd_1_data[index].op_2; /* get dbl operand # 2 */
1044 0002F957 5c 18 effffff6de 50 mull3 $24,_index,r0
1045 0002F95F 0c 8f00000008 50 addl2 $_divd_1_data+8,r0
1046 0002F966 0d a004 effffff6d2 movl 4(r0),_dbl_value_2+4
1047 0002F96E 0d 60 effffff6c7 movl (r0),_dbl_value_2
1048 0002F975 # dbl_expected = divd_1_data[index].exp; /* get expected results */
1049 0002F975 5c 18 effffff6c0 50 mull3 $24,_index,r0
1050 0002F97D 0c 8f00000010 50 addl2 $_divd_1_data+16,r0
1051 0002F984 0d a004 effffff6b4 movl 4(r0),_dbl_expected+4
1052 0002F98C 0d 60 effffff6a9 movl (r0),_dbl_expected
1053 0002F993 # dbl_dummy1.m = 0x40800000; /* get dbl precision 1.0 */
1054 0002F993 0d 8f40800000 effffff69e movl $1082130432,_dbl_dummy1
1055 0002F99E # dbl_dummy1.l = 0;
1056 0002F99E 4d effffff69c clrl _dbl_dummy1+4
1057 0002F9A4 # dbl_dummy2.m = 0; /* get dbl precision 0.0 */
1058 0002F9A4 4d effffff692 clrl _dbl_dummy2
1059 0002F9AA # dbl_dummy2.l = 0;
1060 0002F9AA 4d effffff690 clrl _dbl_dummy2+4
1061 0002F9B0 # /*
1062 0002F9B0 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1063 0002F9B0 # * The force loop flag is set after the first error.
1064 0002F9B0 # */
1065 0002F9B0 # asm("_pipe14_7_lp1:");
1066 0002F9B0 _pipe14_7_lp1:
1067 0002F9B0 # asm("ldd _dbl_dummy2"); /* load a '0.0' ( 0 ) */
1068 0002F9B0 07 effffff686 ldd _dbl_dummy2
1069 0002F9B6 # asm("nop");
1070 0002F9B6 10 nop
1071 0002F9B7 # asm("nop");
1072 0002F9B7 10 nop
1073 0002F9B8 # asm("addd _dbl_value_1"); /* add operand 1 ( op1 ) */
1074 0002F9B8 c7 effffff67e addd _dbl_value_1
1075 0002F9BE # asm("nop");
1076 0002F9BE 10 nop
1077 0002F9BF # asm("nop");
1078 0002F9BF 10 nop
1079 0002F9C0 # asm("divd _dbl_value_2"); /* div by operand 2 ( exp ) */
1080 0002F9C0 f7 effffff676 divd _dbl_value_2
1081 0002F9C6 # asm("nop");
1082 0002F9C6 10 nop
1083 0002F9C7 # asm("nop");
1084 0002F9C7 10 nop
1085 0002F9C8 # asm("muld _dbl_dummy1"); /* multiply by 1.0 ( exp ) */
1086 0002F9C8 e7 effffff66e muld _dbl_dummy1
1087 0002F9CE # asm("nop");
1088 0002F9CE 10 nop
1089 0002F9CF # asm("nop");
1090 0002F9CF 10 nop
1091 0002F9D0 # asm("std _dbl_st_acc"); /* store the result ( exp ) */
1092 0002F9D0 27 effffff666 std _dbl_st_acc
1093 0002F9D6 # if( force_loop )
1094 0002F9D6 5d effffff660 tstl _force_loop
1095 0002F9DC 31 02 jeql L318
1096 0002F9DE # asm("brb _pipe14_7_lp1");; /* run the loop again */
1097 0002F9DE 11 d0 brb _pipe14_7_lp1
1098 0002F9E0 L318:
1099 0002F9E0 # /*
1100 0002F9E0 # * verify the results
1101 0002F9E0 # */
1102 0002F9E0 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1103 0002F9E0 # (dbl_st_acc.l != dbl_expected.l) )
1104 0002F9E0 1d effffff656 effffff651 cmpl _dbl_st_acc,_dbl_expected
1105 0002F9EB 21 0d jneq L9993
1106 0002F9ED 1d effffff64d effffff648 cmpl _dbl_st_acc+4,_dbl_expected+4
1107 0002F9F8 31 42 jeql L319
1108 0002F9FA L9993:
1109 0002F9FA # {
1110 0002F9FA # errcnt++; /* bump the error count */
1111 0002F9FA 6d effffff63c incl _errcnt
1112 0002FA00 # if ( prt_error )
1113 0002FA00 5d effffff636 tstl _prt_error
1114 0002FA06 31 0d jeql L320
1115 0002FA08 # print_pipe14_er("Cache Data, 2 NOPs");
1116 0002FA08 .data 1
1117 0000105b * L321:
1118 0000105b * 436163686520446174612C203 .ascii "Cache Data, 2 NOPs\0"
2204E4F507300
1119 0000106e * .text
1120 0002FA08 dd 8f0000105b pushl $L321
1121 0002FA0E fe 08 ef000003eb callf $8,_print_pipe14_er
1122 0002FA15 # if ( halt_flg ) /* halt on error? */
1123 0002FA15 L320:
1124 0002FA15 5d effffff621 tstl _halt_flg
1125 0002FA1B 31 0d jeql L322
1126 0002FA1D # pipe14_er_hlt( subtest );
1127 0002FA1D dd effffff619 pushl _subtest
1128 0002FA23 fe 08 ef00000554 callf $8,_pipe14_er_hlt
1129 0002FA2A # if ( loop_on_err ) {
1130 0002FA2A L322:
1131 0002FA2A 5d effffff60c tstl _loop_on_err
1132 0002FA30 31 0a jeql L323
1133 0002FA32 # force_loop = TRUE; /* set the force loop flag */
1134 0002FA32 0d 01 effffff603 movl $1,_force_loop
1135 0002FA39 # asm("brw _pipe14_7_lp1"); /* and loop */
1136 0002FA39 13 ff74 brw _pipe14_7_lp1
1137 0002FA3C # }
1138 0002FA3C # } /* end of compare error */
1139 0002FA3C L323:
1140 0002FA3C # } while( index++ < max_divd_1_index );
1141 0002FA3C L319:
1142 0002FA3C L316:
1143 0002FA3C 0d effffff5fa 50 movl _index,r0
1144 0002FA43 6d effffff5f3 incl _index
1145 0002FA49 1d 50 effffff5ec cmpl r0,_max_divd_1_index
1146 0002FA50 81 03 13 fee4 jlss L317
1147 0002FA55 L315:
1148 0002FA55 # } /* end of subtest 7 */
1149 0002FA55 40 ret#2
1150 0002FA56 .set L311,0x0
1151 0002FA56 L313:
1152 0002FA56 13 fed4 jbr L314
1153 0002FA59 .data
1154 00000fe4 * .text
1155 0002FA59 00 .align 1
1156 0002FA5A .globl _pipe14_8
1157 0002FA5A _pipe14_8:
1158 0002FA5A 0000 .word L324
1159 0002FA5C #
1160 0002FA5C #
1161 0002FA5C #
1162 0002FA5C #
1163 0002FA5C #
1164 0002FA5C #
1165 0002FA5C # /************************************************************************
1166 0002FA5C # *
1167 0002FA5C # * SUBTEST 8
1168 0002FA5C # * data in cache, 3 NO-OPs
1169 0002FA5C # *
1170 0002FA5C # ************************************************************************/
1171 0002FA5C # pipe14_8()
1172 0002FA5C # {
1173 0002FA5C 13 012d jbr L326
1174 0002FA5F L327:
1175 0002FA5F # force_loop = FALSE; /* clear the force_loop flg */
1176 0002FA5F 4d effffff5d7 clrl _force_loop
1177 0002FA65 # index = 0;
1178 0002FA65 4d effffff5d1 clrl _index
1179 0002FA6B # do
1180 0002FA6B L330:
1181 0002FA6B # {
1182 0002FA6B # dbl_value_1 = divd_1_data[index].op_1; /* get dbl operand # 1 */
1183 0002FA6B 5c 18 effffff5ca 50 mull3 $24,_index,r0
1184 0002FA73 0c 8f00000000 50 addl2 $_divd_1_data,r0
1185 0002FA7A 0d a004 effffff5be movl 4(r0),_dbl_value_1+4
1186 0002FA82 0d 60 effffff5b3 movl (r0),_dbl_value_1
1187 0002FA89 # dbl_value_2 = divd_1_data[index].op_2; /* get dbl operand # 2 */
1188 0002FA89 5c 18 effffff5ac 50 mull3 $24,_index,r0
1189 0002FA91 0c 8f00000008 50 addl2 $_divd_1_data+8,r0
1190 0002FA98 0d a004 effffff5a0 movl 4(r0),_dbl_value_2+4
1191 0002FAA0 0d 60 effffff595 movl (r0),_dbl_value_2
1192 0002FAA7 # dbl_expected = divd_1_data[index].exp; /* get expected results */
1193 0002FAA7 5c 18 effffff58e 50 mull3 $24,_index,r0
1194 0002FAAF 0c 8f00000010 50 addl2 $_divd_1_data+16,r0
1195 0002FAB6 0d a004 effffff582 movl 4(r0),_dbl_expected+4
1196 0002FABE 0d 60 effffff577 movl (r0),_dbl_expected
1197 0002FAC5 # dbl_dummy1.m = 0x40800000; /* get dbl precision 1.0 */
1198 0002FAC5 0d 8f40800000 effffff56c movl $1082130432,_dbl_dummy1
1199 0002FAD0 # dbl_dummy1.l = 0;
1200 0002FAD0 4d effffff56a clrl _dbl_dummy1+4
1201 0002FAD6 # dbl_dummy2.m = 0; /* get dbl precision 0.0 */
1202 0002FAD6 4d effffff560 clrl _dbl_dummy2
1203 0002FADC # dbl_dummy2.l = 0;
1204 0002FADC 4d effffff55e clrl _dbl_dummy2+4
1205 0002FAE2 # /*
1206 0002FAE2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1207 0002FAE2 # * The force loop flag is set after the first error.
1208 0002FAE2 # */
1209 0002FAE2 # asm("_pipe14_8_lp1:");
1210 0002FAE2 _pipe14_8_lp1:
1211 0002FAE2 # asm("ldd _dbl_dummy2"); /* load a '0.0' ( 0 ) */
1212 0002FAE2 07 effffff554 ldd _dbl_dummy2
1213 0002FAE8 # asm("nop");
1214 0002FAE8 10 nop
1215 0002FAE9 # asm("nop");
1216 0002FAE9 10 nop
1217 0002FAEA # asm("nop");
1218 0002FAEA 10 nop
1219 0002FAEB # asm("addd _dbl_value_1"); /* add operand 1 ( op1 ) */
1220 0002FAEB c7 effffff54b addd _dbl_value_1
1221 0002FAF1 # asm("nop");
1222 0002FAF1 10 nop
1223 0002FAF2 # asm("nop");
1224 0002FAF2 10 nop
1225 0002FAF3 # asm("nop");
1226 0002FAF3 10 nop
1227 0002FAF4 # asm("divd _dbl_value_2"); /* div by operand 2 ( exp ) */
1228 0002FAF4 f7 effffff542 divd _dbl_value_2
1229 0002FAFA # asm("nop");
1230 0002FAFA 10 nop
1231 0002FAFB # asm("nop");
1232 0002FAFB 10 nop
1233 0002FAFC # asm("nop");
1234 0002FAFC 10 nop
1235 0002FAFD # asm("muld _dbl_dummy1"); /* multiply by 1.0 ( exp ) */
1236 0002FAFD e7 effffff539 muld _dbl_dummy1
1237 0002FB03 # asm("nop");
1238 0002FB03 10 nop
1239 0002FB04 # asm("nop");
1240 0002FB04 10 nop
1241 0002FB05 # asm("nop");
1242 0002FB05 10 nop
1243 0002FB06 # asm("std _dbl_st_acc"); /* store the result ( exp ) */
1244 0002FB06 27 effffff530 std _dbl_st_acc
1245 0002FB0C # if( force_loop )
1246 0002FB0C 5d effffff52a tstl _force_loop
1247 0002FB12 31 02 jeql L331
1248 0002FB14 # asm("brb _pipe14_8_lp1");; /* run the loop again */
1249 0002FB14 11 cc brb _pipe14_8_lp1
1250 0002FB16 L331:
1251 0002FB16 # /*
1252 0002FB16 # * verify the results
1253 0002FB16 # */
1254 0002FB16 # if( (dbl_st_acc.m != dbl_expected.m) || /* compare the results */
1255 0002FB16 # (dbl_st_acc.l != dbl_expected.l) )
1256 0002FB16 1d effffff520 effffff51b cmpl _dbl_st_acc,_dbl_expected
1257 0002FB21 21 0d jneq L9992
1258 0002FB23 1d effffff517 effffff512 cmpl _dbl_st_acc+4,_dbl_expected+4
1259 0002FB2E 31 42 jeql L332
1260 0002FB30 L9992:
1261 0002FB30 # {
1262 0002FB30 # errcnt++; /* bump the error count */
1263 0002FB30 6d effffff506 incl _errcnt
1264 0002FB36 # if ( prt_error )
1265 0002FB36 5d effffff500 tstl _prt_error
1266 0002FB3C 31 0d jeql L333
1267 0002FB3E # print_pipe14_er("Cache Data, 3 NOPs");
1268 0002FB3E .data 1
1269 0000106e * L334:
1270 0000106e * 436163686520446174612C203 .ascii "Cache Data, 3 NOPs\0"
3204E4F507300
1271 00001081 * .text
1272 0002FB3E dd 8f0000106e pushl $L334
1273 0002FB44 fe 08 ef000002b5 callf $8,_print_pipe14_er
1274 0002FB4B # if ( halt_flg ) /* halt on error? */
1275 0002FB4B L333:
1276 0002FB4B 5d effffff4eb tstl _halt_flg
1277 0002FB51 31 0d jeql L335
1278 0002FB53 # pipe14_er_hlt( subtest );
1279 0002FB53 dd effffff4e3 pushl _subtest
1280 0002FB59 fe 08 ef0000041e callf $8,_pipe14_er_hlt
1281 0002FB60 # if ( loop_on_err ) {
1282 0002FB60 L335:
1283 0002FB60 5d effffff4d6 tstl _loop_on_err
1284 0002FB66 31 0a jeql L336
1285 0002FB68 # force_loop = TRUE; /* set the force loop flag */
1286 0002FB68 0d 01 effffff4cd movl $1,_force_loop
1287 0002FB6F # asm("brw _pipe14_8_lp1"); /* and loop */
1288 0002FB6F 13 ff70 brw _pipe14_8_lp1
1289 0002FB72 # }
1290 0002FB72 # } /* end of compare error */
1291 0002FB72 L336:
1292 0002FB72 # } while( index++ < max_divd_1_index );
1293 0002FB72 L332:
1294 0002FB72 L329:
1295 0002FB72 0d effffff4c4 50 movl _index,r0
1296 0002FB79 6d effffff4bd incl _index
1297 0002FB7F 1d 50 effffff4b6 cmpl r0,_max_divd_1_index
1298 0002FB86 81 03 13 fee0 jlss L330
1299 0002FB8B L328:
1300 0002FB8B # } /* end of subtest 8 */
1301 0002FB8B 40 ret#2
1302 0002FB8C .set L324,0x0
1303 0002FB8C L326:
1304 0002FB8C 13 fed0 jbr L327
1305 0002FB8F .data
1306 00000fe4 * .text
1307 0002FB8F 00 .align 1
1308 0002FB90 .globl _pipe14_9
1309 0002FB90 _pipe14_9:
1310 0002FB90 0000 .word L337
1311 0002FB92 #
1312 0002FB92 #
1313 0002FB92 #
1314 0002FB92 #
1315 0002FB92 #
1316 0002FB92 #
1317 0002FB92 #
1318 0002FB92 #
1319 0002FB92 #
1320 0002FB92 # /******************************************************************************
1321 0002FB92 # *
1322 0002FB92 # * SUBTEST 9
1323 0002FB92 # *
1324 0002FB92 # * Get the data via the FRAME POINTER ( quad word indexed )
1325 0002FB92 # *
1326 0002FB92 # * ADDRESSES OF DATA OPERANDS INDEX DATA
1327 0002FB92 # * pointer_data,-4 ( FP+40 ) 5 the STF result goes here
1328 0002FB92 # * pointer_data-8,-12 ( FP+32 ) 4 <operand #1 data>
1329 0002FB92 # * pointer_data-16,-20 ( FP+24 ) 3 <operand #2 data>
1330 0002FB92 # * pointer_data-24,-28 ( FP+16 ) 2 < '1.0' data>
1331 0002FB92 # * pointer_data-32,-36 ( FP+8 ) 1 < '0.0' data>
1332 0002FB92 # * pointer_data-40,-44 ( FP ) 0 point the frame pointer here
1333 0002FB92 # *
1334 0002FB92 # * NOTE: The double precision instructions are using Quad Word indexing.
1335 0002FB92 # ******************************************************************************/
1336 0002FB92 # pipe14_9()
1337 0002FB92 # {
1338 0002FB92 13 0267 jbr L339
1339 0002FB95 L340:
1340 0002FB95 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1341 0002FB95 ed 6d effffff4a0 moval (r13),_pre_event_fp
1342 0002FB9C # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1343 0002FB9C ed 6e effffff499 moval (r14),_pre_event_sp
1344 0002FBA3 # force_loop = FALSE; /* clear force_loop flag */
1345 0002FBA3 4d effffff493 clrl _force_loop
1346 0002FBA9 # index = 0;
1347 0002FBA9 4d effffff48d clrl _index
1348 0002FBAF # do
1349 0002FBAF L343:
1350 0002FBAF # {
1351 0002FBAF # sgl_value_1 = divd_1_data[index].op_1.m; /* get op. #1's MSW */
1352 0002FBAF 5c 18 effffff486 50 mull3 $24,_index,r0
1353 0002FBB7 0d e000000000 effffff47a movl _divd_1_data(r0),_sgl_value_1
1354 0002FBC2 # sgl_value_2 = divd_1_data[index].op_1.l; /* get op. #1's LSW */
1355 0002FBC2 5c 18 effffff473 50 mull3 $24,_index,r0
1356 0002FBCA 0d e000000004 effffff467 movl _divd_1_data+4(r0),_sgl_value_2
1357 0002FBD5 # sgl_value_3 = divd_1_data[index].op_2.m; /* get op. #2's MSW */
1358 0002FBD5 5c 18 effffff460 50 mull3 $24,_index,r0
1359 0002FBDD 0d e000000008 effffff454 movl _divd_1_data+8(r0),_sgl_value_3
1360 0002FBE8 # sgl_value_4 = divd_1_data[index].op_2.l; /* get op. #2's LSW */
1361 0002FBE8 5c 18 effffff44d 50 mull3 $24,_index,r0
1362 0002FBF0 0d e00000000c effffff441 movl _divd_1_data+12(r0),_sgl_value_4
1363 0002FBFB # sgl_value_7 = 0x40800000; /* get the '1.0' data */
1364 0002FBFB 0d 8f40800000 effffff436 movl $1082130432,_sgl_value_7
1365 0002FC06 # sgl_value_8 = 0;
1366 0002FC06 4d effffff430 clrl _sgl_value_8
1367 0002FC0C # dbl_expected = divd_1_data[index].exp; /* get expected results */
1368 0002FC0C 5c 18 effffff429 50 mull3 $24,_index,r0
1369 0002FC14 0c 8f00000010 50 addl2 $_divd_1_data+16,r0
1370 0002FC1B 0d a004 effffff41d movl 4(r0),_dbl_expected+4
1371 0002FC23 0d 60 effffff412 movl (r0),_dbl_expected
1372 0002FC2A # /*
1373 0002FC2A # * If LOOP ON ERROR is set, this is the loop for this subtest.
1374 0002FC2A # * The force loop flag is set after the first error.
1375 0002FC2A # */
1376 0002FC2A # asm("_pipe14_9_lp1:");
1377 0002FC2A _pipe14_9_lp1:
1378 0002FC2A # asm("moval _pointer_data,_sgl_value_9");/* get store data's addr */
1379 0002FC2A ed effffff40c effffff407 moval _pointer_data,_sgl_value_9
1380 0002FC35 # sgl_value_9 -= 8;
1381 0002FC35 2c 08 effffff400 subl2 $8,_sgl_value_9
1382 0002FC3C # asm("movl _sgl_value_2,*_sgl_value_9"); /* set operand #1's LSW */
1383 0002FC3C 0d effffff3fa fffffff3f5 movl _sgl_value_2,*_sgl_value_9
1384 0002FC47 # sgl_value_9 -= 4;
1385 0002FC47 2c 04 effffff3ee subl2 $4,_sgl_value_9
1386 0002FC4E # asm("movl _sgl_value_1,*_sgl_value_9"); /* set operand #1's MSW */
1387 0002FC4E 0d effffff3e8 fffffff3e3 movl _sgl_value_1,*_sgl_value_9
1388 0002FC59 # sgl_value_9 -= 4;
1389 0002FC59 2c 04 effffff3dc subl2 $4,_sgl_value_9
1390 0002FC60 # asm("movl _sgl_value_4,*_sgl_value_9"); /* set operand #2's LSW */
1391 0002FC60 0d effffff3d6 fffffff3d1 movl _sgl_value_4,*_sgl_value_9
1392 0002FC6B # sgl_value_9 -= 4;
1393 0002FC6B 2c 04 effffff3ca subl2 $4,_sgl_value_9
1394 0002FC72 # asm("movl _sgl_value_3,*_sgl_value_9"); /* set operand #2's MSW */
1395 0002FC72 0d effffff3c4 fffffff3bf movl _sgl_value_3,*_sgl_value_9
1396 0002FC7D # sgl_value_9 -= 4;
1397 0002FC7D 2c 04 effffff3b8 subl2 $4,_sgl_value_9
1398 0002FC84 # asm("movl _sgl_value_8,*_sgl_value_9"); /* set '1.0' data's LSW */
1399 0002FC84 0d effffff3b2 fffffff3ad movl _sgl_value_8,*_sgl_value_9
1400 0002FC8F # sgl_value_9 -= 4;
1401 0002FC8F 2c 04 effffff3a6 subl2 $4,_sgl_value_9
1402 0002FC96 # asm("movl _sgl_value_7,*_sgl_value_9"); /* set '1.0' data's MSW */
1403 0002FC96 0d effffff3a0 fffffff39b movl _sgl_value_7,*_sgl_value_9
1404 0002FCA1 # sgl_value_9 -= 4;
1405 0002FCA1 2c 04 effffff394 subl2 $4,_sgl_value_9
1406 0002FCA8 # asm("movl _sgl_value_8,*_sgl_value_9"); /* set '0.0' data's LSW */
1407 0002FCA8 0d effffff38e fffffff389 movl _sgl_value_8,*_sgl_value_9
1408 0002FCB3 # sgl_value_9 -= 4;
1409 0002FCB3 2c 04 effffff382 subl2 $4,_sgl_value_9
1410 0002FCBA # asm("movl _sgl_value_8,*_sgl_value_9"); /* set '0.0' data's MSW */
1411 0002FCBA 0d effffff37c fffffff377 movl _sgl_value_8,*_sgl_value_9
1412 0002FCC5 # sgl_value_9 -= 8; /* get FRAME PTR's value */
1413 0002FCC5 2c 08 effffff370 subl2 $8,_sgl_value_9
1414 0002FCCC # asm("movl _sgl_value_9,r13"); /* set the FRAME POINTER */
1415 0002FCCC 0d effffff36a 5d movl _sgl_value_9,r13
1416 0002FCD3 # asm("movl $1,r2"); /* r2 index = 1 quadwords */
1417 0002FCD3 0d 01 52 movl $1,r2
1418 0002FCD6 # asm("movl $2,r3"); /* r3 index = 2 quadwords */
1419 0002FCD6 0d 02 53 movl $2,r3
1420 0002FCD9 # asm("movl $3,r4"); /* r4 index = 3 quadwords */
1421 0002FCD9 0d 03 54 movl $3,r4
1422 0002FCDC # asm("movl $4,r5"); /* r5 index = 4 quadwords */
1423 0002FCDC 0d 04 55 movl $4,r5
1424 0002FCDF # asm("movl $5,r6"); /* r6 index = 5 quadwords */
1425 0002FCDF 0d 05 56 movl $5,r6
1426 0002FCE2 # asm("ldd (r13)[r2]"); /* load a '0.0' ( 0 ) */
1427 0002FCE2 07 426d ldd (r13)[r2]
1428 0002FCE5 # asm("addd (r13)[r5]"); /* add op. #1 ( op1 ) */
1429 0002FCE5 c7 456d addd (r13)[r5]
1430 0002FCE8 # asm("divd (r13)[r4]"); /* divide by op. #2 ( exp ) */
1431 0002FCE8 f7 446d divd (r13)[r4]
1432 0002FCEB # asm("muld (r13)[r3]"); /* multiply by '1.0' ( exp ) */
1433 0002FCEB e7 436d muld (r13)[r3]
1434 0002FCEE # asm("std (r13)[r6]"); /* store the result ( exp ) */
1435 0002FCEE 27 466d std (r13)[r6]
1436 0002FCF1 # if( force_loop )
1437 0002FCF1 5d effffff345 tstl _force_loop
1438 0002FCF7 31 03 jeql L344
1439 0002FCF9 # asm("brw _pipe14_9_lp1");; /* run the loop again */
1440 0002FCF9 13 ff2e brw _pipe14_9_lp1
1441 0002FCFC L344:
1442 0002FCFC # /*
1443 0002FCFC # * verify the results
1444 0002FCFC # */
1445 0002FCFC # asm("moval (r13),_sgl_value_10"); /* save the frame pointer */
1446 0002FCFC ed 6d effffff339 moval (r13),_sgl_value_10
1447 0002FD03 # asm("movl _pointer_data,_sgl_value_6"); /* save the LSW stored */
1448 0002FD03 0d effffff333 effffff32e movl _pointer_data,_sgl_value_6
1449 0002FD0E # asm("movl _pointer_data-4,_sgl_value_5"); /* and the MSW */
1450 0002FD0E 0d effffff324 effffff323 movl _pointer_data-4,_sgl_value_5
1451 0002FD19 # if( (sgl_value_5 != dbl_expected.m) || /* verify the result... */
1452 0002FD19 # (sgl_value_6 != dbl_expected.l) || /* verify the result... */
1453 0002FD19 # (sgl_value_10 != sgl_value_9) ) /* ... and the final FP */
1454 0002FD19 1d effffff31d effffff318 cmpl _sgl_value_5,_dbl_expected
1455 0002FD24 21 1d jneq L9991
1456 0002FD26 1d effffff310 effffff30f cmpl _sgl_value_6,_dbl_expected+4
1457 0002FD31 21 10 jneq L9991
1458 0002FD33 1d effffff303 effffff2fe cmpl _sgl_value_10,_sgl_value_9
1459 0002FD3E 21 03 13 0091 jeql L345
1460 0002FD43 L9991:
1461 0002FD43 # {
1462 0002FD43 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1463 0002FD43 0d effffff2f3 5d movl _pre_event_fp,r13
1464 0002FD4A # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1465 0002FD4A 0d effffff2ec 5e movl _pre_event_sp,r14
1466 0002FD51 # errcnt++; /* bump the error count */
1467 0002FD51 6d effffff2e5 incl _errcnt
1468 0002FD57 # if ( prt_error ) {
1469 0002FD57 5d effffff2df tstl _prt_error
1470 0002FD5D 31 4e jeql L346
1471 0002FD5F # print_pipe14_er("indexed FP addressing.\n");
1472 0002FD5F .data 1
1473 00001081 * L347:
1474 00001081 * 696E646578656420465020616 .ascii "indexed FP addressing.\12\0"
46472657373696E672E0A00
1475 00001099 * .text
1476 0002FD5F dd 8f00001081 pushl $L347
1477 0002FD65 fe 08 ef00000094 callf $8,_print_pipe14_er
1478 0002FD6C # writes("final Frame Pointer = ");
1479 0002FD6C .data 1
1480 00001099 * L348:
1481 00001099 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
06F696E746572203D2000
1482 000010b0 * .text
1483 0002FD6C dd 8f00001099 pushl $L348
1484 0002FD72 fe 08 effffff2c3 callf $8,_writes
1485 0002FD79 # write32h( sgl_value_10 );
1486 0002FD79 dd effffff2bd pushl _sgl_value_10
1487 0002FD7F fe 08 effffff2b6 callf $8,_write32h
1488 0002FD86 # writes(", expected FP = ");
1489 0002FD86 .data 1
1490 000010b0 * L350:
1491 000010b0 * 2C20206578706563746564204 .ascii ", expected FP = \0"
650203D2000
1492 000010c2 * .text
1493 0002FD86 dd 8f000010b0 pushl $L350
1494 0002FD8C fe 08 effffff2a9 callf $8,_writes
1495 0002FD93 # write32h( sgl_value_9 );
1496 0002FD93 dd effffff2a3 pushl _sgl_value_9
1497 0002FD99 fe 08 effffff29c callf $8,_write32h
1498 0002FDA0 # writes(" \n");
1499 0002FDA0 .data 1
1500 000010c2 * L351:
1501 000010c2 * 200A00 .ascii " \12\0"
1502 000010c5 * .text
1503 0002FDA0 dd 8f000010c2 pushl $L351
1504 0002FDA6 fe 08 effffff28f callf $8,_writes
1505 0002FDAD # }
1506 0002FDAD # if ( halt_flg )
1507 0002FDAD L346:
1508 0002FDAD 5d effffff289 tstl _halt_flg
1509 0002FDB3 31 0d jeql L352
1510 0002FDB5 # pipe14_er_hlt( subtest );
1511 0002FDB5 dd effffff281 pushl _subtest
1512 0002FDBB fe 08 ef000001bc callf $8,_pipe14_er_hlt
1513 0002FDC2 # if ( loop_on_err ) {
1514 0002FDC2 L352:
1515 0002FDC2 5d effffff274 tstl _loop_on_err
1516 0002FDC8 31 0a jeql L353
1517 0002FDCA # force_loop = TRUE; /* set the force loop flag */
1518 0002FDCA 0d 01 effffff26b movl $1,_force_loop
1519 0002FDD1 # asm("brw _pipe14_9_lp1"); /* and loop */
1520 0002FDD1 13 fe56 brw _pipe14_9_lp1
1521 0002FDD4 # }
1522 0002FDD4 # } /* end of compare error */
1523 0002FDD4 L353:
1524 0002FDD4 # } while( index++ < max_divd_1_index );
1525 0002FDD4 L345:
1526 0002FDD4 L342:
1527 0002FDD4 0d effffff262 50 movl _index,r0
1528 0002FDDB 6d effffff25b incl _index
1529 0002FDE1 1d 50 effffff254 cmpl r0,_max_divd_1_index
1530 0002FDE8 81 03 13 fdc2 jlss L343
1531 0002FDED L341:
1532 0002FDED # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1533 0002FDED 0d effffff249 5d movl _pre_event_fp,r13
1534 0002FDF4 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1535 0002FDF4 0d effffff242 5e movl _pre_event_sp,r14
1536 0002FDFB # } /* end of subtest 9 */
1537 0002FDFB 40 ret#2
1538 0002FDFC .set L337,0x0
1539 0002FDFC L339:
1540 0002FDFC 13 fd96 jbr L340
1541 0002FDFF .data
1542 00000fe4 * .text
1543 0002FDFF 00 .align 1
1544 0002FE00 .globl _print_pipe14_er
1545 0002FE00 _print_pipe14_er:
1546 0002FE00 0000 .word L354
1547 0002FE02 #
1548 0002FE02 #
1549 0002FE02 # /******************************************************************************
1550 0002FE02 # *
1551 0002FE02 # * ERROR ROUTINE
1552 0002FE02 # *
1553 0002FE02 # * print an error in the following form
1554 0002FE02 # *
1555 0002FE02 # *operand 1 = xxxxxxxx xxxxxxxx, final Acc = xxxxxxxx xxxxxxxx, index = dd
1556 0002FE02 # *operand 2 = xxxxxxxx xxxxxxxx, expected Acc = xxxxxxxx xxxxxxxx
1557 0002FE02 # *
1558 0002FE02 # ******************************************************************************/
1559 0002FE02 # print_pipe14_er(msg)
1560 0002FE02 # char *msg;
1561 0002FE02 # {
1562 0002FE02 13 0175 jbr L356
1563 0002FE05 L357:
1564 0002FE05 # writes(" \n"); /* start a new print line */
1565 0002FE05 .data 1
1566 000010c5 * L358:
1567 000010c5 * 200A00 .ascii " \12\0"
1568 000010c8 * .text
1569 0002FE05 dd 8f000010c5 pushl $L358
1570 0002FE0B fe 08 effffff22a callf $8,_writes
1571 0002FE12 # writes("cycle: ");
1572 0002FE12 .data 1
1573 000010c8 * L359:
1574 000010c8 * 6379636C653A2000 .ascii "cycle: \0"
1575 000010d0 * .text
1576 0002FE12 dd 8f000010c8 pushl $L359
1577 0002FE18 fe 08 effffff21d callf $8,_writes
1578 0002FE1F # writed( cycle );
1579 0002FE1F dd effffff217 pushl _cycle
1580 0002FE25 fe 08 effffff210 callf $8,_writed
1581 0002FE2C # writes(" test ");
1582 0002FE2C .data 1
1583 000010d0 * L361:
1584 000010d0 * 20746573742000 .ascii " test \0"
1585 000010d7 * .text
1586 0002FE2C dd 8f000010d0 pushl $L361
1587 0002FE32 fe 08 effffff203 callf $8,_writes
1588 0002FE39 # writed( test_no );
1589 0002FE39 dd effffff1fd pushl _test_no
1590 0002FE3F fe 08 effffff1f6 callf $8,_writed
1591 0002FE46 # writes(" (Pipe 14), subtest ");
1592 0002FE46 .data 1
1593 000010d7 * L362:
1594 000010d7 * 20202850697065203134292C2 .ascii " (Pipe 14), subtest \0"
0737562746573742000
1595 000010ed * .text
1596 0002FE46 dd 8f000010d7 pushl $L362
1597 0002FE4C fe 08 effffff1e9 callf $8,_writes
1598 0002FE53 # writed( subtest );
1599 0002FE53 dd effffff1e3 pushl _subtest
1600 0002FE59 fe 08 effffff1dc callf $8,_writed
1601 0002FE60 # writes(" error - ");
1602 0002FE60 .data 1
1603 000010ed * L363:
1604 000010ed * 206572726F72202D2000 .ascii " error - \0"
1605 000010f7 * .text
1606 0002FE60 dd 8f000010ed pushl $L363
1607 0002FE66 fe 08 effffff1cf callf $8,_writes
1608 0002FE6D # writes( msg );
1609 0002FE6D dd ad04 pushl 4(fp)
1610 0002FE70 fe 08 effffff1c5 callf $8,_writes
1611 0002FE77 # writec('\n');
1612 0002FE77 dd 0a pushl $10
1613 0002FE79 fe 08 effffff1bc callf $8,_writec
1614 0002FE80 # writes(" LDD(0.0) ADDD(op1) DIVD(op2) MULD(1.0) STD\n");
1615 0002FE80 .data 1
1616 000010f7 * L365:
1617 000010f7 * 204C444428302E30292020414 .ascii " LDD(0.0) ADDD(op1) DIVD(op2) MULD(1.0) STD\12\0"
44444286F7031292020444956
44286F70322920204D554C442
8312E302920205354440A00
1618 00001128 * .text
1619 0002FE80 dd 8f000010f7 pushl $L365
1620 0002FE86 fe 08 effffff1af callf $8,_writes
1621 0002FE8D # writes("operand 1 = ");
1622 0002FE8D .data 1
1623 00001128 * L366:
1624 00001128 * 6F706572616E642031203D200 .ascii "operand 1 = \0"
0
1625 00001135 * .text
1626 0002FE8D dd 8f00001128 pushl $L366
1627 0002FE93 fe 08 effffff1a2 callf $8,_writes
1628 0002FE9A # write32h( sgl_value_1 );
1629 0002FE9A dd effffff19c pushl _sgl_value_1
1630 0002FEA0 fe 08 effffff195 callf $8,_write32h
1631 0002FEA7 # writec(' ');
1632 0002FEA7 dd 20 pushl $32
1633 0002FEA9 fe 08 effffff18c callf $8,_writec
1634 0002FEB0 # write32h( sgl_value_2 );
1635 0002FEB0 dd effffff186 pushl _sgl_value_2
1636 0002FEB6 fe 08 effffff17f callf $8,_write32h
1637 0002FEBD # writes(", final Acc = ");
1638 0002FEBD .data 1
1639 00001135 * L367:
1640 00001135 * 2C2020202066696E616C20416 .ascii ", final Acc = \0"
363203D2000
1641 00001147 * .text
1642 0002FEBD dd 8f00001135 pushl $L367
1643 0002FEC3 fe 08 effffff172 callf $8,_writes
1644 0002FECA # write32h( dbl_st_acc.m );
1645 0002FECA dd effffff16c pushl _dbl_st_acc
1646 0002FED0 fe 08 effffff165 callf $8,_write32h
1647 0002FED7 # writec(' ');
1648 0002FED7 dd 20 pushl $32
1649 0002FED9 fe 08 effffff15c callf $8,_writec
1650 0002FEE0 # write32h( dbl_st_acc.l );
1651 0002FEE0 dd effffff15a pushl _dbl_st_acc+4
1652 0002FEE6 fe 08 effffff14f callf $8,_write32h
1653 0002FEED # writes(", index = ");
1654 0002FEED .data 1
1655 00001147 * L368:
1656 00001147 * 2C202020696E646578203D200 .ascii ", index = \0"
0
1657 00001154 * .text
1658 0002FEED dd 8f00001147 pushl $L368
1659 0002FEF3 fe 08 effffff142 callf $8,_writes
1660 0002FEFA # writed( index );
1661 0002FEFA dd effffff13c pushl _index
1662 0002FF00 fe 08 effffff135 callf $8,_writed
1663 0002FF07 # writec('\n');
1664 0002FF07 dd 0a pushl $10
1665 0002FF09 fe 08 effffff12c callf $8,_writec
1666 0002FF10 # writes("operand 2 = ");
1667 0002FF10 .data 1
1668 00001154 * L369:
1669 00001154 * 6F706572616E642032203D200 .ascii "operand 2 = \0"
0
1670 00001161 * .text
1671 0002FF10 dd 8f00001154 pushl $L369
1672 0002FF16 fe 08 effffff11f callf $8,_writes
1673 0002FF1D # write32h( sgl_value_3 );
1674 0002FF1D dd effffff119 pushl _sgl_value_3
1675 0002FF23 fe 08 effffff112 callf $8,_write32h
1676 0002FF2A # writec(' ');
1677 0002FF2A dd 20 pushl $32
1678 0002FF2C fe 08 effffff109 callf $8,_writec
1679 0002FF33 # write32h( sgl_value_4 );
1680 0002FF33 dd effffff103 pushl _sgl_value_4
1681 0002FF39 fe 08 effffff0fc callf $8,_write32h
1682 0002FF40 # writes(", expected Acc = ");
1683 0002FF40 .data 1
1684 00001161 * L370:
1685 00001161 * 2C20657870656374656420416 .ascii ", expected Acc = \0"
363203D2000
1686 00001173 * .text
1687 0002FF40 dd 8f00001161 pushl $L370
1688 0002FF46 fe 08 effffff0ef callf $8,_writes
1689 0002FF4D # write32h( dbl_expected.m );
1690 0002FF4D dd effffff0e9 pushl _dbl_expected
1691 0002FF53 fe 08 effffff0e2 callf $8,_write32h
1692 0002FF5A # writec(' ');
1693 0002FF5A dd 20 pushl $32
1694 0002FF5C fe 08 effffff0d9 callf $8,_writec
1695 0002FF63 # write32h( dbl_expected.l );
1696 0002FF63 dd effffff0d7 pushl _dbl_expected+4
1697 0002FF69 fe 08 effffff0cc callf $8,_write32h
1698 0002FF70 # writec('\n');
1699 0002FF70 dd 0a pushl $10
1700 0002FF72 fe 08 effffff0c3 callf $8,_writec
1701 0002FF79 # }
1702 0002FF79 40 ret#2
1703 0002FF7A .set L354,0x0
1704 0002FF7A L356:
1705 0002FF7A 13 fe88 jbr L357
1706 0002FF7D .data
1707 00000fe4 * .text
1708 0002FF7D 00 .align 1
1709 0002FF7E .globl _pipe14_er_hlt
1710 0002FF7E _pipe14_er_hlt:
1711 0002FF7E 0000 .word L371
1712 0002FF80 #
1713 0002FF80 #
1714 0002FF80 #
1715 0002FF80 #
1716 0002FF80 #
1717 0002FF80 # /******************************************************************************
1718 0002FF80 # *
1719 0002FF80 # * HALT ON ERROR ROUTINE
1720 0002FF80 # *
1721 0002FF80 # * halt with the necessary information saved in the registers
1722 0002FF80 # *
1723 0002FF80 # ******************************************************************************/
1724 0002FF80 # pipe14_er_hlt( subtest )
1725 0002FF80 # int subtest;
1726 0002FF80 # {
1727 0002FF80 13 0099 jbr L373
1728 0002FF83 L374:
1729 0002FF83 # sgl_value_5 = dbl_st_acc.m;
1730 0002FF83 0d effffff0b3 effffff0ae movl _dbl_st_acc,_sgl_value_5
1731 0002FF8E # sgl_value_6 = dbl_st_acc.l;
1732 0002FF8E 0d effffff0ac effffff0a3 movl _dbl_st_acc+4,_sgl_value_6
1733 0002FF99 # sgl_value_7 = dbl_expected.m;
1734 0002FF99 0d effffff09d effffff098 movl _dbl_expected,_sgl_value_7
1735 0002FFA4 # sgl_value_8 = dbl_expected.l;
1736 0002FFA4 0d effffff096 effffff08d movl _dbl_expected+4,_sgl_value_8
1737 0002FFAF # asm("movl _test_no,r0"); /* r0 = test number */
1738 0002FFAF 0d effffff087 50 movl _test_no,r0
1739 0002FFB6 # asm("movl _subtest,r1"); /* r1 = subtest number */
1740 0002FFB6 0d effffff080 51 movl _subtest,r1
1741 0002FFBD # asm("movl $1,r2"); /* r2 = error code */
1742 0002FFBD 0d 01 52 movl $1,r2
1743 0002FFC0 # asm("movl _cycle,r3"); /* r3 = cycle count */
1744 0002FFC0 0d effffff076 53 movl _cycle,r3
1745 0002FFC7 # asm("movl _sgl_value_1,r4"); /* r4 = MSW operand one */
1746 0002FFC7 0d effffff06f 54 movl _sgl_value_1,r4
1747 0002FFCE # asm("movl _sgl_value_2,r5"); /* r5 = LSW operand one */
1748 0002FFCE 0d effffff068 55 movl _sgl_value_2,r5
1749 0002FFD5 # asm("movl _sgl_value_3,r6"); /* r6 = MSW operand two */
1750 0002FFD5 0d effffff061 56 movl _sgl_value_3,r6
1751 0002FFDC # asm("movl _sgl_value_4,r7"); /* r7 = LSW operand two */
1752 0002FFDC 0d effffff05a 57 movl _sgl_value_4,r7
1753 0002FFE3 # asm("movl _sgl_value_5,r8"); /* r8 = MSW operand stored */
1754 0002FFE3 0d effffff053 58 movl _sgl_value_5,r8
1755 0002FFEA # asm("movl _sgl_value_6,r9"); /* r9 = LSW operand stored */
1756 0002FFEA 0d effffff04c 59 movl _sgl_value_6,r9
1757 0002FFF1 # asm("movl _sgl_value_7,r10"); /* r10 = MSW operand exp */
1758 0002FFF1 0d effffff045 5a movl _sgl_value_7,r10
1759 0002FFF8 # asm("movl _sgl_value_8,r11"); /* r11 = LSW operand exp */
1760 0002FFF8 0d effffff03e 5b movl _sgl_value_8,r11
1761 0002FFFF # asm("movl _index,r12"); /* r12 = data index */
1762 0002FFFF 0d effffff037 5c movl _index,r12
1763 00030006 # if( subtest == 9 ) {
1764 00030006 1d ad04 09 cmpl 4(fp),$9
1765 0003000A 21 0e jneq L375
1766 0003000C # asm("movl _sgl_value_10,r13"); /* r13 = final FP value */
1767 0003000C 0d effffff02a 5d movl _sgl_value_10,r13
1768 00030013 # asm("movl _sgl_value_9,r14"); /* r14 = expected FP value */
1769 00030013 0d effffff023 5e movl _sgl_value_9,r14
1770 0003001A # };
1771 0003001A L375:
1772 0003001A # asm(".globl _pipe14_1_hlt");
1773 0003001A .globl _pipe14_1_hlt
1774 0003001A # asm("_pipe14_1_hlt:"); /* PC after the halt */
1775 0003001A _pipe14_1_hlt:
1776 0003001A # asm("halt"); /* HALT ... */
1777 0003001A 00 halt
1778 0003001B # } /* end of halt on error */
1779 0003001B 40 ret#2
1780 0003001C .set L371,0x0
1781 0003001C L373:
1782 0003001C 13 ff64 jbr L374
1783 0003001F .data
1783 0005F05B .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.