Solving timing issues

sources/CPU/CPU.cpp

@@ -214,12 +214,10 @@ namespace ComSquare::CPU
 	unsigned CPU::_executeInstruction(uint8_t opcode)
 	{
 		Instruction instruction = this->_instructions[opcode];
+		uint24_t valueAddr = 0;
 
 		this->_hasIndexCrossedPageBoundary = false;
 
-		uint24_t valueAddr = 0;
-		int cycles = instruction.cycleCount + !this->_registers.p.m;
-
 		switch (instruction.addressingMode) {
 		case Implied:
 			break;
@@ -250,48 +248,38 @@ namespace ComSquare::CPU
 
 		case DirectPage:
 			valueAddr = this->_getDirectAddr();
-			cycles += this->_registers.dl != 0;
 			break;
 		case DirectPageIndirect:
 			valueAddr = this->_getDirectIndirectAddr();
-			cycles += this->_registers.dl != 0;
 			break;
 		case DirectPageIndirectLong:
 			valueAddr = this->_getDirectIndirectLongAddr();
-			cycles += this->_registers.dl != 0;
 			break;
 
 		case DirectPageIndexedByX:
 			valueAddr = this->_getDirectIndexedByXAddr();
-			cycles += this->_registers.dl != 0;
 			break;
 		case DirectPageIndexedByY:
 			valueAddr = this->_getDirectIndexedByYAddr();
-			cycles += this->_registers.dl != 0;
 			break;
 		case DirectPageIndirectIndexedByX:
 			valueAddr = this->_getDirectIndirectIndexedXAddr();
-			cycles += this->_registers.dl != 0;
 			break;
 		case DirectPageIndirectIndexedByY:
 			valueAddr = this->_getDirectIndirectIndexedYAddr();
-			cycles += this->_registers.dl != 0;
 			break;
 		case DirectPageIndirectIndexedByYLong:
 			valueAddr = this->_getDirectIndirectIndexedYLongAddr();
-			cycles += this->_registers.dl != 0 + this->_hasIndexCrossedPageBoundary;
 			break;
 
 		case AbsoluteIndexedByX:
 			valueAddr = this->_getAbsoluteIndexedByXAddr();
-			cycles += this->_hasIndexCrossedPageBoundary;
 			break;
 		case AbsoluteIndexedByXLong:
 			valueAddr = this->_getAbsoluteIndexedByXLongAddr();
 			break;
 		case AbsoluteIndexedByY:
 			valueAddr = this->_getAbsoluteIndexedByYAddr();
-			cycles += this->_hasIndexCrossedPageBoundary;
 			break;
 
 		case StackRelative:
@@ -314,191 +302,7 @@ namespace ComSquare::CPU
 			break;
 		}
 
-		return cycles + (this->*instruction.call)(valueAddr);
+		return instruction.cycleCount + (this->*instruction.call)(valueAddr, instruction.addressingMode);
-//		uint24_t addr;
-//
-//		switch (opcode) {
-//		case Instructions::BRK:      this->BRK(0x0); return 7 + !this->_isEmulationMode;
-//
-//		case Instructions::COP:      this->COP(); return 7 + !this->_isEmulationMode;
-//
-//		case Instructions::RTI:	     this->RTI(); return 6 + !this->_isEmulationMode;
-//
-//		case Instructions::ADC_IM:   this->ADC(this->_getImmediateAddrForA()); 					return 2 + !this->_registers.p.m;
-//		case Instructions::ADC_ABS:  this->ADC(this->_getAbsoluteAddr()); 						return 4 + !this->_registers.p.m;
-//		case Instructions::ADC_ABSl: this->ADC(this->_getAbsoluteLongAddr()); 					return 5 + !this->_registers.p.m;
-//		case Instructions::ADC_DP:   this->ADC(this->_getDirectAddr()); 							return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::ADC_DPi:  this->ADC(this->_getDirectIndirectAddr()); 					return 5 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::ADC_DPil: this->ADC(this->_getDirectIndirectLongAddr()); 				return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::ADC_ABSX: this->ADC(this->_getAbsoluteIndexedByXAddr()); 				return 4 + !this->_registers.p.m + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::ADC_ABSXl:this->ADC(this->_getAbsoluteIndexedByXLongAddr()); 			return 5 + !this->_registers.p.m;
-//		case Instructions::ADC_ABSY: this->ADC(this->_getAbsoluteIndexedByYAddr()); 				return 4 + !this->_registers.p.m + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::ADC_DPX:  this->ADC(this->_getDirectIndexedByXAddr()); 				return 4 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::ADC_DPXi: this->ADC(this->_getDirectIndirectIndexedXAddr()); 			return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::ADC_DPYi: this->ADC(this->_getDirectIndirectIndexedYAddr()); 			return 5 + !this->_registers.p.m + this->_registers.dl != 0 + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::ADC_DPYil:this->ADC(this->_getDirectIndirectIndexedYLongAddr()); 		return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::ADC_SR:   this->ADC(this->_getStackRelativeAddr()); 					return 4 + !this->_registers.p.m;
-//		case Instructions::ADC_SRYi: this->ADC(this->_getStackRelativeIndirectIndexedYAddr()); 	return 7 + !this->_registers.p.m;
-//
-//		case Instructions::STA_ABS:  this->STA(this->_getAbsoluteAddr()); 						return 4 + !this->_registers.p.m;
-//		case Instructions::STA_ABSl: this->STA(this->_getAbsoluteLongAddr()); 					return 5 + !this->_registers.p.m;
-//		case Instructions::STA_DP:   this->STA(this->_getDirectAddr()); 							return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STA_DPi:  this->STA(this->_getDirectIndirectAddr()); 					return 5 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STA_DPil: this->STA(this->_getDirectIndirectLongAddr()); 				return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STA_ABSX: this->STA(this->_getAbsoluteIndexedByXAddr()); 				return 5 + !this->_registers.p.m;
-//		case Instructions::STA_ABSXl:this->STA(this->_getAbsoluteIndexedByXLongAddr()); 			return 5 + !this->_registers.p.m;
-//		case Instructions::STA_ABSY: this->STA(this->_getAbsoluteIndexedByYAddr()); 				return 5 + !this->_registers.p.m;
-//		case Instructions::STA_DPX:  this->STA(this->_getDirectIndexedByXAddr()); 				return 4 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STA_DPXi: this->STA(this->_getDirectIndirectIndexedXAddr());			return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STA_DPYi: this->STA(this->_getDirectIndirectIndexedYAddr()); 			return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STA_DPYil:this->STA(this->_getDirectIndirectIndexedYLongAddr()); 		return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STA_SR:   this->STA(this->_getStackRelativeAddr()); 					return 4 + !this->_registers.p.m;
-//		case Instructions::STA_SRYi: this->STA(this->_getStackRelativeIndirectIndexedYAddr()); 	return 7 + !this->_registers.p.m;
-//
-//		case Instructions::STX_ABS:  this->STX(this->_getAbsoluteAddr()); 		return 4 + !this->_registers.p.m;
-//		case Instructions::STX_DP:   this->STX(this->_getDirectAddr()); 			return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STX_DPY:  this->STX(this->_getDirectIndexedByYAddr());	return 4 + !this->_registers.p.m + this->_registers.dl != 0;
-//
-//		case Instructions::STY_ABS:  this->STX(this->_getAbsoluteAddr()); 		return 4 + !this->_registers.p.m;
-//		case Instructions::STY_DP:   this->STX(this->_getDirectAddr()); 			return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STY_DPX:  this->STX(this->_getDirectIndexedByXAddr());	return 4 + !this->_registers.p.m + this->_registers.dl != 0;
-//
-//		case Instructions::STZ_ABS:  this->STX(this->_getAbsoluteAddr()); 			return 4 + !this->_registers.p.m;
-//		case Instructions::STZ_DP:   this->STX(this->_getDirectAddr()); 				return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STZ_ABSX: this->STX(this->_getAbsoluteIndexedByXAddr()); 	return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::STZ_DPX:  this->STX(this->_getDirectIndexedByXAddr());		return 4 + !this->_registers.p.m + this->_registers.dl != 0;
-//
-//		case Instructions::LDA_IM:   this->LDA(this->_getImmediateAddrForA()); 					return 2 + !this->_registers.p.m;
-//		case Instructions::LDA_ABS:  this->LDA(this->_getAbsoluteAddr()); 						return 4 + !this->_registers.p.m;
-//		case Instructions::LDA_ABSl: this->LDA(this->_getAbsoluteLongAddr()); 					return 5 + !this->_registers.p.m;
-//		case Instructions::LDA_DP:   this->LDA(this->_getDirectAddr()); 							return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::LDA_DPi:  this->LDA(this->_getDirectIndirectAddr()); 					return 5 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::LDA_DPil: this->LDA(this->_getDirectIndirectLongAddr()); 				return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::LDA_ABSX: this->LDA(this->_getAbsoluteIndexedByXAddr()); 				return 4 + !this->_registers.p.m + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::LDA_ABSXl:this->LDA(this->_getAbsoluteIndexedByXLongAddr()); 			return 5 + !this->_registers.p.m;
-//		case Instructions::LDA_ABSY: this->LDA(this->_getAbsoluteIndexedByYAddr()); 				return 4 + !this->_registers.p.m + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::LDA_DPX:  this->LDA(this->_getDirectIndexedByXAddr()); 				return 4 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::LDA_DPXi: this->LDA(this->_getDirectIndirectIndexedXAddr());			return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::LDA_DPYi: this->LDA(this->_getDirectIndirectIndexedYAddr()); 			return 5 + !this->_registers.p.m + this->_registers.dl != 0 + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::LDA_DPYil:this->LDA(this->_getDirectIndirectIndexedYLongAddr()); 		return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::LDA_SR:   this->LDA(this->_getStackRelativeAddr()); 					return 4 + !this->_registers.p.m;
-//		case Instructions::LDA_SRYi: this->LDA(this->_getStackRelativeIndirectIndexedYAddr()); 	return 7 + !this->_registers.p.m;
-//
-//		case Instructions::LDX_IM:   this->LDX(this->_getImmediateAddrForX()); 		return 2 + !this->_registers.p.m;
-//		case Instructions::LDX_ABS:  this->LDX(this->_getAbsoluteAddr()); 			return 4 + !this->_registers.p.m;
-//		case Instructions::LDX_DP:   this->LDX(this->_getDirectAddr()); 				return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::LDX_ABSY: this->LDX(this->_getAbsoluteIndexedByYAddr()); 	return 4 + !this->_registers.p.m + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::LDX_DPY:  this->LDX(this->_getDirectIndexedByYAddr()); 	return 4 + !this->_registers.p.m + this->_registers.dl != 0;
-//
-//		case Instructions::LDY_IM:   this->LDY(this->_getImmediateAddrForX()); 		return 2 + !this->_registers.p.m;
-//		case Instructions::LDY_ABS:  this->LDY(this->_getAbsoluteAddr()); 			return 4 + !this->_registers.p.m;
-//		case Instructions::LDY_DP:   this->LDY(this->_getDirectAddr()); 				return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::LDY_ABSY: this->LDY(this->_getAbsoluteIndexedByYAddr()); 	return 4 + !this->_registers.p.m + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::LDY_DPY:  this->LDY(this->_getDirectIndexedByYAddr()); 	return 4 + !this->_registers.p.m + this->_registers.dl != 0;
-//
-//		case Instructions::SEP: this->SEP(this->_bus->read(this->_registers.pc++)); return 3;
-//
-//		case Instructions::REP: this->REP(this->_bus->read(this->_registers.pc++)); return 3;
-//
-//		case Instructions::PHA: this->PHA(); return 3 + !this->_registers.p.m;
-//		case Instructions::PHB: this->PHB(); return 3;
-//		case Instructions::PHD: this->PHD(); return 4;
-//		case Instructions::PHK: this->PHK(); return 3;
-//		case Instructions::PHP: this->PHP(); return 3;
-//		case Instructions::PHX: this->PHX(); return 3 + !this->_registers.p.x_b;
-//		case Instructions::PHY: this->PHY(); return 3 + !this->_registers.p.x_b;
-//
-//		case Instructions::PLA: this->PLA(); return 4 + !this->_registers.p.m;
-//		case Instructions::PLB: this->PLB(); return 4;
-//		case Instructions::PLD: this->PLD(); return 5;
-//		case Instructions::PLP: this->PLP(); return 4;
-//		case Instructions::PLX: this->PLX(); return 4 + !this->_registers.p.x_b;
-//		case Instructions::PLY: this->PLY(); return 4 + !this->_registers.p.x_b;
-//
-//		case Instructions::JSR_ABS:   this->JSR(this->_getAbsoluteAddr()); 				   return 6;
-//		case Instructions::JSR_ABSXi: this->JSR(this->_getAbsoluteIndirectIndexedByXAddr()); return 8;
-//
-//		case Instructions::JSL: this->JSL(this->_getAbsoluteLongAddr()); return 8;
-//
-//		case Instructions::CLC: this->CLC(); return 2;
-//		case Instructions::CLI: this->CLI(); return 2;
-//		case Instructions::CLD: this->CLD(); return 2;
-//		case Instructions::CLV: this->CLV(); return 2;
-//
-//		case Instructions::SEC: this->SEC(); return 2;
-//		case Instructions::SED: this->SED(); return 2;
-//		case Instructions::SEI: this->SEI(); return 2;
-//
-//		case Instructions::AND_IM:   this->AND(this->_getImmediateAddrForA()); 					return 2 + !this->_registers.p.m;
-//		case Instructions::AND_ABS:  this->AND(this->_getAbsoluteAddr()); 						return 4 + !this->_registers.p.m;
-//		case Instructions::AND_ABSl: this->AND(this->_getAbsoluteLongAddr()); 					return 5 + !this->_registers.p.m;
-//		case Instructions::AND_DP:   this->AND(this->_getDirectAddr()); 							return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::AND_DPi:  this->AND(this->_getDirectIndirectAddr()); 					return 5 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::AND_DPil: this->AND(this->_getDirectIndirectLongAddr()); 				return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::AND_ABSX: this->AND(this->_getAbsoluteIndexedByXAddr()); 				return 4 + !this->_registers.p.m + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::AND_ABSXl:this->AND(this->_getAbsoluteIndexedByXLongAddr()); 			return 5 + !this->_registers.p.m;
-//		case Instructions::AND_ABSY: this->AND(this->_getAbsoluteIndexedByYAddr()); 				return 4 + !this->_registers.p.m + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::AND_DPX:  this->AND(this->_getDirectIndexedByXAddr()); 				return 4 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::AND_DPXi: this->AND(this->_getDirectIndirectIndexedXAddr());			return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::AND_DPYi: this->AND(this->_getDirectIndirectIndexedYAddr()); 			return 5 + !this->_registers.p.m + this->_registers.dl != 0 + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::AND_DPYil:this->AND(this->_getDirectIndirectIndexedYLongAddr()); 		return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::AND_SR:   this->AND(this->_getStackRelativeAddr()); 					return 4 + !this->_registers.p.m;
-//		case Instructions::AND_SRYi: this->AND(this->_getStackRelativeIndirectIndexedYAddr()); 	return 7 + !this->_registers.p.m;
-//
-//		case Instructions::XCE: this->XCE(); return 2;
-//
-//		case Instructions::SBC_IM:   this->SBC(this->_getImmediateAddrForA()); 					return 2 + !this->_registers.p.m;
-//		case Instructions::SBC_ABS:  this->SBC(this->_getAbsoluteAddr()); 						return 4 + !this->_registers.p.m;
-//		case Instructions::SBC_ABSl: this->SBC(this->_getAbsoluteLongAddr()); 					return 5 + !this->_registers.p.m;
-//		case Instructions::SBC_DP:   this->SBC(this->_getDirectAddr()); 							return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::SBC_DPi:  this->SBC(this->_getDirectIndirectAddr()); 					return 5 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::SBC_DPil: this->SBC(this->_getDirectIndirectLongAddr()); 				return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::SBC_ABSX: this->SBC(this->_getAbsoluteIndexedByXAddr()); 				return 4 + !this->_registers.p.m + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::SBC_ABSXl:this->SBC(this->_getAbsoluteIndexedByXLongAddr()); 			return 5 + !this->_registers.p.m;
-//		case Instructions::SBC_ABSY: this->SBC(this->_getAbsoluteIndexedByYAddr()); 				return 4 + !this->_registers.p.m + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::SBC_DPX:  this->SBC(this->_getDirectIndexedByXAddr()); 				return 4 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::SBC_DPXi: this->SBC(this->_getDirectIndirectIndexedXAddr());			return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::SBC_DPYi: this->SBC(this->_getDirectIndirectIndexedYAddr()); 			return 5 + !this->_registers.p.m + this->_registers.dl != 0 + this->_hasIndexCrossedPageBoundary;
-//		case Instructions::SBC_DPYil:this->SBC(this->_getDirectIndirectIndexedYLongAddr()); 		return 6 + !this->_registers.p.m + this->_registers.dl != 0;
-//		case Instructions::SBC_SR:   this->SBC(this->_getStackRelativeAddr()); 					return 4 + !this->_registers.p.m;
-//		case Instructions::SBC_SRYi: this->SBC(this->_getStackRelativeIndirectIndexedYAddr()); 	return 7 + !this->_registers.p.m;
-//
-//		case Instructions::TAX: 	this->TAX();	return 2;
-//		case Instructions::TAY: 	this->TAY();	return 2;
-//		case Instructions::TXS: 	this->TXS();	return 2;
-//
-//		case Instructions::INX: 	this->INX();	return 2;
-//		case Instructions::INY: 	this->INY();	return 2;
-//
-//		case Instructions::CPX_IM: 	this->CPX(this->_getImmediateAddrForX()); return 2 + !this->_registers.p.m;
-//		case Instructions::CPX_ABS: this->CPX(this->_getAbsoluteAddr());		 return 4 + !this->_registers.p.m;
-//		case Instructions::CPX_DP: 	this->CPX(this->_getDirectAddr());		 return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//
-//		case Instructions::CPY_IM: 	this->CPY(this->_getImmediateAddrForX()); return 2 + !this->_registers.p.m;
-//		case Instructions::CPY_ABS: this->CPY(this->_getAbsoluteAddr());		 return 4 + !this->_registers.p.m;
-//		case Instructions::CPY_DP: 	this->CPY(this->_getDirectAddr());		 return 3 + !this->_registers.p.m + this->_registers.dl != 0;
-//
-//		case Instructions::BCC: return this->BCC(this->_registers.pc++) + 2 + this->_isEmulationMode;
-//		case Instructions::BCS: return this->BCS(this->_registers.pc++) + 2 + this->_isEmulationMode;
-//		case Instructions::BEQ: return this->BEQ(this->_registers.pc++) + 2 + this->_isEmulationMode;
-//		case Instructions::BNE: return this->BNE(this->_registers.pc++) + 2 + this->_isEmulationMode;
-//		case Instructions::BMI: return this->BMI(this->_registers.pc++) + 2 + this->_isEmulationMode;
-//		case Instructions::BPL: return this->BPL(this->_registers.pc++) + 2 + this->_isEmulationMode;
-//		case Instructions::BVC: return this->BVC(this->_registers.pc++) + 2 + this->_isEmulationMode;
-//		case Instructions::BVS: return this->BVS(this->_registers.pc++) + 2 + this->_isEmulationMode;
-//		case Instructions::BRA: this->BRA(this->_registers.pc++);  return 3 + this->_isEmulationMode;
-//		case Instructions::BRL: this->BRL(this->_registers.pc); this->_registers.pc += 2;  return 4;
-//
-//		case Instructions::JMP_ABS: 	addr = this->_getAbsoluteAddr();           this->JMP(addr); 	   return 3;
-//		case Instructions::JMP_ABSi: 	addr = this->_getAbsoluteIndirectAddr();   this->JMP(addr); 	   return 3;
-//		case Instructions::JMP_ABSXi: 	addr = this->_getAbsoluteIndexedByXAddr(); this->JMP(addr); 	   return 3;
-//
-//		case Instructions::JML_ABSl: 	addr = this->_getAbsoluteLongAddr();       this->JML(addr);        return 3;
-//		//case Instructions::JML_ABSil: 	this->JML(this->_getAbsoluteLong()); 	return 3;
-//
-//		default:
-//			throw InvalidOpcode("CPU", opcode);
-//		}
 	}
 
 	void CPU::_push(uint8_t data)

