File removals.

blitz.mod/bdwgc/include/config.h.in

@@ -1,259 +0,0 @@
-/* include/config.h.in.  Generated from configure.ac by autoheader.  */
-
-/* Define to recognise all pointers to the interior of objects. */
-#undef ALL_INTERIOR_POINTERS
-
-/* AO load, store and/or test-and-set primitives are implemented in
-   libatomic_ops using locks. */
-#undef BASE_ATOMIC_OPS_EMULATED
-
-/* Erroneously cleared dirty bits checking. Use only for debugging of the
-   incremental collector. */
-#undef CHECKSUMS
-
-/* See doc/README.macros. */
-#undef DARWIN_DONT_PARSE_STACK
-
-/* Define to force debug headers on all objects. */
-#undef DBG_HDRS_ALL
-
-/* Define to enable eCos target support. */
-#undef ECOS
-
-/* Wine getenv may not return NULL for missing entry. */
-#undef EMPTY_GETENV_RESULTS
-
-/* Define to enable alternative finalization interface. */
-#undef ENABLE_DISCLAIM
-
-/* Define to enable internal debug assertions. */
-#undef GC_ASSERTIONS
-
-/* Define to enable atomic uncollectible allocation. */
-#undef GC_ATOMIC_UNCOLLECTABLE
-
-/* Use C11 (GCC) atomic intrinsics instead of libatomic_ops primitives. */
-#undef GC_BUILTIN_ATOMIC
-
-/* Define to build dynamic libraries with only API symbols exposed. */
-#undef GC_DLL
-
-/* Skip the initial guess of data root sets. */
-#undef GC_DONT_REGISTER_MAIN_STATIC_DATA
-
-/* Define to turn on GC_suspend_thread support. */
-#undef GC_ENABLE_SUSPEND_THREAD
-
-/* Define to include support for gcj. */
-#undef GC_GCJ_SUPPORT
-
-/* Define if backtrace information is supported. */
-#undef GC_HAVE_BUILTIN_BACKTRACE
-
-/* Enable Win32 DllMain-based approach of threads registering. */
-#undef GC_INSIDE_DLL
-
-/* Missing execinfo.h header. */
-#undef GC_MISSING_EXECINFO_H
-
-/* Missing sigsetjmp function. */
-#undef GC_NO_SIGSETJMP
-
-/* Disable threads discovery in GC. */
-#undef GC_NO_THREADS_DISCOVERY
-
-/* Read environment variables from the GC 'env' file. */
-#undef GC_READ_ENV_FILE
-
-/* Define to support platform-specific threads. */
-#undef GC_THREADS
-
-/* Explicitly prefix exported/imported WINAPI symbols with '_'. */
-#undef GC_UNDERSCORE_STDCALL
-
-/* Force the GC to use signals based on SIGRTMIN+k. */
-#undef GC_USESIGRT_SIGNALS
-
-/* See doc/README.macros. */
-#undef GC_USE_DLOPEN_WRAP
-
-/* The major version number of this GC release. */
-#undef GC_VERSION_MAJOR
-
-/* The micro version number of this GC release. */
-#undef GC_VERSION_MICRO
-
-/* The minor version number of this GC release. */
-#undef GC_VERSION_MINOR
-
-/* Define to support pthreads-win32 or winpthreads. */
-#undef GC_WIN32_PTHREADS
-
-/* Define to install pthread_atfork() handlers by default. */
-#undef HANDLE_FORK
-
-/* Define to use 'dladdr' function. */
-#undef HAVE_DLADDR
-
-/* Define to 1 if you have the <dlfcn.h> header file. */
-#undef HAVE_DLFCN_H
-
-/* Define to 1 if you have the `dl_iterate_phdr' function. */
-#undef HAVE_DL_ITERATE_PHDR
-
-/* Define to 1 if you have the <inttypes.h> header file. */
-#undef HAVE_INTTYPES_H
-
-/* libatomic_ops AO_or primitive implementation is lock-free. */
-#undef HAVE_LOCKFREE_AO_OR
-
-/* Define to 1 if you have the <memory.h> header file. */
-#undef HAVE_MEMORY_H
-
-/* Define to 1 if you have the <stdint.h> header file. */
-#undef HAVE_STDINT_H
-
-/* Define to 1 if you have the <stdlib.h> header file. */
-#undef HAVE_STDLIB_H
-
-/* Define to 1 if you have the <strings.h> header file. */
-#undef HAVE_STRINGS_H
-
-/* Define to 1 if you have the <string.h> header file. */
-#undef HAVE_STRING_H
-
-/* Define to 1 if you have the <sys/stat.h> header file. */
-#undef HAVE_SYS_STAT_H
-
-/* Define to 1 if you have the <sys/types.h> header file. */
-#undef HAVE_SYS_TYPES_H
-
-/* Define to 1 if you have the <unistd.h> header file. */
-#undef HAVE_UNISTD_H
-
-/* Do not define DYNAMIC_LOADING even if supported (i.e., build the collector
-   with disabled tracing of dynamic library data roots). */
-#undef IGNORE_DYNAMIC_LOADING
-
-/* See doc/README.macros. */
-#undef JAVA_FINALIZATION
-
-/* Define to save back-pointers in debugging headers. */
-#undef KEEP_BACK_PTRS
-
-/* Define to optimize for large heaps or root sets. */
-#undef LARGE_CONFIG
-
-/* Define to the sub-directory where libtool stores uninstalled libraries. */
-#undef LT_OBJDIR
-
-/* See doc/README.macros. */
-#undef MAKE_BACK_GRAPH
-
-/* Number of GC cycles to wait before unmapping an unused block. */
-#undef MUNMAP_THRESHOLD
-
-/* Define to not use system clock (cross compiling). */
-#undef NO_CLOCK
-
-/* Disable debugging, like GC_dump and its callees. */
-#undef NO_DEBUGGING
-
-/* Define to make the collector not allocate executable memory by default. */
-#undef NO_EXECUTE_PERMISSION
-
-/* Missing getcontext function. */
-#undef NO_GETCONTEXT
-
-/* Prohibit installation of pthread_atfork() handlers. */
-#undef NO_HANDLE_FORK
-
-/* Name of package */
-#undef PACKAGE
-
-/* Define to the address where bug reports for this package should be sent. */
-#undef PACKAGE_BUGREPORT
-
-/* Define to the full name of this package. */
-#undef PACKAGE_NAME
-
-/* Define to the full name and version of this package. */
-#undef PACKAGE_STRING
-
-/* Define to the one symbol short name of this package. */
-#undef PACKAGE_TARNAME
-
-/* Define to the home page for this package. */
-#undef PACKAGE_URL
-
-/* Define to the version of this package. */
-#undef PACKAGE_VERSION
-
-/* Define to enable parallel marking. */
-#undef PARALLEL_MARK
-
-/* If defined, redirect free to this function. */
-#undef REDIRECT_FREE
-
-/* If defined, redirect malloc to this function. */
-#undef REDIRECT_MALLOC
-
-/* If defined, redirect GC_realloc to this function. */
-#undef REDIRECT_REALLOC
-
-/* The number of caller frames saved when allocating with the debugging API.
-   */
-#undef SAVE_CALL_COUNT
-
-/* Shorten the headers to minimize object size at the expense of checking for
-   writes past the end (see doc/README.macros). */
-#undef SHORT_DBG_HDRS
-
-/* Define to tune the collector for small heap sizes. */
-#undef SMALL_CONFIG
-
-/* See the comment in gcconfig.h. */
-#undef SOLARIS25_PROC_VDB_BUG_FIXED
-
-/* Define to 1 if you have the ANSI C header files. */
-#undef STDC_HEADERS
-
-/* Define to work around a Solaris 5.3 bug (see dyn_load.c). */
-#undef SUNOS53_SHARED_LIB
-
-/* Define to enable thread-local allocation optimization. */
-#undef THREAD_LOCAL_ALLOC
-
-/* Use Unicode (W) variant of Win32 API instead of ASCII (A) one. */
-#undef UNICODE
-
-/* Define to use of compiler-support for thread-local variables. */
-#undef USE_COMPILER_TLS
-
-/* Define to use mmap instead of sbrk to expand the heap. */
-#undef USE_MMAP
-
-/* Define to return memory to OS with munmap calls (see doc/README.macros). */
-#undef USE_MUNMAP
-
-/* Define to use Win32 VirtualAlloc (instead of sbrk or mmap) to expand the
-   heap. */
-#undef USE_WINALLOC
-
-/* Version number of package */
-#undef VERSION
-
-/* The POSIX feature macro. */
-#undef _POSIX_C_SOURCE
-
-/* Indicates the use of pthreads (NetBSD). */
-#undef _PTHREADS
-
-/* Required define if using POSIX threads. */
-#undef _REENTRANT
-
-/* Define to `__inline__' or `__inline' if that's what the C compiler
-   calls it, or to nothing if 'inline' is not supported under any name.  */
-#ifndef __cplusplus
-#undef inline
-#endif

blitz.mod/bdwgc/include/extra/gc.h

@@ -1,2 +0,0 @@
-/* This file is installed for backward compatibility. */
-#include <gc/gc.h>

blitz.mod/bdwgc/include/extra/gc_cpp.h

@@ -1,2 +0,0 @@
-/* This file is installed for backward compatibility. */
-#include <gc/gc_cpp.h>

