+2009-09-10 Ivan Maidanski <ivmai@mail.ru>
+ (diff116a, diff116b, diff116c)
+
+ * Makefile.direct (GC_DLL): Add the comment for.
+ * doc/README.macros: Fix a typo.
+ * doc/README.macros (_DLL, GC_DLL, GC_NOT_DLL): Update info.
+ * doc/README.macros (__STDC__): Remove info.
+ * dbg_mlc.c (GC_get_back_ptr_info, GC_generate_random_heap_address,
+ GC_generate_random_valid_address, GC_print_backtrace,
+ GC_generate_random_backtrace, GC_register_describe_type_fn): Add
+ GC_API and GC_CALL to function definition.
+ * malloc.c (GC_generic_malloc): Ditto.
+ * mallocx.c (GC_incr_bytes_allocd, GC_incr_bytes_freed): Ditto.
+ * mark.c (GC_mark_and_push): Ditto.
+ * misc.c (GC_new_free_list_inner, GC_new_free_list,
+ GC_new_kind_inner, GC_new_kind, GC_new_proc_inner, GC_new_proc):
+ Ditto.
+ * include/gc_backptr.h (GC_get_back_ptr_info,
+ GC_generate_random_heap_address, GC_generate_random_valid_address,
+ GC_generate_random_backtrace, GC_print_backtrace): Add GC_API and
+ GC_CALL to function prototype.
+ * include/gc_mark.h (GC_mark_and_push, GC_new_free_list,
+ GC_new_free_list_inner, GC_new_kind, GC_new_kind_inner,
+ GC_new_proc, GC_new_proc_inner, GC_generic_malloc,
+ GC_register_describe_type_fn): Ditto.
+ * include/new_gc_alloc.h (GC_incr_bytes_allocd, GC_incr_mem_freed,
+ GC_generic_malloc_words_small): Ditto.
+ * gc_cpp.cc: Include "config.h" (if HAVE_CONFIG_H defined).
+ * include/private/gc_pmark.h: Ditto.
+ * include/private/gc_priv.h: Ditto.
+ * tests/test.c: Ditto.
+ * gc_cpp.cc: Define GC_BUILD.
+ * include/private/gc_pmark.h: Ditto.
+ * include/private/gc_priv.h: Ditto.
+ * gc_dlopen.c (WRAP_FUNC, REAL_FUNC): New macro.
+ * gc_dlopen.c (dlopen): Add GC_API to the wrapper function
+ definition.
+ * pthread_support.c (GC_pthread_create, GC_pthread_sigmask,
+ GC_pthread_join, GC_pthread_detach, pthread_sigmask, pthread_join,
+ pthread_detach, pthread_create): Ditto.
+ * win32_threads.c (GC_pthread_join, GC_pthread_create,
+ GC_pthread_sigmask, GC_pthread_detach): Ditto.
+ * gc_dlopen.c (dlopen): Use WRAP_FUNC and REAL_FUNC macros.
+ * include/gc_backptr.h: Include "gc.h".
+ * include/gc_backptr.h: Use extern "C" for the exported functions.
+ * include/gc_mark.h: Ditto.
+ * include/gc_config_macros.h (GC_THREADS): Define the macro if any
+ GC_XXX_THREADS is defined.
+ * include/gc_config_macros.h (_PTHREADS, _POSIX4A_DRAFT10_SOURCE):
+ Move the definitions below the place where GC_NETBSD_THREADS and
+ GC_DGUX386_THREADS are defined.
+ * include/gc_config_macros.h (GC_DLL): Don't define (even if _DLL
+ is defined) for GCC.
+ * include/gc_config_macros.h (GC_API): Define for Cygwin (in the
+ same way as for VC++); define for GCC v4+ (other than already
+ recognized MinGW/Cygwin) as a "default" visibility attribute if
+ GC_DLL is defined.
+ * include/gc_config_macros.h (GC_ATTR_MALLOC, GC_ATTR_ALLOC_SIZE):
+ New macro.
+ * include/gc.h (GC_malloc, GC_malloc_atomic, GC_strdup,
+ GC_malloc_uncollectable, GC_malloc_stubborn, GC_memalign,
+ GC_malloc_atomic_uncollectable, GC_malloc_ignore_off_page,
+ GC_malloc_atomic_ignore_off_page, GC_debug_malloc,
+ GC_debug_malloc_atomic, GC_debug_strdup,
+ GC_debug_malloc_uncollectable, GC_debug_malloc_stubborn,
+ GC_debug_malloc_ignore_off_page,
+ GC_debug_malloc_atomic_ignore_off_page,
+ GC_debug_malloc_replacement): Add GC_ATTR_MALLOC attribute.
+ * include/gc_gcj.h (GC_gcj_malloc, GC_debug_gcj_malloc,
+ GC_gcj_malloc_ignore_off_page): Ditto.
+ * include/gc.h (GC_malloc, GC_malloc_atomic,
+ GC_malloc_uncollectable, GC_malloc_stubborn,
+ GC_malloc_atomic_uncollectable, GC_malloc_ignore_off_page,
+ GC_malloc_atomic_ignore_off_page, GC_debug_malloc,
+ GC_debug_malloc_atomic, GC_debug_malloc_uncollectable,
+ GC_debug_malloc_stubborn, GC_debug_malloc_ignore_off_page,
+ GC_debug_malloc_atomic_ignore_off_page,
+ GC_debug_malloc_replacement: Add GC_ATTR_ALLOC_SIZE attribute
+ (for the first argument).
+ * include/gc_gcj.h (GC_gcj_malloc, GC_debug_gcj_malloc,
+ GC_gcj_malloc_ignore_off_page): Ditto.
+ * include/gc.h (GC_memalign, GC_realloc, GC_debug_realloc,
+ GC_debug_realloc_replacement): Add GC_ATTR_ALLOC_SIZE attribute
+ (for the second argument).
+ * include/gc.h (GC_malloc, GC_malloc_atomic, GC_strdup,
+ GC_malloc_uncollectable, GC_malloc_stubborn, GC_memalign,
+ GC_malloc_atomic_uncollectable, GC_free, GC_base, GC_size,
+ GC_realloc, GC_expand_hp, GC_set_max_heap_size,
+ GC_exclude_static_roots, GC_add_roots, GC_remove_roots,
+ GC_register_displacement, GC_debug_register_displacement,
+ GC_try_to_collect, GC_malloc_ignore_off_page,
+ GC_malloc_atomic_ignore_off_page, GC_debug_malloc,
+ GC_debug_malloc_atomic, GC_debug_strdup,
+ GC_debug_malloc_uncollectable, GC_debug_malloc_stubborn,
+ GC_debug_malloc_ignore_off_page,
+ GC_debug_malloc_atomic_ignore_off_page, GC_debug_free,
+ GC_debug_realloc, GC_debug_malloc_replacement,
+ GC_debug_realloc_replacement, GC_finalization_proc,
+ GC_register_finalizer, GC_debug_register_finalizer,
+ GC_register_finalizer_ignore_self,
+ GC_debug_register_finalizer_ignore_self,
+ GC_register_finalizer_no_order,
+ GC_debug_register_finalizer_no_order,
+ GC_register_finalizer_unreachable,
+ GC_debug_register_finalizer_unreachable,
+ GC_register_disappearing_link,
+ GC_general_register_disappearing_link,
+ GC_unregister_disappearing_link, GC_noop1, GC_warn_proc,
+ GC_set_warn_proc, GC_ignore_warn_proc, GC_fn_type,
+ GC_call_with_alloc_lock, GC_stack_base_func,
+ GC_call_with_stack_base, GC_same_obj, GC_pre_incr, GC_post_incr,
+ GC_is_visible, GC_is_valid_displacement, GC_same_obj_print_proc,
+ GC_is_valid_displacement_print_proc, GC_is_visible_print_proc,
+ GC_malloc_many, GC_CreateThread, GC_beginthreadex,
+ GC_endthreadex): Comment out (or remove if single and meaningless)
+ function argument names (to avoid identifiers out of the name
+ space).
+ * include/gc_gcj.h (GC_init_gcj_malloc, GC_gcj_malloc,
+ GC_debug_gcj_malloc, GC_gcj_malloc_ignore_off_page): Ditto.
+ * include/gc.h (GC_try_to_collect): Update the comment.
+ * include/gc.h (GC_size, GC_register_my_thread): Add const
+ qualifier for the argument referent.
+ * misc.c (GC_size): Ditto.
+ * pthread_support.c (GC_register_my_thread_inner,
+ GC_register_my_thread): Ditto.
+ * win32_threads.c (GC_register_my_thread_inner,
+ GC_register_my_thread): Ditto.
+ * include/gc.h (GC_INIT_CONF_ROOTS): New macro for internal use
+ (define instead of GC_INIT() for Cygwin and AIX).
+ * include/gc.h (GC_DONT_EXPAND, GC_MAX_RETRIES,
+ GC_FREE_SPACE_DIVISOR, GC_FULL_FREQ, GC_TIME_LIMIT, GC_IGNORE_WARN,
+ GC_INITIAL_HEAP_SIZE): Recognize new macro.
+ * include/gc.h (GC_INIT_CONF_DONT_EXPAND, GC_INIT_CONF_MAX_RETRIES,
+ GC_INIT_CONF_FREE_SPACE_DIVISOR, GC_INIT_CONF_FULL_FREQ,
+ GC_INIT_CONF_TIME_LIMIT, GC_INIT_CONF_IGNORE_WARN,
+ GC_INIT_CONF_INITIAL_HEAP_SIZE): New macro for internal use.
+ * include/gc.h (GC_INIT): Use GC_INIT_CONF_XXX macros.
+ * include/gc_mark.h: Prefix GC_H with '_'.
+ * include/gc_mark.h (GC_least_plausible_heap_addr,
+ GC_greatest_plausible_heap_addr, GC_debug_header_size): Use GC_API
+ for the public variable declaration.
+ * include/new_gc_alloc.h (GC_objfreelist_ptr, GC_aobjfreelist_ptr,
+ GC_uobjfreelist_ptr, GC_auobjfreelist_ptr): Ditto.
+ * include/gc_pthread_redirects.h (GC_pthread_create,
+ GC_pthread_sigmask, GC_dlopen, GC_pthread_join, GC_pthread_detach):
+ Use GC_API for the wrapper prototype.
+ * include/gc_pthread_redirects.h (pthread_create, pthread_join,
+ pthread_detach, pthread_sigmask, dlopen): Undefine unconditionally
+ before redirecting.
+ * include/new_gc_alloc.h: Replace GC_incr_mem_freed() with
+ GC_incr_bytes_freed(); remove FIXME.
+ * include/private/gc_priv.h (GC_make_closure,
+ GC_debug_invoke_finalizer, GC_noop): Remove GC_API for the private
+ function.
+ * tests/test.c (GC_print_stats): Handle GC_DLL case regardless of
+ the target.
+
2009-09-10 Ivan Maidanski <ivmai@mail.ru>
(diff115)
# specified). Reduces the number of visible symbols (letting the optimizer
# do its work better), which is probably cleaner, but may make some kinds of
# debugging and profiling harder.
+# -DGC_DLL Build dynamic-link library (or dynamic shared object).
+# For Unix this causes the exported symbols to have 'default' visibility
+# (ignored unless GCC v4+, meaningful only if used together with
+# GCC -fvisibility=hidden option).
# -DDONT_USE_USER32_DLL (Win32 only) Don't use "user32" DLL import library
# (containing MessageBox() entry); useful for a static GC library.
# -DGC_PREFER_MPROTECT_VDB Choose MPROTECT_VDB manually in case of multiple
/* 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. */
- GC_ref_kind GC_get_back_ptr_info(void *dest, void **base_p, size_t *offset_p)
+ GC_API GC_ref_kind GC_CALL GC_get_back_ptr_info(void *dest, void **base_p,
+ size_t *offset_p)
{
oh * hdr = (oh *)GC_base(dest);
ptr_t bp;
/* Generate a random heap address. */
/* The resulting address is in the heap, but */
/* not necessarily inside a valid object. */
- void *GC_generate_random_heap_address(void)
+ GC_API void * GC_CALL GC_generate_random_heap_address(void)
{
size_t i;
word heap_offset = RANDOM();
}
/* Generate a random address inside a valid marked heap object. */
- void *GC_generate_random_valid_address(void)
+ GC_API void * GC_CALL GC_generate_random_valid_address(void)
{
ptr_t result;
ptr_t base;
}
/* Print back trace for p */
- void GC_print_backtrace(void *p)
+ GC_API void GC_CALL GC_print_backtrace(void *p)
{
void *current = p;
int i;
GC_print_backtrace(current);
}
- void GC_generate_random_backtrace(void)
+ GC_API void GC_CALL GC_generate_random_backtrace(void)
{
GC_gcollect();
GC_generate_random_backtrace_no_gc();
static GC_describe_type_fn GC_describe_type_fns[MAXOBJKINDS] = {0};
-void GC_CALL GC_register_describe_type_fn(int kind, GC_describe_type_fn fn)
+GC_API void GC_CALL GC_register_describe_type_fn(int kind,
+ GC_describe_type_fn fn)
{
GC_describe_type_fns[kind] = fn;
}
ordinary "if" statements.
2) Whenever possible, tests are performed on the macros defined in gcconfig.h
-instead of directly testing patform-specific predefined macros. This makes it
+instead of directly testing platform-specific predefined macros. This makes it
relatively easy to adapt to new compilers with a different set of predefined
macros. Currently these macros generally identify platforms instead of
features. In many cases, this is a mistake.
not be defined for other compilers (at least if they behave
appreciably differently).
-_DLL Defined by Visual C++ if dynamic libraries are being built
- or used. Used to test whether __declspec(dllimport) or
- __declspec(dllexport) needs to be added to declarations
- to support the case in which the collector is in a dll.
+_DLL Defined by Visual C++ (and mingw-w64) if runtime dynamic
+ libraries are in use. Used (only if none of GC_DLL,
+ GC_NOT_DLL, __GNUC__ are defined) to test whether
+ __declspec(dllimport) needs to be added to declarations
+ to support the case in which the collector is in a DLL.
-GC_DLL User-settable macro that forces the effect of _DLL. Set
- by gc.h if _DLL is defined and GC_NOT_DLL is undefined.
+GC_DLL Defined by user if dynamic libraries are being built
+ or used. Also set by gc.h if _DLL is defined while
+ GC_NOT_DLL and __GNUC__ are both undefined.
This is the macro that is tested internally to determine
whether the GC is in its own dynamic library. May need
to be set by clients before including gc.h. Note that
GC resides in a different DLL, its entry points should
be referenced accordingly, and precautions may need to
be taken to properly deal with statically allocated
- variables in the main program. Used only for MS Windows.
-
-GC_NOT_DLL User-settable macro that overrides _DLL, e.g. if dynamic
- libraries are used, but the collector is in a static library.
-
-__STDC__ Assumed to be defined only by compilers that understand
- prototypes and other C89 features. Its value is generally
- not used, since we are fine with most nonconforming extensions.
+ variables in the main program. Used for MS Windows.
+ Also used by GCC v4+ (only when the dynamic shared library
+ is being built) in conjunction with "-fvisibility=hidden"
+ option to hide internally used symbols.
+
+GC_NOT_DLL User-settable macro that overrides _DLL, e.g. if runtime
+ dynamic libraries are used, but the collector is in a static
+ library.
SUNOS5SIGS Solaris-like signal handling. This is probably misnamed,
since it really doesn't guarantee much more than Posix.
**************************************************************************/
+# ifdef HAVE_CONFIG_H
+# include "config.h"
+# endif
+
+# ifndef GC_BUILD
+# define GC_BUILD
+# endif
+
#include <gc_cpp.h>
void* operator new( size_t size ) {
#include <dlfcn.h>
#ifdef GC_USE_LD_WRAP
- void * __wrap_dlopen(const char *path, int mode)
+# define WRAP_FUNC(f) __wrap_##f
+# define REAL_FUNC(f) __real_##f
#else
- void * GC_dlopen(const char *path, int mode)
+# define WRAP_FUNC(f) GC_##f
+# define REAL_FUNC(f) f
#endif
+
+GC_API void * WRAP_FUNC(dlopen)(const char *path, int mode)
{
void * result;
# ifndef USE_PROC_FOR_LIBRARIES
disable_gc_for_dlopen();
# endif
-# ifdef GC_USE_LD_WRAP
- result = (void *)__real_dlopen(path, mode);
-# else
- result = dlopen(path, mode);
-# endif
+ result = (void *)REAL_FUNC(dlopen)(path, mode);
# ifndef USE_PROC_FOR_LIBRARIES
GC_enable(); /* undoes disable_gc_for_dlopen */
# endif
* Note that the GC_malloc_stubborn support doesn't really
* exist anymore. MANUAL_VDB provides comparable functionality.
*/
-GC_API void * GC_CALL GC_malloc(size_t size_in_bytes);
-GC_API void * GC_CALL GC_malloc_atomic(size_t size_in_bytes);
-GC_API char * GC_CALL GC_strdup (const char *str);
-GC_API void * GC_CALL GC_malloc_uncollectable(size_t size_in_bytes);
-GC_API void * GC_CALL GC_malloc_stubborn(size_t size_in_bytes);
+GC_API void * GC_CALL GC_malloc(size_t /* size_in_bytes */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
+GC_API void * GC_CALL GC_malloc_atomic(size_t /* size_in_bytes */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
+GC_API char * GC_CALL GC_strdup(const char *) GC_ATTR_MALLOC;
+GC_API void * GC_CALL GC_malloc_uncollectable(size_t /* size_in_bytes */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
+GC_API void * GC_CALL GC_malloc_stubborn(size_t /* size_in_bytes */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
/* GC_memalign() is not well tested. */
-GC_API void * GC_CALL GC_memalign(size_t align, size_t lb);
+GC_API void * GC_CALL GC_memalign(size_t /* align */, size_t /* lb */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(2);
/* The following is only defined if the library has been suitably */
/* compiled: */
-GC_API void * GC_CALL GC_malloc_atomic_uncollectable(size_t size_in_bytes);
+GC_API void * GC_CALL GC_malloc_atomic_uncollectable(
+ size_t /* size_in_bytes */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(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 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 * object_addr);
+GC_API void GC_CALL GC_free(void *);
/*
* Stubborn objects may be changed only if the collector is explicitly informed.
/* 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);
+GC_API void * GC_CALL GC_base(void * /* displaced_pointer */);
/* 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(void * object_addr);
+GC_API size_t GC_CALL GC_size(const void * /* object_addr */);
/* For compatibility with C library. This is occasionally faster than */
/* a malloc followed by a bcopy. But if you rely on that, either here */
/* If the argument is stubborn, the result will have changes enabled. */
/* It is an error to have changes enabled for the original object. */
/* Follows ANSI conventions for NULL old_object. */
-GC_API void * GC_CALL GC_realloc(void * old_object, size_t new_size_in_bytes);
+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);
+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. */
-GC_API void GC_CALL GC_set_max_heap_size(GC_word n);
+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 */
/* mistaken for dynamic library data segments on some systems. */
/* The section (referred to by low_address) must be pointer-aligned. */
/* low_address must not be greater than high_address_plus_1. */
-GC_API void GC_CALL GC_exclude_static_roots(void * low_address,
- void * high_address_plus_1);
+GC_API void GC_CALL GC_exclude_static_roots(void * /* low_address */,
+ void * /* high_address_plus_1 */);
/* Clear the set of root segments. Wizards only. */
GC_API void GC_CALL GC_clear_roots(void);
/* Add a root segment. Wizards only. */
/* The segment (referred to by low_address) must 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);
+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);
+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 */
/* 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);
+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);
+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);
/* 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. */
+/* to start from the beginning. stop_func must not be 0. */
/* Return 0 if the collection was aborted, 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_API int GC_CALL GC_try_to_collect(GC_stop_func /* stop_func */);
/* Return the number of bytes in the heap. Excludes collector private */
/* data structures. Excludes the unmapped memory (retuned to the OS). */
/* for arrays likely to be larger than 100K 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 void * GC_CALL GC_malloc_ignore_off_page(size_t lb);
-GC_API void * GC_CALL GC_malloc_atomic_ignore_off_page(size_t lb);
+GC_API void * GC_CALL GC_malloc_ignore_off_page(size_t /* lb */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
+GC_API void * GC_CALL GC_malloc_atomic_ignore_off_page(size_t /* lb */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
#if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION >= 720
# define GC_ADD_CALLER
/* Debugging (annotated) allocation. GC_gcollect will check */
/* objects allocated in this way for overwrites, etc. */
-GC_API void * GC_CALL GC_debug_malloc(size_t size_in_bytes, GC_EXTRA_PARAMS);
-GC_API void * GC_CALL GC_debug_malloc_atomic
- (size_t size_in_bytes, GC_EXTRA_PARAMS);
-GC_API char * GC_CALL GC_debug_strdup(const char *str, GC_EXTRA_PARAMS);
+GC_API void * GC_CALL GC_debug_malloc(size_t /* size_in_bytes */,
+ GC_EXTRA_PARAMS)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
+GC_API void * GC_CALL GC_debug_malloc_atomic(size_t /* size_in_bytes */,
+ GC_EXTRA_PARAMS)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
+GC_API char * GC_CALL GC_debug_strdup(const char *,
+ GC_EXTRA_PARAMS) GC_ATTR_MALLOC;
GC_API void * GC_CALL GC_debug_malloc_uncollectable
- (size_t size_in_bytes, GC_EXTRA_PARAMS);
-GC_API void * GC_CALL GC_debug_malloc_stubborn
- (size_t size_in_bytes, GC_EXTRA_PARAMS);
+ (size_t /* size_in_bytes */, GC_EXTRA_PARAMS)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
+GC_API void * GC_CALL GC_debug_malloc_stubborn(size_t /* size_in_bytes */,
+ GC_EXTRA_PARAMS)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
GC_API void * GC_CALL GC_debug_malloc_ignore_off_page
- (size_t size_in_bytes, GC_EXTRA_PARAMS);
+ (size_t /* size_in_bytes */, GC_EXTRA_PARAMS)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
GC_API 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 * object_addr);
-GC_API void * GC_CALL GC_debug_realloc
- (void * old_object, size_t new_size_in_bytes, GC_EXTRA_PARAMS);
+ (size_t /* size_in_bytes */, GC_EXTRA_PARAMS)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
+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 void GC_CALL GC_debug_change_stubborn(void *);
GC_API void GC_CALL GC_debug_end_stubborn_change(void *);
/* 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 void * GC_CALL GC_debug_malloc_replacement (size_t size_in_bytes);
-GC_API void * GC_CALL GC_debug_realloc_replacement
- (void * object_addr, size_t size_in_bytes);
+GC_API void * GC_CALL GC_debug_malloc_replacement(size_t /* size_in_bytes */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
+GC_API void * GC_CALL GC_debug_realloc_replacement(void * /* object_addr */,
+ size_t /* size_in_bytes */)
+ /* 'realloc' attr */ GC_ATTR_ALLOC_SIZE(2);
# ifdef GC_DEBUG
# define GC_MALLOC(sz) GC_debug_malloc(sz, GC_EXTRAS)
/* 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_API void GC_CALL GC_debug_register_finalizer
- (void * obj, GC_finalization_proc fn, void * cd,
- GC_finalization_proc *ofn, void * *ocd);
+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_API void GC_CALL GC_debug_register_finalizer(void * /* obj */,
+ GC_finalization_proc /* fn */, void * /* cd */,
+ GC_finalization_proc * /* ofn */, void ** /* ocd */);
/* 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 */
/* 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_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_API void GC_CALL GC_register_finalizer_ignore_self(void * /* obj */,
+ GC_finalization_proc /* fn */, void * /* cd */,
+ GC_finalization_proc * /* ofn */, void ** /* ocd */);
+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 */);
/* 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_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_API void GC_CALL GC_register_finalizer_no_order(void * /* obj */,
+ GC_finalization_proc /* fn */, void * /* cd */,
+ GC_finalization_proc * /* ofn */, void ** /* ocd */);
+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 */);
/* This is a special finalizer that is useful when an object's */
/* finalizer must be run when the object is known to be no */
/* 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_API void GC_CALL GC_debug_register_finalizer_unreachable
- (void * obj, GC_finalization_proc fn, void * cd,
- GC_finalization_proc *ofn, void * *ocd);
+GC_API void GC_CALL GC_register_finalizer_unreachable(void * /* obj */,
+ GC_finalization_proc /* fn */, void * /* cd */,
+ GC_finalization_proc * /* ofn */, void ** /* ocd */);
+GC_API void GC_CALL GC_debug_register_finalizer_unreachable(void * /* obj */,
+ GC_finalization_proc /* fn */, void * /* cd */,
+ GC_finalization_proc * /* ofn */, void ** /* ocd */);
/* The following routine may be used to break cycles between */
/* finalizable objects, thus causing cyclic finalizable */
/* 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_API int GC_CALL GC_register_disappearing_link(void ** /* link */);
/* 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 */
/* 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,
- void * obj);
+GC_API int GC_CALL GC_general_register_disappearing_link(void ** /* link */,
+ void * /* obj */);
/* A slight generalization of the above. *link is */
/* cleared when obj first becomes inaccessible. This */
/* can be used to implement weak pointers easily and */
/* decides to reclaim the object and the link is */
/* cleared. */
-GC_API int GC_CALL GC_unregister_disappearing_link (void * * link);
+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). */
# define GC_reachable_here(ptr) \
__asm__ volatile(" " : : "X"(ptr) : "memory");
# else
- GC_API void GC_CALL GC_noop1(GC_word x);
+ GC_API void GC_CALL GC_noop1(GC_word);
# define GC_reachable_here(ptr) GC_noop1((GC_word)(ptr));
#endif
/* GC_set_warn_proc can be used to redirect or filter warning messages. */
/* p may not be a NULL pointer. Both the setter and the getter acquire */
/* the GC lock (to avoid data races). */
-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);
+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_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 *msg, GC_word arg);
+GC_API void GC_CALLBACK GC_ignore_warn_proc(char *, GC_word);
/* The following is intended to be used by a higher level */
/* (e.g. Java-like) finalization facility. It is expected */
/* allocator lock to avoid a race with the collector. */
# endif /* I_HIDE_POINTERS */
-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);
+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 */);
/* These routines are intended to explicitly notify the collector */
/* of new threads. Often this is unnecessary because thread creation */
# endif
};
-typedef void * (GC_CALLBACK * GC_stack_base_func)(struct GC_stack_base *sb,
- void *arg);
+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 base. And we */
/* implement it everywhere. */
-GC_API void * GC_CALL GC_call_with_stack_base(GC_stack_base_func fn,
- void *arg);
+GC_API void * GC_CALL GC_call_with_stack_base(GC_stack_base_func /* fn */,
+ void * /* arg */);
/* Explicitly enable GC_register_my_thread() invocation. */
/* Done implicitly if a GC thread-creation function is called (or */
#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 func anymore. */
#define GC_UNIMPLEMENTED 3 /* Not yet implemented on this platform. */
-GC_API int GC_CALL GC_register_my_thread(struct GC_stack_base *);
+GC_API int GC_CALL GC_register_my_thread(const struct GC_stack_base *);
/* Unregister the current thread. Only an explicity registered thread */
/* (i.e. for which GC_register_my_thread() returns GC_SUCCESS) is */
/* 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);
+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 * *p, ptrdiff_t how_much);
-GC_API void * GC_CALL GC_post_incr (void * *p, ptrdiff_t how_much);
+GC_API void * GC_CALL GC_pre_incr(void **, ptrdiff_t /* how_much */);
+GC_API void * GC_CALL GC_post_incr(void **, ptrdiff_t /* how_much */);
/* Check that p is visible */
/* to the collector as a possibly pointer containing location. */
/* 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 multithreaded worlds. */
-GC_API void * GC_CALL GC_is_visible (void * p);
+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);
+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, */
#endif
/* 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 * p);
-
-GC_API void (GC_CALLBACK * GC_is_visible_print_proc) (void * p);
-
+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 *);
/* For pthread support, we generally need to intercept a number of */
/* thread library calls. We do that here by macro defining them. */
/* 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 void * GC_CALL GC_malloc_many(size_t lb);
+GC_API void * GC_CALL GC_malloc_many(size_t /* lb */);
#define GC_NEXT(p) (*(void * *)(p)) /* Retrieve the next element */
/* in returned list. */
* so that the thread is properly unregistered.
*/
GC_API HANDLE WINAPI GC_CreateThread(
- LPSECURITY_ATTRIBUTES lpThreadAttributes,
- DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress,
- LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId );
+ LPSECURITY_ATTRIBUTES /* lpThreadAttributes */,
+ DWORD /* dwStackSize */,
+ LPTHREAD_START_ROUTINE /* lpStartAddress */,
+ LPVOID /* lpParameter */, DWORD /* dwCreationFlags */,
+ LPDWORD /* lpThreadId */);
GC_API void WINAPI GC_ExitThread(DWORD /* dwExitCode */);
# endif
GC_API GC_uintptr_t GC_CALL GC_beginthreadex(
- void *security, unsigned stack_size,
- unsigned ( __stdcall *start_address )( void * ),
- void *arglist, unsigned initflag, unsigned *thrdaddr);
+ void * /* security */, unsigned /* stack_size */,
+ unsigned (__stdcall *)(void *),
+ void * /* arglist */, unsigned /* initflag */,
+ unsigned * /* thrdaddr */);
- GC_API void GC_CALL GC_endthreadex(unsigned retval);
+ GC_API void GC_CALL GC_endthreadex(unsigned /* retval */);
# else
/* win32_threads.c implements the real WinMain, which will start */
* defined and the initial allocation call is not to GC_malloc() or
* GC_malloc_atomic().
*/
-#if defined(__CYGWIN32__) || defined (_AIX)
+
/*
* Similarly gnu-win32 DLLs need explicit initialization from
* the main program, as does AIX.
*/
-# ifdef __CYGWIN32__
+#ifdef __CYGWIN32__
extern int _data_start__[];
extern int _data_end__[];
extern int _bss_start__[];
# define GC_MIN(x,y) ((x) < (y) ? (x) : (y))
# define GC_DATASTART ((void *) GC_MIN(_data_start__, _bss_start__))
# define GC_DATAEND ((void *) GC_MAX(_data_end__, _bss_end__))
-# define GC_INIT() { GC_add_roots(GC_DATASTART, GC_DATAEND); \
- GC_gcollect(); /* For blacklisting. */}
+# define GC_INIT_CONF_ROOTS GC_add_roots(GC_DATASTART, GC_DATAEND); \
+ GC_gcollect() /* For blacklisting. */
/* Required at least if GC is in dll. And doesn't hurt. */
-# endif
-# if defined(_AIX)
+#elif defined(_AIX)
extern int _data[], _end[];
# define GC_DATASTART ((void *)((ulong)_data))
# define GC_DATAEND ((void *)((ulong)_end))
-# define GC_INIT() { GC_add_roots(GC_DATASTART, GC_DATAEND); }
-# endif
+# define GC_INIT_CONF_ROOTS GC_add_roots(GC_DATASTART, GC_DATAEND)
+#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_MAX_RETRIES
+ /* 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
+
+#ifdef GC_FREE_SPACE_DIVISOR
+ /* 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
+
+#ifdef GC_FULL_FREQ
+ /* 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
+
+#ifdef GC_TIME_LIMIT
+ /* Set GC_time_limit to the desired value at start-up */
+# define GC_INIT_CONF_TIME_LIMIT GC_set_time_limit(GC_TIME_LIMIT)
#else
-# define GC_INIT() { GC_init(); }
+# define GC_INIT_CONF_TIME_LIMIT /* 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
+
+#ifdef GC_INITIAL_HEAP_SIZE
+ /* 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
+
+#define GC_INIT() { GC_INIT_CONF_DONT_EXPAND; /* pre-init */ \
+ GC_INIT_CONF_MAX_RETRIES; \
+ GC_INIT_CONF_FREE_SPACE_DIVISOR; \
+ GC_INIT_CONF_FULL_FREQ; \
+ GC_INIT_CONF_TIME_LIMIT; \
+ 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. */
GC_API void GC_CALL GC_win32_free_heap(void);
#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 */
GC_FINALIZER_REFD /* Finalizable and hence accessible. */
} GC_ref_kind;
-GC_ref_kind GC_get_back_ptr_info(void *dest, void **base_p, size_t *offset_p);
+GC_API GC_ref_kind GC_CALL GC_get_back_ptr_info(void *dest, void **base_p,
+ size_t *offset_p);
/* Generate a random heap address. */
/* The resulting address is in the heap, but */
/* not necessarily inside a valid object. */
-void * GC_generate_random_heap_address(void);
+GC_API void * GC_CALL GC_generate_random_heap_address(void);
/* Generate a random address inside a valid marked heap object. */
-void * GC_generate_random_valid_address(void);
+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. */
-void GC_generate_random_backtrace(void);
+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. */
-void GC_print_backtrace(void *);
+GC_API void GC_CALL GC_print_backtrace(void *);
+
+# ifdef __cplusplus
+ } /* end of extern "C" */
+# endif
#endif /* GC_BACKPTR_H */
# define GC_USE_LD_WRAP
#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
+#if !defined(GC_THREADS) && \
+ (defined(GC_SOLARIS_THREADS) || defined(GC_IRIX_THREADS) || \
+ defined(GC_DGUX386_THREADS) || defined(GC_AIX_THREADS) || \
+ defined(GC_HPUX_THREADS) || defined(GC_OSF1_THREADS) || \
+ defined(GC_LINUX_THREADS) || defined(GC_WIN32_THREADS))
+# define GC_THREADS
#endif
# if defined(GC_SOLARIS_THREADS) || defined(GC_FREEBSD_THREADS) || \
# endif
#endif /* GC_THREADS */
+#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_SOLARIS_THREADS) \
|| defined(GC_HPUX_THREADS) \
|| defined(GC_AIX_THREADS) \
# endif
# endif
-#if defined(_DLL) && !defined(GC_NOT_DLL) && !defined(GC_DLL)
+#if defined(_DLL) && !defined(GC_NOT_DLL) && !defined(GC_DLL) \
+ && !defined(__GNUC__)
# define GC_DLL
#endif
# endif
#endif
-#if (defined(__DMC__) || defined(_MSC_VER) || defined(__BORLANDC__)) \
- && defined(GC_DLL)
+#if (defined(__DMC__) || defined(_MSC_VER) || defined(__BORLANDC__) \
+ || defined(__CYGWIN__)) && defined(GC_DLL)
# ifdef GC_BUILD
# define GC_API extern __declspec(dllexport)
# else
# endif
#endif
+#if defined(__GNUC__) && defined(GC_DLL) && !defined(GC_API)
+ /* Only matters if used in conjunction with -fvisibility=hidden option. */
+# if __GNUC__ >= 4 && defined(GC_BUILD)
+# define GC_API extern __attribute__((__visibility__("default")))
+# endif
+#endif
+
#ifndef GC_API
# define GC_API extern
#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. */
+# if !defined(GC_OOM_FUNC_RETURNS_ALIAS) && defined(__GNUC__) \
+ && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+# define GC_ATTR_MALLOC __attribute__((__malloc__))
+# else
+# define GC_ATTR_MALLOC
+# endif
+#endif
+
+#ifndef GC_ATTR_ALLOC_SIZE
+ /* 'alloc_size' attribute improves __builtin_object_size correctness. */
+ /* Only single-argument form of 'alloc_size' attribute is used. */
+# if defined(__GNUC__) && (__GNUC__ > 4 \
+ || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3 && !defined(__ICC)))
+# define GC_ATTR_ALLOC_SIZE(argnum) __attribute__((__alloc_size__(argnum)))
+# else
+# define GC_ATTR_ALLOC_SIZE(argnum)
+# endif
+#endif
/* 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);
+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 void * GC_CALL GC_gcj_malloc(size_t lb,
- void * ptr_to_struct_containing_descr);
+GC_API void * GC_CALL GC_gcj_malloc(size_t /* lb */,
+ void * /* ptr_to_struct_containing_descr */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
/* The debug versions allocate such that the specified mark_proc */
/* is always invoked. */
-GC_API void * GC_CALL GC_debug_gcj_malloc(size_t lb,
- void * ptr_to_struct_containing_descr,
- GC_EXTRA_PARAMS);
+GC_API void * GC_CALL GC_debug_gcj_malloc(size_t /* lb */,
+ void * /* ptr_to_struct_containing_descr */,
+ GC_EXTRA_PARAMS)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
/* Similar to GC_gcj_malloc, but assumes that a pointer to near the */
/* beginning of the resulting object is always maintained. */
-GC_API void * GC_CALL GC_gcj_malloc_ignore_off_page(size_t lb,
- void * ptr_to_struct_containing_descr);
+GC_API void * GC_CALL GC_gcj_malloc_ignore_off_page(size_t /* lb */,
+ void * /* ptr_to_struct_containing_descr */)
+ GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1);
/* The kind numbers of normal and debug gcj objects. */
/* Useful only for debug support, we hope. */
#ifndef GC_MARK_H
# define GC_MARK_H
-# ifndef GC_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. */
/* held. */
#define GC_INDIR_PER_OBJ_BIAS 0x10
-extern void * GC_least_plausible_heap_addr;
-extern void * GC_greatest_plausible_heap_addr;
+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 */
/* which would tie the client code to a fixed collector version.) */
/* Note that mark procedures should explicitly call FIXUP_POINTER() */
/* if required. */
-struct GC_ms_entry *GC_mark_and_push(void * obj,
+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);
GC_mark_and_push(obj, msp, lim, src) : \
msp)
-extern size_t GC_debug_header_size;
+GC_API size_t GC_debug_header_size;
/* The size of the header added to objects allocated through */
/* the GC_debug routines. */
/* Defined as a variable so that client mark procedures don't */
/* The _inner versions assume the caller holds the allocation lock. */
/* Return a new free list array. */
-void ** GC_new_free_list(void);
-void ** GC_new_free_list_inner(void);
+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. */
-unsigned GC_new_kind(void **free_list, GC_word mark_descriptor_template,
- int add_size_to_descriptor, int clear_new_objects);
+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);
/* The last two parameters must be zero or one. */
-unsigned GC_new_kind_inner(void **free_list,
+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);
/* Return a new mark procedure identifier, suitable for use as */
/* the first argument in GC_MAKE_PROC. */
-unsigned GC_new_proc(GC_mark_proc);
-unsigned GC_new_proc_inner(GC_mark_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. Note that in multithreaded */
/* contexts, this is usually unsafe for kinds that have the descriptor */
/* 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. */
-void * GC_generic_malloc(size_t lb, int k);
+GC_API void * GC_CALL GC_generic_malloc(size_t lb, int k);
typedef void (GC_CALLBACK * GC_describe_type_fn) (void *p, char *out_buf);
/* A procedure which */
/* global free list. */
# define GC_TYPE_DESCR_LEN 40
-void GC_CALL GC_register_describe_type_fn(int kind, GC_describe_type_fn knd);
+GC_API void GC_CALL GC_register_describe_type_fn(int kind,
+ GC_describe_type_fn knd);
/* Register a describe_type function */
/* to be used when printing objects */
/* of a particular kind. */
+# ifdef __cplusplus
+ } /* end of extern "C" */
+# endif
+
#endif /* GC_MARK_H */
# include <dlfcn.h>
# endif
- int GC_pthread_create(pthread_t *new_thread,
- const pthread_attr_t *attr,
- void *(*start_routine)(void *), void *arg);
+GC_API int GC_pthread_create(pthread_t *, const pthread_attr_t *,
+ void *(*)(void *), void * /* arg */);
#ifndef GC_DARWIN_THREADS
- int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset);
- void *GC_dlopen(const char *path, int mode);
-#endif
- int GC_pthread_join(pthread_t thread, void **retval);
- int GC_pthread_detach(pthread_t thread);
-
-#if defined(GC_OSF1_THREADS) \
- && defined(_PTHREAD_USE_MANGLED_NAMES_) && !defined(_PTHREAD_USE_PTDNAM_)
-/* Unless the compiler supports #pragma extern_prefix, the Tru64 UNIX
- <pthread.h> redefines some POSIX thread functions to use mangled names.
- If so, undef them before redefining. */
-# undef pthread_create
-# undef pthread_join
-# undef pthread_detach
+ GC_API int GC_pthread_sigmask(int /* how */, const sigset_t *,
+ sigset_t * /* oset */);
+ GC_API void *GC_dlopen(const char * /* path */, int /* mode */);
#endif
+GC_API int GC_pthread_join(pthread_t, void ** /* retval */);
+GC_API int GC_pthread_detach(pthread_t);
+
+/* Unless the compiler supports #pragma extern_prefix, the Tru64 UNIX */
+/* <pthread.h> 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
+#define pthread_create GC_pthread_create
+#define pthread_join GC_pthread_join
+#define pthread_detach GC_pthread_detach
#ifndef GC_DARWIN_THREADS
-# ifdef pthread_sigmask
-# undef pthread_sigmask
-# endif /* pthread_sigmask */
+# undef pthread_sigmask
+# undef dlopen
# define pthread_sigmask GC_pthread_sigmask
-# ifdef dlopen
-# undef dlopen
-# endif
# define dlopen GC_dlopen
#endif
// This should eventually be factored out into another include file.
extern "C" {
- extern void ** const GC_objfreelist_ptr;
- extern void ** const GC_aobjfreelist_ptr;
- extern void ** const GC_uobjfreelist_ptr;
- extern void ** const GC_auobjfreelist_ptr;
+ GC_API void ** const GC_objfreelist_ptr;
+ GC_API void ** const GC_aobjfreelist_ptr;
+ GC_API void ** const GC_uobjfreelist_ptr;
+ GC_API void ** const GC_auobjfreelist_ptr;
- extern void GC_incr_bytes_allocd(size_t bytes);
- extern void GC_incr_mem_freed(size_t words); /* FIXME: use bytes */
+ GC_API void GC_CALL GC_incr_bytes_allocd(size_t bytes);
+ GC_API void GC_CALL GC_incr_bytes_freed(size_t bytes);
- extern char * GC_generic_malloc_words_small(size_t word, int kind);
+ GC_API char * GC_CALL GC_generic_malloc_words_small(size_t word, int kind);
/* FIXME: Doesn't exist anymore. */
}
GC_incr_bytes_allocd(GC_bytes_recently_allocd);
GC_bytes_recently_allocd = 0;
- GC_incr_mem_freed(GC_bytes_per_word(GC_bytes_recently_freed));
+ GC_incr_bytes_freed(GC_bytes_recently_freed);
GC_bytes_recently_freed = 0;
return GC_generic_malloc_words_small(nwords, kind);
#ifndef GC_PMARK_H
# define GC_PMARK_H
+# ifdef HAVE_CONFIG_H
+# include "config.h"
+# endif
+
+# ifndef GC_BUILD
+# define GC_BUILD
+# endif
+
# if defined(KEEP_BACK_PTRS) || defined(PRINT_BLACK_LIST)
# include "dbg_mlc.h"
# endif
# ifndef GC_PRIVATE_H
# define GC_PRIVATE_H
+# ifdef HAVE_CONFIG_H
+# include "config.h"
+# endif
+
+# ifndef GC_BUILD
+# define GC_BUILD
+# endif
+
# include <stdlib.h>
# if !(defined( sony_news ) )
# include <stddef.h>
/* finalizers to be run, and we haven't called */
/* this procedure yet this GC cycle. */
-GC_API void * GC_make_closure(GC_finalization_proc fn, void * data);
-GC_API void GC_CALLBACK GC_debug_invoke_finalizer(void * obj, void * data);
+void * GC_make_closure(GC_finalization_proc fn, void * data);
+void GC_CALLBACK GC_debug_invoke_finalizer(void * obj, void * data);
/* Auxiliary fns to make finalization work */
/* correctly with displaced pointers introduced */
/* by the debugging allocators. */
void GC_noop(void*, ...);
# else
# ifdef __DMC__
- GC_API void GC_noop(...);
+ void GC_noop(...);
# else
- GC_API void GC_noop();
+ void GC_noop();
# endif
# endif
return op;
}
-void * GC_generic_malloc(size_t lb, int k)
+GC_API void * GC_CALL GC_generic_malloc(size_t lb, int k)
{
void * result;
DCL_LOCK_STATE;
/* Increment GC_bytes_allocd from code that doesn't have direct access */
/* to GC_arrays. */
-void GC_incr_bytes_allocd(size_t n)
+GC_API void GC_CALL GC_incr_bytes_allocd(size_t n)
{
GC_bytes_allocd += n;
}
/* The same for GC_bytes_freed. */
-void GC_incr_bytes_freed(size_t n)
+GC_API void GC_CALL GC_incr_bytes_freed(size_t n)
{
GC_bytes_freed += n;
}
}
/*ARGSUSED*/
-struct GC_ms_entry *GC_mark_and_push(void *obj,
+GC_API struct GC_ms_entry * GC_CALL GC_mark_and_push(void *obj,
mse *mark_stack_ptr,
mse *mark_stack_limit,
void **src)
/* Return the size of an object, given a pointer to its base. */
/* (For small objects this also happens to work from interior pointers, */
/* but that shouldn't be relied upon.) */
-GC_API size_t GC_CALL GC_size(void * p)
+GC_API size_t GC_CALL GC_size(const void * p)
{
hdr * hhdr = HDR(p);
}
/* Helper procedures for new kind creation. */
-void ** GC_new_free_list_inner(void)
+GC_API void ** GC_CALL GC_new_free_list_inner(void)
{
void *result = GC_INTERNAL_MALLOC((MAXOBJGRANULES+1)*sizeof(ptr_t),
PTRFREE);
return result;
}
-void ** GC_new_free_list(void)
+GC_API void ** GC_CALL GC_new_free_list(void)
{
void *result;
LOCK();
return result;
}
-unsigned GC_new_kind_inner(void **fl, GC_word descr, int adjust, int clear)
+GC_API unsigned GC_CALL GC_new_kind_inner(void **fl, GC_word descr,
+ int adjust, int clear)
{
unsigned result = GC_n_kinds++;
return result;
}
-unsigned GC_new_kind(void **fl, GC_word descr, int adjust, int clear)
+GC_API unsigned GC_CALL GC_new_kind(void **fl, GC_word descr, int adjust,
+ int clear)
{
unsigned result;
LOCK();
return result;
}
-unsigned GC_new_proc_inner(GC_mark_proc proc)
+GC_API unsigned GC_CALL GC_new_proc_inner(GC_mark_proc proc)
{
unsigned result = GC_n_mark_procs++;
return result;
}
-unsigned GC_new_proc(GC_mark_proc proc)
+GC_API unsigned GC_CALL GC_new_proc(GC_mark_proc proc)
{
unsigned result;
LOCK();
/* Define GC_ functions as aliases for the plain ones, which will */
/* be intercepted. This allows files which include gc.h, and hence */
/* generate references to the GC_ symbols, to see the right symbols. */
- int GC_pthread_create(pthread_t * t, const pthread_attr_t * a,
+ GC_API int GC_pthread_create(pthread_t * t, const pthread_attr_t * a,
void * (* fn)(void *), void * arg) {
return pthread_create(t, a, fn, arg);
}
- int GC_pthread_sigmask(int how, const sigset_t *mask, sigset_t *old) {
+ GC_API int GC_pthread_sigmask(int how, const sigset_t *mask,
+ sigset_t *old) {
return pthread_sigmask(how, mask, old);
}
- int GC_pthread_join(pthread_t t, void **res) {
+ GC_API int GC_pthread_join(pthread_t t, void **res) {
return pthread_join(t, res);
}
- int GC_pthread_detach(pthread_t t) {
+ GC_API int GC_pthread_detach(pthread_t t) {
return pthread_detach(t);
}
#endif /* Linker-based interception. */
#if !defined(GC_DARWIN_THREADS)
-int WRAP_FUNC(pthread_sigmask)(int how, const sigset_t *set, sigset_t *oset)
+GC_API int WRAP_FUNC(pthread_sigmask)(int how, const sigset_t *set,
+ sigset_t *oset)
{
sigset_t fudged_set;
GC_unregister_my_thread();
}
-int WRAP_FUNC(pthread_join)(pthread_t thread, void **retval)
+GC_API int WRAP_FUNC(pthread_join)(pthread_t thread, void **retval)
{
int result;
GC_thread thread_gc_id;
return result;
}
-int
-WRAP_FUNC(pthread_detach)(pthread_t thread)
+GC_API int WRAP_FUNC(pthread_detach)(pthread_t thread)
{
int result;
GC_thread thread_gc_id;
GC_bool GC_in_thread_creation = FALSE; /* Protected by allocation lock. */
-STATIC GC_thread GC_register_my_thread_inner(struct GC_stack_base *sb,
+STATIC GC_thread GC_register_my_thread_inner(const struct GC_stack_base *sb,
pthread_t my_pthread)
{
GC_thread me;
GC_need_to_lock = TRUE; /* We are multi-threaded now. */
}
-GC_API int GC_CALL GC_register_my_thread(struct GC_stack_base *sb)
+GC_API int GC_CALL GC_register_my_thread(const struct GC_stack_base *sb)
{
pthread_t my_pthread = pthread_self();
GC_thread me;
# endif
}
-int
-WRAP_FUNC(pthread_create)(pthread_t *new_thread,
+GC_API int WRAP_FUNC(pthread_create)(pthread_t *new_thread,
const pthread_attr_t *attr,
void *(*start_routine)(void *), void *arg)
{
/* GC. It uses GC internals to allow more precise results */
/* checking for some of the tests. */
+# ifdef HAVE_CONFIG_H
+# include "config.h"
+# endif
+
# undef GC_BUILD
#ifndef NTHREADS /* Number of additional threads to fork. */
# if defined(MSWIN32) || defined(MSWINCE)
# include <windows.h>
-# ifdef GC_DLL
-# define GC_print_stats 0 /* Not exported from DLL */
+# endif
+
+# ifdef GC_DLL
+# define GC_print_stats 0 /* Not exported from DLL */
/* Redefine to 1 to generate output. */
-# endif
# endif
# ifdef PCR
* If GC_win32_dll_threads is not set, we already hold the allocation lock,
* except possibly during single-threaded start-up code.
*/
-static GC_thread GC_register_my_thread_inner(struct GC_stack_base *sb,
+static GC_thread GC_register_my_thread_inner(const struct GC_stack_base *sb,
DWORD thread_id)
{
GC_vthread me;
GC_need_to_lock = TRUE; /* We are multi-threaded now. */
}
-GC_API int GC_CALL GC_register_my_thread(struct GC_stack_base *sb) {
+GC_API int GC_CALL GC_register_my_thread(const struct GC_stack_base *sb) {
DWORD t = GetCurrentThreadId();
if (GC_need_to_lock == FALSE)
GC_bool detached;
};
-int GC_pthread_join(pthread_t pthread_id, void **retval) {
+GC_API int GC_pthread_join(pthread_t pthread_id, void **retval) {
int result;
GC_thread joinee;
* easily interceptible by us..
* so intercept pthread_create instead
*/
-int
-GC_pthread_create(pthread_t *new_thread,
+GC_API int GC_pthread_create(pthread_t *new_thread,
const pthread_attr_t *attr,
void *(*start_routine)(void *), void *arg) {
int result;
#ifndef GC_WIN32_PTHREADS
/* win32 pthread does not support sigmask */
/* nothing required here... */
-int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) {
+GC_API int GC_pthread_sigmask(int how, const sigset_t *set, sigset_t *oset) {
if (!parallel_initialized) GC_init_parallel();
return pthread_sigmask(how, set, oset);
}
#endif
-int GC_pthread_detach(pthread_t thread)
+GC_API int GC_pthread_detach(pthread_t thread)
{
int result;
GC_thread thread_gc_id;
projects / gc / commitdiff