roytam1/mozilla45esr
1
0
Fork 0
mirror of https://github.com/roytam1/mozilla45esr.git synced 2026-05-26 06:25:03 +00:00
Code Issues Projects Releases Wiki Activity

jemalloc: update to firefox54-bundled version

Browse Source
This commit is contained in:
Roy Tam
2018-06-11 23:48:49 +08:00
parent dba760c999
commit 968484d318
1 changed files with 115 additions and 393 deletions
Download Patch File Download Diff File Expand all files Collapse all files
memory/mozjemalloc/jemalloc.c
+115 -393
View File
@@ -143,8 +143,14 @@
* Use only one arena by default. Mozilla does not currently make extensive
* use of concurrent allocation, so the increased fragmentation associated with
* multiple arenas is not warranted.
*
* When using the Servo style system, we do indeed make use of significant
* concurrent allocation, and the overhead matters. Bug 1291355 tracks
* investigating the fragmentation overhead of turning this on for users.
*/
#define MOZ_MEMORY_NARENAS_DEFAULT_ONE
#ifndef MOZ_STYLO
#define MOZ_MEMORY_NARENAS_DEFAULT_ONE
#endif
/*
* Pass this set of options to jemalloc as its default. It does not override
@@ -238,7 +244,7 @@
#ifndef NO_TLS
static unsigned long tlsIndex = 0xffffffff;
#endif
#endif
#define __thread
#define _pthread_self() __threadid()
@@ -485,7 +491,7 @@ static const bool isthreaded = true;
# define SIZEOF_PTR_2POW 3
# define NO_TLS
#endif
#ifdef __sparc64__
#if defined(__sparc__) && defined(__arch64__)
# define QUANTUM_2POW_MIN 4
# define SIZEOF_PTR_2POW 3
# define NO_TLS
@@ -536,7 +542,7 @@ static const bool isthreaded = true;
*/
#define CHUNK_2POW_DEFAULT 20
/* Maximum number of dirty pages per arena. */
#define DIRTY_MAX_DEFAULT (1U << 10)
#define DIRTY_MAX_DEFAULT (1U << 8)
/*
* Maximum size of L1 cache line. This is used to avoid cache line aliasing,
@@ -547,11 +553,12 @@ static const bool isthreaded = true;
#define CACHELINE ((size_t)(1U << CACHELINE_2POW))
/*
* Smallest size class to support. On Linux and Mac, even malloc(1) must
* reserve a word's worth of memory (see Mozilla bug 691003).
* Smallest size class to support. On Windows the smallest allocation size
* must be 8 bytes on 32-bit, 16 bytes on 64-bit. On Linux and Mac, even
* malloc(1) must reserve a word's worth of memory (see Mozilla bug 691003).
*/
#ifdef MOZ_MEMORY_WINDOWS
#define TINY_MIN_2POW 1
#define TINY_MIN_2POW (sizeof(void*) == 8 ? 4 : 3)
#else
#define TINY_MIN_2POW (sizeof(void*) == 8 ? 3 : 2)
#endif
@@ -1089,7 +1096,7 @@ static const bool config_recycle = false;
* controlling the malloc behavior are defined as compile-time constants
* for best performance and cannot be altered at runtime.
*/
#if !defined(__ia64__) && !defined(__sparc__) && !defined(__mips__)
#if !defined(__ia64__) && !defined(__sparc__) && !defined(__mips__) && !defined(__aarch64__)
#define MALLOC_STATIC_SIZES 1
#endif
@@ -1103,7 +1110,7 @@ static const bool config_recycle = false;
#if (defined(SOLARIS) || defined(__FreeBSD__)) && \
(defined(__sparc) || defined(__sparcv9) || defined(__ia64))
#define pagesize_2pow ((size_t) 13)
#elif defined(__powerpc64__) || defined(__aarch64__)
#elif defined(__powerpc64__)
#define pagesize_2pow ((size_t) 16)
#else
#define pagesize_2pow ((size_t) 12)
@@ -1444,66 +1451,18 @@ static
#endif
bool malloc_init_hard(void);
static void _malloc_prefork(void);
static void _malloc_postfork(void);
#ifdef MOZ_MEMORY_DARWIN
/*
* MALLOC_ZONE_T_NOTE
*
* On Darwin, we hook into the memory allocator using a malloc_zone_t struct.
* We must be very careful around this struct because of different behaviour on
* different versions of OSX.
*
* Each of OSX 10.5, 10.6 and 10.7 use different versions of the struct
* (with version numbers 3, 6 and 8 respectively). The binary we use on each of
* these platforms will not necessarily be built using the correct SDK [1].
* This means we need to statically know the correct struct size to use on all
* OSX releases, and have a fallback for unknown future versions. The struct
* sizes defined in osx_zone_types.h.
*
* For OSX 10.8 and later, we may expect the malloc_zone_t struct to change
* again, and need to dynamically account for this. By simply leaving
* malloc_zone_t alone, we don't quite deal with the problem, because there
* remain calls to jemalloc through the mozalloc interface. We check this
* dynamically on each allocation, using the CHECK_DARWIN macro and
* osx_use_jemalloc.
*
*
* [1] Mozilla is built as a universal binary on Mac, supporting i386 and
* x86_64. The i386 target is built using the 10.5 SDK, even if it runs on
* 10.6. The x86_64 target is built using the 10.6 SDK, even if it runs on
* 10.7 or later, or 10.5.
*
* FIXME:
* When later versions of OSX come out (10.8 and up), we need to check their
* malloc_zone_t versions. If they're greater than 8, we need a new version
* of malloc_zone_t adapted into osx_zone_types.h.
*/
#ifndef MOZ_REPLACE_MALLOC
#include "osx_zone_types.h"
#define LEOPARD_MALLOC_ZONE_T_VERSION 3
#define SNOW_LEOPARD_MALLOC_ZONE_T_VERSION 6
#define LION_MALLOC_ZONE_T_VERSION 8
static bool osx_use_jemalloc = false;
static lion_malloc_zone l_szone;
static malloc_zone_t * szone = (malloc_zone_t*)(&l_szone);
static lion_malloc_introspection l_ozone_introspect;
static malloc_introspection_t * const ozone_introspect =
(malloc_introspection_t*)(&l_ozone_introspect);
static void szone2ozone(malloc_zone_t *zone, size_t size);
static size_t zone_version_size(int version);
#else
static const bool osx_use_jemalloc = true;
#ifndef MOZ_MEMORY_DARWIN
static
#endif
void _malloc_prefork(void);
#ifndef MOZ_MEMORY_DARWIN
static
#endif
void _malloc_postfork_parent(void);
#ifndef MOZ_MEMORY_DARWIN
static
#endif
void _malloc_postfork_child(void);
/*
* End function prototypes.
@@ -1703,6 +1662,9 @@ malloc_mutex_unlock(malloc_mutex_t *mutex)
#endif
}
#if (defined(__GNUC__))
__attribute__((unused))
# endif
static bool
malloc_spin_init(malloc_spinlock_t *lock)
{
@@ -2408,7 +2370,7 @@ static void *
pages_map(void *addr, size_t size)
{
void *ret;
#if defined(__ia64__)
#if defined(__ia64__) || (defined(__sparc__) && defined(__arch64__) && defined(__linux__))
/*
* The JS engine assumes that all allocated pointers have their high 17 bits clear,
* which ia64's mmap doesn't support directly. However, we can emulate it by passing
@@ -2416,10 +2378,10 @@ pages_map(void *addr, size_t size)
* or the nearest available memory above that address, providing a near-guarantee
* that those bits are clear. If they are not, we return NULL below to indicate
* out-of-memory.
*
* The addr is chosen as 0x0000070000000000, which still allows about 120TB of virtual
*
* The addr is chosen as 0x0000070000000000, which still allows about 120TB of virtual
* address space.
*
*
* See Bug 589735 for more information.
*/
bool check_placement = true;
@@ -2429,6 +2391,28 @@ pages_map(void *addr, size_t size)
}
#endif
#if defined(__sparc__) && defined(__arch64__) && defined(__linux__)
const uintptr_t start = 0x0000070000000000ULL;
const uintptr_t end = 0x0000800000000000ULL;
/* Copied from js/src/gc/Memory.cpp and adapted for this source */
uintptr_t hint;
void* region = MAP_FAILED;
for (hint = start; region == MAP_FAILED && hint + size <= end; hint += chunksize) {
region = mmap((void*)hint, size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (region != MAP_FAILED) {
if (((size_t) region + (size - 1)) & 0xffff800000000000) {
if (munmap(region, size)) {
MOZ_ASSERT(errno == ENOMEM);
}
region = MAP_FAILED;
}
}
}
ret = region;
#else
/*
* We don't use MAP_FIXED here, because it can cause the *replacement*
* of existing mappings, and we only want to create new mappings.
@@ -2436,13 +2420,13 @@ pages_map(void *addr, size_t size)
ret = mmap(addr, size, PROT_READ | PROT_WRITE,
MAP_PRIVATE | MAP_ANON, -1, 0);
assert(ret != NULL);
#endif
if (ret == MAP_FAILED) {
ret = NULL;
}
#if defined(__ia64__)
/*
* If the allocated memory doesn't have its upper 17 bits clear, consider it
#if defined(__ia64__) || (defined(__sparc__) && defined(__arch64__) && defined(__linux__))
/*
* If the allocated memory doesn't have its upper 17 bits clear, consider it
* as out of memory.
*/
else if ((long long)ret & 0xffff800000000000) {
@@ -2473,7 +2457,7 @@ pages_map(void *addr, size_t size)
MozTagAnonymousMemory(ret, size, "jemalloc");
}
#if defined(__ia64__)
#if defined(__ia64__) || (defined(__sparc__) && defined(__arch64__) && defined(__linux__))
assert(ret == NULL || (!check_placement && ret != NULL)
|| (check_placement && ret == addr));
#else
@@ -4678,9 +4662,6 @@ arena_dalloc_small(arena_t *arena, arena_chunk_t *chunk, void *ptr,
static void
arena_dalloc_large(arena_t *arena, arena_chunk_t *chunk, void *ptr)
{
/* Large allocation. */
malloc_spin_lock(&arena->lock);
#ifdef MALLOC_FILL
#ifndef MALLOC_STATS
if (opt_poison)
@@ -4706,7 +4687,6 @@ arena_dalloc_large(arena_t *arena, arena_chunk_t *chunk, void *ptr)
#endif
arena_run_dalloc(arena, (arena_run_t *)ptr, true);
malloc_spin_unlock(&arena->lock);
}
static inline void
@@ -4726,16 +4706,18 @@ arena_dalloc(void *ptr, size_t offset)
assert(arena != NULL);
RELEASE_ASSERT(arena->magic == ARENA_MAGIC);
malloc_spin_lock(&arena->lock);
pageind = offset >> pagesize_2pow;
mapelm = &chunk->map[pageind];
RELEASE_ASSERT((mapelm->bits & CHUNK_MAP_ALLOCATED) != 0);
if ((mapelm->bits & CHUNK_MAP_LARGE) == 0) {
/* Small allocation. */
malloc_spin_lock(&arena->lock);
arena_dalloc_small(arena, chunk, ptr, mapelm);
malloc_spin_unlock(&arena->lock);
} else
} else {
/* Large allocation. */
arena_dalloc_large(arena, chunk, ptr);
}
malloc_spin_unlock(&arena->lock);
}
static inline void
@@ -4783,15 +4765,15 @@ arena_ralloc_large_grow(arena_t *arena, arena_chunk_t *chunk, void *ptr,
size_t pageind = ((uintptr_t)ptr - (uintptr_t)chunk) >> pagesize_2pow;
size_t npages = oldsize >> pagesize_2pow;
RELEASE_ASSERT(oldsize == (chunk->map[pageind].bits & ~pagesize_mask));
/* Try to extend the run. */
assert(size > oldsize);
#ifdef MALLOC_BALANCE
arena_lock_balance(arena);
#else
malloc_spin_lock(&arena->lock);
#endif
RELEASE_ASSERT(oldsize == (chunk->map[pageind].bits & ~pagesize_mask));
/* Try to extend the run. */
assert(size > oldsize);
if (pageind + npages < chunk_npages && (chunk->map[pageind+npages].bits
& CHUNK_MAP_ALLOCATED) == 0 && (chunk->map[pageind+npages].bits &
~pagesize_mask) >= size - oldsize) {
@@ -5547,6 +5529,10 @@ malloc_init(void)
}
#endif
#if defined(MOZ_MEMORY_DARWIN) && !defined(MOZ_REPLACE_MALLOC)
extern void register_zone(void);
#endif
#if !defined(MOZ_MEMORY_WINDOWS)
static
#endif
@@ -5560,9 +5546,6 @@ malloc_init_hard(void)
#ifndef MOZ_MEMORY_WINDOWS
int linklen;
#endif
#ifdef MOZ_MEMORY_DARWIN
malloc_zone_t* default_zone;
#endif
#ifndef MOZ_MEMORY_WINDOWS
malloc_mutex_lock(&init_lock);
@@ -5614,7 +5597,7 @@ malloc_init_hard(void)
"", "");
abort();
}
#else
#else
pagesize = (size_t) result;
pagesize_mask = (size_t) result - 1;
pagesize_2pow = ffs((int)result) - 1;
@@ -6058,7 +6041,7 @@ MALLOC_OUT:
#if !defined(MOZ_MEMORY_WINDOWS) && !defined(MOZ_MEMORY_DARWIN)
/* Prevent potential deadlock on malloc locks after fork. */
pthread_atfork(_malloc_prefork, _malloc_postfork, _malloc_postfork);
pthread_atfork(_malloc_prefork, _malloc_postfork_parent, _malloc_postfork_child);
#endif
#if defined(NEEDS_PTHREAD_MMAP_UNALIGNED_TSD)
@@ -6068,45 +6051,7 @@ MALLOC_OUT:
#endif
#if defined(MOZ_MEMORY_DARWIN) && !defined(MOZ_REPLACE_MALLOC)
/*
* Overwrite the default memory allocator to use jemalloc everywhere.
*/
default_zone = malloc_default_zone();
/*
* We only use jemalloc with MacOS 10.6 and 10.7. jemalloc is disabled
* on 32-bit builds (10.5 and 32-bit 10.6) due to bug 702250, an
* apparent MacOS bug. In fact, this code isn't even compiled on
* 32-bit builds.
*
* We'll have to update our code to work with newer versions, because
* the malloc zone layout is likely to change.
*/
osx_use_jemalloc = (default_zone->version == SNOW_LEOPARD_MALLOC_ZONE_T_VERSION ||
default_zone->version == LION_MALLOC_ZONE_T_VERSION);
/* Allow us dynamically turn off jemalloc for testing. */
if (getenv("NO_MAC_JEMALLOC")) {
osx_use_jemalloc = false;
#ifdef __i386__
malloc_printf("Warning: NO_MAC_JEMALLOC has no effect on "
"i386 machines (such as this one).\n");
#endif
}
if (osx_use_jemalloc) {
/*
* Convert the default szone to an "overlay zone" that is capable
* of deallocating szone-allocated objects, but allocating new
* objects from jemalloc.
*/
size_t size = zone_version_size(default_zone->version);
szone2ozone(default_zone, size);
}
else {
szone = default_zone;
}
register_zone();
#endif
#ifndef MOZ_MEMORY_WINDOWS
@@ -6133,32 +6078,11 @@ malloc_shutdown()
* Begin malloc(3)-compatible functions.
*/
/*
* Even though we compile with MOZ_MEMORY, we may have to dynamically decide
* not to use jemalloc, as discussed above. However, we call jemalloc
* functions directly from mozalloc. Since it's pretty dangerous to mix the
* allocators, we need to call the OSX allocators from the functions below,
* when osx_use_jemalloc is not (dynamically) set.
*
* Note that we assume jemalloc is enabled on i386. This is safe because the
* only i386 versions of MacOS are 10.5 and 10.6, which we support. We have to
* do this because madvise isn't in the malloc zone struct for 10.5.
*
* This means that NO_MAC_JEMALLOC doesn't work on i386.
*/
#if defined(MOZ_MEMORY_DARWIN) && !defined(__i386__) && !defined(MOZ_REPLACE_MALLOC)
#define DARWIN_ONLY(A) if (!osx_use_jemalloc) { A; }
#else
#define DARWIN_ONLY(A)
#endif
MOZ_MEMORY_API void *
malloc_impl(size_t size)
{
void *ret;
DARWIN_ONLY(return (szone->malloc)(szone, size));
if (malloc_init()) {
ret = NULL;
goto RETURN;
@@ -6241,8 +6165,6 @@ MEMALIGN(size_t alignment, size_t size)
{
void *ret;
DARWIN_ONLY(return (szone->memalign)(szone, alignment, size));
assert(((alignment - 1) & alignment) == 0);
if (malloc_init()) {
@@ -6341,8 +6263,6 @@ calloc_impl(size_t num, size_t size)
void *ret;
size_t num_size;
DARWIN_ONLY(return (szone->calloc)(szone, num, size));
if (malloc_init()) {
num_size = 0;
ret = NULL;
@@ -6397,8 +6317,6 @@ realloc_impl(void *ptr, size_t size)
{
void *ret;
DARWIN_ONLY(return (szone->realloc)(szone, ptr, size));
if (size == 0) {
#ifdef MALLOC_SYSV
if (opt_sysv == false)
@@ -6460,8 +6378,6 @@ MOZ_MEMORY_API void
free_impl(void *ptr)
{
size_t offset;
DARWIN_ONLY((szone->free)(szone, ptr); return);
UTRACE(ptr, 0, 0);
@@ -6530,11 +6446,14 @@ malloc_good_size_impl(size_t size)
}
#if defined(MOZ_MEMORY_ANDROID) && (ANDROID_VERSION < 19)
MOZ_MEMORY_API size_t
malloc_usable_size_impl(MALLOC_USABLE_SIZE_CONST_PTR void *ptr)
malloc_usable_size_impl(void *ptr)
#else
MOZ_MEMORY_API size_t
malloc_usable_size_impl(const void *ptr)
#endif
{
DARWIN_ONLY(return (szone->size)(szone, ptr));
#ifdef MALLOC_VALIDATE
return (isalloc_validate(ptr));
#else
@@ -6655,8 +6574,6 @@ jemalloc_stats_impl(jemalloc_stats_t *stats)
for (j = 0; j < ntbins + nqbins + nsbins; j++) {
arena_bin_t* bin = &arena->bins[j];
size_t bin_unused = 0;
const size_t run_header_size = sizeof(arena_run_t) +
(sizeof(unsigned) * (bin->regs_mask_nelms - 1));
rb_foreach_begin(arena_chunk_map_t, link, &bin->runs, mapelm) {
run = (arena_run_t *)(mapelm->bits & ~pagesize_mask);
@@ -6854,7 +6771,10 @@ jemalloc_free_dirty_pages_impl(void)
* is threaded here.
*/
static void
#ifndef MOZ_MEMORY_DARWIN
static
#endif
void
_malloc_prefork(void)
{
unsigned i;
@@ -6872,8 +6792,11 @@ _malloc_prefork(void)
malloc_mutex_lock(&huge_mtx);
}
static void
_malloc_postfork(void)
#ifndef MOZ_MEMORY_DARWIN
static
#endif
void
_malloc_postfork_parent(void)
{
unsigned i;
@@ -6890,6 +6813,27 @@ _malloc_postfork(void)
malloc_spin_unlock(&arenas_lock);
}
#ifndef MOZ_MEMORY_DARWIN
static
#endif
void
_malloc_postfork_child(void)
{
unsigned i;
/* Reinitialize all mutexes, now that fork() has completed. */
malloc_mutex_init(&huge_mtx);
malloc_mutex_init(&base_mtx);
for (i = 0; i < narenas; i++) {
if (arenas[i] != NULL)
malloc_spin_init(&arenas[i]->lock);
}
malloc_spin_init(&arenas_lock);
}
/*
* End library-private functions.
*/
@@ -6901,228 +6845,6 @@ _malloc_postfork(void)
#if defined(MOZ_MEMORY_DARWIN)
#if !defined(MOZ_REPLACE_MALLOC)
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_valloc(malloc_zone_t *zone, size_t size)
{
void *ret = NULL; /* Assignment avoids useless compiler warning. */
posix_memalign_impl(&ret, pagesize, size);
return (ret);
}
static void *
zone_memalign(malloc_zone_t *zone, size_t alignment, size_t size)
{
return (memalign_impl(alignment, size));
}
static void *
zone_destroy(malloc_zone_t *zone)
{
/* This function should never be called. */
assert(false);
return (NULL);
}
static size_t
zone_good_size(malloc_zone_t *zone, size_t size)
{
return malloc_good_size_impl(size);
}
static size_t
ozone_size(malloc_zone_t *zone, void *ptr)
{
size_t ret = isalloc_validate(ptr);
if (ret == 0)
ret = szone->size(zone, ptr);
return ret;
}
static void
ozone_free(malloc_zone_t *zone, void *ptr)
{
if (isalloc_validate(ptr) != 0)
free_impl(ptr);
else {
size_t size = szone->size(zone, ptr);
if (size != 0)
(szone->free)(zone, ptr);
/* Otherwise we leak. */
}
}
static void *
ozone_realloc(malloc_zone_t *zone, void *ptr, size_t size)
{
size_t oldsize;
if (ptr == NULL)
return (malloc_impl(size));
oldsize = isalloc_validate(ptr);
if (oldsize != 0)
return (realloc_impl(ptr, size));
else {
oldsize = szone->size(zone, ptr);
if (oldsize == 0)
return (malloc_impl(size));
else {
void *ret = malloc_impl(size);
if (ret != NULL) {
memcpy(ret, ptr, (oldsize < size) ? oldsize :
size);
(szone->free)(zone, ptr);
}
return (ret);
}
}
}
static unsigned
ozone_batch_malloc(malloc_zone_t *zone, size_t size, void **results,
unsigned num_requested)
{
/* Don't bother implementing this interface, since it isn't required. */
return 0;
}
static void
ozone_batch_free(malloc_zone_t *zone, void **to_be_freed, unsigned num)
{
unsigned i;
for (i = 0; i < num; i++)
ozone_free(zone, to_be_freed[i]);
}
static void
ozone_free_definite_size(malloc_zone_t *zone, void *ptr, size_t size)
{
if (isalloc_validate(ptr) != 0) {
assert(isalloc_validate(ptr) == size);
free_impl(ptr);
} else {
assert(size == szone->size(zone, ptr));
l_szone.m16(zone, ptr, size);
}
}
static void
ozone_force_lock(malloc_zone_t *zone)
{
_malloc_prefork();
szone->introspect->force_lock(zone);
}
static void
ozone_force_unlock(malloc_zone_t *zone)
{
szone->introspect->force_unlock(zone);
_malloc_postfork();
}
static size_t
zone_version_size(int version)
{
switch (version)
{
case SNOW_LEOPARD_MALLOC_ZONE_T_VERSION:
return sizeof(snow_leopard_malloc_zone);
case LEOPARD_MALLOC_ZONE_T_VERSION:
return sizeof(leopard_malloc_zone);
default:
case LION_MALLOC_ZONE_T_VERSION:
return sizeof(lion_malloc_zone);
}
}
/*
* Overlay the default scalable zone (szone) such that existing allocations are
* drained, and further allocations come from jemalloc. This is necessary
* because Core Foundation directly accesses and uses the szone before the
* jemalloc library is even loaded.
*/
static void
szone2ozone(malloc_zone_t *default_zone, size_t size)
{
lion_malloc_zone *l_zone;
assert(malloc_initialized);
/*
* Stash a copy of the original szone so that we can call its
* functions as needed. Note that internally, the szone stores its
* bookkeeping data structures immediately following the malloc_zone_t
* header, so when calling szone functions, we need to pass a pointer to
* the original zone structure.
*/
memcpy(szone, default_zone, size);
/* OSX 10.7 allocates the default zone in protected memory. */
if (default_zone->version >= LION_MALLOC_ZONE_T_VERSION) {
void* start_of_page = (void*)((size_t)(default_zone) & ~pagesize_mask);
mprotect (start_of_page, size, PROT_READ | PROT_WRITE);
}
default_zone->size = (void *)ozone_size;
default_zone->malloc = (void *)zone_malloc;
default_zone->calloc = (void *)zone_calloc;
default_zone->valloc = (void *)zone_valloc;
default_zone->free = (void *)ozone_free;
default_zone->realloc = (void *)ozone_realloc;
default_zone->destroy = (void *)zone_destroy;
default_zone->batch_malloc = NULL;
default_zone->batch_free = ozone_batch_free;
default_zone->introspect = ozone_introspect;
/* Don't modify default_zone->zone_name; Mac libc may rely on the name
* being unchanged. See Mozilla bug 694896. */
ozone_introspect->enumerator = NULL;
ozone_introspect->good_size = (void *)zone_good_size;
ozone_introspect->check = NULL;
ozone_introspect->print = NULL;
ozone_introspect->log = NULL;
ozone_introspect->force_lock = (void *)ozone_force_lock;
ozone_introspect->force_unlock = (void *)ozone_force_unlock;
ozone_introspect->statistics = NULL;
/* Platform-dependent structs */
l_zone = (lion_malloc_zone*)(default_zone);
if (default_zone->version >= SNOW_LEOPARD_MALLOC_ZONE_T_VERSION) {
l_zone->m15 = (void (*)())zone_memalign;
l_zone->m16 = (void (*)())ozone_free_definite_size;
l_ozone_introspect.m9 = NULL;
}
if (default_zone->version >= LION_MALLOC_ZONE_T_VERSION) {
l_zone->m17 = NULL;
l_ozone_introspect.m10 = NULL;
l_ozone_introspect.m11 = NULL;
l_ozone_introspect.m12 = NULL;
l_ozone_introspect.m13 = NULL;
}
}
#endif
__attribute__((constructor))
void
jemalloc_darwin_init(void)
@@ -7174,8 +6896,8 @@ MOZ_MEMORY_API void *(*__memalign_hook)(size_t alignment, size_t size) = MEMALIG
* we need to initialize the heap at the first opportunity we get.
* DLL_PROCESS_ATTACH in DllMain is that opportunity.
*/
BOOL APIENTRY DllMain(HINSTANCE hModule,
DWORD reason,
BOOL APIENTRY DllMain(HINSTANCE hModule,
DWORD reason,
LPVOID lpReserved)
{
switch (reason) {
@@ -7186,7 +6908,7 @@ BOOL APIENTRY DllMain(HINSTANCE hModule,
/* Initialize the heap */
malloc_init_hard();
break;
case DLL_PROCESS_DETACH:
break;