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

src/trusted/validator/x86/ncval_reg_sfi/ncvalidate_iter.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.
  */
 
 /*
  * ncvalidate_iter.c
  * Validate x86 instructions for Native Client
  *
  */
 
 #include "native_client/src/trusted/validator/x86/ncval_reg_sfi/ncvalidate_iter.h"
 
 #include <assert.h>
 #include <string.h>
 
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/shared/platform/nacl_log.h"
 #include "native_client/src/trusted/validator/x86/decoder/ncop_exps.h"
 #include "native_client/src/trusted/validator/x86/decoder/nc_inst_state_internal.h"
-#include "native_client/src/trusted/validator/x86/decoder/nc_inst_iter.h"
+#include "native_client/src/trusted/validator/x86/decoder/nc_inst_iter_inl.h"
 #include "native_client/src/trusted/validator/x86/halt_trim.h"
 #include "native_client/src/trusted/validator/x86/nc_segment.h"
 #include "native_client/src/trusted/validator/x86/ncval_reg_sfi/ncvalidate_iter_internal.h"
 #include "native_client/src/trusted/validator/x86/ncval_reg_sfi/ncvalidator_registry.h"
 #include "native_client/src/trusted/validator/x86/ncval_reg_sfi/ncval_decode_tables.h"
 #include "native_client/src/trusted/validator/x86/ncval_reg_sfi/nc_jumps.h"
 #include "native_client/src/trusted/validator_x86/ncdis_decode_tables.h"
 
 /* To turn on debugging of instruction decoding, change value of
  * DEBUGGING to 1.
@@ skipping 524 matching lines @@
   if (NaClValidatorStateInitializeValidators(state)) {
     NCHaltTrimSegment(mbase, vbase, state->alignment, &size, &state->vlimit);
     NaClSegmentInitialize(mbase, vbase, size, &segment);
     do {
       iter = NaClInstIterCreateWithLookback(state->decoder_tables,
                                             &segment, kLookbackSize);
       if (NULL == iter) {
         NaClValidatorMessage(LOG_ERROR, state, "Not enough memory\n");
         break;
       }
-      for (; NaClInstIterHasNext(iter); NaClInstIterAdvance(iter)) {
-        state->cur_inst_state = NaClInstIterGetState(iter);
+      for (; NaClInstIterHasNextInline(iter); NaClInstIterAdvanceInline(iter)) {
+        state->cur_inst_state = NaClInstIterGetStateInline(iter);
         state->cur_inst = NaClInstStateInst(state->cur_inst_state);
         state->cur_inst_vector = NaClInstStateExpVector(state->cur_inst_state);
         NaClApplyValidators(state, iter);
         if (state->quit) break;
       }
       state->cur_inst_state = NULL;
       state->cur_inst = NULL;
       state->cur_inst_vector = NULL;
     } while (0);
     NaClApplyPostValidators(state, iter);
@@ skipping 49 matching lines @@
  * Return value: TRUE if the instruction was changed, FALSE if it's identical.
  */
 static Bool NaClValidateInstReplacement(NaClInstIter *iter_old,
                                         NaClInstIter *iter_new,
                                         struct NaClValidatorState *state) {
   NaClInstState *istate_old, *istate_new;
   NaClExpVector *exp_old, *exp_new;
   uint32_t i;
   Bool inst_changed = FALSE;
 
-  istate_old = NaClInstIterGetState(iter_old);
-  istate_new = NaClInstIterGetState(iter_new);
+  istate_old = NaClInstIterGetStateInline(iter_old);
+  istate_new = NaClInstIterGetStateInline(iter_new);
 
   /* Location/length must match */
   if (istate_new->vpc != istate_old->vpc ||
       istate_new->bytes.length != istate_old->bytes.length) {
     NaClValidatorTwoInstMessage(LOG_ERROR, state, istate_old, istate_new,
           "Code modification: instructions length/addresses do not match");
     inst_changed = TRUE;
     return inst_changed;
   }
 
@@ skipping 120 matching lines @@
   NaClValidatorStateInitializeValidators(state);
   NaClSegmentInitialize(mbase_old, vbase, size, &segment_old);
   NaClSegmentInitialize(mbase_new, vbase, size, &segment_new);
   do {
     iter_old = NaClInstIterCreateWithLookback(state->decoder_tables,
                                               &segment_old, kLookbackSize);
     if (NULL == iter_old) break;
     iter_new = NaClInstIterCreateWithLookback(state->decoder_tables,
                                               &segment_new, kLookbackSize);
     if (NULL == iter_new) break;
-    while (NaClInstIterHasNext(iter_old) &&
-           NaClInstIterHasNext(iter_new)) {
+    while (NaClInstIterHasNextInline(iter_old) &&
+           NaClInstIterHasNextInline(iter_new)) {
       Bool inst_changed;
-      state->cur_inst_state = NaClInstIterGetState(iter_new);
+      state->cur_inst_state = NaClInstIterGetStateInline(iter_new);
       state->cur_inst = NaClInstStateInst(state->cur_inst_state);
       state->cur_inst_vector = NaClInstStateExpVector(state->cur_inst_state);
       inst_changed = NaClValidateInstReplacement(iter_old, iter_new, state);
       if (inst_changed)
         NaClApplyValidators(state, iter_new);
       else
         NaClRememberIpOnly(state, iter_new);
       if (state->quit) break;
-      NaClInstIterAdvance(iter_old);
-      NaClInstIterAdvance(iter_new);
+      NaClInstIterAdvanceInline(iter_old);
+      NaClInstIterAdvanceInline(iter_new);
     }
-    if (NaClInstIterHasNext(iter_old) ||
-        NaClInstIterHasNext(iter_new)) {
+    if (NaClInstIterHasNextInline(iter_old) ||
+        NaClInstIterHasNextInline(iter_new)) {
       NaClValidatorMessage(
           LOG_ERROR, state,
           "Code modification: code segments have different "
           "number of instructions\n");
     }
   } while (0);
 
   state->cur_inst_state = NULL;
   state->cur_inst = NULL;
   state->cur_inst_vector = NULL;
   NaClApplyPostValidators(state, iter_new);
   NaClInstIterDestroy(iter_old);
   NaClInstIterDestroy(iter_new);
   NaClValidatorStatePrintStats(state);
 }