![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lnf.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 lnf.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 0000093c * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _lnf
6: 6 00000000 _lnf:
7: 7 00010810 0000 .word L215
8: 8 00010812 #
9: 9 00010812 # #include "fpp_defs.h"
10: 10 00010812 #
11: 11 00010812 #
12: 12 00010812 # /*****************************************************************************
13: 13 00010812 # *
14: 14 00010812 # * LNF - SINGLE PRECISION FLOATING POINT LOAD_NEGATE TEST
15: 15 00010812 # *
16: 16 00010812 # *****************************************************************************/
17: 17 00010812 # lnf()
18: 18 00010812 # {
19: 19 00010812 11 57 jbr L217
20: 20 00010814 L218:
21: 21 00010814 # asm(".globl _lnf_t");
22: 22 00010814 .globl _lnf_t
23: 23 00010814 # asm("_lnf_t:"); /* entry address */
24: 24 00010814 _lnf_t:
25: 25 00010814 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
26: 26 00010814 1d effffffff6 01 cmpl _cycle,$1
27: 27 0001081B 21 15 jneq L219
28: 28 0001081D 5d efffffffed tstl _prt_hdrs
29: 29 00010823 31 0d jeql L219
30: 30 00010825 # writes(" LNF");
31: 31 00010825 .data 1
32: 32 0000093c * L221:
33: 33 0000093c * 204C4E4600 .ascii " LNF\0"
34: 34 00000941 * .text
35: 35 00010825 dd 8f0000093c pushl $L221
36: 36 0001082B fe 08 efffffffde callf $8,_writes
37: 37 00010832 # lnf_1(); /* load through a register */
38: 38 00010832 L219:
39: 39 00010832 fe 04 ef00000035 callf $4,_lnf_1
40: 40 00010839 # lnf_2(); /* load through the cache */
41: 41 00010839 fe 04 ef00000164 callf $4,_lnf_2
42: 42 00010840 # lnf_3(); /* register stability */
43: 43 00010840 fe 04 ef0000028d callf $4,_lnf_3
44: 44 00010847 # lnf_4(); /* PSL stability test */
45: 45 00010847 fe 04 ef00000424 callf $4,_lnf_4
46: 46 0001084E # lnf_5(); /* pipelined entry test */
47: 47 0001084E fe 04 ef000005c3 callf $4,_lnf_5
48: 48 00010855 # if ( !no_fpp_wcs )
49: 49 00010855 5d efffffffb5 tstl _no_fpp_wcs
50: 50 0001085B 21 07 jneq L227
51: 51 0001085D # lnf_6();; /* pipelined exit test */
52: 52 0001085D fe 04 ef000006c6 callf $4,_lnf_6
53: 53 00010864 L227:
54: 54 00010864 # asm("jmp *return"); /* return to the test monitor */
55: 55 00010864 71 ffffffffa6 jmp *return
56: 56 0001086A # }
57: 57 0001086A 40 ret#2
58: 58 0001086B .set L215,0x0
59: 59 0001086B L217:
60: 60 0001086B 11 a7 jbr L218
61: 61 0001086D .data
62: 62 0000093c * .text
63: 63 0001086D 00 .align 1
64: 64 0001086E .globl _lnf_1
65: 65 0001086E _lnf_1:
66: 66 0001086E 0000 .word L229
67: 67 00010870 #
68: 68 00010870 #
69: 69 00010870 #
70: 70 00010870 # /************************************************************************
71: 71 00010870 # *
72: 72 00010870 # * SUBTEST 1 - load_negate through a register
73: 73 00010870 # *
74: 74 00010870 # ************************************************************************/
75: 75 00010870 # lnf_1()
76: 76 00010870 # {
77: 77 00010870 13 012e jbr L231
78: 78 00010873 L232:
79: 79 00010873 # force_loop = FALSE;
80: 80 00010873 4d efffffff97 clrl _force_loop
81: 81 00010879 # subtest = 1;
82: 82 00010879 0d 01 efffffff90 movl $1,_subtest
83: 83 00010880 # for( index = 0; index < max_lnf_1_index; index++ ) {
84: 84 00010880 4d efffffff8a clrl _index
85: 85 00010886 L235:
86: 86 00010886 1d efffffff84 efffffff7f cmpl _index,_max_lnf_1_index
87: 87 00010891 91 03 13 010a jgeq L234
88: 88 00010896 # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
89: 89 00010896 0d efffffff74 50 movl _index,r0
90: 90 0001089D 48 03 50 50 shll $3,r0,r0
91: 91 000108A1 0d e000000000 efffffff64 movl _lnf_1_data(r0),_sgl_ld_acc
92: 92 000108AC # sgl_expected = lnf_1_data[index].exp; /* get expected result */
93: 93 000108AC 0d efffffff5e 50 movl _index,r0
94: 94 000108B3 48 03 50 50 shll $3,r0,r0
95: 95 000108B7 0d e000000004 efffffff4e movl _lnf_1_data+4(r0),_sgl_expected
96: 96 000108C2 # /*
97: 97 000108C2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
98: 98 000108C2 # * The force loop flag is set after the first error.
99: 99 000108C2 # */
100: 100 000108C2 # asm("_lnf_1_lp1:");
101: 101 000108C2 _lnf_1_lp1:
102: 102 000108C2 # asm("movl _sgl_ld_acc,r4"); /* get the value to negate */
103: 103 000108C2 0d efffffff48 54 movl _sgl_ld_acc,r4
104: 104 000108C9 # asm("lnf r4"); /* load and negate value */
105: 105 000108C9 16 54 lnf r4
106: 106 000108CB # asm("stf r5"); /* store the result in R5 */
107: 107 000108CB 26 55 stf r5
108: 108 000108CD # if( force_loop )
109: 109 000108CD 5d efffffff3d tstl _force_loop
110: 110 000108D3 31 02 jeql L236
111: 111 000108D5 # asm("brb _lnf_1_lp1");; /* loop on the error */
112: 112 000108D5 11 eb brb _lnf_1_lp1
113: 113 000108D7 L236:
114: 114 000108D7 # /*
115: 115 000108D7 # * end error loop - test the results
116: 116 000108D7 # */
117: 117 000108D7 # asm("movl r5,_sgl_st_acc"); /* move R5 data to cache */
118: 118 000108D7 0d 55 efffffff32 movl r5,_sgl_st_acc
119: 119 000108DE # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
120: 120 000108DE 1d efffffff2c efffffff27 cmpl _sgl_st_acc,_sgl_expected
121: 121 000108E9 21 03 13 00a9 jeql L237
122: 122 000108EE # errcnt++; /* bump the error count */
123: 123 000108EE 6d efffffff1c incl _errcnt
124: 124 000108F4 # if( prt_error ) {
125: 125 000108F4 5d efffffff16 tstl _prt_error
126: 126 000108FA 31 78 jeql L238
127: 127 000108FC # writes(" \n"); /* start a new print line */
128: 128 000108FC .data 1
129: 129 00000941 * L239:
130: 130 00000941 * 200A00 .ascii " \12\0"
131: 131 00000944 * .text
132: 132 000108FC dd 8f00000941 pushl $L239
133: 133 00010902 fe 08 efffffff07 callf $8,_writes
134: 134 00010909 # writes("cycle: ");
135: 135 00010909 .data 1
136: 136 00000944 * L240:
137: 137 00000944 * 6379636C653A2000 .ascii "cycle: \0"
138: 138 0000094c * .text
139: 139 00010909 dd 8f00000944 pushl $L240
140: 140 0001090F fe 08 effffffefa callf $8,_writes
141: 141 00010916 # writed( cycle );
142: 142 00010916 dd effffffef4 pushl _cycle
143: 143 0001091C fe 08 effffffeed callf $8,_writed
144: 144 00010923 # writes(" LNF test ");
145: 145 00010923 .data 1
146: 146 0000094c * L242:
147: 147 0000094c * 20204C4E4620746573742000 .ascii " LNF test \0"
148: 148 00000958 * .text
149: 149 00010923 dd 8f0000094c pushl $L242
150: 150 00010929 fe 08 effffffee0 callf $8,_writes
151: 151 00010930 # writed( test_no );
152: 152 00010930 dd effffffeda pushl _test_no
153: 153 00010936 fe 08 effffffed3 callf $8,_writed
154: 154 0001093D # writes(", subtest 1 (Reg. Data) - BAD FINAL ACC\n");
155: 155 0001093D .data 1
156: 156 00000958 * L243:
157: 157 00000958 * 2C20737562746573742031202 .ascii ", subtest 1 (Reg. Data) - BAD FINAL ACC\12\0"
158: 85265672E204461746129202D
159: 204241442046494E414C20414
160: 3430A00
161: 158 00000981 * .text
162: 159 0001093D dd 8f00000958 pushl $L243
163: 160 00010943 fe 08 effffffec6 callf $8,_writes
164: 161 0001094A # print_lnf_data();
165: 162 0001094A fe 04 ef000006eb callf $4,_print_lnf_data
166: 163 00010951 # writes(" Acc expected = ");
167: 164 00010951 .data 1
168: 165 00000981 * L245:
169: 166 00000981 * 2020202020202020202020202 .ascii " Acc expected = \0"
170: 0202020202020202020202020
171: 4163632065787065637465642
172: 03D2000
173: 167 000009aa * .text
174: 168 00010951 dd 8f00000981 pushl $L245
175: 169 00010957 fe 08 effffffeb2 callf $8,_writes
176: 170 0001095E # write32h( sgl_expected );
177: 171 0001095E dd effffffeac pushl _sgl_expected
178: 172 00010964 fe 08 effffffea5 callf $8,_write32h
179: 173 0001096B # writec('\n');
180: 174 0001096B dd 0a pushl $10
181: 175 0001096D fe 08 effffffe9c callf $8,_writec
182: 176 00010974 # }
183: 177 00010974 # if( halt_flg )
184: 178 00010974 L238:
185: 179 00010974 5d effffffe96 tstl _halt_flg
186: 180 0001097A 31 09 jeql L248
187: 181 0001097C # lnf_er_halt( BAD_ACC_HLT ); /* halt on the error */
188: 182 0001097C dd 01 pushl $1
189: 183 0001097E fe 08 ef00000715 callf $8,_lnf_er_halt
190: 184 00010985 # if( loop_on_err ) {
191: 185 00010985 L248:
192: 186 00010985 5d effffffe85 tstl _loop_on_err
193: 187 0001098B 31 0a jeql L250
194: 188 0001098D # force_loop = TRUE; /* set the force loop flag */
195: 189 0001098D 0d 01 effffffe7c movl $1,_force_loop
196: 190 00010994 # asm("brw _lnf_1_lp1");; /* and loop on the error */
197: 191 00010994 13 ff2b brw _lnf_1_lp1
198: 192 00010997 # } /* end of loop on error */
199: 193 00010997 # } /* end of compare error */
200: 194 00010997 L250:
201: 195 00010997 # } /* end of WHILE loop */
202: 196 00010997 L237:
203: 197 00010997 L233:
204: 198 00010997 6d effffffe73 incl _index
205: 199 0001099D 13 fee6 jbr L235
206: 200 000109A0 L234:
207: 201 000109A0 # } /* end of subtest 1 */
208: 202 000109A0 40 ret#2
209: 203 000109A1 .set L229,0x0
210: 204 000109A1 L231:
211: 205 000109A1 13 fecf jbr L232
212: 206 000109A4 .data
213: 207 0000093c * .text
214: 208 000109A4 .align 1
215: 209 000109A4 .globl _lnf_2
216: 210 000109A4 _lnf_2:
217: 211 000109A4 0000 .word L251
218: 212 000109A6 #
219: 213 000109A6 #
220: 214 000109A6 #
221: 215 000109A6 # /************************************************************************
222: 216 000109A6 # *
223: 217 000109A6 # * SUBTEST 2 - load_negate through memory
224: 218 000109A6 # *
225: 219 000109A6 # ************************************************************************/
226: 220 000109A6 # lnf_2()
227: 221 000109A6 # {
228: 222 000109A6 13 0128 jbr L253
229: 223 000109A9 L254:
230: 224 000109A9 # force_loop = FALSE;
231: 225 000109A9 4d effffffe61 clrl _force_loop
232: 226 000109AF # subtest = 2;
233: 227 000109AF 0d 02 effffffe5a movl $2,_subtest
234: 228 000109B6 # for( index = 0; index < max_lnf_1_index; index++ ) {
235: 229 000109B6 4d effffffe54 clrl _index
236: 230 000109BC L257:
237: 231 000109BC 1d effffffe4e effffffe49 cmpl _index,_max_lnf_1_index
238: 232 000109C7 91 03 13 0104 jgeq L256
239: 233 000109CC # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
240: 234 000109CC 0d effffffe3e 50 movl _index,r0
241: 235 000109D3 48 03 50 50 shll $3,r0,r0
242: 236 000109D7 0d e000000000 effffffe2e movl _lnf_1_data(r0),_sgl_ld_acc
243: 237 000109E2 # sgl_expected = lnf_1_data[index].exp; /* get expected result */
244: 238 000109E2 0d effffffe28 50 movl _index,r0
245: 239 000109E9 48 03 50 50 shll $3,r0,r0
246: 240 000109ED 0d e000000004 effffffe18 movl _lnf_1_data+4(r0),_sgl_expected
247: 241 000109F8 # /*
248: 242 000109F8 # * If LOOP ON ERROR is set, this is the loop for this subtest.
249: 243 000109F8 # * The force loop flag is set after the first error.
250: 244 000109F8 # */
251: 245 000109F8 # asm("_lnf_2_lp1:");
252: 246 000109F8 _lnf_2_lp1:
253: 247 000109F8 # asm("lnf _sgl_ld_acc"); /* load and negate the value */
254: 248 000109F8 16 effffffe12 lnf _sgl_ld_acc
255: 249 000109FE # asm("stf _sgl_st_acc"); /* store the result */
256: 250 000109FE 26 effffffe0c stf _sgl_st_acc
257: 251 00010A04 # if( force_loop )
258: 252 00010A04 5d effffffe06 tstl _force_loop
259: 253 00010A0A 31 02 jeql L258
260: 254 00010A0C # asm("brb _lnf_2_lp1");; /* loop on the error */
261: 255 00010A0C 11 ea brb _lnf_2_lp1
262: 256 00010A0E L258:
263: 257 00010A0E # /*
264: 258 00010A0E # * end error loop - test the results
265: 259 00010A0E # */
266: 260 00010A0E # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
267: 261 00010A0E 1d effffffdfc effffffdf7 cmpl _sgl_st_acc,_sgl_expected
268: 262 00010A19 21 03 13 00a9 jeql L259
269: 263 00010A1E # errcnt++; /* bump the error count */
270: 264 00010A1E 6d effffffdec incl _errcnt
271: 265 00010A24 # if( prt_error ) {
272: 266 00010A24 5d effffffde6 tstl _prt_error
273: 267 00010A2A 31 78 jeql L260
274: 268 00010A2C # writes(" \n"); /* start a new print line */
275: 269 00010A2C .data 1
276: 270 000009aa * L261:
277: 271 000009aa * 200A00 .ascii " \12\0"
278: 272 000009ad * .text
279: 273 00010A2C dd 8f000009aa pushl $L261
280: 274 00010A32 fe 08 effffffdd7 callf $8,_writes
281: 275 00010A39 # writes("cycle: ");
282: 276 00010A39 .data 1
283: 277 000009ad * L262:
284: 278 000009ad * 6379636C653A2000 .ascii "cycle: \0"
285: 279 000009b5 * .text
286: 280 00010A39 dd 8f000009ad pushl $L262
287: 281 00010A3F fe 08 effffffdca callf $8,_writes
288: 282 00010A46 # writed( cycle );
289: 283 00010A46 dd effffffdc4 pushl _cycle
290: 284 00010A4C fe 08 effffffdbd callf $8,_writed
291: 285 00010A53 # writes(" LNF test ");
292: 286 00010A53 .data 1
293: 287 000009b5 * L263:
294: 288 000009b5 * 20204C4E4620746573742000 .ascii " LNF test \0"
295: 289 000009c1 * .text
296: 290 00010A53 dd 8f000009b5 pushl $L263
297: 291 00010A59 fe 08 effffffdb0 callf $8,_writes
298: 292 00010A60 # writed( test_no );
299: 293 00010A60 dd effffffdaa pushl _test_no
300: 294 00010A66 fe 08 effffffda3 callf $8,_writed
301: 295 00010A6D # writes(", subtest 2 (Cache Data) - BAD FINAL ACC\n");
302: 296 00010A6D .data 1
303: 297 000009c1 * L264:
304: 298 000009c1 * 2C20737562746573742032202 .ascii ", subtest 2 (Cache Data) - BAD FINAL ACC\12\0"
305: 8436163686520446174612920
306: 2D204241442046494E414C204
307: 143430A00
308: 299 000009eb * .text
309: 300 00010A6D dd 8f000009c1 pushl $L264
310: 301 00010A73 fe 08 effffffd96 callf $8,_writes
311: 302 00010A7A # print_lnf_data();
312: 303 00010A7A fe 04 ef000005bb callf $4,_print_lnf_data
313: 304 00010A81 # writes(" Acc expected = ");
314: 305 00010A81 .data 1
315: 306 000009eb * L265:
316: 307 000009eb * 2020202020202020202020202 .ascii " Acc expected = \0"
317: 0202020202020202020202020
318: 4163632065787065637465642
319: 03D2000
320: 308 00000a14 * .text
321: 309 00010A81 dd 8f000009eb pushl $L265
322: 310 00010A87 fe 08 effffffd82 callf $8,_writes
323: 311 00010A8E # write32h( sgl_expected );
324: 312 00010A8E dd effffffd7c pushl _sgl_expected
325: 313 00010A94 fe 08 effffffd75 callf $8,_write32h
326: 314 00010A9B # writec('\n');
327: 315 00010A9B dd 0a pushl $10
328: 316 00010A9D fe 08 effffffd6c callf $8,_writec
329: 317 00010AA4 # }
330: 318 00010AA4 # if( halt_flg )
331: 319 00010AA4 L260:
332: 320 00010AA4 5d effffffd66 tstl _halt_flg
333: 321 00010AAA 31 09 jeql L266
334: 322 00010AAC # lnf_er_halt( BAD_ACC_HLT ); /* halt on the error */
335: 323 00010AAC dd 01 pushl $1
336: 324 00010AAE fe 08 ef000005e5 callf $8,_lnf_er_halt
337: 325 00010AB5 # if( loop_on_err ) {
338: 326 00010AB5 L266:
339: 327 00010AB5 5d effffffd55 tstl _loop_on_err
340: 328 00010ABB 31 0a jeql L267
341: 329 00010ABD # force_loop = TRUE; /* set the force loop flag */
342: 330 00010ABD 0d 01 effffffd4c movl $1,_force_loop
343: 331 00010AC4 # asm("brw _lnf_2_lp1");; /* and loop on the error */
344: 332 00010AC4 13 ff31 brw _lnf_2_lp1
345: 333 00010AC7 # } /* end of loop on error */
346: 334 00010AC7 # } /* end of compare error */
347: 335 00010AC7 L267:
348: 336 00010AC7 # } /* end of WHILE loop */
349: 337 00010AC7 L259:
350: 338 00010AC7 L255:
351: 339 00010AC7 6d effffffd43 incl _index
352: 340 00010ACD 13 feec jbr L257
353: 341 00010AD0 L256:
354: 342 00010AD0 # } /* end of subtest 2 */
355: 343 00010AD0 40 ret#2
356: 344 00010AD1 .set L251,0x0
357: 345 00010AD1 L253:
358: 346 00010AD1 13 fed5 jbr L254
359: 347 00010AD4 .data
360: 348 0000093c * .text
361: 349 00010AD4 .align 1
362: 350 00010AD4 .globl _lnf_3
363: 351 00010AD4 _lnf_3:
364: 352 00010AD4 0000 .word L268
365: 353 00010AD6 #
366: 354 00010AD6 #
367: 355 00010AD6 #
368: 356 00010AD6 # /************************************************************************
369: 357 00010AD6 # *
370: 358 00010AD6 # * SUBTEST 3 - Check for register corruption
371: 359 00010AD6 # *
372: 360 00010AD6 # ************************************************************************/
373: 361 00010AD6 # lnf_3()
374: 362 00010AD6 # {
375: 363 00010AD6 13 0195 jbr L270
376: 364 00010AD9 L271:
377: 365 00010AD9 # force_loop = FALSE; /* clear force_loop flg */
378: 366 00010AD9 4d effffffd31 clrl _force_loop
379: 367 00010ADF # subtest = 3;
380: 368 00010ADF 0d 03 effffffd2a movl $3,_subtest
381: 369 00010AE6 # fill_reg_buf( load_regs ); /* get patterns for regs */
382: 370 00010AE6 dd 8f00000000 pushl $_load_regs
383: 371 00010AEC fe 08 effffffd1d callf $8,_fill_reg_buf
384: 372 00010AF3 # index = 0;
385: 373 00010AF3 4d effffffd17 clrl _index
386: 374 00010AF9 # sgl_ld_acc = lnf_1_data[0].ld; /* get value to negate */
387: 375 00010AF9 0d effffffd11 effffffd0c movl _lnf_1_data,_sgl_ld_acc
388: 376 00010B04 # sgl_expected = lnf_1_data[0].exp; /* get expected result */
389: 377 00010B04 0d effffffd0a effffffd01 movl _lnf_1_data+4,_sgl_expected
390: 378 00010B0F # /*
391: 379 00010B0F # * If LOOP ON ERROR is set, this is the loop for this subtest.
392: 380 00010B0F # * The force loop flag is set after the first error.
393: 381 00010B0F # */
394: 382 00010B0F # asm("_lnf_3_lp1:");
395: 383 00010B0F _lnf_3_lp1:
396: 384 00010B0F # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
397: 385 00010B0F ab 891fff effffffcf8 loadr $0x1fff,_load_regs
398: 386 00010B18 # asm("nop");
399: 387 00010B18 10 nop
400: 388 00010B19 # asm("lnf _sgl_ld_acc"); /* load and negate the value */
401: 389 00010B19 16 effffffcf1 lnf _sgl_ld_acc
402: 390 00010B1F # asm("nop");
403: 391 00010B1F 10 nop
404: 392 00010B20 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
405: 393 00010B20 bb 891fff effffffce7 storer $0x1fff,_store_regs
406: 394 00010B29 # asm("stf _sgl_st_acc"); /* save the accumulator */
407: 395 00010B29 26 effffffce1 stf _sgl_st_acc
408: 396 00010B2F # if( force_loop )
409: 397 00010B2F 5d effffffcdb tstl _force_loop
410: 398 00010B35 31 02 jeql L273
411: 399 00010B37 # asm("brb _lnf_3_lp1");; /* loop on the error */
412: 400 00010B37 11 d6 brb _lnf_3_lp1
413: 401 00010B39 L273:
414: 402 00010B39 # /*
415: 403 00010B39 # * Now compare the stored register values to those that were loaded
416: 404 00010B39 # */
417: 405 00010B39 # index2 = 0;
418: 406 00010B39 4d effffffcd1 clrl _index2
419: 407 00010B3F # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
420: 408 00010B3F L274:
421: 409 00010B3F 0d effffffccb 50 movl _index2,r0
422: 410 00010B46 0d effffffcc4 51 movl _index2,r1
423: 411 00010B4D 1d 40effffffcbc cmpl _load_regs[r0],_store_regs[r1]
424: 41effffffcb6
425: 412 00010B5A 21 11 jneq L275
426: 413 00010B5C 1d effffffcae 0d cmpl _index2,$13
427: 414 00010B63 81 08 jgeq L275
428: 415 00010B65 # index2++; /* check reg values */
429: 416 00010B65 6d effffffca5 incl _index2
430: 417 00010B6B 11 d2 jbr L274
431: 418 00010B6D L275:
432: 419 00010B6D # if( index2 < 13 ) { /* error if index2 < 13 */
433: 420 00010B6D 1d effffffc9d 0d cmpl _index2,$13
434: 421 00010B74 91 03 13 00f4 jgeq L276
435: 422 00010B79 # errcnt++; /* bump the error count */
436: 423 00010B79 6d effffffc91 incl _errcnt
437: 424 00010B7F # if( prt_error ) {
438: 425 00010B7F 5d effffffc8b tstl _prt_error
439: 426 00010B85 21 03 13 00c0 jeql L277
440: 427 00010B8A # writes(" \n"); /* start a new print line */
441: 428 00010B8A .data 1
442: 429 00000a14 * L278:
443: 430 00000a14 * 200A00 .ascii " \12\0"
444: 431 00000a17 * .text
445: 432 00010B8A dd 8f00000a14 pushl $L278
446: 433 00010B90 fe 08 effffffc79 callf $8,_writes
447: 434 00010B97 # writes("cycle: ");
448: 435 00010B97 .data 1
449: 436 00000a17 * L279:
450: 437 00000a17 * 6379636C653A2000 .ascii "cycle: \0"
451: 438 00000a1f * .text
452: 439 00010B97 dd 8f00000a17 pushl $L279
453: 440 00010B9D fe 08 effffffc6c callf $8,_writes
454: 441 00010BA4 # writed( cycle );
455: 442 00010BA4 dd effffffc66 pushl _cycle
456: 443 00010BAA fe 08 effffffc5f callf $8,_writed
457: 444 00010BB1 # writes(" LNF test ");
458: 445 00010BB1 .data 1
459: 446 00000a1f * L280:
460: 447 00000a1f * 20204C4E4620746573742000 .ascii " LNF test \0"
461: 448 00000a2b * .text
462: 449 00010BB1 dd 8f00000a1f pushl $L280
463: 450 00010BB7 fe 08 effffffc52 callf $8,_writes
464: 451 00010BBE # writed( test_no );
465: 452 00010BBE dd effffffc4c pushl _test_no
466: 453 00010BC4 fe 08 effffffc45 callf $8,_writed
467: 454 00010BCB # writes(", subtest 3 - A REGISTER WAS MODIFIED\n");
468: 455 00010BCB .data 1
469: 456 00000a2b * L281:
470: 457 00000a2b * 2C20737562746573742033202 .ascii ", subtest 3 - A REGISTER WAS MODIFIED\12\0"
471: D204120524547495354455220
472: 574153204D4F4449464945440
473: A00
474: 458 00000a52 * .text
475: 459 00010BCB dd 8f00000a2b pushl $L281
476: 460 00010BD1 fe 08 effffffc38 callf $8,_writes
477: 461 00010BD8 # print_lnf_data(); /* print the operands */
478: 462 00010BD8 fe 04 ef0000045d callf $4,_print_lnf_data
479: 463 00010BDF # writes("register "); /* print the information */
480: 464 00010BDF .data 1
481: 465 00000a52 * L282:
482: 466 00000a52 * 72656769737465722000 .ascii "register \0"
483: 467 00000a5c * .text
484: 468 00010BDF dd 8f00000a52 pushl $L282
485: 469 00010BE5 fe 08 effffffc24 callf $8,_writes
486: 470 00010BEC # writed( index2 ); /* about the corrupted */
487: 471 00010BEC dd effffffc1e pushl _index2
488: 472 00010BF2 fe 08 effffffc17 callf $8,_writed
489: 473 00010BF9 # writes(" = "); /* register */
490: 474 00010BF9 .data 1
491: 475 00000a5c * L283:
492: 476 00000a5c * 203D2000 .ascii " = \0"
493: 477 00000a60 * .text
494: 478 00010BF9 dd 8f00000a5c pushl $L283
495: 479 00010BFF fe 08 effffffc0a callf $8,_writes
496: 480 00010C06 # write32h( store_regs[index2] );
497: 481 00010C06 0d effffffc04 50 movl _index2,r0
498: 482 00010C0D dd 40effffffbfc pushl _store_regs[r0]
499: 483 00010C14 fe 08 effffffbf5 callf $8,_write32h
500: 484 00010C1B # writes(", should be = ");
501: 485 00010C1B .data 1
502: 486 00000a60 * L284:
503: 487 00000a60 * 2C202073686F756C642062652 .ascii ", should be = \0"
504: 03D2000
505: 488 00000a70 * .text
506: 489 00010C1B dd 8f00000a60 pushl $L284
507: 490 00010C21 fe 08 effffffbe8 callf $8,_writes
508: 491 00010C28 # write32h( load_regs[index2] );
509: 492 00010C28 0d effffffbe2 50 movl _index2,r0
510: 493 00010C2F dd 40effffffbda pushl _load_regs[r0]
511: 494 00010C36 fe 08 effffffbd3 callf $8,_write32h
512: 495 00010C3D # writes("\n");
513: 496 00010C3D .data 1
514: 497 00000a70 * L285:
515: 498 00000a70 * 0A00 .ascii "\12\0"
516: 499 00000a72 * .text
517: 500 00010C3D dd 8f00000a70 pushl $L285
518: 501 00010C43 fe 08 effffffbc6 callf $8,_writes
519: 502 00010C4A # }
520: 503 00010C4A # if( halt_flg )
521: 504 00010C4A L277:
522: 505 00010C4A 5d effffffbc0 tstl _halt_flg
523: 506 00010C50 31 09 jeql L286
524: 507 00010C52 # lnf_er_halt( BAD_REG_HLT ); /* halt on the error */
525: 508 00010C52 dd 02 pushl $2
526: 509 00010C54 fe 08 ef0000043f callf $8,_lnf_er_halt
527: 510 00010C5B # if( loop_on_err ) {
528: 511 00010C5B L286:
529: 512 00010C5B 5d effffffbaf tstl _loop_on_err
530: 513 00010C61 31 0a jeql L287
531: 514 00010C63 # force_loop = TRUE; /* set the force loop flag */
532: 515 00010C63 0d 01 effffffba6 movl $1,_force_loop
533: 516 00010C6A # asm("brw _lnf_3_lp1");; /* and loop on the error */
534: 517 00010C6A 13 fea2 brw _lnf_3_lp1
535: 518 00010C6D # } /* end of loop on error */
536: 519 00010C6D # } /* end of register corruption error */
537: 520 00010C6D L287:
538: 521 00010C6D # } /* end of subtest 3 */
539: 522 00010C6D L276:
540: 523 00010C6D 40 ret#2
541: 524 00010C6E .set L268,0x0
542: 525 00010C6E L270:
543: 526 00010C6E 13 fe68 jbr L271
544: 527 00010C71 .data
545: 528 0000093c * .text
546: 529 00010C71 00 .align 1
547: 530 00010C72 .globl _lnf_4
548: 531 00010C72 _lnf_4:
549: 532 00010C72 0000 .word L288
550: 533 00010C74 #
551: 534 00010C74 #
552: 535 00010C74 #
553: 536 00010C74 # /************************************************************************
554: 537 00010C74 # *
555: 538 00010C74 # * SUBTEST 4 - Check for PSL corruption
556: 539 00010C74 # *
557: 540 00010C74 # ************************************************************************/
558: 541 00010C74 # lnf_4()
559: 542 00010C74 # {
560: 543 00010C74 13 019d jbr L290
561: 544 00010C77 L291:
562: 545 00010C77 # force_loop = FALSE; /* clear force_loop flg */
563: 546 00010C77 4d effffffb93 clrl _force_loop
564: 547 00010C7D # subtest = 4;
565: 548 00010C7D 0d 04 effffffb8c movl $4,_subtest
566: 549 00010C84 # fill_reg_buf( load_regs ); /* get patterns for regs */
567: 550 00010C84 dd 8f00000000 pushl $_load_regs
568: 551 00010C8A fe 08 effffffb7f callf $8,_fill_reg_buf
569: 552 00010C91 # for( index = 0; index < 3; index++ ) {
570: 553 00010C91 4d effffffb79 clrl _index
571: 554 00010C97 L294:
572: 555 00010C97 1d effffffb73 03 cmpl _index,$3
573: 556 00010C9E 91 03 13 0170 jgeq L293
574: 557 00010CA3 # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
575: 558 00010CA3 0d effffffb67 50 movl _index,r0
576: 559 00010CAA 48 03 50 50 shll $3,r0,r0
577: 560 00010CAE 0d e000000000 effffffb57 movl _lnf_1_data(r0),_sgl_ld_acc
578: 561 00010CB9 # sgl_expected = lnf_1_data[index].exp; /* get expected */
579: 562 00010CB9 0d effffffb51 50 movl _index,r0
580: 563 00010CC0 48 03 50 50 shll $3,r0,r0
581: 564 00010CC4 0d e000000004 effffffb41 movl _lnf_1_data+4(r0),_sgl_expected
582: 565 00010CCF # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
583: 566 00010CCF 0d effffffb3b 50 movl _status_index,r0
584: 567 00010CD6 0d 40effffffb33 movl _status_array[r0],_sgl_dummy1
585: effffffb2e
586: 568 00010CE2 # /*
587: 569 00010CE2 # * If LOOP ON ERROR is set, this is the loop for this subtest.
588: 570 00010CE2 # * The force loop flag is set after the first error.
589: 571 00010CE2 # */
590: 572 00010CE2 # asm("_lnf_4_lp1:");
591: 573 00010CE2 _lnf_4_lp1:
592: 574 00010CE2 # asm("tstl _sgl_dummy1"); /* set the PSL status */
593: 575 00010CE2 5d effffffb28 tstl _sgl_dummy1
594: 576 00010CE8 # asm("movpsl _init_psl"); /* save the initial PSL */
595: 577 00010CE8 cd effffffb22 movpsl _init_psl
596: 578 00010CEE # asm("lnf _sgl_ld_acc"); /* load and negate the value */
597: 579 00010CEE 16 effffffb1c lnf _sgl_ld_acc
598: 580 00010CF4 # asm("nop");
599: 581 00010CF4 10 nop
600: 582 00010CF5 # asm("movpsl _psl_val"); /* save the final PSL */
601: 583 00010CF5 cd effffffb15 movpsl _psl_val
602: 584 00010CFB # asm("stf _sgl_st_acc"); /* save the accumulator */
603: 585 00010CFB 26 effffffb0f stf _sgl_st_acc
604: 586 00010D01 # if( force_loop )
605: 587 00010D01 5d effffffb09 tstl _force_loop
606: 588 00010D07 31 02 jeql L295
607: 589 00010D09 # asm("brb _lnf_4_lp1");; /* loop on the error */
608: 590 00010D09 11 d7 brb _lnf_4_lp1
609: 591 00010D0B L295:
610: 592 00010D0B # /*
611: 593 00010D0B # * Now compare the final PSL to the initial PSL -they should be the same
612: 594 00010D0B # */
613: 595 00010D0B # exp_psl = init_psl;
614: 596 00010D0B 0d effffffaff effffffafa movl _init_psl,_exp_psl
615: 597 00010D16 # if( psl_val != init_psl ) {
616: 598 00010D16 1d effffffaf4 effffffaef cmpl _psl_val,_init_psl
617: 599 00010D21 21 03 13 00e4 jeql L296
618: 600 00010D26 # errcnt++; /* bump the error count */
619: 601 00010D26 6d effffffae4 incl _errcnt
620: 602 00010D2C # if( prt_error ) {
621: 603 00010D2C 5d effffffade tstl _prt_error
622: 604 00010D32 21 03 13 00b0 jeql L297
623: 605 00010D37 # writes(" \n"); /* start a new print line */
624: 606 00010D37 .data 1
625: 607 00000a72 * L298:
626: 608 00000a72 * 200A00 .ascii " \12\0"
627: 609 00000a75 * .text
628: 610 00010D37 dd 8f00000a72 pushl $L298
629: 611 00010D3D fe 08 effffffacc callf $8,_writes
630: 612 00010D44 # writes("cycle: ");
631: 613 00010D44 .data 1
632: 614 00000a75 * L299:
633: 615 00000a75 * 6379636C653A2000 .ascii "cycle: \0"
634: 616 00000a7d * .text
635: 617 00010D44 dd 8f00000a75 pushl $L299
636: 618 00010D4A fe 08 effffffabf callf $8,_writes
637: 619 00010D51 # writed( cycle );
638: 620 00010D51 dd effffffab9 pushl _cycle
639: 621 00010D57 fe 08 effffffab2 callf $8,_writed
640: 622 00010D5E # writes(" LNF test ");
641: 623 00010D5E .data 1
642: 624 00000a7d * L300:
643: 625 00000a7d * 20204C4E4620746573742000 .ascii " LNF test \0"
644: 626 00000a89 * .text
645: 627 00010D5E dd 8f00000a7d pushl $L300
646: 628 00010D64 fe 08 effffffaa5 callf $8,_writes
647: 629 00010D6B # writed( test_no );
648: 630 00010D6B dd effffffa9f pushl _test_no
649: 631 00010D71 fe 08 effffffa98 callf $8,_writed
650: 632 00010D78 # writes(", subtest 4 - INCORRECT FINAL PSL\n");
651: 633 00010D78 .data 1
652: 634 00000a89 * L301:
653: 635 00000a89 * 2C20737562746573742034202 .ascii ", subtest 4 - INCORRECT FINAL PSL\12\0"
654: D20494E434F52524543542046
655: 494E414C2050534C0A00
656: 636 00000aac * .text
657: 637 00010D78 dd 8f00000a89 pushl $L301
658: 638 00010D7E fe 08 effffffa8b callf $8,_writes
659: 639 00010D85 # print_lnf_data(); /* print the operands */
660: 640 00010D85 fe 04 ef000002b0 callf $4,_print_lnf_data
661: 641 00010D8C # writes("initial PSL = ");
662: 642 00010D8C .data 1
663: 643 00000aac * L302:
664: 644 00000aac * 696E697469616C2050534C203 .ascii "initial PSL = \0"
665: D2000
666: 645 00000abb * .text
667: 646 00010D8C dd 8f00000aac pushl $L302
668: 647 00010D92 fe 08 effffffa77 callf $8,_writes
669: 648 00010D99 # write32h( init_psl );
670: 649 00010D99 dd effffffa71 pushl _init_psl
671: 650 00010D9F fe 08 effffffa6a callf $8,_write32h
672: 651 00010DA6 # writes(", final PSL = ");
673: 652 00010DA6 .data 1
674: 653 00000abb * L303:
675: 654 00000abb * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
676: 03D2000
677: 655 00000acb * .text
678: 656 00010DA6 dd 8f00000abb pushl $L303
679: 657 00010DAC fe 08 effffffa5d callf $8,_writes
680: 658 00010DB3 # write32h( psl_val );
681: 659 00010DB3 dd effffffa57 pushl _psl_val
682: 660 00010DB9 fe 08 effffffa50 callf $8,_write32h
683: 661 00010DC0 # writes(", expected PSL = ");
684: 662 00010DC0 .data 1
685: 663 00000acb * L304:
686: 664 00000acb * 2C20206578706563746564205 .ascii ", expected PSL = \0"
687: 0534C203D2000
688: 665 00000ade * .text
689: 666 00010DC0 dd 8f00000acb pushl $L304
690: 667 00010DC6 fe 08 effffffa43 callf $8,_writes
691: 668 00010DCD # write32h( exp_psl );
692: 669 00010DCD dd effffffa3d pushl _exp_psl
693: 670 00010DD3 fe 08 effffffa36 callf $8,_write32h
694: 671 00010DDA # writes("\n");
695: 672 00010DDA .data 1
696: 673 00000ade * L305:
697: 674 00000ade * 0A00 .ascii "\12\0"
698: 675 00000ae0 * .text
699: 676 00010DDA dd 8f00000ade pushl $L305
700: 677 00010DE0 fe 08 effffffa29 callf $8,_writes
701: 678 00010DE7 # }
702: 679 00010DE7 # if( halt_flg )
703: 680 00010DE7 L297:
704: 681 00010DE7 5d effffffa23 tstl _halt_flg
705: 682 00010DED 31 09 jeql L306
706: 683 00010DEF # lnf_er_halt( BAD_PSL_HLT ); /* halt on the error */
707: 684 00010DEF dd 03 pushl $3
708: 685 00010DF1 fe 08 ef000002a2 callf $8,_lnf_er_halt
709: 686 00010DF8 # if( loop_on_err ) {
710: 687 00010DF8 L306:
711: 688 00010DF8 5d effffffa12 tstl _loop_on_err
712: 689 00010DFE 31 0a jeql L307
713: 690 00010E00 # force_loop = TRUE; /* set the force loop flag */
714: 691 00010E00 0d 01 effffffa09 movl $1,_force_loop
715: 692 00010E07 # asm("brw _lnf_4_lp1");; /* and loop on the error */
716: 693 00010E07 13 fed8 brw _lnf_4_lp1
717: 694 00010E0A # } /* end of loop on error */
718: 695 00010E0A # } /* end of PSL corruption error */
719: 696 00010E0A L307:
720: 697 00010E0A # } /* end of WHILE loop */
721: 698 00010E0A L296:
722: 699 00010E0A L292:
723: 700 00010E0A 6d effffffa00 incl _index
724: 701 00010E10 13 fe84 jbr L294
725: 702 00010E13 L293:
726: 703 00010E13 # } /* end of subtest 4 */
727: 704 00010E13 40 ret#2
728: 705 00010E14 .set L288,0x0
729: 706 00010E14 L290:
730: 707 00010E14 13 fe60 jbr L291
731: 708 00010E17 .data
732: 709 0000093c * .text
733: 710 00010E17 00 .align 1
734: 711 00010E18 .globl _lnf_5
735: 712 00010E18 _lnf_5:
736: 713 00010E18 0000 .word L308
737: 714 00010E1A #
738: 715 00010E1A #
739: 716 00010E1A #
740: 717 00010E1A # /************************************************************************
741: 718 00010E1A # *
742: 719 00010E1A # * SUBTEST 5 - pipelined entry test
743: 720 00010E1A # *
744: 721 00010E1A # ************************************************************************/
745: 722 00010E1A # lnf_5()
746: 723 00010E1A # {
747: 724 00010E1A 13 010a jbr L310
748: 725 00010E1D L311:
749: 726 00010E1D # force_loop = FALSE;
750: 727 00010E1D 4d effffff9ed clrl _force_loop
751: 728 00010E23 # subtest = 8;
752: 729 00010E23 0d 08 effffff9e6 movl $8,_subtest
753: 730 00010E2A # for( index = 0; index < max_lnf_1_index; index++ ) {
754: 731 00010E2A 4d effffff9e0 clrl _index
755: 732 00010E30 L314:
756: 733 00010E30 1d effffff9da effffff9d5 cmpl _index,_max_lnf_1_index
757: 734 00010E3B 91 03 13 00e6 jgeq L313
758: 735 00010E40 # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
759: 736 00010E40 0d effffff9ca 50 movl _index,r0
760: 737 00010E47 48 03 50 50 shll $3,r0,r0
761: 738 00010E4B 0d e000000000 effffff9ba movl _lnf_1_data(r0),_sgl_ld_acc
762: 739 00010E56 # sgl_expected = lnf_1_data[index].exp; /* get expected result */
763: 740 00010E56 0d effffff9b4 50 movl _index,r0
764: 741 00010E5D 48 03 50 50 shll $3,r0,r0
765: 742 00010E61 0d e000000004 effffff9a4 movl _lnf_1_data+4(r0),_sgl_expected
766: 743 00010E6C # /*
767: 744 00010E6C # * If LOOP ON ERROR is set, this is the loop for this subtest.
768: 745 00010E6C # * The force loop flag is set after the first error.
769: 746 00010E6C # */
770: 747 00010E6C # asm("_lnf_5_lp1:");
771: 748 00010E6C _lnf_5_lp1:
772: 749 00010E6C # asm("movl $0,r0"); /* clear r0 */
773: 750 00010E6C 0d 00 50 movl $0,r0
774: 751 00010E6F # asm("ldf r0"); /* load the Acc. with 0.0 */
775: 752 00010E6F 06 50 ldf r0
776: 753 00010E71 # asm("lnf _sgl_ld_acc"); /* load and negate the value */
777: 754 00010E71 16 effffff999 lnf _sgl_ld_acc
778: 755 00010E77 # asm("stf _sgl_st_acc"); /* store the result */
779: 756 00010E77 26 effffff993 stf _sgl_st_acc
780: 757 00010E7D # if( force_loop )
781: 758 00010E7D 5d effffff98d tstl _force_loop
782: 759 00010E83 31 02 jeql L315
783: 760 00010E85 # asm("brb _lnf_5_lp1");; /* loop on the error */
784: 761 00010E85 11 e5 brb _lnf_5_lp1
785: 762 00010E87 L315:
786: 763 00010E87 # /*
787: 764 00010E87 # * end error loop - test the results
788: 765 00010E87 # */
789: 766 00010E87 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
790: 767 00010E87 1d effffff983 effffff97e cmpl _sgl_st_acc,_sgl_expected
791: 768 00010E92 21 03 13 0086 jeql L316
792: 769 00010E97 # errcnt++; /* bump the error count */
793: 770 00010E97 6d effffff973 incl _errcnt
794: 771 00010E9D # if( prt_error ) {
795: 772 00010E9D 5d effffff96d tstl _prt_error
796: 773 00010EA3 31 55 jeql L317
797: 774 00010EA5 # writes(" \n"); /* start a new print line */
798: 775 00010EA5 .data 1
799: 776 00000ae0 * L318:
800: 777 00000ae0 * 200A00 .ascii " \12\0"
801: 778 00000ae3 * .text
802: 779 00010EA5 dd 8f00000ae0 pushl $L318
803: 780 00010EAB fe 08 effffff95e callf $8,_writes
804: 781 00010EB2 # writes("cycle: ");
805: 782 00010EB2 .data 1
806: 783 00000ae3 * L319:
807: 784 00000ae3 * 6379636C653A2000 .ascii "cycle: \0"
808: 785 00000aeb * .text
809: 786 00010EB2 dd 8f00000ae3 pushl $L319
810: 787 00010EB8 fe 08 effffff951 callf $8,_writes
811: 788 00010EBF # writed( cycle );
812: 789 00010EBF dd effffff94b pushl _cycle
813: 790 00010EC5 fe 08 effffff944 callf $8,_writed
814: 791 00010ECC # writes(" LNF test ");
815: 792 00010ECC .data 1
816: 793 00000aeb * L320:
817: 794 00000aeb * 20204C4E4620746573742000 .ascii " LNF test \0"
818: 795 00000af7 * .text
819: 796 00010ECC dd 8f00000aeb pushl $L320
820: 797 00010ED2 fe 08 effffff937 callf $8,_writes
821: 798 00010ED9 # writed( test_no );
822: 799 00010ED9 dd effffff931 pushl _test_no
823: 800 00010EDF fe 08 effffff92a callf $8,_writed
824: 801 00010EE6 # writes(", subtest 5 (Piped Entry) - BAD FINAL ACC\n");
825: 802 00010EE6 .data 1
826: 803 00000af7 * L321:
827: 804 00000af7 * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Entry) - BAD FINAL ACC\12\0"
828: 8506970656420456E74727929
829: 202D204241442046494E414C2
830: 04143430A00
831: 805 00000b22 * .text
832: 806 00010EE6 dd 8f00000af7 pushl $L321
833: 807 00010EEC fe 08 effffff91d callf $8,_writes
834: 808 00010EF3 # print_lnf_data();
835: 809 00010EF3 fe 04 ef00000142 callf $4,_print_lnf_data
836: 810 00010EFA # }
837: 811 00010EFA # if( halt_flg )
838: 812 00010EFA L317:
839: 813 00010EFA 5d effffff910 tstl _halt_flg
840: 814 00010F00 31 09 jeql L322
841: 815 00010F02 # lnf_er_halt( BAD_ACC_HLT ); /* halt on the error */
842: 816 00010F02 dd 01 pushl $1
843: 817 00010F04 fe 08 ef0000018f callf $8,_lnf_er_halt
844: 818 00010F0B # if( loop_on_err ) {
845: 819 00010F0B L322:
846: 820 00010F0B 5d effffff8ff tstl _loop_on_err
847: 821 00010F11 31 0a jeql L323
848: 822 00010F13 # force_loop = TRUE; /* set the force loop flag */
849: 823 00010F13 0d 01 effffff8f6 movl $1,_force_loop
850: 824 00010F1A # asm("brw _lnf_5_lp1");; /* and loop on the error */
851: 825 00010F1A 13 ff4f brw _lnf_5_lp1
852: 826 00010F1D # } /* end of loop on error */
853: 827 00010F1D # } /* end of compare error */
854: 828 00010F1D L323:
855: 829 00010F1D # } /* end of WHILE loop */
856: 830 00010F1D L316:
857: 831 00010F1D L312:
858: 832 00010F1D 6d effffff8ed incl _index
859: 833 00010F23 13 ff0a jbr L314
860: 834 00010F26 L313:
861: 835 00010F26 # } /* end of subtest 5 */
862: 836 00010F26 40 ret#2
863: 837 00010F27 .set L308,0x0
864: 838 00010F27 L310:
865: 839 00010F27 13 fef3 jbr L311
866: 840 00010F2A .data
867: 841 0000093c * .text
868: 842 00010F2A .align 1
869: 843 00010F2A .globl _lnf_6
870: 844 00010F2A _lnf_6:
871: 845 00010F2A 0000 .word L324
872: 846 00010F2C #
873: 847 00010F2C #
874: 848 00010F2C #
875: 849 00010F2C # /************************************************************************
876: 850 00010F2C # *
877: 851 00010F2C # * SUBTEST 6 - pipelined exit test
878: 852 00010F2C # *
879: 853 00010F2C # ************************************************************************/
880: 854 00010F2C # lnf_6()
881: 855 00010F2C # {
882: 856 00010F2C 13 010a jbr L326
883: 857 00010F2F L327:
884: 858 00010F2F # force_loop = FALSE;
885: 859 00010F2F 4d effffff8db clrl _force_loop
886: 860 00010F35 # subtest = 8;
887: 861 00010F35 0d 08 effffff8d4 movl $8,_subtest
888: 862 00010F3C # for( index = 0; index < max_lnf_1_index; index++ ) {
889: 863 00010F3C 4d effffff8ce clrl _index
890: 864 00010F42 L330:
891: 865 00010F42 1d effffff8c8 effffff8c3 cmpl _index,_max_lnf_1_index
892: 866 00010F4D 91 03 13 00e6 jgeq L329
893: 867 00010F52 # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
894: 868 00010F52 0d effffff8b8 50 movl _index,r0
895: 869 00010F59 48 03 50 50 shll $3,r0,r0
896: 870 00010F5D 0d e000000000 effffff8a8 movl _lnf_1_data(r0),_sgl_ld_acc
897: 871 00010F68 # sgl_expected = lnf_1_data[index].exp; /* get expected result */
898: 872 00010F68 0d effffff8a2 50 movl _index,r0
899: 873 00010F6F 48 03 50 50 shll $3,r0,r0
900: 874 00010F73 0d e000000004 effffff892 movl _lnf_1_data+4(r0),_sgl_expected
901: 875 00010F7E # /*
902: 876 00010F7E # * If LOOP ON ERROR is set, this is the loop for this subtest.
903: 877 00010F7E # * The force loop flag is set after the first error.
904: 878 00010F7E # */
905: 879 00010F7E # asm("_lnf_6_lp1:");
906: 880 00010F7E _lnf_6_lp1:
907: 881 00010F7E # asm("movl $0,r0"); /* clear r0 */
908: 882 00010F7E 0d 00 50 movl $0,r0
909: 883 00010F81 # asm("lnf _sgl_ld_acc"); /* load and negate the value */
910: 884 00010F81 16 effffff889 lnf _sgl_ld_acc
911: 885 00010F87 # asm("addf r0"); /* add a zero to the acc. */
912: 886 00010F87 c6 50 addf r0
913: 887 00010F89 # asm("stf _sgl_st_acc"); /* store the result */
914: 888 00010F89 26 effffff881 stf _sgl_st_acc
915: 889 00010F8F # if( force_loop )
916: 890 00010F8F 5d effffff87b tstl _force_loop
917: 891 00010F95 31 02 jeql L331
918: 892 00010F97 # asm("brb _lnf_6_lp1");; /* loop on the error */
919: 893 00010F97 11 e5 brb _lnf_6_lp1
920: 894 00010F99 L331:
921: 895 00010F99 # /*
922: 896 00010F99 # * end error loop - test the results
923: 897 00010F99 # */
924: 898 00010F99 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
925: 899 00010F99 1d effffff871 effffff86c cmpl _sgl_st_acc,_sgl_expected
926: 900 00010FA4 21 03 13 0086 jeql L332
927: 901 00010FA9 # errcnt++; /* bump the error count */
928: 902 00010FA9 6d effffff861 incl _errcnt
929: 903 00010FAF # if( prt_error ) {
930: 904 00010FAF 5d effffff85b tstl _prt_error
931: 905 00010FB5 31 55 jeql L333
932: 906 00010FB7 # writes(" \n"); /* start a new print line */
933: 907 00010FB7 .data 1
934: 908 00000b22 * L334:
935: 909 00000b22 * 200A00 .ascii " \12\0"
936: 910 00000b25 * .text
937: 911 00010FB7 dd 8f00000b22 pushl $L334
938: 912 00010FBD fe 08 effffff84c callf $8,_writes
939: 913 00010FC4 # writes("cycle: ");
940: 914 00010FC4 .data 1
941: 915 00000b25 * L335:
942: 916 00000b25 * 6379636C653A2000 .ascii "cycle: \0"
943: 917 00000b2d * .text
944: 918 00010FC4 dd 8f00000b25 pushl $L335
945: 919 00010FCA fe 08 effffff83f callf $8,_writes
946: 920 00010FD1 # writed( cycle );
947: 921 00010FD1 dd effffff839 pushl _cycle
948: 922 00010FD7 fe 08 effffff832 callf $8,_writed
949: 923 00010FDE # writes(" LNF test ");
950: 924 00010FDE .data 1
951: 925 00000b2d * L336:
952: 926 00000b2d * 20204C4E4620746573742000 .ascii " LNF test \0"
953: 927 00000b39 * .text
954: 928 00010FDE dd 8f00000b2d pushl $L336
955: 929 00010FE4 fe 08 effffff825 callf $8,_writes
956: 930 00010FEB # writed( test_no );
957: 931 00010FEB dd effffff81f pushl _test_no
958: 932 00010FF1 fe 08 effffff818 callf $8,_writed
959: 933 00010FF8 # writes(", subtest 6 (Piped Exit) - BAD FINAL ACC\n");
960: 934 00010FF8 .data 1
961: 935 00000b39 * L337:
962: 936 00000b39 * 2C20737562746573742036202 .ascii ", subtest 6 (Piped Exit) - BAD FINAL ACC\12\0"
963: 8506970656420457869742920
964: 2D204241442046494E414C204
965: 143430A00
966: 937 00000b63 * .text
967: 938 00010FF8 dd 8f00000b39 pushl $L337
968: 939 00010FFE fe 08 effffff80b callf $8,_writes
969: 940 00011005 # print_lnf_data();
970: 941 00011005 fe 04 ef00000030 callf $4,_print_lnf_data
971: 942 0001100C # }
972: 943 0001100C # if( halt_flg )
973: 944 0001100C L333:
974: 945 0001100C 5d effffff7fe tstl _halt_flg
975: 946 00011012 31 09 jeql L338
976: 947 00011014 # lnf_er_halt( BAD_ACC_HLT ); /* halt on the error */
977: 948 00011014 dd 01 pushl $1
978: 949 00011016 fe 08 ef0000007d callf $8,_lnf_er_halt
979: 950 0001101D # if( loop_on_err ) {
980: 951 0001101D L338:
981: 952 0001101D 5d effffff7ed tstl _loop_on_err
982: 953 00011023 31 0a jeql L339
983: 954 00011025 # force_loop = TRUE; /* set the force loop flag */
984: 955 00011025 0d 01 effffff7e4 movl $1,_force_loop
985: 956 0001102C # asm("brw _lnf_6_lp1");; /* and loop on the error */
986: 957 0001102C 13 ff4f brw _lnf_6_lp1
987: 958 0001102F # } /* end of loop on error */
988: 959 0001102F # } /* end of compare error */
989: 960 0001102F L339:
990: 961 0001102F # } /* end of WHILE loop */
991: 962 0001102F L332:
992: 963 0001102F L328:
993: 964 0001102F 6d effffff7db incl _index
994: 965 00011035 13 ff0a jbr L330
995: 966 00011038 L329:
996: 967 00011038 # } /* end of subtest 6 */
997: 968 00011038 40 ret#2
998: 969 00011039 .set L324,0x0
999: 970 00011039 L326:
1000: 971 00011039 13 fef3 jbr L327
1001: 972 0001103C .data
1002: 973 0000093c * .text
1003: 974 0001103C .align 1
1004: 975 0001103C .globl _print_lnf_data
1005: 976 0001103C _print_lnf_data:
1006: 977 0001103C 0000 .word L340
1007: 978 0001103E #
1008: 979 0001103E #
1009: 980 0001103E #
1010: 981 0001103E # /**************************************************************************
1011: 982 0001103E # *
1012: 983 0001103E # * PRINT THE DATA AND STORE RESULTS
1013: 984 0001103E # *
1014: 985 0001103E # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
1015: 986 0001103E # **************************************************************************/
1016: 987 0001103E # print_lnf_data()
1017: 988 0001103E # {
1018: 989 0001103E 11 58 jbr L342
1019: 990 00011040 L343:
1020: 991 00011040 # writes("initial Acc = ");
1021: 992 00011040 .data 1
1022: 993 00000b63 * L344:
1023: 994 00000b63 * 696E697469616C20416363203 .ascii "initial Acc = \0"
1024: D2000
1025: 995 00000b72 * .text
1026: 996 00011040 dd 8f00000b63 pushl $L344
1027: 997 00011046 fe 08 effffff7c3 callf $8,_writes
1028: 998 0001104D # write32h( sgl_ld_acc );
1029: 999 0001104D dd effffff7bd pushl _sgl_ld_acc
1030: 1000 00011053 fe 08 effffff7b6 callf $8,_write32h
1031: 1001 0001105A # writes(", Acc stored = ");
1032: 1002 0001105A .data 1
1033: 1003 00000b72 * L345:
1034: 1004 00000b72 * 2C202020204163632073746F7 .ascii ", Acc stored = \0"
1035: 26564203D2000
1036: 1005 00000b85 * .text
1037: 1006 0001105A dd 8f00000b72 pushl $L345
1038: 1007 00011060 fe 08 effffff7a9 callf $8,_writes
1039: 1008 00011067 # write32h( sgl_st_acc );
1040: 1009 00011067 dd effffff7a3 pushl _sgl_st_acc
1041: 1010 0001106D fe 08 effffff79c callf $8,_write32h
1042: 1011 00011074 # writes(", data index = ");
1043: 1012 00011074 .data 1
1044: 1013 00000b85 * L346:
1045: 1014 00000b85 * 2C20206461746120696E64657 .ascii ", data index = \0"
1046: 8203D2000
1047: 1015 00000b96 * .text
1048: 1016 00011074 dd 8f00000b85 pushl $L346
1049: 1017 0001107A fe 08 effffff78f callf $8,_writes
1050: 1018 00011081 # writed( index );
1051: 1019 00011081 dd effffff789 pushl _index
1052: 1020 00011087 fe 08 effffff782 callf $8,_writed
1053: 1021 0001108E # writec('\n');
1054: 1022 0001108E dd 0a pushl $10
1055: 1023 00011090 fe 08 effffff779 callf $8,_writec
1056: 1024 00011097 # }
1057: 1025 00011097 40 ret#2
1058: 1026 00011098 .set L340,0x0
1059: 1027 00011098 L342:
1060: 1028 00011098 11 a6 jbr L343
1061: 1029 0001109A .data
1062: 1030 0000093c * .text
1063: 1031 0001109A .align 1
1064: 1032 0001109A .globl _lnf_er_halt
1065: 1033 0001109A _lnf_er_halt:
1066: 1034 0001109A 0000 .word L347
1067: 1035 0001109C #
1068: 1036 0001109C #
1069: 1037 0001109C #
1070: 1038 0001109C # /**************************************************************************
1071: 1039 0001109C # *
1072: 1040 0001109C # * HALT ON ERROR ROUTINE
1073: 1041 0001109C # *
1074: 1042 0001109C # **************************************************************************/
1075: 1043 0001109C # lnf_er_halt( halt_code )
1076: 1044 0001109C # int halt_code;
1077: 1045 0001109C # {
1078: 1046 0001109C 13 00a8 jbr L349
1079: 1047 0001109F L350:
1080: 1048 0001109F # sgl_dummy1 = halt_code; /* get the error type */
1081: 1049 0001109F 0d ad04 effffff769 movl 4(fp),_sgl_dummy1
1082: 1050 000110A7 # asm("movl _test_no,r0"); /* r0 = test number */
1083: 1051 000110A7 0d effffff763 50 movl _test_no,r0
1084: 1052 000110AE # asm("movl _subtest,r1"); /* r1 = subtest number */
1085: 1053 000110AE 0d effffff75c 51 movl _subtest,r1
1086: 1054 000110B5 # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1087: 1055 000110B5 0d effffff755 52 movl _sgl_dummy1,r2
1088: 1056 000110BC # asm("movl _cycle,r3"); /* r3 = cycle count */
1089: 1057 000110BC 0d effffff74e 53 movl _cycle,r3
1090: 1058 000110C3 # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
1091: 1059 000110C3 0d effffff747 54 movl _sgl_ld_acc,r4
1092: 1060 000110CA # asm("movl _sgl_st_acc,r5"); /* r5 = data stored */
1093: 1061 000110CA 0d effffff740 55 movl _sgl_st_acc,r5
1094: 1062 000110D1 # if( halt_code == BAD_ACC_HLT ) {
1095: 1063 000110D1 1d ad04 01 cmpl 4(fp),$1
1096: 1064 000110D5 21 10 jneq L351
1097: 1065 000110D7 # asm("movl _sgl_expected,r6"); /* r6 = data expected */
1098: 1066 000110D7 0d effffff733 56 movl _sgl_expected,r6
1099: 1067 000110DE # asm("movl _index,r7"); /* r7 = data index */
1100: 1068 000110DE 0d effffff72c 57 movl _index,r7
1101: 1069 000110E5 # } else
1102: 1070 000110E5 11 5e jbr L352
1103: 1071 000110E7 L351:
1104: 1072 000110E7 # if( halt_code == BAD_REG_HLT ) {
1105: 1073 000110E7 1d ad04 02 cmpl 4(fp),$2
1106: 1074 000110EB 21 3d jneq L353
1107: 1075 000110ED # sgl_dummy1 = load_regs[index2];
1108: 1076 000110ED 0d effffff71d 50 movl _index2,r0
1109: 1077 000110F4 0d 40effffff715 movl _load_regs[r0],_sgl_dummy1
1110: effffff710
1111: 1078 00011100 # sgl_dummy2 = store_regs[index2];
1112: 1079 00011100 0d effffff70a 50 movl _index2,r0
1113: 1080 00011107 0d 40effffff702 movl _store_regs[r0],_sgl_dummy2
1114: effffff6fd
1115: 1081 00011113 # asm("movl _index2,r6"); /* r6 = bad register # */
1116: 1082 00011113 0d effffff6f7 56 movl _index2,r6
1117: 1083 0001111A # asm("movl _sgl_dummy2,r7"); /* r7 = actual value */
1118: 1084 0001111A 0d effffff6f0 57 movl _sgl_dummy2,r7
1119: 1085 00011121 # asm("movl _sgl_dummy1,r8"); /* r8 = expected value */
1120: 1086 00011121 0d effffff6e9 58 movl _sgl_dummy1,r8
1121: 1087 00011128 # } else
1122: 1088 00011128 11 1b jbr L354
1123: 1089 0001112A L353:
1124: 1090 0001112A # if( halt_code == BAD_PSL_HLT ) {
1125: 1091 0001112A 1d ad04 03 cmpl 4(fp),$3
1126: 1092 0001112E 21 15 jneq L355
1127: 1093 00011130 # asm("movl _init_psl,r6"); /* r6 = initial PSL */
1128: 1094 00011130 0d effffff6da 56 movl _init_psl,r6
1129: 1095 00011137 # asm("movl _psl_val,r7"); /* r7 = final PSL */
1130: 1096 00011137 0d effffff6d3 57 movl _psl_val,r7
1131: 1097 0001113E # asm("movl _exp_psl,r8"); /* r8 = expected PSL */
1132: 1098 0001113E 0d effffff6cc 58 movl _exp_psl,r8
1133: 1099 00011145 # };
1134: 1100 00011145 L355:
1135: 1101 00011145 L354:
1136: 1102 00011145 L352:
1137: 1103 00011145 # asm("halt"); /* HALT ... */
1138: 1104 00011145 00 halt
1139: 1105 00011146 # }
1140: 1106 00011146 40 ret#2
1141: 1107 00011147 .set L347,0x0
1142: 1108 00011147 L349:
1143: 1109 00011147 13 ff55 jbr L350
1144: 1110 0001114A .data
1145: 1110 0002195A .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.