2007-03-22 10:30:00 -07:00
|
|
|
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
|
|
*
|
|
|
|
* ***** 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 Communicator client code, released
|
|
|
|
* March 31, 1998.
|
|
|
|
*
|
|
|
|
* The Initial Developer of the Original Code is
|
|
|
|
* Netscape Communications Corporation.
|
|
|
|
* Portions created by the Initial Developer are Copyright (C) 1998
|
|
|
|
* the Initial Developer. All Rights Reserved.
|
|
|
|
*
|
|
|
|
* Contributor(s):
|
|
|
|
*
|
|
|
|
* Alternatively, the contents of this file may be used under the terms of
|
|
|
|
* either of 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 ***** */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* PR assertion checker.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef jsutil_h___
|
|
|
|
#define jsutil_h___
|
|
|
|
|
2010-04-16 12:03:53 -07:00
|
|
|
#include "jstypes.h"
|
2011-07-07 17:31:24 -07:00
|
|
|
#include "jscrashreport.h"
|
2011-04-20 16:27:30 -07:00
|
|
|
#include "mozilla/Util.h"
|
2009-07-27 21:10:12 -07:00
|
|
|
#include <stdlib.h>
|
2011-01-22 08:52:25 -08:00
|
|
|
#include <string.h>
|
2009-07-27 21:10:12 -07:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
JS_BEGIN_EXTERN_C
|
|
|
|
|
2010-11-15 19:40:26 -08:00
|
|
|
#define JS_CRASH_UNLESS(__cond) \
|
|
|
|
JS_BEGIN_MACRO \
|
|
|
|
if (!(__cond)) { \
|
|
|
|
*(int *)(uintptr_t)0xccadbeef = 0; \
|
|
|
|
((void(*)())0)(); /* More reliable, but doesn't say CCADBEEF */ \
|
|
|
|
} \
|
|
|
|
JS_END_MACRO
|
|
|
|
|
2011-07-07 17:31:24 -07:00
|
|
|
#define JS_FREE_PATTERN 0xDA
|
|
|
|
|
2011-07-25 18:05:05 -07:00
|
|
|
#define JS_OPT_ASSERT(expr) \
|
|
|
|
((expr) ? (void)0 : JS_Assert(#expr, __FILE__, __LINE__))
|
|
|
|
|
|
|
|
#define JS_OPT_ASSERT_IF(cond, expr) \
|
|
|
|
((!(cond) || (expr)) ? (void)0 : JS_Assert(#expr, __FILE__, __LINE__))
|
|
|
|
|
2009-03-06 11:51:11 -08:00
|
|
|
#ifdef DEBUG
|
|
|
|
|
* Menu of -D flags for enabling instrumentation, as a commented-out CFLAGS += setting for convenient testing. * js_FindProperty and js_LookupPropertyWithFlags return indexes into the scope and prototype chains, respectively, to support internal instrumentation, and to pave the way for the return of the property cache (bug 365851).. * jsutil.[ch] JSBasicStats struct and functions for computing mean/sigma/max and auto-scaling histogram. * JS_SCOPE_DEPTH_METER instrumentation for compile- and run-time scope chain length instrumentation: + At compile time, rt->hostenvScopeDepthStats and rt->lexicalScopeDepthStats meter scope chains passed into the compile and evaluate APIs. + At runtime, rt->protoLookupDepthStats and rt->scopeSearchDepthStats track steps along the prototype and scope chains until the sought-after property is found. * JS_ARENAMETER uses JSBasicStats now. * Added rt->liveScopePropsPreSweep to fix the property tree stats code that rotted when property tree sweeping moved to after the finalization phase. * Un-bitrotted some DEBUG_brendan code, turned some off for myself via XXX. * Mac OS X toolchain requires initialized data shared across dynamic library member files, outlaws common data, so initialize extern metering vars. * Old HASHMETER code in jshash.[ch] is now JS_HASHMETER-controlled and based on JSBasicStats. * DEBUG_scopemeters macro renamed JS_DUMP_SCOPE_METERS; uses JSBasicStats now. * Disentangle DEBUG and DUMP_SCOPE_STATS (now JS_DUMP_PROPTREE_STATS) and fix inconsistent thread safety for liveScopeProps (sometimes atomic-incremented, sometimes runtime-locked). * Compiler-modeled maxScopeDepth will propagate via JSScript to runtime for capability-based, interpreter-inlined cache hit qualifier bits, to bypass scope and prototype chain lookup by optimizing for common monomorphic get, set, and call site referencing a prototype property in a well-named object (no shadowing or mutation in 99.9% of the cases).
2008-01-12 16:31:31 -08:00
|
|
|
#define JS_ASSERT(expr) \
|
|
|
|
((expr) ? (void)0 : JS_Assert(#expr, __FILE__, __LINE__))
|
2007-03-22 10:30:00 -07:00
|
|
|
|
* Menu of -D flags for enabling instrumentation, as a commented-out CFLAGS += setting for convenient testing. * js_FindProperty and js_LookupPropertyWithFlags return indexes into the scope and prototype chains, respectively, to support internal instrumentation, and to pave the way for the return of the property cache (bug 365851).. * jsutil.[ch] JSBasicStats struct and functions for computing mean/sigma/max and auto-scaling histogram. * JS_SCOPE_DEPTH_METER instrumentation for compile- and run-time scope chain length instrumentation: + At compile time, rt->hostenvScopeDepthStats and rt->lexicalScopeDepthStats meter scope chains passed into the compile and evaluate APIs. + At runtime, rt->protoLookupDepthStats and rt->scopeSearchDepthStats track steps along the prototype and scope chains until the sought-after property is found. * JS_ARENAMETER uses JSBasicStats now. * Added rt->liveScopePropsPreSweep to fix the property tree stats code that rotted when property tree sweeping moved to after the finalization phase. * Un-bitrotted some DEBUG_brendan code, turned some off for myself via XXX. * Mac OS X toolchain requires initialized data shared across dynamic library member files, outlaws common data, so initialize extern metering vars. * Old HASHMETER code in jshash.[ch] is now JS_HASHMETER-controlled and based on JSBasicStats. * DEBUG_scopemeters macro renamed JS_DUMP_SCOPE_METERS; uses JSBasicStats now. * Disentangle DEBUG and DUMP_SCOPE_STATS (now JS_DUMP_PROPTREE_STATS) and fix inconsistent thread safety for liveScopeProps (sometimes atomic-incremented, sometimes runtime-locked). * Compiler-modeled maxScopeDepth will propagate via JSScript to runtime for capability-based, interpreter-inlined cache hit qualifier bits, to bypass scope and prototype chain lookup by optimizing for common monomorphic get, set, and call site referencing a prototype property in a well-named object (no shadowing or mutation in 99.9% of the cases).
2008-01-12 16:31:31 -08:00
|
|
|
#define JS_ASSERT_IF(cond, expr) \
|
|
|
|
((!(cond) || (expr)) ? (void)0 : JS_Assert(#expr, __FILE__, __LINE__))
|
|
|
|
|
|
|
|
#define JS_NOT_REACHED(reason) \
|
|
|
|
JS_Assert(reason, __FILE__, __LINE__)
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2010-04-06 06:15:15 -07:00
|
|
|
#define JS_ALWAYS_TRUE(expr) JS_ASSERT(expr)
|
|
|
|
|
2011-02-11 05:58:53 -08:00
|
|
|
#define JS_ALWAYS_FALSE(expr) JS_ASSERT(!(expr))
|
|
|
|
|
2010-10-01 11:10:30 -07:00
|
|
|
# ifdef JS_THREADSAFE
|
|
|
|
# define JS_THREADSAFE_ASSERT(expr) JS_ASSERT(expr)
|
|
|
|
# else
|
|
|
|
# define JS_THREADSAFE_ASSERT(expr) ((void) 0)
|
|
|
|
# endif
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
#else
|
|
|
|
|
* Menu of -D flags for enabling instrumentation, as a commented-out CFLAGS += setting for convenient testing. * js_FindProperty and js_LookupPropertyWithFlags return indexes into the scope and prototype chains, respectively, to support internal instrumentation, and to pave the way for the return of the property cache (bug 365851).. * jsutil.[ch] JSBasicStats struct and functions for computing mean/sigma/max and auto-scaling histogram. * JS_SCOPE_DEPTH_METER instrumentation for compile- and run-time scope chain length instrumentation: + At compile time, rt->hostenvScopeDepthStats and rt->lexicalScopeDepthStats meter scope chains passed into the compile and evaluate APIs. + At runtime, rt->protoLookupDepthStats and rt->scopeSearchDepthStats track steps along the prototype and scope chains until the sought-after property is found. * JS_ARENAMETER uses JSBasicStats now. * Added rt->liveScopePropsPreSweep to fix the property tree stats code that rotted when property tree sweeping moved to after the finalization phase. * Un-bitrotted some DEBUG_brendan code, turned some off for myself via XXX. * Mac OS X toolchain requires initialized data shared across dynamic library member files, outlaws common data, so initialize extern metering vars. * Old HASHMETER code in jshash.[ch] is now JS_HASHMETER-controlled and based on JSBasicStats. * DEBUG_scopemeters macro renamed JS_DUMP_SCOPE_METERS; uses JSBasicStats now. * Disentangle DEBUG and DUMP_SCOPE_STATS (now JS_DUMP_PROPTREE_STATS) and fix inconsistent thread safety for liveScopeProps (sometimes atomic-incremented, sometimes runtime-locked). * Compiler-modeled maxScopeDepth will propagate via JSScript to runtime for capability-based, interpreter-inlined cache hit qualifier bits, to bypass scope and prototype chain lookup by optimizing for common monomorphic get, set, and call site referencing a prototype property in a well-named object (no shadowing or mutation in 99.9% of the cases).
2008-01-12 16:31:31 -08:00
|
|
|
#define JS_ASSERT(expr) ((void) 0)
|
2007-03-22 10:30:00 -07:00
|
|
|
#define JS_ASSERT_IF(cond,expr) ((void) 0)
|
* Menu of -D flags for enabling instrumentation, as a commented-out CFLAGS += setting for convenient testing. * js_FindProperty and js_LookupPropertyWithFlags return indexes into the scope and prototype chains, respectively, to support internal instrumentation, and to pave the way for the return of the property cache (bug 365851).. * jsutil.[ch] JSBasicStats struct and functions for computing mean/sigma/max and auto-scaling histogram. * JS_SCOPE_DEPTH_METER instrumentation for compile- and run-time scope chain length instrumentation: + At compile time, rt->hostenvScopeDepthStats and rt->lexicalScopeDepthStats meter scope chains passed into the compile and evaluate APIs. + At runtime, rt->protoLookupDepthStats and rt->scopeSearchDepthStats track steps along the prototype and scope chains until the sought-after property is found. * JS_ARENAMETER uses JSBasicStats now. * Added rt->liveScopePropsPreSweep to fix the property tree stats code that rotted when property tree sweeping moved to after the finalization phase. * Un-bitrotted some DEBUG_brendan code, turned some off for myself via XXX. * Mac OS X toolchain requires initialized data shared across dynamic library member files, outlaws common data, so initialize extern metering vars. * Old HASHMETER code in jshash.[ch] is now JS_HASHMETER-controlled and based on JSBasicStats. * DEBUG_scopemeters macro renamed JS_DUMP_SCOPE_METERS; uses JSBasicStats now. * Disentangle DEBUG and DUMP_SCOPE_STATS (now JS_DUMP_PROPTREE_STATS) and fix inconsistent thread safety for liveScopeProps (sometimes atomic-incremented, sometimes runtime-locked). * Compiler-modeled maxScopeDepth will propagate via JSScript to runtime for capability-based, interpreter-inlined cache hit qualifier bits, to bypass scope and prototype chain lookup by optimizing for common monomorphic get, set, and call site referencing a prototype property in a well-named object (no shadowing or mutation in 99.9% of the cases).
2008-01-12 16:31:31 -08:00
|
|
|
#define JS_NOT_REACHED(reason)
|
2010-04-06 06:15:15 -07:00
|
|
|
#define JS_ALWAYS_TRUE(expr) ((void) (expr))
|
2011-02-11 05:58:53 -08:00
|
|
|
#define JS_ALWAYS_FALSE(expr) ((void) (expr))
|
2010-10-01 11:10:30 -07:00
|
|
|
#define JS_THREADSAFE_ASSERT(expr) ((void) 0)
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
#endif /* defined(DEBUG) */
|
|
|
|
|
|
|
|
/*
|
2009-02-19 15:15:32 -08:00
|
|
|
* Compile-time assert. "cond" must be a constant expression.
|
2007-05-24 00:27:45 -07:00
|
|
|
* The macro can be used only in places where an "extern" declaration is
|
|
|
|
* allowed.
|
2007-03-22 10:30:00 -07:00
|
|
|
*/
|
2008-09-01 19:03:18 -07:00
|
|
|
|
2010-10-11 03:23:55 -07:00
|
|
|
#ifdef __SUNPRO_CC
|
2008-09-01 19:03:18 -07:00
|
|
|
/*
|
|
|
|
* Sun Studio C++ compiler has a bug
|
|
|
|
* "sizeof expression not accepted as size of array parameter"
|
2010-10-11 03:23:55 -07:00
|
|
|
* It happens when js_static_assert() function is declared inside functions.
|
2008-09-01 19:03:18 -07:00
|
|
|
* The bug number is 6688515. It is not public yet.
|
2010-10-11 03:23:55 -07:00
|
|
|
* Therefore, for Sun Studio, declare js_static_assert as an array instead.
|
2008-09-01 19:03:18 -07:00
|
|
|
*/
|
2010-10-11 03:23:55 -07:00
|
|
|
#define JS_STATIC_ASSERT(cond) extern char js_static_assert[(cond) ? 1 : -1]
|
2008-09-01 19:03:18 -07:00
|
|
|
#else
|
2009-02-19 15:00:46 -08:00
|
|
|
#ifdef __COUNTER__
|
|
|
|
#define JS_STATIC_ASSERT_GLUE1(x,y) x##y
|
|
|
|
#define JS_STATIC_ASSERT_GLUE(x,y) JS_STATIC_ASSERT_GLUE1(x,y)
|
|
|
|
#define JS_STATIC_ASSERT(cond) \
|
|
|
|
typedef int JS_STATIC_ASSERT_GLUE(js_static_assert, __COUNTER__)[(cond) ? 1 : -1]
|
|
|
|
#else
|
2009-02-19 15:15:32 -08:00
|
|
|
#define JS_STATIC_ASSERT(cond) extern void js_static_assert(int arg[(cond) ? 1 : -1])
|
2009-02-19 15:00:46 -08:00
|
|
|
#endif
|
2008-09-01 19:03:18 -07:00
|
|
|
#endif
|
2007-03-22 10:30:00 -07:00
|
|
|
|
2009-03-05 03:12:50 -08:00
|
|
|
#define JS_STATIC_ASSERT_IF(cond, expr) JS_STATIC_ASSERT(!(cond) || (expr))
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
/*
|
* Menu of -D flags for enabling instrumentation, as a commented-out CFLAGS += setting for convenient testing. * js_FindProperty and js_LookupPropertyWithFlags return indexes into the scope and prototype chains, respectively, to support internal instrumentation, and to pave the way for the return of the property cache (bug 365851).. * jsutil.[ch] JSBasicStats struct and functions for computing mean/sigma/max and auto-scaling histogram. * JS_SCOPE_DEPTH_METER instrumentation for compile- and run-time scope chain length instrumentation: + At compile time, rt->hostenvScopeDepthStats and rt->lexicalScopeDepthStats meter scope chains passed into the compile and evaluate APIs. + At runtime, rt->protoLookupDepthStats and rt->scopeSearchDepthStats track steps along the prototype and scope chains until the sought-after property is found. * JS_ARENAMETER uses JSBasicStats now. * Added rt->liveScopePropsPreSweep to fix the property tree stats code that rotted when property tree sweeping moved to after the finalization phase. * Un-bitrotted some DEBUG_brendan code, turned some off for myself via XXX. * Mac OS X toolchain requires initialized data shared across dynamic library member files, outlaws common data, so initialize extern metering vars. * Old HASHMETER code in jshash.[ch] is now JS_HASHMETER-controlled and based on JSBasicStats. * DEBUG_scopemeters macro renamed JS_DUMP_SCOPE_METERS; uses JSBasicStats now. * Disentangle DEBUG and DUMP_SCOPE_STATS (now JS_DUMP_PROPTREE_STATS) and fix inconsistent thread safety for liveScopeProps (sometimes atomic-incremented, sometimes runtime-locked). * Compiler-modeled maxScopeDepth will propagate via JSScript to runtime for capability-based, interpreter-inlined cache hit qualifier bits, to bypass scope and prototype chain lookup by optimizing for common monomorphic get, set, and call site referencing a prototype property in a well-named object (no shadowing or mutation in 99.9% of the cases).
2008-01-12 16:31:31 -08:00
|
|
|
* Abort the process in a non-graceful manner. This will cause a core file,
|
|
|
|
* call to the debugger or other moral equivalent as well as causing the
|
|
|
|
* entire process to stop.
|
|
|
|
*/
|
2007-03-22 10:30:00 -07:00
|
|
|
extern JS_PUBLIC_API(void) JS_Abort(void);
|
|
|
|
|
2009-12-14 18:36:58 -08:00
|
|
|
#ifdef DEBUG
|
* Menu of -D flags for enabling instrumentation, as a commented-out CFLAGS += setting for convenient testing. * js_FindProperty and js_LookupPropertyWithFlags return indexes into the scope and prototype chains, respectively, to support internal instrumentation, and to pave the way for the return of the property cache (bug 365851).. * jsutil.[ch] JSBasicStats struct and functions for computing mean/sigma/max and auto-scaling histogram. * JS_SCOPE_DEPTH_METER instrumentation for compile- and run-time scope chain length instrumentation: + At compile time, rt->hostenvScopeDepthStats and rt->lexicalScopeDepthStats meter scope chains passed into the compile and evaluate APIs. + At runtime, rt->protoLookupDepthStats and rt->scopeSearchDepthStats track steps along the prototype and scope chains until the sought-after property is found. * JS_ARENAMETER uses JSBasicStats now. * Added rt->liveScopePropsPreSweep to fix the property tree stats code that rotted when property tree sweeping moved to after the finalization phase. * Un-bitrotted some DEBUG_brendan code, turned some off for myself via XXX. * Mac OS X toolchain requires initialized data shared across dynamic library member files, outlaws common data, so initialize extern metering vars. * Old HASHMETER code in jshash.[ch] is now JS_HASHMETER-controlled and based on JSBasicStats. * DEBUG_scopemeters macro renamed JS_DUMP_SCOPE_METERS; uses JSBasicStats now. * Disentangle DEBUG and DUMP_SCOPE_STATS (now JS_DUMP_PROPTREE_STATS) and fix inconsistent thread safety for liveScopeProps (sometimes atomic-incremented, sometimes runtime-locked). * Compiler-modeled maxScopeDepth will propagate via JSScript to runtime for capability-based, interpreter-inlined cache hit qualifier bits, to bypass scope and prototype chain lookup by optimizing for common monomorphic get, set, and call site referencing a prototype property in a well-named object (no shadowing or mutation in 99.9% of the cases).
2008-01-12 16:31:31 -08:00
|
|
|
# define JS_BASIC_STATS 1
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef JS_BASIC_STATS
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
typedef struct JSBasicStats {
|
|
|
|
uint32 num;
|
|
|
|
uint32 max;
|
|
|
|
double sum;
|
|
|
|
double sqsum;
|
|
|
|
uint32 logscale; /* logarithmic scale: 0 (linear), 2, 10 */
|
|
|
|
uint32 hist[11];
|
|
|
|
} JSBasicStats;
|
|
|
|
|
|
|
|
#define JS_INIT_STATIC_BASIC_STATS {0,0,0,0,0,{0,0,0,0,0,0,0,0,0,0,0}}
|
|
|
|
#define JS_BASIC_STATS_INIT(bs) memset((bs), 0, sizeof(JSBasicStats))
|
|
|
|
|
|
|
|
#define JS_BASIC_STATS_ACCUM(bs,val) \
|
|
|
|
JS_BasicStatsAccum(bs, val)
|
|
|
|
|
|
|
|
#define JS_MeanAndStdDevBS(bs,sigma) \
|
|
|
|
JS_MeanAndStdDev((bs)->num, (bs)->sum, (bs)->sqsum, sigma)
|
|
|
|
|
|
|
|
extern void
|
|
|
|
JS_BasicStatsAccum(JSBasicStats *bs, uint32 val);
|
|
|
|
|
|
|
|
extern double
|
|
|
|
JS_MeanAndStdDev(uint32 num, double sum, double sqsum, double *sigma);
|
|
|
|
|
|
|
|
extern void
|
|
|
|
JS_DumpBasicStats(JSBasicStats *bs, const char *title, FILE *fp);
|
|
|
|
|
|
|
|
extern void
|
|
|
|
JS_DumpHistogram(JSBasicStats *bs, FILE *fp);
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
#define JS_BASIC_STATS_ACCUM(bs,val) /* nothing */
|
|
|
|
|
|
|
|
#endif /* JS_BASIC_STATS */
|
|
|
|
|
|
|
|
|
2009-02-08 16:36:55 -08:00
|
|
|
#if defined(DEBUG_notme) && defined(XP_UNIX)
|
2007-03-22 10:30:00 -07:00
|
|
|
|
|
|
|
typedef struct JSCallsite JSCallsite;
|
|
|
|
|
|
|
|
struct JSCallsite {
|
|
|
|
uint32 pc;
|
|
|
|
char *name;
|
|
|
|
const char *library;
|
|
|
|
int offset;
|
|
|
|
JSCallsite *parent;
|
|
|
|
JSCallsite *siblings;
|
|
|
|
JSCallsite *kids;
|
|
|
|
void *handy;
|
|
|
|
};
|
|
|
|
|
2009-02-08 16:36:55 -08:00
|
|
|
extern JS_FRIEND_API(JSCallsite *)
|
|
|
|
JS_Backtrace(int skip);
|
|
|
|
|
|
|
|
extern JS_FRIEND_API(void)
|
|
|
|
JS_DumpBacktrace(JSCallsite *trace);
|
2007-03-22 10:30:00 -07:00
|
|
|
#endif
|
|
|
|
|
2010-04-16 12:03:53 -07:00
|
|
|
#if defined JS_USE_CUSTOM_ALLOCATOR
|
|
|
|
|
|
|
|
#include "jscustomallocator.h"
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
2011-01-17 15:15:00 -08:00
|
|
|
#ifdef DEBUG
|
|
|
|
/*
|
|
|
|
* In order to test OOM conditions, when the shell command-line option
|
|
|
|
* |-A NUM| is passed, we fail continuously after the NUM'th allocation.
|
|
|
|
*/
|
|
|
|
extern JS_PUBLIC_DATA(JSUint32) OOM_maxAllocations; /* set from shell/js.cpp */
|
|
|
|
extern JS_PUBLIC_DATA(JSUint32) OOM_counter; /* data race, who cares. */
|
|
|
|
#define JS_OOM_POSSIBLY_FAIL() \
|
|
|
|
do \
|
|
|
|
{ \
|
|
|
|
if (OOM_counter++ >= OOM_maxAllocations) { \
|
|
|
|
return NULL; \
|
|
|
|
} \
|
|
|
|
} while (0)
|
|
|
|
|
|
|
|
#else
|
|
|
|
#define JS_OOM_POSSIBLY_FAIL() do {} while(0)
|
|
|
|
#endif
|
|
|
|
|
2011-07-07 17:31:24 -07:00
|
|
|
static JS_INLINE void *js_record_oom(void *p) {
|
|
|
|
if (!p)
|
|
|
|
js_SnapshotErrorStack();
|
|
|
|
return p;
|
|
|
|
}
|
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
/*
|
|
|
|
* SpiderMonkey code should not be calling these allocation functions directly.
|
|
|
|
* Instead, all calls should go through JSRuntime, JSContext or OffTheBooks.
|
|
|
|
* However, js_free() can be called directly.
|
|
|
|
*/
|
2009-07-27 21:10:12 -07:00
|
|
|
static JS_INLINE void* js_malloc(size_t bytes) {
|
2011-01-17 15:15:00 -08:00
|
|
|
JS_OOM_POSSIBLY_FAIL();
|
2011-07-07 17:31:24 -07:00
|
|
|
return js_record_oom(malloc(bytes));
|
2009-07-27 21:10:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static JS_INLINE void* js_calloc(size_t bytes) {
|
2011-01-17 15:15:00 -08:00
|
|
|
JS_OOM_POSSIBLY_FAIL();
|
2011-07-07 17:31:24 -07:00
|
|
|
return js_record_oom(calloc(bytes, 1));
|
2009-07-27 21:10:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static JS_INLINE void* js_realloc(void* p, size_t bytes) {
|
2011-01-17 15:15:00 -08:00
|
|
|
JS_OOM_POSSIBLY_FAIL();
|
2011-07-07 17:31:24 -07:00
|
|
|
return js_record_oom(realloc(p, bytes));
|
2009-07-27 21:10:12 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static JS_INLINE void js_free(void* p) {
|
|
|
|
free(p);
|
|
|
|
}
|
2010-04-16 12:03:53 -07:00
|
|
|
#endif/* JS_USE_CUSTOM_ALLOCATOR */
|
2009-07-27 21:10:12 -07:00
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
JS_END_EXTERN_C
|
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
|
|
|
|
|
2009-09-27 23:17:47 -07:00
|
|
|
#ifdef __cplusplus
|
|
|
|
|
2011-01-17 19:44:10 -08:00
|
|
|
/*
|
2011-03-31 19:34:14 -07:00
|
|
|
* User guide to memory management within SpiderMonkey:
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
*
|
|
|
|
* Quick tips:
|
|
|
|
*
|
|
|
|
* Allocation:
|
|
|
|
* - Prefer to allocate using JSContext:
|
2011-03-31 01:14:12 -07:00
|
|
|
* cx->{malloc_,realloc_,calloc_,new_,new_array}
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
*
|
|
|
|
* - If no JSContext is available, use a JSRuntime:
|
2011-03-31 01:14:12 -07:00
|
|
|
* rt->{malloc_,realloc_,calloc_,new_,new_array}
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
*
|
|
|
|
* - As a last resort, use unaccounted allocation ("OffTheBooks"):
|
2011-03-31 01:14:12 -07:00
|
|
|
* js::OffTheBooks::{malloc_,realloc_,calloc_,new_,new_array}
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
*
|
|
|
|
* Deallocation:
|
|
|
|
* - When the deallocation occurs on a slow path, use:
|
2011-03-31 01:14:12 -07:00
|
|
|
* Foreground::{free_,delete_,array_delete}
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
*
|
|
|
|
* - Otherwise deallocate on a background thread using a JSContext:
|
2011-03-31 01:14:12 -07:00
|
|
|
* cx->{free_,delete_,array_delete}
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
*
|
|
|
|
* - If no JSContext is available, use a JSRuntime:
|
2011-03-31 01:14:12 -07:00
|
|
|
* rt->{free_,delete_,array_delete}
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
*
|
|
|
|
* - As a last resort, use UnwantedForeground deallocation:
|
2011-03-31 01:14:12 -07:00
|
|
|
* js::UnwantedForeground::{free_,delete_,array_delete}
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
*
|
|
|
|
* General tips:
|
2011-01-17 19:44:10 -08:00
|
|
|
*
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
* - Mixing and matching these allocators is allowed (you may free memory
|
|
|
|
* allocated by any allocator, with any deallocator).
|
|
|
|
*
|
|
|
|
* - Never, ever use normal C/C++ memory management:
|
|
|
|
* malloc, free, new, new[], delete, operator new, etc.
|
2011-01-17 19:44:10 -08:00
|
|
|
*
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
* - Never, ever use low-level SpiderMonkey allocators:
|
|
|
|
* js_malloc(), js_free(), js_calloc(), js_realloc()
|
|
|
|
* Their use is reserved for the other memory managers.
|
|
|
|
*
|
|
|
|
* - Classes which have private constructors or destructors should have
|
|
|
|
* JS_DECLARE_ALLOCATION_FRIENDS_FOR_PRIVATE_CONSTRUCTOR added to their
|
|
|
|
* declaration.
|
|
|
|
*
|
|
|
|
* Details:
|
|
|
|
*
|
|
|
|
* Using vanilla new/new[] is unsafe in SpiderMonkey because they throw on
|
|
|
|
* failure instead of returning NULL, which is what SpiderMonkey expects.
|
|
|
|
* (Even overriding them is unsafe, as the system's C++ runtime library may
|
|
|
|
* throw, which we do not support. We also can't just use the 'nothrow'
|
|
|
|
* variant of new/new[], because we want to mediate *all* allocations
|
|
|
|
* within SpiderMonkey, to satisfy any embedders using
|
|
|
|
* JS_USE_CUSTOM_ALLOCATOR.)
|
|
|
|
*
|
|
|
|
* JSContexts and JSRuntimes keep track of memory allocated, and use this
|
|
|
|
* accounting to schedule GC. OffTheBooks does not. We'd like to remove
|
|
|
|
* OffTheBooks allocations as much as possible (bug 636558).
|
|
|
|
*
|
|
|
|
* On allocation failure, a JSContext correctly reports an error, which a
|
|
|
|
* JSRuntime and OffTheBooks does not.
|
|
|
|
*
|
|
|
|
* A JSContext deallocates in a background thread. A JSRuntime might
|
|
|
|
* deallocate in the background in the future, but does not now. Foreground
|
|
|
|
* deallocation is preferable on slow paths. UnwantedForeground deallocations
|
|
|
|
* occur where we have no JSContext or JSRuntime, and the deallocation is not
|
|
|
|
* on a slow path. We want to remove UnwantedForeground deallocations (bug
|
|
|
|
* 636561).
|
|
|
|
*
|
|
|
|
* JS_DECLARE_ALLOCATION_FRIENDS_FOR_PRIVATE_CONSTRUCTOR makes the allocation
|
|
|
|
* classes friends with your class, giving them access to private
|
|
|
|
* constructors and destructors.
|
|
|
|
*
|
|
|
|
* |make check| does a source level check on the number of uses OffTheBooks,
|
|
|
|
* UnwantedForeground, js_malloc, js_free etc, to prevent regressions. If you
|
|
|
|
* really must add one, update Makefile.in, and run |make check|.
|
|
|
|
*
|
|
|
|
* |make check| also statically prevents the use of vanilla new/new[].
|
2011-01-17 19:44:10 -08:00
|
|
|
*/
|
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
#define JS_NEW_BODY(allocator, t, parms) \
|
|
|
|
void *memory = allocator(sizeof(t)); \
|
2011-01-17 19:44:10 -08:00
|
|
|
return memory ? new(memory) t parms : NULL;
|
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
/*
|
|
|
|
* Given a class which should provide new_() methods, add
|
|
|
|
* JS_DECLARE_NEW_METHODS (see JSContext for a usage example). This
|
|
|
|
* adds new_()s with up to 12 parameters. Add more versions of new_ below if
|
|
|
|
* you need more than 12 parameters.
|
|
|
|
*
|
|
|
|
* Note: Do not add a ; at the end of a use of JS_DECLARE_NEW_METHODS,
|
|
|
|
* or the build will break.
|
|
|
|
*/
|
|
|
|
#define JS_DECLARE_NEW_METHODS(ALLOCATOR, QUALIFIERS)\
|
|
|
|
template <class T>\
|
|
|
|
QUALIFIERS T *new_() {\
|
|
|
|
JS_NEW_BODY(ALLOCATOR, T, ())\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2, class P3>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2, P3 p3) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2, p3))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2, class P3, class P4>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2, P3 p3, P4 p4) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2, p3, p4))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2, class P3, class P4, class P5>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2, p3, p4, p5))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2, class P3, class P4, class P5, class P6>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2, p3, p4, p5, p6))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2, p3, p4, p5, p6, p7))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2, p3, p4, p5, p6, p7, p8))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2, p3, p4, p5, p6, p7, p8, p9))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2, p3, p4, p5, p6, p7, p8, p9, p10))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11))\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T, class P1, class P2, class P3, class P4, class P5, class P6, class P7, class P8, class P9, class P10, class P11, class P12>\
|
2011-05-17 04:25:39 -07:00
|
|
|
QUALIFIERS T *new_(P1 p1, P2 p2, P3 p3, P4 p4, P5 p5, P6 p6, P7 p7, P8 p8, P9 p9, P10 p10, P11 p11, P12 p12) {\
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_NEW_BODY(ALLOCATOR, T, (p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12))\
|
|
|
|
}\
|
|
|
|
static const int JSMinAlignment = 8;\
|
|
|
|
template <class T>\
|
|
|
|
QUALIFIERS T *array_new(size_t n) {\
|
|
|
|
/* The length is stored just before the vector memory. */\
|
|
|
|
uint64 numBytes64 = uint64(JSMinAlignment) + uint64(sizeof(T)) * uint64(n);\
|
|
|
|
size_t numBytes = size_t(numBytes64);\
|
|
|
|
if (numBytes64 != numBytes) {\
|
|
|
|
JS_ASSERT(0); /* we want to know if this happens in debug builds */\
|
|
|
|
return NULL;\
|
|
|
|
}\
|
|
|
|
void *memory = ALLOCATOR(numBytes);\
|
|
|
|
if (!memory)\
|
|
|
|
return NULL;\
|
|
|
|
*(size_t *)memory = n;\
|
|
|
|
memory = (void*)(uintptr_t(memory) + JSMinAlignment);\
|
|
|
|
return new(memory) T[n];\
|
|
|
|
}\
|
|
|
|
|
|
|
|
|
|
|
|
#define JS_DECLARE_DELETE_METHODS(DEALLOCATOR, QUALIFIERS)\
|
|
|
|
template <class T>\
|
|
|
|
QUALIFIERS void delete_(T *p) {\
|
|
|
|
if (p) {\
|
|
|
|
p->~T();\
|
|
|
|
DEALLOCATOR(p);\
|
|
|
|
}\
|
|
|
|
}\
|
|
|
|
\
|
|
|
|
template <class T>\
|
|
|
|
QUALIFIERS void array_delete(T *p) {\
|
|
|
|
if (p) {\
|
|
|
|
void* p0 = (void *)(uintptr_t(p) - js::OffTheBooks::JSMinAlignment);\
|
|
|
|
size_t n = *(size_t *)p0;\
|
|
|
|
for (size_t i = 0; i < n; i++)\
|
|
|
|
(p + i)->~T();\
|
|
|
|
DEALLOCATOR(p0);\
|
|
|
|
}\
|
|
|
|
}
|
2011-01-17 19:44:10 -08:00
|
|
|
|
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
/*
|
|
|
|
* In general, all allocations should go through a JSContext or JSRuntime, so
|
|
|
|
* that the garbage collector knows how much memory has been allocated. In
|
|
|
|
* cases where it is difficult to use a JSContext or JSRuntime, OffTheBooks can
|
|
|
|
* be used, though this is undesirable.
|
|
|
|
*/
|
|
|
|
namespace js {
|
2011-04-20 16:27:30 -07:00
|
|
|
/* Import common mfbt declarations into "js". */
|
|
|
|
using namespace mozilla;
|
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
class OffTheBooks {
|
|
|
|
public:
|
|
|
|
JS_DECLARE_NEW_METHODS(::js_malloc, JS_ALWAYS_INLINE static)
|
|
|
|
|
2011-03-31 01:14:12 -07:00
|
|
|
static JS_INLINE void* malloc_(size_t bytes) {
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
return ::js_malloc(bytes);
|
|
|
|
}
|
2011-01-17 19:44:10 -08:00
|
|
|
|
2011-03-31 01:14:12 -07:00
|
|
|
static JS_INLINE void* calloc_(size_t bytes) {
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
return ::js_calloc(bytes);
|
|
|
|
}
|
2011-01-17 19:44:10 -08:00
|
|
|
|
2011-03-31 01:14:12 -07:00
|
|
|
static JS_INLINE void* realloc_(void* p, size_t bytes) {
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
return ::js_realloc(p, bytes);
|
|
|
|
}
|
|
|
|
};
|
2011-01-17 19:44:10 -08:00
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
/*
|
|
|
|
* We generally prefer deallocating using JSContext because it can happen in
|
|
|
|
* the background. On slow paths, we may prefer foreground allocation.
|
|
|
|
*/
|
|
|
|
class Foreground {
|
|
|
|
public:
|
|
|
|
/* See parentheses comment above. */
|
2011-03-31 01:14:12 -07:00
|
|
|
static JS_ALWAYS_INLINE void free_(void* p) {
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
::js_free(p);
|
|
|
|
}
|
2011-01-17 19:44:10 -08:00
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
JS_DECLARE_DELETE_METHODS(::js_free, JS_ALWAYS_INLINE static)
|
|
|
|
};
|
2011-01-17 19:44:10 -08:00
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
class UnwantedForeground : public Foreground {
|
|
|
|
};
|
2011-01-17 19:44:10 -08:00
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
} /* namespace js */
|
2011-01-17 19:44:10 -08:00
|
|
|
|
Bug 634155: Account for NewCompartment's memory, and change allocation APIs (r=nnethercote)
This changes the allocation API, in the following way:
js_malloc -> {cx->,rt->,OffTheBooks::}malloc
js_calloc -> {cx->,rt->,OffTheBooks::}calloc
js_realloc -> {cx->,rt->,OffTheBooks::}realloc
js_free -> {cx->,rt->,Foreground::,UnwantedForeground::}free
js_new -> {cx->,rt->,OffTheBooks::}new_
js_new_array -> {cx->,rt->,OffTheBooks::}new_array
js_delete -> {cx->,rt->,Foreground::,UnwantedForeground::}delete_
This is to move as many allocations as possible through a JSContext (so that they may be aken into account by gcMallocBytes) and to move as many deallocations to the background as possible (except on error paths).
2011-03-31 01:13:49 -07:00
|
|
|
/*
|
|
|
|
* Note lack of ; in JSRuntime below. This is intentional so "calling" this
|
|
|
|
* looks "normal".
|
|
|
|
*/
|
|
|
|
#define JS_DECLARE_ALLOCATION_FRIENDS_FOR_PRIVATE_CONSTRUCTOR \
|
|
|
|
friend class js::OffTheBooks;\
|
|
|
|
friend class js::Foreground;\
|
|
|
|
friend class js::UnwantedForeground;\
|
|
|
|
friend struct ::JSContext;\
|
|
|
|
friend struct ::JSRuntime
|
2011-01-17 19:44:10 -08:00
|
|
|
|
|
|
|
|
2009-09-27 23:17:47 -07:00
|
|
|
/**
|
|
|
|
* The following classes are designed to cause assertions to detect
|
|
|
|
* inadvertent use of guard objects as temporaries. In other words,
|
|
|
|
* when we have a guard object whose only purpose is its constructor and
|
|
|
|
* destructor (and is never otherwise referenced), the intended use
|
|
|
|
* might be:
|
2010-03-26 18:01:54 -07:00
|
|
|
* JSAutoTempValueRooter tvr(cx, 1, &val);
|
2009-09-27 23:17:47 -07:00
|
|
|
* but is is easy to accidentally write:
|
2010-03-26 18:01:54 -07:00
|
|
|
* JSAutoTempValueRooter(cx, 1, &val);
|
2009-09-27 23:17:47 -07:00
|
|
|
* which compiles just fine, but runs the destructor well before the
|
|
|
|
* intended time.
|
|
|
|
*
|
|
|
|
* They work by adding (#ifdef DEBUG) an additional parameter to the
|
|
|
|
* guard object's constructor, with a default value, so that users of
|
|
|
|
* the guard object's API do not need to do anything. The default value
|
|
|
|
* of this parameter is a temporary object. C++ (ISO/IEC 14882:1998),
|
|
|
|
* section 12.2 [class.temporary], clauses 4 and 5 seem to assume a
|
|
|
|
* guarantee that temporaries are destroyed in the reverse of their
|
|
|
|
* construction order, but I actually can't find a statement that that
|
|
|
|
* is true in the general case (beyond the two specific cases mentioned
|
|
|
|
* there). However, it seems to be true.
|
|
|
|
*
|
|
|
|
* These classes are intended to be used only via the macros immediately
|
|
|
|
* below them:
|
|
|
|
* JS_DECL_USE_GUARD_OBJECT_NOTIFIER declares (ifdef DEBUG) a member
|
|
|
|
* variable, and should be put where a declaration of a private
|
|
|
|
* member variable would be placed.
|
|
|
|
* JS_GUARD_OBJECT_NOTIFIER_PARAM should be placed at the end of the
|
|
|
|
* parameters to each constructor of the guard object; it declares
|
|
|
|
* (ifdef DEBUG) an additional parameter.
|
|
|
|
* JS_GUARD_OBJECT_NOTIFIER_INIT is a statement that belongs in each
|
|
|
|
* constructor. It uses the parameter declared by
|
|
|
|
* JS_GUARD_OBJECT_NOTIFIER_PARAM.
|
|
|
|
*/
|
|
|
|
#ifdef DEBUG
|
|
|
|
class JSGuardObjectNotifier
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
bool* mStatementDone;
|
|
|
|
public:
|
|
|
|
JSGuardObjectNotifier() : mStatementDone(NULL) {}
|
|
|
|
|
|
|
|
~JSGuardObjectNotifier() {
|
|
|
|
*mStatementDone = true;
|
|
|
|
}
|
|
|
|
|
2010-08-29 11:57:08 -07:00
|
|
|
void setStatementDone(bool *aStatementDone) {
|
2009-09-27 23:17:47 -07:00
|
|
|
mStatementDone = aStatementDone;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
class JSGuardObjectNotificationReceiver
|
|
|
|
{
|
|
|
|
private:
|
|
|
|
bool mStatementDone;
|
|
|
|
public:
|
|
|
|
JSGuardObjectNotificationReceiver() : mStatementDone(false) {}
|
|
|
|
|
|
|
|
~JSGuardObjectNotificationReceiver() {
|
2009-10-21 15:46:33 -07:00
|
|
|
/*
|
|
|
|
* Assert that the guard object was not used as a temporary.
|
|
|
|
* (Note that this assert might also fire if Init is not called
|
|
|
|
* because the guard object's implementation is not using the
|
|
|
|
* above macros correctly.)
|
|
|
|
*/
|
2009-09-27 23:17:47 -07:00
|
|
|
JS_ASSERT(mStatementDone);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Init(const JSGuardObjectNotifier &aNotifier) {
|
2009-10-21 15:46:33 -07:00
|
|
|
/*
|
|
|
|
* aNotifier is passed as a const reference so that we can pass a
|
|
|
|
* temporary, but we really intend it as non-const
|
|
|
|
*/
|
|
|
|
const_cast<JSGuardObjectNotifier&>(aNotifier).
|
2010-08-29 11:57:08 -07:00
|
|
|
setStatementDone(&mStatementDone);
|
2009-09-27 23:17:47 -07:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
#define JS_DECL_USE_GUARD_OBJECT_NOTIFIER \
|
|
|
|
JSGuardObjectNotificationReceiver _mCheckNotUsedAsTemporary;
|
|
|
|
#define JS_GUARD_OBJECT_NOTIFIER_PARAM \
|
|
|
|
, const JSGuardObjectNotifier& _notifier = JSGuardObjectNotifier()
|
2011-03-07 14:00:00 -08:00
|
|
|
#define JS_GUARD_OBJECT_NOTIFIER_PARAM_NO_INIT \
|
|
|
|
, const JSGuardObjectNotifier& _notifier
|
2010-11-11 12:40:29 -08:00
|
|
|
#define JS_GUARD_OBJECT_NOTIFIER_PARAM0 \
|
|
|
|
const JSGuardObjectNotifier& _notifier = JSGuardObjectNotifier()
|
2009-09-27 23:17:47 -07:00
|
|
|
#define JS_GUARD_OBJECT_NOTIFIER_INIT \
|
|
|
|
JS_BEGIN_MACRO _mCheckNotUsedAsTemporary.Init(_notifier); JS_END_MACRO
|
|
|
|
|
|
|
|
#else /* defined(DEBUG) */
|
|
|
|
|
|
|
|
#define JS_DECL_USE_GUARD_OBJECT_NOTIFIER
|
|
|
|
#define JS_GUARD_OBJECT_NOTIFIER_PARAM
|
2011-03-07 14:00:00 -08:00
|
|
|
#define JS_GUARD_OBJECT_NOTIFIER_PARAM_NO_INIT
|
2010-11-11 12:40:29 -08:00
|
|
|
#define JS_GUARD_OBJECT_NOTIFIER_PARAM0
|
2009-09-27 23:17:47 -07:00
|
|
|
#define JS_GUARD_OBJECT_NOTIFIER_INIT JS_BEGIN_MACRO JS_END_MACRO
|
|
|
|
|
|
|
|
#endif /* !defined(DEBUG) */
|
|
|
|
|
2010-08-09 13:59:28 -07:00
|
|
|
namespace js {
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
JS_ALWAYS_INLINE static void
|
|
|
|
PodZero(T *t)
|
|
|
|
{
|
|
|
|
memset(t, 0, sizeof(T));
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class T>
|
|
|
|
JS_ALWAYS_INLINE static void
|
|
|
|
PodZero(T *t, size_t nelem)
|
|
|
|
{
|
|
|
|
memset(t, 0, nelem * sizeof(T));
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Arrays implicitly convert to pointers to their first element, which is
|
|
|
|
* dangerous when combined with the above PodZero definitions. Adding an
|
|
|
|
* overload for arrays is ambiguous, so we need another identifier. The
|
|
|
|
* ambiguous overload is left to catch mistaken uses of PodZero; if you get a
|
|
|
|
* compile error involving PodZero and array types, use PodArrayZero instead.
|
|
|
|
*/
|
|
|
|
template <class T, size_t N> static void PodZero(T (&)[N]); /* undefined */
|
|
|
|
template <class T, size_t N> static void PodZero(T (&)[N], size_t); /* undefined */
|
|
|
|
|
|
|
|
template <class T, size_t N>
|
|
|
|
JS_ALWAYS_INLINE static void
|
|
|
|
PodArrayZero(T (&t)[N])
|
|
|
|
{
|
|
|
|
memset(t, 0, N * sizeof(T));
|
|
|
|
}
|
|
|
|
|
2010-11-08 14:35:30 -08:00
|
|
|
template <class T>
|
|
|
|
JS_ALWAYS_INLINE static void
|
2010-12-06 10:26:58 -08:00
|
|
|
PodCopy(T *dst, const T *src, size_t nelem)
|
2010-11-08 14:35:30 -08:00
|
|
|
{
|
2011-01-11 15:20:07 -08:00
|
|
|
/* Cannot find portable word-sized abs(). */
|
|
|
|
JS_ASSERT_IF(dst >= src, size_t(dst - src) >= nelem);
|
|
|
|
JS_ASSERT_IF(src >= dst, size_t(src - dst) >= nelem);
|
|
|
|
|
2010-11-08 14:35:30 -08:00
|
|
|
if (nelem < 128) {
|
2010-12-06 10:26:58 -08:00
|
|
|
for (const T *srcend = src + nelem; src != srcend; ++src, ++dst)
|
2010-11-08 14:35:30 -08:00
|
|
|
*dst = *src;
|
|
|
|
} else {
|
|
|
|
memcpy(dst, src, nelem * sizeof(T));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-14 13:59:53 -07:00
|
|
|
template <class T>
|
|
|
|
JS_ALWAYS_INLINE static bool
|
|
|
|
PodEqual(T *one, T *two, size_t len)
|
|
|
|
{
|
|
|
|
if (len < 128) {
|
|
|
|
T *p1end = one + len;
|
|
|
|
for (T *p1 = one, *p2 = two; p1 != p1end; ++p1, ++p2) {
|
|
|
|
if (*p1 != *p2)
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return !memcmp(one, two, len * sizeof(T));
|
|
|
|
}
|
|
|
|
|
2011-06-30 09:26:56 -07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Ordinarily, a function taking a JSContext* 'cx' paremter reports errors on
|
|
|
|
* the context. In some cases, functions optionally report and indicate this by
|
|
|
|
* taking a nullable 'maybecx' parameter. In some cases, though, a function
|
|
|
|
* always needs a 'cx', but optionally reports. This option is presented by the
|
|
|
|
* MaybeReportError.
|
|
|
|
*/
|
|
|
|
enum MaybeReportError { REPORT_ERROR = true, DONT_REPORT_ERROR = false };
|
|
|
|
|
2011-08-01 17:52:53 -07:00
|
|
|
/*
|
|
|
|
* "Move" References
|
|
|
|
*
|
|
|
|
* Some types can be copied much more efficiently if we know the original's
|
|
|
|
* value need not be preserved --- that is, if we are doing a "move", not a
|
|
|
|
* "copy". For example, if we have:
|
|
|
|
*
|
|
|
|
* Vector<T> u;
|
|
|
|
* Vector<T> v(u);
|
|
|
|
*
|
|
|
|
* the constructor for v must apply a copy constructor to each element of u ---
|
|
|
|
* taking time linear in the length of u. However, if we know we will not need u
|
|
|
|
* any more once v has been initialized, then we could initialize v very
|
|
|
|
* efficiently simply by stealing u's dynamically allocated buffer and giving it
|
|
|
|
* to v --- a constant-time operation, regardless of the size of u.
|
|
|
|
*
|
|
|
|
* Moves often appear in container implementations. For example, when we append
|
|
|
|
* to a vector, we may need to resize its buffer. This entails moving each of
|
|
|
|
* its extant elements from the old, smaller buffer to the new, larger buffer.
|
|
|
|
* But once the elements have been migrated, we're just going to throw away the
|
|
|
|
* old buffer; we don't care if they still have their values. So if the vector's
|
|
|
|
* element type can implement "move" more efficiently than "copy", the vector
|
|
|
|
* resizing should by all means use a "move" operation. Hash tables also need to
|
|
|
|
* be resized.
|
|
|
|
*
|
|
|
|
* The details of the optimization, and whether it's worth applying, vary from
|
|
|
|
* one type to the next. And while some constructor calls are moves, many really
|
|
|
|
* are copies, and can't be optimized this way. So we need:
|
|
|
|
*
|
|
|
|
* 1) a way for a particular invocation of a copy constructor to say that it's
|
|
|
|
* really a move, and that the value of the original isn't important
|
|
|
|
* afterwards (althought it must still be safe to destroy); and
|
|
|
|
*
|
|
|
|
* 2) a way for a type (like Vector) to announce that it can be moved more
|
|
|
|
* efficiently than it can be copied, and provide an implementation of that
|
|
|
|
* move operation.
|
|
|
|
*
|
|
|
|
* The Move(T &) function takes a reference to a T, and returns an MoveRef<T>
|
|
|
|
* referring to the same value; that's 1). An MoveRef<T> is simply a reference
|
|
|
|
* to a T, annotated to say that a copy constructor applied to it may move that
|
|
|
|
* T, instead of copying it. Finally, a constructor that accepts an MoveRef<T>
|
|
|
|
* should perform a more efficient move, instead of a copy, providing 2).
|
|
|
|
*
|
|
|
|
* So, where we might define a copy constructor for a class C like this:
|
|
|
|
*
|
|
|
|
* C(const C &rhs) { ... copy rhs to this ... }
|
|
|
|
*
|
|
|
|
* we would declare a move constructor like this:
|
|
|
|
*
|
|
|
|
* C(MoveRef<C> rhs) { ... move rhs to this ... }
|
|
|
|
*
|
|
|
|
* And where we might perform a copy like this:
|
|
|
|
*
|
|
|
|
* C c2(c1);
|
|
|
|
*
|
|
|
|
* we would perform a move like this:
|
|
|
|
*
|
|
|
|
* C c2(Move(c1))
|
|
|
|
*
|
|
|
|
* Note that MoveRef<T> implicitly converts to T &, so you can pass an
|
|
|
|
* MoveRef<T> to an ordinary copy constructor for a type that doesn't support a
|
|
|
|
* special move constructor, and you'll just get a copy. This means that
|
|
|
|
* templates can use Move whenever they know they won't use the original value
|
|
|
|
* any more, even if they're not sure whether the type at hand has a specialized
|
|
|
|
* move constructor. If it doesn't, the MoveRef<T> will just convert to a T &,
|
|
|
|
* and the ordinary copy constructor will apply.
|
|
|
|
*
|
|
|
|
* A class with a move constructor can also provide a move assignment operator,
|
|
|
|
* which runs this's destructor, and then applies the move constructor to
|
|
|
|
* *this's memory. A typical definition:
|
|
|
|
*
|
|
|
|
* C &operator=(MoveRef<C> rhs) {
|
|
|
|
* this->~C();
|
|
|
|
* new(this) C(rhs);
|
|
|
|
* return *this;
|
|
|
|
* }
|
|
|
|
*
|
|
|
|
* With that in place, one can write move assignments like this:
|
|
|
|
*
|
|
|
|
* c2 = Move(c1);
|
|
|
|
*
|
|
|
|
* This destroys c1, moves c1's value to c2, and leaves c1 in an undefined but
|
|
|
|
* destructible state.
|
|
|
|
*
|
|
|
|
* This header file defines MoveRef and Move in the js namespace. It's up to
|
|
|
|
* individual containers to annotate moves as such, by calling Move; and it's up
|
|
|
|
* to individual types to define move constructors.
|
|
|
|
*
|
|
|
|
* One hint: if you're writing a move constructor where the type has members
|
|
|
|
* that should be moved themselves, it's much nicer to write this:
|
|
|
|
*
|
|
|
|
* C(MoveRef<C> c) : x(c->x), y(c->y) { }
|
|
|
|
*
|
|
|
|
* than the equivalent:
|
|
|
|
*
|
|
|
|
* C(MoveRef<C> c) { new(&x) X(c->x); new(&y) Y(c->y); }
|
|
|
|
*
|
|
|
|
* especially since GNU C++ fails to notice that this does indeed initialize x
|
|
|
|
* and y, which may matter if they're const.
|
|
|
|
*/
|
|
|
|
template<typename T>
|
|
|
|
class MoveRef {
|
|
|
|
public:
|
|
|
|
typedef T Referent;
|
|
|
|
explicit MoveRef(T &t) : pointer(&t) { }
|
|
|
|
T &operator*() const { return *pointer; }
|
|
|
|
T *operator->() const { return pointer; }
|
|
|
|
operator T &() const { return *pointer; }
|
|
|
|
private:
|
|
|
|
T *pointer;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<typename T>
|
|
|
|
MoveRef<T> Move(T &t) { return MoveRef<T>(t); }
|
|
|
|
|
2010-08-09 13:59:28 -07:00
|
|
|
} /* namespace js */
|
|
|
|
|
2009-09-27 23:17:47 -07:00
|
|
|
#endif /* defined(__cplusplus) */
|
|
|
|
|
2007-03-22 10:30:00 -07:00
|
|
|
#endif /* jsutil_h___ */
|