[MIPS] Forbid $sp update at the end of the last bundle.

src/trusted/validator_mips/validator_tests.cc

 /*
- * Copyright 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.
+ * 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.
  */
 
 /*
  * Unit tests for the MIPS validator
  *
  * These tests use the google-test framework (gtest for short) to exercise the
  * MIPS validator.  The tests currently fall into two rough categories:
  *  1. Simple method-level tests that exercise the validator's primitive
  *     capabilities, and
  *  2. Instruction pattern tests that run the entire validator.
@@ skipping 21 matching lines @@
 using std::string;
 using std::ostringstream;
 
 using nacl_mips_dec::Register;
 using nacl_mips_dec::RegisterList;
 using nacl_mips_dec::Instruction;
 
 using nacl_mips_val::SfiValidator;
 using nacl_mips_val::ProblemSink;
 using nacl_mips_val::CodeSegment;
+using nacl_mips_dec::kInstrSize;
+using nacl_mips_dec::kNop;
+using nacl_mips_dec::kRegisterStack;
+using nacl_mips_dec::kRegListReserved;
 
 namespace {
 
 typedef uint32_t mips_inst;
 
 /*
  * We use these parameters to initialize the validator, below.  They are
  * somewhat different from the parameters used in real NaCl systems, to test
  * degrees of validator freedom that we don't currently exercise in prod.
  */
@@ skipping 187 matching lines @@
 static const AnnotatedInstruction examples_of_safe_jump_masks[] = {
   { (10 << 21 | 14 << 16 | 10 << 11 | 36),
     "and t2,t2,t6 : simple jump masking" },
 };
 
 static const AnnotatedInstruction examples_of_safe_jumps[] = {
   { ((10<<21| 31 << 11 |9) ), "simple jump jalr t2" },
   { (10<<21|8),               "simple jump jr t2" },
 };
 
-static const AnnotatedInstruction nop_instruction[] = {
-  {  0, "nop"},
-};
-
 TEST_F(ValidatorTests, SafeMaskedJumps) {
   /*
    * Produces examples of masked jumps using the safe jump table
    * (above) and the list of possible masking instructions (above).
    */
   for (unsigned m = 0; m < NACL_ARRAY_SIZE(examples_of_safe_jump_masks); m++) {
     for (unsigned s = 0; s < NACL_ARRAY_SIZE(examples_of_safe_jumps); s++) {
       ostringstream message;
       message << examples_of_safe_jump_masks[m].about
               << ", "
               << examples_of_safe_jumps[s].about;
       mips_inst program[] = {
-        nop_instruction[0].inst,
+        kNop,
         examples_of_safe_jump_masks[m].inst,
         examples_of_safe_jumps[s].inst,
       };
       ValidationShouldPass(program,
                            3,
                            kDefaultBaseAddr,
                            message.str());
     }
   }
 }
@@ skipping 70 matching lines @@
    */
   for (unsigned m = 0; m < NACL_ARRAY_SIZE(examples_of_safe_stack_masks); m++) {
     for (unsigned s = 0; s < NACL_ARRAY_SIZE(examples_of_safe_stack_ops); s++) {
       ostringstream bad_message;
       bad_message << examples_of_safe_stack_masks[m].about
                   << ", "
                   << examples_of_safe_stack_ops[s].about;
       mips_inst bad_program[] = {
         examples_of_safe_stack_masks[m].inst,
         examples_of_safe_stack_ops[s].inst,
-        nop_instruction[0].inst
+        kNop
       };
 
       ValidationShouldFail(bad_program,
                            3,
                            kDefaultBaseAddr,
                            bad_message.str());
     }
   }
 }
 
+TEST_F(ValidatorTests, NopBundle) {
+  vector<mips_inst> code(_validator.bytes_per_bundle() / kInstrSize, kNop);
+  ValidationShouldPass(&code[0], code.size(), kDefaultBaseAddr,
+                       "NOP bundle");
+}
+
+TEST_F(ValidatorTests, UnmaskedSpUpdate) {
+  vector<mips_inst> code(_validator.bytes_per_bundle() / kInstrSize, kNop);
+  for (vector<mips_inst>::size_type i = 0; i < code.size(); ++i) {
+    std::fill(code.begin(), code.end(), kNop);
+    code[i] = 0x8fbd0000;  // lw $sp, 0($sp)
+    ValidationShouldFail(&code[0], code.size(), kDefaultBaseAddr,
+                         "unmasked SP update");
+  }
+}
+
+TEST_F(ValidatorTests, MaskedSpUpdate) {
+  vector<mips_inst> code((_validator.bytes_per_bundle() / kInstrSize) * 2,
+                         kNop);
+  for (vector<mips_inst>::size_type i = 0; i < code.size() - 1; ++i) {
+    std::fill(code.begin(), code.end(), kNop);
+    code[i] = examples_of_safe_stack_ops[0].inst;
+    code[i + 1] = examples_of_safe_stack_masks[0].inst;
+    ValidationShouldPass(&code[0], code.size(), kDefaultBaseAddr,
+                         "masked SP update");
+  }
+}
+
 /*
  * Implementation of the ValidatorTests utility methods.  These are documented
  * toward the top of this file.
  */
 ValidatorTests::ValidatorTests()
   : _validator(kBytesPerBundle,
                kCodeRegionSize,
                kDataRegionSize,
-               nacl_mips_dec::kRegListReserved,
-               nacl_mips_dec::kRegisterStack) {}
+               kRegListReserved,
+               RegisterList(kRegisterStack)) {}
 
 bool ValidatorTests::Validate(const mips_inst *pattern,
                               size_t inst_count,
                               uint32_t start_addr,
                               ProblemSink *sink) {
   // We think in instructions; CodeSegment thinks in bytes.
   const uint8_t *bytes = reinterpret_cast<const uint8_t *>(pattern);
   CodeSegment segment(bytes, start_addr, inst_count * sizeof(mips_inst));
 
   vector<CodeSegment> segments;
@@ skipping 38 matching lines @@
   return problems;
 }
 
 };  // anonymous namespace
 
 // Test driver function.
 int main(int argc, char *argv[]) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }