diff --git a/memory/mozjemalloc/jemalloc.c b/memory/mozjemalloc/jemalloc.c index ee9e28853..3f44824c8 100644 --- a/memory/mozjemalloc/jemalloc.c +++ b/memory/mozjemalloc/jemalloc.c @@ -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;