6502/erc-c
1
0
Fork 0
mirror of https://github.com/pevans/erc-c.git synced 2024-12-21 08:30:55 +00:00
Code Issues Projects Releases Wiki Activity

Documentation

Browse Source
This commit is contained in:
Peter Evans 2017-12-06 17:16:20 -06:00
parent 46fedccce1
commit fca069d5de
1 changed files with 44 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/mos6502.bits.c
View File

@ -5,11 +5,26 @@
#include "mos6502.h"
#include "mos6502.enums.h"
/*
* The and instruction will assign the bitwise-and of the accumulator
* and a given operand.
*/
DEFINE_INST(and)
{
cpu->A &= oper;
}
/*
* This is the "arithmetic" shift left instruction.
*
* Here we will shift the contents of the given operand left by one bit.
* If the operand was the accumulator, then we'll store it back there;
* if not, we will store it in the last effective address in memory.
*
* Note that we use the carry bit to help us figure out what the "last
* bit" is, and whether we should now set the carry bit as a result of
* our operation.
*/
DEFINE_INST(asl)
{
cpu->P &= ~CARRY;
@ -26,6 +41,11 @@ DEFINE_INST(asl)
}
}
/*
* The bit instruction will test a given operand for certain
* characteristics, and assign the negative, overflow, and/or carry bits
* in the status register as a result.
*/
DEFINE_INST(bit)
{
cpu->P &= ~NEGATIVE;
@ -45,11 +65,22 @@ DEFINE_INST(bit)
}
}
/*
* Compute the bitwise-exclusive-or between the accumulator and operand,
* and store the result in A.
*/
DEFINE_INST(eor)
{
cpu->A ^= oper;
}
/*
* This is pretty similar in spirit to the ASL instruction, except we
* shift right rather than left.
*
* Note that the letters in the instruction stand for "logical" shift
* right.
*/
DEFINE_INST(lsr)
{
cpu->P &= ~CARRY;
@ -66,11 +97,20 @@ DEFINE_INST(lsr)
}
}
/*
* Compute the bitwise-or of the accumulator and operand, and store the
* result in the A register.
*/
DEFINE_INST(ora)
{
cpu->A |= oper;
}
/*
* This instruction is interesting; it's a _rotation_ left, which means
* that what was in the 8th bit will move to the 1st bit, and everything
* else moves down one place.
*/
DEFINE_INST(rol)
{
CARRY_BIT();
@ -92,6 +132,10 @@ DEFINE_INST(rol)
}
}
/*
* Here it's a rotation to the right, just like the ROL instruction. All
* bits are maintained.
*/
DEFINE_INST(ror)
{
CARRY_BIT();