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