sources/CPU/CPU.hpp

@@ -261,121 +261,121 @@ namespace ComSquare::CPU
 		virtual unsigned _executeInstruction(uint8_t opcode);
 
 		//! @brief Break instruction - Causes a software break. The PC is loaded from a vector table.
-		int BRK(uint24_t);
+		int BRK(uint24_t, AddressingMode);
 		//! @brief Co-Processor Enable instruction - Causes a software break. The PC is loaded from a vector table.
-		int COP(uint24_t);
+		int COP(uint24_t, AddressingMode);
 		//! @brief Return from Interrupt - Used to return from a interrupt handler.
-		int RTI(uint24_t);
+		int RTI(uint24_t, AddressingMode);
 		//! @brief Add with carry - Adds operand to the Accumulator; adds an additional 1 if carry is set.
-		int ADC(uint24_t valueAddr);
+		int ADC(uint24_t valueAddr, AddressingMode);
 		//! @brief Store the accumulator to memory.
-		int STA(uint24_t addr);
+		int STA(uint24_t addr, AddressingMode);
 		//! @brief Store the index register X to memory.
-		int STX(uint24_t addr);
+		int STX(uint24_t addr, AddressingMode);
 		//! @brief Store the index register Y to memory.
-		int STY(uint24_t addr);
+		int STY(uint24_t addr, AddressingMode);
 		//! @brief Store zero to the memory.
-		int STZ(uint24_t addr);
+		int STZ(uint24_t addr, AddressingMode);
 		//! @brief Load the accumulator from memory.
-		int LDA(uint24_t addr);
+		int LDA(uint24_t addr, AddressingMode);
 		//! @brief Load the X index register from memory.
-		int LDX(uint24_t addr);
+		int LDX(uint24_t addr, AddressingMode);
 		//! @brief Load the Y index register from memory.
-		int LDY(uint24_t addr);
+		int LDY(uint24_t addr, AddressingMode);
 		//! @brief Set status bits.
-		int SEP(uint24_t valueAddr);
+		int SEP(uint24_t valueAddr, AddressingMode);
 		//! @brief Reset status bits.
-		int REP(uint24_t valueAddr);
+		int REP(uint24_t valueAddr, AddressingMode);
 		//! @brief Jump to subroutine
-		int JSR(uint24_t addr);
+		int JSR(uint24_t addr, AddressingMode);
 		//! @brief Jump to subroutine (long)
-		int JSL(uint24_t addr);
+		int JSL(uint24_t addr, AddressingMode);
 		//! @brief Push the accumulator to the stack.
-		int PHA(uint24_t);
+		int PHA(uint24_t, AddressingMode);
 		//! @brief Push the data bank register to the stack.
-		int PHB(uint24_t);
+		int PHB(uint24_t, AddressingMode);
 		//! @brief Push the direct page register to the stack.
-		int PHD(uint24_t);
+		int PHD(uint24_t, AddressingMode);
 		//! @brief Push the program bank register to the stack.
-		int PHK(uint24_t);
+		int PHK(uint24_t, AddressingMode);
 		//! @brief Push the processor status register to the stack.
-		int PHP(uint24_t);
+		int PHP(uint24_t, AddressingMode);
 		//! @brief Push the x index register to the stack.
-		int PHX(uint24_t);
+		int PHX(uint24_t, AddressingMode);
 		//! @brief Push the y index register to the stack.
-		int PHY(uint24_t);
+		int PHY(uint24_t, AddressingMode);
 		//! @brief Pull the accumulator to the stack.
-		int PLA(uint24_t);
+		int PLA(uint24_t, AddressingMode);
 		//! @brief Pull the data bank register to the stack.
-		int PLB(uint24_t);
+		int PLB(uint24_t, AddressingMode);
 		//! @brief Pull the direct page register to the stack.
-		int PLD(uint24_t);
+		int PLD(uint24_t, AddressingMode);
 		//! @brief Pull the processor status register to the stack.
-		int PLP(uint24_t);
+		int PLP(uint24_t, AddressingMode);
 		//! @brief Pull the x index register to the stack.
-		int PLX(uint24_t);
+		int PLX(uint24_t, AddressingMode);
 		//! @brief Pull the y index register to the stack.
-		int PLY(uint24_t);
+		int PLY(uint24_t, AddressingMode);
 		//! @brief Clear the carry flag.
-		int CLC(uint24_t);
+		int CLC(uint24_t, AddressingMode);
 		//! @brief Clear the Interrupt Disable flag.
-		int CLI(uint24_t);
+		int CLI(uint24_t, AddressingMode);
 		//! @brief Clear the decimal flag.
-		int CLD(uint24_t);
+		int CLD(uint24_t, AddressingMode);
 		//! @brief Clear the overflow flag.
-		int CLV(uint24_t);
+		int CLV(uint24_t, AddressingMode);
 		//! @brief Set the carry Flag.
-		int SEC(uint24_t);
+		int SEC(uint24_t, AddressingMode);
 		//! @brief Set the decimal flag.
-		int SED(uint24_t);
+		int SED(uint24_t, AddressingMode);
 		//! @brief Set the Interrupt Disable flag.
-		int SEI(uint24_t);
+		int SEI(uint24_t, AddressingMode);
 		//! @brief Exchange Carry and Emulation Flags
-		int XCE(uint24_t);
+		int XCE(uint24_t, AddressingMode);
 		//! @brief And accumulator with memory.
-		int AND(uint24_t valueAddr);
+		int AND(uint24_t valueAddr, AddressingMode);
 		//! @brief Subtract with Borrow from Accumulator.
-		int SBC(uint24_t valueAddr);
+		int SBC(uint24_t valueAddr, AddressingMode);
 		//! @brief Transfer A to X
