Trailing-Edge
-
PDP-10 Archives
-
BB-D480C-SB_1981
-
opgnta.mac
There are 12 other files named opgnta.mac in the archive. Click here to see a list.
TITLE OPGNTA - CODE GENERATION TABLES FOR FORTRAN-10
SUBTTL S. MURPHY/SRM/HPW/DCE/RDH/TFV/RVM 15-Oct-81
;THIS SOFTWARE IS FURNISHED UNDER A LICENSE AND MAY ONLY BE USED
; OR COPIED IN ACCORDANCE WITH THE TERMS OF SUCH LICENSE.
;COPYRIGHT (C) 1972,1981 BY DIGITAL EQUIPMENT CORPORATION
; Authors: S. MURPHY/SRM/HPW/DCE/RDH/TFV
INTERN OPGNTV
OPGNTV= BYTE (3)0(9)6(6)0(18)^D127 ; Version Date: 15-Oct-81
SUBTTL Revision History
Comment \
***** Revision History *****
113 ----- ----- ADD GENERATORS FOR DABS IN LINE
114 ----- ----- ADD GENERATORS FOR EXPONENTATION IN LINE
115 ----- ----- TREAT "NEG-SAME-IMMED" (UNDER OPGETA,OPGETI)
THE SAME AS "NEG-IMMED"
116 ----- ----- ADD GENERATORS FOR EXPONEN TO MEMORY IN LINE
117 ----- ----- REMOVE GENERATORS FOR SQUARE,CUBE,P4 (THEY
ARE NOW PART OF "EXPCIOP")
118 ----- ----- ADD GENERATORS FOR IN LINE DP EXPONEN AND
FOR IN LINE EXPONEN OF AN IMMEDIATE LOOP INDEX
119 264 15974 FIX KI COMPLEX DIVIDE TO MEMORY, (JNT)
***** Begin Version 5A *****
120 611 23662 MULTIPLY OF COMPLEX CONSTANT BY POWER OF TWO
PLUS 1 IS NOT IMPLEMENTED., (DCE)
***** Begin Version 5B *****
121 677 25573 ADD TABLES FOR PARAMETER CHECKING., (DCE)
***** Begin Version 6 *****
122 750 TFV 1-Jan-80 ------
Remove Debug:Parameter switch (edit 677)
123 761 TFV 1-Mar-80 -----
Rework tables to handle /GFLOATING
Remove all KA ops
127 1135 RVM 15-Oct-81
Make conversion from DOUBLE PRECISION to COMPLEX do rounding.
***** End Revision History *****
\
SUBTTL CODE GENERATORS
;
;[761] Get definitions of GFAD, GFSB, GFMP, GFDV
SEARCH GFOPDF ;[761] OPDEFS FOR GFLOATING INSTRUCTIONS
HISEG
INTERN OPGETI ;base of get arg into a reg
INTERN OPGSET ;BASE OF TABLE FOR INITIALIZATION
; OF LOGICAL VALS
INTERN OPGARI ;BASE OF TABLE FOR ARITH OPS, KI10
INTERN OPGARG ;[761] BASE OF TABLE FOR ARITH OPS, gfloating
INTERN OPGTCG ;[761] BASE OF TABLE FOR TYPE-CONVERSIONS, gfloating
INTERN OPGTCI ;BASE OF TABLE FOR TYPE-CONVERSIONS ON KI10
INTERN OPGSTI ;BASE OF TABLE FOR "STORE" - KI10
INTERN OPGASI ;BASE OF TABLE FOR ASSIGNMENT STMNT-KI10
INTERN OPGASR ; SPECIAL CASE FOR ASSIGNMENT OF RIGHT HALF
; OF AOBJN WD
INTERN OPASIN ;TABLE FOR ASSIGN STMNT
INTERN OPGBOO ;BASE OF TABLE FOR BOOLEAN OPS
INTERN OPGREL ;BASE OF TABLE FOR RELATIONALS
INTERN OPGSPG ;[761] base of table for p2mul, p2pl1mul
; for gfloating
INTERN OPGILF ;BASE OF TABLE FOR IN-LINE-FNS (WHEN
; THE ARG IS ALREADY IN REGFORCOMP)
INTERN OPGILI ; (WHEN ARG1 IS REGFORCOMP,ARG2 IS IMMED)
INTERN OPGIL1 ;BASE OF TABLES FOR IN-LINE-FNS WHEN
; ARG IS NOT IN REGFORCOMP: ABS AND SIGN
INTERN OPGN1I ;base of table for neg when in rfc
INTERN OPGN2I ;BASE OF TABLE FOR NEG WHEN ARG NOT IN RFC
INTERN OPGSPI ;BASE OF TABLE FOR P2MUL,P2PL1MUL -
; KI10
INTERN OPGSPM ;BASE OF TABLE FOR P2MUL ETC DONE TO MEMORY
INTERN OPGSTC ;BASE OF TABLE FOR A "STORECLS" NODE
INTERN OPGSTD ;BASE OF TABLE FOR "STORECLS"- DOUBL-P
INTERN OPGVTS ;BASE OF TABLE FOR TRANSFER OF CONTROL
; ON A GIVEN VAL OF A GIVEN VAR
INTERN OPGALT ;BASE OF TABLE FOR TRANSFER OF CONTROL
; TO ONE LABEL IF A GIVEN VAR IS TRUE
; AND TO ANOTHER IF IT IS FALSE
INTERN OPGAIF ;BASE OF TABLE FOR ARITH-IF STMNTS IN WHICH
; THE VAL MUST BE COMPUTED AND TESTED
INTERN OPGCGO ;BASE OF TABLE FOR COMPUTED GOTO
INTERN OPGCGI ; FOR COMPUTED GOTO WHEN THE VAR IS IN THE
; RIGHT HALF OF A REG CONTAINING DO-LOOP CTL
INTERN OPGIOL ;TO GENERATE A CALL TO IOLST.
INTERN OPGMTO ; TO MTOP.
INTERN OPGIN ; TO IN.
INTERN OPGENC ; TO ENC.
INTERN OPGDEC ; TO DEC.
INTERN OPGOUT ; TO OUT.
INTERN OPGWTB ; TO WTB.
INTERN OPGRTB ; TO RTB.
INTERN OPGNLI ; TO NLI.
INTERN OPGNLO ; TO NLO.
INTERN OPGOPE ; TO OPEN.
INTERN OPGFND ; TO FIND.
INTERN OPGRLS ; TO RELEAS.
INTERN OPGCLO ; TO CLOS.
INTERN OPGLIB ; TO MATH LIBRARY FUNCTION
INTERN OPGADJ ; TO ADJ.
INTERN OPGPAU ;ENTRY TO GENERATE CODE FOR PAUSE
INTERN OPGSTP ;ENTRY TO GENERATE CODE FOR STOP
INTERN OPGEXI ;ENTRY TO GENERATE CODE FOR THE EXIT AT END
; OF A MAIN PROGRAM
INTERN OPGRES ; TO GENERATE CODE FOR CALL TO RESET
INTERN OPGFIN ; TO GENERATE CALL TO FOROTS FIN.
INTERN OPP21I ; MULTIPLY IMMED MODE BY POWER OF 2+1
INTERN OPGPHR ; TO PUSH REGS FOR REG SAVE FOR SFN
INTERN OPGPPR ; TO POP REGS FOR REG RESTORE FOR SFN
INTERN OPGDBF ; TO GENERATE DABS IN LINE WHEN ARG IN
; REGFORCOMP
INTERN OPGDB1 ; TO GENERATE DABS IN LINE WHEN ARG NOT
; IN REGFORCOMP
INTERN OPGEX ; TO GENERATE EXPONENTATION IN LINE
INTERN OPGEXS ; to self
INTERN OPGEXM ; to memory
INTERN OPGXPI ; AOBJN
INTERN OPGXG ;[761] EXPONENTIATION IN LINE, GFLOATING
INTERN OPGXGS ;[761] TO SELF
INTERN OPGXGM ;[761] TO MEMORY
;
;DEFINE THE CODE GENERATION TABLES AND DISPATCH TABLE
;
;ELEMENTS IN THE DISPATCH TABLE ARE AOBJN PTRS TO THE PIECE OF CODE
; TO BE GENERATED OR EITHER OF THE FLAGS
; ILG - FOR ILLEGAL ENTRY (EG THE ENTRY FOR A1SAMEFLG AND
; A1IMMEDFLG BOTH SET
; IGN - FOR NO CODE NEED BE GENERATED FOR THIS NODE
;
IGN=0
ILG=1
;
;DEFINE CODE GENERATORS FOR EACH OPERATION
;EACH WORD OF CODE TO BE GENERATED IS REPRESENTED BY A 2 WD ENTRY
; L.H. OF WD 0 - SPECIFIES WHETHER TO ADD A SPECIFIED "REG FOR
; COMP" INTO THE REG FIELD OF THE PATTERN WD
; R.H. OF WD 0 - SPECIFIES WHERE TO GET THE "MEMREF" FIELD (BITS
; 13-36) OF THE INSTRUCTION FROM
; WD 1 - PATTERN FOR INSTRUCTION TO BE GENERATED
;
;DEFINE POSSIBLE VALS FOR LEFT AND RIGHT HALVES OF WD 0
FRPTN=0 ;FROM PATTERN WD
FRRFC=1 ;FROM "REGFORCOMP"
IMFN=2 ;USE THE IMPLICIT-FN-NAME PTED TO BY TREEPTR
WD1IMF=3 ;USE THE IMPLICIT-FN NAME POINTED TO
; BY THE RH OF THE PATTERN WD
RGIMFN=4 ;USE THE IMPLICIT FN NAME POINTED TO BY
; THE RH OF THE PATTERN WD INDEXED BY
; THE "REGFORCOMP" (IE DIFFERENT
; LIBRARY ROUTINES ARE CALLED DEPENDING
; ON WHICH REG THE ARG IS IN)
A1CNST=5 ;ARG1 IMMED CNST
A2CNST=6 ;ARG2 IMMED CNST
A1CNNG=7 ;USE NEG OF IMMED CNST ARG1
A2CNNG=10 ;USE NEG OF IMMED CNST ARG2
PTRA2=11 ;USE ARG2PTR FIELD OF PARENT
NGPTR2=12 ;USE THE NEGATIVE OF THE ARG2PTR FIELD OF
; PARENT
P2PTR2=13 ;USE 2**(VAL OF ARG2PTR)-1 (USED FOR
; P2DIV)
A1LAB=14 ;USE THE LABEL INDICATED BY A1LABEL
A2LAB=15 ;USE THE LABEL INDICATEC BY A2LABEL
A3LAB=16 ;USE THE LABEL INDICATED BY A3LABEL
FROMC1=17 ;USE THE CONTENTS OF THE GLOBAL C1H,
; THIS ADDRESS FIELD WILL HAVE NO
; SYMBOLIC REPRESENTATION
PARTMP=20 ;USE THE TMP INDICATED BY THE TARGET
; OF PARENT (IGNORE INDIRECT AND INDEX
; BITS IN THE TARGET)
FROMA1=21 ;USE TARGET FIELD OF ARG1
FROMA2=22 ;USE TARGET FIELD OF ARG2
FROMPA=23 ;USE TARGET FIELD OF PARENT (TREEPTR)
;
;
;
;DISPATCH TABLE FOR 'GET ARG INTO A REG' -
;TO GENERATE CODE FOR THE KI10
OPGETI: -1,,GA ;NO FLAGS, SINGLE PREC
-1,,GA
-1,,GA2KI ;NO FLAGS, DOUBLEPREC,
-1,,GA2KI ;NO FLAGS, COMPLEX
-1,,GAIMI ;IMMED - INTEGER
-1,,GAIMRL ;IMMED - REAL
-2,,GAIM2 ;IMMED, DOUBL-PREC - RARELY GENERATED
-2,,GAIM2 ;IMMED COMPLEX
IGN ;IGNORE (ARG SAMEFLG SET)
IGN
IGN
IGN
IGN ;ARG SAME AND ARG IMMED FLAGS WILL BOTH BE
; SET WHEN A REGCONTENTS WHICH IS LOOP CTL VAR
; IS AN ARG UNDER A RELATIONAL (IGNORE)
IGN
IGN
IGN
-1,,GANG ;NEG OF ARG
-1,,GANG
-1,,GANG2I ;NEG OF DOUBLE-WD ARG -
-2,,GNGCM ;NEG OF COMPLEX ARG
-1,,GNGIMI ;NEG OF IMMED CNST - INTEGER
-1,,GNGIMR ;NEG OF IMMED CNST - REAL
-2,,GNGIM2 ;NEG OF IMMED DOUBLE-WD
-2,,GNGIM2
-1,,GANGSM ;NEG OF VAL ALREADY IN DESIRED REG
-1,,GANGSM
-1,,GNGS2I ;NEG OF DOUBLE-WD ARG ALREADY IN DESIRED
; REG
-2,,GNGSCM ;NEG OF COMPLEX ARG ALREADY IN DESIRED
; REG
;SAME-IMMED NEGATED - TREAT AS IMMED NEGATED (IGNORE
; THE "SAMEFLG") - OCCURS WHEN BB ALLOCATOR HAS FOUND
; AN IMMED CNST THAT WAS LEFT IN A REG AND THEN
; LATER A NEGFLG WAS MOVED OVER THAT CNST IN CGETVAL
-1,,GNGIMI ;NEG OF IMMED CNST - INTEGER
-1,,GNGIMR ;NEG OF IMMED CNST - REAL
-2,,GNGIM2 ;NEG OF IMMED DOUBLE-WD
-2,,GNGIM2
-1,,GANT ;NOT OF ARG
-1,,GANT
-2,,GANT2 ;NOT OF DOUBLE-WD ARG
-2,,GANT2
-1,,GNTIMI ;NOT OF IMMED CNST - INTEGER
ILG ;NOT OF IMMED CNST - REAL
ILG ;NOT OF IMMED, DOUBLE-WD
ILG
-1,,GANTSM ;NOT OF VAL ALREADY IN THE DESIRED REG
-1,,GANTSM
-2,,GNTS2 ;NOT OF DOUBLE-WD ARG -
-2,,GNTS2
;NOTE THAT ALL "GETA1OPIX" VALS ABOVE THIS PT ARE ILLEGAL
; (INVOLVING EITHER BOTH NEG AND NOT OR SAME AND IMMED)
;
;
;
;DEFINE CODE GENERATORS FOR GETTING ARG1 INTO A REG
;
;
GA=. ;GET ARG INTO REG
;
FRRFC,,FROMA1
MOVE 0,0
;
;
;
;
GA2KI=. ;DOUBLE-PREC KI
FRRFC,,FROMA1
DMOVE 0,0
;
;GET IMMED ARGS
GAIMI=. ;IMMED - INTEGER
FRRFC,,A1CNST
MOVEI 0,0
;
GAIMRL=. ;IMMED - REAL
GAIM2=. ;IMMED DOUBLE-WD (next 2 instrs)
FRRFC,,A1CNST
MOVSI 0,0
;
FRRFC,,FRPTN
MOVEI 1,0
;
;
; GET NOT OF ARG
;
GANT=. ;GET NOT OF ARG
FRRFC,,FROMA1
SETCM 0,0
;
GANT2=. ;GET NOT OF DOUBLE-PREC ARG (next 2 instrs)
FRRFC,,FROMA1
SETCM 0,0
FRRFC,,FROMA1
SETCM 1,1
;
GNTIMI=. ;NOT OF AN IMMED CNST - INTEGER
FRRFC,,A1CNST
SETCMI 0,0
;
;
;
GANTSM=. ;NOT OF AN ARG ALREADY IN DESIRED REG
GNTS2=. ; NOT OF A DOUBLE-WD ARG ALREADY IN
; DESIRED REG (next 2 instrs)
FRRFC,,FRPTN
SETCA 0,0
;
FRRFC,,FRPTN
SETCA 1,0
;
;
;GET NEG ARG
;
GANG=. ;NEG OF ARG
GNGCM=. ;NEG OF A COMPLEX ARG (next 2 instrs)
FRRFC,,FROMA1
MOVN 0,0
;
FRRFC,,FROMA1
MOVN 1,1
;
;
GANG2I=. ;NEG OF DOUBLE-WD ARG FOR KI10
FRRFC,,FROMA1
DMOVN 0,0
;
;
GNGIMI=. ;NEG OF AN IMMED ARG - INTEGER
FRRFC,,A1CNST
MOVNI 0,0
;
GNGIMR=. ;NEG OF AN IMMED ARG - REAL
GNGIM2=. ;NEG OF AN IMMED ARG - DOUBLE-WD (next 2 instrs)
FRRFC,,A1CNNG
MOVSI 0,0
;
FRRFC,,FRPTN
MOVEI 1,0
;
;
;
GANGSM=. ;NEG OF ARG ALREADY IN DESIRED REG
GNGSCM=. ;NEG OF COMPLEX ARG ALREADY IN SAME REG (next 2 instrs)
FRRFC,,FRRFC
MOVN 0,0
;
FRRFC,,FRRFC
MOVN 1,1
;
;
;
;
GNGS2I=. ;NEG OF DOUBLE-WD ARG ALREADY IN REG
; FOR KI10
FRRFC,,FRRFC
DMOVN 0,0
;
;
;
;TABLE FOR CODE GENERATION FOR INITIALIZATION OF LOGICAL VALUES
;
OPGSET: -1,,FLSMEM ;SET MEM LOC FALSE
-1,,FLSREG ;SET REG FALSE
-1,,TRMEM ;SET MEM LOC TRUE
-1,,TRREG ;SET REG TRUE
;
; CODE GENERATORS FOR LOGICAL INIT
FLSMEM=.
FRPTN,,FROMPA
SETZM 0,0
;
FLSREG=.
FRRFC,,FRPTN
SETZ 0,0
;
TRMEM=.
FRPTN,,FROMPA
SETOM 0,0
;
TRREG=.
FRRFC,,FRPTN
SETO 0,0
;
;
;TABLE FOR CODE GENERATORS FOR EXPONENTIATION IN LINE
;
;FOR KI/KL
OPGEX: -1,,OPGEX1 ;INTEGER MULTIPLY BY MEMORY
-1,,OPGEX2 ;REAL MULTIPLY BY MEMORY
-1,,OPGEX7 ;DP MULTIIPLY BY MEMORY
ILG ;(COMPLEX EXPONEN NOT DONE IN LINE)
OPGEXS: -1,,OPGEX3 ;INTEGER MULTIPLY BY SELF
-1,,OPGEX4 ;REAL MULTIPLY BY SELF
-1,,OPGEX8 ;DP MULTIPLY BY SELF
ILG ;(COMPLEX EXPONEN NOT DONE IN LINE)
OPGEXM: -1,,OPGEX5 ;INTEGER MUL TO MEMORY
-1,,OPGEX6 ;REAL MULTIPLY TO MEMORY
ILG ;DP IS NEVER DONE TO MEMORY
ILG ;COMPLEX EXPONEN NOT DONE IN LINE
;
;[761] FOR GFLOATING
OPGXG: -1,,OPGEX1 ;INTEGER MULTIPLY BY MEMORY
-1,,OPGEX2 ;REAL MULTIPLY BY MEMORY
-1,,OPGXG1 ;DP MULTIIPLY BY MEMORY
ILG ;(COMPLEX EXPONEN NOT DONE IN LINE)
OPGXGS: -1,,OPGEX3 ;INTEGER MULTIPLY BY SELF
-1,,OPGEX4 ;REAL MULTIPLY BY SELF
-1,,OPGXG2 ;DP MULTIPLY BY SELF
ILG ;(COMPLEX EXPONEN NOT DONE IN LINE)
OPGXGM: -1,,OPGEX5 ;INTEGER MUL TO MEMORY
-1,,OPGEX6 ;REAL MULTIPLY TO MEMORY
ILG ;DP IS NEVER DONE TO MEMORY
ILG ;COMPLEX EXPONEN NOT DONE IN LINE
;
OPGEX1=.
FRRFC,,FROMA1
IMUL 0,0
;
OPGEX2=.
FRRFC,,FROMA1
FMPR 0,0
;
OPGEX3=.
FRRFC,,FRRFC
IMUL 0,0
;
OPGEX4=.
FRRFC,,FRRFC
FMPR 0,0
;
OPGEX5=.
FRRFC,,FROMA1
IMULM 0,0
;
OPGEX6=.
FRRFC,,FROMA1
FMPRM 0,0
;
OPGEX7=.
FRRFC,,FROMA1
DFMP 0,0 ;DP IS DONE IN LINE FOR KI ONLY
;
OPGEX8=.
FRRFC,,FRRFC
DFMP 0,0
;
OPGXG1=. ;[761]
FRRFC,,FROMA1
GFMP 0,0
;
OPGXG2=. ;[761]
FRRFC,,FRRFC
GFMP 0,0
;
;
; FOR EXPONEN OF AN IMMED LOOP INDEX(IE RIGHT HALF OF AOBJN)
;
OPGXPI: -1,,OPGEX9
;
OPGEX9=.
FRRFC,,A1CNST
IMULI 0,0
;
;TABLE FOR CODE GENERATION FOR ARITH OPERATIONS
;
;FOR KI10
OPGARI: -1,,ADFX
-1,,ADFL
-1,,ADDPKI
-2,,ADCM
-1,,SBFX
-1,,SBFL
-1,,SBDPKI
-2,,SBCM
-1,,MLFX
-1,,MLFL
-1,,MLDPKI
-2,,MLCM
-1,,DVFX
-1,,DVFL
-1,,DVDPKI
-2,,DVCM
; FOR OPERATIONS TO MEMORY
-1,,ADFXM
-1,,ADFLM
-2,,ADDPMI
-2,,ADCMM
-1,,SBFXM
-1,,SBFLM
-2,,SBDPMI
-2,,SBCMM
-1,,MLFXM
-1,,MLFLM
-2,,MLDPMI
-2,,MLCMM
-1,,DVFXM
-1,,DVFLM
-2,,DVDPMI
-2,,DVCMM
; FOR OPERATIONS PERFORMED IMMEDIATE
-1,,ADFXI
-1,,ADFLI
ILG ;DOUBLE-PREC IMMED IS ILLEGAL
-1,,ADCMI
-1,,SBFXI
-1,,SBFLI
ILG ;DOUBLE-PREC IMMED IS ILLEGAL
-1,,SBCMI
-1,,MLFXI
-1,,MLFLI
ILG ;DOUBLE-PREC IMMED IS ILLEGAL
-2,,MLCMI
-1,,DVFXI
-1,,DVFLI
ILG ;DOUBLE-PREC IMMED IS ILLEGAL
-2,,DVCMI
;FOR OPERATIONS TO BOTH (NOTE THAT WE DESIGNATE OP TO BOTH BY SETTING
; BOTH THE "OP TO MEMORY" AND "IMMEDIATE" FLAGS)
-1,,ADFXB ;INTEGER ADD TO BOTH
-1,,ADFLB ;REAL ADD TO BOTH
-2,,ADDPMI ;DP ADD TO BOTH ON KI10 SAME AS DP ADD TO MEM
-2,,ADCMB ;COMPLEX ADD TO BOTH
-1,,SBFXB ;INTEGER SUBTRACT TO BOTH
-1,,SBFLB ;REAL SUBTRACTB TO BOTH
-2,,SBDPMI ;DP SUB TO BOTH ON KI10 SAME AS DP SUB TO MEM
-2,,SBCMB ;COMPLEX SUBTRACT TO BOTH
-1,,MLFXB ;INTEGER MULTIPLY TO BOTH
-1,,MLFLB ;REAL MULTIPLY TO BOTH
-2,,MLDPMI ;DP MUL TO BOTH ON KI10 SAME AS DP MUL TO MEM
ILG ;COMPLEX MULTIPLY TO BOTH NOT IMPLEMENTED
-1,,DVFXB ;INTEGER DIVIDE TO BOTH
-1,,DVFLB ;REAL DIVIDE TO BOTH
-2,,DVDPMI ;DP DIV TO BOTH ON KI10 SAME AS DP DIV TO MEM
ILG ;COMPLEX DIVIDE TO BOTH NOT IMPLEMENTED
;
;[761] FOR GFLOATING
OPGARG: -1,,ADFX
-1,,ADFL
-1,,ADDPGF
-2,,ADCM
-1,,SBFX
-1,,SBFL
-1,,SBDPGF
-2,,SBCM
-1,,MLFX
-1,,MLFL
-1,,MLDPGF
-2,,MLCM
-1,,DVFX
-1,,DVFL
-1,,DVDPGF
-2,,DVCM
; FOR OPERATIONS TO MEMORY
-1,,ADFXM
-1,,ADFLM
-2,,ADDPMG
-2,,ADCMM
-1,,SBFXM
-1,,SBFLM
-2,,SBDPMG
-2,,SBCMM
-1,,MLFXM
-1,,MLFLM
-2,,MLDPMG
-2,,MLCMM
-1,,DVFXM
-1,,DVFLM
-2,,DVDPMG
-2,,DVCMM
; FOR OPERATIONS PERFORMED IMMEDIATE
-1,,ADFXI
-1,,ADFLI
ILG ;DOUBLE-PREC IMMED IS ILLEGAL
-1,,ADCMI
-1,,SBFXI
-1,,SBFLI
ILG ;DOUBLE-PREC IMMED IS ILLEGAL
-1,,SBCMI
-1,,MLFXI
-1,,MLFLI
ILG ;DOUBLE-PREC IMMED IS ILLEGAL
-2,,MLCMI
-1,,DVFXI
-1,,DVFLI
ILG ;DOUBLE-PREC IMMED IS ILLEGAL
-2,,DVCMI
;FOR OPERATIONS TO BOTH (NOTE THAT WE DESIGNATE OP TO BOTH BY SETTING
; BOTH THE "OP TO MEMORY" AND "IMMEDIATE" FLAGS)
-1,,ADFXB ;INTEGER ADD TO BOTH
-1,,ADFLB ;REAL ADD TO BOTH
-2,,ADDPMG ;DP ADD TO BOTH ON KI10 SAME AS DP ADD TO MEM
-2,,ADCMB ;COMPLEX ADD TO BOTH
-1,,SBFXB ;INTEGER SUBTRACT TO BOTH
-1,,SBFLB ;REAL SUBTRACTB TO BOTH
-2,,SBDPMG ;DP SUB TO BOTH ON KI10 SAME AS DP SUB TO MEM
-2,,SBCMB ;COMPLEX SUBTRACT TO BOTH
-1,,MLFXB ;INTEGER MULTIPLY TO BOTH
-1,,MLFLB ;REAL MULTIPLY TO BOTH
-2,,MLDPMG ;DP MUL TO BOTH ON KI10 SAME AS DP MUL TO MEM
ILG ;COMPLEX MULTIPLY TO BOTH NOT IMPLEMENTED
-1,,DVFXB ;INTEGER DIVIDE TO BOTH
-1,,DVFLB ;REAL DIVIDE TO BOTH
-2,,DVDPMG ;DP DIV TO BOTH ON KI10 SAME AS DP DIV TO MEM
ILG ;COMPLEX DIVIDE TO BOTH NOT IMPLEMENTED
;
;
;DEFINE CODE GENERATORS FOR THE ARITHMETIC OPERATIONS
;
;FOR INTEGER, REAL, AND COMPLEX OPERATIONS
ADFX=. ;ADD INTEGER
FRRFC,,FROMA2
ADD 0,0
;
ADFL=. ;ADD FLOATING PT
ADCM=. ;ADD COMPLEX (next 2 instrs)
FRRFC,,FROMA2
FADR 0,0
;
FRRFC,,FROMA2
FADR 1,1
;
;
SBFX=. ;SUBTRACT INTEGER
FRRFC,,FROMA2
SUB 0,0
;
SBFL=. ;SUBTRACT FLOATING PT
SBCM=. ;SUBTRACT COMPLEX (next 2 instrs)
FRRFC,,FROMA2
FSBR 0,0
;
FRRFC,,FROMA2
FSBR 1,1
;
;
MLFX=. ;MULTIPLY INTEGER
FRRFC,,FROMA2
IMUL 0,0
;
MLFL=. ;MULTIPLY REAL
FRRFC,,FROMA2
FMPR 0,0
;
MLCM=. ;MULTIPLY COMPLEX (next 2 instrs)
FRPTN,,FROMA2
MOVEI 16,0
;
FRPTN,,RGIMFN
PUSHJ 17,CMMLTB
;
;
DVFX=. ;INTEGER DIVIDE
FRRFC,,FROMA2
IDIV 0,0
;
DVFL=. ;REAL DIVIDE
FRRFC,,FROMA2
FDVR 0,0
;
DVCM=. ;COMPLEX DIVIDE (next 2 instrs)
FRPTN,,FROMA2
MOVEI 16,0
;
FRPTN,,RGIMFN
PUSHJ 17,CMDVTB
;
;
;FOR INTEGER,REAL AND COMPLEX OPERATIONS PERFORMED TO MEMORY
ADFXM=. ;INTEGER ADD TO MEMORY
FRRFC,,FROMA2
ADDM 0,0
;
ADFLM=. ;ADD FLOATING PT TO MEMORY
ADCMM=. ;ADD COMPLEX TO MEMORY (next 2 instrs)
FRRFC,,FROMA2
FADRM 0,0
;
FRRFC,,FROMA2
FADRM 1,1
;
;
SBFXM=.
FRRFC,,FROMA2
SUBM 0,0
;
SBFLM=. ;SUBTRACT FLOATING PT TO MEMORY
SBCMM=. ;SUBTRACT COMPLEX TO MEMORY (next 2 instrs)
FRRFC,,FROMA2
FSBRM 0,0
;
FRRFC,,FROMA2
FSBRM 1,1
;
;
MLFXM=. ;INTEGER MULTIPLY TO MEMORY
FRRFC,,FROMA2
IMULM 0,0
;
MLFLM=. ;REAL MULTIPLY TO MEMORY
FRRFC,,FROMA2
FMPRM 0,0
;
MLCMM=. ;COMPLEX MULTIPLY TO MEMORY (next 2 instrs)
FRPTN,,FROMA2
MOVEI 16,0
;
FRPTN,,RGIMFN
PUSHJ 17,CMMLMT
;
DVFXM=. ;INTEGER DIVIDE TO MEMORY
FRRFC,,FROMA2
IDIVM 0,0
;
DVFLM=. ;REAL DIVIDE TO MEMORY
FRRFC,,FROMA2
FDVRM 0,0
;
DVCMM=. ;COMPLEX DIVIDE TO MEMORY (next 2 instrs)
FRPTN,,FROMA2
MOVEI 16,0
;
FRPTN,,RGIMFN
PUSHJ 17,CMDVMT
;
;
; INTEGER,REAL AND COMPLEX OPERATIONS PERFORMED IMMEDIATE
ADFXI=.
FRRFC,,A2CNST
ADDI 0,0
;
ADFLI=. ;ADD FLOATING IMMEDIATE
ADCMI=. ;ADD IMMED TO COMPLEX
FRRFC,,A2CNST
FADRI 0,0
;
SBFXI=.
FRRFC,,A2CNST
SUBI 0,0
;
SBFLI=. ;SUB FLOATING IMMED
SBCMI=. ;SUB IMMED FROM COMPLEX
FRRFC,,A2CNST
FSBRI 0,0
;
MLFXI=. ;INTEGER MULTIPLY IMMEDIATE
FRRFC,,A2CNST
IMULI 0,0
;
MLFLI=. ;REAL MULTIPLY IMMEDIATE
FRRFC,,A2CNST
FMPRI 0,0
;
MLCMI=. ;COMPLEX VAR MULTIPLIED BY AN IMMED CONST
FRRFC,,A2CNST ; (next 2 instrs)
FMPRI 0,0
;
FRRFC,,A2CNST
FMPRI 1,0
;
DVFXI=. ;INTEGER DIVIDE IMMED
FRRFC,,A2CNST
IDIVI 0,0
;
DVFLI=. ;REAL DIVIDE IMMED
FRRFC,,A2CNST
FDVRI 0,0
;
DVCMI=. ;COMPLEX VAR DIVIDED BY AN IMMED CNST
FRRFC,,A2CNST ; (next 2 instrs)
FDVRI 0,0
;
FRRFC,,A2CNST
FDVRI 1,0
;
;
;
;
;FOR INTEGER,REAL, AND COMPLEX OPERATIONS TO BOTH
;
ADFXB=. ;INTEGER ADD TO BOTH
FRRFC,,FROMA2
ADDB 0,0
;
ADFLB=. ;REAL ADD TO BOTH
ADCMB=. ;COMPLEX ADD TO BOTH (NEXT 2 INSTRS)
FRRFC,,FROMA2
FADRB 0,0
;
FRRFC,,FROMA2
FADRB 1,1
;
SBFXB=. ;INTEGER SUBTRACT TO BOTH
FRRFC,,FROMA2
SUBB 0,0
;
SBFLB=. ;REAL SUBTRACT TO BOTH
SBCMB=. ;COMPLEX SUBTRACT TO BOTH (next 2 instrs)
FRRFC,,FROMA2
FSBRB 0,0
;
FRRFC,,FROMA2
FSBRB 1,1
;
MLFXB=. ;INTEGER MULTIPLY TO BOTH
FRRFC,,FROMA2
IMULB 0,0
;
MLFLB=. ;REAL MULTIPLY TO BOTH
FRRFC,,FROMA2
FMPRB 0,0
;
; (COMPLEX MULTIPLY TO BOTH NOT IMPLEMENTED)
;
DVFXB=. ;INTEGER DIVIDE TO BOTH
FRRFC,,FROMA2
IDIVB 0,0
;
DVFLB=. ;REAL DIVIDE TO BOTH
FRRFC,,FROMA2
FDVRB 0,0
;
; (COMPLEX DIVIDE TO BOTH NOT IMPLEMENTED)
;
;
;
;FOR DOUBLE-PREC OPS ON KI10
;
ADDPKI=. ; add double-prec
ADDPMI=. ; (to memory - next 2 instrs)
FRRFC,,FROMA2
DFAD 0,0
;
FRRFC,,FROMA2
DMOVEM 0,0
;
;
SBDPKI=. ;SUB DOUBLE-PREC
SBDPMI=. ; (TO MEMORY - next 2 instrs)
FRRFC,,FROMA2
DFSB 0,0
;
FRRFC,,FROMA2
DMOVEM 0,0
;
;
MLDPKI=. ;MUL DOUBLE-PREC
MLDPMI=. ; (TO MEMORY - next 2 instrs)
FRRFC,,FROMA2
DFMP 0,0
;
FRRFC,,FROMA2
DMOVEM 0,0
;
;
DVDPKI=. ;DIV DOUBLE-PREC
DVDPMI=. ; (TO MEMORY - next 2 instrs)
FRRFC,,FROMA2
DFDV 0,0
;
FRRFC,,FROMA2
DMOVEM 0,0
;FOR GLOATING DP OPS ON KL10
;
ADDPGF=. ; add double-prec
ADDPMG=. ; ( to memory - next 2 instrs)
FRRFC,,FROMA2
GFAD 0,0
;
FRRFC,,FROMA2
DMOVEM 0,0
;
;
SBDPGF=. ;SUB DOUBLE-PREC
SBDPMG=. ; (TO MEMORY - next 2 instrs)
FRRFC,,FROMA2
GFSB 0,0
;
FRRFC,,FROMA2
DMOVEM 0,0
;
;
MLDPGF=. ;MUL DOUBLE-PREC
MLDPMG=. ; (TO MEMORY - next 2 instrs)
FRRFC,,FROMA2
GFMP 0,0
;
FRRFC,,FROMA2
DMOVEM 0,0
;
;
DVDPGF=. ;DIV DOUBLE-PREC
DVDPMG=. ; (TO MEMORY - next 2 instrs)
FRRFC,,FROMA2
GFDV 0,0
;
FRRFC,,FROMA2
DMOVEM 0,0
;
;
;
;
;SET UP TABLES OF IMPLICIT FUNCTION NAMES
; FOR EACH OPERATION HAVE A DIFFERENT FN CORRESPONDING
; TO EACH REGISTER BETWEEN 2 AND 14
;
; COMPLEX MULTIPLY
CMMLTB: SIXBIT "CFM.0"
SIXBIT "CFM.1"
SIXBIT "CFM.2"
SIXBIT "CFM.3"
SIXBIT "CFM.4"
SIXBIT "CFM.5"
SIXBIT "CFM.6"
SIXBIT "CFM.7"
SIXBIT "CFM.10"
SIXBIT "CFM.11"
SIXBIT "CFM.12"
SIXBIT "CFM.13"
SIXBIT "CFM.14"
; COMPLEX DIVIDE
CMDVTB: SIXBIT "CFD.0"
SIXBIT "CFD.1"
SIXBIT "CFD.2"
SIXBIT "CFD.3"
SIXBIT "CFD.4"
SIXBIT "CFD.5"
SIXBIT "CFD.6"
SIXBIT "CFD.7"
SIXBIT "CFD.10"
SIXBIT "CFD.11"
SIXBIT "CFD.12"
SIXBIT "CFD.13"
SIXBIT "CFD.14"
; COMPLEX MULTIPLY TO MEMORY
CMMLMT: SIXBIT "CMM.0"
SIXBIT "CMM.1"
SIXBIT "CMM.2"
SIXBIT "CMM.3"
SIXBIT "CMM.4"
SIXBIT "CMM.5"
SIXBIT "CMM.6"
SIXBIT "CMM.7"
SIXBIT "CMM.10"
SIXBIT "CMM.11"
SIXBIT "CMM.12"
SIXBIT "CMM.13"
SIXBIT "CMM.14"
; COMPLEX DIVIDE TO MEMORY
CMDVMT: SIXBIT "CDM.0"
SIXBIT "CDM.1"
SIXBIT "CDM.2"
SIXBIT "CDM.3"
SIXBIT "CDM.4"
SIXBIT "CDM.5"
SIXBIT "CDM.6"
SIXBIT "CDM.7"
SIXBIT "CDM.10"
SIXBIT "CDM.11"
SIXBIT "CDM.12"
SIXBIT "CDM.13"
SIXBIT "CDM.14"
;
;DISPATCH TABLE FOR TYPE-CONVERSION OPERATIONS
;
;
;FOR KI10
OPGTCI: IGN ;FROM LOGICAL, TO INTEG
IGN ; TO REAL
-1,,RLDP ; TO DOUBLE-PREC
-1,,RLCMP ; TO COMPLEX
IGN ;FROM CONTROL, TO INTEG
IGN ; TO REAL
-1,,RLDP ; TO DOUBLE-PREC
-1,,RLCMP ; TO COMPLEX
IGN ;FROM DOUBLE-OCTAL, TO INTEG
IGN ; TO REAL
IGN ; TO DOUBLE-PREC
IGN ; TO COMPLEX
IGN ;FROM LITERAL
IGN
IGN
IGN
IGN ;FROM INTEG, TO INTEG
-1,,INRLI ; TO REAL
-1,,INDP ; TO DOUBLE-PREC
-2,,INCMI ; TO COMPLEX
-1,,RLINI ;FROM REAL, TO INTEGER
IGN ; TO REAL
-1,,RLDP ; TO DOUBLE PREC
-1,,RLCMP ; TO COMPLEX
-1,,DPIN ;FROM DOUBLE-PREC, TO INTEGER
-1,,DPRLI ; TO REAL
IGN ; TO DOUBLE-PREC
-2,,DPCMP ;[1135] TO COMPLEX
-1,,RLINI ;FROM COMPLEX, TO INTEGER
IGN ; TO REAL
-1,,CMPDP ; TO DOUBLE-PREC
IGN ; TO COMPLEX
;[761] FOR GFLOATING DP
OPGTCG: IGN ;FROM LOGICAL, TO INTEG
IGN ; TO REAL
-1,,RLGF ; TO DOUBLE-PREC
-1,,RLCMP ; TO COMPLEX
IGN ;FROM CONTROL, TO INTEG
IGN ; TO REAL
-1,,RLGF ; TO DOUBLE-PREC
-1,,RLCMP ; TO COMPLEX
IGN ;FROM DOUBLE-OCTAL, TO INTEG
IGN ; TO REAL
IGN ; TO DOUBLE-PREC
IGN ; TO COMPLEX
IGN ;FROM LITERAL
IGN
IGN
IGN
IGN ;FROM INTEG, TO INTEG
-1,,INRLI ; TO REAL
-1,,INGF ; TO DOUBLE-PREC
-2,,INCMI ; TO COMPLEX
-1,,RLINI ;FROM REAL, TO INTEGER
IGN ; TO REAL
-1,,RLGF ; TO DOUBLE PREC
-1,,RLCMP ; TO COMPLEX
-1,,GFIN ;FROM DOUBLE-PREC, TO INTEGER
-1,,GFRLI ; TO REAL
IGN ; TO DOUBLE-PREC
-2,,GFCMP ; TO COMPLEX
-1,,RLINI ;FROM COMPLEX, TO INTEGER
IGN ; TO REAL
-1,,CMPGF ; TO DOUBLE-PREC
IGN ; TO COMPLEX
;
;CODE GENERATORS FOR TYPE CONVERSIONS
;
;
;
;
;
INDP=. ;INTEGER TO DOUBLE-PREC
FRPTN,,RGIMFN
PUSHJ 17,DFLTT
;
;
;
;
RLCMP=. ;REAL TO COMPLEX
RLDP=. ;REAL TO DOUBLE-PREC
CMPDP=. ;COMPLEX TO DOUBLE PREC (ACROSS ASSIGNMENT)
FRRFC,,FRPTN
MOVEI 1,0
;
;
;[1135] Make DOUBLE PRECISION to COMPLEX conversion do rounding.
DPCMP=. ;DOUBLE PREC TO COMPLEX (ACROSS ASSIGNMENT)
FRPTN,,RGIMFN
PUSHJ 17,SNGLT
FRRFC,,FRPTN
MOVEI 1,0
;
;
DPIN=. ;FROM DOUBLE-PREC TO INTEGER
FRPTN,,RGIMFN
PUSHJ 17,IDFIXT
;
;
;
;
DPRLI=. ;FROM DOUBLE PREC TO REAL ON KI10 (USE NEXT 1 INSTR)
FRPTN,,RGIMFN
PUSHJ 17,SNGLT
;
;
INRLI=. ;FROM INTEGER TO REAL ON KI10 (NEXT 1 INSTR)
INCMI=. ;FROM INTEGER TO COMPLEX ON KI10 (NEXT 2 INSTRS)
FRRFC,,FRRFC
FLTR 0,0
;
FRRFC,,FRPTN
SETZ 1,0
;
;
RLINI=. ;FROM REAL TO INTEGER ON KI10
FRRFC,,FRRFC
FIX 0,0
;
;
;[761] FOR GFLOATING DP
INGF=.
FRRFC,,RGIMFN
EXTEND 0,GFLTRT
;
;
RLGF=.
CMPGF=.
FRRFC,,RGIMFN
EXTEND 0,GDBLET
;
;
GFIN=.
FRRFC,,RGIMFN
EXTEND 0,GFIXT
;
;
GFCMP=. ; (next 2 instrs)
GFRLI=.
FRRFC,,RGIMFN
EXTEND 0,GSNGLT
;
FRRFC,,FRPTN
MOVEI 1,0
;
;
;
;SET UP SIXBIT FN NAMES FOR THE LIBRARY FNS USED FOR TYPE-CONVERSIONS -
; THE OUTPUT MODULE EXPECTS
; TO BE GIVEN A PTR TO THE SIXBIT FOR A FUNCTION NAME
FLOATT: SIXBIT "FLT.0"
SIXBIT "FLT.1"
SIXBIT "FLT.2"
SIXBIT "FLT.3"
SIXBIT "FLT.4"
SIXBIT "FLT.5"
SIXBIT "FLT.6"
SIXBIT "FLT.7"
SIXBIT "FLT.10"
SIXBIT "FLT.11"
SIXBIT "FLT.12"
SIXBIT "FLT.13"
SIXBIT "FLT.14"
;
DFLTT: SIXBIT "DFL.0"
SIXBIT "DFL.1"
SIXBIT "DFL.2"
SIXBIT "DFL.3"
SIXBIT "DFL.4"
SIXBIT "DFL.5"
SIXBIT "DFL.6"
SIXBIT "DFL.7"
SIXBIT "DFL.10"
SIXBIT "DFL.11"
SIXBIT "DFL.12"
SIXBIT "DFL.13"
SIXBIT "DFL.14"
;
IFIXT: SIXBIT "IFX.0"
SIXBIT "IFX.1"
SIXBIT "IFX.2"
SIXBIT "IFX.3"
SIXBIT "IFX.4"
SIXBIT "IFX.5"
SIXBIT "IFX.6"
SIXBIT "IFX.7"
SIXBIT "IFX.10"
SIXBIT "IFX.11"
SIXBIT "IFX.12"
SIXBIT "IFX.13"
SIXBIT "IFX.14"
;
IDFIXT: SIXBIT "IDF.0"
SIXBIT "IDF.1"
SIXBIT "IDF.2"
SIXBIT "IDF.3"
SIXBIT "IDF.4"
SIXBIT "IDF.5"
SIXBIT "IDF.6"
SIXBIT "IDF.7"
SIXBIT "IDF.10"
SIXBIT "IDF.11"
SIXBIT "IDF.12"
SIXBIT "IDF.13"
SIXBIT "IDF.14"
SNGLT: SIXBIT "SNG.0"
SIXBIT "SNG.1"
SIXBIT "SNG.2"
SIXBIT "SNG.3"
SIXBIT "SNG.4"
SIXBIT "SNG.5"
SIXBIT "SNG.6"
SIXBIT "SNG.7"
SIXBIT "SNG.10"
SIXBIT "SNG.11"
SIXBIT "SNG.12"
SIXBIT "SNG.13"
SIXBIT "SNG.14"
GDBLET: SIXBIT "GDB.0"
SIXBIT "GDB.1"
SIXBIT "GDB.2"
SIXBIT "GDB.3"
SIXBIT "GDB.4"
SIXBIT "GDB.5"
SIXBIT "GDB.6"
SIXBIT "GDB.7"
SIXBIT "GDB.10"
SIXBIT "GDB.11"
SIXBIT "GDB.12"
SIXBIT "GDB.13"
SIXBIT "GDB.14"
GFIXT: SIXBIT "GFX.0"
SIXBIT "GFX.1"
SIXBIT "GFX.2"
SIXBIT "GFX.3"
SIXBIT "GFX.4"
SIXBIT "GFX.5"
SIXBIT "GFX.6"
SIXBIT "GFX.7"
SIXBIT "GFX.10"
SIXBIT "GFX.11"
SIXBIT "GFX.12"
SIXBIT "GFX.13"
SIXBIT "GFX.14"
GFLTRT: SIXBIT "GFL.0"
SIXBIT "GFL.1"
SIXBIT "GFL.2"
SIXBIT "GFL.3"
SIXBIT "GFL.4"
SIXBIT "GFL.5"
SIXBIT "GFL.6"
SIXBIT "GFL.7"
SIXBIT "GFL.10"
SIXBIT "GFL.11"
SIXBIT "GFL.12"
SIXBIT "GFL.13"
SIXBIT "GFL.14"
GSNGLT: SIXBIT "GSN.0"
SIXBIT "GSN.1"
SIXBIT "GSN.2"
SIXBIT "GSN.3"
SIXBIT "GSN.4"
SIXBIT "GSN.5"
SIXBIT "GSN.6"
SIXBIT "GSN.7"
SIXBIT "GSN.10"
SIXBIT "GSN.11"
SIXBIT "GSN.12"
SIXBIT "GSN.13"
SIXBIT "GSN.14"
;
;DISPATCH TABLE FOR STORE VALUE
;
;FOR KI10
OPGSTI: -1,,ST
-1,,ST2I
;
;CODE GENERATORS TO STORE A VAL
ST=.
FRRFC,,FROMPA
MOVEM 0,0
;
;
;
ST2I=.
FRRFC,,FROMPA
DMOVEM 0,0
;
;
;
;
;DISPATCH TABLE FOR "ASSIGNMENT STMNT STORE VALUE"
;
;
;FOR KI10
OPGASI: -1,,ST
-1,,ST
-1,,ST2I
-1,,ST2I
; FOR NEG OF ARG
-1,,STNG
-1,,STNG
-1,,STNG2I ;STORE NEG OF DOUBLE-PREC
-2,,STNCPX ; NEG OF COMPLEX
; FOR NOT OF ARG
-1,,STNT
-1,,STNT
-2,,STNT2
-2,,STNT2
;
;WHEN STORING THE RIGHT HALF OF A REGCONTENTS WHICH WAS USED AS AN AOBJN WD
OPGASR: -1,,STAOBJ
;
;
;CODE GENERATORS TO STORE NEG OR NOT OF A VALUE
STNG=.
STNCPX=. ;STORE NEG OF COMPLEX (NEXT 2 INSTRS)
FRRFC,,FROMPA
MOVNM 0,0
;
FRRFC,,FROMPA
MOVNM 1,1
;
STNT=. ;STORE NOT OF ARG
FRRFC,,FROMPA
SETCAM 0,0
;
;
;
STNG2I=. ;STORE NEG OF ARG - DOUBLE-PREC KI10
FRRFC,,FROMPA
DMOVNM 0,0
;
STNT2=. ;STORE NOT OF DOUBLE-WD ARG (next 2 instrs)
FRRFC,,FROMPA
SETCAM 0,0
;
FRRFC,,FROMPA
SETCAM 1,1
;
;
;CODE GENERATOR FOR THE SPECIAL CASE OF STORING THE RIGHT HALF OF AN AOBJN WD
; (WHICH CONTAINS A LOOP INDEX)
STAOBJ: FRRFC,,FROMPA
HRRZM 0,0
;
;FOR ASSIGN STATEMENT
;
OPASIN: -2,,ASSIGN
;
ASSIGN=. ;ALWAYS USE REG 1 (next 2 instrs)
FRPTN,,A1LAB
MOVEI 1,0
;
FRPTN,,FROMA1
MOVEM 1,0
;
;
;DISPATCH TABLE FOR BOOLEAN OPERATIONS
;
; COMPUTED IN A REG
OPGBOO: -1,,ANDRG
-1,,ORRG
-1,,EQVRG
-1,,XORRG
; COMPUTED TO MEMORY
-1,,ANDMEM
-1,,ORMEM
-1,,EQVMEM
-1,,XORMEM
; COMPUTED IMMEDIATE
-1,,ANDIMM
-1,,ORIMM
-1,,EQVIMM
-1,,XORIMM
; OPERATIONS TO BOTH REG AND MEMORY
-1,,ANDBO
-1,,ORBO
-1,,EQVBO
-1,,XORBO
; OPERATIONS INCLUDING NOT OF 2ND ARG
-1,,ANDNOT
-1,,ORNOT
-1,,XORRG ;EQV WITH NOT X IS SAME AS XOR X
-1,,EQVRG ;XOR WITH NOT X = EQV WITH X
; OPERATIONS TO MEMORY INCLUDING NOT OF 2ND ARG
-1,,ANDNTM
-1,,ORNTM
-1,,XORMEM
-1,,EQVMEM
; COMPUTED IMMEDIATE WITH NOT OF THE 2ND ARG
-1,,ANDNTI
-1,,ORNTI
-1,,XORIMM ;XOR WITH NOT OF ARG IS SAME AS EQV WITH ARG
-1,,EQVIMM
; OPERATIONS TO "BOTH" WITH NOT OF 2ND ARG
-1,,ANDNTB
-1,,ORNTB
-1,,XORBO ;EQV WITH NOT IS SAME AS XOR
-1,,EQVBO ;XOR WITH NOT IS SAME AS EQV
;
;
;
;DEFINE CODE GENERATORS FOR BOOLEAN OPS
;
ANDRG=.
FRRFC,,FROMA2
AND 0,0
;
ORRG=.
FRRFC,,FROMA2
IOR 0,0
;
EQVRG=.
FRRFC,,FROMA2
EQV 0,0
;
XORRG=.
FRRFC,,FROMA2
XOR 0,0
;
ANDMEM=.
FRRFC,,FROMA2
ANDM 0,0
;
ORMEM=.
FRRFC,,FROMA2
IORM 0,0
;
EQVMEM=.
FRRFC,,FROMA2
EQVM 0,0
;
XORMEM=.
FRRFC,,FROMA2
XORM 0,0
;
ANDBO=. ;AND TO BOTH
FRRFC,,FROMA2
ANDB 0,0
;
ORBO=. ;OR TO BOTH
FRRFC,,FROMA2
IORB 0,0
;
EQVBO=. ;EQV TO BOTH
FRRFC,,FROMA2
EQVB 0,0
;
XORBO=.
FRRFC,,FROMA2
XORB 0,0
;
ANDIMM=.
FRRFC,,A2CNST
ANDI 0,0
;
ORIMM=.
FRRFC,,A2CNST
IORI 0,0
;
EQVIMM=.
FRRFC,,A2CNST
EQVI 0,0
;
XORIMM=.
FRRFC,,A2CNST
XORI 0,0
;
ANDNOT=.
FRRFC,,FROMA2
ANDCM 0,0
;
ORNOT=.
FRRFC,,FROMA2
ORCM 0,0
;
ANDNTM=.
FRRFC,,FROMA2
ANDCMM 0,0
;
ORNTM=.
FRRFC,,FROMA2
ORCMM 0,0
;
ANDNTI=. ;AND WITH NOT OF AN IMMED
FRRFC,,A2CNST
ANDCMI 0,0
;
ORNTI=. ;OR WITH NOT OF AN IMMED
FRRFC,,A2CNST
ORCMI 0,0
;
ANDNTB=. ;AND WITH NOT OF ARG TO BOTH
FRRFC,,FROMA2
ANDCMB 0,0
;
ORNTB=. ;OR WITH NOT OF ARG TO BOTH
FRRFC,,FROMA2
ORCMB 0,0
;
;DISPATCH TABLE FOR RELATIONALS
;
; WHERE ARGS ARE SINGLE-WD - AND ARG2 NOT IMMED
OPGREL: ILG ;MODE 0 ILLEGAL
-1,,CMSPL
-1,,CMSPE
-1,,CMSPLE
ILG ;MODE 4 IS ILLEGAL
-1,,CMSPGE
-1,,CMSPN
-1,,CMSPG
; FOR ARG2 IMMED
ILG ;MODE 0 IS ILLEGAL
-1,,CMIML
-1,,CMIME
-1,,CMIMLE
ILG ;MODE 4 IS ILLEGAL
-1,,CMIMGE
-1,,CMIMN
-1,,CMIMG
; FOR ARGS DOUBLE-WD
ILG ;MODE 0 IS ILLEGAL
-3,,CMDPL
-2,,CMDPE
-3,,CMDPLE
ILG ;MODE 4 IS ILLEGAL
-3,,CMDPGE
-3,,CMDPN
-3,,CMDPG
; ARG2 IMMED AND DOUBLE-WD BOTH
ILG ;MODE 0 IS ILLEGAL
-3,,CDPIL
-2,,CDPIE
-3,,CDPILE
ILG ;MODE 4 IS ILLEGAL
-3,,CDPIGE
-3,,CDPIN
-3,,CDPIG
;
;
;CODE GENERATORS FOR RELATIONALS
;
; TO COMPARE SINGLE-WD ARGS
CMSPL=.
FRRFC,,FROMA2
CAML 0,0
;
CMSPE=.
FRRFC,,FROMA2
CAME 0,0
;
CMSPLE=.
FRRFC,,FROMA2
CAMLE 0,0
;
CMSPGE=.
FRRFC,,FROMA2
CAMGE 0,0
;
CMSPN=.
FRRFC,,FROMA2
CAMN 0,0
;
CMSPG=.
FRRFC,,FROMA2
CAMG 0,0
;
; TO COMPARE WITH AN IMMED CNST SPECIFIED BY ARG2
CMIML=.
FRRFC,,A2CNST
CAIL 0,0
;
CMIME=.
FRRFC,,A2CNST
CAIE 0,0
;
CMIMLE=.
FRRFC,,A2CNST
CAILE 0,0
;
CMIMGE=.
FRRFC,,A2CNST
CAIGE 0,0
;
CMIMN=.
FRRFC,,A2CNST
CAIN 0,0
;
CMIMG=.
FRRFC,,A2CNST
CAIG 0,0
;
; TO COMPARE DOUBLE-WD ARGS
CMDPL=. ; (next 3 instrs)
FRRFC,,FROMA2
CAMN 0,0
;
FRRFC,,FROMA2
CAMGE 1,1
;
FRRFC,,FROMA2
CAMLE 0,0
;
CMDPE=. ; (next 3 instrs)
FRRFC,,FROMA2
CAMN 0,0
;
FRRFC,,FROMA2
CAME 1,1
;
CMDPLE=. ; (next 3 instrs)
FRRFC,,FROMA2
CAMN 0,0
;
FRRFC,,FROMA2
CAMG 1,1
;
FRRFC,,FROMA2
CAMLE 0,0
;
CMDPGE=. ; (next 3 instrs)
FRRFC,,FROMA2
CAMN 0,0
;
FRRFC,,FROMA2
CAML 1,1
;
FRRFC,,FROMA2
CAMGE 0,0
;
CMDPN=. ; (next 3 instrs)
FRRFC,,FROMA2
CAMN 0,0
;
FRRFC,,FROMA2
CAME 1,1
;
FRPTN,,FRPTN
SKIPA
;
CMDPG=. ; (next 3 instrs)
FRRFC,,FROMA2
CAMN 0,0
;
FRRFC,,FROMA2
CAMLE 1,1
;
FRRFC,,FROMA2
CAMGE 0,0
;
;
; TO COMPARE DOUBLE-WD IMMED - THIS IS USED ONLY FOR THE CASE
; OF A COMPLEX BEING COMPARED TO 0 , BUT ITS EASIER TO HAVE THE ENTRIES
; IN THE TABLE THAN TO DIFFERENTIATE COMPLEX-IMMED FROM
; REAL-IMMED
CDPIL=. ; (next 3 instrs)
FRRFC,,A2CNST
CAIN 0,0
;
FRRFC,,FRPTN
CAIGE 1,0
;
FRRFC,,A2CNST
CAILE 0,0
;
CDPIE=. ; (next 3 instrs)
FRRFC,,A2CNST
CAIN 0,0
;
FRRFC,,FRPTN
CAIE 1,0
;
CDPILE=. ; (next 3 instrs)
FRRFC,,A2CNST
CAIN 0,0
;
FRRFC,,FRPTN
CAIG 1,0
;
FRRFC,,A2CNST
CAILE 0,0
;
CDPIGE=. ; (next 3 instrs)
FRRFC,,A2CNST
CAIN 0,0
;
FRRFC,,FRPTN
CAIL 1,0
;
FRRFC,,A2CNST
CAIGE 0,0
;
CDPIN=. ; (next 3 instrs)
FRRFC,,A2CNST
CAIN 0,0
;
FRRFC,,FRPTN
CAIE 1,0
;
FRPTN,,FRPTN
SKIPA
;
CDPIG=. ; (next 3 instrs)
FRRFC,,A2CNST
CAIN 0,0
;
FRRFC,,FRPTN
CAILE 1,0
;
FRRFC,,A2CNST
CAIGE 0,0
;
;
;DISPATCH TABLE FOR NEGNOT NODES
; HAVE 2 TABLES - ONE FOR THE CASE WHERE THE VAL HAS BEEN FETCHED
; INTO THE RFC BY GETA2OPIX, THE OTHER FOR THE CASE WHERE IT HAS NOT
;
;NOTE THAT MANY OF THE CODE GENERATORS REFERRED TO ARE ALSO USED FOR
; THE 'OPGETI' ENTRIES AND MAY BE FOUND IN THAT PART OF THE
; LISTING (APPROX LOCS 160-205)
; ALSO, SOME OF THE CODE GENERATORS FOR OPS 'TO MEMORY' ARE ALSO
; USED FOR THE 'OPGASI' ENTRIES AND MAY BE FOUND WITH THEM
; (APPROX LOCS 1244-1263)
;
;IF VAL IS ALREADY IN RFC
;
; KI10
OPGN1I: -1,,GANGSM ;NEG OF INTEGER
-1,,GANGSM ; REAL
-1,,GNGS2I ; DOUBLE-PREC
-2,,GNGSCM ; COMPLEX
;
-1,,GANTSM ;NOT OF INTEGER
-1,,GANTSM ; REAL
-2,,GNTS2 ; DOUBLE-PREC
-2,,GNTS2 ; COMPLEX
;
; TO MEMORY
-1,,STNG ;NEG OF INTEGER
-1,,STNG ; REAL
-3,,STNG2I ; DOUBLE-PREC
-2,,STNCPX ; COMPLEX
;
-1,,STNT ;NOT OF INTEGER
-1,,STNT ; REAL
-2,,STNT2 ; DOUBLE-PREC
-2,,STNT2 ; COMPLEX
;
;
;WHEN THE ARG IS NOT YET IN RFC
;
; KI10
OPGN2I: -1,,GANG ;NEG OF INTEGER
-1,,GANG ; REAL
-1,,GANG2I ; DOUBLE-PREC
-2,,GNGCM ; COMPLEX
;
-1,,GANT ;NOT OF INTEGER
-1,,GANT ; REAL
-2,,GANT2 ; DOUBLE-PREC
-2,,GANT2 ; COMPLEX
;
; TO MEMORY
-1,,NEGM ;NEG OF INTEGER
-1,,NEGM ; REAL
-2,,NEG2IM ; DOUBLE-PREC
-2,,NEGCMM ; COMPLEX
;
-1,,NOTM ;NOT OF INTEGER
-1,,NOTM ; REAL
-2,,NOT2M ; DOUBLE-PREC
-2,,NOT2M ; COMPLEX
;
; IMMEDIATE
-1,,GNGIMI ;NEG OF INTEGER
-1,,GNGIMR ;REAL
ILG ;DOUBLE-PREC (ILLEGAL)
-2,,GNGIM2 ;COMPLEX
;
-1,,GNTIMI ;NOT OF IMMED CNST INTEGER
ILG ; REAL
ILG ; DOUBLE-PREC
ILG ; COMPLEX
;
;
;
;NOTE THAT MOST OF THE CODE GENERATORS REFERENCED ABOVE ARE EITHER WITH
; "OPGETI" OR WITH "OPGASI"
;THE FOLLOWING CODE GENERATORS ARE FOR NEG/NOT PERFORMED FROM MEMORY TO
; MEMORY
;
NEGM=. ;NEG OF INTEGER/REAL
NEGCMM=. ;NEG OF COMPLEX (NEXT 2 INSTRS)
FRPTN,,FROMA2
MOVNS 0,0
;
FRPTN,,FROMA2
MOVNS 0,1
;
;
NEG2IM=. ;NEG OF DOUBLE-PREC ( next 2 instrs )
FRRFC,,FROMA2
DMOVN 0,0
;
FRRFC,,FROMA2
DMOVEM 0,0
;
;
NOTM=. ;NOT OF INTEGER/REAL
NOT2M=. ;NOT OF DOUBLE-PREC/COMPLEX (NEXT 2 INSTRS)
FRPTN,,FROMA2
SETCMM 0,0
;
FRPTN,,FROMA2
SETCMM 0,1
;
;
;DISPATCH TABLE FOR COMPUTATION OF P2MUL,P2DIV AND P2PL1MUL
;
;FOR KI10
;MULTIPLY BY POWER OF 2
OPGSPI: -1,,P2MFX
-1,,P2MFL
ILG
-2,,P2MCM
; WHEN ARG WAS NEGATED
-1,,P2MFX
-1,,P2MFL
ILG
-2,,P2MCM
;DIVIDE BY A POWER OF 2
-3,,P2DFX
-1,,P2DFL
ILG
-2,,P2DCM
; WHEN ARG WAS NEGATED
-3,,P2DFX
-1,,P2DFL
ILG
-2,,P2DCM
;FOR MULTIPLY BY POWER OF 2 PLUS 1
-2,,P21FX
-2,,P21FL
ILG
-4,,P21CM
; WHEN ARG WAS NEGATED
-2,,P21NFX
-2,,P21NFL
ILG
-4,,P21NCM
;[761] FOR GFLOATING DP
;MULTIPLY BY POWER OF 2
OPGSPG: -1,,P2MFX
-1,,P2MFL
ILG
-2,,P2MCM
; WHEN ARG WAS NEGATED
-1,,P2MFX
-1,,P2MFL
ILG
-2,,P2MCM
;DIVIDE BY A POWER OF 2
-3,,P2DFX
-1,,P2DFL
ILG
-2,,P2DCM
; WHEN ARG WAS NEGATED
-3,,P2DFX
-1,,P2DFL
ILG
-2,,P2DCM
;FOR MULTIPLY BY POWER OF 2 PLUS 1
-2,,P21FX
-2,,P21FL
ILG
-4,,P21CM
; WHEN ARG WAS NEGATED
-2,,P21NFX
-2,,P21NFL
ILG
-4,,P21NCM
;
;DISPATCH TABLE FOR MULT BY A POWER OF 2 PLUS 1 WHEN "A1IMMEDFLG" WAS
; SET (THIS IS THE ONLY OPERATOR FOR WHICH IMMEDFLG IS SIGNIFICANT)
OPP21I: -2,,P21IFX ;IMMED, FIXED POINT
-2,,P21IFL ;IMMED, FLOATING POINT
ILG ;IMMED DOUBLE-PREC SHOULD NEVER OCCUR
-2,,P21ICM ;IMMED, COMPLEX
; (P2PL1MUL NEGATED)
-2,,P21INX ;IMMED,NEGATED,FIXED PT
-2,,P21INL ;IMMED,NEGATED,FLOATING PT
ILG ;IMMED, DOUBLE-PREC IS ILLEGAL
-2,,P21INM ;IMMED, NEGATED, COMPLEX
;
;
;
;DISPATCH TABLE FOR SPECIAL OPS DONE TO MEMORY.
;
; P2MUL SHOULD NEVER BE DONE TO MEMORY
OPGSPM: ILG
ILG
ILG
ILG
; (P2MUL NEGATED - SHOULD NEVER BE DONE TO MEMORY)
ILG
ILG
ILG
ILG
; P2DIV SHOULD NEVER BE DONE TO MEMORY
ILG
ILG
ILG
ILG
; (P2DIV NEGATED)
ILG
ILG
ILG
ILG
; MULTIPLY BY A POWER OF 2 PLUS ONE
-2,,P21MFX
-2,,P21MFL
ILG ;DOUBLE PREC OPS ARE NEVER DONE TO MEMORY
-4,,P21MCM
; MULTIPLY THE NEG OF A NUMBER BY A POWER OF TWO PLUS ONE
-2,,P21MNX
-2,,P21MNL
ILG ;DOUBLE PREC OPS ARE NEVER DONE TO MEMORY
-4,,P21MNC
;
;
;
;
;CODE GENERATORS FOR MULTIPLICATION BY A POWER OF 2
;
P2MFX=. ;FIXED POINT MULTIPLY BY A POWER OF 2
P21FX=. ;FIXED POINT MULTIPLY BY A POWER OF 2
; PLUS 1 (USE NEXT 2 INSTRS)
FRRFC,,PTRA2
ASH 0,0
;
FRRFC,,FROMA1
ADD 0,0
;
;
;
P21NFX=. ;FIXED PT MULTIPLY BY POWER OF 2 PLUS
; 1 WHEN ARG WAS NEGATED (NEXT 2 INSTRS)
FRRFC,,PTRA2
ASH 0,0
;
FRRFC,,FROMA1
SUB 0,0
;
;
;
P2MFL=. ;FLOATING MULTIPLY BY A POWER OF 2
; (USE THE 1 NEXT INSTR)
P21FL=. ;FLOATING POINT MULTIPLY BY A POWER OF 2
; PLUS 1 (USE NEXT 2 INSTRS)
FRRFC,,PTRA2
FSC 0,0
;
FRRFC,,FROMA1
FADR 0,0
;
;
P21NFL=. ;FLOATING PT MULTIPLY BY POWER OF 2 PLUS
; ONE WHEN ARG WAS NEGATED (NEXT 2 INSTRS)
FRRFC,,PTRA2
FSC 0,0
;
FRRFC,,FROMA1
FSBR 0,0
;
;
;
;
;
P2MCM=. ;MULTIPLY A COMPLEX BY POWER OF 2
; (USE NEXT 2 INSTRS)
P21CM=. ;MULTIPLY A COMPLEX BY A POWER OF 2 PLUS
; 1 (USE NEXT 4 INSTRS)
FRRFC,,PTRA2
FSC 0,0
;
FRRFC,,PTRA2
FSC 1,0
;
FRRFC,,FROMA1
FADR 0,0
;
FRRFC,,FROMA1
FADR 1,1
;
;
P21NCM=. ;COMPLEX MULTIPLIED BY POWER OF 2 PLUS 1
; WHEN ARG WAS NEGATED (next 4 instrs)
FRRFC,,PTRA2
FSC 0,0
;
FRRFC,,PTRA2
FSC 1,0
;
FRRFC,,FROMA1
FSBR 0,0
;
FRRFC,,FROMA1
FSBR 1,1
;
;
P2DFX=. ;FIXED PT DIVIDE BY A POWER OF 2
; (USE NEXT 3 INSTRS)
FRPTN,,FRRFC
SKIPGE 0
;
FRRFC,,P2PTR2
ADDI 0,0
;
FRRFC,,NGPTR2
ASH 0
;
;
P2DFL=. ;FLOATING PT DIVIDE BY A POWER OF 2
P2DDPI=. ;DOUBLE-PREC DIVIDE BY A POWER OF 2
; ON THE KI10
FRRFC,,NGPTR2
FSC 0,0
;
FRPTN,,FRPTN
JFCL (5)
;
;
P2DCM=. ;COMPLEX DIVIDE BY A POWER OF 2
; (USE THE NEXT 2 INSTRS)
FRRFC,,NGPTR2
FSC 0,0
;
FRRFC,,NGPTR2
FSC 1,0
;
;
;
P2MDPI=. ;DOUBLE-PREC MULTIPLY BY A POWER OF 2 FOR
; THE KI10 (USE THE 2 NEXT INSTR)
P21DPI=. ;DOUBLE-PREC MULTIPLY BY A POWER OF 2 PLUS
; 1 FOR KI10 (USE NEXT 3 INSTRS)
FRRFC,,PTRA2
FSC 0,0
;
FRPTN,,FRPTN
JFCL (5)
;
FRRFC,,FROMA1
DFAD 0,0
;
;
P21NDI=. ;DOUBLE-PREC MULTP BY POWER OF 2 PLUS 1
; ON KI10 WHEN ARG WAS NEGATED
FRRFC,,PTRA2
FSC 0,0
;
FRPTN,,FRPTN
JFCL (5)
;
FRRFC,,FROMA1
DFSB 0,0
;
;
;
;CODE GENERATORS FOR MULTIPLY OF AN IMMED MODE ITEM BY A POWER OF 2 PLUS 1
;
P21IFX=. ;FIXED PT IMMED CNST MULTIPLIED BY A POWER OF
; 2 PLUS 1 (next 2 instrs)
FRRFC,,PTRA2
ASH 0,0
;
FRRFC,,A1CNST
ADDI 0,0
;
;
P21IFL=. ;FLOATING PT IMMED MULTIPLIED BY POWER OF 2 PLUS 1
FRRFC,,PTRA2 ; (next 2 instrs)
FSC 0,0
;
FRRFC,,A1CNST
FADRI 0,0
P21ICM=. ;COMPLEX IMMED, MULTIPLIED BY POWER OF 2 PLUS 1
FRRFC,,PTRA2 ;(next 2 instrs)
FSC 0,0
;
FRRFC,,A1CNST
FADRI 0,0
;
;
P21INX=. ;FIXED PT IMMED, NEGATED AND MULTIPLIED
FRRFC,,PTRA2 ; (next 2 instrs)
ASH 0,0
;
FRRFC,,A1CNST
SUBI 0,0
;
;
P21INL=. ;FLOATING PT IMMED NEGATED AND MULTIPLIED
FRRFC,,PTRA2 ; (next 2 instrs)
FSC 0,0
;
FRRFC,,A1CNST
FSBRI 0,0
;
P21INM=. ;COMPLEX NEGATED MULTIPLIED BY
;POWER OF TWO PLUS 1 (next 2 instrs)
FRRFC,,PTRA2
FSC 0,0
;
FRRFC,,A1CNST
FSBRI 0,0
;
;
;CODE GENERATORS FOR MULT BY A POWER OF 2 PLUS 1 DONE TO MEMORY
;
P21MFX=. ;MULTIPLY FIXED PT BY A POWER OF 2 PLUS 1 TO MEMORY
FRRFC,,PTRA2 ; (next 2 instrs)
ASH 0,0
;
FRRFC,,FROMA1
ADDM 0,0
;
P21MNX=. ;MULTIPLY A FIXED PT WHICH IS NEGATED BY A POWER OF
; 2 PLUS 1 LEAVING RESULT IN MEMORY (next 2 instrs)
FRRFC,,PTRA2
ASH 0,0
;
FRRFC,,FROMA1
SUBM 0,0
;
;
P21MFL=. ;MULTIPLY FLOATING PT BY A POWER OF 2 PLUS 1 TO MEMORY
FRRFC,,PTRA2 ; (next 2 instrs)
FSC 0,0
;
FRRFC,,FROMA1
FADRM 0,0
;
P21MNL=. ;MULTIPLY A FLOATING PT WHICH IS NEGATED BY A POWER OF
; 2 PLUS 1 LEAVING RESULT IN MEMORY (next 2 instrs)
FRRFC,,PTRA2
FSC 0,0
;
FRRFC,,FROMA1
FSBRM 0,0
;
;
P21MCM=. ;MULTIPLY A COMPLEX BY A POWER OF 2 PLUS 1 TO MEMORY
FRRFC,,PTRA2 ; (next 4 instrs)
FSC 0,0
;
FRRFC,,PTRA2
FSC 1,0
;
FRRFC,,FROMA1
FADRM 0,0
;
FRRFC,,FROMA1
FADRM 1,1
;
P21MNC=. ;MULTIPLY A NEGATED COMPLEX BY A POWEROF 2 PLUS
; ONE TO MEMORY (next 4 instrs)
FRRFC,,PTRA2
FSC 0,0
;
FRRFC,,PTRA2
FSC 1,0
;
FRRFC,,FROMA1
FSBRM 0,0
;
FRRFC,,FROMA1
FSBRM 1,1
;
;
;TABLES FOR FUNCTIONS FOR WHICH CODE IS GENERATED IN LINE (ABS,SIGN,
; DIM,MOD,MAX,MIN)
;
;
;WHEN THE VAL FOR ARG1 IS ALREADY IN THE REG FOR COMPUTATION
OPGILF: -1,,ABS
ILG ;RESERVE THIS SLOT FOR IABS IN A LATER RELEASE
; (NEED TO BE ABLE TO GENERATE LABELS TO HANDLE)
-3,,SIGN
-3,,DIM
-2,,MOD ;IN RELEASE 1, MOD MUST MOVE THE VAL FROM REG+1 TO REG
-2,,MAX
-2,,MIN
OPGDBF: -2,,IDABS ;DABS WHEN ARG IN REGFORCOMP ON KI
;
;FOR DIM,MOD,MAX,MIN WHEN ARG2 IS IMMEDIATE
OPGILI: ILG ;SHOULD NEVER SEE ABS WITH A2IMMED
ILG ;SHOULD NEVER SEE IABS WITH A2IMMED
ILG ;SHOULD NEVER SEE SIGN WITH A2IMMED
-3,,DIMI
-2,,MODI
-2,,MAXI
-2,,MINI
;FOR ABS,IABS, AND SIGN - WHEN THE VAL IS NOT YET IN REGFORCOMP
OPGIL1: -1,,ABS1
ILG ;IABS NOT HANDLED IN RELEASE 1
-3,,SIGN1
OPGDB1: -3,,IDABS1 ;DABS WHEN VAL NOT IN REGFORCOMP ON KI
;
;CODE GENERATORS FOR IN LINE FNS
ABS=. ;FOR ABS, USE NEXT 1 INSTR
SIGN=. ;FOR SIGN, USE NEXT 3 INSTRS
FRRFC,,FRRFC
MOVM 0,0
;
FRPTN,,FROMA2
SKIPGE 0,0
;
FRRFC,,FRRFC
MOVNS 0,0
;
;
DIM=. ;FOR DIM, USE NEXT 3 INSTRS
FRRFC,,FROMA2
CAMG 0,0
;
FRRFC,,FRRFC
TDZA 0,0
;
FRRFC,,FROMA2
FSBR 0,0
;
;
MOD=. ;FOR MOD, USE NEXT 2 INSTRS
FRRFC,,FROMA2
IDIV 0,0
;
FRRFC,,FRRFC
MOVE 0,1
;
;
MAX=. ;FOR MAX, USE NEXT 2 INSTRS
FRRFC,,FROMA2
CAMGE 0,0
;
FRRFC,,FROMA2
MOVE 0,0
;
;
MIN=. ;FOR MIN, USE NEXT 2 INSTRS
FRRFC,,FROMA2
CAMLE 0,0
;
FRRFC,,FROMA2
MOVE 0,0
;
;
DIMI=. ;DIM FOR ARG2 IMMED CNST
FRRFC,,A2CNST
CAIG 0,0
;
FRRFC,,FRRFC
TDZA 0,0
;
FRRFC,,A2CNST
FSBRI 0,0
;
;
MODI=. ;MOD WITH ARG2 IMMED (NEXT 2 INSTRS)
FRRFC,,A2CNST
IDIVI 0,0
;
FRRFC,,FRRFC
MOVE 0,1
;
;
MAXI=. ;MAX WITH ARG2 IMMED
FRRFC,,A2CNST
CAIGE 0,0
;
FRRFC,,A2CNST
MOVEI 0,0
;
;
MINI=. ;MIN WITH ARG2 IMMED
FRRFC,,A2CNST
CAILE 0,0
;
FRRFC,,A2CNST
MOVEI 0,0
;
;
;
ABS1=. ;FOR ABS WHEN ARG IS NOT IN REG (1 INST)
SIGN1=. ; SIGN WHEN ARG IS NOT IN REG (3 INSTRS)
FRRFC,,FROMA1
MOVM 0,0
;
FRPTN,,FROMA2
SKIPGE 0
;
FRRFC,,FRRFC
MOVNS 0,0
;
; FOR DABS IN LINE
;
IDABS=. ; FOR DABS WHEN ARG IN REGFORCOMP
; ON KI (next 2 instrs)
FRPTN,,FRRFC
SKIPGE 0,0
;
FRRFC,,FRRFC
DMOVN 0,0
;
;
;
;
IDABS1=. ;FOR DABS WHEN ARG NOT IN
;REGFORCOMP ON KI (next 3 instrs)
FRRFC,,FROMA1
DMOVE 0,0
;
FRPTN,FRRFC
SKIPGE 0,0
;
FRRFC,,FRRFC
DMOVN 0,0
;
;
;TABLES FOR GENERATION OF CODE FOR A "STORECLS" NODE (IE A NODE WHICH
;SPECIFIES THAT SOME VAL IS TO BE STORED IN A TEMPORARY)
;
;
;DISPATCH TABLE
OPGSTC: -2,,STARVL ;STORE VAL OF AN ARRAY ELEMENT
-1,,STRRFC ; STORE VAL OF AN ARRAY ELEM WHEN ITS ALREADY
; IN THE "REG-FOR-COMP"
-2,,STARAD ;STORE PTR TO AN ARRAY ELEM
-1,,STRRFC ; STORE PTR TO AN ARRAY ELEM WHEN THAT
; PTR IS ALREADY IN A REG
; FOR STORING THE VALUE OF AN ELEMENT IN A DOUBLE-WD ARRAY
OPGSTD: -2,,STDI ;TO STORE DOUBLE-WD ON KI10
-1,,STDIS ; DOUBLE-WD, KI10, WHEN VAL IS ALREADY IN
; REG-FOR-COMP
;
;
;
;
;CODE GENERATORS
;
STARVL=. ;TO STORE THE CONTENTS OF AN ARRAY ELEM
FRRFC,,FROMA2 ; (next 2 instrs)
MOVE 0,0
;
STRRFC=. ; (TO STORE A VAL ALREADY IN REGFORCOMP)
FRRFC,,PARTMP
MOVEM 0,0
;
;
STARAD=. ;TO STORE A PTR TO AN ARRAY ELEM
FRRFC,,FROMA2 ; (next 2 instrs)
MOVEI 0,0
;
FRRFC,,PARTMP
MOVEM 0,0
;
;
; CODE GENERATORS FOR STORING DOUBLE-WD VALS
STDI=. ; (next 2 instrs)
FRRFC,,FROMA2
DMOVE 0,0
;
STDIS=. ; KI10 WHEN VAL ALREADY IN REG
FRRFC,,PARTMP
DMOVEM 0,0
;
;
;
;DISPATCH TABLES FOR GENERATION OF INSTRUCTIONS FOR TRANSFERS OF CONTROL
;
;
;DISPATCH TABLE FOR TRANSFER OF CONTROL WHEN A SPECIFIED
; VARIABLE HAS THE SPECIFIED VALUE TRUE OR FALSE
OPGVTS: -2,,TSTMFL ;TRANSFER ON A MEMLOC FALSE
-1,,TSTRFL ;TRANSFER ON A REG CONTENTS FALSE
-2,,TSTMTR ;TRANSFER ON A MEMLOC TRUE
-1,,TSTRTR ;TRANSFER ON A REG TRUE
;
;DISPATCH TABLE FOR TRANSFER TO THE LABEL INDICATED BY A1NODE IF
; A SPECIFIED VARIABLE IS TRUE, TO THE LABEL INDICATED BY A2NODE IF
; IT IS FALSE
OPGALT: -3,,ALTMEM ;TRANSFER DEPENDS ON A VAL IN MEM
-2,,ALTREG ; ON A VAL IN A REG
;
;CODE GENERATORS FOR TRANSFERS OF CONTROL
;
TSTMFL=. ;TRANSFER ON A MEMLOC FALSE
FRPTN,,FROMPA ; (next 2 instrs)
SKIPL 0,0
;
FRPTN,,A1LAB
JRST 0
;
TSTRFL=. ;TRANSFER ON A REG CONTENTS FALSE
FRRFC,,A1LAB
JUMPGE 0,0
;
TSTMTR=. ;TRANSFER ON A MEMLOC TRU
FRPTN,,FROMPA ; (next 2 instrs)
SKIPGE 0,0
;
FRPTN,,A1LAB
JRST 0
;
TSTRTR=. ;TRANSFER ON A REG TRUE
FRRFC,,A1LAB
JUMPL 0,0
;
ALTMEM=. ;TRANSFER TO A1LAB IF MEMLOC IS TRUE,
; TO A2LAB IF FALSE (next 3 instrs)
FRPTN,,FROMPA
SKIPGE 0,0
;
FRPTN,,A1LAB
JRST 0,0
;
FRPTN,,A2LAB
JRST 0,0
;
ALTREG=. ;TRANSFER TO A1LAB IF REG IS TRUE, TO
; A2LAB IF FALSE (next 2 instrs)
FRRFC,,A1LAB
JUMPL 0,0
;
FRPTN,,A2LAB
JRST 0,0
INTERN DOSTC ;STORE THE CONTROL WORD
INTERN OPGDOS
INTERN OPGDOE
INTERN DOSTI
DOSTI: -1,,DOSTH
DOSTC: -1,,STCDO ;TO STORE THE CT WHEN IT IS IN A REG
-1,,STCDO1 ;TO STORE THE CT WHEN IT IS IN THE LEFT HALF OF
; A REG (IN AOBJN FORM)
STCDO=.
FRRFC,,FROMA1
MOVEM 0,0
STCDO1=.
FRRFC,,FROMA1
HLREM 0,0
;
OPGDOS: -1,,DOENS
OPGDOE: -1,,DOEN11
ILG
-1,,RDOEND
-2,,CDOEND
DOEN11=.
FRRFC,,A1LAB
AOBJN 0,0
DOSTH=.
FRRFC,,FROMA1
HRRZM 0,0
RDOEND=.
FRRFC,,A1LAB
AOJL 0,0
DOENS=.
FRRFC,,FROMA1
AOS 0,0
CDOEND=. ; (next 2 instrs)
FRPTN,,FROMA1
AOSGE 0
FRPTN,,A1LAB
JRST 0
;
;
;TABLES FOR CODE GENERATION OF CODE FOR ARITHMETIC IF STATEMENTS
;
;
;DISPATCH TABLE FOR GENERATION OF CODE FOR ARITHMETIC-IF STMNTS IN WHICH
; THE VAL OF THE EXPRESSION MUST BE ENTIRELY COMPUTED AND THEN TESTED
;
; IF NO 2 OF THE LABELS ARE EQUAL TO EACHOTHER
OPGAIF: -4,,AI2NN ;NONE OF THE 3 LABELS IS THE NEXT STMNT, VAL IS NOT IN REG
-3,,AI2NNR ;NONE OF THE LABELS IS NXT, VAL IS IN A REG
-3,,AI2NL ;LESS LABEL IS ON NEXT STMNT (VAL NOT IN REG)
-2,,AI2NLR ;LESS LABEL IS ON NEXT STMNT (VAL IS IN A REG)
-3,,AI2NE ;EQL LABEL IS NEXT (VAL IS NOT IN A REG)
-2,,AI2NER ;EQL LABEL IS NEXT (VAL IS IN A REG)
-3,,AI2NG ;GTR LABEL IS NEXT (VAL IS NOT IN A REG)
-2,,AI2NGR ;GTR LABEL IS NEXT (VAL IS IN A REG)
;
; IF LESS LABEL IS EQUAL TO EQL LABEL
-3,,I2LEN ;NONE OF THE LABELS IS NEXT (VAL IS NOT ON REG)
-2,,I2LENR ;NONE OF THE LABELS IS NEXT (VAL IS IN A REG)
-2,,I2LEL ;LESS (AND EQL) LABEL IS NEXT (VAL NOT IN A REG)
-1,,I2LELR ;LESS (AND EQL) LABEL IS NEXT (VAL IS IN A REG)
-2,,I2LEL ;EQL (AND LESS) LABEL IS NEXT (VAL NOT IN REG)
-1,,I2LELR ;EQL (AND LESS) LABEL IS NEXT (VAL IS IN REG)
-2,,I2LEG ;GTR LABEL IS NEXT (VAL NOT IN REG)
-1,,I2LEGR ;GTR LABEL IS NEXT (VAL IS IN REG)
;
; IF LESS LABEL IS EQUAL TO GTR LABEL
-3,,I2LGN ;NONE OF THE LABELS IS NEXT (VAL IS NOT ON REG)
-2,,I2LGNR ;NONE OF THE LABELS IS NEXT (VAL IS IN A REG)
-2,,I2LGL ;LESS (AND GTR) LABEL IS NEXT (VAL NOT IN A REG)
-1,,I2LGLR ;LESS (AND GTR) LABEL IS NEXT (VAL IS IN A REG)
-2,,I2LGE ;EQL LABEL IS NEXT (VAL NOT IN REG)
-1,,I2LGER ;EQL LABEL IS NEXT (VAL IS IN REG)
-2,,I2LGL ;GTR (AND LESS) LABEL IS NEXT (VAL NOT IN REG)
-1,,I2LGLR ;GTR (AND LESS) LABEL IS NEXT (VAL IS IN REG)
;
; IF GTR LABEL IS EQUAL TO EQL LABEL
-3,,I2GEN ;NONE OF THE LABELS IS NEXT (VAL IS NOT ON REG)
-2,,I2GENR ;NONE OF THE LABELS IS NEXT (VAL IS IN A REG)
-2,,I2GEL ;LESS LABEL IS NEXT (VAL NOT IN A REG)
-1,,I2GELR ;LESS LABEL IS NEXT (VAL IS IN A REG)
-2,,I2GEG ;EQL (AND GTR) LABEL IS NEXT (VAL NOT IN REG)
-1,,I2GEGR ;EQL (AND GTR) LABEL IS NEXT (VAL IS IN REG)
-2,,I2GEG ;GTR (AND EQL) LABEL IS NEXT (VAL NOT IN REG)
-1,,I2GEGR ;GTR (AND EQL) LABEL IS NEXT (VAL IS IN REG)
;
;
;CODE GENERATORS FOR ARITHMETIC-IF STMNTS IN WHICH THE VAL OF THE EXPRESSION
; MUST BE COMPUTED AND TESTED
;
; IF NO 2 OF THE LABELS ARE EQUAL TO EACHOTHER
;
AI2NN=. ;NONE OF THE LABELS IS NEXT, VAL NOT IN REG (next 4 instrs)
AI2NG=. ;GTR LABEL NXT, VAL NOT IN REG (NEXT 3 INSTRS ONLY)
FRRFC,,FROMA1
SKIPGE 0,0
;
FRPTN,,A1LAB
JRST 0
;
FRRFC,,A2LAB
JUMPE 0,0
;
FRPTN,,A3LAB
JRST 0
;
;
AI2NNR=. ;NONE OF THE LABELS IS NEXT, VAL IS IN REG (next 3 instrs)
AI2NGR=. ;GTR LABEL NEXT, VAL IN REG (USE NEXT 2 INSTRS ONLY)
FRRFC,,A1LAB
JUMPL 0,0
;
FRRFC,,A2LAB
JUMPE 0,0
;
FRPTN,,A3LAB
JRST 0
;
;
AI2NL=. ;LESS LABEL IS NEXT, VAL NOT IN REG
FRRFC,,FROMA1 ; (next 3 instrs)
SKIPN 0,0
;
FRPTN,,A2LAB
JRST 0
;
FRRFC,,A3LAB
JUMPG 0,0
;
;
AI2NLR=. ;LESS LABEL IS NEXT, VAL IS IN REG
FRRFC,,A2LAB ; (next 2 instrs)
JUMPE 0,0
;
FRRFC,,A3LAB
JUMPG 0,0
;
;
AI2NE=. ;EQL LABEL IS NEXT, VAL NOT IN REG
FRRFC,,FROMA1 ; (next 3 instrs)
SKIPGE 0,0
;
FRPTN,,A1LAB
JRST 0
;
FRRFC,,A3LAB
JUMPG 0,0
;
;
AI2NER=. ;EQL LABEL IS NEXT VAL IS IN REG
FRRFC,,A1LAB ; (next 2 instrs)
JUMPL 0,0
;
FRRFC,,A3LAB
JUMPG 0,0
;
;
; IF LESS AND EQL LABELS ARE EQUAL TO EACHOTHER
;
I2LEN=. ;NONE OF THE LABELS IS NEXT , VAL NOT IN REG (next 3 instrs)
I2LEG=. ;GTR LABEL NEXT, VAL NOT IN REG (USE THE NEXT 2 INSTRS ONLY)
FRPTN,,FROMA1
SKIPG 0,0
;
FRPTN,,A1LAB
JRST 0
;
FRPTN,,A3LAB
JRST 0
;
;
I2LENR=. ;NONE OF THE LABELS IS NEXT, VAL IS IN A REG (next 2 instrs)
I2LEGR=. ;GTR LABEL NEXT, VAL IN REG (USE THE NEXT INSTR ONLY)
FRRFC,,A1LAB
JUMPLE 0,0
;
FRPTN,,A3LAB
JRST 0
;
;
I2LEL=. ;LESS (AND EQL) LABEL IS NEXT, VAL NOT IN REG
FRPTN,,FROMA1
SKIPLE 0,0
;
FRPTN,,A3LAB
JRST 0
;
;
I2LELR=. ;LESS (AND EQL) LABEL IS NEXT, VAL IS IN REG
FRRFC,,A3LAB
JUMPG 0,0
;
;
; IF GTR LABEL IS EQUAL TO EQL LABEL
;
I2GEN=. ;NONE OF THE LABELS IS NEXT, VAL NOT IN REG (next 3 instrs)
I2GEL=. ;LESS LABEL IS NEXT, VAL NOT IN REG (USE NEXT 2 INSTS ONLY)
FRPTN,,FROMA1
SKIPL 0,0
;
FRPTN,,A3LAB
JRST 0
;
FRPTN,,A1LAB
JRST 0
;
;
I2GENR=. ;NONE OF THE LABELS IS NEXT,VAL IS IN REG (next 2 instrs)
I2GELR=. ;LESS LABEL IS NEXT, VAL IS IN REG (USE NEXT INSTR ONLY)
FRRFC,,A3LAB
JUMPGE 0,0
;
FRPTN,,A1LAB
JRST 0
;
;
I2GEG=. ;GTR (AND EQL) LABEL IS NEXT (next 2 instrs)
FRPTN,,FROMA1
SKIPGE 0,0
;
FRPTN,,A1LAB
JRST 0
;
;
I2GEGR=. ;GTR (AND EQL) LABEL IS NEXT, VAL IS IN REG
FRRFC,,A1LAB
JUMPL 0,0
;
;
; IF LESS LABEL IS EQUAL TO GTR LABEL
;
I2LGN=. ;NONE OF THE LABELS IS NEXT, VAL NOT IN REG (next 3 instrs)
I2LGE=. ;EQL LABEL NEXT, VAL NOT IN REG (USE NEXT 2 INSTRS ONLY)
FRPTN,,FROMA1
SKIPE 0,0
;
FRPTN,,A1LAB
JRST 0
;
FRPTN,,A2LAB
JRST 0
;
;
I2LGNR=. ;NONE OF THE LABELS IS NEXT, VAL IS IN REG (next 2 instrs)
I2LGER=. ;EQL LABEL NEXT, VAL IN REG (USE NEXT INSTR ONLY)
FRRFC,,A1LAB
JUMPN 0,0
;
FRPTN,,A2LAB
JRST 0
;
;
I2LGL=. ;LESS (AND GTR) LABEL IS NEXT, VAL NOT IN REG
FRPTN,,FROMA1 ; (next 2 instrs)
SKIPN 0,0
;
FRPTN,,A2LAB
JRST 0
;
;
I2LGLR=. ;LESS (AND GTR) LABEL IS NEXT, VAL IS IN REG
FRRFC,,A2LAB
JUMPE 0,0
;
;
;FOR COMPUTED GOTO - TO TEST THE RANGE OF THE VAL COMPUTED
; ALWAYS USE REGISTER 1
OPGCGO: -3,,CGOTS
;
CGOTS=. ; (next 3 instrs)
FRPTN,,FROMA1
SKIPLE 01,0
;
FRPTN,,FROMC1
CAILE 01,0
;
FRPTN,,A1LAB
JRST 0,0
;
; FOR COMPUTED GOTO WHEN THE VAR IS IN THE RH OF A REG CONTAINING
; THE DO LOOP CONTROL
OPGCGI: -4,,CGOITS
;
CGOITS=. ; (next 4 instrs)
FRPTN,,A1CNST ;GENERATE "MOVEI 1,0(LOOPREG)
MOVEI 1,0
;
FRPTN,,A1LAB
JUMPLE 1,0
;
FRPTN,,FROMC1
CAILE 1,0
;
FRPTN,,A1LAB
JRST 0,0
;
;
INTERN OPGIIN
INTERN OPGMVL
INTERN OPINDI
INTERN DVALU
INTERN OPINSI
INTERN CRETN
INTERN MOVRET
INTERN POPRET
;FOR PROLOGUE , EPILOGUE AND SUBROUTINE RETURN
;TO SAVE THE EPILOGUE ADDRESS
OPGIIN: -1,,MOVIIA
OPGMVL: -2,,MVLAB
;MOVE INDIRECT THROUGH 16
;FOR THE KI 10
OPINDI: -1,,GAI
-1,,GAI
-1,,GA2KII
-1,,GA2KII
;MAKE VALUES TO ADD FOR MULTIPLE RETURNS
DVALU: -1,,DATER
;SIMPLE RETURN
POPRET: -1,,POPIT
;MOVE THE RETURN I VALUE TO AC 1
MOVRET: -1,,MOVRTN
;STORE INDIRECT THROUGH 16
;FOR THE KI 10
OPINSI: -1,,STI
-1,,ST2II
;FOR A RETURN I
CRETN: -5,,LGRET
MOVIIA=.
FRRFC,,FROMC1
MOVEI 0,0(16)
MVLAB=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 1,0
FRPTN,,FROMA1
MOVEM 1,0
GAI=.
FRRFC,,FROMC1
MOVE 0,0(16)
GA2KII=.
FRRFC,,FROMC1
DMOVE 0,(16)
DATER=.
FRPTN,,FROMC1
0
STI=.
FRRFC,,FROMC1
MOVEM 0,0(16)
ST2II=.
FRRFC,,FROMC1
DMOVEM 0,(16)
LGRET=. ; (next 5 instrs)
FRPTN,,A1LAB
JUMPLE 1,0
FRPTN,,FROMC1
CAILE 1,0
FRPTN,,A1LAB
JRST
FRPTN,,A2LAB
MOVE 1,@0(1)
FRPTN,,FRPTN
HRRM 1,0(17)
POPIT=.
FRPTN,,FRPTN
POPJ 17,0
MOVRTN=.
FRPTN,,FROMC1
MOVE 1,0
;FOR SUBROUTINE OR FUNCTION CALL
INTERN CALLER
INTERN OPGSFN
CALLER: -2,,CALLIT
-1,,CNOARG
OPGSFN: -2,,CALLAB ;FOR STATEMENT FUNCTION REF
CALLIT=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
CNOARG=.
FRPTN,,FROMA1
PUSHJ 17,0
CALLAB=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,A2LAB
PUSHJ 17,0
;
;TO GENERATE CODE TO CALL FOROTS ROUTINES
;
;DISPATCH ENTRIES
OPGIOL: -2,,IOLSTC
OPGMTO: -2,,MTOPC
OPGIN: -2,,INC
OPGENC: -2,,ENCC
OPGDEC: -2,,DECC
OPGOUT: -2,,OUTC
OPGWTB: -2,,WTBC
OPGRTB: -2,,RTBC
OPGNLI: -2,,NLIC
OPGNLO: -2,,NLOC
OPGADJ: -2,,ADJOP
OPGLIB: -2,,LIBCAL
OPGOPE: -2,,OPENC
OPGFND: -2,,FINDC
OPGRLS: -2,,RELSC
OPGCLO: -2,,CLOC
OPGFIN: -1,,FINC
;
; CODE GENERATORS
IOLSTC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
;
FRPTN,,WD1IMF
PUSHJ 17,IOLSTT
;
MTOPC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,MTOPT
INC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,INT
ENCC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,ENCT
DECC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,DECT
OUTC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,OUTT
WTBC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,WTBT
RTBC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,RTBT
NLIC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,NLIT
NLOC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,NLOT
ADJOP=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,ADJT
LIBCAL=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVE 16,0
FRPTN,,IMFN
PUSHJ 17,0
OPENC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,OPENT
FINDC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,FINDT
RELSC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,RELST
CLOC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
FRPTN,,WD1IMF
PUSHJ 17,CLOST
FINC=.
FRPTN,,WD1IMF
PUSHJ 17,FINT
;
;SET UP THE SIXBIT FOR THE NAMES OF THE FOROTS ROUTINES
;
IOLSTT: SIXBIT "IOLST."
MTOPT: SIXBIT "MTOP."
INT: SIXBIT "IN."
OUTT: SIXBIT "OUT."
ENCT: SIXBIT "ENC."
DECT: SIXBIT "DEC."
NLIT: SIXBIT "NLI."
NLOT: SIXBIT "NLO."
WTBT: SIXBIT "WTB."
RTBT: SIXBIT "RTB."
ADJT: SIXBIT "ADJ."
OPENT: SIXBIT "OPEN."
FINDT: SIXBIT "FIND."
CLOST: SIXBIT "CLOSE."
RELST: SIXBIT "RELEA."
FINT: SIXBIT "FIN."
;TO GENERATE CODE FOR A PAUSE STATEMENT
OPGPAU: -2,,PAUSEC
PAUSEC=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
;
FRPTN,,WD1IMF
PUSHJ 17,PAUSET
;
PAUSET: SIXBIT "PAUS."
;
;
;
;
;FOR STOP
;
OPGSTP: -2,,STOPCD
STOPCD=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
;
FRPTN,,WD1IMF
PUSHJ 17,STOPT
;
STOPT: SIXBIT "STOP."
;
;FOR THE EXIT AT THE END OF THE PROGRAM
;
OPGEXI: -2,,EXITCD
EXITCD=. ; (next 2 instrs)
FRPTN,,A1LAB
MOVEI 16,0
;
FRPTN,,WD1IMF
PUSHJ 17,EXITT
;
;
EXITT: SIXBIT "EXIT."
;
;
;
;TO GENERATE CODE FOR THE INITIAL CALL TO RESET.
OPGRES: -3,,RESCD
;
RESCD=. ; (next 3 instrs)
FRPTN,,FRPTN
JFCL 0
;
FRPTN,,WD1IMF
JSP 16,RESETT
;
FRPTN,,FRPTN
0
;
RESETT: SIXBIT "RESET."
;
;TO GENERATE PUSH AND POP REGISTER SAVE AND RESTORES
;FOR STATEMENT FUNCTIONS
OPGPPR: -1,,POPRG
POPRG=.
FRPTN,,FRRFC
POP 17,0
OPGPHR: -1,,PSHR
PSHR=.
FRPTN,,FRRFC
PUSH 17,0
END