Speed up x86-64 validator by inlining heavily called routines. Speeds up

src/trusted/validator/x86/decoder/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.
  */
 
 /*
  * 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.
  */
 
 #ifndef NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_X86_DECODER_NC_INST_STATE_STATICS_C__
 #define NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_X86_DECODER_NC_INST_STATE_STATICS_C__
 
 #include <stdio.h>
 #include <assert.h>
 #include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/shared/utils/debugging.h"
 #include "native_client/src/trusted/validator/x86/decoder/nc_decode_tables.h"
 #include "native_client/src/trusted/validator/x86/decoder/nc_inst_iter.h"
 #include "native_client/src/trusted/validator/x86/decoder/nc_inst_state_internal.h"
 #include "native_client/src/trusted/validator/x86/decoder/nc_inst_trans.h"
 #include "native_client/src/trusted/validator/x86/decoder/ncop_exps.h"
 #include "native_client/src/trusted/validator/x86/decoder/ncopcode_desc.h"
 #include "native_client/src/trusted/validator/x86/nc_segment.h"
+#include "native_client/src/trusted/validator/x86/x86_insts_inl.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->decoder_tables = iter->decoder_tables;
@@ skipping 403 matching lines @@
     /* 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 (modrm_modInline(byte) == 0x3) {
       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 (NaClHasBit(state->inst->flags, NACL_IFLAG(ModRmModIs0x3))) {
         DEBUG(NaClLog(LOG_INFO, "Can't match, modrm mod field not 0x3\n"));
         return FALSE;
       }
     }
     if ((NaClHasBit(state->inst->flags, NACL_IFLAG(ModRmRegSOperand))) &&
-        (modrm_reg(byte) > 5)) {
+        (modrm_regInline(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;
     DEBUG(NaClLog(LOG_INFO, "consume modrm = %02"NACL_PRIx8"\n", state->modrm));
 
     /* Consume the remaining opcode value in the mod/rm byte
      * if applicable.
      */
     if (state->inst->flags & NACL_IFLAG(OpcodeInModRm)) {
       const NaClInst* inst = state->inst;
-      if (modrm_opcode(state->modrm) !=
+      if (modrm_opcodeInline(state->modrm) !=
           NaClGetOpcodeInModRm(inst->opcode_ext)) {
         DEBUG(
             NaClLog(LOG_INFO,
                     "Discarding, opcode in mrm byte (%02"NACL_PRIx8") "
                     "does not match\n",
-                    modrm_opcode(state->modrm)));
+                    modrm_opcodeInline(state->modrm)));
         return FALSE;
       }
       if (state->inst->flags & NACL_IFLAG(OpcodeInModRmRm)) {
-        if (modrm_rm(state->modrm) !=
+        if (modrm_rmInline(state->modrm) !=
             NaClGetOpcodeInModRmRm(inst->opcode_ext)) {
           DEBUG(NaClLog(LOG_INFO,
                         "Discarding, opcode in mrm rm field (%02"NACL_PRIx8") "
                         "does not match\n",
-                        modrm_rm(state->modrm)));
+                        modrm_rmInline(state->modrm)));
           return FALSE;
         }
       }
     }
   }
   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 (Bool)
       (NaClInstRequiresModRm(state) && (16 != state->address_size) &&
-       (modrm_rm(state->modrm) == 0x04 && modrm_mod(state->modrm) != 0x3));
+       (modrm_rmInline(state->modrm) ==
+        0x04 && modrm_modInline(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.
    */
   state->sib = 0;
   state->has_sib = NaClInstRequiresSib(state);
   DEBUG(NaClLog(LOG_INFO, "has sib = %d\n", (int) state->has_sib));
   if (state->has_sib) {
     if (state->bytes.length >= state->length_limit) {
       DEBUG(NaClLog(LOG_INFO, "Can't consume sib, no more bytes!\n"));
       return FALSE;
     }
     /* Read the SIB byte and record. */
     state->sib = NCInstBytesRead(&state->bytes);
     DEBUG(NaClLog(LOG_INFO, "sib = %02"NACL_PRIx8"\n", state->sib));
-    if (sib_base(state->sib) == 0x05 && modrm_mod(state->modrm) > 2) {
+    if (sib_base(state->sib) == 0x05 && modrm_modInline(state->modrm) > 2) {
       DEBUG(NaClLog(LOG_INFO,
                     "Sib byte implies modrm.mod field <= 2, match fails\n"));
       return FALSE;
     }
   }
   return TRUE;
 }
 
 static int NaClGetNumDispBytes(NaClInstState* state) {
   if (NaClInstRequiresModRm(state)) {
     if (16 == state->address_size) {
       /* Corresponding to table 2-1 of the Intel manual. */
-      switch (modrm_mod(state->modrm)) {
+      switch (modrm_modInline(state->modrm)) {
         case 0x0:
-          if (modrm_rm(state->modrm) == 0x06) {
+          if (modrm_rmInline(state->modrm) == 0x06) {
             return 4;  /* disp16 */
           }
           break;
         case 0x1:
           return 1;    /* disp8 */
         case 0x2:
           return 2;    /* disp16 */
         default:
           break;
       }
     } else {
       /* Note: in 64-bit mode, 64-bit addressing is treated the same as 32-bit
        * addressing. Hence, this section covers the 32-bit addressing.
        */
-      switch(modrm_mod(state->modrm)) {
+      switch(modrm_modInline(state->modrm)) {
         case 0x0:
-          if (modrm_rm(state->modrm) == 0x05) {
+          if (modrm_rmInline(state->modrm) == 0x05) {
             return 4;  /* disp32 */
           } else if (state->has_sib && sib_base(state->sib) == 0x5) {
             return 4;
           }
           break;
         case 0x1:
           return 1;    /* disp8 */
         case 0x2:
           return 4;    /* disp32 */
         default:
@@ skipping 342 matching lines @@
     state->inst = matching_inst;
     NCInstBytesReadBytes(matching_length, &state->bytes);
     DEBUG(NaClLog(LOG_INFO, "matched inst sequence [%d]!\n", matching_length));
     return TRUE;
   }
 }
 
 EXTERN_C_END
 
 #endif   /* NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_X86_DECODER_NC_INST_STATE_STATICS_C__ */