[MIPS] Add thread-pointer to data addressing register list.

src/trusted/validator_mips/validator.cc

 /*
  * 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.
  */
 
 #include <assert.h>
 #include "native_client/src/trusted/service_runtime/nacl_config.h"
 #include "native_client/src/trusted/validator_mips/validator.h"
 #include "native_client/src/include/nacl_macros.h"
 
 
 using nacl_mips_dec::Instruction;
 using nacl_mips_dec::ClassDecoder;
 using nacl_mips_dec::Register;
 using nacl_mips_dec::RegisterList;
 
-using nacl_mips_dec::kRegisterJumpMask;
-using nacl_mips_dec::kRegisterLoadStoreMask;
-
 using nacl_mips_dec::kInstrSize;
 using nacl_mips_dec::kInstrAlign;
 
 using std::vector;
 
 namespace nacl_mips_val {
 
 /*
  * TODO(petarj): MIPS validator and runtime port need an external security
  * review before they are delivered in products.
@@ skipping 108 matching lines @@
 
 /*
  * Checks if indirect jumps are guarded properly.
  */
 static PatternMatch CheckJmpReg(const SfiValidator &sfi,
                                 const DecodedInstruction &first,
                                 const DecodedInstruction &second,
                                 ProblemSink *out) {
   UNREFERENCED_PARAMETER(sfi);
   if (second.IsJmpReg()) {
-    if (first.IsMask(second.TargetReg(), kRegisterJumpMask)) {
+    if (first.IsMask(second.TargetReg(), Register::JumpMask())) {
       return PATTERN_SAFE;
     }
     out->ReportProblem(second.addr(), second.safety(),
                        kProblemUnsafeJumpRegister);
     return PATTERN_UNSAFE;
   }
   return NO_MATCH;
 }
 
 
 /*
  * Checks if change of the data register ($sp) is followed by load/store mask.
  */
 static PatternMatch CheckDataRegisterUpdate(const SfiValidator &sfi,
                                             const DecodedInstruction &first,
                                             const DecodedInstruction &second,
                                             ProblemSink *out) {
   if (first.IsDestGprReg(sfi.data_address_registers())
-      && !first.IsMask(first.DestGprReg(), kRegisterLoadStoreMask)) {
-    if (second.IsMask(first.DestGprReg(), kRegisterLoadStoreMask)) {
+      && !first.IsMask(first.DestGprReg(), Register::LoadStoreMask())) {
+    if (second.IsMask(first.DestGprReg(), Register::LoadStoreMask())) {
       return PATTERN_SAFE;
     }
     out->ReportProblem(first.addr(), first.safety(), kProblemUnsafeDataWrite);
     return PATTERN_UNSAFE;
   }
   return NO_MATCH;
 }
 
 /*
  * Checks if data register ($sp) change is in the delay slot.
  */
 static PatternMatch CheckDataRegisterDslot(const SfiValidator &sfi,
                                            const DecodedInstruction &first,
                                            const DecodedInstruction &second,
                                            ProblemSink *out) {
   if (second.IsDestGprReg(sfi.data_address_registers())
-      && !second.IsMask(second.DestGprReg(), kRegisterLoadStoreMask)) {
+      && !second.IsMask(second.DestGprReg(), Register::LoadStoreMask())) {
     if (first.HasDelaySlot()) {
       out->ReportProblem(second.addr(), second.safety(),
                          kProblemDataRegInDelaySlot);
       return PATTERN_UNSAFE;
     }
   }
   return NO_MATCH;
 }
 
 /*
  * Checks if load and store instructions are preceded by load/store mask.
  */
 static PatternMatch CheckLoadStore(const SfiValidator &sfi,
                                    const DecodedInstruction &first,
                                    const DecodedInstruction &second,
                                    ProblemSink *out) {
   if (second.IsLoadStore()) {
     Register base_addr_reg = second.BaseAddressRegister();
     if (!sfi.data_address_registers().
            ContainsAll(RegisterList(base_addr_reg))) {
-      if (first.IsMask(base_addr_reg, kRegisterLoadStoreMask)) {
+      if (first.IsMask(base_addr_reg, Register::LoadStoreMask())) {
         return PATTERN_SAFE;
       }
       out->ReportProblem(second.addr(), second.safety(),
                          kProblemUnsafeLoadStore);
       return PATTERN_UNSAFE;
     }
   }
   return NO_MATCH;
 }
 
@@ skipping 291 matching lines @@
 DecodedInstruction::DecodedInstruction(uint32_t vaddr,
                                        Instruction inst,
                                        const ClassDecoder &decoder)
     : vaddr_(vaddr),
       inst_(inst),
       decoder_(&decoder),
       safety_(decoder.safety(inst_))
 {}
 
 }  // namespace