{File name:  Kiku2MXfer.mc
 Description: Xfer and related opcodes,
I. Yamaura  1-Nov-84 10:47:51 Change for 2M word at {+++}
Daniels 25-Oct-83 18:30:07 Rearrange LFC so that uXferType isn't at fZ = _ib.
Daniels 22-Sep-83 15:06:44 Don't use TOS in GLFrame.
Daniels 17-Jun-83 12:03:30 new instruction set
Johnsson  3-Aug-83 11:18:00
Sandman March 5, 1982  12:02 PM Disable same G after RET trap fix
Sandman January 26, 1982  4:00 PM XferTraps vs disabled for module
Sandman January 22, 1982 XferTraps vs fsi last of page
Sandman November 17, 1981  10:35 AM New Instruction Set
Last edited by Jim Frandeen February 11, 1981  1:54 PM: catch KFCB for Block Equal
Created by R. Johnsson }

{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.LGCEVAlloc,0D]; {must be odd; same as XCode, AllocSub}


{AllocSub returns - Link 2}
MacroDef[Allocr, at[#1,10,AllocRtn]];
Set[L2.LGCEVAlloc,0D]; {must be odd; same as XCode, LoadGC}
Set[L2.AF,0C];

{XCode returns - Link 2}
MacroDef[XCoder, at[#1,10,XCodeRtn]];
Set[L2.LGCEVAlloc,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];{Same as L1.Xfer}

{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 _ 0, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[337'b];
@EFC1:	T _ 1, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[340'b];
@EFC2:	T _ 2, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[341'b];
@EFC3:	T _ 3, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[342'b];
@EFC4:	T _ 4, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[343'b];
@EFC5:	T _ 5, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[344'b];
@EFC6:	T _ 6, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[345'b];
@EFC7:	T _ 7, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[346'b];
@EFC8:	T _ 8, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[347'b];
@EFC9:	T _ 9, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[350'b];
@EFC10:	T _ 0A, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[351'b];
@EFC11:	T _ 0B, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[352'b];
@EFC12:	T _ 0C, L2_L2.EFCnSpc, GOTO[EFCn],		c1, opcode[353'b];

EFCn:	TT _ UvPCpage, push, L1_1, CALL[StashPC1],			c2;
	rhT _ xtFC1, T _ T + T + 1, GOTO[EFCGetLink],	c3, SPCr[L2.EFCnSpc];

{****************************************************************************
	EFCB - External Function Call Byte
****************************************************************************}
@EFCB:	T _ ib, L2_L2.EFCBSpc,					c1, opcode[354'b];
	TT _ UvPCpage, L1_2, push, CALL[StashPC2],			c2;
	rhT _ xtFC2, T _ T + T + 1,			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;
	uXferType _ Rx,							c3;
	
	PC _ ib, pop,							c1;
	PC _ PC LRot8,							c2;
	Noop,								c3;

	TT _ ib, L2_L2.LGCEVAlloc,					c1;
	T _ UvC, L1_L1.Xfer,						c2;
	uDestHi _ PC _ TT or PC, XC2npcDisp, GOTO[XCode],		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,			c3, SPCr[L2.SFCSpc];

	Rx _ XferType.call,						c1;
	uXferType _ Rx, pop,						c2;
	TT _ UvL,							c3;
	
	uSourceLo _ TT, pop,						c1;
	uDestHi _ TT _ Q, pop,						c2;
SFCa:	uDestLo _ T, YDisp, L1_L1.Xfer, 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, push, L2_L2.LLKBLink,				c1, opcode[167'b];
	STK _ TOS, push, PC _ PC + 1, L1_L1.Pop2Dec2, 			c2;
LLKBa:	rhTT _ UvChigh,							c3;

	MAR _ [rhG,G-GF.word],						c1;
	TT _ UvC, 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, 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, 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, XwdDisp,			c3;			{+++ Change for 2M +++}

	MAR _ [rhRx, Q-LF.word], DISP2[FFMUD],		c1, WMFRet[L0.FF];	{+++ Change for 2M +++}
	Q _ 0FF, CANCELBR[$,0],				c2,at[1,4,FFMUD];	{+++ Change for 2M +++}
	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,at[0,4,FFMUD];	{+++ Change for 2M +++}
	CANCELBR[WMapFix,0],				c2,at[2,4,FFMUD];	{+++ Change for 2M +++}
	CANCELBR[WMapFix,0],				c2,at[3,4,FFMUD];	{+++ Change for 2M +++}


{****************************************************************************
	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],				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:
	Udest and T 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 entera at one of:
		XferFrame, XferProc1, XferIndirect, XferProc3
****************************************************************************}
XFER:	Map_Q_[rhMDS,T], uDestLo_T, DISP4[XferFrame,0C],    c1, GLr[L2.EFCLink];


{ ********* Frame link ********* }
XferFrame:
	TOS _ Q, L0_L0.Xfer, ZeroBr,			c2, at[0C,10,XferFrame];
	L _ MD, rhL _ MD, XwdDisp, BRANCH[$, ControlTrap],	c3;	{+++ Change for 2M +++}

XFStartRead:
	MAR _ [rhL, Q-LF.globalLink], DISP2[XFMUD],c1;			{+++ Change for 2M +++}
	MAR _ [rhL, Q-LF.globalLink], DISP2[XFMUD],c1,WMFRet[L0.Xfer];	{+++ Change for 2M +++}
XFMUD:	Rx _ L, CANCELBR[WMapFix, 0],		c2,at[0,4,XFMUD];	{+++ Change for 2M +++}
	Rx _ L, CANCELBR[WMapFix, 0],		c2,at[2,4,XFMUD];	{+++ Change for 2M +++}
	Rx _ L, CANCELBR[WMapFix, 0],		c2,at[3,4,XFMUD];	{+++ Change for 2M +++}

XFMOK:	T _ UvL, CANCELBR[$, 0],		c2,at[1,4,XFMUD];	{+++ Change for 2M +++}
	TT _ MD, uFrame _ T,						c3;

	Map _ Q _ [rhMDS, TT],						c1;
	Ybus _ Q xor UvG, ZeroBr, L2_L2.LGCFrame,			c2;
	G _ rhG _ MD, XRefBr, BRANCH[$,SameG],				c3;

	MAR _ [rhG,Q-GF.codeLow], L0_L0.LGCRead, BRANCH[LGCa,LGCb],	c1, RMFRet[L0.LGCRead];

SameG:	MAR _ G _ [rhG, Q+0], CANCELBR[$,1],		c1, RMFRet[L0.LGCSameG];
	T _ UvC,							c2;
	rhTT _ TT _ UvChigh,						c3;

	MAR _ L _ [rhL,TOS-LF.pc], L2_L2.XFrame,	c1, LGCr[L2.LGCFrame];
	L _ L + LF.pc, CANCELBR[$,0],					c2;
	PC _ MD, XC2npcDisp, UvChigh _ TT, CALL[XCode],			c3;

	UvL _ TOS,					c1, XCoder[L2.XFrame];
	uPCCross _ 0,							c2;
	Q _ T - 1, Xbus _ rhT, XDisp,					c3;

	Map _ [rhMDS, Q + 1], L2_0, push, DISP3[XFTrap],		c1;
XFTrap:	Rx _ Rx + 1,					c2, at[0,8,XFTrap];
	uWDC _ Rx, GOTO[XPEnd],						c3;
XFRet:	TT _ Ufsi and Q, L2_0, GOTO[Freex,0],		c2, at[3,8,XFTrap];
XFCall:	GOTO[XferDone],					c2, at[2,8,XFTrap];
XFRetI:	T _ uSourceLo, push, GOTO[XPSD],		c2, at[7,8,XFTrap];
XFCalI:	T _ uSourceLo, push, GOTO[XPSD],		c2, at[6,8,XFTrap];

{ ********* Indirect link ********* }
XferIndirect:
	T _ rhT,					c2, at[0E,10,XferFrame];
	T _ T or 4, L2_L2.XIndirect,					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;



{ ********* Procedure descriptor ********* }
XferProc:
	Q _ T-1, ZeroBr, GOTO[XProc], L2_L2.LGCEVAlloc,	c2, at[0D,10,XferFrame];
	Q _ T-1, ZeroBr, GOTO[XProc], L2_L2.LGCEVAlloc,	c2, at[0F,10,XferFrame];

XProc:	rhG _ G _ MD, XRefBr, uTT _ TT, BRANCH[$, UnboundTrap],		c3;

	MAR _ [rhG,Q-GF.codeLow], L0_L0.LGCRead, BRANCH[LGCa,LGCb],	c1;

	UvChigh _ TT,					c1, LGCr[L2.LGCEVAlloc];
	PC _ uTT,							c2;
	XC2npcDisp, GOTO[XCode],					c3;

XAlloc:	Map_Q_[rhMDS, T or ib], CALL[AllocSub],	c1, XCoder[L2.LGCEVAlloc];

	uPCCross _ 0,				c3, Allocr[L2.LGCEVAlloc];

	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 _ 0, DISP3[XPTrap],		c1;
XPTrap:	MDR _ uSourceLo, CANCELBR[XTrap,0],		c2, at[0,8,XPTrap];
XPRet:	MDR _ uSourceLo, CANCELBR[XPFree,0],		c2, at[3,8,XPTrap];
XPCall:	MDR _ uSourceLo, CANCELBR[XferDone,0],		c2, at[2,8,XPTrap];
XPRetI:	MDR _ T _ uSourceLo, push, CANCELBR[XPSD,0],	c2, at[7,8,XPTrap];
XPCalI:	MDR _ T _ uSourceLo, push, CANCELBR[XPSD,0],	c2, at[6,8,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, XwdDisp,			c3;		{+++ Change for 2M +++}

	{store new head, fetch old head}
	MAR _ [rhRx,TT+0], DISP2[FreeMUD],		c1;		{+++ Change for 2M +++}
	MAR _ [rhRx,Q+0], DISP2[FreeMUD],	c1, WMFRet[L0.Free];	{+++ Change for 2M +++}
FreeMUD:
	Q _TT+Q+1, GOTO[WMapFix3],L0_L0.Free,	c2,at[0,4,FreeMUD];	{+++ Change for 2M +++}
	Q _TT+Q+1, GOTO[WMapFix3],L0_L0.Free,	c2,at[2,4,FreeMUD];	{+++ Change for 2M +++}
	Q _TT+Q+1, GOTO[WMapFix3],L0_L0.Free,	c2,at[3,4,FreeMUD];	{+++ Change for 2M +++}

FreeMOK:
	MDR _ Rx _ uFrame,			c2,at[1,4,FreeMUD];	{+++ Change for 2M +++}
	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],					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;

{****************************************************************************
Xfer Code:
    Entry:
	T has UvC
	TT has UvChigh
	Fetch pending on PC
    Exit:
	PC has real PC
	IB has first byte(s) of code
	UvChigh, UvC stored
	UrhPCsave has byte PC
****************************************************************************}
XCode:	TT _ RShift1 PC, ZeroBr, BRANCH[xcOdd, xcEven, 0E],		c1;
xcOdd:	Q _ TT + T, IBPtr_1, BRANCH[XCa, XCb],				c2;
xcEven:	Q _ TT + T, IBPtr_1, Cin_pc16, BRANCH[XCa, XCb],		c2;
XCa:	TT _ Q and ~0FF, L0_L0.XCode,					c3;

	Map _ UvPCpage _ [rhTT, TT], Xbus _ ib,				c1;
	T _ 0FF + 1,							c2;
	PC _ rhPC _ MD, XRefBr, UrhPCsave _ PC,				c3;

	MAR_Q_[rhPC,Q+0], Xbus_UrhPCsave, XLDisp, BRANCH[XCd, XCe],	c1, RMFRet[L0.XCode];
XCe:	Rx _ uWDC, BRANCH[xcE, xcO, 2], L2Disp,				c2;
xcE:	IB _ MD, PC _ Q, Cin_pc16, RET[XCodeRtn],			c3;
xcO:	IB _ MD, PC _ Q, IBPtr_1, RET[XCodeRtn],			c3;

XCd:	Rx _ PC, CANCELBR[RCMapFix, 3],					c2;
XCb:	GOTO[UnboundTrap],						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: {TT already has parameter}
	T _ sCodeTrap, CANCELBR[TH1,0],					c2;
	
ControlTrap:
	T _ sControlTrap, CANCELBR[$,3],				c1;
	TT _ uSourceLo,							c2;
TH1:	G _ 1, GOTO[TH],						c3;
	
UnboundTrap:
	T _ sUnbound, CANCELBR[$,1],					c1;
	TT _ uDestLo,							c2;
	Rx _ uDestHi,							c3;

	G _ 2,								c1;
	uTrapParm1 _ Rx,						c2;
	Noop,								c3;

TH:	Noop,								c1;
	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;

	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:	UvG _ 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;


{****************************************************************************
LoadGC subroutine:
    Entry:
	preceeding two instructions are:
		Map_Q_[rhMDS,globalFrameAddr], L2_ret, c1;
		[] _ Q xor UvG, NZeroBr, L1_L1w.XFWFault, GOTO[LoadGC], c2;
    Exit:
	T saved in uPsbLink
	G, rhG, UvG set up
	T has low 16 bits of codebase; stored in UvC
	rhTT and TT have high bits of codebase (to be stored in UvChigh)
	traps if page fault or odd codebase
	returnee executed on c1
****************************************************************************}

LGCa:	Rx _ G{map word}, CANCELBR[RMapFix,0],				c2;

LGCb:	TT _ Q, CANCELBR[$,0],						c2;
	T _ MD{low codebase}, XLDisp,					c3;

LGCHi:	MAR _ G _ [rhG, TT-GF.codeHi], BRANCH[$,CodeTrap,2],		c1;
	G _ G + GF.codeHi, UvC _ T, L2Disp, CANCELBR[$,0],		c2;
	rhTT _ TT _ MD, UvG _ TT, RET[LGCRtn],			c3; 

{****************************************************************************
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 UvChigh
	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 _ UvChigh, RET[SpcRtn],			c2;
St1:	MDR _ TT, rhTT _ UvChigh, 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]
	T has link index
	rhTT has UvChigh
	Link2 has return index
    Exit:
	T has destination control link
	L has caller frame
	TOS saved in STK
	TT and Q smashed
	returnee executed on c1
****************************************************************************}

GetLink:
	TT _ UvC, 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;
GLCode:	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;

GLFrame:
	Q _ T + 4,							c2;
	TT _ UvG,							c3;

	Map _ Q _ [rhMDS, TT-Q-1],					c1;
	TT _ UvL,							c2;
	rhRx _ Rx _ MD, XRefBr, uXferType _ Rx,				c3;

	MAR _ [rhRx, Q+1], L0_L0.CLRead, BRANCH[$,GLb],	c1, RMFRet[L0.CLRead];
	CANCELBR[RMapFix,0],						c2;

GLb:	uSourceLo _ TT, CANCELBR[GLf,0],				c2;


{****************************************************************************
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, XwdDisp,			c3;		{+++ Change for 2M +++}

Alloc1:	MAR _ [rhRx, T+0], DISP2[AllocMUD1],	c1, WMFRet[L0.Alloc1];	{+++ Change for 2M +++}
	TOS _ UvG,				c2,at[1,4,AllocMUD1];	{+++ Change for 2M +++}
	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, XwdDisp,			c3;		{+++ Change for 2M +++}

	MAR _ [rhL, TT+0], DISP2[AllocMUD2],	c1, WMFRet[L0.Alloc2];	{+++ Change for 2M +++}
	Rx _ uRx,				c2,at[1,4,AllocMUD2];	{+++ Change for 2M +++}
	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 _ 1, XDisp, GOTO[Alloc1],			c3;		{+++ Change for 2M +++}

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,at[0,4,AllocMUD1];	{+++ Change for 2M +++}
	   GOTO[WMapFix],			c2,at[2,4,AllocMUD1];	{+++ Change for 2M +++}
	   GOTO[WMapFix],			c2,at[3,4,AllocMUD1];	{+++ Change for 2M +++}

AllocMUD2: Rx _ L, GOTO[WMapFix],		c2,at[0,4,AllocMUD2];	{+++ Change for 2M +++}
	   Rx _ L, GOTO[WMapFix],		c2,at[2,4,AllocMUD2];	{+++ Change for 2M +++}
	   Rx _ L, GOTO[WMapFix],		c2,at[3,4,AllocMUD2];	{+++ Change for 2M +++}


{****************************************************************************
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, XwdDisp,			c3;		{+++ Change for 2M +++}

	MAR _ [rhRx,Q+0], L2Disp, DISP2[XWMUD],	c1, WMFRet[L0.XWrite];	{+++ Change for 2M +++}
	MDR _ T, RET[XWRtn],			c2,at[1,4,XWMUD];	{+++ Change for 2M +++}
XWMUD:	Noop, CANCELBR[WMapFix, 0F],		c2,at[0,4,XWMUD];	{+++ Change for 2M +++}
	Noop, CANCELBR[WMapFix, 0F],		c2,at[2,4,XWMUD];	{+++ Change for 2M +++}
	Noop, CANCELBR[WMapFix, 0F],		c2,at[3,4,XWMUD];	{+++ Change for 2M +++}