ARM: Ignore/warn on accesses to the dccmvac register.

ARM: Decode the enterx and leavex instructions.

ARM: Implement the enterx and leavex instructions.

These enter and leave thumbEE mode. Currently thumbEE mode behaves exactly the
same as Thumb mode, but at least this will make it -look- like we're enter and
leaving it. The actual behavioral changes will be implemented in future
changes.

ARM: Fix the implementation of BX to work in thumbEE mode.

ARM: When an instruction is intentionally undefined, fault on it.

ARM: Decode the thumb version of the ldrd and strd instructions.

ARM: Explicitly keep track of the second destination for double loads/stores.

ARM: Decode the thumb32 load byte/memory hint instructions.

ARM: Decode the load halfword, memory hints instructions for 32 bit Thumb.

ARM: Ignore/warn on accesses to icimvau.

ARM: Ignore/warn on iciallu.

ARM: Ignore/warn on ICIALLUIS.

ARM: Add support for the clidr register.

This register will always report 0 caches as implemented. It's not clear how
to find out how many there really are when dealing with an arbitrary
hierarchy.

ARM: Decode the unimplemented data barrier CP15 accesses.

These are CP15DSB (Data Synchronization Barrier), and CP15DMB (Data Memory
Barrier).

ARM: Implement a stub of CPACR.

This register controls access to the coprocessors. This doesn't actually
implement it, it allows writes which don't turn anything off. In other words,
it allows the simulated program to ask for what it already has.

ARM: Actually write the value of sctlr in ISA.clear().

ARM: Replace the ARM decode of CP15 MCR and MRC instructions.

ARM: Decode the unimplemented cp15 instruction barrier.

ARM: Ignore accesses to DCCIMVAC.

ARM: Allow accesses to the software thread id registers.

ARM: Allow accesses to the contextidr register.

ARM: Warn about and ignore accesses to DCCISW.

This register is supposed to "Clean and invalidate data or unified cache line
by set/way." Since there isn't a good way to do that, we'll just ignore these
and warn about it.

ARM: Decode the thumb versions of the mcr and mrc instructions.

ARM: Implement the mrc and mcr instructions.

ARM: Rename the RevOp base class to something more generic.

ARM: Add a version of the Dest and Op1 operands for accessing the MiscRegs.

ARM: Implement a function to decode CP15 registers to MiscReg indices.

ARM: Decode the bfi and bfc instructions.

ARM: Implement the bfc and bfi instructions.

ARM: Decode the ubfx and sbfx instructions.

ARM: Decode miscellaneous arm mode media instructions.

ARM: Implement the ubfx and sbfx instructions.

ARM: Add a register, immediate, immediate to register base for [su]bfx.

ARM: Decode the clz instruction.

ARM: Implement the clz instruction.

ARM: Decode the rbit instruction.

ARM: Implement the rbit instruction.

ARM: Decode the nop instruction.

ARM: Implement nop.

ARM: Decode the ldrex instruction.

ARM: Rearrange the load/store double/exclusive, table branch thumb decoding.

ARM: Implement the ldrex instruction.

ARM: Decode the usad8 and usada8 instructions.

ARM: Implement the usad8 and usada8 instructions.

ARM: Add a base class to support usada8.

ARM: Decode the sel instruction.

ARM: Implement the sel instruction.

ARM: Add a base class for the sel instruction.

ARM: Decode pkh instructions.

ARM: Implement the pkh instruction.

ARM: Decode the sign/zero extend instructions.

ARM: Implement zero/sign extend instructions.

ARM: Add a base class for extend and add instructions.

ARM: Generalize the saturation instruction bases for use in other instructions.

ARM: Decode the 8/16 bit signed/unsigned add/subtract half instructions.

ARM: Implement the 8/16 bit signed/unsigned add/subtract half instructions.

ARM: Fix signed most significant multiply instructions.

ARM: Fix multiply overflow flag setting.

ARM: Decode the saturation instructions.

ARM: Implement the saturation instructions.

ARM: Implement base classes for the saturation instructions.

ARM: Decode the signed add/subtract and subtract/add instructions.

ARM: Implement signed add/subtract and subtract/add.

ARM: Decode the unsigned 8 and 16 bit add and subtract instructions.

ARM: Implement the unsigned 8 bit and 16 bit vector adds and subtracts.

ARM: Decode the unsigned saturating instructions.

ARM: Implement the unsigned saturating instructions.

ARM: Decode the ssub instructions.

ARM: Implement the ssub instructions.

ARM: Decode the SADD8 and SADD16 instructions.

ARM: Implement the SADD8 and SADD16 instructions.

ARM: Support instructions that set the GE bits when they write the condition codes.

ARM: Decode 32 bit thumb data processing register instructions.

ARM: Decode the 16 bit thumb versions of the REV* instructions.

ARM: Decode the ARM version of the REV* instructions.

ARM: Pull decoding of ARM pack, unpack, saturate and reverse instructions into a format.

ARM: Implement the REV* instructions.

ARM: Add base classes suitable for the REV* instructions.

ARM: Make LDM that loads the PC perform an interworking branch.

ARM: Decode the swp and swpb instructions.

ARM: Implement the swp and swpb instructions.

ARM: Decode MRS and MSR for thumb.

ARM: Replace the versions of MRS and MSR in the ARM decoder with the new ones.

ARM: Define versions of MSR and MRS outside the decoder.

ARM: Hook up the push/pop versions of stm/ldm in thumb.

ARM: Hook SVC into the thumb decoder.

ARM: Implement SVC (was SWI) outside of the decoder.

ARM: Update the stats for the new syscall behavior.

ARM: Trigger system calls from the SupervisorCall invoke method.

This simplifies the decoder slightly, and makes the system call mechanism
very slightly more realistic.

ARM: Fix multiply operations.

These fixes were provided by Ali and fix the saturation condition code and
various multiply instructions.

ARM: Decode the scalar saturating add/subtract instructions.

ARM: Decode the parallel add and subtract instructions.

ARM: Implement signed saturating add and/or subtract instructions.

ARM: Implemented prefetch instructions/decoding (pli, pld, pldw).

ARM: Decode unconditional ARM instructions.

ARM: Make sure ldm exception return writes back its base in the right mode.

This change moves the writeback of load multiple instructions to the beginning
of the macroop. That way, the MicroLdrRetUop that changes the mode will
necessarily happen later, ensuring the writeback happens in the original mode.
The actual value in the base register if it also shows up in the register list
is undefined, so it's fine if it gets clobbered by one of the loads. For
stores where the base register is the lowest numbered in the register list,
the original value should be written back. That means stores can't write back
at the beginning, but the mode changing problem doesn't affect them so they
can continue to write back at the end.

ARM: Rework how unrecognized/unimplemented instructions are handled.

Instead of panic immediately when these instructions are executed, an
UndefinedInstruction fault is returned. In FS mode (not currently
implemented), this is the fault that should, to my knowledge, be triggered in
these situations and should be handled using the normal architected
mechanisms. In SE mode, the fault causes a panic when it's invoked that gives
the same information as the instruction did. When/if support for speculative
execution of ARM is supported, this will allow a mispeculated and unrecognized
and/or unimplemented instruction from causing a panic. Only once the
instruction is going to be committed will the fault be invoked, triggering the
panic.

ARM: Add support for "SUBS PC, LR and related instructions".

ARM: Make ldrs into the PC and ldm exception return do interworking branches.

ARM: Align the PC when using it as the base for a load.