![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe4.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 pipe4.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 00000d78 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_4
6: 6 00000000 _pipe_4:
7: 7 00028630 0000 .word L215
8: 8 00028632 # #include "fpp_defs.h"
9: 9 00028632 #
10: 10 00028632 #
11: 11 00028632 # /*****************************************************************************
12: 12 00028632 # *
13: 13 00028632 # * PIPELINE TEST #4 MONITOR
14: 14 00028632 # *
15: 15 00028632 # * This test will do:
16: 16 00028632 # *
17: 17 00028632 # * LDF(x) STF LDF(1) MULF(1) MULF(x) STF
18: 18 00028632 # *
19: 19 00028632 # * where x is the fmacro1 LDF data. This test verifies the store after the
20: 20 00028632 # * LDF and the LDF after the store. It will also verify all of the MULF's
21: 21 00028632 # * B entry points.
22: 22 00028632 # *****************************************************************************/
23: 23 00028632 # pipe_4()
24: 24 00028632 # {
25: 25 00028632 13 00a8 jbr L217
26: 26 00028635 L218:
27: 27 00028635 # asm(".globl _pipeline_4_t");
28: 28 00028635 .globl _pipeline_4_t
29: 29 00028635 # asm("_pipeline_4_t:"); /* entry address */
30: 30 00028635 _pipeline_4_t:
31: 31 00028635 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
32: 32 00028635 1d effffffff5 01 cmpl _cycle,$1
33: 33 0002863C 21 15 jneq L219
34: 34 0002863E 5d efffffffec tstl _prt_hdrs
35: 35 00028644 31 0d jeql L219
36: 36 00028646 # {
37: 37 00028646 # writes(" PIPE_4 ");
38: 38 00028646 .data 1
39: 39 00000d78 * L221:
40: 40 00000d78 * 20504950455F342000 .ascii " PIPE_4 \0"
41: 41 00000d81 * .text
42: 42 00028646 dd 8f00000d78 pushl $L221
43: 43 0002864C fe 08 efffffffdd callf $8,_writes
44: 44 00028653 # }
45: 45 00028653 # subtest = 1;
46: 46 00028653 L219:
47: 47 00028653 0d 01 efffffffd6 movl $1,_subtest
48: 48 0002865A # pipe4_1(); /* data in REGs, no NOPs */
49: 49 0002865A fe 04 ef0000007f callf $4,_pipe4_1
50: 50 00028661 # subtest++; /* increment subtest num */
51: 51 00028661 6d efffffffc9 incl _subtest
52: 52 00028667 # pipe4_2(); /* data in REGs, 1 NOP */
53: 53 00028667 fe 04 ef00000166 callf $4,_pipe4_2
54: 54 0002866E # subtest++; /* increment subtest num */
55: 55 0002866E 6d efffffffbc incl _subtest
56: 56 00028674 # pipe4_3(); /* data in REGs, 2 NOPs */
57: 57 00028674 fe 04 ef00000251 callf $4,_pipe4_3
58: 58 0002867B # subtest++; /* increment subtest num */
59: 59 0002867B 6d efffffffaf incl _subtest
60: 60 00028681 # pipe4_4(); /* data in REGs, 3 NOPs */
61: 61 00028681 fe 04 ef00000342 callf $4,_pipe4_4
62: 62 00028688 # subtest++; /* increment subtest num */
63: 63 00028688 6d efffffffa2 incl _subtest
64: 64 0002868E # pipe4_5(); /* data in CACHE, no NOPs */
65: 65 0002868E fe 04 ef00000437 callf $4,_pipe4_5
66: 66 00028695 # subtest++; /* increment subtest num */
67: 67 00028695 6d efffffff95 incl _subtest
68: 68 0002869B # pipe4_6(); /* data in CACHE, 1 NOP */
69: 69 0002869B fe 04 ef0000051a callf $4,_pipe4_6
70: 70 000286A2 # subtest++; /* increment subtest num */
71: 71 000286A2 6d efffffff88 incl _subtest
72: 72 000286A8 # pipe4_7(); /* data in CACHE, 2 NOPs */
73: 73 000286A8 fe 04 ef00000601 callf $4,_pipe4_7
74: 74 000286AF # subtest++; /* increment subtest num */
75: 75 000286AF 6d efffffff7b incl _subtest
76: 76 000286B5 # pipe4_8(); /* data in CACHE, 3 NOPs */
77: 77 000286B5 fe 04 ef000006ee callf $4,_pipe4_8
78: 78 000286BC # subtest++; /* increment subtest num */
79: 79 000286BC 6d efffffff6e incl _subtest
80: 80 000286C2 # pipe4_9(); /* data on STACK, no NOPs */
81: 81 000286C2 fe 04 ef000007df callf $4,_pipe4_9
82: 82 000286C9 # subtest++; /* increment subtest num */
83: 83 000286C9 6d efffffff61 incl _subtest
84: 84 000286CF # pipe4_10(); /* data via FP no NOPs */
85: 85 000286CF fe 04 ef00000968 callf $4,_pipe4_10
86: 86 000286D6 # asm("jmp *return"); /* return to the test monitor */
87: 87 000286D6 71 ffffffff54 jmp *return
88: 88 000286DC # }
89: 89 000286DC 40 ret#2
90: 90 000286DD .set L215,0x0
91: 91 000286DD L217:
92: 92 000286DD 13 ff55 jbr L218
93: 93 000286E0 .data
94: 94 00000d78 * .text
95: 95 000286E0 .align 1
96: 96 000286E0 .globl _pipe4_1
97: 97 000286E0 _pipe4_1:
98: 98 000286E0 0000 .word L232
99: 99 000286E2 #
100: 100 000286E2 #
101: 101 000286E2 #
102: 102 000286E2 #
103: 103 000286E2 #
104: 104 000286E2 #
105: 105 000286E2 # /************************************************************************
106: 106 000286E2 # *
107: 107 000286E2 # * SUBTEST 1
108: 108 000286E2 # * data in registers, no NO-OPs
109: 109 000286E2 # *
110: 110 000286E2 # ************************************************************************/
111: 111 000286E2 # pipe4_1()
112: 112 000286E2 # {
113: 113 000286E2 13 00eb jbr L234
114: 114 000286E5 L235:
115: 115 000286E5 # force_loop = FALSE; /* clear force_loop flag */
116: 116 000286E5 4d efffffff45 clrl _force_loop
117: 117 000286EB # index = 0;
118: 118 000286EB 4d efffffff3f clrl _index
119: 119 000286F1 # do
120: 120 000286F1 L238:
121: 121 000286F1 # {
122: 122 000286F1 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
123: 123 000286F1 0d efffffff39 50 movl _index,r0
124: 124 000286F8 48 03 50 50 shll $3,r0,r0
125: 125 000286FC 0d e000000000 efffffff29 movl _ldf_1_data(r0),_sgl_value_1
126: 126 00028707 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
127: 127 00028707 0d efffffff23 50 movl _index,r0
128: 128 0002870E 48 03 50 50 shll $3,r0,r0
129: 129 00028712 0d e000000004 efffffff13 movl _ldf_1_data+4(r0),_sgl_expected
130: 130 0002871D # sgl_value_2 = 0x40800000; /* floating '1' */
131: 131 0002871D 0d 8f40800000 efffffff08 movl $1082130432,_sgl_value_2
132: 132 00028728 # /*
133: 133 00028728 # * If LOOP ON ERROR is set, this is the loop for this subtest.
134: 134 00028728 # * The force loop flag is set after the first error.
135: 135 00028728 # */
136: 136 00028728 # asm("_pipe4_1_lp1:");
137: 137 00028728 _pipe4_1_lp1:
138: 138 00028728 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
139: 139 00028728 0d efffffff02 54 movl _sgl_value_1,r4
140: 140 0002872F # asm("movl _sgl_value_2,r5"); /* move data to r5 */
141: 141 0002872F 0d effffffefb 55 movl _sgl_value_2,r5
142: 142 00028736 # asm("ldf r4"); /* load the operand */
143: 143 00028736 06 54 ldf r4
144: 144 00028738 # asm("stf r7"); /* store the result */
145: 145 00028738 26 57 stf r7
146: 146 0002873A # asm("ldf r5"); /* load a floating '1' */
147: 147 0002873A 06 55 ldf r5
148: 148 0002873C # asm("mulf r5"); /* multipy by a '1' */
149: 149 0002873C e6 55 mulf r5
150: 150 0002873E # asm("mulf r4"); /* multipy by the operand */
151: 151 0002873E e6 54 mulf r4
152: 152 00028740 # asm("stf r8"); /* store the result */
153: 153 00028740 26 58 stf r8
154: 154 00028742 # if( force_loop );
155: 155 00028742 5d effffffee8 tstl _force_loop
156: 156 00028748 31 00 jeql L239
157: 157 0002874A # asm("brb _pipe4_1_lp1");; /* loop on the error */
158: 158 0002874A L239:
159: 159 0002874A 11 dc brb _pipe4_1_lp1
160: 160 0002874C # /*
161: 161 0002874C # * verify the results
162: 162 0002874C # */
163: 163 0002874C # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
164: 164 0002874C 0d 57 effffffedd movl r7,_sgl_st_acc
165: 165 00028753 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
166: 166 00028753 0d 58 effffffed6 movl r8,_sgl_value_6
167: 167 0002875A # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
168: 168 0002875A # (sgl_value_6 != sgl_expected) )
169: 169 0002875A 1d effffffed0 effffffecb cmpl _sgl_st_acc,_sgl_expected
170: 170 00028765 21 0d jneq L9999
171: 171 00028767 1d effffffec3 effffffebe cmpl _sgl_value_6,_sgl_expected
172: 172 00028772 31 42 jeql L240
173: 173 00028774 L9999:
174: 174 00028774 # {
175: 175 00028774 # errcnt++; /* bump the error count */
176: 176 00028774 6d effffffeb6 incl _errcnt
177: 177 0002877A # if ( prt_error )
178: 178 0002877A 5d effffffeb0 tstl _prt_error
179: 179 00028780 31 0d jeql L241
180: 180 00028782 # print_pipe4_er("Reg. Data, no NO-OPs");
181: 181 00028782 .data 1
182: 182 00000d81 * L243:
183: 183 00000d81 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0"
184: F204E4F2D4F507300
185: 184 00000d96 * .text
186: 185 00028782 dd 8f00000d81 pushl $L243
187: 186 00028788 fe 08 ef00000a7f callf $8,_print_pipe4_er
188: 187 0002878F # if ( halt_flg )
189: 188 0002878F L241:
190: 189 0002878F 5d effffffe9b tstl _halt_flg
191: 190 00028795 31 0d jeql L244
192: 191 00028797 # pipe4_er_hlt( subtest );
193: 192 00028797 dd effffffe93 pushl _subtest
194: 193 0002879D fe 08 ef00000b90 callf $8,_pipe4_er_hlt
195: 194 000287A4 # if ( loop_on_err ) {
196: 195 000287A4 L244:
197: 196 000287A4 5d effffffe86 tstl _loop_on_err
198: 197 000287AA 31 0a jeql L246
199: 198 000287AC # force_loop = TRUE; /* set the force loop flag */
200: 199 000287AC 0d 01 effffffe7d movl $1,_force_loop
201: 200 000287B3 # asm("brw _pipe4_1_lp1"); /* and loop */
202: 201 000287B3 13 ff72 brw _pipe4_1_lp1
203: 202 000287B6 # }
204: 203 000287B6 # } /* end of compare error */
205: 204 000287B6 L246:
206: 205 000287B6 # } while( index++ < max_ldf_1_index );
207: 206 000287B6 L240:
208: 207 000287B6 L237:
209: 208 000287B6 0d effffffe74 50 movl _index,r0
210: 209 000287BD 6d effffffe6d incl _index
211: 210 000287C3 1d 50 effffffe66 cmpl r0,_max_ldf_1_index
212: 211 000287CA 81 03 13 ff22 jlss L238
213: 212 000287CF L236:
214: 213 000287CF # } /* end of subtest 1 */
215: 214 000287CF 40 ret#2
216: 215 000287D0 .set L232,0x0
217: 216 000287D0 L234:
218: 217 000287D0 13 ff12 jbr L235
219: 218 000287D3 .data
220: 219 00000d78 * .text
221: 220 000287D3 00 .align 1
222: 221 000287D4 .globl _pipe4_2
223: 222 000287D4 _pipe4_2:
224: 223 000287D4 0000 .word L247
225: 224 000287D6 #
226: 225 000287D6 #
227: 226 000287D6 #
228: 227 000287D6 #
229: 228 000287D6 #
230: 229 000287D6 #
231: 230 000287D6 # /************************************************************************
232: 231 000287D6 # *
233: 232 000287D6 # * SUBTEST 2
234: 233 000287D6 # * data in registers, 1 NO-OP
235: 234 000287D6 # *
236: 235 000287D6 # ************************************************************************/
237: 236 000287D6 # pipe4_2()
238: 237 000287D6 # {
239: 238 000287D6 13 00f0 jbr L249
240: 239 000287D9 L250:
241: 240 000287D9 # force_loop = FALSE; /* clear force_loop flag */
242: 241 000287D9 4d effffffe51 clrl _force_loop
243: 242 000287DF # index = 0;
244: 243 000287DF 4d effffffe4b clrl _index
245: 244 000287E5 # do
246: 245 000287E5 L253:
247: 246 000287E5 # {
248: 247 000287E5 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
249: 248 000287E5 0d effffffe45 50 movl _index,r0
250: 249 000287EC 48 03 50 50 shll $3,r0,r0
251: 250 000287F0 0d e000000000 effffffe35 movl _ldf_1_data(r0),_sgl_value_1
252: 251 000287FB # sgl_expected = ldf_1_data[index].exp; /* get expected results */
253: 252 000287FB 0d effffffe2f 50 movl _index,r0
254: 253 00028802 48 03 50 50 shll $3,r0,r0
255: 254 00028806 0d e000000004 effffffe1f movl _ldf_1_data+4(r0),_sgl_expected
256: 255 00028811 # sgl_value_2 = 0x40800000; /* floating '1' */
257: 256 00028811 0d 8f40800000 effffffe14 movl $1082130432,_sgl_value_2
258: 257 0002881C # /*
259: 258 0002881C # * If LOOP ON ERROR is set, this is the loop for this subtest.
260: 259 0002881C # * The force loop flag is set after the first error.
261: 260 0002881C # */
262: 261 0002881C # asm("_pipe4_2_lp1:");
263: 262 0002881C _pipe4_2_lp1:
264: 263 0002881C # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
265: 264 0002881C 0d effffffe0e 54 movl _sgl_value_1,r4
266: 265 00028823 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
267: 266 00028823 0d effffffe07 55 movl _sgl_value_2,r5
268: 267 0002882A # asm("ldf r4"); /* load the operand */
269: 268 0002882A 06 54 ldf r4
270: 269 0002882C # asm("nop");
271: 270 0002882C 10 nop
272: 271 0002882D # asm("stf r7"); /* store the result */
273: 272 0002882D 26 57 stf r7
274: 273 0002882F # asm("nop");
275: 274 0002882F 10 nop
276: 275 00028830 # asm("ldf r5"); /* load a floating '1' */
277: 276 00028830 06 55 ldf r5
278: 277 00028832 # asm("nop");
279: 278 00028832 10 nop
280: 279 00028833 # asm("mulf r5"); /* multipy by a '1' */
281: 280 00028833 e6 55 mulf r5
282: 281 00028835 # asm("nop");
283: 282 00028835 10 nop
284: 283 00028836 # asm("mulf r4"); /* multipy by the operand */
285: 284 00028836 e6 54 mulf r4
286: 285 00028838 # asm("nop");
287: 286 00028838 10 nop
288: 287 00028839 # asm("stf r8"); /* store the result */
289: 288 00028839 26 58 stf r8
290: 289 0002883B # if( force_loop );
291: 290 0002883B 5d effffffdef tstl _force_loop
292: 291 00028841 31 00 jeql L254
293: 292 00028843 # asm("brb _pipe4_2_lp1");; /* loop on the error */
294: 293 00028843 L254:
295: 294 00028843 11 d7 brb _pipe4_2_lp1
296: 295 00028845 # /*
297: 296 00028845 # * verify the results
298: 297 00028845 # */
299: 298 00028845 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
300: 299 00028845 0d 57 effffffde4 movl r7,_sgl_st_acc
301: 300 0002884C # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
302: 301 0002884C 0d 58 effffffddd movl r8,_sgl_value_6
303: 302 00028853 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
304: 303 00028853 # (sgl_value_6 != sgl_expected) )
305: 304 00028853 1d effffffdd7 effffffdd2 cmpl _sgl_st_acc,_sgl_expected
306: 305 0002885E 21 0d jneq L9998
307: 306 00028860 1d effffffdca effffffdc5 cmpl _sgl_value_6,_sgl_expected
308: 307 0002886B 31 42 jeql L255
309: 308 0002886D L9998:
310: 309 0002886D # {
311: 310 0002886D # errcnt++; /* bump the error count */
312: 311 0002886D 6d effffffdbd incl _errcnt
313: 312 00028873 # if ( prt_error )
314: 313 00028873 5d effffffdb7 tstl _prt_error
315: 314 00028879 31 0d jeql L256
316: 315 0002887B # print_pipe4_er("Reg. Data, 1 NO-OP");
317: 316 0002887B .data 1
318: 317 00000d96 * L257:
319: 318 00000d96 * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
320: 04E4F2D4F5000
321: 319 00000da9 * .text
322: 320 0002887B dd 8f00000d96 pushl $L257
323: 321 00028881 fe 08 ef00000986 callf $8,_print_pipe4_er
324: 322 00028888 # if ( halt_flg )
325: 323 00028888 L256:
326: 324 00028888 5d effffffda2 tstl _halt_flg
327: 325 0002888E 31 0d jeql L258
328: 326 00028890 # pipe4_er_hlt( subtest );
329: 327 00028890 dd effffffd9a pushl _subtest
330: 328 00028896 fe 08 ef00000a97 callf $8,_pipe4_er_hlt
331: 329 0002889D # if ( loop_on_err ) {
332: 330 0002889D L258:
333: 331 0002889D 5d effffffd8d tstl _loop_on_err
334: 332 000288A3 31 0a jeql L259
335: 333 000288A5 # force_loop = TRUE; /* set the force loop flag */
336: 334 000288A5 0d 01 effffffd84 movl $1,_force_loop
337: 335 000288AC # asm("brw _pipe4_2_lp1"); /* and loop */
338: 336 000288AC 13 ff6d brw _pipe4_2_lp1
339: 337 000288AF # }
340: 338 000288AF # } /* end of compare error */
341: 339 000288AF L259:
342: 340 000288AF # } while( index++ < max_ldf_1_index );
343: 341 000288AF L255:
344: 342 000288AF L252:
345: 343 000288AF 0d effffffd7b 50 movl _index,r0
346: 344 000288B6 6d effffffd74 incl _index
347: 345 000288BC 1d 50 effffffd6d cmpl r0,_max_ldf_1_index
348: 346 000288C3 81 03 13 ff1d jlss L253
349: 347 000288C8 L251:
350: 348 000288C8 # } /* end of subtest 2 */
351: 349 000288C8 40 ret#2
352: 350 000288C9 .set L247,0x0
353: 351 000288C9 L249:
354: 352 000288C9 13 ff0d jbr L250
355: 353 000288CC .data
356: 354 00000d78 * .text
357: 355 000288CC .align 1
358: 356 000288CC .globl _pipe4_3
359: 357 000288CC _pipe4_3:
360: 358 000288CC 0000 .word L260
361: 359 000288CE #
362: 360 000288CE #
363: 361 000288CE #
364: 362 000288CE #
365: 363 000288CE #
366: 364 000288CE #
367: 365 000288CE # /************************************************************************
368: 366 000288CE # *
369: 367 000288CE # * SUBTEST 3
370: 368 000288CE # * data in registers, 2 NO-OPs
371: 369 000288CE # *
372: 370 000288CE # ************************************************************************/
373: 371 000288CE # pipe4_3()
374: 372 000288CE # {
375: 373 000288CE 13 00f5 jbr L262
376: 374 000288D1 L263:
377: 375 000288D1 # force_loop = FALSE; /* clear force_loop flag */
378: 376 000288D1 4d effffffd59 clrl _force_loop
379: 377 000288D7 # index = 0;
380: 378 000288D7 4d effffffd53 clrl _index
381: 379 000288DD # do
382: 380 000288DD L266:
383: 381 000288DD # {
384: 382 000288DD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
385: 383 000288DD 0d effffffd4d 50 movl _index,r0
386: 384 000288E4 48 03 50 50 shll $3,r0,r0
387: 385 000288E8 0d e000000000 effffffd3d movl _ldf_1_data(r0),_sgl_value_1
388: 386 000288F3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
389: 387 000288F3 0d effffffd37 50 movl _index,r0
390: 388 000288FA 48 03 50 50 shll $3,r0,r0
391: 389 000288FE 0d e000000004 effffffd27 movl _ldf_1_data+4(r0),_sgl_expected
392: 390 00028909 # sgl_value_2 = 0x40800000; /* floating '1' */
393: 391 00028909 0d 8f40800000 effffffd1c movl $1082130432,_sgl_value_2
394: 392 00028914 # /*
395: 393 00028914 # * If LOOP ON ERROR is set, this is the loop for this subtest.
396: 394 00028914 # * The force loop flag is set after the first error.
397: 395 00028914 # */
398: 396 00028914 # asm("_pipe4_3_lp1:");
399: 397 00028914 _pipe4_3_lp1:
400: 398 00028914 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
401: 399 00028914 0d effffffd16 54 movl _sgl_value_1,r4
402: 400 0002891B # asm("movl _sgl_value_2,r5"); /* move data to r5 */
403: 401 0002891B 0d effffffd0f 55 movl _sgl_value_2,r5
404: 402 00028922 # asm("ldf r4"); /* load the operand */
405: 403 00028922 06 54 ldf r4
406: 404 00028924 # asm("nop");
407: 405 00028924 10 nop
408: 406 00028925 # asm("nop");
409: 407 00028925 10 nop
410: 408 00028926 # asm("stf r7"); /* store the result */
411: 409 00028926 26 57 stf r7
412: 410 00028928 # asm("nop");
413: 411 00028928 10 nop
414: 412 00028929 # asm("nop");
415: 413 00028929 10 nop
416: 414 0002892A # asm("ldf r5"); /* load a floating '1' */
417: 415 0002892A 06 55 ldf r5
418: 416 0002892C # asm("nop");
419: 417 0002892C 10 nop
420: 418 0002892D # asm("nop");
421: 419 0002892D 10 nop
422: 420 0002892E # asm("mulf r5"); /* multipy by a '1' */
423: 421 0002892E e6 55 mulf r5
424: 422 00028930 # asm("nop");
425: 423 00028930 10 nop
426: 424 00028931 # asm("nop");
427: 425 00028931 10 nop
428: 426 00028932 # asm("mulf r4"); /* multipy by the operand */
429: 427 00028932 e6 54 mulf r4
430: 428 00028934 # asm("nop");
431: 429 00028934 10 nop
432: 430 00028935 # asm("nop");
433: 431 00028935 10 nop
434: 432 00028936 # asm("stf r8"); /* store the result */
435: 433 00028936 26 58 stf r8
436: 434 00028938 # if( force_loop );
437: 435 00028938 5d effffffcf2 tstl _force_loop
438: 436 0002893E 31 00 jeql L267
439: 437 00028940 # asm("brb _pipe4_3_lp1");; /* loop on the error */
440: 438 00028940 L267:
441: 439 00028940 11 d2 brb _pipe4_3_lp1
442: 440 00028942 # /*
443: 441 00028942 # * verify the results
444: 442 00028942 # */
445: 443 00028942 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
446: 444 00028942 0d 57 effffffce7 movl r7,_sgl_st_acc
447: 445 00028949 # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
448: 446 00028949 0d 58 effffffce0 movl r8,_sgl_value_6
449: 447 00028950 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
450: 448 00028950 # (sgl_value_6 != sgl_expected) )
451: 449 00028950 1d effffffcda effffffcd5 cmpl _sgl_st_acc,_sgl_expected
452: 450 0002895B 21 0d jneq L9997
453: 451 0002895D 1d effffffccd effffffcc8 cmpl _sgl_value_6,_sgl_expected
454: 452 00028968 31 42 jeql L268
455: 453 0002896A L9997:
456: 454 0002896A # {
457: 455 0002896A # errcnt++; /* bump the error count */
458: 456 0002896A 6d effffffcc0 incl _errcnt
459: 457 00028970 # if ( prt_error )
460: 458 00028970 5d effffffcba tstl _prt_error
461: 459 00028976 31 0d jeql L269
462: 460 00028978 # print_pipe4_er("Reg. Data, 2 NO-OPs");
463: 461 00028978 .data 1
464: 462 00000da9 * L270:
465: 463 00000da9 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0"
466: 04E4F2D4F507300
467: 464 00000dbd * .text
468: 465 00028978 dd 8f00000da9 pushl $L270
469: 466 0002897E fe 08 ef00000889 callf $8,_print_pipe4_er
470: 467 00028985 # if ( halt_flg )
471: 468 00028985 L269:
472: 469 00028985 5d effffffca5 tstl _halt_flg
473: 470 0002898B 31 0d jeql L271
474: 471 0002898D # pipe4_er_hlt( subtest );
475: 472 0002898D dd effffffc9d pushl _subtest
476: 473 00028993 fe 08 ef0000099a callf $8,_pipe4_er_hlt
477: 474 0002899A # if ( loop_on_err ) {
478: 475 0002899A L271:
479: 476 0002899A 5d effffffc90 tstl _loop_on_err
480: 477 000289A0 31 0a jeql L272
481: 478 000289A2 # force_loop = TRUE; /* set the force loop flag */
482: 479 000289A2 0d 01 effffffc87 movl $1,_force_loop
483: 480 000289A9 # asm("brw _pipe4_3_lp1"); /* and loop */
484: 481 000289A9 13 ff68 brw _pipe4_3_lp1
485: 482 000289AC # }
486: 483 000289AC # } /* end of compare error */
487: 484 000289AC L272:
488: 485 000289AC # } while( index++ < max_ldf_1_index );
489: 486 000289AC L268:
490: 487 000289AC L265:
491: 488 000289AC 0d effffffc7e 50 movl _index,r0
492: 489 000289B3 6d effffffc77 incl _index
493: 490 000289B9 1d 50 effffffc70 cmpl r0,_max_ldf_1_index
494: 491 000289C0 81 03 13 ff18 jlss L266
495: 492 000289C5 L264:
496: 493 000289C5 # } /* end of subtest 3 */
497: 494 000289C5 40 ret#2
498: 495 000289C6 .set L260,0x0
499: 496 000289C6 L262:
500: 497 000289C6 13 ff08 jbr L263
501: 498 000289C9 .data
502: 499 00000d78 * .text
503: 500 000289C9 00 .align 1
504: 501 000289CA .globl _pipe4_4
505: 502 000289CA _pipe4_4:
506: 503 000289CA 0000 .word L273
507: 504 000289CC #
508: 505 000289CC #
509: 506 000289CC #
510: 507 000289CC #
511: 508 000289CC #
512: 509 000289CC #
513: 510 000289CC # /************************************************************************
514: 511 000289CC # *
515: 512 000289CC # * SUBTEST 4
516: 513 000289CC # * data in registers, 3 NO-OPs
517: 514 000289CC # *
518: 515 000289CC # ************************************************************************/
519: 516 000289CC # pipe4_4()
520: 517 000289CC # {
521: 518 000289CC 13 00fa jbr L275
522: 519 000289CF L276:
523: 520 000289CF # force_loop = FALSE; /* clear force_loop flag */
524: 521 000289CF 4d effffffc5b clrl _force_loop
525: 522 000289D5 # index = 0;
526: 523 000289D5 4d effffffc55 clrl _index
527: 524 000289DB # do
528: 525 000289DB L279:
529: 526 000289DB # {
530: 527 000289DB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
531: 528 000289DB 0d effffffc4f 50 movl _index,r0
532: 529 000289E2 48 03 50 50 shll $3,r0,r0
533: 530 000289E6 0d e000000000 effffffc3f movl _ldf_1_data(r0),_sgl_value_1
534: 531 000289F1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
535: 532 000289F1 0d effffffc39 50 movl _index,r0
536: 533 000289F8 48 03 50 50 shll $3,r0,r0
537: 534 000289FC 0d e000000004 effffffc29 movl _ldf_1_data+4(r0),_sgl_expected
538: 535 00028A07 # sgl_value_2 = 0x40800000; /* floating '1' */
539: 536 00028A07 0d 8f40800000 effffffc1e movl $1082130432,_sgl_value_2
540: 537 00028A12 # /*
541: 538 00028A12 # * If LOOP ON ERROR is set, this is the loop for this subtest.
542: 539 00028A12 # * The force loop flag is set after the first error.
543: 540 00028A12 # */
544: 541 00028A12 # asm("_pipe4_4_lp1:");
545: 542 00028A12 _pipe4_4_lp1:
546: 543 00028A12 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
547: 544 00028A12 0d effffffc18 54 movl _sgl_value_1,r4
548: 545 00028A19 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
549: 546 00028A19 0d effffffc11 55 movl _sgl_value_2,r5
550: 547 00028A20 # asm("ldf r4"); /* load the operand */
551: 548 00028A20 06 54 ldf r4
552: 549 00028A22 # asm("nop");
553: 550 00028A22 10 nop
554: 551 00028A23 # asm("nop");
555: 552 00028A23 10 nop
556: 553 00028A24 # asm("nop");
557: 554 00028A24 10 nop
558: 555 00028A25 # asm("stf r7"); /* store the result */
559: 556 00028A25 26 57 stf r7
560: 557 00028A27 # asm("nop");
561: 558 00028A27 10 nop
562: 559 00028A28 # asm("nop");
563: 560 00028A28 10 nop
564: 561 00028A29 # asm("nop");
565: 562 00028A29 10 nop
566: 563 00028A2A # asm("ldf r5"); /* load a floating '1' */
567: 564 00028A2A 06 55 ldf r5
568: 565 00028A2C # asm("nop");
569: 566 00028A2C 10 nop
570: 567 00028A2D # asm("nop");
571: 568 00028A2D 10 nop
572: 569 00028A2E # asm("nop");
573: 570 00028A2E 10 nop
574: 571 00028A2F # asm("mulf r5"); /* multipy by a '1' */
575: 572 00028A2F e6 55 mulf r5
576: 573 00028A31 # asm("nop");
577: 574 00028A31 10 nop
578: 575 00028A32 # asm("nop");
579: 576 00028A32 10 nop
580: 577 00028A33 # asm("nop");
581: 578 00028A33 10 nop
582: 579 00028A34 # asm("mulf r4"); /* multipy by the operand */
583: 580 00028A34 e6 54 mulf r4
584: 581 00028A36 # asm("nop");
585: 582 00028A36 10 nop
586: 583 00028A37 # asm("nop");
587: 584 00028A37 10 nop
588: 585 00028A38 # asm("nop");
589: 586 00028A38 10 nop
590: 587 00028A39 # asm("stf r8"); /* store the result */
591: 588 00028A39 26 58 stf r8
592: 589 00028A3B # if( force_loop );
593: 590 00028A3B 5d effffffbef tstl _force_loop
594: 591 00028A41 31 00 jeql L280
595: 592 00028A43 # asm("brb _pipe4_4_lp1");; /* loop on the error */
596: 593 00028A43 L280:
597: 594 00028A43 11 cd brb _pipe4_4_lp1
598: 595 00028A45 # /*
599: 596 00028A45 # * verify the results
600: 597 00028A45 # */
601: 598 00028A45 # asm("movl r7,_sgl_st_acc"); /* get the 1st store value */
602: 599 00028A45 0d 57 effffffbe4 movl r7,_sgl_st_acc
603: 600 00028A4C # asm("movl r8,_sgl_value_6"); /* get the 2nd store value */
604: 601 00028A4C 0d 58 effffffbdd movl r8,_sgl_value_6
605: 602 00028A53 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
606: 603 00028A53 # (sgl_value_6 != sgl_expected) )
607: 604 00028A53 1d effffffbd7 effffffbd2 cmpl _sgl_st_acc,_sgl_expected
608: 605 00028A5E 21 0d jneq L9996
609: 606 00028A60 1d effffffbca effffffbc5 cmpl _sgl_value_6,_sgl_expected
610: 607 00028A6B 31 42 jeql L281
611: 608 00028A6D L9996:
612: 609 00028A6D # {
613: 610 00028A6D # errcnt++; /* bump the error count */
614: 611 00028A6D 6d effffffbbd incl _errcnt
615: 612 00028A73 # if ( prt_error )
616: 613 00028A73 5d effffffbb7 tstl _prt_error
617: 614 00028A79 31 0d jeql L282
618: 615 00028A7B # print_pipe4_er("Reg. Data, 3 NO-OPs");
619: 616 00028A7B .data 1
620: 617 00000dbd * L283:
621: 618 00000dbd * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0"
622: 04E4F2D4F507300
623: 619 00000dd1 * .text
624: 620 00028A7B dd 8f00000dbd pushl $L283
625: 621 00028A81 fe 08 ef00000786 callf $8,_print_pipe4_er
626: 622 00028A88 # if ( halt_flg )
627: 623 00028A88 L282:
628: 624 00028A88 5d effffffba2 tstl _halt_flg
629: 625 00028A8E 31 0d jeql L284
630: 626 00028A90 # pipe4_er_hlt( subtest );
631: 627 00028A90 dd effffffb9a pushl _subtest
632: 628 00028A96 fe 08 ef00000897 callf $8,_pipe4_er_hlt
633: 629 00028A9D # if ( loop_on_err ) {
634: 630 00028A9D L284:
635: 631 00028A9D 5d effffffb8d tstl _loop_on_err
636: 632 00028AA3 31 0a jeql L285
637: 633 00028AA5 # force_loop = TRUE; /* set the force loop flag */
638: 634 00028AA5 0d 01 effffffb84 movl $1,_force_loop
639: 635 00028AAC # asm("brw _pipe4_4_lp1"); /* and loop */
640: 636 00028AAC 13 ff63 brw _pipe4_4_lp1
641: 637 00028AAF # }
642: 638 00028AAF # } /* end of compare error */
643: 639 00028AAF L285:
644: 640 00028AAF # } while( index++ < max_ldf_1_index );
645: 641 00028AAF L281:
646: 642 00028AAF L278:
647: 643 00028AAF 0d effffffb7b 50 movl _index,r0
648: 644 00028AB6 6d effffffb74 incl _index
649: 645 00028ABC 1d 50 effffffb6d cmpl r0,_max_ldf_1_index
650: 646 00028AC3 81 03 13 ff13 jlss L279
651: 647 00028AC8 L277:
652: 648 00028AC8 # } /* end of subtest 4 */
653: 649 00028AC8 40 ret#2
654: 650 00028AC9 .set L273,0x0
655: 651 00028AC9 L275:
656: 652 00028AC9 13 ff03 jbr L276
657: 653 00028ACC .data
658: 654 00000d78 * .text
659: 655 00028ACC .align 1
660: 656 00028ACC .globl _pipe4_5
661: 657 00028ACC _pipe4_5:
662: 658 00028ACC 0000 .word L286
663: 659 00028ACE #
664: 660 00028ACE #
665: 661 00028ACE #
666: 662 00028ACE #
667: 663 00028ACE #
668: 664 00028ACE #
669: 665 00028ACE #
670: 666 00028ACE # /************************************************************************
671: 667 00028ACE # *
672: 668 00028ACE # * SUBTEST 5
673: 669 00028ACE # * data in Cache, no NO-OPs
674: 670 00028ACE # *
675: 671 00028ACE # ************************************************************************/
676: 672 00028ACE # pipe4_5()
677: 673 00028ACE # {
678: 674 00028ACE 13 00e7 jbr L288
679: 675 00028AD1 L289:
680: 676 00028AD1 # force_loop = FALSE; /* clear force_loop flag */
681: 677 00028AD1 4d effffffb59 clrl _force_loop
682: 678 00028AD7 # index = 0;
683: 679 00028AD7 4d effffffb53 clrl _index
684: 680 00028ADD # do
685: 681 00028ADD L292:
686: 682 00028ADD # {
687: 683 00028ADD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
688: 684 00028ADD 0d effffffb4d 50 movl _index,r0
689: 685 00028AE4 48 03 50 50 shll $3,r0,r0
690: 686 00028AE8 0d e000000000 effffffb3d movl _ldf_1_data(r0),_sgl_value_1
691: 687 00028AF3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
692: 688 00028AF3 0d effffffb37 50 movl _index,r0
693: 689 00028AFA 48 03 50 50 shll $3,r0,r0
694: 690 00028AFE 0d e000000004 effffffb27 movl _ldf_1_data+4(r0),_sgl_expected
695: 691 00028B09 # sgl_value_2 = 0x40800000; /* floating '1' */
696: 692 00028B09 0d 8f40800000 effffffb1c movl $1082130432,_sgl_value_2
697: 693 00028B14 # /*
698: 694 00028B14 # * If LOOP ON ERROR is set, this is the loop for this subtest.
699: 695 00028B14 # * The force loop flag is set after the first error.
700: 696 00028B14 # */
701: 697 00028B14 # asm("_pipe4_5_lp1:");
702: 698 00028B14 _pipe4_5_lp1:
703: 699 00028B14 # asm("ldf _sgl_value_1"); /* load the operand */
704: 700 00028B14 06 effffffb16 ldf _sgl_value_1
705: 701 00028B1A # asm("stf _sgl_st_acc"); /* store the result */
706: 702 00028B1A 26 effffffb10 stf _sgl_st_acc
707: 703 00028B20 # asm("ldf _sgl_value_2"); /* load a floating '1' */
708: 704 00028B20 06 effffffb0a ldf _sgl_value_2
709: 705 00028B26 # asm("mulf _sgl_value_2"); /* multipy by a '1' */
710: 706 00028B26 e6 effffffb04 mulf _sgl_value_2
711: 707 00028B2C # asm("mulf _sgl_value_1"); /* multipy by the operand */
712: 708 00028B2C e6 effffffafe mulf _sgl_value_1
713: 709 00028B32 # asm("stf _sgl_value_6"); /* store the result */
714: 710 00028B32 26 effffffaf8 stf _sgl_value_6
715: 711 00028B38 # if( force_loop );
716: 712 00028B38 5d effffffaf2 tstl _force_loop
717: 713 00028B3E 31 00 jeql L293
718: 714 00028B40 # asm("brb _pipe4_5_lp1");; /* loop on the error */
719: 715 00028B40 L293:
720: 716 00028B40 11 d2 brb _pipe4_5_lp1
721: 717 00028B42 # /*
722: 718 00028B42 # * verify the results
723: 719 00028B42 # */
724: 720 00028B42 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
725: 721 00028B42 # (sgl_value_6 != sgl_expected) )
726: 722 00028B42 1d effffffae8 effffffae3 cmpl _sgl_st_acc,_sgl_expected
727: 723 00028B4D 21 0d jneq L9995
728: 724 00028B4F 1d effffffadb effffffad6 cmpl _sgl_value_6,_sgl_expected
729: 725 00028B5A 31 42 jeql L294
730: 726 00028B5C L9995:
731: 727 00028B5C # {
732: 728 00028B5C # errcnt++; /* bump the error count */
733: 729 00028B5C 6d efffffface incl _errcnt
734: 730 00028B62 # if ( prt_error )
735: 731 00028B62 5d effffffac8 tstl _prt_error
736: 732 00028B68 31 0d jeql L295
737: 733 00028B6A # print_pipe4_er("Cache Data, no NO-OPs");
738: 734 00028B6A .data 1
739: 735 00000dd1 * L296:
740: 736 00000dd1 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0"
741: E6F204E4F2D4F507300
742: 737 00000de7 * .text
743: 738 00028B6A dd 8f00000dd1 pushl $L296
744: 739 00028B70 fe 08 ef00000697 callf $8,_print_pipe4_er
745: 740 00028B77 # if ( halt_flg )
746: 741 00028B77 L295:
747: 742 00028B77 5d effffffab3 tstl _halt_flg
748: 743 00028B7D 31 0d jeql L297
749: 744 00028B7F # pipe4_er_hlt( subtest );
750: 745 00028B7F dd effffffaab pushl _subtest
751: 746 00028B85 fe 08 ef000007a8 callf $8,_pipe4_er_hlt
752: 747 00028B8C # if ( loop_on_err ) {
753: 748 00028B8C L297:
754: 749 00028B8C 5d effffffa9e tstl _loop_on_err
755: 750 00028B92 31 0a jeql L298
756: 751 00028B94 # force_loop = TRUE; /* set the force loop flag */
757: 752 00028B94 0d 01 effffffa95 movl $1,_force_loop
758: 753 00028B9B # asm("brw _pipe4_5_lp1"); /* and loop */
759: 754 00028B9B 13 ff76 brw _pipe4_5_lp1
760: 755 00028B9E # }
761: 756 00028B9E # } /* end of compare error */
762: 757 00028B9E L298:
763: 758 00028B9E # } while( index++ < max_ldf_1_index );
764: 759 00028B9E L294:
765: 760 00028B9E L291:
766: 761 00028B9E 0d effffffa8c 50 movl _index,r0
767: 762 00028BA5 6d effffffa85 incl _index
768: 763 00028BAB 1d 50 effffffa7e cmpl r0,_max_ldf_1_index
769: 764 00028BB2 81 03 13 ff26 jlss L292
770: 765 00028BB7 L290:
771: 766 00028BB7 # } /* end of subtest 5 */
772: 767 00028BB7 40 ret#2
773: 768 00028BB8 .set L286,0x0
774: 769 00028BB8 L288:
775: 770 00028BB8 13 ff16 jbr L289
776: 771 00028BBB .data
777: 772 00000d78 * .text
778: 773 00028BBB 00 .align 1
779: 774 00028BBC .globl _pipe4_6
780: 775 00028BBC _pipe4_6:
781: 776 00028BBC 0000 .word L299
782: 777 00028BBE #
783: 778 00028BBE #
784: 779 00028BBE #
785: 780 00028BBE #
786: 781 00028BBE #
787: 782 00028BBE #
788: 783 00028BBE # /************************************************************************
789: 784 00028BBE # *
790: 785 00028BBE # * SUBTEST 6
791: 786 00028BBE # * data in Cache, 1 NO-OP
792: 787 00028BBE # *
793: 788 00028BBE # ************************************************************************/
794: 789 00028BBE # pipe4_6()
795: 790 00028BBE # {
796: 791 00028BBE 13 00ec jbr L301
797: 792 00028BC1 L302:
798: 793 00028BC1 # force_loop = FALSE; /* clear force_loop flag */
799: 794 00028BC1 4d effffffa69 clrl _force_loop
800: 795 00028BC7 # index = 0;
801: 796 00028BC7 4d effffffa63 clrl _index
802: 797 00028BCD # do
803: 798 00028BCD L305:
804: 799 00028BCD # {
805: 800 00028BCD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
806: 801 00028BCD 0d effffffa5d 50 movl _index,r0
807: 802 00028BD4 48 03 50 50 shll $3,r0,r0
808: 803 00028BD8 0d e000000000 effffffa4d movl _ldf_1_data(r0),_sgl_value_1
809: 804 00028BE3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
810: 805 00028BE3 0d effffffa47 50 movl _index,r0
811: 806 00028BEA 48 03 50 50 shll $3,r0,r0
812: 807 00028BEE 0d e000000004 effffffa37 movl _ldf_1_data+4(r0),_sgl_expected
813: 808 00028BF9 # sgl_value_2 = 0x40800000; /* floating '1' */
814: 809 00028BF9 0d 8f40800000 effffffa2c movl $1082130432,_sgl_value_2
815: 810 00028C04 # /*
816: 811 00028C04 # * If LOOP ON ERROR is set, this is the loop for this subtest.
817: 812 00028C04 # * The force loop flag is set after the first error.
818: 813 00028C04 # */
819: 814 00028C04 # asm("_pipe4_6_lp1:");
820: 815 00028C04 _pipe4_6_lp1:
821: 816 00028C04 # asm("ldf _sgl_value_1"); /* load the operand */
822: 817 00028C04 06 effffffa26 ldf _sgl_value_1
823: 818 00028C0A # asm("nop");
824: 819 00028C0A 10 nop
825: 820 00028C0B # asm("stf _sgl_st_acc"); /* store the result */
826: 821 00028C0B 26 effffffa1f stf _sgl_st_acc
827: 822 00028C11 # asm("nop");
828: 823 00028C11 10 nop
829: 824 00028C12 # asm("ldf _sgl_value_2"); /* load a floating '1' */
830: 825 00028C12 06 effffffa18 ldf _sgl_value_2
831: 826 00028C18 # asm("nop");
832: 827 00028C18 10 nop
833: 828 00028C19 # asm("mulf _sgl_value_2"); /* multipy by a '1' */
834: 829 00028C19 e6 effffffa11 mulf _sgl_value_2
835: 830 00028C1F # asm("nop");
836: 831 00028C1F 10 nop
837: 832 00028C20 # asm("mulf _sgl_value_1"); /* multipy by the operand */
838: 833 00028C20 e6 effffffa0a mulf _sgl_value_1
839: 834 00028C26 # asm("nop");
840: 835 00028C26 10 nop
841: 836 00028C27 # asm("stf _sgl_value_6"); /* store the result */
842: 837 00028C27 26 effffffa03 stf _sgl_value_6
843: 838 00028C2D # if( force_loop );
844: 839 00028C2D 5d effffff9fd tstl _force_loop
845: 840 00028C33 31 00 jeql L306
846: 841 00028C35 # asm("brb _pipe4_6_lp1");; /* loop on the error */
847: 842 00028C35 L306:
848: 843 00028C35 11 cd brb _pipe4_6_lp1
849: 844 00028C37 # /*
850: 845 00028C37 # * verify the results
851: 846 00028C37 # */
852: 847 00028C37 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
853: 848 00028C37 # (sgl_value_6 != sgl_expected) )
854: 849 00028C37 1d effffff9f3 effffff9ee cmpl _sgl_st_acc,_sgl_expected
855: 850 00028C42 21 0d jneq L9994
856: 851 00028C44 1d effffff9e6 effffff9e1 cmpl _sgl_value_6,_sgl_expected
857: 852 00028C4F 31 42 jeql L307
858: 853 00028C51 L9994:
859: 854 00028C51 # {
860: 855 00028C51 # errcnt++; /* bump the error count */
861: 856 00028C51 6d effffff9d9 incl _errcnt
862: 857 00028C57 # if ( prt_error )
863: 858 00028C57 5d effffff9d3 tstl _prt_error
864: 859 00028C5D 31 0d jeql L308
865: 860 00028C5F # print_pipe4_er("Cache Data, 1 NO-OP");
866: 861 00028C5F .data 1
867: 862 00000de7 * L309:
868: 863 00000de7 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
869: 1204E4F2D4F5000
870: 864 00000dfb * .text
871: 865 00028C5F dd 8f00000de7 pushl $L309
872: 866 00028C65 fe 08 ef000005a2 callf $8,_print_pipe4_er
873: 867 00028C6C # if ( halt_flg )
874: 868 00028C6C L308:
875: 869 00028C6C 5d effffff9be tstl _halt_flg
876: 870 00028C72 31 0d jeql L310
877: 871 00028C74 # pipe4_er_hlt( subtest );
878: 872 00028C74 dd effffff9b6 pushl _subtest
879: 873 00028C7A fe 08 ef000006b3 callf $8,_pipe4_er_hlt
880: 874 00028C81 # if ( loop_on_err ) {
881: 875 00028C81 L310:
882: 876 00028C81 5d effffff9a9 tstl _loop_on_err
883: 877 00028C87 31 0a jeql L311
884: 878 00028C89 # force_loop = TRUE; /* set the force loop flag */
885: 879 00028C89 0d 01 effffff9a0 movl $1,_force_loop
886: 880 00028C90 # asm("brw _pipe4_6_lp1"); /* and loop */
887: 881 00028C90 13 ff71 brw _pipe4_6_lp1
888: 882 00028C93 # }
889: 883 00028C93 # } /* end of compare error */
890: 884 00028C93 L311:
891: 885 00028C93 # } while( index++ < max_ldf_1_index );
892: 886 00028C93 L307:
893: 887 00028C93 L304:
894: 888 00028C93 0d effffff997 50 movl _index,r0
895: 889 00028C9A 6d effffff990 incl _index
896: 890 00028CA0 1d 50 effffff989 cmpl r0,_max_ldf_1_index
897: 891 00028CA7 81 03 13 ff21 jlss L305
898: 892 00028CAC L303:
899: 893 00028CAC # } /* end of subtest 6 */
900: 894 00028CAC 40 ret#2
901: 895 00028CAD .set L299,0x0
902: 896 00028CAD L301:
903: 897 00028CAD 13 ff11 jbr L302
904: 898 00028CB0 .data
905: 899 00000d78 * .text
906: 900 00028CB0 .align 1
907: 901 00028CB0 .globl _pipe4_7
908: 902 00028CB0 _pipe4_7:
909: 903 00028CB0 0000 .word L312
910: 904 00028CB2 #
911: 905 00028CB2 #
912: 906 00028CB2 #
913: 907 00028CB2 #
914: 908 00028CB2 #
915: 909 00028CB2 #
916: 910 00028CB2 # /************************************************************************
917: 911 00028CB2 # *
918: 912 00028CB2 # * SUBTEST 7
919: 913 00028CB2 # * data in Cache, 2 NO-OPs
920: 914 00028CB2 # *
921: 915 00028CB2 # ************************************************************************/
922: 916 00028CB2 # pipe4_7()
923: 917 00028CB2 # {
924: 918 00028CB2 13 00f1 jbr L314
925: 919 00028CB5 L315:
926: 920 00028CB5 # force_loop = FALSE; /* clear force_loop flag */
927: 921 00028CB5 4d effffff975 clrl _force_loop
928: 922 00028CBB # index = 0;
929: 923 00028CBB 4d effffff96f clrl _index
930: 924 00028CC1 # do
931: 925 00028CC1 L318:
932: 926 00028CC1 # {
933: 927 00028CC1 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
934: 928 00028CC1 0d effffff969 50 movl _index,r0
935: 929 00028CC8 48 03 50 50 shll $3,r0,r0
936: 930 00028CCC 0d e000000000 effffff959 movl _ldf_1_data(r0),_sgl_value_1
937: 931 00028CD7 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
938: 932 00028CD7 0d effffff953 50 movl _index,r0
939: 933 00028CDE 48 03 50 50 shll $3,r0,r0
940: 934 00028CE2 0d e000000004 effffff943 movl _ldf_1_data+4(r0),_sgl_expected
941: 935 00028CED # sgl_value_2 = 0x40800000; /* floating '1' */
942: 936 00028CED 0d 8f40800000 effffff938 movl $1082130432,_sgl_value_2
943: 937 00028CF8 # /*
944: 938 00028CF8 # * If LOOP ON ERROR is set, this is the loop for this subtest.
945: 939 00028CF8 # * The force loop flag is set after the first error.
946: 940 00028CF8 # */
947: 941 00028CF8 # asm("_pipe4_7_lp1:");
948: 942 00028CF8 _pipe4_7_lp1:
949: 943 00028CF8 # asm("ldf _sgl_value_1"); /* load the operand */
950: 944 00028CF8 06 effffff932 ldf _sgl_value_1
951: 945 00028CFE # asm("nop");
952: 946 00028CFE 10 nop
953: 947 00028CFF # asm("nop");
954: 948 00028CFF 10 nop
955: 949 00028D00 # asm("stf _sgl_st_acc"); /* store the result */
956: 950 00028D00 26 effffff92a stf _sgl_st_acc
957: 951 00028D06 # asm("nop");
958: 952 00028D06 10 nop
959: 953 00028D07 # asm("nop");
960: 954 00028D07 10 nop
961: 955 00028D08 # asm("ldf _sgl_value_2"); /* load a floating '1' */
962: 956 00028D08 06 effffff922 ldf _sgl_value_2
963: 957 00028D0E # asm("nop");
964: 958 00028D0E 10 nop
965: 959 00028D0F # asm("nop");
966: 960 00028D0F 10 nop
967: 961 00028D10 # asm("mulf _sgl_value_2"); /* multipy by '1' */
968: 962 00028D10 e6 effffff91a mulf _sgl_value_2
969: 963 00028D16 # asm("nop");
970: 964 00028D16 10 nop
971: 965 00028D17 # asm("nop");
972: 966 00028D17 10 nop
973: 967 00028D18 # asm("mulf _sgl_value_1"); /* multipy by the operand */
974: 968 00028D18 e6 effffff912 mulf _sgl_value_1
975: 969 00028D1E # asm("nop");
976: 970 00028D1E 10 nop
977: 971 00028D1F # asm("nop");
978: 972 00028D1F 10 nop
979: 973 00028D20 # asm("stf _sgl_value_6"); /* store the result */
980: 974 00028D20 26 effffff90a stf _sgl_value_6
981: 975 00028D26 # if( force_loop );
982: 976 00028D26 5d effffff904 tstl _force_loop
983: 977 00028D2C 31 00 jeql L319
984: 978 00028D2E # asm("brb _pipe4_7_lp1");; /* loop on the error */
985: 979 00028D2E L319:
986: 980 00028D2E 11 c8 brb _pipe4_7_lp1
987: 981 00028D30 # /*
988: 982 00028D30 # * verify the results
989: 983 00028D30 # */
990: 984 00028D30 # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
991: 985 00028D30 # (sgl_value_6 != sgl_expected) )
992: 986 00028D30 1d effffff8fa effffff8f5 cmpl _sgl_st_acc,_sgl_expected
993: 987 00028D3B 21 0d jneq L9993
994: 988 00028D3D 1d effffff8ed effffff8e8 cmpl _sgl_value_6,_sgl_expected
995: 989 00028D48 31 42 jeql L320
996: 990 00028D4A L9993:
997: 991 00028D4A # {
998: 992 00028D4A # errcnt++; /* bump the error count */
999: 993 00028D4A 6d effffff8e0 incl _errcnt
1000: 994 00028D50 # if ( prt_error )
1001: 995 00028D50 5d effffff8da tstl _prt_error
1002: 996 00028D56 31 0d jeql L321
1003: 997 00028D58 # print_pipe4_er("Cache Data, 2 NO-OPs");
1004: 998 00028D58 .data 1
1005: 999 00000dfb * L322:
1006: 1000 00000dfb * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0"
1007: 2204E4F2D4F507300
1008: 1001 00000e10 * .text
1009: 1002 00028D58 dd 8f00000dfb pushl $L322
1010: 1003 00028D5E fe 08 ef000004a9 callf $8,_print_pipe4_er
1011: 1004 00028D65 # if ( halt_flg )
1012: 1005 00028D65 L321:
1013: 1006 00028D65 5d effffff8c5 tstl _halt_flg
1014: 1007 00028D6B 31 0d jeql L323
1015: 1008 00028D6D # pipe4_er_hlt( subtest );
1016: 1009 00028D6D dd effffff8bd pushl _subtest
1017: 1010 00028D73 fe 08 ef000005ba callf $8,_pipe4_er_hlt
1018: 1011 00028D7A # if ( loop_on_err ) {
1019: 1012 00028D7A L323:
1020: 1013 00028D7A 5d effffff8b0 tstl _loop_on_err
1021: 1014 00028D80 31 0a jeql L324
1022: 1015 00028D82 # force_loop = TRUE; /* set the force loop flag */
1023: 1016 00028D82 0d 01 effffff8a7 movl $1,_force_loop
1024: 1017 00028D89 # asm("brw _pipe4_7_lp1"); /* and loop */
1025: 1018 00028D89 13 ff6c brw _pipe4_7_lp1
1026: 1019 00028D8C # }
1027: 1020 00028D8C # } /* end of compare error */
1028: 1021 00028D8C L324:
1029: 1022 00028D8C # } while( index++ < max_ldf_1_index );
1030: 1023 00028D8C L320:
1031: 1024 00028D8C L317:
1032: 1025 00028D8C 0d effffff89e 50 movl _index,r0
1033: 1026 00028D93 6d effffff897 incl _index
1034: 1027 00028D99 1d 50 effffff890 cmpl r0,_max_ldf_1_index
1035: 1028 00028DA0 81 03 13 ff1c jlss L318
1036: 1029 00028DA5 L316:
1037: 1030 00028DA5 # } /* end of subtest 7 */
1038: 1031 00028DA5 40 ret#2
1039: 1032 00028DA6 .set L312,0x0
1040: 1033 00028DA6 L314:
1041: 1034 00028DA6 13 ff0c jbr L315
1042: 1035 00028DA9 .data
1043: 1036 00000d78 * .text
1044: 1037 00028DA9 00 .align 1
1045: 1038 00028DAA .globl _pipe4_8
1046: 1039 00028DAA _pipe4_8:
1047: 1040 00028DAA 0000 .word L325
1048: 1041 00028DAC #
1049: 1042 00028DAC #
1050: 1043 00028DAC #
1051: 1044 00028DAC #
1052: 1045 00028DAC #
1053: 1046 00028DAC #
1054: 1047 00028DAC # /************************************************************************
1055: 1048 00028DAC # *
1056: 1049 00028DAC # * SUBTEST 8
1057: 1050 00028DAC # * data in Cache, 3 NO-OPs
1058: 1051 00028DAC # *
1059: 1052 00028DAC # ************************************************************************/
1060: 1053 00028DAC # pipe4_8()
1061: 1054 00028DAC # {
1062: 1055 00028DAC 13 00f6 jbr L327
1063: 1056 00028DAF L328:
1064: 1057 00028DAF # force_loop = FALSE; /* clear force_loop flag */
1065: 1058 00028DAF 4d effffff87b clrl _force_loop
1066: 1059 00028DB5 # index = 0;
1067: 1060 00028DB5 4d effffff875 clrl _index
1068: 1061 00028DBB # do
1069: 1062 00028DBB L331:
1070: 1063 00028DBB # {
1071: 1064 00028DBB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1072: 1065 00028DBB 0d effffff86f 50 movl _index,r0
1073: 1066 00028DC2 48 03 50 50 shll $3,r0,r0
1074: 1067 00028DC6 0d e000000000 effffff85f movl _ldf_1_data(r0),_sgl_value_1
1075: 1068 00028DD1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1076: 1069 00028DD1 0d effffff859 50 movl _index,r0
1077: 1070 00028DD8 48 03 50 50 shll $3,r0,r0
1078: 1071 00028DDC 0d e000000004 effffff849 movl _ldf_1_data+4(r0),_sgl_expected
1079: 1072 00028DE7 # sgl_value_2 = 0x40800000; /* floating '1' */
1080: 1073 00028DE7 0d 8f40800000 effffff83e movl $1082130432,_sgl_value_2
1081: 1074 00028DF2 # /*
1082: 1075 00028DF2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1083: 1076 00028DF2 # * The force loop flag is set after the first error.
1084: 1077 00028DF2 # */
1085: 1078 00028DF2 # asm("_pipe4_8_lp1:");
1086: 1079 00028DF2 _pipe4_8_lp1:
1087: 1080 00028DF2 # asm("ldf _sgl_value_1"); /* load the operand */
1088: 1081 00028DF2 06 effffff838 ldf _sgl_value_1
1089: 1082 00028DF8 # asm("nop");
1090: 1083 00028DF8 10 nop
1091: 1084 00028DF9 # asm("nop");
1092: 1085 00028DF9 10 nop
1093: 1086 00028DFA # asm("nop");
1094: 1087 00028DFA 10 nop
1095: 1088 00028DFB # asm("stf _sgl_st_acc"); /* store the result */
1096: 1089 00028DFB 26 effffff82f stf _sgl_st_acc
1097: 1090 00028E01 # asm("nop");
1098: 1091 00028E01 10 nop
1099: 1092 00028E02 # asm("nop");
1100: 1093 00028E02 10 nop
1101: 1094 00028E03 # asm("nop");
1102: 1095 00028E03 10 nop
1103: 1096 00028E04 # asm("ldf _sgl_value_2"); /* load a floating '1' */
1104: 1097 00028E04 06 effffff826 ldf _sgl_value_2
1105: 1098 00028E0A # asm("nop");
1106: 1099 00028E0A 10 nop
1107: 1100 00028E0B # asm("nop");
1108: 1101 00028E0B 10 nop
1109: 1102 00028E0C # asm("nop");
1110: 1103 00028E0C 10 nop
1111: 1104 00028E0D # asm("mulf _sgl_value_2"); /* multipy by a '1' */
1112: 1105 00028E0D e6 effffff81d mulf _sgl_value_2
1113: 1106 00028E13 # asm("nop");
1114: 1107 00028E13 10 nop
1115: 1108 00028E14 # asm("nop");
1116: 1109 00028E14 10 nop
1117: 1110 00028E15 # asm("nop");
1118: 1111 00028E15 10 nop
1119: 1112 00028E16 # asm("mulf _sgl_value_1"); /* multipy by the operand */
1120: 1113 00028E16 e6 effffff814 mulf _sgl_value_1
1121: 1114 00028E1C # asm("nop");
1122: 1115 00028E1C 10 nop
1123: 1116 00028E1D # asm("nop");
1124: 1117 00028E1D 10 nop
1125: 1118 00028E1E # asm("nop");
1126: 1119 00028E1E 10 nop
1127: 1120 00028E1F # asm("stf _sgl_value_6"); /* store the result */
1128: 1121 00028E1F 26 effffff80b stf _sgl_value_6
1129: 1122 00028E25 # if( force_loop );
1130: 1123 00028E25 5d effffff805 tstl _force_loop
1131: 1124 00028E2B 31 00 jeql L332
1132: 1125 00028E2D # asm("brb _pipe4_8_lp1");; /* loop on the error */
1133: 1126 00028E2D L332:
1134: 1127 00028E2D 11 c3 brb _pipe4_8_lp1
1135: 1128 00028E2F # /*
1136: 1129 00028E2F # * verify the results
1137: 1130 00028E2F # */
1138: 1131 00028E2F # if( (sgl_st_acc != sgl_expected) || /* COMPARE the values */
1139: 1132 00028E2F # (sgl_value_6 != sgl_expected) )
1140: 1133 00028E2F 1d effffff7fb effffff7f6 cmpl _sgl_st_acc,_sgl_expected
1141: 1134 00028E3A 21 0d jneq L9992
1142: 1135 00028E3C 1d effffff7ee effffff7e9 cmpl _sgl_value_6,_sgl_expected
1143: 1136 00028E47 31 42 jeql L333
1144: 1137 00028E49 L9992:
1145: 1138 00028E49 # {
1146: 1139 00028E49 # errcnt++; /* bump the error count */
1147: 1140 00028E49 6d effffff7e1 incl _errcnt
1148: 1141 00028E4F # if ( prt_error )
1149: 1142 00028E4F 5d effffff7db tstl _prt_error
1150: 1143 00028E55 31 0d jeql L334
1151: 1144 00028E57 # print_pipe4_er("Cache Data, 3 NO-OPs");
1152: 1145 00028E57 .data 1
1153: 1146 00000e10 * L335:
1154: 1147 00000e10 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0"
1155: 3204E4F2D4F507300
1156: 1148 00000e25 * .text
1157: 1149 00028E57 dd 8f00000e10 pushl $L335
1158: 1150 00028E5D fe 08 ef000003aa callf $8,_print_pipe4_er
1159: 1151 00028E64 # if ( halt_flg )
1160: 1152 00028E64 L334:
1161: 1153 00028E64 5d effffff7c6 tstl _halt_flg
1162: 1154 00028E6A 31 0d jeql L336
1163: 1155 00028E6C # pipe4_er_hlt( subtest );
1164: 1156 00028E6C dd effffff7be pushl _subtest
1165: 1157 00028E72 fe 08 ef000004bb callf $8,_pipe4_er_hlt
1166: 1158 00028E79 # if ( loop_on_err ) {
1167: 1159 00028E79 L336:
1168: 1160 00028E79 5d effffff7b1 tstl _loop_on_err
1169: 1161 00028E7F 31 0a jeql L337
1170: 1162 00028E81 # force_loop = TRUE; /* set the force loop flag */
1171: 1163 00028E81 0d 01 effffff7a8 movl $1,_force_loop
1172: 1164 00028E88 # asm("brw _pipe4_8_lp1"); /* and loop */
1173: 1165 00028E88 13 ff67 brw _pipe4_8_lp1
1174: 1166 00028E8B # }
1175: 1167 00028E8B # } /* end of compare error */
1176: 1168 00028E8B L337:
1177: 1169 00028E8B # } while( index++ < max_ldf_1_index );
1178: 1170 00028E8B L333:
1179: 1171 00028E8B L330:
1180: 1172 00028E8B 0d effffff79f 50 movl _index,r0
1181: 1173 00028E92 6d effffff798 incl _index
1182: 1174 00028E98 1d 50 effffff791 cmpl r0,_max_ldf_1_index
1183: 1175 00028E9F 81 03 13 ff17 jlss L331
1184: 1176 00028EA4 L329:
1185: 1177 00028EA4 # } /* end of subtest 8 */
1186: 1178 00028EA4 40 ret#2
1187: 1179 00028EA5 .set L325,0x0
1188: 1180 00028EA5 L327:
1189: 1181 00028EA5 13 ff07 jbr L328
1190: 1182 00028EA8 .data
1191: 1183 00000d78 * .text
1192: 1184 00028EA8 .align 1
1193: 1185 00028EA8 .globl _pipe4_9
1194: 1186 00028EA8 _pipe4_9:
1195: 1187 00028EA8 0000 .word L338
1196: 1188 00028EAA #
1197: 1189 00028EAA #
1198: 1190 00028EAA #
1199: 1191 00028EAA #
1200: 1192 00028EAA #
1201: 1193 00028EAA #
1202: 1194 00028EAA # /*****************************************************************************
1203: 1195 00028EAA # *
1204: 1196 00028EAA # * SUBTEST 9
1205: 1197 00028EAA # * data on the stack, no NO-OPs
1206: 1198 00028EAA # *
1207: 1199 00028EAA # *****************************************************************************/
1208: 1200 00028EAA # pipe4_9()
1209: 1201 00028EAA # {
1210: 1202 00028EAA 13 018d jbr L340
1211: 1203 00028EAD L341:
1212: 1204 00028EAD # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1213: 1205 00028EAD ed 6d effffff77c moval (r13),_pre_event_fp
1214: 1206 00028EB4 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1215: 1207 00028EB4 ed 6e effffff775 moval (r14),_pre_event_sp
1216: 1208 00028EBB # force_loop = FALSE; /* clear force_loop flag */
1217: 1209 00028EBB 4d effffff76f clrl _force_loop
1218: 1210 00028EC1 # index = 0;
1219: 1211 00028EC1 4d effffff769 clrl _index
1220: 1212 00028EC7 # do
1221: 1213 00028EC7 L344:
1222: 1214 00028EC7 # {
1223: 1215 00028EC7 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1224: 1216 00028EC7 0d effffff763 50 movl _index,r0
1225: 1217 00028ECE 48 03 50 50 shll $3,r0,r0
1226: 1218 00028ED2 0d e000000000 effffff753 movl _ldf_1_data(r0),_sgl_value_1
1227: 1219 00028EDD # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1228: 1220 00028EDD 0d effffff74d 50 movl _index,r0
1229: 1221 00028EE4 48 03 50 50 shll $3,r0,r0
1230: 1222 00028EE8 0d e000000004 effffff73d movl _ldf_1_data+4(r0),_sgl_expected
1231: 1223 00028EF3 # sgl_value_2 = 0x40800000; /* floating '1' */
1232: 1224 00028EF3 0d 8f40800000 effffff732 movl $1082130432,_sgl_value_2
1233: 1225 00028EFE # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1234: 1226 00028EFE ed effffff72c effffff727 moval _pointer_data,_sgl_value_4
1235: 1227 00028F09 # /*
1236: 1228 00028F09 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1237: 1229 00028F09 # * The force loop flag is set after the first error.
1238: 1230 00028F09 # */
1239: 1231 00028F09 # asm("_pipe4_9_lp1:");
1240: 1232 00028F09 _pipe4_9_lp1:
1241: 1233 00028F09 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1242: 1234 00028F09 ed effffff721 5e moval _pointer_data,r14
1243: 1235 00028F10 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1244: 1236 00028F10 0d effffff71a 7e movl _sgl_value_1,-(r14)
1245: 1237 00028F17 # asm("movl _sgl_value_2,-(r14)"); /* push a floating '1' */
1246: 1238 00028F17 0d effffff713 7e movl _sgl_value_2,-(r14)
1247: 1239 00028F1E # asm("movl _sgl_value_2,-(r14)"); /* push a '1' again */
1248: 1240 00028F1E 0d effffff70c 7e movl _sgl_value_2,-(r14)
1249: 1241 00028F25 # asm("movl _sgl_value_1,-(r14)"); /* push the operand again */
1250: 1242 00028F25 0d effffff705 7e movl _sgl_value_1,-(r14)
1251: 1243 00028F2C # /*
1252: 1244 00028F2C # * now pop the data off the stack
1253: 1245 00028F2C # */
1254: 1246 00028F2C #
1255: 1247 00028F2C # asm("ldf (r14)+"); /* load the operand */
1256: 1248 00028F2C 06 8e ldf (r14)+
1257: 1249 00028F2E # asm("stf r5"); /* store the result */
1258: 1250 00028F2E 26 55 stf r5
1259: 1251 00028F30 # asm("ldf (r14)+"); /* load a floating '1' */
1260: 1252 00028F30 06 8e ldf (r14)+
1261: 1253 00028F32 # asm("mulf (r14)+"); /* multipy by a '1' */
1262: 1254 00028F32 e6 8e mulf (r14)+
1263: 1255 00028F34 # asm("mulf (r14)+"); /* multipy by the operand */
1264: 1256 00028F34 e6 8e mulf (r14)+
1265: 1257 00028F36 # asm("stf r6"); /* store the result */
1266: 1258 00028F36 26 56 stf r6
1267: 1259 00028F38 # if( force_loop );
1268: 1260 00028F38 5d effffff6f2 tstl _force_loop
1269: 1261 00028F3E 31 00 jeql L345
1270: 1262 00028F40 # asm("brb _pipe4_9_lp1");; /* loop on the error */
1271: 1263 00028F40 L345:
1272: 1264 00028F40 11 c7 brb _pipe4_9_lp1
1273: 1265 00028F42 # /*
1274: 1266 00028F42 # * verify the results
1275: 1267 00028F42 # */
1276: 1268 00028F42 # asm("movl r5,_sgl_st_acc"); /* get the 1st store value */
1277: 1269 00028F42 0d 55 effffff6e7 movl r5,_sgl_st_acc
1278: 1270 00028F49 # asm("movl r6,_sgl_value_6"); /* get the 2nd store value */
1279: 1271 00028F49 0d 56 effffff6e0 movl r6,_sgl_value_6
1280: 1272 00028F50 # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1281: 1273 00028F50 ed 6e effffff6d9 moval (r14),_sgl_value_5
1282: 1274 00028F57 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1283: 1275 00028F57 # (sgl_value_6 != sgl_expected) ||
1284: 1276 00028F57 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1285: 1277 00028F57 1d effffff6d3 effffff6ce cmpl _sgl_st_acc,_sgl_expected
1286: 1278 00028F62 21 1d jneq L9991
1287: 1279 00028F64 1d effffff6c6 effffff6c1 cmpl _sgl_value_6,_sgl_expected
1288: 1280 00028F6F 21 10 jneq L9991
1289: 1281 00028F71 1d effffff6b9 effffff6b4 cmpl _sgl_value_5,_sgl_value_4
1290: 1282 00028F7C 21 03 13 0091 jeql L346
1291: 1283 00028F81 L9991:
1292: 1284 00028F81 # {
1293: 1285 00028F81 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1294: 1286 00028F81 0d effffff6a9 5d movl _pre_event_fp,r13
1295: 1287 00028F88 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1296: 1288 00028F88 0d effffff6a2 5e movl _pre_event_sp,r14
1297: 1289 00028F8F # errcnt++; /* bump the error count */
1298: 1290 00028F8F 6d effffff69b incl _errcnt
1299: 1291 00028F95 # if ( prt_error ) {
1300: 1292 00028F95 5d effffff695 tstl _prt_error
1301: 1293 00028F9B 31 4e jeql L347
1302: 1294 00028F9D # print_pipe4_er("POP data from the STACK");
1303: 1295 00028F9D .data 1
1304: 1296 00000e25 * L348:
1305: 1297 00000e25 * 504F5020646174612066726F6 .ascii "POP data from the STACK\0"
1306: D2074686520535441434B00
1307: 1298 00000e3d * .text
1308: 1299 00028F9D dd 8f00000e25 pushl $L348
1309: 1300 00028FA3 fe 08 ef00000264 callf $8,_print_pipe4_er
1310: 1301 00028FAA # writes("final Stack Pointer = ");
1311: 1302 00028FAA .data 1
1312: 1303 00000e3d * L349:
1313: 1304 00000e3d * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
1314: 06F696E746572203D2000
1315: 1305 00000e54 * .text
1316: 1306 00028FAA dd 8f00000e3d pushl $L349
1317: 1307 00028FB0 fe 08 effffff679 callf $8,_writes
1318: 1308 00028FB7 # write32h( sgl_value_5 );
1319: 1309 00028FB7 dd effffff673 pushl _sgl_value_5
1320: 1310 00028FBD fe 08 effffff66c callf $8,_write32h
1321: 1311 00028FC4 # writes(", expected SP = ");
1322: 1312 00028FC4 .data 1
1323: 1313 00000e54 * L351:
1324: 1314 00000e54 * 2C20206578706563746564205 .ascii ", expected SP = \0"
1325: 350203D2000
1326: 1315 00000e66 * .text
1327: 1316 00028FC4 dd 8f00000e54 pushl $L351
1328: 1317 00028FCA fe 08 effffff65f callf $8,_writes
1329: 1318 00028FD1 # write32h( sgl_value_4 );
1330: 1319 00028FD1 dd effffff659 pushl _sgl_value_4
1331: 1320 00028FD7 fe 08 effffff652 callf $8,_write32h
1332: 1321 00028FDE # writes("\n");
1333: 1322 00028FDE .data 1
1334: 1323 00000e66 * L352:
1335: 1324 00000e66 * 0A00 .ascii "\12\0"
1336: 1325 00000e68 * .text
1337: 1326 00028FDE dd 8f00000e66 pushl $L352
1338: 1327 00028FE4 fe 08 effffff645 callf $8,_writes
1339: 1328 00028FEB # }
1340: 1329 00028FEB # if ( halt_flg )
1341: 1330 00028FEB L347:
1342: 1331 00028FEB 5d effffff63f tstl _halt_flg
1343: 1332 00028FF1 31 0d jeql L353
1344: 1333 00028FF3 # pipe4_er_hlt( subtest );
1345: 1334 00028FF3 dd effffff637 pushl _subtest
1346: 1335 00028FF9 fe 08 ef00000334 callf $8,_pipe4_er_hlt
1347: 1336 00029000 # if ( loop_on_err ) {
1348: 1337 00029000 L353:
1349: 1338 00029000 5d effffff62a tstl _loop_on_err
1350: 1339 00029006 31 0a jeql L354
1351: 1340 00029008 # force_loop = TRUE; /* set the force loop flag */
1352: 1341 00029008 0d 01 effffff621 movl $1,_force_loop
1353: 1342 0002900F # asm("brw _pipe4_9_lp1"); /* and loop */
1354: 1343 0002900F 13 fef7 brw _pipe4_9_lp1
1355: 1344 00029012 # }
1356: 1345 00029012 # } /* end of compare error */
1357: 1346 00029012 L354:
1358: 1347 00029012 # } while( index++ < max_ldf_1_index );
1359: 1348 00029012 L346:
1360: 1349 00029012 L343:
1361: 1350 00029012 0d effffff618 50 movl _index,r0
1362: 1351 00029019 6d effffff611 incl _index
1363: 1352 0002901F 1d 50 effffff60a cmpl r0,_max_ldf_1_index
1364: 1353 00029026 81 03 13 fe9c jlss L344
1365: 1354 0002902B L342:
1366: 1355 0002902B # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1367: 1356 0002902B 0d effffff5ff 5d movl _pre_event_fp,r13
1368: 1357 00029032 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1369: 1358 00029032 0d effffff5f8 5e movl _pre_event_sp,r14
1370: 1359 00029039 # } /* end of subtest 9 */
1371: 1360 00029039 40 ret#2
1372: 1361 0002903A .set L338,0x0
1373: 1362 0002903A L340:
1374: 1363 0002903A 13 fe70 jbr L341
1375: 1364 0002903D .data
1376: 1365 00000d78 * .text
1377: 1366 0002903D 00 .align 1
1378: 1367 0002903E .globl _pipe4_10
1379: 1368 0002903E _pipe4_10:
1380: 1369 0002903E 0000 .word L355
1381: 1370 00029040 #
1382: 1371 00029040 #
1383: 1372 00029040 #
1384: 1373 00029040 #
1385: 1374 00029040 #
1386: 1375 00029040 #
1387: 1376 00029040 # /******************************************************************************
1388: 1377 00029040 # *
1389: 1378 00029040 # * SUBTEST 10
1390: 1379 00029040 # * get data via indexed FRAME pointer
1391: 1380 00029040 # *
1392: 1381 00029040 # * ADDR INDEX DATA
1393: 1382 00029040 # * pointer_data 4 <the 1st STF result goes here>
1394: 1383 00029040 # * pointer_data-4 3 <the 2nd STF result goes here>
1395: 1384 00029040 # * pointer_data-8 2 <operand data>
1396: 1385 00029040 # * pointer_data-12 1 <floating '1'>
1397: 1386 00029040 # * pointer_data-16 0 point the frame pointer here
1398: 1387 00029040 # *
1399: 1388 00029040 # ******************************************************************************/
1400: 1389 00029040 # pipe4_10()
1401: 1390 00029040 # {
1402: 1391 00029040 13 01c8 jbr L357
1403: 1392 00029043 L358:
1404: 1393 00029043 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1405: 1394 00029043 ed 6d effffff5e6 moval (r13),_pre_event_fp
1406: 1395 0002904A # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1407: 1396 0002904A ed 6e effffff5df moval (r14),_pre_event_sp
1408: 1397 00029051 # force_loop = FALSE; /* clear force_loop flag */
1409: 1398 00029051 4d effffff5d9 clrl _force_loop
1410: 1399 00029057 # index = 0;
1411: 1400 00029057 4d effffff5d3 clrl _index
1412: 1401 0002905D # do
1413: 1402 0002905D L361:
1414: 1403 0002905D # {
1415: 1404 0002905D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1416: 1405 0002905D 0d effffff5cd 50 movl _index,r0
1417: 1406 00029064 48 03 50 50 shll $3,r0,r0
1418: 1407 00029068 0d e000000000 effffff5bd movl _ldf_1_data(r0),_sgl_value_1
1419: 1408 00029073 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1420: 1409 00029073 0d effffff5b7 50 movl _index,r0
1421: 1410 0002907A 48 03 50 50 shll $3,r0,r0
1422: 1411 0002907E 0d e000000004 effffff5a7 movl _ldf_1_data+4(r0),_sgl_expected
1423: 1412 00029089 # sgl_value_2 = 0x40800000; /* floating '1' */
1424: 1413 00029089 0d 8f40800000 effffff59c movl $1082130432,_sgl_value_2
1425: 1414 00029094 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
1426: 1415 00029094 ed effffff596 effffff591 moval _pointer_data,_sgl_value_4
1427: 1416 0002909F # sgl_value_4 -= 8; /* decrement it by 8 (bytes)*/
1428: 1417 0002909F 2c 08 effffff58a subl2 $8,_sgl_value_4
1429: 1418 000290A6 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
1430: 1419 000290A6 0d effffff584 fffffff57f movl _sgl_value_1,*_sgl_value_4
1431: 1420 000290B1 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1432: 1421 000290B1 2c 04 effffff578 subl2 $4,_sgl_value_4
1433: 1422 000290B8 # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the floating '1' */
1434: 1423 000290B8 0d effffff572 fffffff56d movl _sgl_value_2,*_sgl_value_4
1435: 1424 000290C3 # sgl_value_4 -= 4; /* get FRAME PTR address */
1436: 1425 000290C3 2c 04 effffff566 subl2 $4,_sgl_value_4
1437: 1426 000290CA # /*
1438: 1427 000290CA # * If LOOP ON ERROR is set, this is the loop for this subtest.
1439: 1428 000290CA # * The force loop flag is set after the first error.
1440: 1429 000290CA # */
1441: 1430 000290CA # asm("_pipe4_10_lp1:");
1442: 1431 000290CA _pipe4_10_lp1:
1443: 1432 000290CA # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1444: 1433 000290CA 0d effffff560 5d movl _sgl_value_4,r13
1445: 1434 000290D1 # asm("movl $1,r1"); /* r1 index = 1 longwords */
1446: 1435 000290D1 0d 01 51 movl $1,r1
1447: 1436 000290D4 # asm("movl $2,r2"); /* r2 index = 2 longwords */
1448: 1437 000290D4 0d 02 52 movl $2,r2
1449: 1438 000290D7 # asm("movl $3,r3"); /* r3 index = 3 longwords */
1450: 1439 000290D7 0d 03 53 movl $3,r3
1451: 1440 000290DA # asm("movl $4,r4"); /* r4 index = 4 longwords */
1452: 1441 000290DA 0d 04 54 movl $4,r4
1453: 1442 000290DD # asm("ldf (r13)[r2]"); /* load the op (indx = 2) */
1454: 1443 000290DD 06 426d ldf (r13)[r2]
1455: 1444 000290E0 # asm("stf (r13)[r4]"); /* store -index = 4 */
1456: 1445 000290E0 26 446d stf (r13)[r4]
1457: 1446 000290E3 # asm("ldf (r13)[r1]"); /* load '1' (indx = 1) */
1458: 1447 000290E3 06 416d ldf (r13)[r1]
1459: 1448 000290E6 # asm("mulf (r13)[r1]"); /* multiply by a '1' */
1460: 1449 000290E6 e6 416d mulf (r13)[r1]
1461: 1450 000290E9 # asm("mulf (r13)[r2]"); /* multiply by the operand */
1462: 1451 000290E9 e6 426d mulf (r13)[r2]
1463: 1452 000290EC # asm("stf (r13)[r3]"); /* store -index = 3 */
1464: 1453 000290EC 26 436d stf (r13)[r3]
1465: 1454 000290EF # if( force_loop );
1466: 1455 000290EF 5d effffff53b tstl _force_loop
1467: 1456 000290F5 31 00 jeql L362
1468: 1457 000290F7 # asm("brb _pipe4_10_lp1");; /* loop on the error */
1469: 1458 000290F7 L362:
1470: 1459 000290F7 11 d1 brb _pipe4_10_lp1
1471: 1460 000290F9 # /*
1472: 1461 000290F9 # * verify the results
1473: 1462 000290F9 # */
1474: 1463 000290F9 # sgl_st_acc = pointer_data; /* save 1st stored value */
1475: 1464 000290F9 0d effffff531 effffff52c movl _pointer_data,_sgl_st_acc
1476: 1465 00029104 # asm("moval _pointer_data,_sgl_value_5"); /* get addr of 1st stf */
1477: 1466 00029104 ed effffff526 effffff521 moval _pointer_data,_sgl_value_5
1478: 1467 0002910F # sgl_value_5 -= 4; /* decrement by 4 (bytes) */
1479: 1468 0002910F 2c 04 effffff51a subl2 $4,_sgl_value_5
1480: 1469 00029116 # asm("movl *_sgl_value_5,_sgl_value_6"); /* save 2nd store value */
1481: 1470 00029116 0d fffffff514 effffff50f movl *_sgl_value_5,_sgl_value_6
1482: 1471 00029121 # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1483: 1472 00029121 ed 6d effffff508 moval (r13),_sgl_value_5
1484: 1473 00029128 # if( (sgl_st_acc != sgl_expected) || /* verify the results... */
1485: 1474 00029128 # (sgl_value_6 != sgl_expected) ||
1486: 1475 00029128 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1487: 1476 00029128 1d effffff502 effffff4fd cmpl _sgl_st_acc,_sgl_expected
1488: 1477 00029133 21 1d jneq L9990
1489: 1478 00029135 1d effffff4f5 effffff4f0 cmpl _sgl_value_6,_sgl_expected
1490: 1479 00029140 21 10 jneq L9990
1491: 1480 00029142 1d effffff4e8 effffff4e3 cmpl _sgl_value_5,_sgl_value_4
1492: 1481 0002914D 21 03 13 0091 jeql L363
1493: 1482 00029152 L9990:
1494: 1483 00029152 # {
1495: 1484 00029152 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1496: 1485 00029152 0d effffff4d8 5d movl _pre_event_fp,r13
1497: 1486 00029159 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1498: 1487 00029159 0d effffff4d1 5e movl _pre_event_sp,r14
1499: 1488 00029160 # errcnt++; /* bump the error count */
1500: 1489 00029160 6d effffff4ca incl _errcnt
1501: 1490 00029166 # if ( prt_error ) {
1502: 1491 00029166 5d effffff4c4 tstl _prt_error
1503: 1492 0002916C 31 4e jeql L364
1504: 1493 0002916E # print_pipe4_er("indexed FP addressing");
1505: 1494 0002916E .data 1
1506: 1495 00000e68 * L365:
1507: 1496 00000e68 * 696E646578656420465020616 .ascii "indexed FP addressing\0"
1508: 46472657373696E6700
1509: 1497 00000e7e * .text
1510: 1498 0002916E dd 8f00000e68 pushl $L365
1511: 1499 00029174 fe 08 ef00000093 callf $8,_print_pipe4_er
1512: 1500 0002917B # writes("final Frame Pointer = ");
1513: 1501 0002917B .data 1
1514: 1502 00000e7e * L366:
1515: 1503 00000e7e * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
1516: 06F696E746572203D2000
1517: 1504 00000e95 * .text
1518: 1505 0002917B dd 8f00000e7e pushl $L366
1519: 1506 00029181 fe 08 effffff4a8 callf $8,_writes
1520: 1507 00029188 # writeh( sgl_value_5 );
1521: 1508 00029188 dd effffff4a2 pushl _sgl_value_5
1522: 1509 0002918E fe 08 effffff49b callf $8,_writeh
1523: 1510 00029195 # writes(", expected FP = ");
1524: 1511 00029195 .data 1
1525: 1512 00000e95 * L368:
1526: 1513 00000e95 * 2C20206578706563746564204 .ascii ", expected FP = \0"
1527: 650203D2000
1528: 1514 00000ea7 * .text
1529: 1515 00029195 dd 8f00000e95 pushl $L368
1530: 1516 0002919B fe 08 effffff48e callf $8,_writes
1531: 1517 000291A2 # writeh( sgl_value_4 );
1532: 1518 000291A2 dd effffff488 pushl _sgl_value_4
1533: 1519 000291A8 fe 08 effffff481 callf $8,_writeh
1534: 1520 000291AF # writes("\n");
1535: 1521 000291AF .data 1
1536: 1522 00000ea7 * L369:
1537: 1523 00000ea7 * 0A00 .ascii "\12\0"
1538: 1524 00000ea9 * .text
1539: 1525 000291AF dd 8f00000ea7 pushl $L369
1540: 1526 000291B5 fe 08 effffff474 callf $8,_writes
1541: 1527 000291BC # }
1542: 1528 000291BC # if ( halt_flg )
1543: 1529 000291BC L364:
1544: 1530 000291BC 5d effffff46e tstl _halt_flg
1545: 1531 000291C2 31 0d jeql L370
1546: 1532 000291C4 # pipe4_er_hlt( subtest );
1547: 1533 000291C4 dd effffff466 pushl _subtest
1548: 1534 000291CA fe 08 ef00000163 callf $8,_pipe4_er_hlt
1549: 1535 000291D1 # if ( loop_on_err ) {
1550: 1536 000291D1 L370:
1551: 1537 000291D1 5d effffff459 tstl _loop_on_err
1552: 1538 000291D7 31 0a jeql L371
1553: 1539 000291D9 # force_loop = TRUE; /* set the force loop flag */
1554: 1540 000291D9 0d 01 effffff450 movl $1,_force_loop
1555: 1541 000291E0 # asm("brw _pipe4_10_lp1"); /* and loop */
1556: 1542 000291E0 13 fee7 brw _pipe4_10_lp1
1557: 1543 000291E3 # }
1558: 1544 000291E3 # } /* end of compare error */
1559: 1545 000291E3 L371:
1560: 1546 000291E3 # } while( index++ < max_ldf_1_index );
1561: 1547 000291E3 L363:
1562: 1548 000291E3 L360:
1563: 1549 000291E3 0d effffff447 50 movl _index,r0
1564: 1550 000291EA 6d effffff440 incl _index
1565: 1551 000291F0 1d 50 effffff439 cmpl r0,_max_ldf_1_index
1566: 1552 000291F7 81 03 13 fe61 jlss L361
1567: 1553 000291FC L359:
1568: 1554 000291FC # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1569: 1555 000291FC 0d effffff42e 5d movl _pre_event_fp,r13
1570: 1556 00029203 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1571: 1557 00029203 0d effffff427 5e movl _pre_event_sp,r14
1572: 1558 0002920A # } /* end of subtest 10 */
1573: 1559 0002920A 40 ret#2
1574: 1560 0002920B .set L355,0x0
1575: 1561 0002920B L357:
1576: 1562 0002920B 13 fe35 jbr L358
1577: 1563 0002920E .data
1578: 1564 00000d78 * .text
1579: 1565 0002920E .align 1
1580: 1566 0002920E .globl _print_pipe4_er
1581: 1567 0002920E _print_pipe4_er:
1582: 1568 0002920E 0000 .word L372
1583: 1569 00029210 #
1584: 1570 00029210 #
1585: 1571 00029210 # /******************************************************************************
1586: 1572 00029210 # *
1587: 1573 00029210 # *
1588: 1574 00029210 # * print an error in the following form
1589: 1575 00029210 # *
1590: 1576 00029210 # * operand = xxxxxxxx, 1st store = xxxxxxxx, data index = dd
1591: 1577 00029210 # * 2nd store = xxxxxxxx, expected Acc = xxxxxxxx
1592: 1578 00029210 # *
1593: 1579 00029210 # ******************************************************************************/
1594: 1580 00029210 # print_pipe4_er(msg)
1595: 1581 00029210 # char *msg;
1596: 1582 00029210 # {
1597: 1583 00029210 13 011d jbr L374
1598: 1584 00029213 L375:
1599: 1585 00029213 # writes("\n"); /* start a new print line */
1600: 1586 00029213 .data 1
1601: 1587 00000ea9 * L376:
1602: 1588 00000ea9 * 0A00 .ascii "\12\0"
1603: 1589 00000eab * .text
1604: 1590 00029213 dd 8f00000ea9 pushl $L376
1605: 1591 00029219 fe 08 effffff410 callf $8,_writes
1606: 1592 00029220 # writes("cycle: ");
1607: 1593 00029220 .data 1
1608: 1594 00000eab * L377:
1609: 1595 00000eab * 6379636C653A2000 .ascii "cycle: \0"
1610: 1596 00000eb3 * .text
1611: 1597 00029220 dd 8f00000eab pushl $L377
1612: 1598 00029226 fe 08 effffff403 callf $8,_writes
1613: 1599 0002922D # writed( cycle );
1614: 1600 0002922D dd effffff3fd pushl _cycle
1615: 1601 00029233 fe 08 effffff3f6 callf $8,_writed
1616: 1602 0002923A # writes(" test ");
1617: 1603 0002923A .data 1
1618: 1604 00000eb3 * L379:
1619: 1605 00000eb3 * 20746573742000 .ascii " test \0"
1620: 1606 00000eba * .text
1621: 1607 0002923A dd 8f00000eb3 pushl $L379
1622: 1608 00029240 fe 08 effffff3e9 callf $8,_writes
1623: 1609 00029247 # writed( test_no );
1624: 1610 00029247 dd effffff3e3 pushl _test_no
1625: 1611 0002924D fe 08 effffff3dc callf $8,_writed
1626: 1612 00029254 # writes(" (Pipe 4), subtest ");
1627: 1613 00029254 .data 1
1628: 1614 00000eba * L380:
1629: 1615 00000eba * 202028506970652034292C207 .ascii " (Pipe 4), subtest \0"
1630: 37562746573742000
1631: 1616 00000ecf * .text
1632: 1617 00029254 dd 8f00000eba pushl $L380
1633: 1618 0002925A fe 08 effffff3cf callf $8,_writes
1634: 1619 00029261 # writed( subtest );
1635: 1620 00029261 dd effffff3c9 pushl _subtest
1636: 1621 00029267 fe 08 effffff3c2 callf $8,_writed
1637: 1622 0002926E # writes(" error - ");
1638: 1623 0002926E .data 1
1639: 1624 00000ecf * L381:
1640: 1625 00000ecf * 206572726F72202D2000 .ascii " error - \0"
1641: 1626 00000ed9 * .text
1642: 1627 0002926E dd 8f00000ecf pushl $L381
1643: 1628 00029274 fe 08 effffff3b5 callf $8,_writes
1644: 1629 0002927B # writes( msg );
1645: 1630 0002927B dd ad04 pushl 4(fp)
1646: 1631 0002927E fe 08 effffff3ab callf $8,_writes
1647: 1632 00029285 # writec('\n');
1648: 1633 00029285 dd 0a pushl $10
1649: 1634 00029287 fe 08 effffff3a2 callf $8,_writec
1650: 1635 0002928E # writes(" LDF(op), STF, LDF(1.0), MULF(op), STF\n");
1651: 1636 0002928E .data 1
1652: 1637 00000ed9 * L383:
1653: 1638 00000ed9 * 204C4446286F70292C2053544 .ascii " LDF(op), STF, LDF(1.0), MULF(op), STF\12\0"
1654: 62C204C444628312E30292C20
1655: 4D554C46286F70292C2053544
1656: 60A00
1657: 1639 00000f01 * .text
1658: 1640 0002928E dd 8f00000ed9 pushl $L383
1659: 1641 00029294 fe 08 effffff395 callf $8,_writes
1660: 1642 0002929B # writes(" operand = ");
1661: 1643 0002929B .data 1
1662: 1644 00000f01 * L384:
1663: 1645 00000f01 * 20206F706572616E64203D200 .ascii " operand = \0"
1664: 0
1665: 1646 00000f0e * .text
1666: 1647 0002929B dd 8f00000f01 pushl $L384
1667: 1648 000292A1 fe 08 effffff388 callf $8,_writes
1668: 1649 000292A8 # write32h( sgl_value_1 );
1669: 1650 000292A8 dd effffff382 pushl _sgl_value_1
1670: 1651 000292AE fe 08 effffff37b callf $8,_write32h
1671: 1652 000292B5 # writes(", 1st store = ");
1672: 1653 000292B5 .data 1
1673: 1654 00000f0e * L385:
1674: 1655 00000f0e * 2C20202020203173742073746 .ascii ", 1st store = \0"
1675: F7265203D2000
1676: 1656 00000f21 * .text
1677: 1657 000292B5 dd 8f00000f0e pushl $L385
1678: 1658 000292BB fe 08 effffff36e callf $8,_writes
1679: 1659 000292C2 # write32h( sgl_st_acc );
1680: 1660 000292C2 dd effffff368 pushl _sgl_st_acc
1681: 1661 000292C8 fe 08 effffff361 callf $8,_write32h
1682: 1662 000292CF # writes(", data index = ");
1683: 1663 000292CF .data 1
1684: 1664 00000f21 * L386:
1685: 1665 00000f21 * 2C2020206461746120696E646 .ascii ", data index = \0"
1686: 578203D2000
1687: 1666 00000f33 * .text
1688: 1667 000292CF dd 8f00000f21 pushl $L386
1689: 1668 000292D5 fe 08 effffff354 callf $8,_writes
1690: 1669 000292DC # writed( index );
1691: 1670 000292DC dd effffff34e pushl _index
1692: 1671 000292E2 fe 08 effffff347 callf $8,_writed
1693: 1672 000292E9 # writec('\n');
1694: 1673 000292E9 dd 0a pushl $10
1695: 1674 000292EB fe 08 effffff33e callf $8,_writec
1696: 1675 000292F2 # writes("2nd store = ");
1697: 1676 000292F2 .data 1
1698: 1677 00000f33 * L387:
1699: 1678 00000f33 * .ascii ""
1700: 1679 00000f33 * 326E642073746F7265203D200 .ascii "2nd store = \0"
1701: 0
1702: 1680 00000f40 * .text
1703: 1681 000292F2 dd 8f00000f33 pushl $L387
1704: 1682 000292F8 fe 08 effffff331 callf $8,_writes
1705: 1683 000292FF # write32h( sgl_value_6 );
1706: 1684 000292FF dd effffff32b pushl _sgl_value_6
1707: 1685 00029305 fe 08 effffff324 callf $8,_write32h
1708: 1686 0002930C # writes(", expected Acc = ");
1709: 1687 0002930C .data 1
1710: 1688 00000f40 * L388:
1711: 1689 00000f40 * 2C20206578706563746564204 .ascii ", expected Acc = \0"
1712: 16363203D2000
1713: 1690 00000f53 * .text
1714: 1691 0002930C dd 8f00000f40 pushl $L388
1715: 1692 00029312 fe 08 effffff317 callf $8,_writes
1716: 1693 00029319 # write32h( sgl_expected );
1717: 1694 00029319 dd effffff311 pushl _sgl_expected
1718: 1695 0002931F fe 08 effffff30a callf $8,_write32h
1719: 1696 00029326 # writec('\n');
1720: 1697 00029326 dd 0a pushl $10
1721: 1698 00029328 fe 08 effffff301 callf $8,_writec
1722: 1699 0002932F # }
1723: 1700 0002932F 40 ret#2
1724: 1701 00029330 .set L372,0x0
1725: 1702 00029330 L374:
1726: 1703 00029330 13 fee0 jbr L375
1727: 1704 00029333 .data
1728: 1705 00000d78 * .text
1729: 1706 00029333 00 .align 1
1730: 1707 00029334 .globl _pipe4_er_hlt
1731: 1708 00029334 _pipe4_er_hlt:
1732: 1709 00029334 0000 .word L389
1733: 1710 00029336 #
1734: 1711 00029336 #
1735: 1712 00029336 #
1736: 1713 00029336 #
1737: 1714 00029336 #
1738: 1715 00029336 # /******************************************************************************
1739: 1716 00029336 # *
1740: 1717 00029336 # * HALT ON ERROR ROUTINE
1741: 1718 00029336 # *
1742: 1719 00029336 # * halt with the necessary information saved in the registers
1743: 1720 00029336 # *
1744: 1721 00029336 # ******************************************************************************/
1745: 1722 00029336 # pipe4_er_hlt( subtest )
1746: 1723 00029336 # int subtest;
1747: 1724 00029336 # {
1748: 1725 00029336 11 6e jbr L391
1749: 1726 00029338 L392:
1750: 1727 00029338 # asm("movl _test_no,r0"); /* r0 = test number */
1751: 1728 00029338 0d effffff2f2 50 movl _test_no,r0
1752: 1729 0002933F # asm("movl _subtest,r1"); /* r1 = subtest number */
1753: 1730 0002933F 0d effffff2eb 51 movl _subtest,r1
1754: 1731 00029346 # asm("movl $1,r2"); /* r2 = error code */
1755: 1732 00029346 0d 01 52 movl $1,r2
1756: 1733 00029349 # asm("movl _cycle,r3"); /* r3 = cycle count */
1757: 1734 00029349 0d effffff2e1 53 movl _cycle,r3
1758: 1735 00029350 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1759: 1736 00029350 0d effffff2da 54 movl _sgl_value_1,r4
1760: 1737 00029357 # asm("movl _sgl_st_acc,r5"); /* r5 = 1st word stored */
1761: 1738 00029357 0d effffff2d3 55 movl _sgl_st_acc,r5
1762: 1739 0002935E # asm("movl _sgl_value_6,r6"); /* r6 = 2nd word stored */
1763: 1740 0002935E 0d effffff2cc 56 movl _sgl_value_6,r6
1764: 1741 00029365 # asm("movl _sgl_expected,r7"); /* r7 = sgl expected */
1765: 1742 00029365 0d effffff2c5 57 movl _sgl_expected,r7
1766: 1743 0002936C # asm("movl _index,r8"); /* r8 = data index */
1767: 1744 0002936C 0d effffff2be 58 movl _index,r8
1768: 1745 00029373 # asm("movl _sgl_value_2,r9"); /* r9 = floating one */
1769: 1746 00029373 0d effffff2b7 59 movl _sgl_value_2,r9
1770: 1747 0002937A # if( subtest == 9 ) {
1771: 1748 0002937A 1d ad04 09 cmpl 4(fp),$9
1772: 1749 0002937E 21 10 jneq L393
1773: 1750 00029380 # asm("movl _sgl_value_5,r10"); /* r10= final SP value */
1774: 1751 00029380 0d effffff2aa 5a movl _sgl_value_5,r10
1775: 1752 00029387 # asm("movl _sgl_value_4,r11"); /* r11= expected SP value */
1776: 1753 00029387 0d effffff2a3 5b movl _sgl_value_4,r11
1777: 1754 0002938E # } else
1778: 1755 0002938E 11 14 jbr L394
1779: 1756 00029390 L393:
1780: 1757 00029390 # if( subtest == 10 ) {
1781: 1758 00029390 1d ad04 0a cmpl 4(fp),$10
1782: 1759 00029394 21 0e jneq L395
1783: 1760 00029396 # asm("movl _sgl_value_5,r10"); /* r10= final FP value */
1784: 1761 00029396 0d effffff294 5a movl _sgl_value_5,r10
1785: 1762 0002939D # asm("movl _sgl_value_4,r11"); /* r11= expected FP value */
1786: 1763 0002939D 0d effffff28d 5b movl _sgl_value_4,r11
1787: 1764 000293A4 # };
1788: 1765 000293A4 L395:
1789: 1766 000293A4 L394:
1790: 1767 000293A4 # asm(".globl _pipe4_1_hlt");
1791: 1768 000293A4 .globl _pipe4_1_hlt
1792: 1769 000293A4 # asm("_pipe4_1_hlt:"); /* PC after the halt */
1793: 1770 000293A4 _pipe4_1_hlt:
1794: 1771 000293A4 # asm("halt"); /* HALT ... */
1795: 1772 000293A4 00 halt
1796: 1773 000293A5 # } /* end of halt on error */
1797: 1774 000293A5 40 ret#2
1798: 1775 000293A6 .set L389,0x0
1799: 1776 000293A6 L391:
1800: 1777 000293A6 11 90 jbr L392
1801: 1778 00000d78 * .data
1802: 1778 00000d78 * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.