Issue #1829 - Revert "Issue #1751 -- Remove XP_DARWIN"

This reverts commit 3d671e4275c73a1484c72713304c6e04ec4ffc7c.

6 files changed, 144 insertions, 9 deletions

diff --git a/memory/build/mozmemory.h b/memory/build/mozmemory.h
index 2ed63b9e1f..84007fffb2 100644
--- a/memory/build/mozmemory.h
+++ b/memory/build/mozmemory.h
@@ -25,6 +25,13 @@
 
 MOZ_BEGIN_EXTERN_C
 
+/*
+ * On OSX, malloc/malloc.h contains the declaration for malloc_good_size,
+ * which will call back in jemalloc, through the zone allocator so just use it.
+ */
+#ifdef XP_DARWIN
+#  include <malloc/malloc.h>
+#else
 MOZ_MEMORY_API size_t malloc_good_size_impl(size_t size);
 
 /* Note: the MOZ_GLUE_IN_PROGRAM ifdef below is there to avoid -Werror turning
@@ -32,15 +39,15 @@ MOZ_MEMORY_API size_t malloc_good_size_impl(size_t size);
  * to use weak imports. */
 
 static inline size_t _malloc_good_size(size_t size) {
-#if defined(MOZ_GLUE_IN_PROGRAM) && !defined(IMPL_MFBT)
+#  if defined(MOZ_GLUE_IN_PROGRAM) && !defined(IMPL_MFBT)
   if (!malloc_good_size)
     return size;
-#endif
+#  endif
   return malloc_good_size_impl(size);
 }
 
-#define malloc_good_size _malloc_good_size
-
+#  define malloc_good_size _malloc_good_size
+#endif
 
 MOZ_JEMALLOC_API void jemalloc_stats(jemalloc_stats_t *stats);
 
diff --git a/memory/build/mozmemory_wrap.c b/memory/build/mozmemory_wrap.c
index 409b39da23..fdb8447d33 100644
--- a/memory/build/mozmemory_wrap.c
+++ b/memory/build/mozmemory_wrap.c
@@ -68,6 +68,7 @@ mozmem_malloc_impl(_ZdaPvRKSt9nothrow_t)(void *ptr)
 #undef strndup
 #undef strdup
 
+#ifndef XP_DARWIN
 MOZ_MEMORY_API char *
 strndup_impl(const char *src, size_t len)
 {
@@ -85,6 +86,7 @@ strdup_impl(const char *src)
   size_t len = strlen(src);
   return strndup_impl(src, len);
 }
+#endif /* XP_DARWIN */
 
 #ifdef XP_WIN
 /*
diff --git a/memory/build/mozmemory_wrap.h b/memory/build/mozmemory_wrap.h
index aa305588d4..da4fd27bb1 100644
--- a/memory/build/mozmemory_wrap.h
+++ b/memory/build/mozmemory_wrap.h
@@ -112,7 +112,7 @@
 #    define mozmem_jemalloc_impl(a)   je_ ## a
 #  else
 #    define MOZ_JEMALLOC_API MFBT_API
-#    if defined(XP_WIN)
+#    if (defined(XP_WIN) || defined(XP_DARWIN))
 #      if defined(MOZ_REPLACE_MALLOC)
 #        define mozmem_malloc_impl(a)   a ## _impl
 #      else
diff --git a/memory/build/replace_malloc.c b/memory/build/replace_malloc.c
index 135b566630..91f86497c5 100644
--- a/memory/build/replace_malloc.c
+++ b/memory/build/replace_malloc.c
@@ -26,7 +26,9 @@
  * function resolved with GetProcAddress() instead of weak definitions
  * of functions.
  */
-#if defined(XP_WIN)
+#ifdef XP_DARWIN
+#  define MOZ_REPLACE_WEAK __attribute__((weak_import))
+#elif defined(XP_WIN)
 #  define MOZ_NO_REPLACE_FUNC_DECL
 #elif defined(__GNUC__)
 #  define MOZ_REPLACE_WEAK __attribute__((weak))
@@ -282,6 +284,111 @@ MOZ_MEMORY_API __memalign_hook_type __memalign_hook = memalign_impl;
  * owned by the allocator.
  */
 
