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.

ARM: Make 32 bit thumb use the new, external load instructions.

ARM: Define the store instructions from outside the decoder.

--HG--
rename : src/arch/arm/isa/insts/ldr.isa => src/arch/arm/isa/insts/str.isa

ARM: Define the load instructions from outside the decoder.

ARM: Implement a new set of base classes for non macro memory instructions.

ARM: Create a "decoder" directory for the files implementing the decoder.

--HG--
rename : src/arch/arm/isa/armdecode.isa => src/arch/arm/isa/decoder/arm.isa
rename : src/arch/arm/isa/decoder.isa => src/arch/arm/isa/decoder/decoder.isa
rename : src/arch/arm/isa/thumbdecode.isa => src/arch/arm/isa/decoder/thumb.isa
rename : src/arch/arm/isa/vfpdecode.isa => src/arch/arm/isa/decoder/vfp.isa

ARM: Flesh out the 32 bit thumb store single instructions.

ARM: Implement the 32 bit thumb load word instructions.

ARM: Add an operand for accessing the current PC.

ARM: Flesh out 32 bit thumb load word decoding.

ARM: Implement some 32 bit thumb data processing immediate instructions.

ARM: Replace the "never" condition with the "unconditional" condition.

ARM: Add a base class for 32 bit thumb data processing immediate instructions.

ARM: Add a function to decode 32 bit thumb immediate values.

ARM: Expand the decoding for 32 bit thumb data processing immediate instructions.

ARM: Stub out the 32 bit Thumb portion of the decoder.

ARM: Add bitfields for 32 bit thumb.

ARM: Decode VFP instructions.

ARM: Stub out the 16 bit thumb decoder.

ARM: Add thumb bitfields to the ExtMachInst and the isa definition.

ARM: Make the decoder handle thumb instructions separately.

--HG--
rename : src/arch/arm/isa/decoder.isa => src/arch/arm/isa/armdecode.isa
rename : src/arch/arm/isa/decoder.isa => src/arch/arm/isa/thumbdecode.isa

ARM: Add a thumb bit bitfield.

ARM: Make the predecoder handle Thumb instructions.

ARM: Make sure ExtMachInst is used consistently instead of regular MachInst.

ARM: Add a bitfield for setting the regular, inst bits of an ExtMachInst.

ARM: Add a bit to the ExtMachInst to select thumb mode.

ARM: Allow ARM processes to start in Thumb mode.

ARM: Detect thumb mode elf images.

ARM: Add a new base class for instructions that can do an interworking branch.

ARM: Track the current ISA mode using the PC.

ARM: Fix custom writer/reader code for non indexed operands.