From f5c4671bfbad96bf346bd7e9a21fc4317b4959df Mon Sep 17 00:00:00 2001
From: Indrajith K L
Date: Sat, 3 Dec 2022 17:00:20 +0530
Subject: Adds most of the tools

---
 v_windows/v/thirdparty/libgc/gc.h | 1081 +++++++++++++++++++++++++++++++++++++
 1 file changed, 1081 insertions(+)
 create mode 100644 v_windows/v/thirdparty/libgc/gc.h

(limited to 'v_windows/v/thirdparty/libgc/gc.h')

diff --git a/v_windows/v/thirdparty/libgc/gc.h b/v_windows/v/thirdparty/libgc/gc.h
new file mode 100644
index 0000000..d0646f5
--- /dev/null
+++ b/v_windows/v/thirdparty/libgc/gc.h
@@ -0,0 +1,1081 @@
+/*
+ * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
+ * Copyright (c) 1991-1995 by Xerox Corporation.  All rights reserved.
+ * Copyright 1996-1999 by Silicon Graphics.  All rights reserved.
+ * Copyright 1999 by Hewlett-Packard Company.  All rights reserved.
+ * Copyright (C) 2007 Free Software Foundation, Inc
+ * Copyright (c) 2000-2011 by Hewlett-Packard Development Company.
+ * Copyright (c) 2009-2020 Ivan Maidanski
+ *
+ * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
+ * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
+ *
+ * Permission is hereby granted to use or copy this program
+ * for any purpose,  provided the above notices are retained on all copies.
+ * Permission to modify the code and to distribute modified code is granted,
+ * provided the above notices are retained, and a notice that the code was
+ * modified is included with the above copyright notice.
+ */
+
+#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
+#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
-- 
cgit v1.2.3