![[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.