.TOC "MACRO.MIC -- Macro Definitions" .TOC "Revision 3.1" ; Shawn Persels, Bob Supnik .nobin ;**************************************************************************** ;* * ;* COPYRIGHT (c) 1985, 1986, 1987 BY * ;* DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASSACHUSETTS. * ;* 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. * ;* * ;**************************************************************************** .TOC " Revision History" ; 8-Jan-87 [RMS] Updated copyright notice, pass 2 code freeze ; 03 5-Jul-86 [RMS] Editorial changes, pass 1 code freeze ; 15-May-86 [RMS] Added macros for interlocked m bit update (ECO 5DEC27RMS.1) ; 28-Mar-86 [RMS] Generalized unary BASIC macros ; 31-Jan-86 [RMS] Added DEC.NEXT validity checks ; 6-Jan-86 [RMS] Changed SWAP.RN to LOAD.OLD.RN (ECO 6JAN08DWA.1) ; 29-Dec-85 [RMS] Revised LEN(DL) macro for new validity check ; 19-Sep-85 [RMS] Removed ZEXT, ZEXTB macros (ECO 5SEP19FF.1) ; 12-Sep-85 [RMS] Added CLEAR.WRITE.BUFFER function (ECO 5SEP10PIR.1) ; 26-Jun-85 [RMS] Fixed bug in single operand shift macros ; 21-Jun-85 [RMS] Eliminated spurious FPA broadcasts ; 02 18-Mar-85 [RMS] Revised for second pass model ; 01 15-Feb-85 [SDP] Revised destination select macros for new register file addressing scheme ; 00 4-May-84 [RMS] First edit for CVAX .TOC " BASIC Format Macros" ; Two operand BASIC macros always have the A as the first operand, ; followed by the B field. The choice of destination mode is made ; automatically by the macros, using the following pseudo-field. .SET/BASIC.DST=<.SELECT[ <.EQL[,]>, , <.EQL[,]>, , <.EQL[,]>, , <.EQL[,]>, , <1>, ]> []<--[]+[] "BASIC/FORMAT,BASIC.FNC/A.PLUS.B,W/@1,A/@2,PB/@3,B/<.AND[,0F]>,DST/" []<--[]+[]+1 "BASIC/FORMAT,BASIC.FNC/A.PLUS.B.PLUS.1,W/@1,A/@2,PB/@3,B/<.AND[,0F]>, DST/" []<--[]+[]+PSL.C "BASIC/FORMAT,BASIC.FNC/A.PLUS.B.PLUS.PSL.C,W/@1,A/@2,PB/@3,B/<.AND[,0F]>, DST/" []<--[]-[] "BASIC/FORMAT,BASIC.FNC/A.MINUS.B,W/@1,A/@2,PB/@3,B/<.AND[,0F]>,DST/" []<--[]-[]-PSL.C "BASIC/FORMAT,BASIC.FNC/A.MINUS.B.MINUS.PSL.C,W/@1,A/@2,PB/@3,B/<.AND[,0F]>, DST/" []<--[].AND.[] "BASIC/FORMAT,BASIC.FNC/A.AND.B,W/@1,A/@2,PB/@3,B/<.AND[,0F]>,DST/" []<--[].ANDNOT.[] "BASIC/FORMAT,BASIC.FNC/A.AND.NOT.B,W/@1,A/@2,PB/@3,B/<.AND[,0F]>,DST/" []<--[].OR.[] "BASIC/FORMAT,BASIC.FNC/A.OR.B,W/@1,A/@2,PB/@3,B/<.AND[,0F]>,DST/" []<--[].XOR.[] "BASIC/FORMAT,BASIC.FNC/A.XOR.B,W/@1,A/@2,PB/@3,B/<.AND[,0F]>,DST/" []<--[].SMULS.[] "BASIC/FORMAT,BASIC.FNC/SMUL.STEP,W/@1,A/@2,PB/@3,B/<.AND[,0F]>,DST/" []<--[].UDIVS.[] "BASIC/FORMAT,BASIC.FNC/UDIV.STEP,W/@1,A/@2,PB/@3,B/<.AND[,0F]>,DST/" []<--(-[]+[]) "BASIC/FORMAT,BASIC.FNC/B.MINUS.A,W/@1,A/@2,PB/@3,B/<.AND[,0F]>,DST/" NOP "BASIC/FORMAT,BASIC.FNC/PASS.A,A/0,B/0,DST/DST.ZILCH" ; Basic format macros, continued. ; Unary operation on B port select. ; Set destination mode based on destination, source. .SET/UNARY.B.DST=<.SELECT[ <.EQL[,]>, , <.EQL[,]>, , <.EQL[,]>, , <.LEQ[,3A]>, , <1>, ]> ; Set A port select if required to select destination. .SET/UNARY.B.ASEL=<.SELECT[ <.EQL[,]>, , <.EQL[,]>, , <.EQL[,]>, , <.LEQ[,3A]>, , <1>, ]> []<--B.[] "BASIC/FORMAT,BASIC.FNC/PASS.B,W/@1,PB/@2,B/<.AND[,0F]>,A/, DST/" []<--NEG.[] "BASIC/FORMAT,BASIC.FNC/NEG.B,W/@1,PB/@2,B/<.AND[,0F]>,A/, DST/" []<--NOT.[] "BASIC/FORMAT,BASIC.FNC/NOT.B,W/@1,PB/@2,B/<.AND[,0F]>,A/, DST/" ; Unary operation on A port select. ; Set destination mode based on destination, source. .SET/UNARY.A.DST=<.SELECT[ <.EQL[,]>, , <.EQL[,]>, , <.EQL[,]>, , <.OR[ <.AND[ <.GEQ[,20]>,<.LEQ[,29]>]>, <.AND[ <.GEQ[,3C]>,<.LEQ[,3E]>]>]>, , <1>, ]> ; Set B port select if required to select destination. .SET/UNARY.A.BSEL=<.SELECT[ <.EQL[,]>, , <.EQL[,]>, , <.EQL[,]>, , <.OR[ <.AND[ <.GEQ[,20]>,<.LEQ[,29]>]>, <.AND[ <.GEQ[,3C]>,<.LEQ[,3E]>]>]>, , <1>, ]> []<--[] "BASIC/FORMAT,BASIC.FNC/PASS.A,W/@1,A/@2,PB/,B/<.AND[,0F]>, DST/" []<--[]+1 "BASIC/FORMAT,BASIC.FNC/A.PLUS.1,W/@1,A/@2,PB/,B/<.AND[,0F]>, DST/" []<--[]-1 "BASIC/FORMAT,BASIC.FNC/A.MINUS.1,W/@1,A/@2,PB/,B/<.AND[,0F]>, DST/" .TOC " CONSTANT Format Macros" ; CONSTANT macros always have a constant operand, denoted by K, ; a destination operand, and possibly a source operand. The ; choice of destination mode is made automatically by the macros, ; using the following pseudo-field. .SET/CONSTANT.DST=<.SELECT[ <.EQL[,]>, , <.EQL[,]>, , <1>, ]> .SET/A.EQ.W=<.SELECT[ <.EQL[,]>, , <.LEQ[,3A]>, , <1>, ]> []<--[]+K[] "CONST/FORMAT,CONST.POS/BYTE0,CONST.FNC/A.PLUS.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[]-K[] "CONST/FORMAT,CONST.POS/BYTE0,CONST.FNC/A.MINUS.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--K[]-[] "CONST/FORMAT,CONST.POS/BYTE0,CONST.FNC/CONST.MINUS.A,CONST.BYTE/@2, W/@1,A/@3,CONST.DST/" []<--[].AND.K[] "CONST/FORMAT,CONST.POS/BYTE0,CONST.FNC/A.AND.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[].OR.K[] "CONST/FORMAT,CONST.POS/BYTE0,CONST.FNC/A.OR.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--K[] "CONST/FORMAT,CONST.POS/BYTE0,CONST.FNC/CONST,CONST.BYTE/@2, W/@1,A/,CONST.DST/" []<--[].ANDNOT.K[] "CONST/FORMAT,CONST.POS/BYTE0,CONST.FNC/A.AND.NOT.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[].XOR.K[] "CONST/FORMAT,CONST.POS/BYTE0,CONST.FNC/A.XOR.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[]+K[]0 "CONST/FORMAT,CONST.POS/BYTE1,CONST.FNC/A.PLUS.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[]-K[]0 "CONST/FORMAT,CONST.POS/BYTE1,CONST.FNC/A.MINUS.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--K[]0-[] "CONST/FORMAT,CONST.POS/BYTE1,CONST.FNC/CONST.MINUS.A,CONST.BYTE/@2, W/@1,A/@3,CONST.DST/" []<--[].AND.K[]0 "CONST/FORMAT,CONST.POS/BYTE1,CONST.FNC/A.AND.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[].OR.K[]0 "CONST/FORMAT,CONST.POS/BYTE1,CONST.FNC/A.OR.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--K[]0 "CONST/FORMAT,CONST.POS/BYTE1,CONST.FNC/CONST,CONST.BYTE/@2, W/@1,A/,CONST.DST/" []<--[].ANDNOT.K[]0 "CONST/FORMAT,CONST.POS/BYTE1,CONST.FNC/A.AND.NOT.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[].XOR.K[]0 "CONST/FORMAT,CONST.POS/BYTE1,CONST.FNC/A.XOR.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" ; Constant format macros, continued. []<--[]+K[]00 "CONST/FORMAT,CONST.POS/BYTE2,CONST.FNC/A.PLUS.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[]-K[]00 "CONST/FORMAT,CONST.POS/BYTE2,CONST.FNC/A.MINUS.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--K[]00-[] "CONST/FORMAT,CONST.POS/BYTE2,CONST.FNC/CONST.MINUS.A,CONST.BYTE/@2, W/@1,A/@3,CONST.DST/" []<--[].AND.K[]00 "CONST/FORMAT,CONST.POS/BYTE2,CONST.FNC/A.AND.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[].OR.K[]00 "CONST/FORMAT,CONST.POS/BYTE2,CONST.FNC/A.OR.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--K[]00 "CONST/FORMAT,CONST.POS/BYTE2,CONST.FNC/CONST,CONST.BYTE/@2, W/@1,A/,CONST.DST/" []<--[].ANDNOT.K[]00 "CONST/FORMAT,CONST.POS/BYTE2,CONST.FNC/A.AND.NOT.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[].XOR.K[]00 "CONST/FORMAT,CONST.POS/BYTE2,CONST.FNC/A.XOR.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[]+K[]000 "CONST/FORMAT,CONST.POS/BYTE3,CONST.FNC/A.PLUS.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[]-K[]000 "CONST/FORMAT,CONST.POS/BYTE3,CONST.FNC/A.MINUS.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--K[]000-[] "CONST/FORMAT,CONST.POS/BYTE3,CONST.FNC/CONST.MINUS.A,CONST.BYTE/@2, W/@1,A/@3,CONST.DST/" []<--[].AND.K[]000 "CONST/FORMAT,CONST.POS/BYTE3,CONST.FNC/A.AND.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[].OR.K[]000 "CONST/FORMAT,CONST.POS/BYTE3,CONST.FNC/A.OR.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--K[]000 "CONST/FORMAT,CONST.POS/BYTE3,CONST.FNC/CONST,CONST.BYTE/@2, W/@1,A/,CONST.DST/" []<--[].ANDNOT.K[]000 "CONST/FORMAT,CONST.POS/BYTE3,CONST.FNC/A.AND.NOT.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" []<--[].XOR.K[]000 "CONST/FORMAT,CONST.POS/BYTE3,CONST.FNC/A.XOR.CONST,CONST.BYTE/@3, W/@1,A/@2,CONST.DST/" SET.PSL.V "CONST/FORMAT,CONST.POS/BYTE0,CONST.FNC/A.OR.CONST,CONST.BYTE/2, A/PSL,CONST.DST/DST.A" CONSOLE.HALT[] "CONST/FORMAT,CONST.POS/BYTE1,CONST.FNC/CONST,CONST.BYTE/@1, A/SAVEPSL,CONST.DST/DST.A,MISC/DISABLE.IB.PREFETCH,GOTO[CONSOLE.HALT]" MACHINE.CHECK[] "CONST/FORMAT,CONST.POS/BYTE0,CONST.FNC/CONST,CONST.BYTE/@1, A/TMMGT,CONST.DST/DST.A,MISC/DISABLE.IB.PREFETCH,GOTO[MACHINE.CHECK]" CONSOLE.HALT.PARAM[] "CONST/FORMAT,CONST.POS/BYTE1,CONST.FNC/CONST,CONST.BYTE/@1, A/SAVEPSL,CONST.DST/DST.A,MISC/DISABLE.IB.PREFETCH" .TOC " SHIFT Format Macros" ; SHIFT macros can take a variety of destinations, depending on whether the ; shift is left or right, and on whether the A or B bus operand is suppressed. .SET/SHIFT.DST=<.SELECT[ <.EQL[,]>, , <.EQL[,]>, , <.AND[ <.EQL[,]>, <.EQL[,]>]>, , <.AND[ <.EQL[,]>, <.EQL[,]>]>, , <1>, ]> []<--[].ROTL.[] "SHIFT/FORMAT,SHIFT.VAL/@3,SHIFT.DIR/LEFT,W/@1,PB/@2,B/<.AND[,0F]>,A/@2, DST/" []<--[].ROTL.(SC) "SHIFT/FORMAT,SHIFT.VAL/0,SHIFT.DIR/LEFT,W/@1,PB/@2,B/<.AND[,0F]>,A/@2, DST/" []<--[].ROTR.[] "SHIFT/FORMAT,SHIFT.VAL/@3,SHIFT.DIR/RIGHT,W/@1,PB/@2,B/<.AND[,0F]>,A/@2, DST/" []<--[].ROTR.(SC) "SHIFT/FORMAT,SHIFT.VAL/0,SHIFT.DIR/RIGHT,W/@1,PB/@2,B/<.AND[,0F]>,A/@2, DST/" []<--[]!![].SHFL.[] "SHIFT/FORMAT,SHIFT.VAL/@4,SHIFT.DIR/LEFT,W/@1,PB/@3,B/<.AND[,0F]>,A/@2, DST/" []<--[]!![].SHFL.(SC) "SHIFT/FORMAT,SHIFT.VAL/0,SHIFT.DIR/LEFT,W/@1,PB/@3,B/<.AND[,0F]>,A/@2, DST/" []<--[]!![].SHFR.[] "SHIFT/FORMAT,SHIFT.VAL/@4,SHIFT.DIR/RIGHT,W/@1,PB/@3,B/<.AND[,0F]>,A/@2, DST/" []<--[]!![].SHFR.(SC) "SHIFT/FORMAT,SHIFT.VAL/0,SHIFT.DIR/RIGHT,W/@1,PB/@3,B/<.AND[,0F]>,A/@2, DST/" []<--[]!![].SHFR.(32-SC) "SHIFT/FORMAT,SHIFT.VAL/0,SHIFT.DIR/LEFT,W/@1,PB/@3,B/<.AND[,0F]>,A/@2, DST/" []<--SEXT.[].SHFR.[] "SHIFT/FORMAT,SHIFT.VAL/@3,SHIFT.DIR/RIGHT,W/@1,PB/@2,B/<.AND[,0F]>,A/SEXTN, DST/" []<--SEXT.[].SHFR.(SC) "SHIFT/FORMAT,SHIFT.VAL/0,SHIFT.DIR/RIGHT,W/@1,PB/@2,B/<.AND[,0F]>,A/SEXTN, DST/" []<--SEXT.[].SHFR.(32-SC) "SHIFT/FORMAT,SHIFT.VAL/0,SHIFT.DIR/LEFT,W/@1,PB/@2,B/<.AND[,0F]>,A/SEXTN, DST/" []<--[].SHFL.[] "SHIFT/FORMAT,SHIFT.VAL/@3,SHIFT.DIR/LEFT,PB/@1,A/@2,B/<.AND[,0F]>,DST/DST.B" []<--[].SHFL.(SC) "SHIFT/FORMAT,SHIFT.VAL/0,SHIFT.DIR/LEFT,PB/@1,A/@2,B/<.AND[,0F]>,DST/DST.B" []<--ZEXT.[].SHFR.[] "SHIFT/FORMAT,SHIFT.VAL/@3,SHIFT.DIR/RIGHT,A/@1,PB/@2,B/<.AND[,0F]>,DST/DST.A" []<--ZEXT.[].SHFR.(SC) "SHIFT/FORMAT,SHIFT.VAL/0,SHIFT.DIR/RIGHT,A/@1,PB/@2,B/<.AND[,0F]>,DST/DST.A" .TOC " MEM REQ Format Macros" ; MEMREQ read macros always have the A_bus as the first operand. ; The choice of destination mode is made automatically by the ; macros, using the following pseudo-field. .SET/MEMORY.DST=<.SELECT[ <.EQL[,]>, , <.EQL[,]>, , <1>, ]> []<--MEM(VA) "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VA,MEMREQ.ACC/RCHK.CURR,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VA).CHECK(AT) "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VA,MEMREQ.ACC/AT.CURR,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VA).LOCK "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VA.LOCK,MEMREQ.ACC/WCHK.CURR,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VA).IPR "MEMREQ/FORMAT,MEMREQ.FNC/MEM.PHYS.VA.IPR,MEMREQ.ACC/NONE,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VA).PHYS "MEMREQ/FORMAT,MEMREQ.FNC/MEM.PHYS.VA,MEMREQ.ACC/NONE,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VA).WCHECK "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VA,MEMREQ.ACC/WCHK.CURR,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VAP) "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VAP,MEMREQ.ACC/NONE,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VAP).LOCK "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VAP.LOCK,MEMREQ.ACC/NONE,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VAP).INTVEC "MEMREQ/FORMAT,MEMREQ.FNC/MEM.PHYS.VAP.INTVEC,MEMREQ.ACC/NONE,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VAP).PPTE "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VAP.PTE,MEMREQ.ACC/NONE,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VAP).PHYS "MEMREQ/FORMAT,MEMREQ.FNC/MEM.PHYS.VAP,MEMREQ.ACC/NONE,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VAP).PHYS.LOCK "MEMREQ/FORMAT,MEMREQ.FNC/MEM.PHYS.VAP.LOCK,MEMREQ.ACC/NONE,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MEM(VAP).SPTE "MEMREQ/FORMAT,MEMREQ.FNC/MEM.PHYS.VAP.PTE,MEMREQ.ACC/NONE,W/@1,A/, MEMREQ.RW/READ,DST/" MEM(VA)<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VA,MEMREQ.ACC/WCHK.CURR,A/@1, MEMREQ.RW/WRITE,DST/DST.ZILCH" MEM(VA).IPR<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MEM.PHYS.VA.IPR,MEMREQ.ACC/NONE,A/@1, MEMREQ.RW/WRITE,DST/DST.ZILCH" MEM(VA).PHYS<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MEM.PHYS.VA,MEMREQ.ACC/NONE,A/@1, MEMREQ.RW/WRITE,DST/DST.ZILCH" MEM(VA).UNLOCK<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VA.LOCK,MEMREQ.ACC/WCHK.CURR,A/@1, MEMREQ.RW/WRITE,DST/DST.ZILCH" MEM(VAP)<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VAP,MEMREQ.ACC/NONE,A/@1, MEMREQ.RW/WRITE,DST/DST.ZILCH" MEM(VAP).UNLOCK<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MEM.VIRT.VAP.LOCK,MEMREQ.ACC/NONE,A/@1, MEMREQ.RW/WRITE,DST/DST.ZILCH" MEM(VAP).PHYS<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MEM.PHYS.VAP,MEMREQ.ACC/NONE,A/@1, MEMREQ.RW/WRITE,DST/DST.ZILCH" MEM(VAP).PHYS.UNLOCK<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MEM.PHYS.VAP.LOCK,MEMREQ.ACC/NONE,A/@1, MEMREQ.RW/WRITE,DST/DST.ZILCH" ; MEM REQ format macros, continued. PROBE.READ.CURMODE "MEMREQ/FORMAT,MEMREQ.FNC/PROBE.VIRT.VA,MEMREQ.ACC/RCHK.CURR,A/0, MEMREQ.RW/READ,DST/DST.ZILCH" PROBE.WRITE.CURMODE "MEMREQ/FORMAT,MEMREQ.FNC/PROBE.VIRT.VA,MEMREQ.ACC/WCHK.CURR,A/0, MEMREQ.RW/WRITE,DST/DST.ZILCH" PROBE.READ.MODE "MEMREQ/FORMAT,MEMREQ.FNC/PROBE.VIRT.VA,MEMREQ.ACC/RCHK.MODE,A/0, MEMREQ.RW/READ,DST/DST.ZILCH" PROBE.WRITE.MODE "MEMREQ/FORMAT,MEMREQ.FNC/PROBE.VIRT.VA,MEMREQ.ACC/WCHK.MODE,A/0, MEMREQ.RW/WRITE,DST/DST.ZILCH" PROBE.NOACCHK "MEMREQ/FORMAT,MEMREQ.FNC/PROBE.VIRT.VA,MEMREQ.ACC/NONE,A/0, MEMREQ.RW/READ,DST/DST.ZILCH" PROBE.NOACCHK.VAP "MEMREQ/FORMAT,MEMREQ.FNC/PROBE.VIRT.VAP,MEMREQ.ACC/NONE,A/0, MEMREQ.RW/READ,DST/DST.ZILCH" []<--FPA.DATA "MEMREQ/FORMAT,MEMREQ.FNC/FPA.DATA,W/@1,A/, MEMREQ.RW/READ,DST/" []<--MXPR[] "MEMREQ/FORMAT,MEMREQ.FNC/MXPR,MEMREQ.PR/@2,W/@1,A/, MEMREQ.RW/READ,DST/" MXPR[]<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MXPR,MEMREQ.PR/@1,A/@2, MEMREQ.RW/WRITE,DST/DST.ZILCH" []<--MXPS0[] "MEMREQ/FORMAT,MEMREQ.FNC/MXPS0,MEMREQ.REG.RD.0/@2,W/@1,A/, MEMREQ.RW/READ,DST/" MXPS0[]<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MXPS0,MEMREQ.REG.WR.0/@1,A/@2, MEMREQ.RW/WRITE,DST/DST.ZILCH" []<--MXPS1[] "MEMREQ/FORMAT,MEMREQ.FNC/MXPS1,MEMREQ.REG.RD.1/@2,W/@1,A/, MEMREQ.RW/READ,DST/" MXPS1[]<--[] "MEMREQ/FORMAT,MEMREQ.FNC/MXPS1,MEMREQ.REG.WR.1/@1,A/@2, MEMREQ.RW/WRITE,DST/DST.ZILCH" .TOC " SPECIAL Format Macros" CLEAR.VAX.TRAP.REQUEST "SPECIAL/FORMAT,SPECIAL.MISC1/CLEAR.VAX.TRAP.REQUEST" SET.VAX.TRAP.REQUEST "SPECIAL/FORMAT,SPECIAL.MISC1/SET.VAX.TRAP.REQUEST" ZAP.TB "SPECIAL/FORMAT,SPECIAL.MISC1/ZAP.TB" ZAP.TB(HIT).IF.HIT "SPECIAL/FORMAT,SPECIAL.MISC1/ZAP.TB(HIT).IF.HIT" SET.REPROBE "SPECIAL/FORMAT,SPECIAL.MISC1/SET.REPROBE" SET.MMGT.TD "SPECIAL/FORMAT,SPECIAL.MISC1/SET.MMGT.TD" HALT "SPECIAL/FORMAT,SPECIAL.MISC1/HALT" PC<--BPC "SPECIAL/FORMAT,SPECIAL.MISC2/LOAD.PC.FROM.BPC" STATE5-4<--0 "SPECIAL/FORMAT,SPECIAL.MISC3/CLEAR.STATE.5-4" STATE3<--1 "SPECIAL/FORMAT,SPECIAL.MISC3/SET.STATE.3" STATE4<--1 "SPECIAL/FORMAT,SPECIAL.MISC3/SET.STATE.4" STATE5<--1 "SPECIAL/FORMAT,SPECIAL.MISC3/SET.STATE.5" .TOC " LENGTH Field Macros" ; LENGTH macros are treated as follows: LONG is ignored, ; since the length field defaults to long in microinstructions ; which have a length field, and is implied to be long in ; microinstructions which do not have one. LEN(DL) sets the ; length bit where appropriate. LEN(DL) "L/LEN(DL)" LONG "A/" ; macro must do something .TOC " CC Field Macros" SET.ALUCC "CC/LOAD.ALU.CC" SET.PSLCC "CC/LOAD.PSL.CC" SET.ALUCC&PSLCC "CC/LOAD.ALU.CC&PSL.CC" .TOC " MISC Field Macros" VA& "MISC/WRITE.VA" VAP& "MISC/WRITE.VAP" SC& "MISC/WRITE.SC" CLEAR.WRITE.BUFFER "MISC/CLEAR.WRITE.BUFFER" RESTART.PREFETCH "MISC/RESTART.PREFETCH" ENABLE.IB.PREFETCH "MISC/ENABLE.IB.PREFETCH" DISABLE.IB.PREFETCH "MISC/DISABLE.IB.PREFETCH" RN<--0 "MISC/CLEAR.RN" RN<--RN-1 "MISC/RN.MINUS.1" RN<--RN+1 "MISC/RN.PLUS.1" RN<--RN+DL.Q "MISC/RN.PLUS.DL.Q" RN<--RN.OLD "MISC/LOAD.OLD.RN" DL<--BYTE "MISC/DL.BYTE" DL<--WORD "MISC/DL.WORD" DL<--LONG "MISC/DL.LONG" DL<--QUAD "MISC/DL.QUAD" STATE3-0<--0 "MISC/CLEAR.STATE.3-0" STATE0<--1 "MISC/SET.STATE.0" STATE1<--1 "MISC/SET.STATE.1" STATE2<--1 "MISC/SET.STATE.2" SET.REEXECUTE "MISC/SET.REEXECUTE" CLEAR.MMGT.TD "MISC/CLEAR.MMGT.TD" LOAD.V&PC "MISC/LOAD.V&PC" IF.BCOND.LOAD.V&PC "MISC/IF.BCOND.LOAD.V&PC" IF.BCOND.LOAD.V&PC.TRAP "MISC/IF.BCOND.LOAD.V&PC.TRAP" OLD.Z.AND.NEW.Z "MISC/OLD.Z" USE.DL "MISC/SHIFT.DL" RLOG "MISC/RLOG" MAP.JIZJ "MISC/MAP.JIZJ" MAP.IIII "MISC/MAP.IIII" MAP.IIIJ "MISC/MAP.IIIJ" .TOC " BRANCH Format Macros" CASE2[].AT.[] "BRANCH/FORMAT,BR.BCS/@1,BR64T.OFF/@2" CASE4[].AT.[] "BRANCH/FORMAT,BR.BCS/@1,BR64T.OFF/@2" CASE8[].AT.[] "BRANCH/FORMAT,BR.BCS/@1,BR64T.OFF/@2" DEC.NEXT "BRANCH/FORMAT,BR.BCS/DEC.NEXT,BR64T.OFF/0" IF(DL.BWL)_DEC.NEXT "BRANCH/FORMAT,BR.BCS/DL.BWL_DEC.NEXT" IF(DL.BWL)_DEC.NEXT.ELSE.[] "BRANCH/FORMAT,BR.BCS/DL.BWL_DEC.NEXT,BR64T.OFF/@1" SPEC.NEXT "BRANCH/FORMAT,BR.BCS/SPEC.NEXT,BR64T.OFF/0" IF(DL.BWL)_SPEC.NEXT "BRANCH/FORMAT,BR.BCS/DL.BWL_SPEC.NEXT" IF(DL.BWL)_SPEC.NEXT.ELSE.[] "BRANCH/FORMAT,BR.BCS/DL.BWL_SPEC.NEXT,BR64T.OFF/@1" IF(AT.AV)_SPEC.NEXT "BRANCH/FORMAT,BR.BCS/AT.AV_SPEC.NEXT" IF(AT.AV)_SPEC.NEXT.ELSE.[] "BRANCH/FORMAT,BR.BCS/AT.AV_SPEC.NEXT,BR64T.OFF/@1" IF(DL.BWL.AT.RVM)_SPEC.NEXT "BRANCH/FORMAT,BR.BCS/DL.BWL.AT.RVM_SPEC.NEXT" IF(AT.RVM)_SPEC.NEXT.ELSE.[] "BRANCH/FORMAT,BR.BCS/AT.RVM_SPEC.NEXT,BR64T.OFF/@1" IF(DL.BWL.AT.R)_SPEC.NEXT "BRANCH/FORMAT,BR.BCS/DL.BWL.AT.R_SPEC.NEXT" IF(AT.R)_SPEC.NEXT.ELSE.[] "BRANCH/FORMAT,BR.BCS/AT.R_SPEC.NEXT,BR64T.OFF/@1" RETURN "BRANCH/FORMAT,BR.BCS/RET,BR64T.OFF/0" .TOC " JUMP Format Macros" CALL[] "JUMP/FORMAT,JMP.SUB/CALL,JMP.ADD/" GOTO[] "JUMP/FORMAT,JMP.SUB/NOCALL,JMP.ADD/" .bin