-		int TAX(uint24_t);
+		int TAX(uint24_t, AddressingMode);
 		//! @brief Transfer A to Y
-		int TAY(uint24_t);
+		int TAY(uint24_t, AddressingMode);
 		//! @brief Transfer X to SP
-		int TXS(uint24_t);
+		int TXS(uint24_t, AddressingMode);
 		//! @brief Increment the X register
-		int INX(uint24_t);
+		int INX(uint24_t, AddressingMode);
 		//! @brief Increment the Y register
-		int INY(uint24_t);
+		int INY(uint24_t, AddressingMode);
 		//! @brief Compare the X register with the memory
-		int CPX(uint24_t valueAddr);
+		int CPX(uint24_t valueAddr, AddressingMode);
 		//! @brief Compare the Y register with the memory
-		int CPY(uint24_t valueAddr);
+		int CPY(uint24_t valueAddr, AddressingMode);
 		//! @brief Branch if carry clear
-		int BCC(uint24_t valueAddr);
+		int BCC(uint24_t valueAddr, AddressingMode);
 		//! @brief Branch if carry set
-		int BCS(uint24_t valueAddr);
+		int BCS(uint24_t valueAddr, AddressingMode);
 		//! @brief Branch if equal
-		int BEQ(uint24_t valueAddr);
+		int BEQ(uint24_t valueAddr, AddressingMode);
 		//! @brief Branch if not equal
-		int BNE(uint24_t valueAddr);
+		int BNE(uint24_t valueAddr, AddressingMode);
 		//! @brief Branch if minus
-		int BMI(uint24_t valueAddr);
+		int BMI(uint24_t valueAddr, AddressingMode);
 		//! @brief Branch if plus
-		int BPL(uint24_t valueAddr);
+		int BPL(uint24_t valueAddr, AddressingMode);
 		//! @brief Branch if Overflow Clear
-		int BVC(uint24_t valueAddr);
+		int BVC(uint24_t valueAddr, AddressingMode);
 		//! @brief Branch if Overflow Set
-		int BVS(uint24_t valueAddr);
+		int BVS(uint24_t valueAddr, AddressingMode);
 		//! @brief Branch always
-		int BRA(uint24_t valueAddr);
+		int BRA(uint24_t valueAddr, AddressingMode);
 		//! @brief Branch always long
-		int BRL(uint24_t valueAddr);
+		int BRL(uint24_t valueAddr, AddressingMode);
 		//! @brief Jump.
-		int JMP(uint24_t valueAddr);
+		int JMP(uint24_t valueAddr, AddressingMode);
 		//! @brief Long jump.
-		int JML(uint24_t valueAddr);
+		int JML(uint24_t valueAddr, AddressingMode);
 		//! @brief No OP.
-		int NOP(uint24_t);
+		int NOP(uint24_t, AddressingMode);
 
 		//! @brief All the instructions of the CPU.
 		//! @info Instructions are indexed by their opcode
@@ -580,7 +580,7 @@ namespace ComSquare::CPU
 			{&CPU::BRK, 7, "cmp #-#", AddressingMode::Implied, 2}, // C5
 			{&CPU::BRK, 7, "dec #-#", AddressingMode::Implied, 2}, // C6
 			{&CPU::BRK, 7, "cmp #-#", AddressingMode::Implied, 2}, // C7
-			{&CPU::BRK, 7, "iny #-#", AddressingMode::Implied, 2}, // C8
+			{&CPU::INY, 2, "iny", AddressingMode::Implied, 1}, // C8
 			{&CPU::BRK, 7, "cmp #-#", AddressingMode::Implied, 2}, // C9
 			{&CPU::BRK, 7, "dex #-#", AddressingMode::Implied, 2}, // CA
 			{&CPU::BRK, 7, "wai #-#", AddressingMode::Implied, 2}, // CB
@@ -612,7 +612,7 @@ namespace ComSquare::CPU
 			{&CPU::SBC, 3, "sbc", AddressingMode::DirectPage, 2}, // E5
 			{&CPU::BRK, 7, "inc #-#", AddressingMode::Implied, 2}, // E6
 			{&CPU::SBC, 6, "sbc", AddressingMode::DirectPageIndirectLong, 2}, // E7
-			{&CPU::BRK, 7, "inx #-#", AddressingMode::Implied, 2}, // E8
+			{&CPU::INX, 2, "inx", AddressingMode::Implied, 1}, // E8
 			{&CPU::SBC, 2, "sbc", AddressingMode::ImmediateForA, 2}, // E9
 			{&CPU::NOP, 2, "nop", AddressingMode::Implied, 1}, // EA
 			{&CPU::BRK, 7, "xba #-#", AddressingMode::Implied, 2}, // EB
@@ -663,7 +663,7 @@ namespace ComSquare::CPU
 		Component getComponent() override;
 
 		//! @brief Reset interrupt - Called on boot and when the reset button is pressed.
-		virtual int RESB(uint24_t = 0);
+		virtual int RESB();
 
 		//! @brief Return true if the CPU is overloaded with debugging features.
 		virtual bool isDebugger();

sources/CPU/Instruction.hpp

