![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to emulate.s CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / sys / vax|
Return to emulate.s CVS log | Up to [CSRG BSD Unix] / 43BSD / sys / vax |
1.1 ! root 1: /* ! 2: * @(#)emulate.s 7.1 (Berkeley) 6/5/86 ! 3: */ ! 4: ! 5: #ifdef VAX630 ! 6: /* ! 7: * String instruction emulation - MicroVAX only. These routines are called ! 8: * from locore.s when an "emulate" fault occurs on the MicroVAX. They are ! 9: * called with the stack set up as follows: ! 10: * ! 11: * (sp): Return address of trap handler ! 12: * 4(sp): Instruction Opcode (also holds PSL result from emulator) ! 13: * 8(sp): Instruction PC ! 14: * 12(sp): Operand 1 ! 15: * 16(sp): Operand 2 ! 16: * 20(sp): Operand 3 ! 17: * 24(sp): Operand 4 ! 18: * 28(sp): Operand 5 ! 19: * 32(sp): Operand 6 ! 20: * 36(sp): old Register 11 ! 21: * 40(sp): old Register 10 ! 22: * 44(sp): Return PC ! 23: * 48(sp): Return PSL ! 24: * 52(sp): TOS before instruction ! 25: * ! 26: * R11 and r10 are available for use. If any routine needs to use r9-r1 ! 27: * they need to save them first (unless those registers are SUPPOSED to be ! 28: * messed with by the "instruction"). These routines leave their results ! 29: * in registers 0-5 explicitly, as needed, and use the macros defined below ! 30: * to link up with calling routine. ! 31: */ ! 32: ! 33: #define return rsb ! 34: #define savepsl movpsl 4(sp) ! 35: #define setpsl(reg) movl reg,4(sp) ! 36: #define overflowpsl movl $2,4(sp) ! 37: #define arg1 12(sp) ! 38: #define arg2 16(sp) ! 39: #define arg3 20(sp) ! 40: #define arg4 24(sp) ! 41: #define arg5 28(sp) ! 42: #define arg6 32(sp) ! 43: #define argub(num,reg) movzbl 8+4*num(sp),reg ! 44: #define arguw(num,reg) movzwl 8+4*num(sp),reg ! 45: #define argul(num,reg) movl 8+4*num(sp),reg ! 46: #define argb(num,reg) cvtbl 8+4*num(sp),reg ! 47: #define argw(num,reg) cvtwl 8+4*num(sp),reg ! 48: #define argl(num,reg) movl 8+4*num(sp),reg ! 49: #define toarg(reg,num) movl reg,8+4*num(sp) ! 50: ! 51: ! 52: .text ! 53: .align 1 ! 54: .globl _EMcrc ! 55: _EMcrc: ! 56: argl(1,r11) # (1) table address == r11 ! 57: argl(2,r0) # (2) initial crc == r0 ! 58: toarg(r8,1) # save r8 in arg1 spot ! 59: argl(4,r8) # (4) source address == r8 ! 60: toarg(r1,4) # save r1 in arg4 spot ! 61: tstl arg3 # (3) source length == "arg3" ! 62: jeql Lcrc_out ! 63: Lcrc_loop: ! 64: xorb2 (r8)+,r0 ! 65: extzv $0,$4,r0,r10 ! 66: extzv $4,$28,r0,r1 ! 67: xorl3 r1,(r11)[r10],r0 ! 68: extzv $0,$4,r0,r10 ! 69: extzv $4,$28,r0,r1 ! 70: xorl3 r1,(r11)[r10],r0 ! 71: decl arg3 ! 72: jneq Lcrc_loop ! 73: tstl r0 ! 74: Lcrc_out: ! 75: savepsl ! 76: argl(1,r8) ! 77: argl(4,r1) ! 78: return ! 79: ! 80: ! 81: .align 1 ! 82: .globl _EMmovtc ! 83: _EMmovtc: ! 84: arguw(1,r0) # (1) source length == r0 ! 85: argl(2,r1) # (2) source address == r1 ! 86: argub(3,r11) # (3) fill character == r11 ! 87: argl(4,r3) # (4) table address == r3 ! 88: argl(6,r5) # (6) destination address == r5 ! 89: arguw(5,r4) # (5) destination length == r4 ! 90: jeql Lmovtc_out ! 91: Lmovtc_loop: ! 92: tstl r0 ! 93: jeql Lmovtc_2loop ! 94: movzbl (r1)+,r2 ! 95: movb (r3)[r2],(r5)+ ! 96: decl r0 ! 97: decl r4 ! 98: jeql Lmovtc_out ! 99: jbr Lmovtc_loop ! 100: Lmovtc_2loop: ! 101: movb r11,(r5)+ ! 102: decl r4 ! 103: jneq Lmovtc_2loop ! 104: Lmovtc_out: ! 105: cmpl r4,r0 ! 106: savepsl ! 107: clrl r2 ! 108: return ! 109: ! 110: ! 111: .align 1 ! 112: .globl _EMmovtuc ! 113: _EMmovtuc: ! 114: arguw(1,r0) # (1) source length == r0 ! 115: argl(2,r1) # (2) source address == r1 ! 116: argub(3,r11) # (3) escape character == r11 ! 117: argl(4,r3) # (4) table address == r3 ! 118: argl(6,r5) # (6) destination address == r5 ! 119: arguw(5,r4) # (5) destination length == r4 ! 120: jeql Lmovtuc_out ! 121: Lmovtuc_loop: ! 122: tstl r0 ! 123: jeql Lmovtuc_out ! 124: movzbl (r1),r2 ! 125: movzbl (r3)[r2],r2 ! 126: cmpl r2,r11 ! 127: jeql Lmovtuc_out ! 128: movzbl (r1)+,r2 ! 129: movb (r3)[r2],(r5)+ ! 130: decl r0 ! 131: decl r4 ! 132: jneq Lmovtuc_loop ! 133: Lmovtuc_out: ! 134: cmpl r4,r0 ! 135: savepsl ! 136: clrl r2 ! 137: return ! 138: ! 139: ! 140: .align 1 ! 141: .globl _EMmatchc ! 142: _EMmatchc: ! 143: argl(2,r10) # (2) substring address == r10 ! 144: arguw(3,r2) # (3) source length == r2 ! 145: argl(4,r3) # (4) source address == r3 ! 146: arguw(1,r11) # (1) substring length == r11 ! 147: jeql Lmatchc_out # temp source address == r1 ! 148: addl2 r10,r11 # temp substring address == r0 ! 149: tstl r2 ! 150: jeql Lmatchc_out ! 151: Lmatchc_loop: ! 152: cmpb (r10),(r3) ! 153: jneq Lmatchc_fail ! 154: movl r3,r1 ! 155: movl r10,r0 ! 156: Lmatchc_2loop: ! 157: cmpl r0,r11 ! 158: jeql Lmatchc_succ ! 159: cmpb (r0)+,(r1)+ ! 160: jeql Lmatchc_2loop ! 161: Lmatchc_fail: ! 162: incl r3 ! 163: decl r2 ! 164: jneq Lmatchc_loop ! 165: movl r10,r1 ! 166: subl3 r10,r11,r0 ! 167: jbr Lmatchc_out ! 168: Lmatchc_succ: ! 169: movl r11,r1 ! 170: clrl r0 ! 171: Lmatchc_out: ! 172: savepsl ! 173: return ! 174: ! 175: ! 176: .align 1 ! 177: .globl _EMspanc ! 178: _EMspanc: ! 179: argl(2,r1) # (2) string address == r1 ! 180: argl(3,r3) # (3) table address == r3 ! 181: argub(4,r2) # (4) character-mask == r2 ! 182: arguw(1,r0) # (1) string length == r0 ! 183: jeql Lspanc_out ! 184: Lspanc_loop: ! 185: movzbl (r1),r11 ! 186: mcomb (r3)[r11],r11 ! 187: bicb3 r11,r2,r11 ! 188: jeql Lspanc_out ! 189: incl r1 ! 190: decl r0 ! 191: jneq Lspanc_loop ! 192: Lspanc_out: ! 193: savepsl ! 194: clrl r2 ! 195: return ! 196: ! 197: ! 198: .align 1 ! 199: .globl _EMscanc ! 200: _EMscanc: ! 201: argl(2,r1) # (2) string address == r1 ! 202: argl(3,r3) # (3) table address == r3 ! 203: argub(4,r2) # (4) character-mask == r2 ! 204: arguw(1,r0) # (1) string length == r0 ! 205: jeql Lscanc_out ! 206: Lscanc_loop: ! 207: movzbl (r1),r11 ! 208: mcomb (r3)[r11],r11 ! 209: bicb3 r11,r2,r11 ! 210: jneq Lscanc_out ! 211: incl r1 ! 212: decl r0 ! 213: jneq Lscanc_loop ! 214: Lscanc_out: ! 215: savepsl ! 216: clrl r2 ! 217: return ! 218: ! 219: ! 220: .align 1 ! 221: .globl _EMskpc ! 222: _EMskpc: ! 223: argub(1,r11) # (1) character == r11 ! 224: argl(3,r1) # (3) string address == r1 ! 225: arguw(2,r0) # (2) string length == r0 ! 226: incl r0 ! 227: Lskpc_loop: ! 228: decl r0 ! 229: jeql Lskpc_out ! 230: cmpb (r1)+,r11 ! 231: jeql Lskpc_loop ! 232: decl r1 ! 233: tstl r0 ! 234: Lskpc_out: ! 235: savepsl ! 236: return ! 237: ! 238: ! 239: .align 1 ! 240: .globl _EMlocc ! 241: _EMlocc: ! 242: argub(1,r11) # (1) character == r11 ! 243: argl(3,r1) # (3) string address == r1 ! 244: arguw(2,r0) # (2) string length == r0 ! 245: incl r0 ! 246: Llocc_loop: ! 247: decl r0 ! 248: jeql Llocc_out ! 249: cmpb (r1)+,r11 ! 250: jneq Llocc_loop ! 251: decl r1 ! 252: tstl r0 ! 253: Llocc_out: ! 254: savepsl ! 255: return ! 256: ! 257: ! 258: .align 1 ! 259: .globl _EMcmpc3 ! 260: _EMcmpc3: ! 261: argl(2,r1) # (2) string1 address == r1 ! 262: argl(3,r3) # (3) string2 address == r3 ! 263: arguw(1,r0) # (1) strings' length == r0 ! 264: jeql Lcmpc3_out ! 265: Lcmpc3_loop: ! 266: cmpb (r1),(r3) ! 267: jneq Lcmpc3_out ! 268: incl r1 ! 269: incl r3 ! 270: decl r0 ! 271: jneq Lcmpc3_loop ! 272: Lcmpc3_out: ! 273: savepsl ! 274: movl r0,r2 ! 275: return ! 276: ! 277: ! 278: .align 1 ! 279: .globl _EMcmpc5 ! 280: _EMcmpc5: ! 281: argl(2,r1) # (2) string1 address == r1 ! 282: argub(3,r11) # (1) fill character == r11 ! 283: arguw(4,r2) # (1) string2 length == r2 ! 284: argl(5,r3) # (3) string2 address == r3 ! 285: arguw(1,r0) # (1) string1 length == r0 ! 286: jeql Lcmpc5_str2 ! 287: Lcmpc5_loop: ! 288: tstl r2 ! 289: jeql Lcmpc5_str1loop ! 290: cmpb (r1),(r3) ! 291: jneq Lcmpc5_out ! 292: incl r1 ! 293: incl r3 ! 294: decl r2 ! 295: decl r0 ! 296: jneq Lcmpc5_loop ! 297: Lcmpc5_str2: ! 298: tstl r2 ! 299: jeql Lcmpc5_out ! 300: Lcmpc5_str2loop: ! 301: cmpb r11,(r3) ! 302: jneq Lcmpc5_out ! 303: incl r3 ! 304: decl r2 ! 305: jneq Lcmpc5_str2loop ! 306: jbr Lcmpc5_out ! 307: Lcmpc5_str1loop: ! 308: cmpb (r1),r11 ! 309: jneq Lcmpc5_out ! 310: incl r1 ! 311: decl r0 ! 312: jneq Lcmpc5_str1loop ! 313: Lcmpc5_out: ! 314: savepsl ! 315: return ! 316: ! 317: ! 318: /* ! 319: * Packed Decimal string operations ! 320: */ ! 321: ! 322: #define POSITIVE $12 ! 323: #define NEGATIVE $13 ! 324: #define NEGATIVEalt $11 ! 325: ! 326: ! 327: .align 1 ! 328: .globl _EMaddp4 ! 329: _EMaddp4: ! 330: toarg(r9,6) # save register r9 in arg6 spot ! 331: arguw(1,r11) # (1) source length == r11 ! 332: argl(2,r10) # (2) source address == r10 ! 333: arguw(3,r9) # (3) destination length == r9 ! 334: argl(4,r3) # (4) destination address == r3 ! 335: # arg4 will be needed later ! 336: # arg5 holds destination address of LSNibble temporarily ! 337: ashl $-1,r11,r11 ! 338: addl2 r11,r10 # source address of LSNibble ! 339: incl r11 # source length is in bytes ! 340: ashl $-1,r9,r9 ! 341: addl2 r9,r3 # r3 = destination address of LSNibble ! 342: incl r9 # destination length is in bytes ! 343: toarg(r3,5) # stored in arg5 spot ! 344: extzv $0,$4,(r3),r2 # set standard +/- indicators in destination ! 345: cmpl r2,NEGATIVE ! 346: jeql L112 ! 347: cmpl r2,NEGATIVEalt ! 348: jeql L111 ! 349: insv POSITIVE,$0,$4,(r3) ! 350: jbr L112 ! 351: L111: ! 352: insv NEGATIVE,$0,$4,(r3) ! 353: L112: ! 354: extzv $0,$4,(r10),r2 # r2 = standard +/- of source ! 355: cmpl r2,NEGATIVE ! 356: jeql L114 ! 357: cmpl r2,NEGATIVEalt ! 358: jeql L113 ! 359: movl POSITIVE,r2 ! 360: jbr L114 ! 361: L113: ! 362: movl NEGATIVE,r2 ! 363: L114: ! 364: cmpl r11,r9 # if source is longer than destination ! 365: jleq L115 ! 366: movl r9,r11 # set source length == destination length ! 367: L115: ! 368: extzv $4,$4,(r3),r9 # r9 = LSDigit of destination ! 369: extzv $4,$4,(r10),r1 # r1 = LSDigit of source ! 370: extzv $0,$4,(r3),r0 ! 371: cmpl r0,r2 # if signs of operands are not equal ! 372: jeql Laddp4_same # do a subtraction ! 373: clrl r2 # r2 is non-zero if result is non-zero ! 374: subl2 r1,r9 # r9 = "addition" of operands' high nibble ! 375: jbr L119 # jump into addition loop ! 376: Laddp4_diff_loop: ! 377: decl r3 ! 378: extzv $0,$4,(r3),r0 ! 379: addl2 r0,r1 # r1 = carry + next (low) nibble of source ! 380: decl r10 ! 381: extzv $0,$4,(r10),r0 ! 382: subl2 r0,r1 # r1 -= next (low) nibble of destination ! 383: jgeq L121 # if negative result ! 384: mnegl $1,r9 # r9 == carry = -1 ! 385: addl2 $10,r1 # r1 == result += 10 ! 386: jbr L122 # else ! 387: L121: ! 388: clrl r9 # r9 == carry = 0 ! 389: L122: ! 390: insv r1,$0,$4,(r3) # store result low nibble ! 391: bisl2 r1,r2 ! 392: extzv $4,$4,(r3),r0 ! 393: addl2 r0,r9 # r9 = carry + next (high) nibble of source ! 394: extzv $4,$4,(r10),r0 ! 395: subl2 r0,r9 # r9 -= next (high) nibble of destination ! 396: L119: ! 397: jgeq L117 # if negative result ! 398: mnegl $1,r1 # r1 == carry = -1 ! 399: addl2 $10,r9 # r9 == result += 10 ! 400: jbr L118 # else ! 401: L117: ! 402: clrl r1 # r1 == carry = 0 ! 403: L118: ! 404: insv r9,$4,$4,(r3) # store result high nibble ! 405: bisl2 r9,r2 # r2 is non-zero if result is non-zero ! 406: decl r11 # while (--source length) ! 407: jneq Laddp4_diff_loop ! 408: argl(4,r10) # r10 = address of destination MSNibble ! 409: jbr Laddp4_diff_carry ! 410: Laddp4_diff_carlop: ! 411: decl r3 ! 412: extzv $0,$4,(r3),r0 ! 413: addl2 r0,r1 # r1 == carry += next (low) nibble ! 414: jgeq L127 # if less than zero ! 415: movl r1,r9 # r9 == carry (must be -1) ! 416: movl $9,r1 # r1 == result = 9 ! 417: jbr L128 ! 418: L127: # else ! 419: clrl r9 # r9 == carry = 0 ! 420: L128: ! 421: insv r1,$0,$4,(r3) # store result ! 422: bisl2 r1,r2 ! 423: extzv $4,$4,(r3),r0 ! 424: addl2 r0,r9 # r9 == carry += next (high) nibble ! 425: jgeq L129 # if less than zero ! 426: movl r9,r1 # r1 == carry (must be -1) ! 427: movl $9,r9 # r9 == result = 9 ! 428: jbr L130 ! 429: L129: ! 430: clrl r1 ! 431: L130: ! 432: insv r9,$4,$4,(r3) # store result ! 433: bisl2 r9,r2 ! 434: Laddp4_diff_carry: ! 435: cmpl r3,r10 ! 436: jneq Laddp4_diff_carlop ! 437: tstl r1 # if carry out of MSN then fix up result ! 438: jeql Laddp4_add_done ! 439: argl(5,r3) # r3 == address of LSN of destination ! 440: extzv $0,$4,(r3),r0 ! 441: cmpl r0,NEGATIVE # switch sign of result ! 442: jneq L132 ! 443: insv POSITIVE,$0,$4,(r3) ! 444: jbr L133 ! 445: L132: ! 446: insv NEGATIVE,$0,$4,(r3) ! 447: L133: ! 448: extzv $4,$4,(r3),r0 # normalize result (carry out of MSN into LSN) ! 449: subl3 r0,$10,r9 # r9 = 10 - destination LSNibble ! 450: jbr L134 ! 451: L137: ! 452: movl $9,r1 ! 453: Laddp4_diff_norm: ! 454: insv r9,$4,$4,(r3) ! 455: cmpl r3,r10 # while (not at MSNibble) ! 456: jeql Laddp4_add_done ! 457: decl r3 ! 458: extzv $0,$4,(r3),r0 # low nibble = (9 + carry) - low nibble ! 459: subl2 r0,r1 ! 460: cmpl r1,$9 ! 461: jleq L135 ! 462: clrl r1 ! 463: movl $10,r9 ! 464: jbr L136 ! 465: L135: ! 466: movl $9,r9 ! 467: L136: ! 468: insv r1,$0,$4,(r3) ! 469: extzv $4,$4,(r3),r0 # high nibble = (9 + carry) - high nibble ! 470: subl2 r0,r9 ! 471: L134: ! 472: cmpl r9,$9 ! 473: jleq L137 ! 474: clrl r9 ! 475: movl $10,r1 ! 476: jbr Laddp4_diff_norm ! 477: ! 478: Laddp4_same: # operands are of the same sign ! 479: clrl r2 ! 480: addl2 r1,r9 ! 481: jbr L139 ! 482: Laddp4_same_loop: ! 483: decl r3 ! 484: extzv $0,$4,(r3),r0 ! 485: addl2 r0,r1 # r1 == carry += next (low) nibble of dest ! 486: decl r10 ! 487: extzv $0,$4,(r10),r0 ! 488: addl2 r0,r1 # r1 += next (low) nibble of source ! 489: cmpl r1,$9 # if result > 9 ! 490: jleq L141 ! 491: movl $1,r9 # r9 == carry = 1 ! 492: subl2 $10,r1 # r1 == result -= 10 ! 493: jbr L142 ! 494: L141: # else ! 495: clrl r9 # r9 == carry = 0 ! 496: L142: ! 497: insv r1,$0,$4,(r3) # store result ! 498: bisl2 r1,r2 ! 499: extzv $4,$4,(r10),r0 ! 500: addl2 r0,r9 # ditto for high nibble ! 501: extzv $4,$4,(r3),r0 ! 502: addl2 r0,r9 ! 503: L139: ! 504: cmpl r9,$9 ! 505: jleq L143 ! 506: movl $1,r1 ! 507: subl2 $10,r9 ! 508: jbr L144 ! 509: L143: ! 510: clrl r1 ! 511: L144: ! 512: insv r9,$4,$4,(r3) ! 513: bisl2 r9,r2 ! 514: decl r11 # while (--source length) ! 515: jneq Laddp4_same_loop ! 516: argl(4,r10) # r10 = destination address of MSNibble ! 517: jbr Laddp4_same_carry ! 518: Laddp4_same_cloop: ! 519: decl r3 ! 520: extzv $0,$4,(r3),r0 # propagate carry up to MSNibble of destination ! 521: addl2 r0,r1 ! 522: cmpl r1,$10 ! 523: jneq L147 ! 524: movl $1,r9 ! 525: clrl r1 ! 526: jbr L148 ! 527: L147: ! 528: clrl r9 ! 529: L148: ! 530: insv r1,$0,$4,(r3) ! 531: bisl2 r1,r2 ! 532: extzv $4,$4,(r3),r0 ! 533: addl2 r0,r9 ! 534: cmpl r9,$10 ! 535: jneq L149 ! 536: movl $1,r1 ! 537: clrl r9 ! 538: jbr L150 ! 539: L149: ! 540: clrl r1 ! 541: L150: ! 542: insv r9,$4,$4,(r3) ! 543: bisl2 r9,r2 ! 544: Laddp4_same_carry: ! 545: cmpl r3,r10 ! 546: jneq Laddp4_same_cloop ! 547: ! 548: Laddp4_add_done: ! 549: argl(5,r3) # r3 = destination address of LSNibble ! 550: tstl r2 # if zero result ! 551: jneq L151 ! 552: savepsl # remember that for condition codes ! 553: insv POSITIVE,$0,$4,(r3) # make sure sign of result is positive ! 554: jbr Laddp4_out ! 555: L151: # else ! 556: extzv $0,$4,(r3),r0 ! 557: cmpl r0,NEGATIVE # if result is negative ! 558: jneq Laddp4_out ! 559: mnegl r2,r2 # remember THAT in Cond Codes ! 560: savepsl ! 561: Laddp4_out: ! 562: argl(4,r3) ! 563: argl(2,r1) ! 564: clrl r0 ! 565: clrl r2 ! 566: argl(6,r9) # restore r9 from stack ! 567: return ! 568: ! 569: ! 570: .align 1 ! 571: .globl _EMmovp ! 572: _EMmovp: ! 573: arguw(1,r11) # (1) string length == r11 ! 574: argl(2,r10) # (1) source address == r10 ! 575: argl(3,r3) # (1) destination address == r3 ! 576: # we will need arg2 and arg3 later ! 577: clrl r2 # r2 == non-zero if source is non-zero ! 578: ashl $-1,r11,r11 # length is number of bytes, not nibbles ! 579: jeql Lmovp_zlen ! 580: Lmovp_copy: ! 581: bisb2 (r10),r2 # keep track of non-zero source ! 582: movb (r10)+,(r3)+ # move two nibbles ! 583: decl r11 # loop for length of source ! 584: jneq Lmovp_copy ! 585: Lmovp_zlen: ! 586: extzv $4,$4,(r10),r0 # look at least significant nibble ! 587: bisl2 r0,r2 ! 588: extzv $0,$4,(r10),r0 # check sign nibble ! 589: cmpl r0,NEGATIVEalt ! 590: jeql Lmovp_neg ! 591: cmpl r0,NEGATIVE ! 592: jneq Lmovp_pos ! 593: Lmovp_neg: # source was negative ! 594: mnegl r2,r2 ! 595: Lmovp_pos: ! 596: tstl r2 # set condition codes ! 597: savepsl ! 598: jeql Lmovp_zero ! 599: movb (r10),(r3) # move last byte if non-zero result ! 600: jbr Lmovp_out ! 601: Lmovp_zero: ! 602: movb POSITIVE,(r3) # otherwise, make result zero and positive ! 603: Lmovp_out: ! 604: clrl r0 ! 605: argl(2,r1) ! 606: clrl r2 ! 607: argl(3,r3) ! 608: return ! 609: ! 610: ! 611: /* ! 612: * Definitions for Editpc instruction ! 613: * ! 614: * Here are the commands and their corresponding hex values: ! 615: * ! 616: * EPend 0x00 ! 617: * EPend_float 0x01 ! 618: * EPclear_signif 0x02 ! 619: * EPset_signif 0x03 ! 620: * EPstore_sign 0x04 ! 621: * EPload_fill 0x40 ! 622: * EPload_sign 0x41 ! 623: * EPload_plus 0x42 ! 624: * EPload_minus 0x43 ! 625: * EPinsert 0x44 ! 626: * EPblank_zero 0x45 ! 627: * EPreplace_sign 0x46 ! 628: * EPadjust_input 0x47 ! 629: * EPfill 0x80 ! 630: * EPmove 0x90 ! 631: * EPfloat 0xa0 ! 632: * ! 633: * ! 634: * r4 is carved up as follows: ! 635: * ! 636: * ------------------------------------------- ! 637: * | N Z V C | ! 638: * ------------------------------------------- ! 639: * ! 640: * fill character is stuffed into arg5 space ! 641: * sign character is stuffed into arg6 space ! 642: */ ! 643: ! 644: #define SIGNIFBIT $0 ! 645: #define setsignif bisl2 $1,r4 ! 646: #define clsignif bicl2 $1,r4 ! 647: #define OVERFLOWBIT $1 ! 648: #define setoverflow bisl2 $2,r4 ! 649: #define cloverflow bicl2 $2,r4 ! 650: #define ZEROBIT $2 ! 651: #define setzero bisl2 $4,r4 ! 652: #define clzero bicl2 $4,r4 ! 653: #define NEGATIVEBIT $3 ! 654: #define setnegative bisl2 $8,r4 ! 655: #define clnegative bicl2 $8,r4 ! 656: #define putfill movb arg5,(r5)+ ! 657: #define setfill(reg) movb reg,arg5 ! 658: #define putsign movb arg6,(r5)+ ! 659: #define setsign(reg) movb reg,arg6 ! 660: ! 661: ! 662: .align 1 ! 663: .globl _EMeditpc ! 664: _EMeditpc: ! 665: arguw(1,r11) # (1) source length == r11 ! 666: argl(2,r10) # (2) source address == r10 ! 667: argl(3,r3) # (3) pattern address == r3 ! 668: argl(4,r5) # (4) destination address == r5 ! 669: # we will need arg1 and arg2 later ! 670: # arg5 and arg6 are used for fill and sign - r0 is free ! 671: setfill($32) # fill character is ' ' ! 672: setsign($32) # sign character is ' ' ! 673: clrl r4 # clear flags ! 674: ashl $-1,r11,r11 # source length / 2 ! 675: addl3 r11,r10,r2 ! 676: extzv $4,$4,(r2),r1 # r1 == least significant nibble of source ! 677: L169: ! 678: cmpl r2,r10 ! 679: jeql L170 ! 680: tstb -(r2) # loop over source packed decimal number ! 681: jeql L169 ! 682: incl r1 # r1 is non-zero if source is non-zero ! 683: L170: ! 684: addl3 r11,r10,r2 ! 685: tstl r1 ! 686: jeql L172 # source is zero - set flags ! 687: extzv $0,$4,(r2),r11 ! 688: cmpl r11,NEGATIVEalt ! 689: jeql L9998 # source is negative - set sign and flags ! 690: cmpl r11,NEGATIVE ! 691: jneq L175 ! 692: L9998: ! 693: setnegative ! 694: setsign($45) # sign character is '-' ! 695: jbr L175 ! 696: L172: ! 697: setzero ! 698: L175: ! 699: arguw(1,r2) # (1) source length == r2 ! 700: Ledit_case: ! 701: movzbl (r3)+,r11 # get next edit command (pattern) ! 702: cmpl r11,$128 ! 703: jlss L180 ! 704: extzv $0,$4,r11,r1 # command has a "count" arg - into r1 ! 705: ashl $-4,r11,r11 # and shift over ! 706: L180: ! 707: jbc $6,r11,L181 # "shift" those commands > 64 to 16 and up ! 708: subl2 $48,r11 ! 709: L181: ! 710: caseb r11,$0,$0x18 # "do" the command ! 711: # r11 is available for use, r1 has "count" in it ! 712: Lcaseb_label: ! 713: .word Le_end - Lcaseb_label # 00 ! 714: .word Le_end_float - Lcaseb_label # 01 ! 715: .word Le_clear_signif - Lcaseb_label # 02 ! 716: .word Le_set_signif - Lcaseb_label # 03 ! 717: .word Le_store_sign - Lcaseb_label # 04 ! 718: .word Le_end - Lcaseb_label # 05 ! 719: .word Le_end - Lcaseb_label # 06 ! 720: .word Le_end - Lcaseb_label # 07 ! 721: .word Le_fill - Lcaseb_label # 80 ! 722: .word Le_move - Lcaseb_label # 90 ! 723: .word Le_float - Lcaseb_label # a0 ! 724: .word Le_end - Lcaseb_label # b0 ! 725: .word Le_end - Lcaseb_label # c0 ! 726: .word Le_end - Lcaseb_label # d0 ! 727: .word Le_end - Lcaseb_label # e0 ! 728: .word Le_end - Lcaseb_label # f0 ! 729: .word Le_load_fill - Lcaseb_label # 40 ! 730: .word Le_load_sign - Lcaseb_label # 41 ! 731: .word Le_load_plus - Lcaseb_label # 42 ! 732: .word Le_load_minus - Lcaseb_label # 43 ! 733: .word Le_insert - Lcaseb_label # 44 ! 734: .word Le_blank_zero - Lcaseb_label # 45 ! 735: .word Le_replace_sign - Lcaseb_label # 46 ! 736: .word Le_adjust_input - Lcaseb_label # 47 ! 737: Le_end: ! 738: arguw(1,r0) ! 739: argl(2,r1) ! 740: clrl r2 ! 741: decl r3 ! 742: setpsl(r4) ! 743: clrl r4 ! 744: return ! 745: ! 746: Le_end_float: ! 747: jbs SIGNIFBIT,r4,Ledit_case # if significance not set ! 748: putsign # drop in the sign ! 749: # fall into... ! 750: Le_set_signif: ! 751: setsignif ! 752: jbr Ledit_case ! 753: ! 754: Le_clear_signif: ! 755: clsignif ! 756: jbr Ledit_case ! 757: ! 758: Le_store_sign: ! 759: putsign ! 760: jbr Ledit_case ! 761: ! 762: Le_load_fill: ! 763: setfill((r3)+) ! 764: jbr Ledit_case ! 765: ! 766: Le_load_plus: ! 767: jbs NEGATIVEBIT,r4,Lpattern_inc # if non-negative ! 768: # fall into... ! 769: Le_load_sign: ! 770: setsign((r3)+) ! 771: jbr Ledit_case ! 772: ! 773: Le_load_minus: ! 774: jbs NEGATIVEBIT,r4,Le_load_sign # if negative load the sign ! 775: incl r3 # else increment pattern ! 776: jbr Ledit_case ! 777: ! 778: Le_insert: ! 779: jbc SIGNIFBIT,r4,L196 # if significance set, put next byte ! 780: movb (r3)+,(r5)+ ! 781: jbr Ledit_case ! 782: L196: # else put in fill character ! 783: putfill ! 784: # and throw away character in pattern ! 785: Le_replace_sign: # we don't do anything with ! 786: Lpattern_inc: # replace sign `cause we don't ! 787: incl r3 # get negative zero ! 788: jbr Ledit_case ! 789: ! 790: Le_blank_zero: ! 791: jbc ZEROBIT,r4,Lpattern_inc # if zero ! 792: movzbl (r3)+,r11 # next byte is a count ! 793: jeql Ledit_case ! 794: subl2 r11,r5 # to back up over output and replace ! 795: L200: ! 796: putfill # with fill character ! 797: decl r11 ! 798: jneq L200 ! 799: jbr Ledit_case ! 800: ! 801: Le_adjust_input: ! 802: movzbl (r3)+,r0 # get count of nibbles from pattern ! 803: subl3 r2,r0,r11 ! 804: jgeq Ledit_case # if length of source is > this number ! 805: L204: # discard digits in source ! 806: jlbc r2,L206 # use low bit of length to choose nibble ! 807: bitb $0xf0,(r10) # high nibble ! 808: jeql L208 ! 809: setsignif # set significance and overflow if ! 810: setoverflow # wasted digit is non-zero ! 811: jbr L208 ! 812: L206: ! 813: bitb $0xf,(r10) # low nibble ! 814: jeql L209 ! 815: setsignif ! 816: setoverflow ! 817: L209: ! 818: incl r10 # increment to next byte ! 819: L208: ! 820: decl r2 # decrement source length ! 821: incl r11 # continue `till we're out of excess ! 822: jlss L204 ! 823: jbr Ledit_case ! 824: ! 825: Le_fill: ! 826: tstl r1 # put (count in r1) fill characters ! 827: jeql Ledit_case ! 828: Le_fill_loop: ! 829: putfill ! 830: decl r1 ! 831: jneq Le_fill_loop ! 832: jbr Ledit_case ! 833: ! 834: Le_move: ! 835: tstl r1 # move (count in r1) characters ! 836: jeql Ledit_case # from source to destination ! 837: L214: ! 838: jlbc r2,L215 # read a nibble ! 839: extzv $4,$4,(r10),r11 ! 840: jbr L216 ! 841: L215: ! 842: extzv $0,$4,(r10),r11 ! 843: incl r10 ! 844: L216: ! 845: decl r2 # source length CAN go negative here... ! 846: tstl r11 ! 847: jeql L218 # if non-zero ! 848: setsignif # set significance ! 849: L218: ! 850: jbc SIGNIFBIT,r4,L219 # if significance set ! 851: addb3 $48,r11,(r5)+ # put '0' + digit into destination ! 852: jbr L220 ! 853: L219: # else put fill character ! 854: putfill ! 855: L220: ! 856: decl r1 ! 857: jneq L214 ! 858: jbr Ledit_case ! 859: ! 860: Le_float: # move with floating sign character ! 861: tstl r1 ! 862: jeql Ledit_case ! 863: L221: ! 864: jlbc r2,L222 ! 865: extzv $4,$4,(r10),r11 ! 866: jbr L223 ! 867: L222: ! 868: extzv $0,$4,(r10),r11 ! 869: incl r10 ! 870: L223: ! 871: decl r2 # source length CAN go negative here... ! 872: tstl r11 ! 873: jeql L225 ! 874: jbs SIGNIFBIT,r4,L226 ! 875: putsign ! 876: L226: ! 877: setsignif ! 878: L225: ! 879: jbc SIGNIFBIT,r4,L227 ! 880: addb3 $48,r11,(r5)+ ! 881: jbr L228 ! 882: L227: ! 883: putfill ! 884: L228: ! 885: decl r1 ! 886: jneq L221 ! 887: jbr Ledit_case ! 888: ! 889: ! 890: .align 1 ! 891: .globl _EMashp ! 892: _EMashp: ! 893: argb(1,r11) # (1) scale (number to shift) == r11 ! 894: arguw(2,r10) # (2) source length == r10 ! 895: argl(3,r1) # (3) source address == r1 ! 896: argub(4,r2) # (4) rounding factor == r2 ! 897: arguw(5,r3) # (5) destination length == r3 ! 898: toarg(r6,3) # arg3 holds register 6 from caller ! 899: argl(6,r6) # (6) destination address == r6 ! 900: # we need arg6 for later ! 901: # arg1 is used for temporary storage ! 902: # arg4 is used as general storage ! 903: # arg5 is used as general storage ! 904: ashl $-1,r3,r0 # destination length is number of bytes ! 905: addl2 r0,r6 # destination address == least sig nibble ! 906: toarg(r6,1) # save in arg1 spot for later ! 907: ashl $-1,r10,r0 ! 908: addl2 r0,r1 # source address == least sig nibble ! 909: extzv $0,$4,(r1),r0 # determine sign of source ! 910: cmpl r0,NEGATIVEalt ! 911: jeql Lashp_neg ! 912: cmpl r0,NEGATIVE ! 913: jeql Lashp_neg ! 914: movb POSITIVE,(r6) ! 915: jbr L245 ! 916: Lashp_neg: ! 917: movb NEGATIVE,(r6) ! 918: L245: # r3<0> counts digits going into destination ! 919: bisl2 $1,r3 # and is flip-flop for which nibble to ! 920: tstl r11 # write in destination (1 = high, 0 = low) ! 921: jgeq Lashp_left # (it must start out odd) ! 922: addl2 r11,r10 # scale is negative (right shift) ! 923: jgeq Lashp_right ! 924: clrl r10 # test for shifting whole number out ! 925: jbr Lashp_setround ! 926: Lashp_right: ! 927: divl3 $2,r11,r0 ! 928: addl2 r0,r1 # source address == MSNibble to be shifted off ! 929: jlbc r11,L249 ! 930: extzv $4,$4,(r1),r0 ! 931: addl2 r0,r2 # round = last nibble to be shifted off + round ! 932: jbr Lashp_setround ! 933: L249: ! 934: extzv $0,$4,(r1),r0 ! 935: addl2 r0,r2 # round = last nibble to be shifted off + round ! 936: Lashp_setround: # r11<0> now is flip-flop for which nibble to ! 937: incl r11 # read from source (1 == high, 0 == low) ! 938: cmpl r2,$9 # set rounding factor to one if nibble shifted ! 939: jleq Lashp_noround # off + round argument was 10 or greater ! 940: movl $1,r2 ! 941: jbr Lashp_shift ! 942: Lashp_zloop: ! 943: jlbs r3,L257 # don't need to clear high nibble twice ! 944: clrb -(r6) # clear low (and high) nib of next byte in dest ! 945: L257: ! 946: decl r3 # move to next nibble in destination, but ! 947: jneq L258 # don't go beyond the end. ! 948: incl r3 ! 949: L258: ! 950: decl r11 ! 951: Lashp_left: # while scale is positive ! 952: jneq Lashp_zloop ! 953: incl r11 # r11<0> is flip-plop ... (incl sets it to one) ! 954: Lashp_noround: ! 955: clrl r2 # no more rounding ! 956: Lashp_shift: ! 957: clrl arg4 # arg4 will be used for result condition codes ! 958: tstl r10 ! 959: jeql Lashp_sethigh ! 960: Lashp_shloop: ! 961: jlbc r11,L260 ! 962: extzv $4,$4,(r1),r0 ! 963: jbr L261 ! 964: L260: ! 965: decl r1 ! 966: extzv $0,$4,(r1),r0 ! 967: L261: ! 968: incl r11 # flip the source nibble flip/flop ! 969: addl2 r0,r2 # round += next nibble ! 970: cmpl r2,$10 # if round == 10 ! 971: jneq L262 ! 972: clrl arg5 # then result = 0 and round = 1 ! 973: movl $1,r2 ! 974: jbr L263 ! 975: L262: # else ! 976: movl r2,arg5 # store result and round = 0 ! 977: clrl r2 ! 978: L263: ! 979: bisl2 arg5,arg4 # remember if result was nonzero in arg4 ! 980: decl r3 # move to next nibble early to check ! 981: jgeq Lashp_noovfl # if we've moved passed destination limits ! 982: clrl r3 # test the result for possible overflow ! 983: tstl arg5 # ignore zero nibbles ! 984: jeql L265 # if the nibble was non-zero, overflow ! 985: jbr Lashp_overfl ! 986: Lashp_noovfl: # else ! 987: jlbs r3,L264 ! 988: insv arg5,$4,$4,(r6) # put the result into destination (high or low) ! 989: jbr L265 ! 990: L264: ! 991: decl r6 ! 992: insv arg5,$0,$4,(r6) ! 993: L265: ! 994: decl r10 # loop for length of source ! 995: jneq Lashp_shloop ! 996: ! 997: Lashp_sethigh: ! 998: jlbc r3,L266 # if we haven't set the high nibble, ! 999: insv r2,$4,$4,(r6) # carry the round into the high nibble ! 1000: clrl r2 ! 1001: L266: ! 1002: argl(1,r10) # r10 = address of destination LSNibble ! 1003: argl(6,r3) # r3 = address of destination MSNibble ! 1004: movl arg4,r11 # r11 = non-zero if destination == non-zero ! 1005: savepsl ! 1006: jbr L267 ! 1007: Lashp_zerofill: ! 1008: cvtlb r2,-(r6) # fill up MSNs of destination with carry or zero ! 1009: clrl r2 ! 1010: L267: ! 1011: cmpl r3,r6 ! 1012: jneq Lashp_zerofill ! 1013: tstl r2 # if carry beyond destination, overflow ! 1014: jneq Lashp_overfl ! 1015: extzv $0,$4,(r10),r0 # test for negative result ! 1016: cmpl r0,NEGATIVE ! 1017: jneq Lashp_out ! 1018: mnegl r11,r11 ! 1019: savepsl ! 1020: jneq Lashp_out # turn -0 into 0 ! 1021: insv POSITIVE,$0,$4,(r10) ! 1022: Lashp_out: ! 1023: clrl r0 ! 1024: argl(3,r6) # restore r6 from stack ! 1025: return ! 1026: Lashp_overfl: # do overflow ! 1027: clrl r2 ! 1028: overflowpsl ! 1029: jbr Lashp_out ! 1030: ! 1031: ! 1032: .align 1 ! 1033: .globl _EMcvtlp ! 1034: _EMcvtlp: ! 1035: arguw(2,r10) # (2) destination length == r10 ! 1036: argl(3,r3) # (3) destination address == r3 ! 1037: ashl $-1,r10,r10 ! 1038: addl2 r10,r3 # destination address points to Least Sig byte ! 1039: incl r10 # length is # of bytes, not nibbles ! 1040: argl(1,r11) # (1) source == r11 ! 1041: savepsl ! 1042: jgeq Lcvtlp_pos ! 1043: movb NEGATIVE,(r3) # source is negative ! 1044: divl3 $10,r11,r0 ! 1045: mull3 $10,r0,r1 ! 1046: subl3 r11,r1,r2 # r2 = source mod 10 ! 1047: mnegl r0,r11 # source = -(source / 10) ! 1048: jbr Lcvtlp_cvt ! 1049: Lcvtlp_pos: ! 1050: movb POSITIVE,(r3) # source is non-negative ! 1051: divl3 $10,r11,r0 ! 1052: mull3 $10,r0,r1 ! 1053: subl3 r1,r11,r2 # r2 = source mod 10 ! 1054: movl r0,r11 # source = source / 10 ! 1055: Lcvtlp_cvt: ! 1056: insv r2,$4,$4,(r3) # store least significant digit ! 1057: tstl r11 ! 1058: jeql Lcvtlp_zloop ! 1059: Lcvtlp_loop: # while source is non-zero ! 1060: decl r10 # and for length of destination ... ! 1061: jeql Lcvtlp_over ! 1062: divl3 $10,r11,r1 # r1 = source / 10 ! 1063: mull3 $10,r1,r0 ! 1064: subl2 r0,r11 # source = source mod 10 ! 1065: movb r11,-(r3) # store low "nibble" in next significant byte ! 1066: divl3 $10,r1,r11 # source = r1 / 10 ! 1067: mull3 $10,r11,r0 ! 1068: subl2 r0,r1 # r1 = source mod 10 ! 1069: insv r1,$4,$4,(r3) # store high nibble ! 1070: tstl r11 ! 1071: jneq Lcvtlp_loop # quit if source becomes zero ! 1072: Lcvtlp_zloop: # fill any remaining bytes with zeros ! 1073: decl r10 ! 1074: jeql Lcvtlp_out ! 1075: clrb -(r3) ! 1076: jbr Lcvtlp_zloop ! 1077: Lcvtlp_over: ! 1078: overflowpsl ! 1079: Lcvtlp_out: ! 1080: clrl r1 # r0 is already zero ! 1081: clrl r2 ! 1082: return ! 1083: ! 1084: ! 1085: .align 1 ! 1086: .globl _EMcvtpl ! 1087: _EMcvtpl: ! 1088: arguw(1,r11) # (1) source length == r11 ! 1089: argl(2,r10) # (2) source address == r10 ! 1090: clrl r3 # r3 == destination ! 1091: movl r10,r1 # r1 set up now for return ! 1092: ashl $-1,r11,r11 # source length is number of bytes ! 1093: jeql Lcvtpl_zero ! 1094: Lcvtpl_loop: # for source length ! 1095: mull2 $10,r3 # destination *= 10 ! 1096: extzv $4,$4,(r10),r0 ! 1097: addl2 r0,r3 # destination += high nibble ! 1098: mull2 $10,r3 # destination *= 10 ! 1099: extzv $0,$4,(r10),r0 ! 1100: addl2 r0,r3 # destination += low nibble ! 1101: incl r10 ! 1102: decl r11 ! 1103: jneq Lcvtpl_loop ! 1104: Lcvtpl_zero: # least significant byte ! 1105: mull2 $10,r3 ! 1106: extzv $4,$4,(r10),r0 ! 1107: addl2 r0,r3 # dest = 10 * dest + high nibble ! 1108: savepsl ! 1109: extzv $0,$4,(r10),r2 # test sign nibble ! 1110: cmpl r2,NEGATIVE ! 1111: jeql Lcvtpl_neg ! 1112: cmpl r2,NEGATIVEalt ! 1113: jneq Lcvtpl_out ! 1114: Lcvtpl_neg: # source was negative - negate destination ! 1115: mnegl r3,r3 ! 1116: savepsl ! 1117: Lcvtpl_out: ! 1118: toarg(r3,3) ! 1119: clrl r0 ! 1120: clrl r2 ! 1121: clrl r3 ! 1122: return ! 1123: ! 1124: ! 1125: .align 1 ! 1126: .globl _EMcvtps ! 1127: _EMcvtps: ! 1128: return ! 1129: ! 1130: ! 1131: .align 1 ! 1132: .globl _EMcvtsp ! 1133: _EMcvtsp: ! 1134: return ! 1135: ! 1136: ! 1137: .align 1 ! 1138: .globl _EMaddp6 ! 1139: _EMaddp6: ! 1140: return ! 1141: ! 1142: ! 1143: .align 1 ! 1144: .globl _EMsubp4 ! 1145: _EMsubp4: ! 1146: return ! 1147: ! 1148: ! 1149: .align 1 ! 1150: .globl _EMsubp6 ! 1151: _EMsubp6: ! 1152: return ! 1153: ! 1154: ! 1155: .align 1 ! 1156: .globl _EMcvtpt ! 1157: _EMcvtpt: ! 1158: return ! 1159: ! 1160: ! 1161: .align 1 ! 1162: .globl _EMmulp ! 1163: _EMmulp: ! 1164: return ! 1165: ! 1166: ! 1167: .align 1 ! 1168: .globl _EMcvttp ! 1169: _EMcvttp: ! 1170: return ! 1171: ! 1172: ! 1173: .align 1 ! 1174: .globl _EMdivp ! 1175: _EMdivp: ! 1176: return ! 1177: ! 1178: ! 1179: .align 1 ! 1180: .globl _EMcmpp3 ! 1181: _EMcmpp3: ! 1182: return ! 1183: ! 1184: ! 1185: .align 1 ! 1186: .globl _EMcmpp4 ! 1187: _EMcmpp4: ! 1188: return ! 1189: ! 1190: ! 1191: #endif UVAXII ! 1192: ! 1193: ! 1194: #ifdef notdef ! 1195: /* ! 1196: * Emulation OpCode jump table: ! 1197: * ONLY GOES FROM 0xf8 (-8) TO 0x3B (59) ! 1198: */ ! 1199: #define EMUTABLE 0x43 ! 1200: #define NOEMULATE .long noemulate ! 1201: #define EMULATE(a) .long _EM/**/a ! 1202: .globl _emJUMPtable ! 1203: _emJUMPtable: ! 1204: /* f8 */ EMULATE(ashp); EMULATE(cvtlp); NOEMULATE; NOEMULATE ! 1205: /* fc */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 1206: /* 00 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 1207: /* 04 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 1208: /* 08 */ EMULATE(cvtps); EMULATE(cvtsp); NOEMULATE; EMULATE(crc) ! 1209: /* 0c */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 1210: /* 10 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 1211: /* 14 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 1212: /* 18 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 1213: /* 1c */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 1214: /* 20 */ EMULATE(addp4); EMULATE(addp6); EMULATE(subp4); EMULATE(subp6) ! 1215: /* 24 */ EMULATE(cvtpt); EMULATE(mulp); EMULATE(cvttp); EMULATE(divp) ! 1216: /* 28 */ NOEMULATE; EMULATE(cmpc3); EMULATE(scanc); EMULATE(spanc) ! 1217: /* 2c */ NOEMULATE; EMULATE(cmpc5); EMULATE(movtc); EMULATE(movtuc) ! 1218: /* 30 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE ! 1219: /* 34 */ EMULATE(movp); EMULATE(cmpp3); EMULATE(cvtpl); EMULATE(cmpp4) ! 1220: /* 38 */ EMULATE(editpc); EMULATE(matchc); EMULATE(locc); EMULATE(skpc) ! 1221: ! 1222: /* ! 1223: * The following is called with the stack set up as follows: ! 1224: * ! 1225: * (sp): Opcode ! 1226: * 4(sp): Instruction PC ! 1227: * 8(sp): Operand 1 ! 1228: * 12(sp): Operand 2 ! 1229: * 16(sp): Operand 3 ! 1230: * 20(sp): Operand 4 ! 1231: * 24(sp): Operand 5 ! 1232: * 28(sp): Operand 6 ! 1233: * 32(sp): Operand 7 (unused) ! 1234: * 36(sp): Operand 8 (unused) ! 1235: * 40(sp): Return PC ! 1236: * 44(sp): Return PSL ! 1237: * 48(sp): TOS before instruction ! 1238: * ! 1239: * Each individual routine is called with the stack set up as follows: ! 1240: * ! 1241: * (sp): Return address of trap handler ! 1242: * 4(sp): Opcode (will get return PSL) ! 1243: * 8(sp): Instruction PC ! 1244: * 12(sp): Operand 1 ! 1245: * 16(sp): Operand 2 ! 1246: * 20(sp): Operand 3 ! 1247: * 24(sp): Operand 4 ! 1248: * 28(sp): Operand 5 ! 1249: * 32(sp): Operand 6 ! 1250: * 36(sp): saved register 11 ! 1251: * 40(sp): saved register 10 ! 1252: * 44(sp): Return PC ! 1253: * 48(sp): Return PSL ! 1254: * 52(sp): TOS before instruction ! 1255: */ ! 1256: ! 1257: SCBVEC(emulate): ! 1258: movl r11,32(sp) # save register r11 in unused operand ! 1259: movl r10,36(sp) # save register r10 in unused operand ! 1260: cvtbl (sp),r10 # get opcode ! 1261: addl2 $8,r10 # shift negative opcodes ! 1262: subl3 r10,$EMUTABLE,r11 # forget it if opcode is out of range ! 1263: bcs noemulate ! 1264: movl _emJUMPtable[r10],r10 # call appropriate emulation routine ! 1265: jsb (r10) # routines put return values into regs 0-5 ! 1266: movl 32(sp),r11 # restore register r11 ! 1267: movl 36(sp),r10 # restore register r10 ! 1268: insv (sp),$0,$4,44(sp) # and condition codes in Opcode spot ! 1269: addl2 $40,sp # adjust stack for return ! 1270: rei ! 1271: noemulate: ! 1272: addl2 $48,sp # adjust stack for ! 1273: .word 0xffff # "reserved instruction fault" ! 1274: SCBVEC(emulateFPD): ! 1275: .word 0xffff # "reserved instruction fault" ! 1276: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.