![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to subf.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 subf.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 00000d28 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _subf
6: 6 00000000 _subf:
7: 7 0000E0A4 0000 .word L215
8: 8 0000E0A6 #
9: 9 0000E0A6 # #include "fpp_defs.h"
10: 10 0000E0A6 #
11: 11 0000E0A6 #
12: 12 0000E0A6 # /*****************************************************************************
13: 13 0000E0A6 # *
14: 14 0000E0A6 # * SUBF - SINGLE PRECISION FLOATING POINT ADD TEST
15: 15 0000E0A6 # *
16: 16 0000E0A6 # *****************************************************************************/
17: 17 0000E0A6 # subf()
18: 18 0000E0A6 # {
19: 19 0000E0A6 11 64 jbr L217
20: 20 0000E0A8 L218:
21: 21 0000E0A8 # asm(".globl _subf_t");
22: 22 0000E0A8 .globl _subf_t
23: 23 0000E0A8 # asm("_subf_t:"); /* entry address */
24: 24 0000E0A8 _subf_t:
25: 25 0000E0A8 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
26: 26 0000E0A8 1d effffffff6 01 cmpl _cycle,$1
27: 27 0000E0AF 21 15 jneq L219
28: 28 0000E0B1 5d efffffffed tstl _prt_hdrs
29: 29 0000E0B7 31 0d jeql L219
30: 30 0000E0B9 # writes(" SUBF");
31: 31 0000E0B9 .data 1
32: 32 00000d28 * L221:
33: 33 00000d28 * 205355424600 .ascii " SUBF\0"
34: 34 00000d2e * .text
35: 35 0000E0B9 dd 8f00000d28 pushl $L221
36: 36 0000E0BF fe 08 efffffffde callf $8,_writes
37: 37 0000E0C6 # subf_1(); /* subract through a register */
38: 38 0000E0C6 L219:
39: 39 0000E0C6 fe 04 ef00000041 callf $4,_subf_1
40: 40 0000E0CD # subf_2(); /* subract through the cache */
41: 41 0000E0CD fe 04 ef00000160 callf $4,_subf_2
42: 42 0000E0D4 # subf_3(); /* wait 3 NOPs */
43: 43 0000E0D4 fe 04 ef00000279 callf $4,_subf_3
44: 44 0000E0DB # subf_4(); /* wait 2 NOPs */
45: 45 0000E0DB fe 04 ef00000396 callf $4,_subf_4
46: 46 0000E0E2 # subf_5(); /* wait 1 NOP before storing */
47: 47 0000E0E2 fe 04 ef000004b3 callf $4,_subf_5
48: 48 0000E0E9 # subf_6(); /* register stability test */
49: 49 0000E0E9 fe 04 ef000005ce callf $4,_subf_6
50: 50 0000E0F0 # subf_7(); /* PSL stability test */
51: 51 0000E0F0 fe 04 ef00000777 callf $4,_subf_7
52: 52 0000E0F7 # subf_8(); /* pipelined entry test */
53: 53 0000E0F7 fe 04 ef0000092a callf $4,_subf_8
54: 54 0000E0FE # subf_9(); /* pipelined exit test */
55: 55 0000E0FE fe 04 ef00000a49 callf $4,_subf_9
56: 56 0000E105 # asm("jmp *return"); /* return to the test monitor */
57: 57 0000E105 71 ffffffff99 jmp *return
58: 58 0000E10B # }
59: 59 0000E10B 40 ret#2
60: 60 0000E10C .set L215,0x0
61: 61 0000E10C L217:
62: 62 0000E10C 11 9a jbr L218
63: 63 0000E10E .data
64: 64 00000d28 * .text
65: 65 0000E10E .align 1
66: 66 0000E10E .globl _subf_1
67: 67 0000E10E _subf_1:
68: 68 0000E10E 0000 .word L231
69: 69 0000E110 #
70: 70 0000E110 #
71: 71 0000E110 #
72: 72 0000E110 # /************************************************************************
73: 73 0000E110 # *
74: 74 0000E110 # * SUBTEST 1 - subract through a register
75: 75 0000E110 # *
76: 76 0000E110 # ************************************************************************/
77: 77 0000E110 # subf_1()
78: 78 0000E110 # {
79: 79 0000E110 13 011e jbr L233
80: 80 0000E113 L234:
81: 81 0000E113 # force_loop = FALSE;
82: 82 0000E113 4d efffffff8b clrl _force_loop
83: 83 0000E119 # subtest = 1;
84: 84 0000E119 0d 01 efffffff84 movl $1,_subtest
85: 85 0000E120 # for( index = 0; index < max_subf_1_index; index++ ) {
86: 86 0000E120 4d efffffff7e clrl _index
87: 87 0000E126 L237:
88: 88 0000E126 1d efffffff78 efffffff73 cmpl _index,_max_subf_1_index
89: 89 0000E131 91 03 13 00fa jgeq L236
90: 90 0000E136 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
91: 91 0000E136 5c 0c efffffff67 50 mull3 $12,_index,r0
92: 92 0000E13E 0d e000000000 efffffff5b movl _subf_1_data(r0),_sgl_ld_acc
93: 93 0000E149 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
94: 94 0000E149 5c 0c efffffff54 50 mull3 $12,_index,r0
95: 95 0000E151 0d e000000004 efffffff48 movl _subf_1_data+4(r0),_sgl_value_1
96: 96 0000E15C # sgl_expected = subf_1_data[index].exp; /* get expected result */
97: 97 0000E15C 5c 0c efffffff41 50 mull3 $12,_index,r0
98: 98 0000E164 0d e000000008 efffffff35 movl _subf_1_data+8(r0),_sgl_expected
99: 99 0000E16F # /*
100: 100 0000E16F # * If LOOP ON ERROR is set, this is the loop for this subtest.
101: 101 0000E16F # * The force loop flag is set after the first error.
102: 102 0000E16F # */
103: 103 0000E16F # asm("_subf_1_lp1:");
104: 104 0000E16F _subf_1_lp1:
105: 105 0000E16F # asm("movl _sgl_ld_acc,r3"); /* move the 1st data to r3 */
106: 106 0000E16F 0d efffffff2f 53 movl _sgl_ld_acc,r3
107: 107 0000E176 # asm("movl _sgl_value_1,r4"); /* move the 2nd data to r4 */
108: 108 0000E176 0d efffffff28 54 movl _sgl_value_1,r4
109: 109 0000E17D # asm("ldf r3"); /* load the 1st operand */
110: 110 0000E17D 06 53 ldf r3
111: 111 0000E17F # asm("subf r4"); /* subract the 2nd operand */
112: 112 0000E17F d6 54 subf r4
113: 113 0000E181 # asm("stf _sgl_st_acc"); /* store the result */
114: 114 0000E181 26 efffffff1d stf _sgl_st_acc
115: 115 0000E187 # if( force_loop )
116: 116 0000E187 5d efffffff17 tstl _force_loop
117: 117 0000E18D 31 02 jeql L238
118: 118 0000E18F # asm("brb _subf_1_lp1");; /* loop on the error */
119: 119 0000E18F 11 de brb _subf_1_lp1
120: 120 0000E191 L238:
121: 121 0000E191 # /*
122: 122 0000E191 # * end error loop - test the results
123: 123 0000E191 # */
124: 124 0000E191 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
125: 125 0000E191 1d efffffff0d efffffff08 cmpl _sgl_st_acc,_sgl_expected
126: 126 0000E19C 21 03 13 0086 jeql L239
127: 127 0000E1A1 # errcnt++; /* bump the error count */
128: 128 0000E1A1 6d effffffefd incl _errcnt
129: 129 0000E1A7 # if( prt_error ) {
130: 130 0000E1A7 5d effffffef7 tstl _prt_error
131: 131 0000E1AD 31 55 jeql L240
132: 132 0000E1AF # writes(" \n"); /* start a new print line */
133: 133 0000E1AF .data 1
134: 134 00000d2e * L241:
135: 135 00000d2e * 200A00 .ascii " \12\0"
136: 136 00000d31 * .text
137: 137 0000E1AF dd 8f00000d2e pushl $L241
138: 138 0000E1B5 fe 08 effffffee8 callf $8,_writes
139: 139 0000E1BC # writes("cycle: ");
140: 140 0000E1BC .data 1
141: 141 00000d31 * L242:
142: 142 00000d31 * 6379636C653A2000 .ascii "cycle: \0"
143: 143 00000d39 * .text
144: 144 0000E1BC dd 8f00000d31 pushl $L242
145: 145 0000E1C2 fe 08 effffffedb callf $8,_writes
146: 146 0000E1C9 # writed( cycle );
147: 147 0000E1C9 dd effffffed5 pushl _cycle
148: 148 0000E1CF fe 08 effffffece callf $8,_writed
149: 149 0000E1D6 # writes(" SUBF test ");
150: 150 0000E1D6 .data 1
151: 151 00000d39 * L244:
152: 152 00000d39 * 2020535542462074657374200 .ascii " SUBF test \0"
153: 0
154: 153 00000d46 * .text
155: 154 0000E1D6 dd 8f00000d39 pushl $L244
156: 155 0000E1DC fe 08 effffffec1 callf $8,_writes
157: 156 0000E1E3 # writed( test_no );
158: 157 0000E1E3 dd effffffebb pushl _test_no
159: 158 0000E1E9 fe 08 effffffeb4 callf $8,_writed
160: 159 0000E1F0 # writes(", subtest 1 (Reg. Data) - BAD FINAL ACC\n");
161: 160 0000E1F0 .data 1
162: 161 00000d46 * L245:
163: 162 00000d46 * 2C20737562746573742031202 .ascii ", subtest 1 (Reg. Data) - BAD FINAL ACC\12\0"
164: 85265672E204461746129202D
165: 204241442046494E414C20414
166: 3430A00
167: 163 00000d6f * .text
168: 164 0000E1F0 dd 8f00000d46 pushl $L245
169: 165 0000E1F6 fe 08 effffffea7 callf $8,_writes
170: 166 0000E1FD # print_subf_data();
171: 167 0000E1FD fe 04 ef00000a70 callf $4,_print_subf_data
172: 168 0000E204 # }
173: 169 0000E204 # if( halt_flg )
174: 170 0000E204 L240:
175: 171 0000E204 5d effffffe9a tstl _halt_flg
176: 172 0000E20A 31 09 jeql L247
177: 173 0000E20C # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
178: 174 0000E20C dd 01 pushl $1
179: 175 0000E20E fe 08 ef00000afd callf $8,_subf_er_halt
180: 176 0000E215 # if( loop_on_err ) {
181: 177 0000E215 L247:
182: 178 0000E215 5d effffffe89 tstl _loop_on_err
183: 179 0000E21B 31 0a jeql L249
184: 180 0000E21D # force_loop = TRUE; /* set the force loop flag */
185: 181 0000E21D 0d 01 effffffe80 movl $1,_force_loop
186: 182 0000E224 # asm("brw _subf_1_lp1");; /* and loop on the error */
187: 183 0000E224 13 ff48 brw _subf_1_lp1
188: 184 0000E227 # } /* end of loop on error */
189: 185 0000E227 # } /* end of compare error */
190: 186 0000E227 L249:
191: 187 0000E227 # } /* end of WHILE loop */
192: 188 0000E227 L239:
193: 189 0000E227 L235:
194: 190 0000E227 6d effffffe77 incl _index
195: 191 0000E22D 13 fef6 jbr L237
196: 192 0000E230 L236:
197: 193 0000E230 # } /* end of subtest 1 */
198: 194 0000E230 40 ret#2
199: 195 0000E231 .set L231,0x0
200: 196 0000E231 L233:
201: 197 0000E231 13 fedf jbr L234
202: 198 0000E234 .data
203: 199 00000d28 * .text
204: 200 0000E234 .align 1
205: 201 0000E234 .globl _subf_2
206: 202 0000E234 _subf_2:
207: 203 0000E234 0000 .word L250
208: 204 0000E236 #
209: 205 0000E236 #
210: 206 0000E236 #
211: 207 0000E236 # /************************************************************************
212: 208 0000E236 # *
213: 209 0000E236 # * SUBTEST 2 - subract through memory
214: 210 0000E236 # *
215: 211 0000E236 # ************************************************************************/
216: 212 0000E236 # subf_2()
217: 213 0000E236 # {
218: 214 0000E236 13 0118 jbr L252
219: 215 0000E239 L253:
220: 216 0000E239 # force_loop = FALSE;
221: 217 0000E239 4d effffffe65 clrl _force_loop
222: 218 0000E23F # subtest = 2;
223: 219 0000E23F 0d 02 effffffe5e movl $2,_subtest
224: 220 0000E246 # for( index = 0; index < max_subf_1_index; index++ ) {
225: 221 0000E246 4d effffffe58 clrl _index
226: 222 0000E24C L256:
227: 223 0000E24C 1d effffffe52 effffffe4d cmpl _index,_max_subf_1_index
228: 224 0000E257 91 03 13 00f4 jgeq L255
229: 225 0000E25C # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
230: 226 0000E25C 5c 0c effffffe41 50 mull3 $12,_index,r0
231: 227 0000E264 0d e000000000 effffffe35 movl _subf_1_data(r0),_sgl_ld_acc
232: 228 0000E26F # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
233: 229 0000E26F 5c 0c effffffe2e 50 mull3 $12,_index,r0
234: 230 0000E277 0d e000000004 effffffe22 movl _subf_1_data+4(r0),_sgl_value_1
235: 231 0000E282 # sgl_expected = subf_1_data[index].exp; /* get expected result */
236: 232 0000E282 5c 0c effffffe1b 50 mull3 $12,_index,r0
237: 233 0000E28A 0d e000000008 effffffe0f movl _subf_1_data+8(r0),_sgl_expected
238: 234 0000E295 # /*
239: 235 0000E295 # * If LOOP ON ERROR is set, this is the loop for this subtest.
240: 236 0000E295 # * The force loop flag is set after the first error.
241: 237 0000E295 # */
242: 238 0000E295 # asm("_subf_2_lp1:");
243: 239 0000E295 _subf_2_lp1:
244: 240 0000E295 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */
245: 241 0000E295 06 effffffe09 ldf _sgl_ld_acc
246: 242 0000E29B # asm("subf _sgl_value_1"); /* sub the 2nd operand */
247: 243 0000E29B d6 effffffe03 subf _sgl_value_1
248: 244 0000E2A1 # asm("stf _sgl_st_acc"); /* store the result */
249: 245 0000E2A1 26 effffffdfd stf _sgl_st_acc
250: 246 0000E2A7 # if( force_loop )
251: 247 0000E2A7 5d effffffdf7 tstl _force_loop
252: 248 0000E2AD 31 02 jeql L257
253: 249 0000E2AF # asm("brb _subf_2_lp1");; /* loop on the error */
254: 250 0000E2AF 11 e4 brb _subf_2_lp1
255: 251 0000E2B1 L257:
256: 252 0000E2B1 # /*
257: 253 0000E2B1 # * end error loop - test the results
258: 254 0000E2B1 # */
259: 255 0000E2B1 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
260: 256 0000E2B1 1d effffffded effffffde8 cmpl _sgl_st_acc,_sgl_expected
261: 257 0000E2BC 21 03 13 0086 jeql L258
262: 258 0000E2C1 # errcnt++; /* bump the error count */
263: 259 0000E2C1 6d effffffddd incl _errcnt
264: 260 0000E2C7 # if( prt_error ) {
265: 261 0000E2C7 5d effffffdd7 tstl _prt_error
266: 262 0000E2CD 31 55 jeql L259
267: 263 0000E2CF # writes(" \n"); /* start a new print line */
268: 264 0000E2CF .data 1
269: 265 00000d6f * L260:
270: 266 00000d6f * 200A00 .ascii " \12\0"
271: 267 00000d72 * .text
272: 268 0000E2CF dd 8f00000d6f pushl $L260
273: 269 0000E2D5 fe 08 effffffdc8 callf $8,_writes
274: 270 0000E2DC # writes("cycle: ");
275: 271 0000E2DC .data 1
276: 272 00000d72 * L261:
277: 273 00000d72 * 6379636C653A2000 .ascii "cycle: \0"
278: 274 00000d7a * .text
279: 275 0000E2DC dd 8f00000d72 pushl $L261
280: 276 0000E2E2 fe 08 effffffdbb callf $8,_writes
281: 277 0000E2E9 # writed( cycle );
282: 278 0000E2E9 dd effffffdb5 pushl _cycle
283: 279 0000E2EF fe 08 effffffdae callf $8,_writed
284: 280 0000E2F6 # writes(" SUBF test ");
285: 281 0000E2F6 .data 1
286: 282 00000d7a * L262:
287: 283 00000d7a * 2020535542462074657374200 .ascii " SUBF test \0"
288: 0
289: 284 00000d87 * .text
290: 285 0000E2F6 dd 8f00000d7a pushl $L262
291: 286 0000E2FC fe 08 effffffda1 callf $8,_writes
292: 287 0000E303 # writed( test_no );
293: 288 0000E303 dd effffffd9b pushl _test_no
294: 289 0000E309 fe 08 effffffd94 callf $8,_writed
295: 290 0000E310 # writes(", subtest 2 (Cache Data) - BAD FINAL ACC\n");
296: 291 0000E310 .data 1
297: 292 00000d87 * L263:
298: 293 00000d87 * 2C20737562746573742032202 .ascii ", subtest 2 (Cache Data) - BAD FINAL ACC\12\0"
299: 8436163686520446174612920
300: 2D204241442046494E414C204
301: 143430A00
302: 294 00000db1 * .text
303: 295 0000E310 dd 8f00000d87 pushl $L263
304: 296 0000E316 fe 08 effffffd87 callf $8,_writes
305: 297 0000E31D # print_subf_data();
306: 298 0000E31D fe 04 ef00000950 callf $4,_print_subf_data
307: 299 0000E324 # }
308: 300 0000E324 # if( halt_flg )
309: 301 0000E324 L259:
310: 302 0000E324 5d effffffd7a tstl _halt_flg
311: 303 0000E32A 31 09 jeql L264
312: 304 0000E32C # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
313: 305 0000E32C dd 01 pushl $1
314: 306 0000E32E fe 08 ef000009dd callf $8,_subf_er_halt
315: 307 0000E335 # if( loop_on_err ) {
316: 308 0000E335 L264:
317: 309 0000E335 5d effffffd69 tstl _loop_on_err
318: 310 0000E33B 31 0a jeql L265
319: 311 0000E33D # force_loop = TRUE; /* set the force loop flag */
320: 312 0000E33D 0d 01 effffffd60 movl $1,_force_loop
321: 313 0000E344 # asm("brw _subf_2_lp1");; /* and loop on the error */
322: 314 0000E344 13 ff4e brw _subf_2_lp1
323: 315 0000E347 # } /* end of loop on error */
324: 316 0000E347 # } /* end of compare error */
325: 317 0000E347 L265:
326: 318 0000E347 # } /* end of WHILE loop */
327: 319 0000E347 L258:
328: 320 0000E347 L254:
329: 321 0000E347 6d effffffd57 incl _index
330: 322 0000E34D 13 fefc jbr L256
331: 323 0000E350 L255:
332: 324 0000E350 # } /* end of subtest 2 */
333: 325 0000E350 40 ret#2
334: 326 0000E351 .set L250,0x0
335: 327 0000E351 L252:
336: 328 0000E351 13 fee5 jbr L253
337: 329 0000E354 .data
338: 330 00000d28 * .text
339: 331 0000E354 .align 1
340: 332 0000E354 .globl _subf_3
341: 333 0000E354 _subf_3:
342: 334 0000E354 0000 .word L266
343: 335 0000E356 #
344: 336 0000E356 #
345: 337 0000E356 #
346: 338 0000E356 # /************************************************************************
347: 339 0000E356 # *
348: 340 0000E356 # * SUBTEST 3 - Wait 3 NOPs before storing the results
349: 341 0000E356 # *
350: 342 0000E356 # ************************************************************************/
351: 343 0000E356 # subf_3()
352: 344 0000E356 # {
353: 345 0000E356 13 011c jbr L268
354: 346 0000E359 L269:
355: 347 0000E359 # force_loop = FALSE;
356: 348 0000E359 4d effffffd45 clrl _force_loop
357: 349 0000E35F # subtest = 3;
358: 350 0000E35F 0d 03 effffffd3e movl $3,_subtest
359: 351 0000E366 # for( index = 0; index < max_subf_1_index; index++ ) {
360: 352 0000E366 4d effffffd38 clrl _index
361: 353 0000E36C L272:
362: 354 0000E36C 1d effffffd32 effffffd2d cmpl _index,_max_subf_1_index
363: 355 0000E377 91 03 13 00f8 jgeq L271
364: 356 0000E37C # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
365: 357 0000E37C 5c 0c effffffd21 50 mull3 $12,_index,r0
366: 358 0000E384 0d e000000000 effffffd15 movl _subf_1_data(r0),_sgl_ld_acc
367: 359 0000E38F # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
368: 360 0000E38F 5c 0c effffffd0e 50 mull3 $12,_index,r0
369: 361 0000E397 0d e000000004 effffffd02 movl _subf_1_data+4(r0),_sgl_value_1
370: 362 0000E3A2 # sgl_expected = subf_1_data[index].exp; /* get expected result */
371: 363 0000E3A2 5c 0c effffffcfb 50 mull3 $12,_index,r0
372: 364 0000E3AA 0d e000000008 effffffcef movl _subf_1_data+8(r0),_sgl_expected
373: 365 0000E3B5 # /*
374: 366 0000E3B5 # * If LOOP ON ERROR is set, this is the loop for this subtest.
375: 367 0000E3B5 # * The force loop flag is set after the first error.
376: 368 0000E3B5 # */
377: 369 0000E3B5 # asm("_subf_3_lp1:");
378: 370 0000E3B5 _subf_3_lp1:
379: 371 0000E3B5 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */
380: 372 0000E3B5 06 effffffce9 ldf _sgl_ld_acc
381: 373 0000E3BB # asm("nop"); /* delay */
382: 374 0000E3BB 10 nop
383: 375 0000E3BC # asm("subf _sgl_value_1"); /* sub the 2nd operand */
384: 376 0000E3BC d6 effffffce2 subf _sgl_value_1
385: 377 0000E3C2 # asm("nop"); /* delay before ... */
386: 378 0000E3C2 10 nop
387: 379 0000E3C3 # asm("nop");
388: 380 0000E3C3 10 nop
389: 381 0000E3C4 # asm("nop"); /* ... storing the result */
390: 382 0000E3C4 10 nop
391: 383 0000E3C5 # asm("stf _sgl_st_acc"); /* store the result */
392: 384 0000E3C5 26 effffffcd9 stf _sgl_st_acc
393: 385 0000E3CB # if( force_loop )
394: 386 0000E3CB 5d effffffcd3 tstl _force_loop
395: 387 0000E3D1 31 02 jeql L273
396: 388 0000E3D3 # asm("brb _subf_3_lp1");; /* loop on the error */
397: 389 0000E3D3 11 e0 brb _subf_3_lp1
398: 390 0000E3D5 L273:
399: 391 0000E3D5 # /*
400: 392 0000E3D5 # * end error loop - test the results
401: 393 0000E3D5 # */
402: 394 0000E3D5 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
403: 395 0000E3D5 1d effffffcc9 effffffcc4 cmpl _sgl_st_acc,_sgl_expected
404: 396 0000E3E0 21 03 13 0086 jeql L274
405: 397 0000E3E5 # errcnt++; /* bump the error count */
406: 398 0000E3E5 6d effffffcb9 incl _errcnt
407: 399 0000E3EB # if( prt_error ) {
408: 400 0000E3EB 5d effffffcb3 tstl _prt_error
409: 401 0000E3F1 31 55 jeql L275
410: 402 0000E3F3 # writes(" \n"); /* start a new print line */
411: 403 0000E3F3 .data 1
412: 404 00000db1 * L276:
413: 405 00000db1 * 200A00 .ascii " \12\0"
414: 406 00000db4 * .text
415: 407 0000E3F3 dd 8f00000db1 pushl $L276
416: 408 0000E3F9 fe 08 effffffca4 callf $8,_writes
417: 409 0000E400 # writes("cycle: ");
418: 410 0000E400 .data 1
419: 411 00000db4 * L277:
420: 412 00000db4 * 6379636C653A2000 .ascii "cycle: \0"
421: 413 00000dbc * .text
422: 414 0000E400 dd 8f00000db4 pushl $L277
423: 415 0000E406 fe 08 effffffc97 callf $8,_writes
424: 416 0000E40D # writed( cycle );
425: 417 0000E40D dd effffffc91 pushl _cycle
426: 418 0000E413 fe 08 effffffc8a callf $8,_writed
427: 419 0000E41A # writes(" SUBF test ");
428: 420 0000E41A .data 1
429: 421 00000dbc * L278:
430: 422 00000dbc * 2020535542462074657374200 .ascii " SUBF test \0"
431: 0
432: 423 00000dc9 * .text
433: 424 0000E41A dd 8f00000dbc pushl $L278
434: 425 0000E420 fe 08 effffffc7d callf $8,_writes
435: 426 0000E427 # writed( test_no );
436: 427 0000E427 dd effffffc77 pushl _test_no
437: 428 0000E42D fe 08 effffffc70 callf $8,_writed
438: 429 0000E434 # writes(", subtest 3 (Cache Data - 3 NOPS) - BAD FINAL ACC\n");
439: 430 0000E434 .data 1
440: 431 00000dc9 * L279:
441: 432 00000dc9 * 2C20737562746573742033202 .ascii ", subtest 3 (Cache Data - 3 NOPS) - BAD FINAL ACC\12\0"
442: 843616368652044617461202D
443: 2033204E4F505329202D20424
444: 1442046494E414C204143430A
445: 00
446: 433 00000dfc * .text
447: 434 0000E434 dd 8f00000dc9 pushl $L279
448: 435 0000E43A fe 08 effffffc63 callf $8,_writes
449: 436 0000E441 # print_subf_data();
450: 437 0000E441 fe 04 ef0000082c callf $4,_print_subf_data
451: 438 0000E448 # }
452: 439 0000E448 # if( halt_flg )
453: 440 0000E448 L275:
454: 441 0000E448 5d effffffc56 tstl _halt_flg
455: 442 0000E44E 31 09 jeql L280
456: 443 0000E450 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
457: 444 0000E450 dd 01 pushl $1
458: 445 0000E452 fe 08 ef000008b9 callf $8,_subf_er_halt
459: 446 0000E459 # if( loop_on_err ) {
460: 447 0000E459 L280:
461: 448 0000E459 5d effffffc45 tstl _loop_on_err
462: 449 0000E45F 31 0a jeql L281
463: 450 0000E461 # force_loop = TRUE; /* set the force loop flag */
464: 451 0000E461 0d 01 effffffc3c movl $1,_force_loop
465: 452 0000E468 # asm("brw _subf_3_lp1");; /* and loop on the error */
466: 453 0000E468 13 ff4a brw _subf_3_lp1
467: 454 0000E46B # } /* end of loop on error */
468: 455 0000E46B # } /* end of compare error */
469: 456 0000E46B L281:
470: 457 0000E46B # } /* end of WHILE loop */
471: 458 0000E46B L274:
472: 459 0000E46B L270:
473: 460 0000E46B 6d effffffc33 incl _index
474: 461 0000E471 13 fef8 jbr L272
475: 462 0000E474 L271:
476: 463 0000E474 # } /* end of subtest 3 */
477: 464 0000E474 40 ret#2
478: 465 0000E475 .set L266,0x0
479: 466 0000E475 L268:
480: 467 0000E475 13 fee1 jbr L269
481: 468 0000E478 .data
482: 469 00000d28 * .text
483: 470 0000E478 .align 1
484: 471 0000E478 .globl _subf_4
485: 472 0000E478 _subf_4:
486: 473 0000E478 0000 .word L282
487: 474 0000E47A #
488: 475 0000E47A #
489: 476 0000E47A #
490: 477 0000E47A # /************************************************************************
491: 478 0000E47A # *
492: 479 0000E47A # * SUBTEST 4 - Wait 2 NOPs before storing the results
493: 480 0000E47A # *
494: 481 0000E47A # ************************************************************************/
495: 482 0000E47A # subf_4()
496: 483 0000E47A # {
497: 484 0000E47A 13 011b jbr L284
498: 485 0000E47D L285:
499: 486 0000E47D # force_loop = FALSE;
500: 487 0000E47D 4d effffffc21 clrl _force_loop
501: 488 0000E483 # subtest = 4;
502: 489 0000E483 0d 04 effffffc1a movl $4,_subtest
503: 490 0000E48A # for( index = 0; index < max_subf_1_index; index++ ) {
504: 491 0000E48A 4d effffffc14 clrl _index
505: 492 0000E490 L288:
506: 493 0000E490 1d effffffc0e effffffc09 cmpl _index,_max_subf_1_index
507: 494 0000E49B 91 03 13 00f7 jgeq L287
508: 495 0000E4A0 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
509: 496 0000E4A0 5c 0c effffffbfd 50 mull3 $12,_index,r0
510: 497 0000E4A8 0d e000000000 effffffbf1 movl _subf_1_data(r0),_sgl_ld_acc
511: 498 0000E4B3 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
512: 499 0000E4B3 5c 0c effffffbea 50 mull3 $12,_index,r0
513: 500 0000E4BB 0d e000000004 effffffbde movl _subf_1_data+4(r0),_sgl_value_1
514: 501 0000E4C6 # sgl_expected = subf_1_data[index].exp; /* get expected result */
515: 502 0000E4C6 5c 0c effffffbd7 50 mull3 $12,_index,r0
516: 503 0000E4CE 0d e000000008 effffffbcb movl _subf_1_data+8(r0),_sgl_expected
517: 504 0000E4D9 # /*
518: 505 0000E4D9 # * If LOOP ON ERROR is set, this is the loop for this subtest.
519: 506 0000E4D9 # * The force loop flag is set after the first error.
520: 507 0000E4D9 # */
521: 508 0000E4D9 # asm("_subf_4_lp1:");
522: 509 0000E4D9 _subf_4_lp1:
523: 510 0000E4D9 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */
524: 511 0000E4D9 06 effffffbc5 ldf _sgl_ld_acc
525: 512 0000E4DF # asm("nop"); /* delay */
526: 513 0000E4DF 10 nop
527: 514 0000E4E0 # asm("subf _sgl_value_1"); /* subract the 2nd operand */
528: 515 0000E4E0 d6 effffffbbe subf _sgl_value_1
529: 516 0000E4E6 # asm("nop"); /* delay before ... */
530: 517 0000E4E6 10 nop
531: 518 0000E4E7 # asm("nop"); /* ... storing the result */
532: 519 0000E4E7 10 nop
533: 520 0000E4E8 # asm("stf _sgl_st_acc"); /* store the result */
534: 521 0000E4E8 26 effffffbb6 stf _sgl_st_acc
535: 522 0000E4EE # if( force_loop )
536: 523 0000E4EE 5d effffffbb0 tstl _force_loop
537: 524 0000E4F4 31 02 jeql L289
538: 525 0000E4F6 # asm("brb _subf_4_lp1");; /* loop on the error */
539: 526 0000E4F6 11 e1 brb _subf_4_lp1
540: 527 0000E4F8 L289:
541: 528 0000E4F8 # /*
542: 529 0000E4F8 # * end error loop - test the results
543: 530 0000E4F8 # */
544: 531 0000E4F8 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
545: 532 0000E4F8 1d effffffba6 effffffba1 cmpl _sgl_st_acc,_sgl_expected
546: 533 0000E503 21 03 13 0086 jeql L290
547: 534 0000E508 # errcnt++; /* bump the error count */
548: 535 0000E508 6d effffffb96 incl _errcnt
549: 536 0000E50E # if( prt_error ) {
550: 537 0000E50E 5d effffffb90 tstl _prt_error
551: 538 0000E514 31 55 jeql L291
552: 539 0000E516 # writes(" \n"); /* start a new print line */
553: 540 0000E516 .data 1
554: 541 00000dfc * L292:
555: 542 00000dfc * 200A00 .ascii " \12\0"
556: 543 00000dff * .text
557: 544 0000E516 dd 8f00000dfc pushl $L292
558: 545 0000E51C fe 08 effffffb81 callf $8,_writes
559: 546 0000E523 # writes("cycle: ");
560: 547 0000E523 .data 1
561: 548 00000dff * L293:
562: 549 00000dff * 6379636C653A2000 .ascii "cycle: \0"
563: 550 00000e07 * .text
564: 551 0000E523 dd 8f00000dff pushl $L293
565: 552 0000E529 fe 08 effffffb74 callf $8,_writes
566: 553 0000E530 # writed( cycle );
567: 554 0000E530 dd effffffb6e pushl _cycle
568: 555 0000E536 fe 08 effffffb67 callf $8,_writed
569: 556 0000E53D # writes(" SUBF test ");
570: 557 0000E53D .data 1
571: 558 00000e07 * L294:
572: 559 00000e07 * 2020535542462074657374200 .ascii " SUBF test \0"
573: 0
574: 560 00000e14 * .text
575: 561 0000E53D dd 8f00000e07 pushl $L294
576: 562 0000E543 fe 08 effffffb5a callf $8,_writes
577: 563 0000E54A # writed( test_no );
578: 564 0000E54A dd effffffb54 pushl _test_no
579: 565 0000E550 fe 08 effffffb4d callf $8,_writed
580: 566 0000E557 # writes(", subtest 4 (Cache Data - 2 NOPS) - BAD FINAL ACC\n");
581: 567 0000E557 .data 1
582: 568 00000e14 * L295:
583: 569 00000e14 * 2C20737562746573742034202 .ascii ", subtest 4 (Cache Data - 2 NOPS) - BAD FINAL ACC\12\0"
584: 843616368652044617461202D
585: 2032204E4F505329202D20424
586: 1442046494E414C204143430A
587: 00
588: 570 00000e47 * .text
589: 571 0000E557 dd 8f00000e14 pushl $L295
590: 572 0000E55D fe 08 effffffb40 callf $8,_writes
591: 573 0000E564 # print_subf_data();
592: 574 0000E564 fe 04 ef00000709 callf $4,_print_subf_data
593: 575 0000E56B # }
594: 576 0000E56B # if( halt_flg )
595: 577 0000E56B L291:
596: 578 0000E56B 5d effffffb33 tstl _halt_flg
597: 579 0000E571 31 09 jeql L296
598: 580 0000E573 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
599: 581 0000E573 dd 01 pushl $1
600: 582 0000E575 fe 08 ef00000796 callf $8,_subf_er_halt
601: 583 0000E57C # if( loop_on_err ) {
602: 584 0000E57C L296:
603: 585 0000E57C 5d effffffb22 tstl _loop_on_err
604: 586 0000E582 31 0a jeql L297
605: 587 0000E584 # force_loop = TRUE; /* set the force loop flag */
606: 588 0000E584 0d 01 effffffb19 movl $1,_force_loop
607: 589 0000E58B # asm("brw _subf_4_lp1");; /* and loop on the error */
608: 590 0000E58B 13 ff4b brw _subf_4_lp1
609: 591 0000E58E # } /* end of loop on error */
610: 592 0000E58E # } /* end of compare error */
611: 593 0000E58E L297:
612: 594 0000E58E # } /* end of WHILE loop */
613: 595 0000E58E L290:
614: 596 0000E58E L286:
615: 597 0000E58E 6d effffffb10 incl _index
616: 598 0000E594 13 fef9 jbr L288
617: 599 0000E597 L287:
618: 600 0000E597 # } /* end of subtest 4 */
619: 601 0000E597 40 ret#2
620: 602 0000E598 .set L282,0x0
621: 603 0000E598 L284:
622: 604 0000E598 13 fee2 jbr L285
623: 605 0000E59B .data
624: 606 00000d28 * .text
625: 607 0000E59B 00 .align 1
626: 608 0000E59C .globl _subf_5
627: 609 0000E59C _subf_5:
628: 610 0000E59C 0000 .word L298
629: 611 0000E59E #
630: 612 0000E59E #
631: 613 0000E59E #
632: 614 0000E59E # /************************************************************************
633: 615 0000E59E # *
634: 616 0000E59E # * SUBTEST 5 - Wait 1 NOP before storing the results
635: 617 0000E59E # *
636: 618 0000E59E # ************************************************************************/
637: 619 0000E59E # subf_5()
638: 620 0000E59E # {
639: 621 0000E59E 13 011a jbr L300
640: 622 0000E5A1 L301:
641: 623 0000E5A1 # force_loop = FALSE;
642: 624 0000E5A1 4d effffffafd clrl _force_loop
643: 625 0000E5A7 # subtest = 5;
644: 626 0000E5A7 0d 05 effffffaf6 movl $5,_subtest
645: 627 0000E5AE # for( index = 0; index < max_subf_1_index; index++ ) {
646: 628 0000E5AE 4d effffffaf0 clrl _index
647: 629 0000E5B4 L304:
648: 630 0000E5B4 1d effffffaea effffffae5 cmpl _index,_max_subf_1_index
649: 631 0000E5BF 91 03 13 00f6 jgeq L303
650: 632 0000E5C4 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
651: 633 0000E5C4 5c 0c effffffad9 50 mull3 $12,_index,r0
652: 634 0000E5CC 0d e000000000 effffffacd movl _subf_1_data(r0),_sgl_ld_acc
653: 635 0000E5D7 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
654: 636 0000E5D7 5c 0c effffffac6 50 mull3 $12,_index,r0
655: 637 0000E5DF 0d e000000004 effffffaba movl _subf_1_data+4(r0),_sgl_value_1
656: 638 0000E5EA # sgl_expected = subf_1_data[index].exp; /* get expected result */
657: 639 0000E5EA 5c 0c effffffab3 50 mull3 $12,_index,r0
658: 640 0000E5F2 0d e000000008 effffffaa7 movl _subf_1_data+8(r0),_sgl_expected
659: 641 0000E5FD # /*
660: 642 0000E5FD # * If LOOP ON ERROR is set, this is the loop for this subtest.
661: 643 0000E5FD # * The force loop flag is set after the first error.
662: 644 0000E5FD # */
663: 645 0000E5FD # asm("_subf_5_lp1:");
664: 646 0000E5FD _subf_5_lp1:
665: 647 0000E5FD # asm("ldf _sgl_ld_acc"); /* load the 1st operand */
666: 648 0000E5FD 06 effffffaa1 ldf _sgl_ld_acc
667: 649 0000E603 # asm("nop"); /* delay */
668: 650 0000E603 10 nop
669: 651 0000E604 # asm("subf _sgl_value_1"); /* subract the 2nd operand */
670: 652 0000E604 d6 effffffa9a subf _sgl_value_1
671: 653 0000E60A # asm("nop"); /* delay before storing */
672: 654 0000E60A 10 nop
673: 655 0000E60B # asm("stf _sgl_st_acc"); /* store the result */
674: 656 0000E60B 26 effffffa93 stf _sgl_st_acc
675: 657 0000E611 # if( force_loop )
676: 658 0000E611 5d effffffa8d tstl _force_loop
677: 659 0000E617 31 02 jeql L305
678: 660 0000E619 # asm("brb _subf_5_lp1");; /* loop on the error */
679: 661 0000E619 11 e2 brb _subf_5_lp1
680: 662 0000E61B L305:
681: 663 0000E61B # /*
682: 664 0000E61B # * end error loop - test the results
683: 665 0000E61B # */
684: 666 0000E61B # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
685: 667 0000E61B 1d effffffa83 effffffa7e cmpl _sgl_st_acc,_sgl_expected
686: 668 0000E626 21 03 13 0086 jeql L306
687: 669 0000E62B # errcnt++; /* bump the error count */
688: 670 0000E62B 6d effffffa73 incl _errcnt
689: 671 0000E631 # if( prt_error ) {
690: 672 0000E631 5d effffffa6d tstl _prt_error
691: 673 0000E637 31 55 jeql L307
692: 674 0000E639 # writes(" \n"); /* start a new print line */
693: 675 0000E639 .data 1
694: 676 00000e47 * L308:
695: 677 00000e47 * 200A00 .ascii " \12\0"
696: 678 00000e4a * .text
697: 679 0000E639 dd 8f00000e47 pushl $L308
698: 680 0000E63F fe 08 effffffa5e callf $8,_writes
699: 681 0000E646 # writes("cycle: ");
700: 682 0000E646 .data 1
701: 683 00000e4a * L309:
702: 684 00000e4a * 6379636C653A2000 .ascii "cycle: \0"
703: 685 00000e52 * .text
704: 686 0000E646 dd 8f00000e4a pushl $L309
705: 687 0000E64C fe 08 effffffa51 callf $8,_writes
706: 688 0000E653 # writed( cycle );
707: 689 0000E653 dd effffffa4b pushl _cycle
708: 690 0000E659 fe 08 effffffa44 callf $8,_writed
709: 691 0000E660 # writes(" SUBF test ");
710: 692 0000E660 .data 1
711: 693 00000e52 * L310:
712: 694 00000e52 * 2020535542462074657374200 .ascii " SUBF test \0"
713: 0
714: 695 00000e5f * .text
715: 696 0000E660 dd 8f00000e52 pushl $L310
716: 697 0000E666 fe 08 effffffa37 callf $8,_writes
717: 698 0000E66D # writed( test_no );
718: 699 0000E66D dd effffffa31 pushl _test_no
719: 700 0000E673 fe 08 effffffa2a callf $8,_writed
720: 701 0000E67A # writes(", subtest 5 (Cache Data - 1 NOPS) - BAD FINAL ACC\n");
721: 702 0000E67A .data 1
722: 703 00000e5f * L311:
723: 704 00000e5f * 2C20737562746573742035202 .ascii ", subtest 5 (Cache Data - 1 NOPS) - BAD FINAL ACC\12\0"
724: 843616368652044617461202D
725: 2031204E4F505329202D20424
726: 1442046494E414C204143430A
727: 00
728: 705 00000e92 * .text
729: 706 0000E67A dd 8f00000e5f pushl $L311
730: 707 0000E680 fe 08 effffffa1d callf $8,_writes
731: 708 0000E687 # print_subf_data();
732: 709 0000E687 fe 04 ef000005e6 callf $4,_print_subf_data
733: 710 0000E68E # }
734: 711 0000E68E # if( halt_flg )
735: 712 0000E68E L307:
736: 713 0000E68E 5d effffffa10 tstl _halt_flg
737: 714 0000E694 31 09 jeql L312
738: 715 0000E696 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
739: 716 0000E696 dd 01 pushl $1
740: 717 0000E698 fe 08 ef00000673 callf $8,_subf_er_halt
741: 718 0000E69F # if( loop_on_err ) {
742: 719 0000E69F L312:
743: 720 0000E69F 5d effffff9ff tstl _loop_on_err
744: 721 0000E6A5 31 0a jeql L313
745: 722 0000E6A7 # force_loop = TRUE; /* set the force loop flag */
746: 723 0000E6A7 0d 01 effffff9f6 movl $1,_force_loop
747: 724 0000E6AE # asm("brw _subf_5_lp1");; /* and loop on the error */
748: 725 0000E6AE 13 ff4c brw _subf_5_lp1
749: 726 0000E6B1 # } /* end of loop on error */
750: 727 0000E6B1 # } /* end of compare error */
751: 728 0000E6B1 L313:
752: 729 0000E6B1 # } /* end of WHILE loop */
753: 730 0000E6B1 L306:
754: 731 0000E6B1 L302:
755: 732 0000E6B1 6d effffff9ed incl _index
756: 733 0000E6B7 13 fefa jbr L304
757: 734 0000E6BA L303:
758: 735 0000E6BA # } /* end of subtest 5 */
759: 736 0000E6BA 40 ret#2
760: 737 0000E6BB .set L298,0x0
761: 738 0000E6BB L300:
762: 739 0000E6BB 13 fee3 jbr L301
763: 740 0000E6BE .data
764: 741 00000d28 * .text
765: 742 0000E6BE .align 1
766: 743 0000E6BE .globl _subf_6
767: 744 0000E6BE _subf_6:
768: 745 0000E6BE 0000 .word L314
769: 746 0000E6C0 #
770: 747 0000E6C0 #
771: 748 0000E6C0 #
772: 749 0000E6C0 # /************************************************************************
773: 750 0000E6C0 # *
774: 751 0000E6C0 # * SUBTEST 6 - Check for register corruption
775: 752 0000E6C0 # *
776: 753 0000E6C0 # ************************************************************************/
777: 754 0000E6C0 # subf_6()
778: 755 0000E6C0 # {
779: 756 0000E6C0 13 01a7 jbr L316
780: 757 0000E6C3 L317:
781: 758 0000E6C3 # force_loop = FALSE; /* clear force_loop flg */
782: 759 0000E6C3 4d effffff9db clrl _force_loop
783: 760 0000E6C9 # subtest = 6;
784: 761 0000E6C9 0d 06 effffff9d4 movl $6,_subtest
785: 762 0000E6D0 # fill_reg_buf( load_regs ); /* get patterns for regs */
786: 763 0000E6D0 dd 8f00000000 pushl $_load_regs
787: 764 0000E6D6 fe 08 effffff9c7 callf $8,_fill_reg_buf
788: 765 0000E6DD # index = 0;
789: 766 0000E6DD 4d effffff9c1 clrl _index
790: 767 0000E6E3 # sgl_ld_acc = subf_1_data[0].op_1; /* get operand 1 */
791: 768 0000E6E3 0d effffff9bb effffff9b6 movl _subf_1_data,_sgl_ld_acc
792: 769 0000E6EE # sgl_value_1 = subf_1_data[0].op_2; /* get operand 2 */
793: 770 0000E6EE 0d effffff9b4 effffff9ab movl _subf_1_data+4,_sgl_value_1
794: 771 0000E6F9 # sgl_expected = subf_1_data[0].exp; /* get expected result */
795: 772 0000E6F9 0d effffff9ad effffff9a0 movl _subf_1_data+8,_sgl_expected
796: 773 0000E704 # /*
797: 774 0000E704 # * If LOOP ON ERROR is set, this is the loop for this subtest.
798: 775 0000E704 # * The force loop flag is set after the first error.
799: 776 0000E704 # */
800: 777 0000E704 # asm("_subf_6_lp1:");
801: 778 0000E704 _subf_6_lp1:
802: 779 0000E704 # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */
803: 780 0000E704 06 effffff99a ldf _sgl_ld_acc
804: 781 0000E70A # asm("nop");
805: 782 0000E70A 10 nop
806: 783 0000E70B # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
807: 784 0000E70B ab 891fff effffff990 loadr $0x1fff,_load_regs
808: 785 0000E714 # asm("nop");
809: 786 0000E714 10 nop
810: 787 0000E715 # asm("subf _sgl_value_1"); /* do the subraction */
811: 788 0000E715 d6 effffff989 subf _sgl_value_1
812: 789 0000E71B # asm("nop");
813: 790 0000E71B 10 nop
814: 791 0000E71C # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
815: 792 0000E71C bb 891fff effffff97f storer $0x1fff,_store_regs
816: 793 0000E725 # asm("stf _sgl_st_acc"); /* save the accumulator */
817: 794 0000E725 26 effffff979 stf _sgl_st_acc
818: 795 0000E72B # if( force_loop )
819: 796 0000E72B 5d effffff973 tstl _force_loop
820: 797 0000E731 31 02 jeql L319
821: 798 0000E733 # asm("brb _subf_6_lp1");; /* loop on the error */
822: 799 0000E733 11 cf brb _subf_6_lp1
823: 800 0000E735 L319:
824: 801 0000E735 # /*
825: 802 0000E735 # * Now compare the stored register values to those that were loaded
826: 803 0000E735 # */
827: 804 0000E735 # index2 = 0;
828: 805 0000E735 4d effffff969 clrl _index2
829: 806 0000E73B # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
830: 807 0000E73B L320:
831: 808 0000E73B 0d effffff963 50 movl _index2,r0
832: 809 0000E742 0d effffff95c 51 movl _index2,r1
833: 810 0000E749 1d 40effffff954 cmpl _load_regs[r0],_store_regs[r1]
834: 41effffff94e
835: 811 0000E756 21 11 jneq L321
836: 812 0000E758 1d effffff946 0d cmpl _index2,$13
837: 813 0000E75F 81 08 jgeq L321
838: 814 0000E761 # index2++; /* check reg values */
839: 815 0000E761 6d effffff93d incl _index2
840: 816 0000E767 11 d2 jbr L320
841: 817 0000E769 L321:
842: 818 0000E769 # if( index2 < 13 ) { /* error if index2 < 13 */
843: 819 0000E769 1d effffff935 0d cmpl _index2,$13
844: 820 0000E770 91 03 13 00f4 jgeq L322
845: 821 0000E775 # errcnt++; /* bump the error count */
846: 822 0000E775 6d effffff929 incl _errcnt
847: 823 0000E77B # if( prt_error ) {
848: 824 0000E77B 5d effffff923 tstl _prt_error
849: 825 0000E781 21 03 13 00c0 jeql L323
850: 826 0000E786 # writes(" \n"); /* start a new print line */
851: 827 0000E786 .data 1
852: 828 00000e92 * L324:
853: 829 00000e92 * 200A00 .ascii " \12\0"
854: 830 00000e95 * .text
855: 831 0000E786 dd 8f00000e92 pushl $L324
856: 832 0000E78C fe 08 effffff911 callf $8,_writes
857: 833 0000E793 # writes("cycle: ");
858: 834 0000E793 .data 1
859: 835 00000e95 * L325:
860: 836 00000e95 * 6379636C653A2000 .ascii "cycle: \0"
861: 837 00000e9d * .text
862: 838 0000E793 dd 8f00000e95 pushl $L325
863: 839 0000E799 fe 08 effffff904 callf $8,_writes
864: 840 0000E7A0 # writed( cycle );
865: 841 0000E7A0 dd effffff8fe pushl _cycle
866: 842 0000E7A6 fe 08 effffff8f7 callf $8,_writed
867: 843 0000E7AD # writes(" SUBF test ");
868: 844 0000E7AD .data 1
869: 845 00000e9d * L326:
870: 846 00000e9d * 2020535542462074657374200 .ascii " SUBF test \0"
871: 0
872: 847 00000eaa * .text
873: 848 0000E7AD dd 8f00000e9d pushl $L326
874: 849 0000E7B3 fe 08 effffff8ea callf $8,_writes
875: 850 0000E7BA # writed( test_no );
876: 851 0000E7BA dd effffff8e4 pushl _test_no
877: 852 0000E7C0 fe 08 effffff8dd callf $8,_writed
878: 853 0000E7C7 # writes(", subtest 6 - A REGISTER WAS MODIFIED\n");
879: 854 0000E7C7 .data 1
880: 855 00000eaa * L327:
881: 856 00000eaa * 2C20737562746573742036202 .ascii ", subtest 6 - A REGISTER WAS MODIFIED\12\0"
882: D204120524547495354455220
883: 574153204D4F4449464945440
884: A00
885: 857 00000ed1 * .text
886: 858 0000E7C7 dd 8f00000eaa pushl $L327
887: 859 0000E7CD fe 08 effffff8d0 callf $8,_writes
888: 860 0000E7D4 # print_subf_data(); /* print the operands */
889: 861 0000E7D4 fe 04 ef00000499 callf $4,_print_subf_data
890: 862 0000E7DB # writes("register "); /* print the information */
891: 863 0000E7DB .data 1
892: 864 00000ed1 * L328:
893: 865 00000ed1 * 72656769737465722000 .ascii "register \0"
894: 866 00000edb * .text
895: 867 0000E7DB dd 8f00000ed1 pushl $L328
896: 868 0000E7E1 fe 08 effffff8bc callf $8,_writes
897: 869 0000E7E8 # writed( index2 ); /* about the corrupted */
898: 870 0000E7E8 dd effffff8b6 pushl _index2
899: 871 0000E7EE fe 08 effffff8af callf $8,_writed
900: 872 0000E7F5 # writes(" = "); /* register */
901: 873 0000E7F5 .data 1
902: 874 00000edb * L329:
903: 875 00000edb * 203D2000 .ascii " = \0"
904: 876 00000edf * .text
905: 877 0000E7F5 dd 8f00000edb pushl $L329
906: 878 0000E7FB fe 08 effffff8a2 callf $8,_writes
907: 879 0000E802 # write32h( store_regs[index2] );
908: 880 0000E802 0d effffff89c 50 movl _index2,r0
909: 881 0000E809 dd 40effffff894 pushl _store_regs[r0]
910: 882 0000E810 fe 08 effffff88d callf $8,_write32h
911: 883 0000E817 # writes(", should be = ");
912: 884 0000E817 .data 1
913: 885 00000edf * L331:
914: 886 00000edf * 2C202073686F756C642062652 .ascii ", should be = \0"
915: 03D2000
916: 887 00000eef * .text
917: 888 0000E817 dd 8f00000edf pushl $L331
918: 889 0000E81D fe 08 effffff880 callf $8,_writes
919: 890 0000E824 # write32h( load_regs[index2] );
920: 891 0000E824 0d effffff87a 50 movl _index2,r0
921: 892 0000E82B dd 40effffff872 pushl _load_regs[r0]
922: 893 0000E832 fe 08 effffff86b callf $8,_write32h
923: 894 0000E839 # writes("\n");
924: 895 0000E839 .data 1
925: 896 00000eef * L332:
926: 897 00000eef * 0A00 .ascii "\12\0"
927: 898 00000ef1 * .text
928: 899 0000E839 dd 8f00000eef pushl $L332
929: 900 0000E83F fe 08 effffff85e callf $8,_writes
930: 901 0000E846 # }
931: 902 0000E846 # if( halt_flg )
932: 903 0000E846 L323:
933: 904 0000E846 5d effffff858 tstl _halt_flg
934: 905 0000E84C 31 09 jeql L333
935: 906 0000E84E # subf_er_halt( BAD_REG_HLT ); /* halt on the error */
936: 907 0000E84E dd 02 pushl $2
937: 908 0000E850 fe 08 ef000004bb callf $8,_subf_er_halt
938: 909 0000E857 # if( loop_on_err ) {
939: 910 0000E857 L333:
940: 911 0000E857 5d effffff847 tstl _loop_on_err
941: 912 0000E85D 31 0a jeql L334
942: 913 0000E85F # force_loop = TRUE; /* set the force loop flag */
943: 914 0000E85F 0d 01 effffff83e movl $1,_force_loop
944: 915 0000E866 # asm("brw _subf_6_lp1");; /* and loop on the error */
945: 916 0000E866 13 fe9b brw _subf_6_lp1
946: 917 0000E869 # } /* end of loop on error */
947: 918 0000E869 # } /* end of register corruption error */
948: 919 0000E869 L334:
949: 920 0000E869 # } /* end of subtest 6 */
950: 921 0000E869 L322:
951: 922 0000E869 40 ret#2
952: 923 0000E86A .set L314,0x0
953: 924 0000E86A L316:
954: 925 0000E86A 13 fe56 jbr L317
955: 926 0000E86D .data
956: 927 00000d28 * .text
957: 928 0000E86D 00 .align 1
958: 929 0000E86E .globl _subf_7
959: 930 0000E86E _subf_7:
960: 931 0000E86E 0000 .word L335
961: 932 0000E870 #
962: 933 0000E870 #
963: 934 0000E870 #
964: 935 0000E870 # /************************************************************************
965: 936 0000E870 # *
966: 937 0000E870 # * SUBTEST 7 - Check for PSL corruption
967: 938 0000E870 # *
968: 939 0000E870 # ************************************************************************/
969: 940 0000E870 # subf_7()
970: 941 0000E870 # {
971: 942 0000E870 13 01b1 jbr L337
972: 943 0000E873 L338:
973: 944 0000E873 # force_loop = FALSE; /* clear force_loop flg */
974: 945 0000E873 4d effffff82b clrl _force_loop
975: 946 0000E879 # subtest = 7;
976: 947 0000E879 0d 07 effffff824 movl $7,_subtest
977: 948 0000E880 # fill_reg_buf( load_regs ); /* get patterns for regs */
978: 949 0000E880 dd 8f00000000 pushl $_load_regs
979: 950 0000E886 fe 08 effffff817 callf $8,_fill_reg_buf
980: 951 0000E88D # for( index = 0; index < 3; index++ ) {
981: 952 0000E88D 4d effffff811 clrl _index
982: 953 0000E893 L341:
983: 954 0000E893 1d effffff80b 03 cmpl _index,$3
984: 955 0000E89A 91 03 13 0184 jgeq L340
985: 956 0000E89F # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
986: 957 0000E89F 5c 0c effffff7fe 50 mull3 $12,_index,r0
987: 958 0000E8A7 0d e000000000 effffff7f2 movl _subf_1_data(r0),_sgl_ld_acc
988: 959 0000E8B2 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
989: 960 0000E8B2 5c 0c effffff7eb 50 mull3 $12,_index,r0
990: 961 0000E8BA 0d e000000004 effffff7df movl _subf_1_data+4(r0),_sgl_value_1
991: 962 0000E8C5 # sgl_expected = subf_1_data[index].exp; /* get expected */
992: 963 0000E8C5 5c 0c effffff7d8 50 mull3 $12,_index,r0
993: 964 0000E8CD 0d e000000008 effffff7cc movl _subf_1_data+8(r0),_sgl_expected
994: 965 0000E8D8 # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
995: 966 0000E8D8 0d effffff7c6 50 movl _status_index,r0
996: 967 0000E8DF 0d 40effffff7be movl _status_array[r0],_sgl_dummy1
997: effffff7b9
998: 968 0000E8EB # /*
999: 969 0000E8EB # * If LOOP ON ERROR is set, this is the loop for this subtest.
1000: 970 0000E8EB # * The force loop flag is set after the first error.
1001: 971 0000E8EB # */
1002: 972 0000E8EB # asm("_subf_7_lp1:");
1003: 973 0000E8EB _subf_7_lp1:
1004: 974 0000E8EB # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */
1005: 975 0000E8EB 06 effffff7b3 ldf _sgl_ld_acc
1006: 976 0000E8F1 # asm("nop");
1007: 977 0000E8F1 10 nop
1008: 978 0000E8F2 # asm("tstl _sgl_dummy1"); /* set the PSL status */
1009: 979 0000E8F2 5d effffff7ac tstl _sgl_dummy1
1010: 980 0000E8F8 # asm("movpsl _init_psl"); /* save the initial PSL */
1011: 981 0000E8F8 cd effffff7a6 movpsl _init_psl
1012: 982 0000E8FE # asm("subf _sgl_value_1"); /* do the subract */
1013: 983 0000E8FE d6 effffff7a0 subf _sgl_value_1
1014: 984 0000E904 # asm("nop");
1015: 985 0000E904 10 nop
1016: 986 0000E905 # asm("movpsl _psl_val"); /* save the final PSL */
1017: 987 0000E905 cd effffff799 movpsl _psl_val
1018: 988 0000E90B # asm("stf _sgl_st_acc"); /* save the accumulator */
1019: 989 0000E90B 26 effffff793 stf _sgl_st_acc
1020: 990 0000E911 # if( force_loop )
1021: 991 0000E911 5d effffff78d tstl _force_loop
1022: 992 0000E917 31 02 jeql L342
1023: 993 0000E919 # asm("brb _subf_7_lp1");; /* loop on the error */
1024: 994 0000E919 11 d0 brb _subf_7_lp1
1025: 995 0000E91B L342:
1026: 996 0000E91B # /*
1027: 997 0000E91B # * Now compare the final PSL to the initial PSL -they should be the same
1028: 998 0000E91B # */
1029: 999 0000E91B # exp_psl = init_psl;
1030: 1000 0000E91B 0d effffff783 effffff77e movl _init_psl,_exp_psl
1031: 1001 0000E926 # if( psl_val != init_psl ) {
1032: 1002 0000E926 1d effffff778 effffff773 cmpl _psl_val,_init_psl
1033: 1003 0000E931 21 03 13 00e4 jeql L343
1034: 1004 0000E936 # errcnt++; /* bump the error count */
1035: 1005 0000E936 6d effffff768 incl _errcnt
1036: 1006 0000E93C # if( prt_error ) {
1037: 1007 0000E93C 5d effffff762 tstl _prt_error
1038: 1008 0000E942 21 03 13 00b0 jeql L344
1039: 1009 0000E947 # writes(" \n"); /* start a new print line */
1040: 1010 0000E947 .data 1
1041: 1011 00000ef1 * L345:
1042: 1012 00000ef1 * 200A00 .ascii " \12\0"
1043: 1013 00000ef4 * .text
1044: 1014 0000E947 dd 8f00000ef1 pushl $L345
1045: 1015 0000E94D fe 08 effffff750 callf $8,_writes
1046: 1016 0000E954 # writes("cycle: ");
1047: 1017 0000E954 .data 1
1048: 1018 00000ef4 * L346:
1049: 1019 00000ef4 * 6379636C653A2000 .ascii "cycle: \0"
1050: 1020 00000efc * .text
1051: 1021 0000E954 dd 8f00000ef4 pushl $L346
1052: 1022 0000E95A fe 08 effffff743 callf $8,_writes
1053: 1023 0000E961 # writed( cycle );
1054: 1024 0000E961 dd effffff73d pushl _cycle
1055: 1025 0000E967 fe 08 effffff736 callf $8,_writed
1056: 1026 0000E96E # writes(" SUBF test ");
1057: 1027 0000E96E .data 1
1058: 1028 00000efc * L347:
1059: 1029 00000efc * 2020535542462074657374200 .ascii " SUBF test \0"
1060: 0
1061: 1030 00000f09 * .text
1062: 1031 0000E96E dd 8f00000efc pushl $L347
1063: 1032 0000E974 fe 08 effffff729 callf $8,_writes
1064: 1033 0000E97B # writed( test_no );
1065: 1034 0000E97B dd effffff723 pushl _test_no
1066: 1035 0000E981 fe 08 effffff71c callf $8,_writed
1067: 1036 0000E988 # writes(", subtest 7 - INCORRECT FINAL PSL\n");
1068: 1037 0000E988 .data 1
1069: 1038 00000f09 * L348:
1070: 1039 00000f09 * 2C20737562746573742037202 .ascii ", subtest 7 - INCORRECT FINAL PSL\12\0"
1071: D20494E434F52524543542046
1072: 494E414C2050534C0A00
1073: 1040 00000f2c * .text
1074: 1041 0000E988 dd 8f00000f09 pushl $L348
1075: 1042 0000E98E fe 08 effffff70f callf $8,_writes
1076: 1043 0000E995 # print_subf_data(); /* print the operands */
1077: 1044 0000E995 fe 04 ef000002d8 callf $4,_print_subf_data
1078: 1045 0000E99C # writes("initial PSL = ");
1079: 1046 0000E99C .data 1
1080: 1047 00000f2c * L349:
1081: 1048 00000f2c * 696E697469616C2050534C203 .ascii "initial PSL = \0"
1082: D2000
1083: 1049 00000f3b * .text
1084: 1050 0000E99C dd 8f00000f2c pushl $L349
1085: 1051 0000E9A2 fe 08 effffff6fb callf $8,_writes
1086: 1052 0000E9A9 # write32h( init_psl );
1087: 1053 0000E9A9 dd effffff6f5 pushl _init_psl
1088: 1054 0000E9AF fe 08 effffff6ee callf $8,_write32h
1089: 1055 0000E9B6 # writes(", final PSL = ");
1090: 1056 0000E9B6 .data 1
1091: 1057 00000f3b * L350:
1092: 1058 00000f3b * 2C2066696E616C2050534C203 .ascii ", final PSL = \0"
1093: D2000
1094: 1059 00000f4a * .text
1095: 1060 0000E9B6 dd 8f00000f3b pushl $L350
1096: 1061 0000E9BC fe 08 effffff6e1 callf $8,_writes
1097: 1062 0000E9C3 # write32h( psl_val );
1098: 1063 0000E9C3 dd effffff6db pushl _psl_val
1099: 1064 0000E9C9 fe 08 effffff6d4 callf $8,_write32h
1100: 1065 0000E9D0 # writes(", expected PSL = ");
1101: 1066 0000E9D0 .data 1
1102: 1067 00000f4a * L351:
1103: 1068 00000f4a * 2C20657870656374656420505 .ascii ", expected PSL = \0"
1104: 34C203D2000
1105: 1069 00000f5c * .text
1106: 1070 0000E9D0 dd 8f00000f4a pushl $L351
1107: 1071 0000E9D6 fe 08 effffff6c7 callf $8,_writes
1108: 1072 0000E9DD # write32h( exp_psl );
1109: 1073 0000E9DD dd effffff6c1 pushl _exp_psl
1110: 1074 0000E9E3 fe 08 effffff6ba callf $8,_write32h
1111: 1075 0000E9EA # writes("\n");
1112: 1076 0000E9EA .data 1
1113: 1077 00000f5c * L352:
1114: 1078 00000f5c * 0A00 .ascii "\12\0"
1115: 1079 00000f5e * .text
1116: 1080 0000E9EA dd 8f00000f5c pushl $L352
1117: 1081 0000E9F0 fe 08 effffff6ad callf $8,_writes
1118: 1082 0000E9F7 # }
1119: 1083 0000E9F7 # if( halt_flg )
1120: 1084 0000E9F7 L344:
1121: 1085 0000E9F7 5d effffff6a7 tstl _halt_flg
1122: 1086 0000E9FD 31 09 jeql L353
1123: 1087 0000E9FF # subf_er_halt( BAD_PSL_HLT ); /* halt on the error */
1124: 1088 0000E9FF dd 03 pushl $3
1125: 1089 0000EA01 fe 08 ef0000030a callf $8,_subf_er_halt
1126: 1090 0000EA08 # if( loop_on_err ) {
1127: 1091 0000EA08 L353:
1128: 1092 0000EA08 5d effffff696 tstl _loop_on_err
1129: 1093 0000EA0E 31 0a jeql L354
1130: 1094 0000EA10 # force_loop = TRUE; /* set the force loop flag */
1131: 1095 0000EA10 0d 01 effffff68d movl $1,_force_loop
1132: 1096 0000EA17 # asm("brw _subf_7_lp1");; /* and loop on the error */
1133: 1097 0000EA17 13 fed1 brw _subf_7_lp1
1134: 1098 0000EA1A # } /* end of loop on error */
1135: 1099 0000EA1A # } /* end of PSL corruption error */
1136: 1100 0000EA1A L354:
1137: 1101 0000EA1A # } /* end of WHILE loop */
1138: 1102 0000EA1A L343:
1139: 1103 0000EA1A L339:
1140: 1104 0000EA1A 6d effffff684 incl _index
1141: 1105 0000EA20 13 fe70 jbr L341
1142: 1106 0000EA23 L340:
1143: 1107 0000EA23 # } /* end of subtest 7 */
1144: 1108 0000EA23 40 ret#2
1145: 1109 0000EA24 .set L335,0x0
1146: 1110 0000EA24 L337:
1147: 1111 0000EA24 13 fe4c jbr L338
1148: 1112 0000EA27 .data
1149: 1113 00000d28 * .text
1150: 1114 0000EA27 00 .align 1
1151: 1115 0000EA28 .globl _subf_8
1152: 1116 0000EA28 _subf_8:
1153: 1117 0000EA28 0000 .word L355
1154: 1118 0000EA2A #
1155: 1119 0000EA2A #
1156: 1120 0000EA2A #
1157: 1121 0000EA2A # /************************************************************************
1158: 1122 0000EA2A # *
1159: 1123 0000EA2A # * SUBTEST 8 - pipelined entry test
1160: 1124 0000EA2A # *
1161: 1125 0000EA2A # ************************************************************************/
1162: 1126 0000EA2A # subf_8()
1163: 1127 0000EA2A # {
1164: 1128 0000EA2A 13 011d jbr L357
1165: 1129 0000EA2D L358:
1166: 1130 0000EA2D # force_loop = FALSE;
1167: 1131 0000EA2D 4d effffff671 clrl _force_loop
1168: 1132 0000EA33 # subtest = 8;
1169: 1133 0000EA33 0d 08 effffff66a movl $8,_subtest
1170: 1134 0000EA3A # for( index = 0; index < max_subf_1_index; index++ ) {
1171: 1135 0000EA3A 4d effffff664 clrl _index
1172: 1136 0000EA40 L361:
1173: 1137 0000EA40 1d effffff65e effffff659 cmpl _index,_max_subf_1_index
1174: 1138 0000EA4B 91 03 13 00f9 jgeq L360
1175: 1139 0000EA50 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
1176: 1140 0000EA50 5c 0c effffff64d 50 mull3 $12,_index,r0
1177: 1141 0000EA58 0d e000000000 effffff641 movl _subf_1_data(r0),_sgl_ld_acc
1178: 1142 0000EA63 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
1179: 1143 0000EA63 5c 0c effffff63a 50 mull3 $12,_index,r0
1180: 1144 0000EA6B 0d e000000004 effffff62e movl _subf_1_data+4(r0),_sgl_value_1
1181: 1145 0000EA76 # sgl_expected = subf_1_data[index].exp; /* get expected result */
1182: 1146 0000EA76 5c 0c effffff627 50 mull3 $12,_index,r0
1183: 1147 0000EA7E 0d e000000008 effffff61b movl _subf_1_data+8(r0),_sgl_expected
1184: 1148 0000EA89 # /*
1185: 1149 0000EA89 # * If LOOP ON ERROR is set, this is the loop for this subtest.
1186: 1150 0000EA89 # * The force loop flag is set after the first error.
1187: 1151 0000EA89 # */
1188: 1152 0000EA89 # asm("_subf_8_lp1:");
1189: 1153 0000EA89 _subf_8_lp1:
1190: 1154 0000EA89 # asm("movl $0,r0"); /* clear r0 */
1191: 1155 0000EA89 0d 00 50 movl $0,r0
1192: 1156 0000EA8C # asm("ldf r0"); /* load the Acc. with 0.0 */
1193: 1157 0000EA8C 06 50 ldf r0
1194: 1158 0000EA8E # asm("addf _sgl_ld_acc"); /* add the 1st operand */
1195: 1159 0000EA8E c6 effffff610 addf _sgl_ld_acc
1196: 1160 0000EA94 # asm("subf _sgl_value_1"); /* subract the 2nd operand */
1197: 1161 0000EA94 d6 effffff60a subf _sgl_value_1
1198: 1162 0000EA9A # asm("stf _sgl_st_acc"); /* store the result */
1199: 1163 0000EA9A 26 effffff604 stf _sgl_st_acc
1200: 1164 0000EAA0 # if( force_loop )
1201: 1165 0000EAA0 5d effffff5fe tstl _force_loop
1202: 1166 0000EAA6 31 02 jeql L362
1203: 1167 0000EAA8 # asm("brb _subf_8_lp1");; /* loop on the error */
1204: 1168 0000EAA8 11 df brb _subf_8_lp1
1205: 1169 0000EAAA L362:
1206: 1170 0000EAAA # /*
1207: 1171 0000EAAA # * end error loop - test the results
1208: 1172 0000EAAA # */
1209: 1173 0000EAAA # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1210: 1174 0000EAAA 1d effffff5f4 effffff5ef cmpl _sgl_st_acc,_sgl_expected
1211: 1175 0000EAB5 21 03 13 0086 jeql L363
1212: 1176 0000EABA # errcnt++; /* bump the error count */
1213: 1177 0000EABA 6d effffff5e4 incl _errcnt
1214: 1178 0000EAC0 # if( prt_error ) {
1215: 1179 0000EAC0 5d effffff5de tstl _prt_error
1216: 1180 0000EAC6 31 55 jeql L364
1217: 1181 0000EAC8 # writes(" \n"); /* start a new print line */
1218: 1182 0000EAC8 .data 1
1219: 1183 00000f5e * L365:
1220: 1184 00000f5e * 200A00 .ascii " \12\0"
1221: 1185 00000f61 * .text
1222: 1186 0000EAC8 dd 8f00000f5e pushl $L365
1223: 1187 0000EACE fe 08 effffff5cf callf $8,_writes
1224: 1188 0000EAD5 # writes("cycle: ");
1225: 1189 0000EAD5 .data 1
1226: 1190 00000f61 * L366:
1227: 1191 00000f61 * 6379636C653A2000 .ascii "cycle: \0"
1228: 1192 00000f69 * .text
1229: 1193 0000EAD5 dd 8f00000f61 pushl $L366
1230: 1194 0000EADB fe 08 effffff5c2 callf $8,_writes
1231: 1195 0000EAE2 # writed( cycle );
1232: 1196 0000EAE2 dd effffff5bc pushl _cycle
1233: 1197 0000EAE8 fe 08 effffff5b5 callf $8,_writed
1234: 1198 0000EAEF # writes(" SUBF test ");
1235: 1199 0000EAEF .data 1
1236: 1200 00000f69 * L367:
1237: 1201 00000f69 * 2020535542462074657374200 .ascii " SUBF test \0"
1238: 0
1239: 1202 00000f76 * .text
1240: 1203 0000EAEF dd 8f00000f69 pushl $L367
1241: 1204 0000EAF5 fe 08 effffff5a8 callf $8,_writes
1242: 1205 0000EAFC # writed( test_no );
1243: 1206 0000EAFC dd effffff5a2 pushl _test_no
1244: 1207 0000EB02 fe 08 effffff59b callf $8,_writed
1245: 1208 0000EB09 # writes(", subtest 8 (Piped Entry) - BAD FINAL ACC\n");
1246: 1209 0000EB09 .data 1
1247: 1210 00000f76 * L368:
1248: 1211 00000f76 * 2C20737562746573742038202 .ascii ", subtest 8 (Piped Entry) - BAD FINAL ACC\12\0"
1249: 8506970656420456E74727929
1250: 202D204241442046494E414C2
1251: 04143430A00
1252: 1212 00000fa1 * .text
1253: 1213 0000EB09 dd 8f00000f76 pushl $L368
1254: 1214 0000EB0F fe 08 effffff58e callf $8,_writes
1255: 1215 0000EB16 # print_subf_data();
1256: 1216 0000EB16 fe 04 ef00000157 callf $4,_print_subf_data
1257: 1217 0000EB1D # }
1258: 1218 0000EB1D # if( halt_flg )
1259: 1219 0000EB1D L364:
1260: 1220 0000EB1D 5d effffff581 tstl _halt_flg
1261: 1221 0000EB23 31 09 jeql L369
1262: 1222 0000EB25 # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
1263: 1223 0000EB25 dd 01 pushl $1
1264: 1224 0000EB27 fe 08 ef000001e4 callf $8,_subf_er_halt
1265: 1225 0000EB2E # if( loop_on_err ) {
1266: 1226 0000EB2E L369:
1267: 1227 0000EB2E 5d effffff570 tstl _loop_on_err
1268: 1228 0000EB34 31 0a jeql L370
1269: 1229 0000EB36 # force_loop = TRUE; /* set the force loop flag */
1270: 1230 0000EB36 0d 01 effffff567 movl $1,_force_loop
1271: 1231 0000EB3D # asm("brw _subf_8_lp1");; /* and loop on the error */
1272: 1232 0000EB3D 13 ff49 brw _subf_8_lp1
1273: 1233 0000EB40 # } /* end of loop on error */
1274: 1234 0000EB40 # } /* end of compare error */
1275: 1235 0000EB40 L370:
1276: 1236 0000EB40 # } /* end of WHILE loop */
1277: 1237 0000EB40 L363:
1278: 1238 0000EB40 L359:
1279: 1239 0000EB40 6d effffff55e incl _index
1280: 1240 0000EB46 13 fef7 jbr L361
1281: 1241 0000EB49 L360:
1282: 1242 0000EB49 # } /* end of subtest 8 */
1283: 1243 0000EB49 40 ret#2
1284: 1244 0000EB4A .set L355,0x0
1285: 1245 0000EB4A L357:
1286: 1246 0000EB4A 13 fee0 jbr L358
1287: 1247 0000EB4D .data
1288: 1248 00000d28 * .text
1289: 1249 0000EB4D 00 .align 1
1290: 1250 0000EB4E .globl _subf_9
1291: 1251 0000EB4E _subf_9:
1292: 1252 0000EB4E 0000 .word L371
1293: 1253 0000EB50 #
1294: 1254 0000EB50 #
1295: 1255 0000EB50 #
1296: 1256 0000EB50 # /************************************************************************
1297: 1257 0000EB50 # *
1298: 1258 0000EB50 # * SUBTEST 9 - pipelined exit test
1299: 1259 0000EB50 # *
1300: 1260 0000EB50 # ************************************************************************/
1301: 1261 0000EB50 # subf_9()
1302: 1262 0000EB50 # {
1303: 1263 0000EB50 13 011d jbr L373
1304: 1264 0000EB53 L374:
1305: 1265 0000EB53 # force_loop = FALSE;
1306: 1266 0000EB53 4d effffff54b clrl _force_loop
1307: 1267 0000EB59 # subtest = 9;
1308: 1268 0000EB59 0d 09 effffff544 movl $9,_subtest
1309: 1269 0000EB60 # for( index = 0; index < max_subf_1_index; index++ ) {
1310: 1270 0000EB60 4d effffff53e clrl _index
1311: 1271 0000EB66 L377:
1312: 1272 0000EB66 1d effffff538 effffff533 cmpl _index,_max_subf_1_index
1313: 1273 0000EB71 91 03 13 00f9 jgeq L376
1314: 1274 0000EB76 # sgl_ld_acc = subf_1_data[index].op_1; /* get operand 1 */
1315: 1275 0000EB76 5c 0c effffff527 50 mull3 $12,_index,r0
1316: 1276 0000EB7E 0d e000000000 effffff51b movl _subf_1_data(r0),_sgl_ld_acc
1317: 1277 0000EB89 # sgl_value_1 = subf_1_data[index].op_2; /* get operand 2 */
1318: 1278 0000EB89 5c 0c effffff514 50 mull3 $12,_index,r0
1319: 1279 0000EB91 0d e000000004 effffff508 movl _subf_1_data+4(r0),_sgl_value_1
1320: 1280 0000EB9C # sgl_expected = subf_1_data[index].exp; /* get expected result */
1321: 1281 0000EB9C 5c 0c effffff501 50 mull3 $12,_index,r0
1322: 1282 0000EBA4 0d e000000008 effffff4f5 movl _subf_1_data+8(r0),_sgl_expected
1323: 1283 0000EBAF # /*
1324: 1284 0000EBAF # * If LOOP ON ERROR is set, this is the loop for this subtest.
1325: 1285 0000EBAF # * The force loop flag is set after the first error.
1326: 1286 0000EBAF # */
1327: 1287 0000EBAF # asm("_subf_9_lp1:");
1328: 1288 0000EBAF _subf_9_lp1:
1329: 1289 0000EBAF # asm("movl $0,r0"); /* clear r0 */
1330: 1290 0000EBAF 0d 00 50 movl $0,r0
1331: 1291 0000EBB2 # asm("ldf _sgl_ld_acc"); /* load the 1st operand */
1332: 1292 0000EBB2 06 effffff4ec ldf _sgl_ld_acc
1333: 1293 0000EBB8 # asm("subf _sgl_value_1"); /* subract the 2nd operand */
1334: 1294 0000EBB8 d6 effffff4e6 subf _sgl_value_1
1335: 1295 0000EBBE # asm("addf r0"); /* add a 0.0 to the result */
1336: 1296 0000EBBE c6 50 addf r0
1337: 1297 0000EBC0 # asm("stf _sgl_st_acc"); /* store the result */
1338: 1298 0000EBC0 26 effffff4de stf _sgl_st_acc
1339: 1299 0000EBC6 # if( force_loop )
1340: 1300 0000EBC6 5d effffff4d8 tstl _force_loop
1341: 1301 0000EBCC 31 02 jeql L378
1342: 1302 0000EBCE # asm("brb _subf_9_lp1");; /* loop on the error */
1343: 1303 0000EBCE 11 df brb _subf_9_lp1
1344: 1304 0000EBD0 L378:
1345: 1305 0000EBD0 # /*
1346: 1306 0000EBD0 # * end error loop - test the results
1347: 1307 0000EBD0 # */
1348: 1308 0000EBD0 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
1349: 1309 0000EBD0 1d effffff4ce effffff4c9 cmpl _sgl_st_acc,_sgl_expected
1350: 1310 0000EBDB 21 03 13 0086 jeql L379
1351: 1311 0000EBE0 # errcnt++; /* bump the error count */
1352: 1312 0000EBE0 6d effffff4be incl _errcnt
1353: 1313 0000EBE6 # if( prt_error ) {
1354: 1314 0000EBE6 5d effffff4b8 tstl _prt_error
1355: 1315 0000EBEC 31 55 jeql L380
1356: 1316 0000EBEE # writes(" \n"); /* start a new print line */
1357: 1317 0000EBEE .data 1
1358: 1318 00000fa1 * L381:
1359: 1319 00000fa1 * 200A00 .ascii " \12\0"
1360: 1320 00000fa4 * .text
1361: 1321 0000EBEE dd 8f00000fa1 pushl $L381
1362: 1322 0000EBF4 fe 08 effffff4a9 callf $8,_writes
1363: 1323 0000EBFB # writes("cycle: ");
1364: 1324 0000EBFB .data 1
1365: 1325 00000fa4 * L382:
1366: 1326 00000fa4 * 6379636C653A2000 .ascii "cycle: \0"
1367: 1327 00000fac * .text
1368: 1328 0000EBFB dd 8f00000fa4 pushl $L382
1369: 1329 0000EC01 fe 08 effffff49c callf $8,_writes
1370: 1330 0000EC08 # writed( cycle );
1371: 1331 0000EC08 dd effffff496 pushl _cycle
1372: 1332 0000EC0E fe 08 effffff48f callf $8,_writed
1373: 1333 0000EC15 # writes(" SUBF test ");
1374: 1334 0000EC15 .data 1
1375: 1335 00000fac * L383:
1376: 1336 00000fac * 2020535542462074657374200 .ascii " SUBF test \0"
1377: 0
1378: 1337 00000fb9 * .text
1379: 1338 0000EC15 dd 8f00000fac pushl $L383
1380: 1339 0000EC1B fe 08 effffff482 callf $8,_writes
1381: 1340 0000EC22 # writed( test_no );
1382: 1341 0000EC22 dd effffff47c pushl _test_no
1383: 1342 0000EC28 fe 08 effffff475 callf $8,_writed
1384: 1343 0000EC2F # writes(", subtest 9 (Piped Exit) - BAD FINAL ACC\n");
1385: 1344 0000EC2F .data 1
1386: 1345 00000fb9 * L384:
1387: 1346 00000fb9 * 2C20737562746573742039202 .ascii ", subtest 9 (Piped Exit) - BAD FINAL ACC\12\0"
1388: 8506970656420457869742920
1389: 2D204241442046494E414C204
1390: 143430A00
1391: 1347 00000fe3 * .text
1392: 1348 0000EC2F dd 8f00000fb9 pushl $L384
1393: 1349 0000EC35 fe 08 effffff468 callf $8,_writes
1394: 1350 0000EC3C # print_subf_data();
1395: 1351 0000EC3C fe 04 ef00000031 callf $4,_print_subf_data
1396: 1352 0000EC43 # }
1397: 1353 0000EC43 # if( halt_flg )
1398: 1354 0000EC43 L380:
1399: 1355 0000EC43 5d effffff45b tstl _halt_flg
1400: 1356 0000EC49 31 09 jeql L385
1401: 1357 0000EC4B # subf_er_halt( BAD_ACC_HLT ); /* halt on the error */
1402: 1358 0000EC4B dd 01 pushl $1
1403: 1359 0000EC4D fe 08 ef000000be callf $8,_subf_er_halt
1404: 1360 0000EC54 # if( loop_on_err ) {
1405: 1361 0000EC54 L385:
1406: 1362 0000EC54 5d effffff44a tstl _loop_on_err
1407: 1363 0000EC5A 31 0a jeql L386
1408: 1364 0000EC5C # force_loop = TRUE; /* set the force loop flag */
1409: 1365 0000EC5C 0d 01 effffff441 movl $1,_force_loop
1410: 1366 0000EC63 # asm("brw _subf_9_lp1");; /* and loop on the error */
1411: 1367 0000EC63 13 ff49 brw _subf_9_lp1
1412: 1368 0000EC66 # } /* end of loop on error */
1413: 1369 0000EC66 # } /* end of compare error */
1414: 1370 0000EC66 L386:
1415: 1371 0000EC66 # } /* end of WHILE loop */
1416: 1372 0000EC66 L379:
1417: 1373 0000EC66 L375:
1418: 1374 0000EC66 6d effffff438 incl _index
1419: 1375 0000EC6C 13 fef7 jbr L377
1420: 1376 0000EC6F L376:
1421: 1377 0000EC6F # } /* end of subtest 9 */
1422: 1378 0000EC6F 40 ret#2
1423: 1379 0000EC70 .set L371,0x0
1424: 1380 0000EC70 L373:
1425: 1381 0000EC70 13 fee0 jbr L374
1426: 1382 0000EC73 .data
1427: 1383 00000d28 * .text
1428: 1384 0000EC73 00 .align 1
1429: 1385 0000EC74 .globl _print_subf_data
1430: 1386 0000EC74 _print_subf_data:
1431: 1387 0000EC74 0000 .word L387
1432: 1388 0000EC76 #
1433: 1389 0000EC76 #
1434: 1390 0000EC76 #
1435: 1391 0000EC76 # /**************************************************************************
1436: 1392 0000EC76 # *
1437: 1393 0000EC76 # * PRINT THE DATA AND STORE RESULTS
1438: 1394 0000EC76 # *
1439: 1395 0000EC76 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
1440: 1396 0000EC76 # * operand = xxxxxxxx, expected = xxxxxxxx
1441: 1397 0000EC76 # **************************************************************************/
1442: 1398 0000EC76 # print_subf_data()
1443: 1399 0000EC76 # {
1444: 1400 0000EC76 13 0095 jbr L389
1445: 1401 0000EC79 L390:
1446: 1402 0000EC79 # writes("initial Acc = ");
1447: 1403 0000EC79 .data 1
1448: 1404 00000fe3 * L391:
1449: 1405 00000fe3 * 696E697469616C20416363203 .ascii "initial Acc = \0"
1450: D2000
1451: 1406 00000ff2 * .text
1452: 1407 0000EC79 dd 8f00000fe3 pushl $L391
1453: 1408 0000EC7F fe 08 effffff41e callf $8,_writes
1454: 1409 0000EC86 # write32h( sgl_ld_acc );
1455: 1410 0000EC86 dd effffff418 pushl _sgl_ld_acc
1456: 1411 0000EC8C fe 08 effffff411 callf $8,_write32h
1457: 1412 0000EC93 # writes(", stored = ");
1458: 1413 0000EC93 .data 1
1459: 1414 00000ff2 * L392:
1460: 1415 00000ff2 * 2C2020202073746F726564203 .ascii ", stored = \0"
1461: D2000
1462: 1416 00001001 * .text
1463: 1417 0000EC93 dd 8f00000ff2 pushl $L392
1464: 1418 0000EC99 fe 08 effffff404 callf $8,_writes
1465: 1419 0000ECA0 # write32h( sgl_st_acc );
1466: 1420 0000ECA0 dd effffff3fe pushl _sgl_st_acc
1467: 1421 0000ECA6 fe 08 effffff3f7 callf $8,_write32h
1468: 1422 0000ECAD # writes(", data index = ");
1469: 1423 0000ECAD .data 1
1470: 1424 00001001 * L393:
1471: 1425 00001001 * 2C20206461746120696E64657 .ascii ", data index = \0"
1472: 8203D2000
1473: 1426 00001012 * .text
1474: 1427 0000ECAD dd 8f00001001 pushl $L393
1475: 1428 0000ECB3 fe 08 effffff3ea callf $8,_writes
1476: 1429 0000ECBA # writed( index );
1477: 1430 0000ECBA dd effffff3e4 pushl _index
1478: 1431 0000ECC0 fe 08 effffff3dd callf $8,_writed
1479: 1432 0000ECC7 # writec('\n');
1480: 1433 0000ECC7 dd 0a pushl $10
1481: 1434 0000ECC9 fe 08 effffff3d4 callf $8,_writec
1482: 1435 0000ECD0 # writes(" operand = ");
1483: 1436 0000ECD0 .data 1
1484: 1437 00001012 * L395:
1485: 1438 00001012 * 202020206F706572616E64203 .ascii " operand = \0"
1486: D2000
1487: 1439 00001021 * .text
1488: 1440 0000ECD0 dd 8f00001012 pushl $L395
1489: 1441 0000ECD6 fe 08 effffff3c7 callf $8,_writes
1490: 1442 0000ECDD # write32h( sgl_value_1 );
1491: 1443 0000ECDD dd effffff3c1 pushl _sgl_value_1
1492: 1444 0000ECE3 fe 08 effffff3ba callf $8,_write32h
1493: 1445 0000ECEA # writes(", expected = ");
1494: 1446 0000ECEA .data 1
1495: 1447 00001021 * L396:
1496: 1448 00001021 * 2C20206578706563746564203 .ascii ", expected = \0"
1497: D2000
1498: 1449 00001030 * .text
1499: 1450 0000ECEA dd 8f00001021 pushl $L396
1500: 1451 0000ECF0 fe 08 effffff3ad callf $8,_writes
1501: 1452 0000ECF7 # write32h( sgl_expected );
1502: 1453 0000ECF7 dd effffff3a7 pushl _sgl_expected
1503: 1454 0000ECFD fe 08 effffff3a0 callf $8,_write32h
1504: 1455 0000ED04 # writec('\n');
1505: 1456 0000ED04 dd 0a pushl $10
1506: 1457 0000ED06 fe 08 effffff397 callf $8,_writec
1507: 1458 0000ED0D # }
1508: 1459 0000ED0D 40 ret#2
1509: 1460 0000ED0E .set L387,0x0
1510: 1461 0000ED0E L389:
1511: 1462 0000ED0E 13 ff68 jbr L390
1512: 1463 0000ED11 .data
1513: 1464 00000d28 * .text
1514: 1465 0000ED11 00 .align 1
1515: 1466 0000ED12 .globl _subf_er_halt
1516: 1467 0000ED12 _subf_er_halt:
1517: 1468 0000ED12 0000 .word L397
1518: 1469 0000ED14 #
1519: 1470 0000ED14 #
1520: 1471 0000ED14 #
1521: 1472 0000ED14 # /**************************************************************************
1522: 1473 0000ED14 # *
1523: 1474 0000ED14 # * HALT ON ERROR ROUTINE
1524: 1475 0000ED14 # *
1525: 1476 0000ED14 # **************************************************************************/
1526: 1477 0000ED14 # subf_er_halt( halt_code )
1527: 1478 0000ED14 # int halt_code;
1528: 1479 0000ED14 # {
1529: 1480 0000ED14 13 00af jbr L399
1530: 1481 0000ED17 L400:
1531: 1482 0000ED17 # sgl_dummy1 = halt_code; /* get the error type */
1532: 1483 0000ED17 0d ad04 effffff385 movl 4(fp),_sgl_dummy1
1533: 1484 0000ED1F # asm("movl _test_no,r0"); /* r0 = test number */
1534: 1485 0000ED1F 0d effffff37f 50 movl _test_no,r0
1535: 1486 0000ED26 # asm("movl _subtest,r1"); /* r1 = subtest number */
1536: 1487 0000ED26 0d effffff378 51 movl _subtest,r1
1537: 1488 0000ED2D # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1538: 1489 0000ED2D 0d effffff371 52 movl _sgl_dummy1,r2
1539: 1490 0000ED34 # asm("movl _cycle,r3"); /* r3 = cycle count */
1540: 1491 0000ED34 0d effffff36a 53 movl _cycle,r3
1541: 1492 0000ED3B # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
1542: 1493 0000ED3B 0d effffff363 54 movl _sgl_ld_acc,r4
1543: 1494 0000ED42 # asm("movl _sgl_value_1,r5"); /* r5 = data subtracted */
1544: 1495 0000ED42 0d effffff35c 55 movl _sgl_value_1,r5
1545: 1496 0000ED49 # asm("movl _sgl_st_acc,r6"); /* r6 = data stored */
1546: 1497 0000ED49 0d effffff355 56 movl _sgl_st_acc,r6
1547: 1498 0000ED50 # if(halt_code == BAD_ACC_HLT ) {
1548: 1499 0000ED50 1d ad04 01 cmpl 4(fp),$1
1549: 1500 0000ED54 21 10 jneq L401
1550: 1501 0000ED56 # asm("movl _sgl_expected,r7"); /* r7 = data expected */
1551: 1502 0000ED56 0d effffff348 57 movl _sgl_expected,r7
1552: 1503 0000ED5D # asm("movl _index,r8"); /* r8 = data index */
1553: 1504 0000ED5D 0d effffff341 58 movl _index,r8
1554: 1505 0000ED64 # } else
1555: 1506 0000ED64 11 5e jbr L402
1556: 1507 0000ED66 L401:
1557: 1508 0000ED66 # if( halt_code == BAD_REG_HLT ) {
1558: 1509 0000ED66 1d ad04 02 cmpl 4(fp),$2
1559: 1510 0000ED6A 21 3d jneq L403
1560: 1511 0000ED6C # sgl_dummy1 = load_regs[index2];
1561: 1512 0000ED6C 0d effffff332 50 movl _index2,r0
1562: 1513 0000ED73 0d 40effffff32a movl _load_regs[r0],_sgl_dummy1
1563: effffff325
1564: 1514 0000ED7F # sgl_dummy2 = store_regs[index2];
1565: 1515 0000ED7F 0d effffff31f 50 movl _index2,r0
1566: 1516 0000ED86 0d 40effffff317 movl _store_regs[r0],_sgl_dummy2
1567: effffff312
1568: 1517 0000ED92 # asm("movl _index2,r7"); /* r7 = bad register # */
1569: 1518 0000ED92 0d effffff30c 57 movl _index2,r7
1570: 1519 0000ED99 # asm("movl _sgl_dummy2,r8"); /* r8 = actual value */
1571: 1520 0000ED99 0d effffff305 58 movl _sgl_dummy2,r8
1572: 1521 0000EDA0 # asm("movl _sgl_dummy1,r9"); /* r9 = expected value */
1573: 1522 0000EDA0 0d effffff2fe 59 movl _sgl_dummy1,r9
1574: 1523 0000EDA7 # } else
1575: 1524 0000EDA7 11 1b jbr L404
1576: 1525 0000EDA9 L403:
1577: 1526 0000EDA9 # if( halt_code == BAD_PSL_HLT ) {
1578: 1527 0000EDA9 1d ad04 03 cmpl 4(fp),$3
1579: 1528 0000EDAD 21 15 jneq L405
1580: 1529 0000EDAF # asm("movl _init_psl,r7"); /* r7 = initial PSL */
1581: 1530 0000EDAF 0d effffff2ef 57 movl _init_psl,r7
1582: 1531 0000EDB6 # asm("movl _psl_val,r8"); /* r8 = final PSL */
1583: 1532 0000EDB6 0d effffff2e8 58 movl _psl_val,r8
1584: 1533 0000EDBD # asm("movl _exp_psl,r9"); /* r9 = expected PSL */
1585: 1534 0000EDBD 0d effffff2e1 59 movl _exp_psl,r9
1586: 1535 0000EDC4 # };
1587: 1536 0000EDC4 L405:
1588: 1537 0000EDC4 L404:
1589: 1538 0000EDC4 L402:
1590: 1539 0000EDC4 # asm("halt"); /* HALT ... */
1591: 1540 0000EDC4 00 halt
1592: 1541 0000EDC5 # }
1593: 1542 0000EDC5 40 ret#2
1594: 1543 0000EDC6 .set L397,0x0
1595: 1544 0000EDC6 L399:
1596: 1545 0000EDC6 13 ff4e jbr L400
1597: 1546 0000EDC9 .data
1598: 1546 0001CE6D .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.