@@ -52,11 +52,11 @@ namespace ComSquare::CPU
 
 	//! @brief Struct containing basic information about instructions.
 	struct Instruction {
-		int (CPU::*call)(uint24_t valueAddr);
+		int (CPU::*call)(uint24_t valueAddr, AddressingMode mode) = nullptr;
-		int cycleCount;
+		int cycleCount = 0;
-		std::string name;
+		std::string name = "";
-		AddressingMode addressingMode;
+		AddressingMode addressingMode = Implied;
-		int size;
+		int size = 0;
 
 		Instruction() = default;
 		Instruction(const Instruction &) = default;

sources/CPU/Instructions/BitsInstructions.cpp

@@ -7,7 +7,7 @@
 
 namespace ComSquare::CPU
 {
-	int CPU::AND(uint24_t valueAddr)
+	int CPU::AND(uint24_t valueAddr, AddressingMode mode)
 	{
 		unsigned negativeMask = this->_isEmulationMode ? 0x80u : 0x8000u;
 		unsigned value = this->_bus->read(valueAddr);
@@ -17,6 +17,27 @@ namespace ComSquare::CPU
 		this->_registers.a &= value;
 		this->_registers.p.n = this->_registers.a & negativeMask;
 		this->_registers.p.z = this->_registers.a == 0;
-		return 0;
+
+		int cycles = !this->_registers.p.m;
+		switch (mode) {
+		case DirectPage:
+		case DirectPageIndirect:
+		case DirectPageIndirectLong:
+		case DirectPageIndexedByX:
+		case DirectPageIndirectIndexedByX:
+		case DirectPageIndirectIndexedByYLong:
+			cycles += this->_registers.dl != 0;
+			break;
+		case AbsoluteIndexedByX:
+		case AbsoluteIndexedByY:
+			cycles += this->_hasIndexCrossedPageBoundary;
+			break;
+		case DirectPageIndirectIndexedByY:
+			cycles += this->_registers.dl != 0 + this->_hasIndexCrossedPageBoundary;
+			break;
+		default:
+			break;
+		}
+		return cycles;
 	}
 }

sources/CPU/Instructions/InternalInstruction.cpp

@@ -6,55 +6,55 @@
 
 namespace ComSquare::CPU
 {
-	int CPU::SEC(uint24_t)
+	int CPU::SEC(uint24_t, AddressingMode)
 	{
 		this->_registers.p.c = true;
 		return 0;
 	}
 
-	int CPU::SED(uint24_t)
+	int CPU::SED(uint24_t, AddressingMode)
 	{
 		this->_registers.p.d = true;
 		return 0;
 	}
 
-	int CPU::SEI(uint24_t)
+	int CPU::SEI(uint24_t, AddressingMode)
 	{
 		this->_registers.p.i = true;
 		return 0;
 	}
 
-	int CPU::CLC(uint24_t)
+	int CPU::CLC(uint24_t, AddressingMode)
 	{
 		this->_registers.p.c = false;
 		return 0;
 	}
 
-	int CPU::CLI(uint24_t)
+	int CPU::CLI(uint24_t, AddressingMode)
 	{
 		this->_registers.p.i = false;
 		return 0;
 	}
 
-	int CPU::CLD(uint24_t)
+	int CPU::CLD(uint24_t, AddressingMode)
 	{
 		this->_registers.p.d = false;
 		return 0;
 	}
 
-	int CPU::CLV(uint24_t)
+	int CPU::CLV(uint24_t, AddressingMode)
 	{
 		this->_registers.p.v = false;
 		return 0;
 	}
 
-	int CPU::SEP(uint24_t valueAddr)
+	int CPU::SEP(uint24_t valueAddr, AddressingMode)
 	{
 		this->_registers.p.flags |= this->_bus->read(valueAddr);
 		return 0;
 	}
 
-	int CPU::REP(uint24_t valueAddr)
+	int CPU::REP(uint24_t valueAddr, AddressingMode)
 	{
 		this->_registers.p.flags &= ~this->_bus->read(valueAddr);
 		if (this->_isEmulationMode) {
@@ -64,14 +64,14 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::JSR(uint24_t valueAddr)
+	int CPU::JSR(uint24_t valueAddr, AddressingMode)
 	{
 		this->_push(--this->_registers.pc);
 		this->_registers.pc = valueAddr;
 		return 0;
 	}
 
-	int CPU::JSL(uint24_t valueAddr)
+	int CPU::JSL(uint24_t valueAddr, AddressingMode)
 	{
 		this->_registers.pac--;
 		this->_push(this->_registers.pbr);
@@ -80,58 +80,61 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::PHA(uint24_t)
+	int CPU::PHA(uint24_t, AddressingMode)
 	{
 		this->_push(this->_registers.a);
-		return 0;
+		return !this->_registers.p.m;
 	}
 
-	int CPU::PHB(uint24_t)
+	int CPU::PHB(uint24_t, AddressingMode)
 	{
 		this->_push(this->_registers.dbr);
 		return 0;
 	}
 
-	int CPU::PHD(uint24_t)
+	int CPU::PHD(uint24_t, AddressingMode)
 	{
 		this->_push(this->_registers.d);
 		return 0;
 	}
 
-	int CPU::PHK(uint24_t)
+	int CPU::PHK(uint24_t, AddressingMode)
 	{
 		this->_push(this->_registers.pbr);
 		return 0;
 	}
 
-	int CPU::PHP(uint24_t)
+	int CPU::PHP(uint24_t, AddressingMode)
 	{
 		this->_push(this->_registers.p.flags);
 		return 0;
 	}
 
-	int CPU::PHX(uint24_t)
+	int CPU::PHX(uint24_t, AddressingMode)
 	{
 		this->_push(this->_registers.x);
-		return 0;
+		return !this->_registers.p.x_b;
 	}
 
-	int CPU::PHY(uint24_t)
+	int CPU::PHY(uint24_t, AddressingMode)
 	{
 		this->_push(this->_registers.y);
-		return 0;
+		return !this->_registers.p.x_b;
 	}
 
-	int CPU::PLA(uint24_t)
+	int CPU::PLA(uint24_t, AddressingMode)
 	{
-		// TODO this register should be poped by 8 if the m flag is 1
+		if (this->_registers.p.m) {
-		this->_registers.a = this->_pop16();
+			this->_registers.a = this->_pop();
+			this->_registers.ah = 0;
+		} else
+			this->_registers.a = this->_pop16();
 		this->_registers.p.z = this->_registers.a == 0;
 		this->_registers.p.n = this->_registers.a & 0x8000u;
-		return 0;
+		return !this->_registers.p.m;
 	}
 
-	int CPU::PLB(uint24_t)
+	int CPU::PLB(uint24_t, AddressingMode)
 	{
 		this->_registers.dbr = this->_pop();
 		this->_registers.p.z = this->_registers.dbr == 0;
@@ -139,7 +142,7 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::PLD(uint24_t)
+	int CPU::PLD(uint24_t, AddressingMode)
 	{
 		this->_registers.d = this->_pop16();
 		this->_registers.p.z = this->_registers.d == 0;
@@ -147,7 +150,7 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::PLP(uint24_t)
+	int CPU::PLP(uint24_t, AddressingMode)
 	{
 		this->_registers.p.flags = this->_pop();
 		if (this->_isEmulationMode) {
@@ -157,25 +160,31 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::PLX(uint24_t)
+	int CPU::PLX(uint24_t, AddressingMode)
 	{
-		// TODO this register should be poped by 8 if the x_b is 1
+		if (this->_registers.p.x_b) {
-		this->_registers.x = this->_pop16();
+			this->_registers.x = this->_pop();
+			this->_registers.xh = 0;
+		} else
+			this->_registers.x = this->_pop16();
 		this->_registers.p.z = this->_registers.x == 0;
 		this->_registers.p.n = this->_registers.x & 0x8000u;
-		return 0;
+		return !this->_registers.p.x_b;
 	}
 
-	int CPU::PLY(uint24_t)
+	int CPU::PLY(uint24_t, AddressingMode)
 	{
-		// TODO this register should be poped by 8 if the x_b is 1
+		if (this->_registers.p.x_b) {
-		this->_registers.y = this->_pop16();
+			this->_registers.y = this->_pop();
+			this->_registers.yh = 0;
+		} else
+			this->_registers.y = this->_pop16();
 		this->_registers.p.z = this->_registers.y == 0;
 		this->_registers.p.n = this->_registers.y & 0x8000u;
-		return 0;
+		return !this->_registers.p.x_b;
 	}
 
-	int CPU::XCE(uint24_t)
+	int CPU::XCE(uint24_t, AddressingMode)
 	{
 		bool oldCarry = this->_registers.p.c;
 		this->_registers.p.c = this->_isEmulationMode;
@@ -190,7 +199,7 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::INX(uint24_t)
+	int CPU::INX(uint24_t, AddressingMode)
 	{
 		this->_registers.x++;
 
@@ -203,7 +212,7 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::INY(uint24_t)
+	int CPU::INY(uint24_t, AddressingMode)
 	{
 		this->_registers.y++;
 
@@ -216,7 +225,7 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::CPX(uint24_t valueAddr)
+	int CPU::CPX(uint24_t valueAddr, AddressingMode mode)
 	{
 		unsigned value = this->_bus->read(valueAddr++);
 
@@ -233,10 +242,10 @@ namespace ComSquare::CPU
 			this->_registers.p.n = x & 0x8000u;
 		}
 		this->_registers.p.c = this->_registers.x >= value;
-		return 0;
+		return !this->_registers.p.x_b + (mode == DirectPage && this->_registers.dl != 0);
 	}
 
-	int CPU::CPY(uint24_t valueAddr)
+	int CPU::CPY(uint24_t valueAddr, AddressingMode mode)
 	{
 		unsigned value = this->_bus->read(valueAddr++);
 
@@ -253,93 +262,93 @@ namespace ComSquare::CPU
 			this->_registers.p.z = y == 0;
 			this->_registers.p.n = y & 0x8000u;
 		}
-		return 0;
+		return !this->_registers.p.x_b + (mode == DirectPage && this->_registers.dl != 0);
 	}
 
-	int CPU::BCC(uint24_t valueAddr)
+	int CPU::BCC(uint24_t valueAddr, AddressingMode)
 	{
 		if (!this->_registers.p.c)
 			this->_registers.pc += static_cast<int8_t>(this->_bus->read(valueAddr));
-		return !this->_registers.p.c;
+		return !this->_registers.p.c + this->_isEmulationMode;
 	}
 
-	int CPU::BCS(uint24_t valueAddr)
+	int CPU::BCS(uint24_t valueAddr, AddressingMode)
 	{
 		if (this->_registers.p.c)
 			this->_registers.pc += static_cast<int8_t>(this->_bus->read(valueAddr));
-		return this->_registers.p.c;
+		return this->_registers.p.c + this->_isEmulationMode;
 	}
 
-	int CPU::BEQ(uint24_t valueAddr)
+	int CPU::BEQ(uint24_t valueAddr, AddressingMode)
 	{
 		if (this->_registers.p.z)
 			this->_registers.pc += static_cast<int8_t>(this->_bus->read(valueAddr));
-		return this->_registers.p.z;
+		return this->_registers.p.z + this->_isEmulationMode;
 	}
 
-	int CPU::BNE(uint24_t valueAddr)
+	int CPU::BNE(uint24_t valueAddr, AddressingMode)
 	{
 		if (!this->_registers.p.z)
 			this->_registers.pc += static_cast<int8_t>(this->_bus->read(valueAddr));
-		return !this->_registers.p.z;
+		return !this->_registers.p.z + this->_isEmulationMode;
 	}
 
-	int CPU::BMI(uint24_t valueAddr)
+	int CPU::BMI(uint24_t valueAddr, AddressingMode)
 	{
 		if (this->_registers.p.n)
 			this->_registers.pc += static_cast<int8_t>(this->_bus->read(valueAddr));
-		return this->_registers.p.n;
+		return this->_registers.p.n + this->_isEmulationMode;
 	}
 
-	int CPU::BPL(uint24_t valueAddr)
+	int CPU::BPL(uint24_t valueAddr, AddressingMode)
 	{
 		if (!this->_registers.p.n)
 			this->_registers.pc += static_cast<int8_t>(this->_bus->read(valueAddr));
-		return !this->_registers.p.n;
+		return !this->_registers.p.n + this->_isEmulationMode;
 	}
 
-	int CPU::BRA(uint24_t valueAddr)
+	int CPU::BRA(uint24_t valueAddr, AddressingMode)
 	{
 		this->_registers.pc += static_cast<int8_t>(this->_bus->read(valueAddr));
-		return true;
+		return this->_isEmulationMode;
 	}
 
-	int CPU::BRL(uint24_t valueAddr)
+	int CPU::BRL(uint24_t valueAddr, AddressingMode)
 	{
 		unsigned value = this->_bus->read(valueAddr);
 		value += this->_bus->read(valueAddr + 1) << 8u;
 
 		this->_registers.pc += static_cast<int16_t>(value);
-		return true;
+		return 0;
 	}
 
-	int CPU::BVC(uint24_t valueAddr)
+	int CPU::BVC(uint24_t valueAddr, AddressingMode)
 	{
 		if (!this->_registers.p.v)
 			this->_registers.pc += static_cast<int8_t>(this->_bus->read(valueAddr));
-		return !this->_registers.p.v;
+		return !this->_registers.p.v + this->_isEmulationMode;
 	}
 
-	int CPU::BVS(uint24_t valueAddr)
+	int CPU::BVS(uint24_t valueAddr, AddressingMode)
 	{
 		if (this->_registers.p.v)
 			this->_registers.pc += static_cast<int8_t>(this->_bus->read(valueAddr));
-		return this->_registers.p.v;
+		return this->_registers.p.v + this->_isEmulationMode;
 	}
 
-	int CPU::JMP(uint24_t value)
+	int CPU::JMP(uint24_t value, AddressingMode)
 	{
 		this->_registers.pc = value;
 		return 0;
 	}
 
-	int CPU::JML(uint24_t value)
+	int CPU::JML(uint24_t value, AddressingMode)
 	{
 		this->_registers.pac = value;
 		return 0;
 	}
 
-	int CPU::NOP(uint24_t)
+	int CPU::NOP(uint24_t, AddressingMode)
 	{
 		return 0;
 	}

sources/CPU/Instructions/Interrupts.cpp

@@ -6,7 +6,7 @@
 
 namespace ComSquare::CPU
 {
-	int CPU::RESB(uint24_t)
+	int CPU::RESB()
 	{
 		this->_registers.p.i = true;
 		this->_registers.p.d = false;
@@ -21,7 +21,7 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::BRK(uint24_t)
+	int CPU::BRK(uint24_t, AddressingMode)
 	{
 		if (this->_isEmulationMode) {
 			this->_registers.pc += 2;
@@ -31,7 +31,6 @@ namespace ComSquare::CPU
 			this->_registers.p.i = true;
 			this->_registers.p.d = false;
 			this->_registers.pc = this->_cartridgeHeader.emulationInterrupts.brk;
-
 		} else {
 			this->_push(this->_registers.pbr);
 			this->_registers.pc += 2;
@@ -45,7 +44,7 @@ namespace ComSquare::CPU
 		return !this->_isEmulationMode;
 	}
 
-	int CPU::COP(uint24_t)
+	int CPU::COP(uint24_t, AddressingMode)
 	{
 		if (this->_isEmulationMode) {
 			this->_registers.pc += 2;
@@ -68,13 +67,13 @@ namespace ComSquare::CPU
 		return !this->_isEmulationMode;
 	}
 
-	int CPU::RTI(uint24_t)
+	int CPU::RTI(uint24_t, AddressingMode)
 	{
 		this->_registers.p.flags = this->_pop();
 		this->_registers.pc = this->_pop16();
 
 		if (!this->_isEmulationMode)
 			this->_registers.pbr = this->_pop16();
-		return 0;
+		return !this->_isEmulationMode;
 	}
 }

sources/CPU/Instructions/MathematicalOperations.cpp

@@ -7,7 +7,7 @@
 
 namespace ComSquare::CPU
 {
-	int CPU::ADC(uint24_t valueAddr)
+	int CPU::ADC(uint24_t valueAddr, AddressingMode mode)
 	{
 		unsigned value = this->_bus->read(valueAddr) + this->_registers.p.c;
 		if (!this->_registers.p.m)
@@ -25,10 +25,31 @@ namespace ComSquare::CPU
 			this->_registers.a %= 0x100;
 		this->_registers.p.z = this->_registers.a == 0;
 		this->_registers.p.n = this->_registers.a & negativeMask;
-		return 0;
+
+		int cycles = !this->_registers.p.m;
+		switch (mode) {
+		case DirectPage:
+		case DirectPageIndirect:
+		case DirectPageIndirectLong:
+		case DirectPageIndexedByX:
+		case DirectPageIndirectIndexedByX:
+		case DirectPageIndirectIndexedByYLong:
+			cycles += this->_registers.dl != 0;
+			break;
+		case AbsoluteIndexedByX:
+		case AbsoluteIndexedByY:
+			cycles += this->_hasIndexCrossedPageBoundary;
+			break;
+		case DirectPageIndirectIndexedByY:
+			cycles += this->_registers.dl != 0 + this->_hasIndexCrossedPageBoundary;
+			break;
+		default:
+			break;
+		}
+		return cycles;
 	}
 
-	int CPU::SBC(uint24_t valueAddr)
+	int CPU::SBC(uint24_t valueAddr, AddressingMode mode)
 	{
 		unsigned negativeMask = this->_isEmulationMode ? 0x80u : 0x8000u;
 		unsigned value = this->_bus->read(valueAddr);
@@ -46,6 +67,27 @@ namespace ComSquare::CPU
 			this->_registers.a %= 0x100;
 		this->_registers.p.z = this->_registers.a == 0;
 		this->_registers.p.n = this->_registers.a & negativeMask;
-		return 0;
+
+		int cycles = !this->_registers.p.m;
+		switch (mode) {
+		case DirectPage:
+		case DirectPageIndirect:
+		case DirectPageIndirectLong:
+		case DirectPageIndexedByX:
+		case DirectPageIndirectIndexedByX:
+		case DirectPageIndirectIndexedByYLong:
+			cycles += this->_registers.dl != 0;
+			break;
+		case AbsoluteIndexedByX:
+		case AbsoluteIndexedByY:
+			cycles += this->_hasIndexCrossedPageBoundary;
+			break;
+		case DirectPageIndirectIndexedByY:
+			cycles += this->_registers.dl != 0 + this->_hasIndexCrossedPageBoundary;
+			break;
+		default:
+			break;
+		}
+		return cycles;
 	}
 }

sources/CPU/Instructions/MemoryInstructions.cpp

@@ -6,7 +6,7 @@
 
 namespace ComSquare::CPU
 {
-	int CPU::STA(uint24_t addr)
+	int CPU::STA(uint24_t addr, AddressingMode mode)
 	{
 		if (this->_registers.p.m)
 			this->_bus->write(addr, this->_registers.al);
@@ -14,10 +14,24 @@ namespace ComSquare::CPU
 			this->_bus->write(addr, this->_registers.al);
 			this->_bus->write(addr + 1, this->_registers.ah);
 		}
-		return 0;
+
+		int cycles = !this->_registers.p.m;
+		switch (mode) {
+		case DirectPage:
+		case DirectPageIndirect:
+		case DirectPageIndirectLong:
+		case DirectPageIndexedByX:
+		case DirectPageIndirectIndexedByX:
+		case DirectPageIndirectIndexedByY:
+		case DirectPageIndirectIndexedByYLong:
+			cycles += this->_registers.dl != 0;
+		default:
+			break;
+		}
+		return cycles;
 	}
 
-	int CPU::STX(uint24_t addr)
+	int CPU::STX(uint24_t addr, AddressingMode mode)
 	{
 		if (this->_registers.p.x_b)
 			this->_bus->write(addr, this->_registers.xl);
@@ -25,10 +39,10 @@ namespace ComSquare::CPU
 			this->_bus->write(addr, this->_registers.xl);
 			this->_bus->write(addr + 1, this->_registers.xh);
 		}
-		return 0;
+		return !this->_registers.p.x_b + (mode != Absolute && this->_registers.dl != 0);
 	}
 
-	int CPU::STY(uint24_t addr)
+	int CPU::STY(uint24_t addr, AddressingMode mode)
 	{
 		if (this->_registers.p.x_b)
 			this->_bus->write(addr, this->_registers.yl);
@@ -36,18 +50,20 @@ namespace ComSquare::CPU
 			this->_bus->write(addr, this->_registers.yl);
 			this->_bus->write(addr + 1, this->_registers.yh);
 		}
-		return 0;
+		return !this->_registers.p.x_b + (mode != Absolute && this->_registers.dl != 0);
 	}
 
-	int CPU::STZ(uint24_t addr)
+	int CPU::STZ(uint24_t addr, AddressingMode mode)
 	{
 		this->_bus->write(addr, 0x00);
 		if (!this->_registers.p.m)
 			this->_bus->write(addr + 1, 0x00);
-		return 0;
+		if (mode == Absolute || mode == AbsoluteIndexedByX)
+			return !this->_registers.p.m;
+		return !this->_registers.p.m + this->_registers.dl != 0;
 	}
 
-	int CPU::LDA(uint24_t addr)
+	int CPU::LDA(uint24_t addr, AddressingMode mode)
 	{
 		if (this->_registers.p.m) {
 			this->_registers.a = this->_bus->read(addr);
@@ -58,10 +74,31 @@ namespace ComSquare::CPU
 			this->_registers.p.n = this->_registers.a & 0xF000u;
 		}
 		this->_registers.p.z = this->_registers.a == 0x0;
-		return 0;
+
+		int cycles = !this->_registers.p.m;
+		switch (mode) {
+		case DirectPage:
+		case DirectPageIndirect:
+		case DirectPageIndirectLong:
+		case DirectPageIndexedByX:
+		case DirectPageIndirectIndexedByX:
+		case DirectPageIndirectIndexedByYLong:
+			cycles += this->_registers.dl != 0;
+			break;
+		case AbsoluteIndexedByX:
+		case AbsoluteIndexedByY:
+			cycles += this->_hasIndexCrossedPageBoundary;
+			break;
+		case DirectPageIndirectIndexedByY:
+			cycles += this->_registers.dl != 0 + this->_hasIndexCrossedPageBoundary;
+			break;
+		default:
+			break;
+		}
+		return cycles;
 	}
 
-	int CPU::LDX(uint24_t addr)
+	int CPU::LDX(uint24_t addr, AddressingMode mode)
 	{
 		if (this->_registers.p.x_b) {
 			this->_registers.x = this->_bus->read(addr);
@@ -72,10 +109,23 @@ namespace ComSquare::CPU
 			this->_registers.p.n = this->_registers.x & 0xF000u;
 		}
 		this->_registers.p.z = this->_registers.x == 0x0;
-		return 0;
+
+		int cycles = !this->_registers.p.x_b;
+		switch (mode) {
+		case DirectPage:
+		case DirectPageIndexedByY:
+			cycles += this->_registers.dl != 0;
+			break;
+		case AbsoluteIndexedByY:
+			cycles += this->_hasIndexCrossedPageBoundary;
+			break;
+		default:
+			break;
+		}
+		return cycles;
 	}
 
-	int CPU::LDY(uint24_t addr)
+	int CPU::LDY(uint24_t addr, AddressingMode mode)
 	{
 		if (this->_registers.p.x_b) {
 			this->_registers.y = this->_bus->read(addr);
@@ -86,6 +136,19 @@ namespace ComSquare::CPU
 			this->_registers.p.n = this->_registers.y & 0xF000u;
 		}
 		this->_registers.p.z = this->_registers.y == 0x0;
-		return 0;
+
+		int cycles = !this->_registers.p.x_b;
+		switch (mode) {
+		case DirectPage:
+		case DirectPageIndexedByY:
+			cycles += this->_registers.dl != 0;
+			break;
+		case AbsoluteIndexedByY:
+			cycles += this->_hasIndexCrossedPageBoundary;
+			break;
+		default:
+			break;
+		}
+		return cycles;
 	}
 }

sources/CPU/Instructions/TransferRegisters.cpp

@@ -6,7 +6,7 @@
 
 namespace ComSquare::CPU
 {
-	int CPU::TAX(uint24_t)
+	int CPU::TAX(uint24_t, AddressingMode)
 	{
 		if (this->_registers.p.x_b) {
 			this->_registers.xl = this->_registers.al;
@@ -20,7 +20,7 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::TAY(uint24_t)
+	int CPU::TAY(uint24_t, AddressingMode)
 	{
 		if (this->_registers.p.x_b) {
 			this->_registers.yl = this->_registers.al;
@@ -34,7 +34,7 @@ namespace ComSquare::CPU
 		return 0;
 	}
 
-	int CPU::TXS(uint24_t)
+	int CPU::TXS(uint24_t, AddressingMode)
 	{
 		if (this->_registers.p.x_b) {
 			this->_registers.sh = 0;

sources/Debugger/CPUDebug.cpp

@@ -344,7 +344,7 @@ namespace ComSquare::Debugger
 		return ss.str();
 	}
 
-	int CPUDebug::RESB(uint24_t)
+	int CPUDebug::RESB()
 	{
 		CPU::RESB();
 		this->_updateRegistersPanel();

sources/Debugger/CPUDebug.hpp

@@ -170,7 +170,7 @@ namespace ComSquare::Debugger
 		//! @brief Return the current program counter of this CPU.
 		uint24_t getPC();
 		//! @brief Update the UI when resetting the CPU.
-		int RESB(uint24_t) override;
+		int RESB() override;
 		//! @brief Convert a basic CPU to a debugging CPU.
 		explicit CPUDebug(ComSquare::CPU::CPU &cpu, SNES &snes);
 		CPUDebug(const CPUDebug &) = delete;

tests/CPU/Math/testADC.cpp

@@ -14,7 +14,7 @@ Test(ADC, addingOne)
 	snes.cpu->_isEmulationMode = false;
 	snes.cpu->_registers.a = 0;
 	snes.wram->_data[0] = 0x1;
-	snes.cpu->ADC(0x0);
+	snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 1, "The accumulator's value should be 0x1 but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set.");
@@ -28,7 +28,7 @@ Test(ADC, addingOneEmulation)
 	snes.cpu->_isEmulationMode = true;
 	snes.cpu->_registers.a = 0;
 	snes.wram->_data[0] = 0x1;
-	snes.cpu->ADC(0x0);
+	snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 1, "The accumulator's value should be 0x1 but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set.");
@@ -42,7 +42,7 @@ Test(ADC, overflow)
 	snes.cpu->_isEmulationMode = false;
 	snes.cpu->_registers.a = 0xFFFF;
 	snes.wram->_data[0] = 0x1;
-	snes.cpu->ADC(0x0);
+	snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0, "The accumulator's value should be 0x0 but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flags should be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set.");
@@ -56,7 +56,7 @@ Test(ADC, overflowEmulation)
 	snes.cpu->_isEmulationMode = true;
 	snes.cpu->_registers.a = 0xFF;
 	snes.wram->_data[0] = 0x1;
-	snes.cpu->ADC(0x0);
+	snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0, "The accumulator's value should be 0x0 but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flags should be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set.");
@@ -70,7 +70,7 @@ Test(ADC, signedOverflow)
 	snes.cpu->_isEmulationMode = false;
 	snes.cpu->_registers.a = 0x7FFF;
 	snes.wram->_data[0] = 0x1;
-	snes.cpu->ADC(0x0);
+	snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0x8000, "The accumulator's value should be 0x8000 but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, true, "The overflow flags should be set.");
@@ -84,7 +84,7 @@ Test(ADC, signedOverflowEmulated)
 	snes.cpu->_isEmulationMode = true;
 	snes.cpu->_registers.a = 0x007F;
 	snes.wram->_data[0] = 0x1;
-	snes.cpu->ADC(0x0);
+	snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0x0080, "The accumulator's value should be 0x0080 but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, true, "The overflow flags should be set.");
@@ -98,7 +98,7 @@ Test(ADC, negative)
 	snes.cpu->_isEmulationMode = false;
 	snes.cpu->_registers.a = 0x8FFF;
 	snes.wram->_data[0] = 0x1;
-	snes.cpu->ADC(0x0);
+	snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0x9000, "The accumulator's value should be 0x9000 but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should be set.");
@@ -114,7 +114,7 @@ Test(ADC, memoryTwoBytes)
 	snes.cpu->_registers.a = 0x000F;
 	snes.wram->_data[0] = 0x01;
 	snes.wram->_data[1] = 0x04;
-	snes.cpu->ADC(0x0);
+	snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0x0410, "The accumulator's value should be 0x0410 but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set.");

tests/CPU/Math/testSBC.cpp

@@ -15,7 +15,7 @@ Test(SBC, removingOne)
 	snes.cpu->_registers.p.c = true;
 	snes.cpu->_registers.a = 0x1;
 	snes.wram->_data[0] = 0x1;
-	snes.cpu->SBC(0x0);
+	snes.cpu->SBC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0, "The accumulator's value should be 0x0 but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flags should be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set.");
@@ -32,7 +32,7 @@ Test(SBC, legitOverflowWithCarry)
 	snes.cpu->_registers.p.c = true;
 	snes.wram->_data[0] = 0x03;
 	snes.wram->_data[1] = 0x20;
-	snes.cpu->SBC(0x0);
+	snes.cpu->SBC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0xDFFE, "The accumulator's value should be 0xDFFE but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set.");
@@ -49,7 +49,7 @@ Test(SBC, overflowWithCarry)
 	snes.cpu->_registers.p.c = true;
 	snes.wram->_data[0] = 0x03;
 	snes.wram->_data[1] = 0x20;
-	snes.cpu->SBC(0x0);
+	snes.cpu->SBC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0xDFFE, "The accumulator's value should be 0xDFFE but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should be not set.");
@@ -65,7 +65,7 @@ Test(SBC, overflowEmulation)
 	snes.cpu->_registers.p.m = false;
 	snes.cpu->_registers.p.c = false;
 	snes.wram->_data[0] = 0x02;
-	snes.cpu->SBC(0x0);
+	snes.cpu->SBC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0xFE, "The accumulator's value should be 0xFE but it was 0x%x.", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set.");
@@ -83,7 +83,7 @@ Test(SBC, overflowEmulation)
 //	snes.cpu->_registers.p.m = false;
 //	snes.wram->_data[0] = 0x03;
 //	snes.wram->_data[1] = 0x20;
-//	snes.cpu->SBC(0x0);
+//	snes.cpu->SBC(0x0, ComSquare::CPU::AddressingMode::Implied);
 //	cr_assert_eq(snes.cpu->_registers.a, 0x7998, "The accumulator's value should be 0x7998 but it was 0x%x.", snes.cpu->_registers.a);
 //	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set.");
 //	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set.");

tests/CPU/TransferRegisters.cpp

@@ -17,7 +17,7 @@ Test(TAX, 16bitsTo16Bits)
 	snes.cpu->_registers.p.m = false;
 	snes.cpu->_registers.x = 0xABCD;
 	snes.cpu->_registers.a = 0xFEDC;
-	snes.cpu->TAX(0x0);
+	snes.cpu->TAX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.x, 0xFEDC, "The flags should be 0xFEDC but it was %x", snes.cpu->_registers.x);
 	cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
@@ -31,7 +31,7 @@ Test(TAX, 16bitsTo8Bits)
 	snes.cpu->_registers.p.m = false;
 	snes.cpu->_registers.x = 0xFEDC;
 	snes.cpu->_registers.a = 0xAB00;
-	snes.cpu->TAX(0x0);
+	snes.cpu->TAX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.x, 0xFE00, "The flags should be 0xFE00 but it was %x", snes.cpu->_registers.x);
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.");
@@ -45,7 +45,7 @@ Test(TAX, 8bitsTo16Bits)
 	snes.cpu->_registers.p.m = true;
 	snes.cpu->_registers.x = 0xFEDC;
 	snes.cpu->_registers.a = 0xAB;
-	snes.cpu->TAX(0x0);
+	snes.cpu->TAX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.x, 0x00AB, "The flags should be 0x00AB but it was %x", snes.cpu->_registers.x);
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
@@ -59,7 +59,7 @@ Test(TAX, 8bitsTo8Bits)
 	snes.cpu->_registers.p.m = true;
 	snes.cpu->_registers.x = 0xFE;
 	snes.cpu->_registers.a = 0xAB;
-	snes.cpu->TAX(0x0);
+	snes.cpu->TAX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.x, 0xAB, "The flags should be 0xAB but it was %x", snes.cpu->_registers.x);
 	cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set.");
@@ -74,7 +74,7 @@ Test(TAY, 16bitsTo16Bits)
 	snes.cpu->_registers.p.m = false;
 	snes.cpu->_registers.y = 0xABCD;
 	snes.cpu->_registers.a = 0xFEDC;
-	snes.cpu->TAY(0x0);
+	snes.cpu->TAY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.y, 0xFEDC, "The y register should be 0xFEDC but it was %x", snes.cpu->_registers.y);
 	cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
@@ -88,7 +88,7 @@ Test(TAY, 16bitsTo8Bits)
 	snes.cpu->_registers.p.m = false;
 	snes.cpu->_registers.y = 0xFEDC;
 	snes.cpu->_registers.a = 0xAB00;
-	snes.cpu->TAY(0x0);
+	snes.cpu->TAY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.y, 0xFE00, "The y register should be 0xFE00 but it was %x", snes.cpu->_registers.y);
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.");
@@ -102,7 +102,7 @@ Test(TAY, 8bitsTo16Bits)
 	snes.cpu->_registers.p.m = true;
 	snes.cpu->_registers.y = 0xFEDC;
 	snes.cpu->_registers.a = 0xAB;
-	snes.cpu->TAY(0x0);
+	snes.cpu->TAY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.y, 0x00AB, "The y register should be 0x00AB but it was %x", snes.cpu->_registers.y);
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
@@ -116,7 +116,7 @@ Test(TAY, 8bitsTo8Bits)
 	snes.cpu->_registers.p.m = true;
 	snes.cpu->_registers.y = 0xFE;
 	snes.cpu->_registers.a = 0xAB;