blitz.mod/bdwgc/include/gc_alloc_ptrs.h

@@ -1,40 +0,0 @@
-/*
- * Copyright (c) 1996-1998 by Silicon Graphics.  All rights reserved.
- *
- * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
- * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
- *
- * Permission is hereby granted to use or copy this program
- * for any purpose,  provided the above notices are retained on all copies.
- * Permission to modify the code and to distribute modified code is granted,
- * provided the above notices are retained, and a notice that the code was
- * modified is included with the above copyright notice.
- */
-
-/* This file should never be included by clients directly.      */
-
-#ifndef GC_ALLOC_PTRS_H
-#define GC_ALLOC_PTRS_H
-
-#include "gc.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
-  } /* extern "C" */
-#endif
-
-#endif /* GC_ALLOC_PTRS_H */

blitz.mod/bdwgc/include/gc_config_macros.h

@@ -1,454 +0,0 @@
-/*
- * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
- * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
- * Copyright (c) 1998 by Fergus Henderson.  All rights reserved.
- * Copyright (c) 2000-2009 by Hewlett-Packard Development Company.
- * All rights reserved.
- * Copyright (c) 2008-2020 Ivan Maidanski
- *
- * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
- * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
- *
- * Permission is hereby granted to use or copy this program
- * for any purpose,  provided the above notices are retained on all copies.
- * Permission to modify the code and to distribute modified code is granted,
- * provided the above notices are retained, and a notice that the code was
- * modified is included with the above copyright notice.
- */
-
-/* This should never be included directly; it is included only from gc.h. */
-/* We separate it only to make gc.h more suitable as documentation.       */
-#if defined(GC_H)
-
-/* Convenient internal macro to test version of GCC.    */
-#if defined(__GNUC__) && defined(__GNUC_MINOR__)
-# define GC_GNUC_PREREQ(major, minor) \
-            ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((major) << 16) + (minor))
-#else
-# define GC_GNUC_PREREQ(major, minor) 0 /* FALSE */
-#endif
-
-/* Some tests for old macros.  These violate our namespace rules and    */
-/* will disappear shortly.  Use the GC_ names.                          */
-#if defined(SOLARIS_THREADS) || defined(_SOLARIS_THREADS) \
-    || defined(_SOLARIS_PTHREADS) || defined(GC_SOLARIS_PTHREADS)
-  /* We no longer support old style Solaris threads.            */
-  /* GC_SOLARIS_THREADS now means pthreads.                     */
-# ifndef GC_SOLARIS_THREADS
-#   define GC_SOLARIS_THREADS
-# endif
-#endif
-#if defined(IRIX_THREADS)
-# define GC_IRIX_THREADS
-#endif
-#if defined(DGUX_THREADS) && !defined(GC_DGUX386_THREADS)
-# define GC_DGUX386_THREADS
-#endif
-#if defined(AIX_THREADS)
-# define GC_AIX_THREADS
-#endif
-#if defined(HPUX_THREADS)
-# define GC_HPUX_THREADS
-#endif
-#if defined(OSF1_THREADS)
-# define GC_OSF1_THREADS
-#endif
-#if defined(LINUX_THREADS)
-# define GC_LINUX_THREADS
-#endif
-#if defined(WIN32_THREADS)
-# define GC_WIN32_THREADS
-#endif
-#if defined(RTEMS_THREADS)
-# define GC_RTEMS_PTHREADS
-#endif
-#if defined(USE_LD_WRAP)
-# define GC_USE_LD_WRAP
-#endif
-
-#if defined(GC_WIN32_PTHREADS) && !defined(GC_WIN32_THREADS)
-  /* Using pthreads-win32 library (or other Win32 implementation).  */
-# define GC_WIN32_THREADS
-#endif
-
-#if defined(GC_AIX_THREADS) || defined(GC_DARWIN_THREADS) \
-    || defined(GC_DGUX386_THREADS) || defined(GC_FREEBSD_THREADS) \
-    || defined(GC_HPUX_THREADS) \
-    || defined(GC_IRIX_THREADS) || defined(GC_LINUX_THREADS) \
-    || defined(GC_NETBSD_THREADS) || defined(GC_OPENBSD_THREADS) \
-    || defined(GC_OSF1_THREADS) || defined(GC_SOLARIS_THREADS) \
-    || defined(GC_WIN32_THREADS) || defined(GC_RTEMS_PTHREADS)
-# ifndef GC_THREADS
-#   define GC_THREADS
-# endif
-#elif defined(GC_THREADS)
-# if defined(__linux__)
-#   define GC_LINUX_THREADS
-# elif defined(_PA_RISC1_1) || defined(_PA_RISC2_0) || defined(hppa) \
-       || defined(__HPPA) || (defined(__ia64) && defined(_HPUX_SOURCE))
-#   define GC_HPUX_THREADS
-# elif defined(__HAIKU__)
-#   define GC_HAIKU_THREADS
-# elif defined(__OpenBSD__)
-#   define GC_OPENBSD_THREADS
-# elif defined(__DragonFly__) || defined(__FreeBSD_kernel__) \
-       || (defined(__FreeBSD__) && !defined(SN_TARGET_ORBIS))
-#   define GC_FREEBSD_THREADS
-# elif defined(__NetBSD__)
-#   define GC_NETBSD_THREADS
-# elif defined(__alpha) || defined(__alpha__) /* && !Linux && !xBSD */
-#   define GC_OSF1_THREADS
-# elif (defined(mips) || defined(__mips) || defined(_mips)) \
-        && !(defined(nec_ews) || defined(_nec_ews) \
-             || defined(ultrix) || defined(__ultrix))
-#   define GC_IRIX_THREADS
-# elif defined(__sparc) /* && !Linux */ \
-       || ((defined(sun) || defined(__sun)) \
-           && (defined(i386) || defined(__i386__) \
-               || defined(__amd64) || defined(__amd64__)))
-#   define GC_SOLARIS_THREADS
-# elif defined(__APPLE__) && defined(__MACH__)
-#   define GC_DARWIN_THREADS
-# endif
-# if defined(DGUX) && (defined(i386) || defined(__i386__))
-#   define GC_DGUX386_THREADS
-# endif
-# if defined(_AIX)
-#   define GC_AIX_THREADS
-# endif
-# if (defined(_WIN32) || defined(_MSC_VER) || defined(__BORLANDC__) \
-      || defined(__CYGWIN32__) || defined(__CYGWIN__) || defined(__CEGCC__) \
-      || defined(_WIN32_WCE) || defined(__MINGW32__)) \
-     && !defined(GC_WIN32_THREADS)
-    /* Either posix or native Win32 threads. */
-#   define GC_WIN32_THREADS
-# endif
-# if defined(__rtems__) && (defined(i386) || defined(__i386__))
-#   define GC_RTEMS_PTHREADS
-# endif
-#endif /* GC_THREADS */
-
-#undef GC_PTHREADS
-#if (!defined(GC_WIN32_THREADS) || defined(GC_WIN32_PTHREADS) \
-     || defined(__CYGWIN32__) || defined(__CYGWIN__)) && defined(GC_THREADS) \
-    && !defined(NN_PLATFORM_CTR) && !defined(NN_BUILD_TARGET_PLATFORM_NX)
-  /* Posix threads. */
-# define GC_PTHREADS
-#endif
-
-#if !defined(_PTHREADS) && defined(GC_NETBSD_THREADS)
-# define _PTHREADS
-#endif
-
-#if defined(GC_DGUX386_THREADS) && !defined(_POSIX4A_DRAFT10_SOURCE)
-# define _POSIX4A_DRAFT10_SOURCE 1
-#endif
-
-#if !defined(_REENTRANT) && defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS)
-  /* Better late than never.  This fails if system headers that depend  */
-  /* on this were previously included.                                  */
-# define _REENTRANT 1
-#endif
-
-#define __GC
-#if !defined(_WIN32_WCE) || defined(__GNUC__)
-# include <stddef.h>
-# if defined(__MINGW32__) && !defined(_WIN32_WCE)
-#   include <stdint.h>
-    /* We mention uintptr_t.                                            */
-    /* Perhaps this should be included in pure msft environments        */
-    /* as well?                                                         */
-# endif
-#else /* _WIN32_WCE */
-  /* Yet more kludges for WinCE.        */
-# include <stdlib.h> /* size_t is defined here */
-# ifndef _PTRDIFF_T_DEFINED
-    /* ptrdiff_t is not defined */
-#   define _PTRDIFF_T_DEFINED
-    typedef long ptrdiff_t;
-# endif
-#endif /* _WIN32_WCE */
-
-#if !defined(GC_NOT_DLL) && !defined(GC_DLL) \
-    && ((defined(_DLL) && !defined(__GNUC__)) \
-        || (defined(DLL_EXPORT) && defined(GC_BUILD)))
-# define GC_DLL
-#endif
-
-#if defined(GC_DLL) && !defined(GC_API)
-
-# if defined(__CEGCC__)
-#   if defined(GC_BUILD)
-#     define GC_API __declspec(dllexport)
-#   else
-#     define GC_API __declspec(dllimport)
-#   endif
-
-# elif defined(__MINGW32__)
-#   if defined(__cplusplus) && defined(GC_BUILD)
-#     define GC_API extern __declspec(dllexport)
-#   elif defined(GC_BUILD) || defined(__MINGW32_DELAY_LOAD__)
-#     define GC_API __declspec(dllexport)
-#   else
-#     define GC_API extern __declspec(dllimport)
-#   endif
-
-# elif defined(_MSC_VER) || defined(__DMC__) || defined(__BORLANDC__) \
-        || defined(__CYGWIN__)
-#   ifdef GC_BUILD
-#     define GC_API extern __declspec(dllexport)
-#   else
-#     define GC_API __declspec(dllimport)
-#   endif
-
-# elif defined(__WATCOMC__)
-#   ifdef GC_BUILD
-#     define GC_API extern __declspec(dllexport)
-#   else
-#     define GC_API extern __declspec(dllimport)
-#   endif
-
-# elif defined(__SYMBIAN32__)
-#   ifdef GC_BUILD
-#     define GC_API extern EXPORT_C
-#   else
-#     define GC_API extern IMPORT_C
-#   endif
-
-# elif defined(__GNUC__)
-    /* Only matters if used in conjunction with -fvisibility=hidden option. */
-#   if defined(GC_BUILD) && !defined(GC_NO_VISIBILITY) \
-            && (GC_GNUC_PREREQ(4, 0) || defined(GC_VISIBILITY_HIDDEN_SET))
-#     define GC_API extern __attribute__((__visibility__("default")))
-#   endif
-# endif
-#endif /* GC_DLL */
-
-#ifndef GC_API
-# define GC_API extern
-#endif
-
-#ifndef GC_CALL
-# define GC_CALL
-#endif
-
-#ifndef GC_CALLBACK
-# define GC_CALLBACK GC_CALL
-#endif
-
-#ifndef GC_ATTR_MALLOC
-  /* 'malloc' attribute should be used for all malloc-like functions    */
-  /* (to tell the compiler that a function may be treated as if any     */
-  /* non-NULL pointer it returns cannot alias any other pointer valid   */
-  /* when the function returns).  If the client code violates this rule */
-  /* by using custom GC_oom_func then define GC_OOM_FUNC_RETURNS_ALIAS. */
-# ifdef GC_OOM_FUNC_RETURNS_ALIAS
-#   define GC_ATTR_MALLOC /* empty */
-# elif GC_GNUC_PREREQ(3, 1)
-#   define GC_ATTR_MALLOC __attribute__((__malloc__))
-# elif defined(_MSC_VER) && (_MSC_VER >= 1900) && !defined(__EDG__)
-#   define GC_ATTR_MALLOC \
-                __declspec(allocator) __declspec(noalias) __declspec(restrict)
-# elif defined(_MSC_VER) && _MSC_VER >= 1400
-#   define GC_ATTR_MALLOC __declspec(noalias) __declspec(restrict)
-# else
-#   define GC_ATTR_MALLOC
-# endif
-#endif
-
-#ifndef GC_ATTR_ALLOC_SIZE
-  /* 'alloc_size' attribute improves __builtin_object_size correctness. */
-# undef GC_ATTR_CALLOC_SIZE
-# ifdef __clang__
-#   if __has_attribute(__alloc_size__)
-#     define GC_ATTR_ALLOC_SIZE(argnum) __attribute__((__alloc_size__(argnum)))
-#     define GC_ATTR_CALLOC_SIZE(n, s) __attribute__((__alloc_size__(n, s)))
-#   else
-#     define GC_ATTR_ALLOC_SIZE(argnum) /* empty */
-#   endif
-# elif GC_GNUC_PREREQ(4, 3) && !defined(__ICC)
-#   define GC_ATTR_ALLOC_SIZE(argnum) __attribute__((__alloc_size__(argnum)))
-#   define GC_ATTR_CALLOC_SIZE(n, s) __attribute__((__alloc_size__(n, s)))
-# else
-#   define GC_ATTR_ALLOC_SIZE(argnum) /* empty */
-# endif
-#endif
-
-#ifndef GC_ATTR_CALLOC_SIZE
-# define GC_ATTR_CALLOC_SIZE(n, s) /* empty */
-#endif
-
-#ifndef GC_ATTR_NONNULL
-# if GC_GNUC_PREREQ(4, 0)
-#   define GC_ATTR_NONNULL(argnum) __attribute__((__nonnull__(argnum)))
-# else
-#   define GC_ATTR_NONNULL(argnum) /* empty */
-# endif
-#endif
-
-#ifndef GC_ATTR_CONST
-# if GC_GNUC_PREREQ(4, 0)
-#   define GC_ATTR_CONST __attribute__((__const__))
-# else
-#   define GC_ATTR_CONST /* empty */
-# endif
-#endif
-
-#ifndef GC_ATTR_DEPRECATED
-# ifdef GC_BUILD
-#   undef GC_ATTR_DEPRECATED
-#   define GC_ATTR_DEPRECATED /* empty */
-# elif GC_GNUC_PREREQ(4, 0)
-#   define GC_ATTR_DEPRECATED __attribute__((__deprecated__))
-# elif defined(_MSC_VER) && _MSC_VER >= 1200
-#   define GC_ATTR_DEPRECATED __declspec(deprecated)
-# else
-#   define GC_ATTR_DEPRECATED /* empty */
-# endif
-#endif
-
-#if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION >= 720
-# define GC_ADD_CALLER
-# define GC_RETURN_ADDR (GC_word)__return_address
-#endif
-
-#if defined(__linux__) || defined(__GLIBC__)
-# if !defined(__native_client__)
-#   include <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 /* GLIBC */
-
-#if defined(_MSC_VER) && _MSC_VER >= 1200 /* version 12.0+ (MSVC 6.0+) */ \
-        && !defined(_AMD64_) && !defined(_M_X64) && !defined(_WIN32_WCE) \
-        && !defined(GC_HAVE_NO_BUILTIN_BACKTRACE) \
-        && !defined(GC_HAVE_BUILTIN_BACKTRACE)
-# define GC_HAVE_BUILTIN_BACKTRACE
-#endif
-
-#if defined(GC_HAVE_BUILTIN_BACKTRACE) && !defined(GC_CAN_SAVE_CALL_STACKS)
-# define GC_CAN_SAVE_CALL_STACKS
-#endif
-
-#if defined(__sparc__)
-# define GC_CAN_SAVE_CALL_STACKS
-#endif
-
-/* If we're on a platform on which we can't save call stacks, but       */
-/* gcc is normally used, we go ahead and define GC_ADD_CALLER.          */
-/* We make this decision independent of whether gcc is actually being   */
-/* used, in order to keep the interface consistent, and allow mixing    */
-/* of compilers.                                                        */
-/* This may also be desirable if it is possible but expensive to        */
-/* retrieve the call chain.                                             */
-#if (defined(__linux__) || defined(__DragonFly__) || defined(__FreeBSD__) \
-     || defined(__FreeBSD_kernel__) || defined(__HAIKU__) \
-     || defined(__NetBSD__) || defined(__OpenBSD__) \
-     || defined(HOST_ANDROID) || defined(__ANDROID__)) \
-    && !defined(GC_CAN_SAVE_CALL_STACKS)
-# define GC_ADD_CALLER
-# if GC_GNUC_PREREQ(2, 95)
-    /* gcc knows how to retrieve return address, but we don't know      */
-    /* how to generate call stacks.                                     */
-#   define GC_RETURN_ADDR (GC_word)__builtin_return_address(0)
-#   if GC_GNUC_PREREQ(4, 0) && (defined(__i386__) || defined(__amd64__) \
-                        || defined(__x86_64__) /* and probably others... */)
-#     define GC_HAVE_RETURN_ADDR_PARENT
-#     define GC_RETURN_ADDR_PARENT \
-        (GC_word)__builtin_extract_return_addr(__builtin_return_address(1))
-#   endif
-# else
-    /* Just pass 0 for gcc compatibility.       */
-#   define GC_RETURN_ADDR 0
-# endif
-#endif /* !GC_CAN_SAVE_CALL_STACKS */
-
-#ifdef GC_PTHREADS
-
-# if (defined(GC_DARWIN_THREADS) || defined(GC_WIN32_PTHREADS) \
-      || defined(__native_client__) || defined(GC_RTEMS_PTHREADS)) \
-      && !defined(GC_NO_DLOPEN)
-    /* Either there is no dlopen() or we do not need to intercept it.   */
-#   define GC_NO_DLOPEN
-# endif
-
-# if (defined(GC_DARWIN_THREADS) || defined(GC_WIN32_PTHREADS) \
-      || defined(GC_OPENBSD_THREADS) || defined(__native_client__)) \
-     && !defined(GC_NO_PTHREAD_SIGMASK)
-    /* Either there is no pthread_sigmask() or no need to intercept it. */
-#   define GC_NO_PTHREAD_SIGMASK
-# endif
-
-# if defined(__native_client__)
-    /* At present, NaCl pthread_create() prototype does not have        */
-    /* "const" for its "attr" argument; also, NaCl pthread_exit() one   */
-    /* does not have "noreturn" attribute.                              */
-#   ifndef GC_PTHREAD_CREATE_CONST
-#     define GC_PTHREAD_CREATE_CONST /* empty */
-#   endif
-#   ifndef GC_HAVE_PTHREAD_EXIT
-#     define GC_HAVE_PTHREAD_EXIT
-#     define GC_PTHREAD_EXIT_ATTRIBUTE /* empty */
-#   endif
-# endif
-
-# if !defined(GC_HAVE_PTHREAD_EXIT) \
-     && !defined(HOST_ANDROID) && !defined(__ANDROID__) \
-     && (defined(GC_LINUX_THREADS) || defined(GC_SOLARIS_THREADS))
-#   define GC_HAVE_PTHREAD_EXIT
-    /* Intercept pthread_exit on Linux and Solaris.     */
-#   if GC_GNUC_PREREQ(2, 7)
-#     define GC_PTHREAD_EXIT_ATTRIBUTE __attribute__((__noreturn__))
-#   elif defined(__NORETURN) /* used in Solaris */
-#     define GC_PTHREAD_EXIT_ATTRIBUTE __NORETURN
-#   else
-#     define GC_PTHREAD_EXIT_ATTRIBUTE /* empty */
-#   endif
-# endif
-
-# if (!defined(GC_HAVE_PTHREAD_EXIT) || defined(__native_client__)) \
-     && !defined(GC_NO_PTHREAD_CANCEL)
-    /* Either there is no pthread_cancel() or no need to intercept it.  */
-#   define GC_NO_PTHREAD_CANCEL
-# endif
-
-#endif /* GC_PTHREADS */
-
-#ifdef __cplusplus
-
-#ifndef GC_ATTR_EXPLICIT
-# if __cplusplus >= 201103L && !defined(__clang__) || _MSVC_LANG >= 201103L \
-     || defined(CPPCHECK)
-#   define GC_ATTR_EXPLICIT explicit
-# else
-#   define GC_ATTR_EXPLICIT /* empty */
-# endif
-#endif
-
-#ifndef GC_NOEXCEPT
-# if defined(__DMC__) || (defined(__BORLANDC__) \
-        && (defined(_RWSTD_NO_EXCEPTIONS) || defined(_RWSTD_NO_EX_SPEC))) \
-     || (defined(_MSC_VER) && defined(_HAS_EXCEPTIONS) && !_HAS_EXCEPTIONS) \
-     || (defined(__WATCOMC__) && !defined(_CPPUNWIND))
-#   define GC_NOEXCEPT /* empty */
-#   ifndef GC_NEW_ABORTS_ON_OOM
-#     define GC_NEW_ABORTS_ON_OOM
-#   endif
-# elif __cplusplus >= 201103L || _MSVC_LANG >= 201103L
-#   define GC_NOEXCEPT noexcept
-# else
-#   define GC_NOEXCEPT throw()
-# endif
-#endif
-
-#endif /* __cplusplus */
-
-#endif

