--- a/Makefile.in
+++ b/Makefile.in
@@ -60,23 +60,25 @@ TIERS += base
 #
 tier_base_dirs = \
 	config \
 	build \
 	probes \
 	$(NULL)
 
 ifndef LIBXUL_SDK
-tier_base_dirs += \
-	memory \
-	$(NULL)
+ifdef MOZ_MEMORY
+tier_base_dirs += memory/jemalloc
+endif
+
 ifeq ($(OS_TARGET),Android)
 tier_base_dirs += other-licenses/android
 endif
 
+tier_base_dirs += memory/mozalloc
 endif
 
 ifdef COMPILE_ENVIRONMENT
 include $(topsrcdir)/$(MOZ_BUILD_APP)/build.mk
 endif
 
 
 include $(topsrcdir)/config/config.mk

--- a/configure.in
+++ b/configure.in
@@ -7399,17 +7399,17 @@ else
     ;;
   *-*freebsd*)
     AC_DEFINE(MOZ_MEMORY_BSD)
     ;;
   *-android*|*-linuxandroid*)
     AC_DEFINE(MOZ_MEMORY_LINUX)
     AC_DEFINE(MOZ_MEMORY_ANDROID)
     _WRAP_MALLOC=1
-    export WRAP_MALLOC_LIB="-L$_objdir/dist/lib -lmozalloc -lmozutils"
+    export WRAP_MALLOC_LIB="-L$_objdir/dist/lib -lmozutils"
     WRAP_MALLOC_CFLAGS="-Wl,--wrap=dlopen -Wl,--wrap=dlclose -Wl,--wrap=dlerror -Wl,--wrap=dlsym -Wl,--wrap=dladdr"
     ;;
   *-*linux*)
     AC_DEFINE(MOZ_MEMORY_LINUX)
     ;;
   *-netbsd*)
     AC_DEFINE(MOZ_MEMORY_BSD)
     ;;
@@ -7460,17 +7460,17 @@ dnl = Use malloc wrapper lib
 dnl ========================================================
 MOZ_ARG_ENABLE_BOOL(wrap-malloc,
 [  --enable-wrap-malloc    Wrap malloc calls (gnu linker only)],
     _WRAP_MALLOC=1,
     _WRAP_MALLOC= )
 
 if test -n "$_WRAP_MALLOC"; then
     if test "$GNU_CC"; then
-    WRAP_MALLOC_CFLAGS="${LDFLAGS} ${WRAP_MALLOC_CFLAGS} -Wl,--wrap -Wl,malloc -Wl,--wrap -Wl,calloc -Wl,--wrap -Wl,valloc -Wl,--wrap -Wl,free -Wl,--wrap -Wl,realloc -Wl,--wrap -Wl,memalign -Wl,--wrap -Wl,__builtin_new -Wl,--wrap -Wl,__builtin_vec_new -Wl,--wrap -Wl,__builtin_delete -Wl,--wrap -Wl,__builtin_vec_delete -Wl,--wrap -Wl,PR_Free -Wl,--wrap -Wl,PR_Malloc -Wl,--wrap -Wl,PR_Calloc -Wl,--wrap -Wl,PR_Realloc -Wl,--wrap -Wl,strdup -Wl,--wrap -Wl,strndup -Wl,--wrap -Wl,posix_memalign"
+    WRAP_MALLOC_CFLAGS="${LDFLAGS} ${WRAP_MALLOC_CFLAGS} -Wl,--wrap -Wl,malloc -Wl,--wrap -Wl,calloc -Wl,--wrap -Wl,valloc -Wl,--wrap -Wl,free -Wl,--wrap -Wl,realloc -Wl,--wrap -Wl,memalign -Wl,--wrap -Wl,__builtin_new -Wl,--wrap -Wl,__builtin_vec_new -Wl,--wrap -Wl,__builtin_delete -Wl,--wrap -Wl,__builtin_vec_delete -Wl,--wrap -Wl,PR_Free -Wl,--wrap -Wl,PR_Malloc -Wl,--wrap -Wl,PR_Calloc -Wl,--wrap -Wl,PR_Realloc -Wl,--wrap -Wl,strdup -Wl,--wrap -Wl,strndup -Wl,--wrap -Wl,posix_memalign -Wl,--wrap,malloc_usable_size"
     MKSHLIB="$MKSHLIB"' $(WRAP_MALLOC_CFLAGS) $(WRAP_MALLOC_LIB)'
     MKCSHLIB="$MKCSHLIB"' $(WRAP_MALLOC_CFLAGS) $(WRAP_MALLOC_LIB)'
     fi
 fi
 
 dnl ========================================================
 dnl = Location of malloc wrapper lib
 dnl ========================================================

