2017-08-06 13:36:26 +00:00
|
|
|
#include <processor/processor.hpp>
|
|
|
|
|
#include "arm7tdmi.hpp"
|
|
|
|
|
|
|
|
|
|
namespace Processor {
|
|
|
|
|
|
|
|
|
|
#include "registers.cpp"
|
|
|
|
|
#include "memory.cpp"
|
|
|
|
|
#include "algorithms.cpp"
|
|
|
|
|
#include "instruction.cpp"
|
|
|
|
|
#include "instructions-arm.cpp"
|
|
|
|
|
#include "instructions-thumb.cpp"
|
|
|
|
|
#include "serialization.cpp"
|
Update to v103r28 release.
byuu says:
Changelog:
- processor/arm7tdmi: implemented 10 of 19 ARM instructions
- processor/arm7tdmi: implemented 1 of 22 THUMB instructions
Today's WIP was 6 hours of work, and yesterday's was 5 hours.
Half of today was just trying to come up with the design to use a
lambda-based dispatcher to map both instructions and disassembly,
similar to the 68K core. The problem is that the ARM core has 28 unique
bits, which is just far too many bits to have a full lookup table like
the 16-bit 68K core.
The thing I wanted more than anything else was to perform the opcode
bitfield decoding once, and have it decoded for both instructions and
the disassembler. It took three hours to come up with a design that
worked for the ARM half ... relying on #defines being able to pull in
other #defines that were declared and changed later after the first
one. But, I'm happy with it. The decoding is in the table building, as
it is with the 68K core. The decoding does happen at run-time on each
instruction invocation, but it has to be done.
As to the THUMB core, I can create a 64K-entry lambda table to cover all
possible encodings, and ... even though it's a cache killer, I've
decided to go for it, given the outstanding performance it obtained in
the M68K core, as well as considering that THUMB mode is far more common
in GBA games.
As to both cores ... I'm a little torn between two extremes:
On the one hand, I can condense the number of ARM/THUMB instructions
further to eliminate more redundant code. On the other, I can split them
apart to reduce the number of conditional tests needed to execute each
instruction. It's really the disassembler that makes me not want to
split them up further ... as I have to split the disassembler functions
up equally to the instruction functions. But it may be worth it if it's
a speed improvement.
2017-08-07 12:20:35 +00:00
|
|
|
#include "disassembler.cpp"
|
|
|
|
|
|
|
|
|
|
ARM7TDMI::ARM7TDMI() {
|
|
|
|
|
armInitialize();
|
|
|
|
|
thumbInitialize();
|
|
|
|
|
}
|
2017-08-06 13:36:26 +00:00
|
|
|
|
|
|
|
|
auto ARM7TDMI::power() -> void {
|
|
|
|
|
processor = {};
|
|
|
|
|
processor.r15.modify = [&] { pipeline.reload = true; };
|
|
|
|
|
pipeline = {};
|
|
|
|
|
carry = 0;
|
|
|
|
|
irq = 0;
|
2017-08-11 16:02:09 +00:00
|
|
|
cpsr().f = 1;
|
|
|
|
|
exception(PSR::SVC, 0x00);
|
2017-08-06 13:36:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|