Implement ROL and ROR (rotate left/right) instructions

[Copilot]

Implements M68000 ROL (Rotate Left) and ROR (Rotate Right) instructions per the specification.

Supported modes

• Register with immediate count: ROL.b #3, D0 — count 1-8 (0 encodes 8)
• Register with register count: ROL.w D1, D0 — count mod 64
• Memory: ROL.w (A0) — word only, 1-bit rotation

Condition codes

• X: unchanged
• N: set if MSB of result set
• Z: set if result zero
• V: always cleared
• C: last bit rotated out (cleared when count=0)

Files added

• include/GenieSys/CpuOperations/ROL.h / ROR.h
• src/CpuOperations/ROL.cpp / ROR.cpp
• test/CpuOperations/ROLTest.cpp / RORTest.cpp

Example

// ROL.b #1, D0 with D0=0x80
// Result: D0=0x01, C=1 (bit 7 rotated out to bit 0)

// ROR.b #1, D0 with D0=0x01  
// Result: D0=0x80, C=1 (bit 0 rotated out to bit 7)

36 new tests, all 805 tests passing.

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Implement ROd</issue_title>
<issue_description>Operation: Destination Rotated By < count > → Destination

Assembler ROd Dx,Dy

Syntax: ROd # < data > ,Dy ROd < ea > where d is direction, L or R

Attributes: Size = (Byte, Word, Long)

Description:
Rotates the bits of the operand in the direction specified (L or R). The extend
bit is not included in the rotation. The rotate count for the rotation of a register is
specified in either of two ways:

1. Immediate—The rotate count (1 – 8) is specified in the instruction.
2. Register—The rotate count is the value in the data register specified in the instruction, modulo 64.
   The size of the operation for register destinations is specified as byte, word, or long.
   The contents of memory, (ROd < ea > ), can be rotated one bit only, and operand size
   is restricted to a word.
   The ROL instruction rotates the bits of the operand to the left; the rotate count determines the number of bit positions rotated. Bits rotated out of the high-order bit go to the
   carry bit and also back into the low-order bit.
   .
   The ROR instruction rotates the bits of the operand to the right; the rotate count determines the number of bit positions rotated. Bits rotated out of the low-order bit go to the
   carry bit and also back into the high-order bit.

Condition Codes:
X — Not affected.
N — Set if the most significant bit of the result is set; cleared otherwise.
Z — Set if the result is zero; cleared otherwise.
V — Always cleared.
C — Set according to the last bit rotated out of the operand; cleared when the rotate
count is zero. </issue_description>

<agent_instructions>Please implement this ticket following existing coding practices found in the GenieSys repository.</agent_instructions>

Comments on the Issue (you are @copilot in this section)

• Fixes Implement ROd #81

---

💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more Copilot coding agent tips in the docs.

[PaulTrampert]

We should have a constant here to represent the base opcode. Define the constant using binary representation rather than hex or base-10.

The value should be 0b1110001000011000 for ROL and 0b111000000011000 for ROR.

[PaulTrampert]

:thought: Maybe merge this with ROR and extract the direction as a bitmask on bit 8.

[PaulTrampert]

getOpcodes should be a single call to getPossibleOpcodes. The first parameter should be the base opcode, and the second should be a vector of the addresses of all the operand bitmasks.