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

src/trusted/validator_mips/model.h

 /*
  * 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.
  */
 
 #ifndef NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_MIPS_MODEL_H
 #define NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_MIPS_MODEL_H
 
 /*
@@ skipping 12 matching lines @@
 
 /*
  * A value class that names a single register.  We could use a typedef for this,
  * but it introduces some ambiguity problems because of the implicit conversion
  * to/from int.
  *
  * May be implicitly converted to a single-entry RegisterList (see below).
  */
 class Register {
  public:
+  typedef uint8_t Number;
   explicit inline Register(uint32_t);
 
   /*
    * Produces the bitmask used to represent this register.
    */
   inline uint32_t Bitmask() const;
 
   inline bool Equals(const Register &) const;
 
+  static const Number kJumpMask       = 14;  // $t6 = holds mask for jr.
+  static const Number kLoadStoreMask  = 15;  // $t7 = holds mask for load/store.
+  static const Number kTls            = 24;  // $t8 = holds tls index.
+  static const Number kSp             = 29;  // Stack pointer.
+
+  static const Number kNone           = 32;
+
+  /*
+   * A special value used to indicate that a register field is not used.
+   * This is specially chosen to ensure that bitmask() == 0, so it can be added
+   * to any RegisterList with no effect.
+   */
+  static Register None() { return Register(kNone); }
+
+  /* Registers with special meaning in our model: */
+  static Register JumpMask() { return Register(kJumpMask); }
+  static Register LoadStoreMask() { return Register(kLoadStoreMask); }
+  static Register Tls() { return Register(kTls); }
+  static Register Sp() { return Register(kSp); }
+
  private:
   uint32_t _number;
 };
 
-const Register kRegisterNone(0);
-
-// Registers with special meaning in our model:
-const Register kRegisterStack(29);
-const Register kRegisterJumpMask(14);       // $t6 = holds mask for jr.
-const Register kRegisterLoadStoreMask(15);  // $t7 = holds mask for load/store.
-const Register kRegisterTls(24);            // $t8 = holds tls index.
-
-const Register kRegisterZero(0);
-
 /*
  * A collection of Registers.  Used to describe the side effects of operations.
  *
  * Note that this is technically a set, not a list -- but RegisterSet is a
  * well-known term that means something else.
  */
 class RegisterList {
  public:
   /*
    * Produces a RegisterList that contains the registers specified in the
@@ skipping 19 matching lines @@
   inline bool operator[](const Register) const;
 
   // Checks whether this list contains all the registers in the operand.
   inline bool ContainsAll(RegisterList) const;
 
   // Checks whether this list contains any of the registers in the operand.
   inline bool ContainsAny(RegisterList) const;
 
   inline const RegisterList operator&(const RegisterList) const;
 
+  /*
+   * A list containing every possible register, even some we do not define.
+   * Used exclusively as a bogus scary return value for forbidden instructions.
+   */
+  static RegisterList Everything() { return RegisterList(-1); }
+
+  /* A list of registers that can not be modified by untrusted code. */
+  static RegisterList ReservedRegs() {
+    return RegisterList(((1 << Register::kJumpMask) |
+                         (1 << Register::kLoadStoreMask) |
+                         (1 << Register::kTls)));
+  }
+
+  /* A list of registers that can be used for addressing memory locations. */
+  static RegisterList DataAddrRegs() {
+    return RegisterList(((1 << Register::kSp) |
+                         (1 << Register::kTls)));
+  }
+
  private:
   uint32_t _bits;
 };
 
 /*
- * A list containing every possible register, even some we don't define.
- * Used exclusively as a bogus scary return value for forbidden instructions.
- */
-static const RegisterList kRegisterListEverything = RegisterList(-1);
-
-static uint32_t const kReservedRegsBitmask = kRegisterTls.Bitmask()
-                                             + kRegisterJumpMask.Bitmask()
-                                             + kRegisterLoadStoreMask.Bitmask();
-static RegisterList const kRegListReserved = RegisterList(kReservedRegsBitmask);
-
-/*
  * A 32-bit Mips instruction of unspecified type.
  *
  * This class is designed for efficiency:
  *  - Its public methods for bitfield extraction are short and inline.
  *  - It has no vtable, so on 32-bit platforms it's exactly the size of the
  *    instruction it models.
  */
 class Instruction {
  public:
   explicit inline Instruction(uint32_t bits);
@@ skipping 33 matching lines @@
 
 // Opcode for nop instruction.
 uint32_t const kNop = 0x0;
 
 }  // namespace
 
 // Definitions for our inlined functions.
 #include "native_client/src/trusted/validator_mips/model-inl.h"
 
 #endif  // NATIVE_CLIENT_SRC_TRUSTED_VALIDATOR_MIPS_MODEL_H