![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe2.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 pipe2.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_2
6: 6 00000000 _pipe_2:
7: 7 00026C3C 0000 .word L215
8: 8 00026C3E #
9: 9 00026C3E #
10: 10 00026C3E # #include "fpp_defs.h"
11: 11 00026C3E #
12: 12 00026C3E #
13: 13 00026C3E # /*****************************************************************************
14: 14 00026C3E # *
15: 15 00026C3E # * PIPELINE TEST #2 MONITOR
16: 16 00026C3E # *
17: 17 00026C3E # * This test will do:
18: 18 00026C3E # *
19: 19 00026C3E # * LNF(x), MULF(1), MULF(1), ADDF(0), MULF(1), STF
20: 20 00026C3E # *
21: 21 00026C3E # * where x is the fmacro1 LNF data.
22: 22 00026C3E # *****************************************************************************/
23: 23 00026C3E # pipe_2()
24: 24 00026C3E # {
25: 25 00026C3E 13 00a8 jbr L217
26: 26 00026C41 L218:
27: 27 00026C41 # asm(".globl _pipeline_2_t");
28: 28 00026C41 .globl _pipeline_2_t
29: 29 00026C41 # asm("_pipeline_2_t:"); /* entry address */
30: 30 00026C41 _pipeline_2_t:
31: 31 00026C41 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
32: 32 00026C41 1d effffffff5 01 cmpl _cycle,$1
33: 33 00026C48 21 15 jneq L219
34: 34 00026C4A 5d efffffffec tstl _prt_hdrs
35: 35 00026C50 31 0d jeql L219
36: 36 00026C52 # {
37: 37 00026C52 # writes(" PIPE_2 ");
38: 38 00026C52 .data 1
39: 39 00000d0c * L221:
40: 40 00000d0c * 20504950455F322000 .ascii " PIPE_2 \0"
41: 41 00000d15 * .text
42: 42 00026C52 dd 8f00000d0c pushl $L221
43: 43 00026C58 fe 08 efffffffdd callf $8,_writes
44: 44 00026C5F # }
45: 45 00026C5F # subtest = 1;
46: 46 00026C5F L219:
47: 47 00026C5F 0d 01 efffffffd6 movl $1,_subtest
48: 48 00026C66 # pipe2_1(); /* data in REGs, no NOPs */
49: 49 00026C66 fe 04 ef0000007f callf $4,_pipe2_1
50: 50 00026C6D # subtest++; /* increment the subtest */
51: 51 00026C6D 6d efffffffc9 incl _subtest
52: 52 00026C73 # pipe2_2(); /* data in REGs, 1 NOP */
53: 53 00026C73 fe 04 ef0000015e callf $4,_pipe2_2
54: 54 00026C7A # subtest++; /* increment the subtest */
55: 55 00026C7A 6d efffffffbc incl _subtest
56: 56 00026C80 # pipe2_3(); /* data in REGs, 2 NOPs */
57: 57 00026C80 fe 04 ef00000243 callf $4,_pipe2_3
58: 58 00026C87 # subtest++; /* increment the subtest */
59: 59 00026C87 6d efffffffaf incl _subtest
60: 60 00026C8D # pipe2_4(); /* data in REGs, 3 NOPs */
61: 61 00026C8D fe 04 ef0000032c callf $4,_pipe2_4
62: 62 00026C94 # subtest++; /* increment the subtest */
63: 63 00026C94 6d efffffffa2 incl _subtest
64: 64 00026C9A # pipe2_5(); /* data in CACHE, no NOPs */
65: 65 00026C9A fe 04 ef0000041b callf $4,_pipe2_5
66: 66 00026CA1 # subtest++; /* increment the subtest */
67: 67 00026CA1 6d efffffff95 incl _subtest
68: 68 00026CA7 # pipe2_6(); /* data in CACHE, 1 NOP */
69: 69 00026CA7 fe 04 ef000004f6 callf $4,_pipe2_6
70: 70 00026CAE # subtest++; /* increment the subtest */
71: 71 00026CAE 6d efffffff88 incl _subtest
72: 72 00026CB4 # pipe2_7(); /* data in CACHE, 2 NOPs */
73: 73 00026CB4 fe 04 ef000005d7 callf $4,_pipe2_7
74: 74 00026CBB # subtest++; /* increment the subtest */
75: 75 00026CBB 6d efffffff7b incl _subtest
76: 76 00026CC1 # pipe2_8(); /* data in CACHE, 3 NOPs */
77: 77 00026CC1 fe 04 ef000006bc callf $4,_pipe2_8
78: 78 00026CC8 # subtest++; /* increment the subtest */
79: 79 00026CC8 6d efffffff6e incl _subtest
80: 80 00026CCE # pipe2_9(); /* data on STACK, no NOPs */
81: 81 00026CCE fe 04 ef000007a7 callf $4,_pipe2_9
82: 82 00026CD5 # subtest++; /* increment the subtest */
83: 83 00026CD5 6d efffffff61 incl _subtest
84: 84 00026CDB # pipe2_10(); /* data via FP no NOPs */
85: 85 00026CDB fe 04 ef00000928 callf $4,_pipe2_10
86: 86 00026CE2 # asm("jmp *return"); /* return to the test monitor */
87: 87 00026CE2 71 ffffffff54 jmp *return
88: 88 00026CE8 # }
89: 89 00026CE8 40 ret#2
90: 90 00026CE9 .set L215,0x0
91: 91 00026CE9 L217:
92: 92 00026CE9 13 ff55 jbr L218
93: 93 00026CEC .data
94: 94 00000d0c * .text
95: 95 00026CEC .align 1
96: 96 00026CEC .globl _pipe2_1
97: 97 00026CEC _pipe2_1:
98: 98 00026CEC 0000 .word L232
99: 99 00026CEE #
100: 100 00026CEE #
101: 101 00026CEE #
102: 102 00026CEE #
103: 103 00026CEE #
104: 104 00026CEE #
105: 105 00026CEE # /************************************************************************
106: 106 00026CEE # *
107: 107 00026CEE # * SUBTEST 1
108: 108 00026CEE # * data in registers, no NO-OPs
109: 109 00026CEE # *
110: 110 00026CEE # ************************************************************************/
111: 111 00026CEE # pipe2_1()
112: 112 00026CEE # {
113: 113 00026CEE 13 00e4 jbr L234
114: 114 00026CF1 L235:
115: 115 00026CF1 # force_loop = FALSE; /* clear force_loop flag */
116: 116 00026CF1 4d efffffff45 clrl _force_loop
117: 117 00026CF7 # index = 0;
118: 118 00026CF7 4d efffffff3f clrl _index
119: 119 00026CFD # do
120: 120 00026CFD L238:
121: 121 00026CFD # {
122: 122 00026CFD # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
123: 123 00026CFD 0d efffffff39 50 movl _index,r0
124: 124 00026D04 48 03 50 50 shll $3,r0,r0
125: 125 00026D08 0d e000000000 efffffff29 movl _lnf_1_data(r0),_sgl_value_1
126: 126 00026D13 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
127: 127 00026D13 0d efffffff23 50 movl _index,r0
128: 128 00026D1A 48 03 50 50 shll $3,r0,r0
129: 129 00026D1E 0d e000000004 efffffff13 movl _lnf_1_data+4(r0),_sgl_expected
130: 130 00026D29 # sgl_value_2 = 0x40800000; /* floating '1' */
131: 131 00026D29 0d 8f40800000 efffffff08 movl $1082130432,_sgl_value_2
132: 132 00026D34 # sgl_value_3 = 0; /* floating '0' */
133: 133 00026D34 4d efffffff02 clrl _sgl_value_3
134: 134 00026D3A # /*
135: 135 00026D3A # * If LOOP ON ERROR is set, this is the loop for this subtest.
136: 136 00026D3A # * The force loop flag is set after the first error.
137: 137 00026D3A # */
138: 138 00026D3A # asm("_pipe2_1_lp1:");
139: 139 00026D3A _pipe2_1_lp1:
140: 140 00026D3A # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
141: 141 00026D3A 0d effffffefc 54 movl _sgl_value_1,r4
142: 142 00026D41 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
143: 143 00026D41 0d effffffef5 55 movl _sgl_value_2,r5
144: 144 00026D48 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
145: 145 00026D48 0d effffffeee 56 movl _sgl_value_3,r6
146: 146 00026D4F # asm("lnf r4"); /* load (negate) the data */
147: 147 00026D4F 16 54 lnf r4
148: 148 00026D51 # asm("mulf r5"); /* multipy by '1' (twice) */
149: 149 00026D51 e6 55 mulf r5
150: 150 00026D53 # asm("mulf r5");
151: 151 00026D53 e6 55 mulf r5
152: 152 00026D55 # asm("addf r6"); /* add a '0' */
153: 153 00026D55 c6 56 addf r6
154: 154 00026D57 # asm("mulf r5"); /* multipy by '1' again */
155: 155 00026D57 e6 55 mulf r5
156: 156 00026D59 # asm("stf r7"); /* store the result */
157: 157 00026D59 26 57 stf r7
158: 158 00026D5B # if( force_loop );
159: 159 00026D5B 5d effffffedb tstl _force_loop
160: 160 00026D61 31 00 jeql L239
161: 161 00026D63 # asm("brb _pipe2_1_lp1");; /* loop on the error */
162: 162 00026D63 L239:
163: 163 00026D63 11 d5 brb _pipe2_1_lp1
164: 164 00026D65 # /*
165: 165 00026D65 # * verify the results
166: 166 00026D65 # */
167: 167 00026D65 # asm("movl r7,_sgl_st_acc"); /* get the result */
168: 168 00026D65 0d 57 effffffed0 movl r7,_sgl_st_acc
169: 169 00026D6C # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
170: 170 00026D6C 1d effffffeca effffffec5 cmpl _sgl_st_acc,_sgl_expected
171: 171 00026D77 31 42 jeql L240
172: 172 00026D79 # {
173: 173 00026D79 # errcnt++; /* bump the error count */
174: 174 00026D79 6d effffffebd incl _errcnt
175: 175 00026D7F # if ( prt_error )
176: 176 00026D7F 5d effffffeb7 tstl _prt_error
177: 177 00026D85 31 0d jeql L241
178: 178 00026D87 # print_pipe2_er("Reg. Data, no NO-OPS");
179: 179 00026D87 .data 1
180: 180 00000d15 * L243:
181: 181 00000d15 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPS\0"
182: F204E4F2D4F505300
183: 182 00000d2a * .text
184: 183 00026D87 dd 8f00000d15 pushl $L243
185: 184 00026D8D fe 08 ef00000a34 callf $8,_print_pipe2_er
186: 185 00026D94 # if ( halt_flg ) /* halt on error? */
187: 186 00026D94 L241:
188: 187 00026D94 5d effffffea2 tstl _halt_flg
189: 188 00026D9A 31 0d jeql L244
190: 189 00026D9C # pipe2_er_hlt( subtest );
191: 190 00026D9C dd effffffe9a pushl _subtest
192: 191 00026DA2 fe 08 ef00000b2b callf $8,_pipe2_er_hlt
193: 192 00026DA9 # if ( loop_on_err ) {
194: 193 00026DA9 L244:
195: 194 00026DA9 5d effffffe8d tstl _loop_on_err
196: 195 00026DAF 31 0a jeql L246
197: 196 00026DB1 # force_loop = TRUE; /* set the force loop flag */
198: 197 00026DB1 0d 01 effffffe84 movl $1,_force_loop
199: 198 00026DB8 # asm("brw _pipe2_1_lp1"); /* and loop */
200: 199 00026DB8 13 ff7f brw _pipe2_1_lp1
201: 200 00026DBB # }
202: 201 00026DBB # } /* end of compare error */
203: 202 00026DBB L246:
204: 203 00026DBB # } while( index++ < max_lnf_1_index );
205: 204 00026DBB L240:
206: 205 00026DBB L237:
207: 206 00026DBB 0d effffffe7b 50 movl _index,r0
208: 207 00026DC2 6d effffffe74 incl _index
209: 208 00026DC8 1d 50 effffffe6d cmpl r0,_max_lnf_1_index
210: 209 00026DCF 81 03 13 ff29 jlss L238
211: 210 00026DD4 L236:
212: 211 00026DD4 # } /* end of subtest 1 */
213: 212 00026DD4 40 ret#2
214: 213 00026DD5 .set L232,0x0
215: 214 00026DD5 L234:
216: 215 00026DD5 13 ff19 jbr L235
217: 216 00026DD8 .data
218: 217 00000d0c * .text
219: 218 00026DD8 .align 1
220: 219 00026DD8 .globl _pipe2_2
221: 220 00026DD8 _pipe2_2:
222: 221 00026DD8 0000 .word L247
223: 222 00026DDA #
224: 223 00026DDA #
225: 224 00026DDA #
226: 225 00026DDA #
227: 226 00026DDA #
228: 227 00026DDA #
229: 228 00026DDA # /************************************************************************
230: 229 00026DDA # *
231: 230 00026DDA # * SUBTEST 2
232: 231 00026DDA # * data in registers, 1 NO-OP
233: 232 00026DDA # *
234: 233 00026DDA # ************************************************************************/
235: 234 00026DDA # pipe2_2()
236: 235 00026DDA # {
237: 236 00026DDA 13 00e9 jbr L249
238: 237 00026DDD L250:
239: 238 00026DDD # force_loop = FALSE; /* clear force_loop flag */
240: 239 00026DDD 4d effffffe59 clrl _force_loop
241: 240 00026DE3 # index = 0;
242: 241 00026DE3 4d effffffe53 clrl _index
243: 242 00026DE9 # do
244: 243 00026DE9 L253:
245: 244 00026DE9 # {
246: 245 00026DE9 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
247: 246 00026DE9 0d effffffe4d 50 movl _index,r0
248: 247 00026DF0 48 03 50 50 shll $3,r0,r0
249: 248 00026DF4 0d e000000000 effffffe3d movl _lnf_1_data(r0),_sgl_value_1
250: 249 00026DFF # sgl_expected = lnf_1_data[index].exp; /* get expected results */
251: 250 00026DFF 0d effffffe37 50 movl _index,r0
252: 251 00026E06 48 03 50 50 shll $3,r0,r0
253: 252 00026E0A 0d e000000004 effffffe27 movl _lnf_1_data+4(r0),_sgl_expected
254: 253 00026E15 # sgl_value_2 = 0x40800000; /* floating '1' */
255: 254 00026E15 0d 8f40800000 effffffe1c movl $1082130432,_sgl_value_2
256: 255 00026E20 # sgl_value_3 = 0; /* floating '0' */
257: 256 00026E20 4d effffffe16 clrl _sgl_value_3
258: 257 00026E26 # /*
259: 258 00026E26 # * If LOOP ON ERROR is set, this is the loop for this subtest.
260: 259 00026E26 # * The force loop flag is set after the first error.
261: 260 00026E26 # */
262: 261 00026E26 # asm("_pipe2_2_lp1:");
263: 262 00026E26 _pipe2_2_lp1:
264: 263 00026E26 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
265: 264 00026E26 0d effffffe10 54 movl _sgl_value_1,r4
266: 265 00026E2D # asm("movl _sgl_value_2,r5"); /* move data to r5 */
267: 266 00026E2D 0d effffffe09 55 movl _sgl_value_2,r5
268: 267 00026E34 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
269: 268 00026E34 0d effffffe02 56 movl _sgl_value_3,r6
270: 269 00026E3B # asm("lnf r4"); /* load (negate) the data */
271: 270 00026E3B 16 54 lnf r4
272: 271 00026E3D # asm("nop");
273: 272 00026E3D 10 nop
274: 273 00026E3E # asm("mulf r5"); /* multipy by '1' (twice) */
275: 274 00026E3E e6 55 mulf r5
276: 275 00026E40 # asm("nop");
277: 276 00026E40 10 nop
278: 277 00026E41 # asm("mulf r5");
279: 278 00026E41 e6 55 mulf r5
280: 279 00026E43 # asm("nop");
281: 280 00026E43 10 nop
282: 281 00026E44 # asm("addf r6"); /* add a '0' */
283: 282 00026E44 c6 56 addf r6
284: 283 00026E46 # asm("nop");
285: 284 00026E46 10 nop
286: 285 00026E47 # asm("mulf r5"); /* multipy by '1' again */
287: 286 00026E47 e6 55 mulf r5
288: 287 00026E49 # asm("nop");
289: 288 00026E49 10 nop
290: 289 00026E4A # asm("stf r7"); /* store the result */
291: 290 00026E4A 26 57 stf r7
292: 291 00026E4C # if( force_loop );
293: 292 00026E4C 5d effffffdea tstl _force_loop
294: 293 00026E52 31 00 jeql L254
295: 294 00026E54 # asm("brb _pipe2_2_lp1");; /* loop on the error */
296: 295 00026E54 L254:
297: 296 00026E54 11 d0 brb _pipe2_2_lp1
298: 297 00026E56 # /*
299: 298 00026E56 # * verify the results
300: 299 00026E56 # */
301: 300 00026E56 # asm("movl r7,_sgl_st_acc"); /* get the result */
302: 301 00026E56 0d 57 effffffddf movl r7,_sgl_st_acc
303: 302 00026E5D # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
304: 303 00026E5D 1d effffffdd9 effffffdd4 cmpl _sgl_st_acc,_sgl_expected
305: 304 00026E68 31 42 jeql L255
306: 305 00026E6A # {
307: 306 00026E6A # errcnt++; /* bump the error count */
308: 307 00026E6A 6d effffffdcc incl _errcnt
309: 308 00026E70 # if ( prt_error )
310: 309 00026E70 5d effffffdc6 tstl _prt_error
311: 310 00026E76 31 0d jeql L256
312: 311 00026E78 # print_pipe2_er("Reg. Data, 1 NO-OP");
313: 312 00026E78 .data 1
314: 313 00000d2a * L257:
315: 314 00000d2a * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
316: 04E4F2D4F5000
317: 315 00000d3d * .text
318: 316 00026E78 dd 8f00000d2a pushl $L257
319: 317 00026E7E fe 08 ef00000943 callf $8,_print_pipe2_er
320: 318 00026E85 # if ( halt_flg ) /* halt on error? */
321: 319 00026E85 L256:
322: 320 00026E85 5d effffffdb1 tstl _halt_flg
323: 321 00026E8B 31 0d jeql L258
324: 322 00026E8D # pipe2_er_hlt( subtest );
325: 323 00026E8D dd effffffda9 pushl _subtest
326: 324 00026E93 fe 08 ef00000a3a callf $8,_pipe2_er_hlt
327: 325 00026E9A # if ( loop_on_err ) {
328: 326 00026E9A L258:
329: 327 00026E9A 5d effffffd9c tstl _loop_on_err
330: 328 00026EA0 31 0a jeql L259
331: 329 00026EA2 # force_loop = TRUE; /* set the force loop flag */
332: 330 00026EA2 0d 01 effffffd93 movl $1,_force_loop
333: 331 00026EA9 # asm("brw _pipe2_2_lp1"); /* and loop */
334: 332 00026EA9 13 ff7a brw _pipe2_2_lp1
335: 333 00026EAC # }
336: 334 00026EAC # } /* end of compare error */
337: 335 00026EAC L259:
338: 336 00026EAC # } while( index++ < max_lnf_1_index );
339: 337 00026EAC L255:
340: 338 00026EAC L252:
341: 339 00026EAC 0d effffffd8a 50 movl _index,r0
342: 340 00026EB3 6d effffffd83 incl _index
343: 341 00026EB9 1d 50 effffffd7c cmpl r0,_max_lnf_1_index
344: 342 00026EC0 81 03 13 ff24 jlss L253
345: 343 00026EC5 L251:
346: 344 00026EC5 # } /* end of subtest 2 */
347: 345 00026EC5 40 ret#2
348: 346 00026EC6 .set L247,0x0
349: 347 00026EC6 L249:
350: 348 00026EC6 13 ff14 jbr L250
351: 349 00026EC9 .data
352: 350 00000d0c * .text
353: 351 00026EC9 00 .align 1
354: 352 00026ECA .globl _pipe2_3
355: 353 00026ECA _pipe2_3:
356: 354 00026ECA 0000 .word L260
357: 355 00026ECC #
358: 356 00026ECC #
359: 357 00026ECC #
360: 358 00026ECC #
361: 359 00026ECC #
362: 360 00026ECC #
363: 361 00026ECC # /************************************************************************
364: 362 00026ECC # *
365: 363 00026ECC # * SUBTEST 3
366: 364 00026ECC # * data in registers, 2 NO-OPs
367: 365 00026ECC # *
368: 366 00026ECC # ************************************************************************/
369: 367 00026ECC # pipe2_3()
370: 368 00026ECC # {
371: 369 00026ECC 13 00ee jbr L262
372: 370 00026ECF L263:
373: 371 00026ECF # force_loop = FALSE; /* clear force_loop flag */
374: 372 00026ECF 4d effffffd67 clrl _force_loop
375: 373 00026ED5 # index = 0;
376: 374 00026ED5 4d effffffd61 clrl _index
377: 375 00026EDB # do
378: 376 00026EDB L266:
379: 377 00026EDB # {
380: 378 00026EDB # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
381: 379 00026EDB 0d effffffd5b 50 movl _index,r0
382: 380 00026EE2 48 03 50 50 shll $3,r0,r0
383: 381 00026EE6 0d e000000000 effffffd4b movl _lnf_1_data(r0),_sgl_value_1
384: 382 00026EF1 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
385: 383 00026EF1 0d effffffd45 50 movl _index,r0
386: 384 00026EF8 48 03 50 50 shll $3,r0,r0
387: 385 00026EFC 0d e000000004 effffffd35 movl _lnf_1_data+4(r0),_sgl_expected
388: 386 00026F07 # sgl_value_2 = 0x40800000; /* floating '1' */
389: 387 00026F07 0d 8f40800000 effffffd2a movl $1082130432,_sgl_value_2
390: 388 00026F12 # sgl_value_3 = 0; /* floating '0' */
391: 389 00026F12 4d effffffd24 clrl _sgl_value_3
392: 390 00026F18 # /*
393: 391 00026F18 # * If LOOP ON ERROR is set, this is the loop for this subtest.
394: 392 00026F18 # * The force loop flag is set after the first error.
395: 393 00026F18 # */
396: 394 00026F18 # asm("_pipe2_3_lp1:");
397: 395 00026F18 _pipe2_3_lp1:
398: 396 00026F18 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
399: 397 00026F18 0d effffffd1e 54 movl _sgl_value_1,r4
400: 398 00026F1F # asm("movl _sgl_value_2,r5"); /* move data to r5 */
401: 399 00026F1F 0d effffffd17 55 movl _sgl_value_2,r5
402: 400 00026F26 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
403: 401 00026F26 0d effffffd10 56 movl _sgl_value_3,r6
404: 402 00026F2D # asm("lnf r4"); /* load (negate) the data */
405: 403 00026F2D 16 54 lnf r4
406: 404 00026F2F # asm("nop");
407: 405 00026F2F 10 nop
408: 406 00026F30 # asm("nop");
409: 407 00026F30 10 nop
410: 408 00026F31 # asm("mulf r5"); /* multipy by '1' (twice) */
411: 409 00026F31 e6 55 mulf r5
412: 410 00026F33 # asm("nop");
413: 411 00026F33 10 nop
414: 412 00026F34 # asm("nop");
415: 413 00026F34 10 nop
416: 414 00026F35 # asm("mulf r5");
417: 415 00026F35 e6 55 mulf r5
418: 416 00026F37 # asm("nop");
419: 417 00026F37 10 nop
420: 418 00026F38 # asm("nop");
421: 419 00026F38 10 nop
422: 420 00026F39 # asm("addf r6"); /* add a '0' */
423: 421 00026F39 c6 56 addf r6
424: 422 00026F3B # asm("nop");
425: 423 00026F3B 10 nop
426: 424 00026F3C # asm("nop");
427: 425 00026F3C 10 nop
428: 426 00026F3D # asm("mulf r5"); /* multipy by '1' again */
429: 427 00026F3D e6 55 mulf r5
430: 428 00026F3F # asm("nop");
431: 429 00026F3F 10 nop
432: 430 00026F40 # asm("nop");
433: 431 00026F40 10 nop
434: 432 00026F41 # asm("stf r7"); /* store the result */
435: 433 00026F41 26 57 stf r7
436: 434 00026F43 # if( force_loop );
437: 435 00026F43 5d effffffcf3 tstl _force_loop
438: 436 00026F49 31 00 jeql L267
439: 437 00026F4B # asm("brb _pipe2_3_lp1");; /* loop on the error */
440: 438 00026F4B L267:
441: 439 00026F4B 11 cb brb _pipe2_3_lp1
442: 440 00026F4D # /*
443: 441 00026F4D # * verify the results
444: 442 00026F4D # */
445: 443 00026F4D # asm("movl r7,_sgl_st_acc"); /* get the result */
446: 444 00026F4D 0d 57 effffffce8 movl r7,_sgl_st_acc
447: 445 00026F54 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
448: 446 00026F54 1d effffffce2 effffffcdd cmpl _sgl_st_acc,_sgl_expected
449: 447 00026F5F 31 42 jeql L268
450: 448 00026F61 # {
451: 449 00026F61 # errcnt++; /* bump the error count */
452: 450 00026F61 6d effffffcd5 incl _errcnt
453: 451 00026F67 # if ( prt_error )
454: 452 00026F67 5d effffffccf tstl _prt_error
455: 453 00026F6D 31 0d jeql L269
456: 454 00026F6F # print_pipe2_er("Reg. Data, 2 NO-OPS");
457: 455 00026F6F .data 1
458: 456 00000d3d * L270:
459: 457 00000d3d * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPS\0"
460: 04E4F2D4F505300
461: 458 00000d51 * .text
462: 459 00026F6F dd 8f00000d3d pushl $L270
463: 460 00026F75 fe 08 ef0000084c callf $8,_print_pipe2_er
464: 461 00026F7C # if ( halt_flg ) /* halt on error? */
465: 462 00026F7C L269:
466: 463 00026F7C 5d effffffcba tstl _halt_flg
467: 464 00026F82 31 0d jeql L271
468: 465 00026F84 # pipe2_er_hlt( subtest );
469: 466 00026F84 dd effffffcb2 pushl _subtest
470: 467 00026F8A fe 08 ef00000943 callf $8,_pipe2_er_hlt
471: 468 00026F91 # if ( loop_on_err ) {
472: 469 00026F91 L271:
473: 470 00026F91 5d effffffca5 tstl _loop_on_err
474: 471 00026F97 31 0a jeql L272
475: 472 00026F99 # force_loop = TRUE; /* set the force loop flag */
476: 473 00026F99 0d 01 effffffc9c movl $1,_force_loop
477: 474 00026FA0 # asm("brw _pipe2_3_lp1"); /* and loop */
478: 475 00026FA0 13 ff75 brw _pipe2_3_lp1
479: 476 00026FA3 # }
480: 477 00026FA3 # } /* end of compare error */
481: 478 00026FA3 L272:
482: 479 00026FA3 # } while( index++ < max_lnf_1_index );
483: 480 00026FA3 L268:
484: 481 00026FA3 L265:
485: 482 00026FA3 0d effffffc93 50 movl _index,r0
486: 483 00026FAA 6d effffffc8c incl _index
487: 484 00026FB0 1d 50 effffffc85 cmpl r0,_max_lnf_1_index
488: 485 00026FB7 81 03 13 ff1f jlss L266
489: 486 00026FBC L264:
490: 487 00026FBC # } /* end of subtest 3 */
491: 488 00026FBC 40 ret#2
492: 489 00026FBD .set L260,0x0
493: 490 00026FBD L262:
494: 491 00026FBD 13 ff0f jbr L263
495: 492 00026FC0 .data
496: 493 00000d0c * .text
497: 494 00026FC0 .align 1
498: 495 00026FC0 .globl _pipe2_4
499: 496 00026FC0 _pipe2_4:
500: 497 00026FC0 0000 .word L273
501: 498 00026FC2 #
502: 499 00026FC2 #
503: 500 00026FC2 #
504: 501 00026FC2 #
505: 502 00026FC2 #
506: 503 00026FC2 #
507: 504 00026FC2 # /************************************************************************
508: 505 00026FC2 # *
509: 506 00026FC2 # * SUBTEST 4
510: 507 00026FC2 # * data in registers, 3 NO-OPs
511: 508 00026FC2 # *
512: 509 00026FC2 # ************************************************************************/
513: 510 00026FC2 # pipe2_4()
514: 511 00026FC2 # {
515: 512 00026FC2 13 00f3 jbr L275
516: 513 00026FC5 L276:
517: 514 00026FC5 # force_loop = FALSE; /* clear force_loop flag */
518: 515 00026FC5 4d effffffc71 clrl _force_loop
519: 516 00026FCB # index = 0;
520: 517 00026FCB 4d effffffc6b clrl _index
521: 518 00026FD1 # do
522: 519 00026FD1 L279:
523: 520 00026FD1 # {
524: 521 00026FD1 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
525: 522 00026FD1 0d effffffc65 50 movl _index,r0
526: 523 00026FD8 48 03 50 50 shll $3,r0,r0
527: 524 00026FDC 0d e000000000 effffffc55 movl _lnf_1_data(r0),_sgl_value_1
528: 525 00026FE7 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
529: 526 00026FE7 0d effffffc4f 50 movl _index,r0
530: 527 00026FEE 48 03 50 50 shll $3,r0,r0
531: 528 00026FF2 0d e000000004 effffffc3f movl _lnf_1_data+4(r0),_sgl_expected
532: 529 00026FFD # sgl_value_2 = 0x40800000; /* floating '1' */
533: 530 00026FFD 0d 8f40800000 effffffc34 movl $1082130432,_sgl_value_2
534: 531 00027008 # sgl_value_3 = 0; /* floating '0' */
535: 532 00027008 4d effffffc2e clrl _sgl_value_3
536: 533 0002700E # /*
537: 534 0002700E # * If LOOP ON ERROR is set, this is the loop for this subtest.
538: 535 0002700E # * The force loop flag is set after the first error.
539: 536 0002700E # */
540: 537 0002700E # asm("_pipe2_4_lp1:");
541: 538 0002700E _pipe2_4_lp1:
542: 539 0002700E # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
543: 540 0002700E 0d effffffc28 54 movl _sgl_value_1,r4
544: 541 00027015 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
545: 542 00027015 0d effffffc21 55 movl _sgl_value_2,r5
546: 543 0002701C # asm("movl _sgl_value_3,r6"); /* move data to r6 */
547: 544 0002701C 0d effffffc1a 56 movl _sgl_value_3,r6
548: 545 00027023 # asm("lnf r4"); /* load (negate) the data */
549: 546 00027023 16 54 lnf r4
550: 547 00027025 # asm("nop");
551: 548 00027025 10 nop
552: 549 00027026 # asm("nop");
553: 550 00027026 10 nop
554: 551 00027027 # asm("nop");
555: 552 00027027 10 nop
556: 553 00027028 # asm("mulf r5"); /* multipy by '1' (twice) */
557: 554 00027028 e6 55 mulf r5
558: 555 0002702A # asm("nop");
559: 556 0002702A 10 nop
560: 557 0002702B # asm("nop");
561: 558 0002702B 10 nop
562: 559 0002702C # asm("nop");
563: 560 0002702C 10 nop
564: 561 0002702D # asm("mulf r5");
565: 562 0002702D e6 55 mulf r5
566: 563 0002702F # asm("nop");
567: 564 0002702F 10 nop
568: 565 00027030 # asm("nop");
569: 566 00027030 10 nop
570: 567 00027031 # asm("nop");
571: 568 00027031 10 nop
572: 569 00027032 # asm("addf r6"); /* add a '0' */
573: 570 00027032 c6 56 addf r6
574: 571 00027034 # asm("nop");
575: 572 00027034 10 nop
576: 573 00027035 # asm("nop");
577: 574 00027035 10 nop
578: 575 00027036 # asm("nop");
579: 576 00027036 10 nop
580: 577 00027037 # asm("mulf r5"); /* multipy by '1' again */
581: 578 00027037 e6 55 mulf r5
582: 579 00027039 # asm("nop");
583: 580 00027039 10 nop
584: 581 0002703A # asm("nop");
585: 582 0002703A 10 nop
586: 583 0002703B # asm("nop");
587: 584 0002703B 10 nop
588: 585 0002703C # asm("stf r7"); /* store the result */
589: 586 0002703C 26 57 stf r7
590: 587 0002703E # if( force_loop );
591: 588 0002703E 5d effffffbf8 tstl _force_loop
592: 589 00027044 31 00 jeql L280
593: 590 00027046 # asm("brb _pipe2_4_lp1");; /* loop on the error */
594: 591 00027046 L280:
595: 592 00027046 11 c6 brb _pipe2_4_lp1
596: 593 00027048 # /*
597: 594 00027048 # * verify the results
598: 595 00027048 # */
599: 596 00027048 # asm("movl r7,_sgl_st_acc"); /* get the result */
600: 597 00027048 0d 57 effffffbed movl r7,_sgl_st_acc
601: 598 0002704F # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
602: 599 0002704F 1d effffffbe7 effffffbe2 cmpl _sgl_st_acc,_sgl_expected
603: 600 0002705A 31 42 jeql L281
604: 601 0002705C # {
605: 602 0002705C # errcnt++; /* bump the error count */
606: 603 0002705C 6d effffffbda incl _errcnt
607: 604 00027062 # if ( prt_error )
608: 605 00027062 5d effffffbd4 tstl _prt_error
609: 606 00027068 31 0d jeql L282
610: 607 0002706A # print_pipe2_er("Reg. Data, 3 NO-OPS");
611: 608 0002706A .data 1
612: 609 00000d51 * L283:
613: 610 00000d51 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPS\0"
614: 04E4F2D4F505300
615: 611 00000d65 * .text
616: 612 0002706A dd 8f00000d51 pushl $L283
617: 613 00027070 fe 08 ef00000751 callf $8,_print_pipe2_er
618: 614 00027077 # if ( halt_flg ) /* halt on error? */
619: 615 00027077 L282:
620: 616 00027077 5d effffffbbf tstl _halt_flg
621: 617 0002707D 31 0d jeql L284
622: 618 0002707F # pipe2_er_hlt( subtest );
623: 619 0002707F dd effffffbb7 pushl _subtest
624: 620 00027085 fe 08 ef00000848 callf $8,_pipe2_er_hlt
625: 621 0002708C # if ( loop_on_err ) {
626: 622 0002708C L284:
627: 623 0002708C 5d effffffbaa tstl _loop_on_err
628: 624 00027092 31 0a jeql L285
629: 625 00027094 # force_loop = TRUE; /* set the force loop flag */
630: 626 00027094 0d 01 effffffba1 movl $1,_force_loop
631: 627 0002709B # asm("brw _pipe2_4_lp1"); /* and loop */
632: 628 0002709B 13 ff70 brw _pipe2_4_lp1
633: 629 0002709E # }
634: 630 0002709E # } /* end of compare error */
635: 631 0002709E L285:
636: 632 0002709E # } while( index++ < max_lnf_1_index );
637: 633 0002709E L281:
638: 634 0002709E L278:
639: 635 0002709E 0d effffffb98 50 movl _index,r0
640: 636 000270A5 6d effffffb91 incl _index
641: 637 000270AB 1d 50 effffffb8a cmpl r0,_max_lnf_1_index
642: 638 000270B2 81 03 13 ff1a jlss L279
643: 639 000270B7 L277:
644: 640 000270B7 # } /* end of subtest 4 */
645: 641 000270B7 40 ret#2
646: 642 000270B8 .set L273,0x0
647: 643 000270B8 L275:
648: 644 000270B8 13 ff0a jbr L276
649: 645 000270BB .data
650: 646 00000d0c * .text
651: 647 000270BB 00 .align 1
652: 648 000270BC .globl _pipe2_5
653: 649 000270BC _pipe2_5:
654: 650 000270BC 0000 .word L286
655: 651 000270BE #
656: 652 000270BE #
657: 653 000270BE #
658: 654 000270BE #
659: 655 000270BE #
660: 656 000270BE #
661: 657 000270BE #
662: 658 000270BE # /************************************************************************
663: 659 000270BE # *
664: 660 000270BE # * SUBTEST 5
665: 661 000270BE # * data in Cache, no NO-OPs
666: 662 000270BE # *
667: 663 000270BE # ************************************************************************/
668: 664 000270BE # pipe2_5()
669: 665 000270BE # {
670: 666 000270BE 13 00e0 jbr L288
671: 667 000270C1 L289:
672: 668 000270C1 # force_loop = FALSE; /* clear force_loop flag */
673: 669 000270C1 4d effffffb75 clrl _force_loop
674: 670 000270C7 # index = 0;
675: 671 000270C7 4d effffffb6f clrl _index
676: 672 000270CD # do
677: 673 000270CD L292:
678: 674 000270CD # {
679: 675 000270CD # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
680: 676 000270CD 0d effffffb69 50 movl _index,r0
681: 677 000270D4 48 03 50 50 shll $3,r0,r0
682: 678 000270D8 0d e000000000 effffffb59 movl _lnf_1_data(r0),_sgl_value_1
683: 679 000270E3 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
684: 680 000270E3 0d effffffb53 50 movl _index,r0
685: 681 000270EA 48 03 50 50 shll $3,r0,r0
686: 682 000270EE 0d e000000004 effffffb43 movl _lnf_1_data+4(r0),_sgl_expected
687: 683 000270F9 # sgl_value_2 = 0x40800000; /* floating '1' */
688: 684 000270F9 0d 8f40800000 effffffb38 movl $1082130432,_sgl_value_2
689: 685 00027104 # sgl_value_3 = 0; /* floating '0' */
690: 686 00027104 4d effffffb32 clrl _sgl_value_3
691: 687 0002710A # /*
692: 688 0002710A # * If LOOP ON ERROR is set, this is the loop for this subtest.
693: 689 0002710A # * The force loop flag is set after the first error.
694: 690 0002710A # */
695: 691 0002710A # asm("_pipe2_5_lp1:");
696: 692 0002710A _pipe2_5_lp1:
697: 693 0002710A # asm("lnf _sgl_value_1"); /* load (negate) the data */
698: 694 0002710A 16 effffffb2c lnf _sgl_value_1
699: 695 00027110 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
700: 696 00027110 e6 effffffb26 mulf _sgl_value_2
701: 697 00027116 # asm("mulf _sgl_value_2");
702: 698 00027116 e6 effffffb20 mulf _sgl_value_2
703: 699 0002711C # asm("addf _sgl_value_3"); /* add a '0' */
704: 700 0002711C c6 effffffb1a addf _sgl_value_3
705: 701 00027122 # asm("mulf _sgl_value_2"); /* multipy by '1' again */
706: 702 00027122 e6 effffffb14 mulf _sgl_value_2
707: 703 00027128 # asm("stf _sgl_st_acc"); /* store the result */
708: 704 00027128 26 effffffb0e stf _sgl_st_acc
709: 705 0002712E # if( force_loop );
710: 706 0002712E 5d effffffb08 tstl _force_loop
711: 707 00027134 31 00 jeql L293
712: 708 00027136 # asm("brb _pipe2_5_lp1");; /* loop on the error */
713: 709 00027136 L293:
714: 710 00027136 11 d2 brb _pipe2_5_lp1
715: 711 00027138 # /*
716: 712 00027138 # * verify the results
717: 713 00027138 # */
718: 714 00027138 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
719: 715 00027138 1d effffffafe effffffaf9 cmpl _sgl_st_acc,_sgl_expected
720: 716 00027143 31 42 jeql L294
721: 717 00027145 # {
722: 718 00027145 # errcnt++; /* bump the error count */
723: 719 00027145 6d effffffaf1 incl _errcnt
724: 720 0002714B # if ( prt_error )
725: 721 0002714B 5d effffffaeb tstl _prt_error
726: 722 00027151 31 0d jeql L295
727: 723 00027153 # print_pipe2_er("Cache Data, no NO-OPS");
728: 724 00027153 .data 1
729: 725 00000d65 * L296:
730: 726 00000d65 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPS\0"
731: E6F204E4F2D4F505300
732: 727 00000d7b * .text
733: 728 00027153 dd 8f00000d65 pushl $L296
734: 729 00027159 fe 08 ef00000668 callf $8,_print_pipe2_er
735: 730 00027160 # if ( halt_flg ) /* halt on error? */
736: 731 00027160 L295:
737: 732 00027160 5d effffffad6 tstl _halt_flg
738: 733 00027166 31 0d jeql L297
739: 734 00027168 # pipe2_er_hlt( subtest );
740: 735 00027168 dd efffffface pushl _subtest
741: 736 0002716E fe 08 ef0000075f callf $8,_pipe2_er_hlt
742: 737 00027175 # if ( loop_on_err ) {
743: 738 00027175 L297:
744: 739 00027175 5d effffffac1 tstl _loop_on_err
745: 740 0002717B 31 0a jeql L298
746: 741 0002717D # force_loop = TRUE; /* set the force loop flag */
747: 742 0002717D 0d 01 effffffab8 movl $1,_force_loop
748: 743 00027184 # asm("brw _pipe2_5_lp1"); /* and loop */
749: 744 00027184 13 ff83 brw _pipe2_5_lp1
750: 745 00027187 # }
751: 746 00027187 # } /* end of compare error */
752: 747 00027187 L298:
753: 748 00027187 # } while( index++ < max_lnf_1_index );
754: 749 00027187 L294:
755: 750 00027187 L291:
756: 751 00027187 0d effffffaaf 50 movl _index,r0
757: 752 0002718E 6d effffffaa8 incl _index
758: 753 00027194 1d 50 effffffaa1 cmpl r0,_max_lnf_1_index
759: 754 0002719B 81 03 13 ff2d jlss L292
760: 755 000271A0 L290:
761: 756 000271A0 # } /* end of subtest 5 */
762: 757 000271A0 40 ret#2
763: 758 000271A1 .set L286,0x0
764: 759 000271A1 L288:
765: 760 000271A1 13 ff1d jbr L289
766: 761 000271A4 .data
767: 762 00000d0c * .text
768: 763 000271A4 .align 1
769: 764 000271A4 .globl _pipe2_6
770: 765 000271A4 _pipe2_6:
771: 766 000271A4 0000 .word L299
772: 767 000271A6 #
773: 768 000271A6 #
774: 769 000271A6 #
775: 770 000271A6 #
776: 771 000271A6 #
777: 772 000271A6 #
778: 773 000271A6 # /************************************************************************
779: 774 000271A6 # *
780: 775 000271A6 # * SUBTEST 6
781: 776 000271A6 # * data in Cache, 1 NO-OP
782: 777 000271A6 # *
783: 778 000271A6 # ************************************************************************/
784: 779 000271A6 # pipe2_6()
785: 780 000271A6 # {
786: 781 000271A6 13 00e5 jbr L301
787: 782 000271A9 L302:
788: 783 000271A9 # force_loop = FALSE; /* clear force_loop flag */
789: 784 000271A9 4d effffffa8d clrl _force_loop
790: 785 000271AF # index = 0;
791: 786 000271AF 4d effffffa87 clrl _index
792: 787 000271B5 # do
793: 788 000271B5 L305:
794: 789 000271B5 # {
795: 790 000271B5 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
796: 791 000271B5 0d effffffa81 50 movl _index,r0
797: 792 000271BC 48 03 50 50 shll $3,r0,r0
798: 793 000271C0 0d e000000000 effffffa71 movl _lnf_1_data(r0),_sgl_value_1
799: 794 000271CB # sgl_expected = lnf_1_data[index].exp; /* get expected results */
800: 795 000271CB 0d effffffa6b 50 movl _index,r0
801: 796 000271D2 48 03 50 50 shll $3,r0,r0
802: 797 000271D6 0d e000000004 effffffa5b movl _lnf_1_data+4(r0),_sgl_expected
803: 798 000271E1 # sgl_value_2 = 0x40800000; /* floating '1' */
804: 799 000271E1 0d 8f40800000 effffffa50 movl $1082130432,_sgl_value_2
805: 800 000271EC # sgl_value_3 = 0; /* floating '0' */
806: 801 000271EC 4d effffffa4a clrl _sgl_value_3
807: 802 000271F2 # /*
808: 803 000271F2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
809: 804 000271F2 # * The force loop flag is set after the first error.
810: 805 000271F2 # */
811: 806 000271F2 # asm("_pipe2_6_lp1:");
812: 807 000271F2 _pipe2_6_lp1:
813: 808 000271F2 # asm("lnf _sgl_value_1"); /* load (negate) the data */
814: 809 000271F2 16 effffffa44 lnf _sgl_value_1
815: 810 000271F8 # asm("nop");
816: 811 000271F8 10 nop
817: 812 000271F9 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
818: 813 000271F9 e6 effffffa3d mulf _sgl_value_2
819: 814 000271FF # asm("nop");
820: 815 000271FF 10 nop
821: 816 00027200 # asm("mulf _sgl_value_2");
822: 817 00027200 e6 effffffa36 mulf _sgl_value_2
823: 818 00027206 # asm("nop");
824: 819 00027206 10 nop
825: 820 00027207 # asm("addf _sgl_value_3"); /* add a '0' */
826: 821 00027207 c6 effffffa2f addf _sgl_value_3
827: 822 0002720D # asm("nop");
828: 823 0002720D 10 nop
829: 824 0002720E # asm("mulf _sgl_value_2"); /* multipy by '1' again */
830: 825 0002720E e6 effffffa28 mulf _sgl_value_2
831: 826 00027214 # asm("nop");
832: 827 00027214 10 nop
833: 828 00027215 # asm("stf _sgl_st_acc"); /* store the result */
834: 829 00027215 26 effffffa21 stf _sgl_st_acc
835: 830 0002721B # if( force_loop );
836: 831 0002721B 5d effffffa1b tstl _force_loop
837: 832 00027221 31 00 jeql L306
838: 833 00027223 # asm("brb _pipe2_6_lp1");; /* loop on the error */
839: 834 00027223 L306:
840: 835 00027223 11 cd brb _pipe2_6_lp1
841: 836 00027225 # /*
842: 837 00027225 # * verify the results
843: 838 00027225 # */
844: 839 00027225 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
845: 840 00027225 1d effffffa11 effffffa0c cmpl _sgl_st_acc,_sgl_expected
846: 841 00027230 31 42 jeql L307
847: 842 00027232 # {
848: 843 00027232 # errcnt++; /* bump the error count */
849: 844 00027232 6d effffffa04 incl _errcnt
850: 845 00027238 # if ( prt_error )
851: 846 00027238 5d effffff9fe tstl _prt_error
852: 847 0002723E 31 0d jeql L308
853: 848 00027240 # print_pipe2_er("Cache Data, 1 NO-OP");
854: 849 00027240 .data 1
855: 850 00000d7b * L309:
856: 851 00000d7b * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
857: 1204E4F2D4F5000
858: 852 00000d8f * .text
859: 853 00027240 dd 8f00000d7b pushl $L309
860: 854 00027246 fe 08 ef0000057b callf $8,_print_pipe2_er
861: 855 0002724D # if ( halt_flg ) /* halt on error? */
862: 856 0002724D L308:
863: 857 0002724D 5d effffff9e9 tstl _halt_flg
864: 858 00027253 31 0d jeql L310
865: 859 00027255 # pipe2_er_hlt( subtest );
866: 860 00027255 dd effffff9e1 pushl _subtest
867: 861 0002725B fe 08 ef00000672 callf $8,_pipe2_er_hlt
868: 862 00027262 # if ( loop_on_err ) {
869: 863 00027262 L310:
870: 864 00027262 5d effffff9d4 tstl _loop_on_err
871: 865 00027268 31 0a jeql L311
872: 866 0002726A # force_loop = TRUE; /* set the force loop flag */
873: 867 0002726A 0d 01 effffff9cb movl $1,_force_loop
874: 868 00027271 # asm("brw _pipe2_6_lp1"); /* and loop */
875: 869 00027271 13 ff7e brw _pipe2_6_lp1
876: 870 00027274 # }
877: 871 00027274 # } /* end of compare error */
878: 872 00027274 L311:
879: 873 00027274 # } while( index++ < max_lnf_1_index );
880: 874 00027274 L307:
881: 875 00027274 L304:
882: 876 00027274 0d effffff9c2 50 movl _index,r0
883: 877 0002727B 6d effffff9bb incl _index
884: 878 00027281 1d 50 effffff9b4 cmpl r0,_max_lnf_1_index
885: 879 00027288 81 03 13 ff28 jlss L305
886: 880 0002728D L303:
887: 881 0002728D # } /* end of subtest 6 */
888: 882 0002728D 40 ret#2
889: 883 0002728E .set L299,0x0
890: 884 0002728E L301:
891: 885 0002728E 13 ff18 jbr L302
892: 886 00027291 .data
893: 887 00000d0c * .text
894: 888 00027291 00 .align 1
895: 889 00027292 .globl _pipe2_7
896: 890 00027292 _pipe2_7:
897: 891 00027292 0000 .word L312
898: 892 00027294 #
899: 893 00027294 #
900: 894 00027294 #
901: 895 00027294 #
902: 896 00027294 #
903: 897 00027294 #
904: 898 00027294 # /************************************************************************
905: 899 00027294 # *
906: 900 00027294 # * SUBTEST 7
907: 901 00027294 # * data in Cache, 2 NO-OPs
908: 902 00027294 # *
909: 903 00027294 # ************************************************************************/
910: 904 00027294 # pipe2_7()
911: 905 00027294 # {
912: 906 00027294 13 00ea jbr L314
913: 907 00027297 L315:
914: 908 00027297 # force_loop = FALSE; /* clear force_loop flag */
915: 909 00027297 4d effffff99f clrl _force_loop
916: 910 0002729D # index = 0;
917: 911 0002729D 4d effffff999 clrl _index
918: 912 000272A3 # do
919: 913 000272A3 L318:
920: 914 000272A3 # {
921: 915 000272A3 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
922: 916 000272A3 0d effffff993 50 movl _index,r0
923: 917 000272AA 48 03 50 50 shll $3,r0,r0
924: 918 000272AE 0d e000000000 effffff983 movl _lnf_1_data(r0),_sgl_value_1
925: 919 000272B9 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
926: 920 000272B9 0d effffff97d 50 movl _index,r0
927: 921 000272C0 48 03 50 50 shll $3,r0,r0
928: 922 000272C4 0d e000000004 effffff96d movl _lnf_1_data+4(r0),_sgl_expected
929: 923 000272CF # sgl_value_2 = 0x40800000; /* floating '1' */
930: 924 000272CF 0d 8f40800000 effffff962 movl $1082130432,_sgl_value_2
931: 925 000272DA # sgl_value_3 = 0; /* floating '0' */
932: 926 000272DA 4d effffff95c clrl _sgl_value_3
933: 927 000272E0 # /*
934: 928 000272E0 # * If LOOP ON ERROR is set, this is the loop for this subtest.
935: 929 000272E0 # * The force loop flag is set after the first error.
936: 930 000272E0 # */
937: 931 000272E0 # asm("_pipe2_7_lp1:");
938: 932 000272E0 _pipe2_7_lp1:
939: 933 000272E0 # asm("lnf _sgl_value_1"); /* load (negate) the data */
940: 934 000272E0 16 effffff956 lnf _sgl_value_1
941: 935 000272E6 # asm("nop");
942: 936 000272E6 10 nop
943: 937 000272E7 # asm("nop");
944: 938 000272E7 10 nop
945: 939 000272E8 # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
946: 940 000272E8 e6 effffff94e mulf _sgl_value_2
947: 941 000272EE # asm("nop");
948: 942 000272EE 10 nop
949: 943 000272EF # asm("nop");
950: 944 000272EF 10 nop
951: 945 000272F0 # asm("mulf _sgl_value_2");
952: 946 000272F0 e6 effffff946 mulf _sgl_value_2
953: 947 000272F6 # asm("nop");
954: 948 000272F6 10 nop
955: 949 000272F7 # asm("nop");
956: 950 000272F7 10 nop
957: 951 000272F8 # asm("addf _sgl_value_3"); /* add a '0' */
958: 952 000272F8 c6 effffff93e addf _sgl_value_3
959: 953 000272FE # asm("nop");
960: 954 000272FE 10 nop
961: 955 000272FF # asm("nop");
962: 956 000272FF 10 nop
963: 957 00027300 # asm("mulf _sgl_value_2"); /* multipy by '1' again */
964: 958 00027300 e6 effffff936 mulf _sgl_value_2
965: 959 00027306 # asm("nop");
966: 960 00027306 10 nop
967: 961 00027307 # asm("nop");
968: 962 00027307 10 nop
969: 963 00027308 # asm("stf _sgl_st_acc"); /* store the result */
970: 964 00027308 26 effffff92e stf _sgl_st_acc
971: 965 0002730E # if( force_loop );
972: 966 0002730E 5d effffff928 tstl _force_loop
973: 967 00027314 31 00 jeql L319
974: 968 00027316 # asm("brb _pipe2_7_lp1");; /* loop on the error */
975: 969 00027316 L319:
976: 970 00027316 11 c8 brb _pipe2_7_lp1
977: 971 00027318 # /*
978: 972 00027318 # * verify the results
979: 973 00027318 # */
980: 974 00027318 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
981: 975 00027318 1d effffff91e effffff919 cmpl _sgl_st_acc,_sgl_expected
982: 976 00027323 31 42 jeql L320
983: 977 00027325 # {
984: 978 00027325 # errcnt++; /* bump the error count */
985: 979 00027325 6d effffff911 incl _errcnt
986: 980 0002732B # if ( prt_error )
987: 981 0002732B 5d effffff90b tstl _prt_error
988: 982 00027331 31 0d jeql L321
989: 983 00027333 # print_pipe2_er("Cache Data, 2 NO-OPS");
990: 984 00027333 .data 1
991: 985 00000d8f * L322:
992: 986 00000d8f * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPS\0"
993: 2204E4F2D4F505300
994: 987 00000da4 * .text
995: 988 00027333 dd 8f00000d8f pushl $L322
996: 989 00027339 fe 08 ef00000488 callf $8,_print_pipe2_er
997: 990 00027340 # if ( halt_flg ) /* halt on error? */
998: 991 00027340 L321:
999: 992 00027340 5d effffff8f6 tstl _halt_flg
1000: 993 00027346 31 0d jeql L323
1001: 994 00027348 # pipe2_er_hlt( subtest );
1002: 995 00027348 dd effffff8ee pushl _subtest
1003: 996 0002734E fe 08 ef0000057f callf $8,_pipe2_er_hlt
1004: 997 00027355 # if ( loop_on_err ) {
1005: 998 00027355 L323:
1006: 999 00027355 5d effffff8e1 tstl _loop_on_err
1007: 1000 0002735B 31 0a jeql L324
1008: 1001 0002735D # force_loop = TRUE; /* set the force loop flag */
1009: 1002 0002735D 0d 01 effffff8d8 movl $1,_force_loop
1010: 1003 00027364 # asm("brw _pipe2_7_lp1"); /* and loop */
1011: 1004 00027364 13 ff79 brw _pipe2_7_lp1
1012: 1005 00027367 # }
1013: 1006 00027367 # } /* end of compare error */
1014: 1007 00027367 L324:
1015: 1008 00027367 # } while( index++ < max_lnf_1_index );
1016: 1009 00027367 L320:
1017: 1010 00027367 L317:
1018: 1011 00027367 0d effffff8cf 50 movl _index,r0
1019: 1012 0002736E 6d effffff8c8 incl _index
1020: 1013 00027374 1d 50 effffff8c1 cmpl r0,_max_lnf_1_index
1021: 1014 0002737B 81 03 13 ff23 jlss L318
1022: 1015 00027380 L316:
1023: 1016 00027380 # } /* end of subtest 7 */
1024: 1017 00027380 40 ret#2
1025: 1018 00027381 .set L312,0x0
1026: 1019 00027381 L314:
1027: 1020 00027381 13 ff13 jbr L315
1028: 1021 00027384 .data
1029: 1022 00000d0c * .text
1030: 1023 00027384 .align 1
1031: 1024 00027384 .globl _pipe2_8
1032: 1025 00027384 _pipe2_8:
1033: 1026 00027384 0000 .word L325
1034: 1027 00027386 #
1035: 1028 00027386 #
1036: 1029 00027386 #
1037: 1030 00027386 #
1038: 1031 00027386 #
1039: 1032 00027386 #
1040: 1033 00027386 # /************************************************************************
1041: 1034 00027386 # *
1042: 1035 00027386 # * SUBTEST 8
1043: 1036 00027386 # * data in Cache, 3 NO-OPs
1044: 1037 00027386 # *
1045: 1038 00027386 # ************************************************************************/
1046: 1039 00027386 # pipe2_8()
1047: 1040 00027386 # {
1048: 1041 00027386 13 00ef jbr L327
1049: 1042 00027389 L328:
1050: 1043 00027389 # force_loop = FALSE; /* clear force_loop flag */
1051: 1044 00027389 4d effffff8ad clrl _force_loop
1052: 1045 0002738F # index = 0;
1053: 1046 0002738F 4d effffff8a7 clrl _index
1054: 1047 00027395 # do
1055: 1048 00027395 L331:
1056: 1049 00027395 # {
1057: 1050 00027395 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1058: 1051 00027395 0d effffff8a1 50 movl _index,r0
1059: 1052 0002739C 48 03 50 50 shll $3,r0,r0
1060: 1053 000273A0 0d e000000000 effffff891 movl _lnf_1_data(r0),_sgl_value_1
1061: 1054 000273AB # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1062: 1055 000273AB 0d effffff88b 50 movl _index,r0
1063: 1056 000273B2 48 03 50 50 shll $3,r0,r0
1064: 1057 000273B6 0d e000000004 effffff87b movl _lnf_1_data+4(r0),_sgl_expected
1065: 1058 000273C1 # sgl_value_2 = 0x40800000; /* floating '1' */
1066: 1059 000273C1 0d 8f40800000 effffff870 movl $1082130432,_sgl_value_2
1067: 1060 000273CC # sgl_value_3 = 0; /* floating '0' */
1068: 1061 000273CC 4d effffff86a clrl _sgl_value_3
1069: 1062 000273D2 # /*
1070: 1063 000273D2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1071: 1064 000273D2 # * The force loop flag is set after the first error.
1072: 1065 000273D2 # */
1073: 1066 000273D2 # asm("_pipe2_8_lp1:");
1074: 1067 000273D2 _pipe2_8_lp1:
1075: 1068 000273D2 # asm("lnf _sgl_value_1"); /* load (negate) the data */
1076: 1069 000273D2 16 effffff864 lnf _sgl_value_1
1077: 1070 000273D8 # asm("nop");
1078: 1071 000273D8 10 nop
1079: 1072 000273D9 # asm("nop");
1080: 1073 000273D9 10 nop
1081: 1074 000273DA # asm("nop");
1082: 1075 000273DA 10 nop
1083: 1076 000273DB # asm("mulf _sgl_value_2"); /* multipy by '1' (twice) */
1084: 1077 000273DB e6 effffff85b mulf _sgl_value_2
1085: 1078 000273E1 # asm("nop");
1086: 1079 000273E1 10 nop
1087: 1080 000273E2 # asm("nop");
1088: 1081 000273E2 10 nop
1089: 1082 000273E3 # asm("nop");
1090: 1083 000273E3 10 nop
1091: 1084 000273E4 # asm("mulf _sgl_value_2");
1092: 1085 000273E4 e6 effffff852 mulf _sgl_value_2
1093: 1086 000273EA # asm("nop");
1094: 1087 000273EA 10 nop
1095: 1088 000273EB # asm("nop");
1096: 1089 000273EB 10 nop
1097: 1090 000273EC # asm("nop");
1098: 1091 000273EC 10 nop
1099: 1092 000273ED # asm("addf _sgl_value_3"); /* add a '0' */
1100: 1093 000273ED c6 effffff849 addf _sgl_value_3
1101: 1094 000273F3 # asm("nop");
1102: 1095 000273F3 10 nop
1103: 1096 000273F4 # asm("nop");
1104: 1097 000273F4 10 nop
1105: 1098 000273F5 # asm("nop");
1106: 1099 000273F5 10 nop
1107: 1100 000273F6 # asm("mulf _sgl_value_2"); /* multipy by '1' again */
1108: 1101 000273F6 e6 effffff840 mulf _sgl_value_2
1109: 1102 000273FC # asm("nop");
1110: 1103 000273FC 10 nop
1111: 1104 000273FD # asm("nop");
1112: 1105 000273FD 10 nop
1113: 1106 000273FE # asm("nop");
1114: 1107 000273FE 10 nop
1115: 1108 000273FF # asm("stf _sgl_st_acc"); /* store the result */
1116: 1109 000273FF 26 effffff837 stf _sgl_st_acc
1117: 1110 00027405 # if( force_loop );
1118: 1111 00027405 5d effffff831 tstl _force_loop
1119: 1112 0002740B 31 00 jeql L332
1120: 1113 0002740D # asm("brb _pipe2_8_lp1");; /* loop on the error */
1121: 1114 0002740D L332:
1122: 1115 0002740D 11 c3 brb _pipe2_8_lp1
1123: 1116 0002740F # /*
1124: 1117 0002740F # * verify the results
1125: 1118 0002740F # */
1126: 1119 0002740F # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
1127: 1120 0002740F 1d effffff827 effffff822 cmpl _sgl_st_acc,_sgl_expected
1128: 1121 0002741A 31 42 jeql L333
1129: 1122 0002741C # {
1130: 1123 0002741C # errcnt++; /* bump the error count */
1131: 1124 0002741C 6d effffff81a incl _errcnt
1132: 1125 00027422 # if ( prt_error )
1133: 1126 00027422 5d effffff814 tstl _prt_error
1134: 1127 00027428 31 0d jeql L334
1135: 1128 0002742A # print_pipe2_er("Cache Data, 3 NO-OPS");
1136: 1129 0002742A .data 1
1137: 1130 00000da4 * L335:
1138: 1131 00000da4 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPS\0"
1139: 3204E4F2D4F505300
1140: 1132 00000db9 * .text
1141: 1133 0002742A dd 8f00000da4 pushl $L335
1142: 1134 00027430 fe 08 ef00000391 callf $8,_print_pipe2_er
1143: 1135 00027437 # if ( halt_flg ) /* halt on error? */
1144: 1136 00027437 L334:
1145: 1137 00027437 5d effffff7ff tstl _halt_flg
1146: 1138 0002743D 31 0d jeql L336
1147: 1139 0002743F # pipe2_er_hlt( subtest );
1148: 1140 0002743F dd effffff7f7 pushl _subtest
1149: 1141 00027445 fe 08 ef00000488 callf $8,_pipe2_er_hlt
1150: 1142 0002744C # if ( loop_on_err ) {
1151: 1143 0002744C L336:
1152: 1144 0002744C 5d effffff7ea tstl _loop_on_err
1153: 1145 00027452 31 0a jeql L337
1154: 1146 00027454 # force_loop = TRUE; /* set the force loop flag */
1155: 1147 00027454 0d 01 effffff7e1 movl $1,_force_loop
1156: 1148 0002745B # asm("brw _pipe2_8_lp1"); /* and loop */
1157: 1149 0002745B 13 ff74 brw _pipe2_8_lp1
1158: 1150 0002745E # }
1159: 1151 0002745E # } /* end of compare error */
1160: 1152 0002745E L337:
1161: 1153 0002745E # } while( index++ < max_lnf_1_index );
1162: 1154 0002745E L333:
1163: 1155 0002745E L330:
1164: 1156 0002745E 0d effffff7d8 50 movl _index,r0
1165: 1157 00027465 6d effffff7d1 incl _index
1166: 1158 0002746B 1d 50 effffff7ca cmpl r0,_max_lnf_1_index
1167: 1159 00027472 81 03 13 ff1e jlss L331
1168: 1160 00027477 L329:
1169: 1161 00027477 # } /* end of subtest 8 */
1170: 1162 00027477 40 ret#2
1171: 1163 00027478 .set L325,0x0
1172: 1164 00027478 L327:
1173: 1165 00027478 13 ff0e jbr L328
1174: 1166 0002747B .data
1175: 1167 00000d0c * .text
1176: 1168 0002747B 00 .align 1
1177: 1169 0002747C .globl _pipe2_9
1178: 1170 0002747C _pipe2_9:
1179: 1171 0002747C 0000 .word L338
1180: 1172 0002747E #
1181: 1173 0002747E #
1182: 1174 0002747E #
1183: 1175 0002747E #
1184: 1176 0002747E #
1185: 1177 0002747E #
1186: 1178 0002747E # /*****************************************************************************
1187: 1179 0002747E # *
1188: 1180 0002747E # * SUBTEST 9
1189: 1181 0002747E # * data on the stack, no NO-OPs
1190: 1182 0002747E # *
1191: 1183 0002747E # *****************************************************************************/
1192: 1184 0002747E # pipe2_9()
1193: 1185 0002747E # {
1194: 1186 0002747E 13 0186 jbr L340
1195: 1187 00027481 L341:
1196: 1188 00027481 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1197: 1189 00027481 ed 6d effffff7b4 moval (r13),_pre_event_fp
1198: 1190 00027488 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1199: 1191 00027488 ed 6e effffff7ad moval (r14),_pre_event_sp
1200: 1192 0002748F # force_loop = FALSE; /* clear force_loop flag */
1201: 1193 0002748F 4d effffff7a7 clrl _force_loop
1202: 1194 00027495 # index = 0;
1203: 1195 00027495 4d effffff7a1 clrl _index
1204: 1196 0002749B # do
1205: 1197 0002749B L344:
1206: 1198 0002749B # {
1207: 1199 0002749B # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1208: 1200 0002749B 0d effffff79b 50 movl _index,r0
1209: 1201 000274A2 48 03 50 50 shll $3,r0,r0
1210: 1202 000274A6 0d e000000000 effffff78b movl _lnf_1_data(r0),_sgl_value_1
1211: 1203 000274B1 # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1212: 1204 000274B1 0d effffff785 50 movl _index,r0
1213: 1205 000274B8 48 03 50 50 shll $3,r0,r0
1214: 1206 000274BC 0d e000000004 effffff775 movl _lnf_1_data+4(r0),_sgl_expected
1215: 1207 000274C7 # sgl_value_2 = 0x40800000; /* floating '1' */
1216: 1208 000274C7 0d 8f40800000 effffff76a movl $1082130432,_sgl_value_2
1217: 1209 000274D2 # sgl_value_3 = 0; /* floating '0' */
1218: 1210 000274D2 4d effffff764 clrl _sgl_value_3
1219: 1211 000274D8 # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1220: 1212 000274D8 ed effffff75e effffff759 moval _pointer_data,_sgl_value_4
1221: 1213 000274E3 # /*
1222: 1214 000274E3 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1223: 1215 000274E3 # * The force loop flag is set after the first error.
1224: 1216 000274E3 # */
1225: 1217 000274E3 # asm("_pipe2_9_lp1:");
1226: 1218 000274E3 _pipe2_9_lp1:
1227: 1219 000274E3 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1228: 1220 000274E3 ed effffff753 5e moval _pointer_data,r14
1229: 1221 000274EA # asm("movl _sgl_value_2,-(r14)"); /* push a '1' on the stack */
1230: 1222 000274EA 0d effffff74c 7e movl _sgl_value_2,-(r14)
1231: 1223 000274F1 # asm("movl _sgl_value_3,-(r14)"); /* push a '0' on the stack */
1232: 1224 000274F1 0d effffff745 7e movl _sgl_value_3,-(r14)
1233: 1225 000274F8 # asm("movl _sgl_value_2,-(r14)"); /* push 2 more '1's */
1234: 1226 000274F8 0d effffff73e 7e movl _sgl_value_2,-(r14)
1235: 1227 000274FF # asm("movl _sgl_value_2,-(r14)");
1236: 1228 000274FF 0d effffff737 7e movl _sgl_value_2,-(r14)
1237: 1229 00027506 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1238: 1230 00027506 0d effffff730 7e movl _sgl_value_1,-(r14)
1239: 1231 0002750D # /*
1240: 1232 0002750D # * now pop the data off the stack
1241: 1233 0002750D # */
1242: 1234 0002750D # asm("lnf (r14)+"); /* load (negate) the data */
1243: 1235 0002750D 16 8e lnf (r14)+
1244: 1236 0002750F # asm("mulf (r14)+"); /* multiply by '1' (twice) */
1245: 1237 0002750F e6 8e mulf (r14)+
1246: 1238 00027511 # asm("mulf (r14)+");
1247: 1239 00027511 e6 8e mulf (r14)+
1248: 1240 00027513 # asm("addf (r14)+"); /* add a '0' */
1249: 1241 00027513 c6 8e addf (r14)+
1250: 1242 00027515 # asm("mulf (r14)+"); /* multiply by '1' again */
1251: 1243 00027515 e6 8e mulf (r14)+
1252: 1244 00027517 # asm("stf r5"); /* store the result */
1253: 1245 00027517 26 55 stf r5
1254: 1246 00027519 # if( force_loop );
1255: 1247 00027519 5d effffff71d tstl _force_loop
1256: 1248 0002751F 31 00 jeql L345
1257: 1249 00027521 # asm("brb _pipe2_9_lp1");; /* loop on the error */
1258: 1250 00027521 L345:
1259: 1251 00027521 11 c0 brb _pipe2_9_lp1
1260: 1252 00027523 # /*
1261: 1253 00027523 # * verify the results
1262: 1254 00027523 # */
1263: 1255 00027523 # asm("movl r5,_sgl_st_acc"); /* get the result */
1264: 1256 00027523 0d 55 effffff712 movl r5,_sgl_st_acc
1265: 1257 0002752A # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1266: 1258 0002752A ed 6e effffff70b moval (r14),_sgl_value_5
1267: 1259 00027531 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1268: 1260 00027531 # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1269: 1261 00027531 1d effffff705 effffff700 cmpl _sgl_st_acc,_sgl_expected
1270: 1262 0002753C 21 10 jneq L9999
1271: 1263 0002753E 1d effffff6f8 effffff6f3 cmpl _sgl_value_5,_sgl_value_4
1272: 1264 00027549 21 03 13 0091 jeql L346
1273: 1265 0002754E L9999:
1274: 1266 0002754E # {
1275: 1267 0002754E # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1276: 1268 0002754E 0d effffff6e8 5d movl _pre_event_fp,r13
1277: 1269 00027555 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1278: 1270 00027555 0d effffff6e1 5e movl _pre_event_sp,r14
1279: 1271 0002755C # errcnt++; /* bump the error count */
1280: 1272 0002755C 6d effffff6da incl _errcnt
1281: 1273 00027562 # if ( prt_error )
1282: 1274 00027562 5d effffff6d4 tstl _prt_error
1283: 1275 00027568 31 0d jeql L347
1284: 1276 0002756A # print_pipe2_er("POP Data from the STACK");
1285: 1277 0002756A .data 1
1286: 1278 00000db9 * L348:
1287: 1279 00000db9 * 504F5020446174612066726F6 .ascii "POP Data from the STACK\0"
1288: D2074686520535441434B00
1289: 1280 00000dd1 * .text
1290: 1281 0002756A dd 8f00000db9 pushl $L348
1291: 1282 00027570 fe 08 ef00000251 callf $8,_print_pipe2_er
1292: 1283 00027577 # writes("final Stack Pointer = ");
1293: 1284 00027577 L347:
1294: 1285 00027577 .data 1
1295: 1286 00000dd1 * L349:
1296: 1287 00000dd1 * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
1297: 06F696E746572203D2000
1298: 1288 00000de8 * .text
1299: 1289 00027577 dd 8f00000dd1 pushl $L349
1300: 1290 0002757D fe 08 effffff6b8 callf $8,_writes
1301: 1291 00027584 # write32h( sgl_value_5 );
1302: 1292 00027584 dd effffff6b2 pushl _sgl_value_5
1303: 1293 0002758A fe 08 effffff6ab callf $8,_write32h
1304: 1294 00027591 # writes(", expected SP = ");
1305: 1295 00027591 .data 1
1306: 1296 00000de8 * L351:
1307: 1297 00000de8 * 2C20206578706563746564205 .ascii ", expected SP = \0"
1308: 350203D2000
1309: 1298 00000dfa * .text
1310: 1299 00027591 dd 8f00000de8 pushl $L351
1311: 1300 00027597 fe 08 effffff69e callf $8,_writes
1312: 1301 0002759E # write32h( sgl_value_4 );
1313: 1302 0002759E dd effffff698 pushl _sgl_value_4
1314: 1303 000275A4 fe 08 effffff691 callf $8,_write32h
1315: 1304 000275AB # writes(" \n");
1316: 1305 000275AB .data 1
1317: 1306 00000dfa * L352:
1318: 1307 00000dfa * 200A00 .ascii " \12\0"
1319: 1308 00000dfd * .text
1320: 1309 000275AB dd 8f00000dfa pushl $L352
1321: 1310 000275B1 fe 08 effffff684 callf $8,_writes
1322: 1311 000275B8 # if ( halt_flg ) /* halt on error? */
1323: 1312 000275B8 5d effffff67e tstl _halt_flg
1324: 1313 000275BE 31 0d jeql L353
1325: 1314 000275C0 # pipe2_er_hlt( subtest );
1326: 1315 000275C0 dd effffff676 pushl _subtest
1327: 1316 000275C6 fe 08 ef00000307 callf $8,_pipe2_er_hlt
1328: 1317 000275CD # if ( loop_on_err ) {
1329: 1318 000275CD L353:
1330: 1319 000275CD 5d effffff669 tstl _loop_on_err
1331: 1320 000275D3 31 0a jeql L354
1332: 1321 000275D5 # force_loop = TRUE; /* set the force loop flag */
1333: 1322 000275D5 0d 01 effffff660 movl $1,_force_loop
1334: 1323 000275DC # asm("brw _pipe2_9_lp1"); /* and loop */
1335: 1324 000275DC 13 ff04 brw _pipe2_9_lp1
1336: 1325 000275DF # }
1337: 1326 000275DF # } /* end of compare error */
1338: 1327 000275DF L354:
1339: 1328 000275DF # } while( index++ < max_lnf_1_index );
1340: 1329 000275DF L346:
1341: 1330 000275DF L343:
1342: 1331 000275DF 0d effffff657 50 movl _index,r0
1343: 1332 000275E6 6d effffff650 incl _index
1344: 1333 000275EC 1d 50 effffff649 cmpl r0,_max_lnf_1_index
1345: 1334 000275F3 81 03 13 fea3 jlss L344
1346: 1335 000275F8 L342:
1347: 1336 000275F8 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1348: 1337 000275F8 0d effffff63e 5d movl _pre_event_fp,r13
1349: 1338 000275FF # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1350: 1339 000275FF 0d effffff637 5e movl _pre_event_sp,r14
1351: 1340 00027606 # } /* end of subtest 9 */
1352: 1341 00027606 40 ret#2
1353: 1342 00027607 .set L338,0x0
1354: 1343 00027607 L340:
1355: 1344 00027607 13 fe77 jbr L341
1356: 1345 0002760A .data
1357: 1346 00000d0c * .text
1358: 1347 0002760A .align 1
1359: 1348 0002760A .globl _pipe2_10
1360: 1349 0002760A _pipe2_10:
1361: 1350 0002760A 0000 .word L355
1362: 1351 0002760C #
1363: 1352 0002760C #
1364: 1353 0002760C #
1365: 1354 0002760C #
1366: 1355 0002760C #
1367: 1356 0002760C #
1368: 1357 0002760C # /******************************************************************************
1369: 1358 0002760C # *
1370: 1359 0002760C # * SUBTEST 10
1371: 1360 0002760C # * get data via indexed FRAME pointer
1372: 1361 0002760C # *
1373: 1362 0002760C # * ADDR INDEX DATA
1374: 1363 0002760C # * pointer_data 4 <the STF result goes here>
1375: 1364 0002760C # * pointer_data-4 3 <operand data>
1376: 1365 0002760C # * pointer_data-16 0 point the frame pointer here
1377: 1366 0002760C # *
1378: 1367 0002760C # ******************************************************************************/
1379: 1368 0002760C # pipe2_10()
1380: 1369 0002760C # {
1381: 1370 0002760C 13 01b6 jbr L357
1382: 1371 0002760F L358:
1383: 1372 0002760F # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1384: 1373 0002760F ed 6d effffff626 moval (r13),_pre_event_fp
1385: 1374 00027616 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1386: 1375 00027616 ed 6e effffff61f moval (r14),_pre_event_sp
1387: 1376 0002761D # force_loop = FALSE; /* clear force_loop flag */
1388: 1377 0002761D 4d effffff619 clrl _force_loop
1389: 1378 00027623 # index = 0;
1390: 1379 00027623 4d effffff613 clrl _index
1391: 1380 00027629 # do
1392: 1381 00027629 L361:
1393: 1382 00027629 # {
1394: 1383 00027629 # sgl_value_1 = lnf_1_data[index].ld; /* get operand 1 */
1395: 1384 00027629 0d effffff60d 50 movl _index,r0
1396: 1385 00027630 48 03 50 50 shll $3,r0,r0
1397: 1386 00027634 0d e000000000 effffff5fd movl _lnf_1_data(r0),_sgl_value_1
1398: 1387 0002763F # sgl_expected = lnf_1_data[index].exp; /* get expected results */
1399: 1388 0002763F 0d effffff5f7 50 movl _index,r0
1400: 1389 00027646 48 03 50 50 shll $3,r0,r0
1401: 1390 0002764A 0d e000000004 effffff5e7 movl _lnf_1_data+4(r0),_sgl_expected
1402: 1391 00027655 # sgl_value_2 = 0x40800000; /* floating '1' */
1403: 1392 00027655 0d 8f40800000 effffff5dc movl $1082130432,_sgl_value_2
1404: 1393 00027660 # sgl_value_3 = 0; /* floating '0' */
1405: 1394 00027660 4d effffff5d6 clrl _sgl_value_3
1406: 1395 00027666 # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
1407: 1396 00027666 ed effffff5d0 effffff5cb moval _pointer_data,_sgl_value_4
1408: 1397 00027671 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1409: 1398 00027671 2c 04 effffff5c4 subl2 $4,_sgl_value_4
1410: 1399 00027678 # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
1411: 1400 00027678 0d effffff5be fffffff5b9 movl _sgl_value_1,*_sgl_value_4
1412: 1401 00027683 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1413: 1402 00027683 2c 04 effffff5b2 subl2 $4,_sgl_value_4
1414: 1403 0002768A # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the operand data */
1415: 1404 0002768A 0d effffff5ac fffffff5a7 movl _sgl_value_2,*_sgl_value_4
1416: 1405 00027695 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1417: 1406 00027695 2c 04 effffff5a0 subl2 $4,_sgl_value_4
1418: 1407 0002769C # asm("movl _sgl_value_3,*_sgl_value_4"); /* set the operand data */
1419: 1408 0002769C 0d effffff59a fffffff595 movl _sgl_value_3,*_sgl_value_4
1420: 1409 000276A7 # sgl_value_4 -= 4; /* get FRAME PTR address */
1421: 1410 000276A7 2c 04 effffff58e subl2 $4,_sgl_value_4
1422: 1411 000276AE # /*
1423: 1412 000276AE # * If LOOP ON ERROR is set, this is the loop for this subtest.
1424: 1413 000276AE # * The force loop flag is set after the first error.
1425: 1414 000276AE # */
1426: 1415 000276AE # asm("_pipe2_10_lp1:");
1427: 1416 000276AE _pipe2_10_lp1:
1428: 1417 000276AE # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1429: 1418 000276AE 0d effffff588 5d movl _sgl_value_4,r13
1430: 1419 000276B5 # asm("movl $1,r1"); /* r1 index = 1 longwords */
1431: 1420 000276B5 0d 01 51 movl $1,r1
1432: 1421 000276B8 # asm("movl $2,r2"); /* r2 index = 2 longwords */
1433: 1422 000276B8 0d 02 52 movl $2,r2
1434: 1423 000276BB # asm("movl $3,r3"); /* r3 index = 3 longwords */
1435: 1424 000276BB 0d 03 53 movl $3,r3
1436: 1425 000276BE # asm("movl $4,r4"); /* r4 index = 4 longwords */
1437: 1426 000276BE 0d 04 54 movl $4,r4
1438: 1427 000276C1 # asm("lnf (r13)[r3]"); /* load -indexed by r3 */
1439: 1428 000276C1 16 436d lnf (r13)[r3]
1440: 1429 000276C4 # asm("mulf (r13)[r2]"); /* multiply by '1' (twice) */
1441: 1430 000276C4 e6 426d mulf (r13)[r2]
1442: 1431 000276C7 # asm("mulf (r13)[r2]");
1443: 1432 000276C7 e6 426d mulf (r13)[r2]
1444: 1433 000276CA # asm("addf (r13)[r1]"); /* add a '0' to it */
1445: 1434 000276CA c6 416d addf (r13)[r1]
1446: 1435 000276CD # asm("mulf (r13)[r2]"); /* multiply by '1' again */
1447: 1436 000276CD e6 426d mulf (r13)[r2]
1448: 1437 000276D0 # asm("stf (r13)[r4]"); /* store -indexed by r4 */
1449: 1438 000276D0 26 446d stf (r13)[r4]
1450: 1439 000276D3 # if( force_loop );
1451: 1440 000276D3 5d effffff563 tstl _force_loop
1452: 1441 000276D9 31 00 jeql L362
1453: 1442 000276DB # asm("brb _pipe2_10_lp1");; /* loop on the error */
1454: 1443 000276DB L362:
1455: 1444 000276DB 11 d1 brb _pipe2_10_lp1
1456: 1445 000276DD # /*
1457: 1446 000276DD # * verify the results
1458: 1447 000276DD # */
1459: 1448 000276DD # sgl_st_acc = pointer_data; /* move the stored result */
1460: 1449 000276DD 0d effffff559 effffff554 movl _pointer_data,_sgl_st_acc
1461: 1450 000276E8 # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1462: 1451 000276E8 ed 6d effffff54d moval (r13),_sgl_value_5
1463: 1452 000276EF # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1464: 1453 000276EF # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1465: 1454 000276EF 1d effffff547 effffff542 cmpl _sgl_st_acc,_sgl_expected
1466: 1455 000276FA 21 10 jneq L9998
1467: 1456 000276FC 1d effffff53a effffff535 cmpl _sgl_value_5,_sgl_value_4
1468: 1457 00027707 21 03 13 0091 jeql L363
1469: 1458 0002770C L9998:
1470: 1459 0002770C # {
1471: 1460 0002770C # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1472: 1461 0002770C 0d effffff52a 5d movl _pre_event_fp,r13
1473: 1462 00027713 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1474: 1463 00027713 0d effffff523 5e movl _pre_event_sp,r14
1475: 1464 0002771A # errcnt++; /* bump the error count */
1476: 1465 0002771A 6d effffff51c incl _errcnt
1477: 1466 00027720 # if ( prt_error )
1478: 1467 00027720 5d effffff516 tstl _prt_error
1479: 1468 00027726 31 0d jeql L364
1480: 1469 00027728 # print_pipe2_er("indexed FP addressing");
1481: 1470 00027728 .data 1
1482: 1471 00000dfd * L365:
1483: 1472 00000dfd * 696E646578656420465020616 .ascii "indexed FP addressing\0"
1484: 46472657373696E6700
1485: 1473 00000e13 * .text
1486: 1474 00027728 dd 8f00000dfd pushl $L365
1487: 1475 0002772E fe 08 ef00000093 callf $8,_print_pipe2_er
1488: 1476 00027735 # writes("final Frame Pointer = ");
1489: 1477 00027735 L364:
1490: 1478 00027735 .data 1
1491: 1479 00000e13 * L366:
1492: 1480 00000e13 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
1493: 06F696E746572203D2000
1494: 1481 00000e2a * .text
1495: 1482 00027735 dd 8f00000e13 pushl $L366
1496: 1483 0002773B fe 08 effffff4fa callf $8,_writes
1497: 1484 00027742 # writeh( sgl_value_5 );
1498: 1485 00027742 dd effffff4f4 pushl _sgl_value_5
1499: 1486 00027748 fe 08 effffff4ed callf $8,_writeh
1500: 1487 0002774F # writes(", expected FP = ");
1501: 1488 0002774F .data 1
1502: 1489 00000e2a * L368:
1503: 1490 00000e2a * 2C20206578706563746564204 .ascii ", expected FP = \0"
1504: 650203D2000
1505: 1491 00000e3c * .text
1506: 1492 0002774F dd 8f00000e2a pushl $L368
1507: 1493 00027755 fe 08 effffff4e0 callf $8,_writes
1508: 1494 0002775C # writeh( sgl_value_4 );
1509: 1495 0002775C dd effffff4da pushl _sgl_value_4
1510: 1496 00027762 fe 08 effffff4d3 callf $8,_writeh
1511: 1497 00027769 # writes(" \n");
1512: 1498 00027769 .data 1
1513: 1499 00000e3c * L369:
1514: 1500 00000e3c * 200A00 .ascii " \12\0"
1515: 1501 00000e3f * .text
1516: 1502 00027769 dd 8f00000e3c pushl $L369
1517: 1503 0002776F fe 08 effffff4c6 callf $8,_writes
1518: 1504 00027776 # if ( halt_flg ) /* halt on error? */
1519: 1505 00027776 5d effffff4c0 tstl _halt_flg
1520: 1506 0002777C 31 0d jeql L370
1521: 1507 0002777E # pipe2_er_hlt( subtest );
1522: 1508 0002777E dd effffff4b8 pushl _subtest
1523: 1509 00027784 fe 08 ef00000149 callf $8,_pipe2_er_hlt
1524: 1510 0002778B # if ( loop_on_err ) {
1525: 1511 0002778B L370:
1526: 1512 0002778B 5d effffff4ab tstl _loop_on_err
1527: 1513 00027791 31 0a jeql L371
1528: 1514 00027793 # force_loop = TRUE; /* set the force loop flag */
1529: 1515 00027793 0d 01 effffff4a2 movl $1,_force_loop
1530: 1516 0002779A # asm("brw _pipe2_10_lp1"); /* and loop */
1531: 1517 0002779A 13 ff11 brw _pipe2_10_lp1
1532: 1518 0002779D # }
1533: 1519 0002779D # } /* end of compare error */
1534: 1520 0002779D L371:
1535: 1521 0002779D # } while( index++ < max_lnf_1_index );
1536: 1522 0002779D L363:
1537: 1523 0002779D L360:
1538: 1524 0002779D 0d effffff499 50 movl _index,r0
1539: 1525 000277A4 6d effffff492 incl _index
1540: 1526 000277AA 1d 50 effffff48b cmpl r0,_max_lnf_1_index
1541: 1527 000277B1 81 03 13 fe73 jlss L361
1542: 1528 000277B6 L359:
1543: 1529 000277B6 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1544: 1530 000277B6 0d effffff480 5d movl _pre_event_fp,r13
1545: 1531 000277BD # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1546: 1532 000277BD 0d effffff479 5e movl _pre_event_sp,r14
1547: 1533 000277C4 # } /* end of subtest 10 */
1548: 1534 000277C4 40 ret#2
1549: 1535 000277C5 .set L355,0x0
1550: 1536 000277C5 L357:
1551: 1537 000277C5 13 fe47 jbr L358
1552: 1538 000277C8 .data
1553: 1539 00000d0c * .text
1554: 1540 000277C8 .align 1
1555: 1541 000277C8 .globl _print_pipe2_er
1556: 1542 000277C8 _print_pipe2_er:
1557: 1543 000277C8 0000 .word L372
1558: 1544 000277CA #
1559: 1545 000277CA #
1560: 1546 000277CA # /******************************************************************************
1561: 1547 000277CA # *
1562: 1548 000277CA # *
1563: 1549 000277CA # * print an error in the following form
1564: 1550 000277CA # *
1565: 1551 000277CA # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd
1566: 1552 000277CA # * expected Acc = xxxxxxxx
1567: 1553 000277CA # *
1568: 1554 000277CA # ******************************************************************************/
1569: 1555 000277CA # print_pipe2_er(msg)
1570: 1556 000277CA # char *msg;
1571: 1557 000277CA # {
1572: 1558 000277CA 13 0103 jbr L374
1573: 1559 000277CD L375:
1574: 1560 000277CD # writes(" \n"); /* start a new print line */
1575: 1561 000277CD .data 1
1576: 1562 00000e3f * L376:
1577: 1563 00000e3f * 200A00 .ascii " \12\0"
1578: 1564 00000e42 * .text
1579: 1565 000277CD dd 8f00000e3f pushl $L376
1580: 1566 000277D3 fe 08 effffff462 callf $8,_writes
1581: 1567 000277DA # writes("cycle: ");
1582: 1568 000277DA .data 1
1583: 1569 00000e42 * L377:
1584: 1570 00000e42 * 6379636C653A2000 .ascii "cycle: \0"
1585: 1571 00000e4a * .text
1586: 1572 000277DA dd 8f00000e42 pushl $L377
1587: 1573 000277E0 fe 08 effffff455 callf $8,_writes
1588: 1574 000277E7 # writed( cycle );
1589: 1575 000277E7 dd effffff44f pushl _cycle
1590: 1576 000277ED fe 08 effffff448 callf $8,_writed
1591: 1577 000277F4 # writes(" test ");
1592: 1578 000277F4 .data 1
1593: 1579 00000e4a * L379:
1594: 1580 00000e4a * 20746573742000 .ascii " test \0"
1595: 1581 00000e51 * .text
1596: 1582 000277F4 dd 8f00000e4a pushl $L379
1597: 1583 000277FA fe 08 effffff43b callf $8,_writes
1598: 1584 00027801 # writed( test_no );
1599: 1585 00027801 dd effffff435 pushl _test_no
1600: 1586 00027807 fe 08 effffff42e callf $8,_writed
1601: 1587 0002780E # writes(" (Pipe 2), subtest ");
1602: 1588 0002780E .data 1
1603: 1589 00000e51 * L380:
1604: 1590 00000e51 * 202028506970652032292C207 .ascii " (Pipe 2), subtest \0"
1605: 37562746573742000
1606: 1591 00000e66 * .text
1607: 1592 0002780E dd 8f00000e51 pushl $L380
1608: 1593 00027814 fe 08 effffff421 callf $8,_writes
1609: 1594 0002781B # writed( subtest );
1610: 1595 0002781B dd effffff41b pushl _subtest
1611: 1596 00027821 fe 08 effffff414 callf $8,_writed
1612: 1597 00027828 # writes(" error - ");
1613: 1598 00027828 .data 1
1614: 1599 00000e66 * L381:
1615: 1600 00000e66 * 206572726F72202D2000 .ascii " error - \0"
1616: 1601 00000e70 * .text
1617: 1602 00027828 dd 8f00000e66 pushl $L381
1618: 1603 0002782E fe 08 effffff407 callf $8,_writes
1619: 1604 00027835 # writes( msg );
1620: 1605 00027835 dd ad04 pushl 4(fp)
1621: 1606 00027838 fe 08 effffff3fd callf $8,_writes
1622: 1607 0002783F # writec('\n');
1623: 1608 0002783F dd 0a pushl $10
1624: 1609 00027841 fe 08 effffff3f4 callf $8,_writec
1625: 1610 00027848 # writes(" LNF (op1), MULF(1.0), MULF(1.0), ADD(0.0), MULF(1.0), STF\n");
1626: 1611 00027848 .data 1
1627: 1612 00000e70 * L383:
1628: 1613 00000e70 * 204C4E4620286F7031292C204 .ascii " LNF (op1), MULF(1.0), MULF(1.0), ADD(0.0), MULF(1.0), STF\12\0"
1629: D554C4628312E30292C204D55
1630: 4C4628312E30292C204144442
1631: 8302E30292C204D554C462831
1632: 2E30292C205354460A00
1633: 1614 00000eac * .text
1634: 1615 00027848 dd 8f00000e70 pushl $L383
1635: 1616 0002784E fe 08 effffff3e7 callf $8,_writes
1636: 1617 00027855 # writes("operand = ");
1637: 1618 00027855 .data 1
1638: 1619 00000eac * L384:
1639: 1620 00000eac * 6F706572616E64203D2000 .ascii "operand = \0"
1640: 1621 00000eb7 * .text
1641: 1622 00027855 dd 8f00000eac pushl $L384
1642: 1623 0002785B fe 08 effffff3da callf $8,_writes
1643: 1624 00027862 # write32h( sgl_value_1 );
1644: 1625 00027862 dd effffff3d4 pushl _sgl_value_1
1645: 1626 00027868 fe 08 effffff3cd callf $8,_write32h
1646: 1627 0002786F # writes(", final Acc = ");
1647: 1628 0002786F .data 1
1648: 1629 00000eb7 * L385:
1649: 1630 00000eb7 * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
1650: 3203D2000
1651: 1631 00000ec8 * .text
1652: 1632 0002786F dd 8f00000eb7 pushl $L385
1653: 1633 00027875 fe 08 effffff3c0 callf $8,_writes
1654: 1634 0002787C # write32h( sgl_st_acc );
1655: 1635 0002787C dd effffff3ba pushl _sgl_st_acc
1656: 1636 00027882 fe 08 effffff3b3 callf $8,_write32h
1657: 1637 00027889 # writes(", data index = ");
1658: 1638 00027889 .data 1
1659: 1639 00000ec8 * L386:
1660: 1640 00000ec8 * 2C2020206461746120696E646 .ascii ", data index = \0"
1661: 578203D2000
1662: 1641 00000eda * .text
1663: 1642 00027889 dd 8f00000ec8 pushl $L386
1664: 1643 0002788F fe 08 effffff3a6 callf $8,_writes
1665: 1644 00027896 # writed( index );
1666: 1645 00027896 dd effffff3a0 pushl _index
1667: 1646 0002789C fe 08 effffff399 callf $8,_writed
1668: 1647 000278A3 # writec('\n');
1669: 1648 000278A3 dd 0a pushl $10
1670: 1649 000278A5 fe 08 effffff390 callf $8,_writec
1671: 1650 000278AC # writes(" expected Acc = ");
1672: 1651 000278AC .data 1
1673: 1652 00000eda * L387:
1674: 1653 00000eda * 2020202020202020202020202 .ascii " expected Acc = \0"
1675: 0202020202020657870656374
1676: 656420416363203D2000
1677: 1654 00000efd * .text
1678: 1655 000278AC dd 8f00000eda pushl $L387
1679: 1656 000278B2 fe 08 effffff383 callf $8,_writes
1680: 1657 000278B9 # write32h( sgl_expected );
1681: 1658 000278B9 dd effffff37d pushl _sgl_expected
1682: 1659 000278BF fe 08 effffff376 callf $8,_write32h
1683: 1660 000278C6 # writec('\n');
1684: 1661 000278C6 dd 0a pushl $10
1685: 1662 000278C8 fe 08 effffff36d callf $8,_writec
1686: 1663 000278CF # }
1687: 1664 000278CF 40 ret#2
1688: 1665 000278D0 .set L372,0x0
1689: 1666 000278D0 L374:
1690: 1667 000278D0 13 fefa jbr L375
1691: 1668 000278D3 .data
1692: 1669 00000d0c * .text
1693: 1670 000278D3 00 .align 1
1694: 1671 000278D4 .globl _pipe2_er_hlt
1695: 1672 000278D4 _pipe2_er_hlt:
1696: 1673 000278D4 0000 .word L388
1697: 1674 000278D6 #
1698: 1675 000278D6 #
1699: 1676 000278D6 #
1700: 1677 000278D6 #
1701: 1678 000278D6 #
1702: 1679 000278D6 # /******************************************************************************
1703: 1680 000278D6 # *
1704: 1681 000278D6 # * HALT ON ERROR ROUTINE
1705: 1682 000278D6 # *
1706: 1683 000278D6 # * halt with the necessary information saved in the registers
1707: 1684 000278D6 # *
1708: 1685 000278D6 # ******************************************************************************/
1709: 1686 000278D6 # pipe2_er_hlt( subtest )
1710: 1687 000278D6 # int subtest;
1711: 1688 000278D6 # {
1712: 1689 000278D6 11 6e jbr L390
1713: 1690 000278D8 L391:
1714: 1691 000278D8 # asm("movl _test_no,r0"); /* r0 = test number */
1715: 1692 000278D8 0d effffff35e 50 movl _test_no,r0
1716: 1693 000278DF # asm("movl _subtest,r1"); /* r1 = subtest number */
1717: 1694 000278DF 0d effffff357 51 movl _subtest,r1
1718: 1695 000278E6 # asm("movl $1,r2"); /* r2 = error code */
1719: 1696 000278E6 0d 01 52 movl $1,r2
1720: 1697 000278E9 # asm("movl _cycle,r3"); /* r3 = cycle count */
1721: 1698 000278E9 0d effffff34d 53 movl _cycle,r3
1722: 1699 000278F0 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1723: 1700 000278F0 0d effffff346 54 movl _sgl_value_1,r4
1724: 1701 000278F7 # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */
1725: 1702 000278F7 0d effffff33f 55 movl _sgl_st_acc,r5
1726: 1703 000278FE # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */
1727: 1704 000278FE 0d effffff338 56 movl _sgl_expected,r6
1728: 1705 00027905 # asm("movl _index,r7"); /* r7 = data index */
1729: 1706 00027905 0d effffff331 57 movl _index,r7
1730: 1707 0002790C # asm("movl _sgl_value_2,r8"); /* r8 = floating one */
1731: 1708 0002790C 0d effffff32a 58 movl _sgl_value_2,r8
1732: 1709 00027913 # asm("movl _sgl_value_3,r9"); /* r9 = floating zero */
1733: 1710 00027913 0d effffff323 59 movl _sgl_value_3,r9
1734: 1711 0002791A # if( subtest == 9 ) {
1735: 1712 0002791A 1d ad04 09 cmpl 4(fp),$9
1736: 1713 0002791E 21 10 jneq L392
1737: 1714 00027920 # asm("movl _sgl_value_5,r10"); /* r10= final SP value */
1738: 1715 00027920 0d effffff316 5a movl _sgl_value_5,r10
1739: 1716 00027927 # asm("movl _sgl_value_4,r11"); /* r11= expected SP value */
1740: 1717 00027927 0d effffff30f 5b movl _sgl_value_4,r11
1741: 1718 0002792E # } else
1742: 1719 0002792E 11 14 jbr L393
1743: 1720 00027930 L392:
1744: 1721 00027930 # if( subtest == 10 ) {
1745: 1722 00027930 1d ad04 0a cmpl 4(fp),$10
1746: 1723 00027934 21 0e jneq L394
1747: 1724 00027936 # asm("movl _sgl_value_5,r10"); /* r10= final FP value */
1748: 1725 00027936 0d effffff300 5a movl _sgl_value_5,r10
1749: 1726 0002793D # asm("movl _sgl_value_4,r11"); /* r11= expected FP value */
1750: 1727 0002793D 0d effffff2f9 5b movl _sgl_value_4,r11
1751: 1728 00027944 # };
1752: 1729 00027944 L394:
1753: 1730 00027944 L393:
1754: 1731 00027944 # asm(".globl _pipe2_1_hlt");
1755: 1732 00027944 .globl _pipe2_1_hlt
1756: 1733 00027944 # asm("_pipe2_1_hlt:"); /* PC after the halt */
1757: 1734 00027944 _pipe2_1_hlt:
1758: 1735 00027944 # asm("halt"); /* HALT ... */
1759: 1736 00027944 00 halt
1760: 1737 00027945 # } /* end of halt on error */
1761: 1738 00027945 40 ret#2
1762: 1739 00027946 .set L388,0x0
1763: 1740 00027946 L390:
1764: 1741 00027946 11 90 jbr L391
1765: 1742 00000d0c * .data
1766: 1742 00000d0c * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.