Move validator_x86_XX.rl out of unreviewed.

src/trusted/validator_ragel/unreviewed/decoder_test.c

 /*
  * Copyright (c) 2012 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <assert.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "native_client/src/include/elf32.h"
 #include "native_client/src/include/elf64.h"
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/shared/utils/types.h"
-#include "native_client/src/trusted/validator_ragel/unreviewed/decoder.h"
+#include "native_client/src/trusted/validator_ragel/decoder.h"
 
 /* This is a copy of NaClLog from shared/platform/nacl_log.c to avoid
  * linking in code in NaCl shared code in the unreviewed/Makefile and be able to
  *  use CHECK().
 
  * TODO(khim): remove the copy of NaClLog implementation as soon as
  * unreviewed/Makefile is eliminated.
  */
 void NaClLog(int detail_level, char const  *fmt, ...) {
   va_list ap;
@@ skipping 43 matching lines @@
   *result_size = file_size;
 }
 
 struct DecodeState {
   uint8_t width;
   const uint8_t *fwait; /* Set to true if fwait is detetected. */
   const uint8_t *offset;
   int ia32_mode;
 };
 
 void ProcessInstruction(const uint8_t *begin, const uint8_t *end,

[Brad Chen, 2012/10/05 16:47:21]

I am still waiting for you to break up this large function. Mark would be
complaining now about how not addressing all comments makes reviews longer...

[khim, 2012/10/15 16:38:57]

It made no sense to break it up in the current form: major refactoring was
needed.
Right. If the assumption is that "reviewer is always right" and "any and ALL
agreements (verbal, written or otherwise) can be ignored by reviewer" then yes.

I was under impression that you are not Mark and we *can* have some meaningful
discussion about some subsets of the code. Now it looks like we can not.

Oh, well. I've tried to refactor decoder_test.c. PTAL and suggest which parts
should be moved to separate functions.

[Brad Chen, 2012/10/16 00:16:55]

Here are rules that I generally assume apply during code review:
- By default reviewer is right.
- For questions of implementation details, the author tends to know the code
better than the reviewer and should use the review as an opportunity to teach
the reviewer what's going on. As the reviewer learns it may impact his review.
- For questions of style, the reviewer is generally not going to learn anything
from the review. In this specific case, appropriate use of procedural
abstraction is a broadly accepted style rule. I don't see much wiggle-room here.
If you think this is unreasonable, I'd suggest talking F2F with Dmitry or Kostya
about this, as that will make better use of your time. 

On 2012/10/15 16:38:57, khim wrote:

-                        struct instruction *instruction, void *userdata) {
+                        struct Instruction *instruction, void *userdata) {
   const char *instruction_name = instruction->name;
   unsigned char operands_count = instruction->operands_count;
   unsigned char rex_prefix = instruction->prefix.rex;
-  enum register_name rm_index = instruction->rm.index;
-  enum register_name rm_base = instruction->rm.base;
-#ifdef _MSC_VER
+  enum OperandName rm_index = instruction->rm.index;
+  enum OperandName rm_base = instruction->rm.base;
   Bool data16_prefix = instruction->prefix.data16;
-#else
-  _Bool data16_prefix = instruction->prefix.data16;
-#endif
   const uint8_t *p;
   char delimeter = ' ';
   int print_rip = FALSE;
   int rex_bits = 0;
   int maybe_rex_bits = 0;
   int show_name_suffix = FALSE;
   int empty_rex_prefix_ok = FALSE;
 #define print_name(x) (printf((x)), shown_name += strlen((x)))
   size_t shown_name = 0;
   int i, operand_type;
@@ skipping 134 matching lines @@
   if (operands_count > 0) {
     char rexw_counted = FALSE;
     show_name_suffix = TRUE;
     for (i=operands_count-1; i>=0; --i) {
       if (instruction->operands[i].name == JMP_TO) {
         /* Most control flow instructions never use suffixes, but "call" and
            "jmp" do... unless byte offset is used.  */
         if ((!strcmp(instruction_name, "call")) ||
             (!strcmp(instruction_name, "jmp"))) {
           switch (instruction->operands[i].type) {
-            case OPERAND_SIZE_8_BIT: show_name_suffix = FALSE; break;
-            case OPERAND_SIZE_16_BIT: show_name_suffix = 'w'; break;
-            case OPERAND_SIZE_32_BIT:
+            case OPERAND_TYPE_8_BIT: show_name_suffix = FALSE; break;
+            case OPERAND_TYPE_16_BIT: show_name_suffix = 'w'; break;
+            case OPERAND_TYPE_32_BIT:
               if (((struct DecodeState *)userdata)->ia32_mode) {
                 show_name_suffix = FALSE;
               } else {
                 show_name_suffix = 'q';
                 rex_bits += (rex_prefix & 0x08) >> 3;
                 rexw_counted = TRUE;
               }
               break;
-            case OPERAND_SIZE_2_BIT:
-            case OPERAND_SIZE_64_BIT:
-            case OPERAND_SIZE_128_BIT:
-            case OPERAND_SIZE_256_BIT:
-            case OPERAND_FLOAT_SIZE_16_BIT:
-            case OPERAND_FLOAT_SIZE_32_BIT:
-            case OPERAND_FLOAT_SIZE_64_BIT:
-            case OPERAND_FLOAT_SIZE_80_BIT:
-            case OPERAND_X87_SIZE_16_BIT:
-            case OPERAND_X87_SIZE_32_BIT:
-            case OPERAND_X87_SIZE_64_BIT:
-            case OPERAND_X87_BCD:
-            case OPERAND_X87_ENV:
-            case OPERAND_X87_STATE:
-            case OPERAND_X87_MMX_MM_STATE:
-            case OPERAND_ST:
-            case OPERAND_SELECTOR:
-            case OPERAND_FAR_PTR:
-            case OPERAND_SEGMENT_REGISTER:
-            case OPERAND_CONTROL_REGISTER:
-            case OPERAND_DEBUG_REGISTER:
-            case OPERAND_MMX:
-            case OPERAND_XMM:
-            case OPERAND_YMM:
+            case OPERAND_TYPE_2_BIT:
+            case OPERAND_TYPE_64_BIT:
+            case OPERAND_TYPE_128_BIT:
+            case OPERAND_TYPE_256_BIT:
+            case OPERAND_TYPE_FLOAT_32_BIT:
+            case OPERAND_TYPE_FLOAT_64_BIT:
+            case OPERAND_TYPE_FLOAT_80_BIT:
+            case OPERAND_TYPE_X87_16_BIT:
+            case OPERAND_TYPE_X87_32_BIT:
+            case OPERAND_TYPE_X87_64_BIT:
+            case OPERAND_TYPE_X87_BCD:
+            case OPERAND_TYPE_X87_ENV:
+            case OPERAND_TYPE_X87_STATE:
+            case OPERAND_TYPE_X87_MMX_XMM_STATE:
+            case OPERAND_TYPE_ST:
+            case OPERAND_TYPE_SELECTOR:
+            case OPERAND_TYPE_FAR_PTR:
+            case OPERAND_TYPE_SEGMENT_REGISTER:
+            case OPERAND_TYPE_CONTROL_REGISTER:
+            case OPERAND_TYPE_DEBUG_REGISTER:
+            case OPERAND_TYPE_MMX:
+            case OPERAND_TYPE_XMM:
+            case OPERAND_TYPE_YMM:
               assert(FALSE);
           }
         } else {
           show_name_suffix = FALSE;
         }
       } else if ((instruction->operands[i].name == REG_IMM) ||
                  (instruction->operands[i].name == REG_IMM2) ||
                  (instruction->operands[i].name == REG_RM) ||
                  (instruction->operands[i].name == REG_PORT_DX) ||
                  (instruction->operands[i].name == REG_ES_RDI) ||
                  (instruction->operands[i].name == REG_DS_RSI)) {
         if (show_name_suffix) {
           switch (instruction->operands[i].type) {
-            case OPERAND_SIZE_8_BIT: show_name_suffix = 'b'; break;
-            case OPERAND_SIZE_16_BIT: show_name_suffix = 'w'; break;
-            case OPERAND_SIZE_32_BIT: show_name_suffix = 'l'; break;
-            case OPERAND_SIZE_64_BIT: show_name_suffix = 'q'; break;
-            case OPERAND_FLOAT_SIZE_32_BIT: show_name_suffix = 's'; break;
-            case OPERAND_FLOAT_SIZE_64_BIT: show_name_suffix = 'l'; break;
-            case OPERAND_FLOAT_SIZE_80_BIT:show_name_suffix = 't'; break;
-            case OPERAND_X87_SIZE_32_BIT: show_name_suffix = 'l'; break;
-            case OPERAND_X87_SIZE_64_BIT: show_name_suffix = 'L'; break;
-            case OPERAND_SIZE_2_BIT:
-            case OPERAND_X87_SIZE_16_BIT:
-            case OPERAND_X87_BCD:
-            case OPERAND_X87_ENV:
-            case OPERAND_X87_STATE:
-            case OPERAND_X87_MMX_MM_STATE:
-            case OPERAND_SIZE_128_BIT:
-            case OPERAND_SIZE_256_BIT:
-            case OPERAND_FAR_PTR:
-            case OPERAND_MMX:
-            case OPERAND_XMM:
-            case OPERAND_YMM:
-            case OPERAND_SELECTOR: show_name_suffix = FALSE; break;
-            case OPERAND_FLOAT_SIZE_16_BIT:
-            case OPERAND_ST:
-            case OPERAND_SEGMENT_REGISTER:
-            case OPERAND_CONTROL_REGISTER:
-            case OPERAND_DEBUG_REGISTER:
+            case OPERAND_TYPE_8_BIT: show_name_suffix = 'b'; break;
+            case OPERAND_TYPE_16_BIT: show_name_suffix = 'w'; break;
+            case OPERAND_TYPE_32_BIT: show_name_suffix = 'l'; break;
+            case OPERAND_TYPE_64_BIT: show_name_suffix = 'q'; break;
+            case OPERAND_TYPE_FLOAT_32_BIT: show_name_suffix = 's'; break;
+            case OPERAND_TYPE_FLOAT_64_BIT: show_name_suffix = 'l'; break;
+            case OPERAND_TYPE_FLOAT_80_BIT:show_name_suffix = 't'; break;
+            case OPERAND_TYPE_X87_32_BIT: show_name_suffix = 'l'; break;
+            case OPERAND_TYPE_X87_64_BIT: show_name_suffix = 'L'; break;
+            case OPERAND_TYPE_2_BIT:
+            case OPERAND_TYPE_X87_16_BIT:
+            case OPERAND_TYPE_X87_BCD:
+            case OPERAND_TYPE_X87_ENV:
+            case OPERAND_TYPE_X87_STATE:
+            case OPERAND_TYPE_X87_MMX_XMM_STATE:
+            case OPERAND_TYPE_128_BIT:
+            case OPERAND_TYPE_256_BIT:
+            case OPERAND_TYPE_FAR_PTR:
+            case OPERAND_TYPE_MMX:
+            case OPERAND_TYPE_XMM:
+            case OPERAND_TYPE_YMM:
+            case OPERAND_TYPE_SELECTOR: show_name_suffix = FALSE; break;
+            case OPERAND_TYPE_ST:
+            case OPERAND_TYPE_SEGMENT_REGISTER:
+            case OPERAND_TYPE_CONTROL_REGISTER:
+            case OPERAND_TYPE_DEBUG_REGISTER:
               assert(FALSE);
           }
         }
       } else {
         /* "Empty" rex prefix (0x40) is used to select "sil"/"dil"/"spl"/"bpl".
          */
-        if (instruction->operands[i].type == OPERAND_SIZE_8_BIT &&
+        if (instruction->operands[i].type == OPERAND_TYPE_8_BIT &&
             instruction->operands[i].name <= REG_R15) {
           empty_rex_prefix_ok = TRUE;
         }
         /* First argument of "rcl"/"rcr"/"rol"/"ror"/"sar/""shl"/"shr"
            can not be used to determine size of command.  */
         if (((i != 1) || (strcmp(instruction_name, "rcl") &&
                           strcmp(instruction_name, "rcr") &&
                           strcmp(instruction_name, "rol") &&
                           strcmp(instruction_name, "ror") &&
                           strcmp(instruction_name, "sal") &&
                           strcmp(instruction_name, "sar") &&
                           strcmp(instruction_name, "shl") &&
                           strcmp(instruction_name, "shr"))) &&
         /* Second argument of "crc32" can not be used to determine size of
            command.  */
             ((i != 0) || strcmp(instruction_name, "crc32"))) {
           show_name_suffix = FALSE;
         }
         /* First argument of "crc32" can be used for that but objdump uses
            suffix anyway. */
         if ((i == 1) && (!strcmp(instruction_name, "crc32"))) {
           switch (instruction->operands[i].type) {
-            case OPERAND_SIZE_8_BIT: show_name_suffix = 'b'; break;
-            case OPERAND_SIZE_16_BIT: show_name_suffix = 'w'; break;
-            case OPERAND_SIZE_32_BIT: show_name_suffix = 'l'; break;
-            case OPERAND_SIZE_64_BIT: show_name_suffix = 'q'; break;
-            case OPERAND_SIZE_2_BIT:
-            case OPERAND_SIZE_128_BIT:
-            case OPERAND_SIZE_256_BIT:
-            case OPERAND_FLOAT_SIZE_16_BIT:
-            case OPERAND_FLOAT_SIZE_32_BIT:
-            case OPERAND_FLOAT_SIZE_64_BIT:
-            case OPERAND_FLOAT_SIZE_80_BIT:
-            case OPERAND_X87_SIZE_16_BIT:
-            case OPERAND_X87_SIZE_32_BIT:
-            case OPERAND_X87_SIZE_64_BIT:
-            case OPERAND_X87_BCD:
-            case OPERAND_X87_ENV:
-            case OPERAND_X87_STATE:
-            case OPERAND_X87_MMX_MM_STATE:
-            case OPERAND_ST:
-            case OPERAND_SELECTOR:
-            case OPERAND_FAR_PTR:
-            case OPERAND_SEGMENT_REGISTER:
-            case OPERAND_CONTROL_REGISTER:
-            case OPERAND_DEBUG_REGISTER:
-            case OPERAND_MMX:
-            case OPERAND_XMM:
-            case OPERAND_YMM:
+            case OPERAND_TYPE_8_BIT: show_name_suffix = 'b'; break;
+            case OPERAND_TYPE_16_BIT: show_name_suffix = 'w'; break;
+            case OPERAND_TYPE_32_BIT: show_name_suffix = 'l'; break;
+            case OPERAND_TYPE_64_BIT: show_name_suffix = 'q'; break;
+            case OPERAND_TYPE_2_BIT:
+            case OPERAND_TYPE_128_BIT:
+            case OPERAND_TYPE_256_BIT:
+            case OPERAND_TYPE_FLOAT_32_BIT:
+            case OPERAND_TYPE_FLOAT_64_BIT:
+            case OPERAND_TYPE_FLOAT_80_BIT:
+            case OPERAND_TYPE_X87_16_BIT:
+            case OPERAND_TYPE_X87_32_BIT:
+            case OPERAND_TYPE_X87_64_BIT:
+            case OPERAND_TYPE_X87_BCD:
+            case OPERAND_TYPE_X87_ENV:
+            case OPERAND_TYPE_X87_STATE:
+            case OPERAND_TYPE_X87_MMX_XMM_STATE:
+            case OPERAND_TYPE_ST:
+            case OPERAND_TYPE_SELECTOR:
+            case OPERAND_TYPE_FAR_PTR:
+            case OPERAND_TYPE_SEGMENT_REGISTER:
+            case OPERAND_TYPE_CONTROL_REGISTER:
+            case OPERAND_TYPE_DEBUG_REGISTER:
+            case OPERAND_TYPE_MMX:
+            case OPERAND_TYPE_XMM:
+            case OPERAND_TYPE_YMM:
               assert(FALSE);
           }
         }
       }
       if ((instruction->operands[i].name >= REG_R8) &&
           (instruction->operands[i].name <= REG_R15) &&
-          (instruction->operands[i].type != OPERAND_MMX)) {
+          (instruction->operands[i].type != OPERAND_TYPE_MMX)) {
         if (!((struct DecodeState *)userdata)->ia32_mode) {
           ++rex_bits;
           /* HACK: objdump mistakenly allows "lock" with "mov %crX,%rXX" only in
              32bit mode.  It's perfectly valid in 64bit mode, too, so instead of
              changing the decoder we fix it here.  */
-          if (instruction->operands[i].type == OPERAND_CONTROL_REGISTER) {
+          if (instruction->operands[i].type == OPERAND_TYPE_CONTROL_REGISTER) {
             if ((*begin == 0xf0) && !(instruction->prefix.lock)) {
               print_name("lock ");
               if (!(rex_prefix & 0x04)) {
                 instruction->operands[i].name -= 8;
                 --rex_bits;
               }
             }
           }
         }
       } else if (instruction->operands[i].name == REG_RM) {
         if ((rm_base >= REG_R8) &&
             (rm_base <= REG_R15)) {
           ++rex_bits;
         } else if ((rm_base == NO_REG) ||
                    (rm_base == REG_RIP)) {
           if (strcmp(instruction_name, "movabs"))
             ++maybe_rex_bits;
         }
         if ((rm_index >= REG_R8) &&
             (rm_index <= REG_R15)) {
           ++rex_bits;
         }
       }
-      if ((instruction->operands[i].type == OPERAND_SIZE_64_BIT) &&
+      if ((instruction->operands[i].type == OPERAND_TYPE_64_BIT) &&
                                                                 !rexw_counted) {
         if (strcmp(instruction_name, "callq") &&
             strcmp(instruction_name, "cmpxchg8b") &&
             strcmp(instruction_name, "cvtpi2ps") &&
             strcmp(instruction_name, "cvtpi2pd") &&
             (strcmp(instruction_name, "extractps") ||
              instruction->operands[i].name != REG_RM) &&
             strcmp(instruction_name, "jmpq") &&
             strcmp(instruction_name, "monitor") &&
             strcmp(instruction_name, "movntq") &&
@@ skipping 119 matching lines @@
             strcmp(instruction_name, "punpcklqdq") &&
             strcmp(instruction_name, "punpcklwd") &&
             strcmp(instruction_name, "push") &&
             strcmp(instruction_name, "pxor") &&
             strcmp(instruction_name, "unpckhpd") &&
             strcmp(instruction_name, "unpcklpd")) {
           ++rex_bits;
           rexw_counted = TRUE;
         }
         if ((operands_count == 2) &&
-            ((instruction->operands[1-i].type == OPERAND_CONTROL_REGISTER) ||
-             (instruction->operands[1-i].type == OPERAND_DEBUG_REGISTER))) {
+            ((instruction->operands[1-i].type == OPERAND_TYPE_CONTROL_REGISTER) ||
+             (instruction->operands[1-i].type == OPERAND_TYPE_DEBUG_REGISTER))) {
           --rex_bits;
         }
       }
-      if ((instruction->operands[i].type == OPERAND_SIZE_128_BIT) &&
+      if ((instruction->operands[i].type == OPERAND_TYPE_128_BIT) &&
                                                                 !rexw_counted) {
         if (!strcmp(instruction_name, "cmpxchg16b")) {
           ++rex_bits;
           rexw_counted = TRUE;
         }
       }
     }
   }
   if ((!strcmp(instruction_name, "cvtsi2sd") ||
        !strcmp(instruction_name, "cvtsi2ss")) &&
       instruction->operands[1].name == REG_RM) {
-    if (instruction->operands[1].type == OPERAND_SIZE_32_BIT) {
+    if (instruction->operands[1].type == OPERAND_TYPE_32_BIT) {
       show_name_suffix = 'l';
     } else {
       show_name_suffix = 'q';
     }
   }
   if ((!strcmp(instruction_name, "vcvtpd2dq") ||
        !strcmp(instruction_name, "vcvtpd2ps") ||
        !strcmp(instruction_name, "vcvttpd2dq") ||
        !strcmp(instruction_name, "vcvttpd2ps")) &&
       instruction->operands[1].name == REG_RM) {
-    if (instruction->operands[1].type == OPERAND_SIZE_128_BIT) {
+    if (instruction->operands[1].type == OPERAND_TYPE_128_BIT) {
       show_name_suffix = 'x';
     } else {
       show_name_suffix = 'y';
     }
   }
   if ((!strcmp(instruction_name, "vcvtsi2sd") ||
        !strcmp(instruction_name, "vcvtsi2ss")) &&
       instruction->operands[2].name == REG_RM) {
-    if (instruction->operands[2].type == OPERAND_SIZE_32_BIT) {
+    if (instruction->operands[2].type == OPERAND_TYPE_32_BIT) {
       show_name_suffix = 'l';
     } else {
       show_name_suffix = 'q';
     }
   }
   if (instruction->prefix.lock && (begin[0] == 0xf0)) {
     print_name("lock ");
   }
   if (instruction->prefix.repnz && (begin[0] == 0xf2)) {
     print_name("repnz ");
@@ skipping 196 matching lines @@
     /* "callq","cmpxchg8b"/"jmpq" already include suffix in the nanme.  */
     if ((!strcmp(instruction_name, "callq")) ||
         (!strcmp(instruction_name, "cmpxchg8b")) ||
         (!strcmp(instruction_name, "jmpq"))) {
        show_name_suffix = FALSE;
     }
   }
   if (rex_prefix & 0x08) {
     /* rex.W is not shown for relative jumps with rel32 operand, but are
        shown for relative jumps with rel8 operands.  */
-    if ((instruction->operands[0].type == OPERAND_SIZE_32_BIT) &&
+    if ((instruction->operands[0].type == OPERAND_TYPE_32_BIT) &&
         (!strcmp(instruction_name, "ja") ||
          !strcmp(instruction_name, "jae") ||
          !strcmp(instruction_name, "jb") ||
          !strcmp(instruction_name, "jbe") ||
          !strcmp(instruction_name, "je") ||
          !strcmp(instruction_name, "jg") ||
          !strcmp(instruction_name, "jge") ||
          !strcmp(instruction_name, "jl") ||
          !strcmp(instruction_name, "jle") ||
          !strcmp(instruction_name, "jne") ||
@@ skipping 64 matching lines @@
   if (show_name_suffix) {
     if (show_name_suffix == 'L') {
       print_name("ll");
     } else {
       printf("%c", show_name_suffix);
       ++shown_name;
     }
   }
   if (!strcmp(instruction_name, "mov")) {
     if ((instruction->operands[1].name == REG_IMM) &&
-       (instruction->operands[1].type == OPERAND_SIZE_64_BIT)) {
+       (instruction->operands[1].type == OPERAND_TYPE_64_BIT)) {
       print_name("abs");
     }
   }
   {
     size_t i;
     /* Print branch hint suffixes for conditional jump instructions (Jcc).  */
     const char* jcc_jumps[] = {
       "ja", "jae", "jbe", "jb", "je", "jg", "jge", "jle",
       "jl", "jne", "jno", "jnp", "jns", "jo", "jp", "js",
       "jecxz", "jrcxz", "loop", "loope", "loopne", NULL};
@@ skipping 77 matching lines @@
                (!strcmp(instruction_name, "ljmpq")) ||
                (!strcmp(instruction_name, "lcallw")) ||
                (!strcmp(instruction_name, "lcallq"))) {
       printf("*");
     }
     /* Dirty hack: both AMD manual and Intel manual agree that mov from general
        purpose register to segment register has signature "mov Ew Sw", but
        objdump insist on 32bit/64 bit.  This is clearly error in objdump so we
        fix it here and not in decoder.  */
     if ((begin[0] >= 0x48) && (begin[0] <= 0x4f) && (begin[1] == 0x8e) &&
-        (instruction->operands[i].type == OPERAND_SIZE_16_BIT)) {
-      operand_type = OPERAND_SIZE_64_BIT;
+        (instruction->operands[i].type == OPERAND_TYPE_16_BIT)) {
+      operand_type = OPERAND_TYPE_64_BIT;
     } else if (((begin[0] == 0x8e) ||
        ((begin[0] >= 0x40) && (begin[0] <= 0x4f) && (begin[1] == 0x8e))) &&
-        (instruction->operands[i].type == OPERAND_SIZE_16_BIT)) {
-      operand_type = OPERAND_SIZE_32_BIT;
+        (instruction->operands[i].type == OPERAND_TYPE_16_BIT)) {
+      operand_type = OPERAND_TYPE_32_BIT;
     } else {
       operand_type = instruction->operands[i].type;
     }
     switch (instruction->operands[i].name) {
       case REG_RAX: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%al"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%ax"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%eax"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%rax"); break;
-        case OPERAND_ST: printf("%%st(0)"); break;
-        case OPERAND_MMX: printf("%%mm0"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm0"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm0"); break;
-        case OPERAND_SEGMENT_REGISTER: printf("%%es"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr0"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db0"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%al"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%ax"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%eax"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%rax"); break;
+        case OPERAND_TYPE_ST: printf("%%st(0)"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm0"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm0"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm0"); break;
+        case OPERAND_TYPE_SEGMENT_REGISTER: printf("%%es"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr0"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db0"); break;
         default: assert(FALSE);
       }
       break;
       case REG_RCX: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%cl"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%cx"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%ecx"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%rcx"); break;
-        case OPERAND_ST: printf("%%st(1)"); break;
-        case OPERAND_MMX: printf("%%mm1"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm1"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm1"); break;
-        case OPERAND_SEGMENT_REGISTER: printf("%%cs"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr1"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db1"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%cl"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%cx"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%ecx"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%rcx"); break;
+        case OPERAND_TYPE_ST: printf("%%st(1)"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm1"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm1"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm1"); break;
+        case OPERAND_TYPE_SEGMENT_REGISTER: printf("%%cs"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr1"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db1"); break;
         default: assert(FALSE);
       }
       break;
       case REG_RDX: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%dl"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%dx"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%edx"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%rdx"); break;
-        case OPERAND_ST: printf("%%st(2)"); break;
-        case OPERAND_MMX: printf("%%mm2"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm2"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm2"); break;
-        case OPERAND_SEGMENT_REGISTER: printf("%%ss"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr2"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db2"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%dl"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%dx"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%edx"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%rdx"); break;
+        case OPERAND_TYPE_ST: printf("%%st(2)"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm2"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm2"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm2"); break;
+        case OPERAND_TYPE_SEGMENT_REGISTER: printf("%%ss"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr2"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db2"); break;
         default: assert(FALSE);
       }
       break;
       case REG_RBX: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%bl"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%bx"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%ebx"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%rbx"); break;
-        case OPERAND_ST: printf("%%st(3)"); break;
-        case OPERAND_MMX: printf("%%mm3"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm3"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm3"); break;
-        case OPERAND_SEGMENT_REGISTER: printf("%%ds"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr3"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db3"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%bl"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%bx"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%ebx"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%rbx"); break;
+        case OPERAND_TYPE_ST: printf("%%st(3)"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm3"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm3"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm3"); break;
+        case OPERAND_TYPE_SEGMENT_REGISTER: printf("%%ds"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr3"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db3"); break;
         default: assert(FALSE);
       }
       break;
       case REG_RSP: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: if (rex_prefix)
+        case OPERAND_TYPE_8_BIT: if (rex_prefix)
             printf("%%spl");
           else
             printf("%%ah");
           break;
-        case OPERAND_SIZE_16_BIT: printf("%%sp"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%esp"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%rsp"); break;
-        case OPERAND_ST: printf("%%st(4)"); break;
-        case OPERAND_MMX: printf("%%mm4"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm4"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm4"); break;
-        case OPERAND_SEGMENT_REGISTER: printf("%%fs"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr4"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db4"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%sp"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%esp"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%rsp"); break;
+        case OPERAND_TYPE_ST: printf("%%st(4)"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm4"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm4"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm4"); break;
+        case OPERAND_TYPE_SEGMENT_REGISTER: printf("%%fs"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr4"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db4"); break;
         default: assert(FALSE);
       }
       break;
       case REG_RBP: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: if (rex_prefix)
+        case OPERAND_TYPE_8_BIT: if (rex_prefix)
             printf("%%bpl");
           else
             printf("%%ch");
           break;
-        case OPERAND_SIZE_16_BIT: printf("%%bp"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%ebp"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%rbp"); break;
-        case OPERAND_ST: printf("%%st(5)"); break;
-        case OPERAND_MMX: printf("%%mm5"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm5"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm5"); break;
-        case OPERAND_SEGMENT_REGISTER: printf("%%gs"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr5"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db5"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%bp"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%ebp"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%rbp"); break;
+        case OPERAND_TYPE_ST: printf("%%st(5)"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm5"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm5"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm5"); break;
+        case OPERAND_TYPE_SEGMENT_REGISTER: printf("%%gs"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr5"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db5"); break;
         default: assert(FALSE);
       }
       break;
       case REG_RSI: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: if (rex_prefix)
+        case OPERAND_TYPE_8_BIT: if (rex_prefix)
             printf("%%sil");
           else
             printf("%%dh");
           break;
-        case OPERAND_SIZE_16_BIT: printf("%%si"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%esi"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%rsi"); break;
-        case OPERAND_ST: printf("%%st(6)"); break;
-        case OPERAND_MMX: printf("%%mm6"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm6"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm6"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr6"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db6"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%si"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%esi"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%rsi"); break;
+        case OPERAND_TYPE_ST: printf("%%st(6)"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm6"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm6"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm6"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr6"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db6"); break;
         default: assert(FALSE);
       }
       break;
       case REG_RDI: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: if (rex_prefix)
+        case OPERAND_TYPE_8_BIT: if (rex_prefix)
             printf("%%dil");
           else
             printf("%%bh");
           break;
-        case OPERAND_SIZE_16_BIT: printf("%%di"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%edi"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%rdi"); break;
-        case OPERAND_ST: printf("%%st(7)"); break;
-        case OPERAND_MMX: printf("%%mm7"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm7"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm7"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr7"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db7"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%di"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%edi"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%rdi"); break;
+        case OPERAND_TYPE_ST: printf("%%st(7)"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm7"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm7"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm7"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr7"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db7"); break;
         default: assert(FALSE);
       }
       break;
       case REG_R8: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%r8b"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%r8w"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%r8d"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%r8"); break;
-        case OPERAND_MMX: printf("%%mm0"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm8"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm8"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr8"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db8"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%r8b"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%r8w"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%r8d"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%r8"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm0"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm8"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm8"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr8"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db8"); break;
         default: assert(FALSE);
       }
       break;
       case REG_R9: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%r9b"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%r9w"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%r9d"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%r9"); break;
-        case OPERAND_MMX: printf("%%mm1"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm9"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm9"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr9"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db9"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%r9b"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%r9w"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%r9d"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%r9"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm1"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm9"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm9"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr9"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db9"); break;
         default: assert(FALSE);
       }
       break;
       case REG_R10: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%r10b"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%r10w"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%r10d"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%r10"); break;
-        case OPERAND_MMX: printf("%%mm2"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm10"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm10"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr10"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db10"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%r10b"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%r10w"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%r10d"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%r10"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm2"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm10"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm10"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr10"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db10"); break;
         default: assert(FALSE);
       }
       break;
       case REG_R11: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%r11b"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%r11w"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%r11d"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%r11"); break;
-        case OPERAND_MMX: printf("%%mm3"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm11"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm11"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr11"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db11"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%r11b"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%r11w"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%r11d"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%r11"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm3"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm11"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm11"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr11"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db11"); break;
         default: assert(FALSE);
       }
       break;
       case REG_R12: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%r12b"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%r12w"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%r12d"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%r12"); break;
-        case OPERAND_MMX: printf("%%mm4"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm12"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm12"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr12"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db12"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%r12b"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%r12w"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%r12d"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%r12"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm4"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm12"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm12"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr12"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db12"); break;
         default: assert(FALSE);
       }
       break;
       case REG_R13: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%r13b"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%r13w"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%r13d"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%r13"); break;
-        case OPERAND_MMX: printf("%%mm5"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm13"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm13"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr13"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db13"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%r13b"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%r13w"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%r13d"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%r13"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm5"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm13"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm13"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr13"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db13"); break;
         default: assert(FALSE);
       }
       break;
       case REG_R14: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%r14b"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%r14w"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%r14d"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%r14"); break;
-        case OPERAND_MMX: printf("%%mm6"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm14"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm14"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr14"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db14"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%r14b"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%r14w"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%r14d"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%r14"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm6"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm14"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm14"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr14"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db14"); break;
         default: assert(FALSE);
       }
       break;
       case REG_R15: switch (operand_type) {
-        case OPERAND_SIZE_8_BIT: printf("%%r15b"); break;
-        case OPERAND_SIZE_16_BIT: printf("%%r15w"); break;
-        case OPERAND_SIZE_32_BIT: printf("%%r15d"); break;
-        case OPERAND_SIZE_64_BIT: printf("%%r15"); break;
-        case OPERAND_MMX: printf("%%mm7"); break;
-        case OPERAND_FLOAT_SIZE_32_BIT:
-        case OPERAND_FLOAT_SIZE_64_BIT:
-        case OPERAND_SIZE_128_BIT:
-        case OPERAND_XMM: printf("%%xmm15"); break;
-        case OPERAND_SIZE_256_BIT:
-        case OPERAND_YMM: printf("%%ymm15"); break;
-        case OPERAND_CONTROL_REGISTER: printf("%%cr15"); break;
-        case OPERAND_DEBUG_REGISTER: printf("%%db15"); break;
+        case OPERAND_TYPE_8_BIT: printf("%%r15b"); break;
+        case OPERAND_TYPE_16_BIT: printf("%%r15w"); break;
+        case OPERAND_TYPE_32_BIT: printf("%%r15d"); break;
+        case OPERAND_TYPE_64_BIT: printf("%%r15"); break;
+        case OPERAND_TYPE_MMX: printf("%%mm7"); break;
+        case OPERAND_TYPE_FLOAT_32_BIT:
+        case OPERAND_TYPE_FLOAT_64_BIT:
+        case OPERAND_TYPE_128_BIT:
+        case OPERAND_TYPE_XMM: printf("%%xmm15"); break;
+        case OPERAND_TYPE_256_BIT:
+        case OPERAND_TYPE_YMM: printf("%%ymm15"); break;
+        case OPERAND_TYPE_CONTROL_REGISTER: printf("%%cr15"); break;
+        case OPERAND_TYPE_DEBUG_REGISTER: printf("%%db15"); break;
         default: assert(FALSE);
       }
       break;
       case REG_ST:
-        assert(operand_type == OPERAND_ST);
+        assert(operand_type == OPERAND_TYPE_ST);
         printf("%%st");
         break;
       case REG_RM: {
         if (instruction->rm.disp_type != DISPNONE) {
           if ((instruction->rm.disp_type == DISP64) ||
               (instruction->rm.offset >= 0))
             printf("0x%"NACL_PRIx64, instruction->rm.offset);
           else
             printf("-0x%"NACL_PRIx64, -instruction->rm.offset);
         }
@@ skipping 174 matching lines @@
         } else {
           printf("%%es:(%%rdi)");
         }
         break;
       case REG_DS_RSI: if (((struct DecodeState *)userdata)->ia32_mode) {
           printf("%%ds:(%%esi)");
         } else {
           printf("%%ds:(%%rsi)");
         }
         break;
-      case JMP_TO: if (instruction->operands[0].type == OPERAND_SIZE_16_BIT)
+      case JMP_TO: if (instruction->operands[0].type == OPERAND_TYPE_16_BIT)
           printf("0x%lx", (long)((end + instruction->rm.offset -
                          (((struct DecodeState *)userdata)->offset)) & 0xffff));
         else
           printf("0x%lx", (long)(end + instruction->rm.offset -
                                    (((struct DecodeState *)userdata)->offset)));
         break;
       case REG_RIP:
       case REG_RIZ:
       case NO_REG:
         assert(FALSE);
@@ skipping 148 matching lines @@
   for (index = initial_index; index < argc; ++index) {
     const char *filename = argv[index];
     int rc = DecodeFile(filename, repeat_count);
     if (!rc) {
       printf("file '%s' can not be fully decoded\n", filename);
       return 1;
     }
   }
   return 0;
 }