Start unit testing for functions in nc_inst_state.c

src/trusted/validator_x86/nc_inst_state_statics.c

 /*
  * Copyright (c) 2011 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.
  */
 
 /*
- * Defines an instruction (decoder), based on the current location of
- * the instruction iterator. The instruction decoder takes a list
- * of candidate opcode (instruction) patterns, and searches for the
- * first candidate that matches the requirements of the opcode pattern.
+ * This file contains includes, static functions, and constants that are used
+ * in nc_inst_state.c, but have been factored out and put into this file, so
+ * that we can test them. That is, to allow nc_inst_state.c and
+ * nc_inst_state_Tests.cc to use them.
  */
 
 #include <stdio.h>
 #include <assert.h>
-
-#include "native_client/src/trusted/validator_x86/nc_inst_state.h"
-
 #include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/trusted/validator_x86/nc_inst_iter.h"
 #include "native_client/src/trusted/validator_x86/nc_inst_state_internal.h"
 #include "native_client/src/trusted/validator_x86/nc_inst_trans.h"
 #include "native_client/src/trusted/validator_x86/nc_segment.h"
 #include "native_client/src/trusted/validator_x86/ncop_exps.h"
 #include "native_client/src/trusted/validator_x86/ncopcode_desc.h"
 #ifdef _WIN64
 #include "gen/native_client/src/trusted/validator_x86/nc_opcode_table64.h"
 #else
 #include "gen/native_client/src/trusted/validator_x86/nc_opcode_table.h"
 #endif
-
-/* To turn on debugging of instruction decoding, change value of
- * DEBUGGING to 1.
- */
-#define DEBUGGING 0
+#include "native_client/src/trusted/validator_x86/RexPrefixes.h"
 
 #include "native_client/src/shared/utils/debugging.h"
 
