Make guard_cid and nullable_cid half words.

runtime/vm/disassembler_ia32.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/disassembler.h"
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 #include "platform/utils.h"
 #include "vm/allocation.h"
@@ skipping 329 matching lines @@
   void PrintAddress(uword addr);
 
   typedef void (X86Decoder::*RegisterNamePrinter)(int reg);
 
   int PrintRightOperandHelper(uint8_t* modrmp,
                               RegisterNamePrinter register_printer);
   int PrintRightOperand(uint8_t* modrmp);
   int PrintRightXmmOperand(uint8_t* modrmp);
   int PrintRightByteOperand(uint8_t* modrmp);
   int PrintOperands(const char* mnem, OperandOrder op_order, uint8_t* data);
-  int PrintImmediateOp(uint8_t* data);
+  int PrintImmediateOp(uint8_t* data, bool size_override = false);
 
   // Handle special encodings.
   int JumpShort(uint8_t* data);
   int JumpConditional(uint8_t* data, const char* comment);
   int JumpConditionalShort(uint8_t* data, const char* comment);
   int SetCC(uint8_t* data);
   int CMov(uint8_t* data);
   int D1D3C1Instruction(uint8_t* data);
   uint8_t* F3Instruction(uint8_t* data);
   int F7Instruction(uint8_t* data);
@@ skipping 343 matching lines @@
       break;
     }
     default:
       UNREACHABLE();
       break;
   }
   return advance;
 }
 
 
-int X86Decoder::PrintImmediateOp(uint8_t* data) {
+int X86Decoder::PrintImmediateOp(uint8_t* data, bool size_override) {
   bool sign_extension_bit = (*data & 0x02) != 0;
   uint8_t modrm = *(data+1);
   int mod, regop, rm;
   GetModRm(modrm, &mod, &regop, &rm);
   const char* mnem = "Imm???";
   switch (regop) {
     case 0: mnem = "add"; break;
     case 1: mnem = "or"; break;
     case 2: mnem = "adc"; break;
     case 3: mnem = "sbb"; break;
     case 4: mnem = "and"; break;
     case 5: mnem = "sub"; break;
     case 6: mnem = "xor"; break;
     case 7: mnem = "cmp"; break;
     default: UNIMPLEMENTED();
   }
   Print(mnem);
+  if (size_override) {
+    Print("_w");
+  } else if (sign_extension_bit) {
+    Print("_b");
+  }
   Print(" ");
   int count = PrintRightOperand(data+1);
-  if (sign_extension_bit) {
-    Print(",");
+  Print(",");
+  if (size_override) {
+    PrintHex(*reinterpret_cast<int16_t*>(data + 1 + count));
+    return 1 + count + 2 /*int16_t*/;
+  } else if (sign_extension_bit) {
     PrintHex(*(data + 1 + count));
-    return 1 + count + 1 /*int8*/;
+    return 1 + count + 1 /*int8_t*/;
   } else {
-    Print(",");
     PrintHex(*reinterpret_cast<int32_t*>(data + 1 + count));
     return 1 + count + 4 /*int32_t*/;
   }
 }
 
 
 int X86Decoder::DecodeEnter(uint8_t* data) {
   uint16_t size = *reinterpret_cast<uint16_t*>(data + 1);
   uint8_t level = *reinterpret_cast<uint8_t*>(data + 3);
   Print("enter ");
@@ skipping 920 matching lines @@
             Print("shufpd ");
             PrintXmmRegister(regop);
             Print(",");
             data += PrintRightXmmOperand(data);
             int comparison = *data;
             Print(" [");
             PrintHex(comparison);
             Print("]");
             data++;
           } else {
-              UNIMPLEMENTED();
+            UNIMPLEMENTED();
           }
+        } else if (*data == 0x3B) {
+          data++;
+          Print("cmp_w ");
+          int mod, regop, rm;
+          GetModRm(*data, &mod, &regop, &rm);
+          PrintCPURegister(regop);
+          Print(",");
+          data += PrintRightOperand(data);
+        } else if ((*data == 0x81) || (*data == 0x83)) {
+          data += PrintImmediateOp(data, true /* size_override */);
+        } else if (*data == 0xC7) {
+          data++;
+          Print("mov_w ");
+          data += PrintRightOperand(data);
+          int16_t imm = *reinterpret_cast<int16_t*>(data);
+          Print(",");
+          PrintHex(imm);
+          data += 2;
         } else if (*data == 0x90) {
           data++;
           Print("nop");
         } else {
           UNIMPLEMENTED();
         }
         break;
 
       case 0xFE:
       { data++;
@@ skipping 157 matching lines @@
   }
   hex_buffer[hex_index] = '\0';
   if (out_instr_len) {
     *out_instr_len = instruction_length;
   }
 }
 
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32