![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe3.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 pipe3.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 00000ce8 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_3
6: 6 00000000 _pipe_3:
7: 7 00027948 0000 .word L215
8: 8 0002794A # #include "fpp_defs.h"
9: 9 0002794A #
10: 10 0002794A #
11: 11 0002794A # /*****************************************************************************
12: 12 0002794A # *
13: 13 0002794A # * PIPELINE TEST #3 MONITOR
14: 14 0002794A # *
15: 15 0002794A # * This test will do:
16: 16 0002794A # *
17: 17 0002794A # * CVLF(x), STF, MULF(1), STF
18: 18 0002794A # *
19: 19 0002794A # * where x is the fmacro1 CVLF data. This test verifies that we can keep
20: 20 0002794A # * using data after we store it.
21: 21 0002794A # *****************************************************************************/
22: 22 0002794A # pipe_3()
23: 23 0002794A # {
24: 24 0002794A 13 00a8 jbr L217
25: 25 0002794D L218:
26: 26 0002794D # asm(".globl _pipeline_3_t");
27: 27 0002794D .globl _pipeline_3_t
28: 28 0002794D # asm("_pipeline_3_t:"); /* entry address */
29: 29 0002794D _pipeline_3_t:
30: 30 0002794D # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
31: 31 0002794D 1d effffffff5 01 cmpl _cycle,$1
32: 32 00027954 21 15 jneq L219
33: 33 00027956 5d efffffffec tstl _prt_hdrs
34: 34 0002795C 31 0d jeql L219
35: 35 0002795E # {
36: 36 0002795E # writes(" PIPE_3 ");
37: 37 0002795E .data 1
38: 38 00000ce8 * L221:
39: 39 00000ce8 * 20504950455F332000 .ascii " PIPE_3 \0"
40: 40 00000cf1 * .text
41: 41 0002795E dd 8f00000ce8 pushl $L221
42: 42 00027964 fe 08 efffffffdd callf $8,_writes
43: 43 0002796B # }
44: 44 0002796B # subtest = 1;
45: 45 0002796B L219:
46: 46 0002796B 0d 01 efffffffd6 movl $1,_subtest
47: 47 00027972 # pipe3_1(); /* data in REGs, no NOPs */
48: 48 00027972 fe 04 ef0000007f callf $4,_pipe3_1
49: 49 00027979 # subtest++; /* increment the subtest */
50: 50 00027979 6d efffffffc9 incl _subtest
51: 51 0002797F # pipe3_2(); /* data in REGs, 1 NOP */
52: 52 0002797F fe 04 ef00000162 callf $4,_pipe3_2
53: 53 00027986 # subtest++; /* increment the subtest */
54: 54 00027986 6d efffffffbc incl _subtest
55: 55 0002798C # pipe3_3(); /* data in REGs, 2 NOPs */
56: 56 0002798C fe 04 ef00000247 callf $4,_pipe3_3
57: 57 00027993 # subtest++; /* increment the subtest */
58: 58 00027993 6d efffffffaf incl _subtest
59: 59 00027999 # pipe3_4(); /* data in REGs, 3 NOPs */
60: 60 00027999 fe 04 ef00000330 callf $4,_pipe3_4
61: 61 000279A0 # subtest++; /* increment the subtest */
62: 62 000279A0 6d efffffffa2 incl _subtest
63: 63 000279A6 # pipe3_5(); /* data in CACHE, no NOPs */
64: 64 000279A6 fe 04 ef0000041b callf $4,_pipe3_5
65: 65 000279AD # subtest++; /* increment the subtest */
66: 66 000279AD 6d efffffff95 incl _subtest
67: 67 000279B3 # pipe3_6(); /* data in CACHE, 1 NOP */
68: 68 000279B3 fe 04 ef000004f2 callf $4,_pipe3_6
69: 69 000279BA # subtest++; /* increment the subtest */
70: 70 000279BA 6d efffffff88 incl _subtest
71: 71 000279C0 # pipe3_7(); /* data in CACHE, 2 NOPs */
72: 72 000279C0 fe 04 ef000005cb callf $4,_pipe3_7
73: 73 000279C7 # subtest++; /* increment the subtest */
74: 74 000279C7 6d efffffff7b incl _subtest
75: 75 000279CD # pipe3_8(); /* data in CACHE, 3 NOPs */
76: 76 000279CD fe 04 ef000006a8 callf $4,_pipe3_8
77: 77 000279D4 # subtest++; /* increment the subtest */
78: 78 000279D4 6d efffffff6e incl _subtest
79: 79 000279DA # pipe3_9(); /* data on STACK, no NOPs */
80: 80 000279DA fe 04 ef00000787 callf $4,_pipe3_9
81: 81 000279E1 # subtest++; /* increment the subtest */
82: 82 000279E1 6d efffffff61 incl _subtest
83: 83 000279E7 # pipe3_10(); /* data via FP no NOPs */
84: 84 000279E7 fe 04 ef000008fe callf $4,_pipe3_10
85: 85 000279EE # asm("jmp *return"); /* return to the test monitor */
86: 86 000279EE 71 ffffffff54 jmp *return
87: 87 000279F4 # }
88: 88 000279F4 40 ret#2
89: 89 000279F5 .set L215,0x0
90: 90 000279F5 L217:
91: 91 000279F5 13 ff55 jbr L218
92: 92 000279F8 .data
93: 93 00000ce8 * .text
94: 94 000279F8 .align 1
95: 95 000279F8 .globl _pipe3_1
96: 96 000279F8 _pipe3_1:
97: 97 000279F8 0000 .word L232
98: 98 000279FA #
99: 99 000279FA #
100: 100 000279FA #
101: 101 000279FA #
102: 102 000279FA #
103: 103 000279FA #
104: 104 000279FA # /************************************************************************
105: 105 000279FA # *
106: 106 000279FA # * SUBTEST 1
107: 107 000279FA # * data in registers, no NO-OPs
108: 108 000279FA # *
109: 109 000279FA # ************************************************************************/
110: 110 000279FA # pipe3_1()
111: 111 000279FA # {
112: 112 000279FA 13 00e7 jbr L234
113: 113 000279FD L235:
114: 114 000279FD # force_loop = FALSE; /* clear force_loop flag */
115: 115 000279FD 4d efffffff45 clrl _force_loop
116: 116 00027A03 # index = 0;
117: 117 00027A03 4d efffffff3f clrl _index
118: 118 00027A09 # do
119: 119 00027A09 L238:
120: 120 00027A09 # {
121: 121 00027A09 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
122: 122 00027A09 0d efffffff39 50 movl _index,r0
123: 123 00027A10 48 03 50 50 shll $3,r0,r0
124: 124 00027A14 0d e000000000 efffffff29 movl _cvlf_1_data(r0),_sgl_value_1
125: 125 00027A1F # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
126: 126 00027A1F 0d efffffff23 50 movl _index,r0
127: 127 00027A26 48 03 50 50 shll $3,r0,r0
128: 128 00027A2A 0d e000000004 efffffff13 movl _cvlf_1_data+4(r0),_sgl_expected
129: 129 00027A35 # sgl_value_2 = 0x40800000; /* floating '1' */
130: 130 00027A35 0d 8f40800000 efffffff08 movl $1082130432,_sgl_value_2
131: 131 00027A40 # /*
132: 132 00027A40 # * If LOOP ON ERROR is set, this is the loop for this subtest.
133: 133 00027A40 # * The force loop flag is set after the first error.
134: 134 00027A40 # */
135: 135 00027A40 # asm("_pipe3_1_lp1:");
136: 136 00027A40 _pipe3_1_lp1:
137: 137 00027A40 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
138: 138 00027A40 0d efffffff02 54 movl _sgl_value_1,r4
139: 139 00027A47 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
140: 140 00027A47 0d effffffefb 55 movl _sgl_value_2,r5
141: 141 00027A4E # asm("cvlf r4"); /* load (negate) the data */
142: 142 00027A4E 76 54 cvlf r4
143: 143 00027A50 # asm("stf r7"); /* store the result */
144: 144 00027A50 26 57 stf r7
145: 145 00027A52 # asm("mulf r5"); /* multipy by '1' (twice) */
146: 146 00027A52 e6 55 mulf r5
147: 147 00027A54 # asm("stf r8"); /* store the result */
148: 148 00027A54 26 58 stf r8
149: 149 00027A56 # if( force_loop )
150: 150 00027A56 5d effffffeec tstl _force_loop
151: 151 00027A5C 31 02 jeql L239
152: 152 00027A5E # asm("brb _pipe3_1_lp1");; /* loop on the error */
153: 153 00027A5E 11 e0 brb _pipe3_1_lp1
154: 154 00027A60 L239:
155: 155 00027A60 # /*
156: 156 00027A60 # * verify the results
157: 157 00027A60 # */
158: 158 00027A60 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
159: 159 00027A60 0d 57 effffffee1 movl r7,_sgl_st_acc
160: 160 00027A67 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
161: 161 00027A67 0d 58 effffffeda movl r8,_sgl_value_6
162: 162 00027A6E # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
163: 163 00027A6E # (sgl_value_6 != sgl_expected) )
164: 164 00027A6E 1d effffffed4 effffffecf cmpl _sgl_st_acc,_sgl_expected
165: 165 00027A79 21 0d jneq L9999
166: 166 00027A7B 1d effffffec7 effffffec2 cmpl _sgl_value_6,_sgl_expected
167: 167 00027A86 31 42 jeql L240
168: 168 00027A88 L9999:
169: 169 00027A88 # {
170: 170 00027A88 # errcnt++; /* bump the error count */
171: 171 00027A88 6d effffffeba incl _errcnt
172: 172 00027A8E # if ( prt_error )
173: 173 00027A8E 5d effffffeb4 tstl _prt_error
174: 174 00027A94 31 0d jeql L241
175: 175 00027A96 # print_pipe3_er("Reg. Data, no NOPS");
176: 176 00027A96 .data 1
177: 177 00000cf1 * L243:
178: 178 00000cf1 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NOPS\0"
179: F204E4F505300
180: 179 00000d04 * .text
181: 180 00027A96 dd 8f00000cf1 pushl $L243
182: 181 00027A9C fe 08 ef00000a13 callf $8,_print_pipe3_er
183: 182 00027AA3 # if ( halt_flg )
184: 183 00027AA3 L241:
185: 184 00027AA3 5d effffffe9f tstl _halt_flg
186: 185 00027AA9 31 0d jeql L244
187: 186 00027AAB # pipe3_er_hlt( subtest );
188: 187 00027AAB dd effffffe97 pushl _subtest
189: 188 00027AB1 fe 08 ef00000b0a callf $8,_pipe3_er_hlt
190: 189 00027AB8 # if ( loop_on_err ) {
191: 190 00027AB8 L244:
192: 191 00027AB8 5d effffffe8a tstl _loop_on_err
193: 192 00027ABE 31 0a jeql L246
194: 193 00027AC0 # force_loop = TRUE; /* set the force loop flag */
195: 194 00027AC0 0d 01 effffffe81 movl $1,_force_loop
196: 195 00027AC7 # asm("brw _pipe3_1_lp1"); /* and loop */
197: 196 00027AC7 13 ff76 brw _pipe3_1_lp1
198: 197 00027ACA # }
199: 198 00027ACA # } /* end of compare error */
200: 199 00027ACA L246:
201: 200 00027ACA # } while( index++ < max_cvlf_1_index );
202: 201 00027ACA L240:
203: 202 00027ACA L237:
204: 203 00027ACA 0d effffffe78 50 movl _index,r0
205: 204 00027AD1 6d effffffe71 incl _index
206: 205 00027AD7 1d 50 effffffe6a cmpl r0,_max_cvlf_1_index
207: 206 00027ADE 81 03 13 ff26 jlss L238
208: 207 00027AE3 L236:
209: 208 00027AE3 # } /* end of subtest 1 */
210: 209 00027AE3 40 ret#2
211: 210 00027AE4 .set L232,0x0
212: 211 00027AE4 L234:
213: 212 00027AE4 13 ff16 jbr L235
214: 213 00027AE7 .data
215: 214 00000ce8 * .text
216: 215 00027AE7 00 .align 1
217: 216 00027AE8 .globl _pipe3_2
218: 217 00027AE8 _pipe3_2:
219: 218 00027AE8 0000 .word L247
220: 219 00027AEA #
221: 220 00027AEA #
222: 221 00027AEA #
223: 222 00027AEA #
224: 223 00027AEA #
225: 224 00027AEA #
226: 225 00027AEA # /************************************************************************
227: 226 00027AEA # *
228: 227 00027AEA # * SUBTEST 2
229: 228 00027AEA # * data in registers, 1 NO-OP
230: 229 00027AEA # *
231: 230 00027AEA # ************************************************************************/
232: 231 00027AEA # pipe3_2()
233: 232 00027AEA # {
234: 233 00027AEA 13 00ea jbr L249
235: 234 00027AED L250:
236: 235 00027AED # force_loop = FALSE; /* clear force_loop flag */
237: 236 00027AED 4d effffffe55 clrl _force_loop
238: 237 00027AF3 # index = 0;
239: 238 00027AF3 4d effffffe4f clrl _index
240: 239 00027AF9 # do
241: 240 00027AF9 L253:
242: 241 00027AF9 # {
243: 242 00027AF9 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
244: 243 00027AF9 0d effffffe49 50 movl _index,r0
245: 244 00027B00 48 03 50 50 shll $3,r0,r0
246: 245 00027B04 0d e000000000 effffffe39 movl _cvlf_1_data(r0),_sgl_value_1
247: 246 00027B0F # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
248: 247 00027B0F 0d effffffe33 50 movl _index,r0
249: 248 00027B16 48 03 50 50 shll $3,r0,r0
250: 249 00027B1A 0d e000000004 effffffe23 movl _cvlf_1_data+4(r0),_sgl_expected
251: 250 00027B25 # sgl_value_2 = 0x40800000; /* floating '1' */
252: 251 00027B25 0d 8f40800000 effffffe18 movl $1082130432,_sgl_value_2
253: 252 00027B30 # /*
254: 253 00027B30 # * If LOOP ON ERROR is set, this is the loop for this subtest.
255: 254 00027B30 # * The force loop flag is set after the first error.
256: 255 00027B30 # */
257: 256 00027B30 # asm("_pipe3_2_lp1:");
258: 257 00027B30 _pipe3_2_lp1:
259: 258 00027B30 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
260: 259 00027B30 0d effffffe12 54 movl _sgl_value_1,r4
261: 260 00027B37 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
262: 261 00027B37 0d effffffe0b 55 movl _sgl_value_2,r5
263: 262 00027B3E # asm("cvlf r4"); /* load (negate) the data */
264: 263 00027B3E 76 54 cvlf r4
265: 264 00027B40 # asm("nop");
266: 265 00027B40 10 nop
267: 266 00027B41 # asm("stf r7"); /* store the result */
268: 267 00027B41 26 57 stf r7
269: 268 00027B43 # asm("nop");
270: 269 00027B43 10 nop
271: 270 00027B44 # asm("mulf r5"); /* multipy by '1' (twice) */
272: 271 00027B44 e6 55 mulf r5
273: 272 00027B46 # asm("nop");
274: 273 00027B46 10 nop
275: 274 00027B47 # asm("stf r8"); /* store the result */
276: 275 00027B47 26 58 stf r8
277: 276 00027B49 # if( force_loop )
278: 277 00027B49 5d effffffdf9 tstl _force_loop
279: 278 00027B4F 31 02 jeql L254
280: 279 00027B51 # asm("brb _pipe3_2_lp1");; /* loop on the error */
281: 280 00027B51 11 dd brb _pipe3_2_lp1
282: 281 00027B53 L254:
283: 282 00027B53 # /*
284: 283 00027B53 # * verify the results
285: 284 00027B53 # */
286: 285 00027B53 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
287: 286 00027B53 0d 57 effffffdee movl r7,_sgl_st_acc
288: 287 00027B5A # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
289: 288 00027B5A 0d 58 effffffde7 movl r8,_sgl_value_6
290: 289 00027B61 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
291: 290 00027B61 # (sgl_value_6 != sgl_expected) )
292: 291 00027B61 1d effffffde1 effffffddc cmpl _sgl_st_acc,_sgl_expected
293: 292 00027B6C 21 0d jneq L9998
294: 293 00027B6E 1d effffffdd4 effffffdcf cmpl _sgl_value_6,_sgl_expected
295: 294 00027B79 31 42 jeql L255
296: 295 00027B7B L9998:
297: 296 00027B7B # {
298: 297 00027B7B # errcnt++; /* bump the error count */
299: 298 00027B7B 6d effffffdc7 incl _errcnt
300: 299 00027B81 # if ( prt_error )
301: 300 00027B81 5d effffffdc1 tstl _prt_error
302: 301 00027B87 31 0d jeql L256
303: 302 00027B89 # print_pipe3_er("Reg. Data, 1 NO-OP");
304: 303 00027B89 .data 1
305: 304 00000d04 * L257:
306: 305 00000d04 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
307: 04E4F2D4F5000
308: 306 00000d17 * .text
309: 307 00027B89 dd 8f00000d04 pushl $L257
310: 308 00027B8F fe 08 ef00000920 callf $8,_print_pipe3_er
311: 309 00027B96 # if ( halt_flg )
312: 310 00027B96 L256:
313: 311 00027B96 5d effffffdac tstl _halt_flg
314: 312 00027B9C 31 0d jeql L258
315: 313 00027B9E # pipe3_er_hlt( subtest );
316: 314 00027B9E dd effffffda4 pushl _subtest
317: 315 00027BA4 fe 08 ef00000a17 callf $8,_pipe3_er_hlt
318: 316 00027BAB # if ( loop_on_err ) {
319: 317 00027BAB L258:
320: 318 00027BAB 5d effffffd97 tstl _loop_on_err
321: 319 00027BB1 31 0a jeql L259
322: 320 00027BB3 # force_loop = TRUE; /* set the force loop flag */
323: 321 00027BB3 0d 01 effffffd8e movl $1,_force_loop
324: 322 00027BBA # asm("brw _pipe3_2_lp1"); /* and loop */
325: 323 00027BBA 13 ff73 brw _pipe3_2_lp1
326: 324 00027BBD # }
327: 325 00027BBD # } /* end of compare error */
328: 326 00027BBD L259:
329: 327 00027BBD # } while( index++ < max_cvlf_1_index );
330: 328 00027BBD L255:
331: 329 00027BBD L252:
332: 330 00027BBD 0d effffffd85 50 movl _index,r0
333: 331 00027BC4 6d effffffd7e incl _index
334: 332 00027BCA 1d 50 effffffd77 cmpl r0,_max_cvlf_1_index
335: 333 00027BD1 81 03 13 ff23 jlss L253
336: 334 00027BD6 L251:
337: 335 00027BD6 # } /* end of subtest 2 */
338: 336 00027BD6 40 ret#2
339: 337 00027BD7 .set L247,0x0
340: 338 00027BD7 L249:
341: 339 00027BD7 13 ff13 jbr L250
342: 340 00027BDA .data
343: 341 00000ce8 * .text
344: 342 00027BDA .align 1
345: 343 00027BDA .globl _pipe3_3
346: 344 00027BDA _pipe3_3:
347: 345 00027BDA 0000 .word L260
348: 346 00027BDC #
349: 347 00027BDC #
350: 348 00027BDC #
351: 349 00027BDC #
352: 350 00027BDC #
353: 351 00027BDC #
354: 352 00027BDC # /************************************************************************
355: 353 00027BDC # *
356: 354 00027BDC # * SUBTEST 3
357: 355 00027BDC # * data in registers, 2 NO-OPs
358: 356 00027BDC # *
359: 357 00027BDC # ************************************************************************/
360: 358 00027BDC # pipe3_3()
361: 359 00027BDC # {
362: 360 00027BDC 13 00ed jbr L262
363: 361 00027BDF L263:
364: 362 00027BDF # force_loop = FALSE; /* clear force_loop flag */
365: 363 00027BDF 4d effffffd63 clrl _force_loop
366: 364 00027BE5 # index = 0;
367: 365 00027BE5 4d effffffd5d clrl _index
368: 366 00027BEB # do
369: 367 00027BEB L266:
370: 368 00027BEB # {
371: 369 00027BEB # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
372: 370 00027BEB 0d effffffd57 50 movl _index,r0
373: 371 00027BF2 48 03 50 50 shll $3,r0,r0
374: 372 00027BF6 0d e000000000 effffffd47 movl _cvlf_1_data(r0),_sgl_value_1
375: 373 00027C01 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
376: 374 00027C01 0d effffffd41 50 movl _index,r0
377: 375 00027C08 48 03 50 50 shll $3,r0,r0
378: 376 00027C0C 0d e000000004 effffffd31 movl _cvlf_1_data+4(r0),_sgl_expected
379: 377 00027C17 # sgl_value_2 = 0x40800000; /* floating '1' */
380: 378 00027C17 0d 8f40800000 effffffd26 movl $1082130432,_sgl_value_2
381: 379 00027C22 # /*
382: 380 00027C22 # * If LOOP ON ERROR is set, this is the loop for this subtest.
383: 381 00027C22 # * The force loop flag is set after the first error.
384: 382 00027C22 # */
385: 383 00027C22 # asm("_pipe3_3_lp1:");
386: 384 00027C22 _pipe3_3_lp1:
387: 385 00027C22 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
388: 386 00027C22 0d effffffd20 54 movl _sgl_value_1,r4
389: 387 00027C29 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
390: 388 00027C29 0d effffffd19 55 movl _sgl_value_2,r5
391: 389 00027C30 # asm("cvlf r4"); /* load (negate) the data */
392: 390 00027C30 76 54 cvlf r4
393: 391 00027C32 # asm("nop");
394: 392 00027C32 10 nop
395: 393 00027C33 # asm("nop");
396: 394 00027C33 10 nop
397: 395 00027C34 # asm("stf r7"); /* store the result */
398: 396 00027C34 26 57 stf r7
399: 397 00027C36 # asm("nop");
400: 398 00027C36 10 nop
401: 399 00027C37 # asm("nop");
402: 400 00027C37 10 nop
403: 401 00027C38 # asm("mulf r5"); /* multipy by '1' (twice) */
404: 402 00027C38 e6 55 mulf r5
405: 403 00027C3A # asm("nop");
406: 404 00027C3A 10 nop
407: 405 00027C3B # asm("nop");
408: 406 00027C3B 10 nop
409: 407 00027C3C # asm("stf r8"); /* store the result */
410: 408 00027C3C 26 58 stf r8
411: 409 00027C3E # if( force_loop )
412: 410 00027C3E 5d effffffd04 tstl _force_loop
413: 411 00027C44 31 02 jeql L267
414: 412 00027C46 # asm("brb _pipe3_3_lp1");; /* loop on the error */
415: 413 00027C46 11 da brb _pipe3_3_lp1
416: 414 00027C48 L267:
417: 415 00027C48 # /*
418: 416 00027C48 # * verify the results
419: 417 00027C48 # */
420: 418 00027C48 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
421: 419 00027C48 0d 57 effffffcf9 movl r7,_sgl_st_acc
422: 420 00027C4F # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
423: 421 00027C4F 0d 58 effffffcf2 movl r8,_sgl_value_6
424: 422 00027C56 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
425: 423 00027C56 # (sgl_value_6 != sgl_expected) )
426: 424 00027C56 1d effffffcec effffffce7 cmpl _sgl_st_acc,_sgl_expected
427: 425 00027C61 21 0d jneq L9997
428: 426 00027C63 1d effffffcdf effffffcda cmpl _sgl_value_6,_sgl_expected
429: 427 00027C6E 31 42 jeql L268
430: 428 00027C70 L9997:
431: 429 00027C70 # {
432: 430 00027C70 # errcnt++; /* bump the error count */
433: 431 00027C70 6d effffffcd2 incl _errcnt
434: 432 00027C76 # if ( prt_error )
435: 433 00027C76 5d effffffccc tstl _prt_error
436: 434 00027C7C 31 0d jeql L269
437: 435 00027C7E # print_pipe3_er("Reg. Data, 2 NO-OPS");
438: 436 00027C7E .data 1
439: 437 00000d17 * L270:
440: 438 00000d17 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPS\0"
441: 04E4F2D4F505300
442: 439 00000d2b * .text
443: 440 00027C7E dd 8f00000d17 pushl $L270
444: 441 00027C84 fe 08 ef0000082b callf $8,_print_pipe3_er
445: 442 00027C8B # if ( halt_flg )
446: 443 00027C8B L269:
447: 444 00027C8B 5d effffffcb7 tstl _halt_flg
448: 445 00027C91 31 0d jeql L271
449: 446 00027C93 # pipe3_er_hlt( subtest );
450: 447 00027C93 dd effffffcaf pushl _subtest
451: 448 00027C99 fe 08 ef00000922 callf $8,_pipe3_er_hlt
452: 449 00027CA0 # if ( loop_on_err ) {
453: 450 00027CA0 L271:
454: 451 00027CA0 5d effffffca2 tstl _loop_on_err
455: 452 00027CA6 31 0a jeql L272
456: 453 00027CA8 # force_loop = TRUE; /* set the force loop flag */
457: 454 00027CA8 0d 01 effffffc99 movl $1,_force_loop
458: 455 00027CAF # asm("brw _pipe3_3_lp1"); /* and loop */
459: 456 00027CAF 13 ff70 brw _pipe3_3_lp1
460: 457 00027CB2 # }
461: 458 00027CB2 # } /* end of compare error */
462: 459 00027CB2 L272:
463: 460 00027CB2 # } while( index++ < max_cvlf_1_index );
464: 461 00027CB2 L268:
465: 462 00027CB2 L265:
466: 463 00027CB2 0d effffffc90 50 movl _index,r0
467: 464 00027CB9 6d effffffc89 incl _index
468: 465 00027CBF 1d 50 effffffc82 cmpl r0,_max_cvlf_1_index
469: 466 00027CC6 81 03 13 ff20 jlss L266
470: 467 00027CCB L264:
471: 468 00027CCB # } /* end of subtest 3 */
472: 469 00027CCB 40 ret#2
473: 470 00027CCC .set L260,0x0
474: 471 00027CCC L262:
475: 472 00027CCC 13 ff10 jbr L263
476: 473 00027CCF .data
477: 474 00000ce8 * .text
478: 475 00027CCF 00 .align 1
479: 476 00027CD0 .globl _pipe3_4
480: 477 00027CD0 _pipe3_4:
481: 478 00027CD0 0000 .word L273
482: 479 00027CD2 #
483: 480 00027CD2 #
484: 481 00027CD2 #
485: 482 00027CD2 #
486: 483 00027CD2 #
487: 484 00027CD2 #
488: 485 00027CD2 # /************************************************************************
489: 486 00027CD2 # *
490: 487 00027CD2 # * SUBTEST 4
491: 488 00027CD2 # * data in registers, 3 NO-OPs
492: 489 00027CD2 # *
493: 490 00027CD2 # ************************************************************************/
494: 491 00027CD2 # pipe3_4()
495: 492 00027CD2 # {
496: 493 00027CD2 13 00f0 jbr L275
497: 494 00027CD5 L276:
498: 495 00027CD5 # force_loop = FALSE; /* clear force_loop flag */
499: 496 00027CD5 4d effffffc6d clrl _force_loop
500: 497 00027CDB # index = 0;
501: 498 00027CDB 4d effffffc67 clrl _index
502: 499 00027CE1 # do
503: 500 00027CE1 L279:
504: 501 00027CE1 # {
505: 502 00027CE1 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
506: 503 00027CE1 0d effffffc61 50 movl _index,r0
507: 504 00027CE8 48 03 50 50 shll $3,r0,r0
508: 505 00027CEC 0d e000000000 effffffc51 movl _cvlf_1_data(r0),_sgl_value_1
509: 506 00027CF7 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
510: 507 00027CF7 0d effffffc4b 50 movl _index,r0
511: 508 00027CFE 48 03 50 50 shll $3,r0,r0
512: 509 00027D02 0d e000000004 effffffc3b movl _cvlf_1_data+4(r0),_sgl_expected
513: 510 00027D0D # sgl_value_2 = 0x40800000; /* floating '1' */
514: 511 00027D0D 0d 8f40800000 effffffc30 movl $1082130432,_sgl_value_2
515: 512 00027D18 # /*
516: 513 00027D18 # * If LOOP ON ERROR is set, this is the loop for this subtest.
517: 514 00027D18 # * The force loop flag is set after the first error.
518: 515 00027D18 # */
519: 516 00027D18 # asm("_pipe3_4_lp1:");
520: 517 00027D18 _pipe3_4_lp1:
521: 518 00027D18 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
522: 519 00027D18 0d effffffc2a 54 movl _sgl_value_1,r4
523: 520 00027D1F # asm("movl _sgl_value_2,r5"); /* move data to r5 */
524: 521 00027D1F 0d effffffc23 55 movl _sgl_value_2,r5
525: 522 00027D26 # asm("cvlf r4"); /* load (negate) the data */
526: 523 00027D26 76 54 cvlf r4
527: 524 00027D28 # asm("nop");
528: 525 00027D28 10 nop
529: 526 00027D29 # asm("nop");
530: 527 00027D29 10 nop
531: 528 00027D2A # asm("nop");
532: 529 00027D2A 10 nop
533: 530 00027D2B # asm("stf r7"); /* store the result */
534: 531 00027D2B 26 57 stf r7
535: 532 00027D2D # asm("nop");
536: 533 00027D2D 10 nop
537: 534 00027D2E # asm("nop");
538: 535 00027D2E 10 nop
539: 536 00027D2F # asm("nop");
540: 537 00027D2F 10 nop
541: 538 00027D30 # asm("mulf r5"); /* multipy by '1' (twice) */
542: 539 00027D30 e6 55 mulf r5
543: 540 00027D32 # asm("nop");
544: 541 00027D32 10 nop
545: 542 00027D33 # asm("nop");
546: 543 00027D33 10 nop
547: 544 00027D34 # asm("nop");
548: 545 00027D34 10 nop
549: 546 00027D35 # asm("stf r8"); /* store the result */
550: 547 00027D35 26 58 stf r8
551: 548 00027D37 # if( force_loop )
552: 549 00027D37 5d effffffc0b tstl _force_loop
553: 550 00027D3D 31 02 jeql L280
554: 551 00027D3F # asm("brb _pipe3_4_lp1");; /* loop on the error */
555: 552 00027D3F 11 d7 brb _pipe3_4_lp1
556: 553 00027D41 L280:
557: 554 00027D41 # /*
558: 555 00027D41 # * verify the results
559: 556 00027D41 # */
560: 557 00027D41 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
561: 558 00027D41 0d 57 effffffc00 movl r7,_sgl_st_acc
562: 559 00027D48 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
563: 560 00027D48 0d 58 effffffbf9 movl r8,_sgl_value_6
564: 561 00027D4F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
565: 562 00027D4F # (sgl_value_6 != sgl_expected) )
566: 563 00027D4F 1d effffffbf3 effffffbee cmpl _sgl_st_acc,_sgl_expected
567: 564 00027D5A 21 0d jneq L9996
568: 565 00027D5C 1d effffffbe6 effffffbe1 cmpl _sgl_value_6,_sgl_expected
569: 566 00027D67 31 42 jeql L281
570: 567 00027D69 L9996:
571: 568 00027D69 # {
572: 569 00027D69 # errcnt++; /* bump the error count */
573: 570 00027D69 6d effffffbd9 incl _errcnt
574: 571 00027D6F # if ( prt_error )
575: 572 00027D6F 5d effffffbd3 tstl _prt_error
576: 573 00027D75 31 0d jeql L282
577: 574 00027D77 # print_pipe3_er("Reg. Data, 3 NO-OPS");
578: 575 00027D77 .data 1
579: 576 00000d2b * L283:
580: 577 00000d2b * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPS\0"
581: 04E4F2D4F505300
582: 578 00000d3f * .text
583: 579 00027D77 dd 8f00000d2b pushl $L283
584: 580 00027D7D fe 08 ef00000732 callf $8,_print_pipe3_er
585: 581 00027D84 # if ( halt_flg )
586: 582 00027D84 L282:
587: 583 00027D84 5d effffffbbe tstl _halt_flg
588: 584 00027D8A 31 0d jeql L284
589: 585 00027D8C # pipe3_er_hlt( subtest );
590: 586 00027D8C dd effffffbb6 pushl _subtest
591: 587 00027D92 fe 08 ef00000829 callf $8,_pipe3_er_hlt
592: 588 00027D99 # if ( loop_on_err ) {
593: 589 00027D99 L284:
594: 590 00027D99 5d effffffba9 tstl _loop_on_err
595: 591 00027D9F 31 0a jeql L285
596: 592 00027DA1 # force_loop = TRUE; /* set the force loop flag */
597: 593 00027DA1 0d 01 effffffba0 movl $1,_force_loop
598: 594 00027DA8 # asm("brw _pipe3_4_lp1"); /* and loop */
599: 595 00027DA8 13 ff6d brw _pipe3_4_lp1
600: 596 00027DAB # }
601: 597 00027DAB # } /* end of compare error */
602: 598 00027DAB L285:
603: 599 00027DAB # } while( index++ < max_cvlf_1_index );
604: 600 00027DAB L281:
605: 601 00027DAB L278:
606: 602 00027DAB 0d effffffb97 50 movl _index,r0
607: 603 00027DB2 6d effffffb90 incl _index
608: 604 00027DB8 1d 50 effffffb89 cmpl r0,_max_cvlf_1_index
609: 605 00027DBF 81 03 13 ff1d jlss L279
610: 606 00027DC4 L277:
611: 607 00027DC4 # } /* end of subtest 4 */
612: 608 00027DC4 40 ret#2
613: 609 00027DC5 .set L273,0x0
614: 610 00027DC5 L275:
615: 611 00027DC5 13 ff0d jbr L276
616: 612 00027DC8 .data
617: 613 00000ce8 * .text
618: 614 00027DC8 .align 1
619: 615 00027DC8 .globl _pipe3_5
620: 616 00027DC8 _pipe3_5:
621: 617 00027DC8 0000 .word L286
622: 618 00027DCA #
623: 619 00027DCA #
624: 620 00027DCA #
625: 621 00027DCA #
626: 622 00027DCA #
627: 623 00027DCA #
628: 624 00027DCA #
629: 625 00027DCA # /************************************************************************
630: 626 00027DCA # *
631: 627 00027DCA # * SUBTEST 5
632: 628 00027DCA # * data in Cache, no NO-OPs
633: 629 00027DCA # *
634: 630 00027DCA # ************************************************************************/
635: 631 00027DCA # pipe3_5()
636: 632 00027DCA # {
637: 633 00027DCA 13 00db jbr L288
638: 634 00027DCD L289:
639: 635 00027DCD # force_loop = FALSE; /* clear force_loop flag */
640: 636 00027DCD 4d effffffb75 clrl _force_loop
641: 637 00027DD3 # index = 0;
642: 638 00027DD3 4d effffffb6f clrl _index
643: 639 00027DD9 # do
644: 640 00027DD9 L292:
645: 641 00027DD9 # {
646: 642 00027DD9 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
647: 643 00027DD9 0d effffffb69 50 movl _index,r0
648: 644 00027DE0 48 03 50 50 shll $3,r0,r0
649: 645 00027DE4 0d e000000000 effffffb59 movl _cvlf_1_data(r0),_sgl_value_1
650: 646 00027DEF # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
651: 647 00027DEF 0d effffffb53 50 movl _index,r0
652: 648 00027DF6 48 03 50 50 shll $3,r0,r0
653: 649 00027DFA 0d e000000004 effffffb43 movl _cvlf_1_data+4(r0),_sgl_expected
654: 650 00027E05 # sgl_value_2 = 0x40800000; /* floating '1' */
655: 651 00027E05 0d 8f40800000 effffffb38 movl $1082130432,_sgl_value_2
656: 652 00027E10 # /*
657: 653 00027E10 # * If LOOP ON ERROR is set, this is the loop for this subtest.
658: 654 00027E10 # * The force loop flag is set after the first error.
659: 655 00027E10 # */
660: 656 00027E10 # asm("_pipe3_5_lp1:");
661: 657 00027E10 _pipe3_5_lp1:
662: 658 00027E10 # asm("cvlf _sgl_value_1"); /* load (negate) the data */
663: 659 00027E10 76 effffffb32 cvlf _sgl_value_1
664: 660 00027E16 # asm("stf _sgl_st_acc"); /* store the result */
665: 661 00027E16 26 effffffb2c stf _sgl_st_acc
666: 662 00027E1C # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
667: 663 00027E1C e6 effffffb26 mulf _sgl_value_2
668: 664 00027E22 # asm("stf _sgl_value_6"); /* store the result */
669: 665 00027E22 26 effffffb20 stf _sgl_value_6
670: 666 00027E28 # if( force_loop )
671: 667 00027E28 5d effffffb1a tstl _force_loop
672: 668 00027E2E 31 02 jeql L293
673: 669 00027E30 # asm("brb _pipe3_5_lp1");; /* loop on the error */
674: 670 00027E30 11 de brb _pipe3_5_lp1
675: 671 00027E32 L293:
676: 672 00027E32 # /*
677: 673 00027E32 # * verify the results
678: 674 00027E32 # */
679: 675 00027E32 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
680: 676 00027E32 # (sgl_value_6 != sgl_expected) )
681: 677 00027E32 1d effffffb10 effffffb0b cmpl _sgl_st_acc,_sgl_expected
682: 678 00027E3D 21 0d jneq L9995
683: 679 00027E3F 1d effffffb03 effffffafe cmpl _sgl_value_6,_sgl_expected
684: 680 00027E4A 31 42 jeql L294
685: 681 00027E4C L9995:
686: 682 00027E4C # {
687: 683 00027E4C # errcnt++; /* bump the error count */
688: 684 00027E4C 6d effffffaf6 incl _errcnt
689: 685 00027E52 # if ( prt_error )
690: 686 00027E52 5d effffffaf0 tstl _prt_error
691: 687 00027E58 31 0d jeql L295
692: 688 00027E5A # print_pipe3_er("Cache Data, no NO-OPS");
693: 689 00027E5A .data 1
694: 690 00000d3f * L296:
695: 691 00000d3f * 436163686520446174612C206 .ascii "Cache Data, no NO-OPS\0"
696: E6F204E4F2D4F505300
697: 692 00000d55 * .text
698: 693 00027E5A dd 8f00000d3f pushl $L296
699: 694 00027E60 fe 08 ef0000064f callf $8,_print_pipe3_er
700: 695 00027E67 # if ( halt_flg )
701: 696 00027E67 L295:
702: 697 00027E67 5d effffffadb tstl _halt_flg
703: 698 00027E6D 31 0d jeql L297
704: 699 00027E6F # pipe3_er_hlt( subtest );
705: 700 00027E6F dd effffffad3 pushl _subtest
706: 701 00027E75 fe 08 ef00000746 callf $8,_pipe3_er_hlt
707: 702 00027E7C # if ( loop_on_err ) {
708: 703 00027E7C L297:
709: 704 00027E7C 5d effffffac6 tstl _loop_on_err
710: 705 00027E82 31 0a jeql L298
711: 706 00027E84 # force_loop = TRUE; /* set the force loop flag */
712: 707 00027E84 0d 01 effffffabd movl $1,_force_loop
713: 708 00027E8B # asm("brw _pipe3_5_lp1"); /* and loop */
714: 709 00027E8B 13 ff82 brw _pipe3_5_lp1
715: 710 00027E8E # }
716: 711 00027E8E # } /* end of compare error */
717: 712 00027E8E L298:
718: 713 00027E8E # } while( index++ < max_cvlf_1_index );
719: 714 00027E8E L294:
720: 715 00027E8E L291:
721: 716 00027E8E 0d effffffab4 50 movl _index,r0
722: 717 00027E95 6d effffffaad incl _index
723: 718 00027E9B 1d 50 effffffaa6 cmpl r0,_max_cvlf_1_index
724: 719 00027EA2 81 03 13 ff32 jlss L292
725: 720 00027EA7 L290:
726: 721 00027EA7 # } /* end of subtest 5 */
727: 722 00027EA7 40 ret#2
728: 723 00027EA8 .set L286,0x0
729: 724 00027EA8 L288:
730: 725 00027EA8 13 ff22 jbr L289
731: 726 00027EAB .data
732: 727 00000ce8 * .text
733: 728 00027EAB 00 .align 1
734: 729 00027EAC .globl _pipe3_6
735: 730 00027EAC _pipe3_6:
736: 731 00027EAC 0000 .word L299
737: 732 00027EAE #
738: 733 00027EAE #
739: 734 00027EAE #
740: 735 00027EAE #
741: 736 00027EAE #
742: 737 00027EAE #
743: 738 00027EAE # /************************************************************************
744: 739 00027EAE # *
745: 740 00027EAE # * SUBTEST 6
746: 741 00027EAE # * data in Cache, 1 NO-OP
747: 742 00027EAE # *
748: 743 00027EAE # ************************************************************************/
749: 744 00027EAE # pipe3_6()
750: 745 00027EAE # {
751: 746 00027EAE 13 00de jbr L301
752: 747 00027EB1 L302:
753: 748 00027EB1 # force_loop = FALSE; /* clear force_loop flag */
754: 749 00027EB1 4d effffffa91 clrl _force_loop
755: 750 00027EB7 # index = 0;
756: 751 00027EB7 4d effffffa8b clrl _index
757: 752 00027EBD # do
758: 753 00027EBD L305:
759: 754 00027EBD # {
760: 755 00027EBD # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
761: 756 00027EBD 0d effffffa85 50 movl _index,r0
762: 757 00027EC4 48 03 50 50 shll $3,r0,r0
763: 758 00027EC8 0d e000000000 effffffa75 movl _cvlf_1_data(r0),_sgl_value_1
764: 759 00027ED3 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
765: 760 00027ED3 0d effffffa6f 50 movl _index,r0
766: 761 00027EDA 48 03 50 50 shll $3,r0,r0
767: 762 00027EDE 0d e000000004 effffffa5f movl _cvlf_1_data+4(r0),_sgl_expected
768: 763 00027EE9 # sgl_value_2 = 0x40800000; /* floating '1' */
769: 764 00027EE9 0d 8f40800000 effffffa54 movl $1082130432,_sgl_value_2
770: 765 00027EF4 # /*
771: 766 00027EF4 # * If LOOP ON ERROR is set, this is the loop for this subtest.
772: 767 00027EF4 # * The force loop flag is set after the first error.
773: 768 00027EF4 # */
774: 769 00027EF4 # asm("_pipe3_6_lp1:");
775: 770 00027EF4 _pipe3_6_lp1:
776: 771 00027EF4 # asm("cvlf _sgl_value_1"); /* load (negate) the data */
777: 772 00027EF4 76 effffffa4e cvlf _sgl_value_1
778: 773 00027EFA # asm("nop");
779: 774 00027EFA 10 nop
780: 775 00027EFB # asm("stf _sgl_st_acc"); /* store the result */
781: 776 00027EFB 26 effffffa47 stf _sgl_st_acc
782: 777 00027F01 # asm("nop");
783: 778 00027F01 10 nop
784: 779 00027F02 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
785: 780 00027F02 e6 effffffa40 mulf _sgl_value_2
786: 781 00027F08 # asm("nop");
787: 782 00027F08 10 nop
788: 783 00027F09 # asm("stf _sgl_value_6"); /* store the result */
789: 784 00027F09 26 effffffa39 stf _sgl_value_6
790: 785 00027F0F # if( force_loop )
791: 786 00027F0F 5d effffffa33 tstl _force_loop
792: 787 00027F15 31 02 jeql L306
793: 788 00027F17 # asm("brb _pipe3_6_lp1");; /* loop on the error */
794: 789 00027F17 11 db brb _pipe3_6_lp1
795: 790 00027F19 L306:
796: 791 00027F19 # /*
797: 792 00027F19 # * verify the results
798: 793 00027F19 # */
799: 794 00027F19 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
800: 795 00027F19 # (sgl_value_6 != sgl_expected) )
801: 796 00027F19 1d effffffa29 effffffa24 cmpl _sgl_st_acc,_sgl_expected
802: 797 00027F24 21 0d jneq L9994
803: 798 00027F26 1d effffffa1c effffffa17 cmpl _sgl_value_6,_sgl_expected
804: 799 00027F31 31 42 jeql L307
805: 800 00027F33 L9994:
806: 801 00027F33 # {
807: 802 00027F33 # errcnt++; /* bump the error count */
808: 803 00027F33 6d effffffa0f incl _errcnt
809: 804 00027F39 # if ( prt_error )
810: 805 00027F39 5d effffffa09 tstl _prt_error
811: 806 00027F3F 31 0d jeql L308
812: 807 00027F41 # print_pipe3_er("Cache Data, 1 NO-OP");
813: 808 00027F41 .data 1
814: 809 00000d55 * L309:
815: 810 00000d55 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
816: 1204E4F2D4F5000
817: 811 00000d69 * .text
818: 812 00027F41 dd 8f00000d55 pushl $L309
819: 813 00027F47 fe 08 ef00000568 callf $8,_print_pipe3_er
820: 814 00027F4E # if ( halt_flg )
821: 815 00027F4E L308:
822: 816 00027F4E 5d effffff9f4 tstl _halt_flg
823: 817 00027F54 31 0d jeql L310
824: 818 00027F56 # pipe3_er_hlt( subtest );
825: 819 00027F56 dd effffff9ec pushl _subtest
826: 820 00027F5C fe 08 ef0000065f callf $8,_pipe3_er_hlt
827: 821 00027F63 # if ( loop_on_err ) {
828: 822 00027F63 L310:
829: 823 00027F63 5d effffff9df tstl _loop_on_err
830: 824 00027F69 31 0a jeql L311
831: 825 00027F6B # force_loop = TRUE; /* set the force loop flag */
832: 826 00027F6B 0d 01 effffff9d6 movl $1,_force_loop
833: 827 00027F72 # asm("brw _pipe3_6_lp1"); /* and loop */
834: 828 00027F72 13 ff7f brw _pipe3_6_lp1
835: 829 00027F75 # }
836: 830 00027F75 # } /* end of compare error */
837: 831 00027F75 L311:
838: 832 00027F75 # } while( index++ < max_cvlf_1_index );
839: 833 00027F75 L307:
840: 834 00027F75 L304:
841: 835 00027F75 0d effffff9cd 50 movl _index,r0
842: 836 00027F7C 6d effffff9c6 incl _index
843: 837 00027F82 1d 50 effffff9bf cmpl r0,_max_cvlf_1_index
844: 838 00027F89 81 03 13 ff2f jlss L305
845: 839 00027F8E L303:
846: 840 00027F8E # } /* end of subtest 6 */
847: 841 00027F8E 40 ret#2
848: 842 00027F8F .set L299,0x0
849: 843 00027F8F L301:
850: 844 00027F8F 13 ff1f jbr L302
851: 845 00027F92 .data
852: 846 00000ce8 * .text
853: 847 00027F92 .align 1
854: 848 00027F92 .globl _pipe3_7
855: 849 00027F92 _pipe3_7:
856: 850 00027F92 0000 .word L312
857: 851 00027F94 #
858: 852 00027F94 #
859: 853 00027F94 #
860: 854 00027F94 #
861: 855 00027F94 #
862: 856 00027F94 #
863: 857 00027F94 # /************************************************************************
864: 858 00027F94 # *
865: 859 00027F94 # * SUBTEST 7
866: 860 00027F94 # * data in Cache, 2 NO-OPs
867: 861 00027F94 # *
868: 862 00027F94 # ************************************************************************/
869: 863 00027F94 # pipe3_7()
870: 864 00027F94 # {
871: 865 00027F94 13 00e1 jbr L314
872: 866 00027F97 L315:
873: 867 00027F97 # force_loop = FALSE; /* clear force_loop flag */
874: 868 00027F97 4d effffff9ab clrl _force_loop
875: 869 00027F9D # index = 0;
876: 870 00027F9D 4d effffff9a5 clrl _index
877: 871 00027FA3 # do
878: 872 00027FA3 L318:
879: 873 00027FA3 # {
880: 874 00027FA3 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
881: 875 00027FA3 0d effffff99f 50 movl _index,r0
882: 876 00027FAA 48 03 50 50 shll $3,r0,r0
883: 877 00027FAE 0d e000000000 effffff98f movl _cvlf_1_data(r0),_sgl_value_1
884: 878 00027FB9 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
885: 879 00027FB9 0d effffff989 50 movl _index,r0
886: 880 00027FC0 48 03 50 50 shll $3,r0,r0
887: 881 00027FC4 0d e000000004 effffff979 movl _cvlf_1_data+4(r0),_sgl_expected
888: 882 00027FCF # sgl_value_2 = 0x40800000; /* floating '1' */
889: 883 00027FCF 0d 8f40800000 effffff96e movl $1082130432,_sgl_value_2
890: 884 00027FDA # /*
891: 885 00027FDA # * If LOOP ON ERROR is set, this is the loop for this subtest.
892: 886 00027FDA # * The force loop flag is set after the first error.
893: 887 00027FDA # */
894: 888 00027FDA # asm("_pipe3_7_lp1:");
895: 889 00027FDA _pipe3_7_lp1:
896: 890 00027FDA # asm("cvlf _sgl_value_1"); /* load (negate) the data */
897: 891 00027FDA 76 effffff968 cvlf _sgl_value_1
898: 892 00027FE0 # asm("nop");
899: 893 00027FE0 10 nop
900: 894 00027FE1 # asm("nop");
901: 895 00027FE1 10 nop
902: 896 00027FE2 # asm("stf _sgl_st_acc"); /* store the result */
903: 897 00027FE2 26 effffff960 stf _sgl_st_acc
904: 898 00027FE8 # asm("nop");
905: 899 00027FE8 10 nop
906: 900 00027FE9 # asm("nop");
907: 901 00027FE9 10 nop
908: 902 00027FEA # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
909: 903 00027FEA e6 effffff958 mulf _sgl_value_2
910: 904 00027FF0 # asm("nop");
911: 905 00027FF0 10 nop
912: 906 00027FF1 # asm("nop");
913: 907 00027FF1 10 nop
914: 908 00027FF2 # asm("stf _sgl_value_6"); /* store the result */
915: 909 00027FF2 26 effffff950 stf _sgl_value_6
916: 910 00027FF8 # if( force_loop )
917: 911 00027FF8 5d effffff94a tstl _force_loop
918: 912 00027FFE 31 02 jeql L319
919: 913 00028000 # asm("brb _pipe3_7_lp1");; /* loop on the error */
920: 914 00028000 11 d8 brb _pipe3_7_lp1
921: 915 00028002 L319:
922: 916 00028002 # /*
923: 917 00028002 # * verify the results
924: 918 00028002 # */
925: 919 00028002 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
926: 920 00028002 # (sgl_value_6 != sgl_expected) )
927: 921 00028002 1d effffff940 effffff93b cmpl _sgl_st_acc,_sgl_expected
928: 922 0002800D 21 0d jneq L9993
929: 923 0002800F 1d effffff933 effffff92e cmpl _sgl_value_6,_sgl_expected
930: 924 0002801A 31 42 jeql L320
931: 925 0002801C L9993:
932: 926 0002801C # {
933: 927 0002801C # errcnt++; /* bump the error count */
934: 928 0002801C 6d effffff926 incl _errcnt
935: 929 00028022 # if ( prt_error )
936: 930 00028022 5d effffff920 tstl _prt_error
937: 931 00028028 31 0d jeql L321
938: 932 0002802A # print_pipe3_er("Cache Data, 2 NO-OPS");
939: 933 0002802A .data 1
940: 934 00000d69 * L322:
941: 935 00000d69 * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPS\0"
942: 2204E4F2D4F505300
943: 936 00000d7e * .text
944: 937 0002802A dd 8f00000d69 pushl $L322
945: 938 00028030 fe 08 ef0000047f callf $8,_print_pipe3_er
946: 939 00028037 # if ( halt_flg )
947: 940 00028037 L321:
948: 941 00028037 5d effffff90b tstl _halt_flg
949: 942 0002803D 31 0d jeql L323
950: 943 0002803F # pipe3_er_hlt( subtest );
951: 944 0002803F dd effffff903 pushl _subtest
952: 945 00028045 fe 08 ef00000576 callf $8,_pipe3_er_hlt
953: 946 0002804C # if ( loop_on_err ) {
954: 947 0002804C L323:
955: 948 0002804C 5d effffff8f6 tstl _loop_on_err
956: 949 00028052 31 0a jeql L324
957: 950 00028054 # force_loop = TRUE; /* set the force loop flag */
958: 951 00028054 0d 01 effffff8ed movl $1,_force_loop
959: 952 0002805B # asm("brw _pipe3_7_lp1"); /* and loop */
960: 953 0002805B 13 ff7c brw _pipe3_7_lp1
961: 954 0002805E # }
962: 955 0002805E # } /* end of compare error */
963: 956 0002805E L324:
964: 957 0002805E # } while( index++ < max_cvlf_1_index );
965: 958 0002805E L320:
966: 959 0002805E L317:
967: 960 0002805E 0d effffff8e4 50 movl _index,r0
968: 961 00028065 6d effffff8dd incl _index
969: 962 0002806B 1d 50 effffff8d6 cmpl r0,_max_cvlf_1_index
970: 963 00028072 81 03 13 ff2c jlss L318
971: 964 00028077 L316:
972: 965 00028077 # } /* end of subtest 7 */
973: 966 00028077 40 ret#2
974: 967 00028078 .set L312,0x0
975: 968 00028078 L314:
976: 969 00028078 13 ff1c jbr L315
977: 970 0002807B .data
978: 971 00000ce8 * .text
979: 972 0002807B 00 .align 1
980: 973 0002807C .globl _pipe3_8
981: 974 0002807C _pipe3_8:
982: 975 0002807C 0000 .word L325
983: 976 0002807E #
984: 977 0002807E #
985: 978 0002807E #
986: 979 0002807E #
987: 980 0002807E #
988: 981 0002807E #
989: 982 0002807E # /************************************************************************
990: 983 0002807E # *
991: 984 0002807E # * SUBTEST 8
992: 985 0002807E # * data in Cache, 3 NO-OPs
993: 986 0002807E # *
994: 987 0002807E # ************************************************************************/
995: 988 0002807E # pipe3_8()
996: 989 0002807E # {
997: 990 0002807E 13 00e4 jbr L327
998: 991 00028081 L328:
999: 992 00028081 # force_loop = FALSE; /* clear force_loop flag */
1000: 993 00028081 4d effffff8c1 clrl _force_loop
1001: 994 00028087 # index = 0;
1002: 995 00028087 4d effffff8bb clrl _index
1003: 996 0002808D # do
1004: 997 0002808D L331:
1005: 998 0002808D # {
1006: 999 0002808D # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
1007: 1000 0002808D 0d effffff8b5 50 movl _index,r0
1008: 1001 00028094 48 03 50 50 shll $3,r0,r0
1009: 1002 00028098 0d e000000000 effffff8a5 movl _cvlf_1_data(r0),_sgl_value_1
1010: 1003 000280A3 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
1011: 1004 000280A3 0d effffff89f 50 movl _index,r0
1012: 1005 000280AA 48 03 50 50 shll $3,r0,r0
1013: 1006 000280AE 0d e000000004 effffff88f movl _cvlf_1_data+4(r0),_sgl_expected
1014: 1007 000280B9 # sgl_value_2 = 0x40800000; /* floating '1' */
1015: 1008 000280B9 0d 8f40800000 effffff884 movl $1082130432,_sgl_value_2
1016: 1009 000280C4 # /*
1017: 1010 000280C4 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1018: 1011 000280C4 # * The force loop flag is set after the first error.
1019: 1012 000280C4 # */
1020: 1013 000280C4 # asm("_pipe3_8_lp1:");
1021: 1014 000280C4 _pipe3_8_lp1:
1022: 1015 000280C4 # asm("cvlf _sgl_value_1"); /* load (negate) the data */
1023: 1016 000280C4 76 effffff87e cvlf _sgl_value_1
1024: 1017 000280CA # asm("nop");
1025: 1018 000280CA 10 nop
1026: 1019 000280CB # asm("nop");
1027: 1020 000280CB 10 nop
1028: 1021 000280CC # asm("nop");
1029: 1022 000280CC 10 nop
1030: 1023 000280CD # asm("stf _sgl_st_acc"); /* store the result */
1031: 1024 000280CD 26 effffff875 stf _sgl_st_acc
1032: 1025 000280D3 # asm("nop");
1033: 1026 000280D3 10 nop
1034: 1027 000280D4 # asm("nop");
1035: 1028 000280D4 10 nop
1036: 1029 000280D5 # asm("nop");
1037: 1030 000280D5 10 nop
1038: 1031 000280D6 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
1039: 1032 000280D6 e6 effffff86c mulf _sgl_value_2
1040: 1033 000280DC # asm("nop");
1041: 1034 000280DC 10 nop
1042: 1035 000280DD # asm("nop");
1043: 1036 000280DD 10 nop
1044: 1037 000280DE # asm("nop");
1045: 1038 000280DE 10 nop
1046: 1039 000280DF # asm("stf _sgl_value_6"); /* store the result */
1047: 1040 000280DF 26 effffff863 stf _sgl_value_6
1048: 1041 000280E5 # if( force_loop )
1049: 1042 000280E5 5d effffff85d tstl _force_loop
1050: 1043 000280EB 31 02 jeql L332
1051: 1044 000280ED # asm("brb _pipe3_8_lp1");; /* loop on the error */
1052: 1045 000280ED 11 d5 brb _pipe3_8_lp1
1053: 1046 000280EF L332:
1054: 1047 000280EF # /*
1055: 1048 000280EF # * verify the results
1056: 1049 000280EF # */
1057: 1050 000280EF # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
1058: 1051 000280EF # (sgl_value_6 != sgl_expected) )
1059: 1052 000280EF 1d effffff853 effffff84e cmpl _sgl_st_acc,_sgl_expected
1060: 1053 000280FA 21 0d jneq L9992
1061: 1054 000280FC 1d effffff846 effffff841 cmpl _sgl_value_6,_sgl_expected
1062: 1055 00028107 31 42 jeql L333
1063: 1056 00028109 L9992:
1064: 1057 00028109 # {
1065: 1058 00028109 # errcnt++; /* bump the error count */
1066: 1059 00028109 6d effffff839 incl _errcnt
1067: 1060 0002810F # if ( prt_error )
1068: 1061 0002810F 5d effffff833 tstl _prt_error
1069: 1062 00028115 31 0d jeql L334
1070: 1063 00028117 # print_pipe3_er("Cache Data, 3 NO-OPS");
1071: 1064 00028117 .data 1
1072: 1065 00000d7e * L335:
1073: 1066 00000d7e * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPS\0"
1074: 3204E4F2D4F505300
1075: 1067 00000d93 * .text
1076: 1068 00028117 dd 8f00000d7e pushl $L335
1077: 1069 0002811D fe 08 ef00000392 callf $8,_print_pipe3_er
1078: 1070 00028124 # if ( halt_flg )
1079: 1071 00028124 L334:
1080: 1072 00028124 5d effffff81e tstl _halt_flg
1081: 1073 0002812A 31 0d jeql L336
1082: 1074 0002812C # pipe3_er_hlt( subtest );
1083: 1075 0002812C dd effffff816 pushl _subtest
1084: 1076 00028132 fe 08 ef00000489 callf $8,_pipe3_er_hlt
1085: 1077 00028139 # if ( loop_on_err ) {
1086: 1078 00028139 L336:
1087: 1079 00028139 5d effffff809 tstl _loop_on_err
1088: 1080 0002813F 31 0a jeql L337
1089: 1081 00028141 # force_loop = TRUE; /* set the force loop flag */
1090: 1082 00028141 0d 01 effffff800 movl $1,_force_loop
1091: 1083 00028148 # asm("brw _pipe3_8_lp1"); /* and loop */
1092: 1084 00028148 13 ff79 brw _pipe3_8_lp1
1093: 1085 0002814B # }
1094: 1086 0002814B # } /* end of compare error */
1095: 1087 0002814B L337:
1096: 1088 0002814B # } while( index++ < max_cvlf_1_index );
1097: 1089 0002814B L333:
1098: 1090 0002814B L330:
1099: 1091 0002814B 0d effffff7f7 50 movl _index,r0
1100: 1092 00028152 6d effffff7f0 incl _index
1101: 1093 00028158 1d 50 effffff7e9 cmpl r0,_max_cvlf_1_index
1102: 1094 0002815F 81 03 13 ff29 jlss L331
1103: 1095 00028164 L329:
1104: 1096 00028164 # } /* end of subtest 8 */
1105: 1097 00028164 40 ret#2
1106: 1098 00028165 .set L325,0x0
1107: 1099 00028165 L327:
1108: 1100 00028165 13 ff19 jbr L328
1109: 1101 00028168 .data
1110: 1102 00000ce8 * .text
1111: 1103 00028168 .align 1
1112: 1104 00028168 .globl _pipe3_9
1113: 1105 00028168 _pipe3_9:
1114: 1106 00028168 0000 .word L338
1115: 1107 0002816A #
1116: 1108 0002816A #
1117: 1109 0002816A #
1118: 1110 0002816A #
1119: 1111 0002816A #
1120: 1112 0002816A #
1121: 1113 0002816A # /*****************************************************************************
1122: 1114 0002816A # *
1123: 1115 0002816A # * SUBTEST 9
1124: 1116 0002816A # * data on the stack, no NO-OPs
1125: 1117 0002816A # *
1126: 1118 0002816A # *****************************************************************************/
1127: 1119 0002816A # pipe3_9()
1128: 1120 0002816A # {
1129: 1121 0002816A 13 017b jbr L340
1130: 1122 0002816D L341:
1131: 1123 0002816D # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1132: 1124 0002816D ed 6d effffff7d4 moval (r13),_pre_event_fp
1133: 1125 00028174 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1134: 1126 00028174 ed 6e effffff7cd moval (r14),_pre_event_sp
1135: 1127 0002817B # force_loop = FALSE; /* clear force_loop flag */
1136: 1128 0002817B 4d effffff7c7 clrl _force_loop
1137: 1129 00028181 # index = 0;
1138: 1130 00028181 4d effffff7c1 clrl _index
1139: 1131 00028187 # do
1140: 1132 00028187 L344:
1141: 1133 00028187 # {
1142: 1134 00028187 # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
1143: 1135 00028187 0d effffff7bb 50 movl _index,r0
1144: 1136 0002818E 48 03 50 50 shll $3,r0,r0
1145: 1137 00028192 0d e000000000 effffff7ab movl _cvlf_1_data(r0),_sgl_value_1
1146: 1138 0002819D # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
1147: 1139 0002819D 0d effffff7a5 50 movl _index,r0
1148: 1140 000281A4 48 03 50 50 shll $3,r0,r0
1149: 1141 000281A8 0d e000000004 effffff795 movl _cvlf_1_data+4(r0),_sgl_expected
1150: 1142 000281B3 # sgl_value_2 = 0x40800000; /* floating '1' */
1151: 1143 000281B3 0d 8f40800000 effffff78a movl $1082130432,_sgl_value_2
1152: 1144 000281BE # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1153: 1145 000281BE ed effffff784 effffff77f moval _pointer_data,_sgl_value_4
1154: 1146 000281C9 # /*
1155: 1147 000281C9 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1156: 1148 000281C9 # * The force loop flag is set after the first error.
1157: 1149 000281C9 # */
1158: 1150 000281C9 # asm("_pipe3_9_lp1:");
1159: 1151 000281C9 _pipe3_9_lp1:
1160: 1152 000281C9 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1161: 1153 000281C9 ed effffff779 5e moval _pointer_data,r14
1162: 1154 000281D0 # asm("movl _sgl_value_2,-(r14)"); /* push a floating '1' */
1163: 1155 000281D0 0d effffff772 7e movl _sgl_value_2,-(r14)
1164: 1156 000281D7 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1165: 1157 000281D7 0d effffff76b 7e movl _sgl_value_1,-(r14)
1166: 1158 000281DE # /*
1167: 1159 000281DE # * now pop the data off the stack
1168: 1160 000281DE # */
1169: 1161 000281DE #
1170: 1162 000281DE # asm("cvlf (r14)+"); /* load (negate) the data */
1171: 1163 000281DE 76 8e cvlf (r14)+
1172: 1164 000281E0 # asm("stf r5"); /* store the result */
1173: 1165 000281E0 26 55 stf r5
1174: 1166 000281E2 # asm("mulf (r14)+"); /* multipy by '1' */
1175: 1167 000281E2 e6 8e mulf (r14)+
1176: 1168 000281E4 # asm("stf r6"); /* store the result */
1177: 1169 000281E4 26 56 stf r6
1178: 1170 000281E6 # if( force_loop )
1179: 1171 000281E6 5d effffff75c tstl _force_loop
1180: 1172 000281EC 31 02 jeql L345
1181: 1173 000281EE # asm("brb _pipe3_9_lp1");; /* loop on the error */
1182: 1174 000281EE 11 d9 brb _pipe3_9_lp1
1183: 1175 000281F0 L345:
1184: 1176 000281F0 # /*
1185: 1177 000281F0 # * verify the results
1186: 1178 000281F0 # */
1187: 1179 000281F0 # asm("movl r5,_sgl_st_acc"); /* get the 1st store value */
1188: 1180 000281F0 0d 55 effffff751 movl r5,_sgl_st_acc
1189: 1181 000281F7 # asm("movl r6,_sgl_value_6"); /* get the 2nd store value */
1190: 1182 000281F7 0d 56 effffff74a movl r6,_sgl_value_6
1191: 1183 000281FE # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1192: 1184 000281FE ed 6e effffff743 moval (r14),_sgl_value_5
1193: 1185 00028205 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1194: 1186 00028205 # (sgl_value_6 != sgl_expected) ||
1195: 1187 00028205 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1196: 1188 00028205 1d effffff73d effffff738 cmpl _sgl_st_acc,_sgl_expected
1197: 1189 00028210 21 1d jneq L9991
1198: 1190 00028212 1d effffff730 effffff72b cmpl _sgl_value_6,_sgl_expected
1199: 1191 0002821D 21 10 jneq L9991
1200: 1192 0002821F 1d effffff723 effffff71e cmpl _sgl_value_5,_sgl_value_4
1201: 1193 0002822A 21 03 13 0091 jeql L346
1202: 1194 0002822F L9991:
1203: 1195 0002822F # {
1204: 1196 0002822F # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1205: 1197 0002822F 0d effffff713 5d movl _pre_event_fp,r13
1206: 1198 00028236 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1207: 1199 00028236 0d effffff70c 5e movl _pre_event_sp,r14
1208: 1200 0002823D # errcnt++; /* bump the error count */
1209: 1201 0002823D 6d effffff705 incl _errcnt
1210: 1202 00028243 # if ( prt_error ) {
1211: 1203 00028243 5d effffff6ff tstl _prt_error
1212: 1204 00028249 31 4e jeql L347
1213: 1205 0002824B # print_pipe3_er("Pop data from the STACK");
1214: 1206 0002824B .data 1
1215: 1207 00000d93 * L348:
1216: 1208 00000d93 * 506F7020646174612066726F6 .ascii "Pop data from the STACK\0"
1217: D2074686520535441434B00
1218: 1209 00000dab * .text
1219: 1210 0002824B dd 8f00000d93 pushl $L348
1220: 1211 00028251 fe 08 ef0000025e callf $8,_print_pipe3_er
1221: 1212 00028258 # writes("final Stack Pointer = ");
1222: 1213 00028258 .data 1
1223: 1214 00000dab * L349:
1224: 1215 00000dab * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
1225: 06F696E746572203D2000
1226: 1216 00000dc2 * .text
1227: 1217 00028258 dd 8f00000dab pushl $L349
1228: 1218 0002825E fe 08 effffff6e3 callf $8,_writes
1229: 1219 00028265 # write32h( sgl_value_5 );
1230: 1220 00028265 dd effffff6dd pushl _sgl_value_5
1231: 1221 0002826B fe 08 effffff6d6 callf $8,_write32h
1232: 1222 00028272 # writes(", expected = ");
1233: 1223 00028272 .data 1
1234: 1224 00000dc2 * L351:
1235: 1225 00000dc2 * 2C20206578706563746564203 .ascii ", expected = \0"
1236: D2000
1237: 1226 00000dd1 * .text
1238: 1227 00028272 dd 8f00000dc2 pushl $L351
1239: 1228 00028278 fe 08 effffff6c9 callf $8,_writes
1240: 1229 0002827F # write32h( sgl_value_4 );
1241: 1230 0002827F dd effffff6c3 pushl _sgl_value_4
1242: 1231 00028285 fe 08 effffff6bc callf $8,_write32h
1243: 1232 0002828C # writes(" \n");
1244: 1233 0002828C .data 1
1245: 1234 00000dd1 * L352:
1246: 1235 00000dd1 * 200A00 .ascii " \12\0"
1247: 1236 00000dd4 * .text
1248: 1237 0002828C dd 8f00000dd1 pushl $L352
1249: 1238 00028292 fe 08 effffff6af callf $8,_writes
1250: 1239 00028299 # }
1251: 1240 00028299 # if ( halt_flg )
1252: 1241 00028299 L347:
1253: 1242 00028299 5d effffff6a9 tstl _halt_flg
1254: 1243 0002829F 31 0d jeql L353
1255: 1244 000282A1 # pipe3_er_hlt( subtest );
1256: 1245 000282A1 dd effffff6a1 pushl _subtest
1257: 1246 000282A7 fe 08 ef00000314 callf $8,_pipe3_er_hlt
1258: 1247 000282AE # if ( loop_on_err ) {
1259: 1248 000282AE L353:
1260: 1249 000282AE 5d effffff694 tstl _loop_on_err
1261: 1250 000282B4 31 0a jeql L354
1262: 1251 000282B6 # force_loop = TRUE; /* set the force loop flag */
1263: 1252 000282B6 0d 01 effffff68b movl $1,_force_loop
1264: 1253 000282BD # asm("brw _pipe3_9_lp1"); /* and loop */
1265: 1254 000282BD 13 ff09 brw _pipe3_9_lp1
1266: 1255 000282C0 # }
1267: 1256 000282C0 # } /* end of compare error */
1268: 1257 000282C0 L354:
1269: 1258 000282C0 # } while( index++ < max_cvlf_1_index );
1270: 1259 000282C0 L346:
1271: 1260 000282C0 L343:
1272: 1261 000282C0 0d effffff682 50 movl _index,r0
1273: 1262 000282C7 6d effffff67b incl _index
1274: 1263 000282CD 1d 50 effffff674 cmpl r0,_max_cvlf_1_index
1275: 1264 000282D4 81 03 13 feae jlss L344
1276: 1265 000282D9 L342:
1277: 1266 000282D9 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1278: 1267 000282D9 0d effffff669 5d movl _pre_event_fp,r13
1279: 1268 000282E0 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1280: 1269 000282E0 0d effffff662 5e movl _pre_event_sp,r14
1281: 1270 000282E7 # } /* end of subtest 9 */
1282: 1271 000282E7 40 ret#2
1283: 1272 000282E8 .set L338,0x0
1284: 1273 000282E8 L340:
1285: 1274 000282E8 13 fe82 jbr L341
1286: 1275 000282EB .data
1287: 1276 00000ce8 * .text
1288: 1277 000282EB 00 .align 1
1289: 1278 000282EC .globl _pipe3_10
1290: 1279 000282EC _pipe3_10:
1291: 1280 000282EC 0000 .word L355
1292: 1281 000282EE #
1293: 1282 000282EE #
1294: 1283 000282EE #
1295: 1284 000282EE #
1296: 1285 000282EE #
1297: 1286 000282EE #
1298: 1287 000282EE # /******************************************************************************
1299: 1288 000282EE # *
1300: 1289 000282EE # * SUBTEST 10
1301: 1290 000282EE # * get data via indexed FRAME pointer
1302: 1291 000282EE # *
1303: 1292 000282EE # * ADDR INDEX DATA
1304: 1293 000282EE # * pointer_data 4 <the 1st STF result goes here>
1305: 1294 000282EE # * pointer_data-4 3 <the 2nd STF result goes here>
1306: 1295 000282EE # * pointer_data-8 2 <operand data>
1307: 1296 000282EE # * pointer_data-12 1 <floating '1'>
1308: 1297 000282EE # * pointer_data-16 0 point the frame pointer here
1309: 1298 000282EE # *
1310: 1299 000282EE # ******************************************************************************/
1311: 1300 000282EE # pipe3_10()
1312: 1301 000282EE # {
1313: 1302 000282EE 13 01c2 jbr L357
1314: 1303 000282F1 L358:
1315: 1304 000282F1 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1316: 1305 000282F1 ed 6d effffff650 moval (r13),_pre_event_fp
1317: 1306 000282F8 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1318: 1307 000282F8 ed 6e effffff649 moval (r14),_pre_event_sp
1319: 1308 000282FF # force_loop = FALSE; /* clear force_loop flag */
1320: 1309 000282FF 4d effffff643 clrl _force_loop
1321: 1310 00028305 # index = 0;
1322: 1311 00028305 4d effffff63d clrl _index
1323: 1312 0002830B # do
1324: 1313 0002830B L361:
1325: 1314 0002830B # {
1326: 1315 0002830B # sgl_value_1 = cvlf_1_data[index].ld; /* get operand 1 */
1327: 1316 0002830B 0d effffff637 50 movl _index,r0
1328: 1317 00028312 48 03 50 50 shll $3,r0,r0
1329: 1318 00028316 0d e000000000 effffff627 movl _cvlf_1_data(r0),_sgl_value_1
1330: 1319 00028321 # sgl_expected = cvlf_1_data[index].exp; /* get expected results */
1331: 1320 00028321 0d effffff621 50 movl _index,r0
1332: 1321 00028328 48 03 50 50 shll $3,r0,r0
1333: 1322 0002832C 0d e000000004 effffff611 movl _cvlf_1_data+4(r0),_sgl_expected
1334: 1323 00028337 # sgl_value_2 = 0x40800000; /* floating '1' */
1335: 1324 00028337 0d 8f40800000 effffff606 movl $1082130432,_sgl_value_2
1336: 1325 00028342 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
1337: 1326 00028342 ed effffff600 effffff5fb moval _pointer_data,_sgl_value_4
1338: 1327 0002834D # sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/
1339: 1328 0002834D 2c 08 effffff5f4 subl2 $8,_sgl_value_4
1340: 1329 00028354 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
1341: 1330 00028354 0d effffff5ee fffffff5e9 movl _sgl_value_1,*_sgl_value_4
1342: 1331 0002835F # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1343: 1332 0002835F 2c 04 effffff5e2 subl2 $4,_sgl_value_4
1344: 1333 00028366 # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '1' */
1345: 1334 00028366 0d effffff5dc fffffff5d7 movl _sgl_value_2,*_sgl_value_4
1346: 1335 00028371 # sgl_value_4 -= 4; /* get FRAME PTR address */
1347: 1336 00028371 2c 04 effffff5d0 subl2 $4,_sgl_value_4
1348: 1337 00028378 # /*
1349: 1338 00028378 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1350: 1339 00028378 # * The force loop flag is set after the first error.
1351: 1340 00028378 # */
1352: 1341 00028378 # asm("_pipe3_10_lp1:");
1353: 1342 00028378 _pipe3_10_lp1:
1354: 1343 00028378 # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1355: 1344 00028378 0d effffff5ca 5d movl _sgl_value_4,r13
1356: 1345 0002837F # asm("movl $1,r1"); /* r1 index = 1 longwords */
1357: 1346 0002837F 0d 01 51 movl $1,r1
1358: 1347 00028382 # asm("movl $2,r2"); /* r2 index = 2 longwords */
1359: 1348 00028382 0d 02 52 movl $2,r2
1360: 1349 00028385 # asm("movl $3,r3"); /* r3 index = 3 longwords */
1361: 1350 00028385 0d 03 53 movl $3,r3
1362: 1351 00028388 # asm("movl $4,r4"); /* r4 index = 4 longwords */
1363: 1352 00028388 0d 04 54 movl $4,r4
1364: 1353 0002838B # asm("cvlf (r13)[r2]"); /* load the op (indx = 2) */
1365: 1354 0002838B 76 426d cvlf (r13)[r2]
1366: 1355 0002838E # asm("stf (r13)[r4]"); /* store -indexed by r4 */
1367: 1356 0002838E 26 446d stf (r13)[r4]
1368: 1357 00028391 # asm("mulf (r13)[r1]"); /* multiply by '1' (indx=1) */
1369: 1358 00028391 e6 416d mulf (r13)[r1]
1370: 1359 00028394 # asm("stf (r13)[r3]"); /* store -indexed by r3 */
1371: 1360 00028394 26 436d stf (r13)[r3]
1372: 1361 00028397 # if( force_loop )
1373: 1362 00028397 5d effffff5ab tstl _force_loop
1374: 1363 0002839D 31 02 jeql L362
1375: 1364 0002839F # asm("brb _pipe3_10_lp1");; /* loop on the error */
1376: 1365 0002839F 11 d7 brb _pipe3_10_lp1
1377: 1366 000283A1 L362:
1378: 1367 000283A1 # /*
1379: 1368 000283A1 # * verify the results
1380: 1369 000283A1 # */
1381: 1370 000283A1 # sgl_st_acc = pointer_data; /* save 1st stored value */
1382: 1371 000283A1 0d effffff5a1 effffff59c movl _pointer_data,_sgl_st_acc
1383: 1372 000283AC # asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */
1384: 1373 000283AC ed effffff596 effffff591 moval _pointer_data,_sgl_value_5
1385: 1374 000283B7 # sgl_value_5 -= 4; /* decrement by 4 (bytes) */
1386: 1375 000283B7 2c 04 effffff58a subl2 $4,_sgl_value_5
1387: 1376 000283BE # asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */
1388: 1377 000283BE 0d fffffff584 effffff57f movl *_sgl_value_5,_sgl_value_6
1389: 1378 000283C9 # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1390: 1379 000283C9 ed 6d effffff578 moval (r13),_sgl_value_5
1391: 1380 000283D0 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1392: 1381 000283D0 # (sgl_value_6 != sgl_expected) ||
1393: 1382 000283D0 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1394: 1383 000283D0 1d effffff572 effffff56d cmpl _sgl_st_acc,_sgl_expected
1395: 1384 000283DB 21 1d jneq L9990
1396: 1385 000283DD 1d effffff565 effffff560 cmpl _sgl_value_6,_sgl_expected
1397: 1386 000283E8 21 10 jneq L9990
1398: 1387 000283EA 1d effffff558 effffff553 cmpl _sgl_value_5,_sgl_value_4
1399: 1388 000283F5 21 03 13 0091 jeql L363
1400: 1389 000283FA L9990:
1401: 1390 000283FA # {
1402: 1391 000283FA # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1403: 1392 000283FA 0d effffff548 5d movl _pre_event_fp,r13
1404: 1393 00028401 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1405: 1394 00028401 0d effffff541 5e movl _pre_event_sp,r14
1406: 1395 00028408 # errcnt++; /* bump the error count */
1407: 1396 00028408 6d effffff53a incl _errcnt
1408: 1397 0002840E # if ( prt_error ) {
1409: 1398 0002840E 5d effffff534 tstl _prt_error
1410: 1399 00028414 31 4e jeql L364
1411: 1400 00028416 # print_pipe3_er("indexed FP addressing");
1412: 1401 00028416 .data 1
1413: 1402 00000dd4 * L365:
1414: 1403 00000dd4 * 696E646578656420465020616 .ascii "indexed FP addressing\0"
1415: 46472657373696E6700
1416: 1404 00000dea * .text
1417: 1405 00028416 dd 8f00000dd4 pushl $L365
1418: 1406 0002841C fe 08 ef00000093 callf $8,_print_pipe3_er
1419: 1407 00028423 # writes("final Frame Pointer = ");
1420: 1408 00028423 .data 1
1421: 1409 00000dea * L366:
1422: 1410 00000dea * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
1423: 06F696E746572203D2000
1424: 1411 00000e01 * .text
1425: 1412 00028423 dd 8f00000dea pushl $L366
1426: 1413 00028429 fe 08 effffff518 callf $8,_writes
1427: 1414 00028430 # writeh( sgl_value_5 );
1428: 1415 00028430 dd effffff512 pushl _sgl_value_5
1429: 1416 00028436 fe 08 effffff50b callf $8,_writeh
1430: 1417 0002843D # writes(", expected FP = ");
1431: 1418 0002843D .data 1
1432: 1419 00000e01 * L368:
1433: 1420 00000e01 * 2C20206578706563746564204 .ascii ", expected FP = \0"
1434: 650203D2000
1435: 1421 00000e13 * .text
1436: 1422 0002843D dd 8f00000e01 pushl $L368
1437: 1423 00028443 fe 08 effffff4fe callf $8,_writes
1438: 1424 0002844A # writeh( sgl_value_4 );
1439: 1425 0002844A dd effffff4f8 pushl _sgl_value_4
1440: 1426 00028450 fe 08 effffff4f1 callf $8,_writeh
1441: 1427 00028457 # writes(" \n");
1442: 1428 00028457 .data 1
1443: 1429 00000e13 * L369:
1444: 1430 00000e13 * 200A00 .ascii " \12\0"
1445: 1431 00000e16 * .text
1446: 1432 00028457 dd 8f00000e13 pushl $L369
1447: 1433 0002845D fe 08 effffff4e4 callf $8,_writes
1448: 1434 00028464 # }
1449: 1435 00028464 # if ( halt_flg )
1450: 1436 00028464 L364:
1451: 1437 00028464 5d effffff4de tstl _halt_flg
1452: 1438 0002846A 31 0d jeql L370
1453: 1439 0002846C # pipe3_er_hlt( subtest );
1454: 1440 0002846C dd effffff4d6 pushl _subtest
1455: 1441 00028472 fe 08 ef00000149 callf $8,_pipe3_er_hlt
1456: 1442 00028479 # if ( loop_on_err ) {
1457: 1443 00028479 L370:
1458: 1444 00028479 5d effffff4c9 tstl _loop_on_err
1459: 1445 0002847F 31 0a jeql L371
1460: 1446 00028481 # force_loop = TRUE; /* set the force loop flag */
1461: 1447 00028481 0d 01 effffff4c0 movl $1,_force_loop
1462: 1448 00028488 # asm("brw _pipe3_10_lp1"); /* and loop */
1463: 1449 00028488 13 feed brw _pipe3_10_lp1
1464: 1450 0002848B # }
1465: 1451 0002848B # } /* end of compare error */
1466: 1452 0002848B L371:
1467: 1453 0002848B # } while( index++ < max_cvlf_1_index );
1468: 1454 0002848B L363:
1469: 1455 0002848B L360:
1470: 1456 0002848B 0d effffff4b7 50 movl _index,r0
1471: 1457 00028492 6d effffff4b0 incl _index
1472: 1458 00028498 1d 50 effffff4a9 cmpl r0,_max_cvlf_1_index
1473: 1459 0002849F 81 03 13 fe67 jlss L361
1474: 1460 000284A4 L359:
1475: 1461 000284A4 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1476: 1462 000284A4 0d effffff49e 5d movl _pre_event_fp,r13
1477: 1463 000284AB # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1478: 1464 000284AB 0d effffff497 5e movl _pre_event_sp,r14
1479: 1465 000284B2 # } /* end of subtest 10 */
1480: 1466 000284B2 40 ret#2
1481: 1467 000284B3 .set L355,0x0
1482: 1468 000284B3 L357:
1483: 1469 000284B3 13 fe3b jbr L358
1484: 1470 000284B6 .data
1485: 1471 00000ce8 * .text
1486: 1472 000284B6 .align 1
1487: 1473 000284B6 .globl _print_pipe3_er
1488: 1474 000284B6 _print_pipe3_er:
1489: 1475 000284B6 0000 .word L372
1490: 1476 000284B8 #
1491: 1477 000284B8 #
1492: 1478 000284B8 # /******************************************************************************
1493: 1479 000284B8 # *
1494: 1480 000284B8 # *
1495: 1481 000284B8 # * print an error in the following form
1496: 1482 000284B8 # *
1497: 1483 000284B8 # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd
1498: 1484 000284B8 # * expected Acc = xxxxxxxx
1499: 1485 000284B8 # *
1500: 1486 000284B8 # ******************************************************************************/
1501: 1487 000284B8 # print_pipe3_er(msg)
1502: 1488 000284B8 # char *msg;
1503: 1489 000284B8 # {
1504: 1490 000284B8 13 0103 jbr L374
1505: 1491 000284BB L375:
1506: 1492 000284BB # writes(" \n"); /* start a new print line */
1507: 1493 000284BB .data 1
1508: 1494 00000e16 * L376:
1509: 1495 00000e16 * 200A00 .ascii " \12\0"
1510: 1496 00000e19 * .text
1511: 1497 000284BB dd 8f00000e16 pushl $L376
1512: 1498 000284C1 fe 08 effffff480 callf $8,_writes
1513: 1499 000284C8 # writes("cycle: ");
1514: 1500 000284C8 .data 1
1515: 1501 00000e19 * L377:
1516: 1502 00000e19 * 6379636C653A2000 .ascii "cycle: \0"
1517: 1503 00000e21 * .text
1518: 1504 000284C8 dd 8f00000e19 pushl $L377
1519: 1505 000284CE fe 08 effffff473 callf $8,_writes
1520: 1506 000284D5 # writed( cycle );
1521: 1507 000284D5 dd effffff46d pushl _cycle
1522: 1508 000284DB fe 08 effffff466 callf $8,_writed
1523: 1509 000284E2 # writes(" test ");
1524: 1510 000284E2 .data 1
1525: 1511 00000e21 * L379:
1526: 1512 00000e21 * 20746573742000 .ascii " test \0"
1527: 1513 00000e28 * .text
1528: 1514 000284E2 dd 8f00000e21 pushl $L379
1529: 1515 000284E8 fe 08 effffff459 callf $8,_writes
1530: 1516 000284EF # writed( test_no );
1531: 1517 000284EF dd effffff453 pushl _test_no
1532: 1518 000284F5 fe 08 effffff44c callf $8,_writed
1533: 1519 000284FC # writes(" (Pipe 3), subtest ");
1534: 1520 000284FC .data 1
1535: 1521 00000e28 * L380:
1536: 1522 00000e28 * 202028506970652033292C207 .ascii " (Pipe 3), subtest \0"
1537: 37562746573742000
1538: 1523 00000e3d * .text
1539: 1524 000284FC dd 8f00000e28 pushl $L380
1540: 1525 00028502 fe 08 effffff43f callf $8,_writes
1541: 1526 00028509 # writed( subtest );
1542: 1527 00028509 dd effffff439 pushl _subtest
1543: 1528 0002850F fe 08 effffff432 callf $8,_writed
1544: 1529 00028516 # writes(" error - ");
1545: 1530 00028516 .data 1
1546: 1531 00000e3d * L381:
1547: 1532 00000e3d * 206572726F72202D2000 .ascii " error - \0"
1548: 1533 00000e47 * .text
1549: 1534 00028516 dd 8f00000e3d pushl $L381
1550: 1535 0002851C fe 08 effffff425 callf $8,_writes
1551: 1536 00028523 # writes( msg );
1552: 1537 00028523 dd ad04 pushl 4(fp)
1553: 1538 00028526 fe 08 effffff41b callf $8,_writes
1554: 1539 0002852D # writec('\n');
1555: 1540 0002852D dd 0a pushl $10
1556: 1541 0002852F fe 08 effffff412 callf $8,_writec
1557: 1542 00028536 # writes(" CVLF(op), STF, MULF(1.0), STF\n");
1558: 1543 00028536 .data 1
1559: 1544 00000e47 * L383:
1560: 1545 00000e47 * 2043564C46286F70292C20535 .ascii " CVLF(op), STF, MULF(1.0), STF\12\0"
1561: 4462C204D554C4628312E3029
1562: 2C205354460A00
1563: 1546 00000e67 * .text
1564: 1547 00028536 dd 8f00000e47 pushl $L383
1565: 1548 0002853C fe 08 effffff405 callf $8,_writes
1566: 1549 00028543 # writes("operand = ");
1567: 1550 00028543 .data 1
1568: 1551 00000e67 * L384:
1569: 1552 00000e67 * 6F706572616E64203D2000 .ascii "operand = \0"
1570: 1553 00000e72 * .text
1571: 1554 00028543 dd 8f00000e67 pushl $L384
1572: 1555 00028549 fe 08 effffff3f8 callf $8,_writes
1573: 1556 00028550 # write32h( sgl_value_1 );
1574: 1557 00028550 dd effffff3f2 pushl _sgl_value_1
1575: 1558 00028556 fe 08 effffff3eb callf $8,_write32h
1576: 1559 0002855D # writes(", final Acc = ");
1577: 1560 0002855D .data 1
1578: 1561 00000e72 * L385:
1579: 1562 00000e72 * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
1580: 3203D2000
1581: 1563 00000e83 * .text
1582: 1564 0002855D dd 8f00000e72 pushl $L385
1583: 1565 00028563 fe 08 effffff3de callf $8,_writes
1584: 1566 0002856A # write32h( sgl_st_acc );
1585: 1567 0002856A dd effffff3d8 pushl _sgl_st_acc
1586: 1568 00028570 fe 08 effffff3d1 callf $8,_write32h
1587: 1569 00028577 # writes(", data index = ");
1588: 1570 00028577 .data 1
1589: 1571 00000e83 * L386:
1590: 1572 00000e83 * 2C2020206461746120696E646 .ascii ", data index = \0"
1591: 578203D2000
1592: 1573 00000e95 * .text
1593: 1574 00028577 dd 8f00000e83 pushl $L386
1594: 1575 0002857D fe 08 effffff3c4 callf $8,_writes
1595: 1576 00028584 # writed( index );
1596: 1577 00028584 dd effffff3be pushl _index
1597: 1578 0002858A fe 08 effffff3b7 callf $8,_writed
1598: 1579 00028591 # writec('\n');
1599: 1580 00028591 dd 0a pushl $10
1600: 1581 00028593 fe 08 effffff3ae callf $8,_writec
1601: 1582 0002859A # writes(" expected Acc = ");
1602: 1583 0002859A .data 1
1603: 1584 00000e95 * L387:
1604: 1585 00000e95 * 2020202020202020202020202 .ascii " expected Acc = \0"
1605: 0202020202020657870656374
1606: 656420416363203D2000
1607: 1586 00000eb8 * .text
1608: 1587 0002859A dd 8f00000e95 pushl $L387
1609: 1588 000285A0 fe 08 effffff3a1 callf $8,_writes
1610: 1589 000285A7 # write32h( sgl_expected );
1611: 1590 000285A7 dd effffff39b pushl _sgl_expected
1612: 1591 000285AD fe 08 effffff394 callf $8,_write32h
1613: 1592 000285B4 # writec('\n');
1614: 1593 000285B4 dd 0a pushl $10
1615: 1594 000285B6 fe 08 effffff38b callf $8,_writec
1616: 1595 000285BD # }
1617: 1596 000285BD 40 ret#2
1618: 1597 000285BE .set L372,0x0
1619: 1598 000285BE L374:
1620: 1599 000285BE 13 fefa jbr L375
1621: 1600 000285C1 .data
1622: 1601 00000ce8 * .text
1623: 1602 000285C1 00 .align 1
1624: 1603 000285C2 .globl _pipe3_er_hlt
1625: 1604 000285C2 _pipe3_er_hlt:
1626: 1605 000285C2 0000 .word L388
1627: 1606 000285C4 #
1628: 1607 000285C4 #
1629: 1608 000285C4 #
1630: 1609 000285C4 #
1631: 1610 000285C4 #
1632: 1611 000285C4 # /******************************************************************************
1633: 1612 000285C4 # *
1634: 1613 000285C4 # * HALT ON ERROR ROUTINE
1635: 1614 000285C4 # *
1636: 1615 000285C4 # * halt with the necessary information saved in the registers
1637: 1616 000285C4 # *
1638: 1617 000285C4 # ******************************************************************************/
1639: 1618 000285C4 # pipe3_er_hlt( subtest )
1640: 1619 000285C4 # int subtest;
1641: 1620 000285C4 # {
1642: 1621 000285C4 11 67 jbr L390
1643: 1622 000285C6 L391:
1644: 1623 000285C6 # asm("movl _test_no,r0"); /* r0 = test number */
1645: 1624 000285C6 0d effffff37c 50 movl _test_no,r0
1646: 1625 000285CD # asm("movl _subtest,r1"); /* r1 = subtest number */
1647: 1626 000285CD 0d effffff375 51 movl _subtest,r1
1648: 1627 000285D4 # asm("movl $1,r2"); /* r2 = error code */
1649: 1628 000285D4 0d 01 52 movl $1,r2
1650: 1629 000285D7 # asm("movl _cycle,r3"); /* r3 = cycle count */
1651: 1630 000285D7 0d effffff36b 53 movl _cycle,r3
1652: 1631 000285DE # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1653: 1632 000285DE 0d effffff364 54 movl _sgl_value_1,r4
1654: 1633 000285E5 # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */
1655: 1634 000285E5 0d effffff35d 55 movl _sgl_st_acc,r5
1656: 1635 000285EC # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */
1657: 1636 000285EC 0d effffff356 56 movl _sgl_expected,r6
1658: 1637 000285F3 # asm("movl _index,r7"); /* r7 = data index */
1659: 1638 000285F3 0d effffff34f 57 movl _index,r7
1660: 1639 000285FA # asm("movl _sgl_value_2,r8"); /* r8 = floating one */
1661: 1640 000285FA 0d effffff348 58 movl _sgl_value_2,r8
1662: 1641 00028601 # if( subtest == 9 ) {
1663: 1642 00028601 1d ad04 09 cmpl 4(fp),$9
1664: 1643 00028605 21 10 jneq L392
1665: 1644 00028607 # asm("movl _sgl_value_5,r9"); /* r9 = final SP value */
1666: 1645 00028607 0d effffff33b 59 movl _sgl_value_5,r9
1667: 1646 0002860E # asm("movl _sgl_value_4,r10"); /* r10= expected SP value */
1668: 1647 0002860E 0d effffff334 5a movl _sgl_value_4,r10
1669: 1648 00028615 # } else
1670: 1649 00028615 11 14 jbr L393
1671: 1650 00028617 L392:
1672: 1651 00028617 # if( subtest == 10 ) {
1673: 1652 00028617 1d ad04 0a cmpl 4(fp),$10
1674: 1653 0002861B 21 0e jneq L394
1675: 1654 0002861D # asm("movl _sgl_value_5,r9"); /* r9 = final FP value */
1676: 1655 0002861D 0d effffff325 59 movl _sgl_value_5,r9
1677: 1656 00028624 # asm("movl _sgl_value_4,r10"); /* r10= expected FP value */
1678: 1657 00028624 0d effffff31e 5a movl _sgl_value_4,r10
1679: 1658 0002862B # };
1680: 1659 0002862B L394:
1681: 1660 0002862B L393:
1682: 1661 0002862B # asm(".globl _pipe3_1_hlt");
1683: 1662 0002862B .globl _pipe3_1_hlt
1684: 1663 0002862B # asm("_pipe3_1_hlt:"); /* PC after the halt */
1685: 1664 0002862B _pipe3_1_hlt:
1686: 1665 0002862B # asm("halt"); /* HALT ... */
1687: 1666 0002862B 00 halt
1688: 1667 0002862C # } /* end of halt on error */
1689: 1668 0002862C 40 ret#2
1690: 1669 0002862D .set L388,0x0
1691: 1670 0002862D L390:
1692: 1671 0002862D 11 97 jbr L391
1693: 1672 0002862F .data
1694: 1672 0004FF77 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.