![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pipe8.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 pipe8.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 00000d5c * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _pipe_8
6: 6 00000000 _pipe_8:
7: 7 0002BC54 0000 .word L215
8: 8 0002BC56 # #include "fpp_defs.h"
9: 9 0002BC56 #
10: 10 0002BC56 #
11: 11 0002BC56 # /*****************************************************************************
12: 12 0002BC56 # *
13: 13 0002BC56 # * PIPELINE TEST #8 MONITOR
14: 14 0002BC56 # *
15: 15 0002BC56 # * This test will do:
16: 16 0002BC56 # *
17: 17 0002BC56 # * LDF(1), SUBF(2), MULF(x), ADDF(x), ADDF(x), STF
18: 18 0002BC56 # *
19: 19 0002BC56 # * where x is the fmacro1 LDF data.
20: 20 0002BC56 # *****************************************************************************/
21: 21 0002BC56 # pipe_8()
22: 22 0002BC56 # {
23: 23 0002BC56 13 00a8 jbr L217
24: 24 0002BC59 L218:
25: 25 0002BC59 # asm(".globl _pipeline_8_t");
26: 26 0002BC59 .globl _pipeline_8_t
27: 27 0002BC59 # asm("_pipeline_8_t:"); /* entry address */
28: 28 0002BC59 _pipeline_8_t:
29: 29 0002BC59 # if( (cycle == 1) && (prt_hdrs) ) /* print headers on 1st cycle */
30: 30 0002BC59 1d effffffff5 01 cmpl _cycle,$1
31: 31 0002BC60 21 15 jneq L219
32: 32 0002BC62 5d efffffffec tstl _prt_hdrs
33: 33 0002BC68 31 0d jeql L219
34: 34 0002BC6A # {
35: 35 0002BC6A # writes("\n PIPE_8 ");
36: 36 0002BC6A .data 1
37: 37 00000d5c * L221:
38: 38 00000d5c * 0A20504950455F382000 .ascii "\12 PIPE_8 \0"
39: 39 00000d66 * .text
40: 40 0002BC6A dd 8f00000d5c pushl $L221
41: 41 0002BC70 fe 08 efffffffdd callf $8,_writes
42: 42 0002BC77 # }
43: 43 0002BC77 # subtest = 1;
44: 44 0002BC77 L219:
45: 45 0002BC77 0d 01 efffffffd6 movl $1,_subtest
46: 46 0002BC7E # pipe8_1(); /* data in REGs, no NOPs */
47: 47 0002BC7E fe 04 ef0000007f callf $4,_pipe8_1
48: 48 0002BC85 # subtest++; /* increment subtest num */
49: 49 0002BC85 6d efffffffc9 incl _subtest
50: 50 0002BC8B # pipe8_2(); /* data in REGs, 1 NOP */
51: 51 0002BC8B fe 04 ef00000166 callf $4,_pipe8_2
52: 52 0002BC92 # subtest++; /* increment subtest num */
53: 53 0002BC92 6d efffffffbc incl _subtest
54: 54 0002BC98 # pipe8_3(); /* data in REGs, 2 NOPs */
55: 55 0002BC98 fe 04 ef00000253 callf $4,_pipe8_3
56: 56 0002BC9F # subtest++; /* increment subtest num */
57: 57 0002BC9F 6d efffffffaf incl _subtest
58: 58 0002BCA5 # pipe8_4(); /* data in REGs, 3 NOPs */
59: 59 0002BCA5 fe 04 ef00000344 callf $4,_pipe8_4
60: 60 0002BCAC # subtest++; /* increment subtest num */
61: 61 0002BCAC 6d efffffffa2 incl _subtest
62: 62 0002BCB2 # pipe8_5(); /* data in CACHE, no NOPs */
63: 63 0002BCB2 fe 04 ef0000043b callf $4,_pipe8_5
64: 64 0002BCB9 # subtest++; /* increment subtest num */
65: 65 0002BCB9 6d efffffff95 incl _subtest
66: 66 0002BCBF # pipe8_6(); /* data in CACHE, 1 NOP */
67: 67 0002BCBF fe 04 ef0000051e callf $4,_pipe8_6
68: 68 0002BCC6 # subtest++; /* increment subtest num */
69: 69 0002BCC6 6d efffffff88 incl _subtest
70: 70 0002BCCC # pipe8_7(); /* data in CACHE, 2 NOPs */
71: 71 0002BCCC fe 04 ef00000607 callf $4,_pipe8_7
72: 72 0002BCD3 # subtest++; /* increment subtest num */
73: 73 0002BCD3 6d efffffff7b incl _subtest
74: 74 0002BCD9 # pipe8_8(); /* data in CACHE, 3 NOPs */
75: 75 0002BCD9 fe 04 ef000006f4 callf $4,_pipe8_8
76: 76 0002BCE0 # subtest++; /* increment subtest num */
77: 77 0002BCE0 6d efffffff6e incl _subtest
78: 78 0002BCE6 # pipe8_9(); /* data on STACK, no NOPs */
79: 79 0002BCE6 fe 04 ef000007e7 callf $4,_pipe8_9
80: 80 0002BCED # subtest++; /* increment subtest num */
81: 81 0002BCED 6d efffffff61 incl _subtest
82: 82 0002BCF3 # pipe8_10(); /* data via FP no NOPs */
83: 83 0002BCF3 fe 04 ef00000970 callf $4,_pipe8_10
84: 84 0002BCFA # asm("jmp *return"); /* return to the test monitor */
85: 85 0002BCFA 71 ffffffff54 jmp *return
86: 86 0002BD00 # }
87: 87 0002BD00 40 ret#2
88: 88 0002BD01 .set L215,0x0
89: 89 0002BD01 L217:
90: 90 0002BD01 13 ff55 jbr L218
91: 91 0002BD04 .data
92: 92 00000d5c * .text
93: 93 0002BD04 .align 1
94: 94 0002BD04 .globl _pipe8_1
95: 95 0002BD04 _pipe8_1:
96: 96 0002BD04 0000 .word L232
97: 97 0002BD06 #
98: 98 0002BD06 #
99: 99 0002BD06 #
100: 100 0002BD06 #
101: 101 0002BD06 #
102: 102 0002BD06 #
103: 103 0002BD06 # /************************************************************************
104: 104 0002BD06 # *
105: 105 0002BD06 # * SUBTEST 1
106: 106 0002BD06 # * data in registers, no NO-OPs
107: 107 0002BD06 # *
108: 108 0002BD06 # ************************************************************************/
109: 109 0002BD06 # pipe8_1()
110: 110 0002BD06 # {
111: 111 0002BD06 13 00ec jbr L234
112: 112 0002BD09 L235:
113: 113 0002BD09 # force_loop = FALSE; /* clear force_loop flag */
114: 114 0002BD09 4d efffffff45 clrl _force_loop
115: 115 0002BD0F # index = 0;
116: 116 0002BD0F 4d efffffff3f clrl _index
117: 117 0002BD15 # do
118: 118 0002BD15 L238:
119: 119 0002BD15 # {
120: 120 0002BD15 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
121: 121 0002BD15 0d efffffff39 50 movl _index,r0
122: 122 0002BD1C 48 03 50 50 shll $3,r0,r0
123: 123 0002BD20 0d e000000000 efffffff29 movl _ldf_1_data(r0),_sgl_value_1
124: 124 0002BD2B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
125: 125 0002BD2B 0d efffffff23 50 movl _index,r0
126: 126 0002BD32 48 03 50 50 shll $3,r0,r0
127: 127 0002BD36 0d e000000004 efffffff13 movl _ldf_1_data+4(r0),_sgl_expected
128: 128 0002BD41 # sgl_value_2 = 0x40800000; /* floating '1' */
129: 129 0002BD41 0d 8f40800000 efffffff08 movl $1082130432,_sgl_value_2
130: 130 0002BD4C # sgl_value_3 = 0x41000000; /* floating '2' */
131: 131 0002BD4C 0d 8f41000000 effffffefd movl $1090519040,_sgl_value_3
132: 132 0002BD57 # /*
133: 133 0002BD57 # * If LOOP ON ERROR is set, this is the loop for this subtest.
134: 134 0002BD57 # * The force loop flag is set after the first error.
135: 135 0002BD57 # */
136: 136 0002BD57 # asm("_pipe8_1_lp1:");
137: 137 0002BD57 _pipe8_1_lp1:
138: 138 0002BD57 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
139: 139 0002BD57 0d effffffef7 54 movl _sgl_value_1,r4
140: 140 0002BD5E # asm("movl _sgl_value_2,r5"); /* move data to r5 */
141: 141 0002BD5E 0d effffffef0 55 movl _sgl_value_2,r5
142: 142 0002BD65 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
143: 143 0002BD65 0d effffffee9 56 movl _sgl_value_3,r6
144: 144 0002BD6C # asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
145: 145 0002BD6C 06 55 ldf r5
146: 146 0002BD6E # asm("subf r6"); /* minus 2.0 (-1.0 ) */
147: 147 0002BD6E d6 56 subf r6
148: 148 0002BD70 # asm("mulf r4"); /* *'s the operand ( -op ) */
149: 149 0002BD70 e6 54 mulf r4
150: 150 0002BD72 # asm("addf r4"); /* + the operand ( 0 ) */
151: 151 0002BD72 c6 54 addf r4
152: 152 0002BD74 # asm("addf r4"); /* + the operand ( +op ) */
153: 153 0002BD74 c6 54 addf r4
154: 154 0002BD76 # asm("stf r7"); /* store the result */
155: 155 0002BD76 26 57 stf r7
156: 156 0002BD78 # if( force_loop )
157: 157 0002BD78 5d effffffed6 tstl _force_loop
158: 158 0002BD7E 31 02 jeql L239
159: 159 0002BD80 # asm("brb _pipe8_1_lp1");; /* loop on the error */
160: 160 0002BD80 11 d5 brb _pipe8_1_lp1
161: 161 0002BD82 L239:
162: 162 0002BD82 # /*
163: 163 0002BD82 # * verify the results
164: 164 0002BD82 # */
165: 165 0002BD82 # asm("movl r7,_sgl_st_acc"); /* get the result */
166: 166 0002BD82 0d 57 effffffecb movl r7,_sgl_st_acc
167: 167 0002BD89 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
168: 168 0002BD89 1d effffffec5 effffffec0 cmpl _sgl_st_acc,_sgl_expected
169: 169 0002BD94 31 45 jeql L240
170: 170 0002BD96 # {
171: 171 0002BD96 # errcnt++; /* bump the error count */
172: 172 0002BD96 6d effffffeb8 incl _errcnt
173: 173 0002BD9C # if ( prt_error )
174: 174 0002BD9C 5d effffffeb2 tstl _prt_error
175: 175 0002BDA2 31 0d jeql L241
176: 176 0002BDA4 # print_pipe8_er("Reg. Data, no NO-OPs");
177: 177 0002BDA4 .data 1
178: 178 00000d66 * L243:
179: 179 00000d66 * 5265672E20446174612C206E6 .ascii "Reg. Data, no NO-OPs\0"
180: F204E4F2D4F507300
181: 180 00000d7b * .text
182: 181 0002BDA4 dd 8f00000d66 pushl $L243
183: 182 0002BDAA fe 08 ef00000a7f callf $8,_print_pipe8_er
184: 183 0002BDB1 # if ( halt_flg )
185: 184 0002BDB1 L241:
186: 185 0002BDB1 5d effffffe9d tstl _halt_flg
187: 186 0002BDB7 31 0d jeql L244
188: 187 0002BDB9 # pipe8_er_hlt( subtest );
189: 188 0002BDB9 dd effffffe95 pushl _subtest
190: 189 0002BDBF fe 08 ef00000b76 callf $8,_pipe8_er_hlt
191: 190 0002BDC6 # if ( loop_on_err ) {
192: 191 0002BDC6 L244:
193: 192 0002BDC6 5d effffffe88 tstl _loop_on_err
194: 193 0002BDCC 31 0d jeql L246
195: 194 0002BDCE # force_loop = TRUE; /* set the force loop flag */
196: 195 0002BDCE 0d 01 effffffe7f movl $1,_force_loop
197: 196 0002BDD5 # asm("jmp _pipe8_1_lp1"); /* and loop */
198: 197 0002BDD5 71 efffffff7c jmp _pipe8_1_lp1
199: 198 0002BDDB # }
200: 199 0002BDDB # } /* end of compare error */
201: 200 0002BDDB L246:
202: 201 0002BDDB # } while( index++ < max_ldf_1_index );
203: 202 0002BDDB L240:
204: 203 0002BDDB L237:
205: 204 0002BDDB 0d effffffe73 50 movl _index,r0
206: 205 0002BDE2 6d effffffe6c incl _index
207: 206 0002BDE8 1d 50 effffffe65 cmpl r0,_max_ldf_1_index
208: 207 0002BDEF 81 03 13 ff21 jlss L238
209: 208 0002BDF4 L236:
210: 209 0002BDF4 # } /* end of subtest 1 */
211: 210 0002BDF4 40 ret#2
212: 211 0002BDF5 .set L232,0x0
213: 212 0002BDF5 L234:
214: 213 0002BDF5 13 ff11 jbr L235
215: 214 0002BDF8 .data
216: 215 00000d5c * .text
217: 216 0002BDF8 .align 1
218: 217 0002BDF8 .globl _pipe8_2
219: 218 0002BDF8 _pipe8_2:
220: 219 0002BDF8 0000 .word L247
221: 220 0002BDFA #
222: 221 0002BDFA #
223: 222 0002BDFA #
224: 223 0002BDFA #
225: 224 0002BDFA #
226: 225 0002BDFA #
227: 226 0002BDFA # /************************************************************************
228: 227 0002BDFA # *
229: 228 0002BDFA # * SUBTEST 2
230: 229 0002BDFA # * data in registers, 1 NO-OP
231: 230 0002BDFA # *
232: 231 0002BDFA # ************************************************************************/
233: 232 0002BDFA # pipe8_2()
234: 233 0002BDFA # {
235: 234 0002BDFA 13 00f1 jbr L249
236: 235 0002BDFD L250:
237: 236 0002BDFD # force_loop = FALSE; /* clear force_loop flag */
238: 237 0002BDFD 4d effffffe51 clrl _force_loop
239: 238 0002BE03 # index = 0;
240: 239 0002BE03 4d effffffe4b clrl _index
241: 240 0002BE09 # do
242: 241 0002BE09 L253:
243: 242 0002BE09 # {
244: 243 0002BE09 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
245: 244 0002BE09 0d effffffe45 50 movl _index,r0
246: 245 0002BE10 48 03 50 50 shll $3,r0,r0
247: 246 0002BE14 0d e000000000 effffffe35 movl _ldf_1_data(r0),_sgl_value_1
248: 247 0002BE1F # sgl_expected = ldf_1_data[index].exp; /* get expected results */
249: 248 0002BE1F 0d effffffe2f 50 movl _index,r0
250: 249 0002BE26 48 03 50 50 shll $3,r0,r0
251: 250 0002BE2A 0d e000000004 effffffe1f movl _ldf_1_data+4(r0),_sgl_expected
252: 251 0002BE35 # sgl_value_2 = 0x40800000; /* floating '1' */
253: 252 0002BE35 0d 8f40800000 effffffe14 movl $1082130432,_sgl_value_2
254: 253 0002BE40 # sgl_value_3 = 0x41000000; /* floating '2' */
255: 254 0002BE40 0d 8f41000000 effffffe09 movl $1090519040,_sgl_value_3
256: 255 0002BE4B # /*
257: 256 0002BE4B # * If LOOP ON ERROR is set, this is the loop for this subtest.
258: 257 0002BE4B # * The force loop flag is set after the first error.
259: 258 0002BE4B # */
260: 259 0002BE4B # asm("_pipe8_2_lp1:");
261: 260 0002BE4B _pipe8_2_lp1:
262: 261 0002BE4B # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
263: 262 0002BE4B 0d effffffe03 54 movl _sgl_value_1,r4
264: 263 0002BE52 # asm("movl _sgl_value_2,r5"); /* move data to r5 */
265: 264 0002BE52 0d effffffdfc 55 movl _sgl_value_2,r5
266: 265 0002BE59 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
267: 266 0002BE59 0d effffffdf5 56 movl _sgl_value_3,r6
268: 267 0002BE60 # asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
269: 268 0002BE60 06 55 ldf r5
270: 269 0002BE62 # asm("nop");
271: 270 0002BE62 10 nop
272: 271 0002BE63 # asm("subf r6"); /* minus 2.0 (-1.0 ) */
273: 272 0002BE63 d6 56 subf r6
274: 273 0002BE65 # asm("nop");
275: 274 0002BE65 10 nop
276: 275 0002BE66 # asm("mulf r4"); /* *'s the operand ( -op ) */
277: 276 0002BE66 e6 54 mulf r4
278: 277 0002BE68 # asm("nop");
279: 278 0002BE68 10 nop
280: 279 0002BE69 # asm("addf r4"); /* + the operand ( 0 ) */
281: 280 0002BE69 c6 54 addf r4
282: 281 0002BE6B # asm("nop");
283: 282 0002BE6B 10 nop
284: 283 0002BE6C # asm("addf r4"); /* + the operand ( +op ) */
285: 284 0002BE6C c6 54 addf r4
286: 285 0002BE6E # asm("nop");
287: 286 0002BE6E 10 nop
288: 287 0002BE6F # asm("stf r7"); /* store the result */
289: 288 0002BE6F 26 57 stf r7
290: 289 0002BE71 # if( force_loop )
291: 290 0002BE71 5d effffffddd tstl _force_loop
292: 291 0002BE77 31 02 jeql L254
293: 292 0002BE79 # asm("brb _pipe8_2_lp1");; /* loop on the error */
294: 293 0002BE79 11 d0 brb _pipe8_2_lp1
295: 294 0002BE7B L254:
296: 295 0002BE7B # /*
297: 296 0002BE7B # * verify the results
298: 297 0002BE7B # */
299: 298 0002BE7B # asm("movl r7,_sgl_st_acc"); /* get the result */
300: 299 0002BE7B 0d 57 effffffdd2 movl r7,_sgl_st_acc
301: 300 0002BE82 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
302: 301 0002BE82 1d effffffdcc effffffdc7 cmpl _sgl_st_acc,_sgl_expected
303: 302 0002BE8D 31 45 jeql L255
304: 303 0002BE8F # {
305: 304 0002BE8F # errcnt++; /* bump the error count */
306: 305 0002BE8F 6d effffffdbf incl _errcnt
307: 306 0002BE95 # if ( prt_error )
308: 307 0002BE95 5d effffffdb9 tstl _prt_error
309: 308 0002BE9B 31 0d jeql L256
310: 309 0002BE9D # print_pipe8_er("Reg. Data, 1 NO-OP");
311: 310 0002BE9D .data 1
312: 311 00000d7b * L257:
313: 312 00000d7b * 5265672E20446174612C20312 .ascii "Reg. Data, 1 NO-OP\0"
314: 04E4F2D4F5000
315: 313 00000d8e * .text
316: 314 0002BE9D dd 8f00000d7b pushl $L257
317: 315 0002BEA3 fe 08 ef00000986 callf $8,_print_pipe8_er
318: 316 0002BEAA # if ( halt_flg )
319: 317 0002BEAA L256:
320: 318 0002BEAA 5d effffffda4 tstl _halt_flg
321: 319 0002BEB0 31 0d jeql L258
322: 320 0002BEB2 # pipe8_er_hlt( subtest );
323: 321 0002BEB2 dd effffffd9c pushl _subtest
324: 322 0002BEB8 fe 08 ef00000a7d callf $8,_pipe8_er_hlt
325: 323 0002BEBF # if ( loop_on_err ) {
326: 324 0002BEBF L258:
327: 325 0002BEBF 5d effffffd8f tstl _loop_on_err
328: 326 0002BEC5 31 0d jeql L259
329: 327 0002BEC7 # force_loop = TRUE; /* set the force loop flag */
330: 328 0002BEC7 0d 01 effffffd86 movl $1,_force_loop
331: 329 0002BECE # asm("jmp _pipe8_2_lp1"); /* and loop */
332: 330 0002BECE 71 efffffff77 jmp _pipe8_2_lp1
333: 331 0002BED4 # }
334: 332 0002BED4 # } /* end of compare error */
335: 333 0002BED4 L259:
336: 334 0002BED4 # } while( index++ < max_ldf_1_index );
337: 335 0002BED4 L255:
338: 336 0002BED4 L252:
339: 337 0002BED4 0d effffffd7a 50 movl _index,r0
340: 338 0002BEDB 6d effffffd73 incl _index
341: 339 0002BEE1 1d 50 effffffd6c cmpl r0,_max_ldf_1_index
342: 340 0002BEE8 81 03 13 ff1c jlss L253
343: 341 0002BEED L251:
344: 342 0002BEED # } /* end of subtest 2 */
345: 343 0002BEED 40 ret#2
346: 344 0002BEEE .set L247,0x0
347: 345 0002BEEE L249:
348: 346 0002BEEE 13 ff0c jbr L250
349: 347 0002BEF1 .data
350: 348 00000d5c * .text
351: 349 0002BEF1 00 .align 1
352: 350 0002BEF2 .globl _pipe8_3
353: 351 0002BEF2 _pipe8_3:
354: 352 0002BEF2 0000 .word L260
355: 353 0002BEF4 #
356: 354 0002BEF4 #
357: 355 0002BEF4 #
358: 356 0002BEF4 #
359: 357 0002BEF4 #
360: 358 0002BEF4 #
361: 359 0002BEF4 # /************************************************************************
362: 360 0002BEF4 # *
363: 361 0002BEF4 # * SUBTEST 3
364: 362 0002BEF4 # * data in registers, 2 NO-OPs
365: 363 0002BEF4 # *
366: 364 0002BEF4 # ************************************************************************/
367: 365 0002BEF4 # pipe8_3()
368: 366 0002BEF4 # {
369: 367 0002BEF4 13 00f6 jbr L262
370: 368 0002BEF7 L263:
371: 369 0002BEF7 # force_loop = FALSE; /* clear force_loop flag */
372: 370 0002BEF7 4d effffffd57 clrl _force_loop
373: 371 0002BEFD # index = 0;
374: 372 0002BEFD 4d effffffd51 clrl _index
375: 373 0002BF03 # do
376: 374 0002BF03 L266:
377: 375 0002BF03 # {
378: 376 0002BF03 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
379: 377 0002BF03 0d effffffd4b 50 movl _index,r0
380: 378 0002BF0A 48 03 50 50 shll $3,r0,r0
381: 379 0002BF0E 0d e000000000 effffffd3b movl _ldf_1_data(r0),_sgl_value_1
382: 380 0002BF19 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
383: 381 0002BF19 0d effffffd35 50 movl _index,r0
384: 382 0002BF20 48 03 50 50 shll $3,r0,r0
385: 383 0002BF24 0d e000000004 effffffd25 movl _ldf_1_data+4(r0),_sgl_expected
386: 384 0002BF2F # sgl_value_2 = 0x40800000; /* floating '1' */
387: 385 0002BF2F 0d 8f40800000 effffffd1a movl $1082130432,_sgl_value_2
388: 386 0002BF3A # sgl_value_3 = 0x41000000; /* floating '2' */
389: 387 0002BF3A 0d 8f41000000 effffffd0f movl $1090519040,_sgl_value_3
390: 388 0002BF45 # /*
391: 389 0002BF45 # * If LOOP ON ERROR is set, this is the loop for this subtest.
392: 390 0002BF45 # * The force loop flag is set after the first error.
393: 391 0002BF45 # */
394: 392 0002BF45 # asm("_pipe8_3_lp1:");
395: 393 0002BF45 _pipe8_3_lp1:
396: 394 0002BF45 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
397: 395 0002BF45 0d effffffd09 54 movl _sgl_value_1,r4
398: 396 0002BF4C # asm("movl _sgl_value_2,r5"); /* move data to r5 */
399: 397 0002BF4C 0d effffffd02 55 movl _sgl_value_2,r5
400: 398 0002BF53 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
401: 399 0002BF53 0d effffffcfb 56 movl _sgl_value_3,r6
402: 400 0002BF5A # asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
403: 401 0002BF5A 06 55 ldf r5
404: 402 0002BF5C # asm("nop");
405: 403 0002BF5C 10 nop
406: 404 0002BF5D # asm("nop");
407: 405 0002BF5D 10 nop
408: 406 0002BF5E # asm("subf r6"); /* minus 2.0 (-1.0 ) */
409: 407 0002BF5E d6 56 subf r6
410: 408 0002BF60 # asm("nop");
411: 409 0002BF60 10 nop
412: 410 0002BF61 # asm("nop");
413: 411 0002BF61 10 nop
414: 412 0002BF62 # asm("mulf r4"); /* *'s the operand ( -op ) */
415: 413 0002BF62 e6 54 mulf r4
416: 414 0002BF64 # asm("nop");
417: 415 0002BF64 10 nop
418: 416 0002BF65 # asm("nop");
419: 417 0002BF65 10 nop
420: 418 0002BF66 # asm("addf r4"); /* + the operand ( 0 ) */
421: 419 0002BF66 c6 54 addf r4
422: 420 0002BF68 # asm("nop");
423: 421 0002BF68 10 nop
424: 422 0002BF69 # asm("nop");
425: 423 0002BF69 10 nop
426: 424 0002BF6A # asm("addf r4"); /* + the operand ( +op ) */
427: 425 0002BF6A c6 54 addf r4
428: 426 0002BF6C # asm("nop");
429: 427 0002BF6C 10 nop
430: 428 0002BF6D # asm("nop");
431: 429 0002BF6D 10 nop
432: 430 0002BF6E # asm("stf r7"); /* store the result */
433: 431 0002BF6E 26 57 stf r7
434: 432 0002BF70 # if( force_loop )
435: 433 0002BF70 5d effffffcde tstl _force_loop
436: 434 0002BF76 31 02 jeql L267
437: 435 0002BF78 # asm("brb _pipe8_3_lp1");; /* loop on the error */
438: 436 0002BF78 11 cb brb _pipe8_3_lp1
439: 437 0002BF7A L267:
440: 438 0002BF7A # /*
441: 439 0002BF7A # * verify the results
442: 440 0002BF7A # */
443: 441 0002BF7A # asm("movl r7,_sgl_st_acc"); /* get the result */
444: 442 0002BF7A 0d 57 effffffcd3 movl r7,_sgl_st_acc
445: 443 0002BF81 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
446: 444 0002BF81 1d effffffccd effffffcc8 cmpl _sgl_st_acc,_sgl_expected
447: 445 0002BF8C 31 45 jeql L268
448: 446 0002BF8E # {
449: 447 0002BF8E # errcnt++; /* bump the error count */
450: 448 0002BF8E 6d effffffcc0 incl _errcnt
451: 449 0002BF94 # if ( prt_error )
452: 450 0002BF94 5d effffffcba tstl _prt_error
453: 451 0002BF9A 31 0d jeql L269
454: 452 0002BF9C # print_pipe8_er("Reg. Data, 2 NO-OPs");
455: 453 0002BF9C .data 1
456: 454 00000d8e * L270:
457: 455 00000d8e * 5265672E20446174612C20322 .ascii "Reg. Data, 2 NO-OPs\0"
458: 04E4F2D4F507300
459: 456 00000da2 * .text
460: 457 0002BF9C dd 8f00000d8e pushl $L270
461: 458 0002BFA2 fe 08 ef00000887 callf $8,_print_pipe8_er
462: 459 0002BFA9 # if ( halt_flg )
463: 460 0002BFA9 L269:
464: 461 0002BFA9 5d effffffca5 tstl _halt_flg
465: 462 0002BFAF 31 0d jeql L271
466: 463 0002BFB1 # pipe8_er_hlt( subtest );
467: 464 0002BFB1 dd effffffc9d pushl _subtest
468: 465 0002BFB7 fe 08 ef0000097e callf $8,_pipe8_er_hlt
469: 466 0002BFBE # if ( loop_on_err ) {
470: 467 0002BFBE L271:
471: 468 0002BFBE 5d effffffc90 tstl _loop_on_err
472: 469 0002BFC4 31 0d jeql L272
473: 470 0002BFC6 # force_loop = TRUE; /* set the force loop flag */
474: 471 0002BFC6 0d 01 effffffc87 movl $1,_force_loop
475: 472 0002BFCD # asm("jmp _pipe8_3_lp1"); /* and loop */
476: 473 0002BFCD 71 efffffff72 jmp _pipe8_3_lp1
477: 474 0002BFD3 # }
478: 475 0002BFD3 # } /* end of compare error */
479: 476 0002BFD3 L272:
480: 477 0002BFD3 # } while( index++ < max_ldf_1_index );
481: 478 0002BFD3 L268:
482: 479 0002BFD3 L265:
483: 480 0002BFD3 0d effffffc7b 50 movl _index,r0
484: 481 0002BFDA 6d effffffc74 incl _index
485: 482 0002BFE0 1d 50 effffffc6d cmpl r0,_max_ldf_1_index
486: 483 0002BFE7 81 03 13 ff17 jlss L266
487: 484 0002BFEC L264:
488: 485 0002BFEC # } /* end of subtest 3 */
489: 486 0002BFEC 40 ret#2
490: 487 0002BFED .set L260,0x0
491: 488 0002BFED L262:
492: 489 0002BFED 13 ff07 jbr L263
493: 490 0002BFF0 .data
494: 491 00000d5c * .text
495: 492 0002BFF0 .align 1
496: 493 0002BFF0 .globl _pipe8_4
497: 494 0002BFF0 _pipe8_4:
498: 495 0002BFF0 0000 .word L273
499: 496 0002BFF2 #
500: 497 0002BFF2 #
501: 498 0002BFF2 #
502: 499 0002BFF2 #
503: 500 0002BFF2 #
504: 501 0002BFF2 #
505: 502 0002BFF2 # /************************************************************************
506: 503 0002BFF2 # *
507: 504 0002BFF2 # * SUBTEST 4
508: 505 0002BFF2 # * data in registers, 3 NO-OPs
509: 506 0002BFF2 # *
510: 507 0002BFF2 # ************************************************************************/
511: 508 0002BFF2 # pipe8_4()
512: 509 0002BFF2 # {
513: 510 0002BFF2 13 00fb jbr L275
514: 511 0002BFF5 L276:
515: 512 0002BFF5 # force_loop = FALSE; /* clear force_loop flag */
516: 513 0002BFF5 4d effffffc59 clrl _force_loop
517: 514 0002BFFB # index = 0;
518: 515 0002BFFB 4d effffffc53 clrl _index
519: 516 0002C001 # do
520: 517 0002C001 L279:
521: 518 0002C001 # {
522: 519 0002C001 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
523: 520 0002C001 0d effffffc4d 50 movl _index,r0
524: 521 0002C008 48 03 50 50 shll $3,r0,r0
525: 522 0002C00C 0d e000000000 effffffc3d movl _ldf_1_data(r0),_sgl_value_1
526: 523 0002C017 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
527: 524 0002C017 0d effffffc37 50 movl _index,r0
528: 525 0002C01E 48 03 50 50 shll $3,r0,r0
529: 526 0002C022 0d e000000004 effffffc27 movl _ldf_1_data+4(r0),_sgl_expected
530: 527 0002C02D # sgl_value_2 = 0x40800000; /* floating '1' */
531: 528 0002C02D 0d 8f40800000 effffffc1c movl $1082130432,_sgl_value_2
532: 529 0002C038 # sgl_value_3 = 0x41000000; /* floating '2' */
533: 530 0002C038 0d 8f41000000 effffffc11 movl $1090519040,_sgl_value_3
534: 531 0002C043 # /*
535: 532 0002C043 # * If LOOP ON ERROR is set, this is the loop for this subtest.
536: 533 0002C043 # * The force loop flag is set after the first error.
537: 534 0002C043 # */
538: 535 0002C043 # asm("_pipe8_4_lp1:");
539: 536 0002C043 _pipe8_4_lp1:
540: 537 0002C043 # asm("movl _sgl_value_1,r4"); /* move the data to r4 */
541: 538 0002C043 0d effffffc0b 54 movl _sgl_value_1,r4
542: 539 0002C04A # asm("movl _sgl_value_2,r5"); /* move data to r5 */
543: 540 0002C04A 0d effffffc04 55 movl _sgl_value_2,r5
544: 541 0002C051 # asm("movl _sgl_value_3,r6"); /* move data to r6 */
545: 542 0002C051 0d effffffbfd 56 movl _sgl_value_3,r6
546: 543 0002C058 # asm("ldf r5"); /* 1.0 to the ACC. ( 1.0 ) */
547: 544 0002C058 06 55 ldf r5
548: 545 0002C05A # asm("nop");
549: 546 0002C05A 10 nop
550: 547 0002C05B # asm("nop");
551: 548 0002C05B 10 nop
552: 549 0002C05C # asm("nop");
553: 550 0002C05C 10 nop
554: 551 0002C05D # asm("subf r6"); /* minus 2.0 (-1.0 ) */
555: 552 0002C05D d6 56 subf r6
556: 553 0002C05F # asm("nop");
557: 554 0002C05F 10 nop
558: 555 0002C060 # asm("nop");
559: 556 0002C060 10 nop
560: 557 0002C061 # asm("nop");
561: 558 0002C061 10 nop
562: 559 0002C062 # asm("mulf r4"); /* *'s the operand ( -op ) */
563: 560 0002C062 e6 54 mulf r4
564: 561 0002C064 # asm("nop");
565: 562 0002C064 10 nop
566: 563 0002C065 # asm("nop");
567: 564 0002C065 10 nop
568: 565 0002C066 # asm("nop");
569: 566 0002C066 10 nop
570: 567 0002C067 # asm("addf r4"); /* + the operand ( 0 ) */
571: 568 0002C067 c6 54 addf r4
572: 569 0002C069 # asm("nop");
573: 570 0002C069 10 nop
574: 571 0002C06A # asm("nop");
575: 572 0002C06A 10 nop
576: 573 0002C06B # asm("nop");
577: 574 0002C06B 10 nop
578: 575 0002C06C # asm("addf r4"); /* + the operand ( +op ) */
579: 576 0002C06C c6 54 addf r4
580: 577 0002C06E # asm("nop");
581: 578 0002C06E 10 nop
582: 579 0002C06F # asm("nop");
583: 580 0002C06F 10 nop
584: 581 0002C070 # asm("nop");
585: 582 0002C070 10 nop
586: 583 0002C071 # asm("stf r7"); /* store the result */
587: 584 0002C071 26 57 stf r7
588: 585 0002C073 # if( force_loop )
589: 586 0002C073 5d effffffbdb tstl _force_loop
590: 587 0002C079 31 02 jeql L280
591: 588 0002C07B # asm("brb _pipe8_4_lp1");; /* loop on the error */
592: 589 0002C07B 11 c6 brb _pipe8_4_lp1
593: 590 0002C07D L280:
594: 591 0002C07D # /*
595: 592 0002C07D # * verify the results
596: 593 0002C07D # */
597: 594 0002C07D # asm("movl r7,_sgl_st_acc"); /* get the result */
598: 595 0002C07D 0d 57 effffffbd0 movl r7,_sgl_st_acc
599: 596 0002C084 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
600: 597 0002C084 1d effffffbca effffffbc5 cmpl _sgl_st_acc,_sgl_expected
601: 598 0002C08F 31 45 jeql L281
602: 599 0002C091 # {
603: 600 0002C091 # errcnt++; /* bump the error count */
604: 601 0002C091 6d effffffbbd incl _errcnt
605: 602 0002C097 # if ( prt_error )
606: 603 0002C097 5d effffffbb7 tstl _prt_error
607: 604 0002C09D 31 0d jeql L282
608: 605 0002C09F # print_pipe8_er("Reg. Data, 3 NO-OPs");
609: 606 0002C09F .data 1
610: 607 00000da2 * L283:
611: 608 00000da2 * 5265672E20446174612C20332 .ascii "Reg. Data, 3 NO-OPs\0"
612: 04E4F2D4F507300
613: 609 00000db6 * .text
614: 610 0002C09F dd 8f00000da2 pushl $L283
615: 611 0002C0A5 fe 08 ef00000784 callf $8,_print_pipe8_er
616: 612 0002C0AC # if ( halt_flg )
617: 613 0002C0AC L282:
618: 614 0002C0AC 5d effffffba2 tstl _halt_flg
619: 615 0002C0B2 31 0d jeql L284
620: 616 0002C0B4 # pipe8_er_hlt( subtest );
621: 617 0002C0B4 dd effffffb9a pushl _subtest
622: 618 0002C0BA fe 08 ef0000087b callf $8,_pipe8_er_hlt
623: 619 0002C0C1 # if ( loop_on_err ) {
624: 620 0002C0C1 L284:
625: 621 0002C0C1 5d effffffb8d tstl _loop_on_err
626: 622 0002C0C7 31 0d jeql L285
627: 623 0002C0C9 # force_loop = TRUE; /* set the force loop flag */
628: 624 0002C0C9 0d 01 effffffb84 movl $1,_force_loop
629: 625 0002C0D0 # asm("jmp _pipe8_4_lp1"); /* and loop */
630: 626 0002C0D0 71 efffffff6d jmp _pipe8_4_lp1
631: 627 0002C0D6 # }
632: 628 0002C0D6 # } /* end of compare error */
633: 629 0002C0D6 L285:
634: 630 0002C0D6 # } while( index++ < max_ldf_1_index );
635: 631 0002C0D6 L281:
636: 632 0002C0D6 L278:
637: 633 0002C0D6 0d effffffb78 50 movl _index,r0
638: 634 0002C0DD 6d effffffb71 incl _index
639: 635 0002C0E3 1d 50 effffffb6a cmpl r0,_max_ldf_1_index
640: 636 0002C0EA 81 03 13 ff12 jlss L279
641: 637 0002C0EF L277:
642: 638 0002C0EF # } /* end of subtest 4 */
643: 639 0002C0EF 40 ret#2
644: 640 0002C0F0 .set L273,0x0
645: 641 0002C0F0 L275:
646: 642 0002C0F0 13 ff02 jbr L276
647: 643 0002C0F3 .data
648: 644 00000d5c * .text
649: 645 0002C0F3 00 .align 1
650: 646 0002C0F4 .globl _pipe8_5
651: 647 0002C0F4 _pipe8_5:
652: 648 0002C0F4 0000 .word L286
653: 649 0002C0F6 #
654: 650 0002C0F6 #
655: 651 0002C0F6 #
656: 652 0002C0F6 #
657: 653 0002C0F6 #
658: 654 0002C0F6 #
659: 655 0002C0F6 #
660: 656 0002C0F6 # /************************************************************************
661: 657 0002C0F6 # *
662: 658 0002C0F6 # * SUBTEST 5
663: 659 0002C0F6 # * data in Cache, no NO-OPs
664: 660 0002C0F6 # *
665: 661 0002C0F6 # ************************************************************************/
666: 662 0002C0F6 # pipe8_5()
667: 663 0002C0F6 # {
668: 664 0002C0F6 13 00e8 jbr L288
669: 665 0002C0F9 L289:
670: 666 0002C0F9 # force_loop = FALSE; /* clear force_loop flag */
671: 667 0002C0F9 4d effffffb55 clrl _force_loop
672: 668 0002C0FF # index = 0;
673: 669 0002C0FF 4d effffffb4f clrl _index
674: 670 0002C105 # do
675: 671 0002C105 L292:
676: 672 0002C105 # {
677: 673 0002C105 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
678: 674 0002C105 0d effffffb49 50 movl _index,r0
679: 675 0002C10C 48 03 50 50 shll $3,r0,r0
680: 676 0002C110 0d e000000000 effffffb39 movl _ldf_1_data(r0),_sgl_value_1
681: 677 0002C11B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
682: 678 0002C11B 0d effffffb33 50 movl _index,r0
683: 679 0002C122 48 03 50 50 shll $3,r0,r0
684: 680 0002C126 0d e000000004 effffffb23 movl _ldf_1_data+4(r0),_sgl_expected
685: 681 0002C131 # sgl_value_2 = 0x40800000; /* floating '1' */
686: 682 0002C131 0d 8f40800000 effffffb18 movl $1082130432,_sgl_value_2
687: 683 0002C13C # sgl_value_3 = 0x41000000; /* floating '2' */
688: 684 0002C13C 0d 8f41000000 effffffb0d movl $1090519040,_sgl_value_3
689: 685 0002C147 # /*
690: 686 0002C147 # * If LOOP ON ERROR is set, this is the loop for this subtest.
691: 687 0002C147 # * The force loop flag is set after the first error.
692: 688 0002C147 # */
693: 689 0002C147 # asm("_pipe8_5_lp1:");
694: 690 0002C147 _pipe8_5_lp1:
695: 691 0002C147 # asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
696: 692 0002C147 06 effffffb07 ldf _sgl_value_2
697: 693 0002C14D # asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
698: 694 0002C14D d6 effffffb01 subf _sgl_value_3
699: 695 0002C153 # asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
700: 696 0002C153 e6 effffffafb mulf _sgl_value_1
701: 697 0002C159 # asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
702: 698 0002C159 c6 effffffaf5 addf _sgl_value_1
703: 699 0002C15F # asm("addf _sgl_value_1"); /* + the operand ( +op ) */
704: 700 0002C15F c6 effffffaef addf _sgl_value_1
705: 701 0002C165 # asm("stf _sgl_st_acc"); /* store the result */
706: 702 0002C165 26 effffffae9 stf _sgl_st_acc
707: 703 0002C16B # if( force_loop )
708: 704 0002C16B 5d effffffae3 tstl _force_loop
709: 705 0002C171 31 02 jeql L293
710: 706 0002C173 # asm("brb _pipe8_5_lp1");; /* loop on the error */
711: 707 0002C173 11 d2 brb _pipe8_5_lp1
712: 708 0002C175 L293:
713: 709 0002C175 # /*
714: 710 0002C175 # * verify the results
715: 711 0002C175 # */
716: 712 0002C175 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
717: 713 0002C175 1d effffffad9 effffffad4 cmpl _sgl_st_acc,_sgl_expected
718: 714 0002C180 31 45 jeql L294
719: 715 0002C182 # {
720: 716 0002C182 # errcnt++; /* bump the error count */
721: 717 0002C182 6d effffffacc incl _errcnt
722: 718 0002C188 # if ( prt_error )
723: 719 0002C188 5d effffffac6 tstl _prt_error
724: 720 0002C18E 31 0d jeql L295
725: 721 0002C190 # print_pipe8_er("Cache Data, no NO-OPs");
726: 722 0002C190 .data 1
727: 723 00000db6 * L296:
728: 724 00000db6 * 436163686520446174612C206 .ascii "Cache Data, no NO-OPs\0"
729: E6F204E4F2D4F507300
730: 725 00000dcc * .text
731: 726 0002C190 dd 8f00000db6 pushl $L296
732: 727 0002C196 fe 08 ef00000693 callf $8,_print_pipe8_er
733: 728 0002C19D # if ( halt_flg )
734: 729 0002C19D L295:
735: 730 0002C19D 5d effffffab1 tstl _halt_flg
736: 731 0002C1A3 31 0d jeql L297
737: 732 0002C1A5 # pipe8_er_hlt( subtest );
738: 733 0002C1A5 dd effffffaa9 pushl _subtest
739: 734 0002C1AB fe 08 ef0000078a callf $8,_pipe8_er_hlt
740: 735 0002C1B2 # if ( loop_on_err ) {
741: 736 0002C1B2 L297:
742: 737 0002C1B2 5d effffffa9c tstl _loop_on_err
743: 738 0002C1B8 31 0d jeql L298
744: 739 0002C1BA # force_loop = TRUE; /* set the force loop flag */
745: 740 0002C1BA 0d 01 effffffa93 movl $1,_force_loop
746: 741 0002C1C1 # asm("jmp _pipe8_5_lp1"); /* and loop */
747: 742 0002C1C1 71 efffffff80 jmp _pipe8_5_lp1
748: 743 0002C1C7 # }
749: 744 0002C1C7 # } /* end of compare error */
750: 745 0002C1C7 L298:
751: 746 0002C1C7 # } while( index++ < max_ldf_1_index );
752: 747 0002C1C7 L294:
753: 748 0002C1C7 L291:
754: 749 0002C1C7 0d effffffa87 50 movl _index,r0
755: 750 0002C1CE 6d effffffa80 incl _index
756: 751 0002C1D4 1d 50 effffffa79 cmpl r0,_max_ldf_1_index
757: 752 0002C1DB 81 03 13 ff25 jlss L292
758: 753 0002C1E0 L290:
759: 754 0002C1E0 # } /* end of subtest 5 */
760: 755 0002C1E0 40 ret#2
761: 756 0002C1E1 .set L286,0x0
762: 757 0002C1E1 L288:
763: 758 0002C1E1 13 ff15 jbr L289
764: 759 0002C1E4 .data
765: 760 00000d5c * .text
766: 761 0002C1E4 .align 1
767: 762 0002C1E4 .globl _pipe8_6
768: 763 0002C1E4 _pipe8_6:
769: 764 0002C1E4 0000 .word L299
770: 765 0002C1E6 #
771: 766 0002C1E6 #
772: 767 0002C1E6 #
773: 768 0002C1E6 #
774: 769 0002C1E6 #
775: 770 0002C1E6 #
776: 771 0002C1E6 # /************************************************************************
777: 772 0002C1E6 # *
778: 773 0002C1E6 # * SUBTEST 6
779: 774 0002C1E6 # * data in Cache, 1 NO-OP
780: 775 0002C1E6 # *
781: 776 0002C1E6 # ************************************************************************/
782: 777 0002C1E6 # pipe8_6()
783: 778 0002C1E6 # {
784: 779 0002C1E6 13 00ed jbr L301
785: 780 0002C1E9 L302:
786: 781 0002C1E9 # force_loop = FALSE; /* clear force_loop flag */
787: 782 0002C1E9 4d effffffa65 clrl _force_loop
788: 783 0002C1EF # index = 0;
789: 784 0002C1EF 4d effffffa5f clrl _index
790: 785 0002C1F5 # do
791: 786 0002C1F5 L305:
792: 787 0002C1F5 # {
793: 788 0002C1F5 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
794: 789 0002C1F5 0d effffffa59 50 movl _index,r0
795: 790 0002C1FC 48 03 50 50 shll $3,r0,r0
796: 791 0002C200 0d e000000000 effffffa49 movl _ldf_1_data(r0),_sgl_value_1
797: 792 0002C20B # sgl_expected = ldf_1_data[index].exp; /* get expected results */
798: 793 0002C20B 0d effffffa43 50 movl _index,r0
799: 794 0002C212 48 03 50 50 shll $3,r0,r0
800: 795 0002C216 0d e000000004 effffffa33 movl _ldf_1_data+4(r0),_sgl_expected
801: 796 0002C221 # sgl_value_2 = 0x40800000; /* floating '1' */
802: 797 0002C221 0d 8f40800000 effffffa28 movl $1082130432,_sgl_value_2
803: 798 0002C22C # sgl_value_3 = 0x41000000; /* floating '2' */
804: 799 0002C22C 0d 8f41000000 effffffa1d movl $1090519040,_sgl_value_3
805: 800 0002C237 # /*
806: 801 0002C237 # * If LOOP ON ERROR is set, this is the loop for this subtest.
807: 802 0002C237 # * The force loop flag is set after the first error.
808: 803 0002C237 # */
809: 804 0002C237 # asm("_pipe8_6_lp1:");
810: 805 0002C237 _pipe8_6_lp1:
811: 806 0002C237 # asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
812: 807 0002C237 06 effffffa17 ldf _sgl_value_2
813: 808 0002C23D # asm("nop");
814: 809 0002C23D 10 nop
815: 810 0002C23E # asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
816: 811 0002C23E d6 effffffa10 subf _sgl_value_3
817: 812 0002C244 # asm("nop");
818: 813 0002C244 10 nop
819: 814 0002C245 # asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
820: 815 0002C245 e6 effffffa09 mulf _sgl_value_1
821: 816 0002C24B # asm("nop");
822: 817 0002C24B 10 nop
823: 818 0002C24C # asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
824: 819 0002C24C c6 effffffa02 addf _sgl_value_1
825: 820 0002C252 # asm("nop");
826: 821 0002C252 10 nop
827: 822 0002C253 # asm("addf _sgl_value_1"); /* + the operand ( +op ) */
828: 823 0002C253 c6 effffff9fb addf _sgl_value_1
829: 824 0002C259 # asm("nop");
830: 825 0002C259 10 nop
831: 826 0002C25A # asm("stf _sgl_st_acc"); /* store the result */
832: 827 0002C25A 26 effffff9f4 stf _sgl_st_acc
833: 828 0002C260 # if( force_loop )
834: 829 0002C260 5d effffff9ee tstl _force_loop
835: 830 0002C266 31 02 jeql L306
836: 831 0002C268 # asm("brb _pipe8_6_lp1");; /* loop on the error */
837: 832 0002C268 11 cd brb _pipe8_6_lp1
838: 833 0002C26A L306:
839: 834 0002C26A # /*
840: 835 0002C26A # * verify the results
841: 836 0002C26A # */
842: 837 0002C26A # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
843: 838 0002C26A 1d effffff9e4 effffff9df cmpl _sgl_st_acc,_sgl_expected
844: 839 0002C275 31 45 jeql L307
845: 840 0002C277 # {
846: 841 0002C277 # errcnt++; /* bump the error count */
847: 842 0002C277 6d effffff9d7 incl _errcnt
848: 843 0002C27D # if ( prt_error )
849: 844 0002C27D 5d effffff9d1 tstl _prt_error
850: 845 0002C283 31 0d jeql L308
851: 846 0002C285 # print_pipe8_er("Cache Data, 1 NO-OP");
852: 847 0002C285 .data 1
853: 848 00000dcc * L309:
854: 849 00000dcc * 436163686520446174612C203 .ascii "Cache Data, 1 NO-OP\0"
855: 1204E4F2D4F5000
856: 850 00000de0 * .text
857: 851 0002C285 dd 8f00000dcc pushl $L309
858: 852 0002C28B fe 08 ef0000059e callf $8,_print_pipe8_er
859: 853 0002C292 # if ( halt_flg )
860: 854 0002C292 L308:
861: 855 0002C292 5d effffff9bc tstl _halt_flg
862: 856 0002C298 31 0d jeql L310
863: 857 0002C29A # pipe8_er_hlt( subtest );
864: 858 0002C29A dd effffff9b4 pushl _subtest
865: 859 0002C2A0 fe 08 ef00000695 callf $8,_pipe8_er_hlt
866: 860 0002C2A7 # if ( loop_on_err ) {
867: 861 0002C2A7 L310:
868: 862 0002C2A7 5d effffff9a7 tstl _loop_on_err
869: 863 0002C2AD 31 0d jeql L311
870: 864 0002C2AF # force_loop = TRUE; /* set the force loop flag */
871: 865 0002C2AF 0d 01 effffff99e movl $1,_force_loop
872: 866 0002C2B6 # asm("jmp _pipe8_6_lp1"); /* and loop */
873: 867 0002C2B6 71 efffffff7b jmp _pipe8_6_lp1
874: 868 0002C2BC # }
875: 869 0002C2BC # } /* end of compare error */
876: 870 0002C2BC L311:
877: 871 0002C2BC # } while( index++ < max_ldf_1_index );
878: 872 0002C2BC L307:
879: 873 0002C2BC L304:
880: 874 0002C2BC 0d effffff992 50 movl _index,r0
881: 875 0002C2C3 6d effffff98b incl _index
882: 876 0002C2C9 1d 50 effffff984 cmpl r0,_max_ldf_1_index
883: 877 0002C2D0 81 03 13 ff20 jlss L305
884: 878 0002C2D5 L303:
885: 879 0002C2D5 # } /* end of subtest 6 */
886: 880 0002C2D5 40 ret#2
887: 881 0002C2D6 .set L299,0x0
888: 882 0002C2D6 L301:
889: 883 0002C2D6 13 ff10 jbr L302
890: 884 0002C2D9 .data
891: 885 00000d5c * .text
892: 886 0002C2D9 00 .align 1
893: 887 0002C2DA .globl _pipe8_7
894: 888 0002C2DA _pipe8_7:
895: 889 0002C2DA 0000 .word L312
896: 890 0002C2DC #
897: 891 0002C2DC #
898: 892 0002C2DC #
899: 893 0002C2DC #
900: 894 0002C2DC #
901: 895 0002C2DC #
902: 896 0002C2DC # /************************************************************************
903: 897 0002C2DC # *
904: 898 0002C2DC # * SUBTEST 7
905: 899 0002C2DC # * data in Cache, 2 NO-OPs
906: 900 0002C2DC # *
907: 901 0002C2DC # ************************************************************************/
908: 902 0002C2DC # pipe8_7()
909: 903 0002C2DC # {
910: 904 0002C2DC 13 00f2 jbr L314
911: 905 0002C2DF L315:
912: 906 0002C2DF # force_loop = FALSE; /* clear force_loop flag */
913: 907 0002C2DF 4d effffff96f clrl _force_loop
914: 908 0002C2E5 # index = 0;
915: 909 0002C2E5 4d effffff969 clrl _index
916: 910 0002C2EB # do
917: 911 0002C2EB L318:
918: 912 0002C2EB # {
919: 913 0002C2EB # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
920: 914 0002C2EB 0d effffff963 50 movl _index,r0
921: 915 0002C2F2 48 03 50 50 shll $3,r0,r0
922: 916 0002C2F6 0d e000000000 effffff953 movl _ldf_1_data(r0),_sgl_value_1
923: 917 0002C301 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
924: 918 0002C301 0d effffff94d 50 movl _index,r0
925: 919 0002C308 48 03 50 50 shll $3,r0,r0
926: 920 0002C30C 0d e000000004 effffff93d movl _ldf_1_data+4(r0),_sgl_expected
927: 921 0002C317 # sgl_value_2 = 0x40800000; /* floating '1' */
928: 922 0002C317 0d 8f40800000 effffff932 movl $1082130432,_sgl_value_2
929: 923 0002C322 # sgl_value_3 = 0x41000000; /* floating '2' */
930: 924 0002C322 0d 8f41000000 effffff927 movl $1090519040,_sgl_value_3
931: 925 0002C32D # /*
932: 926 0002C32D # * If LOOP ON ERROR is set, this is the loop for this subtest.
933: 927 0002C32D # * The force loop flag is set after the first error.
934: 928 0002C32D # */
935: 929 0002C32D # asm("_pipe8_7_lp1:");
936: 930 0002C32D _pipe8_7_lp1:
937: 931 0002C32D # asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
938: 932 0002C32D 06 effffff921 ldf _sgl_value_2
939: 933 0002C333 # asm("nop");
940: 934 0002C333 10 nop
941: 935 0002C334 # asm("nop");
942: 936 0002C334 10 nop
943: 937 0002C335 # asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
944: 938 0002C335 d6 effffff919 subf _sgl_value_3
945: 939 0002C33B # asm("nop");
946: 940 0002C33B 10 nop
947: 941 0002C33C # asm("nop");
948: 942 0002C33C 10 nop
949: 943 0002C33D # asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
950: 944 0002C33D e6 effffff911 mulf _sgl_value_1
951: 945 0002C343 # asm("nop");
952: 946 0002C343 10 nop
953: 947 0002C344 # asm("nop");
954: 948 0002C344 10 nop
955: 949 0002C345 # asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
956: 950 0002C345 c6 effffff909 addf _sgl_value_1
957: 951 0002C34B # asm("nop");
958: 952 0002C34B 10 nop
959: 953 0002C34C # asm("nop");
960: 954 0002C34C 10 nop
961: 955 0002C34D # asm("addf _sgl_value_1"); /* + the operand ( +op ) */
962: 956 0002C34D c6 effffff901 addf _sgl_value_1
963: 957 0002C353 # asm("nop");
964: 958 0002C353 10 nop
965: 959 0002C354 # asm("nop");
966: 960 0002C354 10 nop
967: 961 0002C355 # asm("stf _sgl_st_acc"); /* store the result */
968: 962 0002C355 26 effffff8f9 stf _sgl_st_acc
969: 963 0002C35B # if( force_loop )
970: 964 0002C35B 5d effffff8f3 tstl _force_loop
971: 965 0002C361 31 02 jeql L319
972: 966 0002C363 # asm("brb _pipe8_7_lp1");; /* loop on the error */
973: 967 0002C363 11 c8 brb _pipe8_7_lp1
974: 968 0002C365 L319:
975: 969 0002C365 # /*
976: 970 0002C365 # * verify the results
977: 971 0002C365 # */
978: 972 0002C365 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
979: 973 0002C365 1d effffff8e9 effffff8e4 cmpl _sgl_st_acc,_sgl_expected
980: 974 0002C370 31 45 jeql L320
981: 975 0002C372 # {
982: 976 0002C372 # errcnt++; /* bump the error count */
983: 977 0002C372 6d effffff8dc incl _errcnt
984: 978 0002C378 # if ( prt_error )
985: 979 0002C378 5d effffff8d6 tstl _prt_error
986: 980 0002C37E 31 0d jeql L321
987: 981 0002C380 # print_pipe8_er("Cache Data, 2 NO-OPs");
988: 982 0002C380 .data 1
989: 983 00000de0 * L322:
990: 984 00000de0 * 436163686520446174612C203 .ascii "Cache Data, 2 NO-OPs\0"
991: 2204E4F2D4F507300
992: 985 00000df5 * .text
993: 986 0002C380 dd 8f00000de0 pushl $L322
994: 987 0002C386 fe 08 ef000004a3 callf $8,_print_pipe8_er
995: 988 0002C38D # if ( halt_flg )
996: 989 0002C38D L321:
997: 990 0002C38D 5d effffff8c1 tstl _halt_flg
998: 991 0002C393 31 0d jeql L323
999: 992 0002C395 # pipe8_er_hlt( subtest );
1000: 993 0002C395 dd effffff8b9 pushl _subtest
1001: 994 0002C39B fe 08 ef0000059a callf $8,_pipe8_er_hlt
1002: 995 0002C3A2 # if ( loop_on_err ) {
1003: 996 0002C3A2 L323:
1004: 997 0002C3A2 5d effffff8ac tstl _loop_on_err
1005: 998 0002C3A8 31 0d jeql L324
1006: 999 0002C3AA # force_loop = TRUE; /* set the force loop flag */
1007: 1000 0002C3AA 0d 01 effffff8a3 movl $1,_force_loop
1008: 1001 0002C3B1 # asm("jmp _pipe8_7_lp1"); /* and loop */
1009: 1002 0002C3B1 71 efffffff76 jmp _pipe8_7_lp1
1010: 1003 0002C3B7 # }
1011: 1004 0002C3B7 # } /* end of compare error */
1012: 1005 0002C3B7 L324:
1013: 1006 0002C3B7 # } while( index++ < max_ldf_1_index );
1014: 1007 0002C3B7 L320:
1015: 1008 0002C3B7 L317:
1016: 1009 0002C3B7 0d effffff897 50 movl _index,r0
1017: 1010 0002C3BE 6d effffff890 incl _index
1018: 1011 0002C3C4 1d 50 effffff889 cmpl r0,_max_ldf_1_index
1019: 1012 0002C3CB 81 03 13 ff1b jlss L318
1020: 1013 0002C3D0 L316:
1021: 1014 0002C3D0 # } /* end of subtest 7 */
1022: 1015 0002C3D0 40 ret#2
1023: 1016 0002C3D1 .set L312,0x0
1024: 1017 0002C3D1 L314:
1025: 1018 0002C3D1 13 ff0b jbr L315
1026: 1019 0002C3D4 .data
1027: 1020 00000d5c * .text
1028: 1021 0002C3D4 .align 1
1029: 1022 0002C3D4 .globl _pipe8_8
1030: 1023 0002C3D4 _pipe8_8:
1031: 1024 0002C3D4 0000 .word L325
1032: 1025 0002C3D6 #
1033: 1026 0002C3D6 #
1034: 1027 0002C3D6 #
1035: 1028 0002C3D6 #
1036: 1029 0002C3D6 #
1037: 1030 0002C3D6 #
1038: 1031 0002C3D6 # /************************************************************************
1039: 1032 0002C3D6 # *
1040: 1033 0002C3D6 # * SUBTEST 8
1041: 1034 0002C3D6 # * data in Cache, 3 NO-OPs
1042: 1035 0002C3D6 # *
1043: 1036 0002C3D6 # ************************************************************************/
1044: 1037 0002C3D6 # pipe8_8()
1045: 1038 0002C3D6 # {
1046: 1039 0002C3D6 13 00f7 jbr L327
1047: 1040 0002C3D9 L328:
1048: 1041 0002C3D9 # force_loop = FALSE; /* clear force_loop flag */
1049: 1042 0002C3D9 4d effffff875 clrl _force_loop
1050: 1043 0002C3DF # index = 0;
1051: 1044 0002C3DF 4d effffff86f clrl _index
1052: 1045 0002C3E5 # do
1053: 1046 0002C3E5 L331:
1054: 1047 0002C3E5 # {
1055: 1048 0002C3E5 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1056: 1049 0002C3E5 0d effffff869 50 movl _index,r0
1057: 1050 0002C3EC 48 03 50 50 shll $3,r0,r0
1058: 1051 0002C3F0 0d e000000000 effffff859 movl _ldf_1_data(r0),_sgl_value_1
1059: 1052 0002C3FB # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1060: 1053 0002C3FB 0d effffff853 50 movl _index,r0
1061: 1054 0002C402 48 03 50 50 shll $3,r0,r0
1062: 1055 0002C406 0d e000000004 effffff843 movl _ldf_1_data+4(r0),_sgl_expected
1063: 1056 0002C411 # sgl_value_2 = 0x40800000; /* floating '1' */
1064: 1057 0002C411 0d 8f40800000 effffff838 movl $1082130432,_sgl_value_2
1065: 1058 0002C41C # sgl_value_3 = 0x41000000; /* floating '2' */
1066: 1059 0002C41C 0d 8f41000000 effffff82d movl $1090519040,_sgl_value_3
1067: 1060 0002C427 # /*
1068: 1061 0002C427 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1069: 1062 0002C427 # * The force loop flag is set after the first error.
1070: 1063 0002C427 # */
1071: 1064 0002C427 # asm("_pipe8_8_lp1:");
1072: 1065 0002C427 _pipe8_8_lp1:
1073: 1066 0002C427 # asm("ldf _sgl_value_2"); /* 1.0 to the ACC. ( 1.0 ) */
1074: 1067 0002C427 06 effffff827 ldf _sgl_value_2
1075: 1068 0002C42D # asm("nop");
1076: 1069 0002C42D 10 nop
1077: 1070 0002C42E # asm("nop");
1078: 1071 0002C42E 10 nop
1079: 1072 0002C42F # asm("nop");
1080: 1073 0002C42F 10 nop
1081: 1074 0002C430 # asm("subf _sgl_value_3"); /* minus 2.0 (-1.0 ) */
1082: 1075 0002C430 d6 effffff81e subf _sgl_value_3
1083: 1076 0002C436 # asm("nop");
1084: 1077 0002C436 10 nop
1085: 1078 0002C437 # asm("nop");
1086: 1079 0002C437 10 nop
1087: 1080 0002C438 # asm("nop");
1088: 1081 0002C438 10 nop
1089: 1082 0002C439 # asm("mulf _sgl_value_1"); /* *'s the operand ( -op ) */
1090: 1083 0002C439 e6 effffff815 mulf _sgl_value_1
1091: 1084 0002C43F # asm("nop");
1092: 1085 0002C43F 10 nop
1093: 1086 0002C440 # asm("nop");
1094: 1087 0002C440 10 nop
1095: 1088 0002C441 # asm("nop");
1096: 1089 0002C441 10 nop
1097: 1090 0002C442 # asm("addf _sgl_value_1"); /* + the operand ( 0 ) */
1098: 1091 0002C442 c6 effffff80c addf _sgl_value_1
1099: 1092 0002C448 # asm("nop");
1100: 1093 0002C448 10 nop
1101: 1094 0002C449 # asm("nop");
1102: 1095 0002C449 10 nop
1103: 1096 0002C44A # asm("nop");
1104: 1097 0002C44A 10 nop
1105: 1098 0002C44B # asm("addf _sgl_value_1"); /* + the operand ( +op ) */
1106: 1099 0002C44B c6 effffff803 addf _sgl_value_1
1107: 1100 0002C451 # asm("nop");
1108: 1101 0002C451 10 nop
1109: 1102 0002C452 # asm("nop");
1110: 1103 0002C452 10 nop
1111: 1104 0002C453 # asm("nop");
1112: 1105 0002C453 10 nop
1113: 1106 0002C454 # asm("stf _sgl_st_acc"); /* store the result */
1114: 1107 0002C454 26 effffff7fa stf _sgl_st_acc
1115: 1108 0002C45A # if( force_loop )
1116: 1109 0002C45A 5d effffff7f4 tstl _force_loop
1117: 1110 0002C460 31 02 jeql L332
1118: 1111 0002C462 # asm("brb _pipe8_8_lp1");; /* loop on the error */
1119: 1112 0002C462 11 c3 brb _pipe8_8_lp1
1120: 1113 0002C464 L332:
1121: 1114 0002C464 # /*
1122: 1115 0002C464 # * verify the results
1123: 1116 0002C464 # */
1124: 1117 0002C464 # if( sgl_st_acc != sgl_expected ) /* COMPARE the values */
1125: 1118 0002C464 1d effffff7ea effffff7e5 cmpl _sgl_st_acc,_sgl_expected
1126: 1119 0002C46F 31 45 jeql L333
1127: 1120 0002C471 # {
1128: 1121 0002C471 # errcnt++; /* bump the error count */
1129: 1122 0002C471 6d effffff7dd incl _errcnt
1130: 1123 0002C477 # if ( prt_error )
1131: 1124 0002C477 5d effffff7d7 tstl _prt_error
1132: 1125 0002C47D 31 0d jeql L334
1133: 1126 0002C47F # print_pipe8_er("Cache Data, 3 NO-OPs");
1134: 1127 0002C47F .data 1
1135: 1128 00000df5 * L335:
1136: 1129 00000df5 * 436163686520446174612C203 .ascii "Cache Data, 3 NO-OPs\0"
1137: 3204E4F2D4F507300
1138: 1130 00000e0a * .text
1139: 1131 0002C47F dd 8f00000df5 pushl $L335
1140: 1132 0002C485 fe 08 ef000003a4 callf $8,_print_pipe8_er
1141: 1133 0002C48C # if ( halt_flg )
1142: 1134 0002C48C L334:
1143: 1135 0002C48C 5d effffff7c2 tstl _halt_flg
1144: 1136 0002C492 31 0d jeql L336
1145: 1137 0002C494 # pipe8_er_hlt( subtest );
1146: 1138 0002C494 dd effffff7ba pushl _subtest
1147: 1139 0002C49A fe 08 ef0000049b callf $8,_pipe8_er_hlt
1148: 1140 0002C4A1 # if ( loop_on_err ) {
1149: 1141 0002C4A1 L336:
1150: 1142 0002C4A1 5d effffff7ad tstl _loop_on_err
1151: 1143 0002C4A7 31 0d jeql L337
1152: 1144 0002C4A9 # force_loop = TRUE; /* set the force loop flag */
1153: 1145 0002C4A9 0d 01 effffff7a4 movl $1,_force_loop
1154: 1146 0002C4B0 # asm("jmp _pipe8_8_lp1"); /* and loop */
1155: 1147 0002C4B0 71 efffffff71 jmp _pipe8_8_lp1
1156: 1148 0002C4B6 # }
1157: 1149 0002C4B6 # } /* end of compare error */
1158: 1150 0002C4B6 L337:
1159: 1151 0002C4B6 # } while( index++ < max_ldf_1_index );
1160: 1152 0002C4B6 L333:
1161: 1153 0002C4B6 L330:
1162: 1154 0002C4B6 0d effffff798 50 movl _index,r0
1163: 1155 0002C4BD 6d effffff791 incl _index
1164: 1156 0002C4C3 1d 50 effffff78a cmpl r0,_max_ldf_1_index
1165: 1157 0002C4CA 81 03 13 ff16 jlss L331
1166: 1158 0002C4CF L329:
1167: 1159 0002C4CF # } /* end of subtest 8 */
1168: 1160 0002C4CF 40 ret#2
1169: 1161 0002C4D0 .set L325,0x0
1170: 1162 0002C4D0 L327:
1171: 1163 0002C4D0 13 ff06 jbr L328
1172: 1164 0002C4D3 .data
1173: 1165 00000d5c * .text
1174: 1166 0002C4D3 00 .align 1
1175: 1167 0002C4D4 .globl _pipe8_9
1176: 1168 0002C4D4 _pipe8_9:
1177: 1169 0002C4D4 0000 .word L338
1178: 1170 0002C4D6 #
1179: 1171 0002C4D6 #
1180: 1172 0002C4D6 #
1181: 1173 0002C4D6 #
1182: 1174 0002C4D6 #
1183: 1175 0002C4D6 #
1184: 1176 0002C4D6 # /*****************************************************************************
1185: 1177 0002C4D6 # *
1186: 1178 0002C4D6 # * SUBTEST 9
1187: 1179 0002C4D6 # * data on the stack, no NO-OPs
1188: 1180 0002C4D6 # *
1189: 1181 0002C4D6 # *****************************************************************************/
1190: 1182 0002C4D6 # pipe8_9()
1191: 1183 0002C4D6 # {
1192: 1184 0002C4D6 13 018e jbr L340
1193: 1185 0002C4D9 L341:
1194: 1186 0002C4D9 # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1195: 1187 0002C4D9 ed 6d effffff774 moval (r13),_pre_event_fp
1196: 1188 0002C4E0 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1197: 1189 0002C4E0 ed 6e effffff76d moval (r14),_pre_event_sp
1198: 1190 0002C4E7 # force_loop = FALSE; /* clear force_loop flag */
1199: 1191 0002C4E7 4d effffff767 clrl _force_loop
1200: 1192 0002C4ED # index = 0;
1201: 1193 0002C4ED 4d effffff761 clrl _index
1202: 1194 0002C4F3 # do
1203: 1195 0002C4F3 L344:
1204: 1196 0002C4F3 # {
1205: 1197 0002C4F3 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1206: 1198 0002C4F3 0d effffff75b 50 movl _index,r0
1207: 1199 0002C4FA 48 03 50 50 shll $3,r0,r0
1208: 1200 0002C4FE 0d e000000000 effffff74b movl _ldf_1_data(r0),_sgl_value_1
1209: 1201 0002C509 # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1210: 1202 0002C509 0d effffff745 50 movl _index,r0
1211: 1203 0002C510 48 03 50 50 shll $3,r0,r0
1212: 1204 0002C514 0d e000000004 effffff735 movl _ldf_1_data+4(r0),_sgl_expected
1213: 1205 0002C51F # sgl_value_2 = 0x40800000; /* floating '1' */
1214: 1206 0002C51F 0d 8f40800000 effffff72a movl $1082130432,_sgl_value_2
1215: 1207 0002C52A # sgl_value_3 = 0x41000000; /* floating '2' */
1216: 1208 0002C52A 0d 8f41000000 effffff71f movl $1090519040,_sgl_value_3
1217: 1209 0002C535 # asm("moval _pointer_data,_sgl_value_4");/* init / final SP value */
1218: 1210 0002C535 ed effffff719 effffff714 moval _pointer_data,_sgl_value_4
1219: 1211 0002C540 # /*
1220: 1212 0002C540 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1221: 1213 0002C540 # * The force loop flag is set after the first error.
1222: 1214 0002C540 # */
1223: 1215 0002C540 # asm("_pipe8_9_lp1:");
1224: 1216 0002C540 _pipe8_9_lp1:
1225: 1217 0002C540 # asm("moval _pointer_data,r14"); /* set the stack pointer */
1226: 1218 0002C540 ed effffff70e 5e moval _pointer_data,r14
1227: 1219 0002C547 # asm("movl _sgl_value_1,-(r14)"); /* push the operand */
1228: 1220 0002C547 0d effffff707 7e movl _sgl_value_1,-(r14)
1229: 1221 0002C54E # asm("movl _sgl_value_1,-(r14)"); /* onto the stack */
1230: 1222 0002C54E 0d effffff700 7e movl _sgl_value_1,-(r14)
1231: 1223 0002C555 # asm("movl _sgl_value_1,-(r14)"); /* 3 times */
1232: 1224 0002C555 0d effffff6f9 7e movl _sgl_value_1,-(r14)
1233: 1225 0002C55C # asm("movl _sgl_value_3,-(r14)"); /* push a '2' on the stack */
1234: 1226 0002C55C 0d effffff6f2 7e movl _sgl_value_3,-(r14)
1235: 1227 0002C563 # asm("movl _sgl_value_2,-(r14)"); /* push a '1' on the stack */
1236: 1228 0002C563 0d effffff6eb 7e movl _sgl_value_2,-(r14)
1237: 1229 0002C56A # /*
1238: 1230 0002C56A # * now pop the data off the stack
1239: 1231 0002C56A # */
1240: 1232 0002C56A # asm("ldf (r14)+"); /* 1.0 to the ACC. ( 1.0 ) */
1241: 1233 0002C56A 06 8e ldf (r14)+
1242: 1234 0002C56C # asm("subf (r14)+"); /* minus 2.0 (-1.0 ) */
1243: 1235 0002C56C d6 8e subf (r14)+
1244: 1236 0002C56E # asm("mulf (r14)+"); /* *'s the operand ( -op ) */
1245: 1237 0002C56E e6 8e mulf (r14)+
1246: 1238 0002C570 # asm("addf (r14)+"); /* + the operand ( 0 ) */
1247: 1239 0002C570 c6 8e addf (r14)+
1248: 1240 0002C572 # asm("addf (r14)+"); /* + the operand ( +op ) */
1249: 1241 0002C572 c6 8e addf (r14)+
1250: 1242 0002C574 # asm("stf r5"); /* store the result */
1251: 1243 0002C574 26 55 stf r5
1252: 1244 0002C576 # if( force_loop )
1253: 1245 0002C576 5d effffff6d8 tstl _force_loop
1254: 1246 0002C57C 31 02 jeql L345
1255: 1247 0002C57E # asm("brb _pipe8_9_lp1");; /* loop on the error */
1256: 1248 0002C57E 11 c0 brb _pipe8_9_lp1
1257: 1249 0002C580 L345:
1258: 1250 0002C580 # /*
1259: 1251 0002C580 # * verify the results
1260: 1252 0002C580 # */
1261: 1253 0002C580 # asm("movl r5,_sgl_st_acc"); /* get the result */
1262: 1254 0002C580 0d 55 effffff6cd movl r5,_sgl_st_acc
1263: 1255 0002C587 # asm("moval (r14),_sgl_value_5"); /* save the stack pointer */
1264: 1256 0002C587 ed 6e effffff6c6 moval (r14),_sgl_value_5
1265: 1257 0002C58E # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1266: 1258 0002C58E # (sgl_value_5 != sgl_value_4) ) /* ... and the final SP */
1267: 1259 0002C58E 1d effffff6c0 effffff6bb cmpl _sgl_st_acc,_sgl_expected
1268: 1260 0002C599 21 10 jneq L9999
1269: 1261 0002C59B 1d effffff6b3 effffff6ae cmpl _sgl_value_5,_sgl_value_4
1270: 1262 0002C5A6 21 03 13 0094 jeql L346
1271: 1263 0002C5AB L9999:
1272: 1264 0002C5AB # {
1273: 1265 0002C5AB # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1274: 1266 0002C5AB 0d effffff6a3 5d movl _pre_event_fp,r13
1275: 1267 0002C5B2 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1276: 1268 0002C5B2 0d effffff69c 5e movl _pre_event_sp,r14
1277: 1269 0002C5B9 # errcnt++; /* bump the error count */
1278: 1270 0002C5B9 6d effffff695 incl _errcnt
1279: 1271 0002C5BF # if ( prt_error ) {
1280: 1272 0002C5BF 5d effffff68f tstl _prt_error
1281: 1273 0002C5C5 31 4e jeql L347
1282: 1274 0002C5C7 # print_pipe8_er("POP data from the STACK");
1283: 1275 0002C5C7 .data 1
1284: 1276 00000e0a * L348:
1285: 1277 00000e0a * 504F5020646174612066726F6 .ascii "POP data from the STACK\0"
1286: D2074686520535441434B00
1287: 1278 00000e22 * .text
1288: 1279 0002C5C7 dd 8f00000e0a pushl $L348
1289: 1280 0002C5CD fe 08 ef0000025c callf $8,_print_pipe8_er
1290: 1281 0002C5D4 # writes("final Stack Pointer = ");
1291: 1282 0002C5D4 .data 1
1292: 1283 00000e22 * L349:
1293: 1284 00000e22 * 66696E616C20537461636B205 .ascii "final Stack Pointer = \0"
1294: 06F696E746572203D2000
1295: 1285 00000e39 * .text
1296: 1286 0002C5D4 dd 8f00000e22 pushl $L349
1297: 1287 0002C5DA fe 08 effffff673 callf $8,_writes
1298: 1288 0002C5E1 # write32h( sgl_value_5 );
1299: 1289 0002C5E1 dd effffff66d pushl _sgl_value_5
1300: 1290 0002C5E7 fe 08 effffff666 callf $8,_write32h
1301: 1291 0002C5EE # writes(", expected SP = ");
1302: 1292 0002C5EE .data 1
1303: 1293 00000e39 * L351:
1304: 1294 00000e39 * 2C20206578706563746564205 .ascii ", expected SP = \0"
1305: 350203D2000
1306: 1295 00000e4b * .text
1307: 1296 0002C5EE dd 8f00000e39 pushl $L351
1308: 1297 0002C5F4 fe 08 effffff659 callf $8,_writes
1309: 1298 0002C5FB # write32h( sgl_value_4 );
1310: 1299 0002C5FB dd effffff653 pushl _sgl_value_4
1311: 1300 0002C601 fe 08 effffff64c callf $8,_write32h
1312: 1301 0002C608 # writes("\n");
1313: 1302 0002C608 .data 1
1314: 1303 00000e4b * L352:
1315: 1304 00000e4b * 0A00 .ascii "\12\0"
1316: 1305 00000e4d * .text
1317: 1306 0002C608 dd 8f00000e4b pushl $L352
1318: 1307 0002C60E fe 08 effffff63f callf $8,_writes
1319: 1308 0002C615 # }
1320: 1309 0002C615 # if ( halt_flg )
1321: 1310 0002C615 L347:
1322: 1311 0002C615 5d effffff639 tstl _halt_flg
1323: 1312 0002C61B 31 0d jeql L353
1324: 1313 0002C61D # pipe8_er_hlt( subtest );
1325: 1314 0002C61D dd effffff631 pushl _subtest
1326: 1315 0002C623 fe 08 ef00000312 callf $8,_pipe8_er_hlt
1327: 1316 0002C62A # if ( loop_on_err ) {
1328: 1317 0002C62A L353:
1329: 1318 0002C62A 5d effffff624 tstl _loop_on_err
1330: 1319 0002C630 31 0d jeql L354
1331: 1320 0002C632 # force_loop = TRUE; /* set the force loop flag */
1332: 1321 0002C632 0d 01 effffff61b movl $1,_force_loop
1333: 1322 0002C639 # asm("jmp _pipe8_9_lp1"); /* and loop */
1334: 1323 0002C639 71 efffffff01 jmp _pipe8_9_lp1
1335: 1324 0002C63F # }
1336: 1325 0002C63F # } /* end of compare error */
1337: 1326 0002C63F L354:
1338: 1327 0002C63F # } while( index++ < max_ldf_1_index );
1339: 1328 0002C63F L346:
1340: 1329 0002C63F L343:
1341: 1330 0002C63F 0d effffff60f 50 movl _index,r0
1342: 1331 0002C646 6d effffff608 incl _index
1343: 1332 0002C64C 1d 50 effffff601 cmpl r0,_max_ldf_1_index
1344: 1333 0002C653 81 03 13 fe9b jlss L344
1345: 1334 0002C658 L342:
1346: 1335 0002C658 # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1347: 1336 0002C658 0d effffff5f6 5d movl _pre_event_fp,r13
1348: 1337 0002C65F # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1349: 1338 0002C65F 0d effffff5ef 5e movl _pre_event_sp,r14
1350: 1339 0002C666 # } /* end of subtest 9 */
1351: 1340 0002C666 40 ret#2
1352: 1341 0002C667 .set L338,0x0
1353: 1342 0002C667 L340:
1354: 1343 0002C667 13 fe6f jbr L341
1355: 1344 0002C66A .data
1356: 1345 00000d5c * .text
1357: 1346 0002C66A .align 1
1358: 1347 0002C66A .globl _pipe8_10
1359: 1348 0002C66A _pipe8_10:
1360: 1349 0002C66A 0000 .word L355
1361: 1350 0002C66C #
1362: 1351 0002C66C #
1363: 1352 0002C66C #
1364: 1353 0002C66C #
1365: 1354 0002C66C #
1366: 1355 0002C66C #
1367: 1356 0002C66C # /******************************************************************************
1368: 1357 0002C66C # *
1369: 1358 0002C66C # * SUBTEST 10
1370: 1359 0002C66C # * get data via indexed FRAME pointer
1371: 1360 0002C66C # *
1372: 1361 0002C66C # * ADDR INDEX DATA
1373: 1362 0002C66C # * pointer_data 4 <the STF result goes here>
1374: 1363 0002C66C # * pointer_data-4 3 <operand data>
1375: 1364 0002C66C # * pointer_data-8 2 <floating 1.0>
1376: 1365 0002C66C # * pointer_data-12 1 <floating 2.0>
1377: 1366 0002C66C # * pointer_data-16 0 point the frame pointer here
1378: 1367 0002C66C # *
1379: 1368 0002C66C # ******************************************************************************/
1380: 1369 0002C66C # pipe8_10()
1381: 1370 0002C66C # {
1382: 1371 0002C66C 13 01be jbr L357
1383: 1372 0002C66F L358:
1384: 1373 0002C66F # asm("moval (r13),_pre_event_fp"); /* save the frame pointer */
1385: 1374 0002C66F ed 6d effffff5de moval (r13),_pre_event_fp
1386: 1375 0002C676 # asm("moval (r14),_pre_event_sp"); /* save the stack pointer */
1387: 1376 0002C676 ed 6e effffff5d7 moval (r14),_pre_event_sp
1388: 1377 0002C67D # force_loop = FALSE; /* clear force_loop flag */
1389: 1378 0002C67D 4d effffff5d1 clrl _force_loop
1390: 1379 0002C683 # index = 0;
1391: 1380 0002C683 4d effffff5cb clrl _index
1392: 1381 0002C689 # do
1393: 1382 0002C689 L361:
1394: 1383 0002C689 # {
1395: 1384 0002C689 # sgl_value_1 = ldf_1_data[index].ld; /* get operand 1 */
1396: 1385 0002C689 0d effffff5c5 50 movl _index,r0
1397: 1386 0002C690 48 03 50 50 shll $3,r0,r0
1398: 1387 0002C694 0d e000000000 effffff5b5 movl _ldf_1_data(r0),_sgl_value_1
1399: 1388 0002C69F # sgl_expected = ldf_1_data[index].exp; /* get expected results */
1400: 1389 0002C69F 0d effffff5af 50 movl _index,r0
1401: 1390 0002C6A6 48 03 50 50 shll $3,r0,r0
1402: 1391 0002C6AA 0d e000000004 effffff59f movl _ldf_1_data+4(r0),_sgl_expected
1403: 1392 0002C6B5 # sgl_value_2 = 0x40800000; /* floating '1' */
1404: 1393 0002C6B5 0d 8f40800000 effffff594 movl $1082130432,_sgl_value_2
1405: 1394 0002C6C0 # sgl_value_3 = 0x41000000; /* floating '2' */
1406: 1395 0002C6C0 0d 8f41000000 effffff589 movl $1090519040,_sgl_value_3
1407: 1396 0002C6CB # asm("moval _pointer_data,_sgl_value_4");/* get store data's addr */
1408: 1397 0002C6CB ed effffff583 effffff57e moval _pointer_data,_sgl_value_4
1409: 1398 0002C6D6 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1410: 1399 0002C6D6 2c 04 effffff577 subl2 $4,_sgl_value_4
1411: 1400 0002C6DD # asm("movl _sgl_value_1,*_sgl_value_4"); /* set the operand data */
1412: 1401 0002C6DD 0d effffff571 fffffff56c movl _sgl_value_1,*_sgl_value_4
1413: 1402 0002C6E8 # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1414: 1403 0002C6E8 2c 04 effffff565 subl2 $4,_sgl_value_4
1415: 1404 0002C6EF # asm("movl _sgl_value_2,*_sgl_value_4"); /* set the "1.0" data */
1416: 1405 0002C6EF 0d effffff55f fffffff55a movl _sgl_value_2,*_sgl_value_4
1417: 1406 0002C6FA # sgl_value_4 -= 4; /* decrement it by 4 (bytes)*/
1418: 1407 0002C6FA 2c 04 effffff553 subl2 $4,_sgl_value_4
1419: 1408 0002C701 # asm("movl _sgl_value_3,*_sgl_value_4"); /* set the "2.0" data */
1420: 1409 0002C701 0d effffff54d fffffff548 movl _sgl_value_3,*_sgl_value_4
1421: 1410 0002C70C # sgl_value_4 -= 4; /* get FRAME PTR address */
1422: 1411 0002C70C 2c 04 effffff541 subl2 $4,_sgl_value_4
1423: 1412 0002C713 # /*
1424: 1413 0002C713 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1425: 1414 0002C713 # * The force loop flag is set after the first error.
1426: 1415 0002C713 # */
1427: 1416 0002C713 # asm("_pipe8_10_lp1:");
1428: 1417 0002C713 _pipe8_10_lp1:
1429: 1418 0002C713 # asm("movl _sgl_value_4,r13"); /* set the FRAME POINTER */
1430: 1419 0002C713 0d effffff53b 5d movl _sgl_value_4,r13
1431: 1420 0002C71A # asm("movl $1,r1"); /* r1 index = 1 longwords */
1432: 1421 0002C71A 0d 01 51 movl $1,r1
1433: 1422 0002C71D # asm("movl $2,r2"); /* r2 index = 2 longwords */
1434: 1423 0002C71D 0d 02 52 movl $2,r2
1435: 1424 0002C720 # asm("movl $3,r3"); /* r3 index = 3 longwords */
1436: 1425 0002C720 0d 03 53 movl $3,r3
1437: 1426 0002C723 # asm("movl $4,r4"); /* r4 index = 4 longwords */
1438: 1427 0002C723 0d 04 54 movl $4,r4
1439: 1428 0002C726 # asm("ldf (r13)[r2]"); /* 1.0 to the ACC. ( 1.0 ) */
1440: 1429 0002C726 06 426d ldf (r13)[r2]
1441: 1430 0002C729 # asm("subf (r13)[r1]"); /* minus 2.0 (-1.0 ) */
1442: 1431 0002C729 d6 416d subf (r13)[r1]
1443: 1432 0002C72C # asm("mulf (r13)[r3]"); /* *'s the operand ( -op ) */
1444: 1433 0002C72C e6 436d mulf (r13)[r3]
1445: 1434 0002C72F # asm("addf (r13)[r3]"); /* + the operand ( 0 ) */
1446: 1435 0002C72F c6 436d addf (r13)[r3]
1447: 1436 0002C732 # asm("addf (r13)[r3]"); /* + the operand ( +op ) */
1448: 1437 0002C732 c6 436d addf (r13)[r3]
1449: 1438 0002C735 # asm("stf (r13)[r4]"); /* store -indexed by r4 */
1450: 1439 0002C735 26 446d stf (r13)[r4]
1451: 1440 0002C738 # if( force_loop )
1452: 1441 0002C738 5d effffff516 tstl _force_loop
1453: 1442 0002C73E 31 02 jeql L362
1454: 1443 0002C740 # asm("brb _pipe8_10_lp1"); /* loop on the error */
1455: 1444 0002C740 11 d1 brb _pipe8_10_lp1
1456: 1445 0002C742 # /*
1457: 1446 0002C742 # * verify the results
1458: 1447 0002C742 # */
1459: 1448 0002C742 # sgl_st_acc = pointer_data; /* move the stored result */
1460: 1449 0002C742 L362:
1461: 1450 0002C742 0d effffff50c effffff507 movl _pointer_data,_sgl_st_acc
1462: 1451 0002C74D # asm("moval (r13),_sgl_value_5"); /* save the frame pointer */
1463: 1452 0002C74D ed 6d effffff500 moval (r13),_sgl_value_5
1464: 1453 0002C754 # if( (sgl_st_acc != sgl_expected) || /* verify the result... */
1465: 1454 0002C754 # (sgl_value_5 != sgl_value_4) ) /* ... and the final FP */
1466: 1455 0002C754 1d effffff4fa effffff4f5 cmpl _sgl_st_acc,_sgl_expected
1467: 1456 0002C75F 21 10 jneq L9998
1468: 1457 0002C761 1d effffff4ed effffff4e8 cmpl _sgl_value_5,_sgl_value_4
1469: 1458 0002C76C 21 03 13 0094 jeql L363
1470: 1459 0002C771 L9998:
1471: 1460 0002C771 # {
1472: 1461 0002C771 # asm("movl _pre_event_fp,r13"); /* restore frame pointer */
1473: 1462 0002C771 0d effffff4dd 5d movl _pre_event_fp,r13
1474: 1463 0002C778 # asm("movl _pre_event_sp,r14"); /* restore stack pointer */
1475: 1464 0002C778 0d effffff4d6 5e movl _pre_event_sp,r14
1476: 1465 0002C77F # errcnt++; /* bump the error count */
1477: 1466 0002C77F 6d effffff4cf incl _errcnt
1478: 1467 0002C785 # if ( prt_error ) {
1479: 1468 0002C785 5d effffff4c9 tstl _prt_error
1480: 1469 0002C78B 31 4e jeql L364
1481: 1470 0002C78D # print_pipe8_er("indexed FP addressing");
1482: 1471 0002C78D .data 1
1483: 1472 00000e4d * L365:
1484: 1473 00000e4d * 696E646578656420465020616 .ascii "indexed FP addressing\0"
1485: 46472657373696E6700
1486: 1474 00000e63 * .text
1487: 1475 0002C78D dd 8f00000e4d pushl $L365
1488: 1476 0002C793 fe 08 ef00000096 callf $8,_print_pipe8_er
1489: 1477 0002C79A # writes("final Frame Pointer = ");
1490: 1478 0002C79A .data 1
1491: 1479 00000e63 * L366:
1492: 1480 00000e63 * 66696E616C204672616D65205 .ascii "final Frame Pointer = \0"
1493: 06F696E746572203D2000
1494: 1481 00000e7a * .text
1495: 1482 0002C79A dd 8f00000e63 pushl $L366
1496: 1483 0002C7A0 fe 08 effffff4ad callf $8,_writes
1497: 1484 0002C7A7 # writeh( sgl_value_5 );
1498: 1485 0002C7A7 dd effffff4a7 pushl _sgl_value_5
1499: 1486 0002C7AD fe 08 effffff4a0 callf $8,_writeh
1500: 1487 0002C7B4 # writes(", expected FP = ");
1501: 1488 0002C7B4 .data 1
1502: 1489 00000e7a * L368:
1503: 1490 00000e7a * 2C20206578706563746564204 .ascii ", expected FP = \0"
1504: 650203D2000
1505: 1491 00000e8c * .text
1506: 1492 0002C7B4 dd 8f00000e7a pushl $L368
1507: 1493 0002C7BA fe 08 effffff493 callf $8,_writes
1508: 1494 0002C7C1 # writeh( sgl_value_4 );
1509: 1495 0002C7C1 dd effffff48d pushl _sgl_value_4
1510: 1496 0002C7C7 fe 08 effffff486 callf $8,_writeh
1511: 1497 0002C7CE # writes("\n");
1512: 1498 0002C7CE .data 1
1513: 1499 00000e8c * L369:
1514: 1500 00000e8c * 0A00 .ascii "\12\0"
1515: 1501 00000e8e * .text
1516: 1502 0002C7CE dd 8f00000e8c pushl $L369
1517: 1503 0002C7D4 fe 08 effffff479 callf $8,_writes
1518: 1504 0002C7DB # }
1519: 1505 0002C7DB # if ( halt_flg )
1520: 1506 0002C7DB L364:
1521: 1507 0002C7DB 5d effffff473 tstl _halt_flg
1522: 1508 0002C7E1 31 0d jeql L370
1523: 1509 0002C7E3 # pipe8_er_hlt( subtest );
1524: 1510 0002C7E3 dd effffff46b pushl _subtest
1525: 1511 0002C7E9 fe 08 ef0000014c callf $8,_pipe8_er_hlt
1526: 1512 0002C7F0 # if ( loop_on_err ) {
1527: 1513 0002C7F0 L370:
1528: 1514 0002C7F0 5d effffff45e tstl _loop_on_err
1529: 1515 0002C7F6 31 0d jeql L371
1530: 1516 0002C7F8 # force_loop = TRUE; /* set the force loop flag */
1531: 1517 0002C7F8 0d 01 effffff455 movl $1,_force_loop
1532: 1518 0002C7FF # asm("jmp _pipe8_10_lp1"); /* and loop */
1533: 1519 0002C7FF 71 efffffff0e jmp _pipe8_10_lp1
1534: 1520 0002C805 # }
1535: 1521 0002C805 # } /* end of compare error */
1536: 1522 0002C805 L371:
1537: 1523 0002C805 # } while( index++ < max_ldf_1_index );
1538: 1524 0002C805 L363:
1539: 1525 0002C805 L360:
1540: 1526 0002C805 0d effffff449 50 movl _index,r0
1541: 1527 0002C80C 6d effffff442 incl _index
1542: 1528 0002C812 1d 50 effffff43b cmpl r0,_max_ldf_1_index
1543: 1529 0002C819 81 03 13 fe6b jlss L361
1544: 1530 0002C81E L359:
1545: 1531 0002C81E # asm("movl _pre_event_fp,r13"); /* restore the frame pointer */
1546: 1532 0002C81E 0d effffff430 5d movl _pre_event_fp,r13
1547: 1533 0002C825 # asm("movl _pre_event_sp,r14"); /* restore the stack pointer */
1548: 1534 0002C825 0d effffff429 5e movl _pre_event_sp,r14
1549: 1535 0002C82C # } /* end of subtest 10 */
1550: 1536 0002C82C 40 ret#2
1551: 1537 0002C82D .set L355,0x0
1552: 1538 0002C82D L357:
1553: 1539 0002C82D 13 fe3f jbr L358
1554: 1540 0002C830 .data
1555: 1541 00000d5c * .text
1556: 1542 0002C830 .align 1
1557: 1543 0002C830 .globl _print_pipe8_er
1558: 1544 0002C830 _print_pipe8_er:
1559: 1545 0002C830 0000 .word L372
1560: 1546 0002C832 #
1561: 1547 0002C832 #
1562: 1548 0002C832 # /******************************************************************************
1563: 1549 0002C832 # *
1564: 1550 0002C832 # * ERROR ROUTINE
1565: 1551 0002C832 # *
1566: 1552 0002C832 # * print an error in the following form
1567: 1553 0002C832 # *
1568: 1554 0002C832 # * operand = xxxxxxxx, final Acc = xxxxxxxx, data index = dd
1569: 1555 0002C832 # * expected Acc = xxxxxxxx
1570: 1556 0002C832 # *
1571: 1557 0002C832 # ******************************************************************************/
1572: 1558 0002C832 # print_pipe8_er(msg)
1573: 1559 0002C832 # char *msg;
1574: 1560 0002C832 # {
1575: 1561 0002C832 13 0103 jbr L374
1576: 1562 0002C835 L375:
1577: 1563 0002C835 # writes("\n"); /* start a new print line */
1578: 1564 0002C835 .data 1
1579: 1565 00000e8e * L376:
1580: 1566 00000e8e * 0A00 .ascii "\12\0"
1581: 1567 00000e90 * .text
1582: 1568 0002C835 dd 8f00000e8e pushl $L376
1583: 1569 0002C83B fe 08 effffff412 callf $8,_writes
1584: 1570 0002C842 # writes("cycle: ");
1585: 1571 0002C842 .data 1
1586: 1572 00000e90 * L377:
1587: 1573 00000e90 * 6379636C653A2000 .ascii "cycle: \0"
1588: 1574 00000e98 * .text
1589: 1575 0002C842 dd 8f00000e90 pushl $L377
1590: 1576 0002C848 fe 08 effffff405 callf $8,_writes
1591: 1577 0002C84F # writed( cycle );
1592: 1578 0002C84F dd effffff3ff pushl _cycle
1593: 1579 0002C855 fe 08 effffff3f8 callf $8,_writed
1594: 1580 0002C85C # writes(" test ");
1595: 1581 0002C85C .data 1
1596: 1582 00000e98 * L379:
1597: 1583 00000e98 * 20746573742000 .ascii " test \0"
1598: 1584 00000e9f * .text
1599: 1585 0002C85C dd 8f00000e98 pushl $L379
1600: 1586 0002C862 fe 08 effffff3eb callf $8,_writes
1601: 1587 0002C869 # writed( test_no );
1602: 1588 0002C869 dd effffff3e5 pushl _test_no
1603: 1589 0002C86F fe 08 effffff3de callf $8,_writed
1604: 1590 0002C876 # writes(" (Pipe 8), subtest ");
1605: 1591 0002C876 .data 1
1606: 1592 00000e9f * L380:
1607: 1593 00000e9f * 202028506970652038292C207 .ascii " (Pipe 8), subtest \0"
1608: 37562746573742000
1609: 1594 00000eb4 * .text
1610: 1595 0002C876 dd 8f00000e9f pushl $L380
1611: 1596 0002C87C fe 08 effffff3d1 callf $8,_writes
1612: 1597 0002C883 # writed( subtest );
1613: 1598 0002C883 dd effffff3cb pushl _subtest
1614: 1599 0002C889 fe 08 effffff3c4 callf $8,_writed
1615: 1600 0002C890 # writes(" error - ");
1616: 1601 0002C890 .data 1
1617: 1602 00000eb4 * L381:
1618: 1603 00000eb4 * 206572726F72202D2000 .ascii " error - \0"
1619: 1604 00000ebe * .text
1620: 1605 0002C890 dd 8f00000eb4 pushl $L381
1621: 1606 0002C896 fe 08 effffff3b7 callf $8,_writes
1622: 1607 0002C89D # writes( msg );
1623: 1608 0002C89D dd ad04 pushl 4(fp)
1624: 1609 0002C8A0 fe 08 effffff3ad callf $8,_writes
1625: 1610 0002C8A7 # writec('\n');
1626: 1611 0002C8A7 dd 0a pushl $10
1627: 1612 0002C8A9 fe 08 effffff3a4 callf $8,_writec
1628: 1613 0002C8B0 # writes(
1629: 1614 0002C8B0 # "LDF(1.0), SUBF(2.0), MULF(op), ADDF(op), ADDF(op), STF\n");
1630: 1615 0002C8B0 .data 1
1631: 1616 00000ebe * L383:
1632: 1617 00000ebe * 4C444628312E30292C2053554 .ascii "LDF(1.0), SUBF(2.0), MULF(op), ADDF(op), ADDF(op), STF\12\0"
1633: 24628322E30292C204D554C46
1634: 286F70292C2041444446286F7
1635: 0292C202041444446286F7029
1636: 2C20205354460A00
1637: 1618 00000ef8 * .text
1638: 1619 0002C8B0 dd 8f00000ebe pushl $L383
1639: 1620 0002C8B6 fe 08 effffff397 callf $8,_writes
1640: 1621 0002C8BD # writes("operand = ");
1641: 1622 0002C8BD .data 1
1642: 1623 00000ef8 * L384:
1643: 1624 00000ef8 * 6F706572616E64203D2000 .ascii "operand = \0"
1644: 1625 00000f03 * .text
1645: 1626 0002C8BD dd 8f00000ef8 pushl $L384
1646: 1627 0002C8C3 fe 08 effffff38a callf $8,_writes
1647: 1628 0002C8CA # write32h( sgl_value_1 );
1648: 1629 0002C8CA dd effffff384 pushl _sgl_value_1
1649: 1630 0002C8D0 fe 08 effffff37d callf $8,_write32h
1650: 1631 0002C8D7 # writes(", final Acc = ");
1651: 1632 0002C8D7 .data 1
1652: 1633 00000f03 * L385:
1653: 1634 00000f03 * 2C20202066696E616C2041636 .ascii ", final Acc = \0"
1654: 3203D2000
1655: 1635 00000f14 * .text
1656: 1636 0002C8D7 dd 8f00000f03 pushl $L385
1657: 1637 0002C8DD fe 08 effffff370 callf $8,_writes
1658: 1638 0002C8E4 # write32h( sgl_st_acc );
1659: 1639 0002C8E4 dd effffff36a pushl _sgl_st_acc
1660: 1640 0002C8EA fe 08 effffff363 callf $8,_write32h
1661: 1641 0002C8F1 # writes(", data index = ");
1662: 1642 0002C8F1 .data 1
1663: 1643 00000f14 * L386:
1664: 1644 00000f14 * 2C2020206461746120696E646 .ascii ", data index = \0"
1665: 578203D2000
1666: 1645 00000f26 * .text
1667: 1646 0002C8F1 dd 8f00000f14 pushl $L386
1668: 1647 0002C8F7 fe 08 effffff356 callf $8,_writes
1669: 1648 0002C8FE # writed( index );
1670: 1649 0002C8FE dd effffff350 pushl _index
1671: 1650 0002C904 fe 08 effffff349 callf $8,_writed
1672: 1651 0002C90B # writec('\n');
1673: 1652 0002C90B dd 0a pushl $10
1674: 1653 0002C90D fe 08 effffff340 callf $8,_writec
1675: 1654 0002C914 # writes(" expected Acc = ");
1676: 1655 0002C914 .data 1
1677: 1656 00000f26 * L387:
1678: 1657 00000f26 * 2020202020202020202020202 .ascii " expected Acc = \0"
1679: 0202020202020657870656374
1680: 656420416363203D2000
1681: 1658 00000f49 * .text
1682: 1659 0002C914 dd 8f00000f26 pushl $L387
1683: 1660 0002C91A fe 08 effffff333 callf $8,_writes
1684: 1661 0002C921 # write32h( sgl_expected );
1685: 1662 0002C921 dd effffff32d pushl _sgl_expected
1686: 1663 0002C927 fe 08 effffff326 callf $8,_write32h
1687: 1664 0002C92E # writec('\n');
1688: 1665 0002C92E dd 0a pushl $10
1689: 1666 0002C930 fe 08 effffff31d callf $8,_writec
1690: 1667 0002C937 # }
1691: 1668 0002C937 40 ret#2
1692: 1669 0002C938 .set L372,0x0
1693: 1670 0002C938 L374:
1694: 1671 0002C938 13 fefa jbr L375
1695: 1672 0002C93B .data
1696: 1673 00000d5c * .text
1697: 1674 0002C93B 00 .align 1
1698: 1675 0002C93C .globl _pipe8_er_hlt
1699: 1676 0002C93C _pipe8_er_hlt:
1700: 1677 0002C93C 0000 .word L388
1701: 1678 0002C93E #
1702: 1679 0002C93E #
1703: 1680 0002C93E #
1704: 1681 0002C93E #
1705: 1682 0002C93E #
1706: 1683 0002C93E # /******************************************************************************
1707: 1684 0002C93E # *
1708: 1685 0002C93E # * HALT ON ERROR ROUTINE
1709: 1686 0002C93E # *
1710: 1687 0002C93E # * halt with the necessary information saved in the registers
1711: 1688 0002C93E # *
1712: 1689 0002C93E # ******************************************************************************/
1713: 1690 0002C93E # pipe8_er_hlt( subtest )
1714: 1691 0002C93E # int subtest;
1715: 1692 0002C93E # {
1716: 1693 0002C93E 11 6e jbr L390
1717: 1694 0002C940 L391:
1718: 1695 0002C940 # asm("movl _test_no,r0"); /* r0 = test number */
1719: 1696 0002C940 0d effffff30e 50 movl _test_no,r0
1720: 1697 0002C947 # asm("movl _subtest,r1"); /* r1 = subtest number */
1721: 1698 0002C947 0d effffff307 51 movl _subtest,r1
1722: 1699 0002C94E # asm("movl $1,r2"); /* r2 = error code */
1723: 1700 0002C94E 0d 01 52 movl $1,r2
1724: 1701 0002C951 # asm("movl _cycle,r3"); /* r3 = cycle count */
1725: 1702 0002C951 0d effffff2fd 53 movl _cycle,r3
1726: 1703 0002C958 # asm("movl _sgl_value_1,r4"); /* r4 = sgl operand */
1727: 1704 0002C958 0d effffff2f6 54 movl _sgl_value_1,r4
1728: 1705 0002C95F # asm("movl _sgl_st_acc,r5"); /* r5 = sgl stored */
1729: 1706 0002C95F 0d effffff2ef 55 movl _sgl_st_acc,r5
1730: 1707 0002C966 # asm("movl _sgl_expected,r6"); /* r6 = sgl expected */
1731: 1708 0002C966 0d effffff2e8 56 movl _sgl_expected,r6
1732: 1709 0002C96D # asm("movl _index,r7"); /* r7 = data index */
1733: 1710 0002C96D 0d effffff2e1 57 movl _index,r7
1734: 1711 0002C974 # asm("movl _sgl_value_2,r8"); /* r8 = floating one */
1735: 1712 0002C974 0d effffff2da 58 movl _sgl_value_2,r8
1736: 1713 0002C97B # asm("movl _sgl_value_3,r9"); /* r9 = floating two */
1737: 1714 0002C97B 0d effffff2d3 59 movl _sgl_value_3,r9
1738: 1715 0002C982 # if( subtest == 9 ) {
1739: 1716 0002C982 1d ad04 09 cmpl 4(fp),$9
1740: 1717 0002C986 21 10 jneq L392
1741: 1718 0002C988 # asm("movl _sgl_value_3,r10"); /* r10 = final SP value */
1742: 1719 0002C988 0d effffff2c6 5a movl _sgl_value_3,r10
1743: 1720 0002C98F # asm("movl _sgl_value_2,r11"); /* r11 = expected SP value */
1744: 1721 0002C98F 0d effffff2bf 5b movl _sgl_value_2,r11
1745: 1722 0002C996 # } else
1746: 1723 0002C996 11 14 jbr L393
1747: 1724 0002C998 L392:
1748: 1725 0002C998 # if( subtest == 10 ) {
1749: 1726 0002C998 1d ad04 0a cmpl 4(fp),$10
1750: 1727 0002C99C 21 0e jneq L394
1751: 1728 0002C99E # asm("movl _sgl_value_3,r10"); /* r10 = final FP value */
1752: 1729 0002C99E 0d effffff2b0 5a movl _sgl_value_3,r10
1753: 1730 0002C9A5 # asm("movl _sgl_value_2,r11"); /* r11 = expected FP value */
1754: 1731 0002C9A5 0d effffff2a9 5b movl _sgl_value_2,r11
1755: 1732 0002C9AC # };
1756: 1733 0002C9AC L394:
1757: 1734 0002C9AC L393:
1758: 1735 0002C9AC # asm(".globl _pipe8_1_hlt");
1759: 1736 0002C9AC .globl _pipe8_1_hlt
1760: 1737 0002C9AC # asm("_pipe8_1_hlt:"); /* PC after the halt */
1761: 1738 0002C9AC _pipe8_1_hlt:
1762: 1739 0002C9AC # asm("halt"); /* HALT ... */
1763: 1740 0002C9AC 00 halt
1764: 1741 0002C9AD # } /* end of halt on error */
1765: 1742 0002C9AD 40 ret#2
1766: 1743 0002C9AE .set L388,0x0
1767: 1744 0002C9AE L390:
1768: 1745 0002C9AE 11 90 jbr L391
1769: 1746 00000d5c * .data
1770: 1746 00000d5c * .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.