From e9a253a4d15ca530c1fd17ed7a9d4a451e4fa8a4 Mon Sep 17 00:00:00 2001 From: MatCat Date: Mon, 12 Apr 2021 00:07:34 -0700 Subject: [PATCH] STx, Tx, and PHx pretty much done --- js/defines.js | 1 + js/isa/phx.js | 449 ++++++++++++++++++++++++ js/isa/tx.js | 918 ++++++++++++++++++++++++++++++++++++++++++++++++++ js/main.js | 2 - 4 files changed, 1368 insertions(+), 2 deletions(-) diff --git a/js/defines.js b/js/defines.js index b3605c9..2b34c41 100644 --- a/js/defines.js +++ b/js/defines.js @@ -101,6 +101,7 @@ const CONTROL_OUT_HO = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM3 | CONTROL_OEM1 const CONTROL_OUT_HS = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM3 | CONTROL_OEM1 | CONTROL_OEM0; const CONTROL_OUT_AE = CONTROL_AE; const CONTROL_OUT_AO = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM3 | CONTROL_OEM2 | CONTROL_OEM0; +const CONTROL_OUT_SR = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM3 | CONTROL_OEM2 | CONTROL_OEM1; const CONTROL_OUT_RO = CONTROL_OEME | CONTROL_OEM4 | CONTROL_OEM3 | CONTROL_OEM2 | CONTROL_OEM1 | CONTROL_OEM0; const CONTROL_ALU_ADD = CONTROL_OUT_AE; diff --git a/js/isa/phx.js b/js/isa/phx.js index aa9fceb..afea773 100644 --- a/js/isa/phx.js +++ b/js/isa/phx.js @@ -1,3 +1,9 @@ +/* + PUSH x Instructions + + OPCODE Range: 0x280:0x29F +*/ + class IS_PHA extends Microcode_Instruction { constructor(props) { super(props); @@ -93,6 +99,139 @@ class IS_PHAB extends Microcode_Instruction { is_PHAB = new IS_PHAB; Instructions.push(is_PHAB); +class IS_PHAC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x285; + this.Mnemonic = "PHAC"; + this.LongName = "PUSH Register A and C to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_AC | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHAC = new IS_PHAC; +Instructions.push(is_PHAC); + +class IS_PHAD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x286; + this.Mnemonic = "PHAD"; + this.LongName = "PUSH Register A and D to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_AD | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHAD = new IS_PHAD; +Instructions.push(is_PHAD); + +class IS_PHBA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x287; + this.Mnemonic = "PHBA"; + this.LongName = "PUSH Register B and A to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_BA | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHBA = new IS_PHBA; +Instructions.push(is_PHBA); + +class IS_PHBC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x288; + this.Mnemonic = "PHBC"; + this.LongName = "PUSH Register B and C to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_BC | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHBC = new IS_PHBC; +Instructions.push(is_PHBC); + +class IS_PHBD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x289; + this.Mnemonic = "PHBD"; + this.LongName = "PUSH Register B and D to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_BD | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHBD = new IS_PHBD; +Instructions.push(is_PHBD); + +class IS_PHCA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x28A; + this.Mnemonic = "PHCA"; + this.LongName = "PUSH Register C and A to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_CA | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHCA = new IS_PHCA; +Instructions.push(is_PHCA); + +class IS_PHCB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x28B; + this.Mnemonic = "PHCB"; + this.LongName = "PUSH Register C and B to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_CB | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHCB = new IS_PHCB; +Instructions.push(is_PHCB); + class IS_PHCD extends Microcode_Instruction { constructor(props) { super(props); @@ -111,3 +250,313 @@ class IS_PHCD extends Microcode_Instruction { } is_PHCD = new IS_PHCD; Instructions.push(is_PHCD); + +class IS_PHDA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x28D; + this.Mnemonic = "PHDA"; + this.LongName = "PUSH Register D and A to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_DA | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHDA = new IS_PHDA; +Instructions.push(is_PHDA); + +class IS_PHDB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x28E; + this.Mnemonic = "PHDB"; + this.LongName = "PUSH Register D and B to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_DB | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHDB = new IS_PHDB; +Instructions.push(is_PHDB); + +class IS_PHDC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x28F; + this.Mnemonic = "PHDC"; + this.LongName = "PUSH Register D and C to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_DC | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHDC = new IS_PHDC; +Instructions.push(is_PHDC); + +class IS_PHPC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x290; + this.Mnemonic = "PHPC"; + this.LongName = "PUSH Register Program Counter to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_PC | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHPC = new IS_PHPC; +Instructions.push(is_PHPC); + +class IS_PHHR extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x291; + this.Mnemonic = "PHHR"; + this.LongName = "PUSH Register High RAM Page to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_HO | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHHR = new IS_PHHR; +Instructions.push(is_PHHR); + +class IS_PHSP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x292; + this.Mnemonic = "PHSP"; + this.LongName = "PUSH Register Stack Pointer to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHSP = new IS_PHSP; +Instructions.push(is_PHSP); + +class IS_PHSR extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x293; + this.Mnemonic = "PHSR"; + this.LongName = "PUSH Register Status Register to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 4; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_SR | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHSR = new IS_PHSR; +Instructions.push(is_PHSR); + +class IS_PUSH_imm16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x294; + this.Mnemonic = "PUSH"; + this.LongName = "PUSH value to STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Immediate16; + this.Operands = new Array({Operand: "$", Bitwidth: 16}); + this.Words = 2; + this.Cycles = 6; + this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_I2 | CONTROL_PCC; + this.Microcode[4] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[5] = CONTROL_OUT_2O | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PUSH_i = new IS_PUSH_imm16; +Instructions.push(is_PUSH_i); + +class IS_PUSH_abs16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x295; + this.Mnemonic = "PUSH"; + this.LongName = "PUSH value to STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute16; + this.Operands = new Array({Operand: "", Bitwidth: 16}); + this.Words = 2; + this.Cycles = 7; + this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC; + this.Microcode[4] = CONTROL_OUT_I2; + this.Microcode[5] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[6] = CONTROL_OUT_2O | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PUSH_a = new IS_PUSH_abs16; +Instructions.push(is_PUSH_a); + +class IS_PUSH_abs24 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x296; + this.Mnemonic = "PUSH"; + this.LongName = "PUSH value to STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Absolute24; + this.Operands = new Array({Operand: "", Bitwidth: 24}); + this.Words = 3; + this.Cycles = 15; + this.Microcode[2] = CONTROL_SPD | CONTROL_SPC; + this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[4] = CONTROL_OUT_HO | CONTROL_RI | CONTROL_SPC; + this.Microcode[5] = CONTROL_OUT_PC | CONTROL_RRI; + this.Microcode[6] = CONTROL_OUT_I2 | CONTROL_PCC; + this.Microcode[7] = CONTROL_OUT_PC | CONTROL_RRI; + this.Microcode[8] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC; + this.Microcode[9] = CONTROL_OUT_2O | CONTROL_RHI; + this.Microcode[10] = CONTROL_OUT_I2; + this.Microcode[11] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[12] = CONTROL_OUT_2O | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + this.Microcode[13] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[14] = CONTROL_OUT_RO | CONTROL_RHI; + } +} +is_PUSH_a24 = new IS_PUSH_abs24; +Instructions.push(is_PUSH_a24); + +class IS_PUSH_ind16 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x297; + this.Mnemonic = "PUSH"; + this.LongName = "PUSH value to STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect16; + this.Operands = new Array({Operand: "#", Bitwidth: 16}); + this.Words = 2; + this.Cycles = 8; + this.Microcode[2] = CONTROL_OUT_PC | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC; + this.Microcode[4] = CONTROL_OUT_RO | CONTROL_RRI; + this.Microcode[5] = CONTROL_OUT_I2; + this.Microcode[6] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[7] = CONTROL_OUT_2O | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PUSH_in = new IS_PUSH_ind16; +Instructions.push(is_PUSH_in); + +class IS_PUSH_ind24 extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x298; + this.Mnemonic = "PUSH"; + this.LongName = "PUSH value to STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Indirect24; + this.Operands = new Array({Operand: "#", Bitwidth: 24}); + this.Words = 3; + this.Cycles = 16; + this.Microcode[2] = CONTROL_SPD | CONTROL_SPC; + this.Microcode[3] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[4] = CONTROL_OUT_HO | CONTROL_RI | CONTROL_SPC; + this.Microcode[5] = CONTROL_OUT_PC | CONTROL_RRI; + this.Microcode[6] = CONTROL_OUT_I2 | CONTROL_PCC; + this.Microcode[7] = CONTROL_OUT_PC | CONTROL_RRI; + this.Microcode[8] = CONTROL_OUT_RO | CONTROL_RRI | CONTROL_PCC; + this.Microcode[9] = CONTROL_OUT_2O | CONTROL_RHI; + this.Microcode[10] = CONTROL_OUT_RO | CONTROL_RRI; + this.Microcode[11] = CONTROL_OUT_I2; + this.Microcode[12] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[13] = CONTROL_OUT_2O | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + this.Microcode[14] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[15] = CONTROL_OUT_RO | CONTROL_RHI; + } +} +is_PUSH_in24 = new IS_PUSH_ind24; +Instructions.push(is_PUSH_in24); + + +class IS_PHGP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x29E; + this.Mnemonic = "PHGP"; + this.LongName = "PUSH ALL General Purpose Registers to the STACK"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 6; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_AB | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + this.Microcode[4] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[5] = CONTROL_OUT_CD | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + + } +} +is_PHGP = new IS_PHGP; +Instructions.push(is_PHGP); + +class IS_PHALL extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x29F; + this.Mnemonic = "PHALL"; + this.LongName = "PUSH ALL Registers to the STACK (AB,CD,SR,PC,HR)"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 12; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[3] = CONTROL_OUT_AB | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + this.Microcode[4] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[5] = CONTROL_OUT_CD | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + this.Microcode[6] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[7] = CONTROL_OUT_SR | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + this.Microcode[8] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[9] = CONTROL_OUT_PC | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + this.Microcode[10] = CONTROL_OUT_SP | CONTROL_RRI; + this.Microcode[11] = CONTROL_OUT_HO | CONTROL_RI | CONTROL_SPD | CONTROL_SPC; + } +} +is_PHALL = new IS_PHALL; +Instructions.push(is_PHALL); diff --git a/js/isa/tx.js b/js/isa/tx.js index d46ed24..53951eb 100644 --- a/js/isa/tx.js +++ b/js/isa/tx.js @@ -1,3 +1,9 @@ +/* + TRANSFER x Instructions + + OPCODE Range: 0x200:0x23F +*/ + class IS_TAB extends Microcode_Instruction { constructor(props) { super(props); @@ -226,3 +232,915 @@ class IS_TDC extends Microcode_Instruction { is_TDC = new IS_TDC; Instructions.push(is_TDC); +class IS_TABCD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x20C; + this.Mnemonic = "TABCD"; + this.LongName = "TRANSFER Registers A and B to C and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_AB | CONTROL_RCIL | CONTROL_RDIH; + } +} + +is_TABCD = new IS_TABCD; +Instructions.push(is_TABCD); + +class IS_TABDC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x20D; + this.Mnemonic = "TABDC"; + this.LongName = "TRANSFER Registers A and B to D and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_AB | CONTROL_RDIL | CONTROL_RCIH; + } +} + +is_TABDC = new IS_TABDC; +Instructions.push(is_TABDC); + +class IS_TBACD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x20E; + this.Mnemonic = "TBACD"; + this.LongName = "TRANSFER Registers B and A to C and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_BA | CONTROL_RCIL | CONTROL_RDIH; + } +} + +is_TBACD = new IS_TBACD; +Instructions.push(is_TBACD); + +class IS_TBADC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x20F; + this.Mnemonic = "TBADC"; + this.LongName = "TRANSFER Registers B and A to D and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_BA | CONTROL_RDIL | CONTROL_RCIH; + } +} + +is_TBADC = new IS_TBADC; +Instructions.push(is_TBADC); + +class IS_TCABD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x210; + this.Mnemonic = "TCABD"; + this.LongName = "TRANSFER Registers C and A to B and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_CA | CONTROL_RBIL | CONTROL_RDIH; + } +} + +is_TCABD = new IS_TCABD; +Instructions.push(is_TCABD); + +class IS_TCADB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x211; + this.Mnemonic = "TCADB"; + this.LongName = "TRANSFER Registers C and A to D and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_CA | CONTROL_RDIL | CONTROL_RBIH; + } +} + +is_TCADB = new IS_TCADB; +Instructions.push(is_TCADB); + +class IS_TCBAD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x212; + this.Mnemonic = "TCBAD"; + this.LongName = "TRANSFER Registers C and B to A and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_CB | CONTROL_RAIL | CONTROL_RDIH; + } +} + +is_TCBAD = new IS_TCBAD; +Instructions.push(is_TCBAD); + +class IS_TCBDA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x213; + this.Mnemonic = "TCBDA"; + this.LongName = "TRANSFER Registers C and B to D and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_CB | CONTROL_RDIL | CONTROL_RAIH; + } +} + +is_TCBDA = new IS_TCBDA; +Instructions.push(is_TCBDA); + +class IS_TCDAB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x214; + this.Mnemonic = "TCDAB"; + this.LongName = "TRANSFER Registers C and D to A and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_CD | CONTROL_RAIL | CONTROL_RBIH; + } +} + +is_TCDAB = new IS_TCDAB; +Instructions.push(is_TCDAB); + +class IS_TCDBA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x215; + this.Mnemonic = "TCDBA"; + this.LongName = "TRANSFER Registers C and D to B and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_CD | CONTROL_RBIL | CONTROL_RAIH; + } +} + +is_TCDBA = new IS_TCDBA; +Instructions.push(is_TCDBA); + +class IS_TDABC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x216; + this.Mnemonic = "TDABC"; + this.LongName = "TRANSFER Registers D and A to B and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_DA | CONTROL_RBIL | CONTROL_RCIH; + } +} + +is_TDABC = new IS_TDABC; +Instructions.push(is_TDABC); + +class IS_TDACB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x217; + this.Mnemonic = "TDACB"; + this.LongName = "TRANSFER Registers D and A to C and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_DA | CONTROL_RCIL | CONTROL_RBIH; + } +} + +is_TDACB = new IS_TDACB; +Instructions.push(is_TDACB); + +class IS_TDBAC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x218; + this.Mnemonic = "TDBAC"; + this.LongName = "TRANSFER Registers D and B to A and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_DB | CONTROL_RAIL | CONTROL_RCIH; + } +} + +is_TDBAC = new IS_TDBAC; +Instructions.push(is_TDBAC); + +class IS_TDBCA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x219; + this.Mnemonic = "TDBCA"; + this.LongName = "TRANSFER Registers D and B to C and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_DB | CONTROL_RCIL | CONTROL_RAIH; + } +} + +is_TDBCA = new IS_TDBCA; +Instructions.push(is_TDBCA); + +class IS_TDCAB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x21A; + this.Mnemonic = "TDCAB"; + this.LongName = "TRANSFER Registers D and C to A and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_DC | CONTROL_RCIL | CONTROL_RBIH; + } +} + +is_TDCAB = new IS_TDCAB; +Instructions.push(is_TDCAB); + +class IS_TDCBA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x21B; + this.Mnemonic = "TDCBA"; + this.LongName = "TRANSFER Registers D and C to B and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_DC | CONTROL_RBIL | CONTROL_RAIH; + } +} + +is_TDCBA = new IS_TDCBA; +Instructions.push(is_TDCBA); + +class IS_TSPAB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x21C; + this.Mnemonic = "TSPAB"; + this.LongName = "TRANSFER Registers Stack Pointer to A and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RAIL | CONTROL_RBIH; + } +} + +is_TSPAB = new IS_TSPAB; +Instructions.push(is_TSPAB); + +class IS_TSPAC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x21D; + this.Mnemonic = "TSPAC"; + this.LongName = "TRANSFER Registers Stack Pointer to A and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RAIL | CONTROL_RCIH; + } +} + +is_TSPAC = new IS_TSPAC; +Instructions.push(is_TSPAC); + +class IS_TSPAD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x21E; + this.Mnemonic = "TSPAD"; + this.LongName = "TRANSFER Registers Stack Pointer to A and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RAIL | CONTROL_RDIH; + } +} + +is_TSPAD = new IS_TSPAD; +Instructions.push(is_TSPAD); + +class IS_TSPBA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x21F; + this.Mnemonic = "TSPBA"; + this.LongName = "TRANSFER Registers Stack Pointer to B and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RBIL | CONTROL_RAIH; + } +} + +is_TSPBA = new IS_TSPBA; +Instructions.push(is_TSPBA); + + +class IS_TSPBC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x220; + this.Mnemonic = "TSPBC"; + this.LongName = "TRANSFER Registers Stack Pointer to B and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RBIL | CONTROL_RCIH; + } +} + +is_TSPBC = new IS_TSPBC; +Instructions.push(is_TSPBC); + +class IS_TSPBD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x221; + this.Mnemonic = "TSPBD"; + this.LongName = "TRANSFER Registers Stack Pointer to B and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RBIL | CONTROL_RDIH; + } +} + +is_TSPBD = new IS_TSPBD; +Instructions.push(is_TSPBD); + +class IS_TSPCA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x222; + this.Mnemonic = "TSPCA"; + this.LongName = "TRANSFER Registers Stack Pointer to C and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RCIL | CONTROL_RAIH; + } +} + +is_TSPCA = new IS_TSPCA; +Instructions.push(is_TSPCA); + +class IS_TSPCB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x223; + this.Mnemonic = "TSPCB"; + this.LongName = "TRANSFER Registers Stack Pointer to C and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RCIL | CONTROL_RBIH; + } +} + +is_TSPCB = new IS_TSPCB; +Instructions.push(is_TSPCB); + +class IS_TSPCD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x224; + this.Mnemonic = "TSPCD"; + this.LongName = "TRANSFER Registers Stack Pointer to C and D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RCIL | CONTROL_RDIH; + } +} + +is_TSPCD = new IS_TSPCD; +Instructions.push(is_TSPCD); + +class IS_TSPDA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x225; + this.Mnemonic = "TSPDA"; + this.LongName = "TRANSFER Registers Stack Pointer to D and A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RDIL | CONTROL_RAIH; + } +} + +is_TSPDA = new IS_TSPDA; +Instructions.push(is_TSPDA); + +class IS_TSPDB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x226; + this.Mnemonic = "TSPDB"; + this.LongName = "TRANSFER Registers Stack Pointer to D and B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RDIL | CONTROL_RBIH; + } +} + +is_TSPDB = new IS_TSPDB; +Instructions.push(is_TSPDB); + +class IS_TSPDC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x227; + this.Mnemonic = "TSPDC"; + this.LongName = "TRANSFER Registers Stack Pointer to D and C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SP | CONTROL_RDIL | CONTROL_RCIH; + } +} + +is_TSPDC = new IS_TSPDC; +Instructions.push(is_TSPDC); + +class IS_TSRA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x228; + this.Mnemonic = "TSRA"; + this.LongName = "TRANSFER Registers Status Register to A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SR | CONTROL_RAIL; + } +} + +is_TSRA = new IS_TSRA; +Instructions.push(is_TSRA); + +class IS_TSRB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x229; + this.Mnemonic = "TSRB"; + this.LongName = "TRANSFER Registers Status Register to B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SR | CONTROL_RBIL; + } +} + +is_TSRB = new IS_TSRB; +Instructions.push(is_TSRB); + +class IS_TSRC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x22A; + this.Mnemonic = "TSRC"; + this.LongName = "TRANSFER Registers Status Register to C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SR | CONTROL_RCIL; + } +} + +is_TSRC = new IS_TSRC; +Instructions.push(is_TSRC); + +class IS_TSRD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x22B; + this.Mnemonic = "TSRD"; + this.LongName = "TRANSFER Registers Status Register to D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_SR | CONTROL_RDIL; + } +} + +is_TSRD = new IS_TSRD; +Instructions.push(is_TSRD); + +class IS_TABSP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x22C; + this.Mnemonic = "TABSP"; + this.LongName = "TRANSFER Registers A and B to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_AB | CONTROL_SPI; + } +} + +is_TABSP = new IS_TABSP; +Instructions.push(is_TABSP); + +class IS_TACSP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x22D; + this.Mnemonic = "TACSP"; + this.LongName = "TRANSFER Registers A and C to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_AC | CONTROL_SPI; + } +} + +is_TACSP = new IS_TACSP; +Instructions.push(is_TACSP); + +class IS_TADSP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x22E; + this.Mnemonic = "TADSP"; + this.LongName = "TRANSFER Registers A and D to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_AD | CONTROL_SPI; + } +} + +is_TADSP = new IS_TADSP; +Instructions.push(is_TADSP); + +class IS_TBASP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x22F; + this.Mnemonic = "TBASP"; + this.LongName = "TRANSFER Registers B and A to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_BA | CONTROL_SPI; + } +} + +is_TBASP = new IS_TBASP; +Instructions.push(is_TBASP); + +class IS_TBCSP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x230; + this.Mnemonic = "TBCSP"; + this.LongName = "TRANSFER Registers B and C to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_BC | CONTROL_SPI; + } +} + +is_TBCSP = new IS_TBCSP; +Instructions.push(is_TBCSP); + +class IS_TBDSP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x231; + this.Mnemonic = "TBDSP"; + this.LongName = "TRANSFER Registers B and D to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_BD | CONTROL_SPI; + } +} + +is_TBDSP = new IS_TBDSP; +Instructions.push(is_TBDSP); + +class IS_TCASP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x232; + this.Mnemonic = "TCASP"; + this.LongName = "TRANSFER Registers C and A to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_CA | CONTROL_SPI; + } +} + +is_TCASP = new IS_TCASP; +Instructions.push(is_TCASP); + +class IS_TCBSP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x233; + this.Mnemonic = "TCBSP"; + this.LongName = "TRANSFER Registers C and B to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_CB | CONTROL_SPI; + } +} + +is_TCBSP = new IS_TCBSP; +Instructions.push(is_TCBSP); + +class IS_TCDSP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x234; + this.Mnemonic = "TCDSP"; + this.LongName = "TRANSFER Registers C and D to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_CD | CONTROL_SPI; + } +} + +is_TCDSP = new IS_TCDSP; +Instructions.push(is_TCDSP); + +class IS_TDASP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x235; + this.Mnemonic = "TDASP"; + this.LongName = "TRANSFER Registers D and A to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_DA | CONTROL_SPI; + } +} + +is_TDASP = new IS_TDASP; +Instructions.push(is_TDASP); + +class IS_TDBSP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x236; + this.Mnemonic = "TDBSP"; + this.LongName = "TRANSFER Registers D and B to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_DB | CONTROL_SPI; + } +} + +is_TDBSP = new IS_TDBSP; +Instructions.push(is_TDBSP); + +class IS_TDCSP extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x237; + this.Mnemonic = "TDCSP"; + this.LongName = "TRANSFER Registers D and C to Stack Pointer"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_DC | CONTROL_SPI; + } +} + +is_TDCSP = new IS_TDCSP; +Instructions.push(is_TDCSP); + +class IS_THRA extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x238; + this.Mnemonic = "THRA"; + this.LongName = "TRANSFER High RAM Page Register to A"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_HO | CONTROL_RAIL; + } +} + +is_THRA = new IS_THRA; +Instructions.push(is_THRA); + +class IS_THRB extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x239; + this.Mnemonic = "THRB"; + this.LongName = "TRANSFER High RAM Page Register to B"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_HO | CONTROL_RBIL; + } +} + +is_THRB = new IS_THRB; +Instructions.push(is_THRB); + +class IS_THRC extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x23A; + this.Mnemonic = "THRC"; + this.LongName = "TRANSFER High RAM Page Register to C"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_HO | CONTROL_RCIL; + } +} + +is_THRC = new IS_THRC; +Instructions.push(is_THRC); + +class IS_THRD extends Microcode_Instruction { + constructor(props) { + super(props); + this.Bytecode = 0x23B; + this.Mnemonic = "THRD"; + this.LongName = "TRANSFER High RAM Page Register to D"; + this.Aliases = new Array(); + + this.Type = InstructionTypes.Register; + this.Operands = new Array(); + this.Words = 1; + this.Cycles = 3; + this.Microcode[2] = CONTROL_OUT_HO | CONTROL_RDIL; + } +} + +is_THRD = new IS_THRD; +Instructions.push(is_THRD); diff --git a/js/main.js b/js/main.js index 5ca37d7..ef9b449 100644 --- a/js/main.js +++ b/js/main.js @@ -1,8 +1,6 @@ let cpu = new CPU_8SA1(); GenerateMicrocode(Instructions,cpu); -cpu.RAM[0] = is_LDSPP_i.Bytecode; -cpu.RAM[1] = 0xCF; cpu.RAM[2] = is_LDAB_i.Bytecode; cpu.RAM[3] = 0x0100; cpu.RAM[4] = is_PHAB.Bytecode;