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

src/trusted/validator/x86/decoder/ncop_exps.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.
  */
 
 #include "native_client/src/trusted/validator/x86/decoder/ncop_exps.h"
 
 #include <stdio.h>
 #include <ctype.h>
@@ skipping 13 matching lines @@
  * DEBUGGING to 1.
  *
  * WARNING: Debugging messages inside of print messages must be sent to the
  * same gio stream as being printed, since they may be used by another
  * nacl log message that has locked the access to NaClLogGetGio().
  */
 #define DEBUGGING 0
 
 #include "native_client/src/shared/utils/debugging.h"
 
+#include "native_client/src/trusted/validator/x86/decoder/ncopcode_desc_inl.c"
+#include "native_client/src/trusted/validator/x86/decoder/ncop_exps_inl.c"
+
 void NaClPrintExpFlags(struct Gio* file, NaClExpFlags flags) {
   if (flags == 0) {
     gprintf(file, "0");
   } else {
     NaClExpFlag f;
     Bool is_first = TRUE;
     for (f = 0; f < NaClExpFlagEnumSize; f++) {
       if (flags & NACL_EFLAG(f)) {
         if (is_first) {
           is_first = FALSE;
@@ skipping 25 matching lines @@
   {ExprMemOffset, 4},
 };
 
 int NaClExpKindRank(NaClExpKind kind) {
   assert(kind == g_NaClExpKindDesc[kind].name);
   return g_NaClExpKindDesc[kind].rank;
 }
 
 /* Returns the register defined by the given node. */
 NaClOpKind NaClGetExpRegister(NaClExp* node) {
-  assert(node->kind == ExprRegister);
-  return (NaClOpKind) node->value;
+  return NaClGetExpRegisterInline(node);
 }
 
 /* Returns the name of the register defined by the indexed node in the
  * vector of nodes.
  */
 NaClOpKind NaClGetExpVectorRegister(NaClExpVector* vector,
                                     int node) {
-  return NaClGetExpRegister(&vector->node[node]);
+  return NaClGetExpRegisterInline(&vector->node[node]);
 }
 
 static int NaClPrintDisassembledExp(struct Gio* file,
                                     NaClExpVector* vector,
                                     uint32_t index);
 
 /* Print the characters in the given string using lower case. */
 static void NaClPrintLower(struct Gio* file, char* str) {
   while (*str) {
     gprintf(file, "%c", tolower(*str));
@@ skipping 62 matching lines @@
  * to the given file.
  */
 static void NaClPrintDisassembledRegKind(struct Gio* file, NaClOpKind reg) {
   const char* name = NaClOpKindName(reg);
   char* str = strstr(name, "Reg");
   gprintf(file, "%c", '%');
   NaClPrintLower(file, str == NULL ? (char*) name : str + strlen("Reg"));
 }
 
 static INLINE void NaClPrintDisassembledReg(struct Gio* file, NaClExp* node) {
-  NaClPrintDisassembledRegKind(file, NaClGetExpRegister(node));
+  NaClPrintDisassembledRegKind(file, NaClGetExpRegisterInline(node));
 }
 
 void NaClExpVectorPrint(struct Gio* file, NaClExpVector* vector) {
   uint32_t i;
   gprintf(file, "NaClExpVector[%d] = {\n", vector->number_expr_nodes);
   for (i = 0; i < vector->number_expr_nodes; i++) {
     NaClExp* node = &vector->node[i];
     gprintf(file, "  { %s[%d] , ",
             NaClExpKindName(node->kind),
             NaClExpKindRank(node->kind));
@@ skipping 117 matching lines @@
  */
 static Bool NaClHasSegmentOverride(NaClExpVector* vector,
                                    int seg_addr_index,
                                    NaClExpFlag seg_eflag,
                                    NaClOpKind seg_reg) {
   NaClExp* seg_node = &vector->node[seg_addr_index];
   if (seg_node->flags & NACL_EFLAG(seg_eflag)) {
     int seg_index = seg_addr_index + 1;
     NaClExp* node = &vector->node[seg_index];
     if ((ExprRegister == node->kind) &&
-        (seg_reg != NaClGetExpRegister(node))) {
+        (seg_reg != NaClGetExpRegisterInline(node))) {
       return TRUE;
     }
   }
   return FALSE;
 }
 
 /* Prints out the segment register associated with the segment
  * address node defined by vector[seg_addr_index].
  *
  * Parameters:
@@ skipping 68 matching lines @@
       } else {
         gprintf(file, ", ");
       }
       NaClPrintDisassembledExp(file, vector, tree_index);
 
       /* If this is a partial instruction, add set/use information
        * so that that it is more clear what was matched.
        */
       if (NaClHasBit(inst->flags, NACL_IFLAG(PartialInstruction)) &&
           node->kind == OperandReference) {
-        const NaClOp* op = NaClGetInstOperand(state->decoder_tables,
-                                              inst, (uint8_t) node->value);
+        const NaClOp* op =
+            NaClGetInstOperandInline(state->decoder_tables,
+                                     inst, (uint8_t) node->value);
         if (NaClHasBit(op->flags, (NACL_OPFLAG(OpSet) |
                                    NACL_OPFLAG(OpUse) |
                                    NACL_OPFLAG(OperandZeroExtends_v)))) {
           gprintf(file, " (");
           NaClPrintAddOperandFlag(file, op, OpSet, "s");
           NaClPrintAddOperandFlag(file, op, OpUse, "u");
           NaClPrintAddOperandFlag(file, op, OperandZeroExtends_v, "z");
           gprintf(file, ")");
         }
       }
@@ skipping 190 matching lines @@
         /* Assume signed value. */
         int64_t value = (int64_t) NaClGetExpConstant(vector, index);
         return value < 0;
       }
       break;
     default:
       break;
   }
   return FALSE;
 }
+
+/* Dummy routine to allow unreferenced NaClGetInstNumberOperandsInline
+ * inline.
+ */
+uint8_t NaClNcopExpsDummyNaClGetInstNumberOperands(const NaClInst* inst) {
+  return NaClGetInstNumberOperandsInline(inst);
+}