+EXTERN_C_BEGIN
+
 /* Given the current location of the instruction iterator, initialize
  * the given state (to match).
  */
 static void NaClInstStateInit(NaClInstIter* iter, NaClInstState* state) {
   NaClMemorySize limit;
   NCInstBytesInit(&state->bytes);
   state->vpc = iter->segment->vbase + iter->index;
   limit = iter->segment->size - iter->index;
   if (limit > NACL_MAX_BYTES_PER_X86_INSTRUCTION) {
     limit = NACL_MAX_BYTES_PER_X86_INSTRUCTION;
@@ skipping 17 matching lines @@
   state->prefix_mask = 0;
   state->inst = NULL;
   state->nodes.is_defined = FALSE;
   state->nodes.number_expr_nodes = 0;
 }
 
 /* Computes the number of bytes defined for operands of the matched
  * instruction of the given state.
  */
 static int NaClExtractOpSize(NaClInstState* state) {
-  if (state->inst->flags & NACL_IFLAG(OperandSize_b)) {
+  if (NaClHasBit(state->inst->flags, NACL_IFLAG(OperandSize_b))) {
     return 1;
   }
   if (NACL_TARGET_SUBARCH == 64) {
-    if ((state->rexprefix && state->rexprefix & 0x8) ||
-        (state->inst->flags & NACL_IFLAG(OperandSizeForce64))) {
+    if ((state->rexprefix && NaClRexW(state->rexprefix)) ||
+        (NaClHasBit(state->inst->flags, NACL_IFLAG(OperandSizeForce64)))) {
       return 8;
     }
   }
-  if ((state->prefix_mask & kPrefixDATA16) &&
+  if (NaClHasBit(state->prefix_mask, kPrefixDATA16) &&
       (NACL_EMPTY_IFLAGS ==
        (state->inst->flags & NACL_IFLAG(SizeIgnoresData16)))) {
     return 2;
   }
   if ((NACL_TARGET_SUBARCH == 64) &&
-      (state->inst->flags & NACL_IFLAG(OperandSizeDefaultIs64))) {
+      NaClHasBit(state->inst->flags, NACL_IFLAG(OperandSizeDefaultIs64))) {
     return 8;
   }
   return 4;
 }
 
 /* Computes the number of bits defined for addresses of the matched
  * instruction of the given state.
  */
 static int NaClExtractAddressSize(NaClInstState* state) {
   if (NACL_TARGET_SUBARCH == 64) {
-    return (state->prefix_mask & kPrefixADDR16) ? 32 : 64;
+    return NaClHasBit(state->prefix_mask, kPrefixADDR16) ? 32 : 64;
   } else {
-    return (state->prefix_mask & kPrefixADDR16) ? 16 : 32;
+    return NaClHasBit(state->prefix_mask, kPrefixADDR16) ? 16 : 32;
   }
 }
 
 /* Manual implies only 4 bytes is allowed, but I have found up to 6.
  * Why don't we allow any number, so long as (1) There is room for
  * at least one opcode byte, and (2) we don't exceed the max bytes.
  */
 static const int kNaClMaximumPrefixBytes =
     NACL_MAX_BYTES_PER_X86_INSTRUCTION - 1;
 
@@ skipping 61 matching lines @@
   if (NACL_TARGET_SUBARCH == 64) {
     /* REX prefix must be last, unless FO exists. If FO
      * exists, it must be after REX (Intel Manual).
      *
      * NOTE: (karl) It appears that this constraint is violated
      * with compiled code of /bin/ld_static. According to AMD,
      * the rex prefix must be last. Changing code to allow REX
      * prefix to occur anywhere.
      */
     if (rex_index >= 0) {
-      return (rex_index + 1) == state->num_prefix_bytes;
+      return (Bool) ((rex_index + 1) == state->num_prefix_bytes);
     }
   }
   return TRUE;
 }
 
-/* Structure holding the results of consuming the opcode bytes of the
- * instruction.
- */
-typedef struct {
-  /* The (last) byte of the matched opcode. */
-  uint8_t opcode_byte;
-  /* The most specific prefix that the opcode bytes can match
-   * (or OpcodePrefixEnumSize if no such patterns exist).
-   */
-  NaClInstPrefix matched_prefix;
-  /* The number of bytes to subtract from the instruction length,
-   * the next time GetNextNaClInstCandidates is called.
-   */
-  uint8_t next_length_adjustment;
-} NaClInstPrefixDescriptor;
-
 /* Assuming we have matched the byte sequence OF 38, consume the corresponding
  * following (instruction) opcode byte, returning the most specific prefix the
  * patterns can match (or NaClInstPrefixEnumSize if no such patterns exist);
  */
 static void NaClConsume0F38XXNaClInstBytes(NaClInstState* state,
                                            NaClInstPrefixDescriptor* desc) {
   /* Fail if there are no more bytes. Otherwise, read the next
    * byte.
    */
   if (state->bytes.length >= state->length_limit) {
     desc->matched_prefix = NaClInstPrefixEnumSize;
     return;
   }
 
   desc->opcode_byte = NCInstBytesRead(&state->bytes);
-  if (state->prefix_mask & kPrefixREPNE) {
-    desc->matched_prefix = PrefixF20F38;
+  DEBUG(NaClLog(LOG_INFO, "Consume inst byte %02"NACL_PRIx8".\n",
+                desc->opcode_byte));
+  if (NaClExcludesBit(state->prefix_mask, kPrefixREP)) {
+    if (NaClHasBit(state->prefix_mask, kPrefixREPNE)) {
+      /* Note: Flag OpcodeAllowsData16 will explicitly clarify
+       * ambigous case of both REP and DATA16 prefixes.
+       */
+      desc->matched_prefix = PrefixF20F38;
+    } else if (NaClHasBit(state->prefix_mask, kPrefixDATA16)) {
+      desc->matched_prefix = Prefix660F38;
+    } else {
+      desc->matched_prefix = Prefix0F38;
+    }
+    return;
   }
-  else if (state->prefix_mask & kPrefixDATA16) {
-    desc->matched_prefix = Prefix660F38;
-  } else if ((state->prefix_mask & ~kPrefixREX) == 0) {
-    desc->matched_prefix = Prefix0F38;
-  } else {
-    /* Other prefixes like F3 cause an undefined instruction error. */
-    desc->matched_prefix = NaClInstPrefixEnumSize;
-  }
+  /* If reached, can't match special prefixes, fail. */
+  desc->matched_prefix = NaClInstPrefixEnumSize;
 }
 
 /* Assuming we have matched the byte sequence OF 3A, consume the corresponding
  * following (instruction) opcode byte, returning the most specific prefix the
  * patterns can match (or NaClInstPrefixEnumSize if no such patterns exist).
  */
 static void NaClConsume0F3AXXNaClInstBytes(NaClInstState* state,
                                            NaClInstPrefixDescriptor* desc) {
   /* Fail if there are no more bytes. Otherwise, read the next
    * byte and choose appropriate prefix.
    */
   if (state->bytes.length >= state->length_limit) {
     desc->matched_prefix = NaClInstPrefixEnumSize;
     return;
   }
 
   desc->opcode_byte = NCInstBytesRead(&state->bytes);
-  if (state->prefix_mask & kPrefixDATA16) {
-    desc->matched_prefix = Prefix660F3A;
-  } else if ((state->prefix_mask & ~kPrefixREX) == 0) {
-    desc->matched_prefix = Prefix0F3A;
-  } else {
-    /* Other prefixes like F3 cause an undefined instruction error. */
-    desc->matched_prefix = NaClInstPrefixEnumSize;
+  DEBUG(NaClLog(LOG_INFO, "Consume inst byte %02"NACL_PRIx8".\n",
+                desc->opcode_byte));
+  if (NaClExcludesBit(state->prefix_mask, kPrefixREP) &&
+      NaClExcludesBit(state->prefix_mask, kPrefixREPNE)) {
+    if (NaClHasBit(state->prefix_mask, kPrefixDATA16)) {
+      desc->matched_prefix = Prefix660F3A;
+    } else {
+      desc->matched_prefix = Prefix0F3A;
+    }
+    return;
   }
+  /* If reached, can't match special prefixes, fail. */
+  desc->matched_prefix = NaClInstPrefixEnumSize;
 }
 
 /* Assuming we have matched byte OF, consume the corresponding
  * following (instruction) opcode byte, returning the most specific
  * prefix the patterns can match (or NaClInstPrefixEnumSize if no such
  * patterns exist).
  */
 static void NaClConsume0FXXNaClInstBytes(NaClInstState* state,
                                          NaClInstPrefixDescriptor* desc) {
-  if (state->prefix_mask & kPrefixREPNE) {
-    desc->matched_prefix = PrefixF20F;
-  } else if (state->prefix_mask & kPrefixREP) {
-    desc->matched_prefix = PrefixF30F;
-  } else if (state->prefix_mask & kPrefixDATA16) {
-    desc->matched_prefix = Prefix660F;
+  if (NaClHasBit(state->prefix_mask, kPrefixREPNE)) {
+    if (NaClExcludesBit(state->prefix_mask, kPrefixREP)) {
+      /* Note: Flag OpcodeAllowsData16 will explicitly clarify
+       * ambigous case of both REPNE and DATA16 prefixes.
+       */
+      desc->matched_prefix = PrefixF20F;
+      return;
+    }
   } else {
-    desc->matched_prefix = Prefix0F;
+    if (NaClHasBit(state->prefix_mask, kPrefixREP)) {
+      /* Note: Flag OpcodeAllowsData16 will explicitly clarify
+       * ambigous case of both REP and DATA16 prefixes.
+       */
+      desc->matched_prefix = PrefixF30F;
+    } else if (NaClHasBit(state->prefix_mask, kPrefixDATA16)) {
+      desc->matched_prefix = Prefix660F;
+    } else {
+      desc->matched_prefix = Prefix0F;
+    }
+    return;
   }
+  /* If reached, can't match special prefixes, fail. */
+  desc->matched_prefix = NaClInstPrefixEnumSize;
 }
 
 /* Consume one of the x87 instructions that begin with D8-Df, and
  * match the most specific prefix pattern the opcode bytes can match.
  */
 static void NaClConsumeX87NaClInstBytes(NaClInstState* state,
                                         NaClInstPrefixDescriptor* desc) {
   if (state->bytes.length < state->length_limit) {
     /* Can be two byte opcode. */
-    desc->matched_prefix = PrefixD8 +
-        (((unsigned) desc->opcode_byte) - 0xD8);
+    desc->matched_prefix =
+        (NaClInstPrefix) (PrefixD8 +
+                          (((unsigned) desc->opcode_byte) - 0xD8));
     desc->opcode_byte = NCInstBytesRead(&state->bytes);
+    DEBUG(NaClLog(LOG_INFO, "Consume inst byte %02"NACL_PRIx8".\n",
+                  desc->opcode_byte));
     return;
   }
 
   /* If reached, can only be single byte opcode, match as such. */
   desc->matched_prefix = NoPrefix;
 }
 
 /* Consume the opcode bytes, and return the most specific prefix pattern
  * the opcode bytes can match (or NaClInstPrefixEnumSize if no such pattern
  * exists).
  */
 static void NaClConsumeInstBytes(NaClInstState* state,
                                  NaClInstPrefixDescriptor* desc) {
 
   /* Initialize descriptor to the fail state. */
   desc->opcode_byte = 0x0;
   desc->matched_prefix = NaClInstPrefixEnumSize;
   desc->next_length_adjustment = 0;
 
   /* Be sure that we don't exceed the segment length. */
   if (state->bytes.length >= state->length_limit) return;
 
   desc->opcode_byte = NCInstBytesRead(&state->bytes);
+  DEBUG(NaClLog(LOG_INFO, "Consume inst byte %02"NACL_PRIx8".\n",
+                desc->opcode_byte));
   switch (desc->opcode_byte) {
     case 0x0F:
       if (state->bytes.length >= state->length_limit) return;
       desc->opcode_byte = NCInstBytesRead(&state->bytes);
+      DEBUG(NaClLog(LOG_INFO, "Consume inst byte %02"NACL_PRIx8".\n",
+                    desc->opcode_byte));
       switch (desc->opcode_byte) {
         case 0x38:
           NaClConsume0F38XXNaClInstBytes(state, desc);
           break;
         case 0x3a:
           NaClConsume0F3AXXNaClInstBytes(state, desc);
           break;
         default:
           NaClConsume0FXXNaClInstBytes(state, desc);
           break;
@@ skipping 25 matching lines @@
 static Bool NaClConsumeAndCheckOperandSize(NaClInstState* state) {
   state->operand_size = NaClExtractOpSize(state);
   DEBUG(NaClLog(LOG_INFO,
                 "operand size = %"NACL_PRIu8"\n", state->operand_size));
   if (state->inst->flags &
       (NACL_IFLAG(OperandSize_w) | NACL_IFLAG(OperandSize_v) |
        NACL_IFLAG(OperandSize_o))) {
     NaClIFlags good = 1;
     switch (state->operand_size) {
       case 2:
-        good = (state->inst->flags & NACL_IFLAG(OperandSize_w));
+        good = NaClHasBit(state->inst->flags, NACL_IFLAG(OperandSize_w));
         break;
       case 4:
-        good = (state->inst->flags & NACL_IFLAG(OperandSize_v));
+        good = NaClHasBit(state->inst->flags, NACL_IFLAG(OperandSize_v));
         break;
       case 8:
-        good = (state->inst->flags & NACL_IFLAG(OperandSize_o));
+        good = NaClHasBit(state->inst->flags, NACL_IFLAG(OperandSize_o));
         break;
       default:
         good = 0;
         break;
     }
     if (!good) {
       /* The flags associated with the opcode (instruction) don't
        * allow the computed sizes, abort the  match of the instruction.
        */
       DEBUG(NaClLog(LOG_INFO,
                     "Operand size %"NACL_PRIu8
                     " doesn't match flag requirement!\n",
                     state->operand_size));
       return FALSE;
     }
   }
   return TRUE;
 }
 
 static Bool NaClConsumeAndCheckAddressSize(NaClInstState* state) {
   state->address_size = NaClExtractAddressSize(state);
   DEBUG(NaClLog(LOG_INFO,
                 "Address size = %"NACL_PRIu8"\n", state->address_size));
   if (state->inst->flags &
       (NACL_IFLAG(AddressSize_w) | NACL_IFLAG(AddressSize_v) |
        NACL_IFLAG(AddressSize_o))) {
     NaClIFlags good = 1;
     switch (state->address_size) {
     case 16:
-      good = (state->inst->flags & NACL_IFLAG(AddressSize_w));
+      good = NaClHasBit(state->inst->flags, NACL_IFLAG(AddressSize_w));
       break;
     case 32:
-      good = (state->inst->flags & NACL_IFLAG(AddressSize_v));
+      good = NaClHasBit(state->inst->flags, NACL_IFLAG(AddressSize_v));
       break;
     case 64:
-      good = (state->inst->flags & NACL_IFLAG(AddressSize_o));
+      good = NaClHasBit(state->inst->flags, NACL_IFLAG(AddressSize_o));
       break;
     default:
       good = 0;
       break;
     }
     if (!good) {
       /* The flags associated with the opcode (instruction) don't
        * allow the computed sizes, abort the  match of the instruction.
        */
       DEBUG(NaClLog(LOG_INFO,
                     "Address size %"NACL_PRIu8
                     " doesn't match flag requirement!\n",
                     state->address_size));
       return FALSE;
     }
   }
   return TRUE;
 }
 
 /* Returns true if the instruction requires a ModRm bytes. */
 static Bool NaClInstRequiresModRm(NaClInstState* state) {
-  return
+  return (Bool)
       (NACL_EMPTY_IFLAGS !=
        (state->inst->flags & NACL_IFLAG(OpcodeUsesModRm)));
 }
 
 /* Consume the Mod/Rm byte of the instruction, if applicable.
  * Aborts the pattern match if any problems.
  */
 static Bool NaClConsumeModRm(NaClInstState* state) {
   /* First check if the opcode (instruction) pattern specifies that
    * a Mod/Rm byte is needed, and that reading it will not walk
    * past the end of the code segment.
    */
   if (NaClInstRequiresModRm(state)) {
     uint8_t byte;
     /* Has modrm byte. */
     if (state->bytes.length >= state->length_limit) {
       DEBUG(NaClLog(LOG_INFO, "Can't read mod/rm, no more bytes!\n"));
       return FALSE;
     }
     byte = NCInstBytesPeek(&state->bytes, 0);
 
     /* Note: Some instructions only allow values where the ModRm mod field
      * is 0x3. Others only allow values where the ModRm mod field isn't 0x3.
      */
     if (modrm_mod(byte) == 0x3) {
-      if (state->inst->flags & NACL_IFLAG(ModRmModIsnt0x3)) {
+      if (NaClHasBit(state->inst->flags, NACL_IFLAG(ModRmModIsnt0x3))) {
         DEBUG(NaClLog(LOG_INFO, "Can't match, modrm mod field is 0x3\n"));
         return FALSE;
       }
     } else {
-      if (state->inst->flags & NACL_IFLAG(ModRmModIs0x3)) {
+      if (NaClHasBit(state->inst->flags, NACL_IFLAG(ModRmModIs0x3))) {
         DEBUG(NaClLog(LOG_INFO, "Can't match, modrm mod field not 0x3\n"));
         return FALSE;
       }
     }
-    if ((state->inst->flags & NACL_IFLAG(ModRmRegSOperand)) &&
+    if ((NaClHasBit(state->inst->flags, NACL_IFLAG(ModRmRegSOperand))) &&
         (modrm_reg(byte) > 5)) {
       DEBUG(NaClLog(LOG_INFO,
                     "Can't match, modrm reg field doesn't index segment\n"));
       return FALSE;
     }
     state->modrm = NCInstBytesRead(&state->bytes);
     state->num_disp_bytes = 0;
     state->first_disp_byte = 0;
     state->sib = 0;
     state->has_sib = FALSE;
@@ skipping 26 matching lines @@
   }
   return TRUE;
 }
 
 /* Returns true if the instruction requires a SIB bytes. */
 static Bool NaClInstRequiresSib(NaClInstState* state) {
   /* Note: in 64-bit mode, 64-bit addressing is treated the same as 32-bit
    * addressing. Hence, required for all but 16-bit addressing, when
    * the right modrm bytes are specified.
    */
-  return NaClInstRequiresModRm(state) && (16 != state->address_size) &&
-      (modrm_rm(state->modrm) == 0x04 && modrm_mod(state->modrm) != 0x3);
+  return (Bool)
+      (NaClInstRequiresModRm(state) && (16 != state->address_size) &&
+       (modrm_rm(state->modrm) == 0x04 && modrm_mod(state->modrm) != 0x3));
 }
 
 /* Consume the SIB byte of the instruction, if applicable. Aborts the pattern
  * match if any problems are found.
  */
 static Bool NaClConsumeSib(NaClInstState* state) {
   /* First check that the opcode (instruction) pattern specifies that
    * a SIB byte is needed, and that reading it will not walk past
    * the end of the code segment.
    */
@@ skipping 334 matching lines @@
      * using opcode sequences have no (useful) operands, and hence
      * no additional information is needed.
      */
     state->inst = matching_inst;
     NCInstBytesReadBytes(matching_length, &state->bytes);
     DEBUG(NaClLog(LOG_INFO, "matched inst sequence [%d]!\n", matching_length));
     return TRUE;
   }
 }
 
-/* Given the current location of the (relative) pc of the given instruction
- * iterator, update the given state to hold the (found) matched opcode
- * (instruction) pattern. If no matching pattern exists, set the state
- * to a matched undefined opcode (instruction) pattern. In all cases,
- * update the state to hold all information on the matched bytes of the
- * instruction. Note: The iterator expects that the opcode field is
- * changed from NULL to non-NULL by this fuction.
- */
-void NaClDecodeInst(NaClInstIter* iter, NaClInstState* state) {
-  uint8_t opcode_length = 0;
-  const NaClInst* cand_insts;
-  Bool found_match = FALSE;
-  /* Start by consuming the prefix bytes, and getting the possible
-   * candidate opcode (instruction) patterns that can match, based
-   * on the consumed opcode bytes.
-   */
-  NaClInstStateInit(iter, state);
-  if (NaClConsumeOpcodeSequence(state)) {
-    found_match = TRUE;
-  } else if (NaClConsumePrefixBytes(state)) {
-    NaClInstPrefixDescriptor prefix_desc;
-    Bool continue_loop = TRUE;
-    NaClConsumeInstBytes(state, &prefix_desc);
-    opcode_length = state->bytes.length;
-    while (continue_loop) {
-      /* Try matching all possible candidates, in the order they are specified
-       * (from the most specific prefix match, to the least specific prefix
-       * match). Quit when the first pattern is matched.
-       */
-      if (prefix_desc.matched_prefix == NaClInstPrefixEnumSize) {
-        continue_loop = FALSE;
-      } else {
-        cand_insts = NaClGetNextInstCandidates(state, &prefix_desc,
-                                               &opcode_length);
-        while (cand_insts != NULL) {
-          NaClClearInstState(state, opcode_length);
-          state->inst = cand_insts;
-          DEBUG(NaClLog(LOG_INFO, "try opcode pattern:\n"));
-          DEBUG(NaClInstPrint(NaClLogGetGio(), state->inst));
-          if (NaClConsumeAndCheckOperandSize(state) &&
-              NaClConsumeAndCheckAddressSize(state) &&
-              NaClConsumeModRm(state) &&
-              NaClConsumeSib(state) &&
-              NaClConsumeDispBytes(state) &&
-              NaClConsumeImmediateBytes(state) &&
-              NaClValidatePrefixFlags(state)) {
-            if (state->inst->flags & NACL_IFLAG(Opcode0F0F) &&
-                /* Note: If all of the above code worked correctly,
-                 * there should be no need for the following test.
-                 * However, just to be safe, it is added.
-                 */
-                (state->num_imm_bytes == 1)) {
-              /* Special 3DNOW instructions where opcode is in parsed
-               * immediate byte at end of instruction. Look up in table,
-               * and replace if found. Otherwise, let the default 0F0F lookup
-               * act as the matching (invalid) instruction.
-               */
-              const NaClInst* cand_inst;
-              uint8_t opcode_byte = state->bytes.byte[state->first_imm_byte];
-              DEBUG(NaClLog(LOG_INFO,
-                            "NaClConsume immediate byte opcode char: %"
-                            NACL_PRIx8"\n", opcode_byte));
-              cand_inst = g_OpcodeTable[Prefix0F0F][opcode_byte];
-              if (NULL != cand_inst) {
-                state->inst = cand_inst;
-                DEBUG(NaClLog(LOG_INFO, "Replace with 3DNOW opcode:\n"));
-                DEBUG(NaClInstPrint(NaClLogGetGio(), state->inst));
-              }
-            }
-            /* found a match, exit loop. */
-            found_match = TRUE;
-            continue_loop = FALSE;
-            break;
-          } else {
-            /* match failed, try next candidate pattern. */
-            cand_insts = cand_insts->next_rule;
-          }
-        }
-        DEBUG(if (! found_match) {
-            NaClLog(LOG_INFO, "no more candidates for this prefix\n");
-          });
-      }
-    }
-  }
-
-  /* If we did not match a defined opcode, match the undefined opcode,
-   * forcing field opcode to be non-NULL.
-   */
-  if (!found_match) {
-    DEBUG(NaClLog(LOG_INFO, "no instruction found, converting to undefined\n"));
-
-    /* Can't figure out instruction, give up. */
-    NaClClearInstState(state, opcode_length);
-    state->inst = &g_Undefined_Opcode;
-    if (state->bytes.length == 0 && state->bytes.length < state->length_limit) {
-      /* Make sure we eat at least one byte. */
-      NCInstBytesRead(&state->bytes);
-    }
-  }
-}
-
-const NaClInst* NaClInstStateInst(NaClInstState* state) {
-  return state->inst;
-}
-
-NaClPcAddress NaClInstStateVpc(NaClInstState* state) {
-  return state->vpc;
-}
-
-NaClExpVector* NaClInstStateExpVector(NaClInstState* state) {
-  if (!state->nodes.is_defined) {
-    state->nodes.is_defined = TRUE;
-    NaClBuildExpVector(state);
-  }
-  return &state->nodes;
-}
-
-Bool NaClInstStateIsValid(NaClInstState* state) {
-  return InstInvalid != state->inst->name;
-}
-
-uint8_t NaClInstStateLength(NaClInstState* state) {
-  return state->bytes.length;
-}
-
-uint8_t NaClInstStateByte(NaClInstState* state, uint8_t index) {
-  assert(index < state->bytes.length);
-  return state->bytes.byte[index];
-}
-
-uint8_t NaClInstStateOperandSize(NaClInstState* state) {
-  return state->operand_size;
-}
-
-uint8_t NaClInstStateAddressSize(NaClInstState* state) {
-  return state->address_size;
-}
-
-void NaClChangeOpcodesToXedsModel() {
-  /* Changes opcodes to match xed. That is change:
-   * 0f0f..1c: Pf2iw $Pq, $Qq => 0f0f..2c: Pf2iw $Pq, $Qq
-   * 0f0f..1d: Pf2id $Pq, $Qq => 0f0f..2d: Pf2id $Pq, $Qq
-   */
-  g_OpcodeTable[Prefix0F0F][0x2c] = g_OpcodeTable[Prefix0F0F][0x1c];
-  g_OpcodeTable[Prefix0F0F][0x1c] = NULL;
-  g_OpcodeTable[Prefix0F0F][0x2d] = g_OpcodeTable[Prefix0F0F][0x1d];
-  g_OpcodeTable[Prefix0F0F][0x1d] = NULL;
-}
+EXTERN_C_END