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.

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

Will this change be in this CL or in a subsequent CL?

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

It'll be in subsequent CL. Or maybe (most probably) even in a few different
ones. decoder_test.c refactoring is way too big of a task to handle in this CL.
This file is only here to make sure code still compiles after all these changes.

The fact that this file is *NOT* moved out of "unreviewed" should give you a
clue.

  */
 void NaClLog(int detail_level, char const  *fmt, ...) {
   va_list ap;
 
   UNREFERENCED_PARAMETER(detail_level);
   va_start(ap, fmt);
   vfprintf(stderr, fmt, ap);
   exit(1);
 }
 
 static void CheckBounds(unsigned char *data, size_t data_size,

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

I don't understand what this function is for. Please comment or delete. When is
it to be used? Looks like it is never used.

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

It's used when we read the ELF file. But as I've said: refactoring of tests most
definitely should not happen in this CL.

                         void *ptr, size_t inside_size) {
   CHECK(data <= (unsigned char *) ptr);
   CHECK((unsigned char *) ptr + inside_size <= data + data_size);
 }
 
 void ReadImage(const char *filename, uint8_t **result, size_t *result_size) {

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

As a reader it's a bit frustrating to have a procedure with a very generic name
like this but no comment.

   FILE *fp;
   uint8_t *data;
   size_t file_size;
   size_t got;
 
   fp = fopen(filename, "rb");
   if (fp == NULL) {
     fprintf(stderr, "Failed to open input file: %s\n", filename);
     exit(1);
   }
@@ skipping 19 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/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
   _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;
@@ skipping 137 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) &&

[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") &&
             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") &&
             strcmp(instruction_name, "movhpd") &&
             strcmp(instruction_name, "movhps") &&
@@ skipping 117 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;
 }