ARM: Add a RegRegImmOp base class.

ARM: Widen the immediate fields in the misc instruction classes.

ARM: Add a function to decode VFP modified immediate constants.

ARM: Add a function to decode SIMD modified immediate constants.

ARM: Add fp operands to operands.isa.

ARM: Decode the VMRS instruction.

ARM: Update the set of FP related miscregs.

ARM: Implement the VMRS instruction.

ARM: Decode the VMSR instruction.

ARM: Implement the VMSR instruction.

ARM: Decode 8, 16, and 32 bit transfers between core and extension (fp) registers.

ARM: Ignore attempts to disable coprocessors that aren't implemented anyway.

ARM: Implement the udiv instruction.

ARM: Implement the sdiv instruction.

ARM: Ignore writing a bad mode to CPSR with MSR.

ARM: Decode the CPS instruction.

ARM: Implement the CPS instruction.

ARM: Decode the SRS instruction.

ARM: Implement the SRS instruction.

ARM: Add a base class for SRS.

ARM: Implement a badMode function that says whether a mode is legal.

ARM: Allow flattening into any mode.

ARM: Decode TBB and TBH.

ARM: Decode the setend instruction.

ARM: Define the setend instruction.

ARM: Make a base class for instructions that use only an immediate.

ARM: Decode the arm version of ldrexd.

ARM: Decode the strex instructions.

ARM: Implement the strex instructions.

ARM: Set CPSR.E to SCTLR.EE on faults.

ARM: Warn about not implementing MPU translation, not panic about MMU.

We'll start out with a stbu version of PMSA and switch over to VMSA for the
full implementation.

ARM: Ignore/warn on accesses to the DRBAR, DRACR, and DRSR registers.

ARM: Allow access to the RGNR register.

ARM: Make the MPUIR register report that 1 unified data region is supported.

ARM: Ignore/warn on accesses to the BPIALLIS and BPIALL registers.

ARM: Respect the E bit of the CPSR when doing loads and stores.

ARM: Zero the micropc when vectoring to a fault.

ARM: Implement the V7 version of alignment checking.

ARM: Decode the RFE instruction.

ARM: Implement the RFE instruction.

ARM: Add a base class for the RFE instruction.

ARM: Make sure some undefined thumb32 instructions fault.

ARM: Squash the low order bits of the PC when performing a regular branch.

ARM: When changing the CPSR and branching, make sure the branch is second.

ARM: Ignore/warn when CSSELR or CCSIDR are accessed.

These registers provide information about the caches. Since we can't provide
that information, these will be harmlessly inert.

ARM: Ignore/warn access to the bpimva registers.

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.