[MIPS] Use break instruction as NACL_HALT for MIPS.

src/trusted/validator_mips/gen/decode.cc

 /*
  * DO NOT EDIT: GENERATED CODE
  */
 #include <stdio.h>
 #include "native_client/src/trusted/validator_mips/decode.h"
 
 namespace nacl_mips_dec {
 
 /*
  * This beast holds a bunch of pre-created ClassDecoder instances, which
  * we create in init_decode().  Because ClassDecoders are stateless, we
  * can freely reuse them -- even across threads -- and avoid allocating
  * in the inner decoder loop.
  */
 struct DecoderState {
   const Load _Load_instance;
   const JalImm _JalImm_instance;
-  const FPLoadStore _FPLoadStore_instance;
+  const Branch _Branch_instance;

[Mark Seaborn, 2012/09/26 16:59:24]

Why do Branch and FPLoadStore get swapped?  Does the validator's generator not
produce deterministic output?  If not, you might want to fix that.

With these non-trivial changes to generated code, you might want to find an
additional reviewer who has reviewed the MIPS validator before.

[petarj, 2012/09/28 17:55:02]

Validator's generator will produce deterministic output for the same input. In
this case, mips32.table has changed, which resulted in changed mips-opt.table,
and that led us to changes in decode.cc.

The change is not large, yet if you believe someone else should look at
them, please add a person who would be a suitable reviewer (too many people
reviewed the original validator change).

   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 StoreConditional _StoreConditional_instance;
-  const Branch _Branch_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()
-  ,_FPLoadStore_instance()
+  ,_Branch_instance()
   ,_Arithm2_instance()
   ,_Arithm3_instance()
   ,_Forbidden_instance()
   ,_Safe_instance()
   ,_BranchAndLink_instance()
   ,_JalReg_instance()
   ,_NaClHalt_instance()
   ,_StoreConditional_instance()
-  ,_Branch_instance()
+  ,_FPLoadStore_instance()
   ,_JmpImm_instance()
   ,_JmpReg_instance()
   ,_Store_instance()
   ,_ExtIns_instance()
   {}
 };
 
 /*
  * Prototypes for static table-matching functions.
  */
@@ skipping 208 matching lines @@
   }
   
   if (((insn & 0x0000003F) == 0x00000008)) {
     return decode_jr(insn, state);
   }
   
   if (((insn & 0x0000003F) == 0x00000009)) {
     return decode_jalr(insn, state);
   }
   
+  if (((insn & 0x0000003F) == 0x0000000D)) {
+    return state->_Safe_instance;
+  }
+  
   if (((insn & 0x0000003F) == 0x0000000F)) {
     return decode_sync(insn, state);
   }
   
-  if (((insn & 0x00000037) == 0x00000005)) {
+  if (((insn & 0x0000003F) == 0x0000003F)) {
     return state->_Forbidden_instance;
   }
   
+  if (((insn & 0x0000001F) == 0x0000001E)) {
+    return state->_Forbidden_instance;
+  }
+  
+  if (((insn & 0x0000002F) == 0x00000005)) {
+    return state->_Forbidden_instance;
+  }
+  
+  if (((insn & 0x00000037) == 0x00000017)) {
+    return state->_Forbidden_instance;
+  }
+  
   if (((insn & 0x0000003D) == 0x0000000C)) {
     return state->_Forbidden_instance;
   }
   
   if (((insn & 0x0000003D) == 0x00000010)) {
     return decode_mfhi(insn, state);
   }
   
   if (((insn & 0x0000003D) == 0x00000011)) {
     return decode_mthi(insn, state);
   }
   
+  if (((insn & 0x0000003D) == 0x00000014)) {
+    return state->_Forbidden_instance;
+  }
+  
   if (((insn & 0x0000003E) == 0x0000000A)) {
     return decode_arithm3_2(insn, state);
   }
   
   if (((insn & 0x0000003E) == 0x0000002A)) {
     return decode_arithm3_3(insn, state);
   }
   
-  if (((insn & 0x0000003E) == 0x0000003C)) {
+  if (((insn & 0x0000003E) == 0x0000002E)) {
     return state->_Forbidden_instance;
   }
   
-  if (((insn & 0x0000002E) == 0x0000002E)) {
+  if (((insn & 0x0000001E) == 0x0000001C)) {
     return state->_Forbidden_instance;
   }
   
   if (((insn & 0x0000003A) == 0x00000028)) {
     return state->_Forbidden_instance;
   }
   
   if (((insn & 0x0000003C) == 0x00000018)) {
     return decode_mult(insn, state);
   }
   
   if (((insn & 0x0000003C) == 0x00000038)) {
     return state->_Forbidden_instance;
   }
   
-  if (((insn & 0x00000034) == 0x00000014)) {
-    return state->_Forbidden_instance;
-  }
-  
   if (((insn & 0x00000038) == 0x00000020)) {
     return decode_arithm3_3(insn, state);
   }
   
   if (((insn & 0x00000038) == 0x00000030)) {
     return state->_Forbidden_instance;
   }
   
   // Catch any attempt to fall through...
   fprintf(stderr, "TABLE IS INCOMPLETE: special could not parse %08X",insn.Bits(31,0));
@@ skipping 961 matching lines @@
 }
 void delete_state(const DecoderState *state) {
   delete (DecoderState *)state;
 }
 
 const ClassDecoder &decode(const Instruction insn, const DecoderState *state) {
   return decode_MIPS32(insn, (DecoderState *)state);
 }
 
 }  // namespace