From 67205d03011ba1958d81681687d554755f696f35 Mon Sep 17 00:00:00 2001 From: Farrell Rafi Date: Fri, 5 Mar 2021 18:28:10 +0700 Subject: [PATCH] Add Boehm (BDWGC) Garbage Collector, experimental --- bin/compile.js | 9 +- boehm/gc.a | Bin 0 -> 548960 bytes boehm/gc.h | 2 + boehm/gc/cord.h | 377 ++++++ boehm/gc/cord_pos.h | 128 ++ boehm/gc/ec.h | 89 ++ boehm/gc/gc.h | 2151 +++++++++++++++++++++++++++++++ boehm/gc/gc_backptr.h | 96 ++ boehm/gc/gc_config_macros.h | 454 +++++++ boehm/gc/gc_disclaim.h | 74 ++ boehm/gc/gc_gcj.h | 110 ++ boehm/gc/gc_inline.h | 208 +++ boehm/gc/gc_mark.h | 328 +++++ boehm/gc/gc_pthread_redirects.h | 124 ++ boehm/gc/gc_tiny_fl.h | 90 ++ boehm/gc/gc_typed.h | 122 ++ boehm/gc/gc_version.h | 47 + boehm/gc/javaxfc.h | 65 + boehm/gc/leak_detector.h | 68 + 19 files changed, 4540 insertions(+), 2 deletions(-) create mode 100644 boehm/gc.a create mode 100644 boehm/gc.h create mode 100644 boehm/gc/cord.h create mode 100644 boehm/gc/cord_pos.h create mode 100644 boehm/gc/ec.h create mode 100644 boehm/gc/gc.h create mode 100644 boehm/gc/gc_backptr.h create mode 100644 boehm/gc/gc_config_macros.h create mode 100644 boehm/gc/gc_disclaim.h create mode 100644 boehm/gc/gc_gcj.h create mode 100644 boehm/gc/gc_inline.h create mode 100644 boehm/gc/gc_mark.h create mode 100644 boehm/gc/gc_pthread_redirects.h create mode 100644 boehm/gc/gc_tiny_fl.h create mode 100644 boehm/gc/gc_typed.h create mode 100644 boehm/gc/gc_version.h create mode 100644 boehm/gc/javaxfc.h create mode 100644 boehm/gc/leak_detector.h diff --git a/bin/compile.js b/bin/compile.js index 346ae0b..e957d0a 100755 --- a/bin/compile.js +++ b/bin/compile.js @@ -61,8 +61,11 @@ if (!check_exist(emcc + ' -v', true)) throw new Error('emcc (comes with emsdk) m var tempdir = path.join(os.tmpdir(), 'rpython-' + (new Date()).getTime()); fs.mkdirSync(tempdir); process.env.PYPY_USESSION_DIR = platform === 'win32' ? cygpath(tempdir) : tempdir; +if (!process.env.C_INCLUDE_PATH) process.env.C_INCLUDE_PATH = ''; +else process.env.C_INCLUDE_PATH += ':'; +process.env.C_INCLUDE_PATH += path.join(__dirname, '../boehm'); process.env.USER = 'current'; -child_process.execSync([python, rpython, '--gc=none', '-s'].concat(process.argv.slice(2)).join(' '), {stdio: 'inherit', env: process.env}); +child_process.execSync([python, rpython, '--gc=boehm', '-s'].concat(process.argv.slice(2)).join(' '), {stdio: 'inherit', env: process.env}); if (process.argv[2] && process.argv[2].indexOf('.py') !== -1) { var file = process.argv[2].split('.py')[0]; var directory = path.join(tempdir, 'usession-unknown-0', 'testing_1'); @@ -71,16 +74,18 @@ if (process.argv[2] && process.argv[2].indexOf('.py') !== -1) { if (process.argv.indexOf('--use-pthread') === -1) make = make.replace(/-pthread/g, ''); if (platform === 'win32') make = make.replace('RPYDIR = ', 'RPYDIR = "' + rpydir + '"#') make = make.replace(/-lutil/g, ''); + make = make.replace(/-lgc/g, ''); make = make.replace(/--export-all-symbols/g, '--export-dynamic'); make = make.replace('CC = ', 'CC = ' + emcc + ' -s ALLOW_MEMORY_GROWTH=1 #'); make = make.replace('TARGET = ', 'TARGET = ' + file + '.js #'); make = make.replace('DEFAULT_TARGET = ', 'DEFAULT_TARGET = ' + file + '.js #'); + make = make.replace('$(LIBDIRS) $(LIBS) $(LINKFILES) $(LDFLAGS)', path.join(__dirname, '../boehm/gc.a') + ' $(LIBDIRS) $(LIBS) $(LINKFILES) $(LDFLAGS)'); fs.writeFileSync(makefile, make); var cores = process.env.CORE; if (!cores) cores = os.cpus().filter(function(cpu) {return cpu.speed}).length; if (!cores) cores = child_process.execSync('nproc').toString().trim(); if (platform === 'darwin') { - process.env.C_INCLUDE_PATH = path.join(__dirname, '../dmidecode'); + process.env.C_INCLUDE_PATH += ':' + path.join(__dirname, '../dmidecode'); } child_process.execSync(['make', '-j', cores].join(' '), {env: process.env, stdio: 'inherit', cwd: directory}); for (var filename of fs.readdirSync(directory)) { diff --git a/boehm/gc.a b/boehm/gc.a new file mode 100644 index 0000000000000000000000000000000000000000..bbfc93624ca91517db9e7490e171980c73cbfaed GIT binary patch literal 548960 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�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©X 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�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 J|KLaT{{?sXqcQ*h literal 0 HcmV?d00001 diff --git a/boehm/gc.h b/boehm/gc.h new file mode 100644 index 0000000..55ae4c6 --- /dev/null +++ b/boehm/gc.h @@ -0,0 +1,2 @@ +/* This file is installed for backward compatibility. */ +#include diff --git a/boehm/gc/cord.h b/boehm/gc/cord.h new file mode 100644 index 0000000..4ce89ff --- /dev/null +++ b/boehm/gc/cord.h @@ -0,0 +1,377 @@ +/* + * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +/* + * Cords are immutable character strings. A number of operations + * on long cords are much more efficient than their strings.h counterpart. + * In particular, concatenation takes constant time independent of the length + * of the arguments. (Cords are represented as trees, with internal + * nodes representing concatenation and leaves consisting of either C + * strings or a functional description of the string.) + * + * The following are reasonable applications of cords. They would perform + * unacceptably if C strings were used: + * - A compiler that produces assembly language output by repeatedly + * concatenating instructions onto a cord representing the output file. + * - A text editor that converts the input file to a cord, and then + * performs editing operations by producing a new cord representing + * the file after each character change (and keeping the old ones in an + * edit history) + * + * For optimal performance, cords should be built by + * concatenating short sections. + * This interface is designed for maximum compatibility with C strings. + * ASCII NUL characters may be embedded in cords using CORD_from_fn. + * This is handled correctly, but CORD_to_char_star will produce a string + * with embedded NULs when given such a cord. + * + * This interface is fairly big, largely for performance reasons. + * The most basic constants and functions: + * + * CORD - the type of a cord; + * CORD_EMPTY - empty cord; + * CORD_len(cord) - length of a cord; + * CORD_cat(cord1,cord2) - concatenation of two cords; + * CORD_substr(cord, start, len) - substring (or subcord); + * CORD_pos i; CORD_FOR(i, cord) { ... CORD_pos_fetch(i) ... } - + * examine each character in a cord. CORD_pos_fetch(i) is the char. + * CORD_fetch(int i) - Retrieve i'th character (slowly). + * CORD_cmp(cord1, cord2) - compare two cords. + * CORD_from_file(FILE * f) - turn a read-only file into a cord. + * CORD_to_char_star(cord) - convert to C string. + * (Non-NULL C constant strings are cords.) + * CORD_printf (etc.) - cord version of printf. Use %r for cords. + */ +#ifndef CORD_H +#define CORD_H + +#include +#include + +#ifdef __cplusplus + extern "C" { +#endif + +#if defined(GC_DLL) && !defined(CORD_NOT_DLL) + /* Same as for GC_API in gc_config_macros.h. */ +# ifdef CORD_BUILD +# if defined(__MINGW32__) || defined(__CEGCC__) +# define CORD_API __declspec(dllexport) +# elif defined(_MSC_VER) || defined(__DMC__) || defined(__BORLANDC__) \ + || defined(__CYGWIN__) || defined(__WATCOMC__) +# define CORD_API extern __declspec(dllexport) +# elif defined(__GNUC__) && !defined(GC_NO_VISIBILITY) \ + && (__GNUC__ >= 4 || defined(GC_VISIBILITY_HIDDEN_SET)) + /* Only matters if used in conjunction with -fvisibility=hidden option. */ +# define CORD_API extern __attribute__((__visibility__("default"))) +# endif +# else +# if defined(__MINGW32__) || defined(__CEGCC__) || defined(_MSC_VER) \ + || defined(__DMC__) || defined(__BORLANDC__) || defined(__CYGWIN__) +# define CORD_API __declspec(dllimport) +# elif defined(__WATCOMC__) +# define CORD_API extern __declspec(dllimport) +# endif +# endif /* !CORD_BUILD */ +#endif /* GC_DLL */ + +#ifndef CORD_API +# define CORD_API extern +#endif + +/* Cords have type const char *. This is cheating quite a bit, and not */ +/* 100% portable. But it means that nonempty character string */ +/* constants may be used as cords directly, provided the string is */ +/* never modified in place. The empty cord is represented by, and */ +/* can be written as, 0. */ + +typedef const char * CORD; + +/* An empty cord is always represented as nil */ +#define CORD_EMPTY 0 + +/* Is a nonempty cord represented as a C string? */ +#define CORD_IS_STRING(s) (*(s) != '\0') + +/* Concatenate two cords. If the arguments are C strings, they may */ +/* not be subsequently altered. */ +CORD_API CORD CORD_cat(CORD x, CORD y); + +/* Concatenate a cord and a C string with known length. Except for the */ +/* empty string case, this is a special case of CORD_cat. Since the */ +/* length is known, it can be faster. */ +/* The string y is shared with the resulting CORD. Hence it should */ +/* not be altered by the caller. */ +CORD_API CORD CORD_cat_char_star(CORD x, const char * y, size_t leny); + +/* Compute the length of a cord */ +CORD_API size_t CORD_len(CORD x); + +/* Cords may be represented by functions defining the ith character */ +typedef char (* CORD_fn)(size_t i, void * client_data); + +/* Turn a functional description into a cord. */ +CORD_API CORD CORD_from_fn(CORD_fn fn, void * client_data, size_t len); + +/* Return the substring (subcord really) of x with length at most n, */ +/* starting at position i. (The initial character has position 0.) */ +CORD_API CORD CORD_substr(CORD x, size_t i, size_t n); + +/* Return the argument, but rebalanced to allow more efficient */ +/* character retrieval, substring operations, and comparisons. */ +/* This is useful only for cords that were built using repeated */ +/* concatenation. Guarantees log time access to the result, unless */ +/* x was obtained through a large number of repeated substring ops */ +/* or the embedded functional descriptions take longer to evaluate. */ +/* May reallocate significant parts of the cord. The argument is not */ +/* modified; only the result is balanced. */ +CORD_API CORD CORD_balance(CORD x); + +/* The following traverse a cord by applying a function to each */ +/* character. This is occasionally appropriate, especially where */ +/* speed is crucial. But, since C doesn't have nested functions, */ +/* clients of this sort of traversal are clumsy to write. Consider */ +/* the functions that operate on cord positions instead. */ + +/* Function to iteratively apply to individual characters in cord. */ +typedef int (* CORD_iter_fn)(char c, void * client_data); + +/* Function to apply to substrings of a cord. Each substring is a */ +/* a C character string, not a general cord. */ +typedef int (* CORD_batched_iter_fn)(const char * s, void * client_data); +#define CORD_NO_FN ((CORD_batched_iter_fn)0) + +/* Apply f1 to each character in the cord, in ascending order, */ +/* starting at position i. If */ +/* f2 is not CORD_NO_FN, then multiple calls to f1 may be replaced by */ +/* a single call to f2. The parameter f2 is provided only to allow */ +/* some optimization by the client. This terminates when the right */ +/* end of this string is reached, or when f1 or f2 return != 0. In the */ +/* latter case CORD_iter returns != 0. Otherwise it returns 0. */ +/* The specified value of i must be < CORD_len(x). */ +CORD_API int CORD_iter5(CORD x, size_t i, CORD_iter_fn f1, + CORD_batched_iter_fn f2, void * client_data); + +/* A simpler version that starts at 0, and without f2: */ +CORD_API int CORD_iter(CORD x, CORD_iter_fn f1, void * client_data); +#define CORD_iter(x, f1, cd) CORD_iter5(x, 0, f1, CORD_NO_FN, cd) + +/* Similar to CORD_iter5, but end-to-beginning. No provisions for */ +/* CORD_batched_iter_fn. */ +CORD_API int CORD_riter4(CORD x, size_t i, CORD_iter_fn f1, void * client_data); + +/* A simpler version that starts at the end: */ +CORD_API int CORD_riter(CORD x, CORD_iter_fn f1, void * client_data); + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +/* Functions that operate on cord positions. The easy way to traverse */ +/* cords. A cord position is logically a pair consisting of a cord */ +/* and an index into that cord. But it is much faster to retrieve a */ +/* character based on a position than on an index. Unfortunately, */ +/* positions are big (order of a few 100 bytes), so allocate them with */ +/* caution. */ +/* Things in cord_pos.h should be treated as opaque, except as */ +/* described below. Also note that */ +/* CORD_pos_fetch, CORD_next and CORD_prev have both macro and function */ +/* definitions. The former may evaluate their argument more than once. */ +#include "cord_pos.h" + +#ifdef __cplusplus + extern "C" { +#endif + +/* + Visible definitions from above: + + typedef CORD_pos[1]; + + * Extract the cord from a position: + CORD CORD_pos_to_cord(CORD_pos p); + + * Extract the current index from a position: + size_t CORD_pos_to_index(CORD_pos p); + + * Fetch the character located at the given position: + char CORD_pos_fetch(CORD_pos p); + + * Initialize the position to refer to the given cord and index. + * Note that this is the most expensive function on positions: + void CORD_set_pos(CORD_pos p, CORD x, size_t i); + + * Advance the position to the next character. + * P must be initialized and valid. + * Invalidates p if past end: + void CORD_next(CORD_pos p); + + * Move the position to the preceding character. + * P must be initialized and valid. + * Invalidates p if past beginning: + void CORD_prev(CORD_pos p); + + * Is the position valid, i.e. inside the cord? + int CORD_pos_valid(CORD_pos p); +*/ +#define CORD_FOR(pos, cord) \ + for (CORD_set_pos(pos, cord, 0); CORD_pos_valid(pos); CORD_next(pos)) + + +/* An out of memory handler to call. May be supplied by client. */ +/* Must not return. */ +extern void (* CORD_oom_fn)(void); + +/* Dump the representation of x to stdout in an implementation defined */ +/* manner. Intended for debugging only. */ +CORD_API void CORD_dump(CORD x); + +/* The following could easily be implemented by the client. They are */ +/* provided in cordxtra.c for convenience. */ + +/* Concatenate a character to the end of a cord. */ +CORD_API CORD CORD_cat_char(CORD x, char c); + +/* Concatenate n cords. */ +CORD_API CORD CORD_catn(int n, /* CORD */ ...); + +/* Return the character in CORD_substr(x, i, 1) */ +CORD_API char CORD_fetch(CORD x, size_t i); + +/* Return < 0, 0, or > 0, depending on whether x < y, x = y, x > y */ +CORD_API int CORD_cmp(CORD x, CORD y); + +/* A generalization that takes both starting positions for the */ +/* comparison, and a limit on the number of characters to be compared. */ +CORD_API int CORD_ncmp(CORD x, size_t x_start, CORD y, size_t y_start, + size_t len); + +/* Find the first occurrence of s in x at position start or later. */ +/* Return the position of the first character of s in x, or */ +/* CORD_NOT_FOUND if there is none. */ +CORD_API size_t CORD_str(CORD x, size_t start, CORD s); + +/* Return a cord consisting of i copies of (possibly NUL) c. Dangerous */ +/* in conjunction with CORD_to_char_star. */ +/* The resulting representation takes constant space, independent of i. */ +CORD_API CORD CORD_chars(char c, size_t i); +#define CORD_nul(i) CORD_chars('\0', (i)) + +/* Turn a file into cord. The file must be seekable. Its contents */ +/* must remain constant. The file may be accessed as an immediate */ +/* result of this call and/or as a result of subsequent accesses to */ +/* the cord. Short files are likely to be immediately read, but */ +/* long files are likely to be read on demand, possibly relying on */ +/* stdio for buffering. */ +/* We must have exclusive access to the descriptor f, i.e. we may */ +/* read it at any time, and expect the file pointer to be */ +/* where we left it. Normally this should be invoked as */ +/* CORD_from_file(fopen(...)) */ +/* CORD_from_file arranges to close the file descriptor when it is no */ +/* longer needed (e.g. when the result becomes inaccessible). */ +/* The file f must be such that ftell reflects the actual character */ +/* position in the file, i.e. the number of characters that can be */ +/* or were read with fread. On UNIX systems this is always true. On */ +/* MS Windows systems, f must be opened in binary mode. */ +CORD_API CORD CORD_from_file(FILE * f); + +/* Equivalent to the above, except that the entire file will be read */ +/* and the file pointer will be closed immediately. */ +/* The binary mode restriction from above does not apply. */ +CORD_API CORD CORD_from_file_eager(FILE * f); + +/* Equivalent to the above, except that the file will be read on demand.*/ +/* The binary mode restriction applies. */ +CORD_API CORD CORD_from_file_lazy(FILE * f); + +/* Turn a cord into a C string. The result shares no structure with */ +/* x, and is thus modifiable. */ +CORD_API char * CORD_to_char_star(CORD x); + +/* Turn a C string into a CORD. The C string is copied, and so may */ +/* subsequently be modified. */ +CORD_API CORD CORD_from_char_star(const char *s); + +/* Identical to the above, but the result may share structure with */ +/* the argument and is thus not modifiable. */ +CORD_API const char * CORD_to_const_char_star(CORD x); + +/* Write a cord to a file, starting at the current position. No */ +/* trailing NULs are newlines are added. */ +/* Returns EOF if a write error occurs, 1 otherwise. */ +CORD_API int CORD_put(CORD x, FILE * f); + +/* "Not found" result for the following two functions. */ +#define CORD_NOT_FOUND ((size_t)(-1)) + +/* A vague analog of strchr. Returns the position (an integer, not */ +/* a pointer) of the first occurrence of (char) c inside x at position */ +/* i or later. The value i must be < CORD_len(x). */ +CORD_API size_t CORD_chr(CORD x, size_t i, int c); + +/* A vague analog of strrchr. Returns index of the last occurrence */ +/* of (char) c inside x at position i or earlier. The value i */ +/* must be < CORD_len(x). */ +CORD_API size_t CORD_rchr(CORD x, size_t i, int c); + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +/* The following are also not primitive, but are implemented in */ +/* cordprnt.c. They provide functionality similar to the ANSI C */ +/* functions with corresponding names, but with the following */ +/* additions and changes: */ +/* 1. A %r conversion specification specifies a CORD argument. Field */ +/* width, precision, etc. have the same semantics as for %s. */ +/* (Note that %c, %C, and %S were already taken.) */ +/* 2. The format string is represented as a CORD. */ +/* 3. CORD_sprintf and CORD_vsprintf assign the result through the 1st */ +/* argument. Unlike their ANSI C versions, there is no need to guess */ +/* the correct buffer size. */ +/* 4. Most of the conversions are implement through the native */ +/* vsprintf. Hence they are usually no faster, and */ +/* idiosyncrasies of the native printf are preserved. However, */ +/* CORD arguments to CORD_sprintf and CORD_vsprintf are NOT copied; */ +/* the result shares the original structure. This may make them */ +/* very efficient in some unusual applications. */ +/* The format string is copied. */ +/* All functions return the number of characters generated or -1 on */ +/* error. This complies with the ANSI standard, but is inconsistent */ +/* with some older implementations of sprintf. */ + +/* The implementation of these is probably less portable than the rest */ +/* of this package. */ + +#ifndef CORD_NO_IO + +#include + +# ifdef __cplusplus + extern "C" { +# endif + +CORD_API int CORD_sprintf(CORD * out, CORD format, ...); +CORD_API int CORD_vsprintf(CORD * out, CORD format, va_list args); +CORD_API int CORD_fprintf(FILE * f, CORD format, ...); +CORD_API int CORD_vfprintf(FILE * f, CORD format, va_list args); +CORD_API int CORD_printf(CORD format, ...); +CORD_API int CORD_vprintf(CORD format, va_list args); + +# ifdef __cplusplus + } /* extern "C" */ +# endif + +#endif /* CORD_NO_IO */ + +#endif /* CORD_H */ diff --git a/boehm/gc/cord_pos.h b/boehm/gc/cord_pos.h new file mode 100644 index 0000000..29d5df9 --- /dev/null +++ b/boehm/gc/cord_pos.h @@ -0,0 +1,128 @@ +/* + * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +/* This should never be included directly; included only from cord.h. */ +#if !defined(CORD_POSITION_H) && defined(CORD_H) +#define CORD_POSITION_H + +#ifdef __cplusplus + extern "C" { +#endif + +/* The representation of CORD_position. This is private to the */ +/* implementation, but the size is known to clients. Also */ +/* the implementation of some exported macros relies on it. */ +/* Don't use anything defined here and not in cord.h. */ + +# define MAX_DEPTH 48 + /* The maximum depth of a balanced cord + 1. */ + /* We don't let cords get deeper than MAX_DEPTH. */ + +struct CORD_pe { + CORD pe_cord; + size_t pe_start_pos; +}; + +/* A structure describing an entry on the path from the root */ +/* to current position. */ +typedef struct CORD_Pos { + size_t cur_pos; + int path_len; +# define CORD_POS_INVALID (0x55555555) + /* path_len == INVALID <==> position invalid */ + const char *cur_leaf; /* Current leaf, if it is a string. */ + /* If the current leaf is a function, */ + /* then this may point to function_buf */ + /* containing the next few characters. */ + /* Always points to a valid string */ + /* containing the current character */ + /* unless cur_end is 0. */ + size_t cur_start; /* Start position of cur_leaf */ + size_t cur_end; /* Ending position of cur_leaf */ + /* 0 if cur_leaf is invalid. */ + struct CORD_pe path[MAX_DEPTH + 1]; + /* path[path_len] is the leaf corresponding to cur_pos */ + /* path[0].pe_cord is the cord we point to. */ +# define FUNCTION_BUF_SZ 8 + char function_buf[FUNCTION_BUF_SZ]; /* Space for next few chars */ + /* from function node. */ +} CORD_pos[1]; + +/* Extract the cord from a position: */ +CORD_API CORD CORD_pos_to_cord(CORD_pos p); + +/* Extract the current index from a position: */ +CORD_API size_t CORD_pos_to_index(CORD_pos p); + +/* Fetch the character located at the given position: */ +CORD_API char CORD_pos_fetch(CORD_pos p); + +/* Initialize the position to refer to the give cord and index. */ +/* Note that this is the most expensive function on positions: */ +CORD_API void CORD_set_pos(CORD_pos p, CORD x, size_t i); + +/* Advance the position to the next character. */ +/* P must be initialized and valid. */ +/* Invalidates p if past end: */ +CORD_API void CORD_next(CORD_pos p); + +/* Move the position to the preceding character. */ +/* P must be initialized and valid. */ +/* Invalidates p if past beginning: */ +CORD_API void CORD_prev(CORD_pos p); + +/* Is the position valid, i.e. inside the cord? */ +CORD_API int CORD_pos_valid(CORD_pos p); + +CORD_API char CORD__pos_fetch(CORD_pos); +CORD_API void CORD__next(CORD_pos); +CORD_API void CORD__prev(CORD_pos); + +#define CORD_pos_fetch(p) \ + (((p)[0].cur_end != 0)? \ + (p)[0].cur_leaf[(p)[0].cur_pos - (p)[0].cur_start] \ + : CORD__pos_fetch(p)) + +#define CORD_next(p) \ + (((p)[0].cur_pos + 1 < (p)[0].cur_end)? \ + (p)[0].cur_pos++ \ + : (CORD__next(p), 0)) + +#define CORD_prev(p) \ + (((p)[0].cur_end != 0 && (p)[0].cur_pos > (p)[0].cur_start)? \ + (p)[0].cur_pos-- \ + : (CORD__prev(p), 0)) + +#define CORD_pos_to_index(p) ((p)[0].cur_pos) + +#define CORD_pos_to_cord(p) ((p)[0].path[0].pe_cord) + +#define CORD_pos_valid(p) ((p)[0].path_len != CORD_POS_INVALID) + +/* Some grubby stuff for performance-critical friends: */ +#define CORD_pos_chars_left(p) ((long)((p)[0].cur_end) - (long)((p)[0].cur_pos)) + /* Number of characters in cache. <= 0 ==> none */ + +#define CORD_pos_advance(p,n) ((p)[0].cur_pos += (n) - 1, CORD_next(p)) + /* Advance position by n characters */ + /* 0 < n < CORD_pos_chars_left(p) */ + +#define CORD_pos_cur_char_addr(p) \ + (p)[0].cur_leaf + ((p)[0].cur_pos - (p)[0].cur_start) + /* address of current character in cache. */ + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +#endif diff --git a/boehm/gc/ec.h b/boehm/gc/ec.h new file mode 100644 index 0000000..e7e0f7f --- /dev/null +++ b/boehm/gc/ec.h @@ -0,0 +1,89 @@ +/* + * Copyright (c) 1993-1994 by Xerox Corporation. All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +#ifndef EC_H +#define EC_H + +# ifndef CORD_H +# include "cord.h" +# endif + +#ifdef __cplusplus + extern "C" { +#endif + +/* Extensible cords are strings that may be destructively appended to. */ +/* They allow fast construction of cords from characters that are */ +/* being read from a stream. */ +/* + * A client might look like: + * + * { + * CORD_ec x; + * CORD result; + * char c; + * FILE *f; + * + * ... + * CORD_ec_init(x); + * while(...) { + * c = getc(f); + * ... + * CORD_ec_append(x, c); + * } + * result = CORD_balance(CORD_ec_to_cord(x)); + * + * If a C string is desired as the final result, the call to CORD_balance + * may be replaced by a call to CORD_to_char_star. + */ + +# ifndef CORD_BUFSZ +# define CORD_BUFSZ 128 +# endif + +typedef struct CORD_ec_struct { + CORD ec_cord; + char * ec_bufptr; + char ec_buf[CORD_BUFSZ+1]; +} CORD_ec[1]; + +/* This structure represents the concatenation of ec_cord with */ +/* ec_buf[0 ... (ec_bufptr-ec_buf-1)] */ + +/* Flush the buffer part of the extended cord into ec_cord. */ +/* Note that this is almost the only real function, and it is */ +/* implemented in 6 lines in cordxtra.c */ +void CORD_ec_flush_buf(CORD_ec x); + +/* Convert an extensible cord to a cord. */ +# define CORD_ec_to_cord(x) (CORD_ec_flush_buf(x), (x)[0].ec_cord) + +/* Initialize an extensible cord. */ +#define CORD_ec_init(x) \ + ((x)[0].ec_cord = 0, (void)((x)[0].ec_bufptr = (x)[0].ec_buf)) + +/* Append a character to an extensible cord. */ +#define CORD_ec_append(x, c) \ + ((void)((x)[0].ec_bufptr == (x)[0].ec_buf + CORD_BUFSZ \ + ? (CORD_ec_flush_buf(x), 0) : 0), \ + (void)(*(x)[0].ec_bufptr++ = (c))) + +/* Append a cord to an extensible cord. Structure remains shared with */ +/* original. */ +void CORD_ec_append_cord(CORD_ec x, CORD s); + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +#endif /* EC_H */ diff --git a/boehm/gc/gc.h b/boehm/gc/gc.h new file mode 100644 index 0000000..6dc2940 --- /dev/null +++ b/boehm/gc/gc.h @@ -0,0 +1,2151 @@ +/* + * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers + * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. + * Copyright 1996-1999 by Silicon Graphics. All rights reserved. + * Copyright 1999 by Hewlett-Packard Company. All rights reserved. + * Copyright (C) 2007 Free Software Foundation, Inc + * Copyright (c) 2000-2011 by Hewlett-Packard Development Company. + * Copyright (c) 2009-2020 Ivan Maidanski + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +/* + * Note that this defines a large number of tuning hooks, which can + * safely be ignored in nearly all cases. For normal use it suffices + * to call only GC_MALLOC and perhaps GC_REALLOC. + * For better performance, also look at GC_MALLOC_ATOMIC, and + * GC_enable_incremental. If you need an action to be performed + * immediately before an object is collected, look at GC_register_finalizer. + * Everything else is best ignored unless you encounter performance + * problems. + */ + +#ifndef GC_H +#define GC_H + +/* Help debug mixed up preprocessor symbols. */ +#if (defined(WIN64) && !defined(_WIN64)) && defined(_MSC_VER) +#pragma message("Warning: Expecting _WIN64 for x64 targets! Notice the leading underscore!") +#endif + +#include "gc_version.h" + /* Define version numbers here to allow test on build machine */ + /* for cross-builds. Note that this defines the header */ + /* version number, which may or may not match that of the */ + /* dynamic library. GC_get_version() can be used to obtain */ + /* the latter. */ + +#include "gc_config_macros.h" + +#ifdef __cplusplus + extern "C" { +#endif + +typedef void * GC_PTR; /* preserved only for backward compatibility */ + +/* Define word and signed_word to be unsigned and signed types of the */ +/* size as char * or void *. There seems to be no way to do this */ +/* even semi-portably. The following is probably no better/worse */ +/* than almost anything else. */ +/* The ANSI standard suggests that size_t and ptrdiff_t might be */ +/* better choices. But those had incorrect definitions on some older */ +/* systems. Notably "typedef int size_t" is WRONG. */ +#ifdef _WIN64 +# if defined(__int64) && !defined(CPPCHECK) + typedef unsigned __int64 GC_word; + typedef __int64 GC_signed_word; +# else + typedef unsigned long long GC_word; + typedef long long GC_signed_word; +# endif +#else + typedef unsigned long GC_word; + typedef long GC_signed_word; +#endif + +/* Get the GC library version. The returned value is a constant in the */ +/* form: ((version_major<<16) | (version_minor<<8) | version_micro). */ +GC_API unsigned GC_CALL GC_get_version(void); + +/* Public read-only variables */ +/* The supplied getter functions are preferred for new code. */ + +GC_API GC_ATTR_DEPRECATED GC_word GC_gc_no; + /* Counter incremented per collection. */ + /* Includes empty GCs at startup. */ +GC_API GC_word GC_CALL GC_get_gc_no(void); + /* GC_get_gc_no() is unsynchronized, so */ + /* it requires GC_call_with_alloc_lock() to */ + /* avoid data races on multiprocessors. */ + +#ifdef GC_THREADS + GC_API GC_ATTR_DEPRECATED int GC_parallel; + /* GC is parallelized for performance on */ + /* multiprocessors. Set to a non-zero value */ + /* only implicitly if collector is built with */ + /* PARALLEL_MARK defined, and if either */ + /* GC_MARKERS (or GC_NPROCS) environment */ + /* variable is set to > 1, or multiple cores */ + /* (processors) are available, or the client */ + /* calls GC_set_markers_count() before the GC */ + /* initialization. The getter does */ + /* not use or need synchronization (i.e. */ + /* acquiring the GC lock). GC_parallel value */ + /* is equal to the number of marker threads */ + /* minus one (i.e. number of existing parallel */ + /* marker threads excluding the initiating one).*/ + GC_API int GC_CALL GC_get_parallel(void); + + /* Set the number of marker threads (including the initiating one) */ + /* to the desired value at start-up. Zero value means the collector */ + /* is to decide. Has no effect if called after GC initialization. */ + /* If the correct non-zero value is passed, then GC_parallel should */ + /* be set to the value minus one. The function does not use any */ + /* synchronization. */ + GC_API void GC_CALL GC_set_markers_count(unsigned); +#endif + + +/* Public R/W variables */ +/* The supplied setter and getter functions are preferred for new code. */ + +typedef void * (GC_CALLBACK * GC_oom_func)(size_t /* bytes_requested */); +GC_API GC_ATTR_DEPRECATED GC_oom_func GC_oom_fn; + /* When there is insufficient memory to satisfy */ + /* an allocation request, we return */ + /* (*GC_oom_fn)(size). By default this just */ + /* returns NULL. */ + /* If it returns, it must return 0 or a valid */ + /* pointer to a previously allocated heap */ + /* object. GC_oom_fn must not be 0. */ + /* Both the supplied setter and the getter */ + /* acquire the GC lock (to avoid data races). */ +GC_API void GC_CALL GC_set_oom_fn(GC_oom_func) GC_ATTR_NONNULL(1); +GC_API GC_oom_func GC_CALL GC_get_oom_fn(void); + +typedef void (GC_CALLBACK * GC_on_heap_resize_proc)(GC_word /* new_size */); +GC_API GC_ATTR_DEPRECATED GC_on_heap_resize_proc GC_on_heap_resize; + /* Invoked when the heap grows or shrinks. */ + /* Called with the world stopped (and the */ + /* allocation lock held). May be 0. */ +GC_API void GC_CALL GC_set_on_heap_resize(GC_on_heap_resize_proc); +GC_API GC_on_heap_resize_proc GC_CALL GC_get_on_heap_resize(void); + /* Both the supplied setter and the getter */ + /* acquire the GC lock (to avoid data races). */ + +typedef enum { + GC_EVENT_START /* COLLECTION */, + GC_EVENT_MARK_START, + GC_EVENT_MARK_END, + GC_EVENT_RECLAIM_START, + GC_EVENT_RECLAIM_END, + GC_EVENT_END /* COLLECTION */, + GC_EVENT_PRE_STOP_WORLD /* STOPWORLD_BEGIN */, + GC_EVENT_POST_STOP_WORLD /* STOPWORLD_END */, + GC_EVENT_PRE_START_WORLD /* STARTWORLD_BEGIN */, + GC_EVENT_POST_START_WORLD /* STARTWORLD_END */, + GC_EVENT_THREAD_SUSPENDED, + GC_EVENT_THREAD_UNSUSPENDED +} GC_EventType; + +typedef void (GC_CALLBACK * GC_on_collection_event_proc)(GC_EventType); + /* Invoked to indicate progress through the */ + /* collection process. Not used for thread */ + /* suspend/resume notifications. Called with */ + /* the GC lock held (or, even, the world */ + /* stopped). May be 0 (means no notifier). */ +GC_API void GC_CALL GC_set_on_collection_event(GC_on_collection_event_proc); +GC_API GC_on_collection_event_proc GC_CALL GC_get_on_collection_event(void); + /* Both the supplied setter and the getter */ + /* acquire the GC lock (to avoid data races). */ + +#if defined(GC_THREADS) || (defined(GC_BUILD) && defined(NN_PLATFORM_CTR)) + typedef void (GC_CALLBACK * GC_on_thread_event_proc)(GC_EventType, + void * /* thread_id */); + /* Invoked when a thread is suspended or */ + /* resumed during collection. Called with the */ + /* GC lock held (and the world stopped */ + /* partially). May be 0 (means no notifier). */ + GC_API void GC_CALL GC_set_on_thread_event(GC_on_thread_event_proc); + GC_API GC_on_thread_event_proc GC_CALL GC_get_on_thread_event(void); + /* Both the supplied setter and the getter */ + /* acquire the GC lock (to avoid data races). */ +#endif + +GC_API GC_ATTR_DEPRECATED int GC_find_leak; + /* Set to true to turn on the leak-finding mode */ + /* (do not actually garbage collect, but simply */ + /* report inaccessible memory that was not */ + /* deallocated with GC_FREE). Initial value */ + /* is determined by FIND_LEAK macro. */ + /* The value should not typically be modified */ + /* after GC initialization (and, thus, it does */ + /* not use or need synchronization). */ +GC_API void GC_CALL GC_set_find_leak(int); +GC_API int GC_CALL GC_get_find_leak(void); + +GC_API GC_ATTR_DEPRECATED int GC_all_interior_pointers; + /* Arrange for pointers to object interiors to */ + /* be recognized as valid. Typically should */ + /* not be changed after GC initialization (in */ + /* case of calling it after the GC is */ + /* initialized, the setter acquires the GC lock */ + /* (to avoid data races). The initial value */ + /* depends on whether the GC is built with */ + /* ALL_INTERIOR_POINTERS macro defined or not. */ + /* Unless DONT_ADD_BYTE_AT_END is defined, this */ + /* also affects whether sizes are increased by */ + /* at least a byte to allow "off the end" */ + /* pointer recognition. Must be only 0 or 1. */ +GC_API void GC_CALL GC_set_all_interior_pointers(int); +GC_API int GC_CALL GC_get_all_interior_pointers(void); + +GC_API GC_ATTR_DEPRECATED int GC_finalize_on_demand; + /* If nonzero, finalizers will only be run in */ + /* response to an explicit GC_invoke_finalizers */ + /* call. The default is determined by whether */ + /* the FINALIZE_ON_DEMAND macro is defined */ + /* when the collector is built. */ + /* The setter and getter are unsynchronized. */ +GC_API void GC_CALL GC_set_finalize_on_demand(int); +GC_API int GC_CALL GC_get_finalize_on_demand(void); + +GC_API GC_ATTR_DEPRECATED int GC_java_finalization; + /* Mark objects reachable from finalizable */ + /* objects in a separate post-pass. This makes */ + /* it a bit safer to use non-topologically- */ + /* ordered finalization. Default value is */ + /* determined by JAVA_FINALIZATION macro. */ + /* Enables register_finalizer_unreachable to */ + /* work correctly. */ + /* The setter and getter are unsynchronized. */ +GC_API void GC_CALL GC_set_java_finalization(int); +GC_API int GC_CALL GC_get_java_finalization(void); + +typedef void (GC_CALLBACK * GC_finalizer_notifier_proc)(void); +GC_API GC_ATTR_DEPRECATED GC_finalizer_notifier_proc GC_finalizer_notifier; + /* Invoked by the collector when there are */ + /* objects to be finalized. Invoked at most */ + /* once per GC cycle. Never invoked unless */ + /* GC_finalize_on_demand is set. */ + /* Typically this will notify a finalization */ + /* thread, which will call GC_invoke_finalizers */ + /* in response. May be 0 (means no notifier). */ + /* Both the supplied setter and the getter */ + /* acquire the GC lock (to avoid data races). */ +GC_API void GC_CALL GC_set_finalizer_notifier(GC_finalizer_notifier_proc); +GC_API GC_finalizer_notifier_proc GC_CALL GC_get_finalizer_notifier(void); + +GC_API +# ifndef GC_DONT_GC + GC_ATTR_DEPRECATED +# endif + int GC_dont_gc; /* != 0 ==> Do not collect. This overrides */ + /* explicit GC_gcollect() calls as well. */ + /* Used as a counter, so that nested enabling */ + /* and disabling work correctly. Should */ + /* normally be updated with GC_enable() and */ + /* GC_disable() calls. Direct assignment to */ + /* GC_dont_gc is deprecated. To check whether */ + /* GC is disabled, GC_is_disabled() is */ + /* preferred for new code. */ + +GC_API GC_ATTR_DEPRECATED int GC_dont_expand; + /* Do not expand the heap unless explicitly */ + /* requested or forced to. The setter and */ + /* getter are unsynchronized. */ +GC_API void GC_CALL GC_set_dont_expand(int); +GC_API int GC_CALL GC_get_dont_expand(void); + +GC_API GC_ATTR_DEPRECATED int GC_use_entire_heap; + /* Causes the non-incremental collector to use the */ + /* entire heap before collecting. This sometimes */ + /* results in more large block fragmentation, since */ + /* very large blocks will tend to get broken up */ + /* during each GC cycle. It is likely to result in a */ + /* larger working set, but lower collection */ + /* frequencies, and hence fewer instructions executed */ + /* in the collector. */ + +GC_API GC_ATTR_DEPRECATED int GC_full_freq; + /* Number of partial collections between */ + /* full collections. Matters only if */ + /* GC_is_incremental_mode(). */ + /* Full collections are also triggered if */ + /* the collector detects a substantial */ + /* increase in the number of in-use heap */ + /* blocks. Values in the tens are now */ + /* perfectly reasonable, unlike for */ + /* earlier GC versions. */ + /* The setter and getter are unsynchronized, so */ + /* GC_call_with_alloc_lock() is required to */ + /* avoid data races (if the value is modified */ + /* after the GC is put to multi-threaded mode). */ +GC_API void GC_CALL GC_set_full_freq(int); +GC_API int GC_CALL GC_get_full_freq(void); + +GC_API GC_ATTR_DEPRECATED GC_word GC_non_gc_bytes; + /* Bytes not considered candidates for */ + /* collection. Used only to control scheduling */ + /* of collections. Updated by */ + /* GC_malloc_uncollectable and GC_free. */ + /* Wizards only. */ + /* The setter and getter are unsynchronized, so */ + /* GC_call_with_alloc_lock() is required to */ + /* avoid data races (if the value is modified */ + /* after the GC is put to multi-threaded mode). */ +GC_API void GC_CALL GC_set_non_gc_bytes(GC_word); +GC_API GC_word GC_CALL GC_get_non_gc_bytes(void); + +GC_API GC_ATTR_DEPRECATED int GC_no_dls; + /* Don't register dynamic library data segments. */ + /* Wizards only. Should be used only if the */ + /* application explicitly registers all roots. */ + /* (In some environments like Microsoft Windows */ + /* and Apple's Darwin, this may also prevent */ + /* registration of the main data segment as part */ + /* of the root set.) */ + /* The setter and getter are unsynchronized. */ +GC_API void GC_CALL GC_set_no_dls(int); +GC_API int GC_CALL GC_get_no_dls(void); + +GC_API GC_ATTR_DEPRECATED GC_word GC_free_space_divisor; + /* We try to make sure that we allocate at */ + /* least N/GC_free_space_divisor bytes between */ + /* collections, where N is twice the number */ + /* of traced bytes, plus the number of untraced */ + /* bytes (bytes in "atomic" objects), plus */ + /* a rough estimate of the root set size. */ + /* N approximates GC tracing work per GC. */ + /* The initial value is GC_FREE_SPACE_DIVISOR. */ + /* Increasing its value will use less space */ + /* but more collection time. Decreasing it */ + /* will appreciably decrease collection time */ + /* at the expense of space. */ + /* The setter and getter are unsynchronized, so */ + /* GC_call_with_alloc_lock() is required to */ + /* avoid data races (if the value is modified */ + /* after the GC is put to multi-threaded mode). */ + /* In GC v7.1 (and before), the setter returned */ + /* the old value. */ +GC_API void GC_CALL GC_set_free_space_divisor(GC_word); +GC_API GC_word GC_CALL GC_get_free_space_divisor(void); + +GC_API GC_ATTR_DEPRECATED GC_word GC_max_retries; + /* The maximum number of GCs attempted before */ + /* reporting out of memory after heap */ + /* expansion fails. Initially 0. */ + /* The setter and getter are unsynchronized, so */ + /* GC_call_with_alloc_lock() is required to */ + /* avoid data races (if the value is modified */ + /* after the GC is put to multi-threaded mode). */ +GC_API void GC_CALL GC_set_max_retries(GC_word); +GC_API GC_word GC_CALL GC_get_max_retries(void); + + +GC_API GC_ATTR_DEPRECATED char *GC_stackbottom; + /* The cold end (bottom) of user stack. */ + /* May be set in the client prior to */ + /* calling any GC_ routines. This */ + /* avoids some overhead, and */ + /* potentially some signals that can */ + /* confuse debuggers. Otherwise the */ + /* collector attempts to set it */ + /* automatically. */ + /* For multi-threaded code, this is the */ + /* cold end of the stack for the */ + /* primordial thread. Portable clients */ + /* should use GC_get_stack_base(), */ + /* GC_call_with_gc_active() and */ + /* GC_register_my_thread() instead. */ + +GC_API GC_ATTR_DEPRECATED int GC_dont_precollect; + /* Do not collect as part of GC */ + /* initialization. Should be set only */ + /* if the client wants a chance to */ + /* manually initialize the root set */ + /* before the first collection. */ + /* Interferes with blacklisting. */ + /* Wizards only. The setter and getter */ + /* are unsynchronized (and no external */ + /* locking is needed since the value is */ + /* accessed at GC initialization only). */ +GC_API void GC_CALL GC_set_dont_precollect(int); +GC_API int GC_CALL GC_get_dont_precollect(void); + +GC_API GC_ATTR_DEPRECATED unsigned long GC_time_limit; + /* If incremental collection is enabled, */ + /* we try to terminate collections */ + /* after this many milliseconds (plus */ + /* the amount of nanoseconds as given in */ + /* the latest GC_set_time_limit_tv call, */ + /* if any). Not a hard time bound. */ + /* Setting this variable to */ + /* GC_TIME_UNLIMITED will essentially */ + /* disable incremental collection while */ + /* leaving generational collection */ + /* enabled. */ +#define GC_TIME_UNLIMITED 999999 + /* Setting GC_time_limit to this value */ + /* will disable the "pause time exceeded"*/ + /* tests. */ + /* The setter and getter are unsynchronized, so */ + /* GC_call_with_alloc_lock() is required to */ + /* avoid data races (if the value is modified */ + /* after the GC is put to multi-threaded mode). */ + /* The setter does not update the value of the */ + /* nanosecond part of the time limit (it is */ + /* zero unless ever set by GC_set_time_limit_tv */ + /* call). */ +GC_API void GC_CALL GC_set_time_limit(unsigned long); +GC_API unsigned long GC_CALL GC_get_time_limit(void); + +/* A portable type definition of time with a nanosecond precision. */ +struct GC_timeval_s { + unsigned long tv_ms; /* time in milliseconds */ + unsigned long tv_nsec;/* nanoseconds fraction (<1000000) */ +}; + +/* Public procedures */ + +/* Set/get the time limit of the incremental collections. This is */ +/* similar to GC_set_time_limit and GC_get_time_limit but the time is */ +/* provided with the nanosecond precision. The value of tv_nsec part */ +/* should be less than a million. If the value of tv_ms part is */ +/* GC_TIME_UNLIMITED then tv_nsec is ignored. Initially, the value of */ +/* tv_nsec part of the time limit is zero. The functions do not use */ +/* any synchronization. Defined only if the library has been compiled */ +/* without NO_CLOCK. */ +GC_API void GC_CALL GC_set_time_limit_tv(struct GC_timeval_s); +GC_API struct GC_timeval_s GC_CALL GC_get_time_limit_tv(void); + +/* Set/get the minimum value of the ratio of allocated bytes since GC */ +/* to the amount of finalizers created since that GC (value > */ +/* GC_bytes_allocd / (GC_fo_entries - last_fo_entries)) which triggers */ +/* the collection instead heap expansion. The value has no effect in */ +/* the GC incremental mode. The default value is 10000 unless */ +/* GC_ALLOCD_BYTES_PER_FINALIZER macro with a custom value is defined */ +/* to build libgc. The default value might be not the right choice for */ +/* clients where e.g. most objects have a finalizer. Zero value */ +/* effectively disables taking amount of finalizers in the decision */ +/* whether to collect or not. The functions do not use any */ +/* synchronization. */ +GC_API void GC_CALL GC_set_allocd_bytes_per_finalizer(GC_word); +GC_API GC_word GC_CALL GC_get_allocd_bytes_per_finalizer(void); + +/* Tell the collector to start various performance measurements. */ +/* Only the total time taken by full collections is calculated, as */ +/* of now. And, currently, there is no way to stop the measurements. */ +/* The function does not use any synchronization. Defined only if the */ +/* library has been compiled without NO_CLOCK. */ +GC_API void GC_CALL GC_start_performance_measurement(void); + +/* Get the total time of all full collections since the start of the */ +/* performance measurements. The measurement unit is one millisecond. */ +/* Note that the returned value wraps around on overflow. */ +/* The function does not use any synchronization. Defined only if the */ +/* library has been compiled without NO_CLOCK. */ +GC_API unsigned long GC_CALL GC_get_full_gc_total_time(void); + +/* Set whether the GC will allocate executable memory pages or not. */ +/* A non-zero argument instructs the collector to allocate memory with */ +/* the executable flag on. Must be called before the collector is */ +/* initialized. May have no effect on some platforms. The default */ +/* value is controlled by NO_EXECUTE_PERMISSION macro (if present then */ +/* the flag is off). Portable clients should have */ +/* GC_set_pages_executable(1) call (before GC_INIT) provided they are */ +/* going to execute code on any of the GC-allocated memory objects. */ +GC_API void GC_CALL GC_set_pages_executable(int); + +/* Returns non-zero value if the GC is set to the allocate-executable */ +/* mode. The mode could be changed by GC_set_pages_executable (before */ +/* GC_INIT) unless the former has no effect on the platform. Does not */ +/* use or need synchronization (i.e. acquiring the allocator lock). */ +GC_API int GC_CALL GC_get_pages_executable(void); + +/* The setter and getter of the minimum value returned by the internal */ +/* min_bytes_allocd(). The value should not be zero; the default value */ +/* is one. Not synchronized. */ +GC_API void GC_CALL GC_set_min_bytes_allocd(size_t); +GC_API size_t GC_CALL GC_get_min_bytes_allocd(void); + +/* Set/get the size in pages of units operated by GC_collect_a_little. */ +/* The value should not be zero. Not synchronized. */ +GC_API void GC_CALL GC_set_rate(int); +GC_API int GC_CALL GC_get_rate(void); + +/* Set/get the maximum number of prior attempts at the world-stop */ +/* marking. Not synchronized. */ +GC_API void GC_CALL GC_set_max_prior_attempts(int); +GC_API int GC_CALL GC_get_max_prior_attempts(void); + +/* Overrides the default handle-fork mode. Non-zero value means GC */ +/* should install proper pthread_atfork handlers. Has effect only if */ +/* called before GC_INIT. Clients should invoke GC_set_handle_fork */ +/* with non-zero argument if going to use fork with GC functions called */ +/* in the forked child. (Note that such client and atfork handlers */ +/* activities are not fully POSIX-compliant.) GC_set_handle_fork */ +/* instructs GC_init to setup GC fork handlers using pthread_atfork, */ +/* the latter might fail (or, even, absent on some targets) causing */ +/* abort at GC initialization. Issues with missing (or failed) */ +/* pthread_atfork() could be avoided by invocation */ +/* of GC_set_handle_fork(-1) at application start-up and surrounding */ +/* each fork() with the relevant GC_atfork_prepare/parent/child calls. */ +GC_API void GC_CALL GC_set_handle_fork(int); + +/* Routines to handle POSIX fork() manually (no-op if handled */ +/* automatically). GC_atfork_prepare should be called immediately */ +/* before fork(); GC_atfork_parent should be invoked just after fork in */ +/* the branch that corresponds to parent process (i.e., fork result is */ +/* non-zero); GC_atfork_child is to be called immediately in the child */ +/* branch (i.e., fork result is 0). Note that GC_atfork_child() call */ +/* should, of course, precede GC_start_mark_threads call (if any). */ +GC_API void GC_CALL GC_atfork_prepare(void); +GC_API void GC_CALL GC_atfork_parent(void); +GC_API void GC_CALL GC_atfork_child(void); + +/* Initialize the collector. Portable clients should call GC_INIT() */ +/* from the main program instead. */ +GC_API void GC_CALL GC_init(void); + +/* Returns non-zero (TRUE) if and only if the collector is initialized */ +/* (or, at least, the initialization is in progress). */ +GC_API int GC_CALL GC_is_init_called(void); + +/* Perform the collector shutdown. (E.g. dispose critical sections on */ +/* Win32 target.) A duplicate invocation is a no-op. GC_INIT should */ +/* not be called after the shutdown. See also GC_win32_free_heap(). */ +GC_API void GC_CALL GC_deinit(void); + +/* General purpose allocation routines, with roughly malloc calling */ +/* conv. The atomic versions promise that no relevant pointers are */ +/* contained in the object. The non-atomic versions guarantee that the */ +/* new object is cleared. GC_malloc_uncollectable allocates */ +/* an object that is scanned for pointers to collectible */ +/* objects, but is not itself collectible. The object is scanned even */ +/* if it does not appear to be reachable. GC_malloc_uncollectable and */ +/* GC_free called on the resulting object implicitly update */ +/* GC_non_gc_bytes appropriately. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_malloc(size_t /* size_in_bytes */); +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_malloc_atomic(size_t /* size_in_bytes */); +GC_API GC_ATTR_MALLOC char * GC_CALL GC_strdup(const char *); +GC_API GC_ATTR_MALLOC char * GC_CALL + GC_strndup(const char *, size_t) GC_ATTR_NONNULL(1); +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_malloc_uncollectable(size_t /* size_in_bytes */); +GC_API GC_ATTR_DEPRECATED void * GC_CALL GC_malloc_stubborn(size_t); + +/* GC_memalign() is not well tested. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(2) void * GC_CALL + GC_memalign(size_t /* align */, size_t /* lb */); +GC_API int GC_CALL GC_posix_memalign(void ** /* memptr */, size_t /* align */, + size_t /* lb */) GC_ATTR_NONNULL(1); + +/* Explicitly deallocate an object. Dangerous if used incorrectly. */ +/* Requires a pointer to the base of an object. */ +/* An object should not be enabled for finalization (and it should not */ +/* contain registered disappearing links of any kind) when it is */ +/* explicitly deallocated. */ +/* GC_free(0) is a no-op, as required by ANSI C for free. */ +GC_API void GC_CALL GC_free(void *); + +/* The "stubborn" objects allocation is not supported anymore. Exists */ +/* only for the backward compatibility. */ +#define GC_MALLOC_STUBBORN(sz) GC_MALLOC(sz) +#define GC_NEW_STUBBORN(t) GC_NEW(t) +#define GC_CHANGE_STUBBORN(p) GC_change_stubborn(p) +GC_API GC_ATTR_DEPRECATED void GC_CALL GC_change_stubborn(const void *); + +/* Inform the collector that the object has been changed. */ +/* Only non-NULL pointer stores into the object are considered to be */ +/* changes. Matters only if the incremental collection is enabled in */ +/* the manual VDB mode (otherwise the function does nothing). */ +/* Should be followed typically by GC_reachable_here called for each */ +/* of the stored pointers. */ +GC_API void GC_CALL GC_end_stubborn_change(const void *) GC_ATTR_NONNULL(1); + +/* Return a pointer to the base (lowest address) of an object given */ +/* a pointer to a location within the object. */ +/* I.e., map an interior pointer to the corresponding base pointer. */ +/* Note that with debugging allocation, this returns a pointer to the */ +/* actual base of the object, i.e. the debug information, not to */ +/* the base of the user object. */ +/* Return 0 if displaced_pointer doesn't point to within a valid */ +/* object. */ +/* Note that a deallocated object in the garbage collected heap */ +/* may be considered valid, even if it has been deallocated with */ +/* GC_free. */ +GC_API void * GC_CALL GC_base(void * /* displaced_pointer */); + +/* Return non-zero (TRUE) if and only if the argument points to */ +/* somewhere in GC heap. Primary use is as a fast alternative to */ +/* GC_base to check whether the pointed object is allocated by GC */ +/* or not. It is assumed that the collector is already initialized. */ +GC_API int GC_CALL GC_is_heap_ptr(const void *); + +/* Given a pointer to the base of an object, return its size in bytes. */ +/* The returned size may be slightly larger than what was originally */ +/* requested. */ +GC_API size_t GC_CALL GC_size(const void * /* obj_addr */) GC_ATTR_NONNULL(1); + +/* For compatibility with C library. This is occasionally faster than */ +/* a malloc followed by a bcopy. But if you rely on that, either here */ +/* or with the standard C library, your code is broken. In my */ +/* opinion, it shouldn't have been invented, but now we're stuck. -HB */ +/* The resulting object has the same kind as the original. */ +/* It is an error to have changes enabled for the original object. */ +/* It does not change the content of the object from its beginning to */ +/* the minimum of old size and new_size_in_bytes; the content above in */ +/* case of object size growth is initialized to zero (not guaranteed */ +/* for atomic object type). The function follows ANSI conventions for */ +/* NULL old_object (i.e., equivalent to GC_malloc regardless of new */ +/* size). If new size is zero (and old_object is non-NULL) then the */ +/* call is equivalent to GC_free (and NULL is returned). If old_object */ +/* is non-NULL, it must have been returned by an earlier call to */ +/* GC_malloc* or GC_realloc. In case of the allocation failure, the */ +/* memory pointed by old_object is untouched (and not freed). */ +/* If the returned pointer is not the same as old_object and both of */ +/* them are non-NULL then old_object is freed. Returns either NULL (in */ +/* case of the allocation failure or zero new size) or pointer to the */ +/* allocated memory. */ +GC_API void * GC_CALL GC_realloc(void * /* old_object */, + size_t /* new_size_in_bytes */) + /* 'realloc' attr */ GC_ATTR_ALLOC_SIZE(2); + +/* Explicitly increase the heap size. */ +/* Returns 0 on failure, 1 on success. */ +GC_API int GC_CALL GC_expand_hp(size_t /* number_of_bytes */); + +/* Limit the heap size to n bytes. Useful when you're debugging, */ +/* especially on systems that don't handle running out of memory well. */ +/* n == 0 ==> unbounded. This is the default. This setter function is */ +/* unsynchronized (so it might require GC_call_with_alloc_lock to avoid */ +/* data races). */ +GC_API void GC_CALL GC_set_max_heap_size(GC_word /* n */); + +/* Inform the collector that a certain section of statically allocated */ +/* memory contains no pointers to garbage collected memory. Thus it */ +/* need not be scanned. This is sometimes important if the application */ +/* maps large read/write files into the address space, which could be */ +/* mistaken for dynamic library data segments on some systems. */ +/* Both section start and end are not needed to be pointer-aligned. */ +GC_API void GC_CALL GC_exclude_static_roots(void * /* low_address */, + void * /* high_address_plus_1 */); + +/* Clear the number of entries in the exclusion table. Wizards only. */ +GC_API void GC_CALL GC_clear_exclusion_table(void); + +/* Clear the set of root segments. Wizards only. */ +GC_API void GC_CALL GC_clear_roots(void); + +/* Add a root segment. Wizards only. */ +/* Both segment start and end are not needed to be pointer-aligned. */ +/* low_address must not be greater than high_address_plus_1. */ +GC_API void GC_CALL GC_add_roots(void * /* low_address */, + void * /* high_address_plus_1 */); + +/* Remove a root segment. Wizards only. */ +/* May be unimplemented on some platforms. */ +GC_API void GC_CALL GC_remove_roots(void * /* low_address */, + void * /* high_address_plus_1 */); + +/* Add a displacement to the set of those considered valid by the */ +/* collector. GC_register_displacement(n) means that if p was returned */ +/* by GC_malloc, then (char *)p + n will be considered to be a valid */ +/* pointer to p. N must be small and less than the size of p. */ +/* (All pointers to the interior of objects from the stack are */ +/* considered valid in any case. This applies to heap objects and */ +/* static data.) */ +/* Preferably, this should be called before any other GC procedures. */ +/* Calling it later adds to the probability of excess memory */ +/* retention. */ +/* This is a no-op if the collector has recognition of */ +/* arbitrary interior pointers enabled, which is now the default. */ +GC_API void GC_CALL GC_register_displacement(size_t /* n */); + +/* The following version should be used if any debugging allocation is */ +/* being done. */ +GC_API void GC_CALL GC_debug_register_displacement(size_t /* n */); + +/* Explicitly trigger a full, world-stop collection. */ +GC_API void GC_CALL GC_gcollect(void); + +/* Same as above but ignores the default stop_func setting and tries to */ +/* unmap as much memory as possible (regardless of the corresponding */ +/* switch setting). The recommended usage: on receiving a system */ +/* low-memory event; before retrying a system call failed because of */ +/* the system is running out of resources. */ +GC_API void GC_CALL GC_gcollect_and_unmap(void); + +/* Trigger a full world-stopped collection. Abort the collection if */ +/* and when stop_func returns a nonzero value. Stop_func will be */ +/* called frequently, and should be reasonably fast. (stop_func is */ +/* called with the allocation lock held and the world might be stopped; */ +/* it's not allowed for stop_func to manipulate pointers to the garbage */ +/* collected heap or call most of GC functions.) This works even */ +/* if virtual dirty bits, and hence incremental collection is not */ +/* available for this architecture. Collections can be aborted faster */ +/* than normal pause times for incremental collection. However, */ +/* aborted collections do no useful work; the next collection needs */ +/* to start from the beginning. stop_func must not be 0. */ +/* GC_try_to_collect() returns 0 if the collection was aborted (or the */ +/* collections are disabled), 1 if it succeeded. */ +typedef int (GC_CALLBACK * GC_stop_func)(void); +GC_API int GC_CALL GC_try_to_collect(GC_stop_func /* stop_func */) + GC_ATTR_NONNULL(1); + +/* Set and get the default stop_func. The default stop_func is used by */ +/* GC_gcollect() and by implicitly trigged collections (except for the */ +/* case when handling out of memory). Must not be 0. */ +/* Both the setter and getter acquire the GC lock to avoid data races. */ +GC_API void GC_CALL GC_set_stop_func(GC_stop_func /* stop_func */) + GC_ATTR_NONNULL(1); +GC_API GC_stop_func GC_CALL GC_get_stop_func(void); + +/* Return the number of bytes in the heap. Excludes collector private */ +/* data structures. Excludes the unmapped memory (returned to the OS). */ +/* Includes empty blocks and fragmentation loss. Includes some pages */ +/* that were allocated but never written. */ +/* This is an unsynchronized getter, so it should be called typically */ +/* with the GC lock held to avoid data races on multiprocessors (the */ +/* alternative is to use GC_get_heap_usage_safe or GC_get_prof_stats */ +/* API calls instead). */ +/* This getter remains lock-free (unsynchronized) for compatibility */ +/* reason since some existing clients call it from a GC callback */ +/* holding the allocator lock. (This API function and the following */ +/* four ones below were made thread-safe in GC v7.2alpha1 and */ +/* reverted back in v7.2alpha7 for the reason described.) */ +GC_API size_t GC_CALL GC_get_heap_size(void); + +/* Return a lower bound on the number of free bytes in the heap */ +/* (excluding the unmapped memory space). This is an unsynchronized */ +/* getter (see GC_get_heap_size comment regarding thread-safety). */ +GC_API size_t GC_CALL GC_get_free_bytes(void); + +/* Return the size (in bytes) of the unmapped memory (which is returned */ +/* to the OS but could be remapped back by the collector later unless */ +/* the OS runs out of system/virtual memory). This is an unsynchronized */ +/* getter (see GC_get_heap_size comment regarding thread-safety). */ +GC_API size_t GC_CALL GC_get_unmapped_bytes(void); + +/* Return the number of bytes allocated since the last collection. */ +/* This is an unsynchronized getter (see GC_get_heap_size comment */ +/* regarding thread-safety). */ +GC_API size_t GC_CALL GC_get_bytes_since_gc(void); + +/* Return the number of explicitly deallocated bytes of memory since */ +/* the recent collection. This is an unsynchronized getter. */ +GC_API size_t GC_CALL GC_get_expl_freed_bytes_since_gc(void); + +/* Return the total number of bytes allocated in this process. */ +/* Never decreases, except due to wrapping. This is an unsynchronized */ +/* getter (see GC_get_heap_size comment regarding thread-safety). */ +GC_API size_t GC_CALL GC_get_total_bytes(void); + +/* Return the heap usage information. This is a thread-safe (atomic) */ +/* alternative for the five above getters. (This function acquires */ +/* the allocator lock thus preventing data racing and returning the */ +/* consistent result.) Passing NULL pointer is allowed for any */ +/* argument. Returned (filled in) values are of word type. */ +GC_API void GC_CALL GC_get_heap_usage_safe(GC_word * /* pheap_size */, + GC_word * /* pfree_bytes */, + GC_word * /* punmapped_bytes */, + GC_word * /* pbytes_since_gc */, + GC_word * /* ptotal_bytes */); + +/* Structure used to query GC statistics (profiling information). */ +/* More fields could be added in the future. To preserve compatibility */ +/* new fields should be added only to the end, and no deprecated fields */ +/* should be removed from. */ +struct GC_prof_stats_s { + GC_word heapsize_full; + /* Heap size in bytes (including the area unmapped to OS). */ + /* Same as GC_get_heap_size() + GC_get_unmapped_bytes(). */ + GC_word free_bytes_full; + /* Total bytes contained in free and unmapped blocks. */ + /* Same as GC_get_free_bytes() + GC_get_unmapped_bytes(). */ + GC_word unmapped_bytes; + /* Amount of memory unmapped to OS. Same as the value */ + /* returned by GC_get_unmapped_bytes(). */ + GC_word bytes_allocd_since_gc; + /* Number of bytes allocated since the recent collection. */ + /* Same as returned by GC_get_bytes_since_gc(). */ + GC_word allocd_bytes_before_gc; + /* Number of bytes allocated before the recent garbage */ + /* collection. The value may wrap. Same as the result of */ + /* GC_get_total_bytes() - GC_get_bytes_since_gc(). */ + GC_word non_gc_bytes; + /* Number of bytes not considered candidates for garbage */ + /* collection. Same as returned by GC_get_non_gc_bytes(). */ + GC_word gc_no; + /* Garbage collection cycle number. The value may wrap */ + /* (and could be -1). Same as returned by GC_get_gc_no(). */ + GC_word markers_m1; + /* Number of marker threads (excluding the initiating one). */ + /* Same as returned by GC_get_parallel (or 0 if the */ + /* collector is single-threaded). */ + GC_word bytes_reclaimed_since_gc; + /* Approximate number of reclaimed bytes after recent GC. */ + GC_word reclaimed_bytes_before_gc; + /* Approximate number of bytes reclaimed before the recent */ + /* garbage collection. The value may wrap. */ + GC_word expl_freed_bytes_since_gc; + /* Number of bytes freed explicitly since the recent GC. */ + /* Same as returned by GC_get_expl_freed_bytes_since_gc(). */ +}; + +/* Atomically get GC statistics (various global counters). Clients */ +/* should pass the size of the buffer (of GC_prof_stats_s type) to fill */ +/* in the values - this is for interoperability between different GC */ +/* versions, an old client could have fewer fields, and vice versa, */ +/* client could use newer gc.h (with more entries declared in the */ +/* structure) than that of the linked libgc binary; in the latter case, */ +/* unsupported (unknown) fields are filled in with -1. Return the size */ +/* (in bytes) of the filled in part of the structure (excluding all */ +/* unknown fields, if any). */ +GC_API size_t GC_CALL GC_get_prof_stats(struct GC_prof_stats_s *, + size_t /* stats_sz */); +#ifdef GC_THREADS + /* Same as above but unsynchronized (i.e., not holding the allocation */ + /* lock). Clients should call it using GC_call_with_alloc_lock to */ + /* avoid data races on multiprocessors. */ + GC_API size_t GC_CALL GC_get_prof_stats_unsafe(struct GC_prof_stats_s *, + size_t /* stats_sz */); +#endif + +/* Get the element value (converted to bytes) at a given index of */ +/* size_map table which provides requested-to-actual allocation size */ +/* mapping. Assumes the collector is initialized. Returns -1 if the */ +/* index is out of size_map table bounds. Does not use synchronization, */ +/* thus clients should call it using GC_call_with_alloc_lock typically */ +/* to avoid data races on multiprocessors. */ +GC_API size_t GC_CALL GC_get_size_map_at(int i); + +/* Count total memory use in bytes by all allocated blocks. Acquires */ +/* the lock. */ +GC_API size_t GC_CALL GC_get_memory_use(void); + +/* Disable garbage collection. Even GC_gcollect calls will be */ +/* ineffective. */ +GC_API void GC_CALL GC_disable(void); + +/* Return non-zero (TRUE) if and only if garbage collection is disabled */ +/* (i.e., GC_dont_gc value is non-zero). Does not acquire the lock. */ +GC_API int GC_CALL GC_is_disabled(void); + +/* Try to re-enable garbage collection. GC_disable() and GC_enable() */ +/* calls nest. Garbage collection is enabled if the number of calls to */ +/* both functions is equal. */ +GC_API void GC_CALL GC_enable(void); + +/* Select whether to use the manual VDB mode for the incremental */ +/* collection. Has no effect if called after enabling the incremental */ +/* collection. The default value is off unless the collector is */ +/* compiled with MANUAL_VDB defined. The manual VDB mode should be */ +/* used only if the client has the appropriate GC_END_STUBBORN_CHANGE */ +/* and GC_reachable_here (or, alternatively, GC_PTR_STORE_AND_DIRTY) */ +/* calls (to ensure proper write barriers). Both the setter and getter */ +/* are not synchronized, and are defined only if the library has been */ +/* compiled without SMALL_CONFIG. */ +GC_API void GC_CALL GC_set_manual_vdb_allowed(int); +GC_API int GC_CALL GC_get_manual_vdb_allowed(void); + +/* Enable incremental/generational collection. Not advisable unless */ +/* dirty bits are available or most heap objects are pointer-free */ +/* (atomic) or immutable. Don't use in leak finding mode. Ignored if */ +/* GC_dont_gc is non-zero. Only the generational piece of this is */ +/* functional if GC_time_limit is set to GC_TIME_UNLIMITED. Causes */ +/* thread-local variant of GC_gcj_malloc() to revert to locked */ +/* allocation. Must be called before any such GC_gcj_malloc() calls. */ +/* For best performance, should be called as early as possible. */ +/* On some platforms, calling it later may have adverse effects. */ +/* Safe to call before GC_INIT(). Includes a GC_init() call. */ +GC_API void GC_CALL GC_enable_incremental(void); + +/* Return non-zero (TRUE) if and only if the incremental mode is on. */ +/* Does not acquire the lock. */ +GC_API int GC_CALL GC_is_incremental_mode(void); + +/* Does incremental mode write-protect pages? Returns zero or */ +/* more of the following, or'ed together: */ +#define GC_PROTECTS_POINTER_HEAP 1 /* May protect non-atomic objects. */ +#define GC_PROTECTS_PTRFREE_HEAP 2 +#define GC_PROTECTS_STATIC_DATA 4 /* Currently never. */ +#define GC_PROTECTS_STACK 8 /* Probably impractical. */ + +#define GC_PROTECTS_NONE 0 +/* The collector is assumed to be initialized before this call. */ +GC_API int GC_CALL GC_incremental_protection_needs(void); + +/* Perform some garbage collection work, if appropriate. */ +/* Return 0 if there is no more work to be done (including the */ +/* case when garbage collection is not appropriate). */ +/* Typically performs an amount of work corresponding roughly */ +/* to marking from one page. May do more work if further */ +/* progress requires it, e.g. if incremental collection is */ +/* disabled. It is reasonable to call this in a wait loop */ +/* until it returns 0. */ +GC_API int GC_CALL GC_collect_a_little(void); + +/* Allocate an object of size lb bytes. The client guarantees that */ +/* as long as the object is live, it will be referenced by a pointer */ +/* that points to somewhere within the first 256 bytes of the object. */ +/* (This should normally be declared volatile to prevent the compiler */ +/* from invalidating this assertion.) This routine is only useful */ +/* if a large array is being allocated. It reduces the chance of */ +/* accidentally retaining such an array as a result of scanning an */ +/* integer that happens to be an address inside the array. (Actually, */ +/* it reduces the chance of the allocator not finding space for such */ +/* an array, since it will try hard to avoid introducing such a false */ +/* reference.) On a SunOS 4.X or MS Windows system this is recommended */ +/* for arrays likely to be larger than 100 KB or so. For other systems,*/ +/* or if the collector is not configured to recognize all interior */ +/* pointers, the threshold is normally much higher. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_malloc_ignore_off_page(size_t /* lb */); +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_malloc_atomic_ignore_off_page(size_t /* lb */); + +#ifdef GC_ADD_CALLER +# define GC_EXTRAS GC_RETURN_ADDR, __FILE__, __LINE__ +# define GC_EXTRA_PARAMS GC_word ra, const char * s, int i +#else +# define GC_EXTRAS __FILE__, __LINE__ +# define GC_EXTRA_PARAMS const char * s, int i +#endif + +/* The following is only defined if the library has been suitably */ +/* compiled: */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_malloc_atomic_uncollectable(size_t /* size_in_bytes */); +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_debug_malloc_atomic_uncollectable(size_t, GC_EXTRA_PARAMS); + +/* Debugging (annotated) allocation. GC_gcollect will check */ +/* objects allocated in this way for overwrites, etc. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_debug_malloc(size_t /* size_in_bytes */, GC_EXTRA_PARAMS); +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_debug_malloc_atomic(size_t /* size_in_bytes */, GC_EXTRA_PARAMS); +GC_API GC_ATTR_MALLOC char * GC_CALL + GC_debug_strdup(const char *, GC_EXTRA_PARAMS); +GC_API GC_ATTR_MALLOC char * GC_CALL + GC_debug_strndup(const char *, size_t, GC_EXTRA_PARAMS) + GC_ATTR_NONNULL(1); +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_debug_malloc_uncollectable(size_t /* size_in_bytes */, + GC_EXTRA_PARAMS); +GC_API GC_ATTR_DEPRECATED void * GC_CALL + GC_debug_malloc_stubborn(size_t /* size_in_bytes */, GC_EXTRA_PARAMS); +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_debug_malloc_ignore_off_page(size_t /* size_in_bytes */, + GC_EXTRA_PARAMS); +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_debug_malloc_atomic_ignore_off_page(size_t /* size_in_bytes */, + GC_EXTRA_PARAMS); +GC_API void GC_CALL GC_debug_free(void *); +GC_API void * GC_CALL GC_debug_realloc(void * /* old_object */, + size_t /* new_size_in_bytes */, GC_EXTRA_PARAMS) + /* 'realloc' attr */ GC_ATTR_ALLOC_SIZE(2); +GC_API GC_ATTR_DEPRECATED void GC_CALL GC_debug_change_stubborn(const void *); +GC_API void GC_CALL GC_debug_end_stubborn_change(const void *) + GC_ATTR_NONNULL(1); + +/* Routines that allocate objects with debug information (like the */ +/* above), but just fill in dummy file and line number information. */ +/* Thus they can serve as drop-in malloc/realloc replacements. This */ +/* can be useful for two reasons: */ +/* 1) It allows the collector to be built with DBG_HDRS_ALL defined */ +/* even if some allocation calls come from 3rd party libraries */ +/* that can't be recompiled. */ +/* 2) On some platforms, the file and line information is redundant, */ +/* since it can be reconstructed from a stack trace. On such */ +/* platforms it may be more convenient not to recompile, e.g. for */ +/* leak detection. This can be accomplished by instructing the */ +/* linker to replace malloc/realloc with these. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_debug_malloc_replacement(size_t /* size_in_bytes */); +GC_API /* 'realloc' attr */ GC_ATTR_ALLOC_SIZE(2) void * GC_CALL + GC_debug_realloc_replacement(void * /* object_addr */, + size_t /* size_in_bytes */); + +#ifdef GC_DEBUG_REPLACEMENT +# define GC_MALLOC(sz) GC_debug_malloc_replacement(sz) +# define GC_REALLOC(old, sz) GC_debug_realloc_replacement(old, sz) +#elif defined(GC_DEBUG) +# define GC_MALLOC(sz) GC_debug_malloc(sz, GC_EXTRAS) +# define GC_REALLOC(old, sz) GC_debug_realloc(old, sz, GC_EXTRAS) +#else +# define GC_MALLOC(sz) GC_malloc(sz) +# define GC_REALLOC(old, sz) GC_realloc(old, sz) +#endif /* !GC_DEBUG_REPLACEMENT && !GC_DEBUG */ + +#ifdef GC_DEBUG +# define GC_MALLOC_ATOMIC(sz) GC_debug_malloc_atomic(sz, GC_EXTRAS) +# define GC_STRDUP(s) GC_debug_strdup(s, GC_EXTRAS) +# define GC_STRNDUP(s, sz) GC_debug_strndup(s, sz, GC_EXTRAS) +# define GC_MALLOC_ATOMIC_UNCOLLECTABLE(sz) \ + GC_debug_malloc_atomic_uncollectable(sz, GC_EXTRAS) +# define GC_MALLOC_UNCOLLECTABLE(sz) \ + GC_debug_malloc_uncollectable(sz, GC_EXTRAS) +# define GC_MALLOC_IGNORE_OFF_PAGE(sz) \ + GC_debug_malloc_ignore_off_page(sz, GC_EXTRAS) +# define GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE(sz) \ + GC_debug_malloc_atomic_ignore_off_page(sz, GC_EXTRAS) +# define GC_FREE(p) GC_debug_free(p) +# define GC_REGISTER_FINALIZER(p, f, d, of, od) \ + GC_debug_register_finalizer(p, f, d, of, od) +# define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \ + GC_debug_register_finalizer_ignore_self(p, f, d, of, od) +# define GC_REGISTER_FINALIZER_NO_ORDER(p, f, d, of, od) \ + GC_debug_register_finalizer_no_order(p, f, d, of, od) +# define GC_REGISTER_FINALIZER_UNREACHABLE(p, f, d, of, od) \ + GC_debug_register_finalizer_unreachable(p, f, d, of, od) +# define GC_END_STUBBORN_CHANGE(p) GC_debug_end_stubborn_change(p) +# define GC_PTR_STORE_AND_DIRTY(p, q) GC_debug_ptr_store_and_dirty(p, q) +# define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \ + GC_general_register_disappearing_link(link, \ + GC_base((/* no const */ void *)(obj))) +# define GC_REGISTER_LONG_LINK(link, obj) \ + GC_register_long_link(link, GC_base((/* no const */ void *)(obj))) +# define GC_REGISTER_DISPLACEMENT(n) GC_debug_register_displacement(n) +#else +# define GC_MALLOC_ATOMIC(sz) GC_malloc_atomic(sz) +# define GC_STRDUP(s) GC_strdup(s) +# define GC_STRNDUP(s, sz) GC_strndup(s, sz) +# define GC_MALLOC_ATOMIC_UNCOLLECTABLE(sz) GC_malloc_atomic_uncollectable(sz) +# define GC_MALLOC_UNCOLLECTABLE(sz) GC_malloc_uncollectable(sz) +# define GC_MALLOC_IGNORE_OFF_PAGE(sz) \ + GC_malloc_ignore_off_page(sz) +# define GC_MALLOC_ATOMIC_IGNORE_OFF_PAGE(sz) \ + GC_malloc_atomic_ignore_off_page(sz) +# define GC_FREE(p) GC_free(p) +# define GC_REGISTER_FINALIZER(p, f, d, of, od) \ + GC_register_finalizer(p, f, d, of, od) +# define GC_REGISTER_FINALIZER_IGNORE_SELF(p, f, d, of, od) \ + GC_register_finalizer_ignore_self(p, f, d, of, od) +# define GC_REGISTER_FINALIZER_NO_ORDER(p, f, d, of, od) \ + GC_register_finalizer_no_order(p, f, d, of, od) +# define GC_REGISTER_FINALIZER_UNREACHABLE(p, f, d, of, od) \ + GC_register_finalizer_unreachable(p, f, d, of, od) +# define GC_END_STUBBORN_CHANGE(p) GC_end_stubborn_change(p) +# define GC_PTR_STORE_AND_DIRTY(p, q) GC_ptr_store_and_dirty(p, q) +# define GC_GENERAL_REGISTER_DISAPPEARING_LINK(link, obj) \ + GC_general_register_disappearing_link(link, obj) +# define GC_REGISTER_LONG_LINK(link, obj) \ + GC_register_long_link(link, obj) +# define GC_REGISTER_DISPLACEMENT(n) GC_register_displacement(n) +#endif /* !GC_DEBUG */ + +/* The following are included because they are often convenient, and */ +/* reduce the chance for a misspecified size argument. But calls may */ +/* expand to something syntactically incorrect if t is a complicated */ +/* type expression. Note that, unlike C++ new operator, these ones */ +/* may return NULL (if out of memory). */ +#define GC_NEW(t) ((t*)GC_MALLOC(sizeof(t))) +#define GC_NEW_ATOMIC(t) ((t*)GC_MALLOC_ATOMIC(sizeof(t))) +#define GC_NEW_UNCOLLECTABLE(t) ((t*)GC_MALLOC_UNCOLLECTABLE(sizeof(t))) + +#ifdef GC_REQUIRE_WCSDUP + /* This might be unavailable on some targets (or not needed). */ + /* wchar_t should be defined in stddef.h */ + GC_API GC_ATTR_MALLOC wchar_t * GC_CALL + GC_wcsdup(const wchar_t *) GC_ATTR_NONNULL(1); + GC_API GC_ATTR_MALLOC wchar_t * GC_CALL + GC_debug_wcsdup(const wchar_t *, GC_EXTRA_PARAMS) GC_ATTR_NONNULL(1); +# ifdef GC_DEBUG +# define GC_WCSDUP(s) GC_debug_wcsdup(s, GC_EXTRAS) +# else +# define GC_WCSDUP(s) GC_wcsdup(s) +# endif +#endif /* GC_REQUIRE_WCSDUP */ + +/* Finalization. Some of these primitives are grossly unsafe. */ +/* The idea is to make them both cheap, and sufficient to build */ +/* a safer layer, closer to Modula-3, Java, or PCedar finalization. */ +/* The interface represents my conclusions from a long discussion */ +/* with Alan Demers, Dan Greene, Carl Hauser, Barry Hayes, */ +/* Christian Jacobi, and Russ Atkinson. It's not perfect, and */ +/* probably nobody else agrees with it. Hans-J. Boehm 3/13/92 */ +typedef void (GC_CALLBACK * GC_finalization_proc)(void * /* obj */, + void * /* client_data */); + +GC_API void GC_CALL GC_register_finalizer(void * /* obj */, + GC_finalization_proc /* fn */, void * /* cd */, + GC_finalization_proc * /* ofn */, void ** /* ocd */) + GC_ATTR_NONNULL(1); +GC_API void GC_CALL GC_debug_register_finalizer(void * /* obj */, + GC_finalization_proc /* fn */, void * /* cd */, + GC_finalization_proc * /* ofn */, void ** /* ocd */) + GC_ATTR_NONNULL(1); + /* When obj is no longer accessible, invoke */ + /* (*fn)(obj, cd). If a and b are inaccessible, and */ + /* a points to b (after disappearing links have been */ + /* made to disappear), then only a will be */ + /* finalized. (If this does not create any new */ + /* pointers to b, then b will be finalized after the */ + /* next collection.) Any finalizable object that */ + /* is reachable from itself by following one or more */ + /* pointers will not be finalized (or collected). */ + /* Thus cycles involving finalizable objects should */ + /* be avoided, or broken by disappearing links. */ + /* All but the last finalizer registered for an object */ + /* is ignored. */ + /* No-op in the leak-finding mode. */ + /* Finalization may be removed by passing 0 as fn. */ + /* Finalizers are implicitly unregistered when they are */ + /* enqueued for finalization (i.e. become ready to be */ + /* finalized). */ + /* The old finalizer and client data are stored in */ + /* *ofn and *ocd. (ofn and/or ocd may be NULL. */ + /* The allocation lock is held while *ofn and *ocd are */ + /* updated. In case of error (no memory to register */ + /* new finalizer), *ofn and *ocd remain unchanged.) */ + /* Fn is never invoked on an accessible object, */ + /* provided hidden pointers are converted to real */ + /* pointers only if the allocation lock is held, and */ + /* such conversions are not performed by finalization */ + /* routines. */ + /* If GC_register_finalizer is aborted as a result of */ + /* a signal, the object may be left with no */ + /* finalization, even if neither the old nor new */ + /* finalizer were NULL. */ + /* Obj should be the starting address of an object */ + /* allocated by GC_malloc or friends. Obj may also be */ + /* NULL or point to something outside GC heap (in this */ + /* case, fn is ignored, *ofn and *ocd are set to NULL). */ + /* Note that any garbage collectible object referenced */ + /* by cd will be considered accessible until the */ + /* finalizer is invoked. */ + +/* Another versions of the above follow. It ignores */ +/* self-cycles, i.e. pointers from a finalizable object to */ +/* itself. There is a stylistic argument that this is wrong, */ +/* but it's unavoidable for C++, since the compiler may */ +/* silently introduce these. It's also benign in that specific */ +/* case. And it helps if finalizable objects are split to */ +/* avoid cycles. */ +/* Note that cd will still be viewed as accessible, even if it */ +/* refers to the object itself. */ +GC_API void GC_CALL GC_register_finalizer_ignore_self(void * /* obj */, + GC_finalization_proc /* fn */, void * /* cd */, + GC_finalization_proc * /* ofn */, void ** /* ocd */) + GC_ATTR_NONNULL(1); +GC_API void GC_CALL GC_debug_register_finalizer_ignore_self(void * /* obj */, + GC_finalization_proc /* fn */, void * /* cd */, + GC_finalization_proc * /* ofn */, void ** /* ocd */) + GC_ATTR_NONNULL(1); + +/* Another version of the above. It ignores all cycles. */ +/* It should probably only be used by Java implementations. */ +/* Note that cd will still be viewed as accessible, even if it */ +/* refers to the object itself. */ +GC_API void GC_CALL GC_register_finalizer_no_order(void * /* obj */, + GC_finalization_proc /* fn */, void * /* cd */, + GC_finalization_proc * /* ofn */, void ** /* ocd */) + GC_ATTR_NONNULL(1); +GC_API void GC_CALL GC_debug_register_finalizer_no_order(void * /* obj */, + GC_finalization_proc /* fn */, void * /* cd */, + GC_finalization_proc * /* ofn */, void ** /* ocd */) + GC_ATTR_NONNULL(1); + +/* This is a special finalizer that is useful when an object's */ +/* finalizer must be run when the object is known to be no */ +/* longer reachable, not even from other finalizable objects. */ +/* It behaves like "normal" finalization, except that the */ +/* finalizer is not run while the object is reachable from */ +/* other objects specifying unordered finalization. */ +/* Effectively it allows an object referenced, possibly */ +/* indirectly, from an unordered finalizable object to override */ +/* the unordered finalization request. */ +/* This can be used in combination with finalizer_no_order so */ +/* as to release resources that must not be released while an */ +/* object can still be brought back to life by other */ +/* finalizers. */ +/* Only works if GC_java_finalization is set. Probably only */ +/* of interest when implementing a language that requires */ +/* unordered finalization (e.g. Java, C#). */ +GC_API void GC_CALL GC_register_finalizer_unreachable(void * /* obj */, + GC_finalization_proc /* fn */, void * /* cd */, + GC_finalization_proc * /* ofn */, void ** /* ocd */) + GC_ATTR_NONNULL(1); +GC_API void GC_CALL GC_debug_register_finalizer_unreachable(void * /* obj */, + GC_finalization_proc /* fn */, void * /* cd */, + GC_finalization_proc * /* ofn */, void ** /* ocd */) + GC_ATTR_NONNULL(1); + +#define GC_NO_MEMORY 2 /* Failure due to lack of memory. */ + +/* The following routine may be used to break cycles between */ +/* finalizable objects, thus causing cyclic finalizable */ +/* objects to be finalized in the correct order. Standard */ +/* use involves calling GC_register_disappearing_link(&p), */ +/* where p is a pointer that is not followed by finalization */ +/* code, and should not be considered in determining */ +/* finalization order. */ +GC_API int GC_CALL GC_register_disappearing_link(void ** /* link */) + GC_ATTR_NONNULL(1); + /* Link should point to a field of a heap allocated */ + /* object obj. *link will be cleared when obj is */ + /* found to be inaccessible. This happens BEFORE any */ + /* finalization code is invoked, and BEFORE any */ + /* decisions about finalization order are made. */ + /* This is useful in telling the finalizer that */ + /* some pointers are not essential for proper */ + /* finalization. This may avoid finalization cycles. */ + /* Note that obj may be resurrected by another */ + /* finalizer, and thus the clearing of *link may */ + /* be visible to non-finalization code. */ + /* There's an argument that an arbitrary action should */ + /* be allowed here, instead of just clearing a pointer. */ + /* But this causes problems if that action alters, or */ + /* examines connectivity. Returns GC_DUPLICATE if link */ + /* was already registered, GC_SUCCESS if registration */ + /* succeeded, GC_NO_MEMORY if it failed for lack of */ + /* memory, and GC_oom_fn did not handle the problem. */ + /* Only exists for backward compatibility. See below: */ + +GC_API int GC_CALL GC_general_register_disappearing_link(void ** /* link */, + const void * /* obj */) + GC_ATTR_NONNULL(1) GC_ATTR_NONNULL(2); + /* A slight generalization of the above. *link is */ + /* cleared when obj first becomes inaccessible. This */ + /* can be used to implement weak pointers easily and */ + /* safely. Typically link will point to a location */ + /* holding a disguised pointer to obj. (A pointer */ + /* inside an "atomic" object is effectively disguised.) */ + /* In this way, weak pointers are broken before any */ + /* object reachable from them gets finalized. */ + /* Each link may be registered only with one obj value, */ + /* i.e. all objects but the last one (link registered */ + /* with) are ignored. This was added after a long */ + /* email discussion with John Ellis. */ + /* link must be non-NULL (and be properly aligned). */ + /* obj must be a pointer to the first word of an object */ + /* allocated by GC_malloc or friends. A link */ + /* disappears when it is unregistered manually, or when */ + /* (*link) is cleared, or when the object containing */ + /* this link is garbage collected. It is unsafe to */ + /* explicitly deallocate the object containing link. */ + /* Explicit deallocation of obj may or may not cause */ + /* link to eventually be cleared. */ + /* No-op in the leak-finding mode. */ + /* This function can be used to implement certain types */ + /* of weak pointers. Note, however, this generally */ + /* requires that the allocation lock is held (see */ + /* GC_call_with_alloc_lock() below) when the disguised */ + /* pointer is accessed. Otherwise a strong pointer */ + /* could be recreated between the time the collector */ + /* decides to reclaim the object and the link is */ + /* cleared. Returns GC_SUCCESS if registration */ + /* succeeded (a new link is registered), GC_DUPLICATE */ + /* if link was already registered (with some object), */ + /* GC_NO_MEMORY if registration failed for lack of */ + /* memory (and GC_oom_fn did not handle the problem), */ + /* GC_UNIMPLEMENTED if GC_find_leak is true. */ + +GC_API int GC_CALL GC_move_disappearing_link(void ** /* link */, + void ** /* new_link */) + GC_ATTR_NONNULL(2); + /* Moves a link previously registered via */ + /* GC_general_register_disappearing_link (or */ + /* GC_register_disappearing_link). Does not change the */ + /* target object of the weak reference. Does not */ + /* change (*new_link) content. May be called with */ + /* new_link equal to link (to check whether link has */ + /* been registered). Returns GC_SUCCESS on success, */ + /* GC_DUPLICATE if there is already another */ + /* disappearing link at the new location (never */ + /* returned if new_link is equal to link), GC_NOT_FOUND */ + /* if no link is registered at the original location. */ + +GC_API int GC_CALL GC_unregister_disappearing_link(void ** /* link */); + /* Undoes a registration by either of the above two */ + /* routines. Returns 0 if link was not actually */ + /* registered (otherwise returns 1). */ + +GC_API int GC_CALL GC_register_long_link(void ** /* link */, + const void * /* obj */) + GC_ATTR_NONNULL(1) GC_ATTR_NONNULL(2); + /* Similar to GC_general_register_disappearing_link but */ + /* *link only gets cleared when obj becomes truly */ + /* inaccessible. An object becomes truly inaccessible */ + /* when it can no longer be resurrected from its */ + /* finalizer (e.g. by assigning itself to a pointer */ + /* traceable from root). This can be used to implement */ + /* long weak pointers easily and safely. */ + +GC_API int GC_CALL GC_move_long_link(void ** /* link */, + void ** /* new_link */) + GC_ATTR_NONNULL(2); + /* Similar to GC_move_disappearing_link but for a link */ + /* previously registered via GC_register_long_link. */ + +GC_API int GC_CALL GC_unregister_long_link(void ** /* link */); + /* Similar to GC_unregister_disappearing_link but for a */ + /* registration by either of the above two routines. */ + +/* Support of toggle-ref style of external memory management */ +/* without hooking up to the host retain/release machinery. */ +/* The idea of toggle-ref is that an external reference to */ +/* an object is kept and it can be either a strong or weak */ +/* reference; a weak reference is used when the external peer */ +/* has no interest in the object, and a strong otherwise. */ +typedef enum { + GC_TOGGLE_REF_DROP, + GC_TOGGLE_REF_STRONG, + GC_TOGGLE_REF_WEAK +} GC_ToggleRefStatus; + +/* The callback is to decide (return) the new state of a given */ +/* object. Invoked by the collector for all objects registered */ +/* for toggle-ref processing. Invoked with the allocation lock */ +/* held (but the "world" is running). */ +typedef GC_ToggleRefStatus (GC_CALLBACK *GC_toggleref_func)(void * /* obj */); + +/* Set (register) a callback that decides the state of a given */ +/* object (by, probably, inspecting its native state). */ +/* The argument may be 0 (means no callback). Both the setter */ +/* and the getter acquire the allocation lock (to avoid data */ +/* races). */ +GC_API void GC_CALL GC_set_toggleref_func(GC_toggleref_func); +GC_API GC_toggleref_func GC_CALL GC_get_toggleref_func(void); + +/* Register a given object for toggle-ref processing. It will */ +/* be stored internally and the toggle-ref callback will be */ +/* invoked on the object until the callback returns */ +/* GC_TOGGLE_REF_DROP or the object is collected. If is_strong */ +/* is true then the object is registered with a strong ref, */ +/* a weak one otherwise. Returns GC_SUCCESS if registration */ +/* succeeded (or no callback registered yet), GC_NO_MEMORY if */ +/* it failed for lack of memory. */ +GC_API int GC_CALL GC_toggleref_add(void * /* obj */, int /* is_strong */) + GC_ATTR_NONNULL(1); + +/* Finalizer callback support. Invoked by the collector (with */ +/* the allocation lock held) for each unreachable object */ +/* enqueued for finalization. */ +typedef void (GC_CALLBACK * GC_await_finalize_proc)(void * /* obj */); +GC_API void GC_CALL GC_set_await_finalize_proc(GC_await_finalize_proc); +GC_API GC_await_finalize_proc GC_CALL GC_get_await_finalize_proc(void); + /* Zero means no callback. The setter */ + /* and getter acquire the lock too. */ + +/* Returns !=0 if GC_invoke_finalizers has something to do. */ +/* Does not use any synchronization. */ +GC_API int GC_CALL GC_should_invoke_finalizers(void); + +GC_API int GC_CALL GC_invoke_finalizers(void); + /* Run finalizers for all objects that are ready to */ + /* be finalized. Return the number of finalizers */ + /* that were run. Normally this is also called */ + /* implicitly during some allocations. If */ + /* GC_finalize_on_demand is nonzero, it must be called */ + /* explicitly. */ + +/* Explicitly tell the collector that an object is reachable */ +/* at a particular program point. This prevents the argument */ +/* pointer from being optimized away, even it is otherwise no */ +/* longer needed. It should have no visible effect in the */ +/* absence of finalizers or disappearing links. But it may be */ +/* needed to prevent finalizers from running while the */ +/* associated external resource is still in use. */ +/* The function is sometimes called keep_alive in other */ +/* settings. */ +#if defined(__GNUC__) && !defined(__INTEL_COMPILER) +# define GC_reachable_here(ptr) \ + __asm__ __volatile__(" " : : "X"(ptr) : "memory") +#else + GC_API void GC_CALL GC_noop1(GC_word); +# ifdef LINT2 +# define GC_reachable_here(ptr) GC_noop1(~(GC_word)(ptr)^(~(GC_word)0)) + /* The expression matches the one of COVERT_DATAFLOW(). */ +# else +# define GC_reachable_here(ptr) GC_noop1((GC_word)(ptr)) +# endif +#endif + +/* GC_set_warn_proc can be used to redirect or filter warning messages. */ +/* p may not be a NULL pointer. msg is printf format string (arg must */ +/* match the format). Both the setter and the getter acquire the GC */ +/* lock (to avoid data races). In GC v7.1 (and before), the setter */ +/* returned the old warn_proc value. */ +typedef void (GC_CALLBACK * GC_warn_proc)(char * /* msg */, + GC_word /* arg */); +GC_API void GC_CALL GC_set_warn_proc(GC_warn_proc /* p */) GC_ATTR_NONNULL(1); +/* GC_get_warn_proc returns the current warn_proc. */ +GC_API GC_warn_proc GC_CALL GC_get_warn_proc(void); + +/* GC_ignore_warn_proc may be used as an argument for GC_set_warn_proc */ +/* to suppress all warnings (unless statistics printing is turned on). */ +GC_API void GC_CALLBACK GC_ignore_warn_proc(char *, GC_word); + +/* Change file descriptor of GC log. Unavailable on some targets. */ +GC_API void GC_CALL GC_set_log_fd(int); + +/* abort_func is invoked on GC fatal aborts (just before OS-dependent */ +/* abort or exit(1) is called). Must be non-NULL. The default one */ +/* outputs msg to stderr provided msg is non-NULL. msg is NULL if */ +/* invoked before exit(1) otherwise msg is non-NULL (i.e., if invoked */ +/* before abort). Both the setter and getter acquire the GC lock. */ +/* Both the setter and getter are defined only if the library has been */ +/* compiled without SMALL_CONFIG. */ +typedef void (GC_CALLBACK * GC_abort_func)(const char * /* msg */); +GC_API void GC_CALL GC_set_abort_func(GC_abort_func) GC_ATTR_NONNULL(1); +GC_API GC_abort_func GC_CALL GC_get_abort_func(void); + +/* A portable way to abort the application because of not enough memory.*/ +GC_API void GC_CALL GC_abort_on_oom(void); + +/* The following is intended to be used by a higher level */ +/* (e.g. Java-like) finalization facility. It is expected */ +/* that finalization code will arrange for hidden pointers to */ +/* disappear. Otherwise objects can be accessed after they */ +/* have been collected. */ +/* Should not be used in the leak-finding mode. */ +/* Note that putting pointers in atomic objects or in */ +/* non-pointer slots of "typed" objects is equivalent to */ +/* disguising them in this way, and may have other advantages. */ +typedef GC_word GC_hidden_pointer; +#define GC_HIDE_POINTER(p) (~(GC_hidden_pointer)(p)) +/* Converting a hidden pointer to a real pointer requires verifying */ +/* that the object still exists. This involves acquiring the */ +/* allocator lock to avoid a race with the collector. */ +#define GC_REVEAL_POINTER(p) ((void *)GC_HIDE_POINTER(p)) + +#if defined(I_HIDE_POINTERS) || defined(GC_I_HIDE_POINTERS) + /* This exists only for compatibility (the GC-prefixed symbols are */ + /* preferred for new code). */ +# define HIDE_POINTER(p) GC_HIDE_POINTER(p) +# define REVEAL_POINTER(p) GC_REVEAL_POINTER(p) +#endif + +/* The routines to acquire/release the allocator lock. */ +/* The lock is not reentrant. GC_alloc_unlock() should not be called */ +/* unless the lock is acquired by the current thread. */ +#ifdef GC_THREADS + GC_API void GC_CALL GC_alloc_lock(void); + GC_API void GC_CALL GC_alloc_unlock(void); +#else + /* No need for real locking if the client is single-threaded. */ +# define GC_alloc_lock() (void)0 +# define GC_alloc_unlock() (void)0 +#endif /* !GC_THREADS */ + +typedef void * (GC_CALLBACK * GC_fn_type)(void * /* client_data */); +GC_API void * GC_CALL GC_call_with_alloc_lock(GC_fn_type /* fn */, + void * /* client_data */) GC_ATTR_NONNULL(1); + +/* These routines are intended to explicitly notify the collector */ +/* of new threads. Often this is unnecessary because thread creation */ +/* is implicitly intercepted by the collector, using header-file */ +/* defines, or linker-based interception. In the long run the intent */ +/* is to always make redundant registration safe. In the short run, */ +/* this is being implemented a platform at a time. */ +/* The interface is complicated by the fact that we probably will not */ +/* ever be able to automatically determine the stack bottom for thread */ +/* stacks on all platforms. */ + +/* Structure representing the bottom (cold end) of a thread stack. */ +/* On most platforms this contains just a single address. */ +struct GC_stack_base { + void * mem_base; /* the bottom of the general-purpose stack */ +# if defined(__ia64) || defined(__ia64__) || defined(_M_IA64) + void * reg_base; /* the bottom of the register stack */ +# endif +}; + +typedef void * (GC_CALLBACK * GC_stack_base_func)( + struct GC_stack_base * /* sb */, void * /* arg */); + +/* Call a function with a stack base structure corresponding to */ +/* somewhere in the GC_call_with_stack_base frame. This often can */ +/* be used to provide a sufficiently accurate stack bottom. And we */ +/* implement it everywhere. */ +GC_API void * GC_CALL GC_call_with_stack_base(GC_stack_base_func /* fn */, + void * /* arg */) GC_ATTR_NONNULL(1); + +#define GC_SUCCESS 0 +#define GC_DUPLICATE 1 /* Was already registered. */ +#define GC_NO_THREADS 2 /* No thread support in GC. */ + /* GC_NO_THREADS is not returned by any GC function anymore. */ +#define GC_UNIMPLEMENTED 3 /* Not yet implemented on this platform. */ +#define GC_NOT_FOUND 4 /* Requested link not found (returned */ + /* by GC_move_disappearing_link). */ + +#if defined(GC_DARWIN_THREADS) || defined(GC_WIN32_THREADS) + /* Use implicit thread registration and processing (via Win32 DllMain */ + /* or Darwin task_threads). Deprecated. Must be called before */ + /* GC_INIT() and other GC routines. Should be avoided if */ + /* GC_pthread_create, GC_beginthreadex (or GC_CreateThread) could be */ + /* called instead. Disables parallelized GC on Win32. */ + GC_API void GC_CALL GC_use_threads_discovery(void); +#endif + +#ifdef GC_THREADS + /* Suggest the GC to use the specific signal to suspend threads. */ + /* Has no effect after GC_init and on non-POSIX systems. */ + GC_API void GC_CALL GC_set_suspend_signal(int); + + /* Suggest the GC to use the specific signal to resume threads. */ + /* Has no effect after GC_init and on non-POSIX systems. */ + GC_API void GC_CALL GC_set_thr_restart_signal(int); + + /* Return the signal number (constant after initialization) used by */ + /* the GC to suspend threads on POSIX systems. Return -1 otherwise. */ + GC_API int GC_CALL GC_get_suspend_signal(void); + + /* Return the signal number (constant after initialization) used by */ + /* the garbage collector to restart (resume) threads on POSIX */ + /* systems. Return -1 otherwise. */ + GC_API int GC_CALL GC_get_thr_restart_signal(void); + + /* Restart marker threads after POSIX fork in child. Meaningless in */ + /* other situations. Should not be called if fork followed by exec. */ + GC_API void GC_CALL GC_start_mark_threads(void); + + /* Explicitly enable GC_register_my_thread() invocation. */ + /* Done implicitly if a GC thread-creation function is called (or */ + /* implicit thread registration is activated, or the collector is */ + /* compiled with GC_ALWAYS_MULTITHREADED defined). Otherwise, it */ + /* must be called from the main (or any previously registered) thread */ + /* between the collector initialization and the first explicit */ + /* registering of a thread (it should be called as late as possible). */ + GC_API void GC_CALL GC_allow_register_threads(void); + + /* Register the current thread, with the indicated stack bottom, as */ + /* a new thread whose stack(s) should be traced by the GC. If it */ + /* is not implicitly called by the GC, this must be called before a */ + /* thread can allocate garbage collected memory, or assign pointers */ + /* to the garbage collected heap. Once registered, a thread will be */ + /* stopped during garbage collections. */ + /* This call must be previously enabled (see above). */ + /* This should never be called from the main thread, where it is */ + /* always done implicitly. This is normally done implicitly if GC_ */ + /* functions are called to create the thread, e.g. by including gc.h */ + /* (which redefines some system functions) before calling the system */ + /* thread creation function. Nonetheless, thread cleanup routines */ + /* (e.g., pthread key destructor) typically require manual thread */ + /* registering (and unregistering) if pointers to GC-allocated */ + /* objects are manipulated inside. */ + /* It is also always done implicitly on some platforms if */ + /* GC_use_threads_discovery() is called at start-up. Except for the */ + /* latter case, the explicit call is normally required for threads */ + /* created by third-party libraries. */ + /* A manually registered thread requires manual unregistering. */ + /* Returns GC_SUCCESS on success, GC_DUPLICATE if already registered. */ + GC_API int GC_CALL GC_register_my_thread(const struct GC_stack_base *) + GC_ATTR_NONNULL(1); + + /* Return non-zero (TRUE) if and only if the calling thread is */ + /* registered with the garbage collector. */ + GC_API int GC_CALL GC_thread_is_registered(void); + + /* Notify the collector about the stack and the alt-stack of the */ + /* current thread. stack_start/size is used to determine the stack */ + /* boundaries when a thread is suspended while it is on an alt-stack. */ + GC_API void GC_CALL GC_register_altstack(void * /* stack_start */, + GC_word /* stack_size */, + void * /* altstack_base */, + GC_word /* altstack_size */); + + /* Unregister the current thread. Only an explicitly registered */ + /* thread (i.e. for which GC_register_my_thread() returns GC_SUCCESS) */ + /* is allowed (and required) to call this function. (As a special */ + /* exception, it is also allowed to once unregister the main thread.) */ + /* The thread may no longer allocate garbage collected memory or */ + /* manipulate pointers to the garbage collected heap after making */ + /* this call. Specifically, if it wants to return or otherwise */ + /* communicate a pointer to the garbage-collected heap to another */ + /* thread, it must do this before calling GC_unregister_my_thread, */ + /* most probably by saving it in a global data structure. Must not */ + /* be called inside a GC callback function (except for */ + /* GC_call_with_stack_base() one). */ + GC_API int GC_CALL GC_unregister_my_thread(void); + + /* Stop/start the world explicitly. Not recommended for general use. */ + GC_API void GC_CALL GC_stop_world_external(void); + GC_API void GC_CALL GC_start_world_external(void); +#endif /* GC_THREADS */ + +/* Wrapper for functions that are likely to block (or, at least, do not */ +/* allocate garbage collected memory and/or manipulate pointers to the */ +/* garbage collected heap) for an appreciable length of time. While fn */ +/* is running, the collector is said to be in the "inactive" state for */ +/* the current thread (this means that the thread is not suspended and */ +/* the thread's stack frames "belonging" to the functions in the */ +/* "inactive" state are not scanned during garbage collections). It is */ +/* assumed that the collector is already initialized and the current */ +/* thread is registered. It is allowed for fn to call */ +/* GC_call_with_gc_active() (even recursively), thus temporarily */ +/* toggling the collector's state back to "active". The latter */ +/* technique might be used to make stack scanning more precise (i.e. */ +/* scan only stack frames of functions that allocate garbage collected */ +/* memory and/or manipulate pointers to the garbage collected heap). */ +GC_API void * GC_CALL GC_do_blocking(GC_fn_type /* fn */, + void * /* client_data */) GC_ATTR_NONNULL(1); + +/* Call a function switching to the "active" state of the collector for */ +/* the current thread (i.e. the user function is allowed to call any */ +/* GC function and/or manipulate pointers to the garbage collected */ +/* heap). GC_call_with_gc_active() has the functionality opposite to */ +/* GC_do_blocking() one. It is assumed that the collector is already */ +/* initialized and the current thread is registered. fn may toggle */ +/* the collector thread's state temporarily to "inactive" one by using */ +/* GC_do_blocking. GC_call_with_gc_active() often can be used to */ +/* provide a sufficiently accurate stack bottom. */ +GC_API void * GC_CALL GC_call_with_gc_active(GC_fn_type /* fn */, + void * /* client_data */) GC_ATTR_NONNULL(1); + +/* Attempt to fill in the GC_stack_base structure with the stack bottom */ +/* for this thread. This appears to be required to implement anything */ +/* like the JNI AttachCurrentThread in an environment in which new */ +/* threads are not automatically registered with the collector. */ +/* It is also unfortunately hard to implement well on many platforms. */ +/* Returns GC_SUCCESS or GC_UNIMPLEMENTED. This function acquires the */ +/* GC lock on some platforms. */ +GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base *) + GC_ATTR_NONNULL(1); + +/* Fill in the GC_stack_base structure with the cold end (bottom) of */ +/* the stack of the current thread (or coroutine). */ +/* Unlike GC_get_stack_base, it retrieves the value stored in the */ +/* collector (which is initially set by the collector upon the thread */ +/* is started or registered manually but it could be later updated by */ +/* client using GC_set_stackbottom). Returns the GC-internal non-NULL */ +/* handle of the thread which could be passed to GC_set_stackbottom */ +/* later. It is assumed that the collector is already initialized and */ +/* the thread is registered. Acquires the GC lock to avoid data races. */ +GC_API void * GC_CALL GC_get_my_stackbottom(struct GC_stack_base *) + GC_ATTR_NONNULL(1); + +/* Set the cool end of the user (coroutine) stack of the specified */ +/* thread. The GC thread handle is either the one returned by */ +/* GC_get_my_stackbottom or NULL (the latter designates the current */ +/* thread). The caller should hold the GC lock (e.g. using */ +/* GC_call_with_alloc_lock). Also, the function could be used for */ +/* setting GC_stackbottom value (the bottom of the primordial thread) */ +/* before the collector is initialized (the GC lock is not needed to be */ +/* acquired in this case). */ +GC_API void GC_CALL GC_set_stackbottom(void * /* gc_thread_handle */, + const struct GC_stack_base *) + GC_ATTR_NONNULL(2); + +/* The following routines are primarily intended for use with a */ +/* preprocessor which inserts calls to check C pointer arithmetic. */ +/* They indicate failure by invoking the corresponding _print_proc. */ + +/* Check that p and q point to the same object. */ +/* Fail conspicuously if they don't. */ +/* Returns the first argument. */ +/* Succeeds if neither p nor q points to the heap. */ +/* May succeed if both p and q point to between heap objects. */ +GC_API void * GC_CALL GC_same_obj(void * /* p */, void * /* q */); + +/* Checked pointer pre- and post- increment operations. Note that */ +/* the second argument is in units of bytes, not multiples of the */ +/* object size. This should either be invoked from a macro, or the */ +/* call should be automatically generated. */ +GC_API void * GC_CALL GC_pre_incr(void **, ptrdiff_t /* how_much */) + GC_ATTR_NONNULL(1); +GC_API void * GC_CALL GC_post_incr(void **, ptrdiff_t /* how_much */) + GC_ATTR_NONNULL(1); + +/* Check that p is visible */ +/* to the collector as a possibly pointer containing location. */ +/* If it isn't fail conspicuously. */ +/* Returns the argument in all cases. May erroneously succeed */ +/* in hard cases. (This is intended for debugging use with */ +/* untyped allocations. The idea is that it should be possible, though */ +/* slow, to add such a call to all indirect pointer stores.) */ +/* Currently useless for multi-threaded worlds. */ +GC_API void * GC_CALL GC_is_visible(void * /* p */); + +/* Check that if p is a pointer to a heap page, then it points to */ +/* a valid displacement within a heap object. */ +/* Fail conspicuously if this property does not hold. */ +/* Uninteresting with GC_all_interior_pointers. */ +/* Always returns its argument. */ +GC_API void * GC_CALL GC_is_valid_displacement(void * /* p */); + +/* Explicitly dump the GC state. This is most often called from the */ +/* debugger, or by setting the GC_DUMP_REGULARLY environment variable, */ +/* but it may be useful to call it from client code during debugging. */ +/* The current collection number is printed in the header of the dump. */ +/* Acquires the GC lock to avoid data races. */ +/* Defined only if the library has been compiled without NO_DEBUGGING. */ +GC_API void GC_CALL GC_dump(void); + +/* The same as GC_dump but allows to specify the name of dump and does */ +/* not acquire the lock. If name is non-NULL, it is printed to help */ +/* identifying individual dumps. Otherwise the current collection */ +/* number is used as the name. */ +/* Defined only if the library has been compiled without NO_DEBUGGING. */ +GC_API void GC_CALL GC_dump_named(const char * /* name */); + +/* Dump information about each block of every GC memory section. */ +/* Defined only if the library has been compiled without NO_DEBUGGING. */ +GC_API void GC_CALL GC_dump_regions(void); + +/* Dump information about every registered disappearing link and */ +/* finalizable object. */ +/* Defined only if the library has been compiled without NO_DEBUGGING. */ +GC_API void GC_CALL GC_dump_finalization(void); + +/* Safer, but slow, pointer addition. Probably useful mainly with */ +/* a preprocessor. Useful only for heap pointers. */ +/* Only the macros without trailing digits are meant to be used */ +/* by clients. These are designed to model the available C pointer */ +/* arithmetic expressions. */ +/* Even then, these are probably more useful as */ +/* documentation than as part of the API. */ +/* Note that GC_PTR_ADD evaluates the first argument more than once. */ +#if defined(GC_DEBUG) && defined(__GNUC__) +# define GC_PTR_ADD3(x, n, type_of_result) \ + ((type_of_result)GC_same_obj((x)+(n), (x))) +# define GC_PRE_INCR3(x, n, type_of_result) \ + ((type_of_result)GC_pre_incr((void **)(&(x)), (n)*sizeof(*x))) +# define GC_POST_INCR3(x, n, type_of_result) \ + ((type_of_result)GC_post_incr((void **)(&(x)), (n)*sizeof(*x))) +# define GC_PTR_ADD(x, n) GC_PTR_ADD3(x, n, __typeof__(x)) +# define GC_PRE_INCR(x, n) GC_PRE_INCR3(x, n, __typeof__(x)) +# define GC_POST_INCR(x) GC_POST_INCR3(x, 1, __typeof__(x)) +# define GC_POST_DECR(x) GC_POST_INCR3(x, -1, __typeof__(x)) +#else /* !GC_DEBUG || !__GNUC__ */ + /* We can't do this right without typeof, which ANSI decided was not */ + /* sufficiently useful. Without it we resort to the non-debug version. */ + /* TODO: This should eventually support C++0x decltype. */ +# define GC_PTR_ADD(x, n) ((x)+(n)) +# define GC_PRE_INCR(x, n) ((x) += (n)) +# define GC_POST_INCR(x) ((x)++) +# define GC_POST_DECR(x) ((x)--) +#endif /* !GC_DEBUG || !__GNUC__ */ + +/* Safer assignment of a pointer to a non-stack location. */ +#ifdef GC_DEBUG +# define GC_PTR_STORE(p, q) \ + (*(void **)GC_is_visible((void *)(p)) = \ + GC_is_valid_displacement((void *)(q))) +#else +# define GC_PTR_STORE(p, q) (*(void **)(p) = (void *)(q)) +#endif + +/* GC_PTR_STORE_AND_DIRTY(p,q) is equivalent to GC_PTR_STORE(p,q) */ +/* followed by GC_END_STUBBORN_CHANGE(p) and GC_reachable_here(q) */ +/* (assuming p and q do not have side effects). */ +GC_API void GC_CALL GC_ptr_store_and_dirty(void * /* p */, + const void * /* q */); +GC_API void GC_CALL GC_debug_ptr_store_and_dirty(void * /* p */, + const void * /* q */); + +/* Functions called to report pointer checking errors */ +GC_API void (GC_CALLBACK * GC_same_obj_print_proc)(void * /* p */, + void * /* q */); +GC_API void (GC_CALLBACK * GC_is_valid_displacement_print_proc)(void *); +GC_API void (GC_CALLBACK * GC_is_visible_print_proc)(void *); + +#ifdef GC_PTHREADS + /* For pthread support, we generally need to intercept a number of */ + /* thread library calls. We do that here by macro defining them. */ +# ifdef __cplusplus + } /* extern "C" */ +# endif +# include "gc_pthread_redirects.h" +# ifdef __cplusplus + extern "C" { +# endif +#endif + +/* This returns a list of objects, linked through their first word. */ +/* Its use can greatly reduce lock contention problems, since the */ +/* allocation lock can be acquired and released many fewer times. */ +GC_API GC_ATTR_MALLOC void * GC_CALL GC_malloc_many(size_t /* lb */); +#define GC_NEXT(p) (*(void * *)(p)) /* Retrieve the next element */ + /* in returned list. */ + +/* A filter function to control the scanning of dynamic libraries. */ +/* If implemented, called by GC before registering a dynamic library */ +/* (discovered by GC) section as a static data root (called only as */ +/* a last reason not to register). The filename of the library, the */ +/* address and the length of the memory region (section) are passed. */ +/* This routine should return nonzero if that region should be scanned. */ +/* Always called with the allocation lock held. Depending on the */ +/* platform, might be called with the "world" stopped. */ +typedef int (GC_CALLBACK * GC_has_static_roots_func)( + const char * /* dlpi_name */, + void * /* section_start */, + size_t /* section_size */); + +/* Register a new callback (a user-supplied filter) to control the */ +/* scanning of dynamic libraries. Replaces any previously registered */ +/* callback. May be 0 (means no filtering). May be unused on some */ +/* platforms (if the filtering is unimplemented or inappropriate). */ +GC_API void GC_CALL GC_register_has_static_roots_callback( + GC_has_static_roots_func); + +#if !defined(CPPCHECK) && !defined(GC_WINDOWS_H_INCLUDED) && defined(WINAPI) + /* windows.h is included before gc.h */ +# define GC_WINDOWS_H_INCLUDED +#endif + +#if defined(GC_WIN32_THREADS) \ + && (!defined(GC_PTHREADS) || defined(GC_BUILD) \ + || defined(GC_WINDOWS_H_INCLUDED)) + /* Note: for Cygwin and pthreads-win32, this is skipped */ + /* unless windows.h is included before gc.h. */ + +# if (!defined(GC_NO_THREAD_DECLS) || defined(GC_BUILD)) \ + && !defined(GC_DONT_INCL_WINDOWS_H) + +# ifdef __cplusplus + } /* Including windows.h in an extern "C" context no longer works. */ +# endif + +# if !defined(_WIN32_WCE) && !defined(__CEGCC__) +# include /* For _beginthreadex, _endthreadex */ +# endif + +# if defined(GC_BUILD) || !defined(GC_DONT_INCLUDE_WINDOWS_H) +# include +# define GC_WINDOWS_H_INCLUDED +# endif + +# ifdef __cplusplus + extern "C" { +# endif + +# ifdef GC_UNDERSCORE_STDCALL + /* Explicitly prefix exported/imported WINAPI (__stdcall) symbols */ + /* with '_' (underscore). Might be useful if MinGW/x86 is used. */ +# define GC_CreateThread _GC_CreateThread +# define GC_ExitThread _GC_ExitThread +# endif + +# ifndef DECLSPEC_NORETURN + /* Typically defined in winnt.h. */ +# ifdef GC_WINDOWS_H_INCLUDED +# define DECLSPEC_NORETURN /* empty */ +# else +# define DECLSPEC_NORETURN __declspec(noreturn) +# endif +# endif + +# if !defined(_UINTPTR_T) && !defined(_UINTPTR_T_DEFINED) \ + && !defined(UINTPTR_MAX) + typedef GC_word GC_uintptr_t; +# else + typedef uintptr_t GC_uintptr_t; +# endif + +# ifdef _WIN64 +# define GC_WIN32_SIZE_T GC_uintptr_t +# elif defined(GC_WINDOWS_H_INCLUDED) +# define GC_WIN32_SIZE_T DWORD +# else +# define GC_WIN32_SIZE_T unsigned long +# endif + +# ifdef GC_INSIDE_DLL + /* Export GC DllMain to be invoked from client DllMain. */ +# ifdef GC_UNDERSCORE_STDCALL +# define GC_DllMain _GC_DllMain +# endif +# ifdef GC_WINDOWS_H_INCLUDED + GC_API BOOL WINAPI GC_DllMain(HINSTANCE /* inst */, + ULONG /* reason */, + LPVOID /* reserved */); +# else + GC_API int __stdcall GC_DllMain(void *, unsigned long, void *); +# endif +# endif /* GC_INSIDE_DLL */ + + /* All threads must be created using GC_CreateThread or */ + /* GC_beginthreadex, or must explicitly call GC_register_my_thread */ + /* (and call GC_unregister_my_thread before thread termination), so */ + /* that they will be recorded in the thread table. For backward */ + /* compatibility, it is possible to build the GC with GC_DLL */ + /* defined, and to call GC_use_threads_discovery. This implicitly */ + /* registers all created threads, but appears to be less robust. */ + /* Currently the collector expects all threads to fall through and */ + /* terminate normally, or call GC_endthreadex() or GC_ExitThread, */ + /* so that the thread is properly unregistered. */ +# ifdef GC_WINDOWS_H_INCLUDED + GC_API HANDLE WINAPI GC_CreateThread( + LPSECURITY_ATTRIBUTES /* lpThreadAttributes */, + GC_WIN32_SIZE_T /* dwStackSize */, + LPTHREAD_START_ROUTINE /* lpStartAddress */, + LPVOID /* lpParameter */, DWORD /* dwCreationFlags */, + LPDWORD /* lpThreadId */); + + GC_API DECLSPEC_NORETURN void WINAPI GC_ExitThread( + DWORD /* dwExitCode */); +# else + struct _SECURITY_ATTRIBUTES; + GC_API void *__stdcall GC_CreateThread(struct _SECURITY_ATTRIBUTES *, + GC_WIN32_SIZE_T, + unsigned long (__stdcall *)(void *), + void *, unsigned long, unsigned long *); + GC_API DECLSPEC_NORETURN void __stdcall GC_ExitThread(unsigned long); +# endif + +# if !defined(_WIN32_WCE) && !defined(__CEGCC__) + GC_API GC_uintptr_t GC_CALL GC_beginthreadex( + void * /* security */, unsigned /* stack_size */, + unsigned (__stdcall *)(void *), + void * /* arglist */, unsigned /* initflag */, + unsigned * /* thrdaddr */); + + /* Note: _endthreadex() is not currently marked as no-return in */ + /* VC++ and MinGW headers, so we don't mark it neither. */ + GC_API void GC_CALL GC_endthreadex(unsigned /* retval */); +# endif /* !_WIN32_WCE */ + +# endif /* !GC_NO_THREAD_DECLS */ + +# ifdef GC_WINMAIN_REDIRECT + /* win32_threads.c implements the real WinMain(), which will start */ + /* a new thread to call GC_WinMain() after initializing the garbage */ + /* collector. */ +# define WinMain GC_WinMain +# endif + + /* For compatibility only. */ +# define GC_use_DllMain GC_use_threads_discovery + +# ifndef GC_NO_THREAD_REDIRECTS +# define CreateThread GC_CreateThread +# define ExitThread GC_ExitThread +# undef _beginthreadex +# define _beginthreadex GC_beginthreadex +# undef _endthreadex +# define _endthreadex GC_endthreadex +/* #define _beginthread { > "Please use _beginthreadex instead of _beginthread" < } */ +# endif /* !GC_NO_THREAD_REDIRECTS */ + +#endif /* GC_WIN32_THREADS */ + +/* Public setter and getter for switching "unmap as much as possible" */ +/* mode on(1) and off(0). Has no effect unless unmapping is turned on. */ +/* Has no effect on implicitly-initiated garbage collections. Initial */ +/* value is controlled by GC_FORCE_UNMAP_ON_GCOLLECT. The setter and */ +/* getter are unsynchronized. */ +GC_API void GC_CALL GC_set_force_unmap_on_gcollect(int); +GC_API int GC_CALL GC_get_force_unmap_on_gcollect(void); + +/* Fully portable code should call GC_INIT() from the main program */ +/* before making any other GC_ calls. On most platforms this is a */ +/* no-op and the collector self-initializes. But a number of */ +/* platforms make that too hard. */ +/* A GC_INIT call is required if the collector is built with */ +/* THREAD_LOCAL_ALLOC defined and the initial allocation call is not */ +/* to GC_malloc() or GC_malloc_atomic(). */ + +#if defined(__CYGWIN32__) || defined(__CYGWIN__) + /* Similarly gnu-win32 DLLs need explicit initialization from the */ + /* main program, as does AIX. */ +# ifdef __x86_64__ + /* Cygwin/x64 does not add leading underscore to symbols anymore. */ + extern int __data_start__[], __data_end__[]; + extern int __bss_start__[], __bss_end__[]; +# define GC_DATASTART ((GC_word)__data_start__ < (GC_word)__bss_start__ \ + ? (void *)__data_start__ : (void *)__bss_start__) +# define GC_DATAEND ((GC_word)__data_end__ > (GC_word)__bss_end__ \ + ? (void *)__data_end__ : (void *)__bss_end__) +# else + extern int _data_start__[], _data_end__[], _bss_start__[], _bss_end__[]; +# define GC_DATASTART ((GC_word)_data_start__ < (GC_word)_bss_start__ \ + ? (void *)_data_start__ : (void *)_bss_start__) +# define GC_DATAEND ((GC_word)_data_end__ > (GC_word)_bss_end__ \ + ? (void *)_data_end__ : (void *)_bss_end__) +# endif /* !__x86_64__ */ +# define GC_INIT_CONF_ROOTS GC_add_roots(GC_DATASTART, GC_DATAEND); \ + GC_gcollect() /* For blacklisting. */ + /* Required at least if GC is in a DLL. And doesn't hurt. */ +#elif defined(_AIX) + extern int _data[], _end[]; +# define GC_DATASTART ((void *)_data) +# define GC_DATAEND ((void *)_end) +# define GC_INIT_CONF_ROOTS GC_add_roots(GC_DATASTART, GC_DATAEND) +#elif (defined(HOST_ANDROID) || defined(__ANDROID__)) \ + && defined(IGNORE_DYNAMIC_LOADING) + /* This is ugly but seems the only way to register data roots of the */ + /* client shared library if the GC dynamic loading support is off. */ +# pragma weak __dso_handle + extern int __dso_handle[]; + GC_API void * GC_CALL GC_find_limit(void * /* start */, int /* up */); +# define GC_INIT_CONF_ROOTS (void)(__dso_handle != 0 \ + ? (GC_add_roots(__dso_handle, \ + GC_find_limit(__dso_handle, \ + 1 /*up*/)), 0) : 0) +#else +# define GC_INIT_CONF_ROOTS /* empty */ +#endif + +#ifdef GC_DONT_EXPAND + /* Set GC_dont_expand to TRUE at start-up */ +# define GC_INIT_CONF_DONT_EXPAND GC_set_dont_expand(1) +#else +# define GC_INIT_CONF_DONT_EXPAND /* empty */ +#endif + +#ifdef GC_FORCE_UNMAP_ON_GCOLLECT + /* Turn on "unmap as much as possible on explicit GC" mode at start-up */ +# define GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT \ + GC_set_force_unmap_on_gcollect(1) +#else +# define GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT /* empty */ +#endif + +#ifdef GC_DONT_GC + /* This is for debugging only (useful if environment variables are */ + /* unsupported); cannot call GC_disable as goes before GC_init. */ +# define GC_INIT_CONF_MAX_RETRIES (void)(GC_dont_gc = 1) +#elif defined(GC_MAX_RETRIES) && !defined(CPPCHECK) + /* Set GC_max_retries to the desired value at start-up */ +# define GC_INIT_CONF_MAX_RETRIES GC_set_max_retries(GC_MAX_RETRIES) +#else +# define GC_INIT_CONF_MAX_RETRIES /* empty */ +#endif + +#if defined(GC_ALLOCD_BYTES_PER_FINALIZER) && !defined(CPPCHECK) + /* Set GC_allocd_bytes_per_finalizer to the desired value at start-up. */ +# define GC_INIT_CONF_ALLOCD_BYTES_PER_FINALIZER \ + GC_set_allocd_bytes_per_finalizer(GC_ALLOCD_BYTES_PER_FINALIZER) +#else +# define GC_INIT_CONF_ALLOCD_BYTES_PER_FINALIZER /* empty */ +#endif + +#if defined(GC_FREE_SPACE_DIVISOR) && !defined(CPPCHECK) + /* Set GC_free_space_divisor to the desired value at start-up */ +# define GC_INIT_CONF_FREE_SPACE_DIVISOR \ + GC_set_free_space_divisor(GC_FREE_SPACE_DIVISOR) +#else +# define GC_INIT_CONF_FREE_SPACE_DIVISOR /* empty */ +#endif + +#if defined(GC_FULL_FREQ) && !defined(CPPCHECK) + /* Set GC_full_freq to the desired value at start-up */ +# define GC_INIT_CONF_FULL_FREQ GC_set_full_freq(GC_FULL_FREQ) +#else +# define GC_INIT_CONF_FULL_FREQ /* empty */ +#endif + +#if defined(GC_TIME_LIMIT) && !defined(CPPCHECK) + /* Set GC_time_limit (in ms) to the desired value at start-up. */ +# define GC_INIT_CONF_TIME_LIMIT GC_set_time_limit(GC_TIME_LIMIT) +#else +# define GC_INIT_CONF_TIME_LIMIT /* empty */ +#endif + +#if defined(GC_MARKERS) && defined(GC_THREADS) && !defined(CPPCHECK) + /* Set the number of marker threads (including the initiating */ + /* one) to the desired value at start-up. */ +# define GC_INIT_CONF_MARKERS GC_set_markers_count(GC_MARKERS) +#else +# define GC_INIT_CONF_MARKERS /* empty */ +#endif + +#if defined(GC_SIG_SUSPEND) && defined(GC_THREADS) && !defined(CPPCHECK) +# define GC_INIT_CONF_SUSPEND_SIGNAL GC_set_suspend_signal(GC_SIG_SUSPEND) +#else +# define GC_INIT_CONF_SUSPEND_SIGNAL /* empty */ +#endif + +#if defined(GC_SIG_THR_RESTART) && defined(GC_THREADS) && !defined(CPPCHECK) +# define GC_INIT_CONF_THR_RESTART_SIGNAL \ + GC_set_thr_restart_signal(GC_SIG_THR_RESTART) +#else +# define GC_INIT_CONF_THR_RESTART_SIGNAL /* empty */ +#endif + +#if defined(GC_MAXIMUM_HEAP_SIZE) && !defined(CPPCHECK) + /* Limit the heap size to the desired value (useful for debugging). */ + /* The limit could be overridden either at the program start-up by */ + /* the similar environment variable or anytime later by the */ + /* corresponding API function call. */ +# define GC_INIT_CONF_MAXIMUM_HEAP_SIZE \ + GC_set_max_heap_size(GC_MAXIMUM_HEAP_SIZE) +#else +# define GC_INIT_CONF_MAXIMUM_HEAP_SIZE /* empty */ +#endif + +#ifdef GC_IGNORE_WARN + /* Turn off all warnings at start-up (after GC initialization) */ +# define GC_INIT_CONF_IGNORE_WARN GC_set_warn_proc(GC_ignore_warn_proc) +#else +# define GC_INIT_CONF_IGNORE_WARN /* empty */ +#endif + +#if defined(GC_INITIAL_HEAP_SIZE) && !defined(CPPCHECK) + /* Set heap size to the desired value at start-up */ +# define GC_INIT_CONF_INITIAL_HEAP_SIZE \ + { size_t heap_size = GC_get_heap_size(); \ + if (heap_size < (GC_INITIAL_HEAP_SIZE)) \ + (void)GC_expand_hp((GC_INITIAL_HEAP_SIZE) - heap_size); } +#else +# define GC_INIT_CONF_INITIAL_HEAP_SIZE /* empty */ +#endif + +/* Portable clients should call this at the program start-up. More */ +/* over, some platforms require this call to be done strictly from the */ +/* primordial thread. Multiple invocations are harmless. */ +#define GC_INIT() { GC_INIT_CONF_DONT_EXPAND; /* pre-init */ \ + GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT; \ + GC_INIT_CONF_MAX_RETRIES; \ + GC_INIT_CONF_ALLOCD_BYTES_PER_FINALIZER; \ + GC_INIT_CONF_FREE_SPACE_DIVISOR; \ + GC_INIT_CONF_FULL_FREQ; \ + GC_INIT_CONF_TIME_LIMIT; \ + GC_INIT_CONF_MARKERS; \ + GC_INIT_CONF_SUSPEND_SIGNAL; \ + GC_INIT_CONF_THR_RESTART_SIGNAL; \ + GC_INIT_CONF_MAXIMUM_HEAP_SIZE; \ + GC_init(); /* real GC initialization */ \ + GC_INIT_CONF_ROOTS; /* post-init */ \ + GC_INIT_CONF_IGNORE_WARN; \ + GC_INIT_CONF_INITIAL_HEAP_SIZE; } + +/* win32S may not free all resources on process exit. */ +/* This explicitly deallocates the heap. Defined only for Windows. */ +GC_API void GC_CALL GC_win32_free_heap(void); + +#if defined(__SYMBIAN32__) + void GC_init_global_static_roots(void); +#endif + +#if defined(_AMIGA) && !defined(GC_AMIGA_MAKINGLIB) + /* Allocation really goes through GC_amiga_allocwrapper_do. */ + void *GC_amiga_realloc(void *, size_t); +# define GC_realloc(a,b) GC_amiga_realloc(a,b) + void GC_amiga_set_toany(void (*)(void)); + extern int GC_amiga_free_space_divisor_inc; + extern void *(*GC_amiga_allocwrapper_do)(size_t, void *(GC_CALL *)(size_t)); +# define GC_malloc(a) \ + (*GC_amiga_allocwrapper_do)(a,GC_malloc) +# define GC_malloc_atomic(a) \ + (*GC_amiga_allocwrapper_do)(a,GC_malloc_atomic) +# define GC_malloc_uncollectable(a) \ + (*GC_amiga_allocwrapper_do)(a,GC_malloc_uncollectable) +# define GC_malloc_atomic_uncollectable(a) \ + (*GC_amiga_allocwrapper_do)(a,GC_malloc_atomic_uncollectable) +# define GC_malloc_ignore_off_page(a) \ + (*GC_amiga_allocwrapper_do)(a,GC_malloc_ignore_off_page) +# define GC_malloc_atomic_ignore_off_page(a) \ + (*GC_amiga_allocwrapper_do)(a,GC_malloc_atomic_ignore_off_page) +#endif /* _AMIGA && !GC_AMIGA_MAKINGLIB */ + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +#endif /* GC_H */ diff --git a/boehm/gc/gc_backptr.h b/boehm/gc/gc_backptr.h new file mode 100644 index 0000000..5fd9195 --- /dev/null +++ b/boehm/gc/gc_backptr.h @@ -0,0 +1,96 @@ +/* + * Copyright (c) 1994 by Xerox Corporation. All rights reserved. + * Copyright (c) 1996 by Silicon Graphics. All rights reserved. + * Copyright (c) 1998 by Fergus Henderson. All rights reserved. + * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. + * All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +/* + * This is a simple API to implement pointer back tracing, i.e. + * to answer questions such as "who is pointing to this" or + * "why is this object being retained by the collector" + * + * Most of these calls yield useful information on only after + * a garbage collection. Usually the client will first force + * a full collection and then gather information, preferably + * before much intervening allocation. + * + * The implementation of the interface is only about 99.9999% + * correct. It is intended to be good enough for profiling, + * but is not intended to be used with production code. + * + * Results are likely to be much more useful if all allocation is + * accomplished through the debugging allocators. + * + * The implementation idea is due to A. Demers. + */ + +#ifndef GC_BACKPTR_H +#define GC_BACKPTR_H + +#ifndef GC_H +# include "gc.h" +#endif + +#ifdef __cplusplus + extern "C" { +#endif + +/* Store information about the object referencing dest in *base_p */ +/* and *offset_p. */ +/* If multiple objects or roots point to dest, the one reported */ +/* will be the last on used by the garbage collector to trace the */ +/* object. */ +/* source is root ==> *base_p = address, *offset_p = 0 */ +/* source is heap object ==> *base_p != 0, *offset_p = offset */ +/* Returns 1 on success, 0 if source couldn't be determined. */ +/* Dest can be any address within a heap object. */ +typedef enum { + GC_UNREFERENCED, /* No reference info available. */ + GC_NO_SPACE, /* Dest not allocated with debug alloc. */ + GC_REFD_FROM_ROOT, /* Referenced directly by root *base_p. */ + GC_REFD_FROM_REG, /* Referenced from a register, i.e. */ + /* a root without an address. */ + GC_REFD_FROM_HEAP, /* Referenced from another heap obj. */ + GC_FINALIZER_REFD /* Finalizable and hence accessible. */ +} GC_ref_kind; + +GC_API GC_ref_kind GC_CALL GC_get_back_ptr_info(void * /* dest */, + void ** /* base_p */, size_t * /* offset_p */) + GC_ATTR_NONNULL(1); + +/* Generate a random heap address. */ +/* The resulting address is in the heap, but */ +/* not necessarily inside a valid object. */ +GC_API void * GC_CALL GC_generate_random_heap_address(void); + +/* Generate a random address inside a valid marked heap object. */ +GC_API void * GC_CALL GC_generate_random_valid_address(void); + +/* Force a garbage collection and generate a backtrace from a */ +/* random heap address. */ +/* This uses the GC logging mechanism (GC_printf) to produce */ +/* output. It can often be called from a debugger. The */ +/* source in dbg_mlc.c also serves as a sample client. */ +GC_API void GC_CALL GC_generate_random_backtrace(void); + +/* Print a backtrace from a specific address. Used by the */ +/* above. The client should call GC_gcollect() immediately */ +/* before invocation. */ +GC_API void GC_CALL GC_print_backtrace(void *) GC_ATTR_NONNULL(1); + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +#endif /* GC_BACKPTR_H */ diff --git a/boehm/gc/gc_config_macros.h b/boehm/gc/gc_config_macros.h new file mode 100644 index 0000000..c1a0598 --- /dev/null +++ b/boehm/gc/gc_config_macros.h @@ -0,0 +1,454 @@ +/* + * Copyright (c) 1994 by Xerox Corporation. All rights reserved. + * Copyright (c) 1996 by Silicon Graphics. All rights reserved. + * Copyright (c) 1998 by Fergus Henderson. All rights reserved. + * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. + * All rights reserved. + * Copyright (c) 2008-2020 Ivan Maidanski + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +/* This should never be included directly; it is included only from gc.h. */ +/* We separate it only to make gc.h more suitable as documentation. */ +#if defined(GC_H) + +/* Convenient internal macro to test version of GCC. */ +#if defined(__GNUC__) && defined(__GNUC_MINOR__) +# define GC_GNUC_PREREQ(major, minor) \ + ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((major) << 16) + (minor)) +#else +# define GC_GNUC_PREREQ(major, minor) 0 /* FALSE */ +#endif + +/* Some tests for old macros. These violate our namespace rules and */ +/* will disappear shortly. Use the GC_ names. */ +#if defined(SOLARIS_THREADS) || defined(_SOLARIS_THREADS) \ + || defined(_SOLARIS_PTHREADS) || defined(GC_SOLARIS_PTHREADS) + /* We no longer support old style Solaris threads. */ + /* GC_SOLARIS_THREADS now means pthreads. */ +# ifndef GC_SOLARIS_THREADS +# define GC_SOLARIS_THREADS +# endif +#endif +#if defined(IRIX_THREADS) +# define GC_IRIX_THREADS +#endif +#if defined(DGUX_THREADS) && !defined(GC_DGUX386_THREADS) +# define GC_DGUX386_THREADS +#endif +#if defined(AIX_THREADS) +# define GC_AIX_THREADS +#endif +#if defined(HPUX_THREADS) +# define GC_HPUX_THREADS +#endif +#if defined(OSF1_THREADS) +# define GC_OSF1_THREADS +#endif +#if defined(LINUX_THREADS) +# define GC_LINUX_THREADS +#endif +#if defined(WIN32_THREADS) +# define GC_WIN32_THREADS +#endif +#if defined(RTEMS_THREADS) +# define GC_RTEMS_PTHREADS +#endif +#if defined(USE_LD_WRAP) +# define GC_USE_LD_WRAP +#endif + +#if defined(GC_WIN32_PTHREADS) && !defined(GC_WIN32_THREADS) + /* Using pthreads-win32 library (or other Win32 implementation). */ +# define GC_WIN32_THREADS +#endif + +#if defined(GC_AIX_THREADS) || defined(GC_DARWIN_THREADS) \ + || defined(GC_DGUX386_THREADS) || defined(GC_FREEBSD_THREADS) \ + || defined(GC_HPUX_THREADS) \ + || defined(GC_IRIX_THREADS) || defined(GC_LINUX_THREADS) \ + || defined(GC_NETBSD_THREADS) || defined(GC_OPENBSD_THREADS) \ + || defined(GC_OSF1_THREADS) || defined(GC_SOLARIS_THREADS) \ + || defined(GC_WIN32_THREADS) || defined(GC_RTEMS_PTHREADS) +# ifndef GC_THREADS +# define GC_THREADS +# endif +#elif defined(GC_THREADS) +# if defined(__linux__) +# define GC_LINUX_THREADS +# elif defined(_PA_RISC1_1) || defined(_PA_RISC2_0) || defined(hppa) \ + || defined(__HPPA) || (defined(__ia64) && defined(_HPUX_SOURCE)) +# define GC_HPUX_THREADS +# elif defined(__HAIKU__) +# define GC_HAIKU_THREADS +# elif defined(__OpenBSD__) +# define GC_OPENBSD_THREADS +# elif defined(__DragonFly__) || defined(__FreeBSD_kernel__) \ + || (defined(__FreeBSD__) && !defined(SN_TARGET_ORBIS)) +# define GC_FREEBSD_THREADS +# elif defined(__NetBSD__) +# define GC_NETBSD_THREADS +# elif defined(__alpha) || defined(__alpha__) /* && !Linux && !xBSD */ +# define GC_OSF1_THREADS +# elif (defined(mips) || defined(__mips) || defined(_mips)) \ + && !(defined(nec_ews) || defined(_nec_ews) \ + || defined(ultrix) || defined(__ultrix)) +# define GC_IRIX_THREADS +# elif defined(__sparc) /* && !Linux */ \ + || ((defined(sun) || defined(__sun)) \ + && (defined(i386) || defined(__i386__) \ + || defined(__amd64) || defined(__amd64__))) +# define GC_SOLARIS_THREADS +# elif defined(__APPLE__) && defined(__MACH__) +# define GC_DARWIN_THREADS +# endif +# if defined(DGUX) && (defined(i386) || defined(__i386__)) +# define GC_DGUX386_THREADS +# endif +# if defined(_AIX) +# define GC_AIX_THREADS +# endif +# if (defined(_WIN32) || defined(_MSC_VER) || defined(__BORLANDC__) \ + || defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(__CEGCC__) \ + || defined(_WIN32_WCE) || defined(__MINGW32__)) \ + && !defined(GC_WIN32_THREADS) + /* Either posix or native Win32 threads. */ +# define GC_WIN32_THREADS +# endif +# if defined(__rtems__) && (defined(i386) || defined(__i386__)) +# define GC_RTEMS_PTHREADS +# endif +#endif /* GC_THREADS */ + +#undef GC_PTHREADS +#if (!defined(GC_WIN32_THREADS) || defined(GC_WIN32_PTHREADS) \ + || defined(__CYGWIN32__) || defined(__CYGWIN__)) && defined(GC_THREADS) \ + && !defined(NN_PLATFORM_CTR) && !defined(NN_BUILD_TARGET_PLATFORM_NX) + /* Posix threads. */ +# define GC_PTHREADS +#endif + +#if !defined(_PTHREADS) && defined(GC_NETBSD_THREADS) +# define _PTHREADS +#endif + +#if defined(GC_DGUX386_THREADS) && !defined(_POSIX4A_DRAFT10_SOURCE) +# define _POSIX4A_DRAFT10_SOURCE 1 +#endif + +#if !defined(_REENTRANT) && defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS) + /* Better late than never. This fails if system headers that depend */ + /* on this were previously included. */ +# define _REENTRANT 1 +#endif + +#define __GC +#if !defined(_WIN32_WCE) || defined(__GNUC__) +# include +# if defined(__MINGW32__) && !defined(_WIN32_WCE) +# include + /* We mention uintptr_t. */ + /* Perhaps this should be included in pure msft environments */ + /* as well? */ +# endif +#else /* _WIN32_WCE */ + /* Yet more kludges for WinCE. */ +# include /* size_t is defined here */ +# ifndef _PTRDIFF_T_DEFINED + /* ptrdiff_t is not defined */ +# define _PTRDIFF_T_DEFINED + typedef long ptrdiff_t; +# endif +#endif /* _WIN32_WCE */ + +#if !defined(GC_NOT_DLL) && !defined(GC_DLL) \ + && ((defined(_DLL) && !defined(__GNUC__)) \ + || (defined(DLL_EXPORT) && defined(GC_BUILD))) +# define GC_DLL +#endif + +#if defined(GC_DLL) && !defined(GC_API) + +# if defined(__CEGCC__) +# if defined(GC_BUILD) +# define GC_API __declspec(dllexport) +# else +# define GC_API __declspec(dllimport) +# endif + +# elif defined(__MINGW32__) +# if defined(__cplusplus) && defined(GC_BUILD) +# define GC_API extern __declspec(dllexport) +# elif defined(GC_BUILD) || defined(__MINGW32_DELAY_LOAD__) +# define GC_API __declspec(dllexport) +# else +# define GC_API extern __declspec(dllimport) +# endif + +# elif defined(_MSC_VER) || defined(__DMC__) || defined(__BORLANDC__) \ + || defined(__CYGWIN__) +# ifdef GC_BUILD +# define GC_API extern __declspec(dllexport) +# else +# define GC_API __declspec(dllimport) +# endif + +# elif defined(__WATCOMC__) +# ifdef GC_BUILD +# define GC_API extern __declspec(dllexport) +# else +# define GC_API extern __declspec(dllimport) +# endif + +# elif defined(__SYMBIAN32__) +# ifdef GC_BUILD +# define GC_API extern EXPORT_C +# else +# define GC_API extern IMPORT_C +# endif + +# elif defined(__GNUC__) + /* Only matters if used in conjunction with -fvisibility=hidden option. */ +# if defined(GC_BUILD) && !defined(GC_NO_VISIBILITY) \ + && (GC_GNUC_PREREQ(4, 0) || defined(GC_VISIBILITY_HIDDEN_SET)) +# define GC_API extern __attribute__((__visibility__("default"))) +# endif +# endif +#endif /* GC_DLL */ + +#ifndef GC_API +# define GC_API extern +#endif + +#ifndef GC_CALL +# define GC_CALL +#endif + +#ifndef GC_CALLBACK +# define GC_CALLBACK GC_CALL +#endif + +#ifndef GC_ATTR_MALLOC + /* 'malloc' attribute should be used for all malloc-like functions */ + /* (to tell the compiler that a function may be treated as if any */ + /* non-NULL pointer it returns cannot alias any other pointer valid */ + /* when the function returns). If the client code violates this rule */ + /* by using custom GC_oom_func then define GC_OOM_FUNC_RETURNS_ALIAS. */ +# ifdef GC_OOM_FUNC_RETURNS_ALIAS +# define GC_ATTR_MALLOC /* empty */ +# elif GC_GNUC_PREREQ(3, 1) +# define GC_ATTR_MALLOC __attribute__((__malloc__)) +# elif defined(_MSC_VER) && (_MSC_VER >= 1900) && !defined(__EDG__) +# define GC_ATTR_MALLOC \ + __declspec(allocator) __declspec(noalias) __declspec(restrict) +# elif defined(_MSC_VER) && _MSC_VER >= 1400 +# define GC_ATTR_MALLOC __declspec(noalias) __declspec(restrict) +# else +# define GC_ATTR_MALLOC +# endif +#endif + +#ifndef GC_ATTR_ALLOC_SIZE + /* 'alloc_size' attribute improves __builtin_object_size correctness. */ +# undef GC_ATTR_CALLOC_SIZE +# ifdef __clang__ +# if __has_attribute(__alloc_size__) +# define GC_ATTR_ALLOC_SIZE(argnum) __attribute__((__alloc_size__(argnum))) +# define GC_ATTR_CALLOC_SIZE(n, s) __attribute__((__alloc_size__(n, s))) +# else +# define GC_ATTR_ALLOC_SIZE(argnum) /* empty */ +# endif +# elif GC_GNUC_PREREQ(4, 3) && !defined(__ICC) +# define GC_ATTR_ALLOC_SIZE(argnum) __attribute__((__alloc_size__(argnum))) +# define GC_ATTR_CALLOC_SIZE(n, s) __attribute__((__alloc_size__(n, s))) +# else +# define GC_ATTR_ALLOC_SIZE(argnum) /* empty */ +# endif +#endif + +#ifndef GC_ATTR_CALLOC_SIZE +# define GC_ATTR_CALLOC_SIZE(n, s) /* empty */ +#endif + +#ifndef GC_ATTR_NONNULL +# if GC_GNUC_PREREQ(4, 0) +# define GC_ATTR_NONNULL(argnum) __attribute__((__nonnull__(argnum))) +# else +# define GC_ATTR_NONNULL(argnum) /* empty */ +# endif +#endif + +#ifndef GC_ATTR_CONST +# if GC_GNUC_PREREQ(4, 0) +# define GC_ATTR_CONST __attribute__((__const__)) +# else +# define GC_ATTR_CONST /* empty */ +# endif +#endif + +#ifndef GC_ATTR_DEPRECATED +# ifdef GC_BUILD +# undef GC_ATTR_DEPRECATED +# define GC_ATTR_DEPRECATED /* empty */ +# elif GC_GNUC_PREREQ(4, 0) +# define GC_ATTR_DEPRECATED __attribute__((__deprecated__)) +# elif defined(_MSC_VER) && _MSC_VER >= 1200 +# define GC_ATTR_DEPRECATED __declspec(deprecated) +# else +# define GC_ATTR_DEPRECATED /* empty */ +# endif +#endif + +#if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION >= 720 +# define GC_ADD_CALLER +# define GC_RETURN_ADDR (GC_word)__return_address +#endif + +#if defined(__linux__) || defined(__GLIBC__) +# if !defined(__native_client__) +# include +# endif +# if (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 1 || __GLIBC__ > 2) \ + && !defined(__ia64__) \ + && !defined(GC_MISSING_EXECINFO_H) \ + && !defined(GC_HAVE_BUILTIN_BACKTRACE) +# define GC_HAVE_BUILTIN_BACKTRACE +# endif +# if defined(__i386__) || defined(__amd64__) || defined(__x86_64__) +# define GC_CAN_SAVE_CALL_STACKS +# endif +#endif /* GLIBC */ + +#if defined(_MSC_VER) && _MSC_VER >= 1200 /* version 12.0+ (MSVC 6.0+) */ \ + && !defined(_AMD64_) && !defined(_M_X64) && !defined(_WIN32_WCE) \ + && !defined(GC_HAVE_NO_BUILTIN_BACKTRACE) \ + && !defined(GC_HAVE_BUILTIN_BACKTRACE) +# define GC_HAVE_BUILTIN_BACKTRACE +#endif + +#if defined(GC_HAVE_BUILTIN_BACKTRACE) && !defined(GC_CAN_SAVE_CALL_STACKS) +# define GC_CAN_SAVE_CALL_STACKS +#endif + +#if defined(__sparc__) +# define GC_CAN_SAVE_CALL_STACKS +#endif + +/* If we're on a platform on which we can't save call stacks, but */ +/* gcc is normally used, we go ahead and define GC_ADD_CALLER. */ +/* We make this decision independent of whether gcc is actually being */ +/* used, in order to keep the interface consistent, and allow mixing */ +/* of compilers. */ +/* This may also be desirable if it is possible but expensive to */ +/* retrieve the call chain. */ +#if (defined(__linux__) || defined(__DragonFly__) || defined(__FreeBSD__) \ + || defined(__FreeBSD_kernel__) || defined(__HAIKU__) \ + || defined(__NetBSD__) || defined(__OpenBSD__) \ + || defined(HOST_ANDROID) || defined(__ANDROID__)) \ + && !defined(GC_CAN_SAVE_CALL_STACKS) +# define GC_ADD_CALLER +# if GC_GNUC_PREREQ(2, 95) + /* gcc knows how to retrieve return address, but we don't know */ + /* how to generate call stacks. */ +# define GC_RETURN_ADDR (GC_word)__builtin_return_address(0) +# if GC_GNUC_PREREQ(4, 0) && (defined(__i386__) || defined(__amd64__) \ + || defined(__x86_64__) /* and probably others... */) +# define GC_HAVE_RETURN_ADDR_PARENT +# define GC_RETURN_ADDR_PARENT \ + (GC_word)__builtin_extract_return_addr(__builtin_return_address(1)) +# endif +# else + /* Just pass 0 for gcc compatibility. */ +# define GC_RETURN_ADDR 0 +# endif +#endif /* !GC_CAN_SAVE_CALL_STACKS */ + +#ifdef GC_PTHREADS + +# if (defined(GC_DARWIN_THREADS) || defined(GC_WIN32_PTHREADS) \ + || defined(__native_client__) || defined(GC_RTEMS_PTHREADS)) \ + && !defined(GC_NO_DLOPEN) + /* Either there is no dlopen() or we do not need to intercept it. */ +# define GC_NO_DLOPEN +# endif + +# if (defined(GC_DARWIN_THREADS) || defined(GC_WIN32_PTHREADS) \ + || defined(GC_OPENBSD_THREADS) || defined(__native_client__)) \ + && !defined(GC_NO_PTHREAD_SIGMASK) + /* Either there is no pthread_sigmask() or no need to intercept it. */ +# define GC_NO_PTHREAD_SIGMASK +# endif + +# if defined(__native_client__) + /* At present, NaCl pthread_create() prototype does not have */ + /* "const" for its "attr" argument; also, NaCl pthread_exit() one */ + /* does not have "noreturn" attribute. */ +# ifndef GC_PTHREAD_CREATE_CONST +# define GC_PTHREAD_CREATE_CONST /* empty */ +# endif +# ifndef GC_HAVE_PTHREAD_EXIT +# define GC_HAVE_PTHREAD_EXIT +# define GC_PTHREAD_EXIT_ATTRIBUTE /* empty */ +# endif +# endif + +# if !defined(GC_HAVE_PTHREAD_EXIT) \ + && !defined(HOST_ANDROID) && !defined(__ANDROID__) \ + && (defined(GC_LINUX_THREADS) || defined(GC_SOLARIS_THREADS)) +# define GC_HAVE_PTHREAD_EXIT + /* Intercept pthread_exit on Linux and Solaris. */ +# if GC_GNUC_PREREQ(2, 7) +# define GC_PTHREAD_EXIT_ATTRIBUTE __attribute__((__noreturn__)) +# elif defined(__NORETURN) /* used in Solaris */ +# define GC_PTHREAD_EXIT_ATTRIBUTE __NORETURN +# else +# define GC_PTHREAD_EXIT_ATTRIBUTE /* empty */ +# endif +# endif + +# if (!defined(GC_HAVE_PTHREAD_EXIT) || defined(__native_client__)) \ + && !defined(GC_NO_PTHREAD_CANCEL) + /* Either there is no pthread_cancel() or no need to intercept it. */ +# define GC_NO_PTHREAD_CANCEL +# endif + +#endif /* GC_PTHREADS */ + +#ifdef __cplusplus + +#ifndef GC_ATTR_EXPLICIT +# if __cplusplus >= 201103L && !defined(__clang__) || _MSVC_LANG >= 201103L \ + || defined(CPPCHECK) +# define GC_ATTR_EXPLICIT explicit +# else +# define GC_ATTR_EXPLICIT /* empty */ +# endif +#endif + +#ifndef GC_NOEXCEPT +# if defined(__DMC__) || (defined(__BORLANDC__) \ + && (defined(_RWSTD_NO_EXCEPTIONS) || defined(_RWSTD_NO_EX_SPEC))) \ + || (defined(_MSC_VER) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS) \ + || (defined(__WATCOMC__) && !defined(_CPPUNWIND)) +# define GC_NOEXCEPT /* empty */ +# ifndef GC_NEW_ABORTS_ON_OOM +# define GC_NEW_ABORTS_ON_OOM +# endif +# elif __cplusplus >= 201103L || _MSVC_LANG >= 201103L +# define GC_NOEXCEPT noexcept +# else +# define GC_NOEXCEPT throw() +# endif +#endif + +#endif /* __cplusplus */ + +#endif diff --git a/boehm/gc/gc_disclaim.h b/boehm/gc/gc_disclaim.h new file mode 100644 index 0000000..f2942cd --- /dev/null +++ b/boehm/gc/gc_disclaim.h @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2007-2011 by Hewlett-Packard Company. All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +#ifndef GC_DISCLAIM_H +#define GC_DISCLAIM_H + +#include "gc.h" + +#ifdef __cplusplus + extern "C" { +#endif + +/* This API is defined only if the library has been suitably compiled */ +/* (i.e. with ENABLE_DISCLAIM defined). */ + +/* Prepare the object kind used by GC_finalized_malloc. Call it from */ +/* your initialization code or, at least, at some point before using */ +/* finalized allocations. The function is thread-safe. */ +GC_API void GC_CALL GC_init_finalized_malloc(void); + +/* Type of a disclaim call-back. Called with the allocation lock held. */ +typedef int (GC_CALLBACK * GC_disclaim_proc)(void * /*obj*/); + +/* Register "proc" to be called on each object of "kind" ready to be */ +/* reclaimed. If "proc" returns non-zero, the collector will not */ +/* reclaim the object on this GC cycle ("proc" should not try to */ +/* resurrect the object otherwise). Objects reachable from "proc" */ +/* (including the referred closure object) will be protected from */ +/* collection if "mark_from_all" is non-zero, but at the expense that */ +/* long chains of objects will take many cycles to reclaim. */ +/* Calls to GC_free() will free its argument without inquiring "proc". */ +/* No-op in the leak-finding mode. */ +GC_API void GC_CALL GC_register_disclaim_proc(int /*kind*/, + GC_disclaim_proc /*proc*/, + int /*mark_from_all*/) GC_ATTR_NONNULL(2); + +/* The finalizer closure used by GC_finalized_malloc. */ +struct GC_finalizer_closure { + GC_finalization_proc proc; + void *cd; +}; + +/* Allocate "size" bytes which is finalized by "fc". This uses a */ +/* dedicated object kind with a disclaim procedure, and is more */ +/* efficient than GC_register_finalizer and friends. */ +/* GC_init_finalized_malloc must be called before using this. */ +/* The collector will reclaim the object during this GC cycle (thus, */ +/* "proc" should not try to resurrect the object). The other objects */ +/* reachable from "proc" (including the closure object in case it is */ +/* a heap-allocated one) will be protected from collection. */ +/* Note that GC_size (applied to such allocated object) returns a value */ +/* slightly bigger than the specified allocation size, and that GC_base */ +/* result points to a word prior to the start of the allocated object. */ +/* The disclaim procedure is not invoked in the leak-finding mode. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_finalized_malloc(size_t /*size*/, + const struct GC_finalizer_closure * /*fc*/) GC_ATTR_NONNULL(2); + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +#endif diff --git a/boehm/gc/gc_gcj.h b/boehm/gc/gc_gcj.h new file mode 100644 index 0000000..476db22 --- /dev/null +++ b/boehm/gc/gc_gcj.h @@ -0,0 +1,110 @@ +/* + * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers + * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. + * Copyright 1996-1999 by Silicon Graphics. All rights reserved. + * Copyright 1999 by Hewlett-Packard Company. All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +/* This file assumes the collector has been compiled with GC_GCJ_SUPPORT. */ + +/* + * We allocate objects whose first word contains a pointer to a struct + * describing the object type. This struct contains a garbage collector mark + * descriptor at offset MARK_DESCR_OFFSET. Alternatively, the objects + * may be marked by the mark procedure passed to GC_init_gcj_malloc. + */ + +#ifndef GC_GCJ_H +#define GC_GCJ_H + + /* Gcj keeps GC descriptor as second word of vtable. This */ + /* probably needs to be adjusted for other clients. */ + /* We currently assume that this offset is such that: */ + /* - all objects of this kind are large enough to have */ + /* a value at that offset, and */ + /* - it is not zero. */ + /* These assumptions allow objects on the free list to be */ + /* marked normally. */ + +#ifndef GC_H +# include "gc.h" +#endif + +#ifdef __cplusplus + extern "C" { +#endif + +/* The following allocators signal an out of memory condition with */ +/* return GC_oom_fn(bytes); */ + +/* The following function must be called before the gcj allocators */ +/* can be invoked. */ +/* mp_index and mp are the index and mark_proc (see gc_mark.h) */ +/* respectively for the allocated objects. Mark_proc will be */ +/* used to build the descriptor for objects allocated through the */ +/* debugging interface. The mark_proc will be invoked on all such */ +/* objects with an "environment" value of 1. The client may choose */ +/* to use the same mark_proc for some of its generated mark descriptors.*/ +/* In that case, it should use a different "environment" value to */ +/* detect the presence or absence of the debug header. */ +/* Mp is really of type mark_proc, as defined in gc_mark.h. We don't */ +/* want to include that here for namespace pollution reasons. */ +/* Passing in mp_index here instead of having GC_init_gcj_malloc() */ +/* internally call GC_new_proc() is quite ugly, but in typical usage */ +/* scenarios a compiler also has to know about mp_index, so */ +/* generating it dynamically is not acceptable. Mp_index will */ +/* typically be an integer < RESERVED_MARK_PROCS, so that it doesn't */ +/* collide with GC_new_proc allocated indices. If the application */ +/* needs no other reserved indices, zero */ +/* (GC_GCJ_RESERVED_MARK_PROC_INDEX in gc_mark.h) is an obvious choice. */ +GC_API void GC_CALL GC_init_gcj_malloc(int /* mp_index */, + void * /* really mark_proc */ /* mp */); + +/* Allocate an object, clear it, and store the pointer to the */ +/* type structure (vtable in gcj). */ +/* This adds a byte at the end of the object if GC_malloc would.*/ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_gcj_malloc(size_t /* lb */, + void * /* ptr_to_struct_containing_descr */); + +/* The debug versions allocate such that the specified mark_proc */ +/* is always invoked. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_debug_gcj_malloc(size_t /* lb */, + void * /* ptr_to_struct_containing_descr */, + GC_EXTRA_PARAMS); + +/* Similar to GC_gcj_malloc, but assumes that a pointer to near the */ +/* beginning of the resulting object is always maintained. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_gcj_malloc_ignore_off_page(size_t /* lb */, + void * /* ptr_to_struct_containing_descr */); + +/* The kind numbers of normal and debug gcj objects. */ +/* Useful only for debug support, we hope. */ +GC_API int GC_gcj_kind; + +GC_API int GC_gcj_debug_kind; + +#ifdef GC_DEBUG +# define GC_GCJ_MALLOC(s,d) GC_debug_gcj_malloc(s,d,GC_EXTRAS) +# define GC_GCJ_MALLOC_IGNORE_OFF_PAGE(s,d) GC_debug_gcj_malloc(s,d,GC_EXTRAS) +#else +# define GC_GCJ_MALLOC(s,d) GC_gcj_malloc(s,d) +# define GC_GCJ_MALLOC_IGNORE_OFF_PAGE(s,d) GC_gcj_malloc_ignore_off_page(s,d) +#endif + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +#endif /* GC_GCJ_H */ diff --git a/boehm/gc/gc_inline.h b/boehm/gc/gc_inline.h new file mode 100644 index 0000000..d2d614c --- /dev/null +++ b/boehm/gc/gc_inline.h @@ -0,0 +1,208 @@ +/* + * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers + * Copyright (c) 1991-1995 by Xerox Corporation. All rights reserved. + * Copyright (c) 2005 Hewlett-Packard Development Company, L.P. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +#ifndef GC_INLINE_H +#define GC_INLINE_H + +/* WARNING: */ +/* Note that for these routines, it is the clients responsibility to */ +/* add the extra byte at the end to deal with one-past-the-end pointers.*/ +/* In the standard collector configuration, the collector assumes that */ +/* such a byte has been added, and hence does not trace the last word */ +/* in the resulting object. */ +/* This is not an issue if the collector is compiled with */ +/* DONT_ADD_BYTE_AT_END, or if GC_all_interior_pointers is not set. */ +/* This interface is most useful for compilers that generate C. */ +/* It is also used internally for thread-local allocation. */ +/* Manual use is hereby discouraged. */ + +#include "gc.h" +#include "gc_tiny_fl.h" + +#if GC_GNUC_PREREQ(3, 0) +# define GC_EXPECT(expr, outcome) __builtin_expect(expr,outcome) + /* Equivalent to (expr), but predict that usually (expr)==outcome. */ +#else +# define GC_EXPECT(expr, outcome) (expr) +#endif + +#ifndef GC_ASSERT +# ifdef NDEBUG +# define GC_ASSERT(expr) /* empty */ +# else +# include +# define GC_ASSERT(expr) assert(expr) +# endif +#endif + +#ifdef __cplusplus + extern "C" { +#endif + +#ifndef GC_PREFETCH_FOR_WRITE +# if GC_GNUC_PREREQ(3, 0) && !defined(GC_NO_PREFETCH_FOR_WRITE) +# define GC_PREFETCH_FOR_WRITE(x) __builtin_prefetch((x), 1) +# else +# define GC_PREFETCH_FOR_WRITE(x) (void)0 +# endif +#endif + +/* Object kinds; must match PTRFREE, NORMAL in gc_priv.h. */ +#define GC_I_PTRFREE 0 +#define GC_I_NORMAL 1 + +/* Store a pointer to a list of newly allocated objects of kind k and */ +/* size lb in *result. The caller must make sure that *result is */ +/* traced even if objects are ptrfree. */ +GC_API void GC_CALL GC_generic_malloc_many(size_t /* lb */, int /* k */, + void ** /* result */); + +/* Generalized version of GC_malloc and GC_malloc_atomic. */ +/* Uses appropriately the thread-local (if available) or the global */ +/* free-list of the specified kind. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_malloc_kind(size_t /* lb */, int /* k */); + +#ifdef GC_THREADS + /* Same as above but uses only the global free-list. */ + GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_malloc_kind_global(size_t /* lb */, int /* k */); +#else +# define GC_malloc_kind_global GC_malloc_kind +#endif + +/* An internal macro to update the free list pointer atomically (if */ +/* the AO primitives are available) to avoid race with the marker. */ +#if defined(GC_THREADS) && defined(AO_HAVE_store) +# define GC_FAST_M_AO_STORE(my_fl, next) \ + AO_store((volatile AO_t *)(my_fl), (AO_t)(next)) +#else +# define GC_FAST_M_AO_STORE(my_fl, next) (void)(*(my_fl) = (next)) +#endif + +/* The ultimately general inline allocation macro. Allocate an object */ +/* of size granules, putting the resulting pointer in result. Tiny_fl */ +/* is a "tiny" free list array, which will be used first, if the size */ +/* is appropriate. If granules is too large, we allocate with */ +/* default_expr instead. If we need to refill the free list, we use */ +/* GC_generic_malloc_many with the indicated kind. */ +/* Tiny_fl should be an array of GC_TINY_FREELISTS void * pointers. */ +/* If num_direct is nonzero, and the individual free list pointers */ +/* are initialized to (void *)1, then we allocate num_direct granules */ +/* directly using generic_malloc before putting multiple objects into */ +/* the tiny_fl entry. If num_direct is zero, then the free lists may */ +/* also be initialized to (void *)0. */ +/* Note that we use the zeroth free list to hold objects 1 granule in */ +/* size that are used to satisfy size 0 allocation requests. */ +/* We rely on much of this hopefully getting optimized away in the */ +/* num_direct = 0 case. */ +/* Particularly if granules is constant, this should generate a small */ +/* amount of code. */ +# define GC_FAST_MALLOC_GRANS(result,granules,tiny_fl,num_direct, \ + kind,default_expr,init) \ + do { \ + if (GC_EXPECT((granules) >= GC_TINY_FREELISTS,0)) { \ + result = (default_expr); \ + } else { \ + void **my_fl = (tiny_fl) + (granules); \ + void *my_entry=*my_fl; \ + void *next; \ + \ + for (;;) { \ + if (GC_EXPECT((GC_word)my_entry \ + > (num_direct) + GC_TINY_FREELISTS + 1, 1)) { \ + next = *(void **)(my_entry); \ + result = (void *)my_entry; \ + GC_FAST_M_AO_STORE(my_fl, next); \ + init; \ + GC_PREFETCH_FOR_WRITE(next); \ + if ((kind) != GC_I_PTRFREE) { \ + GC_end_stubborn_change(my_fl); \ + GC_reachable_here(next); \ + } \ + GC_ASSERT(GC_size(result) >= (granules)*GC_GRANULE_BYTES); \ + GC_ASSERT((kind) == GC_I_PTRFREE \ + || ((GC_word *)result)[1] == 0); \ + break; \ + } \ + /* Entry contains counter or NULL */ \ + if ((GC_signed_word)my_entry - (GC_signed_word)(num_direct) <= 0 \ + /* (GC_word)my_entry <= (num_direct) */ \ + && my_entry != 0 /* NULL */) { \ + /* Small counter value, not NULL */ \ + GC_FAST_M_AO_STORE(my_fl, (char *)my_entry \ + + (granules) + 1); \ + result = (default_expr); \ + break; \ + } else { \ + /* Large counter or NULL */ \ + GC_generic_malloc_many(((granules) == 0? GC_GRANULE_BYTES : \ + GC_RAW_BYTES_FROM_INDEX(granules)), \ + kind, my_fl); \ + my_entry = *my_fl; \ + if (my_entry == 0) { \ + result = (*GC_get_oom_fn())((granules)*GC_GRANULE_BYTES); \ + break; \ + } \ + } \ + } \ + } \ + } while (0) + +# define GC_WORDS_TO_WHOLE_GRANULES(n) \ + GC_WORDS_TO_GRANULES((n) + GC_GRANULE_WORDS - 1) + +/* Allocate n words (NOT BYTES). X is made to point to the result. */ +/* This should really only be used if GC_all_interior_pointers is */ +/* not set, or DONT_ADD_BYTE_AT_END is set. See above. */ +/* Does not acquire lock. The caller is responsible for supplying */ +/* a cleared tiny_fl free list array. For single-threaded */ +/* applications, this may be a global array. */ +# define GC_MALLOC_WORDS_KIND(result,n,tiny_fl,kind,init) \ + do { \ + size_t granules = GC_WORDS_TO_WHOLE_GRANULES(n); \ + GC_FAST_MALLOC_GRANS(result, granules, tiny_fl, 0, kind, \ + GC_malloc_kind(granules*GC_GRANULE_BYTES, kind), \ + init); \ + } while (0) + +# define GC_MALLOC_WORDS(result,n,tiny_fl) \ + GC_MALLOC_WORDS_KIND(result, n, tiny_fl, GC_I_NORMAL, \ + *(void **)(result) = 0) + +# define GC_MALLOC_ATOMIC_WORDS(result,n,tiny_fl) \ + GC_MALLOC_WORDS_KIND(result, n, tiny_fl, GC_I_PTRFREE, (void)0) + +/* And once more for two word initialized objects: */ +# define GC_CONS(result, first, second, tiny_fl) \ + do { \ + void *l = (void *)(first); \ + void *r = (void *)(second); \ + GC_MALLOC_WORDS_KIND(result, 2, tiny_fl, GC_I_NORMAL, (void)0); \ + if ((result) != 0 /* NULL */) { \ + *(void **)(result) = l; \ + GC_PTR_STORE_AND_DIRTY((void **)(result) + 1, r); \ + GC_reachable_here(l); \ + } \ + } while (0) + +GC_API void GC_CALL GC_print_free_list(int /* kind */, + size_t /* sz_in_granules */); + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +#endif /* !GC_INLINE_H */ diff --git a/boehm/gc/gc_mark.h b/boehm/gc/gc_mark.h new file mode 100644 index 0000000..6ff8cee --- /dev/null +++ b/boehm/gc/gc_mark.h @@ -0,0 +1,328 @@ +/* + * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. + * Copyright (c) 2001 by Hewlett-Packard Company. All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + * + */ + +/* + * This contains interfaces to the GC marker that are likely to be useful to + * clients that provide detailed heap layout information to the collector. + * This interface should not be used by normal C or C++ clients. + * It will be useful to runtimes for other languages. + * + * This is an experts-only interface! There are many ways to break the + * collector in subtle ways by using this functionality. + */ +#ifndef GC_MARK_H +#define GC_MARK_H + +#ifndef GC_H +# include "gc.h" +#endif + +#ifdef __cplusplus + extern "C" { +#endif + +/* A client supplied mark procedure. Returns new mark stack pointer. */ +/* Primary effect should be to push new entries on the mark stack. */ +/* Mark stack pointer values are passed and returned explicitly. */ +/* Global variables describing mark stack are not necessarily valid. */ +/* (This usually saves a few cycles by keeping things in registers.) */ +/* Assumed to scan about GC_PROC_BYTES on average. If it needs to do */ +/* much more work than that, it should do it in smaller pieces by */ +/* pushing itself back on the mark stack. */ +/* Note that it should always do some work (defined as marking some */ +/* objects) before pushing more than one entry on the mark stack. */ +/* This is required to ensure termination in the event of mark stack */ +/* overflows. */ +/* This procedure is always called with at least one empty entry on the */ +/* mark stack. */ +/* Currently we require that mark procedures look for pointers in a */ +/* subset of the places the conservative marker would. It must be safe */ +/* to invoke the normal mark procedure instead. */ +/* WARNING: Such a mark procedure may be invoked on an unused object */ +/* residing on a free list. Such objects are cleared, except for a */ +/* free list link field in the first word. Thus mark procedures may */ +/* not count on the presence of a type descriptor, and must handle this */ +/* case correctly somehow. */ +#define GC_PROC_BYTES 100 + +#if defined(GC_BUILD) || defined(NOT_GCBUILD) + struct GC_ms_entry; +#else + struct GC_ms_entry { void *opaque; }; +#endif +typedef struct GC_ms_entry * (*GC_mark_proc)(GC_word * /* addr */, + struct GC_ms_entry * /* mark_stack_ptr */, + struct GC_ms_entry * /* mark_stack_limit */, + GC_word /* env */); + +#define GC_LOG_MAX_MARK_PROCS 6 +#define GC_MAX_MARK_PROCS (1 << GC_LOG_MAX_MARK_PROCS) + +/* In a few cases it's necessary to assign statically known indices to */ +/* certain mark procs. Thus we reserve a few for well known clients. */ +/* (This is necessary if mark descriptors are compiler generated.) */ +#define GC_RESERVED_MARK_PROCS 8 +#define GC_GCJ_RESERVED_MARK_PROC_INDEX 0 + +/* Object descriptors on mark stack or in objects. Low order two */ +/* bits are tags distinguishing among the following 4 possibilities */ +/* for the high order 30 bits. */ +#define GC_DS_TAG_BITS 2 +#define GC_DS_TAGS ((1 << GC_DS_TAG_BITS) - 1) +#define GC_DS_LENGTH 0 /* The entire word is a length in bytes that */ + /* must be a multiple of 4. */ +#define GC_DS_BITMAP 1 /* 30 (62) bits are a bitmap describing pointer */ + /* fields. The msb is 1 if the first word */ + /* is a pointer. */ + /* (This unconventional ordering sometimes */ + /* makes the marker slightly faster.) */ + /* Zeroes indicate definite nonpointers. Ones */ + /* indicate possible pointers. */ + /* Only usable if pointers are word aligned. */ +#define GC_DS_PROC 2 + /* The objects referenced by this object can be */ + /* pushed on the mark stack by invoking */ + /* PROC(descr). ENV(descr) is passed as the */ + /* last argument. */ +#define GC_MAKE_PROC(proc_index, env) \ + (((((env) << GC_LOG_MAX_MARK_PROCS) \ + | (proc_index)) << GC_DS_TAG_BITS) | GC_DS_PROC) +#define GC_DS_PER_OBJECT 3 /* The real descriptor is at the */ + /* byte displacement from the beginning of the */ + /* object given by descr & ~GC_DS_TAGS. */ + /* If the descriptor is negative, the real */ + /* descriptor is at (*) - */ + /* (descr&~GC_DS_TAGS) - GC_INDIR_PER_OBJ_BIAS */ + /* The latter alternative can be used if each */ + /* object contains a type descriptor in the */ + /* first word. */ + /* Note that in the multi-threaded environments */ + /* per-object descriptors must be located in */ + /* either the first two or last two words of */ + /* the object, since only those are guaranteed */ + /* to be cleared while the allocation lock is */ + /* held. */ +#define GC_INDIR_PER_OBJ_BIAS 0x10 + +GC_API void * GC_least_plausible_heap_addr; +GC_API void * GC_greatest_plausible_heap_addr; + /* Bounds on the heap. Guaranteed valid */ + /* Likely to include future heap expansion. */ + /* Hence usually includes not-yet-mapped */ + /* memory. */ + +/* Handle nested references in a custom mark procedure. */ +/* Check if obj is a valid object. If so, ensure that it is marked. */ +/* If it was not previously marked, push its contents onto the mark */ +/* stack for future scanning. The object will then be scanned using */ +/* its mark descriptor. */ +/* Returns the new mark stack pointer. */ +/* Handles mark stack overflows correctly. */ +/* Since this marks first, it makes progress even if there are mark */ +/* stack overflows. */ +/* Src is the address of the pointer to obj, which is used only */ +/* for back pointer-based heap debugging. */ +/* It is strongly recommended that most objects be handled without mark */ +/* procedures, e.g. with bitmap descriptors, and that mark procedures */ +/* be reserved for exceptional cases. That will ensure that */ +/* performance of this call is not extremely performance critical. */ +/* (Otherwise we would need to inline GC_mark_and_push completely, */ +/* which would tie the client code to a fixed collector version.) */ +/* Note that mark procedures should explicitly call FIXUP_POINTER() */ +/* if required. */ +GC_API struct GC_ms_entry * GC_CALL GC_mark_and_push(void * /* obj */, + struct GC_ms_entry * /* mark_stack_ptr */, + struct GC_ms_entry * /* mark_stack_limit */, + void ** /* src */); + +#define GC_MARK_AND_PUSH(obj, msp, lim, src) \ + ((GC_word)(obj) >= (GC_word)GC_least_plausible_heap_addr && \ + (GC_word)(obj) <= (GC_word)GC_greatest_plausible_heap_addr ? \ + GC_mark_and_push(obj, msp, lim, src) : (msp)) + +/* The size of the header added to objects allocated through the */ +/* GC_debug routines. Defined as a function so that client mark */ +/* procedures do not need to be recompiled for the collector library */ +/* version changes. */ +GC_API GC_ATTR_CONST size_t GC_CALL GC_get_debug_header_size(void); +#define GC_USR_PTR_FROM_BASE(p) \ + ((void *)((char *)(p) + GC_get_debug_header_size())) + +/* The same but defined as a variable. Exists only for the backward */ +/* compatibility. Some compilers do not accept "const" together with */ +/* deprecated or dllimport attributes, so the symbol is exported as */ +/* a non-constant one. */ +GC_API GC_ATTR_DEPRECATED +# ifdef GC_BUILD + const +# endif + size_t GC_debug_header_size; + +/* And some routines to support creation of new "kinds", e.g. with */ +/* custom mark procedures, by language runtimes. */ +/* The _inner versions assume the caller holds the allocation lock. */ + +/* Return a new free list array. */ +GC_API void ** GC_CALL GC_new_free_list(void); +GC_API void ** GC_CALL GC_new_free_list_inner(void); + +/* Return a new kind, as specified. */ +GC_API unsigned GC_CALL GC_new_kind(void ** /* free_list */, + GC_word /* mark_descriptor_template */, + int /* add_size_to_descriptor */, + int /* clear_new_objects */) GC_ATTR_NONNULL(1); + /* The last two parameters must be zero or one. */ +GC_API unsigned GC_CALL GC_new_kind_inner(void ** /* free_list */, + GC_word /* mark_descriptor_template */, + int /* add_size_to_descriptor */, + int /* clear_new_objects */) GC_ATTR_NONNULL(1); + +/* Return a new mark procedure identifier, suitable for use as */ +/* the first argument in GC_MAKE_PROC. */ +GC_API unsigned GC_CALL GC_new_proc(GC_mark_proc); +GC_API unsigned GC_CALL GC_new_proc_inner(GC_mark_proc); + +/* Allocate an object of a given kind. By default, there are only */ +/* a few kinds: composite (pointerful), atomic, uncollectible, etc. */ +/* We claim it is possible for clever client code that understands the */ +/* GC internals to add more, e.g. to communicate object layout */ +/* information to the collector. Note that in the multi-threaded */ +/* contexts, this is usually unsafe for kinds that have the descriptor */ +/* in the object itself, since there is otherwise a window in which */ +/* the descriptor is not correct. Even in the single-threaded case, */ +/* we need to be sure that cleared objects on a free list don't */ +/* cause a GC crash if they are accidentally traced. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL GC_generic_malloc( + size_t /* lb */, + int /* knd */); + +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_generic_malloc_ignore_off_page( + size_t /* lb */, int /* knd */); + /* As above, but pointers to past the */ + /* first page of the resulting object */ + /* are ignored. */ + +/* Generalized version of GC_malloc_[atomic_]uncollectable. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_generic_malloc_uncollectable( + size_t /* lb */, int /* knd */); + +/* Same as above but primary for allocating an object of the same kind */ +/* as an existing one (kind obtained by GC_get_kind_and_size). */ +/* Not suitable for GCJ and typed-malloc kinds. */ +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_generic_or_special_malloc( + size_t /* size */, int /* knd */); +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_debug_generic_or_special_malloc( + size_t /* size */, int /* knd */, + GC_EXTRA_PARAMS); + +#ifdef GC_DEBUG +# define GC_GENERIC_OR_SPECIAL_MALLOC(sz, knd) \ + GC_debug_generic_or_special_malloc(sz, knd, GC_EXTRAS) +#else +# define GC_GENERIC_OR_SPECIAL_MALLOC(sz, knd) \ + GC_generic_or_special_malloc(sz, knd) +#endif /* !GC_DEBUG */ + +/* Similar to GC_size but returns object kind. Size is returned too */ +/* if psize is not NULL. */ +GC_API int GC_CALL GC_get_kind_and_size(const void *, size_t * /* psize */) + GC_ATTR_NONNULL(1); + +typedef void (GC_CALLBACK * GC_describe_type_fn)(void * /* p */, + char * /* out_buf */); + /* A procedure which */ + /* produces a human-readable */ + /* description of the "type" of object */ + /* p into the buffer out_buf of length */ + /* GC_TYPE_DESCR_LEN. This is used by */ + /* the debug support when printing */ + /* objects. */ + /* These functions should be as robust */ + /* as possible, though we do avoid */ + /* invoking them on objects on the */ + /* global free list. */ +#define GC_TYPE_DESCR_LEN 40 + +GC_API void GC_CALL GC_register_describe_type_fn(int /* kind */, + GC_describe_type_fn); + /* Register a describe_type function */ + /* to be used when printing objects */ + /* of a particular kind. */ + +/* Clear some of the inaccessible part of the stack. Returns its */ +/* argument, so it can be used in a tail call position, hence clearing */ +/* another frame. Argument may be NULL. */ +GC_API void * GC_CALL GC_clear_stack(void *); + +/* Set and get the client notifier on collections. The client function */ +/* is called at the start of every full GC (called with the allocation */ +/* lock held). May be 0. This is a really tricky interface to use */ +/* correctly. Unless you really understand the collector internals, */ +/* the callback should not, directly or indirectly, make any GC_ or */ +/* potentially blocking calls. In particular, it is not safe to */ +/* allocate memory using the garbage collector from within the callback */ +/* function. Both the setter and getter acquire the GC lock. */ +typedef void (GC_CALLBACK * GC_start_callback_proc)(void); +GC_API void GC_CALL GC_set_start_callback(GC_start_callback_proc); +GC_API GC_start_callback_proc GC_CALL GC_get_start_callback(void); + +/* Slow/general mark bit manipulation. The caller must hold the */ +/* allocation lock. GC_is_marked returns 1 (TRUE) or 0. */ +GC_API int GC_CALL GC_is_marked(const void *) GC_ATTR_NONNULL(1); +GC_API void GC_CALL GC_clear_mark_bit(const void *) GC_ATTR_NONNULL(1); +GC_API void GC_CALL GC_set_mark_bit(const void *) GC_ATTR_NONNULL(1); + +/* Push everything in the given range onto the mark stack. */ +/* (GC_push_conditional pushes either all or only dirty pages depending */ +/* on the third argument.) GC_push_all_eager also ensures that stack */ +/* is scanned immediately, not just scheduled for scanning. */ +GC_API void GC_CALL GC_push_all(void * /* bottom */, void * /* top */); +GC_API void GC_CALL GC_push_all_eager(void * /* bottom */, void * /* top */); +GC_API void GC_CALL GC_push_conditional(void * /* bottom */, void * /* top */, + int /* bool all */); +GC_API void GC_CALL GC_push_finalizer_structures(void); + +/* Set and get the client push-other-roots procedure. A client */ +/* supplied procedure should also call the original procedure. */ +/* Note that both the setter and getter require some external */ +/* synchronization to avoid data race. */ +typedef void (GC_CALLBACK * GC_push_other_roots_proc)(void); +GC_API void GC_CALL GC_set_push_other_roots(GC_push_other_roots_proc); +GC_API GC_push_other_roots_proc GC_CALL GC_get_push_other_roots(void); + +/* Walk the GC heap visiting all reachable objects. Assume the caller */ +/* holds the allocation lock. Object base pointer, object size and */ +/* client custom data are passed to the callback (holding the lock). */ +typedef void (GC_CALLBACK *GC_reachable_object_proc)(void * /* obj */, + size_t /* bytes */, + void * /* client_data */); +GC_API void GC_CALL GC_enumerate_reachable_objects_inner( + GC_reachable_object_proc, + void * /* client_data */) GC_ATTR_NONNULL(1); + +GC_API int GC_CALL GC_is_tmp_root(void *); + +GC_API void GC_CALL GC_print_trace(GC_word /* gc_no */); +GC_API void GC_CALL GC_print_trace_inner(GC_word /* gc_no */); + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +#endif /* GC_MARK_H */ diff --git a/boehm/gc/gc_pthread_redirects.h b/boehm/gc/gc_pthread_redirects.h new file mode 100644 index 0000000..b235334 --- /dev/null +++ b/boehm/gc/gc_pthread_redirects.h @@ -0,0 +1,124 @@ +/* + * Copyright (c) 1994 by Xerox Corporation. All rights reserved. + * Copyright (c) 1996 by Silicon Graphics. All rights reserved. + * Copyright (c) 1998 by Fergus Henderson. All rights reserved. + * Copyright (c) 2000-2010 by Hewlett-Packard Development Company. + * All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +/* Our pthread support normally needs to intercept a number of thread */ +/* calls. We arrange to do that here, if appropriate. */ + +#ifndef GC_PTHREAD_REDIRECTS_H +#define GC_PTHREAD_REDIRECTS_H + +/* Included from gc.h only. Included only if GC_PTHREADS. */ +#if defined(GC_H) && defined(GC_PTHREADS) + +/* We need to intercept calls to many of the threads primitives, so */ +/* that we can locate thread stacks and stop the world. */ +/* Note also that the collector cannot always see thread specific data. */ +/* Thread specific data should generally consist of pointers to */ +/* uncollectible objects (allocated with GC_malloc_uncollectable, */ +/* not the system malloc), which are deallocated using the destructor */ +/* facility in thr_keycreate. Alternatively, keep a redundant pointer */ +/* to thread specific data on the thread stack. */ + +#ifndef GC_PTHREAD_REDIRECTS_ONLY + +# include +# ifndef GC_NO_DLOPEN +# include +# endif +# ifndef GC_NO_PTHREAD_SIGMASK +# include /* needed anyway for proper redirection */ +# endif + +# ifdef __cplusplus + extern "C" { +# endif + +# ifndef GC_SUSPEND_THREAD_ID +# define GC_SUSPEND_THREAD_ID pthread_t +# endif + +# ifndef GC_NO_DLOPEN + GC_API void *GC_dlopen(const char * /* path */, int /* mode */); +# endif /* !GC_NO_DLOPEN */ + +# ifndef GC_NO_PTHREAD_SIGMASK +# if defined(GC_PTHREAD_SIGMASK_NEEDED) \ + || defined(_BSD_SOURCE) || defined(_GNU_SOURCE) \ + || (_POSIX_C_SOURCE >= 199506L) || (_XOPEN_SOURCE >= 500) + GC_API int GC_pthread_sigmask(int /* how */, const sigset_t *, + sigset_t * /* oset */); +# endif +# endif /* !GC_NO_PTHREAD_SIGMASK */ + +# ifndef GC_PTHREAD_CREATE_CONST + /* This is used for pthread_create() only. */ +# define GC_PTHREAD_CREATE_CONST const +# endif + + GC_API int GC_pthread_create(pthread_t *, + GC_PTHREAD_CREATE_CONST pthread_attr_t *, + void *(*)(void *), void * /* arg */); + GC_API int GC_pthread_join(pthread_t, void ** /* retval */); + GC_API int GC_pthread_detach(pthread_t); + +# ifndef GC_NO_PTHREAD_CANCEL + GC_API int GC_pthread_cancel(pthread_t); +# endif + +# if defined(GC_HAVE_PTHREAD_EXIT) && !defined(GC_PTHREAD_EXIT_DECLARED) +# define GC_PTHREAD_EXIT_DECLARED + GC_API void GC_pthread_exit(void *) GC_PTHREAD_EXIT_ATTRIBUTE; +# endif + +# ifdef __cplusplus + } /* extern "C" */ +# endif + +#endif /* !GC_PTHREAD_REDIRECTS_ONLY */ + +#if !defined(GC_NO_THREAD_REDIRECTS) && !defined(GC_USE_LD_WRAP) + /* Unless the compiler supports #pragma extern_prefix, the Tru64 */ + /* UNIX redefines some POSIX thread functions to use */ + /* mangled names. Anyway, it's safe to undef them before redefining. */ +# undef pthread_create +# undef pthread_join +# undef pthread_detach +# define pthread_create GC_pthread_create +# define pthread_join GC_pthread_join +# define pthread_detach GC_pthread_detach + +# ifndef GC_NO_PTHREAD_SIGMASK +# undef pthread_sigmask +# define pthread_sigmask GC_pthread_sigmask +# endif +# ifndef GC_NO_DLOPEN +# undef dlopen +# define dlopen GC_dlopen +# endif +# ifndef GC_NO_PTHREAD_CANCEL +# undef pthread_cancel +# define pthread_cancel GC_pthread_cancel +# endif +# ifdef GC_HAVE_PTHREAD_EXIT +# undef pthread_exit +# define pthread_exit GC_pthread_exit +# endif +#endif /* !GC_NO_THREAD_REDIRECTS */ + +#endif /* GC_PTHREADS */ + +#endif /* GC_PTHREAD_REDIRECTS_H */ diff --git a/boehm/gc/gc_tiny_fl.h b/boehm/gc/gc_tiny_fl.h new file mode 100644 index 0000000..0382b41 --- /dev/null +++ b/boehm/gc/gc_tiny_fl.h @@ -0,0 +1,90 @@ +/* + * Copyright (c) 1999-2005 Hewlett-Packard Development Company, L.P. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +#ifndef GC_TINY_FL_H +#define GC_TINY_FL_H +/* + * Constants and data structures for "tiny" free lists. + * These are used for thread-local allocation or in-lined allocators. + * Each global free list also essentially starts with one of these. + * However, global free lists are known to the GC. "Tiny" free lists + * are basically private to the client. Their contents are viewed as + * "in use" and marked accordingly by the core of the GC. + * + * Note that inlined code might know about the layout of these and the constants + * involved. Thus any change here may invalidate clients, and such changes should + * be avoided. Hence we keep this as simple as possible. + */ + +/* + * We always set GC_GRANULE_BYTES to twice the length of a pointer. + * This means that all allocation requests are rounded up to the next + * multiple of 16 on 64-bit architectures or 8 on 32-bit architectures. + * This appears to be a reasonable compromise between fragmentation overhead + * and space usage for mark bits (usually mark bytes). + * On many 64-bit architectures some memory references require 16-byte + * alignment, making this necessary anyway. + * For a few 32-bit architecture (e.g. x86), we may also need 16-byte alignment + * for certain memory references. But currently that does not seem to be the + * default for all conventional malloc implementations, so we ignore that + * problem. + * It would always be safe, and often useful, to be able to allocate very + * small objects with smaller alignment. But that would cost us mark bit + * space, so we no longer do so. + */ +#ifndef GC_GRANULE_BYTES + /* GC_GRANULE_BYTES should not be overridden in any instances of the GC */ + /* library that may be shared between applications, since it affects */ + /* the binary interface to the library. */ +# if defined(__LP64__) || defined (_LP64) || defined(_WIN64) \ + || defined(__s390x__) \ + || (defined(__x86_64__) && !defined(__ILP32__)) \ + || defined(__alpha__) || defined(__powerpc64__) \ + || defined(__arch64__) +# define GC_GRANULE_BYTES 16 +# define GC_GRANULE_WORDS 2 +# else +# define GC_GRANULE_BYTES 8 +# define GC_GRANULE_WORDS 2 +# endif +#endif /* !GC_GRANULE_BYTES */ + +#if GC_GRANULE_WORDS == 2 +# define GC_WORDS_TO_GRANULES(n) ((n)>>1) +#else +# define GC_WORDS_TO_GRANULES(n) ((n)*sizeof(void *)/GC_GRANULE_BYTES) +#endif + +/* A "tiny" free list header contains TINY_FREELISTS pointers to */ +/* singly linked lists of objects of different sizes, the ith one */ +/* containing objects i granules in size. Note that there is a list */ +/* of size zero objects. */ +#ifndef GC_TINY_FREELISTS +# if GC_GRANULE_BYTES == 16 +# define GC_TINY_FREELISTS 25 +# else +# define GC_TINY_FREELISTS 33 /* Up to and including 256 bytes */ +# endif +#endif /* !GC_TINY_FREELISTS */ + +/* The ith free list corresponds to size i*GC_GRANULE_BYTES */ +/* Internally to the collector, the index can be computed with */ +/* ROUNDED_UP_GRANULES. Externally, we don't know whether */ +/* DONT_ADD_BYTE_AT_END is set, but the client should know. */ + +/* Convert a free list index to the actual size of objects */ +/* on that list, including extra space we added. Not an */ +/* inverse of the above. */ +#define GC_RAW_BYTES_FROM_INDEX(i) ((i) * GC_GRANULE_BYTES) + +#endif /* GC_TINY_FL_H */ diff --git a/boehm/gc/gc_typed.h b/boehm/gc/gc_typed.h new file mode 100644 index 0000000..f91c7bc --- /dev/null +++ b/boehm/gc/gc_typed.h @@ -0,0 +1,122 @@ +/* + * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers + * Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved. + * Copyright 1996 Silicon Graphics. All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +/* + * Some simple primitives for allocation with explicit type information. + * Facilities for dynamic type inference may be added later. + * Should be used only for extremely performance critical applications, + * or if conservative collector leakage is otherwise a problem (unlikely). + * Note that this is implemented completely separately from the rest + * of the collector, and is not linked in unless referenced. + * This does not currently support GC_DEBUG in any interesting way. + */ + +#ifndef GC_TYPED_H +#define GC_TYPED_H + +#ifndef GC_H +# include "gc.h" +#endif + +#ifdef __cplusplus + extern "C" { +#endif + +typedef GC_word * GC_bitmap; + /* The least significant bit of the first word is one if */ + /* the first word in the object may be a pointer. */ + +#define GC_WORDSZ (8 * sizeof(GC_word)) +#define GC_get_bit(bm, index) \ + (((bm)[(index) / GC_WORDSZ] >> ((index) % GC_WORDSZ)) & 1) +#define GC_set_bit(bm, index) \ + ((bm)[(index) / GC_WORDSZ] |= (GC_word)1 << ((index) % GC_WORDSZ)) +#define GC_WORD_OFFSET(t, f) (offsetof(t,f) / sizeof(GC_word)) +#define GC_WORD_LEN(t) (sizeof(t) / sizeof(GC_word)) +#define GC_BITMAP_SIZE(t) ((GC_WORD_LEN(t) + GC_WORDSZ - 1) / GC_WORDSZ) + +typedef GC_word GC_descr; + +GC_API GC_descr GC_CALL GC_make_descriptor(const GC_word * /* GC_bitmap bm */, + size_t /* len (number_of_bits_in_bitmap) */); + /* Return a type descriptor for the object whose layout */ + /* is described by the argument. */ + /* The least significant bit of the first word is one */ + /* if the first word in the object may be a pointer. */ + /* The second argument specifies the number of */ + /* meaningful bits in the bitmap. The actual object */ + /* may be larger (but not smaller). Any additional */ + /* words in the object are assumed not to contain */ + /* pointers. */ + /* Returns a conservative approximation in the */ + /* (unlikely) case of insufficient memory to build */ + /* the descriptor. Calls to GC_make_descriptor */ + /* may consume some amount of a finite resource. This */ + /* is intended to be called once per type, not once */ + /* per allocation. */ + +/* It is possible to generate a descriptor for a C type T with */ +/* word aligned pointer fields f1, f2, ... as follows: */ +/* */ +/* GC_descr T_descr; */ +/* GC_word T_bitmap[GC_BITMAP_SIZE(T)] = {0}; */ +/* GC_set_bit(T_bitmap, GC_WORD_OFFSET(T,f1)); */ +/* GC_set_bit(T_bitmap, GC_WORD_OFFSET(T,f2)); */ +/* ... */ +/* T_descr = GC_make_descriptor(T_bitmap, GC_WORD_LEN(T)); */ + +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_malloc_explicitly_typed(size_t /* size_in_bytes */, + GC_descr /* d */); + /* Allocate an object whose layout is described by d. */ + /* The size may NOT be less than the number of */ + /* meaningful bits in the bitmap of d multiplied by */ + /* sizeof GC_word. The returned object is cleared. */ + /* The returned object may NOT be passed to GC_realloc. */ + +GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1) void * GC_CALL + GC_malloc_explicitly_typed_ignore_off_page(size_t /* size_in_bytes */, + GC_descr /* d */); + +GC_API GC_ATTR_MALLOC GC_ATTR_CALLOC_SIZE(1, 2) void * GC_CALL + GC_calloc_explicitly_typed(size_t /* nelements */, + size_t /* element_size_in_bytes */, + GC_descr /* d */); + /* Allocate an array of nelements elements, each of the */ + /* given size, and with the given descriptor. */ + /* The element size must be a multiple of the byte */ + /* alignment required for pointers. E.g. on a 32-bit */ + /* machine with 16-bit aligned pointers, size_in_bytes */ + /* must be a multiple of 2. The element size may NOT */ + /* be less than the number of meaningful bits in the */ + /* bitmap of d multiplied by sizeof GC_word. */ + /* Returned object is cleared. */ + +#ifdef GC_DEBUG +# define GC_MALLOC_EXPLICITLY_TYPED(bytes, d) ((void)(d), GC_MALLOC(bytes)) +# define GC_CALLOC_EXPLICITLY_TYPED(n, bytes, d) \ + ((void)(d), GC_MALLOC((n) * (bytes))) +#else +# define GC_MALLOC_EXPLICITLY_TYPED(bytes, d) \ + GC_malloc_explicitly_typed(bytes, d) +# define GC_CALLOC_EXPLICITLY_TYPED(n, bytes, d) \ + GC_calloc_explicitly_typed(n, bytes, d) +#endif + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +#endif /* GC_TYPED_H */ diff --git a/boehm/gc/gc_version.h b/boehm/gc/gc_version.h new file mode 100644 index 0000000..0e7e3a4 --- /dev/null +++ b/boehm/gc/gc_version.h @@ -0,0 +1,47 @@ +/* + * Copyright (c) 1994 by Xerox Corporation. All rights reserved. + * Copyright (c) 1996 by Silicon Graphics. All rights reserved. + * Copyright (c) 1998 by Fergus Henderson. All rights reserved. + * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. + * All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +/* This should never be included directly; it is included only from gc.h. */ +#if defined(GC_H) + +/* The policy regarding version numbers: development code has odd */ +/* "minor" number (and "micro" part is 0); when development is finished */ +/* and a release is prepared, "minor" number is incremented (keeping */ +/* "micro" number still zero), whenever a defect is fixed a new release */ +/* is prepared incrementing "micro" part to odd value (the most stable */ +/* release has the biggest "micro" number). */ + +/* The version here should match that in configure/configure.ac */ +/* Eventually this one may become unnecessary. For now we need */ +/* it to keep the old-style build process working. */ +#define GC_TMP_VERSION_MAJOR 8 +#define GC_TMP_VERSION_MINOR 1 +#define GC_TMP_VERSION_MICRO 0 /* 8.1.0 */ + +#ifdef GC_VERSION_MAJOR +# if GC_TMP_VERSION_MAJOR != GC_VERSION_MAJOR \ + || GC_TMP_VERSION_MINOR != GC_VERSION_MINOR \ + || GC_TMP_VERSION_MICRO != GC_VERSION_MICRO +# error Inconsistent version info. Check README.md, include/gc_version.h and configure.ac. +# endif +#else +# define GC_VERSION_MAJOR GC_TMP_VERSION_MAJOR +# define GC_VERSION_MINOR GC_TMP_VERSION_MINOR +# define GC_VERSION_MICRO GC_TMP_VERSION_MICRO +#endif /* !GC_VERSION_MAJOR */ + +#endif diff --git a/boehm/gc/javaxfc.h b/boehm/gc/javaxfc.h new file mode 100644 index 0000000..40ff5b7 --- /dev/null +++ b/boehm/gc/javaxfc.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 1994 by Xerox Corporation. All rights reserved. + * Copyright (c) 1996 by Silicon Graphics. All rights reserved. + * Copyright (c) 1998 by Fergus Henderson. All rights reserved. + * Copyright (c) 2000-2009 by Hewlett-Packard Development Company. + * All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +#ifndef GC_JAVAXFC_H +#define GC_JAVAXFC_H + +#ifndef GC_H +# include "gc.h" +#endif + +#ifdef __cplusplus + extern "C" { +#endif + +/* + * Invoke all remaining finalizers that haven't yet been run. (Since the + * notifier is not called, this should be called from a separate thread.) + * This function is needed for strict compliance with the Java standard, + * which can make the runtime guarantee that all finalizers are run. + * This is problematic for several reasons: + * 1) It means that finalizers, and all methods called by them, + * must be prepared to deal with objects that have been finalized in + * spite of the fact that they are still referenced by statically + * allocated pointer variables. + * 2) It may mean that we get stuck in an infinite loop running + * finalizers which create new finalizable objects, though that's + * probably unlikely. + * Thus this is not recommended for general use. + */ +GC_API void GC_CALL GC_finalize_all(void); + +#ifdef GC_THREADS + /* External thread suspension support. No thread suspension count */ + /* (so a thread which has been suspended numerous times will be */ + /* resumed with the very first call to GC_resume_thread). */ + /* Acquire the allocation lock. Thread should be registered in GC */ + /* (otherwise no-op, GC_is_thread_suspended returns false). */ + /* Unimplemented on some platforms. Not recommended for general use. */ +# ifndef GC_SUSPEND_THREAD_ID +# define GC_SUSPEND_THREAD_ID void* +# endif + GC_API void GC_CALL GC_suspend_thread(GC_SUSPEND_THREAD_ID); + GC_API void GC_CALL GC_resume_thread(GC_SUSPEND_THREAD_ID); + GC_API int GC_CALL GC_is_thread_suspended(GC_SUSPEND_THREAD_ID); +#endif /* GC_THREADS */ + +#ifdef __cplusplus + } /* extern "C" */ +#endif + +#endif /* GC_JAVAXFC_H */ diff --git a/boehm/gc/leak_detector.h b/boehm/gc/leak_detector.h new file mode 100644 index 0000000..0c27eda --- /dev/null +++ b/boehm/gc/leak_detector.h @@ -0,0 +1,68 @@ +/* + * Copyright (c) 2000-2011 by Hewlett-Packard Development Company. + * All rights reserved. + * + * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED + * OR IMPLIED. ANY USE IS AT YOUR OWN RISK. + * + * Permission is hereby granted to use or copy this program + * for any purpose, provided the above notices are retained on all copies. + * Permission to modify the code and to distribute modified code is granted, + * provided the above notices are retained, and a notice that the code was + * modified is included with the above copyright notice. + */ + +#ifndef GC_LEAK_DETECTOR_H +#define GC_LEAK_DETECTOR_H + +/* Include leak_detector.h (e.g., via GCC --include directive) */ +/* to turn BoehmGC into a Leak Detector. */ + +#ifndef GC_DEBUG +# define GC_DEBUG +#endif +#include "gc.h" + +#ifndef GC_DONT_INCLUDE_STDLIB + /* We ensure stdlib.h and string.h are included before */ + /* redirecting malloc() and the accompanying functions. */ +# include +# include +#endif + +#undef malloc +#define malloc(n) GC_MALLOC(n) +#undef calloc +#define calloc(m,n) GC_MALLOC((m)*(n)) +#undef free +#define free(p) GC_FREE(p) +#undef realloc +#define realloc(p,n) GC_REALLOC(p,n) + +#undef strdup +#define strdup(s) GC_STRDUP(s) +#undef strndup +#define strndup(s,n) GC_STRNDUP(s,n) + +#ifdef GC_REQUIRE_WCSDUP + /* The collector should be built with GC_REQUIRE_WCSDUP */ + /* defined as well to redirect wcsdup(). */ +# include +# undef wcsdup +# define wcsdup(s) GC_WCSDUP(s) +#endif + +#undef memalign +#define memalign(a,n) GC_memalign(a,n) +#undef posix_memalign +#define posix_memalign(p,a,n) GC_posix_memalign(p,a,n) + +#ifndef CHECK_LEAKS +# define CHECK_LEAKS() GC_gcollect() + /* Note 1: CHECK_LEAKS does not have GC prefix (preserved for */ + /* backward compatibility). */ + /* Note 2: GC_gcollect() is also called automatically in the */ + /* leak-finding mode at program exit. */ +#endif + +#endif /* GC_LEAK_DETECTOR_H */