Fix ExceptionPorts.TaskAndThreadExceptionPorts under better compiler optimization

util/mach/exception_ports_test.cc

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 89 matching lines @@
   if (expect_port != MACH_PORT_NULL) {
     EXPECT_TRUE(found);
   } else {
     EXPECT_FALSE(found);
   }
 }
 
 class TestExceptionPorts : public MachMultiprocess,
                            public UniversalMachExcServer::Interface {
  public:
+  // Which entities to set exception ports for.
+  enum SetOn {
+    kSetOnTaskOnly = 0,
+    kSetOnTaskAndThreads,
+  };
+
   // Where to call ExceptionPorts::SetExceptionPort() from.
   enum SetType {
     // Call it from the child process on itself.
     kSetInProcess = 0,
 
     // Call it from the parent process on the child.
     kSetOutOfProcess,
   };
 
-  // Which entities to set exception ports for.
-  enum SetOn {
-    kSetOnTaskOnly = 0,
-    kSetOnTaskAndThreads,
-  };
-
   // Which thread in the child process is expected to crash.
   enum WhoCrashes {
     kNobodyCrashes = 0,
     kMainThreadCrashes,
     kOtherThreadCrashes,
   };
 
-  TestExceptionPorts(SetType set_type, SetOn set_on, WhoCrashes who_crashes)
+  TestExceptionPorts(SetOn set_on, SetType set_type, WhoCrashes who_crashes)
       : MachMultiprocess(),
         UniversalMachExcServer::Interface(),
+        set_on_(set_on),
         set_type_(set_type),
-        set_on_(set_on),
         who_crashes_(who_crashes),
         handled_(false) {}
 
+  SetOn set_on() const { return set_on_; }
   SetType set_type() const { return set_type_; }
-  SetOn set_on() const { return set_on_; }
   WhoCrashes who_crashes() const { return who_crashes_; }
 
   // UniversalMachExcServer::Interface:
 
   virtual kern_return_t CatchMachException(
       exception_behavior_t behavior,
       exception_handler_t exception_port,
       thread_t thread,
       task_t task,
       exception_type_t exception,
@@ skipping 32 matching lines @@
     EXPECT_EQ(EXC_CRASH, exception);
     EXPECT_EQ(2u, code_count);
 
     // The exception and code_count checks above would ideally use ASSERT_EQ so
     // that the next conditional would not be necessary, but ASSERT_* requires a
     // function returning type void, and the interface dictates otherwise here.
     if (exception == EXC_CRASH && code_count >= 1) {
       int signal;
       ExcCrashRecoverOriginalException(code[0], nullptr, &signal);
 
-      // The child crashed with a division by zero, which shows up as SIGFPE.
-      // This was chosen because it’s unlikely to be generated by testing or
-      // assertion failures.
-      EXPECT_EQ(SIGFPE, signal);
+      // The child crashed with __builtin_trap(), which shows up as SIGILL.
+      EXPECT_EQ(SIGILL, signal);
 
       SetExpectedChildTermination(kTerminationSignal, signal);
     }
 
     return ExcServerSuccessfulReturnValue(behavior, false);
   }
 
  private:
   class Child {
    public:
@@ skipping 111 matching lines @@
       }
 
       // If this thread is the one that crashes, do it.
       if (test_exception_ports_->who_crashes() == kOtherThreadCrashes) {
         Crash();
       }
 
       return nullptr;
     }
 
-    // Crashes by performing a division by zero. The assignment is present to
-    // avoid optimizing zero_ out entirely by making it appear that its value
-    // might change.
-    static void Crash() { zero_ = 1 / zero_; }
+    static void Crash() {
+      __builtin_trap();
+    }
 
     // The parent object.
     TestExceptionPorts* test_exception_ports_;  // weak
 
     // The “other” thread.
     pthread_t thread_;
 
     // The main thread waits on this for the other thread to start up and
     // perform its own initialization.
     Semaphore init_semaphore_;
 
     // The child thread waits on this for the parent thread to indicate that the
     // child can test its exception ports and possibly crash, as appropriate.
     Semaphore crash_semaphore_;
 