-	snes.cpu->TAY(0x0);
+	snes.cpu->TAY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.y, 0xAB, "The y register should be 0xAB but it was %x", snes.cpu->_registers.y);
 	cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set.");
@@ -128,7 +128,7 @@ Test(TXS, 16bitsIndex)
 	snes.cpu->_isEmulationMode = false;
 	snes.cpu->_registers.p.x_b = false;
 	snes.cpu->_registers.x = 0xABCD;
-	snes.cpu->TXS(0x0);
+	snes.cpu->TXS(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.s, 0xABCD, "The stack pointer should be 0xABCD but it was %x", snes.cpu->_registers.s);
 	cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set.");
@@ -140,7 +140,7 @@ Test(TXS, 8bitsIndex)
 	snes.cpu->_isEmulationMode = false;
 	snes.cpu->_registers.p.x_b = true;
 	snes.cpu->_registers.x = 0xABCD;
-	snes.cpu->TXS(0x0);
+	snes.cpu->TXS(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.s, 0x00CD, "The stack pointer should be 0x00CD but it was %x", snes.cpu->_registers.s);
 	cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set.");

tests/CPU/testBits.cpp

@@ -15,7 +15,7 @@ Test(AND, emulation)
 	snes.wram->_data[0] = 0x00;
 	snes.cpu->_registers.a = 0xFF;
 	snes.cpu->_isEmulationMode = true;
