makefile

A garbage collector for C and C

# This is the original manually generated Makefile.  It may still be used
# to build the collector.
#
# Primary targets:
# gc.a - builds basic library
# c++ - adds C++ interface to library
# cords - adds cords (heavyweight strings) to library
# test - prints porting information, then builds basic version of gc.a,
#      	 and runs some tests of collector and cords.  Does not add cords or
#	 c++ interface to gc.a
# cord/de - builds dumb editor based on cords.
ABI_FLAG= 
# ABI_FLAG should be the cc flag that specifies the ABI.  On most
# platforms this will be the empty string.  Possible values:
# +DD64 for 64-bit executable on HP/UX.
# -n32, -n64, -o32 for SGI/MIPS ABIs.

AS_ABI_FLAG=$(ABI_FLAG)
# ABI flag for assembler.  On HP/UX this is +A64 for 64 bit
# executables.

CC=cc $(ABI_FLAG)
CXX=g++ $(ABI_FLAG)
AS=as $(AS_ABI_FLAG)
#  The above doesn't work with gas, which doesn't run cpp.
#  Define AS as `gcc -c -x assembler-with-cpp' instead.

# Redefining srcdir allows object code for the nonPCR version of the collector
# to be generated in different directories.
srcdir= .
VPATH= $(srcdir)

CFLAGS= -O -I$(srcdir)/include -DATOMIC_UNCOLLECTABLE -DNO_SIGNALS -DNO_EXECUTE_PERMISSION -DSILENT -DALL_INTERIOR_POINTERS

# To build the parallel collector on Linux, add to the above:
# -DGC_LINUX_THREADS -DPARALLEL_MARK -DTHREAD_LOCAL_ALLOC
# To build the parallel collector in a static library on HP/UX,
# add to the above:
# -DGC_HPUX_THREADS -DPARALLEL_MARK -DTHREAD_LOCAL_ALLOC -D_POSIX_C_SOURCE=199506L
# To build the thread-safe collector on Tru64, add to the above:
# -pthread -DGC_OSF1_THREADS

# HOSTCC and HOSTCFLAGS are used to build executables that will be run as
# part of the build process, i.e. on the build machine.  These will usually
# be the same as CC and CFLAGS, except in a cross-compilation environment.
# Note that HOSTCFLAGS should include any -D flags that affect thread support.
HOSTCC=$(CC)
HOSTCFLAGS=$(CFLAGS)

# For dynamic library builds, it may be necessary to add flags to generate
# PIC code, e.g. -fPIC on Linux.

# Setjmp_test may yield overly optimistic results when compiled
# without optimization.