blitz.mod/bdwgc/include/gc_version.h

@@ -1,47 +0,0 @@
-/*
- * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
- * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
- * Copyright (c) 1998 by Fergus Henderson.  All rights reserved.
- * Copyright (c) 2000-2009 by Hewlett-Packard Development Company.
- * All rights reserved.
- *
- * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
- * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
- *
- * Permission is hereby granted to use or copy this program
- * for any purpose,  provided the above notices are retained on all copies.
- * Permission to modify the code and to distribute modified code is granted,
- * provided the above notices are retained, and a notice that the code was
- * modified is included with the above copyright notice.
- */
-
-/* This should never be included directly; it is included only from gc.h. */
-#if defined(GC_H)
-
-/* The policy regarding version numbers: development code has odd       */
-/* "minor" number (and "micro" part is 0); when development is finished */
-/* and a release is prepared, "minor" number is incremented (keeping    */
-/* "micro" number still zero), whenever a defect is fixed a new release */
-/* is prepared incrementing "micro" part to odd value (the most stable  */
-/* release has the biggest "micro" number).                             */
-
-/* The version here should match that in configure/configure.ac */
-/* Eventually this one may become unnecessary.  For now we need */
-/* it to keep the old-style build process working.              */
-#define GC_TMP_VERSION_MAJOR 8
-#define GC_TMP_VERSION_MINOR 1
-#define GC_TMP_VERSION_MICRO 0 /* 8.1.0 */
-
-#ifdef GC_VERSION_MAJOR
-# if GC_TMP_VERSION_MAJOR != GC_VERSION_MAJOR \
-     || GC_TMP_VERSION_MINOR != GC_VERSION_MINOR \
-     || GC_TMP_VERSION_MICRO != GC_VERSION_MICRO
-#   error Inconsistent version info.  Check README.md, include/gc_version.h and configure.ac.
-# endif
-#else
-# define GC_VERSION_MAJOR GC_TMP_VERSION_MAJOR
-# define GC_VERSION_MINOR GC_TMP_VERSION_MINOR
-# define GC_VERSION_MICRO GC_TMP_VERSION_MICRO
-#endif /* !GC_VERSION_MAJOR */
-
-#endif