-    // Always zero. Crash() divides by this in order to trigger a crash. This is
-    // structured as a static volatile int to ward off aggressive compiler
-    // optimizations.
-    static volatile int zero_;
-
     DISALLOW_COPY_AND_ASSIGN(Child);
   };
 
   // MachMultiprocess:
 
   void MachMultiprocessParent() override {
     // Wait for the child process to be ready. It needs to have all of its
     // threads set up before proceeding if in kSetOutOfProcess mode.
     char c;
     CheckedReadFile(ReadPipeHandle(), &c, 1);
@@ skipping 77 matching lines @@
     }
 
     // Let the child process know that everything in the parent process is set
     // up.
     c = '\0';
     CheckedWriteFile(WritePipeHandle(), &c, 1);
 
     if (who_crashes_ != kNobodyCrashes) {
       UniversalMachExcServer universal_mach_exc_server(this);
 
+      const mach_msg_timeout_t kTimeoutMs = 50;
       kern_return_t kr =
           MachMessageServer::Run(&universal_mach_exc_server,
                                  local_port,
                                  MACH_MSG_OPTION_NONE,
                                  MachMessageServer::kOneShot,
                                  MachMessageServer::kReceiveLargeError,
-                                 kMachMessageTimeoutWaitIndefinitely);
+                                 kTimeoutMs);
       EXPECT_EQ(KERN_SUCCESS, kr)
           << MachErrorMessage(kr, "MachMessageServer::Run");
 
       EXPECT_TRUE(handled_);
     }
 
     // Wait for the child process to exit or terminate, as indicated by it
     // closing its pipe. This keeps LocalPort() alive in the child as
     // RemotePort(), for the child’s use in its TestGetExceptionPorts().
     CheckedReadFileAtEOF(ReadPipeHandle());
   }
 
   void MachMultiprocessChild() override {
     Child child(this);
     child.Run();
   }
 
+  SetOn set_on_;
   SetType set_type_;
-  SetOn set_on_;
   WhoCrashes who_crashes_;
 
   // true if an exception message was handled.
   bool handled_;
 
   DISALLOW_COPY_AND_ASSIGN(TestExceptionPorts);
 };
 
-volatile int TestExceptionPorts::Child::zero_ = 0;
+TEST(ExceptionPorts, TaskExceptionPorts_SetInProcess_NoCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskOnly,
+      TestExceptionPorts::kSetInProcess,
+      TestExceptionPorts::kNobodyCrashes);
+  test_exception_ports.Run();
+}
 
-TEST(ExceptionPorts, TaskAndThreadExceptionPorts) {
-  struct Testcase {
-    TestExceptionPorts::SetType set_type;
-    TestExceptionPorts::SetOn set_on;
-    TestExceptionPorts::WhoCrashes who_crashes;
-  };
-  const Testcase kTestcases[] = {
-      {TestExceptionPorts::kSetInProcess,
-       TestExceptionPorts::kSetOnTaskOnly,
-       TestExceptionPorts::kNobodyCrashes},
-      {TestExceptionPorts::kSetInProcess,
-       TestExceptionPorts::kSetOnTaskOnly,
-       TestExceptionPorts::kMainThreadCrashes},
-      {TestExceptionPorts::kSetInProcess,
-       TestExceptionPorts::kSetOnTaskOnly,
-       TestExceptionPorts::kOtherThreadCrashes},
-      {TestExceptionPorts::kSetInProcess,
-       TestExceptionPorts::kSetOnTaskAndThreads,
-       TestExceptionPorts::kNobodyCrashes},
-      {TestExceptionPorts::kSetInProcess,
-       TestExceptionPorts::kSetOnTaskAndThreads,
-       TestExceptionPorts::kMainThreadCrashes},
-      {TestExceptionPorts::kSetInProcess,
-       TestExceptionPorts::kSetOnTaskAndThreads,
-       TestExceptionPorts::kOtherThreadCrashes},
-      {TestExceptionPorts::kSetOutOfProcess,
-       TestExceptionPorts::kSetOnTaskOnly,
-       TestExceptionPorts::kNobodyCrashes},
-      {TestExceptionPorts::kSetOutOfProcess,
-       TestExceptionPorts::kSetOnTaskOnly,
-       TestExceptionPorts::kMainThreadCrashes},
-      {TestExceptionPorts::kSetOutOfProcess,
-       TestExceptionPorts::kSetOnTaskOnly,
-       TestExceptionPorts::kOtherThreadCrashes},
-      {TestExceptionPorts::kSetOutOfProcess,
-       TestExceptionPorts::kSetOnTaskAndThreads,
-       TestExceptionPorts::kNobodyCrashes},
-      {TestExceptionPorts::kSetOutOfProcess,
-       TestExceptionPorts::kSetOnTaskAndThreads,
-       TestExceptionPorts::kMainThreadCrashes},
-      {TestExceptionPorts::kSetOutOfProcess,
-       TestExceptionPorts::kSetOnTaskAndThreads,
-       TestExceptionPorts::kOtherThreadCrashes},
-  };
+TEST(ExceptionPorts, TaskExceptionPorts_SetInProcess_MainThreadCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskOnly,
+      TestExceptionPorts::kSetInProcess,
+      TestExceptionPorts::kMainThreadCrashes);
+  test_exception_ports.Run();
+}
 
