![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe5.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 pipe5.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 00000d0c * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_5
6: 6 00000000 _pipe_5:
7: 7 000293A8 0000 .word L215
8: 8 000293AA # #include "fpp_defs.h"
9: 9 000293AA #
10: 10 000293AA #
11: 11 000293AA # /*****************************************************************************
12: 12 000293AA # *
13: 13 000293AA # * PIPELINE TEST #5 MONITOR
14: 14 000293AA # *
15: 15 000293AA # * This test will do:
16: 16 000293AA # *
17: 17 000293AA # * LNF(x) STF LNF(0) SUBF(x) STF
18: 18 000293AA # *
19: 19 000293AA # * where x is the fmacro1 LNF data. This test verifies the store after the
20: 20 000293AA # * LNF and the LNF after the store.
21: 21 000293AA # *****************************************************************************/
22: 22 000293AA # pipe_5()
23: 23 000293AA # {
24: 24 000293AA 13 00a8 jbr L217
25: 25 000293AD L218:
26: 26 000293AD # asm(".globl _pipeline_5_t");
27: 27 000293AD .globl _pipeline_5_t
28: 28 000293AD # asm("_pipeline_5_t:"); /* entry address */
29: 29 000293AD _pipeline_5_t:
30: 30 000293AD # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
31: 31 000293AD 1d effffffff5 01 cmpl _cycle,$1
32: 32 000293B4 21 15 jneq L219
33: 33 000293B6 5d efffffffec tstl _prt_hdrs
34: 34 000293BC 31 0d jeql L219
35: 35 000293BE # {
36: 36 000293BE # writes(" PIPE_5 ");
37: 37 000293BE .data 1
38: 38 00000d0c * L221:
39: 39 00000d0c * 20504950455F352000 .ascii " PIPE_5 \0"
40: 40 00000d15 * .text
41: 41 000293BE dd 8f00000d0c pushl $L221
42: 42 000293C4 fe 08 efffffffdd callf $8,_writes
43: 43 000293CB # }
44: 44 000293CB # subtest = 1;
45: 45 000293CB L219:
46: 46 000293CB 0d 01 efffffffd6 movl $1,_subtest
47: 47 000293D2 # pipe5_1(); /* data in REGs, no NOPs */
48: 48 000293D2 fe 04 ef0000007f callf $4,_pipe5_1
49: 49 000293D9 # subtest++; /* increment subtest num */
50: 50 000293D9 6d efffffffc9 incl _subtest
51: 51 000293DF # pipe5_2(); /* data in REGs, 1 NOP */
52: 52 000293DF fe 04 ef0000015e callf $4,_pipe5_2
53: 53 000293E6 # subtest++; /* increment subtest num */
54: 54 000293E6 6d efffffffbc incl _subtest
55: 55 000293EC # pipe5_3(); /* data in REGs, 2 NOPs */
56: 56 000293EC fe 04 ef00000241 callf $4,_pipe5_3
57: 57 000293F3 # subtest++; /* increment subtest num */
58: 58 000293F3 6d efffffffaf incl _subtest
59: 59 000293F9 # pipe5_4(); /* data in REGs, 3 NOPs */
60: 60 000293F9 fe 04 ef00000328 callf $4,_pipe5_4
61: 61 00029400 # subtest++; /* increment subtest num */
62: 62 00029400 6d efffffffa2 incl _subtest
63: 63 00029406 # pipe5_5(); /* data in CACHE, no NOPs */
64: 64 00029406 fe 04 ef00000413 callf $4,_pipe5_5
65: 65 0002940D # subtest++; /* increment subtest num */
66: 66 0002940D 6d efffffff95 incl _subtest
67: 67 00029413 # pipe5_6(); /* data in CACHE, 1 NOP */
68: 68 00029413 fe 04 ef000004ea callf $4,_pipe5_6
69: 69 0002941A # subtest++; /* increment subtest num */
70: 70 0002941A 6d efffffff88 incl _subtest
71: 71 00029420 # pipe5_7(); /* data in CACHE, 2 NOPs */
72: 72 00029420 fe 04 ef000005c5 callf $4,_pipe5_7
73: 73 00029427 # subtest++; /* increment subtest num */
74: 74 00029427 6d efffffff7b incl _subtest
75: 75 0002942D # pipe5_8(); /* data in CACHE, 3 NOPs */
76: 76 0002942D fe 04 ef000006a4 callf $4,_pipe5_8
77: 77 00029434 # subtest++; /* increment subtest num */
78: 78 00029434 6d efffffff6e incl _subtest
79: 79 0002943A # pipe5_9(); /* data on STACK, no NOPs */
80: 80 0002943A fe 04 ef00000787 callf $4,_pipe5_9
81: 81 00029441 # subtest++; /* increment subtest num */
82: 82 00029441 6d efffffff61 incl _subtest
83: 83 00029447 # pipe5_10(); /* data via FP no NOPs */
84: 84 00029447 fe 04 ef00000902 callf $4,_pipe5_10
85: 85 0002944E # asm("jmp *return"); /* return to the test monitor */
86: 86 0002944E 71 ffffffff54 jmp *return
87: 87 00029454 # }
88: 88 00029454 40 ret#2
89: 89 00029455 .set L215,0x0
90: 90 00029455 L217:
91: 91 00029455 13 ff55 jbr L218
92: 92 00029458 .data
93: 93 00000d0c * .text
94: 94 00029458 .align 1
95: 95 00029458 .globl _pipe5_1
96: 96 00029458 _pipe5_1:
97: 97 00029458 0000 .word L232
98: 98 0002945A #
99: 99 0002945A #
100: 100 0002945A #
101: 101 0002945A #
102: 102 0002945A #
103: 103 0002945A #
104: 104 0002945A # /************************************************************************
105: 105 0002945A # *
106: 106 0002945A # * SUBTEST 1
107: 107 0002945A # * data in registers, no NO-OPs
108: 108 0002945A # *
109: 109 0002945A # ************************************************************************/
110: 110 0002945A # pipe5_1()
111: 111 0002945A # {
112: 112 0002945A 13 00e4 jbr L234
113: 113 0002945D L235:
114: 114 0002945D # force_loop = FALSE; /* clear force_loop flag */
115: 115 0002945D 4d efffffff45 clrl _force_loop
116: 116 00029463 # index = 0;
117: 117 00029463 4d efffffff3f clrl _index
118: 118 00029469 # do
119: 119 00029469 L238:
120: 120 00029469 # {
121: 121 00029469 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
122: 122 00029469 0d efffffff39 50 movl _index,r0
123: 123 00029470 48 03 50 50 shll $3,r0,r0
124: 124 00029474 0d e000000000 efffffff29 movl _lnf_1_data(r0),_sgl_value_1
125: 125 0002947F # sgl_expected = lnf_1_data[index].exp; /* get expected results */
126: 126 0002947F 0d efffffff23 50 movl _index,r0
127: 127 00029486 48 03 50 50 shll $3,r0,r0
128: 128 0002948A 0d e000000004 efffffff13 movl _lnf_1_data+4(r0),_sgl_expected
129: 129 00029495 # sgl_value_2 = 0; /* floating '0' */
130: 130 00029495 4d efffffff0d clrl _sgl_value_2
131: 131 0002949B # /*
132: 132 0002949B # * If LOOP ON ERROR is set, this is the loop for this subtest.
133: 133 0002949B # * The force loop flag is set after the first error.
134: 134 0002949B # */
135: 135 0002949B # asm("_pipe5_1_lp1:");
136: 136 0002949B _pipe5_1_lp1:
137: 137 0002949B # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
138: 138 0002949B 0d efffffff07 54 movl _sgl_value_1,r4
139: 139 000294A2 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
140: 140 000294A2 0d efffffff00 55 movl _sgl_value_2,r5
141: 141 000294A9 # asm("lnf r4"); /* load the operand */
142: 142 000294A9 16 54 lnf r4
143: 143 000294AB # asm("stf r7"); /* store the result */
144: 144 000294AB 26 57 stf r7
145: 145 000294AD # asm("lnf r5"); /* load a floating '0' */
146: 146 000294AD 16 55 lnf r5
147: 147 000294AF # asm("subf r4"); /* subtract the operand */
148: 148 000294AF d6 54 subf r4
149: 149 000294B1 # asm("stf r8"); /* store the result */
150: 150 000294B1 26 58 stf r8
151: 151 000294B3 # if( force_loop )
152: 152 000294B3 5d effffffeef tstl _force_loop
153: 153 000294B9 31 02 jeql L239
154: 154 000294BB # asm("brb _pipe5_1_lp1");; /* loop on the error */
155: 155 000294BB 11 de brb _pipe5_1_lp1
156: 156 000294BD L239:
157: 157 000294BD # /*
158: 158 000294BD # * verify the results
159: 159 000294BD # */
160: 160 000294BD # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
161: 161 000294BD 0d 57 effffffee4 movl r7,_sgl_st_acc
162: 162 000294C4 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
163: 163 000294C4 0d 58 effffffedd movl r8,_sgl_value_6
164: 164 000294CB # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
165: 165 000294CB # (sgl_value_6 != sgl_expected) )
166: 166 000294CB 1d effffffed7 effffffed2 cmpl _sgl_st_acc,_sgl_expected
167: 167 000294D6 21 0d jneq L9999
168: 168 000294D8 1d effffffeca effffffec5 cmpl _sgl_value_6,_sgl_expected
169: 169 000294E3 31 42 jeql L240
170: 170 000294E5 L9999:
171: 171 000294E5 # {
172: 172 000294E5 # errcnt++; /* bump the error count */
173: 173 000294E5 6d effffffebd incl _errcnt
174: 174 000294EB # if ( prt_error )
175: 175 000294EB 5d effffffeb7 tstl _prt_error
176: 176 000294F1 31 0d jeql L241
177: 177 000294F3 # print_pipe5_er("Reg. Data, no NO-OPs");
178: 178 000294F3 .data 1
179: 179 00000d15 * L243:
180: 180 00000d15 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0"
181: F204E4F2D4F507300
182: 181 00000d2a * .text
183: 182 000294F3 dd 8f00000d15 pushl $L243
184: 183 000294F9 fe 08 ef00000a18 callf $8,_print_pipe5_er
185: 184 00029500 # if ( halt_flg )
186: 185 00029500 L241:
187: 186 00029500 5d effffffea2 tstl _halt_flg
188: 187 00029506 31 0d jeql L244
189: 188 00029508 # pipe5_er_hlt( subtest );
190: 189 00029508 dd effffffe9a pushl _subtest
191: 190 0002950E fe 08 ef00000b29 callf $8,_pipe5_er_hlt
192: 191 00029515 # if ( loop_on_err ) {
193: 192 00029515 L244:
194: 193 00029515 5d effffffe8d tstl _loop_on_err
195: 194 0002951B 31 0a jeql L246
196: 195 0002951D # force_loop = TRUE; /* set the force loop flag */
197: 196 0002951D 0d 01 effffffe84 movl $1,_force_loop
198: 197 00029524 # asm("brw _pipe5_1_lp1"); /* and loop */
199: 198 00029524 13 ff74 brw _pipe5_1_lp1
200: 199 00029527 # }
201: 200 00029527 # } /* end of compare error */
202: 201 00029527 L246:
203: 202 00029527 # } while( index++ < max_lnf_1_index );
204: 203 00029527 L240:
205: 204 00029527 L237:
206: 205 00029527 0d effffffe7b 50 movl _index,r0
207: 206 0002952E 6d effffffe74 incl _index
208: 207 00029534 1d 50 effffffe6d cmpl r0,_max_lnf_1_index
209: 208 0002953B 81 03 13 ff29 jlss L238
210: 209 00029540 L236:
211: 210 00029540 # } /* end of subtest 1 */
212: 211 00029540 40 ret#2
213: 212 00029541 .set L232,0x0
214: 213 00029541 L234:
215: 214 00029541 13 ff19 jbr L235
216: 215 00029544 .data
217: 216 00000d0c * .text
218: 217 00029544 .align 1
219: 218 00029544 .globl _pipe5_2
220: 219 00029544 _pipe5_2:
221: 220 00029544 0000 .word L247
222: 221 00029546 #
223: 222 00029546 #
224: 223 00029546 #
225: 224 00029546 #
226: 225 00029546 #
227: 226 00029546 #
228: 227 00029546 # /************************************************************************
229: 228 00029546 # *
230: 229 00029546 # * SUBTEST 2
231: 230 00029546 # * data in registers, 1 NO-OP
232: 231 00029546 # *
233: 232 00029546 # ************************************************************************/
234: 233 00029546 # pipe5_2()
235: 234 00029546 # {
236: 235 00029546 13 00e8 jbr L249
237: 236 00029549 L250:
238: 237 00029549 # force_loop = FALSE; /* clear force_loop flag */
239: 238 00029549 4d effffffe59 clrl _force_loop
240: 239 0002954F # index = 0;
241: 240 0002954F 4d effffffe53 clrl _index
242: 241 00029555 # do
243: 242 00029555 L253:
244: 243 00029555 # {
245: 244 00029555 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
246: 245 00029555 0d effffffe4d 50 movl _index,r0
247: 246 0002955C 48 03 50 50 shll $3,r0,r0
248: 247 00029560 0d e000000000 effffffe3d movl _lnf_1_data(r0),_sgl_value_1
249: 248 0002956B # sgl_expected = lnf_1_data[index].exp; /* get expected results */
250: 249 0002956B 0d effffffe37 50 movl _index,r0
251: 250 00029572 48 03 50 50 shll $3,r0,r0
252: 251 00029576 0d e000000004 effffffe27 movl _lnf_1_data+4(r0),_sgl_expected
253: 252 00029581 # sgl_value_2 = 0x00000000; /* floating '0' */
254: 253 00029581 4d effffffe21 clrl _sgl_value_2
255: 254 00029587 # /*
256: 255 00029587 # * If LOOP ON ERROR is set, this is the loop for this subtest.
257: 256 00029587 # * The force loop flag is set after the first error.
258: 257 00029587 # */
259: 258 00029587 # asm("_pipe5_2_lp1:");
260: 259 00029587 _pipe5_2_lp1:
261: 260 00029587 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
262: 261 00029587 0d effffffe1b 54 movl _sgl_value_1,r4
263: 262 0002958E # asm("movl _sgl_value_2,r5"); /* move data to r5 */
264: 263 0002958E 0d effffffe14 55 movl _sgl_value_2,r5
265: 264 00029595 # asm("lnf r4"); /* load the operand */
266: 265 00029595 16 54 lnf r4
267: 266 00029597 # asm("nop");
268: 267 00029597 10 nop
269: 268 00029598 # asm("stf r7"); /* store the result */
270: 269 00029598 26 57 stf r7
271: 270 0002959A # asm("nop");
272: 271 0002959A 10 nop
273: 272 0002959B # asm("lnf r5"); /* load a floating '0' */
274: 273 0002959B 16 55 lnf r5
275: 274 0002959D # asm("nop");
276: 275 0002959D 10 nop
277: 276 0002959E # asm("subf r4"); /* subtract the operand */
278: 277 0002959E d6 54 subf r4
279: 278 000295A0 # asm("nop");
280: 279 000295A0 10 nop
281: 280 000295A1 # asm("stf r8"); /* store the result */
282: 281 000295A1 26 58 stf r8
283: 282 000295A3 # if( force_loop )
284: 283 000295A3 5d effffffdff tstl _force_loop
285: 284 000295A9 31 02 jeql L254
286: 285 000295AB # asm("brb _pipe5_2_lp1");; /* loop on the error */
287: 286 000295AB 11 da brb _pipe5_2_lp1
288: 287 000295AD L254:
289: 288 000295AD # /*
290: 289 000295AD # * verify the results
291: 290 000295AD # */
292: 291 000295AD # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
293: 292 000295AD 0d 57 effffffdf4 movl r7,_sgl_st_acc
294: 293 000295B4 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
295: 294 000295B4 0d 58 effffffded movl r8,_sgl_value_6
296: 295 000295BB # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
297: 296 000295BB # (sgl_value_6 != sgl_expected) )
298: 297 000295BB 1d effffffde7 effffffde2 cmpl _sgl_st_acc,_sgl_expected
299: 298 000295C6 21 0d jneq L9998
300: 299 000295C8 1d effffffdda effffffdd5 cmpl _sgl_value_6,_sgl_expected
301: 300 000295D3 31 42 jeql L255
302: 301 000295D5 L9998:
303: 302 000295D5 # {
304: 303 000295D5 # errcnt++; /* bump the error count */
305: 304 000295D5 6d effffffdcd incl _errcnt
306: 305 000295DB # if ( prt_error )
307: 306 000295DB 5d effffffdc7 tstl _prt_error
308: 307 000295E1 31 0d jeql L256
309: 308 000295E3 # print_pipe5_er("Reg. Data, 1 NO-OP");
310: 309 000295E3 .data 1
311: 310 00000d2a * L257:
312: 311 00000d2a * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
313: 04E4F2D4F5000
314: 312 00000d3d * .text
315: 313 000295E3 dd 8f00000d2a pushl $L257
316: 314 000295E9 fe 08 ef00000928 callf $8,_print_pipe5_er
317: 315 000295F0 # if ( halt_flg )
318: 316 000295F0 L256:
319: 317 000295F0 5d effffffdb2 tstl _halt_flg
320: 318 000295F6 31 0d jeql L258
321: 319 000295F8 # pipe5_er_hlt( subtest );
322: 320 000295F8 dd effffffdaa pushl _subtest
323: 321 000295FE fe 08 ef00000a39 callf $8,_pipe5_er_hlt
324: 322 00029605 # if ( loop_on_err ) {
325: 323 00029605 L258:
326: 324 00029605 5d effffffd9d tstl _loop_on_err
327: 325 0002960B 31 0a jeql L259
328: 326 0002960D # force_loop = TRUE; /* set the force loop flag */
329: 327 0002960D 0d 01 effffffd94 movl $1,_force_loop
330: 328 00029614 # asm("brw _pipe5_2_lp1"); /* and loop */
331: 329 00029614 13 ff70 brw _pipe5_2_lp1
332: 330 00029617 # }
333: 331 00029617 # } /* end of compare error */
334: 332 00029617 L259:
335: 333 00029617 # } while( index++ < max_lnf_1_index );
336: 334 00029617 L255:
337: 335 00029617 L252:
338: 336 00029617 0d effffffd8b 50 movl _index,r0
339: 337 0002961E 6d effffffd84 incl _index
340: 338 00029624 1d 50 effffffd7d cmpl r0,_max_lnf_1_index
341: 339 0002962B 81 03 13 ff25 jlss L253
342: 340 00029630 L251:
343: 341 00029630 # } /* end of subtest 2 */
344: 342 00029630 40 ret#2
345: 343 00029631 .set L247,0x0
346: 344 00029631 L249:
347: 345 00029631 13 ff15 jbr L250
348: 346 00029634 .data
349: 347 00000d0c * .text
350: 348 00029634 .align 1
351: 349 00029634 .globl _pipe5_3
352: 350 00029634 _pipe5_3:
353: 351 00029634 0000 .word L260
354: 352 00029636 #
355: 353 00029636 #
356: 354 00029636 #
357: 355 00029636 #
358: 356 00029636 #
359: 357 00029636 #
360: 358 00029636 # /************************************************************************
361: 359 00029636 # *
362: 360 00029636 # * SUBTEST 3
363: 361 00029636 # * data in registers, 2 NO-OPs
364: 362 00029636 # *
365: 363 00029636 # ************************************************************************/
366: 364 00029636 # pipe5_3()
367: 365 00029636 # {
368: 366 00029636 13 00ec jbr L262
369: 367 00029639 L263:
370: 368 00029639 # force_loop = FALSE; /* clear force_loop flag */
371: 369 00029639 4d effffffd69 clrl _force_loop
372: 370 0002963F # index = 0;
373: 371 0002963F 4d effffffd63 clrl _index
374: 372 00029645 # do
375: 373 00029645 L266:
376: 374 00029645 # {
377: 375 00029645 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
378: 376 00029645 0d effffffd5d 50 movl _index,r0
379: 377 0002964C 48 03 50 50 shll $3,r0,r0
380: 378 00029650 0d e000000000 effffffd4d movl _lnf_1_data(r0),_sgl_value_1
381: 379 0002965B # sgl_expected = lnf_1_data[index].exp; /* get expected results */
382: 380 0002965B 0d effffffd47 50 movl _index,r0
383: 381 00029662 48 03 50 50 shll $3,r0,r0
384: 382 00029666 0d e000000004 effffffd37 movl _lnf_1_data+4(r0),_sgl_expected
385: 383 00029671 # sgl_value_2 = 0x00000000; /* floating '0' */
386: 384 00029671 4d effffffd31 clrl _sgl_value_2
387: 385 00029677 # /*
388: 386 00029677 # * If LOOP ON ERROR is set, this is the loop for this subtest.
389: 387 00029677 # * The force loop flag is set after the first error.
390: 388 00029677 # */
391: 389 00029677 # asm("_pipe5_3_lp1:");
392: 390 00029677 _pipe5_3_lp1:
393: 391 00029677 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
394: 392 00029677 0d effffffd2b 54 movl _sgl_value_1,r4
395: 393 0002967E # asm("movl _sgl_value_2,r5"); /* move data to r5 */
396: 394 0002967E 0d effffffd24 55 movl _sgl_value_2,r5
397: 395 00029685 # asm("lnf r4"); /* load the operand */
398: 396 00029685 16 54 lnf r4
399: 397 00029687 # asm("nop");
400: 398 00029687 10 nop
401: 399 00029688 # asm("nop");
402: 400 00029688 10 nop
403: 401 00029689 # asm("stf r7"); /* store the result */
404: 402 00029689 26 57 stf r7
405: 403 0002968B # asm("nop");
406: 404 0002968B 10 nop
407: 405 0002968C # asm("nop");
408: 406 0002968C 10 nop
409: 407 0002968D # asm("lnf r5"); /* load a floating '0' */
410: 408 0002968D 16 55 lnf r5
411: 409 0002968F # asm("nop");
412: 410 0002968F 10 nop
413: 411 00029690 # asm("nop");
414: 412 00029690 10 nop
415: 413 00029691 # asm("subf r4"); /* subtract the operand */
416: 414 00029691 d6 54 subf r4
417: 415 00029693 # asm("nop");
418: 416 00029693 10 nop
419: 417 00029694 # asm("nop");
420: 418 00029694 10 nop
421: 419 00029695 # asm("stf r8"); /* store the result */
422: 420 00029695 26 58 stf r8
423: 421 00029697 # if( force_loop )
424: 422 00029697 5d effffffd0b tstl _force_loop
425: 423 0002969D 31 02 jeql L267
426: 424 0002969F # asm("brb _pipe5_3_lp1");; /* loop on the error */
427: 425 0002969F 11 d6 brb _pipe5_3_lp1
428: 426 000296A1 L267:
429: 427 000296A1 # /*
430: 428 000296A1 # * verify the results
431: 429 000296A1 # */
432: 430 000296A1 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
433: 431 000296A1 0d 57 effffffd00 movl r7,_sgl_st_acc
434: 432 000296A8 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
435: 433 000296A8 0d 58 effffffcf9 movl r8,_sgl_value_6
436: 434 000296AF # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
437: 435 000296AF # (sgl_value_6 != sgl_expected) )
438: 436 000296AF 1d effffffcf3 effffffcee cmpl _sgl_st_acc,_sgl_expected
439: 437 000296BA 21 0d jneq L9997
440: 438 000296BC 1d effffffce6 effffffce1 cmpl _sgl_value_6,_sgl_expected
441: 439 000296C7 31 42 jeql L268
442: 440 000296C9 L9997:
443: 441 000296C9 # {
444: 442 000296C9 # errcnt++; /* bump the error count */
445: 443 000296C9 6d effffffcd9 incl _errcnt
446: 444 000296CF # if ( prt_error )
447: 445 000296CF 5d effffffcd3 tstl _prt_error
448: 446 000296D5 31 0d jeql L269
449: 447 000296D7 # print_pipe5_er("Reg. Data, 2 NO-OPs");
450: 448 000296D7 .data 1
451: 449 00000d3d * L270:
452: 450 00000d3d * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0"
453: 04E4F2D4F507300
454: 451 00000d51 * .text
455: 452 000296D7 dd 8f00000d3d pushl $L270
456: 453 000296DD fe 08 ef00000834 callf $8,_print_pipe5_er
457: 454 000296E4 # if ( halt_flg )
458: 455 000296E4 L269:
459: 456 000296E4 5d effffffcbe tstl _halt_flg
460: 457 000296EA 31 0d jeql L271
461: 458 000296EC # pipe5_er_hlt( subtest );
462: 459 000296EC dd effffffcb6 pushl _subtest
463: 460 000296F2 fe 08 ef00000945 callf $8,_pipe5_er_hlt
464: 461 000296F9 # if ( loop_on_err ) {
465: 462 000296F9 L271:
466: 463 000296F9 5d effffffca9 tstl _loop_on_err
467: 464 000296FF 31 0a jeql L272
468: 465 00029701 # force_loop = TRUE; /* set the force loop flag */
469: 466 00029701 0d 01 effffffca0 movl $1,_force_loop
470: 467 00029708 # asm("brw _pipe5_3_lp1"); /* and loop */
471: 468 00029708 13 ff6c brw _pipe5_3_lp1
472: 469 0002970B # }
473: 470 0002970B # } /* end of compare error */
474: 471 0002970B L272:
475: 472 0002970B # } while( index++ < max_lnf_1_index );
476: 473 0002970B L268:
477: 474 0002970B L265:
478: 475 0002970B 0d effffffc97 50 movl _index,r0
479: 476 00029712 6d effffffc90 incl _index
480: 477 00029718 1d 50 effffffc89 cmpl r0,_max_lnf_1_index
481: 478 0002971F 81 03 13 ff21 jlss L266
482: 479 00029724 L264:
483: 480 00029724 # } /* end of subtest 3 */
484: 481 00029724 40 ret#2
485: 482 00029725 .set L260,0x0
486: 483 00029725 L262:
487: 484 00029725 13 ff11 jbr L263
488: 485 00029728 .data
489: 486 00000d0c * .text
490: 487 00029728 .align 1
491: 488 00029728 .globl _pipe5_4
492: 489 00029728 _pipe5_4:
493: 490 00029728 0000 .word L273
494: 491 0002972A #
495: 492 0002972A #
496: 493 0002972A #
497: 494 0002972A #
498: 495 0002972A #
499: 496 0002972A #
500: 497 0002972A # /************************************************************************
501: 498 0002972A # *
502: 499 0002972A # * SUBTEST 4
503: 500 0002972A # * data in registers, 3 NO-OPs
504: 501 0002972A # *
505: 502 0002972A # ************************************************************************/
506: 503 0002972A # pipe5_4()
507: 504 0002972A # {
508: 505 0002972A 13 00f0 jbr L275
509: 506 0002972D L276:
510: 507 0002972D # force_loop = FALSE; /* clear force_loop flag */
511: 508 0002972D 4d effffffc75 clrl _force_loop
512: 509 00029733 # index = 0;
513: 510 00029733 4d effffffc6f clrl _index
514: 511 00029739 # do
515: 512 00029739 L279:
516: 513 00029739 # {
517: 514 00029739 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
518: 515 00029739 0d effffffc69 50 movl _index,r0
519: 516 00029740 48 03 50 50 shll $3,r0,r0
520: 517 00029744 0d e000000000 effffffc59 movl _lnf_1_data(r0),_sgl_value_1
521: 518 0002974F # sgl_expected = lnf_1_data[index].exp; /* get expected results */
522: 519 0002974F 0d effffffc53 50 movl _index,r0
523: 520 00029756 48 03 50 50 shll $3,r0,r0
524: 521 0002975A 0d e000000004 effffffc43 movl _lnf_1_data+4(r0),_sgl_expected
525: 522 00029765 # sgl_value_2 = 0x00000000; /* floating '0' */
526: 523 00029765 4d effffffc3d clrl _sgl_value_2
527: 524 0002976B # /*
528: 525 0002976B # * If LOOP ON ERROR is set, this is the loop for this subtest.
529: 526 0002976B # * The force loop flag is set after the first error.
530: 527 0002976B # */
531: 528 0002976B # asm("_pipe5_4_lp1:");
532: 529 0002976B _pipe5_4_lp1:
533: 530 0002976B # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
534: 531 0002976B 0d effffffc37 54 movl _sgl_value_1,r4
535: 532 00029772 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
536: 533 00029772 0d effffffc30 55 movl _sgl_value_2,r5
537: 534 00029779 # asm("lnf r4"); /* load the operand */
538: 535 00029779 16 54 lnf r4
539: 536 0002977B # asm("nop");
540: 537 0002977B 10 nop
541: 538 0002977C # asm("nop");
542: 539 0002977C 10 nop
543: 540 0002977D # asm("nop");
544: 541 0002977D 10 nop
545: 542 0002977E # asm("stf r7"); /* store the result */
546: 543 0002977E 26 57 stf r7
547: 544 00029780 # asm("nop");
548: 545 00029780 10 nop
549: 546 00029781 # asm("nop");
550: 547 00029781 10 nop
551: 548 00029782 # asm("nop");
552: 549 00029782 10 nop
553: 550 00029783 # asm("lnf r5"); /* load a floating '0' */
554: 551 00029783 16 55 lnf r5
555: 552 00029785 # asm("nop");
556: 553 00029785 10 nop
557: 554 00029786 # asm("nop");
558: 555 00029786 10 nop
559: 556 00029787 # asm("nop");
560: 557 00029787 10 nop
561: 558 00029788 # asm("subf r4"); /* subtract the operand */
562: 559 00029788 d6 54 subf r4
563: 560 0002978A # asm("nop");
564: 561 0002978A 10 nop
565: 562 0002978B # asm("nop");
566: 563 0002978B 10 nop
567: 564 0002978C # asm("nop");
568: 565 0002978C 10 nop
569: 566 0002978D # asm("stf r8"); /* store the result */
570: 567 0002978D 26 58 stf r8
571: 568 0002978F # if( force_loop )
572: 569 0002978F 5d effffffc13 tstl _force_loop
573: 570 00029795 31 02 jeql L280
574: 571 00029797 # asm("brb _pipe5_4_lp1");; /* loop on the error */
575: 572 00029797 11 d2 brb _pipe5_4_lp1
576: 573 00029799 L280:
577: 574 00029799 # /*
578: 575 00029799 # * verify the results
579: 576 00029799 # */
580: 577 00029799 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
581: 578 00029799 0d 57 effffffc08 movl r7,_sgl_st_acc
582: 579 000297A0 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
583: 580 000297A0 0d 58 effffffc01 movl r8,_sgl_value_6
584: 581 000297A7 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
585: 582 000297A7 # (sgl_value_6 != sgl_expected) )
586: 583 000297A7 1d effffffbfb effffffbf6 cmpl _sgl_st_acc,_sgl_expected
587: 584 000297B2 21 0d jneq L9996
588: 585 000297B4 1d effffffbee effffffbe9 cmpl _sgl_value_6,_sgl_expected
589: 586 000297BF 31 42 jeql L281
590: 587 000297C1 L9996:
591: 588 000297C1 # {
592: 589 000297C1 # errcnt++; /* bump the error count */
593: 590 000297C1 6d effffffbe1 incl _errcnt
594: 591 000297C7 # if ( prt_error )
595: 592 000297C7 5d effffffbdb tstl _prt_error
596: 593 000297CD 31 0d jeql L282
597: 594 000297CF # print_pipe5_er("Reg. Data, 3 NO-OPs");
598: 595 000297CF .data 1
599: 596 00000d51 * L283:
600: 597 00000d51 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0"
601: 04E4F2D4F507300
602: 598 00000d65 * .text
603: 599 000297CF dd 8f00000d51 pushl $L283
604: 600 000297D5 fe 08 ef0000073c callf $8,_print_pipe5_er
605: 601 000297DC # if ( halt_flg )
606: 602 000297DC L282:
607: 603 000297DC 5d effffffbc6 tstl _halt_flg
608: 604 000297E2 31 0d jeql L284
609: 605 000297E4 # pipe5_er_hlt( subtest );
610: 606 000297E4 dd effffffbbe pushl _subtest
611: 607 000297EA fe 08 ef0000084d callf $8,_pipe5_er_hlt
612: 608 000297F1 # if ( loop_on_err ) {
613: 609 000297F1 L284:
614: 610 000297F1 5d effffffbb1 tstl _loop_on_err
615: 611 000297F7 31 0a jeql L285
616: 612 000297F9 # force_loop = TRUE; /* set the force loop flag */
617: 613 000297F9 0d 01 effffffba8 movl $1,_force_loop
618: 614 00029800 # asm("brw _pipe5_4_lp1"); /* and loop */
619: 615 00029800 13 ff68 brw _pipe5_4_lp1
620: 616 00029803 # }
621: 617 00029803 # } /* end of compare error */
622: 618 00029803 L285:
623: 619 00029803 # } while( index++ < max_lnf_1_index );
624: 620 00029803 L281:
625: 621 00029803 L278:
626: 622 00029803 0d effffffb9f 50 movl _index,r0
627: 623 0002980A 6d effffffb98 incl _index
628: 624 00029810 1d 50 effffffb91 cmpl r0,_max_lnf_1_index
629: 625 00029817 81 03 13 ff1d jlss L279
630: 626 0002981C L277:
631: 627 0002981C # } /* end of subtest 4 */
632: 628 0002981C 40 ret#2
633: 629 0002981D .set L273,0x0
634: 630 0002981D L275:
635: 631 0002981D 13 ff0d jbr L276
636: 632 00029820 .data
637: 633 00000d0c * .text
638: 634 00029820 .align 1
639: 635 00029820 .globl _pipe5_5
640: 636 00029820 _pipe5_5:
641: 637 00029820 0000 .word L286
642: 638 00029822 #
643: 639 00029822 #
644: 640 00029822 #
645: 641 00029822 #
646: 642 00029822 #
647: 643 00029822 #
648: 644 00029822 #
649: 645 00029822 # /************************************************************************
650: 646 00029822 # *
651: 647 00029822 # * SUBTEST 5
652: 648 00029822 # * data in Cache, no NO-OPs
653: 649 00029822 # *
654: 650 00029822 # ************************************************************************/
655: 651 00029822 # pipe5_5()
656: 652 00029822 # {
657: 653 00029822 13 00dc jbr L288
658: 654 00029825 L289:
659: 655 00029825 # force_loop = FALSE; /* clear force_loop flag */
660: 656 00029825 4d effffffb7d clrl _force_loop
661: 657 0002982B # index = 0;
662: 658 0002982B 4d effffffb77 clrl _index
663: 659 00029831 # do
664: 660 00029831 L292:
665: 661 00029831 # {
666: 662 00029831 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
667: 663 00029831 0d effffffb71 50 movl _index,r0
668: 664 00029838 48 03 50 50 shll $3,r0,r0
669: 665 0002983C 0d e000000000 effffffb61 movl _lnf_1_data(r0),_sgl_value_1
670: 666 00029847 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
671: 667 00029847 0d effffffb5b 50 movl _index,r0
672: 668 0002984E 48 03 50 50 shll $3,r0,r0
673: 669 00029852 0d e000000004 effffffb4b movl _lnf_1_data+4(r0),_sgl_expected
674: 670 0002985D # sgl_value_2 = 0x00000000; /* floating '0' */
675: 671 0002985D 4d effffffb45 clrl _sgl_value_2
676: 672 00029863 # /*
677: 673 00029863 # * If LOOP ON ERROR is set, this is the loop for this subtest.
678: 674 00029863 # * The force loop flag is set after the first error.
679: 675 00029863 # */
680: 676 00029863 # asm("_pipe5_5_lp1:");
681: 677 00029863 _pipe5_5_lp1:
682: 678 00029863 # asm("lnf _sgl_value_1"); /* load the operand */
683: 679 00029863 16 effffffb3f lnf _sgl_value_1
684: 680 00029869 # asm("stf _sgl_st_acc"); /* store the result */
685: 681 00029869 26 effffffb39 stf _sgl_st_acc
686: 682 0002986F # asm("lnf _sgl_value_2"); /* load a floating '0' */
687: 683 0002986F 16 effffffb33 lnf _sgl_value_2
688: 684 00029875 # asm("subf _sgl_value_1"); /* subtract the operand */
689: 685 00029875 d6 effffffb2d subf _sgl_value_1
690: 686 0002987B # asm("stf _sgl_value_6"); /* store the result */
691: 687 0002987B 26 effffffb27 stf _sgl_value_6
692: 688 00029881 # if( force_loop )
693: 689 00029881 5d effffffb21 tstl _force_loop
694: 690 00029887 31 02 jeql L293
695: 691 00029889 # asm("brb _pipe5_5_lp1");; /* loop on the error */
696: 692 00029889 11 d8 brb _pipe5_5_lp1
697: 693 0002988B L293:
698: 694 0002988B # /*
699: 695 0002988B # * verify the results
700: 696 0002988B # */
701: 697 0002988B # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
702: 698 0002988B # (sgl_value_6 != sgl_expected) )
703: 699 0002988B 1d effffffb17 effffffb12 cmpl _sgl_st_acc,_sgl_expected
704: 700 00029896 21 0d jneq L9995
705: 701 00029898 1d effffffb0a effffffb05 cmpl _sgl_value_6,_sgl_expected
706: 702 000298A3 31 42 jeql L294
707: 703 000298A5 L9995:
708: 704 000298A5 # {
709: 705 000298A5 # errcnt++; /* bump the error count */
710: 706 000298A5 6d effffffafd incl _errcnt
711: 707 000298AB # if ( prt_error )
712: 708 000298AB 5d effffffaf7 tstl _prt_error
713: 709 000298B1 31 0d jeql L295
714: 710 000298B3 # print_pipe5_er("Cache Data, no NO-OPs");
715: 711 000298B3 .data 1
716: 712 00000d65 * L296:
717: 713 00000d65 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0"
718: E6F204E4F2D4F507300
719: 714 00000d7b * .text
720: 715 000298B3 dd 8f00000d65 pushl $L296
721: 716 000298B9 fe 08 ef00000658 callf $8,_print_pipe5_er
722: 717 000298C0 # if ( halt_flg )
723: 718 000298C0 L295:
724: 719 000298C0 5d effffffae2 tstl _halt_flg
725: 720 000298C6 31 0d jeql L297
726: 721 000298C8 # pipe5_er_hlt( subtest );
727: 722 000298C8 dd effffffada pushl _subtest
728: 723 000298CE fe 08 ef00000769 callf $8,_pipe5_er_hlt
729: 724 000298D5 # if ( loop_on_err ) {
730: 725 000298D5 L297:
731: 726 000298D5 5d effffffacd tstl _loop_on_err
732: 727 000298DB 31 0a jeql L298
733: 728 000298DD # force_loop = TRUE; /* set the force loop flag */
734: 729 000298DD 0d 01 effffffac4 movl $1,_force_loop
735: 730 000298E4 # asm("brw _pipe5_5_lp1"); /* and loop */
736: 731 000298E4 13 ff7c brw _pipe5_5_lp1
737: 732 000298E7 # }
738: 733 000298E7 # } /* end of compare error */
739: 734 000298E7 L298:
740: 735 000298E7 # } while( index++ < max_lnf_1_index );
741: 736 000298E7 L294:
742: 737 000298E7 L291:
743: 738 000298E7 0d effffffabb 50 movl _index,r0
744: 739 000298EE 6d effffffab4 incl _index
745: 740 000298F4 1d 50 effffffaad cmpl r0,_max_lnf_1_index
746: 741 000298FB 81 03 13 ff31 jlss L292
747: 742 00029900 L290:
748: 743 00029900 # } /* end of subtest 5 */
749: 744 00029900 40 ret#2
750: 745 00029901 .set L286,0x0
751: 746 00029901 L288:
752: 747 00029901 13 ff21 jbr L289
753: 748 00029904 .data
754: 749 00000d0c * .text
755: 750 00029904 .align 1
756: 751 00029904 .globl _pipe5_6
757: 752 00029904 _pipe5_6:
758: 753 00029904 0000 .word L299
759: 754 00029906 #
760: 755 00029906 #
761: 756 00029906 #
762: 757 00029906 #
763: 758 00029906 #
764: 759 00029906 #
765: 760 00029906 # /************************************************************************
766: 761 00029906 # *
767: 762 00029906 # * SUBTEST 6
768: 763 00029906 # * data in Cache, 1 NO-OP
769: 764 00029906 # *
770: 765 00029906 # ************************************************************************/
771: 766 00029906 # pipe5_6()
772: 767 00029906 # {
773: 768 00029906 13 00e0 jbr L301
774: 769 00029909 L302:
775: 770 00029909 # force_loop = FALSE; /* clear force_loop flag */
776: 771 00029909 4d effffffa99 clrl _force_loop
777: 772 0002990F # index = 0;
778: 773 0002990F 4d effffffa93 clrl _index
779: 774 00029915 # do
780: 775 00029915 L305:
781: 776 00029915 # {
782: 777 00029915 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
783: 778 00029915 0d effffffa8d 50 movl _index,r0
784: 779 0002991C 48 03 50 50 shll $3,r0,r0
785: 780 00029920 0d e000000000 effffffa7d movl _lnf_1_data(r0),_sgl_value_1
786: 781 0002992B # sgl_expected = lnf_1_data[index].exp; /* get expected results */
787: 782 0002992B 0d effffffa77 50 movl _index,r0
788: 783 00029932 48 03 50 50 shll $3,r0,r0
789: 784 00029936 0d e000000004 effffffa67 movl _lnf_1_data+4(r0),_sgl_expected
790: 785 00029941 # sgl_value_2 = 0x00000000; /* floating '0' */
791: 786 00029941 4d effffffa61 clrl _sgl_value_2
792: 787 00029947 # /*
793: 788 00029947 # * If LOOP ON ERROR is set, this is the loop for this subtest.
794: 789 00029947 # * The force loop flag is set after the first error.
795: 790 00029947 # */
796: 791 00029947 # asm("_pipe5_6_lp1:");
797: 792 00029947 _pipe5_6_lp1:
798: 793 00029947 # asm("lnf _sgl_value_1"); /* load the operand */
799: 794 00029947 16 effffffa5b lnf _sgl_value_1
800: 795 0002994D # asm("nop");
801: 796 0002994D 10 nop
802: 797 0002994E # asm("stf _sgl_st_acc"); /* store the result */
803: 798 0002994E 26 effffffa54 stf _sgl_st_acc
804: 799 00029954 # asm("nop");
805: 800 00029954 10 nop
806: 801 00029955 # asm("lnf _sgl_value_2"); /* load a floating '0' */
807: 802 00029955 16 effffffa4d lnf _sgl_value_2
808: 803 0002995B # asm("nop");
809: 804 0002995B 10 nop
810: 805 0002995C # asm("subf _sgl_value_1"); /* subtract the operand */
811: 806 0002995C d6 effffffa46 subf _sgl_value_1
812: 807 00029962 # asm("nop");
813: 808 00029962 10 nop
814: 809 00029963 # asm("stf _sgl_value_6"); /* store the result */
815: 810 00029963 26 effffffa3f stf _sgl_value_6
816: 811 00029969 # if( force_loop )
817: 812 00029969 5d effffffa39 tstl _force_loop
818: 813 0002996F 31 02 jeql L306
819: 814 00029971 # asm("brb _pipe5_6_lp1");; /* loop on the error */
820: 815 00029971 11 d4 brb _pipe5_6_lp1
821: 816 00029973 L306:
822: 817 00029973 # /*
823: 818 00029973 # * verify the results
824: 819 00029973 # */
825: 820 00029973 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
826: 821 00029973 # (sgl_value_6 != sgl_expected) )
827: 822 00029973 1d effffffa2f effffffa2a cmpl _sgl_st_acc,_sgl_expected
828: 823 0002997E 21 0d jneq L9994
829: 824 00029980 1d effffffa22 effffffa1d cmpl _sgl_value_6,_sgl_expected
830: 825 0002998B 31 42 jeql L307
831: 826 0002998D L9994:
832: 827 0002998D # {
833: 828 0002998D # errcnt++; /* bump the error count */
834: 829 0002998D 6d effffffa15 incl _errcnt
835: 830 00029993 # if ( prt_error )
836: 831 00029993 5d effffffa0f tstl _prt_error
837: 832 00029999 31 0d jeql L308
838: 833 0002999B # print_pipe5_er("Cache Data, 1 NO-OP");
839: 834 0002999B .data 1
840: 835 00000d7b * L309:
841: 836 00000d7b * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
842: 1204E4F2D4F5000
843: 837 00000d8f * .text
844: 838 0002999B dd 8f00000d7b pushl $L309
845: 839 000299A1 fe 08 ef00000570 callf $8,_print_pipe5_er
846: 840 000299A8 # if ( halt_flg )
847: 841 000299A8 L308:
848: 842 000299A8 5d effffff9fa tstl _halt_flg
849: 843 000299AE 31 0d jeql L310
850: 844 000299B0 # pipe5_er_hlt( subtest );
851: 845 000299B0 dd effffff9f2 pushl _subtest
852: 846 000299B6 fe 08 ef00000681 callf $8,_pipe5_er_hlt
853: 847 000299BD # if ( loop_on_err ) {
854: 848 000299BD L310:
855: 849 000299BD 5d effffff9e5 tstl _loop_on_err
856: 850 000299C3 31 0a jeql L311
857: 851 000299C5 # force_loop = TRUE; /* set the force loop flag */
858: 852 000299C5 0d 01 effffff9dc movl $1,_force_loop
859: 853 000299CC # asm("brw _pipe5_6_lp1"); /* and loop */
860: 854 000299CC 13 ff78 brw _pipe5_6_lp1
861: 855 000299CF # }
862: 856 000299CF # } /* end of compare error */
863: 857 000299CF L311:
864: 858 000299CF # } while( index++ < max_lnf_1_index );
865: 859 000299CF L307:
866: 860 000299CF L304:
867: 861 000299CF 0d effffff9d3 50 movl _index,r0
868: 862 000299D6 6d effffff9cc incl _index
869: 863 000299DC 1d 50 effffff9c5 cmpl r0,_max_lnf_1_index
870: 864 000299E3 81 03 13 ff2d jlss L305
871: 865 000299E8 L303:
872: 866 000299E8 # } /* end of subtest 6 */
873: 867 000299E8 40 ret#2
874: 868 000299E9 .set L299,0x0
875: 869 000299E9 L301:
876: 870 000299E9 13 ff1d jbr L302
877: 871 000299EC .data
878: 872 00000d0c * .text
879: 873 000299EC .align 1
880: 874 000299EC .globl _pipe5_7
881: 875 000299EC _pipe5_7:
882: 876 000299EC 0000 .word L312
883: 877 000299EE #
884: 878 000299EE #
885: 879 000299EE #
886: 880 000299EE #
887: 881 000299EE #
888: 882 000299EE #
889: 883 000299EE # /************************************************************************
890: 884 000299EE # *
891: 885 000299EE # * SUBTEST 7
892: 886 000299EE # * data in Cache, 2 NO-OPs
893: 887 000299EE # *
894: 888 000299EE # ************************************************************************/
895: 889 000299EE # pipe5_7()
896: 890 000299EE # {
897: 891 000299EE 13 00e4 jbr L314
898: 892 000299F1 L315:
899: 893 000299F1 # force_loop = FALSE; /* clear force_loop flag */
900: 894 000299F1 4d effffff9b1 clrl _force_loop
901: 895 000299F7 # index = 0;
902: 896 000299F7 4d effffff9ab clrl _index
903: 897 000299FD # do
904: 898 000299FD L318:
905: 899 000299FD # {
906: 900 000299FD # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
907: 901 000299FD 0d effffff9a5 50 movl _index,r0
908: 902 00029A04 48 03 50 50 shll $3,r0,r0
909: 903 00029A08 0d e000000000 effffff995 movl _lnf_1_data(r0),_sgl_value_1
910: 904 00029A13 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
911: 905 00029A13 0d effffff98f 50 movl _index,r0
912: 906 00029A1A 48 03 50 50 shll $3,r0,r0
913: 907 00029A1E 0d e000000004 effffff97f movl _lnf_1_data+4(r0),_sgl_expected
914: 908 00029A29 # sgl_value_2 = 0x00000000; /* floating '0' */
915: 909 00029A29 4d effffff979 clrl _sgl_value_2
916: 910 00029A2F # /*
917: 911 00029A2F # * If LOOP ON ERROR is set, this is the loop for this subtest.
918: 912 00029A2F # * The force loop flag is set after the first error.
919: 913 00029A2F # */
920: 914 00029A2F # asm("_pipe5_7_lp1:");
921: 915 00029A2F _pipe5_7_lp1:
922: 916 00029A2F # asm("lnf _sgl_value_1"); /* load the operand */
923: 917 00029A2F 16 effffff973 lnf _sgl_value_1
924: 918 00029A35 # asm("nop");
925: 919 00029A35 10 nop
926: 920 00029A36 # asm("nop");
927: 921 00029A36 10 nop
928: 922 00029A37 # asm("stf _sgl_st_acc"); /* store the result */
929: 923 00029A37 26 effffff96b stf _sgl_st_acc
930: 924 00029A3D # asm("nop");
931: 925 00029A3D 10 nop
932: 926 00029A3E # asm("nop");
933: 927 00029A3E 10 nop
934: 928 00029A3F # asm("lnf _sgl_value_2"); /* load a floating '0' */
935: 929 00029A3F 16 effffff963 lnf _sgl_value_2
936: 930 00029A45 # asm("nop");
937: 931 00029A45 10 nop
938: 932 00029A46 # asm("nop");
939: 933 00029A46 10 nop
940: 934 00029A47 # asm("subf _sgl_value_1"); /* subtract the operand */
941: 935 00029A47 d6 effffff95b subf _sgl_value_1
942: 936 00029A4D # asm("nop");
943: 937 00029A4D 10 nop
944: 938 00029A4E # asm("nop");
945: 939 00029A4E 10 nop
946: 940 00029A4F # asm("stf _sgl_value_6"); /* store the result */
947: 941 00029A4F 26 effffff953 stf _sgl_value_6
948: 942 00029A55 # if( force_loop )
949: 943 00029A55 5d effffff94d tstl _force_loop
950: 944 00029A5B 31 02 jeql L319
951: 945 00029A5D # asm("brb _pipe5_7_lp1");; /* loop on the error */
952: 946 00029A5D 11 d0 brb _pipe5_7_lp1
953: 947 00029A5F L319:
954: 948 00029A5F # /*
955: 949 00029A5F # * verify the results
956: 950 00029A5F # */
957: 951 00029A5F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
958: 952 00029A5F # (sgl_value_6 != sgl_expected) )
959: 953 00029A5F 1d effffff943 effffff93e cmpl _sgl_st_acc,_sgl_expected
960: 954 00029A6A 21 0d jneq L9993
961: 955 00029A6C 1d effffff936 effffff931 cmpl _sgl_value_6,_sgl_expected
962: 956 00029A77 31 42 jeql L320
963: 957 00029A79 L9993:
964: 958 00029A79 # {
965: 959 00029A79 # errcnt++; /* bump the error count */
966: 960 00029A79 6d effffff929 incl _errcnt
967: 961 00029A7F # if ( prt_error )
968: 962 00029A7F 5d effffff923 tstl _prt_error
969: 963 00029A85 31 0d jeql L321
970: 964 00029A87 # print_pipe5_er("Cache Data, 2 NO-OPs");
971: 965 00029A87 .data 1
972: 966 00000d8f * L322:
973: 967 00000d8f * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0"
974: 2204E4F2D4F507300
975: 968 00000da4 * .text
976: 969 00029A87 dd 8f00000d8f pushl $L322
977: 970 00029A8D fe 08 ef00000484 callf $8,_print_pipe5_er
978: 971 00029A94 # if ( halt_flg )
979: 972 00029A94 L321:
980: 973 00029A94 5d effffff90e tstl _halt_flg
981: 974 00029A9A 31 0d jeql L323
982: 975 00029A9C # pipe5_er_hlt( subtest );
983: 976 00029A9C dd effffff906 pushl _subtest
984: 977 00029AA2 fe 08 ef00000595 callf $8,_pipe5_er_hlt
985: 978 00029AA9 # if ( loop_on_err ) {
986: 979 00029AA9 L323:
987: 980 00029AA9 5d effffff8f9 tstl _loop_on_err
988: 981 00029AAF 31 0a jeql L324
989: 982 00029AB1 # force_loop = TRUE; /* set the force loop flag */
990: 983 00029AB1 0d 01 effffff8f0 movl $1,_force_loop
991: 984 00029AB8 # asm("brw _pipe5_7_lp1"); /* and loop */
992: 985 00029AB8 13 ff74 brw _pipe5_7_lp1
993: 986 00029ABB # }
994: 987 00029ABB # } /* end of compare error */
995: 988 00029ABB L324:
996: 989 00029ABB # } while( index++ < max_lnf_1_index );
997: 990 00029ABB L320:
998: 991 00029ABB L317:
999: 992 00029ABB 0d effffff8e7 50 movl _index,r0
1000: 993 00029AC2 6d effffff8e0 incl _index
1001: 994 00029AC8 1d 50 effffff8d9 cmpl r0,_max_lnf_1_index
1002: 995 00029ACF 81 03 13 ff29 jlss L318
1003: 996 00029AD4 L316:
1004: 997 00029AD4 # } /* end of subtest 7 */
1005: 998 00029AD4 40 ret#2
1006: 999 00029AD5 .set L312,0x0
1007: 1000 00029AD5 L314:
1008: 1001 00029AD5 13 ff19 jbr L315
1009: 1002 00029AD8 .data
1010: 1003 00000d0c * .text
1011: 1004 00029AD8 .align 1
1012: 1005 00029AD8 .globl _pipe5_8
1013: 1006 00029AD8 _pipe5_8:
1014: 1007 00029AD8 0000 .word L325
1015: 1008 00029ADA #
1016: 1009 00029ADA #
1017: 1010 00029ADA #
1018: 1011 00029ADA #
1019: 1012 00029ADA #
1020: 1013 00029ADA #
1021: 1014 00029ADA # /************************************************************************
1022: 1015 00029ADA # *
1023: 1016 00029ADA # * SUBTEST 8
1024: 1017 00029ADA # * data in Cache, 3 NO-OPs
1025: 1018 00029ADA # *
1026: 1019 00029ADA # ************************************************************************/
1027: 1020 00029ADA # pipe5_8()
1028: 1021 00029ADA # {
1029: 1022 00029ADA 13 00e8 jbr L327
1030: 1023 00029ADD L328:
1031: 1024 00029ADD # force_loop = FALSE; /* clear force_loop flag */
1032: 1025 00029ADD 4d effffff8c5 clrl _force_loop
1033: 1026 00029AE3 # index = 0;
1034: 1027 00029AE3 4d effffff8bf clrl _index
1035: 1028 00029AE9 # do
1036: 1029 00029AE9 L331:
1037: 1030 00029AE9 # {
1038: 1031 00029AE9 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1039: 1032 00029AE9 0d effffff8b9 50 movl _index,r0
1040: 1033 00029AF0 48 03 50 50 shll $3,r0,r0
1041: 1034 00029AF4 0d e000000000 effffff8a9 movl _lnf_1_data(r0),_sgl_value_1
1042: 1035 00029AFF # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1043: 1036 00029AFF 0d effffff8a3 50 movl _index,r0
1044: 1037 00029B06 48 03 50 50 shll $3,r0,r0
1045: 1038 00029B0A 0d e000000004 effffff893 movl _lnf_1_data+4(r0),_sgl_expected
1046: 1039 00029B15 # sgl_value_2 = 0x00000000; /* floating '0' */
1047: 1040 00029B15 4d effffff88d clrl _sgl_value_2
1048: 1041 00029B1B # /*
1049: 1042 00029B1B # * If LOOP ON ERROR is set, this is the loop for this subtest.
1050: 1043 00029B1B # * The force loop flag is set after the first error.
1051: 1044 00029B1B # */
1052: 1045 00029B1B # asm("_pipe5_8_lp1:");
1053: 1046 00029B1B _pipe5_8_lp1:
1054: 1047 00029B1B # asm("lnf _sgl_value_1"); /* load the operand */
1055: 1048 00029B1B 16 effffff887 lnf _sgl_value_1
1056: 1049 00029B21 # asm("nop");
1057: 1050 00029B21 10 nop
1058: 1051 00029B22 # asm("nop");
1059: 1052 00029B22 10 nop
1060: 1053 00029B23 # asm("nop");
1061: 1054 00029B23 10 nop
1062: 1055 00029B24 # asm("stf _sgl_st_acc"); /* store the result */
1063: 1056 00029B24 26 effffff87e stf _sgl_st_acc
1064: 1057 00029B2A # asm("nop");
1065: 1058 00029B2A 10 nop
1066: 1059 00029B2B # asm("nop");
1067: 1060 00029B2B 10 nop
1068: 1061 00029B2C # asm("nop");
1069: 1062 00029B2C 10 nop
1070: 1063 00029B2D # asm("lnf _sgl_value_2"); /* load a floating '0' */
1071: 1064 00029B2D 16 effffff875 lnf _sgl_value_2
1072: 1065 00029B33 # asm("nop");
1073: 1066 00029B33 10 nop
1074: 1067 00029B34 # asm("nop");
1075: 1068 00029B34 10 nop
1076: 1069 00029B35 # asm("nop");
1077: 1070 00029B35 10 nop
1078: 1071 00029B36 # asm("subf _sgl_value_1"); /* subtract the operand */
1079: 1072 00029B36 d6 effffff86c subf _sgl_value_1
1080: 1073 00029B3C # asm("nop");
1081: 1074 00029B3C 10 nop
1082: 1075 00029B3D # asm("nop");
1083: 1076 00029B3D 10 nop
1084: 1077 00029B3E # asm("nop");
1085: 1078 00029B3E 10 nop
1086: 1079 00029B3F # asm("stf _sgl_value_6"); /* store the result */
1087: 1080 00029B3F 26 effffff863 stf _sgl_value_6
1088: 1081 00029B45 # if( force_loop )
1089: 1082 00029B45 5d effffff85d tstl _force_loop
1090: 1083 00029B4B 31 02 jeql L332
1091: 1084 00029B4D # asm("brb _pipe5_8_lp1");; /* loop on the error */
1092: 1085 00029B4D 11 cc brb _pipe5_8_lp1
1093: 1086 00029B4F L332:
1094: 1087 00029B4F # /*
1095: 1088 00029B4F # * verify the results
1096: 1089 00029B4F # */
1097: 1090 00029B4F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
1098: 1091 00029B4F # (sgl_value_6 != sgl_expected) )
1099: 1092 00029B4F 1d effffff853 effffff84e cmpl _sgl_st_acc,_sgl_expected
1100: 1093 00029B5A 21 0d jneq L9992
1101: 1094 00029B5C 1d effffff846 effffff841 cmpl _sgl_value_6,_sgl_expected
1102: 1095 00029B67 31 42 jeql L333
1103: 1096 00029B69 L9992:
1104: 1097 00029B69 # {
1105: 1098 00029B69 # errcnt++; /* bump the error count */
1106: 1099 00029B69 6d effffff839 incl _errcnt
1107: 1100 00029B6F # if ( prt_error )
1108: 1101 00029B6F 5d effffff833 tstl _prt_error
1109: 1102 00029B75 31 0d jeql L334
1110: 1103 00029B77 # print_pipe5_er("Cache Data, 3 NO-OPs");
1111: 1104 00029B77 .data 1
1112: 1105 00000da4 * L335:
1113: 1106 00000da4 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0"
1114: 3204E4F2D4F507300
1115: 1107 00000db9 * .text
1116: 1108 00029B77 dd 8f00000da4 pushl $L335
1117: 1109 00029B7D fe 08 ef00000394 callf $8,_print_pipe5_er
1118: 1110 00029B84 # if ( halt_flg )
1119: 1111 00029B84 L334:
1120: 1112 00029B84 5d effffff81e tstl _halt_flg
1121: 1113 00029B8A 31 0d jeql L336
1122: 1114 00029B8C # pipe5_er_hlt( subtest );
1123: 1115 00029B8C dd effffff816 pushl _subtest
1124: 1116 00029B92 fe 08 ef000004a5 callf $8,_pipe5_er_hlt
1125: 1117 00029B99 # if ( loop_on_err ) {
1126: 1118 00029B99 L336:
1127: 1119 00029B99 5d effffff809 tstl _loop_on_err
1128: 1120 00029B9F 31 0a jeql L337
1129: 1121 00029BA1 # force_loop = TRUE; /* set the force loop flag */
1130: 1122 00029BA1 0d 01 effffff800 movl $1,_force_loop
1131: 1123 00029BA8 # asm("brw _pipe5_8_lp1"); /* and loop */
1132: 1124 00029BA8 13 ff70 brw _pipe5_8_lp1
1133: 1125 00029BAB # }
1134: 1126 00029BAB # } /* end of compare error */
1135: 1127 00029BAB L337:
1136: 1128 00029BAB # } while( index++ < max_lnf_1_index );
1137: 1129 00029BAB L333:
1138: 1130 00029BAB L330:
1139: 1131 00029BAB 0d effffff7f7 50 movl _index,r0
1140: 1132 00029BB2 6d effffff7f0 incl _index
1141: 1133 00029BB8 1d 50 effffff7e9 cmpl r0,_max_lnf_1_index
1142: 1134 00029BBF 81 03 13 ff25 jlss L331
1143: 1135 00029BC4 L329:
1144: 1136 00029BC4 # } /* end of subtest 8 */
1145: 1137 00029BC4 40 ret#2
1146: 1138 00029BC5 .set L325,0x0
1147: 1139 00029BC5 L327:
1148: 1140 00029BC5 13 ff15 jbr L328
1149: 1141 00029BC8 .data
1150: 1142 00000d0c * .text
1151: 1143 00029BC8 .align 1
1152: 1144 00029BC8 .globl _pipe5_9
1153: 1145 00029BC8 _pipe5_9:
1154: 1146 00029BC8 0000 .word L338
1155: 1147 00029BCA #
1156: 1148 00029BCA #
1157: 1149 00029BCA #
1158: 1150 00029BCA #
1159: 1151 00029BCA #
1160: 1152 00029BCA #
1161: 1153 00029BCA # /*****************************************************************************
1162: 1154 00029BCA # *
1163: 1155 00029BCA # * SUBTEST 9
1164: 1156 00029BCA # * data on the stack, no NO-OPs
1165: 1157 00029BCA # *
1166: 1158 00029BCA # *****************************************************************************/
1167: 1159 00029BCA # pipe5_9()
1168: 1160 00029BCA # {
1169: 1161 00029BCA 13 017f jbr L340
1170: 1162 00029BCD L341:
1171: 1163 00029BCD # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1172: 1164 00029BCD ed 6d effffff7d4 moval (r13),_pre_event_fp
1173: 1165 00029BD4 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1174: 1166 00029BD4 ed 6e effffff7cd moval (r14),_pre_event_sp
1175: 1167 00029BDB # force_loop = FALSE; /* clear force_loop flag */
1176: 1168 00029BDB 4d effffff7c7 clrl _force_loop
1177: 1169 00029BE1 # index = 0;
1178: 1170 00029BE1 4d effffff7c1 clrl _index
1179: 1171 00029BE7 # do
1180: 1172 00029BE7 L344:
1181: 1173 00029BE7 # {
1182: 1174 00029BE7 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1183: 1175 00029BE7 0d effffff7bb 50 movl _index,r0
1184: 1176 00029BEE 48 03 50 50 shll $3,r0,r0
1185: 1177 00029BF2 0d e000000000 effffff7ab movl _lnf_1_data(r0),_sgl_value_1
1186: 1178 00029BFD # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1187: 1179 00029BFD 0d effffff7a5 50 movl _index,r0
1188: 1180 00029C04 48 03 50 50 shll $3,r0,r0
1189: 1181 00029C08 0d e000000004 effffff795 movl _lnf_1_data+4(r0),_sgl_expected
1190: 1182 00029C13 # sgl_value_2 = 0x00000000; /* floating '0' */
1191: 1183 00029C13 4d effffff78f clrl _sgl_value_2
1192: 1184 00029C19 # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1193: 1185 00029C19 ed effffff789 effffff784 moval _pointer_data,_sgl_value_4
1194: 1186 00029C24 # /*
1195: 1187 00029C24 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1196: 1188 00029C24 # * The force loop flag is set after the first error.
1197: 1189 00029C24 # */
1198: 1190 00029C24 # asm("_pipe5_9_lp1:");
1199: 1191 00029C24 _pipe5_9_lp1:
1200: 1192 00029C24 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1201: 1193 00029C24 ed effffff77e 5e moval _pointer_data,r14
1202: 1194 00029C2B # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1203: 1195 00029C2B 0d effffff777 7e movl _sgl_value_1,-(r14)
1204: 1196 00029C32 # asm("movl _sgl_value_2,-(r14)"); /* push a floating '0' */
1205: 1197 00029C32 0d effffff770 7e movl _sgl_value_2,-(r14)
1206: 1198 00029C39 # asm("movl _sgl_value_1,-(r14)"); /* push the operand again */
1207: 1199 00029C39 0d effffff769 7e movl _sgl_value_1,-(r14)
1208: 1200 00029C40 # /*
1209: 1201 00029C40 # * now pop the data off the stack
1210: 1202 00029C40 # */
1211: 1203 00029C40 #
1212: 1204 00029C40 # asm("lnf (r14)+"); /* load the operand */
1213: 1205 00029C40 16 8e lnf (r14)+
1214: 1206 00029C42 # asm("stf r5"); /* store the result */
1215: 1207 00029C42 26 55 stf r5
1216: 1208 00029C44 # asm("lnf (r14)+"); /* load a floating '0' */
1217: 1209 00029C44 16 8e lnf (r14)+
1218: 1210 00029C46 # asm("subf (r14)+"); /* subtract the operand */
1219: 1211 00029C46 d6 8e subf (r14)+
1220: 1212 00029C48 # asm("stf r6"); /* store the result */
1221: 1213 00029C48 26 56 stf r6
1222: 1214 00029C4A # if( force_loop )
1223: 1215 00029C4A 5d effffff758 tstl _force_loop
1224: 1216 00029C50 31 02 jeql L345
1225: 1217 00029C52 # asm("brb _pipe5_9_lp1");; /* loop on the error */
1226: 1218 00029C52 11 d0 brb _pipe5_9_lp1
1227: 1219 00029C54 L345:
1228: 1220 00029C54 # /*
1229: 1221 00029C54 # * verify the results
1230: 1222 00029C54 # */
1231: 1223 00029C54 # asm("movl r5,_sgl_st_acc"); /* get the 1st store value */
1232: 1224 00029C54 0d 55 effffff74d movl r5,_sgl_st_acc
1233: 1225 00029C5B # asm("movl r6,_sgl_value_6"); /* get the 2nd store value */
1234: 1226 00029C5B 0d 56 effffff746 movl r6,_sgl_value_6
1235: 1227 00029C62 # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1236: 1228 00029C62 ed 6e effffff73f moval (r14),_sgl_value_5
1237: 1229 00029C69 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1238: 1230 00029C69 # (sgl_value_6 != sgl_expected) ||
1239: 1231 00029C69 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1240: 1232 00029C69 1d effffff739 effffff734 cmpl _sgl_st_acc,_sgl_expected
1241: 1233 00029C74 21 1d jneq L9991
1242: 1234 00029C76 1d effffff72c effffff727 cmpl _sgl_value_6,_sgl_expected
1243: 1235 00029C81 21 10 jneq L9991
1244: 1236 00029C83 1d effffff71f effffff71a cmpl _sgl_value_5,_sgl_value_4
1245: 1237 00029C8E 21 03 13 0091 jeql L346
1246: 1238 00029C93 L9991:
1247: 1239 00029C93 # {
1248: 1240 00029C93 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1249: 1241 00029C93 0d effffff70f 5d movl _pre_event_fp,r13
1250: 1242 00029C9A # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1251: 1243 00029C9A 0d effffff708 5e movl _pre_event_sp,r14
1252: 1244 00029CA1 # errcnt++; /* bump the error count */
1253: 1245 00029CA1 6d effffff701 incl _errcnt
1254: 1246 00029CA7 # if ( prt_error ) {
1255: 1247 00029CA7 5d effffff6fb tstl _prt_error
1256: 1248 00029CAD 31 4e jeql L347
1257: 1249 00029CAF # print_pipe5_er("POP data from the STACK");
1258: 1250 00029CAF .data 1
1259: 1251 00000db9 * L348:
1260: 1252 00000db9 * 504F5020646174612066726F6 .ascii "POP data from the STACK\0"
1261: D2074686520535441434B00
1262: 1253 00000dd1 * .text
1263: 1254 00029CAF dd 8f00000db9 pushl $L348
1264: 1255 00029CB5 fe 08 ef0000025c callf $8,_print_pipe5_er
1265: 1256 00029CBC # writes("final Stack Pointer = ");
1266: 1257 00029CBC .data 1
1267: 1258 00000dd1 * L349:
1268: 1259 00000dd1 * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
1269: 06F696E746572203D2000
1270: 1260 00000de8 * .text
1271: 1261 00029CBC dd 8f00000dd1 pushl $L349
1272: 1262 00029CC2 fe 08 effffff6df callf $8,_writes
1273: 1263 00029CC9 # write32h( sgl_value_5 );
1274: 1264 00029CC9 dd effffff6d9 pushl _sgl_value_5
1275: 1265 00029CCF fe 08 effffff6d2 callf $8,_write32h
1276: 1266 00029CD6 # writes(", expected SP = ");
1277: 1267 00029CD6 .data 1
1278: 1268 00000de8 * L351:
1279: 1269 00000de8 * 2C20206578706563746564205 .ascii ", expected SP = \0"
1280: 350203D2000
1281: 1270 00000dfa * .text
1282: 1271 00029CD6 dd 8f00000de8 pushl $L351
1283: 1272 00029CDC fe 08 effffff6c5 callf $8,_writes
1284: 1273 00029CE3 # write32h( sgl_value_4 );
1285: 1274 00029CE3 dd effffff6bf pushl _sgl_value_4
1286: 1275 00029CE9 fe 08 effffff6b8 callf $8,_write32h
1287: 1276 00029CF0 # writes("\n");
1288: 1277 00029CF0 .data 1
1289: 1278 00000dfa * L352:
1290: 1279 00000dfa * 0A00 .ascii "\12\0"
1291: 1280 00000dfc * .text
1292: 1281 00029CF0 dd 8f00000dfa pushl $L352
1293: 1282 00029CF6 fe 08 effffff6ab callf $8,_writes
1294: 1283 00029CFD # }
1295: 1284 00029CFD # if ( halt_flg )
1296: 1285 00029CFD L347:
1297: 1286 00029CFD 5d effffff6a5 tstl _halt_flg
1298: 1287 00029D03 31 0d jeql L353
1299: 1288 00029D05 # pipe5_er_hlt( subtest );
1300: 1289 00029D05 dd effffff69d pushl _subtest
1301: 1290 00029D0B fe 08 ef0000032c callf $8,_pipe5_er_hlt
1302: 1291 00029D12 # if ( loop_on_err ) {
1303: 1292 00029D12 L353:
1304: 1293 00029D12 5d effffff690 tstl _loop_on_err
1305: 1294 00029D18 31 0a jeql L354
1306: 1295 00029D1A # force_loop = TRUE; /* set the force loop flag */
1307: 1296 00029D1A 0d 01 effffff687 movl $1,_force_loop
1308: 1297 00029D21 # asm("brw _pipe5_9_lp1"); /* and loop */
1309: 1298 00029D21 13 ff00 brw _pipe5_9_lp1
1310: 1299 00029D24 # }
1311: 1300 00029D24 # } /* end of compare error */
1312: 1301 00029D24 L354:
1313: 1302 00029D24 # } while( index++ < max_lnf_1_index );
1314: 1303 00029D24 L346:
1315: 1304 00029D24 L343:
1316: 1305 00029D24 0d effffff67e 50 movl _index,r0
1317: 1306 00029D2B 6d effffff677 incl _index
1318: 1307 00029D31 1d 50 effffff670 cmpl r0,_max_lnf_1_index
1319: 1308 00029D38 81 03 13 feaa jlss L344
1320: 1309 00029D3D L342:
1321: 1310 00029D3D # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1322: 1311 00029D3D 0d effffff665 5d movl _pre_event_fp,r13
1323: 1312 00029D44 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1324: 1313 00029D44 0d effffff65e 5e movl _pre_event_sp,r14
1325: 1314 00029D4B # } /* end of subtest 9 */
1326: 1315 00029D4B 40 ret#2
1327: 1316 00029D4C .set L338,0x0
1328: 1317 00029D4C L340:
1329: 1318 00029D4C 13 fe7e jbr L341
1330: 1319 00029D4F .data
1331: 1320 00000d0c * .text
1332: 1321 00029D4F 00 .align 1
1333: 1322 00029D50 .globl _pipe5_10
1334: 1323 00029D50 _pipe5_10:
1335: 1324 00029D50 0000 .word L355
1336: 1325 00029D52 #
1337: 1326 00029D52 #
1338: 1327 00029D52 #
1339: 1328 00029D52 #
1340: 1329 00029D52 #
1341: 1330 00029D52 #
1342: 1331 00029D52 # /******************************************************************************
1343: 1332 00029D52 # *
1344: 1333 00029D52 # * SUBTEST 10
1345: 1334 00029D52 # * get data via indexed FRAME pointer
1346: 1335 00029D52 # *
1347: 1336 00029D52 # * ADDR INDEX DATA
1348: 1337 00029D52 # * pointer_data 4 <the 1st STF result goes here>
1349: 1338 00029D52 # * pointer_data-4 3 <the 2nd STF result goes here>
1350: 1339 00029D52 # * pointer_data-8 2 <operand data>
1351: 1340 00029D52 # * pointer_data-12 1 <floating '0'>
1352: 1341 00029D52 # * pointer_data-16 0 point the frame pointer here
1353: 1342 00029D52 # *
1354: 1343 00029D52 # ******************************************************************************/
1355: 1344 00029D52 # pipe5_10()
1356: 1345 00029D52 # {
1357: 1346 00029D52 13 01c0 jbr L357
1358: 1347 00029D55 L358:
1359: 1348 00029D55 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1360: 1349 00029D55 ed 6d effffff64c moval (r13),_pre_event_fp
1361: 1350 00029D5C # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1362: 1351 00029D5C ed 6e effffff645 moval (r14),_pre_event_sp
1363: 1352 00029D63 # force_loop = FALSE; /* clear force_loop flag */
1364: 1353 00029D63 4d effffff63f clrl _force_loop
1365: 1354 00029D69 # index = 0;
1366: 1355 00029D69 4d effffff639 clrl _index
1367: 1356 00029D6F # do
1368: 1357 00029D6F L361:
1369: 1358 00029D6F # {
1370: 1359 00029D6F # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1371: 1360 00029D6F 0d effffff633 50 movl _index,r0
1372: 1361 00029D76 48 03 50 50 shll $3,r0,r0
1373: 1362 00029D7A 0d e000000000 effffff623 movl _lnf_1_data(r0),_sgl_value_1
1374: 1363 00029D85 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1375: 1364 00029D85 0d effffff61d 50 movl _index,r0
1376: 1365 00029D8C 48 03 50 50 shll $3,r0,r0
1377: 1366 00029D90 0d e000000004 effffff60d movl _lnf_1_data+4(r0),_sgl_expected
1378: 1367 00029D9B # sgl_value_2 = 0x00000000; /* floating '0' */
1379: 1368 00029D9B 4d effffff607 clrl _sgl_value_2
1380: 1369 00029DA1 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
1381: 1370 00029DA1 ed effffff601 effffff5fc moval _pointer_data,_sgl_value_4
1382: 1371 00029DAC # sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/
1383: 1372 00029DAC 2c 08 effffff5f5 subl2 $8,_sgl_value_4
1384: 1373 00029DB3 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
1385: 1374 00029DB3 0d effffff5ef fffffff5ea movl _sgl_value_1,*_sgl_value_4
1386: 1375 00029DBE # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1387: 1376 00029DBE 2c 04 effffff5e3 subl2 $4,_sgl_value_4
1388: 1377 00029DC5 # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '0' */
1389: 1378 00029DC5 0d effffff5dd fffffff5d8 movl _sgl_value_2,*_sgl_value_4
1390: 1379 00029DD0 # sgl_value_4 -= 4; /* get FRAME PTR address */
1391: 1380 00029DD0 2c 04 effffff5d1 subl2 $4,_sgl_value_4
1392: 1381 00029DD7 # /*
1393: 1382 00029DD7 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1394: 1383 00029DD7 # * The force loop flag is set after the first error.
1395: 1384 00029DD7 # */
1396: 1385 00029DD7 # asm("_pipe5_10_lp1:");
1397: 1386 00029DD7 _pipe5_10_lp1:
1398: 1387 00029DD7 # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1399: 1388 00029DD7 0d effffff5cb 5d movl _sgl_value_4,r13
1400: 1389 00029DDE # asm("movl $1,r1"); /* r1 index = 1 longwords */
1401: 1390 00029DDE 0d 01 51 movl $1,r1
1402: 1391 00029DE1 # asm("movl $2,r2"); /* r2 index = 2 longwords */
1403: 1392 00029DE1 0d 02 52 movl $2,r2
1404: 1393 00029DE4 # asm("movl $3,r3"); /* r3 index = 3 longwords */
1405: 1394 00029DE4 0d 03 53 movl $3,r3
1406: 1395 00029DE7 # asm("movl $4,r4"); /* r4 index = 4 longwords */
1407: 1396 00029DE7 0d 04 54 movl $4,r4
1408: 1397 00029DEA # asm("lnf (r13)[r2]"); /* load the op (indx = 2) */
1409: 1398 00029DEA 16 426d lnf (r13)[r2]
1410: 1399 00029DED # asm("stf (r13)[r4]"); /* store -index = 4 */
1411: 1400 00029DED 26 446d stf (r13)[r4]
1412: 1401 00029DF0 # asm("lnf (r13)[r1]"); /* load '0' (indx = 1) */
1413: 1402 00029DF0 16 416d lnf (r13)[r1]
1414: 1403 00029DF3 # asm("subf (r13)[r2]"); /* subtract the operand */
1415: 1404 00029DF3 d6 426d subf (r13)[r2]
1416: 1405 00029DF6 # asm("stf (r13)[r3]"); /* store -index = 3 */
1417: 1406 00029DF6 26 436d stf (r13)[r3]
1418: 1407 00029DF9 # if( force_loop )
1419: 1408 00029DF9 5d effffff5a9 tstl _force_loop
1420: 1409 00029DFF 31 02 jeql L362
1421: 1410 00029E01 # asm("brb _pipe5_10_lp1");; /* loop on the error */
1422: 1411 00029E01 11 d4 brb _pipe5_10_lp1
1423: 1412 00029E03 L362:
1424: 1413 00029E03 # /*
1425: 1414 00029E03 # * verify the results
1426: 1415 00029E03 # */
1427: 1416 00029E03 # sgl_st_acc = pointer_data; /* save 1st stored value */
1428: 1417 00029E03 0d effffff59f effffff59a movl _pointer_data,_sgl_st_acc
1429: 1418 00029E0E # asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */
1430: 1419 00029E0E ed effffff594 effffff58f moval _pointer_data,_sgl_value_5
1431: 1420 00029E19 # sgl_value_5 -= 4; /* decrement by 4 (bytes) */
1432: 1421 00029E19 2c 04 effffff588 subl2 $4,_sgl_value_5
1433: 1422 00029E20 # asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */
1434: 1423 00029E20 0d fffffff582 effffff57d movl *_sgl_value_5,_sgl_value_6
1435: 1424 00029E2B # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1436: 1425 00029E2B ed 6d effffff576 moval (r13),_sgl_value_5
1437: 1426 00029E32 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1438: 1427 00029E32 # (sgl_value_6 != sgl_expected) ||
1439: 1428 00029E32 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1440: 1429 00029E32 1d effffff570 effffff56b cmpl _sgl_st_acc,_sgl_expected
1441: 1430 00029E3D 21 1d jneq L9990
1442: 1431 00029E3F 1d effffff563 effffff55e cmpl _sgl_value_6,_sgl_expected
1443: 1432 00029E4A 21 10 jneq L9990
1444: 1433 00029E4C 1d effffff556 effffff551 cmpl _sgl_value_5,_sgl_value_4
1445: 1434 00029E57 21 03 13 0091 jeql L363
1446: 1435 00029E5C L9990:
1447: 1436 00029E5C # {
1448: 1437 00029E5C # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1449: 1438 00029E5C 0d effffff546 5d movl _pre_event_fp,r13
1450: 1439 00029E63 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1451: 1440 00029E63 0d effffff53f 5e movl _pre_event_sp,r14
1452: 1441 00029E6A # errcnt++; /* bump the error count */
1453: 1442 00029E6A 6d effffff538 incl _errcnt
1454: 1443 00029E70 # if ( prt_error ) {
1455: 1444 00029E70 5d effffff532 tstl _prt_error
1456: 1445 00029E76 31 4e jeql L364
1457: 1446 00029E78 # print_pipe5_er("indexed FP addressing");
1458: 1447 00029E78 .data 1
1459: 1448 00000dfc * L365:
1460: 1449 00000dfc * 696E646578656420465020616 .ascii "indexed FP addressing\0"
1461: 46472657373696E6700
1462: 1450 00000e12 * .text
1463: 1451 00029E78 dd 8f00000dfc pushl $L365
1464: 1452 00029E7E fe 08 ef00000093 callf $8,_print_pipe5_er
1465: 1453 00029E85 # writes("final Frame Pointer = ");
1466: 1454 00029E85 .data 1
1467: 1455 00000e12 * L366:
1468: 1456 00000e12 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
1469: 06F696E746572203D2000
1470: 1457 00000e29 * .text
1471: 1458 00029E85 dd 8f00000e12 pushl $L366
1472: 1459 00029E8B fe 08 effffff516 callf $8,_writes
1473: 1460 00029E92 # writeh( sgl_value_5 );
1474: 1461 00029E92 dd effffff510 pushl _sgl_value_5
1475: 1462 00029E98 fe 08 effffff509 callf $8,_writeh
1476: 1463 00029E9F # writes(", expected FP = ");
1477: 1464 00029E9F .data 1
1478: 1465 00000e29 * L368:
1479: 1466 00000e29 * 2C20206578706563746564204 .ascii ", expected FP = \0"
1480: 650203D2000
1481: 1467 00000e3b * .text
1482: 1468 00029E9F dd 8f00000e29 pushl $L368
1483: 1469 00029EA5 fe 08 effffff4fc callf $8,_writes
1484: 1470 00029EAC # writeh( sgl_value_4 );
1485: 1471 00029EAC dd effffff4f6 pushl _sgl_value_4
1486: 1472 00029EB2 fe 08 effffff4ef callf $8,_writeh
1487: 1473 00029EB9 # writes("\n");
1488: 1474 00029EB9 .data 1
1489: 1475 00000e3b * L369:
1490: 1476 00000e3b * 0A00 .ascii "\12\0"
1491: 1477 00000e3d * .text
1492: 1478 00029EB9 dd 8f00000e3b pushl $L369
1493: 1479 00029EBF fe 08 effffff4e2 callf $8,_writes
1494: 1480 00029EC6 # }
1495: 1481 00029EC6 # if ( halt_flg )
1496: 1482 00029EC6 L364:
1497: 1483 00029EC6 5d effffff4dc tstl _halt_flg
1498: 1484 00029ECC 31 0d jeql L370
1499: 1485 00029ECE # pipe5_er_hlt( subtest );
1500: 1486 00029ECE dd effffff4d4 pushl _subtest
1501: 1487 00029ED4 fe 08 ef00000163 callf $8,_pipe5_er_hlt
1502: 1488 00029EDB # if ( loop_on_err ) {
1503: 1489 00029EDB L370:
1504: 1490 00029EDB 5d effffff4c7 tstl _loop_on_err
1505: 1491 00029EE1 31 0a jeql L371
1506: 1492 00029EE3 # force_loop = TRUE; /* set the force loop flag */
1507: 1493 00029EE3 0d 01 effffff4be movl $1,_force_loop
1508: 1494 00029EEA # asm("brw _pipe5_10_lp1"); /* and loop */
1509: 1495 00029EEA 13 feea brw _pipe5_10_lp1
1510: 1496 00029EED # }
1511: 1497 00029EED # } /* end of compare error */
1512: 1498 00029EED L371:
1513: 1499 00029EED # } while( index++ < max_lnf_1_index );
1514: 1500 00029EED L363:
1515: 1501 00029EED L360:
1516: 1502 00029EED 0d effffff4b5 50 movl _index,r0
1517: 1503 00029EF4 6d effffff4ae incl _index
1518: 1504 00029EFA 1d 50 effffff4a7 cmpl r0,_max_lnf_1_index
1519: 1505 00029F01 81 03 13 fe69 jlss L361
1520: 1506 00029F06 L359:
1521: 1507 00029F06 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1522: 1508 00029F06 0d effffff49c 5d movl _pre_event_fp,r13
1523: 1509 00029F0D # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1524: 1510 00029F0D 0d effffff495 5e movl _pre_event_sp,r14
1525: 1511 00029F14 # } /* end of subtest 10 */
1526: 1512 00029F14 40 ret#2
1527: 1513 00029F15 .set L355,0x0
1528: 1514 00029F15 L357:
1529: 1515 00029F15 13 fe3d jbr L358
1530: 1516 00029F18 .data
1531: 1517 00000d0c * .text
1532: 1518 00029F18 .align 1
1533: 1519 00029F18 .globl _print_pipe5_er
1534: 1520 00029F18 _print_pipe5_er:
1535: 1521 00029F18 0000 .word L372
1536: 1522 00029F1A #
1537: 1523 00029F1A #
1538: 1524 00029F1A # /******************************************************************************
1539: 1525 00029F1A # *
1540: 1526 00029F1A # *
1541: 1527 00029F1A # * print an error in the following form
1542: 1528 00029F1A # *
1543: 1529 00029F1A # * operand = xxxxxxxx, 1st store = xxxxxxxx, data index = dd
1544: 1530 00029F1A # * 2nd store = xxxxxxxx, expected Acc = xxxxxxxx
1545: 1531 00029F1A # *
1546: 1532 00029F1A # ******************************************************************************/
1547: 1533 00029F1A # print_pipe5_er(msg)
1548: 1534 00029F1A # char *msg;
1549: 1535 00029F1A # {
1550: 1536 00029F1A 13 011d jbr L374
1551: 1537 00029F1D L375:
1552: 1538 00029F1D # writes("\n"); /* start a new print line */
1553: 1539 00029F1D .data 1
1554: 1540 00000e3d * L376:
1555: 1541 00000e3d * 0A00 .ascii "\12\0"
1556: 1542 00000e3f * .text
1557: 1543 00029F1D dd 8f00000e3d pushl $L376
1558: 1544 00029F23 fe 08 effffff47e callf $8,_writes
1559: 1545 00029F2A # writes("cycle: ");
1560: 1546 00029F2A .data 1
1561: 1547 00000e3f * L377:
1562: 1548 00000e3f * 6379636C653A2000 .ascii "cycle: \0"
1563: 1549 00000e47 * .text
1564: 1550 00029F2A dd 8f00000e3f pushl $L377
1565: 1551 00029F30 fe 08 effffff471 callf $8,_writes
1566: 1552 00029F37 # writed( cycle );
1567: 1553 00029F37 dd effffff46b pushl _cycle
1568: 1554 00029F3D fe 08 effffff464 callf $8,_writed
1569: 1555 00029F44 # writes(" test ");
1570: 1556 00029F44 .data 1
1571: 1557 00000e47 * L379:
1572: 1558 00000e47 * 20746573742000 .ascii " test \0"
1573: 1559 00000e4e * .text
1574: 1560 00029F44 dd 8f00000e47 pushl $L379
1575: 1561 00029F4A fe 08 effffff457 callf $8,_writes
1576: 1562 00029F51 # writed( test_no );
1577: 1563 00029F51 dd effffff451 pushl _test_no
1578: 1564 00029F57 fe 08 effffff44a callf $8,_writed
1579: 1565 00029F5E # writes(" (Pipe 5), subtest ");
1580: 1566 00029F5E .data 1
1581: 1567 00000e4e * L380:
1582: 1568 00000e4e * 202028506970652035292C207 .ascii " (Pipe 5), subtest \0"
1583: 37562746573742000
1584: 1569 00000e63 * .text
1585: 1570 00029F5E dd 8f00000e4e pushl $L380
1586: 1571 00029F64 fe 08 effffff43d callf $8,_writes
1587: 1572 00029F6B # writed( subtest );
1588: 1573 00029F6B dd effffff437 pushl _subtest
1589: 1574 00029F71 fe 08 effffff430 callf $8,_writed
1590: 1575 00029F78 # writes(" error - ");
1591: 1576 00029F78 .data 1
1592: 1577 00000e63 * L381:
1593: 1578 00000e63 * 206572726F72202D2000 .ascii " error - \0"
1594: 1579 00000e6d * .text
1595: 1580 00029F78 dd 8f00000e63 pushl $L381
1596: 1581 00029F7E fe 08 effffff423 callf $8,_writes
1597: 1582 00029F85 # writes( msg );
1598: 1583 00029F85 dd ad04 pushl 4(fp)
1599: 1584 00029F88 fe 08 effffff419 callf $8,_writes
1600: 1585 00029F8F # writec('\n');
1601: 1586 00029F8F dd 0a pushl $10
1602: 1587 00029F91 fe 08 effffff410 callf $8,_writec
1603: 1588 00029F98 # writes(" LNF(op), STF, LNF(0.0), SUBF(op), STF\n");
1604: 1589 00029F98 .data 1
1605: 1590 00000e6d * L383:
1606: 1591 00000e6d * 204C4E46286F70292C2053544 .ascii " LNF(op), STF, LNF(0.0), SUBF(op), STF\12\0"
1607: 62C204C4E4628302E30292C20
1608: 53554246286F70292C2053544
1609: 60A00
1610: 1592 00000e95 * .text
1611: 1593 00029F98 dd 8f00000e6d pushl $L383
1612: 1594 00029F9E fe 08 effffff403 callf $8,_writes
1613: 1595 00029FA5 # writes(" operand = ");
1614: 1596 00029FA5 .data 1
1615: 1597 00000e95 * L384:
1616: 1598 00000e95 * 20206F706572616E64203D200 .ascii " operand = \0"
1617: 0
1618: 1599 00000ea2 * .text
1619: 1600 00029FA5 dd 8f00000e95 pushl $L384
1620: 1601 00029FAB fe 08 effffff3f6 callf $8,_writes
1621: 1602 00029FB2 # write32h( sgl_value_1 );
1622: 1603 00029FB2 dd effffff3f0 pushl _sgl_value_1
1623: 1604 00029FB8 fe 08 effffff3e9 callf $8,_write32h
1624: 1605 00029FBF # writes(", 1st store = ");
1625: 1606 00029FBF .data 1
1626: 1607 00000ea2 * L385:
1627: 1608 00000ea2 * 2C20202020203173742073746 .ascii ", 1st store = \0"
1628: F7265203D2000
1629: 1609 00000eb5 * .text
1630: 1610 00029FBF dd 8f00000ea2 pushl $L385
1631: 1611 00029FC5 fe 08 effffff3dc callf $8,_writes
1632: 1612 00029FCC # write32h( sgl_st_acc );
1633: 1613 00029FCC dd effffff3d6 pushl _sgl_st_acc
1634: 1614 00029FD2 fe 08 effffff3cf callf $8,_write32h
1635: 1615 00029FD9 # writes(", data index = ");
1636: 1616 00029FD9 .data 1
1637: 1617 00000eb5 * L386:
1638: 1618 00000eb5 * 2C2020206461746120696E646 .ascii ", data index = \0"
1639: 578203D2000
1640: 1619 00000ec7 * .text
1641: 1620 00029FD9 dd 8f00000eb5 pushl $L386
1642: 1621 00029FDF fe 08 effffff3c2 callf $8,_writes
1643: 1622 00029FE6 # writed( index );
1644: 1623 00029FE6 dd effffff3bc pushl _index
1645: 1624 00029FEC fe 08 effffff3b5 callf $8,_writed
1646: 1625 00029FF3 # writec('\n');
1647: 1626 00029FF3 dd 0a pushl $10
1648: 1627 00029FF5 fe 08 effffff3ac callf $8,_writec
1649: 1628 00029FFC # writes("2nd store = ");
1650: 1629 00029FFC .data 1
1651: 1630 00000ec7 * L387:
1652: 1631 00000ec7 * .ascii ""
1653: 1632 00000ec7 * 326E642073746F7265203D200 .ascii "2nd store = \0"
1654: 0
1655: 1633 00000ed4 * .text
1656: 1634 00029FFC dd 8f00000ec7 pushl $L387
1657: 1635 0002A002 fe 08 effffff39f callf $8,_writes
1658: 1636 0002A009 # write32h( sgl_value_6 );
1659: 1637 0002A009 dd effffff399 pushl _sgl_value_6
1660: 1638 0002A00F fe 08 effffff392 callf $8,_write32h
1661: 1639 0002A016 # writes(", expected Acc = ");
1662: 1640 0002A016 .data 1
1663: 1641 00000ed4 * L388:
1664: 1642 00000ed4 * 2C20206578706563746564204 .ascii ", expected Acc = \0"
1665: 16363203D2000
1666: 1643 00000ee7 * .text
1667: 1644 0002A016 dd 8f00000ed4 pushl $L388
1668: 1645 0002A01C fe 08 effffff385 callf $8,_writes
1669: 1646 0002A023 # write32h( sgl_expected );
1670: 1647 0002A023 dd effffff37f pushl _sgl_expected
1671: 1648 0002A029 fe 08 effffff378 callf $8,_write32h
1672: 1649 0002A030 # writec('\n');
1673: 1650 0002A030 dd 0a pushl $10
1674: 1651 0002A032 fe 08 effffff36f callf $8,_writec
1675: 1652 0002A039 # }
1676: 1653 0002A039 40 ret#2
1677: 1654 0002A03A .set L372,0x0
1678: 1655 0002A03A L374:
1679: 1656 0002A03A 13 fee0 jbr L375
1680: 1657 0002A03D .data
1681: 1658 00000d0c * .text
1682: 1659 0002A03D 00 .align 1
1683: 1660 0002A03E .globl _pipe5_er_hlt
1684: 1661 0002A03E _pipe5_er_hlt:
1685: 1662 0002A03E 0000 .word L389
1686: 1663 0002A040 #
1687: 1664 0002A040 #
1688: 1665 0002A040 #
1689: 1666 0002A040 #
1690: 1667 0002A040 #
1691: 1668 0002A040 # /******************************************************************************
1692: 1669 0002A040 # *
1693: 1670 0002A040 # * HALT ON ERROR ROUTINE
1694: 1671 0002A040 # *
1695: 1672 0002A040 # * halt with the necessary information saved in the registers
1696: 1673 0002A040 # *
1697: 1674 0002A040 # ******************************************************************************/
1698: 1675 0002A040 # pipe5_er_hlt( subtest )
1699: 1676 0002A040 # int subtest;
1700: 1677 0002A040 # {
1701: 1678 0002A040 11 6e jbr L391
1702: 1679 0002A042 L392:
1703: 1680 0002A042 # asm("movl _test_no,r0"); /* r0 = test number */
1704: 1681 0002A042 0d effffff360 50 movl _test_no,r0
1705: 1682 0002A049 # asm("movl _subtest,r1"); /* r1 = subtest number */
1706: 1683 0002A049 0d effffff359 51 movl _subtest,r1
1707: 1684 0002A050 # asm("movl $1,r2"); /* r2 = error code */
1708: 1685 0002A050 0d 01 52 movl $1,r2
1709: 1686 0002A053 # asm("movl _cycle,r3"); /* r3 = cycle count */
1710: 1687 0002A053 0d effffff34f 53 movl _cycle,r3
1711: 1688 0002A05A # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1712: 1689 0002A05A 0d effffff348 54 movl _sgl_value_1,r4
1713: 1690 0002A061 # asm("movl _sgl_st_acc,r5"); /* r5 = 1st word stored */
1714: 1691 0002A061 0d effffff341 55 movl _sgl_st_acc,r5
1715: 1692 0002A068 # asm("movl _sgl_value_6,r6"); /* r6 = 2nd word stored */
1716: 1693 0002A068 0d effffff33a 56 movl _sgl_value_6,r6
1717: 1694 0002A06F # asm("movl _sgl_expected,r7"); /* r7 = sgl expected */
1718: 1695 0002A06F 0d effffff333 57 movl _sgl_expected,r7
1719: 1696 0002A076 # asm("movl _index,r8"); /* r8 = data index */
1720: 1697 0002A076 0d effffff32c 58 movl _index,r8
1721: 1698 0002A07D # asm("movl _sgl_value_2,r9"); /* r9 = floating zero */
1722: 1699 0002A07D 0d effffff325 59 movl _sgl_value_2,r9
1723: 1700 0002A084 # if( subtest == 9 ) {
1724: 1701 0002A084 1d ad04 09 cmpl 4(fp),$9
1725: 1702 0002A088 21 10 jneq L393
1726: 1703 0002A08A # asm("movl _sgl_value_5,r10"); /* r10= final SP value */
1727: 1704 0002A08A 0d effffff318 5a movl _sgl_value_5,r10
1728: 1705 0002A091 # asm("movl _sgl_value_4,r11"); /* r11= expected SP value */
1729: 1706 0002A091 0d effffff311 5b movl _sgl_value_4,r11
1730: 1707 0002A098 # } else
1731: 1708 0002A098 11 14 jbr L394
1732: 1709 0002A09A L393:
1733: 1710 0002A09A # if( subtest == 10 ) {
1734: 1711 0002A09A 1d ad04 0a cmpl 4(fp),$10
1735: 1712 0002A09E 21 0e jneq L395
1736: 1713 0002A0A0 # asm("movl _sgl_value_5,r10"); /* r10= final FP value */
1737: 1714 0002A0A0 0d effffff302 5a movl _sgl_value_5,r10
1738: 1715 0002A0A7 # asm("movl _sgl_value_4,r11"); /* r11= expected FP value */
1739: 1716 0002A0A7 0d effffff2fb 5b movl _sgl_value_4,r11
1740: 1717 0002A0AE # };
1741: 1718 0002A0AE L395:
1742: 1719 0002A0AE L394:
1743: 1720 0002A0AE # asm(".globl _pipe5_1_hlt");
1744: 1721 0002A0AE .globl _pipe5_1_hlt
1745: 1722 0002A0AE # asm("_pipe5_1_hlt:"); /* PC after the halt */
1746: 1723 0002A0AE _pipe5_1_hlt:
1747: 1724 0002A0AE # asm("halt"); /* HALT ... */
1748: 1725 0002A0AE 00 halt
1749: 1726 0002A0AF # } /* end of halt on error */
1750: 1727 0002A0AF 40 ret#2
1751: 1728 0002A0B0 .set L389,0x0
1752: 1729 0002A0B0 L391:
1753: 1730 0002A0B0 11 90 jbr L392
1754: 1731 0002A0B2 .data
1755: 1731 0005345A .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.