--- a/memory/jemalloc/Makefile.in
+++ b/memory/jemalloc/Makefile.in
@@ -71,29 +71,29 @@ MODULE_OPTIMIZE_FLAGS = -xO5
 endif
 endif
 
 # Build jemalloc as a shared lib.  This is mandatory for Darwin, since a library
 # init function is used on that platform.
 ifeq ($(OS_ARCH),Darwin)
 FORCE_SHARED_LIB= 1
 else
+# On Android, we're going to link jemalloc into mozutils, and that only works
+# properly if we only build a fakelib, which won't happen if we DIST_INSTALL
+ifneq ($(OS_TARGET),Android)
 DIST_INSTALL = 1
+endif
 FORCE_STATIC_LIB= 1
 endif
 
 #XXX: PGO on Linux causes problems here
 # See bug 419470
 NO_PROFILE_GUIDED_OPTIMIZE = 1
 endif
 
-ifdef WRAP_MALLOC_CFLAGS
-DEFINES += -DWRAP_MALLOC
-endif
-
 include $(topsrcdir)/config/rules.mk
 
 ifeq (Darwin,$(OS_TARGET))
 LDFLAGS += -init _jemalloc_darwin_init
 endif
 
 ifeq (WINNT,$(OS_TARGET))
 # Roll our own custom logic here for the import library

--- a/memory/jemalloc/jemalloc.c
+++ b/memory/jemalloc/jemalloc.c
@@ -5835,40 +5835,64 @@ malloc_shutdown()
 /******************************************************************************/
 /*
  * Begin malloc(3)-compatible functions.
  */
 
 /*
  * Mangle standard interfaces, in order to avoid linking problems.
  */