-  for (size_t index = 0; index < arraysize(kTestcases); ++index) {
-    const Testcase& testcase = kTestcases[index];
-    SCOPED_TRACE(
-        base::StringPrintf("index %zu, set_type %d, set_on %d, who_crashes %d",
-                           index,
-                           testcase.set_type,
-                           testcase.set_on,
-                           testcase.who_crashes));
+TEST(ExceptionPorts, TaskExceptionPorts_SetInProcess_OtherThreadCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskOnly,
+      TestExceptionPorts::kSetInProcess,
+      TestExceptionPorts::kOtherThreadCrashes);
+  test_exception_ports.Run();
+}
 
-    TestExceptionPorts test_exception_ports(
-        testcase.set_type, testcase.set_on, testcase.who_crashes);
-    test_exception_ports.Run();
-  }
+TEST(ExceptionPorts, TaskAndThreadExceptionPorts_SetInProcess_NoCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskAndThreads,
+      TestExceptionPorts::kSetInProcess,
+      TestExceptionPorts::kNobodyCrashes);
+  test_exception_ports.Run();
+}
+
+TEST(ExceptionPorts, TaskAndThreadExceptionPorts_SetInProcess_MainThreadCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskAndThreads,
+      TestExceptionPorts::kSetInProcess,
+      TestExceptionPorts::kMainThreadCrashes);
+  test_exception_ports.Run();
+}
+
+TEST(ExceptionPorts,
+     TaskAndThreadExceptionPorts_SetInProcess_OtherThreadCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskAndThreads,
+      TestExceptionPorts::kSetInProcess,
+      TestExceptionPorts::kOtherThreadCrashes);
+  test_exception_ports.Run();
+}
+
+TEST(ExceptionPorts, TaskExceptionPorts_SetOutOfProcess_NoCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskOnly,
+      TestExceptionPorts::kSetOutOfProcess,
+      TestExceptionPorts::kNobodyCrashes);
+  test_exception_ports.Run();
+}
+
+TEST(ExceptionPorts, TaskExceptionPorts_SetOutOfProcess_MainThreadCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskOnly,
+      TestExceptionPorts::kSetOutOfProcess,
+      TestExceptionPorts::kMainThreadCrashes);
+  test_exception_ports.Run();
+}
+
+TEST(ExceptionPorts, TaskExceptionPorts_SetOutOfProcess_OtherThreadCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskOnly,
+      TestExceptionPorts::kSetOutOfProcess,
+      TestExceptionPorts::kOtherThreadCrashes);
+  test_exception_ports.Run();
+}
+
+TEST(ExceptionPorts, TaskAndThreadExceptionPorts_SetOutOfProcess_NoCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskAndThreads,
+      TestExceptionPorts::kSetOutOfProcess,
+      TestExceptionPorts::kNobodyCrashes);
+  test_exception_ports.Run();
+}
+
+TEST(ExceptionPorts,
+     TaskAndThreadExceptionPorts_SetOutOfProcess_MainThreadCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskAndThreads,
+      TestExceptionPorts::kSetOutOfProcess,
+      TestExceptionPorts::kMainThreadCrashes);
+  test_exception_ports.Run();
+}
+
+TEST(ExceptionPorts,
+     TaskAndThreadExceptionPorts_SetOutOfProcess_OtherThreadCrash) {
+  TestExceptionPorts test_exception_ports(
+      TestExceptionPorts::kSetOnTaskAndThreads,
+      TestExceptionPorts::kSetOutOfProcess,
+      TestExceptionPorts::kOtherThreadCrashes);
+  test_exception_ports.Run();
 }
 
 TEST(ExceptionPorts, HostExceptionPorts) {
   // ExceptionPorts isn’t expected to work as non-root. Just do a quick test to
   // make sure that TargetTypeName() returns the right string, and that the
   // underlying host_get_exception_ports() function appears to be called by
   // looking for a KERN_INVALID_ARGUMENT return value. Or, on the off chance
   // that the test is being run as root, just look for KERN_SUCCESS.
   // host_set_exception_ports() is not tested, because if the test were running
   // as root and the call succeeded, it would have global effects.
@@ skipping 20 matching lines @@
   if (geteuid() == 0) {
     EXPECT_TRUE(rv);
   } else {
     EXPECT_FALSE(rv);
   }
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad