{File name: Xfer.mc
Description: Xfer and related opcodes,
AHL/JAC 21-Sep-87 15:04:46 set uGFI to 0 in trapping case as Trapping+2
AHL/JPM 20-Feb-87 10:39:31 Favor frame links over code links.
JPM 9-Jan-87 14:13:34 Fix bug in LGC (typo)
AHL/JPM 6-Jan-87 11:31:42 Changes for MDS relief
JPM 11-Feb-85 14:00:21 Separate stackP ← and push by one instr. (at DSKc)
JPM 3-Jan-85 15:29:46 Fix branch mask at XCe (mask top 3 bits)
JPM 11-Oct-84 14:04:04 Fix bug in rewritten StashPC routine (wrong-way branch)
JPM 10-Oct-84 12:12:45 Fix XFTrap branch (must now mask bit 12); changed StashPC routine to decrement PCpage
JPM 28-Sep-84 9:52:26 Use hardware to enable/disable interrupts (at @DI, @EI, @XE, and XFTrap)
JPM 11-Sep-84 13:35:25 Fix BRANCH mask after XWtOKDisp; fix allocation error
DEG 1-Sep-84 19:57:28 Add copyright notice.
JPM, 22-Jun-84 9:55:20, replace XRefBr at THx+1 by XDisp (using bit 12), replace XDirtyDisp by XWtOKDisp
HGM, 28-Nov-83 6:56:06, Dicentra version
HGM, 25-Nov-83 19:20:31, MesaIntBr on way to Reschedule (and lots of CANCLEBRs)
HGM, 25-Nov-83 19:20:31, Check c2 at TrapGo
HGM, 28-Sep-83 3:57:11, Dangling branch at LGCa
AXD 25-Oct-83 18:30:07 Rearrange LFC so that uXferType isn't at fZ = ←ib.
AXD 22-Sep-83 15:06:44 Don't use TOS in GLFrame.
AXD 17-Jun-83 12:03:30 new instruction set
RXJ 3-Aug-83 11:18:00
JGS March 5, 1982 12:02 PM Disable same G after RET trap fix
JGS January 26, 1982 4:00 PM XferTraps vs disabled for module
JGS January 22, 1982 XferTraps vs fsi last of page
JGS November 17, 1981 10:35 AM New Instruction Set
Last edited by JXF February 11, 1981 1:54 PM: catch KFCB for Block Equal
Created by RXJ}
{ Copyright (C) 1981, 1982, 1983, 1984, 1985 by Xerox Corporation. All rights reserved.}
{Fault/Trap flag}
Set[L3.XTrap, 0];
Set[L3.XFault, 1];
{LoadGC returns - Link 2; relative to LGCRtn}
MacroDef[LGCr, at[#1,10,LGCRtn]];
Set[L2.LGCFrame,9];{1 mod 3};
Set[L2.LGCFr,0B];{3 mod 3};
Set[L2.XProc,0D]; {must be odd; same as XCode, AllocSub}
{AllocSub returns - Link 2}
MacroDef[Allocr, at[#1,10,AllocRtn]];
{Set[L2.XProc,0D]; {must be odd; same as XCode, LoadGC}}
Set[L2.AF,0C];
{XCode returns - Link 2}
MacroDef[XCoder, at[#1,10,XCodeRtn]];
{Set[L2.XProc,0D]; {must be odd; same as LoadGC, AllocSub}}
Set[L2.XFrame,0A];
{GetLink returns - Link 2; relative to GLRtn}
MacroDef[GLr, at[#1,10,GLRtn]];
Set[L2.LLKBLink,0];
Set[L2.RKIBLink,1];
Set[L2.RKDIBLink,3];
Set[L2.EFCLink,2];
{XMDSWrite returns - Link 2; relative to XWRtn}
MacroDef[XWr, at[#1,10,XWRtn]];
Set[L2.POSpc,5]; {also SPCr}
Set[L2.PI,6];
Set[L2.DSKLoop,7];
Set[L2.DSKStkp,8];
{XMDSRead returns - Link 2; relative to XRRtn}
MacroDef[XRr, at[#1,10,XRRtn]];
Set[L2.LSKStkp,9];
Set[L2.LSKLoop,0A];
Set[L2.XSource,0B];
Set[L2.XIndirect,0C];
{****************************************************************************
LKB - Link Byte
****************************************************************************}
@LKB: T ← ib, push{tos}, c1, opcode[172'b];
PC ← PC + 1, push{destlo}, c2;
TT ← STK, pop{tos}, c3;
MAR ← [rhL, L+0], pop, c1;
MDR ← TT - T, IBDisp, GOTO[DISPNIonly], c2;
{****************************************************************************
EFCn - External Function Call n (n = 0-12)
****************************************************************************}
@EFC0: T ← 3, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[337'b];
@EFC1: T ← 5, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[340'b];
@EFC2: T ← 7, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[341'b];
@EFC3: T ← 9, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[342'b];
@EFC4: T ← 0B, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[343'b];
@EFC5: T ← 0D, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[344'b];
@EFC6: T ← 0F, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[345'b];
@EFC7: T ← 11, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[346'b];
@EFC8: T ← 13, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[347'b];
@EFC9: T ← 15, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[350'b];
@EFC10: T ← 17, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[351'b];
@EFC11: T ← 19, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[352'b];
@EFC12: T ← 1B, L2←L2.EFCnSpc, GOTO[EFCn], c1, opcode[353'b];
EFCn: TT ← UvPCpage, push, L1←1, CALL[StashPC1], c2;
rhT ← xtFC1, CANCELBR[EFCGetLink], c3, SPCr[L2.EFCnSpc];
{****************************************************************************
EFCB - External Function Call Byte
****************************************************************************}
@EFCB: T ← ib + 1, c1, opcode[354'b];
TT ← UvPCpage, L1←2, push, c2;
Q ← UvC, L2←L2.EFCBSpc, GOTO[StashPCa], c3;
rhT ← xtFC2, T ← T + T + 1, CANCELBR[$], c3, SPCr[L2.EFCBSpc];
EFCGetLink:
MAR ← [rhG, G-GF.word], L2←L2.EFCLink, GOTO[GetLink], c1;
{****************************************************************************
LFC - Local Function Call
****************************************************************************}
@LFC: T ← UvL, L2←L2.LFCSpc, c1, opcode[355'b];
TT ← UvPCpage, push, L1←3, CALL[StashPC3], c2;
rhT ← xtFC3, STK ← TOS, CANCELBR[$], c3, SPCr[L2.LFCSpc];
uSourceLo ← T, c1;
Rx ← XferType.lfc, c2;
uXferType ← Rx, c3;
TT ← ib, pop, c1;
TT ← TT LRot8, L2←L2.XProc, c2;
TT ← TT or ib, GOTO[SameG], c3;
{****************************************************************************
SFC - Stack Function Call
****************************************************************************}
@SFC: T ← STK, push, L2←L2.SFCSpc, c1, opcode[356'b];
TT ← UvPCpage, L1←1, CALL[StashPC1], c2;
STK ← Q ← TOS, rhT ← xtSFC1, CANCELBR[$], c3, SPCr[L2.SFCSpc];
Rx ← XferType.call, c1;
uXferType ← Rx, pop, c2;
TT ← UvL, L1←L1.Xfer, c3;
uSourceLo ← TT, pop, c1;
uDestHi ← TT ← Q, pop, c2;
SFCa: uDestLo ← T, YDisp, GOTO[XFER], c3;
{****************************************************************************
RET - Return
****************************************************************************}
@RET: MAR ← [rhL,L-LF.word], L0←0, c1, opcode[357'b];
Rx ← UvPCpage, CANCELBR[$,0], c2;
TT ← MD{fsi}, uRetPChi ← Rx, c3;
RETa: T ← PC LShift1, Cin←pc16, c1;
UreturnPC ← T, L0Disp, c2;
Rx ← UvC, BRANCH[RETb, AFa], c3;
RETb: uRetC ← Rx, Rx ← XferType.ret, c1;
Ufsi ← TT, TT ← 0, c2;
uSourceLo ← TT, c3;
MAR ← [rhL,L-LF.returnLink], push, L1←L1.Xfer, c1;
rhT ← xtRET, STK ← TOS, CANCELBR[$,0], c2;
T ← MD, uXferType ← Rx, pop, XDisp, GOTO[XFER], c3;
{****************************************************************************
LLKB - Load Link Byte
****************************************************************************}
@LLKB: T ← ib + 1, push, L2←L2.LLKBLink, c1, opcode[167'b];
STK ← TOS, push, PC ← PC + 1, L1←L1.Pop2Dec2, c2;
LLKBa: rhTT ← UvGhigh, c3;
MAR ← [rhG,G-GF.word], c1;
TT ← UvG, CANCELBR[$,0], c2;
T ← T + T + 1, Xbus ← MD, XLDisp, GOTO[GLd], c3;
STK ← T, CANCELBR[$,0F], c1, GLr[L2.LLKBLink];
TOS ← TT, push, fZpop, IBDisp, GOTO[DISPNIonly], c2;
{****************************************************************************
RKIB - Read Link Indirect Byte
****************************************************************************}
@RKIB: T ← ib + 1, push, L2←L2.RKIBLink, c1, opcode[170'b];
STK ← TOS, push, PC ← PC + 1, L1←L1.Pop2Dec2, GOTO[LLKBa], c2;
Map ← Q ← [rhTT, T], CANCELBR[$,0F], c1, GLr[L2.RKIBLink];
pop, L1←L1.PopDec2, GOTO[RLMpc3], c2;
{****************************************************************************
RKDIB - Read Link Double Indirect Byte
****************************************************************************}
@RKDIB: T ← ib + 1, push, L2←L2.RKDIBLink, c1, opcode[171'b];
STK ← TOS, push, PC ← PC + 1, L1←L1.Pop2Dec2, GOTO[LLKBa], c2;
Map ← Q ← [rhTT, T], CANCELBR[$,0F], c1, GLr[L2.RKDIBLink];
pop, L1←L1.Pop2Dec2, GOTO[RDLMc3], c2;
{****************************************************************************
PO - Port Out
****************************************************************************}
@POR: PC ← PC - 1, L2←L2.POSpc, GOTO[POa], c1, at[0E,10,ESC0n];
@PO: PC ← PC - 1, L2←L2.POSpc, c1, at[0D,10,ESC0n];
POa: TT ← UvPCpage, L1←2, CALL[StashPC2], c2;
TT ← STK, L0←L0.XWrite, pop, CANCELBR[$], c3, SPCr[L2.POSpc];
Map ← Q ← [rhMDS,TT], L1←L1.Xfer, pop, c1;
T ← UvL, CALL[XWritex], c2;
Q ← TT + 1, rhT ← xtSFC2, c3, XWr[L2.POSpc];
Map ← Q ← [rhMDS, Q + 1], L2←L2.EFCLink, c1;
Rx ← XferType.port, GOTO[GLe], c2;
{****************************************************************************
PI - Port In
****************************************************************************}
@PI: T ← 0, L1←L1.PopDec2, push{tos}, c1, at[0C,10,ESC0n];
rhTT ← UvMDS, push{dest}, c2;
Rx ← STK{dest}, push{source}, L2←L2.PI, c3;
Map ← [rhTT,Rx], TT ← STK{source}, pop{dest}, c1;
Q ← Rx, pop{tos}, L0←L0.XWrite, CALL[XWritex], c2;
T ← TT, ZeroBr, c3, XWr[L2.PI];
TOS ← STK, pop, BRANCH[PIa,IBDispOnly], c1;
PIa: Q ← Q + 2, push, c2;
L1←L1.Dec2, c3;
Map ← [rhMDS, Q], c1;
L0←L0.W, GOTO[WMpc3], c2;
{****************************************************************************
KFCB - Kernel Function Call Byte
****************************************************************************}
@KFCB: T ← ib, L2←L2.KFCBSpc, c1, opcode[360'b];
TT ← UvPCpage, L1←2, push, CALL[StashPC2], c2;
T ← T + T + 1, rhT ← xtFC2, CANCELBR[$], c3, SPCr[L2.KFCBSpc];
Rx ← XferType.call, STK ← TOS, pop, c1;
KFCBa: TOS ← LShift1 0FF, SE ← 1, c2;
rhTT ← UvMDS, c3;
Map ← Q ← [rhMDS, TOS + T], L2←L2.EFCLink, c1;
TT ← UvL, GOTO[GLe], c2;
{****************************************************************************
AF - Allocate frame
****************************************************************************}
@AF: UrL ← L, L ← rhL, pop, c1, at[0A,10,ESC0n];
UrLHi ← L, push, L0←1, c2;
PC ← PC - 1, GOTO[RETa], c3;
AFa: uRetC ← Rx, L2←L2.AF, c1;
Rx ← UvPCpage, Cin←pc16, c2;
uRetPChi ← Rx, c3;
rhT ← xtAF, c1;
T ← 0FF + 1, c2;
L1←L1.Xfer, c3;
Map ← Q ← [rhMDS, T + TOS], L1←L1.Xfer, CALL[AllocSub], c1;
rhL ← UrLHi, c3, Allocr[L2.AF];
TOS ← TT, c1;
L ← UrL, IBDisp, GOTO[NegNI], c2;
{****************************************************************************
FF - Free frame
****************************************************************************}
@FF: Map ← uFrame ← Q ← [rhMDS, TOS], L1←L1.Dec2, c1, at[0B,10,ESC0n];
L0←L0.FF, c2;
rhRx ← Rx ← MD, XWtOKDisp, c3;
MAR ← [rhRx, Q-LF.word], BRANCH[FFMUD,$,0D], c1, WMFRet[L0.FF];
Q ← 0FF, CANCELBR[$,0], c2;
TT ← MD and Q, c3;
Map ← [rhMDS, Q + 1], L2←1, c1;
GOTO[Freex], c2;
FFb: MAR ← [rhRx, Q+0], GOTO[Wb], c1;
FFMUD: CANCELBR[WMapFix,0], c2;
{****************************************************************************
DI - Disable Interrupts
****************************************************************************}
@DI: T ← uWDC, ClrIE, c1, at[0,10,ESC1n];
T ← T+1, PgCarryBr, c2;
uWDC ← T, BRANCH[DIa, DIb], c3;
DIa: GOTO[IBDispOnly], c1;
DIb: T ← sInterruptError, GOTO[Trapc2], c1;
{****************************************************************************
EI - Enable Interrupts
****************************************************************************}
@EI: T ← uWDC, ZeroBr, c1, at[1,10,ESC1n];
T ← T - 1, ZeroBr, BRANCH[EIa, EIb], c2;
EIa: uWDC ← T, BRANCH[EIc, EId], c3;
EIb: uWDC ← T, CANCELBR[DIb,1], c3;
EIc: GOTO[IBDispOnly], c1;
EId: SetIE, GOTO[IBDispOnly], c1;
{****************************************************************************
DSK - Dump Stack
****************************************************************************}
@DSK: Q ← UvL, L1←L1.Dec2, c1, at[0,10,ESC2n];
Q ← Q + ib, L2←0, c2;
Rx ← State.word, c3;
DSKg: T ← UBrkByte, c1;
T ← T LRot8, L2Disp, c2;
UBrkByte ← 0, BRANCH[DSKf, PSSf], c3;
DSKf: TT ← ~ErrnIBnStkp, c1;
TT ← TT and 0F, L2←L2.DSKStkp, c2;
T ← T or TT, c3;
Map ← Q ← [rhMDS, Q+Rx], CALL[XWrite], c1;
T ← TT + 4, NibCarryBr, c3, XWr[L2.DSKStkp];
Q ← Q - State.word, BRANCH[DSTa, DSTb], c1;
DSTa: stackP ← TT ← TT + 2, GOTO[DSKc], c2;
DSTb: stackP ← TT ← 0E, GOTO[DSKc], c2;
DSKc: Q ← Q + TT, L2←L2.DSKLoop, c3;
Map ← Q ← [rhMDS, Q - 1], push, c1;
DSKd: T ← STK, pop, CALL[XWritex], c2;
TT ← TT - 1, ZeroBr, c3, XWr[L2.DSKLoop];
Map ← Q ← [rhMDS, Q - 1], BRANCH[DSKd, DSKe], c1;
DSKe: PC ← PC + PC16, pop, IBDisp, GOTO[DISPNIonly], c2;
{****************************************************************************
LSK - Load Stack
****************************************************************************}
@LSK: T ← UvL, L1←L1.Dec2, c1, at[3,10,ESC2n];
T ← T + ib, L2←L2.LSKStkp, c2;
TOS ← State.word, c3;
Map ← Q ← [rhMDS, TOS + T], c1;
stackP ← 1, L0←L0.XRead, CALL[XReadx], c2;
rhT ← TT LRot8, T ← TT + 1, c1, XRr[L2.LSKStkp];
T ← rhT, uPsbLink ← T, c2;
TT ← TT + 4, NibCarryBr, c3;
UBrkByte ← T, BRANCH[LSKa, LSKb], c1;
LSKa: TT ← TT and 0F, GOTO[LSKc], c2;
LSKb: TT ← 10, GOTO[LSKc], c2;
LSKc: T ← TT - 2, L2←L2.LSKLoop, c3;
LSKf: Map ← Q ← [rhMDS, Q-TOS], CALL[XRead], c1;
T ← T - 1, ZeroBr, push, c1, XRr[L2.LSKLoop];
STK ← TT, BRANCH[LSKd, LSKe], c2;
LSKd: TOS ← TOS xor ~TOS, GOTO[LSKf], c3;
LSKe: stackP ← uPsbLink, c3;
PC ← PC + PC16, c1;
TOS ← STK, pop, IBDisp, GOTO[DISPNIonly], c2;
{****************************************************************************
XF - XFER and Free
****************************************************************************}
@XF: MAR ← [rhL, L-LF.word], c1, at[2,10,ESC2n];
rhT ← xtXF, CANCELBR[$,0], c2;
T ← MD, L2←L2.XSpc, GOTO[XEb], c3;
{****************************************************************************
XE - XFER and Enable
****************************************************************************}
@XE: T ← uWDC, ZeroBr, c1, at[1,10,ESC2n];
T ← T - 1, rhT ← xtX, BRANCH[XEa, $], c2;
uWDC ← T, GOTO[DIb], c3;
XEa: uWDC ← T, ZeroBr, L2←L2.XSpc, c3;
XEb: PC ← PC - 1, BRANCH[XEc, XEd], c1;
XEc: TT ← UvPCpage, L1←3, CALL[StashPC3], c2;
XEd: TT ← UvPCpage, L1←3, SetIE, CALL[StashPC3], c2;
Ufsi ← T, CANCELBR[$], c3, SPCr[L2.XSpc];
TT ← UvL, L1←L1.Xfer, c1;
T ← TT + ib + 1, L0←L0.XRead, c2;
rhTT ← UvMDS, c3;
Map ← Q ← [rhMDS, T - 1], L2←L2.XSource, c1;
uFrame ← TT, CALL[XReadx], c2;
Map ← Q ← [rhMDS, T + 1], L2←L2.EFCLink, c1, XRr[L2.XSource];
Rx ← XferType.xfer, GOTO[GLe], c2;
{****************************************************************************
BRK - BreakPoint
****************************************************************************}
@BRK: T ← UBrkByte, ZeroBr, push, c1, opcode[75'b];
STK ← TOS, pop, BRANCH[BRKa, BRKb], c2;
BRKb: G ← 0, GOTO[Trapc1], c3;
BRKa: UBrkByte ← 0, c3;
BRKc: Xbus ← T LRot12, XDisp, c1;
Ybus ← T, YDisp, DISP4[OpD0], c2;
{OpD0:} GOTOABS[Add[OpcodeBase,0]], c3, at[0,10,OpD0];
GOTOABS[Add[OpcodeBase,10]], c3, at[1,10,OpD0];
GOTOABS[Add[OpcodeBase,20]], c3, at[2,10,OpD0];
GOTOABS[Add[OpcodeBase,30]], c3, at[3,10,OpD0];
GOTOABS[Add[OpcodeBase,40]], c3, at[4,10,OpD0];
GOTOABS[Add[OpcodeBase,50]], c3, at[5,10,OpD0];
GOTOABS[Add[OpcodeBase,60]], c3, at[6,10,OpD0];
GOTOABS[Add[OpcodeBase,70]], c3, at[7,10,OpD0];
GOTOABS[Add[OpcodeBase,80]], c3, at[8,10,OpD0];
GOTOABS[Add[OpcodeBase,90]], c3, at[9,10,OpD0];
GOTOABS[Add[OpcodeBase,0A0]], c3, at[0A,10,OpD0];
GOTOABS[Add[OpcodeBase,0B0]], c3, at[0B,10,OpD0];
GOTOABS[Add[OpcodeBase,0C0]], c3, at[0C,10,OpD0];
GOTOABS[Add[OpcodeBase,0D0]], c3, at[0D,10,OpD0];
GOTOABS[Add[OpcodeBase,0E0]], c3, at[0E,10,OpD0];
GOTOABS[Add[OpcodeBase,0F0]], c3, at[0F,10,OpD0];
{****************************************************************************
Xfer:
Entry:
T and uDestHi hold destination link
PC has LRot1 T (for procedure descriptor decode)
L has va of caller's frame (to be stored into Usource)
calling instruction executed on c1 and enters at one of:
XferFrame, XferProc1, XferIndirect, XferProc3
****************************************************************************}
XFER: Map ← Q ← [rhMDS, T], uDestLo ← T, DISP4[XferFrame,0C], c1, GLr[L2.EFCLink];
{ ********* Frame link ********* }
XferFrame:
rhTT ← GFTHi, [] ← Q, ZeroBr, c2, at[0C,10,XferFrame];
L ← MD, rhL ← MD, XWtOKDisp, BRANCH[$,ControlTrap], c3;
XFStartRead:
MAR ← [rhL, Q-LF.globalLink], BRANCH[XFMUD,XFMOK,0D], c1;
MAR ← [rhL, Q-LF.globalLink], BRANCH[XFMUD,XFMOK,0D], c1, WMFRet[L0.Xfer];
XFMUD: Rx ← L, CANCELBR[WMapFix,0], c2;
XFMOK: T ← UvL, CANCELBR[$,0], c2;
T ← MD {global link}, uFrame ← T, L2 ← L2.XFrame, c3;
MAR ← L ← [rhL, Q-LF.pc], {fix L in LGC subroutine} c1;
TOS ← Q, CANCELBR[$,0], c2;
TT ← MD {pc}, GOTO[LGC], c3;
UvL ← TOS, c1, XCoder[L2.XFrame];
uPCCross ← 0, c2;
Q ← T - 1, Xbus ← rhT, XDisp, c3;
Map ← [rhMDS, T], L2 ← 8, push, DISP4[XFTrap,8], c1;
XFTrap: Rx ← Rx + 1, c2, at[8,10,XFTrap];
uWDC ← Rx, ClrIE, GOTO[XPEnd], c3;
XFCall: GOTO[XferDone], c2, at[0A,10,XFTrap];
XFRet: TT ← Ufsi and Q, L2←0, GOTO[Freex,0], c2, at[0B,10,XFTrap];
XFCalI: T ← uSourceLo, push, GOTO[XPSD], c2, at[0E,10,XFTrap];
XFRetI: T ← uSourceLo, push, GOTO[XPSD], c2, at[0F,10,XFTrap];
{ ********* Indirect link ********* }
XferIndirect:
T ← rhT, c2, at[0E,10,XferFrame];
T ← T or 4, L2←L2.XIndirect, {set indirect xfer bit} c3;
Map ← Q ← [rhMDS, Q+1], L0←L0.XRead, c1;
rhT ← T LRot0, GOTO[XReadx], c2;
MAR ← [rhRx, Q-1], c1, XRr[L2.XIndirect];
T ← UvL, CANCELBR[$,0], c2;
T ← MD, uFrame ← T, XDisp, c3;
Map ← Q ← [rhMDS, T], DISP4[XferFrame,0C], c1;
{ ********* Old Procedure descriptor ********* }
XferProc1:
rhTT ← GFTHi, Q ← T-1, ZeroBr, c2, at[0D,10,XferFrame];
rhRx ← Rx ← MD, XRefBr, BRANCH[$,UnboundTrap], c3;
MAR ← [rhRx, Q-GF.word], L0←L0.XGfi, BRANCH[XOPa,XOPb], c1, RMFRet[L0.XGfi];
XOPa: CANCELBR[RMapFix,0], c2;
XOPb: T ← ~3, L2←L2.XProc, CANCELBR[$,0], c2;
T ← MD and T, GOTO[LGC], c3;
{ ********* New Procedure descriptor ********* }
XferProc3:
T ← T and ~3, ZeroBr, L2←L2.XProc, c2, at[0F,10,XferFrame];
rhTT ← GFTHi, BRANCH[XNPa,XNPb], c3;
XNPa: Map ← Q ← [rhTT, T], GOTO[LGCx], c1;
XNPb: T ← sUnbound, GOTO[UBTa], c1;
XAlloc: Map ← Q ← [rhMDS, T or ib], CALL[AllocSub], c1, XCoder[L2.XProc];
uPCCross ← 0, c3, Allocr[L2.XProc];
MAR ← Q ← [rhL, Q-LF.globalLink], c1;
MDR ← TOS, L ← Q + LF.globalLink, CANCELBR[$,0], c2;
UvL ← TT, Xbus ← rhT, XDisp, push, c3;
XPEnd: MAR ← [rhL,L-LF.returnLink], L2 ← 8, DISP4[XPTrap,8], c1;
XPTrap: MDR ← uSourceLo, CANCELBR[XTrap,0], c2, at[8,10,XPTrap];
XPCall: MDR ← uSourceLo, CANCELBR[XferDone,0], c2, at[0A,10,XPTrap];
XPRet: MDR ← uSourceLo, CANCELBR[XPFree,0], c2, at[0B,10,XPTrap];
XPCalI: MDR ← T ← uSourceLo, push, CANCELBR[XPSD,0], c2, at[0E,10,XPTrap];
XPRetI: MDR ← T ← uSourceLo, push, CANCELBR[XPSD,0], c2, at[0F,10,XPTrap];
XTrap: T ← UrG, ZeroBr, c3;
BRANCH[STPa, STPb], c1;
STPb: GOTO[XferDone], c2;
STPa: Noop, c2;
STPc: T ← T - 1, Ybus ← T, YDisp, c3;
MAR ← [rhL, L+T], DISP4[STPd], c1;
MDR ← uTrapParm0, CANCELBR[XferDone,0], c2, at[1,10,STPd];
MDR ← uTrapParm1, CANCELBR[STPc,0], c2, at[2,10,STPd];
MDR ← uTrapParm2, CANCELBR[STPc,0], c2, at[3,10,STPd];
XPSD: TT ← uDestLo, push, c3;
STK ← T, pop, L2Disp, c1;
STK ← TT, pop, BRANCH[XferDone,XPFree,0E], c2;
XPFree: Q ← 0FF, c3;
{map av item}
Free: Map ← [rhMDS, Q + 1], GOTO[XFRet], c1;
Freex: rhRx ← Rx ← MD, XWtOKDisp, c3;
{store new head, fetch old head}
MAR ← [rhRx,TT+0], L0←L0.Free, BRANCH[FreeMUD,FreeMOK,0D], c1;
MAR ← [rhRx,Q+0], BRANCH[XXXXX,XXXX,1], c1, WMFRet[L0.Free];
FreeMUD:
Q ← TT + Q + 1, GOTO[WMapFix], c2;
XXXXX: GOTO[XXXXX], c*;
XXXX: GOTO[FreeMO2], c2;
FreeMOK:
Q ← TT + Q + 1, c2;
FreeMO2:
T ← MD{old list head}, c3;
MAR ← [rhRx, Q+0], c1;
MDR ← Rx ← uFrame, c2;
Noop, c3;
{map old frame}
Map ← Q ← [rhMDS,Rx], c1;
L2Disp, c2;
rhRx ← Rx ← MD, BRANCH[$, FFb], c3;
{store old list head}
MAR ← [rhRx,Q+0], c1;
MDR ← T, c2;
XferDone:
TT ← RShift1 uXTS, XLDisp, c3;
XTail: uPCValid ← PC xor ~PC, BRANCH[$, XferTrap, 2], c1;
uXTS ← TT, IBDisp, GOTO[SLa], c2;
XferTrap:
TT ← TT LShift1, SE ← 1, uXTS ← TT, c2;
Rx ← uXferType, c3;
MAR ← [rhG, G-GF.word], c1;
T ← 30, CANCELBR[$,0], c2;
Xbus ← MD, XDisp, uTrapParm2 ← Rx, c3;
XTc: [] ← T and ~ErrnIBnStkp, ZeroBr, BRANCH[XTa, XTb, 0D], c1;
XTa: uXTS ← TT, IBDisp, CANCELBR[SLa,1], c2;
XTb: [] ← PC - PC16, PgCarryBr, pop, BRANCH[XTd, XTe], c2;
XTd: T ← sXferTrap, Cin←pc16, CANCELBR[XTg, 1], c3;
XTe: T ← sXferTrap, Cin←pc16, BRANCH[XTf, XTg], c3;
XTf: uPCCross ← TT xor ~TT, GOTO[XTh], c1;
XTg: GOTO[XTh], c1;
XTh: TT ← uDestHi, c2;
uTrapParm1 ← TT, c3;
TT ← uDestLo, c1;
uTrapParm0 ← TT, c2;
G ← 3, GOTO[Trapc1], c3;
{****************************************************************************
LoadGC subroutine:
Entry:
rhTT has GFTHi
T has gfi
Exit:
G, rhG, UvG, UvGhigh, UvC, UvChigh, PC, rhPC, UvPCpage set up
traps if page fault or odd codebase
returnee executed on c1
****************************************************************************}
LGC: Map ← Q ← [rhTT, T], c1;
LGCx: [] ← Q xor uGFI, ZeroBr, L0←L0.GFTRead, c2;
rhRx ← Rx ← MD, XRefBr, IBPtr ← 1, BRANCH[$,SameG], c3;
MAR ← [rhRx, Q+GFTE.codeLo], BRANCH[LGCa,LGCb], c1, RLMFRet[L0.GFTRead];
LGCa: CANCELBR[RLMapFix,0], c2;
LGCb: uTT ← PC ← TT, CANCELBR[$,0], c2;
T ← MD{low codebase}, XLDisp, uGFI ← T, c3;
MAR ← [rhRx, Q+GFTE.globalHi], BRANCH[$,CodeTrap,2], c1;
PC ← RShift1 PC, SE ← 0, ZeroBr, CANCELBR[$,0], c2;
rhTT ← TT ← MD{high global frame}, BRANCH[XCa,XCb], c3;
XCb: T ← sUnbound, GOTO[UBTa], c1;
XCa: MAR ← Rx ← [rhRx, Q+GFTE.globalLo], XC2npcDisp, c1;
UvGhigh ← TT, BRANCH[xcOdd,xcEven,0E], c2;
xcOdd: Q ← MD{low global frame}, GOTO[XMapG], c3;
xcEven: Q ← MD{low global frame}, Cin←pc16, GOTO[XMapG], c3;
XMapG: Map ← UvG ← [rhTT, Q], c1;
PC ← PC + T, c2;
G ← rhG ← MD, XRefBr, UvC ← T, c3;
LGCe: MAR ← [rhRx, Rx+GFTE.codeHi], BRANCH[LGCc,LGCd], c1;
LGCc: T ← qPageFault, CANCELBR[GMapFix,0], c2;
LGCd: T ← 0FF + 1, CANCELBR[$,0], c2;
rhTT ← TT ← MD{high codebase}, c3;
MAR ← G ← [rhG, Q+0], c1;
SGRet: UvChigh ← TT, L ← L + 1 {for frame links}, c2;
XCode: TT ← PC and ~0FF, L0←L0.XCode, c3;
Map ← UvPCpage ← [rhTT, TT], c1;
Q ← PC, Xbus ← ib, c2;
PC ← rhPC ← MD, XRefBr, c3;
MAR ← Q ← [rhPC, Q+0], Xbus ← uTT, XLDisp, BRANCH[XCd,XCe], c1, RMFRet[L0.XCode];
XCd: Rx ← PC, CANCELBR[RCMapFix,3], c2;
XCe: Rx ← uWDC, L2Disp, BRANCH[xcE,xcO,0E], c2;
xcE: IB ← MD, PC ← Q, Cin←pc16, RET[XCodeRtn], c3;
xcO: IB ← MD, PC ← Q, IBPtr←1, RET[XCodeRtn], c3;
SameG: rhTT ← UvChigh, XC2npcDisp, CANCELBR[$,1], c1, RLMFRet[L0.SameG];
uTT ← TT, BRANCH[sgOdd,sgEven,0E], c2;
sgOdd: PC ← UvC, GOTO[sg], c3;
sgEven: PC ← UvC, Cin←pc16, GOTO[sg], c3;
sg: TT ← RShift1 TT, ZeroBr, IBPtr ← 1, c1;
PC ← PC + TT, BRANCH[sgX,sgY], c2;
sgY: GOTO[UnboundTrap], c3;
sgX: T ← 0FF + 1, c3;
TT ← UvChigh, GOTO[SGRet], c1;
GMapFix:
Xbus ← G LRot0, XwdDisp, L3←L3.rhTT.Q, c3;
Map ← [rhTT, Q], DISP2[GMapa], c1;
GMapa: MDR ← G or map.referenced, GOTO[GMapb], c2, at[0,4];
MDR ← G or map.referenced, GOTO[GMapb], c2, at[1,4,GMapa];
MDR ← G or map.referenced, GOTO[GMapb], c2, at[2,4,GMapa];
uGFI ← 0, L1Disp, DISP4[RTrap], c2, at[3,4,GMapa];
GMapb: Xbus ← 1, XDisp, GOTO[LGCe], c3;
{****************************************************************************
Trap Handler:
Entry:
calling instruction on c1
UvL is valid for trapping frame
T has SD index;
Exit:
PC of UvL backed up by amount in rhT
rhT has xtTrap
goes to SDFetch
****************************************************************************}
CodeTrap:
T ← sCodeTrap, CANCELBR[$,0], c2;
TT ← uGFI, c3;
G ← 1, GOTO[THz], c1;
ControlTrap:
T ← sControlTrap, CANCELBR[$,0F], c1;
TT ← uSourceLo, c2;
G ← 1, GOTO[TH], c3;
UnboundTrap:
T ← sUnbound, CANCELBR[$,1], c1;
UBTa: TT ← uDestLo, c2;
Rx ← uDestHi, c3;
G ← 2, c1;
uTrapParm1 ← Rx, c2;
Noop, c3;
TH: Noop, c1;
THz: TOS ← UvL, L3←L3.XTrap, c2;
THa: Xbus ← rhT, XwdDisp, c3;
Map ← [rhMDS, TOS], DISP2[THb], c1;
THb: Q ← 0, GOTO[THc], c2, at[0,4,THb];
Q ← 1, GOTO[THc], c2, at[1,4,THb];
Q ← 2, GOTO[THc], c2, at[2,4,THb];
Q ← 3, GOTO[THc], c2, at[3,4,THb];
THc: L ← rhL ← MD, c3;
MAR ← L ← [rhL, TOS+0], c1;
Xbus ← rhT, XLDisp, c2;
uTrapParm0 ← TT, BRANCH[THx, THy, 1], c3;
THy: push, c1;
push, c2;
Noop, c3;
THx: MAR ← [rhL, L-LF.pc], c1;
Xbus ← rhT, XDisp, CANCELBR[$,0], c2;
PC ← MD, L3Disp, BRANCH[THd, THe, 7], c3;
TrapGo: uPCValid ← 0, CANCELBR[$], c3, SPCr[L2.TRAPSpc];
rhT ← xtTrap, T ← T + T + 1, GOTO[Trapping], c1;
THd: MAR ← [rhL, L-LF.pc], CANCELBR[$,1], c1;
MDR ← PC - Q, L3Disp, CANCELBR[$,0], c2;
uPCValid ← 0, BRANCH[$, XferFault], c3;
rhT ← xtTrap, T ← T + T + 1, c1;
Trapping:
UrG ← G, c2;
Rx ← XferType.trap, c3;
uGFI ← 0{disable SameG}, GOTO[KFCBa], c1;
FaultGo:
uPCValid ← 0, CANCELBR[$,1], c3, SPCr[L2.FAULTSpc];
XferFault:
Rx ← pFault, GOTO[SaveRegs], c1;
THe: Q ← uRetC, XC2npcDisp, L2←L2.TRAPSpc, BRANCH[THj, THk], c1;
THj: PC ← RShift1 UreturnPC, SE ← 0, XLDisp, BRANCH[THf, THg, 0E], c2;
THk: PC ← RShift1 UreturnPC, SE ← 0, XLDisp, BRANCH[THf, THg, 0E], c2;
THf: UvC ← Q, Cin←pc16, BRANCH[THh, THi, 2], c3;
THg: UvC ← Q, BRANCH[THh, THi, 2], c3;
THh: TT ← uRetPChi, GOTO[THl], c1;
THi: TT ← uRetPChi, Cin←pc16, GOTO[THl], c1;
THl: uGFI ← 0{disable SameG}, L1←0, GOTO[StashPC0], c2;
{****************************************************************************
Xfer Page Faults:
Entry:
push from R/WTrap
L3 tells where VA is;
Exit:
returns to Xfer's Trap handler
****************************************************************************}
XPF: Rx ← pFault, L3Disp, GOTO[XPFa], c1, at[L1.Xfer,10,RTrapFix];
Rx ← pFault, L3Disp, GOTO[XPFa], c1, at[L1.Xfer,10,RLTrapFix];
Rx ← pFault, L3Disp, GOTO[XPFa], c1, at[L1.Xfer,10,WTrapFix];
XPFa: TOS ← UvL, L3Disp, BRANCH[XPFb, XPFc, 2], c2;
XPFb: uFaultParm0 ← Q, BRANCH[XPFd, XPFe, 1], c3;
XPFc: uFaultParm0 ← TT, BRANCH[XPFd, XPFe, 1], c3;
XPFd: Q ← rhMDS, L3←L3.XFault, GOTO[XPFf], c1;
XPFe: Q ← rhTT, L3←L3.XFault, GOTO[XPFf], c1;
XPFf: uFaultParm1 ← Q, pop, GOTO[THa], c2;
{****************************************************************************
StashPC subroutine:
Entry:
calling instruction executed on c2 and includes:
TT ← UvPCpage, L1←n, goto[StashPCn]; {n = 0,1,2}
uPCCross is -1 if UvPCpage might be one too large, 0 if UvPCpage is OK
Link1 has PC increment in low two bits
Link2 has return index
Exit:
byte PC computed and stored in L+1
rhTT has UvGhigh
Rx has 0
TT and Q smashed
returnee executed on c3
****************************************************************************}
StashPC0: Q ← UvC, GOTO[StashPCa], c3;
StashPC1: Q ← UvC, GOTO[StashPCa], c3;
StashPC2: Q ← UvC, GOTO[StashPCa], c3;
StashPC3: Q ← UvC, GOTO[StashPCa], c3;
StashPCa: Rx ← 0, Xbus ← uPCCross, XRefBr, c1;
StashPCa1: Q ← TT - Q, L1Disp, BRANCH[StGood,StCross], c2;
StGood: TT ← 0FF and PC, BRANCH[StLT2, StEQ2, 1], c3;
StLT2: TT ← TT + Q, GOTO[StShift], c1;
StEQ2: TT ← TT + Q + 1, GOTO[StShift], c1;
StShift:
TT ← LShift1 TT, SE ← pc16, c2;
TT ← TT+1, L1Disp, GOTO[StashPCb], c3;
StashPCb:
MAR ← [rhL,L-LF.pc], L2Disp, BRANCH[St0, St1, 2], c1;
St0: MDR ← TT-1, rhTT ← UvGhigh, MesaIntBr, RET[SpcRtn], c2;
St1: MDR ← TT, rhTT ← UvGhigh, MesaIntBr, RET[SpcRtn], c2;
{page carry and uPCCross#0 => UvPCpage must be decremented}
StCross:
[] ← PC+1, PgCarryBr, CANCELBR[$, 3], c3;
Q ← UvC, BRANCH[StashPCa1,$], c1;
TT ← TT - 0FF - 1, c2;
uPCCross ← 0, GOTO[StashPCa], c3;
{****************************************************************************
GetLink subroutine:
Entry:
calling instruction executed on c1 and includes:
MAR ← [rhG, G.word]
T has 2*index + 3
rhTT has UvGhigh
Link2 has return index
Exit:
T and uDestHi have destination control link
L has caller frame
TOS saved in STK
TT and Q smashed
returnee executed on c1
****************************************************************************}
GetLink:
TT ← UvG, L1←L1.Xfer, CANCELBR[$,0], c2;
Rx ← Rx + 1, Xbus ← MD, XLDisp, STK ← TOS, pop, c3;
GLd: Map ← Q ← [rhTT, TT-T-1], BRANCH[GLFrame,GLCode,2], c1;
GLFrame:TT ← UvL, c2;
GLe: rhRx ← Rx ← MD, XRefBr, uXferType ← Rx, c3;
MAR ← [rhRx, Q+1], L0←L0.CLRead, BRANCH[$,GLa], c1, RLMFRet[L0.CLRead];
CANCELBR[RLMapFix,0], c2;
GLa: uSourceLo ← TT, CANCELBR[$,0], c2;
GLf: rhTT ← TT ← MD, c3;
MAR ← [rhRx, Q+0], L1←L1.Xfer, c1;
GLc: uDestHi ← TT, L2Disp, CANCELBR[$,0], c2;
T ← MD, XDisp, RET[GLRtn], c3;
GLCode:
{This code takes advantage of two facts:
1) UvC is always even (i.e. the LSB is 0);
2) DRShift1 and DLShift1 are not symmetric, so the shifted bit is inverted.
Thus TT acquires the value (UvC+1).}
TT ← DRShift1 UvC, c2;
rhTT ← UvChigh, TT ← DLShift1 TT, c3;
Map ← Q ← [rhTT, TT-T], GOTO[GLFrame], c1;
{****************************************************************************
Alloc subroutine:
Entry:
calling instruction executed on c1
Map fetch started on AV
Exit:
rhL set up
TOS has uGFI
Q, TT has new frame L (VA)
PC incremented for Xfer
returns through L2 relative to AllocRtn
returnee executed on c1
****************************************************************************}
AllocSub:
uFaultParm0 ← T ← Q, L0←L0.Alloc1, c2;
rhRx ← Rx ← MD, XWtOKDisp, c3;
Alloc1: MAR ← [rhRx, T+0], BRANCH[AllocMUD1,$,0D], c1, WMFRet[L0.Alloc1];
TOS ← uGFI, c2;
TT ← MD, XDisp, uRx ← Rx, c3;
Map ← Q ← [rhMDS, TT], DISP4[AV0,0C], c1;
AV0: PC ← PC + PC16, L0←L0.Alloc2, c2, at[0C,10,AV0];
rhL ← MD, L ← MD, XWtOKDisp, c3;
MAR ← [rhL, TT+0], BRANCH[AllocMUD2,$,0D], c1, WMFRet[L0.Alloc2];
Rx ← uRx, c2;
uTTemp ← TT, TT ← MD, c3;
MAR ← [rhRx, T+0], L2Disp, {Write AV} c1;
MDR ← TT, TT ← uTTemp, RET[AllocRtn] c2;
AV3: TT ← RShift1 TT, GOTO[AV2a], c2, at[0F,10,AV0];
AV2: TT ← RShift1 TT, GOTO[AV2a], c2, at[0E,10,AV0];
AV2a: T ← RShift1 TT, Xbus ← 2, XDisp, GOTO[Alloc1], c3;
AV1: T ← qFrameFault, c2, at[0D,10,AV0];
Q ← 0FF, L3←L3.rhMDS.Q, c3;
Q ← Q and uFaultParm0, push, L3Disp, GOTO[XPFa], c1;
AllocMUD1: GOTO[WMapFix], c2;
AllocMUD2: Rx ← L, GOTO[WMapFix], c2;
{****************************************************************************
XRead subroutine:
Entry:
calling instruction executed on c1 and includes:
Map ← Q ← [mumble]
Link2 has return index
Exit:
TT has memory data
XDisp pending on data in T
L1 smashed
returnee executed on c1
****************************************************************************}
XRead: Noop, c2;
XReadx: rhRx ← Rx ← MD, XRefBr, c3;
XReady: MAR ← [rhRx,Q+0], BRANCH[XRMUD,$], c1, RMFRet[L0.XRead];
XReadz: L2Disp, CANCELBR[$,0], c2;
TT ← MD, LOOPHOLE[mdok], RET[XRRtn], c3;
XRMUD: GOTO[RMapFix], c2;
{****************************************************************************
XMDSWrite subroutine:
Entry:
calling instruction executed on c1 and includes:
Map ← Q ← [mumble]
T has memory data
Link2 has return index
Exit:
returnee executed on c3
****************************************************************************}
XWrite: L0←L0.XWrite, c2;
XWritex:
rhRx ← Rx ← MD, XWtOKDisp, c3;
MAR ← [rhRx,Q+0], L2Disp, BRANCH[XWMUD,$,0D], c1, WMFRet[L0.XWrite];
MDR ← T, RET[XWRtn], c2;
XWMUD: Noop, CANCELBR[WMapFix, 0F], c2;