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