Trailing-Edge
-
PDP-10 Archives
-
BB-AS80D-SM_1986
-
microcode-sources/extexp.mic
There are 5 other files named extexp.mic in the archive. Click here to see a list.
.TOC "GFLT DOUBLE PRECISION ARITHMETIC"
.IF/EXTEXP
.DCODE
102: R, B/0, J/EDFLOT ;GFAD
103: R, B/2, J/EDFLOT ;GFSB
106: R, B/4, J/EDFLOT ;GFMP
107: R, B/6, J/EDFLOT ;GFDV
.UCODE
=0****00**0*
EDFLOT: VMA_VMA+1, LOAD ARX,
MQ_0.S, CALL [XFERW]
FM[E0]_AR, ARX_ARX*2, B DISP ;mem high to E0, do instruction
=
=000
EDFL1: SKP AR0, CALL [ISOEXP] ;save mem high word in E0.
FM[T2]_AR, J/EF1 ;save mem exp in T2.
AR_-AR LONG ;subtract now same as add.
FM[E0]_AR, J/EDFL1 ;save "positive" exponent
=100 SKP AR0, CALL [ISOEXP] ;isolate mem exp in AR.
BR/AR, GEN ARX, SKP AD NE, ;start test for sticky bits.
J/EFMP
=110 BR/AR, GEN AR, SKP AD0, ;save mem high in br.
CALL [ISOEXP] ;get mem exp
FM[T2]_AR, AR_0S, J/EFDV0 ;save mem exp in T2. No sticky bits.
=0
EF1: AR_AC0, SKP AD0, CALL [ISOEXP] ;get AC op
FM[E1]_AR, BR/AR ;save AC exp in E1
;Now have positive mem exponent in T2, pos AC exp in E1.
;Save larger exp in T2 and exp diff if less than 340 in SC.
[AR]_[AR]*FM[T2], AD/A-B, ;AR gets exp diff.
SKP AD0 ;AR get exp diff, BRX gets exp.
=00 SC_#, #/3, CALL [EXPDIF] ;test for exp diff >72.
BR/AR, J/EF3A ;mem op larger.
AR_BR, J/EF5 ;restore exp to AR.
[AR]_FM[E1], CLR FE, J/ACNORM ;exp diff too large, norm AC op.
=00
EF3A: AR_-BR, SC_#, #/3, CALL [EXPDIF];mem larger, get positive diff.
=10 AR_BR, J/EF3B ;restore exponent to AR.
[AR]_FM[T2], CLR FE, J/MEMNRM ;exp diff > 72. norm mem op.
EF3B: AR_AR*8 ;move exp difference into AR0-8.
FE_AR0-8, ;mem larger, op doable.
AR_AC0 ;save smaller AC op in T0,T1
=0 FM[T0]_AR, CALL [EF5B]
FM[T1]_AR
[AR]_FM[E0] ;save larger mem op in AC0,AC1
AC0_AR, AR_ARX
AC1_AR, J/EF5A ;all set to shift and add.
EF5: AR_AR*8 ;move exp difference into AR0-8.
FE_AR0-8, [AR]_FM[E0] ;smaller mem op to T0,T1
FM[T0]_AR, AR_ARX
=0 FM[T1]_AR, CALL [EF5B]
AC1_AR ;we expect AC1*2 to be saved.
[AR]_FM[E1] ;save larger AC exp in T2
FM[T2]_AR, J/EF5A
EF5B: AR_AC1*2, RETURN1
;EXPDIF determines if the exponent difference is too large-ie >110 oct.
;The largest allowed value for shifting is 72 decimal. This is 110 octal.
;Since the exponent is in AR1-11, 110 octal has the value 11 in AR1-8.
;It expects the exponent difference in AR0-8.
;It uses AR0-8 and the BR.
;Returns 2 if the difference is ok (<=110).
;Returns 3 if the difference is too large (>110).
EXPDIF: BR/AR, CLR AR ;zero all of those bits.
AR0-8_#, #/10 ;put in 100 in AR0-11.
GEN AR-BR, SKP AD0, RETURN2 ;<max diff>-<actual diff>
;We now have:
; AC0 / larger op high
; AC1 / larger op low
; T0 / smaller op high
; T1 / smaller op low
; T2 / larger exponent
; FE / exp difference
;We must now sign extend both high ops.
=0
EF5A: AR_AC0, SKP AD0, CALL [SGNEXT] ;get larger high op
AC0_AR ;save larger extended op in AC0
=0 [AR]_FM[T0], SKP AD0, ;get smaller high op
CALL [SGNEXT] ; and sign extend into AR1-11.
FM[T0]_AR ;save smaller extended op in T0
;We are now set to shift the smaller op to align it with the larger op.
[AR]_FM[T1]
[AR]_FM[T0], ARX_AR, SC_FE ;move diff to SC for next line.
SC_#-SC, #/36., SKP SCAD0
=0 ARX_AR, AR_SIGN, J/EF10 ;FE < 37.
BR/AR, BRX/ARX, SC_FE
AR_SIGN, ARX_AR
SC_#-SC, #/72.
ARX_SHIFT ;high is sign, low is sign,,high.
=01 AR_BR LONG, BR/AR, BRX/ARX, ;save new stuff in BR long.
CALL [EF12] ;MQ gets lowest word.
FM[E1]_AR ;save sticky bits.
AR_AC1, J/EF11 ;now prepare to add.
EF10: AR_SHIFT, [ARX]_FM[T1] ;shift high op, load low word.
BR/AR, [AR]_FM[T0] ;shift low op, load high word.
AR_ARX (AD), ARX_SHIFT ;get shifted low word into ARX.
=01 BRX/ARX, CLR ARX, CALL [EF12] ;save low word, shift end bits.
FM[E1]_AR ;save sticky bits. (word 4 of sum).
AR_AC1, J/EF11 ;prepare to add.
BR/AR, BRX/ARX, AR_AC1 ;get larger op in AR,ARX
EF11: ARX_AR, AR_AC0, FE_#, #/0 ;smaller op in BR,BRX
AR_AR+BR, ARX/ADX, SC_#, #/3, ;operation done, now normalize.
NORM, J/ENORM
EF12: MQ_SHIFT, AR_ARX (AD), CLR ARX,J/SHIFT
.IF/GFTCNV ;[273]
EF12A: AR_SHIFT, RETURN10
.ENDIF/GFTCNV ;[273]
.ENDIF/EXTEXP
.TOC "GFLT MULTIPLY"
.IF/EXTEXP
=0
EFMP: CLR AR, J/EFMP1 ;mem low op is zero, no sticky bits.
AR_AC1*2, SKP AD NE ;is AC low op non-zero as well ?
=0 CLR AR ;yes, no sticky bits today.
EFMP1: FM[E1]_AR, AR_0S ;set sticky bits.
AR0-8_#, #/200 ;subtract 200.
BR/AR, AR_BR ;swap around exp and 2000.
AR_AR-BR, CLR SC ;done, and SC is cleared.
=0 BR/AR, AR_AC0, SKP AD0, ;save exp-2000 in BR.
CALL [ISOEXP] ;get AC high and isolate exp.
AR_AR+BR ;add exponents together.
FM[T2]_AR ;and store the sum in T2.
=0 [AR]_FM[E0], SKP AD0, ;get mem high op sign extended.
CALL [SGNEXT]
FE_#, #/-18. ;
BR/AR, BRX/ARX, AR_AC1 ;move mem ops to BR!BRX.
=000 MQ_AR, AR_0S, ARX_0S, ;multiply by low word.
CALL [MULREE]
=100 AR_AR+BR LONG ;low sign was set, add results.
=110 MQ_AR, AR_AC0, FE_#, #/-13., ;now continue with high part.
SKP AD0, CALL [SGNEXT] ;sign extend the ac high op.
FM[T0]_AR ;save sign extended AC op.
; SKP AR0 ;test sign bit to adjust FE.
=0
EFMPP1: MQ_AR, AR_MQ, J/EFMPP2 ;swap AR+MQ.
FE_FE+1, J/EFMPP1 ;inc the FE if number is neg.
=000
EFMPP2: AD/0S, FE_FE+1, DISP/MUL, ;now multiply by the high word.
MQ/MQ*.25, CALL [MULP]
;Since our last multiply step used 2 signs bits instead of a sign bit
;and the MSB, our answer is too low by a power of two for positive numbers
;and too low by a power of 4 for negative numbers.
=100 (AR+ARX+MQ)*2, J/EFMPP3 ;try this correction factor.
=101 (AR+ARX+MQ)*.25, J/EFMPP3 ;shouldn't ever get here.
=110 (AR+ARX+MQ)*2 ;and this for postive numbers.
=
EFMPP3: BR_AR LONG, AR_0.C, ARX_1S ;result to BR!BRX. Build mask.
=01 SC_#, #/10., ;load SC with shift count.
CALL [SHIFT] ;Now have mask of 0,,1777
AR_BR LONG, BR_AR LONG ;mask to BR, result TO AR!ARX.
MQ_MQ*BR, AD/ANDCB ;clear the last 10 MQ bits.
GEN AR, SC_#, #/3, ;generate NORM bits.
NORM, J/ENORM ;conditions set for EE norm.
.ENDIF/EXTEXP
.TOC "GFLT DIVIDE"
.IF/EXTEXP
EFDV0: FM[E1]_AR ;no sticky bits on divide.
=0 AR_BR, SKP AD0, CALL [SGNEXT] ;sign extend mem high.
GEN AR*AC0, AD/XOR, SKP AD0, ;determine sign of result.
BR_AR LONG ;mem op to BR!BRX.
=000 AR_AC1*2, CALL [EFDV1] ;start division.
SR_1, AR_AC1*2, CALL [EFDV1] ;note result if negative.
=011 AC1_AR, AR_MQ, ARL/AD, FE_FE+1, ;set step count to 35-2.
MQ_0.M, CALL [DIV+]
=101 AC1_AR, AR_MQ, ARL/AD, FE_FE+1,
MQ_0.M, CALL [DIV-]
=111 CLR AR, CLR FE ;exp must be adjusted-
AR0-8_#, #/200 ; it is currently 2000 too low
[AR]_[AR]*FM[T2], AD/A+B ;add in the correction.
FM[T2]_AR ;store the corrected exp in T2.
AR_AC1, ARX/MQ, SC_#, #/3, ;get answer ready for norm.
NORM, J/ENORM
=00
EFDV1: ARX_AR, AR_AC0, SKP AD0, FE_#, ;AC low*2 to ARX, AC high to AR.
#/23., CALL [EDVCHK]
=10 SKP BR0, J/DDVSUB
SET FL NO DIV, J/IFNOP ;no division this time.
=0
EDVCHK: MQ_AR, J/EDVCH1 ;go to an even address.
AR_-AR LONG, J/EDVCHK ;make ac op positive.
=0
EDVCH1: SKP AR0, CALL [ISOEXP] ;op saved in MQ, get exp in AR.
[AR]_[AR]*FM[T2], AD/A-B, ;subtract exponents.
SKP AD0 ;did this cause an underflow ?
=0
SET SR2 ;no, let SR2 denote this.
EDVCH2: FM[T2]_AR ;yes, save exponent in T2 for ENORM.
=0
EDVCH3: AR_MQ, SKP AD0, CALL [SGNEXT] ;now sign extend the op.
SKP BR0, MQ_0.M, J/FDVCK1
.ENDIF/EXTEXP
.TOC "GFLT NORMALIZATION"
.IF/EXTEXP
;Normalization is done here.
; The are 8 addresses the can be reached when doing a
; NORM dispatch. The following table describes the
; dispatching and how to normalize the fraction and
; exponent.
;
; =000 AR=0 AR is zero, check ARX,MQ
; =001 AR00=1 sign bit on, complement
; =010 MSB in AR 1-6 shf 4 rt.(a guess)
; =011 MSB in AR07 sht 2 rt.
; =100 MSB in AR08 sht 3 rt.
; =101 MSB in AR09 right on!
; =110 MSB in AR10 sht 1 lf.
; =111 MSB in AR 11-35 sht 4 lf.(a guess)
;
;The normalization routine for double precision assumes that
; the exponent can be found in the FE. As it goes through
; the normalization process, it adjusts the fraction and
; the FE by the correct amounts to normalize the number.
; In GFLT numbers, the exponent may not fit
; into the FE, so it has to be saved in an accumulator.
; However, if one assumes initially that the exponent is
; zero and that it is in the FE, then the same normalization
; algorithm can be used as in double precision numbers
; with the realization that at the end of the normalization
; process the FE contains the correction (EC) that must be
; added into the saved exponent (ES) to produce a 'bit-9'
; normalized number. Once this correction value is obtained,
; the 'bit-12' normalized exponent (EN) is given by
; EN = ES + EC + 3
MEMNRM: FM[T2]_AR ;save larger exponent.
[AR]_FM[E0], SKP AD0, J/ACNRM1 ;get high word, sign extend it
ACNORM: FM[T2]_AR ;save larger exponent.
AR_AC1*2, CLR FE ;get low word*2 into AR.
ARX_AR, AR_AC0, SKP AD0 ;get high word, sign extend it.
=0
ACNRM1: [AR]_[AR]*FM[EXPMSK], AD/AND, ;sign extend with 0's.
NORM, J/ENORM
[AR]_[AR]*FM[EXPMSK], AD/ORCB, ;sign extend with 1's.
NORM ;fall into the normalize routine.
=000
ENORM: SKP ARX+MQ NE, SC_#, #/35., ;AR=0,check ARX,+MQ.
J/ENZERO
BR/AR, BRX/ARX, AR_MQ COMP, ;result neg, complement.
SET SR3, J/ENNEG ;flag negative seen.
AR_AR*.25 LONG, MQ_MQ*.25, ;MSB in AR 1-6.
FE_FE+#, #/4, J/ENHI
AR_AR*.25 LONG, FE_FE+#, ;MSB in AR07.
#/2, J/EROUND ;
AR_AR*.5 LONG, FE_FE+1 ;MSB in AR08.
EROUND: BR_AR LONG, AR+MQ_0.S, ;MSB in AR09, where we want it.
J/ERND1 ;put result in BR!BRX.
(AR+ARX+MQ)*2, FE_FE-1, ;MSB in AR10.
J/EROUND
AR_SHIFT, FE_FE-SC ;MSB somewhere in AR 11-35.
ENSHFT: BR/AR, AR_ARX, ARX/MQ ;shift everyone.
MQ_SHIFT, AR_ARX (ADX), CLR ARX
MQ_SHIFT, ARX/MQ, AR_BR, ;go aroung again.
SC_#, #/10.,
NORM, J/ENORM
ENNEG: GEN E1, SKP AD NE ;any sticky bits left around?
=0 AR_AR+1, SKP CRY0, J/ENNEG1 ;no, 2's comp MQ.
MQ_AR, AR_BR COMP, ARX_BRX COMP,
NORM, J/ENORM ;one's complement to finish.
=0
ENNEG1: MQ_AR, AR_BR COMP, ARX_BRX COMP,
NORM, J/ENORM ;one's complement to finish.
MQ_AR, AR_-BR, ARX/ADX, ;carry happened, do two's comp.
NORM, J/ENORM
ENHI: (AR+ARX+MQ)*.25, J/ENTRY ;go try again after setting SC.
=0
ENZERO: SR_0,AR_0S,ARX_0S,I FETCH,J/DLOAD;[413] result 0, store in AC,AC+1
AR_SHIFT, FE_FE-SC, J/ENSHFT ;not zero, try next 35 bits.
ERND1: ARX_2+MQ0 ;[407] build rounding constant.
ARX_ARX*4 ;gen a 10 in the ARX for rounding.
AR_AR+BR, ARX/ADX, NORM ;do the rounding and test norm.
=110 AR_AR*.5 LONG, FE_FE+1 ;rounding blew norm, correct it.
; When we get here the number is 'bit-9' normalized
; in the AR,ARX. Add the FE + 3 to the exponent
; saved in T2.
; At this point the Extended Exponent must be put
; into the AR after everything is shifted right 3 bits.
; The double precision norm routine does this by:
; EXP_FE TST, SR DISP, CLR MQ, BRX/ARX, ARX_1
ERND2: AR_AR*.25 LONG, ;shift everything 2 bits right.
MQ_MQ*.25, ; " " "
SC_#, #/3 ;add in correction to FE.
AR_AR*.5 LONG, ;now shift the final bit position.
SC_FE+SC ;total exponent correction.
BR/AR, BRX/ARX, CLR AR ;save answer in BR,BRX.
EXP_SC.MS ;get exp corr in AR.
ARX_AR, AR_SIGN, ;get exp into ARX 1-8.
SC_#,#/33. ;prepare to shift 3 places.
ARX_SHIFT, ;move exponent into ARX 1-11.
[AR]_FM[EXPMSK] ;prepare to build mask in AR.
AR0-8_#, #/400 ;include AR00 in EXPMSK==>400077,,-1
AR_AR*BR, AD/AND, ;zero AR1-11 to make room for exp.
SC_#, #/35.
; I am sure a few lines of code can be saved around here.
[AR]_FM[T2], BR/AR ;save high word in BR, load larger exp.
AR_BR, BR/AR ;swap around so we can add.
AR_ARX+BR, BR/AR, ;have final exponent, check for problems.
SC_#,#/0
SH DISP ;any exponent problems ?
=0011 ARX_AR, SC_#, #/35., ; no problems.
J/ENFNL1
ENFNL0: ARX_AR, SC_#, #/35., ; no problems.
J/ENFNL1
SET FLOV, J/EEOV ; an overflow occurred.
SR DISP ;floating underflow - is it real ?
=1101 ;test SR2.
SET FXU, J/EEOV ;yes, it is a real underflow.
SET FLOV ;no, GFDV saw an overflow before.
EEOV: P_P AND #, #/37, ;turn off AR00.
J/ENFNL0
ENFNL1: AR_ARX*BR, AD/OR ;AR now has high word, BRX has low.
ARX_1, MQ_0.M, SR DISP ;incase negation of lower word needed.
=10 AC0_AR, AR_SHIFT, ;store high word,
ARX_BRX, ;move low word to ARX.
I FETCH, J/STD1 ;prepare to store low word and exit.
ARX_ARX*BRX, AD/ANDCA, ; clear rounding bit.
SR_0,J/CDBLST ;negate result and store double result.
ENTRY: SC_#, #/3, GEN AR, NORM, J/ENORM; go normalize again.
.ENDIF/EXTEXP
.TOC "GFLT TO INTEGER CONVERSION"
.IF/EXTEXP
.IF/GFTCNV ;[273]
;ETXIX routine is used when converting extended exponent data to
;single/double precision integers with rounding/truncation.
;This routine assumes that the AR/ARX contain the extended exponent
;data. It also assumes that the maximum exponent value + 1 of either
;36 or 70 (decimal) are already in the FE. This is the positive exponent
;maximum; the code adjusts for the fact that a negative number can have
;an exponent one greater than a positive number.
;It uses all of the registers in the EBOX and returns 4 if the
;result is positive and returns 5 if the result is negative
;with the AR/ARX containing the double word integer. It is the
;responsibility of the calling routine to determine whether
;rounding or truncation should be performed and how many words
;to store.
ETXIX: ARX_ARX*2 ;get low word*2 into ARX.
=0 MQ_AR, SKP AR0, ; get a positive exp in AR.
CALL [ISOEXP]
CLR AR, BR/AR ;clear extraneous bits, save exp.
AR0-8_#, #/200 ;test for positive exp.
GEN AR+BR, SKP AD0, ;skip on positive exponent(sum has AD0 on).
AR_0.M ;so exponent test has a clean register.
=0 MEM/ARL IND, CLR/AR+ARX,;exponent must be positive.
RETURN4 ;return to caller.
AR0-8_#, #/212, J/ET1 ;start range check of positive exponent
;At this point the exponent is in BR 1-11 and it is positive.
;Now we must determine if it is a small enough positive number
;to make the conversion to integer meaningful.
ET1: GEN AR-BR, SKP AD0 ;do the exponent test.
=0 AR_BR*4, J/ET2 ;exp fits in AR0-8, now for final test!
SET AROV, I FETCH, J/NOP;exponent out of range.
ET2: AR_AR*2 ;finish moving exponent into AR0-8.
SC_AR0-8, GEN MQ, ;exponent to SC.
SKP AD0 ;max neg exponent is 1 gtr than max pos exp.
=0
ET2A: AR_MQ, GEN FE-SC, ;shift low word into ARX00-34, caller
SKP SCAD0, ;put max exponent+1 in FE. range check.
J/ET2B
FE_FE+1, J/ET2A ;max neg exp is 1 gtr than max pos exp.
=0
ET2B: FE_SC, J/ET3 ;save exp in FE.
SET AROV, I FETCH, J/NOP;exponent is too large.
ET3: SC_#, #/12. ;prepare to map AR12 into AR00.
;We now have the high word in the AR and
;the low word*2 in the ARX. The SC has 12 (dec) to let the
;shifter strip off the sign and exponent of the high word.
AR_SIGN, MQ_SHIFT ;put high 36 integer bits into MQ.
AR_ARX, BR/AR, CLR ARX ;generate low 36 integer bits and
AR_BR, ARX/MQ, MQ_SHIFT,; put in MQ. High bits to ARX.
SC_FE-#, #/36., ;check the size of the exponent.
SKP SCAD0 ;if exp<36. then high result is sign.
=0 GEN SC, SKP SCAD NE, ;is exponent gtr or geq to 36 ?
J/ET3A
SC_#+SC, #/37., J/ET5 ;exponent less than 36.
=0
ET3A: (AR+ARX+MQ)*2, J/ET3B ;must shift left 1 bit.
BRX/ARX, SC_#+SC, #/1, ;adjust exp, save low word in BRX.
J/ET4
ET3B: BR_AR LONG, AR_ARX, ;high and low to BR!BRX
SC_#, #/35., ;get a good exponent for final shifting.
ARX/MQ, J/ET4A ;rest of fraction to ARX.
ET4: AR_ARX (AD), ARX/MQ, ;exp gtr 36. High result has integer bits.
MQ_SHIFT ;high result to MQ.
AR_MQ, ARX_SHIFT ;put integer bits into ARX.
BR_AR LONG, AR_ARX (AD),;now compute fraction.
CLR ARX ;low integer to AR, pad with zeros in ARX.
ET4A: AR_BR LONG, MQ_SHIFT, ;restore integer to AR!ARX, fraction to MQ.
SC_#, #/35., ;low word must have bit 0 same as high.
SKP AD0, RET[4] ; and return on sign of integer.
=01
ET5: FM[T0]_AR, AR_ARX (AD), ;sign is high 36 bit result. Save in T0.
ARX/MQ, ;high 36 bits of frac to AR, low 23 to ARX.
MQ_SHIFT, ;low integer result to MQ.
CALL [SHIFT] ;high half of fraction to AR.
;Now we have the high 36 bits of mantissa in AR, the low 23 bits if mantissa
;in the ARX, the high 36 bit result (the sign bits) in T0 and the low 36 bit
;result in the MQ. Now we compute the fraction to store.
BR/AR, AR_ARX, CLR ARX ;high frac to BR. Now gen low fraction bits.
ARX_SHIFT, ;low fraction bits to ARX.
SC_#, #/35. ;low word must have same sign as high.
GEN ARX*BR, AD/OR, ;gen composite OR of fraction into 1 word.
MQ_AD, ;put this funny fraction in the MQ.
ARX/MQ ;low integer result to ARX.
[AR]_FM[T0], SKP AD0, ;get high result (Sign) back in AR.
RET[4] ;and return to caller.
.ENDIF/GFTCNV ;[273]
;ISOEXP will isolate the exponent in an extended exponent data word.
;It will return the positive representation of the exponent.
;Call with AR containing high order word with "SKP AR0" to do
;correct things with one's complemented exponent in negative numbers.
;It returns 1 with the positive exponent in the AR.
=0
ISOEXP: [AR]_[AR]*FM[EXPMSK],AD/ANDCB,RET[1] ;isolate pos exp in AR1-11.
[AR]_[AR]*FM[EXPMSK],AD/NOR,RET[1] ;isolate neg exp in AR1-11.
;SGNEXT will extend the sign bit of the AR into AR1-11. Call with
;SKP AR0 so the correct actions are taken for negative numbers.
;It will do a return 1 with either ones or zeroes in AR1-11.
=0
SGNEXT: [AR]_[AR]*FM[EXPMSK], AD/AND, RET[1] ;extend 0s into AR1-11.
[AR]_[AR]*FM[EXPMSK], AD/ORCB, RET[1] ;extend ones into AR1-11.
;OVTEST will determine if the high order word of a double integer,
;as stored in the AR is all sign bits, ie either it is all zeroes
;or all ones. The call is via "GEN AR, SKP AD NE, J/OVTEST".
;It assumes that the double integer is in the AR/ARX and the SC
;contains 35 decimal.
;OVTEST will store the ARX*.5 and exit if the AR is all sign bits.
;It will set AROV and jump to NOP if it finds some data bits.
OVTST1: AR_MQ, SKP AD NE ;get the sign bits from the MQ.
=0
OVTEST: AR_SHIFT, I FETCH, J/OVTST2 ;the high word is all zeros - ok.
GEN AR+1, SKP AD NE ;check to see if it is all ones.
=0 AR_SHIFT, I FETCH, J/OVTST2 ;this is simply a negative number.
SET AROV, I FETCH, J/NOP ;sorry, we found some data bits.
OVTST2: AC0_AR, J/NOP ;finish the store.
.ENDIF/EXTEXP
.TOC "GFLT DATA CONVERSION INSTRUCTIONS"
.IF/EXTEXP
.DCODE
021: EA, AC, J/L-GTPI ;GSNGL--Must mate with EXTEND
EA, J/L-SFTE ;GDBLE
.IF/GFTCNV
EA, B/0, J/L-GTDI ;GDFIX
024: EA, B/2, J/L-GTSI ;GFIX
EA, B/4, J/L-GTDR ;GDFIXR
EA, B/6, J/L-GTSR ;GFIXR
.ENDIF/GFTCNV
027: EA, J/L-DITE ;DGFLTR
030: EA, J/L-SITE ;GFLTR
EA, J/L-EFSC ;GFSC
.UCODE
3116: [AR]_FM[E1], J/L-GTSP ; -21- GSNGL
3114: [AR]_FM[E1], J/L-EDBL ; -22- GDBLE
.IF/GFTCNV ;[273]
3105: [AR]_FM[E1], J/L-GTIN ; -23- DGFIX
3106: [AR]_FM[E1], J/L-GTIN ; -24- GFIX
3107: [AR]_FM[E1], J/L-GTIN ; -25- DGFIXR
3110: [AR]_FM[E1], J/L-GTIN ; -26- GFIXR
.ENDIF/GFTCNV ;[273]
3111: [AR]_FM[E1], J/L-FLTR ; -27- DGFLTR
3112: [AR]_FM[E1], J/L-DFLT ; -30- GFLTR
3113: [AR]_FM[E1], J/L-DFSC ; -31- GFSC
L-GTSP: VMA_AR, LOAD AR ;-21- GSNGL EDPFP TO SPFP
AR_MEM, MQ_0.S ;load high word into AR.
GEN AR, SKP AD NE ;check for zeroes.
=0 I FETCH, J/STORAC ;high word zero, store it.
VMA_VMA+1 ;point to mem low word.
=0 ARX_AR, SKP AR0, ;save high word in ARX.
CALL [ISOEXP] ;get the excess-2000 exponent.
CLR AR, BR/AR ;exp to BR.
AR0-8_#, #/220 ;largest exponent allowed is 2200.
GEN AR-BR-1, SKP AD0 ;range check exponent.
=0 AR0-8_#, #/157, J/L-GTS1;do lower range check now.(actually too low)
SET FLOV, I FETCH, J/NOP;tough
L-GTS1: BR/AR, AR_BR ;swap values around for next subtract.
GEN AR-BR, SKP AD0 ;do lower range check.
=0 BR/AR, CLR AR, J/L-GTS6 ;passed. 10 bit path to do last checks.
SET FXU, I FETCH, J/NOP ;too low.
L-GTS6: AR0-8_#, #/160 ;subtract 1600 to get excess 200 exp.
AR_BR, BR/AR ;swap around to do subtract.
AR_AR-BR ;got it.
AR_AR*8 ;move excess-200 exponent over.
FE_AR0-8, AR_ARX, ;put some exponent in FE. High word to AR.
LOAD ARX ;low word to ARX.
;This next test determines the relative size of the exponent. If the expo-
;nent is less than 401 then it is a positive exponent and all will be well.
;If the exponent is greater than 400 (actually 700), then the exponent is
;really negative but bit 0 of the FE is off. To correct the sign of the
;exponent and to prevent undeserved FXU later because of the incorrect sign
;bit, we must examine the value of the exponent so as to always get the
;correct sign during normalization.
ARX_MEM, GEN FE-#, ;undeserved FXU happens when FE00 should be
#/500, SKP SCAD0;set from previous subtract of 1600.
=0 FE_FE+#, #/777, ;set FE00. Later add will clear it.
ARX_ARX*2, ;low word * 2.
J/L-GTS7 ;continue.
FE_FE-1, ARX_ARX*2 ;adjust FE so later add gets right exp.
=0
L-GTS7: SKP AR0, CALL [SGNEXT] ;sign extend high word.
AR_AR*.25 LONG, ;prepare for normalization
FE_FE+#, #/6, ;adjust exponent.
NORM, J/SNORM ;finish up.
L-EDBL: VMA_AR, LOAD AR ;-22- GDBLE SPFP to EXTENDED EXPONENT
AR_MEM, CLR MQ
SC_EXP, ARX_AR, CLR AR ;correct the expoent, save a copy in the ARX
FM[E1]_AR ;no sticky bits here.
EXP_SC ;put the "positive" exponent back IN THE AR.
AR_AR*.5 ;must move exponent into AR4-11
AR_AR*.25 ; done.
BR/AR, CLR AR ;exp to BR.
AR0-8_#, #/160 ;put 1600 in the AR for exp conversion
AR_AR+BR, FE_#, #/-3 ;convert exp, set initial exp correction
FM[T2]_AR, AR_ARX ;save exp for ENORM, frac to AR
EXP_SIGN.C, ARX_0.M ;get rid of exp, clear low word
GEN AR, SC_#, #/3, NORM,;normalize an extended exponent number
J/ENORM
.IF/GFTCNV ;[273]
L-GTIN: VMA_AR, LOAD AR ;23-26. fetch high word.
AR_MEM, MQ_0.S, ;word in AR, init MQ.
VMA_VMA+1 ;prepare to fetch low word.
GEN AR, SKP AD NE ;is high word all zeroes ?
=0 CLR ARX, EXIT DBL ;high word zero, store zeroes.
LOAD ARX, B DISP ;fetch low word, call appropriate routine.
=000 ARX_MEM, J/L-G23 ;do GDP to DP integer, truncate.
=010 ARX_MEM, J/L-G24 ;do GDP to SP integer, truncate.
=100 ARX_MEM, J/L-G25 ;do GDP to DP integer, rounded.
=110 ARX_MEM, J/L-G26 ;do GDP to SP integer, rounded.
= ;terminate this dispatch block.
;DGFIX needs the sticky bit fix.
=0010
L-G23: FE_#, #/70., ;-23- DGFIX GDP to double integer, truncate.
CALL [ETXIX] ;do the conversion
=0110 EXIT DBL ;store results.
=0111 BR_AR LONG, AR_ARX, ;save high 2 words in BR!BRX, MSB of
ARX/MQ, ;fraction to AR35. Rest of fraction to ARX.
SC_#, #/35., ;get fraction all together.
CALL [EF12A]
=1111 GEN AR, SKP AD NE, ;any fraction bits on ?
MQ_0.S ;[240]CLEAR MQ00 FOR ARX_2 MACRO.
=0 AR_BR LONG, J/ST2AC ;no, leave answer alone.
CLR AR, ARX_2 ;yes, add 1 to integer part.
AR_AR+BR LONG, J/ST2AC ;store result.
;GFIX needs the sticky bit fix.
=0010
L-G24: FE_#, #/35., ;-24- GFIX GDP to single integer, truncate.
CALL [ETXIX] ;do the conversion
=0110
L-GTS2: SKP AR NE, J/OVTEST ;test for sign bits in AR and store.
=0111 BR_AR LONG, AR_ARX, ;save in BR!BRX.
ARX/MQ, ;add one to integer part of negative number
SC_#, #/35., ;if fraction is not zero.
CALL [EF12A]
=1111 GEN AR, SKP AD NE, ;is fraction zero ?
MQ_0.S ;[240]CLEAR MQ00 FOR ARX_2 MACRO.
=0 AR_BR LONG, SKP AD NE, ;yes, try to store the result.
J/OVTEST
CLR AR, ARX_2 ;no, add one to integer part.
AR_AR+BR LONG, SKP AD NE,; do the add and test that the high
J/OVTEST ;word is all sign bits.
=011
L-G25: FE_#, #/70., ;-25- DGFIXR GDP to double integer, rounded.
CALL [ETXIX] ;do the conversion
=111 BR_AR LONG, CLR AR, ;save in BR!BRX, round by adding one half
ARX_1, ;to result. Remember that the MSB of the
SC_#, #/35. ;store routine expects this.
AR_AR+BR LONG, AD FLAGS ;fraction is on ARX35. Do the rounding and
;=0 ; replace SKP CRY0 with AD FLAGS. Eliminates extra word.
EXIT DBL ; store the double result.
; SET AROV, I FETCH, J/NOP;rounding caused an overflow - too bad!
=011
L-G26: FE_#, #/35., ;-26- GFIXR GDP to single integer, rounded.
CALL [ETXIX] ;do the conversion.
=111 BR_AR LONG, CLR AR, ;save in CR!BRX, round by adding one half
ARX_1, ;to result. MSB of the fraction is in ARX35.
SC_#, #/35. ;store routine expects this.
AR_AR+BR LONG, SKP AD NE,;do the rounding.
J/OVTEST ;figure out what, if any, to store.
.ENDIF/GFTCNV ;[273]
L-FLTR: VMA_AR, LOAD AR, ;-27- DGFLTR DP INTEGER to EDPFP
FE_#, #/137 ;inital fugde factor for exp
AR_MEM, MQ_0.S ;get high word into the AR.
=0* VMA_VMA+1, LOAD ARX, ;get the low word into the ARX,
BR/AR, CALL [XFERW]; and save the high word in the BR.
=1* ARX_ARX*2, CLR AR ;ignore the sign copy.
FM[E1]_AR ;no sticky bits here.
AR0-8_#, #/200 ;ENORM expects the exponent in T2.
FM[T2]_AR, AR_BR, ;and save it in T2.
ARX/AD, MQ_ARX ;sign to AR, high to ARX, low to MQ.
AR_SIGN ;
GEN AR, NORM, J/ENORM ;restore high word and normalize.
L-DFLT: VMA_AR, LOAD AR, ;-30- GFLTRSP INTEGER to EDPFP
FE_#, #/4 ;initial fudge factor for exp.
AR_MEM, CLR MQ ;get the single precision op.
AR_SIGN, ARX_AR ;build a dummy high word of all sign.
BR/AR, CLR AR ;save sign, prepare for exponent.
FM[E1]_AR ;no sticky bits here.
AR0-8_#, #/207 ;build an initial exp of 207 for ENORM
FM[T2]_AR, AR_BR, ;save exp for ENORM, restore sign word.
NORM, J/ENORM ;and normalize it.
=0
L-DFSC: AR_AC0, BR/AR, SKP AD0, ;-31- GFSC EDPFP SCALE
CALL [ISOEXP] ;get the exponent into the AR.
BR/AR, AR_BR ;put exp in BR, scale factor to AR.
AR_AR SWAP, GEN AC0, ;put scale in left half of AR.
SKP AD NE ;is high word zero ?
=0 AR+ARX+MQ_0.M, J/ST2AC ;yes, store zero as double result.
AR_SIGN, ARX_AR, SC_#, ;no, move sign and scale factor together.
#/34.
AR_SHIFT, CLR FE ;sign now in AR00, scale in AR 9-19.
EXP_SIGN ;scale sign is in AR00; extend it.
SC_#, #/8. ;move scale factor into AR 1-11 and
AR_SHIFT, ARX_AC1 ; put the sign to left of scale factor.
AR_AR+BR, CLR MQ ;add exponent and scale factor.
SH/AR, DISP/SH0-3 ;check for over and under flovs.
=0011
L-FSC2: [AR]_[AR]*FM[EXPMSK], ;clear out non-exponent bits.
AD/ANDCB, ;and AR00 in the over or under flow case.
J/L-FSC3 ; and continue
=0111 [AR]_[AR]*FM[EXPMSK], ;clear out non-exponent bits.
AD/ANDCB, ;
J/L-FSC3 ; and continue
=1011 SET FLOV, J/L-FSC2 ;you lose
=1111 SET FXU, J/L-FSC2 ;ditto
L-FSC3: FM[T2]_AR, ARX_ARX*2 ;save new exponent fofr ENORM.
=0 AR_AC0, SKP AD0, ;get the high word.
SC_#, #/3, ;for ENORM.
CALL [SGNEXT] ;and sign extend it for ENORM as well.
GEN AR, NORM, J/ENORM ;put the result back together.
.ENDIF/EXTEXP