![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to negf.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 negf.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 000008c8 * .text
4: 4 00000000 .align 1
5: 5 00000000 .globl _negf
6: 6 00000000 _negf:
7: 7 0001114C 0000 .word L215
8: 8 0001114E #
9: 9 0001114E # #include "fpp_defs.h"
10: 10 0001114E #
11: 11 0001114E #
12: 12 0001114E # /*****************************************************************************
13: 13 0001114E # *
14: 14 0001114E # * NEGF - SINGLE PRECISION FLOATING POINT LOAD_NEGATE TEST
15: 15 0001114E # *
16: 16 0001114E # *****************************************************************************/
17: 17 0001114E # negf()
18: 18 0001114E # {
19: 19 0001114E 11 50 jbr L217
20: 20 00011150 L218:
21: 21 00011150 # asm(".globl _negf_t");
22: 22 00011150 .globl _negf_t
23: 23 00011150 # asm("_negf_t:"); /* entry address */
24: 24 00011150 _negf_t:
25: 25 00011150 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */
26: 26 00011150 1d effffffff6 01 cmpl _cycle,$1
27: 27 00011157 21 15 jneq L219
28: 28 00011159 5d efffffffed tstl _prt_hdrs
29: 29 0001115F 31 0d jeql L219
30: 30 00011161 # writes(" NEGF");
31: 31 00011161 .data 1
32: 32 000008c8 * L221:
33: 33 000008c8 * 204E45474600 .ascii " NEGF\0"
34: 34 000008ce * .text
35: 35 00011161 dd 8f000008c8 pushl $L221
36: 36 00011167 fe 08 efffffffde callf $8,_writes
37: 37 0001116E # negf_1(); /* negate through the cache */
38: 38 0001116E L219:
39: 39 0001116E fe 04 ef0000002d callf $4,_negf_1
40: 40 00011175 # negf_2(); /* register stability */
41: 41 00011175 fe 04 ef0000018a callf $4,_negf_2
42: 42 0001117C # negf_3(); /* PSL stability test */
43: 43 0001117C fe 04 ef00000323 callf $4,_negf_3
44: 44 00011183 # if( !no_fpp_wcs ) {
45: 45 00011183 5d efffffffc3 tstl _no_fpp_wcs
46: 46 00011189 21 0e jneq L225
47: 47 0001118B # negf_4(); /* pipelined entry test */
48: 48 0001118B fe 04 ef000004c0 callf $4,_negf_4
49: 49 00011192 # negf_5(); /* pipelined exit test */
50: 50 00011192 fe 04 ef00000623 callf $4,_negf_5
51: 51 00011199 # };
52: 52 00011199 L225:
53: 53 00011199 # asm("jmp *return"); /* return to the test monitor */
54: 54 00011199 71 ffffffffad jmp *return
55: 55 0001119F # }
56: 56 0001119F 40 ret#2
57: 57 000111A0 .set L215,0x0
58: 58 000111A0 L217:
59: 59 000111A0 11 ae jbr L218
60: 60 000111A2 .data
61: 61 000008c8 * .text
62: 62 000111A2 .align 1
63: 63 000111A2 .globl _negf_1
64: 64 000111A2 _negf_1:
65: 65 000111A2 0000 .word L228
66: 66 000111A4 #
67: 67 000111A4 #
68: 68 000111A4 #
69: 69 000111A4 # /************************************************************************
70: 70 000111A4 # *
71: 71 000111A4 # * SUBTEST 1 - negate through memory
72: 72 000111A4 # *
73: 73 000111A4 # ************************************************************************/
74: 74 000111A4 # negf_1()
75: 75 000111A4 # {
76: 76 000111A4 13 015c jbr L230
77: 77 000111A7 L231:
78: 78 000111A7 # force_loop = FALSE;
79: 79 000111A7 4d efffffff9f clrl _force_loop
80: 80 000111AD # subtest = 1;
81: 81 000111AD 0d 01 efffffff98 movl $1,_subtest
82: 82 000111B4 # for( index = 0; index < max_lnf_1_index; index++ ) {
83: 83 000111B4 4d efffffff92 clrl _index
84: 84 000111BA L234:
85: 85 000111BA 1d efffffff8c efffffff87 cmpl _index,_max_lnf_1_index
86: 86 000111C5 91 03 13 0138 jgeq L233
87: 87 000111CA # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
88: 88 000111CA 0d efffffff7c 50 movl _index,r0
89: 89 000111D1 48 03 50 50 shll $3,r0,r0
90: 90 000111D5 0d e000000000 efffffff6c movl _lnf_1_data(r0),_sgl_ld_acc
91: 91 000111E0 # sgl_expected = lnf_1_data[index].exp; /* get expected result */
92: 92 000111E0 0d efffffff66 50 movl _index,r0
93: 93 000111E7 48 03 50 50 shll $3,r0,r0
94: 94 000111EB 0d e000000004 efffffff56 movl _lnf_1_data+4(r0),_sgl_expected
95: 95 000111F6 # /*
96: 96 000111F6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
97: 97 000111F6 # * The force loop flag is set after the first error.
98: 98 000111F6 # */
99: 99 000111F6 # asm("_negf_1_lp1:");
100: 100 000111F6 _negf_1_lp1:
101: 101 000111F6 # asm("ldf _sgl_ld_acc"); /* load the value */
102: 102 000111F6 06 efffffff50 ldf _sgl_ld_acc
103: 103 000111FC # asm("negf"); /* negate the value */
104: 104 000111FC b6 negf
105: 105 000111FD # asm("stf _sgl_st_acc"); /* store the result */
106: 106 000111FD 26 efffffff49 stf _sgl_st_acc
107: 107 00011203 # if( force_loop )
108: 108 00011203 5d efffffff43 tstl _force_loop
109: 109 00011209 31 02 jeql L235
110: 110 0001120B # asm("brb _negf_1_lp1");; /* loop on the error */
111: 111 0001120B 11 e9 brb _negf_1_lp1
112: 112 0001120D L235:
113: 113 0001120D # /*
114: 114 0001120D # * end error loop - test the results
115: 115 0001120D # */
116: 116 0001120D # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
117: 117 0001120D 1d efffffff39 efffffff34 cmpl _sgl_st_acc,_sgl_expected
118: 118 00011218 21 03 13 00dc jeql L236
119: 119 0001121D # errcnt++; /* bump the error count */
120: 120 0001121D 6d efffffff29 incl _errcnt
121: 121 00011223 # if( prt_error ) {
122: 122 00011223 5d efffffff23 tstl _prt_error
123: 123 00011229 21 03 13 00a8 jeql L237
124: 124 0001122E # writes(" \n"); /* start a new print line */
125: 125 0001122E .data 1
126: 126 000008ce * L238:
127: 127 000008ce * 200A00 .ascii " \12\0"
128: 128 000008d1 * .text
129: 129 0001122E dd 8f000008ce pushl $L238
130: 130 00011234 fe 08 efffffff11 callf $8,_writes
131: 131 0001123B # writes("cycle: ");
132: 132 0001123B .data 1
133: 133 000008d1 * L239:
134: 134 000008d1 * 6379636C653A2000 .ascii "cycle: \0"
135: 135 000008d9 * .text
136: 136 0001123B dd 8f000008d1 pushl $L239
137: 137 00011241 fe 08 efffffff04 callf $8,_writes
138: 138 00011248 # writed( cycle );
139: 139 00011248 dd effffffefe pushl _cycle
140: 140 0001124E fe 08 effffffef7 callf $8,_writed
141: 141 00011255 # writes(" NEGF test ");
142: 142 00011255 .data 1
143: 143 000008d9 * L241:
144: 144 000008d9 * 20204E4547462074657374200 .ascii " NEGF test \0"
145: 0
146: 145 000008e6 * .text
147: 146 00011255 dd 8f000008d9 pushl $L241
148: 147 0001125B fe 08 effffffeea callf $8,_writes
149: 148 00011262 # writed( test_no );
150: 149 00011262 dd effffffee4 pushl _test_no
151: 150 00011268 fe 08 effffffedd callf $8,_writed
152: 151 0001126F # writes(", subtest 1 (Cache Data) - BAD FINAL ACC\n");
153: 152 0001126F .data 1
154: 153 000008e6 * L242:
155: 154 000008e6 * 2C20737562746573742031202 .ascii ", subtest 1 (Cache Data) - BAD FINAL ACC\12\0"
156: 8436163686520446174612920
157: 2D204241442046494E414C204
158: 143430A00
159: 155 00000910 * .text
160: 156 0001126F dd 8f000008e6 pushl $L242
161: 157 00011275 fe 08 effffffed0 callf $8,_writes
162: 158 0001127C # print_negf_data();
163: 159 0001127C fe 04 ef000006a3 callf $4,_print_negf_data
164: 160 00011283 # writes(", data index = ");
165: 161 00011283 .data 1
166: 162 00000910 * L244:
167: 163 00000910 * 2C2020206461746120696E646 .ascii ", data index = \0"
168: 578203D2000
169: 164 00000922 * .text
170: 165 00011283 dd 8f00000910 pushl $L244
171: 166 00011289 fe 08 effffffebc callf $8,_writes
172: 167 00011290 # writed( index );
173: 168 00011290 dd effffffeb6 pushl _index
174: 169 00011296 fe 08 effffffeaf callf $8,_writed
175: 170 0001129D # writec('\n');
176: 171 0001129D dd 0a pushl $10
177: 172 0001129F fe 08 effffffea6 callf $8,_writec
178: 173 000112A6 # writes(" ");
179: 174 000112A6 .data 1
180: 175 00000922 * L246:
181: 176 00000922 * 2020202020202020202020202 .ascii " \0"
182: 020202020202020202000
183: 177 00000939 * .text
184: 178 000112A6 dd 8f00000922 pushl $L246
185: 179 000112AC fe 08 effffffe99 callf $8,_writes
186: 180 000112B3 # writes("Acc expected = ");
187: 181 000112B3 .data 1
188: 182 00000939 * L247:
189: 183 00000939 * 4163632065787065637465642 .ascii "Acc expected = \0"
190: 03D2000
191: 184 00000949 * .text
192: 185 000112B3 dd 8f00000939 pushl $L247
193: 186 000112B9 fe 08 effffffe8c callf $8,_writes
194: 187 000112C0 # write32h( sgl_expected );
195: 188 000112C0 dd effffffe86 pushl _sgl_expected
196: 189 000112C6 fe 08 effffffe7f callf $8,_write32h
197: 190 000112CD # writec('\n');
198: 191 000112CD dd 0a pushl $10
199: 192 000112CF fe 08 effffffe76 callf $8,_writec
200: 193 000112D6 # }
201: 194 000112D6 # if( halt_flg )
202: 195 000112D6 L237:
203: 196 000112D6 5d effffffe70 tstl _halt_flg
204: 197 000112DC 31 09 jeql L249
205: 198 000112DE # negf_er_halt( BAD_ACC_HLT ); /* halt on the error */
206: 199 000112DE dd 01 pushl $1
207: 200 000112E0 fe 08 ef0000067b callf $8,_negf_er_halt
208: 201 000112E7 # if( loop_on_err ) {
209: 202 000112E7 L249:
210: 203 000112E7 5d effffffe5f tstl _loop_on_err
211: 204 000112ED 31 0a jeql L251
212: 205 000112EF # force_loop = TRUE; /* set the force loop flag */
213: 206 000112EF 0d 01 effffffe56 movl $1,_force_loop
214: 207 000112F6 # asm("brw _negf_1_lp1");; /* and loop on the error */
215: 208 000112F6 13 fefd brw _negf_1_lp1
216: 209 000112F9 # } /* end of loop on error */
217: 210 000112F9 # } /* end of compare error */
218: 211 000112F9 L251:
219: 212 000112F9 # } /* end of WHILE loop */
220: 213 000112F9 L236:
221: 214 000112F9 L232:
222: 215 000112F9 6d effffffe4d incl _index
223: 216 000112FF 13 feb8 jbr L234
224: 217 00011302 L233:
225: 218 00011302 # } /* end of subtest 1 */
226: 219 00011302 40 ret#2
227: 220 00011303 .set L228,0x0
228: 221 00011303 L230:
229: 222 00011303 13 fea1 jbr L231
230: 223 00011306 .data
231: 224 000008c8 * .text
232: 225 00011306 .align 1
233: 226 00011306 .globl _negf_2
234: 227 00011306 _negf_2:
235: 228 00011306 0000 .word L252
236: 229 00011308 #
237: 230 00011308 #
238: 231 00011308 #
239: 232 00011308 # /************************************************************************
240: 233 00011308 # *
241: 234 00011308 # * SUBTEST 2 - Check for register corruption
242: 235 00011308 # *
243: 236 00011308 # ************************************************************************/
244: 237 00011308 # negf_2()
245: 238 00011308 # {
246: 239 00011308 13 0197 jbr L254
247: 240 0001130B L255:
248: 241 0001130B # force_loop = FALSE; /* clear force_loop flg */
249: 242 0001130B 4d effffffe3b clrl _force_loop
250: 243 00011311 # subtest = 2;
251: 244 00011311 0d 02 effffffe34 movl $2,_subtest
252: 245 00011318 # fill_reg_buf( load_regs ); /* get patterns for regs */
253: 246 00011318 dd 8f00000000 pushl $_load_regs
254: 247 0001131E fe 08 effffffe27 callf $8,_fill_reg_buf
255: 248 00011325 # index = 0;
256: 249 00011325 4d effffffe21 clrl _index
257: 250 0001132B # sgl_ld_acc = lnf_1_data[0].ld; /* get value to negate */
258: 251 0001132B 0d effffffe1b effffffe16 movl _lnf_1_data,_sgl_ld_acc
259: 252 00011336 # sgl_expected = lnf_1_data[0].exp; /* get expected result */
260: 253 00011336 0d effffffe14 effffffe0b movl _lnf_1_data+4,_sgl_expected
261: 254 00011341 # /*
262: 255 00011341 # * If LOOP ON ERROR is set, this is the loop for this subtest.
263: 256 00011341 # * The force loop flag is set after the first error.
264: 257 00011341 # */
265: 258 00011341 # asm("_negf_2_lp1:");
266: 259 00011341 _negf_2_lp1:
267: 260 00011341 # asm("ldf _sgl_ld_acc"); /* load the initial value */
268: 261 00011341 06 effffffe05 ldf _sgl_ld_acc
269: 262 00011347 # asm("nop");
270: 263 00011347 10 nop
271: 264 00011348 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */
272: 265 00011348 ab 891fff effffffdfb loadr $0x1fff,_load_regs
273: 266 00011351 # asm("nop");
274: 267 00011351 10 nop
275: 268 00011352 # asm("negf"); /* negate the value */
276: 269 00011352 b6 negf
277: 270 00011353 # asm("nop");
278: 271 00011353 10 nop
279: 272 00011354 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */
280: 273 00011354 bb 891fff effffffdef storer $0x1fff,_store_regs
281: 274 0001135D # asm("stf _sgl_st_acc"); /* save the accumulator */
282: 275 0001135D 26 effffffde9 stf _sgl_st_acc
283: 276 00011363 # if( force_loop )
284: 277 00011363 5d effffffde3 tstl _force_loop
285: 278 00011369 31 02 jeql L257
286: 279 0001136B # asm("brb _negf_2_lp1");; /* loop on the error */
287: 280 0001136B 11 d4 brb _negf_2_lp1
288: 281 0001136D L257:
289: 282 0001136D # /*
290: 283 0001136D # * Now compare the stored register values to those that were loaded
291: 284 0001136D # */
292: 285 0001136D # index2 = 0;
293: 286 0001136D 4d effffffdd9 clrl _index2
294: 287 00011373 # while( (load_regs[index2] == store_regs[index2]) && (index2 < 13) )
295: 288 00011373 L258:
296: 289 00011373 0d effffffdd3 50 movl _index2,r0
297: 290 0001137A 0d effffffdcc 51 movl _index2,r1
298: 291 00011381 1d 40effffffdc4 cmpl _load_regs[r0],_store_regs[r1]
299: 41effffffdbe
300: 292 0001138E 21 11 jneq L259
301: 293 00011390 1d effffffdb6 0d cmpl _index2,$13
302: 294 00011397 81 08 jgeq L259
303: 295 00011399 # index2++; /* check reg values */
304: 296 00011399 6d effffffdad incl _index2
305: 297 0001139F 11 d2 jbr L258
306: 298 000113A1 L259:
307: 299 000113A1 # if( index2 < 13 ) { /* error if index2 < 13 */
308: 300 000113A1 1d effffffda5 0d cmpl _index2,$13
309: 301 000113A8 91 03 13 00f4 jgeq L260
310: 302 000113AD # errcnt++; /* bump the error count */
311: 303 000113AD 6d effffffd99 incl _errcnt
312: 304 000113B3 # if( prt_error ) {
313: 305 000113B3 5d effffffd93 tstl _prt_error
314: 306 000113B9 21 03 13 00c0 jeql L261
315: 307 000113BE # writes(" \n"); /* start a new print line */
316: 308 000113BE .data 1
317: 309 00000949 * L262:
318: 310 00000949 * 200A00 .ascii " \12\0"
319: 311 0000094c * .text
320: 312 000113BE dd 8f00000949 pushl $L262
321: 313 000113C4 fe 08 effffffd81 callf $8,_writes
322: 314 000113CB # writes("cycle: ");
323: 315 000113CB .data 1
324: 316 0000094c * L263:
325: 317 0000094c * 6379636C653A2000 .ascii "cycle: \0"
326: 318 00000954 * .text
327: 319 000113CB dd 8f0000094c pushl $L263
328: 320 000113D1 fe 08 effffffd74 callf $8,_writes
329: 321 000113D8 # writed( cycle );
330: 322 000113D8 dd effffffd6e pushl _cycle
331: 323 000113DE fe 08 effffffd67 callf $8,_writed
332: 324 000113E5 # writes(" NEGF test ");
333: 325 000113E5 .data 1
334: 326 00000954 * L264:
335: 327 00000954 * 20204E4547462074657374200 .ascii " NEGF test \0"
336: 0
337: 328 00000961 * .text
338: 329 000113E5 dd 8f00000954 pushl $L264
339: 330 000113EB fe 08 effffffd5a callf $8,_writes
340: 331 000113F2 # writed( test_no );
341: 332 000113F2 dd effffffd54 pushl _test_no
342: 333 000113F8 fe 08 effffffd4d callf $8,_writed
343: 334 000113FF # writes(", subtest 2 (Reg. Corr.) - A REGISTER WAS MODIFIED\n");
344: 335 000113FF .data 1
345: 336 00000961 * L265:
346: 337 00000961 * 2C20737562746573742032202 .ascii ", subtest 2 (Reg. Corr.) - A REGISTER WAS MODIFIED\12\0"
347: 85265672E20436F72722E2920
348: 2D20412052454749535445522
349: 0574153204D4F444946494544
350: 0A00
351: 338 00000995 * .text
352: 339 000113FF dd 8f00000961 pushl $L265
353: 340 00011405 fe 08 effffffd40 callf $8,_writes
354: 341 0001140C # print_negf_data(); /* print the operands */
355: 342 0001140C fe 04 ef00000513 callf $4,_print_negf_data
356: 343 00011413 # writes("\nregister "); /* print the information */
357: 344 00011413 .data 1
358: 345 00000995 * L266:
359: 346 00000995 * 0A72656769737465722000 .ascii "\12register \0"
360: 347 000009a0 * .text
361: 348 00011413 dd 8f00000995 pushl $L266
362: 349 00011419 fe 08 effffffd2c callf $8,_writes
363: 350 00011420 # writed( index2 ); /* about the corrupted */
364: 351 00011420 dd effffffd26 pushl _index2
365: 352 00011426 fe 08 effffffd1f callf $8,_writed
366: 353 0001142D # writes(" = "); /* register */
367: 354 0001142D .data 1
368: 355 000009a0 * L267:
369: 356 000009a0 * 203D2000 .ascii " = \0"
370: 357 000009a4 * .text
371: 358 0001142D dd 8f000009a0 pushl $L267
372: 359 00011433 fe 08 effffffd12 callf $8,_writes
373: 360 0001143A # write32h( store_regs[index2] );
374: 361 0001143A 0d effffffd0c 50 movl _index2,r0
375: 362 00011441 dd 40effffffd04 pushl _store_regs[r0]
376: 363 00011448 fe 08 effffffcfd callf $8,_write32h
377: 364 0001144F # writes(", should be = ");
378: 365 0001144F .data 1
379: 366 000009a4 * L268:
380: 367 000009a4 * 2C202073686F756C642062652 .ascii ", should be = \0"
381: 03D2000
382: 368 000009b4 * .text
383: 369 0001144F dd 8f000009a4 pushl $L268
384: 370 00011455 fe 08 effffffcf0 callf $8,_writes
385: 371 0001145C # write32h( load_regs[index2] );
386: 372 0001145C 0d effffffcea 50 movl _index2,r0
387: 373 00011463 dd 40effffffce2 pushl _load_regs[r0]
388: 374 0001146A fe 08 effffffcdb callf $8,_write32h
389: 375 00011471 # writes("\n");
390: 376 00011471 .data 1
391: 377 000009b4 * L269:
392: 378 000009b4 * 0A00 .ascii "\12\0"
393: 379 000009b6 * .text
394: 380 00011471 dd 8f000009b4 pushl $L269
395: 381 00011477 fe 08 effffffcce callf $8,_writes
396: 382 0001147E # }
397: 383 0001147E # if( halt_flg )
398: 384 0001147E L261:
399: 385 0001147E 5d effffffcc8 tstl _halt_flg
400: 386 00011484 31 09 jeql L270
401: 387 00011486 # negf_er_halt( BAD_REG_HLT ); /* halt on the error */
402: 388 00011486 dd 02 pushl $2
403: 389 00011488 fe 08 ef000004d3 callf $8,_negf_er_halt
404: 390 0001148F # if( loop_on_err ) {
405: 391 0001148F L270:
406: 392 0001148F 5d effffffcb7 tstl _loop_on_err
407: 393 00011495 31 0a jeql L271
408: 394 00011497 # force_loop = TRUE; /* set the force loop flag */
409: 395 00011497 0d 01 effffffcae movl $1,_force_loop
410: 396 0001149E # asm("brw _negf_2_lp1");; /* and loop on the error */
411: 397 0001149E 13 fea0 brw _negf_2_lp1
412: 398 000114A1 # } /* end of loop on error */
413: 399 000114A1 # } /* end of register corruption error */
414: 400 000114A1 L271:
415: 401 000114A1 # } /* end of subtest 2 */
416: 402 000114A1 L260:
417: 403 000114A1 40 ret#2
418: 404 000114A2 .set L252,0x0
419: 405 000114A2 L254:
420: 406 000114A2 13 fe66 jbr L255
421: 407 000114A5 .data
422: 408 000008c8 * .text
423: 409 000114A5 00 .align 1
424: 410 000114A6 .globl _negf_3
425: 411 000114A6 _negf_3:
426: 412 000114A6 0000 .word L272
427: 413 000114A8 #
428: 414 000114A8 #
429: 415 000114A8 #
430: 416 000114A8 # /************************************************************************
431: 417 000114A8 # *
432: 418 000114A8 # * SUBTEST 3 - Check for PSL corruption
433: 419 000114A8 # *
434: 420 000114A8 # ************************************************************************/
435: 421 000114A8 # negf_3()
436: 422 000114A8 # {
437: 423 000114A8 13 01a4 jbr L274
438: 424 000114AB L275:
439: 425 000114AB # force_loop = FALSE; /* clear force_loop flg */
440: 426 000114AB 4d effffffc9b clrl _force_loop
441: 427 000114B1 # subtest = 3;
442: 428 000114B1 0d 03 effffffc94 movl $3,_subtest
443: 429 000114B8 # fill_reg_buf( load_regs ); /* get patterns for regs */
444: 430 000114B8 dd 8f00000000 pushl $_load_regs
445: 431 000114BE fe 08 effffffc87 callf $8,_fill_reg_buf
446: 432 000114C5 # for( index = 0; index < 3; index++ ) {
447: 433 000114C5 4d effffffc81 clrl _index
448: 434 000114CB L278:
449: 435 000114CB 1d effffffc7b 03 cmpl _index,$3
450: 436 000114D2 91 03 13 0177 jgeq L277
451: 437 000114D7 # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
452: 438 000114D7 0d effffffc6f 50 movl _index,r0
453: 439 000114DE 48 03 50 50 shll $3,r0,r0
454: 440 000114E2 0d e000000000 effffffc5f movl _lnf_1_data(r0),_sgl_ld_acc
455: 441 000114ED # sgl_expected = lnf_1_data[index].exp; /* get expected */
456: 442 000114ED 0d effffffc59 50 movl _index,r0
457: 443 000114F4 48 03 50 50 shll $3,r0,r0
458: 444 000114F8 0d e000000004 effffffc49 movl _lnf_1_data+4(r0),_sgl_expected
459: 445 00011503 # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */
460: 446 00011503 0d effffffc43 50 movl _status_index,r0
461: 447 0001150A 0d 40effffffc3b movl _status_array[r0],_sgl_dummy1
462: effffffc36
463: 448 00011516 # /*
464: 449 00011516 # * If LOOP ON ERROR is set, this is the loop for this subtest.
465: 450 00011516 # * The force loop flag is set after the first error.
466: 451 00011516 # */
467: 452 00011516 # asm("_negf_3_lp1:");
468: 453 00011516 _negf_3_lp1:
469: 454 00011516 # asm("ldf _sgl_ld_acc"); /* load the initial value */
470: 455 00011516 06 effffffc30 ldf _sgl_ld_acc
471: 456 0001151C # asm("nop");
472: 457 0001151C 10 nop
473: 458 0001151D # asm("tstl _sgl_dummy1"); /* set the PSL status */
474: 459 0001151D 5d effffffc29 tstl _sgl_dummy1
475: 460 00011523 # asm("movpsl _init_psl"); /* save the initial PSL */
476: 461 00011523 cd effffffc23 movpsl _init_psl
477: 462 00011529 # asm("negf"); /* negate the value */
478: 463 00011529 b6 negf
479: 464 0001152A # asm("nop");
480: 465 0001152A 10 nop
481: 466 0001152B # asm("movpsl _psl_val"); /* save the final PSL */
482: 467 0001152B cd effffffc1b movpsl _psl_val
483: 468 00011531 # asm("stf _sgl_st_acc"); /* save the accumulator */
484: 469 00011531 26 effffffc15 stf _sgl_st_acc
485: 470 00011537 # if( force_loop )
486: 471 00011537 5d effffffc0f tstl _force_loop
487: 472 0001153D 31 02 jeql L279
488: 473 0001153F # asm("brb _negf_3_lp1");; /* loop on the error */
489: 474 0001153F 11 d5 brb _negf_3_lp1
490: 475 00011541 L279:
491: 476 00011541 # /*
492: 477 00011541 # * Now compare the final PSL to the initial PSL -they should be the same
493: 478 00011541 # */
494: 479 00011541 # exp_psl = init_psl;
495: 480 00011541 0d effffffc05 effffffc00 movl _init_psl,_exp_psl
496: 481 0001154C # if( psl_val != init_psl ) {
497: 482 0001154C 1d effffffbfa effffffbf5 cmpl _psl_val,_init_psl
498: 483 00011557 21 03 13 00e9 jeql L280
499: 484 0001155C # errcnt++; /* bump the error count */
500: 485 0001155C 6d effffffbea incl _errcnt
501: 486 00011562 # if( prt_error ) {
502: 487 00011562 5d effffffbe4 tstl _prt_error
503: 488 00011568 21 03 13 00b5 jeql L281
504: 489 0001156D # writes(" \n"); /* start a new print line */
505: 490 0001156D .data 1
506: 491 000009b6 * L282:
507: 492 000009b6 * 200A00 .ascii " \12\0"
508: 493 000009b9 * .text
509: 494 0001156D dd 8f000009b6 pushl $L282
510: 495 00011573 fe 08 effffffbd2 callf $8,_writes
511: 496 0001157A # writes("cycle: ");
512: 497 0001157A .data 1
513: 498 000009b9 * L283:
514: 499 000009b9 * 6379636C653A2000 .ascii "cycle: \0"
515: 500 000009c1 * .text
516: 501 0001157A dd 8f000009b9 pushl $L283
517: 502 00011580 fe 08 effffffbc5 callf $8,_writes
518: 503 00011587 # writed( cycle );
519: 504 00011587 dd effffffbbf pushl _cycle
520: 505 0001158D fe 08 effffffbb8 callf $8,_writed
521: 506 00011594 # writes(" NEGF test ");
522: 507 00011594 .data 1
523: 508 000009c1 * L284:
524: 509 000009c1 * 20204E4547462074657374200 .ascii " NEGF test \0"
525: 0
526: 510 000009ce * .text
527: 511 00011594 dd 8f000009c1 pushl $L284
528: 512 0001159A fe 08 effffffbab callf $8,_writes
529: 513 000115A1 # writed( test_no );
530: 514 000115A1 dd effffffba5 pushl _test_no
531: 515 000115A7 fe 08 effffffb9e callf $8,_writed
532: 516 000115AE # writes(", subtest 3 (PSL Corr.) - INCORRECT FINAL PSL\n");
533: 517 000115AE .data 1
534: 518 000009ce * L285:
535: 519 000009ce * 2C20737562746573742033202 .ascii ", subtest 3 (PSL Corr.) - INCORRECT FINAL PSL\12\0"
536: 850534C20436F72722E29202D
537: 20494E434F525245435420464
538: 94E414C2050534C0A00
539: 520 000009fd * .text
540: 521 000115AE dd 8f000009ce pushl $L285
541: 522 000115B4 fe 08 effffffb91 callf $8,_writes
542: 523 000115BB # print_negf_data(); /* print the operands */
543: 524 000115BB fe 04 ef00000364 callf $4,_print_negf_data
544: 525 000115C2 # writec('\n');
545: 526 000115C2 dd 0a pushl $10
546: 527 000115C4 fe 08 effffffb81 callf $8,_writec
547: 528 000115CB # writes("initial PSL = ");
548: 529 000115CB .data 1
549: 530 000009fd * L286:
550: 531 000009fd * 696E697469616C2050534C203 .ascii "initial PSL = \0"
551: D2000
552: 532 00000a0c * .text
553: 533 000115CB dd 8f000009fd pushl $L286
554: 534 000115D1 fe 08 effffffb74 callf $8,_writes
555: 535 000115D8 # write32h( init_psl );
556: 536 000115D8 dd effffffb6e pushl _init_psl
557: 537 000115DE fe 08 effffffb67 callf $8,_write32h
558: 538 000115E5 # writes(", final PSL = ");
559: 539 000115E5 .data 1
560: 540 00000a0c * L287:
561: 541 00000a0c * 2C202066696E616C2050534C2 .ascii ", final PSL = \0"
562: 03D2000
563: 542 00000a1c * .text
564: 543 000115E5 dd 8f00000a0c pushl $L287
565: 544 000115EB fe 08 effffffb5a callf $8,_writes
566: 545 000115F2 # write32h( psl_val );
567: 546 000115F2 dd effffffb54 pushl _psl_val
568: 547 000115F8 fe 08 effffffb4d callf $8,_write32h
569: 548 000115FF # writes(", expected PSL = ");
570: 549 000115FF .data 1
571: 550 00000a1c * L288:
572: 551 00000a1c * 2C20206578706563746564205 .ascii ", expected PSL = \0"
573: 0534C203D2000
574: 552 00000a2f * .text
575: 553 000115FF dd 8f00000a1c pushl $L288
576: 554 00011605 fe 08 effffffb40 callf $8,_writes
577: 555 0001160C # write32h( exp_psl );
578: 556 0001160C dd effffffb3a pushl _exp_psl
579: 557 00011612 fe 08 effffffb33 callf $8,_write32h
580: 558 00011619 # writec('\n');
581: 559 00011619 dd 0a pushl $10
582: 560 0001161B fe 08 effffffb2a callf $8,_writec
583: 561 00011622 # }
584: 562 00011622 # if( halt_flg )
585: 563 00011622 L281:
586: 564 00011622 5d effffffb24 tstl _halt_flg
587: 565 00011628 31 09 jeql L289
588: 566 0001162A # negf_er_halt( BAD_PSL_HLT ); /* halt on the error */
589: 567 0001162A dd 03 pushl $3
590: 568 0001162C fe 08 ef0000032f callf $8,_negf_er_halt
591: 569 00011633 # if( loop_on_err ) {
592: 570 00011633 L289:
593: 571 00011633 5d effffffb13 tstl _loop_on_err
594: 572 00011639 31 0a jeql L290
595: 573 0001163B # force_loop = TRUE; /* set the force loop flag */
596: 574 0001163B 0d 01 effffffb0a movl $1,_force_loop
597: 575 00011642 # asm("brw _negf_3_lp1");; /* and loop on the error */
598: 576 00011642 13 fed1 brw _negf_3_lp1
599: 577 00011645 # } /* end of loop on error */
600: 578 00011645 # } /* end of PSL corruption error */
601: 579 00011645 L290:
602: 580 00011645 # } /* end of WHILE loop */
603: 581 00011645 L280:
604: 582 00011645 L276:
605: 583 00011645 6d effffffb01 incl _index
606: 584 0001164B 13 fe7d jbr L278
607: 585 0001164E L277:
608: 586 0001164E # } /* end of subtest 3 */
609: 587 0001164E 40 ret#2
610: 588 0001164F .set L272,0x0
611: 589 0001164F L274:
612: 590 0001164F 13 fe59 jbr L275
613: 591 00011652 .data
614: 592 000008c8 * .text
615: 593 00011652 .align 1
616: 594 00011652 .globl _negf_4
617: 595 00011652 _negf_4:
618: 596 00011652 0000 .word L291
619: 597 00011654 #
620: 598 00011654 #
621: 599 00011654 #
622: 600 00011654 # /************************************************************************
623: 601 00011654 # *
624: 602 00011654 # * SUBTEST 4 - pipelined entry test
625: 603 00011654 # *
626: 604 00011654 # ************************************************************************/
627: 605 00011654 # negf_4()
628: 606 00011654 # {
629: 607 00011654 13 0161 jbr L293
630: 608 00011657 L294:
631: 609 00011657 # force_loop = FALSE;
632: 610 00011657 4d effffffaef clrl _force_loop
633: 611 0001165D # subtest = 4;
634: 612 0001165D 0d 04 effffffae8 movl $4,_subtest
635: 613 00011664 # for( index = 0; index < max_lnf_1_index; index++ ) {
636: 614 00011664 4d effffffae2 clrl _index
637: 615 0001166A L297:
638: 616 0001166A 1d effffffadc effffffad7 cmpl _index,_max_lnf_1_index
639: 617 00011675 91 03 13 013d jgeq L296
640: 618 0001167A # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
641: 619 0001167A 0d effffffacc 50 movl _index,r0
642: 620 00011681 48 03 50 50 shll $3,r0,r0
643: 621 00011685 0d e000000000 effffffabc movl _lnf_1_data(r0),_sgl_ld_acc
644: 622 00011690 # sgl_expected = lnf_1_data[index].exp; /* get expected result */
645: 623 00011690 0d effffffab6 50 movl _index,r0
646: 624 00011697 48 03 50 50 shll $3,r0,r0
647: 625 0001169B 0d e000000004 effffffaa6 movl _lnf_1_data+4(r0),_sgl_expected
648: 626 000116A6 # /*
649: 627 000116A6 # * If LOOP ON ERROR is set, this is the loop for this subtest.
650: 628 000116A6 # * The force loop flag is set after the first error.
651: 629 000116A6 # */
652: 630 000116A6 # asm("_negf_4_lp1:");
653: 631 000116A6 _negf_4_lp1:
654: 632 000116A6 # asm("movl $0,r0"); /* clear r0 */
655: 633 000116A6 0d 00 50 movl $0,r0
656: 634 000116A9 # asm("ldf r0"); /* load the Acc. with 0.0 */
657: 635 000116A9 06 50 ldf r0
658: 636 000116AB # asm("addf _sgl_ld_acc"); /* add the value to negate */
659: 637 000116AB c6 effffffa9b addf _sgl_ld_acc
660: 638 000116B1 # asm("negf"); /* negate the value */
661: 639 000116B1 b6 negf
662: 640 000116B2 # asm("stf _sgl_st_acc"); /* store the result */
663: 641 000116B2 26 effffffa94 stf _sgl_st_acc
664: 642 000116B8 # if( force_loop )
665: 643 000116B8 5d effffffa8e tstl _force_loop
666: 644 000116BE 31 02 jeql L298
667: 645 000116C0 # asm("brb _negf_4_lp1");; /* loop on the error */
668: 646 000116C0 11 e4 brb _negf_4_lp1
669: 647 000116C2 L298:
670: 648 000116C2 # /*
671: 649 000116C2 # * end error loop - test the results
672: 650 000116C2 # */
673: 651 000116C2 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
674: 652 000116C2 1d effffffa84 effffffa7f cmpl _sgl_st_acc,_sgl_expected
675: 653 000116CD 21 03 13 00dc jeql L299
676: 654 000116D2 # errcnt++; /* bump the error count */
677: 655 000116D2 6d effffffa74 incl _errcnt
678: 656 000116D8 # if( prt_error ) {
679: 657 000116D8 5d effffffa6e tstl _prt_error
680: 658 000116DE 21 03 13 00a8 jeql L300
681: 659 000116E3 # writes(" \n"); /* start a new print line */
682: 660 000116E3 .data 1
683: 661 00000a2f * L301:
684: 662 00000a2f * 200A00 .ascii " \12\0"
685: 663 00000a32 * .text
686: 664 000116E3 dd 8f00000a2f pushl $L301
687: 665 000116E9 fe 08 effffffa5c callf $8,_writes
688: 666 000116F0 # writes("cycle: ");
689: 667 000116F0 .data 1
690: 668 00000a32 * L302:
691: 669 00000a32 * 6379636C653A2000 .ascii "cycle: \0"
692: 670 00000a3a * .text
693: 671 000116F0 dd 8f00000a32 pushl $L302
694: 672 000116F6 fe 08 effffffa4f callf $8,_writes
695: 673 000116FD # writed( cycle );
696: 674 000116FD dd effffffa49 pushl _cycle
697: 675 00011703 fe 08 effffffa42 callf $8,_writed
698: 676 0001170A # writes(" NEGF test ");
699: 677 0001170A .data 1
700: 678 00000a3a * L303:
701: 679 00000a3a * 20204E4547462074657374200 .ascii " NEGF test \0"
702: 0
703: 680 00000a47 * .text
704: 681 0001170A dd 8f00000a3a pushl $L303
705: 682 00011710 fe 08 effffffa35 callf $8,_writes
706: 683 00011717 # writed( test_no );
707: 684 00011717 dd effffffa2f pushl _test_no
708: 685 0001171D fe 08 effffffa28 callf $8,_writed
709: 686 00011724 # writes(", subtest 4 (Piped Entry) - BAD FINAL ACC\n");
710: 687 00011724 .data 1
711: 688 00000a47 * L304:
712: 689 00000a47 * 2C20737562746573742034202 .ascii ", subtest 4 (Piped Entry) - BAD FINAL ACC\12\0"
713: 8506970656420456E74727929
714: 202D204241442046494E414C2
715: 04143430A00
716: 690 00000a72 * .text
717: 691 00011724 dd 8f00000a47 pushl $L304
718: 692 0001172A fe 08 effffffa1b callf $8,_writes
719: 693 00011731 # print_negf_data();
720: 694 00011731 fe 04 ef000001ee callf $4,_print_negf_data
721: 695 00011738 # writes(", data index = ");
722: 696 00011738 .data 1
723: 697 00000a72 * L305:
724: 698 00000a72 * 2C2020206461746120696E646 .ascii ", data index = \0"
725: 578203D2000
726: 699 00000a84 * .text
727: 700 00011738 dd 8f00000a72 pushl $L305
728: 701 0001173E fe 08 effffffa07 callf $8,_writes
729: 702 00011745 # writed( index );
730: 703 00011745 dd effffffa01 pushl _index
731: 704 0001174B fe 08 effffff9fa callf $8,_writed
732: 705 00011752 # writec('\n');
733: 706 00011752 dd 0a pushl $10
734: 707 00011754 fe 08 effffff9f1 callf $8,_writec
735: 708 0001175B # writes(" ");
736: 709 0001175B .data 1
737: 710 00000a84 * L306:
738: 711 00000a84 * 2020202020202020202020202 .ascii " \0"
739: 020202020202020202000
740: 712 00000a9b * .text
741: 713 0001175B dd 8f00000a84 pushl $L306
742: 714 00011761 fe 08 effffff9e4 callf $8,_writes
743: 715 00011768 # writes("Acc expected = ");
744: 716 00011768 .data 1
745: 717 00000a9b * L307:
746: 718 00000a9b * 4163632065787065637465642 .ascii "Acc expected = \0"
747: 03D2000
748: 719 00000aab * .text
749: 720 00011768 dd 8f00000a9b pushl $L307
750: 721 0001176E fe 08 effffff9d7 callf $8,_writes
751: 722 00011775 # write32h( sgl_expected );
752: 723 00011775 dd effffff9d1 pushl _sgl_expected
753: 724 0001177B fe 08 effffff9ca callf $8,_write32h
754: 725 00011782 # writec('\n');
755: 726 00011782 dd 0a pushl $10
756: 727 00011784 fe 08 effffff9c1 callf $8,_writec
757: 728 0001178B # }
758: 729 0001178B # if( halt_flg )
759: 730 0001178B L300:
760: 731 0001178B 5d effffff9bb tstl _halt_flg
761: 732 00011791 31 09 jeql L308
762: 733 00011793 # negf_er_halt( BAD_ACC_HLT ); /* halt on the error */
763: 734 00011793 dd 01 pushl $1
764: 735 00011795 fe 08 ef000001c6 callf $8,_negf_er_halt
765: 736 0001179C # if( loop_on_err ) {
766: 737 0001179C L308:
767: 738 0001179C 5d effffff9aa tstl _loop_on_err
768: 739 000117A2 31 0a jeql L309
769: 740 000117A4 # force_loop = TRUE; /* set the force loop flag */
770: 741 000117A4 0d 01 effffff9a1 movl $1,_force_loop
771: 742 000117AB # asm("brw _negf_4_lp1");; /* and loop on the error */
772: 743 000117AB 13 fef8 brw _negf_4_lp1
773: 744 000117AE # } /* end of loop on error */
774: 745 000117AE # } /* end of compare error */
775: 746 000117AE L309:
776: 747 000117AE # } /* end of WHILE loop */
777: 748 000117AE L299:
778: 749 000117AE L295:
779: 750 000117AE 6d effffff998 incl _index
780: 751 000117B4 13 feb3 jbr L297
781: 752 000117B7 L296:
782: 753 000117B7 # } /* end of subtest 4 */
783: 754 000117B7 40 ret#2
784: 755 000117B8 .set L291,0x0
785: 756 000117B8 L293:
786: 757 000117B8 13 fe9c jbr L294
787: 758 000117BB .data
788: 759 000008c8 * .text
789: 760 000117BB 00 .align 1
790: 761 000117BC .globl _negf_5
791: 762 000117BC _negf_5:
792: 763 000117BC 0000 .word L310
793: 764 000117BE #
794: 765 000117BE #
795: 766 000117BE #
796: 767 000117BE # /************************************************************************
797: 768 000117BE # *
798: 769 000117BE # * SUBTEST 5 - pipelined exit test
799: 770 000117BE # *
800: 771 000117BE # ************************************************************************/
801: 772 000117BE # negf_5()
802: 773 000117BE # {
803: 774 000117BE 13 0161 jbr L312
804: 775 000117C1 L313:
805: 776 000117C1 # force_loop = FALSE;
806: 777 000117C1 4d effffff985 clrl _force_loop
807: 778 000117C7 # subtest = 5;
808: 779 000117C7 0d 05 effffff97e movl $5,_subtest
809: 780 000117CE # for( index = 0; index < max_lnf_1_index; index++ ) {
810: 781 000117CE 4d effffff978 clrl _index
811: 782 000117D4 L316:
812: 783 000117D4 1d effffff972 effffff96d cmpl _index,_max_lnf_1_index
813: 784 000117DF 91 03 13 013d jgeq L315
814: 785 000117E4 # sgl_ld_acc = lnf_1_data[index].ld; /* get value to negate */
815: 786 000117E4 0d effffff962 50 movl _index,r0
816: 787 000117EB 48 03 50 50 shll $3,r0,r0
817: 788 000117EF 0d e000000000 effffff952 movl _lnf_1_data(r0),_sgl_ld_acc
818: 789 000117FA # sgl_expected = lnf_1_data[index].exp; /* get expected result */
819: 790 000117FA 0d effffff94c 50 movl _index,r0
820: 791 00011801 48 03 50 50 shll $3,r0,r0
821: 792 00011805 0d e000000004 effffff93c movl _lnf_1_data+4(r0),_sgl_expected
822: 793 00011810 # /*
823: 794 00011810 # * If LOOP ON ERROR is set, this is the loop for this subtest.
824: 795 00011810 # * The force loop flag is set after the first error.
825: 796 00011810 # */
826: 797 00011810 # asm("_negf_5_lp1:");
827: 798 00011810 _negf_5_lp1:
828: 799 00011810 # asm("movl $0,r0"); /* clear r0 */
829: 800 00011810 0d 00 50 movl $0,r0
830: 801 00011813 # asm("ldf _sgl_ld_acc"); /* load the value */
831: 802 00011813 06 effffff933 ldf _sgl_ld_acc
832: 803 00011819 # asm("negf"); /* negate the value */
833: 804 00011819 b6 negf
834: 805 0001181A # asm("addf r0"); /* add a zero to the acc */
835: 806 0001181A c6 50 addf r0
836: 807 0001181C # asm("stf _sgl_st_acc"); /* store the result */
837: 808 0001181C 26 effffff92a stf _sgl_st_acc
838: 809 00011822 # if( force_loop )
839: 810 00011822 5d effffff924 tstl _force_loop
840: 811 00011828 31 02 jeql L317
841: 812 0001182A # asm("brb _negf_5_lp1");; /* loop on the error */
842: 813 0001182A 11 e4 brb _negf_5_lp1
843: 814 0001182C L317:
844: 815 0001182C # /*
845: 816 0001182C # * end error loop - test the results
846: 817 0001182C # */
847: 818 0001182C # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */
848: 819 0001182C 1d effffff91a effffff915 cmpl _sgl_st_acc,_sgl_expected
849: 820 00011837 21 03 13 00dc jeql L318
850: 821 0001183C # errcnt++; /* bump the error count */
851: 822 0001183C 6d effffff90a incl _errcnt
852: 823 00011842 # if( prt_error ) {
853: 824 00011842 5d effffff904 tstl _prt_error
854: 825 00011848 21 03 13 00a8 jeql L319
855: 826 0001184D # writes(" \n"); /* start a new print line */
856: 827 0001184D .data 1
857: 828 00000aab * L320:
858: 829 00000aab * 200A00 .ascii " \12\0"
859: 830 00000aae * .text
860: 831 0001184D dd 8f00000aab pushl $L320
861: 832 00011853 fe 08 effffff8f2 callf $8,_writes
862: 833 0001185A # writes("cycle: ");
863: 834 0001185A .data 1
864: 835 00000aae * L321:
865: 836 00000aae * 6379636C653A2000 .ascii "cycle: \0"
866: 837 00000ab6 * .text
867: 838 0001185A dd 8f00000aae pushl $L321
868: 839 00011860 fe 08 effffff8e5 callf $8,_writes
869: 840 00011867 # writed( cycle );
870: 841 00011867 dd effffff8df pushl _cycle
871: 842 0001186D fe 08 effffff8d8 callf $8,_writed
872: 843 00011874 # writes(" NEGF test ");
873: 844 00011874 .data 1
874: 845 00000ab6 * L322:
875: 846 00000ab6 * 20204E4547462074657374200 .ascii " NEGF test \0"
876: 0
877: 847 00000ac3 * .text
878: 848 00011874 dd 8f00000ab6 pushl $L322
879: 849 0001187A fe 08 effffff8cb callf $8,_writes
880: 850 00011881 # writed( test_no );
881: 851 00011881 dd effffff8c5 pushl _test_no
882: 852 00011887 fe 08 effffff8be callf $8,_writed
883: 853 0001188E # writes(", subtest 5 (Piped Exit) - BAD FINAL ACC\n");
884: 854 0001188E .data 1
885: 855 00000ac3 * L323:
886: 856 00000ac3 * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Exit) - BAD FINAL ACC\12\0"
887: 8506970656420457869742920
888: 2D204241442046494E414C204
889: 143430A00
890: 857 00000aed * .text
891: 858 0001188E dd 8f00000ac3 pushl $L323
892: 859 00011894 fe 08 effffff8b1 callf $8,_writes
893: 860 0001189B # print_negf_data();
894: 861 0001189B fe 04 ef00000084 callf $4,_print_negf_data
895: 862 000118A2 # writes(", data index = ");
896: 863 000118A2 .data 1
897: 864 00000aed * L324:
898: 865 00000aed * 2C2020206461746120696E646 .ascii ", data index = \0"
899: 578203D2000
900: 866 00000aff * .text
901: 867 000118A2 dd 8f00000aed pushl $L324
902: 868 000118A8 fe 08 effffff89d callf $8,_writes
903: 869 000118AF # writed( index );
904: 870 000118AF dd effffff897 pushl _index
905: 871 000118B5 fe 08 effffff890 callf $8,_writed
906: 872 000118BC # writec('\n');
907: 873 000118BC dd 0a pushl $10
908: 874 000118BE fe 08 effffff887 callf $8,_writec
909: 875 000118C5 # writes(" ");
910: 876 000118C5 .data 1
911: 877 00000aff * L325:
912: 878 00000aff * 2020202020202020202020202 .ascii " \0"
913: 020202020202020202000
914: 879 00000b16 * .text
915: 880 000118C5 dd 8f00000aff pushl $L325
916: 881 000118CB fe 08 effffff87a callf $8,_writes
917: 882 000118D2 # writes("Acc expected = ");
918: 883 000118D2 .data 1
919: 884 00000b16 * L326:
920: 885 00000b16 * 4163632065787065637465642 .ascii "Acc expected = \0"
921: 03D2000
922: 886 00000b26 * .text
923: 887 000118D2 dd 8f00000b16 pushl $L326
924: 888 000118D8 fe 08 effffff86d callf $8,_writes
925: 889 000118DF # write32h( sgl_expected );
926: 890 000118DF dd effffff867 pushl _sgl_expected
927: 891 000118E5 fe 08 effffff860 callf $8,_write32h
928: 892 000118EC # writec('\n');
929: 893 000118EC dd 0a pushl $10
930: 894 000118EE fe 08 effffff857 callf $8,_writec
931: 895 000118F5 # }
932: 896 000118F5 # if( halt_flg )
933: 897 000118F5 L319:
934: 898 000118F5 5d effffff851 tstl _halt_flg
935: 899 000118FB 31 09 jeql L327
936: 900 000118FD # negf_er_halt( BAD_ACC_HLT ); /* halt on the error */
937: 901 000118FD dd 01 pushl $1
938: 902 000118FF fe 08 ef0000005c callf $8,_negf_er_halt
939: 903 00011906 # if( loop_on_err ) {
940: 904 00011906 L327:
941: 905 00011906 5d effffff840 tstl _loop_on_err
942: 906 0001190C 31 0a jeql L328
943: 907 0001190E # force_loop = TRUE; /* set the force loop flag */
944: 908 0001190E 0d 01 effffff837 movl $1,_force_loop
945: 909 00011915 # asm("brw _negf_5_lp1");; /* and loop on the error */
946: 910 00011915 13 fef8 brw _negf_5_lp1
947: 911 00011918 # } /* end of loop on error */
948: 912 00011918 # } /* end of compare error */
949: 913 00011918 L328:
950: 914 00011918 # } /* end of WHILE loop */
951: 915 00011918 L318:
952: 916 00011918 L314:
953: 917 00011918 6d effffff82e incl _index
954: 918 0001191E 13 feb3 jbr L316
955: 919 00011921 L315:
956: 920 00011921 # } /* end of subtest 5 */
957: 921 00011921 40 ret#2
958: 922 00011922 .set L310,0x0
959: 923 00011922 L312:
960: 924 00011922 13 fe9c jbr L313
961: 925 00011925 .data
962: 926 000008c8 * .text
963: 927 00011925 00 .align 1
964: 928 00011926 .globl _print_negf_data
965: 929 00011926 _print_negf_data:
966: 930 00011926 0000 .word L329
967: 931 00011928 #
968: 932 00011928 #
969: 933 00011928 #
970: 934 00011928 # /**************************************************************************
971: 935 00011928 # *
972: 936 00011928 # * PRINT THE DATA AND STORE RESULTS
973: 937 00011928 # *
974: 938 00011928 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx
975: 939 00011928 # * expected = xxxxxxxx
976: 940 00011928 # **************************************************************************/
977: 941 00011928 # print_negf_data()
978: 942 00011928 # {
979: 943 00011928 11 35 jbr L331
980: 944 0001192A L332:
981: 945 0001192A # writes("initial Acc = ");
982: 946 0001192A .data 1
983: 947 00000b26 * L333:
984: 948 00000b26 * 696E697469616C20416363203 .ascii "initial Acc = \0"
985: D2000
986: 949 00000b35 * .text
987: 950 0001192A dd 8f00000b26 pushl $L333
988: 951 00011930 fe 08 effffff815 callf $8,_writes
989: 952 00011937 # write32h( sgl_ld_acc );
990: 953 00011937 dd effffff80f pushl _sgl_ld_acc
991: 954 0001193D fe 08 effffff808 callf $8,_write32h
992: 955 00011944 # writes(", final Acc = ");
993: 956 00011944 .data 1
994: 957 00000b35 * L334:
995: 958 00000b35 * 2C202066696E616C204163632 .ascii ", final Acc = \0"
996: 03D2000
997: 959 00000b45 * .text
998: 960 00011944 dd 8f00000b35 pushl $L334
999: 961 0001194A fe 08 effffff7fb callf $8,_writes
1000: 962 00011951 # write32h( sgl_st_acc );
1001: 963 00011951 dd effffff7f5 pushl _sgl_st_acc
1002: 964 00011957 fe 08 effffff7ee callf $8,_write32h
1003: 965 0001195E # }
1004: 966 0001195E 40 ret#2
1005: 967 0001195F .set L329,0x0
1006: 968 0001195F L331:
1007: 969 0001195F 11 c9 jbr L332
1008: 970 00011961 .data
1009: 971 000008c8 * .text
1010: 972 00011961 00 .align 1
1011: 973 00011962 .globl _negf_er_halt
1012: 974 00011962 _negf_er_halt:
1013: 975 00011962 0000 .word L335
1014: 976 00011964 #
1015: 977 00011964 #
1016: 978 00011964 #
1017: 979 00011964 # /**************************************************************************
1018: 980 00011964 # *
1019: 981 00011964 # * HALT ON ERROR ROUTINE
1020: 982 00011964 # *
1021: 983 00011964 # **************************************************************************/
1022: 984 00011964 # negf_er_halt( halt_code )
1023: 985 00011964 # int halt_code;
1024: 986 00011964 # {
1025: 987 00011964 13 00a8 jbr L337
1026: 988 00011967 L338:
1027: 989 00011967 # sgl_dummy1 = halt_code; /* get the error type */
1028: 990 00011967 0d ad04 effffff7dd movl 4(fp),_sgl_dummy1
1029: 991 0001196F # asm("movl _test_no,r0"); /* r0 = test number */
1030: 992 0001196F 0d effffff7d7 50 movl _test_no,r0
1031: 993 00011976 # asm("movl _subtest,r1"); /* r1 = subtest number */
1032: 994 00011976 0d effffff7d0 51 movl _subtest,r1
1033: 995 0001197D # asm("movl _sgl_dummy1,r2"); /* r2 = error code */
1034: 996 0001197D 0d effffff7c9 52 movl _sgl_dummy1,r2
1035: 997 00011984 # asm("movl _cycle,r3"); /* r3 = cycle count */
1036: 998 00011984 0d effffff7c2 53 movl _cycle,r3
1037: 999 0001198B # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */
1038: 1000 0001198B 0d effffff7bb 54 movl _sgl_ld_acc,r4
1039: 1001 00011992 # asm("movl _sgl_value_1,r5"); /* r5 = data loaded */
1040: 1002 00011992 0d effffff7b4 55 movl _sgl_value_1,r5
1041: 1003 00011999 # if( halt_code == BAD_ACC_HLT ) {
1042: 1004 00011999 1d ad04 01 cmpl 4(fp),$1
1043: 1005 0001199D 21 10 jneq L339
1044: 1006 0001199F # asm("movl _sgl_st_acc,r6"); /* r6 = data stored */
1045: 1007 0001199F 0d effffff7a7 56 movl _sgl_st_acc,r6
1046: 1008 000119A6 # asm("movl _sgl_expected,r7"); /* r7 = data expected */
1047: 1009 000119A6 0d effffff7a0 57 movl _sgl_expected,r7
1048: 1010 000119AD # } else
1049: 1011 000119AD 11 5e jbr L340
1050: 1012 000119AF L339:
1051: 1013 000119AF # if( halt_code == BAD_REG_HLT ) {
1052: 1014 000119AF 1d ad04 02 cmpl 4(fp),$2
1053: 1015 000119B3 21 3d jneq L341
1054: 1016 000119B5 # sgl_dummy1 = load_regs[index2];
1055: 1017 000119B5 0d effffff791 50 movl _index2,r0
1056: 1018 000119BC 0d 40effffff789 movl _load_regs[r0],_sgl_dummy1
1057: effffff784
1058: 1019 000119C8 # sgl_dummy2 = store_regs[index2];
1059: 1020 000119C8 0d effffff77e 50 movl _index2,r0
1060: 1021 000119CF 0d 40effffff776 movl _store_regs[r0],_sgl_dummy2
1061: effffff771
1062: 1022 000119DB # asm("movl _index2,r6"); /* r6 = bad register # */
1063: 1023 000119DB 0d effffff76b 56 movl _index2,r6
1064: 1024 000119E2 # asm("movl _sgl_dummy1,r7"); /* r7 = actual value */
1065: 1025 000119E2 0d effffff764 57 movl _sgl_dummy1,r7
1066: 1026 000119E9 # asm("movl _sgl_dummy2,r8"); /* r8 = expected value */
1067: 1027 000119E9 0d effffff75d 58 movl _sgl_dummy2,r8
1068: 1028 000119F0 # } else
1069: 1029 000119F0 11 1b jbr L342
1070: 1030 000119F2 L341:
1071: 1031 000119F2 # if( halt_code == BAD_PSL_HLT ) {
1072: 1032 000119F2 1d ad04 03 cmpl 4(fp),$3
1073: 1033 000119F6 21 15 jneq L343
1074: 1034 000119F8 # asm("movl _init_psl,r6"); /* r6 = initial PSL */
1075: 1035 000119F8 0d effffff74e 56 movl _init_psl,r6
1076: 1036 000119FF # asm("movl _psl_val,r7"); /* r7 = final PSL */
1077: 1037 000119FF 0d effffff747 57 movl _psl_val,r7
1078: 1038 00011A06 # asm("movl _exp_psl,r8"); /* r8 = expected PSL */
1079: 1039 00011A06 0d effffff740 58 movl _exp_psl,r8
1080: 1040 00011A0D # };
1081: 1041 00011A0D L343:
1082: 1042 00011A0D L342:
1083: 1043 00011A0D L340:
1084: 1044 00011A0D # asm("halt"); /* HALT ... */
1085: 1045 00011A0D 00 halt
1086: 1046 00011A0E # }
1087: 1047 00011A0E 40 ret#2
1088: 1048 00011A0F .set L335,0x0
1089: 1049 00011A0F L337:
1090: 1050 00011A0F 13 ff55 jbr L338
1091: 1051 00011A12 .data
1092: 1051 00022B5E .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.