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