Modify enuminsts to be able to communicate matched instructions accross

src/trusted/validator/x86/testing/enuminsts/xed_tester.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.
  */
 
 /*
  * xed_tester.c
  * Implements a xed decoder that can be used as a NaClEnumeratorDecoder.
  */
@@ skipping 42 matching lines @@
   /* dstate.stack_addr_width = XED_ADDRESS_WIDTH_32b; */
 #if (NACL_TARGET_SUBARCH == 32)
   xed_decoder._xed_state.mmode = XED_MACHINE_MODE_LONG_COMPAT_32;
 #endif
 #if (NACL_TARGET_SUBARCH == 64)
   xed_decoder._xed_state.mmode = XED_MACHINE_MODE_LONG_64;
 #endif
 }
 
 /* Defines the function to parse the first instruction. */
-static void ParseInst(NaClEnumerator* enumerator, int pc_address) {
+static void ParseInst(const NaClEnumerator* enumerator, const int pc_address) {
   xed_decoder._has_xed_disasm = FALSE;
   xed_decoder._pc_address = pc_address;
   xed_decoder._xed_disasm[0] = 0;
   xed_decoder._xed_opcode[0] = 0;
   xed_decoder._xed_operands[0] = 0;
   xed_decoder._xed_inst = NULL;
   xed_decoded_inst_set_input_chip(&xed_decoder._xedd, XED_CHIP_CORE2);
   xed_decoded_inst_zero_set_mode(&xed_decoder._xedd, &xed_decoder._xed_state);
   xed_decoder._xed_error = xed_decode
       (&xed_decoder._xedd, (const xed_uint8_t*)enumerator->_itext,
        enumerator->_num_bytes);
 }
 
 /* Returns true if the instruction parsed a legal instruction. */
-static Bool IsInstLegal(NaClEnumerator* enumerator) {
+static Bool IsInstLegal(const NaClEnumerator* enumerator) {
   return (xed_decoder._xedd._decoded_length != 0) &&
       (XED_ERROR_NONE == xed_decoder._xed_error);
 }
 
 /* Returns the disassembled instruction. */
-static const char* Disassemble(NaClEnumerator* enumerator) {
+static const char* Disassemble(const NaClEnumerator* enumerator) {
   if (!xed_decoder._has_xed_disasm) {
     if (xed_decoder._xedd._decoded_length == 0) {
       strcpy(xed_decoder._xed_disasm, "[illegal instruction]");
     }
     xed_format_intel(&xed_decoder._xedd, xed_decoder._xed_disasm,
                      kBufferSize, xed_decoder._pc_address);
     xed_decoder._has_xed_disasm = TRUE;
   }
   return xed_decoder._xed_disasm;
 }
 
 /* Returns the mnemonic name for the disassembled instruction. */
-static const char* GetInstMnemonic(NaClEnumerator* enumerator) {
+static const char* GetInstMnemonic(const NaClEnumerator* enumerator) {
   char *allocated;
   char *xtmp;
   char *prev_xtmp;
   int char0 = 0;
 
   /* First see if we have cached it. If so, return it. */
   if (xed_decoder._xed_opcode[0] != 0) return xed_decoder._xed_opcode;
 
   /* If reached, we haven't cached it, so find the name from the
    * disassembled instruction, and cache it.
@@ skipping 27 matching lines @@
   CleanString(xtmp, "xmmword ptr ");
   CleanString(xtmp, "word ptr ");
   CleanString(xtmp, "ptr ");
   CleanString(xtmp, "far ");
 
   cstrncpy(xed_decoder._xed_operands, strip(xtmp), kBufferSize);
   free(allocated);
   return xed_decoder._xed_opcode;
 }
 
-static const char* GetInstOperandsText(NaClEnumerator* enumerator) {
+static const char* GetInstOperandsText(const NaClEnumerator* enumerator) {
   /* Force caching of operands and return. */
   if (xed_decoder._xed_operands[0] == 0) GetInstMnemonic(enumerator);
   return xed_decoder._xed_operands;
 }
 
 /* Prints out the disassembled instruction. */
-static void PrintInst(NaClEnumerator* enumerator) {
+static void PrintInst(const NaClEnumerator* enumerator) {
   int i;
-  if (enumerator->_print_opcode_bytes_only) {
-    for (i = 0; i < xed_decoder._xedd._decoded_length; ++i) {
-      printf("%02x", enumerator->_itext[i]);
-    }
-    printf("\n");
-  } else {
-    size_t opcode_size;
-    if (!enumerator->_print_enumerated_instruction) {
-      NaClPcAddress pc_address = (NaClPcAddress) xed_decoder._pc_address;
-      printf("  XED: %"NACL_PRIxNaClPcAddressAll": ", pc_address);
-    }
-    /* Since xed doesn't print out opcode sequence, and it is
-     * useful to know, add it to the print out. Note: Use same
-     * spacing scheme as nacl decoder, so things line up.
-     */
-    size_t num_bytes = MAX_INST_LENGTH;
-    if (enumerator->_num_bytes > num_bytes)
-      num_bytes = enumerator->_num_bytes;
-    for (i = 0; i < num_bytes; ++i) {
-      if (i < xed_decoder._xedd._decoded_length) {
-        printf("%02x ", enumerator->_itext[i]);
-      } else if (!enumerator->_print_enumerated_instruction) {
-        printf("   ");
-      }
-    }
-    if (enumerator->_print_enumerated_instruction) {
-      printf("#%s %s\n", GetInstMnemonic(enumerator),
-             GetInstOperandsText(enumerator));
+  size_t opcode_size;
+  NaClPcAddress pc_address = (NaClPcAddress) xed_decoder._pc_address;
+  printf("  XED: %"NACL_PRIxNaClPcAddressAll": ", pc_address);
+
+  /* Since xed doesn't print out opcode sequence, and it is
+   * useful to know, add it to the print out. Note: Use same
+   * spacing scheme as nacl decoder, so things line up.
+   */
+  size_t num_bytes = MAX_INST_LENGTH;
+  if (enumerator->_num_bytes > num_bytes)
+    num_bytes = enumerator->_num_bytes;
+  for (i = 0; i < num_bytes; ++i) {
+    if (i < xed_decoder._xedd._decoded_length) {
+      printf("%02x ", enumerator->_itext[i]);
     } else {
-      printf("%s\n", Disassemble(enumerator));
+      printf("   ");
     }
   }
+  printf("%s\n", Disassemble(enumerator));
 }
 
-static size_t InstLength(NaClEnumerator* enumerator) {
+static size_t InstLength(const NaClEnumerator* enumerator) {
   return (size_t) xed_decoder._xedd._decoded_length;
 }
 
 static inline xed_inst_t const* GetXedInst() {
   if (xed_decoder._xed_inst == NULL) {
     xed_decoder._xed_inst = xed_decoded_inst_inst(&xed_decoder._xedd);
   }
   return xed_decoder._xed_inst;
 }
 
-static size_t GetNumOperands(NaClEnumerator* enumerator) {
+static size_t GetNumOperands(const NaClEnumerator* enumerator) {
   return (size_t) xed_inst_noperands(GetXedInst());
 }
 
 #if NACL_TARGET_SUBARCH == 64
-static int IsReservedReg(xed_reg_enum_t reg) {
+static int IsReservedReg(const xed_reg_enum_t reg) {
   switch (reg) {
     case XED_REG_RSP:
     case XED_REG_RBP:
     case XED_REG_R15:
       return 1;
   }
   return 0;
 }
 
 
-static int IsWriteAction(xed_operand_action_enum_t rw) {
+static int IsWriteAction(const xed_operand_action_enum_t rw) {
   switch (rw) {
     case XED_OPERAND_ACTION_RW:
     case XED_OPERAND_ACTION_W:
     case XED_OPERAND_ACTION_RCW:
     case XED_OPERAND_ACTION_CW:
     case XED_OPERAND_ACTION_CRW:
       return 1;
   }
   return 0;
 }
 
-static Bool WritesToReservedReg(NaClEnumerator* enumerator,
-                                size_t n) {
+static Bool WritesToReservedReg(const NaClEnumerator* enumerator,
+                                const size_t n) {
   xed_inst_t const* xi = GetXedInst();
   xed_operand_t const* op = xed_inst_operand(xi, n);
   xed_operand_enum_t op_name = xed_operand_name(op);
   return xed_operand_is_register(op_name) &&
       IsReservedReg(xed_decoded_inst_get_reg(&xed_decoder._xedd, op_name)) &&
       IsWriteAction(xed_operand_rw(op));
 }
 #elif NACL_TARGET_SUBARCH == 32
-static Bool WritesToReservedReg(NaClEnumerator* enumerator,
-                                size_t n) {
+static Bool WritesToReservedReg(const NaClEnumerator* enumerator,
+                                const size_t n) {
   return FALSE;
 }
 #else
 #error("Bad NACL_TARGET_SUBARCH")
 #endif
 
-static const char* Usage() {
-  return "Runs xed to decode instructions.";
-}
-
-static void InstallFlag(NaClEnumerator* enumerator,
+static void InstallFlag(const NaClEnumerator* enumerator,
                         const char* flag_name,
-                        void* flag_address) {
+                        const void* flag_address) {
 }
 
 /* Defines the registry function that creates a xed decoder, and returns
  * the decoder to be registered.
  */
 NaClEnumeratorDecoder* RegisterXedDecoder() {
   XedSetup();
   xed_decoder._base._id_name = "xed";
-  xed_decoder._base._legal_only = TRUE;
-  xed_decoder._base._print_only = FALSE;
   xed_decoder._base._parse_inst_fn = ParseInst;
   xed_decoder._base._inst_length_fn = InstLength;
   xed_decoder._base._print_inst_fn = PrintInst;
   xed_decoder._base._get_inst_mnemonic_fn = GetInstMnemonic;
   xed_decoder._base._get_inst_num_operands_fn = GetNumOperands;
   xed_decoder._base._get_inst_operands_text_fn = GetInstOperandsText;
   xed_decoder._base._writes_to_reserved_reg_fn = WritesToReservedReg;
   xed_decoder._base._is_inst_legal_fn = IsInstLegal;
   xed_decoder._base._maybe_inst_validates_fn = NULL;
   xed_decoder._base._segment_validates_fn = NULL;
   xed_decoder._base._install_flag_fn = InstallFlag;
   xed_decoder._base._usage_message = "Runs xed to decode instructions.";
   return &xed_decoder._base;
 }