-	snes.cpu->AND(0x0);
+	snes.cpu->AND(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0x00, "The flags should be 0x00 but it was %x", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.");
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");
@@ -29,7 +29,7 @@ Test(AND, nativeNegative)
 	snes.cpu->_registers.p.m = false;
 	snes.cpu->_registers.a = 0xFF00;
 	snes.cpu->_isEmulationMode = false;
-	snes.cpu->AND(0x0);
+	snes.cpu->AND(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0xF000, "The flags should be 0xF000 but it was %x", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set.");
@@ -42,7 +42,7 @@ Test(AND, emulationTest)
 	snes.wram->_data[0] = 0b00110011;
 	snes.cpu->_registers.a = 0b00110111;
 	snes.cpu->_isEmulationMode = true;
-	snes.cpu->AND(0x0);
+	snes.cpu->AND(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.a, 0b00110011, "The flags should be 0b00110011 but it was %x", snes.cpu->_registers.a);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.");
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set.");

tests/CPU/testInternal.cpp

@@ -16,7 +16,7 @@ Test(SEP, setall)
 {
 	Init()
 	snes.wram->_data[0] = 0xFF;
-	snes.cpu->SEP(0x00);
+	snes.cpu->SEP(0x00, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.p.flags;
 	cr_assert_eq(data, 0xFF, "The flag should be 0xFF but it was %x", data);
 }
@@ -26,7 +26,7 @@ Test(SEP, setsome)
 	Init()
 	snes.cpu->_registers.p.flags = 0b01000000;
 	snes.wram->_data[0] = 0b10110101;
-	snes.cpu->SEP(0x0);
+	snes.cpu->SEP(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.p.flags;
 	cr_assert_eq(data, 0b11110101, "The flag should be 245 but it was %i", data);
 }
@@ -36,7 +36,7 @@ Test(REP, resetall)
 	Init()
 	snes.cpu->_isEmulationMode = false;
 	snes.wram->_data[0] = 0xFF;
-	snes.cpu->REP(0x00);
+	snes.cpu->REP(0x00, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.p.flags;
 	cr_assert_eq(data, 0x00, "The flag should be 0x00 but it was %x", data);
 }
@@ -47,7 +47,7 @@ Test(REP, resetsome)
 	snes.cpu->_isEmulationMode = false;
 	snes.cpu->_registers.p.flags = 0b01000000;
 	snes.wram->_data[0] = 0b01000000;
-	snes.cpu->REP(0x0);
+	snes.cpu->REP(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.p.flags;
 	cr_assert_eq(data, 0x0, "The flag should be 0 but it was %x", data);
 }
@@ -57,7 +57,7 @@ Test(REP, resetallEmulation)
 	Init()
 	snes.cpu->_isEmulationMode = true;
 	snes.wram->_data[0] = 0xFF;
-	snes.cpu->REP(0x00);
+	snes.cpu->REP(0x00, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.p.flags;
 	cr_assert_eq(data, 0b00110000, "The flag should be 0b00110000 but it was %x", data);
 }
@@ -68,7 +68,7 @@ Test(REP, resetsomeEmulation)
 	snes.cpu->_isEmulationMode = true;
 	snes.cpu->_registers.p.flags = 0b01000101;
 	snes.wram->_data[0] = 0b01000001;
-	snes.cpu->REP(0x0);
+	snes.cpu->REP(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.p.flags;
 	cr_assert_eq(data, 0b00110100, "The flag should be 0b00110100 but it was %x", data);
 }
@@ -78,7 +78,7 @@ Test(JSR, jump)
 	Init()
 	snes.cpu->_registers.pc = 0xABCD;
 	snes.cpu->_registers.s = 0x0123;
-	snes.cpu->JSR(0xABFF);
+	snes.cpu->JSR(0xABFF, ComSquare::CPU::AddressingMode::Implied);
 	auto pc = snes.cpu->_registers.pc;
 	cr_assert_eq(pc, 0xABFF, "The PC should be 0xABFF but it was %x", pc);
 	cr_assert_eq(snes.cpu->_registers.s, 0x0121, "The stack pointer should be 0x0121 but it was %x", snes.cpu->_registers.s);
@@ -92,7 +92,7 @@ Test(JSL, jump)
 	snes.cpu->_registers.pbr = 0xFF;
 	snes.cpu->_registers.pc = 0xABCD;
 	snes.cpu->_registers.s = 0x0123;
-	snes.cpu->JSL(0xCDABFF);
+	snes.cpu->JSL(0xCDABFF, ComSquare::CPU::AddressingMode::Implied);
 	auto pac = snes.cpu->_registers.pac;
 	cr_assert_eq(pac, 0xCDABFF, "The PC should be 0xCDABFF but it was %x", pac);
 	cr_assert_eq(snes.cpu->_registers.s, 0x0120, "The stack pointer should be 0x0120 but it was %x", snes.cpu->_registers.s);
@@ -105,7 +105,7 @@ Test(PHA, basic)
 	Init()
 	snes.cpu->_registers.a = 0xABCD;
 	snes.cpu->_registers.s = 0x02;
-	snes.cpu->PHA(0x0);
+	snes.cpu->PHA(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.wram->_data[1], 0xCD, "The second value pushed to the stack should be 0xCD but it was %x", snes.wram->_data[1]);
 	cr_assert_eq(snes.wram->_data[2], 0xAB, "The first value pushed to the stack should be 0xAB but it was %x", snes.wram->_data[2]);
 	cr_assert_eq(snes.cpu->_registers.s, 0x0, "The Stack pointer should be equal to 0x0 but it was %x", snes.cpu->_registers.s);
@@ -116,7 +116,7 @@ Test(PHB, basic)
 	Init()
 	snes.cpu->_registers.dbr = 0xFF;
 	snes.cpu->_registers.s = 0x02;
-	snes.cpu->PHB(0x0);
+	snes.cpu->PHB(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.wram->_data[2], 0xFF, "The first value pushed to the stack should be 0xFF but it was %x", snes.wram->_data[2]);
 	cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s);
 }
@@ -126,7 +126,7 @@ Test(PHD, basic)
 	Init()
 	snes.cpu->_registers.d = 0xABCD;
 	snes.cpu->_registers.s = 0x02;
-	snes.cpu->PHD(0x0);
+	snes.cpu->PHD(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.wram->_data[1], 0xCD, "The second value pushed to the stack should be 0xCD but it was %x", snes.wram->_data[1]);
 	cr_assert_eq(snes.wram->_data[2], 0xAB, "The first value pushed to the stack should be 0xAB but it was %x", snes.wram->_data[2]);
 	cr_assert_eq(snes.cpu->_registers.s, 0x0, "The Stack pointer should be equal to 0x0 but it was %x", snes.cpu->_registers.s);
@@ -137,7 +137,7 @@ Test(PHK, basic)
 	Init()
 	snes.cpu->_registers.pbr = 0xFF;
 	snes.cpu->_registers.s = 0x02;
-	snes.cpu->PHK(0x0);
+	snes.cpu->PHK(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.wram->_data[2], 0xFF, "The first value pushed to the stack should be 0xFF but it was %x", snes.wram->_data[2]);
 	cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s);
 }
@@ -147,7 +147,7 @@ Test(PHP, basic)
 	Init()
 	snes.cpu->_registers.p.flags = 0xFF;
 	snes.cpu->_registers.s = 0x02;
-	snes.cpu->PHP(0x0);
+	snes.cpu->PHP(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.wram->_data[2], 0xFF, "The first value pushed to the stack should be 0xFF but it was %x", snes.wram->_data[2]);
 	cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s);
 }
@@ -157,7 +157,7 @@ Test(PHX, basic)
 	Init()
 	snes.cpu->_registers.x = 0xABCD;
 	snes.cpu->_registers.s = 0x02;
-	snes.cpu->PHX(0x0);
+	snes.cpu->PHX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.wram->_data[1], 0xCD, "The second value pushed to the stack should be 0xCD but it was %x", snes.wram->_data[1]);
 	cr_assert_eq(snes.wram->_data[2], 0xAB, "The first value pushed to the stack should be 0xAB but it was %x", snes.wram->_data[2]);
 	cr_assert_eq(snes.cpu->_registers.s, 0x0, "The Stack pointer should be equal to 0x0 but it was %x", snes.cpu->_registers.s);
@@ -168,7 +168,7 @@ Test(PHY, basic)
 	Init()
 	snes.cpu->_registers.y = 0xABCD;
 	snes.cpu->_registers.s = 0x02;
-	snes.cpu->PHY(0x0);
+	snes.cpu->PHY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.wram->_data[1], 0xCD, "The second value pushed to the stack should be 0xCD but it was %x", snes.wram->_data[1]);
 	cr_assert_eq(snes.wram->_data[2], 0xAB, "The first value pushed to the stack should be 0xAB but it was %x", snes.wram->_data[2]);
 	cr_assert_eq(snes.cpu->_registers.s, 0x0, "The Stack pointer should be equal to 0x0 but it was %x", snes.cpu->_registers.s);
@@ -180,7 +180,8 @@ Test(PLA, basic)
 	snes.wram->_data[1] = 0xCD;
 	snes.wram->_data[2] = 0x7B;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLA(0x0);
