![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe1.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 pipe1.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 00000c00 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_1
6: 6 00000000 _pipe_1:
7: 7 0002603C 0000 .word L215
8: 8 0002603E #
9: 9 0002603E #
10: 10 0002603E # #include "fpp_defs.h"
11: 11 0002603E #
12: 12 0002603E #
13: 13 0002603E # /*****************************************************************************
14: 14 0002603E # *
15: 15 0002603E # * PIPELINE TEST #1 MONITOR
16: 16 0002603E # *
17: 17 0002603E # * This test will do:
18: 18 0002603E # *
19: 19 0002603E # * LDF(x), SUBF(x), SUBF(x), ADDF(x), ADDF(x), STF
20: 20 0002603E # *
21: 21 0002603E # * where the x's are the fmacro1 LDF data patterns.
22: 22 0002603E # *****************************************************************************/
23: 23 0002603E # pipe_1()
24: 24 0002603E # {
25: 25 0002603E 13 00a8 jbr L217
26: 26 00026041 L218:
27: 27 00026041 # asm(".globl _pipeline_1_t");
28: 28 00026041 .globl _pipeline_1_t
29: 29 00026041 # asm("_pipeline_1_t:"); /* entry address */
30: 30 00026041 _pipeline_1_t:
31: 31 00026041 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
32: 32 00026041 1d effffffff5 01 cmpl _cycle,$1
33: 33 00026048 21 15 jneq L219
34: 34 0002604A 5d efffffffec tstl _prt_hdrs
35: 35 00026050 31 0d jeql L219
36: 36 00026052 # {
37: 37 00026052 # writes("\n PIPE_1 ");
38: 38 00026052 .data 1
39: 39 00000c00 * L221:
40: 40 00000c00 * 0A20504950455F312000 .ascii "\12 PIPE_1 \0"
41: 41 00000c0a * .text
42: 42 00026052 dd 8f00000c00 pushl $L221
43: 43 00026058 fe 08 efffffffdd callf $8,_writes
44: 44 0002605F # }
45: 45 0002605F # subtest = 1;
46: 46 0002605F L219:
47: 47 0002605F 0d 01 efffffffd6 movl $1,_subtest
48: 48 00026066 # pipe1_1(); /* data in REGs, no NOPs */
49: 49 00026066 fe 04 ef0000007f callf $4,_pipe1_1
50: 50 0002606D # subtest++; /* increment subtest num */
51: 51 0002606D 6d efffffffc9 incl _subtest
52: 52 00026073 # pipe1_2(); /* data in REGs, 1 NOP */
53: 53 00026073 fe 04 ef00000140 callf $4,_pipe1_2
54: 54 0002607A # subtest++; /* increment subtest num */
55: 55 0002607A 6d efffffffbc incl _subtest
56: 56 00026080 # pipe1_3(); /* data in REGs, 2 NOPs */
57: 57 00026080 fe 04 ef00000205 callf $4,_pipe1_3
58: 58 00026087 # subtest++; /* increment subtest num */
59: 59 00026087 6d efffffffaf incl _subtest
60: 60 0002608D # pipe1_4(); /* data in REGs, 3 NOPs */
61: 61 0002608D fe 04 ef000002d0 callf $4,_pipe1_4
62: 62 00026094 # subtest++; /* increment subtest num */
63: 63 00026094 6d efffffffa2 incl _subtest
64: 64 0002609A # pipe1_5(); /* data in CACHE, no NOPs */
65: 65 0002609A fe 04 ef0000039f callf $4,_pipe1_5
66: 66 000260A1 # subtest++; /* increment subtest num */
67: 67 000260A1 6d efffffff95 incl _subtest
68: 68 000260A7 # pipe1_6(); /* data in CACHE, 1 NOP */
69: 69 000260A7 fe 04 ef0000046a callf $4,_pipe1_6
70: 70 000260AE # subtest++; /* increment subtest num */
71: 71 000260AE 6d efffffff88 incl _subtest
72: 72 000260B4 # pipe1_7(); /* data in CACHE, 2 NOPs */
73: 73 000260B4 fe 04 ef00000539 callf $4,_pipe1_7
74: 74 000260BB # subtest++; /* increment subtest num */
75: 75 000260BB 6d efffffff7b incl _subtest
76: 76 000260C1 # pipe1_8(); /* data in CACHE, 3 NOPs */
77: 77 000260C1 fe 04 ef0000060e callf $4,_pipe1_8
78: 78 000260C8 # subtest++; /* increment subtest num */
79: 79 000260C8 6d efffffff6e incl _subtest
80: 80 000260CE # pipe1_9(); /* data on STACK, no NOPs */
81: 81 000260CE fe 04 ef000006e7 callf $4,_pipe1_9
82: 82 000260D5 # subtest++; /* increment subtest num */
83: 83 000260D5 6d efffffff61 incl _subtest
84: 84 000260DB # pipe1_10(); /* data via FP no NOPs */
85: 85 000260DB fe 04 ef00000858 callf $4,_pipe1_10
86: 86 000260E2 # asm("jmp *return"); /* return to the test monitor */
87: 87 000260E2 71 ffffffff54 jmp *return
88: 88 000260E8 # }
89: 89 000260E8 40 ret#2
90: 90 000260E9 .set L215,0x0
91: 91 000260E9 L217:
92: 92 000260E9 13 ff55 jbr L218
93: 93 000260EC .data
94: 94 00000c00 * .text
95: 95 000260EC .align 1
96: 96 000260EC .globl _pipe1_1
97: 97 000260EC _pipe1_1:
98: 98 000260EC 0000 .word L232
99: 99 000260EE #
100: 100 000260EE #
101: 101 000260EE #
102: 102 000260EE #
103: 103 000260EE #
104: 104 000260EE #
105: 105 000260EE # /************************************************************************
106: 106 000260EE # *
107: 107 000260EE # * SUBTEST 1
108: 108 000260EE # * data in registers, no NO-OPs
109: 109 000260EE # *
110: 110 000260EE # ************************************************************************/
111: 111 000260EE # pipe1_1()
112: 112 000260EE # {
113: 113 000260EE 13 00c5 jbr L234
114: 114 000260F1 L235:
115: 115 000260F1 # force_loop = FALSE; /* clear the force_loop flg */
116: 116 000260F1 4d efffffff45 clrl _force_loop
117: 117 000260F7 # index = 0;
118: 118 000260F7 4d efffffff3f clrl _index
119: 119 000260FD # do
120: 120 000260FD L238:
121: 121 000260FD # {
122: 122 000260FD # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
123: 123 000260FD 0d efffffff39 50 movl _index,r0
124: 124 00026104 48 03 50 50 shll $3,r0,r0
125: 125 00026108 0d e000000000 efffffff29 movl _ldf_1_data(r0),_sgl_value_1
126: 126 00026113 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
127: 127 00026113 0d efffffff23 50 movl _index,r0
128: 128 0002611A 48 03 50 50 shll $3,r0,r0
129: 129 0002611E 0d e000000004 efffffff13 movl _ldf_1_data+4(r0),_sgl_expected
130: 130 00026129 # /*
131: 131 00026129 # * If LOOP ON ERROR is set, this is the loop for this subtest.
132: 132 00026129 # * The force loop flag is set after the first error.
133: 133 00026129 # */
134: 134 00026129 # asm("_pipe1_1_lp1:");
135: 135 00026129 _pipe1_1_lp1:
136: 136 00026129 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
137: 137 00026129 0d efffffff0d 54 movl _sgl_value_1,r4
138: 138 00026130 # asm("ldf r4"); /* load the operand */
139: 139 00026130 06 54 ldf r4
140: 140 00026132 # asm("subf r4"); /* subtract it (twice ) */
141: 141 00026132 d6 54 subf r4
142: 142 00026134 # asm("subf r4");
143: 143 00026134 d6 54 subf r4
144: 144 00026136 # asm("addf r4"); /* add it back (twice) */
145: 145 00026136 c6 54 addf r4
146: 146 00026138 # asm("addf r4");
147: 147 00026138 c6 54 addf r4
148: 148 0002613A # asm("stf r5"); /* store the result */
149: 149 0002613A 26 55 stf r5
150: 150 0002613C # if ( force_loop );
151: 151 0002613C 5d effffffefa tstl _force_loop
152: 152 00026142 31 00 jeql L239
153: 153 00026144 # asm("brb _pipe1_1_lp1");; /* loop on the error */
154: 154 00026144 L239:
155: 155 00026144 11 e3 brb _pipe1_1_lp1
156: 156 00026146 # /*
157: 157 00026146 # * verify the results
158: 158 00026146 # */
159: 159 00026146 # asm("movl r5,_sgl_st_acc"); /* get the result */
160: 160 00026146 0d 55 effffffeef movl r5,_sgl_st_acc
161: 161 0002614D # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
162: 162 0002614D 1d effffffee9 effffffee4 cmpl _sgl_st_acc,_sgl_expected
163: 163 00026158 31 42 jeql L240
164: 164 0002615A # {
165: 165 0002615A # errcnt++; /* bump the error count */
166: 166 0002615A 6d effffffedc incl _errcnt
167: 167 00026160 # if ( prt_error )
168: 168 00026160 5d effffffed6 tstl _prt_error
169: 169 00026166 31 0d jeql L241
170: 170 00026168 # print_pipe1_er("Reg. Data, no NO-OPs");
171: 171 00026168 .data 1
172: 172 00000c0a * L243:
173: 173 00000c0a * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0"
174: F204E4F2D4F507300
175: 174 00000c1f * .text
176: 175 00026168 dd 8f00000c0a pushl $L243
177: 176 0002616E fe 08 ef00000955 callf $8,_print_pipe1_er
178: 177 00026175 # if ( halt_flg ) /* halt on error? */
179: 178 00026175 L241:
180: 179 00026175 5d effffffec1 tstl _halt_flg
181: 180 0002617B 31 0d jeql L244
182: 181 0002617D # pipe1_er_hlt( subtest );
183: 182 0002617D dd effffffeb9 pushl _subtest
184: 183 00026183 fe 08 ef00000a4c callf $8,_pipe1_er_hlt
185: 184 0002618A # if ( loop_on_err ) {
186: 185 0002618A L244:
187: 186 0002618A 5d effffffeac tstl _loop_on_err
188: 187 00026190 31 0a jeql L246
189: 188 00026192 # force_loop = TRUE; /* set the force loop flag */
190: 189 00026192 0d 01 effffffea3 movl $1,_force_loop
191: 190 00026199 # asm("brw _pipe1_1_lp1"); /* and loop */
192: 191 00026199 13 ff8d brw _pipe1_1_lp1
193: 192 0002619C # }
194: 193 0002619C # } /* end of compare error */
195: 194 0002619C L246:
196: 195 0002619C # } while( index++ < max_ldf_1_index );
197: 196 0002619C L240:
198: 197 0002619C L237:
199: 198 0002619C 0d effffffe9a 50 movl _index,r0
200: 199 000261A3 6d effffffe93 incl _index
201: 200 000261A9 1d 50 effffffe8c cmpl r0,_max_ldf_1_index
202: 201 000261B0 81 03 13 ff48 jlss L238
203: 202 000261B5 L236:
204: 203 000261B5 # } /* end of subtest 1 */
205: 204 000261B5 40 ret#2
206: 205 000261B6 .set L232,0x0
207: 206 000261B6 L234:
208: 207 000261B6 13 ff38 jbr L235
209: 208 000261B9 .data
210: 209 00000c00 * .text
211: 210 000261B9 00 .align 1
212: 211 000261BA .globl _pipe1_2
213: 212 000261BA _pipe1_2:
214: 213 000261BA 0000 .word L247
215: 214 000261BC #
216: 215 000261BC #
217: 216 000261BC #
218: 217 000261BC #
219: 218 000261BC #
220: 219 000261BC #
221: 220 000261BC # /************************************************************************
222: 221 000261BC # *
223: 222 000261BC # * SUBTEST 2
224: 223 000261BC # * data in registers, 1 NO-OP
225: 224 000261BC # *
226: 225 000261BC # ************************************************************************/
227: 226 000261BC # pipe1_2()
228: 227 000261BC # {
229: 228 000261BC 13 00ca jbr L249
230: 229 000261BF L250:
231: 230 000261BF # force_loop = FALSE; /* clear force_loop flag */
232: 231 000261BF 4d effffffe77 clrl _force_loop
233: 232 000261C5 # index = 0;
234: 233 000261C5 4d effffffe71 clrl _index
235: 234 000261CB # do
236: 235 000261CB L253:
237: 236 000261CB # {
238: 237 000261CB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
239: 238 000261CB 0d effffffe6b 50 movl _index,r0
240: 239 000261D2 48 03 50 50 shll $3,r0,r0
241: 240 000261D6 0d e000000000 effffffe5b movl _ldf_1_data(r0),_sgl_value_1
242: 241 000261E1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
243: 242 000261E1 0d effffffe55 50 movl _index,r0
244: 243 000261E8 48 03 50 50 shll $3,r0,r0
245: 244 000261EC 0d e000000004 effffffe45 movl _ldf_1_data+4(r0),_sgl_expected
246: 245 000261F7 # /*
247: 246 000261F7 # * If LOOP ON ERROR is set, this is the loop for this subtest.
248: 247 000261F7 # * The force loop flag is set after the first error.
249: 248 000261F7 # */
250: 249 000261F7 # asm("_pipe1_2_lp1:");
251: 250 000261F7 _pipe1_2_lp1:
252: 251 000261F7 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
253: 252 000261F7 0d effffffe3f 54 movl _sgl_value_1,r4
254: 253 000261FE # asm("ldf r4"); /* load the data operand */
255: 254 000261FE 06 54 ldf r4
256: 255 00026200 # asm("nop");
257: 256 00026200 10 nop
258: 257 00026201 # asm("subf r4"); /* subtract the data (2xs) */
259: 258 00026201 d6 54 subf r4
260: 259 00026203 # asm("nop");
261: 260 00026203 10 nop
262: 261 00026204 # asm("subf r4");
263: 262 00026204 d6 54 subf r4
264: 263 00026206 # asm("nop");
265: 264 00026206 10 nop
266: 265 00026207 # asm("addf r4"); /* add it back (2xs) */
267: 266 00026207 c6 54 addf r4
268: 267 00026209 # asm("nop");
269: 268 00026209 10 nop
270: 269 0002620A # asm("addf r4");
271: 270 0002620A c6 54 addf r4
272: 271 0002620C # asm("nop");
273: 272 0002620C 10 nop
274: 273 0002620D # asm("stf r5"); /* store the result */
275: 274 0002620D 26 55 stf r5
276: 275 0002620F # if ( force_loop );
277: 276 0002620F 5d effffffe27 tstl _force_loop
278: 277 00026215 31 00 jeql L254
279: 278 00026217 # asm("brb _pipe1_2_lp1");; /* loop on the error */
280: 279 00026217 L254:
281: 280 00026217 11 de brb _pipe1_2_lp1
282: 281 00026219 # /*
283: 282 00026219 # * verify the results
284: 283 00026219 # */
285: 284 00026219 # asm("movl r5,_sgl_st_acc"); /* get the result */
286: 285 00026219 0d 55 effffffe1c movl r5,_sgl_st_acc
287: 286 00026220 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
288: 287 00026220 1d effffffe16 effffffe11 cmpl _sgl_st_acc,_sgl_expected
289: 288 0002622B 31 42 jeql L255
290: 289 0002622D # {
291: 290 0002622D # errcnt++; /* bump the error count */
292: 291 0002622D 6d effffffe09 incl _errcnt
293: 292 00026233 # if ( prt_error )
294: 293 00026233 5d effffffe03 tstl _prt_error
295: 294 00026239 31 0d jeql L256
296: 295 0002623B # print_pipe1_er("Reg. Data, 1 NO-OP");
297: 296 0002623B .data 1
298: 297 00000c1f * L257:
299: 298 00000c1f * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
300: 04E4F2D4F5000
301: 299 00000c32 * .text
302: 300 0002623B dd 8f00000c1f pushl $L257
303: 301 00026241 fe 08 ef00000882 callf $8,_print_pipe1_er
304: 302 00026248 # if ( halt_flg ) /* halt on error? */
305: 303 00026248 L256:
306: 304 00026248 5d effffffdee tstl _halt_flg
307: 305 0002624E 31 0d jeql L258
308: 306 00026250 # pipe1_er_hlt( subtest );
309: 307 00026250 dd effffffde6 pushl _subtest
310: 308 00026256 fe 08 ef00000979 callf $8,_pipe1_er_hlt
311: 309 0002625D # if ( loop_on_err ) {
312: 310 0002625D L258:
313: 311 0002625D 5d effffffdd9 tstl _loop_on_err
314: 312 00026263 31 0a jeql L259
315: 313 00026265 # force_loop = TRUE; /* set the force loop flag */
316: 314 00026265 0d 01 effffffdd0 movl $1,_force_loop
317: 315 0002626C # asm("brw _pipe1_2_lp1"); /* and loop */
318: 316 0002626C 13 ff88 brw _pipe1_2_lp1
319: 317 0002626F # }
320: 318 0002626F # } /* end of compare error */
321: 319 0002626F L259:
322: 320 0002626F # } while( index++ < max_ldf_1_index );
323: 321 0002626F L255:
324: 322 0002626F L252:
325: 323 0002626F 0d effffffdc7 50 movl _index,r0
326: 324 00026276 6d effffffdc0 incl _index
327: 325 0002627C 1d 50 effffffdb9 cmpl r0,_max_ldf_1_index
328: 326 00026283 81 03 13 ff43 jlss L253
329: 327 00026288 L251:
330: 328 00026288 # } /* end of subtest 2 */
331: 329 00026288 40 ret#2
332: 330 00026289 .set L247,0x0
333: 331 00026289 L249:
334: 332 00026289 13 ff33 jbr L250
335: 333 0002628C .data
336: 334 00000c00 * .text
337: 335 0002628C .align 1
338: 336 0002628C .globl _pipe1_3
339: 337 0002628C _pipe1_3:
340: 338 0002628C 0000 .word L260
341: 339 0002628E #
342: 340 0002628E #
343: 341 0002628E #
344: 342 0002628E #
345: 343 0002628E #
346: 344 0002628E #
347: 345 0002628E # /************************************************************************
348: 346 0002628E # *
349: 347 0002628E # * SUBTEST 3
350: 348 0002628E # * data in registers, 2 NO-OPs
351: 349 0002628E # *
352: 350 0002628E # ************************************************************************/
353: 351 0002628E # pipe1_3()
354: 352 0002628E # {
355: 353 0002628E 13 00cf jbr L262
356: 354 00026291 L263:
357: 355 00026291 # force_loop = FALSE; /* clear force_loop flag */
358: 356 00026291 4d effffffda5 clrl _force_loop
359: 357 00026297 # index = 0;
360: 358 00026297 4d effffffd9f clrl _index
361: 359 0002629D # do
362: 360 0002629D L266:
363: 361 0002629D # {
364: 362 0002629D # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
365: 363 0002629D 0d effffffd99 50 movl _index,r0
366: 364 000262A4 48 03 50 50 shll $3,r0,r0
367: 365 000262A8 0d e000000000 effffffd89 movl _ldf_1_data(r0),_sgl_value_1
368: 366 000262B3 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
369: 367 000262B3 0d effffffd83 50 movl _index,r0
370: 368 000262BA 48 03 50 50 shll $3,r0,r0
371: 369 000262BE 0d e000000004 effffffd73 movl _ldf_1_data+4(r0),_sgl_expected
372: 370 000262C9 # /*
373: 371 000262C9 # * If LOOP ON ERROR is set, this is the loop for this subtest.
374: 372 000262C9 # * The force loop flag is set after the first error.
375: 373 000262C9 # */
376: 374 000262C9 # asm("_pipe1_3_lp1:");
377: 375 000262C9 _pipe1_3_lp1:
378: 376 000262C9 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
379: 377 000262C9 0d effffffd6d 54 movl _sgl_value_1,r4
380: 378 000262D0 # asm("ldf r4"); /* loadthe operand */
381: 379 000262D0 06 54 ldf r4
382: 380 000262D2 # asm("nop");
383: 381 000262D2 10 nop
384: 382 000262D3 # asm("nop");
385: 383 000262D3 10 nop
386: 384 000262D4 # asm("subf r4"); /* subtract the data (2xs) */
387: 385 000262D4 d6 54 subf r4
388: 386 000262D6 # asm("nop");
389: 387 000262D6 10 nop
390: 388 000262D7 # asm("nop");
391: 389 000262D7 10 nop
392: 390 000262D8 # asm("subf r4");
393: 391 000262D8 d6 54 subf r4
394: 392 000262DA # asm("nop");
395: 393 000262DA 10 nop
396: 394 000262DB # asm("nop");
397: 395 000262DB 10 nop
398: 396 000262DC # asm("addf r4"); /* add it back (2xs) */
399: 397 000262DC c6 54 addf r4
400: 398 000262DE # asm("nop");
401: 399 000262DE 10 nop
402: 400 000262DF # asm("nop");
403: 401 000262DF 10 nop
404: 402 000262E0 # asm("addf r4");
405: 403 000262E0 c6 54 addf r4
406: 404 000262E2 # asm("nop");
407: 405 000262E2 10 nop
408: 406 000262E3 # asm("nop");
409: 407 000262E3 10 nop
410: 408 000262E4 # asm("stf r5"); /* store the result */
411: 409 000262E4 26 55 stf r5
412: 410 000262E6 # if ( force_loop );
413: 411 000262E6 5d effffffd50 tstl _force_loop
414: 412 000262EC 31 00 jeql L267
415: 413 000262EE # asm("brb _pipe1_3_lp1");; /* loop on the error */
416: 414 000262EE L267:
417: 415 000262EE 11 d9 brb _pipe1_3_lp1
418: 416 000262F0 # /*
419: 417 000262F0 # * verify the results
420: 418 000262F0 # */
421: 419 000262F0 # asm("movl r5,_sgl_st_acc"); /* get the result */
422: 420 000262F0 0d 55 effffffd45 movl r5,_sgl_st_acc
423: 421 000262F7 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
424: 422 000262F7 1d effffffd3f effffffd3a cmpl _sgl_st_acc,_sgl_expected
425: 423 00026302 31 42 jeql L268
426: 424 00026304 # {
427: 425 00026304 # errcnt++; /* bump the error count */
428: 426 00026304 6d effffffd32 incl _errcnt
429: 427 0002630A # if ( prt_error )
430: 428 0002630A 5d effffffd2c tstl _prt_error
431: 429 00026310 31 0d jeql L269
432: 430 00026312 # print_pipe1_er("Reg. Data, 2 NO-OPs");
433: 431 00026312 .data 1
434: 432 00000c32 * L270:
435: 433 00000c32 * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0"
436: 04E4F2D4F507300
437: 434 00000c46 * .text
438: 435 00026312 dd 8f00000c32 pushl $L270
439: 436 00026318 fe 08 ef000007ab callf $8,_print_pipe1_er
440: 437 0002631F # if ( halt_flg ) /* halt on error? */
441: 438 0002631F L269:
442: 439 0002631F 5d effffffd17 tstl _halt_flg
443: 440 00026325 31 0d jeql L271
444: 441 00026327 # pipe1_er_hlt( subtest );
445: 442 00026327 dd effffffd0f pushl _subtest
446: 443 0002632D fe 08 ef000008a2 callf $8,_pipe1_er_hlt
447: 444 00026334 # if ( loop_on_err ) {
448: 445 00026334 L271:
449: 446 00026334 5d effffffd02 tstl _loop_on_err
450: 447 0002633A 31 0a jeql L272
451: 448 0002633C # force_loop = TRUE; /* set the force loop flag */
452: 449 0002633C 0d 01 effffffcf9 movl $1,_force_loop
453: 450 00026343 # asm("brw _pipe1_3_lp1"); /* and loop */
454: 451 00026343 13 ff83 brw _pipe1_3_lp1
455: 452 00026346 # }
456: 453 00026346 # } /* end of compare error */
457: 454 00026346 L272:
458: 455 00026346 # } while( index++ < max_ldf_1_index );
459: 456 00026346 L268:
460: 457 00026346 L265:
461: 458 00026346 0d effffffcf0 50 movl _index,r0
462: 459 0002634D 6d effffffce9 incl _index
463: 460 00026353 1d 50 effffffce2 cmpl r0,_max_ldf_1_index
464: 461 0002635A 81 03 13 ff3e jlss L266
465: 462 0002635F L264:
466: 463 0002635F # } /* end of subtest 3 */
467: 464 0002635F 40 ret#2
468: 465 00026360 .set L260,0x0
469: 466 00026360 L262:
470: 467 00026360 13 ff2e jbr L263
471: 468 00026363 .data
472: 469 00000c00 * .text
473: 470 00026363 00 .align 1
474: 471 00026364 .globl _pipe1_4
475: 472 00026364 _pipe1_4:
476: 473 00026364 0000 .word L273
477: 474 00026366 #
478: 475 00026366 #
479: 476 00026366 #
480: 477 00026366 #
481: 478 00026366 #
482: 479 00026366 #
483: 480 00026366 # /************************************************************************
484: 481 00026366 # *
485: 482 00026366 # * SUBTEST 4
486: 483 00026366 # * data in registers, 3 NO-OPs
487: 484 00026366 # *
488: 485 00026366 # ************************************************************************/
489: 486 00026366 # pipe1_4()
490: 487 00026366 # {
491: 488 00026366 13 00d4 jbr L275
492: 489 00026369 L276:
493: 490 00026369 # force_loop = FALSE; /* clear force_loop flag */
494: 491 00026369 4d effffffccd clrl _force_loop
495: 492 0002636F # index = 0;
496: 493 0002636F 4d effffffcc7 clrl _index
497: 494 00026375 # do
498: 495 00026375 L279:
499: 496 00026375 # {
500: 497 00026375 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
501: 498 00026375 0d effffffcc1 50 movl _index,r0
502: 499 0002637C 48 03 50 50 shll $3,r0,r0
503: 500 00026380 0d e000000000 effffffcb1 movl _ldf_1_data(r0),_sgl_value_1
504: 501 0002638B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
505: 502 0002638B 0d effffffcab 50 movl _index,r0
506: 503 00026392 48 03 50 50 shll $3,r0,r0
507: 504 00026396 0d e000000004 effffffc9b movl _ldf_1_data+4(r0),_sgl_expected
508: 505 000263A1 # /*
509: 506 000263A1 # * If LOOP ON ERROR is set, this is the loop for this subtest.
510: 507 000263A1 # * The force loop flag is set after the first error.
511: 508 000263A1 # */
512: 509 000263A1 # asm("_pipe1_4_lp1:");
513: 510 000263A1 _pipe1_4_lp1:
514: 511 000263A1 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
515: 512 000263A1 0d effffffc95 54 movl _sgl_value_1,r4
516: 513 000263A8 # asm("ldf r4"); /* load the operand */
517: 514 000263A8 06 54 ldf r4
518: 515 000263AA # asm("nop");
519: 516 000263AA 10 nop
520: 517 000263AB # asm("nop");
521: 518 000263AB 10 nop
522: 519 000263AC # asm("nop");
523: 520 000263AC 10 nop
524: 521 000263AD # asm("subf r4"); /* subtract the data (2xs) */
525: 522 000263AD d6 54 subf r4
526: 523 000263AF # asm("nop");
527: 524 000263AF 10 nop
528: 525 000263B0 # asm("nop");
529: 526 000263B0 10 nop
530: 527 000263B1 # asm("nop");
531: 528 000263B1 10 nop
532: 529 000263B2 # asm("subf r4");
533: 530 000263B2 d6 54 subf r4
534: 531 000263B4 # asm("nop");
535: 532 000263B4 10 nop
536: 533 000263B5 # asm("nop");
537: 534 000263B5 10 nop
538: 535 000263B6 # asm("nop");
539: 536 000263B6 10 nop
540: 537 000263B7 # asm("addf r4"); /* add it back (2xs) */
541: 538 000263B7 c6 54 addf r4
542: 539 000263B9 # asm("nop");
543: 540 000263B9 10 nop
544: 541 000263BA # asm("nop");
545: 542 000263BA 10 nop
546: 543 000263BB # asm("nop");
547: 544 000263BB 10 nop
548: 545 000263BC # asm("addf r4");
549: 546 000263BC c6 54 addf r4
550: 547 000263BE # asm("nop");
551: 548 000263BE 10 nop
552: 549 000263BF # asm("nop");
553: 550 000263BF 10 nop
554: 551 000263C0 # asm("nop");
555: 552 000263C0 10 nop
556: 553 000263C1 # asm("stf r5"); /* store the result */
557: 554 000263C1 26 55 stf r5
558: 555 000263C3 # if ( force_loop );
559: 556 000263C3 5d effffffc73 tstl _force_loop
560: 557 000263C9 31 00 jeql L280
561: 558 000263CB # asm("brb _pipe1_4_lp1");; /* loop on the error */
562: 559 000263CB L280:
563: 560 000263CB 11 d4 brb _pipe1_4_lp1
564: 561 000263CD # /*
565: 562 000263CD # * verify the results
566: 563 000263CD # */
567: 564 000263CD # asm("movl r5,_sgl_st_acc"); /* get the result */
568: 565 000263CD 0d 55 effffffc68 movl r5,_sgl_st_acc
569: 566 000263D4 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
570: 567 000263D4 1d effffffc62 effffffc5d cmpl _sgl_st_acc,_sgl_expected
571: 568 000263DF 31 42 jeql L281
572: 569 000263E1 # {
573: 570 000263E1 # errcnt++; /* bump the error count */
574: 571 000263E1 6d effffffc55 incl _errcnt
575: 572 000263E7 # if ( prt_error )
576: 573 000263E7 5d effffffc4f tstl _prt_error
577: 574 000263ED 31 0d jeql L282
578: 575 000263EF # print_pipe1_er("Reg. Data, 3 NO-OPs");
579: 576 000263EF .data 1
580: 577 00000c46 * L283:
581: 578 00000c46 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0"
582: 04E4F2D4F507300
583: 579 00000c5a * .text
584: 580 000263EF dd 8f00000c46 pushl $L283
585: 581 000263F5 fe 08 ef000006ce callf $8,_print_pipe1_er
586: 582 000263FC # if ( halt_flg ) /* halt on error? */
587: 583 000263FC L282:
588: 584 000263FC 5d effffffc3a tstl _halt_flg
589: 585 00026402 31 0d jeql L284
590: 586 00026404 # pipe1_er_hlt( subtest );
591: 587 00026404 dd effffffc32 pushl _subtest
592: 588 0002640A fe 08 ef000007c5 callf $8,_pipe1_er_hlt
593: 589 00026411 # if ( loop_on_err ) {
594: 590 00026411 L284:
595: 591 00026411 5d effffffc25 tstl _loop_on_err
596: 592 00026417 31 0a jeql L285
597: 593 00026419 # force_loop = TRUE; /* set the force loop flag */
598: 594 00026419 0d 01 effffffc1c movl $1,_force_loop
599: 595 00026420 # asm("brw _pipe1_4_lp1"); /* and loop */
600: 596 00026420 13 ff7e brw _pipe1_4_lp1
601: 597 00026423 # }
602: 598 00026423 # } /* end of compare error */
603: 599 00026423 L285:
604: 600 00026423 # } while( index++ < max_ldf_1_index );
605: 601 00026423 L281:
606: 602 00026423 L278:
607: 603 00026423 0d effffffc13 50 movl _index,r0
608: 604 0002642A 6d effffffc0c incl _index
609: 605 00026430 1d 50 effffffc05 cmpl r0,_max_ldf_1_index
610: 606 00026437 81 03 13 ff39 jlss L279
611: 607 0002643C L277:
612: 608 0002643C # } /* end of subtest 4 */
613: 609 0002643C 40 ret#2
614: 610 0002643D .set L273,0x0
615: 611 0002643D L275:
616: 612 0002643D 13 ff29 jbr L276
617: 613 00026440 .data
618: 614 00000c00 * .text
619: 615 00026440 .align 1
620: 616 00026440 .globl _pipe1_5
621: 617 00026440 _pipe1_5:
622: 618 00026440 0000 .word L286
623: 619 00026442 #
624: 620 00026442 #
625: 621 00026442 #
626: 622 00026442 #
627: 623 00026442 #
628: 624 00026442 #
629: 625 00026442 #
630: 626 00026442 # /************************************************************************
631: 627 00026442 # *
632: 628 00026442 # * SUBTEST 5
633: 629 00026442 # * data in Cache, no NO-OPs
634: 630 00026442 # *
635: 631 00026442 # ************************************************************************/
636: 632 00026442 # pipe1_5()
637: 633 00026442 # {
638: 634 00026442 13 00cf jbr L288
639: 635 00026445 L289:
640: 636 00026445 # force_loop = FALSE; /* clear force_loop flag */
641: 637 00026445 4d effffffbf1 clrl _force_loop
642: 638 0002644B # index = 0;
643: 639 0002644B 4d effffffbeb clrl _index
644: 640 00026451 # do
645: 641 00026451 L292:
646: 642 00026451 # {
647: 643 00026451 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
648: 644 00026451 0d effffffbe5 50 movl _index,r0
649: 645 00026458 48 03 50 50 shll $3,r0,r0
650: 646 0002645C 0d e000000000 effffffbd5 movl _ldf_1_data(r0),_sgl_value_1
651: 647 00026467 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
652: 648 00026467 0d effffffbcf 50 movl _index,r0
653: 649 0002646E 48 03 50 50 shll $3,r0,r0
654: 650 00026472 0d e000000004 effffffbbf movl _ldf_1_data+4(r0),_sgl_expected
655: 651 0002647D # /*
656: 652 0002647D # * If LOOP ON ERROR is set, this is the loop for this subtest.
657: 653 0002647D # * The force loop flag is set after the first error.
658: 654 0002647D # */
659: 655 0002647D # asm("_pipe1_5_lp1:");
660: 656 0002647D _pipe1_5_lp1:
661: 657 0002647D # asm("ldf _sgl_value_1"); /* load the operand */
662: 658 0002647D 06 effffffbb9 ldf _sgl_value_1
663: 659 00026483 # asm("subf _sgl_value_1"); /* subtract it (twice) */
664: 660 00026483 d6 effffffbb3 subf _sgl_value_1
665: 661 00026489 # asm("subf _sgl_value_1");
666: 662 00026489 d6 effffffbad subf _sgl_value_1
667: 663 0002648F # asm("addf _sgl_value_1"); /* add it back (twice) */
668: 664 0002648F c6 effffffba7 addf _sgl_value_1
669: 665 00026495 # asm("addf _sgl_value_1");
670: 666 00026495 c6 effffffba1 addf _sgl_value_1
671: 667 0002649B # asm("stf _sgl_st_acc"); /* store the result */
672: 668 0002649B 26 effffffb9b stf _sgl_st_acc
673: 669 000264A1 # if ( force_loop );
674: 670 000264A1 5d effffffb95 tstl _force_loop
675: 671 000264A7 31 00 jeql L293
676: 672 000264A9 # asm("brb _pipe1_5_lp1");; /* loop on the error */
677: 673 000264A9 L293:
678: 674 000264A9 11 d2 brb _pipe1_5_lp1
679: 675 000264AB # /*
680: 676 000264AB # * verify the results
681: 677 000264AB # */
682: 678 000264AB # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
683: 679 000264AB 1d effffffb8b effffffb86 cmpl _sgl_st_acc,_sgl_expected
684: 680 000264B6 31 42 jeql L294
685: 681 000264B8 # {
686: 682 000264B8 # errcnt++; /* bump the error count */
687: 683 000264B8 6d effffffb7e incl _errcnt
688: 684 000264BE # if ( prt_error )
689: 685 000264BE 5d effffffb78 tstl _prt_error
690: 686 000264C4 31 0d jeql L295
691: 687 000264C6 # print_pipe1_er("Cache Data, no NO-OPs");
692: 688 000264C6 .data 1
693: 689 00000c5a * L296:
694: 690 00000c5a * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0"
695: E6F204E4F2D4F507300
696: 691 00000c70 * .text
697: 692 000264C6 dd 8f00000c5a pushl $L296
698: 693 000264CC fe 08 ef000005f7 callf $8,_print_pipe1_er
699: 694 000264D3 # if ( halt_flg ) /* halt on error? */
700: 695 000264D3 L295:
701: 696 000264D3 5d effffffb63 tstl _halt_flg
702: 697 000264D9 31 0d jeql L297
703: 698 000264DB # pipe1_er_hlt( subtest );
704: 699 000264DB dd effffffb5b pushl _subtest
705: 700 000264E1 fe 08 ef000006ee callf $8,_pipe1_er_hlt
706: 701 000264E8 # if ( loop_on_err ) {
707: 702 000264E8 L297:
708: 703 000264E8 5d effffffb4e tstl _loop_on_err
709: 704 000264EE 31 0a jeql L298
710: 705 000264F0 # force_loop = TRUE; /* set the force loop flag */
711: 706 000264F0 0d 01 effffffb45 movl $1,_force_loop
712: 707 000264F7 # asm("brw _pipe1_5_lp1"); /* and loop */
713: 708 000264F7 13 ff83 brw _pipe1_5_lp1
714: 709 000264FA # }
715: 710 000264FA # } /* end of compare error */
716: 711 000264FA L298:
717: 712 000264FA # } while( index++ < max_ldf_1_index );
718: 713 000264FA L294:
719: 714 000264FA L291:
720: 715 000264FA 0d effffffb3c 50 movl _index,r0
721: 716 00026501 6d effffffb35 incl _index
722: 717 00026507 1d 50 effffffb2e cmpl r0,_max_ldf_1_index
723: 718 0002650E 81 03 13 ff3e jlss L292
724: 719 00026513 L290:
725: 720 00026513 # } /* end of subtest 5 */
726: 721 00026513 40 ret#2
727: 722 00026514 .set L286,0x0
728: 723 00026514 L288:
729: 724 00026514 13 ff2e jbr L289
730: 725 00026517 .data
731: 726 00000c00 * .text
732: 727 00026517 00 .align 1
733: 728 00026518 .globl _pipe1_6
734: 729 00026518 _pipe1_6:
735: 730 00026518 0000 .word L299
736: 731 0002651A #
737: 732 0002651A #
738: 733 0002651A #
739: 734 0002651A #
740: 735 0002651A #
741: 736 0002651A #
742: 737 0002651A # /************************************************************************
743: 738 0002651A # *
744: 739 0002651A # * SUBTEST 6
745: 740 0002651A # * data in Cache, 1 NO-OP
746: 741 0002651A # *
747: 742 0002651A # ************************************************************************/
748: 743 0002651A # pipe1_6()
749: 744 0002651A # {
750: 745 0002651A 13 00d4 jbr L301
751: 746 0002651D L302:
752: 747 0002651D # force_loop = FALSE; /* clear force_loop flag */
753: 748 0002651D 4d effffffb19 clrl _force_loop
754: 749 00026523 # index = 0;
755: 750 00026523 4d effffffb13 clrl _index
756: 751 00026529 # do
757: 752 00026529 L305:
758: 753 00026529 # {
759: 754 00026529 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
760: 755 00026529 0d effffffb0d 50 movl _index,r0
761: 756 00026530 48 03 50 50 shll $3,r0,r0
762: 757 00026534 0d e000000000 effffffafd movl _ldf_1_data(r0),_sgl_value_1
763: 758 0002653F # sgl_expected = ldf_1_data[index].exp; /* get expected results */
764: 759 0002653F 0d effffffaf7 50 movl _index,r0
765: 760 00026546 48 03 50 50 shll $3,r0,r0
766: 761 0002654A 0d e000000004 effffffae7 movl _ldf_1_data+4(r0),_sgl_expected
767: 762 00026555 # /*
768: 763 00026555 # * If LOOP ON ERROR is set, this is the loop for this subtest.
769: 764 00026555 # * The force loop flag is set after the first error.
770: 765 00026555 # */
771: 766 00026555 # asm("_pipe1_6_lp1:");
772: 767 00026555 _pipe1_6_lp1:
773: 768 00026555 # asm("ldf _sgl_value_1"); /* load the operand */
774: 769 00026555 06 effffffae1 ldf _sgl_value_1
775: 770 0002655B # asm("nop");
776: 771 0002655B 10 nop
777: 772 0002655C # asm("subf _sgl_value_1"); /* subtract it (twice) */
778: 773 0002655C d6 effffffada subf _sgl_value_1
779: 774 00026562 # asm("nop");
780: 775 00026562 10 nop
781: 776 00026563 # asm("subf _sgl_value_1");
782: 777 00026563 d6 effffffad3 subf _sgl_value_1
783: 778 00026569 # asm("nop");
784: 779 00026569 10 nop
785: 780 0002656A # asm("addf _sgl_value_1"); /* add it back (twice) */
786: 781 0002656A c6 effffffacc addf _sgl_value_1
787: 782 00026570 # asm("nop");
788: 783 00026570 10 nop
789: 784 00026571 # asm("addf _sgl_value_1");
790: 785 00026571 c6 effffffac5 addf _sgl_value_1
791: 786 00026577 # asm("nop");
792: 787 00026577 10 nop
793: 788 00026578 # asm("stf _sgl_st_acc"); /* store the result */
794: 789 00026578 26 effffffabe stf _sgl_st_acc
795: 790 0002657E # if ( force_loop );
796: 791 0002657E 5d effffffab8 tstl _force_loop
797: 792 00026584 31 00 jeql L306
798: 793 00026586 # asm("brb _pipe1_6_lp1");; /* loop on the error */
799: 794 00026586 L306:
800: 795 00026586 11 cd brb _pipe1_6_lp1
801: 796 00026588 # /*
802: 797 00026588 # * verify the results
803: 798 00026588 # */
804: 799 00026588 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
805: 800 00026588 1d effffffaae effffffaa9 cmpl _sgl_st_acc,_sgl_expected
806: 801 00026593 31 42 jeql L307
807: 802 00026595 # {
808: 803 00026595 # errcnt++; /* bump the error count */
809: 804 00026595 6d effffffaa1 incl _errcnt
810: 805 0002659B # if ( prt_error )
811: 806 0002659B 5d effffffa9b tstl _prt_error
812: 807 000265A1 31 0d jeql L308
813: 808 000265A3 # print_pipe1_er("Cache Data, 1 NO-OP");
814: 809 000265A3 .data 1
815: 810 00000c70 * L309:
816: 811 00000c70 * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
817: 1204E4F2D4F5000
818: 812 00000c84 * .text
819: 813 000265A3 dd 8f00000c70 pushl $L309
820: 814 000265A9 fe 08 ef0000051a callf $8,_print_pipe1_er
821: 815 000265B0 # if ( halt_flg ) /* halt on error? */
822: 816 000265B0 L308:
823: 817 000265B0 5d effffffa86 tstl _halt_flg
824: 818 000265B6 31 0d jeql L310
825: 819 000265B8 # pipe1_er_hlt( subtest );
826: 820 000265B8 dd effffffa7e pushl _subtest
827: 821 000265BE fe 08 ef00000611 callf $8,_pipe1_er_hlt
828: 822 000265C5 # if ( loop_on_err ) {
829: 823 000265C5 L310:
830: 824 000265C5 5d effffffa71 tstl _loop_on_err
831: 825 000265CB 31 0a jeql L311
832: 826 000265CD # force_loop = TRUE; /* set the force loop flag */
833: 827 000265CD 0d 01 effffffa68 movl $1,_force_loop
834: 828 000265D4 # asm("brw _pipe1_6_lp1"); /* and loop */
835: 829 000265D4 13 ff7e brw _pipe1_6_lp1
836: 830 000265D7 # }
837: 831 000265D7 # } /* end of compare error */
838: 832 000265D7 L311:
839: 833 000265D7 # } while( index++ < max_ldf_1_index );
840: 834 000265D7 L307:
841: 835 000265D7 L304:
842: 836 000265D7 0d effffffa5f 50 movl _index,r0
843: 837 000265DE 6d effffffa58 incl _index
844: 838 000265E4 1d 50 effffffa51 cmpl r0,_max_ldf_1_index
845: 839 000265EB 81 03 13 ff39 jlss L305
846: 840 000265F0 L303:
847: 841 000265F0 # } /* end of subtest 6 */
848: 842 000265F0 40 ret#2
849: 843 000265F1 .set L299,0x0
850: 844 000265F1 L301:
851: 845 000265F1 13 ff29 jbr L302
852: 846 000265F4 .data
853: 847 00000c00 * .text
854: 848 000265F4 .align 1
855: 849 000265F4 .globl _pipe1_7
856: 850 000265F4 _pipe1_7:
857: 851 000265F4 0000 .word L312
858: 852 000265F6 #
859: 853 000265F6 #
860: 854 000265F6 #
861: 855 000265F6 #
862: 856 000265F6 #
863: 857 000265F6 #
864: 858 000265F6 # /************************************************************************
865: 859 000265F6 # *
866: 860 000265F6 # * SUBTEST 7
867: 861 000265F6 # * data in Cache, 2 NO-OPs
868: 862 000265F6 # *
869: 863 000265F6 # ************************************************************************/
870: 864 000265F6 # pipe1_7()
871: 865 000265F6 # {
872: 866 000265F6 13 00d9 jbr L314
873: 867 000265F9 L315:
874: 868 000265F9 # force_loop = FALSE; /* clear force_loop flag */
875: 869 000265F9 4d effffffa3d clrl _force_loop
876: 870 000265FF # index = 0;
877: 871 000265FF 4d effffffa37 clrl _index
878: 872 00026605 # do
879: 873 00026605 L318:
880: 874 00026605 # {
881: 875 00026605 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
882: 876 00026605 0d effffffa31 50 movl _index,r0
883: 877 0002660C 48 03 50 50 shll $3,r0,r0
884: 878 00026610 0d e000000000 effffffa21 movl _ldf_1_data(r0),_sgl_value_1
885: 879 0002661B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
886: 880 0002661B 0d effffffa1b 50 movl _index,r0
887: 881 00026622 48 03 50 50 shll $3,r0,r0
888: 882 00026626 0d e000000004 effffffa0b movl _ldf_1_data+4(r0),_sgl_expected
889: 883 00026631 # /*
890: 884 00026631 # * If LOOP ON ERROR is set, this is the loop for this subtest.
891: 885 00026631 # * The force loop flag is set after the first error.
892: 886 00026631 # */
893: 887 00026631 # asm("_pipe1_7_lp1:");
894: 888 00026631 _pipe1_7_lp1:
895: 889 00026631 # asm("ldf _sgl_value_1"); /* load the operand */
896: 890 00026631 06 effffffa05 ldf _sgl_value_1
897: 891 00026637 # asm("nop");
898: 892 00026637 10 nop
899: 893 00026638 # asm("nop");
900: 894 00026638 10 nop
901: 895 00026639 # asm("subf _sgl_value_1"); /* subtract it (twice) */
902: 896 00026639 d6 effffff9fd subf _sgl_value_1
903: 897 0002663F # asm("nop");
904: 898 0002663F 10 nop
905: 899 00026640 # asm("nop");
906: 900 00026640 10 nop
907: 901 00026641 # asm("subf _sgl_value_1");
908: 902 00026641 d6 effffff9f5 subf _sgl_value_1
909: 903 00026647 # asm("nop");
910: 904 00026647 10 nop
911: 905 00026648 # asm("nop");
912: 906 00026648 10 nop
913: 907 00026649 # asm("addf _sgl_value_1"); /* add it back (twice) */
914: 908 00026649 c6 effffff9ed addf _sgl_value_1
915: 909 0002664F # asm("nop");
916: 910 0002664F 10 nop
917: 911 00026650 # asm("nop");
918: 912 00026650 10 nop
919: 913 00026651 # asm("addf _sgl_value_1");
920: 914 00026651 c6 effffff9e5 addf _sgl_value_1
921: 915 00026657 # asm("nop");
922: 916 00026657 10 nop
923: 917 00026658 # asm("nop");
924: 918 00026658 10 nop
925: 919 00026659 # asm("stf _sgl_st_acc"); /* store the result */
926: 920 00026659 26 effffff9dd stf _sgl_st_acc
927: 921 0002665F # if ( force_loop );
928: 922 0002665F 5d effffff9d7 tstl _force_loop
929: 923 00026665 31 00 jeql L319
930: 924 00026667 # asm("brb _pipe1_7_lp1");; /* loop on the error */
931: 925 00026667 L319:
932: 926 00026667 11 c8 brb _pipe1_7_lp1
933: 927 00026669 # /*
934: 928 00026669 # * verify the results
935: 929 00026669 # */
936: 930 00026669 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
937: 931 00026669 1d effffff9cd effffff9c8 cmpl _sgl_st_acc,_sgl_expected
938: 932 00026674 31 42 jeql L320
939: 933 00026676 # {
940: 934 00026676 # errcnt++; /* bump the error count */
941: 935 00026676 6d effffff9c0 incl _errcnt
942: 936 0002667C # if ( prt_error )
943: 937 0002667C 5d effffff9ba tstl _prt_error
944: 938 00026682 31 0d jeql L321
945: 939 00026684 # print_pipe1_er("Cache Data, 2 NO-OPs");
946: 940 00026684 .data 1
947: 941 00000c84 * L322:
948: 942 00000c84 * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0"
949: 2204E4F2D4F507300
950: 943 00000c99 * .text
951: 944 00026684 dd 8f00000c84 pushl $L322
952: 945 0002668A fe 08 ef00000439 callf $8,_print_pipe1_er
953: 946 00026691 # if ( halt_flg ) /* halt on error? */
954: 947 00026691 L321:
955: 948 00026691 5d effffff9a5 tstl _halt_flg
956: 949 00026697 31 0d jeql L323
957: 950 00026699 # pipe1_er_hlt( subtest );
958: 951 00026699 dd effffff99d pushl _subtest
959: 952 0002669F fe 08 ef00000530 callf $8,_pipe1_er_hlt
960: 953 000266A6 # if ( loop_on_err ) {
961: 954 000266A6 L323:
962: 955 000266A6 5d effffff990 tstl _loop_on_err
963: 956 000266AC 31 0a jeql L324
964: 957 000266AE # force_loop = TRUE; /* set the force loop flag */
965: 958 000266AE 0d 01 effffff987 movl $1,_force_loop
966: 959 000266B5 # asm("brw _pipe1_7_lp1"); /* and loop */
967: 960 000266B5 13 ff79 brw _pipe1_7_lp1
968: 961 000266B8 # }
969: 962 000266B8 # } /* end of compare error */
970: 963 000266B8 L324:
971: 964 000266B8 # } while( index++ < max_ldf_1_index );
972: 965 000266B8 L320:
973: 966 000266B8 L317:
974: 967 000266B8 0d effffff97e 50 movl _index,r0
975: 968 000266BF 6d effffff977 incl _index
976: 969 000266C5 1d 50 effffff970 cmpl r0,_max_ldf_1_index
977: 970 000266CC 81 03 13 ff34 jlss L318
978: 971 000266D1 L316:
979: 972 000266D1 # } /* end of subtest 7 */
980: 973 000266D1 40 ret#2
981: 974 000266D2 .set L312,0x0
982: 975 000266D2 L314:
983: 976 000266D2 13 ff24 jbr L315
984: 977 000266D5 .data
985: 978 00000c00 * .text
986: 979 000266D5 00 .align 1
987: 980 000266D6 .globl _pipe1_8
988: 981 000266D6 _pipe1_8:
989: 982 000266D6 0000 .word L325
990: 983 000266D8 #
991: 984 000266D8 #
992: 985 000266D8 #
993: 986 000266D8 #
994: 987 000266D8 #
995: 988 000266D8 #
996: 989 000266D8 # /************************************************************************
997: 990 000266D8 # *
998: 991 000266D8 # * SUBTEST 8
999: 992 000266D8 # * data in Cache, 3 NO-OPs
1000: 993 000266D8 # *
1001: 994 000266D8 # ************************************************************************/
1002: 995 000266D8 # pipe1_8()
1003: 996 000266D8 # {
1004: 997 000266D8 13 00de jbr L327
1005: 998 000266DB L328:
1006: 999 000266DB # force_loop = FALSE; /* clear force_loop flag */
1007: 1000 000266DB 4d effffff95b clrl _force_loop
1008: 1001 000266E1 # index = 0;
1009: 1002 000266E1 4d effffff955 clrl _index
1010: 1003 000266E7 # do
1011: 1004 000266E7 L331:
1012: 1005 000266E7 # {
1013: 1006 000266E7 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1014: 1007 000266E7 0d effffff94f 50 movl _index,r0
1015: 1008 000266EE 48 03 50 50 shll $3,r0,r0
1016: 1009 000266F2 0d e000000000 effffff93f movl _ldf_1_data(r0),_sgl_value_1
1017: 1010 000266FD # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1018: 1011 000266FD 0d effffff939 50 movl _index,r0
1019: 1012 00026704 48 03 50 50 shll $3,r0,r0
1020: 1013 00026708 0d e000000004 effffff929 movl _ldf_1_data+4(r0),_sgl_expected
1021: 1014 00026713 # /*
1022: 1015 00026713 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1023: 1016 00026713 # * The force loop flag is set after the first error.
1024: 1017 00026713 # */
1025: 1018 00026713 # asm("_pipe1_8_lp1:");
1026: 1019 00026713 _pipe1_8_lp1:
1027: 1020 00026713 # asm("ldf _sgl_value_1"); /* load the operand */
1028: 1021 00026713 06 effffff923 ldf _sgl_value_1
1029: 1022 00026719 # asm("nop");
1030: 1023 00026719 10 nop
1031: 1024 0002671A # asm("nop");
1032: 1025 0002671A 10 nop
1033: 1026 0002671B # asm("nop");
1034: 1027 0002671B 10 nop
1035: 1028 0002671C # asm("subf _sgl_value_1"); /* subtract it (twice) */
1036: 1029 0002671C d6 effffff91a subf _sgl_value_1
1037: 1030 00026722 # asm("nop");
1038: 1031 00026722 10 nop
1039: 1032 00026723 # asm("nop");
1040: 1033 00026723 10 nop
1041: 1034 00026724 # asm("nop");
1042: 1035 00026724 10 nop
1043: 1036 00026725 # asm("subf _sgl_value_1");
1044: 1037 00026725 d6 effffff911 subf _sgl_value_1
1045: 1038 0002672B # asm("nop");
1046: 1039 0002672B 10 nop
1047: 1040 0002672C # asm("nop");
1048: 1041 0002672C 10 nop
1049: 1042 0002672D # asm("nop");
1050: 1043 0002672D 10 nop
1051: 1044 0002672E # asm("addf _sgl_value_1"); /* add it back (twice) */
1052: 1045 0002672E c6 effffff908 addf _sgl_value_1
1053: 1046 00026734 # asm("nop");
1054: 1047 00026734 10 nop
1055: 1048 00026735 # asm("nop");
1056: 1049 00026735 10 nop
1057: 1050 00026736 # asm("nop");
1058: 1051 00026736 10 nop
1059: 1052 00026737 # asm("addf _sgl_value_1");
1060: 1053 00026737 c6 effffff8ff addf _sgl_value_1
1061: 1054 0002673D # asm("nop");
1062: 1055 0002673D 10 nop
1063: 1056 0002673E # asm("nop");
1064: 1057 0002673E 10 nop
1065: 1058 0002673F # asm("nop");
1066: 1059 0002673F 10 nop
1067: 1060 00026740 # asm("stf _sgl_st_acc"); /* store the result */
1068: 1061 00026740 26 effffff8f6 stf _sgl_st_acc
1069: 1062 00026746 # if ( force_loop );
1070: 1063 00026746 5d effffff8f0 tstl _force_loop
1071: 1064 0002674C 31 00 jeql L332
1072: 1065 0002674E # asm("brb _pipe1_8_lp1");; /* loop on the error */
1073: 1066 0002674E L332:
1074: 1067 0002674E 11 c3 brb _pipe1_8_lp1
1075: 1068 00026750 # /*
1076: 1069 00026750 # * verify the results
1077: 1070 00026750 # */
1078: 1071 00026750 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
1079: 1072 00026750 1d effffff8e6 effffff8e1 cmpl _sgl_st_acc,_sgl_expected
1080: 1073 0002675B 31 42 jeql L333
1081: 1074 0002675D # {
1082: 1075 0002675D # errcnt++; /* bump the error count */
1083: 1076 0002675D 6d effffff8d9 incl _errcnt
1084: 1077 00026763 # if ( prt_error )
1085: 1078 00026763 5d effffff8d3 tstl _prt_error
1086: 1079 00026769 31 0d jeql L334
1087: 1080 0002676B # print_pipe1_er("Cache Data, 3 NO-OPs");
1088: 1081 0002676B .data 1
1089: 1082 00000c99 * L335:
1090: 1083 00000c99 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0"
1091: 3204E4F2D4F507300
1092: 1084 00000cae * .text
1093: 1085 0002676B dd 8f00000c99 pushl $L335
1094: 1086 00026771 fe 08 ef00000352 callf $8,_print_pipe1_er
1095: 1087 00026778 # if ( halt_flg ) /* halt on error? */
1096: 1088 00026778 L334:
1097: 1089 00026778 5d effffff8be tstl _halt_flg
1098: 1090 0002677E 31 0d jeql L336
1099: 1091 00026780 # pipe1_er_hlt( subtest );
1100: 1092 00026780 dd effffff8b6 pushl _subtest
1101: 1093 00026786 fe 08 ef00000449 callf $8,_pipe1_er_hlt
1102: 1094 0002678D # if ( loop_on_err ) {
1103: 1095 0002678D L336:
1104: 1096 0002678D 5d effffff8a9 tstl _loop_on_err
1105: 1097 00026793 31 0a jeql L337
1106: 1098 00026795 # force_loop = TRUE; /* set the force loop flag */
1107: 1099 00026795 0d 01 effffff8a0 movl $1,_force_loop
1108: 1100 0002679C # asm("brw _pipe1_8_lp1"); /* and loop */
1109: 1101 0002679C 13 ff74 brw _pipe1_8_lp1
1110: 1102 0002679F # }
1111: 1103 0002679F # } /* end of compare error */
1112: 1104 0002679F L337:
1113: 1105 0002679F # } while( index++ < max_ldf_1_index );
1114: 1106 0002679F L333:
1115: 1107 0002679F L330:
1116: 1108 0002679F 0d effffff897 50 movl _index,r0
1117: 1109 000267A6 6d effffff890 incl _index
1118: 1110 000267AC 1d 50 effffff889 cmpl r0,_max_ldf_1_index
1119: 1111 000267B3 81 03 13 ff2f jlss L331
1120: 1112 000267B8 L329:
1121: 1113 000267B8 # } /* end of subtest 8 */
1122: 1114 000267B8 40 ret#2
1123: 1115 000267B9 .set L325,0x0
1124: 1116 000267B9 L327:
1125: 1117 000267B9 13 ff1f jbr L328
1126: 1118 000267BC .data
1127: 1119 00000c00 * .text
1128: 1120 000267BC .align 1
1129: 1121 000267BC .globl _pipe1_9
1130: 1122 000267BC _pipe1_9:
1131: 1123 000267BC 0000 .word L338
1132: 1124 000267BE #
1133: 1125 000267BE #
1134: 1126 000267BE #
1135: 1127 000267BE #
1136: 1128 000267BE #
1137: 1129 000267BE #
1138: 1130 000267BE # /*****************************************************************************
1139: 1131 000267BE # *
1140: 1132 000267BE # * SUBTEST 9
1141: 1133 000267BE # * data on the stack, no NO-OPs
1142: 1134 000267BE # *
1143: 1135 000267BE # *****************************************************************************/
1144: 1136 000267BE # pipe1_9()
1145: 1137 000267BE # {
1146: 1138 000267BE 13 0175 jbr L340
1147: 1139 000267C1 L341:
1148: 1140 000267C1 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1149: 1141 000267C1 ed 6d effffff874 moval (r13),_pre_event_fp
1150: 1142 000267C8 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1151: 1143 000267C8 ed 6e effffff86d moval (r14),_pre_event_sp
1152: 1144 000267CF # force_loop = FALSE; /* clear force_loop flag */
1153: 1145 000267CF 4d effffff867 clrl _force_loop
1154: 1146 000267D5 # index = 0;
1155: 1147 000267D5 4d effffff861 clrl _index
1156: 1148 000267DB # do
1157: 1149 000267DB L344:
1158: 1150 000267DB # {
1159: 1151 000267DB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1160: 1152 000267DB 0d effffff85b 50 movl _index,r0
1161: 1153 000267E2 48 03 50 50 shll $3,r0,r0
1162: 1154 000267E6 0d e000000000 effffff84b movl _ldf_1_data(r0),_sgl_value_1
1163: 1155 000267F1 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1164: 1156 000267F1 0d effffff845 50 movl _index,r0
1165: 1157 000267F8 48 03 50 50 shll $3,r0,r0
1166: 1158 000267FC 0d e000000004 effffff835 movl _ldf_1_data+4(r0),_sgl_expected
1167: 1159 00026807 # asm("moval _pointer_data,_sgl_value_2");/* init / final SP value */
1168: 1160 00026807 ed effffff82f effffff82a moval _pointer_data,_sgl_value_2
1169: 1161 00026812 # /*
1170: 1162 00026812 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1171: 1163 00026812 # * The force loop flag is set after the first error.
1172: 1164 00026812 # */
1173: 1165 00026812 # asm("_pipe1_9_lp1:");
1174: 1166 00026812 _pipe1_9_lp1:
1175: 1167 00026812 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1176: 1168 00026812 ed effffff824 5e moval _pointer_data,r14
1177: 1169 00026819 # asm("movl _sgl_value_1,-(r14)"); /* push the operand 5 times */
1178: 1170 00026819 0d effffff81d 7e movl _sgl_value_1,-(r14)
1179: 1171 00026820 # asm("movl _sgl_value_1,-(r14)");
1180: 1172 00026820 0d effffff816 7e movl _sgl_value_1,-(r14)
1181: 1173 00026827 # asm("movl _sgl_value_1,-(r14)");
1182: 1174 00026827 0d effffff80f 7e movl _sgl_value_1,-(r14)
1183: 1175 0002682E # asm("movl _sgl_value_1,-(r14)");
1184: 1176 0002682E 0d effffff808 7e movl _sgl_value_1,-(r14)
1185: 1177 00026835 # asm("movl _sgl_value_1,-(r14)");
1186: 1178 00026835 0d effffff801 7e movl _sgl_value_1,-(r14)
1187: 1179 0002683C # /*
1188: 1180 0002683C # * now pop the data off the stack
1189: 1181 0002683C # */
1190: 1182 0002683C # asm("ldf (r14)+"); /* pop the data & load it */
1191: 1183 0002683C 06 8e ldf (r14)+
1192: 1184 0002683E # asm("subf (r14)+"); /* subtract it (twice) */
1193: 1185 0002683E d6 8e subf (r14)+
1194: 1186 00026840 # asm("subf (r14)+");
1195: 1187 00026840 d6 8e subf (r14)+
1196: 1188 00026842 # asm("addf (r14)+"); /* add it back (twice) */
1197: 1189 00026842 c6 8e addf (r14)+
1198: 1190 00026844 # asm("addf (r14)+");
1199: 1191 00026844 c6 8e addf (r14)+
1200: 1192 00026846 # asm("stf r5"); /* store the result */
1201: 1193 00026846 26 55 stf r5
1202: 1194 00026848 # if ( force_loop );
1203: 1195 00026848 5d effffff7ee tstl _force_loop
1204: 1196 0002684E 31 00 jeql L345
1205: 1197 00026850 # asm("brb _pipe1_9_lp1");; /* loop on the error */
1206: 1198 00026850 L345:
1207: 1199 00026850 11 c0 brb _pipe1_9_lp1
1208: 1200 00026852 # /*
1209: 1201 00026852 # * verify the results
1210: 1202 00026852 # */
1211: 1203 00026852 # asm("movl r5,_sgl_st_acc"); /* get the result */
1212: 1204 00026852 0d 55 effffff7e3 movl r5,_sgl_st_acc
1213: 1205 00026859 # asm("moval (r14),_sgl_value_3"); /* save the stack pointer */
1214: 1206 00026859 ed 6e effffff7dc moval (r14),_sgl_value_3
1215: 1207 00026860 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1216: 1208 00026860 # (sgl_value_3 != sgl_value_2) ) /* ... and the final SP */
1217: 1209 00026860 1d effffff7d6 effffff7d1 cmpl _sgl_st_acc,_sgl_expected
1218: 1210 0002686B 21 10 jneq L9999
1219: 1211 0002686D 1d effffff7c9 effffff7c4 cmpl _sgl_value_3,_sgl_value_2
1220: 1212 00026878 21 03 13 0091 jeql L346
1221: 1213 0002687D L9999:
1222: 1214 0002687D # {
1223: 1215 0002687D # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1224: 1216 0002687D 0d effffff7b9 5d movl _pre_event_fp,r13
1225: 1217 00026884 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1226: 1218 00026884 0d effffff7b2 5e movl _pre_event_sp,r14
1227: 1219 0002688B # errcnt++; /* bump the error count */
1228: 1220 0002688B 6d effffff7ab incl _errcnt
1229: 1221 00026891 # if ( prt_error ) {
1230: 1222 00026891 5d effffff7a5 tstl _prt_error
1231: 1223 00026897 31 4e jeql L347
1232: 1224 00026899 # print_pipe1_er("POP data from the SP");
1233: 1225 00026899 .data 1
1234: 1226 00000cae * L348:
1235: 1227 00000cae * 504F5020646174612066726F6 .ascii "POP data from the SP\0"
1236: D2074686520535000
1237: 1228 00000cc3 * .text
1238: 1229 00026899 dd 8f00000cae pushl $L348
1239: 1230 0002689F fe 08 ef00000224 callf $8,_print_pipe1_er
1240: 1231 000268A6 # writes("final Stack Pointer = ");
1241: 1232 000268A6 .data 1
1242: 1233 00000cc3 * L349:
1243: 1234 00000cc3 * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
1244: 06F696E746572203D2000
1245: 1235 00000cda * .text
1246: 1236 000268A6 dd 8f00000cc3 pushl $L349
1247: 1237 000268AC fe 08 effffff789 callf $8,_writes
1248: 1238 000268B3 # write32h( sgl_value_3 );
1249: 1239 000268B3 dd effffff783 pushl _sgl_value_3
1250: 1240 000268B9 fe 08 effffff77c callf $8,_write32h
1251: 1241 000268C0 # writes(", expected SP = ");
1252: 1242 000268C0 .data 1
1253: 1243 00000cda * L351:
1254: 1244 00000cda * 2C20206578706563746564205 .ascii ", expected SP = \0"
1255: 350203D2000
1256: 1245 00000cec * .text
1257: 1246 000268C0 dd 8f00000cda pushl $L351
1258: 1247 000268C6 fe 08 effffff76f callf $8,_writes
1259: 1248 000268CD # write32h( sgl_value_2 );
1260: 1249 000268CD dd effffff769 pushl _sgl_value_2
1261: 1250 000268D3 fe 08 effffff762 callf $8,_write32h
1262: 1251 000268DA # writes(" \n");
1263: 1252 000268DA .data 1
1264: 1253 00000cec * L352:
1265: 1254 00000cec * 200A00 .ascii " \12\0"
1266: 1255 00000cef * .text
1267: 1256 000268DA dd 8f00000cec pushl $L352
1268: 1257 000268E0 fe 08 effffff755 callf $8,_writes
1269: 1258 000268E7 # }
1270: 1259 000268E7 # if ( halt_flg ) /* halt on error? */
1271: 1260 000268E7 L347:
1272: 1261 000268E7 5d effffff74f tstl _halt_flg
1273: 1262 000268ED 31 0d jeql L353
1274: 1263 000268EF # pipe1_er_hlt( subtest );
1275: 1264 000268EF dd effffff747 pushl _subtest
1276: 1265 000268F5 fe 08 ef000002da callf $8,_pipe1_er_hlt
1277: 1266 000268FC # if ( loop_on_err ) {
1278: 1267 000268FC L353:
1279: 1268 000268FC 5d effffff73a tstl _loop_on_err
1280: 1269 00026902 31 0a jeql L354
1281: 1270 00026904 # force_loop = TRUE; /* set the force loop flag */
1282: 1271 00026904 0d 01 effffff731 movl $1,_force_loop
1283: 1272 0002690B # asm("brw _pipe1_9_lp1"); /* and loop */
1284: 1273 0002690B 13 ff04 brw _pipe1_9_lp1
1285: 1274 0002690E # }
1286: 1275 0002690E # } /* end of compare error */
1287: 1276 0002690E L354:
1288: 1277 0002690E # } while( index++ < max_ldf_1_index );
1289: 1278 0002690E L346:
1290: 1279 0002690E L343:
1291: 1280 0002690E 0d effffff728 50 movl _index,r0
1292: 1281 00026915 6d effffff721 incl _index
1293: 1282 0002691B 1d 50 effffff71a cmpl r0,_max_ldf_1_index
1294: 1283 00026922 81 03 13 feb4 jlss L344
1295: 1284 00026927 L342:
1296: 1285 00026927 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1297: 1286 00026927 0d effffff70f 5d movl _pre_event_fp,r13
1298: 1287 0002692E # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1299: 1288 0002692E 0d effffff708 5e movl _pre_event_sp,r14
1300: 1289 00026935 # } /* end of subtest 9 */
1301: 1290 00026935 40 ret#2
1302: 1291 00026936 .set L338,0x0
1303: 1292 00026936 L340:
1304: 1293 00026936 13 fe88 jbr L341
1305: 1294 00026939 .data
1306: 1295 00000c00 * .text
1307: 1296 00026939 00 .align 1
1308: 1297 0002693A .globl _pipe1_10
1309: 1298 0002693A _pipe1_10:
1310: 1299 0002693A 0000 .word L355
1311: 1300 0002693C #
1312: 1301 0002693C #
1313: 1302 0002693C #
1314: 1303 0002693C #
1315: 1304 0002693C #
1316: 1305 0002693C #
1317: 1306 0002693C # /******************************************************************************
1318: 1307 0002693C # *
1319: 1308 0002693C # * SUBTEST 10
1320: 1309 0002693C # * load 0, add operand 4 times -get data via indexed FRAME pointer
1321: 1310 0002693C # *
1322: 1311 0002693C # * ADDR INDEX DATA
1323: 1312 0002693C # * pointer_data 4 <the STF result goes here>
1324: 1313 0002693C # * pointer_data-4 3 <operand data>
1325: 1314 0002693C # * pointer_data-16 0 point the frame pointer here
1326: 1315 0002693C # *
1327: 1316 0002693C # ******************************************************************************/
1328: 1317 0002693C # pipe1_10()
1329: 1318 0002693C # {
1330: 1319 0002693C 13 0187 jbr L357
1331: 1320 0002693F L358:
1332: 1321 0002693F # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1333: 1322 0002693F ed 6d effffff6f6 moval (r13),_pre_event_fp
1334: 1323 00026946 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1335: 1324 00026946 ed 6e effffff6ef moval (r14),_pre_event_sp
1336: 1325 0002694D # force_loop = FALSE; /* clear force_loop flag */
1337: 1326 0002694D 4d effffff6e9 clrl _force_loop
1338: 1327 00026953 # index = 0;
1339: 1328 00026953 4d effffff6e3 clrl _index
1340: 1329 00026959 # do
1341: 1330 00026959 L361:
1342: 1331 00026959 # {
1343: 1332 00026959 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1344: 1333 00026959 0d effffff6dd 50 movl _index,r0
1345: 1334 00026960 48 03 50 50 shll $3,r0,r0
1346: 1335 00026964 0d e000000000 effffff6cd movl _ldf_1_data(r0),_sgl_value_1
1347: 1336 0002696F # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1348: 1337 0002696F 0d effffff6c7 50 movl _index,r0
1349: 1338 00026976 48 03 50 50 shll $3,r0,r0
1350: 1339 0002697A 0d e000000004 effffff6b7 movl _ldf_1_data+4(r0),_sgl_expected
1351: 1340 00026985 # asm("moval _pointer_data,_sgl_value_2");/* init / final SP value */
1352: 1341 00026985 ed effffff6b1 effffff6ac moval _pointer_data,_sgl_value_2
1353: 1342 00026990 # /*
1354: 1343 00026990 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1355: 1344 00026990 # * The force loop flag is set after the first error.
1356: 1345 00026990 # */
1357: 1346 00026990 # asm("_pipe1_10_lp1:");
1358: 1347 00026990 _pipe1_10_lp1:
1359: 1348 00026990 # asm("moval _pointer_data,_sgl_value_2");/* get store data's addr */
1360: 1349 00026990 ed effffff6a6 effffff6a1 moval _pointer_data,_sgl_value_2
1361: 1350 0002699B # sgl_value_2 -= 4; /* decrement it by 4 (bytes)*/
1362: 1351 0002699B 2c 04 effffff69a subl2 $4,_sgl_value_2
1363: 1352 000269A2 # asm("movl _sgl_value_1,*_sgl_value_2");/* set the operand data */
1364: 1353 000269A2 0d effffff694 fffffff68f movl _sgl_value_1,*_sgl_value_2
1365: 1354 000269AD # sgl_value_2 -= 12; /* get the FP addr to use */
1366: 1355 000269AD 2c 0c effffff688 subl2 $12,_sgl_value_2
1367: 1356 000269B4 # asm("movl _sgl_value_2,r13"); /* set the FRAME POINTER */
1368: 1357 000269B4 0d effffff682 5d movl _sgl_value_2,r13
1369: 1358 000269BB # asm("movl $3,r5"); /* r5 index = 3 longwords */
1370: 1359 000269BB 0d 03 55 movl $3,r5
1371: 1360 000269BE # asm("movl $4,r6"); /* r6 index = 4 longwords */
1372: 1361 000269BE 0d 04 56 movl $4,r6
1373: 1362 000269C1 # asm("ldf (r13)[r5]"); /* load -indexed by r5 */
1374: 1363 000269C1 06 456d ldf (r13)[r5]
1375: 1364 000269C4 # asm("subf (r13)[r5]"); /* subtract it (twice) */
1376: 1365 000269C4 d6 456d subf (r13)[r5]
1377: 1366 000269C7 # asm("subf (r13)[r5]");
1378: 1367 000269C7 d6 456d subf (r13)[r5]
1379: 1368 000269CA # asm("addf (r13)[r5]"); /* add it back (twice) */
1380: 1369 000269CA c6 456d addf (r13)[r5]
1381: 1370 000269CD # asm("addf (r13)[r5]");
1382: 1371 000269CD c6 456d addf (r13)[r5]
1383: 1372 000269D0 # asm("stf (r13)[r6]"); /* store -indexed by r6 */
1384: 1373 000269D0 26 466d stf (r13)[r6]
1385: 1374 000269D3 # if ( force_loop );
1386: 1375 000269D3 5d effffff663 tstl _force_loop
1387: 1376 000269D9 31 00 jeql L362
1388: 1377 000269DB # asm("brw _pipe1_10_lp1");; /* loop on the error */
1389: 1378 000269DB L362:
1390: 1379 000269DB 13 ffb2 brw _pipe1_10_lp1
1391: 1380 000269DE # /*
1392: 1381 000269DE # * verify the results
1393: 1382 000269DE # */
1394: 1383 000269DE # sgl_st_acc = pointer_data; /* move the stored result */
1395: 1384 000269DE 0d effffff658 effffff653 movl _pointer_data,_sgl_st_acc
1396: 1385 000269E9 # asm("moval (r13),_sgl_value_3"); /* save the frame pointer */
1397: 1386 000269E9 ed 6d effffff64c moval (r13),_sgl_value_3
1398: 1387 000269F0 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1399: 1388 000269F0 # (sgl_value_3 != sgl_value_2) ) /* ... and the final FP */
1400: 1389 000269F0 1d effffff646 effffff641 cmpl _sgl_st_acc,_sgl_expected
1401: 1390 000269FB 21 10 jneq L9998
1402: 1391 000269FD 1d effffff639 effffff634 cmpl _sgl_value_3,_sgl_value_2
1403: 1392 00026A08 21 03 13 0091 jeql L363
1404: 1393 00026A0D L9998:
1405: 1394 00026A0D # {
1406: 1395 00026A0D # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1407: 1396 00026A0D 0d effffff629 5d movl _pre_event_fp,r13
1408: 1397 00026A14 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1409: 1398 00026A14 0d effffff622 5e movl _pre_event_sp,r14
1410: 1399 00026A1B # errcnt++; /* bump the error count */
1411: 1400 00026A1B 6d effffff61b incl _errcnt
1412: 1401 00026A21 # if ( prt_error ) {
1413: 1402 00026A21 5d effffff615 tstl _prt_error
1414: 1403 00026A27 31 4e jeql L364
1415: 1404 00026A29 # print_pipe1_er("indexed FP addressing");
1416: 1405 00026A29 .data 1
1417: 1406 00000cef * L365:
1418: 1407 00000cef * 696E646578656420465020616 .ascii "indexed FP addressing\0"
1419: 46472657373696E6700
1420: 1408 00000d05 * .text
1421: 1409 00026A29 dd 8f00000cef pushl $L365
1422: 1410 00026A2F fe 08 ef00000094 callf $8,_print_pipe1_er
1423: 1411 00026A36 # writes("final Frame Pointer = ");
1424: 1412 00026A36 .data 1
1425: 1413 00000d05 * L366:
1426: 1414 00000d05 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
1427: 06F696E746572203D2000
1428: 1415 00000d1c * .text
1429: 1416 00026A36 dd 8f00000d05 pushl $L366
1430: 1417 00026A3C fe 08 effffff5f9 callf $8,_writes
1431: 1418 00026A43 # writeh( sgl_value_3 );
1432: 1419 00026A43 dd effffff5f3 pushl _sgl_value_3
1433: 1420 00026A49 fe 08 effffff5ec callf $8,_writeh
1434: 1421 00026A50 # writes(", expected FP = ");
1435: 1422 00026A50 .data 1
1436: 1423 00000d1c * L368:
1437: 1424 00000d1c * 2C20206578706563746564204 .ascii ", expected FP = \0"
1438: 650203D2000
1439: 1425 00000d2e * .text
1440: 1426 00026A50 dd 8f00000d1c pushl $L368
1441: 1427 00026A56 fe 08 effffff5df callf $8,_writes
1442: 1428 00026A5D # writeh( sgl_value_2 );
1443: 1429 00026A5D dd effffff5d9 pushl _sgl_value_2
1444: 1430 00026A63 fe 08 effffff5d2 callf $8,_writeh
1445: 1431 00026A6A # writes(" \n");
1446: 1432 00026A6A .data 1
1447: 1433 00000d2e * L369:
1448: 1434 00000d2e * 200A00 .ascii " \12\0"
1449: 1435 00000d31 * .text
1450: 1436 00026A6A dd 8f00000d2e pushl $L369
1451: 1437 00026A70 fe 08 effffff5c5 callf $8,_writes
1452: 1438 00026A77 # }
1453: 1439 00026A77 # if ( halt_flg ) /* halt on error? */
1454: 1440 00026A77 L364:
1455: 1441 00026A77 5d effffff5bf tstl _halt_flg
1456: 1442 00026A7D 31 0d jeql L370
1457: 1443 00026A7F # pipe1_er_hlt( subtest );
1458: 1444 00026A7F dd effffff5b7 pushl _subtest
1459: 1445 00026A85 fe 08 ef0000014a callf $8,_pipe1_er_hlt
1460: 1446 00026A8C # if ( loop_on_err ) {
1461: 1447 00026A8C L370:
1462: 1448 00026A8C 5d effffff5aa tstl _loop_on_err
1463: 1449 00026A92 31 0a jeql L371
1464: 1450 00026A94 # force_loop = TRUE; /* set the force loop flag */
1465: 1451 00026A94 0d 01 effffff5a1 movl $1,_force_loop
1466: 1452 00026A9B # asm("brw _pipe1_10_lp1"); /* and loop */
1467: 1453 00026A9B 13 fef2 brw _pipe1_10_lp1
1468: 1454 00026A9E # }
1469: 1455 00026A9E # } /* end of compare error */
1470: 1456 00026A9E L371:
1471: 1457 00026A9E # } while( index++ < max_ldf_1_index );
1472: 1458 00026A9E L363:
1473: 1459 00026A9E L360:
1474: 1460 00026A9E 0d effffff598 50 movl _index,r0
1475: 1461 00026AA5 6d effffff591 incl _index
1476: 1462 00026AAB 1d 50 effffff58a cmpl r0,_max_ldf_1_index
1477: 1463 00026AB2 81 03 13 fea2 jlss L361
1478: 1464 00026AB7 L359:
1479: 1465 00026AB7 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1480: 1466 00026AB7 0d effffff57f 5d movl _pre_event_fp,r13
1481: 1467 00026ABE # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1482: 1468 00026ABE 0d effffff578 5e movl _pre_event_sp,r14
1483: 1469 00026AC5 # } /* end of subtest 10 */
1484: 1470 00026AC5 40 ret#2
1485: 1471 00026AC6 .set L355,0x0
1486: 1472 00026AC6 L357:
1487: 1473 00026AC6 13 fe76 jbr L358
1488: 1474 00026AC9 .data
1489: 1475 00000c00 * .text
1490: 1476 00026AC9 00 .align 1
1491: 1477 00026ACA .globl _print_pipe1_er
1492: 1478 00026ACA _print_pipe1_er:
1493: 1479 00026ACA 0000 .word L372
1494: 1480 00026ACC #
1495: 1481 00026ACC #
1496: 1482 00026ACC #
1497: 1483 00026ACC #
1498: 1484 00026ACC #
1499: 1485 00026ACC # /******************************************************************************
1500: 1486 00026ACC # *
1501: 1487 00026ACC # * ERROR ROUTINE
1502: 1488 00026ACC # *
1503: 1489 00026ACC # * print an error in the following form
1504: 1490 00026ACC # *
1505: 1491 00026ACC # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd
1506: 1492 00026ACC # * expected Acc = xxxxxxxx
1507: 1493 00026ACC # *
1508: 1494 00026ACC # ******************************************************************************/
1509: 1495 00026ACC # print_pipe1_er(msg)
1510: 1496 00026ACC # char *msg;
1511: 1497 00026ACC # {
1512: 1498 00026ACC 13 0103 jbr L374
1513: 1499 00026ACF L375:
1514: 1500 00026ACF # writes(" \n"); /* start a new print line */
1515: 1501 00026ACF .data 1
1516: 1502 00000d31 * L376:
1517: 1503 00000d31 * 200A00 .ascii " \12\0"
1518: 1504 00000d34 * .text
1519: 1505 00026ACF dd 8f00000d31 pushl $L376
1520: 1506 00026AD5 fe 08 effffff560 callf $8,_writes
1521: 1507 00026ADC # writes("cycle: ");
1522: 1508 00026ADC .data 1
1523: 1509 00000d34 * L377:
1524: 1510 00000d34 * 6379636C653A2000 .ascii "cycle: \0"
1525: 1511 00000d3c * .text
1526: 1512 00026ADC dd 8f00000d34 pushl $L377
1527: 1513 00026AE2 fe 08 effffff553 callf $8,_writes
1528: 1514 00026AE9 # writed( cycle );
1529: 1515 00026AE9 dd effffff54d pushl _cycle
1530: 1516 00026AEF fe 08 effffff546 callf $8,_writed
1531: 1517 00026AF6 # writes(" test ");
1532: 1518 00026AF6 .data 1
1533: 1519 00000d3c * L379:
1534: 1520 00000d3c * 20746573742000 .ascii " test \0"
1535: 1521 00000d43 * .text
1536: 1522 00026AF6 dd 8f00000d3c pushl $L379
1537: 1523 00026AFC fe 08 effffff539 callf $8,_writes
1538: 1524 00026B03 # writed( test_no );
1539: 1525 00026B03 dd effffff533 pushl _test_no
1540: 1526 00026B09 fe 08 effffff52c callf $8,_writed
1541: 1527 00026B10 # writes(" (Pipe 1), subtest ");
1542: 1528 00026B10 .data 1
1543: 1529 00000d43 * L380:
1544: 1530 00000d43 * 202028506970652031292C207 .ascii " (Pipe 1), subtest \0"
1545: 37562746573742000
1546: 1531 00000d58 * .text
1547: 1532 00026B10 dd 8f00000d43 pushl $L380
1548: 1533 00026B16 fe 08 effffff51f callf $8,_writes
1549: 1534 00026B1D # writed( subtest );
1550: 1535 00026B1D dd effffff519 pushl _subtest
1551: 1536 00026B23 fe 08 effffff512 callf $8,_writed
1552: 1537 00026B2A # writes(" error - ");
1553: 1538 00026B2A .data 1
1554: 1539 00000d58 * L381:
1555: 1540 00000d58 * 206572726F72202D2000 .ascii " error - \0"
1556: 1541 00000d62 * .text
1557: 1542 00026B2A dd 8f00000d58 pushl $L381
1558: 1543 00026B30 fe 08 effffff505 callf $8,_writes
1559: 1544 00026B37 # writes( msg );
1560: 1545 00026B37 dd ad04 pushl 4(fp)
1561: 1546 00026B3A fe 08 effffff4fb callf $8,_writes
1562: 1547 00026B41 # writec('\n');
1563: 1548 00026B41 dd 0a pushl $10
1564: 1549 00026B43 fe 08 effffff4f2 callf $8,_writec
1565: 1550 00026B4A # writes(" LDF(op1), SUBF(op1), SUBF(op1), ADDF(op1), ADDF(op1), STF\n");
1566: 1551 00026B4A .data 1
1567: 1552 00000d62 * L383:
1568: 1553 00000d62 * 204C4446286F7031292C20535 .ascii " LDF(op1), SUBF(op1), SUBF(op1), ADDF(op1), ADDF(op1), STF\12\0"
1569: 54246286F7031292C20535542
1570: 46286F7031292C20414444462
1571: 86F7031292C2041444446286F
1572: 7031292C205354460A00
1573: 1554 00000d9e * .text
1574: 1555 00026B4A dd 8f00000d62 pushl $L383
1575: 1556 00026B50 fe 08 effffff4e5 callf $8,_writes
1576: 1557 00026B57 # writes("operand = ");
1577: 1558 00026B57 .data 1
1578: 1559 00000d9e * L384:
1579: 1560 00000d9e * 6F706572616E64203D2000 .ascii "operand = \0"
1580: 1561 00000da9 * .text
1581: 1562 00026B57 dd 8f00000d9e pushl $L384
1582: 1563 00026B5D fe 08 effffff4d8 callf $8,_writes
1583: 1564 00026B64 # write32h( sgl_value_1 );
1584: 1565 00026B64 dd effffff4d2 pushl _sgl_value_1
1585: 1566 00026B6A fe 08 effffff4cb callf $8,_write32h
1586: 1567 00026B71 # writes(", final Acc = ");
1587: 1568 00026B71 .data 1
1588: 1569 00000da9 * L385:
1589: 1570 00000da9 * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
1590: 3203D2000
1591: 1571 00000dba * .text
1592: 1572 00026B71 dd 8f00000da9 pushl $L385
1593: 1573 00026B77 fe 08 effffff4be callf $8,_writes
1594: 1574 00026B7E # write32h( sgl_st_acc );
1595: 1575 00026B7E dd effffff4b8 pushl _sgl_st_acc
1596: 1576 00026B84 fe 08 effffff4b1 callf $8,_write32h
1597: 1577 00026B8B # writes(", data index = ");
1598: 1578 00026B8B .data 1
1599: 1579 00000dba * L386:
1600: 1580 00000dba * 2C2020206461746120696E646 .ascii ", data index = \0"
1601: 578203D2000
1602: 1581 00000dcc * .text
1603: 1582 00026B8B dd 8f00000dba pushl $L386
1604: 1583 00026B91 fe 08 effffff4a4 callf $8,_writes
1605: 1584 00026B98 # writed( index );
1606: 1585 00026B98 dd effffff49e pushl _index
1607: 1586 00026B9E fe 08 effffff497 callf $8,_writed
1608: 1587 00026BA5 # writec('\n');
1609: 1588 00026BA5 dd 0a pushl $10
1610: 1589 00026BA7 fe 08 effffff48e callf $8,_writec
1611: 1590 00026BAE # writes(" expected Acc = ");
1612: 1591 00026BAE .data 1
1613: 1592 00000dcc * L387:
1614: 1593 00000dcc * 2020202020202020202020202 .ascii " expected Acc = \0"
1615: 0202020202020657870656374
1616: 656420416363203D2000
1617: 1594 00000def * .text
1618: 1595 00026BAE dd 8f00000dcc pushl $L387
1619: 1596 00026BB4 fe 08 effffff481 callf $8,_writes
1620: 1597 00026BBB # write32h( sgl_expected );
1621: 1598 00026BBB dd effffff47b pushl _sgl_expected
1622: 1599 00026BC1 fe 08 effffff474 callf $8,_write32h
1623: 1600 00026BC8 # writec('\n');
1624: 1601 00026BC8 dd 0a pushl $10
1625: 1602 00026BCA fe 08 effffff46b callf $8,_writec
1626: 1603 00026BD1 # }
1627: 1604 00026BD1 40 ret#2
1628: 1605 00026BD2 .set L372,0x0
1629: 1606 00026BD2 L374:
1630: 1607 00026BD2 13 fefa jbr L375
1631: 1608 00026BD5 .data
1632: 1609 00000c00 * .text
1633: 1610 00026BD5 00 .align 1
1634: 1611 00026BD6 .globl _pipe1_er_hlt
1635: 1612 00026BD6 _pipe1_er_hlt:
1636: 1613 00026BD6 0000 .word L388
1637: 1614 00026BD8 #
1638: 1615 00026BD8 #
1639: 1616 00026BD8 #
1640: 1617 00026BD8 #
1641: 1618 00026BD8 #
1642: 1619 00026BD8 # /******************************************************************************
1643: 1620 00026BD8 # *
1644: 1621 00026BD8 # * HALT ON ERROR ROUTINE
1645: 1622 00026BD8 # *
1646: 1623 00026BD8 # * halt with the necessary information saved in the registers
1647: 1624 00026BD8 # *
1648: 1625 00026BD8 # ******************************************************************************/
1649: 1626 00026BD8 # pipe1_er_hlt( subtest )
1650: 1627 00026BD8 # int subtest;
1651: 1628 00026BD8 # {
1652: 1629 00026BD8 11 60 jbr L390
1653: 1630 00026BDA L391:
1654: 1631 00026BDA # asm("movl _test_no,r0"); /* r0 = test number */
1655: 1632 00026BDA 0d effffff45c 50 movl _test_no,r0
1656: 1633 00026BE1 # asm("movl _subtest,r1"); /* r1 = subtest number */
1657: 1634 00026BE1 0d effffff455 51 movl _subtest,r1
1658: 1635 00026BE8 # asm("movl $1,r2"); /* r2 = error code */
1659: 1636 00026BE8 0d 01 52 movl $1,r2
1660: 1637 00026BEB # asm("movl _cycle,r3"); /* r3 = cycle count */
1661: 1638 00026BEB 0d effffff44b 53 movl _cycle,r3
1662: 1639 00026BF2 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1663: 1640 00026BF2 0d effffff444 54 movl _sgl_value_1,r4
1664: 1641 00026BF9 # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */
1665: 1642 00026BF9 0d effffff43d 55 movl _sgl_st_acc,r5
1666: 1643 00026C00 # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */
1667: 1644 00026C00 0d effffff436 56 movl _sgl_expected,r6
1668: 1645 00026C07 # asm("movl _index,r7"); /* r7 = data index */
1669: 1646 00026C07 0d effffff42f 57 movl _index,r7
1670: 1647 00026C0E # if( subtest == 9 ) {
1671: 1648 00026C0E 1d ad04 09 cmpl 4(fp),$9
1672: 1649 00026C12 21 10 jneq L392
1673: 1650 00026C14 # asm("movl _sgl_value_3,r8"); /* r8 = final SP value */
1674: 1651 00026C14 0d effffff422 58 movl _sgl_value_3,r8
1675: 1652 00026C1B # asm("movl _sgl_value_2,r9"); /* r9 = expected SP value */
1676: 1653 00026C1B 0d effffff41b 59 movl _sgl_value_2,r9
1677: 1654 00026C22 # } else
1678: 1655 00026C22 11 14 jbr L393
1679: 1656 00026C24 L392:
1680: 1657 00026C24 # if( subtest == 10 ) {
1681: 1658 00026C24 1d ad04 0a cmpl 4(fp),$10
1682: 1659 00026C28 21 0e jneq L394
1683: 1660 00026C2A # asm("movl _sgl_value_3,r8"); /* r8 = final FP value */
1684: 1661 00026C2A 0d effffff40c 58 movl _sgl_value_3,r8
1685: 1662 00026C31 # asm("movl _sgl_value_2,r9"); /* r9 = expected FP value */
1686: 1663 00026C31 0d effffff405 59 movl _sgl_value_2,r9
1687: 1664 00026C38 # };
1688: 1665 00026C38 L394:
1689: 1666 00026C38 L393:
1690: 1667 00026C38 # asm(".globl _pipe1_1_hlt");
1691: 1668 00026C38 .globl _pipe1_1_hlt
1692: 1669 00026C38 # asm("_pipe1_1_hlt:"); /* PC after the halt */
1693: 1670 00026C38 _pipe1_1_hlt:
1694: 1671 00026C38 # asm("halt"); /* HALT ... */
1695: 1672 00026C38 00 halt
1696: 1673 00026C39 # } /* end of halt on error */
1697: 1674 00026C39 40 ret#2
1698: 1675 00026C3A .set L388,0x0
1699: 1676 00026C3A L390:
1700: 1677 00026C3A 11 9e jbr L391
1701: 1678 00000c00 * .data
1702: 1678 00000c00 * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.