NetBSD-5.0.2/sys/arch/vax/vax/emulate.S
/* $NetBSD: emulate.S,v 1.5 2005/12/11 12:19:36 christos Exp $ */
/*
* Copyright (c) 1986, 1987 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Mt. Xinu.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* @(#)emulate.s 7.5 (Berkeley) 6/28/90
*/
#include <machine/asm.h>
/*
* String instruction emulation - MicroVAX only. These routines are called
* from locore.s when an "emulate" fault occurs on the MicroVAX. They are
* called with the stack set up as follows:
*
* (%sp): Return address of trap handler
* 4(%sp): Instruction Opcode (also holds PSL result from emulator)
* 8(%sp): Instruction PC
* 12(%sp): Operand 1
* 16(%sp): Operand 2
* 20(%sp): Operand 3
* 24(%sp): Operand 4
* 28(%sp): Operand 5
* 32(%sp): Operand 6
* 36(%sp): old Register 11
* 40(%sp): old Register 10
* 44(%sp): Return PC
* 48(%sp): Return PSL
* 52(%sp): TOS before instruction
*
* R11 and %r10 are available for use. If any routine needs to use %r9-%r1
* they need to save them first (unless those registers are SUPPOSED to be
* messed with by the "instruction"). These routines leave their results
* in registers 0-5 explicitly, as needed, and use the macros defined below
* to link up with calling routine.
*/
#define return rsb
#define savepsl movpsl 4(%sp)
#define setpsl(reg) movl reg,4(%sp)
#define overflowpsl movl $2,4(%sp)
#define arg1 12(%sp)
#define arg2 16(%sp)
#define arg3 20(%sp)
#define arg4 24(%sp)
#define arg5 28(%sp)
#define arg6 32(%sp)
#define argub(num,reg) movzbl 8+4*num(%sp),reg
#define arguw(num,reg) movzwl 8+4*num(%sp),reg
#define argul(num,reg) movl 8+4*num(%sp),reg
#define argb(num,reg) cvtbl 8+4*num(%sp),reg
#define argw(num,reg) cvtwl 8+4*num(%sp),reg
#define argl(num,reg) movl 8+4*num(%sp),reg
#define toarg(reg,num) movl reg,8+4*num(%sp)
.text
.align 1
ALTENTRY(EMcrc)
argl(1,%r11) # (1) table address == %r11
argl(2,%r0) # (2) initial crc == %r0
argl(4,%r3) # (4) source address == %r3
arguw(3,%r2) # (3) source length == %r2
jeql Lcrc_out
Lcrc_loop:
xorb2 (%r3)+,%r0
extzv $0,$4,%r0,%r10
extzv $4,$28,%r0,%r1
xorl3 %r1,(%r11)[%r10],%r0
extzv $0,$4,%r0,%r10
extzv $4,$28,%r0,%r1
xorl3 %r1,(%r11)[%r10],%r0
sobgtr %r2,Lcrc_loop
tstl %r0
Lcrc_out:
savepsl
clrl %r1
return
.align 1
ALTENTRY(EMmovtc)
arguw(1,%r0) # (1) source length == %r0
argl(2,%r1) # (2) source address == %r1
argub(3,%r11) # (3) fill character == %r11
argl(4,%r3) # (4) table address == %r3
argl(6,%r5) # (6) destination address == %r5
arguw(5,%r4) # (5) destination length == %r4
jeql Lmovtc_out
Lmovtc_loop:
tstl %r0
jeql Lmovtc_2loop
movzbl (%r1)+,%r2
movb (%r3)[%r2],(%r5)+
decl %r0
sobgtr %r4,Lmovtc_loop
jbr Lmovtc_out
Lmovtc_2loop:
movb %r11,(%r5)+
sobgtr %r4,Lmovtc_2loop
Lmovtc_out:
cmpw arg1,arg5
savepsl
clrl %r2
return
.align 1
ALTENTRY(EMmovtuc)
arguw(1,%r0) # (1) source length == %r0
argl(2,%r1) # (2) source address == %r1
argub(3,%r11) # (3) escape character == %r11
argl(4,%r3) # (4) table address == %r3
argl(6,%r5) # (6) destination address == %r5
arguw(5,%r4) # (5) destination length == %r4
jeql Lmovtuc_out1
Lmovtuc_loop:
tstl %r0
jeql Lmovtuc_out1
movzbl (%r1),%r2
movzbl (%r3)[%r2],%r2
cmpl %r2,%r11
jeql Lmovtuc_out2
movzbl (%r1)+,%r2
movb (%r3)[%r2],(%r5)+
decl %r0
sobgtr %r4,Lmovtuc_loop
Lmovtuc_out1:
clrl %r2 # clear V-bit
brb Lmovtuc_out
Lmovtuc_out2:
movl $2,%r2 # set V-bit
Lmovtuc_out:
cmpw arg1,arg5
savepsl
bisl2 %r2,4(%sp) # merge V-bit into psl
clrl %r2
return
.align 1
ALTENTRY(EMmatchc)
argl(2,%r10) # (2) substring address == %r10
arguw(3,%r2) # (3) source length == %r2
argl(4,%r3) # (4) source address == %r3
arguw(1,%r11) # (1) substring length == %r11
jeql Lmatchc_out # temp source address == %r1
addl2 %r10,%r11 # temp substring address == %r0
tstl %r2
jeql Lmatchc_out
Lmatchc_loop:
cmpb (%r10),(%r3)
jneq Lmatchc_fail
movl %r3,%r1
movl %r10,%r0
Lmatchc_2loop:
cmpl %r0,%r11
jeql Lmatchc_succ
cmpb (%r0)+,(%r1)+
jeql Lmatchc_2loop
Lmatchc_fail:
incl %r3
sobgtr %r2,Lmatchc_loop
movl %r10,%r1
subl3 %r10,%r11,%r0
jbr Lmatchc_out
Lmatchc_succ:
movl %r1,%r3
movl %r11,%r1
clrl %r0
Lmatchc_out:
savepsl
return
.align 1
ALTENTRY(EMspanc)
argl(2,%r1) # (2) string address == %r1
argub(4,%r2) # (4) character-mask == %r2
argl(3,%r3) # (3) table address == %r3
arguw(1,%r0) # (1) string length == %r0
jeql Lspanc_out
Lspanc_loop:
movzbl (%r1),%r11
mcomb (%r3)[%r11],%r11
bicb3 %r11,%r2,%r11
jeql Lspanc_out
incl %r1
sobgtr %r0,Lspanc_loop
Lspanc_out:
savepsl
clrl %r2
return
.align 1
ALTENTRY(EMscanc)
argl(2,%r1) # (2) string address == %r1
argub(4,%r2) # (4) character-mask == %r2
argl(3,%r3) # (3) table address == %r3
arguw(1,%r0) # (1) string length == %r0
jeql Lscanc_out
Lscanc_loop:
movzbl (%r1),%r11
mcomb (%r3)[%r11],%r11
bicb3 %r11,%r2,%r11
jneq Lscanc_out
incl %r1
sobgtr %r0,Lscanc_loop
Lscanc_out:
savepsl
clrl %r2
return
.align 1
ALTENTRY(EMskpc)
argub(1,%r11) # (1) character == %r11
argl(3,%r1) # (3) string address == %r1
arguw(2,%r0) # (2) string length == %r0
jeql Lskpc_out # forget zero length strings
Lskpc_loop:
cmpb (%r1),%r11
jneq Lskpc_out
incl %r1
sobgtr %r0,Lskpc_loop
Lskpc_out:
tstl %r0 # be sure of condition codes
savepsl
return
.align 1
ALTENTRY(EMlocc)
argub(1,%r11) # (1) character == %r11
argl(3,%r1) # (3) string address == %r1
arguw(2,%r0) # (2) string length == %r0
jeql Lskpc_out # forget zero length strings
Llocc_loop:
cmpb (%r1),%r11
jeql Llocc_out
incl %r1
sobgtr %r0,Llocc_loop
Llocc_out:
tstl %r0 # be sure of condition codes
savepsl
return
.align 1
ALTENTRY(EMcmpc3)
argl(2,%r1) # (2) string1 address == %r1
argl(3,%r3) # (3) string2 address == %r3
arguw(1,%r0) # (1) strings length == %r0
jeql Lcmpc3_out
Lcmpc3_loop:
cmpb (%r1),(%r3)
jneq Lcmpc3_out
incl %r1
incl %r3
sobgtr %r0,Lcmpc3_loop
Lcmpc3_out:
savepsl
movl %r0,%r2
return
.align 1
ALTENTRY(EMcmpc5)
argl(2,%r1) # (2) string1 address == %r1
argub(3,%r11) # (1) fill character == %r11
arguw(4,%r2) # (1) string2 length == %r2
argl(5,%r3) # (3) string2 address == %r3
arguw(1,%r0) # (1) string1 length == %r0
jeql Lcmpc5_str2
Lcmpc5_loop:
tstl %r2
jeql Lcmpc5_str1loop
cmpb (%r1),(%r3)
jneq Lcmpc5_out
incl %r1
incl %r3
decl %r2
sobgtr %r0,Lcmpc5_loop
Lcmpc5_str2:
tstl %r2
jeql Lcmpc5_out
Lcmpc5_str2loop:
cmpb %r11,(%r3)
jneq Lcmpc5_out
incl %r3
sobgtr %r2,Lcmpc5_str2loop
jbr Lcmpc5_out
Lcmpc5_str1loop:
cmpb (%r1),%r11
jneq Lcmpc5_out
incl %r1
sobgtr %r0,Lcmpc5_str1loop
Lcmpc5_out:
savepsl
return
/*
* Packed Decimal string operations
*/
#define POSITIVE $12
#define NEGATIVE $13
#define NEGATIVEalt $11
.align 1
ALTENTRY(EMaddp4)
toarg(%r9,6) # save register %r9 in arg6 spot
arguw(1,%r11) # (1) source length == %r11
argl(2,%r10) # (2) source address == %r10
arguw(3,%r9) # (3) destination length == %r9
argl(4,%r3) # (4) destination address == %r3
ashl $-1,%r11,%r11
addl2 %r11,%r10 # source address of LSNibble
incl %r11 # source length is in bytes
ashl $-1,%r9,%r9
addl2 %r9,%r3 # %r3 = destination address of LSNibble
incl %r9 # destination length is in bytes
toarg(%r3,5)
extzv $0,$4,(%r3),%r2 # set standard +/- indicators in destination
cmpl %r2,NEGATIVE
jeql L112
cmpl %r2,NEGATIVEalt
jeql L111
insv POSITIVE,$0,$4,(%r3)
jbr L112
L111:
insv NEGATIVE,$0,$4,(%r3)
L112:
extzv $0,$4,(%r10),%r2 # %r2 = standard +/- of source
cmpl %r2,NEGATIVE
jeql L114
cmpl %r2,NEGATIVEalt
jeql L113
movl POSITIVE,%r2
jbr L114
L113:
movl NEGATIVE,%r2
L114:
cmpl %r11,%r9 # if source is longer than destination
jleq L115
movl %r9,%r11 # set source length == destination length
L115:
extzv $4,$4,(%r3),%r9 # %r9 = LSDigit of destination
extzv $4,$4,(%r10),%r1 # %r1 = LSDigit of source
extzv $0,$4,(%r3),%r0
cmpl %r0,%r2 # if signs of operands are not equal
jeql Laddp4_same # do a subtraction
clrl %r2 # %r2 is non-zero if result is non-zero
subl2 %r1,%r9 # %r9 = "addition" of operands high nibble
jbr L119 # jump into addition loop
Laddp4_diff_loop:
decl %r3
extzv $0,$4,(%r3),%r0
addl2 %r0,%r1 # %r1 = carry + next (low) nibble of source
decl %r10
extzv $0,$4,(%r10),%r0
subl2 %r0,%r1 # %r1 -= next (low) nibble of destination
jgeq L121 # if negative result
mnegl $1,%r9 # %r9 == carry = -1
addl2 $10,%r1 # %r1 == result += 10
jbr L122 # else
L121:
clrl %r9 # %r9 == carry = 0
L122:
insv %r1,$0,$4,(%r3) # store result low nibble
bisl2 %r1,%r2
extzv $4,$4,(%r3),%r0
addl2 %r0,%r9 # %r9 = carry + next (high) nibble of source
extzv $4,$4,(%r10),%r0
subl2 %r0,%r9 # %r9 -= next (high) nibble of destination
L119:
jgeq L117 # if negative result
mnegl $1,%r1 # %r1 == carry = -1
addl2 $10,%r9 # %r9 == result += 10
jbr L118 # else
L117:
clrl %r1 # %r1 == carry = 0
L118:
insv %r9,$4,$4,(%r3) # store result high nibble
bisl2 %r9,%r2 # %r2 is non-zero if result is non-zero
decl %r11 # while (--source length)
jneq Laddp4_diff_loop
argl(4,%r10) # %r10 = address of destination MSNibble
jbr Laddp4_diff_carry
Laddp4_diff_carlop:
decl %r3
extzv $0,$4,(%r3),%r0
addl2 %r0,%r1 # %r1 == carry += next (low) nibble
jgeq L127 # if less than zero
movl %r1,%r9 # %r9 == carry (must be -1)
movl $9,%r1 # %r1 == result = 9
jbr L128
L127: # else
clrl %r9 # %r9 == carry = 0
L128:
insv %r1,$0,$4,(%r3) # store result
bisl2 %r1,%r2
extzv $4,$4,(%r3),%r0
addl2 %r0,%r9 # %r9 == carry += next (high) nibble
jgeq L129 # if less than zero
movl %r9,%r1 # %r1 == carry (must be -1)
movl $9,%r9 # %r9 == result = 9
jbr L130
L129:
clrl %r1
L130:
insv %r9,$4,$4,(%r3) # store result
bisl2 %r9,%r2
Laddp4_diff_carry:
cmpl %r3,%r10
jneq Laddp4_diff_carlop
tstl %r1 # if carry out of MSN then fix up result
jeql Laddp4_add_done
argl(5,%r3) # %r3 == address of LSN of destination
extzv $0,$4,(%r3),%r0
cmpl %r0,NEGATIVE # switch sign of result
jneq L132
insv POSITIVE,$0,$4,(%r3)
jbr L133
L132:
insv NEGATIVE,$0,$4,(%r3)
L133:
extzv $4,$4,(%r3),%r0 # normalize result (carry out of MSN into LSN)
subl3 %r0,$10,%r9 # %r9 = 10 - destination LSNibble
jbr L134
L137:
movl $9,%r1
Laddp4_diff_norm:
insv %r9,$4,$4,(%r3)
cmpl %r3,%r10 # while (not at MSNibble)
jeql Laddp4_add_done
decl %r3
extzv $0,$4,(%r3),%r0 # low nibble = (9 + carry) - low nibble
subl2 %r0,%r1
cmpl %r1,$9
jleq L135
clrl %r1
movl $10,%r9
jbr L136
L135:
movl $9,%r9
L136:
insv %r1,$0,$4,(%r3)
extzv $4,$4,(%r3),%r0 # high nibble = (9 + carry) - high nibble
subl2 %r0,%r9
L134:
cmpl %r9,$9
jleq L137
clrl %r9
movl $10,%r1
jbr Laddp4_diff_norm
Laddp4_same: # operands are of the same sign
clrl %r2
addl2 %r1,%r9
jbr L139
Laddp4_same_loop:
decl %r3
extzv $0,$4,(%r3),%r0
addl2 %r0,%r1 # %r1 == carry += next (low) nibble of dest
decl %r10
extzv $0,$4,(%r10),%r0
addl2 %r0,%r1 # %r1 += next (low) nibble of source
cmpl %r1,$9 # if result > 9
jleq L141
movl $1,%r9 # %r9 == carry = 1
subl2 $10,%r1 # %r1 == result -= 10
jbr L142
L141: # else
clrl %r9 # %r9 == carry = 0
L142:
insv %r1,$0,$4,(%r3) # store result
bisl2 %r1,%r2
extzv $4,$4,(%r10),%r0
addl2 %r0,%r9 # ditto for high nibble
extzv $4,$4,(%r3),%r0
addl2 %r0,%r9
L139:
cmpl %r9,$9
jleq L143
movl $1,%r1
subl2 $10,%r9
jbr L144
L143:
clrl %r1
L144:
insv %r9,$4,$4,(%r3)
bisl2 %r9,%r2
sobgtr %r11,Laddp4_same_loop # while (--source length)
argl(4,%r10) # %r10 = destination address of MSNibble
jbr Laddp4_same_carry
Laddp4_same_cloop:
decl %r3
extzv $0,$4,(%r3),%r0 # propagate carry up to MSNibble of destination
addl2 %r0,%r1
cmpl %r1,$10
jneq L147
movl $1,%r9
clrl %r1
jbr L148
L147:
clrl %r9
L148:
insv %r1,$0,$4,(%r3)
bisl2 %r1,%r2
extzv $4,$4,(%r3),%r0
addl2 %r0,%r9
cmpl %r9,$10
jneq L149
movl $1,%r1
clrl %r9
jbr L150
L149:
clrl %r1
L150:
insv %r9,$4,$4,(%r3)
bisl2 %r9,%r2
Laddp4_same_carry:
cmpl %r3,%r10
jneq Laddp4_same_cloop
Laddp4_add_done:
argl(5,%r3) # %r3 = destination address of LSNibble
tstl %r2 # if zero result
jneq L151
savepsl # remember that for condition codes
insv POSITIVE,$0,$4,(%r3) # make sure sign of result is positive
jbr Laddp4_out
L151: # else
extzv $0,$4,(%r3),%r0
cmpl %r0,NEGATIVE # if result is negative
jneq Laddp4_out
mnegl %r2,%r2 # remember THAT in Cond Codes
savepsl
Laddp4_out:
argl(4,%r3)
argl(2,%r1)
clrl %r0
clrl %r2
argl(6,%r9) # restore %r9 from stack
return
.align 1
ALTENTRY(EMmovp)
arguw(1,%r11) # (1) string length == %r11
argl(2,%r10) # (1) source address == %r10
argl(3,%r3) # (1) destination address == %r3
# we will need arg2 and arg3 later
clrl %r2 # %r2 == non-zero if source is non-zero
ashl $-1,%r11,%r11 # length is number of bytes, not nibbles
jeql Lmovp_zlen
Lmovp_copy:
bisb2 (%r10),%r2 # keep track of non-zero source
movb (%r10)+,(%r3)+ # move two nibbles
sobgtr %r11,Lmovp_copy # loop for length of source
Lmovp_zlen:
extzv $4,$4,(%r10),%r0 # look at least significant nibble
bisl2 %r0,%r2
extzv $0,$4,(%r10),%r0 # check sign nibble
cmpl %r0,NEGATIVEalt
jeql Lmovp_neg
cmpl %r0,NEGATIVE
jneq Lmovp_pos
Lmovp_neg: # source was negative
mnegl %r2,%r2
Lmovp_pos:
tstl %r2 # set condition codes
savepsl
jeql Lmovp_zero
movb (%r10),(%r3) # move last byte if non-zero result
jbr Lmovp_out
Lmovp_zero:
movb POSITIVE,(%r3) # otherwise, make result zero and positive
Lmovp_out:
clrl %r0
argl(2,%r1)
clrl %r2
argl(3,%r3)
return
/*
* Definitions for Editpc instruction
*
* Here are the commands and their corresponding hex values:
*
* EPend 0x00
* EPend_float 0x01
* EPclear_signif 0x02
* EPset_signif 0x03
* EPstore_sign 0x04
* EPload_fill 0x40
* EPload_sign 0x41
* EPload_plus 0x42
* EPload_minus 0x43
* EPinsert 0x44
* EPblank_zero 0x45
* EPreplace_sign 0x46
* EPadjust_input 0x47
* EPfill 0x80
* EPmove 0x90
* EPfloat 0xa0
*
*
* %r4 is carved up as follows:
*
* -------------------------------------------
* | N Z V C |
* -------------------------------------------
*
* fill character is stuffed into arg5 space
* sign character is stuffed into arg6 space
*/
#define SIGNIFBIT $0
#define setsignif bisl2 $1,%r4
#define clsignif bicl2 $1,%r4
#define OVERFLOWBIT $1
#define setoverflow bisl2 $2,%r4
#define cloverflow bicl2 $2,%r4
#define ZEROBIT $2
#define setzero bisl2 $4,%r4
#define clzero bicl2 $4,%r4
#define NEGATIVEBIT $3
#define setnegative bisl2 $8,%r4
#define clnegative bicl2 $8,%r4
#define putfill movb arg5,(%r5)+
#define setfill(reg) movb reg,arg5
#define putsign movb arg6,(%r5)+
#define setsign(reg) movb reg,arg6
.align 1
ALTENTRY(EMeditpc)
arguw(1,%r11) # (1) source length == %r11
argl(2,%r10) # (2) source address == %r10
argl(3,%r3) # (3) pattern address == %r3
argl(4,%r5) # (4) destination address == %r5
/* # we will need arg1 and arg2 later */
/* # arg5 and arg6 are used for fill and sign - %r0 is free */
setfill($32) # fill character is ' '
setsign($32) # sign character is ' '
clrl %r4 # clear flags
ashl $-1,%r11,%r11 # source length / 2
addl3 %r11,%r10,%r2
extzv $4,$4,(%r2),%r1 # %r1 == least significant nibble of source
L169:
cmpl %r2,%r10
jeql L170
tstb -(%r2) # loop over source packed decimal number
jeql L169
incl %r1 # %r1 is non-zero if source is non-zero
L170:
addl3 %r11,%r10,%r2
tstl %r1
jeql L172 # source is zero - set flags
extzv $0,$4,(%r2),%r11
cmpl %r11,NEGATIVEalt
jeql L9998 # source is negative - set sign and flags
cmpl %r11,NEGATIVE
jneq L175
L9998:
setnegative
setsign($45) # sign character is '-'
jbr L175
L172:
setzero
L175:
arguw(1,%r2) # (1) source length == %r2
Ledit_case:
movzbl (%r3)+,%r11 # get next edit command (pattern)
cmpl %r11,$128
jlss L180
extzv $0,$4,%r11,%r1 # command has a "count" arg - into %r1
ashl $-4,%r11,%r11 # and shift over
L180:
jbc $6,%r11,L181 # "shift" those commands > 64 to 16 and up
subl2 $48,%r11
L181:
caseb %r11,$0,$0x18 # "do" the command
# %r11 is available for use, %r1 has "count" in it
Lcaseb_label:
.word Le_end - Lcaseb_label # 00
.word Le_end_float - Lcaseb_label # 01
.word Le_clear_signif - Lcaseb_label # 02
.word Le_set_signif - Lcaseb_label # 03
.word Le_store_sign - Lcaseb_label # 04
.word Le_end - Lcaseb_label # 05
.word Le_end - Lcaseb_label # 06
.word Le_end - Lcaseb_label # 07
.word Le_fill - Lcaseb_label # 80
.word Le_move - Lcaseb_label # 90
.word Le_float - Lcaseb_label # a0
.word Le_end - Lcaseb_label # b0
.word Le_end - Lcaseb_label # c0
.word Le_end - Lcaseb_label # d0
.word Le_end - Lcaseb_label # e0
.word Le_end - Lcaseb_label # f0
.word Le_load_fill - Lcaseb_label # 40
.word Le_load_sign - Lcaseb_label # 41
.word Le_load_plus - Lcaseb_label # 42
.word Le_load_minus - Lcaseb_label # 43
.word Le_insert - Lcaseb_label # 44
.word Le_blank_zero - Lcaseb_label # 45
.word Le_replace_sign - Lcaseb_label # 46
.word Le_adjust_input - Lcaseb_label # 47
Le_end:
arguw(1,%r0)
argl(2,%r1)
clrl %r2
decl %r3
setpsl(%r4)
clrl %r4
return
Le_end_float:
jbs SIGNIFBIT,%r4,Ledit_case # if significance not set
putsign # drop in the sign
# fall into...
Le_set_signif:
setsignif
jbr Ledit_case
Le_clear_signif:
clsignif
jbr Ledit_case
Le_store_sign:
putsign
jbr Ledit_case
Le_load_fill:
setfill((%r3)+)
jbr Ledit_case
Le_load_plus:
jbs NEGATIVEBIT,%r4,Lpattern_inc # if non-negative
# fall into...
Le_load_sign:
setsign((%r3)+)
jbr Ledit_case
Le_load_minus:
jbs NEGATIVEBIT,%r4,Le_load_sign # if negative load the sign
incl %r3 # else increment pattern
jbr Ledit_case
Le_insert:
jbc SIGNIFBIT,%r4,L196 # if significance set, put next byte
movb (%r3)+,(%r5)+
jbr Ledit_case
L196: # else put in fill character
putfill
# and throw away character in pattern
Le_replace_sign: # we dont do anything with
Lpattern_inc: # replace sign cause we dont
incl %r3 # get negative zero
jbr Ledit_case
Le_blank_zero:
jbc ZEROBIT,%r4,Lpattern_inc # if zero
movzbl (%r3)+,%r11 # next byte is a count
jeql Ledit_case
subl2 %r11,%r5 # to back up over output and replace
L200:
putfill # with fill character
sobgtr %r11,L200
jbr Ledit_case
Le_adjust_input:
movzbl (%r3)+,%r0 # get count of nibbles from pattern
subl3 %r2,%r0,%r11
jgeq Ledit_case # if length of source is > this number
L204: # discard digits in source
jlbc %r2,L206 # use low bit of length to choose nibble
bitb $0xf0,(%r10) # high nibble
jeql L208
setsignif # set significance and overflow if
setoverflow # wasted digit is non-zero
jbr L208
L206:
bitb $0xf,(%r10) # low nibble
jeql L209
setsignif
setoverflow
L209:
incl %r10 # increment to next byte
L208:
decl %r2 # decrement source length
incl %r11 # continue till were out of excess
jlss L204
jbr Ledit_case
Le_fill:
tstl %r1 # put (count in %r1) fill characters
jeql Ledit_case
Le_fill_loop:
putfill
sobgtr %r1,Le_fill_loop
jbr Ledit_case
Le_move:
tstl %r1 # move (count in %r1) characters
jeql Ledit_case # from source to destination
L214:
jlbc %r2,L215 # read a nibble
extzv $4,$4,(%r10),%r11
jbr L216
L215:
extzv $0,$4,(%r10),%r11
incl %r10
L216:
decl %r2 # source length CAN go negative here...
tstl %r11
jeql L218 # if non-zero
setsignif # set significance
L218:
jbc SIGNIFBIT,%r4,L219 # if significance set
addb3 $48,%r11,(%r5)+ # put 0 + digit into destination
jbr L220
L219: # else put fill character
putfill
L220:
sobgtr %r1,L214
jbr Ledit_case
Le_float: # move with floating sign character
tstl %r1
jeql Ledit_case
L221:
jlbc %r2,L222
extzv $4,$4,(%r10),%r11
jbr L223
L222:
extzv $0,$4,(%r10),%r11
incl %r10
L223:
decl %r2 # source length CAN go negative here...
tstl %r11
jeql L225
jbs SIGNIFBIT,%r4,L226
putsign
L226:
setsignif
L225:
jbc SIGNIFBIT,%r4,L227
addb3 $48,%r11,(%r5)+
jbr L228
L227:
putfill
L228:
sobgtr %r1,L221
jbr Ledit_case
.align 1
ALTENTRY(EMashp)
argb(1,%r11) # (1) scale (number to shift) == %r11
arguw(2,%r10) # (2) source length == %r10
argl(3,%r1) # (3) source address == %r1
argub(4,%r2) # (4) rounding factor == %r2
arguw(5,%r3) # (5) destination length == %r3
toarg(%r6,3)/* # arg3 holds register 6 from caller */
argl(6,%r6) # (6) destination address == %r6
/*
# we need arg6 for later
# arg1 is used for temporary storage
# arg2 holds "even or odd" destination length
# arg4 is used as general storage
# arg5 is used as general storage
*/
ashl $-1,%r3,%r0 # destination length is number of bytes
addl2 %r0,%r6 # destination address == least sig nibble
toarg(%r6,1) # save in arg1 spot for later
ashl $-1,%r10,%r0
addl2 %r0,%r1 # source address == least sig nibble
extzv $0,$4,(%r1),%r0 # determine sign of source
cmpl %r0,NEGATIVEalt
jeql Lashp_neg
cmpl %r0,NEGATIVE
jeql Lashp_neg
movb POSITIVE,(%r6)
jbr L245
Lashp_neg:
movb NEGATIVE,(%r6)
L245:
clrl arg2 # arg2 is 1 if dstlen is even, 0 if odd
blbs %r3,L246
incl arg2
bisl2 $1,%r3 # %r3<0> counts digits going into destination
L246: # and is flip-flop for which nibble to
tstl %r11 # write in destination (1 = high, 0 = low)
jgeq Lashp_left # (it must start out odd)
addl2 %r11,%r10 # scale is negative (right shift)
jgeq Lashp_right
clrl %r10 # test for shifting whole number out
jbr Lashp_setround
Lashp_right:
divl3 $2,%r11,%r0
addl2 %r0,%r1 # source address == MSNibble to be shifted off
jlbc %r11,L249
extzv $4,$4,(%r1),%r0
addl2 %r0,%r2 # round = last nibble to be shifted off + round
jbr Lashp_setround
L249:
extzv $0,$4,(%r1),%r0
addl2 %r0,%r2 # round = last nibble to be shifted off + round
Lashp_setround: # %r11<0> now is flip-flop for which nibble to
incl %r11 # read from source (1 == high, 0 == low)
cmpl %r2,$9 # set rounding factor to one if nibble shifted
jleq Lashp_noround # off + round argument was 10 or greater
movl $1,%r2
jbr Lashp_shift
Lashp_zloop:
jlbs %r3,L257 # dont need to clear high nibble twice
clrb -(%r6) # clear low (and high) nib of next byte in dest
L257:
sobgtr %r3,L258 # move to next nibble in destination, but
incl %r3 # dont go beyond the end.
L258:
decl %r11
Lashp_left: # while scale is positive
jneq Lashp_zloop
incl %r11 # %r11<0> is flip-plop ... (incl sets it to one)
Lashp_noround:
clrl %r2 # no more rounding
Lashp_shift:
clrl arg4 # arg4 will be used for result condition codes
tstl %r10
jeql Lashp_round
Lashp_shloop:
jlbc %r11,L260
extzv $4,$4,(%r1),%r0
jbr L261
L260:
decl %r1
extzv $0,$4,(%r1),%r0
L261:
incl %r11 # flip the source nibble flip/flop
addl2 %r0,%r2 # round += next nibble
cmpl %r2,$10 # if round == 10
jneq L262
clrl arg5 # then result = 0 and round = 1
movl $1,%r2
jbr L263
L262: # else
movl %r2,arg5 # store result and round = 0
clrl %r2
L263:
bisl2 arg5,arg4 # remember if result was nonzero in arg4
decl %r3 # move to next nibble early to check
cmpl %r3,arg2 # if weve moved passed destination limits
jgeq Lashp_noovfl # test the result for possible overflow
movl arg2,%r3 # ignore zero nibbles
tstl arg5 # if the nibble was non-zero, overflow
jeql L265
jbr Lashp_overfl
Lashp_noovfl: # else
jlbs %r3,L264
insv arg5,$4,$4,(%r6) # put the result into destination (high or low)
jbr L265
L264:
movb arg5,-(%r6)
L265:
sobgtr %r10,Lashp_shloop # loop for length of source
Lashp_round:
tstl %r2 # take care of round out of high nibble
jeql Lashp_zeroround
decl %r3
cmpl %r3,arg2 # if weve moved passed destination limits
jlss Lashp_overfl # then overflow
jlbs %r3,L266
insv arg5,$4,$4,(%r6) # put the round into destination (high or low)
jbr Lashp_zeroround
L266:
movb arg5,-(%r6)
Lashp_zeroround:
argl(1,%r10) # %r10 = address of destination LSNibble
argl(6,%r3) # %r3 = address of destination MSNibble
movl arg4,%r11 # %r11 = non-zero if destination == non-zero
savepsl
jbr L267
Lashp_zerofill:
clrb -(%r6) # fill up MSNs of destination with zeros
L267:
cmpl %r3,%r6
jneq Lashp_zerofill
extzv $0,$4,(%r10),%r0 # test for negative result
cmpl %r0,NEGATIVE
jneq Lashp_out
mnegl %r11,%r11
savepsl
jneq Lashp_out # turn -0 into 0
insv POSITIVE,$0,$4,(%r10)
Lashp_out:
clrl %r0
argl(3,%r6) # restore %r6 from stack
return
Lashp_overfl: # do overflow
clrl %r2
overflowpsl
jbr Lashp_out
.align 1
ALTENTRY(EMcvtlp)
arguw(2,%r10) # (2) destination length == %r10
argl(3,%r3) # (3) destination address == %r3
ashl $-1,%r10,%r10
addl2 %r10,%r3 # destination address points to Least Sig byte
incl %r10 # length is # of bytes, not nibbles
argl(1,%r11) # (1) source == %r11
savepsl
jgeq Lcvtlp_pos
movb NEGATIVE,(%r3) # source is negative
divl3 $10,%r11,%r0
mull3 $10,%r0,%r1
subl3 %r11,%r1,%r2 # %r2 = source mod 10
mnegl %r0,%r11 # source = -(source / 10)
jbr Lcvtlp_cvt
Lcvtlp_pos:
movb POSITIVE,(%r3) # source is non-negative
divl3 $10,%r11,%r0
mull3 $10,%r0,%r1
subl3 %r1,%r11,%r2 # %r2 = source mod 10
movl %r0,%r11 # source = source / 10
Lcvtlp_cvt:
insv %r2,$4,$4,(%r3) # store least significant digit
tstl %r11
jeql Lcvtlp_zloop
Lcvtlp_loop: # while source is non-zero
decl %r10 # and for length of destination ...
jeql Lcvtlp_over
divl3 $10,%r11,%r1 # %r1 = source / 10
mull3 $10,%r1,%r0
subl2 %r0,%r11 # source = source mod 10
movb %r11,-(%r3) # store low "nibble" in next significant byte
divl3 $10,%r1,%r11 # source = %r1 / 10
mull3 $10,%r11,%r0
subl2 %r0,%r1 # %r1 = source mod 10
insv %r1,$4,$4,(%r3) # store high nibble
tstl %r11
jneq Lcvtlp_loop # quit if source becomes zero
Lcvtlp_zloop: # fill any remaining bytes with zeros
decl %r10
jeql Lcvtlp_out
clrb -(%r3)
jbr Lcvtlp_zloop
Lcvtlp_over:
overflowpsl
Lcvtlp_out:
clrl %r1 # %r0 is already zero
clrl %r2
return
.align 1
ALTENTRY(EMcvtpl)
arguw(1,%r11) # (1) source length == %r11
argl(2,%r10) # (2) source address == %r10
clrl %r3 # %r3 == destination
movl %r10,%r1 # %r1 set up now for return
ashl $-1,%r11,%r11 # source length is number of bytes
jeql Lcvtpl_zero
Lcvtpl_loop: # for source length
mull2 $10,%r3 # destination *= 10
extzv $4,$4,(%r10),%r0
addl2 %r0,%r3 # destination += high nibble
mull2 $10,%r3 # destination *= 10
extzv $0,$4,(%r10),%r0
addl2 %r0,%r3 # destination += low nibble
incl %r10
sobgtr %r11,Lcvtpl_loop
Lcvtpl_zero: # least significant byte
mull2 $10,%r3
extzv $4,$4,(%r10),%r0
addl2 %r0,%r3 # dest = 10 * dest + high nibble
savepsl
extzv $0,$4,(%r10),%r2 # test sign nibble
cmpl %r2,NEGATIVE
jeql Lcvtpl_neg
cmpl %r2,NEGATIVEalt
jneq Lcvtpl_out
Lcvtpl_neg: # source was negative - negate destination
mnegl %r3,%r3
savepsl
Lcvtpl_out:
toarg(%r3,3)
clrl %r0
clrl %r2
clrl %r3
return
.align 1
ALTENTRY(EMcvtps)
return
.align 1
ALTENTRY(EMcvtsp)
return
.align 1
ALTENTRY(EMaddp6)
return
.align 1
ALTENTRY(EMsubp4)
return
.align 1
ALTENTRY(EMsubp6)
return
.align 1
ALTENTRY(EMcvtpt)
return
.align 1
ALTENTRY(EMmulp)
return
.align 1
ALTENTRY(EMcvttp)
return
.align 1
ALTENTRY(EMdivp)
return
.align 1
ALTENTRY(EMcmpp3)
return
.align 1
ALTENTRY(EMcmpp4)
return
#ifdef notdef
/*
* Emulation OpCode jump table:
* ONLY GOES FROM 0xf8 (-8) TO 0x3B (59)
*/
#define EMUTABLE 0x43
#define NOEMULATE .long noemulate
#define EMULATE(a) .long _EM/**/a
.globl _C_LABEL(emJUMPtable)
_C_LABEL(emJUMPtable)
/* f8 */ EMULATE(ashp); EMULATE(cvtlp); NOEMULATE; NOEMULATE
/* fc */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
/* 00 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
/* 04 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
/* 08 */ EMULATE(cvtps); EMULATE(cvtsp); NOEMULATE; EMULATE(crc)
/* 0c */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
/* 10 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
/* 14 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
/* 18 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
/* 1c */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
/* 20 */ EMULATE(addp4); EMULATE(addp6); EMULATE(subp4); EMULATE(subp6)
/* 24 */ EMULATE(cvtpt); EMULATE(mulp); EMULATE(cvttp); EMULATE(divp)
/* 28 */ NOEMULATE; EMULATE(cmpc3); EMULATE(scanc); EMULATE(spanc)
/* 2c */ NOEMULATE; EMULATE(cmpc5); EMULATE(movtc); EMULATE(movtuc)
/* 30 */ NOEMULATE; NOEMULATE; NOEMULATE; NOEMULATE
/* 34 */ EMULATE(movp); EMULATE(cmpp3); EMULATE(cvtpl); EMULATE(cmpp4)
/* 38 */ EMULATE(editpc); EMULATE(matchc); EMULATE(locc); EMULATE(skpc)
/*
* The following is called with the stack set up as follows:
*
* (%sp): Opcode
* 4(%sp): Instruction PC
* 8(%sp): Operand 1
* 12(%sp): Operand 2
* 16(%sp): Operand 3
* 20(%sp): Operand 4
* 24(%sp): Operand 5
* 28(%sp): Operand 6
* 32(%sp): Operand 7 (unused)
* 36(%sp): Operand 8 (unused)
* 40(%sp): Return PC
* 44(%sp): Return PSL
* 48(%sp): TOS before instruction
*
* Each individual routine is called with the stack set up as follows:
*
* (%sp): Return address of trap handler
* 4(%sp): Opcode (will get return PSL)
* 8(%sp): Instruction PC
* 12(%sp): Operand 1
* 16(%sp): Operand 2
* 20(%sp): Operand 3
* 24(%sp): Operand 4
* 28(%sp): Operand 5
* 32(%sp): Operand 6
* 36(%sp): saved register 11
* 40(%sp): saved register 10
* 44(%sp): Return PC
* 48(%sp): Return PSL
* 52(%sp): TOS before instruction
*/
SCBVEC(emulate):
movl %r11,32(%sp) # save register %r11 in unused operand
movl %r10,36(%sp) # save register %r10 in unused operand
cvtbl (%sp),%r10 # get opcode
addl2 $8,%r10 # shift negative opcodes
subl3 %r10,$EMUTABLE,%r11 # forget it if opcode is out of range
bcs noemulate
movl _C_LABEL(emJUMPtable)[%r10],%r10
# call appropriate emulation routine
jsb (%r10) # routines put return values into regs 0-5
movl 32(%sp),%r11 # restore register %r11
movl 36(%sp),%r10 # restore register %r10
insv (%sp),$0,$4,44(%sp) # and condition codes in Opcode spot
addl2 $40,%sp # adjust stack for return
rei
noemulate:
addl2 $48,%sp # adjust stack for
.word 0xffff # "reserved instruction fault"
SCBVEC(emulateFPD):
.word 0xffff # "reserved instruction fault"
#endif