![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tstf.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 tstf.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 000009a4 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _tstf ! 6: 6 00000000 _tstf: ! 7: 7 00011A14 0000 .word L215 ! 8: 8 00011A16 # ! 9: 9 00011A16 # #include "fpp_defs.h" ! 10: 10 00011A16 # ! 11: 11 00011A16 # ! 12: 12 00011A16 # /***************************************************************************** ! 13: 13 00011A16 # * ! 14: 14 00011A16 # * TSTF - SINGLE PRECISION FLOATING POINT TEST ACC. TEST ! 15: 15 00011A16 # * ! 16: 16 00011A16 # *****************************************************************************/ ! 17: 17 00011A16 # tstf() ! 18: 18 00011A16 # { ! 19: 19 00011A16 11 50 jbr L217 ! 20: 20 00011A18 L218: ! 21: 21 00011A18 # asm(".globl _tstf_t"); ! 22: 22 00011A18 .globl _tstf_t ! 23: 23 00011A18 # asm("_tstf_t:"); /* entry address */ ! 24: 24 00011A18 _tstf_t: ! 25: 25 00011A18 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 26: 26 00011A18 1d effffffff6 01 cmpl _cycle,$1 ! 27: 27 00011A1F 21 15 jneq L219 ! 28: 28 00011A21 5d efffffffed tstl _prt_hdrs ! 29: 29 00011A27 31 0d jeql L219 ! 30: 30 00011A29 # writes(" TSTF"); ! 31: 31 00011A29 .data 1 ! 32: 32 000009a4 * L221: ! 33: 33 000009a4 * 205453544600 .ascii " TSTF\0" ! 34: 34 000009aa * .text ! 35: 35 00011A29 dd 8f000009a4 pushl $L221 ! 36: 36 00011A2F fe 08 efffffffde callf $8,_writes ! 37: 37 00011A36 # tstf_1(); /* PSL flags test */ ! 38: 38 00011A36 L219: ! 39: 39 00011A36 fe 04 ef0000002d callf $4,_tstf_1 ! 40: 40 00011A3D # tstf_2(); /* register stability */ ! 41: 41 00011A3D fe 04 ef00000206 callf $4,_tstf_2 ! 42: 42 00011A44 # tstf_3(); /* accumulator stability */ ! 43: 43 00011A44 fe 04 ef000003fb callf $4,_tstf_3 ! 44: 44 00011A4B # if( !no_fpp_wcs ) { ! 45: 45 00011A4B 5d efffffffc3 tstl _no_fpp_wcs ! 46: 46 00011A51 21 0e jneq L225 ! 47: 47 00011A53 # tstf_4(); /* pipelined entry test */ ! 48: 48 00011A53 fe 04 ef0000052e callf $4,_tstf_4 ! 49: 49 00011A5A # tstf_5(); /* pipelined exit test */ ! 50: 50 00011A5A fe 04 ef0000070d callf $4,_tstf_5 ! 51: 51 00011A61 # }; ! 52: 52 00011A61 L225: ! 53: 53 00011A61 # asm("jmp *return"); /* return to the test monitor */ ! 54: 54 00011A61 71 ffffffffad jmp *return ! 55: 55 00011A67 # } ! 56: 56 00011A67 40 ret#2 ! 57: 57 00011A68 .set L215,0x0 ! 58: 58 00011A68 L217: ! 59: 59 00011A68 11 ae jbr L218 ! 60: 60 00011A6A .data ! 61: 61 000009a4 * .text ! 62: 62 00011A6A .align 1 ! 63: 63 00011A6A .globl _tstf_1 ! 64: 64 00011A6A _tstf_1: ! 65: 65 00011A6A 0000 .word L228 ! 66: 66 00011A6C # ! 67: 67 00011A6C # ! 68: 68 00011A6C # ! 69: 69 00011A6C # /************************************************************************ ! 70: 70 00011A6C # * ! 71: 71 00011A6C # * SUBTEST 1 - Check for PSL corruption ! 72: 72 00011A6C # * ! 73: 73 00011A6C # ************************************************************************/ ! 74: 74 00011A6C # tstf_1() ! 75: 75 00011A6C # { ! 76: 76 00011A6C 13 01d8 jbr L230 ! 77: 77 00011A6F L231: ! 78: 78 00011A6F # force_loop = FALSE; /* clear force_loop flg */ ! 79: 79 00011A6F 4d efffffff9f clrl _force_loop ! 80: 80 00011A75 # subtest = 1; ! 81: 81 00011A75 0d 01 efffffff98 movl $1,_subtest ! 82: 82 00011A7C # for( index = 0; index < max_tstf_1_index; index++ ) { ! 83: 83 00011A7C 4d efffffff92 clrl _index ! 84: 84 00011A82 L234: ! 85: 85 00011A82 1d efffffff8c efffffff87 cmpl _index,_max_tstf_1_index ! 86: 86 00011A8D 91 03 13 01b4 jgeq L233 ! 87: 87 00011A92 # sgl_ld_acc = tstf_1_data[index].ld; /* get value to load */ ! 88: 88 00011A92 0d efffffff7c 50 movl _index,r0 ! 89: 89 00011A99 48 03 50 50 shll $3,r0,r0 ! 90: 90 00011A9D 0d e000000000 efffffff6c movl _tstf_1_data(r0),_sgl_ld_acc ! 91: 91 00011AA8 # sgl_expected = tstf_1_data[index].exp; /* get expected flags*/ ! 92: 92 00011AA8 0d efffffff66 50 movl _index,r0 ! 93: 93 00011AAF 48 03 50 50 shll $3,r0,r0 ! 94: 94 00011AB3 0d e000000004 efffffff56 movl _tstf_1_data+4(r0),_sgl_expected ! 95: 95 00011ABE # for( status_index = 0; status_index < 3; status_index++ ) { ! 96: 96 00011ABE 4d efffffff50 clrl _status_index ! 97: 97 00011AC4 L237: ! 98: 98 00011AC4 1d efffffff4a 03 cmpl _status_index,$3 ! 99: 99 00011ACB 91 03 13 016d jgeq L236 ! 100: 100 00011AD0 # sgl_dummy1 = status_array[status_index]; /* status = +,-,0 */ ! 101: 101 00011AD0 0d efffffff3e 50 movl _status_index,r0 ! 102: 102 00011AD7 0d 40efffffff36 movl _status_array[r0],_sgl_dummy1 ! 103: efffffff31 ! 104: 103 00011AE3 # /* ! 105: 104 00011AE3 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 106: 105 00011AE3 # * The force loop flag is set after the first error. ! 107: 106 00011AE3 # */ ! 108: 107 00011AE3 # asm("ldf _sgl_ld_acc"); /* load the initial value */ ! 109: 108 00011AE3 06 efffffff2b ldf _sgl_ld_acc ! 110: 109 00011AE9 # asm("_tstf_1_lp1:"); ! 111: 110 00011AE9 _tstf_1_lp1: ! 112: 111 00011AE9 # asm("tstl _sgl_dummy1"); /* set the PSL status */ ! 113: 112 00011AE9 5d efffffff25 tstl _sgl_dummy1 ! 114: 113 00011AEF # asm("movpsl _init_psl"); /* save the initial PSL */ ! 115: 114 00011AEF cd efffffff1f movpsl _init_psl ! 116: 115 00011AF5 # asm("tstf"); /* test the accmulator */ ! 117: 116 00011AF5 56 tstf ! 118: 117 00011AF6 # asm("nop"); ! 119: 118 00011AF6 10 nop ! 120: 119 00011AF7 # asm("movpsl _psl_val"); /* save the final PSL */ ! 121: 120 00011AF7 cd efffffff17 movpsl _psl_val ! 122: 121 00011AFD # asm("stf _sgl_st_acc"); /* save the final Acc. */ ! 123: 122 00011AFD 26 efffffff11 stf _sgl_st_acc ! 124: 123 00011B03 # if( force_loop ) ! 125: 124 00011B03 5d efffffff0b tstl _force_loop ! 126: 125 00011B09 31 02 jeql L238 ! 127: 126 00011B0B # asm("brb _tstf_1_lp1");; /* loop on the error */ ! 128: 127 00011B0B 11 dc brb _tstf_1_lp1 ! 129: 128 00011B0D L238: ! 130: 129 00011B0D # /* ! 131: 130 00011B0D # * Now compare the final PSL to the initial PSL -they should be the same ! 132: 131 00011B0D # */ ! 133: 132 00011B0D # exp_psl = init_psl; /* get the initial PSL */ ! 134: 133 00011B0D 0d efffffff01 effffffefc movl _init_psl,_exp_psl ! 135: 134 00011B18 # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 136: 135 00011B18 ac 88f3 effffffef4 andl2 $-13,_exp_psl ! 137: 136 00011B20 # if( sgl_expected == ZERO ) ! 138: 137 00011B20 1d effffffeee 04 cmpl _sgl_expected,$4 ! 139: 138 00011B27 21 07 jneq L239 ! 140: 139 00011B29 # exp_psl |= PSL_Z; /* expect the ZERO bit set */ ! 141: 140 00011B29 8c 04 effffffee4 orl2 $4,_exp_psl ! 142: 141 00011B30 # if( sgl_expected == NEGATIVE ) ! 143: 142 00011B30 L239: ! 144: 143 00011B30 1d effffffede 08 cmpl _sgl_expected,$8 ! 145: 144 00011B37 21 07 jneq L240 ! 146: 145 00011B39 # exp_psl |= PSL_N; /* expect the NEG bit set */ ! 147: 146 00011B39 8c 08 effffffed4 orl2 $8,_exp_psl ! 148: 147 00011B40 # if( psl_val != exp_psl ) { ! 149: 148 00011B40 L240: ! 150: 149 00011B40 1d effffffece effffffec9 cmpl _psl_val,_exp_psl ! 151: 150 00011B4B 21 03 13 00e4 jeql L241 ! 152: 151 00011B50 # errcnt++; /* bump the error count */ ! 153: 152 00011B50 6d effffffebe incl _errcnt ! 154: 153 00011B56 # if( prt_error ) { ! 155: 154 00011B56 5d effffffeb8 tstl _prt_error ! 156: 155 00011B5C 21 03 13 00b0 jeql L242 ! 157: 156 00011B61 # writes(" \n"); /* start new print line */ ! 158: 157 00011B61 .data 1 ! 159: 158 000009aa * L243: ! 160: 159 000009aa * 200A00 .ascii " \12\0" ! 161: 160 000009ad * .text ! 162: 161 00011B61 dd 8f000009aa pushl $L243 ! 163: 162 00011B67 fe 08 effffffea6 callf $8,_writes ! 164: 163 00011B6E # writes("cycle: "); ! 165: 164 00011B6E .data 1 ! 166: 165 000009ad * L244: ! 167: 166 000009ad * 6379636C653A2000 .ascii "cycle: \0" ! 168: 167 000009b5 * .text ! 169: 168 00011B6E dd 8f000009ad pushl $L244 ! 170: 169 00011B74 fe 08 effffffe99 callf $8,_writes ! 171: 170 00011B7B # writed( cycle ); ! 172: 171 00011B7B dd effffffe93 pushl _cycle ! 173: 172 00011B81 fe 08 effffffe8c callf $8,_writed ! 174: 173 00011B88 # writes(" TSTF test "); ! 175: 174 00011B88 .data 1 ! 176: 175 000009b5 * L246: ! 177: 176 000009b5 * 2020545354462074657374200 .ascii " TSTF test \0" ! 178: 0 ! 179: 177 000009c2 * .text ! 180: 178 00011B88 dd 8f000009b5 pushl $L246 ! 181: 179 00011B8E fe 08 effffffe7f callf $8,_writes ! 182: 180 00011B95 # writed( test_no ); ! 183: 181 00011B95 dd effffffe79 pushl _test_no ! 184: 182 00011B9B fe 08 effffffe72 callf $8,_writed ! 185: 183 00011BA2 # writes( ! 186: 184 00011BA2 # ", subtest 1 - BAD FINAL PSL\n"); ! 187: 185 00011BA2 .data 1 ! 188: 186 000009c2 * L247: ! 189: 187 000009c2 * 2C20737562746573742031202 .ascii ", subtest 1 - BAD FINAL PSL\12\0" ! 190: D204241442046494E414C2050 ! 191: 534C0A00 ! 192: 188 000009df * .text ! 193: 189 00011BA2 dd 8f000009c2 pushl $L247 ! 194: 190 00011BA8 fe 08 effffffe65 callf $8,_writes ! 195: 191 00011BAF # print_tstf_data(); /* print the operands */ ! 196: 192 00011BAF fe 04 ef000006f8 callf $4,_print_tstf_data ! 197: 193 00011BB6 # writes("initial PSL = "); ! 198: 194 00011BB6 .data 1 ! 199: 195 000009df * L249: ! 200: 196 000009df * 696E697469616C2050534C203 .ascii "initial PSL = \0" ! 201: D2000 ! 202: 197 000009ee * .text ! 203: 198 00011BB6 dd 8f000009df pushl $L249 ! 204: 199 00011BBC fe 08 effffffe51 callf $8,_writes ! 205: 200 00011BC3 # write32h( init_psl ); ! 206: 201 00011BC3 dd effffffe4b pushl _init_psl ! 207: 202 00011BC9 fe 08 effffffe44 callf $8,_write32h ! 208: 203 00011BD0 # writes(", final PSL = "); ! 209: 204 00011BD0 .data 1 ! 210: 205 000009ee * L251: ! 211: 206 000009ee * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 212: 03D2000 ! 213: 207 000009fe * .text ! 214: 208 00011BD0 dd 8f000009ee pushl $L251 ! 215: 209 00011BD6 fe 08 effffffe37 callf $8,_writes ! 216: 210 00011BDD # write32h( psl_val ); ! 217: 211 00011BDD dd effffffe31 pushl _psl_val ! 218: 212 00011BE3 fe 08 effffffe2a callf $8,_write32h ! 219: 213 00011BEA # writes(", expected PSL = "); ! 220: 214 00011BEA .data 1 ! 221: 215 000009fe * L252: ! 222: 216 000009fe * 2C20657870656374656420505 .ascii ", expected PSL = \0" ! 223: 34C203D2000 ! 224: 217 00000a10 * .text ! 225: 218 00011BEA dd 8f000009fe pushl $L252 ! 226: 219 00011BF0 fe 08 effffffe1d callf $8,_writes ! 227: 220 00011BF7 # write32h( exp_psl ); ! 228: 221 00011BF7 dd effffffe17 pushl _exp_psl ! 229: 222 00011BFD fe 08 effffffe10 callf $8,_write32h ! 230: 223 00011C04 # writes("\n"); ! 231: 224 00011C04 .data 1 ! 232: 225 00000a10 * L253: ! 233: 226 00000a10 * 0A00 .ascii "\12\0" ! 234: 227 00000a12 * .text ! 235: 228 00011C04 dd 8f00000a10 pushl $L253 ! 236: 229 00011C0A fe 08 effffffe03 callf $8,_writes ! 237: 230 00011C11 # } ! 238: 231 00011C11 # if( halt_flg ) ! 239: 232 00011C11 L242: ! 240: 233 00011C11 5d effffffdfd tstl _halt_flg ! 241: 234 00011C17 31 09 jeql L254 ! 242: 235 00011C19 # tstf_er_halt( BAD_PSL_HLT ); /* halt on error */ ! 243: 236 00011C19 dd 03 pushl $3 ! 244: 237 00011C1B fe 08 ef000006ea callf $8,_tstf_er_halt ! 245: 238 00011C22 # if( loop_on_err ) { ! 246: 239 00011C22 L254: ! 247: 240 00011C22 5d effffffdec tstl _loop_on_err ! 248: 241 00011C28 31 0a jeql L256 ! 249: 242 00011C2A # force_loop = TRUE; /* set force loop flag */ ! 250: 243 00011C2A 0d 01 effffffde3 movl $1,_force_loop ! 251: 244 00011C31 # asm("brw _tstf_1_lp1"); /* loop on the error */ ! 252: 245 00011C31 13 feb5 brw _tstf_1_lp1 ! 253: 246 00011C34 # } /* end of loop on error */ ! 254: 247 00011C34 # } /* end of PSL corruption error */ ! 255: 248 00011C34 L256: ! 256: 249 00011C34 # } /* end of initial status WHILE loop */ ! 257: 250 00011C34 L241: ! 258: 251 00011C34 L235: ! 259: 252 00011C34 6d effffffdda incl _status_index ! 260: 253 00011C3A 13 fe87 jbr L237 ! 261: 254 00011C3D L236: ! 262: 255 00011C3D # } /* end of data pattern WHILE loop */ ! 263: 256 00011C3D L232: ! 264: 257 00011C3D 6d effffffdd1 incl _index ! 265: 258 00011C43 13 fe3c jbr L234 ! 266: 259 00011C46 L233: ! 267: 260 00011C46 # } /* end of subtest 1 */ ! 268: 261 00011C46 40 ret#2 ! 269: 262 00011C47 .set L228,0x0 ! 270: 263 00011C47 L230: ! 271: 264 00011C47 13 fe25 jbr L231 ! 272: 265 00011C4A .data ! 273: 266 000009a4 * .text ! 274: 267 00011C4A .align 1 ! 275: 268 00011C4A .globl _tstf_2 ! 276: 269 00011C4A _tstf_2: ! 277: 270 00011C4A 0000 .word L257 ! 278: 271 00011C4C # ! 279: 272 00011C4C # ! 280: 273 00011C4C # ! 281: 274 00011C4C # /************************************************************************ ! 282: 275 00011C4C # * ! 283: 276 00011C4C # * SUBTEST 2 - Check for register corruption ! 284: 277 00011C4C # * ! 285: 278 00011C4C # ************************************************************************/ ! 286: 279 00011C4C # tstf_2() ! 287: 280 00011C4C # { ! 288: 281 00011C4C 13 01f3 jbr L259 ! 289: 282 00011C4F L260: ! 290: 283 00011C4F # force_loop = FALSE; /* clear force_loop flg */ ! 291: 284 00011C4F 4d effffffdbf clrl _force_loop ! 292: 285 00011C55 # subtest = 2; ! 293: 286 00011C55 0d 02 effffffdb8 movl $2,_subtest ! 294: 287 00011C5C # fill_reg_buf( load_regs ); /* get patterns for regs */ ! 295: 288 00011C5C dd 8f00000000 pushl $_load_regs ! 296: 289 00011C62 fe 08 effffffdab callf $8,_fill_reg_buf ! 297: 290 00011C69 # for( index = 0; index < max_tstf_1_index; index++ ) { ! 298: 291 00011C69 4d effffffda5 clrl _index ! 299: 292 00011C6F L264: ! 300: 293 00011C6F 1d effffffd9f effffffd9a cmpl _index,_max_tstf_1_index ! 301: 294 00011C7A 91 03 13 01c2 jgeq L263 ! 302: 295 00011C7F # sgl_ld_acc = tstf_1_data[index].ld; /* get value to load */ ! 303: 296 00011C7F 0d effffffd8f 50 movl _index,r0 ! 304: 297 00011C86 48 03 50 50 shll $3,r0,r0 ! 305: 298 00011C8A 0d e000000000 effffffd7f movl _tstf_1_data(r0),_sgl_ld_acc ! 306: 299 00011C95 # sgl_expected = tstf_1_data[index].exp; /* get expected flags*/ ! 307: 300 00011C95 0d effffffd79 50 movl _index,r0 ! 308: 301 00011C9C 48 03 50 50 shll $3,r0,r0 ! 309: 302 00011CA0 0d e000000004 effffffd69 movl _tstf_1_data+4(r0),_sgl_expected ! 310: 303 00011CAB # for( status_index = 0; status_index < 3; status_index++ ) { ! 311: 304 00011CAB 4d effffffd63 clrl _status_index ! 312: 305 00011CB1 L267: ! 313: 306 00011CB1 1d effffffd5d 03 cmpl _status_index,$3 ! 314: 307 00011CB8 91 03 13 017b jgeq L266 ! 315: 308 00011CBD # sgl_dummy1 = status_array[status_index]; /* status = +,-,0 */ ! 316: 309 00011CBD 0d effffffd51 50 movl _status_index,r0 ! 317: 310 00011CC4 0d 40effffffd49 movl _status_array[r0],_sgl_dummy1 ! 318: effffffd44 ! 319: 311 00011CD0 # /* ! 320: 312 00011CD0 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 321: 313 00011CD0 # * The force loop flag is set after the first error. ! 322: 314 00011CD0 # */ ! 323: 315 00011CD0 # asm("_tstf_2_lp1:"); ! 324: 316 00011CD0 _tstf_2_lp1: ! 325: 317 00011CD0 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */ ! 326: 318 00011CD0 ab 891fff effffffd3b loadr $0x1fff,_load_regs ! 327: 319 00011CD9 # asm("ldf _sgl_ld_acc"); /* load the Acc. */ ! 328: 320 00011CD9 06 effffffd35 ldf _sgl_ld_acc ! 329: 321 00011CDF # asm("nop"); ! 330: 322 00011CDF 10 nop ! 331: 323 00011CE0 # asm("tstf"); /* test the acc. */ ! 332: 324 00011CE0 56 tstf ! 333: 325 00011CE1 # asm("nop"); ! 334: 326 00011CE1 10 nop ! 335: 327 00011CE2 # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 336: 328 00011CE2 bb 891fff effffffd29 storer $0x1fff,_store_regs ! 337: 329 00011CEB # asm("stf _sgl_st_acc"); /* save the acc. */ ! 338: 330 00011CEB 26 effffffd23 stf _sgl_st_acc ! 339: 331 00011CF1 # if( force_loop ) ! 340: 332 00011CF1 5d effffffd1d tstl _force_loop ! 341: 333 00011CF7 31 02 jeql L268 ! 342: 334 00011CF9 # asm("brb _tstf_2_lp1");; /* loop on the error */ ! 343: 335 00011CF9 11 d5 brb _tstf_2_lp1 ! 344: 336 00011CFB L268: ! 345: 337 00011CFB # /* ! 346: 338 00011CFB # * Now compare the stored register values to those that were loaded ! 347: 339 00011CFB # */ ! 348: 340 00011CFB # index2 = 0; ! 349: 341 00011CFB 4d effffffd13 clrl _index2 ! 350: 342 00011D01 # while( (load_regs[index2] == store_regs[index2]) && ! 351: 343 00011D01 # (index2 < 13) ) ! 352: 344 00011D01 L269: ! 353: 345 00011D01 0d effffffd0d 50 movl _index2,r0 ! 354: 346 00011D08 0d effffffd06 51 movl _index2,r1 ! 355: 347 00011D0F 1d 40effffffcfe cmpl _load_regs[r0],_store_regs[r1] ! 356: 41effffffcf8 ! 357: 348 00011D1C 21 11 jneq L270 ! 358: 349 00011D1E 1d effffffcf0 0d cmpl _index2,$13 ! 359: 350 00011D25 81 08 jgeq L270 ! 360: 351 00011D27 # index2++; /* check reg values */ ! 361: 352 00011D27 6d effffffce7 incl _index2 ! 362: 353 00011D2D 11 d2 jbr L269 ! 363: 354 00011D2F L270: ! 364: 355 00011D2F # if( index2 < 13 ) { /* error if index2 < 13 */ ! 365: 356 00011D2F 1d effffffcdf 0d cmpl _index2,$13 ! 366: 357 00011D36 91 03 13 00f4 jgeq L271 ! 367: 358 00011D3B # errcnt++; /* bump the error count */ ! 368: 359 00011D3B 6d effffffcd3 incl _errcnt ! 369: 360 00011D41 # if( prt_error ) { ! 370: 361 00011D41 5d effffffccd tstl _prt_error ! 371: 362 00011D47 21 03 13 00c0 jeql L272 ! 372: 363 00011D4C # writes(" \n"); /* start a new print line */ ! 373: 364 00011D4C .data 1 ! 374: 365 00000a12 * L273: ! 375: 366 00000a12 * 200A00 .ascii " \12\0" ! 376: 367 00000a15 * .text ! 377: 368 00011D4C dd 8f00000a12 pushl $L273 ! 378: 369 00011D52 fe 08 effffffcbb callf $8,_writes ! 379: 370 00011D59 # writes("cycle: "); ! 380: 371 00011D59 .data 1 ! 381: 372 00000a15 * L274: ! 382: 373 00000a15 * 6379636C653A2000 .ascii "cycle: \0" ! 383: 374 00000a1d * .text ! 384: 375 00011D59 dd 8f00000a15 pushl $L274 ! 385: 376 00011D5F fe 08 effffffcae callf $8,_writes ! 386: 377 00011D66 # writed( cycle ); ! 387: 378 00011D66 dd effffffca8 pushl _cycle ! 388: 379 00011D6C fe 08 effffffca1 callf $8,_writed ! 389: 380 00011D73 # writes(" TSTF test "); ! 390: 381 00011D73 .data 1 ! 391: 382 00000a1d * L275: ! 392: 383 00000a1d * 2020545354462074657374200 .ascii " TSTF test \0" ! 393: 0 ! 394: 384 00000a2a * .text ! 395: 385 00011D73 dd 8f00000a1d pushl $L275 ! 396: 386 00011D79 fe 08 effffffc94 callf $8,_writes ! 397: 387 00011D80 # writed( test_no ); ! 398: 388 00011D80 dd effffffc8e pushl _test_no ! 399: 389 00011D86 fe 08 effffffc87 callf $8,_writed ! 400: 390 00011D8D # writes(", subtest 2 - A REGISTER WAS MODIFIED\n"); ! 401: 391 00011D8D .data 1 ! 402: 392 00000a2a * L276: ! 403: 393 00000a2a * 2C20737562746573742032202 .ascii ", subtest 2 - A REGISTER WAS MODIFIED\12\0" ! 404: D204120524547495354455220 ! 405: 574153204D4F4449464945440 ! 406: A00 ! 407: 394 00000a51 * .text ! 408: 395 00011D8D dd 8f00000a2a pushl $L276 ! 409: 396 00011D93 fe 08 effffffc7a callf $8,_writes ! 410: 397 00011D9A # print_tstf_data(); /* print the operands */ ! 411: 398 00011D9A fe 04 ef0000050d callf $4,_print_tstf_data ! 412: 399 00011DA1 # writes("register "); /* print the information */ ! 413: 400 00011DA1 .data 1 ! 414: 401 00000a51 * L277: ! 415: 402 00000a51 * 72656769737465722000 .ascii "register \0" ! 416: 403 00000a5b * .text ! 417: 404 00011DA1 dd 8f00000a51 pushl $L277 ! 418: 405 00011DA7 fe 08 effffffc66 callf $8,_writes ! 419: 406 00011DAE # writed( index2 ); /* about the corrupted */ ! 420: 407 00011DAE dd effffffc60 pushl _index2 ! 421: 408 00011DB4 fe 08 effffffc59 callf $8,_writed ! 422: 409 00011DBB # writes(" = "); /* register */ ! 423: 410 00011DBB .data 1 ! 424: 411 00000a5b * L278: ! 425: 412 00000a5b * 203D2000 .ascii " = \0" ! 426: 413 00000a5f * .text ! 427: 414 00011DBB dd 8f00000a5b pushl $L278 ! 428: 415 00011DC1 fe 08 effffffc4c callf $8,_writes ! 429: 416 00011DC8 # write32h( store_regs[index2] ); ! 430: 417 00011DC8 0d effffffc46 50 movl _index2,r0 ! 431: 418 00011DCF dd 40effffffc3e pushl _store_regs[r0] ! 432: 419 00011DD6 fe 08 effffffc37 callf $8,_write32h ! 433: 420 00011DDD # writes(", should be = "); ! 434: 421 00011DDD .data 1 ! 435: 422 00000a5f * L279: ! 436: 423 00000a5f * 2C202073686F756C642062652 .ascii ", should be = \0" ! 437: 03D2000 ! 438: 424 00000a6f * .text ! 439: 425 00011DDD dd 8f00000a5f pushl $L279 ! 440: 426 00011DE3 fe 08 effffffc2a callf $8,_writes ! 441: 427 00011DEA # write32h( load_regs[index2] ); ! 442: 428 00011DEA 0d effffffc24 50 movl _index2,r0 ! 443: 429 00011DF1 dd 40effffffc1c pushl _load_regs[r0] ! 444: 430 00011DF8 fe 08 effffffc15 callf $8,_write32h ! 445: 431 00011DFF # writes("\n"); ! 446: 432 00011DFF .data 1 ! 447: 433 00000a6f * L280: ! 448: 434 00000a6f * 0A00 .ascii "\12\0" ! 449: 435 00000a71 * .text ! 450: 436 00011DFF dd 8f00000a6f pushl $L280 ! 451: 437 00011E05 fe 08 effffffc08 callf $8,_writes ! 452: 438 00011E0C # } ! 453: 439 00011E0C # if( halt_flg ) ! 454: 440 00011E0C L272: ! 455: 441 00011E0C 5d effffffc02 tstl _halt_flg ! 456: 442 00011E12 31 09 jeql L281 ! 457: 443 00011E14 # tstf_er_halt( BAD_REG_HLT ); /* halt on error */ ! 458: 444 00011E14 dd 02 pushl $2 ! 459: 445 00011E16 fe 08 ef000004ef callf $8,_tstf_er_halt ! 460: 446 00011E1D # if( loop_on_err ) { ! 461: 447 00011E1D L281: ! 462: 448 00011E1D 5d effffffbf1 tstl _loop_on_err ! 463: 449 00011E23 31 0a jeql L282 ! 464: 450 00011E25 # force_loop = TRUE; /* set force loop flag */ ! 465: 451 00011E25 0d 01 effffffbe8 movl $1,_force_loop ! 466: 452 00011E2C # asm("brw _tstf_2_lp1"); /* loop on the error */ ! 467: 453 00011E2C 13 fea1 brw _tstf_2_lp1 ! 468: 454 00011E2F # } /* end of loop on error */ ! 469: 455 00011E2F # } /* end of register corruption error */ ! 470: 456 00011E2F L282: ! 471: 457 00011E2F # } /* end of initial PSL WHILE loop */ ! 472: 458 00011E2F L271: ! 473: 459 00011E2F L265: ! 474: 460 00011E2F 6d effffffbdf incl _status_index ! 475: 461 00011E35 13 fe79 jbr L267 ! 476: 462 00011E38 L266: ! 477: 463 00011E38 # } /* end of tstf data WHILE loop */ ! 478: 464 00011E38 L262: ! 479: 465 00011E38 6d effffffbd6 incl _index ! 480: 466 00011E3E 13 fe2e jbr L264 ! 481: 467 00011E41 L263: ! 482: 468 00011E41 # } /* end of subtest 2 */ ! 483: 469 00011E41 40 ret#2 ! 484: 470 00011E42 .set L257,0x0 ! 485: 471 00011E42 L259: ! 486: 472 00011E42 13 fe0a jbr L260 ! 487: 473 00011E45 .data ! 488: 474 000009a4 * .text ! 489: 475 00011E45 00 .align 1 ! 490: 476 00011E46 .globl _tstf_3 ! 491: 477 00011E46 _tstf_3: ! 492: 478 00011E46 0000 .word L283 ! 493: 479 00011E48 # ! 494: 480 00011E48 # ! 495: 481 00011E48 # ! 496: 482 00011E48 # ! 497: 483 00011E48 # /************************************************************************ ! 498: 484 00011E48 # * ! 499: 485 00011E48 # * SUBTEST 3 - Check for accumulator corruption ! 500: 486 00011E48 # * ! 501: 487 00011E48 # ************************************************************************/ ! 502: 488 00011E48 # tstf_3() ! 503: 489 00011E48 # { ! 504: 490 00011E48 13 0139 jbr L285 ! 505: 491 00011E4B L286: ! 506: 492 00011E4B # force_loop = FALSE; /* clear force_loop flg */ ! 507: 493 00011E4B 4d effffffbc3 clrl _force_loop ! 508: 494 00011E51 # subtest = 3; ! 509: 495 00011E51 0d 03 effffffbbc movl $3,_subtest ! 510: 496 00011E58 # for( index = 0; index < max_tstf_1_index; index++ ) { ! 511: 497 00011E58 4d effffffbb6 clrl _index ! 512: 498 00011E5E L289: ! 513: 499 00011E5E 1d effffffbb0 effffffbab cmpl _index,_max_tstf_1_index ! 514: 500 00011E69 91 03 13 0115 jgeq L288 ! 515: 501 00011E6E # sgl_ld_acc = tstf_1_data[index].ld; /* get value to load */ ! 516: 502 00011E6E 0d effffffba0 50 movl _index,r0 ! 517: 503 00011E75 48 03 50 50 shll $3,r0,r0 ! 518: 504 00011E79 0d e000000000 effffffb90 movl _tstf_1_data(r0),_sgl_ld_acc ! 519: 505 00011E84 # if( sgl_ld_acc & 0x7f800000 ) ! 520: 506 00011E84 3d 8f7f800000 effffffb85 bitl $2139095040,_sgl_ld_acc ! 521: 507 00011E8F 31 0d jeql L290 ! 522: 508 00011E91 # sgl_expected = sgl_ld_acc; /* the Acc should not change */ ! 523: 509 00011E91 0d effffffb7d effffffb78 movl _sgl_ld_acc,_sgl_expected ! 524: 510 00011E9C # else ! 525: 511 00011E9C 11 06 jbr L291 ! 526: 512 00011E9E L290: ! 527: 513 00011E9E # sgl_expected = 0; /* expect a '0' final Acc */ ! 528: 514 00011E9E 4d effffffb70 clrl _sgl_expected ! 529: 515 00011EA4 L291: ! 530: 516 00011EA4 # /* ! 531: 517 00011EA4 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 532: 518 00011EA4 # * The force loop flag is set after the first error. ! 533: 519 00011EA4 # */ ! 534: 520 00011EA4 # asm("_tstf_3_lp1:"); ! 535: 521 00011EA4 _tstf_3_lp1: ! 536: 522 00011EA4 # asm("ldf _sgl_ld_acc"); ! 537: 523 00011EA4 06 effffffb6a ldf _sgl_ld_acc ! 538: 524 00011EAA # asm("nop"); ! 539: 525 00011EAA 10 nop ! 540: 526 00011EAB # asm("tstf"); /* test the accumulator */ ! 541: 527 00011EAB 56 tstf ! 542: 528 00011EAC # asm("nop"); ! 543: 529 00011EAC 10 nop ! 544: 530 00011EAD # asm("stf _sgl_st_acc"); /* save the accumulator */ ! 545: 531 00011EAD 26 effffffb61 stf _sgl_st_acc ! 546: 532 00011EB3 # if( force_loop ) ! 547: 533 00011EB3 5d effffffb5b tstl _force_loop ! 548: 534 00011EB9 31 02 jeql L292 ! 549: 535 00011EBB # asm("brb _tstf_3_lp1");; /* loop on the error */ ! 550: 536 00011EBB 11 e7 brb _tstf_3_lp1 ! 551: 537 00011EBD L292: ! 552: 538 00011EBD # /* ! 553: 539 00011EBD # * Now compare the stored accumulator to the value that was loaded ! 554: 540 00011EBD # */ ! 555: 541 00011EBD # if( sgl_st_acc != sgl_expected ) { /* Acc corrupted? */ ! 556: 542 00011EBD 1d effffffb51 effffffb4c cmpl _sgl_st_acc,_sgl_expected ! 557: 543 00011EC8 21 03 13 00ad jeql L293 ! 558: 544 00011ECD # errcnt++; /* bump error count */ ! 559: 545 00011ECD 6d effffffb41 incl _errcnt ! 560: 546 00011ED3 # if( prt_error ) { ! 561: 547 00011ED3 5d effffffb3b tstl _prt_error ! 562: 548 00011ED9 31 7c jeql L294 ! 563: 549 00011EDB # writes(" \n"); /* start a new line */ ! 564: 550 00011EDB .data 1 ! 565: 551 00000a71 * L295: ! 566: 552 00000a71 * 200A00 .ascii " \12\0" ! 567: 553 00000a74 * .text ! 568: 554 00011EDB dd 8f00000a71 pushl $L295 ! 569: 555 00011EE1 fe 08 effffffb2c callf $8,_writes ! 570: 556 00011EE8 # writes("cycle: "); ! 571: 557 00011EE8 .data 1 ! 572: 558 00000a74 * L296: ! 573: 559 00000a74 * 6379636C653A2000 .ascii "cycle: \0" ! 574: 560 00000a7c * .text ! 575: 561 00011EE8 dd 8f00000a74 pushl $L296 ! 576: 562 00011EEE fe 08 effffffb1f callf $8,_writes ! 577: 563 00011EF5 # writed( cycle ); ! 578: 564 00011EF5 dd effffffb19 pushl _cycle ! 579: 565 00011EFB fe 08 effffffb12 callf $8,_writed ! 580: 566 00011F02 # writes(" TSTF test "); ! 581: 567 00011F02 .data 1 ! 582: 568 00000a7c * L297: ! 583: 569 00000a7c * 2020545354462074657374200 .ascii " TSTF test \0" ! 584: 0 ! 585: 570 00000a89 * .text ! 586: 571 00011F02 dd 8f00000a7c pushl $L297 ! 587: 572 00011F08 fe 08 effffffb05 callf $8,_writes ! 588: 573 00011F0F # writed( test_no ); ! 589: 574 00011F0F dd effffffaff pushl _test_no ! 590: 575 00011F15 fe 08 effffffaf8 callf $8,_writed ! 591: 576 00011F1C # writes(", subtest 3 (Cache Data) - THE ACC WAS MODIFIED\n"); ! 592: 577 00011F1C .data 1 ! 593: 578 00000a89 * L298: ! 594: 579 00000a89 * 2C20737562746573742033202 .ascii ", subtest 3 (Cache Data) - THE ACC WAS MODIFIED\12\0" ! 595: 8436163686520446174612920 ! 596: 2D20544845204143432057415 ! 597: 3204D4F4449464945440A00 ! 598: 580 00000aba * .text ! 599: 581 00011F1C dd 8f00000a89 pushl $L298 ! 600: 582 00011F22 fe 08 effffffaeb callf $8,_writes ! 601: 583 00011F29 # print_tstf_data(); /* print the operands */ ! 602: 584 00011F29 fe 04 ef0000037e callf $4,_print_tstf_data ! 603: 585 00011F30 # writes(" expected Acc = "); ! 604: 586 00011F30 .data 1 ! 605: 587 00000aba * L299: ! 606: 588 00000aba * 2020202020202020202020202 .ascii " expected Acc = \0" ! 607: 0202020202020202020657870 ! 608: 656374656420416363203D200 ! 609: 0 ! 610: 589 00000ae0 * .text ! 611: 590 00011F30 dd 8f00000aba pushl $L299 ! 612: 591 00011F36 fe 08 effffffad7 callf $8,_writes ! 613: 592 00011F3D # write32h( sgl_expected ); ! 614: 593 00011F3D dd effffffad1 pushl _sgl_expected ! 615: 594 00011F43 fe 08 effffffaca callf $8,_write32h ! 616: 595 00011F4A # writes("\n"); ! 617: 596 00011F4A .data 1 ! 618: 597 00000ae0 * L300: ! 619: 598 00000ae0 * 0A00 .ascii "\12\0" ! 620: 599 00000ae2 * .text ! 621: 600 00011F4A dd 8f00000ae0 pushl $L300 ! 622: 601 00011F50 fe 08 effffffabd callf $8,_writes ! 623: 602 00011F57 # } ! 624: 603 00011F57 # if( halt_flg ) ! 625: 604 00011F57 L294: ! 626: 605 00011F57 5d effffffab7 tstl _halt_flg ! 627: 606 00011F5D 31 09 jeql L301 ! 628: 607 00011F5F # tstf_er_halt( BAD_ACC_HLT ); /* halt on error */ ! 629: 608 00011F5F dd 01 pushl $1 ! 630: 609 00011F61 fe 08 ef000003a4 callf $8,_tstf_er_halt ! 631: 610 00011F68 # if( loop_on_err ) { ! 632: 611 00011F68 L301: ! 633: 612 00011F68 5d effffffaa6 tstl _loop_on_err ! 634: 613 00011F6E 31 0a jeql L302 ! 635: 614 00011F70 # force_loop = TRUE; /* set force loop flag */ ! 636: 615 00011F70 0d 01 effffffa9d movl $1,_force_loop ! 637: 616 00011F77 # asm("brw _tstf_3_lp1"); /* loop on the error */ ! 638: 617 00011F77 13 ff2a brw _tstf_3_lp1 ! 639: 618 00011F7A # } /* end of loop on error */ ! 640: 619 00011F7A # } /* end of register corruption error */ ! 641: 620 00011F7A L302: ! 642: 621 00011F7A # } /* end of tstf data WHILE loop */ ! 643: 622 00011F7A L293: ! 644: 623 00011F7A L287: ! 645: 624 00011F7A 6d effffffa94 incl _index ! 646: 625 00011F80 13 fedb jbr L289 ! 647: 626 00011F83 L288: ! 648: 627 00011F83 # } /* end of subtest 3 */ ! 649: 628 00011F83 40 ret#2 ! 650: 629 00011F84 .set L283,0x0 ! 651: 630 00011F84 L285: ! 652: 631 00011F84 13 fec4 jbr L286 ! 653: 632 00011F87 .data ! 654: 633 000009a4 * .text ! 655: 634 00011F87 00 .align 1 ! 656: 635 00011F88 .globl _tstf_4 ! 657: 636 00011F88 _tstf_4: ! 658: 637 00011F88 0000 .word L303 ! 659: 638 00011F8A # ! 660: 639 00011F8A # ! 661: 640 00011F8A # ! 662: 641 00011F8A # /************************************************************************ ! 663: 642 00011F8A # * ! 664: 643 00011F8A # * SUBTEST 4 - pipelined entry test ! 665: 644 00011F8A # * ! 666: 645 00011F8A # ************************************************************************/ ! 667: 646 00011F8A # tstf_4() ! 668: 647 00011F8A # { ! 669: 648 00011F8A 13 01dd jbr L305 ! 670: 649 00011F8D L306: ! 671: 650 00011F8D # force_loop = FALSE; ! 672: 651 00011F8D 4d effffffa81 clrl _force_loop ! 673: 652 00011F93 # subtest = 4; ! 674: 653 00011F93 0d 04 effffffa7a movl $4,_subtest ! 675: 654 00011F9A # for( index = 0; index < max_tstf_1_index; index++ ) { ! 676: 655 00011F9A 4d effffffa74 clrl _index ! 677: 656 00011FA0 L309: ! 678: 657 00011FA0 1d effffffa6e effffffa69 cmpl _index,_max_tstf_1_index ! 679: 658 00011FAB 91 03 13 01b9 jgeq L308 ! 680: 659 00011FB0 # sgl_ld_acc = tstf_1_data[index].ld; /* get value to negate */ ! 681: 660 00011FB0 0d effffffa5e 50 movl _index,r0 ! 682: 661 00011FB7 48 03 50 50 shll $3,r0,r0 ! 683: 662 00011FBB 0d e000000000 effffffa4e movl _tstf_1_data(r0),_sgl_ld_acc ! 684: 663 00011FC6 # sgl_expected = tstf_1_data[index].exp; /* get expected result */ ! 685: 664 00011FC6 0d effffffa48 50 movl _index,r0 ! 686: 665 00011FCD 48 03 50 50 shll $3,r0,r0 ! 687: 666 00011FD1 0d e000000004 effffffa38 movl _tstf_1_data+4(r0),_sgl_expected ! 688: 667 00011FDC # for( status_index = 0; status_index < 3; status_index++ ) { ! 689: 668 00011FDC 4d effffffa32 clrl _status_index ! 690: 669 00011FE2 L312: ! 691: 670 00011FE2 1d effffffa2c 03 cmpl _status_index,$3 ! 692: 671 00011FE9 91 03 13 0172 jgeq L311 ! 693: 672 00011FEE # sgl_dummy1 = status_array[status_index]; /* status = +,-,0 */ ! 694: 673 00011FEE 0d effffffa20 50 movl _status_index,r0 ! 695: 674 00011FF5 0d 40effffffa18 movl _status_array[r0],_sgl_dummy1 ! 696: effffffa13 ! 697: 675 00012001 # /* ! 698: 676 00012001 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 699: 677 00012001 # * The force loop flag is set after the first error. ! 700: 678 00012001 # */ ! 701: 679 00012001 # asm("_tstf_4_lp1:"); ! 702: 680 00012001 _tstf_4_lp1: ! 703: 681 00012001 # asm("ldf $0"); /* load Acc. with 0.0 */ ! 704: 682 00012001 06 8f00000000 ldf $0 ! 705: 683 00012007 # asm("tstl _sgl_dummy1"); /* set the PSL status */ ! 706: 684 00012007 5d effffffa07 tstl _sgl_dummy1 ! 707: 685 0001200D # asm("movpsl _init_psl"); /* save initial PSL */ ! 708: 686 0001200D cd effffffa01 movpsl _init_psl ! 709: 687 00012013 # asm("addf _sgl_ld_acc"); /* add the value */ ! 710: 688 00012013 c6 effffff9fb addf _sgl_ld_acc ! 711: 689 00012019 # asm("tstf"); /* test accumulator */ ! 712: 690 00012019 56 tstf ! 713: 691 0001201A # asm("movpsl _psl_val"); /* save final PSL */ ! 714: 692 0001201A cd effffff9f4 movpsl _psl_val ! 715: 693 00012020 # asm("stf _sgl_st_acc"); /* store the result */ ! 716: 694 00012020 26 effffff9ee stf _sgl_st_acc ! 717: 695 00012026 # if( force_loop ) ! 718: 696 00012026 5d effffff9e8 tstl _force_loop ! 719: 697 0001202C 31 02 jeql L313 ! 720: 698 0001202E # asm("brb _tstf_4_lp1");; /* loop on the error */ ! 721: 699 0001202E 11 d1 brb _tstf_4_lp1 ! 722: 700 00012030 L313: ! 723: 701 00012030 # /* ! 724: 702 00012030 # * end error loop - test the results ! 725: 703 00012030 # */ ! 726: 704 00012030 # exp_psl = init_psl; /* get initial PSL */ ! 727: 705 00012030 0d effffff9de effffff9d9 movl _init_psl,_exp_psl ! 728: 706 0001203B # exp_psl &= 0xfffffff3; /* clear ZERO, NEGATIVE */ ! 729: 707 0001203B ac 88f3 effffff9d1 andl2 $-13,_exp_psl ! 730: 708 00012043 # if( sgl_expected == ZERO ) ! 731: 709 00012043 1d effffff9cb 04 cmpl _sgl_expected,$4 ! 732: 710 0001204A 21 07 jneq L314 ! 733: 711 0001204C # exp_psl |= PSL_Z; /* expect ZERO bit set */ ! 734: 712 0001204C 8c 04 effffff9c1 orl2 $4,_exp_psl ! 735: 713 00012053 # if( sgl_expected == NEGATIVE ) ! 736: 714 00012053 L314: ! 737: 715 00012053 1d effffff9bb 08 cmpl _sgl_expected,$8 ! 738: 716 0001205A 21 07 jneq L315 ! 739: 717 0001205C # exp_psl |= PSL_N; /* expect NEG bit set */ ! 740: 718 0001205C 8c 08 effffff9b1 orl2 $8,_exp_psl ! 741: 719 00012063 # if( psl_val != exp_psl ) { ! 742: 720 00012063 L315: ! 743: 721 00012063 1d effffff9ab effffff9a6 cmpl _psl_val,_exp_psl ! 744: 722 0001206E 21 03 13 00e4 jeql L316 ! 745: 723 00012073 # errcnt++; /* bump the error count */ ! 746: 724 00012073 6d effffff99b incl _errcnt ! 747: 725 00012079 # if( prt_error ) { ! 748: 726 00012079 5d effffff995 tstl _prt_error ! 749: 727 0001207F 21 03 13 00b0 jeql L317 ! 750: 728 00012084 # writes(" \n"); /* start new print line */ ! 751: 729 00012084 .data 1 ! 752: 730 00000ae2 * L318: ! 753: 731 00000ae2 * 200A00 .ascii " \12\0" ! 754: 732 00000ae5 * .text ! 755: 733 00012084 dd 8f00000ae2 pushl $L318 ! 756: 734 0001208A fe 08 effffff983 callf $8,_writes ! 757: 735 00012091 # writes("cycle: "); ! 758: 736 00012091 .data 1 ! 759: 737 00000ae5 * L319: ! 760: 738 00000ae5 * 6379636C653A2000 .ascii "cycle: \0" ! 761: 739 00000aed * .text ! 762: 740 00012091 dd 8f00000ae5 pushl $L319 ! 763: 741 00012097 fe 08 effffff976 callf $8,_writes ! 764: 742 0001209E # writed( cycle ); ! 765: 743 0001209E dd effffff970 pushl _cycle ! 766: 744 000120A4 fe 08 effffff969 callf $8,_writed ! 767: 745 000120AB # writes(" TSTF test "); ! 768: 746 000120AB .data 1 ! 769: 747 00000aed * L320: ! 770: 748 00000aed * 2020545354462074657374200 .ascii " TSTF test \0" ! 771: 0 ! 772: 749 00000afa * .text ! 773: 750 000120AB dd 8f00000aed pushl $L320 ! 774: 751 000120B1 fe 08 effffff95c callf $8,_writes ! 775: 752 000120B8 # writed( test_no ); ! 776: 753 000120B8 dd effffff956 pushl _test_no ! 777: 754 000120BE fe 08 effffff94f callf $8,_writed ! 778: 755 000120C5 # writes( ! 779: 756 000120C5 # ", subtest 4 (Piped Entry) -BAD FINAL PSL\n"); ! 780: 757 000120C5 .data 1 ! 781: 758 00000afa * L321: ! 782: 759 00000afa * 2C20737562746573742034202 .ascii ", subtest 4 (Piped Entry) -BAD FINAL PSL\12\0" ! 783: 8506970656420456E74727929 ! 784: 202D4241442046494E414C205 ! 785: 0534C0A00 ! 786: 760 00000b24 * .text ! 787: 761 000120C5 dd 8f00000afa pushl $L321 ! 788: 762 000120CB fe 08 effffff942 callf $8,_writes ! 789: 763 000120D2 # print_tstf_data(); /* print operands */ ! 790: 764 000120D2 fe 04 ef000001d5 callf $4,_print_tstf_data ! 791: 765 000120D9 # writes("initial PSL = "); ! 792: 766 000120D9 .data 1 ! 793: 767 00000b24 * L322: ! 794: 768 00000b24 * 696E697469616C2050534C203 .ascii "initial PSL = \0" ! 795: D2000 ! 796: 769 00000b33 * .text ! 797: 770 000120D9 dd 8f00000b24 pushl $L322 ! 798: 771 000120DF fe 08 effffff92e callf $8,_writes ! 799: 772 000120E6 # write32h( init_psl ); ! 800: 773 000120E6 dd effffff928 pushl _init_psl ! 801: 774 000120EC fe 08 effffff921 callf $8,_write32h ! 802: 775 000120F3 # writes(", final PSL = "); ! 803: 776 000120F3 .data 1 ! 804: 777 00000b33 * L323: ! 805: 778 00000b33 * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 806: 03D2000 ! 807: 779 00000b43 * .text ! 808: 780 000120F3 dd 8f00000b33 pushl $L323 ! 809: 781 000120F9 fe 08 effffff914 callf $8,_writes ! 810: 782 00012100 # write32h( psl_val ); ! 811: 783 00012100 dd effffff90e pushl _psl_val ! 812: 784 00012106 fe 08 effffff907 callf $8,_write32h ! 813: 785 0001210D # writes(", expected PSL = "); ! 814: 786 0001210D .data 1 ! 815: 787 00000b43 * L324: ! 816: 788 00000b43 * 2C20657870656374656420505 .ascii ", expected PSL = \0" ! 817: 34C203D2000 ! 818: 789 00000b55 * .text ! 819: 790 0001210D dd 8f00000b43 pushl $L324 ! 820: 791 00012113 fe 08 effffff8fa callf $8,_writes ! 821: 792 0001211A # write32h( exp_psl ); ! 822: 793 0001211A dd effffff8f4 pushl _exp_psl ! 823: 794 00012120 fe 08 effffff8ed callf $8,_write32h ! 824: 795 00012127 # writes("\n"); ! 825: 796 00012127 .data 1 ! 826: 797 00000b55 * L325: ! 827: 798 00000b55 * 0A00 .ascii "\12\0" ! 828: 799 00000b57 * .text ! 829: 800 00012127 dd 8f00000b55 pushl $L325 ! 830: 801 0001212D fe 08 effffff8e0 callf $8,_writes ! 831: 802 00012134 # } ! 832: 803 00012134 # if( halt_flg ) ! 833: 804 00012134 L317: ! 834: 805 00012134 5d effffff8da tstl _halt_flg ! 835: 806 0001213A 31 09 jeql L326 ! 836: 807 0001213C # tstf_er_halt( BAD_PSL_HLT ); /* halt on error */ ! 837: 808 0001213C dd 03 pushl $3 ! 838: 809 0001213E fe 08 ef000001c7 callf $8,_tstf_er_halt ! 839: 810 00012145 # if( loop_on_err ) { ! 840: 811 00012145 L326: ! 841: 812 00012145 5d effffff8c9 tstl _loop_on_err ! 842: 813 0001214B 31 0a jeql L327 ! 843: 814 0001214D # force_loop = TRUE; /* set loop flag */ ! 844: 815 0001214D 0d 01 effffff8c0 movl $1,_force_loop ! 845: 816 00012154 # asm("brw _tstf_4_lp1"); /* loop on error */ ! 846: 817 00012154 13 feaa brw _tstf_4_lp1 ! 847: 818 00012157 # } /* end of loop on error */ ! 848: 819 00012157 # } /* end of PSL corruption error */ ! 849: 820 00012157 L327: ! 850: 821 00012157 # } /* end of status WHILE loop */ ! 851: 822 00012157 L316: ! 852: 823 00012157 L310: ! 853: 824 00012157 6d effffff8b7 incl _status_index ! 854: 825 0001215D 13 fe82 jbr L312 ! 855: 826 00012160 L311: ! 856: 827 00012160 # } /* end of data WHILE loop */ ! 857: 828 00012160 L307: ! 858: 829 00012160 6d effffff8ae incl _index ! 859: 830 00012166 13 fe37 jbr L309 ! 860: 831 00012169 L308: ! 861: 832 00012169 # } /* end of subtest 4 */ ! 862: 833 00012169 40 ret#2 ! 863: 834 0001216A .set L303,0x0 ! 864: 835 0001216A L305: ! 865: 836 0001216A 13 fe20 jbr L306 ! 866: 837 0001216D .data ! 867: 838 000009a4 * .text ! 868: 839 0001216D 00 .align 1 ! 869: 840 0001216E .globl _tstf_5 ! 870: 841 0001216E _tstf_5: ! 871: 842 0001216E 0000 .word L328 ! 872: 843 00012170 # ! 873: 844 00012170 # ! 874: 845 00012170 # ! 875: 846 00012170 # /************************************************************************ ! 876: 847 00012170 # * ! 877: 848 00012170 # * SUBTEST 5 - pipelined exit test ! 878: 849 00012170 # * ! 879: 850 00012170 # ************************************************************************/ ! 880: 851 00012170 # tstf_5() ! 881: 852 00012170 # { ! 882: 853 00012170 13 0138 jbr L330 ! 883: 854 00012173 L331: ! 884: 855 00012173 # force_loop = FALSE; ! 885: 856 00012173 4d effffff89b clrl _force_loop ! 886: 857 00012179 # subtest = 5; ! 887: 858 00012179 0d 05 effffff894 movl $5,_subtest ! 888: 859 00012180 # for( index = 0; index < max_tstf_1_index; index++ ) { ! 889: 860 00012180 4d effffff88e clrl _index ! 890: 861 00012186 L334: ! 891: 862 00012186 1d effffff888 effffff883 cmpl _index,_max_tstf_1_index ! 892: 863 00012191 91 03 13 0114 jgeq L333 ! 893: 864 00012196 # sgl_ld_acc = tstf_1_data[index].ld; /* get value to test */ ! 894: 865 00012196 0d effffff878 50 movl _index,r0 ! 895: 866 0001219D 48 03 50 50 shll $3,r0,r0 ! 896: 867 000121A1 0d e000000000 effffff868 movl _tstf_1_data(r0),_sgl_ld_acc ! 897: 868 000121AC # if( sgl_ld_acc & 0x7f800000 ) ! 898: 869 000121AC 3d 8f7f800000 effffff85d bitl $2139095040,_sgl_ld_acc ! 899: 870 000121B7 31 0d jeql L335 ! 900: 871 000121B9 # sgl_expected = sgl_ld_acc; /* the Acc should not change */ ! 901: 872 000121B9 0d effffff855 effffff850 movl _sgl_ld_acc,_sgl_expected ! 902: 873 000121C4 # else ! 903: 874 000121C4 11 06 jbr L336 ! 904: 875 000121C6 L335: ! 905: 876 000121C6 # sgl_expected = 0; /* expect a '0' final Acc */ ! 906: 877 000121C6 4d effffff848 clrl _sgl_expected ! 907: 878 000121CC L336: ! 908: 879 000121CC # /* ! 909: 880 000121CC # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 910: 881 000121CC # * The force loop flag is set after the first error. ! 911: 882 000121CC # */ ! 912: 883 000121CC # asm("_tstf_5_lp1:"); ! 913: 884 000121CC _tstf_5_lp1: ! 914: 885 000121CC # asm("movl $0,r0"); /* clear r0 */ ! 915: 886 000121CC 0d 00 50 movl $0,r0 ! 916: 887 000121CF # asm("ldf _sgl_ld_acc"); /* load the value */ ! 917: 888 000121CF 06 effffff83f ldf _sgl_ld_acc ! 918: 889 000121D5 # asm("tstf"); /* test the accumulator */ ! 919: 890 000121D5 56 tstf ! 920: 891 000121D6 # asm("addf r0"); /* add a zero */ ! 921: 892 000121D6 c6 50 addf r0 ! 922: 893 000121D8 # asm("stf _sgl_st_acc"); /* store the result */ ! 923: 894 000121D8 26 effffff836 stf _sgl_st_acc ! 924: 895 000121DE # if( force_loop ) ! 925: 896 000121DE 5d effffff830 tstl _force_loop ! 926: 897 000121E4 31 02 jeql L337 ! 927: 898 000121E6 # asm("brb _tstf_5_lp1");; /* loop on the error */ ! 928: 899 000121E6 11 e4 brb _tstf_5_lp1 ! 929: 900 000121E8 L337: ! 930: 901 000121E8 # /* ! 931: 902 000121E8 # * end error loop - test the results ! 932: 903 000121E8 # */ ! 933: 904 000121E8 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 934: 905 000121E8 1d effffff826 effffff821 cmpl _sgl_st_acc,_sgl_expected ! 935: 906 000121F3 21 03 13 00a9 jeql L338 ! 936: 907 000121F8 # errcnt++; /* bump the error count */ ! 937: 908 000121F8 6d effffff816 incl _errcnt ! 938: 909 000121FE # if( prt_error ) { ! 939: 910 000121FE 5d effffff810 tstl _prt_error ! 940: 911 00012204 31 78 jeql L339 ! 941: 912 00012206 # writes(" \n"); /* start a new print line */ ! 942: 913 00012206 .data 1 ! 943: 914 00000b57 * L340: ! 944: 915 00000b57 * 200A00 .ascii " \12\0" ! 945: 916 00000b5a * .text ! 946: 917 00012206 dd 8f00000b57 pushl $L340 ! 947: 918 0001220C fe 08 effffff801 callf $8,_writes ! 948: 919 00012213 # writes("cycle: "); ! 949: 920 00012213 .data 1 ! 950: 921 00000b5a * L341: ! 951: 922 00000b5a * 6379636C653A2000 .ascii "cycle: \0" ! 952: 923 00000b62 * .text ! 953: 924 00012213 dd 8f00000b5a pushl $L341 ! 954: 925 00012219 fe 08 effffff7f4 callf $8,_writes ! 955: 926 00012220 # writed( cycle ); ! 956: 927 00012220 dd effffff7ee pushl _cycle ! 957: 928 00012226 fe 08 effffff7e7 callf $8,_writed ! 958: 929 0001222D # writes(" TSTF test "); ! 959: 930 0001222D .data 1 ! 960: 931 00000b62 * L342: ! 961: 932 00000b62 * 2020545354462074657374200 .ascii " TSTF test \0" ! 962: 0 ! 963: 933 00000b6f * .text ! 964: 934 0001222D dd 8f00000b62 pushl $L342 ! 965: 935 00012233 fe 08 effffff7da callf $8,_writes ! 966: 936 0001223A # writed( test_no ); ! 967: 937 0001223A dd effffff7d4 pushl _test_no ! 968: 938 00012240 fe 08 effffff7cd callf $8,_writed ! 969: 939 00012247 # writes( ! 970: 940 00012247 # ", subtest 5 (Piped Exit) - BAD FINAL ACC\n"); ! 971: 941 00012247 .data 1 ! 972: 942 00000b6f * L343: ! 973: 943 00000b6f * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Exit) - BAD FINAL ACC\12\0" ! 974: 8506970656420457869742920 ! 975: 2D204241442046494E414C204 ! 976: 143430A00 ! 977: 944 00000b99 * .text ! 978: 945 00012247 dd 8f00000b6f pushl $L343 ! 979: 946 0001224D fe 08 effffff7c0 callf $8,_writes ! 980: 947 00012254 # print_tstf_data(); ! 981: 948 00012254 fe 04 ef00000053 callf $4,_print_tstf_data ! 982: 949 0001225B # writes(" expected Acc = "); ! 983: 950 0001225B .data 1 ! 984: 951 00000b99 * L344: ! 985: 952 00000b99 * 2020202020202020202020202 .ascii " expected Acc = \0" ! 986: 0202020202020202020657870 ! 987: 656374656420416363203D200 ! 988: 0 ! 989: 953 00000bbf * .text ! 990: 954 0001225B dd 8f00000b99 pushl $L344 ! 991: 955 00012261 fe 08 effffff7ac callf $8,_writes ! 992: 956 00012268 # write32h( sgl_expected ); ! 993: 957 00012268 dd effffff7a6 pushl _sgl_expected ! 994: 958 0001226E fe 08 effffff79f callf $8,_write32h ! 995: 959 00012275 # writec('\n'); ! 996: 960 00012275 dd 0a pushl $10 ! 997: 961 00012277 fe 08 effffff796 callf $8,_writec ! 998: 962 0001227E # } ! 999: 963 0001227E # if( halt_flg ) ! 1000: 964 0001227E L339: ! 1001: 965 0001227E 5d effffff790 tstl _halt_flg ! 1002: 966 00012284 31 09 jeql L346 ! 1003: 967 00012286 # tstf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 1004: 968 00012286 dd 01 pushl $1 ! 1005: 969 00012288 fe 08 ef0000007d callf $8,_tstf_er_halt ! 1006: 970 0001228F # if( loop_on_err ) { ! 1007: 971 0001228F L346: ! 1008: 972 0001228F 5d effffff77f tstl _loop_on_err ! 1009: 973 00012295 31 0a jeql L347 ! 1010: 974 00012297 # force_loop = TRUE; /* set the force loop flag */ ! 1011: 975 00012297 0d 01 effffff776 movl $1,_force_loop ! 1012: 976 0001229E # asm("brw _tstf_5_lp1"); /* and loop on the error */ ! 1013: 977 0001229E 13 ff2b brw _tstf_5_lp1 ! 1014: 978 000122A1 # } /* end of loop on error */ ! 1015: 979 000122A1 # } /* end of compare error */ ! 1016: 980 000122A1 L347: ! 1017: 981 000122A1 # } /* end of WHILE loop */ ! 1018: 982 000122A1 L338: ! 1019: 983 000122A1 L332: ! 1020: 984 000122A1 6d effffff76d incl _index ! 1021: 985 000122A7 13 fedc jbr L334 ! 1022: 986 000122AA L333: ! 1023: 987 000122AA # } /* end of subtest 5 */ ! 1024: 988 000122AA 40 ret#2 ! 1025: 989 000122AB .set L328,0x0 ! 1026: 990 000122AB L330: ! 1027: 991 000122AB 13 fec5 jbr L331 ! 1028: 992 000122AE .data ! 1029: 993 000009a4 * .text ! 1030: 994 000122AE .align 1 ! 1031: 995 000122AE .globl _print_tstf_data ! 1032: 996 000122AE _print_tstf_data: ! 1033: 997 000122AE 0000 .word L348 ! 1034: 998 000122B0 # ! 1035: 999 000122B0 # ! 1036: 1000 000122B0 # ! 1037: 1001 000122B0 # /************************************************************************** ! 1038: 1002 000122B0 # * ! 1039: 1003 000122B0 # * PRINT THE DATA AND STORE RESULTS ! 1040: 1004 000122B0 # * ! 1041: 1005 000122B0 # * initial Acc = xxxxxxxx, final Acc = xxxxxxxx, data index = xx ! 1042: 1006 000122B0 # **************************************************************************/ ! 1043: 1007 000122B0 # print_tstf_data() ! 1044: 1008 000122B0 # { ! 1045: 1009 000122B0 11 58 jbr L350 ! 1046: 1010 000122B2 L351: ! 1047: 1011 000122B2 # writes("initial Acc = "); ! 1048: 1012 000122B2 .data 1 ! 1049: 1013 00000bbf * L352: ! 1050: 1014 00000bbf * 696E697469616C20416363203 .ascii "initial Acc = \0" ! 1051: D2000 ! 1052: 1015 00000bce * .text ! 1053: 1016 000122B2 dd 8f00000bbf pushl $L352 ! 1054: 1017 000122B8 fe 08 effffff755 callf $8,_writes ! 1055: 1018 000122BF # write32h( sgl_ld_acc ); ! 1056: 1019 000122BF dd effffff74f pushl _sgl_ld_acc ! 1057: 1020 000122C5 fe 08 effffff748 callf $8,_write32h ! 1058: 1021 000122CC # writes(", final Acc = "); ! 1059: 1022 000122CC .data 1 ! 1060: 1023 00000bce * L353: ! 1061: 1024 00000bce * 2C202066696E616C204163632 .ascii ", final Acc = \0" ! 1062: 03D2000 ! 1063: 1025 00000bde * .text ! 1064: 1026 000122CC dd 8f00000bce pushl $L353 ! 1065: 1027 000122D2 fe 08 effffff73b callf $8,_writes ! 1066: 1028 000122D9 # write32h( sgl_st_acc ); ! 1067: 1029 000122D9 dd effffff735 pushl _sgl_st_acc ! 1068: 1030 000122DF fe 08 effffff72e callf $8,_write32h ! 1069: 1031 000122E6 # writes(", data index = "); ! 1070: 1032 000122E6 .data 1 ! 1071: 1033 00000bde * L354: ! 1072: 1034 00000bde * 2C2020206461746120696E646 .ascii ", data index = \0" ! 1073: 578203D2000 ! 1074: 1035 00000bf0 * .text ! 1075: 1036 000122E6 dd 8f00000bde pushl $L354 ! 1076: 1037 000122EC fe 08 effffff721 callf $8,_writes ! 1077: 1038 000122F3 # writed( index ); ! 1078: 1039 000122F3 dd effffff71b pushl _index ! 1079: 1040 000122F9 fe 08 effffff714 callf $8,_writed ! 1080: 1041 00012300 # writec('\n'); ! 1081: 1042 00012300 dd 0a pushl $10 ! 1082: 1043 00012302 fe 08 effffff70b callf $8,_writec ! 1083: 1044 00012309 # } ! 1084: 1045 00012309 40 ret#2 ! 1085: 1046 0001230A .set L348,0x0 ! 1086: 1047 0001230A L350: ! 1087: 1048 0001230A 11 a6 jbr L351 ! 1088: 1049 0001230C .data ! 1089: 1050 000009a4 * .text ! 1090: 1051 0001230C .align 1 ! 1091: 1052 0001230C .globl _tstf_er_halt ! 1092: 1053 0001230C _tstf_er_halt: ! 1093: 1054 0001230C 0000 .word L355 ! 1094: 1055 0001230E # ! 1095: 1056 0001230E # ! 1096: 1057 0001230E # ! 1097: 1058 0001230E # /************************************************************************** ! 1098: 1059 0001230E # * ! 1099: 1060 0001230E # * HALT ON ERROR ROUTINE ! 1100: 1061 0001230E # * ! 1101: 1062 0001230E # **************************************************************************/ ! 1102: 1063 0001230E # tstf_er_halt( halt_code ) ! 1103: 1064 0001230E # int halt_code; ! 1104: 1065 0001230E # { ! 1105: 1066 0001230E 13 00a1 jbr L357 ! 1106: 1067 00012311 L358: ! 1107: 1068 00012311 # sgl_dummy1 = halt_code; /* get the error type */ ! 1108: 1069 00012311 0d ad04 effffff6fb movl 4(fp),_sgl_dummy1 ! 1109: 1070 00012319 # asm("movl _test_no,r0"); /* r0 = test number */ ! 1110: 1071 00012319 0d effffff6f5 50 movl _test_no,r0 ! 1111: 1072 00012320 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1112: 1073 00012320 0d effffff6ee 51 movl _subtest,r1 ! 1113: 1074 00012327 # asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 1114: 1075 00012327 0d effffff6e7 52 movl _sgl_dummy1,r2 ! 1115: 1076 0001232E # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1116: 1077 0001232E 0d effffff6e0 53 movl _cycle,r3 ! 1117: 1078 00012335 # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */ ! 1118: 1079 00012335 0d effffff6d9 54 movl _sgl_ld_acc,r4 ! 1119: 1080 0001233C # asm("movl _psl_val,r5"); /* r5 = final PSL */ ! 1120: 1081 0001233C 0d effffff6d2 55 movl _psl_val,r5 ! 1121: 1082 00012343 # if( halt_code == BAD_ACC_HLT ) { ! 1122: 1083 00012343 1d ad04 01 cmpl 4(fp),$1 ! 1123: 1084 00012347 21 10 jneq L359 ! 1124: 1085 00012349 # asm("movl _sgl_st_acc,r6"); /* r6 = actual value */ ! 1125: 1086 00012349 0d effffff6c5 56 movl _sgl_st_acc,r6 ! 1126: 1087 00012350 # asm("movl _sgl_expected,r7"); /* r7 = expected value */ ! 1127: 1088 00012350 0d effffff6be 57 movl _sgl_expected,r7 ! 1128: 1089 00012357 # } else ! 1129: 1090 00012357 11 57 jbr L360 ! 1130: 1091 00012359 L359: ! 1131: 1092 00012359 # if( halt_code == BAD_REG_HLT ) { ! 1132: 1093 00012359 1d ad04 02 cmpl 4(fp),$2 ! 1133: 1094 0001235D 21 3d jneq L361 ! 1134: 1095 0001235F # sgl_dummy1 = load_regs[index2]; ! 1135: 1096 0001235F 0d effffff6af 50 movl _index2,r0 ! 1136: 1097 00012366 0d 40effffff6a7 movl _load_regs[r0],_sgl_dummy1 ! 1137: effffff6a2 ! 1138: 1098 00012372 # sgl_dummy2 = store_regs[index2]; ! 1139: 1099 00012372 0d effffff69c 50 movl _index2,r0 ! 1140: 1100 00012379 0d 40effffff694 movl _store_regs[r0],_sgl_dummy2 ! 1141: effffff68f ! 1142: 1101 00012385 # asm("movl _index2,r6"); /* r6 = bad register # */ ! 1143: 1102 00012385 0d effffff689 56 movl _index2,r6 ! 1144: 1103 0001238C # asm("movl _sgl_dummy2,r7"); /* r7 = actual value */ ! 1145: 1104 0001238C 0d effffff682 57 movl _sgl_dummy2,r7 ! 1146: 1105 00012393 # asm("movl _sgl_dummy1,r8"); /* r8 = expected value */ ! 1147: 1106 00012393 0d effffff67b 58 movl _sgl_dummy1,r8 ! 1148: 1107 0001239A # } else ! 1149: 1108 0001239A 11 14 jbr L362 ! 1150: 1109 0001239C L361: ! 1151: 1110 0001239C # if( halt_code == BAD_PSL_HLT ) { ! 1152: 1111 0001239C 1d ad04 03 cmpl 4(fp),$3 ! 1153: 1112 000123A0 21 0e jneq L363 ! 1154: 1113 000123A2 # asm("movl _exp_psl,r6"); /* r6 = expected PSL */ ! 1155: 1114 000123A2 0d effffff66c 56 movl _exp_psl,r6 ! 1156: 1115 000123A9 # asm("movl _index,r7"); /* r7 = data index */ ! 1157: 1116 000123A9 0d effffff665 57 movl _index,r7 ! 1158: 1117 000123B0 # }; ! 1159: 1118 000123B0 L363: ! 1160: 1119 000123B0 L362: ! 1161: 1120 000123B0 L360: ! 1162: 1121 000123B0 # asm("halt"); /* HALT ... */ ! 1163: 1122 000123B0 00 halt ! 1164: 1123 000123B1 # } ! 1165: 1124 000123B1 40 ret#2 ! 1166: 1125 000123B2 .set L355,0x0 ! 1167: 1126 000123B2 L357: ! 1168: 1127 000123B2 13 ff5c jbr L358 ! 1169: 1128 000123B5 .data ! 1170: 1128 00023DC9 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.