![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to logf.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 logf.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 00000a60 * .text ! 4: 4 00000000 .align 1 ! 5: 5 00000000 .globl _logf ! 6: 6 00000000 _logf: ! 7: 7 000215BC 0000 .word L215 ! 8: 8 000215BE # #include "fpp_defs.h" ! 9: 9 000215BE # ! 10: 10 000215BE # ! 11: 11 000215BE # ! 12: 12 000215BE # /*************************************************************************** ! 13: 13 000215BE # * ! 14: 14 000215BE # * LOGF - SINGLE PRECISION FLOATING POINT LOGF FUNCTION TEST ! 15: 15 000215BE # * ! 16: 16 000215BE # * LOGF TEST MONITOR ! 17: 17 000215BE # * ! 18: 18 000215BE # *****************************************************************************/ ! 19: 19 000215BE # logf() ! 20: 20 000215BE # { ! 21: 21 000215BE 11 4f jbr L217 ! 22: 22 000215C0 L218: ! 23: 23 000215C0 # asm(".globl _logf_t"); ! 24: 24 000215C0 .globl _logf_t ! 25: 25 000215C0 # asm("_logf_t:"); /* entry address */ ! 26: 26 000215C0 _logf_t: ! 27: 27 000215C0 # if( ( cycle == 1 ) && ( prt_hdrs ) ) /* print headers on 1st pass */ ! 28: 28 000215C0 1d effffffff6 01 cmpl _cycle,$1 ! 29: 29 000215C7 21 15 jneq L219 ! 30: 30 000215C9 5d efffffffed tstl _prt_hdrs ! 31: 31 000215CF 31 0d jeql L219 ! 32: 32 000215D1 # { ! 33: 33 000215D1 # writes(" LOGF"); ! 34: 34 000215D1 .data 1 ! 35: 35 00000a60 * L221: ! 36: 36 00000a60 * 204C4F474600 .ascii " LOGF\0" ! 37: 37 00000a66 * .text ! 38: 38 000215D1 dd 8f00000a60 pushl $L221 ! 39: 39 000215D7 fe 08 efffffffde callf $8,_writes ! 40: 40 000215DE # } ! 41: 41 000215DE # logf_1(); /* test log function w/ delay */ ! 42: 42 000215DE L219: ! 43: 43 000215DE fe 04 ef0000002d callf $4,_logf_1 ! 44: 44 000215E5 # logf_2(); /* test log function */ ! 45: 45 000215E5 fe 04 ef00000198 callf $4,_logf_2 ! 46: 46 000215EC # logf_3(); /* register corruption */ ! 47: 47 000215EC fe 04 ef000002f1 callf $4,_logf_3 ! 48: 48 000215F3 # logf_4(); /* test the PSL */ ! 49: 49 000215F3 fe 04 ef000004d4 callf $4,_logf_4 ! 50: 50 000215FA # logf_5(); /* pipelined entry */ ! 51: 51 000215FA fe 04 ef0000067d callf $4,_logf_5 ! 52: 52 00021601 # logf_6(); /* pipelined exit */ ! 53: 53 00021601 fe 04 ef000007d2 callf $4,_logf_6 ! 54: 54 00021608 # asm("jmp *return"); /* return to the test monitor */ ! 55: 55 00021608 71 ffffffffae jmp *return ! 56: 56 0002160E # } ! 57: 57 0002160E 40 ret#2 ! 58: 58 0002160F .set L215,0x0 ! 59: 59 0002160F L217: ! 60: 60 0002160F 11 af jbr L218 ! 61: 61 00021611 .data ! 62: 62 00000a60 * .text ! 63: 63 00021611 00 .align 1 ! 64: 64 00021612 .globl _logf_1 ! 65: 65 00021612 _logf_1: ! 66: 66 00021612 0000 .word L228 ! 67: 67 00021614 # ! 68: 68 00021614 # /*************************************************************************** ! 69: 69 00021614 # * ! 70: 70 00021614 # * SUBTEST 1 - LOGF FUNCTION ! 71: 71 00021614 # * ! 72: 72 00021614 # ***************************************************************************/ ! 73: 73 00021614 # logf_1() ! 74: 74 00021614 # { ! 75: 75 00021614 13 016a jbr L230 ! 76: 76 00021617 L231: ! 77: 77 00021617 # #define DELAY 15 /* delay 30 ticks between LOGF & STF */ ! 78: 78 00021617 # force_loop = FALSE; /* clear the LOOP flag */ ! 79: 79 00021617 4d efffffff9f clrl _force_loop ! 80: 80 0002161D # subtest = 1; ! 81: 81 0002161D 0d 01 efffffff98 movl $1,_subtest ! 82: 82 00021624 # index = 0; ! 83: 83 00021624 4d efffffff92 clrl _index ! 84: 84 0002162A # do ! 85: 85 0002162A L234: ! 86: 86 0002162A # { ! 87: 87 0002162A # sgl_ld_acc = logf_1_data[index].ld; /* get the operand */ ! 88: 88 0002162A 0d efffffff8c 50 movl _index,r0 ! 89: 89 00021631 48 03 50 50 shll $3,r0,r0 ! 90: 90 00021635 0d e000000000 efffffff7c movl _logf_1_data(r0),_sgl_ld_acc ! 91: 91 00021640 # sgl_expected = logf_1_data[index].exp; /* get expected results */ ! 92: 92 00021640 0d efffffff76 50 movl _index,r0 ! 93: 93 00021647 48 03 50 50 shll $3,r0,r0 ! 94: 94 0002164B 0d e000000004 efffffff66 movl _logf_1_data+4(r0),_sgl_expected ! 95: 95 00021656 # sgl_dummy1 = DELAY; ! 96: 96 00021656 0d 0f efffffff5f movl $15,_sgl_dummy1 ! 97: 97 0002165D # /* ! 98: 98 0002165D # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 99: 99 0002165D # * The force loop flag is set after the first error. ! 100: 100 0002165D # */ ! 101: 101 0002165D # asm("_logf_1_lp1:"); ! 102: 102 0002165D _logf_1_lp1: ! 103: 103 0002165D # asm("movl _sgl_ld_acc,r4"); /* set the data to load */ ! 104: 104 0002165D 0d efffffff59 54 movl _sgl_ld_acc,r4 ! 105: 105 00021664 # asm("ldf r4"); /* load the accumulator */ ! 106: 106 00021664 06 54 ldf r4 ! 107: 107 00021666 # asm("movl _sgl_dummy1,r0"); /* get the delay factor */ ! 108: 108 00021666 0d efffffff50 50 movl _sgl_dummy1,r0 ! 109: 109 0002166D # asm("logf"); /* get ACC.'s log */ ! 110: 110 0002166D 35 logf ! 111: 111 0002166E # asm("1:"); ! 112: 112 0002166E 1: ! 113: 113 0002166E # asm("decl r0"); /* delay to let the LOGF */ ! 114: 114 0002166E 7d 50 decl r0 ! 115: 115 00021670 # asm("bgtr 1b"); /* instruction finish */ ! 116: 116 00021670 41 fc bgtr 1b ! 117: 117 00021672 # asm("stf r5"); /* store the result */ ! 118: 118 00021672 26 55 stf r5 ! 119: 119 00021674 # if( force_loop ) ! 120: 120 00021674 5d efffffff42 tstl _force_loop ! 121: 121 0002167A 31 02 jeql L235 ! 122: 122 0002167C # asm("brb _logf_1_lp1");; /* loop on the error */ ! 123: 123 0002167C 11 df brb _logf_1_lp1 ! 124: 124 0002167E L235: ! 125: 125 0002167E # /* ! 126: 126 0002167E # * end error loop ! 127: 127 0002167E # */ ! 128: 128 0002167E # asm("movl r5,_sgl_st_acc"); /* save the result */ ! 129: 129 0002167E 0d 55 efffffff37 movl r5,_sgl_st_acc ! 130: 130 00021685 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 131: 131 00021685 1d efffffff31 efffffff2c cmpl _sgl_st_acc,_sgl_expected ! 132: 132 00021690 21 03 13 00d2 jeql L236 ! 133: 133 00021695 # errcnt++; /* bump the error count */ ! 134: 134 00021695 6d efffffff21 incl _errcnt ! 135: 135 0002169B # if ( prt_error ) { ! 136: 136 0002169B 5d efffffff1b tstl _prt_error ! 137: 137 000216A1 21 03 13 009b jeql L237 ! 138: 138 000216A6 # writes(" \n"); /* start a new print line */ ! 139: 139 000216A6 .data 1 ! 140: 140 00000a66 * L238: ! 141: 141 00000a66 * 200A00 .ascii " \12\0" ! 142: 142 00000a69 * .text ! 143: 143 000216A6 dd 8f00000a66 pushl $L238 ! 144: 144 000216AC fe 08 efffffff09 callf $8,_writes ! 145: 145 000216B3 # writes("cycle: "); ! 146: 146 000216B3 .data 1 ! 147: 147 00000a69 * L239: ! 148: 148 00000a69 * 6379636C653A2000 .ascii "cycle: \0" ! 149: 149 00000a71 * .text ! 150: 150 000216B3 dd 8f00000a69 pushl $L239 ! 151: 151 000216B9 fe 08 effffffefc callf $8,_writes ! 152: 152 000216C0 # writed( cycle ); ! 153: 153 000216C0 dd effffffef6 pushl _cycle ! 154: 154 000216C6 fe 08 effffffeef callf $8,_writed ! 155: 155 000216CD # writes(" LOGF test "); ! 156: 156 000216CD .data 1 ! 157: 157 00000a71 * L241: ! 158: 158 00000a71 * 2020204C4F474620746573742 .ascii " LOGF test \0" ! 159: 000 ! 160: 159 00000a7f * .text ! 161: 160 000216CD dd 8f00000a71 pushl $L241 ! 162: 161 000216D3 fe 08 effffffee2 callf $8,_writes ! 163: 162 000216DA # writed( test_no ); ! 164: 163 000216DA dd effffffedc pushl _test_no ! 165: 164 000216E0 fe 08 effffffed5 callf $8,_writed ! 166: 165 000216E7 # writes(", subtest 1 (delayed store) - BAD FINAL ACC\n"); ! 167: 166 000216E7 .data 1 ! 168: 167 00000a7f * L242: ! 169: 168 00000a7f * 2C20737562746573742031202 .ascii ", subtest 1 (delayed store) - BAD FINAL ACC\12\0" ! 170: 864656C617965642073746F72 ! 171: 6529202D204241442046494E4 ! 172: 14C204143430A00 ! 173: 169 00000aac * .text ! 174: 170 000216E7 dd 8f00000a7f pushl $L242 ! 175: 171 000216ED fe 08 effffffec8 callf $8,_writes ! 176: 172 000216F4 # print_logf_data(); ! 177: 173 000216F4 fe 04 ef0000083b callf $4,_print_logf_data ! 178: 174 000216FB # writes(", data index = "); ! 179: 175 000216FB .data 1 ! 180: 176 00000aac * L244: ! 181: 177 00000aac * 2C20206461746120696E64657 .ascii ", data index = \0" ! 182: 8203D2000 ! 183: 178 00000abd * .text ! 184: 179 000216FB dd 8f00000aac pushl $L244 ! 185: 180 00021701 fe 08 effffffeb4 callf $8,_writes ! 186: 181 00021708 # writed( index ); ! 187: 182 00021708 dd effffffeae pushl _index ! 188: 183 0002170E fe 08 effffffea7 callf $8,_writed ! 189: 184 00021715 # writec('\n'); ! 190: 185 00021715 dd 0a pushl $10 ! 191: 186 00021717 fe 08 effffffe9e callf $8,_writec ! 192: 187 0002171E # writes(" expected = "); ! 193: 188 0002171E .data 1 ! 194: 189 00000abd * L246: ! 195: 190 00000abd * 2020202020202020202020202 .ascii " expected = \0" ! 196: 0202020202020202020202020 ! 197: 206578706563746564203D200 ! 198: 0 ! 199: 191 00000ae3 * .text ! 200: 192 0002171E dd 8f00000abd pushl $L246 ! 201: 193 00021724 fe 08 effffffe91 callf $8,_writes ! 202: 194 0002172B # write32h( sgl_expected ); ! 203: 195 0002172B dd effffffe8b pushl _sgl_expected ! 204: 196 00021731 fe 08 effffffe84 callf $8,_write32h ! 205: 197 00021738 # writec('\n'); ! 206: 198 00021738 dd 0a pushl $10 ! 207: 199 0002173A fe 08 effffffe7b callf $8,_writec ! 208: 200 00021741 # } ! 209: 201 00021741 # if ( halt_flg ) /* halt on error? */ ! 210: 202 00021741 L237: ! 211: 203 00021741 5d effffffe75 tstl _halt_flg ! 212: 204 00021747 31 09 jeql L248 ! 213: 205 00021749 # logf_er_halt( BAD_ACC_HLT ); ! 214: 206 00021749 dd 01 pushl $1 ! 215: 207 0002174B fe 08 ef00000820 callf $8,_logf_er_halt ! 216: 208 00021752 # if ( loop_on_err ) ! 217: 209 00021752 L248: ! 218: 210 00021752 5d effffffe64 tstl _loop_on_err ! 219: 211 00021758 31 0d jeql L250 ! 220: 212 0002175A # { ! 221: 213 0002175A # force_loop = TRUE; /* set the force loop flag */ ! 222: 214 0002175A 0d 01 effffffe5b movl $1,_force_loop ! 223: 215 00021761 # asm("jmp _logf_1_lp1"); /* and loop */ ! 224: 216 00021761 71 effffffef6 jmp _logf_1_lp1 ! 225: 217 00021767 # } ! 226: 218 00021767 # } /* end of compare error */ ! 227: 219 00021767 L250: ! 228: 220 00021767 # } while( index++ < max_logf_1_index ); ! 229: 221 00021767 L236: ! 230: 222 00021767 L233: ! 231: 223 00021767 0d effffffe4f 50 movl _index,r0 ! 232: 224 0002176E 6d effffffe48 incl _index ! 233: 225 00021774 1d 50 effffffe41 cmpl r0,_max_logf_1_index ! 234: 226 0002177B 81 03 13 feaa jlss L234 ! 235: 227 00021780 L232: ! 236: 228 00021780 # } /* end of subtest 1 */ ! 237: 229 00021780 40 ret#2 ! 238: 230 00021781 .set L228,0x0 ! 239: 231 00021781 L230: ! 240: 232 00021781 13 fe93 jbr L231 ! 241: 233 00021784 .data ! 242: 234 00000a60 * .text ! 243: 235 00021784 .align 1 ! 244: 236 00021784 .globl _logf_2 ! 245: 237 00021784 _logf_2: ! 246: 238 00021784 0000 .word L251 ! 247: 239 00021786 # ! 248: 240 00021786 # ! 249: 241 00021786 # ! 250: 242 00021786 # /*************************************************************************** ! 251: 243 00021786 # * ! 252: 244 00021786 # * SUBTEST 2 - LOGF FUNCTION ! 253: 245 00021786 # * ! 254: 246 00021786 # ***************************************************************************/ ! 255: 247 00021786 # logf_2() ! 256: 248 00021786 # { ! 257: 249 00021786 13 0158 jbr L253 ! 258: 250 00021789 L254: ! 259: 251 00021789 # force_loop = FALSE; /* clear the LOOP flag */ ! 260: 252 00021789 4d effffffe2d clrl _force_loop ! 261: 253 0002178F # subtest = 2; ! 262: 254 0002178F 0d 02 effffffe26 movl $2,_subtest ! 263: 255 00021796 # index = 0; ! 264: 256 00021796 4d effffffe20 clrl _index ! 265: 257 0002179C # do ! 266: 258 0002179C L257: ! 267: 259 0002179C # { ! 268: 260 0002179C # sgl_ld_acc = logf_1_data[index].ld; /* get the operand */ ! 269: 261 0002179C 0d effffffe1a 50 movl _index,r0 ! 270: 262 000217A3 48 03 50 50 shll $3,r0,r0 ! 271: 263 000217A7 0d e000000000 effffffe0a movl _logf_1_data(r0),_sgl_ld_acc ! 272: 264 000217B2 # sgl_expected = logf_1_data[index].exp; /* get expected results */ ! 273: 265 000217B2 0d effffffe04 50 movl _index,r0 ! 274: 266 000217B9 48 03 50 50 shll $3,r0,r0 ! 275: 267 000217BD 0d e000000004 effffffdf4 movl _logf_1_data+4(r0),_sgl_expected ! 276: 268 000217C8 # /* ! 277: 269 000217C8 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 278: 270 000217C8 # * The force loop flag is set after the first error. ! 279: 271 000217C8 # */ ! 280: 272 000217C8 # asm("_logf_2_lp1:"); ! 281: 273 000217C8 _logf_2_lp1: ! 282: 274 000217C8 # asm("movl _sgl_ld_acc,r4"); /* set the data to load */ ! 283: 275 000217C8 0d effffffdee 54 movl _sgl_ld_acc,r4 ! 284: 276 000217CF # asm("ldf r4"); /* load the accumulator */ ! 285: 277 000217CF 06 54 ldf r4 ! 286: 278 000217D1 # asm("logf"); /* get ACC.'s log */ ! 287: 279 000217D1 35 logf ! 288: 280 000217D2 # asm("stf r5"); /* store the result */ ! 289: 281 000217D2 26 55 stf r5 ! 290: 282 000217D4 # if( force_loop ) ! 291: 283 000217D4 5d effffffde2 tstl _force_loop ! 292: 284 000217DA 31 02 jeql L258 ! 293: 285 000217DC # asm("brb _logf_2_lp1");; /* loop on the error */ ! 294: 286 000217DC 11 ea brb _logf_2_lp1 ! 295: 287 000217DE L258: ! 296: 288 000217DE # /* ! 297: 289 000217DE # * end error loop ! 298: 290 000217DE # */ ! 299: 291 000217DE # asm("movl r5,_sgl_st_acc"); /* save the result */ ! 300: 292 000217DE 0d 55 effffffdd7 movl r5,_sgl_st_acc ! 301: 293 000217E5 # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 302: 294 000217E5 1d effffffdd1 effffffdcc cmpl _sgl_st_acc,_sgl_expected ! 303: 295 000217F0 21 03 13 00d2 jeql L259 ! 304: 296 000217F5 # errcnt++; /* bump the error count */ ! 305: 297 000217F5 6d effffffdc1 incl _errcnt ! 306: 298 000217FB # if ( prt_error ) { ! 307: 299 000217FB 5d effffffdbb tstl _prt_error ! 308: 300 00021801 21 03 13 009b jeql L260 ! 309: 301 00021806 # writes(" \n"); /* start a new print line */ ! 310: 302 00021806 .data 1 ! 311: 303 00000ae3 * L261: ! 312: 304 00000ae3 * 200A00 .ascii " \12\0" ! 313: 305 00000ae6 * .text ! 314: 306 00021806 dd 8f00000ae3 pushl $L261 ! 315: 307 0002180C fe 08 effffffda9 callf $8,_writes ! 316: 308 00021813 # writes("cycle: "); ! 317: 309 00021813 .data 1 ! 318: 310 00000ae6 * L262: ! 319: 311 00000ae6 * 6379636C653A2000 .ascii "cycle: \0" ! 320: 312 00000aee * .text ! 321: 313 00021813 dd 8f00000ae6 pushl $L262 ! 322: 314 00021819 fe 08 effffffd9c callf $8,_writes ! 323: 315 00021820 # writed( cycle ); ! 324: 316 00021820 dd effffffd96 pushl _cycle ! 325: 317 00021826 fe 08 effffffd8f callf $8,_writed ! 326: 318 0002182D # writes(" LOGF test "); ! 327: 319 0002182D .data 1 ! 328: 320 00000aee * L263: ! 329: 321 00000aee * 2020204C4F474620746573742 .ascii " LOGF test \0" ! 330: 000 ! 331: 322 00000afc * .text ! 332: 323 0002182D dd 8f00000aee pushl $L263 ! 333: 324 00021833 fe 08 effffffd82 callf $8,_writes ! 334: 325 0002183A # writed( test_no ); ! 335: 326 0002183A dd effffffd7c pushl _test_no ! 336: 327 00021840 fe 08 effffffd75 callf $8,_writed ! 337: 328 00021847 # writes(", subtest 2 (immediate store) - BAD FINAL ACC\n"); ! 338: 329 00021847 .data 1 ! 339: 330 00000afc * L264: ! 340: 331 00000afc * 2C20737562746573742032202 .ascii ", subtest 2 (immediate store) - BAD FINAL ACC\12\0" ! 341: 8696D6D656469617465207374 ! 342: 6F726529202D2042414420464 ! 343: 94E414C204143430A00 ! 344: 332 00000b2b * .text ! 345: 333 00021847 dd 8f00000afc pushl $L264 ! 346: 334 0002184D fe 08 effffffd68 callf $8,_writes ! 347: 335 00021854 # print_logf_data(); ! 348: 336 00021854 fe 04 ef000006db callf $4,_print_logf_data ! 349: 337 0002185B # writes(", data index = "); ! 350: 338 0002185B .data 1 ! 351: 339 00000b2b * L265: ! 352: 340 00000b2b * 2C20206461746120696E64657 .ascii ", data index = \0" ! 353: 8203D2000 ! 354: 341 00000b3c * .text ! 355: 342 0002185B dd 8f00000b2b pushl $L265 ! 356: 343 00021861 fe 08 effffffd54 callf $8,_writes ! 357: 344 00021868 # writed( index ); ! 358: 345 00021868 dd effffffd4e pushl _index ! 359: 346 0002186E fe 08 effffffd47 callf $8,_writed ! 360: 347 00021875 # writec('\n'); ! 361: 348 00021875 dd 0a pushl $10 ! 362: 349 00021877 fe 08 effffffd3e callf $8,_writec ! 363: 350 0002187E # writes(" expected = "); ! 364: 351 0002187E .data 1 ! 365: 352 00000b3c * L266: ! 366: 353 00000b3c * 2020202020202020202020202 .ascii " expected = \0" ! 367: 0202020202020202020202020 ! 368: 206578706563746564203D200 ! 369: 0 ! 370: 354 00000b62 * .text ! 371: 355 0002187E dd 8f00000b3c pushl $L266 ! 372: 356 00021884 fe 08 effffffd31 callf $8,_writes ! 373: 357 0002188B # write32h( sgl_expected ); ! 374: 358 0002188B dd effffffd2b pushl _sgl_expected ! 375: 359 00021891 fe 08 effffffd24 callf $8,_write32h ! 376: 360 00021898 # writec('\n'); ! 377: 361 00021898 dd 0a pushl $10 ! 378: 362 0002189A fe 08 effffffd1b callf $8,_writec ! 379: 363 000218A1 # } ! 380: 364 000218A1 # if ( halt_flg ) /* halt on error? */ ! 381: 365 000218A1 L260: ! 382: 366 000218A1 5d effffffd15 tstl _halt_flg ! 383: 367 000218A7 31 09 jeql L267 ! 384: 368 000218A9 # logf_er_halt( BAD_ACC_HLT ); ! 385: 369 000218A9 dd 01 pushl $1 ! 386: 370 000218AB fe 08 ef000006c0 callf $8,_logf_er_halt ! 387: 371 000218B2 # if ( loop_on_err ) ! 388: 372 000218B2 L267: ! 389: 373 000218B2 5d effffffd04 tstl _loop_on_err ! 390: 374 000218B8 31 0d jeql L268 ! 391: 375 000218BA # { ! 392: 376 000218BA # force_loop = TRUE; /* set the force loop flag */ ! 393: 377 000218BA 0d 01 effffffcfb movl $1,_force_loop ! 394: 378 000218C1 # asm("jmp _logf_2_lp1"); /* and loop */ ! 395: 379 000218C1 71 efffffff01 jmp _logf_2_lp1 ! 396: 380 000218C7 # } ! 397: 381 000218C7 # } /* end of compare error */ ! 398: 382 000218C7 L268: ! 399: 383 000218C7 # } while( index++ < max_logf_1_index ); ! 400: 384 000218C7 L259: ! 401: 385 000218C7 L256: ! 402: 386 000218C7 0d effffffcef 50 movl _index,r0 ! 403: 387 000218CE 6d effffffce8 incl _index ! 404: 388 000218D4 1d 50 effffffce1 cmpl r0,_max_logf_1_index ! 405: 389 000218DB 81 03 13 febc jlss L257 ! 406: 390 000218E0 L255: ! 407: 391 000218E0 # } /* end of subtest 2 */ ! 408: 392 000218E0 40 ret#2 ! 409: 393 000218E1 .set L251,0x0 ! 410: 394 000218E1 L253: ! 411: 395 000218E1 13 fea5 jbr L254 ! 412: 396 000218E4 .data ! 413: 397 00000a60 * .text ! 414: 398 000218E4 .align 1 ! 415: 399 000218E4 .globl _logf_3 ! 416: 400 000218E4 _logf_3: ! 417: 401 000218E4 0000 .word L269 ! 418: 402 000218E6 # ! 419: 403 000218E6 # ! 420: 404 000218E6 # ! 421: 405 000218E6 # /*************************************************************************** ! 422: 406 000218E6 # * ! 423: 407 000218E6 # * SUBTEST 3 - REGISTER INTEGRITY WITH THE LOGF FUNCTION ! 424: 408 000218E6 # * ! 425: 409 000218E6 # ***************************************************************************/ ! 426: 410 000218E6 # logf_3() ! 427: 411 000218E6 # { ! 428: 412 000218E6 13 01e1 jbr L271 ! 429: 413 000218E9 L272: ! 430: 414 000218E9 # fill_reg_buf( load_regs ); /* set reg values to load */ ! 431: 415 000218E9 dd 8f00000000 pushl $_load_regs ! 432: 416 000218EF fe 08 effffffcc6 callf $8,_fill_reg_buf ! 433: 417 000218F6 # force_loop = FALSE; /* clear the LOOP flag */ ! 434: 418 000218F6 4d effffffcc0 clrl _force_loop ! 435: 419 000218FC # subtest = 3; ! 436: 420 000218FC 0d 03 effffffcb9 movl $3,_subtest ! 437: 421 00021903 # index = 0; ! 438: 422 00021903 4d effffffcb3 clrl _index ! 439: 423 00021909 # do ! 440: 424 00021909 L276: ! 441: 425 00021909 # { ! 442: 426 00021909 # sgl_ld_acc = logf_1_data[index].ld; /* get the operand */ ! 443: 427 00021909 0d effffffcad 50 movl _index,r0 ! 444: 428 00021910 48 03 50 50 shll $3,r0,r0 ! 445: 429 00021914 0d e000000000 effffffc9d movl _logf_1_data(r0),_sgl_ld_acc ! 446: 430 0002191F # sgl_expected = logf_1_data[index].exp; /* get expected results */ ! 447: 431 0002191F 0d effffffc97 50 movl _index,r0 ! 448: 432 00021926 48 03 50 50 shll $3,r0,r0 ! 449: 433 0002192A 0d e000000004 effffffc87 movl _logf_1_data+4(r0),_sgl_expected ! 450: 434 00021935 # /* ! 451: 435 00021935 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 452: 436 00021935 # * The force loop flag is set after the first error. ! 453: 437 00021935 # */ ! 454: 438 00021935 # asm("_logf_3_lp1:"); ! 455: 439 00021935 _logf_3_lp1: ! 456: 440 00021935 # asm("loadr $0x1fff,_load_regs"); /* load regs 0 - 12 */ ! 457: 441 00021935 ab 891fff effffffc7e loadr $0x1fff,_load_regs ! 458: 442 0002193E # asm("ldf _sgl_ld_acc"); /* load the accumulator */ ! 459: 443 0002193E 06 effffffc78 ldf _sgl_ld_acc ! 460: 444 00021944 # asm("logf"); /* get ACC.'s log */ ! 461: 445 00021944 35 logf ! 462: 446 00021945 # asm("stf _sgl_st_acc"); /* store the result */ ! 463: 447 00021945 26 effffffc71 stf _sgl_st_acc ! 464: 448 0002194B # asm("storer $0x1fff,_store_regs"); /* store regs 0 - 12 */ ! 465: 449 0002194B bb 891fff effffffc68 storer $0x1fff,_store_regs ! 466: 450 00021954 # if( force_loop ) ! 467: 451 00021954 5d effffffc62 tstl _force_loop ! 468: 452 0002195A 31 02 jeql L277 ! 469: 453 0002195C # asm("brb _logf_3_lp1");; /* loop on the error */ ! 470: 454 0002195C 11 d7 brb _logf_3_lp1 ! 471: 455 0002195E L277: ! 472: 456 0002195E # /* ! 473: 457 0002195E # * end error loop ! 474: 458 0002195E # */ ! 475: 459 0002195E # reg_no = 0; ! 476: 460 0002195E 4d effffffc58 clrl _reg_no ! 477: 461 00021964 # regs_ok = TRUE; ! 478: 462 00021964 0d 01 effffffc51 movl $1,_regs_ok ! 479: 463 0002196B # while( (reg_no < 13) && (regs_ok) ) /* check 1st 12 regs */ ! 480: 464 0002196B L278: ! 481: 465 0002196B 1d effffffc4b 0d cmpl _reg_no,$13 ! 482: 466 00021972 81 35 jgeq L279 ! 483: 467 00021974 5d effffffc42 tstl _regs_ok ! 484: 468 0002197A 31 2d jeql L279 ! 485: 469 0002197C # if( store_regs[ reg_no ] == load_regs[ reg_no ] ) ! 486: 470 0002197C 0d effffffc3a 50 movl _reg_no,r0 ! 487: 471 00021983 0d effffffc33 51 movl _reg_no,r1 ! 488: 472 0002198A 1d 40effffffc2b cmpl _store_regs[r0],_load_regs[r1] ! 489: 41effffffc25 ! 490: 473 00021997 21 08 jneq L280 ! 491: 474 00021999 # reg_no++; ! 492: 475 00021999 6d effffffc1d incl _reg_no ! 493: 476 0002199F # else ! 494: 477 0002199F 11 06 jbr L281 ! 495: 478 000219A1 L280: ! 496: 479 000219A1 # regs_ok = FALSE; ! 497: 480 000219A1 4d effffffc15 clrl _regs_ok ! 498: 481 000219A7 L281: ! 499: 482 000219A7 11 c2 jbr L278 ! 500: 483 000219A9 L279: ! 501: 484 000219A9 # if( !regs_ok ) { ! 502: 485 000219A9 5d effffffc0d tstl _regs_ok ! 503: 486 000219AF 31 03 13 00fc jneq L282 ! 504: 487 000219B4 # errcnt++; /* bump the error count */ ! 505: 488 000219B4 6d effffffc02 incl _errcnt ! 506: 489 000219BA # if ( prt_error ) { ! 507: 490 000219BA 5d effffffbfc tstl _prt_error ! 508: 491 000219C0 21 03 13 00eb jeql L283 ! 509: 492 000219C5 # writes(" \n"); /* start a new print line */ ! 510: 493 000219C5 .data 1 ! 511: 494 00000b62 * L284: ! 512: 495 00000b62 * 200A00 .ascii " \12\0" ! 513: 496 00000b65 * .text ! 514: 497 000219C5 dd 8f00000b62 pushl $L284 ! 515: 498 000219CB fe 08 effffffbea callf $8,_writes ! 516: 499 000219D2 # writes("cycle: "); ! 517: 500 000219D2 .data 1 ! 518: 501 00000b65 * L285: ! 519: 502 00000b65 * 6379636C653A2000 .ascii "cycle: \0" ! 520: 503 00000b6d * .text ! 521: 504 000219D2 dd 8f00000b65 pushl $L285 ! 522: 505 000219D8 fe 08 effffffbdd callf $8,_writes ! 523: 506 000219DF # writed( cycle ); ! 524: 507 000219DF dd effffffbd7 pushl _cycle ! 525: 508 000219E5 fe 08 effffffbd0 callf $8,_writed ! 526: 509 000219EC # writes(" LOGF test "); ! 527: 510 000219EC .data 1 ! 528: 511 00000b6d * L286: ! 529: 512 00000b6d * 2020204C4F474620746573742 .ascii " LOGF test \0" ! 530: 000 ! 531: 513 00000b7b * .text ! 532: 514 000219EC dd 8f00000b6d pushl $L286 ! 533: 515 000219F2 fe 08 effffffbc3 callf $8,_writes ! 534: 516 000219F9 # writed( test_no ); ! 535: 517 000219F9 dd effffffbbd pushl _test_no ! 536: 518 000219FF fe 08 effffffbb6 callf $8,_writed ! 537: 519 00021A06 # writes(", subtest 3 - A REGISTER WAS MODIFIED\n"); { ! 538: 520 00021A06 .data 1 ! 539: 521 00000b7b * L287: ! 540: 522 00000b7b * 2C20737562746573742033202 .ascii ", subtest 3 - A REGISTER WAS MODIFIED\12\0" ! 541: D204120524547495354455220 ! 542: 574153204D4F4449464945440 ! 543: A00 ! 544: 523 00000ba2 * .text ! 545: 524 00021A06 dd 8f00000b7b pushl $L287 ! 546: 525 00021A0C fe 08 effffffba9 callf $8,_writes ! 547: 526 00021A13 # print_logf_data(); ! 548: 527 00021A13 fe 04 ef0000051c callf $4,_print_logf_data ! 549: 528 00021A1A # writec('\n'); ! 550: 529 00021A1A dd 0a pushl $10 ! 551: 530 00021A1C fe 08 effffffb99 callf $8,_writec ! 552: 531 00021A23 # writes("register "); ! 553: 532 00021A23 .data 1 ! 554: 533 00000ba2 * L288: ! 555: 534 00000ba2 * 72656769737465722000 .ascii "register \0" ! 556: 535 00000bac * .text ! 557: 536 00021A23 dd 8f00000ba2 pushl $L288 ! 558: 537 00021A29 fe 08 effffffb8c callf $8,_writes ! 559: 538 00021A30 # writed( reg_no ); ! 560: 539 00021A30 dd effffffb86 pushl _reg_no ! 561: 540 00021A36 fe 08 effffffb7f callf $8,_writed ! 562: 541 00021A3D # writes(" = "); ! 563: 542 00021A3D .data 1 ! 564: 543 00000bac * L289: ! 565: 544 00000bac * 203D2000 .ascii " = \0" ! 566: 545 00000bb0 * .text ! 567: 546 00021A3D dd 8f00000bac pushl $L289 ! 568: 547 00021A43 fe 08 effffffb72 callf $8,_writes ! 569: 548 00021A4A # write32h( load_regs[reg_no] ); ! 570: 549 00021A4A 0d effffffb6c 50 movl _reg_no,r0 ! 571: 550 00021A51 dd 40effffffb64 pushl _load_regs[r0] ! 572: 551 00021A58 fe 08 effffffb5d callf $8,_write32h ! 573: 552 00021A5F # writes(", should be = "); ! 574: 553 00021A5F .data 1 ! 575: 554 00000bb0 * L290: ! 576: 555 00000bb0 * 2C202073686F756C642062652 .ascii ", should be = \0" ! 577: 03D2000 ! 578: 556 00000bc0 * .text ! 579: 557 00021A5F dd 8f00000bb0 pushl $L290 ! 580: 558 00021A65 fe 08 effffffb50 callf $8,_writes ! 581: 559 00021A6C # write32h( store_regs[reg_no] ); ! 582: 560 00021A6C 0d effffffb4a 50 movl _reg_no,r0 ! 583: 561 00021A73 dd 40effffffb42 pushl _store_regs[r0] ! 584: 562 00021A7A fe 08 effffffb3b callf $8,_write32h ! 585: 563 00021A81 # writec('\n'); ! 586: 564 00021A81 dd 0a pushl $10 ! 587: 565 00021A83 fe 08 effffffb32 callf $8,_writec ! 588: 566 00021A8A # } ! 589: 567 00021A8A # if ( halt_flg ) /* halt on error? */ ! 590: 568 00021A8A 5d effffffb2c tstl _halt_flg ! 591: 569 00021A90 31 09 jeql L291 ! 592: 570 00021A92 # logf_er_halt( BAD_REG_HLT ); ! 593: 571 00021A92 dd 02 pushl $2 ! 594: 572 00021A94 fe 08 ef000004d7 callf $8,_logf_er_halt ! 595: 573 00021A9B # if ( loop_on_err ) ! 596: 574 00021A9B L291: ! 597: 575 00021A9B 5d effffffb1b tstl _loop_on_err ! 598: 576 00021AA1 31 0d jeql L292 ! 599: 577 00021AA3 # { ! 600: 578 00021AA3 # force_loop = TRUE; /* get the force loop flag */ ! 601: 579 00021AA3 0d 01 effffffb12 movl $1,_force_loop ! 602: 580 00021AAA # asm("jmp _logf_3_lp1"); /* and loop */ ! 603: 581 00021AAA 71 effffffe85 jmp _logf_3_lp1 ! 604: 582 00021AB0 # } ! 605: 583 00021AB0 # } /* end of compare error */ ! 606: 584 00021AB0 L292: ! 607: 585 00021AB0 # } /* end of while loop */ ! 608: 586 00021AB0 L283: ! 609: 587 00021AB0 # } while( index++ < max_logf_1_index ); ! 610: 588 00021AB0 L282: ! 611: 589 00021AB0 L275: ! 612: 590 00021AB0 0d effffffb06 50 movl _index,r0 ! 613: 591 00021AB7 6d effffffaff incl _index ! 614: 592 00021ABD 1d 50 effffffaf8 cmpl r0,_max_logf_1_index ! 615: 593 00021AC4 81 03 13 fe40 jlss L276 ! 616: 594 00021AC9 L274: ! 617: 595 00021AC9 # } /* end of subtest 3 */ ! 618: 596 00021AC9 40 ret#2 ! 619: 597 00021ACA .set L269,0x0 ! 620: 598 00021ACA L271: ! 621: 599 00021ACA 13 fe1c jbr L272 ! 622: 600 00021ACD .data ! 623: 601 00000a60 * .text ! 624: 602 00021ACD 00 .align 1 ! 625: 603 00021ACE .globl _logf_4 ! 626: 604 00021ACE _logf_4: ! 627: 605 00021ACE 0000 .word L293 ! 628: 606 00021AD0 # ! 629: 607 00021AD0 # ! 630: 608 00021AD0 # ! 631: 609 00021AD0 # /************************************************************************ ! 632: 610 00021AD0 # * ! 633: 611 00021AD0 # * SUBTEST 4 - Check for PSL corruption ! 634: 612 00021AD0 # * ! 635: 613 00021AD0 # ************************************************************************/ ! 636: 614 00021AD0 # logf_4() ! 637: 615 00021AD0 # { ! 638: 616 00021AD0 13 01a8 jbr L295 ! 639: 617 00021AD3 L296: ! 640: 618 00021AD3 # force_loop = FALSE; /* clear force_loop flg */ ! 641: 619 00021AD3 4d effffffae3 clrl _force_loop ! 642: 620 00021AD9 # subtest = 4; ! 643: 621 00021AD9 0d 04 effffffadc movl $4,_subtest ! 644: 622 00021AE0 # fill_reg_buf( load_regs ); /* get patterns for regs */ ! 645: 623 00021AE0 dd 8f00000000 pushl $_load_regs ! 646: 624 00021AE6 fe 08 effffffacf callf $8,_fill_reg_buf ! 647: 625 00021AED # for( index = 0; index < 3; index++ ) { ! 648: 626 00021AED 4d effffffac9 clrl _index ! 649: 627 00021AF3 L299: ! 650: 628 00021AF3 1d effffffac3 03 cmpl _index,$3 ! 651: 629 00021AFA 91 03 13 017b jgeq L298 ! 652: 630 00021AFF # sgl_ld_acc = logf_1_data[index].ld; /* get operand 1 */ ! 653: 631 00021AFF 0d effffffab7 50 movl _index,r0 ! 654: 632 00021B06 48 03 50 50 shll $3,r0,r0 ! 655: 633 00021B0A 0d e000000000 effffffaa7 movl _logf_1_data(r0),_sgl_ld_acc ! 656: 634 00021B15 # sgl_expected = logf_1_data[index].exp; /* get expected */ ! 657: 635 00021B15 0d effffffaa1 50 movl _index,r0 ! 658: 636 00021B1C 48 03 50 50 shll $3,r0,r0 ! 659: 637 00021B20 0d e000000004 effffffa91 movl _logf_1_data+4(r0),_sgl_expected ! 660: 638 00021B2B # sgl_dummy1 = status_array[status_index]; /* status = +, -, 0 */ ! 661: 639 00021B2B 0d effffffa8b 50 movl _status_index,r0 ! 662: 640 00021B32 0d 40effffffa83 movl _status_array[r0],_sgl_dummy1 ! 663: effffffa7e ! 664: 641 00021B3E # /* ! 665: 642 00021B3E # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 666: 643 00021B3E # * The force loop flag is set after the first error. ! 667: 644 00021B3E # */ ! 668: 645 00021B3E # asm("_logf_4_lp1:"); ! 669: 646 00021B3E _logf_4_lp1: ! 670: 647 00021B3E # asm("ldf _sgl_ld_acc"); /* LOAD the accumulator */ ! 671: 648 00021B3E 06 effffffa78 ldf _sgl_ld_acc ! 672: 649 00021B44 # asm("nop"); ! 673: 650 00021B44 10 nop ! 674: 651 00021B45 # asm("tstl _sgl_dummy1"); /* set the PSL status */ ! 675: 652 00021B45 5d effffffa71 tstl _sgl_dummy1 ! 676: 653 00021B4B # asm("movpsl _init_psl"); /* save the initial PSL */ ! 677: 654 00021B4B cd effffffa6b movpsl _init_psl ! 678: 655 00021B51 # asm("logf"); /* do the log */ ! 679: 656 00021B51 35 logf ! 680: 657 00021B52 # asm("nop"); ! 681: 658 00021B52 10 nop ! 682: 659 00021B53 # asm("movpsl _psl_val"); /* save the final PSL */ ! 683: 660 00021B53 cd effffffa63 movpsl _psl_val ! 684: 661 00021B59 # asm("stf _sgl_st_acc"); /* save the accumulator */ ! 685: 662 00021B59 26 effffffa5d stf _sgl_st_acc ! 686: 663 00021B5F # if( force_loop ) ! 687: 664 00021B5F 5d effffffa57 tstl _force_loop ! 688: 665 00021B65 31 02 jeql L300 ! 689: 666 00021B67 # asm("brb _logf_4_lp1");; /* loop on the error */ ! 690: 667 00021B67 11 d5 brb _logf_4_lp1 ! 691: 668 00021B69 L300: ! 692: 669 00021B69 # /* ! 693: 670 00021B69 # * Now compare the final PSL to the initial PSL -they should be the same ! 694: 671 00021B69 # */ ! 695: 672 00021B69 # exp_psl = init_psl; ! 696: 673 00021B69 0d effffffa4d effffffa48 movl _init_psl,_exp_psl ! 697: 674 00021B74 # if( psl_val != exp_psl ) { ! 698: 675 00021B74 1d effffffa42 effffffa3d cmpl _psl_val,_exp_psl ! 699: 676 00021B7F 21 03 13 00ed jeql L301 ! 700: 677 00021B84 # errcnt++; /* bump the error count */ ! 701: 678 00021B84 6d effffffa32 incl _errcnt ! 702: 679 00021B8A # if( prt_error ) { ! 703: 680 00021B8A 5d effffffa2c tstl _prt_error ! 704: 681 00021B90 21 03 13 00b9 jeql L302 ! 705: 682 00021B95 # writes(" \n"); /* start a new print line */ ! 706: 683 00021B95 .data 1 ! 707: 684 00000bc0 * L303: ! 708: 685 00000bc0 * 200A00 .ascii " \12\0" ! 709: 686 00000bc3 * .text ! 710: 687 00021B95 dd 8f00000bc0 pushl $L303 ! 711: 688 00021B9B fe 08 effffffa1a callf $8,_writes ! 712: 689 00021BA2 # writes("cycle: "); ! 713: 690 00021BA2 .data 1 ! 714: 691 00000bc3 * L304: ! 715: 692 00000bc3 * 6379636C653A2000 .ascii "cycle: \0" ! 716: 693 00000bcb * .text ! 717: 694 00021BA2 dd 8f00000bc3 pushl $L304 ! 718: 695 00021BA8 fe 08 effffffa0d callf $8,_writes ! 719: 696 00021BAF # writed( cycle ); ! 720: 697 00021BAF dd effffffa07 pushl _cycle ! 721: 698 00021BB5 fe 08 effffffa00 callf $8,_writed ! 722: 699 00021BBC # writes(" LOGF test "); ! 723: 700 00021BBC .data 1 ! 724: 701 00000bcb * L305: ! 725: 702 00000bcb * 2020204C4F474620746573742 .ascii " LOGF test \0" ! 726: 000 ! 727: 703 00000bd9 * .text ! 728: 704 00021BBC dd 8f00000bcb pushl $L305 ! 729: 705 00021BC2 fe 08 effffff9f3 callf $8,_writes ! 730: 706 00021BC9 # writed( test_no ); ! 731: 707 00021BC9 dd effffff9ed pushl _test_no ! 732: 708 00021BCF fe 08 effffff9e6 callf $8,_writed ! 733: 709 00021BD6 # writes(", subtest 4 - INCORRECT FINAL PSL\n"); ! 734: 710 00021BD6 .data 1 ! 735: 711 00000bd9 * L306: ! 736: 712 00000bd9 * 2C20737562746573742034202 .ascii ", subtest 4 - INCORRECT FINAL PSL\12\0" ! 737: D20494E434F52524543542046 ! 738: 494E414C2050534C0A00 ! 739: 713 00000bfc * .text ! 740: 714 00021BD6 dd 8f00000bd9 pushl $L306 ! 741: 715 00021BDC fe 08 effffff9d9 callf $8,_writes ! 742: 716 00021BE3 # print_logf_data(); /* print the operands */ ! 743: 717 00021BE3 fe 04 ef0000034c callf $4,_print_logf_data ! 744: 718 00021BEA # writec('\n'); ! 745: 719 00021BEA dd 0a pushl $10 ! 746: 720 00021BEC fe 08 effffff9c9 callf $8,_writec ! 747: 721 00021BF3 # writes("initial PSL = "); ! 748: 722 00021BF3 .data 1 ! 749: 723 00000bfc * L307: ! 750: 724 00000bfc * 696E697469616C2050534C203 .ascii "initial PSL = \0" ! 751: D2000 ! 752: 725 00000c0b * .text ! 753: 726 00021BF3 dd 8f00000bfc pushl $L307 ! 754: 727 00021BF9 fe 08 effffff9bc callf $8,_writes ! 755: 728 00021C00 # write32h( init_psl ); ! 756: 729 00021C00 dd effffff9b6 pushl _init_psl ! 757: 730 00021C06 fe 08 effffff9af callf $8,_write32h ! 758: 731 00021C0D # writes(", final PSL = "); ! 759: 732 00021C0D .data 1 ! 760: 733 00000c0b * L308: ! 761: 734 00000c0b * 2C202066696E616C2050534C2 .ascii ", final PSL = \0" ! 762: 03D2000 ! 763: 735 00000c1b * .text ! 764: 736 00021C0D dd 8f00000c0b pushl $L308 ! 765: 737 00021C13 fe 08 effffff9a2 callf $8,_writes ! 766: 738 00021C1A # write32h( psl_val ); ! 767: 739 00021C1A dd effffff99c pushl _psl_val ! 768: 740 00021C20 fe 08 effffff995 callf $8,_write32h ! 769: 741 00021C27 # writes(", expected PSL = "); ! 770: 742 00021C27 .data 1 ! 771: 743 00000c1b * L309: ! 772: 744 00000c1b * 2C20206578706563746564205 .ascii ", expected PSL = \0" ! 773: 0534C203D2000 ! 774: 745 00000c2e * .text ! 775: 746 00021C27 dd 8f00000c1b pushl $L309 ! 776: 747 00021C2D fe 08 effffff988 callf $8,_writes ! 777: 748 00021C34 # write32h( exp_psl ); ! 778: 749 00021C34 dd effffff982 pushl _exp_psl ! 779: 750 00021C3A fe 08 effffff97b callf $8,_write32h ! 780: 751 00021C41 # writes("\n"); ! 781: 752 00021C41 .data 1 ! 782: 753 00000c2e * L310: ! 783: 754 00000c2e * 0A00 .ascii "\12\0" ! 784: 755 00000c30 * .text ! 785: 756 00021C41 dd 8f00000c2e pushl $L310 ! 786: 757 00021C47 fe 08 effffff96e callf $8,_writes ! 787: 758 00021C4E # } ! 788: 759 00021C4E # if( halt_flg ) ! 789: 760 00021C4E L302: ! 790: 761 00021C4E 5d effffff968 tstl _halt_flg ! 791: 762 00021C54 31 09 jeql L311 ! 792: 763 00021C56 # logf_er_halt( BAD_PSL_HLT ); /* halt on the error */ ! 793: 764 00021C56 dd 03 pushl $3 ! 794: 765 00021C58 fe 08 ef00000313 callf $8,_logf_er_halt ! 795: 766 00021C5F # if( loop_on_err ) { ! 796: 767 00021C5F L311: ! 797: 768 00021C5F 5d effffff957 tstl _loop_on_err ! 798: 769 00021C65 31 0a jeql L312 ! 799: 770 00021C67 # force_loop = TRUE; /* set the force loop flag */ ! 800: 771 00021C67 0d 01 effffff94e movl $1,_force_loop ! 801: 772 00021C6E # asm("brw _logf_4_lp1");; /* and loop on the error */ ! 802: 773 00021C6E 13 fecd brw _logf_4_lp1 ! 803: 774 00021C71 # } /* end of loop on error */ ! 804: 775 00021C71 # } /* end of PSL corruption error */ ! 805: 776 00021C71 L312: ! 806: 777 00021C71 # } /* end of WHILE loop */ ! 807: 778 00021C71 L301: ! 808: 779 00021C71 L297: ! 809: 780 00021C71 6d effffff945 incl _index ! 810: 781 00021C77 13 fe79 jbr L299 ! 811: 782 00021C7A L298: ! 812: 783 00021C7A # } /* end of subtest 4 */ ! 813: 784 00021C7A 40 ret#2 ! 814: 785 00021C7B .set L293,0x0 ! 815: 786 00021C7B L295: ! 816: 787 00021C7B 13 fe55 jbr L296 ! 817: 788 00021C7E .data ! 818: 789 00000a60 * .text ! 819: 790 00021C7E .align 1 ! 820: 791 00021C7E .globl _logf_5 ! 821: 792 00021C7E _logf_5: ! 822: 793 00021C7E 0000 .word L313 ! 823: 794 00021C80 # ! 824: 795 00021C80 # ! 825: 796 00021C80 # ! 826: 797 00021C80 # /************************************************************************ ! 827: 798 00021C80 # * ! 828: 799 00021C80 # * SUBTEST 5 - pipelined entry test ! 829: 800 00021C80 # * ! 830: 801 00021C80 # ************************************************************************/ ! 831: 802 00021C80 # logf_5() ! 832: 803 00021C80 # { ! 833: 804 00021C80 13 0154 jbr L315 ! 834: 805 00021C83 L316: ! 835: 806 00021C83 # force_loop = FALSE; ! 836: 807 00021C83 4d effffff933 clrl _force_loop ! 837: 808 00021C89 # subtest = 8; ! 838: 809 00021C89 0d 08 effffff92c movl $8,_subtest ! 839: 810 00021C90 # for( index = 0; index < max_logf_1_index; index++ ) { ! 840: 811 00021C90 4d effffff926 clrl _index ! 841: 812 00021C96 L319: ! 842: 813 00021C96 1d effffff920 effffff91b cmpl _index,_max_logf_1_index ! 843: 814 00021CA1 91 03 13 0130 jgeq L318 ! 844: 815 00021CA6 # sgl_ld_acc = logf_1_data[index].ld; /* get operand 1 */ ! 845: 816 00021CA6 0d effffff910 50 movl _index,r0 ! 846: 817 00021CAD 48 03 50 50 shll $3,r0,r0 ! 847: 818 00021CB1 0d e000000000 effffff900 movl _logf_1_data(r0),_sgl_ld_acc ! 848: 819 00021CBC # sgl_expected = logf_1_data[index].exp; /* get expected result */ ! 849: 820 00021CBC 0d effffff8fa 50 movl _index,r0 ! 850: 821 00021CC3 48 03 50 50 shll $3,r0,r0 ! 851: 822 00021CC7 0d e000000004 effffff8ea movl _logf_1_data+4(r0),_sgl_expected ! 852: 823 00021CD2 # /* ! 853: 824 00021CD2 # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 854: 825 00021CD2 # * The force loop flag is set after the first error. ! 855: 826 00021CD2 # */ ! 856: 827 00021CD2 # asm("_logf_5_lp1:"); ! 857: 828 00021CD2 _logf_5_lp1: ! 858: 829 00021CD2 # asm("movl $0,r0"); /* clear r0 */ ! 859: 830 00021CD2 0d 00 50 movl $0,r0 ! 860: 831 00021CD5 # asm("ldf r0"); /* load the Acc. with 0.0 */ ! 861: 832 00021CD5 06 50 ldf r0 ! 862: 833 00021CD7 # asm("addf _sgl_ld_acc"); /* add the 1st operand */ ! 863: 834 00021CD7 c6 effffff8df addf _sgl_ld_acc ! 864: 835 00021CDD # asm("logf"); /* get the log */ ! 865: 836 00021CDD 35 logf ! 866: 837 00021CDE # asm("stf _sgl_st_acc"); /* store the result */ ! 867: 838 00021CDE 26 effffff8d8 stf _sgl_st_acc ! 868: 839 00021CE4 # if( force_loop ) ! 869: 840 00021CE4 5d effffff8d2 tstl _force_loop ! 870: 841 00021CEA 31 02 jeql L320 ! 871: 842 00021CEC # asm("brb _logf_5_lp1");; /* loop on the error */ ! 872: 843 00021CEC 11 e4 brb _logf_5_lp1 ! 873: 844 00021CEE L320: ! 874: 845 00021CEE # /* ! 875: 846 00021CEE # * end error loop - test the results ! 876: 847 00021CEE # */ ! 877: 848 00021CEE # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 878: 849 00021CEE 1d effffff8c8 effffff8c3 cmpl _sgl_st_acc,_sgl_expected ! 879: 850 00021CF9 21 03 13 00cf jeql L321 ! 880: 851 00021CFE # errcnt++; /* bump the error count */ ! 881: 852 00021CFE 6d effffff8b8 incl _errcnt ! 882: 853 00021D04 # if( prt_error ) { ! 883: 854 00021D04 5d effffff8b2 tstl _prt_error ! 884: 855 00021D0A 21 03 13 009b jeql L322 ! 885: 856 00021D0F # writes(" \n"); /* start a new print line */ ! 886: 857 00021D0F .data 1 ! 887: 858 00000c30 * L323: ! 888: 859 00000c30 * 200A00 .ascii " \12\0" ! 889: 860 00000c33 * .text ! 890: 861 00021D0F dd 8f00000c30 pushl $L323 ! 891: 862 00021D15 fe 08 effffff8a0 callf $8,_writes ! 892: 863 00021D1C # writes("cycle: "); ! 893: 864 00021D1C .data 1 ! 894: 865 00000c33 * L324: ! 895: 866 00000c33 * 6379636C653A2000 .ascii "cycle: \0" ! 896: 867 00000c3b * .text ! 897: 868 00021D1C dd 8f00000c33 pushl $L324 ! 898: 869 00021D22 fe 08 effffff893 callf $8,_writes ! 899: 870 00021D29 # writed( cycle ); ! 900: 871 00021D29 dd effffff88d pushl _cycle ! 901: 872 00021D2F fe 08 effffff886 callf $8,_writed ! 902: 873 00021D36 # writes(" LOGF test "); ! 903: 874 00021D36 .data 1 ! 904: 875 00000c3b * L325: ! 905: 876 00000c3b * 2020204C4F474620746573742 .ascii " LOGF test \0" ! 906: 000 ! 907: 877 00000c49 * .text ! 908: 878 00021D36 dd 8f00000c3b pushl $L325 ! 909: 879 00021D3C fe 08 effffff879 callf $8,_writes ! 910: 880 00021D43 # writed( test_no ); ! 911: 881 00021D43 dd effffff873 pushl _test_no ! 912: 882 00021D49 fe 08 effffff86c callf $8,_writed ! 913: 883 00021D50 # writes(", subtest 5 (Piped Entry) - BAD FINAL ACC\n"); ! 914: 884 00021D50 .data 1 ! 915: 885 00000c49 * L326: ! 916: 886 00000c49 * 2C20737562746573742035202 .ascii ", subtest 5 (Piped Entry) - BAD FINAL ACC\12\0" ! 917: 8506970656420456E74727929 ! 918: 202D204241442046494E414C2 ! 919: 04143430A00 ! 920: 887 00000c74 * .text ! 921: 888 00021D50 dd 8f00000c49 pushl $L326 ! 922: 889 00021D56 fe 08 effffff85f callf $8,_writes ! 923: 890 00021D5D # print_logf_data(); ! 924: 891 00021D5D fe 04 ef000001d2 callf $4,_print_logf_data ! 925: 892 00021D64 # writes(", data index = "); ! 926: 893 00021D64 .data 1 ! 927: 894 00000c74 * L327: ! 928: 895 00000c74 * 2C20206461746120696E64657 .ascii ", data index = \0" ! 929: 8203D2000 ! 930: 896 00000c85 * .text ! 931: 897 00021D64 dd 8f00000c74 pushl $L327 ! 932: 898 00021D6A fe 08 effffff84b callf $8,_writes ! 933: 899 00021D71 # writed( index ); ! 934: 900 00021D71 dd effffff845 pushl _index ! 935: 901 00021D77 fe 08 effffff83e callf $8,_writed ! 936: 902 00021D7E # writec('\n'); ! 937: 903 00021D7E dd 0a pushl $10 ! 938: 904 00021D80 fe 08 effffff835 callf $8,_writec ! 939: 905 00021D87 # writes(" expected = "); ! 940: 906 00021D87 .data 1 ! 941: 907 00000c85 * L328: ! 942: 908 00000c85 * 2020202020202020202020202 .ascii " expected = \0" ! 943: 0202020202020202020202020 ! 944: 206578706563746564203D200 ! 945: 0 ! 946: 909 00000cab * .text ! 947: 910 00021D87 dd 8f00000c85 pushl $L328 ! 948: 911 00021D8D fe 08 effffff828 callf $8,_writes ! 949: 912 00021D94 # write32h( sgl_expected ); ! 950: 913 00021D94 dd effffff822 pushl _sgl_expected ! 951: 914 00021D9A fe 08 effffff81b callf $8,_write32h ! 952: 915 00021DA1 # writec('\n'); ! 953: 916 00021DA1 dd 0a pushl $10 ! 954: 917 00021DA3 fe 08 effffff812 callf $8,_writec ! 955: 918 00021DAA # } ! 956: 919 00021DAA # if( halt_flg ) ! 957: 920 00021DAA L322: ! 958: 921 00021DAA 5d effffff80c tstl _halt_flg ! 959: 922 00021DB0 31 09 jeql L329 ! 960: 923 00021DB2 # logf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 961: 924 00021DB2 dd 01 pushl $1 ! 962: 925 00021DB4 fe 08 ef000001b7 callf $8,_logf_er_halt ! 963: 926 00021DBB # if( loop_on_err ) { ! 964: 927 00021DBB L329: ! 965: 928 00021DBB 5d effffff7fb tstl _loop_on_err ! 966: 929 00021DC1 31 0a jeql L330 ! 967: 930 00021DC3 # force_loop = TRUE; /* set the force loop flag */ ! 968: 931 00021DC3 0d 01 effffff7f2 movl $1,_force_loop ! 969: 932 00021DCA # asm("brw _logf_5_lp1");; /* and loop on the error */ ! 970: 933 00021DCA 13 ff05 brw _logf_5_lp1 ! 971: 934 00021DCD # } /* end of loop on error */ ! 972: 935 00021DCD # } /* end of compare error */ ! 973: 936 00021DCD L330: ! 974: 937 00021DCD # } /* end of WHILE loop */ ! 975: 938 00021DCD L321: ! 976: 939 00021DCD L317: ! 977: 940 00021DCD 6d effffff7e9 incl _index ! 978: 941 00021DD3 13 fec0 jbr L319 ! 979: 942 00021DD6 L318: ! 980: 943 00021DD6 # } /* end of subtest 5 */ ! 981: 944 00021DD6 40 ret#2 ! 982: 945 00021DD7 .set L313,0x0 ! 983: 946 00021DD7 L315: ! 984: 947 00021DD7 13 fea9 jbr L316 ! 985: 948 00021DDA .data ! 986: 949 00000a60 * .text ! 987: 950 00021DDA .align 1 ! 988: 951 00021DDA .globl _logf_6 ! 989: 952 00021DDA _logf_6: ! 990: 953 00021DDA 0000 .word L331 ! 991: 954 00021DDC # ! 992: 955 00021DDC # ! 993: 956 00021DDC # ! 994: 957 00021DDC # /************************************************************************ ! 995: 958 00021DDC # * ! 996: 959 00021DDC # * SUBTEST 6 - pipelined exit test ! 997: 960 00021DDC # * ! 998: 961 00021DDC # ************************************************************************/ ! 999: 962 00021DDC # logf_6() ! 1000: 963 00021DDC # { ! 1001: 964 00021DDC 13 0154 jbr L333 ! 1002: 965 00021DDF L334: ! 1003: 966 00021DDF # force_loop = FALSE; ! 1004: 967 00021DDF 4d effffff7d7 clrl _force_loop ! 1005: 968 00021DE5 # subtest = 8; ! 1006: 969 00021DE5 0d 08 effffff7d0 movl $8,_subtest ! 1007: 970 00021DEC # for( index = 0; index < max_logf_1_index; index++ ) { ! 1008: 971 00021DEC 4d effffff7ca clrl _index ! 1009: 972 00021DF2 L337: ! 1010: 973 00021DF2 1d effffff7c4 effffff7bf cmpl _index,_max_logf_1_index ! 1011: 974 00021DFD 91 03 13 0130 jgeq L336 ! 1012: 975 00021E02 # sgl_ld_acc = logf_1_data[index].ld; /* get operand 1 */ ! 1013: 976 00021E02 0d effffff7b4 50 movl _index,r0 ! 1014: 977 00021E09 48 03 50 50 shll $3,r0,r0 ! 1015: 978 00021E0D 0d e000000000 effffff7a4 movl _logf_1_data(r0),_sgl_ld_acc ! 1016: 979 00021E18 # sgl_expected = logf_1_data[index].exp; /* get expected result */ ! 1017: 980 00021E18 0d effffff79e 50 movl _index,r0 ! 1018: 981 00021E1F 48 03 50 50 shll $3,r0,r0 ! 1019: 982 00021E23 0d e000000004 effffff78e movl _logf_1_data+4(r0),_sgl_expected ! 1020: 983 00021E2E # /* ! 1021: 984 00021E2E # * If LOOP ON ERROR is set, this is the loop for this subtest. ! 1022: 985 00021E2E # * The force loop flag is set after the first error. ! 1023: 986 00021E2E # */ ! 1024: 987 00021E2E # asm("_logf_6_lp1:"); ! 1025: 988 00021E2E _logf_6_lp1: ! 1026: 989 00021E2E # asm("movl $0,r0"); /* clear r0 */ ! 1027: 990 00021E2E 0d 00 50 movl $0,r0 ! 1028: 991 00021E31 # asm("ldf _sgl_ld_acc"); /* load the Acc. */ ! 1029: 992 00021E31 06 effffff785 ldf _sgl_ld_acc ! 1030: 993 00021E37 # asm("logf"); /* get the log */ ! 1031: 994 00021E37 35 logf ! 1032: 995 00021E38 # asm("addf r0"); /* add a zero to the acc */ ! 1033: 996 00021E38 c6 50 addf r0 ! 1034: 997 00021E3A # asm("stf _sgl_st_acc"); /* store the result */ ! 1035: 998 00021E3A 26 effffff77c stf _sgl_st_acc ! 1036: 999 00021E40 # if( force_loop ) ! 1037: 1000 00021E40 5d effffff776 tstl _force_loop ! 1038: 1001 00021E46 31 02 jeql L338 ! 1039: 1002 00021E48 # asm("brb _logf_6_lp1");; /* loop on the error */ ! 1040: 1003 00021E48 11 e4 brb _logf_6_lp1 ! 1041: 1004 00021E4A L338: ! 1042: 1005 00021E4A # /* ! 1043: 1006 00021E4A # * end error loop - test the results ! 1044: 1007 00021E4A # */ ! 1045: 1008 00021E4A # if( sgl_st_acc != sgl_expected ) { /* COMPARE the values */ ! 1046: 1009 00021E4A 1d effffff76c effffff767 cmpl _sgl_st_acc,_sgl_expected ! 1047: 1010 00021E55 21 03 13 00cf jeql L339 ! 1048: 1011 00021E5A # errcnt++; /* bump the error count */ ! 1049: 1012 00021E5A 6d effffff75c incl _errcnt ! 1050: 1013 00021E60 # if( prt_error ) { ! 1051: 1014 00021E60 5d effffff756 tstl _prt_error ! 1052: 1015 00021E66 21 03 13 009b jeql L340 ! 1053: 1016 00021E6B # writes(" \n"); /* start a new print line */ ! 1054: 1017 00021E6B .data 1 ! 1055: 1018 00000cab * L341: ! 1056: 1019 00000cab * 200A00 .ascii " \12\0" ! 1057: 1020 00000cae * .text ! 1058: 1021 00021E6B dd 8f00000cab pushl $L341 ! 1059: 1022 00021E71 fe 08 effffff744 callf $8,_writes ! 1060: 1023 00021E78 # writes("cycle: "); ! 1061: 1024 00021E78 .data 1 ! 1062: 1025 00000cae * L342: ! 1063: 1026 00000cae * 6379636C653A2000 .ascii "cycle: \0" ! 1064: 1027 00000cb6 * .text ! 1065: 1028 00021E78 dd 8f00000cae pushl $L342 ! 1066: 1029 00021E7E fe 08 effffff737 callf $8,_writes ! 1067: 1030 00021E85 # writed( cycle ); ! 1068: 1031 00021E85 dd effffff731 pushl _cycle ! 1069: 1032 00021E8B fe 08 effffff72a callf $8,_writed ! 1070: 1033 00021E92 # writes(" LOGF test "); ! 1071: 1034 00021E92 .data 1 ! 1072: 1035 00000cb6 * L343: ! 1073: 1036 00000cb6 * 2020204C4F474620746573742 .ascii " LOGF test \0" ! 1074: 000 ! 1075: 1037 00000cc4 * .text ! 1076: 1038 00021E92 dd 8f00000cb6 pushl $L343 ! 1077: 1039 00021E98 fe 08 effffff71d callf $8,_writes ! 1078: 1040 00021E9F # writed( test_no ); ! 1079: 1041 00021E9F dd effffff717 pushl _test_no ! 1080: 1042 00021EA5 fe 08 effffff710 callf $8,_writed ! 1081: 1043 00021EAC # writes(", subtest 6 (Piped Exit) - BAD FINAL ACC\n"); ! 1082: 1044 00021EAC .data 1 ! 1083: 1045 00000cc4 * L344: ! 1084: 1046 00000cc4 * 2C20737562746573742036202 .ascii ", subtest 6 (Piped Exit) - BAD FINAL ACC\12\0" ! 1085: 8506970656420457869742920 ! 1086: 2D204241442046494E414C204 ! 1087: 143430A00 ! 1088: 1047 00000cee * .text ! 1089: 1048 00021EAC dd 8f00000cc4 pushl $L344 ! 1090: 1049 00021EB2 fe 08 effffff703 callf $8,_writes ! 1091: 1050 00021EB9 # print_logf_data(); ! 1092: 1051 00021EB9 fe 04 ef00000076 callf $4,_print_logf_data ! 1093: 1052 00021EC0 # writes(", data index = "); ! 1094: 1053 00021EC0 .data 1 ! 1095: 1054 00000cee * L345: ! 1096: 1055 00000cee * 2C20206461746120696E64657 .ascii ", data index = \0" ! 1097: 8203D2000 ! 1098: 1056 00000cff * .text ! 1099: 1057 00021EC0 dd 8f00000cee pushl $L345 ! 1100: 1058 00021EC6 fe 08 effffff6ef callf $8,_writes ! 1101: 1059 00021ECD # writed( index ); ! 1102: 1060 00021ECD dd effffff6e9 pushl _index ! 1103: 1061 00021ED3 fe 08 effffff6e2 callf $8,_writed ! 1104: 1062 00021EDA # writec('\n'); ! 1105: 1063 00021EDA dd 0a pushl $10 ! 1106: 1064 00021EDC fe 08 effffff6d9 callf $8,_writec ! 1107: 1065 00021EE3 # writes(" expected = "); ! 1108: 1066 00021EE3 .data 1 ! 1109: 1067 00000cff * L346: ! 1110: 1068 00000cff * 2020202020202020202020202 .ascii " expected = \0" ! 1111: 0202020202020202020202020 ! 1112: 206578706563746564203D200 ! 1113: 0 ! 1114: 1069 00000d25 * .text ! 1115: 1070 00021EE3 dd 8f00000cff pushl $L346 ! 1116: 1071 00021EE9 fe 08 effffff6cc callf $8,_writes ! 1117: 1072 00021EF0 # write32h( sgl_expected ); ! 1118: 1073 00021EF0 dd effffff6c6 pushl _sgl_expected ! 1119: 1074 00021EF6 fe 08 effffff6bf callf $8,_write32h ! 1120: 1075 00021EFD # writec('\n'); ! 1121: 1076 00021EFD dd 0a pushl $10 ! 1122: 1077 00021EFF fe 08 effffff6b6 callf $8,_writec ! 1123: 1078 00021F06 # } ! 1124: 1079 00021F06 # if( halt_flg ) ! 1125: 1080 00021F06 L340: ! 1126: 1081 00021F06 5d effffff6b0 tstl _halt_flg ! 1127: 1082 00021F0C 31 09 jeql L347 ! 1128: 1083 00021F0E # logf_er_halt( BAD_ACC_HLT ); /* halt on the error */ ! 1129: 1084 00021F0E dd 01 pushl $1 ! 1130: 1085 00021F10 fe 08 ef0000005b callf $8,_logf_er_halt ! 1131: 1086 00021F17 # if( loop_on_err ) { ! 1132: 1087 00021F17 L347: ! 1133: 1088 00021F17 5d effffff69f tstl _loop_on_err ! 1134: 1089 00021F1D 31 0a jeql L348 ! 1135: 1090 00021F1F # force_loop = TRUE; /* set the force loop flag */ ! 1136: 1091 00021F1F 0d 01 effffff696 movl $1,_force_loop ! 1137: 1092 00021F26 # asm("brw _logf_6_lp1");; /* and loop on the error */ ! 1138: 1093 00021F26 13 ff05 brw _logf_6_lp1 ! 1139: 1094 00021F29 # } /* end of loop on error */ ! 1140: 1095 00021F29 # } /* end of compare error */ ! 1141: 1096 00021F29 L348: ! 1142: 1097 00021F29 # } /* end of WHILE loop */ ! 1143: 1098 00021F29 L339: ! 1144: 1099 00021F29 L335: ! 1145: 1100 00021F29 6d effffff68d incl _index ! 1146: 1101 00021F2F 13 fec0 jbr L337 ! 1147: 1102 00021F32 L336: ! 1148: 1103 00021F32 # } /* end of subtest 6 */ ! 1149: 1104 00021F32 40 ret#2 ! 1150: 1105 00021F33 .set L331,0x0 ! 1151: 1106 00021F33 L333: ! 1152: 1107 00021F33 13 fea9 jbr L334 ! 1153: 1108 00021F36 .data ! 1154: 1109 00000a60 * .text ! 1155: 1110 00021F36 .align 1 ! 1156: 1111 00021F36 .globl _print_logf_data ! 1157: 1112 00021F36 _print_logf_data: ! 1158: 1113 00021F36 0000 .word L349 ! 1159: 1114 00021F38 # ! 1160: 1115 00021F38 # ! 1161: 1116 00021F38 # /************************************************************************** ! 1162: 1117 00021F38 # * ! 1163: 1118 00021F38 # * PRINT THE DATA AND STORE RESULTS ! 1164: 1119 00021F38 # * ! 1165: 1120 00021F38 # * initial Acc = xxxxxxxx, stored = xxxxxxxx, data index = xx ! 1166: 1121 00021F38 # * Acc expected = xxxxxxxx ! 1167: 1122 00021F38 # **************************************************************************/ ! 1168: 1123 00021F38 # print_logf_data() ! 1169: 1124 00021F38 # { ! 1170: 1125 00021F38 11 35 jbr L351 ! 1171: 1126 00021F3A L352: ! 1172: 1127 00021F3A # writes("initial Acc = "); ! 1173: 1128 00021F3A .data 1 ! 1174: 1129 00000d25 * L353: ! 1175: 1130 00000d25 * 696E697469616C20416363203 .ascii "initial Acc = \0" ! 1176: D2000 ! 1177: 1131 00000d34 * .text ! 1178: 1132 00021F3A dd 8f00000d25 pushl $L353 ! 1179: 1133 00021F40 fe 08 effffff675 callf $8,_writes ! 1180: 1134 00021F47 # write32h( sgl_ld_acc ); ! 1181: 1135 00021F47 dd effffff66f pushl _sgl_ld_acc ! 1182: 1136 00021F4D fe 08 effffff668 callf $8,_write32h ! 1183: 1137 00021F54 # writes(", final Acc = "); ! 1184: 1138 00021F54 .data 1 ! 1185: 1139 00000d34 * L354: ! 1186: 1140 00000d34 * 2C202066696E616C204163632 .ascii ", final Acc = \0" ! 1187: 03D2000 ! 1188: 1141 00000d44 * .text ! 1189: 1142 00021F54 dd 8f00000d34 pushl $L354 ! 1190: 1143 00021F5A fe 08 effffff65b callf $8,_writes ! 1191: 1144 00021F61 # write32h( sgl_st_acc ); ! 1192: 1145 00021F61 dd effffff655 pushl _sgl_st_acc ! 1193: 1146 00021F67 fe 08 effffff64e callf $8,_write32h ! 1194: 1147 00021F6E # } ! 1195: 1148 00021F6E 40 ret#2 ! 1196: 1149 00021F6F .set L349,0x0 ! 1197: 1150 00021F6F L351: ! 1198: 1151 00021F6F 11 c9 jbr L352 ! 1199: 1152 00021F71 .data ! 1200: 1153 00000a60 * .text ! 1201: 1154 00021F71 00 .align 1 ! 1202: 1155 00021F72 .globl _logf_er_halt ! 1203: 1156 00021F72 _logf_er_halt: ! 1204: 1157 00021F72 0000 .word L355 ! 1205: 1158 00021F74 # ! 1206: 1159 00021F74 # ! 1207: 1160 00021F74 # ! 1208: 1161 00021F74 # /************************************************************************** ! 1209: 1162 00021F74 # * ! 1210: 1163 00021F74 # * HALT ON ERROR ROUTINE ! 1211: 1164 00021F74 # * ! 1212: 1165 00021F74 # **************************************************************************/ ! 1213: 1166 00021F74 # logf_er_halt( halt_code ) ! 1214: 1167 00021F74 # int halt_code; ! 1215: 1168 00021F74 # { ! 1216: 1169 00021F74 13 00a0 jbr L357 ! 1217: 1170 00021F77 L358: ! 1218: 1171 00021F77 # sgl_dummy1 = halt_code; /* get the error type */ ! 1219: 1172 00021F77 0d ad04 effffff63d movl 4(fp),_sgl_dummy1 ! 1220: 1173 00021F7F # asm("movl _test_no,r0"); /* r0 = test number */ ! 1221: 1174 00021F7F 0d effffff637 50 movl _test_no,r0 ! 1222: 1175 00021F86 # asm("movl _subtest,r1"); /* r1 = subtest number */ ! 1223: 1176 00021F86 0d effffff630 51 movl _subtest,r1 ! 1224: 1177 00021F8D # asm("movl _sgl_dummy1,r2"); /* r2 = error code */ ! 1225: 1178 00021F8D 0d effffff629 52 movl _sgl_dummy1,r2 ! 1226: 1179 00021F94 # asm("movl _cycle,r3"); /* r3 = cycle count */ ! 1227: 1180 00021F94 0d effffff622 53 movl _cycle,r3 ! 1228: 1181 00021F9B # asm("movl _sgl_ld_acc,r4"); /* r4 = initial data */ ! 1229: 1182 00021F9B 0d effffff61b 54 movl _sgl_ld_acc,r4 ! 1230: 1183 00021FA2 # asm("movl _sgl_st_acc,r5"); /* r5 = data stored */ ! 1231: 1184 00021FA2 0d effffff614 55 movl _sgl_st_acc,r5 ! 1232: 1185 00021FA9 # asm("movl _sgl_expected,r6"); /* r6 = data expected */ ! 1233: 1186 00021FA9 0d effffff60d 56 movl _sgl_expected,r6 ! 1234: 1187 00021FB0 # asm("movl _index,r7"); /* r7 = data index */ ! 1235: 1188 00021FB0 0d effffff606 57 movl _index,r7 ! 1236: 1189 00021FB7 # if( halt_code == BAD_REG_HLT ) { ! 1237: 1190 00021FB7 1d ad04 02 cmpl 4(fp),$2 ! 1238: 1191 00021FBB 21 3d jneq L359 ! 1239: 1192 00021FBD # sgl_dummy1 = load_regs[index2]; ! 1240: 1193 00021FBD 0d effffff5f9 50 movl _index2,r0 ! 1241: 1194 00021FC4 0d 40effffff5f1 movl _load_regs[r0],_sgl_dummy1 ! 1242: effffff5ec ! 1243: 1195 00021FD0 # sgl_dummy2 = store_regs[index2]; ! 1244: 1196 00021FD0 0d effffff5e6 50 movl _index2,r0 ! 1245: 1197 00021FD7 0d 40effffff5de movl _store_regs[r0],_sgl_dummy2 ! 1246: effffff5d9 ! 1247: 1198 00021FE3 # asm("movl _index2,r6"); /* r6 = bad register # */ ! 1248: 1199 00021FE3 0d effffff5d3 56 movl _index2,r6 ! 1249: 1200 00021FEA # asm("movl _sgl_dummy2,r7"); /* r7 = actual value */ ! 1250: 1201 00021FEA 0d effffff5cc 57 movl _sgl_dummy2,r7 ! 1251: 1202 00021FF1 # asm("movl _sgl_dummy1,r8"); /* r8 = expected value */ ! 1252: 1203 00021FF1 0d effffff5c5 58 movl _sgl_dummy1,r8 ! 1253: 1204 00021FF8 # } else ! 1254: 1205 00021FF8 11 1b jbr L360 ! 1255: 1206 00021FFA L359: ! 1256: 1207 00021FFA # if( halt_code == BAD_PSL_HLT ) { ! 1257: 1208 00021FFA 1d ad04 03 cmpl 4(fp),$3 ! 1258: 1209 00021FFE 21 15 jneq L361 ! 1259: 1210 00022000 # asm("movl _init_psl,r6"); /* r6 = initial PSL */ ! 1260: 1211 00022000 0d effffff5b6 56 movl _init_psl,r6 ! 1261: 1212 00022007 # asm("movl _psl_val,r7"); /* r7 = final PSL */ ! 1262: 1213 00022007 0d effffff5af 57 movl _psl_val,r7 ! 1263: 1214 0002200E # asm("movl _exp_psl,r8"); /* r8 = expected PSL */ ! 1264: 1215 0002200E 0d effffff5a8 58 movl _exp_psl,r8 ! 1265: 1216 00022015 # }; ! 1266: 1217 00022015 L361: ! 1267: 1218 00022015 L360: ! 1268: 1219 00022015 # asm("halt"); /* HALT ... */ ! 1269: 1220 00022015 00 halt ! 1270: 1221 00022016 # } ! 1271: 1222 00022016 40 ret#2 ! 1272: 1223 00022017 .set L355,0x0 ! 1273: 1224 00022017 L357: ! 1274: 1225 00022017 13 ff5d jbr L358 ! 1275: 1226 0002201A .data ! 1276: 1226 000435D6 .data
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.