blitz.mod/bdwgc/include/leak_detector.h

@@ -1,68 +0,0 @@
-/*
- * Copyright (c) 2000-2011 by Hewlett-Packard Development Company.
- * All rights reserved.
- *
- * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
- * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
- *
- * Permission is hereby granted to use or copy this program
- * for any purpose,  provided the above notices are retained on all copies.
- * Permission to modify the code and to distribute modified code is granted,
- * provided the above notices are retained, and a notice that the code was
- * modified is included with the above copyright notice.
- */
-
-#ifndef GC_LEAK_DETECTOR_H
-#define GC_LEAK_DETECTOR_H
-
-/* Include leak_detector.h (e.g., via GCC --include directive)  */
-/* to turn BoehmGC into a Leak Detector.                        */
-
-#ifndef GC_DEBUG
-# define GC_DEBUG
-#endif
-#include "gc.h"
-
-#ifndef GC_DONT_INCLUDE_STDLIB
-  /* We ensure stdlib.h and string.h are included before        */
-  /* redirecting malloc() and the accompanying functions.       */
-# include <stdlib.h>
-# include <string.h>
-#endif
-
-#undef malloc
-#define malloc(n) GC_MALLOC(n)
-#undef calloc
-#define calloc(m,n) GC_MALLOC((m)*(n))
-#undef free
-#define free(p) GC_FREE(p)
-#undef realloc
-#define realloc(p,n) GC_REALLOC(p,n)
-
-#undef strdup
-#define strdup(s) GC_STRDUP(s)
-#undef strndup
-#define strndup(s,n) GC_STRNDUP(s,n)
-
-#ifdef GC_REQUIRE_WCSDUP
-  /* The collector should be built with GC_REQUIRE_WCSDUP       */
-  /* defined as well to redirect wcsdup().                      */
-# include <wchar.h>
-# undef wcsdup
-# define wcsdup(s) GC_WCSDUP(s)
-#endif
-
-#undef memalign
-#define memalign(a,n) GC_memalign(a,n)
-#undef posix_memalign
-#define posix_memalign(p,a,n) GC_posix_memalign(p,a,n)
-
-#ifndef CHECK_LEAKS
-# define CHECK_LEAKS() GC_gcollect()
-  /* Note 1: CHECK_LEAKS does not have GC prefix (preserved for */
-  /* backward compatibility).                                   */
-  /* Note 2: GC_gcollect() is also called automatically in the  */
-  /* leak-finding mode at program exit.                         */
-#endif
-
-#endif /* GC_LEAK_DETECTOR_H */

blitz.mod/bdwgc/include/new_gc_alloc.h

