X86: Let the integer multiply microop use every other possible source value.

X86: Implement the media shifts that operate on 64 bits or less at a time.

X86: Implement the media shift microops. These don't handle full 128 bit wide shifts.

X86: Implement the sum of absolute differences instructions.

X86: Implement a "sum of absolute differences" microop.

X86: Implement the media integer subtract instructions.

X86: Implement an integer media subtract microop.

X86: Implement the integer media multiply instructions.

X86: Implement a media integer multiply microop.

X86: Make larger blocks of instructions use the Inst format by default.

X86: Implement the integer media max instructions.

X86: Implement an integer media max microop.

X86: Implement the integer media min instructions.

X86: Add a media integer min microop.

X86: Implement the media integer addition instructions.

X86: Implement an integer media addition microop with optional saturation.

X86: Implement the instructions that convert between forms of floating point.

X86: Implement a media microop that converts between floating point data types.

X86: Implement the instructions that compare fp values and write masks as the result.

X86: Implement a microop that compares fp values and writes a mask as its result.

X86: Implement the MOVDDUP instruction.

X86: Implement many of the media mov instructions.

X86: Implement the media instructions that convert integer values to floating point.

X86: Implement a media microop for converting integer values to floating point.

X86: Implement the floating point media instructions.

X86: Implement a floating point media divide microop.

X86: Implement the floating point media multiply instructions.

X86: Implement a floating point media multiply microop.

X86: Implement the floating point media subtract instructions.

X86: Implement a media floating point subtract microop.

X86: Implement the floating point media add instructions.

X86: Implement a floating point media add microop.

X86: Implement the media sqrt instructions.

X86: Implement a media square root microop.

X86: Implement the media floating point max instructions.

X86: Implement the floating point media max microop.

X86: Implement the media floating point min instructions.

X86: Implement a floating point media min microop.

X86: Implement the pack instructions.

X86: Create a pack media microop.

X86: Rename sel to ext for media microops.

X86: Move the MMX version of MOVD into the simd64 directory.

X86: Implement the remaining unpack instructions.

X86: Implement PANDN, ANDNPS, and ANDNPD.

X86: Implement a multimedia andn microop.

X86: Implement PAND, ANDPS, and ANDPD.

X86: Implement a multimedia and microop.

X86: Implement POR, ORPD and ORPS.

X86: Implement a media or microop.

X86: Implement PXOR.

X86: (Re)implement XORPS and XORPD.

X86: Implement a media xor microop.

X86: Implement PUNPCKLQDQ.

X86: Implement PUNPCKHQDQ.

X86: Implement PUNPCKHDQ.

X86: Implement PUNPCKHWD.

X86: Implement PUNPCKHBW.

X86: Implement PUNPCKLDQ.

X86: Implement PUNPCKLWD.

X86: Implement the versions of PUNPCKLBW that use XMM registers.

X86: Implement the MOVQ instruction.

X86: Implement the lfpimm microop.

X86: Implement the versions of MOVD that have an MMX source.

X86: Implement the versions of PUNPCKLBW that use MMX registers.

X86: Implement an unpack microop.

X86: Implement the versions of MOVD that have an MMX destination.

X86: Ignore the size part of XMM/MMX operands. The instructions know what they want.

X86: Use suffixes to differentiate XMM/MMX/GPR operands.

X86: Add microcode assembler symbols for mmx registers.

X86: Set up a media microop framework and create mov2int and mov2fp microops.

X86: Create base classes for use with media/SIMD microops.

X86: Turn the DIV and IDIV microcode into templates and generate all the variants.

X86: Remove some FIXMEs from IDIV that have been fixed.

X86: Turn the CMPXCHG8B microcode into a template and generate each variant.

Merge with head.

X86: Fix a bug introduced to IDIV in a recent attempt to fix another bug.

code_formatter: Add a python class for writing code generator templates

ply: add a base class called Grammar that encapsulates a ply grammar

orderdict: Use DictMixin and add orderdict to m5.util

python: Make it possible to import the parts of m5 that are pure python

ply: update PLY to version 3.2

Automated merge with ssh://hg@m5sim.org/m5

ruby: config bugfix

ruby/network data_msg_size bug fix with updated stats

merged Tushar's bug fix with public repository changes

Automated merge with ssh://hg@m5sim.org/m5

protocol: added recycle actions to MOESI DMA events

X86: Update the stats on the ruby x86 regressions for the new CMOVcc implementation.

X86: Implement the CMPXCHG8B/CMPXCHG16B instruction.

X86: Don't clobber the original dividend when doing signed divide.

X86: Decode byte sized singed divide as byte sized.

X86: Update the stats for the slightly lengthened cmov.

X86: Make not taken conditional moves leave the destination alone. Adjust CMOVcc.
The manuals from both AMD and Intel say that when writing to a 32 bit
destination in 64 bit mode, the upper 32 bits of the register are filled with
zeros. They also both say that the CMOV instructions leave their destination
alone when their condition fails. Unfortunately, it seems that CMOV will zero
extend its destination register whether or not it was supposed to actually do
a move on both platforms. This seems to be the only case where this happens,
but it would be hard to say for sure.

bug fix for data_msg_size in network/Network.cc

X86: (Re)Implemented SHRD.

X86: Implement SHLD.

X86: Implement shift right/left double microops.
This is my best guess as far as what these should do. Other existing microops
use implicit registers, mul1s and mul1u for instance, so this should be ok.
The microop that loads the implicit DoubleBits register would fall into one
of the microop slots for moving to/from special registers.

X86: Make the qaud width bswap instruction handle the fact that 32 bit operations zero extend.

X86: Use the right field when using legacy prefixes to distinguish instructions.

X86: Don't truncate the immediate parameter for the ENTER instruction.