# These define arguments influence the collector configuration:
# -DSILENT disables statistics printing, and improves performance.
# -DFIND_LEAK causes GC_find_leak to be initially set.
#   This causes the collector to assume that all inaccessible
#   objects should have been explicitly deallocated, and reports exceptions.
#   Finalization and the test program are not usable in this mode.
# -DGC_SOLARIS_THREADS enables support for Solaris (thr_) threads.
#   (Clients should also define GC_SOLARIS_THREADS and then include
#   gc.h before performing thr_ or dl* or GC_ operations.)
#   Must also define -D_REENTRANT.
# -DGC_SOLARIS_PTHREADS enables support for Solaris pthreads.
#   (Internally this define GC_SOLARIS_THREADS as well.)
# -DGC_IRIX_THREADS enables support for Irix pthreads.  See README.irix.
# -DGC_HPUX_THREADS enables support for HP/UX 11 pthreads.
#   Also requires -D_REENTRANT or -D_POSIX_C_SOURCE=199506L. See README.hp.
# -DGC_LINUX_THREADS enables support for Xavier Leroy's Linux threads.
#   see README.linux.  -D_REENTRANT may also be required.
# -DGC_OSF1_THREADS enables support for Tru64 pthreads.  Untested.
# -DGC_FREEBSD_THREADS enables support for FreeBSD pthreads.  Untested.
#   Appeared to run into some underlying thread problems.
# -DGC_DARWIN_THREADS enables support for Mac OS X pthreads.  Untested.
# -DGC_DGUX386_THREADS enables support for DB/UX on I386 threads.
#   See README.DGUX386.
# -DGC_WIN32_THREADS enables support for win32 threads.  That makes sense
#   for this Makefile only under Cygwin.
# -DGC_THREADS should set the appropriate one of the above macros.
#   It assumes pthreads for Solaris.
# -DALL_INTERIOR_POINTERS allows all pointers to the interior
#   of objects to be recognized.  (See gc_priv.h for consequences.)
#   Alternatively, GC_all_interior_pointers can be set at process
#   initialization time.
# -DSMALL_CONFIG tries to tune the collector for small heap sizes,
#   usually causing it to use less space in such situations.
#   Incremental collection no longer works in this case.
# -DLARGE_CONFIG tunes the collector for unusually large heaps.
#   Necessary for heaps larger than about 500 MB on most machines.
#   Recommended for heaps larger than about 64 MB.
# -DDONT_ADD_BYTE_AT_END is meaningful only with -DALL_INTERIOR_POINTERS or
#   GC_all_interior_pointers = 1.  Normally -DALL_INTERIOR_POINTERS
#   causes all objects to be padded so that pointers just past the end of
#   an object can be recognized.  This can be expensive.  (The padding
#   is normally more than one byte due to alignment constraints.)
#   -DDONT_ADD_BYTE_AT_END disables the padding.
# -DNO_SIGNALS does not disable signals during critical parts of
#   the GC process.  This is no less correct than many malloc 
#   implementations, and it sometimes has a significant performance
#   impact.  However, it is dangerous for many not-quite-ANSI C
#   programs that call things like printf in asynchronous signal handlers.
#   This is on by default.  Turning it off has not been extensively tested with
#   compilers that reorder stores.  It should have been.
# -DNO_EXECUTE_PERMISSION may cause some or all of the heap to not
#   have execute permission, i.e. it may be impossible to execute
#   code from the heap.  Currently this only affects the incremental
#   collector on UNIX machines.  It may greatly improve its performance,
#   since this may avoid some expensive cache synchronization.
# -DGC_NO_OPERATOR_NEW_ARRAY declares that the C++ compiler does not support
#   the  new syntax "operator new[]" for allocating and deleting arrays.
#   See gc_cpp.h for details.  No effect on the C part of the collector.
#   This is defined implicitly in a few environments.  Must also be defined
#   by clients that use gc_cpp.h.
# -DREDIRECT_MALLOC=X causes malloc to be defined as alias for X.
#   Unless the following macros are defined, realloc is also redirected
#   to GC_realloc, and free is redirected to GC_free.
#   Calloc and strdup are redefined in terms of the new malloc.  X should
#   be either GC_malloc or GC_malloc_uncollectable, or
#   GC_debug_malloc_replacement.  (The latter invokes GC_debug_malloc
#   with dummy source location information, but still results in
#   properly remembered call stacks on Linux/X86 and Solaris/SPARC.
#   It requires that the following two macros also be used.)
#   The former is occasionally useful for working around leaks in code
#   you don't want to (or can't) look at.  It may not work for
#   existing code, but it often does.  Neither works on all platforms,
#   since some ports use malloc or calloc to obtain system memory.
#   (Probably works for UNIX, and win32.)  If you build with DBG_HDRS_ALL,
#   you should only use GC_debug_malloc_replacement as a malloc
#   replacement.
# -DREDIRECT_REALLOC=X causes GC_realloc to be redirected to X.
#   The canonical use is -DREDIRECT_REALLOC=GC_debug_realloc_replacement,
#   together with -DREDIRECT_MALLOC=GC_debug_malloc_replacement to
#   generate leak reports with call stacks for both malloc and realloc.
#   This also requires the following:
# -DREDIRECT_FREE=X causes free to be redirected to X.  The
#   canonical use is -DREDIRECT_FREE=GC_debug_free.
# -DIGNORE_FREE turns calls to free into a noop.  Only useful with
#   -DREDIRECT_MALLOC.
# -DNO_DEBUGGING removes GC_dump and the debugging routines it calls.
#   Reduces code size slightly at the expense of debuggability.
# -DJAVA_FINALIZATION makes it somewhat safer to finalize objects out of
#   order by specifying a nonstandard finalization mark procedure  (see
#   finalize.c).  Objects reachable from finalizable objects will be marked
#   in a sepearte postpass, and hence their memory won't be reclaimed.
#   Not recommended unless you are implementing a language that specifies
#   these semantics.  Since 5.0, determines only only the initial value
#   of GC_java_finalization variable.
# -DFINALIZE_ON_DEMAND causes finalizers to be run only in response
#   to explicit GC_invoke_finalizers() calls.
#   In 5.0 this became runtime adjustable, and this only determines the
#   initial value of GC_finalize_on_demand.
# -DATOMIC_UNCOLLECTABLE includes code for GC_malloc_atomic_uncollectable.
#   This is useful if either the vendor malloc implementation is poor,
#   or if REDIRECT_MALLOC is used.
# -DHBLKSIZE=ddd, where ddd is a power of 2 between 512 and 16384, explicitly
#   sets the heap block size.  Each heap block is devoted to a single size and
#   kind of object.  For the incremental collector it makes sense to match
#   the most likely page size.  Otherwise large values result in more
#   fragmentation, but generally better performance for large heaps.
# -DUSE_MMAP use MMAP instead of sbrk to get new memory.
#   Works for Solaris and Irix.
# -DUSE_MUNMAP causes memory to be returned to the OS under the right
#   circumstances.  This currently disables VM-based incremental collection.
#   This is currently experimental, and works only under some Unix,
#   Linux and Windows versions.
# -DMMAP_STACKS (for Solaris threads) Use mmap from /dev/zero rather than
#   GC_scratch_alloc() to get stack memory.
# -DPRINT_BLACK_LIST Whenever a black list entry is added, i.e. whenever
#   the garbage collector detects a value that looks almost, but not quite,
#   like a pointer, print both the address containing the value, and the
#   value of the near-bogus-pointer.  Can be used to identifiy regions of
#   memory that are likely to contribute misidentified pointers.
# -DKEEP_BACK_PTRS Add code to save back pointers in debugging headers
#   for objects allocated with the debugging allocator.  If all objects
#   through GC_MALLOC with GC_DEBUG defined, this allows the client
#   to determine how particular or randomly chosen objects are reachable
#   for debugging/profiling purposes.  The gc_backptr.h interface is
#   implemented only if this is defined.
# -DGC_ASSERTIONS Enable some internal GC assertion checking.  Currently
#   this facility is only used in a few places.  It is intended primarily
#   for debugging of the garbage collector itself, but could also
# -DDBG_HDRS_ALL Make sure that all objects have debug headers.  Increases
#   the reliability (from 99.9999% to 100% mod. bugs) of some of the debugging
#   code (especially KEEP_BACK_PTRS).  Makes -DSHORT_DBG_HDRS possible.
#   Assumes that all client allocation is done through debugging
#   allocators.
# -DSHORT_DBG_HDRS Assume that all objects have debug headers.  Shorten
#   the headers to minimize object size, at the expense of checking for
#   writes past the end of an object.  This is intended for environments
#   in which most client code is written in a "safe" language, such as
#   Scheme or Java.  Assumes that all client allocation is done using
#   the GC_debug_ functions, or through the macros that expand to these,
#   or by redirecting malloc to GC_debug_malloc_replacement.
#   (Also eliminates the field for the requested object size.)
#   occasionally be useful for debugging of client code.  Slows down the
#   collector somewhat, but not drastically.
# -DSAVE_CALL_COUNT=<n> Set the number of call frames saved with objects
#   allocated through the debugging interface.  Affects the amount of
#   information generated in leak reports.  Only matters on platforms
#   on which we can quickly generate call stacks, currently Linux/(X86 & SPARC)
#   and Solaris/SPARC and platforms that provide execinfo.h.
#   Default is zero.  On X86, client
#   code should NOT be compiled with -fomit-frame-pointer.
# -DSAVE_CALL_NARGS=<n> Set the number of functions arguments to be
#   saved with each call frame.  Default is zero.  Ignored if we
#   don't know how to retrieve arguments on the platform.
# -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
#   altered stubborn objects, at substantial performance cost.
#   Use only for debugging of the incremental collector.
# -DGC_GCJ_SUPPORT includes support for gcj (and possibly other systems
#   that include a pointer to a type descriptor in each allocated object).
#   Building this way requires an ANSI C compiler.
# -DUSE_I686_PREFETCH causes the collector to issue Pentium III style
#   prefetch instructions.  No effect except on X86 Linux platforms.
#   Assumes a very recent gcc-compatible compiler and assembler.
#   (Gas prefetcht0 support was added around May 1999.)
#   Empirically the code appears to still run correctly on Pentium II
#   processors, though with no performance benefit.  May not run on other
#   X86 processors?  In some cases this improves performance by
#   15% or so.
# -DUSE_3DNOW_PREFETCH causes the collector to issue AMD 3DNow style
#   prefetch instructions.  Same restrictions as USE_I686_PREFETCH.
#   Minimally tested.  Didn't appear to be an obvious win on a K6-2/500.
# -DUSE_PPC_PREFETCH causes the collector to issue PowerPC style
#   prefetch instructions.  No effect except on PowerPC OS X platforms.