@@ -1,514 +0,0 @@
-/*
- * Copyright (c) 1996-1998 by Silicon Graphics.  All rights reserved.
- *
- * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
- * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
- *
- * Permission is hereby granted to use or copy this program
- * for any purpose,  provided the above notices are retained on all copies.
- * Permission to modify the code and to distribute modified code is granted,
- * provided the above notices are retained, and a notice that the code was
- * modified is included with the above copyright notice.
- */
-
-//
-// This is a revision of gc_allocator.h for SGI STL versions > 3.0.
-// Unlike earlier versions, it supplements the standard (STL) alloc.h
-// instead of replacing it.
-//
-// This is sloppy about variable names used in header files.
-// It also doesn't yet understand the new header file names or
-// namespaces.
-//
-// This assumes the collector has been compiled with -DGC_ATOMIC_UNCOLLECTABLE.
-// The user should also consider -DREDIRECT_MALLOC=GC_uncollectable_malloc,
-// to ensure that object allocated through malloc are traced.
-//
-// Some of this could be faster in the explicit deallocation case.
-// In particular, we spend too much time clearing objects on the
-// free lists.  That could be avoided.
-//
-// This uses template classes with static members, and hence does not work
-// with g++ 2.7.2 and earlier.
-//
-// Unlike its predecessor, this one simply defines
-//      gc_alloc
-//      single_client_gc_alloc
-//      traceable_alloc
-//      single_client_traceable_alloc
-//
-// It does not redefine alloc.  Nor does it change the default allocator,
-// though the user may wish to do so.  (The argument against changing
-// the default allocator is that it may introduce subtle link compatibility
-// problems.  The argument for changing it is that the usual default
-// allocator is usually a very bad choice for a garbage collected environment.)
-//
-
-#ifndef GC_NEW_ALLOC_H
-#define GC_NEW_ALLOC_H
-
-#include "gc.h"
-
-#if GC_GNUC_PREREQ(3, 0)
-# include <bits/stl_alloc.h>
-# ifndef __STL_BEGIN_NAMESPACE
-#   define __STL_BEGIN_NAMESPACE namespace std {
-#   define __STL_END_NAMESPACE };
-# endif
-# ifndef __STL_USE_STD_ALLOCATORS
-#   define __STL_USE_STD_ALLOCATORS
-# endif
-#else
-# include <stack>   // A more portable way to get stl_alloc.h file.
-#endif
-
-/* A hack to deal with gcc 3.1.  If you are using gcc3.1 and later,     */
-/* you should probably really use gc_allocator.h instead.               */
-#if GC_GNUC_PREREQ(3, 1)
-# define simple_alloc __simple_alloc
-#endif
-
-#include <stddef.h>
-#include <string.h>
-
-// We can't include gc_priv.h, since that pulls in way too much stuff.
-#include "gc_alloc_ptrs.h"
-
-#define GC_generic_malloc_words_small(lw, k) \
-                        GC_generic_malloc((lw) * sizeof(GC_word), k)
-
-#define GC_ALLOCATOR_THROW_OR_ABORT() GC_abort_on_oom()
-
-// Object kinds; must match PTRFREE, NORMAL, UNCOLLECTABLE, and
-// AUNCOLLECTABLE in gc_priv.h.
-
-enum { GC_PTRFREE = 0, GC_NORMAL = 1, GC_UNCOLLECTABLE = 2,
-       GC_AUNCOLLECTABLE = 3 };
-
-enum { GC_max_fast_bytes = 255 };
-
-enum { GC_byte_alignment = 8 };
-
-#if defined(CPPCHECK)
-  const unsigned GC_bytes_per_word = sizeof(char *);
-  const unsigned GC_word_alignment = GC_byte_alignment/GC_bytes_per_word;
-#else
-  enum { GC_bytes_per_word = sizeof(char *) };
-  enum { GC_word_alignment = GC_byte_alignment/GC_bytes_per_word };
-#endif
-
-inline void * &GC_obj_link(void * p)
-{   return *reinterpret_cast<void **>(p);  }
-
-// Compute a number of words >= n+1 bytes.
-// The +1 allows for pointers one past the end.
-inline size_t GC_round_up(size_t n)
-{
-    return ((n + GC_byte_alignment)/GC_byte_alignment)*GC_word_alignment;
-}
-
-// The same but don't allow for extra byte.
-inline size_t GC_round_up_uncollectable(size_t n)
-{
-    return ((n + GC_byte_alignment - 1)/GC_byte_alignment)*GC_word_alignment;
-}
-
-template <int dummy>
-class GC_aux_template {
-public:
-  // File local count of allocated words.  Occasionally this is
-  // added into the global count.  A separate count is necessary since the
-  // real one must be updated with a procedure call.
-  static size_t GC_bytes_recently_allocd;
-
-  // Same for uncollectible memory.  Not yet reflected in either
-  // GC_bytes_recently_allocd or GC_non_gc_bytes.
-  static size_t GC_uncollectable_bytes_recently_allocd;
-
-  // Similar counter for explicitly deallocated memory.
-  static size_t GC_bytes_recently_freed;
-
-  // Again for uncollectible memory.
-  static size_t GC_uncollectable_bytes_recently_freed;
-
-  static void * GC_out_of_line_malloc(size_t nwords, int kind);
-};
-
-template <int dummy>
-size_t GC_aux_template<dummy>::GC_bytes_recently_allocd = 0;
-
-template <int dummy>
-size_t GC_aux_template<dummy>::GC_uncollectable_bytes_recently_allocd = 0;
-
-template <int dummy>
-size_t GC_aux_template<dummy>::GC_bytes_recently_freed = 0;
-
-template <int dummy>
-size_t GC_aux_template<dummy>::GC_uncollectable_bytes_recently_freed = 0;
-
-template <int dummy>
-void * GC_aux_template<dummy>::GC_out_of_line_malloc(size_t nwords, int kind)
-{
-    void * op = GC_generic_malloc_words_small(nwords, kind);
-    if (0 == op)
-        GC_ALLOCATOR_THROW_OR_ABORT();
-
-    GC_bytes_recently_allocd += GC_uncollectable_bytes_recently_allocd;
-    GC_non_gc_bytes +=
-                GC_uncollectable_bytes_recently_allocd;
-    GC_uncollectable_bytes_recently_allocd = 0;
-
-    GC_bytes_recently_freed += GC_uncollectable_bytes_recently_freed;
-    GC_non_gc_bytes -= GC_uncollectable_bytes_recently_freed;
-    GC_uncollectable_bytes_recently_freed = 0;
-
-    GC_incr_bytes_allocd(GC_bytes_recently_allocd);
-    GC_bytes_recently_allocd = 0;
-
-    GC_incr_bytes_freed(GC_bytes_recently_freed);
-    GC_bytes_recently_freed = 0;
-    return op;
-}
-
-typedef GC_aux_template<0> GC_aux;
-
-// A fast, single-threaded, garbage-collected allocator
-// We assume the first word will be immediately overwritten.
-// In this version, deallocation is not a no-op, and explicit
-// deallocation is likely to help performance.
-template <int dummy>
-class single_client_gc_alloc_template {
-    public:
-        static void * allocate(size_t n)
-        {
-            size_t nwords = GC_round_up(n);
-            void ** flh;
-            void * op;
-
-            if (n > GC_max_fast_bytes) {
-                op = GC_malloc(n);
-                if (0 == op)
-                    GC_ALLOCATOR_THROW_OR_ABORT();
-                return op;
-            }
-            flh = &GC_objfreelist_ptr[nwords];
-            op = *flh;
-            if (0 == op) {
-                return GC_aux::GC_out_of_line_malloc(nwords, GC_NORMAL);
-            }
-            *flh = GC_obj_link(op);
-            GC_aux::GC_bytes_recently_allocd += nwords * GC_bytes_per_word;
-            return op;
-        }
-        static void * ptr_free_allocate(size_t n)
-        {
-            size_t nwords = GC_round_up(n);
-            void ** flh;
-            void * op;
-
-            if (n > GC_max_fast_bytes) {
-                op = GC_malloc_atomic(n);
-                if (0 == op)
-                    GC_ALLOCATOR_THROW_OR_ABORT();
-                return op;
-            }
-            flh = &GC_aobjfreelist_ptr[nwords];
-            op = *flh;
-            if (0 == op) {
-                return GC_aux::GC_out_of_line_malloc(nwords, GC_PTRFREE);
-            }
-            *flh = GC_obj_link(op);
-            GC_aux::GC_bytes_recently_allocd += nwords * GC_bytes_per_word;
-            return op;
-        }
-        static void deallocate(void *p, size_t n)
-        {
-            if (n > GC_max_fast_bytes)  {
-                GC_free(p);
-            } else {
-                size_t nwords = GC_round_up(n);
-                void ** flh = &GC_objfreelist_ptr[nwords];
-
-                GC_obj_link(p) = *flh;
-                memset(reinterpret_cast<char *>(p) + GC_bytes_per_word, 0,
-                       GC_bytes_per_word * (nwords - 1));
-                *flh = p;
-                GC_aux::GC_bytes_recently_freed += nwords * GC_bytes_per_word;
-            }
-        }
-        static void ptr_free_deallocate(void *p, size_t n)
-        {
-            if (n > GC_max_fast_bytes) {
-                GC_free(p);
-            } else {
-                size_t nwords = GC_round_up(n);
-                void ** flh = &GC_aobjfreelist_ptr[nwords];
-
-                GC_obj_link(p) = *flh;
-                *flh = p;
-                GC_aux::GC_bytes_recently_freed += nwords * GC_bytes_per_word;
-            }
-        }
-};
-
-typedef single_client_gc_alloc_template<0> single_client_gc_alloc;
-
-// Once more, for uncollectible objects.
-template <int dummy>
-class single_client_traceable_alloc_template {
-    public:
-        static void * allocate(size_t n)
-        {
-            size_t nwords = GC_round_up_uncollectable(n);
-            void ** flh;
-            void * op;
-
-            if (n > GC_max_fast_bytes) {
-                op = GC_malloc_uncollectable(n);
-                if (0 == op)
-                    GC_ALLOCATOR_THROW_OR_ABORT();
-                return op;
-            }
-            flh = &GC_uobjfreelist_ptr[nwords];
-            op = *flh;
-            if (0 == op) {
-                return GC_aux::GC_out_of_line_malloc(nwords, GC_UNCOLLECTABLE);
-            }
-            *flh = GC_obj_link(op);
-            GC_aux::GC_uncollectable_bytes_recently_allocd +=
-                                        nwords * GC_bytes_per_word;
-            return op;
-        }
-        static void * ptr_free_allocate(size_t n)
-        {
-            size_t nwords = GC_round_up_uncollectable(n);
-            void ** flh;
-            void * op;
-
-            if (n > GC_max_fast_bytes) {
-                op = GC_malloc_atomic_uncollectable(n);
-                if (0 == op)
-                    GC_ALLOCATOR_THROW_OR_ABORT();
-                return op;
-            }
-            flh = &GC_auobjfreelist_ptr[nwords];
-            op = *flh;
-            if (0 == op) {
-                return GC_aux::GC_out_of_line_malloc(nwords, GC_AUNCOLLECTABLE);
-            }
-            *flh = GC_obj_link(op);
-            GC_aux::GC_uncollectable_bytes_recently_allocd +=
-                                        nwords * GC_bytes_per_word;
-            return op;
-        }
-        static void deallocate(void *p, size_t n)
-        {
-            if (n > GC_max_fast_bytes)  {
-                GC_free(p);
-            } else {
-                size_t nwords = GC_round_up_uncollectable(n);
-                void ** flh = &GC_uobjfreelist_ptr[nwords];
-
-                GC_obj_link(p) = *flh;
-                *flh = p;
-                GC_aux::GC_uncollectable_bytes_recently_freed +=
-                                nwords * GC_bytes_per_word;
-            }
-        }
-        static void ptr_free_deallocate(void *p, size_t n)
-        {
-            if (n > GC_max_fast_bytes) {
-                GC_free(p);
-            } else {
-                size_t nwords = GC_round_up_uncollectable(n);
-                void ** flh = &GC_auobjfreelist_ptr[nwords];
-
-                GC_obj_link(p) = *flh;
-                *flh = p;
-                GC_aux::GC_uncollectable_bytes_recently_freed +=
-                                nwords * GC_bytes_per_word;
-            }
-        }
-};
-
-typedef single_client_traceable_alloc_template<0> single_client_traceable_alloc;
-
-template < int dummy >
-class gc_alloc_template {
-    public:
-        static void * allocate(size_t n) {
-            void * op = GC_malloc(n);
-            if (0 == op)
-                GC_ALLOCATOR_THROW_OR_ABORT();
-            return op;
-        }
-        static void * ptr_free_allocate(size_t n) {
-            void * op = GC_malloc_atomic(n);
-            if (0 == op)
-                GC_ALLOCATOR_THROW_OR_ABORT();
-            return op;
-        }
-        static void deallocate(void *, size_t) { }
-        static void ptr_free_deallocate(void *, size_t) { }
-};
-
-typedef gc_alloc_template < 0 > gc_alloc;
-
-template < int dummy >
-class traceable_alloc_template {
-    public:
-        static void * allocate(size_t n) {
-            void * op = GC_malloc_uncollectable(n);
-            if (0 == op)
-                GC_ALLOCATOR_THROW_OR_ABORT();
-            return op;
-        }
-        static void * ptr_free_allocate(size_t n) {
-            void * op = GC_malloc_atomic_uncollectable(n);
-            if (0 == op)
-                GC_ALLOCATOR_THROW_OR_ABORT();
-            return op;
-        }
-        static void deallocate(void *p, size_t) { GC_free(p); }
-        static void ptr_free_deallocate(void *p, size_t) { GC_free(p); }
-};
-
-typedef traceable_alloc_template < 0 > traceable_alloc;
-
-// We want to specialize simple_alloc so that it does the right thing
-// for all pointer-free types.  At the moment there is no portable way to
-// even approximate that.  The following approximation should work for
-// SGI compilers, and recent versions of g++.
-
-// GC_SPECIALIZE() is used internally.
-#define GC_SPECIALIZE(T,alloc) \
-  class simple_alloc<T, alloc> { \
-  public: \
-    static T *allocate(size_t n) \
-        { reinterpret_cast<T*>(alloc::ptr_free_allocate(0 == n ? 1 \
-                                                    : n * sizeof(T))); } \
-    static T *allocate(void) \
-        { return reinterpret_cast<T*>(alloc::ptr_free_allocate(sizeof(T))); } \
-    static void deallocate(T *p, size_t n) \
-        { alloc::ptr_free_deallocate(p, 0 == n ? 1 : n * sizeof(T)); } \
-    static void deallocate(T *p) \
-        { alloc::ptr_free_deallocate(p, sizeof(T)); } \
-  };
-
-__STL_BEGIN_NAMESPACE
-
-GC_SPECIALIZE(char, gc_alloc)
-GC_SPECIALIZE(int, gc_alloc)
-GC_SPECIALIZE(unsigned, gc_alloc)
-GC_SPECIALIZE(float, gc_alloc)
-GC_SPECIALIZE(double, gc_alloc)
-
-GC_SPECIALIZE(char, traceable_alloc)
-GC_SPECIALIZE(int, traceable_alloc)
-GC_SPECIALIZE(unsigned, traceable_alloc)
-GC_SPECIALIZE(float, traceable_alloc)
-GC_SPECIALIZE(double, traceable_alloc)
-
-GC_SPECIALIZE(char, single_client_gc_alloc)
-GC_SPECIALIZE(int, single_client_gc_alloc)
-GC_SPECIALIZE(unsigned, single_client_gc_alloc)
-GC_SPECIALIZE(float, single_client_gc_alloc)
-GC_SPECIALIZE(double, single_client_gc_alloc)
-
-GC_SPECIALIZE(char, single_client_traceable_alloc)
-GC_SPECIALIZE(int, single_client_traceable_alloc)
-GC_SPECIALIZE(unsigned, single_client_traceable_alloc)
-GC_SPECIALIZE(float, single_client_traceable_alloc)
-GC_SPECIALIZE(double, single_client_traceable_alloc)
-
-__STL_END_NAMESPACE
-
-#ifdef __STL_USE_STD_ALLOCATORS
-
-__STL_BEGIN_NAMESPACE
-
-template <class _Tp>
-struct _Alloc_traits<_Tp, gc_alloc >
-{
-  static const bool _S_instanceless = true;
-  typedef simple_alloc<_Tp, gc_alloc > _Alloc_type;
-  typedef __allocator<_Tp, gc_alloc > allocator_type;
-};
-
-inline bool operator==(const gc_alloc&,
-                       const gc_alloc&)
-{
-  return true;
-}
-
-inline bool operator!=(const gc_alloc&,
-                       const gc_alloc&)
-{
-  return false;
-}
-
-template <class _Tp>
-struct _Alloc_traits<_Tp, single_client_gc_alloc >
-{
-  static const bool _S_instanceless = true;
-  typedef simple_alloc<_Tp, single_client_gc_alloc > _Alloc_type;
-  typedef __allocator<_Tp, single_client_gc_alloc > allocator_type;
-};
-
-inline bool operator==(const single_client_gc_alloc&,
-                       const single_client_gc_alloc&)
-{
-  return true;
-}
-
-inline bool operator!=(const single_client_gc_alloc&,
-                       const single_client_gc_alloc&)
-{
-  return false;
-}
-
-template <class _Tp>
-struct _Alloc_traits<_Tp, traceable_alloc >
-{
-  static const bool _S_instanceless = true;
-  typedef simple_alloc<_Tp, traceable_alloc > _Alloc_type;
-  typedef __allocator<_Tp, traceable_alloc > allocator_type;
-};
-
-inline bool operator==(const traceable_alloc&,
-                       const traceable_alloc&)
-{
-  return true;
-}
-
-inline bool operator!=(const traceable_alloc&,
-                       const traceable_alloc&)
-{
-  return false;
-}
-
-template <class _Tp>
-struct _Alloc_traits<_Tp, single_client_traceable_alloc >
-{
-  static const bool _S_instanceless = true;
-  typedef simple_alloc<_Tp, single_client_traceable_alloc > _Alloc_type;
-  typedef __allocator<_Tp, single_client_traceable_alloc > allocator_type;
-};
-
-inline bool operator==(const single_client_traceable_alloc&,
-                       const single_client_traceable_alloc&)
-{
-  return true;
-}
-
-inline bool operator!=(const single_client_traceable_alloc&,
-                       const single_client_traceable_alloc&)
-{
-  return false;
-}
-
-__STL_END_NAMESPACE
-
-#endif /* __STL_USE_STD_ALLOCATORS */
-
-#endif /* GC_NEW_ALLOC_H */

