ARM: Introduce new VFP base classes that are optionally microops.

ARM: Implement VCVT between double and single width FP.

ARM: Implement vcvt between int and fp. Ignore rounding.

ARM: Consolidate the VFP register index computation code.

ARM: Implement the VFP negated multiplies.

ARM: Implement the VFP versions of VMLA and VMLS.

ARM: Implement the VFP version of vdiv and vsqrt.

ARM: Implement the VFP version of vsub.

ARM: Implement the VFP version of vadd.

ARM: Implement the VFP version of vabs.

ARM: Implement the VFP version of vneg.

ARM: Implement the VFP version of vmul.

ARM: Move the VFP data operation decode into a function.

ARM: Implement and update the DFSR and IFSR registers on faults.

ARM: Make integer division by zero return a fault.

ARM: Add in some missing SCTLR fields.

ARM: Decode ARM unconditional MRC and MCR instructions.

ARM: Move the CP15 decode block into a function.

ARM: Decode the unconditional version of ARM fp instructions.

ARM: Move the FP decode blocks into functions.

ARM: Warn/ignore when TLB maintenance operations are performed.

ARM: Handle accesses to TLBTR.

ARM: Handle accesses to the DACR.

ARM: Handle accesses to TTBR0 and TTBR1.

ARM: Convert the CP15 registers from MPU to MMU.

ARM: Add some support for wfi/wfe/yield/etc

ARM: Move PC mode bits around so they can be used for exectrace

ARM: Add a traceflag to print cpsr

ARM: Undef instruction on invalid user CP15 access

ARM: Decode the VSTR instruction.

ARM: Implement the vstr instruction.

ARM: BXJ should be BX when there is no J support

ARM: Make sure macroops aren't interrupted midinstruction.

Do this by setting the delayed commit flag for all but the last microop.

ARM: Fix the implementation of the VFP ldm and stm macroops.

There were four bugs in these instructions. First, the loaded value was being
stored into a floating point register as floating point, changing the value as
it was transfered. Second, the meaning of the "up" bit had been reversed.
Third, the statically sized microop array wasn't bit enough for all possible
inputs. It's now dynamically sized and should always be big enough. Fourth,
the offset was stored as an unsigned 8 bit value. Negative offsets would look
like moderately large positive offsets.

Simple CPU: Make the FloatRegs trace flag do something.

ARM: Fix up thumb decoding of coproc instructions.

ARM: Clean up some redundancy and fault behavior for unimplemented thumb MCR, MRC.

CPU: Reset fetch offset after a exception

ARM: Decode the VLDR instruction.

ARM: Implement the VLDR instruction.

ARM: Decode all the various forms of vmov.

ARM: Make VFP load/store and 64 bit move decode correspond with CP10 and CP11.

ARM: Implement the various versions of VMOV.

ARM: Add a new RegImmOp base class.

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.