dis/z80disasm.go

@@ -354,16 +354,15 @@ func (d *Disassembler) getRel() string {
 }
 
 var shiftOps = []string{"RLC", "RRC", "RL", "RR", "SLA", "SRA", "SLL", "SRL"}
-var bitOps = []string{"BIT", "RES", "SET"}
 
 // opocodeCB disassemble Z80 Opcodes, with CB first byte
 func (d *Disassembler) opocodeCB() string {
 	op := ""
 	opcode := d.getByte()
 	if opcode <= 0x3F {
-		op = shiftOps[opcode>>3&0x07] + sep + operands[opcode&0x7]
+		op = shiftOps[opcode>>3&0x07] + operands[opcode&0x7]
 	} else {
-		op = bitOps[(opcode>>6&0x03)-1] + " " + string(rune(48+(opcode>>3)&0x07)) + sep + operands[opcode&0x7]
+		op = shiftOps[(opcode>>6&0x03)-1] + operands[opcode&0x7]
 	}
 	return op
 }
@@ -402,68 +401,18 @@ func (d *Disassembler) opocodeDD(op byte) string {
 		result = "LD (ii" + d.getRel() + ")" + sep + "n"
 	case 0x39:
 		result = "ADD ii" + sep + "SP"
-
-	case 0x44:
-		result = "LD B" + sep + "iiH"
-	case 0x45:
-		result = "LD B" + sep + "iiL"
 	case 0x46:
 		result = "LD B" + sep + "(ii" + d.getRel() + ")"
-		// 0x47 - 0x4B - no instruction
-	case 0x4C:
-		result = "LD C" + sep + "iiH"
-	case 0x4D:
-		result = "LD C" + sep + "iiL"
 	case 0x4E:
 		result = "LD C" + sep + "(ii" + d.getRel() + ")"
-
-	case 0x54:
-		result = "LD D" + sep + "iiH"
-	case 0x55:
-		result = "LD D" + sep + "iiL"
 	case 0x56:
 		result = "LD D" + sep + "(ii" + d.getRel() + ")"
-
-	case 0x5C:
-		result = "LD E" + sep + "iiH"
-	case 0x5D:
-		result = "LD E" + sep + "iiL"
 	case 0x5E:
 		result = "LD E" + sep + "(ii" + d.getRel() + ")"
-
-	case 0x60:
-		result = "LD iiH" + sep + "B"
-	case 0x61:
-		result = "LD iiH" + sep + "C"
-	case 0x62:
-		result = "LD iiH" + sep + "D"
-	case 0x63:
-		result = "LD iiH" + sep + "E"
-	case 0x64:
-		result = "LD iiH" + sep + "H"
-	case 0x65:
-		result = "LD iiH" + sep + "iiL"
 	case 0x66:
 		result = "LD H" + sep + "(ii" + d.getRel() + ")"
-	case 0x67:
-		result = "LD iiH" + sep + "A"
-	case 0x68:
-		result = "LD iiL" + sep + "B"
-	case 0x69:
-		result = "LD iiL" + sep + "C"
-	case 0x6A:
-		result = "LD iiL" + sep + "D"
-	case 0x6B:
-		result = "LD iiL" + sep + "E"
-	case 0x6C:
-		result = "LD iiL" + sep + "iiH"
-	case 0x6D:
-		result = "LD iiL" + sep + "L"
 	case 0x6E:
 		result = "LD L" + sep + "(ii" + d.getRel() + ")"
-	case 0x6F:
-		result = "LD iiL" + sep + "A"
-
 	case 0x70:
 		result = "LD (ii" + d.getRel() + ")" + sep + "B"
 	case 0x71:
@@ -478,14 +427,8 @@ func (d *Disassembler) opocodeDD(op byte) string {
 		result = "LD (ii" + d.getRel() + ")" + sep + "L"
 	case 0x77:
 		result = "LD (ii" + d.getRel() + ")" + sep + "A"
-
-	case 0x7C:
-		result = "LD A" + sep + "iiH"
-	case 0x7D:
-		result = "LD A" + sep + "iiL"
 	case 0x7E:
 		result = "LD A" + sep + "(ii" + d.getRel() + ")"
-
 	case 0x86:
 		result = "ADD A" + sep + "(ii" + d.getRel() + ")"
 	case 0x8E:

dis/z80disasm_test.go

@@ -112,43 +112,3 @@ func Test_JR_mnn(t *testing.T) {
 		t.Errorf("Error disassm JR -nn, result '%s', expected '%s'", res, expected)
 	}
 }
-
-var testLDrIXn = []byte{0xdd, 0x55, 0xdd, 0x7c}
-
-func Test_LD_r_IXn(t *testing.T) {
-	expected := "  0100 LD D, IXL"
-	setMemory(0x0100, testLDrIXn)
-	res := disasm.Disassm(0x0100)
-	if res != expected {
-		t.Errorf("Error disassm LD_r_IXn, result '%s', expected '%s'", res, expected)
-	}
-
-	expected = "  0102 LD A, IXH"
-	res = disasm.Disassm(0x0102)
-	if res != expected {
-		t.Errorf("Error disassm LD_r_IXn, result '%s', expected '%s'", res, expected)
-	}
-}
-
-var testBITnH = []byte{0xcb, 0x64, 0xcb, 0xde, 0xcb, 0x95}
-
-func Test_BIT_nn(t *testing.T) {
-	expected := "  0000 BIT 4, H" // JR back
-	setMemory(0x0000, testBITnH)
-	res := disasm.Disassm(0x0000)
-	if res != expected {
-		t.Errorf("Error disassm BIT n,H, result '%s', expected '%s'", res, expected)
-	}
-
-	expected = "  0002 SET 3, (HL)" // JR back
-	res = disasm.Disassm(0x0002)
-	if res != expected {
-		t.Errorf("Error disassm SET n,(HL), result '%s', expected '%s'", res, expected)
-	}
-
-	expected = "  0004 RES 2, L" // JR back
-	res = disasm.Disassm(0x0004)
-	if res != expected {
-		t.Errorf("Error disassm RES n,(HL), result '%s', expected '%s'", res, expected)
-	}
-}

opcodes.go

@@ -1093,13 +1093,7 @@ func (z *CPU) execOpcode(opcode byte) {
 		z.B--
 		z.condJr(z.B != 0) // djnz *
 	case 0x18:
-		// jr *
+		z.PC += uint16(z.nextB()) // jr *
-		offset := z.nextB()
-		if offset&0x80 == 0 {
-			z.PC += uint16(offset)
-		} else {
-			z.PC += 0xFF00 | uint16(offset)
-		}
 		z.MemPtr = z.PC
 	case 0x20:
 		z.condJr(!z.Flags.Z) // jr nz, *

z80go_test.go

@@ -593,23 +593,3 @@ func checkComputerState(t *testing.T, name string) {
 		}
 	}
 }
-
-func setMemory(addr uint16, value []byte) {
-	for i := 0; i < len(value); i++ {
-		computer.memory[addr+uint16(i)] = value[i]
-	}
-}
-
-var testJRm = []byte{0x70, 0x7d, 0xb3, 0x3c, 0x28, 0x09, 0xb3, 0xab, 0x4f, 0x7d, 0xa3, 0xb1, 0x6f, 0x18, 0xf1, 0x7d}
-
-func TestZ80_JR_mnn(t *testing.T) {
-	setMemory(0x31eb, testJRm)
-	state := computer.cpu.GetState()
-	state.PC = 0x31F8
-	computer.cpu.SetState(state)
-	computer.cpu.RunInstruction()
-	expected := uint16(0x31EB)
-	if computer.cpu.PC != expected {
-		t.Errorf("Error JR -nn, result PC=0x%04X, expected: 0x%04X", computer.cpu.PC, expected)
-	}
-}