blitz.mod/bdwgc/include/private/msvc_dbg.h

@@ -1,70 +0,0 @@
-/*
-  Copyright (c) 2004-2005 Andrei Polushin
-
-  Permission is hereby granted, free of charge,  to any person obtaining a copy
-  of this software and associated documentation files (the "Software"), to deal
-  in the Software without restriction,  including without limitation the rights
-  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-  copies of the Software, and to permit persons to whom the Software is
-  furnished to do so, subject to the following conditions:
-
-  The above copyright notice and this permission notice shall be included in
-  all copies or substantial portions of the Software.
-
-  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-  THE SOFTWARE.
-*/
-
-#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);
-
-/* Compatibility with <execinfo.h> */
-MSVC_DBG_EXPORT int    backtrace(void* addresses[], int count);
-MSVC_DBG_EXPORT char** backtrace_symbols(void*const addresses[], int count);
-
-#ifdef __cplusplus
-  } /* extern "C" */
-#endif
-
-#endif /* GC_MSVC_DBG_H */

blitz.mod/bdwgc/libatomic_ops/appveyor.yml

@@ -1,26 +0,0 @@
-version: 7.7.0-{build}
-
-clone_depth: 50
-
-environment:
-  MS_SDK_VER: v7.1
-  matrix:
-  - CPU: x86
-    BLD: debug
-    CFLAGS_EXTRA: -DAO_ASSUME_VISTA -DAO_USE_PENTIUM4_INSTRS
-  - CPU: x86
-    BLD: release
-  - CPU: x64
-    BLD: debug
-    CFLAGS_EXTRA: -DAO_CMPXCHG16B_AVAILABLE
-  - CPU: x64
-    BLD: release
-
-install:
-  - cmd: '"C:\Program Files\Microsoft SDKs\Windows\%MS_SDK_VER%\Bin\SetEnv.cmd" /%CPU% /%BLD%'
-
-build_script:
-  - cmd: cd src && nmake -f Makefile.msft clean all CFLAGS_EXTRA="%CFLAGS_EXTRA%" && cd ..
-
-test_script:
-  - cmd: cd src && nmake -f Makefile.msft check-noautogen CFLAGS_EXTRA="%CFLAGS_EXTRA%"

