IFUSrcComplete.mesa
Copyright c 1986 by Xerox Corporation. All rights reserved.
Last Edited by Curry, October 22, 1986 11:45:17 am PDT
Don Curry November 1, 1986 4:15:17 pm PST
Last Edited by: Louis Monier February 10, 1987 10:21:55 pm PST
DIRECTORY
CCDUtils, CD, CDBasics, Core, CoreClasses, CoreCreate, CoreFrame, CoreGeometry, CoreGlue, CoreName, Dragon, IFUCoreCtl, IFUCoreDrive, IFUCorePads, IFUSrc, IO, PW, PWC;
IFUSrcComplete: CEDAR PROGRAM 
IMPORTS CCDUtils, CDBasics, CoreClasses, CoreCreate, CoreFrame, CoreGeometry, CoreGlue, CoreName, IFUCoreCtl, IFUCoreDrive, IFUCorePads, IFUSrc, IO, PW, PWC
EXPORTS IFUSrc =
BEGIN
ROPE:   TYPE = Core.ROPE;
PadsType: TYPE = IFUCorePads.PadsType;
PadRec:  TYPE = IFUCorePads.PadRec;
Side:   TYPE = CoreFrame.Side;
CellType:  TYPE = Core.CellType;
Ph:   TYPE = CoreName.Ph;
DrGate:  TYPE = IFUCoreDrive.DrGate;
GND:   ROPE ← CoreName.RopeNm["GND"];
VDD:   ROPE ← CoreName.RopeNm["VDD"];
Signal: SIGNAL = CODE;
MakePads: PROC[name: ROPE, side: Side, pads: LIST OF PadRec]
RETURNS[cellType: CellType] = {
PadCell: PROC[pad: PadRec] =
{pad.side ← side; cnt ← cnt-1; new.seq[cnt] ← IFUCorePads.CellProc[data: pad]};
Sig: PROC RETURNS[pad: PadRec] = {pad ← list.first; list ← list.rest};
ltOrRt: BOOL ← side=left OR side=right;
list:  LIST OF PadRec;
new:  CoreFrame.Frame;
cnt:  INT ← 0;
list ← pads; pads ← NIL;
FOR list ← list, list.rest WHILE list # NIL DO
cnt ← cnt+1; pads ← CONS[list.first, pads] ENDLOOP; -- count and reverse list
IF cnt # (IF ltOrRt THEN 28 ELSE 32) THEN ERROR; -- left and right missing 4
cnt ← cnt+15;
IF ltOrRt
THEN {cellType ← CoreFrame.NewFrameCell[ name: name, rec: [first: bottom], size: cnt ]}
ELSE {cellType ← CoreFrame.NewFrameCell[ name: name, rec: [first: left],  size: cnt ]};
new  ← CoreFrame.FCT[cellType];
list ← pads;
From Top or Right
IF NOT ltOrRt THEN  { PadCell[ Sig[] ];  PadCell[ Sig[] ] };
PadCell[[type: gnd   ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: padgnd  ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: padvdd  ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: vdd   ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: vdd   ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: padvdd  ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: padgnd  ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: gnd   ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: padgnd  ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: padvdd  ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: vdd   ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: vdd   ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: padvdd  ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: padgnd  ]]; PadCell[ Sig[] ];  PadCell[ Sig[] ];
PadCell[[type: gnd   ]];
IF NOT ltOrRt THEN  { PadCell[ Sig[] ];  PadCell[ Sig[] ] };
IF list#NIL OR cnt#0 THEN ERROR };
PadLt: PUBLIC PROC RETURNS[cellType: CellType] = {
pads: LIST OF PadRec ← NIL;
name: ROPE ← CoreName.RopeNm["IFUPadLtCore"];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: in, data1: "IPRejectB"],       pads];
pads ← CONS[ [type: in, data1: "IPFaultingB"],      pads];
pads ← CONS[ [type:gate2Out, data2:"NewFetchBAA", enWtA:"PhA"],pads];
pads ← CONS[ [type: in, data1: "ResetAB"],       pads];
pads ← CONS[ [type: in, data1: "RescheduleAB"],     pads];
pads ← CONS[ [type: conn, data1: "VBB"],        pads];
pads ← CONS[ [type: in, data1: IFUSrc.dShIn],      pads];
pads ← CONS[ [type: out, data2: IFUSrc.dShOut],      pads];
pads ← CONS[ [type: conn, data1: "PhA"],        pads];
pads ← CONS[ [type: conn, data1: "PhB"],        pads];
pads ← CONS[ [type: conn, data1: "NotPhA"],       pads];
pads ← CONS[ [type: conn, data1: "NotPhB"],       pads];
pads ← CONS[ [type: conn, data1: "DShA"],        pads];
pads ← CONS[ [type: conn, data1: "DShB"],        pads];
pads ← CONS[ [type: conn, data1: "DShRd"],        pads];
pads ← CONS[ [type: conn, data1: "DShWt"],        pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
cellType ← MakePads[name, left, pads];
CoreFrame.WriteFrameCache[cellType]};
cellType ← CoreFrame.NewFrameCells[ name: "IFUPadLt", rec: [first: top], cells: LIST[
CoreGlue.CellProc[t: ext, b: conn ],
cellType,
CoreGlue.CellProc[t: conn, b: ext ] ] ]};
PadRt: PUBLIC PROC RETURNS[cellType: CellType] = {
pads: LIST OF PadRec ← NIL;
name: ROPE ← CoreName.RopeNm["IFUPadRtCore"];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
wa: ROPE ← CoreName.RopeNm["PhA"];
wb: ROPE ← CoreName.RopeNm["NotDPRejectBA"];
wc: ROPE ← CoreName.RopeNm["Stage3ANormalBA"];
pads ← CONS[ [type: conn, data1: "IDPlaFireV"],      pads];
pads ← CONS[ [type: conn, data1: "IDPlaNotPhA"],      pads];
pads ← CONS[ [type: in, data1: "DPFaultB.3"],      pads];
pads ← CONS[ [type: in, data1: "DPFaultB.2"],      pads];
pads ← CONS[ [type: in, data1: "DPFaultB.1"],      pads];
pads ← CONS[ [type: in, data1: "DPFaultB.0"],      pads];
pads ← CONS[ [type: in, data1: "DPRejectB"],       pads];
pads ← CONS[ [type: out, data2: "UserMode2BAA"],     pads];
pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.7",enWtA:wa,enWtB:wb,enWtC:wc],pads];
pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.6",enWtA:wa,enWtB:wb,enWtC:wc],pads];
pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.5",enWtA:wa,enWtB:wb,enWtC:wc],pads];
pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.4",enWtA:wa,enWtB:wb,enWtC:wc],pads];
pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.3",enWtA:wa,enWtB:wb,enWtC:wc],pads];
pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.2",enWtA:wa,enWtB:wb,enWtC:wc],pads];
pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.1",enWtA:wa,enWtB:wb,enWtC:wc],pads];
pads ← CONS[[type:gate4Out,data2:"DPCmnd2BAA.0",enWtA:wa,enWtB:wb,enWtC:wc],pads];
pads ← CONS[ [type: out, data2: "EUAluOp2ABB.3"],     pads];
pads ← CONS[ [type: out, data2: "EUAluOp2ABB.2"],     pads];
pads ← CONS[ [type: out, data2: "EUAluOp2ABB.1"],     pads];
pads ← CONS[ [type: out, data2: "EUAluOp2ABB.0"],     pads];
pads ← CONS[ [type: out, data2: "EUCondSel2ABB.3"],    pads];
pads ← CONS[ [type: out, data2: "EUCondSel2ABB.2"],    pads];
pads ← CONS[ [type: out, data2: "EUCondSel2ABB.1"],    pads];
pads ← CONS[ [type: out, data2: "EUCondSel2ABB.0"],    pads];
pads ← CONS[ [type: in, data1: "EUCondition2B"],     pads];
pads ← CONS[ [type: out, data2: "EURdFromPBus3ABB"],   pads];
pads ← CONS[ [type: out, data2: "EUWriteToPBus3ABB"],   pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
pads ← CONS[ [type: empty],            pads];
cellType ← MakePads[name, right, pads];
CoreFrame.WriteFrameCache[cellType]};
cellType ← CoreFrame.NewFrameCells[ name: "IFUPadRt", rec: [first: top], cells: LIST[
CoreGlue.CellProc[t: ext, b: conn ],
cellType,
CoreGlue.CellProc[t: conn, b: ext ] ] ]};
PadTop: PUBLIC PROC RETURNS[cellType: CellType] = {
pads: LIST OF PadRec ← NIL;
name: ROPE ← CoreName.RopeNm["IFUPadTopCore"];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
FOR i: INT DECREASING IN [0..32) DO
in:  ROPE ← IO.PutFR["IPData.%02b", IO.int[i] ];
out: ROPE ← IO.PutFR["IPAddr.%02b", IO.int[i] ];
pads ← CONS[ [type: triOut, data1: in, data2: out, enWtA: VDD, enWtB: GND], pads];
ENDLOOP;
cellType ← MakePads[name, top, pads];
CoreFrame.WriteFrameCache[cellType]};
cellType ← CoreFrame.NewFrameCells[ name: "IFUPadTop", rec: [first: left], cells: LIST[
IFUCorePads.CellProc["TopLeft", [corLo, top] ],
cellType,
IFUCorePads.CellProc["TopRight", [corHi, top] ] ] ]};
PadBot: PUBLIC PROC RETURNS[cellType: CellType] = {
enWtA: ROPE ← "KPadsOut3BA";
enRd:  ROPE ← "KPadsIn4Ac";
disRd:  ROPE ← "NotKPadsIn4Ac";
pads: LIST OF PadRec ← NIL;
name: ROPE ← CoreName.RopeNm["IFUPadBotCore"];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
FOR i: INT DECREASING IN [0..32) DO
in:   ROPE ← IO.PutFR["XBus.%02b", IO.int[i] ];
out:  ROPE ← IO.PutFR["XBus.%02b", IO.int[i] ];
pads ← CONS[[type: triIO,
data1:  in,  data2:  out,
enWtA: enWtA, enWtB: VDD,
enRd:  enRd,  disRd:  disRd], pads];
ENDLOOP;
cellType ← MakePads[name, bottom, pads];
CoreFrame.WriteFrameCache[cellType]};
cellType ← CoreFrame.NewFrameCells[ name: "IFUPadBot", rec: [first: left], cells: LIST[
IFUCorePads.CellProc["BottomLeft", [corLo, bottom] ],
cellType,
IFUCorePads.CellProc["BottomRight", [corHi, bottom] ] ] ]};
PadExt: PROC[side1, side2: Side] RETURNS[cellType: CellType] = {
cellType ← CoreFrame.NewFrameCells[name:CoreName.ID["PadExt"],
rec:[ -- starts in top-left
first:  left,
orient: CDBasics.ComposeOrient[
SELECT side1 FROM
top  => original,
bottom => rotate180X,
left  => rotate270X,
right  => rotate270, ENDCASE => ERROR,
SELECT side2 FROM
top  => original,
bottom => rotate180X,
left  => original,
right  => mirrorX, ENDCASE => ERROR] ],
cells: LIST[
IFUCorePads.CellProc[data: [type: ext, side: top]],
CoreGlue.CellProc[l: conn, r: ext] ] ] };
Interlock: PUBLIC PROC [sIn: ROPE, altOut: ROPE ← NIL]
RETURNS [cellType: CellType, sOut: ROPE] = {
name: ROPE ← CoreName.RopeNm["IFUPLAInterlock"];
IF altOut#NIL THEN Signal[];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
{
desc: IFUCoreCtl.PLADescription ← NEW[IFUCoreCtl.PLADescriptionRec ←
[name: "IFUPLAInterlock", plaPhs: [BA, B, BAA, B, BA] ] ];
desc.plaType    ← hot ;
desc.inSh     ← sIn;
IFUCoreCtl.MakePLA1[desc];
IFUCoreDrive.AdjustDriveInPhRef[B, desc.inDrs, "
KIsRtOp1BA
FCtlIsRtOp1BA
CIsField2AB
CIsField3AB
DPCmndIsRd2BA
A1IsC2B
A1IsC3B
B1IsC2B
B1IsC3B "];
IFUCoreCtl.MakePLA2[desc];
sOut   ← desc.outSh;
cellType  ← IFUCoreCtl.CellProc[complete, desc];
[ ] ← CoreName.CellNm[cellType, name];
IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];
};
CoreFrame.WriteFrameCache[cellType]};
[sIn, sOut] ← IFUCoreDrive.GetDShiftIO[cellType];
cellType ← CoreFrame.NewFrameCells[ name: "InterlockFillX", rec: [first: left], cells: LIST[
CoreGlue.CellProc[l: ext, r: conn],
cellType ]]};
MainPipeControl: PUBLIC PROC [sIn: ROPE, altOut: ROPE ← NIL]
RETURNS [cellType: CellType, sOut: ROPE] = {
name: ROPE ← CoreName.RopeNm["IFUPLAMainPipeControl"];
IF altOut#NIL THEN Signal[];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
{
dr: IFUCoreDrive.Drive;
desc: IFUCoreCtl.PLADescription ← NEW[IFUCoreCtl.PLADescriptionRec ←
[name: "IFUPLAMainPipeControl", plaPhs: [BA, B, BAA, B, BA] ] ];
desc.plaType    ← hot ;
desc.nofTermCols  ← 3;
desc.fullWidthTerms ← FALSE;
IFUCoreCtl.MakePLA1[desc];
IFUCoreDrive.AdjustDriveInPhRef[A, desc.inDrs, "
RschClearAB "];
IFUCoreDrive.AdjustDriveInPhRef[B, desc.inDrs, "
ResetBA
DPRejectBA
DPFaultingBA   ← DPFaultBA.0
ProtMicroCycleBA
MicroExcptJmpBubbleAB
Stage2BAbortAB
Stage1BHoldBA
CondEffect1BA.0 CondEffect1BA.1
CondEffect2BA.0 CondEffect2BA.1
EUCondition2BA
TrapsEnabled2BA  ← Flag2BA.7
EStkOverflow2BA
InstStarting2BA
RescheduleBA
RschWaitingAB
Push2AB
InstFault2BA
IStkNearlyFullBA "];
IFUCoreDrive.AdjustDriveOutPh[desc.outDrs, "
Stage2ANormalBA    Stage2ABubbleBA
Stage3ANormalBA    Stage3AAbortBA
LoadStage1Ac
LoadStage2Ac
LoadStage3Ac
Stage1BHoldingAB    NotStage1BHoldingAB
Stage2BNormalAB     Stage2BAbortAB
Stage3BCPipeNormalAB   Stage3BCPipeAbortAB
MicroExcptJmpNoneAB
MicroExcptJmpMicroJumpAB
MicroExcptJmpBubbleAB
MicroExcptJmpResettingAB
MicroExcptJmpTrapAB
MicroExcptJmpCJumpAB
ExceptTypeSpecialCodeAB ExceptTypeCondCodeAB ExceptTypeDpFaultAB
ExceptCodeAB.0 ExceptCodeAB.1 ExceptCodeAB.2 ExceptCodeAB.3
RschClearAB
RschWaitingAB " ];
dr ← IFUCoreDrive.FindDrive[desc.outDrs, "BcLoadStage1BA"];
dr.name  ← "LoadStage";
dr.dualOut ← FALSE;
dr.gate  ← negBc;
dr.in ← [pos, A];
dr.ref ← [pos, A];
dr.out ← [pos, Bc];
IFUCoreCtl.MakePLA2[desc];
sOut   ← desc.outSh;
cellType  ← IFUCoreCtl.CellProc[complete, desc];
[ ] ← CoreName.CellNm[cellType, name];
IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];
};
CoreFrame.WriteFrameCache[cellType]};
[sIn, sOut] ← IFUCoreDrive.GetDShiftIO[cellType];
cellType ← CoreFrame.NewFrameCells[name: "MainPipeControlFillX", rec:[first:left], cells:LIST[
CoreGlue.CellProc[l: ext, r: conn],
cellType ]]};
LtDrPadIO: PUBLIC PROC[sIn: ROPE, altOut: ROPE ← NIL]
RETURNS [cellType: CellType, sOut: ROPE] = {
name: ROPE ← CoreName.RopeNm["IFULtDrPadIOCore"];
IF altOut#NIL THEN Signal[];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
{
Drive: PROC[dir: IFUCoreDrive.Dir, in, out: ROPE, inverted, dual: BOOL ← FALSE] = {
drives ← CONS[IFUCoreDrive.SpecificDrive[dir, in, out, inverted, dual], drives]};
drives:  IFUCoreDrive.Drives ← NIL;
toInside:  IFUCoreDrive.Dir = out;
toOutside: IFUCoreDrive.Dir = in;
Drive[toInside, "IPRejectB",   "IPRejectBA"];
Drive[toInside, "IPFaultingB",  "IPFaultingBA"];
Drive[toOutside, "NewFetchBA",  "NewFetchBAA"];
Drive[toInside, "ResetAB",   "ResetBA",    FALSE, TRUE];
Drive[toInside, "RescheduleAB", "RescheduleBA"];
[drives, sOut] ← IFUCoreDrive.CapDrives[drives, sIn];
cellType ← IFUCoreDrive.DrivesToFrame[name, drives];
IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];
};
CoreFrame.WriteFrameCache[cellType]};
[sIn, sOut] ← IFUCoreDrive.GetDShiftIO[cellType];
cellType ← CoreFrame.NewFrameCells[ name: "LtDrPadIO", rec: [first: left],
cells: LIST[ CoreGlue.CellProc[l: ext, r: conn], cellType ]]};
IFULogo: PROC RETURNS [cellType: CellType] = {
design: CD.Design ← PW.OpenDesign["IFULogo"];
object: CD.Object  ← PW.Get[design, "WideHorizontalLogo"];
cellType ← CoreClasses.CreateRecordCell
[CoreCreate.Seq[size:0], CoreCreate.Seq[size:0], NIL, "Logo", NIL];
PWC.SetLayoutObj[cellType, object];
PWC.SetExtractCell[object, cellType];
CoreGeometry.PutObject[PWC.extractMode.decoration, cellType, object];
cellType ← CoreFrame.NewFrameCells[ name: "IFULogo", rec: [first: top], cells: LIST[
CoreGlue.CellProc[],
CoreFrame.NewFrameCells[ name: NIL, rec: [first: left], cells: LIST[
CoreGlue.CellProc[],
CoreFrame.NewFrameCell[size: 0, name: "Logo", rec: [first: left, cell: cellType] ],
CoreGlue.CellProc[] ]],
CoreGlue.CellProc[] ]]};
IFULogoCell: CellType ← NIL;
IFULogo: PROC RETURNS [cellType: CellType] = {
IF IFULogoCell=NIL THEN {
design:   CD.Design ← PW.OpenDesign["IFULogo"];
object:   CD.Object  ← PW.Get[design, "WideHorizontalLogo"];
object    ← PW.Rot90[object];
IFULogoCell  ← CoreLibrary.ObjCell[object, "HorizontalLogo", NIL, 0]};
cellType ← CoreFrame.NewFrameCells[ name: "IFULogo", rec: [first: top], cells: LIST[
CoreGlue.CellProc[],
CoreFrame.NewFrameCells[ name: NIL, rec: [first: left], cells: LIST[
CoreGlue.CellProc[l: ext, r: conn],
CoreFrame.NewFrameCell[size: 0, name: "IFULogoMain", rec: [first: left, cell: IFULogoCell] ],
CoreGlue.CellProc[l: conn, r: ext] ]],
CoreGlue.CellProc[] ]] };
LeftColumn: PUBLIC PROC RETURNS [cellType: CellType] = {
name: ROPE ← CoreName.RopeNm["IFULeftColumnCore"];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
sftIn:  ROPE ← IFUSrc.dShIn;
sft:  ROPE ← sftIn;
sftRtn: ROPE ← IFUSrc.dShOut;
fetchIndex, stackIndex: CellType;
fetchControl, ltDrPadIO, stackControl, mainPipeControl, interlock: CellType;
chanTopLeft, chanTopRight, chanBotLeft, chanBotRight: CellType;
stackIndex     ← IFUSrc.StackIndexing [];
capBot
[interlock,   sft] ← IFUSrc.Interlock   [sft];
[mainPipeControl, sft] ← IFUSrc.MainPipeControl [sft];
[stackControl,  sft] ← IFUSrc.StackControler  [sft];
[ltDrPadIO,   sft] ← LtDrPadIO     [sft];
[fetchControl,  sft] ← IFUSrc.FetchControler [sft, IFUSrc.dShLeftOut];
capTop
fetchIndex     ← IFUSrc.FetchIndexing [];
chanTopLeft ← CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50" ]];
chanTopRight ← CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", IFUSrc.dShLeftOut ]];
chanBotLeft ← CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", "DShRd", "DShWt", "DShA", "DShB",
"PhA", "PhB", "NotPhA", "NotPhB", "VBB", sftRtn, sftIn ]];
chanBotRight ← CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50","DShRd", "DShWt", "DShA", "DShB",
"PhA", "PhB", "NotPhA", "NotPhB", "VBB", sftRtn]];
cellType ← CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST[
fetchIndex,
CoreGlue.CellProc[l: chan, b: conn, r: chan, lCell: chanTopLeft, rCell: chanTopRight],
fetchControl,
ltDrPadIO,
stackControl,
mainPipeControl,
interlock,
CoreGlue.CellProc[l: chan, t: conn, r: chan, lCell: chanBotLeft, rCell: chanBotRight],
stackIndex ] ];
CoreFrame.WriteFrameCache[cellType]};
cellType ← CoreFrame.NewFrameCells[ name: "IFULeftColumn", rec: [first: top],
cells: LIST[ CoreGlue.CellProc[], cellType, CoreGlue.CellProc[] ]]};
DataColumn: PUBLIC PROC RETURNS [cellType: CellType] = {
name: ROPE ← CoreName.RopeNm["IFUDataColumnCore"];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
cellType ← CoreFrame.NewFrameCells[ name: name, rec: [first: left], cells: LIST[
CoreGlue.CellProc[ l: ext,  r: conn, xlate: TRUE],
CoreFrame.NewFrameCells[ name: "IFUDataColumnMain", rec: [first: top], cells: LIST[
IFUSrc.Fetch[],
IFUSrc.FetchBuf[],
IFUSrc.XaForm[],
IFUSrc.PCFormTop[],
IFUSrc.PCFormBot[],
IFUSrc.StackBuf[],
IFUSrc.LSForm[],
IFUSrc.ABForm[],
IFUSrc.ControlPipe[] ] ],
CoreGlue.CellProc[ l: conn, r: ext,  xlate: TRUE] ] ];
CoreFrame.WriteFrameCache[cellType]};
cellType ← CoreFrame.NewFrameCells[ name: "DataColumn", rec: [first: top], cells: LIST[
CoreGlue.CellProc[t:ext, b:conn, xlate: TRUE],
cellType,
CoreGlue.CellProc[t:conn, b:ext, xlate: TRUE] ] ]};
RtDrPadIO: PUBLIC PROC[sIn, altOut: ROPE ← NIL]
RETURNS [cellType: CellType, sOut: ROPE] = {
name: ROPE ← CoreName.RopeNm["IFURtDrPadIOCore"];
IF altOut#NIL THEN Signal[];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
{
Drive: PROC[dir: IFUCoreDrive.Dir, in, out: ROPE, inverted, dual: BOOL ← FALSE] = {
drives ← CONS[IFUCoreDrive.SpecificDrive[dir, in, out, inverted, dual], drives]};
drives:  IFUCoreDrive.Drives ← NIL;
toInside:  IFUCoreDrive.Dir = out;
toOutside: IFUCoreDrive.Dir = in;
Drive[toInside, "DPRejectB",    "DPRejectBA", FALSE, TRUE];
Drive[toInside, "DPFaultB.3",   "DPFaultBA.3"];
Drive[toInside, "DPFaultB.2",   "DPFaultBA.2"];
Drive[toInside, "DPFaultB.1",   "DPFaultBA.1"];
Drive[toInside, "DPFaultB.0",   "DPFaultBA.0"];
Drive[toOutside, "DPFaultBA.3",   "DPFaultBAA.3"];
Drive[toOutside, "DPFaultBA.2",   "DPFaultBAA.2"];
Drive[toOutside, "DPFaultBA.1",   "DPFaultBAA.1"];
Drive[toInside, "DPFaultBAA.3",  "DPFaultAB.3"];
Drive[toInside, "DPFaultBAA.2",  "DPFaultAB.2"];
Drive[toInside, "DPFaultBAA.1",  "DPFaultAB.1"];
Drive[toOutside, "DPCmnd2BA.7",  "DPCmnd2BAA.7"];
Drive[toOutside, "DPCmnd2BA.6",  "DPCmnd2BAA.6"];
Drive[toOutside, "DPCmnd2BA.5",  "DPCmnd2BAA.5"];
Drive[toOutside, "DPCmnd2BA.4",  "DPCmnd2BAA.4"];
Drive[toOutside, "DPCmnd2BA.3",  "DPCmnd2BAA.3"];
Drive[toOutside, "DPCmnd2BA.2",  "DPCmnd2BAA.2"];
Drive[toOutside, "DPCmnd2BA.1",  "DPCmnd2BAA.1"];
Drive[toOutside, "DPCmnd2BA.0",  "DPCmnd2BAA.0"];
Drive[toOutside, "Flag2BA.6",    "UserMode2BAA"];
Drive[toOutside, "EUAluOp2AB.3",  "EUAluOp2ABB.3"];
Drive[toOutside, "EUAluOp2AB.2",  "EUAluOp2ABB.2"];
Drive[toOutside, "EUAluOp2AB.1",  "EUAluOp2ABB.1"];
Drive[toOutside, "EUAluOp2AB.0",  "EUAluOp2ABB.0"];
Drive[toOutside, "EUCondSel2AB.3",  "EUCondSel2ABB.3"];
Drive[toOutside, "EUCondSel2AB.2",  "EUCondSel2ABB.2"];
Drive[toOutside, "EUCondSel2AB.1",  "EUCondSel2ABB.1"];
Drive[toOutside, "EUCondSel2AB.0",  "EUCondSel2ABB.0"];
Drive[toInside, "EUCondition2B",  "EUCondition2BA"];
Drive[toOutside, "EUWriteToPBus3AB", "EUWriteToPBus3ABB"];
Drive[toOutside, "EURdFromPBus3AB", "EURdFromPBus3ABB"];
Drive[toInside, "KPadsIn3BA",   "KPadsOut3BA", TRUE];
Drive[toInside, "KPadsIn3BA",   "KPadsOut3BA", TRUE];
Drive[toInside, "KPadsIn3BA",   "KPadsIn4Ac", FALSE, TRUE];
Drive[toInside, "KPadsIn3BA",   "KPadsIn4Ac", FALSE, TRUE];
Drive[toOutside, "X2ASrcLit1BA",   "X2ASrcLit1BAA"];
Drive[toInside, "X2ASrcLit1BAA",  "X2ASrcLit2Ac", FALSE, TRUE];
Drive[toInside, NIL,      "DebugABGD"];
Drive[toInside, NIL,      "DebugPC"];
Drive[toInside, NIL,      "DebugLSCF"];
Drive[toInside, NIL,      "DebugABStLim"];
[drives, sOut] ← IFUCoreDrive.CapDrives[drives, sIn];
cellType ← IFUCoreDrive.DrivesToFrame[name, drives];
IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];
CoreFrame.WriteFrameCache[cellType]};
};
[sIn, sOut] ← IFUCoreDrive.GetDShiftIO[cellType];
cellType ← CoreFrame.NewFrameCells[ name: "RtDrPadIO", rec: [first: left],
cells: LIST[ CoreGlue.CellProc[l: ext, r: conn], cellType ]]};
RightColumn: PUBLIC PROC RETURNS[cellType: CellType] = {
name: ROPE ← CoreName.RopeNm["IFURightColumnCore"];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
sftIn:  ROPE ← IFUSrc.dShLeftOut;
sftOut: ROPE ← IFUSrc.dShRightOut;
sft:  ROPE ← sftIn;
logo, instrDecode, rtDrPadIO: CellType;
idTopLeft, idTopRight, idBotLeft, idBotRight: CellType;
capBot
[rtDrPadIO,  sft] ← RtDrPadIO[sft];
[instrDecode,  sft] ← IFUSrc.InstrDecode[sft, sftOut];
capTop
logo      ← IFULogo[];
CoreFrame.FCT[logo].orient  ← mirrorX;
Note: left and right are deliberately swapped below. Want to make checkpoint in normal orientation so that all the specific generic drivers do not have to be reoriented. Left and right are set right just after reading in the checkpoint.
idTopLeft ← CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50" ]];
idTopRight ← CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", sftOut ]];
idBotLeft ← CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", "IDPlaFireV", "IDPlaNotPhA", "NotDPRejectBA", "Stage3ANormalBA", "KPadsIn3BA"]];
idBotRight ← CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", "DShRd", "DShWt", "DShA", "DShB", "KPadsIn3BA",
"PhA", "PhB", "NotPhA", "NotPhB", "IDPlaFireV", "IDPlaNotPhA", "NotDPRejectBA", "Stage3ANormalBA", sftIn ]];
cellType ← CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST [
logo,
CoreGlue.CellProc[l: chan, b: conn, r: chan, lCell: idTopLeft, rCell: idTopRight],
instrDecode,
rtDrPadIO,
CoreGlue.CellProc[l: chan, t: conn, r: chan, lCell: idBotLeft, rCell: idBotRight] ] ];
CoreFrame.WriteFrameCache[cellType] };
CoreFrame.FCT[cellType].orient ← mirrorX;
cellType ← CoreFrame.NewFrameCells[ name: "IFURightColumn", rec: [first: top], cells: LIST [
CoreGlue.CellProc[ ], cellType, CoreGlue.CellProc[ ] ] ] };
Heart: PUBLIC PROC RETURNS[cellType: CellType] = {
name: ROPE ← CoreName.RopeNm["IFUHeart"];
IF (cellType ← CoreFrame.ReadFrameCache[name]) =NIL THEN {
topLt: CellType ← CoreGlue.ChanSideCell[ side: top, layer: CCDUtils.cmosMet2,
list: LIST["VDD/96", "GND/96" ] ];
botLt: CellType ← CoreGlue.ChanSideCell[ side: bottom, layer: CCDUtils.cmosMet2,
list: LIST["VDD/96", "GND/96" ] ];
topRt: CellType ← CoreGlue.ChanSideCell[ side: top, layer: CCDUtils.cmosMet2,
list: LIST["VDD/96", "GND/96", "ResetAB" ] ];
botRt: CellType ← CoreGlue.ChanSideCell[ side: bottom, layer: CCDUtils.cmosMet2,
list: LIST["VDD/96", "GND/96", "KPadsOut3BA", "NotKPadsIn4Ac", "KPadsIn4Ac" ] ];
cellType ← CoreFrame.NewFrameCells[ name: name, rec: [first: left], cells: LIST [
LeftColumn[],
CoreGlue.CellProc[name: "IFULtColumnRoute", l: conn, r: conn,
t: chan, tCell: topLt,
b: chan, bCell: botLt],
DataColumn[],
CoreGlue.CellProc[name: "IFURtColumnRoute", l: conn, r: conn,
t: chan, tCell: topRt,
b: chan, bCell: botRt],
RightColumn[] ] ];
CoreFrame.WriteFrameCache[cellType] }};
PadHeart: PUBLIC PROC RETURNS[cellType: CellType] = {
ltTop: CellType ← CoreGlue.ChanSideCell[ side: top, layer: CCDUtils.cmosMet2,
list: LIST["PhA", "PhB", "ResetAB" ] ];
ltBot: CellType ← CoreGlue.ChanSideCell[ side: bottom, layer: CCDUtils.cmosMet2,
list: LIST["PhA", "PhB" ] ];
cellType ← CoreFrame.NewFrameCells[ name: "IFUPadHeart", rec: [first: left], cells: LIST [
PadLt[],
CoreFrame.NewFrameCells[ name: "IFUPadHeartMid", rec: [first: left], cells: LIST [
CoreGlue.CellProc
[name: "IFULtPadRoute", l: pwr, b: chan, r: conn, t: chan, bCell: ltBot, tCell: ltTop],
CoreFrame.NewFrameCells[ name: "IFUPadHeartY", rec: [first: top], cells: LIST [
CoreGlue.CellProc[t: ext, b: conn],
Heart[],
CoreGlue.CellProc[t: conn, b: ext] ] ],
CoreGlue.CellProc
[name: "IFURtPadRoute", l: conn, b: cap, r: pwr, t: cap] ] ],
PadRt[] ] ]};
Complete: PUBLIC PROC RETURNS[cellType: CellType] = {
name: ROPE ← CoreName.RopeNm["IFUComplete"];
IF (cellType ← CoreFrame.ReadFrameCache[name])=NIL THEN {
cellType ← CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST [
PadTop[],
CoreFrame.NewFrameCells[ name: "TopPadGlue", rec: [first: left], cells: LIST [
PadExt[left, top],
CoreGlue.CellProc[name: "IFUTopPadRoute", t: pwr, b: conn],
PadExt[right, top] ] ],
PadHeart[],
CoreFrame.NewFrameCells[ name: "BotPadGlue", rec: [first: left], cells: LIST [
PadExt[left, bottom],
CoreGlue.CellProc[name: "IFUBotPadRoute", t: conn, b: pwr],
PadExt[right, bottom] ] ],
PadBot[] ] ];
CoreFrame.WriteFrameCache[cellType]}};
END.