path: root/v_windows/v/old/thirdparty/libgc/gc.c

/*
 * 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) 2009-2018 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.
 */

#ifndef __cplusplus
#define GC_INNER STATIC
#define GC_EXTERN GC_INNER
#endif
#ifndef GC_DBG_MLC_H
#define GC_DBG_MLC_H
#ifndef GC_PRIVATE_H
#define GC_PRIVATE_H
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if!defined(GC_BUILD)&&!defined(NOT_GCBUILD)
#define GC_BUILD
#endif
#if (defined(__linux__)||defined(__GLIBC__)||defined(__GNU__)||(defined(__CYGWIN__)&&(defined(GC_THREADS)||!defined(USE_MMAP))))&&!defined(_GNU_SOURCE)
#define _GNU_SOURCE 1
#endif
#if defined(__INTERIX)&&!defined(_ALL_SOURCE)
#define _ALL_SOURCE 1
#endif
#if (defined(DGUX)&&defined(GC_THREADS)||defined(DGUX386_THREADS)||defined(GC_DGUX386_THREADS))&&!defined(_USING_POSIX4A_DRAFT10)
#define _USING_POSIX4A_DRAFT10 1
#endif
#if defined(__MINGW32__)&&!defined(__MINGW_EXCPT_DEFINE_PSDK)&&defined(__i386__)&&defined(GC_EXTERN)
#define __MINGW_EXCPT_DEFINE_PSDK 1
#endif
#if defined(NO_DEBUGGING)&&!defined(GC_ASSERTIONS)&&!defined(NDEBUG)
#define NDEBUG 1
#endif
#ifndef GC_H
#ifndef GC_H
#define GC_H
#if (defined(WIN64)&&!defined(_WIN64))&&defined(_MSC_VER)
#pragma message("Warning:Expecting _WIN64 for x64 targets!Notice the leading underscore!")
#endif
#if defined(GC_H)
#define GC_TMP_VERSION_MAJOR 8
#define GC_TMP_VERSION_MINOR 1
#define GC_TMP_VERSION_MICRO 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
#endif
#if defined(GC_H)
#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
#endif
#if defined(SOLARIS_THREADS)||defined(_SOLARIS_THREADS)||defined(_SOLARIS_PTHREADS)||defined(GC_SOLARIS_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)
#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(__OpenBSD__)
#define GC_OPENBSD_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(__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__)
#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)||((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)
#define GC_WIN32_THREADS
#endif
#if defined(__rtems__)&&(defined(i386)||defined(__i386__))
#define GC_RTEMS_PTHREADS
#endif
#endif
#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)
#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)
#define _REENTRANT 1
#endif
#define __GC
#if!defined(_WIN32_WCE)||defined(__GNUC__)
#include <stddef.h>
#if defined(__MINGW32__)&&!defined(_WIN32_WCE)
#include <stdint.h>
#endif
#else
#include <stdlib.h>
#ifndef _PTRDIFF_T_DEFINED
#define _PTRDIFF_T_DEFINED
typedef long ptrdiff_t;
#endif
#endif
#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__)
#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
#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
#ifdef GC_OOM_FUNC_RETURNS_ALIAS
#define GC_ATTR_MALLOC
#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
#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)
#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)
#endif
#endif
#ifndef GC_ATTR_CALLOC_SIZE
#define GC_ATTR_CALLOC_SIZE(n,s)
#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)
#endif
#endif
#ifndef GC_ATTR_CONST
#if GC_GNUC_PREREQ(4,0)
#define GC_ATTR_CONST __attribute__((__const__))
#else
#define GC_ATTR_CONST
#endif
#endif
#ifndef GC_ATTR_DEPRECATED
#ifdef GC_BUILD
#undef GC_ATTR_DEPRECATED
#define GC_ATTR_DEPRECATED
#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
#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 <features.h>
#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
#if defined(_MSC_VER)&&_MSC_VER>=1200&&!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 (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)
#define GC_RETURN_ADDR (GC_word)__builtin_return_address(0)
#if GC_GNUC_PREREQ(4,0)&&(defined(__i386__)||defined(__amd64__)||defined(__x86_64__))
#define GC_HAVE_RETURN_ADDR_PARENT
#define GC_RETURN_ADDR_PARENT (GC_word)__builtin_extract_return_addr(__builtin_return_address(1))
#endif
#else
#define GC_RETURN_ADDR 0
#endif
#endif
#ifdef GC_PTHREADS
#if (defined(GC_DARWIN_THREADS)||defined(GC_WIN32_PTHREADS)||defined(__native_client__)||defined(GC_RTEMS_PTHREADS))&&!defined(GC_NO_DLOPEN)
#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)
#define GC_NO_PTHREAD_SIGMASK
#endif
#if defined(__native_client__)
#ifndef GC_PTHREAD_CREATE_CONST
#define GC_PTHREAD_CREATE_CONST
#endif
#ifndef GC_HAVE_PTHREAD_EXIT
#define GC_HAVE_PTHREAD_EXIT
#define GC_PTHREAD_EXIT_ATTRIBUTE
#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
#if GC_GNUC_PREREQ(2,7)
#define GC_PTHREAD_EXIT_ATTRIBUTE __attribute__((__noreturn__))
#elif defined(__NORETURN)
#define GC_PTHREAD_EXIT_ATTRIBUTE __NORETURN
#else
#define GC_PTHREAD_EXIT_ATTRIBUTE
#endif
#endif
#if (!defined(GC_HAVE_PTHREAD_EXIT)||defined(__native_client__))&&!defined(GC_NO_PTHREAD_CANCEL)
#define GC_NO_PTHREAD_CANCEL
#endif
#endif
#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
#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
#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
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef void*GC_PTR;
#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
GC_API unsigned GC_CALL GC_get_version(void);
GC_API GC_ATTR_DEPRECATED GC_word GC_gc_no;
GC_API GC_word GC_CALL GC_get_gc_no(void);
#ifdef GC_THREADS
GC_API GC_ATTR_DEPRECATED int GC_parallel;
GC_API int GC_CALL GC_get_parallel(void);
GC_API void GC_CALL GC_set_markers_count(unsigned);
#endif
typedef void*(GC_CALLBACK*GC_oom_func)(size_t);
GC_API GC_ATTR_DEPRECATED GC_oom_func GC_oom_fn;
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);
GC_API GC_ATTR_DEPRECATED GC_on_heap_resize_proc GC_on_heap_resize;
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);
typedef enum {
GC_EVENT_START,
GC_EVENT_MARK_START,
GC_EVENT_MARK_END,
GC_EVENT_RECLAIM_START,
GC_EVENT_RECLAIM_END,
GC_EVENT_END,
GC_EVENT_PRE_STOP_WORLD,
GC_EVENT_POST_STOP_WORLD,
GC_EVENT_PRE_START_WORLD,
GC_EVENT_POST_START_WORLD,
GC_EVENT_THREAD_SUSPENDED,
GC_EVENT_THREAD_UNSUSPENDED
} GC_EventType;
typedef void (GC_CALLBACK*GC_on_collection_event_proc)(GC_EventType);
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);
#if defined(GC_THREADS)||(defined(GC_BUILD)&&defined(NN_PLATFORM_CTR))
typedef void (GC_CALLBACK*GC_on_thread_event_proc)(GC_EventType,
void*);
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);
#endif
GC_API GC_ATTR_DEPRECATED int GC_find_leak;
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;
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;
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;
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;
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;
GC_API GC_ATTR_DEPRECATED int GC_dont_expand;
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;
GC_API GC_ATTR_DEPRECATED int GC_full_freq;
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;
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;
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;
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;
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;
GC_API GC_ATTR_DEPRECATED int GC_dont_precollect;
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;
#define GC_TIME_UNLIMITED 999999
GC_API void GC_CALL GC_set_time_limit(unsigned long);
GC_API unsigned long GC_CALL GC_get_time_limit(void);
struct GC_timeval_s {
unsigned long tv_ms;
unsigned long tv_nsec;
};
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);
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);
GC_API void GC_CALL GC_start_performance_measurement(void);
GC_API unsigned long GC_CALL GC_get_full_gc_total_time(void);
GC_API void GC_CALL GC_set_pages_executable(int);
GC_API int GC_CALL GC_get_pages_executable(void);
GC_API void GC_CALL GC_set_min_bytes_allocd(size_t);
GC_API size_t GC_CALL GC_get_min_bytes_allocd(void);
GC_API void GC_CALL GC_set_rate(int);
GC_API int GC_CALL GC_get_rate(void);
GC_API void GC_CALL GC_set_max_prior_attempts(int);
GC_API int GC_CALL GC_get_max_prior_attempts(void);
GC_API void GC_CALL GC_set_handle_fork(int);
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);
GC_API void GC_CALL GC_init(void);
GC_API int GC_CALL GC_is_init_called(void);
GC_API void GC_CALL GC_deinit(void);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_malloc(size_t);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_malloc_atomic(size_t);
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);
GC_API GC_ATTR_DEPRECATED void*GC_CALL GC_malloc_stubborn(size_t);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(2)void*GC_CALL
GC_memalign(size_t,size_t);
GC_API int GC_CALL GC_posix_memalign(void**,size_t,
size_t)GC_ATTR_NONNULL(1);
GC_API void GC_CALL GC_free(void*);
#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*);
GC_API void GC_CALL GC_end_stubborn_change(const void*)GC_ATTR_NONNULL(1);
GC_API void*GC_CALL GC_base(void*);
GC_API int GC_CALL GC_is_heap_ptr(const void*);
GC_API size_t GC_CALL GC_size(const void*)GC_ATTR_NONNULL(1);
GC_API void*GC_CALL GC_realloc(void*,
size_t)
GC_ATTR_ALLOC_SIZE(2);
GC_API int GC_CALL GC_expand_hp(size_t);
GC_API void GC_CALL GC_set_max_heap_size(GC_word);
GC_API void GC_CALL GC_exclude_static_roots(void*,
void*);
GC_API void GC_CALL GC_clear_exclusion_table(void);
GC_API void GC_CALL GC_clear_roots(void);
GC_API void GC_CALL GC_add_roots(void*,
void*);
GC_API void GC_CALL GC_remove_roots(void*,
void*);
GC_API void GC_CALL GC_register_displacement(size_t);
GC_API void GC_CALL GC_debug_register_displacement(size_t);
GC_API void GC_CALL GC_gcollect(void);
GC_API void GC_CALL GC_gcollect_and_unmap(void);
typedef int (GC_CALLBACK*GC_stop_func)(void);
GC_API int GC_CALL GC_try_to_collect(GC_stop_func)
GC_ATTR_NONNULL(1);
GC_API void GC_CALL GC_set_stop_func(GC_stop_func)
GC_ATTR_NONNULL(1);
GC_API GC_stop_func GC_CALL GC_get_stop_func(void);
GC_API size_t GC_CALL GC_get_heap_size(void);
GC_API size_t GC_CALL GC_get_free_bytes(void);
GC_API size_t GC_CALL GC_get_unmapped_bytes(void);
GC_API size_t GC_CALL GC_get_bytes_since_gc(void);
GC_API size_t GC_CALL GC_get_expl_freed_bytes_since_gc(void);
GC_API size_t GC_CALL GC_get_total_bytes(void);
GC_API void GC_CALL GC_get_heap_usage_safe(GC_word*,
GC_word*,
GC_word*,
GC_word*,
GC_word*);
struct GC_prof_stats_s {
GC_word heapsize_full;
GC_word free_bytes_full;
GC_word unmapped_bytes;
GC_word bytes_allocd_since_gc;
GC_word allocd_bytes_before_gc;
GC_word non_gc_bytes;
GC_word gc_no;
GC_word markers_m1;
GC_word bytes_reclaimed_since_gc;
GC_word reclaimed_bytes_before_gc;
GC_word expl_freed_bytes_since_gc;
};
GC_API size_t GC_CALL GC_get_prof_stats(struct GC_prof_stats_s*,
size_t);
#ifdef GC_THREADS
GC_API size_t GC_CALL GC_get_prof_stats_unsafe(struct GC_prof_stats_s*,
size_t);
#endif
GC_API size_t GC_CALL GC_get_size_map_at(int i);
GC_API size_t GC_CALL GC_get_memory_use(void);
GC_API void GC_CALL GC_disable(void);
GC_API int GC_CALL GC_is_disabled(void);
GC_API void GC_CALL GC_enable(void);
GC_API void GC_CALL GC_set_manual_vdb_allowed(int);
GC_API int GC_CALL GC_get_manual_vdb_allowed(void);
GC_API void GC_CALL GC_enable_incremental(void);
GC_API int GC_CALL GC_is_incremental_mode(void);
#define GC_PROTECTS_POINTER_HEAP 1
#define GC_PROTECTS_PTRFREE_HEAP 2
#define GC_PROTECTS_STATIC_DATA 4
#define GC_PROTECTS_STACK 8
#define GC_PROTECTS_NONE 0
GC_API int GC_CALL GC_incremental_protection_needs(void);
GC_API int GC_CALL GC_collect_a_little(void);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_malloc_ignore_off_page(size_t);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_malloc_atomic_ignore_off_page(size_t);
#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
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_malloc_atomic_uncollectable(size_t);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_debug_malloc_atomic_uncollectable(size_t,GC_EXTRA_PARAMS);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_debug_malloc(size_t,GC_EXTRA_PARAMS);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_debug_malloc_atomic(size_t,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,
GC_EXTRA_PARAMS);
GC_API GC_ATTR_DEPRECATED void*GC_CALL
GC_debug_malloc_stubborn(size_t,GC_EXTRA_PARAMS);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_debug_malloc_ignore_off_page(size_t,
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,
GC_EXTRA_PARAMS);
GC_API void GC_CALL GC_debug_free(void*);
GC_API void*GC_CALL GC_debug_realloc(void*,
size_t,GC_EXTRA_PARAMS)
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);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_debug_malloc_replacement(size_t);
GC_API GC_ATTR_ALLOC_SIZE(2)void*GC_CALL
GC_debug_realloc_replacement(void*,
size_t);
#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
#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(( void*)(obj)))
#define GC_REGISTER_LONG_LINK(link,obj)GC_register_long_link(link,GC_base(( 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
#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
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
typedef void (GC_CALLBACK*GC_finalization_proc)(void*,
void*);
GC_API void GC_CALL GC_register_finalizer(void*,
GC_finalization_proc,void*,
GC_finalization_proc*,void**)
GC_ATTR_NONNULL(1);
GC_API void GC_CALL GC_debug_register_finalizer(void*,
GC_finalization_proc,void*,
GC_finalization_proc*,void**)
GC_ATTR_NONNULL(1);
GC_API void GC_CALL GC_register_finalizer_ignore_self(void*,
GC_finalization_proc,void*,
GC_finalization_proc*,void**)
GC_ATTR_NONNULL(1);
GC_API void GC_CALL GC_debug_register_finalizer_ignore_self(void*,
GC_finalization_proc,void*,
GC_finalization_proc*,void**)
GC_ATTR_NONNULL(1);
GC_API void GC_CALL GC_register_finalizer_no_order(void*,
GC_finalization_proc,void*,
GC_finalization_proc*,void**)
GC_ATTR_NONNULL(1);
GC_API void GC_CALL GC_debug_register_finalizer_no_order(void*,
GC_finalization_proc,void*,
GC_finalization_proc*,void**)
GC_ATTR_NONNULL(1);
GC_API void GC_CALL GC_register_finalizer_unreachable(void*,
GC_finalization_proc,void*,
GC_finalization_proc*,void**)
GC_ATTR_NONNULL(1);
GC_API void GC_CALL GC_debug_register_finalizer_unreachable(void*,
GC_finalization_proc,void*,
GC_finalization_proc*,void**)
GC_ATTR_NONNULL(1);
#define GC_NO_MEMORY 2
GC_API int GC_CALL GC_register_disappearing_link(void**)
GC_ATTR_NONNULL(1);
GC_API int GC_CALL GC_general_register_disappearing_link(void**,
const void*)
GC_ATTR_NONNULL(1)GC_ATTR_NONNULL(2);
GC_API int GC_CALL GC_move_disappearing_link(void**,
void**)
GC_ATTR_NONNULL(2);
GC_API int GC_CALL GC_unregister_disappearing_link(void**);
GC_API int GC_CALL GC_register_long_link(void**,
const void*)
GC_ATTR_NONNULL(1)GC_ATTR_NONNULL(2);
GC_API int GC_CALL GC_move_long_link(void**,
void**)
GC_ATTR_NONNULL(2);
GC_API int GC_CALL GC_unregister_long_link(void**);
typedef enum {
GC_TOGGLE_REF_DROP,
GC_TOGGLE_REF_STRONG,
GC_TOGGLE_REF_WEAK
} GC_ToggleRefStatus;
typedef GC_ToggleRefStatus (GC_CALLBACK*GC_toggleref_func)(void*);
GC_API void GC_CALL GC_set_toggleref_func(GC_toggleref_func);
GC_API GC_toggleref_func GC_CALL GC_get_toggleref_func(void);
GC_API int GC_CALL GC_toggleref_add(void*,int)
GC_ATTR_NONNULL(1);
typedef void (GC_CALLBACK*GC_await_finalize_proc)(void*);
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);
GC_API int GC_CALL GC_should_invoke_finalizers(void);
GC_API int GC_CALL GC_invoke_finalizers(void);
#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))
#else
#define GC_reachable_here(ptr)GC_noop1((GC_word)(ptr))
#endif
#endif
typedef void (GC_CALLBACK*GC_warn_proc)(char*,
GC_word);
GC_API void GC_CALL GC_set_warn_proc(GC_warn_proc)GC_ATTR_NONNULL(1);
GC_API GC_warn_proc GC_CALL GC_get_warn_proc(void);
GC_API void GC_CALLBACK GC_ignore_warn_proc(char*,GC_word);
GC_API void GC_CALL GC_set_log_fd(int);
typedef void (GC_CALLBACK*GC_abort_func)(const char*);
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);
GC_API void GC_CALL GC_abort_on_oom(void);
typedef GC_word GC_hidden_pointer;
#define GC_HIDE_POINTER(p)(~(GC_hidden_pointer)(p))
#define GC_REVEAL_POINTER(p)((void*)GC_HIDE_POINTER(p))
#if defined(I_HIDE_POINTERS)||defined(GC_I_HIDE_POINTERS)
#define HIDE_POINTER(p)GC_HIDE_POINTER(p)
#define REVEAL_POINTER(p)GC_REVEAL_POINTER(p)
#endif
#ifdef GC_THREADS
GC_API void GC_CALL GC_alloc_lock(void);
GC_API void GC_CALL GC_alloc_unlock(void);
#else
#define GC_alloc_lock()(void)0
#define GC_alloc_unlock()(void)0
#endif
typedef void*(GC_CALLBACK*GC_fn_type)(void*);
GC_API void*GC_CALL GC_call_with_alloc_lock(GC_fn_type,
void*)GC_ATTR_NONNULL(1);
struct GC_stack_base {
void*mem_base;
#if defined(__ia64)||defined(__ia64__)||defined(_M_IA64)
void*reg_base;
#endif
};
typedef void*(GC_CALLBACK*GC_stack_base_func)(
struct GC_stack_base*,void*);
GC_API void*GC_CALL GC_call_with_stack_base(GC_stack_base_func,
void*)GC_ATTR_NONNULL(1);
#define GC_SUCCESS 0
#define GC_DUPLICATE 1
#define GC_NO_THREADS 2
#define GC_UNIMPLEMENTED 3
#define GC_NOT_FOUND 4
#if defined(GC_DARWIN_THREADS)||defined(GC_WIN32_THREADS)
GC_API void GC_CALL GC_use_threads_discovery(void);
#endif
#ifdef GC_THREADS
GC_API void GC_CALL GC_set_suspend_signal(int);
GC_API void GC_CALL GC_set_thr_restart_signal(int);
GC_API int GC_CALL GC_get_suspend_signal(void);
GC_API int GC_CALL GC_get_thr_restart_signal(void);
GC_API void GC_CALL GC_start_mark_threads(void);
GC_API void GC_CALL GC_allow_register_threads(void);
GC_API int GC_CALL GC_register_my_thread(const struct GC_stack_base*)
GC_ATTR_NONNULL(1);
GC_API int GC_CALL GC_thread_is_registered(void);
GC_API void GC_CALL GC_register_altstack(void*,
GC_word,
void*,
GC_word);
GC_API int GC_CALL GC_unregister_my_thread(void);
GC_API void GC_CALL GC_stop_world_external(void);
GC_API void GC_CALL GC_start_world_external(void);
#endif
GC_API void*GC_CALL GC_do_blocking(GC_fn_type,
void*)GC_ATTR_NONNULL(1);
GC_API void*GC_CALL GC_call_with_gc_active(GC_fn_type,
void*)GC_ATTR_NONNULL(1);
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*)
GC_ATTR_NONNULL(1);
GC_API void*GC_CALL GC_get_my_stackbottom(struct GC_stack_base*)
GC_ATTR_NONNULL(1);
GC_API void GC_CALL GC_set_stackbottom(void*,
const struct GC_stack_base*)
GC_ATTR_NONNULL(2);
GC_API void*GC_CALL GC_same_obj(void*,void*);
GC_API void*GC_CALL GC_pre_incr(void**,ptrdiff_t)
GC_ATTR_NONNULL(1);
GC_API void*GC_CALL GC_post_incr(void**,ptrdiff_t)
GC_ATTR_NONNULL(1);
GC_API void*GC_CALL GC_is_visible(void*);
GC_API void*GC_CALL GC_is_valid_displacement(void*);
GC_API void GC_CALL GC_dump(void);
GC_API void GC_CALL GC_dump_named(const char*);
GC_API void GC_CALL GC_dump_regions(void);
GC_API void GC_CALL GC_dump_finalization(void);
#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
#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
#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_API void GC_CALL GC_ptr_store_and_dirty(void*,
const void*);
GC_API void GC_CALL GC_debug_ptr_store_and_dirty(void*,
const void*);
GC_API void (GC_CALLBACK*GC_same_obj_print_proc)(void*,
void*);
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
#ifdef __cplusplus
}
#endif
#ifndef GC_PTHREAD_REDIRECTS_H
#define GC_PTHREAD_REDIRECTS_H
#if defined(GC_H)&&defined(GC_PTHREADS)
#ifndef GC_PTHREAD_REDIRECTS_ONLY
#include <pthread.h>
#ifndef GC_NO_DLOPEN
#include <dlfcn.h>
#endif
#ifndef GC_NO_PTHREAD_SIGMASK
#include <signal.h>
#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*,int);
#endif
#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,const sigset_t*,
sigset_t*);
#endif
#endif
#ifndef GC_PTHREAD_CREATE_CONST
#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*);
GC_API int GC_pthread_join(pthread_t,void**);
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
}
#endif
#endif
#if!defined(GC_NO_THREAD_REDIRECTS)&&!defined(GC_USE_LD_WRAP)
#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
#endif
#endif
#ifdef __cplusplus
extern "C" {
#endif
#endif
GC_API GC_ATTR_MALLOC void*GC_CALL GC_malloc_many(size_t);
#define GC_NEXT(p)(*(void**)(p))
typedef int (GC_CALLBACK*GC_has_static_roots_func)(
const char*,
void*,
size_t);
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)
#define GC_WINDOWS_H_INCLUDED
#endif
#if defined(GC_WIN32_THREADS)&&(!defined(GC_PTHREADS)||defined(GC_BUILD)||defined(GC_WINDOWS_H_INCLUDED))
#if (!defined(GC_NO_THREAD_DECLS)||defined(GC_BUILD))&&!defined(GC_DONT_INCL_WINDOWS_H)
#ifdef __cplusplus
}
#endif
#if!defined(_WIN32_WCE)&&!defined(__CEGCC__)
#include <process.h>
#endif
#if defined(GC_BUILD)||!defined(GC_DONT_INCLUDE_WINDOWS_H)
#include <windows.h>
#define GC_WINDOWS_H_INCLUDED
#endif
#ifdef __cplusplus
extern "C" {
#endif
#ifdef GC_UNDERSCORE_STDCALL
#define GC_CreateThread _GC_CreateThread
#define GC_ExitThread _GC_ExitThread
#endif
#ifndef DECLSPEC_NORETURN
#ifdef GC_WINDOWS_H_INCLUDED
#define DECLSPEC_NORETURN
#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
#ifdef GC_UNDERSCORE_STDCALL
#define GC_DllMain _GC_DllMain
#endif
#ifdef GC_WINDOWS_H_INCLUDED
GC_API BOOL WINAPI GC_DllMain(HINSTANCE,
ULONG,
LPVOID);
#else
GC_API int __stdcall GC_DllMain(void*,unsigned long,void*);
#endif
#endif
#ifdef GC_WINDOWS_H_INCLUDED
GC_API HANDLE WINAPI GC_CreateThread(
LPSECURITY_ATTRIBUTES,
GC_WIN32_SIZE_T,
LPTHREAD_START_ROUTINE,
LPVOID,DWORD,
LPDWORD);
GC_API DECLSPEC_NORETURN void WINAPI GC_ExitThread(
DWORD);
#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*,unsigned,
unsigned (__stdcall*)(void*),
void*,unsigned,
unsigned*);
GC_API void GC_CALL GC_endthreadex(unsigned);
#endif
#endif
#ifdef GC_WINMAIN_REDIRECT
#define WinMain GC_WinMain
#endif
#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
#endif
#endif
GC_API void GC_CALL GC_set_force_unmap_on_gcollect(int);
GC_API int GC_CALL GC_get_force_unmap_on_gcollect(void);
#if defined(__CYGWIN32__)||defined(__CYGWIN__)
#ifdef __x86_64__
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
#define GC_INIT_CONF_ROOTS GC_add_roots(GC_DATASTART,GC_DATAEND);GC_gcollect()
#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)
#pragma weak __dso_handle
extern int __dso_handle[];
GC_API void*GC_CALL GC_find_limit(void*,int);
#define GC_INIT_CONF_ROOTS (void)(__dso_handle!=0?(GC_add_roots(__dso_handle,GC_find_limit(__dso_handle,1)),0):0)
#else
#define GC_INIT_CONF_ROOTS
#endif
#ifdef GC_DONT_EXPAND
#define GC_INIT_CONF_DONT_EXPAND GC_set_dont_expand(1)
#else
#define GC_INIT_CONF_DONT_EXPAND
#endif
#ifdef GC_FORCE_UNMAP_ON_GCOLLECT
#define GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT GC_set_force_unmap_on_gcollect(1)
#else
#define GC_INIT_CONF_FORCE_UNMAP_ON_GCOLLECT
#endif
#ifdef GC_DONT_GC
#define GC_INIT_CONF_MAX_RETRIES (void)(GC_dont_gc=1)
#elif defined(GC_MAX_RETRIES)&&!defined(CPPCHECK)
#define GC_INIT_CONF_MAX_RETRIES GC_set_max_retries(GC_MAX_RETRIES)
#else
#define GC_INIT_CONF_MAX_RETRIES
#endif
#if defined(GC_ALLOCD_BYTES_PER_FINALIZER)&&!defined(CPPCHECK)
#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
#endif
#if defined(GC_FREE_SPACE_DIVISOR)&&!defined(CPPCHECK)
#define GC_INIT_CONF_FREE_SPACE_DIVISOR GC_set_free_space_divisor(GC_FREE_SPACE_DIVISOR)
#else
#define GC_INIT_CONF_FREE_SPACE_DIVISOR
#endif
#if defined(GC_FULL_FREQ)&&!defined(CPPCHECK)
#define GC_INIT_CONF_FULL_FREQ GC_set_full_freq(GC_FULL_FREQ)
#else
#define GC_INIT_CONF_FULL_FREQ
#endif
#if defined(GC_TIME_LIMIT)&&!defined(CPPCHECK)
#define GC_INIT_CONF_TIME_LIMIT GC_set_time_limit(GC_TIME_LIMIT)
#else
#define GC_INIT_CONF_TIME_LIMIT
#endif
#if defined(GC_MARKERS)&&defined(GC_THREADS)&&!defined(CPPCHECK)
#define GC_INIT_CONF_MARKERS GC_set_markers_count(GC_MARKERS)
#else
#define GC_INIT_CONF_MARKERS
#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
#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
#endif
#if defined(GC_MAXIMUM_HEAP_SIZE)&&!defined(CPPCHECK)
#define GC_INIT_CONF_MAXIMUM_HEAP_SIZE GC_set_max_heap_size(GC_MAXIMUM_HEAP_SIZE)
#else
#define GC_INIT_CONF_MAXIMUM_HEAP_SIZE
#endif
#ifdef GC_IGNORE_WARN
#define GC_INIT_CONF_IGNORE_WARN GC_set_warn_proc(GC_ignore_warn_proc)
#else
#define GC_INIT_CONF_IGNORE_WARN
#endif
#if defined(GC_INITIAL_HEAP_SIZE)&&!defined(CPPCHECK)
#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
#endif
#define GC_INIT(){ GC_INIT_CONF_DONT_EXPAND;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();GC_INIT_CONF_ROOTS;GC_INIT_CONF_IGNORE_WARN;GC_INIT_CONF_INITIAL_HEAP_SIZE;}
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)
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
#ifdef __cplusplus
}
#endif
#endif
#endif
#include <stdlib.h>
#if!defined(sony_news)
#include <stddef.h>
#endif
#ifdef DGUX
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#endif
#ifdef BSD_TIME
#include <sys/types.h>
#include <sys/time.h>
#include <sys/resource.h>
#endif
#ifdef PARALLEL_MARK
#define AO_REQUIRE_CAS
#if!defined(__GNUC__)&&!defined(AO_ASSUME_WINDOWS98)
#define AO_ASSUME_WINDOWS98
#endif
#endif
#ifndef GC_TINY_FL_H
#define GC_TINY_FL_H
#ifndef GC_GRANULE_BYTES
#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
#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
#ifndef GC_TINY_FREELISTS
#if GC_GRANULE_BYTES==16
#define GC_TINY_FREELISTS 25
#else
#define GC_TINY_FREELISTS 33
#endif
#endif
#define GC_RAW_BYTES_FROM_INDEX(i)((i)*GC_GRANULE_BYTES)
#endif
#ifndef GC_MARK_H
#define GC_MARK_H
#ifndef GC_H
#endif
#ifdef __cplusplus
extern "C" {
#endif
#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*,
struct GC_ms_entry*,
struct GC_ms_entry*,
GC_word);
#define GC_LOG_MAX_MARK_PROCS 6
#define GC_MAX_MARK_PROCS (1<<GC_LOG_MAX_MARK_PROCS)
#define GC_RESERVED_MARK_PROCS 8
#define GC_GCJ_RESERVED_MARK_PROC_INDEX 0
#define GC_DS_TAG_BITS 2
#define GC_DS_TAGS ((1<<GC_DS_TAG_BITS)- 1)
#define GC_DS_LENGTH 0
#define GC_DS_BITMAP 1
#define GC_DS_PROC 2
#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
#define GC_INDIR_PER_OBJ_BIAS 0x10
GC_API void*GC_least_plausible_heap_addr;
GC_API void*GC_greatest_plausible_heap_addr;
GC_API struct GC_ms_entry*GC_CALL GC_mark_and_push(void*,
struct GC_ms_entry*,
struct GC_ms_entry*,
void**);
#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))
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()))
GC_API GC_ATTR_DEPRECATED
#ifdef GC_BUILD
const
#endif
size_t GC_debug_header_size;
GC_API void**GC_CALL GC_new_free_list(void);
GC_API void**GC_CALL GC_new_free_list_inner(void);
GC_API unsigned GC_CALL GC_new_kind(void**,
GC_word,
int,
int)GC_ATTR_NONNULL(1);
GC_API unsigned GC_CALL GC_new_kind_inner(void**,
GC_word,
int,
int)GC_ATTR_NONNULL(1);
GC_API unsigned GC_CALL GC_new_proc(GC_mark_proc);
GC_API unsigned GC_CALL GC_new_proc_inner(GC_mark_proc);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL GC_generic_malloc(
size_t,
int);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_generic_malloc_ignore_off_page(
size_t,int);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_generic_malloc_uncollectable(
size_t,int);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_generic_or_special_malloc(
size_t,int);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_debug_generic_or_special_malloc(
size_t,int,
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_API int GC_CALL GC_get_kind_and_size(const void*,size_t*)
GC_ATTR_NONNULL(1);
typedef void (GC_CALLBACK*GC_describe_type_fn)(void*,
char*);
#define GC_TYPE_DESCR_LEN 40
GC_API void GC_CALL GC_register_describe_type_fn(int,
GC_describe_type_fn);
GC_API void*GC_CALL GC_clear_stack(void*);
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);
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);
GC_API void GC_CALL GC_push_all(void*,void*);
GC_API void GC_CALL GC_push_all_eager(void*,void*);
GC_API void GC_CALL GC_push_conditional(void*,void*,
int);
GC_API void GC_CALL GC_push_finalizer_structures(void);
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);
typedef void (GC_CALLBACK*GC_reachable_object_proc)(void*,
size_t,
void*);
GC_API void GC_CALL GC_enumerate_reachable_objects_inner(
GC_reachable_object_proc,
void*)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_API void GC_CALL GC_print_trace_inner(GC_word);
#ifdef __cplusplus
}
#endif
#endif
typedef GC_word word;
typedef GC_signed_word signed_word;
typedef unsigned int unsigned32;
typedef int GC_bool;
#define TRUE 1
#define FALSE 0
#ifndef PTR_T_DEFINED
typedef char*ptr_t;
#define PTR_T_DEFINED
#endif
#ifndef SIZE_MAX
#include <limits.h>
#endif
#if defined(SIZE_MAX)&&!defined(CPPCHECK)
#define GC_SIZE_MAX ((size_t)SIZE_MAX)
#else
#define GC_SIZE_MAX (~(size_t)0)
#endif
#if GC_GNUC_PREREQ(3,0)&&!defined(LINT2)
#define EXPECT(expr,outcome)__builtin_expect(expr,outcome)
#else
#define EXPECT(expr,outcome)(expr)
#endif
#define SIZET_SAT_ADD(a,b)(EXPECT((a)< GC_SIZE_MAX - (b),TRUE)?(a)+(b):GC_SIZE_MAX)
#ifndef GCCONFIG_H
#define GCCONFIG_H
#ifdef CPPCHECK
#undef CLOCKS_PER_SEC
#undef FIXUP_POINTER
#undef POINTER_MASK
#undef POINTER_SHIFT
#undef REDIRECT_REALLOC
#undef _MAX_PATH
#endif
#ifndef PTR_T_DEFINED
typedef char*ptr_t;
#define PTR_T_DEFINED
#endif
#if!defined(sony_news)
#include <stddef.h>
#endif
#ifdef __cplusplus
#define EXTERN_C_BEGIN extern "C" {
#define EXTERN_C_END }
#else
#define EXTERN_C_BEGIN
#define EXTERN_C_END
#endif
EXTERN_C_BEGIN
#if defined(__clang__)&&defined(__clang_major__)
#define GC_CLANG_PREREQ(major,minor)((__clang_major__<<16)+__clang_minor__>=((major)<<16)+(minor))
#define GC_CLANG_PREREQ_FULL(major,minor,patchlevel)(GC_CLANG_PREREQ(major,(minor)+1)||(__clang_major__==(major)&&__clang_minor__==(minor)&&__clang_patchlevel__>=(patchlevel)))
#else
#define GC_CLANG_PREREQ(major,minor)0
#define GC_CLANG_PREREQ_FULL(major,minor,patchlevel)0
#endif
#ifdef LINT2
#define COVERT_DATAFLOW(w)(~(GC_word)(w)^(~(GC_word)0))
#else
#define COVERT_DATAFLOW(w)((GC_word)(w))
#endif
#if defined(__ANDROID__)&&!defined(HOST_ANDROID)
#define HOST_ANDROID 1
#endif
#if defined(TIZEN)&&!defined(HOST_TIZEN)
#define HOST_TIZEN 1
#endif
#if defined(__SYMBIAN32__)&&!defined(SYMBIAN)
#define SYMBIAN
#ifdef __WINS__
#pragma data_seg(".data2")
#endif
#endif
#if (defined(linux)||defined(__linux__)||defined(HOST_ANDROID))&&!defined(LINUX)&&!defined(__native_client__)
#define LINUX
#endif
#if defined(__NetBSD__)
#define NETBSD
#endif
#if defined(__OpenBSD__)
#define OPENBSD
#endif
#if (defined(__FreeBSD__)||defined(__DragonFly__)||defined(__FreeBSD_kernel__))&&!defined(FREEBSD)&&!defined(SN_TARGET_ORBIS)
#define FREEBSD
#endif
#if defined(macosx)||(defined(__APPLE__)&&defined(__MACH__))
#define DARWIN
EXTERN_C_END
#include <TargetConditionals.h>
EXTERN_C_BEGIN
#endif
#if defined(__native_client__)
#define NACL
#if!defined(__portable_native_client__)&&!defined(__arm__)
#define I386
#define mach_type_known
#else
#endif
#endif
#if defined(__aarch64__)
#define AARCH64
#if!defined(LINUX)&&!defined(DARWIN)&&!defined(FREEBSD)&&!defined(NETBSD)&&!defined(NN_BUILD_TARGET_PLATFORM_NX)&&!defined(OPENBSD)
#define NOSYS
#define mach_type_known
#endif
#endif
#if defined(__arm)||defined(__arm__)||defined(__thumb__)
#define ARM32
#if defined(NACL)
#define mach_type_known
#elif!defined(LINUX)&&!defined(NETBSD)&&!defined(FREEBSD)&&!defined(OPENBSD)&&!defined(DARWIN)&&!defined(_WIN32)&&!defined(__CEGCC__)&&!defined(NN_PLATFORM_CTR)&&!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)&&!defined(SYMBIAN)
#define NOSYS
#define mach_type_known
#endif
#endif
#if defined(sun)&&defined(mc68000)&&!defined(CPPCHECK)
#error SUNOS4 no longer supported
#endif
#if defined(hp9000s300)&&!defined(CPPCHECK)
#error M68K based HP machines no longer supported
#endif
#if defined(OPENBSD)&&defined(m68k)
#define M68K
#define mach_type_known
#endif
#if defined(OPENBSD)&&defined(__sparc__)
#define SPARC
#define mach_type_known
#endif
#if defined(OPENBSD)&&defined(__arm__)
#define ARM32
#define mach_type_known
#endif
#if defined(OPENBSD)&&defined(__aarch64__)
#define AARCH64
#define mach_type_known
#endif
#if defined(OPENBSD)&&defined(__sh__)
#define SH
#define mach_type_known
#endif
#if defined(NETBSD)&&(defined(m68k)||defined(__m68k__))
#define M68K
#define mach_type_known
#endif
#if defined(NETBSD)&&defined(__powerpc__)
#define POWERPC
#define mach_type_known
#endif
#if defined(NETBSD)&&(defined(__arm32__)||defined(__arm__))
#define ARM32
#define mach_type_known
#endif
#if defined(NETBSD)&&defined(__aarch64__)
#define AARCH64
#define mach_type_known
#endif
#if defined(NETBSD)&&defined(__sh__)
#define SH
#define mach_type_known
#endif
#if defined(vax)||defined(__vax__)
#define VAX
#ifdef ultrix
#define ULTRIX
#else
#define BSD
#endif
#define mach_type_known
#endif
#if defined(NETBSD)&&defined(__vax__)
#define VAX
#define mach_type_known
#endif
#if defined(mips)||defined(__mips)||defined(_mips)
#define MIPS
#if defined(nec_ews)||defined(_nec_ews)
#define EWS4800
#endif
#if!defined(LINUX)&&!defined(EWS4800)&&!defined(NETBSD)&&!defined(OPENBSD)
#if defined(ultrix)||defined(__ultrix)
#define ULTRIX
#else
#define IRIX5
#endif
#endif
#if defined(NETBSD)&&defined(__MIPSEL__)
#undef ULTRIX
#endif
#define mach_type_known
#endif
#if defined(__QNX__)
#define I386
#define mach_type_known
#endif
#if defined(__NIOS2__)||defined(__NIOS2)||defined(__nios2__)
#define NIOS2
#define mach_type_known
#endif
#if defined(__or1k__)
#define OR1K
#define mach_type_known
#endif
#if defined(DGUX)&&(defined(i386)||defined(__i386__))
#define I386
#ifndef _USING_DGUX
#define _USING_DGUX
#endif
#define mach_type_known
#endif
#if defined(sequent)&&(defined(i386)||defined(__i386__))
#define I386
#define SEQUENT
#define mach_type_known
#endif
#if (defined(sun)||defined(__sun))&&(defined(i386)||defined(__i386__))
#define I386
#define SOLARIS
#define mach_type_known
#endif
#if (defined(sun)||defined(__sun))&&defined(__amd64)
#define X86_64
#define SOLARIS
#define mach_type_known
#endif
#if (defined(__OS2__)||defined(__EMX__))&&defined(__32BIT__)
#define I386
#define OS2
#define mach_type_known
#endif
#if defined(ibm032)&&!defined(CPPCHECK)
#error IBM PC/RT no longer supported
#endif
#if (defined(sun)||defined(__sun))&&(defined(sparc)||defined(__sparc))
EXTERN_C_END
#include <errno.h>
EXTERN_C_BEGIN
#define SPARC
#define SOLARIS
#define mach_type_known
#elif defined(sparc)&&defined(unix)&&!defined(sun)&&!defined(linux)&&!defined(FREEBSD)&&!defined(NETBSD)&&!defined(OPENBSD)
#define SPARC
#define DRSNX
#define mach_type_known
#endif
#if defined(_IBMR2)
#define POWERPC
#define AIX
#define mach_type_known
#endif
#if defined(NETBSD)&&defined(__sparc__)
#define SPARC
#define mach_type_known
#endif
#if defined(_M_XENIX)&&defined(_M_SYSV)&&defined(_M_I386)
#define I386
#if defined(_SCO_ELF)
#define SCO_ELF
#else
#define SCO
#endif
#define mach_type_known
#endif
#if defined(_AUX_SOURCE)&&!defined(CPPCHECK)
#error A/UX no longer supported
#endif
#if defined(_PA_RISC1_0)||defined(_PA_RISC1_1)||defined(_PA_RISC2_0)||defined(hppa)||defined(__hppa__)
#define HP_PA
#if!defined(LINUX)&&!defined(HPUX)&&!defined(OPENBSD)
#define HPUX
#endif
#define mach_type_known
#endif
#if defined(__ia64)&&(defined(_HPUX_SOURCE)||defined(__HP_aCC))
#define IA64
#ifndef HPUX
#define HPUX
#endif
#define mach_type_known
#endif
#if (defined(__BEOS__)||defined(__HAIKU__))&&defined(_X86_)
#define I386
#define HAIKU
#define mach_type_known
#endif
#if defined(__HAIKU__)&&(defined(__amd64__)||defined(__x86_64__))
#define X86_64
#define HAIKU
#define mach_type_known
#endif
#if defined(OPENBSD)&&defined(__amd64__)
#define X86_64
#define mach_type_known
#endif
#if defined(LINUX)&&(defined(i386)||defined(__i386__))
#define I386
#define mach_type_known
#endif
#if defined(LINUX)&&defined(__x86_64__)
#define X86_64
#define mach_type_known
#endif
#if defined(LINUX)&&(defined(__ia64__)||defined(__ia64))
#define IA64
#define mach_type_known
#endif
#if defined(LINUX)&&defined(__aarch64__)
#define AARCH64
#define mach_type_known
#endif
#if defined(LINUX)&&(defined(__arm)||defined(__arm__))
#define ARM32
#define mach_type_known
#endif
#if defined(LINUX)&&defined(__cris__)
#ifndef CRIS
#define CRIS
#endif
#define mach_type_known
#endif
#if defined(LINUX)&&(defined(powerpc)||defined(__powerpc__)||defined(powerpc64)||defined(__powerpc64__))
#define POWERPC
#define mach_type_known
#endif
#if defined(LINUX)&&defined(__mc68000__)
#define M68K
#define mach_type_known
#endif
#if defined(LINUX)&&(defined(sparc)||defined(__sparc__))
#define SPARC
#define mach_type_known
#endif
#if defined(LINUX)&&defined(__sh__)
#define SH
#define mach_type_known
#endif
#if defined(LINUX)&&defined(__avr32__)
#define AVR32
#define mach_type_known
#endif
#if defined(LINUX)&&defined(__m32r__)
#define M32R
#define mach_type_known
#endif
#if defined(__alpha)||defined(__alpha__)
#define ALPHA
#if!defined(LINUX)&&!defined(NETBSD)&&!defined(OPENBSD)&&!defined(FREEBSD)
#define OSF1
#endif
#define mach_type_known
#endif
#if defined(_AMIGA)&&!defined(AMIGA)
#define AMIGA
#endif
#ifdef AMIGA
#define M68K
#define mach_type_known
#endif
#if defined(THINK_C)||(defined(__MWERKS__)&&!defined(__powerc)&&!defined(SYMBIAN))
#define M68K
#define MACOS
#define mach_type_known
#endif
#if defined(__MWERKS__)&&defined(__powerc)&&!defined(__MACH__)&&!defined(SYMBIAN)
#define POWERPC
#define MACOS
#define mach_type_known
#endif
#if defined(OPENBSD)&&defined(__powerpc__)
#define POWERPC
#define mach_type_known
#endif
#if defined(DARWIN)
#if defined(__ppc__)||defined(__ppc64__)
#define POWERPC
#define mach_type_known
#elif defined(__x86_64__)||defined(__x86_64)
#define X86_64
#define mach_type_known
#elif defined(__i386__)
#define I386
#define mach_type_known
#elif defined(__arm__)
#define ARM32
#define mach_type_known
#elif defined(__aarch64__)
#define AARCH64
#define mach_type_known
#endif
#endif
#if defined(__rtems__)&&(defined(i386)||defined(__i386__))
#define I386
#define RTEMS
#define mach_type_known
#endif
#if defined(NeXT)&&defined(mc68000)
#define M68K
#define NEXT
#define mach_type_known
#endif
#if defined(NeXT)&&(defined(i386)||defined(__i386__))
#define I386
#define NEXT
#define mach_type_known
#endif
#if defined(OPENBSD)&&(defined(i386)||defined(__i386__))
#define I386
#define mach_type_known
#endif
#if defined(NETBSD)&&(defined(i386)||defined(__i386__))
#define I386
#define mach_type_known
#endif
#if defined(NETBSD)&&defined(__x86_64__)
#define X86_64
#define mach_type_known
#endif
#if defined(FREEBSD)&&(defined(i386)||defined(__i386__))
#define I386
#define mach_type_known
#endif
#if (defined(FREEBSD)||defined(SN_TARGET_ORBIS))&&(defined(__amd64__)||defined(__x86_64__))
#define X86_64
#define mach_type_known
#endif
#if defined(FREEBSD)&&defined(__sparc__)
#define SPARC
#define mach_type_known
#endif
#if defined(FREEBSD)&&(defined(powerpc)||defined(__powerpc__))
#define POWERPC
#define mach_type_known
#endif
#if defined(FREEBSD)&&defined(__arm__)
#define ARM32
#define mach_type_known
#endif
#if defined(FREEBSD)&&defined(__aarch64__)
#define AARCH64
#define mach_type_known
#endif
#if defined(FREEBSD)&&(defined(mips)||defined(__mips)||defined(_mips))
#define MIPS
#define mach_type_known
#endif
#if defined(bsdi)&&(defined(i386)||defined(__i386__))
#define I386
#define BSDI
#define mach_type_known
#endif
#if!defined(mach_type_known)&&defined(__386BSD__)
#define I386
#define THREE86BSD
#define mach_type_known
#endif
#if defined(_CX_UX)&&defined(_M88K)
#define M88K
#define CX_UX
#define mach_type_known
#endif
#if defined(DGUX)&&defined(m88k)
#define M88K
#define mach_type_known
#endif
#if defined(_WIN32_WCE)||defined(__CEGCC__)||defined(__MINGW32CE__)
#if defined(SH3)||defined(SH4)
#define SH
#endif
#if defined(x86)||defined(__i386__)
#define I386
#endif
#if defined(_M_ARM)||defined(ARM)||defined(_ARM_)
#define ARM32
#endif
#define MSWINCE
#define mach_type_known
#else
#if ((defined(_MSDOS)||defined(_MSC_VER))&&(_M_IX86>=300))||(defined(_WIN32)&&!defined(__CYGWIN32__)&&!defined(__CYGWIN__)&&!defined(__INTERIX)&&!defined(SYMBIAN))
#if defined(__LP64__)||defined(_M_X64)
#define X86_64
#elif defined(_M_ARM)
#define ARM32
#elif defined(_M_ARM64)
#define AARCH64
#else
#define I386
#endif
#ifdef _XBOX_ONE
#define MSWIN_XBOX1
#else
#ifndef MSWIN32
#define MSWIN32
#endif
#if defined(WINAPI_FAMILY)&&(WINAPI_FAMILY==WINAPI_FAMILY_APP)
#define MSWINRT_FLAVOR
#endif
#endif
#define mach_type_known
#endif
#if defined(_MSC_VER)&&defined(_M_IA64)
#define IA64
#define MSWIN32
#endif
#endif
#if defined(__DJGPP__)
#define I386
#ifndef DJGPP
#define DJGPP
#endif
#define mach_type_known
#endif
#if defined(__CYGWIN32__)||defined(__CYGWIN__)
#if defined(__LP64__)
#define X86_64
#else
#define I386
#endif
#define CYGWIN32
#define mach_type_known
#endif
#if defined(__INTERIX)
#define I386
#define INTERIX
#define mach_type_known
#endif
#if defined(__MINGW32__)&&!defined(mach_type_known)
#define I386
#define MSWIN32
#define mach_type_known
#endif
#if defined(__BORLANDC__)
#define I386
#define MSWIN32
#define mach_type_known
#endif
#if defined(_UTS)&&!defined(mach_type_known)
#define S370
#define UTS4
#define mach_type_known
#endif
#if defined(__pj__)&&!defined(CPPCHECK)
#error PicoJava no longer supported
#endif
#if defined(__embedded__)&&defined(PPC)
#define POWERPC
#define NOSYS
#define mach_type_known
#endif
#if defined(__WATCOMC__)&&defined(__386__)
#define I386
#if!defined(OS2)&&!defined(MSWIN32)&&!defined(DOS4GW)
#if defined(__OS2__)
#define OS2
#else
#if defined(__WINDOWS_386__)||defined(__NT__)
#define MSWIN32
#else
#define DOS4GW
#endif
#endif
#endif
#define mach_type_known
#endif
#if defined(__s390__)&&defined(LINUX)
#define S390
#define mach_type_known
#endif
#if defined(__GNU__)
#if defined(__i386__)
#define HURD
#define I386
#define mach_type_known
#endif
#endif
#if defined(__TANDEM)
#define MIPS
#define NONSTOP
#define mach_type_known
#endif
#if defined(__arc__)&&defined(LINUX)
#define ARC
#define mach_type_known
#endif
#if defined(__hexagon__)&&defined(LINUX)
#define HEXAGON
#define mach_type_known
#endif
#if defined(__tile__)&&defined(LINUX)
#ifdef __tilegx__
#define TILEGX
#else
#define TILEPRO
#endif
#define mach_type_known
#endif
#if defined(__riscv)&&(defined(FREEBSD)||defined(LINUX))
#define RISCV
#define mach_type_known
#endif
#if defined(SN_TARGET_PSP2)
#define mach_type_known
#endif
#if defined(NN_PLATFORM_CTR)
#define mach_type_known
#endif
#if defined(NN_BUILD_TARGET_PLATFORM_NX)
#define NINTENDO_SWITCH
#define mach_type_known
#endif
#if defined(SYMBIAN)
#define mach_type_known
#endif
#if defined(__EMSCRIPTEN__)
#define I386
#define mach_type_known
#endif
#if!defined(mach_type_known)&&!defined(CPPCHECK)
#error The collector has not been ported to this machine/OS combination
#endif
#if GC_GNUC_PREREQ(2,8)&&!defined(__INTEL_COMPILER)&&!defined(__PATHCC__)&&!defined(__FUJITSU)&&!(defined(POWERPC)&&defined(DARWIN))&&!defined(RTEMS)&&!defined(__ARMCC_VERSION)&&!defined(__clang__)
#define HAVE_BUILTIN_UNWIND_INIT
#endif
#ifdef SYMBIAN
#define MACH_TYPE "SYMBIAN"
#define OS_TYPE "SYMBIAN"
#define CPP_WORDSZ 32
#define ALIGNMENT 4
#define DATASTART (ptr_t)ALIGNMENT
#define DATAEND (ptr_t)ALIGNMENT
#endif
#define STACK_GRAN 0x1000000
#ifdef M68K
#define MACH_TYPE "M68K"
#define ALIGNMENT 2
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#define HEURISTIC2
#ifdef __ELF__
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#define DYNAMIC_LOADING
#else
extern char etext[];
#define DATASTART ((ptr_t)(etext))
#endif
#endif
#ifdef NETBSD
#define OS_TYPE "NETBSD"
#define HEURISTIC2
#ifdef __ELF__
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#define DYNAMIC_LOADING
#else
extern char etext[];
#define DATASTART ((ptr_t)(etext))
#endif
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#if!defined(REDIRECT_MALLOC)
#define MPROTECT_VDB
#endif
#ifdef __ELF__
#define DYNAMIC_LOADING
EXTERN_C_END
#include <features.h>
EXTERN_C_BEGIN
#if defined(__GLIBC__)&&__GLIBC__>=2
#define SEARCH_FOR_DATA_START
#else
extern char**__environ;
#define DATASTART ((ptr_t)(&__environ))
#endif
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#else
extern int etext[];
#define DATASTART ((ptr_t)((((word)(etext))+0xfff)&~0xfff))
#endif
#endif
#ifdef AMIGA
#define OS_TYPE "AMIGA"
#define DATAEND
#define GETPAGESIZE()4096
#endif
#ifdef MACOS
#ifndef __LOWMEM__
EXTERN_C_END
#include <LowMem.h>
EXTERN_C_BEGIN
#endif
#define OS_TYPE "MACOS"
#define STACKBOTTOM ((ptr_t)LMGetCurStackBase())
#define DATAEND
#define GETPAGESIZE()4096
#endif
#ifdef NEXT
#define OS_TYPE "NEXT"
#define DATASTART ((ptr_t)get_etext())
#define DATASTART_IS_FUNC
#define STACKBOTTOM ((ptr_t)0x4000000)
#define DATAEND
#endif
#endif
#ifdef POWERPC
#define MACH_TYPE "POWERPC"
#ifdef MACOS
#define ALIGNMENT 2
#ifndef __LOWMEM__
EXTERN_C_END
#include <LowMem.h>
EXTERN_C_BEGIN
#endif
#define OS_TYPE "MACOS"
#define STACKBOTTOM ((ptr_t)LMGetCurStackBase())
#define DATAEND
#endif
#ifdef LINUX
#if defined(__powerpc64__)
#define ALIGNMENT 8
#define CPP_WORDSZ 64
#ifndef HBLKSIZE
#define HBLKSIZE 4096
#endif
#else
#define ALIGNMENT 4
#endif
#define OS_TYPE "LINUX"
#if defined(__bg__)
#define HEURISTIC2
#define NO_PTHREAD_GETATTR_NP
#else
#define LINUX_STACKBOTTOM
#endif
#define COUNT_UNMAPPED_REGIONS
#define DYNAMIC_LOADING
#define SEARCH_FOR_DATA_START
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#endif
#ifdef DARWIN
#define OS_TYPE "DARWIN"
#define DYNAMIC_LOADING
#if defined(__ppc64__)
#define ALIGNMENT 8
#define CPP_WORDSZ 64
#define STACKBOTTOM ((ptr_t)0x7fff5fc00000)
#define CACHE_LINE_SIZE 64
#ifndef HBLKSIZE
#define HBLKSIZE 4096
#endif
#else
#define ALIGNMENT 4
#define STACKBOTTOM ((ptr_t)0xc0000000)
#endif
#define DATASTART ((ptr_t)get_etext())
#define DATAEND ((ptr_t)get_end())
#define USE_MMAP_ANON
#define MPROTECT_VDB
EXTERN_C_END
#include <unistd.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)getpagesize()
#if defined(USE_PPC_PREFETCH)&&defined(__GNUC__)
#define PREFETCH(x)__asm__ __volatile__ ("dcbt 0,%0"::"r" ((const void*)(x)))
#define GC_PREFETCH_FOR_WRITE(x)__asm__ __volatile__ ("dcbtst 0,%0"::"r" ((const void*)(x)))
#endif
#define NO_PTHREAD_TRYLOCK
#endif
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#if defined(__powerpc64__)
#define ALIGNMENT 8
#define CPP_WORDSZ 64
#else
#define ALIGNMENT 4
#endif
#ifndef GC_OPENBSD_THREADS
#define HEURISTIC2
#endif
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#define DYNAMIC_LOADING
#endif
#ifdef FREEBSD
#if defined(__powerpc64__)
#define ALIGNMENT 8
#define CPP_WORDSZ 64
#ifndef HBLKSIZE
#define HBLKSIZE 4096
#endif
#else
#define ALIGNMENT 4
#endif
#define OS_TYPE "FREEBSD"
#ifndef GC_FREEBSD_THREADS
#define MPROTECT_VDB
#endif
#define SIG_SUSPEND SIGUSR1
#define SIG_THR_RESTART SIGUSR2
#define FREEBSD_STACKBOTTOM
#define DYNAMIC_LOADING
extern char etext[];
#define DATASTART GC_FreeBSDGetDataStart(0x1000,(ptr_t)etext)
#define DATASTART_USES_BSDGETDATASTART
#endif
#ifdef NETBSD
#define ALIGNMENT 4
#define OS_TYPE "NETBSD"
#define HEURISTIC2
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#define DYNAMIC_LOADING
#endif
#ifdef SN_TARGET_PS3
#define OS_TYPE "SN_TARGET_PS3"
#define NO_GETENV
#define CPP_WORDSZ 32
#define ALIGNMENT 4
extern int _end[];
extern int __bss_start;
#define DATASTART ((ptr_t)(__bss_start))
#define DATAEND ((ptr_t)(_end))
#define STACKBOTTOM ((ptr_t)ps3_get_stack_bottom())
#define NO_PTHREAD_TRYLOCK
#endif
#ifdef AIX
#define OS_TYPE "AIX"
#undef ALIGNMENT
#undef IA64
#ifdef __64BIT__
#define ALIGNMENT 8
#define CPP_WORDSZ 64
#define STACKBOTTOM ((ptr_t)0x1000000000000000)
#else
#define ALIGNMENT 4
#define CPP_WORDSZ 32
#define STACKBOTTOM ((ptr_t)((ulong)&errno))
#endif
#define USE_MMAP_ANON
extern int _data[],_end[];
#define DATASTART ((ptr_t)((ulong)_data))
#define DATAEND ((ptr_t)((ulong)_end))
extern int errno;
#define DYNAMIC_LOADING
#endif
#ifdef NOSYS
#define ALIGNMENT 4
#define OS_TYPE "NOSYS"
extern void __end[],__dso_handle[];
#define DATASTART ((ptr_t)__dso_handle)
#define DATAEND ((ptr_t)(__end))
#undef STACK_GRAN
#define STACK_GRAN 0x10000000
#define HEURISTIC1
#endif
#endif
#ifdef NACL
#define OS_TYPE "NACL"
#if defined(__GLIBC__)
#define DYNAMIC_LOADING
#endif
#define DATASTART ((ptr_t)0x10020000)
extern int _end[];
#define DATAEND ((ptr_t)_end)
#undef STACK_GRAN
#define STACK_GRAN 0x10000
#define HEURISTIC1
#define NO_PTHREAD_GETATTR_NP
#define USE_MMAP_ANON
#define GETPAGESIZE()65536
#define MAX_NACL_GC_THREADS 1024
#endif
#ifdef VAX
#define MACH_TYPE "VAX"
#define ALIGNMENT 4
extern char etext[];
#define DATASTART ((ptr_t)(etext))
#ifdef BSD
#define OS_TYPE "BSD"
#define HEURISTIC1
#endif
#ifdef ULTRIX
#define OS_TYPE "ULTRIX"
#define STACKBOTTOM ((ptr_t)0x7fffc800)
#endif
#endif
#ifdef SPARC
#define MACH_TYPE "SPARC"
#if defined(__arch64__)||defined(__sparcv9)
#define ALIGNMENT 8
#define CPP_WORDSZ 64
#define ELF_CLASS ELFCLASS64
#else
#define ALIGNMENT 4
#define CPP_WORDSZ 32
#endif
#ifdef SOLARIS
#define OS_TYPE "SOLARIS"
extern int _etext[];
extern int _end[];
ptr_t GC_SysVGetDataStart(size_t,ptr_t);
#define DATASTART GC_SysVGetDataStart(0x10000,(ptr_t)_etext)
#define DATASTART_IS_FUNC
#define DATAEND ((ptr_t)(_end))
#if!defined(USE_MMAP)&&defined(REDIRECT_MALLOC)
#define USE_MMAP 1
#endif
#ifdef USE_MMAP
#define HEAP_START (ptr_t)0x40000000
#else
#define HEAP_START DATAEND
#endif
#define PROC_VDB
EXTERN_C_END
#include <sys/vmparam.h>
#include <unistd.h>
EXTERN_C_BEGIN
#ifdef USERLIMIT
#define STACKBOTTOM ((ptr_t)USRSTACK)
#else
#define HEURISTIC2
#endif
#define GETPAGESIZE()(unsigned)sysconf(_SC_PAGESIZE)
#define DYNAMIC_LOADING
#endif
#ifdef DRSNX
#define OS_TYPE "DRSNX"
extern int etext[];
ptr_t GC_SysVGetDataStart(size_t,ptr_t);
#define DATASTART GC_SysVGetDataStart(0x10000,(ptr_t)etext)
#define DATASTART_IS_FUNC
#define MPROTECT_VDB
#define STACKBOTTOM ((ptr_t)0xdfff0000)
#define DYNAMIC_LOADING
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
#ifdef __ELF__
#define DYNAMIC_LOADING
#elif!defined(CPPCHECK)
#error Linux SPARC a.out not supported
#endif
#define COUNT_UNMAPPED_REGIONS
extern int _end[];
extern int _etext[];
#define DATAEND ((ptr_t)(_end))
#define SVR4
ptr_t GC_SysVGetDataStart(size_t,ptr_t);
#ifdef __arch64__
#define DATASTART GC_SysVGetDataStart(0x100000,(ptr_t)_etext)
#else
#define DATASTART GC_SysVGetDataStart(0x10000,(ptr_t)_etext)
#endif
#define DATASTART_IS_FUNC
#define LINUX_STACKBOTTOM
#endif
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#ifndef GC_OPENBSD_THREADS
#define HEURISTIC2
#endif
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#define DYNAMIC_LOADING
#endif
#ifdef NETBSD
#define OS_TYPE "NETBSD"
#define HEURISTIC2
#ifdef __ELF__
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#define DYNAMIC_LOADING
#else
extern char etext[];
#define DATASTART ((ptr_t)(etext))
#endif
#endif
#ifdef FREEBSD
#define OS_TYPE "FREEBSD"
#define SIG_SUSPEND SIGUSR1
#define SIG_THR_RESTART SIGUSR2
#define FREEBSD_STACKBOTTOM
#define DYNAMIC_LOADING
extern char etext[];
extern char edata[];
#if!defined(CPPCHECK)
extern char end[];
#endif
#define NEED_FIND_LIMIT
#define DATASTART ((ptr_t)(&etext))
void*GC_find_limit(void*,int);
#define DATAEND (ptr_t)GC_find_limit(DATASTART,TRUE)
#define DATAEND_IS_FUNC
#define GC_HAVE_DATAREGION2
#define DATASTART2 ((ptr_t)(&edata))
#define DATAEND2 ((ptr_t)(&end))
#endif
#endif
#ifdef I386
#define MACH_TYPE "I386"
#if (defined(__LP64__)||defined(_WIN64))&&!defined(CPPCHECK)
#error This should be handled as X86_64
#else
#define CPP_WORDSZ 32
#define ALIGNMENT 4
#endif
#ifdef SEQUENT
#define OS_TYPE "SEQUENT"
extern int etext[];
#define DATASTART ((ptr_t)((((word)(etext))+0xfff)&~0xfff))
#define STACKBOTTOM ((ptr_t)0x3ffff000)
#endif
#if defined(__EMSCRIPTEN__)
#define OS_TYPE "EMSCRIPTEN"
#define DATASTART (ptr_t)ALIGNMENT
#define DATAEND (ptr_t)ALIGNMENT
#define USE_MMAP_ANON
#define STACK_GROWS_DOWN
#endif
#if defined(__QNX__)
#define OS_TYPE "QNX"
#define SA_RESTART 0
#define HEURISTIC1
extern char etext[];
extern int _end[];
#define DATASTART ((ptr_t)etext)
#define DATAEND ((ptr_t)_end)
#endif
#ifdef HAIKU
#define OS_TYPE "HAIKU"
EXTERN_C_END
#include <OS.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)B_PAGE_SIZE
extern int etext[];
#define DATASTART ((ptr_t)((((word)(etext))+0xfff)&~0xfff))
#define DYNAMIC_LOADING
#define MPROTECT_VDB
#endif
#ifdef SOLARIS
#define OS_TYPE "SOLARIS"
extern int _etext[],_end[];
ptr_t GC_SysVGetDataStart(size_t,ptr_t);
#define DATASTART GC_SysVGetDataStart(0x1000,(ptr_t)_etext)
#define DATASTART_IS_FUNC
#define DATAEND ((ptr_t)(_end))
EXTERN_C_END
#include <sys/vmparam.h>
EXTERN_C_BEGIN
#ifdef USERLIMIT
#define STACKBOTTOM ((ptr_t)USRSTACK)
#else
#define HEURISTIC2
#endif
#ifdef SOLARIS25_PROC_VDB_BUG_FIXED
#define PROC_VDB
#endif
#ifndef GC_THREADS
#define MPROTECT_VDB
#endif
#define DYNAMIC_LOADING
#if!defined(USE_MMAP)&&defined(REDIRECT_MALLOC)
#define USE_MMAP 1
#endif
#ifdef USE_MMAP
#define HEAP_START (ptr_t)0x40000000
#else
#define HEAP_START DATAEND
#endif
#endif
#ifdef SCO
#define OS_TYPE "SCO"
extern int etext[];
#define DATASTART ((ptr_t)((((word)(etext))+0x3fffff)&~0x3fffff)+((word)(etext)&0xfff))
#define STACKBOTTOM ((ptr_t)0x7ffffffc)
#endif
#ifdef SCO_ELF
#define OS_TYPE "SCO_ELF"
extern int etext[];
#define DATASTART ((ptr_t)(etext))
#define STACKBOTTOM ((ptr_t)0x08048000)
#define DYNAMIC_LOADING
#define ELF_CLASS ELFCLASS32
#endif
#ifdef DGUX
#define OS_TYPE "DGUX"
extern int _etext,_end;
ptr_t GC_SysVGetDataStart(size_t,ptr_t);
#define DATASTART GC_SysVGetDataStart(0x1000,(ptr_t)(&_etext))
#define DATASTART_IS_FUNC
#define DATAEND ((ptr_t)(&_end))
#define STACK_GROWS_DOWN
#define HEURISTIC2
EXTERN_C_END
#include <unistd.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)sysconf(_SC_PAGESIZE)
#define DYNAMIC_LOADING
#ifndef USE_MMAP
#define USE_MMAP 1
#endif
#define MAP_FAILED (void*)((word)-1)
#define HEAP_START (ptr_t)0x40000000
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#if!defined(REDIRECT_MALLOC)
#define MPROTECT_VDB
#else
#endif
#define HEAP_START (ptr_t)0x1000
#ifdef __ELF__
#define DYNAMIC_LOADING
EXTERN_C_END
#include <features.h>
EXTERN_C_BEGIN
#if defined(__GLIBC__)&&__GLIBC__>=2||defined(HOST_ANDROID)||defined(HOST_TIZEN)
#define SEARCH_FOR_DATA_START
#else
extern char**__environ;
#define DATASTART ((ptr_t)(&__environ))
#endif
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#if!defined(GC_NO_SIGSETJMP)&&(defined(HOST_TIZEN)||(defined(HOST_ANDROID)&&!(GC_GNUC_PREREQ(4,8)||GC_CLANG_PREREQ(3,2)||__ANDROID_API__>=18)))
#define GC_NO_SIGSETJMP 1
#endif
#else
extern int etext[];
#define DATASTART ((ptr_t)((((word)(etext))+0xfff)&~0xfff))
#endif
#ifdef USE_I686_PREFETCH
#define PREFETCH(x)__asm__ __volatile__ ("prefetchnta %0"::"m"(*(char*)(x)))
#ifdef FORCE_WRITE_PREFETCH
#define GC_PREFETCH_FOR_WRITE(x)__asm__ __volatile__ ("prefetcht0 %0"::"m"(*(char*)(x)))
#else
#define GC_NO_PREFETCH_FOR_WRITE
#endif
#elif defined(USE_3DNOW_PREFETCH)
#define PREFETCH(x)__asm__ __volatile__ ("prefetch %0"::"m"(*(char*)(x)))
#define GC_PREFETCH_FOR_WRITE(x)__asm__ __volatile__ ("prefetchw %0"::"m"(*(char*)(x)))
#endif
#if defined(__GLIBC__)&&!defined(__UCLIBC__)
#define GLIBC_2_19_TSX_BUG
EXTERN_C_END
#include <gnu/libc-version.h>
EXTERN_C_BEGIN
#endif
#endif
#ifdef CYGWIN32
#define OS_TYPE "CYGWIN32"
#define WOW64_THREAD_CONTEXT_WORKAROUND
#define RETRY_GET_THREAD_CONTEXT
#define DATASTART ((ptr_t)GC_DATASTART)
#define DATAEND ((ptr_t)GC_DATAEND)
#ifdef USE_WINALLOC
#define GWW_VDB
#else
#
#ifdef USE_MMAP
#define NEED_FIND_LIMIT
#define USE_MMAP_ANON
#endif
#endif
#endif
#ifdef INTERIX
#define OS_TYPE "INTERIX"
extern int _data_start__[];
extern int _bss_end__[];
#define DATASTART ((ptr_t)_data_start__)
#define DATAEND ((ptr_t)_bss_end__)
#define STACKBOTTOM ({ ptr_t rv;__asm__ __volatile__ ("movl %%fs:4,%%eax":"=a" (rv));rv;})
#define USE_MMAP_ANON
#endif
#ifdef OS2
#define OS_TYPE "OS2"
#define DATAEND
#endif
#ifdef MSWIN32
#define OS_TYPE "MSWIN32"
#define WOW64_THREAD_CONTEXT_WORKAROUND
#define RETRY_GET_THREAD_CONTEXT
#define MPROTECT_VDB
#define GWW_VDB
#define DATAEND
#endif
#ifdef MSWINCE
#define OS_TYPE "MSWINCE"
#define DATAEND
#endif
#ifdef DJGPP
#define OS_TYPE "DJGPP"
EXTERN_C_END
#include "stubinfo.h"
EXTERN_C_BEGIN
extern int etext[];
extern int _stklen;
extern int __djgpp_stack_limit;
#define DATASTART ((ptr_t)((((word)(etext))+0x1ff)&~0x1ff))
#define STACKBOTTOM ((ptr_t)((word)__djgpp_stack_limit+_stklen))
#endif
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#ifndef GC_OPENBSD_THREADS
#define HEURISTIC2
#endif
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#define DYNAMIC_LOADING
#endif
#ifdef FREEBSD
#define OS_TYPE "FREEBSD"
#ifndef GC_FREEBSD_THREADS
#define MPROTECT_VDB
#endif
#ifdef __GLIBC__
#define SIG_SUSPEND (32+6)
#define SIG_THR_RESTART (32+5)
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#else
#define SIG_SUSPEND SIGUSR1
#define SIG_THR_RESTART SIGUSR2
#endif
#define FREEBSD_STACKBOTTOM
#ifdef __ELF__
#define DYNAMIC_LOADING
#endif
extern char etext[];
#define DATASTART GC_FreeBSDGetDataStart(0x1000,(ptr_t)etext)
#define DATASTART_USES_BSDGETDATASTART
#endif
#ifdef NETBSD
#define OS_TYPE "NETBSD"
#ifdef __ELF__
#define DYNAMIC_LOADING
#endif
#endif
#ifdef THREE86BSD
#define OS_TYPE "THREE86BSD"
#endif
#ifdef BSDI
#define OS_TYPE "BSDI"
#endif
#if defined(NETBSD)||defined(THREE86BSD)||defined(BSDI)
#define HEURISTIC2
extern char etext[];
#define DATASTART ((ptr_t)(etext))
#endif
#ifdef NEXT
#define OS_TYPE "NEXT"
#define DATASTART ((ptr_t)get_etext())
#define DATASTART_IS_FUNC
#define STACKBOTTOM ((ptr_t)0xc0000000)
#define DATAEND
#endif
#ifdef RTEMS
#define OS_TYPE "RTEMS"
EXTERN_C_END
#include <sys/unistd.h>
EXTERN_C_BEGIN
extern int etext[];
void*rtems_get_stack_bottom(void);
#define InitStackBottom rtems_get_stack_bottom()
#define DATASTART ((ptr_t)etext)
#define STACKBOTTOM ((ptr_t)InitStackBottom)
#define SIG_SUSPEND SIGUSR1
#define SIG_THR_RESTART SIGUSR2
#endif
#ifdef DOS4GW
#define OS_TYPE "DOS4GW"
extern long __nullarea;
extern char _end;
extern char*_STACKTOP;
#pragma aux __nullarea "*";
#pragma aux _end "*";
#define STACKBOTTOM ((ptr_t)_STACKTOP)
#define DATASTART ((ptr_t)(&__nullarea))
#define DATAEND ((ptr_t)(&_end))
#endif
#ifdef HURD
#define OS_TYPE "HURD"
#define STACK_GROWS_DOWN
#define HEURISTIC2
#define SIG_SUSPEND SIGUSR1
#define SIG_THR_RESTART SIGUSR2
#define SEARCH_FOR_DATA_START
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#define DYNAMIC_LOADING
#define USE_MMAP_ANON
#endif
#ifdef DARWIN
#define OS_TYPE "DARWIN"
#define DARWIN_DONT_PARSE_STACK 1
#define DYNAMIC_LOADING
#define DATASTART ((ptr_t)get_etext())
#define DATAEND ((ptr_t)get_end())
#define STACKBOTTOM ((ptr_t)0xc0000000)
#define USE_MMAP_ANON
#define MPROTECT_VDB
EXTERN_C_END
#include <unistd.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)getpagesize()
#define NO_PTHREAD_TRYLOCK
#if TARGET_OS_IPHONE&&!defined(NO_DYLD_BIND_FULLY_IMAGE)
#define NO_DYLD_BIND_FULLY_IMAGE
#endif
#endif
#endif
#ifdef NS32K
#define MACH_TYPE "NS32K"
#define ALIGNMENT 4
extern char**environ;
#define DATASTART ((ptr_t)(&environ))
#define STACKBOTTOM ((ptr_t)0xfffff000)
#endif
#ifdef MIPS
#define MACH_TYPE "MIPS"
#ifdef LINUX
#define OS_TYPE "LINUX"
#define DYNAMIC_LOADING
#define COUNT_UNMAPPED_REGIONS
extern int _end[];
#pragma weak __data_start
extern int __data_start[];
#define DATASTART ((ptr_t)(__data_start))
#define DATAEND ((ptr_t)(_end))
#ifdef _MIPS_SZPTR
#define CPP_WORDSZ _MIPS_SZPTR
#define ALIGNMENT (_MIPS_SZPTR/8)
#else
#define ALIGNMENT 4
#endif
#ifndef HBLKSIZE
#define HBLKSIZE 4096
#endif
#if __GLIBC__==2&&__GLIBC_MINOR__>=2||__GLIBC__ > 2
#define LINUX_STACKBOTTOM
#else
#define STACKBOTTOM ((ptr_t)0x7fff8000)
#endif
#endif
#ifdef EWS4800
#define HEURISTIC2
#if defined(_MIPS_SZPTR)&&(_MIPS_SZPTR==64)
extern int _fdata[],_end[];
#define DATASTART ((ptr_t)_fdata)
#define DATAEND ((ptr_t)_end)
#define CPP_WORDSZ _MIPS_SZPTR
#define ALIGNMENT (_MIPS_SZPTR/8)
#else
extern int etext[],edata[];
#if!defined(CPPCHECK)
extern int end[];
#endif
extern int _DYNAMIC_LINKING[],_gp[];
#define DATASTART ((ptr_t)((((word)(etext)+0x3ffff)&~0x3ffff)+((word)(etext)&0xffff)))
#define DATAEND ((ptr_t)(edata))
#define GC_HAVE_DATAREGION2
#define DATASTART2 (_DYNAMIC_LINKING?(ptr_t)(((word)_gp+0x8000+0x3ffff)&~0x3ffff):(ptr_t)edata)
#define DATAEND2 ((ptr_t)(end))
#define ALIGNMENT 4
#endif
#define OS_TYPE "EWS4800"
#endif
#ifdef ULTRIX
#define HEURISTIC2
#define DATASTART ((ptr_t)0x10000000)
#define OS_TYPE "ULTRIX"
#define ALIGNMENT 4
#endif
#ifdef IRIX5
#define HEURISTIC2
extern int _fdata[];
#define DATASTART ((ptr_t)(_fdata))
#ifdef USE_MMAP
#define HEAP_START (ptr_t)0x30000000
#else
#define HEAP_START DATASTART
#endif
#define OS_TYPE "IRIX5"
#ifdef _MIPS_SZPTR
#define CPP_WORDSZ _MIPS_SZPTR
#define ALIGNMENT (_MIPS_SZPTR/8)
#else
#define ALIGNMENT 4
#endif
#define DYNAMIC_LOADING
#endif
#ifdef MSWINCE
#define OS_TYPE "MSWINCE"
#define ALIGNMENT 4
#define DATAEND
#endif
#ifdef NETBSD
#define OS_TYPE "NETBSD"
#define ALIGNMENT 4
#define HEURISTIC2
#ifdef __ELF__
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#define NEED_FIND_LIMIT
#define DYNAMIC_LOADING
#else
#define DATASTART ((ptr_t)0x10000000)
#define STACKBOTTOM ((ptr_t)0x7ffff000)
#endif
#endif
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#define CPP_WORDSZ 64
#define ALIGNMENT 8
#ifndef GC_OPENBSD_THREADS
#define HEURISTIC2
#endif
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#define DYNAMIC_LOADING
#endif
#ifdef FREEBSD
#define OS_TYPE "FREEBSD"
#define ALIGNMENT 4
#ifndef GC_FREEBSD_THREADS
#define MPROTECT_VDB
#endif
#define SIG_SUSPEND SIGUSR1
#define SIG_THR_RESTART SIGUSR2
#define FREEBSD_STACKBOTTOM
#define DYNAMIC_LOADING
extern char etext[];
#define DATASTART GC_FreeBSDGetDataStart(0x1000,(ptr_t)etext)
#define DATASTART_USES_BSDGETDATASTART
#endif
#if defined(NONSTOP)
#define CPP_WORDSZ 32
#define OS_TYPE "NONSTOP"
#define ALIGNMENT 4
#define DATASTART ((ptr_t)0x08000000)
extern char**environ;
#define DATAEND ((ptr_t)(environ - 0x10))
#define STACKBOTTOM ((ptr_t)0x4fffffff)
#endif
#endif
#ifdef NIOS2
#define CPP_WORDSZ 32
#define MACH_TYPE "NIOS2"
#ifdef LINUX
#define OS_TYPE "LINUX"
#define DYNAMIC_LOADING
#define COUNT_UNMAPPED_REGIONS
extern int _end[];
extern int __data_start[];
#define DATASTART ((ptr_t)(__data_start))
#define DATAEND ((ptr_t)(_end))
#define ALIGNMENT 4
#ifndef HBLKSIZE
#define HBLKSIZE 4096
#endif
#define LINUX_STACKBOTTOM
#endif
#endif
#ifdef OR1K
#define CPP_WORDSZ 32
#define MACH_TYPE "OR1K"
#ifdef LINUX
#define OS_TYPE "LINUX"
#define DYNAMIC_LOADING
#define COUNT_UNMAPPED_REGIONS
extern int _end[];
extern int __data_start[];
#define DATASTART ((ptr_t)(__data_start))
#define DATAEND ((ptr_t)(_end))
#define ALIGNMENT 4
#ifndef HBLKSIZE
#define HBLKSIZE 4096
#endif
#define LINUX_STACKBOTTOM
#endif
#endif
#ifdef HP_PA
#define MACH_TYPE "HP_PA"
#ifdef __LP64__
#define CPP_WORDSZ 64
#define ALIGNMENT 8
#else
#define CPP_WORDSZ 32
#define ALIGNMENT 4
#endif
#if!defined(GC_HPUX_THREADS)&&!defined(GC_LINUX_THREADS)&&!defined(OPENBSD)&&!defined(LINUX)
#define MPROTECT_VDB
#endif
#define STACK_GROWS_UP
#ifdef HPUX
#define OS_TYPE "HPUX"
extern int __data_start[];
#define DATASTART ((ptr_t)(__data_start))
#ifdef USE_MMAP
#define USE_MMAP_ANON
#endif
#ifdef USE_HPUX_FIXED_STACKBOTTOM
#define STACKBOTTOM ((ptr_t)0x7b033000)
#elif defined(USE_ENVIRON_POINTER)
extern char**environ;
#define STACKBOTTOM ((ptr_t)environ)
#elif!defined(HEURISTIC2)
#define HPUX_MAIN_STACKBOTTOM
#define NEED_FIND_LIMIT
#endif
#define DYNAMIC_LOADING
EXTERN_C_END
#include <unistd.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)sysconf(_SC_PAGE_SIZE)
#ifndef __GNUC__
#define PREFETCH(x)do { register long addr=(long)(x);(void)_asm ("LDW",0,0,addr,0);} while (0)
#endif
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#define DYNAMIC_LOADING
#define SEARCH_FOR_DATA_START
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#endif
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#ifndef GC_OPENBSD_THREADS
#define HEURISTIC2
#endif
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#define DYNAMIC_LOADING
#endif
#endif
#ifdef ALPHA
#define MACH_TYPE "ALPHA"
#define ALIGNMENT 8
#define CPP_WORDSZ 64
#ifdef NETBSD
#define OS_TYPE "NETBSD"
#define HEURISTIC2
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#define ELFCLASS32 32
#define ELFCLASS64 64
#define ELF_CLASS ELFCLASS64
#define DYNAMIC_LOADING
#endif
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#ifndef GC_OPENBSD_THREADS
#define HEURISTIC2
#endif
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#define DYNAMIC_LOADING
#endif
#ifdef FREEBSD
#define OS_TYPE "FREEBSD"
#define SIG_SUSPEND SIGUSR1
#define SIG_THR_RESTART SIGUSR2
#define FREEBSD_STACKBOTTOM
#define DYNAMIC_LOADING
extern char etext[];
extern char edata[];
#if!defined(CPPCHECK)
extern char end[];
#endif
#define NEED_FIND_LIMIT
#define DATASTART ((ptr_t)(&etext))
void*GC_find_limit(void*,int);
#define DATAEND (ptr_t)GC_find_limit(DATASTART,TRUE)
#define DATAEND_IS_FUNC
#define GC_HAVE_DATAREGION2
#define DATASTART2 ((ptr_t)(&edata))
#define DATAEND2 ((ptr_t)(&end))
#endif
#ifdef OSF1
#define OS_TYPE "OSF1"
#define DATASTART ((ptr_t)0x140000000)
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
extern char**environ;
#define STACKBOTTOM ((ptr_t)(((word)(environ)|(getpagesize()-1))+1))
extern int __start[];
#define HEURISTIC2_LIMIT ((ptr_t)((word)(__start)&~(getpagesize()-1)))
#ifndef GC_OSF1_THREADS
#define MPROTECT_VDB
#endif
#define DYNAMIC_LOADING
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#ifdef __ELF__
#define SEARCH_FOR_DATA_START
#define DYNAMIC_LOADING
#else
#define DATASTART ((ptr_t)0x140000000)
#endif
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#if!defined(REDIRECT_MALLOC)
#define MPROTECT_VDB
#endif
#endif
#endif
#ifdef IA64
#define MACH_TYPE "IA64"
#ifdef HPUX
#ifdef _ILP32
#define CPP_WORDSZ 32
#define ALIGNMENT 4
#else
#if!defined(_LP64)&&!defined(CPPCHECK)
#error Unknown ABI
#endif
#define CPP_WORDSZ 64
#define ALIGNMENT 8
#endif
#define OS_TYPE "HPUX"
extern int __data_start[];
#define DATASTART ((ptr_t)(__data_start))
#ifdef USE_MMAP
#define USE_MMAP_ANON
#endif
extern char**environ;
#define STACKBOTTOM ((ptr_t)environ)
#define HPUX_STACKBOTTOM
#define DYNAMIC_LOADING
EXTERN_C_END
#include <unistd.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)sysconf(_SC_PAGE_SIZE)
#define BACKING_STORE_DISPLACEMENT 0x1000000
#define BACKING_STORE_ALIGNMENT 0x1000
extern ptr_t GC_register_stackbottom;
#define BACKING_STORE_BASE GC_register_stackbottom
#endif
#ifdef LINUX
#define CPP_WORDSZ 64
#define ALIGNMENT 8
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
extern ptr_t GC_register_stackbottom;
#define BACKING_STORE_BASE GC_register_stackbottom
#define COUNT_UNMAPPED_REGIONS
#define SEARCH_FOR_DATA_START
#ifdef __GNUC__
#define DYNAMIC_LOADING
#else
#endif
#if!defined(REDIRECT_MALLOC)
#define MPROTECT_VDB
#endif
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#ifdef __GNUC__
#ifndef __INTEL_COMPILER
#define PREFETCH(x)__asm__ (" lfetch [%0]"::"r"(x))
#define GC_PREFETCH_FOR_WRITE(x)__asm__ (" lfetch.excl [%0]"::"r"(x))
#define CLEAR_DOUBLE(x)__asm__ (" stf.spill [%0]=f0"::"r"((void*)(x)))
#else
EXTERN_C_END
#include <ia64intrin.h>
EXTERN_C_BEGIN
#define PREFETCH(x)__lfetch(__lfhint_none,(x))
#define GC_PREFETCH_FOR_WRITE(x)__lfetch(__lfhint_nta,(x))
#define CLEAR_DOUBLE(x)__stf_spill((void*)(x),0)
#endif
#endif
#endif
#ifdef MSWIN32
#define OS_TYPE "MSWIN32"
#define DATAEND
#if defined(_WIN64)
#define CPP_WORDSZ 64
#else
#define CPP_WORDSZ 32
#endif
#define ALIGNMENT 8
#endif
#endif
#ifdef M88K
#define MACH_TYPE "M88K"
#define ALIGNMENT 4
extern int etext[];
#ifdef CX_UX
#define OS_TYPE "CX_UX"
#define DATASTART ((ptr_t)((((word)(etext)+0x3fffff)&~0x3fffff)+0x10000))
#endif
#ifdef DGUX
#define OS_TYPE "DGUX"
ptr_t GC_SysVGetDataStart(size_t,ptr_t);
#define DATASTART GC_SysVGetDataStart(0x10000,(ptr_t)etext)
#define DATASTART_IS_FUNC
#endif
#define STACKBOTTOM ((char*)0xf0000000)
#endif
#ifdef S370
#define MACH_TYPE "S370"
#define ALIGNMENT 4
#ifdef UTS4
#define OS_TYPE "UTS4"
extern int etext[];
extern int _etext[];
extern int _end[];
ptr_t GC_SysVGetDataStart(size_t,ptr_t);
#define DATASTART GC_SysVGetDataStart(0x10000,(ptr_t)_etext)
#define DATASTART_IS_FUNC
#define DATAEND ((ptr_t)(_end))
#define HEURISTIC2
#endif
#endif
#ifdef S390
#define MACH_TYPE "S390"
#ifndef __s390x__
#define ALIGNMENT 4
#define CPP_WORDSZ 32
#else
#define ALIGNMENT 8
#define CPP_WORDSZ 64
#ifndef HBLKSIZE
#define HBLKSIZE 4096
#endif
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#define DYNAMIC_LOADING
#define COUNT_UNMAPPED_REGIONS
extern int __data_start[] __attribute__((__weak__));
#define DATASTART ((ptr_t)(__data_start))
extern int _end[] __attribute__((__weak__));
#define DATAEND ((ptr_t)(_end))
#define CACHE_LINE_SIZE 256
#define GETPAGESIZE()4096
#endif
#endif
#ifdef AARCH64
#define MACH_TYPE "AARCH64"
#ifdef __ILP32__
#define CPP_WORDSZ 32
#define ALIGNMENT 4
#else
#define CPP_WORDSZ 64
#define ALIGNMENT 8
#endif
#ifndef HBLKSIZE
#define HBLKSIZE 4096
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#if!defined(REDIRECT_MALLOC)
#define MPROTECT_VDB
#endif
#define DYNAMIC_LOADING
#if defined(HOST_ANDROID)
#define SEARCH_FOR_DATA_START
#else
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
#endif
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#endif
#ifdef DARWIN
#define OS_TYPE "DARWIN"
#define DARWIN_DONT_PARSE_STACK 1
#define DYNAMIC_LOADING
#define DATASTART ((ptr_t)get_etext())
#define DATAEND ((ptr_t)get_end())
#define STACKBOTTOM ((ptr_t)0x16fdfffff)
#define USE_MMAP_ANON
EXTERN_C_END
#include <unistd.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)getpagesize()
#define NO_PTHREAD_TRYLOCK
#if TARGET_OS_IPHONE&&!defined(NO_DYLD_BIND_FULLY_IMAGE)
#define NO_DYLD_BIND_FULLY_IMAGE
#endif
#endif
#ifdef FREEBSD
#define OS_TYPE "FREEBSD"
#ifndef GC_FREEBSD_THREADS
#define MPROTECT_VDB
#endif
#define FREEBSD_STACKBOTTOM
#define DYNAMIC_LOADING
extern char etext[];
#define DATASTART GC_FreeBSDGetDataStart(0x1000,(ptr_t)etext)
#define DATASTART_USES_BSDGETDATASTART
#endif
#ifdef NETBSD
#define OS_TYPE "NETBSD"
#define HEURISTIC2
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#define ELF_CLASS ELFCLASS64
#define DYNAMIC_LOADING
#endif
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#ifndef GC_OPENBSD_THREADS
#define HEURISTIC2
#endif
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#define DYNAMIC_LOADING
#endif
#ifdef NINTENDO_SWITCH
#define OS_TYPE "NINTENDO_SWITCH"
extern int __bss_end[];
#define NO_HANDLE_FORK 1
#define DATASTART (ptr_t)ALIGNMENT
#define DATAEND (ptr_t)(&__bss_end)
void*switch_get_stack_bottom(void);
#define STACKBOTTOM ((ptr_t)switch_get_stack_bottom())
#endif
#ifdef MSWIN32
#define OS_TYPE "MSWIN32"
#ifndef DATAEND
#define DATAEND
#endif
#endif
#ifdef NOSYS
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
extern void*__stack_base__;
#define STACKBOTTOM ((ptr_t)__stack_base__)
#endif
#endif
#ifdef ARM32
#if defined(NACL)
#define MACH_TYPE "NACL"
#else
#define MACH_TYPE "ARM32"
#endif
#define CPP_WORDSZ 32
#define ALIGNMENT 4
#ifdef NETBSD
#define OS_TYPE "NETBSD"
#define HEURISTIC2
#ifdef __ELF__
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#define DYNAMIC_LOADING
#else
extern char etext[];
#define DATASTART ((ptr_t)(etext))
#endif
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#if!defined(REDIRECT_MALLOC)
#define MPROTECT_VDB
#endif
#define DYNAMIC_LOADING
EXTERN_C_END
#include <features.h>
EXTERN_C_BEGIN
#if defined(__GLIBC__)&&__GLIBC__>=2||defined(HOST_ANDROID)||defined(HOST_TIZEN)
#define SEARCH_FOR_DATA_START
#else
extern char**__environ;
#define DATASTART ((ptr_t)(&__environ))
#endif
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#endif
#ifdef MSWINCE
#define OS_TYPE "MSWINCE"
#define DATAEND
#endif
#ifdef FREEBSD
#define OS_TYPE "FREEBSD"
#ifndef GC_FREEBSD_THREADS
#define MPROTECT_VDB
#endif
#define SIG_SUSPEND SIGUSR1
#define SIG_THR_RESTART SIGUSR2
#define FREEBSD_STACKBOTTOM
#define DYNAMIC_LOADING
extern char etext[];
#define DATASTART GC_FreeBSDGetDataStart(0x1000,(ptr_t)etext)
#define DATASTART_USES_BSDGETDATASTART
#endif
#ifdef DARWIN
#define OS_TYPE "DARWIN"
#define DARWIN_DONT_PARSE_STACK 1
#define DYNAMIC_LOADING
#define DATASTART ((ptr_t)get_etext())
#define DATAEND ((ptr_t)get_end())
#define STACKBOTTOM ((ptr_t)0x30000000)
#define USE_MMAP_ANON
EXTERN_C_END
#include <unistd.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)getpagesize()
#define NO_PTHREAD_TRYLOCK
#if TARGET_OS_IPHONE&&!defined(NO_DYLD_BIND_FULLY_IMAGE)
#define NO_DYLD_BIND_FULLY_IMAGE
#endif
#endif
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#ifndef GC_OPENBSD_THREADS
#define HEURISTIC2
#endif
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#define DYNAMIC_LOADING
#endif
#ifdef SN_TARGET_PSP2
#define OS_TYPE "SN_TARGET_PSP2"
#define NO_HANDLE_FORK 1
#define DATASTART (ptr_t)ALIGNMENT
#define DATAEND (ptr_t)ALIGNMENT
void*psp2_get_stack_bottom(void);
#define STACKBOTTOM ((ptr_t)psp2_get_stack_bottom())
#endif
#ifdef NN_PLATFORM_CTR
#define OS_TYPE "NN_PLATFORM_CTR"
extern unsigned char Image$$ZI$$ZI$$Base[];
#define DATASTART (ptr_t)(Image$$ZI$$ZI$$Base)
extern unsigned char Image$$ZI$$ZI$$Limit[];
#define DATAEND (ptr_t)(Image$$ZI$$ZI$$Limit)
void*n3ds_get_stack_bottom(void);
#define STACKBOTTOM ((ptr_t)n3ds_get_stack_bottom())
#endif
#ifdef MSWIN32
#define OS_TYPE "MSWIN32"
#ifndef DATAEND
#define DATAEND
#endif
#endif
#ifdef NOSYS
extern int __data_start[];
#define DATASTART ((ptr_t)(__data_start))
extern void*__stack_base__;
#define STACKBOTTOM ((ptr_t)(__stack_base__))
#endif
#endif
#ifdef CRIS
#define MACH_TYPE "CRIS"
#define CPP_WORDSZ 32
#define ALIGNMENT 1
#ifdef LINUX
#define OS_TYPE "LINUX"
#define DYNAMIC_LOADING
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#define SEARCH_FOR_DATA_START
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#endif
#endif
#if defined(SH)&&!defined(SH4)
#define MACH_TYPE "SH"
#define ALIGNMENT 4
#ifdef MSWINCE
#define OS_TYPE "MSWINCE"
#define DATAEND
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#define DYNAMIC_LOADING
#define SEARCH_FOR_DATA_START
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#endif
#ifdef NETBSD
#define OS_TYPE "NETBSD"
#define HEURISTIC2
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#define DYNAMIC_LOADING
#endif
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#ifndef GC_OPENBSD_THREADS
#define HEURISTIC2
#endif
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
extern int _end[];
#define DATAEND ((ptr_t)(&_end))
#define DYNAMIC_LOADING
#endif
#endif
#ifdef SH4
#define MACH_TYPE "SH4"
#define ALIGNMENT 4
#ifdef MSWINCE
#define OS_TYPE "MSWINCE"
#define DATAEND
#endif
#endif
#ifdef AVR32
#define MACH_TYPE "AVR32"
#define CPP_WORDSZ 32
#define ALIGNMENT 4
#ifdef LINUX
#define OS_TYPE "LINUX"
#define DYNAMIC_LOADING
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#define SEARCH_FOR_DATA_START
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#endif
#endif
#ifdef M32R
#define CPP_WORDSZ 32
#define MACH_TYPE "M32R"
#define ALIGNMENT 4
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#define DYNAMIC_LOADING
#define SEARCH_FOR_DATA_START
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#endif
#endif
#ifdef X86_64
#define MACH_TYPE "X86_64"
#ifdef __ILP32__
#define ALIGNMENT 4
#define CPP_WORDSZ 32
#else
#define ALIGNMENT 8
#define CPP_WORDSZ 64
#endif
#ifndef HBLKSIZE
#define HBLKSIZE 4096
#endif
#ifndef CACHE_LINE_SIZE
#define CACHE_LINE_SIZE 64
#endif
#ifdef SN_TARGET_ORBIS
#define OS_TYPE "SN_TARGET_ORBIS"
#define DATASTART (ptr_t)ALIGNMENT
#define DATAEND (ptr_t)ALIGNMENT
void*ps4_get_stack_bottom(void);
#define STACKBOTTOM ((ptr_t)ps4_get_stack_bottom())
#endif
#ifdef OPENBSD
#define OS_TYPE "OPENBSD"
#ifndef GC_OPENBSD_THREADS
#define HEURISTIC2
#endif
extern int __data_start[];
extern int _end[];
#define DATASTART ((ptr_t)__data_start)
#define DATAEND ((ptr_t)(&_end))
#define DYNAMIC_LOADING
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#if!defined(REDIRECT_MALLOC)
#define MPROTECT_VDB
#else
#endif
#define COUNT_UNMAPPED_REGIONS
#define DYNAMIC_LOADING
EXTERN_C_END
#include <features.h>
EXTERN_C_BEGIN
#define SEARCH_FOR_DATA_START
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#if defined(__GLIBC__)&&!defined(__UCLIBC__)
#define USE_MMAP_ANON
#define GETCONTEXT_FPU_EXCMASK_BUG
#define GLIBC_2_19_TSX_BUG
EXTERN_C_END
#include <gnu/libc-version.h>
EXTERN_C_BEGIN
#endif
#endif
#ifdef DARWIN
#define OS_TYPE "DARWIN"
#define DARWIN_DONT_PARSE_STACK 1
#define DYNAMIC_LOADING
#define DATASTART ((ptr_t)get_etext())
#define DATAEND ((ptr_t)get_end())
#define STACKBOTTOM ((ptr_t)0x7fff5fc00000)
#define USE_MMAP_ANON
#define MPROTECT_VDB
EXTERN_C_END
#include <unistd.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)getpagesize()
#define NO_PTHREAD_TRYLOCK
#if TARGET_OS_IPHONE&&!defined(NO_DYLD_BIND_FULLY_IMAGE)
#define NO_DYLD_BIND_FULLY_IMAGE
#endif
#endif
#ifdef FREEBSD
#define OS_TYPE "FREEBSD"
#ifndef GC_FREEBSD_THREADS
#define MPROTECT_VDB
#endif
#ifdef __GLIBC__
#define SIG_SUSPEND (32+6)
#define SIG_THR_RESTART (32+5)
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#else
#define SIG_SUSPEND SIGUSR1
#define SIG_THR_RESTART SIGUSR2
#endif
#define FREEBSD_STACKBOTTOM
#if defined(__DragonFly__)
#define COUNT_UNMAPPED_REGIONS
#endif
#define DYNAMIC_LOADING
extern char etext[];
#define DATASTART GC_FreeBSDGetDataStart(0x1000,(ptr_t)etext)
#define DATASTART_USES_BSDGETDATASTART
#endif
#ifdef NETBSD
#define OS_TYPE "NETBSD"
#define HEURISTIC2
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#define DYNAMIC_LOADING
#endif
#ifdef HAIKU
#define OS_TYPE "HAIKU"
EXTERN_C_END
#include <OS.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)B_PAGE_SIZE
#define HEURISTIC2
#define SEARCH_FOR_DATA_START
#define DYNAMIC_LOADING
#define MPROTECT_VDB
#endif
#ifdef SOLARIS
#define OS_TYPE "SOLARIS"
#define ELF_CLASS ELFCLASS64
extern int _etext[],_end[];
ptr_t GC_SysVGetDataStart(size_t,ptr_t);
#define DATASTART GC_SysVGetDataStart(0x1000,(ptr_t)_etext)
#define DATASTART_IS_FUNC
#define DATAEND ((ptr_t)(_end))
EXTERN_C_END
#include <sys/vmparam.h>
EXTERN_C_BEGIN
#ifdef USERLIMIT
#define STACKBOTTOM ((ptr_t)USRSTACK)
#else
#define HEURISTIC2
#endif
#ifdef SOLARIS25_PROC_VDB_BUG_FIXED
#define PROC_VDB
#endif
#ifndef GC_THREADS
#define MPROTECT_VDB
#endif
#define DYNAMIC_LOADING
#if!defined(USE_MMAP)&&defined(REDIRECT_MALLOC)
#define USE_MMAP 1
#endif
#ifdef USE_MMAP
#define HEAP_START (ptr_t)0x40000000
#else
#define HEAP_START DATAEND
#endif
#endif
#ifdef CYGWIN32
#define OS_TYPE "CYGWIN32"
#define RETRY_GET_THREAD_CONTEXT
#ifdef USE_WINALLOC
#define GWW_VDB
#else
#if defined(THREAD_LOCAL_ALLOC)
#else
#define MPROTECT_VDB
#endif
#ifdef USE_MMAP
#define USE_MMAP_ANON
#endif
#endif
#endif
#ifdef MSWIN_XBOX1
#define OS_TYPE "MSWIN_XBOX1"
#define NO_GETENV
#define DATASTART (ptr_t)ALIGNMENT
#define DATAEND (ptr_t)ALIGNMENT
LONG64 durango_get_stack_bottom(void);
#define STACKBOTTOM ((ptr_t)durango_get_stack_bottom())
#define GETPAGESIZE()4096
#ifndef USE_MMAP
#define USE_MMAP 1
#endif
#define PROT_NONE 0
#define PROT_READ 1
#define PROT_WRITE 2
#define PROT_EXEC 4
#define MAP_PRIVATE 2
#define MAP_FIXED 0x10
#define MAP_FAILED ((void*)-1)
#endif
#ifdef MSWIN32
#define OS_TYPE "MSWIN32"
#define RETRY_GET_THREAD_CONTEXT
#if!defined(__GNUC__)||defined(__INTEL_COMPILER)||GC_GNUC_PREREQ(4,7)
#define MPROTECT_VDB
#endif
#define GWW_VDB
#ifndef DATAEND
#define DATAEND
#endif
#endif
#endif
#ifdef ARC
#define CPP_WORDSZ 32
#define MACH_TYPE "ARC"
#define ALIGNMENT 4
#define CACHE_LINE_SIZE 64
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#define DYNAMIC_LOADING
extern int __data_start[] __attribute__((__weak__));
#define DATASTART ((ptr_t)__data_start)
#endif
#endif
#ifdef HEXAGON
#define CPP_WORDSZ 32
#define MACH_TYPE "HEXAGON"
#define ALIGNMENT 4
#ifdef LINUX
#define OS_TYPE "LINUX"
#define LINUX_STACKBOTTOM
#if!defined(REDIRECT_MALLOC)
#define MPROTECT_VDB
#endif
#define COUNT_UNMAPPED_REGIONS
#define DYNAMIC_LOADING
EXTERN_C_END
#include <features.h>
EXTERN_C_BEGIN
#if defined(__GLIBC__)
#define SEARCH_FOR_DATA_START
#elif!defined(CPPCHECK)
#error Unknown Hexagon libc configuration
#endif
extern int _end[];
#define DATAEND ((ptr_t)(_end))
#endif
#endif
#ifdef TILEPRO
#define CPP_WORDSZ 32
#define MACH_TYPE "TILEPro"
#define ALIGNMENT 4
#define PREFETCH(x)__insn_prefetch(x)
#define CACHE_LINE_SIZE 64
#ifdef LINUX
#define OS_TYPE "LINUX"
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#define DYNAMIC_LOADING
#endif
#endif
#ifdef TILEGX
#define CPP_WORDSZ (__SIZEOF_POINTER__*8)
#define MACH_TYPE "TILE-Gx"
#define ALIGNMENT __SIZEOF_POINTER__
#if CPP_WORDSZ < 64
#define CLEAR_DOUBLE(x)(*(long long*)(x)=0)
#endif
#define PREFETCH(x)__insn_prefetch_l1(x)
#define CACHE_LINE_SIZE 64
#ifdef LINUX
#define OS_TYPE "LINUX"
extern int __data_start[];
#define DATASTART ((ptr_t)__data_start)
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#define DYNAMIC_LOADING
#endif
#endif
#ifdef RISCV
#define MACH_TYPE "RISC-V"
#define CPP_WORDSZ __riscv_xlen
#define ALIGNMENT (CPP_WORDSZ/8)
#ifdef FREEBSD
#define OS_TYPE "FREEBSD"
#ifndef GC_FREEBSD_THREADS
#define MPROTECT_VDB
#endif
#define SIG_SUSPEND SIGUSR1
#define SIG_THR_RESTART SIGUSR2
#define FREEBSD_STACKBOTTOM
#define DYNAMIC_LOADING
extern char etext[];
#define DATASTART GC_FreeBSDGetDataStart(0x1000,(ptr_t)etext)
#define DATASTART_USES_BSDGETDATASTART
#endif
#ifdef LINUX
#define OS_TYPE "LINUX"
extern int __data_start[] __attribute__((__weak__));
#define DATASTART ((ptr_t)__data_start)
#define LINUX_STACKBOTTOM
#define COUNT_UNMAPPED_REGIONS
#define DYNAMIC_LOADING
#endif
#endif
#if defined(__GLIBC__)&&!defined(DONT_USE_LIBC_PRIVATES)
#define USE_LIBC_PRIVATES
#endif
#ifdef NO_RETRY_GET_THREAD_CONTEXT
#undef RETRY_GET_THREAD_CONTEXT
#endif
#if defined(LINUX_STACKBOTTOM)&&defined(NO_PROC_STAT)&&!defined(USE_LIBC_PRIVATES)
#undef LINUX_STACKBOTTOM
#define HEURISTIC2
#endif
#if defined(USE_MMAP_ANON)&&!defined(USE_MMAP)
#define USE_MMAP 1
#elif (defined(LINUX)||defined(OPENBSD))&&defined(USE_MMAP)
#define USE_MMAP_ANON
#endif
#if defined(GC_LINUX_THREADS)&&defined(REDIRECT_MALLOC)&&!defined(USE_PROC_FOR_LIBRARIES)
#define USE_PROC_FOR_LIBRARIES
#endif
#ifndef STACK_GROWS_UP
#define STACK_GROWS_DOWN
#endif
#ifndef CPP_WORDSZ
#define CPP_WORDSZ 32
#endif
#ifndef OS_TYPE
#define OS_TYPE ""
#endif
#ifndef DATAEND
#if!defined(CPPCHECK)
extern int end[];
#endif
#define DATAEND ((ptr_t)(end))
#endif
#if defined(HOST_ANDROID)&&defined(__clang__)&&!defined(BROKEN_UUENDUU_SYM)
#undef DATAEND
#pragma weak __end__
extern int __end__[];
#define DATAEND (__end__!=0?(ptr_t)__end__:(ptr_t)_end)
#endif
#if (defined(SVR4)||defined(HOST_ANDROID)||defined(HOST_TIZEN))&&!defined(GETPAGESIZE)
EXTERN_C_END
#include <unistd.h>
EXTERN_C_BEGIN
#define GETPAGESIZE()(unsigned)sysconf(_SC_PAGESIZE)
#endif
#ifndef GETPAGESIZE
#if defined(SOLARIS)||defined(IRIX5)||defined(LINUX)||defined(NETBSD)||defined(FREEBSD)||defined(HPUX)
EXTERN_C_END
#include <unistd.h>
EXTERN_C_BEGIN
#endif
#define GETPAGESIZE()(unsigned)getpagesize()
#endif
#if defined(HOST_ANDROID)&&!(__ANDROID_API__>=23)&&((defined(MIPS)&&(CPP_WORDSZ==32))||defined(ARM32)||defined(I386))
#define USE_TKILL_ON_ANDROID
#endif
#if defined(SOLARIS)||defined(DRSNX)||defined(UTS4)
#define SVR4
#endif
#if defined(SOLARIS)||defined(DRSNX)
#define SOLARISDL
#define SUNOS5SIGS
#endif
#if defined(HPUX)
#define SUNOS5SIGS
#endif
#if defined(FREEBSD)&&(defined(__DragonFly__)||__FreeBSD__>=4||(__FreeBSD_kernel__>=4))
#define SUNOS5SIGS
#endif
#if!defined(GC_EXPLICIT_SIGNALS_UNBLOCK)&&defined(SUNOS5SIGS)&&!defined(GC_NO_PTHREAD_SIGMASK)
#define GC_EXPLICIT_SIGNALS_UNBLOCK
#endif
#if!defined(NO_SIGNALS_UNBLOCK_IN_MAIN)&&defined(GC_NO_PTHREAD_SIGMASK)
#define NO_SIGNALS_UNBLOCK_IN_MAIN
#endif
#if!defined(NO_MARKER_SPECIAL_SIGMASK)&&(defined(NACL)||defined(GC_WIN32_PTHREADS))
#define NO_MARKER_SPECIAL_SIGMASK
#endif
#ifdef GC_NETBSD_THREADS
#define SIGRTMIN 33
#define SIGRTMAX 63
#define GC_NETBSD_THREADS_WORKAROUND
#endif
#ifdef GC_OPENBSD_THREADS
EXTERN_C_END
#include <sys/param.h>
EXTERN_C_BEGIN
#if OpenBSD < 201211
#define GC_OPENBSD_UTHREADS 1
#endif
#endif
#if defined(SVR4)||defined(LINUX)||defined(IRIX5)||defined(HPUX)||defined(OPENBSD)||defined(NETBSD)||defined(FREEBSD)||defined(DGUX)||defined(BSD)||defined(HAIKU)||defined(HURD)||defined(AIX)||defined(DARWIN)||defined(OSF1)
#define UNIX_LIKE
#endif
#if defined(CPPCHECK)
#undef CPP_WORDSZ
#define CPP_WORDSZ (__SIZEOF_POINTER__*8)
#elif CPP_WORDSZ!=32&&CPP_WORDSZ!=64
#error Bad word size
#endif
#if!defined(ALIGNMENT)&&!defined(CPPCHECK)
#error Undefined ALIGNMENT
#endif
#ifdef PCR
#undef DYNAMIC_LOADING
#undef STACKBOTTOM
#undef HEURISTIC1
#undef HEURISTIC2
#undef PROC_VDB
#undef MPROTECT_VDB
#define PCR_VDB
#endif
#if!defined(STACKBOTTOM)&&(defined(ECOS)||defined(NOSYS))&&!defined(CPPCHECK)
#error Undefined STACKBOTTOM
#endif
#ifdef IGNORE_DYNAMIC_LOADING
#undef DYNAMIC_LOADING
#endif
#if defined(SMALL_CONFIG)&&!defined(GC_DISABLE_INCREMENTAL)
#define GC_DISABLE_INCREMENTAL
#endif
#if (defined(MSWIN32)||defined(MSWINCE))&&!defined(USE_WINALLOC)
#define USE_WINALLOC 1
#endif
#ifdef USE_WINALLOC
#undef USE_MMAP
#endif
#if defined(DARWIN)||defined(FREEBSD)||defined(HAIKU)||defined(IRIX5)||defined(LINUX)||defined(NETBSD)||defined(OPENBSD)||defined(SOLARIS)||((defined(CYGWIN32)||defined(USE_MMAP)||defined(USE_MUNMAP))&&!defined(USE_WINALLOC))
#define MMAP_SUPPORTED
#endif
#if defined(USE_MUNMAP)&&!defined(MUNMAP_THRESHOLD)&&(defined(SN_TARGET_ORBIS)||defined(SN_TARGET_PS3)||defined(SN_TARGET_PSP2)||defined(MSWIN_XBOX1))
#define MUNMAP_THRESHOLD 2
#endif
#if defined(USE_MUNMAP)&&defined(COUNT_UNMAPPED_REGIONS)&&!defined(GC_UNMAPPED_REGIONS_SOFT_LIMIT)
#if defined(__DragonFly__)
#define GC_UNMAPPED_REGIONS_SOFT_LIMIT (1000000/4)
#else
#define GC_UNMAPPED_REGIONS_SOFT_LIMIT 16384
#endif
#endif
#if defined(GC_DISABLE_INCREMENTAL)||defined(DEFAULT_VDB)
#undef GWW_VDB
#undef MPROTECT_VDB
#undef PCR_VDB
#undef PROC_VDB
#endif
#ifdef GC_DISABLE_INCREMENTAL
#undef CHECKSUMS
#endif
#ifdef USE_GLOBAL_ALLOC
#undef GWW_VDB
#endif
#if defined(BASE_ATOMIC_OPS_EMULATED)
#undef MPROTECT_VDB
#endif
#if defined(USE_PROC_FOR_LIBRARIES)&&defined(GC_LINUX_THREADS)
#undef MPROTECT_VDB
#endif
#if defined(MPROTECT_VDB)&&defined(GC_PREFER_MPROTECT_VDB)
#undef PCR_VDB
#undef PROC_VDB
#endif
#ifdef PROC_VDB
#undef MPROTECT_VDB
#endif
#if defined(MPROTECT_VDB)&&!defined(MSWIN32)&&!defined(MSWINCE)
#include <signal.h>
#endif
#if defined(SIGBUS)&&!defined(HAVE_SIGBUS)&&!defined(CPPCHECK)
#define HAVE_SIGBUS
#endif
#ifndef SA_SIGINFO
#define NO_SA_SIGACTION
#endif
#if (defined(NO_SA_SIGACTION)||defined(GC_NO_SIGSETJMP))&&defined(MPROTECT_VDB)&&!defined(DARWIN)&&!defined(MSWIN32)&&!defined(MSWINCE)
#undef MPROTECT_VDB
#endif
#if!defined(PCR_VDB)&&!defined(PROC_VDB)&&!defined(MPROTECT_VDB)&&!defined(GWW_VDB)&&!defined(DEFAULT_VDB)&&!defined(GC_DISABLE_INCREMENTAL)
#define DEFAULT_VDB
#endif
#if ((defined(UNIX_LIKE)&&(defined(DARWIN)||defined(HAIKU)||defined(HURD)||defined(OPENBSD)||defined(ARM32)||defined(AVR32)||defined(MIPS)||defined(NIOS2)||defined(OR1K)))||(defined(LINUX)&&!defined(__gnu_linux__))||(defined(RTEMS)&&defined(I386))||defined(HOST_ANDROID))&&!defined(NO_GETCONTEXT)
#define NO_GETCONTEXT 1
#endif
#ifndef PREFETCH
#if GC_GNUC_PREREQ(3,0)&&!defined(NO_PREFETCH)
#define PREFETCH(x)__builtin_prefetch((x),0,0)
#else
#define PREFETCH(x)(void)0
#endif
#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
#ifndef CACHE_LINE_SIZE
#define CACHE_LINE_SIZE 32
#endif
#ifndef STATIC
#ifdef GC_ASSERTIONS
#define STATIC
#else
#define STATIC static
#endif
#endif
#if defined(LINUX)&&(defined(USE_PROC_FOR_LIBRARIES)||defined(IA64)||!defined(SMALL_CONFIG))
#define NEED_PROC_MAPS
#endif
#if defined(LINUX)||defined(HURD)||defined(__GLIBC__)
#define REGISTER_LIBRARIES_EARLY
#endif
#if defined(SEARCH_FOR_DATA_START)
extern ptr_t GC_data_start;
#define DATASTART GC_data_start
#endif
#ifndef HEAP_START
#define HEAP_START ((ptr_t)0)
#endif
#ifndef CLEAR_DOUBLE
#define CLEAR_DOUBLE(x)(((word*)(x))[0]=0,((word*)(x))[1]=0)
#endif
#if defined(GC_LINUX_THREADS)&&defined(REDIRECT_MALLOC)&&!defined(INCLUDE_LINUX_THREAD_DESCR)
#define INCLUDE_LINUX_THREAD_DESCR
#endif
#if!defined(CPPCHECK)
#if defined(GC_IRIX_THREADS)&&!defined(IRIX5)
#error Inconsistent configuration
#endif
#if defined(GC_LINUX_THREADS)&&!defined(LINUX)&&!defined(NACL)
#error Inconsistent configuration
#endif
#if defined(GC_NETBSD_THREADS)&&!defined(NETBSD)
#error Inconsistent configuration
#endif
#if defined(GC_FREEBSD_THREADS)&&!defined(FREEBSD)
#error Inconsistent configuration
#endif
#if defined(GC_SOLARIS_THREADS)&&!defined(SOLARIS)
#error Inconsistent configuration
#endif
#if defined(GC_HPUX_THREADS)&&!defined(HPUX)
#error Inconsistent configuration
#endif
#if defined(GC_AIX_THREADS)&&!defined(_AIX)
#error Inconsistent configuration
#endif
#if defined(GC_WIN32_THREADS)&&!defined(CYGWIN32)&&!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(MSWIN_XBOX1)
#error Inconsistent configuration
#endif
#if defined(GC_WIN32_PTHREADS)&&defined(CYGWIN32)
#error Inconsistent configuration
#endif
#endif
#if defined(PCR)||defined(GC_WIN32_THREADS)||defined(GC_PTHREADS)||((defined(NN_PLATFORM_CTR)||defined(NINTENDO_SWITCH)||defined(SN_TARGET_ORBIS)||defined(SN_TARGET_PS3)||defined(SN_TARGET_PSP2))&&defined(GC_THREADS))
#define THREADS
#endif
#if defined(PARALLEL_MARK)&&!defined(THREADS)&&!defined(CPPCHECK)
#error Invalid config:PARALLEL_MARK requires GC_THREADS
#endif
#if defined(GWW_VDB)&&!defined(USE_WINALLOC)&&!defined(CPPCHECK)
#error Invalid config:GWW_VDB requires USE_WINALLOC
#endif
#if (((defined(MSWIN32)||defined(MSWINCE))&&!defined(__GNUC__))||(defined(MSWIN32)&&defined(I386))||(defined(USE_PROC_FOR_LIBRARIES)&&defined(THREADS)))&&!defined(NO_CRT)&&!defined(NO_WRAP_MARK_SOME)
#define WRAP_MARK_SOME
#endif
#if defined(PARALLEL_MARK)&&!defined(DEFAULT_STACK_MAYBE_SMALL)&&(defined(HPUX)||defined(GC_DGUX386_THREADS)||defined(NO_GETCONTEXT))
#define DEFAULT_STACK_MAYBE_SMALL
#endif
#ifdef PARALLEL_MARK
#define MIN_STACK_SIZE (8*HBLKSIZE*sizeof(word))
#endif
#if defined(HOST_ANDROID)&&!defined(THREADS)&&!defined(USE_GET_STACKBASE_FOR_MAIN)
#define USE_GET_STACKBASE_FOR_MAIN
#endif
#if ((defined(FREEBSD)&&defined(__GLIBC__))||defined(LINUX)||defined(NETBSD)||defined(HOST_ANDROID))&&!defined(NO_PTHREAD_GETATTR_NP)
#define HAVE_PTHREAD_GETATTR_NP 1
#elif defined(FREEBSD)&&!defined(__GLIBC__)&&!defined(NO_PTHREAD_ATTR_GET_NP)
#define HAVE_PTHREAD_NP_H 1
#define HAVE_PTHREAD_ATTR_GET_NP 1
#endif
#if defined(UNIX_LIKE)&&defined(THREADS)&&!defined(NO_CANCEL_SAFE)&&!defined(HOST_ANDROID)
#define CANCEL_SAFE
#endif
#ifdef CANCEL_SAFE
#define IF_CANCEL(x)x
#else
#define IF_CANCEL(x)
#endif
#if!defined(CAN_HANDLE_FORK)&&!defined(NO_HANDLE_FORK)&&!defined(HAVE_NO_FORK)&&((defined(GC_PTHREADS)&&!defined(NACL)&&!defined(GC_WIN32_PTHREADS)&&!defined(USE_WINALLOC))||(defined(DARWIN)&&defined(MPROTECT_VDB))||defined(HANDLE_FORK))
#define CAN_HANDLE_FORK
#endif
#if defined(CAN_HANDLE_FORK)&&!defined(CAN_CALL_ATFORK)&&!defined(HURD)&&!defined(SN_TARGET_ORBIS)&&!defined(HOST_TIZEN)&&(!defined(HOST_ANDROID)||__ANDROID_API__>=21)
#define CAN_CALL_ATFORK
#endif
#if!defined(CAN_HANDLE_FORK)&&!defined(HAVE_NO_FORK)&&(defined(MSWIN32)||defined(MSWINCE)||defined(DOS4GW)||defined(OS2)||defined(SYMBIAN))
#define HAVE_NO_FORK
#endif
#if!defined(USE_MARK_BITS)&&!defined(USE_MARK_BYTES)&&defined(PARALLEL_MARK)
#define USE_MARK_BYTES
#endif
#if (defined(MSWINCE)&&!defined(__CEGCC__)||defined(MSWINRT_FLAVOR))&&!defined(NO_GETENV)
#define NO_GETENV
#endif
#if (defined(NO_GETENV)||defined(MSWINCE))&&!defined(NO_GETENV_WIN32)
#define NO_GETENV_WIN32
#endif
#if!defined(MSGBOX_ON_ERROR)&&!defined(NO_MSGBOX_ON_ERROR)&&!defined(SMALL_CONFIG)&&defined(MSWIN32)&&!defined(MSWINRT_FLAVOR)&&!defined(MSWIN_XBOX1)
#define MSGBOX_ON_ERROR
#endif
#ifndef STRTOULL
#if defined(_WIN64)&&!defined(__GNUC__)
#define STRTOULL _strtoui64
#elif defined(_LLP64)||defined(__LLP64__)||defined(_WIN64)
#define STRTOULL strtoull
#else
#define STRTOULL strtoul
#endif
#endif
#ifndef GC_WORD_C
#if defined(_WIN64)&&!defined(__GNUC__)
#define GC_WORD_C(val)val##ui64
#elif defined(_LLP64)||defined(__LLP64__)||defined(_WIN64)
#define GC_WORD_C(val)val##ULL
#else
#define GC_WORD_C(val)((word)val##UL)
#endif
#endif
#if defined(__has_feature)
#if __has_feature(address_sanitizer)&&!defined(ADDRESS_SANITIZER)
#define ADDRESS_SANITIZER
#endif
#if __has_feature(memory_sanitizer)&&!defined(MEMORY_SANITIZER)
#define MEMORY_SANITIZER
#endif
#if __has_feature(thread_sanitizer)&&!defined(THREAD_SANITIZER)
#define THREAD_SANITIZER
#endif
#else
#ifdef __SANITIZE_ADDRESS__
#define ADDRESS_SANITIZER
#endif
#endif
#if defined(SPARC)
#define ASM_CLEAR_CODE
#endif
#if defined(SPARC)
#define CAN_SAVE_CALL_ARGS
#endif
#if (defined(I386)||defined(X86_64))&&(defined(LINUX)||defined(__GLIBC__))
#define CAN_SAVE_CALL_ARGS
#endif
#if defined(SAVE_CALL_COUNT)&&!defined(GC_ADD_CALLER)&&defined(GC_CAN_SAVE_CALL_STACKS)
#define SAVE_CALL_CHAIN
#endif
#ifdef SAVE_CALL_CHAIN
#if defined(SAVE_CALL_NARGS)&&defined(CAN_SAVE_CALL_ARGS)
#define NARGS SAVE_CALL_NARGS
#else
#define NARGS 0
#endif
#endif
#ifdef SAVE_CALL_CHAIN
#if!defined(SAVE_CALL_COUNT)||defined(CPPCHECK)
#define NFRAMES 6
#else
#define NFRAMES ((SAVE_CALL_COUNT+1)&~1)
#endif
#define NEED_CALLINFO
#endif
#ifdef GC_ADD_CALLER
#define NFRAMES 1
#define NARGS 0
#define NEED_CALLINFO
#endif
#if (defined(FREEBSD)||(defined(DARWIN)&&!defined(_POSIX_C_SOURCE))||(defined(SOLARIS)&&(!defined(_XOPEN_SOURCE)||defined(__EXTENSIONS__)))||defined(LINUX))&&!defined(HAVE_DLADDR)
#define HAVE_DLADDR 1
#endif
#if defined(MAKE_BACK_GRAPH)&&!defined(DBG_HDRS_ALL)
#define DBG_HDRS_ALL 1
#endif
#if defined(POINTER_MASK)&&!defined(POINTER_SHIFT)
#define POINTER_SHIFT 0
#endif
#if defined(POINTER_SHIFT)&&!defined(POINTER_MASK)
#define POINTER_MASK ((word)(-1))
#endif
#if!defined(FIXUP_POINTER)&&defined(POINTER_MASK)
#define FIXUP_POINTER(p)(p=((p)&POINTER_MASK)<<POINTER_SHIFT)
#endif
#if defined(FIXUP_POINTER)
#define NEED_FIXUP_POINTER
#else
#define FIXUP_POINTER(p)
#endif
#if!defined(MARK_BIT_PER_GRANULE)&&!defined(MARK_BIT_PER_OBJ)
#define MARK_BIT_PER_GRANULE
#endif
#if!defined(CPPCHECK)
#if defined(MARK_BIT_PER_GRANULE)&&defined(MARK_BIT_PER_OBJ)
#error Define only one of MARK_BIT_PER_GRANULE and MARK_BIT_PER_OBJ
#endif
#if defined(STACK_GROWS_UP)&&defined(STACK_GROWS_DOWN)
#error Only one of STACK_GROWS_UP and STACK_GROWS_DOWN should be defined
#endif
#if!defined(STACK_GROWS_UP)&&!defined(STACK_GROWS_DOWN)
#error One of STACK_GROWS_UP and STACK_GROWS_DOWN should be defined
#endif
#if defined(REDIRECT_MALLOC)&&defined(THREADS)&&!defined(LINUX)&&!defined(REDIRECT_MALLOC_IN_HEADER)
#error REDIRECT_MALLOC with THREADS works at most on Linux
#endif
#endif
#ifdef GC_PRIVATE_H
struct hblk;
#if defined(PCR)
char*real_malloc(size_t bytes);
#define GET_MEM(bytes)HBLKPTR(real_malloc(SIZET_SAT_ADD(bytes,GC_page_size))+GC_page_size-1)
#elif defined(OS2)
void*os2_alloc(size_t bytes);
#define GET_MEM(bytes)HBLKPTR((ptr_t)os2_alloc( SIZET_SAT_ADD(bytes,GC_page_size))+GC_page_size-1)
#elif defined(NEXT)||defined(DOS4GW)||defined(NONSTOP)||(defined(AMIGA)&&!defined(GC_AMIGA_FASTALLOC))||(defined(SOLARIS)&&!defined(USE_MMAP))||defined(RTEMS)||defined(__CC_ARM)
#define GET_MEM(bytes)HBLKPTR((size_t)calloc(1,SIZET_SAT_ADD(bytes,GC_page_size))+GC_page_size - 1)
#elif defined(MSWIN_XBOX1)
ptr_t GC_durango_get_mem(size_t bytes);
#define GET_MEM(bytes)(struct hblk*)GC_durango_get_mem(bytes)
#elif defined(MSWIN32)||defined(CYGWIN32)
ptr_t GC_win32_get_mem(size_t bytes);
#define GET_MEM(bytes)(struct hblk*)GC_win32_get_mem(bytes)
#elif defined(MACOS)
#if defined(USE_TEMPORARY_MEMORY)
Ptr GC_MacTemporaryNewPtr(size_t size,Boolean clearMemory);
#define GET_MEM(bytes)HBLKPTR(GC_MacTemporaryNewPtr( SIZET_SAT_ADD(bytes,GC_page_size),true)+GC_page_size-1)
#else
#define GET_MEM(bytes)HBLKPTR(NewPtrClear(SIZET_SAT_ADD(bytes,GC_page_size))+GC_page_size-1)
#endif
#elif defined(MSWINCE)
ptr_t GC_wince_get_mem(size_t bytes);
#define GET_MEM(bytes)(struct hblk*)GC_wince_get_mem(bytes)
#elif defined(AMIGA)&&defined(GC_AMIGA_FASTALLOC)
void*GC_amiga_get_mem(size_t bytes);
#define GET_MEM(bytes)HBLKPTR((size_t)GC_amiga_get_mem( SIZET_SAT_ADD(bytes,GC_page_size))+GC_page_size-1)
#elif defined(SN_TARGET_ORBIS)
void*ps4_get_mem(size_t bytes);
#define GET_MEM(bytes)(struct hblk*)ps4_get_mem(bytes)
#elif defined(SN_TARGET_PS3)
void*ps3_get_mem(size_t bytes);
#define GET_MEM(bytes)(struct hblk*)ps3_get_mem(bytes)
#elif defined(SN_TARGET_PSP2)
void*psp2_get_mem(size_t bytes);
#define GET_MEM(bytes)(struct hblk*)psp2_get_mem(bytes)
#elif defined(NINTENDO_SWITCH)
void*switch_get_mem(size_t bytes);
#define GET_MEM(bytes)(struct hblk*)switch_get_mem(bytes)
#elif defined(HAIKU)
ptr_t GC_haiku_get_mem(size_t bytes);
#define GET_MEM(bytes)(struct hblk*)GC_haiku_get_mem(bytes)
#else
ptr_t GC_unix_get_mem(size_t bytes);
#define GET_MEM(bytes)(struct hblk*)GC_unix_get_mem(bytes)
#endif
#endif
EXTERN_C_END
#endif
#if!defined(GC_ATOMIC_UNCOLLECTABLE)&&defined(ATOMIC_UNCOLLECTABLE)
#define GC_ATOMIC_UNCOLLECTABLE
#endif
#ifndef GC_INNER
#if defined(GC_DLL)&&defined(__GNUC__)&&!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
#if GC_GNUC_PREREQ(4,0)&&!defined(GC_NO_VISIBILITY)
#define GC_INNER __attribute__((__visibility__("hidden")))
#else
#define GC_INNER
#endif
#else
#define GC_INNER
#endif
#define GC_EXTERN extern GC_INNER
#endif
#ifdef __cplusplus
#define REGISTER
#else
#define REGISTER register
#endif
#if defined(CPPCHECK)
#define MACRO_BLKSTMT_BEGIN {
#define MACRO_BLKSTMT_END }
#else
#define MACRO_BLKSTMT_BEGIN do {
#define MACRO_BLKSTMT_END } while (0)
#endif
#if defined(M68K)&&defined(__GNUC__)
#define GC_ATTR_WORD_ALIGNED __attribute__((__aligned__(sizeof(word))))
#else
#define GC_ATTR_WORD_ALIGNED
#endif
#ifndef HEADERS_H
#ifndef GC_HEADERS_H
#define GC_HEADERS_H
#if CPP_WORDSZ!=32&&CPP_WORDSZ < 36&&!defined(CPPCHECK)
#error Get a real machine
#endif
EXTERN_C_BEGIN
typedef struct hblkhdr hdr;
#if CPP_WORDSZ > 32
#define HASH_TL
#endif
#if defined(LARGE_CONFIG)||!defined(SMALL_CONFIG)
#define LOG_BOTTOM_SZ 10
#else
#define LOG_BOTTOM_SZ 11
#endif
#define BOTTOM_SZ (1<<LOG_BOTTOM_SZ)
#ifndef HASH_TL
#define LOG_TOP_SZ (WORDSZ - LOG_BOTTOM_SZ - LOG_HBLKSIZE)
#else
#define LOG_TOP_SZ 11
#endif
#define TOP_SZ (1<<LOG_TOP_SZ)
#ifdef COUNT_HDR_CACHE_HITS
extern word GC_hdr_cache_hits;
extern word GC_hdr_cache_misses;
#define HC_HIT()(void)(++GC_hdr_cache_hits)
#define HC_MISS()(void)(++GC_hdr_cache_misses)
#else
#define HC_HIT()
#define HC_MISS()
#endif
typedef struct hce {
word block_addr;
hdr*hce_hdr;
} hdr_cache_entry;
#define HDR_CACHE_SIZE 8
#define DECLARE_HDR_CACHE hdr_cache_entry hdr_cache[HDR_CACHE_SIZE]
#define INIT_HDR_CACHE BZERO(hdr_cache,sizeof(hdr_cache))
#define HCE(h)(hdr_cache+(((word)(h)>>LOG_HBLKSIZE)&(HDR_CACHE_SIZE-1)))
#define HCE_VALID_FOR(hce,h)((hce)->block_addr==((word)(h)>>LOG_HBLKSIZE))
#define HCE_HDR(h)((hce)->hce_hdr)
#ifdef PRINT_BLACK_LIST
GC_INNER hdr*GC_header_cache_miss(ptr_t p,hdr_cache_entry*hce,
ptr_t source);
#define HEADER_CACHE_MISS(p,hce,source)GC_header_cache_miss(p,hce,source)
#else
GC_INNER hdr*GC_header_cache_miss(ptr_t p,hdr_cache_entry*hce);
#define HEADER_CACHE_MISS(p,hce,source)GC_header_cache_miss(p,hce)
#endif
#define HC_GET_HDR(p,hhdr,source){ hdr_cache_entry*hce=HCE(p);if (EXPECT(HCE_VALID_FOR(hce,p),TRUE)){ HC_HIT();hhdr=hce->hce_hdr;} else { hhdr=HEADER_CACHE_MISS(p,hce,source);if (NULL==hhdr)break;} }
typedef struct bi {
hdr*index[BOTTOM_SZ];
struct bi*asc_link;
struct bi*desc_link;
word key;
#ifdef HASH_TL
struct bi*hash_link;
#endif
} bottom_index;
#define MAX_JUMP (HBLKSIZE - 1)
#define HDR_FROM_BI(bi,p)((bi)->index[((word)(p)>>LOG_HBLKSIZE)&(BOTTOM_SZ - 1)])
#ifndef HASH_TL
#define BI(p)(GC_top_index [(word)(p)>>(LOG_BOTTOM_SZ+LOG_HBLKSIZE)])
#define HDR_INNER(p)HDR_FROM_BI(BI(p),p)
#ifdef SMALL_CONFIG
#define HDR(p)GC_find_header((ptr_t)(p))
#else
#define HDR(p)HDR_INNER(p)
#endif
#define GET_BI(p,bottom_indx)(void)((bottom_indx)=BI(p))
#define GET_HDR(p,hhdr)(void)((hhdr)=HDR(p))
#define SET_HDR(p,hhdr)(void)(HDR_INNER(p)=(hhdr))
#define GET_HDR_ADDR(p,ha)(void)((ha)=&HDR_INNER(p))
#else
#define TL_HASH(hi)((hi)&(TOP_SZ - 1))
#define GET_BI(p,bottom_indx)do { REGISTER word hi=(word)(p)>>(LOG_BOTTOM_SZ+LOG_HBLKSIZE);REGISTER bottom_index*_bi=GC_top_index[TL_HASH(hi)];while (_bi->key!=hi&&_bi!=GC_all_nils)_bi=_bi->hash_link;(bottom_indx)=_bi;} while (0)
#define GET_HDR_ADDR(p,ha)do { REGISTER bottom_index*bi;GET_BI(p,bi);(ha)=&HDR_FROM_BI(bi,p);} while (0)
#define GET_HDR(p,hhdr)do { REGISTER hdr**_ha;GET_HDR_ADDR(p,_ha);(hhdr)=*_ha;} while (0)
#define SET_HDR(p,hhdr)do { REGISTER hdr**_ha;GET_HDR_ADDR(p,_ha);*_ha=(hhdr);} while (0)
#define HDR(p)GC_find_header((ptr_t)(p))
#endif
#define IS_FORWARDING_ADDR_OR_NIL(hhdr)((size_t)(hhdr)<=MAX_JUMP)
#define FORWARDED_ADDR(h,hhdr)((struct hblk*)(h)- (size_t)(hhdr))
EXTERN_C_END
#endif
#endif
#ifndef GC_ATTR_NO_SANITIZE_ADDR
#ifndef ADDRESS_SANITIZER
#define GC_ATTR_NO_SANITIZE_ADDR
#elif GC_CLANG_PREREQ(3,8)
#define GC_ATTR_NO_SANITIZE_ADDR __attribute__((no_sanitize("address")))
#else
#define GC_ATTR_NO_SANITIZE_ADDR __attribute__((no_sanitize_address))
#endif
#endif
#ifndef GC_ATTR_NO_SANITIZE_MEMORY
#ifndef MEMORY_SANITIZER
#define GC_ATTR_NO_SANITIZE_MEMORY
#elif GC_CLANG_PREREQ(3,8)
#define GC_ATTR_NO_SANITIZE_MEMORY __attribute__((no_sanitize("memory")))
#else
#define GC_ATTR_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
#endif
#endif
#ifndef GC_ATTR_NO_SANITIZE_THREAD
#ifndef THREAD_SANITIZER
#define GC_ATTR_NO_SANITIZE_THREAD
#elif GC_CLANG_PREREQ(3,8)
#define GC_ATTR_NO_SANITIZE_THREAD __attribute__((no_sanitize("thread")))
#else
#define GC_ATTR_NO_SANITIZE_THREAD __attribute__((no_sanitize_thread))
#endif
#endif
#ifndef GC_ATTR_UNUSED
#if GC_GNUC_PREREQ(3,4)
#define GC_ATTR_UNUSED __attribute__((__unused__))
#else
#define GC_ATTR_UNUSED
#endif
#endif
#ifdef HAVE_CONFIG_H
#define GC_INLINE static inline
#elif defined(_MSC_VER)||defined(__INTEL_COMPILER)||defined(__DMC__)||(GC_GNUC_PREREQ(3,0)&&defined(__STRICT_ANSI__))||defined(__WATCOMC__)
#define GC_INLINE static __inline
#elif GC_GNUC_PREREQ(3,0)||defined(__sun)
#define GC_INLINE static inline
#else
#define GC_INLINE static
#endif
#ifndef GC_ATTR_NOINLINE
#if GC_GNUC_PREREQ(4,0)
#define GC_ATTR_NOINLINE __attribute__((__noinline__))
#elif _MSC_VER>=1400
#define GC_ATTR_NOINLINE __declspec(noinline)
#else
#define GC_ATTR_NOINLINE
#endif
#endif
#ifndef GC_API_OSCALL
#if defined(__GNUC__)
#if GC_GNUC_PREREQ(4,0)&&!defined(GC_NO_VISIBILITY)
#define GC_API_OSCALL extern __attribute__((__visibility__("default")))
#else
#define GC_API_OSCALL extern
#endif
#else
#define GC_API_OSCALL GC_API
#endif
#endif
#ifndef GC_API_PRIV
#define GC_API_PRIV GC_API
#endif
#if defined(THREADS)&&!defined(NN_PLATFORM_CTR)
#ifndef GC_ATOMIC_OPS_H
#define GC_ATOMIC_OPS_H
#ifdef GC_BUILTIN_ATOMIC
#ifdef __cplusplus
extern "C" {
#endif
typedef GC_word AO_t;
#ifdef GC_PRIVATE_H
#define AO_INLINE GC_INLINE
#else
#define AO_INLINE static __inline
#endif
typedef unsigned char AO_TS_t;
#define AO_TS_CLEAR 0
#define AO_TS_INITIALIZER (AO_TS_t)AO_TS_CLEAR
#if defined(__GCC_ATOMIC_TEST_AND_SET_TRUEVAL)&&!defined(CPPCHECK)
#define AO_TS_SET __GCC_ATOMIC_TEST_AND_SET_TRUEVAL
#else
#define AO_TS_SET (AO_TS_t)1
#endif
#define AO_CLEAR(p)__atomic_clear(p,__ATOMIC_RELEASE)
#define AO_test_and_set_acquire(p)__atomic_test_and_set(p,__ATOMIC_ACQUIRE)
#define AO_HAVE_test_and_set_acquire
#define AO_compiler_barrier()__atomic_signal_fence(__ATOMIC_SEQ_CST)
#define AO_nop_full()__atomic_thread_fence(__ATOMIC_SEQ_CST)
#define AO_HAVE_nop_full
#define AO_fetch_and_add(p,v)__atomic_fetch_add(p,v,__ATOMIC_RELAXED)
#define AO_HAVE_fetch_and_add
#define AO_fetch_and_add1(p)AO_fetch_and_add(p,1)
#define AO_HAVE_fetch_and_add1
#define AO_or(p,v)(void)__atomic_or_fetch(p,v,__ATOMIC_RELAXED)
#define AO_HAVE_or
#define AO_load(p)__atomic_load_n(p,__ATOMIC_RELAXED)
#define AO_HAVE_load
#define AO_load_acquire(p)__atomic_load_n(p,__ATOMIC_ACQUIRE)
#define AO_HAVE_load_acquire
#define AO_load_acquire_read(p)AO_load_acquire(p)
#define AO_HAVE_load_acquire_read
#define AO_store(p,v)__atomic_store_n(p,v,__ATOMIC_RELAXED)
#define AO_HAVE_store
#define AO_store_release(p,v)__atomic_store_n(p,v,__ATOMIC_RELEASE)
#define AO_HAVE_store_release
#define AO_store_release_write(p,v)AO_store_release(p,v)
#define AO_HAVE_store_release_write
#define AO_char_load(p)__atomic_load_n(p,__ATOMIC_RELAXED)
#define AO_HAVE_char_load
#define AO_char_store(p,v)__atomic_store_n(p,v,__ATOMIC_RELAXED)
#define AO_HAVE_char_store
#ifdef AO_REQUIRE_CAS
AO_INLINE int
AO_compare_and_swap(volatile AO_t*p,AO_t ov,AO_t nv)
{
return (int)__atomic_compare_exchange_n(p,&ov,nv,0,
__ATOMIC_RELAXED,__ATOMIC_RELAXED);
}
AO_INLINE int
AO_compare_and_swap_release(volatile AO_t*p,AO_t ov,AO_t nv)
{
return (int)__atomic_compare_exchange_n(p,&ov,nv,0,
__ATOMIC_RELEASE,__ATOMIC_RELAXED);
}
#define AO_HAVE_compare_and_swap_release
#endif
#ifdef __cplusplus
}
#endif
#ifndef NO_LOCKFREE_AO_OR
#define HAVE_LOCKFREE_AO_OR 1
#endif
#else
#include "atomic_ops.h"
#if (!defined(AO_HAVE_load)||!defined(AO_HAVE_store))&&!defined(CPPCHECK)
#error AO_load or AO_store is missing;probably old version of atomic_ops
#endif
#endif
#endif
#ifndef AO_HAVE_compiler_barrier
#define AO_HAVE_compiler_barrier 1
#endif
#endif
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)
#ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN 1
#endif
#define NOSERVICE
#include <windows.h>
#include <winbase.h>
#endif
#ifndef GC_LOCKS_H
#define GC_LOCKS_H
#ifdef THREADS
#ifdef PCR
#include <base/PCR_Base.h>
#include <th/PCR_Th.h>
#endif
EXTERN_C_BEGIN
#ifdef PCR
GC_EXTERN PCR_Th_ML GC_allocate_ml;
#if defined(CPPCHECK)
#define DCL_LOCK_STATE
#else
#define DCL_LOCK_STATE PCR_ERes GC_fastLockRes;PCR_sigset_t GC_old_sig_mask
#endif
#define UNCOND_LOCK()PCR_Th_ML_Acquire(&GC_allocate_ml)
#define UNCOND_UNLOCK()PCR_Th_ML_Release(&GC_allocate_ml)
#elif defined(NN_PLATFORM_CTR)||defined(NINTENDO_SWITCH)
extern void GC_lock(void);
extern void GC_unlock(void);
#define UNCOND_LOCK()GC_lock()
#define UNCOND_UNLOCK()GC_unlock()
#endif
#if (!defined(AO_HAVE_test_and_set_acquire)||defined(GC_RTEMS_PTHREADS)||defined(SN_TARGET_ORBIS)||defined(SN_TARGET_PS3)||defined(GC_WIN32_THREADS)||defined(BASE_ATOMIC_OPS_EMULATED)||defined(LINT2))&&defined(GC_PTHREADS)
#define USE_PTHREAD_LOCKS
#undef USE_SPIN_LOCK
#endif
#if defined(GC_WIN32_THREADS)&&!defined(USE_PTHREAD_LOCKS)
#define NO_THREAD (DWORD)(-1)
GC_EXTERN CRITICAL_SECTION GC_allocate_ml;
#ifdef GC_ASSERTIONS
GC_EXTERN DWORD GC_lock_holder;
#define SET_LOCK_HOLDER()GC_lock_holder=GetCurrentThreadId()
#define UNSET_LOCK_HOLDER()GC_lock_holder=NO_THREAD
#define I_HOLD_LOCK()(!GC_need_to_lock||GC_lock_holder==GetCurrentThreadId())
#ifdef THREAD_SANITIZER
#define I_DONT_HOLD_LOCK()TRUE
#else
#define I_DONT_HOLD_LOCK()(!GC_need_to_lock||GC_lock_holder!=GetCurrentThreadId())
#endif
#define UNCOND_LOCK(){ GC_ASSERT(I_DONT_HOLD_LOCK());EnterCriticalSection(&GC_allocate_ml);SET_LOCK_HOLDER();}
#define UNCOND_UNLOCK(){ GC_ASSERT(I_HOLD_LOCK());UNSET_LOCK_HOLDER();LeaveCriticalSection(&GC_allocate_ml);}
#else
#define UNCOND_LOCK()EnterCriticalSection(&GC_allocate_ml)
#define UNCOND_UNLOCK()LeaveCriticalSection(&GC_allocate_ml)
#endif
#elif defined(GC_PTHREADS)
EXTERN_C_END
#include <pthread.h>
EXTERN_C_BEGIN
#if!defined(GC_WIN32_PTHREADS)
#define NUMERIC_THREAD_ID(id)((unsigned long)(id))
#define THREAD_EQUAL(id1,id2)((id1)==(id2))
#define NUMERIC_THREAD_ID_UNIQUE
#elif defined(__WINPTHREADS_VERSION_MAJOR)
#define NUMERIC_THREAD_ID(id)((unsigned long)(id))
#define THREAD_EQUAL(id1,id2)((id1)==(id2))
#ifndef _WIN64
#define NUMERIC_THREAD_ID_UNIQUE
#endif
#else
#define NUMERIC_THREAD_ID(id)((unsigned long)(word)(id.p))
#define THREAD_EQUAL(id1,id2)((id1.p==id2.p)&&(id1.x==id2.x))
#undef NUMERIC_THREAD_ID_UNIQUE
#endif
#define NO_THREAD ((unsigned long)(-1l))
#ifdef SN_TARGET_PSP2
EXTERN_C_END
#include "psp2-support.h"
EXTERN_C_BEGIN
GC_EXTERN WapiMutex GC_allocate_ml_PSP2;
#define UNCOND_LOCK(){ int res;GC_ASSERT(I_DONT_HOLD_LOCK());res=PSP2_MutexLock(&GC_allocate_ml_PSP2);GC_ASSERT(0==res);(void)res;SET_LOCK_HOLDER();}
#define UNCOND_UNLOCK(){ int res;GC_ASSERT(I_HOLD_LOCK());UNSET_LOCK_HOLDER();res=PSP2_MutexUnlock(&GC_allocate_ml_PSP2);GC_ASSERT(0==res);(void)res;}
#elif (!defined(THREAD_LOCAL_ALLOC)||defined(USE_SPIN_LOCK))&&!defined(USE_PTHREAD_LOCKS)
#undef USE_SPIN_LOCK
#define USE_SPIN_LOCK
GC_EXTERN volatile AO_TS_t GC_allocate_lock;
GC_INNER void GC_lock(void);
#ifdef GC_ASSERTIONS
#define UNCOND_LOCK(){ GC_ASSERT(I_DONT_HOLD_LOCK());if (AO_test_and_set_acquire(&GC_allocate_lock)==AO_TS_SET)GC_lock();SET_LOCK_HOLDER();}
#define UNCOND_UNLOCK(){ GC_ASSERT(I_HOLD_LOCK());UNSET_LOCK_HOLDER();AO_CLEAR(&GC_allocate_lock);}
#else
#define UNCOND_LOCK(){ if (AO_test_and_set_acquire(&GC_allocate_lock)==AO_TS_SET)GC_lock();}
#define UNCOND_UNLOCK()AO_CLEAR(&GC_allocate_lock)
#endif
#else
#ifndef USE_PTHREAD_LOCKS
#define USE_PTHREAD_LOCKS
#endif
#endif
#ifdef USE_PTHREAD_LOCKS
EXTERN_C_END
#include <pthread.h>
EXTERN_C_BEGIN
GC_EXTERN pthread_mutex_t GC_allocate_ml;
#ifdef GC_ASSERTIONS
GC_INNER void GC_lock(void);
#define UNCOND_LOCK(){ GC_ASSERT(I_DONT_HOLD_LOCK());GC_lock();SET_LOCK_HOLDER();}
#define UNCOND_UNLOCK(){ GC_ASSERT(I_HOLD_LOCK());UNSET_LOCK_HOLDER();pthread_mutex_unlock(&GC_allocate_ml);}
#else
#if defined(NO_PTHREAD_TRYLOCK)
#define UNCOND_LOCK()pthread_mutex_lock(&GC_allocate_ml)
#else
GC_INNER void GC_lock(void);
#define UNCOND_LOCK(){ if (0!=pthread_mutex_trylock(&GC_allocate_ml))GC_lock();}
#endif
#define UNCOND_UNLOCK()pthread_mutex_unlock(&GC_allocate_ml)
#endif
#endif
#ifdef GC_ASSERTIONS
GC_EXTERN unsigned long GC_lock_holder;
#define SET_LOCK_HOLDER()GC_lock_holder=NUMERIC_THREAD_ID(pthread_self())
#define UNSET_LOCK_HOLDER()GC_lock_holder=NO_THREAD
#define I_HOLD_LOCK()(!GC_need_to_lock||GC_lock_holder==NUMERIC_THREAD_ID(pthread_self()))
#if!defined(NUMERIC_THREAD_ID_UNIQUE)||defined(THREAD_SANITIZER)
#define I_DONT_HOLD_LOCK()TRUE
#else
#define I_DONT_HOLD_LOCK()(!GC_need_to_lock||GC_lock_holder!=NUMERIC_THREAD_ID(pthread_self()))
#endif
#endif
#ifndef GC_WIN32_THREADS
GC_EXTERN volatile GC_bool GC_collecting;
#ifdef AO_HAVE_char_store
#define ENTER_GC()AO_char_store((unsigned char*)&GC_collecting,TRUE)
#define EXIT_GC()AO_char_store((unsigned char*)&GC_collecting,FALSE)
#else
#define ENTER_GC()(void)(GC_collecting=TRUE)
#define EXIT_GC()(void)(GC_collecting=FALSE)
#endif
#endif
#endif
#if defined(GC_ALWAYS_MULTITHREADED)&&(defined(USE_PTHREAD_LOCKS)||defined(USE_SPIN_LOCK))
#define GC_need_to_lock TRUE
#define set_need_to_lock()(void)0
#else
#if defined(GC_ALWAYS_MULTITHREADED)&&!defined(CPPCHECK)
#error Runtime initialization of GC lock is needed!
#endif
#undef GC_ALWAYS_MULTITHREADED
GC_EXTERN GC_bool GC_need_to_lock;
#ifdef THREAD_SANITIZER
#define set_need_to_lock()(void)(*(GC_bool volatile*)&GC_need_to_lock?FALSE:(GC_need_to_lock=TRUE))
#else
#define set_need_to_lock()(void)(GC_need_to_lock=TRUE)
#endif
#endif
EXTERN_C_END
#else
#define LOCK()(void)0
#define UNLOCK()(void)0
#ifdef GC_ASSERTIONS
#define I_HOLD_LOCK()TRUE
#define I_DONT_HOLD_LOCK()TRUE
#endif
#endif
#if defined(UNCOND_LOCK)&&!defined(LOCK)
#if (defined(LINT2)&&defined(USE_PTHREAD_LOCKS))||defined(GC_ALWAYS_MULTITHREADED)
#define LOCK()UNCOND_LOCK()
#define UNLOCK()UNCOND_UNLOCK()
#else
#define LOCK()do { if (GC_need_to_lock)UNCOND_LOCK();} while (0)
#define UNLOCK()do { if (GC_need_to_lock)UNCOND_UNLOCK();} while (0)
#endif
#endif
#ifndef ENTER_GC
#define ENTER_GC()
#define EXIT_GC()
#endif
#ifndef DCL_LOCK_STATE
#define DCL_LOCK_STATE
#endif
#endif
#define GC_WORD_MAX (~(word)0)
#ifdef STACK_GROWS_DOWN
#define COOLER_THAN >
#define HOTTER_THAN <
#define MAKE_COOLER(x,y)if ((word)((x)+(y))> (word)(x)){(x)+=(y);} else (x)=(ptr_t)GC_WORD_MAX
#define MAKE_HOTTER(x,y)(x)-=(y)
#else
#define COOLER_THAN <
#define HOTTER_THAN >
#define MAKE_COOLER(x,y)if ((word)((x)- (y))< (word)(x)){(x)-=(y);} else (x)=0
#define MAKE_HOTTER(x,y)(x)+=(y)
#endif
#if defined(AMIGA)&&defined(__SASC)
#define GC_FAR __far
#else
#define GC_FAR
#endif
EXTERN_C_BEGIN
#ifndef GC_NO_FINALIZATION
#define GC_INVOKE_FINALIZERS()GC_notify_or_invoke_finalizers()
GC_INNER void GC_notify_or_invoke_finalizers(void);
GC_INNER void GC_finalize(void);
#ifndef GC_TOGGLE_REFS_NOT_NEEDED
GC_INNER void GC_process_togglerefs(void);
#endif
#ifndef SMALL_CONFIG
GC_INNER void GC_print_finalization_stats(void);
#endif
#else
#define GC_INVOKE_FINALIZERS()(void)0
#endif
#if!defined(DONT_ADD_BYTE_AT_END)
#ifdef LINT2
#define EXTRA_BYTES ((size_t)(GC_all_interior_pointers?1:0))
#else
#define EXTRA_BYTES (size_t)GC_all_interior_pointers
#endif
#define MAX_EXTRA_BYTES 1
#else
#define EXTRA_BYTES 0
#define MAX_EXTRA_BYTES 0
#endif
#ifndef LARGE_CONFIG
#define MINHINCR 16
#define MAXHINCR 2048
#else
#define MINHINCR 64
#define MAXHINCR 4096
#endif
#define BL_LIMIT GC_black_list_spacing
#ifdef NEED_CALLINFO
struct callinfo {
word ci_pc;
#if NARGS > 0
word ci_arg[NARGS];
#endif
#if (NFRAMES*(NARGS+1))% 2==1
word ci_dummy;
#endif
};
#endif
#ifdef SAVE_CALL_CHAIN
GC_INNER void GC_save_callers(struct callinfo info[NFRAMES]);
GC_INNER void GC_print_callers(struct callinfo info[NFRAMES]);
#endif
EXTERN_C_END
#ifndef NO_CLOCK
#ifdef BSD_TIME
#undef CLOCK_TYPE
#undef GET_TIME
#undef MS_TIME_DIFF
#define CLOCK_TYPE struct timeval
#define CLOCK_TYPE_INITIALIZER { 0,0 }
#define GET_TIME(x)do { struct rusage rusage;getrusage(RUSAGE_SELF,&rusage);x=rusage.ru_utime;} while (0)
#define MS_TIME_DIFF(a,b)((unsigned long)((long)(a.tv_sec-b.tv_sec)*1000+(long)(a.tv_usec - b.tv_usec)/1000 - (a.tv_usec < b.tv_usec&&(long)(a.tv_usec - b.tv_usec)% 1000!=0?1:0)))
#define NS_FRAC_TIME_DIFF(a,b)((unsigned long)((a.tv_usec < b.tv_usec&&(long)(a.tv_usec - b.tv_usec)% 1000!=0?1000L:0)+(long)(a.tv_usec - b.tv_usec)% 1000)*1000)
#elif defined(MSWIN32)||defined(MSWINCE)||defined(WINXP_USE_PERF_COUNTER)
#if defined(MSWINRT_FLAVOR)||defined(WINXP_USE_PERF_COUNTER)
#define CLOCK_TYPE ULONGLONG
#define GET_TIME(x)do { LARGE_INTEGER freq,tc;if (!QueryPerformanceFrequency(&freq)||!QueryPerformanceCounter(&tc))ABORT("QueryPerformanceCounter requires WinXP+");x=(CLOCK_TYPE)((double)tc.QuadPart/freq.QuadPart*1e9);} while (0)
#define MS_TIME_DIFF(a,b)((unsigned long)(((a)- (b))/1000000UL))
#define NS_FRAC_TIME_DIFF(a,b)((unsigned long)(((a)- (b))% 1000000UL))
#else
#define CLOCK_TYPE DWORD
#define GET_TIME(x)(void)(x=GetTickCount())
#define MS_TIME_DIFF(a,b)((unsigned long)((a)- (b)))
#define NS_FRAC_TIME_DIFF(a,b)0UL
#endif
#elif defined(NN_PLATFORM_CTR)
#define CLOCK_TYPE long long
EXTERN_C_BEGIN
CLOCK_TYPE n3ds_get_system_tick(void);
CLOCK_TYPE n3ds_convert_tick_to_ms(CLOCK_TYPE tick);
EXTERN_C_END
#define GET_TIME(x)(void)(x=n3ds_get_system_tick())
#define MS_TIME_DIFF(a,b)((unsigned long)n3ds_convert_tick_to_ms((a)-(b)))
#define NS_FRAC_TIME_DIFF(a,b)0UL
#elif defined(NINTENDO_SWITCH)||(((defined(LINUX)&&defined(__USE_POSIX199309))||defined(CYGWIN32))&&defined(_POSIX_TIMERS))
#include <time.h>
#define CLOCK_TYPE struct timespec
#define CLOCK_TYPE_INITIALIZER { 0,0 }
#if defined(_POSIX_MONOTONIC_CLOCK)&&!defined(NINTENDO_SWITCH)
#define GET_TIME(x)do { if (clock_gettime(CLOCK_MONOTONIC,&x)==-1)ABORT("clock_gettime failed");} while (0)
#else
#define GET_TIME(x)do { if (clock_gettime(CLOCK_REALTIME,&x)==-1)ABORT("clock_gettime failed");} while (0)
#endif
#define MS_TIME_DIFF(a,b)((unsigned long)((a).tv_nsec+(1000000L*1000 - (b).tv_nsec))/1000000UL+((unsigned long)((a).tv_sec - (b).tv_sec)*1000UL)- 1000UL)
#define NS_FRAC_TIME_DIFF(a,b)((unsigned long)((a).tv_nsec+(1000000L*1000 - (b).tv_nsec))% 1000000UL)
#else
#include <time.h>
#if defined(FREEBSD)&&!defined(CLOCKS_PER_SEC)
#include <machine/limits.h>
#define CLOCKS_PER_SEC CLK_TCK
#endif
#if!defined(CLOCKS_PER_SEC)
#define CLOCKS_PER_SEC 1000000
#endif
#define CLOCK_TYPE clock_t
#define GET_TIME(x)(void)(x=clock())
#define MS_TIME_DIFF(a,b)(CLOCKS_PER_SEC % 1000==0?(unsigned long)((a)- (b))/(unsigned long)(CLOCKS_PER_SEC/1000):((unsigned long)((a)- (b))*1000)/(unsigned long)CLOCKS_PER_SEC)
#define NS_FRAC_TIME_DIFF(a,b)(CLOCKS_PER_SEC<=1000?0UL:(unsigned long)(CLOCKS_PER_SEC<=(clock_t)1000000UL?(((a)- (b))*((clock_t)1000000UL/CLOCKS_PER_SEC)% 1000)*1000:(CLOCKS_PER_SEC<=(clock_t)1000000UL*1000?((a)- (b))*((clock_t)1000000UL*1000/CLOCKS_PER_SEC):(((a)- (b))*(clock_t)1000000UL*1000)/CLOCKS_PER_SEC)% (clock_t)1000000UL))
#endif
#ifndef CLOCK_TYPE_INITIALIZER
#define CLOCK_TYPE_INITIALIZER 0
#endif
#endif
#if defined(SPARC)&&defined(SUNOS4)||(defined(M68K)&&defined(NEXT))||defined(VAX)
#define BCOPY_EXISTS
#elif defined(AMIGA)||defined(DARWIN)
#include <string.h>
#define BCOPY_EXISTS
#elif defined(MACOS)&&defined(POWERPC)
#include <MacMemory.h>
#define bcopy(x,y,n)BlockMoveData(x,y,n)
#define bzero(x,n)BlockZero(x,n)
#define BCOPY_EXISTS
#endif
#if!defined(BCOPY_EXISTS)||defined(CPPCHECK)
#include <string.h>
#define BCOPY(x,y,n)memcpy(y,x,(size_t)(n))
#define BZERO(x,n)memset(x,0,(size_t)(n))
#else
#define BCOPY(x,y,n)bcopy((void*)(x),(void*)(y),(size_t)(n))
#define BZERO(x,n)bzero((void*)(x),(size_t)(n))
#endif
#ifdef PCR
#include "th/PCR_ThCtl.h"
#endif
EXTERN_C_BEGIN
#ifdef PCR
#define STOP_WORLD()PCR_ThCtl_SetExclusiveMode(PCR_ThCtl_ExclusiveMode_stopNormal,PCR_allSigsBlocked,PCR_waitForever)
#define START_WORLD()PCR_ThCtl_SetExclusiveMode(PCR_ThCtl_ExclusiveMode_null,PCR_allSigsBlocked,PCR_waitForever)
#else
#if defined(NN_PLATFORM_CTR)||defined(NINTENDO_SWITCH)||defined(GC_WIN32_THREADS)||defined(GC_PTHREADS)
GC_INNER void GC_stop_world(void);
GC_INNER void GC_start_world(void);
#define STOP_WORLD()GC_stop_world()
#define START_WORLD()GC_start_world()
#else
#define STOP_WORLD()GC_ASSERT(GC_blocked_sp==NULL)
#define START_WORLD()
#endif
#endif
#ifdef THREADS
GC_EXTERN GC_on_thread_event_proc GC_on_thread_event;
#endif
#if defined(SMALL_CONFIG)||defined(PCR)
#define GC_on_abort(msg)(void)0
#else
GC_API_PRIV GC_abort_func GC_on_abort;
#endif
#if defined(CPPCHECK)
#define ABORT(msg){ GC_on_abort(msg);abort();}
#elif defined(PCR)
#define ABORT(s)PCR_Base_Panic(s)
#else
#if defined(MSWIN_XBOX1)&&!defined(DebugBreak)
#define DebugBreak()__debugbreak()
#elif defined(MSWINCE)&&!defined(DebugBreak)&&(!defined(UNDER_CE)||(defined(__MINGW32CE__)&&!defined(ARM32)))
#define DebugBreak()_exit(-1)
#endif
#if defined(MSWIN32)&&(defined(NO_DEBUGGING)||defined(LINT2))
#define ABORT(msg)(GC_on_abort(msg),_exit(-1))
#elif defined(MSWINCE)&&defined(NO_DEBUGGING)
#define ABORT(msg)(GC_on_abort(msg),ExitProcess(-1))
#elif defined(MSWIN32)||defined(MSWINCE)
#if defined(_CrtDbgBreak)&&defined(_DEBUG)&&defined(_MSC_VER)
#define ABORT(msg){ GC_on_abort(msg);_CrtDbgBreak();}
#else
#define ABORT(msg){ GC_on_abort(msg);DebugBreak();}
#endif
#else
#define ABORT(msg)(GC_on_abort(msg),abort())
#endif
#endif
#define ABORT_ARG1(C_msg,C_fmt,arg1)MACRO_BLKSTMT_BEGIN GC_INFOLOG_PRINTF(C_msg C_fmt "\n",arg1);ABORT(C_msg);MACRO_BLKSTMT_END
#define ABORT_ARG2(C_msg,C_fmt,arg1,arg2)MACRO_BLKSTMT_BEGIN GC_INFOLOG_PRINTF(C_msg C_fmt "\n",arg1,arg2);ABORT(C_msg);MACRO_BLKSTMT_END
#define ABORT_ARG3(C_msg,C_fmt,arg1,arg2,arg3)MACRO_BLKSTMT_BEGIN GC_INFOLOG_PRINTF(C_msg C_fmt "\n",arg1,arg2,arg3);ABORT(C_msg);MACRO_BLKSTMT_END
#define ABORT_RET(msg)if ((signed_word)GC_current_warn_proc==-1){} else ABORT(msg)
#ifdef PCR
#define EXIT()PCR_Base_Exit(1,PCR_waitForever)
#else
#define EXIT()(GC_on_abort(NULL),exit(1))
#endif
#define WARN(msg,arg)(*GC_current_warn_proc)(( char*)("GC Warning:" msg),(word)(arg))
GC_EXTERN GC_warn_proc GC_current_warn_proc;
#ifndef WARN_PRIdPTR
#define WARN_PRIdPTR "ld"
#endif
#define TRUSTED_STRING(s)(char*)COVERT_DATAFLOW(s)
#ifdef GC_READ_ENV_FILE
GC_INNER char*GC_envfile_getenv(const char*name);
#define GETENV(name)GC_envfile_getenv(name)
#elif defined(NO_GETENV)&&!defined(CPPCHECK)
#define GETENV(name)NULL
#elif defined(EMPTY_GETENV_RESULTS)
GC_INLINE char*fixed_getenv(const char*name)
{
char*value=getenv(name);
return value!=NULL&&*value!='\0'?value:NULL;
}
#define GETENV(name)fixed_getenv(name)
#else
#define GETENV(name)getenv(name)
#endif
EXTERN_C_END
#if defined(DARWIN)
#include <mach/thread_status.h>
#ifndef MAC_OS_X_VERSION_MAX_ALLOWED
#include <AvailabilityMacros.h>
#endif
#if defined(POWERPC)
#if CPP_WORDSZ==32
#define GC_THREAD_STATE_T ppc_thread_state_t
#else
#define GC_THREAD_STATE_T ppc_thread_state64_t
#define GC_MACH_THREAD_STATE PPC_THREAD_STATE64
#define GC_MACH_THREAD_STATE_COUNT PPC_THREAD_STATE64_COUNT
#endif
#elif defined(I386)||defined(X86_64)
#if CPP_WORDSZ==32
#if defined(i386_THREAD_STATE_COUNT)&&!defined(x86_THREAD_STATE32_COUNT)
#define GC_THREAD_STATE_T i386_thread_state_t
#define GC_MACH_THREAD_STATE i386_THREAD_STATE
#define GC_MACH_THREAD_STATE_COUNT i386_THREAD_STATE_COUNT
#else
#define GC_THREAD_STATE_T x86_thread_state32_t
#define GC_MACH_THREAD_STATE x86_THREAD_STATE32
#define GC_MACH_THREAD_STATE_COUNT x86_THREAD_STATE32_COUNT
#endif
#else
#define GC_THREAD_STATE_T x86_thread_state64_t
#define GC_MACH_THREAD_STATE x86_THREAD_STATE64
#define GC_MACH_THREAD_STATE_COUNT x86_THREAD_STATE64_COUNT
#endif
#elif defined(ARM32)&&defined(ARM_UNIFIED_THREAD_STATE)&&!defined(CPPCHECK)
#define GC_THREAD_STATE_T arm_unified_thread_state_t
#define GC_MACH_THREAD_STATE ARM_UNIFIED_THREAD_STATE
#define GC_MACH_THREAD_STATE_COUNT ARM_UNIFIED_THREAD_STATE_COUNT
#elif defined(ARM32)
#define GC_THREAD_STATE_T arm_thread_state_t
#ifdef ARM_MACHINE_THREAD_STATE_COUNT
#define GC_MACH_THREAD_STATE ARM_MACHINE_THREAD_STATE
#define GC_MACH_THREAD_STATE_COUNT ARM_MACHINE_THREAD_STATE_COUNT
#endif
#elif defined(AARCH64)
#define GC_THREAD_STATE_T arm_thread_state64_t
#define GC_MACH_THREAD_STATE ARM_THREAD_STATE64
#define GC_MACH_THREAD_STATE_COUNT ARM_THREAD_STATE64_COUNT
#elif!defined(CPPCHECK)
#error define GC_THREAD_STATE_T
#endif
#ifndef GC_MACH_THREAD_STATE
#define GC_MACH_THREAD_STATE MACHINE_THREAD_STATE
#define GC_MACH_THREAD_STATE_COUNT MACHINE_THREAD_STATE_COUNT
#endif
#if CPP_WORDSZ==32
#define GC_MACH_HEADER mach_header
#define GC_MACH_SECTION section
#define GC_GETSECTBYNAME getsectbynamefromheader
#else
#define GC_MACH_HEADER mach_header_64
#define GC_MACH_SECTION section_64
#define GC_GETSECTBYNAME getsectbynamefromheader_64
#endif
#if __DARWIN_UNIX03
#define THREAD_FLD_NAME(x)__ ## x
#else
#define THREAD_FLD_NAME(x)x
#endif
#if defined(ARM32)&&defined(ARM_UNIFIED_THREAD_STATE)
#define THREAD_FLD(x)ts_32.THREAD_FLD_NAME(x)
#else
#define THREAD_FLD(x)THREAD_FLD_NAME(x)
#endif
#endif
#include <setjmp.h>
#if __STDC_VERSION__>=201112L
#include <assert.h>
#endif
EXTERN_C_BEGIN
#if CPP_WORDSZ==32
#define WORDS_TO_BYTES(x)((x)<<2)
#define BYTES_TO_WORDS(x)((x)>>2)
#define LOGWL ((word)5)
#define modWORDSZ(n)((n)&0x1f)
#if ALIGNMENT!=4
#define UNALIGNED_PTRS
#endif
#endif
#if CPP_WORDSZ==64
#define WORDS_TO_BYTES(x)((x)<<3)
#define BYTES_TO_WORDS(x)((x)>>3)
#define LOGWL ((word)6)
#define modWORDSZ(n)((n)&0x3f)
#if ALIGNMENT!=8
#define UNALIGNED_PTRS
#endif
#endif
#define GRANULE_BYTES GC_GRANULE_BYTES
#define TINY_FREELISTS GC_TINY_FREELISTS
#define WORDSZ ((word)CPP_WORDSZ)
#define SIGNB ((word)1<<(WORDSZ-1))
#define BYTES_PER_WORD ((word)(sizeof (word)))
#define divWORDSZ(n)((n)>>LOGWL)
#if GRANULE_BYTES==8
#define BYTES_TO_GRANULES(n)((n)>>3)
#define GRANULES_TO_BYTES(n)((n)<<3)
#if CPP_WORDSZ==64
#define GRANULES_TO_WORDS(n)(n)
#elif CPP_WORDSZ==32
#define GRANULES_TO_WORDS(n)((n)<<1)
#else
#define GRANULES_TO_WORDS(n)BYTES_TO_WORDS(GRANULES_TO_BYTES(n))
#endif
#elif GRANULE_BYTES==16
#define BYTES_TO_GRANULES(n)((n)>>4)
#define GRANULES_TO_BYTES(n)((n)<<4)
#if CPP_WORDSZ==64
#define GRANULES_TO_WORDS(n)((n)<<1)
#elif CPP_WORDSZ==32
#define GRANULES_TO_WORDS(n)((n)<<2)
#else
#define GRANULES_TO_WORDS(n)BYTES_TO_WORDS(GRANULES_TO_BYTES(n))
#endif
#else
#error Bad GRANULE_BYTES value
#endif
#ifndef HBLKSIZE
#if defined(LARGE_CONFIG)||!defined(SMALL_CONFIG)
#ifdef ALPHA
#define CPP_LOG_HBLKSIZE 13
#elif defined(SN_TARGET_ORBIS)||defined(SN_TARGET_PSP2)
#define CPP_LOG_HBLKSIZE 16
#else
#define CPP_LOG_HBLKSIZE 12
#endif
#else
#define CPP_LOG_HBLKSIZE 10
#endif
#else
#if HBLKSIZE==512
#define CPP_LOG_HBLKSIZE 9
#elif HBLKSIZE==1024
#define CPP_LOG_HBLKSIZE 10
#elif HBLKSIZE==2048
#define CPP_LOG_HBLKSIZE 11
#elif HBLKSIZE==4096
#define CPP_LOG_HBLKSIZE 12
#elif HBLKSIZE==8192
#define CPP_LOG_HBLKSIZE 13
#elif HBLKSIZE==16384
#define CPP_LOG_HBLKSIZE 14
#elif!defined(CPPCHECK)
#error Bad HBLKSIZE value
#endif
#undef HBLKSIZE
#endif
#define CPP_HBLKSIZE (1<<CPP_LOG_HBLKSIZE)
#define LOG_HBLKSIZE ((size_t)CPP_LOG_HBLKSIZE)
#define HBLKSIZE ((size_t)CPP_HBLKSIZE)
#define GC_SQRT_SIZE_MAX ((((size_t)1)<<(WORDSZ/2))- 1)
#define CPP_MAXOBJBYTES (CPP_HBLKSIZE/2)
#define MAXOBJBYTES ((size_t)CPP_MAXOBJBYTES)
#define CPP_MAXOBJWORDS BYTES_TO_WORDS(CPP_MAXOBJBYTES)
#define MAXOBJWORDS ((size_t)CPP_MAXOBJWORDS)
#define CPP_MAXOBJGRANULES BYTES_TO_GRANULES(CPP_MAXOBJBYTES)
#define MAXOBJGRANULES ((size_t)CPP_MAXOBJGRANULES)
#define divHBLKSZ(n)((n)>>LOG_HBLKSIZE)
#define HBLK_PTR_DIFF(p,q)divHBLKSZ((ptr_t)p - (ptr_t)q)
#define modHBLKSZ(n)((n)&(HBLKSIZE-1))
#define HBLKPTR(objptr)((struct hblk*)(((word)(objptr))&~(word)(HBLKSIZE-1)))
#define HBLKDISPL(objptr)(((size_t)(objptr))&(HBLKSIZE-1))
#define ROUNDUP_GRANULE_SIZE(lb)(SIZET_SAT_ADD(lb,GRANULE_BYTES - 1)&~(GRANULE_BYTES - 1))
#define ROUNDED_UP_GRANULES(lb)BYTES_TO_GRANULES(SIZET_SAT_ADD(lb,GRANULE_BYTES - 1+EXTRA_BYTES))
#if MAX_EXTRA_BYTES==0
#define SMALL_OBJ(bytes)EXPECT((bytes)<=(MAXOBJBYTES),TRUE)
#else
#define SMALL_OBJ(bytes)(EXPECT((bytes)<=(MAXOBJBYTES - MAX_EXTRA_BYTES),TRUE)||(bytes)<=MAXOBJBYTES - EXTRA_BYTES)
#endif
#define ADD_SLOP(lb)SIZET_SAT_ADD(lb,EXTRA_BYTES)
#ifdef LARGE_CONFIG
#if CPP_WORDSZ==32
#define LOG_PHT_ENTRIES 20
#else
#define LOG_PHT_ENTRIES 21
#endif
#elif!defined(SMALL_CONFIG)
#define LOG_PHT_ENTRIES 18
#else
#define LOG_PHT_ENTRIES 15
#endif
#define PHT_ENTRIES ((word)1<<LOG_PHT_ENTRIES)
#define PHT_SIZE (PHT_ENTRIES>>LOGWL)
typedef word page_hash_table[PHT_SIZE];
#define PHT_HASH(addr)((((word)(addr))>>LOG_HBLKSIZE)&(PHT_ENTRIES - 1))
#define get_pht_entry_from_index(bl,index)(((bl)[divWORDSZ(index)]>>modWORDSZ(index))&1)
#define set_pht_entry_from_index(bl,index)(void)((bl)[divWORDSZ(index)]|=(word)1<<modWORDSZ(index))
#if defined(THREADS)&&defined(AO_HAVE_or)
#define set_pht_entry_from_index_concurrent(bl,index)AO_or((volatile AO_t*)&(bl)[divWORDSZ(index)],(AO_t)((word)1<<modWORDSZ(index)))
#else
#define set_pht_entry_from_index_concurrent(bl,index)set_pht_entry_from_index(bl,index)
#endif
#define HBLKMASK (HBLKSIZE-1)
#define MARK_BITS_PER_HBLK (HBLKSIZE/GRANULE_BYTES)
union word_ptr_ao_u {
word w;
signed_word sw;
void*vp;
#ifdef PARALLEL_MARK
volatile AO_t ao;
#endif
};
struct hblkhdr {
struct hblk*hb_next;
struct hblk*hb_prev;
struct hblk*hb_block;
unsigned char hb_obj_kind;
unsigned char hb_flags;
#define IGNORE_OFF_PAGE 1
#define WAS_UNMAPPED 2
#define FREE_BLK 4
#ifdef ENABLE_DISCLAIM
#define HAS_DISCLAIM 8
#define MARK_UNCONDITIONALLY 0x10
#endif
#ifdef MARK_BIT_PER_GRANULE
#define LARGE_BLOCK 0x20
#endif
unsigned short hb_last_reclaimed;
#ifdef MARK_BIT_PER_OBJ
unsigned32 hb_inv_sz;
#define LARGE_INV_SZ (1<<16)
#endif
word hb_sz;
word hb_descr;
#ifdef MARK_BIT_PER_GRANULE
unsigned short*hb_map;
#endif
#ifdef PARALLEL_MARK
volatile AO_t hb_n_marks;
#else
size_t hb_n_marks;
#endif
#ifdef USE_MARK_BYTES
#define MARK_BITS_SZ (MARK_BITS_PER_HBLK+1)
union {
char _hb_marks[MARK_BITS_SZ];
word dummy;
} _mark_byte_union;
#define hb_marks _mark_byte_union._hb_marks
#else
#define MARK_BITS_SZ (MARK_BITS_PER_HBLK/CPP_WORDSZ+1)
word hb_marks[MARK_BITS_SZ];
#endif
};
#define ANY_INDEX 23
#define HBLK_WORDS (HBLKSIZE/sizeof(word))
#define HBLK_GRANULES (HBLKSIZE/GRANULE_BYTES)
#define HBLK_OBJS(sz_in_bytes)(HBLKSIZE/(sz_in_bytes))
struct hblk {
char hb_body[HBLKSIZE];
};
#define HBLK_IS_FREE(hdr)(((hdr)->hb_flags&FREE_BLK)!=0)
#define OBJ_SZ_TO_BLOCKS(lb)divHBLKSZ((lb)+HBLKSIZE-1)
#define OBJ_SZ_TO_BLOCKS_CHECKED(lb)divHBLKSZ(SIZET_SAT_ADD(lb,HBLKSIZE - 1))
#define obj_link(p)(*(void**)(p))
#define LOG_MAX_MARK_PROCS 6
#define MAX_MARK_PROCS (1<<LOG_MAX_MARK_PROCS)
#ifdef LARGE_CONFIG
#define MAX_ROOT_SETS 8192
#elif!defined(SMALL_CONFIG)
#define MAX_ROOT_SETS 2048
#else
#define MAX_ROOT_SETS 512
#endif
#define MAX_EXCLUSIONS (MAX_ROOT_SETS/4)
struct exclusion {
ptr_t e_start;
ptr_t e_end;
};
struct roots {
ptr_t r_start;
ptr_t r_end;
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
struct roots*r_next;
#endif
GC_bool r_tmp;
};
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
#define LOG_RT_SIZE 6
#define RT_SIZE (1<<LOG_RT_SIZE)
#endif
#ifndef MAX_HEAP_SECTS
#ifdef LARGE_CONFIG
#if CPP_WORDSZ > 32
#define MAX_HEAP_SECTS 81920
#else
#define MAX_HEAP_SECTS 7680
#endif
#elif defined(SMALL_CONFIG)&&!defined(USE_PROC_FOR_LIBRARIES)
#if defined(PARALLEL_MARK)&&(defined(MSWIN32)||defined(CYGWIN32))
#define MAX_HEAP_SECTS 384
#else
#define MAX_HEAP_SECTS 128
#endif
#elif CPP_WORDSZ > 32
#define MAX_HEAP_SECTS 1024
#else
#define MAX_HEAP_SECTS 512
#endif
#endif
typedef struct GC_ms_entry {
ptr_t mse_start;
union word_ptr_ao_u mse_descr;
} mse;
typedef int mark_state_t;
struct disappearing_link;
struct finalizable_object;
struct dl_hashtbl_s {
struct disappearing_link**head;
word entries;
unsigned log_size;
};
struct fnlz_roots_s {
struct finalizable_object**fo_head;
struct finalizable_object*finalize_now;
};
union toggle_ref_u {
void*strong_ref;
GC_hidden_pointer weak_ref;
};
typedef struct {
word ed_bitmap;
GC_bool ed_continued;
} typed_ext_descr_t;
struct _GC_arrays {
word _heapsize;
word _requested_heapsize;
ptr_t _last_heap_addr;
ptr_t _prev_heap_addr;
word _large_free_bytes;
word _large_allocd_bytes;
word _max_large_allocd_bytes;
word _bytes_allocd_before_gc;
#ifndef SEPARATE_GLOBALS
#define GC_bytes_allocd GC_arrays._bytes_allocd
word _bytes_allocd;
#endif
word _bytes_dropped;
word _bytes_finalized;
word _bytes_freed;
word _finalizer_bytes_freed;
bottom_index*_all_bottom_indices;
bottom_index*_all_bottom_indices_end;
ptr_t _scratch_free_ptr;
hdr*_hdr_free_list;
ptr_t _scratch_end_ptr;
ptr_t _scratch_last_end_ptr;
mse*_mark_stack;
mse*_mark_stack_limit;
#ifdef PARALLEL_MARK
mse*volatile _mark_stack_top;
#else
mse*_mark_stack_top;
#endif
word _composite_in_use;
word _atomic_in_use;
#ifdef USE_MUNMAP
#define GC_unmapped_bytes GC_arrays._unmapped_bytes
word _unmapped_bytes;
#ifdef COUNT_UNMAPPED_REGIONS
#define GC_num_unmapped_regions GC_arrays._num_unmapped_regions
signed_word _num_unmapped_regions;
#endif
#else
#define GC_unmapped_bytes 0
#endif
bottom_index*_all_nils;
#define GC_scan_ptr GC_arrays._scan_ptr
struct hblk*_scan_ptr;
#ifdef PARALLEL_MARK
#define GC_main_local_mark_stack GC_arrays._main_local_mark_stack
mse*_main_local_mark_stack;
#define GC_first_nonempty GC_arrays._first_nonempty
volatile AO_t _first_nonempty;
#endif
#define GC_mark_stack_size GC_arrays._mark_stack_size
size_t _mark_stack_size;
#define GC_mark_state GC_arrays._mark_state
mark_state_t _mark_state;
#define GC_mark_stack_too_small GC_arrays._mark_stack_too_small
GC_bool _mark_stack_too_small;
#define GC_objects_are_marked GC_arrays._objects_are_marked
GC_bool _objects_are_marked;
#ifdef ENABLE_TRACE
#define GC_trace_addr GC_arrays._trace_addr
ptr_t _trace_addr;
#endif
#define GC_n_heap_sects GC_arrays._n_heap_sects
word _n_heap_sects;
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)
#define GC_n_heap_bases GC_arrays._n_heap_bases
word _n_heap_bases;
#endif
#ifdef USE_PROC_FOR_LIBRARIES
#define GC_n_memory GC_arrays._n_memory
word _n_memory;
#endif
#ifdef GC_GCJ_SUPPORT
#define GC_gcjobjfreelist GC_arrays._gcjobjfreelist
ptr_t*_gcjobjfreelist;
#endif
#define GC_fo_entries GC_arrays._fo_entries
word _fo_entries;
#ifndef GC_NO_FINALIZATION
#define GC_dl_hashtbl GC_arrays._dl_hashtbl
#define GC_fnlz_roots GC_arrays._fnlz_roots
#define GC_log_fo_table_size GC_arrays._log_fo_table_size
#ifndef GC_LONG_REFS_NOT_NEEDED
#define GC_ll_hashtbl GC_arrays._ll_hashtbl
struct dl_hashtbl_s _ll_hashtbl;
#endif
struct dl_hashtbl_s _dl_hashtbl;
struct fnlz_roots_s _fnlz_roots;
unsigned _log_fo_table_size;
#ifndef GC_TOGGLE_REFS_NOT_NEEDED
#define GC_toggleref_arr GC_arrays._toggleref_arr
#define GC_toggleref_array_size GC_arrays._toggleref_array_size
#define GC_toggleref_array_capacity GC_arrays._toggleref_array_capacity
union toggle_ref_u*_toggleref_arr;
size_t _toggleref_array_size;
size_t _toggleref_array_capacity;
#endif
#endif
#ifdef TRACE_BUF
#define GC_trace_buf_ptr GC_arrays._trace_buf_ptr
int _trace_buf_ptr;
#endif
#ifdef ENABLE_DISCLAIM
#define GC_finalized_kind GC_arrays._finalized_kind
int _finalized_kind;
#endif
#define n_root_sets GC_arrays._n_root_sets
#define GC_excl_table_entries GC_arrays._excl_table_entries
int _n_root_sets;
size_t _excl_table_entries;
#ifdef THREADS
#define GC_roots_were_cleared GC_arrays._roots_were_cleared
GC_bool _roots_were_cleared;
#endif
#define GC_explicit_typing_initialized GC_arrays._explicit_typing_initialized
#define GC_ed_size GC_arrays._ed_size
#define GC_avail_descr GC_arrays._avail_descr
#define GC_ext_descriptors GC_arrays._ext_descriptors
#ifdef AO_HAVE_load_acquire
volatile AO_t _explicit_typing_initialized;
#else
GC_bool _explicit_typing_initialized;
#endif
size_t _ed_size;
size_t _avail_descr;
typed_ext_descr_t*_ext_descriptors;
GC_mark_proc _mark_procs[MAX_MARK_PROCS];
char _modws_valid_offsets[sizeof(word)];
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
#define GC_root_index GC_arrays._root_index
struct roots*_root_index[RT_SIZE];
#endif
#ifdef SAVE_CALL_CHAIN
#define GC_last_stack GC_arrays._last_stack
struct callinfo _last_stack[NFRAMES];
#endif
#ifndef SEPARATE_GLOBALS
#define GC_objfreelist GC_arrays._objfreelist
void*_objfreelist[MAXOBJGRANULES+1];
#define GC_aobjfreelist GC_arrays._aobjfreelist
void*_aobjfreelist[MAXOBJGRANULES+1];
#endif
void*_uobjfreelist[MAXOBJGRANULES+1];
#ifdef GC_ATOMIC_UNCOLLECTABLE
#define GC_auobjfreelist GC_arrays._auobjfreelist
void*_auobjfreelist[MAXOBJGRANULES+1];
#endif
size_t _size_map[MAXOBJBYTES+1];
#ifdef MARK_BIT_PER_GRANULE
#define GC_obj_map GC_arrays._obj_map
unsigned short*_obj_map[MAXOBJGRANULES+1];
#define MAP_LEN BYTES_TO_GRANULES(HBLKSIZE)
#endif
#define VALID_OFFSET_SZ HBLKSIZE
char _valid_offsets[VALID_OFFSET_SZ];
#ifndef GC_DISABLE_INCREMENTAL
#define GC_grungy_pages GC_arrays._grungy_pages
page_hash_table _grungy_pages;
#define GC_dirty_pages GC_arrays._dirty_pages
volatile page_hash_table _dirty_pages;
#endif
#if (defined(CHECKSUMS)&&defined(GWW_VDB))||defined(PROC_VDB)
#define GC_written_pages GC_arrays._written_pages
page_hash_table _written_pages;
#endif
#define GC_heap_sects GC_arrays._heap_sects
struct HeapSect {
ptr_t hs_start;
size_t hs_bytes;
} _heap_sects[MAX_HEAP_SECTS];
#if defined(USE_PROC_FOR_LIBRARIES)
#define GC_our_memory GC_arrays._our_memory
struct HeapSect _our_memory[MAX_HEAP_SECTS];
#endif
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)
#define GC_heap_bases GC_arrays._heap_bases
ptr_t _heap_bases[MAX_HEAP_SECTS];
#endif
#ifdef MSWINCE
#define GC_heap_lengths GC_arrays._heap_lengths
word _heap_lengths[MAX_HEAP_SECTS];
#endif
struct roots _static_roots[MAX_ROOT_SETS];
struct exclusion _excl_table[MAX_EXCLUSIONS];
bottom_index*_top_index[TOP_SZ];
};
GC_API_PRIV GC_FAR struct _GC_arrays GC_arrays;
#define GC_all_nils GC_arrays._all_nils
#define GC_atomic_in_use GC_arrays._atomic_in_use
#define GC_bytes_allocd_before_gc GC_arrays._bytes_allocd_before_gc
#define GC_bytes_dropped GC_arrays._bytes_dropped
#define GC_bytes_finalized GC_arrays._bytes_finalized
#define GC_bytes_freed GC_arrays._bytes_freed
#define GC_composite_in_use GC_arrays._composite_in_use
#define GC_excl_table GC_arrays._excl_table
#define GC_finalizer_bytes_freed GC_arrays._finalizer_bytes_freed
#define GC_heapsize GC_arrays._heapsize
#define GC_large_allocd_bytes GC_arrays._large_allocd_bytes
#define GC_large_free_bytes GC_arrays._large_free_bytes
#define GC_last_heap_addr GC_arrays._last_heap_addr
#define GC_mark_stack GC_arrays._mark_stack
#define GC_mark_stack_limit GC_arrays._mark_stack_limit
#define GC_mark_stack_top GC_arrays._mark_stack_top
#define GC_mark_procs GC_arrays._mark_procs
#define GC_max_large_allocd_bytes GC_arrays._max_large_allocd_bytes
#define GC_modws_valid_offsets GC_arrays._modws_valid_offsets
#define GC_prev_heap_addr GC_arrays._prev_heap_addr
#define GC_requested_heapsize GC_arrays._requested_heapsize
#define GC_all_bottom_indices GC_arrays._all_bottom_indices
#define GC_all_bottom_indices_end GC_arrays._all_bottom_indices_end
#define GC_scratch_free_ptr GC_arrays._scratch_free_ptr
#define GC_hdr_free_list GC_arrays._hdr_free_list
#define GC_scratch_end_ptr GC_arrays._scratch_end_ptr
#define GC_scratch_last_end_ptr GC_arrays._scratch_last_end_ptr
#define GC_size_map GC_arrays._size_map
#define GC_static_roots GC_arrays._static_roots
#define GC_top_index GC_arrays._top_index
#define GC_uobjfreelist GC_arrays._uobjfreelist
#define GC_valid_offsets GC_arrays._valid_offsets
#define beginGC_arrays ((ptr_t)(&GC_arrays))
#define endGC_arrays (((ptr_t)(&GC_arrays))+(sizeof GC_arrays))
#define USED_HEAP_SIZE (GC_heapsize - GC_large_free_bytes)
#ifndef MAXOBJKINDS
#define MAXOBJKINDS 16
#endif
GC_EXTERN struct obj_kind {
void**ok_freelist;
struct hblk**ok_reclaim_list;
word ok_descriptor;
GC_bool ok_relocate_descr;
GC_bool ok_init;
#ifdef ENABLE_DISCLAIM
GC_bool ok_mark_unconditionally;
int (GC_CALLBACK*ok_disclaim_proc)(void*);
#define OK_DISCLAIM_INITZ,FALSE,0
#else
#define OK_DISCLAIM_INITZ
#endif
} GC_obj_kinds[MAXOBJKINDS];
#define beginGC_obj_kinds ((ptr_t)(&GC_obj_kinds))
#define endGC_obj_kinds (beginGC_obj_kinds+(sizeof GC_obj_kinds))
#ifdef SEPARATE_GLOBALS
extern word GC_bytes_allocd;
extern ptr_t GC_objfreelist[MAXOBJGRANULES+1];
#define beginGC_objfreelist ((ptr_t)(&GC_objfreelist))
#define endGC_objfreelist (beginGC_objfreelist+sizeof(GC_objfreelist))
extern ptr_t GC_aobjfreelist[MAXOBJGRANULES+1];
#define beginGC_aobjfreelist ((ptr_t)(&GC_aobjfreelist))
#define endGC_aobjfreelist (beginGC_aobjfreelist+sizeof(GC_aobjfreelist))
#endif
#define PTRFREE 0
#define NORMAL 1
#define UNCOLLECTABLE 2
#ifdef GC_ATOMIC_UNCOLLECTABLE
#define AUNCOLLECTABLE 3
#define IS_UNCOLLECTABLE(k)(((k)&~1)==UNCOLLECTABLE)
#define GC_N_KINDS_INITIAL_VALUE 4
#else
#define IS_UNCOLLECTABLE(k)((k)==UNCOLLECTABLE)
#define GC_N_KINDS_INITIAL_VALUE 3
#endif
GC_EXTERN unsigned GC_n_kinds;
GC_EXTERN size_t GC_page_size;
#define ROUNDUP_PAGESIZE(lb)(SIZET_SAT_ADD(lb,GC_page_size - 1)&~(GC_page_size - 1))
#ifdef MMAP_SUPPORTED
#define ROUNDUP_PAGESIZE_IF_MMAP(lb)ROUNDUP_PAGESIZE(lb)
#else
#define ROUNDUP_PAGESIZE_IF_MMAP(lb)(lb)
#endif
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)
GC_EXTERN SYSTEM_INFO GC_sysinfo;
GC_INNER GC_bool GC_is_heap_base(void*p);
#endif
GC_EXTERN word GC_black_list_spacing;
#ifdef GC_GCJ_SUPPORT
extern struct hblk*GC_hblkfreelist[];
extern word GC_free_bytes[];
#endif
GC_EXTERN word GC_root_size;
GC_EXTERN GC_bool GC_debugging_started;
struct blocking_data {
GC_fn_type fn;
void*client_data;
};
struct GC_traced_stack_sect_s {
ptr_t saved_stack_ptr;
#ifdef IA64
ptr_t saved_backing_store_ptr;
ptr_t backing_store_end;
#endif
struct GC_traced_stack_sect_s*prev;
};
#ifdef THREADS
GC_INNER void GC_push_all_stack_sections(ptr_t lo,ptr_t hi,
struct GC_traced_stack_sect_s*traced_stack_sect);
GC_EXTERN word GC_total_stacksize;
#else
GC_EXTERN ptr_t GC_blocked_sp;
GC_EXTERN struct GC_traced_stack_sect_s*GC_traced_stack_sect;
#endif
#ifdef IA64
GC_INNER void GC_push_all_register_sections(ptr_t bs_lo,ptr_t bs_hi,
int eager,struct GC_traced_stack_sect_s*traced_stack_sect);
#endif
#ifdef USE_MARK_BYTES
#define mark_bit_from_hdr(hhdr,n)((hhdr)->hb_marks[n])
#define set_mark_bit_from_hdr(hhdr,n)((hhdr)->hb_marks[n]=1)
#define clear_mark_bit_from_hdr(hhdr,n)((hhdr)->hb_marks[n]=0)
#else
#if defined(PARALLEL_MARK)||(defined(THREAD_SANITIZER)&&defined(THREADS))
#define OR_WORD(addr,bits)AO_or((volatile AO_t*)(addr),(AO_t)(bits))
#else
#define OR_WORD(addr,bits)(void)(*(addr)|=(bits))
#endif
#define mark_bit_from_hdr(hhdr,n)(((hhdr)->hb_marks[divWORDSZ(n)]>>modWORDSZ(n))&(word)1)
#define set_mark_bit_from_hdr(hhdr,n)OR_WORD((hhdr)->hb_marks+divWORDSZ(n),(word)1<<modWORDSZ(n))
#define clear_mark_bit_from_hdr(hhdr,n)((hhdr)->hb_marks[divWORDSZ(n)]&=~((word)1<<modWORDSZ(n)))
#endif
#ifdef MARK_BIT_PER_OBJ
#define MARK_BIT_NO(offset,sz)(((word)(offset))/(sz))
#define MARK_BIT_OFFSET(sz)1
#define IF_PER_OBJ(x)x
#define FINAL_MARK_BIT(sz)((sz)> MAXOBJBYTES?1:HBLK_OBJS(sz))
#else
#define MARK_BIT_NO(offset,sz)BYTES_TO_GRANULES((word)(offset))
#define MARK_BIT_OFFSET(sz)BYTES_TO_GRANULES(sz)
#define IF_PER_OBJ(x)
#define FINAL_MARK_BIT(sz)((sz)> MAXOBJBYTES?MARK_BITS_PER_HBLK:BYTES_TO_GRANULES((sz)*HBLK_OBJS(sz)))
#endif
GC_INNER ptr_t GC_approx_sp(void);
GC_INNER GC_bool GC_should_collect(void);
void GC_apply_to_all_blocks(void (*fn)(struct hblk*h,word client_data),
word client_data);
GC_INNER struct hblk*GC_next_block(struct hblk*h,GC_bool allow_free);
GC_INNER struct hblk*GC_prev_block(struct hblk*h);
GC_INNER void GC_mark_init(void);
GC_INNER void GC_clear_marks(void);
GC_INNER void GC_invalidate_mark_state(void);
GC_INNER GC_bool GC_mark_some(ptr_t cold_gc_frame);
GC_INNER void GC_initiate_gc(void);
GC_INNER GC_bool GC_collection_in_progress(void);
#define GC_PUSH_ALL_SYM(sym)GC_push_all(( void*)&(sym),( void*)(&(sym)+1))
GC_INNER void GC_push_all_stack(ptr_t b,ptr_t t);
#if defined(WRAP_MARK_SOME)&&defined(PARALLEL_MARK)
GC_INNER void GC_push_conditional_eager(void*bottom,void*top,
GC_bool all);
#endif
GC_INNER void GC_push_roots(GC_bool all,ptr_t cold_gc_frame);
GC_API_PRIV GC_push_other_roots_proc GC_push_other_roots;
#ifdef THREADS
void GC_push_thread_structures(void);
#endif
GC_EXTERN void (*GC_push_typed_structures)(void);
GC_INNER void GC_with_callee_saves_pushed(void (*fn)(ptr_t,void*),
volatile ptr_t arg);
#if defined(SPARC)||defined(IA64)
ptr_t GC_save_regs_in_stack(void);
#endif
#if defined(AMIGA)||defined(MACOS)||defined(GC_DARWIN_THREADS)
void GC_push_one(word p);
#endif
#ifdef GC_WIN32_THREADS
GC_INNER void GC_push_many_regs(const word*regs,unsigned count);
#endif
#if defined(PRINT_BLACK_LIST)||defined(KEEP_BACK_PTRS)
GC_INNER void GC_mark_and_push_stack(ptr_t p,ptr_t source);
#else
GC_INNER void GC_mark_and_push_stack(ptr_t p);
#endif
GC_INNER void GC_clear_hdr_marks(hdr*hhdr);
GC_INNER void GC_set_hdr_marks(hdr*hhdr);
GC_INNER void GC_set_fl_marks(ptr_t p);
#if defined(GC_ASSERTIONS)&&defined(THREAD_LOCAL_ALLOC)
void GC_check_fl_marks(void**);
#endif
void GC_add_roots_inner(ptr_t b,ptr_t e,GC_bool tmp);
#ifdef USE_PROC_FOR_LIBRARIES
GC_INNER void GC_remove_roots_subregion(ptr_t b,ptr_t e);
#endif
GC_INNER void GC_exclude_static_roots_inner(void*start,void*finish);
#if defined(DYNAMIC_LOADING)||defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)||defined(PCR)
GC_INNER void GC_register_dynamic_libraries(void);
#endif
GC_INNER void GC_cond_register_dynamic_libraries(void);
ptr_t GC_get_main_stack_base(void);
#ifdef IA64
GC_INNER ptr_t GC_get_register_stack_base(void);
#endif
void GC_register_data_segments(void);
#ifdef THREADS
GC_INNER void GC_thr_init(void);
GC_INNER void GC_init_parallel(void);
#else
GC_INNER GC_bool GC_is_static_root(void*p);
#ifdef TRACE_BUF
void GC_add_trace_entry(char*kind,word arg1,word arg2);
#endif
#endif
#ifdef PRINT_BLACK_LIST
GC_INNER void GC_add_to_black_list_normal(word p,ptr_t source);
#define GC_ADD_TO_BLACK_LIST_NORMAL(bits,source)if (GC_all_interior_pointers){ GC_add_to_black_list_stack((word)(bits),(source));} else GC_add_to_black_list_normal((word)(bits),(source))
GC_INNER void GC_add_to_black_list_stack(word p,ptr_t source);
#define GC_ADD_TO_BLACK_LIST_STACK(bits,source)GC_add_to_black_list_stack((word)(bits),(source))
#else
GC_INNER void GC_add_to_black_list_normal(word p);
#define GC_ADD_TO_BLACK_LIST_NORMAL(bits,source)if (GC_all_interior_pointers){ GC_add_to_black_list_stack((word)(bits));} else GC_add_to_black_list_normal((word)(bits))
GC_INNER void GC_add_to_black_list_stack(word p);
#define GC_ADD_TO_BLACK_LIST_STACK(bits,source)GC_add_to_black_list_stack((word)(bits))
#endif
struct hblk*GC_is_black_listed(struct hblk*h,word len);
GC_INNER void GC_promote_black_lists(void);
GC_INNER void GC_unpromote_black_lists(void);
GC_INNER ptr_t GC_scratch_alloc(size_t bytes);
#ifdef GWW_VDB
#else
#define GC_scratch_recycle_no_gww GC_scratch_recycle_inner
#endif
GC_INNER void GC_scratch_recycle_inner(void*ptr,size_t bytes);
#ifdef MARK_BIT_PER_GRANULE
GC_INNER GC_bool GC_add_map_entry(size_t sz);
#endif
GC_INNER void GC_register_displacement_inner(size_t offset);
GC_INNER void GC_new_hblk(size_t size_in_granules,int kind);
GC_INNER ptr_t GC_build_fl(struct hblk*h,size_t words,GC_bool clear,
ptr_t list);
GC_INNER struct hblk*GC_allochblk(size_t size_in_bytes,int kind,
unsigned flags);
GC_INNER ptr_t GC_alloc_large(size_t lb,int k,unsigned flags);
GC_INNER void GC_freehblk(struct hblk*p);
GC_INNER GC_bool GC_expand_hp_inner(word n);
GC_INNER void GC_start_reclaim(GC_bool abort_if_found);
GC_INNER void GC_continue_reclaim(word sz,int kind);
GC_INNER GC_bool GC_reclaim_all(GC_stop_func stop_func,GC_bool ignore_old);
GC_INNER ptr_t GC_reclaim_generic(struct hblk*hbp,hdr*hhdr,size_t sz,
GC_bool init,ptr_t list,
signed_word*count);
GC_INNER GC_bool GC_block_empty(hdr*hhdr);
GC_INNER int GC_CALLBACK GC_never_stop_func(void);
GC_INNER GC_bool GC_try_to_collect_inner(GC_stop_func f);
#define GC_gcollect_inner()(void)GC_try_to_collect_inner(GC_never_stop_func)
#ifdef THREADS
GC_EXTERN GC_bool GC_in_thread_creation;
#endif
GC_EXTERN GC_bool GC_is_initialized;
GC_INNER void GC_collect_a_little_inner(int n);
GC_INNER void*GC_generic_malloc_inner(size_t lb,int k);
#if defined(DBG_HDRS_ALL)||defined(GC_GCJ_SUPPORT)||!defined(GC_NO_FINALIZATION)
GC_INNER void*GC_generic_malloc_inner_ignore_off_page(size_t lb,int k);
#endif
GC_INNER GC_bool GC_collect_or_expand(word needed_blocks,
GC_bool ignore_off_page,GC_bool retry);
GC_INNER ptr_t GC_allocobj(size_t sz,int kind);
#ifdef GC_ADD_CALLER
#ifdef GC_HAVE_RETURN_ADDR_PARENT
#define GC_DBG_EXTRAS GC_RETURN_ADDR_PARENT,NULL,0
#else
#define GC_DBG_EXTRAS GC_RETURN_ADDR,NULL,0
#endif
#else
#define GC_DBG_EXTRAS "unknown",0
#endif
#ifdef GC_COLLECT_AT_MALLOC
extern size_t GC_dbg_collect_at_malloc_min_lb;
#define GC_DBG_COLLECT_AT_MALLOC(lb)(void)((lb)>=GC_dbg_collect_at_malloc_min_lb?(GC_gcollect(),0):0)
#else
#define GC_DBG_COLLECT_AT_MALLOC(lb)(void)0
#endif
#if defined(THREAD_LOCAL_ALLOC)&&defined(GC_GCJ_SUPPORT)
GC_INNER void*GC_core_gcj_malloc(size_t,void*);
#endif
GC_INNER void GC_init_headers(void);
GC_INNER struct hblkhdr*GC_install_header(struct hblk*h);
GC_INNER GC_bool GC_install_counts(struct hblk*h,size_t sz);
GC_INNER void GC_remove_header(struct hblk*h);
GC_INNER void GC_remove_counts(struct hblk*h,size_t sz);
GC_INNER hdr*GC_find_header(ptr_t h);
GC_INNER void GC_add_to_heap(struct hblk*p,size_t bytes);
#ifdef USE_PROC_FOR_LIBRARIES
GC_INNER void GC_add_to_our_memory(ptr_t p,size_t bytes);
#else
#define GC_add_to_our_memory(p,bytes)
#endif
GC_INNER void GC_print_all_errors(void);
GC_EXTERN void (*GC_check_heap)(void);
GC_EXTERN void (*GC_print_all_smashed)(void);
GC_EXTERN void (*GC_print_heap_obj)(ptr_t p);
#if defined(LINUX)&&defined(__ELF__)&&!defined(SMALL_CONFIG)
void GC_print_address_map(void);
#endif
#ifndef SHORT_DBG_HDRS
GC_EXTERN GC_bool GC_findleak_delay_free;
GC_INNER GC_bool GC_check_leaked(ptr_t base);
#endif
GC_EXTERN GC_bool GC_have_errors;
#define VERBOSE 2
#if!defined(NO_CLOCK)||!defined(SMALL_CONFIG)
extern int GC_print_stats;
#else
#define GC_print_stats 0
#endif
#ifdef KEEP_BACK_PTRS
GC_EXTERN long GC_backtraces;
GC_INNER void GC_generate_random_backtrace_no_gc(void);
#endif
#ifdef LINT2
#define GC_RAND_MAX (~0U>>1)
GC_API_PRIV long GC_random(void);
#endif
GC_EXTERN GC_bool GC_print_back_height;
#ifdef MAKE_BACK_GRAPH
void GC_print_back_graph_stats(void);
#endif
#ifdef THREADS
GC_INNER void GC_free_inner(void*p);
#endif
#ifdef DBG_HDRS_ALL
GC_INNER void*GC_debug_generic_malloc_inner(size_t lb,int k);
GC_INNER void*GC_debug_generic_malloc_inner_ignore_off_page(size_t lb,
int k);
#define GC_INTERNAL_MALLOC GC_debug_generic_malloc_inner
#define GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE GC_debug_generic_malloc_inner_ignore_off_page
#ifdef THREADS
GC_INNER void GC_debug_free_inner(void*p);
#define GC_INTERNAL_FREE GC_debug_free_inner
#else
#define GC_INTERNAL_FREE GC_debug_free
#endif
#else
#define GC_INTERNAL_MALLOC GC_generic_malloc_inner
#define GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE GC_generic_malloc_inner_ignore_off_page
#ifdef THREADS
#define GC_INTERNAL_FREE GC_free_inner
#else
#define GC_INTERNAL_FREE GC_free
#endif
#endif
#ifdef USE_MUNMAP
GC_INNER void GC_unmap_old(void);
GC_INNER void GC_merge_unmapped(void);
GC_INNER void GC_unmap(ptr_t start,size_t bytes);
GC_INNER void GC_remap(ptr_t start,size_t bytes);
GC_INNER void GC_unmap_gap(ptr_t start1,size_t bytes1,ptr_t start2,
size_t bytes2);
GC_INLINE ptr_t GC_unmap_end(ptr_t start,size_t bytes)
{
return (ptr_t)((word)(start+bytes)&~(GC_page_size - 1));
}
#endif
#ifdef CAN_HANDLE_FORK
GC_EXTERN int GC_handle_fork;
#endif
#ifdef GC_DISABLE_INCREMENTAL
#define GC_incremental FALSE
#define GC_auto_incremental FALSE
#define GC_manual_vdb FALSE
#define GC_dirty(p)(void)(p)
#define REACHABLE_AFTER_DIRTY(p)(void)(p)
#else
GC_EXTERN GC_bool GC_incremental;
GC_INNER void GC_read_dirty(GC_bool output_unneeded);
GC_INNER GC_bool GC_page_was_dirty(struct hblk*h);
GC_INNER void GC_remove_protection(struct hblk*h,word nblocks,
GC_bool pointerfree);
GC_INNER GC_bool GC_dirty_init(void);
GC_EXTERN GC_bool GC_manual_vdb;
#define GC_auto_incremental (GC_incremental&&!GC_manual_vdb)
GC_INNER void GC_dirty_inner(const void*p);
#define GC_dirty(p)(GC_manual_vdb?GC_dirty_inner(p):(void)0)
#define REACHABLE_AFTER_DIRTY(p)GC_reachable_here(p)
#endif
#define GC_base_C(p)((const void*)GC_base(( void*)(p)))
void GC_print_block_list(void);
void GC_print_hblkfreelist(void);
void GC_print_heap_sects(void);
void GC_print_static_roots(void);
#ifdef KEEP_BACK_PTRS
GC_INNER void GC_store_back_pointer(ptr_t source,ptr_t dest);
GC_INNER void GC_marked_for_finalization(ptr_t dest);
#define GC_STORE_BACK_PTR(source,dest)GC_store_back_pointer(source,dest)
#define GC_MARKED_FOR_FINALIZATION(dest)GC_marked_for_finalization(dest)
#else
#define GC_STORE_BACK_PTR(source,dest)(void)(source)
#define GC_MARKED_FOR_FINALIZATION(dest)
#endif
void GC_noop6(word,word,word,word,word,word);
GC_API void GC_CALL GC_noop1(word);
#ifndef GC_ATTR_FORMAT_PRINTF
#if GC_GNUC_PREREQ(3,0)
#define GC_ATTR_FORMAT_PRINTF(spec_argnum,first_checked)__attribute__((__format__(__printf__,spec_argnum,first_checked)))
#else
#define GC_ATTR_FORMAT_PRINTF(spec_argnum,first_checked)
#endif
#endif
GC_API_PRIV void GC_printf(const char*format,...)
GC_ATTR_FORMAT_PRINTF(1,2);
GC_API_PRIV void GC_err_printf(const char*format,...)
GC_ATTR_FORMAT_PRINTF(1,2);
GC_API_PRIV void GC_log_printf(const char*format,...)
GC_ATTR_FORMAT_PRINTF(1,2);
#ifndef GC_ANDROID_LOG
#define GC_PRINT_STATS_FLAG (GC_print_stats!=0)
#define GC_INFOLOG_PRINTF GC_COND_LOG_PRINTF
#define GC_verbose_log_printf GC_log_printf
#else
extern GC_bool GC_quiet;
#define GC_PRINT_STATS_FLAG (!GC_quiet)
#ifndef GC_INFOLOG_PRINTF
#define GC_INFOLOG_PRINTF if (GC_quiet){} else GC_info_log_printf
#endif
GC_INNER void GC_info_log_printf(const char*format,...)
GC_ATTR_FORMAT_PRINTF(1,2);
GC_INNER void GC_verbose_log_printf(const char*format,...)
GC_ATTR_FORMAT_PRINTF(1,2);
#endif
#define GC_COND_LOG_PRINTF if (EXPECT(!GC_print_stats,TRUE)){} else GC_log_printf
#define GC_VERBOSE_LOG_PRINTF if (EXPECT(GC_print_stats!=VERBOSE,TRUE)){} else GC_verbose_log_printf
#ifndef GC_DBGLOG_PRINTF
#define GC_DBGLOG_PRINTF if (!GC_PRINT_STATS_FLAG){} else GC_log_printf
#endif
void GC_err_puts(const char*s);
#define TO_KiB_UL(v)((unsigned long)(((v)+((1<<9)- 1))>>10))
GC_EXTERN unsigned GC_fail_count;
GC_EXTERN long GC_large_alloc_warn_interval;
GC_EXTERN signed_word GC_bytes_found;
#ifndef GC_GET_HEAP_USAGE_NOT_NEEDED
GC_EXTERN word GC_reclaimed_bytes_before_gc;
#endif
#ifdef USE_MUNMAP
GC_EXTERN int GC_unmap_threshold;
GC_EXTERN GC_bool GC_force_unmap_on_gcollect;
#endif
#ifdef MSWIN32
GC_EXTERN GC_bool GC_no_win32_dlls;
GC_EXTERN GC_bool GC_wnt;
#endif
#ifdef THREADS
#if (defined(MSWIN32)&&!defined(CONSOLE_LOG))||defined(MSWINCE)
GC_EXTERN CRITICAL_SECTION GC_write_cs;
#ifdef GC_ASSERTIONS
GC_EXTERN GC_bool GC_write_disabled;
#endif
#endif
#if defined(GC_DISABLE_INCREMENTAL)||defined(HAVE_LOCKFREE_AO_OR)
#define GC_acquire_dirty_lock()(void)0
#define GC_release_dirty_lock()(void)0
#else
#define GC_acquire_dirty_lock()do { } while (AO_test_and_set_acquire(&GC_fault_handler_lock)==AO_TS_SET)
#define GC_release_dirty_lock()AO_CLEAR(&GC_fault_handler_lock)
GC_EXTERN volatile AO_TS_t GC_fault_handler_lock;
#endif
#ifdef MSWINCE
GC_EXTERN GC_bool GC_dont_query_stack_min;
#endif
#elif defined(IA64)
GC_EXTERN ptr_t GC_save_regs_ret_val;
#endif
#ifdef THREAD_LOCAL_ALLOC
GC_EXTERN GC_bool GC_world_stopped;
GC_INNER void GC_mark_thread_local_free_lists(void);
#endif
#if defined(MPROTECT_VDB)&&defined(GWW_VDB)
GC_INNER GC_bool GC_gww_dirty_init(void);
#endif
#if defined(CHECKSUMS)||defined(PROC_VDB)
GC_INNER GC_bool GC_page_was_ever_dirty(struct hblk*h);
#endif
#ifdef CHECKSUMS
#if defined(MPROTECT_VDB)&&!defined(DARWIN)
void GC_record_fault(struct hblk*h);
#endif
void GC_check_dirty(void);
#endif
GC_INNER void GC_default_print_heap_obj_proc(ptr_t p);
GC_INNER void GC_setpagesize(void);
GC_INNER void GC_initialize_offsets(void);
GC_INNER void GC_bl_init(void);
GC_INNER void GC_bl_init_no_interiors(void);
GC_INNER void GC_start_debugging_inner(void);
GC_INNER void*GC_store_debug_info_inner(void*p,word sz,const char*str,
int linenum);
#ifdef REDIRECT_MALLOC
#ifdef GC_LINUX_THREADS
GC_INNER GC_bool GC_text_mapping(char*nm,ptr_t*startp,ptr_t*endp);
#endif
#elif defined(USE_WINALLOC)
GC_INNER void GC_add_current_malloc_heap(void);
#endif
#ifdef MAKE_BACK_GRAPH
GC_INNER void GC_build_back_graph(void);
GC_INNER void GC_traverse_back_graph(void);
#endif
#ifdef MSWIN32
GC_INNER void GC_init_win32(void);
#endif
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
GC_INNER void*GC_roots_present(ptr_t);
#endif
#ifdef GC_WIN32_THREADS
GC_INNER void GC_get_next_stack(char*start,char*limit,char**lo,
char**hi);
#if defined(MPROTECT_VDB)&&!defined(CYGWIN32)
GC_INNER void GC_set_write_fault_handler(void);
#endif
#if defined(WRAP_MARK_SOME)&&!defined(GC_PTHREADS)
GC_INNER GC_bool GC_started_thread_while_stopped(void);
#endif
#endif
#ifdef THREADS
GC_INNER void GC_reset_finalizer_nested(void);
GC_INNER unsigned char*GC_check_finalizer_nested(void);
GC_INNER void GC_do_blocking_inner(ptr_t data,void*context);
GC_INNER void GC_push_all_stacks(void);
#ifdef USE_PROC_FOR_LIBRARIES
GC_INNER GC_bool GC_segment_is_thread_stack(ptr_t lo,ptr_t hi);
#endif
#ifdef IA64
GC_INNER ptr_t GC_greatest_stack_base_below(ptr_t bound);
#endif
#endif
#ifdef DYNAMIC_LOADING
GC_INNER GC_bool GC_register_main_static_data(void);
#ifdef DARWIN
GC_INNER void GC_init_dyld(void);
#endif
#endif
#ifdef SEARCH_FOR_DATA_START
GC_INNER void GC_init_linux_data_start(void);
void*GC_find_limit(void*,int);
#endif
#if defined(NETBSD)&&defined(__ELF__)
GC_INNER void GC_init_netbsd_elf(void);
void*GC_find_limit(void*,int);
#endif
#ifdef UNIX_LIKE
GC_INNER void GC_set_and_save_fault_handler(void (*handler)(int));
#endif
#ifdef NEED_PROC_MAPS
#if defined(DYNAMIC_LOADING)&&defined(USE_PROC_FOR_LIBRARIES)
GC_INNER char*GC_parse_map_entry(char*buf_ptr,ptr_t*start,ptr_t*end,
char**prot,unsigned int*maj_dev,
char**mapping_name);
#endif
#if defined(IA64)||defined(INCLUDE_LINUX_THREAD_DESCR)
GC_INNER GC_bool GC_enclosing_mapping(ptr_t addr,
ptr_t*startp,ptr_t*endp);
#endif
GC_INNER char*GC_get_maps(void);
#endif
#ifdef GC_ASSERTIONS
#define GC_ASSERT(expr)do { if (!(expr)){ GC_err_printf("Assertion failure:%s:%d\n",__FILE__,__LINE__);ABORT("assertion failure");} } while (0)
GC_INNER word GC_compute_large_free_bytes(void);
GC_INNER word GC_compute_root_size(void);
#else
#define GC_ASSERT(expr)
#endif
#if _MSC_VER>=1700
#define GC_STATIC_ASSERT(expr)static_assert(expr,"static assertion failed:" #expr)
#elif defined(static_assert)&&__STDC_VERSION__>=201112L
#define GC_STATIC_ASSERT(expr)static_assert(expr,#expr)
#elif defined(mips)&&!defined(__GNUC__)
#define GC_STATIC_ASSERT(expr)do { if (0){ char j[(expr)?1:-1];j[0]='\0';j[0]=j[0];} } while(0)
#else
#define GC_STATIC_ASSERT(expr)(void)sizeof(char[(expr)?1:-1])
#endif
#if GC_GNUC_PREREQ(4,0)
#define NONNULL_ARG_NOT_NULL(arg)(*(volatile void**)&(arg)!=NULL)
#else
#define NONNULL_ARG_NOT_NULL(arg)(NULL!=(arg))
#endif
#define COND_DUMP_CHECKS do { GC_ASSERT(GC_compute_large_free_bytes()==GC_large_free_bytes);GC_ASSERT(GC_compute_root_size()==GC_root_size);} while (0)
#ifndef NO_DEBUGGING
GC_EXTERN GC_bool GC_dump_regularly;
#define COND_DUMP if (EXPECT(GC_dump_regularly,FALSE)){ GC_dump_named(NULL);} else COND_DUMP_CHECKS
#else
#define COND_DUMP COND_DUMP_CHECKS
#endif
#if defined(PARALLEL_MARK)
#define GC_markers_m1 GC_parallel
GC_EXTERN GC_bool GC_parallel_mark_disabled;
GC_INNER void GC_wait_for_markers_init(void);
GC_INNER void GC_acquire_mark_lock(void);
GC_INNER void GC_release_mark_lock(void);
GC_INNER void GC_notify_all_builder(void);
GC_INNER void GC_wait_for_reclaim(void);
GC_EXTERN signed_word GC_fl_builder_count;
GC_INNER void GC_notify_all_marker(void);
GC_INNER void GC_wait_marker(void);
GC_EXTERN word GC_mark_no;
GC_INNER void GC_help_marker(word my_mark_no);
GC_INNER void GC_start_mark_threads_inner(void);
#endif
#if defined(GC_PTHREADS)&&!defined(GC_WIN32_THREADS)&&!defined(NACL)&&!defined(GC_DARWIN_THREADS)&&!defined(SIG_SUSPEND)
#if (defined(GC_LINUX_THREADS)||defined(GC_DGUX386_THREADS))&&!defined(GC_USESIGRT_SIGNALS)
#if defined(SPARC)&&!defined(SIGPWR)
#define SIG_SUSPEND SIGLOST
#else
#define SIG_SUSPEND SIGPWR
#endif
#elif defined(GC_OPENBSD_THREADS)
#ifndef GC_OPENBSD_UTHREADS
#define SIG_SUSPEND SIGXFSZ
#endif
#elif defined(_SIGRTMIN)&&!defined(CPPCHECK)
#define SIG_SUSPEND _SIGRTMIN+6
#else
#define SIG_SUSPEND SIGRTMIN+6
#endif
#endif
#if defined(GC_PTHREADS)&&!defined(GC_SEM_INIT_PSHARED)
#define GC_SEM_INIT_PSHARED 0
#endif
#if (defined(UNIX_LIKE)||(defined(NEED_FIND_LIMIT)&&defined(CYGWIN32)))&&!defined(GC_NO_SIGSETJMP)
#if defined(SUNOS5SIGS)&&!defined(FREEBSD)&&!defined(LINUX)
EXTERN_C_END
#include <sys/siginfo.h>
EXTERN_C_BEGIN
#endif
#define SETJMP(env)sigsetjmp(env,1)
#define LONGJMP(env,val)siglongjmp(env,val)
#define JMP_BUF sigjmp_buf
#else
#ifdef ECOS
#define SETJMP(env)hal_setjmp(env)
#else
#define SETJMP(env)setjmp(env)
#endif
#define LONGJMP(env,val)longjmp(env,val)
#define JMP_BUF jmp_buf
#endif
#if defined(HEURISTIC2)||defined(SEARCH_FOR_DATA_START)||((defined(SVR4)||defined(AIX)||defined(DGUX)||(defined(LINUX)&&defined(SPARC)))&&!defined(PCR))
#define NEED_FIND_LIMIT
#endif
#if defined(DATASTART_USES_BSDGETDATASTART)
EXTERN_C_END
#include <machine/trap.h>
EXTERN_C_BEGIN
#if!defined(PCR)
#define NEED_FIND_LIMIT
#endif
GC_INNER ptr_t GC_FreeBSDGetDataStart(size_t,ptr_t);
#define DATASTART_IS_FUNC
#endif
#if (defined(NETBSD)||defined(OPENBSD))&&defined(__ELF__)&&!defined(NEED_FIND_LIMIT)
#define NEED_FIND_LIMIT
#endif
#if defined(IA64)&&!defined(NEED_FIND_LIMIT)
#define NEED_FIND_LIMIT
#endif
#if defined(NEED_FIND_LIMIT)||(defined(USE_PROC_FOR_LIBRARIES)&&defined(THREADS))
GC_EXTERN JMP_BUF GC_jmp_buf;
GC_INNER void GC_setup_temporary_fault_handler(void);
GC_INNER void GC_reset_fault_handler(void);
#endif
#if defined(CANCEL_SAFE)
#if defined(GC_ASSERTIONS)&&(defined(USE_COMPILER_TLS)||(defined(LINUX)&&!defined(ARM32)&&GC_GNUC_PREREQ(3,3)||defined(HPUX)))
extern __thread unsigned char GC_cancel_disable_count;
#define NEED_CANCEL_DISABLE_COUNT
#define INCR_CANCEL_DISABLE()++GC_cancel_disable_count
#define DECR_CANCEL_DISABLE()--GC_cancel_disable_count
#define ASSERT_CANCEL_DISABLED()GC_ASSERT(GC_cancel_disable_count > 0)
#else
#define INCR_CANCEL_DISABLE()
#define DECR_CANCEL_DISABLE()
#define ASSERT_CANCEL_DISABLED()(void)0
#endif
#define DISABLE_CANCEL(state)do { pthread_setcancelstate(PTHREAD_CANCEL_DISABLE,&state);INCR_CANCEL_DISABLE();} while (0)
#define RESTORE_CANCEL(state)do { ASSERT_CANCEL_DISABLED();pthread_setcancelstate(state,NULL);DECR_CANCEL_DISABLE();} while (0)
#else
#define DISABLE_CANCEL(state)(void)0
#define RESTORE_CANCEL(state)(void)0
#define ASSERT_CANCEL_DISABLED()(void)0
#endif
EXTERN_C_END
#endif
#ifdef KEEP_BACK_PTRS
#ifndef GC_BACKPTR_H
#define GC_BACKPTR_H
#ifndef GC_H
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef enum {
GC_UNREFERENCED,
GC_NO_SPACE,
GC_REFD_FROM_ROOT,
GC_REFD_FROM_REG,
GC_REFD_FROM_HEAP,
GC_FINALIZER_REFD
} GC_ref_kind;
GC_API GC_ref_kind GC_CALL GC_get_back_ptr_info(void*,
void**,size_t*)
GC_ATTR_NONNULL(1);
GC_API void*GC_CALL GC_generate_random_heap_address(void);
GC_API void*GC_CALL GC_generate_random_valid_address(void);
GC_API void GC_CALL GC_generate_random_backtrace(void);
GC_API void GC_CALL GC_print_backtrace(void*)GC_ATTR_NONNULL(1);
#ifdef __cplusplus
}
#endif
#endif
#endif
EXTERN_C_BEGIN
#if CPP_WORDSZ==32
#define START_FLAG (word)0xfedcedcb
#define END_FLAG (word)0xbcdecdef
#else
#define START_FLAG GC_WORD_C(0xFEDCEDCBfedcedcb)
#define END_FLAG GC_WORD_C(0xBCDECDEFbcdecdef)
#endif
#if defined(KEEP_BACK_PTRS)||defined(PRINT_BLACK_LIST)||defined(MAKE_BACK_GRAPH)
#define NOT_MARKED (ptr_t)0
#define MARKED_FOR_FINALIZATION ((ptr_t)(word)2)
#define MARKED_FROM_REGISTER ((ptr_t)(word)4)
#endif
typedef struct {
#if defined(KEEP_BACK_PTRS)||defined(MAKE_BACK_GRAPH)
#if ALIGNMENT==1
#define HIDE_BACK_PTR(p)GC_HIDE_POINTER(~1&(word)(p))
#else
#define HIDE_BACK_PTR(p)GC_HIDE_POINTER(p)
#endif
#ifdef KEEP_BACK_PTRS
GC_hidden_pointer oh_back_ptr;
#endif
#ifdef MAKE_BACK_GRAPH
GC_hidden_pointer oh_bg_ptr;
#endif
#if defined(KEEP_BACK_PTRS)!=defined(MAKE_BACK_GRAPH)
word oh_dummy;
#endif
#endif
const char*oh_string;
signed_word oh_int;
#ifdef NEED_CALLINFO
struct callinfo oh_ci[NFRAMES];
#endif
#ifndef SHORT_DBG_HDRS
word oh_sz;
word oh_sf;
#endif
} oh;
#ifdef SHORT_DBG_HDRS
#define DEBUG_BYTES (sizeof (oh))
#define UNCOLLECTABLE_DEBUG_BYTES DEBUG_BYTES
#else
#define UNCOLLECTABLE_DEBUG_BYTES (sizeof (oh)+sizeof (word))
#define DEBUG_BYTES (UNCOLLECTABLE_DEBUG_BYTES - EXTRA_BYTES)
#endif
#define SIMPLE_ROUNDED_UP_WORDS(n)BYTES_TO_WORDS((n)+WORDS_TO_BYTES(1)- 1)
#if defined(SAVE_CALL_CHAIN)
struct callinfo;
GC_INNER void GC_save_callers(struct callinfo info[NFRAMES]);
GC_INNER void GC_print_callers(struct callinfo info[NFRAMES]);
#define ADD_CALL_CHAIN(base,ra)GC_save_callers(((oh*)(base))->oh_ci)
#define PRINT_CALL_CHAIN(base)GC_print_callers(((oh*)(base))->oh_ci)
#elif defined(GC_ADD_CALLER)
struct callinfo;
GC_INNER void GC_print_callers(struct callinfo info[NFRAMES]);
#define ADD_CALL_CHAIN(base,ra)((oh*)(base))->oh_ci[0].ci_pc=(ra)
#define PRINT_CALL_CHAIN(base)GC_print_callers(((oh*)(base))->oh_ci)
#else
#define ADD_CALL_CHAIN(base,ra)
#define PRINT_CALL_CHAIN(base)
#endif
#ifdef GC_ADD_CALLER
#define OPT_RA ra,
#else
#define OPT_RA
#endif
#ifdef SHORT_DBG_HDRS
#define GC_has_other_debug_info(p)1
#else
GC_INNER int GC_has_other_debug_info(ptr_t p);
#endif
#if defined(KEEP_BACK_PTRS)||defined(MAKE_BACK_GRAPH)
#if defined(SHORT_DBG_HDRS)&&!defined(CPPCHECK)
#error Non-ptr stored in object results in GC_HAS_DEBUG_INFO malfunction
#endif
#if defined(PARALLEL_MARK)&&defined(KEEP_BACK_PTRS)
#define GC_HAS_DEBUG_INFO(p)((AO_load((volatile AO_t*)(p))&1)!=0&&GC_has_other_debug_info(p)> 0)
#else
#define GC_HAS_DEBUG_INFO(p)((*(word*)(p)&1)&&GC_has_other_debug_info(p)> 0)
#endif
#else
#define GC_HAS_DEBUG_INFO(p)(GC_has_other_debug_info(p)> 0)
#endif
EXTERN_C_END
#endif
#ifdef MAKE_BACK_GRAPH
#define MAX_IN 10
#if (!defined(DBG_HDRS_ALL)||(ALIGNMENT!=CPP_WORDSZ/8))&&!defined(CPPCHECK)
#error The configuration does not support MAKE_BACK_GRAPH
#endif
#define FLAG_MANY 2
typedef struct back_edges_struct {
word n_edges;
unsigned short flags;
#define RETAIN 1
unsigned short height_gc_no;
signed_word height;
#define HEIGHT_UNKNOWN (-2)
#define HEIGHT_IN_PROGRESS (-1)
ptr_t edges[MAX_IN];
struct back_edges_struct*cont;
} back_edges;
#define MAX_BACK_EDGE_STRUCTS 100000
static back_edges*back_edge_space=0;
STATIC int GC_n_back_edge_structs=0;
static back_edges*avail_back_edges=0;
static back_edges*new_back_edges(void)
{
if (0==back_edge_space){
size_t bytes_to_get=ROUNDUP_PAGESIZE_IF_MMAP(MAX_BACK_EDGE_STRUCTS
*sizeof(back_edges));
GC_ASSERT(GC_page_size!=0);
back_edge_space=(back_edges*)GET_MEM(bytes_to_get);
if (NULL==back_edge_space)
ABORT("Insufficient memory for back edges");
GC_add_to_our_memory((ptr_t)back_edge_space,bytes_to_get);
}
if (0!=avail_back_edges){
back_edges*result=avail_back_edges;
avail_back_edges=result->cont;
result->cont=0;
return result;
}
if (GC_n_back_edge_structs>=MAX_BACK_EDGE_STRUCTS - 1){
ABORT("Needed too much space for back edges:adjust "
"MAX_BACK_EDGE_STRUCTS");
}
return back_edge_space+(GC_n_back_edge_structs++);
}
static void deallocate_back_edges(back_edges*p)
{
back_edges*last=p;
while (0!=last->cont)last=last->cont;
last->cont=avail_back_edges;
avail_back_edges=p;
}
#define INITIAL_IN_PROGRESS 10000
static ptr_t*in_progress_space=0;
static size_t in_progress_size=0;
static size_t n_in_progress=0;
static void push_in_progress(ptr_t p)
{
if (n_in_progress>=in_progress_size){
ptr_t*new_in_progress_space;
GC_ASSERT(GC_page_size!=0);
if (NULL==in_progress_space){
in_progress_size=ROUNDUP_PAGESIZE_IF_MMAP(INITIAL_IN_PROGRESS
*sizeof(ptr_t))
/sizeof(ptr_t);
new_in_progress_space=
(ptr_t*)GET_MEM(in_progress_size*sizeof(ptr_t));
} else {
in_progress_size*=2;
new_in_progress_space=(ptr_t*)
GET_MEM(in_progress_size*sizeof(ptr_t));
if (new_in_progress_space!=NULL)
BCOPY(in_progress_space,new_in_progress_space,
n_in_progress*sizeof(ptr_t));
}
GC_add_to_our_memory((ptr_t)new_in_progress_space,
in_progress_size*sizeof(ptr_t));
#ifndef GWW_VDB
GC_scratch_recycle_no_gww(in_progress_space,
n_in_progress*sizeof(ptr_t));
#elif defined(LINT2)
GC_noop1((word)in_progress_space);
#endif
in_progress_space=new_in_progress_space;
}
if (in_progress_space==0)
ABORT("MAKE_BACK_GRAPH:Out of in-progress space:"
"Huge linear data structure?");
in_progress_space[n_in_progress++]=p;
}
static GC_bool is_in_progress(ptr_t p)
{
size_t i;
for (i=0;i < n_in_progress;++i){
if (in_progress_space[i]==p)return TRUE;
}
return FALSE;
}
GC_INLINE void pop_in_progress(ptr_t p GC_ATTR_UNUSED)
{
--n_in_progress;
GC_ASSERT(in_progress_space[n_in_progress]==p);
}
#define GET_OH_BG_PTR(p)(ptr_t)GC_REVEAL_POINTER(((oh*)(p))->oh_bg_ptr)
#define SET_OH_BG_PTR(p,q)(((oh*)(p))->oh_bg_ptr=GC_HIDE_POINTER(q))
static void ensure_struct(ptr_t p)
{
ptr_t old_back_ptr=GET_OH_BG_PTR(p);
if (!((word)old_back_ptr&FLAG_MANY)){
back_edges*be=new_back_edges();
be->flags=0;
if (0==old_back_ptr){
be->n_edges=0;
} else {
be->n_edges=1;
be->edges[0]=old_back_ptr;
}
be->height=HEIGHT_UNKNOWN;
be->height_gc_no=(unsigned short)(GC_gc_no - 1);
GC_ASSERT((word)be>=(word)back_edge_space);
SET_OH_BG_PTR(p,(word)be|FLAG_MANY);
}
}
static void add_edge(ptr_t p,ptr_t q)
{
ptr_t pred=GET_OH_BG_PTR(q);
back_edges*be,*be_cont;
word i;
GC_ASSERT(p==GC_base(p)&&q==GC_base(q));
if (!GC_HAS_DEBUG_INFO(q)||!GC_HAS_DEBUG_INFO(p)){
return;
}
if (NULL==pred){
static unsigned random_number=13;
#define GOT_LUCKY_NUMBER (((++random_number)&0x7f)==0)
SET_OH_BG_PTR(q,p);
if (GOT_LUCKY_NUMBER)ensure_struct(q);
return;
}
{
back_edges*e=(back_edges*)((word)pred&~FLAG_MANY);
word n_edges;
word total;
int local=0;
if (((word)pred&FLAG_MANY)!=0){
n_edges=e->n_edges;
} else if (((word)COVERT_DATAFLOW(pred)&1)==0){
n_edges=1;
local=-1;
} else {
n_edges=0;
}
for (total=0;total < n_edges;++total){
if (local==MAX_IN){
e=e->cont;
local=0;
}
if (local>=0)
pred=e->edges[local++];
if (pred==p)
return;
}
}
ensure_struct(q);
be=(back_edges*)((word)GET_OH_BG_PTR(q)&~FLAG_MANY);
for (i=be->n_edges,be_cont=be;i > MAX_IN;i-=MAX_IN)
be_cont=be_cont->cont;
if (i==MAX_IN){
be_cont->cont=new_back_edges();
be_cont=be_cont->cont;
i=0;
}
be_cont->edges[i]=p;
be->n_edges++;
#ifdef DEBUG_PRINT_BIG_N_EDGES
if (GC_print_stats==VERBOSE&&be->n_edges==100){
GC_err_printf("The following object has big in-degree:\n");
GC_print_heap_obj(q);
}
#endif
}
typedef void (*per_object_func)(ptr_t p,size_t n_bytes,word gc_descr);
static void per_object_helper(struct hblk*h,word fn)
{
hdr*hhdr=HDR(h);
size_t sz=(size_t)hhdr->hb_sz;
word descr=hhdr->hb_descr;
per_object_func f=(per_object_func)fn;
size_t i=0;
do {
f((ptr_t)(h->hb_body+i),sz,descr);
i+=sz;
} while (i+sz<=BYTES_TO_WORDS(HBLKSIZE));
}
GC_INLINE void GC_apply_to_each_object(per_object_func f)
{
GC_apply_to_all_blocks(per_object_helper,(word)f);
}
static void reset_back_edge(ptr_t p,size_t n_bytes GC_ATTR_UNUSED,
word gc_descr GC_ATTR_UNUSED)
{
if (GC_HAS_DEBUG_INFO(p)){
ptr_t old_back_ptr=GET_OH_BG_PTR(p);
if ((word)old_back_ptr&FLAG_MANY){
back_edges*be=(back_edges*)((word)old_back_ptr&~FLAG_MANY);
if (!(be->flags&RETAIN)){
deallocate_back_edges(be);
SET_OH_BG_PTR(p,0);
} else {
GC_ASSERT(GC_is_marked(p));
be->n_edges=0;
if (0!=be->cont){
deallocate_back_edges(be->cont);
be->cont=0;
}
GC_ASSERT(GC_is_marked(p));
be->flags&=~RETAIN;
}
} else {
SET_OH_BG_PTR(p,0);
}
}
}
static void add_back_edges(ptr_t p,size_t n_bytes,word gc_descr)
{
word*currentp=(word*)(p+sizeof(oh));
if((gc_descr&GC_DS_TAGS)!=GC_DS_LENGTH){
gc_descr=n_bytes;
}
while ((word)currentp < (word)(p+gc_descr)){
word current=*currentp++;
FIXUP_POINTER(current);
if (current>=(word)GC_least_plausible_heap_addr&&
current<=(word)GC_greatest_plausible_heap_addr){
ptr_t target=(ptr_t)GC_base((void*)current);
if (0!=target){
add_edge(p,target);
}
}
}
}
GC_INNER void GC_build_back_graph(void)
{
GC_ASSERT(I_HOLD_LOCK());
GC_apply_to_each_object(add_back_edges);
}
static word backwards_height(ptr_t p)
{
word result;
ptr_t pred=GET_OH_BG_PTR(p);
back_edges*be;
if (NULL==pred)
return 1;
if (((word)pred&FLAG_MANY)==0){
if (is_in_progress(p))return 0;
push_in_progress(p);
result=backwards_height(pred)+1;
pop_in_progress(p);
return result;
}
be=(back_edges*)((word)pred&~FLAG_MANY);
if (be->height>=0&&be->height_gc_no==(unsigned short)GC_gc_no)
return be->height;
if (be->height==HEIGHT_IN_PROGRESS)return 0;
result=(be->height > 0?be->height:1);
be->height=HEIGHT_IN_PROGRESS;
{
back_edges*e=be;
word n_edges;
word total;
int local=0;
if (((word)pred&FLAG_MANY)!=0){
n_edges=e->n_edges;
} else if (((word)pred&1)==0){
n_edges=1;
local=-1;
} else {
n_edges=0;
}
for (total=0;total < n_edges;++total){
word this_height;
if (local==MAX_IN){
e=e->cont;
local=0;
}
if (local>=0)
pred=e->edges[local++];
if (GC_is_marked(pred)&&((word)GET_OH_BG_PTR(p)&FLAG_MANY)==0){
GC_COND_LOG_PRINTF("Found bogus pointer from %p to %p\n",
(void*)pred,(void*)p);
this_height=1;
} else {
this_height=backwards_height(pred);
}
if (this_height>=result)
result=this_height+1;
}
}
be->height=result;
be->height_gc_no=(unsigned short)GC_gc_no;
return result;
}
STATIC word GC_max_height=0;
STATIC ptr_t GC_deepest_obj=NULL;
static void update_max_height(ptr_t p,size_t n_bytes GC_ATTR_UNUSED,
word gc_descr GC_ATTR_UNUSED)
{
if (GC_is_marked(p)&&GC_HAS_DEBUG_INFO(p)){
word p_height=0;
ptr_t p_deepest_obj=0;
ptr_t back_ptr;
back_edges*be=0;
back_ptr=GET_OH_BG_PTR(p);
if (0!=back_ptr&&((word)back_ptr&FLAG_MANY)){
be=(back_edges*)((word)back_ptr&~FLAG_MANY);
if (be->height!=HEIGHT_UNKNOWN)p_height=be->height;
}
{
ptr_t pred=GET_OH_BG_PTR(p);
back_edges*e=(back_edges*)((word)pred&~FLAG_MANY);
word n_edges;
word total;
int local=0;
if (((word)pred&FLAG_MANY)!=0){
n_edges=e->n_edges;
} else if (pred!=NULL&&((word)pred&1)==0){
n_edges=1;
local=-1;
} else {
n_edges=0;
}
for (total=0;total < n_edges;++total){
if (local==MAX_IN){
e=e->cont;
local=0;
}
if (local>=0)
pred=e->edges[local++];
if (!GC_is_marked(pred)&&GC_HAS_DEBUG_INFO(pred)){
word this_height=backwards_height(pred);
if (this_height > p_height){
p_height=this_height;
p_deepest_obj=pred;
}
}
}
}
if (p_height > 0){
if (be==0){
ensure_struct(p);
back_ptr=GET_OH_BG_PTR(p);
be=(back_edges*)((word)back_ptr&~FLAG_MANY);
}
be->flags|=RETAIN;
be->height=p_height;
be->height_gc_no=(unsigned short)GC_gc_no;
}
if (p_height > GC_max_height){
GC_max_height=p_height;
GC_deepest_obj=p_deepest_obj;
}
}
}
STATIC word GC_max_max_height=0;
GC_INNER void GC_traverse_back_graph(void)
{
GC_ASSERT(I_HOLD_LOCK());
GC_max_height=0;
GC_apply_to_each_object(update_max_height);
if (0!=GC_deepest_obj)
GC_set_mark_bit(GC_deepest_obj);
}
void GC_print_back_graph_stats(void)
{
GC_ASSERT(I_HOLD_LOCK());
GC_printf("Maximum backwards height of reachable objects at GC %lu is %lu\n",
(unsigned long)GC_gc_no,(unsigned long)GC_max_height);
if (GC_max_height > GC_max_max_height){
ptr_t obj=GC_deepest_obj;
GC_max_max_height=GC_max_height;
UNLOCK();
GC_err_printf(
"The following unreachable object is last in a longest chain "
"of unreachable objects:\n");
GC_print_heap_obj(obj);
LOCK();
}
GC_COND_LOG_PRINTF("Needed max total of %d back-edge structs\n",
GC_n_back_edge_structs);
GC_apply_to_each_object(reset_back_edge);
GC_deepest_obj=0;
}
#endif
STATIC word*GC_old_normal_bl=NULL;
STATIC word*GC_incomplete_normal_bl=NULL;
STATIC word*GC_old_stack_bl=NULL;
STATIC word*GC_incomplete_stack_bl=NULL;
STATIC word GC_total_stack_black_listed=0;
GC_INNER word GC_black_list_spacing=MINHINCR*HBLKSIZE;
STATIC void GC_clear_bl(word*);
GC_INNER void GC_default_print_heap_obj_proc(ptr_t p)
{
ptr_t base=(ptr_t)GC_base(p);
int kind=HDR(base)->hb_obj_kind;
GC_err_printf("object at %p of appr. %lu bytes (%s)\n",
(void*)base,(unsigned long)GC_size(base),
kind==PTRFREE?"atomic":
IS_UNCOLLECTABLE(kind)?"uncollectable":"composite");
}
GC_INNER void (*GC_print_heap_obj)(ptr_t p)=GC_default_print_heap_obj_proc;
#ifdef PRINT_BLACK_LIST
STATIC void GC_print_blacklisted_ptr(word p,ptr_t source,
const char*kind_str)
{
ptr_t base=(ptr_t)GC_base(source);
if (0==base){
GC_err_printf("Black listing (%s)%p referenced from %p in %s\n",
kind_str,(void*)p,(void*)source,
NULL!=source?"root set":"register");
} else {
GC_err_printf("Black listing (%s)%p referenced from %p in"
" object at %p of appr. %lu bytes\n",
kind_str,(void*)p,(void*)source,
(void*)base,(unsigned long)GC_size(base));
}
}
#endif
GC_INNER void GC_bl_init_no_interiors(void)
{
if (GC_incomplete_normal_bl==0){
GC_old_normal_bl=(word*)GC_scratch_alloc(sizeof(page_hash_table));
GC_incomplete_normal_bl=(word*)GC_scratch_alloc(
sizeof(page_hash_table));
if (GC_old_normal_bl==0||GC_incomplete_normal_bl==0){
GC_err_printf("Insufficient memory for black list\n");
EXIT();
}
GC_clear_bl(GC_old_normal_bl);
GC_clear_bl(GC_incomplete_normal_bl);
}
}
GC_INNER void GC_bl_init(void)
{
if (!GC_all_interior_pointers){
GC_bl_init_no_interiors();
}
GC_ASSERT(NULL==GC_old_stack_bl&&NULL==GC_incomplete_stack_bl);
GC_old_stack_bl=(word*)GC_scratch_alloc(sizeof(page_hash_table));
GC_incomplete_stack_bl=(word*)GC_scratch_alloc(sizeof(page_hash_table));
if (GC_old_stack_bl==0||GC_incomplete_stack_bl==0){
GC_err_printf("Insufficient memory for black list\n");
EXIT();
}
GC_clear_bl(GC_old_stack_bl);
GC_clear_bl(GC_incomplete_stack_bl);
}
STATIC void GC_clear_bl(word*doomed)
{
BZERO(doomed,sizeof(page_hash_table));
}
STATIC void GC_copy_bl(word*old,word*dest)
{
BCOPY(old,dest,sizeof(page_hash_table));
}
static word total_stack_black_listed(void);
GC_INNER void GC_promote_black_lists(void)
{
word*very_old_normal_bl=GC_old_normal_bl;
word*very_old_stack_bl=GC_old_stack_bl;
GC_old_normal_bl=GC_incomplete_normal_bl;
GC_old_stack_bl=GC_incomplete_stack_bl;
if (!GC_all_interior_pointers){
GC_clear_bl(very_old_normal_bl);
}
GC_clear_bl(very_old_stack_bl);
GC_incomplete_normal_bl=very_old_normal_bl;
GC_incomplete_stack_bl=very_old_stack_bl;
GC_total_stack_black_listed=total_stack_black_listed();
GC_VERBOSE_LOG_PRINTF(
"%lu bytes in heap blacklisted for interior pointers\n",
(unsigned long)GC_total_stack_black_listed);
if (GC_total_stack_black_listed!=0){
GC_black_list_spacing=
HBLKSIZE*(GC_heapsize/GC_total_stack_black_listed);
}
if (GC_black_list_spacing < 3*HBLKSIZE){
GC_black_list_spacing=3*HBLKSIZE;
}
if (GC_black_list_spacing > MAXHINCR*HBLKSIZE){
GC_black_list_spacing=MAXHINCR*HBLKSIZE;
}
}
GC_INNER void GC_unpromote_black_lists(void)
{
if (!GC_all_interior_pointers){
GC_copy_bl(GC_old_normal_bl,GC_incomplete_normal_bl);
}
GC_copy_bl(GC_old_stack_bl,GC_incomplete_stack_bl);
}
#if defined(PARALLEL_MARK)&&defined(THREAD_SANITIZER)
#define backlist_set_pht_entry_from_index(db,index)set_pht_entry_from_index_concurrent(db,index)
#else
#define backlist_set_pht_entry_from_index(bl,index)set_pht_entry_from_index(bl,index)
#endif
#ifdef PRINT_BLACK_LIST
GC_INNER void GC_add_to_black_list_normal(word p,ptr_t source)
#else
GC_INNER void GC_add_to_black_list_normal(word p)
#endif
{
if (GC_modws_valid_offsets[p&(sizeof(word)-1)]){
word index=PHT_HASH((word)p);
if (HDR(p)==0||get_pht_entry_from_index(GC_old_normal_bl,index)){
#ifdef PRINT_BLACK_LIST
if (!get_pht_entry_from_index(GC_incomplete_normal_bl,index)){
GC_print_blacklisted_ptr(p,source,"normal");
}
#endif
backlist_set_pht_entry_from_index(GC_incomplete_normal_bl,index);
}
}
}
#ifdef PRINT_BLACK_LIST
GC_INNER void GC_add_to_black_list_stack(word p,ptr_t source)
#else
GC_INNER void GC_add_to_black_list_stack(word p)
#endif
{
word index=PHT_HASH((word)p);
if (HDR(p)==0||get_pht_entry_from_index(GC_old_stack_bl,index)){
#ifdef PRINT_BLACK_LIST
if (!get_pht_entry_from_index(GC_incomplete_stack_bl,index)){
GC_print_blacklisted_ptr(p,source,"stack");
}
#endif
backlist_set_pht_entry_from_index(GC_incomplete_stack_bl,index);
}
}
struct hblk*GC_is_black_listed(struct hblk*h,word len)
{
word index=PHT_HASH((word)h);
word i;
word nblocks;
if (!GC_all_interior_pointers
&&(get_pht_entry_from_index(GC_old_normal_bl,index)
||get_pht_entry_from_index(GC_incomplete_normal_bl,index))){
return (h+1);
}
nblocks=divHBLKSZ(len);
for (i=0;;){
if (GC_old_stack_bl[divWORDSZ(index)]==0
&&GC_incomplete_stack_bl[divWORDSZ(index)]==0){
i+=WORDSZ - modWORDSZ(index);
} else {
if (get_pht_entry_from_index(GC_old_stack_bl,index)
||get_pht_entry_from_index(GC_incomplete_stack_bl,index)){
return(h+i+1);
}
i++;
}
if (i>=nblocks)break;
index=PHT_HASH((word)(h+i));
}
return(0);
}
STATIC word GC_number_stack_black_listed(struct hblk*start,
struct hblk*endp1)
{
struct hblk*h;
word result=0;
for (h=start;(word)h < (word)endp1;h++){
word index=PHT_HASH((word)h);
if (get_pht_entry_from_index(GC_old_stack_bl,index))result++;
}
return(result);
}
static word total_stack_black_listed(void)
{
unsigned i;
word total=0;
for (i=0;i < GC_n_heap_sects;i++){
struct hblk*start=(struct hblk*)GC_heap_sects[i].hs_start;
struct hblk*endp1=start+divHBLKSZ(GC_heap_sects[i].hs_bytes);
total+=GC_number_stack_black_listed(start,endp1);
}
return(total*HBLKSIZE);
}
#ifdef CHECKSUMS
#define NSUMS 10000
#define OFFSET 0x10000
typedef struct {
GC_bool new_valid;
word old_sum;
word new_sum;
struct hblk*block;
} page_entry;
page_entry GC_sums[NSUMS];
STATIC word GC_faulted[NSUMS]={ 0 };
STATIC size_t GC_n_faulted=0;
#if defined(MPROTECT_VDB)&&!defined(DARWIN)
void GC_record_fault(struct hblk*h)
{
word page=(word)h&~(GC_page_size - 1);
GC_ASSERT(GC_page_size!=0);
if (GC_n_faulted>=NSUMS)ABORT("write fault log overflowed");
GC_faulted[GC_n_faulted++]=page;
}
#endif
STATIC GC_bool GC_was_faulted(struct hblk*h)
{
size_t i;
word page=(word)h&~(GC_page_size - 1);
for (i=0;i < GC_n_faulted;++i){
if (GC_faulted[i]==page)return TRUE;
}
return FALSE;
}
STATIC word GC_checksum(struct hblk*h)
{
word*p=(word*)h;
word*lim=(word*)(h+1);
word result=0;
while ((word)p < (word)lim){
result+=*p++;
}
return(result|0x80000000);
}
int GC_n_dirty_errors=0;
int GC_n_faulted_dirty_errors=0;
unsigned long GC_n_clean=0;
unsigned long GC_n_dirty=0;
STATIC void GC_update_check_page(struct hblk*h,int index)
{
page_entry*pe=GC_sums+index;
hdr*hhdr=HDR(h);
struct hblk*b;
if (pe->block!=0&&pe->block!=h+OFFSET)ABORT("goofed");
pe->old_sum=pe->new_sum;
pe->new_sum=GC_checksum(h);
#if!defined(MSWIN32)&&!defined(MSWINCE)
if (pe->new_sum!=0x80000000&&!GC_page_was_ever_dirty(h)){
GC_err_printf("GC_page_was_ever_dirty(%p)is wrong\n",(void*)h);
}
#endif
if (GC_page_was_dirty(h)){
GC_n_dirty++;
} else {
GC_n_clean++;
}
b=h;
while (IS_FORWARDING_ADDR_OR_NIL(hhdr)&&hhdr!=0){
b-=(word)hhdr;
hhdr=HDR(b);
}
if (pe->new_valid
&&hhdr!=0&&hhdr->hb_descr!=0
&&pe->old_sum!=pe->new_sum){
if (!GC_page_was_dirty(h)||!GC_page_was_ever_dirty(h)){
GC_bool was_faulted=GC_was_faulted(h);
GC_n_dirty_errors++;
if (was_faulted)GC_n_faulted_dirty_errors++;
}
}
pe->new_valid=TRUE;
pe->block=h+OFFSET;
}
word GC_bytes_in_used_blocks=0;
STATIC void GC_add_block(struct hblk*h,word dummy GC_ATTR_UNUSED)
{
hdr*hhdr=HDR(h);
GC_bytes_in_used_blocks+=(hhdr->hb_sz+HBLKSIZE-1)&~(HBLKSIZE-1);
}
STATIC void GC_check_blocks(void)
{
word bytes_in_free_blocks=GC_large_free_bytes;
GC_bytes_in_used_blocks=0;
GC_apply_to_all_blocks(GC_add_block,(word)0);
GC_COND_LOG_PRINTF("GC_bytes_in_used_blocks=%lu,"
" bytes_in_free_blocks=%lu,heapsize=%lu\n",
(unsigned long)GC_bytes_in_used_blocks,
(unsigned long)bytes_in_free_blocks,
(unsigned long)GC_heapsize);
if (GC_bytes_in_used_blocks+bytes_in_free_blocks!=GC_heapsize){
GC_err_printf("LOST SOME BLOCKS!!\n");
}
}
void GC_check_dirty(void)
{
int index;
unsigned i;
struct hblk*h;
ptr_t start;
GC_check_blocks();
GC_n_dirty_errors=0;
GC_n_faulted_dirty_errors=0;
GC_n_clean=0;
GC_n_dirty=0;
index=0;
for (i=0;i < GC_n_heap_sects;i++){
start=GC_heap_sects[i].hs_start;
for (h=(struct hblk*)start;
(word)h < (word)(start+GC_heap_sects[i].hs_bytes);h++){
GC_update_check_page(h,index);
index++;
if (index>=NSUMS)goto out;
}
}
out:
GC_COND_LOG_PRINTF("Checked %lu clean and %lu dirty pages\n",
GC_n_clean,GC_n_dirty);
if (GC_n_dirty_errors > 0){
GC_err_printf("Found %d dirty bit errors (%d were faulted)\n",
GC_n_dirty_errors,GC_n_faulted_dirty_errors);
}
for (i=0;i < GC_n_faulted;++i){
GC_faulted[i]=0;
}
GC_n_faulted=0;
}
#endif
#ifndef GC_PMARK_H
#define GC_PMARK_H
#if defined(HAVE_CONFIG_H)&&!defined(GC_PRIVATE_H)
#endif
#ifndef GC_BUILD
#define GC_BUILD
#endif
#if (defined(__linux__)||defined(__GLIBC__)||defined(__GNU__))&&!defined(_GNU_SOURCE)&&defined(GC_PTHREADS)&&!defined(GC_NO_PTHREAD_SIGMASK)
#define _GNU_SOURCE 1
#endif
#if defined(KEEP_BACK_PTRS)||defined(PRINT_BLACK_LIST)
#endif
EXTERN_C_BEGIN
#ifndef MARK_DESCR_OFFSET
#define MARK_DESCR_OFFSET sizeof(word)
#endif
#define BITMAP_BITS (WORDSZ - GC_DS_TAG_BITS)
#define PROC(descr)(GC_mark_procs[((descr)>>GC_DS_TAG_BITS)&(GC_MAX_MARK_PROCS-1)])
#define ENV(descr)((descr)>>(GC_DS_TAG_BITS+GC_LOG_MAX_MARK_PROCS))
#define MAX_ENV (((word)1<<(WORDSZ - GC_DS_TAG_BITS - GC_LOG_MAX_MARK_PROCS))- 1)
GC_EXTERN unsigned GC_n_mark_procs;
#define GC_MARK_STACK_DISCARDS (INITIAL_MARK_STACK_SIZE/8)
#ifdef PARALLEL_MARK
#endif
GC_INNER mse*GC_signal_mark_stack_overflow(mse*msp);
GC_INLINE mse*GC_push_obj(ptr_t obj,hdr*hhdr,mse*mark_stack_top,
mse*mark_stack_limit)
{
word descr=hhdr->hb_descr;
GC_ASSERT(!HBLK_IS_FREE(hhdr));
if (descr!=0){
mark_stack_top++;
if ((word)mark_stack_top>=(word)mark_stack_limit){
mark_stack_top=GC_signal_mark_stack_overflow(mark_stack_top);
}
mark_stack_top->mse_start=obj;
mark_stack_top->mse_descr.w=descr;
}
return mark_stack_top;
}
#define PUSH_CONTENTS(current,mark_stack_top,mark_stack_limit,source)do { hdr*my_hhdr;HC_GET_HDR(current,my_hhdr,source);mark_stack_top=GC_push_contents_hdr(current,mark_stack_top,mark_stack_limit,source,my_hhdr,TRUE);} while (0)
#ifdef USE_MARK_BYTES
#if defined(PARALLEL_MARK)&&defined(AO_HAVE_char_store)&&!defined(BASE_ATOMIC_OPS_EMULATED)
#define SET_MARK_BIT_EXIT_IF_SET(hhdr,bit_no){ volatile unsigned char*mark_byte_addr=(unsigned char*)(hhdr)->hb_marks+(bit_no);if (AO_char_load(mark_byte_addr)!=0)break;AO_char_store(mark_byte_addr,1);}
#else
#define SET_MARK_BIT_EXIT_IF_SET(hhdr,bit_no){ char*mark_byte_addr=(char*)(hhdr)->hb_marks+(bit_no);if (*mark_byte_addr!=0)break;*mark_byte_addr=1;}
#endif
#else
#ifdef PARALLEL_MARK
#ifdef THREAD_SANITIZER
#define OR_WORD_EXIT_IF_SET(addr,bits){ if (!((word)AO_load((volatile AO_t*)(addr))&(bits))){ AO_or((volatile AO_t*)(addr),(AO_t)(bits));} else { break;} }
#else
#define OR_WORD_EXIT_IF_SET(addr,bits){ if (!(*(addr)&(bits))){ AO_or((volatile AO_t*)(addr),(AO_t)(bits));} else { break;} }
#endif
#else
#define OR_WORD_EXIT_IF_SET(addr,bits){ word old=*(addr);word my_bits=(bits);if ((old&my_bits)!=0)break;*(addr)=old|my_bits;}
#endif
#define SET_MARK_BIT_EXIT_IF_SET(hhdr,bit_no){ word*mark_word_addr=(hhdr)->hb_marks+divWORDSZ(bit_no);OR_WORD_EXIT_IF_SET(mark_word_addr,(word)1<<modWORDSZ(bit_no));}
#endif
#ifdef PARALLEL_MARK
#define INCR_MARKS(hhdr)AO_store(&hhdr->hb_n_marks,AO_load(&hhdr->hb_n_marks)+1)
#else
#define INCR_MARKS(hhdr)(void)(++hhdr->hb_n_marks)
#endif
#ifdef ENABLE_TRACE
#define TRACE(source,cmd)if (GC_trace_addr!=0&&(ptr_t)(source)==GC_trace_addr)cmd
#define TRACE_TARGET(target,cmd)if (GC_trace_addr!=0&&(target)==*(ptr_t*)GC_trace_addr)cmd
#else
#define TRACE(source,cmd)
#define TRACE_TARGET(source,cmd)
#endif
#if defined(I386)&&defined(__GNUC__)&&!defined(NACL)
#define LONG_MULT(hprod,lprod,x,y)do { __asm__ __volatile__("mull %2":"=a"(lprod),"=d"(hprod):"g"(y),"0"(x));} while (0)
#else
#if defined(__int64)&&!defined(__GNUC__)&&!defined(CPPCHECK)
#define ULONG_MULT_T unsigned __int64
#else
#define ULONG_MULT_T unsigned long long
#endif
#define LONG_MULT(hprod,lprod,x,y)do { ULONG_MULT_T prod=(ULONG_MULT_T)(x)*(ULONG_MULT_T)(y);GC_STATIC_ASSERT(sizeof(x)+sizeof(y)<=sizeof(prod));hprod=prod>>32;lprod=(unsigned32)prod;} while (0)
#endif
GC_INLINE mse*GC_push_contents_hdr(ptr_t current,mse*mark_stack_top,
mse*mark_stack_limit,ptr_t source,
hdr*hhdr,GC_bool do_offset_check)
{
do {
size_t displ=HBLKDISPL(current);
ptr_t base=current;
#ifdef MARK_BIT_PER_GRANULE
size_t gran_displ=BYTES_TO_GRANULES(displ);
size_t gran_offset=hhdr->hb_map[gran_displ];
size_t byte_offset=displ&(GRANULE_BYTES - 1);
if (EXPECT((gran_offset|byte_offset)!=0,FALSE))
#else
unsigned32 gran_displ;
unsigned32 inv_sz=hhdr->hb_inv_sz;
#endif
{
#ifdef MARK_BIT_PER_GRANULE
if ((hhdr->hb_flags&LARGE_BLOCK)!=0)
#else
if (EXPECT(inv_sz==LARGE_INV_SZ,FALSE))
#endif
{
size_t obj_displ;
base=(ptr_t)hhdr->hb_block;
obj_displ=current - base;
if (obj_displ!=displ){
GC_ASSERT(obj_displ < hhdr->hb_sz);
} else if (do_offset_check&&!GC_valid_offsets[obj_displ]){
GC_ADD_TO_BLACK_LIST_NORMAL(current,source);
break;
}
GC_ASSERT(hhdr->hb_sz > HBLKSIZE
||hhdr->hb_block==HBLKPTR(current));
GC_ASSERT((word)hhdr->hb_block<=(word)current);
gran_displ=0;
} else {
#ifdef MARK_BIT_PER_GRANULE
size_t obj_displ=GRANULES_TO_BYTES(gran_offset)+byte_offset;
#else
unsigned32 low_prod;
LONG_MULT(gran_displ,low_prod,(unsigned32)displ,inv_sz);
if ((low_prod>>16)!=0)
#endif
{
#if defined(MARK_BIT_PER_OBJ)&&!defined(MARK_BIT_PER_GRANULE)
size_t obj_displ;
GC_STATIC_ASSERT(HBLKSIZE<=(1<<15));
obj_displ=(((low_prod>>16)+1)*(size_t)hhdr->hb_sz)>>16;
#endif
if (do_offset_check&&!GC_valid_offsets[obj_displ]){
GC_ADD_TO_BLACK_LIST_NORMAL(current,source);
break;
}
#ifdef MARK_BIT_PER_GRANULE
gran_displ-=gran_offset;
#endif
base-=obj_displ;
}
}
}
#ifdef MARK_BIT_PER_GRANULE
GC_ASSERT(hhdr==GC_find_header(base));
GC_ASSERT(gran_displ % BYTES_TO_GRANULES(hhdr->hb_sz)==0);
#else
GC_ASSERT(gran_displ<=HBLK_OBJS(hhdr->hb_sz));
#endif
TRACE(source,GC_log_printf("GC #%u:passed validity tests\n",
(unsigned)GC_gc_no));
SET_MARK_BIT_EXIT_IF_SET(hhdr,gran_displ);
TRACE(source,GC_log_printf("GC #%u:previously unmarked\n",
(unsigned)GC_gc_no));
TRACE_TARGET(base,GC_log_printf("GC #%u:marking %p from %p instead\n",
(unsigned)GC_gc_no,(void*)base,
(void*)source));
INCR_MARKS(hhdr);
GC_STORE_BACK_PTR(source,base);
mark_stack_top=GC_push_obj(base,hhdr,mark_stack_top,
mark_stack_limit);
} while (0);
return mark_stack_top;
}
#if defined(PRINT_BLACK_LIST)||defined(KEEP_BACK_PTRS)
#define PUSH_ONE_CHECKED_STACK(p,source)GC_mark_and_push_stack((ptr_t)(p),(ptr_t)(source))
#else
#define PUSH_ONE_CHECKED_STACK(p,source)GC_mark_and_push_stack((ptr_t)(p))
#endif
#ifdef NEED_FIXUP_POINTER
#define GC_PUSH_ONE_STACK(p,source)do { if ((word)(p)>=(word)GC_least_plausible_heap_addr&&(word)(p)< (word)GC_greatest_plausible_heap_addr){ PUSH_ONE_CHECKED_STACK(p,source);} FIXUP_POINTER(p);if ((word)(p)>=(word)GC_least_plausible_heap_addr&&(word)(p)< (word)GC_greatest_plausible_heap_addr){ PUSH_ONE_CHECKED_STACK(p,source);} } while (0)
#else
#define GC_PUSH_ONE_STACK(p,source)do { if ((word)(p)>=(word)GC_least_plausible_heap_addr&&(word)(p)< (word)GC_greatest_plausible_heap_addr){ PUSH_ONE_CHECKED_STACK(p,source);} } while (0)
#endif
#define GC_PUSH_ONE_HEAP(p,source,mark_stack_top)do { FIXUP_POINTER(p);if ((word)(p)>=(word)GC_least_plausible_heap_addr&&(word)(p)< (word)GC_greatest_plausible_heap_addr)mark_stack_top=GC_mark_and_push((void*)(p),mark_stack_top,GC_mark_stack_limit,(void**)(source));} while (0)
GC_INNER mse*GC_mark_from(mse*top,mse*bottom,mse*limit);
#define MARK_FROM_MARK_STACK()GC_mark_stack_top=GC_mark_from(GC_mark_stack_top,GC_mark_stack,GC_mark_stack+GC_mark_stack_size);
#define GC_mark_stack_empty()((word)GC_mark_stack_top < (word)GC_mark_stack)
#define GC_MARK_FO(real_ptr,mark_proc)do { (*(mark_proc))(real_ptr);while (!GC_mark_stack_empty())MARK_FROM_MARK_STACK();if (GC_mark_state!=MS_NONE){ GC_set_mark_bit(real_ptr);while (!GC_mark_some((ptr_t)0)){ } } } while (0)
#define MS_NONE 0
#define MS_PUSH_RESCUERS 1
#define MS_PUSH_UNCOLLECTABLE 2
#define MS_ROOTS_PUSHED 3
#define MS_PARTIALLY_INVALID 4
#define MS_INVALID 5
EXTERN_C_END
#endif
#ifdef GC_GCJ_SUPPORT
#ifndef GC_GCJ_H
#define GC_GCJ_H
#ifndef GC_H
#endif
#ifdef __cplusplus
extern "C" {
#endif
GC_API void GC_CALL GC_init_gcj_malloc(int,
void*);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_gcj_malloc(size_t,
void*);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_debug_gcj_malloc(size_t,
void*,
GC_EXTRA_PARAMS);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_gcj_malloc_ignore_off_page(size_t,
void*);
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
}
#endif
#endif
int GC_gcj_kind=0;
int GC_gcj_debug_kind=0;
STATIC struct GC_ms_entry*GC_gcj_fake_mark_proc(word*addr GC_ATTR_UNUSED,
struct GC_ms_entry*mark_stack_ptr,
struct GC_ms_entry*mark_stack_limit GC_ATTR_UNUSED,
word env GC_ATTR_UNUSED)
{
ABORT_RET("No client gcj mark proc is specified");
return mark_stack_ptr;
}
GC_API void GC_CALL GC_init_gcj_malloc(int mp_index,
void*mp)
{
#ifndef GC_IGNORE_GCJ_INFO
GC_bool ignore_gcj_info;
#endif
DCL_LOCK_STATE;
if (mp==0)
mp=(void*)(word)GC_gcj_fake_mark_proc;
GC_init();
LOCK();
if (GC_gcjobjfreelist!=NULL){
UNLOCK();
return;
}
#ifdef GC_IGNORE_GCJ_INFO
#define ignore_gcj_info TRUE
#else
ignore_gcj_info=(0!=GETENV("GC_IGNORE_GCJ_INFO"));
#endif
if (ignore_gcj_info){
GC_COND_LOG_PRINTF("Gcj-style type information is disabled!\n");
}
GC_ASSERT(GC_mark_procs[mp_index]==(GC_mark_proc)0);
GC_mark_procs[mp_index]=(GC_mark_proc)(word)mp;
if ((unsigned)mp_index>=GC_n_mark_procs)
ABORT("GC_init_gcj_malloc:bad index");
GC_gcjobjfreelist=(ptr_t*)GC_new_free_list_inner();
if (ignore_gcj_info){
GC_gcj_kind=GC_new_kind_inner((void**)GC_gcjobjfreelist,
GC_DS_LENGTH,
TRUE,TRUE);
GC_gcj_debug_kind=GC_gcj_kind;
} else {
GC_gcj_kind=GC_new_kind_inner(
(void**)GC_gcjobjfreelist,
(((word)(-(signed_word)MARK_DESCR_OFFSET
- GC_INDIR_PER_OBJ_BIAS))
|GC_DS_PER_OBJECT),
FALSE,TRUE);
GC_gcj_debug_kind=GC_new_kind_inner(GC_new_free_list_inner(),
GC_MAKE_PROC(mp_index,
1),
FALSE,TRUE);
}
UNLOCK();
#undef ignore_gcj_info
}
#define GENERAL_MALLOC_INNER(lb,k)GC_clear_stack(GC_generic_malloc_inner(lb,k))
#define GENERAL_MALLOC_INNER_IOP(lb,k)GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb,k))
static void maybe_finalize(void)
{
static word last_finalized_no=0;
DCL_LOCK_STATE;
if (GC_gc_no==last_finalized_no||
!EXPECT(GC_is_initialized,TRUE))return;
UNLOCK();
GC_INVOKE_FINALIZERS();
LOCK();
last_finalized_no=GC_gc_no;
}
#ifdef THREAD_LOCAL_ALLOC
GC_INNER void*GC_core_gcj_malloc(size_t lb,
void*ptr_to_struct_containing_descr)
#else
GC_API GC_ATTR_MALLOC void*GC_CALL GC_gcj_malloc(size_t lb,
void*ptr_to_struct_containing_descr)
#endif
{
ptr_t op;
DCL_LOCK_STATE;
GC_DBG_COLLECT_AT_MALLOC(lb);
if(SMALL_OBJ(lb)){
word lg;
LOCK();
lg=GC_size_map[lb];
op=GC_gcjobjfreelist[lg];
if(EXPECT(0==op,FALSE)){
maybe_finalize();
op=(ptr_t)GENERAL_MALLOC_INNER((word)lb,GC_gcj_kind);
if (0==op){
GC_oom_func oom_fn=GC_oom_fn;
UNLOCK();
return((*oom_fn)(lb));
}
} else {
GC_gcjobjfreelist[lg]=(ptr_t)obj_link(op);
GC_bytes_allocd+=GRANULES_TO_BYTES((word)lg);
}
GC_ASSERT(((void**)op)[1]==0);
} else {
LOCK();
maybe_finalize();
op=(ptr_t)GENERAL_MALLOC_INNER((word)lb,GC_gcj_kind);
if (0==op){
GC_oom_func oom_fn=GC_oom_fn;
UNLOCK();
return((*oom_fn)(lb));
}
}
*(void**)op=ptr_to_struct_containing_descr;
UNLOCK();
GC_dirty(op);
REACHABLE_AFTER_DIRTY(ptr_to_struct_containing_descr);
return (void*)op;
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_debug_gcj_malloc(size_t lb,
void*ptr_to_struct_containing_descr,GC_EXTRA_PARAMS)
{
void*result;
DCL_LOCK_STATE;
LOCK();
maybe_finalize();
result=GC_generic_malloc_inner(SIZET_SAT_ADD(lb,DEBUG_BYTES),
GC_gcj_debug_kind);
if (result==0){
GC_oom_func oom_fn=GC_oom_fn;
UNLOCK();
GC_err_printf("GC_debug_gcj_malloc(%lu,%p)returning NULL (%s:%d)\n",
(unsigned long)lb,ptr_to_struct_containing_descr,s,i);
return((*oom_fn)(lb));
}
*((void**)((ptr_t)result+sizeof(oh)))=ptr_to_struct_containing_descr;
if (!GC_debugging_started){
GC_start_debugging_inner();
}
ADD_CALL_CHAIN(result,ra);
result=GC_store_debug_info_inner(result,(word)lb,s,i);
UNLOCK();
GC_dirty(result);
REACHABLE_AFTER_DIRTY(ptr_to_struct_containing_descr);
return result;
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_gcj_malloc_ignore_off_page(size_t lb,
void*ptr_to_struct_containing_descr)
{
ptr_t op;
DCL_LOCK_STATE;
GC_DBG_COLLECT_AT_MALLOC(lb);
if(SMALL_OBJ(lb)){
word lg;
LOCK();
lg=GC_size_map[lb];
op=GC_gcjobjfreelist[lg];
if (EXPECT(0==op,FALSE)){
maybe_finalize();
op=(ptr_t)GENERAL_MALLOC_INNER_IOP(lb,GC_gcj_kind);
if (0==op){
GC_oom_func oom_fn=GC_oom_fn;
UNLOCK();
return((*oom_fn)(lb));
}
} else {
GC_gcjobjfreelist[lg]=(ptr_t)obj_link(op);
GC_bytes_allocd+=GRANULES_TO_BYTES((word)lg);
}
} else {
LOCK();
maybe_finalize();
op=(ptr_t)GENERAL_MALLOC_INNER_IOP(lb,GC_gcj_kind);
if (0==op){
GC_oom_func oom_fn=GC_oom_fn;
UNLOCK();
return((*oom_fn)(lb));
}
}
*(void**)op=ptr_to_struct_containing_descr;
UNLOCK();
GC_dirty(op);
REACHABLE_AFTER_DIRTY(ptr_to_struct_containing_descr);
return (void*)op;
}
#endif
GC_INNER hdr*GC_find_header(ptr_t h)
{
#ifdef HASH_TL
hdr*result;
GET_HDR(h,result);
return(result);
#else
return(HDR_INNER(h));
#endif
}
GC_INNER hdr*
#ifdef PRINT_BLACK_LIST
GC_header_cache_miss(ptr_t p,hdr_cache_entry*hce,ptr_t source)
#else
GC_header_cache_miss(ptr_t p,hdr_cache_entry*hce)
#endif
{
hdr*hhdr;
HC_MISS();
GET_HDR(p,hhdr);
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)){
if (GC_all_interior_pointers){
if (hhdr!=0){
ptr_t current=p;
current=(ptr_t)HBLKPTR(current);
do {
current=current - HBLKSIZE*(word)hhdr;
hhdr=HDR(current);
} while(IS_FORWARDING_ADDR_OR_NIL(hhdr));
if (hhdr->hb_flags&IGNORE_OFF_PAGE)
return 0;
if (HBLK_IS_FREE(hhdr)
||p - current>=(ptrdiff_t)(hhdr->hb_sz)){
GC_ADD_TO_BLACK_LIST_NORMAL(p,source);
return 0;
}
} else {
GC_ADD_TO_BLACK_LIST_NORMAL(p,source);
}
GC_ASSERT(hhdr==0||!HBLK_IS_FREE(hhdr));
return hhdr;
} else {
if (hhdr==0){
GC_ADD_TO_BLACK_LIST_NORMAL(p,source);
}
return 0;
}
} else {
if (HBLK_IS_FREE(hhdr)){
GC_ADD_TO_BLACK_LIST_NORMAL(p,source);
return 0;
} else {
hce->block_addr=(word)(p)>>LOG_HBLKSIZE;
hce->hce_hdr=hhdr;
return hhdr;
}
}
}
GC_INNER ptr_t GC_scratch_alloc(size_t bytes)
{
ptr_t result=GC_scratch_free_ptr;
size_t bytes_to_get;
bytes=ROUNDUP_GRANULE_SIZE(bytes);
for (;;){
GC_scratch_free_ptr+=bytes;
if ((word)GC_scratch_free_ptr<=(word)GC_scratch_end_ptr){
return result;
}
GC_ASSERT(GC_page_size!=0);
if (bytes>=MINHINCR*HBLKSIZE){
bytes_to_get=ROUNDUP_PAGESIZE_IF_MMAP(bytes);
result=(ptr_t)GET_MEM(bytes_to_get);
GC_add_to_our_memory(result,bytes_to_get);
GC_scratch_free_ptr-=bytes;
if (result!=NULL){
GC_scratch_last_end_ptr=result+bytes;
}
return result;
}
bytes_to_get=ROUNDUP_PAGESIZE_IF_MMAP(MINHINCR*HBLKSIZE);
result=(ptr_t)GET_MEM(bytes_to_get);
GC_add_to_our_memory(result,bytes_to_get);
if (NULL==result){
WARN("Out of memory - trying to allocate requested amount"
" (%" WARN_PRIdPTR " bytes)...\n",(word)bytes);
GC_scratch_free_ptr-=bytes;
bytes_to_get=ROUNDUP_PAGESIZE_IF_MMAP(bytes);
result=(ptr_t)GET_MEM(bytes_to_get);
GC_add_to_our_memory(result,bytes_to_get);
return result;
}
GC_scratch_free_ptr=result;
GC_scratch_end_ptr=GC_scratch_free_ptr+bytes_to_get;
GC_scratch_last_end_ptr=GC_scratch_end_ptr;
}
}
static hdr*alloc_hdr(void)
{
hdr*result;
if (NULL==GC_hdr_free_list){
result=(hdr*)GC_scratch_alloc(sizeof(hdr));
} else {
result=GC_hdr_free_list;
GC_hdr_free_list=(hdr*)result->hb_next;
}
return(result);
}
GC_INLINE void free_hdr(hdr*hhdr)
{
hhdr->hb_next=(struct hblk*)GC_hdr_free_list;
GC_hdr_free_list=hhdr;
}
#ifdef COUNT_HDR_CACHE_HITS
word GC_hdr_cache_hits=0;
word GC_hdr_cache_misses=0;
#endif
GC_INNER void GC_init_headers(void)
{
unsigned i;
GC_ASSERT(NULL==GC_all_nils);
GC_all_nils=(bottom_index*)GC_scratch_alloc(sizeof(bottom_index));
if (GC_all_nils==NULL){
GC_err_printf("Insufficient memory for GC_all_nils\n");
EXIT();
}
BZERO(GC_all_nils,sizeof(bottom_index));
for (i=0;i < TOP_SZ;i++){
GC_top_index[i]=GC_all_nils;
}
}
static GC_bool get_index(word addr)
{
word hi=(word)(addr)>>(LOG_BOTTOM_SZ+LOG_HBLKSIZE);
bottom_index*r;
bottom_index*p;
bottom_index**prev;
bottom_index*pi;
word i;
GC_ASSERT(I_HOLD_LOCK());
#ifdef HASH_TL
i=TL_HASH(hi);
pi=p=GC_top_index[i];
while(p!=GC_all_nils){
if (p->key==hi)return(TRUE);
p=p->hash_link;
}
#else
if (GC_top_index[hi]!=GC_all_nils)
return TRUE;
i=hi;
#endif
r=(bottom_index*)GC_scratch_alloc(sizeof(bottom_index));
if (EXPECT(NULL==r,FALSE))
return FALSE;
BZERO(r,sizeof(bottom_index));
r->key=hi;
#ifdef HASH_TL
r->hash_link=pi;
#endif
prev=&GC_all_bottom_indices;
pi=0;
while ((p=*prev)!=0&&p->key < hi){
pi=p;
prev=&(p->asc_link);
}
r->desc_link=pi;
if (0==p){
GC_all_bottom_indices_end=r;
} else {
p->desc_link=r;
}
r->asc_link=p;
*prev=r;
GC_top_index[i]=r;
return(TRUE);
}
GC_INNER struct hblkhdr*GC_install_header(struct hblk*h)
{
hdr*result;
if (!get_index((word)h))return(0);
result=alloc_hdr();
if (result){
SET_HDR(h,result);
#ifdef USE_MUNMAP
result->hb_last_reclaimed=(unsigned short)GC_gc_no;
#endif
}
return(result);
}
GC_INNER GC_bool GC_install_counts(struct hblk*h,size_t sz)
{
struct hblk*hbp;
for (hbp=h;(word)hbp < (word)h+sz;hbp+=BOTTOM_SZ){
if (!get_index((word)hbp))
return FALSE;
if ((word)hbp > GC_WORD_MAX - (word)BOTTOM_SZ*HBLKSIZE)
break;
}
if (!get_index((word)h+sz - 1))
return FALSE;
for (hbp=h+1;(word)hbp < (word)h+sz;hbp+=1){
word i=HBLK_PTR_DIFF(hbp,h);
SET_HDR(hbp,(hdr*)(i > MAX_JUMP?MAX_JUMP:i));
}
return TRUE;
}
GC_INNER void GC_remove_header(struct hblk*h)
{
hdr**ha;
GET_HDR_ADDR(h,ha);
free_hdr(*ha);
*ha=0;
}
GC_INNER void GC_remove_counts(struct hblk*h,size_t sz)
{
struct hblk*hbp;
for (hbp=h+1;(word)hbp < (word)h+sz;hbp+=1){
SET_HDR(hbp,0);
}
}
void GC_apply_to_all_blocks(void (*fn)(struct hblk*h,word client_data),
word client_data)
{
signed_word j;
bottom_index*index_p;
for (index_p=GC_all_bottom_indices;index_p!=0;
index_p=index_p->asc_link){
for (j=BOTTOM_SZ-1;j>=0;){
if (!IS_FORWARDING_ADDR_OR_NIL(index_p->index[j])){
if (!HBLK_IS_FREE(index_p->index[j])){
(*fn)(((struct hblk*)
(((index_p->key<<LOG_BOTTOM_SZ)+(word)j)
<<LOG_HBLKSIZE)),
client_data);
}
j--;
} else if (index_p->index[j]==0){
j--;
} else {
j-=(signed_word)(index_p->index[j]);
}
}
}
}
GC_INNER struct hblk*GC_next_block(struct hblk*h,GC_bool allow_free)
{
REGISTER bottom_index*bi;
REGISTER word j=((word)h>>LOG_HBLKSIZE)&(BOTTOM_SZ-1);
GC_ASSERT(I_HOLD_LOCK());
GET_BI(h,bi);
if (bi==GC_all_nils){
REGISTER word hi=(word)h>>(LOG_BOTTOM_SZ+LOG_HBLKSIZE);
bi=GC_all_bottom_indices;
while (bi!=0&&bi->key < hi)bi=bi->asc_link;
j=0;
}
while (bi!=0){
while (j < BOTTOM_SZ){
hdr*hhdr=bi->index[j];
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)){
j++;
} else {
if (allow_free||!HBLK_IS_FREE(hhdr)){
return ((struct hblk*)
(((bi->key<<LOG_BOTTOM_SZ)+j)
<<LOG_HBLKSIZE));
} else {
j+=divHBLKSZ(hhdr->hb_sz);
}
}
}
j=0;
bi=bi->asc_link;
}
return(0);
}
GC_INNER struct hblk*GC_prev_block(struct hblk*h)
{
bottom_index*bi;
signed_word j=((word)h>>LOG_HBLKSIZE)&(BOTTOM_SZ-1);
GC_ASSERT(I_HOLD_LOCK());
GET_BI(h,bi);
if (bi==GC_all_nils){
word hi=(word)h>>(LOG_BOTTOM_SZ+LOG_HBLKSIZE);
bi=GC_all_bottom_indices_end;
while (bi!=0&&bi->key > hi)bi=bi->desc_link;
j=BOTTOM_SZ - 1;
}
while(bi!=0){
while (j>=0){
hdr*hhdr=bi->index[j];
if (0==hhdr){
--j;
} else if (IS_FORWARDING_ADDR_OR_NIL(hhdr)){
j-=(signed_word)hhdr;
} else {
return((struct hblk*)
(((bi->key<<LOG_BOTTOM_SZ)+j)
<<LOG_HBLKSIZE));
}
}
j=BOTTOM_SZ - 1;
bi=bi->desc_link;
}
return(0);
}
#include <stdio.h>
#ifndef SMALL_CONFIG
STATIC ptr_t GC_build_fl_clear2(struct hblk*h,ptr_t ofl)
{
word*p=(word*)(h->hb_body);
word*lim=(word*)(h+1);
p[0]=(word)ofl;
p[1]=0;
p[2]=(word)p;
p[3]=0;
p+=4;
for (;(word)p < (word)lim;p+=4){
p[0]=(word)(p-2);
p[1]=0;
p[2]=(word)p;
p[3]=0;
};
return((ptr_t)(p-2));
}
STATIC ptr_t GC_build_fl_clear4(struct hblk*h,ptr_t ofl)
{
word*p=(word*)(h->hb_body);
word*lim=(word*)(h+1);
p[0]=(word)ofl;
p[1]=0;
p[2]=0;
p[3]=0;
p+=4;
for (;(word)p < (word)lim;p+=4){
GC_PREFETCH_FOR_WRITE((ptr_t)(p+64));
p[0]=(word)(p-4);
p[1]=0;
CLEAR_DOUBLE(p+2);
};
return((ptr_t)(p-4));
}
STATIC ptr_t GC_build_fl2(struct hblk*h,ptr_t ofl)
{
word*p=(word*)(h->hb_body);
word*lim=(word*)(h+1);
p[0]=(word)ofl;
p[2]=(word)p;
p+=4;
for (;(word)p < (word)lim;p+=4){
p[0]=(word)(p-2);
p[2]=(word)p;
};
return((ptr_t)(p-2));
}
STATIC ptr_t GC_build_fl4(struct hblk*h,ptr_t ofl)
{
word*p=(word*)(h->hb_body);
word*lim=(word*)(h+1);
p[0]=(word)ofl;
p[4]=(word)p;
p+=8;
for (;(word)p < (word)lim;p+=8){
GC_PREFETCH_FOR_WRITE((ptr_t)(p+64));
p[0]=(word)(p-4);
p[4]=(word)p;
};
return((ptr_t)(p-4));
}
#endif
GC_INNER ptr_t GC_build_fl(struct hblk*h,size_t sz,GC_bool clear,
ptr_t list)
{
word*p,*prev;
word*last_object;
GC_PREFETCH_FOR_WRITE((ptr_t)h);
GC_PREFETCH_FOR_WRITE((ptr_t)h+128);
GC_PREFETCH_FOR_WRITE((ptr_t)h+256);
GC_PREFETCH_FOR_WRITE((ptr_t)h+378);
#ifndef SMALL_CONFIG
switch (sz){
case 2:if (clear){
return GC_build_fl_clear2(h,list);
} else {
return GC_build_fl2(h,list);
}
case 4:if (clear){
return GC_build_fl_clear4(h,list);
} else {
return GC_build_fl4(h,list);
}
default:
break;
}
#endif
if (clear)BZERO(h,HBLKSIZE);
p=(word*)(h->hb_body)+sz;
prev=(word*)(h->hb_body);
last_object=(word*)((char*)h+HBLKSIZE);
last_object-=sz;
while ((word)p<=(word)last_object){
obj_link(p)=(ptr_t)prev;
prev=p;
p+=sz;
}
p-=sz;
*(ptr_t*)h=list;
return ((ptr_t)p);
}
GC_INNER void GC_new_hblk(size_t gran,int kind)
{
struct hblk*h;
GC_bool clear=GC_obj_kinds[kind].ok_init;
GC_STATIC_ASSERT((sizeof (struct hblk))==HBLKSIZE);
if (GC_debugging_started)clear=TRUE;
h=GC_allochblk(GRANULES_TO_BYTES(gran),kind,0);
if (h==0)return;
if (IS_UNCOLLECTABLE(kind))GC_set_hdr_marks(HDR(h));
GC_obj_kinds[kind].ok_freelist[gran]=
GC_build_fl(h,GRANULES_TO_WORDS(gran),clear,
(ptr_t)GC_obj_kinds[kind].ok_freelist[gran]);
}
GC_API void GC_CALL GC_register_displacement(size_t offset)
{
DCL_LOCK_STATE;
LOCK();
GC_register_displacement_inner(offset);
UNLOCK();
}
GC_INNER void GC_register_displacement_inner(size_t offset)
{
GC_ASSERT(I_HOLD_LOCK());
if (offset>=VALID_OFFSET_SZ){
ABORT("Bad argument to GC_register_displacement");
}
if (!GC_valid_offsets[offset]){
GC_valid_offsets[offset]=TRUE;
GC_modws_valid_offsets[offset % sizeof(word)]=TRUE;
}
}
#ifdef MARK_BIT_PER_GRANULE
GC_INNER GC_bool GC_add_map_entry(size_t granules)
{
unsigned displ;
unsigned short*new_map;
if (granules > BYTES_TO_GRANULES(MAXOBJBYTES))granules=0;
if (GC_obj_map[granules]!=0){
return(TRUE);
}
new_map=(unsigned short*)GC_scratch_alloc(MAP_LEN*sizeof(short));
if (new_map==0)return(FALSE);
GC_COND_LOG_PRINTF(
"Adding block map for size of %u granules (%u bytes)\n",
(unsigned)granules,(unsigned)GRANULES_TO_BYTES(granules));
if (granules==0){
for (displ=0;displ < BYTES_TO_GRANULES(HBLKSIZE);displ++){
new_map[displ]=1;
}
} else {
for (displ=0;displ < BYTES_TO_GRANULES(HBLKSIZE);displ++){
new_map[displ]=(unsigned short)(displ % granules);
}
}
GC_obj_map[granules]=new_map;
return(TRUE);
}
#endif
GC_INNER void GC_initialize_offsets(void)
{
unsigned i;
if (GC_all_interior_pointers){
for (i=0;i < VALID_OFFSET_SZ;++i)
GC_valid_offsets[i]=TRUE;
} else {
BZERO(GC_valid_offsets,sizeof(GC_valid_offsets));
for (i=0;i < sizeof(word);++i)
GC_modws_valid_offsets[i]=FALSE;
}
}
STATIC void GC_CALLBACK GC_default_same_obj_print_proc(void*p,void*q)
{
ABORT_ARG2("GC_same_obj test failed",
":%p and %p are not in the same object",p,q);
}
void (GC_CALLBACK*GC_same_obj_print_proc)(void*,void*)
=GC_default_same_obj_print_proc;
GC_API void*GC_CALL GC_same_obj(void*p,void*q)
{
struct hblk*h;
hdr*hhdr;
ptr_t base,limit;
word sz;
if (!EXPECT(GC_is_initialized,TRUE))GC_init();
hhdr=HDR((word)p);
if (hhdr==0){
if (divHBLKSZ((word)p)!=divHBLKSZ((word)q)
&&HDR((word)q)!=0){
goto fail;
}
return(p);
}
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)){
h=HBLKPTR(p)- (word)hhdr;
hhdr=HDR(h);
while (IS_FORWARDING_ADDR_OR_NIL(hhdr)){
h=FORWARDED_ADDR(h,hhdr);
hhdr=HDR(h);
}
limit=(ptr_t)h+hhdr->hb_sz;
if ((word)p>=(word)limit||(word)q>=(word)limit
||(word)q < (word)h){
goto fail;
}
return(p);
}
sz=hhdr->hb_sz;
if (sz > MAXOBJBYTES){
base=(ptr_t)HBLKPTR(p);
limit=base+sz;
if ((word)p>=(word)limit){
goto fail;
}
} else {
size_t offset;
size_t pdispl=HBLKDISPL(p);
offset=pdispl % sz;
if (HBLKPTR(p)!=HBLKPTR(q))goto fail;
base=(ptr_t)p - offset;
limit=base+sz;
}
if ((word)q>=(word)limit||(word)q < (word)base){
goto fail;
}
return(p);
fail:
(*GC_same_obj_print_proc)((ptr_t)p,(ptr_t)q);
return(p);
}
STATIC void GC_CALLBACK GC_default_is_valid_displacement_print_proc (void*p)
{
ABORT_ARG1("GC_is_valid_displacement test failed",":%p not valid",p);
}
void (GC_CALLBACK*GC_is_valid_displacement_print_proc)(void*)=
GC_default_is_valid_displacement_print_proc;
GC_API void*GC_CALL GC_is_valid_displacement(void*p)
{
hdr*hhdr;
word pdispl;
word offset;
struct hblk*h;
word sz;
if (!EXPECT(GC_is_initialized,TRUE))GC_init();
hhdr=HDR((word)p);
if (hhdr==0)return(p);
h=HBLKPTR(p);
if (GC_all_interior_pointers){
while (IS_FORWARDING_ADDR_OR_NIL(hhdr)){
h=FORWARDED_ADDR(h,hhdr);
hhdr=HDR(h);
}
} else if (IS_FORWARDING_ADDR_OR_NIL(hhdr)){
goto fail;
}
sz=hhdr->hb_sz;
pdispl=HBLKDISPL(p);
offset=pdispl % sz;
if ((sz > MAXOBJBYTES&&(word)p>=(word)h+sz)
||!GC_valid_offsets[offset]
||((word)p+(sz - offset)> (word)(h+1)
&&!IS_FORWARDING_ADDR_OR_NIL(HDR(h+1)))){
goto fail;
}
return(p);
fail:
(*GC_is_valid_displacement_print_proc)((ptr_t)p);
return(p);
}
STATIC void GC_CALLBACK GC_default_is_visible_print_proc(void*p)
{
ABORT_ARG1("GC_is_visible test failed",":%p not GC-visible",p);
}
void (GC_CALLBACK*GC_is_visible_print_proc)(void*p)=
GC_default_is_visible_print_proc;
#ifndef THREADS
STATIC GC_bool GC_on_stack(void*p)
{
#ifdef STACK_GROWS_DOWN
if ((word)p>=(word)GC_approx_sp()
&&(word)p < (word)GC_stackbottom){
return(TRUE);
}
#else
if ((word)p<=(word)GC_approx_sp()
&&(word)p > (word)GC_stackbottom){
return(TRUE);
}
#endif
return(FALSE);
}
#endif
GC_API void*GC_CALL GC_is_visible(void*p)
{
hdr*hhdr;
if ((word)p&(ALIGNMENT - 1))goto fail;
if (!EXPECT(GC_is_initialized,TRUE))GC_init();
#ifdef THREADS
hhdr=HDR((word)p);
if (hhdr!=0&&GC_base(p)==0){
goto fail;
} else {
return(p);
}
#else
if (GC_on_stack(p))return(p);
hhdr=HDR((word)p);
if (hhdr==0){
if (GC_is_static_root(p))return(p);
#if defined(DYNAMIC_LOADING)||defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)||defined(PCR)
GC_register_dynamic_libraries();
if (GC_is_static_root(p))
return(p);
#endif
goto fail;
} else {
word descr;
ptr_t base=(ptr_t)GC_base(p);
if (NULL==base)goto fail;
if (HBLKPTR(base)!=HBLKPTR(p))
hhdr=HDR(base);
descr=hhdr->hb_descr;
retry:
switch(descr&GC_DS_TAGS){
case GC_DS_LENGTH:
if ((word)p - (word)base > descr)goto fail;
break;
case GC_DS_BITMAP:
if ((word)p - (word)base>=WORDS_TO_BYTES(BITMAP_BITS)
||((word)p&(sizeof(word)- 1)))goto fail;
if (!(((word)1<<(WORDSZ - ((ptr_t)p - (ptr_t)base)- 1))
&descr))goto fail;
break;
case GC_DS_PROC:
break;
case GC_DS_PER_OBJECT:
if ((signed_word)descr>=0){
descr=*(word*)((ptr_t)base+(descr&~GC_DS_TAGS));
} else {
ptr_t type_descr=*(ptr_t*)base;
descr=*(word*)(type_descr
- (descr - (word)(GC_DS_PER_OBJECT
- GC_INDIR_PER_OBJ_BIAS)));
}
goto retry;
}
return(p);
}
#endif
fail:
(*GC_is_visible_print_proc)((ptr_t)p);
return(p);
}
GC_API void*GC_CALL GC_pre_incr (void**p,ptrdiff_t how_much)
{
void*initial=*p;
void*result=GC_same_obj((void*)((ptr_t)initial+how_much),initial);
if (!GC_all_interior_pointers){
(void)GC_is_valid_displacement(result);
}
return (*p=result);
}
GC_API void*GC_CALL GC_post_incr (void**p,ptrdiff_t how_much)
{
void*initial=*p;
void*result=GC_same_obj((void*)((ptr_t)initial+how_much),initial);
if (!GC_all_interior_pointers){
(void)GC_is_valid_displacement(result);
}
*p=result;
return(initial);
}
#ifndef GC_INLINE_H
#define GC_INLINE_H
#if GC_GNUC_PREREQ(3,0)
#define GC_EXPECT(expr,outcome)__builtin_expect(expr,outcome)
#else
#define GC_EXPECT(expr,outcome)(expr)
#endif
#ifndef GC_ASSERT
#ifdef NDEBUG
#define GC_ASSERT(expr)
#else
#include <assert.h>
#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
#define GC_I_PTRFREE 0
#define GC_I_NORMAL 1
GC_API void GC_CALL GC_generic_malloc_many(size_t,int,
void**);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_malloc_kind(size_t,int);
#ifdef GC_THREADS
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_malloc_kind_global(size_t,int);
#else
#define GC_malloc_kind_global GC_malloc_kind
#endif
#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
#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;} if ((GC_signed_word)my_entry - (GC_signed_word)(num_direct)<=0&&my_entry!=0){ GC_FAST_M_AO_STORE(my_fl,(char*)my_entry+(granules)+1);result=(default_expr);break;} else { 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)
#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)
#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){*(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,
size_t);
#ifdef __cplusplus
}
#endif
#endif
#include <stdio.h>
#ifdef GC_USE_ENTIRE_HEAP
int GC_use_entire_heap=TRUE;
#else
int GC_use_entire_heap=FALSE;
#endif
#define MAX_BLACK_LIST_ALLOC (2*HBLKSIZE)
#define UNIQUE_THRESHOLD 32
#define HUGE_THRESHOLD 256
#define FL_COMPRESSION 8
#define N_HBLK_FLS ((HUGE_THRESHOLD - UNIQUE_THRESHOLD)/FL_COMPRESSION+UNIQUE_THRESHOLD)
#ifndef GC_GCJ_SUPPORT
STATIC
#endif
struct hblk*GC_hblkfreelist[N_HBLK_FLS+1]={ 0 };
#ifndef GC_GCJ_SUPPORT
STATIC
#endif
word GC_free_bytes[N_HBLK_FLS+1]={ 0 };
GC_INLINE int GC_enough_large_bytes_left(void)
{
int n;
word bytes=GC_large_allocd_bytes;
GC_ASSERT(GC_max_large_allocd_bytes<=GC_heapsize);
for (n=N_HBLK_FLS;n>=0;--n){
bytes+=GC_free_bytes[n];
if (bytes>=GC_max_large_allocd_bytes)return n;
}
return 0;
}
STATIC int GC_hblk_fl_from_blocks(word blocks_needed)
{
if (blocks_needed<=UNIQUE_THRESHOLD)return (int)blocks_needed;
if (blocks_needed>=HUGE_THRESHOLD)return N_HBLK_FLS;
return (int)(blocks_needed - UNIQUE_THRESHOLD)/FL_COMPRESSION
+UNIQUE_THRESHOLD;
}
#define PHDR(hhdr)HDR((hhdr)->hb_prev)
#define NHDR(hhdr)HDR((hhdr)->hb_next)
#ifdef USE_MUNMAP
#define IS_MAPPED(hhdr)(((hhdr)->hb_flags&WAS_UNMAPPED)==0)
#else
#define IS_MAPPED(hhdr)TRUE
#endif
#if!defined(NO_DEBUGGING)||defined(GC_ASSERTIONS)
GC_INNER word GC_compute_large_free_bytes(void)
{
word total_free=0;
unsigned i;
for (i=0;i<=N_HBLK_FLS;++i){
struct hblk*h;
hdr*hhdr;
for (h=GC_hblkfreelist[i];h!=0;h=hhdr->hb_next){
hhdr=HDR(h);
total_free+=hhdr->hb_sz;
}
}
return total_free;
}
#endif
#if!defined(NO_DEBUGGING)
void GC_print_hblkfreelist(void)
{
unsigned i;
word total;
for (i=0;i<=N_HBLK_FLS;++i){
struct hblk*h=GC_hblkfreelist[i];
if (0!=h)GC_printf("Free list %u (total size %lu):\n",
i,(unsigned long)GC_free_bytes[i]);
while (h){
hdr*hhdr=HDR(h);
GC_printf("\t%p size %lu %s black listed\n",
(void*)h,(unsigned long)hhdr->hb_sz,
GC_is_black_listed(h,HBLKSIZE)!=0?"start":
GC_is_black_listed(h,hhdr->hb_sz)!=0?"partially":
"not");
h=hhdr->hb_next;
}
}
GC_printf("GC_large_free_bytes:%lu\n",
(unsigned long)GC_large_free_bytes);
if ((total=GC_compute_large_free_bytes())!=GC_large_free_bytes)
GC_err_printf("GC_large_free_bytes INCONSISTENT!!Should be:%lu\n",
(unsigned long)total);
}
static int free_list_index_of(hdr*wanted)
{
int i;
for (i=0;i<=N_HBLK_FLS;++i){
struct hblk*h;
hdr*hhdr;
for (h=GC_hblkfreelist[i];h!=0;h=hhdr->hb_next){
hhdr=HDR(h);
if (hhdr==wanted)return i;
}
}
return -1;
}
GC_API void GC_CALL GC_dump_regions(void)
{
unsigned i;
for (i=0;i < GC_n_heap_sects;++i){
ptr_t start=GC_heap_sects[i].hs_start;
size_t bytes=GC_heap_sects[i].hs_bytes;
ptr_t end=start+bytes;
ptr_t p;
while (i+1 < GC_n_heap_sects&&GC_heap_sects[i+1].hs_start==end){
++i;
end=GC_heap_sects[i].hs_start+GC_heap_sects[i].hs_bytes;
}
GC_printf("***Section from %p to %p\n",(void*)start,(void*)end);
for (p=start;(word)p < (word)end;){
hdr*hhdr=HDR(p);
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)){
GC_printf("\t%p Missing header!!(%p)\n",
(void*)p,(void*)hhdr);
p+=HBLKSIZE;
continue;
}
if (HBLK_IS_FREE(hhdr)){
int correct_index=GC_hblk_fl_from_blocks(
divHBLKSZ(hhdr->hb_sz));
int actual_index;
GC_printf("\t%p\tfree block of size 0x%lx bytes%s\n",
(void*)p,(unsigned long)(hhdr->hb_sz),
IS_MAPPED(hhdr)?"":" (unmapped)");
actual_index=free_list_index_of(hhdr);
if (-1==actual_index){
GC_printf("\t\tBlock not on free list %d!!\n",
correct_index);
} else if (correct_index!=actual_index){
GC_printf("\t\tBlock on list %d,should be on %d!!\n",
actual_index,correct_index);
}
p+=hhdr->hb_sz;
} else {
GC_printf("\t%p\tused for blocks of size 0x%lx bytes\n",
(void*)p,(unsigned long)(hhdr->hb_sz));
p+=HBLKSIZE*OBJ_SZ_TO_BLOCKS(hhdr->hb_sz);
}
}
}
}
#endif
static GC_bool setup_header(hdr*hhdr,struct hblk*block,size_t byte_sz,
int kind,unsigned flags)
{
word descr;
#ifdef MARK_BIT_PER_GRANULE
if (byte_sz > MAXOBJBYTES)
flags|=LARGE_BLOCK;
#endif
#ifdef ENABLE_DISCLAIM
if (GC_obj_kinds[kind].ok_disclaim_proc)
flags|=HAS_DISCLAIM;
if (GC_obj_kinds[kind].ok_mark_unconditionally)
flags|=MARK_UNCONDITIONALLY;
#endif
hhdr->hb_sz=byte_sz;
hhdr->hb_obj_kind=(unsigned char)kind;
hhdr->hb_flags=(unsigned char)flags;
hhdr->hb_block=block;
descr=GC_obj_kinds[kind].ok_descriptor;
if (GC_obj_kinds[kind].ok_relocate_descr)descr+=byte_sz;
hhdr->hb_descr=descr;
#ifdef MARK_BIT_PER_OBJ
if (byte_sz > MAXOBJBYTES){
hhdr->hb_inv_sz=LARGE_INV_SZ;
} else {
word inv_sz;
#if CPP_WORDSZ==64
inv_sz=((word)1<<32)/byte_sz;
if (((inv_sz*byte_sz)>>32)==0)++inv_sz;
#else
GC_ASSERT(byte_sz>=4);
inv_sz=((unsigned)1<<31)/byte_sz;
inv_sz*=2;
while (inv_sz*byte_sz > byte_sz)++inv_sz;
#endif
#ifdef INV_SZ_COMPUTATION_CHECK
GC_ASSERT(((1ULL<<32)+byte_sz - 1)/byte_sz==inv_sz);
#endif
hhdr->hb_inv_sz=inv_sz;
}
#endif
#ifdef MARK_BIT_PER_GRANULE
{
size_t granules=BYTES_TO_GRANULES(byte_sz);
if (EXPECT(!GC_add_map_entry(granules),FALSE)){
hhdr->hb_sz=HBLKSIZE;
hhdr->hb_descr=0;
hhdr->hb_flags|=LARGE_BLOCK;
hhdr->hb_map=0;
return FALSE;
}
hhdr->hb_map=GC_obj_map[(hhdr->hb_flags&LARGE_BLOCK)!=0?
0:granules];
}
#endif
GC_clear_hdr_marks(hhdr);
hhdr->hb_last_reclaimed=(unsigned short)GC_gc_no;
return(TRUE);
}
STATIC void GC_remove_from_fl_at(hdr*hhdr,int index)
{
GC_ASSERT(((hhdr->hb_sz)&(HBLKSIZE-1))==0);
if (hhdr->hb_prev==0){
GC_ASSERT(HDR(GC_hblkfreelist[index])==hhdr);
GC_hblkfreelist[index]=hhdr->hb_next;
} else {
hdr*phdr;
GET_HDR(hhdr->hb_prev,phdr);
phdr->hb_next=hhdr->hb_next;
}
GC_ASSERT(GC_free_bytes[index]>=hhdr->hb_sz);
GC_free_bytes[index]-=hhdr->hb_sz;
if (0!=hhdr->hb_next){
hdr*nhdr;
GC_ASSERT(!IS_FORWARDING_ADDR_OR_NIL(NHDR(hhdr)));
GET_HDR(hhdr->hb_next,nhdr);
nhdr->hb_prev=hhdr->hb_prev;
}
}
GC_INLINE void GC_remove_from_fl(hdr*hhdr)
{
GC_remove_from_fl_at(hhdr,GC_hblk_fl_from_blocks(divHBLKSZ(hhdr->hb_sz)));
}
static struct hblk*get_block_ending_at(struct hblk*h)
{
struct hblk*p=h - 1;
hdr*phdr;
GET_HDR(p,phdr);
while (0!=phdr&&IS_FORWARDING_ADDR_OR_NIL(phdr)){
p=FORWARDED_ADDR(p,phdr);
phdr=HDR(p);
}
if (0!=phdr){
return p;
}
p=GC_prev_block(h - 1);
if (p){
phdr=HDR(p);
if ((ptr_t)p+phdr->hb_sz==(ptr_t)h){
return p;
}
}
return NULL;
}
STATIC struct hblk*GC_free_block_ending_at(struct hblk*h)
{
struct hblk*p=get_block_ending_at(h);
if (p){
hdr*phdr=HDR(p);
if (HBLK_IS_FREE(phdr)){
return p;
}
}
return 0;
}
STATIC void GC_add_to_fl(struct hblk*h,hdr*hhdr)
{
int index=GC_hblk_fl_from_blocks(divHBLKSZ(hhdr->hb_sz));
struct hblk*second=GC_hblkfreelist[index];
#if defined(GC_ASSERTIONS)&&!defined(USE_MUNMAP)
struct hblk*next=(struct hblk*)((word)h+hhdr->hb_sz);
hdr*nexthdr=HDR(next);
struct hblk*prev=GC_free_block_ending_at(h);
hdr*prevhdr=HDR(prev);
GC_ASSERT(nexthdr==0||!HBLK_IS_FREE(nexthdr)
||(GC_heapsize&SIGNB)!=0);
GC_ASSERT(prev==0||!HBLK_IS_FREE(prevhdr)
||(GC_heapsize&SIGNB)!=0);
#endif
GC_ASSERT(((hhdr->hb_sz)&(HBLKSIZE-1))==0);
GC_hblkfreelist[index]=h;
GC_free_bytes[index]+=hhdr->hb_sz;
GC_ASSERT(GC_free_bytes[index]<=GC_large_free_bytes);
hhdr->hb_next=second;
hhdr->hb_prev=0;
if (second){
hdr*second_hdr;
GET_HDR(second,second_hdr);
second_hdr->hb_prev=h;
}
hhdr->hb_flags|=FREE_BLK;
}
#ifdef USE_MUNMAP
#ifndef MUNMAP_THRESHOLD
#define MUNMAP_THRESHOLD 6
#endif
GC_INNER int GC_unmap_threshold=MUNMAP_THRESHOLD;
#ifdef COUNT_UNMAPPED_REGIONS
static int calc_num_unmapped_regions_delta(struct hblk*h,hdr*hhdr)
{
struct hblk*prev=get_block_ending_at(h);
struct hblk*next;
GC_bool prev_unmapped=FALSE;
GC_bool next_unmapped=FALSE;
next=GC_next_block((struct hblk*)((ptr_t)h+hhdr->hb_sz),TRUE);
if ((ptr_t)next!=GC_unmap_end((ptr_t)h,(size_t)hhdr->hb_sz)){
next=NULL;
}
if (prev!=NULL){
hdr*prevhdr=HDR(prev);
prev_unmapped=!IS_MAPPED(prevhdr);
}
if (next!=NULL){
hdr*nexthdr=HDR(next);
next_unmapped=!IS_MAPPED(nexthdr);
}
if (prev_unmapped&&next_unmapped){
return IS_MAPPED(hhdr)?-1:1;
}
if (!prev_unmapped&&!next_unmapped){
return IS_MAPPED(hhdr)?1:-1;
}
return 0;
}
#endif
GC_INLINE void GC_adjust_num_unmapped(struct hblk*h GC_ATTR_UNUSED,
hdr*hhdr GC_ATTR_UNUSED)
{
#ifdef COUNT_UNMAPPED_REGIONS
GC_num_unmapped_regions+=calc_num_unmapped_regions_delta(h,hhdr);
#endif
}
GC_INNER void GC_unmap_old(void)
{
int i;
if (GC_unmap_threshold==0)
return;
#ifdef COUNT_UNMAPPED_REGIONS
if (GC_num_unmapped_regions>=GC_UNMAPPED_REGIONS_SOFT_LIMIT)
return;
#endif
for (i=0;i<=N_HBLK_FLS;++i){
struct hblk*h;
hdr*hhdr;
for (h=GC_hblkfreelist[i];0!=h;h=hhdr->hb_next){
hhdr=HDR(h);
if (!IS_MAPPED(hhdr))continue;
if ((unsigned short)(GC_gc_no - hhdr->hb_last_reclaimed)>
(unsigned short)GC_unmap_threshold){
#ifdef COUNT_UNMAPPED_REGIONS
int delta=calc_num_unmapped_regions_delta(h,hhdr);
signed_word regions=GC_num_unmapped_regions+delta;
if (delta>=0&&regions>=GC_UNMAPPED_REGIONS_SOFT_LIMIT){
GC_COND_LOG_PRINTF("Unmapped regions limit reached!\n");
return;
}
GC_num_unmapped_regions=regions;
#endif
GC_unmap((ptr_t)h,(size_t)hhdr->hb_sz);
hhdr->hb_flags|=WAS_UNMAPPED;
}
}
}
}
GC_INNER void GC_merge_unmapped(void)
{
int i;
for (i=0;i<=N_HBLK_FLS;++i){
struct hblk*h=GC_hblkfreelist[i];
while (h!=0){
struct hblk*next;
hdr*hhdr,*nexthdr;
word size,nextsize;
GET_HDR(h,hhdr);
size=hhdr->hb_sz;
next=(struct hblk*)((word)h+size);
GET_HDR(next,nexthdr);
if (0!=nexthdr&&HBLK_IS_FREE(nexthdr)
&&(signed_word)(size+(nextsize=nexthdr->hb_sz))> 0
){
if (IS_MAPPED(hhdr)&&!IS_MAPPED(nexthdr)){
if (size > nextsize){
GC_adjust_num_unmapped(next,nexthdr);
GC_remap((ptr_t)next,nextsize);
} else {
GC_adjust_num_unmapped(h,hhdr);
GC_unmap((ptr_t)h,size);
GC_unmap_gap((ptr_t)h,size,(ptr_t)next,nextsize);
hhdr->hb_flags|=WAS_UNMAPPED;
}
} else if (IS_MAPPED(nexthdr)&&!IS_MAPPED(hhdr)){
if (size > nextsize){
GC_adjust_num_unmapped(next,nexthdr);
GC_unmap((ptr_t)next,nextsize);
GC_unmap_gap((ptr_t)h,size,(ptr_t)next,nextsize);
} else {
GC_adjust_num_unmapped(h,hhdr);
GC_remap((ptr_t)h,size);
hhdr->hb_flags&=~WAS_UNMAPPED;
hhdr->hb_last_reclaimed=nexthdr->hb_last_reclaimed;
}
} else if (!IS_MAPPED(hhdr)&&!IS_MAPPED(nexthdr)){
GC_unmap_gap((ptr_t)h,size,(ptr_t)next,nextsize);
}
GC_remove_from_fl_at(hhdr,i);
GC_remove_from_fl(nexthdr);
hhdr->hb_sz+=nexthdr->hb_sz;
GC_remove_header(next);
GC_add_to_fl(h,hhdr);
h=GC_hblkfreelist[i];
} else {
h=hhdr->hb_next;
}
}
}
}
#endif
STATIC struct hblk*GC_get_first_part(struct hblk*h,hdr*hhdr,
size_t bytes,int index)
{
word total_size=hhdr->hb_sz;
struct hblk*rest;
hdr*rest_hdr;
GC_ASSERT((total_size&(HBLKSIZE-1))==0);
GC_remove_from_fl_at(hhdr,index);
if (total_size==bytes)return h;
rest=(struct hblk*)((word)h+bytes);
rest_hdr=GC_install_header(rest);
if (0==rest_hdr){
WARN("Header allocation failed:dropping block\n",0);
return(0);
}
rest_hdr->hb_sz=total_size - bytes;
rest_hdr->hb_flags=0;
#ifdef GC_ASSERTIONS
hhdr->hb_flags&=~FREE_BLK;
#endif
GC_add_to_fl(rest,rest_hdr);
return h;
}
STATIC void GC_split_block(struct hblk*h,hdr*hhdr,struct hblk*n,
hdr*nhdr,int index)
{
word total_size=hhdr->hb_sz;
word h_size=(word)n - (word)h;
struct hblk*prev=hhdr->hb_prev;
struct hblk*next=hhdr->hb_next;
nhdr->hb_prev=prev;
nhdr->hb_next=next;
nhdr->hb_sz=total_size - h_size;
nhdr->hb_flags=0;
if (prev){
HDR(prev)->hb_next=n;
} else {
GC_hblkfreelist[index]=n;
}
if (next){
HDR(next)->hb_prev=n;
}
GC_ASSERT(GC_free_bytes[index] > h_size);
GC_free_bytes[index]-=h_size;
#ifdef USE_MUNMAP
hhdr->hb_last_reclaimed=(unsigned short)GC_gc_no;
#endif
hhdr->hb_sz=h_size;
GC_add_to_fl(h,hhdr);
nhdr->hb_flags|=FREE_BLK;
}
STATIC struct hblk*
GC_allochblk_nth(size_t sz,int kind,unsigned flags,int n,
int may_split);
#define AVOID_SPLIT_REMAPPED 2
GC_INNER struct hblk*
GC_allochblk(size_t sz,int kind,unsigned flags)
{
word blocks;
int start_list;
struct hblk*result;
int may_split;
int split_limit;
GC_ASSERT((sz&(GRANULE_BYTES - 1))==0);
blocks=OBJ_SZ_TO_BLOCKS_CHECKED(sz);
if ((signed_word)(blocks*HBLKSIZE)< 0){
return 0;
}
start_list=GC_hblk_fl_from_blocks(blocks);
result=GC_allochblk_nth(sz,kind,flags,start_list,FALSE);
if (0!=result)return result;
may_split=TRUE;
if (GC_use_entire_heap||GC_dont_gc
||USED_HEAP_SIZE < GC_requested_heapsize
||GC_incremental||!GC_should_collect()){
split_limit=N_HBLK_FLS;
} else if (GC_finalizer_bytes_freed > (GC_heapsize>>4)){
split_limit=0;
} else {
split_limit=GC_enough_large_bytes_left();
#ifdef USE_MUNMAP
if (split_limit > 0)
may_split=AVOID_SPLIT_REMAPPED;
#endif
}
if (start_list < UNIQUE_THRESHOLD){
++start_list;
}
for (;start_list<=split_limit;++start_list){
result=GC_allochblk_nth(sz,kind,flags,start_list,may_split);
if (0!=result)
break;
}
return result;
}
STATIC long GC_large_alloc_warn_suppressed=0;
STATIC struct hblk*
GC_allochblk_nth(size_t sz,int kind,unsigned flags,int n,int may_split)
{
struct hblk*hbp;
hdr*hhdr;
struct hblk*thishbp;
hdr*thishdr;
signed_word size_needed=HBLKSIZE*OBJ_SZ_TO_BLOCKS_CHECKED(sz);
for (hbp=GC_hblkfreelist[n];;hbp=hhdr->hb_next){
signed_word size_avail;
if (hbp){
} else {
return NULL;
}
GET_HDR(hbp,hhdr);
size_avail=(signed_word)hhdr->hb_sz;
if (size_avail < size_needed)continue;
if (size_avail!=size_needed){
if (!may_split)continue;
thishbp=hhdr->hb_next;
if (thishbp){
signed_word next_size;
GET_HDR(thishbp,thishdr);
next_size=(signed_word)(thishdr->hb_sz);
if (next_size < size_avail
&&next_size>=size_needed
&&!GC_is_black_listed(thishbp,(word)size_needed)){
continue;
}
}
}
if (!IS_UNCOLLECTABLE(kind)&&(kind!=PTRFREE
||size_needed > (signed_word)MAX_BLACK_LIST_ALLOC)){
struct hblk*lasthbp=hbp;
ptr_t search_end=(ptr_t)hbp+size_avail - size_needed;
signed_word orig_avail=size_avail;
signed_word eff_size_needed=(flags&IGNORE_OFF_PAGE)!=0?
(signed_word)HBLKSIZE
:size_needed;
while ((word)lasthbp<=(word)search_end
&&(thishbp=GC_is_black_listed(lasthbp,
(word)eff_size_needed))!=0){
lasthbp=thishbp;
}
size_avail-=(ptr_t)lasthbp - (ptr_t)hbp;
thishbp=lasthbp;
if (size_avail>=size_needed){
if (thishbp!=hbp){
#ifdef USE_MUNMAP
if (may_split==AVOID_SPLIT_REMAPPED&&!IS_MAPPED(hhdr))
continue;
#endif
thishdr=GC_install_header(thishbp);
if (0!=thishdr){
#ifdef USE_MUNMAP
if (!IS_MAPPED(hhdr)){
GC_adjust_num_unmapped(hbp,hhdr);
GC_remap((ptr_t)hbp,(size_t)hhdr->hb_sz);
hhdr->hb_flags&=~WAS_UNMAPPED;
}
#endif
GC_split_block(hbp,hhdr,thishbp,thishdr,n);
hbp=thishbp;
hhdr=thishdr;
}
}
} else if (size_needed > (signed_word)BL_LIMIT
&&orig_avail - size_needed
> (signed_word)BL_LIMIT){
if (++GC_large_alloc_warn_suppressed
>=GC_large_alloc_warn_interval){
WARN("Repeated allocation of very large block "
"(appr. size %" WARN_PRIdPTR "):\n"
"\tMay lead to memory leak and poor performance\n",
size_needed);
GC_large_alloc_warn_suppressed=0;
}
size_avail=orig_avail;
} else if (size_avail==0
&&size_needed==(signed_word)HBLKSIZE
&&IS_MAPPED(hhdr)){
if (!GC_find_leak){
static unsigned count=0;
if ((++count&3)==0){
word total_size=hhdr->hb_sz;
struct hblk*limit=hbp+divHBLKSZ(total_size);
struct hblk*h;
struct hblk*prev=hhdr->hb_prev;
GC_large_free_bytes-=total_size;
GC_bytes_dropped+=total_size;
GC_remove_from_fl_at(hhdr,n);
for (h=hbp;(word)h < (word)limit;h++){
if (h!=hbp){
hhdr=GC_install_header(h);
}
if (NULL!=hhdr){
(void)setup_header(hhdr,h,HBLKSIZE,PTRFREE,0);
if (GC_debugging_started){
BZERO(h,HBLKSIZE);
}
}
}
hbp=prev;
if (0==hbp){
return GC_allochblk_nth(sz,kind,flags,n,may_split);
}
hhdr=HDR(hbp);
}
}
}
}
if( size_avail>=size_needed){
#ifdef USE_MUNMAP
if (!IS_MAPPED(hhdr)){
GC_adjust_num_unmapped(hbp,hhdr);
GC_remap((ptr_t)hbp,(size_t)hhdr->hb_sz);
hhdr->hb_flags&=~WAS_UNMAPPED;
}
#endif
hbp=GC_get_first_part(hbp,hhdr,size_needed,n);
break;
}
}
if (0==hbp)return 0;
if (!GC_install_counts(hbp,(word)size_needed))return(0);
if (!setup_header(hhdr,hbp,sz,kind,flags)){
GC_remove_counts(hbp,(word)size_needed);
return(0);
}
#ifndef GC_DISABLE_INCREMENTAL
GC_ASSERT((size_needed&(HBLKSIZE-1))==0);
GC_remove_protection(hbp,divHBLKSZ(size_needed),
(hhdr->hb_descr==0));
#endif
GC_fail_count=0;
GC_large_free_bytes-=size_needed;
GC_ASSERT(IS_MAPPED(hhdr));
return( hbp);
}
GC_INNER void GC_freehblk(struct hblk*hbp)
{
struct hblk*next,*prev;
hdr*hhdr,*prevhdr,*nexthdr;
word size;
GET_HDR(hbp,hhdr);
size=HBLKSIZE*OBJ_SZ_TO_BLOCKS(hhdr->hb_sz);
if ((size&SIGNB)!=0)
ABORT("Deallocating excessively large block. Too large an allocation?");
GC_remove_counts(hbp,size);
hhdr->hb_sz=size;
#ifdef USE_MUNMAP
hhdr->hb_last_reclaimed=(unsigned short)GC_gc_no;
#endif
if (HBLK_IS_FREE(hhdr)){
ABORT_ARG1("Duplicate large block deallocation",
" of %p",(void*)hbp);
}
GC_ASSERT(IS_MAPPED(hhdr));
hhdr->hb_flags|=FREE_BLK;
next=(struct hblk*)((ptr_t)hbp+size);
GET_HDR(next,nexthdr);
prev=GC_free_block_ending_at(hbp);
if(0!=nexthdr&&HBLK_IS_FREE(nexthdr)&&IS_MAPPED(nexthdr)
&&(signed_word)(hhdr->hb_sz+nexthdr->hb_sz)> 0
){
GC_remove_from_fl(nexthdr);
hhdr->hb_sz+=nexthdr->hb_sz;
GC_remove_header(next);
}
if (prev){
prevhdr=HDR(prev);
if (IS_MAPPED(prevhdr)
&&(signed_word)(hhdr->hb_sz+prevhdr->hb_sz)> 0){
GC_remove_from_fl(prevhdr);
prevhdr->hb_sz+=hhdr->hb_sz;
#ifdef USE_MUNMAP
prevhdr->hb_last_reclaimed=(unsigned short)GC_gc_no;
#endif
GC_remove_header(hbp);
hbp=prev;
hhdr=prevhdr;
}
}
GC_large_free_bytes+=size;
GC_add_to_fl(hbp,hhdr);
}
#include <stdio.h>
#if!defined(MACOS)&&!defined(MSWINCE)
#include <signal.h>
#if!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)&&!defined(__CC_ARM)
#include <sys/types.h>
#endif
#endif
word GC_non_gc_bytes=0;
word GC_gc_no=0;
#ifndef NO_CLOCK
static unsigned long full_gc_total_time=0;
static unsigned full_gc_total_ns_frac=0;
static GC_bool measure_performance=FALSE;
GC_API void GC_CALL GC_start_performance_measurement(void)
{
measure_performance=TRUE;
}
GC_API unsigned long GC_CALL GC_get_full_gc_total_time(void)
{
return full_gc_total_time;
}
#endif
#ifndef GC_DISABLE_INCREMENTAL
GC_INNER GC_bool GC_incremental=FALSE;
#endif
GC_API int GC_CALL GC_is_incremental_mode(void)
{
return (int)GC_incremental;
}
#ifdef THREADS
int GC_parallel=FALSE;
#endif
#if defined(GC_FULL_FREQ)&&!defined(CPPCHECK)
int GC_full_freq=GC_FULL_FREQ;
#else
int GC_full_freq=19;
#endif
STATIC GC_bool GC_need_full_gc=FALSE;
#ifdef THREAD_LOCAL_ALLOC
GC_INNER GC_bool GC_world_stopped=FALSE;
#endif
STATIC word GC_used_heap_size_after_full=0;
EXTERN_C_BEGIN
extern const char*const GC_copyright[];
EXTERN_C_END
const char*const GC_copyright[]=
{"Copyright 1988,1989 Hans-J. Boehm and Alan J. Demers ",
"Copyright (c)1991-1995 by Xerox Corporation. All rights reserved. ",
"Copyright (c)1996-1998 by Silicon Graphics. All rights reserved. ",
"Copyright (c)1999-2009 by Hewlett-Packard 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.",
"See source code for details." };
#ifndef GC_NO_VERSION_VAR
EXTERN_C_BEGIN
extern const unsigned GC_version;
EXTERN_C_END
const unsigned GC_version=((GC_VERSION_MAJOR<<16)|
(GC_VERSION_MINOR<<8)|GC_VERSION_MICRO);
#endif
GC_API unsigned GC_CALL GC_get_version(void)
{
return (GC_VERSION_MAJOR<<16)|(GC_VERSION_MINOR<<8)|
GC_VERSION_MICRO;
}
#ifdef GC_DONT_EXPAND
int GC_dont_expand=TRUE;
#else
int GC_dont_expand=FALSE;
#endif
#if defined(GC_FREE_SPACE_DIVISOR)&&!defined(CPPCHECK)
word GC_free_space_divisor=GC_FREE_SPACE_DIVISOR;
#else
word GC_free_space_divisor=3;
#endif
GC_INNER int GC_CALLBACK GC_never_stop_func(void)
{
return(0);
}
#if defined(GC_TIME_LIMIT)&&!defined(CPPCHECK)
unsigned long GC_time_limit=GC_TIME_LIMIT;
#elif defined(PARALLEL_MARK)
unsigned long GC_time_limit=GC_TIME_UNLIMITED;
#else
unsigned long GC_time_limit=50;
#endif
#ifndef NO_CLOCK
STATIC unsigned long GC_time_lim_nsec=0;
#define TV_NSEC_LIMIT (1000UL*1000)
GC_API void GC_CALL GC_set_time_limit_tv(struct GC_timeval_s tv)
{
GC_ASSERT(tv.tv_ms<=GC_TIME_UNLIMITED);
GC_ASSERT(tv.tv_nsec < TV_NSEC_LIMIT);
GC_time_limit=tv.tv_ms;
GC_time_lim_nsec=tv.tv_nsec;
}
GC_API struct GC_timeval_s GC_CALL GC_get_time_limit_tv(void)
{
struct GC_timeval_s tv;
tv.tv_ms=GC_time_limit;
tv.tv_nsec=GC_time_lim_nsec;
return tv;
}
STATIC CLOCK_TYPE GC_start_time=CLOCK_TYPE_INITIALIZER;
#endif
STATIC int GC_n_attempts=0;
STATIC GC_stop_func GC_default_stop_func=GC_never_stop_func;
GC_API void GC_CALL GC_set_stop_func(GC_stop_func stop_func)
{
DCL_LOCK_STATE;
GC_ASSERT(NONNULL_ARG_NOT_NULL(stop_func));
LOCK();
GC_default_stop_func=stop_func;
UNLOCK();
}
GC_API GC_stop_func GC_CALL GC_get_stop_func(void)
{
GC_stop_func stop_func;
DCL_LOCK_STATE;
LOCK();
stop_func=GC_default_stop_func;
UNLOCK();
return stop_func;
}
#if defined(GC_DISABLE_INCREMENTAL)||defined(NO_CLOCK)
#define GC_timeout_stop_func GC_default_stop_func
#else
STATIC int GC_CALLBACK GC_timeout_stop_func (void)
{
CLOCK_TYPE current_time;
static unsigned count=0;
unsigned long time_diff,nsec_diff;
if ((*GC_default_stop_func)())
return(1);
if ((count++&3)!=0)return(0);
GET_TIME(current_time);
time_diff=MS_TIME_DIFF(current_time,GC_start_time);
nsec_diff=NS_FRAC_TIME_DIFF(current_time,GC_start_time);
#if defined(CPPCHECK)
GC_noop1((word)&nsec_diff);
#endif
if (time_diff>=GC_time_limit
&&(time_diff > GC_time_limit||nsec_diff>=GC_time_lim_nsec)){
GC_COND_LOG_PRINTF("Abandoning stopped marking after %lu ms %lu ns"
" (attempt %d)\n",
time_diff,nsec_diff,GC_n_attempts);
return 1;
}
return(0);
}
#endif
#ifdef THREADS
GC_INNER word GC_total_stacksize=0;
#endif
static size_t min_bytes_allocd_minimum=1;
GC_API void GC_CALL GC_set_min_bytes_allocd(size_t value)
{
GC_ASSERT(value > 0);
min_bytes_allocd_minimum=value;
}
GC_API size_t GC_CALL GC_get_min_bytes_allocd(void)
{
return min_bytes_allocd_minimum;
}
static word min_bytes_allocd(void)
{
word result;
word stack_size;
word total_root_size;
word scan_size;
#ifdef THREADS
if (GC_need_to_lock){
stack_size=GC_total_stacksize;
#ifdef DEBUG_THREADS
GC_log_printf("Total stacks size:%lu\n",
(unsigned long)stack_size);
#endif
} else
#endif
{
#ifdef STACK_NOT_SCANNED
stack_size=0;
#elif defined(STACK_GROWS_UP)
stack_size=GC_approx_sp()- GC_stackbottom;
#else
stack_size=GC_stackbottom - GC_approx_sp();
#endif
}
total_root_size=2*stack_size+GC_root_size;
scan_size=2*GC_composite_in_use+GC_atomic_in_use/4
+total_root_size;
result=scan_size/GC_free_space_divisor;
if (GC_incremental){
result/=2;
}
return result > min_bytes_allocd_minimum
?result:min_bytes_allocd_minimum;
}
STATIC word GC_non_gc_bytes_at_gc=0;
STATIC word GC_adj_bytes_allocd(void)
{
signed_word result;
signed_word expl_managed=(signed_word)GC_non_gc_bytes
- (signed_word)GC_non_gc_bytes_at_gc;
result=(signed_word)GC_bytes_allocd
+(signed_word)GC_bytes_dropped
- (signed_word)GC_bytes_freed
+(signed_word)GC_finalizer_bytes_freed
- expl_managed;
if (result > (signed_word)GC_bytes_allocd){
result=GC_bytes_allocd;
}
result+=GC_bytes_finalized;
if (result < (signed_word)(GC_bytes_allocd>>3)){
return(GC_bytes_allocd>>3);
} else {
return(result);
}
}
STATIC void GC_clear_a_few_frames(void)
{
#ifndef CLEAR_NWORDS
#define CLEAR_NWORDS 64
#endif
volatile word frames[CLEAR_NWORDS];
BZERO((word*)frames,CLEAR_NWORDS*sizeof(word));
}
STATIC word GC_collect_at_heapsize=GC_WORD_MAX;
GC_INNER GC_bool GC_should_collect(void)
{
static word last_min_bytes_allocd;
static word last_gc_no;
if (last_gc_no!=GC_gc_no){
last_min_bytes_allocd=min_bytes_allocd();
last_gc_no=GC_gc_no;
}
return(GC_adj_bytes_allocd()>=last_min_bytes_allocd
||GC_heapsize>=GC_collect_at_heapsize);
}
GC_start_callback_proc GC_start_call_back=0;
GC_API void GC_CALL GC_set_start_callback(GC_start_callback_proc fn)
{
DCL_LOCK_STATE;
LOCK();
GC_start_call_back=fn;
UNLOCK();
}
GC_API GC_start_callback_proc GC_CALL GC_get_start_callback(void)
{
GC_start_callback_proc fn;
DCL_LOCK_STATE;
LOCK();
fn=GC_start_call_back;
UNLOCK();
return fn;
}
GC_INLINE void GC_notify_full_gc(void)
{
if (GC_start_call_back!=0){
(*GC_start_call_back)();
}
}
STATIC GC_bool GC_is_full_gc=FALSE;
STATIC GC_bool GC_stopped_mark(GC_stop_func stop_func);
STATIC void GC_finish_collection(void);
STATIC void GC_maybe_gc(void)
{
GC_ASSERT(I_HOLD_LOCK());
ASSERT_CANCEL_DISABLED();
if (GC_should_collect()){
static int n_partial_gcs=0;
if (!GC_incremental){
GC_try_to_collect_inner(GC_never_stop_func);
n_partial_gcs=0;
return;
} else {
#ifdef PARALLEL_MARK
if (GC_parallel)
GC_wait_for_reclaim();
#endif
if (GC_need_full_gc||n_partial_gcs>=GC_full_freq){
GC_COND_LOG_PRINTF(
"***>Full mark for collection #%lu after %lu allocd bytes\n",
(unsigned long)GC_gc_no+1,(unsigned long)GC_bytes_allocd);
GC_promote_black_lists();
(void)GC_reclaim_all((GC_stop_func)0,TRUE);
GC_notify_full_gc();
GC_clear_marks();
n_partial_gcs=0;
GC_is_full_gc=TRUE;
} else {
n_partial_gcs++;
}
}
#ifndef NO_CLOCK
if (GC_time_limit!=GC_TIME_UNLIMITED){ GET_TIME(GC_start_time);}
#endif
if (GC_stopped_mark(GC_time_limit==GC_TIME_UNLIMITED?
GC_never_stop_func:GC_timeout_stop_func)){
#ifdef SAVE_CALL_CHAIN
GC_save_callers(GC_last_stack);
#endif
GC_finish_collection();
} else {
if (!GC_is_full_gc){
GC_n_attempts++;
}
}
}
}
STATIC GC_on_collection_event_proc GC_on_collection_event=0;
GC_API void GC_CALL GC_set_on_collection_event(GC_on_collection_event_proc fn)
{
DCL_LOCK_STATE;
LOCK();
GC_on_collection_event=fn;
UNLOCK();
}
GC_API GC_on_collection_event_proc GC_CALL GC_get_on_collection_event(void)
{
GC_on_collection_event_proc fn;
DCL_LOCK_STATE;
LOCK();
fn=GC_on_collection_event;
UNLOCK();
return fn;
}
GC_INNER GC_bool GC_try_to_collect_inner(GC_stop_func stop_func)
{
#ifndef NO_CLOCK
CLOCK_TYPE start_time=CLOCK_TYPE_INITIALIZER;
GC_bool start_time_valid;
#endif
ASSERT_CANCEL_DISABLED();
GC_ASSERT(I_HOLD_LOCK());
if (GC_dont_gc||(*stop_func)())return FALSE;
if (GC_on_collection_event)
GC_on_collection_event(GC_EVENT_START);
if (GC_incremental&&GC_collection_in_progress()){
GC_COND_LOG_PRINTF(
"GC_try_to_collect_inner:finishing collection in progress\n");
while(GC_collection_in_progress()){
if ((*stop_func)()){
return(FALSE);
}
ENTER_GC();
GC_collect_a_little_inner(1);
EXIT_GC();
}
}
GC_notify_full_gc();
#ifndef NO_CLOCK
start_time_valid=FALSE;
if ((GC_print_stats|(int)measure_performance)!=0){
if (GC_print_stats)
GC_log_printf("Initiating full world-stop collection!\n");
start_time_valid=TRUE;
GET_TIME(start_time);
}
#endif
GC_promote_black_lists();
#ifdef PARALLEL_MARK
if (GC_parallel)
GC_wait_for_reclaim();
#endif
if ((GC_find_leak||stop_func!=GC_never_stop_func)
&&!GC_reclaim_all(stop_func,FALSE)){
return(FALSE);
}
GC_invalidate_mark_state();
GC_clear_marks();
#ifdef SAVE_CALL_CHAIN
GC_save_callers(GC_last_stack);
#endif
GC_is_full_gc=TRUE;
if (!GC_stopped_mark(stop_func)){
if (!GC_incremental){
GC_invalidate_mark_state();
GC_unpromote_black_lists();
}
return(FALSE);
}
GC_finish_collection();
#ifndef NO_CLOCK
if (start_time_valid){
CLOCK_TYPE current_time;
unsigned long time_diff,ns_frac_diff;
GET_TIME(current_time);
time_diff=MS_TIME_DIFF(current_time,start_time);
ns_frac_diff=NS_FRAC_TIME_DIFF(current_time,start_time);
if (measure_performance){
full_gc_total_time+=time_diff;
full_gc_total_ns_frac+=(unsigned)ns_frac_diff;
if (full_gc_total_ns_frac>=1000000U){
full_gc_total_ns_frac-=1000000U;
full_gc_total_time++;
}
}
if (GC_print_stats)
GC_log_printf("Complete collection took %lu ms %lu ns\n",
time_diff,ns_frac_diff);
}
#endif
if (GC_on_collection_event)
GC_on_collection_event(GC_EVENT_END);
return(TRUE);
}
#ifndef GC_RATE
#define GC_RATE 10
#endif
#ifndef MAX_PRIOR_ATTEMPTS
#define MAX_PRIOR_ATTEMPTS 1
#endif
STATIC int GC_deficit=0;
STATIC int GC_rate=GC_RATE;
GC_API void GC_CALL GC_set_rate(int value)
{
GC_ASSERT(value > 0);
GC_rate=value;
}
GC_API int GC_CALL GC_get_rate(void)
{
return GC_rate;
}
static int max_prior_attempts=MAX_PRIOR_ATTEMPTS;
GC_API void GC_CALL GC_set_max_prior_attempts(int value)
{
GC_ASSERT(value>=0);
max_prior_attempts=value;
}
GC_API int GC_CALL GC_get_max_prior_attempts(void)
{
return max_prior_attempts;
}
GC_INNER void GC_collect_a_little_inner(int n)
{
IF_CANCEL(int cancel_state;)
GC_ASSERT(I_HOLD_LOCK());
if (GC_dont_gc)return;
DISABLE_CANCEL(cancel_state);
if (GC_incremental&&GC_collection_in_progress()){
int i;
int max_deficit=GC_rate*n;
#ifdef PARALLEL_MARK
if (GC_time_limit!=GC_TIME_UNLIMITED)
GC_parallel_mark_disabled=TRUE;
#endif
for (i=GC_deficit;i < max_deficit;i++){
if (GC_mark_some(NULL))
break;
}
#ifdef PARALLEL_MARK
GC_parallel_mark_disabled=FALSE;
#endif
if (i < max_deficit){
#ifdef SAVE_CALL_CHAIN
GC_save_callers(GC_last_stack);
#endif
#ifdef PARALLEL_MARK
if (GC_parallel)
GC_wait_for_reclaim();
#endif
if (GC_n_attempts < max_prior_attempts
&&GC_time_limit!=GC_TIME_UNLIMITED){
#ifndef NO_CLOCK
GET_TIME(GC_start_time);
#endif
if (GC_stopped_mark(GC_timeout_stop_func)){
GC_finish_collection();
} else {
GC_n_attempts++;
}
} else {
(void)GC_stopped_mark(GC_never_stop_func);
GC_finish_collection();
}
}
if (GC_deficit > 0){
GC_deficit-=max_deficit;
if (GC_deficit < 0)
GC_deficit=0;
}
} else {
GC_maybe_gc();
}
RESTORE_CANCEL(cancel_state);
}
GC_INNER void (*GC_check_heap)(void)=0;
GC_INNER void (*GC_print_all_smashed)(void)=0;
GC_API int GC_CALL GC_collect_a_little(void)
{
int result;
DCL_LOCK_STATE;
LOCK();
ENTER_GC();
GC_collect_a_little_inner(1);
EXIT_GC();
result=(int)GC_collection_in_progress();
UNLOCK();
if (!result&&GC_debugging_started)GC_print_all_smashed();
return(result);
}
#ifndef NO_CLOCK
static unsigned world_stopped_total_time=0;
static unsigned world_stopped_total_divisor=0;
#ifndef MAX_TOTAL_TIME_DIVISOR
#define MAX_TOTAL_TIME_DIVISOR 1000
#endif
#endif
#ifdef USE_MUNMAP
#define IF_USE_MUNMAP(x)x
#define COMMA_IF_USE_MUNMAP(x),x
#else
#define IF_USE_MUNMAP(x)
#define COMMA_IF_USE_MUNMAP(x)
#endif
STATIC GC_bool GC_stopped_mark(GC_stop_func stop_func)
{
int i;
#ifndef NO_CLOCK
CLOCK_TYPE start_time=CLOCK_TYPE_INITIALIZER;
#endif
GC_ASSERT(I_HOLD_LOCK());
#if!defined(REDIRECT_MALLOC)&&defined(USE_WINALLOC)
GC_add_current_malloc_heap();
#endif
#if defined(REGISTER_LIBRARIES_EARLY)
GC_cond_register_dynamic_libraries();
#endif
#ifndef NO_CLOCK
if (GC_PRINT_STATS_FLAG)
GET_TIME(start_time);
#endif
#if!defined(GC_NO_FINALIZATION)&&!defined(GC_TOGGLE_REFS_NOT_NEEDED)
GC_process_togglerefs();
#endif
#ifdef THREADS
if (GC_on_collection_event)
GC_on_collection_event(GC_EVENT_PRE_STOP_WORLD);
#endif
STOP_WORLD();
#ifdef THREADS
if (GC_on_collection_event)
GC_on_collection_event(GC_EVENT_POST_STOP_WORLD);
#endif
#ifdef THREAD_LOCAL_ALLOC
GC_world_stopped=TRUE;
#endif
GC_COND_LOG_PRINTF(
"\n--> Marking for collection #%lu after %lu allocated bytes\n",
(unsigned long)GC_gc_no+1,(unsigned long)GC_bytes_allocd);
#ifdef MAKE_BACK_GRAPH
if (GC_print_back_height){
GC_build_back_graph();
}
#endif
if (GC_on_collection_event)
GC_on_collection_event(GC_EVENT_MARK_START);
GC_clear_a_few_frames();
GC_noop6(0,0,0,0,0,0);
GC_initiate_gc();
#ifdef PARALLEL_MARK
if (stop_func!=GC_never_stop_func)
GC_parallel_mark_disabled=TRUE;
#endif
for (i=0;!(*stop_func)();i++){
if (GC_mark_some(GC_approx_sp())){
#ifdef PARALLEL_MARK
if (GC_parallel&&GC_parallel_mark_disabled){
GC_COND_LOG_PRINTF("Stopped marking done after %d iterations"
" with disabled parallel marker\n",i);
}
#endif
i=-1;
break;
}
}
#ifdef PARALLEL_MARK
GC_parallel_mark_disabled=FALSE;
#endif
if (i>=0){
GC_COND_LOG_PRINTF("Abandoned stopped marking after"
" %d iterations\n",i);
GC_deficit=i;
#ifdef THREAD_LOCAL_ALLOC
GC_world_stopped=FALSE;
#endif
#ifdef THREADS
if (GC_on_collection_event)
GC_on_collection_event(GC_EVENT_PRE_START_WORLD);
#endif
START_WORLD();
#ifdef THREADS
if (GC_on_collection_event)
GC_on_collection_event(GC_EVENT_POST_START_WORLD);
#endif
return FALSE;
}
GC_gc_no++;
GC_DBGLOG_PRINTF("GC #%lu freed %ld bytes,heap %lu KiB"
IF_USE_MUNMAP(" (+%lu KiB unmapped)")"\n",
(unsigned long)GC_gc_no,(long)GC_bytes_found,
TO_KiB_UL(GC_heapsize - GC_unmapped_bytes)
COMMA_IF_USE_MUNMAP(TO_KiB_UL(GC_unmapped_bytes)));
if (GC_debugging_started){
(*GC_check_heap)();
}
if (GC_on_collection_event){
GC_on_collection_event(GC_EVENT_MARK_END);
#ifdef THREADS
GC_on_collection_event(GC_EVENT_PRE_START_WORLD);
#endif
}
#ifdef THREAD_LOCAL_ALLOC
GC_world_stopped=FALSE;
#endif
START_WORLD();
#ifdef THREADS
if (GC_on_collection_event)
GC_on_collection_event(GC_EVENT_POST_START_WORLD);
#endif
#ifndef NO_CLOCK
if (GC_PRINT_STATS_FLAG){
unsigned long time_diff;
unsigned total_time,divisor;
CLOCK_TYPE current_time;
GET_TIME(current_time);
time_diff=MS_TIME_DIFF(current_time,start_time);
total_time=world_stopped_total_time;
divisor=world_stopped_total_divisor;
if ((int)total_time < 0||divisor>=MAX_TOTAL_TIME_DIVISOR){
total_time>>=1;
divisor>>=1;
}
total_time+=time_diff < (((unsigned)-1)>>1)?
(unsigned)time_diff:((unsigned)-1)>>1;
world_stopped_total_time=total_time;
world_stopped_total_divisor=++divisor;
GC_ASSERT(divisor!=0);
GC_log_printf("World-stopped marking took %lu ms %lu ns"
" (%u ms in average)\n",
time_diff,NS_FRAC_TIME_DIFF(current_time,start_time),
total_time/divisor);
}
#endif
return(TRUE);
}
GC_INNER void GC_set_fl_marks(ptr_t q)
{
if (q){
struct hblk*h=HBLKPTR(q);
struct hblk*last_h=h;
hdr*hhdr=HDR(h);
IF_PER_OBJ(word sz=hhdr->hb_sz;)
for (;;){
word bit_no=MARK_BIT_NO((ptr_t)q - (ptr_t)h,sz);
if (!mark_bit_from_hdr(hhdr,bit_no)){
set_mark_bit_from_hdr(hhdr,bit_no);
++hhdr->hb_n_marks;
}
q=(ptr_t)obj_link(q);
if (q==NULL)
break;
h=HBLKPTR(q);
if (h!=last_h){
last_h=h;
hhdr=HDR(h);
IF_PER_OBJ(sz=hhdr->hb_sz;)
}
}
}
}
#if defined(GC_ASSERTIONS)&&defined(THREAD_LOCAL_ALLOC)
void GC_check_fl_marks(void**pfreelist)
{
#if defined(AO_HAVE_load_acquire_read)&&!defined(THREAD_SANITIZER)
AO_t*list=(AO_t*)AO_load_acquire_read((AO_t*)pfreelist);
AO_t*prev;
AO_t*p;
if ((word)list<=HBLKSIZE)return;
prev=(AO_t*)pfreelist;
for (p=list;p!=NULL;){
AO_t*next;
if (!GC_is_marked(p)){
ABORT_ARG2("Unmarked local free list entry",
":object %p on list %p",(void*)p,(void*)list);
}
next=(AO_t*)AO_load_acquire_read(p);
if (AO_load(prev)!=(AO_t)p)
break;
prev=p;
p=next;
}
#else
(void)pfreelist;
#endif
}
#endif
STATIC void GC_clear_fl_marks(ptr_t q)
{
struct hblk*h=HBLKPTR(q);
struct hblk*last_h=h;
hdr*hhdr=HDR(h);
word sz=hhdr->hb_sz;
for (;;){
word bit_no=MARK_BIT_NO((ptr_t)q - (ptr_t)h,sz);
if (mark_bit_from_hdr(hhdr,bit_no)){
size_t n_marks=hhdr->hb_n_marks;
GC_ASSERT(n_marks!=0);
clear_mark_bit_from_hdr(hhdr,bit_no);
n_marks--;
#ifdef PARALLEL_MARK
if (0!=n_marks||!GC_parallel){
hhdr->hb_n_marks=n_marks;
}
#else
hhdr->hb_n_marks=n_marks;
#endif
}
GC_bytes_found-=sz;
q=(ptr_t)obj_link(q);
if (q==NULL)
break;
h=HBLKPTR(q);
if (h!=last_h){
last_h=h;
hhdr=HDR(h);
sz=hhdr->hb_sz;
}
}
}
#if defined(GC_ASSERTIONS)&&defined(THREAD_LOCAL_ALLOC)
void GC_check_tls(void);
#endif
GC_on_heap_resize_proc GC_on_heap_resize=0;
GC_INLINE int GC_compute_heap_usage_percent(void)
{
word used=GC_composite_in_use+GC_atomic_in_use;
word heap_sz=GC_heapsize - GC_unmapped_bytes;
#if defined(CPPCHECK)
word limit=(GC_WORD_MAX>>1)/50;
#else
const word limit=GC_WORD_MAX/100;
#endif
return used>=heap_sz?0:used < limit?
(int)((used*100)/heap_sz):(int)(used/(heap_sz/100));
}
STATIC void GC_finish_collection(void)
{
#ifndef NO_CLOCK
CLOCK_TYPE start_time=CLOCK_TYPE_INITIALIZER;
CLOCK_TYPE finalize_time=CLOCK_TYPE_INITIALIZER;
#endif
GC_ASSERT(I_HOLD_LOCK());
#if defined(GC_ASSERTIONS)&&defined(THREAD_LOCAL_ALLOC)&&!defined(DBG_HDRS_ALL)
GC_check_tls();
#endif
#ifndef NO_CLOCK
if (GC_print_stats)
GET_TIME(start_time);
#endif
if (GC_on_collection_event)
GC_on_collection_event(GC_EVENT_RECLAIM_START);
#ifndef GC_GET_HEAP_USAGE_NOT_NEEDED
if (GC_bytes_found > 0)
GC_reclaimed_bytes_before_gc+=(word)GC_bytes_found;
#endif
GC_bytes_found=0;
#if defined(LINUX)&&defined(__ELF__)&&!defined(SMALL_CONFIG)
if (GETENV("GC_PRINT_ADDRESS_MAP")!=0){
GC_print_address_map();
}
#endif
COND_DUMP;
if (GC_find_leak){
word size;
unsigned kind;
ptr_t q;
for (kind=0;kind < GC_n_kinds;kind++){
for (size=1;size<=MAXOBJGRANULES;size++){
q=(ptr_t)GC_obj_kinds[kind].ok_freelist[size];
if (q!=NULL)
GC_set_fl_marks(q);
}
}
GC_start_reclaim(TRUE);
}
#ifndef GC_NO_FINALIZATION
GC_finalize();
#endif
#ifndef NO_CLOCK
if (GC_print_stats)
GET_TIME(finalize_time);
#endif
if (GC_print_back_height){
#ifdef MAKE_BACK_GRAPH
GC_traverse_back_graph();
#elif!defined(SMALL_CONFIG)
GC_err_printf("Back height not available:"
"Rebuild collector with -DMAKE_BACK_GRAPH\n");
#endif
}
{
word size;
ptr_t q;
unsigned kind;
for (kind=0;kind < GC_n_kinds;kind++){
for (size=1;size<=MAXOBJGRANULES;size++){
q=(ptr_t)GC_obj_kinds[kind].ok_freelist[size];
if (q!=NULL)
GC_clear_fl_marks(q);
}
}
}
GC_VERBOSE_LOG_PRINTF("Bytes recovered before sweep - f.l. count=%ld\n",
(long)GC_bytes_found);
GC_start_reclaim(FALSE);
GC_DBGLOG_PRINTF("In-use heap:%d%% (%lu KiB pointers+%lu KiB other)\n",
GC_compute_heap_usage_percent(),
TO_KiB_UL(GC_composite_in_use),
TO_KiB_UL(GC_atomic_in_use));
if (GC_is_full_gc){
GC_used_heap_size_after_full=USED_HEAP_SIZE;
GC_need_full_gc=FALSE;
} else {
GC_need_full_gc=USED_HEAP_SIZE - GC_used_heap_size_after_full
> min_bytes_allocd();
}
GC_VERBOSE_LOG_PRINTF("Immediately reclaimed %ld bytes,heapsize:"
" %lu bytes" IF_USE_MUNMAP(" (%lu unmapped)")"\n",
(long)GC_bytes_found,
(unsigned long)GC_heapsize
COMMA_IF_USE_MUNMAP((unsigned long)
GC_unmapped_bytes));
GC_n_attempts=0;
GC_is_full_gc=FALSE;
GC_bytes_allocd_before_gc+=GC_bytes_allocd;
GC_non_gc_bytes_at_gc=GC_non_gc_bytes;
GC_bytes_allocd=0;
GC_bytes_dropped=0;
GC_bytes_freed=0;
GC_finalizer_bytes_freed=0;
IF_USE_MUNMAP(GC_unmap_old());
if (GC_on_collection_event)
GC_on_collection_event(GC_EVENT_RECLAIM_END);
#ifndef NO_CLOCK
if (GC_print_stats){
CLOCK_TYPE done_time;
GET_TIME(done_time);
#if!defined(SMALL_CONFIG)&&!defined(GC_NO_FINALIZATION)
GC_print_finalization_stats();
#endif
GC_log_printf("Finalize and initiate sweep took %lu ms %lu ns"
"+%lu ms %lu ns\n",
MS_TIME_DIFF(finalize_time,start_time),
NS_FRAC_TIME_DIFF(finalize_time,start_time),
MS_TIME_DIFF(done_time,finalize_time),
NS_FRAC_TIME_DIFF(done_time,finalize_time));
}
#elif!defined(SMALL_CONFIG)&&!defined(GC_NO_FINALIZATION)
if (GC_print_stats)
GC_print_finalization_stats();
#endif
}
STATIC GC_bool GC_try_to_collect_general(GC_stop_func stop_func,
GC_bool force_unmap GC_ATTR_UNUSED)
{
GC_bool result;
IF_USE_MUNMAP(int old_unmap_threshold;)
IF_CANCEL(int cancel_state;)
DCL_LOCK_STATE;
if (!EXPECT(GC_is_initialized,TRUE))GC_init();
if (GC_debugging_started)GC_print_all_smashed();
GC_INVOKE_FINALIZERS();
LOCK();
DISABLE_CANCEL(cancel_state);
#ifdef USE_MUNMAP
old_unmap_threshold=GC_unmap_threshold;
if (force_unmap||
(GC_force_unmap_on_gcollect&&old_unmap_threshold > 0))
GC_unmap_threshold=1;
#endif
ENTER_GC();
GC_noop6(0,0,0,0,0,0);
result=GC_try_to_collect_inner(stop_func!=0?stop_func:
GC_default_stop_func);
EXIT_GC();
IF_USE_MUNMAP(GC_unmap_threshold=old_unmap_threshold);
RESTORE_CANCEL(cancel_state);
UNLOCK();
if (result){
if (GC_debugging_started)GC_print_all_smashed();
GC_INVOKE_FINALIZERS();
}
return(result);
}
GC_API int GC_CALL GC_try_to_collect(GC_stop_func stop_func)
{
GC_ASSERT(NONNULL_ARG_NOT_NULL(stop_func));
return (int)GC_try_to_collect_general(stop_func,FALSE);
}
GC_API void GC_CALL GC_gcollect(void)
{
(void)GC_try_to_collect_general(0,FALSE);
if (GC_have_errors)GC_print_all_errors();
}
STATIC word GC_heapsize_at_forced_unmap=0;
GC_API void GC_CALL GC_gcollect_and_unmap(void)
{
GC_heapsize_at_forced_unmap=GC_heapsize;
(void)GC_try_to_collect_general(GC_never_stop_func,TRUE);
}
#ifdef USE_PROC_FOR_LIBRARIES
GC_INNER void GC_add_to_our_memory(ptr_t p,size_t bytes)
{
if (0==p)return;
if (GC_n_memory>=MAX_HEAP_SECTS)
ABORT("Too many GC-allocated memory sections:Increase MAX_HEAP_SECTS");
GC_our_memory[GC_n_memory].hs_start=p;
GC_our_memory[GC_n_memory].hs_bytes=bytes;
GC_n_memory++;
}
#endif
GC_INNER void GC_add_to_heap(struct hblk*p,size_t bytes)
{
hdr*phdr;
word endp;
if (GC_n_heap_sects>=MAX_HEAP_SECTS){
ABORT("Too many heap sections:Increase MAXHINCR or MAX_HEAP_SECTS");
}
while ((word)p<=HBLKSIZE){
++p;
bytes-=HBLKSIZE;
if (0==bytes)return;
}
endp=(word)p+bytes;
if (endp<=(word)p){
bytes-=HBLKSIZE;
if (0==bytes)return;
endp-=HBLKSIZE;
}
phdr=GC_install_header(p);
if (0==phdr){
return;
}
GC_ASSERT(endp > (word)p&&endp==(word)p+bytes);
GC_heap_sects[GC_n_heap_sects].hs_start=(ptr_t)p;
GC_heap_sects[GC_n_heap_sects].hs_bytes=bytes;
GC_n_heap_sects++;
phdr->hb_sz=bytes;
phdr->hb_flags=0;
GC_freehblk(p);
GC_heapsize+=bytes;
GC_collect_at_heapsize+=bytes;
if (GC_collect_at_heapsize < GC_heapsize)
GC_collect_at_heapsize=GC_WORD_MAX;
if ((word)p<=(word)GC_least_plausible_heap_addr
||GC_least_plausible_heap_addr==0){
GC_least_plausible_heap_addr=(void*)((ptr_t)p - sizeof(word));
}
if ((word)p+bytes>=(word)GC_greatest_plausible_heap_addr){
GC_greatest_plausible_heap_addr=(void*)endp;
}
}
#if!defined(NO_DEBUGGING)
void GC_print_heap_sects(void)
{
unsigned i;
GC_printf("Total heap size:%lu" IF_USE_MUNMAP(" (%lu unmapped)")"\n",
(unsigned long)GC_heapsize
COMMA_IF_USE_MUNMAP((unsigned long)GC_unmapped_bytes));
for (i=0;i < GC_n_heap_sects;i++){
ptr_t start=GC_heap_sects[i].hs_start;
size_t len=GC_heap_sects[i].hs_bytes;
struct hblk*h;
unsigned nbl=0;
for (h=(struct hblk*)start;(word)h < (word)(start+len);h++){
if (GC_is_black_listed(h,HBLKSIZE))nbl++;
}
GC_printf("Section %d from %p to %p %u/%lu blacklisted\n",
i,(void*)start,(void*)&start[len],
nbl,(unsigned long)divHBLKSZ(len));
}
}
#endif
void*GC_least_plausible_heap_addr=(void*)GC_WORD_MAX;
void*GC_greatest_plausible_heap_addr=0;
GC_INLINE word GC_max(word x,word y)
{
return(x > y?x:y);
}
GC_INLINE word GC_min(word x,word y)
{
return(x < y?x:y);
}
STATIC word GC_max_heapsize=0;
GC_API void GC_CALL GC_set_max_heap_size(GC_word n)
{
GC_max_heapsize=n;
}
GC_word GC_max_retries=0;
GC_INNER GC_bool GC_expand_hp_inner(word n)
{
size_t bytes;
struct hblk*space;
word expansion_slop;
GC_ASSERT(I_HOLD_LOCK());
GC_ASSERT(GC_page_size!=0);
if (n < MINHINCR)n=MINHINCR;
bytes=ROUNDUP_PAGESIZE((size_t)n*HBLKSIZE);
if (GC_max_heapsize!=0
&&(GC_max_heapsize < (word)bytes
||GC_heapsize > GC_max_heapsize - (word)bytes)){
return(FALSE);
}
space=GET_MEM(bytes);
GC_add_to_our_memory((ptr_t)space,bytes);
if (space==0){
WARN("Failed to expand heap by %" WARN_PRIdPTR " bytes\n",
(word)bytes);
return(FALSE);
}
GC_INFOLOG_PRINTF("Grow heap to %lu KiB after %lu bytes allocated\n",
TO_KiB_UL(GC_heapsize+(word)bytes),
(unsigned long)GC_bytes_allocd);
expansion_slop=min_bytes_allocd()+4*MAXHINCR*HBLKSIZE;
if ((GC_last_heap_addr==0&&!((word)space&SIGNB))
||(GC_last_heap_addr!=0
&&(word)GC_last_heap_addr < (word)space)){
word new_limit=(word)space+(word)bytes+expansion_slop;
if (new_limit > (word)space){
GC_greatest_plausible_heap_addr=
(void*)GC_max((word)GC_greatest_plausible_heap_addr,
(word)new_limit);
}
} else {
word new_limit=(word)space - expansion_slop;
if (new_limit < (word)space){
GC_least_plausible_heap_addr=
(void*)GC_min((word)GC_least_plausible_heap_addr,
(word)space - expansion_slop);
}
}
GC_prev_heap_addr=GC_last_heap_addr;
GC_last_heap_addr=(ptr_t)space;
GC_add_to_heap(space,bytes);
GC_collect_at_heapsize=
GC_heapsize+expansion_slop - 2*MAXHINCR*HBLKSIZE;
if (GC_collect_at_heapsize < GC_heapsize)
GC_collect_at_heapsize=GC_WORD_MAX;
if (GC_on_heap_resize)
(*GC_on_heap_resize)(GC_heapsize);
return(TRUE);
}
GC_API int GC_CALL GC_expand_hp(size_t bytes)
{
int result;
DCL_LOCK_STATE;
if (!EXPECT(GC_is_initialized,TRUE))GC_init();
LOCK();
result=(int)GC_expand_hp_inner(divHBLKSZ((word)bytes));
if (result)GC_requested_heapsize+=bytes;
UNLOCK();
return(result);
}
GC_INNER unsigned GC_fail_count=0;
#if defined(GC_ALLOCD_BYTES_PER_FINALIZER)&&!defined(CPPCHECK)
STATIC word GC_allocd_bytes_per_finalizer=GC_ALLOCD_BYTES_PER_FINALIZER;
#else
STATIC word GC_allocd_bytes_per_finalizer=10000;
#endif
GC_API void GC_CALL GC_set_allocd_bytes_per_finalizer(GC_word value)
{
GC_allocd_bytes_per_finalizer=value;
}
GC_API GC_word GC_CALL GC_get_allocd_bytes_per_finalizer(void)
{
return GC_allocd_bytes_per_finalizer;
}
static word last_fo_entries=0;
static word last_bytes_finalized=0;
GC_INNER GC_bool GC_collect_or_expand(word needed_blocks,
GC_bool ignore_off_page,
GC_bool retry)
{
GC_bool gc_not_stopped=TRUE;
word blocks_to_get;
IF_CANCEL(int cancel_state;)
GC_ASSERT(I_HOLD_LOCK());
DISABLE_CANCEL(cancel_state);
if (!GC_incremental&&!GC_dont_gc&&
((GC_dont_expand&&GC_bytes_allocd > 0)
||(GC_fo_entries > last_fo_entries
&&(last_bytes_finalized|GC_bytes_finalized)!=0
&&(GC_fo_entries - last_fo_entries)
*GC_allocd_bytes_per_finalizer > GC_bytes_allocd)
||GC_should_collect())){
gc_not_stopped=GC_try_to_collect_inner(
GC_bytes_allocd > 0&&(!GC_dont_expand||!retry)?
GC_default_stop_func:GC_never_stop_func);
if (gc_not_stopped==TRUE||!retry){
last_fo_entries=GC_fo_entries;
last_bytes_finalized=GC_bytes_finalized;
RESTORE_CANCEL(cancel_state);
return(TRUE);
}
}
blocks_to_get=(GC_heapsize - GC_heapsize_at_forced_unmap)
/(HBLKSIZE*GC_free_space_divisor)
+needed_blocks;
if (blocks_to_get > MAXHINCR){
word slop;
if (ignore_off_page){
slop=4;
} else {
slop=2*divHBLKSZ(BL_LIMIT);
if (slop > needed_blocks)slop=needed_blocks;
}
if (needed_blocks+slop > MAXHINCR){
blocks_to_get=needed_blocks+slop;
} else {
blocks_to_get=MAXHINCR;
}
if (blocks_to_get > divHBLKSZ(GC_WORD_MAX))
blocks_to_get=divHBLKSZ(GC_WORD_MAX);
}
if (!GC_expand_hp_inner(blocks_to_get)
&&(blocks_to_get==needed_blocks
||!GC_expand_hp_inner(needed_blocks))){
if (gc_not_stopped==FALSE){
GC_gcollect_inner();
GC_ASSERT(GC_bytes_allocd==0);
} else if (GC_fail_count++< GC_max_retries){
WARN("Out of Memory!Trying to continue...\n",0);
GC_gcollect_inner();
} else {
#if!defined(AMIGA)||!defined(GC_AMIGA_FASTALLOC)
WARN("Out of Memory!Heap size:%" WARN_PRIdPTR " MiB."
" Returning NULL!\n",(GC_heapsize - GC_unmapped_bytes)>>20);
#endif
RESTORE_CANCEL(cancel_state);
return(FALSE);
}
} else if (GC_fail_count){
GC_COND_LOG_PRINTF("Memory available again...\n");
}
RESTORE_CANCEL(cancel_state);
return(TRUE);
}
GC_INNER ptr_t GC_allocobj(size_t gran,int kind)
{
void**flh=&(GC_obj_kinds[kind].ok_freelist[gran]);
GC_bool tried_minor=FALSE;
GC_bool retry=FALSE;
GC_ASSERT(I_HOLD_LOCK());
if (gran==0)return(0);
while (*flh==0){
ENTER_GC();
#ifndef GC_DISABLE_INCREMENTAL
if (GC_incremental&&GC_time_limit!=GC_TIME_UNLIMITED){
GC_collect_a_little_inner(1);
}
#endif
GC_ASSERT(!GC_is_full_gc
||NULL==GC_obj_kinds[kind].ok_reclaim_list
||NULL==GC_obj_kinds[kind].ok_reclaim_list[gran]);
GC_continue_reclaim(gran,kind);
EXIT_GC();
#if defined(CPPCHECK)
GC_noop1((word)&flh);
#endif
if (NULL==*flh){
GC_new_hblk(gran,kind);
#if defined(CPPCHECK)
GC_noop1((word)&flh);
#endif
if (NULL==*flh){
ENTER_GC();
if (GC_incremental&&GC_time_limit==GC_TIME_UNLIMITED
&&!tried_minor){
GC_collect_a_little_inner(1);
tried_minor=TRUE;
} else {
if (!GC_collect_or_expand(1,FALSE,retry)){
EXIT_GC();
return(0);
}
retry=TRUE;
}
EXIT_GC();
}
}
}
GC_fail_count=0;
return (ptr_t)(*flh);
}
#ifndef MSWINCE
#include <errno.h>
#endif
#include <string.h>
#ifndef SHORT_DBG_HDRS
GC_INNER int GC_has_other_debug_info(ptr_t p)
{
ptr_t body=(ptr_t)((oh*)p+1);
word sz=GC_size(p);
if (HBLKPTR(p)!=HBLKPTR((ptr_t)body)
||sz < DEBUG_BYTES+EXTRA_BYTES){
return 0;
}
if (((oh*)p)->oh_sf!=(START_FLAG^(word)body)
&&((word*)p)[BYTES_TO_WORDS(sz)-1]!=(END_FLAG^(word)body)){
return 0;
}
if (((oh*)p)->oh_sz==sz){
return -1;
}
return 1;
}
#endif
#ifdef LINT2
long GC_random(void)
{
static unsigned seed=1;
seed=(seed*1103515245U+12345)&GC_RAND_MAX;
return (long)seed;
}
#endif
#ifdef KEEP_BACK_PTRS
#ifdef LINT2
#define RANDOM()GC_random()
#else
#include <stdlib.h>
#define GC_RAND_MAX RAND_MAX
#if defined(__GLIBC__)||defined(SOLARIS)||defined(HPUX)||defined(IRIX5)||defined(OSF1)
#define RANDOM()random()
#else
#define RANDOM()(long)rand()
#endif
#endif
GC_INNER void GC_store_back_pointer(ptr_t source,ptr_t dest)
{
if (GC_HAS_DEBUG_INFO(dest)){
#ifdef PARALLEL_MARK
AO_store((volatile AO_t*)&((oh*)dest)->oh_back_ptr,
(AO_t)HIDE_BACK_PTR(source));
#else
((oh*)dest)->oh_back_ptr=HIDE_BACK_PTR(source);
#endif
}
}
GC_INNER void GC_marked_for_finalization(ptr_t dest)
{
GC_store_back_pointer(MARKED_FOR_FINALIZATION,dest);
}
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;
ptr_t bp_base;
#ifdef LINT2
if (!hdr)ABORT("Invalid GC_get_back_ptr_info argument");
#endif
if (!GC_HAS_DEBUG_INFO((ptr_t)hdr))return GC_NO_SPACE;
bp=(ptr_t)GC_REVEAL_POINTER(hdr->oh_back_ptr);
if (MARKED_FOR_FINALIZATION==bp)return GC_FINALIZER_REFD;
if (MARKED_FROM_REGISTER==bp)return GC_REFD_FROM_REG;
if (NOT_MARKED==bp)return GC_UNREFERENCED;
#if ALIGNMENT==1
{
ptr_t alternate_ptr=bp+1;
ptr_t target=*(ptr_t*)bp;
ptr_t alternate_target=*(ptr_t*)alternate_ptr;
if ((word)alternate_target>=(word)GC_least_plausible_heap_addr
&&(word)alternate_target<=(word)GC_greatest_plausible_heap_addr
&&((word)target < (word)GC_least_plausible_heap_addr
||(word)target > (word)GC_greatest_plausible_heap_addr)){
bp=alternate_ptr;
}
}
#endif
bp_base=(ptr_t)GC_base(bp);
if (NULL==bp_base){
*base_p=bp;
*offset_p=0;
return GC_REFD_FROM_ROOT;
} else {
if (GC_HAS_DEBUG_INFO(bp_base))bp_base+=sizeof(oh);
*base_p=bp_base;
*offset_p=bp - bp_base;
return GC_REFD_FROM_HEAP;
}
}
GC_API void*GC_CALL GC_generate_random_heap_address(void)
{
size_t i;
word heap_offset=RANDOM();
if (GC_heapsize > GC_RAND_MAX){
heap_offset*=GC_RAND_MAX;
heap_offset+=RANDOM();
}
heap_offset%=GC_heapsize;
for (i=0;;++i){
size_t size;
if (i>=GC_n_heap_sects)
ABORT("GC_generate_random_heap_address:size inconsistency");
size=GC_heap_sects[i].hs_bytes;
if (heap_offset < size){
break;
} else {
heap_offset-=size;
}
}
return GC_heap_sects[i].hs_start+heap_offset;
}
GC_API void*GC_CALL GC_generate_random_valid_address(void)
{
ptr_t result;
ptr_t base;
do {
result=(ptr_t)GC_generate_random_heap_address();
base=(ptr_t)GC_base(result);
} while (NULL==base||!GC_is_marked(base));
return result;
}
GC_API void GC_CALL GC_print_backtrace(void*p)
{
void*current=p;
int i;
GC_ref_kind source;
size_t offset;
void*base;
GC_print_heap_obj((ptr_t)GC_base(current));
for (i=0;;++i){
source=GC_get_back_ptr_info(current,&base,&offset);
if (GC_UNREFERENCED==source){
GC_err_printf("Reference could not be found\n");
goto out;
}
if (GC_NO_SPACE==source){
GC_err_printf("No debug info in object:Can't find reference\n");
goto out;
}
GC_err_printf("Reachable via %d levels of pointers from ",i);
switch(source){
case GC_REFD_FROM_ROOT:
GC_err_printf("root at %p\n\n",base);
goto out;
case GC_REFD_FROM_REG:
GC_err_printf("root in register\n\n");
goto out;
case GC_FINALIZER_REFD:
GC_err_printf("list of finalizable objects\n\n");
goto out;
case GC_REFD_FROM_HEAP:
GC_err_printf("offset %ld in object:\n",(long)offset);
GC_print_heap_obj((ptr_t)GC_base(base));
break;
default:
GC_err_printf("INTERNAL ERROR:UNEXPECTED SOURCE!!!!\n");
goto out;
}
current=base;
}
out:;
}
GC_INNER void GC_generate_random_backtrace_no_gc(void)
{
void*current;
current=GC_generate_random_valid_address();
GC_printf("\n****Chosen address %p in object\n",current);
GC_print_backtrace(current);
}
GC_API void GC_CALL GC_generate_random_backtrace(void)
{
if (GC_try_to_collect(GC_never_stop_func)==0){
GC_err_printf("Cannot generate a backtrace:"
"garbage collection is disabled!\n");
return;
}
GC_generate_random_backtrace_no_gc();
}
#endif
#define CROSSES_HBLK(p,sz)(((word)((p)+sizeof(oh)+(sz)- 1)^(word)(p))>=HBLKSIZE)
GC_INNER void*GC_store_debug_info_inner(void*p,word sz GC_ATTR_UNUSED,
const char*string,int linenum)
{
word*result=(word*)((oh*)p+1);
GC_ASSERT(I_HOLD_LOCK());
GC_ASSERT(GC_size(p)>=sizeof(oh)+sz);
GC_ASSERT(!(SMALL_OBJ(sz)&&CROSSES_HBLK((ptr_t)p,sz)));
#ifdef KEEP_BACK_PTRS
((oh*)p)->oh_back_ptr=HIDE_BACK_PTR(NOT_MARKED);
#endif
#ifdef MAKE_BACK_GRAPH
((oh*)p)->oh_bg_ptr=HIDE_BACK_PTR((ptr_t)0);
#endif
((oh*)p)->oh_string=string;
((oh*)p)->oh_int=linenum;
#ifndef SHORT_DBG_HDRS
((oh*)p)->oh_sz=sz;
((oh*)p)->oh_sf=START_FLAG^(word)result;
((word*)p)[BYTES_TO_WORDS(GC_size(p))-1]=
result[SIMPLE_ROUNDED_UP_WORDS(sz)]=END_FLAG^(word)result;
#endif
return result;
}
static void*store_debug_info(void*p,size_t lb,
const char*fn,GC_EXTRA_PARAMS)
{
void*result;
DCL_LOCK_STATE;
if (NULL==p){
GC_err_printf("%s(%lu)returning NULL (%s:%d)\n",
fn,(unsigned long)lb,s,i);
return NULL;
}
LOCK();
if (!GC_debugging_started)
GC_start_debugging_inner();
ADD_CALL_CHAIN(p,ra);
result=GC_store_debug_info_inner(p,(word)lb,s,i);
UNLOCK();
return result;
}
#ifndef SHORT_DBG_HDRS
STATIC ptr_t GC_check_annotated_obj(oh*ohdr)
{
ptr_t body=(ptr_t)(ohdr+1);
word gc_sz=GC_size((ptr_t)ohdr);
if (ohdr->oh_sz+DEBUG_BYTES > gc_sz){
return((ptr_t)(&(ohdr->oh_sz)));
}
if (ohdr->oh_sf!=(START_FLAG^(word)body)){
return((ptr_t)(&(ohdr->oh_sf)));
}
if (((word*)ohdr)[BYTES_TO_WORDS(gc_sz)-1]!=(END_FLAG^(word)body)){
return (ptr_t)(&((word*)ohdr)[BYTES_TO_WORDS(gc_sz)-1]);
}
if (((word*)body)[SIMPLE_ROUNDED_UP_WORDS(ohdr->oh_sz)]
!=(END_FLAG^(word)body)){
return (ptr_t)(&((word*)body)[SIMPLE_ROUNDED_UP_WORDS(ohdr->oh_sz)]);
}
return(0);
}
#endif
STATIC GC_describe_type_fn GC_describe_type_fns[MAXOBJKINDS]={0};
GC_API void GC_CALL GC_register_describe_type_fn(int kind,
GC_describe_type_fn fn)
{
GC_describe_type_fns[kind]=fn;
}
#define GET_OH_LINENUM(ohdr)((int)(ohdr)->oh_int)
#ifndef SHORT_DBG_HDRS
#define IF_NOT_SHORTDBG_HDRS(x)x
#define COMMA_IFNOT_SHORTDBG_HDRS(x),x
#else
#define IF_NOT_SHORTDBG_HDRS(x)
#define COMMA_IFNOT_SHORTDBG_HDRS(x)
#endif
STATIC void GC_print_obj(ptr_t p)
{
oh*ohdr=(oh*)GC_base(p);
ptr_t q;
hdr*hhdr;
int kind;
const char*kind_str;
char buffer[GC_TYPE_DESCR_LEN+1];
GC_ASSERT(I_DONT_HOLD_LOCK());
#ifdef LINT2
if (!ohdr)ABORT("Invalid GC_print_obj argument");
#endif
q=(ptr_t)(ohdr+1);
hhdr=GC_find_header(q);
kind=hhdr->hb_obj_kind;
if (0!=GC_describe_type_fns[kind]&&GC_is_marked(ohdr)){
buffer[GC_TYPE_DESCR_LEN]=0;
(GC_describe_type_fns[kind])(q,buffer);
GC_ASSERT(buffer[GC_TYPE_DESCR_LEN]==0);
kind_str=buffer;
} else {
switch(kind){
case PTRFREE:
kind_str="PTRFREE";
break;
case NORMAL:
kind_str="NORMAL";
break;
case UNCOLLECTABLE:
kind_str="UNCOLLECTABLE";
break;
#ifdef GC_ATOMIC_UNCOLLECTABLE
case AUNCOLLECTABLE:
kind_str="ATOMIC_UNCOLLECTABLE";
break;
#endif
default:
kind_str=NULL;
}
}
if (NULL!=kind_str){
GC_err_printf("%p (%s:%d," IF_NOT_SHORTDBG_HDRS(" sz=%lu,")" %s)\n",
(void*)((ptr_t)ohdr+sizeof(oh)),
ohdr->oh_string,GET_OH_LINENUM(ohdr)
COMMA_IFNOT_SHORTDBG_HDRS((unsigned long)ohdr->oh_sz),
kind_str);
} else {
GC_err_printf("%p (%s:%d," IF_NOT_SHORTDBG_HDRS(" sz=%lu,")
" kind=%d descr=0x%lx)\n",
(void*)((ptr_t)ohdr+sizeof(oh)),
ohdr->oh_string,GET_OH_LINENUM(ohdr)
COMMA_IFNOT_SHORTDBG_HDRS((unsigned long)ohdr->oh_sz),
kind,(unsigned long)hhdr->hb_descr);
}
PRINT_CALL_CHAIN(ohdr);
}
STATIC void GC_debug_print_heap_obj_proc(ptr_t p)
{
GC_ASSERT(I_DONT_HOLD_LOCK());
if (GC_HAS_DEBUG_INFO(p)){
GC_print_obj(p);
} else {
GC_default_print_heap_obj_proc(p);
}
}
#ifndef SHORT_DBG_HDRS
STATIC void GC_print_smashed_obj(const char*msg,void*p,
ptr_t clobbered_addr)
{
oh*ohdr=(oh*)GC_base(p);
GC_ASSERT(I_DONT_HOLD_LOCK());
#ifdef LINT2
if (!ohdr)ABORT("Invalid GC_print_smashed_obj argument");
#endif
if ((word)clobbered_addr<=(word)(&ohdr->oh_sz)
||ohdr->oh_string==0){
GC_err_printf(
"%s %p in or near object at %p(<smashed>,appr. sz=%lu)\n",
msg,(void*)clobbered_addr,p,
(unsigned long)(GC_size((ptr_t)ohdr)- DEBUG_BYTES));
} else {
GC_err_printf("%s %p in or near object at %p (%s:%d,sz=%lu)\n",
msg,(void*)clobbered_addr,p,
(word)(ohdr->oh_string)< HBLKSIZE?"(smashed string)":
ohdr->oh_string[0]=='\0'?"EMPTY(smashed?)":
ohdr->oh_string,
GET_OH_LINENUM(ohdr),(unsigned long)(ohdr->oh_sz));
PRINT_CALL_CHAIN(ohdr);
}
}
STATIC void GC_check_heap_proc (void);
STATIC void GC_print_all_smashed_proc (void);
#else
STATIC void GC_do_nothing(void){}
#endif
GC_INNER void GC_start_debugging_inner(void)
{
GC_ASSERT(I_HOLD_LOCK());
#ifndef SHORT_DBG_HDRS
GC_check_heap=GC_check_heap_proc;
GC_print_all_smashed=GC_print_all_smashed_proc;
#else
GC_check_heap=GC_do_nothing;
GC_print_all_smashed=GC_do_nothing;
#endif
GC_print_heap_obj=GC_debug_print_heap_obj_proc;
GC_debugging_started=TRUE;
GC_register_displacement_inner((word)sizeof(oh));
#if defined(CPPCHECK)
GC_noop1(GC_debug_header_size);
#endif
}
const size_t GC_debug_header_size=sizeof(oh);
GC_API size_t GC_CALL GC_get_debug_header_size(void){
return sizeof(oh);
}
GC_API void GC_CALL GC_debug_register_displacement(size_t offset)
{
DCL_LOCK_STATE;
LOCK();
GC_register_displacement_inner(offset);
GC_register_displacement_inner((word)sizeof(oh)+offset);
UNLOCK();
}
#ifdef GC_ADD_CALLER
#if defined(HAVE_DLADDR)&&defined(GC_HAVE_RETURN_ADDR_PARENT)
#include <dlfcn.h>
STATIC void GC_caller_func_offset(word ad,const char**symp,int*offp)
{
Dl_info caller;
if (ad&&dladdr((void*)ad,&caller)&&caller.dli_sname!=NULL){
*symp=caller.dli_sname;
*offp=(int)((char*)ad - (char*)caller.dli_saddr);
}
if (NULL==*symp){
*symp="unknown";
}
}
#else
#define GC_caller_func_offset(ad,symp,offp)(void)(*(symp)="unknown")
#endif
#endif
GC_API GC_ATTR_MALLOC void*GC_CALL GC_debug_malloc(size_t lb,
GC_EXTRA_PARAMS)
{
void*result;
result=GC_malloc(SIZET_SAT_ADD(lb,DEBUG_BYTES));
#ifdef GC_ADD_CALLER
if (s==NULL){
GC_caller_func_offset(ra,&s,&i);
}
#endif
return store_debug_info(result,lb,"GC_debug_malloc",OPT_RA s,i);
}
GC_API GC_ATTR_MALLOC void*GC_CALL
GC_debug_malloc_ignore_off_page(size_t lb,GC_EXTRA_PARAMS)
{
void*result=GC_malloc_ignore_off_page(SIZET_SAT_ADD(lb,DEBUG_BYTES));
return store_debug_info(result,lb,"GC_debug_malloc_ignore_off_page",
OPT_RA s,i);
}
GC_API GC_ATTR_MALLOC void*GC_CALL
GC_debug_malloc_atomic_ignore_off_page(size_t lb,GC_EXTRA_PARAMS)
{
void*result=GC_malloc_atomic_ignore_off_page(
SIZET_SAT_ADD(lb,DEBUG_BYTES));
return store_debug_info(result,lb,
"GC_debug_malloc_atomic_ignore_off_page",
OPT_RA s,i);
}
STATIC void*GC_debug_generic_malloc(size_t lb,int knd,GC_EXTRA_PARAMS)
{
void*result=GC_generic_malloc(SIZET_SAT_ADD(lb,DEBUG_BYTES),knd);
return store_debug_info(result,lb,"GC_debug_generic_malloc",
OPT_RA s,i);
}
#ifdef DBG_HDRS_ALL
GC_INNER void*GC_debug_generic_malloc_inner(size_t lb,int k)
{
void*result;
GC_ASSERT(I_HOLD_LOCK());
result=GC_generic_malloc_inner(SIZET_SAT_ADD(lb,DEBUG_BYTES),k);
if (NULL==result){
GC_err_printf("GC internal allocation (%lu bytes)returning NULL\n",
(unsigned long)lb);
return(0);
}
if (!GC_debugging_started){
GC_start_debugging_inner();
}
ADD_CALL_CHAIN(result,GC_RETURN_ADDR);
return (GC_store_debug_info_inner(result,(word)lb,"INTERNAL",0));
}
GC_INNER void*GC_debug_generic_malloc_inner_ignore_off_page(size_t lb,
int k)
{
void*result;
GC_ASSERT(I_HOLD_LOCK());
result=GC_generic_malloc_inner_ignore_off_page(
SIZET_SAT_ADD(lb,DEBUG_BYTES),k);
if (NULL==result){
GC_err_printf("GC internal allocation (%lu bytes)returning NULL\n",
(unsigned long)lb);
return(0);
}
if (!GC_debugging_started){
GC_start_debugging_inner();
}
ADD_CALL_CHAIN(result,GC_RETURN_ADDR);
return (GC_store_debug_info_inner(result,(word)lb,"INTERNAL",0));
}
#endif
#ifndef CPPCHECK
GC_API void*GC_CALL GC_debug_malloc_stubborn(size_t lb,GC_EXTRA_PARAMS)
{
return GC_debug_malloc(lb,OPT_RA s,i);
}
GC_API void GC_CALL GC_debug_change_stubborn(
const void*p GC_ATTR_UNUSED){}
#endif
GC_API void GC_CALL GC_debug_end_stubborn_change(const void*p)
{
const void*q=GC_base_C(p);
if (NULL==q){
ABORT_ARG1("GC_debug_end_stubborn_change:bad arg",":%p",p);
}
GC_end_stubborn_change(q);
}
GC_API void GC_CALL GC_debug_ptr_store_and_dirty(void*p,const void*q)
{
*(void**)GC_is_visible(p)=GC_is_valid_displacement((void*)q);
GC_debug_end_stubborn_change(p);
REACHABLE_AFTER_DIRTY(q);
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_debug_malloc_atomic(size_t lb,
GC_EXTRA_PARAMS)
{
void*result=GC_malloc_atomic(SIZET_SAT_ADD(lb,DEBUG_BYTES));
return store_debug_info(result,lb,"GC_debug_malloc_atomic",
OPT_RA s,i);
}
GC_API GC_ATTR_MALLOC char*GC_CALL GC_debug_strdup(const char*str,
GC_EXTRA_PARAMS)
{
char*copy;
size_t lb;
if (str==NULL){
if (GC_find_leak)
GC_err_printf("strdup(NULL)behavior is undefined\n");
return NULL;
}
lb=strlen(str)+1;
copy=(char*)GC_debug_malloc_atomic(lb,OPT_RA s,i);
if (copy==NULL){
#ifndef MSWINCE
errno=ENOMEM;
#endif
return NULL;
}
BCOPY(str,copy,lb);
return copy;
}
GC_API GC_ATTR_MALLOC char*GC_CALL GC_debug_strndup(const char*str,
size_t size,GC_EXTRA_PARAMS)
{
char*copy;
size_t len=strlen(str);
if (len > size)
len=size;
copy=(char*)GC_debug_malloc_atomic(len+1,OPT_RA s,i);
if (copy==NULL){
#ifndef MSWINCE
errno=ENOMEM;
#endif
return NULL;
}
if (len > 0)
BCOPY(str,copy,len);
copy[len]='\0';
return copy;
}
#ifdef GC_REQUIRE_WCSDUP
#include <wchar.h>
GC_API GC_ATTR_MALLOC wchar_t*GC_CALL GC_debug_wcsdup(const wchar_t*str,
GC_EXTRA_PARAMS)
{
size_t lb=(wcslen(str)+1)*sizeof(wchar_t);
wchar_t*copy=(wchar_t*)GC_debug_malloc_atomic(lb,OPT_RA s,i);
if (copy==NULL){
#ifndef MSWINCE
errno=ENOMEM;
#endif
return NULL;
}
BCOPY(str,copy,lb);
return copy;
}
#endif
GC_API GC_ATTR_MALLOC void*GC_CALL GC_debug_malloc_uncollectable(size_t lb,
GC_EXTRA_PARAMS)
{
void*result=GC_malloc_uncollectable(
SIZET_SAT_ADD(lb,UNCOLLECTABLE_DEBUG_BYTES));
return store_debug_info(result,lb,"GC_debug_malloc_uncollectable",
OPT_RA s,i);
}
#ifdef GC_ATOMIC_UNCOLLECTABLE
GC_API GC_ATTR_MALLOC void*GC_CALL
GC_debug_malloc_atomic_uncollectable(size_t lb,GC_EXTRA_PARAMS)
{
void*result=GC_malloc_atomic_uncollectable(
SIZET_SAT_ADD(lb,UNCOLLECTABLE_DEBUG_BYTES));
return store_debug_info(result,lb,
"GC_debug_malloc_atomic_uncollectable",
OPT_RA s,i);
}
#endif
#ifndef GC_FREED_MEM_MARKER
#if CPP_WORDSZ==32
#define GC_FREED_MEM_MARKER 0xdeadbeef
#else
#define GC_FREED_MEM_MARKER GC_WORD_C(0xEFBEADDEdeadbeef)
#endif
#endif
GC_API void GC_CALL GC_debug_free(void*p)
{
ptr_t base;
if (0==p)return;
base=(ptr_t)GC_base(p);
if (NULL==base){
#if defined(REDIRECT_MALLOC)&&((defined(NEED_CALLINFO)&&defined(GC_HAVE_BUILTIN_BACKTRACE))||defined(GC_LINUX_THREADS)||defined(GC_SOLARIS_THREADS)||defined(MSWIN32))
if (!GC_is_heap_ptr(p))return;
#endif
ABORT_ARG1("Invalid pointer passed to free()",":%p",p);
}
if ((ptr_t)p - (ptr_t)base!=sizeof(oh)){
#if defined(REDIRECT_FREE)&&defined(USE_PROC_FOR_LIBRARIES)
#endif
GC_err_printf(
"GC_debug_free called on pointer %p w/o debugging info\n",p);
} else {
#ifndef SHORT_DBG_HDRS
ptr_t clobbered=GC_check_annotated_obj((oh*)base);
word sz=GC_size(base);
if (clobbered!=0){
GC_have_errors=TRUE;
if (((oh*)base)->oh_sz==sz){
GC_print_smashed_obj(
"GC_debug_free:found previously deallocated (?)object at",
p,clobbered);
return;
} else {
GC_print_smashed_obj("GC_debug_free:found smashed location at",
p,clobbered);
}
}
((oh*)base)->oh_sz=sz;
#endif
}
if (GC_find_leak
#ifndef SHORT_DBG_HDRS
&&((ptr_t)p - (ptr_t)base!=sizeof(oh)||!GC_findleak_delay_free)
#endif
){
GC_free(base);
} else {
hdr*hhdr=HDR(p);
if (hhdr->hb_obj_kind==UNCOLLECTABLE
#ifdef GC_ATOMIC_UNCOLLECTABLE
||hhdr->hb_obj_kind==AUNCOLLECTABLE
#endif
){
GC_free(base);
} else {
word i;
word sz=hhdr->hb_sz;
word obj_sz=BYTES_TO_WORDS(sz - sizeof(oh));
for (i=0;i < obj_sz;++i)
((word*)p)[i]=GC_FREED_MEM_MARKER;
GC_ASSERT((word*)p+i==(word*)(base+sz));
LOCK();
GC_bytes_freed+=sz;
UNLOCK();
}
}
}
#if defined(THREADS)&&defined(DBG_HDRS_ALL)
GC_INNER void GC_debug_free_inner(void*p)
{
ptr_t base=(ptr_t)GC_base(p);
GC_ASSERT((ptr_t)p - (ptr_t)base==sizeof(oh));
#ifdef LINT2
if (!base)ABORT("Invalid GC_debug_free_inner argument");
#endif
#ifndef SHORT_DBG_HDRS
((oh*)base)->oh_sz=GC_size(base);
#endif
GC_free_inner(base);
}
#endif
GC_API void*GC_CALL GC_debug_realloc(void*p,size_t lb,GC_EXTRA_PARAMS)
{
void*base;
void*result;
hdr*hhdr;
if (p==0){
return GC_debug_malloc(lb,OPT_RA s,i);
}
if (0==lb){
GC_debug_free(p);
return NULL;
}
#ifdef GC_ADD_CALLER
if (s==NULL){
GC_caller_func_offset(ra,&s,&i);
}
#endif
base=GC_base(p);
if (base==0){
ABORT_ARG1("Invalid pointer passed to realloc()",":%p",p);
}
if ((ptr_t)p - (ptr_t)base!=sizeof(oh)){
GC_err_printf(
"GC_debug_realloc called on pointer %p w/o debugging info\n",p);
return(GC_realloc(p,lb));
}
hhdr=HDR(base);
switch (hhdr->hb_obj_kind){
case NORMAL:
result=GC_debug_malloc(lb,OPT_RA s,i);
break;
case PTRFREE:
result=GC_debug_malloc_atomic(lb,OPT_RA s,i);
break;
case UNCOLLECTABLE:
result=GC_debug_malloc_uncollectable(lb,OPT_RA s,i);
break;
#ifdef GC_ATOMIC_UNCOLLECTABLE
case AUNCOLLECTABLE:
result=GC_debug_malloc_atomic_uncollectable(lb,OPT_RA s,i);
break;
#endif
default:
result=NULL;
ABORT_RET("GC_debug_realloc:encountered bad kind");
}
if (result!=NULL){
size_t old_sz;
#ifdef SHORT_DBG_HDRS
old_sz=GC_size(base)- sizeof(oh);
#else
old_sz=((oh*)base)->oh_sz;
#endif
if (old_sz > 0)
BCOPY(p,result,old_sz < lb?old_sz:lb);
GC_debug_free(p);
}
return(result);
}
GC_API GC_ATTR_MALLOC void*GC_CALL
GC_debug_generic_or_special_malloc(size_t lb,int knd,GC_EXTRA_PARAMS)
{
switch (knd){
case PTRFREE:
return GC_debug_malloc_atomic(lb,OPT_RA s,i);
case NORMAL:
return GC_debug_malloc(lb,OPT_RA s,i);
case UNCOLLECTABLE:
return GC_debug_malloc_uncollectable(lb,OPT_RA s,i);
#ifdef GC_ATOMIC_UNCOLLECTABLE
case AUNCOLLECTABLE:
return GC_debug_malloc_atomic_uncollectable(lb,OPT_RA s,i);
#endif
default:
return GC_debug_generic_malloc(lb,knd,OPT_RA s,i);
}
}
#ifndef SHORT_DBG_HDRS
#ifndef MAX_SMASHED
#define MAX_SMASHED 20
#endif
STATIC ptr_t GC_smashed[MAX_SMASHED]={0};
STATIC unsigned GC_n_smashed=0;
STATIC void GC_add_smashed(ptr_t smashed)
{
GC_ASSERT(GC_is_marked(GC_base(smashed)));
GC_smashed[GC_n_smashed]=smashed;
if (GC_n_smashed < MAX_SMASHED - 1)++GC_n_smashed;
GC_have_errors=TRUE;
}
STATIC void GC_print_all_smashed_proc(void)
{
unsigned i;
GC_ASSERT(I_DONT_HOLD_LOCK());
if (GC_n_smashed==0)return;
GC_err_printf("GC_check_heap_block:found %u smashed heap objects:\n",
GC_n_smashed);
for (i=0;i < GC_n_smashed;++i){
ptr_t base=(ptr_t)GC_base(GC_smashed[i]);
#ifdef LINT2
if (!base)ABORT("Invalid GC_smashed element");
#endif
GC_print_smashed_obj("",base+sizeof(oh),GC_smashed[i]);
GC_smashed[i]=0;
}
GC_n_smashed=0;
}
STATIC void GC_check_heap_block(struct hblk*hbp,word dummy GC_ATTR_UNUSED)
{
struct hblkhdr*hhdr=HDR(hbp);
word sz=hhdr->hb_sz;
word bit_no;
char*p,*plim;
p=hbp->hb_body;
if (sz > MAXOBJBYTES){
plim=p;
} else {
plim=hbp->hb_body+HBLKSIZE - sz;
}
for (bit_no=0;(word)p<=(word)plim;
bit_no+=MARK_BIT_OFFSET(sz),p+=sz){
if (mark_bit_from_hdr(hhdr,bit_no)&&GC_HAS_DEBUG_INFO((ptr_t)p)){
ptr_t clobbered=GC_check_annotated_obj((oh*)p);
if (clobbered!=0)
GC_add_smashed(clobbered);
}
}
}
STATIC void GC_check_heap_proc(void)
{
GC_STATIC_ASSERT((sizeof(oh)&(GRANULE_BYTES - 1))==0);
GC_apply_to_all_blocks(GC_check_heap_block,0);
}
GC_INNER GC_bool GC_check_leaked(ptr_t base)
{
word i;
word obj_sz;
word*p;
if (
#if defined(KEEP_BACK_PTRS)||defined(MAKE_BACK_GRAPH)
(*(word*)base&1)!=0&&
#endif
GC_has_other_debug_info(base)>=0)
return TRUE;
p=(word*)(base+sizeof(oh));
obj_sz=BYTES_TO_WORDS(HDR(base)->hb_sz - sizeof(oh));
for (i=0;i < obj_sz;++i)
if (p[i]!=GC_FREED_MEM_MARKER){
GC_set_mark_bit(base);
GC_add_smashed((ptr_t)(&p[i]));
break;
}
return FALSE;
}
#endif
#ifndef GC_NO_FINALIZATION
struct closure {
GC_finalization_proc cl_fn;
void*cl_data;
};
STATIC void*GC_make_closure(GC_finalization_proc fn,void*data)
{
struct closure*result=
#ifdef DBG_HDRS_ALL
(struct closure*)GC_debug_malloc(sizeof (struct closure),
GC_EXTRAS);
#else
(struct closure*)GC_malloc(sizeof (struct closure));
#endif
if (result!=0){
result->cl_fn=fn;
result->cl_data=data;
}
return((void*)result);
}
STATIC void GC_CALLBACK GC_debug_invoke_finalizer(void*obj,void*data)
{
struct closure*cl=(struct closure*)data;
(*(cl->cl_fn))((void*)((char*)obj+sizeof(oh)),cl->cl_data);
}
#define OFN_UNSET ((GC_finalization_proc)~(signed_word)0)
static void store_old(void*obj,GC_finalization_proc my_old_fn,
struct closure*my_old_cd,GC_finalization_proc*ofn,
void**ocd)
{
if (0!=my_old_fn){
if (my_old_fn==OFN_UNSET){
return;
}
if (my_old_fn!=GC_debug_invoke_finalizer){
GC_err_printf("Debuggable object at %p had a non-debug finalizer\n",
obj);
} else {
if (ofn)*ofn=my_old_cd->cl_fn;
if (ocd)*ocd=my_old_cd->cl_data;
}
} else {
if (ofn)*ofn=0;
if (ocd)*ocd=0;
}
}
GC_API void GC_CALL GC_debug_register_finalizer(void*obj,
GC_finalization_proc fn,
void*cd,GC_finalization_proc*ofn,
void**ocd)
{
GC_finalization_proc my_old_fn=OFN_UNSET;
void*my_old_cd;
ptr_t base=(ptr_t)GC_base(obj);
if (NULL==base){
if (ocd)*ocd=0;
if (ofn)*ofn=0;
return;
}
if ((ptr_t)obj - base!=sizeof(oh)){
GC_err_printf("GC_debug_register_finalizer called with"
" non-base-pointer %p\n",obj);
}
if (0==fn){
GC_register_finalizer(base,0,0,&my_old_fn,&my_old_cd);
} else {
cd=GC_make_closure(fn,cd);
if (cd==0)return;
GC_register_finalizer(base,GC_debug_invoke_finalizer,
cd,&my_old_fn,&my_old_cd);
}
store_old(obj,my_old_fn,(struct closure*)my_old_cd,ofn,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_finalization_proc my_old_fn=OFN_UNSET;
void*my_old_cd;
ptr_t base=(ptr_t)GC_base(obj);
if (NULL==base){
if (ocd)*ocd=0;
if (ofn)*ofn=0;
return;
}
if ((ptr_t)obj - base!=sizeof(oh)){
GC_err_printf("GC_debug_register_finalizer_no_order called with"
" non-base-pointer %p\n",obj);
}
if (0==fn){
GC_register_finalizer_no_order(base,0,0,&my_old_fn,&my_old_cd);
} else {
cd=GC_make_closure(fn,cd);
if (cd==0)return;
GC_register_finalizer_no_order(base,GC_debug_invoke_finalizer,
cd,&my_old_fn,&my_old_cd);
}
store_old(obj,my_old_fn,(struct closure*)my_old_cd,ofn,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_finalization_proc my_old_fn=OFN_UNSET;
void*my_old_cd;
ptr_t base=(ptr_t)GC_base(obj);
if (NULL==base){
if (ocd)*ocd=0;
if (ofn)*ofn=0;
return;
}
if ((ptr_t)obj - base!=sizeof(oh)){
GC_err_printf("GC_debug_register_finalizer_unreachable called with"
" non-base-pointer %p\n",obj);
}
if (0==fn){
GC_register_finalizer_unreachable(base,0,0,&my_old_fn,&my_old_cd);
} else {
cd=GC_make_closure(fn,cd);
if (cd==0)return;
GC_register_finalizer_unreachable(base,GC_debug_invoke_finalizer,
cd,&my_old_fn,&my_old_cd);
}
store_old(obj,my_old_fn,(struct closure*)my_old_cd,ofn,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_finalization_proc my_old_fn=OFN_UNSET;
void*my_old_cd;
ptr_t base=(ptr_t)GC_base(obj);
if (NULL==base){
if (ocd)*ocd=0;
if (ofn)*ofn=0;
return;
}
if ((ptr_t)obj - base!=sizeof(oh)){
GC_err_printf("GC_debug_register_finalizer_ignore_self called with"
" non-base-pointer %p\n",obj);
}
if (0==fn){
GC_register_finalizer_ignore_self(base,0,0,&my_old_fn,&my_old_cd);
} else {
cd=GC_make_closure(fn,cd);
if (cd==0)return;
GC_register_finalizer_ignore_self(base,GC_debug_invoke_finalizer,
cd,&my_old_fn,&my_old_cd);
}
store_old(obj,my_old_fn,(struct closure*)my_old_cd,ofn,ocd);
}
#endif
GC_API GC_ATTR_MALLOC void*GC_CALL GC_debug_malloc_replacement(size_t lb)
{
return GC_debug_malloc(lb,GC_DBG_EXTRAS);
}
GC_API void*GC_CALL GC_debug_realloc_replacement(void*p,size_t lb)
{
return GC_debug_realloc(p,lb,GC_DBG_EXTRAS);
}
#ifndef GC_NO_FINALIZATION
#ifndef GC_JAVAXFC_H
#define GC_JAVAXFC_H
#ifndef GC_H
#endif
#ifdef __cplusplus
extern "C" {
#endif
GC_API void GC_CALL GC_finalize_all(void);
#ifdef GC_THREADS
#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
#ifdef __cplusplus
}
#endif
#endif
typedef void (*finalization_mark_proc)(ptr_t);
#define HASH3(addr,size,log_size)((((word)(addr)>>3)^((word)(addr)>>(3+(log_size))))&((size)- 1))
#define HASH2(addr,log_size)HASH3(addr,(word)1<<(log_size),log_size)
struct hash_chain_entry {
word hidden_key;
struct hash_chain_entry*next;
};
struct disappearing_link {
struct hash_chain_entry prolog;
#define dl_hidden_link prolog.hidden_key
#define dl_next(x)(struct disappearing_link*)((x)->prolog.next)
#define dl_set_next(x,y)(void)((x)->prolog.next=(struct hash_chain_entry*)(y))
word dl_hidden_obj;
};
struct finalizable_object {
struct hash_chain_entry prolog;
#define fo_hidden_base prolog.hidden_key
#define fo_next(x)(struct finalizable_object*)((x)->prolog.next)
#define fo_set_next(x,y)((x)->prolog.next=(struct hash_chain_entry*)(y))
GC_finalization_proc fo_fn;
ptr_t fo_client_data;
word fo_object_size;
finalization_mark_proc fo_mark_proc;
};
#ifdef AO_HAVE_store
#define SET_FINALIZE_NOW(fo)AO_store((volatile AO_t*)&GC_fnlz_roots.finalize_now,(AO_t)(fo))
#else
#define SET_FINALIZE_NOW(fo)(void)(GC_fnlz_roots.finalize_now=(fo))
#endif
GC_API void GC_CALL GC_push_finalizer_structures(void)
{
GC_ASSERT((word)(&GC_dl_hashtbl.head)% sizeof(word)==0);
GC_ASSERT((word)(&GC_fnlz_roots)% sizeof(word)==0);
#ifndef GC_LONG_REFS_NOT_NEEDED
GC_ASSERT((word)(&GC_ll_hashtbl.head)% sizeof(word)==0);
GC_PUSH_ALL_SYM(GC_ll_hashtbl.head);
#endif
GC_PUSH_ALL_SYM(GC_dl_hashtbl.head);
GC_PUSH_ALL_SYM(GC_fnlz_roots);
}
#ifndef GC_ON_GROW_LOG_SIZE_MIN
#define GC_ON_GROW_LOG_SIZE_MIN CPP_LOG_HBLKSIZE
#endif
STATIC void GC_grow_table(struct hash_chain_entry***table,
unsigned*log_size_ptr,word*entries_ptr)
{
word i;
struct hash_chain_entry*p;
unsigned log_old_size=*log_size_ptr;
unsigned log_new_size=log_old_size+1;
word old_size=*table==NULL?0:(word)1<<log_old_size;
word new_size=(word)1<<log_new_size;
struct hash_chain_entry**new_table;
GC_ASSERT(I_HOLD_LOCK());
if (log_old_size>=GC_ON_GROW_LOG_SIZE_MIN&&!GC_incremental){
IF_CANCEL(int cancel_state;)
DISABLE_CANCEL(cancel_state);
(void)GC_try_to_collect_inner(GC_never_stop_func);
RESTORE_CANCEL(cancel_state);
if (*entries_ptr < ((word)1<<log_old_size)- (*entries_ptr>>2))
return;
}
new_table=(struct hash_chain_entry**)
GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE(
(size_t)new_size*sizeof(struct hash_chain_entry*),
NORMAL);
if (new_table==0){
if (*table==0){
ABORT("Insufficient space for initial table allocation");
} else {
return;
}
}
for (i=0;i < old_size;i++){
p=(*table)[i];
while (p!=0){
ptr_t real_key=(ptr_t)GC_REVEAL_POINTER(p->hidden_key);
struct hash_chain_entry*next=p->next;
size_t new_hash=HASH3(real_key,new_size,log_new_size);
p->next=new_table[new_hash];
GC_dirty(p);
new_table[new_hash]=p;
p=next;
}
}
*log_size_ptr=log_new_size;
*table=new_table;
GC_dirty(new_table);
}
GC_API int GC_CALL GC_register_disappearing_link(void**link)
{
ptr_t base;
base=(ptr_t)GC_base(link);
if (base==0)
ABORT("Bad arg to GC_register_disappearing_link");
return(GC_general_register_disappearing_link(link,base));
}
STATIC int GC_register_disappearing_link_inner(
struct dl_hashtbl_s*dl_hashtbl,void**link,
const void*obj,const char*tbl_log_name)
{
struct disappearing_link*curr_dl;
size_t index;
struct disappearing_link*new_dl;
DCL_LOCK_STATE;
if (EXPECT(GC_find_leak,FALSE))return GC_UNIMPLEMENTED;
LOCK();
GC_ASSERT(obj!=NULL&&GC_base_C(obj)==obj);
if (EXPECT(NULL==dl_hashtbl->head,FALSE)
||EXPECT(dl_hashtbl->entries
> ((word)1<<dl_hashtbl->log_size),FALSE)){
GC_grow_table((struct hash_chain_entry***)&dl_hashtbl->head,
&dl_hashtbl->log_size,&dl_hashtbl->entries);
GC_COND_LOG_PRINTF("Grew %s table to %u entries\n",tbl_log_name,
1U<<dl_hashtbl->log_size);
}
index=HASH2(link,dl_hashtbl->log_size);
for (curr_dl=dl_hashtbl->head[index];curr_dl!=0;
curr_dl=dl_next(curr_dl)){
if (curr_dl->dl_hidden_link==GC_HIDE_POINTER(link)){
curr_dl->dl_hidden_obj=GC_HIDE_POINTER(obj);
UNLOCK();
return GC_DUPLICATE;
}
}
new_dl=(struct disappearing_link*)
GC_INTERNAL_MALLOC(sizeof(struct disappearing_link),NORMAL);
if (0==new_dl){
GC_oom_func oom_fn=GC_oom_fn;
UNLOCK();
new_dl=(struct disappearing_link*)
(*oom_fn)(sizeof(struct disappearing_link));
if (0==new_dl){
return GC_NO_MEMORY;
}
LOCK();
index=HASH2(link,dl_hashtbl->log_size);
for (curr_dl=dl_hashtbl->head[index];curr_dl!=0;
curr_dl=dl_next(curr_dl)){
if (curr_dl->dl_hidden_link==GC_HIDE_POINTER(link)){
curr_dl->dl_hidden_obj=GC_HIDE_POINTER(obj);
UNLOCK();
#ifndef DBG_HDRS_ALL
GC_free((void*)new_dl);
#endif
return GC_DUPLICATE;
}
}
}
new_dl->dl_hidden_obj=GC_HIDE_POINTER(obj);
new_dl->dl_hidden_link=GC_HIDE_POINTER(link);
dl_set_next(new_dl,dl_hashtbl->head[index]);
GC_dirty(new_dl);
dl_hashtbl->head[index]=new_dl;
dl_hashtbl->entries++;
GC_dirty(dl_hashtbl->head+index);
UNLOCK();
return GC_SUCCESS;
}
GC_API int GC_CALL GC_general_register_disappearing_link(void**link,
const void*obj)
{
if (((word)link&(ALIGNMENT-1))!=0||!NONNULL_ARG_NOT_NULL(link))
ABORT("Bad arg to GC_general_register_disappearing_link");
return GC_register_disappearing_link_inner(&GC_dl_hashtbl,link,obj,
"dl");
}
#ifdef DBG_HDRS_ALL
#define FREE_DL_ENTRY(curr_dl)dl_set_next(curr_dl,NULL)
#else
#define FREE_DL_ENTRY(curr_dl)GC_free(curr_dl)
#endif
GC_INLINE struct disappearing_link*GC_unregister_disappearing_link_inner(
struct dl_hashtbl_s*dl_hashtbl,void**link)
{
struct disappearing_link*curr_dl;
struct disappearing_link*prev_dl=NULL;
size_t index;
GC_ASSERT(I_HOLD_LOCK());
if (EXPECT(NULL==dl_hashtbl->head,FALSE))return NULL;
index=HASH2(link,dl_hashtbl->log_size);
for (curr_dl=dl_hashtbl->head[index];curr_dl;
curr_dl=dl_next(curr_dl)){
if (curr_dl->dl_hidden_link==GC_HIDE_POINTER(link)){
if (NULL==prev_dl){
dl_hashtbl->head[index]=dl_next(curr_dl);
GC_dirty(dl_hashtbl->head+index);
} else {
dl_set_next(prev_dl,dl_next(curr_dl));
GC_dirty(prev_dl);
}
dl_hashtbl->entries--;
break;
}
prev_dl=curr_dl;
}
return curr_dl;
}
GC_API int GC_CALL GC_unregister_disappearing_link(void**link)
{
struct disappearing_link*curr_dl;
DCL_LOCK_STATE;
if (((word)link&(ALIGNMENT-1))!=0)return(0);
LOCK();
curr_dl=GC_unregister_disappearing_link_inner(&GC_dl_hashtbl,link);
UNLOCK();
if (NULL==curr_dl)return 0;
FREE_DL_ENTRY(curr_dl);
return 1;
}
#ifndef GC_TOGGLE_REFS_NOT_NEEDED
typedef union toggle_ref_u GCToggleRef;
STATIC GC_toggleref_func GC_toggleref_callback=0;
GC_INNER void GC_process_togglerefs(void)
{
size_t i;
size_t new_size=0;
GC_bool needs_barrier=FALSE;
GC_ASSERT(I_HOLD_LOCK());
for (i=0;i < GC_toggleref_array_size;++i){
GCToggleRef r=GC_toggleref_arr[i];
void*obj=r.strong_ref;
if (((word)obj&1)!=0){
obj=GC_REVEAL_POINTER(r.weak_ref);
}
if (NULL==obj){
continue;
}
switch (GC_toggleref_callback(obj)){
case GC_TOGGLE_REF_DROP:
break;
case GC_TOGGLE_REF_STRONG:
GC_toggleref_arr[new_size++].strong_ref=obj;
needs_barrier=TRUE;
break;
case GC_TOGGLE_REF_WEAK:
GC_toggleref_arr[new_size++].weak_ref=GC_HIDE_POINTER(obj);
break;
default:
ABORT("Bad toggle-ref status returned by callback");
}
}
if (new_size < GC_toggleref_array_size){
BZERO(&GC_toggleref_arr[new_size],
(GC_toggleref_array_size - new_size)*sizeof(GCToggleRef));
GC_toggleref_array_size=new_size;
}
if (needs_barrier)
GC_dirty(GC_toggleref_arr);
}
STATIC void GC_normal_finalize_mark_proc(ptr_t);
static void push_and_mark_object(void*p)
{
GC_normal_finalize_mark_proc((ptr_t)p);
while (!GC_mark_stack_empty()){
MARK_FROM_MARK_STACK();
}
GC_set_mark_bit(p);
if (GC_mark_state!=MS_NONE){
while (!GC_mark_some(0)){
}
}
}
STATIC void GC_mark_togglerefs(void)
{
size_t i;
if (NULL==GC_toggleref_arr)
return;
GC_set_mark_bit(GC_toggleref_arr);
for (i=0;i < GC_toggleref_array_size;++i){
void*obj=GC_toggleref_arr[i].strong_ref;
if (obj!=NULL&&((word)obj&1)==0){
push_and_mark_object(obj);
}
}
}
STATIC void GC_clear_togglerefs(void)
{
size_t i;
for (i=0;i < GC_toggleref_array_size;++i){
if ((GC_toggleref_arr[i].weak_ref&1)!=0){
if (!GC_is_marked(GC_REVEAL_POINTER(GC_toggleref_arr[i].weak_ref))){
GC_toggleref_arr[i].weak_ref=0;
} else {
}
}
}
}
GC_API void GC_CALL GC_set_toggleref_func(GC_toggleref_func fn)
{
DCL_LOCK_STATE;
LOCK();
GC_toggleref_callback=fn;
UNLOCK();
}
GC_API GC_toggleref_func GC_CALL GC_get_toggleref_func(void)
{
GC_toggleref_func fn;
DCL_LOCK_STATE;
LOCK();
fn=GC_toggleref_callback;
UNLOCK();
return fn;
}
static GC_bool ensure_toggleref_capacity(size_t capacity_inc)
{
GC_ASSERT(I_HOLD_LOCK());
if (NULL==GC_toggleref_arr){
GC_toggleref_array_capacity=32;
GC_toggleref_arr=(GCToggleRef*)GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE(
GC_toggleref_array_capacity*sizeof(GCToggleRef),
NORMAL);
if (NULL==GC_toggleref_arr)
return FALSE;
}
if (GC_toggleref_array_size+capacity_inc
>=GC_toggleref_array_capacity){
GCToggleRef*new_array;
while (GC_toggleref_array_capacity
< GC_toggleref_array_size+capacity_inc){
GC_toggleref_array_capacity*=2;
if ((GC_toggleref_array_capacity
&((size_t)1<<(sizeof(size_t)*8 - 1)))!=0)
return FALSE;
}
new_array=(GCToggleRef*)GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE(
GC_toggleref_array_capacity*sizeof(GCToggleRef),
NORMAL);
if (NULL==new_array)
return FALSE;
if (EXPECT(GC_toggleref_array_size > 0,TRUE))
BCOPY(GC_toggleref_arr,new_array,
GC_toggleref_array_size*sizeof(GCToggleRef));
GC_INTERNAL_FREE(GC_toggleref_arr);
GC_toggleref_arr=new_array;
}
return TRUE;
}
GC_API int GC_CALL GC_toggleref_add(void*obj,int is_strong_ref)
{
int res=GC_SUCCESS;
DCL_LOCK_STATE;
GC_ASSERT(NONNULL_ARG_NOT_NULL(obj));
LOCK();
if (GC_toggleref_callback!=0){
if (!ensure_toggleref_capacity(1)){
res=GC_NO_MEMORY;
} else {
GC_toggleref_arr[GC_toggleref_array_size].strong_ref=
is_strong_ref?obj:(void*)GC_HIDE_POINTER(obj);
if (is_strong_ref)
GC_dirty(GC_toggleref_arr+GC_toggleref_array_size);
GC_toggleref_array_size++;
}
}
UNLOCK();
return res;
}
#endif
STATIC GC_await_finalize_proc GC_object_finalized_proc=0;
GC_API void GC_CALL GC_set_await_finalize_proc(GC_await_finalize_proc fn)
{
DCL_LOCK_STATE;
LOCK();
GC_object_finalized_proc=fn;
UNLOCK();
}
GC_API GC_await_finalize_proc GC_CALL GC_get_await_finalize_proc(void)
{
GC_await_finalize_proc fn;
DCL_LOCK_STATE;
LOCK();
fn=GC_object_finalized_proc;
UNLOCK();
return fn;
}
#ifndef GC_LONG_REFS_NOT_NEEDED
GC_API int GC_CALL GC_register_long_link(void**link,const void*obj)
{
if (((word)link&(ALIGNMENT-1))!=0||!NONNULL_ARG_NOT_NULL(link))
ABORT("Bad arg to GC_register_long_link");
return GC_register_disappearing_link_inner(&GC_ll_hashtbl,link,obj,
"long dl");
}
GC_API int GC_CALL GC_unregister_long_link(void**link)
{
struct disappearing_link*curr_dl;
DCL_LOCK_STATE;
if (((word)link&(ALIGNMENT-1))!=0)return(0);
LOCK();
curr_dl=GC_unregister_disappearing_link_inner(&GC_ll_hashtbl,link);
UNLOCK();
if (NULL==curr_dl)return 0;
FREE_DL_ENTRY(curr_dl);
return 1;
}
#endif
#ifndef GC_MOVE_DISAPPEARING_LINK_NOT_NEEDED
STATIC int GC_move_disappearing_link_inner(
struct dl_hashtbl_s*dl_hashtbl,
void**link,void**new_link)
{
struct disappearing_link*curr_dl,*new_dl;
struct disappearing_link*prev_dl=NULL;
size_t curr_index,new_index;
word curr_hidden_link,new_hidden_link;
GC_ASSERT(I_HOLD_LOCK());
if (EXPECT(NULL==dl_hashtbl->head,FALSE))return GC_NOT_FOUND;
curr_index=HASH2(link,dl_hashtbl->log_size);
curr_hidden_link=GC_HIDE_POINTER(link);
for (curr_dl=dl_hashtbl->head[curr_index];curr_dl;
curr_dl=dl_next(curr_dl)){
if (curr_dl->dl_hidden_link==curr_hidden_link)
break;
prev_dl=curr_dl;
}
if (EXPECT(NULL==curr_dl,FALSE)){
return GC_NOT_FOUND;
} else if (link==new_link){
return GC_SUCCESS;
}
new_index=HASH2(new_link,dl_hashtbl->log_size);
new_hidden_link=GC_HIDE_POINTER(new_link);
for (new_dl=dl_hashtbl->head[new_index];new_dl;
new_dl=dl_next(new_dl)){
if (new_dl->dl_hidden_link==new_hidden_link){
return GC_DUPLICATE;
}
}
if (NULL==prev_dl){
dl_hashtbl->head[curr_index]=dl_next(curr_dl);
} else {
dl_set_next(prev_dl,dl_next(curr_dl));
GC_dirty(prev_dl);
}
curr_dl->dl_hidden_link=new_hidden_link;
dl_set_next(curr_dl,dl_hashtbl->head[new_index]);
dl_hashtbl->head[new_index]=curr_dl;
GC_dirty(curr_dl);
GC_dirty(dl_hashtbl->head);
return GC_SUCCESS;
}
GC_API int GC_CALL GC_move_disappearing_link(void**link,void**new_link)
{
int result;
DCL_LOCK_STATE;
if (((word)new_link&(ALIGNMENT-1))!=0
||!NONNULL_ARG_NOT_NULL(new_link))
ABORT("Bad new_link arg to GC_move_disappearing_link");
if (((word)link&(ALIGNMENT-1))!=0)
return GC_NOT_FOUND;
LOCK();
result=GC_move_disappearing_link_inner(&GC_dl_hashtbl,link,new_link);
UNLOCK();
return result;
}
#ifndef GC_LONG_REFS_NOT_NEEDED
GC_API int GC_CALL GC_move_long_link(void**link,void**new_link)
{
int result;
DCL_LOCK_STATE;
if (((word)new_link&(ALIGNMENT-1))!=0
||!NONNULL_ARG_NOT_NULL(new_link))
ABORT("Bad new_link arg to GC_move_long_link");
if (((word)link&(ALIGNMENT-1))!=0)
return GC_NOT_FOUND;
LOCK();
result=GC_move_disappearing_link_inner(&GC_ll_hashtbl,link,new_link);
UNLOCK();
return result;
}
#endif
#endif
STATIC void GC_normal_finalize_mark_proc(ptr_t p)
{
#if defined(_MSC_VER)&&defined(I386)
hdr*hhdr=HDR(p);
#define mark_stack_top GC_mark_stack_top
mse*mark_stack_limit=GC_mark_stack+GC_mark_stack_size;
word descr=hhdr->hb_descr;
if (descr!=0){
mark_stack_top++;
if ((word)mark_stack_top>=(word)mark_stack_limit){
mark_stack_top=GC_signal_mark_stack_overflow(mark_stack_top);
}
mark_stack_top->mse_start=p;
mark_stack_top->mse_descr.w=descr;
}
#undef mark_stack_top
#else
GC_mark_stack_top=GC_push_obj(p,HDR(p),GC_mark_stack_top,
GC_mark_stack+GC_mark_stack_size);
#endif
}
STATIC void GC_ignore_self_finalize_mark_proc(ptr_t p)
{
hdr*hhdr=HDR(p);
word descr=hhdr->hb_descr;
ptr_t q;
ptr_t scan_limit;
ptr_t target_limit=p+hhdr->hb_sz - 1;
if ((descr&GC_DS_TAGS)==GC_DS_LENGTH){
scan_limit=p+descr - sizeof(word);
} else {
scan_limit=target_limit+1 - sizeof(word);
}
for (q=p;(word)q<=(word)scan_limit;q+=ALIGNMENT){
word r=*(word*)q;
if (r < (word)p||r > (word)target_limit){
GC_PUSH_ONE_HEAP(r,q,GC_mark_stack_top);
}
}
}
STATIC void GC_null_finalize_mark_proc(ptr_t p GC_ATTR_UNUSED){}
STATIC void GC_unreachable_finalize_mark_proc(ptr_t p)
{
GC_normal_finalize_mark_proc(p);
}
STATIC void GC_register_finalizer_inner(void*obj,
GC_finalization_proc fn,void*cd,
GC_finalization_proc*ofn,void**ocd,
finalization_mark_proc mp)
{
struct finalizable_object*curr_fo;
size_t index;
struct finalizable_object*new_fo=0;
hdr*hhdr=NULL;
DCL_LOCK_STATE;
if (EXPECT(GC_find_leak,FALSE))return;
LOCK();
if (EXPECT(NULL==GC_fnlz_roots.fo_head,FALSE)
||EXPECT(GC_fo_entries > ((word)1<<GC_log_fo_table_size),FALSE)){
GC_grow_table((struct hash_chain_entry***)&GC_fnlz_roots.fo_head,
&GC_log_fo_table_size,&GC_fo_entries);
GC_COND_LOG_PRINTF("Grew fo table to %u entries\n",
1U<<GC_log_fo_table_size);
}
for (;;){
struct finalizable_object*prev_fo=NULL;
GC_oom_func oom_fn;
index=HASH2(obj,GC_log_fo_table_size);
curr_fo=GC_fnlz_roots.fo_head[index];
while (curr_fo!=0){
GC_ASSERT(GC_size(curr_fo)>=sizeof(struct finalizable_object));
if (curr_fo->fo_hidden_base==GC_HIDE_POINTER(obj)){
if (ocd)*ocd=(void*)(curr_fo->fo_client_data);
if (ofn)*ofn=curr_fo->fo_fn;
if (prev_fo==0){
GC_fnlz_roots.fo_head[index]=fo_next(curr_fo);
} else {
fo_set_next(prev_fo,fo_next(curr_fo));
GC_dirty(prev_fo);
}
if (fn==0){
GC_fo_entries--;
#if!defined(THREADS)&&!defined(DBG_HDRS_ALL)
GC_free((void*)curr_fo);
#endif
} else {
curr_fo->fo_fn=fn;
curr_fo->fo_client_data=(ptr_t)cd;
curr_fo->fo_mark_proc=mp;
GC_dirty(curr_fo);
if (prev_fo==0){
GC_fnlz_roots.fo_head[index]=curr_fo;
} else {
fo_set_next(prev_fo,curr_fo);
GC_dirty(prev_fo);
}
}
if (NULL==prev_fo)
GC_dirty(GC_fnlz_roots.fo_head+index);
UNLOCK();
#ifndef DBG_HDRS_ALL
GC_free((void*)new_fo);
#endif
return;
}
prev_fo=curr_fo;
curr_fo=fo_next(curr_fo);
}
if (EXPECT(new_fo!=0,FALSE)){
GC_ASSERT(fn!=0);
#ifdef LINT2
if (NULL==hhdr)ABORT("Bad hhdr in GC_register_finalizer_inner");
#endif
break;
}
if (fn==0){
if (ocd)*ocd=0;
if (ofn)*ofn=0;
UNLOCK();
return;
}
GET_HDR(obj,hhdr);
if (EXPECT(0==hhdr,FALSE)){
if (ocd)*ocd=0;
if (ofn)*ofn=0;
UNLOCK();
return;
}
new_fo=(struct finalizable_object*)
GC_INTERNAL_MALLOC(sizeof(struct finalizable_object),NORMAL);
if (EXPECT(new_fo!=0,TRUE))
break;
oom_fn=GC_oom_fn;
UNLOCK();
new_fo=(struct finalizable_object*)
(*oom_fn)(sizeof(struct finalizable_object));
if (0==new_fo){
return;
}
LOCK();
}
GC_ASSERT(GC_size(new_fo)>=sizeof(struct finalizable_object));
if (ocd)*ocd=0;
if (ofn)*ofn=0;
new_fo->fo_hidden_base=GC_HIDE_POINTER(obj);
new_fo->fo_fn=fn;
new_fo->fo_client_data=(ptr_t)cd;
new_fo->fo_object_size=hhdr->hb_sz;
new_fo->fo_mark_proc=mp;
fo_set_next(new_fo,GC_fnlz_roots.fo_head[index]);
GC_dirty(new_fo);
GC_fo_entries++;
GC_fnlz_roots.fo_head[index]=new_fo;
GC_dirty(GC_fnlz_roots.fo_head+index);
UNLOCK();
}
GC_API void GC_CALL GC_register_finalizer(void*obj,
GC_finalization_proc fn,void*cd,
GC_finalization_proc*ofn,void**ocd)
{
GC_register_finalizer_inner(obj,fn,cd,ofn,
ocd,GC_normal_finalize_mark_proc);
}
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_register_finalizer_inner(obj,fn,cd,ofn,
ocd,GC_ignore_self_finalize_mark_proc);
}
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_register_finalizer_inner(obj,fn,cd,ofn,
ocd,GC_null_finalize_mark_proc);
}
static GC_bool need_unreachable_finalization=FALSE;
GC_API void GC_CALL GC_register_finalizer_unreachable(void*obj,
GC_finalization_proc fn,void*cd,
GC_finalization_proc*ofn,void**ocd)
{
need_unreachable_finalization=TRUE;
GC_ASSERT(GC_java_finalization);
GC_register_finalizer_inner(obj,fn,cd,ofn,
ocd,GC_unreachable_finalize_mark_proc);
}
#ifndef NO_DEBUGGING
STATIC void GC_dump_finalization_links(
const struct dl_hashtbl_s*dl_hashtbl)
{
size_t dl_size=(size_t)1<<dl_hashtbl->log_size;
size_t i;
if (NULL==dl_hashtbl->head)return;
for (i=0;i < dl_size;i++){
struct disappearing_link*curr_dl;
for (curr_dl=dl_hashtbl->head[i];curr_dl!=0;
curr_dl=dl_next(curr_dl)){
ptr_t real_ptr=(ptr_t)GC_REVEAL_POINTER(curr_dl->dl_hidden_obj);
ptr_t real_link=(ptr_t)GC_REVEAL_POINTER(curr_dl->dl_hidden_link);
GC_printf("Object:%p,link:%p\n",
(void*)real_ptr,(void*)real_link);
}
}
}
GC_API void GC_CALL GC_dump_finalization(void)
{
struct finalizable_object*curr_fo;
size_t i;
size_t fo_size=GC_fnlz_roots.fo_head==NULL?0:
(size_t)1<<GC_log_fo_table_size;
GC_printf("Disappearing (short)links:\n");
GC_dump_finalization_links(&GC_dl_hashtbl);
#ifndef GC_LONG_REFS_NOT_NEEDED
GC_printf("Disappearing long links:\n");
GC_dump_finalization_links(&GC_ll_hashtbl);
#endif
GC_printf("Finalizers:\n");
for (i=0;i < fo_size;i++){
for (curr_fo=GC_fnlz_roots.fo_head[i];
curr_fo!=NULL;curr_fo=fo_next(curr_fo)){
ptr_t real_ptr=(ptr_t)GC_REVEAL_POINTER(curr_fo->fo_hidden_base);
GC_printf("Finalizable object:%p\n",(void*)real_ptr);
}
}
}
#endif
#ifndef SMALL_CONFIG
STATIC word GC_old_dl_entries=0;
#ifndef GC_LONG_REFS_NOT_NEEDED
STATIC word GC_old_ll_entries=0;
#endif
#endif
#ifndef THREADS
STATIC int GC_finalizer_nested=0;
STATIC unsigned GC_finalizer_skipped=0;
STATIC unsigned char*GC_check_finalizer_nested(void)
{
unsigned nesting_level=*(unsigned char*)&GC_finalizer_nested;
if (nesting_level){
if (++GC_finalizer_skipped < (1U<<nesting_level))return NULL;
GC_finalizer_skipped=0;
}
*(char*)&GC_finalizer_nested=(char)(nesting_level+1);
return (unsigned char*)&GC_finalizer_nested;
}
#endif
GC_INLINE void GC_make_disappearing_links_disappear(
struct dl_hashtbl_s*dl_hashtbl,
GC_bool is_remove_dangling)
{
size_t i;
size_t dl_size=(size_t)1<<dl_hashtbl->log_size;
GC_bool needs_barrier=FALSE;
GC_ASSERT(I_HOLD_LOCK());
if (NULL==dl_hashtbl->head)return;
for (i=0;i < dl_size;i++){
struct disappearing_link*curr_dl,*next_dl;
struct disappearing_link*prev_dl=NULL;
for (curr_dl=dl_hashtbl->head[i];curr_dl!=NULL;curr_dl=next_dl){
next_dl=dl_next(curr_dl);
if (is_remove_dangling){
ptr_t real_link=(ptr_t)GC_base(GC_REVEAL_POINTER(
curr_dl->dl_hidden_link));
if (NULL==real_link||EXPECT(GC_is_marked(real_link),TRUE)){
prev_dl=curr_dl;
continue;
}
} else {
if (EXPECT(GC_is_marked((ptr_t)GC_REVEAL_POINTER(
curr_dl->dl_hidden_obj)),TRUE)){
prev_dl=curr_dl;
continue;
}
*(ptr_t*)GC_REVEAL_POINTER(curr_dl->dl_hidden_link)=NULL;
}
if (NULL==prev_dl){
dl_hashtbl->head[i]=next_dl;
needs_barrier=TRUE;
} else {
dl_set_next(prev_dl,next_dl);
GC_dirty(prev_dl);
}
GC_clear_mark_bit(curr_dl);
dl_hashtbl->entries--;
}
}
if (needs_barrier)
GC_dirty(dl_hashtbl->head);
}
GC_INNER void GC_finalize(void)
{
struct finalizable_object*curr_fo,*prev_fo,*next_fo;
ptr_t real_ptr;
size_t i;
size_t fo_size=GC_fnlz_roots.fo_head==NULL?0:
(size_t)1<<GC_log_fo_table_size;
GC_bool needs_barrier=FALSE;
GC_ASSERT(I_HOLD_LOCK());
#ifndef SMALL_CONFIG
GC_old_dl_entries=GC_dl_hashtbl.entries;
#ifndef GC_LONG_REFS_NOT_NEEDED
GC_old_ll_entries=GC_ll_hashtbl.entries;
#endif
#endif
#ifndef GC_TOGGLE_REFS_NOT_NEEDED
GC_mark_togglerefs();
#endif
GC_make_disappearing_links_disappear(&GC_dl_hashtbl,FALSE);
GC_ASSERT(GC_mark_state==MS_NONE);
for (i=0;i < fo_size;i++){
for (curr_fo=GC_fnlz_roots.fo_head[i];
curr_fo!=NULL;curr_fo=fo_next(curr_fo)){
GC_ASSERT(GC_size(curr_fo)>=sizeof(struct finalizable_object));
real_ptr=(ptr_t)GC_REVEAL_POINTER(curr_fo->fo_hidden_base);
if (!GC_is_marked(real_ptr)){
GC_MARKED_FOR_FINALIZATION(real_ptr);
GC_MARK_FO(real_ptr,curr_fo->fo_mark_proc);
if (GC_is_marked(real_ptr)){
WARN("Finalization cycle involving %p\n",real_ptr);
}
}
}
}
GC_bytes_finalized=0;
for (i=0;i < fo_size;i++){
curr_fo=GC_fnlz_roots.fo_head[i];
prev_fo=0;
while (curr_fo!=0){
real_ptr=(ptr_t)GC_REVEAL_POINTER(curr_fo->fo_hidden_base);
if (!GC_is_marked(real_ptr)){
if (!GC_java_finalization){
GC_set_mark_bit(real_ptr);
}
next_fo=fo_next(curr_fo);
if (NULL==prev_fo){
GC_fnlz_roots.fo_head[i]=next_fo;
if (GC_object_finalized_proc){
GC_dirty(GC_fnlz_roots.fo_head+i);
} else {
needs_barrier=TRUE;
}
} else {
fo_set_next(prev_fo,next_fo);
GC_dirty(prev_fo);
}
GC_fo_entries--;
if (GC_object_finalized_proc)
GC_object_finalized_proc(real_ptr);
fo_set_next(curr_fo,GC_fnlz_roots.finalize_now);
GC_dirty(curr_fo);
SET_FINALIZE_NOW(curr_fo);
curr_fo->fo_hidden_base=
(word)GC_REVEAL_POINTER(curr_fo->fo_hidden_base);
GC_bytes_finalized+=
curr_fo->fo_object_size
+sizeof(struct finalizable_object);
GC_ASSERT(GC_is_marked(GC_base(curr_fo)));
curr_fo=next_fo;
} else {
prev_fo=curr_fo;
curr_fo=fo_next(curr_fo);
}
}
}
if (GC_java_finalization){
for (curr_fo=GC_fnlz_roots.finalize_now;
curr_fo!=NULL;curr_fo=fo_next(curr_fo)){
real_ptr=(ptr_t)curr_fo->fo_hidden_base;
if (!GC_is_marked(real_ptr)){
if (curr_fo->fo_mark_proc==GC_null_finalize_mark_proc){
GC_MARK_FO(real_ptr,GC_normal_finalize_mark_proc);
}
if (curr_fo->fo_mark_proc!=GC_unreachable_finalize_mark_proc){
GC_set_mark_bit(real_ptr);
}
}
}
if (need_unreachable_finalization){
curr_fo=GC_fnlz_roots.finalize_now;
GC_ASSERT(NULL==curr_fo||GC_fnlz_roots.fo_head!=NULL);
prev_fo=NULL;
while (curr_fo!=NULL){
next_fo=fo_next(curr_fo);
if (curr_fo->fo_mark_proc==GC_unreachable_finalize_mark_proc){
real_ptr=(ptr_t)curr_fo->fo_hidden_base;
if (!GC_is_marked(real_ptr)){
GC_set_mark_bit(real_ptr);
} else {
if (NULL==prev_fo){
SET_FINALIZE_NOW(next_fo);
} else {
fo_set_next(prev_fo,next_fo);
GC_dirty(prev_fo);
}
curr_fo->fo_hidden_base=
GC_HIDE_POINTER(curr_fo->fo_hidden_base);
GC_bytes_finalized-=
curr_fo->fo_object_size+sizeof(struct finalizable_object);
i=HASH2(real_ptr,GC_log_fo_table_size);
fo_set_next(curr_fo,GC_fnlz_roots.fo_head[i]);
GC_dirty(curr_fo);
GC_fo_entries++;
GC_fnlz_roots.fo_head[i]=curr_fo;
curr_fo=prev_fo;
needs_barrier=TRUE;
}
}
prev_fo=curr_fo;
curr_fo=next_fo;
}
}
}
if (needs_barrier)
GC_dirty(GC_fnlz_roots.fo_head);
GC_make_disappearing_links_disappear(&GC_dl_hashtbl,TRUE);
#ifndef GC_TOGGLE_REFS_NOT_NEEDED
GC_clear_togglerefs();
#endif
#ifndef GC_LONG_REFS_NOT_NEEDED
GC_make_disappearing_links_disappear(&GC_ll_hashtbl,FALSE);
GC_make_disappearing_links_disappear(&GC_ll_hashtbl,TRUE);
#endif
if (GC_fail_count){
#ifdef THREADS
GC_reset_finalizer_nested();
#else
GC_finalizer_nested=0;
#endif
}
}
#ifndef JAVA_FINALIZATION_NOT_NEEDED
STATIC void GC_enqueue_all_finalizers(void)
{
struct finalizable_object*next_fo;
size_t i;
size_t fo_size=GC_fnlz_roots.fo_head==NULL?0:
(size_t)1<<GC_log_fo_table_size;
GC_ASSERT(I_HOLD_LOCK());
GC_bytes_finalized=0;
for (i=0;i < fo_size;i++){
struct finalizable_object*curr_fo=GC_fnlz_roots.fo_head[i];
GC_fnlz_roots.fo_head[i]=NULL;
while (curr_fo!=NULL){
ptr_t real_ptr=(ptr_t)GC_REVEAL_POINTER(curr_fo->fo_hidden_base);
GC_MARK_FO(real_ptr,GC_normal_finalize_mark_proc);
GC_set_mark_bit(real_ptr);
next_fo=fo_next(curr_fo);
fo_set_next(curr_fo,GC_fnlz_roots.finalize_now);
GC_dirty(curr_fo);
SET_FINALIZE_NOW(curr_fo);
curr_fo->fo_hidden_base=
(word)GC_REVEAL_POINTER(curr_fo->fo_hidden_base);
GC_bytes_finalized+=
curr_fo->fo_object_size+sizeof(struct finalizable_object);
curr_fo=next_fo;
}
}
GC_fo_entries=0;
}
GC_API void GC_CALL GC_finalize_all(void)
{
DCL_LOCK_STATE;
LOCK();
while (GC_fo_entries > 0){
GC_enqueue_all_finalizers();
UNLOCK();
GC_invoke_finalizers();
LOCK();
}
UNLOCK();
}
#endif
GC_API int GC_CALL GC_should_invoke_finalizers(void)
{
#ifdef AO_HAVE_load
return AO_load((volatile AO_t*)&GC_fnlz_roots.finalize_now)!=0;
#else
return GC_fnlz_roots.finalize_now!=NULL;
#endif
}
GC_API int GC_CALL GC_invoke_finalizers(void)
{
int count=0;
word bytes_freed_before=0;
DCL_LOCK_STATE;
while (GC_should_invoke_finalizers()){
struct finalizable_object*curr_fo;
#ifdef THREADS
LOCK();
#endif
if (count==0){
bytes_freed_before=GC_bytes_freed;
}
curr_fo=GC_fnlz_roots.finalize_now;
#ifdef THREADS
if (curr_fo!=NULL)
SET_FINALIZE_NOW(fo_next(curr_fo));
UNLOCK();
if (curr_fo==0)break;
#else
GC_fnlz_roots.finalize_now=fo_next(curr_fo);
#endif
fo_set_next(curr_fo,0);
(*(curr_fo->fo_fn))((ptr_t)(curr_fo->fo_hidden_base),
curr_fo->fo_client_data);
curr_fo->fo_client_data=0;
++count;
}
if (count!=0
#if defined(THREADS)&&!defined(THREAD_SANITIZER)
&&bytes_freed_before!=GC_bytes_freed
#endif
){
LOCK();
GC_finalizer_bytes_freed+=(GC_bytes_freed - bytes_freed_before);
UNLOCK();
}
return count;
}
static word last_finalizer_notification=0;
GC_INNER void GC_notify_or_invoke_finalizers(void)
{
GC_finalizer_notifier_proc notifier_fn=0;
#if defined(KEEP_BACK_PTRS)||defined(MAKE_BACK_GRAPH)
static word last_back_trace_gc_no=1;
#endif
DCL_LOCK_STATE;
#if defined(THREADS)&&!defined(KEEP_BACK_PTRS)&&!defined(MAKE_BACK_GRAPH)
if (!GC_should_invoke_finalizers())
return;
#endif
LOCK();
#if defined(KEEP_BACK_PTRS)||defined(MAKE_BACK_GRAPH)
if (GC_gc_no > last_back_trace_gc_no){
#ifdef KEEP_BACK_PTRS
long i;
last_back_trace_gc_no=GC_WORD_MAX;
for (i=0;i < GC_backtraces;++i){
UNLOCK();
GC_generate_random_backtrace_no_gc();
LOCK();
}
last_back_trace_gc_no=GC_gc_no;
#endif
#ifdef MAKE_BACK_GRAPH
if (GC_print_back_height){
GC_print_back_graph_stats();
}
#endif
}
#endif
if (NULL==GC_fnlz_roots.finalize_now){
UNLOCK();
return;
}
if (!GC_finalize_on_demand){
unsigned char*pnested=GC_check_finalizer_nested();
UNLOCK();
if (pnested!=NULL){
(void)GC_invoke_finalizers();
*pnested=0;
#ifndef THREADS
GC_ASSERT(NULL==GC_fnlz_roots.finalize_now);
#endif
}
return;
}
if (last_finalizer_notification!=GC_gc_no){
notifier_fn=GC_finalizer_notifier;
last_finalizer_notification=GC_gc_no;
}
UNLOCK();
if (notifier_fn!=0)
(*notifier_fn)();
}
#ifndef SMALL_CONFIG
#ifndef GC_LONG_REFS_NOT_NEEDED
#define IF_LONG_REFS_PRESENT_ELSE(x,y)(x)
#else
#define IF_LONG_REFS_PRESENT_ELSE(x,y)(y)
#endif
GC_INNER void GC_print_finalization_stats(void)
{
struct finalizable_object*fo;
unsigned long ready=0;
GC_log_printf("%lu finalization entries;"
" %lu/%lu short/long disappearing links alive\n",
(unsigned long)GC_fo_entries,
(unsigned long)GC_dl_hashtbl.entries,
(unsigned long)IF_LONG_REFS_PRESENT_ELSE(
GC_ll_hashtbl.entries,0));
for (fo=GC_fnlz_roots.finalize_now;fo!=NULL;fo=fo_next(fo))
++ready;
GC_log_printf("%lu finalization-ready objects;"
" %ld/%ld short/long links cleared\n",
ready,
(long)GC_old_dl_entries - (long)GC_dl_hashtbl.entries,
(long)IF_LONG_REFS_PRESENT_ELSE(
GC_old_ll_entries - GC_ll_hashtbl.entries,0));
}
#endif
#endif
#ifdef ENABLE_DISCLAIM
#ifndef GC_DISCLAIM_H
#define GC_DISCLAIM_H
#ifdef __cplusplus
extern "C" {
#endif
GC_API void GC_CALL GC_init_finalized_malloc(void);
typedef int (GC_CALLBACK*GC_disclaim_proc)(void*);
GC_API void GC_CALL GC_register_disclaim_proc(int,
GC_disclaim_proc,
int)GC_ATTR_NONNULL(2);
struct GC_finalizer_closure {
GC_finalization_proc proc;
void*cd;
};
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_finalized_malloc(size_t,
const struct GC_finalizer_closure*)GC_ATTR_NONNULL(2);
#ifdef __cplusplus
}
#endif
#endif
#if defined(KEEP_BACK_PTRS)||defined(MAKE_BACK_GRAPH)
#define FINALIZER_CLOSURE_FLAG 0x2
#else
#define FINALIZER_CLOSURE_FLAG 0x1
#endif
STATIC int GC_CALLBACK GC_finalized_disclaim(void*obj)
{
word fc_word=*(word*)obj;
if ((fc_word&FINALIZER_CLOSURE_FLAG)!=0){
const struct GC_finalizer_closure*fc
=(struct GC_finalizer_closure*)(fc_word
&~(word)FINALIZER_CLOSURE_FLAG);
GC_ASSERT(!GC_find_leak);
(*fc->proc)((word*)obj+1,fc->cd);
}
return 0;
}
GC_API void GC_CALL GC_init_finalized_malloc(void)
{
DCL_LOCK_STATE;
GC_init();
LOCK();
if (GC_finalized_kind!=0){
UNLOCK();
return;
}
GC_register_displacement_inner(sizeof(word));
GC_register_displacement_inner(FINALIZER_CLOSURE_FLAG);
GC_register_displacement_inner(sizeof(oh)+FINALIZER_CLOSURE_FLAG);
GC_finalized_kind=GC_new_kind_inner(GC_new_free_list_inner(),
GC_DS_LENGTH,TRUE,TRUE);
GC_ASSERT(GC_finalized_kind!=0);
GC_register_disclaim_proc(GC_finalized_kind,GC_finalized_disclaim,TRUE);
UNLOCK();
}
GC_API void GC_CALL GC_register_disclaim_proc(int kind,GC_disclaim_proc proc,
int mark_unconditionally)
{
GC_ASSERT((unsigned)kind < MAXOBJKINDS);
GC_ASSERT(NONNULL_ARG_NOT_NULL(proc));
if (!EXPECT(GC_find_leak,FALSE)){
GC_obj_kinds[kind].ok_disclaim_proc=proc;
GC_obj_kinds[kind].ok_mark_unconditionally=
(GC_bool)mark_unconditionally;
}
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_finalized_malloc(size_t lb,
const struct GC_finalizer_closure*fclos)
{
word*op;
GC_ASSERT(GC_finalized_kind!=0);
GC_ASSERT(NONNULL_ARG_NOT_NULL(fclos));
GC_ASSERT(((word)fclos&FINALIZER_CLOSURE_FLAG)==0);
op=(word*)GC_malloc_kind(SIZET_SAT_ADD(lb,sizeof(word)),
GC_finalized_kind);
if (EXPECT(NULL==op,FALSE))
return NULL;
*op=(word)fclos|FINALIZER_CLOSURE_FLAG;
GC_dirty(op);
REACHABLE_AFTER_DIRTY(fclos);
return op+1;
}
#endif
#include <stdio.h>
#include <string.h>
STATIC GC_bool GC_alloc_reclaim_list(struct obj_kind*kind)
{
struct hblk**result=(struct hblk**)
GC_scratch_alloc((MAXOBJGRANULES+1)*sizeof(struct hblk*));
if (result==0)return(FALSE);
BZERO(result,(MAXOBJGRANULES+1)*sizeof(struct hblk*));
kind->ok_reclaim_list=result;
return(TRUE);
}
GC_INNER ptr_t GC_alloc_large(size_t lb,int k,unsigned flags)
{
struct hblk*h;
word n_blocks;
ptr_t result;
GC_bool retry=FALSE;
GC_ASSERT(I_HOLD_LOCK());
lb=ROUNDUP_GRANULE_SIZE(lb);
n_blocks=OBJ_SZ_TO_BLOCKS_CHECKED(lb);
if (!EXPECT(GC_is_initialized,TRUE)){
DCL_LOCK_STATE;
UNLOCK();
GC_init();
LOCK();
}
if (GC_incremental&&!GC_dont_gc){
ENTER_GC();
GC_collect_a_little_inner((int)n_blocks);
EXIT_GC();
}
h=GC_allochblk(lb,k,flags);
#ifdef USE_MUNMAP
if (0==h){
GC_merge_unmapped();
h=GC_allochblk(lb,k,flags);
}
#endif
while (0==h&&GC_collect_or_expand(n_blocks,flags!=0,retry)){
h=GC_allochblk(lb,k,flags);
retry=TRUE;
}
if (h==0){
result=0;
} else {
size_t total_bytes=n_blocks*HBLKSIZE;
if (n_blocks > 1){
GC_large_allocd_bytes+=total_bytes;
if (GC_large_allocd_bytes > GC_max_large_allocd_bytes)
GC_max_large_allocd_bytes=GC_large_allocd_bytes;
}
result=h->hb_body;
}
return result;
}
STATIC ptr_t GC_alloc_large_and_clear(size_t lb,int k,unsigned flags)
{
ptr_t result;
GC_ASSERT(I_HOLD_LOCK());
result=GC_alloc_large(lb,k,flags);
if (result!=NULL
&&(GC_debugging_started||GC_obj_kinds[k].ok_init)){
word n_blocks=OBJ_SZ_TO_BLOCKS(lb);
BZERO(result,n_blocks*HBLKSIZE);
}
return result;
}
STATIC void GC_extend_size_map(size_t i)
{
size_t orig_granule_sz=ROUNDED_UP_GRANULES(i);
size_t granule_sz;
size_t byte_sz=GRANULES_TO_BYTES(orig_granule_sz);
size_t smaller_than_i=byte_sz - (byte_sz>>3);
size_t low_limit;
size_t number_of_objs;
GC_ASSERT(I_HOLD_LOCK());
GC_ASSERT(0==GC_size_map[i]);
if (0==GC_size_map[smaller_than_i]){
low_limit=byte_sz - (byte_sz>>2);
granule_sz=orig_granule_sz;
while (GC_size_map[low_limit]!=0)
low_limit++;
} else {
low_limit=smaller_than_i+1;
while (GC_size_map[low_limit]!=0)
low_limit++;
granule_sz=ROUNDED_UP_GRANULES(low_limit);
granule_sz+=granule_sz>>3;
if (granule_sz < orig_granule_sz)
granule_sz=orig_granule_sz;
}
granule_sz=(granule_sz+1)&~1;
if (granule_sz > MAXOBJGRANULES)
granule_sz=MAXOBJGRANULES;
number_of_objs=HBLK_GRANULES/granule_sz;
GC_ASSERT(number_of_objs!=0);
granule_sz=(HBLK_GRANULES/number_of_objs)&~1;
byte_sz=GRANULES_TO_BYTES(granule_sz)- EXTRA_BYTES;
for (;low_limit<=byte_sz;low_limit++)
GC_size_map[low_limit]=granule_sz;
}
GC_INNER void*GC_generic_malloc_inner(size_t lb,int k)
{
void*op;
GC_ASSERT(I_HOLD_LOCK());
GC_ASSERT(k < MAXOBJKINDS);
if (SMALL_OBJ(lb)){
struct obj_kind*kind=GC_obj_kinds+k;
size_t lg=GC_size_map[lb];
void**opp=&(kind->ok_freelist[lg]);
op=*opp;
if (EXPECT(0==op,FALSE)){
if (lg==0){
if (!EXPECT(GC_is_initialized,TRUE)){
DCL_LOCK_STATE;
UNLOCK();
GC_init();
LOCK();
lg=GC_size_map[lb];
}
if (0==lg){
GC_extend_size_map(lb);
lg=GC_size_map[lb];
GC_ASSERT(lg!=0);
}
opp=&(kind->ok_freelist[lg]);
op=*opp;
}
if (0==op){
if (0==kind->ok_reclaim_list&&
!GC_alloc_reclaim_list(kind))
return NULL;
op=GC_allocobj(lg,k);
if (0==op)
return NULL;
}
}
*opp=obj_link(op);
obj_link(op)=0;
GC_bytes_allocd+=GRANULES_TO_BYTES((word)lg);
} else {
op=(ptr_t)GC_alloc_large_and_clear(ADD_SLOP(lb),k,0);
if (op!=NULL)
GC_bytes_allocd+=lb;
}
return op;
}
#if defined(DBG_HDRS_ALL)||defined(GC_GCJ_SUPPORT)||!defined(GC_NO_FINALIZATION)
GC_INNER void*GC_generic_malloc_inner_ignore_off_page(size_t lb,int k)
{
word lb_adjusted;
void*op;
GC_ASSERT(I_HOLD_LOCK());
if (lb<=HBLKSIZE)
return GC_generic_malloc_inner(lb,k);
GC_ASSERT(k < MAXOBJKINDS);
lb_adjusted=ADD_SLOP(lb);
op=GC_alloc_large_and_clear(lb_adjusted,k,IGNORE_OFF_PAGE);
if (op!=NULL)
GC_bytes_allocd+=lb_adjusted;
return op;
}
#endif
#ifdef GC_COLLECT_AT_MALLOC
#if defined(CPPCHECK)
size_t GC_dbg_collect_at_malloc_min_lb=16*1024;
#else
size_t GC_dbg_collect_at_malloc_min_lb=(GC_COLLECT_AT_MALLOC);
#endif
#endif
GC_API GC_ATTR_MALLOC void*GC_CALL GC_generic_malloc(size_t lb,int k)
{
void*result;
DCL_LOCK_STATE;
GC_ASSERT(k < MAXOBJKINDS);
if (EXPECT(GC_have_errors,FALSE))
GC_print_all_errors();
GC_INVOKE_FINALIZERS();
GC_DBG_COLLECT_AT_MALLOC(lb);
if (SMALL_OBJ(lb)){
LOCK();
result=GC_generic_malloc_inner(lb,k);
UNLOCK();
} else {
size_t lg;
size_t lb_rounded;
word n_blocks;
GC_bool init;
lg=ROUNDED_UP_GRANULES(lb);
lb_rounded=GRANULES_TO_BYTES(lg);
n_blocks=OBJ_SZ_TO_BLOCKS(lb_rounded);
init=GC_obj_kinds[k].ok_init;
LOCK();
result=(ptr_t)GC_alloc_large(lb_rounded,k,0);
if (0!=result){
if (GC_debugging_started){
BZERO(result,n_blocks*HBLKSIZE);
} else {
#ifdef THREADS
((word*)result)[0]=0;
((word*)result)[1]=0;
((word*)result)[GRANULES_TO_WORDS(lg)-1]=0;
((word*)result)[GRANULES_TO_WORDS(lg)-2]=0;
#endif
}
GC_bytes_allocd+=lb_rounded;
}
UNLOCK();
if (init&&!GC_debugging_started&&0!=result){
BZERO(result,n_blocks*HBLKSIZE);
}
}
if (0==result){
return((*GC_get_oom_fn())(lb));
} else {
return(result);
}
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_malloc_kind_global(size_t lb,int k)
{
GC_ASSERT(k < MAXOBJKINDS);
if (SMALL_OBJ(lb)){
void*op;
void**opp;
size_t lg;
DCL_LOCK_STATE;
GC_DBG_COLLECT_AT_MALLOC(lb);
LOCK();
lg=GC_size_map[lb];
opp=&GC_obj_kinds[k].ok_freelist[lg];
op=*opp;
if (EXPECT(op!=NULL,TRUE)){
if (k==PTRFREE){
*opp=obj_link(op);
} else {
GC_ASSERT(0==obj_link(op)
||((word)obj_link(op)
<=(word)GC_greatest_plausible_heap_addr
&&(word)obj_link(op)
>=(word)GC_least_plausible_heap_addr));
*opp=obj_link(op);
obj_link(op)=0;
}
GC_bytes_allocd+=GRANULES_TO_BYTES((word)lg);
UNLOCK();
return op;
}
UNLOCK();
}
return GC_clear_stack(GC_generic_malloc(lb,k));
}
#if defined(THREADS)&&!defined(THREAD_LOCAL_ALLOC)
GC_API GC_ATTR_MALLOC void*GC_CALL GC_malloc_kind(size_t lb,int k)
{
return GC_malloc_kind_global(lb,k);
}
#endif
GC_API GC_ATTR_MALLOC void*GC_CALL GC_malloc_atomic(size_t lb)
{
return GC_malloc_kind(lb,PTRFREE);
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_malloc(size_t lb)
{
return GC_malloc_kind(lb,NORMAL);
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_generic_malloc_uncollectable(
size_t lb,int k)
{
void*op;
DCL_LOCK_STATE;
GC_ASSERT(k < MAXOBJKINDS);
if (SMALL_OBJ(lb)){
void**opp;
size_t lg;
GC_DBG_COLLECT_AT_MALLOC(lb);
if (EXTRA_BYTES!=0&&lb!=0)lb--;
LOCK();
lg=GC_size_map[lb];
opp=&GC_obj_kinds[k].ok_freelist[lg];
op=*opp;
if (EXPECT(op!=NULL,TRUE)){
*opp=obj_link(op);
obj_link(op)=0;
GC_bytes_allocd+=GRANULES_TO_BYTES((word)lg);
GC_non_gc_bytes+=GRANULES_TO_BYTES((word)lg);
UNLOCK();
} else {
UNLOCK();
op=GC_generic_malloc(lb,k);
}
GC_ASSERT(0==op||GC_is_marked(op));
} else {
op=GC_generic_malloc(lb,k);
if (op){
hdr*hhdr=HDR(op);
GC_ASSERT(((word)op&(HBLKSIZE - 1))==0);
LOCK();
set_mark_bit_from_hdr(hhdr,0);
#ifndef THREADS
GC_ASSERT(hhdr->hb_n_marks==0);
#endif
hhdr->hb_n_marks=1;
UNLOCK();
}
}
return op;
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_malloc_uncollectable(size_t lb)
{
return GC_generic_malloc_uncollectable(lb,UNCOLLECTABLE);
}
#ifdef GC_ATOMIC_UNCOLLECTABLE
GC_API GC_ATTR_MALLOC void*GC_CALL
GC_malloc_atomic_uncollectable(size_t lb)
{
return GC_generic_malloc_uncollectable(lb,AUNCOLLECTABLE);
}
#endif
#if defined(REDIRECT_MALLOC)&&!defined(REDIRECT_MALLOC_IN_HEADER)
#ifndef MSWINCE
#include <errno.h>
#endif
#define GC_debug_malloc_replacement(lb)GC_debug_malloc(lb,GC_DBG_EXTRAS)
#if defined(CPPCHECK)
#define REDIRECT_MALLOC_F GC_malloc
#else
#define REDIRECT_MALLOC_F REDIRECT_MALLOC
#endif
void*malloc(size_t lb)
{
#if defined(I386)&&defined(GC_SOLARIS_THREADS)
if (!EXPECT(GC_is_initialized,TRUE))return sbrk(lb);
#endif
return (void*)REDIRECT_MALLOC_F(lb);
}
#if defined(GC_LINUX_THREADS)
STATIC ptr_t GC_libpthread_start=0;
STATIC ptr_t GC_libpthread_end=0;
STATIC ptr_t GC_libld_start=0;
STATIC ptr_t GC_libld_end=0;
STATIC void GC_init_lib_bounds(void)
{
IF_CANCEL(int cancel_state;)
if (GC_libpthread_start!=0)return;
DISABLE_CANCEL(cancel_state);
GC_init();
if (!GC_text_mapping("libpthread-",
&GC_libpthread_start,&GC_libpthread_end)){
WARN("Failed to find libpthread.so text mapping:Expect crash\n",0);
GC_libpthread_start=(ptr_t)1;
}
if (!GC_text_mapping("ld-",&GC_libld_start,&GC_libld_end)){
WARN("Failed to find ld.so text mapping:Expect crash\n",0);
}
RESTORE_CANCEL(cancel_state);
}
#endif
void*calloc(size_t n,size_t lb)
{
if ((lb|n)> GC_SQRT_SIZE_MAX
&&lb&&n > GC_SIZE_MAX/lb)
return (*GC_get_oom_fn())(GC_SIZE_MAX);
#if defined(GC_LINUX_THREADS)
{
static GC_bool lib_bounds_set=FALSE;
ptr_t caller=(ptr_t)__builtin_return_address(0);
if (!EXPECT(lib_bounds_set,TRUE)){
GC_init_lib_bounds();
lib_bounds_set=TRUE;
}
if (((word)caller>=(word)GC_libpthread_start
&&(word)caller < (word)GC_libpthread_end)
||((word)caller>=(word)GC_libld_start
&&(word)caller < (word)GC_libld_end))
return GC_generic_malloc_uncollectable(n*lb,UNCOLLECTABLE);
}
#endif
return (void*)REDIRECT_MALLOC_F(n*lb);
}
#ifndef strdup
char*strdup(const char*s)
{
size_t lb=strlen(s)+1;
char*result=(char*)REDIRECT_MALLOC_F(lb);
if (result==0){
errno=ENOMEM;
return 0;
}
BCOPY(s,result,lb);
return result;
}
#endif
#ifndef strndup
char*strndup(const char*str,size_t size)
{
char*copy;
size_t len=strlen(str);
if (len > size)
len=size;
copy=(char*)REDIRECT_MALLOC_F(len+1);
if (copy==NULL){
errno=ENOMEM;
return NULL;
}
if (EXPECT(len > 0,TRUE))
BCOPY(str,copy,len);
copy[len]='\0';
return copy;
}
#endif
#undef GC_debug_malloc_replacement
#endif
GC_API void GC_CALL GC_free(void*p)
{
struct hblk*h;
hdr*hhdr;
size_t sz;
size_t ngranules;
int knd;
struct obj_kind*ok;
DCL_LOCK_STATE;
if (p){
} else {
return;
}
#ifdef LOG_ALLOCS
GC_log_printf("GC_free(%p)after GC #%lu\n",
p,(unsigned long)GC_gc_no);
#endif
h=HBLKPTR(p);
hhdr=HDR(h);
#if defined(REDIRECT_MALLOC)&&((defined(NEED_CALLINFO)&&defined(GC_HAVE_BUILTIN_BACKTRACE))||defined(GC_SOLARIS_THREADS)||defined(GC_LINUX_THREADS)||defined(MSWIN32))
if (0==hhdr)return;
#endif
GC_ASSERT(GC_base(p)==p);
sz=(size_t)hhdr->hb_sz;
ngranules=BYTES_TO_GRANULES(sz);
knd=hhdr->hb_obj_kind;
ok=&GC_obj_kinds[knd];
if (EXPECT(ngranules<=MAXOBJGRANULES,TRUE)){
void**flh;
LOCK();
GC_bytes_freed+=sz;
if (IS_UNCOLLECTABLE(knd))GC_non_gc_bytes-=sz;
if (ok->ok_init&&EXPECT(sz > sizeof(word),TRUE)){
BZERO((word*)p+1,sz-sizeof(word));
}
flh=&(ok->ok_freelist[ngranules]);
obj_link(p)=*flh;
*flh=(ptr_t)p;
UNLOCK();
} else {
size_t nblocks=OBJ_SZ_TO_BLOCKS(sz);
LOCK();
GC_bytes_freed+=sz;
if (IS_UNCOLLECTABLE(knd))GC_non_gc_bytes-=sz;
if (nblocks > 1){
GC_large_allocd_bytes-=nblocks*HBLKSIZE;
}
GC_freehblk(h);
UNLOCK();
}
}
#ifdef THREADS
GC_INNER void GC_free_inner(void*p)
{
struct hblk*h;
hdr*hhdr;
size_t sz;
size_t ngranules;
int knd;
struct obj_kind*ok;
h=HBLKPTR(p);
hhdr=HDR(h);
knd=hhdr->hb_obj_kind;
sz=(size_t)hhdr->hb_sz;
ngranules=BYTES_TO_GRANULES(sz);
ok=&GC_obj_kinds[knd];
if (ngranules<=MAXOBJGRANULES){
void**flh;
GC_bytes_freed+=sz;
if (IS_UNCOLLECTABLE(knd))GC_non_gc_bytes-=sz;
if (ok->ok_init&&EXPECT(sz > sizeof(word),TRUE)){
BZERO((word*)p+1,sz-sizeof(word));
}
flh=&(ok->ok_freelist[ngranules]);
obj_link(p)=*flh;
*flh=(ptr_t)p;
} else {
size_t nblocks=OBJ_SZ_TO_BLOCKS(sz);
GC_bytes_freed+=sz;
if (IS_UNCOLLECTABLE(knd))GC_non_gc_bytes-=sz;
if (nblocks > 1){
GC_large_allocd_bytes-=nblocks*HBLKSIZE;
}
GC_freehblk(h);
}
}
#endif
#if defined(REDIRECT_MALLOC)&&!defined(REDIRECT_FREE)
#define REDIRECT_FREE GC_free
#endif
#if defined(REDIRECT_FREE)&&!defined(REDIRECT_MALLOC_IN_HEADER)
#if defined(CPPCHECK)
#define REDIRECT_FREE_F GC_free
#else
#define REDIRECT_FREE_F REDIRECT_FREE
#endif
void free(void*p)
{
#ifndef IGNORE_FREE
#if defined(GC_LINUX_THREADS)&&!defined(USE_PROC_FOR_LIBRARIES)
ptr_t caller=(ptr_t)__builtin_return_address(0);
if (((word)caller>=(word)GC_libpthread_start
&&(word)caller < (word)GC_libpthread_end)
||((word)caller>=(word)GC_libld_start
&&(word)caller < (word)GC_libld_end)){
GC_free(p);
return;
}
#endif
REDIRECT_FREE_F(p);
#endif
}
#endif
#include <stdio.h>
#include <string.h>
#ifndef MSWINCE
#include <errno.h>
#endif
#ifndef GC_ALLOC_PTRS_H
#define GC_ALLOC_PTRS_H
#ifdef __cplusplus
extern "C" {
#endif
GC_API void**const GC_objfreelist_ptr;
GC_API void**const GC_aobjfreelist_ptr;
GC_API void**const GC_uobjfreelist_ptr;
#ifdef GC_ATOMIC_UNCOLLECTABLE
GC_API void**const GC_auobjfreelist_ptr;
#endif
GC_API void GC_CALL GC_incr_bytes_allocd(size_t bytes);
GC_API void GC_CALL GC_incr_bytes_freed(size_t bytes);
#ifdef __cplusplus
}
#endif
#endif
void**const GC_objfreelist_ptr=GC_objfreelist;
void**const GC_aobjfreelist_ptr=GC_aobjfreelist;
void**const GC_uobjfreelist_ptr=GC_uobjfreelist;
#ifdef GC_ATOMIC_UNCOLLECTABLE
void**const GC_auobjfreelist_ptr=GC_auobjfreelist;
#endif
GC_API int GC_CALL GC_get_kind_and_size(const void*p,size_t*psize)
{
hdr*hhdr=HDR(p);
if (psize!=NULL){
*psize=(size_t)hhdr->hb_sz;
}
return hhdr->hb_obj_kind;
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_generic_or_special_malloc(size_t lb,
int knd)
{
switch(knd){
case PTRFREE:
case NORMAL:
return GC_malloc_kind(lb,knd);
case UNCOLLECTABLE:
#ifdef GC_ATOMIC_UNCOLLECTABLE
case AUNCOLLECTABLE:
#endif
return GC_generic_malloc_uncollectable(lb,knd);
default:
return GC_generic_malloc(lb,knd);
}
}
GC_API void*GC_CALL GC_realloc(void*p,size_t lb)
{
struct hblk*h;
hdr*hhdr;
void*result;
size_t sz;
size_t orig_sz;
int obj_kind;
if (p==0)return(GC_malloc(lb));
if (0==lb){
#ifndef IGNORE_FREE
GC_free(p);
#endif
return NULL;
}
h=HBLKPTR(p);
hhdr=HDR(h);
sz=(size_t)hhdr->hb_sz;
obj_kind=hhdr->hb_obj_kind;
orig_sz=sz;
if (sz > MAXOBJBYTES){
word descr=GC_obj_kinds[obj_kind].ok_descriptor;
sz=(sz+HBLKSIZE-1)&~HBLKMASK;
if (GC_obj_kinds[obj_kind].ok_relocate_descr)
descr+=sz;
#ifdef AO_HAVE_store
GC_STATIC_ASSERT(sizeof(hhdr->hb_sz)==sizeof(AO_t));
AO_store((volatile AO_t*)&hhdr->hb_sz,(AO_t)sz);
AO_store((volatile AO_t*)&hhdr->hb_descr,(AO_t)descr);
#else
{
DCL_LOCK_STATE;
LOCK();
hhdr->hb_sz=sz;
hhdr->hb_descr=descr;
UNLOCK();
}
#endif
#ifdef MARK_BIT_PER_OBJ
GC_ASSERT(hhdr->hb_inv_sz==LARGE_INV_SZ);
#endif
#ifdef MARK_BIT_PER_GRANULE
GC_ASSERT((hhdr->hb_flags&LARGE_BLOCK)!=0
&&hhdr->hb_map[ANY_INDEX]==1);
#endif
if (IS_UNCOLLECTABLE(obj_kind))GC_non_gc_bytes+=(sz - orig_sz);
}
if (ADD_SLOP(lb)<=sz){
if (lb>=(sz>>1)){
if (orig_sz > lb){
BZERO(((ptr_t)p)+lb,orig_sz - lb);
}
return(p);
}
sz=lb;
}
result=GC_generic_or_special_malloc((word)lb,obj_kind);
if (result!=NULL){
BCOPY(p,result,sz);
#ifndef IGNORE_FREE
GC_free(p);
#endif
}
return result;
}
#if defined(REDIRECT_MALLOC)&&!defined(REDIRECT_REALLOC)
#define REDIRECT_REALLOC GC_realloc
#endif
#ifdef REDIRECT_REALLOC
#define GC_debug_realloc_replacement(p,lb)GC_debug_realloc(p,lb,GC_DBG_EXTRAS)
#if!defined(REDIRECT_MALLOC_IN_HEADER)
void*realloc(void*p,size_t lb)
{
return(REDIRECT_REALLOC(p,lb));
}
#endif
#undef GC_debug_realloc_replacement
#endif
GC_API GC_ATTR_MALLOC void*GC_CALL
GC_generic_malloc_ignore_off_page(size_t lb,int k)
{
void*result;
size_t lg;
size_t lb_rounded;
word n_blocks;
GC_bool init;
DCL_LOCK_STATE;
if (SMALL_OBJ(lb))
return GC_generic_malloc(lb,k);
GC_ASSERT(k < MAXOBJKINDS);
lg=ROUNDED_UP_GRANULES(lb);
lb_rounded=GRANULES_TO_BYTES(lg);
n_blocks=OBJ_SZ_TO_BLOCKS(lb_rounded);
init=GC_obj_kinds[k].ok_init;
if (EXPECT(GC_have_errors,FALSE))
GC_print_all_errors();
GC_INVOKE_FINALIZERS();
GC_DBG_COLLECT_AT_MALLOC(lb);
LOCK();
result=(ptr_t)GC_alloc_large(ADD_SLOP(lb),k,IGNORE_OFF_PAGE);
if (NULL==result){
GC_oom_func oom_fn=GC_oom_fn;
UNLOCK();
return (*oom_fn)(lb);
}
if (GC_debugging_started){
BZERO(result,n_blocks*HBLKSIZE);
} else {
#ifdef THREADS
((word*)result)[0]=0;
((word*)result)[1]=0;
((word*)result)[GRANULES_TO_WORDS(lg)-1]=0;
((word*)result)[GRANULES_TO_WORDS(lg)-2]=0;
#endif
}
GC_bytes_allocd+=lb_rounded;
UNLOCK();
if (init&&!GC_debugging_started){
BZERO(result,n_blocks*HBLKSIZE);
}
return(result);
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_malloc_ignore_off_page(size_t lb)
{
return GC_generic_malloc_ignore_off_page(lb,NORMAL);
}
GC_API GC_ATTR_MALLOC void*GC_CALL
GC_malloc_atomic_ignore_off_page(size_t lb)
{
return GC_generic_malloc_ignore_off_page(lb,PTRFREE);
}
GC_API void GC_CALL GC_incr_bytes_allocd(size_t n)
{
GC_bytes_allocd+=n;
}
GC_API void GC_CALL GC_incr_bytes_freed(size_t n)
{
GC_bytes_freed+=n;
}
GC_API size_t GC_CALL GC_get_expl_freed_bytes_since_gc(void)
{
return (size_t)GC_bytes_freed;
}
#ifdef PARALLEL_MARK
STATIC volatile AO_t GC_bytes_allocd_tmp=0;
#endif
GC_API void GC_CALL GC_generic_malloc_many(size_t lb,int k,void**result)
{
void*op;
void*p;
void**opp;
size_t lw;
size_t lg;
signed_word my_bytes_allocd=0;
struct obj_kind*ok=&(GC_obj_kinds[k]);
struct hblk**rlh;
DCL_LOCK_STATE;
GC_ASSERT(lb!=0&&(lb&(GRANULE_BYTES-1))==0);
if (!SMALL_OBJ(lb)||GC_manual_vdb){
op=GC_generic_malloc(lb,k);
if (EXPECT(0!=op,TRUE))
obj_link(op)=0;
*result=op;
#ifndef GC_DISABLE_INCREMENTAL
if (GC_manual_vdb&&GC_is_heap_ptr(result)){
GC_dirty_inner(result);
REACHABLE_AFTER_DIRTY(op);
}
#endif
return;
}
GC_ASSERT(k < MAXOBJKINDS);
lw=BYTES_TO_WORDS(lb);
lg=BYTES_TO_GRANULES(lb);
if (EXPECT(GC_have_errors,FALSE))
GC_print_all_errors();
GC_INVOKE_FINALIZERS();
GC_DBG_COLLECT_AT_MALLOC(lb);
if (!EXPECT(GC_is_initialized,TRUE))GC_init();
LOCK();
if (GC_incremental&&!GC_dont_gc){
ENTER_GC();
GC_collect_a_little_inner(1);
EXIT_GC();
}
rlh=ok->ok_reclaim_list;
if (rlh!=NULL){
struct hblk*hbp;
hdr*hhdr;
for (rlh+=lg;(hbp=*rlh)!=NULL;){
hhdr=HDR(hbp);
*rlh=hhdr->hb_next;
GC_ASSERT(hhdr->hb_sz==lb);
hhdr->hb_last_reclaimed=(unsigned short)GC_gc_no;
#ifdef PARALLEL_MARK
if (GC_parallel){
signed_word my_bytes_allocd_tmp=
(signed_word)AO_load(&GC_bytes_allocd_tmp);
GC_ASSERT(my_bytes_allocd_tmp>=0);
if (my_bytes_allocd_tmp!=0){
(void)AO_fetch_and_add(&GC_bytes_allocd_tmp,
(AO_t)(-my_bytes_allocd_tmp));
GC_bytes_allocd+=my_bytes_allocd_tmp;
}
GC_acquire_mark_lock();
++GC_fl_builder_count;
UNLOCK();
GC_release_mark_lock();
}
#endif
op=GC_reclaim_generic(hbp,hhdr,lb,
ok->ok_init,0,&my_bytes_allocd);
if (op!=0){
#ifdef PARALLEL_MARK
if (GC_parallel){
*result=op;
(void)AO_fetch_and_add(&GC_bytes_allocd_tmp,
(AO_t)my_bytes_allocd);
GC_acquire_mark_lock();
--GC_fl_builder_count;
if (GC_fl_builder_count==0)GC_notify_all_builder();
#ifdef THREAD_SANITIZER
GC_release_mark_lock();
LOCK();
GC_bytes_found+=my_bytes_allocd;
UNLOCK();
#else
GC_bytes_found+=my_bytes_allocd;
GC_release_mark_lock();
#endif
(void)GC_clear_stack(0);
return;
}
#endif
GC_bytes_found+=my_bytes_allocd;
GC_bytes_allocd+=my_bytes_allocd;
goto out;
}
#ifdef PARALLEL_MARK
if (GC_parallel){
GC_acquire_mark_lock();
--GC_fl_builder_count;
if (GC_fl_builder_count==0)GC_notify_all_builder();
GC_release_mark_lock();
LOCK();
}
#endif
}
}
opp=&(GC_obj_kinds[k].ok_freelist[lg]);
if ( (op=*opp)!=0){
*opp=0;
my_bytes_allocd=0;
for (p=op;p!=0;p=obj_link(p)){
my_bytes_allocd+=lb;
if ((word)my_bytes_allocd>=HBLKSIZE){
*opp=obj_link(p);
obj_link(p)=0;
break;
}
}
GC_bytes_allocd+=my_bytes_allocd;
goto out;
}
{
struct hblk*h=GC_allochblk(lb,k,0);
if (h){
if (IS_UNCOLLECTABLE(k))GC_set_hdr_marks(HDR(h));
GC_bytes_allocd+=HBLKSIZE - HBLKSIZE % lb;
#ifdef PARALLEL_MARK
if (GC_parallel){
GC_acquire_mark_lock();
++GC_fl_builder_count;
UNLOCK();
GC_release_mark_lock();
op=GC_build_fl(h,lw,
(ok->ok_init||GC_debugging_started),0);
*result=op;
GC_acquire_mark_lock();
--GC_fl_builder_count;
if (GC_fl_builder_count==0)GC_notify_all_builder();
GC_release_mark_lock();
(void)GC_clear_stack(0);
return;
}
#endif
op=GC_build_fl(h,lw,(ok->ok_init||GC_debugging_started),0);
goto out;
}
}
op=GC_generic_malloc_inner(lb,k);
if (0!=op)obj_link(op)=0;
out:
*result=op;
UNLOCK();
(void)GC_clear_stack(0);
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_malloc_many(size_t lb)
{
void*result;
lb=SIZET_SAT_ADD(lb,EXTRA_BYTES+GRANULE_BYTES - 1)
&~(GRANULE_BYTES - 1);
GC_generic_malloc_many(lb,NORMAL,&result);
return result;
}
#include <limits.h>
GC_API GC_ATTR_MALLOC void*GC_CALL GC_memalign(size_t align,size_t lb)
{
size_t new_lb;
size_t offset;
ptr_t result;
if (align<=GRANULE_BYTES)return GC_malloc(lb);
if (align>=HBLKSIZE/2||lb>=HBLKSIZE/2){
if (align > HBLKSIZE){
return (*GC_get_oom_fn())(LONG_MAX-1024);
}
return GC_malloc(lb<=HBLKSIZE?HBLKSIZE:lb);
}
new_lb=SIZET_SAT_ADD(lb,align - 1);
result=(ptr_t)GC_malloc(new_lb);
offset=(word)result % align;
if (offset!=0){
offset=align - offset;
if (!GC_all_interior_pointers){
GC_STATIC_ASSERT(VALID_OFFSET_SZ<=HBLKSIZE);
GC_ASSERT(offset < VALID_OFFSET_SZ);
GC_register_displacement(offset);
}
}
result+=offset;
GC_ASSERT((word)result % align==0);
return result;
}
GC_API int GC_CALL GC_posix_memalign(void**memptr,size_t align,size_t lb)
{
size_t align_minus_one=align - 1;
if (align < sizeof(void*)||(align_minus_one&align)!=0){
#ifdef MSWINCE
return ERROR_INVALID_PARAMETER;
#else
return EINVAL;
#endif
}
if ((*memptr=GC_memalign(align,lb))==NULL){
#ifdef MSWINCE
return ERROR_NOT_ENOUGH_MEMORY;
#else
return ENOMEM;
#endif
}
return 0;
}
GC_API GC_ATTR_MALLOC char*GC_CALL GC_strdup(const char*s)
{
char*copy;
size_t lb;
if (s==NULL)return NULL;
lb=strlen(s)+1;
copy=(char*)GC_malloc_atomic(lb);
if (NULL==copy){
#ifndef MSWINCE
errno=ENOMEM;
#endif
return NULL;
}
BCOPY(s,copy,lb);
return copy;
}
GC_API GC_ATTR_MALLOC char*GC_CALL GC_strndup(const char*str,size_t size)
{
char*copy;
size_t len=strlen(str);
if (len > size)
len=size;
copy=(char*)GC_malloc_atomic(len+1);
if (copy==NULL){
#ifndef MSWINCE
errno=ENOMEM;
#endif
return NULL;
}
if (EXPECT(len > 0,TRUE))
BCOPY(str,copy,len);
copy[len]='\0';
return copy;
}
#ifdef GC_REQUIRE_WCSDUP
#include <wchar.h>
GC_API GC_ATTR_MALLOC wchar_t*GC_CALL GC_wcsdup(const wchar_t*str)
{
size_t lb=(wcslen(str)+1)*sizeof(wchar_t);
wchar_t*copy=(wchar_t*)GC_malloc_atomic(lb);
if (copy==NULL){
#ifndef MSWINCE
errno=ENOMEM;
#endif
return NULL;
}
BCOPY(str,copy,lb);
return copy;
}
#endif
#ifndef CPPCHECK
GC_API void*GC_CALL GC_malloc_stubborn(size_t lb)
{
return GC_malloc(lb);
}
GC_API void GC_CALL GC_change_stubborn(const void*p GC_ATTR_UNUSED)
{
}
#endif
GC_API void GC_CALL GC_end_stubborn_change(const void*p)
{
GC_dirty(p);
}
GC_API void GC_CALL GC_ptr_store_and_dirty(void*p,const void*q)
{
*(const void**)p=q;
GC_dirty(p);
REACHABLE_AFTER_DIRTY(q);
}
#if defined(__MINGW32__)&&!defined(__MINGW_EXCPT_DEFINE_PSDK)&&defined(__i386__)
#define __MINGW_EXCPT_DEFINE_PSDK 1
#endif
#include <stdio.h>
#if defined(MSWIN32)&&defined(__GNUC__)
#include <excpt.h>
#endif
GC_ATTR_NOINLINE
void GC_noop6(word arg1 GC_ATTR_UNUSED,word arg2 GC_ATTR_UNUSED,
word arg3 GC_ATTR_UNUSED,word arg4 GC_ATTR_UNUSED,
word arg5 GC_ATTR_UNUSED,word arg6 GC_ATTR_UNUSED)
{
#if defined(AO_HAVE_compiler_barrier)&&!defined(BASE_ATOMIC_OPS_EMULATED)
AO_compiler_barrier();
#else
GC_noop1(0);
#endif
}
volatile word GC_noop_sink;
GC_ATTR_NO_SANITIZE_THREAD
GC_API void GC_CALL GC_noop1(word x)
{
GC_noop_sink=x;
}
GC_INNER struct obj_kind GC_obj_kinds[MAXOBJKINDS]={
{&GC_aobjfreelist[0],0,
GC_DS_LENGTH,FALSE,FALSE
OK_DISCLAIM_INITZ },
{&GC_objfreelist[0],0,
GC_DS_LENGTH,
TRUE,TRUE
OK_DISCLAIM_INITZ },
{&GC_uobjfreelist[0],0,
GC_DS_LENGTH,TRUE,TRUE
OK_DISCLAIM_INITZ },
#ifdef GC_ATOMIC_UNCOLLECTABLE
{&GC_auobjfreelist[0],0,
GC_DS_LENGTH,FALSE,FALSE
OK_DISCLAIM_INITZ },
#endif
};
#ifndef INITIAL_MARK_STACK_SIZE
#define INITIAL_MARK_STACK_SIZE (1*HBLKSIZE)
#endif
#if!defined(GC_DISABLE_INCREMENTAL)
STATIC word GC_n_rescuing_pages=0;
#endif
#ifdef PARALLEL_MARK
GC_INNER GC_bool GC_parallel_mark_disabled=FALSE;
#endif
GC_INNER GC_bool GC_collection_in_progress(void)
{
return(GC_mark_state!=MS_NONE);
}
GC_INNER void GC_clear_hdr_marks(hdr*hhdr)
{
size_t last_bit;
#ifdef AO_HAVE_load
last_bit=FINAL_MARK_BIT((size_t)AO_load((volatile AO_t*)&hhdr->hb_sz));
#else
last_bit=FINAL_MARK_BIT((size_t)hhdr->hb_sz);
#endif
BZERO(hhdr->hb_marks,sizeof(hhdr->hb_marks));
set_mark_bit_from_hdr(hhdr,last_bit);
hhdr->hb_n_marks=0;
}
GC_INNER void GC_set_hdr_marks(hdr*hhdr)
{
unsigned i;
size_t sz=(size_t)hhdr->hb_sz;
unsigned n_marks=(unsigned)FINAL_MARK_BIT(sz);
#ifdef USE_MARK_BYTES
for (i=0;i<=n_marks;i+=(unsigned)MARK_BIT_OFFSET(sz)){
hhdr->hb_marks[i]=1;
}
#else
for (i=0;i < divWORDSZ(n_marks+WORDSZ);++i){
hhdr->hb_marks[i]=GC_WORD_MAX;
}
#endif
#ifdef MARK_BIT_PER_OBJ
hhdr->hb_n_marks=n_marks;
#else
hhdr->hb_n_marks=HBLK_OBJS(sz);
#endif
}
static void clear_marks_for_block(struct hblk*h,word dummy GC_ATTR_UNUSED)
{
hdr*hhdr=HDR(h);
if (IS_UNCOLLECTABLE(hhdr->hb_obj_kind))return;
GC_clear_hdr_marks(hhdr);
}
GC_API void GC_CALL GC_set_mark_bit(const void*p)
{
struct hblk*h=HBLKPTR(p);
hdr*hhdr=HDR(h);
word bit_no=MARK_BIT_NO((ptr_t)p - (ptr_t)h,hhdr->hb_sz);
if (!mark_bit_from_hdr(hhdr,bit_no)){
set_mark_bit_from_hdr(hhdr,bit_no);
++hhdr->hb_n_marks;
}
}
GC_API void GC_CALL GC_clear_mark_bit(const void*p)
{
struct hblk*h=HBLKPTR(p);
hdr*hhdr=HDR(h);
word bit_no=MARK_BIT_NO((ptr_t)p - (ptr_t)h,hhdr->hb_sz);
if (mark_bit_from_hdr(hhdr,bit_no)){
size_t n_marks=hhdr->hb_n_marks;
GC_ASSERT(n_marks!=0);
clear_mark_bit_from_hdr(hhdr,bit_no);
n_marks--;
#ifdef PARALLEL_MARK
if (n_marks!=0||!GC_parallel)
hhdr->hb_n_marks=n_marks;
#else
hhdr->hb_n_marks=n_marks;
#endif
}
}
GC_API int GC_CALL GC_is_marked(const void*p)
{
struct hblk*h=HBLKPTR(p);
hdr*hhdr=HDR(h);
word bit_no=MARK_BIT_NO((ptr_t)p - (ptr_t)h,hhdr->hb_sz);
return (int)mark_bit_from_hdr(hhdr,bit_no);
}
GC_INNER void GC_clear_marks(void)
{
GC_apply_to_all_blocks(clear_marks_for_block,(word)0);
GC_objects_are_marked=FALSE;
GC_mark_state=MS_INVALID;
GC_scan_ptr=NULL;
}
GC_INNER void GC_initiate_gc(void)
{
GC_ASSERT(I_HOLD_LOCK());
#ifndef GC_DISABLE_INCREMENTAL
if (GC_incremental){
#ifdef CHECKSUMS
GC_read_dirty(FALSE);
GC_check_dirty();
#else
GC_read_dirty(GC_mark_state==MS_INVALID);
#endif
}
GC_n_rescuing_pages=0;
#endif
if (GC_mark_state==MS_NONE){
GC_mark_state=MS_PUSH_RESCUERS;
} else if (GC_mark_state!=MS_INVALID){
ABORT("Unexpected state");
}
GC_scan_ptr=NULL;
}
#ifdef PARALLEL_MARK
STATIC void GC_do_parallel_mark(void);
#endif
#ifdef GC_DISABLE_INCREMENTAL
#define GC_push_next_marked_dirty(h)GC_push_next_marked(h)
#else
STATIC struct hblk*GC_push_next_marked_dirty(struct hblk*h);
#endif
STATIC struct hblk*GC_push_next_marked(struct hblk*h);
STATIC struct hblk*GC_push_next_marked_uncollectable(struct hblk*h);
static void alloc_mark_stack(size_t);
#ifdef WRAP_MARK_SOME
STATIC GC_bool GC_mark_some_inner(ptr_t cold_gc_frame)
#else
GC_INNER GC_bool GC_mark_some(ptr_t cold_gc_frame)
#endif
{
switch(GC_mark_state){
case MS_NONE:
break;
case MS_PUSH_RESCUERS:
if ((word)GC_mark_stack_top
>=(word)(GC_mark_stack_limit - INITIAL_MARK_STACK_SIZE/2)){
GC_mark_stack_too_small=TRUE;
MARK_FROM_MARK_STACK();
break;
} else {
GC_scan_ptr=GC_push_next_marked_dirty(GC_scan_ptr);
if (NULL==GC_scan_ptr){
#if!defined(GC_DISABLE_INCREMENTAL)
GC_COND_LOG_PRINTF("Marked from %lu dirty pages\n",
(unsigned long)GC_n_rescuing_pages);
#endif
GC_push_roots(FALSE,cold_gc_frame);
GC_objects_are_marked=TRUE;
if (GC_mark_state!=MS_INVALID){
GC_mark_state=MS_ROOTS_PUSHED;
}
}
}
break;
case MS_PUSH_UNCOLLECTABLE:
if ((word)GC_mark_stack_top
>=(word)(GC_mark_stack+GC_mark_stack_size/4)){
#ifdef PARALLEL_MARK
if (GC_parallel)GC_mark_stack_too_small=TRUE;
#endif
MARK_FROM_MARK_STACK();
break;
} else {
GC_scan_ptr=GC_push_next_marked_uncollectable(GC_scan_ptr);
if (NULL==GC_scan_ptr){
GC_push_roots(TRUE,cold_gc_frame);
GC_objects_are_marked=TRUE;
if (GC_mark_state!=MS_INVALID){
GC_mark_state=MS_ROOTS_PUSHED;
}
}
}
break;
case MS_ROOTS_PUSHED:
#ifdef PARALLEL_MARK
if (GC_parallel&&!GC_parallel_mark_disabled){
GC_do_parallel_mark();
GC_ASSERT((word)GC_mark_stack_top < (word)GC_first_nonempty);
GC_mark_stack_top=GC_mark_stack - 1;
if (GC_mark_stack_too_small){
alloc_mark_stack(2*GC_mark_stack_size);
}
if (GC_mark_state==MS_ROOTS_PUSHED){
GC_mark_state=MS_NONE;
return(TRUE);
}
break;
}
#endif
if ((word)GC_mark_stack_top>=(word)GC_mark_stack){
MARK_FROM_MARK_STACK();
break;
} else {
GC_mark_state=MS_NONE;
if (GC_mark_stack_too_small){
alloc_mark_stack(2*GC_mark_stack_size);
}
return(TRUE);
}
case MS_INVALID:
case MS_PARTIALLY_INVALID:
if (!GC_objects_are_marked){
GC_mark_state=MS_PUSH_UNCOLLECTABLE;
break;
}
if ((word)GC_mark_stack_top>=(word)GC_mark_stack){
MARK_FROM_MARK_STACK();
break;
}
if (NULL==GC_scan_ptr&&GC_mark_state==MS_INVALID){
if (GC_mark_stack_too_small){
alloc_mark_stack(2*GC_mark_stack_size);
}
GC_mark_state=MS_PARTIALLY_INVALID;
}
GC_scan_ptr=GC_push_next_marked(GC_scan_ptr);
if (NULL==GC_scan_ptr&&GC_mark_state==MS_PARTIALLY_INVALID){
GC_push_roots(TRUE,cold_gc_frame);
GC_objects_are_marked=TRUE;
if (GC_mark_state!=MS_INVALID){
GC_mark_state=MS_ROOTS_PUSHED;
}
}
break;
default:
ABORT("GC_mark_some:bad state");
}
return(FALSE);
}
#ifdef WRAP_MARK_SOME
#if (defined(MSWIN32)||defined(MSWINCE))&&defined(__GNUC__)
typedef struct {
EXCEPTION_REGISTRATION ex_reg;
void*alt_path;
} ext_ex_regn;
static EXCEPTION_DISPOSITION mark_ex_handler(
struct _EXCEPTION_RECORD*ex_rec,
void*est_frame,
struct _CONTEXT*context,
void*disp_ctxt GC_ATTR_UNUSED)
{
if (ex_rec->ExceptionCode==STATUS_ACCESS_VIOLATION){
ext_ex_regn*xer=(ext_ex_regn*)est_frame;
context->Esp=context->Ebp;
context->Ebp=*((DWORD*)context->Esp);
context->Esp=context->Esp - 8;
context->Eip=(DWORD)(xer->alt_path);
return ExceptionContinueExecution;
} else {
return ExceptionContinueSearch;
}
}
#endif
GC_INNER GC_bool GC_mark_some(ptr_t cold_gc_frame)
{
GC_bool ret_val;
#if defined(MSWIN32)||defined(MSWINCE)
#ifndef __GNUC__
__try {
ret_val=GC_mark_some_inner(cold_gc_frame);
} __except (GetExceptionCode()==EXCEPTION_ACCESS_VIOLATION?
EXCEPTION_EXECUTE_HANDLER:EXCEPTION_CONTINUE_SEARCH){
goto handle_ex;
}
#if defined(GC_WIN32_THREADS)&&!defined(GC_PTHREADS)
if (GC_started_thread_while_stopped())
goto handle_thr_start;
#endif
rm_handler:
return ret_val;
#else
ext_ex_regn er;
#if GC_GNUC_PREREQ(4,7)||GC_CLANG_PREREQ(3,3)
#pragma GCC diagnostic push
#if defined(__clang__)||GC_GNUC_PREREQ(6,4)
#pragma GCC diagnostic ignored "-Wpedantic"
#else
#pragma GCC diagnostic ignored "-pedantic"
#endif
er.alt_path=&&handle_ex;
#pragma GCC diagnostic pop
#elif!defined(CPPCHECK)
er.alt_path=&&handle_ex;
#endif
er.ex_reg.handler=mark_ex_handler;
__asm__ __volatile__ ("movl %%fs:0,%0":"=r" (er.ex_reg.prev));
__asm__ __volatile__ ("movl %0,%%fs:0"::"r" (&er));
ret_val=GC_mark_some_inner(cold_gc_frame);
if (er.alt_path==0)
goto handle_ex;
#if defined(GC_WIN32_THREADS)&&!defined(GC_PTHREADS)
if (GC_started_thread_while_stopped())
goto handle_thr_start;
#endif
rm_handler:
__asm__ __volatile__ ("mov %0,%%fs:0"::"r" (er.ex_reg.prev));
return ret_val;
#endif
#else
#ifndef DEFAULT_VDB
if (GC_auto_incremental){
WARN("Incremental GC incompatible with/proc roots\n",0);
}
#endif
GC_setup_temporary_fault_handler();
if(SETJMP(GC_jmp_buf)!=0)goto handle_ex;
ret_val=GC_mark_some_inner(cold_gc_frame);
rm_handler:
GC_reset_fault_handler();
return ret_val;
#endif
handle_ex:
{
static word warned_gc_no;
if (warned_gc_no!=GC_gc_no){
WARN("Caught ACCESS_VIOLATION in marker;"
" memory mapping disappeared\n",0);
warned_gc_no=GC_gc_no;
}
}
#if (defined(MSWIN32)||defined(MSWINCE))&&defined(GC_WIN32_THREADS)&&!defined(GC_PTHREADS)
handle_thr_start:
#endif
#ifdef REGISTER_LIBRARIES_EARLY
START_WORLD();
GC_cond_register_dynamic_libraries();
STOP_WORLD();
#endif
GC_invalidate_mark_state();
GC_scan_ptr=NULL;
ret_val=FALSE;
goto rm_handler;
}
#endif
GC_INNER void GC_invalidate_mark_state(void)
{
GC_mark_state=MS_INVALID;
GC_mark_stack_top=GC_mark_stack-1;
}
GC_INNER mse*GC_signal_mark_stack_overflow(mse*msp)
{
GC_mark_state=MS_INVALID;
#ifdef PARALLEL_MARK
if (!GC_parallel)
GC_mark_stack_too_small=TRUE;
#else
GC_mark_stack_too_small=TRUE;
#endif
GC_COND_LOG_PRINTF("Mark stack overflow;current size=%lu entries\n",
(unsigned long)GC_mark_stack_size);
return(msp - GC_MARK_STACK_DISCARDS);
}
GC_ATTR_NO_SANITIZE_ADDR GC_ATTR_NO_SANITIZE_MEMORY GC_ATTR_NO_SANITIZE_THREAD
GC_INNER mse*GC_mark_from(mse*mark_stack_top,mse*mark_stack,
mse*mark_stack_limit)
{
signed_word credit=HBLKSIZE;
ptr_t current_p;
word current;
ptr_t limit=0;
word descr;
ptr_t greatest_ha=(ptr_t)GC_greatest_plausible_heap_addr;
ptr_t least_ha=(ptr_t)GC_least_plausible_heap_addr;
DECLARE_HDR_CACHE;
#define SPLIT_RANGE_WORDS 128
GC_objects_are_marked=TRUE;
INIT_HDR_CACHE;
#ifdef OS2
while ((word)mark_stack_top>=(word)mark_stack&&credit>=0)
#else
while (((((word)mark_stack_top - (word)mark_stack)|(word)credit)
&SIGNB)==0)
#endif
{
current_p=mark_stack_top->mse_start;
descr=mark_stack_top->mse_descr.w;
retry:
if (descr&((~(WORDS_TO_BYTES(SPLIT_RANGE_WORDS)- 1))|GC_DS_TAGS)){
word tag=descr&GC_DS_TAGS;
GC_STATIC_ASSERT(GC_DS_TAGS==0x3);
switch(tag){
case GC_DS_LENGTH:
GC_ASSERT(descr < (word)GC_greatest_plausible_heap_addr
- (word)GC_least_plausible_heap_addr
||(word)(current_p+descr)
<=(word)GC_least_plausible_heap_addr
||(word)current_p>=(word)GC_greatest_plausible_heap_addr);
#ifdef PARALLEL_MARK
#define SHARE_BYTES 2048
if (descr > SHARE_BYTES&&GC_parallel
&&(word)mark_stack_top < (word)(mark_stack_limit - 1)){
word new_size=(descr/2)&~(word)(sizeof(word)-1);
mark_stack_top->mse_start=current_p;
mark_stack_top->mse_descr.w=new_size+sizeof(word);
mark_stack_top++;
#ifdef ENABLE_TRACE
if ((word)GC_trace_addr>=(word)current_p
&&(word)GC_trace_addr < (word)(current_p+descr)){
GC_log_printf("GC #%u:large section;start %p,len %lu,"
" splitting (parallel)at %p\n",
(unsigned)GC_gc_no,(void*)current_p,
(unsigned long)descr,
(void*)(current_p+new_size));
}
#endif
current_p+=new_size;
descr-=new_size;
goto retry;
}
#endif
mark_stack_top->mse_start=
limit=current_p+WORDS_TO_BYTES(SPLIT_RANGE_WORDS-1);
mark_stack_top->mse_descr.w=
descr - WORDS_TO_BYTES(SPLIT_RANGE_WORDS-1);
#ifdef ENABLE_TRACE
if ((word)GC_trace_addr>=(word)current_p
&&(word)GC_trace_addr < (word)(current_p+descr)){
GC_log_printf("GC #%u:large section;start %p,len %lu,"
" splitting at %p\n",
(unsigned)GC_gc_no,(void*)current_p,
(unsigned long)descr,(void*)limit);
}
#endif
limit+=sizeof(word)- ALIGNMENT;
break;
case GC_DS_BITMAP:
mark_stack_top--;
#ifdef ENABLE_TRACE
if ((word)GC_trace_addr>=(word)current_p
&&(word)GC_trace_addr < (word)(current_p
+WORDS_TO_BYTES(WORDSZ-2))){
GC_log_printf("GC #%u:tracing from %p bitmap descr %lu\n",
(unsigned)GC_gc_no,(void*)current_p,
(unsigned long)descr);
}
#endif
descr&=~GC_DS_TAGS;
credit-=WORDS_TO_BYTES(WORDSZ/2);
while (descr!=0){
if ((descr&SIGNB)!=0){
current=*(word*)current_p;
FIXUP_POINTER(current);
if (current>=(word)least_ha&&current < (word)greatest_ha){
PREFETCH((ptr_t)current);
#ifdef ENABLE_TRACE
if (GC_trace_addr==current_p){
GC_log_printf("GC #%u:considering(3)%p->%p\n",
(unsigned)GC_gc_no,(void*)current_p,
(void*)current);
}
#endif
PUSH_CONTENTS((ptr_t)current,mark_stack_top,
mark_stack_limit,current_p);
}
}
descr<<=1;
current_p+=sizeof(word);
}
continue;
case GC_DS_PROC:
mark_stack_top--;
#ifdef ENABLE_TRACE
if ((word)GC_trace_addr>=(word)current_p
&&GC_base(current_p)!=0
&&GC_base(current_p)==GC_base(GC_trace_addr)){
GC_log_printf("GC #%u:tracing from %p,proc descr %lu\n",
(unsigned)GC_gc_no,(void*)current_p,
(unsigned long)descr);
}
#endif
credit-=GC_PROC_BYTES;
mark_stack_top=(*PROC(descr))((word*)current_p,mark_stack_top,
mark_stack_limit,ENV(descr));
continue;
case GC_DS_PER_OBJECT:
if ((signed_word)descr>=0){
descr=*(word*)(current_p+descr - GC_DS_PER_OBJECT);
} else {
ptr_t type_descr=*(ptr_t*)current_p;
if (EXPECT(0==type_descr,FALSE)){
mark_stack_top--;
continue;
}
descr=*(word*)(type_descr
- ((signed_word)descr+(GC_INDIR_PER_OBJ_BIAS
- GC_DS_PER_OBJECT)));
}
if (0==descr){
mark_stack_top--;
continue;
}
goto retry;
}
} else {
mark_stack_top--;
#ifndef SMALL_CONFIG
if (descr < sizeof(word))
continue;
#endif
#ifdef ENABLE_TRACE
if ((word)GC_trace_addr>=(word)current_p
&&(word)GC_trace_addr < (word)(current_p+descr)){
GC_log_printf("GC #%u:small object;start %p,len %lu\n",
(unsigned)GC_gc_no,(void*)current_p,
(unsigned long)descr);
}
#endif
limit=current_p+(word)descr;
}
GC_ASSERT(!((word)current_p&(ALIGNMENT-1)));
credit-=limit - current_p;
limit-=sizeof(word);
{
#define PREF_DIST 4
#ifndef SMALL_CONFIG
word deferred;
for(;;){
PREFETCH(limit - PREF_DIST*CACHE_LINE_SIZE);
GC_ASSERT((word)limit>=(word)current_p);
deferred=*(word*)limit;
FIXUP_POINTER(deferred);
limit-=ALIGNMENT;
if (deferred>=(word)least_ha&&deferred < (word)greatest_ha){
PREFETCH((ptr_t)deferred);
break;
}
if ((word)current_p > (word)limit)goto next_object;
deferred=*(word*)limit;
FIXUP_POINTER(deferred);
limit-=ALIGNMENT;
if (deferred>=(word)least_ha&&deferred < (word)greatest_ha){
PREFETCH((ptr_t)deferred);
break;
}
if ((word)current_p > (word)limit)goto next_object;
}
#endif
while ((word)current_p<=(word)limit){
current=*(word*)current_p;
FIXUP_POINTER(current);
PREFETCH(current_p+PREF_DIST*CACHE_LINE_SIZE);
if (current>=(word)least_ha&&current < (word)greatest_ha){
PREFETCH((ptr_t)current);
#ifdef ENABLE_TRACE
if (GC_trace_addr==current_p){
GC_log_printf("GC #%u:considering(1)%p->%p\n",
(unsigned)GC_gc_no,(void*)current_p,
(void*)current);
}
#endif
PUSH_CONTENTS((ptr_t)current,mark_stack_top,
mark_stack_limit,current_p);
}
current_p+=ALIGNMENT;
}
#ifndef SMALL_CONFIG
#ifdef ENABLE_TRACE
if (GC_trace_addr==current_p){
GC_log_printf("GC #%u:considering(2)%p->%p\n",
(unsigned)GC_gc_no,(void*)current_p,
(void*)deferred);
}
#endif
PUSH_CONTENTS((ptr_t)deferred,mark_stack_top,
mark_stack_limit,current_p);
next_object:;
#endif
}
}
return mark_stack_top;
}
#ifdef PARALLEL_MARK
STATIC GC_bool GC_help_wanted=FALSE;
STATIC unsigned GC_helper_count=0;
STATIC unsigned GC_active_count=0;
GC_INNER word GC_mark_no=0;
#ifdef LINT2
#define LOCAL_MARK_STACK_SIZE (HBLKSIZE/8)
#else
#define LOCAL_MARK_STACK_SIZE HBLKSIZE
#endif
GC_INNER void GC_wait_for_markers_init(void)
{
signed_word count;
if (GC_markers_m1==0)
return;
#ifndef CAN_HANDLE_FORK
GC_ASSERT(NULL==GC_main_local_mark_stack);
#else
if (NULL==GC_main_local_mark_stack)
#endif
{
size_t bytes_to_get=
ROUNDUP_PAGESIZE_IF_MMAP(LOCAL_MARK_STACK_SIZE*sizeof(mse));
GC_ASSERT(GC_page_size!=0);
GC_main_local_mark_stack=(mse*)GET_MEM(bytes_to_get);
if (NULL==GC_main_local_mark_stack)
ABORT("Insufficient memory for main local_mark_stack");
GC_add_to_our_memory((ptr_t)GC_main_local_mark_stack,bytes_to_get);
}
GC_acquire_mark_lock();
GC_fl_builder_count+=GC_markers_m1;
count=GC_fl_builder_count;
GC_release_mark_lock();
if (count!=0){
GC_ASSERT(count > 0);
GC_wait_for_reclaim();
}
}
STATIC mse*GC_steal_mark_stack(mse*low,mse*high,mse*local,
unsigned max,mse**next)
{
mse*p;
mse*top=local - 1;
unsigned i=0;
GC_ASSERT((word)high>=(word)(low - 1)
&&(word)(high - low+1)<=GC_mark_stack_size);
for (p=low;(word)p<=(word)high&&i<=max;++p){
word descr=(word)AO_load(&p->mse_descr.ao);
if (descr!=0){
AO_store_release_write(&p->mse_descr.ao,0);
++top;
top->mse_descr.w=descr;
top->mse_start=p->mse_start;
GC_ASSERT((descr&GC_DS_TAGS)!=GC_DS_LENGTH
||descr < (word)GC_greatest_plausible_heap_addr
- (word)GC_least_plausible_heap_addr
||(word)(p->mse_start+descr)
<=(word)GC_least_plausible_heap_addr
||(word)p->mse_start
>=(word)GC_greatest_plausible_heap_addr);
++i;
if ((descr&GC_DS_TAGS)==GC_DS_LENGTH)i+=(int)(descr>>8);
}
}
*next=p;
return top;
}
STATIC void GC_return_mark_stack(mse*low,mse*high)
{
mse*my_top;
mse*my_start;
size_t stack_size;
if ((word)high < (word)low)return;
stack_size=high - low+1;
GC_acquire_mark_lock();
my_top=GC_mark_stack_top;
my_start=my_top+1;
if ((word)(my_start - GC_mark_stack+stack_size)
> (word)GC_mark_stack_size){
GC_COND_LOG_PRINTF("No room to copy back mark stack\n");
GC_mark_state=MS_INVALID;
GC_mark_stack_too_small=TRUE;
} else {
BCOPY(low,my_start,stack_size*sizeof(mse));
GC_ASSERT((mse*)AO_load((volatile AO_t*)(&GC_mark_stack_top))
==my_top);
AO_store_release_write((volatile AO_t*)(&GC_mark_stack_top),
(AO_t)(my_top+stack_size));
}
GC_release_mark_lock();
GC_notify_all_marker();
}
#ifndef N_LOCAL_ITERS
#define N_LOCAL_ITERS 1
#endif
static GC_bool has_inactive_helpers(void)
{
GC_bool res;
GC_acquire_mark_lock();
res=GC_active_count < GC_helper_count;
GC_release_mark_lock();
return res;
}
STATIC void GC_do_local_mark(mse*local_mark_stack,mse*local_top)
{
unsigned n;
for (;;){
for (n=0;n < N_LOCAL_ITERS;++n){
local_top=GC_mark_from(local_top,local_mark_stack,
local_mark_stack+LOCAL_MARK_STACK_SIZE);
if ((word)local_top < (word)local_mark_stack)return;
if ((word)(local_top - local_mark_stack)
>=LOCAL_MARK_STACK_SIZE/2){
GC_return_mark_stack(local_mark_stack,local_top);
return;
}
}
if ((word)AO_load((volatile AO_t*)&GC_mark_stack_top)
< (word)AO_load(&GC_first_nonempty)
&&(word)local_top > (word)(local_mark_stack+1)
&&has_inactive_helpers()){
mse*new_bottom=local_mark_stack
+(local_top - local_mark_stack)/2;
GC_ASSERT((word)new_bottom > (word)local_mark_stack
&&(word)new_bottom < (word)local_top);
GC_return_mark_stack(local_mark_stack,new_bottom - 1);
memmove(local_mark_stack,new_bottom,
(local_top - new_bottom+1)*sizeof(mse));
local_top-=(new_bottom - local_mark_stack);
}
}
}
#ifndef ENTRIES_TO_GET
#define ENTRIES_TO_GET 5
#endif
STATIC void GC_mark_local(mse*local_mark_stack,int id)
{
mse*my_first_nonempty;
GC_active_count++;
my_first_nonempty=(mse*)AO_load(&GC_first_nonempty);
GC_ASSERT((word)GC_mark_stack<=(word)my_first_nonempty);
GC_ASSERT((word)my_first_nonempty
<=(word)AO_load((volatile AO_t*)&GC_mark_stack_top)+sizeof(mse));
GC_VERBOSE_LOG_PRINTF("Starting mark helper %d\n",id);
GC_release_mark_lock();
for (;;){
size_t n_on_stack;
unsigned n_to_get;
mse*my_top;
mse*local_top;
mse*global_first_nonempty=(mse*)AO_load(&GC_first_nonempty);
GC_ASSERT((word)my_first_nonempty>=(word)GC_mark_stack&&
(word)my_first_nonempty<=
(word)AO_load((volatile AO_t*)&GC_mark_stack_top)
+sizeof(mse));
GC_ASSERT((word)global_first_nonempty>=(word)GC_mark_stack);
if ((word)my_first_nonempty < (word)global_first_nonempty){
my_first_nonempty=global_first_nonempty;
} else if ((word)global_first_nonempty < (word)my_first_nonempty){
(void)AO_compare_and_swap(&GC_first_nonempty,
(AO_t)global_first_nonempty,
(AO_t)my_first_nonempty);
}
my_top=(mse*)AO_load_acquire((volatile AO_t*)(&GC_mark_stack_top));
if ((word)my_top < (word)my_first_nonempty){
GC_acquire_mark_lock();
my_top=GC_mark_stack_top;
n_on_stack=my_top - my_first_nonempty+1;
if (0==n_on_stack){
GC_active_count--;
GC_ASSERT(GC_active_count<=GC_helper_count);
if (0==GC_active_count)GC_notify_all_marker();
while (GC_active_count > 0
&&(word)AO_load(&GC_first_nonempty)
> (word)GC_mark_stack_top){
GC_wait_marker();
}
if (GC_active_count==0
&&(word)AO_load(&GC_first_nonempty)
> (word)GC_mark_stack_top){
GC_bool need_to_notify=FALSE;
GC_helper_count--;
if (0==GC_helper_count)need_to_notify=TRUE;
GC_VERBOSE_LOG_PRINTF("Finished mark helper %d\n",id);
if (need_to_notify)GC_notify_all_marker();
return;
}
GC_active_count++;
GC_ASSERT(GC_active_count > 0);
GC_release_mark_lock();
continue;
} else {
GC_release_mark_lock();
}
} else {
n_on_stack=my_top - my_first_nonempty+1;
}
n_to_get=ENTRIES_TO_GET;
if (n_on_stack < 2*ENTRIES_TO_GET)n_to_get=1;
local_top=GC_steal_mark_stack(my_first_nonempty,my_top,
local_mark_stack,n_to_get,
&my_first_nonempty);
GC_ASSERT((word)my_first_nonempty>=(word)GC_mark_stack&&
(word)my_first_nonempty<=
(word)AO_load((volatile AO_t*)&GC_mark_stack_top)
+sizeof(mse));
GC_do_local_mark(local_mark_stack,local_top);
}
}
STATIC void GC_do_parallel_mark(void)
{
GC_acquire_mark_lock();
GC_ASSERT(I_HOLD_LOCK());
if (GC_help_wanted||GC_active_count!=0||GC_helper_count!=0)
ABORT("Tried to start parallel mark in bad state");
GC_VERBOSE_LOG_PRINTF("Starting marking for mark phase number %lu\n",
(unsigned long)GC_mark_no);
GC_first_nonempty=(AO_t)GC_mark_stack;
GC_active_count=0;
GC_helper_count=1;
GC_help_wanted=TRUE;
GC_notify_all_marker();
GC_mark_local(GC_main_local_mark_stack,0);
GC_help_wanted=FALSE;
while (GC_helper_count > 0){
GC_wait_marker();
}
GC_VERBOSE_LOG_PRINTF("Finished marking for mark phase number %lu\n",
(unsigned long)GC_mark_no);
GC_mark_no++;
GC_release_mark_lock();
GC_notify_all_marker();
}
GC_INNER void GC_help_marker(word my_mark_no)
{
#define my_id my_id_mse.mse_descr.w
mse my_id_mse;
mse local_mark_stack[LOCAL_MARK_STACK_SIZE];
GC_ASSERT(GC_parallel);
while (GC_mark_no < my_mark_no
||(!GC_help_wanted&&GC_mark_no==my_mark_no)){
GC_wait_marker();
}
my_id=GC_helper_count;
if (GC_mark_no!=my_mark_no||my_id > (unsigned)GC_markers_m1){
return;
}
GC_helper_count=(unsigned)my_id+1;
GC_mark_local(local_mark_stack,(int)my_id);
#undef my_id
}
#endif
GC_INNER void GC_scratch_recycle_inner(void*ptr,size_t bytes)
{
if (ptr!=NULL){
size_t page_offset=(word)ptr&(GC_page_size - 1);
size_t displ=0;
size_t recycled_bytes;
GC_ASSERT(bytes!=0);
GC_ASSERT(GC_page_size!=0);
if (page_offset!=0)
displ=GC_page_size - page_offset;
recycled_bytes=(bytes - displ)&~(GC_page_size - 1);
GC_COND_LOG_PRINTF("Recycle %lu scratch-allocated bytes at %p\n",
(unsigned long)recycled_bytes,ptr);
if (recycled_bytes > 0)
GC_add_to_heap((struct hblk*)((word)ptr+displ),recycled_bytes);
}
}
static void alloc_mark_stack(size_t n)
{
mse*new_stack=(mse*)GC_scratch_alloc(n*sizeof(struct GC_ms_entry));
#ifdef GWW_VDB
static GC_bool GC_incremental_at_stack_alloc=FALSE;
GC_bool recycle_old=!GC_auto_incremental
||GC_incremental_at_stack_alloc;
GC_incremental_at_stack_alloc=GC_auto_incremental;
#else
#define recycle_old TRUE
#endif
GC_mark_stack_too_small=FALSE;
if (GC_mark_stack!=NULL){
if (new_stack!=0){
if (recycle_old){
GC_scratch_recycle_inner(GC_mark_stack,
GC_mark_stack_size*sizeof(struct GC_ms_entry));
}
GC_mark_stack=new_stack;
GC_mark_stack_size=n;
GC_mark_stack_limit=new_stack+n;
GC_COND_LOG_PRINTF("Grew mark stack to %lu frames\n",
(unsigned long)GC_mark_stack_size);
} else {
WARN("Failed to grow mark stack to %" WARN_PRIdPTR " frames\n",n);
}
} else if (NULL==new_stack){
GC_err_printf("No space for mark stack\n");
EXIT();
} else {
GC_mark_stack=new_stack;
GC_mark_stack_size=n;
GC_mark_stack_limit=new_stack+n;
}
GC_mark_stack_top=GC_mark_stack-1;
}
GC_INNER void GC_mark_init(void)
{
alloc_mark_stack(INITIAL_MARK_STACK_SIZE);
}
GC_API void GC_CALL GC_push_all(void*bottom,void*top)
{
word length;
bottom=(void*)(((word)bottom+ALIGNMENT-1)&~(ALIGNMENT-1));
top=(void*)((word)top&~(ALIGNMENT-1));
if ((word)bottom>=(word)top)return;
GC_mark_stack_top++;
if ((word)GC_mark_stack_top>=(word)GC_mark_stack_limit){
ABORT("Unexpected mark stack overflow");
}
length=(word)top - (word)bottom;
#if GC_DS_TAGS > ALIGNMENT - 1
length+=GC_DS_TAGS;
length&=~GC_DS_TAGS;
#endif
GC_mark_stack_top->mse_start=(ptr_t)bottom;
GC_mark_stack_top->mse_descr.w=length;
}
#ifndef GC_DISABLE_INCREMENTAL
STATIC void GC_push_selected(ptr_t bottom,ptr_t top,
GC_bool (*dirty_fn)(struct hblk*))
{
struct hblk*h;
bottom=(ptr_t)(((word)bottom+ALIGNMENT-1)&~(ALIGNMENT-1));
top=(ptr_t)(((word)top)&~(ALIGNMENT-1));
if ((word)bottom>=(word)top)return;
h=HBLKPTR(bottom+HBLKSIZE);
if ((word)top<=(word)h){
if ((*dirty_fn)(h-1)){
GC_push_all(bottom,top);
}
return;
}
if ((*dirty_fn)(h-1)){
if ((word)(GC_mark_stack_top - GC_mark_stack)
> 3*GC_mark_stack_size/4){
GC_push_all(bottom,top);
return;
}
GC_push_all(bottom,h);
}
while ((word)(h+1)<=(word)top){
if ((*dirty_fn)(h)){
if ((word)(GC_mark_stack_top - GC_mark_stack)
> 3*GC_mark_stack_size/4){
GC_push_all(h,top);
return;
} else {
GC_push_all(h,h+1);
}
}
h++;
}
if ((ptr_t)h!=top&&(*dirty_fn)(h)){
GC_push_all(h,top);
}
}
GC_API void GC_CALL GC_push_conditional(void*bottom,void*top,int all)
{
if (!all){
GC_push_selected((ptr_t)bottom,(ptr_t)top,GC_page_was_dirty);
} else {
#ifdef PROC_VDB
if (GC_auto_incremental){
GC_push_selected((ptr_t)bottom,(ptr_t)top,GC_page_was_ever_dirty);
} else
#endif
{
GC_push_all(bottom,top);
}
}
}
#else
GC_API void GC_CALL GC_push_conditional(void*bottom,void*top,
int all GC_ATTR_UNUSED)
{
GC_push_all(bottom,top);
}
#endif
#if defined(AMIGA)||defined(MACOS)||defined(GC_DARWIN_THREADS)
void GC_push_one(word p)
{
GC_PUSH_ONE_STACK(p,MARKED_FROM_REGISTER);
}
#endif
#ifdef GC_WIN32_THREADS
GC_INNER void GC_push_many_regs(const word*regs,unsigned count)
{
unsigned i;
for (i=0;i < count;i++)
GC_PUSH_ONE_STACK(regs[i],MARKED_FROM_REGISTER);
}
#endif
GC_API struct GC_ms_entry*GC_CALL GC_mark_and_push(void*obj,
mse*mark_stack_ptr,
mse*mark_stack_limit,
void**src GC_ATTR_UNUSED)
{
hdr*hhdr;
PREFETCH(obj);
GET_HDR(obj,hhdr);
if ((EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr),FALSE)
&&(!GC_all_interior_pointers
||NULL==(hhdr=GC_find_header((ptr_t)GC_base(obj)))))
||EXPECT(HBLK_IS_FREE(hhdr),FALSE)){
GC_ADD_TO_BLACK_LIST_NORMAL(obj,(ptr_t)src);
return mark_stack_ptr;
}
return GC_push_contents_hdr((ptr_t)obj,mark_stack_ptr,mark_stack_limit,
(ptr_t)src,hhdr,TRUE);
}
#if defined(PRINT_BLACK_LIST)||defined(KEEP_BACK_PTRS)
GC_INNER void GC_mark_and_push_stack(ptr_t p,ptr_t source)
#else
GC_INNER void GC_mark_and_push_stack(ptr_t p)
#define source ((ptr_t)0)
#endif
{
hdr*hhdr;
ptr_t r=p;
PREFETCH(p);
GET_HDR(p,hhdr);
if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr),FALSE)){
if (NULL==hhdr
||(r=(ptr_t)GC_base(p))==NULL
||(hhdr=HDR(r))==NULL){
GC_ADD_TO_BLACK_LIST_STACK(p,source);
return;
}
}
if (EXPECT(HBLK_IS_FREE(hhdr),FALSE)){
GC_ADD_TO_BLACK_LIST_NORMAL(p,source);
return;
}
#ifdef THREADS
GC_dirty(p);
#endif
GC_mark_stack_top=GC_push_contents_hdr(r,GC_mark_stack_top,
GC_mark_stack_limit,
source,hhdr,FALSE);
}
#undef source
#ifdef TRACE_BUF
#ifndef TRACE_ENTRIES
#define TRACE_ENTRIES 1000
#endif
struct trace_entry {
char*kind;
word gc_no;
word bytes_allocd;
word arg1;
word arg2;
} GC_trace_buf[TRACE_ENTRIES]={ { NULL,0,0,0,0 } };
void GC_add_trace_entry(char*kind,word arg1,word arg2)
{
GC_trace_buf[GC_trace_buf_ptr].kind=kind;
GC_trace_buf[GC_trace_buf_ptr].gc_no=GC_gc_no;
GC_trace_buf[GC_trace_buf_ptr].bytes_allocd=GC_bytes_allocd;
GC_trace_buf[GC_trace_buf_ptr].arg1=arg1^0x80000000;
GC_trace_buf[GC_trace_buf_ptr].arg2=arg2^0x80000000;
GC_trace_buf_ptr++;
if (GC_trace_buf_ptr>=TRACE_ENTRIES)GC_trace_buf_ptr=0;
}
GC_API void GC_CALL GC_print_trace_inner(word gc_no)
{
int i;
for (i=GC_trace_buf_ptr-1;i!=GC_trace_buf_ptr;i--){
struct trace_entry*p;
if (i < 0)i=TRACE_ENTRIES-1;
p=GC_trace_buf+i;
if (p->gc_no < gc_no||p->kind==0){
return;
}
GC_printf("Trace:%s (gc:%u,bytes:%lu)0x%lX,0x%lX\n",
p->kind,(unsigned)p->gc_no,
(unsigned long)p->bytes_allocd,
(long)p->arg1^0x80000000L,(long)p->arg2^0x80000000L);
}
GC_printf("Trace incomplete\n");
}
GC_API void GC_CALL GC_print_trace(word gc_no)
{
DCL_LOCK_STATE;
LOCK();
GC_print_trace_inner(gc_no);
UNLOCK();
}
#endif
GC_ATTR_NO_SANITIZE_ADDR GC_ATTR_NO_SANITIZE_MEMORY GC_ATTR_NO_SANITIZE_THREAD
GC_API void GC_CALL GC_push_all_eager(void*bottom,void*top)
{
word*b=(word*)(((word)bottom+ALIGNMENT-1)&~(ALIGNMENT-1));
word*t=(word*)(((word)top)&~(ALIGNMENT-1));
REGISTER word*p;
REGISTER word*lim;
REGISTER ptr_t greatest_ha=(ptr_t)GC_greatest_plausible_heap_addr;
REGISTER ptr_t least_ha=(ptr_t)GC_least_plausible_heap_addr;
#define GC_greatest_plausible_heap_addr greatest_ha
#define GC_least_plausible_heap_addr least_ha
if (top==0)return;
lim=t - 1;
for (p=b;(word)p<=(word)lim;
p=(word*)(((ptr_t)p)+ALIGNMENT)){
REGISTER word q=*p;
GC_PUSH_ONE_STACK(q,p);
}
#undef GC_greatest_plausible_heap_addr
#undef GC_least_plausible_heap_addr
}
GC_INNER void GC_push_all_stack(ptr_t bottom,ptr_t top)
{
#ifndef NEED_FIXUP_POINTER
if (GC_all_interior_pointers
#if defined(THREADS)&&defined(MPROTECT_VDB)
&&!GC_auto_incremental
#endif
&&(word)GC_mark_stack_top
< (word)(GC_mark_stack_limit - INITIAL_MARK_STACK_SIZE/8)){
GC_push_all(bottom,top);
} else
#endif
{
GC_push_all_eager(bottom,top);
}
}
#if defined(WRAP_MARK_SOME)&&defined(PARALLEL_MARK)
GC_ATTR_NO_SANITIZE_ADDR GC_ATTR_NO_SANITIZE_MEMORY
GC_ATTR_NO_SANITIZE_THREAD
GC_INNER void GC_push_conditional_eager(void*bottom,void*top,
GC_bool all)
{
word*b=(word*)(((word)bottom+ALIGNMENT-1)&~(ALIGNMENT-1));
word*t=(word*)(((word)top)&~(ALIGNMENT-1));
REGISTER word*p;
REGISTER word*lim;
REGISTER ptr_t greatest_ha=(ptr_t)GC_greatest_plausible_heap_addr;
REGISTER ptr_t least_ha=(ptr_t)GC_least_plausible_heap_addr;
#define GC_greatest_plausible_heap_addr greatest_ha
#define GC_least_plausible_heap_addr least_ha
if (top==NULL)
return;
(void)all;
lim=t - 1;
for (p=b;(word)p<=(word)lim;p=(word*)((ptr_t)p+ALIGNMENT)){
REGISTER word q=*p;
GC_PUSH_ONE_HEAP(q,p,GC_mark_stack_top);
}
#undef GC_greatest_plausible_heap_addr
#undef GC_least_plausible_heap_addr
}
#endif
#if!defined(SMALL_CONFIG)&&!defined(USE_MARK_BYTES)&&defined(MARK_BIT_PER_GRANULE)
#if GC_GRANULE_WORDS==1
#define USE_PUSH_MARKED_ACCELERATORS
#define PUSH_GRANULE(q)do { word qcontents=(q)[0];GC_PUSH_ONE_HEAP(qcontents,q,GC_mark_stack_top);} while (0)
#elif GC_GRANULE_WORDS==2
#define USE_PUSH_MARKED_ACCELERATORS
#define PUSH_GRANULE(q)do { word qcontents=(q)[0];GC_PUSH_ONE_HEAP(qcontents,q,GC_mark_stack_top);qcontents=(q)[1];GC_PUSH_ONE_HEAP(qcontents,(q)+1,GC_mark_stack_top);} while (0)
#elif GC_GRANULE_WORDS==4
#define USE_PUSH_MARKED_ACCELERATORS
#define PUSH_GRANULE(q)do { word qcontents=(q)[0];GC_PUSH_ONE_HEAP(qcontents,q,GC_mark_stack_top);qcontents=(q)[1];GC_PUSH_ONE_HEAP(qcontents,(q)+1,GC_mark_stack_top);qcontents=(q)[2];GC_PUSH_ONE_HEAP(qcontents,(q)+2,GC_mark_stack_top);qcontents=(q)[3];GC_PUSH_ONE_HEAP(qcontents,(q)+3,GC_mark_stack_top);} while (0)
#endif
#endif
#ifdef USE_PUSH_MARKED_ACCELERATORS
STATIC void GC_push_marked1(struct hblk*h,hdr*hhdr)
{
word*mark_word_addr=&(hhdr->hb_marks[0]);
word*p;
word*plim;
ptr_t greatest_ha=(ptr_t)GC_greatest_plausible_heap_addr;
ptr_t least_ha=(ptr_t)GC_least_plausible_heap_addr;
mse*mark_stack_top=GC_mark_stack_top;
mse*mark_stack_limit=GC_mark_stack_limit;
#undef GC_mark_stack_top
#undef GC_mark_stack_limit
#define GC_mark_stack_top mark_stack_top
#define GC_mark_stack_limit mark_stack_limit
#define GC_greatest_plausible_heap_addr greatest_ha
#define GC_least_plausible_heap_addr least_ha
p=(word*)(h->hb_body);
plim=(word*)(((word)h)+HBLKSIZE);
while ((word)p < (word)plim){
word mark_word=*mark_word_addr++;
word*q=p;
while(mark_word!=0){
if (mark_word&1){
PUSH_GRANULE(q);
}
q+=GC_GRANULE_WORDS;
mark_word>>=1;
}
p+=WORDSZ*GC_GRANULE_WORDS;
}
#undef GC_greatest_plausible_heap_addr
#undef GC_least_plausible_heap_addr
#undef GC_mark_stack_top
#undef GC_mark_stack_limit
#define GC_mark_stack_limit GC_arrays._mark_stack_limit
#define GC_mark_stack_top GC_arrays._mark_stack_top
GC_mark_stack_top=mark_stack_top;
}
#ifndef UNALIGNED_PTRS
STATIC void GC_push_marked2(struct hblk*h,hdr*hhdr)
{
word*mark_word_addr=&(hhdr->hb_marks[0]);
word*p;
word*plim;
ptr_t greatest_ha=(ptr_t)GC_greatest_plausible_heap_addr;
ptr_t least_ha=(ptr_t)GC_least_plausible_heap_addr;
mse*mark_stack_top=GC_mark_stack_top;
mse*mark_stack_limit=GC_mark_stack_limit;
#undef GC_mark_stack_top
#undef GC_mark_stack_limit
#define GC_mark_stack_top mark_stack_top
#define GC_mark_stack_limit mark_stack_limit
#define GC_greatest_plausible_heap_addr greatest_ha
#define GC_least_plausible_heap_addr least_ha
p=(word*)(h->hb_body);
plim=(word*)(((word)h)+HBLKSIZE);
while ((word)p < (word)plim){
word mark_word=*mark_word_addr++;
word*q=p;
while(mark_word!=0){
if (mark_word&1){
PUSH_GRANULE(q);
PUSH_GRANULE(q+GC_GRANULE_WORDS);
}
q+=2*GC_GRANULE_WORDS;
mark_word>>=2;
}
p+=WORDSZ*GC_GRANULE_WORDS;
}
#undef GC_greatest_plausible_heap_addr
#undef GC_least_plausible_heap_addr
#undef GC_mark_stack_top
#undef GC_mark_stack_limit
#define GC_mark_stack_limit GC_arrays._mark_stack_limit
#define GC_mark_stack_top GC_arrays._mark_stack_top
GC_mark_stack_top=mark_stack_top;
}
#if GC_GRANULE_WORDS < 4
STATIC void GC_push_marked4(struct hblk*h,hdr*hhdr)
{
word*mark_word_addr=&(hhdr->hb_marks[0]);
word*p;
word*plim;
ptr_t greatest_ha=(ptr_t)GC_greatest_plausible_heap_addr;
ptr_t least_ha=(ptr_t)GC_least_plausible_heap_addr;
mse*mark_stack_top=GC_mark_stack_top;
mse*mark_stack_limit=GC_mark_stack_limit;
#undef GC_mark_stack_top
#undef GC_mark_stack_limit
#define GC_mark_stack_top mark_stack_top
#define GC_mark_stack_limit mark_stack_limit
#define GC_greatest_plausible_heap_addr greatest_ha
#define GC_least_plausible_heap_addr least_ha
p=(word*)(h->hb_body);
plim=(word*)(((word)h)+HBLKSIZE);
while ((word)p < (word)plim){
word mark_word=*mark_word_addr++;
word*q=p;
while(mark_word!=0){
if (mark_word&1){
PUSH_GRANULE(q);
PUSH_GRANULE(q+GC_GRANULE_WORDS);
PUSH_GRANULE(q+2*GC_GRANULE_WORDS);
PUSH_GRANULE(q+3*GC_GRANULE_WORDS);
}
q+=4*GC_GRANULE_WORDS;
mark_word>>=4;
}
p+=WORDSZ*GC_GRANULE_WORDS;
}
#undef GC_greatest_plausible_heap_addr
#undef GC_least_plausible_heap_addr
#undef GC_mark_stack_top
#undef GC_mark_stack_limit
#define GC_mark_stack_limit GC_arrays._mark_stack_limit
#define GC_mark_stack_top GC_arrays._mark_stack_top
GC_mark_stack_top=mark_stack_top;
}
#endif
#endif
#endif
STATIC void GC_push_marked(struct hblk*h,hdr*hhdr)
{
word sz=hhdr->hb_sz;
word descr=hhdr->hb_descr;
ptr_t p;
word bit_no;
ptr_t lim;
mse*GC_mark_stack_top_reg;
mse*mark_stack_limit=GC_mark_stack_limit;
if (( GC_DS_LENGTH)==descr)return;
if (GC_block_empty(hhdr))return;
#if!defined(GC_DISABLE_INCREMENTAL)
GC_n_rescuing_pages++;
#endif
GC_objects_are_marked=TRUE;
if (sz > MAXOBJBYTES){
lim=h->hb_body;
} else {
lim=(ptr_t)((word)(h+1)->hb_body - sz);
}
switch(BYTES_TO_GRANULES(sz)){
#if defined(USE_PUSH_MARKED_ACCELERATORS)
case 1:
GC_push_marked1(h,hhdr);
break;
#if!defined(UNALIGNED_PTRS)
case 2:
GC_push_marked2(h,hhdr);
break;
#if GC_GRANULE_WORDS < 4
case 4:
GC_push_marked4(h,hhdr);
break;
#endif
#endif
#else
case 1:
#endif
default:
GC_mark_stack_top_reg=GC_mark_stack_top;
for (p=h->hb_body,bit_no=0;(word)p<=(word)lim;
p+=sz,bit_no+=MARK_BIT_OFFSET(sz)){
if (mark_bit_from_hdr(hhdr,bit_no)){
GC_mark_stack_top_reg=GC_push_obj(p,hhdr,GC_mark_stack_top_reg,
mark_stack_limit);
}
}
GC_mark_stack_top=GC_mark_stack_top_reg;
}
}
#ifdef ENABLE_DISCLAIM
STATIC void GC_push_unconditionally(struct hblk*h,hdr*hhdr)
{
word sz=hhdr->hb_sz;
word descr=hhdr->hb_descr;
ptr_t p;
ptr_t lim;
mse*GC_mark_stack_top_reg;
mse*mark_stack_limit=GC_mark_stack_limit;
if (( GC_DS_LENGTH)==descr)
return;
#if!defined(GC_DISABLE_INCREMENTAL)
GC_n_rescuing_pages++;
#endif
GC_objects_are_marked=TRUE;
if (sz > MAXOBJBYTES)
lim=h->hb_body;
else
lim=(ptr_t)((word)(h+1)->hb_body - sz);
GC_mark_stack_top_reg=GC_mark_stack_top;
for (p=h->hb_body;(word)p<=(word)lim;p+=sz)
if ((*(word*)p&0x3)!=0)
GC_mark_stack_top_reg=GC_push_obj(p,hhdr,GC_mark_stack_top_reg,
mark_stack_limit);
GC_mark_stack_top=GC_mark_stack_top_reg;
}
#endif
#ifndef GC_DISABLE_INCREMENTAL
STATIC GC_bool GC_block_was_dirty(struct hblk*h,hdr*hhdr)
{
word sz=hhdr->hb_sz;
if (sz<=MAXOBJBYTES){
return(GC_page_was_dirty(h));
} else {
ptr_t p=(ptr_t)h;
while ((word)p < (word)h+sz){
if (GC_page_was_dirty((struct hblk*)p))return(TRUE);
p+=HBLKSIZE;
}
return(FALSE);
}
}
#endif
STATIC struct hblk*GC_push_next_marked(struct hblk*h)
{
hdr*hhdr=HDR(h);
if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr)||HBLK_IS_FREE(hhdr),FALSE)){
h=GC_next_block(h,FALSE);
if (NULL==h)return NULL;
hhdr=GC_find_header((ptr_t)h);
} else {
#ifdef LINT2
if (NULL==h)ABORT("Bad HDR()definition");
#endif
}
GC_push_marked(h,hhdr);
return(h+OBJ_SZ_TO_BLOCKS(hhdr->hb_sz));
}
#ifndef GC_DISABLE_INCREMENTAL
STATIC struct hblk*GC_push_next_marked_dirty(struct hblk*h)
{
hdr*hhdr=HDR(h);
if (!GC_incremental)ABORT("Dirty bits not set up");
for (;;){
if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr)
||HBLK_IS_FREE(hhdr),FALSE)){
h=GC_next_block(h,FALSE);
if (NULL==h)return NULL;
hhdr=GC_find_header((ptr_t)h);
} else {
#ifdef LINT2
if (NULL==h)ABORT("Bad HDR()definition");
#endif
}
if (GC_block_was_dirty(h,hhdr))
break;
h+=OBJ_SZ_TO_BLOCKS(hhdr->hb_sz);
hhdr=HDR(h);
}
#ifdef ENABLE_DISCLAIM
if ((hhdr->hb_flags&MARK_UNCONDITIONALLY)!=0){
GC_push_unconditionally(h,hhdr);
} else
#endif
{
GC_push_marked(h,hhdr);
}
return(h+OBJ_SZ_TO_BLOCKS(hhdr->hb_sz));
}
#endif
STATIC struct hblk*GC_push_next_marked_uncollectable(struct hblk*h)
{
hdr*hhdr=HDR(h);
for (;;){
if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr)
||HBLK_IS_FREE(hhdr),FALSE)){
h=GC_next_block(h,FALSE);
if (NULL==h)return NULL;
hhdr=GC_find_header((ptr_t)h);
} else {
#ifdef LINT2
if (NULL==h)ABORT("Bad HDR()definition");
#endif
}
if (hhdr->hb_obj_kind==UNCOLLECTABLE){
GC_push_marked(h,hhdr);
break;
}
#ifdef ENABLE_DISCLAIM
if ((hhdr->hb_flags&MARK_UNCONDITIONALLY)!=0){
GC_push_unconditionally(h,hhdr);
break;
}
#endif
h+=OBJ_SZ_TO_BLOCKS(hhdr->hb_sz);
hhdr=HDR(h);
}
return(h+OBJ_SZ_TO_BLOCKS(hhdr->hb_sz));
}
#include <stdio.h>
int GC_no_dls=0;
#if!defined(NO_DEBUGGING)||defined(GC_ASSERTIONS)
GC_INNER word GC_compute_root_size(void)
{
int i;
word size=0;
for (i=0;i < n_root_sets;i++){
size+=GC_static_roots[i].r_end - GC_static_roots[i].r_start;
}
return size;
}
#endif
#if!defined(NO_DEBUGGING)
void GC_print_static_roots(void)
{
int i;
word size;
for (i=0;i < n_root_sets;i++){
GC_printf("From %p to %p%s\n",
(void*)GC_static_roots[i].r_start,
(void*)GC_static_roots[i].r_end,
GC_static_roots[i].r_tmp?" (temporary)":"");
}
GC_printf("GC_root_size:%lu\n",(unsigned long)GC_root_size);
if ((size=GC_compute_root_size())!=GC_root_size)
GC_err_printf("GC_root_size incorrect!!Should be:%lu\n",
(unsigned long)size);
}
#endif
#ifndef THREADS
GC_INNER GC_bool GC_is_static_root(void*p)
{
static int last_root_set=MAX_ROOT_SETS;
int i;
if (last_root_set < n_root_sets
&&(word)p>=(word)GC_static_roots[last_root_set].r_start
&&(word)p < (word)GC_static_roots[last_root_set].r_end)
return(TRUE);
for (i=0;i < n_root_sets;i++){
if ((word)p>=(word)GC_static_roots[i].r_start
&&(word)p < (word)GC_static_roots[i].r_end){
last_root_set=i;
return(TRUE);
}
}
return(FALSE);
}
#endif
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
GC_INLINE int rt_hash(ptr_t addr)
{
word result=(word)addr;
#if CPP_WORDSZ > 8*LOG_RT_SIZE
result^=result>>8*LOG_RT_SIZE;
#endif
#if CPP_WORDSZ > 4*LOG_RT_SIZE
result^=result>>4*LOG_RT_SIZE;
#endif
result^=result>>2*LOG_RT_SIZE;
result^=result>>LOG_RT_SIZE;
result&=(RT_SIZE-1);
return(result);
}
GC_INNER void*GC_roots_present(ptr_t b)
{
int h=rt_hash(b);
struct roots*p=GC_root_index[h];
while (p!=0){
if (p->r_start==(ptr_t)b)return(p);
p=p->r_next;
}
return NULL;
}
GC_INLINE void add_roots_to_index(struct roots*p)
{
int h=rt_hash(p->r_start);
p->r_next=GC_root_index[h];
GC_root_index[h]=p;
}
#endif
GC_INNER word GC_root_size=0;
GC_API void GC_CALL GC_add_roots(void*b,void*e)
{
DCL_LOCK_STATE;
if (!EXPECT(GC_is_initialized,TRUE))GC_init();
LOCK();
GC_add_roots_inner((ptr_t)b,(ptr_t)e,FALSE);
UNLOCK();
}
void GC_add_roots_inner(ptr_t b,ptr_t e,GC_bool tmp)
{
GC_ASSERT((word)b<=(word)e);
b=(ptr_t)(((word)b+(sizeof(word)- 1))&~(word)(sizeof(word)- 1));
e=(ptr_t)((word)e&~(word)(sizeof(word)- 1));
if ((word)b>=(word)e)return;
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)
{
int i;
struct roots*old=NULL;
for (i=0;i < n_root_sets;i++){
old=GC_static_roots+i;
if ((word)b<=(word)old->r_end
&&(word)e>=(word)old->r_start){
if ((word)b < (word)old->r_start){
GC_root_size+=old->r_start - b;
old->r_start=b;
}
if ((word)e > (word)old->r_end){
GC_root_size+=e - old->r_end;
old->r_end=e;
}
old->r_tmp&=tmp;
break;
}
}
if (i < n_root_sets){
struct roots*other;
for (i++;i < n_root_sets;i++){
other=GC_static_roots+i;
b=other->r_start;
e=other->r_end;
if ((word)b<=(word)old->r_end
&&(word)e>=(word)old->r_start){
if ((word)b < (word)old->r_start){
GC_root_size+=old->r_start - b;
old->r_start=b;
}
if ((word)e > (word)old->r_end){
GC_root_size+=e - old->r_end;
old->r_end=e;
}
old->r_tmp&=other->r_tmp;
GC_root_size-=(other->r_end - other->r_start);
other->r_start=GC_static_roots[n_root_sets-1].r_start;
other->r_end=GC_static_roots[n_root_sets-1].r_end;
n_root_sets--;
}
}
return;
}
}
#else
{
struct roots*old=(struct roots*)GC_roots_present(b);
if (old!=0){
if ((word)e<=(word)old->r_end){
old->r_tmp&=tmp;
return;
}
if (old->r_tmp==tmp||!tmp){
GC_root_size+=e - old->r_end;
old->r_end=e;
old->r_tmp=tmp;
return;
}
b=old->r_end;
}
}
#endif
if (n_root_sets==MAX_ROOT_SETS){
ABORT("Too many root sets");
}
#ifdef DEBUG_ADD_DEL_ROOTS
GC_log_printf("Adding data root section %d:%p .. %p%s\n",
n_root_sets,(void*)b,(void*)e,
tmp?" (temporary)":"");
#endif
GC_static_roots[n_root_sets].r_start=(ptr_t)b;
GC_static_roots[n_root_sets].r_end=(ptr_t)e;
GC_static_roots[n_root_sets].r_tmp=tmp;
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
GC_static_roots[n_root_sets].r_next=0;
add_roots_to_index(GC_static_roots+n_root_sets);
#endif
GC_root_size+=e - b;
n_root_sets++;
}
GC_API void GC_CALL GC_clear_roots(void)
{
DCL_LOCK_STATE;
if (!EXPECT(GC_is_initialized,TRUE))GC_init();
LOCK();
#ifdef THREADS
GC_roots_were_cleared=TRUE;
#endif
n_root_sets=0;
GC_root_size=0;
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
BZERO(GC_root_index,RT_SIZE*sizeof(void*));
#endif
#ifdef DEBUG_ADD_DEL_ROOTS
GC_log_printf("Clear all data root sections\n");
#endif
UNLOCK();
}
STATIC void GC_remove_root_at_pos(int i)
{
#ifdef DEBUG_ADD_DEL_ROOTS
GC_log_printf("Remove data root section at %d:%p .. %p%s\n",
i,(void*)GC_static_roots[i].r_start,
(void*)GC_static_roots[i].r_end,
GC_static_roots[i].r_tmp?" (temporary)":"");
#endif
GC_root_size-=(GC_static_roots[i].r_end - GC_static_roots[i].r_start);
GC_static_roots[i].r_start=GC_static_roots[n_root_sets-1].r_start;
GC_static_roots[i].r_end=GC_static_roots[n_root_sets-1].r_end;
GC_static_roots[i].r_tmp=GC_static_roots[n_root_sets-1].r_tmp;
n_root_sets--;
}
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
STATIC void GC_rebuild_root_index(void)
{
int i;
BZERO(GC_root_index,RT_SIZE*sizeof(void*));
for (i=0;i < n_root_sets;i++)
add_roots_to_index(GC_static_roots+i);
}
#endif
#if defined(DYNAMIC_LOADING)||defined(MSWIN32)||defined(MSWINCE)||defined(PCR)||defined(CYGWIN32)
STATIC void GC_remove_tmp_roots(void)
{
int i;
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
int old_n_roots=n_root_sets;
#endif
for (i=0;i < n_root_sets;){
if (GC_static_roots[i].r_tmp){
GC_remove_root_at_pos(i);
} else {
i++;
}
}
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
if (n_root_sets < old_n_roots)
GC_rebuild_root_index();
#endif
}
#endif
#if!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)
STATIC void GC_remove_roots_inner(ptr_t b,ptr_t e);
GC_API void GC_CALL GC_remove_roots(void*b,void*e)
{
DCL_LOCK_STATE;
if ((((word)b+(sizeof(word)- 1))&~(word)(sizeof(word)- 1))>=
((word)e&~(word)(sizeof(word)- 1)))
return;
LOCK();
GC_remove_roots_inner((ptr_t)b,(ptr_t)e);
UNLOCK();
}
STATIC void GC_remove_roots_inner(ptr_t b,ptr_t e)
{
int i;
GC_bool rebuild=FALSE;
for (i=0;i < n_root_sets;){
if ((word)GC_static_roots[i].r_start>=(word)b
&&(word)GC_static_roots[i].r_end<=(word)e){
GC_remove_root_at_pos(i);
rebuild=TRUE;
} else {
i++;
}
}
if (rebuild)
GC_rebuild_root_index();
}
#endif
#ifdef USE_PROC_FOR_LIBRARIES
GC_INLINE void swap_static_roots(int i,int j)
{
ptr_t r_start=GC_static_roots[i].r_start;
ptr_t r_end=GC_static_roots[i].r_end;
GC_bool r_tmp=GC_static_roots[i].r_tmp;
GC_static_roots[i].r_start=GC_static_roots[j].r_start;
GC_static_roots[i].r_end=GC_static_roots[j].r_end;
GC_static_roots[i].r_tmp=GC_static_roots[j].r_tmp;
GC_static_roots[j].r_start=r_start;
GC_static_roots[j].r_end=r_end;
GC_static_roots[j].r_tmp=r_tmp;
}
GC_INNER void GC_remove_roots_subregion(ptr_t b,ptr_t e)
{
int i;
GC_bool rebuild=FALSE;
GC_ASSERT(I_HOLD_LOCK());
GC_ASSERT((word)b % sizeof(word)==0&&(word)e % sizeof(word)==0);
for (i=0;i < n_root_sets;i++){
ptr_t r_start,r_end;
if (GC_static_roots[i].r_tmp){
#ifdef GC_ASSERTIONS
int j;
for (j=i+1;j < n_root_sets;j++){
GC_ASSERT(GC_static_roots[j].r_tmp);
}
#endif
break;
}
r_start=GC_static_roots[i].r_start;
r_end=GC_static_roots[i].r_end;
if (!EXPECT((word)e<=(word)r_start||(word)r_end<=(word)b,TRUE)){
#ifdef DEBUG_ADD_DEL_ROOTS
GC_log_printf("Removing %p .. %p from root section %d (%p .. %p)\n",
(void*)b,(void*)e,
i,(void*)r_start,(void*)r_end);
#endif
if ((word)r_start < (word)b){
GC_root_size-=r_end - b;
GC_static_roots[i].r_end=b;
if ((word)e < (word)r_end){
int j;
if (rebuild){
GC_rebuild_root_index();
rebuild=FALSE;
}
GC_add_roots_inner(e,r_end,FALSE);
for (j=i+1;j < n_root_sets;j++)
if (GC_static_roots[j].r_tmp)
break;
if (j < n_root_sets-1&&!GC_static_roots[n_root_sets-1].r_tmp){
swap_static_roots(j,n_root_sets - 1);
rebuild=TRUE;
}
}
} else {
if ((word)e < (word)r_end){
GC_root_size-=e - r_start;
GC_static_roots[i].r_start=e;
} else {
GC_remove_root_at_pos(i);
if (i < n_root_sets - 1&&GC_static_roots[i].r_tmp
&&!GC_static_roots[i+1].r_tmp){
int j;
for (j=i+2;j < n_root_sets;j++)
if (GC_static_roots[j].r_tmp)
break;
swap_static_roots(i,j - 1);
}
i--;
}
rebuild=TRUE;
}
}
}
if (rebuild)
GC_rebuild_root_index();
}
#endif
#if!defined(NO_DEBUGGING)
GC_API int GC_CALL GC_is_tmp_root(void*p)
{
static int last_root_set=MAX_ROOT_SETS;
int i;
if (last_root_set < n_root_sets
&&(word)p>=(word)GC_static_roots[last_root_set].r_start
&&(word)p < (word)GC_static_roots[last_root_set].r_end)
return GC_static_roots[last_root_set].r_tmp;
for (i=0;i < n_root_sets;i++){
if ((word)p>=(word)GC_static_roots[i].r_start
&&(word)p < (word)GC_static_roots[i].r_end){
last_root_set=i;
return GC_static_roots[i].r_tmp;
}
}
return(FALSE);
}
#endif
GC_INNER ptr_t GC_approx_sp(void)
{
volatile word sp;
#if defined(S390)&&!defined(CPPCHECK)&&(__clang_major__ < 8)
sp=(word)&sp;
#elif defined(CPPCHECK)||(__GNUC__>=4&&!defined(STACK_NOT_SCANNED))
sp=(word)__builtin_frame_address(0);
#else
sp=(word)&sp;
#endif
return((ptr_t)sp);
}
GC_API void GC_CALL GC_clear_exclusion_table(void)
{
GC_excl_table_entries=0;
}
STATIC struct exclusion*GC_next_exclusion(ptr_t start_addr)
{
size_t low=0;
size_t high;
GC_ASSERT(GC_excl_table_entries > 0);
high=GC_excl_table_entries - 1;
while (high > low){
size_t mid=(low+high)>>1;
if ((word)GC_excl_table[mid].e_end<=(word)start_addr){
low=mid+1;
} else {
high=mid;
}
}
if ((word)GC_excl_table[low].e_end<=(word)start_addr)return 0;
return GC_excl_table+low;
}
GC_INNER void GC_exclude_static_roots_inner(void*start,void*finish)
{
struct exclusion*next;
size_t next_index;
GC_ASSERT((word)start % sizeof(word)==0);
GC_ASSERT((word)start < (word)finish);
if (0==GC_excl_table_entries){
next=0;
} else {
next=GC_next_exclusion((ptr_t)start);
}
if (0!=next){
size_t i;
if ((word)(next->e_start)< (word)finish){
ABORT("Exclusion ranges overlap");
}
if ((word)(next->e_start)==(word)finish){
next->e_start=(ptr_t)start;
return;
}
next_index=next - GC_excl_table;
for (i=GC_excl_table_entries;i > next_index;--i){
GC_excl_table[i]=GC_excl_table[i-1];
}
} else {
next_index=GC_excl_table_entries;
}
if (GC_excl_table_entries==MAX_EXCLUSIONS)ABORT("Too many exclusions");
GC_excl_table[next_index].e_start=(ptr_t)start;
GC_excl_table[next_index].e_end=(ptr_t)finish;
++GC_excl_table_entries;
}
GC_API void GC_CALL GC_exclude_static_roots(void*b,void*e)
{
DCL_LOCK_STATE;
if (b==e)return;
b=(void*)((word)b&~(word)(sizeof(word)- 1));
e=(void*)(((word)e+(sizeof(word)- 1))&~(word)(sizeof(word)- 1));
if (NULL==e)
e=(void*)(~(word)(sizeof(word)- 1));
LOCK();
GC_exclude_static_roots_inner(b,e);
UNLOCK();
}
#if defined(WRAP_MARK_SOME)&&defined(PARALLEL_MARK)
#define GC_PUSH_CONDITIONAL(b,t,all)(GC_parallel?GC_push_conditional_eager(b,t,all):GC_push_conditional(b,t,all))
#elif defined(GC_DISABLE_INCREMENTAL)
#define GC_PUSH_CONDITIONAL(b,t,all)GC_push_all(b,t)
#else
#define GC_PUSH_CONDITIONAL(b,t,all)GC_push_conditional(b,t,all)
#endif
STATIC void GC_push_conditional_with_exclusions(ptr_t bottom,ptr_t top,
GC_bool all GC_ATTR_UNUSED)
{
while ((word)bottom < (word)top){
struct exclusion*next=GC_next_exclusion(bottom);
ptr_t excl_start;
if (0==next
||(word)(excl_start=next->e_start)>=(word)top){
GC_PUSH_CONDITIONAL(bottom,top,all);
break;
}
if ((word)excl_start > (word)bottom)
GC_PUSH_CONDITIONAL(bottom,excl_start,all);
bottom=next->e_end;
}
}
#ifdef IA64
GC_INNER void GC_push_all_register_sections(ptr_t bs_lo,ptr_t bs_hi,
int eager,struct GC_traced_stack_sect_s*traced_stack_sect)
{
while (traced_stack_sect!=NULL){
ptr_t frame_bs_lo=traced_stack_sect->backing_store_end;
GC_ASSERT((word)frame_bs_lo<=(word)bs_hi);
if (eager){
GC_push_all_eager(frame_bs_lo,bs_hi);
} else {
GC_push_all_stack(frame_bs_lo,bs_hi);
}
bs_hi=traced_stack_sect->saved_backing_store_ptr;
traced_stack_sect=traced_stack_sect->prev;
}
GC_ASSERT((word)bs_lo<=(word)bs_hi);
if (eager){
GC_push_all_eager(bs_lo,bs_hi);
} else {
GC_push_all_stack(bs_lo,bs_hi);
}
}
#endif
#ifdef THREADS
GC_INNER void GC_push_all_stack_sections(ptr_t lo,ptr_t hi,
struct GC_traced_stack_sect_s*traced_stack_sect)
{
while (traced_stack_sect!=NULL){
GC_ASSERT((word)lo HOTTER_THAN (word)traced_stack_sect);
#ifdef STACK_GROWS_UP
GC_push_all_stack((ptr_t)traced_stack_sect,lo);
#else
GC_push_all_stack(lo,(ptr_t)traced_stack_sect);
#endif
lo=traced_stack_sect->saved_stack_ptr;
GC_ASSERT(lo!=NULL);
traced_stack_sect=traced_stack_sect->prev;
}
GC_ASSERT(!((word)hi HOTTER_THAN (word)lo));
#ifdef STACK_GROWS_UP
GC_push_all_stack(hi,lo);
#else
GC_push_all_stack(lo,hi);
#endif
}
#else
STATIC void GC_push_all_stack_partially_eager(ptr_t bottom,ptr_t top,
ptr_t cold_gc_frame)
{
#ifndef NEED_FIXUP_POINTER
if (GC_all_interior_pointers){
if (0==cold_gc_frame){
GC_push_all_stack(bottom,top);
return;
}
GC_ASSERT((word)bottom<=(word)cold_gc_frame
&&(word)cold_gc_frame<=(word)top);
#ifdef STACK_GROWS_DOWN
GC_push_all(cold_gc_frame - sizeof(ptr_t),top);
GC_push_all_eager(bottom,cold_gc_frame);
#else
GC_push_all(bottom,cold_gc_frame+sizeof(ptr_t));
GC_push_all_eager(cold_gc_frame,top);
#endif
} else
#endif
{
GC_push_all_eager(bottom,top);
}
#ifdef TRACE_BUF
GC_add_trace_entry("GC_push_all_stack",(word)bottom,(word)top);
#endif
}
STATIC void GC_push_all_stack_part_eager_sections(ptr_t lo,ptr_t hi,
ptr_t cold_gc_frame,struct GC_traced_stack_sect_s*traced_stack_sect)
{
GC_ASSERT(traced_stack_sect==NULL||cold_gc_frame==NULL||
(word)cold_gc_frame HOTTER_THAN (word)traced_stack_sect);
while (traced_stack_sect!=NULL){
GC_ASSERT((word)lo HOTTER_THAN (word)traced_stack_sect);
#ifdef STACK_GROWS_UP
GC_push_all_stack_partially_eager((ptr_t)traced_stack_sect,lo,
cold_gc_frame);
#else
GC_push_all_stack_partially_eager(lo,(ptr_t)traced_stack_sect,
cold_gc_frame);
#endif
lo=traced_stack_sect->saved_stack_ptr;
GC_ASSERT(lo!=NULL);
traced_stack_sect=traced_stack_sect->prev;
cold_gc_frame=NULL;
}
GC_ASSERT(!((word)hi HOTTER_THAN (word)lo));
#ifdef STACK_GROWS_UP
GC_push_all_stack_partially_eager(hi,lo,cold_gc_frame);
#else
GC_push_all_stack_partially_eager(lo,hi,cold_gc_frame);
#endif
}
#endif
STATIC void GC_push_current_stack(ptr_t cold_gc_frame,
void*context GC_ATTR_UNUSED)
{
#if defined(THREADS)
#ifdef STACK_GROWS_DOWN
GC_push_all_eager(GC_approx_sp(),cold_gc_frame);
#else
GC_push_all_eager(cold_gc_frame,GC_approx_sp());
#endif
#else
GC_push_all_stack_part_eager_sections(GC_approx_sp(),GC_stackbottom,
cold_gc_frame,GC_traced_stack_sect);
#ifdef IA64
{
ptr_t bsp=GC_save_regs_ret_val;
ptr_t cold_gc_bs_pointer=bsp - 2048;
if (GC_all_interior_pointers
&&(word)cold_gc_bs_pointer > (word)BACKING_STORE_BASE){
if (GC_traced_stack_sect!=NULL
&&(word)cold_gc_bs_pointer
< (word)GC_traced_stack_sect->backing_store_end)
cold_gc_bs_pointer=
GC_traced_stack_sect->backing_store_end;
GC_push_all_register_sections(BACKING_STORE_BASE,
cold_gc_bs_pointer,FALSE,GC_traced_stack_sect);
GC_push_all_eager(cold_gc_bs_pointer,bsp);
} else {
GC_push_all_register_sections(BACKING_STORE_BASE,bsp,
TRUE,GC_traced_stack_sect);
}
}
#endif
#endif
}
GC_INNER void (*GC_push_typed_structures)(void)=0;
GC_INNER void GC_cond_register_dynamic_libraries(void)
{
#if (defined(DYNAMIC_LOADING)&&!defined(MSWIN_XBOX1))||defined(CYGWIN32)||defined(MSWIN32)||defined(MSWINCE)||defined(PCR)
GC_remove_tmp_roots();
if (!GC_no_dls)GC_register_dynamic_libraries();
#else
GC_no_dls=TRUE;
#endif
}
STATIC void GC_push_regs_and_stack(ptr_t cold_gc_frame)
{
#ifdef THREADS
if (NULL==cold_gc_frame)
return;
#endif
GC_with_callee_saves_pushed(GC_push_current_stack,cold_gc_frame);
}
GC_INNER void GC_push_roots(GC_bool all,ptr_t cold_gc_frame GC_ATTR_UNUSED)
{
int i;
unsigned kind;
#if!defined(REGISTER_LIBRARIES_EARLY)
GC_cond_register_dynamic_libraries();
#endif
for (i=0;i < n_root_sets;i++){
GC_push_conditional_with_exclusions(
GC_static_roots[i].r_start,
GC_static_roots[i].r_end,all);
}
for (kind=0;kind < GC_n_kinds;kind++){
void*base=GC_base(GC_obj_kinds[kind].ok_freelist);
if (base!=NULL){
GC_set_mark_bit(base);
}
}
#ifndef GC_NO_FINALIZATION
GC_push_finalizer_structures();
#endif
#ifdef THREADS
if (GC_no_dls||GC_roots_were_cleared)
GC_push_thread_structures();
#endif
if (GC_push_typed_structures)
GC_push_typed_structures();
#if defined(THREAD_LOCAL_ALLOC)
if (GC_world_stopped)
GC_mark_thread_local_free_lists();
#endif
#ifndef STACK_NOT_SCANNED
GC_push_regs_and_stack(cold_gc_frame);
#endif
if (GC_push_other_roots!=0){
(*GC_push_other_roots)();
}
}
#ifdef ENABLE_DISCLAIM
#endif
#include <stdio.h>
GC_INNER signed_word GC_bytes_found=0;
#if defined(PARALLEL_MARK)
GC_INNER signed_word GC_fl_builder_count=0;
#endif
#ifndef MAX_LEAKED
#define MAX_LEAKED 40
#endif
STATIC ptr_t GC_leaked[MAX_LEAKED]={ NULL };
STATIC unsigned GC_n_leaked=0;
GC_INNER GC_bool GC_have_errors=FALSE;
#if!defined(EAGER_SWEEP)&&defined(ENABLE_DISCLAIM)
STATIC void GC_reclaim_unconditionally_marked(void);
#endif
GC_INLINE void GC_add_leaked(ptr_t leaked)
{
#ifndef SHORT_DBG_HDRS
if (GC_findleak_delay_free&&!GC_check_leaked(leaked))
return;
#endif
GC_have_errors=TRUE;
if (GC_n_leaked < MAX_LEAKED){
GC_leaked[GC_n_leaked++]=leaked;
GC_set_mark_bit(leaked);
}
}
GC_INNER void GC_print_all_errors(void)
{
static GC_bool printing_errors=FALSE;
GC_bool have_errors;
unsigned i,n_leaked;
ptr_t leaked[MAX_LEAKED];
DCL_LOCK_STATE;
LOCK();
if (printing_errors){
UNLOCK();
return;
}
have_errors=GC_have_errors;
printing_errors=TRUE;
n_leaked=GC_n_leaked;
if (n_leaked > 0){
GC_ASSERT(n_leaked<=MAX_LEAKED);
BCOPY(GC_leaked,leaked,n_leaked*sizeof(ptr_t));
GC_n_leaked=0;
BZERO(GC_leaked,n_leaked*sizeof(ptr_t));
}
UNLOCK();
if (GC_debugging_started){
GC_print_all_smashed();
} else {
have_errors=FALSE;
}
if (n_leaked > 0){
GC_err_printf("Found %u leaked objects:\n",n_leaked);
have_errors=TRUE;
}
for (i=0;i < n_leaked;i++){
ptr_t p=leaked[i];
#ifndef SKIP_LEAKED_OBJECTS_PRINTING
GC_print_heap_obj(p);
#endif
GC_free(p);
}
if (have_errors
#ifndef GC_ABORT_ON_LEAK
&&GETENV("GC_ABORT_ON_LEAK")!=NULL
#endif
){
ABORT("Leaked or smashed objects encountered");
}
LOCK();
printing_errors=FALSE;
UNLOCK();
}
GC_INNER GC_bool GC_block_empty(hdr*hhdr)
{
return (hhdr->hb_n_marks==0);
}
STATIC GC_bool GC_block_nearly_full(hdr*hhdr,word sz)
{
return hhdr->hb_n_marks > HBLK_OBJS(sz)*7/8;
}
STATIC ptr_t GC_reclaim_clear(struct hblk*hbp,hdr*hhdr,word sz,
ptr_t list,signed_word*count)
{
word bit_no=0;
word*p,*q,*plim;
signed_word n_bytes_found=0;
GC_ASSERT(hhdr==GC_find_header((ptr_t)hbp));
#ifndef THREADS
GC_ASSERT(sz==hhdr->hb_sz);
#else
#endif
GC_ASSERT((sz&(BYTES_PER_WORD-1))==0);
p=(word*)(hbp->hb_body);
plim=(word*)(hbp->hb_body+HBLKSIZE - sz);
while ((word)p<=(word)plim){
if (mark_bit_from_hdr(hhdr,bit_no)){
p=(word*)((ptr_t)p+sz);
} else {
n_bytes_found+=sz;
obj_link(p)=list;
list=((ptr_t)p);
q=(word*)((ptr_t)p+sz);
#ifdef USE_MARK_BYTES
GC_ASSERT(!(sz&1)
&&!((word)p&(2*sizeof(word)- 1)));
p[1]=0;
p+=2;
while ((word)p < (word)q){
CLEAR_DOUBLE(p);
p+=2;
}
#else
p++;
while ((word)p < (word)q){
*p++=0;
}
#endif
}
bit_no+=MARK_BIT_OFFSET(sz);
}
*count+=n_bytes_found;
return(list);
}
STATIC ptr_t GC_reclaim_uninit(struct hblk*hbp,hdr*hhdr,word sz,
ptr_t list,signed_word*count)
{
word bit_no=0;
word*p,*plim;
signed_word n_bytes_found=0;
#ifndef THREADS
GC_ASSERT(sz==hhdr->hb_sz);
#endif
p=(word*)(hbp->hb_body);
plim=(word*)((ptr_t)hbp+HBLKSIZE - sz);
while ((word)p<=(word)plim){
if (!mark_bit_from_hdr(hhdr,bit_no)){
n_bytes_found+=sz;
obj_link(p)=list;
list=((ptr_t)p);
}
p=(word*)((ptr_t)p+sz);
bit_no+=MARK_BIT_OFFSET(sz);
}
*count+=n_bytes_found;
return(list);
}
#ifdef ENABLE_DISCLAIM
STATIC ptr_t GC_disclaim_and_reclaim(struct hblk*hbp,hdr*hhdr,word sz,
ptr_t list,signed_word*count)
{
word bit_no=0;
word*p,*q,*plim;
signed_word n_bytes_found=0;
struct obj_kind*ok=&GC_obj_kinds[hhdr->hb_obj_kind];
int (GC_CALLBACK*disclaim)(void*)=ok->ok_disclaim_proc;
#ifndef THREADS
GC_ASSERT(sz==hhdr->hb_sz);
#endif
p=(word*)(hbp->hb_body);
plim=(word*)((ptr_t)p+HBLKSIZE - sz);
while ((word)p<=(word)plim){
int marked=mark_bit_from_hdr(hhdr,bit_no);
if (!marked&&(*disclaim)(p)){
set_mark_bit_from_hdr(hhdr,bit_no);
hhdr->hb_n_marks++;
marked=1;
}
if (marked)
p=(word*)((ptr_t)p+sz);
else {
n_bytes_found+=sz;
obj_link(p)=list;
list=((ptr_t)p);
q=(word*)((ptr_t)p+sz);
#ifdef USE_MARK_BYTES
GC_ASSERT((sz&1)==0);
GC_ASSERT(((word)p&(2*sizeof(word)- 1))==0);
p[1]=0;
p+=2;
while ((word)p < (word)q){
CLEAR_DOUBLE(p);
p+=2;
}
#else
p++;
while ((word)p < (word)q){
*p++=0;
}
#endif
}
bit_no+=MARK_BIT_OFFSET(sz);
}
*count+=n_bytes_found;
return list;
}
#endif
STATIC void GC_reclaim_check(struct hblk*hbp,hdr*hhdr,word sz)
{
word bit_no;
ptr_t p,plim;
#ifndef THREADS
GC_ASSERT(sz==hhdr->hb_sz);
#endif
p=hbp->hb_body;
plim=p+HBLKSIZE - sz;
for (bit_no=0;(word)p<=(word)plim;
p+=sz,bit_no+=MARK_BIT_OFFSET(sz)){
if (!mark_bit_from_hdr(hhdr,bit_no)){
GC_add_leaked(p);
}
}
}
#ifdef AO_HAVE_load
#define IS_PTRFREE_SAFE(hhdr)(AO_load((volatile AO_t*)&(hhdr)->hb_descr)==0)
#else
#define IS_PTRFREE_SAFE(hhdr)((hhdr)->hb_descr==0)
#endif
GC_INNER ptr_t GC_reclaim_generic(struct hblk*hbp,hdr*hhdr,size_t sz,
GC_bool init,ptr_t list,
signed_word*count)
{
ptr_t result;
GC_ASSERT(GC_find_header((ptr_t)hbp)==hhdr);
#ifndef GC_DISABLE_INCREMENTAL
GC_remove_protection(hbp,1,IS_PTRFREE_SAFE(hhdr));
#endif
#ifdef ENABLE_DISCLAIM
if ((hhdr->hb_flags&HAS_DISCLAIM)!=0){
result=GC_disclaim_and_reclaim(hbp,hhdr,sz,list,count);
} else
#endif
if (init||GC_debugging_started){
result=GC_reclaim_clear(hbp,hhdr,sz,list,count);
} else {
GC_ASSERT(IS_PTRFREE_SAFE(hhdr));
result=GC_reclaim_uninit(hbp,hhdr,sz,list,count);
}
if (IS_UNCOLLECTABLE(hhdr->hb_obj_kind))GC_set_hdr_marks(hhdr);
return result;
}
STATIC void GC_reclaim_small_nonempty_block(struct hblk*hbp,word sz,
GC_bool report_if_found)
{
hdr*hhdr=HDR(hbp);
struct obj_kind*ok=&GC_obj_kinds[hhdr->hb_obj_kind];
void**flh=&(ok->ok_freelist[BYTES_TO_GRANULES(sz)]);
hhdr->hb_last_reclaimed=(unsigned short)GC_gc_no;
if (report_if_found){
GC_reclaim_check(hbp,hhdr,sz);
} else {
*flh=GC_reclaim_generic(hbp,hhdr,sz,ok->ok_init,
(ptr_t)(*flh),&GC_bytes_found);
}
}
#ifdef ENABLE_DISCLAIM
STATIC void GC_disclaim_and_reclaim_or_free_small_block(struct hblk*hbp)
{
hdr*hhdr=HDR(hbp);
word sz=hhdr->hb_sz;
struct obj_kind*ok=&GC_obj_kinds[hhdr->hb_obj_kind];
void**flh=&(ok->ok_freelist[BYTES_TO_GRANULES(sz)]);
void*flh_next;
hhdr->hb_last_reclaimed=(unsigned short)GC_gc_no;
flh_next=GC_reclaim_generic(hbp,hhdr,sz,ok->ok_init,
(ptr_t)(*flh),&GC_bytes_found);
if (hhdr->hb_n_marks)
*flh=flh_next;
else {
GC_bytes_found+=HBLKSIZE;
GC_freehblk(hbp);
}
}
#endif
STATIC void GC_reclaim_block(struct hblk*hbp,word report_if_found)
{
hdr*hhdr=HDR(hbp);
word sz;
struct obj_kind*ok=&GC_obj_kinds[hhdr->hb_obj_kind];
#ifdef AO_HAVE_load
sz=(word)AO_load((volatile AO_t*)&hhdr->hb_sz);
#else
sz=hhdr->hb_sz;
#endif
if( sz > MAXOBJBYTES){
if(!mark_bit_from_hdr(hhdr,0)){
if (report_if_found){
GC_add_leaked((ptr_t)hbp);
} else {
word blocks;
#ifdef ENABLE_DISCLAIM
if (EXPECT(hhdr->hb_flags&HAS_DISCLAIM,0)){
if ((*ok->ok_disclaim_proc)(hbp)){
set_mark_bit_from_hdr(hhdr,0);
goto in_use;
}
}
#endif
blocks=OBJ_SZ_TO_BLOCKS(sz);
#if defined(CPPCHECK)
GC_noop1((word)&blocks);
#endif
if (blocks > 1){
GC_large_allocd_bytes-=blocks*HBLKSIZE;
}
GC_bytes_found+=sz;
GC_freehblk(hbp);
}
} else {
#ifdef ENABLE_DISCLAIM
in_use:
#endif
if (IS_PTRFREE_SAFE(hhdr)){
GC_atomic_in_use+=sz;
} else {
GC_composite_in_use+=sz;
}
}
} else {
GC_bool empty=GC_block_empty(hhdr);
#ifdef PARALLEL_MARK
GC_ASSERT(hhdr->hb_n_marks<=2*(HBLKSIZE/sz+1)+16);
#else
GC_ASSERT(sz*hhdr->hb_n_marks<=HBLKSIZE);
#endif
if (report_if_found){
GC_reclaim_small_nonempty_block(hbp,sz,
TRUE);
} else if (empty){
#ifdef ENABLE_DISCLAIM
if ((hhdr->hb_flags&HAS_DISCLAIM)!=0){
GC_disclaim_and_reclaim_or_free_small_block(hbp);
} else
#endif
{
GC_bytes_found+=HBLKSIZE;
GC_freehblk(hbp);
}
} else if (GC_find_leak||!GC_block_nearly_full(hhdr,sz)){
struct hblk**rlh=ok->ok_reclaim_list;
if (rlh!=NULL){
rlh+=BYTES_TO_GRANULES(sz);
hhdr->hb_next=*rlh;
*rlh=hbp;
}
}
if (IS_PTRFREE_SAFE(hhdr)){
GC_atomic_in_use+=sz*hhdr->hb_n_marks;
} else {
GC_composite_in_use+=sz*hhdr->hb_n_marks;
}
}
}
#if!defined(NO_DEBUGGING)
struct Print_stats
{
size_t number_of_blocks;
size_t total_bytes;
};
#ifdef USE_MARK_BYTES
unsigned GC_n_set_marks(hdr*hhdr)
{
unsigned result=0;
word i;
word sz=hhdr->hb_sz;
word offset=MARK_BIT_OFFSET(sz);
word limit=FINAL_MARK_BIT(sz);
for (i=0;i < limit;i+=offset){
result+=hhdr->hb_marks[i];
}
GC_ASSERT(hhdr->hb_marks[limit]);
return(result);
}
#else
static unsigned set_bits(word n)
{
word m=n;
unsigned result=0;
while (m > 0){
if (m&1)result++;
m>>=1;
}
return(result);
}
unsigned GC_n_set_marks(hdr*hhdr)
{
unsigned result=0;
word i;
word n_mark_words;
#ifdef MARK_BIT_PER_OBJ
word n_objs=HBLK_OBJS(hhdr->hb_sz);
if (0==n_objs)n_objs=1;
n_mark_words=divWORDSZ(n_objs+WORDSZ - 1);
#else
n_mark_words=MARK_BITS_SZ;
#endif
for (i=0;i < n_mark_words - 1;i++){
result+=set_bits(hhdr->hb_marks[i]);
}
#ifdef MARK_BIT_PER_OBJ
result+=set_bits((hhdr->hb_marks[n_mark_words - 1])
<<(n_mark_words*WORDSZ - n_objs));
#else
result+=set_bits(hhdr->hb_marks[n_mark_words - 1]);
#endif
return result;
}
#endif
STATIC void GC_print_block_descr(struct hblk*h,
word raw_ps)
{
hdr*hhdr=HDR(h);
size_t bytes=hhdr->hb_sz;
struct Print_stats*ps;
unsigned n_marks=GC_n_set_marks(hhdr);
unsigned n_objs=(unsigned)HBLK_OBJS(bytes);
if (0==n_objs)n_objs=1;
if (hhdr->hb_n_marks!=n_marks){
GC_printf("%u,%u,%u!=%u,%u\n",hhdr->hb_obj_kind,(unsigned)bytes,
(unsigned)hhdr->hb_n_marks,n_marks,n_objs);
} else {
GC_printf("%u,%u,%u,%u\n",hhdr->hb_obj_kind,(unsigned)bytes,
n_marks,n_objs);
}
ps=(struct Print_stats*)raw_ps;
ps->total_bytes+=(bytes+(HBLKSIZE-1))&~(HBLKSIZE-1);
ps->number_of_blocks++;
}
void GC_print_block_list(void)
{
struct Print_stats pstats;
GC_printf("kind(0=ptrfree,1=normal,2=unc.),"
"size_in_bytes,#_marks_set,#objs\n");
pstats.number_of_blocks=0;
pstats.total_bytes=0;
GC_apply_to_all_blocks(GC_print_block_descr,(word)&pstats);
GC_printf("blocks=%lu,bytes=%lu\n",
(unsigned long)pstats.number_of_blocks,
(unsigned long)pstats.total_bytes);
}
GC_API void GC_CALL GC_print_free_list(int kind,size_t sz_in_granules)
{
void*flh_next;
int n;
GC_ASSERT(kind < MAXOBJKINDS);
GC_ASSERT(sz_in_granules<=MAXOBJGRANULES);
flh_next=GC_obj_kinds[kind].ok_freelist[sz_in_granules];
for (n=0;flh_next;n++){
GC_printf("Free object in heap block %p [%d]:%p\n",
(void*)HBLKPTR(flh_next),n,flh_next);
flh_next=obj_link(flh_next);
}
}
#endif
STATIC void GC_clear_fl_links(void**flp)
{
void*next=*flp;
while (0!=next){
*flp=0;
flp=&(obj_link(next));
next=*flp;
}
}
GC_INNER void GC_start_reclaim(GC_bool report_if_found)
{
unsigned kind;
#if defined(PARALLEL_MARK)
GC_ASSERT(0==GC_fl_builder_count);
#endif
GC_composite_in_use=0;
GC_atomic_in_use=0;
for (kind=0;kind < GC_n_kinds;kind++){
struct hblk**rlist=GC_obj_kinds[kind].ok_reclaim_list;
GC_bool should_clobber=(GC_obj_kinds[kind].ok_descriptor!=0);
if (rlist==0)continue;
if (!report_if_found){
void**fop;
void**lim=&(GC_obj_kinds[kind].ok_freelist[MAXOBJGRANULES+1]);
for (fop=GC_obj_kinds[kind].ok_freelist;
(word)fop < (word)lim;(*(word**)&fop)++){
if (*fop!=0){
if (should_clobber){
GC_clear_fl_links(fop);
} else {
*fop=0;
}
}
}
}
BZERO(rlist,(MAXOBJGRANULES+1)*sizeof(void*));
}
GC_apply_to_all_blocks(GC_reclaim_block,(word)report_if_found);
#ifdef EAGER_SWEEP
GC_reclaim_all((GC_stop_func)0,FALSE);
#elif defined(ENABLE_DISCLAIM)
GC_reclaim_unconditionally_marked();
#endif
#if defined(PARALLEL_MARK)
GC_ASSERT(0==GC_fl_builder_count);
#endif
}
GC_INNER void GC_continue_reclaim(word sz,int kind)
{
hdr*hhdr;
struct hblk*hbp;
struct obj_kind*ok=&(GC_obj_kinds[kind]);
struct hblk**rlh=ok->ok_reclaim_list;
void**flh=&(ok->ok_freelist[sz]);
if (NULL==rlh)
return;
for (rlh+=sz;(hbp=*rlh)!=NULL;){
hhdr=HDR(hbp);
*rlh=hhdr->hb_next;
GC_reclaim_small_nonempty_block(hbp,hhdr->hb_sz,FALSE);
if (*flh!=0)
break;
}
}
GC_INNER GC_bool GC_reclaim_all(GC_stop_func stop_func,GC_bool ignore_old)
{
word sz;
unsigned kind;
hdr*hhdr;
struct hblk*hbp;
struct obj_kind*ok;
struct hblk**rlp;
struct hblk**rlh;
#ifndef NO_CLOCK
CLOCK_TYPE start_time=CLOCK_TYPE_INITIALIZER;
if (GC_print_stats==VERBOSE)
GET_TIME(start_time);
#endif
for (kind=0;kind < GC_n_kinds;kind++){
ok=&(GC_obj_kinds[kind]);
rlp=ok->ok_reclaim_list;
if (rlp==0)continue;
for (sz=1;sz<=MAXOBJGRANULES;sz++){
for (rlh=rlp+sz;(hbp=*rlh)!=NULL;){
if (stop_func!=(GC_stop_func)0&&(*stop_func)()){
return(FALSE);
}
hhdr=HDR(hbp);
*rlh=hhdr->hb_next;
if (!ignore_old
||(word)hhdr->hb_last_reclaimed==GC_gc_no - 1){
GC_reclaim_small_nonempty_block(hbp,hhdr->hb_sz,FALSE);
}
}
}
}
#ifndef NO_CLOCK
if (GC_print_stats==VERBOSE){
CLOCK_TYPE done_time;
GET_TIME(done_time);
GC_verbose_log_printf(
"Disposing of reclaim lists took %lu ms %lu ns\n",
MS_TIME_DIFF(done_time,start_time),
NS_FRAC_TIME_DIFF(done_time,start_time));
}
#endif
return(TRUE);
}
#if!defined(EAGER_SWEEP)&&defined(ENABLE_DISCLAIM)
STATIC void GC_reclaim_unconditionally_marked(void)
{
word sz;
unsigned kind;
hdr*hhdr;
struct hblk*hbp;
struct obj_kind*ok;
struct hblk**rlp;
struct hblk**rlh;
for (kind=0;kind < GC_n_kinds;kind++){
ok=&(GC_obj_kinds[kind]);
if (!ok->ok_mark_unconditionally)
continue;
rlp=ok->ok_reclaim_list;
if (rlp==0)
continue;
for (sz=1;sz<=MAXOBJGRANULES;sz++){
rlh=rlp+sz;
while ((hbp=*rlh)!=0){
hhdr=HDR(hbp);
*rlh=hhdr->hb_next;
GC_reclaim_small_nonempty_block(hbp,hhdr->hb_sz,FALSE);
}
}
}
}
#endif
struct enumerate_reachable_s {
GC_reachable_object_proc proc;
void*client_data;
};
STATIC void GC_do_enumerate_reachable_objects(struct hblk*hbp,word ped)
{
struct hblkhdr*hhdr=HDR(hbp);
size_t sz=(size_t)hhdr->hb_sz;
size_t bit_no;
char*p,*plim;
if (GC_block_empty(hhdr)){
return;
}
p=hbp->hb_body;
if (sz > MAXOBJBYTES){
plim=p;
} else {
plim=hbp->hb_body+HBLKSIZE - sz;
}
for (bit_no=0;p<=plim;bit_no+=MARK_BIT_OFFSET(sz),p+=sz){
if (mark_bit_from_hdr(hhdr,bit_no)){
((struct enumerate_reachable_s*)ped)->proc(p,sz,
((struct enumerate_reachable_s*)ped)->client_data);
}
}
}
GC_API void GC_CALL GC_enumerate_reachable_objects_inner(
GC_reachable_object_proc proc,
void*client_data)
{
struct enumerate_reachable_s ed;
GC_ASSERT(I_HOLD_LOCK());
ed.proc=proc;
ed.client_data=client_data;
GC_apply_to_all_blocks(GC_do_enumerate_reachable_objects,(word)&ed);
}
#ifndef GC_TYPED_H
#define GC_TYPED_H
#ifndef GC_H
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef GC_word*GC_bitmap;
#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*,
size_t);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_malloc_explicitly_typed(size_t,
GC_descr);
GC_API GC_ATTR_MALLOC GC_ATTR_ALLOC_SIZE(1)void*GC_CALL
GC_malloc_explicitly_typed_ignore_off_page(size_t,
GC_descr);
GC_API GC_ATTR_MALLOC GC_ATTR_CALLOC_SIZE(1,2)void*GC_CALL
GC_calloc_explicitly_typed(size_t,
size_t,
GC_descr);
#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
}
#endif
#endif
#define TYPD_EXTRA_BYTES (sizeof(word)- EXTRA_BYTES)
STATIC int GC_explicit_kind=0;
STATIC int GC_array_kind=0;
struct LeafDescriptor {
word ld_tag;
#define LEAF_TAG 1
size_t ld_size;
size_t ld_nelements;
GC_descr ld_descriptor;
};
struct ComplexArrayDescriptor {
word ad_tag;
#define ARRAY_TAG 2
size_t ad_nelements;
union ComplexDescriptor*ad_element_descr;
};
struct SequenceDescriptor {
word sd_tag;
#define SEQUENCE_TAG 3
union ComplexDescriptor*sd_first;
union ComplexDescriptor*sd_second;
};
typedef union ComplexDescriptor {
struct LeafDescriptor ld;
struct ComplexArrayDescriptor ad;
struct SequenceDescriptor sd;
} complex_descriptor;
#define TAG ad.ad_tag
#define ED_INITIAL_SIZE 100
STATIC int GC_typed_mark_proc_index=0;
STATIC int GC_array_mark_proc_index=0;
STATIC void GC_push_typed_structures_proc(void)
{
GC_PUSH_ALL_SYM(GC_ext_descriptors);
}
STATIC signed_word GC_add_ext_descriptor(const word*bm,word nbits)
{
size_t nwords=divWORDSZ(nbits+WORDSZ-1);
signed_word result;
size_t i;
word last_part;
size_t extra_bits;
DCL_LOCK_STATE;
LOCK();
while (GC_avail_descr+nwords>=GC_ed_size){
typed_ext_descr_t*newExtD;
size_t new_size;
word ed_size=GC_ed_size;
if (ed_size==0){
GC_ASSERT((word)(&GC_ext_descriptors)% sizeof(word)==0);
GC_push_typed_structures=GC_push_typed_structures_proc;
UNLOCK();
new_size=ED_INITIAL_SIZE;
} else {
UNLOCK();
new_size=2*ed_size;
if (new_size > MAX_ENV)return(-1);
}
newExtD=(typed_ext_descr_t*)GC_malloc_atomic(new_size
*sizeof(typed_ext_descr_t));
if (NULL==newExtD)
return -1;
LOCK();
if (ed_size==GC_ed_size){
if (GC_avail_descr!=0){
BCOPY(GC_ext_descriptors,newExtD,
GC_avail_descr*sizeof(typed_ext_descr_t));
}
GC_ed_size=new_size;
GC_ext_descriptors=newExtD;
}
}
result=GC_avail_descr;
for (i=0;i < nwords-1;i++){
GC_ext_descriptors[result+i].ed_bitmap=bm[i];
GC_ext_descriptors[result+i].ed_continued=TRUE;
}
last_part=bm[i];
extra_bits=nwords*WORDSZ - nbits;
last_part<<=extra_bits;
last_part>>=extra_bits;
GC_ext_descriptors[result+i].ed_bitmap=last_part;
GC_ext_descriptors[result+i].ed_continued=FALSE;
GC_avail_descr+=nwords;
UNLOCK();
return(result);
}
STATIC GC_descr GC_bm_table[WORDSZ/2];
STATIC GC_descr GC_double_descr(GC_descr descriptor,word nwords)
{
if ((descriptor&GC_DS_TAGS)==GC_DS_LENGTH){
descriptor=GC_bm_table[BYTES_TO_WORDS((word)descriptor)];
};
descriptor|=(descriptor&~GC_DS_TAGS)>>nwords;
return(descriptor);
}
STATIC complex_descriptor*
GC_make_sequence_descriptor(complex_descriptor*first,
complex_descriptor*second);
#define COMPLEX 2
#define LEAF 1
#define SIMPLE 0
#define NO_MEM (-1)
STATIC int GC_make_array_descriptor(size_t nelements,size_t size,
GC_descr descriptor,GC_descr*simple_d,
complex_descriptor**complex_d,
struct LeafDescriptor*leaf)
{
#define OPT_THRESHOLD 50
if ((descriptor&GC_DS_TAGS)==GC_DS_LENGTH){
if (descriptor==(GC_descr)size){
*simple_d=nelements*descriptor;
return(SIMPLE);
} else if ((word)descriptor==0){
*simple_d=(GC_descr)0;
return(SIMPLE);
}
}
if (nelements<=OPT_THRESHOLD){
if (nelements<=1){
if (nelements==1){
*simple_d=descriptor;
return(SIMPLE);
} else {
*simple_d=(GC_descr)0;
return(SIMPLE);
}
}
} else if (size<=BITMAP_BITS/2
&&(descriptor&GC_DS_TAGS)!=GC_DS_PROC
&&(size&(sizeof(word)-1))==0){
int result=
GC_make_array_descriptor(nelements/2,2*size,
GC_double_descr(descriptor,
BYTES_TO_WORDS(size)),
simple_d,complex_d,leaf);
if ((nelements&1)==0){
return(result);
} else {
struct LeafDescriptor*one_element=
(struct LeafDescriptor*)
GC_malloc_atomic(sizeof(struct LeafDescriptor));
if (result==NO_MEM||one_element==0)return(NO_MEM);
one_element->ld_tag=LEAF_TAG;
one_element->ld_size=size;
one_element->ld_nelements=1;
one_element->ld_descriptor=descriptor;
switch(result){
case SIMPLE:
{
struct LeafDescriptor*beginning=
(struct LeafDescriptor*)
GC_malloc_atomic(sizeof(struct LeafDescriptor));
if (beginning==0)return(NO_MEM);
beginning->ld_tag=LEAF_TAG;
beginning->ld_size=size;
beginning->ld_nelements=1;
beginning->ld_descriptor=*simple_d;
*complex_d=GC_make_sequence_descriptor(
(complex_descriptor*)beginning,
(complex_descriptor*)one_element);
break;
}
case LEAF:
{
struct LeafDescriptor*beginning=
(struct LeafDescriptor*)
GC_malloc_atomic(sizeof(struct LeafDescriptor));
if (beginning==0)return(NO_MEM);
beginning->ld_tag=LEAF_TAG;
beginning->ld_size=leaf->ld_size;
beginning->ld_nelements=leaf->ld_nelements;
beginning->ld_descriptor=leaf->ld_descriptor;
*complex_d=GC_make_sequence_descriptor(
(complex_descriptor*)beginning,
(complex_descriptor*)one_element);
break;
}
case COMPLEX:
*complex_d=GC_make_sequence_descriptor(
*complex_d,
(complex_descriptor*)one_element);
break;
}
return(COMPLEX);
}
}
leaf->ld_size=size;
leaf->ld_nelements=nelements;
leaf->ld_descriptor=descriptor;
return(LEAF);
}
STATIC complex_descriptor*
GC_make_sequence_descriptor(complex_descriptor*first,
complex_descriptor*second)
{
struct SequenceDescriptor*result=
(struct SequenceDescriptor*)
GC_malloc(sizeof(struct SequenceDescriptor));
if (result!=0){
result->sd_tag=SEQUENCE_TAG;
result->sd_first=first;
result->sd_second=second;
GC_dirty(result);
REACHABLE_AFTER_DIRTY(first);
REACHABLE_AFTER_DIRTY(second);
}
return((complex_descriptor*)result);
}
STATIC mse*GC_typed_mark_proc(word*addr,mse*mark_stack_ptr,
mse*mark_stack_limit,word env);
STATIC mse*GC_array_mark_proc(word*addr,mse*mark_stack_ptr,
mse*mark_stack_limit,word env);
STATIC void GC_init_explicit_typing(void)
{
unsigned i;
GC_STATIC_ASSERT(sizeof(struct LeafDescriptor)% sizeof(word)==0);
GC_explicit_kind=GC_new_kind_inner(GC_new_free_list_inner(),
(WORDS_TO_BYTES((word)-1)|GC_DS_PER_OBJECT),
TRUE,TRUE);
GC_typed_mark_proc_index=GC_new_proc_inner(GC_typed_mark_proc);
GC_array_mark_proc_index=GC_new_proc_inner(GC_array_mark_proc);
GC_array_kind=GC_new_kind_inner(GC_new_free_list_inner(),
GC_MAKE_PROC(GC_array_mark_proc_index,0),
FALSE,TRUE);
GC_bm_table[0]=GC_DS_BITMAP;
for (i=1;i < WORDSZ/2;i++){
GC_bm_table[i]=(((word)-1)<<(WORDSZ - i))|GC_DS_BITMAP;
}
}
STATIC mse*GC_typed_mark_proc(word*addr,mse*mark_stack_ptr,
mse*mark_stack_limit,word env)
{
word bm=GC_ext_descriptors[env].ed_bitmap;
word*current_p=addr;
word current;
ptr_t greatest_ha=(ptr_t)GC_greatest_plausible_heap_addr;
ptr_t least_ha=(ptr_t)GC_least_plausible_heap_addr;
DECLARE_HDR_CACHE;
INIT_HDR_CACHE;
for (;bm!=0;bm>>=1,current_p++){
if (bm&1){
current=*current_p;
FIXUP_POINTER(current);
if (current>=(word)least_ha&&current<=(word)greatest_ha){
PUSH_CONTENTS((ptr_t)current,mark_stack_ptr,
mark_stack_limit,(ptr_t)current_p);
}
}
}
if (GC_ext_descriptors[env].ed_continued){
mark_stack_ptr++;
if ((word)mark_stack_ptr>=(word)mark_stack_limit){
mark_stack_ptr=GC_signal_mark_stack_overflow(mark_stack_ptr);
}
mark_stack_ptr->mse_start=(ptr_t)(addr+WORDSZ);
mark_stack_ptr->mse_descr.w=
GC_MAKE_PROC(GC_typed_mark_proc_index,env+1);
}
return(mark_stack_ptr);
}
STATIC word GC_descr_obj_size(complex_descriptor*d)
{
switch(d->TAG){
case LEAF_TAG:
return(d->ld.ld_nelements*d->ld.ld_size);
case ARRAY_TAG:
return(d->ad.ad_nelements
*GC_descr_obj_size(d->ad.ad_element_descr));
case SEQUENCE_TAG:
return(GC_descr_obj_size(d->sd.sd_first)
+GC_descr_obj_size(d->sd.sd_second));
default:
ABORT_RET("Bad complex descriptor");
return 0;
}
}
STATIC mse*GC_push_complex_descriptor(word*addr,complex_descriptor*d,
mse*msp,mse*msl)
{
ptr_t current=(ptr_t)addr;
word nelements;
word sz;
word i;
switch(d->TAG){
case LEAF_TAG:
{
GC_descr descr=d->ld.ld_descriptor;
nelements=d->ld.ld_nelements;
if (msl - msp<=(ptrdiff_t)nelements)return(0);
sz=d->ld.ld_size;
for (i=0;i < nelements;i++){
msp++;
msp->mse_start=current;
msp->mse_descr.w=descr;
current+=sz;
}
return(msp);
}
case ARRAY_TAG:
{
complex_descriptor*descr=d->ad.ad_element_descr;
nelements=d->ad.ad_nelements;
sz=GC_descr_obj_size(descr);
for (i=0;i < nelements;i++){
msp=GC_push_complex_descriptor((word*)current,descr,
msp,msl);
if (msp==0)return(0);
current+=sz;
}
return(msp);
}
case SEQUENCE_TAG:
{
sz=GC_descr_obj_size(d->sd.sd_first);
msp=GC_push_complex_descriptor((word*)current,d->sd.sd_first,
msp,msl);
if (msp==0)return(0);
current+=sz;
msp=GC_push_complex_descriptor((word*)current,d->sd.sd_second,
msp,msl);
return(msp);
}
default:
ABORT_RET("Bad complex descriptor");
return 0;
}
}
STATIC mse*GC_array_mark_proc(word*addr,mse*mark_stack_ptr,
mse*mark_stack_limit,
word env GC_ATTR_UNUSED)
{
hdr*hhdr=HDR(addr);
word sz=hhdr->hb_sz;
word nwords=BYTES_TO_WORDS(sz);
complex_descriptor*descr=(complex_descriptor*)(addr[nwords-1]);
mse*orig_mark_stack_ptr=mark_stack_ptr;
mse*new_mark_stack_ptr;
if (descr==0){
return(orig_mark_stack_ptr);
}
new_mark_stack_ptr=GC_push_complex_descriptor(addr,descr,
mark_stack_ptr,
mark_stack_limit-1);
if (new_mark_stack_ptr==0){
if (NULL==mark_stack_ptr)ABORT("Bad mark_stack_ptr");
#ifdef PARALLEL_MARK
if (GC_mark_stack+GC_mark_stack_size==mark_stack_limit)
#endif
{
GC_mark_stack_too_small=TRUE;
}
new_mark_stack_ptr=orig_mark_stack_ptr+1;
new_mark_stack_ptr->mse_start=(ptr_t)addr;
new_mark_stack_ptr->mse_descr.w=sz|GC_DS_LENGTH;
} else {
new_mark_stack_ptr++;
new_mark_stack_ptr->mse_start=(ptr_t)(addr+nwords - 1);
new_mark_stack_ptr->mse_descr.w=sizeof(word)|GC_DS_LENGTH;
}
return new_mark_stack_ptr;
}
GC_API GC_descr GC_CALL GC_make_descriptor(const GC_word*bm,size_t len)
{
signed_word last_set_bit=len - 1;
GC_descr result;
DCL_LOCK_STATE;
#if defined(AO_HAVE_load_acquire)&&defined(AO_HAVE_store_release)
if (!EXPECT(AO_load_acquire(&GC_explicit_typing_initialized),TRUE)){
LOCK();
if (!GC_explicit_typing_initialized){
GC_init_explicit_typing();
AO_store_release(&GC_explicit_typing_initialized,TRUE);
}
UNLOCK();
}
#else
LOCK();
if (!EXPECT(GC_explicit_typing_initialized,TRUE)){
GC_init_explicit_typing();
GC_explicit_typing_initialized=TRUE;
}
UNLOCK();
#endif
while (last_set_bit>=0&&!GC_get_bit(bm,last_set_bit))
last_set_bit--;
if (last_set_bit < 0)return(0);
#if ALIGNMENT==CPP_WORDSZ/8
{
signed_word i;
for (i=0;i < last_set_bit;i++){
if (!GC_get_bit(bm,i)){
break;
}
}
if (i==last_set_bit){
return (WORDS_TO_BYTES(last_set_bit+1)|GC_DS_LENGTH);
}
}
#endif
if ((word)last_set_bit < BITMAP_BITS){
signed_word i;
result=SIGNB;
for (i=last_set_bit - 1;i>=0;i--){
result>>=1;
if (GC_get_bit(bm,i))result|=SIGNB;
}
result|=GC_DS_BITMAP;
} else {
signed_word index=GC_add_ext_descriptor(bm,(word)last_set_bit+1);
if (index==-1)return(WORDS_TO_BYTES(last_set_bit+1)|GC_DS_LENGTH);
result=GC_MAKE_PROC(GC_typed_mark_proc_index,(word)index);
}
return result;
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_malloc_explicitly_typed(size_t lb,
GC_descr d)
{
word*op;
size_t lg;
GC_ASSERT(GC_explicit_typing_initialized);
lb=SIZET_SAT_ADD(lb,TYPD_EXTRA_BYTES);
op=(word*)GC_malloc_kind(lb,GC_explicit_kind);
if (EXPECT(NULL==op,FALSE))
return NULL;
lg=BYTES_TO_GRANULES(GC_size(op));
op[GRANULES_TO_WORDS(lg)- 1]=d;
GC_dirty(op+GRANULES_TO_WORDS(lg)- 1);
REACHABLE_AFTER_DIRTY(d);
return op;
}
#define GENERAL_MALLOC_IOP(lb,k)GC_clear_stack(GC_generic_malloc_ignore_off_page(lb,k))
GC_API GC_ATTR_MALLOC void*GC_CALL
GC_malloc_explicitly_typed_ignore_off_page(size_t lb,GC_descr d)
{
ptr_t op;
size_t lg;
DCL_LOCK_STATE;
GC_ASSERT(GC_explicit_typing_initialized);
lb=SIZET_SAT_ADD(lb,TYPD_EXTRA_BYTES);
if (SMALL_OBJ(lb)){
void**opp;
GC_DBG_COLLECT_AT_MALLOC(lb);
LOCK();
lg=GC_size_map[lb];
opp=&GC_obj_kinds[GC_explicit_kind].ok_freelist[lg];
op=(ptr_t)(*opp);
if (EXPECT(0==op,FALSE)){
UNLOCK();
op=(ptr_t)GENERAL_MALLOC_IOP(lb,GC_explicit_kind);
if (0==op)return 0;
lg=BYTES_TO_GRANULES(GC_size(op));
} else {
*opp=obj_link(op);
obj_link(op)=0;
GC_bytes_allocd+=GRANULES_TO_BYTES((word)lg);
UNLOCK();
}
} else {
op=(ptr_t)GENERAL_MALLOC_IOP(lb,GC_explicit_kind);
if (NULL==op)return NULL;
lg=BYTES_TO_GRANULES(GC_size(op));
}
((word*)op)[GRANULES_TO_WORDS(lg)- 1]=d;
GC_dirty(op+GRANULES_TO_WORDS(lg)- 1);
REACHABLE_AFTER_DIRTY(d);
return op;
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_calloc_explicitly_typed(size_t n,
size_t lb,GC_descr d)
{
word*op;
size_t lg;
GC_descr simple_descr;
complex_descriptor*complex_descr;
int descr_type;
struct LeafDescriptor leaf;
GC_ASSERT(GC_explicit_typing_initialized);
descr_type=GC_make_array_descriptor((word)n,(word)lb,d,&simple_descr,
&complex_descr,&leaf);
if ((lb|n)> GC_SQRT_SIZE_MAX
&&lb > 0&&n > GC_SIZE_MAX/lb)
return (*GC_get_oom_fn())(GC_SIZE_MAX);
lb*=n;
switch(descr_type){
case NO_MEM:return(0);
case SIMPLE:
return GC_malloc_explicitly_typed(lb,simple_descr);
case LEAF:
lb=SIZET_SAT_ADD(lb,
sizeof(struct LeafDescriptor)+TYPD_EXTRA_BYTES);
break;
case COMPLEX:
lb=SIZET_SAT_ADD(lb,TYPD_EXTRA_BYTES);
break;
}
op=(word*)GC_malloc_kind(lb,GC_array_kind);
if (EXPECT(NULL==op,FALSE))
return NULL;
lg=BYTES_TO_GRANULES(GC_size(op));
if (descr_type==LEAF){
volatile struct LeafDescriptor*lp=
(struct LeafDescriptor*)
(op+GRANULES_TO_WORDS(lg)
- (BYTES_TO_WORDS(sizeof(struct LeafDescriptor))+1));
lp->ld_tag=LEAF_TAG;
lp->ld_size=leaf.ld_size;
lp->ld_nelements=leaf.ld_nelements;
lp->ld_descriptor=leaf.ld_descriptor;
((volatile word*)op)[GRANULES_TO_WORDS(lg)- 1]=(word)lp;
} else {
#ifndef GC_NO_FINALIZATION
size_t lw=GRANULES_TO_WORDS(lg);
op[lw - 1]=(word)complex_descr;
GC_dirty(op+lw - 1);
REACHABLE_AFTER_DIRTY(complex_descr);
if (EXPECT(GC_general_register_disappearing_link(
(void**)(op+lw - 1),op)
==GC_NO_MEMORY,FALSE))
#endif
{
return (*GC_get_oom_fn())(lb);
}
}
return op;
}
#include <stdio.h>
#include <limits.h>
#include <stdarg.h>
#ifndef MSWINCE
#include <signal.h>
#endif
#ifdef GC_SOLARIS_THREADS
#include <sys/syscall.h>
#endif
#if defined(UNIX_LIKE)||defined(CYGWIN32)||defined(SYMBIAN)||(defined(CONSOLE_LOG)&&defined(MSWIN32))
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#endif
#if defined(CONSOLE_LOG)&&defined(MSWIN32)&&defined(_MSC_VER)
#include <io.h>
#endif
#ifdef NONSTOP
#include <floss.h>
#endif
#ifdef THREADS
#ifdef PCR
#include "il/PCR_IL.h"
GC_INNER PCR_Th_ML GC_allocate_ml;
#elif defined(SN_TARGET_PSP2)
GC_INNER WapiMutex GC_allocate_ml_PSP2={ 0,NULL };
#elif defined(SN_TARGET_ORBIS)||defined(SN_TARGET_PS3)
#include <pthread.h>
GC_INNER pthread_mutex_t GC_allocate_ml;
#endif
#endif
#ifdef DYNAMIC_LOADING
#define GC_REGISTER_MAIN_STATIC_DATA()GC_register_main_static_data()
#elif defined(GC_DONT_REGISTER_MAIN_STATIC_DATA)
#define GC_REGISTER_MAIN_STATIC_DATA()FALSE
#else
#define GC_REGISTER_MAIN_STATIC_DATA()TRUE
#endif
#ifdef NEED_CANCEL_DISABLE_COUNT
__thread unsigned char GC_cancel_disable_count=0;
#endif
GC_FAR struct _GC_arrays GC_arrays;
GC_INNER unsigned GC_n_mark_procs=GC_RESERVED_MARK_PROCS;
GC_INNER unsigned GC_n_kinds=GC_N_KINDS_INITIAL_VALUE;
GC_INNER GC_bool GC_debugging_started=FALSE;
ptr_t GC_stackbottom=0;
#ifdef IA64
ptr_t GC_register_stackbottom=0;
#endif
int GC_dont_gc=FALSE;
int GC_dont_precollect=FALSE;
GC_bool GC_quiet=0;
#if!defined(NO_CLOCK)||!defined(SMALL_CONFIG)
int GC_print_stats=0;
#endif
#ifdef GC_PRINT_BACK_HEIGHT
GC_INNER GC_bool GC_print_back_height=TRUE;
#else
GC_INNER GC_bool GC_print_back_height=FALSE;
#endif
#ifndef NO_DEBUGGING
#ifdef GC_DUMP_REGULARLY
GC_INNER GC_bool GC_dump_regularly=TRUE;
#else
GC_INNER GC_bool GC_dump_regularly=FALSE;
#endif
#ifndef NO_CLOCK
STATIC CLOCK_TYPE GC_init_time;
#endif
#endif
#ifdef KEEP_BACK_PTRS
GC_INNER long GC_backtraces=0;
#endif
#ifdef FIND_LEAK
int GC_find_leak=1;
#else
int GC_find_leak=0;
#endif
#ifndef SHORT_DBG_HDRS
#ifdef GC_FINDLEAK_DELAY_FREE
GC_INNER GC_bool GC_findleak_delay_free=TRUE;
#else
GC_INNER GC_bool GC_findleak_delay_free=FALSE;
#endif
#endif
#ifdef ALL_INTERIOR_POINTERS
int GC_all_interior_pointers=1;
#else
int GC_all_interior_pointers=0;
#endif
#ifdef FINALIZE_ON_DEMAND
int GC_finalize_on_demand=1;
#else
int GC_finalize_on_demand=0;
#endif
#ifdef JAVA_FINALIZATION
int GC_java_finalization=1;
#else
int GC_java_finalization=0;
#endif
GC_finalizer_notifier_proc GC_finalizer_notifier=
(GC_finalizer_notifier_proc)0;
#ifdef GC_FORCE_UNMAP_ON_GCOLLECT
GC_INNER GC_bool GC_force_unmap_on_gcollect=TRUE;
#else
GC_INNER GC_bool GC_force_unmap_on_gcollect=FALSE;
#endif
#ifndef GC_LARGE_ALLOC_WARN_INTERVAL
#define GC_LARGE_ALLOC_WARN_INTERVAL 5
#endif
GC_INNER long GC_large_alloc_warn_interval=GC_LARGE_ALLOC_WARN_INTERVAL;
STATIC void*GC_CALLBACK GC_default_oom_fn(
size_t bytes_requested GC_ATTR_UNUSED)
{
return(0);
}
GC_oom_func GC_oom_fn=GC_default_oom_fn;
#ifdef CAN_HANDLE_FORK
#ifdef HANDLE_FORK
GC_INNER int GC_handle_fork=1;
#else
GC_INNER int GC_handle_fork=FALSE;
#endif
#elif!defined(HAVE_NO_FORK)
GC_API void GC_CALL GC_atfork_prepare(void)
{
#ifdef THREADS
ABORT("fork()handling unsupported");
#endif
}
GC_API void GC_CALL GC_atfork_parent(void)
{
}
GC_API void GC_CALL GC_atfork_child(void)
{
}
#endif
GC_API void GC_CALL GC_set_handle_fork(int value GC_ATTR_UNUSED)
{
#ifdef CAN_HANDLE_FORK
if (!GC_is_initialized)
GC_handle_fork=value>=-1?value:1;
#elif defined(THREADS)||(defined(DARWIN)&&defined(MPROTECT_VDB))
if (!GC_is_initialized&&value){
#ifndef SMALL_CONFIG
GC_init();
#ifndef THREADS
if (GC_manual_vdb)
return;
#endif
#endif
ABORT("fork()handling unsupported");
}
#else
#endif
}
STATIC void GC_init_size_map(void)
{
size_t i;
GC_size_map[0]=1;
for (i=1;i<=GRANULES_TO_BYTES(TINY_FREELISTS-1)- EXTRA_BYTES;i++){
GC_size_map[i]=ROUNDED_UP_GRANULES(i);
#ifndef _MSC_VER
GC_ASSERT(GC_size_map[i] < TINY_FREELISTS);
#endif
}
}
#ifndef SMALL_CLEAR_SIZE
#define SMALL_CLEAR_SIZE 256
#endif
#if defined(ALWAYS_SMALL_CLEAR_STACK)||defined(STACK_NOT_SCANNED)
GC_API void*GC_CALL GC_clear_stack(void*arg)
{
#ifndef STACK_NOT_SCANNED
word volatile dummy[SMALL_CLEAR_SIZE];
BZERO(( void*)dummy,sizeof(dummy));
#endif
return arg;
}
#else
#ifdef THREADS
#define BIG_CLEAR_SIZE 2048
#else
STATIC word GC_stack_last_cleared=0;
STATIC ptr_t GC_min_sp=NULL;
STATIC ptr_t GC_high_water=NULL;
STATIC word GC_bytes_allocd_at_reset=0;
#define DEGRADE_RATE 50
#endif
#if defined(ASM_CLEAR_CODE)
void*GC_clear_stack_inner(void*,ptr_t);
#else
void*GC_clear_stack_inner(void*arg,
#if defined(__APPLE_CC__)&&!GC_CLANG_PREREQ(6,0)
volatile
#endif
ptr_t limit)
{
#define CLEAR_SIZE 213
volatile word dummy[CLEAR_SIZE];
BZERO(( void*)dummy,sizeof(dummy));
if ((word)GC_approx_sp()COOLER_THAN (word)limit){
(void)GC_clear_stack_inner(arg,limit);
}
#if defined(CPPCHECK)
GC_noop1(dummy[0]);
#else
GC_noop1(COVERT_DATAFLOW(dummy));
#endif
return(arg);
}
#endif
#ifdef THREADS
GC_ATTR_NO_SANITIZE_THREAD
static unsigned next_random_no(void)
{
static unsigned random_no=0;
return++random_no % 13;
}
#endif
GC_API void*GC_CALL GC_clear_stack(void*arg)
{
ptr_t sp=GC_approx_sp();
#ifdef THREADS
word volatile dummy[SMALL_CLEAR_SIZE];
#endif
#define SLOP 400
#define GC_SLOP 4000
#define CLEAR_THRESHOLD 100000
#ifdef THREADS
if (next_random_no()==0){
ptr_t limit=sp;
MAKE_HOTTER(limit,BIG_CLEAR_SIZE*sizeof(word));
limit=(ptr_t)((word)limit&~0xf);
return GC_clear_stack_inner(arg,limit);
}
BZERO((void*)dummy,SMALL_CLEAR_SIZE*sizeof(word));
#else
if (GC_gc_no > GC_stack_last_cleared){
if (GC_stack_last_cleared==0)
GC_high_water=(ptr_t)GC_stackbottom;
GC_min_sp=GC_high_water;
GC_stack_last_cleared=GC_gc_no;
GC_bytes_allocd_at_reset=GC_bytes_allocd;
}
MAKE_COOLER(GC_high_water,WORDS_TO_BYTES(DEGRADE_RATE)+GC_SLOP);
if ((word)sp HOTTER_THAN (word)GC_high_water){
GC_high_water=sp;
}
MAKE_HOTTER(GC_high_water,GC_SLOP);
{
ptr_t limit=GC_min_sp;
MAKE_HOTTER(limit,SLOP);
if ((word)sp COOLER_THAN (word)limit){
limit=(ptr_t)((word)limit&~0xf);
GC_min_sp=sp;
return GC_clear_stack_inner(arg,limit);
}
}
if (GC_bytes_allocd - GC_bytes_allocd_at_reset > CLEAR_THRESHOLD){
GC_min_sp=sp;
MAKE_HOTTER(GC_min_sp,CLEAR_THRESHOLD/4);
if ((word)GC_min_sp HOTTER_THAN (word)GC_high_water)
GC_min_sp=GC_high_water;
GC_bytes_allocd_at_reset=GC_bytes_allocd;
}
#endif
return arg;
}
#endif
GC_API void*GC_CALL GC_base(void*p)
{
ptr_t r;
struct hblk*h;
bottom_index*bi;
hdr*candidate_hdr;
r=(ptr_t)p;
if (!EXPECT(GC_is_initialized,TRUE))return 0;
h=HBLKPTR(r);
GET_BI(r,bi);
candidate_hdr=HDR_FROM_BI(bi,r);
if (candidate_hdr==0)return(0);
while (IS_FORWARDING_ADDR_OR_NIL(candidate_hdr)){
h=FORWARDED_ADDR(h,candidate_hdr);
r=(ptr_t)h;
candidate_hdr=HDR(h);
}
if (HBLK_IS_FREE(candidate_hdr))return(0);
r=(ptr_t)((word)r&~(WORDS_TO_BYTES(1)- 1));
{
size_t offset=HBLKDISPL(r);
word sz=candidate_hdr->hb_sz;
size_t obj_displ=offset % sz;
ptr_t limit;
r-=obj_displ;
limit=r+sz;
if ((word)limit > (word)(h+1)&&sz<=HBLKSIZE){
return(0);
}
if ((word)p>=(word)limit)return(0);
}
return((void*)r);
}
GC_API int GC_CALL GC_is_heap_ptr(const void*p)
{
bottom_index*bi;
GC_ASSERT(GC_is_initialized);
GET_BI(p,bi);
return HDR_FROM_BI(bi,p)!=0;
}
GC_API size_t GC_CALL GC_size(const void*p)
{
hdr*hhdr=HDR(p);
return (size_t)hhdr->hb_sz;
}
GC_API size_t GC_CALL GC_get_heap_size(void)
{
return (size_t)(GC_heapsize - GC_unmapped_bytes);
}
GC_API size_t GC_CALL GC_get_free_bytes(void)
{
return (size_t)(GC_large_free_bytes - GC_unmapped_bytes);
}
GC_API size_t GC_CALL GC_get_unmapped_bytes(void)
{
return (size_t)GC_unmapped_bytes;
}
GC_API size_t GC_CALL GC_get_bytes_since_gc(void)
{
return (size_t)GC_bytes_allocd;
}
GC_API size_t GC_CALL GC_get_total_bytes(void)
{
return (size_t)(GC_bytes_allocd+GC_bytes_allocd_before_gc);
}
#ifndef GC_GET_HEAP_USAGE_NOT_NEEDED
GC_API size_t GC_CALL GC_get_size_map_at(int i)
{
if ((unsigned)i > MAXOBJBYTES)
return GC_SIZE_MAX;
return GRANULES_TO_BYTES(GC_size_map[i]);
}
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)
{
DCL_LOCK_STATE;
LOCK();
if (pheap_size!=NULL)
*pheap_size=GC_heapsize - GC_unmapped_bytes;
if (pfree_bytes!=NULL)
*pfree_bytes=GC_large_free_bytes - GC_unmapped_bytes;
if (punmapped_bytes!=NULL)
*punmapped_bytes=GC_unmapped_bytes;
if (pbytes_since_gc!=NULL)
*pbytes_since_gc=GC_bytes_allocd;
if (ptotal_bytes!=NULL)
*ptotal_bytes=GC_bytes_allocd+GC_bytes_allocd_before_gc;
UNLOCK();
}
GC_INNER word GC_reclaimed_bytes_before_gc=0;
static void fill_prof_stats(struct GC_prof_stats_s*pstats)
{
pstats->heapsize_full=GC_heapsize;
pstats->free_bytes_full=GC_large_free_bytes;
pstats->unmapped_bytes=GC_unmapped_bytes;
pstats->bytes_allocd_since_gc=GC_bytes_allocd;
pstats->allocd_bytes_before_gc=GC_bytes_allocd_before_gc;
pstats->non_gc_bytes=GC_non_gc_bytes;
pstats->gc_no=GC_gc_no;
#ifdef PARALLEL_MARK
pstats->markers_m1=(word)((signed_word)GC_markers_m1);
#else
pstats->markers_m1=0;
#endif
pstats->bytes_reclaimed_since_gc=GC_bytes_found > 0?
(word)GC_bytes_found:0;
pstats->reclaimed_bytes_before_gc=GC_reclaimed_bytes_before_gc;
pstats->expl_freed_bytes_since_gc=GC_bytes_freed;
}
#include <string.h>
GC_API size_t GC_CALL GC_get_prof_stats(struct GC_prof_stats_s*pstats,
size_t stats_sz)
{
struct GC_prof_stats_s stats;
DCL_LOCK_STATE;
LOCK();
fill_prof_stats(stats_sz>=sizeof(stats)?pstats:&stats);
UNLOCK();
if (stats_sz==sizeof(stats)){
return sizeof(stats);
} else if (stats_sz > sizeof(stats)){
memset((char*)pstats+sizeof(stats),0xff,stats_sz - sizeof(stats));
return sizeof(stats);
} else {
if (EXPECT(stats_sz > 0,TRUE))
BCOPY(&stats,pstats,stats_sz);
return stats_sz;
}
}
#ifdef THREADS
GC_API size_t GC_CALL GC_get_prof_stats_unsafe(
struct GC_prof_stats_s*pstats,
size_t stats_sz)
{
struct GC_prof_stats_s stats;
if (stats_sz>=sizeof(stats)){
fill_prof_stats(pstats);
if (stats_sz > sizeof(stats))
memset((char*)pstats+sizeof(stats),0xff,
stats_sz - sizeof(stats));
return sizeof(stats);
} else {
if (EXPECT(stats_sz > 0,TRUE)){
fill_prof_stats(&stats);
BCOPY(&stats,pstats,stats_sz);
}
return stats_sz;
}
}
#endif
#endif
#if defined(GC_DARWIN_THREADS)||defined(GC_OPENBSD_UTHREADS)||defined(GC_WIN32_THREADS)||(defined(NACL)&&defined(THREADS))
GC_API void GC_CALL GC_set_suspend_signal(int sig GC_ATTR_UNUSED)
{
}
GC_API void GC_CALL GC_set_thr_restart_signal(int sig GC_ATTR_UNUSED)
{
}
GC_API int GC_CALL GC_get_suspend_signal(void)
{
return -1;
}
GC_API int GC_CALL GC_get_thr_restart_signal(void)
{
return -1;
}
#endif
#if!defined(_MAX_PATH)&&(defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32))
#define _MAX_PATH MAX_PATH
#endif
#ifdef GC_READ_ENV_FILE
STATIC char*GC_envfile_content=NULL;
STATIC unsigned GC_envfile_length=0;
#ifndef GC_ENVFILE_MAXLEN
#define GC_ENVFILE_MAXLEN 0x4000
#endif
#define GC_ENV_FILE_EXT ".gc.env"
STATIC void GC_envfile_init(void)
{
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)
HANDLE hFile;
char*content;
unsigned ofs;
unsigned len;
DWORD nBytesRead;
TCHAR path[_MAX_PATH+0x10];
len=(unsigned)GetModuleFileName(NULL,path,
_MAX_PATH+1);
if (len > 4&&path[len - 4]==(TCHAR)'.'){
len-=4;
}
BCOPY(TEXT(GC_ENV_FILE_EXT),&path[len],sizeof(TEXT(GC_ENV_FILE_EXT)));
hFile=CreateFile(path,GENERIC_READ,
FILE_SHARE_READ|FILE_SHARE_WRITE,
NULL,OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,NULL);
if (hFile==INVALID_HANDLE_VALUE)
return;
len=(unsigned)GetFileSize(hFile,NULL);
if (len<=1||len>=GC_ENVFILE_MAXLEN){
CloseHandle(hFile);
return;
}
GC_ASSERT(GC_page_size!=0);
content=(char*)GET_MEM(ROUNDUP_PAGESIZE_IF_MMAP((size_t)len+1));
if (content==NULL){
CloseHandle(hFile);
return;
}
ofs=0;
nBytesRead=(DWORD)-1L;
while (ReadFile(hFile,content+ofs,len - ofs+1,&nBytesRead,
NULL)&&nBytesRead!=0){
if ((ofs+=nBytesRead)> len)
break;
}
CloseHandle(hFile);
if (ofs!=len||nBytesRead!=0)
return;
content[ofs]='\0';
while (ofs--> 0){
if (content[ofs]=='\r'||content[ofs]=='\n')
content[ofs]='\0';
}
GC_ASSERT(NULL==GC_envfile_content);
GC_envfile_length=len+1;
GC_envfile_content=content;
#endif
}
GC_INNER char*GC_envfile_getenv(const char*name)
{
char*p;
char*end_of_content;
unsigned namelen;
#ifndef NO_GETENV
p=getenv(name);
if (p!=NULL)
return*p!='\0'?p:NULL;
#endif
p=GC_envfile_content;
if (p==NULL)
return NULL;
namelen=strlen(name);
if (namelen==0)
return NULL;
for (end_of_content=p+GC_envfile_length;
p!=end_of_content;p+=strlen(p)+1){
if (strncmp(p,name,namelen)==0&&*(p+=namelen)=='='){
p++;
return*p!='\0'?p:NULL;
}
}
return NULL;
}
#endif
GC_INNER GC_bool GC_is_initialized=FALSE;
GC_API int GC_CALL GC_is_init_called(void)
{
return GC_is_initialized;
}
#if defined(GC_WIN32_THREADS)&&((defined(MSWIN32)&&!defined(CONSOLE_LOG))||defined(MSWINCE))
GC_INNER CRITICAL_SECTION GC_write_cs;
#endif
#ifndef DONT_USE_ATEXIT
#if!defined(PCR)&&!defined(SMALL_CONFIG)
static GC_bool skip_gc_atexit=FALSE;
#else
#define skip_gc_atexit FALSE
#endif
STATIC void GC_exit_check(void)
{
if (GC_find_leak&&!skip_gc_atexit){
#ifdef THREADS
GC_in_thread_creation=TRUE;
GC_gcollect();
GC_in_thread_creation=FALSE;
#else
GC_gcollect();
#endif
}
}
#endif
#if defined(UNIX_LIKE)&&!defined(NO_DEBUGGING)
static void looping_handler(int sig)
{
GC_err_printf("Caught signal %d:looping in handler\n",sig);
for (;;){
}
}
static GC_bool installed_looping_handler=FALSE;
static void maybe_install_looping_handler(void)
{
if (!installed_looping_handler&&0!=GETENV("GC_LOOP_ON_ABORT")){
GC_set_and_save_fault_handler(looping_handler);
installed_looping_handler=TRUE;
}
}
#else
#define maybe_install_looping_handler()
#endif
#define GC_DEFAULT_STDOUT_FD 1
#define GC_DEFAULT_STDERR_FD 2
#if!defined(OS2)&&!defined(MACOS)&&!defined(GC_ANDROID_LOG)&&!defined(NN_PLATFORM_CTR)&&!defined(NINTENDO_SWITCH)&&(!defined(MSWIN32)||defined(CONSOLE_LOG))&&!defined(MSWINCE)
STATIC int GC_stdout=GC_DEFAULT_STDOUT_FD;
STATIC int GC_stderr=GC_DEFAULT_STDERR_FD;
STATIC int GC_log=GC_DEFAULT_STDERR_FD;
#ifndef MSWIN32
GC_API void GC_CALL GC_set_log_fd(int fd)
{
GC_log=fd;
}
#endif
#endif
#ifdef MSGBOX_ON_ERROR
STATIC void GC_win32_MessageBoxA(const char*msg,const char*caption,
unsigned flags)
{
#ifndef DONT_USE_USER32_DLL
(void)MessageBoxA(NULL,msg,caption,flags);
#else
HINSTANCE hU32=LoadLibrary(TEXT("user32.dll"));
if (hU32){
FARPROC pfn=GetProcAddress(hU32,"MessageBoxA");
if (pfn)
(void)(*(int (WINAPI*)(HWND,LPCSTR,LPCSTR,UINT))(word)pfn)(
NULL,msg,caption,flags);
(void)FreeLibrary(hU32);
}
#endif
}
#endif
#if defined(THREADS)&&defined(UNIX_LIKE)&&!defined(NO_GETCONTEXT)
static void callee_saves_pushed_dummy_fn(ptr_t data GC_ATTR_UNUSED,
void*context GC_ATTR_UNUSED){}
#endif
#ifndef SMALL_CONFIG
#ifdef MANUAL_VDB
static GC_bool manual_vdb_allowed=TRUE;
#else
static GC_bool manual_vdb_allowed=FALSE;
#endif
GC_API void GC_CALL GC_set_manual_vdb_allowed(int value)
{
manual_vdb_allowed=(GC_bool)value;
}
GC_API int GC_CALL GC_get_manual_vdb_allowed(void)
{
return (int)manual_vdb_allowed;
}
#endif
STATIC word GC_parse_mem_size_arg(const char*str)
{
word result=0;
if (*str!='\0'){
char*endptr;
char ch;
result=(word)STRTOULL(str,&endptr,10);
ch=*endptr;
if (ch!='\0'){
if (*(endptr+1)!='\0')
return 0;
switch (ch){
case 'K':
case 'k':
result<<=10;
break;
case 'M':
case 'm':
result<<=20;
break;
case 'G':
case 'g':
result<<=30;
break;
default:
result=0;
}
}
}
return result;
}
#define GC_LOG_STD_NAME "gc.log"
GC_API void GC_CALL GC_init(void)
{
word initial_heap_sz;
IF_CANCEL(int cancel_state;)
#if defined(GC_ASSERTIONS)&&defined(GC_ALWAYS_MULTITHREADED)
DCL_LOCK_STATE;
#endif
if (EXPECT(GC_is_initialized,TRUE))return;
#ifdef REDIRECT_MALLOC
{
static GC_bool init_started=FALSE;
if (init_started)
ABORT("Redirected malloc()called during GC init");
init_started=TRUE;
}
#endif
#if defined(GC_INITIAL_HEAP_SIZE)&&!defined(CPPCHECK)
initial_heap_sz=GC_INITIAL_HEAP_SIZE;
#else
initial_heap_sz=MINHINCR*HBLKSIZE;
#endif
DISABLE_CANCEL(cancel_state);
#ifdef THREADS
#ifndef GC_ALWAYS_MULTITHREADED
GC_ASSERT(!GC_need_to_lock);
#endif
#ifdef SN_TARGET_PS3
{
pthread_mutexattr_t mattr;
if (0!=pthread_mutexattr_init(&mattr)){
ABORT("pthread_mutexattr_init failed");
}
if (0!=pthread_mutex_init(&GC_allocate_ml,&mattr)){
ABORT("pthread_mutex_init failed");
}
(void)pthread_mutexattr_destroy(&mattr);
}
#endif
#endif
#if defined(GC_WIN32_THREADS)&&!defined(GC_PTHREADS)
#ifndef SPIN_COUNT
#define SPIN_COUNT 4000
#endif
#ifdef MSWINRT_FLAVOR
InitializeCriticalSectionAndSpinCount(&GC_allocate_ml,SPIN_COUNT);
#else
{
#ifndef MSWINCE
FARPROC pfn=0;
HMODULE hK32=GetModuleHandle(TEXT("kernel32.dll"));
if (hK32)
pfn=GetProcAddress(hK32,
"InitializeCriticalSectionAndSpinCount");
if (pfn){
(*(BOOL (WINAPI*)(LPCRITICAL_SECTION,DWORD))(word)pfn)(
&GC_allocate_ml,SPIN_COUNT);
} else
#endif
InitializeCriticalSection(&GC_allocate_ml);
}
#endif
#endif
#if defined(GC_WIN32_THREADS)&&((defined(MSWIN32)&&!defined(CONSOLE_LOG))||defined(MSWINCE))
InitializeCriticalSection(&GC_write_cs);
#endif
GC_setpagesize();
#ifdef MSWIN32
GC_init_win32();
#endif
#ifdef GC_READ_ENV_FILE
GC_envfile_init();
#endif
#if!defined(NO_CLOCK)||!defined(SMALL_CONFIG)
#ifdef GC_PRINT_VERBOSE_STATS
GC_print_stats=VERBOSE;
#else
if (0!=GETENV("GC_PRINT_VERBOSE_STATS")){
GC_print_stats=VERBOSE;
} else if (0!=GETENV("GC_PRINT_STATS")){
GC_print_stats=1;
}
#endif
#endif
#if ((defined(UNIX_LIKE)&&!defined(GC_ANDROID_LOG))||(defined(CONSOLE_LOG)&&defined(MSWIN32))||defined(CYGWIN32)||defined(SYMBIAN))&&!defined(SMALL_CONFIG)
{
char*file_name=TRUSTED_STRING(GETENV("GC_LOG_FILE"));
#ifdef GC_LOG_TO_FILE_ALWAYS
if (NULL==file_name)
file_name=GC_LOG_STD_NAME;
#else
if (0!=file_name)
#endif
{
#if defined(_MSC_VER)
int log_d=_open(file_name,O_CREAT|O_WRONLY|O_APPEND);
#else
int log_d=open(file_name,O_CREAT|O_WRONLY|O_APPEND,0644);
#endif
if (log_d < 0){
GC_err_printf("Failed to open %s as log file\n",file_name);
} else {
char*str;
GC_log=log_d;
str=GETENV("GC_ONLY_LOG_TO_FILE");
#ifdef GC_ONLY_LOG_TO_FILE
if (str!=NULL&&*str=='0'&&*(str+1)=='\0')
#else
if (str==NULL||(*str=='0'&&*(str+1)=='\0'))
#endif
{
GC_stdout=log_d;
GC_stderr=log_d;
}
}
}
}
#endif
#if!defined(NO_DEBUGGING)&&!defined(GC_DUMP_REGULARLY)
if (0!=GETENV("GC_DUMP_REGULARLY")){
GC_dump_regularly=TRUE;
}
#endif
#ifdef KEEP_BACK_PTRS
{
char*backtraces_string=GETENV("GC_BACKTRACES");
if (0!=backtraces_string){
GC_backtraces=atol(backtraces_string);
if (backtraces_string[0]=='\0')GC_backtraces=1;
}
}
#endif
if (0!=GETENV("GC_FIND_LEAK")){
GC_find_leak=1;
}
#ifndef SHORT_DBG_HDRS
if (0!=GETENV("GC_FINDLEAK_DELAY_FREE")){
GC_findleak_delay_free=TRUE;
}
#endif
if (0!=GETENV("GC_ALL_INTERIOR_POINTERS")){
GC_all_interior_pointers=1;
}
if (0!=GETENV("GC_DONT_GC")){
GC_dont_gc=1;
}
if (0!=GETENV("GC_PRINT_BACK_HEIGHT")){
GC_print_back_height=TRUE;
}
if (0!=GETENV("GC_NO_BLACKLIST_WARNING")){
GC_large_alloc_warn_interval=LONG_MAX;
}
{
char*addr_string=GETENV("GC_TRACE");
if (0!=addr_string){
#ifndef ENABLE_TRACE
WARN("Tracing not enabled:Ignoring GC_TRACE value\n",0);
#else
word addr=(word)STRTOULL(addr_string,NULL,16);
if (addr < 0x1000)
WARN("Unlikely trace address:%p\n",(void*)addr);
GC_trace_addr=(ptr_t)addr;
#endif
}
}
#ifdef GC_COLLECT_AT_MALLOC
{
char*string=GETENV("GC_COLLECT_AT_MALLOC");
if (0!=string){
size_t min_lb=(size_t)STRTOULL(string,NULL,10);
if (min_lb > 0)
GC_dbg_collect_at_malloc_min_lb=min_lb;
}
}
#endif
#if!defined(GC_DISABLE_INCREMENTAL)&&!defined(NO_CLOCK)
{
char*time_limit_string=GETENV("GC_PAUSE_TIME_TARGET");
if (0!=time_limit_string){
long time_limit=atol(time_limit_string);
if (time_limit > 0){
GC_time_limit=time_limit;
}
}
}
#endif
#ifndef SMALL_CONFIG
{
char*full_freq_string=GETENV("GC_FULL_FREQUENCY");
if (full_freq_string!=NULL){
int full_freq=atoi(full_freq_string);
if (full_freq > 0)
GC_full_freq=full_freq;
}
}
#endif
{
char*interval_string=GETENV("GC_LARGE_ALLOC_WARN_INTERVAL");
if (0!=interval_string){
long interval=atol(interval_string);
if (interval<=0){
WARN("GC_LARGE_ALLOC_WARN_INTERVAL environment variable has "
"bad value:Ignoring\n",0);
} else {
GC_large_alloc_warn_interval=interval;
}
}
}
{
char*space_divisor_string=GETENV("GC_FREE_SPACE_DIVISOR");
if (space_divisor_string!=NULL){
int space_divisor=atoi(space_divisor_string);
if (space_divisor > 0)
GC_free_space_divisor=(unsigned)space_divisor;
}
}
#ifdef USE_MUNMAP
{
char*string=GETENV("GC_UNMAP_THRESHOLD");
if (string!=NULL){
if (*string=='0'&&*(string+1)=='\0'){
GC_unmap_threshold=0;
} else {
int unmap_threshold=atoi(string);
if (unmap_threshold > 0)
GC_unmap_threshold=unmap_threshold;
}
}
}
{
char*string=GETENV("GC_FORCE_UNMAP_ON_GCOLLECT");
if (string!=NULL){
if (*string=='0'&&*(string+1)=='\0'){
GC_force_unmap_on_gcollect=FALSE;
} else {
GC_force_unmap_on_gcollect=TRUE;
}
}
}
{
char*string=GETENV("GC_USE_ENTIRE_HEAP");
if (string!=NULL){
if (*string=='0'&&*(string+1)=='\0'){
GC_use_entire_heap=FALSE;
} else {
GC_use_entire_heap=TRUE;
}
}
}
#endif
#if!defined(NO_DEBUGGING)&&!defined(NO_CLOCK)
GET_TIME(GC_init_time);
#endif
maybe_install_looping_handler();
#if ALIGNMENT > GC_DS_TAGS
if (EXTRA_BYTES!=0)
GC_obj_kinds[NORMAL].ok_descriptor=(word)(-ALIGNMENT)|GC_DS_LENGTH;
#endif
GC_exclude_static_roots_inner(beginGC_arrays,endGC_arrays);
GC_exclude_static_roots_inner(beginGC_obj_kinds,endGC_obj_kinds);
#ifdef SEPARATE_GLOBALS
GC_exclude_static_roots_inner(beginGC_objfreelist,endGC_objfreelist);
GC_exclude_static_roots_inner(beginGC_aobjfreelist,endGC_aobjfreelist);
#endif
#if defined(USE_PROC_FOR_LIBRARIES)&&defined(GC_LINUX_THREADS)
WARN("USE_PROC_FOR_LIBRARIES+GC_LINUX_THREADS performs poorly.\n",0);
#endif
#if defined(SEARCH_FOR_DATA_START)
GC_init_linux_data_start();
#endif
#if defined(NETBSD)&&defined(__ELF__)
GC_init_netbsd_elf();
#endif
#if!defined(THREADS)||defined(GC_PTHREADS)||defined(NN_PLATFORM_CTR)||defined(NINTENDO_SWITCH)||defined(GC_WIN32_THREADS)||defined(GC_SOLARIS_THREADS)
if (GC_stackbottom==0){
GC_stackbottom=GC_get_main_stack_base();
#if (defined(LINUX)||defined(HPUX))&&defined(IA64)
GC_register_stackbottom=GC_get_register_stack_base();
#endif
} else {
#if (defined(LINUX)||defined(HPUX))&&defined(IA64)
if (GC_register_stackbottom==0){
WARN("GC_register_stackbottom should be set with GC_stackbottom\n",0);
GC_register_stackbottom=GC_get_register_stack_base();
}
#endif
}
#endif
#if!defined(CPPCHECK)
GC_STATIC_ASSERT(sizeof(ptr_t)==sizeof(word));
GC_STATIC_ASSERT(sizeof(signed_word)==sizeof(word));
#if!defined(_AUX_SOURCE)||defined(__GNUC__)
GC_STATIC_ASSERT((word)(-1)> (word)0);
#endif
GC_STATIC_ASSERT((signed_word)(-1)< (signed_word)0);
#endif
GC_STATIC_ASSERT(sizeof (struct hblk)==HBLKSIZE);
#ifndef THREADS
GC_ASSERT(!((word)GC_stackbottom HOTTER_THAN (word)GC_approx_sp()));
#endif
#ifndef GC_DISABLE_INCREMENTAL
if (GC_incremental||0!=GETENV("GC_ENABLE_INCREMENTAL")){
#if defined(BASE_ATOMIC_OPS_EMULATED)||defined(CHECKSUMS)||defined(REDIRECT_MALLOC)||defined(REDIRECT_MALLOC_IN_HEADER)||defined(SMALL_CONFIG)
#else
if (manual_vdb_allowed){
GC_manual_vdb=TRUE;
GC_incremental=TRUE;
} else
#endif
{
GC_incremental=GC_dirty_init();
GC_ASSERT(GC_bytes_allocd==0);
}
}
#endif
if (GC_REGISTER_MAIN_STATIC_DATA())GC_register_data_segments();
GC_init_headers();
GC_bl_init();
GC_mark_init();
{
char*sz_str=GETENV("GC_INITIAL_HEAP_SIZE");
if (sz_str!=NULL){
initial_heap_sz=GC_parse_mem_size_arg(sz_str);
if (initial_heap_sz<=MINHINCR*HBLKSIZE){
WARN("Bad initial heap size %s - ignoring it.\n",sz_str);
}
}
}
{
char*sz_str=GETENV("GC_MAXIMUM_HEAP_SIZE");
if (sz_str!=NULL){
word max_heap_sz=GC_parse_mem_size_arg(sz_str);
if (max_heap_sz < initial_heap_sz){
WARN("Bad maximum heap size %s - ignoring it.\n",sz_str);
}
if (0==GC_max_retries)GC_max_retries=2;
GC_set_max_heap_size(max_heap_sz);
}
}
#if defined(GC_ASSERTIONS)&&defined(GC_ALWAYS_MULTITHREADED)
LOCK();
#endif
if (!GC_expand_hp_inner(divHBLKSZ(initial_heap_sz))){
GC_err_printf("Can't start up:not enough memory\n");
EXIT();
} else {
GC_requested_heapsize+=initial_heap_sz;
}
if (GC_all_interior_pointers)
GC_initialize_offsets();
GC_register_displacement_inner(0L);
#if defined(GC_LINUX_THREADS)&&defined(REDIRECT_MALLOC)
if (!GC_all_interior_pointers){
GC_register_displacement_inner(sizeof(void*));
}
#endif
GC_init_size_map();
#ifdef PCR
if (PCR_IL_Lock(PCR_Bool_false,PCR_allSigsBlocked,PCR_waitForever)
!=PCR_ERes_okay){
ABORT("Can't lock load state");
} else if (PCR_IL_Unlock()!=PCR_ERes_okay){
ABORT("Can't unlock load state");
}
PCR_IL_Unlock();
GC_pcr_install();
#endif
GC_is_initialized=TRUE;
#if defined(GC_PTHREADS)||defined(GC_WIN32_THREADS)
GC_thr_init();
#ifdef PARALLEL_MARK
#if defined(GC_ASSERTIONS)&&defined(GC_ALWAYS_MULTITHREADED)
UNLOCK();
#endif
GC_start_mark_threads_inner();
#if defined(GC_ASSERTIONS)&&defined(GC_ALWAYS_MULTITHREADED)
LOCK();
#endif
#endif
#endif
COND_DUMP;
if (!GC_dont_precollect||GC_incremental){
GC_gcollect_inner();
}
#if defined(GC_ASSERTIONS)&&defined(GC_ALWAYS_MULTITHREADED)
UNLOCK();
#endif
#if defined(THREADS)&&defined(UNIX_LIKE)&&!defined(NO_GETCONTEXT)
if (GC_dont_gc||GC_dont_precollect)
GC_with_callee_saves_pushed(callee_saves_pushed_dummy_fn,NULL);
#endif
#ifndef DONT_USE_ATEXIT
if (GC_find_leak){
atexit(GC_exit_check);
}
#endif
#if defined(PARALLEL_MARK)||defined(THREAD_LOCAL_ALLOC)||(defined(GC_ALWAYS_MULTITHREADED)&&defined(GC_WIN32_THREADS)&&!defined(GC_NO_THREADS_DISCOVERY))
GC_init_parallel();
#endif
#if defined(DYNAMIC_LOADING)&&defined(DARWIN)
GC_init_dyld();
#endif
RESTORE_CANCEL(cancel_state);
}
GC_API void GC_CALL GC_enable_incremental(void)
{
#if!defined(GC_DISABLE_INCREMENTAL)&&!defined(KEEP_BACK_PTRS)
DCL_LOCK_STATE;
if (!GC_find_leak&&0==GETENV("GC_DISABLE_INCREMENTAL")){
LOCK();
if (!GC_incremental){
GC_setpagesize();
maybe_install_looping_handler();
if (!GC_is_initialized){
UNLOCK();
GC_incremental=TRUE;
GC_init();
LOCK();
} else {
#if!defined(BASE_ATOMIC_OPS_EMULATED)&&!defined(CHECKSUMS)&&!defined(REDIRECT_MALLOC)&&!defined(REDIRECT_MALLOC_IN_HEADER)&&!defined(SMALL_CONFIG)
if (manual_vdb_allowed){
GC_manual_vdb=TRUE;
GC_incremental=TRUE;
} else
#endif
{
GC_incremental=GC_dirty_init();
}
}
if (GC_incremental&&!GC_dont_gc){
IF_CANCEL(int cancel_state;)
DISABLE_CANCEL(cancel_state);
if (GC_bytes_allocd > 0){
GC_gcollect_inner();
}
GC_read_dirty(FALSE);
RESTORE_CANCEL(cancel_state);
}
}
UNLOCK();
return;
}
#endif
GC_init();
}
#if defined(THREADS)
GC_API void GC_CALL GC_start_mark_threads(void)
{
#if defined(PARALLEL_MARK)&&defined(CAN_HANDLE_FORK)&&!defined(THREAD_SANITIZER)
IF_CANCEL(int cancel_state;)
DISABLE_CANCEL(cancel_state);
GC_start_mark_threads_inner();
RESTORE_CANCEL(cancel_state);
#else
GC_ASSERT(I_DONT_HOLD_LOCK());
#endif
}
#endif
GC_API void GC_CALL GC_deinit(void)
{
if (GC_is_initialized){
GC_is_initialized=FALSE;
#if defined(GC_WIN32_THREADS)&&(defined(MSWIN32)||defined(MSWINCE))
#if!defined(CONSOLE_LOG)||defined(MSWINCE)
DeleteCriticalSection(&GC_write_cs);
#endif
DeleteCriticalSection(&GC_allocate_ml);
#endif
}
}
#if (defined(MSWIN32)&&!defined(CONSOLE_LOG))||defined(MSWINCE)
#if defined(_MSC_VER)&&defined(_DEBUG)&&!defined(MSWINCE)
#include <crtdbg.h>
#endif
STATIC HANDLE GC_log=0;
#ifdef THREADS
#if defined(PARALLEL_MARK)&&!defined(GC_ALWAYS_MULTITHREADED)
#define IF_NEED_TO_LOCK(x)if (GC_parallel||GC_need_to_lock)x
#else
#define IF_NEED_TO_LOCK(x)if (GC_need_to_lock)x
#endif
#else
#define IF_NEED_TO_LOCK(x)
#endif
#ifdef MSWINRT_FLAVOR
#include <windows.storage.h>
DECLSPEC_IMPORT HRESULT WINAPI RoGetActivationFactory(
HSTRING activatableClassId,
REFIID iid,void**factory);
static GC_bool getWinRTLogPath(wchar_t*buf,size_t bufLen)
{
static const GUID kIID_IApplicationDataStatics={
0x5612147B,0xE843,0x45E3,
0x94,0xD8,0x06,0x16,0x9E,0x3C,0x8E,0x17
};
static const GUID kIID_IStorageItem={
0x4207A996,0xCA2F,0x42F7,
0xBD,0xE8,0x8B,0x10,0x45,0x7A,0x7F,0x30
};
GC_bool result=FALSE;
HSTRING_HEADER appDataClassNameHeader;
HSTRING appDataClassName;
__x_ABI_CWindows_CStorage_CIApplicationDataStatics*appDataStatics=0;
GC_ASSERT(bufLen > 0);
if (SUCCEEDED(WindowsCreateStringReference(
RuntimeClass_Windows_Storage_ApplicationData,
(sizeof(RuntimeClass_Windows_Storage_ApplicationData)-1)
/sizeof(wchar_t),
&appDataClassNameHeader,&appDataClassName))
&&SUCCEEDED(RoGetActivationFactory(appDataClassName,
&kIID_IApplicationDataStatics,
&appDataStatics))){
__x_ABI_CWindows_CStorage_CIApplicationData*appData=NULL;
__x_ABI_CWindows_CStorage_CIStorageFolder*tempFolder=NULL;
__x_ABI_CWindows_CStorage_CIStorageItem*tempFolderItem=NULL;
HSTRING tempPath=NULL;
if (SUCCEEDED(appDataStatics->lpVtbl->get_Current(appDataStatics,
&appData))
&&SUCCEEDED(appData->lpVtbl->get_TemporaryFolder(appData,
&tempFolder))
&&SUCCEEDED(tempFolder->lpVtbl->QueryInterface(tempFolder,
&kIID_IStorageItem,
&tempFolderItem))
&&SUCCEEDED(tempFolderItem->lpVtbl->get_Path(tempFolderItem,
&tempPath))){
UINT32 tempPathLen;
const wchar_t*tempPathBuf=
WindowsGetStringRawBuffer(tempPath,&tempPathLen);
buf[0]='\0';
if (wcsncat_s(buf,bufLen,tempPathBuf,tempPathLen)==0
&&wcscat_s(buf,bufLen,L"\\")==0
&&wcscat_s(buf,bufLen,TEXT(GC_LOG_STD_NAME))==0)
result=TRUE;
WindowsDeleteString(tempPath);
}
if (tempFolderItem!=NULL)
tempFolderItem->lpVtbl->Release(tempFolderItem);
if (tempFolder!=NULL)
tempFolder->lpVtbl->Release(tempFolder);
if (appData!=NULL)
appData->lpVtbl->Release(appData);
appDataStatics->lpVtbl->Release(appDataStatics);
}
return result;
}
#endif
STATIC HANDLE GC_CreateLogFile(void)
{
HANDLE hFile;
#ifdef MSWINRT_FLAVOR
TCHAR pathBuf[_MAX_PATH+0x10];
hFile=INVALID_HANDLE_VALUE;
if (getWinRTLogPath(pathBuf,_MAX_PATH+1)){
CREATEFILE2_EXTENDED_PARAMETERS extParams;
BZERO(&extParams,sizeof(extParams));
extParams.dwSize=sizeof(extParams);
extParams.dwFileAttributes=FILE_ATTRIBUTE_NORMAL;
extParams.dwFileFlags=GC_print_stats==VERBOSE?0
:FILE_FLAG_WRITE_THROUGH;
hFile=CreateFile2(pathBuf,GENERIC_WRITE,FILE_SHARE_READ,
CREATE_ALWAYS,&extParams);
}
#else
TCHAR*logPath;
#if defined(NO_GETENV_WIN32)&&defined(CPPCHECK)
#define appendToFile FALSE
#else
BOOL appendToFile=FALSE;
#endif
#if!defined(NO_GETENV_WIN32)||!defined(OLD_WIN32_LOG_FILE)
TCHAR pathBuf[_MAX_PATH+0x10];
logPath=pathBuf;
#endif
#ifndef NO_GETENV_WIN32
if (GetEnvironmentVariable(TEXT("GC_LOG_FILE"),pathBuf,
_MAX_PATH+1)- 1U < (DWORD)_MAX_PATH){
appendToFile=TRUE;
} else
#endif
{
#ifdef OLD_WIN32_LOG_FILE
logPath=TEXT(GC_LOG_STD_NAME);
#else
int len=(int)GetModuleFileName(NULL,pathBuf,
_MAX_PATH+1);
if (len > 4&&pathBuf[len - 4]==(TCHAR)'.'){
len-=4;
}
BCOPY(TEXT(".")TEXT(GC_LOG_STD_NAME),&pathBuf[len],
sizeof(TEXT(".")TEXT(GC_LOG_STD_NAME)));
#endif
}
hFile=CreateFile(logPath,GENERIC_WRITE,FILE_SHARE_READ,
NULL,
appendToFile?OPEN_ALWAYS:CREATE_ALWAYS,
GC_print_stats==VERBOSE?FILE_ATTRIBUTE_NORMAL:
FILE_ATTRIBUTE_NORMAL|FILE_FLAG_WRITE_THROUGH,
NULL);
#ifndef NO_GETENV_WIN32
if (appendToFile&&hFile!=INVALID_HANDLE_VALUE){
LONG posHigh=0;
(void)SetFilePointer(hFile,0,&posHigh,FILE_END);
}
#endif
#undef appendToFile
#endif
return hFile;
}
STATIC int GC_write(const char*buf,size_t len)
{
BOOL res;
DWORD written;
#if defined(THREADS)&&defined(GC_ASSERTIONS)
static GC_bool inside_write=FALSE;
if (inside_write)
return -1;
#endif
if (len==0)
return 0;
IF_NEED_TO_LOCK(EnterCriticalSection(&GC_write_cs));
#if defined(THREADS)&&defined(GC_ASSERTIONS)
if (GC_write_disabled){
inside_write=TRUE;
ABORT("Assertion failure:GC_write called with write_disabled");
}
#endif
if (GC_log==0){
GC_log=GC_CreateLogFile();
}
if (GC_log==INVALID_HANDLE_VALUE){
IF_NEED_TO_LOCK(LeaveCriticalSection(&GC_write_cs));
#ifdef NO_DEBUGGING
return 0;
#else
return -1;
#endif
}
res=WriteFile(GC_log,buf,(DWORD)len,&written,NULL);
#if defined(_MSC_VER)&&defined(_DEBUG)&&!defined(NO_CRT)
#ifdef MSWINCE
{
WCHAR wbuf[1024];
wbuf[MultiByteToWideChar(CP_ACP,0,
buf,len,wbuf,
sizeof(wbuf)/sizeof(wbuf[0])- 1)]=0;
OutputDebugStringW(wbuf);
}
#else
_CrtDbgReport(_CRT_WARN,NULL,0,NULL,"%.*s",len,buf);
#endif
#endif
IF_NEED_TO_LOCK(LeaveCriticalSection(&GC_write_cs));
return res?(int)written:-1;
}
#define WRITE(f,buf,len)GC_write(buf,len)
#elif defined(OS2)||defined(MACOS)
STATIC FILE*GC_stdout=NULL;
STATIC FILE*GC_stderr=NULL;
STATIC FILE*GC_log=NULL;
STATIC void GC_set_files(void)
{
if (GC_stdout==NULL){
GC_stdout=stdout;
}
if (GC_stderr==NULL){
GC_stderr=stderr;
}
if (GC_log==NULL){
GC_log=stderr;
}
}
GC_INLINE int GC_write(FILE*f,const char*buf,size_t len)
{
int res=fwrite(buf,1,len,f);
fflush(f);
return res;
}
#define WRITE(f,buf,len)(GC_set_files(),GC_write(f,buf,len))
#elif defined(GC_ANDROID_LOG)
#include <android/log.h>
#ifndef GC_ANDROID_LOG_TAG
#define GC_ANDROID_LOG_TAG "BDWGC"
#endif
#define GC_stdout ANDROID_LOG_DEBUG
#define GC_stderr ANDROID_LOG_ERROR
#define GC_log GC_stdout
#define WRITE(level,buf,unused_len)__android_log_write(level,GC_ANDROID_LOG_TAG,buf)
#elif defined(NN_PLATFORM_CTR)
int n3ds_log_write(const char*text,int length);
#define WRITE(level,buf,len)n3ds_log_write(buf,len)
#elif defined(NINTENDO_SWITCH)
int switch_log_write(const char*text,int length);
#define WRITE(level,buf,len)switch_log_write(buf,len)
#else
#if!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)
#if!defined(AMIGA)&&!defined(MSWIN32)&&!defined(MSWIN_XBOX1)&&!defined(__CC_ARM)
#include <unistd.h>
#endif
#if!defined(ECOS)&&!defined(NOSYS)
#include <errno.h>
#endif
#endif
STATIC int GC_write(int fd,const char*buf,size_t len)
{
#if defined(ECOS)||defined(SN_TARGET_ORBIS)||defined(SN_TARGET_PSP2)||defined(NOSYS)
#ifdef ECOS
#else
#endif
return len;
#else
int bytes_written=0;
IF_CANCEL(int cancel_state;)
DISABLE_CANCEL(cancel_state);
while ((unsigned)bytes_written < len){
#ifdef GC_SOLARIS_THREADS
int result=syscall(SYS_write,fd,buf+bytes_written,
len - bytes_written);
#elif defined(_MSC_VER)
int result=_write(fd,buf+bytes_written,
(unsigned)(len - bytes_written));
#else
int result=write(fd,buf+bytes_written,len - bytes_written);
#endif
if (-1==result){
if (EAGAIN==errno)
continue;
RESTORE_CANCEL(cancel_state);
return(result);
}
bytes_written+=result;
}
RESTORE_CANCEL(cancel_state);
return(bytes_written);
#endif
}
#define WRITE(f,buf,len)GC_write(f,buf,len)
#endif
#define BUFSZ 1024
#if defined(DJGPP)||defined(__STRICT_ANSI__)
#define GC_VSNPRINTF(buf,bufsz,format,args)vsprintf(buf,format,args)
#elif defined(_MSC_VER)
#ifdef MSWINCE
#define GC_VSNPRINTF StringCchVPrintfA
#else
#define GC_VSNPRINTF _vsnprintf
#endif
#else
#define GC_VSNPRINTF vsnprintf
#endif
#define GC_PRINTF_FILLBUF(buf,format)do { va_list args;va_start(args,format);(buf)[sizeof(buf)- 1]=0x15;(void)GC_VSNPRINTF(buf,sizeof(buf)- 1,format,args);va_end(args);if ((buf)[sizeof(buf)- 1]!=0x15)ABORT("GC_printf clobbered stack");} while (0)
void GC_printf(const char*format,...)
{
if (!GC_quiet){
char buf[BUFSZ+1];
GC_PRINTF_FILLBUF(buf,format);
#ifdef NACL
(void)WRITE(GC_stdout,buf,strlen(buf));
#else
if (WRITE(GC_stdout,buf,strlen(buf))< 0
#if defined(CYGWIN32)||(defined(CONSOLE_LOG)&&defined(MSWIN32))
&&GC_stdout!=GC_DEFAULT_STDOUT_FD
#endif
){
ABORT("write to stdout failed");
}
#endif
}
}
void GC_err_printf(const char*format,...)
{
char buf[BUFSZ+1];
GC_PRINTF_FILLBUF(buf,format);
GC_err_puts(buf);
}
void GC_log_printf(const char*format,...)
{
char buf[BUFSZ+1];
GC_PRINTF_FILLBUF(buf,format);
#ifdef NACL
(void)WRITE(GC_log,buf,strlen(buf));
#else
if (WRITE(GC_log,buf,strlen(buf))< 0
#if defined(CYGWIN32)||(defined(CONSOLE_LOG)&&defined(MSWIN32))
&&GC_log!=GC_DEFAULT_STDERR_FD
#endif
){
ABORT("write to GC log failed");
}
#endif
}
#ifndef GC_ANDROID_LOG
#define GC_warn_printf GC_err_printf
#else
GC_INNER void GC_info_log_printf(const char*format,...)
{
char buf[BUFSZ+1];
GC_PRINTF_FILLBUF(buf,format);
(void)WRITE(ANDROID_LOG_INFO,buf,0);
}
GC_INNER void GC_verbose_log_printf(const char*format,...)
{
char buf[BUFSZ+1];
GC_PRINTF_FILLBUF(buf,format);
(void)WRITE(ANDROID_LOG_VERBOSE,buf,0);
}
STATIC void GC_warn_printf(const char*format,...)
{
char buf[BUFSZ+1];
GC_PRINTF_FILLBUF(buf,format);
(void)WRITE(ANDROID_LOG_WARN,buf,0);
}
#endif
void GC_err_puts(const char*s)
{
(void)WRITE(GC_stderr,s,strlen(s));
}
STATIC void GC_CALLBACK GC_default_warn_proc(char*msg,GC_word arg)
{
GC_warn_printf(msg,arg);
}
GC_INNER GC_warn_proc GC_current_warn_proc=GC_default_warn_proc;
GC_API void GC_CALLBACK GC_ignore_warn_proc(char*msg,GC_word arg)
{
if (GC_print_stats){
GC_default_warn_proc(msg,arg);
}
}
GC_API void GC_CALL GC_set_warn_proc(GC_warn_proc p)
{
DCL_LOCK_STATE;
GC_ASSERT(NONNULL_ARG_NOT_NULL(p));
#ifdef GC_WIN32_THREADS
#ifdef CYGWIN32
GC_ASSERT(GC_is_initialized);
#else
if (!GC_is_initialized)GC_init();
#endif
#endif
LOCK();
GC_current_warn_proc=p;
UNLOCK();
}
GC_API GC_warn_proc GC_CALL GC_get_warn_proc(void)
{
GC_warn_proc result;
DCL_LOCK_STATE;
LOCK();
result=GC_current_warn_proc;
UNLOCK();
return(result);
}
#if!defined(PCR)&&!defined(SMALL_CONFIG)
STATIC void GC_CALLBACK GC_default_on_abort(const char*msg)
{
#ifndef DONT_USE_ATEXIT
skip_gc_atexit=TRUE;
#endif
if (msg!=NULL){
#ifdef MSGBOX_ON_ERROR
GC_win32_MessageBoxA(msg,"Fatal error in GC",MB_ICONERROR|MB_OK);
#endif
#ifndef GC_ANDROID_LOG
#if defined(GC_WIN32_THREADS)&&defined(GC_ASSERTIONS)&&((defined(MSWIN32)&&!defined(CONSOLE_LOG))||defined(MSWINCE))
if (!GC_write_disabled)
#endif
{
if (WRITE(GC_stderr,msg,strlen(msg))>=0)
(void)WRITE(GC_stderr,"\n",1);
}
#else
__android_log_assert("*",GC_ANDROID_LOG_TAG,"%s\n",msg);
#endif
}
#if!defined(NO_DEBUGGING)&&!defined(GC_ANDROID_LOG)
if (GETENV("GC_LOOP_ON_ABORT")!=NULL){
for(;;){
}
}
#endif
}
GC_abort_func GC_on_abort=GC_default_on_abort;
GC_API void GC_CALL GC_set_abort_func(GC_abort_func fn)
{
DCL_LOCK_STATE;
GC_ASSERT(NONNULL_ARG_NOT_NULL(fn));
LOCK();
GC_on_abort=fn;
UNLOCK();
}
GC_API GC_abort_func GC_CALL GC_get_abort_func(void)
{
GC_abort_func fn;
DCL_LOCK_STATE;
LOCK();
fn=GC_on_abort;
UNLOCK();
return fn;
}
#endif
GC_API void GC_CALL GC_enable(void)
{
DCL_LOCK_STATE;
LOCK();
GC_ASSERT(GC_dont_gc!=0);
GC_dont_gc--;
UNLOCK();
}
GC_API void GC_CALL GC_disable(void)
{
DCL_LOCK_STATE;
LOCK();
GC_dont_gc++;
UNLOCK();
}
GC_API int GC_CALL GC_is_disabled(void)
{
return GC_dont_gc!=0;
}
GC_API void**GC_CALL GC_new_free_list_inner(void)
{
void*result;
GC_ASSERT(I_HOLD_LOCK());
result=GC_INTERNAL_MALLOC((MAXOBJGRANULES+1)*sizeof(ptr_t),PTRFREE);
if (NULL==result)ABORT("Failed to allocate freelist for new kind");
BZERO(result,(MAXOBJGRANULES+1)*sizeof(ptr_t));
return (void**)result;
}
GC_API void**GC_CALL GC_new_free_list(void)
{
void**result;
DCL_LOCK_STATE;
LOCK();
result=GC_new_free_list_inner();
UNLOCK();
return result;
}
GC_API unsigned GC_CALL GC_new_kind_inner(void**fl,GC_word descr,
int adjust,int clear)
{
unsigned result=GC_n_kinds;
GC_ASSERT(NONNULL_ARG_NOT_NULL(fl));
GC_ASSERT(adjust==FALSE||adjust==TRUE);
GC_ASSERT(clear==TRUE
||(descr==0&&adjust==FALSE&&clear==FALSE));
if (result < MAXOBJKINDS){
GC_ASSERT(result > 0);
GC_n_kinds++;
GC_obj_kinds[result].ok_freelist=fl;
GC_obj_kinds[result].ok_reclaim_list=0;
GC_obj_kinds[result].ok_descriptor=descr;
GC_obj_kinds[result].ok_relocate_descr=adjust;
GC_obj_kinds[result].ok_init=(GC_bool)clear;
#ifdef ENABLE_DISCLAIM
GC_obj_kinds[result].ok_mark_unconditionally=FALSE;
GC_obj_kinds[result].ok_disclaim_proc=0;
#endif
} else {
ABORT("Too many kinds");
}
return result;
}
GC_API unsigned GC_CALL GC_new_kind(void**fl,GC_word descr,int adjust,
int clear)
{
unsigned result;
DCL_LOCK_STATE;
LOCK();
result=GC_new_kind_inner(fl,descr,adjust,clear);
UNLOCK();
return result;
}
GC_API unsigned GC_CALL GC_new_proc_inner(GC_mark_proc proc)
{
unsigned result=GC_n_mark_procs;
if (result < MAX_MARK_PROCS){
GC_n_mark_procs++;
GC_mark_procs[result]=proc;
} else {
ABORT("Too many mark procedures");
}
return result;
}
GC_API unsigned GC_CALL GC_new_proc(GC_mark_proc proc)
{
unsigned result;
DCL_LOCK_STATE;
LOCK();
result=GC_new_proc_inner(proc);
UNLOCK();
return result;
}
GC_API void*GC_CALL GC_call_with_alloc_lock(GC_fn_type fn,void*client_data)
{
void*result;
DCL_LOCK_STATE;
#ifdef THREADS
LOCK();
#endif
result=(*fn)(client_data);
#ifdef THREADS
UNLOCK();
#endif
return(result);
}
GC_API void*GC_CALL GC_call_with_stack_base(GC_stack_base_func fn,void*arg)
{
struct GC_stack_base base;
void*result;
base.mem_base=(void*)&base;
#ifdef IA64
base.reg_base=(void*)GC_save_regs_in_stack();
#endif
result=fn(&base,arg);
GC_noop1(COVERT_DATAFLOW(&base));
return result;
}
#ifndef THREADS
GC_INNER ptr_t GC_blocked_sp=NULL;
#ifdef IA64
STATIC ptr_t GC_blocked_register_sp=NULL;
#endif
GC_INNER struct GC_traced_stack_sect_s*GC_traced_stack_sect=NULL;
GC_API void*GC_CALL GC_call_with_gc_active(GC_fn_type fn,
void*client_data)
{
struct GC_traced_stack_sect_s stacksect;
GC_ASSERT(GC_is_initialized);
if ((word)GC_stackbottom HOTTER_THAN (word)(&stacksect))
GC_stackbottom=(ptr_t)COVERT_DATAFLOW(&stacksect);
if (GC_blocked_sp==NULL){
client_data=fn(client_data);
GC_noop1(COVERT_DATAFLOW(&stacksect));
return client_data;
}
stacksect.saved_stack_ptr=GC_blocked_sp;
#ifdef IA64
stacksect.backing_store_end=GC_save_regs_in_stack();
stacksect.saved_backing_store_ptr=GC_blocked_register_sp;
#endif
stacksect.prev=GC_traced_stack_sect;
GC_blocked_sp=NULL;
GC_traced_stack_sect=&stacksect;
client_data=fn(client_data);
GC_ASSERT(GC_blocked_sp==NULL);
GC_ASSERT(GC_traced_stack_sect==&stacksect);
#if defined(CPPCHECK)
GC_noop1((word)GC_traced_stack_sect - (word)GC_blocked_sp);
#endif
GC_traced_stack_sect=stacksect.prev;
#ifdef IA64
GC_blocked_register_sp=stacksect.saved_backing_store_ptr;
#endif
GC_blocked_sp=stacksect.saved_stack_ptr;
return client_data;
}
STATIC void GC_do_blocking_inner(ptr_t data,void*context GC_ATTR_UNUSED)
{
struct blocking_data*d=(struct blocking_data*)data;
GC_ASSERT(GC_is_initialized);
GC_ASSERT(GC_blocked_sp==NULL);
#ifdef SPARC
GC_blocked_sp=GC_save_regs_in_stack();
#else
GC_blocked_sp=(ptr_t)&d;
#endif
#ifdef IA64
GC_blocked_register_sp=GC_save_regs_in_stack();
#endif
d->client_data=(d->fn)(d->client_data);
#ifdef SPARC
GC_ASSERT(GC_blocked_sp!=NULL);
#else
GC_ASSERT(GC_blocked_sp==(ptr_t)(&d));
#endif
#if defined(CPPCHECK)
GC_noop1((word)GC_blocked_sp);
#endif
GC_blocked_sp=NULL;
}
GC_API void GC_CALL GC_set_stackbottom(void*gc_thread_handle,
const struct GC_stack_base*sb)
{
GC_ASSERT(sb->mem_base!=NULL);
GC_ASSERT(NULL==gc_thread_handle||&GC_stackbottom==gc_thread_handle);
GC_ASSERT(NULL==GC_blocked_sp
&&NULL==GC_traced_stack_sect);
(void)gc_thread_handle;
GC_stackbottom=(char*)sb->mem_base;
#ifdef IA64
GC_register_stackbottom=(ptr_t)sb->reg_base;
#endif
}
GC_API void*GC_CALL GC_get_my_stackbottom(struct GC_stack_base*sb)
{
GC_ASSERT(GC_is_initialized);
sb->mem_base=GC_stackbottom;
#ifdef IA64
sb->reg_base=GC_register_stackbottom;
#endif
return&GC_stackbottom;
}
#endif
GC_API void*GC_CALL GC_do_blocking(GC_fn_type fn,void*client_data)
{
struct blocking_data my_data;
my_data.fn=fn;
my_data.client_data=client_data;
GC_with_callee_saves_pushed(GC_do_blocking_inner,(ptr_t)(&my_data));
return my_data.client_data;
}
#if!defined(NO_DEBUGGING)
GC_API void GC_CALL GC_dump(void)
{
DCL_LOCK_STATE;
LOCK();
GC_dump_named(NULL);
UNLOCK();
}
GC_API void GC_CALL GC_dump_named(const char*name)
{
#ifndef NO_CLOCK
CLOCK_TYPE current_time;
GET_TIME(current_time);
#endif
if (name!=NULL){
GC_printf("***GC Dump %s\n",name);
} else {
GC_printf("***GC Dump collection #%lu\n",(unsigned long)GC_gc_no);
}
#ifndef NO_CLOCK
GC_printf("Time since GC init:%lu ms\n",
MS_TIME_DIFF(current_time,GC_init_time));
#endif
GC_printf("\n***Static roots:\n");
GC_print_static_roots();
GC_printf("\n***Heap sections:\n");
GC_print_heap_sects();
GC_printf("\n***Free blocks:\n");
GC_print_hblkfreelist();
GC_printf("\n***Blocks in use:\n");
GC_print_block_list();
}
#endif
static void block_add_size(struct hblk*h,word pbytes)
{
hdr*hhdr=HDR(h);
*(word*)pbytes+=(WORDS_TO_BYTES(hhdr->hb_sz)+(HBLKSIZE - 1))
&~(word)(HBLKSIZE - 1);
}
GC_API size_t GC_CALL GC_get_memory_use(void)
{
word bytes=0;
DCL_LOCK_STATE;
LOCK();
GC_apply_to_all_blocks(block_add_size,(word)(&bytes));
UNLOCK();
return (size_t)bytes;
}
GC_API GC_word GC_CALL GC_get_gc_no(void)
{
return GC_gc_no;
}
#ifdef THREADS
GC_API int GC_CALL GC_get_parallel(void)
{
return GC_parallel;
}
GC_API void GC_CALL GC_alloc_lock(void)
{
DCL_LOCK_STATE;
LOCK();
}
GC_API void GC_CALL GC_alloc_unlock(void)
{
UNLOCK();
}
GC_INNER GC_on_thread_event_proc GC_on_thread_event=0;
GC_API void GC_CALL GC_set_on_thread_event(GC_on_thread_event_proc fn)
{
DCL_LOCK_STATE;
LOCK();
GC_on_thread_event=fn;
UNLOCK();
}
GC_API GC_on_thread_event_proc GC_CALL GC_get_on_thread_event(void)
{
GC_on_thread_event_proc fn;
DCL_LOCK_STATE;
LOCK();
fn=GC_on_thread_event;
UNLOCK();
return fn;
}
#endif
GC_API void GC_CALL GC_set_oom_fn(GC_oom_func fn)
{
GC_ASSERT(NONNULL_ARG_NOT_NULL(fn));
DCL_LOCK_STATE;
LOCK();
GC_oom_fn=fn;
UNLOCK();
}
GC_API GC_oom_func GC_CALL GC_get_oom_fn(void)
{
GC_oom_func fn;
DCL_LOCK_STATE;
LOCK();
fn=GC_oom_fn;
UNLOCK();
return fn;
}
GC_API void GC_CALL GC_set_on_heap_resize(GC_on_heap_resize_proc fn)
{
DCL_LOCK_STATE;
LOCK();
GC_on_heap_resize=fn;
UNLOCK();
}
GC_API GC_on_heap_resize_proc GC_CALL GC_get_on_heap_resize(void)
{
GC_on_heap_resize_proc fn;
DCL_LOCK_STATE;
LOCK();
fn=GC_on_heap_resize;
UNLOCK();
return fn;
}
GC_API void GC_CALL GC_set_finalizer_notifier(GC_finalizer_notifier_proc fn)
{
DCL_LOCK_STATE;
LOCK();
GC_finalizer_notifier=fn;
UNLOCK();
}
GC_API GC_finalizer_notifier_proc GC_CALL GC_get_finalizer_notifier(void)
{
GC_finalizer_notifier_proc fn;
DCL_LOCK_STATE;
LOCK();
fn=GC_finalizer_notifier;
UNLOCK();
return fn;
}
GC_API void GC_CALL GC_set_find_leak(int value)
{
GC_find_leak=value;
}
GC_API int GC_CALL GC_get_find_leak(void)
{
return GC_find_leak;
}
GC_API void GC_CALL GC_set_all_interior_pointers(int value)
{
DCL_LOCK_STATE;
GC_all_interior_pointers=value?1:0;
if (GC_is_initialized){
LOCK();
GC_initialize_offsets();
if (!GC_all_interior_pointers)
GC_bl_init_no_interiors();
UNLOCK();
}
}
GC_API int GC_CALL GC_get_all_interior_pointers(void)
{
return GC_all_interior_pointers;
}
GC_API void GC_CALL GC_set_finalize_on_demand(int value)
{
GC_ASSERT(value!=-1);
GC_finalize_on_demand=value;
}
GC_API int GC_CALL GC_get_finalize_on_demand(void)
{
return GC_finalize_on_demand;
}
GC_API void GC_CALL GC_set_java_finalization(int value)
{
GC_ASSERT(value!=-1);
GC_java_finalization=value;
}
GC_API int GC_CALL GC_get_java_finalization(void)
{
return GC_java_finalization;
}
GC_API void GC_CALL GC_set_dont_expand(int value)
{
GC_ASSERT(value!=-1);
GC_dont_expand=value;
}
GC_API int GC_CALL GC_get_dont_expand(void)
{
return GC_dont_expand;
}
GC_API void GC_CALL GC_set_no_dls(int value)
{
GC_ASSERT(value!=-1);
GC_no_dls=value;
}
GC_API int GC_CALL GC_get_no_dls(void)
{
return GC_no_dls;
}
GC_API void GC_CALL GC_set_non_gc_bytes(GC_word value)
{
GC_non_gc_bytes=value;
}
GC_API GC_word GC_CALL GC_get_non_gc_bytes(void)
{
return GC_non_gc_bytes;
}
GC_API void GC_CALL GC_set_free_space_divisor(GC_word value)
{
GC_ASSERT(value > 0);
GC_free_space_divisor=value;
}
GC_API GC_word GC_CALL GC_get_free_space_divisor(void)
{
return GC_free_space_divisor;
}
GC_API void GC_CALL GC_set_max_retries(GC_word value)
{
GC_ASSERT((GC_signed_word)value!=-1);
GC_max_retries=value;
}
GC_API GC_word GC_CALL GC_get_max_retries(void)
{
return GC_max_retries;
}
GC_API void GC_CALL GC_set_dont_precollect(int value)
{
GC_ASSERT(value!=-1);
GC_dont_precollect=value;
}
GC_API int GC_CALL GC_get_dont_precollect(void)
{
return GC_dont_precollect;
}
GC_API void GC_CALL GC_set_full_freq(int value)
{
GC_ASSERT(value>=0);
GC_full_freq=value;
}
GC_API int GC_CALL GC_get_full_freq(void)
{
return GC_full_freq;
}
GC_API void GC_CALL GC_set_time_limit(unsigned long value)
{
GC_ASSERT((long)value!=-1L);
GC_time_limit=value;
}
GC_API unsigned long GC_CALL GC_get_time_limit(void)
{
return GC_time_limit;
}
GC_API void GC_CALL GC_set_force_unmap_on_gcollect(int value)
{
GC_force_unmap_on_gcollect=(GC_bool)value;
}
GC_API int GC_CALL GC_get_force_unmap_on_gcollect(void)
{
return (int)GC_force_unmap_on_gcollect;
}
GC_API void GC_CALL GC_abort_on_oom(void)
{
GC_err_printf("Insufficient memory for the allocation\n");
EXIT();
}
#ifdef THREADS
GC_API void GC_CALL GC_stop_world_external(void)
{
GC_ASSERT(GC_is_initialized);
LOCK();
#ifdef THREAD_LOCAL_ALLOC
GC_ASSERT(!GC_world_stopped);
#endif
STOP_WORLD();
#ifdef THREAD_LOCAL_ALLOC
GC_world_stopped=TRUE;
#endif
}
GC_API void GC_CALL GC_start_world_external(void)
{
#ifdef THREAD_LOCAL_ALLOC
GC_ASSERT(GC_world_stopped);
GC_world_stopped=FALSE;
#else
GC_ASSERT(GC_is_initialized);
#endif
START_WORLD();
UNLOCK();
}
#endif
#if!defined(OS2)&&!defined(PCR)&&!defined(AMIGA)&&!defined(MACOS)&&!defined(MSWINCE)&&!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)&&!defined(__CC_ARM)
#include <sys/types.h>
#if!defined(MSWIN32)&&!defined(MSWIN_XBOX1)
#include <unistd.h>
#endif
#endif
#include <stdio.h>
#if defined(MSWINCE)||defined(SN_TARGET_PS3)
#define SIGSEGV 0
#else
#include <signal.h>
#endif
#if defined(UNIX_LIKE)||defined(CYGWIN32)||defined(NACL)||defined(SYMBIAN)
#include <fcntl.h>
#endif
#if defined(LINUX)||defined(LINUX_STACKBOTTOM)
#include <ctype.h>
#endif
#ifdef AMIGA
#define GC_AMIGA_DEF
#if!defined(GC_AMIGA_DEF)&&!defined(GC_AMIGA_SB)&&!defined(GC_AMIGA_DS)&&!defined(GC_AMIGA_AM)
#include <stdio.h>
#include <signal.h>
#define GC_AMIGA_DEF
#define GC_AMIGA_SB
#define GC_AMIGA_DS
#define GC_AMIGA_AM
#endif
#ifdef GC_AMIGA_DEF
#ifndef __GNUC__
#include <exec/exec.h>
#endif
#include <proto/exec.h>
#include <proto/dos.h>
#include <dos/dosextens.h>
#include <workbench/startup.h>
#endif
#ifdef GC_AMIGA_SB
ptr_t GC_get_main_stack_base(void)
{
struct Process*proc=(struct Process*)SysBase->ThisTask;
if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS
&&proc->pr_CLI!=NULL){
return (char*)proc->pr_ReturnAddr+sizeof(ULONG);
} else {
return (char*)proc->pr_Task.tc_SPUpper;
}
}
#endif
#ifdef GC_AMIGA_DS
void GC_register_data_segments(void)
{
struct Process*proc;
struct CommandLineInterface*cli;
BPTR myseglist;
ULONG*data;
#ifdef __GNUC__
ULONG dataSegSize;
GC_bool found_segment=FALSE;
extern char __data_size[];
dataSegSize=__data_size+8;
#endif
proc=(struct Process*)SysBase->ThisTask;
myseglist=proc->pr_SegList;
if (proc->pr_Task.tc_Node.ln_Type==NT_PROCESS){
if (proc->pr_CLI!=NULL){
cli=BADDR(proc->pr_CLI);
myseglist=cli->cli_Module;
}
} else {
ABORT("Not a Process.");
}
if (myseglist==NULL){
ABORT("Arrrgh.. can't find segments,aborting");
}
for (data=(ULONG*)BADDR(myseglist);data!=NULL;
data=(ULONG*)BADDR(data[0])){
if ((ULONG)GC_register_data_segments < (ULONG)(&data[1])
||(ULONG)GC_register_data_segments > (ULONG)(&data[1])
+data[-1]){
#ifdef __GNUC__
if (dataSegSize==data[-1]){
found_segment=TRUE;
}
#endif
GC_add_roots_inner((char*)&data[1],
((char*)&data[1])+data[-1],FALSE);
}
}
#ifdef __GNUC__
if (!found_segment){
ABORT("Can`t find correct Segments.\nSolution:Use an newer version of ixemul.library");
}
#endif
}
#endif
#ifdef GC_AMIGA_AM
#ifndef GC_AMIGA_FASTALLOC
void*GC_amiga_allocwrapper(size_t size,void*(*AllocFunction)(size_t size2)){
return (*AllocFunction)(size);
}
void*(*GC_amiga_allocwrapper_do)(size_t size,void*(*AllocFunction)(size_t size2))
=GC_amiga_allocwrapper;
#else
void*GC_amiga_allocwrapper_firsttime(size_t size,void*(*AllocFunction)(size_t size2));
void*(*GC_amiga_allocwrapper_do)(size_t size,void*(*AllocFunction)(size_t size2))
=GC_amiga_allocwrapper_firsttime;
struct GC_Amiga_AllocedMemoryHeader{
ULONG size;
struct GC_Amiga_AllocedMemoryHeader*next;
};
struct GC_Amiga_AllocedMemoryHeader*GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader*)(int)~(NULL);
ULONG GC_AMIGA_MEMF=MEMF_FAST|MEMF_CLEAR;
#ifndef GC_AMIGA_ONLYFAST
BOOL GC_amiga_dontalloc=FALSE;
#endif
#ifdef GC_AMIGA_PRINTSTATS
int succ=0,succ2=0;
int nsucc=0,nsucc2=0;
int nullretries=0;
int numcollects=0;
int chipa=0;
int allochip=0;
int allocfast=0;
int cur0=0;
int cur1=0;
int cur10=0;
int cur50=0;
int cur150=0;
int cur151=0;
int ncur0=0;
int ncur1=0;
int ncur10=0;
int ncur50=0;
int ncur150=0;
int ncur151=0;
#endif
void GC_amiga_free_all_mem(void){
struct GC_Amiga_AllocedMemoryHeader*gc_am=(struct GC_Amiga_AllocedMemoryHeader*)(~(int)(GC_AMIGAMEM));
#ifdef GC_AMIGA_PRINTSTATS
printf("\n\n"
"%d bytes of chip-mem,and %d bytes of fast-mem where allocated from the OS.\n",
allochip,allocfast
);
printf(
"%d bytes of chip-mem were returned from the GC_AMIGA_FASTALLOC supported allocating functions.\n",
chipa
);
printf("\n");
printf("GC_gcollect was called %d times to avoid returning NULL or start allocating with the MEMF_ANY flag.\n",numcollects);
printf("%d of them was a success. (the others had to use allocation from the OS.)\n",nullretries);
printf("\n");
printf("Succeeded forcing %d gc-allocations (%d bytes)of chip-mem to be fast-mem.\n",succ,succ2);
printf("Failed forcing %d gc-allocations (%d bytes)of chip-mem to be fast-mem.\n",nsucc,nsucc2);
printf("\n");
printf(
"Number of retries before succeeding a chip->fast force:\n"
"0:%d,1:%d,2-9:%d,10-49:%d,50-149:%d,>150:%d\n",
cur0,cur1,cur10,cur50,cur150,cur151
);
printf(
"Number of retries before giving up a chip->fast force:\n"
"0:%d,1:%d,2-9:%d,10-49:%d,50-149:%d,>150:%d\n",
ncur0,ncur1,ncur10,ncur50,ncur150,ncur151
);
#endif
while(gc_am!=NULL){
struct GC_Amiga_AllocedMemoryHeader*temp=gc_am->next;
FreeMem(gc_am,gc_am->size);
gc_am=(struct GC_Amiga_AllocedMemoryHeader*)(~(int)(temp));
}
}
#ifndef GC_AMIGA_ONLYFAST
char*chipmax;
size_t latestsize;
#endif
#ifdef GC_AMIGA_FASTALLOC
void*GC_amiga_get_mem(size_t size){
struct GC_Amiga_AllocedMemoryHeader*gc_am;
#ifndef GC_AMIGA_ONLYFAST
if(GC_amiga_dontalloc==TRUE){
return NULL;
}
if(GC_AMIGA_MEMF==(MEMF_ANY|MEMF_CLEAR)&&size>100000&&latestsize<50000)return NULL;
#endif
gc_am=AllocMem((ULONG)(size+sizeof(struct GC_Amiga_AllocedMemoryHeader)),GC_AMIGA_MEMF);
if(gc_am==NULL)return NULL;
gc_am->next=GC_AMIGAMEM;
gc_am->size=size+sizeof(struct GC_Amiga_AllocedMemoryHeader);
GC_AMIGAMEM=(struct GC_Amiga_AllocedMemoryHeader*)(~(int)(gc_am));
#ifdef GC_AMIGA_PRINTSTATS
if((char*)gc_am<chipmax){
allochip+=size;
}else{
allocfast+=size;
}
#endif
return gc_am+1;
}
#endif
#ifndef GC_AMIGA_ONLYFAST
#ifdef GC_AMIGA_RETRY
void*GC_amiga_rec_alloc(size_t size,void*(*AllocFunction)(size_t size2),const int rec){
void*ret;
ret=(*AllocFunction)(size);
#ifdef GC_AMIGA_PRINTSTATS
if((char*)ret>chipmax||ret==NULL){
if(ret==NULL){
nsucc++;
nsucc2+=size;
if(rec==0)ncur0++;
if(rec==1)ncur1++;
if(rec>1&&rec<10)ncur10++;
if(rec>=10&&rec<50)ncur50++;
if(rec>=50&&rec<150)ncur150++;
if(rec>=150)ncur151++;
}else{
succ++;
succ2+=size;
if(rec==0)cur0++;
if(rec==1)cur1++;
if(rec>1&&rec<10)cur10++;
if(rec>=10&&rec<50)cur50++;
if(rec>=50&&rec<150)cur150++;
if(rec>=150)cur151++;
}
}
#endif
if (((char*)ret)<=chipmax&&ret!=NULL&&(rec<(size>500000?9:size/5000))){
ret=GC_amiga_rec_alloc(size,AllocFunction,rec+1);
}
return ret;
}
#endif
void*GC_amiga_allocwrapper_any(size_t size,void*(*AllocFunction)(size_t size2)){
void*ret;
GC_amiga_dontalloc=TRUE;
latestsize=size;
ret=(*AllocFunction)(size);
if(((char*)ret)<=chipmax){
if(ret==NULL){
#ifdef GC_AMIGA_GC
if(!GC_dont_gc){
GC_gcollect();
#ifdef GC_AMIGA_PRINTSTATS
numcollects++;
#endif
ret=(*AllocFunction)(size);
}
if(ret==NULL)
#endif
{
GC_amiga_dontalloc=FALSE;
ret=(*AllocFunction)(size);
if(ret==NULL){
WARN("Out of Memory!Returning NIL!\n",0);
}
}
#ifdef GC_AMIGA_PRINTSTATS
else{
nullretries++;
}
if(ret!=NULL&&(char*)ret<=chipmax)chipa+=size;
#endif
}
#ifdef GC_AMIGA_RETRY
else{
void*ret2;
if(
AllocFunction!=GC_malloc_uncollectable
#ifdef GC_ATOMIC_UNCOLLECTABLE
&&AllocFunction!=GC_malloc_atomic_uncollectable
#endif
){
ret2=GC_amiga_rec_alloc(size,AllocFunction,0);
}else{
ret2=(*AllocFunction)(size);
#ifdef GC_AMIGA_PRINTSTATS
if((char*)ret2<chipmax||ret2==NULL){
nsucc++;
nsucc2+=size;
ncur0++;
}else{
succ++;
succ2+=size;
cur0++;
}
#endif
}
if(((char*)ret2)>chipmax){
GC_free(ret);
ret=ret2;
}else{
GC_free(ret2);
}
}
#endif
}
#if defined(CPPCHECK)
if (GC_amiga_dontalloc)
#endif
GC_amiga_dontalloc=FALSE;
return ret;
}
void (*GC_amiga_toany)(void)=NULL;
void GC_amiga_set_toany(void (*func)(void)){
GC_amiga_toany=func;
}
#endif
void*GC_amiga_allocwrapper_fast(size_t size,void*(*AllocFunction)(size_t size2)){
void*ret;
ret=(*AllocFunction)(size);
if(ret==NULL){
#ifdef GC_AMIGA_GC
if(!GC_dont_gc){
GC_gcollect();
#ifdef GC_AMIGA_PRINTSTATS
numcollects++;
#endif
ret=(*AllocFunction)(size);
}
if(ret==NULL)
#endif
{
#ifndef GC_AMIGA_ONLYFAST
GC_AMIGA_MEMF=MEMF_ANY|MEMF_CLEAR;
if(GC_amiga_toany!=NULL)(*GC_amiga_toany)();
GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
return GC_amiga_allocwrapper_any(size,AllocFunction);
#endif
}
#ifdef GC_AMIGA_PRINTSTATS
else{
nullretries++;
}
#endif
}
return ret;
}
void*GC_amiga_allocwrapper_firsttime(size_t size,void*(*AllocFunction)(size_t size2)){
atexit(&GC_amiga_free_all_mem);
chipmax=(char*)SysBase->MaxLocMem;
GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_fast;
return GC_amiga_allocwrapper_fast(size,AllocFunction);
}
#endif
void*GC_amiga_realloc(void*old_object,size_t new_size_in_bytes){
#ifndef GC_AMIGA_FASTALLOC
return GC_realloc(old_object,new_size_in_bytes);
#else
void*ret;
latestsize=new_size_in_bytes;
ret=GC_realloc(old_object,new_size_in_bytes);
if(ret==NULL&&new_size_in_bytes!=0
&&GC_AMIGA_MEMF==(MEMF_FAST|MEMF_CLEAR)){
#ifdef GC_AMIGA_GC
if(!GC_dont_gc){
GC_gcollect();
#ifdef GC_AMIGA_PRINTSTATS
numcollects++;
#endif
ret=GC_realloc(old_object,new_size_in_bytes);
}
if(ret==NULL)
#endif
{
#ifndef GC_AMIGA_ONLYFAST
GC_AMIGA_MEMF=MEMF_ANY|MEMF_CLEAR;
if(GC_amiga_toany!=NULL)(*GC_amiga_toany)();
GC_amiga_allocwrapper_do=GC_amiga_allocwrapper_any;
ret=GC_realloc(old_object,new_size_in_bytes);
#endif
}
#ifdef GC_AMIGA_PRINTSTATS
else{
nullretries++;
}
#endif
}
if(ret==NULL&&new_size_in_bytes!=0){
WARN("Out of Memory!Returning NIL!\n",0);
}
#ifdef GC_AMIGA_PRINTSTATS
if(((char*)ret)<chipmax&&ret!=NULL){
chipa+=new_size_in_bytes;
}
#endif
return ret;
#endif
}
#endif
#undef GC_AMIGA_DEF
#endif
#ifdef MACOS
#include <Processes.h>
#endif
#ifdef IRIX5
#include <sys/uio.h>
#include <malloc.h>
#endif
#if defined(MMAP_SUPPORTED)||defined(ADD_HEAP_GUARD_PAGES)
#if defined(USE_MUNMAP)&&!defined(USE_MMAP)&&!defined(CPPCHECK)
#error Invalid config:USE_MUNMAP requires USE_MMAP
#endif
#include <sys/types.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <errno.h>
#endif
#ifdef DARWIN
#include <mach-o/getsect.h>
#endif
#ifdef DJGPP
typedef long unsigned int caddr_t;
#endif
#ifdef PCR
#include "mm/PCR_MM.h"
#endif
#if defined(GC_DARWIN_THREADS)&&defined(MPROTECT_VDB)
#ifndef GC_DARWIN_STOP_WORLD_H
#define GC_DARWIN_STOP_WORLD_H
#if!defined(GC_DARWIN_THREADS)
#error darwin_stop_world.h included without GC_DARWIN_THREADS defined
#endif
#include <mach/mach.h>
#include <mach/thread_act.h>
EXTERN_C_BEGIN
struct thread_stop_info {
mach_port_t mach_thread;
ptr_t stack_ptr;
};
#ifndef DARWIN_DONT_PARSE_STACK
GC_INNER ptr_t GC_FindTopOfStack(unsigned long);
#endif
#ifdef MPROTECT_VDB
GC_INNER void GC_mprotect_stop(void);
GC_INNER void GC_mprotect_resume(void);
#ifndef GC_NO_THREADS_DISCOVERY
GC_INNER void GC_darwin_register_mach_handler_thread(mach_port_t thread);
#endif
#endif
#if defined(PARALLEL_MARK)&&!defined(GC_NO_THREADS_DISCOVERY)
GC_INNER GC_bool GC_is_mach_marker(thread_act_t);
#endif
EXTERN_C_END
#endif
#endif
#if!defined(NO_EXECUTE_PERMISSION)
STATIC GC_bool GC_pages_executable=TRUE;
#else
STATIC GC_bool GC_pages_executable=FALSE;
#endif
#define IGNORE_PAGES_EXECUTABLE 1
#ifdef NEED_PROC_MAPS
STATIC ssize_t GC_repeat_read(int fd,char*buf,size_t count)
{
#define READ read
size_t num_read=0;
ASSERT_CANCEL_DISABLED();
while (num_read < count){
ssize_t result=READ(fd,buf+num_read,count - num_read);
if (result < 0)return result;
if (result==0)break;
num_read+=result;
}
#undef READ
return num_read;
}
#ifdef THREADS
STATIC size_t GC_get_file_len(int f)
{
size_t total=0;
ssize_t result;
#define GET_FILE_LEN_BUF_SZ 500
char buf[GET_FILE_LEN_BUF_SZ];
do {
result=read(f,buf,GET_FILE_LEN_BUF_SZ);
if (result==-1)return 0;
total+=result;
} while (result > 0);
return total;
}
STATIC size_t GC_get_maps_len(void)
{
int f=open("/proc/self/maps",O_RDONLY);
size_t result;
if (f < 0)return 0;
result=GC_get_file_len(f);
close(f);
return result;
}
#endif
GC_INNER char*GC_get_maps(void)
{
ssize_t result;
static char*maps_buf=NULL;
static size_t maps_buf_sz=1;
size_t maps_size;
#ifdef THREADS
size_t old_maps_size=0;
#endif
GC_ASSERT(I_HOLD_LOCK());
#ifdef THREADS
maps_size=GC_get_maps_len();
if (0==maps_size)return 0;
#else
maps_size=4000;
#endif
do {
int f;
while (maps_size>=maps_buf_sz){
#ifdef LINT2
GC_noop1((word)maps_buf);
#else
GC_scratch_recycle_no_gww(maps_buf,maps_buf_sz);
#endif
while (maps_size>=maps_buf_sz)maps_buf_sz*=2;
maps_buf=GC_scratch_alloc(maps_buf_sz);
#ifdef THREADS
maps_size=GC_get_maps_len();
if (0==maps_size)return 0;
#endif
if (maps_buf==0)return 0;
}
GC_ASSERT(maps_buf_sz>=maps_size+1);
f=open("/proc/self/maps",O_RDONLY);
if (-1==f)return 0;
#ifdef THREADS
old_maps_size=maps_size;
#endif
maps_size=0;
do {
result=GC_repeat_read(f,maps_buf,maps_buf_sz-1);
if (result<=0){
close(f);
return 0;
}
maps_size+=result;
} while ((size_t)result==maps_buf_sz-1);
close(f);
#ifdef THREADS
if (maps_size > old_maps_size){
WARN("Unexpected asynchronous/proc/self/maps growth"
" (to %" WARN_PRIdPTR " bytes)\n",maps_size);
}
#endif
} while (maps_size>=maps_buf_sz
#ifdef THREADS
||maps_size < old_maps_size
#endif
);
maps_buf[maps_size]='\0';
return maps_buf;
}
#if (defined(DYNAMIC_LOADING)&&defined(USE_PROC_FOR_LIBRARIES))||defined(IA64)||defined(INCLUDE_LINUX_THREAD_DESCR)||defined(REDIRECT_MALLOC)
GC_INNER char*GC_parse_map_entry(char*buf_ptr,ptr_t*start,ptr_t*end,
char**prot,unsigned int*maj_dev,
char**mapping_name)
{
unsigned char*start_start,*end_start,*maj_dev_start;
unsigned char*p;
if (buf_ptr==NULL||*buf_ptr=='\0'){
return NULL;
}
p=(unsigned char*)buf_ptr;
while (isspace(*p))++p;
start_start=p;
GC_ASSERT(isxdigit(*start_start));
*start=(ptr_t)strtoul((char*)start_start,(char**)&p,16);
GC_ASSERT(*p=='-');
++p;
end_start=p;
GC_ASSERT(isxdigit(*end_start));
*end=(ptr_t)strtoul((char*)end_start,(char**)&p,16);
GC_ASSERT(isspace(*p));
while (isspace(*p))++p;
GC_ASSERT(*p=='r'||*p=='-');
*prot=(char*)p;
while (!isspace(*p))++p;
while (isspace(*p))p++;
GC_ASSERT(isxdigit(*p));
while (!isspace(*p))++p;
while (isspace(*p))p++;
maj_dev_start=p;
GC_ASSERT(isxdigit(*maj_dev_start));
*maj_dev=strtoul((char*)maj_dev_start,NULL,16);
if (mapping_name==0){
while (*p&&*p++!='\n');
} else {
while (*p&&*p!='\n'&&*p!='/'&&*p!='[')p++;
*mapping_name=(char*)p;
while (*p&&*p++!='\n');
}
return (char*)p;
}
#endif
#if defined(IA64)||defined(INCLUDE_LINUX_THREAD_DESCR)
GC_INNER GC_bool GC_enclosing_mapping(ptr_t addr,ptr_t*startp,
ptr_t*endp)
{
char*prot;
ptr_t my_start,my_end;
unsigned int maj_dev;
char*maps=GC_get_maps();
char*buf_ptr=maps;
if (0==maps)return(FALSE);
for (;;){
buf_ptr=GC_parse_map_entry(buf_ptr,&my_start,&my_end,
&prot,&maj_dev,0);
if (buf_ptr==NULL)return FALSE;
if (prot[1]=='w'&&maj_dev==0){
if ((word)my_end > (word)addr&&(word)my_start<=(word)addr){
*startp=my_start;
*endp=my_end;
return TRUE;
}
}
}
return FALSE;
}
#endif
#if defined(REDIRECT_MALLOC)
GC_INNER GC_bool GC_text_mapping(char*nm,ptr_t*startp,ptr_t*endp)
{
size_t nm_len=strlen(nm);
char*prot;
char*map_path;
ptr_t my_start,my_end;
unsigned int maj_dev;
char*maps=GC_get_maps();
char*buf_ptr=maps;
if (0==maps)return(FALSE);
for (;;){
buf_ptr=GC_parse_map_entry(buf_ptr,&my_start,&my_end,
&prot,&maj_dev,&map_path);
if (buf_ptr==NULL)return FALSE;
if (prot[0]=='r'&&prot[1]=='-'&&prot[2]=='x'){
char*p=map_path;
while (*p!='\0'&&*p!='\n'&&*p!=' '&&*p!='\t')++p;
while (*p!='/'&&(word)p>=(word)map_path)--p;
++p;
if (strncmp(nm,p,nm_len)==0){
*startp=my_start;
*endp=my_end;
return TRUE;
}
}
}
return FALSE;
}
#endif
#ifdef IA64
static ptr_t backing_store_base_from_proc(void)
{
ptr_t my_start,my_end;
if (!GC_enclosing_mapping(GC_save_regs_in_stack(),&my_start,&my_end)){
GC_COND_LOG_PRINTF("Failed to find backing store base from/proc\n");
return 0;
}
return my_start;
}
#endif
#endif
#if defined(SEARCH_FOR_DATA_START)
#if defined(LINUX)||defined(HURD)
EXTERN_C_BEGIN
#pragma weak __data_start
#pragma weak data_start
extern int __data_start[],data_start[];
EXTERN_C_END
#endif
ptr_t GC_data_start=NULL;
GC_INNER void GC_init_linux_data_start(void)
{
ptr_t data_end=DATAEND;
#if (defined(LINUX)||defined(HURD))&&defined(USE_PROG_DATA_START)
if (COVERT_DATAFLOW(__data_start)!=0){
GC_data_start=(ptr_t)(__data_start);
} else {
GC_data_start=(ptr_t)(data_start);
}
if (COVERT_DATAFLOW(GC_data_start)!=0){
if ((word)GC_data_start > (word)data_end)
ABORT_ARG2("Wrong __data_start/_end pair",
":%p .. %p",(void*)GC_data_start,(void*)data_end);
return;
}
#ifdef DEBUG_ADD_DEL_ROOTS
GC_log_printf("__data_start not provided\n");
#endif
#endif
if (GC_no_dls){
GC_data_start=data_end;
return;
}
GC_data_start=(ptr_t)GC_find_limit(data_end,FALSE);
}
#endif
#ifdef ECOS
#ifndef ECOS_GC_MEMORY_SIZE
#define ECOS_GC_MEMORY_SIZE (448*1024)
#endif
static char ecos_gc_memory[ECOS_GC_MEMORY_SIZE];
static char*ecos_gc_brk=ecos_gc_memory;
static void*tiny_sbrk(ptrdiff_t increment)
{
void*p=ecos_gc_brk;
ecos_gc_brk+=increment;
if ((word)ecos_gc_brk > (word)(ecos_gc_memory+sizeof(ecos_gc_memory))){
ecos_gc_brk-=increment;
return NULL;
}
return p;
}
#define sbrk tiny_sbrk
#endif
#if defined(NETBSD)&&defined(__ELF__)
ptr_t GC_data_start=NULL;
EXTERN_C_BEGIN
extern char**environ;
EXTERN_C_END
GC_INNER void GC_init_netbsd_elf(void)
{
GC_data_start=(ptr_t)GC_find_limit(&environ,FALSE);
}
#endif
#if defined(ADDRESS_SANITIZER)&&(defined(UNIX_LIKE)||defined(NEED_FIND_LIMIT)||defined(MPROTECT_VDB))&&!defined(CUSTOM_ASAN_DEF_OPTIONS)
GC_API const char*__asan_default_options(void)
{
return "allow_user_segv_handler=1";
}
#endif
#ifdef OPENBSD
static struct sigaction old_segv_act;
STATIC JMP_BUF GC_jmp_buf_openbsd;
STATIC void GC_fault_handler_openbsd(int sig GC_ATTR_UNUSED)
{
LONGJMP(GC_jmp_buf_openbsd,1);
}
#ifdef GC_OPENBSD_UTHREADS
#include <sys/syscall.h>
EXTERN_C_BEGIN
extern sigset_t __syscall(quad_t,...);
EXTERN_C_END
STATIC ptr_t GC_find_limit_openbsd(ptr_t p,ptr_t bound)
{
static volatile ptr_t result;
struct sigaction act;
word pgsz=(word)sysconf(_SC_PAGESIZE);
GC_ASSERT((word)bound>=pgsz);
GC_ASSERT(I_HOLD_LOCK());
act.sa_handler=GC_fault_handler_openbsd;
sigemptyset(&act.sa_mask);
act.sa_flags=SA_NODEFER|SA_RESTART;
sigaction(SIGSEGV,&act,&old_segv_act);
if (SETJMP(GC_jmp_buf_openbsd)==0){
result=(ptr_t)((word)p&~(pgsz-1));
for (;;){
if ((word)result>=(word)bound - pgsz){
result=bound;
break;
}
result+=pgsz;
GC_noop1((word)(*result));
}
}
#ifdef THREADS
__syscall(SYS_sigprocmask,SIG_UNBLOCK,sigmask(SIGPROF));
#endif
sigaction(SIGSEGV,&old_segv_act,0);
return(result);
}
#endif
static volatile int firstpass;
STATIC ptr_t GC_skip_hole_openbsd(ptr_t p,ptr_t bound)
{
static volatile ptr_t result;
struct sigaction act;
word pgsz=(word)sysconf(_SC_PAGESIZE);
GC_ASSERT((word)bound>=pgsz);
GC_ASSERT(I_HOLD_LOCK());
act.sa_handler=GC_fault_handler_openbsd;
sigemptyset(&act.sa_mask);
act.sa_flags=SA_NODEFER|SA_RESTART;
sigaction(SIGSEGV,&act,&old_segv_act);
firstpass=1;
result=(ptr_t)((word)p&~(pgsz-1));
if (SETJMP(GC_jmp_buf_openbsd)!=0||firstpass){
firstpass=0;
if ((word)result>=(word)bound - pgsz){
result=bound;
} else {
result+=pgsz;
GC_noop1((word)(*result));
}
}
sigaction(SIGSEGV,&old_segv_act,0);
return(result);
}
#endif
#ifdef OS2
#include <stddef.h>
#if!defined(__IBMC__)&&!defined(__WATCOMC__)
struct exe_hdr {
unsigned short magic_number;
unsigned short padding[29];
long new_exe_offset;
};
#define E_MAGIC(x)(x).magic_number
#define EMAGIC 0x5A4D
#define E_LFANEW(x)(x).new_exe_offset
struct e32_exe {
unsigned char magic_number[2];
unsigned char byte_order;
unsigned char word_order;
unsigned long exe_format_level;
unsigned short cpu;
unsigned short os;
unsigned long padding1[13];
unsigned long object_table_offset;
unsigned long object_count;
unsigned long padding2[31];
};
#define E32_MAGIC1(x)(x).magic_number[0]
#define E32MAGIC1 'L'
#define E32_MAGIC2(x)(x).magic_number[1]
#define E32MAGIC2 'X'
#define E32_BORDER(x)(x).byte_order
#define E32LEBO 0
#define E32_WORDER(x)(x).word_order
#define E32LEWO 0
#define E32_CPU(x)(x).cpu
#define E32CPU286 1
#define E32_OBJTAB(x)(x).object_table_offset
#define E32_OBJCNT(x)(x).object_count
struct o32_obj {
unsigned long size;
unsigned long base;
unsigned long flags;
unsigned long pagemap;
unsigned long mapsize;
unsigned long reserved;
};
#define O32_FLAGS(x)(x).flags
#define OBJREAD 0x0001L
#define OBJWRITE 0x0002L
#define OBJINVALID 0x0080L
#define O32_SIZE(x)(x).size
#define O32_BASE(x)(x).base
#else
#ifndef WORD
#define WORD unsigned short
#endif
#ifndef DWORD
#define DWORD unsigned long
#endif
#define EXE386 1
#include <newexe.h>
#include <exe386.h>
#endif
#define INCL_DOSEXCEPTIONS
#define INCL_DOSPROCESS
#define INCL_DOSERRORS
#define INCL_DOSMODULEMGR
#define INCL_DOSMEMMGR
#include <os2.h>
#endif
GC_INNER size_t GC_page_size=0;
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)
#ifndef VER_PLATFORM_WIN32_CE
#define VER_PLATFORM_WIN32_CE 3
#endif
#if defined(MSWINCE)&&defined(THREADS)
GC_INNER GC_bool GC_dont_query_stack_min=FALSE;
#endif
GC_INNER SYSTEM_INFO GC_sysinfo;
GC_INNER void GC_setpagesize(void)
{
GetSystemInfo(&GC_sysinfo);
#if defined(CYGWIN32)&&(defined(MPROTECT_VDB)||defined(USE_MUNMAP))
GC_page_size=(size_t)GC_sysinfo.dwAllocationGranularity;
GC_ASSERT(GC_page_size>=(size_t)GC_sysinfo.dwPageSize);
#else
GC_page_size=(size_t)GC_sysinfo.dwPageSize;
#endif
#if defined(MSWINCE)&&!defined(_WIN32_WCE_EMULATION)
{
OSVERSIONINFO verInfo;
verInfo.dwOSVersionInfoSize=sizeof(OSVERSIONINFO);
if (!GetVersionEx(&verInfo))
ABORT("GetVersionEx failed");
if (verInfo.dwPlatformId==VER_PLATFORM_WIN32_CE&&
verInfo.dwMajorVersion < 6){
GC_sysinfo.lpMaximumApplicationAddress=(LPVOID)((word)32<<20);
#ifdef THREADS
if (verInfo.dwMajorVersion < 5)
GC_dont_query_stack_min=TRUE;
#endif
}
}
#endif
}
#ifndef CYGWIN32
#define is_writable(prot)((prot)==PAGE_READWRITE||(prot)==PAGE_WRITECOPY||(prot)==PAGE_EXECUTE_READWRITE||(prot)==PAGE_EXECUTE_WRITECOPY)
STATIC word GC_get_writable_length(ptr_t p,ptr_t*base)
{
MEMORY_BASIC_INFORMATION buf;
word result;
word protect;
result=VirtualQuery(p,&buf,sizeof(buf));
if (result!=sizeof(buf))ABORT("Weird VirtualQuery result");
if (base!=0)*base=(ptr_t)(buf.AllocationBase);
protect=(buf.Protect&~(PAGE_GUARD|PAGE_NOCACHE));
if (!is_writable(protect)){
return(0);
}
if (buf.State!=MEM_COMMIT)return(0);
return(buf.RegionSize);
}
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*sb)
{
ptr_t trunc_sp;
word size;
if (!GC_page_size)GC_setpagesize();
trunc_sp=(ptr_t)((word)GC_approx_sp()&~(GC_page_size - 1));
size=GC_get_writable_length(trunc_sp,0);
GC_ASSERT(size!=0);
sb->mem_base=trunc_sp+size;
return GC_SUCCESS;
}
#else
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*sb)
{
#ifdef X86_64
sb->mem_base=((NT_TIB*)NtCurrentTeb())->StackBase;
#else
void*_tlsbase;
__asm__ ("movl %%fs:4,%0"
:"=r" (_tlsbase));
sb->mem_base=_tlsbase;
#endif
return GC_SUCCESS;
}
#endif
#define HAVE_GET_STACK_BASE
#else
GC_INNER void GC_setpagesize(void)
{
#if defined(MPROTECT_VDB)||defined(PROC_VDB)||defined(USE_MMAP)
GC_page_size=(size_t)GETPAGESIZE();
#if!defined(CPPCHECK)
if (0==GC_page_size)
ABORT("getpagesize failed");
#endif
#else
GC_page_size=HBLKSIZE;
#endif
}
#endif
#ifdef HAIKU
#include <kernel/OS.h>
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*sb)
{
thread_info th;
get_thread_info(find_thread(NULL),&th);
sb->mem_base=th.stack_end;
return GC_SUCCESS;
}
#define HAVE_GET_STACK_BASE
#endif
#ifdef OS2
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*sb)
{
PTIB ptib;
PPIB ppib;
if (DosGetInfoBlocks(&ptib,&ppib)!=NO_ERROR){
WARN("DosGetInfoBlocks failed\n",0);
return GC_UNIMPLEMENTED;
}
sb->mem_base=ptib->tib_pstacklimit;
return GC_SUCCESS;
}
#define HAVE_GET_STACK_BASE
#endif
#ifdef AMIGA
#define GC_AMIGA_SB
#undef GC_AMIGA_SB
#define GET_MAIN_STACKBASE_SPECIAL
#endif
#if defined(NEED_FIND_LIMIT)||defined(UNIX_LIKE)
typedef void (*GC_fault_handler_t)(int);
#if defined(SUNOS5SIGS)||defined(IRIX5)||defined(OSF1)||defined(HAIKU)||defined(HURD)||defined(FREEBSD)||defined(NETBSD)
static struct sigaction old_segv_act;
#if defined(_sigargs)||defined(HURD)||defined(NETBSD)||defined(FREEBSD)
static struct sigaction old_bus_act;
#endif
#else
static GC_fault_handler_t old_segv_handler;
#ifdef HAVE_SIGBUS
static GC_fault_handler_t old_bus_handler;
#endif
#endif
GC_INNER void GC_set_and_save_fault_handler(GC_fault_handler_t h)
{
#if defined(SUNOS5SIGS)||defined(IRIX5)||defined(OSF1)||defined(HAIKU)||defined(HURD)||defined(FREEBSD)||defined(NETBSD)||defined(OPENBSD)
struct sigaction act;
act.sa_handler=h;
#ifdef SIGACTION_FLAGS_NODEFER_HACK
act.sa_flags=SA_RESTART|SA_NODEFER;
#else
act.sa_flags=SA_RESTART;
#endif
(void)sigemptyset(&act.sa_mask);
#ifdef GC_IRIX_THREADS
(void)sigaction(SIGSEGV,0,&old_segv_act);
(void)sigaction(SIGSEGV,&act,0);
#else
(void)sigaction(SIGSEGV,&act,&old_segv_act);
#if defined(IRIX5)&&defined(_sigargs)||defined(HURD)||defined(NETBSD)||defined(FREEBSD)
(void)sigaction(SIGBUS,&act,&old_bus_act);
#endif
#endif
#else
old_segv_handler=signal(SIGSEGV,h);
#ifdef HAVE_SIGBUS
old_bus_handler=signal(SIGBUS,h);
#endif
#endif
#if defined(CPPCHECK)&&defined(ADDRESS_SANITIZER)
GC_noop1((word)&__asan_default_options);
#endif
}
#endif
#if defined(NEED_FIND_LIMIT)||(defined(USE_PROC_FOR_LIBRARIES)&&defined(THREADS))
#define MIN_PAGE_SIZE 256
GC_INNER JMP_BUF GC_jmp_buf;
STATIC void GC_fault_handler(int sig GC_ATTR_UNUSED)
{
LONGJMP(GC_jmp_buf,1);
}
GC_INNER void GC_setup_temporary_fault_handler(void)
{
GC_ASSERT(I_HOLD_LOCK());
GC_set_and_save_fault_handler(GC_fault_handler);
}
GC_INNER void GC_reset_fault_handler(void)
{
#if defined(SUNOS5SIGS)||defined(IRIX5)||defined(OSF1)||defined(HAIKU)||defined(HURD)||defined(FREEBSD)||defined(NETBSD)||defined(OPENBSD)
(void)sigaction(SIGSEGV,&old_segv_act,0);
#if defined(IRIX5)&&defined(_sigargs)||defined(HURD)||defined(NETBSD)
(void)sigaction(SIGBUS,&old_bus_act,0);
#endif
#else
(void)signal(SIGSEGV,old_segv_handler);
#ifdef HAVE_SIGBUS
(void)signal(SIGBUS,old_bus_handler);
#endif
#endif
}
GC_ATTR_NO_SANITIZE_ADDR
STATIC ptr_t GC_find_limit_with_bound(ptr_t p,GC_bool up,ptr_t bound)
{
static volatile ptr_t result;
GC_ASSERT(up?(word)bound>=MIN_PAGE_SIZE
:(word)bound<=~(word)MIN_PAGE_SIZE);
GC_ASSERT(I_HOLD_LOCK());
GC_setup_temporary_fault_handler();
if (SETJMP(GC_jmp_buf)==0){
result=(ptr_t)(((word)(p))
&~(MIN_PAGE_SIZE-1));
for (;;){
if (up){
if ((word)result>=(word)bound - MIN_PAGE_SIZE){
result=bound;
break;
}
result+=MIN_PAGE_SIZE;
} else {
if ((word)result<=(word)bound+MIN_PAGE_SIZE){
result=bound - MIN_PAGE_SIZE;
break;
}
result-=MIN_PAGE_SIZE;
}
GC_noop1((word)(*result));
}
}
GC_reset_fault_handler();
if (!up){
result+=MIN_PAGE_SIZE;
}
return(result);
}
void*GC_find_limit(void*p,int up)
{
return GC_find_limit_with_bound((ptr_t)p,(GC_bool)up,
up?(ptr_t)GC_WORD_MAX:0);
}
#endif
#ifdef HPUX_MAIN_STACKBOTTOM
#include <sys/param.h>
#include <sys/pstat.h>
STATIC ptr_t GC_hpux_main_stack_base(void)
{
struct pst_vm_status vm_status;
int i=0;
while (pstat_getprocvm(&vm_status,sizeof(vm_status),0,i++)==1){
if (vm_status.pst_type==PS_STACK)
return (ptr_t)vm_status.pst_vaddr;
}
#ifdef STACK_GROWS_UP
return (ptr_t)GC_find_limit(GC_approx_sp(),FALSE);
#else
return (ptr_t)GC_find_limit(GC_approx_sp(),TRUE);
#endif
}
#endif
#ifdef HPUX_STACKBOTTOM
#include <sys/param.h>
#include <sys/pstat.h>
GC_INNER ptr_t GC_get_register_stack_base(void)
{
struct pst_vm_status vm_status;
int i=0;
while (pstat_getprocvm(&vm_status,sizeof(vm_status),0,i++)==1){
if (vm_status.pst_type==PS_RSESTACK){
return (ptr_t)vm_status.pst_vaddr;
}
}
return (ptr_t)(((word)GC_stackbottom - BACKING_STORE_DISPLACEMENT - 1)
&~(BACKING_STORE_ALIGNMENT - 1));
}
#endif
#ifdef LINUX_STACKBOTTOM
#include <sys/types.h>
#include <sys/stat.h>
#define STAT_SKIP 27
#ifdef USE_LIBC_PRIVATES
EXTERN_C_BEGIN
#pragma weak __libc_stack_end
extern ptr_t __libc_stack_end;
#ifdef IA64
#pragma weak __libc_ia64_register_backing_store_base
extern ptr_t __libc_ia64_register_backing_store_base;
#endif
EXTERN_C_END
#endif
#ifdef IA64
GC_INNER ptr_t GC_get_register_stack_base(void)
{
ptr_t result;
#ifdef USE_LIBC_PRIVATES
if (0!=&__libc_ia64_register_backing_store_base
&&0!=__libc_ia64_register_backing_store_base){
return __libc_ia64_register_backing_store_base;
}
#endif
result=backing_store_base_from_proc();
if (0==result){
result=(ptr_t)GC_find_limit(GC_save_regs_in_stack(),FALSE);
}
return result;
}
#endif
STATIC ptr_t GC_linux_main_stack_base(void)
{
#ifndef STAT_READ
#define STAT_BUF_SIZE 4096
#define STAT_READ read
#endif
char stat_buf[STAT_BUF_SIZE];
int f;
word result;
int i,buf_offset=0,len;
#ifdef USE_LIBC_PRIVATES
if (0!=&__libc_stack_end&&0!=__libc_stack_end){
#if defined(IA64)
if (((word)__libc_stack_end&0xfff)+0x10 < 0x1000){
return __libc_stack_end+0x10;
}
#elif defined(SPARC)
if (__libc_stack_end!=(ptr_t)(unsigned long)0x1)
return __libc_stack_end;
#else
return __libc_stack_end;
#endif
}
#endif
f=open("/proc/self/stat",O_RDONLY);
if (f < 0)
ABORT("Couldn't read/proc/self/stat");
len=STAT_READ(f,stat_buf,STAT_BUF_SIZE);
close(f);
for (i=0;i < STAT_SKIP;++i){
while (buf_offset < len&&isspace(stat_buf[buf_offset++])){
}
while (buf_offset < len&&!isspace(stat_buf[buf_offset++])){
}
}
while (buf_offset < len&&isspace(stat_buf[buf_offset])){
buf_offset++;
}
for (i=0;buf_offset+i < len;i++){
if (!isdigit(stat_buf[buf_offset+i]))break;
}
if (buf_offset+i>=len)ABORT("Could not parse/proc/self/stat");
stat_buf[buf_offset+i]='\0';
result=(word)STRTOULL(&stat_buf[buf_offset],NULL,10);
if (result < 0x100000||(result&(sizeof(word)- 1))!=0)
ABORT("Absurd stack bottom value");
return (ptr_t)result;
}
#endif
#ifdef FREEBSD_STACKBOTTOM
#include <unistd.h>
#include <sys/types.h>
#include <sys/sysctl.h>
STATIC ptr_t GC_freebsd_main_stack_base(void)
{
int nm[2]={CTL_KERN,KERN_USRSTACK};
ptr_t base;
size_t len=sizeof(ptr_t);
int r=sysctl(nm,2,&base,&len,NULL,0);
if (r)ABORT("Error getting main stack base");
return base;
}
#endif
#if defined(ECOS)||defined(NOSYS)
ptr_t GC_get_main_stack_base(void)
{
return STACKBOTTOM;
}
#define GET_MAIN_STACKBASE_SPECIAL
#elif defined(SYMBIAN)
EXTERN_C_BEGIN
extern int GC_get_main_symbian_stack_base(void);
EXTERN_C_END
ptr_t GC_get_main_stack_base(void)
{
return (ptr_t)GC_get_main_symbian_stack_base();
}
#define GET_MAIN_STACKBASE_SPECIAL
#elif defined(__EMSCRIPTEN__)
#include <emscripten.h>
static void*emscripten_stack_base;
static void scan_stack_cb(void*begin,void*end)
{
(void)begin;
emscripten_stack_base=end;
}
ptr_t GC_get_main_stack_base(void)
{
emscripten_scan_stack(scan_stack_cb);
return (ptr_t)emscripten_stack_base;
}
#define GET_MAIN_STACKBASE_SPECIAL
#elif!defined(AMIGA)&&!defined(HAIKU)&&!defined(OS2)&&!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(CYGWIN32)&&!defined(GC_OPENBSD_THREADS)&&(!defined(GC_SOLARIS_THREADS)||defined(_STRICT_STDC))
#if (defined(HAVE_PTHREAD_ATTR_GET_NP)||defined(HAVE_PTHREAD_GETATTR_NP))&&(defined(THREADS)||defined(USE_GET_STACKBASE_FOR_MAIN))
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
#elif defined(DARWIN)&&!defined(NO_PTHREAD_GET_STACKADDR_NP)
#include <pthread.h>
#undef STACKBOTTOM
#define STACKBOTTOM (ptr_t)pthread_get_stackaddr_np(pthread_self())
#endif
ptr_t GC_get_main_stack_base(void)
{
ptr_t result;
#if (defined(HAVE_PTHREAD_ATTR_GET_NP)||defined(HAVE_PTHREAD_GETATTR_NP))&&(defined(USE_GET_STACKBASE_FOR_MAIN)||(defined(THREADS)&&!defined(REDIRECT_MALLOC)))
pthread_attr_t attr;
void*stackaddr;
size_t size;
#ifdef HAVE_PTHREAD_ATTR_GET_NP
if (pthread_attr_init(&attr)==0
&&(pthread_attr_get_np(pthread_self(),&attr)==0
?TRUE:(pthread_attr_destroy(&attr),FALSE)))
#else
if (pthread_getattr_np(pthread_self(),&attr)==0)
#endif
{
if (pthread_attr_getstack(&attr,&stackaddr,&size)==0
&&stackaddr!=NULL){
(void)pthread_attr_destroy(&attr);
#ifdef STACK_GROWS_DOWN
stackaddr=(char*)stackaddr+size;
#endif
return (ptr_t)stackaddr;
}
(void)pthread_attr_destroy(&attr);
}
WARN("pthread_getattr_np or pthread_attr_getstack failed"
" for main thread\n",0);
#endif
#ifdef STACKBOTTOM
result=STACKBOTTOM;
#else
#ifdef HEURISTIC1
#define STACKBOTTOM_ALIGNMENT_M1 ((word)STACK_GRAN - 1)
#ifdef STACK_GROWS_DOWN
result=(ptr_t)(((word)GC_approx_sp()+STACKBOTTOM_ALIGNMENT_M1)
&~STACKBOTTOM_ALIGNMENT_M1);
#else
result=(ptr_t)((word)GC_approx_sp()&~STACKBOTTOM_ALIGNMENT_M1);
#endif
#elif defined(HPUX_MAIN_STACKBOTTOM)
result=GC_hpux_main_stack_base();
#elif defined(LINUX_STACKBOTTOM)
result=GC_linux_main_stack_base();
#elif defined(FREEBSD_STACKBOTTOM)
result=GC_freebsd_main_stack_base();
#elif defined(HEURISTIC2)
{
ptr_t sp=GC_approx_sp();
#ifdef STACK_GROWS_DOWN
result=(ptr_t)GC_find_limit(sp,TRUE);
#if defined(HEURISTIC2_LIMIT)&&!defined(CPPCHECK)
if ((word)result > (word)HEURISTIC2_LIMIT
&&(word)sp < (word)HEURISTIC2_LIMIT){
result=HEURISTIC2_LIMIT;
}
#endif
#else
result=(ptr_t)GC_find_limit(sp,FALSE);
#if defined(HEURISTIC2_LIMIT)&&!defined(CPPCHECK)
if ((word)result < (word)HEURISTIC2_LIMIT
&&(word)sp > (word)HEURISTIC2_LIMIT){
result=HEURISTIC2_LIMIT;
}
#endif
#endif
}
#elif defined(STACK_NOT_SCANNED)||defined(CPPCHECK)
result=NULL;
#else
#error None of HEURISTIC*and*STACKBOTTOM defined!
#endif
#if defined(STACK_GROWS_DOWN)&&!defined(CPPCHECK)
if (result==0)
result=(ptr_t)(signed_word)(-sizeof(ptr_t));
#endif
#endif
#if!defined(CPPCHECK)
GC_ASSERT((word)GC_approx_sp()HOTTER_THAN (word)result);
#endif
return(result);
}
#define GET_MAIN_STACKBASE_SPECIAL
#endif
#if (defined(HAVE_PTHREAD_ATTR_GET_NP)||defined(HAVE_PTHREAD_GETATTR_NP))&&defined(THREADS)&&!defined(HAVE_GET_STACK_BASE)
#include <pthread.h>
#ifdef HAVE_PTHREAD_NP_H
#include <pthread_np.h>
#endif
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*b)
{
pthread_attr_t attr;
size_t size;
#ifdef IA64
DCL_LOCK_STATE;
#endif
#ifdef HAVE_PTHREAD_ATTR_GET_NP
if (pthread_attr_init(&attr)!=0)
ABORT("pthread_attr_init failed");
if (pthread_attr_get_np(pthread_self(),&attr)!=0){
WARN("pthread_attr_get_np failed\n",0);
(void)pthread_attr_destroy(&attr);
return GC_UNIMPLEMENTED;
}
#else
if (pthread_getattr_np(pthread_self(),&attr)!=0){
WARN("pthread_getattr_np failed\n",0);
return GC_UNIMPLEMENTED;
}
#endif
if (pthread_attr_getstack(&attr,&(b->mem_base),&size)!=0){
ABORT("pthread_attr_getstack failed");
}
(void)pthread_attr_destroy(&attr);
#ifdef STACK_GROWS_DOWN
b->mem_base=(char*)(b->mem_base)+size;
#endif
#ifdef IA64
LOCK();
{
IF_CANCEL(int cancel_state;)
ptr_t bsp;
ptr_t next_stack;
DISABLE_CANCEL(cancel_state);
bsp=GC_save_regs_in_stack();
next_stack=GC_greatest_stack_base_below(bsp);
if (0==next_stack){
b->reg_base=GC_find_limit(bsp,FALSE);
} else {
b->reg_base=GC_find_limit_with_bound(bsp,FALSE,next_stack);
}
RESTORE_CANCEL(cancel_state);
}
UNLOCK();
#endif
return GC_SUCCESS;
}
#define HAVE_GET_STACK_BASE
#endif
#if defined(GC_DARWIN_THREADS)&&!defined(NO_PTHREAD_GET_STACKADDR_NP)
#include <pthread.h>
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*b)
{
b->mem_base=pthread_get_stackaddr_np(pthread_self());
GC_ASSERT((word)GC_approx_sp()HOTTER_THAN (word)b->mem_base);
return GC_SUCCESS;
}
#define HAVE_GET_STACK_BASE
#endif
#ifdef GC_OPENBSD_THREADS
#include <sys/signal.h>
#include <pthread.h>
#include <pthread_np.h>
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*sb)
{
stack_t stack;
if (pthread_stackseg_np(pthread_self(),&stack))
ABORT("pthread_stackseg_np(self)failed");
sb->mem_base=stack.ss_sp;
return GC_SUCCESS;
}
#define HAVE_GET_STACK_BASE
#endif
#if defined(GC_SOLARIS_THREADS)&&!defined(_STRICT_STDC)
#include <thread.h>
#include <signal.h>
#include <pthread.h>
static pthread_t stackbase_main_self=0;
static void*stackbase_main_ss_sp=NULL;
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*b)
{
stack_t s;
pthread_t self=pthread_self();
if (self==stackbase_main_self)
{
b->mem_base=stackbase_main_ss_sp;
GC_ASSERT(b->mem_base!=NULL);
return GC_SUCCESS;
}
if (thr_stksegment(&s)){
ABORT("thr_stksegment failed");
}
GC_ASSERT((word)GC_approx_sp()HOTTER_THAN (word)s.ss_sp);
if (!stackbase_main_self&&thr_main()!=0)
{
stackbase_main_ss_sp=s.ss_sp;
stackbase_main_self=self;
}
b->mem_base=s.ss_sp;
return GC_SUCCESS;
}
#define HAVE_GET_STACK_BASE
#endif
#ifdef GC_RTEMS_PTHREADS
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*sb)
{
sb->mem_base=rtems_get_stack_bottom();
return GC_SUCCESS;
}
#define HAVE_GET_STACK_BASE
#endif
#ifndef HAVE_GET_STACK_BASE
#ifdef NEED_FIND_LIMIT
GC_API int GC_CALL GC_get_stack_base(struct GC_stack_base*b)
{
IF_CANCEL(int cancel_state;)
DCL_LOCK_STATE;
LOCK();
DISABLE_CANCEL(cancel_state);
#ifdef STACK_GROWS_DOWN
b->mem_base=GC_find_limit(GC_approx_sp(),TRUE);
#ifdef IA64
b->reg_base=GC_find_limit(GC_save_regs_in_stack(),FALSE);
#endif
#else
b->mem_base=GC_find_limit(GC_approx_sp(),FALSE);
#endif
RESTORE_CANCEL(cancel_state);
UNLOCK();
return GC_SUCCESS;
}
#else
GC_API int GC_CALL GC_get_stack_base(
struct GC_stack_base*b GC_ATTR_UNUSED)
{
#if defined(GET_MAIN_STACKBASE_SPECIAL)&&!defined(THREADS)&&!defined(IA64)
b->mem_base=GC_get_main_stack_base();
return GC_SUCCESS;
#else
return GC_UNIMPLEMENTED;
#endif
}
#endif
#endif
#ifndef GET_MAIN_STACKBASE_SPECIAL
ptr_t GC_get_main_stack_base(void)
{
struct GC_stack_base sb;
if (GC_get_stack_base(&sb)!=GC_SUCCESS)
ABORT("GC_get_stack_base failed");
GC_ASSERT((word)GC_approx_sp()HOTTER_THAN (word)sb.mem_base);
return (ptr_t)sb.mem_base;
}
#endif
#ifdef OS2
void GC_register_data_segments(void)
{
PTIB ptib;
PPIB ppib;
HMODULE module_handle;
#define PBUFSIZ 512
UCHAR path[PBUFSIZ];
FILE*myexefile;
struct exe_hdr hdrdos;
struct e32_exe hdr386;
struct o32_obj seg;
int nsegs;
#if defined(CPPCHECK)
hdrdos.padding[0]=0;
hdr386.exe_format_level=0;
hdr386.os=0;
hdr386.padding1[0]=0;
hdr386.padding2[0]=0;
seg.pagemap=0;
seg.mapsize=0;
seg.reserved=0;
#endif
if (DosGetInfoBlocks(&ptib,&ppib)!=NO_ERROR){
ABORT("DosGetInfoBlocks failed");
}
module_handle=ppib->pib_hmte;
if (DosQueryModuleName(module_handle,PBUFSIZ,path)!=NO_ERROR){
ABORT("DosQueryModuleName failed");
}
myexefile=fopen(path,"rb");
if (myexefile==0){
ABORT_ARG1("Failed to open executable",":%s",path);
}
if (fread((char*)(&hdrdos),1,sizeof(hdrdos),myexefile)
< sizeof(hdrdos)){
ABORT_ARG1("Could not read MSDOS header"," from:%s",path);
}
if (E_MAGIC(hdrdos)!=EMAGIC){
ABORT_ARG1("Bad DOS magic number"," in file:%s",path);
}
if (fseek(myexefile,E_LFANEW(hdrdos),SEEK_SET)!=0){
ABORT_ARG1("Bad DOS magic number"," in file:%s",path);
}
if (fread((char*)(&hdr386),1,sizeof(hdr386),myexefile)
< sizeof(hdr386)){
ABORT_ARG1("Could not read OS/2 header"," from:%s",path);
}
if (E32_MAGIC1(hdr386)!=E32MAGIC1||E32_MAGIC2(hdr386)!=E32MAGIC2){
ABORT_ARG1("Bad OS/2 magic number"," in file:%s",path);
}
if (E32_BORDER(hdr386)!=E32LEBO||E32_WORDER(hdr386)!=E32LEWO){
ABORT_ARG1("Bad byte order in executable"," file:%s",path);
}
if (E32_CPU(hdr386)==E32CPU286){
ABORT_ARG1("GC cannot handle 80286 executables",":%s",path);
}
if (fseek(myexefile,E_LFANEW(hdrdos)+E32_OBJTAB(hdr386),
SEEK_SET)!=0){
ABORT_ARG1("Seek to object table failed"," in file:%s",path);
}
for (nsegs=E32_OBJCNT(hdr386);nsegs > 0;nsegs--){
int flags;
if (fread((char*)(&seg),1,sizeof(seg),myexefile)< sizeof(seg)){
ABORT_ARG1("Could not read obj table entry"," from file:%s",path);
}
flags=O32_FLAGS(seg);
if (!(flags&OBJWRITE))continue;
if (!(flags&OBJREAD))continue;
if (flags&OBJINVALID){
GC_err_printf("Object with invalid pages?\n");
continue;
}
GC_add_roots_inner((ptr_t)O32_BASE(seg),
(ptr_t)(O32_BASE(seg)+O32_SIZE(seg)),FALSE);
}
(void)fclose(myexefile);
}
#else
#if defined(GWW_VDB)
#ifndef MEM_WRITE_WATCH
#define MEM_WRITE_WATCH 0x200000
#endif
#ifndef WRITE_WATCH_FLAG_RESET
#define WRITE_WATCH_FLAG_RESET 1
#endif
#define GC_ULONG_PTR word
typedef UINT (WINAPI*GetWriteWatch_type)(
DWORD,PVOID,GC_ULONG_PTR,
PVOID*,GC_ULONG_PTR*,PULONG);
static FARPROC GetWriteWatch_func;
static DWORD GetWriteWatch_alloc_flag;
#define GC_GWW_AVAILABLE()(GetWriteWatch_func!=0)
static void detect_GetWriteWatch(void)
{
static GC_bool done;
HMODULE hK32;
if (done)
return;
#if defined(MPROTECT_VDB)
{
char*str=GETENV("GC_USE_GETWRITEWATCH");
#if defined(GC_PREFER_MPROTECT_VDB)
if (str==NULL||(*str=='0'&&*(str+1)=='\0')){
done=TRUE;
return;
}
#else
if (str!=NULL&&*str=='0'&&*(str+1)=='\0'){
done=TRUE;
return;
}
#endif
}
#endif
#ifdef MSWINRT_FLAVOR
{
MEMORY_BASIC_INFORMATION memInfo;
SIZE_T result=VirtualQuery(GetProcAddress,
&memInfo,sizeof(memInfo));
if (result!=sizeof(memInfo))
ABORT("Weird VirtualQuery result");
hK32=(HMODULE)memInfo.AllocationBase;
}
#else
hK32=GetModuleHandle(TEXT("kernel32.dll"));
#endif
if (hK32!=(HMODULE)0&&
(GetWriteWatch_func=GetProcAddress(hK32,"GetWriteWatch"))!=0){
void*page;
GC_ASSERT(GC_page_size!=0);
page=VirtualAlloc(NULL,GC_page_size,MEM_WRITE_WATCH|MEM_RESERVE,
PAGE_READWRITE);
if (page!=NULL){
PVOID pages[16];
GC_ULONG_PTR count=16;
DWORD page_size;
if ((*(GetWriteWatch_type)(word)GetWriteWatch_func)(
WRITE_WATCH_FLAG_RESET,page,
GC_page_size,pages,&count,
&page_size)!=0){
GetWriteWatch_func=0;
} else {
GetWriteWatch_alloc_flag=MEM_WRITE_WATCH;
}
VirtualFree(page,0,MEM_RELEASE);
} else {
GetWriteWatch_func=0;
}
}
#ifndef SMALL_CONFIG
if (!GetWriteWatch_func){
GC_COND_LOG_PRINTF("Did not find a usable GetWriteWatch()\n");
} else {
GC_COND_LOG_PRINTF("Using GetWriteWatch()\n");
}
#endif
done=TRUE;
}
#else
#define GetWriteWatch_alloc_flag 0
#endif
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)
#ifdef MSWIN32
GC_INNER GC_bool GC_no_win32_dlls=FALSE;
GC_INNER GC_bool GC_wnt=FALSE;
GC_INNER void GC_init_win32(void)
{
#if defined(_WIN64)||(defined(_MSC_VER)&&_MSC_VER>=1800)
GC_wnt=TRUE;
#else
DWORD v=GetVersion();
GC_wnt=!(v&0x80000000);
GC_no_win32_dlls|=((!GC_wnt)&&(v&0xff)<=3);
#endif
#ifdef USE_MUNMAP
if (GC_no_win32_dlls){
GC_unmap_threshold=0;
}
#endif
}
STATIC ptr_t GC_least_described_address(ptr_t start)
{
MEMORY_BASIC_INFORMATION buf;
LPVOID limit=GC_sysinfo.lpMinimumApplicationAddress;
ptr_t p=(ptr_t)((word)start&~(GC_page_size - 1));
GC_ASSERT(GC_page_size!=0);
for (;;){
size_t result;
LPVOID q=(LPVOID)(p - GC_page_size);
if ((word)q > (word)p||(word)q < (word)limit)break;
result=VirtualQuery(q,&buf,sizeof(buf));
if (result!=sizeof(buf)||buf.AllocationBase==0)break;
p=(ptr_t)(buf.AllocationBase);
}
return p;
}
#endif
#if defined(USE_WINALLOC)&&!defined(REDIRECT_MALLOC)
STATIC size_t GC_max_root_size=100000;
STATIC struct GC_malloc_heap_list {
void*allocation_base;
struct GC_malloc_heap_list*next;
}*GC_malloc_heap_l=0;
STATIC GC_bool GC_is_malloc_heap_base(void*p)
{
struct GC_malloc_heap_list*q=GC_malloc_heap_l;
while (0!=q){
if (q->allocation_base==p)return TRUE;
q=q->next;
}
return FALSE;
}
STATIC void*GC_get_allocation_base(void*p)
{
MEMORY_BASIC_INFORMATION buf;
size_t result=VirtualQuery(p,&buf,sizeof(buf));
if (result!=sizeof(buf)){
ABORT("Weird VirtualQuery result");
}
return buf.AllocationBase;
}
GC_INNER void GC_add_current_malloc_heap(void)
{
struct GC_malloc_heap_list*new_l=(struct GC_malloc_heap_list*)
malloc(sizeof(struct GC_malloc_heap_list));
void*candidate;
if (NULL==new_l)return;
candidate=GC_get_allocation_base(new_l);
if (GC_is_malloc_heap_base(candidate)){
size_t req_size=10000;
do {
void*p=malloc(req_size);
if (0==p){
free(new_l);
return;
}
candidate=GC_get_allocation_base(p);
free(p);
req_size*=2;
} while (GC_is_malloc_heap_base(candidate)
&&req_size < GC_max_root_size/10&&req_size < 500000);
if (GC_is_malloc_heap_base(candidate)){
free(new_l);
return;
}
}
GC_COND_LOG_PRINTF("Found new system malloc AllocationBase at %p\n",
candidate);
new_l->allocation_base=candidate;
new_l->next=GC_malloc_heap_l;
GC_malloc_heap_l=new_l;
}
STATIC void GC_free_malloc_heap_list(void)
{
struct GC_malloc_heap_list*q=GC_malloc_heap_l;
GC_malloc_heap_l=NULL;
while (q!=NULL){
struct GC_malloc_heap_list*next=q->next;
free(q);
q=next;
}
}
#endif
GC_INNER GC_bool GC_is_heap_base(void*p)
{
int i;
#if defined(USE_WINALLOC)&&!defined(REDIRECT_MALLOC)
if (GC_root_size > GC_max_root_size)
GC_max_root_size=GC_root_size;
if (GC_is_malloc_heap_base(p))
return TRUE;
#endif
for (i=0;i < (int)GC_n_heap_bases;i++){
if (GC_heap_bases[i]==p)return TRUE;
}
return FALSE;
}
#ifdef MSWIN32
STATIC void GC_register_root_section(ptr_t static_root)
{
MEMORY_BASIC_INFORMATION buf;
LPVOID p;
char*base;
char*limit;
if (!GC_no_win32_dlls)return;
p=base=limit=GC_least_described_address(static_root);
while ((word)p < (word)GC_sysinfo.lpMaximumApplicationAddress){
size_t result=VirtualQuery(p,&buf,sizeof(buf));
char*new_limit;
DWORD protect;
if (result!=sizeof(buf)||buf.AllocationBase==0
||GC_is_heap_base(buf.AllocationBase))break;
new_limit=(char*)p+buf.RegionSize;
protect=buf.Protect;
if (buf.State==MEM_COMMIT
&&is_writable(protect)){
if ((char*)p==limit){
limit=new_limit;
} else {
if (base!=limit)GC_add_roots_inner(base,limit,FALSE);
base=(char*)p;
limit=new_limit;
}
}
if ((word)p > (word)new_limit)break;
p=(LPVOID)new_limit;
}
if (base!=limit)GC_add_roots_inner(base,limit,FALSE);
}
#endif
void GC_register_data_segments(void)
{
#ifdef MSWIN32
GC_register_root_section((ptr_t)&GC_pages_executable);
#endif
}
#else
#if (defined(SVR4)||defined(AIX)||defined(DGUX)||(defined(LINUX)&&defined(SPARC)))&&!defined(PCR)
ptr_t GC_SysVGetDataStart(size_t max_page_size,ptr_t etext_addr)
{
word text_end=((word)(etext_addr)+sizeof(word)- 1)
&~(word)(sizeof(word)- 1);
word next_page=((text_end+(word)max_page_size - 1)
&~((word)max_page_size - 1));
word page_offset=(text_end&((word)max_page_size - 1));
volatile ptr_t result=(char*)(next_page+page_offset);
GC_setup_temporary_fault_handler();
if (SETJMP(GC_jmp_buf)==0){
#ifdef AO_HAVE_fetch_and_add
volatile AO_t zero=0;
(void)AO_fetch_and_add((volatile AO_t*)result,zero);
#else
char v=*result;
#if defined(CPPCHECK)
GC_noop1((word)&v);
#endif
*result=v;
#endif
GC_reset_fault_handler();
} else {
GC_reset_fault_handler();
result=(char*)GC_find_limit(DATAEND,FALSE);
}
return ( ptr_t)result;
}
#endif
#ifdef DATASTART_USES_BSDGETDATASTART
GC_INNER ptr_t GC_FreeBSDGetDataStart(size_t max_page_size,
ptr_t etext_addr)
{
word text_end=((word)(etext_addr)+sizeof(word)- 1)
&~(word)(sizeof(word)- 1);
volatile word next_page=(text_end+(word)max_page_size - 1)
&~((word)max_page_size - 1);
volatile ptr_t result=(ptr_t)text_end;
GC_setup_temporary_fault_handler();
if (SETJMP(GC_jmp_buf)==0){
for (;next_page < (word)DATAEND;next_page+=(word)max_page_size)
*(volatile char*)next_page;
GC_reset_fault_handler();
} else {
GC_reset_fault_handler();
result=(ptr_t)GC_find_limit(DATAEND,FALSE);
}
return(result);
}
#endif
#ifdef AMIGA
#define GC_AMIGA_DS
#undef GC_AMIGA_DS
#elif defined(OPENBSD)
void GC_register_data_segments(void)
{
ptr_t region_start=DATASTART;
if ((word)region_start - 1U>=(word)DATAEND)
ABORT_ARG2("Wrong DATASTART/END pair",
":%p .. %p",(void*)region_start,(void*)DATAEND);
for (;;){
#ifdef GC_OPENBSD_UTHREADS
ptr_t region_end=GC_find_limit_openbsd(region_start,DATAEND);
#else
ptr_t region_end=GC_find_limit_with_bound(region_start,TRUE,DATAEND);
#endif
GC_add_roots_inner(region_start,region_end,FALSE);
if ((word)region_end>=(word)DATAEND)
break;
region_start=GC_skip_hole_openbsd(region_end,DATAEND);
}
}
#else
#if!defined(PCR)&&!defined(MACOS)&&defined(REDIRECT_MALLOC)&&defined(GC_SOLARIS_THREADS)
EXTERN_C_BEGIN
extern caddr_t sbrk(int);
EXTERN_C_END
#endif
void GC_register_data_segments(void)
{
#if!defined(PCR)&&!defined(MACOS)
#if defined(REDIRECT_MALLOC)&&defined(GC_SOLARIS_THREADS)
GC_ASSERT(DATASTART);
{
ptr_t p=(ptr_t)sbrk(0);
if ((word)DATASTART < (word)p)
GC_add_roots_inner(DATASTART,p,FALSE);
}
#else
if ((word)DATASTART - 1U>=(word)DATAEND){
ABORT_ARG2("Wrong DATASTART/END pair",
":%p .. %p",(void*)DATASTART,(void*)DATAEND);
}
GC_add_roots_inner(DATASTART,DATAEND,FALSE);
#ifdef GC_HAVE_DATAREGION2
if ((word)DATASTART2 - 1U>=(word)DATAEND2)
ABORT_ARG2("Wrong DATASTART/END2 pair",
":%p .. %p",(void*)DATASTART2,(void*)DATAEND2);
GC_add_roots_inner(DATASTART2,DATAEND2,FALSE);
#endif
#endif
#endif
#if defined(MACOS)
{
#if defined(THINK_C)
extern void*GC_MacGetDataStart(void);
GC_add_roots_inner((ptr_t)GC_MacGetDataStart(),
(ptr_t)LMGetCurrentA5(),FALSE);
#else
#if defined(__MWERKS__)
#if!__POWERPC__
extern void*GC_MacGetDataStart(void);
#if __option(far_data)
extern void*GC_MacGetDataEnd(void);
#endif
GC_add_roots_inner((ptr_t)GC_MacGetDataStart(),
(ptr_t)LMGetCurrentA5(),FALSE);
#if __option(far_data)
GC_add_roots_inner((ptr_t)LMGetCurrentA5(),
(ptr_t)GC_MacGetDataEnd(),FALSE);
#endif
#else
extern char __data_start__[],__data_end__[];
GC_add_roots_inner((ptr_t)&__data_start__,
(ptr_t)&__data_end__,FALSE);
#endif
#endif
#endif
}
#endif
}
#endif
#endif
#endif
#if!defined(OS2)&&!defined(PCR)&&!defined(AMIGA)&&!defined(USE_WINALLOC)&&!defined(MACOS)&&!defined(DOS4GW)&&!defined(NINTENDO_SWITCH)&&!defined(NONSTOP)&&!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PS3)&&!defined(SN_TARGET_PSP2)&&!defined(RTEMS)&&!defined(__CC_ARM)
#define SBRK_ARG_T ptrdiff_t
#if defined(MMAP_SUPPORTED)
#ifdef USE_MMAP_FIXED
#define GC_MMAP_FLAGS MAP_FIXED|MAP_PRIVATE
#else
#define GC_MMAP_FLAGS MAP_PRIVATE
#endif
#ifdef USE_MMAP_ANON
#define zero_fd -1
#if defined(MAP_ANONYMOUS)&&!defined(CPPCHECK)
#define OPT_MAP_ANON MAP_ANONYMOUS
#else
#define OPT_MAP_ANON MAP_ANON
#endif
#else
static int zero_fd=-1;
#define OPT_MAP_ANON 0
#endif
#ifndef MSWIN_XBOX1
#if defined(SYMBIAN)&&!defined(USE_MMAP_ANON)
EXTERN_C_BEGIN
extern char*GC_get_private_path_and_zero_file(void);
EXTERN_C_END
#endif
STATIC ptr_t GC_unix_mmap_get_mem(size_t bytes)
{
void*result;
static ptr_t last_addr=HEAP_START;
#ifndef USE_MMAP_ANON
static GC_bool initialized=FALSE;
if (!EXPECT(initialized,TRUE)){
#ifdef SYMBIAN
char*path=GC_get_private_path_and_zero_file();
if (path!=NULL){
zero_fd=open(path,O_RDWR|O_CREAT,0644);
free(path);
}
#else
zero_fd=open("/dev/zero",O_RDONLY);
#endif
if (zero_fd==-1)
ABORT("Could not open/dev/zero");
if (fcntl(zero_fd,F_SETFD,FD_CLOEXEC)==-1)
WARN("Could not set FD_CLOEXEC for/dev/zero\n",0);
initialized=TRUE;
}
#endif
GC_ASSERT(GC_page_size!=0);
if (bytes&(GC_page_size - 1))ABORT("Bad GET_MEM arg");
result=mmap(last_addr,bytes,(PROT_READ|PROT_WRITE)
|(GC_pages_executable?PROT_EXEC:0),
GC_MMAP_FLAGS|OPT_MAP_ANON,zero_fd,0);
#undef IGNORE_PAGES_EXECUTABLE
if (EXPECT(MAP_FAILED==result,FALSE)){
if (HEAP_START==last_addr&&GC_pages_executable&&EACCES==errno)
ABORT("Cannot allocate executable pages");
return NULL;
}
last_addr=(ptr_t)(((word)result+bytes+GC_page_size - 1)
&~(GC_page_size - 1));
#if!defined(LINUX)
if (last_addr==0){
munmap(result,~GC_page_size - (size_t)result+1);
return GC_unix_mmap_get_mem(bytes);
}
#else
GC_ASSERT(last_addr!=0);
#endif
if (((word)result % HBLKSIZE)!=0)
ABORT(
"GC_unix_get_mem:Memory returned by mmap is not aligned to HBLKSIZE.");
return((ptr_t)result);
}
#endif
#endif
#if defined(USE_MMAP)
ptr_t GC_unix_get_mem(size_t bytes)
{
return GC_unix_mmap_get_mem(bytes);
}
#else
STATIC ptr_t GC_unix_sbrk_get_mem(size_t bytes)
{
ptr_t result;
#ifdef IRIX5
__LOCK_MALLOC();
#endif
{
ptr_t cur_brk=(ptr_t)sbrk(0);
SBRK_ARG_T lsbs=(word)cur_brk&(GC_page_size-1);
GC_ASSERT(GC_page_size!=0);
if ((SBRK_ARG_T)bytes < 0){
result=0;
goto out;
}
if (lsbs!=0){
if((ptr_t)sbrk((SBRK_ARG_T)GC_page_size - lsbs)==(ptr_t)(-1)){
result=0;
goto out;
}
}
#ifdef ADD_HEAP_GUARD_PAGES
{
ptr_t guard=(ptr_t)sbrk((SBRK_ARG_T)GC_page_size);
if (mprotect(guard,GC_page_size,PROT_NONE)!=0)
ABORT("ADD_HEAP_GUARD_PAGES:mprotect failed");
}
#endif
result=(ptr_t)sbrk((SBRK_ARG_T)bytes);
if (result==(ptr_t)(-1))result=0;
}
out:
#ifdef IRIX5
__UNLOCK_MALLOC();
#endif
return(result);
}
ptr_t GC_unix_get_mem(size_t bytes)
{
#if defined(MMAP_SUPPORTED)
static GC_bool sbrk_failed=FALSE;
ptr_t result=0;
if (GC_pages_executable){
return GC_unix_mmap_get_mem(bytes);
}
if (!sbrk_failed)result=GC_unix_sbrk_get_mem(bytes);
if (0==result){
sbrk_failed=TRUE;
result=GC_unix_mmap_get_mem(bytes);
}
if (0==result){
result=GC_unix_sbrk_get_mem(bytes);
}
return result;
#else
return GC_unix_sbrk_get_mem(bytes);
#endif
}
#endif
#endif
#ifdef OS2
void*os2_alloc(size_t bytes)
{
void*result;
if (DosAllocMem(&result,bytes,(PAG_READ|PAG_WRITE|PAG_COMMIT)
|(GC_pages_executable?PAG_EXECUTE:0))
!=NO_ERROR){
return(0);
}
if (result==0)return(os2_alloc(bytes));
return(result);
}
#endif
#ifdef MSWIN_XBOX1
ptr_t GC_durango_get_mem(size_t bytes)
{
if (0==bytes)return NULL;
return (ptr_t)VirtualAlloc(NULL,bytes,MEM_COMMIT|MEM_TOP_DOWN,
PAGE_READWRITE);
}
#elif defined(MSWINCE)
ptr_t GC_wince_get_mem(size_t bytes)
{
ptr_t result=0;
word i;
GC_ASSERT(GC_page_size!=0);
bytes=ROUNDUP_PAGESIZE(bytes);
for (i=0;i < GC_n_heap_bases;i++){
if (((word)(-(signed_word)GC_heap_lengths[i])
&(GC_sysinfo.dwAllocationGranularity-1))
>=bytes){
result=GC_heap_bases[i]+GC_heap_lengths[i];
break;
}
}
if (i==GC_n_heap_bases){
size_t res_bytes=
SIZET_SAT_ADD(bytes,(size_t)GC_sysinfo.dwAllocationGranularity-1)
&~((size_t)GC_sysinfo.dwAllocationGranularity-1);
result=(ptr_t)VirtualAlloc(NULL,res_bytes,
MEM_RESERVE|MEM_TOP_DOWN,
GC_pages_executable?PAGE_EXECUTE_READWRITE:
PAGE_READWRITE);
if (HBLKDISPL(result)!=0)ABORT("Bad VirtualAlloc result");
if (GC_n_heap_bases>=MAX_HEAP_SECTS)ABORT("Too many heap sections");
if (result==NULL)return NULL;
GC_heap_bases[GC_n_heap_bases]=result;
GC_heap_lengths[GC_n_heap_bases]=0;
GC_n_heap_bases++;
}
result=(ptr_t)VirtualAlloc(result,bytes,MEM_COMMIT,
GC_pages_executable?PAGE_EXECUTE_READWRITE:
PAGE_READWRITE);
#undef IGNORE_PAGES_EXECUTABLE
if (result!=NULL){
if (HBLKDISPL(result)!=0)ABORT("Bad VirtualAlloc result");
GC_heap_lengths[i]+=bytes;
}
return(result);
}
#elif (defined(USE_WINALLOC)&&!defined(MSWIN_XBOX1))||defined(CYGWIN32)
#ifdef USE_GLOBAL_ALLOC
#define GLOBAL_ALLOC_TEST 1
#else
#define GLOBAL_ALLOC_TEST GC_no_win32_dlls
#endif
#if (defined(GC_USE_MEM_TOP_DOWN)&&defined(USE_WINALLOC))||defined(CPPCHECK)
DWORD GC_mem_top_down=MEM_TOP_DOWN;
#else
#define GC_mem_top_down 0
#endif
ptr_t GC_win32_get_mem(size_t bytes)
{
ptr_t result;
#ifndef USE_WINALLOC
result=GC_unix_get_mem(bytes);
#else
#if defined(MSWIN32)&&!defined(MSWINRT_FLAVOR)
if (GLOBAL_ALLOC_TEST){
result=(ptr_t)GlobalAlloc(0,SIZET_SAT_ADD(bytes,HBLKSIZE));
result=(ptr_t)(((word)result+HBLKSIZE - 1)
&~(word)(HBLKSIZE - 1));
} else
#endif
{
#ifdef MPROTECT_VDB
#ifdef GWW_VDB
#define VIRTUAL_ALLOC_PAD (GC_GWW_AVAILABLE()?0:1)
#else
#define VIRTUAL_ALLOC_PAD 1
#endif
#else
#define VIRTUAL_ALLOC_PAD 0
#endif
result=(ptr_t)VirtualAlloc(NULL,
SIZET_SAT_ADD(bytes,VIRTUAL_ALLOC_PAD),
GetWriteWatch_alloc_flag
|(MEM_COMMIT|MEM_RESERVE)
|GC_mem_top_down,
GC_pages_executable?PAGE_EXECUTE_READWRITE:
PAGE_READWRITE);
#undef IGNORE_PAGES_EXECUTABLE
}
#endif
if (HBLKDISPL(result)!=0)ABORT("Bad VirtualAlloc result");
if (GC_n_heap_bases>=MAX_HEAP_SECTS)ABORT("Too many heap sections");
if (0!=result)GC_heap_bases[GC_n_heap_bases++]=result;
return(result);
}
#endif
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)||defined(MSWIN_XBOX1)
GC_API void GC_CALL GC_win32_free_heap(void)
{
#if defined(USE_WINALLOC)&&!defined(REDIRECT_MALLOC)&&!defined(MSWIN_XBOX1)
GC_free_malloc_heap_list();
#endif
#if (defined(USE_WINALLOC)&&!defined(MSWIN_XBOX1)&&!defined(MSWINCE))||defined(CYGWIN32)
#ifndef MSWINRT_FLAVOR
#ifndef CYGWIN32
if (GLOBAL_ALLOC_TEST)
#endif
{
while (GC_n_heap_bases--> 0){
#ifdef CYGWIN32
#else
GlobalFree(GC_heap_bases[GC_n_heap_bases]);
#endif
GC_heap_bases[GC_n_heap_bases]=0;
}
return;
}
#endif
#ifndef CYGWIN32
while (GC_n_heap_bases > 0){
VirtualFree(GC_heap_bases[--GC_n_heap_bases],0,MEM_RELEASE);
GC_heap_bases[GC_n_heap_bases]=0;
}
#endif
#endif
}
#endif
#ifdef AMIGA
#define GC_AMIGA_AM
#undef GC_AMIGA_AM
#endif
#if defined(HAIKU)
#include <stdlib.h>
ptr_t GC_haiku_get_mem(size_t bytes)
{
void*mem;
GC_ASSERT(GC_page_size!=0);
if (posix_memalign(&mem,GC_page_size,bytes)==0)
return mem;
return NULL;
}
#endif
#ifdef USE_MUNMAP
#if!defined(NN_PLATFORM_CTR)&&!defined(MSWIN32)&&!defined(MSWINCE)&&!defined(MSWIN_XBOX1)
#include <unistd.h>
#ifdef SN_TARGET_PS3
#include <sys/memory.h>
#else
#include <sys/mman.h>
#endif
#include <sys/stat.h>
#include <sys/types.h>
#endif
STATIC ptr_t GC_unmap_start(ptr_t start,size_t bytes)
{
ptr_t result=(ptr_t)(((word)start+GC_page_size - 1)
&~(GC_page_size - 1));
GC_ASSERT(GC_page_size!=0);
if ((word)(result+GC_page_size)> (word)(start+bytes))return 0;
return result;
}
GC_INNER void GC_unmap(ptr_t start,size_t bytes)
{
ptr_t start_addr=GC_unmap_start(start,bytes);
ptr_t end_addr=GC_unmap_end(start,bytes);
word len=end_addr - start_addr;
if (0==start_addr)return;
#ifdef USE_WINALLOC
while (len!=0){
MEMORY_BASIC_INFORMATION mem_info;
word free_len;
if (VirtualQuery(start_addr,&mem_info,sizeof(mem_info))
!=sizeof(mem_info))
ABORT("Weird VirtualQuery result");
free_len=(len < mem_info.RegionSize)?len:mem_info.RegionSize;
if (!VirtualFree(start_addr,free_len,MEM_DECOMMIT))
ABORT("VirtualFree failed");
GC_unmapped_bytes+=free_len;
start_addr+=free_len;
len-=free_len;
}
#elif defined(SN_TARGET_PS3)
ps3_free_mem(start_addr,len);
#else
{
#if defined(AIX)||defined(CYGWIN32)||defined(HAIKU)||defined(HPUX)
if (mprotect(start_addr,len,PROT_NONE))
ABORT("mprotect(PROT_NONE)failed");
#elif defined(__EMSCRIPTEN__)
#else
void*result=mmap(start_addr,len,PROT_NONE,
MAP_PRIVATE|MAP_FIXED|OPT_MAP_ANON,
zero_fd,0);
if (result!=(void*)start_addr)
ABORT("mmap(PROT_NONE)failed");
#if defined(CPPCHECK)||defined(LINT2)
GC_noop1((word)result);
#endif
#endif
}
GC_unmapped_bytes+=len;
#endif
}
GC_INNER void GC_remap(ptr_t start,size_t bytes)
{
ptr_t start_addr=GC_unmap_start(start,bytes);
ptr_t end_addr=GC_unmap_end(start,bytes);
word len=end_addr - start_addr;
if (0==start_addr)return;
#ifdef USE_WINALLOC
while (len!=0){
MEMORY_BASIC_INFORMATION mem_info;
word alloc_len;
ptr_t result;
if (VirtualQuery(start_addr,&mem_info,sizeof(mem_info))
!=sizeof(mem_info))
ABORT("Weird VirtualQuery result");
alloc_len=(len < mem_info.RegionSize)?len:mem_info.RegionSize;
result=(ptr_t)VirtualAlloc(start_addr,alloc_len,MEM_COMMIT,
GC_pages_executable
?PAGE_EXECUTE_READWRITE
:PAGE_READWRITE);
if (result!=start_addr){
if (GetLastError()==ERROR_NOT_ENOUGH_MEMORY||
GetLastError()==ERROR_OUTOFMEMORY){
ABORT("Not enough memory to process remapping");
} else {
ABORT("VirtualAlloc remapping failed");
}
}
#ifdef LINT2
GC_noop1((word)result);
#endif
GC_unmapped_bytes-=alloc_len;
start_addr+=alloc_len;
len-=alloc_len;
}
#else
{
#if defined(NACL)||defined(NETBSD)
void*result=mmap(start_addr,len,(PROT_READ|PROT_WRITE)
|(GC_pages_executable?PROT_EXEC:0),
MAP_PRIVATE|MAP_FIXED|OPT_MAP_ANON,
zero_fd,0);
if (result!=(void*)start_addr)
ABORT("mmap as mprotect failed");
#if defined(CPPCHECK)||defined(LINT2)
GC_noop1((word)result);
#endif
#else
if (mprotect(start_addr,len,(PROT_READ|PROT_WRITE)
|(GC_pages_executable?PROT_EXEC:0))!=0){
ABORT_ARG3("mprotect remapping failed",
" at %p (length %lu),errcode=%d",
(void*)start_addr,(unsigned long)len,errno);
}
#endif
}
#undef IGNORE_PAGES_EXECUTABLE
GC_unmapped_bytes-=len;
#endif
}
GC_INNER void GC_unmap_gap(ptr_t start1,size_t bytes1,ptr_t start2,
size_t bytes2)
{
ptr_t start1_addr=GC_unmap_start(start1,bytes1);
ptr_t end1_addr=GC_unmap_end(start1,bytes1);
ptr_t start2_addr=GC_unmap_start(start2,bytes2);
ptr_t start_addr=end1_addr;
ptr_t end_addr=start2_addr;
size_t len;
GC_ASSERT(start1+bytes1==start2);
if (0==start1_addr)start_addr=GC_unmap_start(start1,bytes1+bytes2);
if (0==start2_addr)end_addr=GC_unmap_end(start1,bytes1+bytes2);
if (0==start_addr)return;
len=end_addr - start_addr;
#ifdef USE_WINALLOC
while (len!=0){
MEMORY_BASIC_INFORMATION mem_info;
word free_len;
if (VirtualQuery(start_addr,&mem_info,sizeof(mem_info))
!=sizeof(mem_info))
ABORT("Weird VirtualQuery result");
free_len=(len < mem_info.RegionSize)?len:mem_info.RegionSize;
if (!VirtualFree(start_addr,free_len,MEM_DECOMMIT))
ABORT("VirtualFree failed");
GC_unmapped_bytes+=free_len;
start_addr+=free_len;
len-=free_len;
}
#else
if (len!=0){
#if defined(AIX)||defined(CYGWIN32)||defined(HAIKU)||defined(HPUX)
if (mprotect(start_addr,len,PROT_NONE))
ABORT("mprotect(PROT_NONE)failed");
#else
void*result=mmap(start_addr,len,PROT_NONE,
MAP_PRIVATE|MAP_FIXED|OPT_MAP_ANON,
zero_fd,0);
if (result!=(void*)start_addr)
ABORT("mmap(PROT_NONE)failed");
#if defined(CPPCHECK)||defined(LINT2)
GC_noop1((word)result);
#endif
#endif
GC_unmapped_bytes+=len;
}
#endif
}
#endif
#ifndef THREADS
#if defined(__EMSCRIPTEN__)
static void scan_regs_cb(void*begin,void*end)
{
GC_push_all_stack((ptr_t)begin,(ptr_t)end);
}
STATIC void GC_CALLBACK GC_default_push_other_roots(void)
{
emscripten_scan_registers(scan_regs_cb);
}
#else
#define GC_default_push_other_roots 0
#endif
#else
#ifdef PCR
PCR_ERes GC_push_thread_stack(PCR_Th_T*t,PCR_Any dummy)
{
struct PCR_ThCtl_TInfoRep info;
PCR_ERes result;
info.ti_stkLow=info.ti_stkHi=0;
result=PCR_ThCtl_GetInfo(t,&info);
GC_push_all_stack((ptr_t)(info.ti_stkLow),(ptr_t)(info.ti_stkHi));
return(result);
}
PCR_ERes GC_push_old_obj(void*p,size_t size,PCR_Any data)
{
GC_push_all_stack((ptr_t)p,(ptr_t)p+size);
return(PCR_ERes_okay);
}
extern struct PCR_MM_ProcsRep*GC_old_allocator;
STATIC void GC_CALLBACK GC_default_push_other_roots(void)
{
if ((*(GC_old_allocator->mmp_enumerate))(PCR_Bool_false,
GC_push_old_obj,0)
!=PCR_ERes_okay){
ABORT("Old object enumeration failed");
}
if (PCR_ERes_IsErr(
PCR_ThCtl_ApplyToAllOtherThreads(GC_push_thread_stack,0))
||PCR_ERes_IsErr(GC_push_thread_stack(PCR_Th_CurrThread(),0))){
ABORT("Thread stack marking failed");
}
}
#elif defined(SN_TARGET_PS3)
STATIC void GC_CALLBACK GC_default_push_other_roots(void)
{
ABORT("GC_default_push_other_roots is not implemented");
}
void GC_push_thread_structures(void)
{
ABORT("GC_push_thread_structures is not implemented");
}
#else
STATIC void GC_CALLBACK GC_default_push_other_roots(void)
{
GC_push_all_stacks();
}
#endif
#endif
GC_push_other_roots_proc GC_push_other_roots=GC_default_push_other_roots;
GC_API void GC_CALL GC_set_push_other_roots(GC_push_other_roots_proc fn)
{
GC_push_other_roots=fn;
}
GC_API GC_push_other_roots_proc GC_CALL GC_get_push_other_roots(void)
{
return GC_push_other_roots;
}
#if (defined(CHECKSUMS)&&defined(GWW_VDB))||defined(PROC_VDB)
STATIC void GC_or_pages(page_hash_table pht1,page_hash_table pht2)
{
unsigned i;
for (i=0;i < PHT_SIZE;i++)pht1[i]|=pht2[i];
}
#endif
#ifdef GWW_VDB
#define GC_GWW_BUF_LEN (MAXHINCR*HBLKSIZE/4096)
static PVOID gww_buf[GC_GWW_BUF_LEN];
#ifndef MPROTECT_VDB
#define GC_gww_dirty_init GC_dirty_init
#endif
GC_INNER GC_bool GC_gww_dirty_init(void)
{
detect_GetWriteWatch();
return GC_GWW_AVAILABLE();
}
GC_INLINE void GC_gww_read_dirty(GC_bool output_unneeded)
{
word i;
if (!output_unneeded)
BZERO(GC_grungy_pages,sizeof(GC_grungy_pages));
for (i=0;i!=GC_n_heap_sects;++i){
GC_ULONG_PTR count;
do {
PVOID*pages=gww_buf;
DWORD page_size;
count=GC_GWW_BUF_LEN;
if ((*(GetWriteWatch_type)(word)GetWriteWatch_func)(
WRITE_WATCH_FLAG_RESET,
GC_heap_sects[i].hs_start,
GC_heap_sects[i].hs_bytes,
pages,&count,&page_size)!=0){
static int warn_count=0;
struct hblk*start=(struct hblk*)GC_heap_sects[i].hs_start;
static struct hblk*last_warned=0;
size_t nblocks=divHBLKSZ(GC_heap_sects[i].hs_bytes);
if (i!=0&&last_warned!=start&&warn_count++< 5){
last_warned=start;
WARN("GC_gww_read_dirty unexpectedly failed at %p:"
"Falling back to marking all pages dirty\n",start);
}
if (!output_unneeded){
unsigned j;
for (j=0;j < nblocks;++j){
word hash=PHT_HASH(start+j);
set_pht_entry_from_index(GC_grungy_pages,hash);
}
}
count=1;
} else if (!output_unneeded){
PVOID*pages_end=pages+count;
while (pages!=pages_end){
struct hblk*h=(struct hblk*)*pages++;
struct hblk*h_end=(struct hblk*)((char*)h+page_size);
do {
set_pht_entry_from_index(GC_grungy_pages,PHT_HASH(h));
} while ((word)(++h)< (word)h_end);
}
}
} while (count==GC_GWW_BUF_LEN);
}
#ifdef CHECKSUMS
GC_ASSERT(!output_unneeded);
GC_or_pages(GC_written_pages,GC_grungy_pages);
#endif
}
#else
#define GC_GWW_AVAILABLE()FALSE
#endif
#ifdef DEFAULT_VDB
GC_INNER GC_bool GC_dirty_init(void)
{
GC_VERBOSE_LOG_PRINTF("Initializing DEFAULT_VDB...\n");
return TRUE;
}
#endif
#ifndef GC_DISABLE_INCREMENTAL
#if!defined(THREADS)||defined(HAVE_LOCKFREE_AO_OR)
#define async_set_pht_entry_from_index(db,index)set_pht_entry_from_index_concurrent(db,index)
#elif defined(AO_HAVE_test_and_set_acquire)
GC_INNER volatile AO_TS_t GC_fault_handler_lock=AO_TS_INITIALIZER;
static void async_set_pht_entry_from_index(volatile page_hash_table db,
size_t index)
{
GC_acquire_dirty_lock();
set_pht_entry_from_index(db,index);
GC_release_dirty_lock();
}
#else
#error No test_and_set operation:Introduces a race.
#endif
#endif
#ifdef MPROTECT_VDB
#ifdef DARWIN
#include <mach/vm_map.h>
STATIC mach_port_t GC_task_self=0;
#define PROTECT(addr,len)if (vm_protect(GC_task_self,(vm_address_t)(addr),(vm_size_t)(len),FALSE,VM_PROT_READ|(GC_pages_executable?VM_PROT_EXECUTE:0))==KERN_SUCCESS){} else ABORT("vm_protect(PROTECT)failed")
#define UNPROTECT(addr,len)if (vm_protect(GC_task_self,(vm_address_t)(addr),(vm_size_t)(len),FALSE,(VM_PROT_READ|VM_PROT_WRITE)|(GC_pages_executable?VM_PROT_EXECUTE:0))==KERN_SUCCESS){} else ABORT("vm_protect(UNPROTECT)failed")
#elif!defined(USE_WINALLOC)
#include <sys/mman.h>
#include <signal.h>
#if!defined(CYGWIN32)&&!defined(HAIKU)
#include <sys/syscall.h>
#endif
#define PROTECT(addr,len)if (mprotect((caddr_t)(addr),(size_t)(len),PROT_READ|(GC_pages_executable?PROT_EXEC:0))>=0){ } else ABORT("mprotect failed")
#define UNPROTECT(addr,len)if (mprotect((caddr_t)(addr),(size_t)(len),(PROT_READ|PROT_WRITE)|(GC_pages_executable?PROT_EXEC:0))>=0){ } else ABORT(GC_pages_executable?"un-mprotect executable page failed" " (probably disabled by OS)":"un-mprotect failed")
#undef IGNORE_PAGES_EXECUTABLE
#else
#ifndef MSWINCE
#include <signal.h>
#endif
static DWORD protect_junk;
#define PROTECT(addr,len)if (VirtualProtect((addr),(len),GC_pages_executable?PAGE_EXECUTE_READ:PAGE_READONLY,&protect_junk)){ } else ABORT_ARG1("VirtualProtect failed",":errcode=0x%X",(unsigned)GetLastError())
#define UNPROTECT(addr,len)if (VirtualProtect((addr),(len),GC_pages_executable?PAGE_EXECUTE_READWRITE:PAGE_READWRITE,&protect_junk)){ } else ABORT("un-VirtualProtect failed")
#endif
#if defined(MSWIN32)
typedef LPTOP_LEVEL_EXCEPTION_FILTER SIG_HNDLR_PTR;
#undef SIG_DFL
#define SIG_DFL (LPTOP_LEVEL_EXCEPTION_FILTER)((signed_word)-1)
#elif defined(MSWINCE)
typedef LONG (WINAPI*SIG_HNDLR_PTR)(struct _EXCEPTION_POINTERS*);
#undef SIG_DFL
#define SIG_DFL (SIG_HNDLR_PTR)(-1)
#elif defined(DARWIN)
typedef void (*SIG_HNDLR_PTR)();
#else
typedef void (*SIG_HNDLR_PTR)(int,siginfo_t*,void*);
typedef void (*PLAIN_HNDLR_PTR)(int);
#endif
#if defined(__GLIBC__)
#if __GLIBC__ < 2||__GLIBC__==2&&__GLIBC_MINOR__ < 2
#error glibc too old?
#endif
#endif
#ifndef DARWIN
STATIC SIG_HNDLR_PTR GC_old_segv_handler=0;
#if defined(FREEBSD)||defined(HPUX)||defined(HURD)||defined(LINUX)
STATIC SIG_HNDLR_PTR GC_old_bus_handler=0;
#ifndef LINUX
STATIC GC_bool GC_old_bus_handler_used_si=FALSE;
#endif
#endif
#if!defined(MSWIN32)&&!defined(MSWINCE)
STATIC GC_bool GC_old_segv_handler_used_si=FALSE;
#endif
#endif
#ifdef THREADS
GC_ATTR_NO_SANITIZE_THREAD
static GC_bool is_header_found_async(void*addr)
{
#ifdef HASH_TL
hdr*result;
GET_HDR((ptr_t)addr,result);
return result!=NULL;
#else
return HDR_INNER(addr)!=NULL;
#endif
}
#else
#define is_header_found_async(addr)(HDR(addr)!=NULL)
#endif
#ifndef DARWIN
#if!defined(MSWIN32)&&!defined(MSWINCE)
#include <errno.h>
#if defined(FREEBSD)||defined(HURD)||defined(HPUX)
#define SIG_OK (sig==SIGBUS||sig==SIGSEGV)
#else
#define SIG_OK (sig==SIGSEGV)
#endif
#if defined(FREEBSD)
#ifndef SEGV_ACCERR
#define SEGV_ACCERR 2
#endif
#if defined(AARCH64)||defined(ARM32)||defined(MIPS)
#define CODE_OK (si->si_code==SEGV_ACCERR)
#elif defined(POWERPC)
#define AIM
#include <machine/trap.h>
#define CODE_OK (si->si_code==EXC_DSI||si->si_code==SEGV_ACCERR)
#else
#define CODE_OK (si->si_code==BUS_PAGE_FAULT||si->si_code==SEGV_ACCERR)
#endif
#elif defined(OSF1)
#define CODE_OK (si->si_code==2)
#elif defined(IRIX5)
#define CODE_OK (si->si_code==EACCES)
#elif defined(CYGWIN32)||defined(HAIKU)||defined(HURD)
#define CODE_OK TRUE
#elif defined(LINUX)
#define CODE_OK TRUE
#elif defined(HPUX)
#define CODE_OK (si->si_code==SEGV_ACCERR||si->si_code==BUS_ADRERR||si->si_code==BUS_UNKNOWN||si->si_code==SEGV_UNKNOWN||si->si_code==BUS_OBJERR)
#elif defined(SUNOS5SIGS)
#define CODE_OK (si->si_code==SEGV_ACCERR)
#endif
#ifndef NO_GETCONTEXT
#include <ucontext.h>
#endif
STATIC void GC_write_fault_handler(int sig,siginfo_t*si,void*raw_sc)
#else
#define SIG_OK (exc_info->ExceptionRecord->ExceptionCode==STATUS_ACCESS_VIOLATION)
#define CODE_OK (exc_info->ExceptionRecord->ExceptionInformation[0]==1)
STATIC LONG WINAPI GC_write_fault_handler(
struct _EXCEPTION_POINTERS*exc_info)
#endif
{
#if!defined(MSWIN32)&&!defined(MSWINCE)
char*addr=(char*)si->si_addr;
#else
char*addr=(char*)(exc_info->ExceptionRecord
->ExceptionInformation[1]);
#endif
if (SIG_OK&&CODE_OK){
struct hblk*h=(struct hblk*)((word)addr&~(GC_page_size-1));
GC_bool in_allocd_block;
size_t i;
GC_ASSERT(GC_page_size!=0);
#ifdef CHECKSUMS
GC_record_fault(h);
#endif
#ifdef SUNOS5SIGS
in_allocd_block=FALSE;
for (i=0;i < divHBLKSZ(GC_page_size);i++){
if (is_header_found_async(&h[i])){
in_allocd_block=TRUE;
break;
}
}
#else
in_allocd_block=is_header_found_async(addr);
#endif
if (!in_allocd_block){
SIG_HNDLR_PTR old_handler;
#if defined(MSWIN32)||defined(MSWINCE)
old_handler=GC_old_segv_handler;
#else
GC_bool used_si;
#if defined(FREEBSD)||defined(HURD)||defined(HPUX)
if (sig==SIGBUS){
old_handler=GC_old_bus_handler;
used_si=GC_old_bus_handler_used_si;
} else
#endif
{
old_handler=GC_old_segv_handler;
used_si=GC_old_segv_handler_used_si;
}
#endif
if (old_handler==(SIG_HNDLR_PTR)(signed_word)SIG_DFL){
#if!defined(MSWIN32)&&!defined(MSWINCE)
ABORT_ARG1("Unexpected bus error or segmentation fault",
" at %p",(void*)addr);
#else
return(EXCEPTION_CONTINUE_SEARCH);
#endif
} else {
#if defined(MSWIN32)||defined(MSWINCE)
return((*old_handler)(exc_info));
#else
if (used_si)
((SIG_HNDLR_PTR)old_handler)(sig,si,raw_sc);
else
((PLAIN_HNDLR_PTR)(signed_word)old_handler)(sig);
return;
#endif
}
}
UNPROTECT(h,GC_page_size);
for (i=0;i < divHBLKSZ(GC_page_size);i++){
word index=PHT_HASH(h+i);
async_set_pht_entry_from_index(GC_dirty_pages,index);
}
#if defined(MSWIN32)||defined(MSWINCE)
return(EXCEPTION_CONTINUE_EXECUTION);
#else
return;
#endif
}
#if defined(MSWIN32)||defined(MSWINCE)
return EXCEPTION_CONTINUE_SEARCH;
#else
ABORT_ARG1("Unexpected bus error or segmentation fault",
" at %p",(void*)addr);
#endif
}
#if defined(GC_WIN32_THREADS)&&!defined(CYGWIN32)
GC_INNER void GC_set_write_fault_handler(void)
{
SetUnhandledExceptionFilter(GC_write_fault_handler);
}
#endif
#endif
#if!defined(DARWIN)
GC_INNER GC_bool GC_dirty_init(void)
{
#if!defined(MSWIN32)&&!defined(MSWINCE)
struct sigaction act,oldact;
act.sa_flags=SA_RESTART|SA_SIGINFO;
act.sa_sigaction=GC_write_fault_handler;
(void)sigemptyset(&act.sa_mask);
#if defined(THREADS)&&!defined(GC_OPENBSD_UTHREADS)&&!defined(GC_WIN32_THREADS)&&!defined(NACL)
(void)sigaddset(&act.sa_mask,GC_get_suspend_signal());
#endif
#endif
GC_VERBOSE_LOG_PRINTF(
"Initializing mprotect virtual dirty bit implementation\n");
if (GC_page_size % HBLKSIZE!=0){
ABORT("Page size not multiple of HBLKSIZE");
}
#if!defined(MSWIN32)&&!defined(MSWINCE)
#if defined(GC_IRIX_THREADS)
sigaction(SIGSEGV,0,&oldact);
sigaction(SIGSEGV,&act,0);
#else
{
int res=sigaction(SIGSEGV,&act,&oldact);
if (res!=0)ABORT("Sigaction failed");
}
#endif
if (oldact.sa_flags&SA_SIGINFO){
GC_old_segv_handler=oldact.sa_sigaction;
GC_old_segv_handler_used_si=TRUE;
} else {
GC_old_segv_handler=(SIG_HNDLR_PTR)(signed_word)oldact.sa_handler;
GC_old_segv_handler_used_si=FALSE;
}
if (GC_old_segv_handler==(SIG_HNDLR_PTR)(signed_word)SIG_IGN){
WARN("Previously ignored segmentation violation!?\n",0);
GC_old_segv_handler=(SIG_HNDLR_PTR)(signed_word)SIG_DFL;
}
if (GC_old_segv_handler!=(SIG_HNDLR_PTR)(signed_word)SIG_DFL){
GC_VERBOSE_LOG_PRINTF("Replaced other SIGSEGV handler\n");
}
#if defined(HPUX)||defined(LINUX)||defined(HURD)||(defined(FREEBSD)&&(defined(__GLIBC__)||defined(SUNOS5SIGS)))
sigaction(SIGBUS,&act,&oldact);
if ((oldact.sa_flags&SA_SIGINFO)!=0){
GC_old_bus_handler=oldact.sa_sigaction;
#if!defined(LINUX)
GC_old_bus_handler_used_si=TRUE;
#endif
} else {
GC_old_bus_handler=(SIG_HNDLR_PTR)(signed_word)oldact.sa_handler;
}
if (GC_old_bus_handler==(SIG_HNDLR_PTR)(signed_word)SIG_IGN){
WARN("Previously ignored bus error!?\n",0);
#if!defined(LINUX)
GC_old_bus_handler=(SIG_HNDLR_PTR)(signed_word)SIG_DFL;
#else
#endif
} else if (GC_old_bus_handler!=(SIG_HNDLR_PTR)(signed_word)SIG_DFL){
GC_VERBOSE_LOG_PRINTF("Replaced other SIGBUS handler\n");
}
#endif
#endif
#if defined(GWW_VDB)
if (GC_gww_dirty_init())
return TRUE;
#endif
#if defined(MSWIN32)
GC_old_segv_handler=SetUnhandledExceptionFilter(GC_write_fault_handler);
if (GC_old_segv_handler!=NULL){
GC_COND_LOG_PRINTF("Replaced other UnhandledExceptionFilter\n");
} else {
GC_old_segv_handler=SIG_DFL;
}
#elif defined(MSWINCE)
#endif
#if defined(CPPCHECK)&&defined(ADDRESS_SANITIZER)
GC_noop1((word)&__asan_default_options);
#endif
return TRUE;
}
#endif
GC_API int GC_CALL GC_incremental_protection_needs(void)
{
GC_ASSERT(GC_is_initialized);
if (GC_page_size==HBLKSIZE){
return GC_PROTECTS_POINTER_HEAP;
} else {
return GC_PROTECTS_POINTER_HEAP|GC_PROTECTS_PTRFREE_HEAP;
}
}
#define HAVE_INCREMENTAL_PROTECTION_NEEDS
#define IS_PTRFREE(hhdr)((hhdr)->hb_descr==0)
#define PAGE_ALIGNED(x)!((word)(x)&(GC_page_size - 1))
STATIC void GC_protect_heap(void)
{
unsigned i;
GC_bool protect_all=
(0!=(GC_incremental_protection_needs()&GC_PROTECTS_PTRFREE_HEAP));
GC_ASSERT(GC_page_size!=0);
for (i=0;i < GC_n_heap_sects;i++){
ptr_t start=GC_heap_sects[i].hs_start;
size_t len=GC_heap_sects[i].hs_bytes;
if (protect_all){
PROTECT(start,len);
} else {
struct hblk*current;
struct hblk*current_start;
struct hblk*limit;
GC_ASSERT(PAGE_ALIGNED(len));
GC_ASSERT(PAGE_ALIGNED(start));
current_start=current=(struct hblk*)start;
limit=(struct hblk*)(start+len);
while ((word)current < (word)limit){
hdr*hhdr;
word nhblks;
GC_bool is_ptrfree;
GC_ASSERT(PAGE_ALIGNED(current));
GET_HDR(current,hhdr);
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)){
GC_ASSERT(current_start==current);
current_start=++current;
continue;
}
if (HBLK_IS_FREE(hhdr)){
GC_ASSERT(PAGE_ALIGNED(hhdr->hb_sz));
nhblks=divHBLKSZ(hhdr->hb_sz);
is_ptrfree=TRUE;
} else {
nhblks=OBJ_SZ_TO_BLOCKS(hhdr->hb_sz);
is_ptrfree=IS_PTRFREE(hhdr);
}
if (is_ptrfree){
if ((word)current_start < (word)current){
PROTECT(current_start,(ptr_t)current - (ptr_t)current_start);
}
current_start=(current+=nhblks);
} else {
current+=nhblks;
}
}
if ((word)current_start < (word)current){
PROTECT(current_start,(ptr_t)current - (ptr_t)current_start);
}
}
}
}
#endif
#ifdef PROC_VDB
#include <errno.h>
#include <sys/types.h>
#include <sys/signal.h>
#include <sys/syscall.h>
#include <sys/stat.h>
#ifdef GC_NO_SYS_FAULT_H
#define PG_MODIFIED 1
struct prpageheader {
int dummy[2];
unsigned long pr_nmap;
unsigned long pr_npage;
};
struct prasmap {
char*pr_vaddr;
size_t pr_npage;
char dummy1[64+8];
unsigned pr_mflags;
unsigned pr_pagesize;
int dummy2[2];
};
#else
#include <sys/fault.h>
#include <sys/procfs.h>
#endif
#define INITIAL_BUF_SZ 16384
STATIC size_t GC_proc_buf_size=INITIAL_BUF_SZ;
STATIC char*GC_proc_buf=NULL;
STATIC int GC_proc_fd=0;
GC_INNER GC_bool GC_dirty_init(void)
{
char buf[40];
if (GC_bytes_allocd!=0||GC_bytes_allocd_before_gc!=0){
memset(GC_written_pages,0xff,sizeof(page_hash_table));
GC_VERBOSE_LOG_PRINTF(
"Allocated %lu bytes:all pages may have been written\n",
(unsigned long)(GC_bytes_allocd+GC_bytes_allocd_before_gc));
}
(void)snprintf(buf,sizeof(buf),"/proc/%ld/pagedata",(long)getpid());
buf[sizeof(buf)- 1]='\0';
GC_proc_fd=open(buf,O_RDONLY);
if (GC_proc_fd < 0){
WARN("/proc open failed;cannot enable GC incremental mode\n",0);
return FALSE;
}
if (syscall(SYS_fcntl,GC_proc_fd,F_SETFD,FD_CLOEXEC)==-1)
WARN("Could not set FD_CLOEXEC for/proc\n",0);
GC_proc_buf=GC_scratch_alloc(GC_proc_buf_size);
if (GC_proc_buf==NULL)
ABORT("Insufficient space for/proc read");
return TRUE;
}
GC_INLINE void GC_proc_read_dirty(GC_bool output_unneeded)
{
#define READ read
int nmaps;
char*bufp=GC_proc_buf;
int i;
BZERO(GC_grungy_pages,sizeof(GC_grungy_pages));
if (READ(GC_proc_fd,bufp,GC_proc_buf_size)<=0){
size_t new_size=2*GC_proc_buf_size;
char*new_buf;
WARN("/proc read failed:GC_proc_buf_size=%" WARN_PRIdPTR "\n",
(signed_word)GC_proc_buf_size);
new_buf=GC_scratch_alloc(new_size);
if (new_buf!=0){
GC_scratch_recycle_no_gww(bufp,GC_proc_buf_size);
GC_proc_buf=bufp=new_buf;
GC_proc_buf_size=new_size;
}
if (READ(GC_proc_fd,bufp,GC_proc_buf_size)<=0){
WARN("Insufficient space for/proc read\n",0);
if (!output_unneeded)
memset(GC_grungy_pages,0xff,sizeof (page_hash_table));
memset(GC_written_pages,0xff,sizeof(page_hash_table));
return;
}
}
nmaps=((struct prpageheader*)bufp)->pr_nmap;
#ifdef DEBUG_DIRTY_BITS
GC_log_printf("Proc VDB read:pr_nmap=%u,pr_npage=%lu\n",
nmaps,((struct prpageheader*)bufp)->pr_npage);
#endif
#if defined(GC_NO_SYS_FAULT_H)&&defined(CPPCHECK)
GC_noop1(((struct prpageheader*)bufp)->dummy[0]);
#endif
bufp+=sizeof(struct prpageheader);
for (i=0;i < nmaps;i++){
struct prasmap*map=(struct prasmap*)bufp;
ptr_t vaddr=(ptr_t)(map->pr_vaddr);
unsigned long npages=map->pr_npage;
unsigned pagesize=map->pr_pagesize;
ptr_t limit;
#if defined(GC_NO_SYS_FAULT_H)&&defined(CPPCHECK)
GC_noop1(map->dummy1[0]+map->dummy2[0]);
#endif
#ifdef DEBUG_DIRTY_BITS
GC_log_printf(
"pr_vaddr=%p,npage=%lu,mflags=0x%x,pagesize=0x%x\n",
(void*)vaddr,npages,map->pr_mflags,pagesize);
#endif
bufp+=sizeof(struct prasmap);
limit=vaddr+pagesize*npages;
for (;(word)vaddr < (word)limit;vaddr+=pagesize){
if ((*bufp++)&PG_MODIFIED){
struct hblk*h;
ptr_t next_vaddr=vaddr+pagesize;
#ifdef DEBUG_DIRTY_BITS
GC_log_printf("dirty page at:%p\n",(void*)vaddr);
#endif
for (h=(struct hblk*)vaddr;
(word)h < (word)next_vaddr;h++){
word index=PHT_HASH(h);
set_pht_entry_from_index(GC_grungy_pages,index);
}
}
}
bufp=(char*)(((word)bufp+(sizeof(long)-1))
&~(word)(sizeof(long)-1));
}
#ifdef DEBUG_DIRTY_BITS
GC_log_printf("Proc VDB read done\n");
#endif
GC_or_pages(GC_written_pages,GC_grungy_pages);
#undef READ
}
#endif
#ifdef PCR_VDB
#include "vd/PCR_VD.h"
#define NPAGES (32*1024)
PCR_VD_DB GC_grungy_bits[NPAGES];
STATIC ptr_t GC_vd_base=NULL;
GC_INNER GC_bool GC_dirty_init(void)
{
GC_vd_base=GC_heap_sects[0].hs_start;
if (GC_vd_base==0){
ABORT("Bad initial heap segment");
}
if (PCR_VD_Start(HBLKSIZE,GC_vd_base,NPAGES*HBLKSIZE)
!=PCR_ERes_okay){
ABORT("Dirty bit initialization failed");
}
return TRUE;
}
#endif
#ifndef GC_DISABLE_INCREMENTAL
GC_INNER GC_bool GC_manual_vdb=FALSE;
GC_INNER void GC_dirty_inner(const void*p)
{
word index=PHT_HASH(p);
#if defined(MPROTECT_VDB)
GC_ASSERT(GC_manual_vdb);
#endif
async_set_pht_entry_from_index(GC_dirty_pages,index);
}
GC_INNER void GC_read_dirty(GC_bool output_unneeded)
{
if (GC_manual_vdb
#if defined(MPROTECT_VDB)
||!GC_GWW_AVAILABLE()
#endif
){
if (!output_unneeded)
BCOPY(( void*)GC_dirty_pages,GC_grungy_pages,
sizeof(GC_dirty_pages));
BZERO(( void*)GC_dirty_pages,
sizeof(GC_dirty_pages));
#ifdef MPROTECT_VDB
if (!GC_manual_vdb)
GC_protect_heap();
#endif
return;
}
#ifdef GWW_VDB
GC_gww_read_dirty(output_unneeded);
#elif defined(PROC_VDB)
GC_proc_read_dirty(output_unneeded);
#elif defined(PCR_VDB)
{
static int onhs=0;
int nhs=GC_n_heap_sects;
for (;onhs < nhs;onhs++){
PCR_VD_WriteProtectEnable(
GC_heap_sects[onhs].hs_start,
GC_heap_sects[onhs].hs_bytes);
}
}
if (PCR_VD_Clear(GC_vd_base,NPAGES*HBLKSIZE,GC_grungy_bits)
!=PCR_ERes_okay){
ABORT("Dirty bit read failed");
}
#endif
}
GC_INNER GC_bool GC_page_was_dirty(struct hblk*h)
{
#ifdef PCR_VDB
if (!GC_manual_vdb){
if ((word)h < (word)GC_vd_base
||(word)h>=(word)(GC_vd_base+NPAGES*HBLKSIZE)){
return TRUE;
}
return GC_grungy_bits[h-(struct hblk*)GC_vd_base]&PCR_VD_DB_dirtyBit;
}
#elif defined(DEFAULT_VDB)
if (!GC_manual_vdb)
return TRUE;
#endif
return NULL==HDR(h)
||get_pht_entry_from_index(GC_grungy_pages,PHT_HASH(h));
}
#if defined(CHECKSUMS)||defined(PROC_VDB)
GC_INNER GC_bool GC_page_was_ever_dirty(struct hblk*h)
{
#if defined(GWW_VDB)||defined(PROC_VDB)
#ifdef MPROTECT_VDB
if (!GC_GWW_AVAILABLE())
return TRUE;
#endif
return NULL==HDR(h)
||get_pht_entry_from_index(GC_written_pages,PHT_HASH(h));
#else
(void)h;
return TRUE;
#endif
}
#endif
GC_INNER void GC_remove_protection(struct hblk*h,word nblocks,
GC_bool is_ptrfree)
{
#ifdef PCR_VDB
(void)is_ptrfree;
if (!GC_auto_incremental)
return;
PCR_VD_WriteProtectDisable(h,nblocks*HBLKSIZE);
PCR_VD_WriteProtectEnable(h,nblocks*HBLKSIZE);
#elif defined(MPROTECT_VDB)
struct hblk*h_trunc;
struct hblk*h_end;
struct hblk*current;
if (!GC_auto_incremental||GC_GWW_AVAILABLE())
return;
GC_ASSERT(GC_page_size!=0);
h_trunc=(struct hblk*)((word)h&~(GC_page_size-1));
h_end=(struct hblk*)(((word)(h+nblocks)+GC_page_size - 1)
&~(GC_page_size - 1));
if (h_end==h_trunc+1&&
get_pht_entry_from_index(GC_dirty_pages,PHT_HASH(h_trunc))){
return;
}
for (current=h_trunc;(word)current < (word)h_end;++current){
word index=PHT_HASH(current);
if (!is_ptrfree||(word)current < (word)h
||(word)current>=(word)(h+nblocks)){
async_set_pht_entry_from_index(GC_dirty_pages,index);
}
}
UNPROTECT(h_trunc,(ptr_t)h_end - (ptr_t)h_trunc);
#else
(void)h;(void)nblocks;(void)is_ptrfree;
#endif
}
#endif
#if defined(MPROTECT_VDB)&&defined(DARWIN)
#include <mach/mach.h>
#include <mach/mach_error.h>
#include <mach/exception.h>
#include <mach/task.h>
#include <pthread.h>
EXTERN_C_BEGIN
extern boolean_t
exc_server(mach_msg_header_t*,mach_msg_header_t*);
extern kern_return_t
exception_raise(mach_port_t,mach_port_t,mach_port_t,exception_type_t,
exception_data_t,mach_msg_type_number_t);
extern kern_return_t
exception_raise_state(mach_port_t,mach_port_t,mach_port_t,exception_type_t,
exception_data_t,mach_msg_type_number_t,
thread_state_flavor_t*,thread_state_t,
mach_msg_type_number_t,thread_state_t,
mach_msg_type_number_t*);
extern kern_return_t
exception_raise_state_identity(mach_port_t,mach_port_t,mach_port_t,
exception_type_t,exception_data_t,
mach_msg_type_number_t,thread_state_flavor_t*,
thread_state_t,mach_msg_type_number_t,
thread_state_t,mach_msg_type_number_t*);
GC_API_OSCALL kern_return_t
catch_exception_raise(mach_port_t exception_port,mach_port_t thread,
mach_port_t task,exception_type_t exception,
exception_data_t code,
mach_msg_type_number_t code_count);
GC_API_OSCALL kern_return_t
catch_exception_raise_state(mach_port_name_t exception_port,
int exception,exception_data_t code,
mach_msg_type_number_t codeCnt,int flavor,
thread_state_t old_state,int old_stateCnt,
thread_state_t new_state,int new_stateCnt);
GC_API_OSCALL kern_return_t
catch_exception_raise_state_identity(mach_port_name_t exception_port,
mach_port_t thread,mach_port_t task,int exception,
exception_data_t code,mach_msg_type_number_t codeCnt,
int flavor,thread_state_t old_state,int old_stateCnt,
thread_state_t new_state,int new_stateCnt);
EXTERN_C_END
GC_API_OSCALL kern_return_t
catch_exception_raise_state(mach_port_name_t exception_port GC_ATTR_UNUSED,
int exception GC_ATTR_UNUSED,exception_data_t code GC_ATTR_UNUSED,
mach_msg_type_number_t codeCnt GC_ATTR_UNUSED,int flavor GC_ATTR_UNUSED,
thread_state_t old_state GC_ATTR_UNUSED,int old_stateCnt GC_ATTR_UNUSED,
thread_state_t new_state GC_ATTR_UNUSED,int new_stateCnt GC_ATTR_UNUSED)
{
ABORT_RET("Unexpected catch_exception_raise_state invocation");
return(KERN_INVALID_ARGUMENT);
}
GC_API_OSCALL kern_return_t
catch_exception_raise_state_identity(
mach_port_name_t exception_port GC_ATTR_UNUSED,
mach_port_t thread GC_ATTR_UNUSED,mach_port_t task GC_ATTR_UNUSED,
int exception GC_ATTR_UNUSED,exception_data_t code GC_ATTR_UNUSED,
mach_msg_type_number_t codeCnt GC_ATTR_UNUSED,int flavor GC_ATTR_UNUSED,
thread_state_t old_state GC_ATTR_UNUSED,int old_stateCnt GC_ATTR_UNUSED,
thread_state_t new_state GC_ATTR_UNUSED,int new_stateCnt GC_ATTR_UNUSED)
{
ABORT_RET("Unexpected catch_exception_raise_state_identity invocation");
return(KERN_INVALID_ARGUMENT);
}
#define MAX_EXCEPTION_PORTS 16
static struct {
mach_msg_type_number_t count;
exception_mask_t masks[MAX_EXCEPTION_PORTS];
exception_handler_t ports[MAX_EXCEPTION_PORTS];
exception_behavior_t behaviors[MAX_EXCEPTION_PORTS];
thread_state_flavor_t flavors[MAX_EXCEPTION_PORTS];
} GC_old_exc_ports;
STATIC struct ports_s {
void (*volatile os_callback[3])(void);
mach_port_t exception;
#if defined(THREADS)
mach_port_t reply;
#endif
} GC_ports={
{
(void (*)(void))catch_exception_raise,
(void (*)(void))catch_exception_raise_state,
(void (*)(void))catch_exception_raise_state_identity
},
#ifdef THREADS
0,
#endif
0
};
typedef struct {
mach_msg_header_t head;
} GC_msg_t;
typedef enum {
GC_MP_NORMAL,
GC_MP_DISCARDING,
GC_MP_STOPPED
} GC_mprotect_state_t;
#ifdef THREADS
#define ID_STOP 1
#define ID_RESUME 2
#define ID_ACK 3
STATIC GC_mprotect_state_t GC_mprotect_state=GC_MP_NORMAL;
STATIC void GC_mprotect_thread_notify(mach_msg_id_t id)
{
struct buf_s {
GC_msg_t msg;
mach_msg_trailer_t trailer;
} buf;
mach_msg_return_t r;
buf.msg.head.msgh_bits=MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND,0);
buf.msg.head.msgh_size=sizeof(buf.msg);
buf.msg.head.msgh_remote_port=GC_ports.exception;
buf.msg.head.msgh_local_port=MACH_PORT_NULL;
buf.msg.head.msgh_id=id;
r=mach_msg(&buf.msg.head,MACH_SEND_MSG|MACH_RCV_MSG|MACH_RCV_LARGE,
sizeof(buf.msg),sizeof(buf),GC_ports.reply,
MACH_MSG_TIMEOUT_NONE,MACH_PORT_NULL);
if (r!=MACH_MSG_SUCCESS)
ABORT("mach_msg failed in GC_mprotect_thread_notify");
if (buf.msg.head.msgh_id!=ID_ACK)
ABORT("Invalid ack in GC_mprotect_thread_notify");
}
STATIC void GC_mprotect_thread_reply(void)
{
GC_msg_t msg;
mach_msg_return_t r;
msg.head.msgh_bits=MACH_MSGH_BITS(MACH_MSG_TYPE_MAKE_SEND,0);
msg.head.msgh_size=sizeof(msg);
msg.head.msgh_remote_port=GC_ports.reply;
msg.head.msgh_local_port=MACH_PORT_NULL;
msg.head.msgh_id=ID_ACK;
r=mach_msg(&msg.head,MACH_SEND_MSG,sizeof(msg),0,MACH_PORT_NULL,
MACH_MSG_TIMEOUT_NONE,MACH_PORT_NULL);
if (r!=MACH_MSG_SUCCESS)
ABORT("mach_msg failed in GC_mprotect_thread_reply");
}
GC_INNER void GC_mprotect_stop(void)
{
GC_mprotect_thread_notify(ID_STOP);
}
GC_INNER void GC_mprotect_resume(void)
{
GC_mprotect_thread_notify(ID_RESUME);
}
#else
#define GC_mprotect_state GC_MP_NORMAL
#endif
struct mp_reply_s {
mach_msg_header_t head;
char data[256];
};
struct mp_msg_s {
mach_msg_header_t head;
mach_msg_body_t msgh_body;
char data[1024];
};
STATIC void*GC_mprotect_thread(void*arg)
{
mach_msg_return_t r;
struct mp_reply_s reply;
struct mp_msg_s msg;
mach_msg_id_t id;
if ((word)arg==GC_WORD_MAX)return 0;
#if defined(CPPCHECK)
reply.data[0]=0;
msg.data[0]=0;
#endif
#if defined(HAVE_PTHREAD_SETNAME_NP_WITHOUT_TID)
(void)pthread_setname_np("GC-mprotect");
#endif
#if defined(THREADS)&&!defined(GC_NO_THREADS_DISCOVERY)
GC_darwin_register_mach_handler_thread(mach_thread_self());
#endif
for(;;){
r=mach_msg(&msg.head,MACH_RCV_MSG|MACH_RCV_LARGE|
(GC_mprotect_state==GC_MP_DISCARDING?MACH_RCV_TIMEOUT:0),
0,sizeof(msg),GC_ports.exception,
GC_mprotect_state==GC_MP_DISCARDING?0
:MACH_MSG_TIMEOUT_NONE,MACH_PORT_NULL);
id=r==MACH_MSG_SUCCESS?msg.head.msgh_id:-1;
#if defined(THREADS)
if(GC_mprotect_state==GC_MP_DISCARDING){
if(r==MACH_RCV_TIMED_OUT){
GC_mprotect_state=GC_MP_STOPPED;
GC_mprotect_thread_reply();
continue;
}
if(r==MACH_MSG_SUCCESS&&(id==ID_STOP||id==ID_RESUME))
ABORT("Out of order mprotect thread request");
}
#endif
if (r!=MACH_MSG_SUCCESS){
ABORT_ARG2("mach_msg failed",
":errcode=%d (%s)",(int)r,mach_error_string(r));
}
switch(id){
#if defined(THREADS)
case ID_STOP:
if(GC_mprotect_state!=GC_MP_NORMAL)
ABORT("Called mprotect_stop when state wasn't normal");
GC_mprotect_state=GC_MP_DISCARDING;
break;
case ID_RESUME:
if(GC_mprotect_state!=GC_MP_STOPPED)
ABORT("Called mprotect_resume when state wasn't stopped");
GC_mprotect_state=GC_MP_NORMAL;
GC_mprotect_thread_reply();
break;
#endif
default:
if(!exc_server(&msg.head,&reply.head))
ABORT("exc_server failed");
r=mach_msg(&reply.head,MACH_SEND_MSG,reply.head.msgh_size,0,
MACH_PORT_NULL,MACH_MSG_TIMEOUT_NONE,
MACH_PORT_NULL);
if(r!=MACH_MSG_SUCCESS){
#ifdef BROKEN_EXCEPTION_HANDLING
GC_err_printf("mach_msg failed with %d %s while sending "
"exc reply\n",(int)r,mach_error_string(r));
#else
ABORT("mach_msg failed while sending exception reply");
#endif
}
}
}
}
#ifdef BROKEN_EXCEPTION_HANDLING
STATIC int GC_sigbus_count=0;
STATIC void GC_darwin_sigbus(int num,siginfo_t*sip,void*context)
{
if (num!=SIGBUS)
ABORT("Got a non-sigbus signal in the sigbus handler");
if (GC_sigbus_count>=8){
ABORT("Got more than 8 SIGBUSs in a row!");
} else {
GC_sigbus_count++;
WARN("Ignoring SIGBUS\n",0);
}
}
#endif
GC_INNER GC_bool GC_dirty_init(void)
{
kern_return_t r;
mach_port_t me;
pthread_t thread;
pthread_attr_t attr;
exception_mask_t mask;
#ifdef CAN_HANDLE_FORK
if (GC_handle_fork){
WARN("Can't turn on GC incremental mode as fork()"
" handling requested\n",0);
return FALSE;
}
#endif
GC_VERBOSE_LOG_PRINTF("Initializing mach/darwin mprotect"
" virtual dirty bit implementation\n");
#ifdef BROKEN_EXCEPTION_HANDLING
WARN("Enabling workarounds for various darwin "
"exception handling bugs\n",0);
#endif
if (GC_page_size % HBLKSIZE!=0){
ABORT("Page size not multiple of HBLKSIZE");
}
GC_task_self=me=mach_task_self();
r=mach_port_allocate(me,MACH_PORT_RIGHT_RECEIVE,&GC_ports.exception);
if (r!=KERN_SUCCESS)
ABORT("mach_port_allocate failed (exception port)");
r=mach_port_insert_right(me,GC_ports.exception,GC_ports.exception,
MACH_MSG_TYPE_MAKE_SEND);
if (r!=KERN_SUCCESS)
ABORT("mach_port_insert_right failed (exception port)");
#if defined(THREADS)
r=mach_port_allocate(me,MACH_PORT_RIGHT_RECEIVE,&GC_ports.reply);
if(r!=KERN_SUCCESS)
ABORT("mach_port_allocate failed (reply port)");
#endif
mask=EXC_MASK_BAD_ACCESS;
r=task_get_exception_ports(me,mask,GC_old_exc_ports.masks,
&GC_old_exc_ports.count,GC_old_exc_ports.ports,
GC_old_exc_ports.behaviors,
GC_old_exc_ports.flavors);
if (r!=KERN_SUCCESS)
ABORT("task_get_exception_ports failed");
r=task_set_exception_ports(me,mask,GC_ports.exception,EXCEPTION_DEFAULT,
GC_MACH_THREAD_STATE);
if (r!=KERN_SUCCESS)
ABORT("task_set_exception_ports failed");
if (pthread_attr_init(&attr)!=0)
ABORT("pthread_attr_init failed");
if (pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED)!=0)
ABORT("pthread_attr_setdetachedstate failed");
#undef pthread_create
if (pthread_create(&thread,&attr,GC_mprotect_thread,NULL)!=0)
ABORT("pthread_create failed");
(void)pthread_attr_destroy(&attr);
#ifdef BROKEN_EXCEPTION_HANDLING
{
struct sigaction sa,oldsa;
sa.sa_handler=(SIG_HNDLR_PTR)GC_darwin_sigbus;
sigemptyset(&sa.sa_mask);
sa.sa_flags=SA_RESTART|SA_SIGINFO;
if (sigaction(SIGBUS,&sa,&oldsa)< 0)
ABORT("sigaction failed");
if (oldsa.sa_handler!=(SIG_HNDLR_PTR)(signed_word)SIG_DFL){
GC_VERBOSE_LOG_PRINTF("Replaced other SIGBUS handler\n");
}
}
#endif
#if defined(CPPCHECK)
GC_noop1((word)GC_ports.os_callback[0]);
#endif
return TRUE;
}
STATIC kern_return_t GC_forward_exception(mach_port_t thread,mach_port_t task,
exception_type_t exception,
exception_data_t data,
mach_msg_type_number_t data_count)
{
unsigned int i;
kern_return_t r;
mach_port_t port;
exception_behavior_t behavior;
thread_state_flavor_t flavor;
thread_state_data_t thread_state;
mach_msg_type_number_t thread_state_count=THREAD_STATE_MAX;
for (i=0;i < GC_old_exc_ports.count;i++)
if (GC_old_exc_ports.masks[i]&(1<<exception))
break;
if (i==GC_old_exc_ports.count)
ABORT("No handler for exception!");
port=GC_old_exc_ports.ports[i];
behavior=GC_old_exc_ports.behaviors[i];
flavor=GC_old_exc_ports.flavors[i];
if (behavior==EXCEPTION_STATE||behavior==EXCEPTION_STATE_IDENTITY){
r=thread_get_state(thread,flavor,thread_state,&thread_state_count);
if(r!=KERN_SUCCESS)
ABORT("thread_get_state failed in forward_exception");
}
switch(behavior){
case EXCEPTION_STATE:
r=exception_raise_state(port,thread,task,exception,data,data_count,
&flavor,thread_state,thread_state_count,
thread_state,&thread_state_count);
break;
case EXCEPTION_STATE_IDENTITY:
r=exception_raise_state_identity(port,thread,task,exception,data,
data_count,&flavor,thread_state,
thread_state_count,thread_state,
&thread_state_count);
break;
default:
r=exception_raise(port,thread,task,exception,data,data_count);
}
if (behavior==EXCEPTION_STATE||behavior==EXCEPTION_STATE_IDENTITY){
r=thread_set_state(thread,flavor,thread_state,thread_state_count);
if (r!=KERN_SUCCESS)
ABORT("thread_set_state failed in forward_exception");
}
return r;
}
#define FWD()GC_forward_exception(thread,task,exception,code,code_count)
#ifdef ARM32
#define DARWIN_EXC_STATE ARM_EXCEPTION_STATE
#define DARWIN_EXC_STATE_COUNT ARM_EXCEPTION_STATE_COUNT
#define DARWIN_EXC_STATE_T arm_exception_state_t
#define DARWIN_EXC_STATE_DAR THREAD_FLD_NAME(far)
#elif defined(AARCH64)
#define DARWIN_EXC_STATE ARM_EXCEPTION_STATE64
#define DARWIN_EXC_STATE_COUNT ARM_EXCEPTION_STATE64_COUNT
#define DARWIN_EXC_STATE_T arm_exception_state64_t
#define DARWIN_EXC_STATE_DAR THREAD_FLD_NAME(far)
#elif defined(POWERPC)
#if CPP_WORDSZ==32
#define DARWIN_EXC_STATE PPC_EXCEPTION_STATE
#define DARWIN_EXC_STATE_COUNT PPC_EXCEPTION_STATE_COUNT
#define DARWIN_EXC_STATE_T ppc_exception_state_t
#else
#define DARWIN_EXC_STATE PPC_EXCEPTION_STATE64
#define DARWIN_EXC_STATE_COUNT PPC_EXCEPTION_STATE64_COUNT
#define DARWIN_EXC_STATE_T ppc_exception_state64_t
#endif
#define DARWIN_EXC_STATE_DAR THREAD_FLD_NAME(dar)
#elif defined(I386)||defined(X86_64)
#if CPP_WORDSZ==32
#if defined(i386_EXCEPTION_STATE_COUNT)&&!defined(x86_EXCEPTION_STATE32_COUNT)
#define DARWIN_EXC_STATE i386_EXCEPTION_STATE
#define DARWIN_EXC_STATE_COUNT i386_EXCEPTION_STATE_COUNT
#define DARWIN_EXC_STATE_T i386_exception_state_t
#else
#define DARWIN_EXC_STATE x86_EXCEPTION_STATE32
#define DARWIN_EXC_STATE_COUNT x86_EXCEPTION_STATE32_COUNT
#define DARWIN_EXC_STATE_T x86_exception_state32_t
#endif
#else
#define DARWIN_EXC_STATE x86_EXCEPTION_STATE64
#define DARWIN_EXC_STATE_COUNT x86_EXCEPTION_STATE64_COUNT
#define DARWIN_EXC_STATE_T x86_exception_state64_t
#endif
#define DARWIN_EXC_STATE_DAR THREAD_FLD_NAME(faultvaddr)
#elif!defined(CPPCHECK)
#error FIXME for non-arm/ppc/x86 darwin
#endif
GC_API_OSCALL kern_return_t
catch_exception_raise(mach_port_t exception_port GC_ATTR_UNUSED,
mach_port_t thread,mach_port_t task GC_ATTR_UNUSED,
exception_type_t exception,exception_data_t code,
mach_msg_type_number_t code_count GC_ATTR_UNUSED)
{
kern_return_t r;
char*addr;
thread_state_flavor_t flavor=DARWIN_EXC_STATE;
mach_msg_type_number_t exc_state_count=DARWIN_EXC_STATE_COUNT;
DARWIN_EXC_STATE_T exc_state;
if (exception!=EXC_BAD_ACCESS||code[0]!=KERN_PROTECTION_FAILURE){
#ifdef DEBUG_EXCEPTION_HANDLING
GC_log_printf("Exception:0x%x Code:0x%x 0x%x in catch...\n",
exception,code_count > 0?code[0]:-1,
code_count > 1?code[1]:-1);
#endif
return FWD();
}
r=thread_get_state(thread,flavor,(natural_t*)&exc_state,
&exc_state_count);
if(r!=KERN_SUCCESS){
#ifdef BROKEN_EXCEPTION_HANDLING
GC_err_printf("thread_get_state failed in catch_exception_raise\n");
return KERN_SUCCESS;
#else
ABORT("thread_get_state failed in catch_exception_raise");
#endif
}
addr=(char*)exc_state.DARWIN_EXC_STATE_DAR;
if (!is_header_found_async(addr)){
#ifdef BROKEN_EXCEPTION_HANDLING
static char*last_fault;
static int last_fault_count;
if(addr!=last_fault){
last_fault=addr;
last_fault_count=0;
}
if(++last_fault_count < 32){
if(last_fault_count==1)
WARN("Ignoring KERN_PROTECTION_FAILURE at %p\n",addr);
return KERN_SUCCESS;
}
GC_err_printf("Unexpected KERN_PROTECTION_FAILURE at %p;aborting...\n",
(void*)addr);
EXIT();
#else
return FWD();
#endif
}
#ifdef BROKEN_EXCEPTION_HANDLING
GC_sigbus_count=0;
#endif
GC_ASSERT(GC_page_size!=0);
if (GC_mprotect_state==GC_MP_NORMAL){
struct hblk*h=(struct hblk*)((word)addr&~(GC_page_size-1));
size_t i;
UNPROTECT(h,GC_page_size);
for (i=0;i < divHBLKSZ(GC_page_size);i++){
word index=PHT_HASH(h+i);
async_set_pht_entry_from_index(GC_dirty_pages,index);
}
} else if (GC_mprotect_state==GC_MP_DISCARDING){
} else {
GC_err_printf("KERN_PROTECTION_FAILURE while world is stopped\n");
return FWD();
}
return KERN_SUCCESS;
}
#undef FWD
#ifndef NO_DESC_CATCH_EXCEPTION_RAISE
__asm__(".desc _catch_exception_raise,0x10");
__asm__(".desc _catch_exception_raise_state,0x10");
__asm__(".desc _catch_exception_raise_state_identity,0x10");
#endif
#endif
#ifndef HAVE_INCREMENTAL_PROTECTION_NEEDS
GC_API int GC_CALL GC_incremental_protection_needs(void)
{
GC_ASSERT(GC_is_initialized);
return GC_PROTECTS_NONE;
}
#endif
#ifdef ECOS
#undef sbrk
#endif
GC_API void GC_CALL GC_set_pages_executable(int value)
{
GC_ASSERT(!GC_is_initialized);
GC_pages_executable=(GC_bool)(value!=0);
}
GC_API int GC_CALL GC_get_pages_executable(void)
{
#ifdef IGNORE_PAGES_EXECUTABLE
return 1;
#else
return (int)GC_pages_executable;
#endif
}
#if defined(I386)&&defined(LINUX)&&defined(SAVE_CALL_CHAIN)
#include <features.h>
struct frame {
struct frame*fr_savfp;
long fr_savpc;
#if NARGS > 0
long fr_arg[NARGS];
#endif
};
#endif
#if defined(SPARC)
#if defined(LINUX)
#include <features.h>
#if defined(SAVE_CALL_CHAIN)
struct frame {
long fr_local[8];
long fr_arg[6];
struct frame*fr_savfp;
long fr_savpc;
#ifndef __arch64__
char*fr_stret;
#endif
long fr_argd[6];
long fr_argx[0];
};
#endif
#elif defined (DRSNX)
#include <sys/sparc/frame.h>
#elif defined(OPENBSD)
#include <frame.h>
#elif defined(FREEBSD)||defined(NETBSD)
#include <machine/frame.h>
#else
#include <sys/frame.h>
#endif
#if NARGS > 6
#error We only know how to get the first 6 arguments
#endif
#endif
#ifdef NEED_CALLINFO
#ifdef LINUX
#include <unistd.h>
#endif
#endif
#if defined(GC_HAVE_BUILTIN_BACKTRACE)
#ifdef _MSC_VER
#ifndef GC_MSVC_DBG_H
#define GC_MSVC_DBG_H
#include <stdlib.h>
#ifdef __cplusplus
extern "C" {
#endif
#if!MSVC_DBG_DLL
#define MSVC_DBG_EXPORT
#elif MSVC_DBG_BUILD
#define MSVC_DBG_EXPORT __declspec(dllexport)
#else
#define MSVC_DBG_EXPORT __declspec(dllimport)
#endif
#ifndef MAX_SYM_NAME
#define MAX_SYM_NAME 2000
#endif
typedef void*HANDLE;
typedef struct _CONTEXT CONTEXT;
MSVC_DBG_EXPORT size_t GetStackFrames(size_t skip,void*frames[],size_t maxFrames);
MSVC_DBG_EXPORT size_t GetStackFramesFromContext(HANDLE hProcess,HANDLE hThread,CONTEXT*context,size_t skip,void*frames[],size_t maxFrames);
MSVC_DBG_EXPORT size_t GetModuleNameFromAddress(void*address,char*moduleName,size_t size);
MSVC_DBG_EXPORT size_t GetModuleNameFromStack(size_t skip,char*moduleName,size_t size);
MSVC_DBG_EXPORT size_t GetSymbolNameFromAddress(void*address,char*symbolName,size_t size,size_t*offsetBytes);
MSVC_DBG_EXPORT size_t GetSymbolNameFromStack(size_t skip,char*symbolName,size_t size,size_t*offsetBytes);
MSVC_DBG_EXPORT size_t GetFileLineFromAddress(void*address,char*fileName,size_t size,size_t*lineNumber,size_t*offsetBytes);
MSVC_DBG_EXPORT size_t GetFileLineFromStack(size_t skip,char*fileName,size_t size,size_t*lineNumber,size_t*offsetBytes);
MSVC_DBG_EXPORT size_t GetDescriptionFromAddress(void*address,const char*format,char*description,size_t size);
MSVC_DBG_EXPORT size_t GetDescriptionFromStack(void*const frames[],size_t count,const char*format,char*description[],size_t size);
MSVC_DBG_EXPORT int backtrace(void*addresses[],int count);
MSVC_DBG_EXPORT char**backtrace_symbols(void*const addresses[],int count);
#ifdef __cplusplus
}
#endif
#endif
#else
#include <execinfo.h>
#endif
#endif
#ifdef SAVE_CALL_CHAIN
#if NARGS==0&&NFRAMES % 2==0&&defined(GC_HAVE_BUILTIN_BACKTRACE)
#ifdef REDIRECT_MALLOC
#ifdef THREADS
__thread
#endif
GC_bool GC_in_save_callers=FALSE;
#endif
GC_INNER void GC_save_callers(struct callinfo info[NFRAMES])
{
void*tmp_info[NFRAMES+1];
int npcs,i;
#define IGNORE_FRAMES 1
#ifdef REDIRECT_MALLOC
if (GC_in_save_callers){
info[0].ci_pc=(word)(&GC_save_callers);
for (i=1;i < NFRAMES;++i)info[i].ci_pc=0;
return;
}
GC_in_save_callers=TRUE;
#endif
GC_ASSERT(I_HOLD_LOCK());
GC_STATIC_ASSERT(sizeof(struct callinfo)==sizeof(void*));
npcs=backtrace((void**)tmp_info,NFRAMES+IGNORE_FRAMES);
if (npcs > IGNORE_FRAMES)
BCOPY(&tmp_info[IGNORE_FRAMES],info,
(npcs - IGNORE_FRAMES)*sizeof(void*));
for (i=npcs - IGNORE_FRAMES;i < NFRAMES;++i)info[i].ci_pc=0;
#ifdef REDIRECT_MALLOC
GC_in_save_callers=FALSE;
#endif
}
#else
#if (defined(OPENBSD)||defined(NETBSD)||defined(FREEBSD))&&defined(SPARC)
#define FR_SAVFP fr_fp
#define FR_SAVPC fr_pc
#else
#define FR_SAVFP fr_savfp
#define FR_SAVPC fr_savpc
#endif
#if defined(SPARC)&&(defined(__arch64__)||defined(__sparcv9))
#define BIAS 2047
#else
#define BIAS 0
#endif
GC_INNER void GC_save_callers(struct callinfo info[NFRAMES])
{
struct frame*frame;
struct frame*fp;
int nframes=0;
#ifdef I386
asm("movl %%ebp,%0":"=r"(frame));
fp=frame;
#else
frame=(struct frame*)GC_save_regs_in_stack();
fp=(struct frame*)((long)frame->FR_SAVFP+BIAS);
#endif
for (;!((word)fp HOTTER_THAN (word)frame)
#ifndef THREADS
&&!((word)GC_stackbottom HOTTER_THAN (word)fp)
#elif defined(STACK_GROWS_UP)
&&fp!=NULL
#endif
&&nframes < NFRAMES;
fp=(struct frame*)((long)fp->FR_SAVFP+BIAS),nframes++){
#if NARGS > 0
int i;
#endif
info[nframes].ci_pc=fp->FR_SAVPC;
#if NARGS > 0
for (i=0;i < NARGS;i++){
info[nframes].ci_arg[i]=~(fp->fr_arg[i]);
}
#endif
}
if (nframes < NFRAMES)info[nframes].ci_pc=0;
}
#endif
#endif
#ifdef NEED_CALLINFO
GC_INNER void GC_print_callers(struct callinfo info[NFRAMES])
{
int i;
static int reentry_count=0;
DCL_LOCK_STATE;
LOCK();
++reentry_count;
UNLOCK();
#if NFRAMES==1
GC_err_printf("\tCaller at allocation:\n");
#else
GC_err_printf("\tCall chain at allocation:\n");
#endif
for (i=0;i < NFRAMES;i++){
#if defined(LINUX)&&!defined(SMALL_CONFIG)
GC_bool stop=FALSE;
#endif
if (0==info[i].ci_pc)
break;
#if NARGS > 0
{
int j;
GC_err_printf("\t\targs:");
for (j=0;j < NARGS;j++){
if (j!=0)GC_err_printf(",");
GC_err_printf("%d (0x%X)",~(info[i].ci_arg[j]),
~(info[i].ci_arg[j]));
}
GC_err_printf("\n");
}
#endif
if (reentry_count > 1){
GC_err_printf("\t\t##PC##=0x%lx\n",
(unsigned long)info[i].ci_pc);
continue;
}
{
char buf[40];
char*name;
#if defined(GC_HAVE_BUILTIN_BACKTRACE)&&!defined(GC_BACKTRACE_SYMBOLS_BROKEN)
char**sym_name=
backtrace_symbols((void**)(&(info[i].ci_pc)),1);
if (sym_name!=NULL){
name=sym_name[0];
} else
#endif
{
(void)snprintf(buf,sizeof(buf),"##PC##=0x%lx",
(unsigned long)info[i].ci_pc);
buf[sizeof(buf)- 1]='\0';
name=buf;
}
#if defined(LINUX)&&!defined(SMALL_CONFIG)
do {
FILE*pipe;
#define EXE_SZ 100
static char exe_name[EXE_SZ];
#define CMD_SZ 200
char cmd_buf[CMD_SZ];
#define RESULT_SZ 200
static char result_buf[RESULT_SZ];
size_t result_len;
char*old_preload;
#define PRELOAD_SZ 200
char preload_buf[PRELOAD_SZ];
static GC_bool found_exe_name=FALSE;
static GC_bool will_fail=FALSE;
if (will_fail)
break;
if (!found_exe_name){
int ret_code=readlink("/proc/self/exe",exe_name,EXE_SZ);
if (ret_code < 0||ret_code>=EXE_SZ
||exe_name[0]!='/'){
will_fail=TRUE;
break;
}
exe_name[ret_code]='\0';
found_exe_name=TRUE;
}
(void)snprintf(cmd_buf,sizeof(cmd_buf),
"/usr/bin/addr2line -f -e %s 0x%lx",
exe_name,(unsigned long)info[i].ci_pc);
cmd_buf[sizeof(cmd_buf)- 1]='\0';
old_preload=GETENV("LD_PRELOAD");
if (0!=old_preload){
size_t old_len=strlen(old_preload);
if (old_len>=PRELOAD_SZ){
will_fail=TRUE;
break;
}
BCOPY(old_preload,preload_buf,old_len+1);
unsetenv ("LD_PRELOAD");
}
pipe=popen(cmd_buf,"r");
if (0!=old_preload
&&0!=setenv ("LD_PRELOAD",preload_buf,0)){
WARN("Failed to reset LD_PRELOAD\n",0);
}
if (NULL==pipe){
will_fail=TRUE;
break;
}
result_len=fread(result_buf,1,RESULT_SZ - 1,pipe);
(void)pclose(pipe);
if (0==result_len){
will_fail=TRUE;
break;
}
if (result_buf[result_len - 1]=='\n')--result_len;
result_buf[result_len]=0;
if (result_buf[0]=='?'
||(result_buf[result_len-2]==':'
&&result_buf[result_len-1]=='0'))
break;
{
char*nl=strchr(result_buf,'\n');
if (nl!=NULL
&&(word)nl < (word)(result_buf+result_len)){
*nl=':';
}
if (strncmp(result_buf,"main",
nl!=NULL
?(size_t)((word)nl
- COVERT_DATAFLOW(result_buf))
:result_len)==0){
stop=TRUE;
}
}
if (result_len < RESULT_SZ - 25){
(void)snprintf(&result_buf[result_len],
sizeof(result_buf)- result_len,
" [0x%lx]",(unsigned long)info[i].ci_pc);
result_buf[sizeof(result_buf)- 1]='\0';
}
#if defined(CPPCHECK)
GC_noop1((unsigned char)name[0]);
#endif
name=result_buf;
} while (0);
#endif
GC_err_printf("\t\t%s\n",name);
#if defined(GC_HAVE_BUILTIN_BACKTRACE)&&!defined(GC_BACKTRACE_SYMBOLS_BROKEN)
if (sym_name!=NULL)
free(sym_name);
#endif
}
#if defined(LINUX)&&!defined(SMALL_CONFIG)
if (stop)
break;
#endif
}
LOCK();
--reentry_count;
UNLOCK();
}
#endif
#if defined(LINUX)&&defined(__ELF__)&&!defined(SMALL_CONFIG)
void GC_print_address_map(void)
{
char*maps;
GC_err_printf("----------Begin address map----------\n");
maps=GC_get_maps();
GC_err_puts(maps!=NULL?maps:"Failed to get map!\n");
GC_err_printf("----------End address map----------\n");
}
#endif
#if defined(THREAD_LOCAL_ALLOC)
#ifndef THREADS
#error "invalid config - THREAD_LOCAL_ALLOC requires GC_THREADS"
#endif
#ifndef GC_THREAD_LOCAL_ALLOC_H
#define GC_THREAD_LOCAL_ALLOC_H
#ifdef THREAD_LOCAL_ALLOC
#if defined(USE_HPUX_TLS)
#error USE_HPUX_TLS macro was replaced by USE_COMPILER_TLS
#endif
#include <stdlib.h>
EXTERN_C_BEGIN
#if!defined(USE_PTHREAD_SPECIFIC)&&!defined(USE_WIN32_SPECIFIC)&&!defined(USE_WIN32_COMPILER_TLS)&&!defined(USE_COMPILER_TLS)&&!defined(USE_CUSTOM_SPECIFIC)
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)
#if defined(CYGWIN32)&&GC_GNUC_PREREQ(4,0)
#if defined(__clang__)
#define USE_PTHREAD_SPECIFIC
#else
#define USE_COMPILER_TLS
#endif
#elif defined(__GNUC__)||defined(MSWINCE)
#define USE_WIN32_SPECIFIC
#else
#define USE_WIN32_COMPILER_TLS
#endif
#elif (defined(LINUX)&&!defined(ARM32)&&!defined(AVR32)&&GC_GNUC_PREREQ(3,3)&&!(defined(__clang__)&&defined(HOST_ANDROID)))||(defined(FREEBSD)||(defined(NETBSD)&&__NetBSD_Version__>=600000000)&&(GC_GNUC_PREREQ(4,4)||GC_CLANG_PREREQ(3,9)))||(defined(HOST_ANDROID)&&defined(ARM32)&&(GC_GNUC_PREREQ(4,6)||GC_CLANG_PREREQ_FULL(3,8,256229)))
#define USE_COMPILER_TLS
#elif defined(GC_DGUX386_THREADS)||defined(GC_OSF1_THREADS)||defined(GC_AIX_THREADS)||defined(GC_DARWIN_THREADS)||defined(GC_FREEBSD_THREADS)||defined(GC_NETBSD_THREADS)||defined(GC_LINUX_THREADS)||defined(GC_HAIKU_THREADS)||defined(GC_RTEMS_PTHREADS)
#define USE_PTHREAD_SPECIFIC
#elif defined(GC_HPUX_THREADS)
#ifdef __GNUC__
#define USE_PTHREAD_SPECIFIC
#else
#define USE_COMPILER_TLS
#endif
#else
#define USE_CUSTOM_SPECIFIC
#endif
#endif
#ifndef THREAD_FREELISTS_KINDS
#ifdef ENABLE_DISCLAIM
#define THREAD_FREELISTS_KINDS (NORMAL+2)
#else
#define THREAD_FREELISTS_KINDS (NORMAL+1)
#endif
#endif
typedef struct thread_local_freelists {
void*_freelists[THREAD_FREELISTS_KINDS][TINY_FREELISTS];
#define ptrfree_freelists _freelists[PTRFREE]
#define normal_freelists _freelists[NORMAL]
#ifdef GC_GCJ_SUPPORT
void*gcj_freelists[TINY_FREELISTS];
#define ERROR_FL ((void*)GC_WORD_MAX)
#endif
#define DIRECT_GRANULES (HBLKSIZE/GRANULE_BYTES)
}*GC_tlfs;
#if defined(USE_PTHREAD_SPECIFIC)
#define GC_getspecific pthread_getspecific
#define GC_setspecific pthread_setspecific
#define GC_key_create pthread_key_create
#define GC_remove_specific(key)pthread_setspecific(key,NULL)
#define GC_remove_specific_after_fork(key,t)(void)0
typedef pthread_key_t GC_key_t;
#elif defined(USE_COMPILER_TLS)||defined(USE_WIN32_COMPILER_TLS)
#define GC_getspecific(x)(x)
#define GC_setspecific(key,v)((key)=(v),0)
#define GC_key_create(key,d)0
#define GC_remove_specific(key)
#define GC_remove_specific_after_fork(key,t)(void)0
typedef void*GC_key_t;
#elif defined(USE_WIN32_SPECIFIC)
#define GC_getspecific TlsGetValue
#define GC_setspecific(key,v)!TlsSetValue(key,v)
#ifndef TLS_OUT_OF_INDEXES
#define TLS_OUT_OF_INDEXES (DWORD)0xFFFFFFFF
#endif
#define GC_key_create(key,d)((d)!=0||(*(key)=TlsAlloc())==TLS_OUT_OF_INDEXES?-1:0)
#define GC_remove_specific(key)
#define GC_remove_specific_after_fork(key,t)(void)0
typedef DWORD GC_key_t;
#elif defined(USE_CUSTOM_SPECIFIC)
EXTERN_C_END
#ifndef GC_SPECIFIC_H
#define GC_SPECIFIC_H
#include <errno.h>
EXTERN_C_BEGIN
#define MALLOC_CLEAR(n)GC_INTERNAL_MALLOC(n,NORMAL)
#define TS_CACHE_SIZE 1024
#define CACHE_HASH(n)((((n)>>8)^(n))&(TS_CACHE_SIZE - 1))
#define TS_HASH_SIZE 1024
#define HASH(p)((unsigned)((((word)(p))>>8)^(word)(p))&(TS_HASH_SIZE - 1))
#ifdef GC_ASSERTIONS
typedef GC_hidden_pointer ts_entry_value_t;
#define TS_HIDE_VALUE(p)GC_HIDE_POINTER(p)
#define TS_REVEAL_PTR(p)GC_REVEAL_POINTER(p)
#else
typedef void*ts_entry_value_t;
#define TS_HIDE_VALUE(p)(p)
#define TS_REVEAL_PTR(p)(p)
#endif
typedef struct thread_specific_entry {
volatile AO_t qtid;
ts_entry_value_t value;
struct thread_specific_entry*next;
pthread_t thread;
} tse;
#define quick_thread_id()(((word)GC_approx_sp())>>12)
#define INVALID_QTID ((word)0)
#define INVALID_THREADID ((pthread_t)0)
union ptse_ao_u {
tse*p;
volatile AO_t ao;
};
typedef struct thread_specific_data {
tse*volatile cache[TS_CACHE_SIZE];
union ptse_ao_u hash[TS_HASH_SIZE];
pthread_mutex_t lock;
} tsd;
typedef tsd*GC_key_t;
#define GC_key_create(key,d)GC_key_create_inner(key)
GC_INNER int GC_key_create_inner(tsd**key_ptr);
GC_INNER int GC_setspecific(tsd*key,void*value);
#define GC_remove_specific(key)GC_remove_specific_after_fork(key,pthread_self())
GC_INNER void GC_remove_specific_after_fork(tsd*key,pthread_t t);
GC_INNER void*GC_slow_getspecific(tsd*key,word qtid,
tse*volatile*cache_entry);
GC_INLINE void*GC_getspecific(tsd*key)
{
word qtid=quick_thread_id();
tse*volatile*entry_ptr=&key->cache[CACHE_HASH(qtid)];
tse*entry=*entry_ptr;
GC_ASSERT(qtid!=INVALID_QTID);
if (EXPECT(entry->qtid==qtid,TRUE)){
GC_ASSERT(entry->thread==pthread_self());
return TS_REVEAL_PTR(entry->value);
}
return GC_slow_getspecific(key,qtid,entry_ptr);
}
EXTERN_C_END
#endif
EXTERN_C_BEGIN
#else
#error implement me
#endif
GC_INNER void GC_init_thread_local(GC_tlfs p);
GC_INNER void GC_destroy_thread_local(GC_tlfs p);
GC_INNER void GC_mark_thread_local_fls_for(GC_tlfs p);
#ifdef GC_ASSERTIONS
GC_bool GC_is_thread_tsd_valid(void*tsd);
void GC_check_tls_for(GC_tlfs p);
#if defined(USE_CUSTOM_SPECIFIC)
void GC_check_tsd_marks(tsd*key);
#endif
#endif
#ifndef GC_ATTR_TLS_FAST
#define GC_ATTR_TLS_FAST
#endif
extern
#if defined(USE_COMPILER_TLS)
__thread GC_ATTR_TLS_FAST
#elif defined(USE_WIN32_COMPILER_TLS)
__declspec(thread)GC_ATTR_TLS_FAST
#endif
GC_key_t GC_thread_key;
EXTERN_C_END
#endif
#endif
#include <stdlib.h>
#if defined(USE_COMPILER_TLS)
__thread GC_ATTR_TLS_FAST
#elif defined(USE_WIN32_COMPILER_TLS)
__declspec(thread)GC_ATTR_TLS_FAST
#endif
GC_key_t GC_thread_key;
static GC_bool keys_initialized;
static void return_single_freelist(void*fl,void**gfl)
{
if (*gfl==0){
*gfl=fl;
} else {
void*q,**qptr;
GC_ASSERT(GC_size(fl)==GC_size(*gfl));
qptr=&(obj_link(fl));
while ((word)(q=*qptr)>=HBLKSIZE)
qptr=&(obj_link(q));
GC_ASSERT(0==q);
*qptr=*gfl;
*gfl=fl;
}
}
static void return_freelists(void**fl,void**gfl)
{
int i;
for (i=1;i < TINY_FREELISTS;++i){
if ((word)(fl[i])>=HBLKSIZE){
return_single_freelist(fl[i],&gfl[i]);
}
fl[i]=(ptr_t)HBLKSIZE;
}
#ifdef GC_GCJ_SUPPORT
if (fl[0]==ERROR_FL)return;
#endif
if ((word)(fl[0])>=HBLKSIZE){
return_single_freelist(fl[0],&gfl[1]);
}
}
#ifdef USE_PTHREAD_SPECIFIC
static void reset_thread_key(void*v){
pthread_setspecific(GC_thread_key,v);
}
#else
#define reset_thread_key 0
#endif
GC_INNER void GC_init_thread_local(GC_tlfs p)
{
int i,j,res;
GC_ASSERT(I_HOLD_LOCK());
if (!EXPECT(keys_initialized,TRUE)){
GC_ASSERT((word)&GC_thread_key % sizeof(word)==0);
res=GC_key_create(&GC_thread_key,reset_thread_key);
if (COVERT_DATAFLOW(res)!=0){
ABORT("Failed to create key for local allocator");
}
keys_initialized=TRUE;
}
res=GC_setspecific(GC_thread_key,p);
if (COVERT_DATAFLOW(res)!=0){
ABORT("Failed to set thread specific allocation pointers");
}
for (j=0;j < TINY_FREELISTS;++j){
for (i=0;i < THREAD_FREELISTS_KINDS;++i){
p->_freelists[i][j]=(void*)(word)1;
}
#ifdef GC_GCJ_SUPPORT
p->gcj_freelists[j]=(void*)(word)1;
#endif
}
#ifdef GC_GCJ_SUPPORT
p->gcj_freelists[0]=ERROR_FL;
#endif
}
GC_INNER void GC_destroy_thread_local(GC_tlfs p)
{
int k;
GC_STATIC_ASSERT(THREAD_FREELISTS_KINDS<=MAXOBJKINDS);
for (k=0;k < THREAD_FREELISTS_KINDS;++k){
if (k==(int)GC_n_kinds)
break;
return_freelists(p->_freelists[k],GC_obj_kinds[k].ok_freelist);
}
#ifdef GC_GCJ_SUPPORT
return_freelists(p->gcj_freelists,(void**)GC_gcjobjfreelist);
#endif
}
GC_API GC_ATTR_MALLOC void*GC_CALL GC_malloc_kind(size_t bytes,int kind)
{
size_t granules;
void*tsd;
void*result;
#if MAXOBJKINDS > THREAD_FREELISTS_KINDS
if (EXPECT(kind>=THREAD_FREELISTS_KINDS,FALSE)){
return GC_malloc_kind_global(bytes,kind);
}
#endif
#if!defined(USE_PTHREAD_SPECIFIC)&&!defined(USE_WIN32_SPECIFIC)
{
GC_key_t k=GC_thread_key;
if (EXPECT(0==k,FALSE)){
return GC_malloc_kind_global(bytes,kind);
}
tsd=GC_getspecific(k);
}
#else
if (!EXPECT(keys_initialized,TRUE))
return GC_malloc_kind_global(bytes,kind);
tsd=GC_getspecific(GC_thread_key);
#endif
#if!defined(USE_COMPILER_TLS)&&!defined(USE_WIN32_COMPILER_TLS)
if (EXPECT(0==tsd,FALSE)){
return GC_malloc_kind_global(bytes,kind);
}
#endif
GC_ASSERT(GC_is_initialized);
GC_ASSERT(GC_is_thread_tsd_valid(tsd));
granules=ROUNDED_UP_GRANULES(bytes);
#if defined(CPPCHECK)
#define MALLOC_KIND_PTRFREE_INIT (void*)1
#else
#define MALLOC_KIND_PTRFREE_INIT NULL
#endif
GC_FAST_MALLOC_GRANS(result,granules,
((GC_tlfs)tsd)->_freelists[kind],DIRECT_GRANULES,
kind,GC_malloc_kind_global(bytes,kind),
(void)(kind==PTRFREE?MALLOC_KIND_PTRFREE_INIT
:(obj_link(result)=0)));
#ifdef LOG_ALLOCS
GC_log_printf("GC_malloc_kind(%lu,%d)returned %p,recent GC #%lu\n",
(unsigned long)bytes,kind,result,
(unsigned long)GC_gc_no);
#endif
return result;
}
#ifdef GC_GCJ_SUPPORT
GC_API GC_ATTR_MALLOC void*GC_CALL GC_gcj_malloc(size_t bytes,
void*ptr_to_struct_containing_descr)
{
if (EXPECT(GC_incremental,FALSE)){
return GC_core_gcj_malloc(bytes,ptr_to_struct_containing_descr);
} else {
size_t granules=ROUNDED_UP_GRANULES(bytes);
void*result;
void**tiny_fl;
GC_ASSERT(GC_gcjobjfreelist!=NULL);
tiny_fl=((GC_tlfs)GC_getspecific(GC_thread_key))->gcj_freelists;
GC_FAST_MALLOC_GRANS(result,granules,tiny_fl,DIRECT_GRANULES,
GC_gcj_kind,
GC_core_gcj_malloc(bytes,
ptr_to_struct_containing_descr),
{AO_compiler_barrier();
*(void**)result=ptr_to_struct_containing_descr;});
return result;
}
}
#endif
GC_INNER void GC_mark_thread_local_fls_for(GC_tlfs p)
{
ptr_t q;
int i,j;
for (j=0;j < TINY_FREELISTS;++j){
for (i=0;i < THREAD_FREELISTS_KINDS;++i){
q=(ptr_t)AO_load((volatile AO_t*)&p->_freelists[i][j]);
if ((word)q > HBLKSIZE)
GC_set_fl_marks(q);
}
#ifdef GC_GCJ_SUPPORT
if (EXPECT(j > 0,TRUE)){
q=(ptr_t)AO_load((volatile AO_t*)&p->gcj_freelists[j]);
if ((word)q > HBLKSIZE)
GC_set_fl_marks(q);
}
#endif
}
}
#if defined(GC_ASSERTIONS)
void GC_check_tls_for(GC_tlfs p)
{
int i,j;
for (j=1;j < TINY_FREELISTS;++j){
for (i=0;i < THREAD_FREELISTS_KINDS;++i){
GC_check_fl_marks(&p->_freelists[i][j]);
}
#ifdef GC_GCJ_SUPPORT
GC_check_fl_marks(&p->gcj_freelists[j]);
#endif
}
}
#endif
#endif
#ifndef GC_PTHREAD_SUPPORT_H
#define GC_PTHREAD_SUPPORT_H
#if defined(GC_PTHREADS)&&!defined(GC_WIN32_THREADS)
#if defined(GC_DARWIN_THREADS)
#else
#ifndef GC_PTHREAD_STOP_WORLD_H
#define GC_PTHREAD_STOP_WORLD_H
EXTERN_C_BEGIN
struct thread_stop_info {
#if!defined(GC_OPENBSD_UTHREADS)&&!defined(NACL)&&!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)
volatile AO_t last_stop_count;
#endif
ptr_t stack_ptr;
#ifdef NACL
#ifdef ARM32
#define NACL_GC_REG_STORAGE_SIZE 9
#else
#define NACL_GC_REG_STORAGE_SIZE 20
#endif
ptr_t reg_storage[NACL_GC_REG_STORAGE_SIZE];
#elif defined(SN_TARGET_ORBIS)
#define ORBIS_GC_REG_STORAGE_SIZE 27
word registers[ORBIS_GC_REG_STORAGE_SIZE];
#endif
};
GC_INNER void GC_stop_init(void);
EXTERN_C_END
#endif
#endif
#ifdef THREAD_LOCAL_ALLOC
#endif
#ifdef THREAD_SANITIZER
#endif
EXTERN_C_BEGIN
typedef struct GC_Thread_Rep {
#ifdef THREAD_SANITIZER
char dummy[sizeof(oh)];
#endif
struct GC_Thread_Rep*next;
pthread_t id;
#ifdef USE_TKILL_ON_ANDROID
pid_t kernel_id;
#endif
struct thread_stop_info stop_info;
#if defined(GC_ENABLE_SUSPEND_THREAD)&&!defined(GC_DARWIN_THREADS)&&!defined(GC_OPENBSD_UTHREADS)&&!defined(NACL)
volatile AO_t suspended_ext;
#endif
unsigned char flags;
#define FINISHED 1
#define DETACHED 2
#define MAIN_THREAD 4
#define DISABLED_GC 0x10
unsigned char thread_blocked;
unsigned short finalizer_skipped;
unsigned char finalizer_nested;
ptr_t stack_end;
ptr_t altstack;
word altstack_size;
ptr_t stack;
word stack_size;
#if defined(GC_DARWIN_THREADS)&&!defined(DARWIN_DONT_PARSE_STACK)
ptr_t topOfStack;
#endif
#ifdef IA64
ptr_t backing_store_end;
ptr_t backing_store_ptr;
#endif
struct GC_traced_stack_sect_s*traced_stack_sect;
void*status;
#ifdef THREAD_LOCAL_ALLOC
struct thread_local_freelists tlfs GC_ATTR_WORD_ALIGNED;
#endif
}*GC_thread;
#ifndef THREAD_TABLE_SZ
#define THREAD_TABLE_SZ 256
#endif
#if CPP_WORDSZ==64
#define THREAD_TABLE_INDEX(id)(int)(((((NUMERIC_THREAD_ID(id)>>8)^NUMERIC_THREAD_ID(id))>>16)^((NUMERIC_THREAD_ID(id)>>8)^NUMERIC_THREAD_ID(id)))% THREAD_TABLE_SZ)
#else
#define THREAD_TABLE_INDEX(id)(int)(((NUMERIC_THREAD_ID(id)>>16)^(NUMERIC_THREAD_ID(id)>>8)^NUMERIC_THREAD_ID(id))% THREAD_TABLE_SZ)
#endif
GC_EXTERN volatile GC_thread GC_threads[THREAD_TABLE_SZ];
GC_EXTERN GC_bool GC_thr_initialized;
GC_INNER GC_thread GC_lookup_thread(pthread_t id);
#ifdef NACL
GC_EXTERN __thread GC_thread GC_nacl_gc_thread_self;
GC_INNER void GC_nacl_initialize_gc_thread(void);
GC_INNER void GC_nacl_shutdown_gc_thread(void);
#endif
#ifdef GC_EXPLICIT_SIGNALS_UNBLOCK
GC_INNER void GC_unblock_gc_signals(void);
#endif
#ifdef GC_PTHREAD_START_STANDALONE
#define GC_INNER_PTHRSTART
#else
#define GC_INNER_PTHRSTART GC_INNER
#endif
GC_INNER_PTHRSTART void*GC_CALLBACK GC_inner_start_routine(
struct GC_stack_base*sb,void*arg);
GC_INNER_PTHRSTART GC_thread GC_start_rtn_prepare_thread(
void*(**pstart)(void*),
void**pstart_arg,
struct GC_stack_base*sb,void*arg);
GC_INNER_PTHRSTART void GC_thread_exit_proc(void*);
EXTERN_C_END
#endif
#endif
#if defined(GC_DARWIN_THREADS)
#include <sys/sysctl.h>
#include <mach/machine.h>
#include <CoreFoundation/CoreFoundation.h>
#ifdef POWERPC
#if CPP_WORDSZ==32
#define PPC_RED_ZONE_SIZE 224
#elif CPP_WORDSZ==64
#define PPC_RED_ZONE_SIZE 320
#endif
#endif
#ifndef DARWIN_DONT_PARSE_STACK
typedef struct StackFrame {
unsigned long savedSP;
unsigned long savedCR;
unsigned long savedLR;
unsigned long reserved[2];
unsigned long savedRTOC;
} StackFrame;
GC_INNER ptr_t GC_FindTopOfStack(unsigned long stack_start)
{
StackFrame*frame=(StackFrame*)stack_start;
if (stack_start==0){
#ifdef POWERPC
#if CPP_WORDSZ==32
__asm__ __volatile__ ("lwz %0,0(r1)":"=r" (frame));
#else
__asm__ __volatile__ ("ld %0,0(r1)":"=r" (frame));
#endif
#elif defined(ARM32)
volatile ptr_t sp_reg;
__asm__ __volatile__ ("mov %0,r7\n":"=r" (sp_reg));
frame=(StackFrame*)sp_reg;
#elif defined(AARCH64)
volatile ptr_t sp_reg;
__asm__ __volatile__ ("mov %0,x29\n":"=r" (sp_reg));
frame=(StackFrame*)sp_reg;
#else
#if defined(CPPCHECK)
GC_noop1((word)&frame);
#endif
ABORT("GC_FindTopOfStack(0)is not implemented");
#endif
}
#ifdef DEBUG_THREADS_EXTRA
GC_log_printf("FindTopOfStack start at sp=%p\n",(void*)frame);
#endif
while (frame->savedSP!=0){
frame=(StackFrame*)frame->savedSP;
if ((frame->savedLR&~0x3)==0||(frame->savedLR&~0x3)==~0x3UL)
break;
}
#ifdef DEBUG_THREADS_EXTRA
GC_log_printf("FindTopOfStack finish at sp=%p\n",(void*)frame);
#endif
return (ptr_t)frame;
}
#endif
#ifdef GC_NO_THREADS_DISCOVERY
#define GC_query_task_threads FALSE
#elif defined(GC_DISCOVER_TASK_THREADS)
#define GC_query_task_threads TRUE
#else
STATIC GC_bool GC_query_task_threads=FALSE;
#endif
GC_API void GC_CALL GC_use_threads_discovery(void)
{
#if defined(GC_NO_THREADS_DISCOVERY)||defined(DARWIN_DONT_PARSE_STACK)
ABORT("Darwin task-threads-based stop and push unsupported");
#else
#ifndef GC_ALWAYS_MULTITHREADED
GC_ASSERT(!GC_need_to_lock);
#endif
#ifndef GC_DISCOVER_TASK_THREADS
GC_query_task_threads=TRUE;
#endif
GC_init_parallel();
#endif
}
#ifndef kCFCoreFoundationVersionNumber_iOS_8_0
#define kCFCoreFoundationVersionNumber_iOS_8_0 1140.1
#endif
STATIC ptr_t GC_stack_range_for(ptr_t*phi,thread_act_t thread,GC_thread p,
GC_bool thread_blocked,mach_port_t my_thread,
ptr_t*paltstack_lo,
ptr_t*paltstack_hi GC_ATTR_UNUSED)
{
ptr_t lo;
if (thread==my_thread){
GC_ASSERT(!thread_blocked);
lo=GC_approx_sp();
#ifndef DARWIN_DONT_PARSE_STACK
*phi=GC_FindTopOfStack(0);
#endif
} else if (thread_blocked){
#if defined(CPPCHECK)
if (NULL==p)ABORT("Invalid GC_thread passed to GC_stack_range_for");
#endif
lo=p->stop_info.stack_ptr;
#ifndef DARWIN_DONT_PARSE_STACK
*phi=p->topOfStack;
#endif
} else {
kern_return_t kern_result;
GC_THREAD_STATE_T state;
#if defined(ARM32)&&defined(ARM_THREAD_STATE32)
size_t size;
static cpu_type_t cputype=0;
if (cputype==0){
sysctlbyname("hw.cputype",&cputype,&size,NULL,0);
}
if (cputype==CPU_TYPE_ARM64
||kCFCoreFoundationVersionNumber
>=kCFCoreFoundationVersionNumber_iOS_8_0){
arm_unified_thread_state_t unified_state;
mach_msg_type_number_t unified_thread_state_count
=ARM_UNIFIED_THREAD_STATE_COUNT;
#if defined(CPPCHECK)
#define GC_ARM_UNIFIED_THREAD_STATE 1
#else
#define GC_ARM_UNIFIED_THREAD_STATE ARM_UNIFIED_THREAD_STATE
#endif
kern_result=thread_get_state(thread,GC_ARM_UNIFIED_THREAD_STATE,
(natural_t*)&unified_state,
&unified_thread_state_count);
#if!defined(CPPCHECK)
if (unified_state.ash.flavor!=ARM_THREAD_STATE32){
ABORT("unified_state flavor should be ARM_THREAD_STATE32");
}
#endif
state=unified_state;
} else
#endif
{
mach_msg_type_number_t thread_state_count=GC_MACH_THREAD_STATE_COUNT;
kern_result=thread_get_state(thread,GC_MACH_THREAD_STATE,
(natural_t*)&state,
&thread_state_count);
}
#ifdef DEBUG_THREADS
GC_log_printf("thread_get_state returns value=%d\n",kern_result);
#endif
if (kern_result!=KERN_SUCCESS)
ABORT("thread_get_state failed");
#if defined(I386)
lo=(ptr_t)state.THREAD_FLD(esp);
#ifndef DARWIN_DONT_PARSE_STACK
*phi=GC_FindTopOfStack(state.THREAD_FLD(esp));
#endif
GC_push_one(state.THREAD_FLD(eax));
GC_push_one(state.THREAD_FLD(ebx));
GC_push_one(state.THREAD_FLD(ecx));
GC_push_one(state.THREAD_FLD(edx));
GC_push_one(state.THREAD_FLD(edi));
GC_push_one(state.THREAD_FLD(esi));
GC_push_one(state.THREAD_FLD(ebp));
#elif defined(X86_64)
lo=(ptr_t)state.THREAD_FLD(rsp);
#ifndef DARWIN_DONT_PARSE_STACK
*phi=GC_FindTopOfStack(state.THREAD_FLD(rsp));
#endif
GC_push_one(state.THREAD_FLD(rax));
GC_push_one(state.THREAD_FLD(rbx));
GC_push_one(state.THREAD_FLD(rcx));
GC_push_one(state.THREAD_FLD(rdx));
GC_push_one(state.THREAD_FLD(rdi));
GC_push_one(state.THREAD_FLD(rsi));
GC_push_one(state.THREAD_FLD(rbp));
GC_push_one(state.THREAD_FLD(r8));
GC_push_one(state.THREAD_FLD(r9));
GC_push_one(state.THREAD_FLD(r10));
GC_push_one(state.THREAD_FLD(r11));
GC_push_one(state.THREAD_FLD(r12));
GC_push_one(state.THREAD_FLD(r13));
GC_push_one(state.THREAD_FLD(r14));
GC_push_one(state.THREAD_FLD(r15));
#elif defined(POWERPC)
lo=(ptr_t)(state.THREAD_FLD(r1)- PPC_RED_ZONE_SIZE);
#ifndef DARWIN_DONT_PARSE_STACK
*phi=GC_FindTopOfStack(state.THREAD_FLD(r1));
#endif
GC_push_one(state.THREAD_FLD(r0));
GC_push_one(state.THREAD_FLD(r2));
GC_push_one(state.THREAD_FLD(r3));
GC_push_one(state.THREAD_FLD(r4));
GC_push_one(state.THREAD_FLD(r5));
GC_push_one(state.THREAD_FLD(r6));
GC_push_one(state.THREAD_FLD(r7));
GC_push_one(state.THREAD_FLD(r8));
GC_push_one(state.THREAD_FLD(r9));
GC_push_one(state.THREAD_FLD(r10));
GC_push_one(state.THREAD_FLD(r11));
GC_push_one(state.THREAD_FLD(r12));
GC_push_one(state.THREAD_FLD(r13));
GC_push_one(state.THREAD_FLD(r14));
GC_push_one(state.THREAD_FLD(r15));
GC_push_one(state.THREAD_FLD(r16));
GC_push_one(state.THREAD_FLD(r17));
GC_push_one(state.THREAD_FLD(r18));
GC_push_one(state.THREAD_FLD(r19));
GC_push_one(state.THREAD_FLD(r20));
GC_push_one(state.THREAD_FLD(r21));
GC_push_one(state.THREAD_FLD(r22));
GC_push_one(state.THREAD_FLD(r23));
GC_push_one(state.THREAD_FLD(r24));
GC_push_one(state.THREAD_FLD(r25));
GC_push_one(state.THREAD_FLD(r26));
GC_push_one(state.THREAD_FLD(r27));
GC_push_one(state.THREAD_FLD(r28));
GC_push_one(state.THREAD_FLD(r29));
GC_push_one(state.THREAD_FLD(r30));
GC_push_one(state.THREAD_FLD(r31));
#elif defined(ARM32)
lo=(ptr_t)state.THREAD_FLD(sp);
#ifndef DARWIN_DONT_PARSE_STACK
*phi=GC_FindTopOfStack(state.THREAD_FLD(r[7]));
#endif
{
int j;
for (j=0;j < 7;j++)
GC_push_one(state.THREAD_FLD(r[j]));
j++;
for (;j<=12;j++)
GC_push_one(state.THREAD_FLD(r[j]));
}
GC_push_one(state.THREAD_FLD(lr));
#elif defined(AARCH64)
lo=(ptr_t)state.THREAD_FLD(sp);
#ifndef DARWIN_DONT_PARSE_STACK
*phi=GC_FindTopOfStack(state.THREAD_FLD(fp));
#endif
{
int j;
for (j=0;j<=28;j++){
GC_push_one(state.THREAD_FLD(x[j]));
}
}
GC_push_one(state.THREAD_FLD(lr));
#elif defined(CPPCHECK)
lo=NULL;
#else
#error FIXME for non-arm/ppc/x86 architectures
#endif
}
#ifdef DARWIN_DONT_PARSE_STACK
*phi=(p->flags&MAIN_THREAD)!=0?GC_stackbottom:p->stack_end;
#endif
#ifdef DARWIN_DONT_PARSE_STACK
if (p->altstack!=NULL&&(word)p->altstack<=(word)lo
&&(word)lo<=(word)p->altstack+p->altstack_size){
*paltstack_lo=lo;
*paltstack_hi=p->altstack+p->altstack_size;
lo=p->stack;
*phi=p->stack+p->stack_size;
} else
#endif
{
*paltstack_lo=NULL;
}
#ifdef DEBUG_THREADS
GC_log_printf("Darwin:Stack for thread %p=[%p,%p)\n",
(void*)(word)thread,(void*)lo,(void*)(*phi));
#endif
return lo;
}
GC_INNER void GC_push_all_stacks(void)
{
ptr_t hi,altstack_lo,altstack_hi;
task_t my_task=current_task();
mach_port_t my_thread=mach_thread_self();
GC_bool found_me=FALSE;
int nthreads=0;
word total_size=0;
mach_msg_type_number_t listcount=(mach_msg_type_number_t)THREAD_TABLE_SZ;
if (!EXPECT(GC_thr_initialized,TRUE))
GC_thr_init();
#ifndef DARWIN_DONT_PARSE_STACK
if (GC_query_task_threads){
int i;
kern_return_t kern_result;
thread_act_array_t act_list=0;
kern_result=task_threads(my_task,&act_list,&listcount);
if (kern_result!=KERN_SUCCESS)
ABORT("task_threads failed");
for (i=0;i < (int)listcount;i++){
thread_act_t thread=act_list[i];
ptr_t lo=GC_stack_range_for(&hi,thread,NULL,FALSE,my_thread,
&altstack_lo,&altstack_hi);
if (lo){
GC_ASSERT((word)lo<=(word)hi);
total_size+=hi - lo;
GC_push_all_stack(lo,hi);
}
nthreads++;
if (thread==my_thread)
found_me=TRUE;
mach_port_deallocate(my_task,thread);
}
vm_deallocate(my_task,(vm_address_t)act_list,
sizeof(thread_t)*listcount);
} else
#endif
{
int i;
for (i=0;i < (int)listcount;i++){
GC_thread p;
for (p=GC_threads[i];p!=NULL;p=p->next)
if ((p->flags&FINISHED)==0){
thread_act_t thread=(thread_act_t)p->stop_info.mach_thread;
ptr_t lo=GC_stack_range_for(&hi,thread,p,
(GC_bool)p->thread_blocked,
my_thread,&altstack_lo,
&altstack_hi);
if (lo){
GC_ASSERT((word)lo<=(word)hi);
total_size+=hi - lo;
GC_push_all_stack_sections(lo,hi,p->traced_stack_sect);
}
if (altstack_lo){
total_size+=altstack_hi - altstack_lo;
GC_push_all_stack(altstack_lo,altstack_hi);
}
nthreads++;
if (thread==my_thread)
found_me=TRUE;
}
}
}
mach_port_deallocate(my_task,my_thread);
GC_VERBOSE_LOG_PRINTF("Pushed %d thread stacks\n",nthreads);
if (!found_me&&!GC_in_thread_creation)
ABORT("Collecting from unknown thread");
GC_total_stacksize=total_size;
}
#ifndef GC_NO_THREADS_DISCOVERY
#ifdef MPROTECT_VDB
STATIC mach_port_t GC_mach_handler_thread=0;
STATIC GC_bool GC_use_mach_handler_thread=FALSE;
GC_INNER void GC_darwin_register_mach_handler_thread(mach_port_t thread)
{
GC_mach_handler_thread=thread;
GC_use_mach_handler_thread=TRUE;
}
#endif
#ifndef GC_MAX_MACH_THREADS
#define GC_MAX_MACH_THREADS THREAD_TABLE_SZ
#endif
struct GC_mach_thread {
thread_act_t thread;
GC_bool suspended;
};
struct GC_mach_thread GC_mach_threads[GC_MAX_MACH_THREADS];
STATIC int GC_mach_threads_count=0;
STATIC GC_bool GC_suspend_thread_list(thread_act_array_t act_list,int count,
thread_act_array_t old_list,
int old_count,task_t my_task,
mach_port_t my_thread)
{
int i;
int j=-1;
GC_bool changed=FALSE;
for (i=0;i < count;i++){
thread_act_t thread=act_list[i];
GC_bool found;
kern_return_t kern_result;
if (thread==my_thread
#ifdef MPROTECT_VDB
||(GC_mach_handler_thread==thread&&GC_use_mach_handler_thread)
#endif
#ifdef PARALLEL_MARK
||GC_is_mach_marker(thread)
#endif
){
mach_port_deallocate(my_task,thread);
continue;
}
found=FALSE;
{
int last_found=j;
while (++j < old_count)
if (old_list[j]==thread){
found=TRUE;
break;
}
if (!found){
for (j=0;j < last_found;j++)
if (old_list[j]==thread){
found=TRUE;
break;
}
}
}
if (found){
mach_port_deallocate(my_task,thread);
continue;
}
if (GC_mach_threads_count==GC_MAX_MACH_THREADS)
ABORT("Too many threads");
GC_mach_threads[GC_mach_threads_count].thread=thread;
GC_mach_threads[GC_mach_threads_count].suspended=FALSE;
changed=TRUE;
#ifdef DEBUG_THREADS
GC_log_printf("Suspending %p\n",(void*)(word)thread);
#endif
GC_acquire_dirty_lock();
do {
kern_result=thread_suspend(thread);
} while (kern_result==KERN_ABORTED);
GC_release_dirty_lock();
if (kern_result!=KERN_SUCCESS){
GC_mach_threads[GC_mach_threads_count].suspended=FALSE;
} else {
GC_mach_threads[GC_mach_threads_count].suspended=TRUE;
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_SUSPENDED,(void*)(word)thread);
}
GC_mach_threads_count++;
}
return changed;
}
#endif
GC_INNER void GC_stop_world(void)
{
task_t my_task=current_task();
mach_port_t my_thread=mach_thread_self();
kern_return_t kern_result;
#ifdef DEBUG_THREADS
GC_log_printf("Stopping the world from thread %p\n",
(void*)(word)my_thread);
#endif
#ifdef PARALLEL_MARK
if (GC_parallel){
GC_acquire_mark_lock();
GC_ASSERT(GC_fl_builder_count==0);
}
#endif
if (GC_query_task_threads){
#ifndef GC_NO_THREADS_DISCOVERY
GC_bool changed;
thread_act_array_t act_list,prev_list;
mach_msg_type_number_t listcount,prevcount;
GC_mach_threads_count=0;
changed=TRUE;
prev_list=NULL;
prevcount=0;
do {
kern_result=task_threads(my_task,&act_list,&listcount);
if (kern_result==KERN_SUCCESS){
changed=GC_suspend_thread_list(act_list,listcount,prev_list,
prevcount,my_task,my_thread);
if (prev_list!=NULL){
vm_deallocate(my_task,(vm_address_t)prev_list,
sizeof(thread_t)*prevcount);
}
prev_list=act_list;
prevcount=listcount;
}
} while (changed);
GC_ASSERT(prev_list!=0);
vm_deallocate(my_task,(vm_address_t)act_list,
sizeof(thread_t)*listcount);
#endif
} else {
unsigned i;
for (i=0;i < THREAD_TABLE_SZ;i++){
GC_thread p;
for (p=GC_threads[i];p!=NULL;p=p->next){
if ((p->flags&FINISHED)==0&&!p->thread_blocked&&
p->stop_info.mach_thread!=my_thread){
GC_acquire_dirty_lock();
do {
kern_result=thread_suspend(p->stop_info.mach_thread);
} while (kern_result==KERN_ABORTED);
GC_release_dirty_lock();
if (kern_result!=KERN_SUCCESS)
ABORT("thread_suspend failed");
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_SUSPENDED,
(void*)(word)p->stop_info.mach_thread);
}
}
}
}
#ifdef MPROTECT_VDB
if (GC_auto_incremental){
GC_mprotect_stop();
}
#endif
#ifdef PARALLEL_MARK
if (GC_parallel)
GC_release_mark_lock();
#endif
#ifdef DEBUG_THREADS
GC_log_printf("World stopped from %p\n",(void*)(word)my_thread);
#endif
mach_port_deallocate(my_task,my_thread);
}
GC_INLINE void GC_thread_resume(thread_act_t thread)
{
kern_return_t kern_result;
#if defined(DEBUG_THREADS)||defined(GC_ASSERTIONS)
struct thread_basic_info info;
mach_msg_type_number_t outCount=THREAD_BASIC_INFO_COUNT;
#if defined(CPPCHECK)&&defined(DEBUG_THREADS)
info.run_state=0;
#endif
kern_result=thread_info(thread,THREAD_BASIC_INFO,
(thread_info_t)&info,&outCount);
if (kern_result!=KERN_SUCCESS)
ABORT("thread_info failed");
#endif
#ifdef DEBUG_THREADS
GC_log_printf("Resuming thread %p with state %d\n",(void*)(word)thread,
info.run_state);
#endif
kern_result=thread_resume(thread);
if (kern_result!=KERN_SUCCESS){
WARN("thread_resume(%p)failed:mach port invalid\n",thread);
} else if (GC_on_thread_event){
GC_on_thread_event(GC_EVENT_THREAD_UNSUSPENDED,(void*)(word)thread);
}
}
GC_INNER void GC_start_world(void)
{
task_t my_task=current_task();
#ifdef DEBUG_THREADS
GC_log_printf("World starting\n");
#endif
#ifdef MPROTECT_VDB
if (GC_auto_incremental){
GC_mprotect_resume();
}
#endif
if (GC_query_task_threads){
#ifndef GC_NO_THREADS_DISCOVERY
int i,j;
kern_return_t kern_result;
thread_act_array_t act_list;
mach_msg_type_number_t listcount;
kern_result=task_threads(my_task,&act_list,&listcount);
if (kern_result!=KERN_SUCCESS)
ABORT("task_threads failed");
j=(int)listcount;
for (i=0;i < GC_mach_threads_count;i++){
thread_act_t thread=GC_mach_threads[i].thread;
if (GC_mach_threads[i].suspended){
int last_found=j;
while (++j < (int)listcount){
if (act_list[j]==thread)
break;
}
if (j>=(int)listcount){
for (j=0;j < last_found;j++){
if (act_list[j]==thread)
break;
}
}
if (j!=last_found){
GC_thread_resume(thread);
}
} else {
#ifdef DEBUG_THREADS
GC_log_printf("Not resuming thread %p as it is not suspended\n",
(void*)(word)thread);
#endif
}
mach_port_deallocate(my_task,thread);
}
for (i=0;i < (int)listcount;i++)
mach_port_deallocate(my_task,act_list[i]);
vm_deallocate(my_task,(vm_address_t)act_list,
sizeof(thread_t)*listcount);
#endif
} else {
int i;
mach_port_t my_thread=mach_thread_self();
for (i=0;i < THREAD_TABLE_SZ;i++){
GC_thread p;
for (p=GC_threads[i];p!=NULL;p=p->next){
if ((p->flags&FINISHED)==0&&!p->thread_blocked&&
p->stop_info.mach_thread!=my_thread)
GC_thread_resume(p->stop_info.mach_thread);
}
}
mach_port_deallocate(my_task,my_thread);
}
#ifdef DEBUG_THREADS
GC_log_printf("World started\n");
#endif
}
#endif
#if!defined(MACOS)&&!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)&&!defined(_WIN32_WCE)&&!defined(__CC_ARM)
#include <sys/types.h>
#endif
#undef GC_MUST_RESTORE_REDEFINED_DLOPEN
#if defined(GC_PTHREADS)&&!defined(GC_NO_DLOPEN)&&!defined(GC_NO_THREAD_REDIRECTS)&&!defined(GC_USE_LD_WRAP)
#undef dlopen
#define GC_MUST_RESTORE_REDEFINED_DLOPEN
#endif
STATIC GC_has_static_roots_func GC_has_static_roots=0;
#if (defined(DYNAMIC_LOADING)||defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32))&&!defined(PCR)
#if!defined(DARWIN)&&!defined(SCO_ELF)&&!defined(SOLARISDL)&&!defined(AIX)&&!defined(DGUX)&&!defined(IRIX5)&&!defined(HPUX)&&!defined(CYGWIN32)&&!defined(MSWIN32)&&!defined(MSWINCE)&&!(defined(ALPHA)&&defined(OSF1))&&!(defined(FREEBSD)&&defined(__ELF__))&&!(defined(LINUX)&&defined(__ELF__))&&!(defined(NETBSD)&&defined(__ELF__))&&!(defined(OPENBSD)&&(defined(__ELF__)||defined(M68K)))&&!defined(HAIKU)&&!defined(HURD)&&!defined(NACL)&&!defined(CPPCHECK)
#error We only know how to find data segments of dynamic libraries for above.
#error Additional SVR4 variants might not be too hard to add.
#endif
#include <stdio.h>
#ifdef SOLARISDL
#include <sys/elf.h>
#include <dlfcn.h>
#include <link.h>
#endif
#if defined(NETBSD)
#include <sys/param.h>
#include <dlfcn.h>
#include <machine/elf_machdep.h>
#define ELFSIZE ARCH_ELFSIZE
#endif
#if defined(OPENBSD)
#include <sys/param.h>
#if (OpenBSD>=200519)&&!defined(HAVE_DL_ITERATE_PHDR)
#define HAVE_DL_ITERATE_PHDR
#endif
#endif
#if defined(SCO_ELF)||defined(DGUX)||defined(HURD)||defined(NACL)||(defined(__ELF__)&&(defined(LINUX)||defined(FREEBSD)||defined(NETBSD)||defined(OPENBSD)))
#include <stddef.h>
#if!defined(OPENBSD)&&!defined(HOST_ANDROID)
#include <elf.h>
#endif
#ifdef HOST_ANDROID
#ifdef BIONIC_ELFDATA_REDEF_BUG
#include <asm/elf.h>
#include <linux/elf-em.h>
#undef ELF_DATA
#undef EM_ALPHA
#endif
#include <link.h>
#if!defined(GC_DONT_DEFINE_LINK_MAP)&&!(__ANDROID_API__>=21)
struct link_map {
uintptr_t l_addr;
char*l_name;
uintptr_t l_ld;
struct link_map*l_next;
struct link_map*l_prev;
};
struct r_debug {
int32_t r_version;
struct link_map*r_map;
void (*r_brk)(void);
int32_t r_state;
uintptr_t r_ldbase;
};
#endif
#else
EXTERN_C_BEGIN
#include <link.h>
EXTERN_C_END
#endif
#endif
#ifndef ElfW
#if defined(FREEBSD)
#if __ELF_WORD_SIZE==32
#define ElfW(type)Elf32_##type
#else
#define ElfW(type)Elf64_##type
#endif
#elif defined(NETBSD)||defined(OPENBSD)
#if ELFSIZE==32
#define ElfW(type)Elf32_##type
#elif ELFSIZE==64
#define ElfW(type)Elf64_##type
#else
#error Missing ELFSIZE define
#endif
#else
#if!defined(ELF_CLASS)||ELF_CLASS==ELFCLASS32
#define ElfW(type)Elf32_##type
#else
#define ElfW(type)Elf64_##type
#endif
#endif
#endif
#if defined(SOLARISDL)&&!defined(USE_PROC_FOR_LIBRARIES)
EXTERN_C_BEGIN
extern ElfW(Dyn)_DYNAMIC;
EXTERN_C_END
STATIC struct link_map*
GC_FirstDLOpenedLinkMap(void)
{
ElfW(Dyn)*dp;
static struct link_map*cachedResult=0;
static ElfW(Dyn)*dynStructureAddr=0;
#ifdef SUNOS53_SHARED_LIB
if( dynStructureAddr==0){
void*startupSyms=dlopen(0,RTLD_LAZY);
dynStructureAddr=(ElfW(Dyn)*)(word)dlsym(startupSyms,"_DYNAMIC");
}
#else
dynStructureAddr=&_DYNAMIC;
#endif
if (0==COVERT_DATAFLOW(dynStructureAddr)){
return(0);
}
if (cachedResult==0){
int tag;
for( dp=((ElfW(Dyn)*)(&_DYNAMIC));(tag=dp->d_tag)!=0;dp++){
if (tag==DT_DEBUG){
struct r_debug*rd=(struct r_debug*)dp->d_un.d_ptr;
if (rd!=NULL){
struct link_map*lm=rd->r_map;
if (lm!=NULL)
cachedResult=lm->l_next;
}
break;
}
}
}
return cachedResult;
}
#endif
#ifdef GC_MUST_RESTORE_REDEFINED_DLOPEN
#define dlopen GC_dlopen
#endif
#if defined(SOLARISDL)
#if!defined(PCR)&&!defined(GC_SOLARIS_THREADS)&&defined(THREADS)&&!defined(CPPCHECK)
#error Fix mutual exclusion with dlopen
#endif
#ifndef USE_PROC_FOR_LIBRARIES
GC_INNER void GC_register_dynamic_libraries(void)
{
struct link_map*lm;
for (lm=GC_FirstDLOpenedLinkMap();lm!=0;lm=lm->l_next){
ElfW(Ehdr)*e;
ElfW(Phdr)*p;
unsigned long offset;
char*start;
int i;
e=(ElfW(Ehdr)*)lm->l_addr;
p=((ElfW(Phdr)*)(((char*)(e))+e->e_phoff));
offset=((unsigned long)(lm->l_addr));
for( i=0;i < (int)e->e_phnum;i++,p++){
switch( p->p_type){
case PT_LOAD:
{
if(!(p->p_flags&PF_W))break;
start=((char*)(p->p_vaddr))+offset;
GC_add_roots_inner(start,start+p->p_memsz,TRUE);
}
break;
default:
break;
}
}
}
}
#endif
#endif
#if defined(SCO_ELF)||defined(DGUX)||defined(HURD)||defined(NACL)||(defined(__ELF__)&&(defined(LINUX)||defined(FREEBSD)||defined(NETBSD)||defined(OPENBSD)))
#ifdef USE_PROC_FOR_LIBRARIES
#include <string.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#define MAPS_BUF_SIZE (32*1024)
static void sort_heap_sects(struct HeapSect*base,size_t number_of_elements)
{
signed_word n=(signed_word)number_of_elements;
signed_word nsorted=1;
while (nsorted < n){
signed_word i;
while (nsorted < n&&
(word)base[nsorted-1].hs_start < (word)base[nsorted].hs_start)
++nsorted;
if (nsorted==n)break;
GC_ASSERT((word)base[nsorted-1].hs_start > (word)base[nsorted].hs_start);
i=nsorted - 1;
while (i>=0&&(word)base[i].hs_start > (word)base[i+1].hs_start){
struct HeapSect tmp=base[i];
base[i]=base[i+1];
base[i+1]=tmp;
--i;
}
GC_ASSERT((word)base[nsorted-1].hs_start < (word)base[nsorted].hs_start);
++nsorted;
}
}
STATIC void GC_register_map_entries(char*maps)
{
char*prot;
char*buf_ptr=maps;
ptr_t start,end;
unsigned int maj_dev;
ptr_t least_ha,greatest_ha;
unsigned i;
GC_ASSERT(I_HOLD_LOCK());
sort_heap_sects(GC_our_memory,GC_n_memory);
least_ha=GC_our_memory[0].hs_start;
greatest_ha=GC_our_memory[GC_n_memory-1].hs_start
+GC_our_memory[GC_n_memory-1].hs_bytes;
for (;;){
buf_ptr=GC_parse_map_entry(buf_ptr,&start,&end,&prot,
&maj_dev,0);
if (NULL==buf_ptr)
break;
if (prot[1]=='w'){
if ((word)start<=(word)GC_stackbottom
&&(word)end>=(word)GC_stackbottom){
continue;
}
#ifdef THREADS
if (GC_segment_is_thread_stack(start,end))continue;
#endif
if ((word)end<=(word)least_ha
||(word)start>=(word)greatest_ha){
GC_add_roots_inner(start,end,TRUE);
continue;
}
i=0;
while ((word)(GC_our_memory[i].hs_start
+GC_our_memory[i].hs_bytes)< (word)start)
++i;
GC_ASSERT(i < GC_n_memory);
if ((word)GC_our_memory[i].hs_start<=(word)start){
start=GC_our_memory[i].hs_start
+GC_our_memory[i].hs_bytes;
++i;
}
while (i < GC_n_memory
&&(word)GC_our_memory[i].hs_start < (word)end
&&(word)start < (word)end){
if ((word)start < (word)GC_our_memory[i].hs_start)
GC_add_roots_inner(start,
GC_our_memory[i].hs_start,TRUE);
start=GC_our_memory[i].hs_start
+GC_our_memory[i].hs_bytes;
++i;
}
if ((word)start < (word)end)
GC_add_roots_inner(start,end,TRUE);
} else if (prot[0]=='-'&&prot[1]=='-'&&prot[2]=='-'){
GC_remove_roots_subregion(start,end);
}
}
}
GC_INNER void GC_register_dynamic_libraries(void)
{
char*maps=GC_get_maps();
if (NULL==maps)
ABORT("Failed to read/proc for library registration");
GC_register_map_entries(maps);
}
GC_INNER GC_bool GC_register_main_static_data(void)
{
return FALSE;
}
#define HAVE_REGISTER_MAIN_STATIC_DATA
#else
#if __GLIBC__ > 2||(__GLIBC__==2&&__GLIBC_MINOR__ > 2)||(__GLIBC__==2&&__GLIBC_MINOR__==2&&defined(DT_CONFIG))||defined(HOST_ANDROID)
#ifndef HAVE_DL_ITERATE_PHDR
#define HAVE_DL_ITERATE_PHDR
#endif
#ifdef HOST_ANDROID
EXTERN_C_BEGIN
extern int dl_iterate_phdr(int (*cb)(struct dl_phdr_info*,
size_t,void*),
void*data);
EXTERN_C_END
#endif
#endif
#if defined(__DragonFly__)||defined(__FreeBSD_kernel__)||(defined(FREEBSD)&&__FreeBSD__>=7)
#ifndef HAVE_DL_ITERATE_PHDR
#define HAVE_DL_ITERATE_PHDR
#endif
#define DL_ITERATE_PHDR_STRONG
#elif defined(HAVE_DL_ITERATE_PHDR)
EXTERN_C_BEGIN
#pragma weak dl_iterate_phdr
EXTERN_C_END
#endif
#if defined(HAVE_DL_ITERATE_PHDR)
#ifdef PT_GNU_RELRO
#define MAX_LOAD_SEGS MAX_ROOT_SETS
static struct load_segment {
ptr_t start;
ptr_t end;
ptr_t start2;
ptr_t end2;
} load_segs[MAX_LOAD_SEGS];
static int n_load_segs;
static GC_bool load_segs_overflow;
#endif
STATIC int GC_register_dynlib_callback(struct dl_phdr_info*info,
size_t size,void*ptr)
{
const ElfW(Phdr)*p;
ptr_t start,end;
int i;
if (size < offsetof (struct dl_phdr_info,dlpi_phnum)
+sizeof (info->dlpi_phnum))
return -1;
p=info->dlpi_phdr;
for (i=0;i < (int)info->dlpi_phnum;i++,p++){
if (p->p_type==PT_LOAD){
GC_has_static_roots_func callback=GC_has_static_roots;
if ((p->p_flags&PF_W)==0)continue;
start=(ptr_t)p->p_vaddr+info->dlpi_addr;
end=start+p->p_memsz;
if (callback!=0&&!callback(info->dlpi_name,start,p->p_memsz))
continue;
#ifdef PT_GNU_RELRO
#if CPP_WORDSZ==64
start=(ptr_t)((word)start&~(word)(sizeof(word)- 1));
#endif
if (n_load_segs>=MAX_LOAD_SEGS){
if (!load_segs_overflow){
WARN("Too many PT_LOAD segments;"
" registering as roots directly...\n",0);
load_segs_overflow=TRUE;
}
GC_add_roots_inner(start,end,TRUE);
} else {
load_segs[n_load_segs].start=start;
load_segs[n_load_segs].end=end;
load_segs[n_load_segs].start2=0;
load_segs[n_load_segs].end2=0;
++n_load_segs;
}
#else
GC_add_roots_inner(start,end,TRUE);
#endif
}
}
#ifdef PT_GNU_RELRO
p=info->dlpi_phdr;
for (i=0;i < (int)info->dlpi_phnum;i++,p++){
if (p->p_type==PT_GNU_RELRO){
int j;
start=(ptr_t)p->p_vaddr+info->dlpi_addr;
end=start+p->p_memsz;
for (j=n_load_segs;--j>=0;){
if ((word)start>=(word)load_segs[j].start
&&(word)start < (word)load_segs[j].end){
if (load_segs[j].start2!=0){
WARN("More than one GNU_RELRO segment per load one\n",0);
} else {
GC_ASSERT((word)end<=(word)load_segs[j].end);
load_segs[j].end2=load_segs[j].end;
load_segs[j].end=start;
load_segs[j].start2=end;
}
break;
}
if (0==j&&0==GC_has_static_roots)
WARN("Failed to find PT_GNU_RELRO segment"
" inside PT_LOAD region\n",0);
}
}
}
#endif
*(int*)ptr=1;
return 0;
}
GC_INNER GC_bool GC_register_main_static_data(void)
{
#ifdef DL_ITERATE_PHDR_STRONG
return FALSE;
#else
return 0==COVERT_DATAFLOW(dl_iterate_phdr);
#endif
}
STATIC GC_bool GC_register_dynamic_libraries_dl_iterate_phdr(void)
{
int did_something;
if (GC_register_main_static_data())
return FALSE;
#ifdef PT_GNU_RELRO
{
static GC_bool excluded_segs=FALSE;
n_load_segs=0;
load_segs_overflow=FALSE;
if (!EXPECT(excluded_segs,TRUE)){
GC_exclude_static_roots_inner((ptr_t)load_segs,
(ptr_t)load_segs+sizeof(load_segs));
excluded_segs=TRUE;
}
}
#endif
did_something=0;
dl_iterate_phdr(GC_register_dynlib_callback,&did_something);
if (did_something){
#ifdef PT_GNU_RELRO
int i;
for (i=0;i < n_load_segs;++i){
if ((word)load_segs[i].end > (word)load_segs[i].start){
GC_add_roots_inner(load_segs[i].start,load_segs[i].end,TRUE);
}
if ((word)load_segs[i].end2 > (word)load_segs[i].start2){
GC_add_roots_inner(load_segs[i].start2,load_segs[i].end2,TRUE);
}
}
#endif
} else {
ptr_t datastart,dataend;
#ifdef DATASTART_IS_FUNC
static ptr_t datastart_cached=(ptr_t)GC_WORD_MAX;
if (datastart_cached==(ptr_t)GC_WORD_MAX){
datastart_cached=DATASTART;
}
datastart=datastart_cached;
#else
datastart=DATASTART;
#endif
#ifdef DATAEND_IS_FUNC
{
static ptr_t dataend_cached=0;
if (dataend_cached==0){
dataend_cached=DATAEND;
}
dataend=dataend_cached;
}
#else
dataend=DATAEND;
#endif
if (NULL==*(char*volatile*)&datastart
||(word)datastart > (word)dataend)
ABORT_ARG2("Wrong DATASTART/END pair",
":%p .. %p",(void*)datastart,(void*)dataend);
GC_add_roots_inner(datastart,dataend,TRUE);
#ifdef GC_HAVE_DATAREGION2
if ((word)DATASTART2 - 1U>=(word)DATAEND2){
ABORT_ARG2("Wrong DATASTART/END2 pair",
":%p .. %p",(void*)DATASTART2,(void*)DATAEND2);
}
GC_add_roots_inner(DATASTART2,DATAEND2,TRUE);
#endif
}
return TRUE;
}
#define HAVE_REGISTER_MAIN_STATIC_DATA
#else
#if defined(NETBSD)||defined(OPENBSD)
#include <sys/exec_elf.h>
#ifndef DT_DEBUG
#define DT_DEBUG 21
#endif
#ifndef PT_LOAD
#define PT_LOAD 1
#endif
#ifndef PF_W
#define PF_W 2
#endif
#elif!defined(HOST_ANDROID)
#include <elf.h>
#endif
#ifndef HOST_ANDROID
#include <link.h>
#endif
#endif
EXTERN_C_BEGIN
#ifdef __GNUC__
#pragma weak _DYNAMIC
#endif
extern ElfW(Dyn)_DYNAMIC[];
EXTERN_C_END
STATIC struct link_map*
GC_FirstDLOpenedLinkMap(void)
{
static struct link_map*cachedResult=0;
if (0==COVERT_DATAFLOW(_DYNAMIC)){
return(0);
}
if( cachedResult==0){
#if defined(NETBSD)&&defined(RTLD_DI_LINKMAP)
#if defined(CPPCHECK)
#define GC_RTLD_DI_LINKMAP 2
#else
#define GC_RTLD_DI_LINKMAP RTLD_DI_LINKMAP
#endif
struct link_map*lm=NULL;
if (!dlinfo(RTLD_SELF,GC_RTLD_DI_LINKMAP,&lm)&&lm!=NULL){
while (lm->l_prev!=NULL){
lm=lm->l_prev;
}
cachedResult=lm->l_next;
}
#else
ElfW(Dyn)*dp;
int tag;
for( dp=_DYNAMIC;(tag=dp->d_tag)!=0;dp++){
if (tag==DT_DEBUG){
struct r_debug*rd=(struct r_debug*)dp->d_un.d_ptr;
if (rd!=NULL){
struct link_map*lm=rd->r_map;
if (lm!=NULL)
cachedResult=lm->l_next;
}
break;
}
}
#endif
}
return cachedResult;
}
GC_INNER void GC_register_dynamic_libraries(void)
{
struct link_map*lm;
#ifdef HAVE_DL_ITERATE_PHDR
if (GC_register_dynamic_libraries_dl_iterate_phdr()){
return;
}
#endif
for (lm=GC_FirstDLOpenedLinkMap();lm!=0;lm=lm->l_next)
{
ElfW(Ehdr)*e;
ElfW(Phdr)*p;
unsigned long offset;
char*start;
int i;
e=(ElfW(Ehdr)*)lm->l_addr;
#ifdef HOST_ANDROID
if (e==NULL)
continue;
#endif
p=((ElfW(Phdr)*)(((char*)(e))+e->e_phoff));
offset=((unsigned long)(lm->l_addr));
for( i=0;i < (int)e->e_phnum;i++,p++){
switch( p->p_type){
case PT_LOAD:
{
if(!(p->p_flags&PF_W))break;
start=((char*)(p->p_vaddr))+offset;
GC_add_roots_inner(start,start+p->p_memsz,TRUE);
}
break;
default:
break;
}
}
}
}
#endif
#endif
#if defined(IRIX5)||(defined(USE_PROC_FOR_LIBRARIES)&&!defined(LINUX))
#include <sys/procfs.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <elf.h>
#include <errno.h>
#include <signal.h>
#ifndef _sigargs
#define IRIX6
#endif
GC_INNER void GC_register_dynamic_libraries(void)
{
static int fd=-1;
char buf[30];
static prmap_t*addr_map=0;
static int current_sz=0;
int needed_sz=0;
int i;
long flags;
ptr_t start;
ptr_t limit;
ptr_t heap_start=HEAP_START;
ptr_t heap_end=heap_start;
#ifdef SOLARISDL
#define MA_PHYS 0
#endif
if (fd < 0){
(void)snprintf(buf,sizeof(buf),"/proc/%ld",(long)getpid());
buf[sizeof(buf)- 1]='\0';
fd=open(buf,O_RDONLY);
if (fd < 0){
ABORT("/proc open failed");
}
}
if (ioctl(fd,PIOCNMAP,&needed_sz)< 0){
ABORT_ARG2("/proc PIOCNMAP ioctl failed",
":fd=%d,errno=%d",fd,errno);
}
if (needed_sz>=current_sz){
GC_scratch_recycle_no_gww(addr_map,
(size_t)current_sz*sizeof(prmap_t));
current_sz=needed_sz*2+1;
addr_map=(prmap_t*)GC_scratch_alloc(
(size_t)current_sz*sizeof(prmap_t));
if (addr_map==NULL)
ABORT("Insufficient memory for address map");
}
if (ioctl(fd,PIOCMAP,addr_map)< 0){
ABORT_ARG3("/proc PIOCMAP ioctl failed",
":errcode=%d,needed_sz=%d,addr_map=%p",
errno,needed_sz,(void*)addr_map);
};
if (GC_n_heap_sects > 0){
heap_end=GC_heap_sects[GC_n_heap_sects-1].hs_start
+GC_heap_sects[GC_n_heap_sects-1].hs_bytes;
if ((word)heap_end < (word)GC_scratch_last_end_ptr)
heap_end=GC_scratch_last_end_ptr;
}
for (i=0;i < needed_sz;i++){
flags=addr_map[i].pr_mflags;
if ((flags&(MA_BREAK|MA_STACK|MA_PHYS
|MA_FETCHOP|MA_NOTCACHED))!=0)goto irrelevant;
if ((flags&(MA_READ|MA_WRITE))!=(MA_READ|MA_WRITE))
goto irrelevant;
start=(ptr_t)(addr_map[i].pr_vaddr);
if (GC_roots_present(start))goto irrelevant;
if ((word)start < (word)heap_end&&(word)start>=(word)heap_start)
goto irrelevant;
limit=start+addr_map[i].pr_size;
#ifndef IRIX6
if (addr_map[i].pr_off==0&&strncmp(start,ELFMAG,4)==0){
caddr_t arg;
int obj;
#define MAP_IRR_SZ 10
static ptr_t map_irr[MAP_IRR_SZ];
static int n_irr=0;
struct stat buf;
int j;
for (j=0;j < n_irr;j++){
if (map_irr[j]==start)goto irrelevant;
}
arg=(caddr_t)start;
obj=ioctl(fd,PIOCOPENM,&arg);
if (obj>=0){
fstat(obj,&buf);
close(obj);
if ((buf.st_mode&0111)!=0){
if (n_irr < MAP_IRR_SZ){
map_irr[n_irr++]=start;
}
goto irrelevant;
}
}
}
#endif
GC_add_roots_inner(start,limit,TRUE);
irrelevant:;
}
if (close(fd)< 0)ABORT("Couldn't close/proc file");
fd=-1;
}
#endif
#if defined(MSWIN32)||defined(MSWINCE)||defined(CYGWIN32)
#include <stdlib.h>
STATIC void GC_cond_add_roots(char*base,char*limit)
{
#ifdef GC_WIN32_THREADS
char*curr_base=base;
char*next_stack_lo;
char*next_stack_hi;
if (base==limit)return;
for(;;){
GC_get_next_stack(curr_base,limit,&next_stack_lo,&next_stack_hi);
if ((word)next_stack_lo>=(word)limit)break;
if ((word)next_stack_lo > (word)curr_base)
GC_add_roots_inner(curr_base,next_stack_lo,TRUE);
curr_base=next_stack_hi;
}
if ((word)curr_base < (word)limit)
GC_add_roots_inner(curr_base,limit,TRUE);
#else
char*stack_top
=(char*)((word)GC_approx_sp()&
~(word)(GC_sysinfo.dwAllocationGranularity - 1));
if (base==limit)return;
if ((word)limit > (word)stack_top
&&(word)base < (word)GC_stackbottom){
return;
}
GC_add_roots_inner(base,limit,TRUE);
#endif
}
#ifdef DYNAMIC_LOADING
GC_INNER GC_bool GC_register_main_static_data(void)
{
#if defined(MSWINCE)||defined(CYGWIN32)
return FALSE;
#else
return GC_no_win32_dlls;
#endif
}
#define HAVE_REGISTER_MAIN_STATIC_DATA
#endif
#ifdef DEBUG_VIRTUALQUERY
void GC_dump_meminfo(MEMORY_BASIC_INFORMATION*buf)
{
GC_printf("BaseAddress=0x%lx,AllocationBase=0x%lx,"
" RegionSize=0x%lx(%lu)\n",buf->BaseAddress,
buf->AllocationBase,buf->RegionSize,buf->RegionSize);
GC_printf("\tAllocationProtect=0x%lx,State=0x%lx,Protect=0x%lx,"
"Type=0x%lx\n",buf->AllocationProtect,buf->State,
buf->Protect,buf->Type);
}
#endif
#if defined(MSWINCE)||defined(CYGWIN32)
#define GC_wnt TRUE
#endif
GC_INNER void GC_register_dynamic_libraries(void)
{
MEMORY_BASIC_INFORMATION buf;
DWORD protect;
LPVOID p;
char*base;
char*limit,*new_limit;
#ifdef MSWIN32
if (GC_no_win32_dlls)return;
#endif
p=GC_sysinfo.lpMinimumApplicationAddress;
base=limit=(char*)p;
while ((word)p < (word)GC_sysinfo.lpMaximumApplicationAddress){
size_t result=VirtualQuery(p,&buf,sizeof(buf));
#ifdef MSWINCE
if (result==0){
new_limit=(char*)
(((DWORD)p+GC_sysinfo.dwAllocationGranularity)
&~(GC_sysinfo.dwAllocationGranularity-1));
} else
#endif
{
if (result!=sizeof(buf)){
ABORT("Weird VirtualQuery result");
}
new_limit=(char*)p+buf.RegionSize;
protect=buf.Protect;
if (buf.State==MEM_COMMIT
&&(protect==PAGE_EXECUTE_READWRITE
||protect==PAGE_EXECUTE_WRITECOPY
||protect==PAGE_READWRITE
||protect==PAGE_WRITECOPY)
&&(buf.Type==MEM_IMAGE
#ifdef GC_REGISTER_MEM_PRIVATE
||(protect==PAGE_READWRITE&&buf.Type==MEM_PRIVATE)
#else
||(!GC_wnt&&buf.Type==MEM_PRIVATE)
#endif
)
&&!GC_is_heap_base(buf.AllocationBase)){
#ifdef DEBUG_VIRTUALQUERY
GC_dump_meminfo(&buf);
#endif
if ((char*)p!=limit){
GC_cond_add_roots(base,limit);
base=(char*)p;
}
limit=new_limit;
}
}
if ((word)p > (word)new_limit)break;
p=(LPVOID)new_limit;
}
GC_cond_add_roots(base,limit);
}
#endif
#if defined(ALPHA)&&defined(OSF1)
#include <loader.h>
EXTERN_C_BEGIN
extern char*sys_errlist[];
extern int sys_nerr;
extern int errno;
EXTERN_C_END
GC_INNER void GC_register_dynamic_libraries(void)
{
ldr_module_t moduleid=LDR_NULL_MODULE;
ldr_process_t mypid=ldr_my_process();
while (TRUE){
ldr_module_info_t moduleinfo;
size_t modulereturnsize;
ldr_region_t region;
ldr_region_info_t regioninfo;
size_t regionreturnsize;
int status=ldr_next_module(mypid,&moduleid);
if (moduleid==LDR_NULL_MODULE)
break;
if (status!=0){
ABORT_ARG3("ldr_next_module failed",
":status=%d,errcode=%d (%s)",status,errno,
errno < sys_nerr?sys_errlist[errno]:"");
}
status=ldr_inq_module(mypid,moduleid,&moduleinfo,
sizeof(moduleinfo),&modulereturnsize);
if (status!=0)
ABORT("ldr_inq_module failed");
if (moduleinfo.lmi_flags&LDR_MAIN)
continue;
#ifdef DL_VERBOSE
GC_log_printf("---Module---\n");
GC_log_printf("Module ID\t=%16ld\n",moduleinfo.lmi_modid);
GC_log_printf("Count of regions=%16d\n",moduleinfo.lmi_nregion);
GC_log_printf("flags for module=%16lx\n",moduleinfo.lmi_flags);
GC_log_printf("module pathname\t=\"%s\"\n",moduleinfo.lmi_name);
#endif
for (region=0;region < moduleinfo.lmi_nregion;region++){
status=ldr_inq_region(mypid,moduleid,region,&regioninfo,
sizeof(regioninfo),&regionreturnsize);
if (status!=0)
ABORT("ldr_inq_region failed");
if (!(regioninfo.lri_prot&LDR_W))
continue;
#ifdef DL_VERBOSE
GC_log_printf("--- Region---\n");
GC_log_printf("Region number\t=%16ld\n",
regioninfo.lri_region_no);
GC_log_printf("Protection flags=%016x\n",regioninfo.lri_prot);
GC_log_printf("Virtual address\t=%16p\n",regioninfo.lri_vaddr);
GC_log_printf("Mapped address\t=%16p\n",
regioninfo.lri_mapaddr);
GC_log_printf("Region size\t=%16ld\n",regioninfo.lri_size);
GC_log_printf("Region name\t=\"%s\"\n",regioninfo.lri_name);
#endif
GC_add_roots_inner((char*)regioninfo.lri_mapaddr,
(char*)regioninfo.lri_mapaddr+regioninfo.lri_size,
TRUE);
}
}
}
#endif
#if defined(HPUX)
#include <errno.h>
#include <dl.h>
EXTERN_C_BEGIN
extern char*sys_errlist[];
extern int sys_nerr;
EXTERN_C_END
GC_INNER void GC_register_dynamic_libraries(void)
{
int index=1;
while (TRUE){
struct shl_descriptor*shl_desc;
int status=shl_get(index,&shl_desc);
if (status!=0){
#ifdef GC_HPUX_THREADS
break;
#else
if (errno==EINVAL){
break;
} else {
ABORT_ARG3("shl_get failed",
":status=%d,errcode=%d (%s)",status,errno,
errno < sys_nerr?sys_errlist[errno]:"");
}
#endif
}
#ifdef DL_VERBOSE
GC_log_printf("---Shared library---\n");
GC_log_printf("\tfilename\t=\"%s\"\n",shl_desc->filename);
GC_log_printf("\tindex\t\t=%d\n",index);
GC_log_printf("\thandle\t\t=%08x\n",
(unsigned long)shl_desc->handle);
GC_log_printf("\ttext seg.start\t=%08x\n",shl_desc->tstart);
GC_log_printf("\ttext seg.end\t=%08x\n",shl_desc->tend);
GC_log_printf("\tdata seg.start\t=%08x\n",shl_desc->dstart);
GC_log_printf("\tdata seg.end\t=%08x\n",shl_desc->dend);
GC_log_printf("\tref.count\t=%lu\n",shl_desc->ref_count);
#endif
GC_add_roots_inner((char*)shl_desc->dstart,
(char*)shl_desc->dend,TRUE);
index++;
}
}
#endif
#ifdef AIX
#include <alloca.h>
#include <sys/ldr.h>
#include <sys/errno.h>
GC_INNER void GC_register_dynamic_libraries(void)
{
int ldibuflen=8192;
for (;;){
int len;
struct ld_info*ldi;
#if defined(CPPCHECK)
char ldibuf[ldibuflen];
#else
char*ldibuf=alloca(ldibuflen);
#endif
len=loadquery(L_GETINFO,ldibuf,ldibuflen);
if (len < 0){
if (errno!=ENOMEM){
ABORT("loadquery failed");
}
ldibuflen*=2;
continue;
}
ldi=(struct ld_info*)ldibuf;
while (ldi){
len=ldi->ldinfo_next;
GC_add_roots_inner(
ldi->ldinfo_dataorg,
(ptr_t)(unsigned long)ldi->ldinfo_dataorg
+ldi->ldinfo_datasize,
TRUE);
ldi=len?(struct ld_info*)((char*)ldi+len):0;
}
break;
}
}
#endif
#ifdef DARWIN
#ifndef __private_extern__
#define __private_extern__ extern
#include <mach-o/dyld.h>
#undef __private_extern__
#else
#include <mach-o/dyld.h>
#endif
#include <mach-o/getsect.h>
STATIC const struct dyld_sections_s {
const char*seg;
const char*sect;
} GC_dyld_sections[]={
{ SEG_DATA,SECT_DATA },
{ SEG_DATA,"__static_data" },
{ SEG_DATA,SECT_BSS },
{ SEG_DATA,SECT_COMMON },
{ SEG_DATA,"__zobj_data" },
{ SEG_DATA,"__zobj_bss" }
};
STATIC const char*const GC_dyld_add_sect_fmts[]={
"__bss%u",
"__pu_bss%u",
"__zo_bss%u",
"__zo_pu_bss%u"
};
#ifndef L2_MAX_OFILE_ALIGNMENT
#define L2_MAX_OFILE_ALIGNMENT 15
#endif
STATIC const char*GC_dyld_name_for_hdr(const struct GC_MACH_HEADER*hdr)
{
unsigned long i,c;
c=_dyld_image_count();
for (i=0;i < c;i++)
if ((const struct GC_MACH_HEADER*)_dyld_get_image_header(i)==hdr)
return _dyld_get_image_name(i);
return NULL;
}
STATIC void GC_dyld_image_add(const struct GC_MACH_HEADER*hdr,
intptr_t slide)
{
unsigned long start,end;
unsigned i,j;
const struct GC_MACH_SECTION*sec;
const char*name;
GC_has_static_roots_func callback=GC_has_static_roots;
DCL_LOCK_STATE;
if (GC_no_dls)return;
#ifdef DARWIN_DEBUG
name=GC_dyld_name_for_hdr(hdr);
#else
name=callback!=0?GC_dyld_name_for_hdr(hdr):NULL;
#endif
for (i=0;i < sizeof(GC_dyld_sections)/sizeof(GC_dyld_sections[0]);i++){
sec=GC_GETSECTBYNAME(hdr,GC_dyld_sections[i].seg,
GC_dyld_sections[i].sect);
if (sec==NULL||sec->size < sizeof(word))
continue;
start=slide+sec->addr;
end=start+sec->size;
LOCK();
if (callback==0||callback(name,(void*)start,(size_t)sec->size)){
#ifdef DARWIN_DEBUG
GC_log_printf(
"Adding section __DATA,%s at %p-%p (%lu bytes)from image %s\n",
GC_dyld_sections[i].sect,(void*)start,(void*)end,
(unsigned long)sec->size,name);
#endif
GC_add_roots_inner((ptr_t)start,(ptr_t)end,FALSE);
}
UNLOCK();
}
for (j=0;j < sizeof(GC_dyld_add_sect_fmts)/sizeof(char*);j++){
const char*fmt=GC_dyld_add_sect_fmts[j];
for (i=0;i<=L2_MAX_OFILE_ALIGNMENT;i++){
char secnam[16];
(void)snprintf(secnam,sizeof(secnam),fmt,(unsigned)i);
secnam[sizeof(secnam)- 1]='\0';
sec=GC_GETSECTBYNAME(hdr,SEG_DATA,secnam);
if (sec==NULL||sec->size==0)
continue;
start=slide+sec->addr;
end=start+sec->size;
#ifdef DARWIN_DEBUG
GC_log_printf("Adding on-demand section __DATA,%s at"
" %p-%p (%lu bytes)from image %s\n",
secnam,(void*)start,(void*)end,
(unsigned long)sec->size,name);
#endif
GC_add_roots((char*)start,(char*)end);
}
}
#if defined(DARWIN_DEBUG)&&!defined(NO_DEBUGGING)
LOCK();
GC_print_static_roots();
UNLOCK();
#endif
}
STATIC void GC_dyld_image_remove(const struct GC_MACH_HEADER*hdr,
intptr_t slide)
{
unsigned long start,end;
unsigned i,j;
const struct GC_MACH_SECTION*sec;
#if defined(DARWIN_DEBUG)&&!defined(NO_DEBUGGING)
DCL_LOCK_STATE;
#endif
for (i=0;i < sizeof(GC_dyld_sections)/sizeof(GC_dyld_sections[0]);i++){
sec=GC_GETSECTBYNAME(hdr,GC_dyld_sections[i].seg,
GC_dyld_sections[i].sect);
if (sec==NULL||sec->size==0)
continue;
start=slide+sec->addr;
end=start+sec->size;
#ifdef DARWIN_DEBUG
GC_log_printf(
"Removing section __DATA,%s at %p-%p (%lu bytes)from image %s\n",
GC_dyld_sections[i].sect,(void*)start,(void*)end,
(unsigned long)sec->size,GC_dyld_name_for_hdr(hdr));
#endif
GC_remove_roots((char*)start,(char*)end);
}
for (j=0;j < sizeof(GC_dyld_add_sect_fmts)/sizeof(char*);j++){
const char*fmt=GC_dyld_add_sect_fmts[j];
for (i=0;i<=L2_MAX_OFILE_ALIGNMENT;i++){
char secnam[16];
(void)snprintf(secnam,sizeof(secnam),fmt,(unsigned)i);
secnam[sizeof(secnam)- 1]='\0';
sec=GC_GETSECTBYNAME(hdr,SEG_DATA,secnam);
if (sec==NULL||sec->size==0)
continue;
start=slide+sec->addr;
end=start+sec->size;
#ifdef DARWIN_DEBUG
GC_log_printf("Removing on-demand section __DATA,%s at"
" %p-%p (%lu bytes)from image %s\n",secnam,
(void*)start,(void*)end,(unsigned long)sec->size,
GC_dyld_name_for_hdr(hdr));
#endif
GC_remove_roots((char*)start,(char*)end);
}
}
#if defined(DARWIN_DEBUG)&&!defined(NO_DEBUGGING)
LOCK();
GC_print_static_roots();
UNLOCK();
#endif
}
GC_INNER void GC_register_dynamic_libraries(void)
{
}
GC_INNER void GC_init_dyld(void)
{
static GC_bool initialized=FALSE;
if (initialized)return;
#ifdef DARWIN_DEBUG
GC_log_printf("Registering dyld callbacks...\n");
#endif
_dyld_register_func_for_add_image(
(void (*)(const struct mach_header*,intptr_t))GC_dyld_image_add);
_dyld_register_func_for_remove_image(
(void (*)(const struct mach_header*,intptr_t))GC_dyld_image_remove);
initialized=TRUE;
#ifdef NO_DYLD_BIND_FULLY_IMAGE
#else
if (GC_no_dls)return;
if (GETENV("DYLD_BIND_AT_LAUNCH")==0){
#ifdef DARWIN_DEBUG
GC_log_printf("Forcing full bind of GC code...\n");
#endif
if (!_dyld_bind_fully_image_containing_address(
(unsigned long*)GC_malloc))
ABORT("_dyld_bind_fully_image_containing_address failed");
}
#endif
}
#define HAVE_REGISTER_MAIN_STATIC_DATA
GC_INNER GC_bool GC_register_main_static_data(void)
{
return FALSE;
}
#endif
#if defined(HAIKU)
#include <kernel/image.h>
GC_INNER void GC_register_dynamic_libraries(void)
{
image_info info;
int32 cookie=0;
while (get_next_image_info(0,&cookie,&info)==B_OK){
ptr_t data=(ptr_t)info.data;
GC_add_roots_inner(data,data+info.data_size,TRUE);
}
}
#endif
#elif defined(PCR)
GC_INNER void GC_register_dynamic_libraries(void)
{
PCR_IL_LoadedFile*p=PCR_IL_GetLastLoadedFile();
PCR_IL_LoadedSegment*q;
while (p!=NIL&&!(p->lf_commitPoint)){
p=p->lf_prev;
}
for (;p!=NIL;p=p->lf_prev){
for (q=p->lf_ls;q!=NIL;q=q->ls_next){
if ((q->ls_flags&PCR_IL_SegFlags_Traced_MASK)
==PCR_IL_SegFlags_Traced_on){
GC_add_roots_inner((ptr_t)q->ls_addr,
(ptr_t)q->ls_addr+q->ls_bytes,TRUE);
}
}
}
}
#endif
#if!defined(HAVE_REGISTER_MAIN_STATIC_DATA)&&defined(DYNAMIC_LOADING)
GC_INNER GC_bool GC_register_main_static_data(void)
{
return TRUE;
}
#endif
GC_API void GC_CALL GC_register_has_static_roots_callback(
GC_has_static_roots_func callback)
{
GC_has_static_roots=callback;
}
#if defined(GC_PTHREADS)&&!defined(GC_NO_DLOPEN)
#undef GC_MUST_RESTORE_REDEFINED_DLOPEN
#if defined(dlopen)&&!defined(GC_USE_LD_WRAP)
#undef dlopen
#define GC_MUST_RESTORE_REDEFINED_DLOPEN
#endif
#ifndef USE_PROC_FOR_LIBRARIES
static void disable_gc_for_dlopen(void)
{
DCL_LOCK_STATE;
LOCK();
while (GC_incremental&&GC_collection_in_progress()){
ENTER_GC();
GC_collect_a_little_inner(1000);
EXIT_GC();
}
++GC_dont_gc;
UNLOCK();
}
#endif
#ifdef GC_USE_LD_WRAP
#define WRAP_DLFUNC(f)__wrap_##f
#define REAL_DLFUNC(f)__real_##f
void*REAL_DLFUNC(dlopen)(const char*,int);
#else
#define WRAP_DLFUNC(f)GC_##f
#define REAL_DLFUNC(f)f
#endif
GC_API void*WRAP_DLFUNC(dlopen)(const char*path,int mode)
{
void*result;
#ifndef USE_PROC_FOR_LIBRARIES
disable_gc_for_dlopen();
#endif
result=REAL_DLFUNC(dlopen)(path,mode);
#ifndef USE_PROC_FOR_LIBRARIES
GC_enable();
#endif
return(result);
}
#ifdef GC_USE_LD_WRAP
GC_API void*GC_dlopen(const char*path,int mode)
{
return dlopen(path,mode);
}
#endif
#ifdef GC_MUST_RESTORE_REDEFINED_DLOPEN
#define dlopen GC_dlopen
#endif
#endif
#if!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)
#include <stdio.h>
#ifdef AMIGA
#ifndef __GNUC__
#include <dos.h>
#else
#include <machine/reg.h>
#endif
#endif
#if defined(MACOS)&&defined(__MWERKS__)
#if defined(POWERPC)
#define NONVOLATILE_GPR_COUNT 19
struct ppc_registers {
unsigned long gprs[NONVOLATILE_GPR_COUNT];
};
typedef struct ppc_registers ppc_registers;
#if defined(CPPCHECK)
void getRegisters(ppc_registers*regs);
#else
asm static void getRegisters(register ppc_registers*regs)
{
stmw r13,regs->gprs
blr
}
#endif
static void PushMacRegisters(void)
{
ppc_registers regs;
int i;
getRegisters(&regs);
for (i=0;i < NONVOLATILE_GPR_COUNT;i++)
GC_push_one(regs.gprs[i]);
}
#else
asm static void PushMacRegisters(void)
{
sub.w #4,sp
move.l a2,(sp)
jsr GC_push_one
move.l a3,(sp)
jsr GC_push_one
move.l a4,(sp)
jsr GC_push_one
#if!__option(a6frames)
move.l a6,(sp)
jsr GC_push_one
#endif
move.l d2,(sp)
jsr GC_push_one
move.l d3,(sp)
jsr GC_push_one
move.l d4,(sp)
jsr GC_push_one
move.l d5,(sp)
jsr GC_push_one
move.l d6,(sp)
jsr GC_push_one
move.l d7,(sp)
jsr GC_push_one
add.w #4,sp
rts
}
#endif
#endif
#if defined(SPARC)||defined(IA64)
GC_INNER ptr_t GC_save_regs_ret_val=NULL;
#endif
#undef HAVE_PUSH_REGS
#if defined(USE_ASM_PUSH_REGS)
#define HAVE_PUSH_REGS
#else
#ifdef STACK_NOT_SCANNED
void GC_push_regs(void)
{
}
#define HAVE_PUSH_REGS
#elif defined(M68K)&&defined(AMIGA)
void GC_push_regs(void)
{
#ifdef __GNUC__
asm("subq.w&0x4,%sp");
asm("mov.l %a2,(%sp)");asm("jsr _GC_push_one");
asm("mov.l %a3,(%sp)");asm("jsr _GC_push_one");
asm("mov.l %a4,(%sp)");asm("jsr _GC_push_one");
asm("mov.l %a5,(%sp)");asm("jsr _GC_push_one");
asm("mov.l %a6,(%sp)");asm("jsr _GC_push_one");
asm("mov.l %d2,(%sp)");asm("jsr _GC_push_one");
asm("mov.l %d3,(%sp)");asm("jsr _GC_push_one");
asm("mov.l %d4,(%sp)");asm("jsr _GC_push_one");
asm("mov.l %d5,(%sp)");asm("jsr _GC_push_one");
asm("mov.l %d6,(%sp)");asm("jsr _GC_push_one");
asm("mov.l %d7,(%sp)");asm("jsr _GC_push_one");
asm("addq.w&0x4,%sp");
#else
GC_push_one(getreg(REG_A2));
GC_push_one(getreg(REG_A3));
#ifndef __SASC
GC_push_one(getreg(REG_A4));
#endif
GC_push_one(getreg(REG_A5));
GC_push_one(getreg(REG_A6));
GC_push_one(getreg(REG_D2));
GC_push_one(getreg(REG_D3));
GC_push_one(getreg(REG_D4));
GC_push_one(getreg(REG_D5));
GC_push_one(getreg(REG_D6));
GC_push_one(getreg(REG_D7));
#endif
}
#define HAVE_PUSH_REGS
#elif defined(MACOS)
#if defined(M68K)&&defined(THINK_C)&&!defined(CPPCHECK)
#define PushMacReg(reg)move.l reg,(sp)jsr GC_push_one
void GC_push_regs(void)
{
asm {
sub.w #4,sp;reserve space for one parameter.
PushMacReg(a2);
PushMacReg(a3);
PushMacReg(a4);
;skip a5 (globals),a6 (frame pointer),and a7 (stack pointer)
PushMacReg(d2);
PushMacReg(d3);
PushMacReg(d4);
PushMacReg(d5);
PushMacReg(d6);
PushMacReg(d7);
add.w #4,sp;fix stack.
}
}
#define HAVE_PUSH_REGS
#undef PushMacReg
#elif defined(__MWERKS__)
void GC_push_regs(void)
{
PushMacRegisters();
}
#define HAVE_PUSH_REGS
#endif
#endif
#endif
#if defined(HAVE_PUSH_REGS)&&defined(THREADS)
#error GC_push_regs cannot be used with threads
#undef HAVE_PUSH_REGS
#endif
#if!defined(HAVE_PUSH_REGS)&&defined(UNIX_LIKE)
#include <signal.h>
#ifndef NO_GETCONTEXT
#if defined(DARWIN)&&(MAC_OS_X_VERSION_MAX_ALLOWED>=1060)
#include <sys/ucontext.h>
#else
#include <ucontext.h>
#endif
#ifdef GETCONTEXT_FPU_EXCMASK_BUG
#include <fenv.h>
#endif
#endif
#endif
GC_ATTR_NO_SANITIZE_ADDR
GC_INNER void GC_with_callee_saves_pushed(void (*fn)(ptr_t,void*),
volatile ptr_t arg)
{
volatile int dummy;
volatile ptr_t context=0;
#if defined(HAVE_PUSH_REGS)
GC_push_regs();
#elif defined(__EMSCRIPTEN__)
#else
#if defined(UNIX_LIKE)&&!defined(NO_GETCONTEXT)
static signed char getcontext_works=0;
ucontext_t ctxt;
#ifdef GETCONTEXT_FPU_EXCMASK_BUG
#ifdef X86_64
unsigned short old_fcw;
#if defined(CPPCHECK)
GC_noop1((word)&old_fcw);
#endif
__asm__ __volatile__ ("fstcw %0":"=m" (*&old_fcw));
#else
int except_mask=fegetexcept();
#endif
#endif
if (getcontext_works>=0){
if (getcontext(&ctxt)< 0){
WARN("getcontext failed:"
" using another register retrieval method...\n",0);
} else {
context=(ptr_t)&ctxt;
}
if (EXPECT(0==getcontext_works,FALSE))
getcontext_works=context!=NULL?1:-1;
}
#ifdef GETCONTEXT_FPU_EXCMASK_BUG
#ifdef X86_64
__asm__ __volatile__ ("fldcw %0"::"m" (*&old_fcw));
{
unsigned mxcsr;
__asm__ __volatile__ ("stmxcsr %0":"=m" (*&mxcsr));
mxcsr=(mxcsr&~(FE_ALL_EXCEPT<<7))|
((old_fcw&FE_ALL_EXCEPT)<<7);
__asm__ __volatile__ ("ldmxcsr %0"::"m" (*&mxcsr));
}
#else
if (feenableexcept(except_mask)< 0)
ABORT("feenableexcept failed");
#endif
#endif
#if defined(SPARC)||defined(IA64)
GC_save_regs_ret_val=GC_save_regs_in_stack();
#endif
if (NULL==context)
#endif
{
#if defined(HAVE_BUILTIN_UNWIND_INIT)
__builtin_unwind_init();
#elif defined(NO_CRT)&&defined(MSWIN32)
CONTEXT ctx;
RtlCaptureContext(&ctx);
#else
jmp_buf regs;
word*i=(word*)&regs;
ptr_t lim=(ptr_t)(&regs)+sizeof(regs);
for (;(word)i < (word)lim;i++){
*i=0;
}
#if defined(MSWIN32)||defined(MSWINCE)||defined(UTS4)||defined(OS2)||defined(CX_UX)||defined(__CC_ARM)||defined(LINUX)||defined(EWS4800)||defined(RTEMS)
(void)setjmp(regs);
#else
(void)_setjmp(regs);
#endif
#endif
}
#endif
fn(arg,( void*)context);
GC_noop1(COVERT_DATAFLOW(&dummy));
}
#endif
#if defined(GC_PTHREADS)&&!defined(GC_WIN32_THREADS)&&!defined(GC_DARWIN_THREADS)&&!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)
#ifdef NACL
#include <unistd.h>
#include <sys/time.h>
STATIC int GC_nacl_num_gc_threads=0;
STATIC __thread int GC_nacl_thread_idx=-1;
STATIC volatile int GC_nacl_park_threads_now=0;
STATIC volatile pthread_t GC_nacl_thread_parker=-1;
GC_INNER __thread GC_thread GC_nacl_gc_thread_self=NULL;
volatile int GC_nacl_thread_parked[MAX_NACL_GC_THREADS];
int GC_nacl_thread_used[MAX_NACL_GC_THREADS];
#elif defined(GC_OPENBSD_UTHREADS)
#include <pthread_np.h>
#else
#include <signal.h>
#include <semaphore.h>
#include <errno.h>
#include <time.h>
#include <unistd.h>
#if (!defined(AO_HAVE_load_acquire)||!defined(AO_HAVE_store_release))&&!defined(CPPCHECK)
#error AO_load_acquire and/or AO_store_release are missing;
#error please define AO_REQUIRE_CAS manually
#endif
#undef pthread_sigmask
#ifdef GC_ENABLE_SUSPEND_THREAD
static void*GC_CALLBACK suspend_self_inner(void*client_data);
#endif
#ifdef DEBUG_THREADS
#ifndef NSIG
#if defined(MAXSIG)
#define NSIG (MAXSIG+1)
#elif defined(_NSIG)
#define NSIG _NSIG
#elif defined(__SIGRTMAX)
#define NSIG (__SIGRTMAX+1)
#else
#error define NSIG
#endif
#endif
void GC_print_sig_mask(void)
{
sigset_t blocked;
int i;
if (pthread_sigmask(SIG_BLOCK,NULL,&blocked)!=0)
ABORT("pthread_sigmask failed");
for (i=1;i < NSIG;i++){
if (sigismember(&blocked,i))
GC_printf("Signal blocked:%d\n",i);
}
}
#endif
STATIC void GC_remove_allowed_signals(sigset_t*set)
{
if (sigdelset(set,SIGINT)!=0
||sigdelset(set,SIGQUIT)!=0
||sigdelset(set,SIGABRT)!=0
||sigdelset(set,SIGTERM)!=0){
ABORT("sigdelset failed");
}
#ifdef MPROTECT_VDB
if (sigdelset(set,SIGSEGV)!=0
#ifdef HAVE_SIGBUS
||sigdelset(set,SIGBUS)!=0
#endif
){
ABORT("sigdelset failed");
}
#endif
}
static sigset_t suspend_handler_mask;
#define THREAD_RESTARTED 0x1
STATIC volatile AO_t GC_stop_count=0;
STATIC volatile AO_t GC_world_is_stopped=FALSE;
#if defined(GC_OSF1_THREADS)||defined(THREAD_SANITIZER)||defined(ADDRESS_SANITIZER)||defined(MEMORY_SANITIZER)
STATIC GC_bool GC_retry_signals=TRUE;
#else
STATIC GC_bool GC_retry_signals=FALSE;
#endif
#ifndef SIG_THR_RESTART
#if defined(GC_HPUX_THREADS)||defined(GC_OSF1_THREADS)||defined(GC_NETBSD_THREADS)||defined(GC_USESIGRT_SIGNALS)
#if defined(_SIGRTMIN)&&!defined(CPPCHECK)
#define SIG_THR_RESTART _SIGRTMIN+5
#else
#define SIG_THR_RESTART SIGRTMIN+5
#endif
#else
#define SIG_THR_RESTART SIGXCPU
#endif
#endif
#define SIGNAL_UNSET (-1)
STATIC int GC_sig_suspend=SIGNAL_UNSET;
STATIC int GC_sig_thr_restart=SIGNAL_UNSET;
GC_API void GC_CALL GC_set_suspend_signal(int sig)
{
if (GC_is_initialized)return;
GC_sig_suspend=sig;
}
GC_API void GC_CALL GC_set_thr_restart_signal(int sig)
{
if (GC_is_initialized)return;
GC_sig_thr_restart=sig;
}
GC_API int GC_CALL GC_get_suspend_signal(void)
{
return GC_sig_suspend!=SIGNAL_UNSET?GC_sig_suspend:SIG_SUSPEND;
}
GC_API int GC_CALL GC_get_thr_restart_signal(void)
{
return GC_sig_thr_restart!=SIGNAL_UNSET
?GC_sig_thr_restart:SIG_THR_RESTART;
}
#if defined(GC_EXPLICIT_SIGNALS_UNBLOCK)||!defined(NO_SIGNALS_UNBLOCK_IN_MAIN)
GC_INNER void GC_unblock_gc_signals(void)
{
sigset_t set;
sigemptyset(&set);
GC_ASSERT(GC_sig_suspend!=SIGNAL_UNSET);
GC_ASSERT(GC_sig_thr_restart!=SIGNAL_UNSET);
sigaddset(&set,GC_sig_suspend);
sigaddset(&set,GC_sig_thr_restart);
if (pthread_sigmask(SIG_UNBLOCK,&set,NULL)!=0)
ABORT("pthread_sigmask failed");
}
#endif
STATIC sem_t GC_suspend_ack_sem;
STATIC void GC_suspend_handler_inner(ptr_t dummy,void*context);
#ifndef NO_SA_SIGACTION
STATIC void GC_suspend_handler(int sig,siginfo_t*info GC_ATTR_UNUSED,
void*context GC_ATTR_UNUSED)
#else
STATIC void GC_suspend_handler(int sig)
#endif
{
int old_errno=errno;
if (sig!=GC_sig_suspend){
#if defined(GC_FREEBSD_THREADS)
if (0==sig)return;
#endif
ABORT("Bad signal in suspend_handler");
}
#if defined(IA64)||defined(HP_PA)||defined(M68K)
GC_with_callee_saves_pushed(GC_suspend_handler_inner,NULL);
#else
{
#ifdef NO_SA_SIGACTION
void*context=0;
#endif
GC_suspend_handler_inner(NULL,context);
}
#endif
errno=old_errno;
}
#ifdef BASE_ATOMIC_OPS_EMULATED
#define ao_load_acquire_async(p)(*(p))
#define ao_load_async(p)ao_load_acquire_async(p)
#define ao_store_release_async(p,v)(void)(*(p)=(v))
#define ao_store_async(p,v)ao_store_release_async(p,v)
#else
#define ao_load_acquire_async(p)AO_load_acquire(p)
#define ao_load_async(p)AO_load(p)
#define ao_store_release_async(p,v)AO_store_release(p,v)
#define ao_store_async(p,v)AO_store(p,v)
#endif
#ifdef THREAD_SANITIZER
GC_ATTR_NO_SANITIZE_THREAD
static GC_thread GC_lookup_thread_async(pthread_t id)
{
GC_thread p=GC_threads[THREAD_TABLE_INDEX(id)];
while (p!=NULL&&!THREAD_EQUAL(p->id,id))
p=p->next;
return p;
}
#else
#define GC_lookup_thread_async GC_lookup_thread
#endif
GC_INLINE void GC_store_stack_ptr(GC_thread me)
{
#ifdef SPARC
ao_store_async((volatile AO_t*)&me->stop_info.stack_ptr,
(AO_t)GC_save_regs_in_stack());
#else
#ifdef IA64
me->backing_store_ptr=GC_save_regs_in_stack();
#endif
ao_store_async((volatile AO_t*)&me->stop_info.stack_ptr,
(AO_t)GC_approx_sp());
#endif
}
STATIC void GC_suspend_handler_inner(ptr_t dummy GC_ATTR_UNUSED,
void*context GC_ATTR_UNUSED)
{
pthread_t self=pthread_self();
GC_thread me;
IF_CANCEL(int cancel_state;)
AO_t my_stop_count=ao_load_acquire_async(&GC_stop_count);
DISABLE_CANCEL(cancel_state);
#ifdef DEBUG_THREADS
GC_log_printf("Suspending %p\n",(void*)self);
#endif
GC_ASSERT(((word)my_stop_count&THREAD_RESTARTED)==0);
me=GC_lookup_thread_async(self);
#ifdef GC_ENABLE_SUSPEND_THREAD
if (ao_load_async(&me->suspended_ext)){
GC_store_stack_ptr(me);
sem_post(&GC_suspend_ack_sem);
suspend_self_inner(me);
#ifdef DEBUG_THREADS
GC_log_printf("Continuing %p on GC_resume_thread\n",(void*)self);
#endif
RESTORE_CANCEL(cancel_state);
return;
}
#endif
if (((word)me->stop_info.last_stop_count&~(word)THREAD_RESTARTED)
==(word)my_stop_count){
if (!GC_retry_signals){
WARN("Duplicate suspend signal in thread %p\n",self);
}
RESTORE_CANCEL(cancel_state);
return;
}
GC_store_stack_ptr(me);
#ifdef THREAD_SANITIZER
{
sigset_t set;
sigemptyset(&set);
GC_ASSERT(GC_sig_suspend!=SIGNAL_UNSET);
GC_ASSERT(GC_sig_thr_restart!=SIGNAL_UNSET);
sigaddset(&set,GC_sig_suspend);
sigaddset(&set,GC_sig_thr_restart);
if (pthread_sigmask(SIG_UNBLOCK,&set,NULL)!=0)
ABORT("pthread_sigmask failed in suspend handler");
}
#endif
sem_post(&GC_suspend_ack_sem);
ao_store_release_async(&me->stop_info.last_stop_count,my_stop_count);
do {
sigsuspend (&suspend_handler_mask);
} while (ao_load_acquire_async(&GC_world_is_stopped)
&&ao_load_async(&GC_stop_count)==my_stop_count);
#ifdef DEBUG_THREADS
GC_log_printf("Continuing %p\n",(void*)self);
#endif
#ifndef GC_NETBSD_THREADS_WORKAROUND
if (GC_retry_signals)
#endif
{
sem_post(&GC_suspend_ack_sem);
#ifdef GC_NETBSD_THREADS_WORKAROUND
if (GC_retry_signals)
#endif
{
ao_store_release_async(&me->stop_info.last_stop_count,
(AO_t)((word)my_stop_count|THREAD_RESTARTED));
}
}
RESTORE_CANCEL(cancel_state);
}
static void suspend_restart_barrier(int n_live_threads)
{
int i;
for (i=0;i < n_live_threads;i++){
while (0!=sem_wait(&GC_suspend_ack_sem)){
if (errno!=EINTR)
ABORT("sem_wait failed");
}
}
#ifdef GC_ASSERTIONS
sem_getvalue(&GC_suspend_ack_sem,&i);
GC_ASSERT(0==i);
#endif
}
static int resend_lost_signals(int n_live_threads,
int (*suspend_restart_all)(void))
{
#define WAIT_UNIT 3000
#define RETRY_INTERVAL 100000
if (n_live_threads > 0){
unsigned long wait_usecs=0;
for (;;){
int ack_count;
sem_getvalue(&GC_suspend_ack_sem,&ack_count);
if (ack_count==n_live_threads)
break;
if (wait_usecs > RETRY_INTERVAL){
int newly_sent=suspend_restart_all();
GC_COND_LOG_PRINTF("Resent %d signals after timeout\n",newly_sent);
sem_getvalue(&GC_suspend_ack_sem,&ack_count);
if (newly_sent < n_live_threads - ack_count){
WARN("Lost some threads while stopping or starting world?!\n",0);
n_live_threads=ack_count+newly_sent;
}
wait_usecs=0;
}
#ifdef LINT2
#undef WAIT_UNIT
#define WAIT_UNIT 1
sched_yield();
#elif defined(CPPCHECK)
{
struct timespec ts;
ts.tv_sec=0;
ts.tv_nsec=WAIT_UNIT*1000;
(void)nanosleep(&ts,NULL);
}
#else
usleep(WAIT_UNIT);
#endif
wait_usecs+=WAIT_UNIT;
}
}
return n_live_threads;
}
STATIC void GC_restart_handler(int sig)
{
#if defined(DEBUG_THREADS)
int old_errno=errno;
#endif
if (sig!=GC_sig_thr_restart)
ABORT("Bad signal in restart handler");
#ifdef DEBUG_THREADS
GC_log_printf("In GC_restart_handler for %p\n",(void*)pthread_self());
errno=old_errno;
#endif
}
#ifdef USE_TKILL_ON_ANDROID
EXTERN_C_BEGIN
extern int tkill(pid_t tid,int sig);
EXTERN_C_END
static int android_thread_kill(pid_t tid,int sig)
{
int ret;
int old_errno=errno;
ret=tkill(tid,sig);
if (ret < 0){
ret=errno;
errno=old_errno;
}
return ret;
}
#define THREAD_SYSTEM_ID(t)(t)->kernel_id
#define RAISE_SIGNAL(t,sig)android_thread_kill(THREAD_SYSTEM_ID(t),sig)
#else
#define THREAD_SYSTEM_ID(t)(t)->id
#define RAISE_SIGNAL(t,sig)pthread_kill(THREAD_SYSTEM_ID(t),sig)
#endif
#ifdef GC_ENABLE_SUSPEND_THREAD
#include <sys/time.h>
STATIC void GC_brief_async_signal_safe_sleep(void)
{
struct timeval tv;
tv.tv_sec=0;
#if defined(GC_TIME_LIMIT)&&!defined(CPPCHECK)
tv.tv_usec=1000*GC_TIME_LIMIT/2;
#else
tv.tv_usec=1000*50/2;
#endif
(void)select(0,0,0,0,&tv);
}
static void*GC_CALLBACK suspend_self_inner(void*client_data){
GC_thread me=(GC_thread)client_data;
while (ao_load_acquire_async(&me->suspended_ext)){
GC_brief_async_signal_safe_sleep();
}
return NULL;
}
GC_API void GC_CALL GC_suspend_thread(GC_SUSPEND_THREAD_ID thread){
GC_thread t;
IF_CANCEL(int cancel_state;)
DCL_LOCK_STATE;
LOCK();
t=GC_lookup_thread((pthread_t)thread);
if (t==NULL||t->suspended_ext){
UNLOCK();
return;
}
AO_store_release(&t->suspended_ext,TRUE);
if (THREAD_EQUAL((pthread_t)thread,pthread_self())){
UNLOCK();
(void)GC_do_blocking(suspend_self_inner,t);
return;
}
if ((t->flags&FINISHED)!=0){
UNLOCK();
return;
}
DISABLE_CANCEL(cancel_state);
#ifdef PARALLEL_MARK
if (GC_parallel)
GC_wait_for_reclaim();
#endif
if (GC_manual_vdb){
GC_acquire_dirty_lock();
}
switch (RAISE_SIGNAL(t,GC_sig_suspend)){
case 0:
break;
default:
ABORT("pthread_kill failed");
}
GC_ASSERT(GC_thr_initialized);
while (sem_wait(&GC_suspend_ack_sem)!=0){
if (errno!=EINTR)
ABORT("sem_wait for handler failed (suspend_self)");
}
if (GC_manual_vdb)
GC_release_dirty_lock();
RESTORE_CANCEL(cancel_state);
UNLOCK();
}
GC_API void GC_CALL GC_resume_thread(GC_SUSPEND_THREAD_ID thread){
GC_thread t;
DCL_LOCK_STATE;
LOCK();
t=GC_lookup_thread((pthread_t)thread);
if (t!=NULL)
AO_store(&t->suspended_ext,FALSE);
UNLOCK();
}
GC_API int GC_CALL GC_is_thread_suspended(GC_SUSPEND_THREAD_ID thread){
GC_thread t;
int is_suspended=0;
DCL_LOCK_STATE;
LOCK();
t=GC_lookup_thread((pthread_t)thread);
if (t!=NULL&&t->suspended_ext)
is_suspended=(int)TRUE;
UNLOCK();
return is_suspended;
}
#endif
#undef ao_load_acquire_async
#undef ao_load_async
#undef ao_store_async
#undef ao_store_release_async
#endif
#ifdef IA64
#define IF_IA64(x)x
#else
#define IF_IA64(x)
#endif
GC_INNER void GC_push_all_stacks(void)
{
GC_bool found_me=FALSE;
size_t nthreads=0;
int i;
GC_thread p;
ptr_t lo,hi;
IF_IA64(ptr_t bs_lo;ptr_t bs_hi;)
struct GC_traced_stack_sect_s*traced_stack_sect;
pthread_t self=pthread_self();
word total_size=0;
if (!EXPECT(GC_thr_initialized,TRUE))
GC_thr_init();
#ifdef DEBUG_THREADS
GC_log_printf("Pushing stacks from thread %p\n",(void*)self);
#endif
for (i=0;i < THREAD_TABLE_SZ;i++){
for (p=GC_threads[i];p!=0;p=p->next){
if (p->flags&FINISHED)continue;
++nthreads;
traced_stack_sect=p->traced_stack_sect;
if (THREAD_EQUAL(p->id,self)){
GC_ASSERT(!p->thread_blocked);
#ifdef SPARC
lo=(ptr_t)GC_save_regs_in_stack();
#else
lo=GC_approx_sp();
#endif
found_me=TRUE;
IF_IA64(bs_hi=(ptr_t)GC_save_regs_in_stack();)
} else {
lo=(ptr_t)AO_load((volatile AO_t*)&p->stop_info.stack_ptr);
IF_IA64(bs_hi=p->backing_store_ptr;)
if (traced_stack_sect!=NULL
&&traced_stack_sect->saved_stack_ptr==lo){
traced_stack_sect=traced_stack_sect->prev;
}
}
if ((p->flags&MAIN_THREAD)==0){
hi=p->stack_end;
IF_IA64(bs_lo=p->backing_store_end);
} else {
hi=GC_stackbottom;
IF_IA64(bs_lo=BACKING_STORE_BASE;)
}
#ifdef DEBUG_THREADS
GC_log_printf("Stack for thread %p=[%p,%p)\n",
(void*)p->id,(void*)lo,(void*)hi);
#endif
if (0==lo)ABORT("GC_push_all_stacks:sp not set!");
if (p->altstack!=NULL&&(word)p->altstack<=(word)lo
&&(word)lo<=(word)p->altstack+p->altstack_size){
hi=p->altstack+p->altstack_size;
}
GC_push_all_stack_sections(lo,hi,traced_stack_sect);
#ifdef STACK_GROWS_UP
total_size+=lo - hi;
#else
total_size+=hi - lo;
#endif
#ifdef NACL
GC_push_all_stack((ptr_t)p->stop_info.reg_storage,
(ptr_t)(p->stop_info.reg_storage+NACL_GC_REG_STORAGE_SIZE));
total_size+=NACL_GC_REG_STORAGE_SIZE*sizeof(ptr_t);
#endif
#ifdef IA64
#ifdef DEBUG_THREADS
GC_log_printf("Reg stack for thread %p=[%p,%p)\n",
(void*)p->id,(void*)bs_lo,(void*)bs_hi);
#endif
GC_push_all_register_sections(bs_lo,bs_hi,
THREAD_EQUAL(p->id,self),
traced_stack_sect);
total_size+=bs_hi - bs_lo;
#endif
}
}
GC_VERBOSE_LOG_PRINTF("Pushed %d thread stacks\n",(int)nthreads);
if (!found_me&&!GC_in_thread_creation)
ABORT("Collecting from unknown thread");
GC_total_stacksize=total_size;
}
#ifdef DEBUG_THREADS
pthread_t GC_stopping_thread;
int GC_stopping_pid=0;
#endif
STATIC int GC_suspend_all(void)
{
int n_live_threads=0;
int i;
#ifndef NACL
GC_thread p;
#ifndef GC_OPENBSD_UTHREADS
int result;
#endif
pthread_t self=pthread_self();
for (i=0;i < THREAD_TABLE_SZ;i++){
for (p=GC_threads[i];p!=0;p=p->next){
if (!THREAD_EQUAL(p->id,self)){
if ((p->flags&FINISHED)!=0)continue;
if (p->thread_blocked)continue;
#ifndef GC_OPENBSD_UTHREADS
#ifdef GC_ENABLE_SUSPEND_THREAD
if (p->suspended_ext)continue;
#endif
if (AO_load(&p->stop_info.last_stop_count)==GC_stop_count)
continue;
n_live_threads++;
#endif
#ifdef DEBUG_THREADS
GC_log_printf("Sending suspend signal to %p\n",(void*)p->id);
#endif
#ifdef GC_OPENBSD_UTHREADS
{
stack_t stack;
GC_acquire_dirty_lock();
if (pthread_suspend_np(p->id)!=0)
ABORT("pthread_suspend_np failed");
GC_release_dirty_lock();
if (pthread_stackseg_np(p->id,&stack))
ABORT("pthread_stackseg_np failed");
p->stop_info.stack_ptr=(ptr_t)stack.ss_sp - stack.ss_size;
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_SUSPENDED,
(void*)p->id);
}
#else
result=RAISE_SIGNAL(p,GC_sig_suspend);
switch(result){
case ESRCH:
n_live_threads--;
break;
case 0:
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_SUSPENDED,
(void*)(word)THREAD_SYSTEM_ID(p));
break;
default:
ABORT_ARG1("pthread_kill failed at suspend",
":errcode=%d",result);
}
#endif
}
}
}
#else
#ifndef NACL_PARK_WAIT_NANOSECONDS
#define NACL_PARK_WAIT_NANOSECONDS (100*1000)
#endif
#define NANOS_PER_SECOND (1000UL*1000*1000)
unsigned long num_sleeps=0;
#ifdef DEBUG_THREADS
GC_log_printf("pthread_stop_world:num_threads=%d\n",
GC_nacl_num_gc_threads - 1);
#endif
GC_nacl_thread_parker=pthread_self();
GC_nacl_park_threads_now=1;
if (GC_manual_vdb)
GC_acquire_dirty_lock();
while (1){
int num_threads_parked=0;
struct timespec ts;
int num_used=0;
for (i=0;i < MAX_NACL_GC_THREADS
&&num_used < GC_nacl_num_gc_threads;i++){
if (GC_nacl_thread_used[i]==1){
num_used++;
if (GC_nacl_thread_parked[i]==1){
num_threads_parked++;
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_SUSPENDED,(void*)(word)i);
}
}
}
if (num_threads_parked>=GC_nacl_num_gc_threads - 1)
break;
ts.tv_sec=0;
ts.tv_nsec=NACL_PARK_WAIT_NANOSECONDS;
#ifdef DEBUG_THREADS
GC_log_printf("Sleep waiting for %d threads to park...\n",
GC_nacl_num_gc_threads - num_threads_parked - 1);
#endif
nanosleep(&ts,0);
if (++num_sleeps > NANOS_PER_SECOND/NACL_PARK_WAIT_NANOSECONDS){
WARN("GC appears stalled waiting for %" WARN_PRIdPTR
" threads to park...\n",
GC_nacl_num_gc_threads - num_threads_parked - 1);
num_sleeps=0;
}
}
if (GC_manual_vdb)
GC_release_dirty_lock();
#endif
return n_live_threads;
}
GC_INNER void GC_stop_world(void)
{
#if!defined(GC_OPENBSD_UTHREADS)&&!defined(NACL)
int n_live_threads;
#endif
GC_ASSERT(I_HOLD_LOCK());
#ifdef DEBUG_THREADS
GC_stopping_thread=pthread_self();
GC_stopping_pid=getpid();
GC_log_printf("Stopping the world from %p\n",(void*)GC_stopping_thread);
#endif
#ifdef PARALLEL_MARK
if (GC_parallel){
GC_acquire_mark_lock();
GC_ASSERT(GC_fl_builder_count==0);
}
#endif
#if defined(GC_OPENBSD_UTHREADS)||defined(NACL)
(void)GC_suspend_all();
#else
AO_store(&GC_stop_count,
(AO_t)((word)GC_stop_count+(THREAD_RESTARTED+1)));
if (GC_manual_vdb){
GC_acquire_dirty_lock();
}
AO_store_release(&GC_world_is_stopped,TRUE);
n_live_threads=GC_suspend_all();
if (GC_retry_signals)
n_live_threads=resend_lost_signals(n_live_threads,GC_suspend_all);
suspend_restart_barrier(n_live_threads);
if (GC_manual_vdb)
GC_release_dirty_lock();
#endif
#ifdef PARALLEL_MARK
if (GC_parallel)
GC_release_mark_lock();
#endif
#ifdef DEBUG_THREADS
GC_log_printf("World stopped from %p\n",(void*)pthread_self());
GC_stopping_thread=0;
#endif
}
#ifdef NACL
#if defined(__x86_64__)
#define NACL_STORE_REGS()do { __asm__ __volatile__ ("push %rbx");__asm__ __volatile__ ("push %rbp");__asm__ __volatile__ ("push %r12");__asm__ __volatile__ ("push %r13");__asm__ __volatile__ ("push %r14");__asm__ __volatile__ ("push %r15");__asm__ __volatile__ ("mov %%esp,%0":"=m" (GC_nacl_gc_thread_self->stop_info.stack_ptr));BCOPY(GC_nacl_gc_thread_self->stop_info.stack_ptr,GC_nacl_gc_thread_self->stop_info.reg_storage,NACL_GC_REG_STORAGE_SIZE*sizeof(ptr_t));__asm__ __volatile__ ("naclasp $48,%r15");} while (0)
#elif defined(__i386__)
#define NACL_STORE_REGS()do { __asm__ __volatile__ ("push %ebx");__asm__ __volatile__ ("push %ebp");__asm__ __volatile__ ("push %esi");__asm__ __volatile__ ("push %edi");__asm__ __volatile__ ("mov %%esp,%0":"=m" (GC_nacl_gc_thread_self->stop_info.stack_ptr));BCOPY(GC_nacl_gc_thread_self->stop_info.stack_ptr,GC_nacl_gc_thread_self->stop_info.reg_storage,NACL_GC_REG_STORAGE_SIZE*sizeof(ptr_t));__asm__ __volatile__ ("add $16,%esp");} while (0)
#elif defined(__arm__)
#define NACL_STORE_REGS()do { __asm__ __volatile__ ("push {r4-r8,r10-r12,lr}");__asm__ __volatile__ ("mov r0,%0"::"r" (&GC_nacl_gc_thread_self->stop_info.stack_ptr));__asm__ __volatile__ ("bic r0,r0,#0xc0000000");__asm__ __volatile__ ("str sp,[r0]");BCOPY(GC_nacl_gc_thread_self->stop_info.stack_ptr,GC_nacl_gc_thread_self->stop_info.reg_storage,NACL_GC_REG_STORAGE_SIZE*sizeof(ptr_t));__asm__ __volatile__ ("add sp,sp,#40");__asm__ __volatile__ ("bic sp,sp,#0xc0000000");} while (0)
#else
#error TODO Please port NACL_STORE_REGS
#endif
GC_API_OSCALL void nacl_pre_syscall_hook(void)
{
if (GC_nacl_thread_idx!=-1){
NACL_STORE_REGS();
GC_nacl_gc_thread_self->stop_info.stack_ptr=GC_approx_sp();
GC_nacl_thread_parked[GC_nacl_thread_idx]=1;
}
}
GC_API_OSCALL void __nacl_suspend_thread_if_needed(void)
{
if (GC_nacl_park_threads_now){
pthread_t self=pthread_self();
if (GC_nacl_thread_parker==self)
return;
if (GC_nacl_thread_idx < 0)
return;
if (!GC_nacl_thread_parked[GC_nacl_thread_idx]){
NACL_STORE_REGS();
GC_nacl_gc_thread_self->stop_info.stack_ptr=GC_approx_sp();
}
GC_nacl_thread_parked[GC_nacl_thread_idx]=1;
while (GC_nacl_park_threads_now){
}
GC_nacl_thread_parked[GC_nacl_thread_idx]=0;
BZERO(GC_nacl_gc_thread_self->stop_info.reg_storage,
NACL_GC_REG_STORAGE_SIZE*sizeof(ptr_t));
}
}
GC_API_OSCALL void nacl_post_syscall_hook(void)
{
__nacl_suspend_thread_if_needed();
if (GC_nacl_thread_idx!=-1){
GC_nacl_thread_parked[GC_nacl_thread_idx]=0;
}
}
STATIC GC_bool GC_nacl_thread_parking_inited=FALSE;
STATIC pthread_mutex_t GC_nacl_thread_alloc_lock=PTHREAD_MUTEX_INITIALIZER;
struct nacl_irt_blockhook {
int (*register_block_hooks)(void (*pre)(void),void (*post)(void));
};
EXTERN_C_BEGIN
extern size_t nacl_interface_query(const char*interface_ident,
void*table,size_t tablesize);
EXTERN_C_END
GC_INNER void GC_nacl_initialize_gc_thread(void)
{
int i;
static struct nacl_irt_blockhook gc_hook;
pthread_mutex_lock(&GC_nacl_thread_alloc_lock);
if (!EXPECT(GC_nacl_thread_parking_inited,TRUE)){
BZERO(GC_nacl_thread_parked,sizeof(GC_nacl_thread_parked));
BZERO(GC_nacl_thread_used,sizeof(GC_nacl_thread_used));
nacl_interface_query("nacl-irt-blockhook-0.1",
&gc_hook,sizeof(gc_hook));
gc_hook.register_block_hooks(nacl_pre_syscall_hook,
nacl_post_syscall_hook);
GC_nacl_thread_parking_inited=TRUE;
}
GC_ASSERT(GC_nacl_num_gc_threads<=MAX_NACL_GC_THREADS);
for (i=0;i < MAX_NACL_GC_THREADS;i++){
if (GC_nacl_thread_used[i]==0){
GC_nacl_thread_used[i]=1;
GC_nacl_thread_idx=i;
GC_nacl_num_gc_threads++;
break;
}
}
pthread_mutex_unlock(&GC_nacl_thread_alloc_lock);
}
GC_INNER void GC_nacl_shutdown_gc_thread(void)
{
pthread_mutex_lock(&GC_nacl_thread_alloc_lock);
GC_ASSERT(GC_nacl_thread_idx>=0);
GC_ASSERT(GC_nacl_thread_idx < MAX_NACL_GC_THREADS);
GC_ASSERT(GC_nacl_thread_used[GC_nacl_thread_idx]!=0);
GC_nacl_thread_used[GC_nacl_thread_idx]=0;
GC_nacl_thread_idx=-1;
GC_nacl_num_gc_threads--;
pthread_mutex_unlock(&GC_nacl_thread_alloc_lock);
}
#else
STATIC int GC_restart_all(void)
{
int n_live_threads=0;
int i;
pthread_t self=pthread_self();
GC_thread p;
#ifndef GC_OPENBSD_UTHREADS
int result;
#endif
for (i=0;i < THREAD_TABLE_SZ;i++){
for (p=GC_threads[i];p!=NULL;p=p->next){
if (!THREAD_EQUAL(p->id,self)){
if ((p->flags&FINISHED)!=0)continue;
if (p->thread_blocked)continue;
#ifndef GC_OPENBSD_UTHREADS
#ifdef GC_ENABLE_SUSPEND_THREAD
if (p->suspended_ext)continue;
#endif
if (GC_retry_signals
&&AO_load(&p->stop_info.last_stop_count)
==(AO_t)((word)GC_stop_count|THREAD_RESTARTED))
continue;
n_live_threads++;
#endif
#ifdef DEBUG_THREADS
GC_log_printf("Sending restart signal to %p\n",(void*)p->id);
#endif
#ifdef GC_OPENBSD_UTHREADS
if (pthread_resume_np(p->id)!=0)
ABORT("pthread_resume_np failed");
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_UNSUSPENDED,(void*)p->id);
#else
result=RAISE_SIGNAL(p,GC_sig_thr_restart);
switch(result){
case ESRCH:
n_live_threads--;
break;
case 0:
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_UNSUSPENDED,
(void*)(word)THREAD_SYSTEM_ID(p));
break;
default:
ABORT_ARG1("pthread_kill failed at resume",
":errcode=%d",result);
}
#endif
}
}
}
return n_live_threads;
}
#endif
GC_INNER void GC_start_world(void)
{
#ifndef NACL
int n_live_threads;
GC_ASSERT(I_HOLD_LOCK());
#ifdef DEBUG_THREADS
GC_log_printf("World starting\n");
#endif
#ifndef GC_OPENBSD_UTHREADS
AO_store_release(&GC_world_is_stopped,FALSE);
#endif
n_live_threads=GC_restart_all();
#ifdef GC_OPENBSD_UTHREADS
(void)n_live_threads;
#elif defined(GC_NETBSD_THREADS_WORKAROUND)
if (GC_retry_signals)
n_live_threads=resend_lost_signals(n_live_threads,GC_restart_all);
suspend_restart_barrier(n_live_threads);
#else
if (GC_retry_signals){
n_live_threads=resend_lost_signals(n_live_threads,GC_restart_all);
suspend_restart_barrier(n_live_threads);
}
#endif
#ifdef DEBUG_THREADS
GC_log_printf("World started\n");
#endif
#else
#ifdef DEBUG_THREADS
GC_log_printf("World starting...\n");
#endif
GC_nacl_park_threads_now=0;
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_UNSUSPENDED,NULL);
#endif
}
GC_INNER void GC_stop_init(void)
{
#if!defined(GC_OPENBSD_UTHREADS)&&!defined(NACL)
struct sigaction act;
char*str;
if (SIGNAL_UNSET==GC_sig_suspend)
GC_sig_suspend=SIG_SUSPEND;
if (SIGNAL_UNSET==GC_sig_thr_restart)
GC_sig_thr_restart=SIG_THR_RESTART;
if (GC_sig_suspend==GC_sig_thr_restart)
ABORT("Cannot use same signal for thread suspend and resume");
if (sem_init(&GC_suspend_ack_sem,GC_SEM_INIT_PSHARED,0)!=0)
ABORT("sem_init failed");
#ifdef SA_RESTART
act.sa_flags=SA_RESTART
#else
act.sa_flags=0
#endif
#ifndef NO_SA_SIGACTION
|SA_SIGINFO
#endif
;
if (sigfillset(&act.sa_mask)!=0){
ABORT("sigfillset failed");
}
#ifdef GC_RTEMS_PTHREADS
if(sigprocmask(SIG_UNBLOCK,&act.sa_mask,NULL)!=0){
ABORT("sigprocmask failed");
}
#endif
GC_remove_allowed_signals(&act.sa_mask);
#ifndef NO_SA_SIGACTION
act.sa_sigaction=GC_suspend_handler;
#else
act.sa_handler=GC_suspend_handler;
#endif
if (sigaction(GC_sig_suspend,&act,NULL)!=0){
ABORT("Cannot set SIG_SUSPEND handler");
}
#ifndef NO_SA_SIGACTION
act.sa_flags&=~SA_SIGINFO;
#endif
act.sa_handler=GC_restart_handler;
if (sigaction(GC_sig_thr_restart,&act,NULL)!=0){
ABORT("Cannot set SIG_THR_RESTART handler");
}
if (sigfillset(&suspend_handler_mask)!=0)ABORT("sigfillset failed");
GC_remove_allowed_signals(&suspend_handler_mask);
if (sigdelset(&suspend_handler_mask,GC_sig_thr_restart)!=0)
ABORT("sigdelset failed");
str=GETENV("GC_RETRY_SIGNALS");
if (str!=NULL){
if (*str=='0'&&*(str+1)=='\0'){
GC_retry_signals=FALSE;
} else {
GC_retry_signals=TRUE;
}
}
if (GC_retry_signals){
GC_COND_LOG_PRINTF(
"Will retry suspend and restart signals if necessary\n");
}
#ifndef NO_SIGNALS_UNBLOCK_IN_MAIN
GC_unblock_gc_signals();
#endif
#endif
}
#endif
#if defined(GC_PTHREADS)&&!defined(GC_WIN32_THREADS)
#include <stdlib.h>
#include <pthread.h>
#include <sched.h>
#include <time.h>
#include <errno.h>
#include <unistd.h>
#if!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)
#if!defined(GC_RTEMS_PTHREADS)
#include <sys/mman.h>
#endif
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#endif
#include <signal.h>
#if defined(GC_DARWIN_THREADS)
#ifndef GC_DARWIN_SEMAPHORE_H
#define GC_DARWIN_SEMAPHORE_H
#if!defined(GC_DARWIN_THREADS)
#error darwin_semaphore.h included with GC_DARWIN_THREADS not defined
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
pthread_mutex_t mutex;
pthread_cond_t cond;
int value;
} sem_t;
GC_INLINE int sem_init(sem_t*sem,int pshared,int value){
if (pshared!=0){
errno=EPERM;
return -1;
}
sem->value=value;
if (pthread_mutex_init(&sem->mutex,NULL)!=0)
return -1;
if (pthread_cond_init(&sem->cond,NULL)!=0){
(void)pthread_mutex_destroy(&sem->mutex);
return -1;
}
return 0;
}
GC_INLINE int sem_post(sem_t*sem){
if (pthread_mutex_lock(&sem->mutex)!=0)
return -1;
sem->value++;
if (pthread_cond_signal(&sem->cond)!=0){
(void)pthread_mutex_unlock(&sem->mutex);
return -1;
}
return pthread_mutex_unlock(&sem->mutex)!=0?-1:0;
}
GC_INLINE int sem_wait(sem_t*sem){
if (pthread_mutex_lock(&sem->mutex)!=0)
return -1;
while (sem->value==0){
if (pthread_cond_wait(&sem->cond,&sem->mutex)!=0){
(void)pthread_mutex_unlock(&sem->mutex);
return -1;
}
}
sem->value--;
return pthread_mutex_unlock(&sem->mutex)!=0?-1:0;
}
GC_INLINE int sem_destroy(sem_t*sem){
return pthread_cond_destroy(&sem->cond)!=0
||pthread_mutex_destroy(&sem->mutex)!=0?-1:0;
}
#ifdef __cplusplus
}
#endif
#endif
#else
#include <semaphore.h>
#endif
#if defined(GC_DARWIN_THREADS)||defined(GC_FREEBSD_THREADS)
#include <sys/sysctl.h>
#endif
#if defined(GC_NETBSD_THREADS)||defined(GC_OPENBSD_THREADS)
#include <sys/param.h>
#include <sys/sysctl.h>
#endif
#if!defined(USE_SPIN_LOCK)
GC_INNER pthread_mutex_t GC_allocate_ml=PTHREAD_MUTEX_INITIALIZER;
#endif
#ifdef GC_ASSERTIONS
GC_INNER unsigned long GC_lock_holder=NO_THREAD;
#endif
#if defined(GC_DGUX386_THREADS)
#include <sys/dg_sys_info.h>
#include <sys/_int_psem.h>
typedef unsigned int sem_t;
#endif
#undef pthread_create
#ifndef GC_NO_PTHREAD_SIGMASK
#undef pthread_sigmask
#endif
#ifndef GC_NO_PTHREAD_CANCEL
#undef pthread_cancel
#endif
#ifdef GC_HAVE_PTHREAD_EXIT
#undef pthread_exit
#endif
#undef pthread_join
#undef pthread_detach
#if defined(GC_OSF1_THREADS)&&defined(_PTHREAD_USE_MANGLED_NAMES_)&&!defined(_PTHREAD_USE_PTDNAM_)
#define pthread_create __pthread_create
#define pthread_join __pthread_join
#define pthread_detach __pthread_detach
#ifndef GC_NO_PTHREAD_CANCEL
#define pthread_cancel __pthread_cancel
#endif
#ifdef GC_HAVE_PTHREAD_EXIT
#define pthread_exit __pthread_exit
#endif
#endif
#ifdef GC_USE_LD_WRAP
#define WRAP_FUNC(f)__wrap_##f
#define REAL_FUNC(f)__real_##f
int REAL_FUNC(pthread_create)(pthread_t*,
GC_PTHREAD_CREATE_CONST pthread_attr_t*,
void*(*start_routine)(void*),void*);
int REAL_FUNC(pthread_join)(pthread_t,void**);
int REAL_FUNC(pthread_detach)(pthread_t);
#ifndef GC_NO_PTHREAD_SIGMASK
int REAL_FUNC(pthread_sigmask)(int,const sigset_t*,sigset_t*);
#endif
#ifndef GC_NO_PTHREAD_CANCEL
int REAL_FUNC(pthread_cancel)(pthread_t);
#endif
#ifdef GC_HAVE_PTHREAD_EXIT
void REAL_FUNC(pthread_exit)(void*)GC_PTHREAD_EXIT_ATTRIBUTE;
#endif
#else
#ifdef GC_USE_DLOPEN_WRAP
#include <dlfcn.h>
#define WRAP_FUNC(f)f
#define REAL_FUNC(f)GC_real_##f
typedef int (*GC_pthread_create_t)(pthread_t*,
GC_PTHREAD_CREATE_CONST pthread_attr_t*,
void*(*)(void*),void*);
static GC_pthread_create_t REAL_FUNC(pthread_create);
#ifndef GC_NO_PTHREAD_SIGMASK
typedef int (*GC_pthread_sigmask_t)(int,const sigset_t*,
sigset_t*);
static GC_pthread_sigmask_t REAL_FUNC(pthread_sigmask);
#endif
typedef int (*GC_pthread_join_t)(pthread_t,void**);
static GC_pthread_join_t REAL_FUNC(pthread_join);
typedef int (*GC_pthread_detach_t)(pthread_t);
static GC_pthread_detach_t REAL_FUNC(pthread_detach);
#ifndef GC_NO_PTHREAD_CANCEL
typedef int (*GC_pthread_cancel_t)(pthread_t);
static GC_pthread_cancel_t REAL_FUNC(pthread_cancel);
#endif
#ifdef GC_HAVE_PTHREAD_EXIT
typedef void (*GC_pthread_exit_t)(void*)GC_PTHREAD_EXIT_ATTRIBUTE;
static GC_pthread_exit_t REAL_FUNC(pthread_exit);
#endif
#else
#define WRAP_FUNC(f)GC_##f
#if!defined(GC_DGUX386_THREADS)
#define REAL_FUNC(f)f
#else
#define REAL_FUNC(f)__d10_##f
#endif
#endif
#endif
#if defined(GC_USE_LD_WRAP)||defined(GC_USE_DLOPEN_WRAP)
GC_API int GC_pthread_create(pthread_t*t,
GC_PTHREAD_CREATE_CONST pthread_attr_t*a,
void*(*fn)(void*),void*arg)
{
return pthread_create(t,a,fn,arg);
}
#ifndef GC_NO_PTHREAD_SIGMASK
GC_API int GC_pthread_sigmask(int how,const sigset_t*mask,
sigset_t*old)
{
return pthread_sigmask(how,mask,old);
}
#endif
GC_API int GC_pthread_join(pthread_t t,void**res)
{
return pthread_join(t,res);
}
GC_API int GC_pthread_detach(pthread_t t)
{
return pthread_detach(t);
}
#ifndef GC_NO_PTHREAD_CANCEL
GC_API int GC_pthread_cancel(pthread_t t)
{
return pthread_cancel(t);
}
#endif
#ifdef GC_HAVE_PTHREAD_EXIT
GC_API GC_PTHREAD_EXIT_ATTRIBUTE void GC_pthread_exit(void*retval)
{
pthread_exit(retval);
}
#endif
#endif
#ifdef GC_USE_DLOPEN_WRAP
STATIC GC_bool GC_syms_initialized=FALSE;
STATIC void GC_init_real_syms(void)
{
void*dl_handle;
if (GC_syms_initialized)return;
#ifdef RTLD_NEXT
dl_handle=RTLD_NEXT;
#else
dl_handle=dlopen("libpthread.so.0",RTLD_LAZY);
if (NULL==dl_handle){
dl_handle=dlopen("libpthread.so",RTLD_LAZY);
}
if (NULL==dl_handle)ABORT("Couldn't open libpthread");
#endif
REAL_FUNC(pthread_create)=(GC_pthread_create_t)(word)
dlsym(dl_handle,"pthread_create");
#ifdef RTLD_NEXT
if (REAL_FUNC(pthread_create)==0)
ABORT("pthread_create not found"
" (probably -lgc is specified after -lpthread)");
#endif
#ifndef GC_NO_PTHREAD_SIGMASK
REAL_FUNC(pthread_sigmask)=(GC_pthread_sigmask_t)(word)
dlsym(dl_handle,"pthread_sigmask");
#endif
REAL_FUNC(pthread_join)=(GC_pthread_join_t)(word)
dlsym(dl_handle,"pthread_join");
REAL_FUNC(pthread_detach)=(GC_pthread_detach_t)(word)
dlsym(dl_handle,"pthread_detach");
#ifndef GC_NO_PTHREAD_CANCEL
REAL_FUNC(pthread_cancel)=(GC_pthread_cancel_t)(word)
dlsym(dl_handle,"pthread_cancel");
#endif
#ifdef GC_HAVE_PTHREAD_EXIT
REAL_FUNC(pthread_exit)=(GC_pthread_exit_t)(word)
dlsym(dl_handle,"pthread_exit");
#endif
GC_syms_initialized=TRUE;
}
#define INIT_REAL_SYMS()if (EXPECT(GC_syms_initialized,TRUE)){} else GC_init_real_syms()
#define ASSERT_SYMS_INITIALIZED()GC_ASSERT(GC_syms_initialized)
#else
#define INIT_REAL_SYMS()(void)0
#define ASSERT_SYMS_INITIALIZED()GC_ASSERT(parallel_initialized)
#endif
static GC_bool parallel_initialized=FALSE;
#ifndef GC_ALWAYS_MULTITHREADED
GC_INNER GC_bool GC_need_to_lock=FALSE;
#endif
STATIC int GC_nprocs=1;
#ifdef THREAD_LOCAL_ALLOC
GC_INNER void GC_mark_thread_local_free_lists(void)
{
int i;
GC_thread p;
for (i=0;i < THREAD_TABLE_SZ;++i){
for (p=GC_threads[i];0!=p;p=p->next){
if (!(p->flags&FINISHED))
GC_mark_thread_local_fls_for(&(p->tlfs));
}
}
}
#if defined(GC_ASSERTIONS)
void GC_check_tls(void)
{
int i;
GC_thread p;
for (i=0;i < THREAD_TABLE_SZ;++i){
for (p=GC_threads[i];0!=p;p=p->next){
if (!(p->flags&FINISHED))
GC_check_tls_for(&(p->tlfs));
}
}
#if defined(USE_CUSTOM_SPECIFIC)
if (GC_thread_key!=0)
GC_check_tsd_marks(GC_thread_key);
#endif
}
#endif
#endif
#ifdef PARALLEL_MARK
#ifndef MAX_MARKERS
#define MAX_MARKERS 16
#endif
static ptr_t marker_sp[MAX_MARKERS - 1]={0};
#ifdef IA64
static ptr_t marker_bsp[MAX_MARKERS - 1]={0};
#endif
#if defined(GC_DARWIN_THREADS)&&!defined(GC_NO_THREADS_DISCOVERY)
static mach_port_t marker_mach_threads[MAX_MARKERS - 1]={0};
GC_INNER GC_bool GC_is_mach_marker(thread_act_t thread)
{
int i;
for (i=0;i < GC_markers_m1;i++){
if (marker_mach_threads[i]==thread)
return TRUE;
}
return FALSE;
}
#endif
#ifdef HAVE_PTHREAD_SETNAME_NP_WITH_TID_AND_ARG
static void set_marker_thread_name(unsigned id)
{
int err=pthread_setname_np(pthread_self(),"GC-marker-%zu",
(void*)(size_t)id);
if (err!=0)
WARN("pthread_setname_np failed,errno=%" WARN_PRIdPTR "\n",err);
}
#elif defined(HAVE_PTHREAD_SETNAME_NP_WITH_TID)||defined(HAVE_PTHREAD_SETNAME_NP_WITHOUT_TID)
static void set_marker_thread_name(unsigned id)
{
char name_buf[16];
int len=sizeof("GC-marker-")- 1;
BCOPY("GC-marker-",name_buf,len);
if (id>=10)
name_buf[len++]=(char)('0'+(id/10)% 10);
name_buf[len]=(char)('0'+id % 10);
name_buf[len+1]='\0';
#ifdef HAVE_PTHREAD_SETNAME_NP_WITHOUT_TID
(void)pthread_setname_np(name_buf);
#else
if (pthread_setname_np(pthread_self(),name_buf)!=0)
WARN("pthread_setname_np failed\n",0);
#endif
}
#else
#define set_marker_thread_name(id)(void)(id)
#endif
STATIC void*GC_mark_thread(void*id)
{
word my_mark_no=0;
IF_CANCEL(int cancel_state;)
if ((word)id==GC_WORD_MAX)return 0;
DISABLE_CANCEL(cancel_state);
set_marker_thread_name((unsigned)(word)id);
marker_sp[(word)id]=GC_approx_sp();
#ifdef IA64
marker_bsp[(word)id]=GC_save_regs_in_stack();
#endif
#if defined(GC_DARWIN_THREADS)&&!defined(GC_NO_THREADS_DISCOVERY)
marker_mach_threads[(word)id]=mach_thread_self();
#endif
GC_acquire_mark_lock();
if (0==--GC_fl_builder_count)
GC_notify_all_builder();
for (;;++my_mark_no){
if (my_mark_no < GC_mark_no||my_mark_no > GC_mark_no+2){
my_mark_no=GC_mark_no;
}
#ifdef DEBUG_THREADS
GC_log_printf("Starting mark helper for mark number %lu\n",
(unsigned long)my_mark_no);
#endif
GC_help_marker(my_mark_no);
}
}
STATIC pthread_t GC_mark_threads[MAX_MARKERS];
#ifdef CAN_HANDLE_FORK
static int available_markers_m1=0;
static pthread_cond_t mark_cv;
#else
#define available_markers_m1 GC_markers_m1
static pthread_cond_t mark_cv=PTHREAD_COND_INITIALIZER;
#endif
GC_INNER void GC_start_mark_threads_inner(void)
{
int i;
pthread_attr_t attr;
#ifndef NO_MARKER_SPECIAL_SIGMASK
sigset_t set,oldset;
#endif
GC_ASSERT(I_DONT_HOLD_LOCK());
if (available_markers_m1<=0)return;
#ifdef CAN_HANDLE_FORK
if (GC_parallel)return;
{
pthread_cond_t mark_cv_local=PTHREAD_COND_INITIALIZER;
BCOPY(&mark_cv_local,&mark_cv,sizeof(mark_cv));
}
#endif
GC_ASSERT(GC_fl_builder_count==0);
INIT_REAL_SYMS();
if (0!=pthread_attr_init(&attr))ABORT("pthread_attr_init failed");
if (0!=pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED))
ABORT("pthread_attr_setdetachstate failed");
#ifdef DEFAULT_STACK_MAYBE_SMALL
{
size_t old_size;
if (pthread_attr_getstacksize(&attr,&old_size)!=0)
ABORT("pthread_attr_getstacksize failed");
if (old_size < MIN_STACK_SIZE
&&old_size!=0){
if (pthread_attr_setstacksize(&attr,MIN_STACK_SIZE)!=0)
ABORT("pthread_attr_setstacksize failed");
}
}
#endif
#ifndef NO_MARKER_SPECIAL_SIGMASK
if (sigfillset(&set)!=0)
ABORT("sigfillset failed");
#if!defined(GC_DARWIN_THREADS)&&!defined(GC_OPENBSD_UTHREADS)&&!defined(NACL)
if (sigdelset(&set,GC_get_suspend_signal())!=0
||sigdelset(&set,GC_get_thr_restart_signal())!=0)
ABORT("sigdelset failed");
#endif
if (REAL_FUNC(pthread_sigmask)(SIG_BLOCK,&set,&oldset)< 0){
WARN("pthread_sigmask set failed,no markers started,"
" errno=%" WARN_PRIdPTR "\n",errno);
GC_markers_m1=0;
(void)pthread_attr_destroy(&attr);
return;
}
#endif
#ifdef CAN_HANDLE_FORK
GC_markers_m1=available_markers_m1;
#endif
for (i=0;i < available_markers_m1;++i){
if (0!=REAL_FUNC(pthread_create)(GC_mark_threads+i,&attr,
GC_mark_thread,(void*)(word)i)){
WARN("Marker thread creation failed,errno=%" WARN_PRIdPTR "\n",
errno);
GC_markers_m1=i;
break;
}
}
#ifndef NO_MARKER_SPECIAL_SIGMASK
if (REAL_FUNC(pthread_sigmask)(SIG_SETMASK,&oldset,NULL)< 0){
WARN("pthread_sigmask restore failed,errno=%" WARN_PRIdPTR "\n",
errno);
}
#endif
(void)pthread_attr_destroy(&attr);
GC_wait_for_markers_init();
GC_COND_LOG_PRINTF("Started %d mark helper threads\n",GC_markers_m1);
}
#endif
GC_INNER GC_bool GC_thr_initialized=FALSE;
GC_INNER volatile GC_thread GC_threads[THREAD_TABLE_SZ]={0};
void GC_push_thread_structures(void)
{
GC_ASSERT(I_HOLD_LOCK());
GC_PUSH_ALL_SYM(GC_threads);
#if defined(THREAD_LOCAL_ALLOC)
GC_PUSH_ALL_SYM(GC_thread_key);
#endif
}
#ifdef DEBUG_THREADS
STATIC int GC_count_threads(void)
{
int i;
int count=0;
GC_ASSERT(I_HOLD_LOCK());
for (i=0;i < THREAD_TABLE_SZ;++i){
GC_thread th=GC_threads[i];
while (th){
if (!(th->flags&FINISHED))
++count;
th=th->next;
}
}
return count;
}
#endif
static struct GC_Thread_Rep first_thread;
STATIC GC_thread GC_new_thread(pthread_t id)
{
int hv=THREAD_TABLE_INDEX(id);
GC_thread result;
static GC_bool first_thread_used=FALSE;
#ifdef DEBUG_THREADS
GC_log_printf("Creating thread %p\n",(void*)id);
for (result=GC_threads[hv];result!=NULL;result=result->next)
if (!THREAD_EQUAL(result->id,id)){
GC_log_printf("Hash collision at GC_threads[%d]\n",hv);
break;
}
#endif
GC_ASSERT(I_HOLD_LOCK());
if (!EXPECT(first_thread_used,TRUE)){
result=&first_thread;
first_thread_used=TRUE;
GC_ASSERT(NULL==GC_threads[hv]);
#if defined(THREAD_SANITIZER)&&defined(CPPCHECK)
GC_noop1(result->dummy[0]);
#endif
} else {
result=(struct GC_Thread_Rep*)
GC_INTERNAL_MALLOC(sizeof(struct GC_Thread_Rep),NORMAL);
if (result==0)return(0);
}
result->id=id;
#ifdef USE_TKILL_ON_ANDROID
result->kernel_id=gettid();
#endif
result->next=GC_threads[hv];
GC_threads[hv]=result;
#ifdef NACL
GC_nacl_gc_thread_self=result;
GC_nacl_initialize_gc_thread();
#endif
GC_ASSERT(result->flags==0&&result->thread_blocked==0);
if (EXPECT(result!=&first_thread,TRUE))
GC_dirty(result);
return(result);
}
STATIC void GC_delete_thread(pthread_t id)
{
int hv=THREAD_TABLE_INDEX(id);
GC_thread p=GC_threads[hv];
GC_thread prev=NULL;
#ifdef DEBUG_THREADS
GC_log_printf("Deleting thread %p,n_threads=%d\n",
(void*)id,GC_count_threads());
#endif
#ifdef NACL
GC_nacl_shutdown_gc_thread();
GC_nacl_gc_thread_self=NULL;
#endif
GC_ASSERT(I_HOLD_LOCK());
while (!THREAD_EQUAL(p->id,id)){
prev=p;
p=p->next;
}
if (prev==0){
GC_threads[hv]=p->next;
} else {
GC_ASSERT(prev!=&first_thread);
prev->next=p->next;
GC_dirty(prev);
}
if (p!=&first_thread){
#ifdef GC_DARWIN_THREADS
mach_port_deallocate(mach_task_self(),p->stop_info.mach_thread);
#endif
GC_INTERNAL_FREE(p);
}
}
STATIC void GC_delete_gc_thread(GC_thread t)
{
pthread_t id=t->id;
int hv=THREAD_TABLE_INDEX(id);
GC_thread p=GC_threads[hv];
GC_thread prev=NULL;
GC_ASSERT(I_HOLD_LOCK());
while (p!=t){
prev=p;
p=p->next;
}
if (prev==0){
GC_threads[hv]=p->next;
} else {
GC_ASSERT(prev!=&first_thread);
prev->next=p->next;
GC_dirty(prev);
}
#ifdef GC_DARWIN_THREADS
mach_port_deallocate(mach_task_self(),p->stop_info.mach_thread);
#endif
GC_INTERNAL_FREE(p);
#ifdef DEBUG_THREADS
GC_log_printf("Deleted thread %p,n_threads=%d\n",
(void*)id,GC_count_threads());
#endif
}
GC_INNER GC_thread GC_lookup_thread(pthread_t id)
{
GC_thread p=GC_threads[THREAD_TABLE_INDEX(id)];
while (p!=0&&!THREAD_EQUAL(p->id,id))p=p->next;
return(p);
}
GC_INNER void GC_reset_finalizer_nested(void)
{
GC_thread me=GC_lookup_thread(pthread_self());
me->finalizer_nested=0;
}
GC_INNER unsigned char*GC_check_finalizer_nested(void)
{
GC_thread me=GC_lookup_thread(pthread_self());
unsigned nesting_level=me->finalizer_nested;
if (nesting_level){
if (++me->finalizer_skipped < (1U<<nesting_level))return NULL;
me->finalizer_skipped=0;
}
me->finalizer_nested=(unsigned char)(nesting_level+1);
return&me->finalizer_nested;
}
#if defined(GC_ASSERTIONS)&&defined(THREAD_LOCAL_ALLOC)
GC_bool GC_is_thread_tsd_valid(void*tsd)
{
GC_thread me;
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread(pthread_self());
UNLOCK();
return (word)tsd>=(word)(&me->tlfs)
&&(word)tsd < (word)(&me->tlfs)+sizeof(me->tlfs);
}
#endif
GC_API int GC_CALL GC_thread_is_registered(void)
{
pthread_t self=pthread_self();
GC_thread me;
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread(self);
UNLOCK();
return me!=NULL;
}
static pthread_t main_pthread_id;
static void*main_stack,*main_altstack;
static word main_stack_size,main_altstack_size;
GC_API void GC_CALL GC_register_altstack(void*stack,GC_word stack_size,
void*altstack,
GC_word altstack_size)
{
GC_thread me;
pthread_t self=pthread_self();
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread(self);
if (me!=NULL){
me->stack=(ptr_t)stack;
me->stack_size=stack_size;
me->altstack=(ptr_t)altstack;
me->altstack_size=altstack_size;
} else {
main_pthread_id=self;
main_stack=stack;
main_stack_size=stack_size;
main_altstack=altstack;
main_altstack_size=altstack_size;
}
UNLOCK();
}
#ifdef CAN_HANDLE_FORK
#ifdef CAN_CALL_ATFORK
GC_ATTR_NO_SANITIZE_THREAD
#endif
static void store_to_threads_table(int hv,GC_thread me)
{
GC_threads[hv]=me;
}
STATIC void GC_remove_all_threads_but_me(void)
{
pthread_t self=pthread_self();
int hv;
for (hv=0;hv < THREAD_TABLE_SZ;++hv){
GC_thread p,next;
GC_thread me=NULL;
for (p=GC_threads[hv];0!=p;p=next){
next=p->next;
if (THREAD_EQUAL(p->id,self)
&&me==NULL){
me=p;
p->next=0;
#ifdef GC_DARWIN_THREADS
me->stop_info.mach_thread=mach_thread_self();
#endif
#ifdef USE_TKILL_ON_ANDROID
me->kernel_id=gettid();
#endif
#if defined(THREAD_LOCAL_ALLOC)&&!defined(USE_CUSTOM_SPECIFIC)
{
int res;
res=GC_setspecific(GC_thread_key,&me->tlfs);
if (COVERT_DATAFLOW(res)!=0)
ABORT("GC_setspecific failed (in child)");
}
#endif
} else {
#ifdef THREAD_LOCAL_ALLOC
if (!(p->flags&FINISHED)){
GC_remove_specific_after_fork(GC_thread_key,p->id);
}
#endif
#if!defined(THREAD_SANITIZER)||!defined(CAN_CALL_ATFORK)
if (p!=&first_thread)GC_INTERNAL_FREE(p);
#endif
}
}
store_to_threads_table(hv,me);
}
}
#endif
#ifdef USE_PROC_FOR_LIBRARIES
GC_INNER GC_bool GC_segment_is_thread_stack(ptr_t lo,ptr_t hi)
{
int i;
GC_thread p;
GC_ASSERT(I_HOLD_LOCK());
#ifdef PARALLEL_MARK
for (i=0;i < GC_markers_m1;++i){
if ((word)marker_sp[i] > (word)lo&&(word)marker_sp[i] < (word)hi)
return TRUE;
#ifdef IA64
if ((word)marker_bsp[i] > (word)lo
&&(word)marker_bsp[i] < (word)hi)
return TRUE;
#endif
}
#endif
for (i=0;i < THREAD_TABLE_SZ;i++){
for (p=GC_threads[i];p!=0;p=p->next){
if (0!=p->stack_end){
#ifdef STACK_GROWS_UP
if ((word)p->stack_end>=(word)lo
&&(word)p->stack_end < (word)hi)
return TRUE;
#else
if ((word)p->stack_end > (word)lo
&&(word)p->stack_end<=(word)hi)
return TRUE;
#endif
}
}
}
return FALSE;
}
#endif
#ifdef IA64
GC_INNER ptr_t GC_greatest_stack_base_below(ptr_t bound)
{
int i;
GC_thread p;
ptr_t result=0;
GC_ASSERT(I_HOLD_LOCK());
#ifdef PARALLEL_MARK
for (i=0;i < GC_markers_m1;++i){
if ((word)marker_sp[i] > (word)result
&&(word)marker_sp[i] < (word)bound)
result=marker_sp[i];
}
#endif
for (i=0;i < THREAD_TABLE_SZ;i++){
for (p=GC_threads[i];p!=0;p=p->next){
if ((word)p->stack_end > (word)result
&&(word)p->stack_end < (word)bound){
result=p->stack_end;
}
}
}
return result;
}
#endif
#ifndef STAT_READ
#define STAT_BUF_SIZE 4096
#define STAT_READ read
#endif
#ifdef GC_HPUX_THREADS
#define GC_get_nprocs()pthread_num_processors_np()
#elif defined(GC_OSF1_THREADS)||defined(GC_AIX_THREADS)||defined(GC_HAIKU_THREADS)||defined(GC_SOLARIS_THREADS)||defined(HURD)||defined(HOST_ANDROID)||defined(NACL)
GC_INLINE int GC_get_nprocs(void)
{
int nprocs=(int)sysconf(_SC_NPROCESSORS_ONLN);
return nprocs > 0?nprocs:1;
}
#elif defined(GC_IRIX_THREADS)
GC_INLINE int GC_get_nprocs(void)
{
int nprocs=(int)sysconf(_SC_NPROC_ONLN);
return nprocs > 0?nprocs:1;
}
#elif defined(GC_LINUX_THREADS)
STATIC int GC_get_nprocs(void)
{
char stat_buf[STAT_BUF_SIZE];
int f;
int result,i,len;
f=open("/proc/stat",O_RDONLY);
if (f < 0){
WARN("Couldn't read/proc/stat\n",0);
return 1;
}
len=STAT_READ(f,stat_buf,STAT_BUF_SIZE);
close(f);
result=1;
for (i=0;i < len - 100;++i){
if (stat_buf[i]=='\n'&&stat_buf[i+1]=='c'
&&stat_buf[i+2]=='p'&&stat_buf[i+3]=='u'){
int cpu_no=atoi(&stat_buf[i+4]);
if (cpu_no>=result)
result=cpu_no+1;
}
}
return result;
}
#elif defined(GC_DGUX386_THREADS)
STATIC int GC_get_nprocs(void)
{
int numCpus;
struct dg_sys_info_pm_info pm_sysinfo;
int status=0;
status=dg_sys_info((long int*)&pm_sysinfo,
DG_SYS_INFO_PM_INFO_TYPE,DG_SYS_INFO_PM_CURRENT_VERSION);
if (status < 0)
numCpus=-1;
else
numCpus=pm_sysinfo.idle_vp_count;
return(numCpus);
}
#elif defined(GC_DARWIN_THREADS)||defined(GC_FREEBSD_THREADS)||defined(GC_NETBSD_THREADS)||defined(GC_OPENBSD_THREADS)
STATIC int GC_get_nprocs(void)
{
int mib[]={CTL_HW,HW_NCPU};
int res;
size_t len=sizeof(res);
sysctl(mib,sizeof(mib)/sizeof(int),&res,&len,NULL,0);
return res;
}
#else
#define GC_get_nprocs()1
#endif
#if defined(ARM32)&&defined(GC_LINUX_THREADS)&&!defined(NACL)
STATIC int GC_get_nprocs_present(void)
{
char stat_buf[16];
int f;
int len;
f=open("/sys/devices/system/cpu/present",O_RDONLY);
if (f < 0)
return -1;
len=STAT_READ(f,stat_buf,sizeof(stat_buf));
close(f);
if (len < 2||stat_buf[0]!='0'||stat_buf[len - 1]!='\n'){
return 0;
} else if (len==2){
return 1;
} else if (stat_buf[1]!='-'){
return 0;
}
stat_buf[len - 1]='\0';
return atoi(&stat_buf[2])+1;
}
#endif
STATIC void GC_wait_for_gc_completion(GC_bool wait_for_all)
{
DCL_LOCK_STATE;
#if!defined(THREAD_SANITIZER)||!defined(CAN_CALL_ATFORK)
GC_ASSERT(I_HOLD_LOCK());
#endif
ASSERT_CANCEL_DISABLED();
if (GC_incremental&&GC_collection_in_progress()){
word old_gc_no=GC_gc_no;
while (GC_incremental&&GC_collection_in_progress()
&&(wait_for_all||old_gc_no==GC_gc_no)){
ENTER_GC();
GC_in_thread_creation=TRUE;
GC_collect_a_little_inner(1);
GC_in_thread_creation=FALSE;
EXIT_GC();
UNLOCK();
sched_yield();
LOCK();
}
}
}
#ifdef CAN_HANDLE_FORK
IF_CANCEL(static int fork_cancel_state;)
#if defined(GC_ASSERTIONS)&&defined(CAN_CALL_ATFORK)
GC_ATTR_NO_SANITIZE_THREAD
#endif
static void fork_prepare_proc(void)
{
LOCK();
DISABLE_CANCEL(fork_cancel_state);
#if defined(PARALLEL_MARK)
if (GC_parallel)
GC_wait_for_reclaim();
#endif
GC_wait_for_gc_completion(TRUE);
#if defined(PARALLEL_MARK)
if (GC_parallel)
GC_acquire_mark_lock();
#endif
GC_acquire_dirty_lock();
}
#if defined(GC_ASSERTIONS)&&defined(CAN_CALL_ATFORK)
GC_ATTR_NO_SANITIZE_THREAD
#endif
static void fork_parent_proc(void)
{
GC_release_dirty_lock();
#if defined(PARALLEL_MARK)
if (GC_parallel)
GC_release_mark_lock();
#endif
RESTORE_CANCEL(fork_cancel_state);
UNLOCK();
}
#if defined(GC_ASSERTIONS)&&defined(CAN_CALL_ATFORK)
GC_ATTR_NO_SANITIZE_THREAD
#endif
static void fork_child_proc(void)
{
GC_release_dirty_lock();
#if defined(PARALLEL_MARK)
if (GC_parallel)
GC_release_mark_lock();
#endif
GC_remove_all_threads_but_me();
#ifdef PARALLEL_MARK
GC_parallel=FALSE;
#endif
RESTORE_CANCEL(fork_cancel_state);
UNLOCK();
#ifdef USE_PTHREAD_LOCKS
GC_ASSERT(I_DONT_HOLD_LOCK());
(void)pthread_mutex_destroy(&GC_allocate_ml);
if (0!=pthread_mutex_init(&GC_allocate_ml,NULL))
ABORT("pthread_mutex_init failed (in child)");
#endif
}
GC_API void GC_CALL GC_atfork_prepare(void)
{
if (!EXPECT(GC_is_initialized,TRUE))GC_init();
#if defined(GC_DARWIN_THREADS)&&defined(MPROTECT_VDB)
if (GC_auto_incremental){
GC_ASSERT(0==GC_handle_fork);
ABORT("Unable to fork while mprotect_thread is running");
}
#endif
if (GC_handle_fork<=0)
fork_prepare_proc();
}
GC_API void GC_CALL GC_atfork_parent(void)
{
if (GC_handle_fork<=0)
fork_parent_proc();
}
GC_API void GC_CALL GC_atfork_child(void)
{
if (GC_handle_fork<=0)
fork_child_proc();
}
#endif
#ifdef INCLUDE_LINUX_THREAD_DESCR
__thread int GC_dummy_thread_local;
#endif
#ifdef PARALLEL_MARK
static void setup_mark_lock(void);
static unsigned required_markers_cnt=0;
#endif
GC_API void GC_CALL GC_set_markers_count(unsigned markers GC_ATTR_UNUSED)
{
#ifdef PARALLEL_MARK
required_markers_cnt=markers < MAX_MARKERS?markers:MAX_MARKERS;
#endif
}
GC_INNER void GC_thr_init(void)
{
GC_ASSERT(I_HOLD_LOCK());
if (GC_thr_initialized)return;
GC_thr_initialized=TRUE;
GC_ASSERT((word)&GC_threads % sizeof(word)==0);
#ifdef CAN_HANDLE_FORK
if (GC_handle_fork){
#ifdef CAN_CALL_ATFORK
if (pthread_atfork(fork_prepare_proc,fork_parent_proc,
fork_child_proc)==0){
GC_handle_fork=1;
} else
#endif
if (GC_handle_fork!=-1)
ABORT("pthread_atfork failed");
}
#endif
#ifdef INCLUDE_LINUX_THREAD_DESCR
{
ptr_t thread_local_addr=(ptr_t)(&GC_dummy_thread_local);
ptr_t main_thread_start,main_thread_end;
if (!GC_enclosing_mapping(thread_local_addr,&main_thread_start,
&main_thread_end)){
ABORT("Failed to find mapping for main thread thread locals");
} else {
GC_add_roots_inner(main_thread_start,main_thread_end,FALSE);
}
}
#endif
{
pthread_t self=pthread_self();
GC_thread t=GC_new_thread(self);
if (t==NULL)
ABORT("Failed to allocate memory for the initial thread");
#ifdef GC_DARWIN_THREADS
t->stop_info.mach_thread=mach_thread_self();
#else
t->stop_info.stack_ptr=GC_approx_sp();
#endif
t->flags=DETACHED|MAIN_THREAD;
if (THREAD_EQUAL(self,main_pthread_id)){
t->stack=(ptr_t)main_stack;
t->stack_size=main_stack_size;
t->altstack=(ptr_t)main_altstack;
t->altstack_size=main_altstack_size;
}
}
#ifndef GC_DARWIN_THREADS
GC_stop_init();
#endif
{
char*nprocs_string=GETENV("GC_NPROCS");
GC_nprocs=-1;
if (nprocs_string!=NULL)GC_nprocs=atoi(nprocs_string);
}
if (GC_nprocs<=0
#if defined(ARM32)&&defined(GC_LINUX_THREADS)&&!defined(NACL)
&&(GC_nprocs=GC_get_nprocs_present())<=1
#endif
)
{
GC_nprocs=GC_get_nprocs();
}
if (GC_nprocs<=0){
WARN("GC_get_nprocs()returned %" WARN_PRIdPTR "\n",GC_nprocs);
GC_nprocs=2;
#ifdef PARALLEL_MARK
available_markers_m1=0;
#endif
} else {
#ifdef PARALLEL_MARK
{
char*markers_string=GETENV("GC_MARKERS");
int markers=required_markers_cnt;
if (markers_string!=NULL){
markers=atoi(markers_string);
if (markers<=0||markers > MAX_MARKERS){
WARN("Too big or invalid number of mark threads:%" WARN_PRIdPTR
";using maximum threads\n",(signed_word)markers);
markers=MAX_MARKERS;
}
} else if (0==markers){
markers=GC_nprocs;
#if defined(GC_MIN_MARKERS)&&!defined(CPPCHECK)
if (markers < GC_MIN_MARKERS)
markers=GC_MIN_MARKERS;
#endif
if (markers > MAX_MARKERS)
markers=MAX_MARKERS;
}
available_markers_m1=markers - 1;
}
#endif
}
GC_COND_LOG_PRINTF("Number of processors=%d\n",GC_nprocs);
#ifdef PARALLEL_MARK
if (available_markers_m1<=0){
GC_parallel=FALSE;
GC_COND_LOG_PRINTF(
"Single marker thread,turning off parallel marking\n");
} else {
setup_mark_lock();
}
#endif
}
GC_INNER void GC_init_parallel(void)
{
#if defined(THREAD_LOCAL_ALLOC)
DCL_LOCK_STATE;
#endif
if (parallel_initialized)return;
parallel_initialized=TRUE;
if (!GC_is_initialized)GC_init();
#if defined(THREAD_LOCAL_ALLOC)
LOCK();
GC_init_thread_local(&(GC_lookup_thread(pthread_self())->tlfs));
UNLOCK();
#endif
}
#ifndef GC_NO_PTHREAD_SIGMASK
GC_API int WRAP_FUNC(pthread_sigmask)(int how,const sigset_t*set,
sigset_t*oset)
{
sigset_t fudged_set;
INIT_REAL_SYMS();
if (set!=NULL&&(how==SIG_BLOCK||how==SIG_SETMASK)){
int sig_suspend=GC_get_suspend_signal();
fudged_set=*set;
GC_ASSERT(sig_suspend>=0);
if (sigdelset(&fudged_set,sig_suspend)!=0)
ABORT("sigdelset failed");
set=&fudged_set;
}
return(REAL_FUNC(pthread_sigmask)(how,set,oset));
}
#endif
GC_INNER void GC_do_blocking_inner(ptr_t data,void*context GC_ATTR_UNUSED)
{
struct blocking_data*d=(struct blocking_data*)data;
pthread_t self=pthread_self();
GC_thread me;
#if defined(SPARC)||defined(IA64)
ptr_t stack_ptr=GC_save_regs_in_stack();
#endif
#if defined(GC_DARWIN_THREADS)&&!defined(DARWIN_DONT_PARSE_STACK)
GC_bool topOfStackUnset=FALSE;
#endif
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread(self);
GC_ASSERT(!(me->thread_blocked));
#ifdef SPARC
me->stop_info.stack_ptr=stack_ptr;
#else
me->stop_info.stack_ptr=GC_approx_sp();
#endif
#if defined(GC_DARWIN_THREADS)&&!defined(DARWIN_DONT_PARSE_STACK)
if (me->topOfStack==NULL){
topOfStackUnset=TRUE;
me->topOfStack=GC_FindTopOfStack(0);
}
#endif
#ifdef IA64
me->backing_store_ptr=stack_ptr;
#endif
me->thread_blocked=(unsigned char)TRUE;
UNLOCK();
d->client_data=(d->fn)(d->client_data);
LOCK();
#if defined(CPPCHECK)
GC_noop1((word)&me->thread_blocked);
#endif
me->thread_blocked=FALSE;
#if defined(GC_DARWIN_THREADS)&&!defined(DARWIN_DONT_PARSE_STACK)
if (topOfStackUnset)
me->topOfStack=NULL;
#endif
UNLOCK();
}
GC_API void GC_CALL GC_set_stackbottom(void*gc_thread_handle,
const struct GC_stack_base*sb)
{
GC_thread t=(GC_thread)gc_thread_handle;
GC_ASSERT(sb->mem_base!=NULL);
if (!EXPECT(GC_is_initialized,TRUE)){
GC_ASSERT(NULL==t);
} else {
GC_ASSERT(I_HOLD_LOCK());
if (NULL==t)
t=GC_lookup_thread(pthread_self());
GC_ASSERT((t->flags&FINISHED)==0);
GC_ASSERT(!(t->thread_blocked)
&&NULL==t->traced_stack_sect);
if ((t->flags&MAIN_THREAD)==0){
t->stack_end=(ptr_t)sb->mem_base;
#ifdef IA64
t->backing_store_end=(ptr_t)sb->reg_base;
#endif
return;
}
}
GC_stackbottom=(char*)sb->mem_base;
#ifdef IA64
GC_register_stackbottom=(ptr_t)sb->reg_base;
#endif
}
GC_API void*GC_CALL GC_get_my_stackbottom(struct GC_stack_base*sb)
{
pthread_t self=pthread_self();
GC_thread me;
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread(self);
if ((me->flags&MAIN_THREAD)==0){
sb->mem_base=me->stack_end;
#ifdef IA64
sb->reg_base=me->backing_store_end;
#endif
} else {
sb->mem_base=GC_stackbottom;
#ifdef IA64
sb->reg_base=GC_register_stackbottom;
#endif
}
UNLOCK();
return (void*)me;
}
GC_API void*GC_CALL GC_call_with_gc_active(GC_fn_type fn,
void*client_data)
{
struct GC_traced_stack_sect_s stacksect;
pthread_t self=pthread_self();
GC_thread me;
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread(self);
if ((me->flags&MAIN_THREAD)==0){
GC_ASSERT(me->stack_end!=NULL);
if ((word)me->stack_end HOTTER_THAN (word)(&stacksect))
me->stack_end=(ptr_t)(&stacksect);
} else {
if ((word)GC_stackbottom HOTTER_THAN (word)(&stacksect))
GC_stackbottom=(ptr_t)COVERT_DATAFLOW(&stacksect);
}
if (!me->thread_blocked){
UNLOCK();
client_data=fn(client_data);
GC_noop1(COVERT_DATAFLOW(&stacksect));
return client_data;
}
stacksect.saved_stack_ptr=me->stop_info.stack_ptr;
#ifdef IA64
stacksect.backing_store_end=GC_save_regs_in_stack();
stacksect.saved_backing_store_ptr=me->backing_store_ptr;
#endif
stacksect.prev=me->traced_stack_sect;
me->thread_blocked=FALSE;
me->traced_stack_sect=&stacksect;
UNLOCK();
client_data=fn(client_data);
GC_ASSERT(me->thread_blocked==FALSE);
GC_ASSERT(me->traced_stack_sect==&stacksect);
#if defined(CPPCHECK)
GC_noop1((word)me->traced_stack_sect);
#endif
LOCK();
me->traced_stack_sect=stacksect.prev;
#ifdef IA64
me->backing_store_ptr=stacksect.saved_backing_store_ptr;
#endif
me->thread_blocked=(unsigned char)TRUE;
me->stop_info.stack_ptr=stacksect.saved_stack_ptr;
UNLOCK();
return client_data;
}
STATIC void GC_unregister_my_thread_inner(GC_thread me)
{
#ifdef DEBUG_THREADS
GC_log_printf(
"Unregistering thread %p,gc_thread=%p,n_threads=%d\n",
(void*)me->id,(void*)me,GC_count_threads());
#endif
GC_ASSERT(!(me->flags&FINISHED));
#if defined(THREAD_LOCAL_ALLOC)
GC_ASSERT(GC_getspecific(GC_thread_key)==&me->tlfs);
GC_destroy_thread_local(&(me->tlfs));
#endif
#if defined(GC_HAVE_PTHREAD_EXIT)||!defined(GC_NO_PTHREAD_CANCEL)
if ((me->flags&DISABLED_GC)!=0){
GC_dont_gc--;
}
#endif
if (me->flags&DETACHED){
GC_delete_thread(pthread_self());
} else {
me->flags|=FINISHED;
}
#if defined(THREAD_LOCAL_ALLOC)
GC_remove_specific(GC_thread_key);
#endif
}
GC_API int GC_CALL GC_unregister_my_thread(void)
{
pthread_t self=pthread_self();
GC_thread me;
IF_CANCEL(int cancel_state;)
DCL_LOCK_STATE;
LOCK();
DISABLE_CANCEL(cancel_state);
GC_wait_for_gc_completion(FALSE);
me=GC_lookup_thread(self);
#ifdef DEBUG_THREADS
GC_log_printf(
"Called GC_unregister_my_thread on %p,gc_thread=%p\n",
(void*)self,(void*)me);
#endif
GC_ASSERT(THREAD_EQUAL(me->id,self));
GC_unregister_my_thread_inner(me);
RESTORE_CANCEL(cancel_state);
UNLOCK();
return GC_SUCCESS;
}
GC_INNER_PTHRSTART void GC_thread_exit_proc(void*arg)
{
IF_CANCEL(int cancel_state;)
DCL_LOCK_STATE;
#ifdef DEBUG_THREADS
GC_log_printf("Called GC_thread_exit_proc on %p,gc_thread=%p\n",
(void*)((GC_thread)arg)->id,arg);
#endif
LOCK();
DISABLE_CANCEL(cancel_state);
GC_wait_for_gc_completion(FALSE);
GC_unregister_my_thread_inner((GC_thread)arg);
RESTORE_CANCEL(cancel_state);
UNLOCK();
}
#if!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)
GC_API int WRAP_FUNC(pthread_join)(pthread_t thread,void**retval)
{
int result;
GC_thread t;
DCL_LOCK_STATE;
ASSERT_SYMS_INITIALIZED();
LOCK();
t=GC_lookup_thread(thread);
UNLOCK();
result=REAL_FUNC(pthread_join)(thread,retval);
#if defined(GC_FREEBSD_THREADS)
if (result==EINTR)result=0;
#endif
if (result==0){
LOCK();
if ((t->flags&FINISHED)!=0)
GC_delete_gc_thread(t);
UNLOCK();
}
return result;
}
GC_API int WRAP_FUNC(pthread_detach)(pthread_t thread)
{
int result;
GC_thread t;
DCL_LOCK_STATE;
ASSERT_SYMS_INITIALIZED();
LOCK();
t=GC_lookup_thread(thread);
UNLOCK();
result=REAL_FUNC(pthread_detach)(thread);
if (result==0){
LOCK();
t->flags|=DETACHED;
if ((t->flags&FINISHED)!=0){
GC_delete_gc_thread(t);
}
UNLOCK();
}
return result;
}
#endif
#ifndef GC_NO_PTHREAD_CANCEL
GC_API int WRAP_FUNC(pthread_cancel)(pthread_t thread)
{
#ifdef CANCEL_SAFE
GC_thread t;
DCL_LOCK_STATE;
#endif
INIT_REAL_SYMS();
#ifdef CANCEL_SAFE
LOCK();
t=GC_lookup_thread(thread);
if (t!=NULL&&(t->flags&DISABLED_GC)==0){
t->flags|=DISABLED_GC;
GC_dont_gc++;
}
UNLOCK();
#endif
return REAL_FUNC(pthread_cancel)(thread);
}
#endif
#ifdef GC_HAVE_PTHREAD_EXIT
GC_API GC_PTHREAD_EXIT_ATTRIBUTE void WRAP_FUNC(pthread_exit)(void*retval)
{
pthread_t self=pthread_self();
GC_thread me;
DCL_LOCK_STATE;
INIT_REAL_SYMS();
LOCK();
me=GC_lookup_thread(self);
if (me!=0&&(me->flags&DISABLED_GC)==0){
me->flags|=DISABLED_GC;
GC_dont_gc++;
}
UNLOCK();
REAL_FUNC(pthread_exit)(retval);
}
#endif
GC_INNER GC_bool GC_in_thread_creation=FALSE;
GC_INLINE void GC_record_stack_base(GC_thread me,
const struct GC_stack_base*sb)
{
#ifndef GC_DARWIN_THREADS
me->stop_info.stack_ptr=(ptr_t)sb->mem_base;
#endif
me->stack_end=(ptr_t)sb->mem_base;
if (me->stack_end==NULL)
ABORT("Bad stack base in GC_register_my_thread");
#ifdef IA64
me->backing_store_end=(ptr_t)sb->reg_base;
#endif
}
STATIC GC_thread GC_register_my_thread_inner(const struct GC_stack_base*sb,
pthread_t my_pthread)
{
GC_thread me;
GC_in_thread_creation=TRUE;
me=GC_new_thread(my_pthread);
GC_in_thread_creation=FALSE;
if (me==0)
ABORT("Failed to allocate memory for thread registering");
#ifdef GC_DARWIN_THREADS
me->stop_info.mach_thread=mach_thread_self();
#endif
GC_record_stack_base(me,sb);
#ifdef GC_EXPLICIT_SIGNALS_UNBLOCK
GC_unblock_gc_signals();
#endif
return me;
}
GC_API void GC_CALL GC_allow_register_threads(void)
{
GC_ASSERT(GC_lookup_thread(pthread_self())!=0);
set_need_to_lock();
}
GC_API int GC_CALL GC_register_my_thread(const struct GC_stack_base*sb)
{
pthread_t self=pthread_self();
GC_thread me;
DCL_LOCK_STATE;
if (GC_need_to_lock==FALSE)
ABORT("Threads explicit registering is not previously enabled");
LOCK();
me=GC_lookup_thread(self);
if (0==me){
me=GC_register_my_thread_inner(sb,self);
#if defined(CPPCHECK)
GC_noop1(me->flags);
#endif
me->flags|=DETACHED;
#if defined(THREAD_LOCAL_ALLOC)
GC_init_thread_local(&(me->tlfs));
#endif
UNLOCK();
return GC_SUCCESS;
} else if ((me->flags&FINISHED)!=0){
#ifdef GC_DARWIN_THREADS
me->stop_info.mach_thread=mach_thread_self();
#endif
GC_record_stack_base(me,sb);
me->flags&=~FINISHED;
#ifdef GC_EXPLICIT_SIGNALS_UNBLOCK
GC_unblock_gc_signals();
#endif
#if defined(THREAD_LOCAL_ALLOC)
GC_init_thread_local(&(me->tlfs));
#endif
UNLOCK();
return GC_SUCCESS;
} else {
UNLOCK();
return GC_DUPLICATE;
}
}
struct start_info {
void*(*start_routine)(void*);
void*arg;
word flags;
sem_t registered;
};
GC_INNER_PTHRSTART GC_thread GC_start_rtn_prepare_thread(
void*(**pstart)(void*),
void**pstart_arg,
struct GC_stack_base*sb,void*arg)
{
struct start_info*si=(struct start_info*)arg;
pthread_t self=pthread_self();
GC_thread me;
DCL_LOCK_STATE;
#ifdef DEBUG_THREADS
GC_log_printf("Starting thread %p,pid=%ld,sp=%p\n",
(void*)self,(long)getpid(),(void*)&arg);
#endif
LOCK();
me=GC_register_my_thread_inner(sb,self);
me->flags=si->flags;
#if defined(THREAD_LOCAL_ALLOC)
GC_init_thread_local(&(me->tlfs));
#endif
UNLOCK();
*pstart=si->start_routine;
#ifdef DEBUG_THREADS
GC_log_printf("start_routine=%p\n",(void*)(signed_word)(*pstart));
#endif
*pstart_arg=si->arg;
sem_post(&(si->registered));
return me;
}
#if!defined(SN_TARGET_ORBIS)&&!defined(SN_TARGET_PSP2)
STATIC void*GC_start_routine(void*arg)
{
#ifdef INCLUDE_LINUX_THREAD_DESCR
struct GC_stack_base sb;
#ifdef REDIRECT_MALLOC
GC_disable();
#endif
if (GC_get_stack_base(&sb)!=GC_SUCCESS)
ABORT("Failed to get thread stack base");
#ifdef REDIRECT_MALLOC
GC_enable();
#endif
return GC_inner_start_routine(&sb,arg);
#else
return GC_call_with_stack_base(GC_inner_start_routine,arg);
#endif
}
GC_API int WRAP_FUNC(pthread_create)(pthread_t*new_thread,
GC_PTHREAD_CREATE_CONST pthread_attr_t*attr,
void*(*start_routine)(void*),void*arg)
{
int result;
int detachstate;
word my_flags=0;
struct start_info si;
DCL_LOCK_STATE;
INIT_REAL_SYMS();
if (!EXPECT(parallel_initialized,TRUE))
GC_init_parallel();
if (sem_init(&si.registered,GC_SEM_INIT_PSHARED,0)!=0)
ABORT("sem_init failed");
si.start_routine=start_routine;
si.arg=arg;
LOCK();
if (!EXPECT(GC_thr_initialized,TRUE))
GC_thr_init();
#ifdef GC_ASSERTIONS
{
size_t stack_size=0;
if (NULL!=attr){
if (pthread_attr_getstacksize(attr,&stack_size)!=0)
ABORT("pthread_attr_getstacksize failed");
}
if (0==stack_size){
pthread_attr_t my_attr;
if (pthread_attr_init(&my_attr)!=0)
ABORT("pthread_attr_init failed");
if (pthread_attr_getstacksize(&my_attr,&stack_size)!=0)
ABORT("pthread_attr_getstacksize failed");
(void)pthread_attr_destroy(&my_attr);
}
if (0==stack_size){
#ifndef SOLARIS
WARN("Failed to get stack size for assertion checking\n",0);
#endif
stack_size=1000000;
}
GC_ASSERT(stack_size>=65536);
}
#endif
if (NULL==attr){
detachstate=PTHREAD_CREATE_JOINABLE;
} else {
pthread_attr_getdetachstate(attr,&detachstate);
}
if (PTHREAD_CREATE_DETACHED==detachstate)my_flags|=DETACHED;
si.flags=my_flags;
UNLOCK();
#ifdef DEBUG_THREADS
GC_log_printf("About to start new thread from thread %p\n",
(void*)pthread_self());
#endif
set_need_to_lock();
result=REAL_FUNC(pthread_create)(new_thread,attr,GC_start_routine,
&si);
if (0==result){
IF_CANCEL(int cancel_state;)
#ifdef DEBUG_THREADS
GC_log_printf("Started thread %p\n",(void*)(*new_thread));
#endif
DISABLE_CANCEL(cancel_state);
while (0!=sem_wait(&si.registered)){
#if defined(GC_HAIKU_THREADS)
if (EACCES==errno)continue;
#endif
if (EINTR!=errno)ABORT("sem_wait failed");
}
RESTORE_CANCEL(cancel_state);
}
sem_destroy(&si.registered);
return(result);
}
#endif
#if defined(USE_SPIN_LOCK)||!defined(NO_PTHREAD_TRYLOCK)
#define GC_PAUSE_SPIN_CYCLES 10
STATIC void GC_pause(void)
{
int i;
for (i=0;i < GC_PAUSE_SPIN_CYCLES;++i){
#if defined(AO_HAVE_compiler_barrier)&&!defined(BASE_ATOMIC_OPS_EMULATED)
AO_compiler_barrier();
#else
GC_noop1(i);
#endif
}
}
#endif
#ifndef SPIN_MAX
#define SPIN_MAX 128
#endif
GC_INNER volatile GC_bool GC_collecting=FALSE;
#if (!defined(USE_SPIN_LOCK)&&!defined(NO_PTHREAD_TRYLOCK))||defined(PARALLEL_MARK)
#ifdef LOCK_STATS
volatile AO_t GC_spin_count=0;
volatile AO_t GC_block_count=0;
volatile AO_t GC_unlocked_count=0;
#endif
STATIC void GC_generic_lock(pthread_mutex_t*lock)
{
#ifndef NO_PTHREAD_TRYLOCK
unsigned pause_length=1;
unsigned i;
if (0==pthread_mutex_trylock(lock)){
#ifdef LOCK_STATS
(void)AO_fetch_and_add1(&GC_unlocked_count);
#endif
return;
}
for (;pause_length<=SPIN_MAX;pause_length<<=1){
for (i=0;i < pause_length;++i){
GC_pause();
}
switch(pthread_mutex_trylock(lock)){
case 0:
#ifdef LOCK_STATS
(void)AO_fetch_and_add1(&GC_spin_count);
#endif
return;
case EBUSY:
break;
default:
ABORT("Unexpected error from pthread_mutex_trylock");
}
}
#endif
#ifdef LOCK_STATS
(void)AO_fetch_and_add1(&GC_block_count);
#endif
pthread_mutex_lock(lock);
}
#endif
#if defined(AO_HAVE_char_load)&&!defined(BASE_ATOMIC_OPS_EMULATED)
#define is_collecting()((GC_bool)AO_char_load((unsigned char*)&GC_collecting))
#else
#define is_collecting()GC_collecting
#endif
#if defined(USE_SPIN_LOCK)
GC_INNER volatile AO_TS_t GC_allocate_lock=AO_TS_INITIALIZER;
#define low_spin_max 30
#define high_spin_max SPIN_MAX
static volatile AO_t spin_max=low_spin_max;
static volatile AO_t last_spins=0;
GC_INNER void GC_lock(void)
{
unsigned my_spin_max;
unsigned my_last_spins;
unsigned i;
if (AO_test_and_set_acquire(&GC_allocate_lock)==AO_TS_CLEAR){
return;
}
my_spin_max=(unsigned)AO_load(&spin_max);
my_last_spins=(unsigned)AO_load(&last_spins);
for (i=0;i < my_spin_max;i++){
if (is_collecting()||GC_nprocs==1)
goto yield;
if (i < my_last_spins/2){
GC_pause();
continue;
}
if (AO_test_and_set_acquire(&GC_allocate_lock)==AO_TS_CLEAR){
AO_store(&last_spins,(AO_t)i);
AO_store(&spin_max,(AO_t)high_spin_max);
return;
}
}
AO_store(&spin_max,(AO_t)low_spin_max);
yield:
for (i=0;;++i){
if (AO_test_and_set_acquire(&GC_allocate_lock)==AO_TS_CLEAR){
return;
}
#define SLEEP_THRESHOLD 12
if (i < SLEEP_THRESHOLD){
sched_yield();
} else {
struct timespec ts;
if (i > 24)i=24;
ts.tv_sec=0;
ts.tv_nsec=1<<i;
nanosleep(&ts,0);
}
}
}
#elif defined(USE_PTHREAD_LOCKS)
#ifndef NO_PTHREAD_TRYLOCK
GC_INNER void GC_lock(void)
{
if (1==GC_nprocs||is_collecting()){
pthread_mutex_lock(&GC_allocate_ml);
} else {
GC_generic_lock(&GC_allocate_ml);
}
}
#elif defined(GC_ASSERTIONS)
GC_INNER void GC_lock(void)
{
pthread_mutex_lock(&GC_allocate_ml);
}
#endif
#endif
#ifdef PARALLEL_MARK
#ifdef GC_ASSERTIONS
STATIC unsigned long GC_mark_lock_holder=NO_THREAD;
#define SET_MARK_LOCK_HOLDER (void)(GC_mark_lock_holder=NUMERIC_THREAD_ID(pthread_self()))
#define UNSET_MARK_LOCK_HOLDER do { GC_ASSERT(GC_mark_lock_holder==NUMERIC_THREAD_ID(pthread_self()));GC_mark_lock_holder=NO_THREAD;} while (0)
#else
#define SET_MARK_LOCK_HOLDER (void)0
#define UNSET_MARK_LOCK_HOLDER (void)0
#endif
#ifdef GLIBC_2_1_MUTEX_HACK
static pthread_mutex_t mark_mutex=
{0,0,0,PTHREAD_MUTEX_ERRORCHECK_NP,{0,0}};
#else
static pthread_mutex_t mark_mutex=PTHREAD_MUTEX_INITIALIZER;
#endif
static pthread_cond_t builder_cv=PTHREAD_COND_INITIALIZER;
#ifdef GLIBC_2_19_TSX_BUG
static int parse_version(int*pminor,const char*pverstr){
char*endp;
unsigned long value=strtoul(pverstr,&endp,10);
int major=(int)value;
if (major < 0||(char*)pverstr==endp||(unsigned)major!=value){
return -1;
}
if (*endp!='.'){
*pminor=-1;
} else {
value=strtoul(endp+1,&endp,10);
*pminor=(int)value;
if (*pminor < 0||(unsigned)(*pminor)!=value){
return -1;
}
}
return major;
}
#endif
static void setup_mark_lock(void)
{
#ifdef GLIBC_2_19_TSX_BUG
pthread_mutexattr_t mattr;
int glibc_minor=-1;
int glibc_major=parse_version(&glibc_minor,gnu_get_libc_version());
if (glibc_major > 2||(glibc_major==2&&glibc_minor>=19)){
if (0!=pthread_mutexattr_init(&mattr)){
ABORT("pthread_mutexattr_init failed");
}
if (0!=pthread_mutexattr_settype(&mattr,PTHREAD_MUTEX_NORMAL)){
ABORT("pthread_mutexattr_settype failed");
}
if (0!=pthread_mutex_init(&mark_mutex,&mattr)){
ABORT("pthread_mutex_init failed");
}
(void)pthread_mutexattr_destroy(&mattr);
}
#endif
}
GC_INNER void GC_acquire_mark_lock(void)
{
#if defined(NUMERIC_THREAD_ID_UNIQUE)&&!defined(THREAD_SANITIZER)
GC_ASSERT(GC_mark_lock_holder!=NUMERIC_THREAD_ID(pthread_self()));
#endif
GC_generic_lock(&mark_mutex);
SET_MARK_LOCK_HOLDER;
}
GC_INNER void GC_release_mark_lock(void)
{
UNSET_MARK_LOCK_HOLDER;
if (pthread_mutex_unlock(&mark_mutex)!=0){
ABORT("pthread_mutex_unlock failed");
}
}
STATIC void GC_wait_builder(void)
{
ASSERT_CANCEL_DISABLED();
UNSET_MARK_LOCK_HOLDER;
if (pthread_cond_wait(&builder_cv,&mark_mutex)!=0){
ABORT("pthread_cond_wait failed");
}
GC_ASSERT(GC_mark_lock_holder==NO_THREAD);
SET_MARK_LOCK_HOLDER;
}
GC_INNER void GC_wait_for_reclaim(void)
{
GC_acquire_mark_lock();
while (GC_fl_builder_count > 0){
GC_wait_builder();
}
GC_release_mark_lock();
}
GC_INNER void GC_notify_all_builder(void)
{
GC_ASSERT(GC_mark_lock_holder==NUMERIC_THREAD_ID(pthread_self()));
if (pthread_cond_broadcast(&builder_cv)!=0){
ABORT("pthread_cond_broadcast failed");
}
}
GC_INNER void GC_wait_marker(void)
{
ASSERT_CANCEL_DISABLED();
GC_ASSERT(GC_parallel);
UNSET_MARK_LOCK_HOLDER;
if (pthread_cond_wait(&mark_cv,&mark_mutex)!=0){
ABORT("pthread_cond_wait failed");
}
GC_ASSERT(GC_mark_lock_holder==NO_THREAD);
SET_MARK_LOCK_HOLDER;
}
GC_INNER void GC_notify_all_marker(void)
{
GC_ASSERT(GC_parallel);
if (pthread_cond_broadcast(&mark_cv)!=0){
ABORT("pthread_cond_broadcast failed");
}
}
#endif
#ifdef PTHREAD_REGISTER_CANCEL_WEAK_STUBS
EXTERN_C_BEGIN
extern void __pthread_register_cancel(void)__attribute__((__weak__));
extern void __pthread_unregister_cancel(void)__attribute__((__weak__));
EXTERN_C_END
void __pthread_register_cancel(void){}
void __pthread_unregister_cancel(void){}
#endif
#endif
#if defined(USE_CUSTOM_SPECIFIC)
static const tse invalid_tse={INVALID_QTID,0,0,INVALID_THREADID};
GC_INNER int GC_key_create_inner(tsd**key_ptr)
{
int i;
int ret;
tsd*result;
GC_ASSERT(I_HOLD_LOCK());
GC_ASSERT((word)(&invalid_tse.next)% sizeof(tse*)==0);
result=(tsd*)MALLOC_CLEAR(sizeof(tsd));
if (NULL==result)return ENOMEM;
ret=pthread_mutex_init(&result->lock,NULL);
if (ret!=0)return ret;
for (i=0;i < TS_CACHE_SIZE;++i){
result->cache[i]=( tse*)&invalid_tse;
}
#ifdef GC_ASSERTIONS
for (i=0;i < TS_HASH_SIZE;++i){
GC_ASSERT(result->hash[i].p==0);
}
#endif
*key_ptr=result;
return 0;
}
GC_INNER int GC_setspecific(tsd*key,void*value)
{
pthread_t self=pthread_self();
unsigned hash_val=HASH(self);
volatile tse*entry;
GC_ASSERT(I_HOLD_LOCK());
GC_ASSERT(self!=INVALID_THREADID);
GC_dont_gc++;
entry=(volatile tse*)MALLOC_CLEAR(sizeof(tse));
GC_dont_gc--;
if (0==entry)return ENOMEM;
pthread_mutex_lock(&(key->lock));
entry->next=key->hash[hash_val].p;
entry->thread=self;
entry->value=TS_HIDE_VALUE(value);
GC_ASSERT(entry->qtid==INVALID_QTID);
AO_store_release(&key->hash[hash_val].ao,(AO_t)entry);
GC_dirty(( void*)entry);
GC_dirty(key->hash+hash_val);
if (pthread_mutex_unlock(&key->lock)!=0)
ABORT("pthread_mutex_unlock failed (setspecific)");
return 0;
}
GC_INNER void GC_remove_specific_after_fork(tsd*key,pthread_t t)
{
unsigned hash_val=HASH(t);
tse*entry;
tse*prev=NULL;
#ifdef CAN_HANDLE_FORK
GC_ASSERT(I_HOLD_LOCK());
#endif
pthread_mutex_lock(&(key->lock));
entry=key->hash[hash_val].p;
while (entry!=NULL&&!THREAD_EQUAL(entry->thread,t)){
prev=entry;
entry=entry->next;
}
if (entry!=NULL){
entry->qtid=INVALID_QTID;
if (NULL==prev){
key->hash[hash_val].p=entry->next;
GC_dirty(key->hash+hash_val);
} else {
prev->next=entry->next;
GC_dirty(prev);
}
}
#ifdef LINT2
GC_noop1((word)entry);
#endif
if (pthread_mutex_unlock(&key->lock)!=0)
ABORT("pthread_mutex_unlock failed (remove_specific after fork)");
}
GC_INNER void*GC_slow_getspecific(tsd*key,word qtid,
tse*volatile*cache_ptr)
{
pthread_t self=pthread_self();
tse*entry=key->hash[HASH(self)].p;
GC_ASSERT(qtid!=INVALID_QTID);
while (entry!=NULL&&!THREAD_EQUAL(entry->thread,self)){
entry=entry->next;
}
if (entry==NULL)return NULL;
entry->qtid=(AO_t)qtid;
*cache_ptr=entry;
return TS_REVEAL_PTR(entry->value);
}
#ifdef GC_ASSERTIONS
void GC_check_tsd_marks(tsd*key)
{
int i;
tse*p;
if (!GC_is_marked(GC_base(key))){
ABORT("Unmarked thread-specific-data table");
}
for (i=0;i < TS_HASH_SIZE;++i){
for (p=key->hash[i].p;p!=0;p=p->next){
if (!GC_is_marked(GC_base(p))){
ABORT_ARG1("Unmarked thread-specific-data entry",
" at %p",(void*)p);
}
}
}
for (i=0;i < TS_CACHE_SIZE;++i){
p=key->cache[i];
if (p!=&invalid_tse&&!GC_is_marked(GC_base(p))){
ABORT_ARG1("Unmarked cached thread-specific-data entry",
" at %p",(void*)p);
}
}
}
#endif
#endif
#if defined(GC_WIN32_THREADS)
#ifdef THREAD_LOCAL_ALLOC
#endif
#if!defined(USE_PTHREAD_LOCKS)
GC_INNER CRITICAL_SECTION GC_allocate_ml;
#ifdef GC_ASSERTIONS
GC_INNER DWORD GC_lock_holder=NO_THREAD;
#endif
#else
GC_INNER pthread_mutex_t GC_allocate_ml=PTHREAD_MUTEX_INITIALIZER;
#ifdef GC_ASSERTIONS
GC_INNER unsigned long GC_lock_holder=NO_THREAD;
#endif
#endif
#undef CreateThread
#undef ExitThread
#undef _beginthreadex
#undef _endthreadex
#ifdef GC_PTHREADS
#include <errno.h>
#undef pthread_create
#undef pthread_join
#undef pthread_detach
#ifndef GC_NO_PTHREAD_SIGMASK
#undef pthread_sigmask
#endif
STATIC void*GC_pthread_start(void*arg);
STATIC void GC_thread_exit_proc(void*arg);
#include <pthread.h>
#ifdef CAN_CALL_ATFORK
#include <unistd.h>
#endif
#elif!defined(MSWINCE)
#include <process.h>
#include <errno.h>
#endif
static ptr_t copy_ptr_regs(word*regs,const CONTEXT*pcontext);
#if defined(I386)
#ifdef WOW64_THREAD_CONTEXT_WORKAROUND
#define PUSHED_REGS_COUNT 9
#else
#define PUSHED_REGS_COUNT 7
#endif
#elif defined(X86_64)||defined(SHx)
#define PUSHED_REGS_COUNT 15
#elif defined(ARM32)
#define PUSHED_REGS_COUNT 13
#elif defined(AARCH64)
#define PUSHED_REGS_COUNT 30
#elif defined(MIPS)||defined(ALPHA)
#define PUSHED_REGS_COUNT 28
#elif defined(PPC)
#define PUSHED_REGS_COUNT 29
#endif
#if (defined(GC_DLL)||defined(GC_INSIDE_DLL))&&!defined(NO_CRT)&&!defined(GC_NO_THREADS_DISCOVERY)&&!defined(MSWINCE)&&!defined(THREAD_LOCAL_ALLOC)&&!defined(GC_PTHREADS)
#ifdef GC_DISCOVER_TASK_THREADS
#define GC_win32_dll_threads TRUE
#else
STATIC GC_bool GC_win32_dll_threads=FALSE;
#endif
#else
#ifndef GC_NO_THREADS_DISCOVERY
#define GC_NO_THREADS_DISCOVERY
#endif
#define GC_win32_dll_threads FALSE
#undef MAX_THREADS
#define MAX_THREADS 1
#endif
typedef LONG*IE_t;
STATIC GC_bool GC_thr_initialized=FALSE;
#ifndef GC_ALWAYS_MULTITHREADED
GC_INNER GC_bool GC_need_to_lock=FALSE;
#endif
static GC_bool parallel_initialized=FALSE;
GC_API void GC_CALL GC_use_threads_discovery(void)
{
#ifdef GC_NO_THREADS_DISCOVERY
ABORT("GC DllMain-based thread registration unsupported");
#else
GC_ASSERT(!parallel_initialized);
#ifndef GC_DISCOVER_TASK_THREADS
GC_win32_dll_threads=TRUE;
#endif
GC_init_parallel();
#endif
}
#define ADDR_LIMIT ((ptr_t)GC_WORD_MAX)
struct GC_Thread_Rep {
union {
#ifndef GC_NO_THREADS_DISCOVERY
volatile AO_t in_use;
LONG long_in_use;
#endif
struct GC_Thread_Rep*next;
} tm;
DWORD id;
#ifdef MSWINCE
#define THREAD_HANDLE(t)(HANDLE)(word)(t)->id
#else
HANDLE handle;
#define THREAD_HANDLE(t)(t)->handle
#endif
ptr_t stack_base;
ptr_t last_stack_min;
#ifdef IA64
ptr_t backing_store_end;
ptr_t backing_store_ptr;
#elif defined(I386)
ptr_t initial_stack_base;
#endif
ptr_t thread_blocked_sp;
struct GC_traced_stack_sect_s*traced_stack_sect;
unsigned short finalizer_skipped;
unsigned char finalizer_nested;
unsigned char suspended;
#ifdef GC_PTHREADS
unsigned char flags;
#define FINISHED 1
#define DETACHED 2
#define KNOWN_FINISHED(t)(((t)->flags)&FINISHED)
pthread_t pthread_id;
void*status;
#else
#define KNOWN_FINISHED(t)0
#endif
#ifdef THREAD_LOCAL_ALLOC
struct thread_local_freelists tlfs;
#endif
#ifdef RETRY_GET_THREAD_CONTEXT
ptr_t context_sp;
word context_regs[PUSHED_REGS_COUNT];
#endif
};
typedef struct GC_Thread_Rep*GC_thread;
typedef volatile struct GC_Thread_Rep*GC_vthread;
#ifndef GC_NO_THREADS_DISCOVERY
STATIC DWORD GC_main_thread=0;
STATIC volatile AO_t GC_attached_thread=FALSE;
STATIC volatile GC_bool GC_please_stop=FALSE;
#elif defined(GC_ASSERTIONS)
STATIC GC_bool GC_please_stop=FALSE;
#endif
#if defined(WRAP_MARK_SOME)&&!defined(GC_PTHREADS)
GC_INNER GC_bool GC_started_thread_while_stopped(void)
{
#ifndef GC_NO_THREADS_DISCOVERY
if (GC_win32_dll_threads){
#ifdef AO_HAVE_compare_and_swap_release
if (AO_compare_and_swap_release(&GC_attached_thread,TRUE,
FALSE))
return TRUE;
#else
AO_nop_full();
if (AO_load(&GC_attached_thread)){
AO_store(&GC_attached_thread,FALSE);
return TRUE;
}
#endif
}
#endif
return FALSE;
}
#endif
#ifndef MAX_THREADS
#define MAX_THREADS 512
#endif
volatile struct GC_Thread_Rep dll_thread_table[MAX_THREADS];
STATIC volatile LONG GC_max_thread_index=0;
#ifndef THREAD_TABLE_SZ
#define THREAD_TABLE_SZ 256
#endif
#define THREAD_TABLE_INDEX(id)(int)((((id)>>8)^(id))% THREAD_TABLE_SZ)
STATIC GC_thread GC_threads[THREAD_TABLE_SZ];
static struct GC_Thread_Rep first_thread;
static GC_bool first_thread_used=FALSE;
STATIC GC_thread GC_new_thread(DWORD id)
{
int hv=THREAD_TABLE_INDEX(id);
GC_thread result;
#ifdef DEBUG_THREADS
GC_log_printf("Creating thread 0x%lx\n",(long)id);
if (GC_threads[hv]!=NULL)
GC_log_printf("Hash collision at GC_threads[%d]\n",hv);
#endif
GC_ASSERT(I_HOLD_LOCK());
if (!EXPECT(first_thread_used,TRUE)){
result=&first_thread;
first_thread_used=TRUE;
GC_ASSERT(NULL==GC_threads[hv]);
} else {
GC_ASSERT(!GC_win32_dll_threads);
result=(struct GC_Thread_Rep*)
GC_INTERNAL_MALLOC(sizeof(struct GC_Thread_Rep),NORMAL);
if (result==0)return(0);
}
result->tm.next=GC_threads[hv];
GC_threads[hv]=result;
#ifdef GC_PTHREADS
GC_ASSERT(result->flags==0);
#endif
GC_ASSERT(result->thread_blocked_sp==NULL);
if (EXPECT(result!=&first_thread,TRUE))
GC_dirty(result);
return(result);
}
GC_INNER GC_bool GC_in_thread_creation=FALSE;
GC_INLINE void GC_record_stack_base(GC_vthread me,
const struct GC_stack_base*sb)
{
me->stack_base=(ptr_t)sb->mem_base;
#ifdef IA64
me->backing_store_end=(ptr_t)sb->reg_base;
#elif defined(I386)
me->initial_stack_base=(ptr_t)sb->mem_base;
#endif
if (me->stack_base==NULL)
ABORT("Bad stack base in GC_register_my_thread");
}
STATIC GC_thread GC_register_my_thread_inner(const struct GC_stack_base*sb,
DWORD thread_id)
{
GC_vthread me;
#if defined(MPROTECT_VDB)&&!defined(CYGWIN32)
if (GC_auto_incremental
#ifdef GWW_VDB
&&!GC_gww_dirty_init()
#endif
)
GC_set_write_fault_handler();
#endif
#ifndef GC_NO_THREADS_DISCOVERY
if (GC_win32_dll_threads){
int i;
for (i=0;
InterlockedExchange(&dll_thread_table[i].tm.long_in_use,1)!=0;
i++){
if (i==MAX_THREADS - 1)
ABORT("Too many threads");
}
while (i > GC_max_thread_index){
InterlockedIncrement((IE_t)&GC_max_thread_index);
}
if (GC_max_thread_index>=MAX_THREADS){
GC_max_thread_index=MAX_THREADS - 1;
}
me=dll_thread_table+i;
} else
#endif
{
GC_ASSERT(I_HOLD_LOCK());
GC_in_thread_creation=TRUE;
me=GC_new_thread(thread_id);
GC_in_thread_creation=FALSE;
if (me==0)
ABORT("Failed to allocate memory for thread registering");
}
#ifdef GC_PTHREADS
me->pthread_id=pthread_self();
#endif
#ifndef MSWINCE
if (!DuplicateHandle(GetCurrentProcess(),GetCurrentThread(),
GetCurrentProcess(),
(HANDLE*)&(me->handle),
0,FALSE,
DUPLICATE_SAME_ACCESS)){
ABORT_ARG1("DuplicateHandle failed",
":errcode=0x%X",(unsigned)GetLastError());
}
#endif
me->last_stack_min=ADDR_LIMIT;
GC_record_stack_base(me,sb);
me->id=thread_id;
#if defined(THREAD_LOCAL_ALLOC)
GC_init_thread_local((GC_tlfs)(&(me->tlfs)));
#endif
#ifndef GC_NO_THREADS_DISCOVERY
if (GC_win32_dll_threads){
if (GC_please_stop){
AO_store(&GC_attached_thread,TRUE);
AO_nop_full();
}
} else
#endif
{
GC_ASSERT(!GC_please_stop);
}
return (GC_thread)(me);
}
GC_INLINE LONG GC_get_max_thread_index(void)
{
LONG my_max=GC_max_thread_index;
if (my_max>=MAX_THREADS)return MAX_THREADS - 1;
return my_max;
}
STATIC GC_thread GC_lookup_thread_inner(DWORD thread_id)
{
#ifndef GC_NO_THREADS_DISCOVERY
if (GC_win32_dll_threads){
int i;
LONG my_max=GC_get_max_thread_index();
for (i=0;i<=my_max&&
(!AO_load_acquire(&dll_thread_table[i].tm.in_use)
||dll_thread_table[i].id!=thread_id);
i++){
}
return i<=my_max?(GC_thread)(dll_thread_table+i):NULL;
} else
#endif
{
GC_thread p=GC_threads[THREAD_TABLE_INDEX(thread_id)];
GC_ASSERT(I_HOLD_LOCK());
while (p!=0&&p->id!=thread_id)p=p->tm.next;
return(p);
}
}
#ifdef LINT2
#define CHECK_LOOKUP_MY_THREAD(me)if (!(me))ABORT("GC_lookup_thread_inner(GetCurrentThreadId)failed")
#else
#define CHECK_LOOKUP_MY_THREAD(me)
#endif
GC_INNER void GC_reset_finalizer_nested(void)
{
GC_thread me=GC_lookup_thread_inner(GetCurrentThreadId());
CHECK_LOOKUP_MY_THREAD(me);
me->finalizer_nested=0;
}
GC_INNER unsigned char*GC_check_finalizer_nested(void)
{
GC_thread me=GC_lookup_thread_inner(GetCurrentThreadId());
unsigned nesting_level;
CHECK_LOOKUP_MY_THREAD(me);
nesting_level=me->finalizer_nested;
if (nesting_level){
if (++me->finalizer_skipped < (1U<<nesting_level))return NULL;
me->finalizer_skipped=0;
}
me->finalizer_nested=(unsigned char)(nesting_level+1);
return&me->finalizer_nested;
}
#if defined(GC_ASSERTIONS)&&defined(THREAD_LOCAL_ALLOC)
GC_bool GC_is_thread_tsd_valid(void*tsd)
{
GC_thread me;
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread_inner(GetCurrentThreadId());
UNLOCK();
return (word)tsd>=(word)(&me->tlfs)
&&(word)tsd < (word)(&me->tlfs)+sizeof(me->tlfs);
}
#endif
GC_API int GC_CALL GC_thread_is_registered(void)
{
DWORD thread_id=GetCurrentThreadId();
GC_thread me;
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread_inner(thread_id);
UNLOCK();
return me!=NULL;
}
GC_API void GC_CALL GC_register_altstack(void*stack GC_ATTR_UNUSED,
GC_word stack_size GC_ATTR_UNUSED,
void*altstack GC_ATTR_UNUSED,
GC_word altstack_size GC_ATTR_UNUSED)
{
}
#if defined(MPROTECT_VDB)
#define UNPROTECT_THREAD(t)if (!GC_win32_dll_threads&&GC_auto_incremental&&t!=&first_thread){ GC_ASSERT(SMALL_OBJ(GC_size(t)));GC_remove_protection(HBLKPTR(t),1,FALSE);} else (void)0
#else
#define UNPROTECT_THREAD(t)(void)0
#endif
#ifdef CYGWIN32
#define GC_PTHREAD_PTRVAL(pthread_id)pthread_id
#elif defined(GC_WIN32_PTHREADS)||defined(GC_PTHREADS_PARAMARK)
#include <pthread.h>
#if defined(__WINPTHREADS_VERSION_MAJOR)
#define GC_PTHREAD_PTRVAL(pthread_id)pthread_id
#else
#define GC_PTHREAD_PTRVAL(pthread_id)pthread_id.p
#endif
#endif
STATIC void GC_delete_gc_thread_no_free(GC_vthread t)
{
#ifndef MSWINCE
CloseHandle(t->handle);
#endif
#ifndef GC_NO_THREADS_DISCOVERY
if (GC_win32_dll_threads){
t->stack_base=0;
t->id=0;
t->suspended=FALSE;
#ifdef RETRY_GET_THREAD_CONTEXT
t->context_sp=NULL;
#endif
AO_store_release(&t->tm.in_use,FALSE);
} else
#endif
{
DWORD id=((GC_thread)t)->id;
int hv=THREAD_TABLE_INDEX(id);
GC_thread p=GC_threads[hv];
GC_thread prev=NULL;
GC_ASSERT(I_HOLD_LOCK());
while (p!=(GC_thread)t){
prev=p;
p=p->tm.next;
}
if (prev==0){
GC_threads[hv]=p->tm.next;
} else {
GC_ASSERT(prev!=&first_thread);
prev->tm.next=p->tm.next;
GC_dirty(prev);
}
}
}
STATIC void GC_delete_thread(DWORD id)
{
if (GC_win32_dll_threads){
GC_vthread t=GC_lookup_thread_inner(id);
if (0==t){
WARN("Removing nonexistent thread,id=%" WARN_PRIdPTR "\n",id);
} else {
GC_delete_gc_thread_no_free(t);
}
} else {
int hv=THREAD_TABLE_INDEX(id);
GC_thread p=GC_threads[hv];
GC_thread prev=NULL;
GC_ASSERT(I_HOLD_LOCK());
while (p->id!=id){
prev=p;
p=p->tm.next;
}
#ifndef MSWINCE
CloseHandle(p->handle);
#endif
if (prev==0){
GC_threads[hv]=p->tm.next;
} else {
GC_ASSERT(prev!=&first_thread);
prev->tm.next=p->tm.next;
GC_dirty(prev);
}
if (EXPECT(p!=&first_thread,TRUE)){
GC_INTERNAL_FREE(p);
}
}
}
GC_API void GC_CALL GC_allow_register_threads(void)
{
GC_ASSERT(GC_lookup_thread_inner(GetCurrentThreadId())!=0);
#if!defined(GC_ALWAYS_MULTITHREADED)&&!defined(PARALLEL_MARK)&&!defined(GC_NO_THREADS_DISCOVERY)
parallel_initialized=TRUE;
#endif
set_need_to_lock();
}
GC_API int GC_CALL GC_register_my_thread(const struct GC_stack_base*sb)
{
GC_thread me;
DWORD thread_id=GetCurrentThreadId();
DCL_LOCK_STATE;
if (GC_need_to_lock==FALSE)
ABORT("Threads explicit registering is not previously enabled");
LOCK();
me=GC_lookup_thread_inner(thread_id);
if (me==0){
#ifdef GC_PTHREADS
me=GC_register_my_thread_inner(sb,thread_id);
#if defined(CPPCHECK)
GC_noop1(me->flags);
#endif
me->flags|=DETACHED;
#else
GC_register_my_thread_inner(sb,thread_id);
#endif
UNLOCK();
return GC_SUCCESS;
} else
#ifdef GC_PTHREADS
if ((me->flags&FINISHED)!=0){
GC_record_stack_base(me,sb);
me->flags&=~FINISHED;
#ifdef THREAD_LOCAL_ALLOC
GC_init_thread_local((GC_tlfs)(&me->tlfs));
#endif
UNLOCK();
return GC_SUCCESS;
} else
#endif
{
UNLOCK();
return GC_DUPLICATE;
}
}
STATIC void GC_wait_for_gc_completion(GC_bool wait_for_all)
{
GC_ASSERT(I_HOLD_LOCK());
if (GC_incremental&&GC_collection_in_progress()){
word old_gc_no=GC_gc_no;
do {
ENTER_GC();
GC_in_thread_creation=TRUE;
GC_collect_a_little_inner(1);
GC_in_thread_creation=FALSE;
EXIT_GC();
UNLOCK();
Sleep(0);
LOCK();
} while (GC_incremental&&GC_collection_in_progress()
&&(wait_for_all||old_gc_no==GC_gc_no));
}
}
GC_API int GC_CALL GC_unregister_my_thread(void)
{
DCL_LOCK_STATE;
#ifdef DEBUG_THREADS
GC_log_printf("Unregistering thread 0x%lx\n",(long)GetCurrentThreadId());
#endif
if (GC_win32_dll_threads){
#if defined(THREAD_LOCAL_ALLOC)
GC_ASSERT(FALSE);
#else
GC_delete_thread(GetCurrentThreadId());
#endif
} else {
#if defined(THREAD_LOCAL_ALLOC)||defined(GC_PTHREADS)
GC_thread me;
#endif
DWORD thread_id=GetCurrentThreadId();
LOCK();
GC_wait_for_gc_completion(FALSE);
#if defined(THREAD_LOCAL_ALLOC)||defined(GC_PTHREADS)
me=GC_lookup_thread_inner(thread_id);
CHECK_LOOKUP_MY_THREAD(me);
GC_ASSERT(!KNOWN_FINISHED(me));
#endif
#if defined(THREAD_LOCAL_ALLOC)
GC_ASSERT(GC_getspecific(GC_thread_key)==&me->tlfs);
GC_destroy_thread_local(&(me->tlfs));
#endif
#ifdef GC_PTHREADS
if ((me->flags&DETACHED)==0){
me->flags|=FINISHED;
} else
#endif
{
GC_delete_thread(thread_id);
}
#if defined(THREAD_LOCAL_ALLOC)
GC_remove_specific(GC_thread_key);
#endif
UNLOCK();
}
return GC_SUCCESS;
}
GC_INNER void GC_do_blocking_inner(ptr_t data,void*context GC_ATTR_UNUSED)
{
struct blocking_data*d=(struct blocking_data*)data;
DWORD thread_id=GetCurrentThreadId();
GC_thread me;
#ifdef IA64
ptr_t stack_ptr=GC_save_regs_in_stack();
#endif
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread_inner(thread_id);
CHECK_LOOKUP_MY_THREAD(me);
GC_ASSERT(me->thread_blocked_sp==NULL);
#ifdef IA64
me->backing_store_ptr=stack_ptr;
#endif
me->thread_blocked_sp=(ptr_t)&d;
UNLOCK();
d->client_data=(d->fn)(d->client_data);
LOCK();
#if defined(CPPCHECK)
GC_noop1((word)me->thread_blocked_sp);
#endif
me->thread_blocked_sp=NULL;
UNLOCK();
}
GC_API void*GC_CALL GC_call_with_gc_active(GC_fn_type fn,
void*client_data)
{
struct GC_traced_stack_sect_s stacksect;
DWORD thread_id=GetCurrentThreadId();
GC_thread me;
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread_inner(thread_id);
CHECK_LOOKUP_MY_THREAD(me);
GC_ASSERT(me->stack_base!=NULL);
if ((word)me->stack_base < (word)(&stacksect)){
me->stack_base=(ptr_t)(&stacksect);
#if defined(I386)
me->initial_stack_base=me->stack_base;
#endif
}
if (me->thread_blocked_sp==NULL){
UNLOCK();
client_data=fn(client_data);
GC_noop1(COVERT_DATAFLOW(&stacksect));
return client_data;
}
stacksect.saved_stack_ptr=me->thread_blocked_sp;
#ifdef IA64
stacksect.backing_store_end=GC_save_regs_in_stack();
stacksect.saved_backing_store_ptr=me->backing_store_ptr;
#endif
stacksect.prev=me->traced_stack_sect;
me->thread_blocked_sp=NULL;
me->traced_stack_sect=&stacksect;
UNLOCK();
client_data=fn(client_data);
GC_ASSERT(me->thread_blocked_sp==NULL);
GC_ASSERT(me->traced_stack_sect==&stacksect);
LOCK();
#if defined(CPPCHECK)
GC_noop1((word)me->traced_stack_sect);
#endif
me->traced_stack_sect=stacksect.prev;
#ifdef IA64
me->backing_store_ptr=stacksect.saved_backing_store_ptr;
#endif
me->thread_blocked_sp=stacksect.saved_stack_ptr;
UNLOCK();
return client_data;
}
GC_API void GC_CALL GC_set_stackbottom(void*gc_thread_handle,
const struct GC_stack_base*sb)
{
GC_thread t=(GC_thread)gc_thread_handle;
GC_ASSERT(sb->mem_base!=NULL);
if (!EXPECT(GC_is_initialized,TRUE)){
GC_ASSERT(NULL==t);
GC_stackbottom=(char*)sb->mem_base;
#ifdef IA64
GC_register_stackbottom=(ptr_t)sb->reg_base;
#endif
return;
}
GC_ASSERT(I_HOLD_LOCK());
if (NULL==t){
t=GC_lookup_thread_inner(GetCurrentThreadId());
CHECK_LOOKUP_MY_THREAD(t);
}
GC_ASSERT(!KNOWN_FINISHED(t));
GC_ASSERT(NULL==t->thread_blocked_sp
&&NULL==t->traced_stack_sect);
t->stack_base=(ptr_t)sb->mem_base;
t->last_stack_min=ADDR_LIMIT;
#ifdef IA64
t->backing_store_end=(ptr_t)sb->reg_base;
#endif
}
GC_API void*GC_CALL GC_get_my_stackbottom(struct GC_stack_base*sb)
{
DWORD thread_id=GetCurrentThreadId();
GC_thread me;
DCL_LOCK_STATE;
LOCK();
me=GC_lookup_thread_inner(thread_id);
CHECK_LOOKUP_MY_THREAD(me);
sb->mem_base=me->stack_base;
#ifdef IA64
sb->reg_base=me->backing_store_end;
#endif
UNLOCK();
return (void*)me;
}
#ifdef GC_PTHREADS
#define PTHREAD_MAP_SIZE 512
DWORD GC_pthread_map_cache[PTHREAD_MAP_SIZE]={0};
#define PTHREAD_MAP_INDEX(pthread_id)((NUMERIC_THREAD_ID(pthread_id)>>5)% PTHREAD_MAP_SIZE)
#define SET_PTHREAD_MAP_CACHE(pthread_id,win32_id)(void)(GC_pthread_map_cache[PTHREAD_MAP_INDEX(pthread_id)]=(win32_id))
#define GET_PTHREAD_MAP_CACHE(pthread_id)GC_pthread_map_cache[PTHREAD_MAP_INDEX(pthread_id)]
STATIC GC_thread GC_lookup_pthread(pthread_t id)
{
#ifndef GC_NO_THREADS_DISCOVERY
if (GC_win32_dll_threads){
int i;
LONG my_max=GC_get_max_thread_index();
for (i=0;i<=my_max&&
(!AO_load_acquire(&dll_thread_table[i].tm.in_use)
||THREAD_EQUAL(dll_thread_table[i].pthread_id,id));
i++){
}
return i<=my_max?(GC_thread)(dll_thread_table+i):NULL;
} else
#endif
{
DWORD win32_id=GET_PTHREAD_MAP_CACHE(id);
int hv_guess=THREAD_TABLE_INDEX(win32_id);
int hv;
GC_thread p;
DCL_LOCK_STATE;
LOCK();
for (p=GC_threads[hv_guess];0!=p;p=p->tm.next){
if (THREAD_EQUAL(p->pthread_id,id))
goto foundit;
}
for (hv=0;hv < THREAD_TABLE_SZ;++hv){
for (p=GC_threads[hv];0!=p;p=p->tm.next){
if (THREAD_EQUAL(p->pthread_id,id))
goto foundit;
}
}
p=0;
foundit:
UNLOCK();
return p;
}
}
#endif
#ifdef CAN_HANDLE_FORK
STATIC void GC_remove_all_threads_but_me(void)
{
int hv;
GC_thread me=NULL;
DWORD thread_id;
pthread_t pthread_id=pthread_self();
GC_ASSERT(!GC_win32_dll_threads);
for (hv=0;hv < THREAD_TABLE_SZ;++hv){
GC_thread p,next;
for (p=GC_threads[hv];0!=p;p=next){
next=p->tm.next;
if (THREAD_EQUAL(p->pthread_id,pthread_id)
&&me==NULL){
me=p;
p->tm.next=0;
} else {
#ifdef THREAD_LOCAL_ALLOC
if ((p->flags&FINISHED)==0){
GC_remove_specific_after_fork(GC_thread_key,p->pthread_id);
}
#endif
if (&first_thread!=p)
GC_INTERNAL_FREE(p);
}
}
GC_threads[hv]=NULL;
}
GC_ASSERT(me!=NULL);
thread_id=GetCurrentThreadId();
GC_threads[THREAD_TABLE_INDEX(thread_id)]=me;
me->id=thread_id;
#ifndef MSWINCE
if (!DuplicateHandle(GetCurrentProcess(),GetCurrentThread(),
GetCurrentProcess(),(HANDLE*)&me->handle,
0,FALSE,
DUPLICATE_SAME_ACCESS))
ABORT("DuplicateHandle failed");
#endif
#if defined(THREAD_LOCAL_ALLOC)&&!defined(USE_CUSTOM_SPECIFIC)
if (GC_setspecific(GC_thread_key,&me->tlfs)!=0)
ABORT("GC_setspecific failed (in child)");
#endif
}
static void fork_prepare_proc(void)
{
LOCK();
#ifdef PARALLEL_MARK
if (GC_parallel)
GC_wait_for_reclaim();
#endif
GC_wait_for_gc_completion(TRUE);
#ifdef PARALLEL_MARK
if (GC_parallel)
GC_acquire_mark_lock();
#endif
}
static void fork_parent_proc(void)
{
#ifdef PARALLEL_MARK
if (GC_parallel)
GC_release_mark_lock();
#endif
UNLOCK();
}
static void fork_child_proc(void)
{
#ifdef PARALLEL_MARK
if (GC_parallel){
GC_release_mark_lock();
GC_parallel=FALSE;
}
#endif
GC_remove_all_threads_but_me();
UNLOCK();
}
GC_API void GC_CALL GC_atfork_prepare(void)
{
if (!EXPECT(GC_is_initialized,TRUE))GC_init();
if (GC_handle_fork<=0)
fork_prepare_proc();
}
GC_API void GC_CALL GC_atfork_parent(void)
{
if (GC_handle_fork<=0)
fork_parent_proc();
}
GC_API void GC_CALL GC_atfork_child(void)
{
if (GC_handle_fork<=0)
fork_child_proc();
}
#endif
void GC_push_thread_structures(void)
{
GC_ASSERT(I_HOLD_LOCK());
#ifndef GC_NO_THREADS_DISCOVERY
if (GC_win32_dll_threads){
} else
#endif
{
GC_PUSH_ALL_SYM(GC_threads);
}
#if defined(THREAD_LOCAL_ALLOC)
GC_PUSH_ALL_SYM(GC_thread_key);
#endif
}
#ifdef WOW64_THREAD_CONTEXT_WORKAROUND
#ifndef CONTEXT_EXCEPTION_ACTIVE
#define CONTEXT_EXCEPTION_ACTIVE 0x08000000
#define CONTEXT_EXCEPTION_REQUEST 0x40000000
#define CONTEXT_EXCEPTION_REPORTING 0x80000000
#endif
static BOOL isWow64;
#define GET_THREAD_CONTEXT_FLAGS (isWow64?CONTEXT_INTEGER|CONTEXT_CONTROL|CONTEXT_EXCEPTION_REQUEST|CONTEXT_SEGMENTS:CONTEXT_INTEGER|CONTEXT_CONTROL)
#else
#define GET_THREAD_CONTEXT_FLAGS (CONTEXT_INTEGER|CONTEXT_CONTROL)
#endif
STATIC void GC_suspend(GC_thread t)
{
#ifndef MSWINCE
DWORD exitCode;
#endif
#ifdef RETRY_GET_THREAD_CONTEXT
int retry_cnt=0;
#define MAX_SUSPEND_THREAD_RETRIES (1000*1000)
#endif
#ifdef DEBUG_THREADS
GC_log_printf("Suspending 0x%x\n",(int)t->id);
#endif
UNPROTECT_THREAD(t);
GC_acquire_dirty_lock();
#ifdef MSWINCE
while (SuspendThread(THREAD_HANDLE(t))==(DWORD)-1){
GC_release_dirty_lock();
Sleep(10);
GC_acquire_dirty_lock();
}
#elif defined(RETRY_GET_THREAD_CONTEXT)
for (;;){
if (GetExitCodeThread(t->handle,&exitCode)
&&exitCode!=STILL_ACTIVE){
GC_release_dirty_lock();
#ifdef GC_PTHREADS
t->stack_base=0;
#else
GC_ASSERT(GC_win32_dll_threads);
GC_delete_gc_thread_no_free(t);
#endif
return;
}
if (SuspendThread(t->handle)!=(DWORD)-1){
CONTEXT context;
context.ContextFlags=GET_THREAD_CONTEXT_FLAGS;
if (GetThreadContext(t->handle,&context)){
t->context_sp=copy_ptr_regs(t->context_regs,&context);
break;
}
if (ResumeThread(t->handle)==(DWORD)-1)
ABORT("ResumeThread failed in suspend loop");
}
if (retry_cnt > 1){
GC_release_dirty_lock();
Sleep(0);
GC_acquire_dirty_lock();
}
if (++retry_cnt>=MAX_SUSPEND_THREAD_RETRIES)
ABORT("SuspendThread loop failed");
}
#else
if (GetExitCodeThread(t->handle,&exitCode)
&&exitCode!=STILL_ACTIVE){
GC_release_dirty_lock();
#ifdef GC_PTHREADS
t->stack_base=0;
#else
GC_ASSERT(GC_win32_dll_threads);
GC_delete_gc_thread_no_free(t);
#endif
return;
}
if (SuspendThread(t->handle)==(DWORD)-1)
ABORT("SuspendThread failed");
#endif
t->suspended=(unsigned char)TRUE;
GC_release_dirty_lock();
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_SUSPENDED,THREAD_HANDLE(t));
}
#if defined(GC_ASSERTIONS)&&((defined(MSWIN32)&&!defined(CONSOLE_LOG))||defined(MSWINCE))
GC_INNER GC_bool GC_write_disabled=FALSE;
#endif
GC_INNER void GC_stop_world(void)
{
DWORD thread_id=GetCurrentThreadId();
if (!GC_thr_initialized)
ABORT("GC_stop_world()called before GC_thr_init()");
GC_ASSERT(I_HOLD_LOCK());
#ifdef PARALLEL_MARK
if (GC_parallel){
GC_acquire_mark_lock();
GC_ASSERT(GC_fl_builder_count==0);
}
#endif
#if!defined(GC_NO_THREADS_DISCOVERY)||defined(GC_ASSERTIONS)
GC_please_stop=TRUE;
#endif
#if (defined(MSWIN32)&&!defined(CONSOLE_LOG))||defined(MSWINCE)
GC_ASSERT(!GC_write_disabled);
EnterCriticalSection(&GC_write_cs);
#ifdef GC_ASSERTIONS
GC_write_disabled=TRUE;
#endif
#endif
#ifndef GC_NO_THREADS_DISCOVERY
if (GC_win32_dll_threads){
int i;
int my_max;
AO_store(&GC_attached_thread,FALSE);
my_max=(int)GC_get_max_thread_index();
for (i=0;i<=my_max;i++){
GC_vthread t=dll_thread_table+i;
if (t->stack_base!=0&&t->thread_blocked_sp==NULL
&&t->id!=thread_id){
GC_suspend((GC_thread)t);
}
}
} else
#endif
{
GC_thread t;
int i;
for (i=0;i < THREAD_TABLE_SZ;i++){
for (t=GC_threads[i];t!=0;t=t->tm.next){
if (t->stack_base!=0&&t->thread_blocked_sp==NULL
&&!KNOWN_FINISHED(t)&&t->id!=thread_id){
GC_suspend(t);
}
}
}
}
#if (defined(MSWIN32)&&!defined(CONSOLE_LOG))||defined(MSWINCE)
#ifdef GC_ASSERTIONS
GC_write_disabled=FALSE;
#endif
LeaveCriticalSection(&GC_write_cs);
#endif
#ifdef PARALLEL_MARK
if (GC_parallel)
GC_release_mark_lock();
#endif
}
GC_INNER void GC_start_world(void)
{
#ifdef GC_ASSERTIONS
DWORD thread_id=GetCurrentThreadId();
#endif
GC_ASSERT(I_HOLD_LOCK());
if (GC_win32_dll_threads){
LONG my_max=GC_get_max_thread_index();
int i;
for (i=0;i<=my_max;i++){
GC_thread t=(GC_thread)(dll_thread_table+i);
if (t->suspended){
#ifdef DEBUG_THREADS
GC_log_printf("Resuming 0x%x\n",(int)t->id);
#endif
GC_ASSERT(t->stack_base!=0&&t->id!=thread_id);
if (ResumeThread(THREAD_HANDLE(t))==(DWORD)-1)
ABORT("ResumeThread failed");
t->suspended=FALSE;
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_UNSUSPENDED,THREAD_HANDLE(t));
}
}
} else {
GC_thread t;
int i;
for (i=0;i < THREAD_TABLE_SZ;i++){
for (t=GC_threads[i];t!=0;t=t->tm.next){
if (t->suspended){
#ifdef DEBUG_THREADS
GC_log_printf("Resuming 0x%x\n",(int)t->id);
#endif
GC_ASSERT(t->stack_base!=0&&t->id!=thread_id);
if (ResumeThread(THREAD_HANDLE(t))==(DWORD)-1)
ABORT("ResumeThread failed");
UNPROTECT_THREAD(t);
t->suspended=FALSE;
if (GC_on_thread_event)
GC_on_thread_event(GC_EVENT_THREAD_UNSUSPENDED,THREAD_HANDLE(t));
} else {
#ifdef DEBUG_THREADS
GC_log_printf("Not resuming thread 0x%x as it is not suspended\n",
(int)t->id);
#endif
}
}
}
}
#if!defined(GC_NO_THREADS_DISCOVERY)||defined(GC_ASSERTIONS)
GC_please_stop=FALSE;
#endif
}
#ifdef MSWINCE
#define GC_wince_evaluate_stack_min(s)(ptr_t)(((word)(s)- 1)&~(word)0xFFFF)
#elif defined(GC_ASSERTIONS)
#define GC_dont_query_stack_min FALSE
#endif
static ptr_t last_address=0;
static MEMORY_BASIC_INFORMATION last_info;
STATIC ptr_t GC_get_stack_min(ptr_t s)
{
ptr_t bottom;
GC_ASSERT(I_HOLD_LOCK());
if (s!=last_address){
VirtualQuery(s,&last_info,sizeof(last_info));
last_address=s;
}
do {
bottom=(ptr_t)last_info.BaseAddress;
VirtualQuery(bottom - 1,&last_info,sizeof(last_info));
last_address=bottom - 1;
} while ((last_info.Protect&PAGE_READWRITE)
&&!(last_info.Protect&PAGE_GUARD));
return(bottom);
}
static GC_bool may_be_in_stack(ptr_t s)
{
GC_ASSERT(I_HOLD_LOCK());
if (s!=last_address){
VirtualQuery(s,&last_info,sizeof(last_info));
last_address=s;
}
return (last_info.Protect&PAGE_READWRITE)
&&!(last_info.Protect&PAGE_GUARD);
}
static ptr_t copy_ptr_regs(word*regs,const CONTEXT*pcontext){
ptr_t sp;
int cnt=0;
#define context (*pcontext)
#define PUSH1(reg)(regs[cnt++]=(word)pcontext->reg)
#define PUSH2(r1,r2)(PUSH1(r1),PUSH1(r2))
#define PUSH4(r1,r2,r3,r4)(PUSH2(r1,r2),PUSH2(r3,r4))
#if defined(I386)
#ifdef WOW64_THREAD_CONTEXT_WORKAROUND
PUSH2(ContextFlags,SegFs);
#endif
PUSH4(Edi,Esi,Ebx,Edx),PUSH2(Ecx,Eax),PUSH1(Ebp);
sp=(ptr_t)context.Esp;
#elif defined(X86_64)
PUSH4(Rax,Rcx,Rdx,Rbx);PUSH2(Rbp,Rsi);PUSH1(Rdi);
PUSH4(R8,R9,R10,R11);PUSH4(R12,R13,R14,R15);
sp=(ptr_t)context.Rsp;
#elif defined(ARM32)
PUSH4(R0,R1,R2,R3),PUSH4(R4,R5,R6,R7),PUSH4(R8,R9,R10,R11);
PUSH1(R12);
sp=(ptr_t)context.Sp;
#elif defined(AARCH64)
PUSH4(X0,X1,X2,X3),PUSH4(X4,X5,X6,X7),PUSH4(X8,X9,X10,X11);
PUSH4(X12,X13,X14,X15),PUSH4(X16,X17,X18,X19),PUSH4(X20,X21,X22,X23);
PUSH4(X24,X25,X26,X27),PUSH1(X28);
PUSH1(Lr);
sp=(ptr_t)context.Sp;
#elif defined(SHx)
PUSH4(R0,R1,R2,R3),PUSH4(R4,R5,R6,R7),PUSH4(R8,R9,R10,R11);
PUSH2(R12,R13),PUSH1(R14);
sp=(ptr_t)context.R15;
#elif defined(MIPS)
PUSH4(IntAt,IntV0,IntV1,IntA0),PUSH4(IntA1,IntA2,IntA3,IntT0);
PUSH4(IntT1,IntT2,IntT3,IntT4),PUSH4(IntT5,IntT6,IntT7,IntS0);
PUSH4(IntS1,IntS2,IntS3,IntS4),PUSH4(IntS5,IntS6,IntS7,IntT8);
PUSH4(IntT9,IntK0,IntK1,IntS8);
sp=(ptr_t)context.IntSp;
#elif defined(PPC)
PUSH4(Gpr0,Gpr3,Gpr4,Gpr5),PUSH4(Gpr6,Gpr7,Gpr8,Gpr9);
PUSH4(Gpr10,Gpr11,Gpr12,Gpr14),PUSH4(Gpr15,Gpr16,Gpr17,Gpr18);
PUSH4(Gpr19,Gpr20,Gpr21,Gpr22),PUSH4(Gpr23,Gpr24,Gpr25,Gpr26);
PUSH4(Gpr27,Gpr28,Gpr29,Gpr30),PUSH1(Gpr31);
sp=(ptr_t)context.Gpr1;
#elif defined(ALPHA)
PUSH4(IntV0,IntT0,IntT1,IntT2),PUSH4(IntT3,IntT4,IntT5,IntT6);
PUSH4(IntT7,IntS0,IntS1,IntS2),PUSH4(IntS3,IntS4,IntS5,IntFp);
PUSH4(IntA0,IntA1,IntA2,IntA3),PUSH4(IntA4,IntA5,IntT8,IntT9);
PUSH4(IntT10,IntT11,IntT12,IntAt);
sp=(ptr_t)context.IntSp;
#elif defined(CPPCHECK)
sp=(ptr_t)(word)cnt;
#else
#error Architecture is not supported
#endif
#undef context
GC_ASSERT(cnt==PUSHED_REGS_COUNT);
return sp;
}
STATIC word GC_push_stack_for(GC_thread thread,DWORD me)
{
ptr_t sp,stack_min;
struct GC_traced_stack_sect_s*traced_stack_sect=
thread->traced_stack_sect;
if (thread->id==me){
GC_ASSERT(thread->thread_blocked_sp==NULL);
sp=GC_approx_sp();
} else if ((sp=thread->thread_blocked_sp)==NULL){
#ifdef RETRY_GET_THREAD_CONTEXT
word*regs=thread->context_regs;
if (thread->suspended){
sp=thread->context_sp;
} else
#else
word regs[PUSHED_REGS_COUNT];
#endif
{
CONTEXT context;
context.ContextFlags=GET_THREAD_CONTEXT_FLAGS;
if (GetThreadContext(THREAD_HANDLE(thread),&context)){
sp=copy_ptr_regs(regs,&context);
} else {
#ifdef RETRY_GET_THREAD_CONTEXT
sp=thread->context_sp;
if (NULL==sp){
return 0;
}
#else
ABORT("GetThreadContext failed");
#endif
}
}
#ifdef THREAD_LOCAL_ALLOC
GC_ASSERT(thread->suspended||!GC_world_stopped);
#endif
#ifndef WOW64_THREAD_CONTEXT_WORKAROUND
GC_push_many_regs(regs,PUSHED_REGS_COUNT);
#else
GC_push_many_regs(regs+2,PUSHED_REGS_COUNT - 2);
if (isWow64){
DWORD ContextFlags=(DWORD)regs[0];
WORD SegFs=(WORD)regs[1];
if ((ContextFlags&CONTEXT_EXCEPTION_REPORTING)!=0
&&(ContextFlags&(CONTEXT_EXCEPTION_ACTIVE
))!=0){
LDT_ENTRY selector;
PNT_TIB tib;
if (!GetThreadSelectorEntry(THREAD_HANDLE(thread),SegFs,&selector))
ABORT("GetThreadSelectorEntry failed");
tib=(PNT_TIB)(selector.BaseLow
|(selector.HighWord.Bits.BaseMid<<16)
|(selector.HighWord.Bits.BaseHi<<24));
#ifdef DEBUG_THREADS
GC_log_printf("TIB stack limit/base:%p .. %p\n",
(void*)tib->StackLimit,(void*)tib->StackBase);
#endif
GC_ASSERT(!((word)thread->stack_base
COOLER_THAN (word)tib->StackBase));
if (thread->stack_base!=thread->initial_stack_base
&&((word)thread->stack_base<=(word)tib->StackLimit
||(word)tib->StackBase < (word)thread->stack_base)){
WARN("GetThreadContext might return stale register values"
" including ESP=%p\n",sp);
} else {
sp=(ptr_t)tib->StackLimit;
}
}
#ifdef DEBUG_THREADS
else {
static GC_bool logged;
if (!logged
&&(ContextFlags&CONTEXT_EXCEPTION_REPORTING)==0){
GC_log_printf("CONTEXT_EXCEPTION_REQUEST not supported\n");
logged=TRUE;
}
}
#endif
}
#endif
}
if (thread->last_stack_min==ADDR_LIMIT){
#ifdef MSWINCE
if (GC_dont_query_stack_min){
stack_min=GC_wince_evaluate_stack_min(traced_stack_sect!=NULL?
(ptr_t)traced_stack_sect:thread->stack_base);
} else
#endif
{
stack_min=GC_get_stack_min(traced_stack_sect!=NULL?
(ptr_t)traced_stack_sect:thread->stack_base);
UNPROTECT_THREAD(thread);
thread->last_stack_min=stack_min;
}
} else {
if (traced_stack_sect!=NULL&&
(word)thread->last_stack_min > (word)traced_stack_sect){
UNPROTECT_THREAD(thread);
thread->last_stack_min=(ptr_t)traced_stack_sect;
}
if ((word)sp < (word)thread->stack_base
&&(word)sp>=(word)thread->last_stack_min){
stack_min=sp;
} else {
if (may_be_in_stack(thread->id==me&&
(word)sp < (word)thread->last_stack_min?
sp:thread->last_stack_min)){
stack_min=(ptr_t)last_info.BaseAddress;
if ((word)sp < (word)stack_min
||(word)sp>=(word)thread->stack_base)
stack_min=GC_get_stack_min(thread->last_stack_min);
} else {
stack_min=GC_get_stack_min(thread->stack_base);
}
UNPROTECT_THREAD(thread);
thread->last_stack_min=stack_min;
}
}
GC_ASSERT(GC_dont_query_stack_min
||stack_min==GC_get_stack_min(thread->stack_base)
||((word)sp>=(word)stack_min
&&(word)stack_min < (word)thread->stack_base
&&(word)stack_min
> (word)GC_get_stack_min(thread->stack_base)));
if ((word)sp>=(word)stack_min&&(word)sp < (word)thread->stack_base){
#ifdef DEBUG_THREADS
GC_log_printf("Pushing stack for 0x%x from sp %p to %p from 0x%x\n",
(int)thread->id,(void*)sp,(void*)thread->stack_base,
(int)me);
#endif
GC_push_all_stack_sections(sp,thread->stack_base,traced_stack_sect);
} else {
if (thread->id==me||(word)sp>=(word)thread->stack_base
||(word)(sp+GC_page_size)< (word)stack_min)
WARN("Thread stack pointer %p out of range,pushing everything\n",
sp);
#ifdef DEBUG_THREADS
GC_log_printf("Pushing stack for 0x%x from (min)%p to %p from 0x%x\n",
(int)thread->id,(void*)stack_min,
(void*)thread->stack_base,(int)me);
#endif
GC_push_all_stack(stack_min,thread->stack_base);
}
return thread->stack_base - sp;
}
GC_INNER void GC_push_all_stacks(void)
{
DWORD thread_id=GetCurrentThreadId();
GC_bool found_me=FALSE;
#ifndef SMALL_CONFIG
unsigned nthreads=0;
#endif
word total_size=0;
#ifndef GC_NO_THREADS_DISCOVERY
if (GC_win32_dll_threads){
int i;
LONG my_max=GC_get_max_thread_index();
for (i=0;i<=my_max;i++){
GC_thread t=(GC_thread)(dll_thread_table+i);
if (t->tm.in_use&&t->stack_base){
#ifndef SMALL_CONFIG
++nthreads;
#endif
total_size+=GC_push_stack_for(t,thread_id);
if (t->id==thread_id)found_me=TRUE;
}
}
} else
#endif
{
int i;
for (i=0;i < THREAD_TABLE_SZ;i++){
GC_thread t;
for (t=GC_threads[i];t!=0;t=t->tm.next){
if (!KNOWN_FINISHED(t)&&t->stack_base){
#ifndef SMALL_CONFIG
++nthreads;
#endif
total_size+=GC_push_stack_for(t,thread_id);
if (t->id==thread_id)found_me=TRUE;
}
}
}
}
#ifndef SMALL_CONFIG
GC_VERBOSE_LOG_PRINTF("Pushed %d thread stacks%s\n",nthreads,
GC_win32_dll_threads?
" based on DllMain thread tracking":"");
#endif
if (!found_me&&!GC_in_thread_creation)
ABORT("Collecting from unknown thread");
GC_total_stacksize=total_size;
}
#ifdef PARALLEL_MARK
#ifndef MAX_MARKERS
#define MAX_MARKERS 16
#endif
static ptr_t marker_sp[MAX_MARKERS - 1];
#ifdef IA64
static ptr_t marker_bsp[MAX_MARKERS - 1];
#endif
static ptr_t marker_last_stack_min[MAX_MARKERS - 1];
#endif
GC_INNER void GC_get_next_stack(char*start,char*limit,
char**lo,char**hi)
{
int i;
char*current_min=ADDR_LIMIT;
ptr_t*plast_stack_min=NULL;
GC_thread thread=NULL;
if (GC_win32_dll_threads){
LONG my_max=GC_get_max_thread_index();
for (i=0;i<=my_max;i++){
ptr_t s=(ptr_t)(dll_thread_table[i].stack_base);
if ((word)s > (word)start&&(word)s < (word)current_min){
plast_stack_min=(ptr_t*)
&dll_thread_table[i].last_stack_min;
current_min=s;
#if defined(CPPCHECK)
thread=(GC_thread)&dll_thread_table[i];
#endif
}
}
} else {
for (i=0;i < THREAD_TABLE_SZ;i++){
GC_thread t;
for (t=GC_threads[i];t!=0;t=t->tm.next){
ptr_t s=t->stack_base;
if ((word)s > (word)start&&(word)s < (word)current_min){
plast_stack_min=&t->last_stack_min;
thread=t;
current_min=s;
}
}
}
#ifdef PARALLEL_MARK
for (i=0;i < GC_markers_m1;++i){
ptr_t s=marker_sp[i];
#ifdef IA64
#endif
if ((word)s > (word)start&&(word)s < (word)current_min){
GC_ASSERT(marker_last_stack_min[i]!=NULL);
plast_stack_min=&marker_last_stack_min[i];
current_min=s;
thread=NULL;
}
}
#endif
}
*hi=current_min;
if (current_min==ADDR_LIMIT){
*lo=ADDR_LIMIT;
return;
}
GC_ASSERT((word)current_min > (word)start&&plast_stack_min!=NULL);
#ifdef MSWINCE
if (GC_dont_query_stack_min){
*lo=GC_wince_evaluate_stack_min(current_min);
return;
}
#endif
if ((word)current_min > (word)limit&&!may_be_in_stack(limit)){
*lo=ADDR_LIMIT;
return;
}
if (*plast_stack_min==ADDR_LIMIT
||!may_be_in_stack(*plast_stack_min)){
*lo=GC_get_stack_min(current_min);
} else {
*lo=GC_get_stack_min(*plast_stack_min);
}
if (thread!=NULL){
UNPROTECT_THREAD(thread);
}
*plast_stack_min=*lo;
}
#ifdef PARALLEL_MARK
#if defined(GC_PTHREADS)&&!defined(GC_PTHREADS_PARAMARK)
#if!defined(__MINGW32__)
#define GC_PTHREADS_PARAMARK
#endif
#endif
#if!defined(GC_PTHREADS_PARAMARK)
STATIC HANDLE GC_marker_cv[MAX_MARKERS - 1]={0};
STATIC DWORD GC_marker_Id[MAX_MARKERS - 1]={0};
#endif
#if defined(GC_PTHREADS)&&defined(HAVE_PTHREAD_SETNAME_NP_WITH_TID)
static void set_marker_thread_name(unsigned id)
{
char name_buf[16];
int len=sizeof("GC-marker-")- 1;
BCOPY("GC-marker-",name_buf,len);
if (id>=10)
name_buf[len++]=(char)('0'+(id/10)% 10);
name_buf[len]=(char)('0'+id % 10);
name_buf[len+1]='\0';
if (pthread_setname_np(pthread_self(),name_buf)!=0)
WARN("pthread_setname_np failed\n",0);
}
#elif!defined(MSWINCE)
static FARPROC setThreadDescription_fn;
static void set_marker_thread_name(unsigned id)
{
WCHAR name_buf[16];
int len=sizeof(L"GC-marker-")/sizeof(WCHAR)- 1;
HRESULT hr;
if (!setThreadDescription_fn)return;
BCOPY(L"GC-marker-",name_buf,len*sizeof(WCHAR));
if (id>=10)
name_buf[len++]=(WCHAR)('0'+(id/10)% 10);
name_buf[len]=(WCHAR)('0'+id % 10);
name_buf[len+1]=0;
hr=(*(HRESULT (WINAPI*)(HANDLE,const WCHAR*))
(word)setThreadDescription_fn)(GetCurrentThread(),name_buf);
if (FAILED(hr))
WARN("SetThreadDescription failed\n",0);
}
#else
#define set_marker_thread_name(id)(void)(id)
#endif
#ifdef GC_PTHREADS_PARAMARK
STATIC void*GC_mark_thread(void*id)
#elif defined(MSWINCE)
STATIC DWORD WINAPI GC_mark_thread(LPVOID id)
#else
STATIC unsigned __stdcall GC_mark_thread(void*id)
#endif
{
word my_mark_no=0;
if ((word)id==GC_WORD_MAX)return 0;
set_marker_thread_name((unsigned)(word)id);
marker_sp[(word)id]=GC_approx_sp();
#ifdef IA64
marker_bsp[(word)id]=GC_save_regs_in_stack();
#endif
#if!defined(GC_PTHREADS_PARAMARK)
GC_marker_Id[(word)id]=GetCurrentThreadId();
#endif
GC_acquire_mark_lock();
if (0==--GC_fl_builder_count)
GC_notify_all_builder();
for (;;++my_mark_no){
if (my_mark_no - GC_mark_no > (word)2){
my_mark_no=GC_mark_no;
}
#ifdef DEBUG_THREADS
GC_log_printf("Starting mark helper for mark number %lu\n",
(unsigned long)my_mark_no);
#endif
GC_help_marker(my_mark_no);
}
}
#ifndef GC_ASSERTIONS
#define SET_MARK_LOCK_HOLDER (void)0
#define UNSET_MARK_LOCK_HOLDER (void)0
#endif
#ifdef CAN_HANDLE_FORK
static int available_markers_m1=0;
#else
#define available_markers_m1 GC_markers_m1
#endif
#ifdef GC_PTHREADS_PARAMARK
#include <pthread.h>
#if defined(GC_ASSERTIONS)&&!defined(NUMERIC_THREAD_ID)
#define NUMERIC_THREAD_ID(id)(unsigned long)(word)GC_PTHREAD_PTRVAL(id)
#endif
#ifdef CAN_HANDLE_FORK
static pthread_cond_t mark_cv;
#else
static pthread_cond_t mark_cv=PTHREAD_COND_INITIALIZER;
#endif
GC_INNER void GC_start_mark_threads_inner(void)
{
int i;
pthread_attr_t attr;
pthread_t new_thread;
#ifndef NO_MARKER_SPECIAL_SIGMASK
sigset_t set,oldset;
#endif
GC_ASSERT(I_DONT_HOLD_LOCK());
if (available_markers_m1<=0)return;
#ifdef CAN_HANDLE_FORK
if (GC_parallel)return;
{
pthread_cond_t mark_cv_local=PTHREAD_COND_INITIALIZER;
BCOPY(&mark_cv_local,&mark_cv,sizeof(mark_cv));
}
#endif
GC_ASSERT(GC_fl_builder_count==0);
if (0!=pthread_attr_init(&attr))ABORT("pthread_attr_init failed");
if (0!=pthread_attr_setdetachstate(&attr,PTHREAD_CREATE_DETACHED))
ABORT("pthread_attr_setdetachstate failed");
#ifndef NO_MARKER_SPECIAL_SIGMASK
if (sigfillset(&set)!=0)
ABORT("sigfillset failed");
if (pthread_sigmask(SIG_BLOCK,&set,&oldset)< 0){
WARN("pthread_sigmask set failed,no markers started,"
" errno=%" WARN_PRIdPTR "\n",errno);
GC_markers_m1=0;
(void)pthread_attr_destroy(&attr);
return;
}
#endif
#ifdef CAN_HANDLE_FORK
GC_markers_m1=available_markers_m1;
#endif
for (i=0;i < available_markers_m1;++i){
marker_last_stack_min[i]=ADDR_LIMIT;
if (0!=pthread_create(&new_thread,&attr,
GC_mark_thread,(void*)(word)i)){
WARN("Marker thread creation failed\n",0);
GC_markers_m1=i;
break;
}
}
#ifndef NO_MARKER_SPECIAL_SIGMASK
if (pthread_sigmask(SIG_SETMASK,&oldset,NULL)< 0){
WARN("pthread_sigmask restore failed,errno=%" WARN_PRIdPTR "\n",
errno);
}
#endif
(void)pthread_attr_destroy(&attr);
GC_wait_for_markers_init();
GC_COND_LOG_PRINTF("Started %d mark helper threads\n",GC_markers_m1);
}
#ifdef GC_ASSERTIONS
STATIC unsigned long GC_mark_lock_holder=NO_THREAD;
#define SET_MARK_LOCK_HOLDER (void)(GC_mark_lock_holder=NUMERIC_THREAD_ID(pthread_self()))
#define UNSET_MARK_LOCK_HOLDER do { GC_ASSERT(GC_mark_lock_holder==NUMERIC_THREAD_ID(pthread_self()));GC_mark_lock_holder=NO_THREAD;} while (0)
#endif
static pthread_mutex_t mark_mutex=PTHREAD_MUTEX_INITIALIZER;
static pthread_cond_t builder_cv=PTHREAD_COND_INITIALIZER;
#ifdef LOCK_STATS
volatile AO_t GC_block_count=0;
#endif
GC_INNER void GC_acquire_mark_lock(void)
{
#if defined(NUMERIC_THREAD_ID_UNIQUE)&&!defined(THREAD_SANITIZER)
GC_ASSERT(GC_mark_lock_holder!=NUMERIC_THREAD_ID(pthread_self()));
#endif
if (pthread_mutex_lock(&mark_mutex)!=0){
ABORT("pthread_mutex_lock failed");
}
#ifdef LOCK_STATS
(void)AO_fetch_and_add1(&GC_block_count);
#endif
SET_MARK_LOCK_HOLDER;
}
GC_INNER void GC_release_mark_lock(void)
{
UNSET_MARK_LOCK_HOLDER;
if (pthread_mutex_unlock(&mark_mutex)!=0){
ABORT("pthread_mutex_unlock failed");
}
}
STATIC void GC_wait_builder(void)
{
UNSET_MARK_LOCK_HOLDER;
if (pthread_cond_wait(&builder_cv,&mark_mutex)!=0){
ABORT("pthread_cond_wait failed");
}
GC_ASSERT(GC_mark_lock_holder==NO_THREAD);
SET_MARK_LOCK_HOLDER;
}
GC_INNER void GC_wait_for_reclaim(void)
{
GC_acquire_mark_lock();
while (GC_fl_builder_count > 0){
GC_wait_builder();
}
GC_release_mark_lock();
}
GC_INNER void GC_notify_all_builder(void)
{
GC_ASSERT(GC_mark_lock_holder==NUMERIC_THREAD_ID(pthread_self()));
if (pthread_cond_broadcast(&builder_cv)!=0){
ABORT("pthread_cond_broadcast failed");
}
}
GC_INNER void GC_wait_marker(void)
{
GC_ASSERT(GC_parallel);
UNSET_MARK_LOCK_HOLDER;
if (pthread_cond_wait(&mark_cv,&mark_mutex)!=0){
ABORT("pthread_cond_wait failed");
}
GC_ASSERT(GC_mark_lock_holder==NO_THREAD);
SET_MARK_LOCK_HOLDER;
}
GC_INNER void GC_notify_all_marker(void)
{
GC_ASSERT(GC_parallel);
if (pthread_cond_broadcast(&mark_cv)!=0){
ABORT("pthread_cond_broadcast failed");
}
}
#else
#ifndef MARK_THREAD_STACK_SIZE
#define MARK_THREAD_STACK_SIZE 0
#endif
static HANDLE mark_mutex_event=(HANDLE)0;
static HANDLE builder_cv=(HANDLE)0;
static HANDLE mark_cv=(HANDLE)0;
GC_INNER void GC_start_mark_threads_inner(void)
{
int i;
GC_ASSERT(I_DONT_HOLD_LOCK());
if (available_markers_m1<=0)return;
GC_ASSERT(GC_fl_builder_count==0);
for (i=0;i < GC_markers_m1;++i){
if ((GC_marker_cv[i]=CreateEvent(NULL,
TRUE,
FALSE,
NULL))==(HANDLE)0)
ABORT("CreateEvent failed");
}
for (i=0;i < GC_markers_m1;++i){
#if defined(MSWINCE)||defined(MSWIN_XBOX1)
HANDLE handle;
DWORD thread_id;
marker_last_stack_min[i]=ADDR_LIMIT;
handle=CreateThread(NULL,
MARK_THREAD_STACK_SIZE,
GC_mark_thread,(LPVOID)(word)i,
0,&thread_id);
if (handle==NULL){
WARN("Marker thread creation failed\n",0);
break;
} else {
CloseHandle(handle);
}
#else
GC_uintptr_t handle;
unsigned thread_id;
marker_last_stack_min[i]=ADDR_LIMIT;
handle=_beginthreadex(NULL,
MARK_THREAD_STACK_SIZE,GC_mark_thread,
(void*)(word)i,0,&thread_id);
if (!handle||handle==(GC_uintptr_t)-1L){
WARN("Marker thread creation failed\n",0);
break;
} else {
}
#endif
}
while (GC_markers_m1 > i){
GC_markers_m1--;
CloseHandle(GC_marker_cv[GC_markers_m1]);
}
GC_wait_for_markers_init();
GC_COND_LOG_PRINTF("Started %d mark helper threads\n",GC_markers_m1);
if (i==0){
CloseHandle(mark_cv);
CloseHandle(builder_cv);
CloseHandle(mark_mutex_event);
}
}
#ifdef GC_ASSERTIONS
STATIC DWORD GC_mark_lock_holder=NO_THREAD;
#define SET_MARK_LOCK_HOLDER (void)(GC_mark_lock_holder=GetCurrentThreadId())
#define UNSET_MARK_LOCK_HOLDER do { GC_ASSERT(GC_mark_lock_holder==GetCurrentThreadId());GC_mark_lock_holder=NO_THREAD;} while (0)
#endif
STATIC LONG GC_mark_mutex_state=0;
#ifdef LOCK_STATS
volatile AO_t GC_block_count=0;
volatile AO_t GC_unlocked_count=0;
#endif
GC_INNER void GC_acquire_mark_lock(void)
{
#ifndef THREAD_SANITIZER
GC_ASSERT(GC_mark_lock_holder!=GetCurrentThreadId());
#endif
if (InterlockedExchange(&GC_mark_mutex_state,1)!=0){
#ifdef LOCK_STATS
(void)AO_fetch_and_add1(&GC_block_count);
#endif
while (InterlockedExchange(&GC_mark_mutex_state,
-1)!=0){
if (WaitForSingleObject(mark_mutex_event,INFINITE)==WAIT_FAILED)
ABORT("WaitForSingleObject failed");
}
}
#ifdef LOCK_STATS
else {
(void)AO_fetch_and_add1(&GC_unlocked_count);
}
#endif
GC_ASSERT(GC_mark_lock_holder==NO_THREAD);
SET_MARK_LOCK_HOLDER;
}
GC_INNER void GC_release_mark_lock(void)
{
UNSET_MARK_LOCK_HOLDER;
if (InterlockedExchange(&GC_mark_mutex_state,0)< 0){
if (SetEvent(mark_mutex_event)==FALSE)
ABORT("SetEvent failed");
}
}
GC_INNER void GC_wait_for_reclaim(void)
{
GC_ASSERT(builder_cv!=0);
for (;;){
GC_acquire_mark_lock();
if (GC_fl_builder_count==0)
break;
if (ResetEvent(builder_cv)==FALSE)
ABORT("ResetEvent failed");
GC_release_mark_lock();
if (WaitForSingleObject(builder_cv,INFINITE)==WAIT_FAILED)
ABORT("WaitForSingleObject failed");
}
GC_release_mark_lock();
}
GC_INNER void GC_notify_all_builder(void)
{
GC_ASSERT(GC_mark_lock_holder==GetCurrentThreadId());
GC_ASSERT(builder_cv!=0);
GC_ASSERT(GC_fl_builder_count==0);
if (SetEvent(builder_cv)==FALSE)
ABORT("SetEvent failed");
}
GC_INNER void GC_wait_marker(void)
{
HANDLE event=mark_cv;
DWORD thread_id=GetCurrentThreadId();
int i=GC_markers_m1;
while (i--> 0){
if (GC_marker_Id[i]==thread_id){
event=GC_marker_cv[i];
break;
}
}
if (ResetEvent(event)==FALSE)
ABORT("ResetEvent failed");
GC_release_mark_lock();
if (WaitForSingleObject(event,INFINITE)==WAIT_FAILED)
ABORT("WaitForSingleObject failed");
GC_acquire_mark_lock();
}
GC_INNER void GC_notify_all_marker(void)
{
DWORD thread_id=GetCurrentThreadId();
int i=GC_markers_m1;
while (i--> 0){
if (SetEvent(GC_marker_Id[i]!=thread_id?GC_marker_cv[i]:
mark_cv)==FALSE)
ABORT("SetEvent failed");
}
}
#endif
static unsigned required_markers_cnt=0;
#endif
typedef struct {
LPTHREAD_START_ROUTINE start;
LPVOID param;
} thread_args;
STATIC void*GC_CALLBACK GC_win32_start_inner(struct GC_stack_base*sb,
void*arg)
{
void*ret;
LPTHREAD_START_ROUTINE start=((thread_args*)arg)->start;
LPVOID param=((thread_args*)arg)->param;
GC_register_my_thread(sb);
#ifdef DEBUG_THREADS
GC_log_printf("thread 0x%lx starting...\n",(long)GetCurrentThreadId());
#endif
GC_free(arg);
#if!defined(__GNUC__)&&!defined(NO_CRT)
ret=NULL;
__try
#endif
{
ret=(void*)(word)(*start)(param);
}
#if!defined(__GNUC__)&&!defined(NO_CRT)
__finally
#endif
{
GC_unregister_my_thread();
}
#ifdef DEBUG_THREADS
GC_log_printf("thread 0x%lx returned from start routine\n",
(long)GetCurrentThreadId());
#endif
return ret;
}
STATIC DWORD WINAPI GC_win32_start(LPVOID arg)
{
return (DWORD)(word)GC_call_with_stack_base(GC_win32_start_inner,arg);
}
GC_API HANDLE WINAPI GC_CreateThread(
LPSECURITY_ATTRIBUTES lpThreadAttributes,
GC_WIN32_SIZE_T dwStackSize,
LPTHREAD_START_ROUTINE lpStartAddress,
LPVOID lpParameter,DWORD dwCreationFlags,
LPDWORD lpThreadId)
{
if (!EXPECT(parallel_initialized,TRUE))
GC_init_parallel();
#ifdef DEBUG_THREADS
GC_log_printf("About to create a thread from 0x%lx\n",
(long)GetCurrentThreadId());
#endif
if (GC_win32_dll_threads){
return CreateThread(lpThreadAttributes,dwStackSize,lpStartAddress,
lpParameter,dwCreationFlags,lpThreadId);
} else {
thread_args*args=
(thread_args*)GC_malloc_uncollectable(sizeof(thread_args));
HANDLE thread_h;
if (NULL==args){
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return NULL;
}
args->start=lpStartAddress;
args->param=lpParameter;
GC_dirty(args);
REACHABLE_AFTER_DIRTY(lpParameter);
set_need_to_lock();
thread_h=CreateThread(lpThreadAttributes,dwStackSize,GC_win32_start,
args,dwCreationFlags,lpThreadId);
if (thread_h==0)GC_free(args);
return thread_h;
}
}
GC_API DECLSPEC_NORETURN void WINAPI GC_ExitThread(DWORD dwExitCode)
{
GC_unregister_my_thread();
ExitThread(dwExitCode);
}
#if!defined(CYGWIN32)&&!defined(MSWINCE)&&!defined(MSWIN_XBOX1)&&!defined(NO_CRT)
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)
{
if (!EXPECT(parallel_initialized,TRUE))
GC_init_parallel();
#ifdef DEBUG_THREADS
GC_log_printf("About to create a thread from 0x%lx\n",
(long)GetCurrentThreadId());
#endif
if (GC_win32_dll_threads){
return _beginthreadex(security,stack_size,start_address,
arglist,initflag,thrdaddr);
} else {
GC_uintptr_t thread_h;
thread_args*args=
(thread_args*)GC_malloc_uncollectable(sizeof(thread_args));
if (NULL==args){
errno=EAGAIN;
return 0;
}
args->start=(LPTHREAD_START_ROUTINE)start_address;
args->param=arglist;
GC_dirty(args);
REACHABLE_AFTER_DIRTY(arglist);
set_need_to_lock();
thread_h=_beginthreadex(security,stack_size,
(unsigned (__stdcall*)(void*))GC_win32_start,
args,initflag,thrdaddr);
if (thread_h==0)GC_free(args);
return thread_h;
}
}
GC_API void GC_CALL GC_endthreadex(unsigned retval)
{
GC_unregister_my_thread();
_endthreadex(retval);
}
#endif
#ifdef GC_WINMAIN_REDIRECT
#if defined(MSWINCE)&&defined(UNDER_CE)
#define WINMAIN_LPTSTR LPWSTR
#else
#define WINMAIN_LPTSTR LPSTR
#endif
#undef WinMain
int WINAPI GC_WinMain(HINSTANCE,HINSTANCE,WINMAIN_LPTSTR,int);
typedef struct {
HINSTANCE hInstance;
HINSTANCE hPrevInstance;
WINMAIN_LPTSTR lpCmdLine;
int nShowCmd;
} main_thread_args;
static DWORD WINAPI main_thread_start(LPVOID arg)
{
main_thread_args*args=(main_thread_args*)arg;
return (DWORD)GC_WinMain(args->hInstance,args->hPrevInstance,
args->lpCmdLine,args->nShowCmd);
}
STATIC void*GC_waitForSingleObjectInfinite(void*handle)
{
return (void*)(word)WaitForSingleObject((HANDLE)handle,INFINITE);
}
#ifndef WINMAIN_THREAD_STACK_SIZE
#define WINMAIN_THREAD_STACK_SIZE 0
#endif
int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
WINMAIN_LPTSTR lpCmdLine,int nShowCmd)
{
DWORD exit_code=1;
main_thread_args args={
hInstance,hPrevInstance,lpCmdLine,nShowCmd
};
HANDLE thread_h;
DWORD thread_id;
GC_INIT();
thread_h=GC_CreateThread(NULL,
WINMAIN_THREAD_STACK_SIZE,
main_thread_start,&args,0,
&thread_id);
if (thread_h!=NULL){
if ((DWORD)(word)GC_do_blocking(GC_waitForSingleObjectInfinite,
(void*)thread_h)==WAIT_FAILED)
ABORT("WaitForSingleObject(main_thread)failed");
GetExitCodeThread (thread_h,&exit_code);
CloseHandle (thread_h);
} else {
ABORT("GC_CreateThread(main_thread)failed");
}
#ifdef MSWINCE
GC_deinit();
#endif
return (int)exit_code;
}
#endif
GC_API void GC_CALL GC_set_markers_count(unsigned markers GC_ATTR_UNUSED)
{
#ifdef PARALLEL_MARK
required_markers_cnt=markers < MAX_MARKERS?markers:MAX_MARKERS;
#endif
}
GC_INNER void GC_thr_init(void)
{
struct GC_stack_base sb;
#if (!defined(HAVE_PTHREAD_SETNAME_NP_WITH_TID)&&!defined(MSWINCE)&&defined(PARALLEL_MARK))||defined(WOW64_THREAD_CONTEXT_WORKAROUND)
HMODULE hK32=GetModuleHandle(TEXT("kernel32.dll"));
#endif
GC_ASSERT(I_HOLD_LOCK());
if (GC_thr_initialized)return;
GC_ASSERT((word)&GC_threads % sizeof(word)==0);
#ifdef GC_NO_THREADS_DISCOVERY
#define GC_main_thread GetCurrentThreadId()
#else
GC_main_thread=GetCurrentThreadId();
#endif
GC_thr_initialized=TRUE;
#ifdef CAN_HANDLE_FORK
if (GC_handle_fork){
#ifdef CAN_CALL_ATFORK
if (pthread_atfork(fork_prepare_proc,fork_parent_proc,
fork_child_proc)==0){
GC_handle_fork=1;
} else
#endif
if (GC_handle_fork!=-1)
ABORT("pthread_atfork failed");
}
#endif
#ifdef WOW64_THREAD_CONTEXT_WORKAROUND
if (hK32){
FARPROC pfn=GetProcAddress(hK32,"IsWow64Process");
if (pfn
&&!(*(BOOL (WINAPI*)(HANDLE,BOOL*))(word)pfn)(
GetCurrentProcess(),&isWow64))
isWow64=FALSE;
}
#endif
sb.mem_base=GC_stackbottom;
GC_ASSERT(sb.mem_base!=NULL);
#ifdef IA64
sb.reg_base=GC_register_stackbottom;
#endif
#if defined(PARALLEL_MARK)
{
char*markers_string=GETENV("GC_MARKERS");
int markers=required_markers_cnt;
if (markers_string!=NULL){
markers=atoi(markers_string);
if (markers<=0||markers > MAX_MARKERS){
WARN("Too big or invalid number of mark threads:%" WARN_PRIdPTR
";using maximum threads\n",(signed_word)markers);
markers=MAX_MARKERS;
}
} else if (0==markers){
#ifdef MSWINCE
markers=(int)GC_sysinfo.dwNumberOfProcessors;
#else
#ifdef _WIN64
DWORD_PTR procMask=0;
DWORD_PTR sysMask;
#else
DWORD procMask=0;
DWORD sysMask;
#endif
int ncpu=0;
if (
#ifdef __cplusplus
GetProcessAffinityMask(GetCurrentProcess(),&procMask,&sysMask)
#else
GetProcessAffinityMask(GetCurrentProcess(),
(void*)&procMask,(void*)&sysMask)
#endif
&&procMask){
do {
ncpu++;
} while ((procMask&=procMask - 1)!=0);
}
markers=ncpu;
#endif
#if defined(GC_MIN_MARKERS)&&!defined(CPPCHECK)
if (markers < GC_MIN_MARKERS)
markers=GC_MIN_MARKERS;
#endif
if (markers > MAX_MARKERS)
markers=MAX_MARKERS;
}
available_markers_m1=markers - 1;
}
if (GC_win32_dll_threads||available_markers_m1<=0){
GC_parallel=FALSE;
GC_COND_LOG_PRINTF(
"Single marker thread,turning off parallel marking\n");
} else {
#ifndef GC_PTHREADS_PARAMARK
mark_mutex_event=CreateEvent(NULL,
FALSE,
FALSE,NULL);
builder_cv=CreateEvent(NULL,
TRUE,
FALSE,NULL);
mark_cv=CreateEvent(NULL,TRUE,
FALSE,NULL);
if (mark_mutex_event==(HANDLE)0||builder_cv==(HANDLE)0
||mark_cv==(HANDLE)0)
ABORT("CreateEvent failed");
#endif
#if!defined(HAVE_PTHREAD_SETNAME_NP_WITH_TID)&&!defined(MSWINCE)
if (hK32)
setThreadDescription_fn=GetProcAddress(hK32,
"SetThreadDescription");
#endif
}
#endif
GC_ASSERT(0==GC_lookup_thread_inner(GC_main_thread));
GC_register_my_thread_inner(&sb,GC_main_thread);
#undef GC_main_thread
}
#ifdef GC_PTHREADS
struct start_info {
void*(*start_routine)(void*);
void*arg;
GC_bool detached;
};
GC_API int GC_pthread_join(pthread_t pthread_id,void**retval)
{
int result;
#ifndef GC_WIN32_PTHREADS
GC_thread t;
#endif
DCL_LOCK_STATE;
GC_ASSERT(!GC_win32_dll_threads);
#ifdef DEBUG_THREADS
GC_log_printf("thread %p(0x%lx)is joining thread %p\n",
(void*)GC_PTHREAD_PTRVAL(pthread_self()),
(long)GetCurrentThreadId(),
(void*)GC_PTHREAD_PTRVAL(pthread_id));
#endif
#ifndef GC_WIN32_PTHREADS
while ((t=GC_lookup_pthread(pthread_id))==0)
Sleep(10);
#endif
result=pthread_join(pthread_id,retval);
if (0==result){
#ifdef GC_WIN32_PTHREADS
GC_thread t=GC_lookup_pthread(pthread_id);
if (NULL==t)ABORT("Thread not registered");
#endif
LOCK();
if ((t->flags&FINISHED)!=0){
GC_delete_gc_thread_no_free(t);
GC_INTERNAL_FREE(t);
}
UNLOCK();
}
#ifdef DEBUG_THREADS
GC_log_printf("thread %p(0x%lx)join with thread %p %s\n",
(void*)GC_PTHREAD_PTRVAL(pthread_self()),
(long)GetCurrentThreadId(),
(void*)GC_PTHREAD_PTRVAL(pthread_id),
result!=0?"failed":"succeeded");
#endif
return result;
}
GC_API int GC_pthread_create(pthread_t*new_thread,
GC_PTHREAD_CREATE_CONST pthread_attr_t*attr,
void*(*start_routine)(void*),void*arg)
{
int result;
struct start_info*si;
if (!EXPECT(parallel_initialized,TRUE))
GC_init_parallel();
GC_ASSERT(!GC_win32_dll_threads);
si=(struct start_info*)GC_malloc_uncollectable(
sizeof(struct start_info));
if (NULL==si)
return EAGAIN;
si->start_routine=start_routine;
si->arg=arg;
GC_dirty(si);
REACHABLE_AFTER_DIRTY(arg);
if (attr!=0&&
pthread_attr_getdetachstate(attr,&si->detached)
==PTHREAD_CREATE_DETACHED){
si->detached=TRUE;
}
#ifdef DEBUG_THREADS
GC_log_printf("About to create a thread from %p(0x%lx)\n",
(void*)GC_PTHREAD_PTRVAL(pthread_self()),
(long)GetCurrentThreadId());
#endif
set_need_to_lock();
result=pthread_create(new_thread,attr,GC_pthread_start,si);
if (result){
GC_free(si);
}
return(result);
}
STATIC void*GC_CALLBACK GC_pthread_start_inner(struct GC_stack_base*sb,
void*arg)
{
struct start_info*si=(struct start_info*)arg;
void*result;
void*(*start)(void*);
void*start_arg;
DWORD thread_id=GetCurrentThreadId();
pthread_t pthread_id=pthread_self();
GC_thread me;
DCL_LOCK_STATE;
#ifdef DEBUG_THREADS
GC_log_printf("thread %p(0x%x)starting...\n",
(void*)GC_PTHREAD_PTRVAL(pthread_id),(int)thread_id);
#endif
GC_ASSERT(!GC_win32_dll_threads);
LOCK();
me=GC_register_my_thread_inner(sb,thread_id);
SET_PTHREAD_MAP_CACHE(pthread_id,thread_id);
GC_ASSERT(me!=&first_thread);
me->pthread_id=pthread_id;
if (si->detached)me->flags|=DETACHED;
UNLOCK();
start=si->start_routine;
start_arg=si->arg;
GC_free(si);
pthread_cleanup_push(GC_thread_exit_proc,(void*)me);
result=(*start)(start_arg);
me->status=result;
GC_dirty(me);
pthread_cleanup_pop(1);
#ifdef DEBUG_THREADS
GC_log_printf("thread %p(0x%x)returned from start routine\n",
(void*)GC_PTHREAD_PTRVAL(pthread_id),(int)thread_id);
#endif
return(result);
}
STATIC void*GC_pthread_start(void*arg)
{
return GC_call_with_stack_base(GC_pthread_start_inner,arg);
}
STATIC void GC_thread_exit_proc(void*arg)
{
GC_thread me=(GC_thread)arg;
DCL_LOCK_STATE;
GC_ASSERT(!GC_win32_dll_threads);
#ifdef DEBUG_THREADS
GC_log_printf("thread %p(0x%lx)called pthread_exit()\n",
(void*)GC_PTHREAD_PTRVAL(pthread_self()),
(long)GetCurrentThreadId());
#endif
LOCK();
GC_wait_for_gc_completion(FALSE);
#if defined(THREAD_LOCAL_ALLOC)
GC_ASSERT(GC_getspecific(GC_thread_key)==&me->tlfs);
GC_destroy_thread_local(&(me->tlfs));
#endif
if (me->flags&DETACHED){
GC_delete_thread(GetCurrentThreadId());
} else {
me->flags|=FINISHED;
}
#if defined(THREAD_LOCAL_ALLOC)
GC_remove_specific(GC_thread_key);
#endif
UNLOCK();
}
#ifndef GC_NO_PTHREAD_SIGMASK
GC_API int GC_pthread_sigmask(int how,const sigset_t*set,
sigset_t*oset)
{
return pthread_sigmask(how,set,oset);
}
#endif
GC_API int GC_pthread_detach(pthread_t thread)
{
int result;
GC_thread t;
DCL_LOCK_STATE;
GC_ASSERT(!GC_win32_dll_threads);
while ((t=GC_lookup_pthread(thread))==NULL)
Sleep(10);
result=pthread_detach(thread);
if (result==0){
LOCK();
t->flags|=DETACHED;
if ((t->flags&FINISHED)!=0){
GC_delete_gc_thread_no_free(t);
GC_INTERNAL_FREE(t);
}
UNLOCK();
}
return result;
}
#elif!defined(GC_NO_THREADS_DISCOVERY)
#ifdef GC_INSIDE_DLL
GC_API
#else
#define GC_DllMain DllMain
#endif
BOOL WINAPI GC_DllMain(HINSTANCE inst GC_ATTR_UNUSED,ULONG reason,
LPVOID reserved GC_ATTR_UNUSED)
{
DWORD thread_id;
if (!GC_win32_dll_threads&&parallel_initialized)return TRUE;
switch (reason){
case DLL_THREAD_ATTACH:
#ifdef PARALLEL_MARK
if (GC_parallel){
break;
}
#endif
case DLL_PROCESS_ATTACH:
thread_id=GetCurrentThreadId();
if (parallel_initialized&&GC_main_thread!=thread_id){
#ifdef PARALLEL_MARK
ABORT("Cannot initialize parallel marker from DllMain");
#else
struct GC_stack_base sb;
#ifdef GC_ASSERTIONS
int sb_result=
#endif
GC_get_stack_base(&sb);
GC_ASSERT(sb_result==GC_SUCCESS);
GC_register_my_thread_inner(&sb,thread_id);
#endif
}
break;
case DLL_THREAD_DETACH:
GC_ASSERT(parallel_initialized);
if (GC_win32_dll_threads){
GC_delete_thread(GetCurrentThreadId());
}
break;
case DLL_PROCESS_DETACH:
if (GC_win32_dll_threads){
int i;
int my_max=(int)GC_get_max_thread_index();
for (i=0;i<=my_max;++i){
if (AO_load(&(dll_thread_table[i].tm.in_use)))
GC_delete_gc_thread_no_free(&dll_thread_table[i]);
}
GC_deinit();
}
break;
}
return TRUE;
}
#endif
GC_INNER void GC_init_parallel(void)
{
#if defined(THREAD_LOCAL_ALLOC)
GC_thread me;
DCL_LOCK_STATE;
#endif
if (parallel_initialized)return;
parallel_initialized=TRUE;
if (!GC_is_initialized)GC_init();
#if defined(CPPCHECK)&&!defined(GC_NO_THREADS_DISCOVERY)
GC_noop1((word)&GC_DllMain);
#endif
if (GC_win32_dll_threads){
set_need_to_lock();
}
#if defined(THREAD_LOCAL_ALLOC)
LOCK();
me=GC_lookup_thread_inner(GetCurrentThreadId());
CHECK_LOOKUP_MY_THREAD(me);
GC_init_thread_local(&me->tlfs);
UNLOCK();
#endif
}
#if defined(USE_PTHREAD_LOCKS)
GC_INNER void GC_lock(void)
{
pthread_mutex_lock(&GC_allocate_ml);
}
#endif
#if defined(THREAD_LOCAL_ALLOC)
GC_INNER void GC_mark_thread_local_free_lists(void)
{
int i;
GC_thread p;
for (i=0;i < THREAD_TABLE_SZ;++i){
for (p=GC_threads[i];0!=p;p=p->tm.next){
if (!KNOWN_FINISHED(p)){
#ifdef DEBUG_THREADS
GC_log_printf("Marking thread locals for 0x%x\n",(int)p->id);
#endif
GC_mark_thread_local_fls_for(&(p->tlfs));
}
}
}
}
#if defined(GC_ASSERTIONS)
void GC_check_tls(void)
{
int i;
GC_thread p;
for (i=0;i < THREAD_TABLE_SZ;++i){
for (p=GC_threads[i];0!=p;p=p->tm.next){
if (!KNOWN_FINISHED(p))
GC_check_tls_for(&(p->tlfs));
}
}
#if defined(USE_CUSTOM_SPECIFIC)
if (GC_thread_key!=0)
GC_check_tsd_marks(GC_thread_key);
#endif
}
#endif
#endif
#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
#endif
#endif
#ifndef GC_PTHREAD_START_STANDALONE
#if defined(__GNUC__)&&defined(__linux__)
#undef __EXCEPTIONS
#endif
#if defined(GC_PTHREADS)&&!defined(GC_WIN32_THREADS)
#include <pthread.h>
#include <sched.h>
GC_INNER_PTHRSTART void*GC_CALLBACK GC_inner_start_routine(
struct GC_stack_base*sb,void*arg)
{
void*(*start)(void*);
void*start_arg;
void*result;
volatile GC_thread me=
GC_start_rtn_prepare_thread(&start,&start_arg,sb,arg);
#ifndef NACL
pthread_cleanup_push(GC_thread_exit_proc,me);
#endif
result=(*start)(start_arg);
#if defined(DEBUG_THREADS)&&!defined(GC_PTHREAD_START_STANDALONE)
GC_log_printf("Finishing thread %p\n",(void*)pthread_self());
#endif
me->status=result;
GC_end_stubborn_change(me);
#ifndef NACL
pthread_cleanup_pop(1);
#endif
return result;
}
#endif
#endif
#ifndef GC_NO_THREAD_REDIRECTS
#define GC_PTHREAD_REDIRECTS_ONLY
#ifndef GC_PTHREAD_REDIRECTS_H
#define GC_PTHREAD_REDIRECTS_H
#if defined(GC_H)&&defined(GC_PTHREADS)
#ifndef GC_PTHREAD_REDIRECTS_ONLY
#include <pthread.h>
#ifndef GC_NO_DLOPEN
#include <dlfcn.h>
#endif
#ifndef GC_NO_PTHREAD_SIGMASK
#include <signal.h>
#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*,int);
#endif
#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,const sigset_t*,
sigset_t*);
#endif
#endif
#ifndef GC_PTHREAD_CREATE_CONST
#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*);
GC_API int GC_pthread_join(pthread_t,void**);
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
}
#endif
#endif
#if!defined(GC_NO_THREAD_REDIRECTS)&&!defined(GC_USE_LD_WRAP)
#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
#endif
#endif
#endif