blitz.mod/bdwgc/libatomic_ops/doc/LICENSING.txt

@@ -1,63 +0,0 @@
-Our intent is to make it easy to use libatomic_ops, in
-both free and proprietary software.  Hence most code that we expect to be
-linked into a client application is covered by an MIT-style license.
-
-A few library routines are covered by the GNU General Public License.
-These are put into a separate library, libatomic_ops_gpl.a .
-
-The low-level part of the library is mostly covered by the following
-license:
-
-----------------------------------------
-
-Copyright (c) ...
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
---------------------------------
-
-A few files in the sysdeps directory were inherited in part from the
-Boehm-Demers-Weiser conservative garbage collector, and are covered by
-its license, which is similar in spirit:
-
---------------------------------
-
-Copyright (c) ...
-
-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.
-
-----------------------------------
-
-A few files are covered by the GNU General Public License.  (See file
-"COPYING".) This applies only to test code, sample applications,
-and the libatomic_ops_gpl portion of the library.
-Thus libatomic_ops_gpl should generally not be linked into proprietary code.
-(This distinction was motivated by patent considerations.)
-
-It is possible that the license of the GPL pieces may be changed for
-future versions to make them more consistent with the rest of the package.
-If you submit patches, and have strong preferences about licensing, please
-express them.

blitz.mod/bdwgc/libatomic_ops/doc/Makefile.am

@@ -1,7 +0,0 @@
-# installed documentation
-#
-
-if ENABLE_DOCS
-dist_doc_DATA = LICENSING.txt README_details.txt README_stack.txt \
-    README_malloc.txt README_win32.txt
-endif

blitz.mod/bdwgc/libatomic_ops/doc/README_details.txt

@@ -1,241 +0,0 @@
-Usage:
-
-0) If possible, do this on a multiprocessor, especially if you are planning
-on modifying or enhancing the package.  It will work on a uniprocessor,
-but the tests are much more likely to pass in the presence of serious problems.
-
-1) Type ./configure --prefix=<install dir>; make; make check
-in the directory containing unpacked source.  The usual GNU build machinery
-is used, except that only static, but position-independent, libraries
-are normally built.  On Windows, read README_win32.txt instead.
-
-2) Applications should include atomic_ops.h.  Nearly all operations
-are implemented by header files included from it.  It is sometimes
-necessary, and always recommended to also link against libatomic_ops.a.
-To use the almost non-blocking stack or malloc implementations,
-see the corresponding README files, and also link against libatomic_ops_gpl.a
-before linking against libatomic_ops.a.
-
-OVERVIEW:
-Atomic_ops.h defines a large collection of operations, each one of which is
-a combination of an (optional) atomic memory operation, and a memory barrier.
-Also defines associated feature-test macros to determine whether a particular
-operation is available on the current target hardware (either directly or
-by synthesis).  This is an attempt to replace various existing files with
-similar goals, since they usually do not handle differences in memory
-barrier styles with sufficient generality.
-
-If this is included after defining AO_REQUIRE_CAS, then the package makes
-an attempt to emulate [fetch_]compare_and_swap* (single-width) in a way that,
-at least on Linux, should still be async-signal-safe.  As a result, most
-other atomic operations may then be defined using the compare-and-swap
-emulation.  This emulation is slow, since it needs to disable signals.
-And it needs to block in case of contention.  If you care about performance
-on a platform that can't directly provide compare-and-swap, there are
-probably better alternatives.  But this allows easy ports to some such
-platforms (e.g. PA_RISC).  The option is ignored if compare-and-swap
-can be implemented directly.
-
-If atomic_ops.h is included after defining AO_USE_PTHREAD_DEFS, then all
-atomic operations will be emulated with pthread locking.  This is NOT
-async-signal-safe.  And it is slow.  It is intended primarily for debugging
-of the atomic_ops package itself.
-
-Note that the implementation reflects our understanding of real processor
-behavior.  This occasionally diverges from the documented behavior.  (E.g.
-the documented X86 behavior seems to be weak enough that it is impractical
-to use.  Current real implementations appear to be much better behaved.)
-We of course are in no position to guarantee that future processors
-(even HPs) will continue to behave this way, though we hope they will.
-
-Corrections/additions for other platforms are greatly appreciated.
-
-OPERATIONS:
-
-Most operations handle values of type AO_t, which are unsigned integers
-whose size matches that of pointers on the given architecture.  Additionally,
-on most supported architectures the operations are also implemented to handle
-smaller integers types; such operations are indicated by the appropriate size
-prefix:
-- char_... Operates on unsigned char values;
-- short_... Operates on unsigned short values;
-- int_... Operates on unsigned int values.
-
-The notable exception is AO_test_and_set operating only on AO_TS_t, which is
-whatever size the hardware supports with good performance.  In some cases this
-is the length of a cache line, in some other cases it is a byte.  In many
-cases AO_TS_t is equivalent to AO_t.
-
-The defined operations are all of the form AO_[<size>]<op><barrier>(<args>).
-
-The <op> component specifies an atomic memory operation.  It may be
-one of the following, where the corresponding argument and result types
-are also specified:
-
-void nop()
-        No atomic operation.  The barrier may still be useful.
-AO_t load(const volatile AO_t * addr)
-        Atomic load of *addr.
-void store(volatile AO_t * addr, AO_t new_val)
-        Atomically store new_val to *addr.
-AO_t fetch_and_add(volatile AO_t *addr, AO_t incr)
-        Atomically add incr to *addr, and return the original value of *addr.
-AO_t fetch_and_add1(volatile AO_t *addr)
-        Equivalent to AO_fetch_and_add(addr, 1).
-AO_t fetch_and_sub1(volatile AO_t *addr)
-        Equivalent to AO_fetch_and_add(addr, (AO_t)(-1)).
-void and(volatile AO_t *addr, AO_t value)
-        Atomically 'and' value into *addr.
-void or(volatile AO_t *addr, AO_t value)
-        Atomically 'or' value into *addr.
-void xor(volatile AO_t *addr, AO_t value)
-        Atomically 'xor' value into *addr.
-int compare_and_swap(volatile AO_t * addr, AO_t old_val, AO_t new_val)
-        Atomically compare *addr to old_val, and replace *addr by new_val
-        if the first comparison succeeds; returns nonzero if the comparison
-        succeeded and *addr was updated; cannot fail spuriously.
-AO_t fetch_compare_and_swap(volatile AO_t * addr, AO_t old_val, AO_t new_val)
-        Atomically compare *addr to old_val, and replace *addr by new_val
-        if the first comparison succeeds; returns the original value of *addr;
-        cannot fail spuriously.
-AO_TS_VAL_t test_and_set(volatile AO_TS_t * addr)
-        Atomically read the binary value at *addr, and set it.  AO_TS_VAL_t
-        is an enumeration type which includes two values AO_TS_SET and
-        AO_TS_CLEAR.  An AO_TS_t location is capable of holding an
-        AO_TS_VAL_t, but may be much larger, as dictated by hardware
-        constraints.  Test_and_set logically sets the value to AO_TS_SET.
-        It may be reset to AO_TS_CLEAR with the AO_CLEAR(AO_TS_t *) macro.
-        AO_TS_t locations should be initialized to AO_TS_INITIALIZER.
-        The values of AO_TS_SET and AO_TS_CLEAR are hardware dependent.
-        (On PA-RISC, AO_TS_SET is zero!)
-
-Test_and_set is a more limited version of compare_and_swap.  Its only
-advantage is that it is more easily implementable on some hardware.  It
-should thus be used if only binary test-and-set functionality is needed.
-
-If available, we also provide compare_and_swap operations that operate
-on wider values.  Since standard data types for double width values
-may not be available, these explicitly take pairs of arguments for the
-new and/or old value.  Unfortunately, there are two common variants,
-neither of which can easily and efficiently emulate the other.
-The first performs a comparison against the entire value being replaced,
-where the second replaces a double-width replacement, but performs
-a single-width comparison:
-
-int compare_double_and_swap_double(volatile AO_double_t * addr,
-                                   AO_t old_val1, AO_t old_val2,
-                                   AO_t new_val1, AO_t new_val2);
-
-int compare_and_swap_double(volatile AO_double_t * addr,
-                            AO_t old_val1,
-                            AO_t new_val1, AO_t new_val2);
-
-where AO_double_t is a structure containing AO_val1 and AO_val2 fields,
-both of type AO_t.  For compare_and_swap_double, we compare against
-the val1 field.  AO_double_t exists only if AO_HAVE_double_t
-is defined.  If this type is available then the following operation is
-provided for convenience, fully equivalent to compare_double_and_swap_double:
-
-int double_compare_and_swap(volatile AO_double_t * addr,
-                            AO_double_t old_val, AO_double_t new_val)
-
-Please note that AO_double_t (and AO_stack_t) variables should be properly
-aligned (8-byte alignment on 32-bit targets, 16-byte alignment on 64-bit ones)
-otherwise the behavior of a double-wide atomic primitive might be undefined
-(or an assertion violation might occur) if such a misaligned variable is
-passed (as a reference) to the primitive.  Global and static variables should
-already have proper alignment automatically but automatic variables (i.e.
-located on the stack) might be misaligned because the stack might be
-word-aligned (e.g. 4-byte stack alignment is the default one for x86).
-Luckily, stack-allocated AO variables operated atomically are used rarely
-in practice.
-
-ORDERING CONSTRAINTS:
-
-Each operation name also includes a suffix that specifies the associated
-ordering semantics.  The ordering constraint limits reordering of this
-operation with respect to other atomic operations and ordinary memory
-references.  The current implementation assumes that all memory references
-are to ordinary cacheable memory; the ordering guarantee is with respect
-to other threads or processes, not I/O devices.  (Whether or not this
-distinction is important is platform-dependent.)
-
-Ordering suffixes are one of the following:
-
-<none>: No memory barrier.  A plain AO_nop() really does nothing.
-_release: Earlier operations must become visible to other threads
-          before the atomic operation.
-_acquire: Later operations must become visible after this operation.
-_read: Subsequent reads must become visible after reads included in
-       the atomic operation or preceding it.  Rarely useful for clients?
-_write: Earlier writes become visible before writes during or after
-        the atomic operation.  Rarely useful for clients?
-_full: The associated operation is ordered with respect to both earlier and
-       later memory ops.  If the associated operation is nop, then this orders
-       all earlier memory operations with respect to subsequent ones.
-       AO_store_full or AO_nop_full are the normal ways to force a store
-       to be ordered with respect to a later load.
-_release_write: Ordered with respect to earlier writes.  This is
-                normally implemented as either a _write or _release
-                barrier.
-_acquire_read: Ordered with respect to later reads. This is
-                normally implemented as either a _read or _acquire barrier.
-_dd_acquire_read: Ordered with respect to later reads that are data
-               dependent on this one.  This is needed on
-               a pointer read, which is later dereferenced to read a
-               second value, with the expectation that the second
-               read is ordered after the first one.  On most architectures,
-               this is equivalent to no barrier.  (This is very
-               hard to define precisely.  It should probably be avoided.
-               A major problem is that optimizers tend to try to
-               eliminate dependencies from the generated code, since
-               dependencies force the hardware to execute the code
-               serially.)
-
-We assume that if a store is data-dependent on a previous load, then
-the two are always implicitly ordered.
-
-It is possible to test whether AO_[<size>]<op><barrier> is available on the
-target platform by checking whether AO_HAVE_[<size>]<op><barrier> is defined
-as a macro.
-
-Note that we generally don't implement operations that are either
-meaningless (e.g. AO_nop_acquire, AO_nop_release) or which appear to
-have no clear use (e.g. AO_load_release, AO_store_acquire, AO_load_write,
-AO_store_read).  On some platforms (e.g. PA-RISC) many operations
-will remain undefined unless AO_REQUIRE_CAS is defined before including
-the package.
-
-When typed in the package build directory, the following command
-will print operations that are unimplemented on the platform:
-
-make test_atomic; ./test_atomic
-
-The following command generates a file "list_atomic.i" containing the
-macro expansions of all implemented operations on the platform:
-
-make list_atomic.i
-
-Known issues include:
-
-We should be more precise in defining the semantics of the ordering
-constraints, and if and how we can guarantee sequential consistency.
-
-Dd_acquire_read is very hard or impossible to define in a way that cannot
-be invalidated by reasonably standard compiler transformations.
-
-Example:
-
-If you want to initialize an object, and then "publish" a pointer to it
-in a global location p, such that other threads reading the new value of
-p are guaranteed to see an initialized object, it suffices to use
-AO_release_write(p, ...) to write the pointer to the object, and to
-retrieve it in other threads with AO_acquire_read(p).
-
-Platform notes:
-
-All X86: We quietly assume 486 or better.
-
-Gcc on x86:
-Define AO_USE_PENTIUM4_INSTRS to use the Pentium 4 mfence instruction.
-Currently this is appears to be of marginal benefit.

