Macintosh-SW/sys7.1-doc-wip
1
0
Fork 0
mirror of https://github.com/elliotnunn/sys7.1-doc-wip.git synced 2024-06-01 04:41:39 +00:00
Code Issues Projects Releases Wiki Activity
master
sys7.1-doc-wip/Toolbox/SANE/FP881NonArith.a
Horst Beepmanh 33cd9271f4 SuperMarioProj.1994-02-09
2019-07-27 22:37:48 +08:00

611 lines
18 KiB
Plaintext
Raw Permalink Blame History

;EASE$$$ READ ONLY COPY of file “FP881nonarith.a”
; 1.2 GGD 07/14/1989 Fixed CopySign to copy Sign(dst) -> Sign(src), even though it seems
; backwards, that is how it is documented, and how the Mac Plus/SE work.
; 1.1 CCH 11/11/1988 Fixed Header.
; 1.0 CCH 11/ 9/1988 Adding to EASE.
; OLD REVISIONS BELOW
; 1.0 BBM 2/12/88 Adding file for the first time into EASE…
; END EASE MODIFICATION HISTORY
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; File: FP881nonarith.a
;; Implementation of FP68K non-arithmetic functions.
;; Copyright Apple Computer, Inc. 1985,1986,1987
;; All Rights Reserved
;; Confidential and Proprietary to Apple Computer,Inc.
;;
;; Written by Clayton Lewis, begun 14 Feb 85.
;; Debugged by Stuart McDonald.
;;
;; Modification history:
;; Rev2: 16 May 85
;; Rev3: 17 May 85
;; Rev4: 17 May 85
;; Rev5: 27 May 85
;; Rev6: 30 May 85
;; Rev7: 04 Jun 85
;; Rev8: 16 Jun 85 CRL moved to MPW
;; Rev9: 08 Sep 86 -S.McD. Minor revs. to NextAfter to handle NaNs and SNaNs
;; RevA: 19 Nov 86 -S.McD. Fixed TestExp's case selection.
;; 26 Dec 86 -S.McD. CopySign rearranged slightly.
;; 28 Dec 86 -S.McD. Fixed ProcEx's behavior.
;; 30 Dec 86 -S.McD. Zeroed FPSR for NonArith codes exiting thru halt check.
;; 03 Jan 87 -S.McD. Nextafter was signalling on old status.
;; 13 Jan 87 -S.McD. Now save/restore any of the registers FP2-FP7 used.
;; 15 Jan 87 -S.McD. Status and copyright notice changed.
;; 21 Jan 87 -S.McD. Cleaned up SetHv/GetHv.
;; 22 Jan 87 -S.McD. SetExp was setting halt bit instead of flag bit.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ToSANE ; used by EGet below and by halt mechanism in FP881Arith
DC.B 0,16,8,24,2,18,10,26,4,20,12,28,6,22,14,30
DC.B 1,17,9,25,3,19,11,27,5,21,13,29,7,23,15,31
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; GET ENVIRONMENT.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
GetEnv
BSR.S EGet ; returning SANE Env in D1
MOVEA.L LKADR1(A6),A1
MOVE.W D1,(A1)
BRA Exit1NoHalt
EGet
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Used by GetEnvironment, ProcEntry.
;; Returns SANE environment in D1.
;; D5.hi = STATUS.lo; D5.lo = CONTROL
;; -----------------------------------------
;; First transfer accrued exceptions to D1.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOVEQ #19,D1 ; clear result space
MOVE.L D5,D0
LSR.L D1,D0 ; move exceptions to low bits
ANDI.W #XCPMASK,D0 ; mask word to only 5 bits
MOVE.B ToSANE(PC,D0),D1 ; set SANE exception bits
LSL.W #8,D1 ; and move to high byte
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Move CONTROL to the stack and map the eight
;; 881 halt bits to 5 SANE bits in D1.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOVE.W D5,-(SP) ; copy of caller control register
MOVE.B (SP),D0 ; pick up only the halt bits
LSR.B #1,D0 ; shift I1 to carry bit
BCC.S @1 ; branch if I1 not set
ORI.B #1,D0 ; else copy I1 to I2 as lowest bit
@1
CMPI.B #$10,D0 ; are any of the 3 invalid bits set?
BCS.S @2 ; if not, branch
BSET #0,D1 ; else set invalid in D1
@2
ANDI.W #$0F,D0 ; show only OUDI bits
OR.B ToSANE(PC,D0),D1 ; set corresponding SANE halts
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Collect and set in D1 first RR (rounding precision)
;; bits then rr (rounding direction) bits.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOVE.W #$C0,D0
AND.W (SP),D0 ; show only RR bits of CONTROL
ROL.B #2,D0 ; RR to low bits
OR.B RPrec(PC,D0),D1 ; set RR in D1
MOVEQ #$30,D0 ; mask for rr bits
AND.W (SP)+,D0 ; collect rr bits; pop temp from stack
LSR.B #3,D0 ; move to bits 1 & 2 (index to a WORD table)
OR.W rDir(PC,D0),D1 ; set rr in D1
RTS
RPrec
DC.B 0,64,32,0
rDir
DC.W 0,24576,16384,8192
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SET ENVIRONMENT.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SetEnv
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Move SANE environment to D0, convert to
;; 881 format, set environment, and exit.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOVEA.L LKADR1(A6),A1
MOVE.W (A1),D0
BSR.S ESet ; sets SANE Env currently in D0
BRA Exit1NoHalt
ESet
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Used by SetEnv, ProcExit, SetException.
;; Enter with D0 holding SANE environment to be set.
;; Routine sets equivalent environment in D5 for later pass to 881.
;; -----------------------------------------------------
;; Install the exception bits in the 881 STATUS register.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOVE.W D0,-(SP) ; keep a copy of env on the stack
MOVEQ #XCPMASK,D0 ; mask for 5 exception bits
AND.B (SP),D0 ; capture exception bits
FMOVE FPSR,D1
MOVE.B FromSANE(PC,D0),D1 ; map to 881 accrued exceptions
; and install in 881
FMOVE D1,FPSR
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Collect halt bits in D0. Duplicate hi bit 3 times and
;; low bit twice to set all 3 invalid and 2 inexact halts.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOVEQ #XCPMASK,D0 ; show only 5 halt bits
AND.W (SP),D0
MOVE.B FromSANE(PC,D0),D0 ; halts in hi bits of byte
ASR.B #2,D0 ; replicate the hi bit twice
LSL.W #6,D0 ; shift all but lowest bit to hi byte
ASR.B #1,D0 ; replicate the low bit once
LSL.W #2,D0 ; and shift all bits to hi byte
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Set rr (rounding direction) bits in D0.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOVEQ #0,D1 ; clear D1 for indexing below
MOVE.B #3,D0 ; mask and shift count
MOVE.B (SP),D1 ; fresh copy of SANE environment
ROL.B D0,D1 ; move rr to low bits
AND.B D0,D1 ; and mask to show only rr
MOVE.B rrDir(PC,D1),D0 ; map to 881 rr bits
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Set RR (rounding precision) bits in D0 and reset control in D5.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOVEQ #$60,D1
AND.W (SP)+,D1 ; mask to RR and pop saved env from stack
ROL.B #3,D1 ; shift to low bits
OR.B RRPrec(PC,D1),D0 ; map to 881 RR bits
MOVE.W D0,D5 ; reset user control held in D5
RTS
FromSANE
DC.B 0,128,32,160,64,192,96,224
DC.B 16,144,48,176,80,208,112,240
DC.B 8,136,40,168,72,200,104,232
DC.B 24,152,56,184,88,216,120,248
RRPrec
DC.B 0,128,64,0
rrDir
DC.B 0,48,32,16
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SET HALT VECTOR & GET HALT VECTOR.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SetHv
MOVE.L #FPSTATE+2,A0
MOVE.L LKADR1(A6),A1
MOVE.L (A1),(A0)
BRA Exit1NoHalt
GetHv
MOVE.L #FPSTATE+2,A0
MOVE.L LKADR1(A6),A1
MOVE.L (A0),(A1)
BRA Exit1NoHalt
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; NEGATE.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Negate
MOVE.L LKADR1(A6),A0
BCHG.B #7,(A0)
BRA Exit1NoHalt
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ABSOLUTE VALUE.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Abs
MOVE.L LKADR1(A6),A0
BCLR.B #7,(A0)
BRA Exit1NoHalt
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PROCENTRY.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ProcEnt
BSR EGet ; SANE env now in D1
MOVE.L LKADR1(A6),A0
MOVE.W D1,(A0)
MOVEQ #0,D5 ; set environment 0
FMOVE D5,FPSR
BRA Exit1NoHalt
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; TESTEXCEPTION.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
TestExp
MOVE.L LKADR1(A6),A0
MOVE.W (A0),D1 ; was .L -S.McD.
MACHINE MC68020
MOVE.W IndTab(PC,D1*2),D1 ; added *2. -S.McD.
MACHINE MC68000
CLR.W (A0)
BTST D1,D5
BEQ.S @2
ADDQ.B #1,(A0)
@2
BRA Exit1NoHalt
IndTab
DC.W 23,21,22,20,19 ; not 22,21. -S.McD.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; NEXTAFTER - Modify SRC by one ulp in direction of DST
;; 1. Clear the control register (default rounding, no halts) and
;; move the tiniest extended denorm to FP2.
;; 2. Move SRC to FP0. If INF bit is set, then set SRCINF flag and save sign bit.
;; 3. Move DST to FP1. If NaN bit is set, then move FP1 to FP0.
;; 4. Compare FP0 and FP1. If equal, then go to 9.
;; 5. If SRC = Infinity, handle separately, returning INF dec 1.
;; If FP1 > FP0 then set rounding to upward, & add tiniest denorm to FP0
;; else set rounding downward, & subt tiniest denorm from FP0.
;; Test for 0 result. If found, change sign.
;; 6. Move result from FP0 to SRC and check for INF. Skip 7 if not found.
;; 7. INF returned. If SRCINF is not set, then set [ovfl, inex] locally.
;; 8. Check opcode for format of SRC and examine exponent manually for zero or
;; denorm. If either, then set [underflow, inexact] locally.
;; 9. Pass local exception flags to 881. Exit through halt checking code
;; (which acts like procexit; restoring caller's environment, stimulating
;; current exceptions, and possibly halting).
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
NextAfter
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; State 1. Clear the control register and move the tiniest extended denorm to FP2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
FMOVE #0,FPCR
FMOVEM FP2,-(SP) ; must save/restore FP2-FP7 -S.McD.
FMOVE.X #"$000000000000000000000001",FP2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; State 2. Move SRC to FP0.
;; If INF bit is set, then set SRCINF flag, handle INF and goto 6.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MOVE.L LKADR2(A6),A0 ; collect source address
MOVEQ #19,D0
EOR.W D0,D1 ; leave only format in opword
ROL.W #4,D1 ; D-bit to bit 15, S-bit to bit 0. Other bits zero.
BNE.S @2 ; branch if single or double
ADDQ.L #6,A0 ; Extended SRC
MOVE.L (A0),-(SP)
MOVE.L -(A0),-(SP)
SUBQ.L #2,A0
MOVE.L (A0),-(SP)
FMOVE.X (SP)+,FP0
BRA.S @6
@2
BPL.S @4 ; branch if single
FMOVE.D (A0),FP0 ; Double SRC
BRA.S @6
@4
FMOVE.S (A0),FP0 ; Single SRC
@6
;;;;;;;;;;;;;;;;;;;;;;;
;; Test SRC for INF or SNaN
;;;;;;;;;;;;;;;;;;;;;;;
FMOVE FPSR,D0
BTST #14,D0 ; is SNaN bit set from SRC move?-S.McD.
BEQ.S @7 ; if not, skip to INF tests
BSET #29,D1 ; else save SNaN bit in D1 and
BRA.W State6 ; begin returning Nan
@7
BTST #25,D0 ; is INF bit set from SRC move?
BEQ.S State3 ; if not, skip flag setting
BSET #31,D1 ; else set SRCINF flag in D1
BTST #27,D0 ; what sign infinity?
BEQ.S State3 ; branch if positive
BSET #30,D1 ; save sign bit in D1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; State 3. Move DST to FP1.
;; If NaN bit is set, then move FP1 to SRC.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
State3
MOVE.L LKADR1(A6),A1 ; collect destination address
TST.W D1
BNE.S @8 ; branch if single or double format
ADDQ.L #6,A1 ; Extended DST
MOVE.L (A1),-(SP)
MOVE.L -(A1),-(SP)
SUBQ.L #2,A1
MOVE.L (A1),-(SP)
FMOVE.X (SP)+,FP1
BRA.S @12
@8
BPL.S @10 ; branch if single
FMOVE.D (A1),FP1 ; Double DST
BRA.S @12
@10
FMOVE.S (A1),FP1 ; Single DST
;;;;;;;;;;;;;;;;;;;;;;;
;; Move DST if NaN bit set
;;;;;;;;;;;;;;;;;;;;;;;
@12
FBOR.W State4 ; branch if NaN bit not set
FMOVE FP1,FP0 ; else DST was a NaN. Copy it to FP0.
BTST.B #6,2(A1) ; was that a SNaN?
BNE.S State6 ; if no, then State6
BSET #29,D1 ; if yes, use bit 29 of D1 as temp SNaN flag
BRA.S State6 ; NaN result. Time to get out. -S.McD.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; State 4. Compare FP0 and FP1. If equal, then go to state 9.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
State4
FCMP FP0,FP1
FBNE.W State5
BRA State9
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; State 5. If SRC = Infinity, handle separately, returning INF dec 1.
;; If FP1 > FP0, then set rounding to upward & add FP2 to FP0
;; else set rounding to dwnwrd & sub FP2 fm FP0.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
State5
TST.L D1 ; was source an infinity?
BGE.S @8 ; if not, branch around infinity code
;;;;;;;;;;;;;;;;;;;;;;;
;; Infinity code.
;; INF = SRC ≠ DST, so result = Infinity decremented by 1.
;; Move this value to FP0.
;;;;;;;;;;;;;;;;;;;;;;;
MOVEQ #-1,D0 ; no exceptions to be OR'd in
TST.W D1
BNE.S @2 ; branch if single or double format
;;;;;;;;;;;;;;;;;;;;;;;
;; Handle extended precision INF dec 1.
;;;;;;;;;;;;;;;;;;;;;;;
MOVE.W #$7FFE,(A0)+
MOVE.L D0,(A0)+
MOVE.L D0,(A0)
SUBQ #6,A0
BRA.S @6
@2
BPL.S @4 ; branch if single
;;;;;;;;;;;;;;;;;;;;;;;
;; Handle double precision INF dec 1.
;;;;;;;;;;;;;;;;;;;;;;;
MOVE.L #$7FEFFFFF,(A0)+
MOVE.L D0,(A0)
SUBQ #4,A0
BRA.S @6
@4
;;;;;;;;;;;;;;;;;;;;;;;
;; Handle single precision INF dec 1.
;;;;;;;;;;;;;;;;;;;;;;;
MOVE.L #$7F7FFFFF,(A0)
@6
BTST #30,D1 ; sign of SRC?
BEQ.S @7 ; do nothing if positive
BSET #7,(A0) ; else set sign bit
@7
MOVEQ #0,D0 ; signal no exceptions
BRA State9 ; and leave
;;;;;;;;;;;;;;;;;;;;;;;
;; Non-infinity code.
;;;;;;;;;;;;;;;;;;;;;;;
@8
FBOGT.W @10 ; branch if FP1 > FP0
MOVEQ #$20,D0 ; set rounding downward
FMOVE D0,FPCR
FSUB FP2,FP0
BRA.S @12 ; branch if FP1 <? FP0
@10
MOVEQ #$30,D0 ; set rounding upward
FMOVE D0,FPCR
FADD FP2,FP0
@12
FBNE.W State6
FNEG FP0,FP0
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; State 6. Move result from FP0 to SRC.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
State6
TST.W D1
BNE.S @2 ; branch if single or double format
;;;;;;;;;;;;;;;;;;;;;;;
;; Handle extended precision.
;;;;;;;;;;;;;;;;;;;;;;;
FMOVE.X FP0,-(SP) ; Extended DST
MOVE.L (SP)+,(A0)+
SUBQ.L #2,A0
MOVE.L (SP)+,(A0)+
MOVE.L (SP)+,(A0)
SUBQ.L #6,A0
FMOVE FPSR,D0 ; check INF
BTST #29,D1 ; is SNaN bit set? -S.McD.
BEQ.S @1 ; skip if not SNaN
MOVE.L #$80,D0 ; set invalid if SNaN
BRA.S State85
@1
BTST #25,D0 ; is INF bit set?
BEQ.S State8 ; State8 if not INF
BRA.S State7 ; State7 if INF
;;;;;;;;;;;;;;;;;;;;;;;
;; Handle double precision.
;;;;;;;;;;;;;;;;;;;;;;;
@2
BPL.S @4 ; branch if single
FMOVE.D FP0,(A0) ; Double DST
MOVE.L (A0),D0 ; examine hi long of double for INF
ADD.L D0,D0 ; ignore sign bit
CMPI.L #$FFE00000,D0 ; does it match INF?
BNE.S State8 ; State8 if no match
TST.L 4(A0) ; does lo long of double match INF?
BNE.S State8 ; State8 if not INF
BRA.S State7 ; State7 if INF
;;;;;;;;;;;;;;;;;;;;;;;
;; Handle single precision.
;;;;;;;;;;;;;;;;;;;;;;;
@4
FMOVE.S FP0,(A0) ; Single DST
MOVE.L (A0),D0 ; examine single for INF
ADD.L D0,D0 ; ignore sign bit
CMPI.L #$FF000000,D0 ; does it match INF?
BNE.S State8 ; branch if no match
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; State 7. INF returned. If SRCINF is not set, then set [ovfl, inex].
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
State7
TST.L D1 ; check SRCINF flag at bit 31
BMI.S State8 ; if set, go to next state
MOVEQ #$48,D0 ; if INF ^ ~SRCINF then hold o,x in D0 for later
BRA.S State85
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; State 8. Check opcode for format of SRC and examine exponent
;; manually for zero or denorm. If either, then set [ufl, inex].
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
State8
MOVEQ #0,D0
State85
TST.W D1
BNE.S @2 ; branch if single or double format
MOVE.W #$7FFF,D1 ; extended exponent mask
TST.B 2(A0) ; test the 'i' bit in extended format
BMI.S State9 ; if set, then cannot be denormal.BNE->BMI-S.McD.
BRA.S @6
@2
BPL.S @4 ; branch if single
MOVE.W #$7FF0,D1 ; double exponent mask
BRA.S @6
@4
MOVE.W #$7F80,D1 ; single exponent mask
@6
AND.W (A0),D1 ; exactly the exponent bits
BNE.S State9 ; if nonzero, then neither zero nor denorm
MOVEQ #$28,D0 ; if exponent=0 then hold u,x for later
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; State 9. Pass local exception flags to 881. Exit thru common code.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
State9
MOVEQ #0,D1 ; zero status -S.McD.
MOVE.W D0,D1 ; set exceptions from above -S.McD.
FMOVE D1,FPSR
FMOVEM (SP)+,FP2 ; must save/restore FP2-FP7 -S.McD.
BRA Exit2Args
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; PROCEXIT
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
ProcEx
FMOVE FPSR,D1 ; get current status -S.McD.
MOVE.W D1,A1 ; and save it temporarily in A1. -S.McD.
MOVE.L LKADR1(A6),A0 ; addr saved environment
MOVE.W (A0),D0 ; saved environment
BSR ESet ; SANE env in D0 -> FPSR:FPCR in D5
MOVEQ #STKREM1,D0 ; unrolled Exit1Arg to handle special D1. -S.McD.
LEA LKADR1(A6),A0
MOVE.W D0,LKCNT(A6) ; final stack adjust
MOVE.W A1,D1 ; restore current status to D1. -S.McD.
FMOVE FPSR,D0 ; "or" in current status with saved status. -S.McD.
OR.W D1,D0
FMOVE D0,FPSR
SWAP D5 ; ExitProcEx expects FPSR and FPCR swapped. -S.McD.
BRA ExitProcEx ; -S.McD.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; SETEXCEPTION
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
SetExp
FMOVE #0,FPSR ; IEEE default status -S.McD.
MOVE.L LKADR1(A6),A0
BSR EGet ; returns SANE environment in D1
MOVE.W (A0),D0 ; bit index of exception to be set
ADDQ.W #8,D0 ; Set flag, not halt bit! -S.McD.
BSET D0,D1 ; set the exception
MOVE.W D1,D0 ; new SANE environment
SetOut
BSR ESet ; place in 881
BRA Exit1Arg ; and exit through halt testing code
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; COPYSIGN.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
CopySign
MOVE.L LKADR1(A6),A0
MOVE.L LKADR2(A6),A1
; This code is opposite from the MacSE, should copy dst->src
* BCLR #7,(A0) ; <1.2>
* TST.B (A1) ; <1.2>
* BPL.S Exit2NoHalt ; <1.2>
* BSET #7,(A0) ; <1.2>
; CopySign is documented as Sign(dst) -> Sign(src)
move.w (a0),d0 ; get dst sign into bit 15 <1.2>
move.b (a1),d0 ; get src sign into bit 8 <1.2>
add.w d0,d0 ; shift dst sign into carry <1.2>
roxr.b #1,d0 ; shift dst sign into src <1.2>
move.b d0,(a1) ; restore updated src sign <1.2>
Exit2NoHalt
MOVEQ #STKREM2,D0
MOVE.L LKRET(A6),LKADR2(A6)
BRA.S AndOut
Exit1NoHalt
MOVEQ #STKREM1,D0
MOVE.L LKRET(A6),LKADR1(A6)
AndOut
MOVE.W D0,LKCNT(A6)
MOVE.W D5,D0 ; rest of D0 zeroed by MOVEQs. -S.McD.
FMOVE D0,FPCR ; restore control register from D0, which may
; have been modified by ESet or ProcEntry
MOVEA.L (A6),A6
MOVEM.L (SP)+,D0/D1/D5/A0/A1
ADDA.W (SP),SP
RTS
Reference in New Issue View Git Blame Copy Permalink