dDFC => {
Effect: call proc at AlphaBetaGammaDelta
newPC ← rest;
GO TO call;
};
dLIQB => {
Effect: [S]𡤊lphaBetaGammaDelta; S←S+1
resWord ← rest;
GO TO storeReg;
};
dJ5 => {
Effect: noop
GO TO noCheck;
};
dJQB => {
Effect: noop
newPC ← rest;
GO TO jump;
};
dOR, dAND, dRX, dBC, dADD, dSUB, dLADD, dLSUB => {
Effect: [S-1]←[S-1] op [S]; S←S-1;
op: ALUOps;
cond: TrapIndex ← ALUCondFalse;
wordA: Word = RegFetchInline[sM1];
SELECT inst
FROM
dOR => {
Effect: [S-1]←[S-1] OR [S]; S←S-1
op ← Or;
};
dAND => {
Effect: [S-1]←[S-1] AND [S]; S←S-1
op ← And;
};
dRX => {
Effect: [S-1]←([S-1]+[S])^; S←S-1
resAddr ← VanillaAdd[wordA, topOfStack];
GO TO memFetch;
};
dBC => {
Effect: trap if [S-1] < 0 OR [S-1]-[S] >= 0; S←S-1
op ← BndChk;
cond ← ALUCondBC;
};
dADD => {
Effect: [S-1]←[S-1]+[S]+carry; carry𡤀 trap on overflow; S←S-1
op ← SAdd;
cond ← ALUCondOver;
};
dSUB => {
Effect: [S-1]←[S-1]-[S]-carry; carry𡤀 trap on overflow; S←S-1
op ← SSub;
cond ← ALUCondOver;
};
dLADD => {
Effect: [S-1]←[S-1]+[S]; carry𡤀 trap on overflow or Lisp NaN; S←S-1
op ← LAdd;
cond ← ALUCondIL;
};
dLSUB => {
Effect: [S-1]←[S-1]-[S]; carry𡤀 trap on overflow or Lisp NaN; S←S-1
op ← LSub;
cond ← ALUCondIL;
};
ENDCASE => GO TO xop;
[resWord, trapCode] ← DoALUOp[processor, wordA, topOfStack, op, cond];
GO TO aluDone;
};
dDUP =>
GO
TO storeReg;
Effect: [S+1]←[S]; S←S+1
dDIS =>
GO
TO done;
Effect: S←S-1
dEXDIS =>
GO
TO storeReg;
Effect: [S-1]←[S]; S←S-1
dSFC => {
Effect: call proc at [S]; S←S-1
newPC ← topOfStack;
GO TO call;
};
dSFCI => {
Effect: call proc at ([S])^
[newPC, trapCode] ← MemFetch[topOfStack];
IF trapCode # NoFault THEN GO TO memFault;
GO TO call;
};
dRETN =>
GO
TO return;
Effect: return from proc (no stack change)
dKFC => {
Effect: [S+1]←Status; PC←InstTrap[KFC]; set kernel mode; disable traps; S←S+1
IF
NOT LizardHeart.WillPushOverflow[processor]
THEN {
status.userMode ← status.trapsEnabled ← FALSE;
processor.regs[ifuStatus] ← LOOPHOLE[status];
newPC ← CardToWord[DragOpsCrossUtils.XopToBytePC[inst]];
RegStore[resReg, resWord];
};
GO TO call;
};
dJ1 =>
GO
TO noCheck;
Effect: noop
dJS => {
Effect: PC←PC+[S]; S←S-1
newPC ← VanillaAdd[thisPC, topOfStack];
IF WillEUStackOverflow[] THEN GO TO euOverflow;
GO TO jump;
};
dLC0, dLC1, dLC2, dLC3, dLC4, dLC5, dLC6, dLC7 => {
Effect: [S+1]𡤌onstants[n]; S←S+1
resReg ← RegPlus[euConstant, ORD[inst] MOD 8];
GO TO pushReg;
};
dLR0 => {
Effect: [S+1]←[L+n]; S←S+1
resReg ← StackPlus[regL, ORD[inst] MOD 16];
GO TO pushReg;
};
dSR0 => {
Effect: [L+n]←[S]; S←S-1
resReg ← StackPlus[regL, ORD[inst] MOD 16];
GO TO storeReg;
};
dQOR, dQAND, dQRX, dQBC, dQADD, dQSUB, dQLADD, dQLSUB => {
OPEN form: LOOPHOLE[formBytes2, QRformat];
wordB: Word ← RegFetchInline[CalcReg[form.aux, form.opt, form.reg]];
op: ALUOps;
cond: TrapIndex ← ALUCondFalse;
sd: [0..1] ← 1;
srcReg: ProcessorRegister ← regS;
SELECT form.aOp
FROM
topAtop => sd ← 0;
C: [S], A: [S], B: general
pushAtop => {};
C: [S+1]+, A: [S], B: general
pushA0 => srcReg ← euConstant;
C: [S+1]+, A: c0, B: general
pushA1 => srcReg ← RegPlus[euConstant, 1];
C: [S+1]+, A: c1, B: general
ENDCASE;
topOfStack ← RegFetchInline[srcReg]; -- the A operand word
resReg ← StackPlus[regS, sd]; -- the C register
stackEffect ← stackEffect + sd; -- the change to stack effect
SELECT inst
FROM
dQOR => {
Effect: [S] ← Rs OR Rb
op ← Or;
};
dQAND => {
Effect: [S] ← Rs AND Rb
op ← And;
};
dQRX => {
Effect: [S] ← (Rs+[Rb])^
resAddr ← VanillaAdd[topOfStack, wordB];
GO TO memFetch;
};
dQBC => {
Effect: [S] ← Rs BC Rb; trap if [S] < 0 OR [S]-Rb >= 0
op ← BndChk;
cond ← ALUCondBC;
};
dQADD => {
Effect: [S] ← Rs+Rb+carry; carry𡤀 trap on overflow
op ← SAdd;
cond ← ALUCondOver;
};
dQSUB => {
Effect: [S] ← Rs-Rb-carry; carry𡤀 trap on overflow
op ← SSub;
cond ← ALUCondOver;
};
dQLADD => {
Effect: [S] ← Rs+Rb; carry𡤀 trap on overflow or Lisp NaN
op ← LAdd;
cond ← ALUCondIL;
};
dQLSUB => {
Effect: [S] ← Rs-Rb; carry𡤀 trap on overflow or Lisp NaN
op ← LSub;
cond ← ALUCondIL;
};
ENDCASE => ERROR;
[resWord, trapCode] ← DoALUOp[processor, topOfStack, wordB, op, cond];
GO TO aluDone;
};
dALS => {
Effect: L ← S + Alpha
[] ← AdjustL[regS];
GO TO noCheck;
};
dAL => {
Effect: L ← L + Alpha
[] ← AdjustL[regL];
GO TO noCheck;
};
dASL => {
Effect: S ← L + Alpha (no stack overflow check)
[] ← AdjustS[regL];
GO TO noCheck;
};
dAS => {
Effect: S ← S + Alpha (no stack overflow check)
[] ← AdjustS[regS];
GO TO noCheck;
};
dCST => {
Effect: atomic
[S+1] ← ([S-2]+AlphaZ)^;
IF [S+1] = [S] THEN [S-2]+AlphaZ)^ ← [S-1] ELSE [] ← ([S-2]+AlphaZ)^;
S←S+1
resAddr ← AddDelta[alphaZ, RegFetch[StackPlus[regS, -2]]];
[resWord, trapCode] ← MemFetch[resAddr];
SELECT
TRUE
FROM
trapCode # NoFault => GO TO memFault;
WillEUStackOverflow[] => GO TO euOverflow;
ENDCASE;
RegStore[resReg, resWord];
IF resWord = topOfStack
THEN {
The conditional store was successful, so store the new word
resWord ← RegFetch[sM1];
GO TO memStore;
};
The conditional store was not successful, so refetch the word (which simulates releasing the bus)
[] ← MemFetch[resAddr];
GO TO noCheck;
};
dRET => {
Effect: S←L+Alpha; return from proc
IF NOT AdjustS[regL] THEN GO TO noCheck;
GO TO return;
};
dRETK => {
Effect: RETurn from Kernel. Status←[S]; S←L+AlphaZ
delta: CARDINAL ← (ORD[regS]+(EUStackSize+1)-ORD[regL]) MOD EUStackSize;
newS: ProcessorRegister = StackPlus[regL, alphaZ];
IF delta > EUStackSize/2
OR (alphaZ+1)
MOD 256 > delta
THEN
IF careful THEN SIGNAL OutsideEnvelope["VERY suspicious RETK!"];
IF status.userMode THEN GO TO modeFault;
resWord ← MergeStatus[];
RegStore[ifuS, RegToWord[newS]];
RegStore[ifuStatus, resWord];
GO TO return;
};
dLIP => {
Effect: [S+1]←PReg[Alpha]; S←S+1
reg: ProcessorRegister ← LOOPHOLE[alphaZ];
IF reg > euLast
THEN cycles ← cycles + 4;
IFU registers take longer to fetch than EU registers
SELECT reg
FROM
ifuEldestPC => {
Reading from the ifuEldestPC register has the side effect of popping the entry from the IFU stack. We do a check for empty stacks here, but the processor really doesn't.
eldest: NAT ← processor.eldest;
entries: NAT ← processor.stackEntries;
IF status.userMode THEN GO TO modeFault;
resWord ← processor.ifuStack[eldest].pc;
IF processor.stackEntries = 0
THEN SIGNAL OutsideEnvelope["Empty IFU stack in LIP ifuEldestPC."]
ELSE {
IF WillEUStackOverflow[]
THEN
GO
TO euOverflow;
Check for overflow before altering the state!
processor.eldest ← (eldest + 1) MOD LizardIFUStackSize;
processor.stackEntries ← entries - 1;
};
};
ifuEldestL => {
IF processor.stackEntries = 0
THEN
SIGNAL OutsideEnvelope["Empty IFU stack in LIP ifuEldestL."];
resWord ← RegToWord[processor.ifuStack[processor.eldest].regL];
};
ifuYoungestPC => {
IF processor.stackEntries = 0
THEN
SIGNAL OutsideEnvelope["Empty IFU stack in LIP ifuYoungestPC."];
resWord ← processor.ifuStack[processor.youngest].pc;
};
ifuYoungestL => {
IF processor.stackEntries = 0
THEN SIGNAL OutsideEnvelope["Empty IFU stack in LIP ifuYoungestL."];
resWord ← RegToWord[processor.ifuStack[processor.youngest].regL];
};
ENDCASE =>
resWord ← RegFetch[reg];
GO TO storeReg
};
dSIP => {
Effect: PReg[Alpha]←[S]; S←S-1
Note: we try to do the EU stack overflow checking after the IFU stack overflow checking in here, even though there is only one register (ifuEldestPC) that really does the overflow checking
reg: ProcessorRegister ← LOOPHOLE[alphaZ];
IF status.userMode THEN GO TO modeFault;
stackEffect ← -1;
[] ← WillEUStackOverflow[];
This just checks for bogus oveflows
IF reg > euLast
THEN cycles ← cycles + 4;
IFU registers take longer to store than EU registers
SELECT reg
FROM
ifuStatus => {
Setting this register may enable traps.
resWord ← MergeStatus[];
IF status.trapsEnabled
AND processor.stackEntries >= IFUOverflow
THEN
SIGNAL OutsideEnvelope["Too full IFU stack in SIP ifuStatus."];
};
ifuEldestPC => {
Setting this register causes a new eldest entry to be created before writing. This is roughly the same as a push, of course, so we use the same IFU stack overflow check.
entries: NAT ← processor.stackEntries+1;
eldest: NAT ← processor.eldest;
IF LizardHeart.WillPushOverflow[processor]
THEN {
CauseTrap[IFUStackOverflowTrap];
GO TO done;
};
processor.stackEntries ← entries;
eldest ← (eldest + (LizardIFUStackSize - 1)) MOD LizardIFUStackSize;
processor.eldest ← eldest;
processor.ifuStack[eldest].pc ← resWord;
};
ifuEldestL => {
IF processor.stackEntries = 0
THEN
SIGNAL OutsideEnvelope["Empty IFU stack in SIP ifuEldestL."];
processor.ifuStack[processor.eldest].regL ← WordToReg[resWord];
};
ifuYoungestPC => {
IF processor.stackEntries = 0
THEN
SIGNAL OutsideEnvelope["Empty IFU stack in SIP ifuYoungestPC."];
processor.ifuStack[processor.youngest].pc ← resWord;
};
ifuYoungestL => {
IF processor.stackEntries = 0
THEN
SIGNAL OutsideEnvelope["Empty IFU stack in SIP ifuYoungestL."];
processor.ifuStack[processor.youngest].regL ← WordToReg[resWord];
};
ENDCASE => IF WillEUStackOverflow[] THEN GO TO euOverflow;
resReg ← reg;
GO TO storeReg;
};
dLIB => {
Effect: [S+1]𡤊lphaZ; S←S+1
resWord ← CardToWord[alphaZ];
GO TO storeReg;
};
dADDB, dSUBB => {
Effect: [S] ← [S] ± AlphaZ; trap on overflow
[resWord, trapCode] ← DoALUOp[
processor,
topOfStack,
CardToWord[alphaZ],
IF inst = dADDB THEN SAdd ELSE SSub,
ALUCondOver];
GO TO aluDone;
};
dJ2 =>
GO
TO noCheck;
Effect: noop
dJB => {
Effect: PC←PC+Alpha
alphaS: INT ← alphaZ;
IF alphaZ > 127 THEN alphaS ← alphaS - 256;
newPC ← AddDelta[alphaS, thisPC];
GO TO jump;
};
dRB =>
GO
TO memFetchAlpha;
Effect: [S]←([S]+AlphaZ)^
dWB => {
Effect: ([S]+AlphaZ)^←[S-1]; S←S-2
resWord ← RegFetch[sM1];
GO TO memStoreAlpha;
};
dRSB =>
GO
TO memFetchAlpha;
Effect: [S+1]←([S]+AlphaZ)^; S←S+1
dWSB => {
Effect: ([S-1]+AlphaZ)^←[S]; S←S-2
resAddr ← RegFetch[sM1];
GO TO memStoreAlpha;
};
dIOS, dIOL, dION => {
An incomplete simulation of the IOx instructions. IOFetch & IOStore effects are mostly ignored. However, the stack effect and the other goodies are correct as far as I can tell.
ioOp: IOOperand = [LOOPHOLE[alphaZ], LOOPHOLE[betaZ]];
pDataA: Word ← AddDelta[ByteToCard[ioOp.pDataA], (IF inst = dIOS THEN topOfStack ELSE CardToWord[0])];
IF status.userMode
THEN
SELECT
TRUE
FROM
ioOp.pCmd.mode = kernelOnly =>
GO TO modeFault;
ioOp.pCmd.addressChecks = kernelIfFirst16M
AND WordToCard[pDataA] < KernalLimit => {
kernel mode required for this cmd if address IN [0..1000000H)
CauseTrap[AddressCheckFault];
GO TO noCheck;
};
SELECT ioOp.pCmd.direction
FROM
read => {
IF inst = dIOL THEN resReg ← StackPlus[regS, stackEffect ← 1];
[resWord, trapCode] ← IOFetch[ioOp.pCmd, pDataA];
IF trapCode # NoFault THEN GO TO memFault;
IF inst = dION THEN GO TO done;
processor.euBusyReg ← resReg;
GO TO storeReg;
};
write => {
SELECT inst
FROM
dIOL => stackEffect ← -1;
dIOS => {resWord ← RegFetch[sM1]; stackEffect ← -2};
ENDCASE;
trapCode ← IOStore[ioOp.pCmd, pDataA, resWord];
IF trapCode # NoFault THEN GO TO memFault;
GO TO done;
};
ENDCASE => ERROR;
};
dPSB => {
Effect: ([S-1]+AlphaZ)^←[S]; S←S-1
resAddr ← RegFetch[sM1];
GO TO memStoreAlpha;
};
dLRI0 => {
Effect: [S+1]←([L+n]+AlphaZ)^; S←S+1
OPEN form: LOOPHOLE[formBytes2, LRBformat];
resAddr ← RegFetchInline[StackPlus[regL, form.reg]];
GO TO memFetchAlpha;
};
dSRI0 => {
Effect: ([L+n]+AlphaZ)^←[S]; S←S-1
OPEN form: LOOPHOLE[formBytes2, LRBformat];
resAddr ← RegFetchInline[StackPlus[regL, form.reg]];
GO TO memStoreAlpha;
};
dROR, dRAND, dRRX, dRBC, dRADD, dRSUB, dRLADD, dRLSUB, dRXOR, dRFU, dRVADD, dRVSUB, dRUADD, dRUSUB => {
OPEN form: LOOPHOLE[formBytes3, RRformat];
aux: BOOL = form.aux;
regA: ProcessorRegister = CalcReg[aux, form.aOpt, form.a];
wordA: Word = RegFetchInline[regA];
regB: ProcessorRegister = CalcReg[aux, form.bOpt, form.b];
wordB: Word = RegFetchInline[regB];
op: ALUOps;
cond: TrapIndex ← ALUCondFalse;
resReg ← CalcReg[aux, form.cOpt, form.c, TRUE];
{
This code checks for assignments to the constant or auxilliary registers. All constant and the first eight auxiliary registers are protected against being written while in user mode.
firstProtectedAux: ProcessorRegister = euAux;
lastProtectedAux: ProcessorRegister = VAL[ORD[firstProtectedAux]+7];
firstProtectedConst: ProcessorRegister = euConstant;
lastProtectedConst: ProcessorRegister = VAL[ORD[firstProtectedConst]+11];
SELECT resReg
FROM
IN [firstProtectedAux..lastProtectedAux] =>
IF status.userMode THEN GO TO modeFault;
IN [firstProtectedConst..lastProtectedConst] => {
IF status.userMode THEN GO TO modeFault;
IF resReg = euConstant
THEN {
SIGNAL OutsideEnvelope["Storing into constant register 0 not permited!"];
resWord ← CardToWord[0];
trapCode ← NoFault;
GO TO aluDone;
}
};
ENDCASE;
};
SELECT inst
FROM
dROR => {
Effect: Rc ← Ra OR Rb
op ← Or;
};
dRAND => {
Effect: Rc ← Ra AND Rb
op ← And;
};
dRRX => {
Effect: [Rc]←([Ra]+[Rb])^
resAddr ← VanillaAdd[wordA, wordB];
GO TO memFetch;
};
dRBC => {
Effect: Rc ← Ra; trap if Ra < 0 OR Ra-Rb >= 0
op ← BndChk;
cond ← ALUCondBC;
};
dRADD => {
Effect: Rc ← Ra+Rb+carry; carry𡤀 trap on overflow
op ← SAdd;
cond ← ALUCondOver;
};
dRSUB => {
Effect: Rc ← Ra-Rb-carry; carry𡤀 trap on overflow
op ← SSub;
cond ← ALUCondOver;
};
dRLADD => {
Effect: Rc ← Ra+Rb; carry𡤀 trap on overflow or Lisp NaN
op ← LAdd;
cond ← ALUCondIL;
};
dRLSUB => {
Effect: Rc ← Ra-Rb; carry𡤀 trap on overflow or Lisp NaN
op ← LSub;
cond ← ALUCondIL;
};
dRXOR => {
Effect: Rc ← Ra XOR Rb
op ← Xor;
};
dRFU => {
Effect: [Rc]𡤏ieldUnit[[Ra],[Rb],MDF]
fd: FieldDescriptor = CardToFieldDescriptor[
HalfToCard[WordToHalves[RegFetch[euField]][1]]
];
resWord ← FieldUnit[wordA, wordB, fd];
GO TO storeReg;
};
dRVADD => {
Effect: Rc ← Ra+Rb
resWord ← VanillaAdd[wordA, wordB];
GO TO storeReg;
};
dRVSUB => {
Effect: Rc ← Ra-Rb
resWord ← VanillaSub[wordA, wordB];
GO TO storeReg;
};
dRUADD => {
Effect: Rc ← Ra+Rb+carry; set carry
op ← UAdd;
};
dRUSUB => {
Effect: Rc ← Ra-Rb-carry; set carry
op ← USub;
};
ENDCASE => ERROR;
[resWord, trapCode] ← DoALUOp[processor, wordA, wordB, op, cond];
GO TO aluDone;
};
dLGF => {
Effect: [S+1]←([GB]+AlphaBetaZ)^; S←S+1
resAddr ← AddDelta[alphaBetaZ, RegFetch[euAux]];
GO TO memFetch;
};
dLIDB => {
Effect: [S+1]𡤊lphaBetaZ; S←S+1
resWord ← CardToWord[alphaBetaZ];
GO TO storeReg;
};
dADDDB, dSUBDB => {
Effect: [S] ← [S] ± AlphaBetaZ; trap on overflow
[resWord, trapCode] ← DoALUOp[
processor,
topOfStack,
CardToWord[alphaBetaZ],
IF inst = dADDDB THEN SAdd ELSE SSub,
ALUCondOver];
GO TO aluDone;
};
dJ3 =>
GO
TO noCheck;
Effect: noop
dJDB => {
Effect (dJDB): PC←PC+AlphaBetaS
newPC ← AddDelta[LOOPHOLE[alphaBetaZ, INTEGER], thisPC];
GO TO jump;
};
dLFC => {
Effect (dLFC): call proc at PC+AlphaBetaS
newPC ← AddDelta[LOOPHOLE[alphaBetaZ, INTEGER], thisPC];
GO TO call;
};
dRAI, dRRI, dWAI, dWRI => {
OPEN form: LOOPHOLE[formBytes3, LRRBformat];
baseReg: ProcessorRegister ←
SELECT inst
FROM
dRAI, dWAI => RegPlus[euAux, form.reg2],
ENDCASE => StackPlus[regL, form.reg2];
resReg ← StackPlus[regL, form.reg1];
resAddr ← RegFetchInline[baseReg];
SELECT inst
FROM
dRAI, dRRI => {
Effect (dRAI): [L+BetaL]←(AuxRegs[BetaR]+AlphaZ)^
Effect (dRRI): [L+BetaL]←([L+BetaR]+AlphaZ)^
GO TO memFetchAlpha;
};
dWAI, dWRI => {
Effect (dWAI): (AuxRegs[BetaR]+AlphaZ)^←[L+BetaL]
Effect (dWRI): ([L+BetaR]+AlphaZ)^←[L+BetaL]
resWord ← RegFetchInline[resReg];
GO TO memStoreAlpha;
};
ENDCASE => ERROR;
};
dRJEB, dRJEBJ, dRJGB, dRJGBJ, dRJGEB, dRJGEBJ, dRJLB, dRJLBJ, dRJLEB, dRJLEBJ, dRJNEB, dRJNEBJ => {
Effect: IF Rs cond Rb THEN PC←PC+BetaS
OPEN form: LOOPHOLE[formBytes3, RJBformat];
comparison: Basics.Comparison;
regA: ProcessorRegister ← regS;
SELECT form.aOp
FROM
c0 => regA ← euConstant;
c1 => regA ← SUCC[euConstant];
top => regA ← regS;
popTop => {regA ← regS; stackEffect ← stackEffect - 1};
ENDCASE;
resWord ← RegFetchInline[regA];
comparison ← Basics.CompareINT[
WordToInt[resWord],
WordToInt[RegFetchInline[CalcReg[form.aux, form.opt, form.reg]]]];
IF WillEUStackOverflow[] THEN GO TO euOverflow;
SELECT inst
FROM
dRJEB, dRJEBJ => IF comparison = equal THEN GO TO condJump;
dRJGB, dRJGBJ => IF comparison = greater THEN GO TO condJump;
dRJGEB, dRJGEBJ => IF comparison # less THEN GO TO condJump;
dRJLB, dRJLBJ => IF comparison = less THEN GO TO condJump;
dRJLEB, dRJLEBJ => IF comparison # greater THEN GO TO condJump;
dRJNEB, dRJNEBJ => IF comparison # equal THEN GO TO condJump;
ENDCASE => ERROR;
At this point we should NOT branch.
GO TO condFall;
};
dJEBB, dJEBBJ =>
Effect: AlphaZ = [S] => PC←PC+BetaS; S←S-1
IF topOfStack = CardToWord[alphaZ] THEN GO TO condJump ELSE GO TO condFall;
dJNEBB, dJNEBBJ =>
Effect: AlphaZ # [S] => PC←PC+BetaS; S←S-1
IF topOfStack # CardToWord[alphaZ] THEN GO TO condJump ELSE GO TO condFall;
dSHL => {
Effect: [S]𡤏ieldUnit[[S],0,AlphaBeta]
topOfStack ← ZerosWord;
GO TO storeField;
};
dSHR =>
GO
TO storeField;
Effect: [S]𡤏ieldUnit[[S],[S],AlphaBeta]
dSHD => {
Effect: [S-1]𡤏ieldUnit[[S-1],[S],AlphaBeta]; S←S-1
resWord ← RegFetch[sM1];
GO TO storeField;
};
dFSDB => {
Effect: euField𡤊lphaBeta+[S]; S←S-1
resWord ← VanillaAdd[CardToWord[alphaBetaZ], topOfStack];
resReg ← euField;
GO TO storeReg;
};
x311B, x313B, x337B, x340B, x344B, x350B, x354B => {
SIGNAL OutsideEnvelope[IO.PutFR["Opcode %g has undefined effects", IO.rope[HandCodingUtil.GetInstArray[][inst]]]];
GO TO xop;
};
ENDCASE => NULL;