@jhlagado/azm 0.1.1 → 0.2.0

package/dist/src/z80/effects.js

@@ -1,4 +1,3 @@
-import { expandCarrier } from '../registerCare/carriers.js';
 const FLAG_WRITES = ['sign', 'zero', 'halfCarry', 'parity', 'carry'];
 const INC_DEC_FLAG_WRITES = ['sign', 'zero', 'halfCarry', 'parity'];
 const ROTATE_SHIFT_FLAG_WRITES = [
@@ -58,116 +57,111 @@ function concatUnique(...groups) {
         appendUnique(out, group);
     return out;
 }
-function registerUnits(op) {
-    if (!op || op.kind !== 'Reg')
-        return undefined;
-    return expandCarrier(op.name);
-}
-function immName(op) {
-    return op?.kind === 'Imm' && op.expr.kind === 'ImmName' ? op.expr.name : undefined;
-}
-function immLiteral(op) {
-    return op?.kind === 'Imm' && op.expr.kind === 'ImmLiteral' ? op.expr.value : undefined;
-}
-function operandTokenName(op) {
-    if (op?.kind === 'Reg')
-        return op.name.toUpperCase();
-    if (op?.kind === 'Imm' && op.expr.kind === 'ImmName')
-        return op.expr.name.toUpperCase();
-    return undefined;
-}
-function conditionFlagRead(op) {
-    switch (operandTokenName(op)) {
-        case 'Z':
-        case 'NZ':
+function reg8Units(raw) {
+    const reg = raw.toLowerCase();
+    if (reg === 'a')
+        return ['A'];
+    if (reg === 'b')
+        return ['B'];
+    if (reg === 'c')
+        return ['C'];
+    if (reg === 'd')
+        return ['D'];
+    if (reg === 'e')
+        return ['E'];
+    if (reg === 'h')
+        return ['H'];
+    if (reg === 'l')
+        return ['L'];
+    return [];
+}
+function reg16Units(raw) {
+    const reg = raw.toLowerCase();
+    if (reg === 'bc')
+        return ['B', 'C'];
+    if (reg === 'de')
+        return ['D', 'E'];
+    if (reg === 'hl')
+        return ['H', 'L'];
+    if (reg === 'sp')
+        return ['SPH', 'SPL'];
+    if (reg === 'ix')
+        return ['IXH', 'IXL'];
+    if (reg === 'iy')
+        return ['IYH', 'IYL'];
+    if (reg === 'af')
+        return ['A', ...FLAG_WRITES];
+    return [];
+}
+function regHalfUnits(raw) {
+    const reg = raw.toLowerCase();
+    if (reg === 'ixh')
+        return ['IXH'];
+    if (reg === 'ixl')
+        return ['IXL'];
+    if (reg === 'iyh')
+        return ['IYH'];
+    if (reg === 'iyl')
+        return ['IYL'];
+    return [];
+}
+function expressionSymbol(expression) {
+    return expression.kind === 'symbol' ? expression.name : undefined;
+}
+function conditionFlagRead(condition) {
+    switch (condition) {
+        case 'z':
+        case 'nz':
             return ['zero'];
-        case 'C':
-        case 'NC':
+        case 'c':
+        case 'nc':
             return ['carry'];
-        case 'M':
-        case 'P':
+        case 'm':
+        case 'p':
             return ['sign'];
-        case 'PE':
-        case 'PO':
+        case 'pe':
+        case 'po':
             return ['parity'];
         default:
-            return undefined;
-    }
-}
-function eaReads(ea) {
-    switch (ea.kind) {
-        case 'EaName':
-            return expandCarrier(ea.name) ?? [];
-        case 'EaImm':
             return [];
-        case 'EaLayoutCast':
-        case 'EaField':
-            return eaReads(ea.base);
-        case 'EaAdd':
-        case 'EaSub':
-            return eaReads(ea.base);
-        case 'EaIndex': {
-            const base = eaReads(ea.base);
-            const index = indexReads(ea.index);
-            if (!base || !index)
-                return undefined;
-            return concatUnique(base, index);
-        }
-        default:
-            return undefined;
     }
 }
-function indexReads(index) {
-    switch (index.kind) {
-        case 'IndexImm':
+function operandReads(op) {
+    switch (op.kind) {
+        case 'reg8':
+            return reg8Units(op.register);
+        case 'reg16':
+        case 'reg-index16':
+            return reg16Units(op.register);
+        case 'reg-half-index':
+            return regHalfUnits(op.register);
+        case 'special8':
+            return [];
+        case 'reg-indirect':
+            return reg16Units(op.register);
+        case 'indexed':
+            return reg16Units(op.register);
+        case 'mem-abs':
+        case 'imm':
             return [];
-        case 'IndexReg8':
-        case 'IndexReg16':
-            return expandCarrier(index.reg);
-        case 'IndexMemHL':
-            return expandCarrier('HL');
-        case 'IndexMemIxIy':
-            return expandCarrier(index.base);
-        case 'IndexEa':
-            return eaReads(index.expr);
         default:
             return undefined;
     }
 }
-function operandReads(op) {
-    if (!op)
-        return undefined;
+function operandWrites(op) {
     switch (op.kind) {
-        case 'Reg':
-            return expandCarrier(op.name);
-        case 'Imm':
-            return immReads(op.expr);
-        case 'Ea':
-        case 'Mem':
-            return eaReads(op.expr);
-        case 'PortC':
-            return expandCarrier('C');
-        case 'PortImm8':
-            return immReads(op.expr);
+        case 'reg8':
+            return reg8Units(op.register);
+        case 'reg16':
+            return reg16Units(op.register);
+        case 'reg-index16':
+            return reg16Units(op.register);
+        case 'reg-half-index':
+            return regHalfUnits(op.register);
         default:
             return undefined;
     }
 }
-function immReads(expr) {
-    switch (expr.kind) {
-        case 'ImmBinary':
-            return concatUnique(immReads(expr.left), immReads(expr.right));
-        case 'ImmUnary':
-            return immReads(expr.expr);
-        default:
-            return [];
-    }
-}
-function targetName(operands) {
-    if (operands.length === 0)
-        return undefined;
-    return immName(operands[operands.length - 1]);
-}
 function callControl(target, conditional) {
     return target === undefined
         ? { kind: 'call', conditional }
@@ -181,105 +175,181 @@ function jumpControl(target, conditional) {
         ? { kind: 'jump', conditional }
         : { kind: 'jump', target, conditional };
 }
-function isConditionalControl(operands) {
-    return operands.length > 1;
+function controlEffect(control, reads = []) {
+    return {
+        ...baseEffect(),
+        reads,
+        control,
+    };
 }
-function ldEffect(inst) {
-    if (inst.operands.length !== 2)
-        return unknownEffect();
-    const dst = inst.operands[0];
-    const src = inst.operands[1];
-    if (!dst || !src)
-        return unknownEffect();
-    const effect = baseEffect();
-    const srcReads = operandReads(src);
-    if (!srcReads)
+function stackControlEffect(control, reads = []) {
+    return {
+        ...controlEffect(control, reads),
+        writes: STACK_POINTER_UNITS,
+        stack: { kind: 'unknown' },
+    };
+}
+function ldEffect(instruction) {
+    const srcReads = operandReads(instruction.source);
+    if (srcReads === undefined)
         return unknownEffect();
-    if (dst.kind === 'Reg') {
-        const dstWrites = expandCarrier(dst.name);
-        if (!dstWrites)
+    const dstWrites = operandWrites(instruction.target);
+    if (instruction.target.kind === 'reg8' || instruction.target.kind === 'reg16') {
+        if (dstWrites === undefined)
             return unknownEffect();
-        effect.reads = srcReads;
-        effect.writes = dstWrites;
-        return effect;
+        return {
+            ...baseEffect(),
+            reads: srcReads,
+            writes: dstWrites,
+        };
+    }
+    if (instruction.target.kind === 'reg-index16' ||
+        instruction.target.kind === 'reg-half-index') {
+        if (dstWrites === undefined)
+            return unknownEffect();
+        return {
+            ...baseEffect(),
+            reads: srcReads,
+            writes: dstWrites,
+        };
     }
-    if (dst.kind === 'Mem') {
-        const dstReads = operandReads(dst);
-        if (!dstReads)
+    if (instruction.target.kind === 'reg-indirect' || instruction.target.kind === 'indexed') {
+        const dstReads = operandReads(instruction.target);
+        if (dstReads === undefined)
             return unknownEffect();
-        effect.reads = concatUnique(dstReads, srcReads);
-        return effect;
+        return {
+            ...baseEffect(),
+            reads: concatUnique(dstReads, srcReads),
+        };
+    }
+    if (instruction.target.kind === 'mem-abs') {
+        return {
+            ...baseEffect(),
+            reads: srcReads,
+        };
     }
     return unknownEffect();
 }
-function unaryOperandEffect(inst, flagWrites) {
-    if (inst.operands.length !== 1)
-        return unknownEffect();
-    const op = inst.operands[0];
-    if (!op)
-        return unknownEffect();
-    const reads = operandReads(op);
-    if (!reads)
-        return unknownEffect();
-    const writes = op.kind === 'Reg' ? registerUnits(op) : [];
-    if (!writes)
+function incDecEffect(instruction) {
+    const operand = instruction.operand;
+    if (operand.kind === 'reg8') {
+        const units = reg8Units(operand.register);
+        return {
+            ...baseEffect(),
+            reads: units,
+            writes: concatUnique(units, INC_DEC_FLAG_WRITES),
+        };
+    }
+    if (operand.kind === 'reg16') {
+        const units = reg16Units(operand.register);
+        return {
+            ...baseEffect(),
+            reads: units,
+            writes: units,
+        };
+    }
+    if (operand.kind === 'reg-half-index') {
+        const units = regHalfUnits(operand.register);
+        return {
+            ...baseEffect(),
+            reads: units,
+            writes: concatUnique(units, INC_DEC_FLAG_WRITES),
+        };
+    }
+    const reads = operandReads(operand);
+    if (reads === undefined)
         return unknownEffect();
     return {
         ...baseEffect(),
         reads,
-        writes: concatUnique(writes, flagWrites),
+        writes: INC_DEC_FLAG_WRITES,
     };
 }
-function incDecEffect(inst) {
-    return unaryOperandEffect(inst, INC_DEC_FLAG_WRITES);
-}
-function aluEffect(inst) {
-    if (inst.operands.length < 1 || inst.operands.length > 2)
-        return unknownEffect();
-    const first = inst.operands[0];
-    const second = inst.operands[1];
-    const xorSelfZero = inst.head === 'xor' &&
-        second === undefined &&
-        first?.kind === 'Reg' &&
-        first.name.toUpperCase() === 'A';
-    const firstReads = operandReads(first);
-    if (!firstReads)
-        return unknownEffect();
-    let reads;
-    let writes = [];
-    if (second) {
-        const secondReads = operandReads(second);
-        if (!secondReads)
+function aluEffect(instruction) {
+    if (instruction.mnemonic === 'add' &&
+        'target' in instruction &&
+        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
+        const targetReads = operandReads(instruction.target);
+        const sourceReads = operandReads(instruction.source);
+        if (targetReads === undefined || sourceReads === undefined)
             return unknownEffect();
-        reads = concatUnique(firstReads, secondReads);
-        if (inst.head !== 'cp' && first?.kind === 'Reg') {
-            const firstWrites = registerUnits(first);
-            if (!firstWrites)
-                return unknownEffect();
-            writes = firstWrites;
-        }
+        return {
+            ...baseEffect(),
+            reads: concatUnique(targetReads, sourceReads),
+            writes: concatUnique(operandWrites(instruction.target) ?? [], FLAG_WRITES),
+        };
     }
-    else {
-        const aReads = expandCarrier('A');
-        if (!aReads)
+    if (instruction.mnemonic === 'adc' &&
+        'target' in instruction &&
+        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
+        const targetReads = operandReads(instruction.target);
+        const sourceReads = operandReads(instruction.source);
+        if (targetReads === undefined || sourceReads === undefined)
             return unknownEffect();
-        reads = xorSelfZero ? [] : concatUnique(aReads, firstReads);
-        if (inst.head !== 'cp')
-            writes = aReads;
+        return {
+            ...baseEffect(),
+            reads: concatUnique(targetReads, sourceReads, ['carry']),
+            writes: concatUnique(operandWrites(instruction.target) ?? [], FLAG_WRITES),
+        };
+    }
+    if (instruction.mnemonic === 'sbc' &&
+        'target' in instruction &&
+        (instruction.target.kind === 'reg16' || instruction.target.kind === 'reg-index16')) {
+        const targetReads = operandReads(instruction.target);
+        const sourceReads = operandReads(instruction.source);
+        if (targetReads === undefined || sourceReads === undefined)
+            return unknownEffect();
+        return {
+            ...baseEffect(),
+            reads: concatUnique(targetReads, sourceReads, ['carry']),
+            writes: concatUnique(operandWrites(instruction.target) ?? [], FLAG_WRITES),
+        };
+    }
+    if (!('source' in instruction))
+        return unknownEffect();
+    const source = instruction.source;
+    let sourceReads;
+    if (source.kind === 'reg8') {
+        sourceReads = reg8Units(source.register);
+    }
+    else if (source.kind === 'reg-indirect' || source.kind === 'indexed') {
+        sourceReads = operandReads(source) ?? [];
+    }
+    else if (source.kind === 'mem-abs' || source.kind === 'imm') {
+        sourceReads = [];
+    }
+    else if (source.kind === 'reg16' || source.kind === 'reg-index16') {
+        sourceReads = reg16Units(source.register);
+    }
+    else if (source.kind === 'reg-half-index') {
+        sourceReads = regHalfUnits(source.register);
+    }
+    else {
+        sourceReads = [];
+    }
+    const xorSelfZero = instruction.mnemonic === 'xor' &&
+        source.kind === 'reg8' &&
+        source.register === 'a';
+    const reads = xorSelfZero ? [] : concatUnique(['A'], sourceReads);
+    const carryReads = instruction.mnemonic === 'adc' || instruction.mnemonic === 'sbc' ? ['carry'] : [];
+    if (instruction.mnemonic === 'cp') {
+        return {
+            ...baseEffect(),
+            reads: concatUnique(reads, carryReads),
+            writes: FLAG_WRITES,
+        };
     }
-    const carryReads = inst.head === 'adc' || inst.head === 'sbc' ? ['carry'] : [];
     return {
         ...baseEffect(),
         reads: concatUnique(reads, carryReads),
-        writes: concatUnique(writes, FLAG_WRITES),
+        writes: concatUnique(['A'], FLAG_WRITES),
     };
 }
-function pushEffect(inst) {
-    if (inst.operands.length !== 1)
-        return unknownEffect();
-    const units = registerUnits(inst.operands[0]);
-    if (!units)
-        return unknownEffect();
+function stackRegisterUnits(register) {
+    return reg16Units(register);
+}
+function pushEffect(register) {
+    const units = stackRegisterUnits(register);
     return {
         ...baseEffect(),
         reads: units,
@@ -287,169 +357,116 @@ function pushEffect(inst) {
         stack: { kind: 'push', units },
     };
 }
-function popEffect(inst) {
-    if (inst.operands.length !== 1)
-        return unknownEffect();
-    const units = registerUnits(inst.operands[0]);
-    if (!units)
-        return unknownEffect();
+function popEffect(register) {
+    const units = stackRegisterUnits(register);
     return {
         ...baseEffect(),
         writes: concatUnique(units, STACK_POINTER_UNITS),
         stack: { kind: 'pop', units },
     };
 }
-function controlEffect(control, reads = []) {
+function rotateShiftEffect(instruction) {
+    const reads = operandReads(instruction.operand);
+    const writes = operandWrites(instruction.operand);
+    if (reads === undefined || writes === undefined)
+        return unknownEffect();
     return {
         ...baseEffect(),
         reads,
-        control,
+        writes: concatUnique(writes, ROTATE_SHIFT_FLAG_WRITES),
     };
 }
-function stackControlEffect(control, reads = []) {
-    return {
-        ...controlEffect(control, reads),
-        writes: STACK_POINTER_UNITS,
-        stack: { kind: 'unknown' },
-    };
-}
-function jumpEffect(inst) {
-    const conditional = isConditionalControl(inst.operands);
-    const reads = conditional
-        ? conditionFlagRead(inst.operands[0])
-        : operandReads(inst.operands[inst.operands.length - 1]);
-    if (!reads)
+function bitEffect(instruction) {
+    const reads = operandReads(instruction.operand);
+    if (reads === undefined)
         return unknownEffect();
-    const effect = controlEffect(jumpControl(targetName(inst.operands), conditional));
-    effect.reads = reads;
-    return effect;
-}
-function callEffect(inst) {
-    const conditional = isConditionalControl(inst.operands);
-    const reads = conditional ? conditionFlagRead(inst.operands[0]) : [];
-    if (!reads)
-        return unknownEffect();
-    return stackControlEffect(callControl(targetName(inst.operands), conditional), reads);
-}
-function retEffect(inst) {
-    const reads = inst.operands.length > 0 ? conditionFlagRead(inst.operands[0]) : [];
-    if (!reads)
+    if (instruction.mnemonic === 'bit') {
+        return {
+            ...baseEffect(),
+            reads,
+            writes: BIT_FLAG_WRITES,
+        };
+    }
+    const writes = operandWrites(instruction.operand);
+    if (writes === undefined)
         return unknownEffect();
-    return stackControlEffect({ kind: 'return' }, reads);
-}
-function djnzEffect(inst) {
     return {
         ...baseEffect(),
-        reads: ['B'],
-        writes: ['B'],
-        control: jumpControl(targetName(inst.operands), true),
+        reads,
+        writes,
     };
 }
-function rotateShiftEffect(inst) {
-    return unaryOperandEffect(inst, ROTATE_SHIFT_FLAG_WRITES);
-}
-function accumulatorRotateEffect(head) {
-    const reads = head === 'rla' || head === 'rra' ? ['A', 'carry'] : ['A'];
+function inEffect(instruction) {
+    const targetWrites = instruction.target?.kind === 'reg8' ? reg8Units(instruction.target.register) : undefined;
+    if (instruction.port.kind === 'imm') {
+        return {
+            ...baseEffect(),
+            reads: ['A'],
+            writes: targetWrites ?? [],
+        };
+    }
     return {
         ...baseEffect(),
-        reads,
-        writes: ['A', 'carry', 'halfCarry'],
+        reads: ['C'],
+        writes: concatUnique(targetWrites ?? [], BIT_FLAG_WRITES),
     };
 }
-function bitEffect(inst) {
-    if (inst.operands.length !== 2)
-        return unknownEffect();
-    const target = inst.operands[1];
-    if (!target)
-        return unknownEffect();
-    const reads = operandReads(target);
-    if (!reads)
-        return unknownEffect();
+function outEffect(instruction) {
+    const valueReads = instruction.source.kind === 'reg8' ? reg8Units(instruction.source.register) : [];
+    if (instruction.port.kind === 'c') {
+        return {
+            ...baseEffect(),
+            reads: concatUnique(['C'], valueReads),
+        };
+    }
     return {
         ...baseEffect(),
-        reads,
-        writes: BIT_FLAG_WRITES,
+        reads: valueReads,
     };
 }
-function outEffect(inst) {
-    if (inst.operands.length !== 2)
-        return unknownEffect();
-    const portReads = operandReads(inst.operands[0]);
-    const valueReads = operandReads(inst.operands[1]);
-    if (!portReads || !valueReads)
-        return unknownEffect();
+function blockTransferEffect() {
     return {
         ...baseEffect(),
-        reads: concatUnique(portReads, valueReads),
+        reads: ['H', 'L', 'D', 'E', 'B', 'C'],
+        writes: ['H', 'L', 'D', 'E', 'B', 'C', 'halfCarry', 'parity'],
     };
 }
-function inEffect(inst) {
-    if (inst.operands.length !== 2)
-        return unknownEffect();
-    const target = inst.operands[0];
-    const port = inst.operands[1];
-    if (target?.kind !== 'Reg')
-        return unknownEffect();
-    const writes = registerUnits(target);
-    if (!writes)
-        return unknownEffect();
-    if (port?.kind === 'PortImm8') {
+function exEffect(instruction) {
+    if (instruction.form === 'de-hl') {
         return {
             ...baseEffect(),
-            reads: concatUnique(['A'], operandReads(port) ?? []),
-            writes,
-        };
-    }
-    if (port?.kind === 'PortC') {
-        return {
-            ...baseEffect(),
-            reads: ['C'],
-            writes: concatUnique(writes, BIT_FLAG_WRITES),
+            reads: ['D', 'E', 'H', 'L'],
+            writes: ['D', 'E', 'H', 'L'],
         };
     }
     return unknownEffect();
 }
-function blockTransferEffect(inst) {
-    if (inst.operands.length !== 0)
-        return unknownEffect();
+function accumulatorRotateEffect(mnemonic) {
+    const reads = mnemonic === 'rla' || mnemonic === 'rra' ? ['A', 'carry'] : ['A'];
     return {
         ...baseEffect(),
-        reads: ['H', 'L', 'D', 'E', 'B', 'C'],
-        writes: ['H', 'L', 'D', 'E', 'B', 'C', 'halfCarry', 'parity'],
-    };
-}
-function exEffect(inst) {
-    if (inst.operands.length !== 2)
-        return unknownEffect();
-    const left = inst.operands[0];
-    const right = inst.operands[1];
-    const leftUnits = registerUnits(left);
-    const rightUnits = registerUnits(right);
-    if (!leftUnits || !rightUnits)
-        return unknownEffect();
-    const leftName = left?.kind === 'Reg' ? left.name.toUpperCase() : '';
-    const rightName = right?.kind === 'Reg' ? right.name.toUpperCase() : '';
-    const isDeHl = (leftName === 'DE' && rightName === 'HL') || (leftName === 'HL' && rightName === 'DE');
-    if (!isDeHl)
-        return unknownEffect();
-    return {
-        ...baseEffect(),
-        reads: concatUnique(leftUnits, rightUnits),
-        writes: concatUnique(leftUnits, rightUnits),
+        reads,
+        writes: ['A', 'carry', 'halfCarry'],
     };
 }
-export function getZ80InstructionEffect(inst) {
-    switch (inst.head.toLowerCase()) {
+export function getZ80InstructionEffect(instruction) {
+    switch (instruction.mnemonic) {
         case 'nop':
         case 'halt':
         case 'di':
         case 'ei':
+        case 'im':
             return baseEffect();
+        case 'reti':
+        case 'retn':
+            return stackControlEffect({ kind: 'return', conditional: false });
+        case 'ld-a-imm':
+            return { ...baseEffect(), writes: ['A'] };
         case 'ld':
-            return ldEffect(inst);
+            return ldEffect(instruction);
         case 'inc':
         case 'dec':
-            return incDecEffect(inst);
+            return incDecEffect(instruction);
         case 'add':
         case 'adc':
         case 'sbc':
@@ -458,39 +475,57 @@ export function getZ80InstructionEffect(inst) {
         case 'or':
         case 'xor':
         case 'cp':
-            return aluEffect(inst);
+            return aluEffect(instruction);
         case 'push':
-            return pushEffect(inst);
+            return pushEffect(instruction.register);
         case 'pop':
-            return popEffect(inst);
+            return popEffect(instruction.register);
         case 'call':
-            return callEffect(inst);
+            return stackControlEffect(callControl(expressionSymbol(instruction.expression), false));
+        case 'call-cc':
+            return stackControlEffect(callControl(expressionSymbol(instruction.expression), true), conditionFlagRead(instruction.condition));
         case 'rst':
-            return stackControlEffect(rstControl(immLiteral(inst.operands[0])));
+            return stackControlEffect(rstControl(instruction.vector));
         case 'ret':
-        case 'retn':
-        case 'reti':
-            return retEffect(inst);
+            return stackControlEffect({ kind: 'return', conditional: false });
+        case 'ret-cc':
+            return stackControlEffect({ kind: 'return', conditional: true }, conditionFlagRead(instruction.condition));
         case 'jp':
+            return controlEffect(jumpControl(expressionSymbol(instruction.expression), false));
+        case 'jp-cc':
+            return controlEffect(jumpControl(expressionSymbol(instruction.expression), true), conditionFlagRead(instruction.condition));
+        case 'jp-indirect':
+            return controlEffect(jumpControl(undefined, false), reg16Units(instruction.register));
         case 'jr':
-            return jumpEffect(inst);
+            return controlEffect(jumpControl(expressionSymbol(instruction.expression), false));
+        case 'jr-cc':
+            return controlEffect(jumpControl(expressionSymbol(instruction.expression), true), conditionFlagRead(instruction.condition));
         case 'djnz':
-            return djnzEffect(inst);
+            return {
+                ...baseEffect(),
+                reads: ['B'],
+                writes: ['B'],
+                control: jumpControl(expressionSymbol(instruction.expression), true),
+            };
         case 'rlc':
         case 'rrc':
         case 'rl':
         case 'rr':
         case 'sla':
         case 'sra':
+        case 'sll':
+        case 'sls':
         case 'srl':
-            return rotateShiftEffect(inst);
+            return rotateShiftEffect(instruction);
         case 'rlca':
         case 'rrca':
         case 'rla':
         case 'rra':
-            return accumulatorRotateEffect(inst.head.toLowerCase());
+            return accumulatorRotateEffect(instruction.mnemonic);
         case 'bit':
-            return bitEffect(inst);
+        case 'res':
+        case 'set':
+            return bitEffect(instruction);
         case 'scf':
             return { ...baseEffect(), writes: ['carry', 'halfCarry'] };
         case 'ccf':
@@ -500,16 +535,28 @@ export function getZ80InstructionEffect(inst) {
         case 'neg':
             return { ...baseEffect(), reads: ['A'], writes: concatUnique(['A'], FLAG_WRITES) };
         case 'out':
-            return outEffect(inst);
+            return outEffect(instruction);
         case 'in':
-            return inEffect(inst);
+            return inEffect(instruction);
         case 'ldi':
         case 'ldir':
         case 'ldd':
         case 'lddr':
-            return blockTransferEffect(inst);
+        case 'cpi':
+        case 'cpir':
+        case 'cpd':
+        case 'cpdr':
+        case 'ini':
+        case 'inir':
+        case 'ind':
+        case 'indr':
+        case 'outi':
+        case 'otir':
+        case 'outd':
+        case 'otdr':
+            return blockTransferEffect();
         case 'ex':
-            return exEffect(inst);
+            return exEffect(instruction);
         default:
             return unknownEffect();
     }