Change BKPT and UDF encodings on ARM.

src/trusted/validator_arm/validator_small_tests.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.
  */
 
 #ifndef NACL_TRUSTED_BUT_NOT_TCB
 #error This file is not meant for use in the TCB
 #endif
 
@@ skipping 502 matching lines @@
         << undefined_insts[i].about;
     EXPECT_EQ(nacl_arm_dec::UNDEFINED, spy.GetSafetyLevel(first))
         << "Instruction must be flagged as UNDEFINED: "
         << undefined_insts[i].about;
     EXPECT_EQ(nacl_arm_val::kProblemUnsafe, first.problem())
         << "Instruction must be marked unsafe: "
         << undefined_insts[i].about;
   }
 }
 
-TEST_F(ValidatorTests, LessScaryUndefinedInstructions) {
-  // These instructions are specified by ARM as *permanently* undefined, so we
-  // treat them as a reliable Illegal Instruction trap.
-
-  static const AnnotatedInstruction perm_undefined[] = {
-    { 0xE7FFDEFE, "permanently undefined instruction produced by LLVM" },
-  };
-
-  for (unsigned i = 0; i < NACL_ARRAY_SIZE(perm_undefined); i++) {
-    arm_inst program[] = { perm_undefined[i].inst };
-    validation_should_pass(program,
-                           1,
-                           kDefaultBaseAddr,
-                           perm_undefined[i].about);
-  }
-}
-
 TEST_F(ValidatorTests, PcRelativeFirstInst) {
   // Note: This tests the fix for issue 2771.
   static const arm_inst pcrel_boundary_tests[] = {
     0xe59f0000,  // ldr     r0, [pc, #0]
     0xe320f000,  // nop     {0}
     0xe320f000,  // nop     {0}
     0xe320f000,  // nop     {0}"
   };
   validation_should_pass(pcrel_boundary_tests,
                          NACL_ARRAY_SIZE(pcrel_boundary_tests),
@@ skipping 489 matching lines @@
   }
 }
 
 TEST_F(ValidatorTests, LiteralPoolHeadIsBreakpoint) {
   EXPECT_EQ(nacl_arm_dec::kLiteralPoolHeadInstruction & 0xFFF000F0,
             0xE1200070)  // BKPT #0
       << ("the literal pool head should be a breakpoint: "
           "it needs to act as a roadblock");
 }
 
+TEST_F(ValidatorTests, Breakpoint) {
+  EXPECT_EQ(nacl_arm_dec::kBreakpoint & 0xFFF000F0,
+            0xE1200070)  // BKPT #0
+      << ("the breakpoint instruction should be a breakpoint: "
+          "it needs to trap");
+}
+
+TEST_F(ValidatorTests, HaltFill) {
+  EXPECT_EQ(nacl_arm_dec::kHaltFill & 0xFFF000F0,
+            0xE7F000F0)  // UDF #0
+      << ("the halt fill instruction should be UDF: "
+          "it needs to trap");
+}
+
+TEST_F(ValidatorTests, AbortNow) {
+  EXPECT_EQ(nacl_arm_dec::kAbortNow & 0xFFF000F0,
+            0xE7F000F0)  // UDF #0
+      << ("the abort now instruction should be UDF: "
+          "it needs to trap");
+}
+
+TEST_F(ValidatorTests, FailValidation) {
+  EXPECT_EQ(nacl_arm_dec::kFailValidation & 0xFFF000F0,
+            0xE7F000F0)  // UDF #0
+      << ("the fail validation instruction should be UDF: "
+          "it needs to trap");
+}
+
+TEST_F(ValidatorTests, UDFAndBKPTValidateAsExpected) {
+  ProblemSpy spy;
+  for (uint32_t i = 0; i < 0xFFFF; ++i) {
+    arm_inst bkpt_inst = 0xE1200070 | ((i & 0xFFF0) << 4) | (i & 0xF);
+    arm_inst udf_inst  = 0xE7F000F0 | ((i & 0xFFF0) << 4) | (i & 0xF);
+    EXPECT_EQ(validate(&bkpt_inst, 1, kDefaultBaseAddr, &spy),
+              ((bkpt_inst == nacl_arm_dec::kLiteralPoolHeadInstruction) ||
+               (bkpt_inst == nacl_arm_dec::kBreakpoint)));
+    EXPECT_EQ(validate(&udf_inst, 1, kDefaultBaseAddr, &spy),
+              ((udf_inst == nacl_arm_dec::kHaltFill) ||
+               (udf_inst == nacl_arm_dec::kAbortNow)));
+    // Tautological note: kFailValidation should fail validation.
+  }
+}
+
 TEST_F(ValidatorTests, LiteralPoolHeadInstruction) {
   // Make sure that literal pools are handled properly: they should be preceded
   // by a special breakpoint instruction at the start of the bundle, and can
   // then contain any bits that would otherwise look malicious.
   // Each literal pool bundle has to start with such a literal pool head.
   vector<arm_inst> literal_pool(_validator.InstructionsPerBundle(),
                                 0xEF000000);  // SVC #0
   literal_pool[0] = 0xE1200070;  // BKPT #0
   // Try out all BKPT encodings, and make sure only one of them works.
   for (uint32_t imm16 = 0; imm16 <= 0xFFFF; ++imm16) {
@@ skipping 99 matching lines @@
   }
 }
 
 };  // anonymous namespace
 
 // Test driver function.
 int main(int argc, char *argv[]) {
   testing::InitGoogleTest(&argc, argv);
   return RUN_ALL_TESTS();
 }