author Mike Hommey <>
Fri, 08 Jul 2016 08:43:17 +0900
changeset 346288 764dfcab17e9354843c9f4668c9f3617eb8e9a96
parent 279660 e8d8ea70caed2fbaa6c4e251c8b61d92a1835751
child 412187 4bd3eb1b5f3761565871f226e80c4b158defdf48
permissions -rw-r--r--
Bug 1283052 - Remove some of the magic around mozconfig detection. r=gps The mozconfig detection logic has bitten us on many occasions in the past. The following changes are made to tentatively improve the situation: - The API is modified such that autodetection of the mozconfig has to be a conscious decision made by the caller, and not triggered any time there is no mozconfig given, which could be a conscious decision of the opposite. - mozinfo.json now stores the actual mozconfig (or lack thereof) used during configure.

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this file,
 * You can obtain one at */

#ifndef replace_malloc_h
#define replace_malloc_h

 * The replace_malloc facility allows an external library to replace or
 * supplement the jemalloc implementation.
 * The external library may be hooked by setting one of the following
 * environment variables to the library path:
 *   - LD_PRELOAD on Linux,
 *   - MOZ_REPLACE_MALLOC_LIB on Windows and Android.
 * An initialization function is called before any malloc replacement
 * function, and has the following declaration:
 *   void replace_init(const malloc_table_t *)
 * The const malloc_table_t pointer given to that function is a table
 * containing pointers to the original jemalloc implementation, so that
 * replacement functions can call them back if they need to. The pointer
 * itself can safely be kept around (no need to copy the table itself).
 * The functions to be implemented in the external library are of the form:
 *   void *replace_malloc(size_t size)
 *   {
 *     // Fiddle with the size if necessary.
 *     // orig->malloc doesn't have to be called if the external library
 *     // provides its own allocator, but in this case it will have to
 *     // implement all functions.
 *     void *ptr = orig->malloc(size);
 *     // Do whatever you want with the ptr.
 *     return ptr;
 *   }
 * where "orig" is the pointer obtained from replace_init.
 * See malloc_decls.h for a list of functions that can be replaced this
 * way. The implementations are all in the form:
 *   return_type replace_name(arguments [,...])
 * They don't all need to be provided.
 * Building a replace-malloc library is like rocket science. It can end up
 * with things blowing up, especially when trying to use complex types, and
 * even more especially when these types come from XPCOM or other parts of the
 * Mozilla codebase.
 * It is recommended to add the following to a replace-malloc implementation's
 *   DISABLE_STL_WRAPPING = True # Avoid STL wrapping
 * If your replace-malloc implementation lives under memory/replace, these
 * are taken care of by memory/replace/

#ifdef replace_malloc_bridge_h
#error Do not include replace_malloc_bridge.h before replace_malloc.h. \
  In fact, you only need the latter.


#include "replace_malloc_bridge.h"

/* Implementing a replace-malloc library is incompatible with using mozalloc. */

#include "mozilla/Types.h"


/* MOZ_NO_REPLACE_FUNC_DECL and MOZ_REPLACE_WEAK are only defined in
 * replace_malloc.c. Normally including this header will add function
 * definitions. */

#    define MOZ_REPLACE_WEAK
#  endif

#  define MALLOC_DECL(name, return_type, ...) \
    MOZ_EXPORT return_type replace_ ## name(__VA_ARGS__) MOZ_REPLACE_WEAK;

#  include "malloc_decls.h"


 * posix_memalign, aligned_alloc, memalign and valloc all implement some
 * kind of aligned memory allocation. For convenience, replace_posix_memalign,
 * replace_aligned_alloc and replace_valloc can be automatically derived from
 * memalign when MOZ_REPLACE_ONLY_MEMALIGN is defined before including this
 * header. PAGE_SIZE also needs to be defined to the appropriate expression.
#include <errno.h>

int replace_posix_memalign(void **ptr, size_t alignment, size_t size)
  if (size == 0) {
    *ptr = NULL;
    return 0;
  /* alignment must be a power of two and a multiple of sizeof(void *) */
  if (((alignment - 1) & alignment) != 0 || (alignment % sizeof(void *)))
    return EINVAL;
  *ptr = replace_memalign(alignment, size);
  return *ptr ? 0 : ENOMEM;

void *replace_aligned_alloc(size_t alignment, size_t size)
  /* size should be a multiple of alignment */
  if (size % alignment)
    return NULL;
  return replace_memalign(alignment, size);

void *replace_valloc(size_t size)
  return replace_memalign(PAGE_SIZE, size);


#endif /* replace_malloc_h */