Patch out posix_memalign in the out-of-memory killer....

base/process_util_unittest.cc

 // Copyright (c) 2009 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.
 
 #define _CRT_SECURE_NO_WARNINGS
 
 #include <limits>
 
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/multiprocess_test.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_LINUX)
-#include <dlfcn.h>
 #include <errno.h>
 #include <malloc.h>
 #include <glib.h>
 #endif
 #if defined(OS_POSIX)
+#include <dlfcn.h>
 #include <fcntl.h>
 #include <sys/resource.h>
 #include <sys/socket.h>
 #endif
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 #if defined(OS_MACOSX)
 #include "base/process_util_unittest_mac.h"
 #endif
@@ skipping 574 matching lines @@
 }
 
 TEST_F(OutOfMemoryTest, ViaSharedLibraries) {
   // g_try_malloc is documented to return NULL on failure. (g_malloc is the
   // 'safe' default that crashes if allocation fails). However, since we have
   // hopefully overridden malloc, even g_try_malloc should fail. This tests
   // that the run-time symbol resolution is overriding malloc for shared
   // libraries as well as for our code.
   ASSERT_DEATH(value_ = g_try_malloc(test_size_), "");
 }
+#endif  // OS_LINUX
 
-
+#if defined(OS_POSIX)
 TEST_F(OutOfMemoryTest, Posix_memalign) {
-  // Grab the return value of posix_memalign to silence a compiler warning
-  // about unused return values. We don't actually care about the return
-  // value, since we're asserting death.
-  ASSERT_DEATH(EXPECT_EQ(ENOMEM, posix_memalign(&value_, 8, test_size_)), "");
+  typedef int (*memalign_t)(void **, size_t, size_t);
+#if defined(OS_MACOSX)
+  // posix_memalign only exists on >= 10.6. Use dlsym to grab it at runtime
+  // because it may not be present in the SDK used for compilation.
+  memalign_t memalign =
+      reinterpret_cast<memalign_t>(dlsym(RTLD_DEFAULT, "posix_memalign"));
+#else
+  memalign_t memalign = posix_memalign;
+#endif  // OS_*
+  if (memalign) {
+    // Grab the return value of posix_memalign to silence a compiler warning
+    // about unused return values. We don't actually care about the return
+    // value, since we're asserting death.
+    ASSERT_DEATH(EXPECT_EQ(ENOMEM, memalign(&value_, 8, test_size_)), "");
+  }
 }
-#endif  // OS_LINUX
+#endif  // OS_POSIX
 
 #if defined(OS_MACOSX)
 
 // Since these allocation functions take a signed size, it's possible that
 // calling them just once won't be enough to exhaust memory. In the 32-bit
 // environment, it's likely that these allocation attempts will fail because
 // not enough contiguous address space is availble. In the 64-bit environment,
 // it's likely that they'll fail because they would require a preposterous
 // amount of (virtual) memory.
 
@@ skipping 19 matching lines @@
 
 TEST_F(OutOfMemoryTest, PsychoticallyBigObjCObject) {
   ASSERT_DEATH(while ((value_ =
       base::AllocatePsychoticallyBigObjCObject())) {}, "");
 }
 
 #endif  // !ARCH_CPU_64_BITS
 #endif  // OS_MACOSX
 
 #endif  // !defined(OS_WIN)