+#ifdef XP_DARWIN
+#include <stdlib.h>
+#include <malloc/malloc.h>
+#include "mozilla/Assertions.h"
+
+static size_t
+zone_size(malloc_zone_t *zone, void *ptr)
+{
+  return malloc_usable_size_impl(ptr);
+}
+
+static void *
+zone_malloc(malloc_zone_t *zone, size_t size)
+{
+  return malloc_impl(size);
+}
+
+static void *
+zone_calloc(malloc_zone_t *zone, size_t num, size_t size)
+{
+  return calloc_impl(num, size);
+}
+
+static void *
+zone_realloc(malloc_zone_t *zone, void *ptr, size_t size)
+{
+  if (malloc_usable_size_impl(ptr))
+    return realloc_impl(ptr, size);
+  return realloc(ptr, size);
+}
+
+static void
+zone_free(malloc_zone_t *zone, void *ptr)
+{
+  if (malloc_usable_size_impl(ptr)) {
+    free_impl(ptr);
+    return;
+  }
+  free(ptr);
+}
+
+static void
+zone_free_definite_size(malloc_zone_t *zone, void *ptr, size_t size)
+{
+  size_t current_size = malloc_usable_size_impl(ptr);
+  if (current_size) {
+    MOZ_ASSERT(current_size == size);
+    free_impl(ptr);
+    return;
+  }
+  free(ptr);
+}
+
+static void *
+zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size)
+{
+  void *ptr;
+  if (posix_memalign_impl(&ptr, alignment, size) == 0)
+    return ptr;
+  return NULL;
+}
+
+static void *
+zone_valloc(malloc_zone_t *zone, size_t size)
+{
+  return valloc_impl(size);
+}
+
+static void *
+zone_destroy(malloc_zone_t *zone)
+{
+  /* This function should never be called. */
+  MOZ_CRASH();
+}
+
+static size_t
+zone_good_size(malloc_zone_t *zone, size_t size)
+{
+  return malloc_good_size_impl(size);
+}
+
+#ifdef MOZ_JEMALLOC
+
+#include "jemalloc/internal/jemalloc_internal.h"
+
+static void
+zone_force_lock(malloc_zone_t *zone)
+{
+  /* /!\ This calls into jemalloc. It works because we're linked in the
+   * same library. Stolen from jemalloc's zone.c. */
+  if (isthreaded)
+    jemalloc_prefork();
+}
+
+static void
+zone_force_unlock(malloc_zone_t *zone)
+{
+  /* /!\ This calls into jemalloc. It works because we're linked in the
+   * same library. Stolen from jemalloc's zone.c. */
+  if (isthreaded)
+    jemalloc_postfork_parent();
+}
+
+#else
+
 #define JEMALLOC_ZONE_VERSION 6
 
 /* Empty implementations are needed, because fork() calls zone->force_(un)lock
@@ -296,7 +403,7 @@ zone_force_unlock(malloc_zone_t *zone)
 {
 }
 
-/* --- */
+#endif
 
 static malloc_zone_t zone;
 static struct malloc_introspection_t zone_introspect;
diff --git a/memory/mozalloc/mozalloc.cpp b/memory/mozalloc/mozalloc.cpp
index 1ae071ea04..55d36d80be 100644
--- a/memory/mozalloc/mozalloc.cpp
+++ b/memory/mozalloc/mozalloc.cpp
@@ -19,6 +19,10 @@
 #define MOZ_MEMORY_IMPL
 #include "mozmemory_wrap.h"
 
+#if defined(XP_DARWIN)
+#include <malloc/malloc.h> // for malloc_size
+#endif
+
 // See mozmemory_wrap.h for more details. This file is part of libmozglue, so
 // it needs to use _impl suffixes. However, with libmozglue growing, this is
 // becoming cumbersome, so we will likely use a malloc.h wrapper of some sort
@@ -149,6 +153,17 @@ moz_posix_memalign(void **ptr, size_t alignment, size_t size)
     if (code)
         return code;
 
+#if defined(XP_DARWIN)
+    // Workaround faulty OSX posix_memalign, which provides memory with the
+    // incorrect alignment sometimes, but returns 0 as if nothing was wrong.
+    size_t mask = alignment - 1;
+    if (((size_t)(*ptr) & mask) != 0) {
+        void* old = *ptr;
+        code = moz_posix_memalign(ptr, alignment, size);
+        free(old);
+    }
+#endif
+
     return code;
 
 }
@@ -188,7 +203,9 @@ moz_malloc_usable_size(void *ptr)
     if (!ptr)
         return 0;
 
-#if defined(HAVE_MALLOC_USABLE_SIZE) || defined(MOZ_MEMORY)
+#if defined(XP_DARWIN)
+    return malloc_size(ptr);
+#elif defined(HAVE_MALLOC_USABLE_SIZE) || defined(MOZ_MEMORY)
     return malloc_usable_size_impl(ptr);
 #elif defined(XP_WIN)
     return _msize(ptr);
diff --git a/memory/volatile/VolatileBuffer.h b/memory/volatile/VolatileBuffer.h
index 19aeb9df2b..b6bcdfcb74 100644
--- a/memory/volatile/VolatileBuffer.h
+++ b/memory/volatile/VolatileBuffer.h
@@ -76,7 +76,9 @@ private:
   void* mBuf;
   size_t mSize;
   int mLockCount;
-#if defined(XP_WIN)
+#ifdef XP_DARWIN
+  bool mHeap;
+#elif defined(XP_WIN)
   bool mHeap;
   bool mFirstLock;
 #endif