428 lines
9.6 KiB
ArmAsm
428 lines
9.6 KiB
ArmAsm
# Copyright Digital Equipment Corporation & INRIA 1988, 1989
|
|
#
|
|
# KerN for NS32032
|
|
# Francis Dupont
|
|
#
|
|
.text
|
|
|
|
.globl _BnnSetToZero
|
|
.align 2
|
|
_BnnSetToZero: .set BSTZnn,4
|
|
.set BSTZnl,8
|
|
movd BSTZnn(sp),r0
|
|
movd BSTZnl(sp),r1
|
|
acbd 0,r1,BSTZ1 # ?? test a 0 + rapide ??
|
|
ret 0
|
|
BSTZ1: movqd 0,0(r0) # *nn = 0;
|
|
addqd 4,r0 # nn++;
|
|
acbd -1,r1,BSTZ1 # if!(--nl) goto BSTZ1;
|
|
ret 0
|
|
|
|
.globl _BnnAssign
|
|
.align 2
|
|
_BnnAssign: .set BAGmm,4
|
|
.set BAGnn,8
|
|
.set BAGnl,12
|
|
movd BAGnl(sp),r0
|
|
movd BAGnn(sp),r1
|
|
movd BAGmm(sp),r2
|
|
cmpd r2,r1
|
|
bge BAG1 # if(mm >= nn) goto BAG1;
|
|
movsd # bcopy(nn, mm, 4*nl);
|
|
ret 0
|
|
BAG1: addr r2[r0:d],r2 # mm = &mm[nl];
|
|
addr r1[r0:d],r1 # nn = &nn[nl];
|
|
addqd -4,r2 # mm--;
|
|
addqd -4,r1 # nn--;
|
|
movsd b # revbcopy(nn, mm, 4*nl);
|
|
ret 0
|
|
|
|
.globl _BnnSetDigit
|
|
.align 2
|
|
_BnnSetDigit: .set BSDnn,4
|
|
.set BSDd,8
|
|
movd BSDd(sp),0(BSDnn(sp)) # *nn = d;
|
|
ret 0
|
|
|
|
.globl _BnnGetDigit
|
|
.align 2
|
|
_BnnGetDigit: .set BGDnn,4
|
|
movd 0(BGDnn(sp)),r0 # return(*nn);
|
|
ret 0
|
|
|
|
.globl _BnnNumDigits
|
|
.align 2
|
|
_BnnNumDigits: .set BNDnn,4
|
|
.set BNDnl,8
|
|
movd BNDnl(sp),r0
|
|
cmpqd 0,r0
|
|
beq BND2 # if(nl == 0) return(1);
|
|
addr 0(BNDnn(sp))[r0:d],r1 # nn = &nn[nd];
|
|
BND1: addqd -4,r1 # --nn;
|
|
cmpqd 0,0(r1)
|
|
bne BND3 # if(*nn != 0) return(nl);
|
|
acbd -1,r0,BND1 # if(!--nl) goto BND1;
|
|
BND2: movqd 1,r0 # return(1);
|
|
BND3: ret 0
|
|
|
|
.globl _BnnNumLeadingZeroBitsInDigit
|
|
.align 2
|
|
_BnnNumLeadingZeroBitsInDigit: .set BLZd,4
|
|
movd BLZd(sp),r1
|
|
movd 31,r0 # ret = 31;
|
|
BLZ1: tbitd r0,r1
|
|
bfs BLZ2 # if(d & 2^ret) goto BLZ2;
|
|
addqd -1,r0
|
|
bcs BLZ1 # if(--ret) goto BLZ1;
|
|
BLZ2: negd r0,r0
|
|
addd 31,r0 # return(31 - ret);
|
|
ret 0
|
|
|
|
.globl _BnnDoesDigitFitInWord
|
|
.align 2
|
|
_BnnDoesDigitFitInWord: .set BDFd,4
|
|
movqd 1,r0 # return(1);
|
|
ret 0
|
|
|
|
.globl _BnnIsDigitZero
|
|
.align 2
|
|
_BnnIsDigitZero: .set BDZd,4
|
|
cmpqd 0,BDZd(sp) # return(!d);
|
|
seqd r0
|
|
ret 0
|
|
|
|
.globl _BnnIsDigitNormalized
|
|
.align 2
|
|
_BnnIsDigitNormalized: .set BDNd,4
|
|
tbitd 31,BDNd(sp) # return(d & 2^31);
|
|
sfsd r0
|
|
ret 0
|
|
|
|
.globl _BnnIsDigitOdd
|
|
.align 2
|
|
_BnnIsDigitOdd: .set BDOd,4
|
|
movqd 1,r0 # return(d & 1);
|
|
andd BDOd(sp),r0
|
|
ret 0
|
|
|
|
.globl _BnnCompareDigits
|
|
.align 2
|
|
_BnnCompareDigits: .set BCDd1,4
|
|
.set BCDd2,8
|
|
cmpd BCDd1(sp),BCDd2(sp)
|
|
bhs BCD1 # if(d1 >= d2)
|
|
movqd -1,r0 # return(-1);
|
|
ret 0
|
|
BCD1: sned r0 # return(d1 != d2);
|
|
ret 0
|
|
|
|
.globl _BnnComplement
|
|
.align 2
|
|
_BnnComplement: .set BCMnn,4
|
|
.set BCMnl,8
|
|
movd BCMnl(sp),r1
|
|
cmpqd 0,r1
|
|
beq BCM2 # if(nl == 0) return;
|
|
movd BCMnn(sp),r0
|
|
BCM1: comd 0(r0),0(r0) # *nn ^= -1;
|
|
addqd 4,r0 # nn++;
|
|
acbd -1,r1,BCM1 # if(!--nl) goto BCM1;
|
|
BCM2: ret 0
|
|
|
|
.globl _BnnAndDigits
|
|
.align 2
|
|
_BnnAndDigits: .set BADnn,4
|
|
.set BADd,8
|
|
andd BADd(sp),0(BADnn(sp)) # *nn &= d;
|
|
ret 0
|
|
|
|
.globl _BnnOrDigits
|
|
.align 2
|
|
_BnnOrDigits: .set BODnn,4
|
|
.set BODd,8
|
|
ord BODd(sp),0(BODnn(sp)) # *nn |= d;
|
|
ret 0
|
|
|
|
.globl _BnnXorDigits
|
|
.align 2
|
|
_BnnXorDigits: .set BXDnn,4
|
|
.set BXDd,8
|
|
xord BXDd(sp),0(BXDnn(sp)) # *nn ^= d;
|
|
ret 0
|
|
|
|
.globl _BnnShiftLeft
|
|
.align 2
|
|
_BnnShiftLeft: .set BSLmm,8
|
|
.set BSLml,12
|
|
.set BSLnbi,16
|
|
enter [r3,r4,r5,r6],0
|
|
movqd 0,r0 # res = 0;
|
|
movd BSLnbi(fp),r5
|
|
cmpqd 0,r5
|
|
beq BSL2 # if(nbi == 0) return(res);
|
|
movd BSLml(fp),r3
|
|
cmpqd 0,r3
|
|
beq BSL2 # if(ml == 0) return(res);
|
|
movd r5,r6
|
|
subd 32,r6 # rnbi = nbi - BN_DIGIT_SIZE;
|
|
movd BSLmm(fp),r2
|
|
BSL1: movd 0(r2),r1 # save = *mm;
|
|
movd r1,r4 # X = save;
|
|
lshd r5,r4 # X <<= nbi;
|
|
ord r0,r4 # X |= res;
|
|
movd r4,0(r2) # *mm = X;
|
|
addqd 4,r2 # mm++;
|
|
movd r1,r0 # res = save;
|
|
lshd r6,r0 # res <<= rnbi;
|
|
acbd -1,r3,BSL1 # if(!--nl) goto BSL1;
|
|
BSL2: exit [r3,r4,r5,r6]
|
|
ret 0
|
|
|
|
.globl _BnnShiftRight
|
|
.align 2
|
|
_BnnShiftRight: .set BSRmm,8
|
|
.set BSRml,12
|
|
.set BSRnbi,16
|
|
enter [r3,r4,r5,r6],0
|
|
movqd 0,r0 # res = 0;
|
|
movd BSRnbi(fp),r1
|
|
cmpqd 0,r1 # if(nbi == 0) return(res);
|
|
beq BSR2
|
|
movd BSRml(fp),r3
|
|
cmpqd 0,r3
|
|
beq BSR2 # if(ml == 0) return(res);
|
|
addr @32,r6
|
|
subd r1,r6 # rnbi = BN_DIGIT_SIZE - nbi;
|
|
negd r1,r5 # nbi = - nbi;
|
|
addr 0(BSRmm(fp))[r3:d],r2 # mm = &mm[ml];
|
|
BSR1: addqd -4,r2 # mm--;
|
|
movd 0(r2),r1 # save = *mm;
|
|
movd r1,r4 # X = save;
|
|
lshd r5,r4 # X <<= nbi;
|
|
ord r0,r4 # X |= res
|
|
movd r4,0(r2) # *mm = X;
|
|
movd r1,r0 # res = save;
|
|
lshd r6,r0 # res <<= rnbi;
|
|
acbd -1,r3,BSR1 # if(!--nl) goto BSR1;
|
|
BSR2: exit [r3,r4,r5,r6]
|
|
ret 0
|
|
|
|
.globl _BnnAddCarry
|
|
.align 2
|
|
_BnnAddCarry: .set BACnn,4
|
|
.set BACnl,8
|
|
.set BACcar,12
|
|
cmpqd 0,BACcar(sp)
|
|
beq BAC3 # if(car == 0) return(0);
|
|
movd BACnl(sp),r0
|
|
cmpqd 0,r0 # if(nl = 0) return(1);
|
|
beq BAC2
|
|
movd BACnn(sp),r1
|
|
BAC1: addqd 1,0(r1) # ++(*nn);
|
|
bcc BAC3 # if(!Carry) return(0);
|
|
addqd 4,r1 # nn++;
|
|
acbd -1,r0,BAC1 # if(!--nl) goto BAC1;
|
|
BAC2: movqd 1,r0 # return(1);
|
|
ret 0
|
|
BAC3: movqd 0,r0 # return(0);
|
|
ret 0
|
|
|
|
.globl _BnnAdd
|
|
.align 2
|
|
_BnnAdd: .set BADDmm,8
|
|
.set BADDml,12
|
|
.set BADDnn,16
|
|
.set BADDnl,20
|
|
.set BADDcar,24
|
|
enter [r3,r4,r5],0
|
|
movd BADDnl(fp),r4
|
|
movd BADDcar(fp),r1
|
|
movd BADDmm(fp),r2
|
|
movd BADDnn(fp),r3
|
|
movd BADDml(fp),r5
|
|
subd r4,r5 # ml -= nl
|
|
BADD1: cmpqd 0,r4
|
|
beq BADD4 # if(nl == 0) goto BADD4;
|
|
addqd -1,r4 # nl--;
|
|
addd 0(r2),r1 # car += *mm;
|
|
bcc BADD2 # if(!Carry) goto BADD2;
|
|
movd 0(r3),0(r2) # *mm = *nn;
|
|
addqd 4,r3 # nn++;
|
|
addqd 4,r2 # mm++;
|
|
movqd 1,r1 # car = 1
|
|
br BADD1 # goto BADD1
|
|
BADD2: movd 0(r3),r0 # save = *nn;
|
|
addqd 4,r3 # nn++;
|
|
addd r0,r1 # car += save;
|
|
movd r1,0(r2) # *mm = car;
|
|
addqd 4,r2 # mm++;
|
|
cmpd r1,r0
|
|
slod r1 # car = (car < save) ? 1 : 0;
|
|
br BADD1 # goto BADD1;
|
|
|
|
BADD4: cmpqd 0,r1 # if (car == 0) return(0);
|
|
beq BADD8
|
|
cmpqd 0,r5 # if (ml == 0) return(1);
|
|
beq BADD9
|
|
BADD5: addqd 1,0(r2) # ++(*mm);
|
|
bcc BADD8 # if(Carry) return(0):
|
|
addqd 4,r2 # mm++;
|
|
acbd -1,r5,BADD5 # if(!--ml) goto BADD5;
|
|
BADD9: movqd 1,r0 # return(1);
|
|
exit [r3,r4,r5]
|
|
ret 0
|
|
BADD8: movqd 0,r0 # return(0);
|
|
exit [r3,r4,r5]
|
|
ret 0
|
|
|
|
.globl _BnnSubtractBorrow
|
|
.align 2
|
|
_BnnSubtractBorrow: .set BSBnn,4
|
|
.set BSBnl,8
|
|
.set BSBcar,12
|
|
cmpqd 1,BSBcar(sp)
|
|
beq BSB3 # if(car == 1) return(1);
|
|
movd BSBnl(sp),r0
|
|
cmpqd 0,r0
|
|
beq BSB2 # if(nl == 0) return(0);
|
|
movd BSBnn(sp),r1
|
|
BSB1: addqd -1,0(r1) # (*nn)--;
|
|
bcs BSB3 # if(Carry) return(1);
|
|
addqd 4,r1 # nn++;
|
|
acbd -1,r0,BSB1 # if(!--nl) goto BSB1;
|
|
BSB2: ret 0 # return(nl);
|
|
BSB3: movqd 1,r0 # return(1);
|
|
ret 0
|
|
|
|
|
|
.globl _BnnSubtract
|
|
.align 2
|
|
_BnnSubtract: .set BSmm,8
|
|
.set BSml,12
|
|
.set BSnn,16
|
|
.set BSnl,20
|
|
.set BScar,24
|
|
enter [r3,r4,r5,r6],0
|
|
movd BSmm(fp),r4
|
|
movd BSml(fp),r6
|
|
movd BSnn(fp),r3
|
|
movd BSnl(fp),r5
|
|
movd BScar(fp),r1
|
|
subd r5,r6 # ml -= nl;
|
|
BS1: cmpqd 0,r5
|
|
beq BS4 # if (nl == 0) goto BS4;
|
|
addqd -1,r5 # nl--;
|
|
addd 0(r4),r1 # car += *mm;
|
|
bcc BS2 # if(!Carry) goto BS2;
|
|
comd 0(r3),0(r4) # *mm = ~*nn
|
|
addqd 4,r3 # nn++
|
|
addqd 4,r4 # mm++
|
|
movqd 1,r1 # car = 1;
|
|
br BS1 # goto BS1;
|
|
BS2: comd 0(r3),r0 # save = *nn;
|
|
addqd 4,r3 # nn++;
|
|
addd r0,r1 # car += save;
|
|
movd r1,0(r4) # *mm = car;
|
|
addqd 4,r4 # mm++;
|
|
cmpd r1,r0
|
|
slod r1 # car = (car < save) ? 1 : 0;
|
|
br BS1 # goto BS1;
|
|
|
|
BS4: cmpqd 1,r1
|
|
beq BS8 # if(car == 1) return(1);
|
|
cmpqd 0,r6
|
|
beq BS9 # if(ml != 0) return(0);
|
|
BS5: addqd -1,0(r4) # (*mm)--;
|
|
bcs BS8 # if(Carry) return(1);
|
|
addqd 4,r4 # mm++;
|
|
acbd -1,r6,BS5 # if(!--ml) goto BS5;
|
|
BS9: movqd 0,r0 # return(0);
|
|
exit [r3,r4,r5,r6]
|
|
ret 0
|
|
BS8: movqd 1,r0 # return(1);
|
|
exit [r3,r4,r5,r6]
|
|
ret 0
|
|
|
|
.globl _BnnMultiplyDigit
|
|
.align 2
|
|
_BnnMultiplyDigit: .set BMDpp,8
|
|
.set BMDpl,12
|
|
.set BMDmm,16
|
|
.set BMDml,20
|
|
.set BMDd,24
|
|
enter [r3,r4,r5,r6,r7],0
|
|
movd BMDd(fp),r0
|
|
cmpqd 0,r0
|
|
beq BMD10 # if(d == 0) return(0);
|
|
cmpqd 1,r0
|
|
bne BMD1 # if(d != 1) goto BMD1;
|
|
exit [r3,r4,r5,r6,r7]
|
|
movqd 0,20(sp)
|
|
br _BnnAdd # BnAdd(pp,pl,mm,ml,0);
|
|
BMD1: movqd 0,r7 # c = 0;
|
|
movd BMDpp(fp),r4
|
|
movd BMDml(fp),r5
|
|
movd BMDpl(fp),r6
|
|
subd r5,r6 # pl -= ml;
|
|
cmpqd 0,r5
|
|
beq BMD7 # if(ml == 0) goto BMD7;
|
|
movd BMDmm(fp),r1
|
|
BMD2: movd 0(r1),r2 # save = *mm;
|
|
addqd 4,r1 # mm++;
|
|
meid r0,r2 # X = d * save;
|
|
addd r7,r2 # X += c;
|
|
bcc BMD3 # if(Carry) XH++;
|
|
addqd 1,r3
|
|
BMD3: addd r2,0(r4) # *pp += XL;
|
|
bcc BMD4 # if(Carry) XH++;
|
|
addqd 1,r3
|
|
BMD4: addqd 4,r4 # pp++;
|
|
movd r3,r7 # c = XL;
|
|
acbd -1,r5,BMD2 # if(!--ml) goto BMD2;
|
|
BMD7: addd r7,0(r4) # *pp += c;
|
|
bcc BMD10 # if(!Carry) return(0);
|
|
addqd 4,r4 # pp++;
|
|
addqd -1,r6 # pl--;
|
|
cmpqd 0,r6
|
|
beq BMD11 # if (pl == 0) goto BMD11;
|
|
BMD8: addqd 1,0(r4) # ++(*p);
|
|
bcc BMD10 # if(!Carry) return(0);
|
|
addqd 4,r4 # pp++;
|
|
acbd -1,r6,BMD8 # if(!--pl) goto BMD8;
|
|
BMD11: movqd 1,r0 # return(1);
|
|
exit [r3,r4,r5,r6,r7]
|
|
ret 0
|
|
BMD10: movqd 0,r0 # return(0);
|
|
exit [r3,r4,r5,r6,r7]
|
|
ret 0
|
|
|
|
.globl _BnnDivideDigit
|
|
.align 2
|
|
_BnnDivideDigit: .set BDDqq,8
|
|
.set BDDnn,12
|
|
.set BDDnl,16
|
|
.set BDDd,20
|
|
enter [r3,r4,r5],0
|
|
movd BDDd(fp),r2
|
|
movd BDDnl(fp),r3
|
|
addr 0(BDDnn(fp))[r3:d],r4 # nn = &nn[nl];
|
|
addqd -1,r3 # nl--;
|
|
addr 0(BDDqq(fp))[r3:d],r5 # qq = &qq[nl];
|
|
addqd -4,r4 # nn--;
|
|
movd 0(r4),r1 # Xhig = *nn;
|
|
cmpqd 0,r3
|
|
beq BDD2 # if(nl == 0) return(Xhig);
|
|
BDD1: addqd -4,r4 # --nn;
|
|
addqd -4,r5 # --qq;
|
|
movd 0(r4),r0 # Xlow = *nn;
|
|
deid r2,r0 # Xlow = X % c;
|
|
# Xhig = X / c;
|
|
movd r1,0(r5) # *qq = Xhig;
|
|
movd r0,r1 # Xhig = Xlow;
|
|
acbd -1,r3,BDD1 # if(!--nl) goto BDD1;
|
|
exit [r3,r4,r5] # return(Xlow);
|
|
ret 0
|
|
BDD2: movd r1,r0 # return(Xlow);
|
|
exit [r3,r4,r5]
|
|
ret 0
|