base: make CHECK macros trap at distinct addresses in official builds

base/logging_unittest.cc

 // Copyright (c) 2011 The Chromium 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 "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/macros.h"
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_POSIX)
+#include <signal.h>
+#include <unistd.h>
+#include "base/posix/eintr_wrapper.h"
+#endif  // OS_POSIX
+
 namespace logging {
 
 namespace {
 
 using ::testing::Return;
 
 // Needs to be global since log assert handlers can't maintain state.
 int log_sink_call_count = 0;
 
 #if !defined(OFFICIAL_BUILD) || defined(DCHECK_ALWAYS_ON) || !defined(NDEBUG)
@@ skipping 283 matching lines @@
     return out << "Streamable";
   }
   TEST_F(LoggingTest, StreamingWstringFindsCorrectOperator) {
     std::wstring wstr = L"Hello World";
     std::ostringstream ostr;
     ostr << wstr;
     EXPECT_EQ("Hello World", ostr.str());
   }
 }  // namespace nested_test
 
+// This test checks that, on official builds, the crash address of CHECK() is
+// distinct in presence of multiple CHECK()s in the same function. This is a
+// regression test for http://crbug.com/664209 .
+#if defined(OFFICIAL_BUILD) && defined(OS_POSIX)
+
+int g_child_crash_pipe;
+
+void OfficialCHECKNotAmbiguous_Sighandler(int, siginfo_t* info, void*) {
+  const uintptr_t crash_addr = reinterpret_cast<uintptr_t>(info->si_addr);
+  write(g_child_crash_pipe, &crash_addr, sizeof(uintptr_t));
+  _exit(0);
+}
+
+void OfficialCHECKNotAmbiguous_ChildMain(int death_location) {
+  struct sigaction act = {};
+  act.sa_sigaction = OfficialCHECKNotAmbiguous_Sighandler;
+  act.sa_flags = SA_SIGINFO;
+  ASSERT_EQ(0, sigaction(SIGTRAP, &act, NULL));
+  ASSERT_EQ(0, sigaction(SIGILL, &act, NULL));
+  CHECK(death_location != 1);
+  CHECK(death_location != 2);
+  printf("\n");
+  CHECK(death_location != 3);
+
+  // Should never reach this point.
+  const uintptr_t failed = 0;
+  write(g_child_crash_pipe, &failed, sizeof(uintptr_t));
+};
+
+void OfficialCHECKNotAmbiguous_DoCrashChild(int death_location,
+                                            uintptr_t* child_crash_addr) {
+  int pipefd[2];
+  ASSERT_EQ(0, pipe(pipefd));
+
+  int pid = fork();
+  ASSERT_GE(pid, 0);
+
+  if (pid == 0) {      // child process.
+    close(pipefd[0]);  // Close reader (parent) end.
+    g_child_crash_pipe = pipefd[1];
+    OfficialCHECKNotAmbiguous_ChildMain(death_location);
+    FAIL() << "The child process was supposed to crash. It didn't.";
+  }
+
+  close(pipefd[1]);  // Close writer (child) end.
+  DCHECK(child_crash_addr);
+  int res = HANDLE_EINTR(read(pipefd[0], child_crash_addr, sizeof(uintptr_t)));
+  ASSERT_EQ(static_cast<int>(sizeof(uintptr_t)), res);
+}
+
+TEST_F(LoggingTest, OfficialCHECKNotAmbiguous) {
+  uintptr_t child_crash_addr_1 = 0;
+  uintptr_t child_crash_addr_2 = 0;
+  uintptr_t child_crash_addr_3 = 0;
+
+  OfficialCHECKNotAmbiguous_DoCrashChild(1, &child_crash_addr_1);
+  OfficialCHECKNotAmbiguous_DoCrashChild(2, &child_crash_addr_2);
+  OfficialCHECKNotAmbiguous_DoCrashChild(3, &child_crash_addr_3);
+
+  ASSERT_NE(0u, child_crash_addr_1);
+  ASSERT_NE(0u, child_crash_addr_2);
+  ASSERT_NE(0u, child_crash_addr_3);
+  ASSERT_NE(child_crash_addr_1, child_crash_addr_2);
+  ASSERT_NE(child_crash_addr_1, child_crash_addr_3);
+  ASSERT_NE(child_crash_addr_2, child_crash_addr_3);
+}
+#endif  // defined(OFFICIAL_BUILD) && defined(OS_POSIX)
+
 }  // namespace
 
 }  // namespace logging