+	snes.cpu->_registers.p.m = false;
+	snes.cpu->PLA(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.a;
 	cr_assert_eq(data, 0x7BCD, "The accumulator should be 0x7BCD but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.", snes.cpu->_registers.p.z);
@@ -194,7 +195,8 @@ Test(PLA, zero)
 	snes.wram->_data[1] = 0x00;
 	snes.wram->_data[2] = 0x00;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLA(0x0);
+	snes.cpu->_registers.p.m = false;
+	snes.cpu->PLA(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.a;
 	cr_assert_eq(data, 0x0000, "The accumulator should be 0x0000 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.", snes.cpu->_registers.p.z);
@@ -208,7 +210,8 @@ Test(PLA, negative)
 	snes.wram->_data[1] = 0x00;
 	snes.wram->_data[2] = 0xA0;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLA(0x0);
+	snes.cpu->_registers.p.m = false;
+	snes.cpu->PLA(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.a;
 	cr_assert_eq(data, 0xA000, "The accumulator should be 0xA000 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.", snes.cpu->_registers.p.z);
@@ -222,7 +225,8 @@ Test(PLX, basic)
 	snes.wram->_data[1] = 0xCD;
 	snes.wram->_data[2] = 0x7B;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLX(0x0);
+	snes.cpu->_registers.p.x_b = false;
+	snes.cpu->PLX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.x;
 	cr_assert_eq(data, 0x7BCD, "The X register should be 0x7BCD but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.", snes.cpu->_registers.p.z);
@@ -236,7 +240,8 @@ Test(PLX, zero)
 	snes.wram->_data[1] = 0x00;
 	snes.wram->_data[2] = 0x00;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLX(0x0);
+	snes.cpu->_registers.p.x_b = false;
+	snes.cpu->PLX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.x;
 	cr_assert_eq(data, 0x0000, "The x register should be 0x0000 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.", snes.cpu->_registers.p.z);
@@ -250,7 +255,8 @@ Test(PLX, negative)
 	snes.wram->_data[1] = 0x00;
 	snes.wram->_data[2] = 0xA0;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLX(0x0);
+	snes.cpu->_registers.p.x_b = false;
+	snes.cpu->PLX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.x;
 	cr_assert_eq(data, 0xA000, "The x register should be 0xA000 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.", snes.cpu->_registers.p.z);
@@ -264,7 +270,8 @@ Test(PLY, basic)
 	snes.wram->_data[1] = 0xCD;
 	snes.wram->_data[2] = 0x7B;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLY(0x0);
+	snes.cpu->_registers.p.x_b = false;
+	snes.cpu->PLY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.y;
 	cr_assert_eq(data, 0x7BCD, "The Y register should be 0x7BCD but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.", snes.cpu->_registers.p.z);
@@ -278,7 +285,8 @@ Test(PLY, zero)
 	snes.wram->_data[1] = 0x00;
 	snes.wram->_data[2] = 0x00;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLY(0x0);
+	snes.cpu->_registers.p.x_b = false;
+	snes.cpu->PLY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.y;
 	cr_assert_eq(data, 0x0000, "The y register should be 0x0000 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.", snes.cpu->_registers.p.z);
@@ -292,7 +300,8 @@ Test(PLY, negative)
 	snes.wram->_data[1] = 0x00;
 	snes.wram->_data[2] = 0xA0;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLY(0x0);
+	snes.cpu->_registers.p.x_b = false;
+	snes.cpu->PLY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.y;
 	cr_assert_eq(data, 0xA000, "The y register should be 0xA000 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.", snes.cpu->_registers.p.z);
@@ -306,7 +315,7 @@ Test(PLD, basic)
 	snes.wram->_data[1] = 0xCD;
 	snes.wram->_data[2] = 0x7B;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLD(0x0);
+	snes.cpu->PLD(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.d;
 	cr_assert_eq(data, 0x7BCD, "The D register should be 0x7BCD but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.", snes.cpu->_registers.p.z);
@@ -320,7 +329,7 @@ Test(PLD, zero)
 	snes.wram->_data[1] = 0x00;
 	snes.wram->_data[2] = 0x00;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLD(0x0);
+	snes.cpu->PLD(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.d;
 	cr_assert_eq(data, 0x0000, "The d register should be 0x0000 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.", snes.cpu->_registers.p.z);
@@ -334,7 +343,7 @@ Test(PLD, negative)
 	snes.wram->_data[1] = 0x00;
 	snes.wram->_data[2] = 0xA0;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLD(0x0);
+	snes.cpu->PLD(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.d;
 	cr_assert_eq(data, 0xA000, "The D register should be 0xA000 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.", snes.cpu->_registers.p.z);
@@ -347,7 +356,7 @@ Test(PLB, basic)
 	Init()
 	snes.wram->_data[1] = 0x7D;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLB(0x0);
+	snes.cpu->PLB(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.dbr;
 	cr_assert_eq(data, 0x7D, "The DBR should be 0x7D but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set.", snes.cpu->_registers.p.z);
@@ -360,7 +369,7 @@ Test(PLB, zero)
 	Init()
 	snes.wram->_data[1] = 0x00;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLB(0x0);
+	snes.cpu->PLB(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.dbr;
 	cr_assert_eq(data, 0x00, "The dbr should be 0x00 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set.", snes.cpu->_registers.p.z);
@@ -373,7 +382,7 @@ Test(PLB, negative)
 	Init()
 	snes.wram->_data[1] = 0xA0;
 	snes.cpu->_registers.s = 0x00;
-	snes.cpu->PLB(0x0);
+	snes.cpu->PLB(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.dbr;
 	cr_assert_eq(data, 0xA0, "The D register should be 0xA0 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set.", snes.cpu->_registers.p.z);
@@ -387,7 +396,7 @@ Test(PLP, basic)
 	snes.wram->_data[1] = 0x7D;
 	snes.cpu->_registers.s = 0x00;
 	snes.cpu->_isEmulationMode = false;
-	snes.cpu->PLP(0x0);
+	snes.cpu->PLP(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.p.flags;
 	cr_assert_eq(data, 0x7D, "The flags should be 0x7D but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s);
@@ -399,7 +408,7 @@ Test(PLP, emulation)
 	snes.wram->_data[1] = 0x00;
 	snes.cpu->_registers.s = 0x00;
 	snes.cpu->_isEmulationMode = true;
-	snes.cpu->PLP(0x0);
+	snes.cpu->PLP(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.p.flags;
 	cr_assert_eq(data, 0b00110000, "The flags should be 0b00110000 but it was %x", data);
 	cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s);
@@ -409,7 +418,7 @@ Test(CLC, clear)
 {
 	Init()
 	snes.cpu->_registers.p.flags = 0xFF;
-	snes.cpu->CLC(0x0);
+	snes.cpu->CLC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set");
 }
 
@@ -417,7 +426,7 @@ Test(CLI, clear)
 {
 	Init()
 	snes.cpu->_registers.p.flags = 0xFF;
-	snes.cpu->CLI(0x0);
+	snes.cpu->CLI(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.i, false, "The interrupt flag should not be set");
 }
 
@@ -425,7 +434,7 @@ Test(CLD, clear)
 {
 	Init()
 	snes.cpu->_registers.p.flags = 0xFF;
-	snes.cpu->CLD(0x0);
+	snes.cpu->CLD(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.d, false, "The decimal flag should not be set");
 }
 
@@ -433,7 +442,7 @@ Test(CLV, clear)
 {
 	Init()
 	snes.cpu->_registers.p.flags = 0xFF;
-	snes.cpu->CLV(0x0);
+	snes.cpu->CLV(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flag should not be set");
 }
 
@@ -441,7 +450,7 @@ Test(SEC, set)
 {
 	Init()
 	snes.cpu->_registers.p.flags = 0x00;
-	snes.cpu->SEC(0x0);
+	snes.cpu->SEC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set");
 }
 
@@ -449,7 +458,7 @@ Test(SEI, set)
 {
 	Init()
 	snes.cpu->_registers.p.flags = 0x00;
-	snes.cpu->SEI(0x0);
+	snes.cpu->SEI(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.i, true, "The interrupt disabled flag should be set");
 }
 
@@ -457,7 +466,7 @@ Test(SED, set)
 {
 	Init()
 	snes.cpu->_registers.p.flags = 0x00;
-	snes.cpu->SED(0x0);
+	snes.cpu->SED(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.d, true, "The decimal flag should be set");
 }
 
@@ -469,7 +478,7 @@ Test(XCE, enableEmulation)
 	snes.cpu->_registers.p.c = true;
 	snes.cpu->_registers.xh = 0xFF;
 	snes.cpu->_registers.yh = 0xFF;
-	snes.cpu->XCE(0x0);
+	snes.cpu->XCE(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_isEmulationMode, true, "The e flag should be set");
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set");
 	cr_assert_eq(snes.cpu->_registers.p.m, false, "The memory width flag should be untouched (unset)");
@@ -485,7 +494,7 @@ Test(XCE, enableNative)
 	snes.cpu->_registers.p.flags = 0;
 	snes.cpu->_registers.xh = 0xFF;
 	snes.cpu->_registers.yh = 0xFF;
-	snes.cpu->XCE(0x0);
+	snes.cpu->XCE(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_isEmulationMode, false, "The e flag should be not set");
 	cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set");
 	cr_assert_eq(snes.cpu->_registers.p.m, true, "The memory width flag should be set");
@@ -501,7 +510,7 @@ Test(INX, basic)
 	snes.cpu->_registers.p.flags = 0;
 	snes.cpu->_registers.p.x_b = false;
 	snes.cpu->_registers.x = 0xFF;
-	snes.cpu->INX(0x0);
+	snes.cpu->INX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.x, 0x0100, "The x register should be equal to 0x0100 but it was 0x%x.", snes.cpu->_registers.x);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set");
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set");
@@ -514,7 +523,7 @@ Test(INX, 8bits)
 	snes.cpu->_registers.p.flags = 0;
 	snes.cpu->_registers.p.x_b = true;
 	snes.cpu->_registers.x = 0xFF;
-	snes.cpu->INX(0x0);
+	snes.cpu->INX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.x, 0x00, "The x register should be equal to 0x00 but it was 0x%x.", snes.cpu->_registers.x);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set");
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set");
@@ -527,7 +536,7 @@ Test(INY, basic)
 	snes.cpu->_registers.p.flags = 0;
 	snes.cpu->_registers.p.x_b = false;
 	snes.cpu->_registers.y = 0xFF;
-	snes.cpu->INY(0x0);
+	snes.cpu->INY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.y, 0x0100, "The y register should be equal to 0x0100 but it was 0x%x.", snes.cpu->_registers.y);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set");
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set");
@@ -540,7 +549,7 @@ Test(INY, 8bits)
 	snes.cpu->_registers.p.flags = 0;
 	snes.cpu->_registers.p.x_b = true;
 	snes.cpu->_registers.y = 0xFF;
-	snes.cpu->INY(0x0);
+	snes.cpu->INY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.y, 0x00, "The y register should be equal to 0x00 but it was 0x%x.", snes.cpu->_registers.y);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set");
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set");
@@ -553,7 +562,7 @@ Test(CPX, basic)
 	snes.cpu->_registers.p.flags = 0;
 	snes.cpu->_registers.x = 0xFF;
 	snes.wram->_data[0] = 0xFF;
-	snes.cpu->CPX(0x0);
+	snes.cpu->CPX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set");
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set");
 	cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set");
@@ -566,7 +575,7 @@ Test(CPX, negative)
 	snes.cpu->_registers.p.flags = 0;
 	snes.cpu->_registers.x = 0x80;
 	snes.wram->_data[0] = 0xFF;
-	snes.cpu->CPX(0x0);
+	snes.cpu->CPX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set");
 	cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set");
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set");
@@ -580,7 +589,7 @@ Test(CPX, 16bits)
 	snes.cpu->_registers.x = 0x8888;
 	snes.wram->_data[0] = 0x88;
 	snes.wram->_data[1] = 0x98;
-	snes.cpu->CPX(0x0);
+	snes.cpu->CPX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set");
 	cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set");
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set");
@@ -593,7 +602,7 @@ Test(CPY, basic)
 	snes.cpu->_registers.p.flags = 0;
 	snes.cpu->_registers.y = 0xFF;
 	snes.wram->_data[0] = 0xFF;
-	snes.cpu->CPY(0x0);
+	snes.cpu->CPY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set");
 	cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set");
 	cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set");
@@ -606,7 +615,7 @@ Test(CPY, negative)
 	snes.cpu->_registers.p.flags = 0;
 	snes.cpu->_registers.y = 0x80;
 	snes.wram->_data[0] = 0xFF;
-	snes.cpu->CPY(0x0);
+	snes.cpu->CPY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set");
 	cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set");
 	cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set");
@@ -618,7 +627,7 @@ Test(BCC, basic)
 	snes.cpu->_registers.p.c = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x50;
-	snes.cpu->BCC(0x0);
+	snes.cpu->BCC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -628,7 +637,7 @@ Test(BCC, negativeJump)
 	snes.cpu->_registers.p.c = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0xF0;
-	snes.cpu->BCC(0x0);
+	snes.cpu->BCC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -638,7 +647,7 @@ Test(BCC, noJump)
 	snes.cpu->_registers.p.c = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x90;
-	snes.cpu->BCC(0x0);
+	snes.cpu->BCC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -648,7 +657,7 @@ Test(BCS, basic)
 	snes.cpu->_registers.p.c = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x50;
-	snes.cpu->BCS(0x0);
+	snes.cpu->BCS(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -658,7 +667,7 @@ Test(BCS, negativeJump)
 	snes.cpu->_registers.p.c = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0xF0;
-	snes.cpu->BCS(0x0);
+	snes.cpu->BCS(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -668,7 +677,7 @@ Test(BCS, noJump)
 	snes.cpu->_registers.p.c = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x90;
-	snes.cpu->BCS(0x0);
+	snes.cpu->BCS(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -678,7 +687,7 @@ Test(BEQ, basic)
 	snes.cpu->_registers.p.z = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x50;
-	snes.cpu->BEQ(0x0);
+	snes.cpu->BEQ(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -688,7 +697,7 @@ Test(BEQ, negativeJump)
 	snes.cpu->_registers.p.z = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0xF0;
-	snes.cpu->BEQ(0x0);
+	snes.cpu->BEQ(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -698,7 +707,7 @@ Test(BEQ, noJump)
 	snes.cpu->_registers.p.z = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x90;
-	snes.cpu->BEQ(0x0);
+	snes.cpu->BEQ(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -708,7 +717,7 @@ Test(BNE, basic)
 	snes.cpu->_registers.p.z = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x50;
-	snes.cpu->BNE(0x0);
+	snes.cpu->BNE(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -718,7 +727,7 @@ Test(BNE, negativeJump)
 	snes.cpu->_registers.p.z = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0xF0;
-	snes.cpu->BNE(0x0);
+	snes.cpu->BNE(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -728,7 +737,7 @@ Test(BNE, noJump)
 	snes.cpu->_registers.p.z = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x90;
-	snes.cpu->BNE(0x0);
+	snes.cpu->BNE(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -738,7 +747,7 @@ Test(BMI, basic)
 	snes.cpu->_registers.p.n = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x50;
-	snes.cpu->BMI(0x0);
+	snes.cpu->BMI(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -748,7 +757,7 @@ Test(BMI, negativeJump)
 	snes.cpu->_registers.p.n = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0xF0;
-	snes.cpu->BMI(0x0);
+	snes.cpu->BMI(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -758,7 +767,7 @@ Test(BMI, noJump)
 	snes.cpu->_registers.p.n = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x90;
-	snes.cpu->BMI(0x0);
+	snes.cpu->BMI(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -768,7 +777,7 @@ Test(BPL, basic)
 	snes.cpu->_registers.p.n = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x50;
-	snes.cpu->BPL(0x0);
+	snes.cpu->BPL(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -778,7 +787,7 @@ Test(BPL, negativeJump)
 	snes.cpu->_registers.p.n = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0xF0;
-	snes.cpu->BPL(0x0);
+	snes.cpu->BPL(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -788,7 +797,7 @@ Test(BPL, noJump)
 	snes.cpu->_registers.p.n = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x90;
-	snes.cpu->BPL(0x0);
+	snes.cpu->BPL(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -797,7 +806,7 @@ Test(BRA, basic)
 	Init()
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x50;
-	snes.cpu->BRA(0x0);
+	snes.cpu->BRA(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -806,7 +815,7 @@ Test(BRA, negativeJump)
 	Init()
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0xF0;
-	snes.cpu->BRA(0x0);
+	snes.cpu->BRA(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -816,7 +825,7 @@ Test(BRL, basic)
 	snes.cpu->_registers.pc = 0x8080;
 	snes.wram->_data[0] = 0x00;
 	snes.wram->_data[1] = 0x10;
-	snes.cpu->BRL(0x0);
+	snes.cpu->BRL(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x9080, "The program counter should be equal to 0x9080 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -826,7 +835,7 @@ Test(BRL, negativeJump)
 	snes.cpu->_registers.pc = 0x8080;
 	snes.wram->_data[0] = 0x00;
 	snes.wram->_data[1] = 0xF0;
-	snes.cpu->BRL(0x0);
+	snes.cpu->BRL(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x7080, "The program counter should be equal to 0x7080 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -836,7 +845,7 @@ Test(BVC, basic)
 	snes.cpu->_registers.p.v = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x50;
-	snes.cpu->BVC(0x0);
+	snes.cpu->BVC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -846,7 +855,7 @@ Test(BVC, negativeJump)
 	snes.cpu->_registers.p.v = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0xF0;
-	snes.cpu->BVC(0x0);
+	snes.cpu->BVC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -856,7 +865,7 @@ Test(BVC, noJump)
 	snes.cpu->_registers.p.v = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x90;
-	snes.cpu->BVC(0x0);
+	snes.cpu->BVC(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -867,7 +876,7 @@ Test(BVS, basic)
 	snes.cpu->_registers.p.v = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x50;
-	snes.cpu->BVS(0x0);
+	snes.cpu->BVS(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -877,7 +886,7 @@ Test(BVS, negativeJump)
 	snes.cpu->_registers.p.v = true;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0xF0;
-	snes.cpu->BVS(0x0);
+	snes.cpu->BVS(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -887,7 +896,7 @@ Test(BVS, noJump)
 	snes.cpu->_registers.p.v = false;
 	snes.cpu->_registers.pc = 0x80;
 	snes.wram->_data[0] = 0x90;
-	snes.cpu->BVS(0x0);
+	snes.cpu->BVS(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -895,7 +904,7 @@ Test(JMP, simpleJump)
 {
 	Init()
 	snes.cpu->_registers.pc = 0x8000;
-	snes.cpu->JMP(0x1000);
+	snes.cpu->JMP(0x1000, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x1000, "The program counter should be equal to 0x9000 but it was 0x%x.", snes.cpu->_registers.pc);
 }
 
@@ -903,6 +912,6 @@ Test(JML, simpleJump)
 {
 	Init()
 	snes.cpu->_registers.pc = 0x8000;
-	snes.cpu->JML(0x10AB00);
+	snes.cpu->JML(0x10AB00, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pac, 0x10AB00, "The program counter should be equal to 0x10AB00 but it was 0x%x.", snes.cpu->_registers.pac);
 }

tests/CPU/testInterupts.cpp

@@ -18,7 +18,7 @@ Test(CPU_emulated, BRK)
 	snes.cpu->_registers.p.flags = 0xF1;
 	snes.cpu->_registers.pc = 0x156u;
 	snes.cpu->_registers.pbr = 0x15;
-	snes.cpu->BRK(0x0);
+	snes.cpu->BRK(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x123u, "The program counter should be 0x123u but it was 0x%X", snes.cpu->_registers.pc);
 	cr_assert_eq(snes.cpu->_registers.pbr, 0x15, "The PBR should be 0x15 but it was 0x%X", snes.cpu->_registers.pbr);
 	cr_assert_eq(snes.cpu->_registers.p.d, false, "The decimal flag should not be set.");
@@ -38,7 +38,7 @@ Test(CPU_native, BRK)
 	snes.cpu->_registers.p.flags = 0xF1;
 	snes.cpu->_registers.pc = 0x156u;
 	snes.cpu->_registers.pbr = 0x15;
-	snes.cpu->BRK(0x0);
+	snes.cpu->BRK(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x123u, "The program counter should be 0x123u but it was 0x%X", snes.cpu->_registers.pc);
 	cr_assert_eq(snes.cpu->_registers.pbr, 0x0, "The PBR should be 0x0 but it was 0x%X", snes.cpu->_registers.pbr);
 	cr_assert_eq(snes.cpu->_registers.p.d, false, "The decimal flag should not be set.");
@@ -59,7 +59,7 @@ Test(CPU_emulated, COP)
 	snes.cpu->_registers.p.flags = 0x0F;
 	snes.cpu->_registers.pc = 0x156u;
 	snes.cpu->_registers.pbr = 0x15;
-	snes.cpu->COP(0x0);
+	snes.cpu->COP(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x123u, "The program counter should be 0x123u but it was 0x%X", snes.cpu->_registers.pc);
 	cr_assert_eq(snes.cpu->_registers.pbr, 0x15, "The PBR should be 0x15 but it was 0x%X", snes.cpu->_registers.pbr);
 	cr_assert_eq(snes.cpu->_registers.p.d, false, "The decimal flag should not be set.");
@@ -79,7 +79,7 @@ Test(CPU_native, COP)
 	snes.cpu->_registers.p.flags = 0xF1;
 	snes.cpu->_registers.pc = 0x156u;
 	snes.cpu->_registers.pbr = 0x15;
-	snes.cpu->COP(0x0);
+	snes.cpu->COP(0x0, ComSquare::CPU::AddressingMode::Implied);
 	cr_assert_eq(snes.cpu->_registers.pc, 0x123u, "The program counter should be 0x123u but it was 0x%X", snes.cpu->_registers.pc);
 	cr_assert_eq(snes.cpu->_registers.pbr, 0x0, "The PBR should be 0x0 but it was 0x%X", snes.cpu->_registers.pbr);
 	cr_assert_eq(snes.cpu->_registers.p.d, false, "The decimal flag should not be set.");

tests/CPU/testStore.cpp

@@ -14,7 +14,7 @@ Test(STA, 8bits)
 	Init()
 	snes.cpu->_registers.p.m = true;
 	snes.cpu->_registers.a = 0x11;
-	snes.cpu->STA(0x0);
+	snes.cpu->STA(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.wram->_data[0];
 	cr_assert_eq(data, 0x11, "The stored value should be 0x11 but it was 0x%x.", data);
 }
@@ -24,7 +24,7 @@ Test(STA, 16bits)
 	Init()
 	snes.cpu->_registers.p.m = false;
 	snes.cpu->_registers.a = 0x11AB;
-	snes.cpu->STA(0x0);
+	snes.cpu->STA(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.wram->_data[0] + (snes.wram->_data[1] << 8u);
 	cr_assert_eq(data, 0x11AB, "The stored value should be 0x11AB but it was 0x%x.", data);
 }
@@ -34,7 +34,7 @@ Test(STX, 8bits)
 	Init()
 	snes.cpu->_registers.p.x_b = true;
 	snes.cpu->_registers.x = 0x11;
-	snes.cpu->STX(0x0);
+	snes.cpu->STX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.wram->_data[0];
 	cr_assert_eq(data, 0x11, "The stored value should be 0x11 but it was 0x%x.", data);
 }
@@ -44,7 +44,7 @@ Test(STX, 16bits)
 	Init()
 	snes.cpu->_registers.p.x_b = false;
 	snes.cpu->_registers.x = 0x11AB;
-	snes.cpu->STX(0x0);
+	snes.cpu->STX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.wram->_data[0] + (snes.wram->_data[1] << 8u);
 	cr_assert_eq(data, 0x11AB, "The stored value should be 0x11AB but it was 0x%x.", data);
 }
@@ -54,7 +54,7 @@ Test(STY, 8bits)
 	Init()
 	snes.cpu->_registers.p.x_b = true;
 	snes.cpu->_registers.y = 0x11;
-	snes.cpu->STY(0x0);
+	snes.cpu->STY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.wram->_data[0];
 	cr_assert_eq(data, 0x11, "The stored value should be 0x11 but it was 0x%x.", data);
 }
@@ -64,7 +64,7 @@ Test(STY, 16bits)
 	Init()
 	snes.cpu->_registers.p.x_b = false;
 	snes.cpu->_registers.y = 0x11AB;
-	snes.cpu->STY(0x0);
+	snes.cpu->STY(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.wram->_data[0] + (snes.wram->_data[1] << 8u);
 	cr_assert_eq(data, 0x11AB, "The stored value should be 0x11AB but it was 0x%x.", data);
 }
@@ -74,7 +74,7 @@ Test(STZ, 8bits)
 	Init()
 	snes.cpu->_registers.p.m = true;
 	snes.wram->_data[0] = 0x11;
-	snes.cpu->STZ(0x0);
+	snes.cpu->STZ(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.wram->_data[0];
 	cr_assert_eq(data, 0x00, "The stored value should be 0x00 but it was 0x%x.", data);
 }
@@ -85,7 +85,7 @@ Test(STZ, 16bits)
 	snes.cpu->_registers.p.m = false;
 	snes.wram->_data[0] = 0x11;
 	snes.wram->_data[1] = 0x11;
-	snes.cpu->STZ(0x0);
+	snes.cpu->STZ(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.wram->_data[0] + (snes.wram->_data[1] << 8u);
 	cr_assert_eq(data, 0x00, "The stored value should be 0x00 but it was 0x%x.", data);
 }
@@ -95,7 +95,7 @@ Test(LDX, 8bits)
 	Init()
 	snes.cpu->_registers.p.x_b = true;
 	snes.wram->_data[0] = 0x01;
-	snes.cpu->LDX(0x0);
+	snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.x;
 	cr_assert_eq(data, 0x01, "The stored value should be 0x01 but it was 0x%x.", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag register should not be set.");
@@ -107,7 +107,7 @@ Test(LDX, 8bitsNegative)
 	Init()
 	snes.cpu->_registers.p.x_b = true;
 	snes.wram->_data[0] = 0x11;
-	snes.cpu->LDX(0x0);
+	snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.x;
 	cr_assert_eq(data, 0x11, "The stored value should be 0x11 but it was 0x%x.", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag register should not be set.");
@@ -120,7 +120,7 @@ Test(LDX, 8bitsZero)
 	snes.cpu->_registers.p.x_b = true;
 	snes.wram->_data[0] = 0x00;
 	snes.wram->_data[1] = 0x11;
-	snes.cpu->LDX(0x0);
+	snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.x;
 	cr_assert_eq(data, 0x00, "The stored value should be 0x00 but it was 0x%x.", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag register should be set.");
@@ -133,7 +133,7 @@ Test(LDX, 16bits)
 	snes.cpu->_registers.p.x_b = false;
 	snes.wram->_data[0] = 0xAB;
 	snes.wram->_data[1] = 001;
-	snes.cpu->LDX(0x0);
+	snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.x;
 	cr_assert_eq(data, 0x01AB, "The stored value should be 0x01AB but it was 0x%x.", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag register should not be set.");
@@ -146,7 +146,7 @@ Test(LDX, 16bitsNegative)
 	snes.cpu->_registers.p.x_b = false;
 	snes.wram->_data[0] = 0xAB;
 	snes.wram->_data[1] = 0x11;
-	snes.cpu->LDX(0x0);
+	snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.x;
 	cr_assert_eq(data, 0x11AB, "The stored value should be 0x11AB but it was 0x%x.", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag register should not be set.");
@@ -159,7 +159,7 @@ Test(LDX, 16bitsZero)
 	snes.cpu->_registers.p.x_b = false;
 	snes.wram->_data[0] = 0x00;
 	snes.wram->_data[1] = 0x00;
-	snes.cpu->LDX(0x0);
+	snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied);
 	auto data = snes.cpu->_registers.x;
 	cr_assert_eq(data, 0x0000, "The stored value should be 0x0000 but it was 0x%x.", data);
 	cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag register should be set.");