Move validator_x86_XX.rl out of unreviewed.

src/trusted/validator_ragel/unreviewed/decoder_test.c

Index: src/trusted/validator_ragel/unreviewed/decoder_test.c
===================================================================
--- src/trusted/validator_ragel/unreviewed/decoder_test.c	(revision 9911)
+++ src/trusted/validator_ragel/unreviewed/decoder_test.c	(working copy)
@@ -13,7 +13,7 @@
 #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
@@ -78,12 +78,12 @@
 };
 
 void ProcessInstruction(const uint8_t *begin, const uint8_t *end,

[Brad Chen, 2012/10/04 17:26:04]

This procedure is way too long. Please factor it into multiple functions;
ideally when you are done this will read as a sequence of procedure calls, eg.
void ProcessInstruction(...) {
  DoFirstImportantStep()
  DoSecondImportantStep()
  ...
}

Please apply this notion throughout this CL. A CL is not ready for review if it
includes procedures like this.

[Brad Chen, 2012/10/22 21:29:05]

Looks to me like you didn't take care of this requested change. I noticed you
pulled out fwait processing, which is a move in the right direction, but mostly
this procedure is still too hard to understand and to hard to maintain. 

Your thoughts?

On 2012/10/04 17:26:04, Brad Chen 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;
+  enum OperandName rm_index = instruction->rm.index;
+  enum OperandName rm_base = instruction->rm.base;
 #ifdef _MSC_VER
   Bool data16_prefix = instruction->prefix.data16;

[Brad Chen, 2012/10/04 17:26:04]

Again, it is really awful that you have to declare everything twice. Please
propose an alternative fix.

[khim, 2012/10/05 08:22:53]

Done.

 #else
@@ -243,9 +243,9 @@
         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 {
@@ -254,30 +254,29 @@
                 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 {
@@ -291,40 +290,39 @@
                  (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;
         }
@@ -347,46 +345,45 @@
            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)) {
@@ -410,7 +407,7 @@
           ++rex_bits;
         }
       }
-      if ((instruction->operands[i].type == OPERAND_SIZE_64_BIT) &&
+      if ((instruction->operands[i].type == OPERAND_TYPE_64_BIT) &&

[Brad Chen, 2012/10/22 21:29:05]

The disappearance of this next large block of code is an example of why
procedures would make it much easier for other people to help maintain this
code. I note that references to the string "callq" have disappeared in your last
patch, but I have not idea where they went. If this code were in a procedure
with a useful name like "spurious_rex_prefix =
IdentifySpuriousRexPrefixCases(...) reading and understanding might be easier.

Does this make sense? Does it seem reasonable?

                                                                 !rexw_counted) {
         if (strcmp(instruction_name, "callq") &&

[Brad Chen, 2012/10/04 17:26:04]

Please break this if statement out into its own function. Give it a name so it
is obvious to a casual reader what it does. Think about whether there is a
better option than this if statement for implementing this functionality.

             strcmp(instruction_name, "cmpxchg8b") &&
@@ -550,12 +547,12 @@
           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;
@@ -567,7 +564,7 @@
   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';
@@ -578,7 +575,7 @@
        !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';
@@ -587,7 +584,7 @@
   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';
@@ -804,7 +801,7 @@
   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") ||
@@ -889,7 +886,7 @@
   }
   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");
     }
   }
@@ -987,320 +984,320 @@
        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: {
@@ -1495,7 +1492,7 @@
           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