411 lines
9.5 KiB
ArmAsm
411 lines
9.5 KiB
ArmAsm
| Copyright Digital Equipment Corporation & INRIA 1988, 1989
|
|
|
|
|
| KerN for the 68020 : MOTOROLA syntax
|
|
| [Bepaul]
|
|
|
|
|
SECTION 10
|
|
|
|
XDEF _BnnSetToZero
|
|
BSTZnn EQU 4
|
|
BSTZnl EQU 8
|
|
_BnnSetToZero MOVE.L BSTZnn(A7),A0
|
|
MOVE.L BSTZnl(A7),D0
|
|
DBF D0,BSTZ1 | if(nl--) goto BSTZ1;
|
|
RTS | return;
|
|
BSTZ1 CLR.L (A0)+ | *(nn++) = 0;
|
|
DBF D0,BSTZ1 | if(nl--) goto BSTZ1;
|
|
RTS | return;
|
|
|
|
XDEF _BnnAssign
|
|
BAGmm EQU 4
|
|
BAGnn EQU 8
|
|
BAGnl EQU 12
|
|
_BnnAssign MOVE.L BAGmm(A7),A0
|
|
MOVE.L BAGnn(A7),A1
|
|
MOVE.L BAGnl(A7),D0
|
|
CMP.L A1,A0
|
|
BCC BAG2 | if(mm >= nn) goto BAG2;
|
|
DBF D0,BAG1 | if(nl--) goto BAG1;
|
|
RTS | return;
|
|
BAG1 MOVE.L (A1)+,(A0)+ | *(mm++) = *(nn++);
|
|
DBF D0,BAG1 | if(nl--) goto BAG1;
|
|
RTS | return;
|
|
BAG2 BLS BAG4 | if(mm <= nn) goto BAG4;
|
|
LEA 0(A0,D0.L*4),A0 | mm = &mm[nl];
|
|
LEA 0(A1,D0.L*4),A1 | nn = &nn[nl];
|
|
DBF D0,BAG3 | if(nl--) goto BAG3;
|
|
RTS | return;
|
|
BAG3 MOVE.L -(A1),-(A0) | *(--mm) = *(--nn);
|
|
DBF D0,BAG3 | if(nl--) goto BAG3;
|
|
BAG4 RTS | return;
|
|
|
|
XDEF _BnnSetDigit
|
|
BSDnn EQU 4
|
|
BSDd EQU 8
|
|
_BnnSetDigit MOVE.L BSDnn(A7),A0
|
|
MOVE.L BSDd(A7),(A0) | *nn = d;
|
|
RTS | return;
|
|
|
|
XDEF _BnnGetDigit
|
|
BGDnn EQU 4
|
|
_BnnGetDigit MOVE.L BGDnn(A7),A0
|
|
MOVE.L (A0),D0 | return(*nn);
|
|
RTS
|
|
|
|
XDEF _BnnNumDigits
|
|
BNDnn EQU 4
|
|
BNDnl EQU 8
|
|
_BnnNumDigits MOVE.L BNDnn(A7),A0
|
|
MOVE.L BNDnl(A7),D0
|
|
LEA 0(A0,D0.L*4),A0 | nn = &nn[nl];
|
|
DBF D0,BND1 | if(nl--) goto BND1;
|
|
MOVEQ #1,D0
|
|
RTS | return(1);
|
|
BND1 TST.L -(A0)
|
|
BNE BND3 | if(*(--nn) != 0) goto BND3;
|
|
DBF D0,BND1 | if(nl--) goto BND1;
|
|
MOVEQ #1,D0
|
|
RTS | return(1);
|
|
BND3 ADDQ.L #1,D0
|
|
RTS | return(nl + 1);
|
|
|
|
XDEF _BnnNumLeadingZeroBitsInDigit
|
|
BLZd EQU 4
|
|
_BnnNumLeadingZeroBitsInDigit
|
|
BFFFO BLZd(A7){#0:#32},D0
|
|
RTS
|
|
|
|
XDEF _BnnDoesDigitFitInWord
|
|
BDFd EQU 4
|
|
_BnnDoesDigitFitInWord
|
|
MOVEQ #1,D0 | C_VERSION
|
|
RTS
|
|
|
|
XDEF _BnnIsDigitZero
|
|
BDZd EQU 4
|
|
_BnnIsDigitZero CLR.L D0
|
|
TST.L BDZd(A7)
|
|
SEQ D0
|
|
RTS | return(d == 0);
|
|
|
|
XDEF _BnnIsDigitNormalized
|
|
BDNd EQU 4
|
|
_BnnIsDigitNormalized
|
|
CLR.L D0
|
|
TST.W BDNd(A7)
|
|
SMI D0
|
|
RTS | return(d < 0);
|
|
|
|
XDEF _BnnIsDigitOdd
|
|
BDOd EQU 4
|
|
_BnnIsDigitOdd CLR.L D0
|
|
MOVE BDOd+2(A7),CCR
|
|
SCS D0
|
|
RTS | return(d & 1);
|
|
|
|
XDEF _BnnCompareDigits
|
|
BCDd1 EQU 4
|
|
BCDd2 EQU 8
|
|
_BnnCompareDigits
|
|
MOVE.L BCDd1(A7),D1
|
|
CMP.L BCDd2(A7),D1
|
|
BHI BCDsup | if(d1 > d2) goto BCDsup;
|
|
SNE D0
|
|
EXTB.L D0
|
|
RTS | return(-(d1 < d2));
|
|
BCDsup MOVEQ #1,D0
|
|
RTS | return(1);
|
|
|
|
XDEF _BnnComplement
|
|
BCMnn EQU 4
|
|
BCMnl EQU 8
|
|
_BnnComplement MOVE.L BCMnn(A7),A0
|
|
MOVE.L BCMnl(A7),D0
|
|
DBF D0,BCM1 | if(nl--) goto BCM1;
|
|
RTS | return;
|
|
BCM1 NOT.L (A0)+ | *(nn++) ^= -1;
|
|
DBF D0,BCM1 | if(nl--) goto BCM1;
|
|
RTS | return;
|
|
|
|
XDEF _BnnAndDigits
|
|
BADnn EQU 4
|
|
BADd EQU 8
|
|
_BnnAndDigits MOVE.L BADnn(A7),A0
|
|
MOVE.L BADd(A7),D0
|
|
AND.L D0,(A0) | *n &= d;
|
|
RTS | return;
|
|
|
|
XDEF _BnnOrDigits
|
|
BODnn EQU 4
|
|
BODd EQU 8
|
|
_BnnOrDigits MOVE.L BODnn(A7),A0
|
|
MOVE.L BODd(A7),D0
|
|
OR.L D0,(A0) | *n |= d;
|
|
RTS | return;
|
|
|
|
XDEF _BnnXorDigits
|
|
BXDnn EQU 4
|
|
BXDd EQU 8
|
|
_BnnXorDigits
|
|
MOVE.L BXDnn(A7),A0
|
|
MOVE.L BXDd(A7),D0
|
|
EOR.L D0,(A0) | *n ^= d;
|
|
RTS | return;
|
|
|
|
XDEF _BnnShiftLeft
|
|
BSLmm EQU 4
|
|
BSLml EQU 8
|
|
BSLnbi EQU 12
|
|
_BnnShiftLeft CLR.L D0 | res = 0;
|
|
MOVE.L BSLnbi(A7),D1
|
|
BNE BSL0 | if(nbi) goto BSL0;
|
|
RTS | return(res);
|
|
BSL0 MOVE.L BSLmm(A7),A0
|
|
MOVEM.L D2-D5,-(A7) | Save 4 registers
|
|
MOVE.L BSLml+16(A7),D2
|
|
MOVEQ #32,D3 | rnbi = BN_DIGIT_SIZE;
|
|
SUB.L D1,D3 | rnbi -= nbi;
|
|
DBF D2,BSL1 | if(ml--) goto BSL1;
|
|
MOVEM.L (A7)+,D2-D5 | Restore 4 registers
|
|
RTS | return(res);
|
|
BSL1 MOVE.L (A0),D4 | save = *mm;
|
|
MOVE.L D4,D5 | X = save;
|
|
LSL.L D1,D5 | X <<= nbi;
|
|
OR.L D0,D5 | X |= res;
|
|
MOVE.L D5,(A0)+ | *(mm++) = X;
|
|
MOVE.L D4,D0 | res = save;
|
|
LSR.L D3,D0 | res >>= rnbi;
|
|
DBF D2,BSL1 | if(ml--) goto BSL1;
|
|
MOVEM.L (A7)+,D2-D5 | Restore 4 registers
|
|
RTS | return(res);
|
|
|
|
XDEF _BnnShiftRight
|
|
BSRmm EQU 4
|
|
BSRml EQU 8
|
|
BSRnbi EQU 12
|
|
_BnnShiftRight CLR.L D0 | res = 0;
|
|
MOVE.L BSRnbi(A7),D1
|
|
BNE BSR0 | if(nbi) goto BSR0;
|
|
RTS | return(res);
|
|
BSR0 MOVE.L BSRmm(A7),A0
|
|
MOVEM.L D2-D5,-(A7) | Save 4 registers
|
|
MOVE.L BSRml+16(A7),D2
|
|
LEA 0(A0,D2.L*4),A0 | mm = &mm[ml];
|
|
MOVEQ #32,D3 | lnbi = BN_DIGIT_SIZE;
|
|
SUB.L D1,D3 | lnbi -= nbi;
|
|
DBF D2,BSR1 | if(ml--) goto BSR1;
|
|
MOVEM.L (A7)+,D2-D5 | Restore 4 registers
|
|
RTS | return(res);
|
|
BSR1 MOVE.L -(A0),D4 | save = *(--mm);
|
|
MOVE.L D4,D5 | X = save;
|
|
LSR.L D1,D5 | X >>= nbi;
|
|
OR.L D0,D5 | X |= res;
|
|
MOVE.L D5,(A0) | *mm = X;
|
|
MOVE.L D4,D0 | res = save;
|
|
LSL.L D3,D0 | res <<= lnbi;
|
|
BSR2 DBF D2,BSR1 | if(ml--) goto BSR1;
|
|
MOVEM.L (A7)+,D2-D5 | Restore 4 registers
|
|
RTS | return(res);
|
|
|
|
XDEF _BnnAddCarry
|
|
BACnn EQU 4
|
|
BACnl EQU 8
|
|
BACcar EQU 12
|
|
_BnnAddCarry MOVE.L BACcar(A7),D0 |
|
|
BEQ BAC2 | if(car == 0) return(car);
|
|
MOVE.L BACnl(A7),D0 |
|
|
BEQ BAC3 | if(nl == 0) return(1);
|
|
MOVE.L BACnn(A7),A0
|
|
SUBQ.L #1,D0 | nl--;
|
|
BAC1 ADDQ.L #1,(A0)+ | ++(*nn++);
|
|
DBCC D0,BAC1 | if(Carry || nl--) goto BAC1
|
|
SCS D0
|
|
NEG.B D0
|
|
EXTB.L D0
|
|
BAC2 RTS | return(Carry)
|
|
BAC3 MOVEQ #1,D0
|
|
RTS | return(1);
|
|
|
|
XDEF _BnnAdd
|
|
BADDmm EQU 4
|
|
BADDml EQU 8
|
|
BADDnn EQU 12
|
|
BADDnl EQU 16
|
|
BADDcar EQU 20
|
|
_BnnAdd MOVE.L BADDmm(A7),A0
|
|
MOVE.L BADDnn(A7),A1
|
|
MOVE.L BADDnl(A7),D1
|
|
SUB.L D1,BADDml(A7) | ml -= nl;
|
|
TST.L D1
|
|
BNE BADD1 | if(nl) goto BADD1
|
|
TST.L BADDcar(A7) ||
|
|
BNE BADD7 | if(car) goto BADD7
|
|
CLR.L D0
|
|
RTS | return(0);
|
|
BADD1 SUBQ.L #1,D1 | nl--;
|
|
MOVE.L BADDcar(A7),D0
|
|
NEG.B D0 | /* Bit No 4 */
|
|
MOVE D0,CCR | X = car;
|
|
MOVE.L D2,-(A7) ||| Save register.
|
|
BADDX MOVE.L (A1)+,D0
|
|
MOVE.L (A0),D2
|
|
ADDX.L D0,D2 | N = *mm + *(nn++) + X
|
|
MOVE.L D2,(A0)+ | X = N >> 32; *(mn++) = N;
|
|
DBF D1,BADDX | if(nl--) goto BADDX
|
|
MOVE.L (A7)+,D2 ||| Restore register.
|
|
MOVE CCR,D0
|
|
AND.W #0x10,D0
|
|
BNE BADD7 | if(X) goto BADD7;
|
|
CLR.L D0 | return(0);
|
|
RTS
|
|
BADD7 MOVE.L BADDml(A7),D0
|
|
BEQ BADD9 | if(ml == 0) return(1);
|
|
SUBQ.L #1,D0 | ml--;
|
|
BADD8 ADDQ.L #1,(A0)+ | ++(*mm++);
|
|
DBCC D0,BADD8 | if(Carry || ml--) goto BADD8
|
|
SCS D0
|
|
NEG.B D0
|
|
EXTB.L D0
|
|
RTS | return(Carry)
|
|
BADD9 MOVEQ #1,D0
|
|
RTS | return(1);
|
|
|
|
XDEF _BnnSubtractBorrow
|
|
BSBnn EQU 4
|
|
BSBnl EQU 8
|
|
BSBcar EQU 12
|
|
_BnnSubtractBorrow
|
|
MOVE.L BSBcar(A7),D0
|
|
BNE BSB2 | if(car) return(car);
|
|
MOVE.L BSBnl(A7),D0
|
|
BEQ BSB3 | if(nl == 0) return(0);
|
|
MOVE.L BSBnn(A7),A0
|
|
SUBQ.L #1,D0 | nl--;
|
|
BSB1 SUBQ.L #1,(A0)+ | (*nn++)--;
|
|
DBCC D0,BSB1 | if(Carry || nl--) goto BSB1
|
|
SCC D0
|
|
NEG.B D0
|
|
EXTB.L D0
|
|
BSB2 RTS | return(Carry)
|
|
BSB3 MOVEQ #0,D0
|
|
RTS | return(0);
|
|
|
|
XDEF _BnnSubtract
|
|
BSmm EQU 4
|
|
BSml EQU 8
|
|
BSnn EQU 12
|
|
BSnl EQU 16
|
|
BScar EQU 20
|
|
_BnnSubtract MOVE.L BSmm(A7),A0
|
|
MOVE.L BSnn(A7),A1
|
|
MOVE.L BSnl(A7),D1
|
|
SUB.L D1,BSml(A7) | ml -= nl;
|
|
TST.L D1
|
|
BNE BS1 | if(nl) goto BS1
|
|
TST.L BScar(A7)
|
|
BEQ BS7 | if(!car) goto BS7
|
|
MOVEQ #1,D0
|
|
RTS | return(1);
|
|
BS1 SUBQ.L #1,D1 | nl--;
|
|
MOVE.L BScar(A7),D0
|
|
NEG.B D0 | /* Bit No 4 */
|
|
NOT.B D0
|
|
MOVE D0,CCR | X = ~car;
|
|
MOVE.L D2,-(A7) ||| Save register.
|
|
BSX MOVE.L (A1)+,D0
|
|
MOVE.L (A0),D2
|
|
SUBX.L D0,D2 | N = *mm - *(nn++) - X
|
|
MOVE.L D2,(A0)+ | X = N >> 32; *(mm++) = N;
|
|
DBF D1,BSX | if(nl--) goto BSX
|
|
MOVE.L (A7)+,D2 ||| Restore register.
|
|
MOVE CCR,D0
|
|
AND.W #0x10,D0
|
|
BNE BS7 | if(X) goto BS7;
|
|
MOVEQ #1,D0 | return(1);
|
|
RTS
|
|
BS7 MOVE.L BSml(A7),D1
|
|
BEQ BS9 | if(ml == 0) goto BS9;
|
|
SUBQ.L #1,D1 | ml--;
|
|
BS8 SUBQ.L #1,(A0)+ | --(*m++);
|
|
DBCC D1,BS8 | if(Carry || ml--) goto BS8
|
|
SCC D0
|
|
NEG.B D0
|
|
EXTB.L D0
|
|
RTS | return(C)
|
|
BS9 CLR.L D0
|
|
RTS | return(0);
|
|
|
|
XDEF _BnnMultiplyDigit
|
|
BMDpp EQU 4
|
|
BMDpl EQU 8
|
|
BMDmm EQU 12
|
|
BMDml EQU 16
|
|
BMDd EQU 20
|
|
_BnnMultiplyDigit
|
|
MOVE.L BMDd(A7),D0
|
|
BNE BMD1 | if(d) goto BMD1;
|
|
RTS | return(0);
|
|
BMD1 CMP.L #1,D0
|
|
BNE BMD2 | if(d != 1) goto BMD2;
|
|
CLR.L BMDd(A7)
|
|
BRA _BnnAdd | BnnAdd(p,pl,m,ml,0);
|
|
BMD2 MOVE.L BMDpp(A7),A0
|
|
MOVE.L BMDmm(A7),A1
|
|
MOVE.L BMDml(A7),D1
|
|
SUB.L D1,BMDpl(A7) | pl -= ml;
|
|
MOVEM.L D2-D5,-(A7) | Save 4 registers
|
|
CLR.L D2 | low = 0;
|
|
CLR.L D5
|
|
BRA BMD6 | goto BMD6;
|
|
BMD3 MOVE.L (A1)+,D4 | X = *(mm++);
|
|
MULU.L D0,D3:D4 | X *= d;
|
|
ADD.L D2,D4 | X += low;
|
|
ADDX.L D5,D3 | X(hight) += Carry;
|
|
ADD.L (A0),D4 | X += *pp;
|
|
ADDX.L D5,D3 | X(hight) += Carry;
|
|
MOVE.L D4,(A0)+ | *(pp++) = X(low);
|
|
MOVE.L D3,D2 | low = X(hight);
|
|
BMD6 DBF D1,BMD3 | if(ml--) goto BMD3;
|
|
MOVE.L D2,D0
|
|
MOVEM.L (A7)+,D2-D5 | Restore 4 registers
|
|
ADD.L D0,(A0)+ | *(pp++) += low;
|
|
BCS BMD7 | if(Carry) goto BMD7;
|
|
CLR.L D0
|
|
RTS | return(0);
|
|
BMD7 MOVE.L BMDpl(A7),D0
|
|
SUBQ.L #1,D0 | pl--;
|
|
BEQ BMD10 | if(!pl) goto BM10;
|
|
SUBQ.L #1,D0 | pl--;
|
|
BMD8 ADDQ.L #1,(A0)+ | ++(*pp++);
|
|
BMD9 DBCC D0,BMD8 | if(Carry || pl--) goto BMD8
|
|
SCS D0
|
|
NEG.B D0
|
|
EXTB.L D0
|
|
RTS | return(Carry);
|
|
BMD10 MOVEQ #1,D0
|
|
RTS | return(1);
|
|
|
|
XDEF _BnnDivideDigit
|
|
BDDqq EQU 12
|
|
BDDnn EQU 16
|
|
BDDnl EQU 20
|
|
BDDd EQU 24
|
|
_BnnDivideDigit MOVEM.L D2-D3,-(A7) | Save 2 registers
|
|
MOVE.L BDDqq(A7),A1
|
|
MOVE.L BDDnn(A7),A0
|
|
MOVE.L BDDnl(A7),D0
|
|
MOVE.L BDDd(A7),D1
|
|
LEA 0(A0,D0.L*4),A0 | nn = &nn[nl];
|
|
SUBQ.L #1,D0 | nl--;
|
|
LEA 0(A1,D0.l*4),A1 | qq = &qq[nl];
|
|
MOVE.L -(A0),D2 || X(hight) = *(--nn);
|
|
BRA BDD2 | goto BDD2;
|
|
BDD1 MOVE.L -(A0),D3 | X(low) = *(--nn);
|
|
DIVU.L D1,D2:D3 | X(low) = X / d;
|
|
| X(hight) = X % d;
|
|
MOVE.L D3,-(A1) | *(--qq) = X(low);
|
|
BDD2 DBF D0,BDD1 | if(nl--) goto BDD1;
|
|
MOVE.L D2,D0 || return(X(hight));
|
|
MOVEM.L (A7)+,D2-D3 | Restore 2 registers
|
|
RTS
|