DragonMicroPLAImplA.mesa
Copyright © 1984 by Xerox Corporation. All rights reserved.
Last edited by TWilliams, August 27, 1984 4:58:00 pm PDT
Last edited by Curry, September 4, 1984 12:33:34 pm PDT
DIRECTORY
Commander,
Dragon,
DragonMicroPLA,
DragOpsCross,
IO;
DragonMicroPLAImplA: CEDAR PROGRAM
IMPORTS DragonMicroPLA, IO, Commander, Dragon EXPORTS DragonMicroPLA =
BEGIN OPEN DragonMicroPLA, DragOpsCross;
PLAMinterms: PUBLIC [0..MaxPLAMinterms) ← 0;
opCodeMap: PUBLIC PACKED ARRAY [0..256) OF BoolFalse;
PLA: PUBLIC REF PLAType ~ NEW[PLAType];
GeneratePLA: PUBLIC PROC = {
sigphBArgs: SigPhBArgs ← SigPhBArgsFalse;
m: MicroInst;
phBArgs: PhBArgs;
PlaRowPointer: PUBLIC [0..MaxPLAMinterms) ← 0;
PLAMinterms ← 0;
FOR opcode:Dragon.Opcode IN [0..256) DO
opCodeMap[opcode] ← FALSE;
ENDLOOP;
sigphBArgs.state.exceptions ← TRUE;
phBArgs.state.exceptions ← aboutToReset;
m ← [
doMacroJump: FALSE,
dontGetNextMacro: TRUE,
xBSource: trapPCGenerator,
lSource: [ zero, one ],
sSource: [ zero, zero ] ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.exceptions ← reset;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: trapPCGenerator,
lSource: [ zero, one ],
sSource: [ zero, zero ] ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.exceptions ← euCC;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: trapPCGenerator,
xASource: bAddrIFUReg,
bReg: ifuLevel3LS,
lSource: [ xBus, zero ],
sSource: [ xBus, zero ],
pushLevel3: TRUE ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.exceptions ← epFault;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.exceptions ← epReject;
m ← NoOpMicro;
m.delayed ← TRUE;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.exceptions ← cJump;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: pipe3PC,
xASource: bAddrIFUReg,
bReg: ifuLevel3LS,
lSource: [ xBus, zero ],
sSource: [ xBus, zero ] ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.exceptions ← none;
sigphBArgs.delayACycle ← TRUE;
phBArgs.delayACycle ← TRUE;
m ← NoOpMicro;
m.delayed ← TRUE;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.delayACycle ← FALSE;
sigphBArgs.state.cycle ← TRUE;
sigphBArgs.op ← SigInstByteTrue;
dMUL and dUMUL
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
aReg: [ s, minus1 ], -- Product.msw
bReg: [ s, zero ],  -- Multiplicand
cReg: [ s, minus1 ], -- Product.msw
aluOp: MulStep ];
FOR cycle:INT IN [1..16] DO
phBArgs.state.cycle ← cycle;
phBArgs.op ← dMUL; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dUMUL; AddPLARow[ sigphBArgs, phBArgs, m];
ENDLOOP;
phBArgs.state.cycle ← 17;
phBArgs.op ← dUMUL;
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
aReg: [ s, minus1 ], -- Product.msw
bReg: [ s, zero ],  -- Multiplicand
cReg: [ s, minus1 ], -- Product.msw
aluOp: MulAdj ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dMUL;
m ← [
dontGetNextMacro: FALSE,
cReg: [ s, zero ],  -- Product.lsw ← MQ
aluOp: RdMQ ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 18; -- dUMUL 18 same as dMUL 17
phBArgs.op ← dUMUL; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 32; -- Target of microjump
m ← [
aReg: constantZero,  -- Product.msw
bReg: constantZero,  -- Multiplicand
cReg: [ s, minus1 ], -- Product.msw ← 0
aluOp: Or ];
phBArgs.op ← dMUL; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dUMUL; AddPLARow[ sigphBArgs, phBArgs, m];
d*DIV
phBArgs.state.cycle ← 1;
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
aReg: [ s, one ],  -- Dividend.msw (temp location)
bReg: [ s, zero ],  -- Divisor
cReg: [ s, one ] ];  -- Dividend.msw (temp location)
m.aluOp  ← DivLdS;
phBArgs.op ← dMDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRDIV;  AddPLARow[ sigphBArgs, phBArgs, m];
m.aluOp ← DivLdU;
phBArgs.op ← dUDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 2;
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
aReg: [ s, one ],  -- Dividend.msw (temp location)
bReg: [ s, zero ],  -- Divisor
cReg: [ s, minus1 ], -- Remainder destination
condSel:  DivOvFl,
condEffect: macroTrap ];
m.aluOp ← DivCkU;
phBArgs.op ← dUDIV; AddPLARow[ sigphBArgs, phBArgs, m];
m.aluOp ← DivCkS;
phBArgs.op ← dMDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 3..33
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
aReg: [ s, minus1 ], -- Remainder source
bReg: [ s, zero ],  -- Divisor
cReg: [ s, minus1 ], -- Remainder destination
aluOp:  DivStep ];
FOR cycle: INT IN [3..33] DO
phBArgs.state.cycle ← cycle;
phBArgs.op ← dUDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dMDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRDIV; AddPLARow[ sigphBArgs, phBArgs, m];
ENDLOOP;
phBArgs.state.cycle ← 34;
m.aluOp ← DivAdjM;
phBArgs.op ← dUDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dMDIV; AddPLARow[ sigphBArgs, phBArgs, m];
m.aluOp ← DivAdjR;
phBArgs.op ← dRDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 35;
m.aluOp ← DivAdj;
phBArgs.op ← dUDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dMDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 36;
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
cReg: [ s, minus2 ], -- Quotient destination
aluOp: RdMQ ];
phBArgs.op ← dUDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dMDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 37;
m ← [
dontGetNextMacro: FALSE,
aReg: [ s, minus2 ], -- Quotient source
bReg: constantZero,  -- Zero
cReg: [ s, minus2 ], -- Quotient destination
deltaSa: pop,
aluOp: SAdd ];
phBArgs.op ← dUDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dMDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dFP;
phBArgs.state.cycle ← 1;
m ← [dontGetNextMacro: FALSE];
FPAddPLARow[ setMode, sigphBArgs, phBArgs, m];
m ← NoOpMicro;
FPAddPLARow[ sglUnCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglUnAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglUnCvt,  sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
bReg:    [ s, minus1 ],
xASource:  fpLdAMsw,
euPBusCmd:  StoreFP ];
FPAddPLARow[ dblUnCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnCvt, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiCom,  sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiAlu,  sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiMult, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
bReg:    [ s, minus1 ],
xASource:  fpLdBMsw,
euPBusCmd:  StoreFP ];
FPAddPLARow[ dblBiCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiAlu,  sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiMult, sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 2;
m ← NoOpMicro;
FPAddPLARow[ sglUnCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglUnAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglUnCvt,  sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnCvt, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiCom,  sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiAlu,  sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiMult, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
bReg:    [ s, minus2 ],
xASource:  fpLdALsw,
euPBusCmd:  StoreFP ];
FPAddPLARow[ dblBiCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiAlu,  sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiMult, sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 3;
m ← NoOpMicro;
FPAddPLARow[ sglUnCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglUnAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglUnCvt,  sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnCvt, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiCom,  sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiAlu,  sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiMult, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
bReg:    [ s, minus3 ],
xASource:  fpLdAMsw,
euPBusCmd:  StoreFP ];
FPAddPLARow[ dblBiCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiAlu,  sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiMult, sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 4;
m ← [
dontGetNextMacro: FALSE,
deltaSa:   pop,
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ sglUnCom, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: FALSE,
cReg:    [ s, zero ],
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ sglUnAlu, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
cReg:    [ s, zero ],
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ sglUnCvt,  sigphBArgs, phBArgs, m];
m ← NoOpMicro;
FPAddPLARow[ dblUnCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnCvt, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiCom,  sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiAlu,  sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiMult, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiAlu,  sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiMult, sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 5;
m ← [
dontGetNextMacro: FALSE,
deltaSc:   push,
cReg:    [ s, one ],
xASource:  fpUnldLsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ sglUnCvt, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: FALSE,
deltaSa:   pop,
deltaSb:   pop,
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ dblUnCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiCom,  sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
cReg:    [ s, minus1 ],
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ dblUnAlu, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: FALSE,
deltaSa:   pop,
cReg:    [ s, minus1 ],
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ dblUnCvt, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiAlu,  sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: FALSE,
deltaSa:   pop,
cReg:    [ s, minus1 ],
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPMult ];
FPAddPLARow[ sglBiMult, sigphBArgs, phBArgs, m];
m ← NoOpMicro;
FPAddPLARow[ dblBiCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiAlu,  sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiMult, sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 6;
m ← [
dontGetNextMacro: FALSE,
cReg:    [ s, zero ],
xASource:  fpUnldLsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ dblUnAlu, sigphBArgs, phBArgs, m];
m ← NoOpMicro;
FPAddPLARow[ dblBiCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiAlu,  sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiMult, sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 7;
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
deltaSa:   pop,
deltaSb:   pop, -- Two more left for next cycle
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ dblBiCom, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
cReg:    [ s, minus3 ],
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ dblBiAlu, sigphBArgs, phBArgs, m];
m ← NoOpMicro;
FPAddPLARow[ dblBiMult, sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 8;
m ← [
dontGetNextMacro: FALSE,
deltaSa:   pop,
deltaSb:   pop, -- Last two
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ dblBiCom, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: FALSE,
deltaSa:   pop,
deltaSb:   pop,
cReg:    [ s, minus2 ],
xASource:  fpUnldLsw,
euPBusCmd:  FetchFPAlu ];
FPAddPLARow[ dblBiAlu, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
cReg:    [ s, minus3 ],
xASource:  fpUnldMsw,
euPBusCmd:  FetchFPMult ];
FPAddPLARow[ dblBiMult, sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 9;
m ← [
dontGetNextMacro: FALSE,
deltaSa:   pop,
deltaSb:   pop,
cReg:    [ s, minus2 ],
xASource:  fpUnldLsw,
euPBusCmd:  FetchFPMult ];
FPAddPLARow[ dblBiMult, sigphBArgs, phBArgs, m];
sigphBArgs.alpha ← SigInstByteFalse;
phBArgs.op ← dSIFUR;
phBArgs.state.cycle ← 1;
m ← NoOpMicro; -- to allow ALU result to reach Result3
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 2;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 3;
S ← S-1 EU driving ifu XBus during A with S
IFU internal destination specified by level 3 cAddr
m ← [
dontGetNextMacro: FALSE,
deltaSa: pop ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSJ;
phBArgs.state.cycle ← 1;
m ← NoOpMicro; -- to allow Xa to latch Result3
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 2;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 3;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 4; -- S ← S-1
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: pcPlusXA,
deltaSa: pop ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSFC;
phBArgs.state.cycle ← 1;
m ← NoOpMicro; -- to allow Xa to latch Result3
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 2;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 3;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 4; -- S ← S-1
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: xA,
deltaSa: pop,
pipedPLSASpec: pLenLSnext,
iStackPostEffect: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSFCI;
phBArgs.state.cycle ← 1;
m ← NoOpMicro; -- to allow Xa to latch Result3
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 2;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 3;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 4; -- S ← S-1
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: xA,
deltaS: 0, -- shouldn't SFCI pop S?
pipedPLSASpec: pLenLSnext,
iStackPostEffect: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dCST;
phBArgs.state.cycle ← 1;
This cycle will invariably be Delayed (automatically) by the pipe since cycle 0 was a fetch into S+1
-- IF [S+1] = [S] THEN double microPC
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
aReg: [ s, one ],
bReg: abStackTop,
aluOp: VSub,
condSel: EZ,
condEffect: microJump ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 2;
m ← NoOpMicro; -- Allow ALU result to get back
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 3;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 4; -- [] ← ([S-2]+alpha)^, release hold, S ← S+1
m ← [
aReg: [ s, minus2 ],
xASource: alpha,
aluRtIsK: TRUE,
deltaSc: push,
aluOp: VAdd,
euPBusCmd: Fetch ];
AddPLARow[ sigphBArgs, phBArgs, m];
Remember that when doing microjumps, you can't get next macro until the condition has been tested since the opcode must be the same (cycles 2 and 3 above are necessary). This could be changed fairly easily to be similar to macro conditional jumps where the condition true means restart the instruction at cycle 32.
phBArgs.state.cycle ← 32; -- target of microjump, ([S-2]+alpha)^ ← [S-1], release hold, S ← S+1
m ← [
aReg: [ s, minus2 ],
bReg: [ s, minus1 ],
xASource: alpha,
aluRtIsK: TRUE,
deltaSc: push,
aluOp: VAdd,
euPBusCmd: Store ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dEXCH;
phBArgs.state.cycle ← 1;
m ← [
dontBypass: TRUE,
bReg: [ s, minus1 ],
cReg: cStackTop ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.cycle ← 0;
sigphBArgs.op ← SigInstByteFalse;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: trapPCGenerator,
iStackPostEffect: push,
iTrapPostEffect: disable ];
phBArgs.state.exceptions ← rschlWait;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.exceptions ← iStkOFlow;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.exceptions ← eStkOFlow;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.exceptions ← iFtchFault;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.state.exceptions ← none;
sigphBArgs.instReady ← TRUE;
phBArgs.instReady ← FALSE;
m ← NoOpMicro;
m.delayed ← TRUE;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.instReady ← TRUE;
sigphBArgs.pushPending ← TRUE;
phBArgs.pushPending ← TRUE;
sigphBArgs.op ← SigInstByteTrue;
phBArgs.op ← dRET;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRETT;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRETN;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dLIFUR;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.pushPending ← FALSE;
sigphBArgs.popPending ← TRUE;
phBArgs.popPending ← TRUE;
phBArgs.op ← dRET;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRETT;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRETN;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dLIFUR;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dEP;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.popPending ← FALSE;
sigphBArgs.iStkEmpty ← TRUE;
phBArgs.iStkEmpty ← TRUE;
sigphBArgs.pushPending ← TRUE;
phBArgs.pushPending ← FALSE;
phBArgs.op ← dEP; -- IStack Underflow is the default for trapPC
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: trapPCGenerator,
lSource: [ s, alpha ],
pipedPLSASpec: pLenLSnext,
iStackPostEffect: push, -- this push differentiates this trap from the following
iTrapPostEffect: disable ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.popPending ← TRUE;
phBArgs.popPending ← FALSE;
IStack Underflow is the default for trapPC
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: trapPCGenerator,
sSource: [ l, alpha ],
iTrapPostEffect: disable ];
phBArgs.op ← dRET;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRETT;
m.sSource ← [ s, zero ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRETN;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.iStkEmpty ← FALSE;
sigphBArgs.popPending ← FALSE;
sigphBArgs.pushPending ← FALSE;
Generate1PLA[sigphBArgs, phBArgs]; -- Arbitrary break
}; -- of GeneratePLA
Generate1PLA: PROC [sigphBArgs: SigPhBArgs, phBArgs: PhBArgs] = {
m: MicroInst ← DefaultMicro;
phBArgs.op ← dJEBB;
m ← [
aReg: abStackTop,
xASource: beta,
aluRtIsK: TRUE,
deltaSa: pop,
aluOp: VSub,
condEffect: macroJump,
condSel: EZ,
doMacroJump: FALSE,
dontGetNextMacro: FALSE,
xBSource: pcPlusLen,
pipedPLSASpec: pAlphasLSnext];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dJNEBB;
m.condSel ← NE;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dJEBBJ;
m.doMacroJump ← TRUE;
m.dontGetNextMacro ← TRUE;
m.xBSource ← pcPlusAlphaS;
m.pipedPLSASpec ← pLenLSnext;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dJNEBBJ;
m.condSel ← EZ;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRJEB;
sigphBArgs.op.bit5 ← FALSE; -- Bit 4 distinguishes dRJEB from dRJEBJ
sigphBArgs.op.bit6 ← FALSE;
sigphBArgs.op.bit7 ← FALSE;
m ← [
aluOp: VSub,
condSel: op57,
condEffect: macroJump,
doMacroJump: FALSE,
dontGetNextMacro: FALSE,
xBSource: pcPlusLen,
pipedPLSASpec: pAlphasLSnext];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRJEBJ;
m ← [
aluOp: VSub,
condSel: op57,
condEffect: macroJump,
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: pcPlusAlphaS,
pipedPLSASpec: pLenLSnext];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.op.bit4 ← FALSE;
sigphBArgs.beta.bit1 ← TRUE; -- sd
phBArgs.beta ← 377B;
m ← BlankMicro;
m.aReg ← [ s, minus1 ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 0;
m.aReg ← [ s, zero ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta.bit1 ← FALSE; -- sd
sigphBArgs.beta.bit2 ← TRUE; -- opt
sigphBArgs.beta.bit4 ← TRUE; -- reg.bit0
sigphBArgs.beta.bit5 ← TRUE; -- reg.bit1
m ← BlankMicro;
m.bReg ← [cBase, beta47 ];
phBArgs.beta ← 40B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 44B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 50B;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta.bit7 ← TRUE;
phBArgs.beta ← 54B;
m.bReg ← [s, zero ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 55B;
m.bReg ← [s, minus1 ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta.bit3 ← TRUE; -- aux
sigphBArgs.beta.bit4 ← FALSE; -- reg.bit0
sigphBArgs.beta.bit5 ← FALSE; -- reg.bit1
sigphBArgs.beta.bit7 ← FALSE; -- reg.bit3
phBArgs.beta ← 0B;
m.bReg ← [l, beta47 ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 20B;
m.bReg ← [aBase, beta47 ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta ← SigInstByteFalse;
phBArgs.beta ← 257B;
m ← BlankMicro;
m.deltaSa ← pop;
sigphBArgs.beta.bit0 ← TRUE; -- sdd
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta.bit0 ← FALSE; -- sdd
sigphBArgs.beta.bit2 ← TRUE; -- opt
sigphBArgs.beta.bit4 ← TRUE; -- reg.bit0
sigphBArgs.beta.bit5 ← TRUE; -- reg.bit1
sigphBArgs.beta.bit6 ← TRUE; -- reg.bit2
m ← BlankMicro;
m.deltaSb ← pop;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta ← SigInstByteFalse;
sigphBArgs.op ← SigInstByteTrue;
m ← DefaultMicro;
phBArgs.op ← dJ1;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dJ2;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dJ3;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dJ5;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dJB;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: pcPlusAlphaS ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dJDB;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: pcPlusBetaAlphaS ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dDJ;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: deltaGammaBetaAlpha ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSJ;
m ← [ -- ifuXBus ← [S]
dontGetNextMacro: TRUE,
xBSource: pc,
bReg: abStackTop,
cReg: ifuXBus ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRET;
sigphBArgs.pushPending ← TRUE;
phBArgs.pushPending ← FALSE;
sigphBArgs.popPending ← TRUE;
phBArgs.popPending ← FALSE;
sigphBArgs.iStkEmpty ← TRUE;
phBArgs.iStkEmpty ← FALSE;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: iStackPC,
xASource: bAddrIFUReg,
bReg: ifuYoungestL,
lSource: [ xBus, zero ],
sSource: [ l, alpha ],
iStackPostEffect: pop ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRETN;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: iStackPC,
xASource: bAddrIFUReg,
bReg: ifuYoungestL,
lSource: [ xBus, zero ],
iStackPostEffect: pop ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRETT;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: iStackPC,
xASource: bAddrIFUReg,
bReg: ifuYoungestL,
lSource: [ xBus, zero ],
iStackPostEffect: pop,
iTrapPostEffect: enable ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.pushPending ← FALSE;
sigphBArgs.popPending ← FALSE;
sigphBArgs.iStkEmpty ← FALSE;
phBArgs.op ← dLFC;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: pcPlusBetaAlphaS,
pipedPLSASpec: pLenLSnext,
iStackPostEffect: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dDFC;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: deltaGammaBetaAlpha,
pipedPLSASpec: pLenLSnext,
iStackPostEffect: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSFC;
m ← [ -- ifuXBus ← [S]
dontGetNextMacro: TRUE,
xBSource: pc,
bReg: abStackTop,
cReg: ifuXBus ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSFCI;
m ← [ -- ifuXBus ← [S]^
dontGetNextMacro: TRUE,
xBSource: pc,
bReg: abStackTop,
cReg: ifuXBus,
euPBusCmd: Fetch ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dIN;
m ← [
aReg: abStackTop,
xASource: alpha,
aluRtIsK: TRUE,
cReg: cStackTop,
aluOp: VAdd,
euPBusCmd: IOFetch ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRB;
m ← [
aReg: abStackTop,
xASource: alpha,
aluRtIsK: TRUE,
cReg: cStackTop,
aluOp: VAdd,
euPBusCmd: Fetch ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRSB;
m ← [
aReg: abStackTop,
xASource: alpha,
aluRtIsK: TRUE,
cReg: [ s, one ],
deltaSc: push,
aluOp: VAdd,
euPBusCmd: Fetch ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dLRI0;
sigphBArgs.op.bit4 ← FALSE;
sigphBArgs.op.bit5 ← FALSE;
sigphBArgs.op.bit6 ← FALSE;
sigphBArgs.op.bit7 ← FALSE;
m ← [
aReg: [ l, op47 ],
xASource: alpha,
aluRtIsK: TRUE,
cReg: [ s, one ],
deltaSc: push,
aluOp: VAdd,
euPBusCmd: Fetch ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.op ← SigInstByteTrue;
Save me for lisp
phBArgs.op ← dLGF;
m ← [
aReg: euGF,
xASource: betaAlpha,
aluRtIsK: TRUE,
cReg: [ s, one ],
deltaSc: push,
aluOp: VAdd,
euPBusCmd: Fetch ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRRI;
m ← [
aReg: [ l, beta47],
xASource: alpha,
aluRtIsK: TRUE,
cReg: [ l, beta03 ],
aluOp: VAdd,
euPBusCmd: Fetch ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRAI;
m ← [
aReg: [ aBase, beta47],
xASource: alpha,
aluRtIsK: TRUE,
cReg: [ l, beta03 ],
aluOp: VAdd,
euPBusCmd: Fetch ];
AddPLARow[ sigphBArgs, phBArgs, m];
dRRX is with the RR instructions
phBArgs.op ← dCST;
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
aReg: [ s, minus2 ],
xASource: alpha,
aluRtIsK: TRUE,
cReg: [ s, one ],
aluOp: VAdd,
euPBusCmd: FetchHold ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dOUT;
m ← [
aReg: abStackTop,
bReg: [ s, minus1 ],
xASource: alpha,
aluRtIsK: TRUE,
deltaSa: pop,
deltaSb: pop,
aluOp: VAdd,
euPBusCmd: IOStore ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dWB;
m ← [
aReg: abStackTop,
bReg: [ s, minus1 ],
xASource: alpha,
aluRtIsK: TRUE,
deltaSa: pop,
deltaSb: pop,
aluOp: VAdd,
euPBusCmd: Store ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dWSB;
m ← [
aReg: [ s, minus1 ],
bReg: abStackTop,
xASource: alpha,
aluRtIsK: TRUE,
deltaSa: pop,
deltaSb: pop,
aluOp: VAdd,
euPBusCmd: Store ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dPSB;
m ← [
aReg: [ s, minus1 ],
bReg: abStackTop,
xASource: alpha,
aluRtIsK: TRUE,
deltaSa: pop,
aluOp: VAdd,
euPBusCmd: Store ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSRI0;
sigphBArgs.op.bit4 ← FALSE;
sigphBArgs.op.bit5 ← FALSE;
sigphBArgs.op.bit6 ← FALSE;
sigphBArgs.op.bit7 ← FALSE;
m ← [
aReg: [ l, op47 ],
bReg: [ s, zero ],
xASource: alpha,
aluRtIsK: TRUE,
deltaSb: pop,
aluOp: VAdd,
euPBusCmd: Store ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.op ← SigInstByteTrue;
phBArgs.op ← dWRI;
m ← [
aReg: [ l, beta47],
bReg: [ l, beta03 ],
xASource: alpha,
aluRtIsK: TRUE,
aluOp: VAdd,
euPBusCmd: Store ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dWAI;
m ← [
aReg: [ aBase, beta47],
bReg: [ l, beta03 ],
xASource: alpha,
aluRtIsK: TRUE,
aluOp: VAdd,
euPBusCmd: Store ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dDIS;
m ← [deltaSa: pop];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dAS;
m ← [sSource: [s, alpha]];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dAL;
m ← [lSource: [l, alpha]];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dASL;
m ← [sSource: [ l, alpha]];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dEP;
m ← [lSource: [ s, alpha]];
sigphBArgs.popPending ← TRUE;
phBArgs.popPending ← FALSE;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.popPending ← FALSE;
sigphBArgs.pushPending ← TRUE;
phBArgs.pushPending ← TRUE;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.pushPending ← FALSE;
sigphBArgs.iStkEmpty ← TRUE;
phBArgs.iStkEmpty ← FALSE;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.iStkEmpty ← FALSE;
phBArgs.op ← dFSDB;
m ← [
xASource: betaAlpha,
aluRtIsK: TRUE,
cReg: euField ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dLIB;
m ← [
xASource: alpha,
aluRtIsK: TRUE,
cReg: [ s, one ],
deltaSc: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dLIDB;
m ← [
xASource: betaAlpha,
aluRtIsK: TRUE,
cReg: [ s, one ],
deltaSc: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dLIQB;
m ← [
xASource: deltaGammaBetaAlpha,
aluRtIsK: TRUE,
cReg: [ s, one ],
deltaSc: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dLC0;
sigphBArgs.op.bit5 ← FALSE;
sigphBArgs.op.bit6 ← FALSE;
sigphBArgs.op.bit7 ← FALSE;
m ← [
bReg: [ cBase, op47 ],
cReg: [ s, one ],
deltaSc: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dLR0;
sigphBArgs.op.bit4 ←FALSE;
m ← [
bReg: [ l, op47 ],
cReg: [ s, one ],
deltaSc: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSR0;
m ← [
bReg: [ s, zero ],
cReg: [ l, op47 ],
deltaSb: pop ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.op ← SigInstByteTrue;
phBArgs.op ← dDUP;
m ← [
bReg: abStackTop,
cReg: [ s, one ],
deltaSc: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dEXDIS;
m ← [
bReg: abStackTop,
cReg: [ s, minus1 ],
deltaSa: pop ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dEXCH;
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
bReg: abStackTop,
cReg: [ s, minus1 ] ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSEUR;
m ← [
bReg: abStackTop,
cReg: [ zero, alpha ],
deltaSb: pop ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSIFUR;
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
bReg: abStackTop,
cReg: [ zero, alpha ] ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dLEUR;
m ← [
bReg: [ zero, alpha ],
cReg: [ s, one ],
deltaSc: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dLIFUR;
sigphBArgs.pushPending ← TRUE;
phBArgs.pushPending ← FALSE;
m ← [
bReg: [zero, alpha],
xASource: bAddrIFUReg,
aluRtIsK: TRUE,
cReg: [ s, one ],
deltaSc: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.pushPending ← FALSE;
sigphBArgs.popPending ← TRUE;
phBArgs.popPending ← FALSE;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.popPending ← FALSE;
phBArgs.op ← dADDB;
m ← [
aReg: abStackTop,
xASource: alpha,
aluRtIsK: TRUE,
cReg: cStackTop,
aluOp: SAdd,
condSel: OvFl ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dADDDB;
m ← [
aReg: abStackTop,
xASource: betaAlpha,
aluRtIsK: TRUE,
cReg: cStackTop,
aluOp: SAdd,
condSel: OvFl ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSUBB;
m ← [
aReg: abStackTop,
xASource: alpha,
aluRtIsK: TRUE,
cReg: cStackTop,
aluOp: SSub,
condSel: OvFl ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSHL;
m ← [
aReg: abStackTop,
bReg: [ cBase, zero ],
xASource: betaAlpha,
cReg: cStackTop,
aluOp: FOPK ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSHR;
m ← [
aReg: abStackTop,
bReg: [ s, zero ],
xASource: betaAlpha,
cReg: cStackTop,
aluOp: FOPK ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dADD;
m ← [
aReg: [ s, minus1 ],
bReg: abStackTop,
cReg: [ s, minus1 ],
deltaSa: pop,
aluOp: SAdd,
condSel: OvFl,
condEffect: macroTrap ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dSUB;
m ← [
aReg: [ s, minus1 ],
bReg: [ s, zero ],
cReg: [ s, minus1 ],
deltaSa: pop,
aluOp: SSub,
condSel: OvFl,
condEffect: macroTrap ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dMUL;
m ← [-- MCandSign ← LtSign
dontGetNextMacro: TRUE,
xBSource: pc,
aReg: [ s, zero ],  -- Lt ← S=Multiplicand
bReg: [ s, minus1 ], -- MQ ← Rt ← Multiplier
cReg: [ s, minus1 ], -- Product.msw
condSel: EZ,    -- IF aluout=Lt=Multiplicand is zero then quit
condEffect: microJump]; -- cycle ← 32 if zero
m.aluOp ← MulLdS;
phBArgs.op ← dMUL; AddPLARow[ sigphBArgs, phBArgs, m];
m.aluOp ← MulLdU;
phBArgs.op ← dUMUL; AddPLARow[ sigphBArgs, phBArgs, m];
d*DIV
m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
aReg: [ s, minus2 ], -- Dividend MSW
bReg: [ s, minus1 ], -- Dividend LSW
cReg: [ s, one ],
aluOp: DivLdDbl];
phBArgs.op ← dMDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRDIV; AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dUDIV; AddPLARow[ sigphBArgs, phBArgs, m];
Generate2PLA[sigphBArgs, phBArgs]; -- Arbitrary break
}; -- of Generate1PLA
Generate2PLA: PROC [sigphBArgs: SigPhBArgs, phBArgs: PhBArgs] = {
m: MicroInst ← DefaultMicro;
phBArgs.op ← dFP;
m ← [
dontGetNextMacro: TRUE, -- delay one for KBus contention
xBSource:   pc,
xASource:  fpLdMode,
euPBusCmd:  StoreFP];
FPAddPLARow[ setMode, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
bReg:    [ s, zero ],
xASource:  fpLdAMsw,
euPBusCmd:  StoreFP];
FPAddPLARow[ sglUnCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglUnAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglUnCvt, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
bReg:    [ s, zero ],
xASource:  fpLdALsw,
euPBusCmd:  StoreFP];
FPAddPLARow[ dblUnCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblUnCvt, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
bReg:    [ s, zero ],
xASource:  fpLdBMsw,
euPBusCmd:  StoreFP];
FPAddPLARow[ sglBiCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ sglBiMult, sigphBArgs, phBArgs, m];
m ← [
dontGetNextMacro: TRUE,
xBSource:   pc,
bReg:    [ s, zero ],
xASource:  fpLdBLsw,
euPBusCmd:  StoreFP];
FPAddPLARow[ dblBiCom, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiAlu, sigphBArgs, phBArgs, m];
FPAddPLARow[ dblBiMult, sigphBArgs, phBArgs, m];
phBArgs.op ← dBNDCK;
m ← [
aReg: [ s, minus1 ],
bReg: [ s, zero ],
deltaSa: pop,
aluOp: VSub, -- This does not need to be BndChk since cReg is not used
condSel: BC,
condEffect: macroTrap ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRADD;
sigphBArgs.op.bit4 ← FALSE;
sigphBArgs.op.bit5 ← FALSE;
sigphBArgs.op.bit6 ← FALSE;
sigphBArgs.op.bit7 ← FALSE;
m ← DefaultMicro;
sigphBArgs.beta.bit0 ← TRUE; -- aOpt
sigphBArgs.beta.bit3 ← TRUE; -- aux
phBArgs.beta ← 0B;
m.aReg ← [l, alpha47 ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 20B; -- aux
m.aReg ← [aBase, alpha47 ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta.bit3 ← FALSE; -- aux
phBArgs.beta ← 200B;
sigphBArgs.alpha.bit4 ← TRUE; -- a0
sigphBArgs.alpha.bit5 ← TRUE; -- a1
m.aReg ← [cBase, alpha47 ];
phBArgs.alpha ← 0B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.alpha ← 4B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.alpha ← 10B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.alpha ← 16B;
sigphBArgs.alpha.bit7 ← TRUE; --a3
m.aReg ← [s, zero ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.alpha ← 17B;
m.aReg ← [s, minus1 ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.alpha.bit7 ← FALSE; --a3
sigphBArgs.alpha.bit6 ← TRUE; --a2
m ← BlankMicro;
m.deltaSa ← pop;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.alpha ← SigInstByteFalse;
sigphBArgs.beta ← SigInstByteFalse;
sigphBArgs.beta.bit2 ← TRUE; -- bOpt
sigphBArgs.beta.bit3 ← TRUE; -- aux
phBArgs.beta ← 0B;
m ← BlankMicro;
m.bReg ← [l, beta47 ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 20B; -- aux
m.bReg ← [aBase, beta47 ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta.bit3 ← FALSE;
phBArgs.beta ← 40B;
sigphBArgs.beta.bit4 ← TRUE; -- b0
sigphBArgs.beta.bit5 ← TRUE; -- b1
m.bReg ← [cBase, beta47 ];
phBArgs.beta ← 40B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 44B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 50B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 54B;
sigphBArgs.beta.bit7 ← TRUE; -- b3
m.bReg ← [s, zero ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 57B;
m.bReg ← [s, minus1 ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta.bit7 ← FALSE; --b3
sigphBArgs.beta.bit6 ← TRUE; --b2
m ← BlankMicro;
m.deltaSb ← pop;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta ← SigInstByteFalse;
sigphBArgs.beta.bit1 ← TRUE; -- cOpt
sigphBArgs.beta.bit3 ← TRUE; -- aux
phBArgs.beta ← 0B;
m ← BlankMicro;
m.cReg ← [l, alpha03 ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.beta ← 20B; -- aux
m.cReg ← [aBase, alpha03 ];
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.beta.bit3 ← FALSE;
phBArgs.beta ← 100B;
sigphBArgs.alpha.bit0 ← TRUE; -- c0
sigphBArgs.alpha.bit1 ← TRUE; -- c1
m.cReg ← [cBase, alpha03 ];
phBArgs.alpha ← 0B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.alpha ← 100B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.alpha ← 200B;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.alpha ← 300B;
sigphBArgs.alpha.bit2 ← TRUE; --c2
sigphBArgs.alpha.bit3 ← TRUE; -- c3
m.cReg ← [s, zero ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.alpha ← 320B;
m.cReg ← [s, minus1 ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.alpha ← 340B;
m.cReg ← [s, one ];
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.alpha ← 360B;
m.deltaSc ← push;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.alpha ← SigInstByteFalse;
sigphBArgs.beta ← SigInstByteFalse;
m ← BlankMicro;
m.aluOp ← op47;
AddPLARow[ sigphBArgs, phBArgs, m];
sigphBArgs.op.bit4 ← TRUE;
sigphBArgs.op.bit5 ← TRUE;
sigphBArgs.op.bit6 ← TRUE;
phBArgs.op ← dRADD; -- or dRSUB
m ← BlankMicro;
m.condSel ← OvFl;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRLADD; -- or dRLSUB
m.condSel ← IL;
AddPLARow[ sigphBArgs, phBArgs, m];
We have purposely defined the last four bits of dRRX(1000) such that oring VAdd(1100) converts its RR generated aluOp into VAdd(1100).
sigphBArgs.op ← SigInstByteTrue;
phBArgs.op ← dRRX;
m ← BlankMicro;
m.aluOp ← VAdd;
m.euPBusCmd ← Fetch;
AddPLARow[ sigphBArgs, phBArgs, m];
phBArgs.op ← dRBC;
m ← BlankMicro;
m.condSel ← BC;
m.condEffect ← macroTrap;
AddPLARow[ sigphBArgs, phBArgs, m];
Now Do the generation of the XOP based upon all unused opcodes.
FOR opcode:Dragon.Opcode IN [0..256) DO
oplength: [0..5] ← Dragon.OpLength [ opcode ];
IF opCodeMap[opcode] THEN LOOP;
TRUSTED {phBArgs.op ← LOOPHOLE [opcode]; };
phBArgs.state.cycle ← 0;
IF oplength=1 THEN
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: xopGenerator,
pipedPLSASpec: pLenLSnext,
iStackPostEffect: push ]
ELSE m ← [
dontGetNextMacro: TRUE,
xBSource: pc,
xASource: deltaGammaBetaAlpha,
aluRtIsK: TRUE,
cReg: [ s, one ] ];
AddPLARow[ sigphBArgs, phBArgs, m];
IF oplength>1 THEN {
phBArgs.state.cycle ← 1;
m ← [
doMacroJump: TRUE,
dontGetNextMacro: TRUE,
xBSource: xopGenerator,
pipedPLSASpec: pLenLSnext,
iStackPostEffect: push,
deltaSc: push ];
AddPLARow[ sigphBArgs, phBArgs, m];
};
ENDLOOP;
}; -- of Generate2PLA

PrintTotal: Commander.CommandProc = {
screen: IO.STREAM ← cmd.out;
screen.PutF["There were %g Microcode minterms generated.\n", IO.int[PLAMinterms]];
};
Commander.Register [ key: "PLASize", proc: PrintTotal, doc: "Size of Dragon Microcode PLA."];
END.