[MIPS] Make validator allow only two load patterns via $t8

src/trusted/validator_mips/gen/decode.cc

 /*
  * Copyright (c) 2013 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.
  */
 
 // DO NOT EDIT: GENERATED CODE
 
 #include <stdio.h>
 #include "native_client/src/trusted/validator_mips/decode.h"
@@ skipping 10 matching lines @@
   const Load _Load_instance;
   const JalImm _JalImm_instance;
   const Branch _Branch_instance;
   const Arithm2 _Arithm2_instance;
   const Arithm3 _Arithm3_instance;
   const Forbidden _Forbidden_instance;
   const Safe _Safe_instance;
   const BranchAndLink _BranchAndLink_instance;
   const JalReg _JalReg_instance;
   const NaClHalt _NaClHalt_instance;
+  const LoadWord _LoadWord_instance;
   const StoreConditional _StoreConditional_instance;
   const FPLoadStore _FPLoadStore_instance;
   const JmpImm _JmpImm_instance;
   const JmpReg _JmpReg_instance;
   const Store _Store_instance;
   const ExtIns _ExtIns_instance;
   DecoderState() :
   _Load_instance()
   , _JalImm_instance()
   , _Branch_instance()
   , _Arithm2_instance()
   , _Arithm3_instance()
   , _Forbidden_instance()
   , _Safe_instance()
   , _BranchAndLink_instance()
   , _JalReg_instance()
   , _NaClHalt_instance()
+  , _LoadWord_instance()
   , _StoreConditional_instance()
   , _FPLoadStore_instance()
   , _JmpImm_instance()
   , _JmpReg_instance()
   , _Store_instance()
   , _ExtIns_instance()
   {}
 };
 
 /*
@@ skipping 127 matching lines @@
   }
 
   if (((insn & 0xFC000000) == 0x78000000)) {
     return state->_Forbidden_instance;
   }
 
   if (((insn & 0xFC000000) == 0x7C000000)) {
     return decode_special3(insn, state);
   }
 
-  if (((insn & 0xFC000000) == 0x98000000)) {
-    return state->_Load_instance;
+  if (((insn & 0xFC000000) == 0x8C000000)) {
+    return state->_LoadWord_instance;
   }
 
   if (((insn & 0xFC000000) == 0xB8000000)) {
     return state->_Store_instance;
   }
 
   if (((insn & 0xFC000000) == 0xC0000000)) {
     return state->_Load_instance;
   }
 
   if (((insn & 0xFC000000) == 0xE0000000)) {
     return state->_StoreConditional_instance;
   }
 
   if (((insn & 0xDC000000) == 0x9C000000)) {
     return state->_Forbidden_instance;
   }
 
   if (((insn & 0xDC000000) == 0xD0000000)) {
     return state->_Forbidden_instance;
   }
 
   if (((insn & 0xF8000000) == 0x30000000)) {
     return state->_Arithm2_instance;
   }
 
-  if (((insn & 0xF8000000) == 0x90000000)) {
+  if (((insn & 0xEC000000) == 0x88000000)) {
     return state->_Load_instance;
   }
 
   if (((insn & 0xF8000000) == 0xB0000000)) {
     return state->_Forbidden_instance;
   }
 
   if (((insn & 0xB8000000) == 0x10000000)) {
     return state->_Branch_instance;
   }
@@ skipping 15 matching lines @@
   }
 
   if (((insn & 0xF0000000) == 0x20000000)) {
     return state->_Arithm2_instance;
   }
 
   if (((insn & 0xF0000000) == 0x60000000)) {
     return state->_Forbidden_instance;
   }
 
-  if (((insn & 0xF0000000) == 0x80000000)) {
+  if (((insn & 0xE8000000) == 0x80000000)) {
     return state->_Load_instance;
   }
 
   if (((insn & 0xF0000000) == 0xA0000000)) {
     return state->_Store_instance;
   }
 
   // Catch any attempt to fall through...
   fprintf(stderr, "TABLE IS INCOMPLETE: "
           "MIPS32 could not parse %08X", insn.Bits(31, 0));
@@ skipping 1172 matching lines @@
 }
 void delete_state(const DecoderState *state) {
   delete state;
 }
 
 const ClassDecoder &decode(const Instruction insn, const DecoderState *state) {
   return decode_MIPS32(insn, state);
 }
 
 }  // namespace nacl_mips_dec