{File name FixedLoadStore.mc
Description: Mesa Load and Store op-codes
Author: Sandman
Created: February 16, 1980
Last edited: Trow 26-Oct-87 23:41:07
}

{The Load mesa op-codes consist of the following:
OP	val	bytes	stk	time
LL0	10'b	1	+1	1
LL1	11'b	1	+1	1
LL2	12'b	1	+1	1
LL3	13'b	1	+1	1
LL4	14'b	1	+1	1
LL5	15'b	1	+1	1
LL6	16'b	1	+1	1
LL7	17'b	1	+1	1
LLB	20'b	2	+1	1
LLDB	21'b	2	+2	2
LG0	37'b	1	+1	1
LG1	40'b	1	+1	1
LG2	41'b	1	+1	1
LG3	42'b	1	+1	1
LG4	43'b	1	+1	1
LG5	44'b	1	+1	1
LG6	45'b	1	+1	1
LG7	46'b	1	+1	1
LGB	47'b	2	+1	1
LGDB	50'b	2	+2	2
LI0	56'b	1	+1	1
LI1	57'b	1	+1	1
LI2	60'b	1	+1	1
LI3	61'b	1	+1	1
LI4	62'b	1	+1	1
LI5	63'b	1	+1	1
LI6	64'b	1	+1	1
LIN1	65'b	1	+1	1
LINI	66'b	1	+1	1
LIB	67'b	2	+1	1
LIW	70'b	3	+1	2
LINB	71'b	2	+1	1
LADRB	72'b	2	+1	2
GADRB	73'b	2	+1	2
LCO	74'b	3	+1	2
LP	161'b	1	+1	1

The Store mesa op-codes consist of the following:
OP	val	bytes	stk	time
SL0	22'b	1	-1	1
SL1	23'b	1	-1	1
SL2	24'b	1	-1	1
SL3	25'b	1	-1	1
SL4	26'b	1	-1	1
SL5	27'b	1	-1	1
SL6	30'b	1	-1	1
SL7	31'b	1	-1	1
SLB	32'b	2	-1	1
SLDB	162'b	2	-2	2
SG0	51'b	1	-1	1
SG1	52'b	1	-1	1
SG2	53'b	1	-1	1
SG3	54'b	1	-1	1
SGB	55'b	2	-1	1
SGDB	163'b	2	-2	2
PL0	34'b	1	0	1
PL1	35'b	1	0	1
PL2	36'b	1	0	1
PL3	37'b	1	0	1}
{Times for memory operations are + 2 if page cross + 2 if fix map flags}

{L2	CarryMapRets}
Set[L2.Lcarry,  1];
Set[L2.LDcarry, 5];
Set[L2.Scarry,  0];
Set[L2.SLDcarry, 9];
Set[L2.SGDcarry, 0D]; {1 mod 4}

{*****************************************************************************
	LLn{n:[0..7]} Load Local n   1 click
*****************************************************************************}
@LL0:	MAR _ Q _ [rhL, L+4], L1 _ L1r.PopOnly, push, GOTO[LLns],	c1, opcode[10'b];
@LL1:	MAR _ Q _ [rhL, L+5], L1 _ L1r.PopOnly, push, GOTO[LLns],	c1, opcode[11'b];
@LL2:	MAR _ Q _ [rhL, L+6], L1 _ L1r.PopOnly, push, GOTO[LLns],	c1, opcode[12'b];
@LL3:	MAR _ Q _ [rhL, L+7], L1 _ L1r.PopOnly, push, GOTO[LLns],	c1, opcode[13'b];
@LL4:	MAR _ Q _ [rhL, L+8], L1 _ L1r.PopOnly, push, GOTO[LLns],	c1, opcode[14'b];
@LL5:	MAR _ Q _ [rhL, L+9], L1 _ L1r.PopOnly, push, GOTO[LLns],	c1, opcode[15'b];
@LL6:	MAR _ Q _ [rhL, L+0A], L1 _ L1r.PopOnly, push, GOTO[LLns],	c1, opcode[16'b];
@LL7:	MAR _ Q _ [rhL, L+0B], L1 _ L1r.PopOnly, push, GOTO[LLns],	c1, opcode[17'b];

LLns:	STK _ TOS, PC _ PC + PC16, IBDisp, L2_L2.Lcarry, BRANCH[LLTail,LLcarry,1],	c2;
LLTail:	TOS _ MD, push, fZpop, DISPNI[OpTable],	c3;

LLcarry:	TT _ UvL, GOTO[CarryMap],	c3;


{*****************************************************************************
	LLB Load Local Byte   1 click
*****************************************************************************}
@LLB:	MAR _ Q _ [rhL, L+ib], L1 _ L1r.PopDec, push, GOTO[LLBs],	c1, opcode[20'b];

LLBs:	STK _ TOS, PC _ PC + 1, IBDisp, L2_L2.Lcarry, BRANCH[LLTail,LLcarry,1],	c2;


{*****************************************************************************
	Load Carry Logic (shared between LLx and LGx)
*****************************************************************************}
CarryMap:	Noop,	c1;
CarryFix:	Q _ Q - TT, L2Disp,	c2;
	Q _ Q and 0FF, RET[CarryMapRets],	c3;

LcarryMap:	Map _ Q _ [rhMDS, TT+Q],	c1, at[Or[L2.Lcarry,2], 10, CarryMapRets];
	PC _ PC-PC16,	c2;
	Rx _ rhRx _ MD, XRefBr, GOTO[RedoR],	c3;


{*****************************************************************************
	LGn{n:[0..7]} Load Global n   1 click
*****************************************************************************}
@LG0:	MAR _ Q _ [rhG, G+3], L1 _ L1r.PopOnly, push, GOTO[LGns],	c1, opcode[37'b];
@LG1:	MAR _ Q _ [rhG, G+4], L1 _ L1r.PopOnly, push, GOTO[LGns],	c1, opcode[40'b];
@LG2:	MAR _ Q _ [rhG, G+5], L1 _ L1r.PopOnly, push, GOTO[LGns],	c1, opcode[41'b];
@LG3:	MAR _ Q _ [rhG, G+6], L1 _ L1r.PopOnly, push, GOTO[LGns],	c1, opcode[42'b];
@LG4:	MAR _ Q _ [rhG, G+7], L1 _ L1r.PopOnly, push, GOTO[LGns],	c1, opcode[43'b];
@LG5:	MAR _ Q _ [rhG, G+8], L1 _ L1r.PopOnly, push, GOTO[LGns],	c1, opcode[44'b];
@LG6:	MAR _ Q _ [rhG, G+9], L1 _ L1r.PopOnly, push, GOTO[LGns],	c1, opcode[45'b];
@LG7:	MAR _ Q _ [rhG, G+0A], L1 _ L1r.PopOnly, push, GOTO[LGns],	c1, opcode[46'b];

LGns:	STK _ TOS, PC _ PC + PC16, IBDisp, L2_L2.Lcarry, BRANCH[LGTail,LGcarry,1],	c2;
LGTail:	TOS _ MD, push, fZpop, DISPNI[OpTable],	c3;

LGcarry:	TT _ UvG, GOTO[CarryMap],	c3;


{*****************************************************************************
	LGB Load Global Byte   1 click
*****************************************************************************}
@LGB:	MAR _ Q _ [rhG, G+ib], L1 _ L1r.PopDec, push, GOTO[LGBs],	c1, opcode[47'b];

LGBs:	STK _ TOS, PC _ PC + 1, IBDisp, L2_L2.Lcarry, BRANCH[LGTail,LGcarry,1],	c2;


{*****************************************************************************
	LLDB Load Local Double Byte  2 clicks
*****************************************************************************}
@LLDB:	MAR _ Q _ [rhL, L + ib], push, L1 _ L1r.PopDec,		c1, opcode[21'b];
	STK _ TOS, PC _ PC + PC16, L2 _ L2.LDcarry, BRANCH[$, LLDBcarry,1],	c2;
	T _ MD,							c3;

	MAR _ Q _ [rhL, Q + 1], push, L1 _ L1r.Pop2DecDec,	c1;
	STK _ T, IBDisp, PC _ PC + PC16, L2 _ L2.Lcarry, BRANCH[LLTail, LLcarry, 1],	c2;

LLDBcarry:
	TT _ UvL, GOTO[CarryMap],				c3;


{*****************************************************************************
	LGDB Load Global Double Byte  2 clicks
*****************************************************************************}
@LGDB:	MAR _ Q _ [rhG, G + ib], push, L1 _ L1r.PopDec,	c1, opcode[50'b];
	STK _ TOS, PC _ PC + PC16, L2 _ L2.LDcarry, BRANCH[$, LGDBcarry,1],	c2;
	T _ MD,							c3;

	MAR _ Q _ [rhG, Q + 1], push, L1 _ L1r.Pop2DecDec,	c1;
LGDBx:	STK _ T, IBDisp, PC _ PC + PC16, L2 _ L2.Lcarry, BRANCH[$, LGDBCarry2, 1],	c2;
	TOS _ MD, push, fZpop, DISPNI[OpTable],			c3;

LGDBcarry:
	TT _ UvG, GOTO[CarryMap],				c3;


{*****************************************************************************
	Load Double Carry Logic (shared by LLDx and LGDx)
*****************************************************************************}
{First word on next page => remap page and get both words}
LDcarryMap:
	Map _ Q _ [rhMDS, TT + Q],				c1, at[Or[L2.LDcarry,2], 10, CarryMapRets];
	L0 _ L0.LDcarry,					c2;
	Rx _ rhRx _ MD, XRefBr,					c3;

LDcarry:
	MAR _ [rhRx, Q + 0], BRANCH[LDcarryMapUD, $],		c1, at[L0.LDcarry,10,RMapFixCaller];
	Noop,							c2;
	T _ MD,							c3;

	MAR _ [rhRx, Q + 1], push, GOTO[LGDBx],			c1;

LDcarryMapUD:
	CALL[RMapFix], {will return to LDcarry}			c2;


{*****************************************************************************

Sturgis: 14-Jun-84 15:44:44

The following is additional carry logic for the case of second word in a page that page faults.  The reason that this fix is so bad is that there are at least two case tables that are full, and so I have had to duplicate a lot of code here.  The two case tables that are full are the RFixForTrap table, and RMapFixCaller.

The bug is that in the incorrect code, L1 was set to L1r.Pop2DecDec, to be used in the case of a fault, but in fact the value should have been Pop2Dec, but there is no such value, and the table is full.  The reason it should have been Pop2Dec is that some joint code has temporarily subtracted 1 from the pc.  Unfortunately, I can not simply replace this joint code, as the subroutine it uses has a full return list.  So I must also duplicate the subroutine.

It is possible that no one else uses L1r.Pop2DecDec, in which I could replace this case with the one I want.  However, it seems too painful to check this.

In the following I leave some indication of where the code is borrowed from.

Fiala: 24-Apr-86 18:33:00
Found that the stack item underneath the value pushed by LGDB was getting smashed when
the double-word fetched by LGDB straddled a page boundary.  Changed the first fetch of
both LGDB and LLDB to use T rather than TOS for MD.
*****************************************************************************}

{LGcarry}
LGDBCarry2:
	TT _ UvG,			c3;

{CarryMap}
	Noop,				c1;
	Q _ Q - TT,			c2;
	Q _ Q and 0FF, 			c3;
	
{LcarryMap}
	Map _ Q _ [rhMDS, TT + Q],	c1;
	Noop,				c2;
	Rx _ rhRx _ MD, XRefBr,		c3;
	
{Read.RedoR}
LGDBCarry3:
	MAR _ [rhRx, Q + 0], BRANCH[LGDBCarry4, $], c1;
	IBDisp,				c2;
{LLTail}
	TOS _ MD, push, fZpop, DISPNI[OpTable], c3;
	
{Read.RMapUD}
LGDBCarry4:
	Noop,				c2;
{CommonSubs.RMapFix}
{db}	Xbus _ Rx LRot0, XdwDisp, L3 _ L3.rhMDS.Q, c3;
	
	Map _ [rhMDS,Q], DISP2[LGDBFixRFlags], c1;

LGDBFixRFlags:
	MDR _ Rx or 10, GOTO[LGDBCarry5], c2, at[0,4];
{db}	MDR _ Rx or 10, GOTO[LGDBCarry5], c2, at[2,4, LGDBFixRFlags];
{db}	MDR _ Rx or 10, GOTO[LGDBCarry5], c2, at[1,4, LGDBFixRFlags];
	T _ qPageFault, L1Disp, GOTO[RTrap], c2, at[3,4, LGDBFixRFlags];

LGDBCarry5:
{db}	Xbus _ rdw.1xx, XDisp, GOTO[LGDBCarry3],	c3;
	

{*****************************************************************************
	LIn{n:[0..6]} Load Immediate n   1 click
*****************************************************************************}
@LI0:	T _ 0, push, GOTO[LInTail],	c1, opcode[56'b];
@LI1:	T _ 1, push, GOTO[LInTail],	c1, opcode[57'b];
@LI2:	T _ 2, push, GOTO[LInTail],	c1, opcode[60'b];
@LI3:	T _ 3, push, GOTO[LInTail],	c1, opcode[61'b];
@LI4:	T _ 4, push, GOTO[LInTail],	c1, opcode[62'b];
@LI5:	T _ 5, push, GOTO[LInTail],	c1, opcode[63'b];
@LI6:	T _ 6, push, GOTO[LInTail],	c1, opcode[64'b];

LInTail:	STK _ TOS, PC _ PC + PC16, IBDisp,	c2;
PushT:	TOS _ T, push, fZpop, DISPNI[OpTable],	c3;


{*****************************************************************************
	LIN1 Load Immediate Negative One   1 click
*****************************************************************************}
@LIN1:	T _ T xor ~T, push, GOTO[LInTail],	c1, opcode[65'b];


{*****************************************************************************
	LINI Load Immediate Negative Infinity   1 click
*****************************************************************************}
@LINI:	T _ RShift1 0, SE _ 1, push, GOTO[LInTail],	c1, opcode[66'b];


{*****************************************************************************
	LIB Load Immediate Byte   1 click
*****************************************************************************}
@LIB:	T _ ib, push,	c1, opcode[67'b];
	STK _ TOS, PC _ PC + 1, IBDisp, GOTO[PushT],	c2;


{*****************************************************************************
	LIW Load Immediate Word    2 clicks
*****************************************************************************}
@LIW:	T _ ib, push,	c1, opcode[70'b];
LIWx:	PC _ PC + 1,	c2;
	T _ T LRot8,	c3;

	T _ T or ib, GOTO[LInTail],	c1;


{*****************************************************************************
	LINB Load Immediate Negative Byte   1 click
*****************************************************************************}
@LINB:	Q _ ib, push,	c1, opcode[71'b];
	STK _ TOS, PC _ PC + 1, push, fZpop, IBDisp,	c2;
	TOS _ Q xor ~0FF, DISPNI[OpTable],	c3;


{*****************************************************************************
	LADRB Local Address Byte    2 clicks
*****************************************************************************}
@LADRB:	TT _ UvL,	c1, opcode[72'b];
LADRBx:	T _ ib, push,	c2;
	PC _ PC + PC16,	c3;

	T _ TT + T, GOTO[LInTail],	c1;


{*****************************************************************************
	GADRB Global Address Byte    2 clicks
*****************************************************************************}
@GADRB:	TT _ UvG, GOTO[LADRBx],	c1, opcode[73'b];


{*****************************************************************************
	LCO Load Code Offset    2 clicks
*****************************************************************************}
@LCO:	T _ ib, push, GOTO[LIWx],	c1, opcode[74'b];


{*****************************************************************************
	LP Lengthen Pointer	2 click
*****************************************************************************}
@LP:	[] _ TOS, ZeroBr, fXpop, push,	c1, opcode[161'b];
	BRANCH[LPnot, LPnil],	c2;
LPnot:	T _ UvMDS, GOTO[LPTail],	c3;
LPnil:	T _ 0, GOTO[LPTail],	c3;

LPTail:	push, GOTO[LInTail],	c1;


{*****************************************************************************
	SLn{n:[0..7]} Store Local n    1 click
*****************************************************************************}
@SL0:	MAR _ Q _ [rhL, L+4], L1 _ L1w.DecOnly, push, GOTO[SLns],	c1, opcode[22'b];
@SL1:	MAR _ Q _ [rhL, L+5], L1 _ L1w.DecOnly, push, GOTO[SLns],	c1, opcode[23'b];
@SL2:	MAR _ Q _ [rhL, L+6], L1 _ L1w.DecOnly, push, GOTO[SLns],	c1, opcode[24'b];
@SL3:	MAR _ Q _ [rhL, L+7], L1 _ L1w.DecOnly, push, GOTO[SLns],	c1, opcode[25'b];
@SL4:	MAR _ Q _ [rhL, L+8], L1 _ L1w.DecOnly, push, GOTO[SLns],	c1, opcode[26'b];
@SL5:	MAR _ Q _ [rhL, L+9], L1 _ L1w.DecOnly, push, GOTO[SLns],	c1, opcode[27'b];
@SL6:	MAR _ Q _ [rhL, L+0A], L1 _ L1w.DecOnly, push, GOTO[SLns],	c1, opcode[30'b];
@SL7:	MAR _ Q _ [rhL, L+0B], L1 _ L1w.DecOnly, push, GOTO[SLns],	c1, opcode[31'b];

SLns:	MDR _ STK _ TOS, PC _ PC + PC16, pop, IBDisp, BRANCH[$,SLcarry,1],	c2;
SLTail:	TOS _ STK, pop, DISPNI[OpTable],	c3;

SLcarry:	TT _ UvL, L2_L2.Scarry, GOTO[CarryMap],	c3;


{*****************************************************************************
	SLB Store Local Byte    1 click
*****************************************************************************}
@SLB:	MAR _ Q _ [rhL, L+ib], L1 _ L1w.DecDec, push, GOTO[SLBs],	c1, opcode[32'b];

SLBs:	MDR _ STK _ TOS, PC _ PC + 1, pop, IBDisp, BRANCH[SLTail,SLcarry,1],	c2;


{*****************************************************************************
	PLn{n:[0..3]} Put Local n    1 click
*****************************************************************************}
{no page carry possible on local 0-3}
@PL0:	MAR _ Q _ [rhL, L+4], fXpop, push, GOTO[PLns],	c1, opcode[33'b];
@PL1:	MAR _ Q _ [rhL, L+5], fXpop, push, GOTO[PLns],	c1, opcode[34'b];
@PL2:	MAR _ Q _ [rhL, L+6], fXpop, push, GOTO[PLns],	c1, opcode[35'b];
@PL3:	MAR _ Q _ [rhL, L+7], fXpop, push, GOTO[PLns],	c1, opcode[36'b];

PLns:	MDR _ TOS, PC _ PC + PC16, IBDisp, CANCELBR[DISPNIonly,0],	c2;


{*****************************************************************************
	Store Carry Logic (shared between SLx and SGx)
*****************************************************************************}
ScarryMap:
	Map _ Q _ [rhMDS, TT+Q], {map next page}	c1, at[L2.Scarry, 10, CarryMapRets];
	L0 _ L0.Scarry,					c2;
{db}	Rx _ rhRx _ MD, XdwDisp,			c3;

Scarry:	MAR _ [rhRx, Q+0], DISP2[ScarryMapUD],		c1, at[L0.Scarry,10,WMapFixCaller];
ScarryMapUD:
	CALL[WMapFix], {will return to Scarry}		c2, at[0, 4, ScarryMapUD];
{db}	CALL[WMapFix], {WP fault}			c2, at[1, 4, ScarryMapUD];
	CALL[WMapFix], {Page fault}			c2, at[3, 4, ScarryMapUD];
SGStore:
{db}	MDR _ TOS, IBDisp, CANCELBR[SLTail,0],		c2, at[2, 4, ScarryMapUD];


{*****************************************************************************
	SGn{n:[0..7]} Store Global n    1 click
*****************************************************************************}
@SG0:	Q _ G + 3, PgCarryBr, L1 _ L1w.DecOnly, GOTO[SGns],	c1, opcode[51'b];
@SG1:	Q _ G + 4, PgCarryBr, L1 _ L1w.DecOnly, GOTO[SGns],	c1, opcode[52'b];
@SG2:	Q _ G + 5, PgCarryBr, L1 _ L1w.DecOnly, GOTO[SGns],	c1, opcode[53'b];
@SG3:	Q _ G + 6, PgCarryBr, L1 _ L1w.DecOnly, GOTO[SGns],	c1, opcode[54'b];

SGns:
{db}	Xbus _ rhG, XdwDisp, push, BRANCH[SGnNoCross, SGnCross],	c2;
SGnNoCross:
	STK _ TOS, pop, PC _ PC + PC16, DISP2[SGMapFix],	c3;

SGMapFix:
	TT _ UvG, L2 _ L2.Scarry, GOTO[SGMapFixx],			c1, at[0, 4, SGMapFix];
{db}	TT _ UvG, L2 _ L2.Scarry, GOTO[SGMapFixx],			c1, at[1, 4, SGMapFix];
	TT _ UvG, L2 _ L2.Scarry, GOTO[SGMapFixx],			c1, at[3, 4, SGMapFix];
{db}	MAR _ [rhG, Q + 0], GOTO[SGStore],				c1, at[2, 4, SGMapFix];

SGMapFixx:
	Q _ Q - TT,							c2;
	Q _ Q and 0FF,							c3;

	Map _ [rhMDS, TT],						c1;
	L2Disp,								c2;
	rhG _ MD, RET[CarryMapRets],					c3;

SGnCross:
	STK _ TOS, pop, PC _ PC + PC16, CANCELBR[SGCrossFix,3],		c3;
SGCrossFix:
	TT _ UvG, L2 _ L2.Scarry, GOTO[SGMapFixx],			c1;


{*****************************************************************************
	SGB Store Global Byte    1 click
*****************************************************************************}
@SGB:	Q _ G + ib, PgCarryBr, L1 _ L1w.DecDec,	c1, opcode[55'b];

SGBs:
{db}	Xbus _ rhG, XdwDisp, push, BRANCH[SGbNoCross, SGbCross],	c2;

SGbNoCross:
	STK _ TOS, pop, PC _ PC + 1, DISP2[SGMapFix],	c3;
SGbCross:
	STK _ TOS, pop, PC _ PC + 1, CANCELBR[SGCrossFix,3],	c3;


{*****************************************************************************
	SLDB Store Local Double Byte    2 clicks
*****************************************************************************}
@SLDB:	MAR _ Q _ [rhL, L + ib], L1 _ L1w.NoFixes,	c1, opcode[162'b];
	MDR _ STK, push, L2 _ L2.SLDcarry, BRANCH[$, SLDBcarry,1],	c2;
	PC _ PC + PC16, STK _ TOS, pop,			c3;

SLDB2:	MAR _ Q _ [rhL, Q + 1], pop, L1 _ L1w.PushDecDec,	c1;
SLDB2x:	MDR _ TOS, PC _ PC + PC16, IBDisp, BRANCH[SLTail,SLcarry,1],	c2;

SLDBcarry:
	TT _ UvL, GOTO[CarryMap],			c3;


{*****************************************************************************
	SGDB Store Global Double Byte    2 clicks
*****************************************************************************}
@SGDB:	Q _ G + ib + 1, PgCarryBr, L2_L2.SGDcarry,	c1, opcode[163'b];
{db}	Xbus _ rhG, Q _ Q - 1, XdwDisp, push, BRANCH[$,SGDBcarry],	c2;
	STK _ TOS, pop, DISP2[SGDBMapFix],	c3;

SGDBMapFix:
	TT _ UvG, CALL[SGMapFixx],		c1, at[0, 4, SGDBMapFix];
{db}	TT _ UvG, CALL[SGMapFixx],		c1, at[1, 4, SGDBMapFix];
	TT _ UvG, CALL[SGMapFixx],		c1, at[3, 4, SGDBMapFix];

SGDBMapOK:
{db}	MAR _ Q _ [rhG, Q + 0],			c1, at[2, 4, SGDBMapFix];
	MDR _ STK,	c2;
	PC _ PC + PC16,	c3;

	MAR _ [rhG, Q + 1], pop, GOTO[SLDB2x],	c1;

	T _ TOS, L1 _ L1w.PushDec,	c1, at[L2.SGDcarry, 10, CarryMapRets];
	Q _ TT + Q, GOTO[WDBx],	c2;

SGDBcarry:
	STK _ TOS, pop, CANCELBR[$,3],	c3;
	TT _ UvG, CALL[SGMapFixx],	c1;


{*****************************************************************************
	Store Double Carry Logic (shared by SLDx)
*****************************************************************************}
{First word on next page => remap page and store both words}
SDcarryMap:
	Map _ Q _ [rhMDS, TT+Q],			c1, at[Or[L2.SLDcarry,2], 10, CarryMapRets];
	L0 _ L0.SDcarry,				c2;
{db}	Rx _ rhRx _ MD, XdwDisp {XDirtyDisp}, pop,		c3;

SDcarry:
	MAR _ [rhRx, Q+0], DISP2[SDcarryMapUD] {BRANCH[SDcarryMapUD, $, 1]},	c1, at[L0.SDcarry,10,WMapFixCaller];
SDcarryMapUD:
	CALL[WMapFix], {will return to SDcarry}		c2, at[0, 4, SDcarryMapUD];
{db}	CALL[WMapFix], {WP fault}			c2, at[1, 4, SDcarryMapUD];
	CALL[WMapFix], {Page fault}			c2, at[3, 4, SDcarryMapUD];
{db}	MDR _ STK, push,				c2, at[2, 4, SDcarryMapUD];
	STK _ TOS, PC _ PC + PC16, pop,			c3;

	MAR _ [rhRx, Q+1], pop,				c1;
	MDR _ TOS, PC _ PC + PC16, IBDisp, CANCELBR[SLTail,0],	c2;
	
{14-Jun-84 15:36:28: Sturgis: repair nasty bug in LGDB, that occurs when second word is
	in a new page, and that page is not mapped in.  The fix is gross, see comments in the opcode
Fiala 24 April 1986 Another fix to LGDB, which was smashing the item underneath when the first and second words
	of the double-word crossed a page boundary.
Fiala 16-May-86 15:03:35 Changes for the 4MB storage mod; changes at SG0..SG3 were particularly awful,
	likely source of bugs.
Trow	13-Oct-87 14:43:39 Reverse targets 1 and 2 of XwdDisp.
Trow	22-Oct-87 17:42:51 Change XwdDisp to XdwDisp.
}