Implements REP and SEP and exposes the MX flags generally.

Processors/6502Esque/6502Esque.hpp

@@ -49,7 +49,11 @@ enum Flag: uint8_t {
 	Decimal		= 0x08,
 	Interrupt	= 0x04,
 	Zero		= 0x02,
-	Carry		= 0x01
+	Carry		= 0x01,
+
+	// These are available on a 65816 only.
+	MemorySize	= 0x20,
+	IndexSize	= 0x10,
 };
 
 /*!

Processors/65816/Implementation/65816Implementation.hpp

@@ -318,10 +318,13 @@ template <typename BusHandler> void Processor<BusHandler>::run_for(const Cycles
 
 				bool is_brk = false;
 
+				// TODO: probably this should have been decided in advance? And the interrupt flag
+				// needs to be factored in?
+
 				if(pending_exceptions_ & (Reset | PowerOn)) {
-					// TODO: set emulation mode, etc.
 					pending_exceptions_ &= ~(Reset | PowerOn);
 					data_address_ = 0xfffc;
+					set_reset_state();
 				} else if(pending_exceptions_ & NMI) {
 					pending_exceptions_ &= ~NMI;
 					data_address_ = 0xfffa;
@@ -338,7 +341,7 @@ template <typename BusHandler> void Processor<BusHandler>::run_for(const Cycles
 					}
 				}
 
-				data_buffer_.value = (pc_ << 8) | flags_.get();
+				data_buffer_.value = (pc_ << 8) | get_flags();
 				if(emulation_flag_) {
 					if(is_brk) data_buffer_.value |= Flag::Break;
 					data_buffer_.size = 3;
@@ -347,8 +350,6 @@ template <typename BusHandler> void Processor<BusHandler>::run_for(const Cycles
 					data_buffer_.value |= program_bank_ << 24;
 					data_buffer_.size = 4;
 					program_bank_ = 0;
-
-					assert(false);	// TODO: proper flags, still.
 				}
 
 				flags_.inverse_interrupt = 0;
@@ -397,11 +398,7 @@ template <typename BusHandler> void Processor<BusHandler>::run_for(const Cycles
 					break;
 
 					case PLP:
-						flags_.set(data_buffer_.value);
-
-						if(!emulation_flag_) {
-							assert(false);	// TODO: M and X.
-						}
+						set_flags(data_buffer_.value);
 					break;
 
 					case STA:
@@ -440,12 +437,10 @@ template <typename BusHandler> void Processor<BusHandler>::run_for(const Cycles
 					break;
 
 					case PHP:
-						data_buffer_.value = flags_.get();
+						data_buffer_.value = get_flags();
 						data_buffer_.size = 1;
 
-						if(!emulation_flag_) {
-							assert(false);	// TODO: M and X.
-						} else {
+						if(emulation_flag_) {
 							// On the 6502, the break flag is set during a PHP.
 							data_buffer_.value |= Flag::Break;
 						}
@@ -530,11 +525,10 @@ template <typename BusHandler> void Processor<BusHandler>::run_for(const Cycles
 
 					case RTI:
 						pc_ = uint16_t(data_buffer_.value >> 8);
-						flags_.set(uint8_t(data_buffer_.value));
+						set_flags(uint8_t(data_buffer_.value));
 
 						if(!emulation_flag_) {
 							program_bank_ = (data_buffer_.value & 0xff000000) >> 8;
-							assert(false); // Extra flags to unpack!
 						}
 					break;
 
@@ -571,6 +565,14 @@ template <typename BusHandler> void Processor<BusHandler>::run_for(const Cycles
 					case SEI: flags_.inverse_interrupt = 0;					break;
 					case SED: flags_.decimal = Flag::Decimal;				break;
 
+					case REP:
+						set_flags(get_flags() &~ instruction_buffer_.value);
+					break;
+
+					case SEP:
+						set_flags(get_flags() | instruction_buffer_.value);
+					break;
+
 					//
 					// Increments and decrements.
 					//
@@ -777,7 +779,6 @@ template <typename BusHandler> void Processor<BusHandler>::run_for(const Cycles
 
 					// TODO:
 					//	TRB, TSB,
-					//	REP, SEP,
 					//	XCE, XBA,
 					//	STP, WAI,
 					//	RTL,
@@ -787,9 +788,6 @@ template <typename BusHandler> void Processor<BusHandler>::run_for(const Cycles
 						assert(false);
 				}
 			continue;
-
-			default:
-				assert(false);
 		}
 
 #undef LD
@@ -798,6 +796,9 @@ template <typename BusHandler> void Processor<BusHandler>::run_for(const Cycles
 #undef y_top
 #undef a_top
 
+		// TODO: do some sort of evaluation here on whether an interrupt or similar is pending,
+		// react appropriately.
+
 		number_of_cycles -= bus_handler_.perform_bus_operation(bus_operation, bus_address, bus_value);
 	}
 

Processors/65816/Implementation/65816Storage.cpp

@@ -731,7 +731,7 @@ struct CPU::WDC65816::ProcessorStorageConstructor {
 };
 
 ProcessorStorage::ProcessorStorage() {
-	a_.full = x_.full = y_.full = 0;	// TEMPORARY (?)
+	set_reset_state();
 
 	ProcessorStorageConstructor constructor(*this);
 
@@ -1023,3 +1023,63 @@ ProcessorStorage::ProcessorStorage() {
 	printf("Generated %zd micro-ops in total; covered %d opcodes\n", micro_ops_.size(), constructor.opcode);
 #endif
 }
+
+void ProcessorStorage::set_reset_state() {
+	data_bank_ = 0;
+	program_bank_ = 0;
+	direct_ = 0;
+	flags_.decimal = 0;
+	flags_.inverse_interrupt = 0;
+	set_emulation_mode(true);
+}
+
+void ProcessorStorage::set_emulation_mode(bool enabled) {
+	if(emulation_flag_ == enabled) {
+		return;
+	}
+
+	if(emulation_flag_) {
+		set_m_x_flags(true, true);
+		x_.halves.high = y_.halves.high = 0;
+		e_masks_[0] = 0xff00;
+		e_masks_[1] = 0x00ff;
+	} else {
+		e_masks_[0] = 0x0000;
+		e_masks_[1] = 0xffff;
+	}
+
+	emulation_flag_ = enabled;
+}
+
+void ProcessorStorage::set_m_x_flags(bool m, bool x) {
+	mx_flags_[0] = m;
+	mx_flags_[1] = x;
+
+	m_masks_[0] = m ? 0xff00 : 0x0000;
+	m_masks_[1] = m ? 0x00ff : 0xffff;
+	m_shift_ = m ? 0 : 8;
+
+	x_masks_[0] = x ? 0xff00 : 0x0000;
+	x_masks_[1] = x ? 0x00ff : 0xffff;
+	x_shift_ = x ? 0 : 8;
+}
+
+uint8_t ProcessorStorage::get_flags() {
+	uint8_t result = flags_.get();
+
+	if(!emulation_flag_) {
+		result &= ~(Flag::MemorySize | Flag::IndexSize);
+		result |= mx_flags_[0] * Flag::MemorySize;
+		result |= mx_flags_[1] * Flag::IndexSize;
+	}
+
+	return result;
+}
+
+void ProcessorStorage::set_flags(uint8_t value) {
+	flags_.set(value);
+
+	if(!emulation_flag_) {
+		set_m_x_flags(value & Flag::MemorySize, value & Flag::IndexSize);
+	}
+}

Processors/65816/Implementation/65816Storage.hpp

@@ -312,4 +312,10 @@ struct ProcessorStorage {
 
 	std::vector<MicroOp> micro_ops_;
 	MicroOp *next_op_ = nullptr;
+
+	void set_reset_state();
+	void set_emulation_mode(bool);
+	void set_m_x_flags(bool m, bool x);
+	uint8_t get_flags();
+	void set_flags(uint8_t);
 };