IFUPLAStackControlImpl.mesa
Copyright c 1984 by Xerox Corporation. All rights reserved.
Last edited by McCreight, April 8, 1986 6:21:16 pm PST
Last edited by Curry, September 2, 1986 10:18:11 am PDT
Don Curry March 14, 1987 12:34:54 pm PST
DIRECTORY
Commander, IFUPLAStackControl, IO, PLAOps, Rope;
IFUPLAStackControlImpl:
CEDAR
PROGRAM
IMPORTS Commander, IO, PLAOps, Rope =
BEGIN OPEN PO: PLAOps;
StackDecodeIn: TYPE = IFUPLAStackControl.StackDecodeIn;
StackAControlIn: TYPE = IFUPLAStackControl.StackAControlIn;
StackBControlIn: TYPE = IFUPLAStackControl.StackBControlIn;
StackAControlOut: TYPE = IFUPLAStackControl.StackAControlOut;
StackBControlOut: TYPE = IFUPLAStackControl.StackBControlOut;
StackDecodeOut: TYPE = IFUPLAStackControl.StackDecodeOut;
StackDecodeWtPOut: TYPE = IFUPLAStackControl.StackDecodeWtPOut;
StackDecodeWtLOut: TYPE = IFUPLAStackControl.StackDecodeWtLOut;
StackDecodeRdOut: TYPE = IFUPLAStackControl.StackDecodeRdOut;
Index: TYPE = IFUPLAStackControl.Index;
SixteenBits: TYPE = IFUPLAStackControl.SixteenBits;
TosMod: Index = IFUPLAStackControl.TosMod;
BosMod: Index = IFUPLAStackControl.BosMod;
DiffSig: Index = IFUPLAStackControl.DiffSig;
TosSig: Index = IFUPLAStackControl.TosSig;
BosSig: Index = IFUPLAStackControl.BosSig;
StackAControlPLA: PUBLIC PLAOps.PLA;
StackBControlPLA: PUBLIC PLAOps.PLA;
StackDecodePLA: PUBLIC PLAOps.PLA;
StackDecodeWtPPLA: PUBLIC PLAOps.PLA;
StackDecodeWtLPLA: PUBLIC PLAOps.PLA;
StackDecodeRdPLA: PUBLIC PLAOps.PLA;
StackAControlProc: PROC[argRec: StackAControlIn] RETURNS[resRec: StackAControlOut];
StackBControlProc: PROC[argRec: StackBControlIn] RETURNS[resRec: StackBControlOut];
StackDecodeProc: PROC[argRec: StackDecodeIn] RETURNS[resRec: StackDecodeOut];
nearlyFullDiff: Index = 10;
This difference corresponds to 11 entries on the stack (since top-bottom = 0 when there is one entry). The iStkNearlyFull signal is used in conjunction with Push2BA to decide whether to convert the target address to the IFU stack overflow handler. Thus there will be exactly 12 frames on the IFU stack when control arrives at the stack overflow handler.
GenStackAControlPLA:
PROC = {
x1ASrcStack: BE ← BEA[m:[x1ASrcStack: TRUE], d:[x1ASrcStack: TRUE]];
x1ADstStack: BE ← BEA[m:[x1ADstStack: TRUE], d:[x1ADstStack: TRUE]];
xBusStackEldest: BE ← BEA[m:[xBusStackEldest: TRUE], d:[xBusStackEldest: TRUE]];
xBusStackL: BE ← BEA[m:[xBusStackL: TRUE], d:[xBusStackL: TRUE]];
push3: BE ← BEA[m:[push3: TRUE], d:[push3: TRUE]];
pop3: BE ← BEA[m:[pop3: TRUE], d:[pop3: TRUE]];
SetA[out:[stackAdjTos: TRUE], s: PO.Or[push3, pop3] ];
SetA[out:[stackAddendIsOnes:
TRUE],
s: PO.Or[pop3, PO.And[x1ADstStack, xBusStackEldest, PO.Not[ xBusStackL]]] ];
SetA[out:[stackCarryIsOne:
TRUE],
s: PO.Or[push3, PO.And[x1ASrcStack, xBusStackEldest, PO.Not[ xBusStackL]]] ]};
GenStackBControlPLA:
PROC = {
trap: BE ← BEB[m:[microExcptJmpTrap: TRUE], d:[microExcptJmpTrap: TRUE]];
push3: BE ← BEB[m:[pushIn3: TRUE], d:[pushIn3: TRUE]];
pop3: BE ← BEB[m:[popIn3: TRUE], d:[popIn3: TRUE]];
pushing: BE ← PO.Or[push3, trap];
SetB[ out:[push3: TRUE], s:pushing ];
SetB[ out:[pop3: TRUE], s:pop3 ];
SetB[out:[iStkNearlyFull:
TRUE],
s: PO.And[pushing, BEB[m:[stackDiff: DiffSig], d:[stackDiff: nearlyFullDiff-1]]] ];
SetB[out:[iStkNearlyFull:
TRUE],
s: PO.And[PO.Not[pop3], BEB[m:[stackDiff: DiffSig], d:[stackDiff: nearlyFullDiff]]] ];
FOR diff: Index
IN (nearlyFullDiff..TosMod)
DO
SetB[out:[iStkNearlyFull: TRUE], m:[stackDiff: DiffSig], d:[stackDiff: diff] ];
ENDLOOP };
GenStackDecodePLA:
PROC = {
current: BE;
temp: BE;
x1ASrcStack: BE ← BEDEC[m:[x1ASrcStack: TRUE], d:[x1ASrcStack: TRUE]];
x1ADstStack: BE ← BEDEC[m:[x1ADstStack: TRUE], d:[x1ADstStack: TRUE]];
xBusStackEldest: BE ← BEDEC[m:[xBusStackEldest: TRUE], d:[xBusStackEldest: TRUE]];
xBusStackL: BE ← BEDEC[m:[xBusStackL: TRUE], d:[xBusStackL: TRUE]];
push3: BE ← BEDEC[m:[push3: TRUE], d:[push3: TRUE]];
pop3: BE ← BEDEC[m:[pop3: TRUE], d:[pop3: TRUE]];
out: SixteenBits ← 1;
WtP
out ← 1;
temp ← PO.And[PO.Not[x1ADstStack], push3];
FOR val: Index
DECREASING
IN [0..TosMod)
DO
tos: Index ← (val-1+TosMod) MOD TosMod; -- writes above top of stack
SetDec[out:[stkLdP: out], s: temp, m:[tos: TosSig], d:[tos: tos] ];
out ← out*2 ENDLOOP;
current ← PO.Not[temp];
temp ← PO.And[x1ADstStack, PO.Not[xBusStackL], xBusStackEldest];
out ← 1;
FOR val: Index
DECREASING
IN [0..BosMod)
DO
bos: Index ← (val+1) MOD BosMod; -- writes below bottom of stack
SetDec[out:[stkLdP: out], s: PO.And[current, temp], m:[bos: BosSig], d:[bos: bos] ];
out ← out*2 ENDLOOP;
current ← PO.And[current, PO.Not[temp]];
temp ← PO.And[x1ADstStack, PO.Not[xBusStackL], PO.Not[xBusStackEldest]];
out ← 1;
FOR val: Index
DECREASING
IN [0..TosMod)
DO
SetDec[out:[stkLdP: out], s: PO.And[current, temp], m:[tos: TosSig], d:[tos: val] ];
out ← out*2 ENDLOOP;
WtL
out ← 1;
temp ← PO.And[PO.Not[x1ADstStack], push3];
FOR val: Index
DECREASING
IN [0..TosMod)
DO
tos: Index ← (val-1+TosMod) MOD TosMod; -- write above top of stack
SetDec[out:[stkLdL: out], s: temp, m:[tos: TosSig], d:[tos: tos] ];
out ← out*2 ENDLOOP;
current ← PO.Not[temp];
temp ← PO.And[x1ADstStack, xBusStackL, xBusStackEldest];
out ← 1;
FOR val: Index
DECREASING
IN [0..BosMod)
DO
SetDec[out:[stkLdL: out], s: PO.And[current, temp], m:[bos: BosSig], d:[bos: val] ];
out ← out*2 ENDLOOP;
current ← PO.And[current, PO.Not[temp]];
temp ← PO.And[x1ADstStack, xBusStackL, PO.Not[xBusStackEldest]];
out ← 1;
FOR val: Index
DECREASING
IN [0..TosMod)
DO
SetDec[out:[stkLdL: out], s: PO.And[current, temp], m:[tos: TosSig], d:[tos: val] ];
out ← out*2 ENDLOOP;
Rd
out ← 1;
temp ← PO.Or[
PO.And[PO.Not[x1ASrcStack], PO.Not[pop3]],
PO.And[x1ASrcStack, PO.Not[xBusStackEldest]]];
This temp was changed to the one below to remove one of the four terms
temp ← PO.And[PO.Not[xBusStackEldest], PO.Not[pop3]];
FOR val: Index
DECREASING
IN [0..TosMod)
DO
SetDec[out:[stkRd: out], s: temp, m:[tos: TosSig], d:[tos: val] ];
out ← out*2 ENDLOOP;
current ← PO.Not[temp];
temp ← PO.And[PO.Not[x1ASrcStack], pop3];
out ← 1;
FOR val: Index
DECREASING
IN [0..TosMod)
DO
tos: Index ← (val+1) MOD TosMod;
SetDec[out:[stkRd: out], s: PO.And[current, temp], m:[tos: TosSig], d:[tos: tos] ];
out ← out*2 ENDLOOP;
current ← PO.And[current, PO.Not[temp]];
temp ← PO.And[x1ASrcStack, xBusStackEldest];
out ← 1;
FOR val: Index
DECREASING
IN [0..BosMod)
DO
SetDec[out:[stkRd: out], s: PO.And[current, temp], m:[bos: BosSig], d:[bos: val] ];
out ← out*2 ENDLOOP };
BE: TYPE = PO.BoolExpr;
BEA:
PROC [m, d: StackAControlIn]
RETURNS[
BE] = {
mRef: REF StackAControlIn ← NARROW[StackAControlPLA.mask];
dRef: REF StackAControlIn ← NARROW[StackAControlPLA.data];
mRef^ ← m; dRef^ ← d; RETURN[PO.GetBEForDataMask[StackAControlPLA]]};
BEB:
PROC [m, d: StackBControlIn]
RETURNS[
BE] = {
mRef: REF StackBControlIn ← NARROW[StackBControlPLA.mask];
dRef: REF StackBControlIn ← NARROW[StackBControlPLA.data];
mRef^ ← m; dRef^ ← d; RETURN[PO.GetBEForDataMask[StackBControlPLA]]};
BEDEC:
PROC [m, d: StackDecodeIn]
RETURNS[
BE] = {
mRef: REF StackDecodeIn ← NARROW[StackDecodePLA.mask];
dRef: REF StackDecodeIn ← NARROW[StackDecodePLA.data];
mRef^ ← m; dRef^ ← d; RETURN[PO.GetBEForDataMask[StackDecodePLA]]}; -- only ins import
SetA:
PROC [s:
BE ←
NIL, m, d: StackAControlIn ← [ ], out: StackAControlOut] = {
res: REF StackAControlOut ← NARROW[StackAControlPLA.out];
IF s=
NIL
THEN s ← BEA[m,d]
ELSE s ← PO.And[s, BEA[m,d] ];
res^ ← out; PO.SetOutForBE[StackAControlPLA, s]};
SetB:
PROC [s:
BE ←
NIL, m, d: StackBControlIn ← [ ], out: StackBControlOut] = {
res: REF StackBControlOut ← NARROW[StackBControlPLA.out];
IF s=
NIL
THEN s ← BEB[m,d]
ELSE s ← PO.And[s, BEB[m,d] ];
res^ ← out; PO.SetOutForBE[StackBControlPLA, s]};
SetDec:
PROC [s:
BE ←
NIL, m, d: StackDecodeIn ← [ ], out: StackDecodeOut] = {
res: REF StackDecodeOut ← NARROW[StackDecodePLA.out];
resWtP: REF StackDecodeWtPOut ← NARROW[StackDecodeWtPPLA.out];
resWtL: REF StackDecodeWtLOut ← NARROW[StackDecodeWtLPLA.out];
resRd: REF StackDecodeRdOut ← NARROW[StackDecodeRdPLA.out];
s ← IF s=NIL THEN BEDEC[m,d] ELSE PO.And[ s, BEDEC[m,d] ];
res^ ← out; PO.SetOutForBE[StackDecodePLA, s];
IF out.stkLdP#0 THEN {resWtP.stkLdP ← out.stkLdP; PO.SetOutForBE[StackDecodeWtPPLA, s]};
IF out.stkLdL#0 THEN {resWtL.stkLdL ← out.stkLdL; PO.SetOutForBE[StackDecodeWtLPLA, s]};
IF out.stkRd#0 THEN {resRd.stkRd ← out.stkRd; PO.SetOutForBE[StackDecodeRdPLA, s]}};
GenStackControl: Commander.CommandProc = {
ip: IO.ROPE ← "IFUPLA";
rt: IO.ROPE ← "IFUPLAStackControl";
sac: IO.ROPE ← "StackAControl";
sbc: IO.ROPE ← "StackBControl";
sd: IO.ROPE ← "StackDecode";
sdp: IO.ROPE ← "StackDecodeWtP";
sdl: IO.ROPE ← "StackDecodeWtL";
sdr: IO.ROPE ← "StackDecodeRd";
StackAControlPLA ← PO.NewPLA[rt.Cat[".", sac, "In"], rt.Cat[".", sac, "Out"], ip.Cat[sac]];
StackBControlPLA ← PO.NewPLA[rt.Cat[".", sbc, "In"], rt.Cat[".", sbc, "Out"], ip.Cat[sbc]];
StackDecodePLA ← PO.NewPLA[rt.Cat[".", sd, "In"], rt.Cat[".", sd, "Out"], ip.Cat[sd]];
StackDecodeWtPPLA ← PO.NewPLA[rt.Cat[".", sd, "In"], rt.Cat[".", sdp, "Out"], ip.Cat[sdp]];
StackDecodeWtLPLA ← PO.NewPLA[rt.Cat[".", sd, "In"], rt.Cat[".", sdl, "Out"], ip.Cat[sdl]];
StackDecodeRdPLA ← PO.NewPLA[rt.Cat[".", sd, "In"], rt.Cat[".", sdr, "Out"], ip.Cat[sdr]];
GenStackAControlPLA [];
GenStackBControlPLA [];
GenStackDecodePLA [];
[ ] ← PO.ConvertTermListToCompleteSum[StackAControlPLA.termList, FALSE,FALSE,cmd.out];
[ ] ← PO.ConvertTermListToCompleteSum[StackBControlPLA.termList, FALSE,FALSE,cmd.out];
[ ] ← PO.ConvertTermListToCompleteSum[StackDecodePLA.termList, FALSE,FALSE,cmd.out];
[ ] ← PO.ConvertTermListToCompleteSum[StackDecodeWtPPLA.termList, FALSE,FALSE,cmd.out];
[ ] ← PO.ConvertTermListToCompleteSum[StackDecodeWtLPLA.termList, FALSE,FALSE,cmd.out];
[ ] ← PO.ConvertTermListToCompleteSum[StackDecodeRdPLA.termList, FALSE,FALSE,cmd.out];
[ ] ← PO.FindAMinimalCover[StackAControlPLA.termList, 120, cmd.out];
[ ] ← PO.FindAMinimalCover[StackBControlPLA.termList, 120, cmd.out];
[ ] ← PO.FindAMinimalCover[StackDecodePLA.termList, 120, cmd.out];
[ ] ← PO.FindAMinimalCover[StackDecodeWtPPLA.termList, 120, cmd.out];
[ ] ← PO.FindAMinimalCover[StackDecodeWtLPLA.termList, 120, cmd.out];
[ ] ← PO.FindAMinimalCover[StackDecodeRdPLA.termList, 120, cmd.out];
PO.WritePLAFile[ StackAControlPLA, NIL, cmd.out];
PO.WritePLAFile[ StackBControlPLA, NIL, cmd.out];
PO.WritePLAFile[ StackDecodePLA, NIL, cmd.out];
PO.WritePLAFile[ StackDecodeWtPPLA, NIL, cmd.out];
PO.WritePLAFile[ StackDecodeWtLPLA, NIL, cmd.out];
PO.WritePLAFile[ StackDecodeRdPLA, NIL, cmd.out]};
Commander.Register[key:"GenStackControl", proc: GenStackControl];
END.