github.com/livingcomputermuseum.Darkstar
1
0
Fork 0
mirror of https://github.com/livingcomputermuseum/Darkstar.git synced 2026-03-06 11:34:33 +00:00
Code Issues Releases Wiki Activity
Files
master
livingcomputermuseum.Darkstar/D/CP/Source/ProcListXfer.mc,v
Josh Dersch bb52985dea Adding CP microcode and IOP 8085 sources.
2023-09-27 16:17:41 -07:00

39 lines
34 KiB
Plaintext
Raw Permalink Blame History

head 1.1;
branch 1.1.1;
access ;
symbols start:1.1.1.1 Xerox:1.1.1;
locks ; strict;
comment @# @;
1.1
date 2001.08.12.22.22.25; author freier; state Exp;
branches 1.1.1.1;
next ;
1.1.1.1
date 2001.08.12.22.22.25; author freier; state Exp;
branches ;
next ;
desc
@@
1.1
log
@Initial revision
@
text
@{File name: ProcListXfer.mc
Description: Xfer and related opcodes,
Copyright (C) 1981, 1982, 1983, 1987 by Xerox Corporation. All rights reserved.
RDH 20-Nov-87 16:35:45 Rename xcO and xcE to xcOdd2 and xcEven2. Add comments to LGC routine. Fix another ProcList problem to wit, don't do anything special at xcOdd2 when the PC is on the last byte of a page and the control link is of type frame. The last byte might be a RET and we are safe from the previous bug fixed in the frame case.
AHL/RDH 2-Nov-87 10:17:54 Another ProcList fix at xcO. Add conditional assembly of ProcList and non ProcList versions.
RDH 21-Sep-87 15:09:10 Re-inserted uGFI ¬ 0 at THl.
RDH 21-Sep-87 13:39:44 Insert this line for AHL who added uGFI ¬ 0 at TrapGo and removed it at THl for Mysterious MDS relief crash fix.
AHL 21-Sep-87 13:43:49 MDS relief (this line by RDH).
DEG 1-Sep-84 19:57:28 Add copyright notice.
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 Jim JXF February 11, 1981 1:54 PM: catch KFCB for Block Equal
Created by R. RXJ }
{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 ¬ 1, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[337'b];
@@EFC1: T ¬ 3, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[340'b];
@@EFC2: T ¬ 5, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[341'b];
@@EFC3: T ¬ 7, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[342'b];
@@EFC4: T ¬ 9, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[343'b];
@@EFC5: T ¬ 0B, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[344'b];
@@EFC6: T ¬ 0D, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[345'b];
@@EFC7: T ¬ 0F, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[346'b];
@@EFC8: T ¬ 11, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[347'b];
@@EFC9: T ¬ 13, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[350'b];
@@EFC10: T ¬ 15, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[351'b];
@@EFC11: T ¬ 17, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[352'b];
@@EFC12: T ¬ 19, L2¬L2.EFCnSpc, GOTO[EFCn], c1, opcode[353'b];
EFCn: TT ¬ UvPCpage, push, L1¬1, CALL[StashPC1], c2;
rhT ¬ xtFC1, T ¬ T + 1, GOTO[EFCGetLink], c3, SPCr[L2.EFCnSpc];
{****************************************************************************
EFCB - External Function Call Byte
****************************************************************************}
@@EFCB: T ¬ LShift1 ib, SE ¬ 1, c1, opcode[354'b];
TT ¬ UvPCpage, L1¬2, push, c2;
Q ¬ UvC, L2¬L2.EFCBSpc, GOTO[StashPCa], c3;
rhT ¬ xtFC2, T ¬ T + 1, STK ¬ TOS, c3, SPCr[L2.EFCBSpc];
EFCGetLink:
MAR ¬ [rhG, G-GF.word], GOTO[GetLink], L2¬L2.EFCLink, 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, c3, SPCr[L2.LFCSpc];
uSourceLo ¬ T, c1;
Rx ¬ XferType.lfc, c2;
IfEqual[ProcList, TRUE, Continue, SkipTo[NoProcList2]];
{ IF ProcList THEN }
uXferType ¬ Rx, T ¬ Rx + 1, c3;
TT ¬ ib, pop, c1;
TT ¬ TT LRot8, L2¬L2.XProc, c2;
TT ¬ TT or ib, c3;
uDestHi ¬ TT, c1;
T ¬ uGFI or T {3}, c2;
uDestLo ¬ T, GOTO[SameG], c3;
IfEqual[ProcList, TRUE, SkipTo[DoneProcListDiff2], Continue];
NoProcList2!
{ ELSE }
uXferType ¬ Rx, c3;
TT ¬ ib, pop, c1;
TT ¬ TT LRot8, L2¬L2.XProc, c2;
TT ¬ TT or ib, GOTO[SameG], c3;
DoneProcListDiff2!
{ ENDIF }
{****************************************************************************
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, 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, 0E], 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-1, CANCELBR[$,0], LOOPHOLE[stw], c2;
T ¬ T + T, 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, 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;
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, 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, XDirtyDisp, c3;
MAR ¬ [rhRx, Q-LF.word], BRANCH[FFMUD,$,1], 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, c1, at[0,10,ESC1n];
T ¬ T+1, PgCarryBr, c2;
DIc: uWDC ¬ T, BRANCH[DIa, DIb], c3;
DIa: GOTO[IBDispOnly], c1;
DIb: T ¬ sInterruptError, GOTO[Trapc2], c1;
{****************************************************************************
EI - Enable Interrupts
****************************************************************************}
@@EI: T ¬ uWDC, c1, at[1,10,ESC1n];
T ¬ T - 1, NegBr, GOTO[DIc], c2;
{****************************************************************************
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, 0E], 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, push, L2¬L2.DSKLoop, c3;
DSKh: Map ¬ Q ¬ [rhMDS, Q - 1], BRANCH[DSKd, DSKe], c1;
DSKd: T ¬ STK, pop, CALL[XWritex], c2;
TT ¬ TT - 1, ZeroBr, GOTO[DSKh], c3, XWr[L2.DSKLoop];
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[Xa], c3;
{****************************************************************************
XE - XFER and Enable
****************************************************************************}
@@XE: T ¬ uWDC, c1, at[1,10,ESC2n];
rhT ¬ xtX, T ¬ T - 1, c2;
uWDC ¬ T, L2¬L2.XSpc, c3;
Xa: PC ¬ PC - 1, c1;
TT ¬ UvPCpage, L1¬3, CALL[StashPC3], c2;
Ufsi ¬ T, 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 ********* }
rhTT ¬ GFTHi, Ybus ¬ Q, ZeroBr, c2, at[0C,10,XferFrame];
rhL ¬ L ¬ MD, XDirtyDisp, BRANCH[$, ControlTrap], c3;
MAR ¬ [rhL, Q-LF.pc], BRANCH[XFMUD,XFMOK,1], c1;
MAR ¬ [rhL, Q-LF.pc], BRANCH[XFMUD,XFMOK,1], c1, WMFRet[L0.Xfer];
XFMUD: Rx ¬ L, CANCELBR[WMapFix, 0], c2;
XFMOK: T ¬ UvL, CANCELBR[$, 0], c2;
TT ¬ MD, uFrame ¬ T, L2¬L2.XFrame, { get pc } c3;
MAR ¬ L ¬ [rhL, Q-LF.globalLink], { fix L later } c1;
TOS ¬ Q, CANCELBR[$,0], c2;
T ¬ MD, GOTO[LGC], { get global link } c3;
UvL ¬ TOS, c1, XCoder[L2.XFrame];
uPCCross ¬ T {should really be 0}, L ¬ L + 1, c2;
Q ¬ T-1, Xbus ¬ rhT, XDisp, c3;
Map ¬ [rhMDS, T], L2 ¬ 8, push, DISP4[XFTrap,8], c1;
XFTrap: Rx ¬ Rx + 1, c2, at[08,10,XFTrap];
uWDC ¬ Rx, GOTO[XPEnd], c3;
XFCall: GOTO[XferDone], c2, at[0A,10,XFTrap];
XFRet: TT ¬ Ufsi and Q, 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], BRANCH[XOPa,XOPb], L0¬L0.XGfi, c1, RMFRet[L0.XGfi];
XOPa: CANCELBR[RMapFix,0], c2;
XOPb: T ¬ ~3, CANCELBR[$,0], L2¬L2.XProc, 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[08,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], L2¬0, c1;
TT ¬ Ufsi and Q, c2;
Freex: rhRx ¬ Rx ¬ MD, XDirtyDisp, c3;
{store new head, fetch old head}
MAR ¬ [rhRx,TT+0], L0¬L0.Free, BRANCH[FreeMUD,FreeMOK,1], c1;
MAR ¬ [rhRx,Q+0], BRANCH[FreeMUD,FreeMOK,1], c1, WMFRet[L0.Free];
FreeMUD:
Q ¬ TT + Q + 1, GOTO[WMapFix], c2;
FreeMOK:
MDR ¬ Rx ¬ uFrame, c2;
T ¬ MD{old list head}, c3;
{Dicentra:
Noop, c3;
MAR ¬ [rhRx, TT+0], c1;
Noop, c2;
T ¬ MD, c3;
}
{map old frame}
Map ¬ Q ¬ [rhMDS,Rx], c1;
L2Disp, c2;
rhRx ¬ Rx ¬ MD, BRANCH[$, FFb, 0E], 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 ¬ T xor ~T, 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
TT has princops PC of new context
Exit:
G, rhG, UvG, UvGhigh, UvC, UvChigh, PC, rhPC, PC16, UvPCpage, uGFI set up
traps if page fault or odd codebase
returnee executed on c1
****************************************************************************}
LGC: Map ¬ Q ¬ [rhTT, T], {Q ¬ virtual ptr to GFT entry} c1;
LGCx: Ybus ¬ Q xor uGFI, ZeroBr, L0¬L0.GFTRead,{Check for intra-module xfer} c2;
Rx ¬ rhRx ¬ 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 {Convert to word offset}, SE ¬ 0, ZeroBr,
CANCELBR[$,0], c2;
rhTT ¬ TT ¬ MD {GF.high}, 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 {GF.low}, GOTO[XMapG], {pc16 already odd} c3;
xcEven: Q ¬ MD {GF.low}, Cin¬pc16, GOTO[XMapG], {Force pc16 odd} c3;
XMapG: Map ¬ UvG ¬ [rhTT, Q], c1;
PC ¬ PC + T {PC ¬ word addr low of point of execution}, c2;
G ¬ rhG ¬ MD {Cached real GF.high}, 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 {CB.high}, c3;
MAR ¬ G ¬ [rhG, Q+0], {side effect sets up G} c1;
SGRet: UvChigh ¬ TT, L ¬ L + 1 {for frame links}, c2;
XCode: TT ¬ PC and ~0FF, L0¬L0.XCode, {Zap low byte of code addr low} c3;
Map ¬ UvPCpage ¬ [rhTT, TT], {Set UvPCpage} c1;
Q ¬ PC {word addr of execution point}, Xbus ¬ ib {Clear ib}, c2;
PC ¬ rhPC ¬ MD, XRefBr, {cached real code page high} c3;
MAR¬Q¬[rhPC,Q+0] {side effect sets Q to cached real code pointer},
Xbus¬uTT, XLDisp, BRANCH[XCd, XCe], c1, RMFRet[L0.XCode];
XCd: Rx ¬ PC, CANCELBR[RCMapFix, 3], c2;
XCe: Rx ¬ uWDC, BRANCH[xcEven2, xcOdd2, 2], L2Disp, c2;
xcEven2:
IB ¬ MD, PC ¬ Q, Cin¬pc16, RET[XCodeRtn], c3;
IfEqual[ProcList, TRUE, Continue, SkipTo[NoProcList1]];
{ IF ProcList THEN }
xcOdd2: IB ¬ MD, PC ¬ Q, IBPtr¬1, DISP4[FrameOrProc, 8],{ProcList} c3;
{Check for exotic case of fsi on last byte of page and next page vacant and procedure variable}
{If so then page fault on the next page}
{Maybe we should check if we are going to xfer trap but not right now}
{The consequences of checking here for the next page are that faults of various sorts may not occur in the same order as they otherwise would. For example if this xfer would have caused a frame fault, then the frame fault will occur after the page fault whereas in non proc list mode the page fault comes before. I believe this is harmless.}
Noop, at[L2.XFrame, 10, FrameOrProc], {ProcList} c1;
TT ¬ TT + 0FF + 1, L2Disp, GOTO[xcNoProblem], {ProcList} c2;
xcWrongL2:
{Assert that we never come here because L2 is either L2.XProc or L2.XFrame.}
Noop, GOTO[xcHang], at[8, 10, FrameOrProc], {ProcList} c1;
Noop, GOTO[xcHang], at[9, 10, FrameOrProc], {ProcList} c1;
Noop, GOTO[xcHang], at[0B, 10, FrameOrProc], {ProcList} c1;
Noop, GOTO[xcHang], at[0C, 10, FrameOrProc], {ProcList} c1;
Noop, GOTO[xcHang], at[0E, 10, FrameOrProc], {ProcList} c1;
Noop, GOTO[xcHang], at[0F, 10, FrameOrProc], {ProcList} c1;
xcHang: Noop, c2;
GOTO[xcWrongL2], c3;
{pc16 is odd so if PC = FF then we are indeed on the last byte of a page.}
{If we have come to this point then we know that we have a (new or old) procedure variable control link.}
[] ¬ PC + 1, PgCarryBr, at[L2.XProc, 10, FrameOrProc],{ProcList}c1;
TT ¬ TT + 0FF + 1, L2Disp, BRANCH[xcNoProblem, xcCheckNextPage],c2;
xcNoProblem:
TT ¬ TT - 0FF - 1, RET[XCodeRtn], {ProcList} c3;
xcCheckNextPage:
Noop, CANCELBR[$, 0F], {ProcList} c3;
Map ¬ [rhTT, TT], {ProcList} c1;
Noop, {ProcList} c2;
Q ¬ MD, XwdDisp, {ProcList} c3;
DISP2[xcCheckNext], {ProcList} c1;
GOTO[xcNoProblem], L2Disp, {ProcList} at[0,4,xcCheckNext], c2;
GOTO[xcNoProblem], L2Disp, {ProcList} at[1,4,xcCheckNext], c2;
GOTO[xcNoProblem], L2Disp, {ProcList} at[2,4,xcCheckNext], c2;
Rx ¬ Q, GOTO[RCMapFix], {ProcList} at[3,4,xcCheckNext], c2;
IfEqual[ProcList, TRUE, SkipTo[DoneProcListDiff1], Continue];
NoProcList1!
{ ELSE }
xcOdd2: IB ¬ MD, PC ¬ Q, IBPtr¬1, RET[XCodeRtn], {Normal} c3;
DoneProcListDiff1!
{ ENDIF }
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 10, GOTO[GMapb], c2, at[0,10];
MDR ¬ G or 10, GOTO[GMapb], c2, at[1,10,GMapa];
MDR ¬ G or 10, GOTO[GMapb], c2, at[2,10,GMapa];
uGFI ¬ 0, L1Disp, DISP4[RTrap], c2, at[3,10,GMapa];
GMapb: Xbus ¬ 1, XDisp, GOTO[LGCe], c3, at[0,10,GMapb];
{****************************************************************************
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: {TT already has parameter}
T ¬ sCodeTrap, CANCELBR[TH2,0], c2;
TH2: TT ¬ uGFI, c3;
G ¬ 1, GOTO[THz], c1;
ControlTrap:
T ¬ sControlTrap, CANCELBR[$,3], c1;
TT ¬ uSourceLo, c2;
TH1: 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, XRefBr, CANCELBR[$,0], c2;
PC ¬ MD, L3Disp, BRANCH[THd, THe], c3;
THd: MAR ¬ [rhL, L-LF.pc], CANCELBR[$,1], c1;
MDR ¬ PC - Q, L3Disp, CANCELBR[$,0], c2;
TrapGo: uPCValid ¬ 0, BRANCH[$, XferFault], c3, SPCr[L2.TRAPSpc];
rhT ¬ xtTrap, T ¬ T + T + 1, c1;
UrG ¬ G, c2;
Rx ¬ XferType.trap, c3;
uGFI ¬ 0{disable SameG}, GOTO[KFCBa], c1;
FaultGo:
uPCValid ¬ 0, CANCELBR[$,0], 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, 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 small, 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, RET[SpcRtn], c2;
St1: MDR ¬ TT, rhTT ¬ UvGhigh, RET[SpcRtn], c2;
{no page carry and uPCCross#0 => UvPCpage must be advanced}
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 + 2
rhTT has UvGhigh
Rx has XferType-1
Link2 has return index
Exit:
T and uDestHi has destination control link
L has caller frame
TOS saved in STK
TT and Q smashed
returnee executed on c1
****************************************************************************}
GetLink:
TT ¬ UvG-1, L1¬L1.Xfer, CANCELBR[$,0], LOOPHOLE[stw], 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:
TT ¬ UvC, c2;
rhTT ¬ UvChigh, 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 UvG
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, XDirtyDisp, c3;
Alloc1: MAR ¬ [rhRx, T+0], BRANCH[AllocMUD1,$,1], 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, XDirtyDisp, c3;
MAR ¬ [rhL, TT+0], BRANCH[AllocMUD2,$,1], 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, XDirtyDisp, c3;
MAR ¬ [rhRx,Q+0], L2Disp, BRANCH[XWMUD,$,1], c1, WMFRet[L0.XWrite];
MDR ¬ T, RET[XWRtn], c2;
XWMUD: Noop, CANCELBR[WMapFix, 0F], c2;
@
1.1.1.1
log
@first add
@
text
@@
Reference in New Issue View Git Blame Copy Permalink