-#if defined(MOZ_MEMORY_DARWIN) || defined(MOZ_MEMORY_ANDROID) || \
-    defined(WRAP_MALLOC) || defined(MOZ_MEMORY_WINDOWS)
-inline void sys_free(void* ptr) {return free(ptr);}
-#define	malloc(a)               je_malloc(a)
-#if defined(MOZ_MEMORY_WINDOWS) || defined(MOZ_MEMORY_DARWIN)
-#define	memalign(a, b)          je_memalign(a, b)
-#endif
-#define	posix_memalign(a, b, c) je_posix_memalign(a, b, c)
-#define	valloc(a)               je_valloc(a)
-#define	calloc(a, b)            je_calloc(a, b)
-#define	realloc(a, b)           je_realloc(a, b)
-#define	free(a)                 je_free(a)
-#define	malloc_usable_size(a)   je_malloc_usable_size(a)
- 
-
-char    *je_strndup(const char *src, size_t len) {
-  char* dst = (char*)je_malloc(len + 1);
-  if(dst)
-    strncpy(dst, src, len + 1);
-  return dst;
+#if defined(MOZ_MEMORY_DARWIN) || defined(MOZ_MEMORY_WINDOWS) || \
+    defined(MOZ_MEMORY_ANDROID)
+
+#ifdef MOZ_MEMORY_ANDROID
+/*
+ * On Android, we use __wrap_* instead of je_* to accomodate with the
+ * linker's --wrap option we use. That option prefixes the function
+ * names it is given with __wrap_.
+ */
+#define wrap(a) __wrap_ ## a
+
+/* Extra wrappers for NSPR alloc functions */
+void *
+__wrap_PR_Malloc(size_t size) __attribute__((alias("__wrap_malloc")));
+void *
+__wrap_PR_Calloc(size_t num, size_t size) __attribute__((alias("__wrap_calloc")));
+void *
+__wrap_PR_Realloc(void *ptr, size_t size) __attribute__((alias("__wrap_realloc")));
+void
+__wrap_PR_Free(void *ptr) __attribute__((alias("__wrap_free")));
+
+#else
+#define wrap(a) je_ ## a
+#endif
+
+#define malloc(a)               wrap(malloc)(a)
+#define memalign(a, b)          wrap(memalign)(a, b)
+#define posix_memalign(a, b, c) wrap(posix_memalign)(a, b, c)
+#define valloc(a)               wrap(valloc)(a)
+#define calloc(a, b)            wrap(calloc)(a, b)
+#define realloc(a, b)           wrap(realloc)(a, b)
+#define free(a)                 wrap(free)(a)
+#define malloc_usable_size(a)   wrap(malloc_usable_size)(a)
+
+void *malloc(size_t size);
+
+char *
+wrap(strndup)(const char *src, size_t len) {
+	char* dst = (char*) malloc(len + 1);
+	if (dst)
+		strncpy(dst, src, len + 1);
+	return dst;
 }
-char    *je_strdup(const char *src) {
-  size_t len = strlen(src);
-  return je_strndup(src, len );
+
+char *
+wrap(strdup)(const char *src) {
+	size_t len = strlen(src);
+	return wrap(strndup)(src, len);
 }
 #endif
 
 /*
  * We are not able to assume that we can replace the OSX allocator with
  * jemalloc on future unreleased versions of OSX. Despite this, 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
@@ -6007,19 +6031,18 @@ RETURN:
 		abort();
 	}
 #endif
 	UTRACE(0, size, ret);
 	return (ret);
 }
 
 #ifdef MOZ_MEMORY_ELF
-extern __typeof(memalign_internal)
-        memalign __attribute__((alias ("memalign_internal"),
-				visibility ("default")));
+extern void *
+memalign(size_t alignment, size_t size) __attribute__((alias ("memalign_internal"), visibility ("default")));
 #endif
 
 int
 posix_memalign(void **memptr, size_t alignment, size_t size)
 {
 	void *result;
 
 	/* Make sure that alignment is a large enough power of 2. */
@@ -6766,22 +6789,20 @@ jemalloc_darwin_init(void)
  * glibc provides the RTLD_DEEPBIND flag for dlopen which can make it possible
  * to inconsistently reference libc's malloc(3)-compatible functions
  * (bug 493541).
  *
  * These definitions interpose hooks in glibc.  The functions are actually
  * passed an extra argument for the caller return address, which will be
  * ignored.
  */
-#ifndef WRAP_MALLOC
 void (*__free_hook)(void *ptr) = free;
 void *(*__malloc_hook)(size_t size) = malloc;
 void *(*__realloc_hook)(void *ptr, size_t size) = realloc;
 void *(*__memalign_hook)(size_t alignment, size_t size) = MEMALIGN;
-#endif
 
 #elif defined(RTLD_DEEPBIND)
 /*
  * XXX On systems that support RTLD_GROUP or DF_1_GROUP, do their
  * implementations permit similar inconsistencies?  Should STV_SINGLETON
  * visibility be used for interposition where available?
  */
 #  error "Interposing malloc is unsafe on this system without libc malloc hooks."

--- a/memory/jemalloc/jemalloc.h
+++ b/memory/jemalloc/jemalloc.h
@@ -45,33 +45,33 @@ extern const char *_malloc_options;
 void	*malloc(size_t size);
 void	*valloc(size_t size);
 void	*calloc(size_t num, size_t size);
 void	*realloc(void *ptr, size_t size);
 void	free(void *ptr);
 int	posix_memalign(void **memptr, size_t alignment, size_t size);
 #endif /* MOZ_MEMORY_DARWIN, MOZ_MEMORY_LINUX */
 
-#if defined(MOZ_MEMORY_DARWIN) || defined(MOZ_MEMORY_ANDROID) || \
-    defined(WRAP_MALLOC) || defined(MOZ_MEMORY_WINDOWS)
+/* Android doesn't have posix_memalign */
+#ifdef MOZ_MEMORY_ANDROID
+int	posix_memalign(void **memptr, size_t alignment, size_t size);
+#endif
+
+#if defined(MOZ_MEMORY_DARWIN) || defined(MOZ_MEMORY_WINDOWS)
 void	*je_malloc(size_t size);
 void	*je_valloc(size_t size);
 void	*je_calloc(size_t num, size_t size);
 void	*je_realloc(void *ptr, size_t size);
 void	je_free(void *ptr);
 void *je_memalign(size_t alignment, size_t size);
 int	je_posix_memalign(void **memptr, size_t alignment, size_t size);
 char    *je_strndup(const char *src, size_t len);
 char    *je_strdup(const char *src);
-#if defined(MOZ_MEMORY_ANDROID)
-size_t  je_malloc_usable_size(void *ptr);
-#else
 size_t	je_malloc_usable_size(const void *ptr);
 #endif
-#endif
 
 /* Linux has memalign and malloc_usable_size */
 #if !defined(MOZ_MEMORY_LINUX)
 void	*memalign(size_t alignment, size_t size);
 size_t	malloc_usable_size(const void *ptr);
 #endif /* MOZ_MEMORY_LINUX */
 
 void	jemalloc_stats(jemalloc_stats_t *stats);

--- a/memory/mozalloc/Makefile.in
+++ b/memory/mozalloc/Makefile.in
@@ -50,26 +50,16 @@ STL_FLAGS	= -D_HAS_EXCEPTIONS=0
 endif
 
 MODULE		= mozalloc
 LIBRARY_NAME	= mozalloc
 FORCE_SHARED_LIB= 1
 DIST_INSTALL 	= 1
 
 ifdef MOZ_MEMORY
-ifneq (,$(findstring mozalloc,$(WRAP_MALLOC_LIB)))
-EXTRA_DSO_LDOPTS += $(DIST)/lib/libjemalloc.a
-WRAP_MALLOC_LIB=
-WRAP_MALLOC_CFLAGS=
-DEFINES += -DWRAP_MALLOC_WITH_JEMALLOC
-CSRCS = ld_malloc_wrappers.c
-ifeq (,$(filter-out Linux,$(OS_TARGET)))
-EXTRA_DSO_LDOPTS += -lpthread
-endif
-endif
 ifeq ($(OS_ARCH),Darwin)
 EXTRA_DSO_LDOPTS += -L$(DIST)/lib -ljemalloc
 endif
 endif
 
 ifeq (,$(filter-out OS2,$(OS_ARCH)))
 # The strndup declaration in string.h is in an ifdef __USE_GNU section
 DEFINES		+= -D_GNU_SOURCE

deleted file mode 100644
--- a/memory/mozalloc/ld_malloc_wrappers.c
+++ /dev/null
@@ -1,140 +0,0 @@
-/* ***** BEGIN LICENSE BLOCK *****
- * Version: MPL 1.1/GPL 2.0/LGPL 2.1
- *
- * The contents of this file are subject to the Mozilla Public License Version
- * 1.1 (the "License"); you may not use this file except in compliance with
- * the License. You may obtain a copy of the License at
- * http://www.mozilla.org/MPL/
- *
- * Software distributed under the License is distributed on an "AS IS" basis,
- * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
- * for the specific language governing rights and limitations under the
- * License.
- *
- * The Original Code is mozilla.org code.
- *
- * The Initial Developer of the Original Code is
- * Mozilla Foundation.
- * Portions created by the Initial Developer are Copyright (C) 2010
- * the Initial Developer. All Rights Reserved.
- *
- * Contributor(s):
- *  Brad Lassey <blassey@mozilla.com>
- *
- * Alternatively, the contents of this file may be used under the terms of
- * either the GNU General Public License Version 2 or later (the "GPL"), or
- * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
- * in which case the provisions of the GPL or the LGPL are applicable instead
- * of those above. If you wish to allow use of your version of this file only
- * under the terms of either the GPL or the LGPL, and not to allow others to
- * use your version of this file under the terms of the MPL, indicate your
- * decision by deleting the provisions above and replace them with the notice
- * and other provisions required by the GPL or the LGPL. If you do not delete
- * the provisions above, a recipient may use your version of this file under
- * the terms of any one of the MPL, the GPL or the LGPL.
- *
- * ***** END LICENSE BLOCK ***** */
-
-#include <stddef.h>             // for size_t
-#include <stdlib.h>             // for malloc, free
-#include "mozalloc.h"
-#include <malloc.h>
-     
-#ifdef __malloc_hook
-static void* moz_malloc_hook(size_t size, const void *caller)
-{
-  return moz_malloc(size);
-}
-
-static void* moz_realloc_hook(void *ptr, size_t size, const void *caller)
-{
-  return moz_realloc(ptr, size);
-}
-
-static void moz_free_hook(void *ptr, const void *caller)
-{
-  moz_free(ptr);
-}
-
-static void* moz_memalign_hook(size_t align, size_t size, const void *caller)
-{
-  return moz_memalign(align, size);
-}
-
-static void
-moz_malloc_init_hook (void)
-{
-  __malloc_hook = moz_malloc_hook;
-  __realloc_hook = moz_realloc_hook;
-  __free_hook = moz_free_hook;
-  __memalign_hook = moz_memalign_hook;
-}
-
-/* Override initializing hook from the C library. */
-void (*__malloc_initialize_hook) (void) = moz_malloc_init_hook;
-#endif
-
-inline void  __wrap_free(void* ptr)
-{
-  moz_free(ptr);
-}
-
-inline void* __wrap_malloc(size_t size)
-{
-  return moz_malloc(size);
-}
-
-inline void* __wrap_realloc(void* ptr, size_t size)
-{
-  return moz_realloc(ptr, size);
-}
-
-inline void* __wrap_calloc(size_t num, size_t size)
-{
-  return moz_calloc(num, size);
-}
-
-inline void* __wrap_valloc(size_t size)
-{
-  return moz_valloc(size);
-}
-
-inline void* __wrap_memalign(size_t align, size_t size)
-{
-  return moz_memalign(align, size);
-}
-
-inline char* __wrap_strdup(char* str)
-{
-  return moz_strdup(str);
-}
-
-inline char* __wrap_strndup(const char* str, size_t size) {
-  return moz_strndup(str, size);
-}
-
-
-inline void  __wrap_PR_Free(void* ptr)
-{
-  moz_free(ptr);
-}
-
-inline void* __wrap_PR_Malloc(size_t size)
-{
-  return moz_malloc(size);
-}
-
-inline void* __wrap_PR_Realloc(void* ptr, size_t size)
-{
-  return moz_realloc(ptr, size);
-}
-
-inline void* __wrap_PR_Calloc(size_t num, size_t size)
-{
-  return moz_calloc(num, size);
-}
-
-inline int __wrap_posix_memalign(void **memptr, size_t alignment, size_t size)
-{
-  return moz_posix_memalign(memptr, alignment, size);
-}

--- a/memory/mozalloc/mozalloc.cpp
+++ b/memory/mozalloc/mozalloc.cpp
@@ -71,36 +71,29 @@
 #if defined(__GNUC__) && (__GNUC__ > 2)
 #define LIKELY(x)    (__builtin_expect(!!(x), 1))
 #define UNLIKELY(x)  (__builtin_expect(!!(x), 0))
 #else
 #define LIKELY(x)    (x)
 #define UNLIKELY(x)  (x)
 #endif
 
-#if defined(MOZ_MEMORY_DARWIN) || defined(MOZ_MEMORY_ANDROID) || \
-    defined(WRAP_MALLOC_WITH_JEMALLOC)
+#ifdef MOZ_MEMORY_DARWIN
 #include "jemalloc.h"
 #define malloc(a)               je_malloc(a)
 #define posix_memalign(a, b, c) je_posix_memalign(a, b, c)
 #define valloc(a)               je_valloc(a)
 #define calloc(a, b)            je_calloc(a, b)
-#ifndef MOZ_MEMORY_DARWIN
-   // These functions could be passed a memory region that was not allocated by
-   // jemalloc, so use the system-provided functions, which will in turn call
-   // the jemalloc versions when appropriate.
-#  define realloc(a, b)         je_realloc(a, b)
-#  define free(a)               je_free(a)
-#  define malloc_usable_size(a) je_malloc_usable_size(a)
-#endif
-#ifndef MOZ_MEMORY_ANDROID
 #define memalign(a, b)          je_memalign(a, b)
-#endif
 #define strdup(a)               je_strdup(a)
 #define strndup(a, b)           je_strndup(a, b)
+/* We omit functions which could be passed a memory region that was not
+ * allocated by jemalloc (realloc, free and malloc_usable_size). Instead,
+ * we use the system-provided functions, which will in turn call the
+ * jemalloc versions when appropriate */
 #endif
 
 void
 moz_free(void* ptr)
 {
     free(ptr);
 }
 

--- a/mobile/app/Makefile.in
+++ b/mobile/app/Makefile.in
@@ -43,16 +43,17 @@ VPATH     = @srcdir@
 include $(DEPTH)/config/autoconf.mk
 
 DIRS = profile/extensions
 
 PREF_JS_EXPORTS = $(srcdir)/mobile.js
 DIST_FILES = application.ini
 
 ifndef LIBXUL_SDK
+ifneq (Android,$(OS_TARGET))
 PROGRAM=$(MOZ_APP_NAME)$(BIN_SUFFIX)
 
 CPPSRCS = nsBrowserApp.cpp
 
 LOCAL_INCLUDES += -I$(topsrcdir)/toolkit/xre
 LOCAL_INCLUDES += -I$(topsrcdir)/xpcom/base
 LOCAL_INCLUDES += -I$(topsrcdir)/xpcom/build
 
@@ -70,16 +71,17 @@ ifeq ($(OS_ARCH),WINNT)
 OS_LIBS += $(call EXPAND_LIBNAME,version)
 endif
 
 ifdef _MSC_VER
 # Always enter a Windows program through wmain, whether or not we're
 # a console application.
 WIN32_EXE_LDFLAGS += -ENTRY:wmainCRTStartup
 endif
+endif
 endif #LIBXUL_SDK
 
 # Make sure the standalone glue doesn't try to get libxpcom.so from mobile/app.
 NSDISTMODE = copy
 
 include $(topsrcdir)/config/rules.mk
 
 GRE_MILESTONE = $(shell $(PYTHON) $(topsrcdir)/config/printconfigsetting.py $(LIBXUL_DIST)/bin/platform.ini Build Milestone)

--- a/other-licenses/android/Makefile.in
+++ b/other-licenses/android/Makefile.in
@@ -69,12 +69,16 @@ CSRCS = \
   linker_format.c \
   rt.c \
   $(NULL)
 
 EXPORTS = APKOpen.h
 
 EXTRA_DSO_LDOPTS += $(ZLIB_LIBS)
 
+ifdef MOZ_MEMORY
+SHARED_LIBRARY_LIBS = $(call EXPAND_LIBNAME_PATH,jemalloc,$(DEPTH)/memory/jemalloc)
+endif
+
 WRAP_MALLOC_LIB =
 WRAP_MALLOC_CFLAGS =
 
 include $(topsrcdir)/config/rules.mk