Trailing-Edge
-
PDP-10 Archives
-
CFS_TSU04_19910205_1of1
-
update/ftnosr/mthtrp.mac
There are 9 other files named mthtrp.mac in the archive. Click here to see a list.
SEARCH MTHPRM
TV MTHTRP ARITHMETIC TRAP HANDLER,2(4017)
SUBTTL CHRIS SMITH/CKS/JLC/DAW 31-Jul-79
;COPYRIGHT (c) DIGITAL EQUIPMENT CORPORATION 1981, 1987
;ALL RIGHTS RESERVED.
;
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY BE USED AND COPIED
;ONLY IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE AND WITH THE
;INCLUSION OF THE ABOVE COPYRIGHT NOTICE. THIS SOFTWARE OR ANY OTHER
;COPIES THEREOF MAY NOT BE PROVIDED OR OTHERWISE MADE AVAILABLE TO ANY
;OTHER PERSON. NO TITLE TO AND OWNERSHIP OF THE SOFTWARE IS HEREBY
;TRANSFERRED.
;THE INFORMATION IN THIS SOFTWARE IS SUBJECT TO CHANGE WITHOUT NOTICE
;AND SHOULD NOT BE CONSTRUED AS A COMMITMENT BY DIGITAL EQUIPMENT
;CORPORATION.
;DIGITAL ASSUMES NO RESPONSIBILITY FOR THE USE OR RELIABILITY OF ITS
;SOFTWARE ON EQUIPMENT WHICH IS NOT SUPPLIED BY DIGITAL.
COMMENT \
***** Begin Revision History *****
Modified from LIB40 TRAPS version 32A(444)
1100 CKS 10-Aug-79
Rewrite for version 6
Remove KA code and fixups for KA-format double precision instructions
Add integer fixups (not enabled)
Change UTRP instruction to JSR (can't use PUSHJ because DDT's stack
pointer is AC 1)
Reorder stuff to optimize for SWTRP and UTRP
Add fixups for G-format DP numbers
1217 JLC 09-Dec-80
Fix integer divide check so it "patches" the answer
1464 DAW 12-May-81
Error messages.
1466 CKS 18-May-81
Use XSIR-format tables if the monitor supports them
1526 BL 9-Jul-81
Make %PSIINI 'IF20'-conditional.
1531 JLC 10-Jul-81
Typo in edit 1526.
1572 JLC 31-Jul-81 Q10-6348
Setup F before calling trap error typeout.
1656 DAW 2-Sep-81
Get rid of magic numbers.
1662 DAW 4-Sep-81
New routine %CALU.
1700 BL 10-Sep-81
Remove INTERN %CALU from 'IF20'.
1731 DAW 21-Sep-81
Overflows not filling in the right stuff.
1753 DAW 29-Sep-81
Don't call %TRACE on LERR's - PC is part of message now.
2033 DAW 19-Nov-81
Don't do XSIR% unless FOROTS is running in a non-zero section;
otherwise the Release 4 EXEC gets confused.
***** Begin Mathlib *****
3056 JLC 23-Mar-82
Change the names of the error tables, add 1.
3122 JLC 29-Apr-82
MATHLIB integration. Return to program if the instruction
after the trapped one is JFCL with flag bits. If JFCL with
no flag bits, do standard fixup and return to user program
or address if address is specified. If other instruction,
call error routine via $TCALL, which will print error
message if not over message limit, and call a user trap
routine (if specified) with the unfixed result and its type,
allowing the user to supply a fixup.
Removed the non-preferred trapping mechanisms for both
TOPS-10 and TOPS-20, as the preferred methods (UTRP. on
the -10 and SWTRP% on the -20) are both standard in the
currently released monitors.
3203 JLC 27-May-82
Fixed typo at NOCALU, TRNE was TRNN, so trap returned
to AC0 instead of routine.
3204 JLC 2-Jun-82
Removed ERR segment.
3205 JLC 3-Jun-82
Moved the error character to the first argument in TERRs.
3211 JLC 26-Jun-82
Fixed the documentation to reflect the separation of the
data type and the "2nd error number" in the user subroutine
call.
3213 JLC 20-Jul-82
Save user's PDP in %ERPDP in trap processing, so that error
processor can call GETPC to get module name.
3214 JLC 16-Aug-82
Fix code at NOCLRF so it gets the original flags into PC
for JRSTF. Turn off extraneous bits (namely, WRONGBIT) before
using index into XLOAD and XSTORE.
3222 JLC 9-Nov-82
Install patch to use APRENB instead of UTRP for the KS-10
to avoid microcode/monitor bug which caused infinite loops
in the overflow trap code.
3225 CKS 3-Jan-83
Clear floating underflow PC flag when returning from underflow trap
caught by JOV. Otherwise, since the JOV only clears overflow, you
get stray underflow flags left around.
***** Begin Version 1A *****
3243 BCM 29-Mar-83
Get and clear PC flags with new GETFLG and RESFLG macros. Fixes
always clearing underflow in MTHTRP. Only applies to JOV branches.
3252 MRB 27-Sep-83 10-34127
Changed error message "integer overflow" to "Arithmetic
integer overflow" to avoid confusion with "Input integer
overflow".
***** End Revision History *****
***** Begin Version 2 *****
4006 JLC 27-Oct-83
Removed edit 3252, as confusion is now removed by the
word "Input" for the input overflows.
4013 JLC 12-Jun-84
Added code to get XCT of a trapped instruction right most
of the time.
4017 JLC 16-Jan-85
Fix TOPS-10 extended addressing trap code.
\
SEGMENT CODE
ENTRY %TRPINI
EXTERN %TRFLG,%ERRPC,%UNFXD,%FIXED,%ERTYP,%ERPDP
EXTERN %ABORT
COMMENT \
DESCRIPTION OF "TRAPS" PROGRAM FOR MATHLIB-
I. THE PURPOSE OF THE TRAPS PROGRAM IS DO ERROR DETECTION,
CORRECTION, AND REPORTING WHEN ARITHMETIC FAULTS OCCUR
DURING THE EXECUTION OF FORTRAN PROGRAMS.
II. THE TRAPS PROGRAM CONSISTS OF THREE DISTINCT PARTS:
A. %TRPINI
1. CALLING SEQUENCE- PUSHJ P,%TRPINI
2. PROCESSOR AND MONITOR TRAPPING ON OVERFLOW (PC WORD
BIT 0) IS ENABLED
B. ERRSET is a user-callable subroutine to set the conditions
for trap handling.
CALL ERRSET (N)
or CALL ERRSET (N, I)
or CALL ERRSET (N, I, SUBR)
where N = max number of error messages to type
I = which error this call applies to. One of:
-1 any of the following
0 integer overflow
1 integer divide check
4 floating overflow
5 floating divide check
6 floating underflow
if I is not specified, -1 is assumed
SUBR = routine to call on the trap
C. OVTRAP IS THE USER-MODE INTERRUPT ROUTINE WHICH IS STARTED
BY THE MONITOR WHEN AN ARITHMETIC FAULT OCCURS.
1. The PC word (with the address+1 of the instruction
causing the trap) is stored in PC.
2. FOR FLOATING POINT INSTRUCTIONS
A. FOR OVERFLOWS AND DIVIDE CHECKS,
THE FAULTY ANSWER IS PATCHED
TO BE PLUS OR MINUS (THE SIGN WILL BE THAT
OF THE CORRECT ANSWER)THE LARGEST POSSIBLE
NUMBER.
B. FOR UNDERFLOWS, THE FAULTY ANSWER IS NORMALLY
PATCHED TO BE 0. HOWEVER, IF THE INSTRUCTION
FOLLOWING THE TRAPPING INSTRUCTION IS A JFCL
WITH BIT 16 (XR2) SET, THE ANSWER WILL BE
UN-NORMALIZED ENOUGH TO BRING THE EXPONENT
BACK INTO RANGE.
3. For integer instructions, no attempt is made to fix
up the faulty result. The problem is with the instructions
AOJX, AOSX, SOJX, and SOSX. These can modify the PC
and overflow. The new PC stored by the overflow trap
does not point to the instruction that overflowed, so
the recovery code will "fix" up a random instruction. The
probability of this occurrence is small, but if it does
happen there is no way to limit the consequences.
The only available solution is to not touch any integer
overflow.
4. IF THE INSTRUCTION AFTER THE TRAPPING INSTRUCTION
IS JFCL
A. DO NOT TYPE AN ERROR MESSAGE
B. DO NOT INCREMENT THE TRAP COUNTER ENTRY
C. IF ANY FLAG BITS ARE ON (9-12), IMMEDIATELY
RETURN TO THE PROGRAM WITHOUT CLEARING THE
FLAGS, AS IF THERE WERE NO TRAP HANDLER.
D. IF THE ADDRESS (BITS 18-35) OF THE JFCL
ARE NON-ZERO, THE INTERRUPTED PROGRAM WILL
BE RESTARTED AT THE ADDRESS OF THE JFCL
(THE @ AND INDEX FIELDS ARE IGNORED FOR
THE EFFECTIVE ADDRESS).
E. IF THE ADDRESS OF THE JFCL IS ZERO, THE
INTERRUPTED PROGRAM WILL BE RESTARTED AT
THE JFCL
5. IF THE INSTRUCTION AFTER THE TRAPPING INSTRUCTION
IS NOT JFCL
A. INCREMENT THE TRAP COUNTER ENTRY
B. TYPE AN ERROR MESSAGE WITH THE FOLLOWING INFORMATION:
FLOATING OR INTEGER FAULT
OVERFLOW, UNDERFLOW, OR DIVIDE CHECK
ADDRESS OF FAULTING INSTRUCTION
C. IF A USER SUBROUTINE SUBR IS SPECIFIED BY A PREVIOUS
CALL TO ERRSET (SEE ABOVE), THE TRAP HANDLER
SIMULATES A CALL TO THE SUBROUTINE:
CALL SUBR (TRPNUM,PC,NUM2,VARTYP,UNFXD,FIXED)
WHERE TRPNUM IS THE TRAP NUMBER, PC IS THE
LOCATION OF THE TRAP RETURNED BY THE
MONITOR (WHICH MAY BE THE ADDRESS OF AN
XCT OR UUO WHICH THEN EXECUTED THE ACTUAL
INSTRUCTION TRAPPED), NUM2 IS A 2ND ERROR NUMBER
RESERVED FOR FUTURE USE, VARTYP IS THE TYPE CODE
OF THE VARIABLE MODIFIED BY THE TRAPPED
INSTRUCTION, UNFXD IS THE UNFIXED VALUE
OF THE VARIABLE, AND FIXED IS THE FORTRAN
FIXED VALUE. FORTRP USES THE VALUE RETURNED
IN FIXED, SO THAT THE USER MAY SUBSTITUTE
FOR THE FORTRAN FIXUP. NOTE THAT WHILE INTEGER
OVERFLOWS ARE TRAPPED, FIXUPS ARE NOT DONE.
(SEE NOTE ABOVE REGARDING INTEGER INSTRUCTIONS.)
D. THE INTERRUPTED PROGRAM WILL BE RESTARTED AT
THE INSTRUCTION AFTER THE TRAPPING INSTRUCTION
E. THE PROCESSOR FLAGS (PC WORD FLAGS) ARE CLEARED
EXCEPT FOR CRY0, CRY1, AND USER IOT.
F. THE INTERRUPTED PROGRAM IS RESTARTED
III. LIMITATIONS
A. Fixups are not made for KA-format double precision
numbers. The instructions FADL, FSBL, FMPL, FDVL,
UFA, and DFN are not recognized as requiring fixups.
B. THE MEMORY FIX UPS FOR THE FLOATING POINT INSTRUCTIONS
WILL NOT WORK PROPERLY IF THE ANSWER IS STORED INDEXED
BY 17 (THE PUSH DOWN POINTER). EXAMPLES:
FADRM AC,(17)
FMPRB AC,-2(17)
FDVM AC,+1(17)
C. MOVNX and MOVMX are integer instructions and will have
get integer fixups if they cause overflow. These
instructions can't overflow when dealing with normalized
floating point numbers.
D. THE TRAPPING INSTRUCTION MUST NOT BE IN AC 0.
F. THE SIGN OF F.P. DIVIDE CHECK FIX UPS WILL BE CORRECT
ONLY WHEN DIVIDING BY ZERO. (THIS IMPLIES THAT THE
ARGUMENTS FOR DIVIDE CHECKS SHOULD BE NORMALIZED.)
\
;PC FLAGS
;THESE FLAGS SHOULD BE DEFINED IN FORPRM INSTEAD
UBITS==PC%USR+PC%UIO ;FOR NOW, THE FLAGS WE WANT NOT
;TO TURN OFF. WE REALLY
;WANT TO JUST TURN OFF
;THE FLAGS WE ARE INTERESTED IN
;ENTRY POINT TO INITALIZE TRAP HANDLER
%TRPINI:
XMOVEI T1,. ;Get section number
HLLZM T1,MSECT ;SAVE SECTION NUMBER OF TRAP HANDLER
TLNN T1,-1 ; Are we running in section 0?
JRSTF @[UBITS+SETRAP] ;YES. DO JRSTF TO CLEAR FLAGS
XMOVEI T1,SETRAP ;Place to go
MOVEM T1,TRPBLK+1 ;Save in 2nd word
MOVE T1,[UBITS] ;Flags
MOVEM T1,TRPBLK ;Save in 1st word
XJRSTF TRPBLK ;** Clear arithmetic flags **
IF20,<
SETRAP: XMOVEI T1,OVTRP ;SET TRAP ADDRESS IN CONTROL BLOCK
MOVEM T1,NPC
MOVEI T1,.FHSLF ;THIS FORK
MOVEI T2,.SWART ;SET ARITHMETIC TRAP ADDRESS
XMOVEI T3,TRPBLK ;POINT TO CONTROL BLOCK
SWTRP% ;TELL MONITOR
POPJ P, ;DONE
> ;END IF20
IF10,<
; This code is to alleviate a problem caused by a
; microcode bug in the KS processor running under
; TOPS-10. It should be removed when the problem
; has been corrected (don't hold your breath).
; The code will check to see
; if the processor type is a KS10, then use the
; APRENB trapping to avoid the problem with UTRP.
SETRAP: MOVE T1,[%CCTYP] ;get processor type from
GETTAB T1, ; the CPU data constants
JRST NUTRP ;CAN'T FAIL
MOVEI T1,(T1) ;get just right half
CAIN T1,.CCKSX ;if the processor is a KS
JRST NUTRP ;then use APRENB trapping.
MOVE T1,[JRST OVINT] ;SET UP JRST TO HIGH SEG
MOVEM T1,LTRAP+1 ;STORE IN WRITABLE MEMORY FOR JSR
MOVE T1,[1,,[2 ;SET TRAP,,BLOCK LENGTH
.UTAOF ;TRAP ON ARITHMETIC OVERFLOW
JSR LTRAP]] ;INSTRUCTION TO EXECUTE ON TRAP
UTRP. T1, ;SET INSTRUCTION TO EXECUTE
JRST NUTRP ;TOO BAD, NO TRAPPING
POPJ P, ;DONE
;APRENB TRAPPING. USE ONLY IF WE'RE ON A KS OR UTRP DOESN'T WORK.
NUTRP: MOVEI T1,APRTRP ;GET TRAP ADDRESS
HRRZM T1,.JBAPR ;STORE IN JOBDAT
MOVEI T1,AP.REN+AP.AOV+AP.FOV ;TRAP ON OVERFLOW
APRENB T1, ;ENABLE TRAPS
POPJ P, ;DONE
;HERE FROM MONITOR ON APRENB TRAP
;MOVE PC TO WHERE UTRP WOULD HAVE PUT IT
APRTRP: PORTAL .+1 ;OK TO ENTER HERE FROM PUBLIC PAGE
DMOVEM T0,ACS ;SAVE T0-T1
MOVE T0,.JBTPC ;GET TRAP PC
MOVEM T0,LTRAP ;STORE IT IN RIGHT PLACE
JRST OVZERO ;JOIN UTRP CODE
;HERE FROM JSR ON DIRECT OVERFLOW TRAP
;[4013] NEW CODE
OVINT: PORTAL .+1 ;OK TO ENTER HERE FROM PUBLIC PAGE
DMOVEM T0,ACS ;SAVE T0-T1
SKIPN MSECT ;SHOULD WE BE IN A NON-ZERO SECTION?
JRST OVZERO ;NO
XMOVEI T0,0 ;ARE WE ALREADY THERE?
JUMPN T0,OVNONZ ;YES
MOVE T0,MSECT ;GET SECTION # OF TRAP HANDLER
HRRI T0,OVNONZ ;AND ADDRESS OF A PLACE TO GO
XJRST T0 ;AND GO THERE
> ;END IF10
;THIS CODE ATTEMPTS TO GET ALL THE DATA THAT THE SWTRP JSYS GETS
;ON TOPS-20. THE COMPLICATED PART IS THE CALCULATION OF THE EFFECTIVE
;ADDRESS OF THE TRAPPED INSTRUCTION. THIS IS DONE BY GETTING THE LOCAL
;(18-BIT) ADDRESS FROM THE TRAPPED INSTRUCTION, THEN MOVING THE INDIRECT
;AND INDEX BITS TO THEIR PLACE IN EFIW FORMAT, AND USING AN INDIRECTED
;XMOVEI INSTRUCTION TO CALCULATE THE EFFECTIVE ADDRESS (THIS MUST BE
;DONE BECAUSE THE TRAPPED INSTRUCTION MAY, IN FACT, BE IN A DIFFERENT
;SECTION THAN THE TRAP HANDLER). NOTE THAT IF THE TRAPPED INSTRUCTION IS
;INDEXED, THE INDEX REGISTER MUST BE EXAMINED TO SEE IF IT CONTAINS A
;SECTION NUMBER. IF IT DOES, THE Y FIELD OF THE TRAPPED INSTRUCTION IS
;AN OFFSET, AND THUS DOES NOT GET A SECTION NUMBER ATTACHED TO IT IN
;THE EFFECTIVE ADDRESS CALCULATION.
OVNONZ: SFM FLGS ;SAVE FLAGS WHERE THEY BELONG
MOVE T0,LTRAP ;NON-ZERO SECTION. GET PC
MOVEM T0,PC ;SAVE IT
SUBI T0,1 ;DECREMENT TO POINT AT TRAP INSTRUCTION
MOVE T0,@T0 ;GET TRAP INSTRUCTION
XCTNZ: HLRM T0,INST ;[4017] STORE TRAP INSTRUCTION
HRRZM T0,INDADR ;SAVE LOCAL ADDRESS OF TRAPPED INST
HLLZ T0,T0 ;TOSS THE LOCAL ADDRESS
TLZ T0,777740 ;CLEAR THE INSTRUCTION AND AC FIELDS
LSH T0,^D12 ;MOVE IND,IDX TO EFIW FIELDS
MOVEM T0,INDTMP ;[4017] SAVE IND, IDX FIELDS
TLZ T0,200000 ;[4017] CLEAR IND FIELD
JUMPN T0,NZIDX ;IF INDEX, GO CHECK INDEX REGISTER
HRRZ T0,INDADR ;NO INDEXING. GET LOCAL ADDRESS AGAIN
CAILE T0,17 ;IS IT AN AC?
JRST NZGSN ;NO. USE PC-SECTION
HRLI T0,1 ;YES. GET AC GLOBAL ADDRESS
JRST GETEA ;AND GO CALCULATE EFFECTIVE ADDRESS
NZIDX: XMOVEI T0,@T0 ;[4017] GET INDEX REG
TLZN T0,-1 ;[4017] IS IT EXTENDED REG?
NZGSN: IOR T0,PC ;[4017] NO. GET SECTION NUMBER IN LEFT HALF
GETEA: IOR T0,INDTMP ;[4017] GET IND, IDX AGAIN
HLLM T0,INDADR ;SAVE EFIW IND, IDX, AND SECTION NUMBER
MOVE T0,ACS ;GET SAVED T0
XMOVEI T0,@INDADR ;DO EACALC
MOVEM T0,E ;SAVE EFFECTIVE ADDRESS OF TRAPPED INST
JRST OVTRAP ;JOIN COMMON CODE
OVZERO: MOVE T0,LTRAP ;GET TRAP PC AND FLAGS
HLLZM T0,FLGS ;SAVE FLAGS
HRRZM T0,PC ;AND PC
SUBI T0,1 ;DECREMENT TO POINT AT TRAP INSTRUCTION
MOVE T0,@T0 ;GET TRAP INSTRUCTION
HLRM T0,INST ;STORE TRAP INSTRUCTION
MOVEI T0,@T0 ;GET EFFECTIVE ADDRESS
MOVEM T0,E ;SAVE IT
JRST OVTRAP ;JOIN COMMON CODE
;HERE ON OVERFLOW TRAP WITH TRPBLK FILLED IN
OVTRP: DMOVEM T0,ACS ;SAVE T0-T1
;CHECK HERE IF WE GOT A TRAP WITHIN A TRAP ROUTINE (FATAL).
OVTRAP: MOVEM P,%ERPDP ;SAVE CURRENT PDP FOR ERROR REPORTING
MOVE T0,PC ;GET PC OF TRAP + 1
SUBI T0,1 ;GET PC OF TRAP
MOVEM T0,%ERRPC ;SAVE FOR ERROR REPORTING
SKIPE %TRFLG ;WERE WE IN A TRAP ALREADY?
$TCALL TDT,%ABORT ;TRAP DURING TRAP PROCESSING
;[3122]CHECK THE INSTRUCTION AFTER THE TRAPPED ONE. IF IT IS
;JFCL WITH FLAGS, RETURN TO THE USER PROGRAM WITHOUT TURNING
;OFF THE FLAGS.
TRAPOK: HLRZ T0,@PC ;GET INSTRUCTION AFTER TRAP
TRZ T0,37 ;SHUT OFF I AND X
TRZN T0,740 ;ANY AC BITS?
JRST NOTJF ;NO. CAN'T BE JFCL WITH FLAGS
CAIE T0,(JFCL) ;[3243] YES. IS IT A JFCL?
JRST NOTJF ;[3243] NO, GO HANDLE THE TRAP
DMOVE T0,ACS ;[3243] YES, RESTORE ACS AND RETURN NOW
JRST @PC ;[3243] WITHOUT SETTING ANY FLAGS
NOTJF: SETOM %TRFLG ;SET FLAG FOR INSIDE TRAP ROUTINE
DMOVEM T2,ACS+T2 ;SAVE T2-T3
LDB T1,[POINT 9,INST,26] ;GET OPCODE OF TRAP INSTRUCTION
CAIL T1,100 ;OUTSIDE TABLE RANGE?
CAILE T1,377
MOVEI T1,100 ;YES, SET TO INNOCUOUS TABLE ENTRY
IDIVI T1,4 ;4 BYTES PER WORD
LDB T1,BPTAB(T2) ;GET FLAG BITS FOR THIS INSTRUCTION
JUMPE T1,XRET ;INSTRUCTION CAN'T OVERFLOW, DON'T TRY FIXUPS
LDB T2,[POINT 4,INST,30] ;GET AC FIELD OF INSTRUCTION
CAIG T2,T3 ;DOES INST USE ACS T0-T3?
XMOVEI T2,ACS(T2) ;YES, RELOCATE TO SAVED ACS
MOVEM T2,AC ;SAVE AC ADDRESS OF INSTRUCTION
MOVE T2,E ;GET EFFECTIVE ADDRESS
CAIG T2,T3 ;IN SAVED ACS?
XMOVEI T2,ACS(T2) ;YES, RELOCATE
MOVEM T2,E
CAIE T1,SP ;SPECIAL INSTRUCTION?
JRST SPCONT ;NO. NORMAL INST
;SPECIAL CASES (EXTEND INSTRUCTIONS, XCT)
;[3122] FOR FIX, FIXR, PUT THE UNFIXED RESULT (A REAL VALUE) IN THE AC
SPINST: LDB T1,[POINT 9,INST,26] ;GET OPCODE AGAIN
CAIN T1,(<XCT>B9) ;XCT INSTRUCTION?
JRST SPXCT ;YES, GO HANDLE
CAIN T1,(<EXTEND>B9) ;EXTEND?
JRST SPEXT ;YES
;MUST BE A FIX OR FIXR
SPFIX: MOVE T0,@E ;GET THE UNFIXED QUANTITY
MOVEM T0,@AC ;PRETEND THE AC GOT THE UNFIXED VALUE
MOVEI T1,SPRA ;TELL THE USER IT'S A REAL VALUE
JRST SPCONT ;AND CONTINUE
SPEXT: MOVE T1,ACS+T1 ;RESTORE NONZERO ACS
DMOVE T2,ACS+T2
MOVE T0,@E ;GET EXTENDED INST
XMOVEI T1,@T0 ;GET ITS EFFECTIVE ADDRESS
CAIG T1,T3 ;IN SAVED ACS?
XMOVEI T1,ACS(T1) ;YES, RELOCATE
MOVEM T1,E ;Store real E
LDB T1,[POINT 9,T0,8] ;GET EXTEND OPCODE
CAIL T1,020 ;OUTSIDE TABLE RANGE?
CAILE T1,031
MOVEI T1,020 ;YES, SET TO INNOCUOUS TABLE ENTRY
ADDI T1,400-020 ;OFFSET TO END OF MAIN TABLE
IDIVI T1,4 ;9 BYTES PER WORD
LDB T1,BPTAB(T2) ;GET FLAG BITS FOR INSTRUCTION
JUMPE T1,XRET ;IF INST CAN'T OVERFLOW, DON'T TRY FIXUP
TRZN T1,WRONGBIT ;DOES INST LEAVE RESULT IN WRONG OPERAND?
JRST SPCONT ;NO, FINE
MOVE T0,@E ;GET OPERAND
MOVEM T0,@AC ;STORE IN AC FOR SIGN FIXUP
JRST SPCONT ;GO CONTINUE AS IF NORMAL INST
SPXCT: DMOVE T0,ACS ;RESTORE ACS
DMOVE T2,ACS+T2
MOVE T0,@E ;GET XCTED INST
SKIPE MSECT ;[4013]NON-ZERO SECTION?
JRST XCTNZ ;[4013]YES. MUST BE HANDLED MORE CAREFULLY
XMOVEI T1,@T0 ;GET ITS EFFECTIVE ADDRESS
CAIG T2,T3 ;IN SAVED ACS?
XMOVEI T2,ACS(T2) ;YES, RELOCATE
HLRM T0,INST ;STORE INST
MOVEM T1,E ;Store E
JRST OVTRAP ;START OVER
;[3122] SAVE THE UNFIXED RESULT IN %UNFXD
SPCONT: MOVEI T2,(T1) ;COPY FLAGS, ARG TYPE
LSH T2,-4 ;GET JUST FLAGS
ANDI T2,7 ;TURN OFF EXTRA BITS
XCT XLOAD(T2) ;GET UNFIXED RESULT
DMOVEM T2,%UNFXD ;SAVE FOR USER CALL
HLLZ T0,FLGS ;GET PC FLAGS
TLNN T0,(PC%FUF) ;FLOATING UNDERFLOW?
JRST OV ;NO, GO HANDLE OVERFLOW
REPEAT 0,<
MOVE T2,@PC ;GET INSTRUCTION AFTER TRAP INST
TLC T2,(JFCL (2)) ;IS IT A JFCL (2)?
TLNN T2,777002
JRST UNNORM ;YES, GO UNNORMALIZE RESULT
> ;END REPEAT 0
SETZB T2,T3 ;SET FIXED-UP VALUE TO 0
JRST STRET ;DONE
REPEAT 0,<
;THIS CODE HAS BEEN RECODED AND MOVED TO MODULE UNNORM IN MTHSNG, SINCE
;THE USER NOW HAS ACCESS TO THE UNFIXED AND FIXED-UP RESULTS
;VIA ERRSET.
UNNORM: MOVEI T2,(T1) ;COPY FLAGS AND TYPE CODE
LSH T2,-4 ;GET JUST FLAGS
ANDI T2,7 ;TURN OFF EXTRA BITS
XCT XLOAD(T2) ;GET RESULT STORED BY THE HARDWARE, HAS
;CORRECT FRACTION AND EXPONENT TOO LARGE
;BY 400
PUSH P,T1 ;SAVE T1
HLRE T1,T2 ;GET EXPONENT AND SIGN AND SOME FRACTION BITS
ASH T1,-9 ;GET RID OF FRACTION BITS
TSCE T1,T1 ;GET ABS(EXPONENT), SKIP IF POSITIVE FRACTION
TLOA T2,777000 ;NEGATIVE FRACTION, SET EXPONENT TO ALL ONES
TLZ T2,777000 ;POSITIVE FRACTION, SET EXPONENT TO ALL ZEROS
CAME T1,[377,,377] ;SUPPRESS ZERO-BIT SHIFT (-0 IS -256)
ASHC T2,400001(T1) ;UNNORMALIZE FRACTION, KEEP 1 BIT FOR ROUNDING
POP P,T1 ;GET FLAG BITS BACK
TRNE T1,DPBIT ;WAS TRAP INSTRUCTION DOUBLE PRECISION?
JRST DROUND ;YES, GO ROUND DP NUMBER
ADDI T2,1 ;ROUND HIGH WORD OF FRACTION
ASH T2,-1 ;DISCARD ROUNDING BIT
JRST STRET ;DONE
DROUND: TLO T3,(1B0) ;PREVENT INTEGER OVERFLOW WHEN WE ROUND
ADDI T3,1 ;ROUND LOW WORD
TLZN T3,(1B0) ;DID FRACTION OVERFLOW INTO SIGN BIT?
ADDI T2,1 ;YES, PROPAGATE CARRY TO HIGH WORD
ASHC T2,-1 ;DISCARD ROUNDING BIT
JRST STRET ;DONE
> ;END REPEAT 0
;HERE ON FLOATING & INTEGER OVERFLOW AND DIVIDE CHECK
OV: TLNE T0,(PC%NDV) ;NO DIVIDE?
JRST DIVCHK ;YES. CHECK FOR 0/0
TLNN T0,(PC%FOV) ;NO. FLOATING OVERFLOW?
JRST INTRET ;NO. INTEGER FIXUP IS DANGEROUS
JRST NDVCHK ;YES. GO ON WITH FIXUP
DIVCHK: SKIPE @AC ;DIVIDE BY ZERO. ZERO DIVIDEND?
JRST NDVCHK ;NO.
SETZB T2,T3 ;SET FIXED-UP VALUE TO 0
JRST STRET
NDVCHK: TRNN T1,ACBIT ;DID INST STORE ITS RESULT IN THE AC?
TLNE T0,(PC%NDV) ;YES, NO-DIVIDE, WHICH STORES NO RESULT?
SKIPA T2,@AC ;NO, GET RESULT FROM AC
MOVE T2,@E ;ELSE GET RESULT FROM E
TRZE T1,WRONGBIT ;DID INST STORE WRONG SIGN?
TLC T2,(1B0) ;YES, SET CORRECT SIGN
JUMPL T2,NEGOV ;IF CORRECT ANSWER NEGATIVE, GO SET -INF
DMOVE T2,[OCT 377777777777,377777777777] ;GET +INFINITY
JRST STRET
NEGOV: TLNN T0,(PC%FOV) ;FLOATING OVERFLOW?
JRST INTOV ;NO, USE INTEGER -INFINITY
MOVN T2,[OCT 377777777777] ;FLOATING, GET FLOATING -INFINITY
TRNE T1,DPBIT ;WAS INSTRUCTION DOUBLE PRECISION?
DMOVN T2,[OCT 377777777777,377777777777] ;YES, GET IT IN DP
JRST STRET ;GO STORE RESULT AND RETURN
INTOV: DMOVE T2,[OCT 400000000000,0] ;GET INTEGER -INFINITY
;[3122]CALL TCALU, WHICH IF THE INSTRUCTION FOLLOWING THE TRAPPED
;INSTRUCTION IS NOT A JFCL, ISSUES THE ERROR MESSAGE (IF NOT OVER THE
;MESSAGE LIMIT) AND CALLS THE USER-SPECIFIED TRAP SUBROUTINE (IF ANY);
;THEN USE THE RETURNED VALUE OF %FIXED (WHICH WILL BE UNTOUCHED IF
;THE USER DOESN'T DO ANYTHING TO IT).
STRET: DMOVEM T2,%FIXED ;STORE FIXED RESULT
PUSHJ P,TCALU ;CALL USER TRAP ROUTINE
DMOVE T2,%FIXED ;GET FIXED RESULT
LSH T1,-4 ;TOSS DATA TYPE, JUST GET FLAGS
ANDI T1,7 ;TURN OFF EXTRA BITS
XCT XSTORE(T1) ;STORE ANSWER
;RESTORE SOME ACS, CLEAR THE PC FLAGS
XRET: DMOVE T2,ACS+T2 ;RESTORE T2-T3
MOVSI T1,(PC%OVF+PC%FOV+PC%FUF+PC%NDV) ;CLEAR OV, FOV, FUF, NDV
ANDCAB T1,FLGS
SETZM %TRFLG ;WE ARE NO LONGER IN A TRAP
HLLZ T0,PC ;GET LH OF PC+1 OF TRAPPED INST
JUMPE T0,XRET0 ;NOT AN EXTENDED ADDRESSING TRAP
DMOVE T0,ACS ;RESTORE T0-T1
XJRSTF FLGS ;Return to user.
XRET0: HLLM T1,PC ;STORE FLAGS FOR JRSTF
DMOVE T0,ACS ;RESTORE T0-T1
JRSTF @PC
;INTEGER OVERFLOW RETURN - CALL TCALU TO ISSUE THE ERROR MSG AND
;CALL THE USER-SPECIFIED ROUTINE, BUT DO NOT USE THE FIXED-UP RESULT.
INTRET: SETZM %FIXED ;SET FIXED-UP VALUE TO 0
SETZM %FIXED+1
PUSHJ P,TCALU ;CALL USER ROUTINE
JRST XRET ;DON'T USE FIXED-UP VALUE
;[3122] IF THE INST AFTER THE TRAP IS A JFCL WITH NO FLAGS, PROCEED TO DO
;THE STANDARD FORTRAN FIXUP. OTHERWISE, PRINT A MESSAGE AND
;CALL A USER TRAP ROUTINE VIA $TCALL.
TCALU: MOVE T0,@PC ;GET INSTRUCTION AFTER TRAP
TLC T0,(JFCL) ;SEE IF IT'S JFCL
TLNN T0,777000 ;IS IT?
JRST NOCALU ;YES. DON'T PRINT MSG OR CALL USER
MOVEI T2,(T1) ;GET FLAGS AGAIN
ANDI T2,17 ;GET VARIABLE TYPE
MOVEM T2,%ERTYP ;SAVE FOR USER CALL
SETZ T2, ;CREATE AN INDEX
MOVE T0,FLGS ;TESTING THE FLAGS
TLNE T0,(PC%NDV) ;NO-DIVIDE?
TRO T2,1 ;YES
TLNE T0,(PC%FUF) ;FLOATING UNDERFLOW?
TRO T2,2 ;YES
TLNE T0,(PC%FOV) ;FLOATING OVERFLOW?
TRO T2,4 ;YES
XCT TCALTB(T2) ;DO MESSAGE CALL
POPJ P,
NOCALU: TRNE T0,-1 ;ADDR IN JCFL?
HRRM T0,PC ;YES. RETURN TO THAT ADDR
POPJ P,
SEGMENT DATA
IF20,<
;SWTRP BLOCK, FILLED IN BY MONITOR OR MICROCODE ON OVERFLOW TRAP
LTRAP: ;NON-FUNCTIONAL. HERE FOR COMPATIBILITY
TRPBLK:
FLGS: ;LH = PC FLAGS
INST: BLOCK 1 ;RH = LH(TRAP INSTRUCTION)
PC: BLOCK 1 ;PC+1 OF TRAP INSTRUCTION
E: BLOCK 1 ;E OF TRAP INSTRUCTION
NPC: BLOCK 1 ;NEW PC TO USE AT TRAP
>;END IF20
IF10,<
TRPBLK:
LTRAP: BLOCK 2 ;JSR HERE ON OVERFLOW
FLGS:
INST: BLOCK 1 ;RH = LH(TRAP INSTRUCTION)
PC: BLOCK 1 ;PC+1 OF TRAP INSTRUCTION
E: BLOCK 1 ;ITS EFFECTIVE ADDRESS
>;END IF10
MSECT: BLOCK 1 ;SECTION NUMBER OF TRAP HANDLER
INDADR: BLOCK 1 ;TRAPPED INST IND,IDX,E IN EFIW FORMAT
INDTMP: BLOCK 1 ;TEMP INDIRECT AND INDEX OF TRAPPED INST
AC: BLOCK 1 ;AC FIELD OF TRAP INSTRUCTION
ACS: BLOCK 4 ;TEMP SPACE FOR T0-T3
SEGMENT CODE
;FLAG BITS FOR EVERY INSTRUCTION THAT CAN OVERFLOW
;[3122] EXPANDED THE FLAG BYTE FOR EACH INSTRUCTION TO 9 BITS,
;TO ALLOW FOR THE VARIABLE TYPE CODE AND FOR A NEW BIT, NOT YET
;IMPLEMENTED, FOR THE AOS/SOS-CLASS INSTRUCTIONS, WHICH LEAVE
;THE RESULT IN MEMORY AND AN AC IF A NON-ZERO AC IS SPECIFIED.
;THIS IS NOT A PROBLEM FOR THE CURRENT PROCESSORS, SINCE INTEGER
;FIXUPS CANNOT BE DONE RELIABLY (SEE NOTES AT BEGINNING OF MODULE).
DPBIT==1*20 ;1 IF INST STORES 2-WORD RESULT
ACBIT==2*20 ;1 IF INST STORES RESULT IN AC
MEMBIT==4*20 ;1 IF INST STORES RESULT IN MEMORY
WRONGBIT==10*20 ;1 IF INST STORES RESULT WITH WRONG SIGN,
; FOR EXTEND MEANS RESULT NOT STORED IN AC
BOTHBT==ACBIT+MEMBIT ;RESULT STORED IN BOTH AC AND MEMORY
NZACBT==4*20 ;1 IF INST STORES RESULT IN BOTH IF AC NONZERO
;NOT HANDLED, AS INTEGER OVERFLOWS AREN'T FIXED
SPRA==TP%SPR+ACBIT ;SINGLE PRECISION REAL, RESULT IN AC
SPRM==TP%SPR+MEMBIT ;SINGLE REAL, RESULT IN MEMORY
SPRB==TP%SPR+BOTHBT ;SINGLE REAL, RESULT IN BOTH
INTA==TP%INT+ACBIT ;INTEGER, RESULT IN AC
INTM==TP%INT+MEMBIT ;INTEGER, RESULT IN MEMORY
INTB==TP%INT+BOTHBT ;INTEGER, RESULT IN BOTH
DPIA==TP%DPI+ACBIT+DPBIT ;DOUBLE INTEGER, RESULT IN AC
DPIM==TP%DPI+MEMBIT+DPBIT ;DOUBLE INTEGER, RESULT IN MEMORY
DPIB==TP%DPI+BOTHBT+DPBIT ;DOUBLE INTEGER, RESULT IN BOTH
DPRA==TP%DPR+ACBIT+DPBIT ;DOUBLE REAL, RESULT IN AC
DPRM==TP%DPR+MEMBIT+DPBIT ;DOUBLE REAL, RESULT IN MEMORY
DPRB==TP%DPR+BOTHBT+DPBIT ;DOUBLE REAL, RESULT IN BOTH
DPXA==TP%DPX+ACBIT+DPBIT ;GDOUBLE REAL, RESULT IN AC
DPXM==TP%DPX+MEMBIT+DPBIT ;GDOUBLE REAL, RESULT IN MEMORY
DPXB==TP%DPX+BOTHBT+DPBIT ;GDOUBLE REAL, RESULT IN BOTH
SPRAW==SPRA+WRONGBIT ;SPRA, RESULT HAS WRONG SIGN
SPRMW==SPRM+WRONGBIT ;SPRM, RESULT HAS WRONG SIGN
SPRBW==SPRB+WRONGBIT ;SPRB, RESULT HAS WRONG SIGN
INTAW==INTA+WRONGBIT ;INTA, RESULT HAS WRONG SIGN
INTMW==INTM+WRONGBIT ;INTM, RESULT HAS WRONG SIGN
INTBW==INTB+WRONGBIT ;INTB, RESULT HAS WRONG SIGN
INTNW==TP%INT+WRONGBIT+NZACBT ;INTEGER, WRONG SIGN, RESULT IN
;BOTH IF NON-ZERO AC
DPIAW==DPIA+WRONGBIT ;DPIA, RESULT HAS WRONG SIGN
DPIMW==DPIM+WRONGBIT ;DPIM, RESULT HAS WRONG SIGN
DPIBW==DPIB+WRONGBIT ;DPIB, RESULT HAS WRONG SIGN
DPRAW==DPRA+WRONGBIT ;DPRA, RESULT HAS WRONG SIGN
DPRMW==DPRM+WRONGBIT ;DPRM, RESULT HAS WRONG SIGN
DPRBW==DPRB+WRONGBIT ;DPRB, RESULT HAS WRONG SIGN
DPXAW==DPXA+WRONGBIT ;DPXA, RESULT HAS WRONG SIGN
DPXMW==DPXM+WRONGBIT ;DPXM, RESULT HAS WRONG SIGN
DPXBW==DPXB+WRONGBIT ;DPXB, RESULT HAS WRONG SIGN
SP==1 ;SPECIAL CASE, NOT COVERED ABOVE
NOBIT==0 ;NO BITS
BITS: BYTE (9) NOBIT, NOBIT, DPXA, DPXA ;OPCODE 100 UJEN-GFSB
BYTE (9) NOBIT, NOBIT, DPXA, DPXA ; 104 JSYS-GFDV
BYTE (9) DPRA, DPRA, DPRA, DPRA ; 110 DFAD-DFDV
BYTE (9) DPIAW, DPIAW, DPIAW, DPIA ; 114 DADD-DDIV
BYTE (9) NOBIT, DPIAW, SP, SP ; 120 DMOVE-EXTEND
BYTE (9) NOBIT, DPIMW, SP, NOBIT ; 124 DMOVEM-FLTR
BYTE (9) SPRA, NOBIT, SPRA, INTA ; 130 UFA-ADJBP
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 134 ILDB-DPB
BYTE (9) SPRA, SPRA, SPRM, SPRB ; 140 FAD-FADB
BYTE (9) SPRA, SPRA, SPRM, SPRB ; 144 FADR-FADRB
BYTE (9) SPRA, SPRA, SPRM, SPRB ; 150 FSB-FSBB
BYTE (9) SPRA, SPRA, SPRM, SPRB ; 154 FSBR-FSBRB
BYTE (9) SPRA, SPRA, SPRM, SPRB ; 160 FMP-FMPB
BYTE (9) SPRA, SPRA, SPRM, SPRB ; 164 FMPR-FMPRB
BYTE (9) SPRA, SPRA, SPRM, SPRB ; 170 FDV-FDVB
BYTE (9) SPRA, SPRA, SPRM, SPRB ; 174 FDVR-FDVRB
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 200 MOVE-MOVES
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 204 MOVS-MOVSS
BYTE (9) INTAW, NOBIT, INTMW, INTMW ; 210 MOVN-MOVNS
BYTE (9) INTAW, NOBIT, INTMW, INTMW ; 214 MOVM-MOVMS
BYTE (9) INTA, INTA, INTM, INTB ; 220 IMUL-IMULB
BYTE (9) DPIA, DPIA, DPIM, DPIB ; 224 MUL-MULB
BYTE (9) INTA, INTA, INTM, INTB ; 230 IDIV-IDIVB
BYTE (9) DPIA, DPIA, DPIM, DPIB ; 234 DIV-DIVB
BYTE (9) INTA, NOBIT, NOBIT, NOBIT ; 240 ASH-JFFO
BYTE (9) INTA, NOBIT, NOBIT, NOBIT ; 244 ASHC-NONE
BYTE (9) NOBIT, NOBIT, INTA, INTA ; 250 EXCH-AOBJN
BYTE (9) NOBIT, NOBIT, SP, NOBIT ; 254 JRST-MAP
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 260 PUSHJ-POPJ
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 264 JSR-JRA
BYTE (9) INTAW, INTAW, INTMW, INTBW ; 270 ADD-ADDB
BYTE (9) INTAW, INTAW, INTMW, INTBW ; 274 SUB-SUBB
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 300 CAI-CAILE
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 304 CAIA-CAIG
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 310 CAM-CAMG
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 314 CAMA-CAMGE
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 320 JUMP-JUMPLE
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 324 JUMPA-JUMPG
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 330 SKIP-SKIPLE
BYTE (9) NOBIT, NOBIT, NOBIT, NOBIT ; 334 SKIPA-SKIPG
BYTE (9) INTAW, INTAW, INTAW, INTAW ; 340 AOJ-AOJLE
BYTE (9) INTAW, INTAW, INTAW, INTAW ; 344 AOJA-AOJG
BYTE (9) INTNW, INTNW, INTNW, INTNW ; 350 AOS-AOSLE
BYTE (9) INTNW, INTNW, INTNW, INTNW ; 354 AOSA-AOSG
BYTE (9) INTAW, INTAW, INTAW, INTAW ; 360 SOJ-SOJLE
BYTE (9) INTAW, INTAW, INTAW, INTAW ; 364 SOJA-SOJG
BYTE (9) INTNW, INTNW, INTNW, INTNW ; 370 SOS-SOSLE
BYTE (9) INTNW, INTNW, INTNW, INTNW ; 374 SOSA-SOSG
BYTE (9) NOBIT, SPRAW, NOBIT, DPIAW ;EXTEND 020 XBLT-DGFIX
BYTE (9) INTAW, DPIAW, INTAW, NOBIT ;EXTEND 024 GFIX-DGFLTR
BYTE (9) NOBIT, DPXA, NOBIT, NOBIT ;EXTEND 030 GFLTR,GFSC
BPTAB: POINT 9,BITS-20(T1),8 ;BYTE POINTERS, OFFSET BY 100 OCTAL
POINT 9,BITS-20(T1),17
POINT 9,BITS-20(T1),26
POINT 9,BITS-20(T1),35
;TABLES INDEXED BY T1 (WITH FLAG BITS IN IT) TO ACCESS INSTRUCTION OPERANDS
XLOAD=.-2
MOVE T2,@AC ;SA
DMOVE T2,@AC ;DA
MOVE T2,@E ;SM
DMOVE T2,@E ;DM
MOVE T2,@AC ;SB
DMOVE T2,@AC ;DB
XSTORE=.-2
MOVEM T2,@AC ;SA
DMOVEM T2,@AC ;DA
MOVEM T2,@E ;SM
DMOVEM T2,@E ;DM
PUSHJ P,[MOVEM T2,@AC ;SB
MOVEM T2,@E
POPJ P,]
PUSHJ P,[DMOVEM T2,@AC ;DB
DMOVEM T2,@E
POPJ P,]
;TRAP MESSAGE CALL EXECUTE TABLE
TCALTB: $TCALL IOV
$TCALL IDC
NOP
NOP
$TCALL FOV
$TCALL FDC
$TCALL FUN
NOP
;TRAP ERROR MESSAGES
SEGMENT CODE
$TERR (%,IOV,0,0,Integer overflow) ;000
$TERR (%,IDC,1,0,Integer divide check) ;001 NDV
; $TERR (%,XXX,2,0,Floating underflow) ;010 FXU (impossible)
; $TERR (%,XXX,3,0,Floating divide check) ;011 FXU,NDV (impossible)
$TERR (%,FOV,4,0,Floating overflow) ;100 FXO
$TERR (%,FDC,5,0,Floating divide check) ;101 FXO,NDV
$TERR (%,FUN,6,0,Floating underflow) ;110 FXO,FXU
; $TERR (%,XXX,7,0,Floating divide check) ;111 FXO,FXU,NDV (impossible)
$TERR (?,TDT,-1,0,Trap occured during trap processing)
END