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.

ARM: Implement ADR as separate from ADD.

ARM: Add support for interworking branch ALU instructions.

ARM: Fix when the flag bits are updated for thumb.

ARM: Don't rely on undefined behavior to get arithmetic right shift.
Shifting to the right of a signed value when the MSB is one is technically
undefined behavior, even though in my experience it's done the "right thing"
and sign extended the value. This replaces the arithmetic right shift code in
ARM that uses that coincidence with some code that relies on bit math.

ARM: Restrict the shift amount from a register to 8 bits.
The shift amount when taken from a register is supposed to be truncated to an
8 bit value.

ARM: Update the stats now that VFP load/store multiple is implemented.

ARM: Define the VFP load/store multiple instructions.

ARM: Decode the VFP load/store multiple instructions.

ARM: Fix the constant describing the number of floating point registers.

ARM: Add templates for VFP load/store multiple instructions.

ARM: Add base classes for VFP load/store multiple.

ARM: Add floating point load/store microops.

ARM: Add an fp version of one of the microop indexed registers.

ARM: Move the mmap region to where Linux actually has it.

ARM: Eliminate the unused rhi and rlo operands.

ARM: Move the macro mem constructor out of the isa desc.
This code doesn't use the parser at all, and moving it out reduces the
conceptual complexity of that code.

ARM: Make macroops panic if executed directly.
The macroop should never be executed, only it's microops will.

ARM: GCC < 4.3 has some issues with attribute no return on some functions. Fix so it works for older gccs.

ARM: Split out the "basic" templates and format.

--HG--
rename : src/arch/arm/isa/formats/basic.isa => src/arch/arm/isa/templates/basic.isa

ARM: Remove unnecessary cruft from includes.isa.

ARM: Move the inst2string function out of the isa_desc.
Delete the now empty formats/util.isa.

ARM: Get rid of the unused ArmGenericCodeSubs.

ARM: Make the predecoder print out the ExtMachInst it gathered when traced.

ARM: Remove special naming for the new version of multiply.

ARM: Hook the new multiply instructions into all the decoders.

ARM: Implement all integer multiply instructions.

ARM: Add templates for multiply instructions.

ARM: Add base classes for multiply instructions.

ARM: Decode plain binary immediate thumb data processing instructions.

ARM: Define a new "movt" data processing instruction.

ARM: Hook the new branch instructions into the 32 bit thumb decoder.

ARM: Hook the new branch instructions into the 16 bit thumb decoder.

ARM: Eliminate the old style branch instructions.

ARM: Hook the new branch instructions into the ARM decoder.

ARM: Implement branch instructions external to the decoder.

ARM: Add new templates for branch instructions.

ARM: Implement new base classes for branches.

ARM: Replace the interworking branch base class with a special operand.

ARM: Fix PC operand handling.

ARM: Remove the special naming from the new version of data processing instructions.

ARM: Get rid of unnecessary flag calculating functions.

ARM: Get rid of the unused Jump format.

ARM: Get rid of obsoleted predicated inst formats, etc.

ARM: Implement disassembly for the new data processing classes.

ARM: Hook the external data processing instructions into the Thumb decoder.

ARM: Move the modified_imm function from all ARM instructions to just data processing ones.

ARM: Hook the new external data processing instructions to the ARM decoder.

ARM: Implement data processing instructions external to the decoder.

ARM: Add new base classes for data processing instructions.

ARM: Hook up 32 bit thumb load/store multiple.

ARM: Hook up 16 bit thumb load/store multiple.

ARM: Reimplement load/store multiple external to the decoder.

--HG--
rename : src/arch/arm/isa/formats/macromem.isa => src/arch/arm/isa/insts/macromem.isa
rename : src/arch/arm/isa/formats/macromem.isa => src/arch/arm/isa/templates/macromem.isa

ARM: Move the templates for predicated instructions into a separate file.
This allows the templates to all be available at the same time before any of
the formats, etc. This breaks an artificial circular dependence.

--HG--
rename : src/arch/arm/isa/formats/pred.isa => src/arch/arm/isa/templates/pred.isa

ARM: Remove the special naming for the new memory instructions.
These are the only memory instructions now.

ARM: Eliminate the old memory formats which are no longer used.

ARM: Eliminate decoding for the very deprecated FPA instructions.

ARM: Make the addressing mode 3 loads/stores use the externally defined instructions.

ARM: Pull double memory instructions out of the decoder.

ARM: Force the condition code for 16 bit thumb instructions to be unconditional.
Before, because 16 bit thumb instructions didn't set the upper 16 bits of the
ExtMachInst, that field would be interpretted as "equals".

ARM: Decode 16 bit thumb PC relative memory instructions.

ARM: Decode 16 bit thumb immediate addressed memory instructions.

ARM: Decode 16 bit thumb register addressed memory instructions.

ARM: Make single stores decode to the new external store instructions.

ARM: Add a .w to the disassembly of 32 bit thumb instructions.
This isn't technically correct since the .w should only be added if there are
32 and 16 bit encodings, but always having it always is better than never
having it.