blitz.mod/bdwgc/libatomic_ops/doc/README_malloc.txt

@@ -1,57 +0,0 @@
-The libatomic_ops_gpl includes a simple almost-lock-free malloc implementation.
-
-This is intended as a safe way to allocate memory from a signal handler,
-or to allocate memory in the context of a library that does not know what
-thread library it will be used with.  In either case locking is impossible.
-
-Note that the operations are only guaranteed to be 1-lock-free, i.e. a
-single blocked thread will not prevent progress, but multiple blocked
-threads may.  To safely use these operations in a signal handler,
-the handler should be non-reentrant, i.e. it should not be interruptable
-by another handler using these operations.  Furthermore use outside
-of signal handlers in a multithreaded application should be protected
-by a lock, so that at most one invocation may be interrupted by a signal.
-The header will define the macro "AO_MALLOC_IS_LOCK_FREE" on platforms
-on which malloc is completely lock-free, and hence these restrictions
-do not apply.
-
-In the presence of threads, but absence of contention, the time performance
-of this package should be as good, or slightly better than, most system
-malloc implementations.  Its space performance
-is theoretically optimal (to within a constant factor), but probably
-quite poor in practice.  In particular, no attempt is made to
-coalesce free small memory blocks.  Something like Doug Lea's malloc is
-likely to use significantly less memory for complex applications.
-
-Performance on platforms without an efficient compare-and-swap implementation
-will be poor.
-
-This package was not designed for processor-scalability in the face of
-high allocation rates.  If all threads happen to allocate different-sized
-objects, you might get lucky.  Otherwise expect contention and false-sharing
-problems.  If this is an issue, something like Maged Michael's algorithm
-(PLDI 2004) would be technically a far better choice.  If you are concerned
-only with scalability, and not signal-safety, you might also consider
-using Hoard instead.  We have seen a factor of 3 to 4 slowdown from the
-standard glibc malloc implementation with contention, even when the
-performance without contention was faster.  (To make the implementation
-more scalable, one would need to replicate at least the free list headers,
-so that concurrent access is possible without cache conflicts.)
-
-Unfortunately there is no portable async-signal-safe way to obtain large
-chunks of memory from the OS.  Based on reading of the source code,
-mmap-based allocation appears safe under Linux, and probably BSD variants.
-It is probably unsafe for operating systems built on Mach, such as
-Apple's Darwin.  Without use of mmap, the allocator is
-limited to a fixed size, statically preallocated heap (2MB by default),
-and will fail to allocate objects above a certain size (just under 64K
-by default).  Use of mmap to circumvent these limitations requires an
-explicit call.
-
-The entire interface to the AO_malloc package currently consists of:
-
-#include <atomic_ops_malloc.h> /* includes atomic_ops.h */
-
-void *AO_malloc(size_t sz);
-void AO_free(void *p);
-void AO_malloc_enable_mmap(void);

blitz.mod/bdwgc/libatomic_ops/doc/README_win32.txt

@@ -1,26 +0,0 @@
-Most of the atomic_ops functionality is available under Win32 with
-the Microsoft tools, but the build process is more primitive than that on
-Linux/Unix platforms.
-
-To build:
-1) Go to the src directory in the distribution.
-2) Make sure the Microsoft command-line tools (e.g. nmake) are available.
-3) Run "nmake -f Makefile.msft check".  This should build libatomic_ops_gpl.lib
-and run some tests.
-4) To compile applications, you will need to retain or copy the following
-pieces from the resulting src directory contents:
-        "atomic_ops.h" - Header file defining low-level primitives.  This
-                         includes files from the following folder.
-        "atomic_ops"- Subdirectory containing implementation header files.
-        "atomic_ops_stack.h" - Header file describing almost lock-free stack.
-        "atomic_ops_malloc.h" - Header file describing almost lock-free malloc.
-        "libatomic_ops_gpl.lib" - Library containing implementation of the
-                        above two (plus AO_pause() defined in atomic_ops.c).
-                        The atomic_ops.h implementation is entirely in the
-                        header files in Win32.
-
-If the client defines AO_ASSUME_VISTA (before include atomic_ops.h), it should
-make double_compare_and_swap_full available.
-
-Note that the library is covered by the GNU General Public License, while
-the top 2 of these pieces allow use in proprietary code.

blitz.mod/bdwgc/sparc_sunos4_mach_dep.s

@@ -1,32 +0,0 @@
-!	SPARCompiler 3.0 and later apparently no longer handles
-!	asm outside functions.  So we need a separate .s file
-!	This is only set up for SunOS 4.
-!	Assumes this is called before the stack contents are
-!	examined.
-
-	.seg 	"text"
-	.globl	_GC_save_regs_in_stack
-	.globl 	_GC_push_regs
-_GC_save_regs_in_stack:
-_GC_push_regs:
-	ta	0x3   ! ST_FLUSH_WINDOWS
-	mov	%sp,%o0
-	retl
-	nop
-
-	.globl	_GC_clear_stack_inner
-_GC_clear_stack_inner:
-	mov	%sp,%o2		! Save sp
-	add	%sp,-8,%o3	! p = sp-8
-	clr	%g1		! [g0,g1] = 0
-	add	%o1,-0x60,%sp	! Move sp out of the way,
-				! so that traps still work.
-				! Includes some extra words
-				! so we can be sloppy below.
-loop:
-	std	%g0,[%o3]	! *(long long *)p = 0
-	cmp	%o3,%o1
-	bgu	loop		! if (p > limit) goto loop
-	  add	%o3,-8,%o3	! p -= 8 (delay slot)
-	retl
-	  mov	%o2,%sp		! Restore sp., delay slot