X86: Make sure instruction flags are set properly even on 32 bit machines.

The way flag bits were being set for microops in x86 ended up implicitly
calling the bitset constructor which was truncating flags beyond the width of
an unsigned long. This change sets the bits in chunks which are always small
enough to avoid being truncated. On 64 bit machines this should reduce to be
the same as before, and on 32 bit machines it should work properly and not be
unreasonably inefficient.

src/arch/x86/insts/microop.hh

@@ -100,7 +100,15 @@ namespace X86ISA
             X86ISA::X86StaticInst(mnem, _machInst, __opClass),
             instMnem(_instMnem)
         {
-            flags |= setFlags;
+            const int ChunkSize = sizeof(unsigned long);
+            const int Chunks = sizeof(setFlags) / ChunkSize;
+
+            // Since the bitset constructor can only handle unsigned long
+            // sized chunks, feed it those one at a time while oring them in.
+            for (int i = 0; i < Chunks; i++) {
+                unsigned shift = i * ChunkSize * 8;
+                flags |= (std::bitset<NumFlags>(setFlags >> shift) << shift);
+            }
         }
 
         std::string generateDisassembly(Addr pc,