summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorIvan Maidanski <ivmai@mail.ru>2011-07-26 18:09:54 +0200
committerIvan Maidanski <ivmai@mail.ru>2011-07-26 18:09:54 +0200
commite35a4171fe47dfbf847e08988ea6cec4dfc8d124 (patch)
tree25f3501669fbf24a4b370c4f8b0c0701b1da4062
parentffa0c9ea38b3dd87e91b5ed2118c74002fed6782 (diff)
gc7.0alpha1 tarball importgc7_0alpha1
-rw-r--r--BCC_MAKEFILE3
-rw-r--r--EMX_MAKEFILE5
-rw-r--r--MacOS.c8
-rw-r--r--Makefile53
-rw-r--r--Makefile.am14
-rw-r--r--Makefile.direct53
-rw-r--r--Makefile.dj5
-rw-r--r--Makefile.in19
-rw-r--r--NT_MAKEFILE4
-rw-r--r--NT_STATIC_THREADS_MAKEFILE6
-rw-r--r--NT_THREADS_MAKEFILE8
-rw-r--r--OS2_MAKEFILE2
-rw-r--r--PCR-Makefile2
-rw-r--r--SMakefile.amiga1
-rw-r--r--WCC_MAKEFILE18
-rw-r--r--aix_irix_threads.c12
-rw-r--r--allchblk.c175
-rw-r--r--alloc.c496
-rw-r--r--backgraph.c20
-rw-r--r--blacklst.c81
-rw-r--r--checksums.c47
-rwxr-xr-xconfigure174
-rw-r--r--configure.in40
-rw-r--r--darwin_stop_world.c34
-rw-r--r--dbg_mlc.c484
-rw-r--r--digimars.mak4
-rw-r--r--doc/Makefile.in2
-rw-r--r--doc/README2
-rw-r--r--doc/README.changes134
-rw-r--r--doc/README.environment20
-rw-r--r--doc/README.solaris24
-rw-r--r--dyn_load.c209
-rw-r--r--finalize.c232
-rw-r--r--gc.mak8
-rw-r--r--gc_dlopen.c4
-rw-r--r--gcc_support.c516
-rw-r--r--gcj_mlc.c136
-rw-r--r--headers.c128
-rw-r--r--if_mach.c5
-rw-r--r--if_not_there.c5
-rw-r--r--include/Makefile.am4
-rw-r--r--include/Makefile.in6
-rw-r--r--include/gc.h224
-rw-r--r--include/gc_alloc.h383
-rw-r--r--include/gc_config_macros.h7
-rw-r--r--include/gc_gcj.h12
-rw-r--r--include/gc_inl.h8
-rw-r--r--include/gc_local_alloc.h8
-rw-r--r--include/gc_mark.h46
-rw-r--r--include/gc_tiny_fl.h67
-rw-r--r--include/gc_typed.h16
-rw-r--r--include/new_gc_alloc.h64
-rw-r--r--include/private/dbg_mlc.h21
-rw-r--r--include/private/gc_hdrs.h67
-rw-r--r--include/private/gc_locks.h567
-rw-r--r--include/private/gc_pmark.h299
-rw-r--r--include/private/gc_priv.h859
-rw-r--r--include/private/gcconfig.h249
-rw-r--r--include/private/pthread_support.h29
-rw-r--r--include/private/solaris_threads.h37
-rw-r--r--include/private/specific.h3
-rw-r--r--mach_dep.c15
-rw-r--r--malloc.c311
-rw-r--r--mallocx.c363
-rw-r--r--mark.c749
-rw-r--r--mark_rts.c152
-rw-r--r--misc.c526
-rw-r--r--new_hblk.c122
-rw-r--r--obj_map.c131
-rw-r--r--os_dep.c1002
-rw-r--r--pcr_interface.c23
-rw-r--r--pthread_stop_world.c75
-rw-r--r--pthread_support.c227
-rw-r--r--ptr_chck.c126
-rw-r--r--real_malloc.c9
-rw-r--r--reclaim.c793
-rw-r--r--setjmp_t.c2
-rw-r--r--solaris_pthreads.c179
-rw-r--r--solaris_threads.c959
-rw-r--r--specific.c44
-rw-r--r--stubborn.c302
-rw-r--r--tests/test.c332
-rw-r--r--threadlibs.c9
-rw-r--r--typd_mlc.c293
-rw-r--r--version.h6
-rwxr-xr-xwin32_threads.c47
86 files changed, 4216 insertions, 8730 deletions
diff --git a/BCC_MAKEFILE b/BCC_MAKEFILE
index e21bc3d..b49d6b9 100644
--- a/BCC_MAKEFILE
+++ b/BCC_MAKEFILE
@@ -15,8 +15,7 @@ lib= $(bcbin)\tlib
link= $(bcbin)\ilink32
cflags= -O2 -R -v- -vi -H -H=gc.csm -I$(bcinclude);$(gcinclude1);$(gcinclude2) -L$(bclib) \
-w-pro -w-aus -w-par -w-ccc -w-rch -a4 -D__STDC__=0
-#defines= -DSILENT
-defines= -DSILENT -DALL_INTERIOR_POINTERS -DUSE_GENERIC -DNO_GETENV -DJAVA_FINALIZATION -DGC_OPERATOR_NEW_ARRAY
+defines= -DALL_INTERIOR_POINTERS -DUSE_GENERIC -DNO_GETENV -DJAVA_FINALIZATION -DGC_OPERATOR_NEW_ARRAY
.c.obj:
$(cc) @&&|
diff --git a/EMX_MAKEFILE b/EMX_MAKEFILE
index d7674b3..c7e5bb8 100644
--- a/EMX_MAKEFILE
+++ b/EMX_MAKEFILE
@@ -18,10 +18,9 @@ CC= gcc
CXX=g++
# Needed only for "make c++", which adds the c++ interface
-CFLAGS= -O -DALL_INTERIOR_POINTERS -DSILENT
+CFLAGS= -O -DALL_INTERIOR_POINTERS
# Setjmp_test may yield overly optimistic results when compiled
# without optimization.
-# -DSILENT disables statistics printing, and improves performance.
# -DCHECKSUMS reports on erroneously clear dirty bits, and unexpectedly
# altered stubborn objects, at substantial performance cost.
# -DFIND_LEAK causes the collector to assume that all inaccessible
@@ -74,7 +73,7 @@ all: gc.a gctest.exe
$(OBJS) test.o: $(srcdir)/gc_priv.h $(srcdir)/gc_hdrs.h $(srcdir)/gc.h \
$(srcdir)/gcconfig.h $(srcdir)/gc_typed.h
# The dependency on Makefile is needed. Changing
-# options such as -DSILENT affects the size of GC_arrays,
+# options affects the size of GC_arrays,
# invalidating all .o files that rely on gc_priv.h
mark.o typd_mlc.o finalize.o: $(srcdir)/include/gc_mark.h $(srcdir)/include/private/gc_pmark.h
diff --git a/MacOS.c b/MacOS.c
index cc12cd1..b56bea7 100644
--- a/MacOS.c
+++ b/MacOS.c
@@ -128,10 +128,12 @@ void GC_MacFreeTemporaryMemory()
}
theTemporaryMemory = NULL;
-# if !defined(SILENT) && !defined(SHARED_LIBRARY_BUILD)
- fprintf(stdout, "[total memory used: %ld bytes.]\n",
+# if !defined(SHARED_LIBRARY_BUILD)
+ if (GC_print_stats) {
+ fprintf(stdout, "[total memory used: %ld bytes.]\n",
totalMemoryUsed);
- fprintf(stdout, "[total collections: %ld.]\n", GC_gc_no);
+ fprintf(stdout, "[total collections: %ld.]\n", GC_gc_no);
+ }
# endif
}
}
diff --git a/Makefile b/Makefile
index 20fa40a..83d4d60 100644
--- a/Makefile
+++ b/Makefile
@@ -30,7 +30,13 @@ AS=as $(AS_ABI_FLAG)
srcdir= .
VPATH= $(srcdir)
-CFLAGS= -O -I$(srcdir)/include -DATOMIC_UNCOLLECTABLE -DNO_SIGNALS -DNO_EXECUTE_PERMISSION -DSILENT -DALL_INTERIOR_POINTERS
+# Atomic_ops installation directory. If this doesn't exist, we create
+# it from the included atomic_ops distribution.
+AO_VERSION=0.6
+AO_SRC_DIR=$(srcdir)/atomic_ops-$(AO_VERSION)
+AO_INSTALL_DIR=$(AO_SRC_DIR)/installed
+
+CFLAGS= -O -I$(srcdir)/include -I$(AO_INSTALL_DIR)/include -DATOMIC_UNCOLLECTABLE -DNO_EXECUTE_PERMISSION -DALL_INTERIOR_POINTERS
# To build the parallel collector on Linux, add to the above:
# -DGC_LINUX_THREADS -DPARALLEL_MARK -DTHREAD_LOCAL_ALLOC
@@ -54,7 +60,6 @@ HOSTCFLAGS=$(CFLAGS)
# 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.
@@ -96,13 +101,6 @@ HOSTCFLAGS=$(CFLAGS)
# 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
@@ -154,6 +152,14 @@ HOSTCFLAGS=$(CFLAGS)
# -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.
+# -DMARK_BIT_PER_GRANULE requests that a mark bit (or often byte)
+# be allocated for each allocation granule, as opposed to each object.
+# This often improves speed, possibly at some cost in space and/or
+# cache footprint. Normally it is best to let this decision be
+# made automatically depending on platform.
+# -DMARK_BIT_PER_OBJ requests that a mark bit be allocated for each
+# object instead of allocation granule. The opposiet of
+# MARK_BIT_PER_GRANULE.
# -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
@@ -276,6 +282,9 @@ HOSTCFLAGS=$(CFLAGS)
# -DPOINTER_SHIFT=n causes the collector to left shift candidate pointers
# by the indicated amount before trying to interpret them. Applied
# after POINTER_MASK. EXPERIMENTAL. See also the preceding macro.
+# -DENABLE_TRACE enables the GC_TRACE=addr environment setting to do its
+# job. By default this is not supported in order tokeep the marker as fast
+# as possible.
#
CXXFLAGS= $(CFLAGS)
@@ -283,25 +292,25 @@ AR= ar
RANLIB= ranlib
-OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dbg_mlc.o malloc.o stubborn.o checksums.o solaris_threads.o aix_irix_threads.o pthread_support.o pthread_stop_world.o darwin_stop_world.o typd_mlc.o ptr_chck.o mallocx.o solaris_pthreads.o gcj_mlc.o specific.o gc_dlopen.o backgraph.o win32_threads.o
+OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dbg_mlc.o malloc.o stubborn.o checksums.o aix_irix_threads.o pthread_support.o pthread_stop_world.o darwin_stop_world.o typd_mlc.o ptr_chck.o mallocx.o gcj_mlc.o specific.o gc_dlopen.o backgraph.o win32_threads.o
-CSRCS= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c checksums.c solaris_threads.c aix_irix_threads.c pthread_support.c pthread_stop_world.c darwin_stop_world.c typd_mlc.c ptr_chck.c mallocx.c solaris_pthreads.c gcj_mlc.c specific.c gc_dlopen.c backgraph.c win32_threads.c
+CSRCS= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c checksums.c aix_irix_threads.c pthread_support.c pthread_stop_world.c darwin_stop_world.c typd_mlc.c ptr_chck.c mallocx.c gcj_mlc.c specific.c gc_dlopen.c backgraph.c win32_threads.c
CORD_SRCS= cord/cordbscs.c cord/cordxtra.c cord/cordprnt.c cord/de.c cord/cordtest.c include/cord.h include/ec.h include/private/cord_pos.h cord/de_win.c cord/de_win.h cord/de_cmds.h cord/de_win.ICO cord/de_win.RC
CORD_OBJS= cord/cordbscs.o cord/cordxtra.o cord/cordprnt.o
SRCS= $(CSRCS) mips_sgi_mach_dep.s rs6000_mach_dep.s alpha_mach_dep.S \
- sparc_mach_dep.S include/gc.h include/gc_typed.h \
+ sparc_mach_dep.S include/gc.h include/gc_typed.h include/gc_tiny_fl.h \
include/private/gc_hdrs.h include/private/gc_priv.h \
include/private/gcconfig.h include/private/gc_pmark.h \
include/gc_inl.h include/gc_inline.h include/gc_mark.h \
threadlibs.c if_mach.c if_not_there.c gc_cpp.cc include/gc_cpp.h \
gcname.c include/weakpointer.h include/private/gc_locks.h \
- gcc_support.c mips_ultrix_mach_dep.s include/gc_alloc.h \
+ mips_ultrix_mach_dep.s \
include/new_gc_alloc.h include/gc_allocator.h \
include/javaxfc.h sparc_sunos4_mach_dep.s sparc_netbsd_mach_dep.s \
- include/private/solaris_threads.h include/gc_backptr.h \
+ include/gc_backptr.h \
hpux_test_and_clear.s include/gc_gcj.h \
include/gc_local_alloc.h include/private/dbg_mlc.h \
include/private/specific.h powerpc_darwin_mach_dep.s \
@@ -344,7 +353,7 @@ OTHER_FILES= Makefile setjmp_t.c callprocs pc_excludes \
Mac_files/datastart.c Mac_files/dataend.c \
Mac_files/MacOS_config.h Mac_files/MacOS_Test_config.h \
add_gc_prefix.c gc_cpp.cpp \
- version.h AmigaOS.c \
+ version.h AmigaOS.c atomic_ops-0.6.tar.gz \
$(TESTS) $(GNU_BUILD_FILES) $(OTHER_MAKEFILES)
CORD_INCLUDE_FILES= $(srcdir)/include/gc.h $(srcdir)/include/cord.h \
@@ -360,7 +369,7 @@ CURSES= -lcurses -ltermlib
# the SHELL environment variable.
SHELL= /bin/sh
-SPECIALCFLAGS = -I$(srcdir)/include
+SPECIALCFLAGS = -I$(srcdir)/include -I$(AO_INSTALL_DIR)/include
# Alternative flags to the C compiler for mach_dep.c.
# Mach_dep.c often doesn't like optimization, and it's
# not time-critical anyway.
@@ -368,6 +377,11 @@ SPECIALCFLAGS = -I$(srcdir)/include
all: gc.a gctest
+# if AO_INSTALL_DIR doesn't exist, we assume that it is pointing to
+# the default location, and we need to build
+$(AO_INSTALL_DIR):
+ tar xvfz $(AO_SRC_DIR).tar.gz; cd $(AO_SRC_DIR); make CC=$(CC) install
+
LEAKFLAGS=$(CFLAGS) -DFIND_LEAK
BSD-pkg-all: bsd-libgc.a bsd-libleak.a
@@ -397,17 +411,15 @@ $(OBJS) tests/test.o dyn_load.o dyn_load_sunos53.o: \
$(srcdir)/include/private/gc_hdrs.h $(srcdir)/include/private/gc_locks.h \
$(srcdir)/include/gc.h $(srcdir)/include/gc_pthread_redirects.h \
$(srcdir)/include/private/gcconfig.h $(srcdir)/include/gc_typed.h \
- $(srcdir)/include/gc_config_macros.h Makefile
+ $(srcdir)/include/gc_config_macros.h Makefile $(AO_INSTALL_DIR)
# The dependency on Makefile is needed. Changing
-# options such as -DSILENT affects the size of GC_arrays,
+# options affects the size of GC_arrays,
# invalidating all .o files that rely on gc_priv.h
mark.o typd_mlc.o finalize.o ptr_chck.o: $(srcdir)/include/gc_mark.h $(srcdir)/include/private/gc_pmark.h
specific.o pthread_support.o: $(srcdir)/include/private/specific.h
-solaris_threads.o solaris_pthreads.o: $(srcdir)/include/private/solaris_threads.h
-
dbg_mlc.o gcj_mlc.o: $(srcdir)/include/private/dbg_mlc.h
tests/test.o: tests $(srcdir)/tests/test.c
@@ -512,7 +524,6 @@ mach_dep.o: $(srcdir)/mach_dep.c $(srcdir)/mips_sgi_mach_dep.s \
./if_mach POWERPC DARWIN $(AS) -o mach_dep.o $(srcdir)/powerpc_darwin_mach_dep.s
./if_mach ALPHA LINUX $(CC) -c -o mach_dep.o $(srcdir)/alpha_mach_dep.S
./if_mach SPARC SUNOS5 $(CC) -c -o mach_dep.o $(srcdir)/sparc_mach_dep.S
- ./if_mach SPARC SUNOS4 $(AS) -o mach_dep.o $(srcdir)/sparc_sunos4_mach_dep.s
./if_mach SPARC OPENBSD $(AS) -o mach_dep.o $(srcdir)/sparc_sunos4_mach_dep.s
./if_mach SPARC NETBSD $(AS) -o mach_dep.o $(srcdir)/sparc_netbsd_mach_dep.s
./if_mach IA64 "" as $(AS_ABI_FLAG) -o ia64_save_regs_in_stack.o $(srcdir)/ia64_save_regs_in_stack.s
diff --git a/Makefile.am b/Makefile.am
index 0ee551e..6389d0b 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -34,7 +34,8 @@ lib_LTLIBRARIES = libgc.la $(extra)
include_HEADERS = include/gc.h include/gc_local_alloc.h \
include/gc_pthread_redirects.h include/gc_config_macros.h \
-include/leak_detector.h include/gc_typed.h @addincludes@
+include/leak_detector.h include/gc_typed.h include/gc_tiny_fl.h \
+@addincludes@
EXTRA_HEADERS = include/gc_cpp.h include/gc_allocator.h
@@ -53,9 +54,9 @@ backgraph.c win32_threads.c \
pthread_support.c pthread_stop_world.c darwin_stop_world.c \
$(asm_libgc_sources)
-# Include THREADDLLIBS here to ensure that the correct versions of
+# Include THREADLIBS here to ensure that the correct versions of
# linuxthread semaphore functions get linked:
-libgc_la_LIBADD = @addobjs@ $(THREADDLLIBS) $(UNWINDLIBS)
+libgc_la_LIBADD = @addobjs@ $(THREADLIBS) $(UNWINDLIBS)
libgc_la_DEPENDENCIES = @addobjs@
libgc_la_LDFLAGS = -version-info 1:2:0
@@ -65,7 +66,7 @@ EXTRA_libgc_la_SOURCES = alpha_mach_dep.S \
sparc_sunos4_mach_dep.s ia64_save_regs_in_stack.s
libgccpp_la_SOURCES = gc_cpp.cc
-libgccpp_la_LIBADD = $(THREADDLLIBS) $(UNWINDLIBS)
+libgccpp_la_LIBADD = $(THREADLIBS) $(UNWINDLIBS)
libgccpp_la_LDFLAGS = -version-info 1:2:0
EXTRA_DIST += alpha_mach_dep.S mips_sgi_mach_dep.s sparc_mach_dep.S
@@ -91,9 +92,9 @@ test_cpp.o: $(srcdir)/tests/test_cpp.cc
## are included in the distribution
# gctest_OBJECTS = test.o
gctest_SOURCES = tests/test.c
-gctest_LDADD = ./libgc.la $(THREADDLLIBS) $(UNWINDLIBS) $(EXTRA_TEST_LIBS)
+gctest_LDADD = ./libgc.la $(THREADLIBS) $(UNWINDLIBS) $(EXTRA_TEST_LIBS)
test_cpp_SOURCES = tests/test_cpp.cc
-test_cpp_LDADD = ./libgc.la ./libgccpp.la $(THREADDLLIBS) $(UNWINDLIBS) $(EXTRA_TEST_LIBS)
+test_cpp_LDADD = ./libgc.la ./libgccpp.la $(THREADLIBS) $(UNWINDLIBS) $(EXTRA_TEST_LIBS)
TESTS = gctest $(extra_checks)
@@ -106,6 +107,7 @@ include/gc_mark.h @addincludes@
## FIXME: we shouldn't have to do this, but automake forces us to.
.s.lo:
+.S.lo:
## We use -Wp,-P to strip #line directives. Irix `as' chokes on
## these.
$(LTCOMPILE) -Wp,-P -x assembler-with-cpp -c $<
diff --git a/Makefile.direct b/Makefile.direct
index 20fa40a..83d4d60 100644
--- a/Makefile.direct
+++ b/Makefile.direct
@@ -30,7 +30,13 @@ AS=as $(AS_ABI_FLAG)
srcdir= .
VPATH= $(srcdir)
-CFLAGS= -O -I$(srcdir)/include -DATOMIC_UNCOLLECTABLE -DNO_SIGNALS -DNO_EXECUTE_PERMISSION -DSILENT -DALL_INTERIOR_POINTERS
+# Atomic_ops installation directory. If this doesn't exist, we create
+# it from the included atomic_ops distribution.
+AO_VERSION=0.6
+AO_SRC_DIR=$(srcdir)/atomic_ops-$(AO_VERSION)
+AO_INSTALL_DIR=$(AO_SRC_DIR)/installed
+
+CFLAGS= -O -I$(srcdir)/include -I$(AO_INSTALL_DIR)/include -DATOMIC_UNCOLLECTABLE -DNO_EXECUTE_PERMISSION -DALL_INTERIOR_POINTERS
# To build the parallel collector on Linux, add to the above:
# -DGC_LINUX_THREADS -DPARALLEL_MARK -DTHREAD_LOCAL_ALLOC
@@ -54,7 +60,6 @@ HOSTCFLAGS=$(CFLAGS)
# 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.
@@ -96,13 +101,6 @@ HOSTCFLAGS=$(CFLAGS)
# 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
@@ -154,6 +152,14 @@ HOSTCFLAGS=$(CFLAGS)
# -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.
+# -DMARK_BIT_PER_GRANULE requests that a mark bit (or often byte)
+# be allocated for each allocation granule, as opposed to each object.
+# This often improves speed, possibly at some cost in space and/or
+# cache footprint. Normally it is best to let this decision be
+# made automatically depending on platform.
+# -DMARK_BIT_PER_OBJ requests that a mark bit be allocated for each
+# object instead of allocation granule. The opposiet of
+# MARK_BIT_PER_GRANULE.
# -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
@@ -276,6 +282,9 @@ HOSTCFLAGS=$(CFLAGS)
# -DPOINTER_SHIFT=n causes the collector to left shift candidate pointers
# by the indicated amount before trying to interpret them. Applied
# after POINTER_MASK. EXPERIMENTAL. See also the preceding macro.
+# -DENABLE_TRACE enables the GC_TRACE=addr environment setting to do its
+# job. By default this is not supported in order tokeep the marker as fast
+# as possible.
#
CXXFLAGS= $(CFLAGS)
@@ -283,25 +292,25 @@ AR= ar
RANLIB= ranlib
-OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dbg_mlc.o malloc.o stubborn.o checksums.o solaris_threads.o aix_irix_threads.o pthread_support.o pthread_stop_world.o darwin_stop_world.o typd_mlc.o ptr_chck.o mallocx.o solaris_pthreads.o gcj_mlc.o specific.o gc_dlopen.o backgraph.o win32_threads.o
+OBJS= alloc.o reclaim.o allchblk.o misc.o mach_dep.o os_dep.o mark_rts.o headers.o mark.o obj_map.o blacklst.o finalize.o new_hblk.o dbg_mlc.o malloc.o stubborn.o checksums.o aix_irix_threads.o pthread_support.o pthread_stop_world.o darwin_stop_world.o typd_mlc.o ptr_chck.o mallocx.o gcj_mlc.o specific.o gc_dlopen.o backgraph.o win32_threads.o
-CSRCS= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c checksums.c solaris_threads.c aix_irix_threads.c pthread_support.c pthread_stop_world.c darwin_stop_world.c typd_mlc.c ptr_chck.c mallocx.c solaris_pthreads.c gcj_mlc.c specific.c gc_dlopen.c backgraph.c win32_threads.c
+CSRCS= reclaim.c allchblk.c misc.c alloc.c mach_dep.c os_dep.c mark_rts.c headers.c mark.c obj_map.c pcr_interface.c blacklst.c finalize.c new_hblk.c real_malloc.c dyn_load.c dbg_mlc.c malloc.c stubborn.c checksums.c aix_irix_threads.c pthread_support.c pthread_stop_world.c darwin_stop_world.c typd_mlc.c ptr_chck.c mallocx.c gcj_mlc.c specific.c gc_dlopen.c backgraph.c win32_threads.c
CORD_SRCS= cord/cordbscs.c cord/cordxtra.c cord/cordprnt.c cord/de.c cord/cordtest.c include/cord.h include/ec.h include/private/cord_pos.h cord/de_win.c cord/de_win.h cord/de_cmds.h cord/de_win.ICO cord/de_win.RC
CORD_OBJS= cord/cordbscs.o cord/cordxtra.o cord/cordprnt.o
SRCS= $(CSRCS) mips_sgi_mach_dep.s rs6000_mach_dep.s alpha_mach_dep.S \
- sparc_mach_dep.S include/gc.h include/gc_typed.h \
+ sparc_mach_dep.S include/gc.h include/gc_typed.h include/gc_tiny_fl.h \
include/private/gc_hdrs.h include/private/gc_priv.h \
include/private/gcconfig.h include/private/gc_pmark.h \
include/gc_inl.h include/gc_inline.h include/gc_mark.h \
threadlibs.c if_mach.c if_not_there.c gc_cpp.cc include/gc_cpp.h \
gcname.c include/weakpointer.h include/private/gc_locks.h \
- gcc_support.c mips_ultrix_mach_dep.s include/gc_alloc.h \
+ mips_ultrix_mach_dep.s \
include/new_gc_alloc.h include/gc_allocator.h \
include/javaxfc.h sparc_sunos4_mach_dep.s sparc_netbsd_mach_dep.s \
- include/private/solaris_threads.h include/gc_backptr.h \
+ include/gc_backptr.h \
hpux_test_and_clear.s include/gc_gcj.h \
include/gc_local_alloc.h include/private/dbg_mlc.h \
include/private/specific.h powerpc_darwin_mach_dep.s \
@@ -344,7 +353,7 @@ OTHER_FILES= Makefile setjmp_t.c callprocs pc_excludes \
Mac_files/datastart.c Mac_files/dataend.c \
Mac_files/MacOS_config.h Mac_files/MacOS_Test_config.h \
add_gc_prefix.c gc_cpp.cpp \
- version.h AmigaOS.c \
+ version.h AmigaOS.c atomic_ops-0.6.tar.gz \
$(TESTS) $(GNU_BUILD_FILES) $(OTHER_MAKEFILES)
CORD_INCLUDE_FILES= $(srcdir)/include/gc.h $(srcdir)/include/cord.h \
@@ -360,7 +369,7 @@ CURSES= -lcurses -ltermlib
# the SHELL environment variable.
SHELL= /bin/sh
-SPECIALCFLAGS = -I$(srcdir)/include
+SPECIALCFLAGS = -I$(srcdir)/include -I$(AO_INSTALL_DIR)/include
# Alternative flags to the C compiler for mach_dep.c.
# Mach_dep.c often doesn't like optimization, and it's
# not time-critical anyway.
@@ -368,6 +377,11 @@ SPECIALCFLAGS = -I$(srcdir)/include
all: gc.a gctest
+# if AO_INSTALL_DIR doesn't exist, we assume that it is pointing to
+# the default location, and we need to build
+$(AO_INSTALL_DIR):
+ tar xvfz $(AO_SRC_DIR).tar.gz; cd $(AO_SRC_DIR); make CC=$(CC) install
+
LEAKFLAGS=$(CFLAGS) -DFIND_LEAK
BSD-pkg-all: bsd-libgc.a bsd-libleak.a
@@ -397,17 +411,15 @@ $(OBJS) tests/test.o dyn_load.o dyn_load_sunos53.o: \
$(srcdir)/include/private/gc_hdrs.h $(srcdir)/include/private/gc_locks.h \
$(srcdir)/include/gc.h $(srcdir)/include/gc_pthread_redirects.h \
$(srcdir)/include/private/gcconfig.h $(srcdir)/include/gc_typed.h \
- $(srcdir)/include/gc_config_macros.h Makefile
+ $(srcdir)/include/gc_config_macros.h Makefile $(AO_INSTALL_DIR)
# The dependency on Makefile is needed. Changing
-# options such as -DSILENT affects the size of GC_arrays,
+# options affects the size of GC_arrays,
# invalidating all .o files that rely on gc_priv.h
mark.o typd_mlc.o finalize.o ptr_chck.o: $(srcdir)/include/gc_mark.h $(srcdir)/include/private/gc_pmark.h
specific.o pthread_support.o: $(srcdir)/include/private/specific.h
-solaris_threads.o solaris_pthreads.o: $(srcdir)/include/private/solaris_threads.h
-
dbg_mlc.o gcj_mlc.o: $(srcdir)/include/private/dbg_mlc.h
tests/test.o: tests $(srcdir)/tests/test.c
@@ -512,7 +524,6 @@ mach_dep.o: $(srcdir)/mach_dep.c $(srcdir)/mips_sgi_mach_dep.s \
./if_mach POWERPC DARWIN $(AS) -o mach_dep.o $(srcdir)/powerpc_darwin_mach_dep.s
./if_mach ALPHA LINUX $(CC) -c -o mach_dep.o $(srcdir)/alpha_mach_dep.S
./if_mach SPARC SUNOS5 $(CC) -c -o mach_dep.o $(srcdir)/sparc_mach_dep.S
- ./if_mach SPARC SUNOS4 $(AS) -o mach_dep.o $(srcdir)/sparc_sunos4_mach_dep.s
./if_mach SPARC OPENBSD $(AS) -o mach_dep.o $(srcdir)/sparc_sunos4_mach_dep.s
./if_mach SPARC NETBSD $(AS) -o mach_dep.o $(srcdir)/sparc_netbsd_mach_dep.s
./if_mach IA64 "" as $(AS_ABI_FLAG) -o ia64_save_regs_in_stack.o $(srcdir)/ia64_save_regs_in_stack.s
diff --git a/Makefile.dj b/Makefile.dj
index 7757f15..4548feb 100644
--- a/Makefile.dj
+++ b/Makefile.dj
@@ -29,11 +29,10 @@ EXE_SUFFIX=.exe
srcdir= .
VPATH= $(srcdir)
-CFLAGS= -gstabs+ -O2 -I$(srcdir)/include -DATOMIC_UNCOLLECTABLE -DNO_SIGNALS -DALL_INTERIOR_POINTERS -DNO_EXECUTE_PERMISSION -DSILENT
+CFLAGS= -gstabs+ -O2 -I$(srcdir)/include -DATOMIC_UNCOLLECTABLE -DALL_INTERIOR_POINTERS -DNO_EXECUTE_PERMISSION
# Setjmp_test may yield overly optimistic results when compiled
# without optimization.
-# -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.
@@ -221,7 +220,7 @@ $(OBJS) test.o dyn_load.o dyn_load_sunos53.o: \
$(srcdir)/include/private/gcconfig.h $(srcdir)/include/gc_typed.h \
Makefile
# The dependency on Makefile is needed. Changing
-# options such as -DSILENT affects the size of GC_arrays,
+# options affects the size of GC_arrays,
# invalidating all .o files that rely on gc_priv.h
mark.o typd_mlc.o finalize.o: $(srcdir)/include/gc_mark.h
diff --git a/Makefile.in b/Makefile.in
index ef39e7d..0c353cf 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -108,7 +108,7 @@ OBJDUMP = @OBJDUMP@
PACKAGE = @PACKAGE@
RANLIB = @RANLIB@
STRIP = @STRIP@
-THREADDLLIBS = @THREADDLLIBS@
+THREADLIBS = @THREADLIBS@
UNWINDLIBS = @UNWINDLIBS@
VERSION = @VERSION@
addincludes = @addincludes@
@@ -168,7 +168,8 @@ lib_LTLIBRARIES = libgc.la $(extra)
include_HEADERS = include/gc.h include/gc_local_alloc.h \
include/gc_pthread_redirects.h include/gc_config_macros.h \
-include/leak_detector.h include/gc_typed.h @addincludes@
+include/leak_detector.h include/gc_typed.h include/gc_tiny_fl.h \
+@addincludes@
EXTRA_HEADERS = include/gc_cpp.h include/gc_allocator.h
@@ -186,9 +187,9 @@ pthread_support.c pthread_stop_world.c darwin_stop_world.c \
$(asm_libgc_sources)
-# Include THREADDLLIBS here to ensure that the correct versions of
+# Include THREADLIBS here to ensure that the correct versions of
# linuxthread semaphore functions get linked:
-libgc_la_LIBADD = @addobjs@ $(THREADDLLIBS) $(UNWINDLIBS)
+libgc_la_LIBADD = @addobjs@ $(THREADLIBS) $(UNWINDLIBS)
libgc_la_DEPENDENCIES = @addobjs@
libgc_la_LDFLAGS = -version-info 1:2:0
@@ -199,7 +200,7 @@ EXTRA_libgc_la_SOURCES = alpha_mach_dep.S \
libgccpp_la_SOURCES = gc_cpp.cc
-libgccpp_la_LIBADD = $(THREADDLLIBS) $(UNWINDLIBS)
+libgccpp_la_LIBADD = $(THREADLIBS) $(UNWINDLIBS)
libgccpp_la_LDFLAGS = -version-info 1:2:0
AM_CXXFLAGS = @GC_CFLAGS@
@@ -212,9 +213,9 @@ check_PROGRAMS = gctest $(extra_checks)
# gctest_OBJECTS = test.o
gctest_SOURCES = tests/test.c
-gctest_LDADD = ./libgc.la $(THREADDLLIBS) $(UNWINDLIBS) $(EXTRA_TEST_LIBS)
+gctest_LDADD = ./libgc.la $(THREADLIBS) $(UNWINDLIBS) $(EXTRA_TEST_LIBS)
test_cpp_SOURCES = tests/test_cpp.cc
-test_cpp_LDADD = ./libgc.la ./libgccpp.la $(THREADDLLIBS) $(UNWINDLIBS) $(EXTRA_TEST_LIBS)
+test_cpp_LDADD = ./libgc.la ./libgccpp.la $(THREADLIBS) $(UNWINDLIBS) $(EXTRA_TEST_LIBS)
TESTS = gctest $(extra_checks)
@@ -450,9 +451,6 @@ distclean-depend:
.S.obj:
$(CCASCOMPILE) -c `cygpath -w $<`
-.S.lo:
- $(LTCCASCOMPILE) -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$<
-
.c.o:
@AMDEP_TRUE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@
@@ -909,6 +907,7 @@ include/gc_pthread_redirects.h include/gc_config_macros.h \
include/gc_mark.h @addincludes@
.s.lo:
+.S.lo:
$(LTCOMPILE) -Wp,-P -x assembler-with-cpp -c $<
#
diff --git a/NT_MAKEFILE b/NT_MAKEFILE
index d1b6a5d..3d0e3a5 100644
--- a/NT_MAKEFILE
+++ b/NT_MAKEFILE
@@ -11,10 +11,10 @@ OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_r
all: gctest.exe cord\de.exe test_cpp.exe
.c.obj:
- $(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DSILENT -DALL_INTERIOR_POINTERS -D__STDC__ -DGC_NOT_DLL -DGC_BUILD $*.c /Fo$*.obj
+ $(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DALL_INTERIOR_POINTERS -D__STDC__ -DGC_NOT_DLL -DGC_BUILD $*.c /Fo$*.obj
.cpp.obj:
- $(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DSILENT -DALL_INTERIOR_POINTERS -DGC_NOT_DLL -DGC_BUILD $*.CPP /Fo$*.obj
+ $(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DALL_INTERIOR_POINTERS -DGC_NOT_DLL -DGC_BUILD $*.CPP /Fo$*.obj
$(OBJS) tests\test.obj: include\private\gc_priv.h include\private\gc_hdrs.h include\gc.h include\private\gcconfig.h include\private\gc_locks.h include\private\gc_pmark.h include\gc_mark.h
diff --git a/NT_STATIC_THREADS_MAKEFILE b/NT_STATIC_THREADS_MAKEFILE
index a7582af..cd951bf 100644
--- a/NT_STATIC_THREADS_MAKEFILE
+++ b/NT_STATIC_THREADS_MAKEFILE
@@ -1,4 +1,4 @@
-# Makefile for Windows NT. Assumes Microsoft compiler.
+# Makefile for Windows NT. Assumes Microsoft compiler, and a single thread.
# DLLs are included in the root set under NT, but not under win32S.
# Use "nmake nodebug=1 all" for optimized versions of library, gctest and editor.
@@ -11,10 +11,10 @@ OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_r
all: gctest.exe cord\de.exe test_cpp.exe
.c.obj:
- $(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DSILENT -DALL_INTERIOR_POINTERS -D__STDC__ -DGC_NOT_DLL -DGC_WIN32_THREADS $*.c /Fo$*.obj
+ $(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DALL_INTERIOR_POINTERS -D__STDC__ -DGC_NOT_DLL -DGC_WIN32_THREADS $*.c /Fo$*.obj
.cpp.obj:
- $(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DSILENT -DALL_INTERIOR_POINTERS -DGC_NOT_DLL $*.CPP -DGC_WIN32_THREADS /Fo$*.obj
+ $(cc) $(cdebug) $(cflags) $(cvars) -Iinclude -DALL_INTERIOR_POINTERS -DGC_NOT_DLL $*.CPP -DGC_WIN32_THREADS /Fo$*.obj
$(OBJS) tests\test.obj: include\private\gc_priv.h include\private\gc_hdrs.h include\gc.h include\private\gcconfig.h include\private\gc_locks.h include\private\gc_pmark.h include\gc_mark.h
diff --git a/NT_THREADS_MAKEFILE b/NT_THREADS_MAKEFILE
index 5f0b546..73cad89 100644
--- a/NT_THREADS_MAKEFILE
+++ b/NT_THREADS_MAKEFILE
@@ -114,8 +114,8 @@ CLEAN :
CPP=cl.exe
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "SILENT" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "GC_WIN32_THREADS" /FR /YX /c
-CPP_PROJ=/nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "SILENT" /D "GC_BUILD" /D\
+# ADD CPP /nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "GC_WIN32_THREADS" /FR /YX /c
+CPP_PROJ=/nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "GC_BUILD" /D\
"WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D\
"GC_WIN32_THREADS" /FR"$(INTDIR)/" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/" /c
CPP_OBJS=.\Release/
@@ -296,8 +296,8 @@ CLEAN :
CPP=cl.exe
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG" /D "SILENT" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "GC_WIN32_THREADS" /FR /YX /c
-CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG" /D "SILENT" /D "GC_BUILD"\
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "GC_WIN32_THREADS" /FR /YX /c
+CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG" /D "GC_BUILD"\
/D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D\
"GC_WIN32_THREADS" /FR"$(INTDIR)/" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/"\
/Fd"$(INTDIR)/" /c
diff --git a/OS2_MAKEFILE b/OS2_MAKEFILE
index 690598d..c6bad7a 100644
--- a/OS2_MAKEFILE
+++ b/OS2_MAKEFILE
@@ -10,7 +10,7 @@ OBJS= alloc.obj reclaim.obj allchblk.obj misc.obj mach_dep.obj os_dep.obj mark_r
CORDOBJS= cord\cordbscs.obj cord\cordxtra.obj cord\cordprnt.obj
CC= icc
-CFLAGS= /O /Q /DSILENT /DSMALL_CONFIG /DALL_INTERIOR_POINTERS
+CFLAGS= /O /Q /DSMALL_CONFIG /DALL_INTERIOR_POINTERS
# Use /Ti instead of /O for debugging
# Setjmp_test may yield overly optimistic results when compiled
# without optimization.
diff --git a/PCR-Makefile b/PCR-Makefile
index 1eae367..e165524 100644
--- a/PCR-Makefile
+++ b/PCR-Makefile
@@ -13,7 +13,7 @@ include ../config/common.mk
CPPFLAGS = $(INCLUDE) $(CONFIG_CPPFLAGS) \
-DPCR_NO_RENAME -DPCR_NO_HOSTDEP_ERR
-#CFLAGS = -DPCR -DSILENT $(CONFIG_CFLAGS)
+#CFLAGS = -DPCR $(CONFIG_CFLAGS)
CFLAGS = -DPCR $(CONFIG_CFLAGS)
SPECIALCFLAGS = # For code involving asm's
diff --git a/SMakefile.amiga b/SMakefile.amiga
index e208505..94fb723 100644
--- a/SMakefile.amiga
+++ b/SMakefile.amiga
@@ -26,7 +26,6 @@ OPTIMIZE=optimize optimizetime optglobal optimizerdepth=100 optimizerpeephole op
OPT= $(OPTIMIZE) CPU=$(CPU) math=$(MATH) NOSTACKCHECK VERBOSE \
MAPHUNK NOVERSION NOICONS nodebug \
-DEFINE SILENT \
parm=reg \
DEFINE __USE_SYSBASE
diff --git a/WCC_MAKEFILE b/WCC_MAKEFILE
index 32b01df..6b1d78b 100644
--- a/WCC_MAKEFILE
+++ b/WCC_MAKEFILE
@@ -25,7 +25,7 @@ CPU=5
OPTIM=-oneatx -s
#OPTIM=-ohneatx -s
-DEFS=-DALL_INTERIOR_POINTERS -DSILENT -DNO_SIGNALS #-DSMALL_CONFIG #-DGC_DEBUG
+DEFS=-DALL_INTERIOR_POINTERS #-DSMALL_CONFIG #-DGC_DEBUG
#####
@@ -98,13 +98,13 @@ gc.dll: $(OBJS) .AUTODEPEND
@for %i in ($(OBJS)) do @%append $*.lnk file '%i'
!ifeq CALLING s
@%append $*.lnk export GC_is_marked
- @%append $*.lnk export GC_incr_words_allocd
- @%append $*.lnk export GC_incr_mem_freed
+ @%append $*.lnk export GC_incr_bytes_allocd
+ @%append $*.lnk export GC_incr_bytes_freed
@%append $*.lnk export GC_generic_malloc_words_small
!else
@%append $*.lnk export GC_is_marked_
- @%append $*.lnk export GC_incr_words_allocd_
- @%append $*.lnk export GC_incr_mem_freed_
+ @%append $*.lnk export GC_incr_bytes_allocd_
+ @%append $*.lnk export GC_incr_bytes_freed_
@%append $*.lnk export GC_generic_malloc_words_small_
!endif
*wlink @$*.lnk
@@ -156,12 +156,12 @@ test_cpp.exe: test_cpp.obj gc.lib
@%append $*.lnk library gc.lib
!ifdef MAKE_AS_DLL
!ifeq CALLING s
- @%append $*.lnk import GC_incr_words_allocd gc
- @%append $*.lnk import GC_incr_mem_freed gc
+ @%append $*.lnk import GC_incr_bytes_allocd gc
+ @%append $*.lnk import GC_incr_bytes_freed gc
@%append $*.lnk import GC_generic_malloc_words_small gc
!else
- @%append $*.lnk import GC_incr_words_allocd_ gc
- @%append $*.lnk import GC_incr_mem_freed_ gc
+ @%append $*.lnk import GC_incr_bytes_allocd_ gc
+ @%append $*.lnk import GC_incr_bytes_freed_ gc
@%append $*.lnk import GC_generic_malloc_words_small_ gc
!endif
!endif
diff --git a/aix_irix_threads.c b/aix_irix_threads.c
index 5d27afd..f1cf14c 100644
--- a/aix_irix_threads.c
+++ b/aix_irix_threads.c
@@ -26,10 +26,9 @@
* as a base instead.
*/
-# include "private/gc_priv.h"
-
# if defined(GC_IRIX_THREADS) || defined(GC_AIX_THREADS)
+# include "private/gc_priv.h"
# include <pthread.h>
# include <assert.h>
# include <semaphore.h>
@@ -65,6 +64,8 @@ void GC_print_sig_mask()
}
#endif
+GC_bool GC_need_to_lock = FALSE;
+
/* We use the allocation lock to protect thread-related data structures. */
/* The set of all known threads. We intercept thread creation and */
@@ -583,6 +584,7 @@ GC_pthread_create(pthread_t *new_thread,
pthread_attr_getdetachstate(attr, &detachstate);
if (PTHREAD_CREATE_DETACHED == detachstate) my_flags |= DETACHED;
si -> flags = my_flags;
+ GC_need_to_lock = TRUE;
result = pthread_create(new_thread, attr, GC_start_routine, si);
/* Wait until child has been added to the thread table. */
@@ -617,9 +619,9 @@ VOLATILE GC_bool GC_collecting = 0; /* A hint that we're in the collector and
#define SLEEP_THRESHOLD 3
-volatile unsigned int GC_allocate_lock = 0;
-#define GC_TRY_LOCK() !GC_test_and_set(&GC_allocate_lock)
-#define GC_LOCK_TAKEN GC_allocate_lock
+volatile AO_TS_t GC_allocate_lock = 0;
+#define GC_TRY_LOCK() !AO_test_and_set_acquire(&GC_allocate_lock)
+#define GC_LOCK_TAKEN ((int)(GC_allocate_lock)) /* FIXME */
void GC_lock()
{
diff --git a/allchblk.c b/allchblk.c
index f9c31e0..7ed647a 100644
--- a/allchblk.c
+++ b/allchblk.c
@@ -106,40 +106,39 @@ void GC_print_hblkfreelist()
word total_free = 0;
hdr * hhdr;
word sz;
- int i;
+ unsigned i;
for (i = 0; i <= N_HBLK_FLS; ++i) {
h = GC_hblkfreelist[i];
# ifdef USE_MUNMAP
- if (0 != h) GC_printf1("Free list %ld:\n",
- (unsigned long)i);
+ if (0 != h) GC_printf("Free list %ld:\n",
+ (unsigned long)i);
# else
- if (0 != h) GC_printf2("Free list %ld (Total size %ld):\n",
- (unsigned long)i,
- (unsigned long)GC_free_bytes[i]);
+ if (0 != h) GC_printf("Free list %lu (Total size %lu):\n",
+ i, (unsigned long)GC_free_bytes[i]);
# endif
while (h != 0) {
hhdr = HDR(h);
sz = hhdr -> hb_sz;
- GC_printf2("\t0x%lx size %lu ", (unsigned long)h, (unsigned long)sz);
+ GC_printf("\t0x%lx size %lu ", (unsigned long)h, (unsigned long)sz);
total_free += sz;
if (GC_is_black_listed(h, HBLKSIZE) != 0) {
- GC_printf0("start black listed\n");
+ GC_printf("start black listed\n");
} else if (GC_is_black_listed(h, hhdr -> hb_sz) != 0) {
- GC_printf0("partially black listed\n");
+ GC_printf("partially black listed\n");
} else {
- GC_printf0("not black listed\n");
+ GC_printf("not black listed\n");
}
h = hhdr -> hb_next;
}
}
# ifndef USE_MUNMAP
if (total_free != GC_large_free_bytes) {
- GC_printf1("GC_large_free_bytes = %lu (INCONSISTENT!!)\n",
- (unsigned long) GC_large_free_bytes);
+ GC_printf("GC_large_free_bytes = %lu (INCONSISTENT!!)\n",
+ (unsigned long) GC_large_free_bytes);
}
# endif
- GC_printf1("Total of %lu bytes on free list\n", (unsigned long)total_free);
+ GC_printf("Total of %lu bytes on free list\n", (unsigned long)total_free);
}
/* Return the free list index on which the block described by the header */
@@ -178,12 +177,12 @@ void GC_dump_regions()
++i;
end = GC_heap_sects[i].hs_start + GC_heap_sects[i].hs_bytes;
}
- GC_printf2("***Section from 0x%lx to 0x%lx\n", start, end);
+ GC_printf("***Section from %p to %p\n", start, end);
for (p = start; p < end;) {
hhdr = HDR(p);
- GC_printf1("\t0x%lx ", (unsigned long)p);
+ GC_printf("\t%p ", p);
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
- GC_printf1("Missing header!!(%ld)\n", hhdr);
+ GC_printf("Missing header!!(%d)\n", hhdr);
p += HBLKSIZE;
continue;
}
@@ -192,25 +191,25 @@ void GC_dump_regions()
divHBLKSZ(hhdr -> hb_sz));
int actual_index;
- GC_printf1("\tfree block of size 0x%lx bytes",
- (unsigned long)(hhdr -> hb_sz));
+ GC_printf("\tfree block of size 0x%lx bytes",
+ (unsigned long)(hhdr -> hb_sz));
if (IS_MAPPED(hhdr)) {
- GC_printf0("\n");
+ GC_printf("\n");
} else {
- GC_printf0("(unmapped)\n");
+ GC_printf("(unmapped)\n");
}
actual_index = free_list_index_of(hhdr);
if (-1 == actual_index) {
- GC_printf1("\t\tBlock not on free list %ld!!\n",
- correct_index);
+ GC_printf("\t\tBlock not on free list %d!!\n",
+ correct_index);
} else if (correct_index != actual_index) {
- GC_printf2("\t\tBlock on list %ld, should be on %ld!!\n",
- actual_index, correct_index);
+ GC_printf("\t\tBlock on list %d, should be on %d!!\n",
+ actual_index, correct_index);
}
p += hhdr -> hb_sz;
} else {
- GC_printf1("\tused for blocks of size 0x%lx bytes\n",
- (unsigned long)WORDS_TO_BYTES(hhdr -> hb_sz));
+ GC_printf("\tused for blocks of size 0x%lx bytes\n",
+ (unsigned long)(hhdr -> hb_sz));
p += HBLKSIZE * OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz);
}
}
@@ -222,25 +221,56 @@ void GC_dump_regions()
/* Initialize hdr for a block containing the indicated size and */
/* kind of objects. */
/* Return FALSE on failure. */
-static GC_bool setup_header(hhdr, sz, kind, flags)
-register hdr * hhdr;
-word sz; /* object size in words */
-int kind;
-unsigned char flags;
+static GC_bool setup_header(hdr * hhdr, struct hblk *block, size_t byte_sz,
+ int kind, unsigned char flags)
{
- register word descr;
+ word descr;
+ size_t granules;
- /* Add description of valid object pointers */
- if (!GC_add_map_entry(sz)) return(FALSE);
- hhdr -> hb_map = GC_obj_map[sz > MAXOBJSZ? 0 : sz];
-
/* Set size, kind and mark proc fields */
- hhdr -> hb_sz = sz;
+ hhdr -> hb_sz = byte_sz;
hhdr -> hb_obj_kind = kind;
hhdr -> hb_flags = flags;
+ hhdr -> hb_block = block;
descr = GC_obj_kinds[kind].ok_descriptor;
- if (GC_obj_kinds[kind].ok_relocate_descr) descr += WORDS_TO_BYTES(sz);
+ if (GC_obj_kinds[kind].ok_relocate_descr) descr += byte_sz;
hhdr -> hb_descr = descr;
+
+# ifdef MARK_BIT_PER_OBJ
+ /* Set hb_inv_sz as portably as possible. */
+ /* We set it to the smallest value such that sz * inv_sz > 2**32 */
+ /* This may be more precision than necessary. */
+ if (byte_sz > MAXOBJBYTES) {
+ hhdr -> hb_inv_sz = LARGE_INV_SZ;
+ } else {
+ word inv_sz;
+
+# if CPP_WORDSZ == 64
+ inv_sz = ((word)1 << 32)/byte_sz;
+ if (((inv_sz*byte_sz) >> 32) == 0) ++inv_sz;
+# else /* 32 bit words */
+ GC_ASSERT(byte_sz >= 4);
+ inv_sz = ((unsigned)1 << 31)/byte_sz;
+ inv_sz *= 2;
+ while (inv_sz*byte_sz > byte_sz) ++inv_sz;
+# endif
+ hhdr -> hb_inv_sz = inv_sz;
+ }
+# else /* MARK_BIT_PER_GRANULE */
+ hhdr -> hb_large_block = (byte_sz > MAXOBJBYTES);
+ granules = BYTES_TO_GRANULES(byte_sz);
+ if (EXPECT(!GC_add_map_entry(granules), FALSE)) {
+ /* Make it look like a valid block. */
+ hhdr -> hb_sz = HBLKSIZE;
+ hhdr -> hb_descr = 0;
+ hhdr -> hb_large_block = TRUE;
+ hhdr -> hb_map = 0;
+ return FALSE;
+ } else {
+ int index = (hhdr -> hb_large_block? 0 : granules);
+ hhdr -> hb_map = GC_obj_map[index];
+ }
+# endif /* MARK_BIT_PER_GRANULE */
/* Clear mark bits */
GC_clear_hdr_marks(hhdr);
@@ -355,7 +385,7 @@ hdr * hhdr;
GET_HDR(second, second_hdr);
second_hdr -> hb_prev = h;
}
- GC_invalidate_map(hhdr);
+ hhdr -> hb_flags |= FREE_BLK;
}
#ifdef USE_MUNMAP
@@ -471,7 +501,7 @@ int index;
rest = (struct hblk *)((word)h + bytes);
rest_hdr = GC_install_header(rest);
if (0 == rest_hdr) {
- /* This may be very bad news ... */
+ /* FIXME: This is likely to be very bad news ... */
WARN("Header allocation failed: Dropping block.\n", 0);
return(0);
}
@@ -479,7 +509,7 @@ int index;
rest_hdr -> hb_flags = 0;
# ifdef GC_ASSERTIONS
/* Mark h not free, to avoid assertion about adjacent free blocks. */
- hhdr -> hb_map = 0;
+ hhdr -> hb_flags &= ~FREE_BLK;
# endif
GC_add_to_fl(rest, rest_hdr);
return h;
@@ -525,7 +555,8 @@ int index; /* Index of free list */
INCR_FREE_BYTES(index, -(signed_word)h_size);
FREE_ASSERT(GC_free_bytes[index] > 0);
# ifdef GC_ASSERTIONS
- nhdr -> hb_map = 0; /* Don't fail test for consecutive */
+ nhdr -> hb_flags &= ~FREE_BLK;
+ /* Don't fail test for consecutive */
/* free blocks in GC_add_to_fl. */
# endif
# ifdef USE_MUNMAP
@@ -533,30 +564,31 @@ int index; /* Index of free list */
# endif
hhdr -> hb_sz = h_size;
GC_add_to_fl(h, hhdr);
- GC_invalidate_map(nhdr);
+ nhdr -> hb_flags |= FREE_BLK;
}
-struct hblk * GC_allochblk_nth();
+struct hblk *
+GC_allochblk_nth(word sz/* bytes */, int kind, unsigned char flags, int n);
/*
* Allocate (and return pointer to) a heap block
- * for objects of size sz words, searching the nth free list.
+ * for objects of size sz bytes, searching the nth free list.
*
* NOTE: We set obj_map field in header correctly.
* Caller is responsible for building an object freelist in block.
*
- * Unlike older versions of the collectors, the client is responsible
- * for clearing the block, if necessary.
+ * The client is responsible for clearing the block, if necessary.
*/
struct hblk *
-GC_allochblk(sz, kind, flags)
-word sz;
-int kind;
-unsigned flags; /* IGNORE_OFF_PAGE or 0 */
+GC_allochblk(size_t sz, int kind, unsigned flags/* IGNORE_OFF_PAGE or 0 */)
{
- word blocks = OBJ_SZ_TO_BLOCKS(sz);
- int start_list = GC_hblk_fl_from_blocks(blocks);
+ word blocks;
+ int start_list;
int i;
+
+ GC_ASSERT((sz & (GRANULE_BYTES - 1)) == 0);
+ blocks = OBJ_SZ_TO_BLOCKS(sz);
+ start_list = GC_hblk_fl_from_blocks(blocks);
for (i = start_list; i <= N_HBLK_FLS; ++i) {
struct hblk * result = GC_allochblk_nth(sz, kind, flags, i);
if (0 != result) {
@@ -567,18 +599,18 @@ unsigned flags; /* IGNORE_OFF_PAGE or 0 */
}
/*
* The same, but with search restricted to nth free list.
+ * Flags is IGNORE_OFF_PAGE or zero.
+ * Unlike the above, sz is in bytes.
*/
struct hblk *
-GC_allochblk_nth(sz, kind, flags, n)
-word sz;
-int kind;
-unsigned char flags; /* IGNORE_OFF_PAGE or 0 */
-int n;
+GC_allochblk_nth(word sz, int kind, unsigned char flags, int n)
{
- register struct hblk *hbp;
- register hdr * hhdr; /* Header corr. to hbp */
- register struct hblk *thishbp;
- register hdr * thishdr; /* Header corr. to hbp */
+ struct hblk *hbp;
+ hdr * hhdr; /* Header corr. to hbp */
+ /* Initialized after loop if hbp !=0 */
+ /* Gcc uninitialized use warning is bogus. */
+ struct hblk *thishbp;
+ hdr * thishdr; /* Header corr. to hbp */
signed_word size_needed; /* number of bytes in requested objects */
signed_word size_avail; /* bytes available in this block */
@@ -609,8 +641,7 @@ int n;
/* If we are deallocating lots of memory from */
/* finalizers, fail and collect sooner rather */
/* than later. */
- if (WORDS_TO_BYTES(GC_finalizer_mem_freed)
- > (GC_heapsize >> 4)) {
+ if (GC_finalizer_bytes_freed > (GC_heapsize >> 4)) {
continue;
}
# endif /* !USE_MUNMAP */
@@ -700,14 +731,14 @@ int n;
struct hblk * h;
struct hblk * prev = hhdr -> hb_prev;
- GC_words_wasted += BYTES_TO_WORDS(total_size);
+ GC_bytes_wasted += total_size;
GC_large_free_bytes -= total_size;
GC_remove_from_fl(hhdr, n);
for (h = hbp; h < limit; h++) {
if (h == hbp || 0 != (hhdr = GC_install_header(h))) {
(void) setup_header(
- hhdr,
- BYTES_TO_WORDS(HBLKSIZE),
+ hhdr, h,
+ HBLKSIZE,
PTRFREE, 0); /* Cant fail */
if (GC_debugging_started) {
BZERO(h, HBLKSIZE);
@@ -745,7 +776,7 @@ int n;
/* This leaks memory under very rare conditions. */
/* Set up header */
- if (!setup_header(hhdr, sz, kind, flags)) {
+ if (!setup_header(hhdr, hbp, sz, kind, flags)) {
GC_remove_counts(hbp, (word)size_needed);
return(0); /* ditto */
}
@@ -779,8 +810,7 @@ struct hblk * GC_freehblk_ptr = 0; /* Search position hint for GC_freehblk */
* All mark words are assumed to be cleared.
*/
void
-GC_freehblk(hbp)
-struct hblk *hbp;
+GC_freehblk(struct hblk *hbp)
{
struct hblk *next, *prev;
hdr *hhdr, *prevhdr, *nexthdr;
@@ -798,13 +828,12 @@ signed_word size;
/* Check for duplicate deallocation in the easy case */
if (HBLK_IS_FREE(hhdr)) {
- GC_printf1("Duplicate large block deallocation of 0x%lx\n",
- (unsigned long) hbp);
+ GC_printf("Duplicate large block deallocation of %p\n", hbp);
ABORT("Duplicate large block deallocation");
}
GC_ASSERT(IS_MAPPED(hhdr));
- GC_invalidate_map(hhdr);
+ hhdr -> hb_flags |= FREE_BLK;
next = (struct hblk *)((word)hbp + size);
GET_HDR(next, nexthdr);
prev = GC_free_block_ending_at(hbp);
diff --git a/alloc.c b/alloc.c
index 53afa0d..834e8a0 100644
--- a/alloc.c
+++ b/alloc.c
@@ -2,7 +2,7 @@
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
* Copyright (c) 1991-1996 by Xerox Corporation. All rights reserved.
* Copyright (c) 1998 by Silicon Graphics. All rights reserved.
- * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
+ * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P.
*
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
@@ -26,7 +26,7 @@
/*
* Separate free lists are maintained for different sized objects
- * up to MAXOBJSZ.
+ * up to MAXOBJBYTES.
* The call GC_allocobj(i,k) ensures that the freelist for
* kind k objects of size i points to a non-empty
* free list. It returns a pointer to the first entry on the free list.
@@ -94,7 +94,7 @@ char * GC_copyright[] =
/* some more variables */
-extern signed_word GC_mem_found; /* Number of reclaimed longwords */
+extern signed_word GC_bytes_found; /* Number of reclaimed bytes */
/* after garbage collection */
GC_bool GC_dont_expand = 0;
@@ -104,7 +104,7 @@ word GC_free_space_divisor = 3;
extern GC_bool GC_collection_in_progress();
/* Collection is in progress, or was abandoned. */
-int GC_never_stop_func GC_PROTO((void)) { return(0); }
+int GC_never_stop_func (void) { return(0); }
unsigned long GC_time_limit = TIME_LIMIT;
@@ -117,7 +117,7 @@ int GC_n_attempts = 0; /* Number of attempts at finishing */
#if defined(SMALL_CONFIG) || defined(NO_CLOCK)
# define GC_timeout_stop_func GC_never_stop_func
#else
- int GC_timeout_stop_func GC_PROTO((void))
+ int GC_timeout_stop_func (void)
{
CLOCK_TYPE current_time;
static unsigned count = 0;
@@ -127,13 +127,11 @@ int GC_n_attempts = 0; /* Number of attempts at finishing */
GET_TIME(current_time);
time_diff = MS_TIME_DIFF(current_time,GC_start_time);
if (time_diff >= GC_time_limit) {
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf0("Abandoning stopped marking after ");
- GC_printf1("%lu msecs", (unsigned long)time_diff);
- GC_printf1("(attempt %ld)\n", (unsigned long) GC_n_attempts);
- }
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("Abandoning stopped marking after ");
+ GC_log_printf("%lu msecs", time_diff);
+ GC_log_printf("(attempt %d)\n", GC_n_attempts);
+ }
return(1);
}
return(0);
@@ -142,14 +140,14 @@ int GC_n_attempts = 0; /* Number of attempts at finishing */
/* Return the minimum number of words that must be allocated between */
/* collections to amortize the collection cost. */
-static word min_words_allocd()
+static word min_bytes_allocd()
{
# ifdef THREADS
/* We punt, for now. */
register signed_word stack_size = 10000;
# else
int dummy;
- register signed_word stack_size = (ptr_t)(&dummy) - GC_stackbottom;
+ signed_word stack_size = (ptr_t)(&dummy) - GC_stackbottom;
# endif
word total_root_size; /* includes double stack size, */
/* since the stack is expensive */
@@ -159,10 +157,8 @@ static word min_words_allocd()
if (stack_size < 0) stack_size = -stack_size;
total_root_size = 2 * stack_size + GC_root_size;
- scan_size = BYTES_TO_WORDS(GC_heapsize - GC_large_free_bytes
- + (GC_large_free_bytes >> 2)
- /* use a bit more of large empty heap */
- + total_root_size);
+ scan_size = 2 * GC_composite_in_use + GC_atomic_in_use
+ + total_root_size;
if (TRUE_INCREMENTAL) {
return scan_size / (2 * GC_free_space_divisor);
} else {
@@ -173,40 +169,39 @@ static word min_words_allocd()
/* Return the number of words allocated, adjusted for explicit storage */
/* management, etc.. This number is used in deciding when to trigger */
/* collections. */
-word GC_adj_words_allocd()
+word GC_adj_bytes_allocd(void)
{
register signed_word result;
register signed_word expl_managed =
- BYTES_TO_WORDS((long)GC_non_gc_bytes
- - (long)GC_non_gc_bytes_at_gc);
+ (long)GC_non_gc_bytes - (long)GC_non_gc_bytes_at_gc;
/* Don't count what was explicitly freed, or newly allocated for */
/* explicit management. Note that deallocating an explicitly */
/* managed object should not alter result, assuming the client */
/* is playing by the rules. */
- result = (signed_word)GC_words_allocd
- - (signed_word)GC_mem_freed
- + (signed_word)GC_finalizer_mem_freed - expl_managed;
- if (result > (signed_word)GC_words_allocd) {
- result = GC_words_allocd;
+ result = (signed_word)GC_bytes_allocd
+ - (signed_word)GC_bytes_freed
+ + (signed_word)GC_finalizer_bytes_freed
+ - expl_managed;
+ if (result > (signed_word)GC_bytes_allocd) {
+ result = GC_bytes_allocd;
/* probably client bug or unfortunate scheduling */
}
- result += GC_words_finalized;
+ result += GC_bytes_finalized;
/* We count objects enqueued for finalization as though they */
/* had been reallocated this round. Finalization is user */
/* visible progress. And if we don't count this, we have */
/* stability problems for programs that finalize all objects. */
- if ((GC_words_wasted >> 3) < result)
- result += GC_words_wasted;
+ result += GC_bytes_wasted;
/* This doesn't reflect useful work. But if there is lots of */
/* new fragmentation, the same is probably true of the heap, */
/* and the collection will be correspondingly cheaper. */
- if (result < (signed_word)(GC_words_allocd >> 3)) {
+ if (result < (signed_word)(GC_bytes_allocd >> 3)) {
/* Always count at least 1/8 of the allocations. We don't want */
/* to collect too infrequently, since that would inhibit */
/* coalescing of free storage blocks. */
/* This also makes us partially robust against client bugs. */
- return(GC_words_allocd >> 3);
+ return(GC_bytes_allocd >> 3);
} else {
return(result);
}
@@ -232,16 +227,16 @@ void GC_clear_a_few_frames()
static word GC_collect_at_heapsize = (word)(-1);
/* Have we allocated enough to amortize a collection? */
-GC_bool GC_should_collect()
+GC_bool GC_should_collect(void)
{
- return(GC_adj_words_allocd() >= min_words_allocd()
+ return(GC_adj_bytes_allocd() >= min_bytes_allocd()
|| GC_heapsize >= GC_collect_at_heapsize);
}
-void GC_notify_full_gc()
+void GC_notify_full_gc(void)
{
- if (GC_start_call_back != (void (*) GC_PROTO((void)))0) {
+ if (GC_start_call_back != (void (*) (void))0) {
(*GC_start_call_back)();
}
}
@@ -254,7 +249,7 @@ GC_bool GC_is_full_gc = FALSE;
* between partial, full, and stop-world collections.
* Assumes lock held, signals disabled.
*/
-void GC_maybe_gc()
+void GC_maybe_gc(void)
{
static int n_partial_gcs = 0;
@@ -268,14 +263,12 @@ void GC_maybe_gc()
GC_wait_for_reclaim();
# endif
if (GC_need_full_gc || n_partial_gcs >= GC_full_freq) {
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf2(
+ if (GC_print_stats) {
+ GC_log_printf(
"***>Full mark for collection %lu after %ld allocd bytes\n",
- (unsigned long) GC_gc_no+1,
- (long)WORDS_TO_BYTES(GC_words_allocd));
- }
-# endif
+ (unsigned long)GC_gc_no+1,
+ (long)GC_bytes_allocd);
+ }
GC_promote_black_lists();
(void)GC_reclaim_all((GC_stop_func)0, TRUE);
GC_clear_marks();
@@ -313,20 +306,15 @@ void GC_maybe_gc()
* If stop_func is not GC_never_stop_func, then abort if stop_func returns TRUE.
* Return TRUE if we successfully completed the collection.
*/
-GC_bool GC_try_to_collect_inner(stop_func)
-GC_stop_func stop_func;
+GC_bool GC_try_to_collect_inner(GC_stop_func stop_func)
{
-# ifdef CONDPRINT
- CLOCK_TYPE start_time, current_time;
-# endif
+ CLOCK_TYPE start_time, current_time;
if (GC_dont_gc) return FALSE;
if (GC_incremental && GC_collection_in_progress()) {
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf0(
+ if (GC_print_stats) {
+ GC_log_printf(
"GC_try_to_collect_inner: finishing collection in progress\n");
- }
-# endif /* CONDPRINT */
+ }
/* Just finish collection already in progress. */
while(GC_collection_in_progress()) {
if (stop_func()) return(FALSE);
@@ -334,15 +322,12 @@ GC_stop_func stop_func;
}
}
if (stop_func == GC_never_stop_func) GC_notify_full_gc();
-# ifdef CONDPRINT
- if (GC_print_stats) {
- if (GC_print_stats) GET_TIME(start_time);
- GC_printf2(
+ if (GC_print_stats) {
+ GET_TIME(start_time);
+ GC_log_printf(
"Initiating full world-stop collection %lu after %ld allocd bytes\n",
- (unsigned long) GC_gc_no+1,
- (long)WORDS_TO_BYTES(GC_words_allocd));
- }
-# endif
+ (unsigned long)GC_gc_no+1, (long)GC_bytes_allocd);
+ }
GC_promote_black_lists();
/* Make sure all blocks have been reclaimed, so sweep routines */
/* don't see cleared mark bits. */
@@ -375,13 +360,11 @@ GC_stop_func stop_func;
return(FALSE);
}
GC_finish_collection();
-# if defined(CONDPRINT)
- if (GC_print_stats) {
+ if (GC_print_stats) {
GET_TIME(current_time);
- GC_printf1("Complete collection took %lu msecs\n",
- MS_TIME_DIFF(current_time,start_time));
- }
-# endif
+ GC_log_printf("Complete collection took %lu msecs\n",
+ MS_TIME_DIFF(current_time,start_time));
+ }
return(TRUE);
}
@@ -404,10 +387,9 @@ GC_stop_func stop_func;
int GC_deficit = 0; /* The number of extra calls to GC_mark_some */
/* that we have made. */
-void GC_collect_a_little_inner(n)
-int n;
+void GC_collect_a_little_inner(int n)
{
- register int i;
+ int i;
if (GC_dont_gc) return;
if (GC_incremental && GC_collection_in_progress()) {
@@ -441,17 +423,15 @@ int n;
}
}
-int GC_collect_a_little GC_PROTO(())
+int GC_collect_a_little(void)
{
int result;
DCL_LOCK_STATE;
- DISABLE_SIGNALS();
LOCK();
GC_collect_a_little_inner(1);
result = (int)GC_collection_in_progress();
UNLOCK();
- ENABLE_SIGNALS();
if (!result && GC_debugging_started) GC_print_all_smashed();
return(result);
}
@@ -462,35 +442,27 @@ int GC_collect_a_little GC_PROTO(())
* If stop_func() ever returns TRUE, we may fail and return FALSE.
* Increment GC_gc_no if we succeed.
*/
-GC_bool GC_stopped_mark(stop_func)
-GC_stop_func stop_func;
+GC_bool GC_stopped_mark(GC_stop_func stop_func)
{
- register int i;
+ unsigned i;
int dummy;
-# if defined(PRINTTIMES) || defined(CONDPRINT)
- CLOCK_TYPE start_time, current_time;
-# endif
+ CLOCK_TYPE start_time, current_time;
-# ifdef PRINTTIMES
+ if (GC_print_stats)
GET_TIME(start_time);
-# endif
-# if defined(CONDPRINT) && !defined(PRINTTIMES)
- if (GC_print_stats) GET_TIME(start_time);
-# endif
+
# if defined(REGISTER_LIBRARIES_EARLY)
GC_cond_register_dynamic_libraries();
# endif
STOP_WORLD();
IF_THREADS(GC_world_stopped = TRUE);
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf1("--> Marking for collection %lu ",
- (unsigned long) GC_gc_no + 1);
- GC_printf2("after %lu allocd bytes + %lu wasted bytes\n",
- (unsigned long) WORDS_TO_BYTES(GC_words_allocd),
- (unsigned long) WORDS_TO_BYTES(GC_words_wasted));
- }
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("--> Marking for collection %lu ",
+ (unsigned long)GC_gc_no + 1);
+ GC_log_printf("after %lu allocd bytes + %lu wasted bytes\n",
+ (unsigned long) GC_bytes_allocd,
+ (unsigned long) GC_bytes_wasted);
+ }
# ifdef MAKE_BACK_GRAPH
if (GC_print_back_height) {
GC_build_back_graph();
@@ -504,13 +476,10 @@ GC_stop_func stop_func;
GC_initiate_gc();
for(i = 0;;i++) {
if ((*stop_func)()) {
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf0("Abandoned stopped marking after ");
- GC_printf1("%lu iterations\n",
- (unsigned long)i);
- }
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("Abandoned stopped marking after ");
+ GC_log_printf("%u iterations\n", i);
+ }
GC_deficit = i; /* Give the mutator a chance. */
IF_THREADS(GC_world_stopped = FALSE);
START_WORLD();
@@ -520,26 +489,16 @@ GC_stop_func stop_func;
}
GC_gc_no++;
-# ifdef PRINTSTATS
- GC_printf2("Collection %lu reclaimed %ld bytes",
- (unsigned long) GC_gc_no - 1,
- (long)WORDS_TO_BYTES(GC_mem_found));
-# else
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf1("Collection %lu finished", (unsigned long) GC_gc_no - 1);
- }
-# endif
-# endif /* !PRINTSTATS */
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf1(" ---> heapsize = %lu bytes\n",
- (unsigned long) GC_heapsize);
+ if (GC_print_stats) {
+ GC_log_printf("Collection %lu reclaimed %ld bytes",
+ (unsigned long)GC_gc_no - 1,
+ (long)GC_bytes_found);
+ GC_log_printf(" ---> heapsize = %lu bytes\n",
+ (unsigned long) GC_heapsize);
/* Printf arguments may be pushed in funny places. Clear the */
/* space. */
- GC_printf0("");
- }
-# endif /* CONDPRINT */
+ GC_log_printf("");
+ }
/* Check all debugged objects for consistency */
if (GC_debugging_started) {
@@ -548,90 +507,103 @@ GC_stop_func stop_func;
IF_THREADS(GC_world_stopped = FALSE);
START_WORLD();
-# ifdef PRINTTIMES
- GET_TIME(current_time);
- GC_printf1("World-stopped marking took %lu msecs\n",
- MS_TIME_DIFF(current_time,start_time));
-# else
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GET_TIME(current_time);
- GC_printf1("World-stopped marking took %lu msecs\n",
- MS_TIME_DIFF(current_time,start_time));
- }
-# endif
-# endif
+ if (GC_print_stats) {
+ GET_TIME(current_time);
+ GC_log_printf("World-stopped marking took %lu msecs\n",
+ MS_TIME_DIFF(current_time,start_time));
+ }
return(TRUE);
}
/* Set all mark bits for the free list whose first entry is q */
-#ifdef __STDC__
- void GC_set_fl_marks(ptr_t q)
-#else
- void GC_set_fl_marks(q)
- ptr_t q;
-#endif
+void GC_set_fl_marks(ptr_t q)
{
ptr_t p;
struct hblk * h, * last_h = 0;
- hdr *hhdr;
- int word_no;
+ hdr *hhdr; /* gcc "might be uninitialized" warning is bogus. */
+ IF_PER_OBJ(size_t sz;)
+ int bit_no;
for (p = q; p != 0; p = obj_link(p)){
h = HBLKPTR(p);
if (h != last_h) {
last_h = h;
hhdr = HDR(h);
+ IF_PER_OBJ(sz = hhdr->hb_sz;)
}
- word_no = (((word *)p) - ((word *)h));
- set_mark_bit_from_hdr(hhdr, word_no);
+ bit_no = MARK_BIT_NO((ptr_t)p - (ptr_t)h, sz);
+ if (!mark_bit_from_hdr(hhdr, bit_no)) {
+ set_mark_bit_from_hdr(hhdr, bit_no);
+ ++hhdr -> hb_n_marks;
+ }
}
}
-/* Clear all mark bits for the free list whose first entry is q */
-/* Decrement GC_mem_found by number of words on free list. */
-#ifdef __STDC__
- void GC_clear_fl_marks(ptr_t q)
-#else
- void GC_clear_fl_marks(q)
- ptr_t q;
+#ifdef GC_ASSERTIONS
+/* Check that all mark bits for the free list whose first entry is q */
+/* are set. */
+void GC_check_fl_marks(ptr_t q)
+{
+ ptr_t p;
+
+ for (p = q; p != 0; p = obj_link(p)){
+ if (!GC_is_marked(p)) {
+ GC_err_printf("Unmarked object %p on list %p\n", p, q);
+ ABORT("Unmarked local free list entry.");
+ }
+ }
+}
#endif
+
+/* Clear all mark bits for the free list whose first entry is q */
+/* Decrement GC_bytes_found by number of bytes on free list. */
+void GC_clear_fl_marks(ptr_t q)
{
ptr_t p;
struct hblk * h, * last_h = 0;
hdr *hhdr;
- int word_no;
+ size_t sz;
+ int bit_no;
for (p = q; p != 0; p = obj_link(p)){
h = HBLKPTR(p);
if (h != last_h) {
last_h = h;
hhdr = HDR(h);
+ sz = hhdr->hb_sz; /* Normally set only once. */
}
- word_no = (((word *)p) - ((word *)h));
- clear_mark_bit_from_hdr(hhdr, word_no);
-# ifdef GATHERSTATS
- GC_mem_found -= hhdr -> hb_sz;
-# endif
+ bit_no = MARK_BIT_NO((ptr_t)p - (ptr_t)h, sz);
+ if (mark_bit_from_hdr(hhdr, bit_no)) {
+ clear_mark_bit_from_hdr(hhdr, bit_no);
+ --hhdr -> hb_n_marks;
+ }
+ GC_bytes_found -= sz;
}
}
+#if defined(GC_ASSERTIONS) && defined(GC_LINUX_THREADS)
+extern void GC_check_tls(void);
+#endif
+
/* Finish up a collection. Assumes lock is held, signals are disabled, */
/* but the world is otherwise running. */
void GC_finish_collection()
{
-# ifdef PRINTTIMES
- CLOCK_TYPE start_time;
- CLOCK_TYPE finalize_time;
- CLOCK_TYPE done_time;
+ CLOCK_TYPE start_time;
+ CLOCK_TYPE finalize_time;
+ CLOCK_TYPE done_time;
- GET_TIME(start_time);
- finalize_time = start_time;
+# if defined(GC_ASSERTIONS) && defined(GC_LINUX_THREADS) \
+ && defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
+ /* Check that we marked some of our own data. */
+ /* FIXME: Add more checks. */
+ GC_check_tls();
# endif
-# ifdef GATHERSTATS
- GC_mem_found = 0;
-# endif
+ if (GC_print_stats)
+ GET_TIME(start_time);
+
+ GC_bytes_found = 0;
# if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG)
if (getenv("GC_PRINT_ADDRESS_MAP") != 0) {
GC_print_address_map();
@@ -647,7 +619,7 @@ void GC_finish_collection()
ptr_t q;
for (kind = 0; kind < GC_n_kinds; kind++) {
- for (size = 1; size <= MAXOBJSZ; size++) {
+ for (size = 1; size <= MAXOBJGRANULES; size++) {
q = GC_obj_kinds[kind].ok_freelist[size];
if (q != 0) GC_set_fl_marks(q);
}
@@ -662,24 +634,23 @@ void GC_finish_collection()
GC_clean_changing_list();
# endif
-# ifdef PRINTTIMES
+ if (GC_print_stats)
GET_TIME(finalize_time);
-# endif
if (GC_print_back_height) {
# ifdef MAKE_BACK_GRAPH
GC_traverse_back_graph();
# else
# ifndef SMALL_CONFIG
- GC_err_printf0("Back height not available: "
- "Rebuild collector with -DMAKE_BACK_GRAPH\n");
+ GC_err_printf("Back height not available: "
+ "Rebuild collector with -DMAKE_BACK_GRAPH\n");
# endif
# endif
}
/* Clear free list mark bits, in case they got accidentally marked */
/* (or GC_find_leak is set and they were intentionally marked). */
- /* Also subtract memory remaining from GC_mem_found count. */
+ /* Also subtract memory remaining from GC_bytes_found count. */
/* Note that composite objects on free list are cleared. */
/* Thus accidentally marking a free list is not a problem; only */
/* objects on the list itself will be marked, and that's fixed here. */
@@ -689,7 +660,7 @@ void GC_finish_collection()
int kind;
for (kind = 0; kind < GC_n_kinds; kind++) {
- for (size = 1; size <= MAXOBJSZ; size++) {
+ for (size = 1; size <= MAXOBJGRANULES; size++) {
q = GC_obj_kinds[kind].ok_freelist[size];
if (q != 0) GC_clear_fl_marks(q);
}
@@ -697,70 +668,67 @@ void GC_finish_collection()
}
-# ifdef PRINTSTATS
- GC_printf1("Bytes recovered before sweep - f.l. count = %ld\n",
- (long)WORDS_TO_BYTES(GC_mem_found));
-# endif
+ if (GC_print_stats == VERBOSE)
+ GC_log_printf("Bytes recovered before sweep - f.l. count = %ld\n",
+ (long)GC_bytes_found);
+
/* Reconstruct free lists to contain everything not marked */
GC_start_reclaim(FALSE);
+ if (GC_print_stats) {
+ GC_log_printf("Heap contains %lu pointer-containing "
+ "+ %lu pointer-free reachable bytes\n",
+ (unsigned long)GC_composite_in_use,
+ (unsigned long)GC_atomic_in_use);
+ }
if (GC_is_full_gc) {
GC_used_heap_size_after_full = USED_HEAP_SIZE;
GC_need_full_gc = FALSE;
} else {
GC_need_full_gc =
- BYTES_TO_WORDS(USED_HEAP_SIZE - GC_used_heap_size_after_full)
- > min_words_allocd();
+ USED_HEAP_SIZE - GC_used_heap_size_after_full
+ > min_bytes_allocd();
}
-# ifdef PRINTSTATS
- GC_printf2(
+ if (GC_print_stats == VERBOSE) {
+ GC_log_printf(
"Immediately reclaimed %ld bytes in heap of size %lu bytes",
- (long)WORDS_TO_BYTES(GC_mem_found),
+ (long)GC_bytes_found,
(unsigned long)GC_heapsize);
# ifdef USE_MUNMAP
- GC_printf1("(%lu unmapped)", GC_unmapped_bytes);
+ GC_log_printf("(%lu unmapped)", (unsigned long)GC_unmapped_bytes);
# endif
- GC_printf2(
- "\n%lu (atomic) + %lu (composite) collectable bytes in use\n",
- (unsigned long)WORDS_TO_BYTES(GC_atomic_in_use),
- (unsigned long)WORDS_TO_BYTES(GC_composite_in_use));
-# endif
+ GC_log_printf("\n");
+ }
+ /* Reset or increment counters for next cycle */
GC_n_attempts = 0;
GC_is_full_gc = FALSE;
- /* Reset or increment counters for next cycle */
- GC_words_allocd_before_gc += GC_words_allocd;
+ GC_bytes_allocd_before_gc += GC_bytes_allocd;
GC_non_gc_bytes_at_gc = GC_non_gc_bytes;
- GC_words_allocd = 0;
- GC_words_wasted = 0;
- GC_mem_freed = 0;
- GC_finalizer_mem_freed = 0;
+ GC_bytes_allocd = 0;
+ GC_bytes_wasted = 0;
+ GC_bytes_freed = 0;
+ GC_finalizer_bytes_freed = 0;
# ifdef USE_MUNMAP
GC_unmap_old();
# endif
-# ifdef PRINTTIMES
+ if (GC_print_stats) {
GET_TIME(done_time);
- GC_printf2("Finalize + initiate sweep took %lu + %lu msecs\n",
- MS_TIME_DIFF(finalize_time,start_time),
- MS_TIME_DIFF(done_time,finalize_time));
-# endif
+ GC_log_printf("Finalize + initiate sweep took %lu + %lu msecs\n",
+ MS_TIME_DIFF(finalize_time,start_time),
+ MS_TIME_DIFF(done_time,finalize_time));
+ }
}
/* Externally callable routine to invoke full, stop-world collection */
-# if defined(__STDC__) || defined(__cplusplus)
- int GC_try_to_collect(GC_stop_func stop_func)
-# else
- int GC_try_to_collect(stop_func)
- GC_stop_func stop_func;
-# endif
+int GC_try_to_collect(GC_stop_func stop_func)
{
int result;
DCL_LOCK_STATE;
if (GC_debugging_started) GC_print_all_smashed();
GC_INVOKE_FINALIZERS();
- DISABLE_SIGNALS();
LOCK();
ENTER_GC();
if (!GC_is_initialized) GC_init_inner();
@@ -769,7 +737,6 @@ void GC_finish_collection()
result = (int)GC_try_to_collect_inner(stop_func);
EXIT_GC();
UNLOCK();
- ENABLE_SIGNALS();
if(result) {
if (GC_debugging_started) GC_print_all_smashed();
GC_INVOKE_FINALIZERS();
@@ -777,7 +744,7 @@ void GC_finish_collection()
return(result);
}
-void GC_gcollect GC_PROTO(())
+void GC_gcollect(void)
{
(void)GC_try_to_collect(GC_never_stop_func);
if (GC_have_errors) GC_print_all_errors();
@@ -789,11 +756,8 @@ word GC_n_heap_sects = 0; /* Number of sections currently in heap. */
* Use the chunk of memory starting at p of size bytes as part of the heap.
* Assumes p is HBLKSIZE aligned, and bytes is a multiple of HBLKSIZE.
*/
-void GC_add_to_heap(p, bytes)
-struct hblk *p;
-word bytes;
+void GC_add_to_heap(struct hblk *p, size_t bytes)
{
- word words;
hdr * phdr;
if (GC_n_heap_sects >= MAX_HEAP_SECTS) {
@@ -809,69 +773,60 @@ word bytes;
GC_heap_sects[GC_n_heap_sects].hs_start = (ptr_t)p;
GC_heap_sects[GC_n_heap_sects].hs_bytes = bytes;
GC_n_heap_sects++;
- words = BYTES_TO_WORDS(bytes);
- phdr -> hb_sz = words;
- phdr -> hb_map = (unsigned char *)1; /* A value != GC_invalid_map */
+ phdr -> hb_sz = bytes;
phdr -> hb_flags = 0;
GC_freehblk(p);
GC_heapsize += bytes;
if ((ptr_t)p <= (ptr_t)GC_least_plausible_heap_addr
|| GC_least_plausible_heap_addr == 0) {
- GC_least_plausible_heap_addr = (GC_PTR)((ptr_t)p - sizeof(word));
+ GC_least_plausible_heap_addr = (void *)((ptr_t)p - sizeof(word));
/* Making it a little smaller than necessary prevents */
/* us from getting a false hit from the variable */
/* itself. There's some unintentional reflection */
/* here. */
}
if ((ptr_t)p + bytes >= (ptr_t)GC_greatest_plausible_heap_addr) {
- GC_greatest_plausible_heap_addr = (GC_PTR)((ptr_t)p + bytes);
+ GC_greatest_plausible_heap_addr = (void *)((ptr_t)p + bytes);
}
}
# if !defined(NO_DEBUGGING)
-void GC_print_heap_sects()
+void GC_print_heap_sects(void)
{
register unsigned i;
- GC_printf1("Total heap size: %lu\n", (unsigned long) GC_heapsize);
+ GC_printf("Total heap size: %lu\n", (unsigned long) GC_heapsize);
for (i = 0; i < GC_n_heap_sects; i++) {
- unsigned long start = (unsigned long) GC_heap_sects[i].hs_start;
+ ptr_t start = GC_heap_sects[i].hs_start;
unsigned long len = (unsigned long) GC_heap_sects[i].hs_bytes;
struct hblk *h;
unsigned nbl = 0;
- GC_printf3("Section %ld from 0x%lx to 0x%lx ", (unsigned long)i,
+ GC_printf("Section %d from %p to %p ", i,
start, (unsigned long)(start + len));
for (h = (struct hblk *)start; h < (struct hblk *)(start + len); h++) {
if (GC_is_black_listed(h, HBLKSIZE)) nbl++;
}
- GC_printf2("%lu/%lu blacklisted\n", (unsigned long)nbl,
+ GC_printf("%lu/%lu blacklisted\n", (unsigned long)nbl,
(unsigned long)(len/HBLKSIZE));
}
}
# endif
-GC_PTR GC_least_plausible_heap_addr = (GC_PTR)ONES;
-GC_PTR GC_greatest_plausible_heap_addr = 0;
+void * GC_least_plausible_heap_addr = (void *)ONES;
+void * GC_greatest_plausible_heap_addr = 0;
-ptr_t GC_max(x,y)
-ptr_t x, y;
+static INLINE ptr_t GC_max(ptr_t x, ptr_t y)
{
return(x > y? x : y);
}
-ptr_t GC_min(x,y)
-ptr_t x, y;
+static INLINE ptr_t GC_min(ptr_t x, ptr_t y)
{
return(x < y? x : y);
}
-# if defined(__STDC__) || defined(__cplusplus)
- void GC_set_max_heap_size(GC_word n)
-# else
- void GC_set_max_heap_size(n)
- GC_word n;
-# endif
+void GC_set_max_heap_size(GC_word n)
{
GC_max_heapsize = n;
}
@@ -885,8 +840,7 @@ GC_word GC_max_retries = 0;
* Tiny values of n are rounded up.
* Returns FALSE on failure.
*/
-GC_bool GC_expand_hp_inner(n)
-word n;
+GC_bool GC_expand_hp_inner(word n)
{
word bytes;
struct hblk * space;
@@ -908,37 +862,28 @@ word n;
}
space = GET_MEM(bytes);
if( space == 0 ) {
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf1("Failed to expand heap by %ld bytes\n",
- (unsigned long)bytes);
- }
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("Failed to expand heap by %ld bytes\n",
+ (unsigned long)bytes);
+ }
return(FALSE);
}
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf2("Increasing heap size by %lu after %lu allocated bytes\n",
- (unsigned long)bytes,
- (unsigned long)WORDS_TO_BYTES(GC_words_allocd));
-# ifdef UNDEFINED
- GC_printf1("Root size = %lu\n", GC_root_size);
- GC_print_block_list(); GC_print_hblkfreelist();
- GC_printf0("\n");
-# endif
- }
-# endif
- expansion_slop = WORDS_TO_BYTES(min_words_allocd()) + 4*MAXHINCR*HBLKSIZE;
- if (GC_last_heap_addr == 0 && !((word)space & SIGNB)
+ if (GC_print_stats) {
+ GC_log_printf("Increasing heap size by %lu after %lu allocated bytes\n",
+ (unsigned long)bytes,
+ (unsigned long)GC_bytes_allocd);
+ }
+ expansion_slop = min_bytes_allocd() + 4*MAXHINCR*HBLKSIZE;
+ if ((GC_last_heap_addr == 0 && !((word)space & SIGNB))
|| (GC_last_heap_addr != 0 && GC_last_heap_addr < (ptr_t)space)) {
/* Assume the heap is growing up */
GC_greatest_plausible_heap_addr =
- (GC_PTR)GC_max((ptr_t)GC_greatest_plausible_heap_addr,
+ (void *)GC_max((ptr_t)GC_greatest_plausible_heap_addr,
(ptr_t)space + bytes + expansion_slop);
} else {
/* Heap is growing down */
GC_least_plausible_heap_addr =
- (GC_PTR)GC_min((ptr_t)GC_least_plausible_heap_addr,
+ (void *)GC_min((ptr_t)GC_least_plausible_heap_addr,
(ptr_t)space - expansion_slop);
}
# if defined(LARGE_CONFIG)
@@ -954,33 +899,26 @@ word n;
GC_add_to_heap(space, bytes);
/* Force GC before we are likely to allocate past expansion_slop */
GC_collect_at_heapsize =
- GC_heapsize + expansion_slop - 2*MAXHINCR*HBLKSIZE;
+ GC_heapsize + expansion_slop - 2*MAXHINCR*HBLKSIZE;
# if defined(LARGE_CONFIG)
if (GC_collect_at_heapsize < GC_heapsize /* wrapped */)
- GC_collect_at_heapsize = (word)(-1);
+ GC_collect_at_heapsize = (word)(-1);
# endif
return(TRUE);
}
/* Really returns a bool, but it's externally visible, so that's clumsy. */
/* Arguments is in bytes. */
-# if defined(__STDC__) || defined(__cplusplus)
- int GC_expand_hp(size_t bytes)
-# else
- int GC_expand_hp(bytes)
- size_t bytes;
-# endif
+int GC_expand_hp(size_t bytes)
{
int result;
DCL_LOCK_STATE;
- DISABLE_SIGNALS();
LOCK();
if (!GC_is_initialized) GC_init_inner();
result = (int)GC_expand_hp_inner(divHBLKSZ((word)bytes));
if (result) GC_requested_heapsize += bytes;
UNLOCK();
- ENABLE_SIGNALS();
return(result);
}
@@ -988,12 +926,10 @@ unsigned GC_fail_count = 0;
/* How many consecutive GC/expansion failures? */
/* Reset by GC_allochblk. */
-GC_bool GC_collect_or_expand(needed_blocks, ignore_off_page)
-word needed_blocks;
-GC_bool ignore_off_page;
+GC_bool GC_collect_or_expand(word needed_blocks, GC_bool ignore_off_page)
{
if (!GC_incremental && !GC_dont_gc &&
- ((GC_dont_expand && GC_words_allocd > 0) || GC_should_collect())) {
+ ((GC_dont_expand && GC_bytes_allocd > 0) || GC_should_collect())) {
GC_gcollect_inner();
} else {
word blocks_to_get = GC_heapsize/(HBLKSIZE*GC_free_space_divisor)
@@ -1029,41 +965,37 @@ GC_bool ignore_off_page;
return(FALSE);
}
} else {
-# ifdef CONDPRINT
- if (GC_fail_count && GC_print_stats) {
- GC_printf0("Memory available again ...\n");
- }
-# endif
+ if (GC_fail_count && GC_print_stats) {
+ GC_printf("Memory available again ...\n");
+ }
}
}
return(TRUE);
}
/*
- * Make sure the object free list for sz is not empty.
+ * Make sure the object free list for size gran (in granules) is not empty.
* Return a pointer to the first object on the free list.
* The object MUST BE REMOVED FROM THE FREE LIST BY THE CALLER.
* Assumes we hold the allocator lock and signals are disabled.
*
*/
-ptr_t GC_allocobj(sz, kind)
-word sz;
-int kind;
+ptr_t GC_allocobj(size_t gran, int kind)
{
- ptr_t * flh = &(GC_obj_kinds[kind].ok_freelist[sz]);
+ void ** flh = &(GC_obj_kinds[kind].ok_freelist[gran]);
GC_bool tried_minor = FALSE;
- if (sz == 0) return(0);
+ if (gran == 0) return(0);
while (*flh == 0) {
ENTER_GC();
/* Do our share of marking work */
if(TRUE_INCREMENTAL) GC_collect_a_little_inner(1);
/* Sweep blocks for objects of this size */
- GC_continue_reclaim(sz, kind);
+ GC_continue_reclaim(gran, kind);
EXIT_GC();
if (*flh == 0) {
- GC_new_hblk(sz, kind);
+ GC_new_hblk(gran, kind);
}
if (*flh == 0) {
ENTER_GC();
diff --git a/backgraph.c b/backgraph.c
index 0c512e2..b4dbbb0 100644
--- a/backgraph.c
+++ b/backgraph.c
@@ -254,12 +254,12 @@ static void add_edge(ptr_t p, ptr_t q)
}
}
-typedef void (*per_object_func)(ptr_t p, word n_words, word gc_descr);
+typedef void (*per_object_func)(ptr_t p, word n_bytes, word gc_descr);
static void per_object_helper(struct hblk *h, word fn)
{
hdr * hhdr = HDR(h);
- word sz = hhdr -> hb_sz;
+ size_t sz = hhdr -> hb_sz;
word descr = hhdr -> hb_descr;
per_object_func f = (per_object_func)fn;
int i = 0;
@@ -275,7 +275,7 @@ void GC_apply_to_each_object(per_object_func f)
GC_apply_to_all_blocks(per_object_helper, (word)f);
}
-static void reset_back_edge(ptr_t p, word n_words, word gc_descr)
+static void reset_back_edge(ptr_t p, word n_bytes, word gc_descr)
{
/* Skip any free list links, or dropped blocks */
if (GC_HAS_DEBUG_INFO(p)) {
@@ -311,20 +311,20 @@ static void reset_back_edge(ptr_t p, word n_words, word gc_descr)
}
}
-static void add_back_edges(ptr_t p, word n_words, word gc_descr)
+static void add_back_edges(ptr_t p, size_t n_bytes, word gc_descr)
{
word *currentp = (word *)(p + sizeof(oh));
/* For now, fix up non-length descriptors conservatively. */
if((gc_descr & GC_DS_TAGS) != GC_DS_LENGTH) {
- gc_descr = WORDS_TO_BYTES(n_words);
+ gc_descr = n_bytes;
}
while (currentp < (word *)(p + gc_descr)) {
word current = *currentp++;
FIXUP_POINTER(current);
if (current >= (word)GC_least_plausible_heap_addr &&
current <= (word)GC_greatest_plausible_heap_addr) {
- ptr_t target = GC_base((GC_PTR)current);
+ ptr_t target = GC_base((void *)current);
if (0 != target) {
add_edge(p, target);
}
@@ -369,7 +369,7 @@ static word backwards_height(ptr_t p)
word this_height;
if (GC_is_marked(q) && !(FLAG_MANY & (word)GET_OH_BG_PTR(p))) {
if (GC_print_stats)
- GC_printf2("Found bogus pointer from 0x%lx to 0x%lx\n", q, p);
+ GC_log_printf("Found bogus pointer from 0x%lx to 0x%lx\n", q, p);
/* Reachable object "points to" unreachable one. */
/* Could be caused by our lax treatment of GC descriptors. */
this_height = 1;
@@ -392,7 +392,7 @@ ptr_t GC_deepest_obj;
/* next GC. */
/* Set GC_max_height to be the maximum height we encounter, and */
/* GC_deepest_obj to be the corresponding object. */
-static void update_max_height(ptr_t p, word n_words, word gc_descr)
+static void update_max_height(ptr_t p, word n_bytes, word gc_descr)
{
if (GC_is_marked(p) && GC_HAS_DEBUG_INFO(p)) {
int i;
@@ -457,8 +457,8 @@ void GC_print_back_graph_stats(void)
GC_print_heap_obj(GC_deepest_obj);
}
if (GC_print_stats) {
- GC_printf1("Needed max total of %ld back-edge structs\n",
- GC_n_back_edge_structs);
+ GC_log_printf("Needed max total of %ld back-edge structs\n",
+ GC_n_back_edge_structs);
}
GC_apply_to_each_object(reset_back_edge);
GC_deepest_obj = 0;
diff --git a/blacklst.c b/blacklst.c
index ae2f95c..686893d 100644
--- a/blacklst.c
+++ b/blacklst.c
@@ -50,40 +50,34 @@ word GC_total_stack_black_listed;
word GC_black_list_spacing = MINHINCR*HBLKSIZE; /* Initial rough guess */
-void GC_clear_bl();
+void GC_clear_bl(word *);
-# if defined(__STDC__) || defined(__cplusplus)
- void GC_default_print_heap_obj_proc(ptr_t p)
-# else
- void GC_default_print_heap_obj_proc(p)
- ptr_t p;
-# endif
+void GC_default_print_heap_obj_proc(ptr_t p)
{
ptr_t base = GC_base(p);
- GC_err_printf2("start: 0x%lx, appr. length: %ld", base, GC_size(base));
+ GC_err_printf("start: %p, appr. length: %ld", base,
+ (unsigned long)GC_size(base));
}
-void (*GC_print_heap_obj) GC_PROTO((ptr_t p)) =
- GC_default_print_heap_obj_proc;
+void (*GC_print_heap_obj) (ptr_t p) = GC_default_print_heap_obj_proc;
-void GC_print_source_ptr(p)
-ptr_t p;
+void GC_print_source_ptr(ptr_t p)
{
ptr_t base = GC_base(p);
if (0 == base) {
if (0 == p) {
- GC_err_printf0("in register");
+ GC_err_printf("in register");
} else {
- GC_err_printf0("in root set");
+ GC_err_printf("in root set");
}
} else {
- GC_err_printf0("in object at ");
+ GC_err_printf("in object at ");
(*GC_print_heap_obj)(base);
}
}
-void GC_bl_init()
+void GC_bl_init(void)
{
if (!GC_all_interior_pointers) {
GC_old_normal_bl = (word *)
@@ -91,7 +85,7 @@ void GC_bl_init()
GC_incomplete_normal_bl = (word *)GC_scratch_alloc
((word)(sizeof(page_hash_table)));
if (GC_old_normal_bl == 0 || GC_incomplete_normal_bl == 0) {
- GC_err_printf0("Insufficient memory for black list\n");
+ GC_err_printf("Insufficient memory for black list\n");
EXIT();
}
GC_clear_bl(GC_old_normal_bl);
@@ -101,30 +95,28 @@ void GC_bl_init()
GC_incomplete_stack_bl = (word *)GC_scratch_alloc
((word)(sizeof(page_hash_table)));
if (GC_old_stack_bl == 0 || GC_incomplete_stack_bl == 0) {
- GC_err_printf0("Insufficient memory for black list\n");
+ GC_err_printf("Insufficient memory for black list\n");
EXIT();
}
GC_clear_bl(GC_old_stack_bl);
GC_clear_bl(GC_incomplete_stack_bl);
}
-void GC_clear_bl(doomed)
-word *doomed;
+void GC_clear_bl(word *doomed)
{
BZERO(doomed, sizeof(page_hash_table));
}
-void GC_copy_bl(old, new)
-word *new, *old;
+void GC_copy_bl(word *old, word *new)
{
BCOPY(old, new, sizeof(page_hash_table));
}
-static word total_stack_black_listed();
+static word total_stack_black_listed(void);
/* Signal the completion of a collection. Turn the incomplete black */
/* lists into new black lists, etc. */
-void GC_promote_black_lists()
+void GC_promote_black_lists(void)
{
word * very_old_normal_bl = GC_old_normal_bl;
word * very_old_stack_bl = GC_old_stack_bl;
@@ -138,10 +130,9 @@ void GC_promote_black_lists()
GC_incomplete_normal_bl = very_old_normal_bl;
GC_incomplete_stack_bl = very_old_stack_bl;
GC_total_stack_black_listed = total_stack_black_listed();
-# ifdef PRINTSTATS
- GC_printf1("%ld bytes in heap blacklisted for interior pointers\n",
- (unsigned long)GC_total_stack_black_listed);
-# endif
+ if (GC_print_stats == VERBOSE)
+ GC_log_printf("%ld bytes in heap blacklisted for interior pointers\n",
+ (unsigned long)GC_total_stack_black_listed);
if (GC_total_stack_black_listed != 0) {
GC_black_list_spacing =
HBLKSIZE*(GC_heapsize/GC_total_stack_black_listed);
@@ -158,7 +149,7 @@ void GC_promote_black_lists()
}
}
-void GC_unpromote_black_lists()
+void GC_unpromote_black_lists(void)
{
if (!GC_all_interior_pointers) {
GC_copy_bl(GC_old_normal_bl, GC_incomplete_normal_bl);
@@ -170,12 +161,10 @@ void GC_unpromote_black_lists()
/* the plausible heap bounds. */
/* Add it to the normal incomplete black list if appropriate. */
#ifdef PRINT_BLACK_LIST
- void GC_add_to_black_list_normal(p, source)
- ptr_t source;
+ void GC_add_to_black_list_normal(word p, ptr_t source)
#else
- void GC_add_to_black_list_normal(p)
+ void GC_add_to_black_list_normal(word p)
#endif
-word p;
{
if (!(GC_modws_valid_offsets[p & (sizeof(word)-1)])) return;
{
@@ -184,9 +173,9 @@ word p;
if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_normal_bl, index)) {
# ifdef PRINT_BLACK_LIST
if (!get_pht_entry_from_index(GC_incomplete_normal_bl, index)) {
- GC_err_printf2(
- "Black listing (normal) 0x%lx referenced from 0x%lx ",
- (unsigned long) p, (unsigned long) source);
+ GC_err_printf(
+ "Black listing (normal) %p referenced from %p ",
+ (ptr_t) p, source);
GC_print_source_ptr(source);
GC_err_puts("\n");
}
@@ -199,21 +188,20 @@ word p;
/* And the same for false pointers from the stack. */
#ifdef PRINT_BLACK_LIST
- void GC_add_to_black_list_stack(p, source)
+ void GC_add_to_black_list_stack(word p, ptr_t source)
ptr_t source;
#else
- void GC_add_to_black_list_stack(p)
+ void GC_add_to_black_list_stack(word p)
#endif
-word p;
{
register int index = PHT_HASH(p);
if (HDR(p) == 0 || get_pht_entry_from_index(GC_old_stack_bl, index)) {
# ifdef PRINT_BLACK_LIST
if (!get_pht_entry_from_index(GC_incomplete_stack_bl, index)) {
- GC_err_printf2(
- "Black listing (stack) 0x%lx referenced from 0x%lx ",
- (unsigned long)p, (unsigned long)source);
+ GC_err_printf(
+ "Black listing (stack) %p referenced from %p ",
+ (ptr_t)p, source);
GC_print_source_ptr(source);
GC_err_puts("\n");
}
@@ -230,9 +218,7 @@ word p;
* If (h,len) is not black listed, return 0.
* Knows about the structure of the black list hash tables.
*/
-struct hblk * GC_is_black_listed(h, len)
-struct hblk * h;
-word len;
+struct hblk * GC_is_black_listed(struct hblk *h, word len)
{
register int index = PHT_HASH((word)h);
register word i;
@@ -267,8 +253,7 @@ word len;
/* Return the number of blacklisted blocks in a given range. */
/* Used only for statistical purposes. */
/* Looks only at the GC_incomplete_stack_bl. */
-word GC_number_stack_black_listed(start, endp1)
-struct hblk *start, *endp1;
+word GC_number_stack_black_listed(struct hblk *start, struct hblk *endp1)
{
register struct hblk * h;
word result = 0;
@@ -283,7 +268,7 @@ struct hblk *start, *endp1;
/* Return the total number of (stack) black-listed bytes. */
-static word total_stack_black_listed()
+static word total_stack_black_listed(void)
{
register unsigned i;
word total = 0;
diff --git a/checksums.c b/checksums.c
index 57a6ebc..0942acb 100644
--- a/checksums.c
+++ b/checksums.c
@@ -50,14 +50,14 @@ struct hblk *h;
# ifdef STUBBORN_ALLOC
/* Check whether a stubborn object from the given block appears on */
/* the appropriate free list. */
-GC_bool GC_on_free_list(h)
+GC_bool GC_on_free_list(struct hblk *h)
struct hblk *h;
{
- register hdr * hhdr = HDR(h);
- register int sz = hhdr -> hb_sz;
+ hdr * hhdr = HDR(h);
+ int sz = BYTES_TO_WORDS(hhdr -> hb_sz);
ptr_t p;
- if (sz > MAXOBJSZ) return(FALSE);
+ if (sz > MAXOBJWORDS) return(FALSE);
for (p = GC_sobjfreelist[sz]; p != 0; p = obj_link(p)) {
if (HBLKPTR(p) == h) return(TRUE);
}
@@ -70,9 +70,7 @@ int GC_n_changed_errors;
int GC_n_clean;
int GC_n_dirty;
-void GC_update_check_page(h, index)
-struct hblk *h;
-int index;
+void GC_update_check_page(struct hblk *h, int index)
{
page_entry *pe = GC_sums + index;
register hdr * hhdr = HDR(h);
@@ -83,8 +81,7 @@ int index;
pe -> new_sum = GC_checksum(h);
# if !defined(MSWIN32) && !defined(MSWINCE)
if (pe -> new_sum != 0x80000000 && !GC_page_was_ever_dirty(h)) {
- GC_printf1("GC_page_was_ever_dirty(0x%lx) is wrong\n",
- (unsigned long)h);
+ GC_printf("GC_page_was_ever_dirty(%p) is wrong\n", h);
}
# endif
if (GC_page_was_dirty(h)) {
@@ -104,7 +101,7 @@ int index;
/* Set breakpoint here */GC_n_dirty_errors++;
}
# ifdef STUBBORN_ALLOC
- if ( hhdr -> hb_map != GC_invalid_map
+ if (!HBLK_IS_FREE(hhdr)
&& hhdr -> hb_obj_kind == STUBBORN
&& !GC_page_was_changed(h)
&& !GC_on_free_list(h)) {
@@ -118,14 +115,14 @@ int index;
pe -> block = h + OFFSET;
}
-word GC_bytes_in_used_blocks;
+unsigned long GC_bytes_in_used_blocks;
void GC_add_block(h, dummy)
struct hblk *h;
word dummy;
{
- register hdr * hhdr = HDR(h);
- register bytes = WORDS_TO_BYTES(hhdr -> hb_sz);
+ hdr * hhdr = HDR(h);
+ bytes = hhdr -> hb_sz;
bytes += HBLKSIZE-1;
bytes &= ~(HBLKSIZE-1);
@@ -134,15 +131,15 @@ word dummy;
void GC_check_blocks()
{
- word bytes_in_free_blocks = GC_large_free_bytes;
+ unsigned long bytes_in_free_blocks = GC_large_free_bytes;
GC_bytes_in_used_blocks = 0;
GC_apply_to_all_blocks(GC_add_block, (word)0);
- GC_printf2("GC_bytes_in_used_blocks = %ld, bytes_in_free_blocks = %ld ",
- GC_bytes_in_used_blocks, bytes_in_free_blocks);
- GC_printf1("GC_heapsize = %ld\n", GC_heapsize);
+ GC_printf("GC_bytes_in_used_blocks = %lu, bytes_in_free_blocks = %lu ",
+ GC_bytes_in_used_blocks, bytes_in_free_blocks);
+ GC_printf("GC_heapsize = %lu\n", (unsigned long)GC_heapsize);
if (GC_bytes_in_used_blocks + bytes_in_free_blocks != GC_heapsize) {
- GC_printf0("LOST SOME BLOCKS!!\n");
+ GC_printf("LOST SOME BLOCKS!!\n");
}
}
@@ -173,18 +170,18 @@ void GC_check_dirty()
}
}
out:
- GC_printf2("Checked %lu clean and %lu dirty pages\n",
+ GC_printf("Checked %lu clean and %lu dirty pages\n",
(unsigned long) GC_n_clean, (unsigned long) GC_n_dirty);
if (GC_n_dirty_errors > 0) {
- GC_printf1("Found %lu dirty bit errors\n",
- (unsigned long)GC_n_dirty_errors);
+ GC_printf("Found %lu dirty bit errors\n",
+ (unsigned long)GC_n_dirty_errors);
}
if (GC_n_changed_errors > 0) {
- GC_printf1("Found %lu changed bit errors\n",
- (unsigned long)GC_n_changed_errors);
- GC_printf0("These may be benign (provoked by nonpointer changes)\n");
+ GC_printf("Found %lu changed bit errors\n",
+ (unsigned long)GC_n_changed_errors);
+ GC_printf("These may be benign (provoked by nonpointer changes)\n");
# ifdef THREADS
- GC_printf0(
+ GC_printf(
"Also expect 1 per thread currently allocating a stubborn obj.\n");
# endif
}
diff --git a/configure b/configure
index 3ea15df..adc02d4 100755
--- a/configure
+++ b/configure
@@ -1,7 +1,7 @@
#! /bin/sh
# From configure.in Revision: 1.2 .
# Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.59 for gc 6.4.
+# Generated by GNU Autoconf 2.59 for gc 7.0alpha1.
#
# Report bugs to <Hans.Boehm@hp.com>.
#
@@ -429,8 +429,8 @@ SHELL=${CONFIG_SHELL-/bin/sh}
# Identity of this package.
PACKAGE_NAME='gc'
PACKAGE_TARNAME='gc'
-PACKAGE_VERSION='6.4'
-PACKAGE_STRING='gc 6.4'
+PACKAGE_VERSION='7.0alpha1'
+PACKAGE_STRING='gc 7.0alpha1'
PACKAGE_BUGREPORT='Hans.Boehm@hp.com'
ac_unique_file="gcj_mlc.c"
@@ -471,7 +471,7 @@ ac_includes_default="\
# include <unistd.h>
#endif"
-ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO AMTAR install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM AWK SET_MAKE GC_VERSION CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE CXX CXXFLAGS ac_ct_CXX CXXDEPMODE CCAS CCASFLAGS AR ac_ct_AR RANLIB ac_ct_RANLIB MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT GC_CFLAGS THREADDLLIBS POWERPC_DARWIN_TRUE POWERPC_DARWIN_FALSE EXTRA_TEST_LIBS target_all CPLUSPLUS_TRUE CPLUSPLUS_FALSE INCLUDES CXXINCLUDES addobjs addincludes addlibs addtests LN_S ECHO CPP EGREP LIBTOOL MY_CFLAGS UNWINDLIBS USE_LIBDIR_TRUE USE_LIBDIR_FALSE LIBOBJS LTLIBOBJS'
+ac_subst_vars='SHELL PATH_SEPARATOR PACKAGE_NAME PACKAGE_TARNAME PACKAGE_VERSION PACKAGE_STRING PACKAGE_BUGREPORT exec_prefix prefix program_transform_name bindir sbindir libexecdir datadir sysconfdir sharedstatedir localstatedir libdir includedir oldincludedir infodir mandir build_alias host_alias target_alias DEFS ECHO_C ECHO_N ECHO_T LIBS build build_cpu build_vendor build_os host host_cpu host_vendor host_os target target_cpu target_vendor target_os INSTALL_PROGRAM INSTALL_SCRIPT INSTALL_DATA PACKAGE VERSION ACLOCAL AUTOCONF AUTOMAKE AUTOHEADER MAKEINFO AMTAR install_sh STRIP ac_ct_STRIP INSTALL_STRIP_PROGRAM AWK SET_MAKE GC_VERSION CC CFLAGS LDFLAGS CPPFLAGS ac_ct_CC EXEEXT OBJEXT DEPDIR am__include am__quote AMDEP_TRUE AMDEP_FALSE AMDEPBACKSLASH CCDEPMODE CXX CXXFLAGS ac_ct_CXX CXXDEPMODE CCAS CCASFLAGS AR ac_ct_AR RANLIB ac_ct_RANLIB MAINTAINER_MODE_TRUE MAINTAINER_MODE_FALSE MAINT GC_CFLAGS THREADLIBS POWERPC_DARWIN_TRUE POWERPC_DARWIN_FALSE EXTRA_TEST_LIBS target_all CPLUSPLUS_TRUE CPLUSPLUS_FALSE INCLUDES CXXINCLUDES addobjs addincludes addlibs addtests LN_S ECHO CPP EGREP LIBTOOL MY_CFLAGS UNWINDLIBS USE_LIBDIR_TRUE USE_LIBDIR_FALSE LIBOBJS LTLIBOBJS'
ac_subst_files=''
# Initialize some variables set by options.
@@ -948,7 +948,7 @@ if test "$ac_init_help" = "long"; then
# Omit some internal or obsolete options to make the list less imposing.
# This message is too long to be a string in the A/UX 3.1 sh.
cat <<_ACEOF
-\`configure' configures gc 6.4 to adapt to many kinds of systems.
+\`configure' configures gc 7.0alpha1 to adapt to many kinds of systems.
Usage: $0 [OPTION]... [VAR=VALUE]...
@@ -1015,7 +1015,7 @@ fi
if test -n "$ac_init_help"; then
case $ac_init_help in
- short | recursive ) echo "Configuration of gc 6.4:";;
+ short | recursive ) echo "Configuration of gc 7.0alpha1:";;
esac
cat <<\_ACEOF
@@ -1033,7 +1033,7 @@ Optional Features:
--enable-static=PKGS build static libraries default=yes
--enable-fast-install=PKGS optimize for fast installation default=yes
--disable-libtool-lock avoid locking (might break parallel builds)
- --enable-full-debug include full support for pointer backtracing etc.
+ --enable-gc-debug include full support for pointer backtracing etc.
--enable-redirect-malloc redirect malloc and friends to GC routines
--enable-gc-assertions collector-internal assertion checking
@@ -1150,14 +1150,14 @@ esac
else
echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
fi
- cd "$ac_popdir"
+ cd $ac_popdir
done
fi
test -n "$ac_init_help" && exit 0
if $ac_init_version; then
cat <<\_ACEOF
-gc configure 6.4
+gc configure 7.0alpha1
generated by GNU Autoconf 2.59
Copyright (C) 2003 Free Software Foundation, Inc.
@@ -1171,7 +1171,7 @@ cat >&5 <<_ACEOF
This file contains any messages produced by compilers while
running configure, to aid debugging if configure makes a mistake.
-It was created by gc $as_me 6.4, which was
+It was created by gc $as_me 7.0alpha1, which was
generated by GNU Autoconf 2.59. Invocation command line was
$ $0 $@
@@ -1892,7 +1892,7 @@ fi
# Define the identity of the package.
PACKAGE=gc
- VERSION=6.4
+ VERSION=7.0alpha1
cat >>confdefs.h <<_ACEOF
@@ -2590,7 +2590,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -2648,7 +2649,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -2764,7 +2766,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -2818,7 +2821,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -2863,7 +2867,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -2907,7 +2912,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -3233,7 +3239,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_cxx_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -3291,7 +3298,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_cxx_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -3362,7 +3370,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_cxx_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -3406,7 +3415,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_cxx_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_cxx_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -3821,15 +3831,14 @@ if test "${enable_cplusplus+set}" = set; then
fi;
INCLUDES=-I${srcdir}/include
-THREADDLLIBS=
-## Libraries needed to support dynamic loading and/or threads.
+THREADLIBS=
case "$THREADS" in
no | none | single)
THREADS=none
;;
posix | pthreads)
THREADS=posix
- THREADDLLIBS=-lpthread
+ THREADLIBS=-lpthread
case "$host" in
x86-*-linux* | ia64-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* | alpha-*-linux*)
cat >>confdefs.h <<\_ACEOF
@@ -3892,7 +3901,7 @@ _ACEOF
#define THREAD_LOCAL_ALLOC 1
_ACEOF
- THREADDLLIBS="-lpthread -lrt"
+ THREADLIBS="-lpthread -lrt"
;;
*-*-freebsd*)
{ echo "$as_me:$LINENO: WARNING: \"FreeBSD does not yet fully support threads with Boehm GC.\"" >&5
@@ -3902,7 +3911,7 @@ echo "$as_me: WARNING: \"FreeBSD does not yet fully support threads with Boehm G
_ACEOF
INCLUDES="$INCLUDES -pthread"
- THREADDLLIBS=-pthread
+ THREADLIBS=-pthread
;;
*-*-solaris*)
cat >>confdefs.h <<\_ACEOF
@@ -3960,12 +3969,7 @@ _ACEOF
# Measurements havent yet been done.
fi
INCLUDES="$INCLUDES -pthread"
- THREADDLLIBS="-lpthread -lrt"
- ;;
- *)
- { { echo "$as_me:$LINENO: error: \"Pthreads not supported by the GC on this platform.\"" >&5
-echo "$as_me: error: \"Pthreads not supported by the GC on this platform.\"" >&2;}
- { (exit 1); exit 1; }; }
+ THREADLIBS="-lpthread -lrt"
;;
esac
;;
@@ -3981,10 +3985,10 @@ _ACEOF
;;
dgux386)
THREADS=dgux386
- echo "$as_me:$LINENO: result: $THREADDLLIBS" >&5
-echo "${ECHO_T}$THREADDLLIBS" >&6
+ echo "$as_me:$LINENO: result: $THREADLIBS" >&5
+echo "${ECHO_T}$THREADLIBS" >&6
# Use pthread GCC switch
- THREADDLLIBS=-pthread
+ THREADLIBS=-pthread
if test "${enable_parallel_mark}" = yes; then
cat >>confdefs.h <<\_ACEOF
#define PARALLEL_MARK 1
@@ -4008,7 +4012,7 @@ _ACEOF
;;
aix)
THREADS=posix
- THREADDLLIBS=-lpthread
+ THREADLIBS=-lpthread
cat >>confdefs.h <<\_ACEOF
#define GC_AIX_THREADS 1
_ACEOF
@@ -4091,7 +4095,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -4117,7 +4122,7 @@ fi
echo "$as_me:$LINENO: result: $ac_cv_lib_dl_dlopen" >&5
echo "${ECHO_T}$ac_cv_lib_dl_dlopen" >&6
if test $ac_cv_lib_dl_dlopen = yes; then
- THREADDLLIBS="$THREADDLLIBS -ldl"
+ EXTRA_TEST_LIBS="$EXTRA_TEST_LIBS -ldl"
fi
;;
@@ -4272,7 +4277,7 @@ _ACEOF
_ACEOF
;;
- sparc*-sun-solaris2.*)
+ sparc-sun-solaris2.*)
machdep="sparc_mach_dep.lo"
;;
ia64-*-*)
@@ -5174,7 +5179,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -5344,7 +5350,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -5411,7 +5418,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -5845,7 +5853,7 @@ test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
case $host in
*-*-irix6*)
# Find out which ABI we are using.
- echo '#line 5848 "configure"' > conftest.$ac_ext
+ echo '#line 5856 "configure"' > conftest.$ac_ext
if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
(eval $ac_compile) 2>&5
ac_status=$?
@@ -5907,7 +5915,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -6249,7 +6258,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -6345,7 +6355,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -6404,7 +6415,7 @@ chmod -w .
save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS -o out/conftest2.$ac_objext"
compiler_c_o=no
-if { (eval echo configure:6407: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>out/conftest.err; } && test -s out/conftest2.$ac_objext; then
+if { (eval echo configure:6418: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>out/conftest.err; } && test -s out/conftest2.$ac_objext; then
# The compiler can only warn and ignore the option if not recognized
# So say no if there are warnings
if test -s out/conftest.err; then
@@ -6468,7 +6479,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -6561,7 +6573,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -7863,7 +7876,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -7928,7 +7942,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -8021,7 +8036,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -8086,7 +8102,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -8152,7 +8169,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -8218,7 +8236,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -8293,7 +8312,7 @@ else
lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
lt_status=$lt_dlunknown
cat > conftest.$ac_ext <<EOF
-#line 8296 "configure"
+#line 8315 "configure"
#include "confdefs.h"
#if HAVE_DLFCN_H
@@ -8391,7 +8410,7 @@ else
lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
lt_status=$lt_dlunknown
cat > conftest.$ac_ext <<EOF
-#line 8394 "configure"
+#line 8413 "configure"
#include "confdefs.h"
#if HAVE_DLFCN_H
@@ -9150,7 +9169,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_compile\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -9302,7 +9322,7 @@ fi
echo "$as_me:$LINENO: checking whether Solaris gcc optimization fix is necessary" >&5
echo $ECHO_N "checking whether Solaris gcc optimization fix is necessary... $ECHO_C" >&6
case "$host" in
- *aix*)
+ sparc-sun-solaris2*|*aix*)
if test "$GCC" = yes; then
echo "$as_me:$LINENO: result: yes" >&5
echo "${ECHO_T}yes" >&6
@@ -9330,14 +9350,6 @@ MY_CFLAGS="$CFLAGS"
cat >>confdefs.h <<\_ACEOF
-#define SILENT 1
-_ACEOF
-
-cat >>confdefs.h <<\_ACEOF
-#define NO_SIGNALS 1
-_ACEOF
-
-cat >>confdefs.h <<\_ACEOF
#define NO_EXECUTE_PERMISSION 1
_ACEOF
@@ -9379,10 +9391,10 @@ _ACEOF
fi
UNWINDLIBS=
-# Check whether --enable-full-debug or --disable-full-debug was given.
-if test "${enable_full_debug+set}" = set; then
- enableval="$enable_full_debug"
- if test "$enable_full_debug" = "yes"; then
+# Check whether --enable-gc-debug or --disable-gc-debug was given.
+if test "${enable_gc_debug+set}" = set; then
+ enableval="$enable_gc_debug"
+ if test "$enable_gc_debug" = "yes"; then
{ echo "$as_me:$LINENO: WARNING: \"Should define GC_DEBUG and use debug alloc. in clients.\"" >&5
echo "$as_me: WARNING: \"Should define GC_DEBUG and use debug alloc. in clients.\"" >&2;}
cat >>confdefs.h <<\_ACEOF
@@ -9441,7 +9453,8 @@ if { (eval echo "$as_me:$LINENO: \"$ac_link\"") >&5
cat conftest.err >&5
echo "$as_me:$LINENO: \$? = $ac_status" >&5
(exit $ac_status); } &&
- { ac_try='test -z "$ac_c_werror_flag" || test ! -s conftest.err'
+ { ac_try='test -z "$ac_c_werror_flag"
+ || test ! -s conftest.err'
{ (eval echo "$as_me:$LINENO: \"$ac_try\"") >&5
(eval $ac_try) 2>&5
ac_status=$?
@@ -9984,7 +9997,7 @@ _ASBOX
} >&5
cat >&5 <<_CSEOF
-This file was extended by gc $as_me 6.4, which was
+This file was extended by gc $as_me 7.0alpha1, which was
generated by GNU Autoconf 2.59. Invocation command line was
CONFIG_FILES = $CONFIG_FILES
@@ -10042,7 +10055,7 @@ _ACEOF
cat >>$CONFIG_STATUS <<_ACEOF
ac_cs_version="\\
-gc config.status 6.4
+gc config.status 7.0alpha1
configured by $0, generated by GNU Autoconf 2.59,
with options \\"`echo "$ac_configure_args" | sed 's/[\\""\`\$]/\\\\&/g'`\\"
@@ -10305,7 +10318,7 @@ s,@MAINTAINER_MODE_TRUE@,$MAINTAINER_MODE_TRUE,;t t
s,@MAINTAINER_MODE_FALSE@,$MAINTAINER_MODE_FALSE,;t t
s,@MAINT@,$MAINT,;t t
s,@GC_CFLAGS@,$GC_CFLAGS,;t t
-s,@THREADDLLIBS@,$THREADDLLIBS,;t t
+s,@THREADLIBS@,$THREADLIBS,;t t
s,@POWERPC_DARWIN_TRUE@,$POWERPC_DARWIN_TRUE,;t t
s,@POWERPC_DARWIN_FALSE@,$POWERPC_DARWIN_FALSE,;t t
s,@EXTRA_TEST_LIBS@,$EXTRA_TEST_LIBS,;t t
@@ -10495,6 +10508,11 @@ esac
*) ac_INSTALL=$ac_top_builddir$INSTALL ;;
esac
+ if test x"$ac_file" != x-; then
+ { echo "$as_me:$LINENO: creating $ac_file" >&5
+echo "$as_me: creating $ac_file" >&6;}
+ rm -f "$ac_file"
+ fi
# Let's still pretend it is `configure' which instantiates (i.e., don't
# use $as_me), people would be surprised to read:
# /* config.h. Generated by config.status. */
@@ -10533,12 +10551,6 @@ echo "$as_me: error: cannot find input file: $f" >&2;}
fi;;
esac
done` || { (exit 1); exit 1; }
-
- if test x"$ac_file" != x-; then
- { echo "$as_me:$LINENO: creating $ac_file" >&5
-echo "$as_me: creating $ac_file" >&6;}
- rm -f "$ac_file"
- fi
_ACEOF
cat >>$CONFIG_STATUS <<_ACEOF
sed "$ac_vpsub
diff --git a/configure.in b/configure.in
index c2a6ea9..798a835 100644
--- a/configure.in
+++ b/configure.in
@@ -17,7 +17,7 @@ dnl Process this file with autoconf to produce configure.
# Initialization
# ==============
-AC_INIT(gc,6.4,Hans.Boehm@hp.com)
+AC_INIT(gc,7.0alpha1,Hans.Boehm@hp.com)
## version must conform to [0-9]+[.][0-9]+(alpha[0-9]+)?
AC_CONFIG_SRCDIR(gcj_mlc.c)
AC_CANONICAL_TARGET
@@ -68,15 +68,14 @@ AC_ARG_ENABLE(cplusplus,
)
INCLUDES=-I${srcdir}/include
-THREADDLLIBS=
-## Libraries needed to support dynamic loading and/or threads.
+THREADLIBS=
case "$THREADS" in
no | none | single)
THREADS=none
;;
posix | pthreads)
THREADS=posix
- THREADDLLIBS=-lpthread
+ THREADLIBS=-lpthread
case "$host" in
x86-*-linux* | ia64-*-linux* | i586-*-linux* | i686-*-linux* | x86_64-*-linux* | alpha-*-linux*)
AC_DEFINE(GC_LINUX_THREADS)
@@ -102,13 +101,13 @@ case "$THREADS" in
AC_DEFINE(PARALLEL_MARK)
fi
AC_DEFINE(THREAD_LOCAL_ALLOC)
- THREADDLLIBS="-lpthread -lrt"
+ THREADLIBS="-lpthread -lrt"
;;
*-*-freebsd*)
AC_MSG_WARN("FreeBSD does not yet fully support threads with Boehm GC.")
AC_DEFINE(GC_FREEBSD_THREADS)
INCLUDES="$INCLUDES -pthread"
- THREADDLLIBS=-pthread
+ THREADLIBS=-pthread
;;
*-*-solaris*)
AC_DEFINE(GC_SOLARIS_THREADS)
@@ -136,10 +135,7 @@ case "$THREADS" in
# Measurements havent yet been done.
fi
INCLUDES="$INCLUDES -pthread"
- THREADDLLIBS="-lpthread -lrt"
- ;;
- *)
- AC_MSG_ERROR("Pthreads not supported by the GC on this platform.")
+ THREADLIBS="-lpthread -lrt"
;;
esac
;;
@@ -150,9 +146,9 @@ case "$THREADS" in
;;
dgux386)
THREADS=dgux386
- AC_MSG_RESULT($THREADDLLIBS)
+ AC_MSG_RESULT($THREADLIBS)
# Use pthread GCC switch
- THREADDLLIBS=-pthread
+ THREADLIBS=-pthread
if test "${enable_parallel_mark}" = yes; then
AC_DEFINE(PARALLEL_MARK)
fi
@@ -164,7 +160,7 @@ case "$THREADS" in
;;
aix)
THREADS=posix
- THREADDLLIBS=-lpthread
+ THREADLIBS=-lpthread
AC_DEFINE(GC_AIX_THREADS)
AC_DEFINE(_REENTRANT)
;;
@@ -175,7 +171,7 @@ case "$THREADS" in
AC_MSG_ERROR($THREADS is an unknown thread package)
;;
esac
-AC_SUBST(THREADDLLIBS)
+AC_SUBST(THREADLIBS)
case "$host" in
powerpc-*-darwin*)
@@ -189,7 +185,7 @@ AM_CONDITIONAL(POWERPC_DARWIN,test x$powerpc_darwin = xtrue)
case "$host" in
*-*-darwin*) ;;
*)
- AC_CHECK_LIB(dl, dlopen, THREADDLLIBS="$THREADDLLIBS -ldl")
+ AC_CHECK_LIB(dl, dlopen, EXTRA_TEST_LIBS="$EXTRA_TEST_LIBS -ldl")
;;
esac
@@ -290,7 +286,7 @@ case "$host" in
machdep="sparc_mach_dep.lo"
AC_DEFINE(SUNOS53_SHARED_LIB)
;;
- sparc*-sun-solaris2.*)
+ sparc-sun-solaris2.*)
machdep="sparc_mach_dep.lo"
;;
ia64-*-*)
@@ -349,10 +345,10 @@ fi
dnl As of 4.13a2, the collector will not properly work on Solaris when
dnl built with gcc and -O. So we remove -O in the appropriate case.
-dnl Not needed anymore on Solaris.
+dnl
AC_MSG_CHECKING(whether Solaris gcc optimization fix is necessary)
case "$host" in
- *aix*)
+ sparc-sun-solaris2*|*aix*)
if test "$GCC" = yes; then
AC_MSG_RESULT(yes)
new_CFLAGS=
@@ -379,8 +375,6 @@ AC_SUBST(MY_CFLAGS)
dnl Include defines that have become de facto standard.
dnl ALL_INTERIOR_POINTERS can be overridden in startup code.
-AC_DEFINE(SILENT)
-AC_DEFINE(NO_SIGNALS)
AC_DEFINE(NO_EXECUTE_PERMISSION)
AC_DEFINE(ALL_INTERIOR_POINTERS)
@@ -400,9 +394,9 @@ if test -n "${with_cross_host}"; then
fi
UNWINDLIBS=
-AC_ARG_ENABLE(full-debug,
-[ --enable-full-debug include full support for pointer backtracing etc.],
-[ if test "$enable_full_debug" = "yes"; then
+AC_ARG_ENABLE(gc-debug,
+[ --enable-gc-debug include full support for pointer backtracing etc.],
+[ if test "$enable_gc_debug" = "yes"; then
AC_MSG_WARN("Should define GC_DEBUG and use debug alloc. in clients.")
AC_DEFINE(KEEP_BACK_PTRS)
AC_DEFINE(DBG_HDRS_ALL)
diff --git a/darwin_stop_world.c b/darwin_stop_world.c
index cb81e7c..3fc5bee 100644
--- a/darwin_stop_world.c
+++ b/darwin_stop_world.c
@@ -34,7 +34,7 @@ unsigned int FindTopOfStack(unsigned int stack_start) {
}
# ifdef DEBUG_THREADS
- /* GC_printf1("FindTopOfStack start at sp = %p\n", frame); */
+ /* GC_printf("FindTopOfStack start at sp = %p\n", frame); */
# endif
do {
if (frame->savedSP == NULL) break;
@@ -50,7 +50,7 @@ unsigned int FindTopOfStack(unsigned int stack_start) {
} while (1);
# ifdef DEBUG_THREADS
- /* GC_printf1("FindTopOfStack finish at sp = %p\n", frame); */
+ /* GC_printf("FindTopOfStack finish at sp = %p\n", frame); */
# endif
return (unsigned int)frame;
@@ -146,11 +146,9 @@ void GC_push_all_stacks() {
# endif /* !POWERPC */
}
# if DEBUG_THREADS
- GC_printf3("Darwin: Stack for thread 0x%lx = [%lx,%lx)\n",
- (unsigned long) thread,
- (unsigned long) lo,
- (unsigned long) hi
- );
+ GC_printf("Darwin: Stack for thread 0x%lx = [%p,%p)\n",
+ (unsigned long) thread, lo, hi
+ );
# endif
GC_push_all_stack(lo, hi);
} /* for(p=GC_threads[i]...) */
@@ -183,7 +181,7 @@ int GC_suspend_thread_list(thread_act_array_t act_list, int count,
for(i = 0; i < count; i++) {
thread_act_t thread = act_list[i];
# if DEBUG_THREADS
- GC_printf1("Attempting to suspend thread %p\n", thread);
+ GC_printf("Attempting to suspend thread %p\n", thread);
# endif
/* find the current thread in the old list */
int found = 0;
@@ -221,7 +219,8 @@ int GC_suspend_thread_list(thread_act_array_t act_list, int count,
continue;
}
# if DEBUG_THREADS
- GC_printf2("Thread state for 0x%lx = %d\n", thread, info.run_state);
+ GC_printf("Thread state for 0x%lx = %d\n",
+ (unsigned long)thread, info.run_state);
# endif
if (!found) {
GC_mach_threads[GC_mach_threads_count].already_suspended = info.suspend_count;
@@ -229,7 +228,7 @@ int GC_suspend_thread_list(thread_act_array_t act_list, int count,
if (info.suspend_count) continue;
# if DEBUG_THREADS
- GC_printf1("Suspending 0x%lx\n", thread);
+ GC_printf("Suspending 0x%lx\n", (unsigned long)thread);
# endif
/* Suspend the thread */
kern_result = thread_suspend(thread);
@@ -261,7 +260,8 @@ void GC_stop_world()
mach_msg_type_number_t listcount, prevcount;
# if DEBUG_THREADS
- GC_printf1("Stopping the world from 0x%lx\n", mach_thread_self());
+ GC_printf("Stopping the world from 0x%lx\n",
+ (unsigned long)mach_thread_self());
# endif
/* clear out the mach threads list table */
@@ -310,7 +310,7 @@ void GC_stop_world()
GC_release_mark_lock();
# endif
#if DEBUG_THREADS
- GC_printf1("World stopped from 0x%lx\n", my_thread);
+ GC_printf("World stopped from 0x%lx\n", (unsigned long)my_thread);
#endif
}
@@ -328,7 +328,7 @@ void GC_start_world()
mach_msg_type_number_t outCount = THREAD_INFO_MAX;
# if DEBUG_THREADS
- GC_printf0("World starting\n");
+ GC_printf("World starting\n");
# endif
# ifdef MPROTECT_VDB
@@ -348,7 +348,7 @@ void GC_start_world()
if (thread == GC_mach_threads[j].thread) {
if (GC_mach_threads[j].already_suspended) {
# if DEBUG_THREADS
- GC_printf1("Not resuming already suspended thread %p\n", thread);
+ GC_printf("Not resuming already suspended thread %p\n", thread);
# endif
continue;
}
@@ -356,9 +356,9 @@ void GC_start_world()
(thread_info_t)&info, &outCount);
if(kern_result != KERN_SUCCESS) ABORT("thread_info failed");
# if DEBUG_THREADS
- GC_printf2("Thread state for 0x%lx = %d\n", thread,
+ GC_printf("Thread state for 0x%lx = %d\n", (unsigned long)thread,
info.run_state);
- GC_printf1("Resuming 0x%lx\n", thread);
+ GC_printf("Resuming 0x%lx\n", (unsigned long)thread);
# endif
/* Resume the thread */
kern_result = thread_resume(thread);
@@ -368,7 +368,7 @@ void GC_start_world()
}
}
# if DEBUG_THREADS
- GC_printf0("World started\n");
+ GC_printf("World started\n");
# endif
}
diff --git a/dbg_mlc.c b/dbg_mlc.c
index aacbb7a..643f0e2 100644
--- a/dbg_mlc.c
+++ b/dbg_mlc.c
@@ -18,8 +18,8 @@
void GC_default_print_heap_obj_proc();
GC_API void GC_register_finalizer_no_order
- GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
- GC_finalization_proc *ofn, GC_PTR *ocd));
+ (void * obj, GC_finalization_proc fn, void * cd,
+ GC_finalization_proc *ofn, void * *ocd);
#ifndef SHORT_DBG_HDRS
@@ -32,8 +32,7 @@ GC_API void GC_register_finalizer_no_order
/* on free lists may not have debug information set. Thus it's */
/* not always safe to return TRUE, even if the client does */
/* its part. */
-GC_bool GC_has_other_debug_info(p)
-ptr_t p;
+GC_bool GC_has_other_debug_info(ptr_t p)
{
register oh * ohdr = (oh *)p;
register ptr_t body = (ptr_t)(ohdr + 1);
@@ -59,7 +58,7 @@ ptr_t p;
# include <stdlib.h>
-# if defined(LINUX) || defined(SUNOS4) || defined(SUNOS5) \
+# if defined(LINUX) || defined(SUNOS5) \
|| defined(HPUX) || defined(IRIX5) || defined(OSF1)
# define RANDOM() random()
# else
@@ -180,34 +179,34 @@ ptr_t p;
void *base;
GC_print_heap_obj(GC_base(current));
- GC_err_printf0("\n");
+ GC_err_printf("\n");
for (i = 0; ; ++i) {
source = GC_get_back_ptr_info(current, &base, &offset);
if (GC_UNREFERENCED == source) {
- GC_err_printf0("Reference could not be found\n");
+ GC_err_printf("Reference could not be found\n");
goto out;
}
if (GC_NO_SPACE == source) {
- GC_err_printf0("No debug info in object: Can't find reference\n");
+ GC_err_printf("No debug info in object: Can't find reference\n");
goto out;
}
- GC_err_printf1("Reachable via %d levels of pointers from ",
+ GC_err_printf("Reachable via %d levels of pointers from ",
(unsigned long)i);
switch(source) {
case GC_REFD_FROM_ROOT:
- GC_err_printf1("root at 0x%lx\n\n", (unsigned long)base);
+ GC_err_printf("root at %p\n\n", base);
goto out;
case GC_REFD_FROM_REG:
- GC_err_printf0("root in register\n\n");
+ GC_err_printf("root in register\n\n");
goto out;
case GC_FINALIZER_REFD:
- GC_err_printf0("list of finalizable objects\n\n");
+ GC_err_printf("list of finalizable objects\n\n");
goto out;
case GC_REFD_FROM_HEAP:
- GC_err_printf1("offset %ld in object:\n", (unsigned long)offset);
+ GC_err_printf("offset %ld in object:\n", (unsigned long)offset);
/* Take GC_base(base) to get real base, i.e. header. */
GC_print_heap_obj(GC_base(base));
- GC_err_printf0("\n");
+ GC_err_printf("\n");
break;
}
current = base;
@@ -221,7 +220,7 @@ ptr_t p;
{
void * current;
current = GC_generate_random_valid_address();
- GC_printf1("\n****Chose address 0x%lx in object\n", (unsigned long)current);
+ GC_printf("\n****Chose address %p in object\n", current);
GC_print_backtrace(current);
}
@@ -237,11 +236,7 @@ ptr_t p;
(((word)(p + sizeof(oh) + sz - 1) ^ (word)p) >= HBLKSIZE)
/* Store debugging info into p. Return displaced pointer. */
/* Assumes we don't hold allocation lock. */
-ptr_t GC_store_debug_info(p, sz, string, integer)
-register ptr_t p; /* base pointer */
-word sz; /* bytes */
-GC_CONST char * string;
-word integer;
+ptr_t GC_store_debug_info(ptr_t p, word sz, const char *string, word integer)
{
register word * result = (word *)((oh *)p + 1);
DCL_LOCK_STATE;
@@ -273,11 +268,7 @@ word integer;
#ifdef DBG_HDRS_ALL
/* Store debugging info into p. Return displaced pointer. */
/* This version assumes we do hold the allocation lock. */
-ptr_t GC_store_debug_info_inner(p, sz, string, integer)
-register ptr_t p; /* base pointer */
-word sz; /* bytes */
-char * string;
-word integer;
+ptr_t GC_store_debug_info_inner(ptr_t p, word sz, char *string, word integer)
{
register word * result = (word *)((oh *)p + 1);
@@ -375,7 +366,8 @@ ptr_t p;
GC_err_puts("STUBBORN");
break;
default:
- GC_err_printf2("kind %ld, descr 0x%lx", kind, hhdr -> hb_descr);
+ GC_err_printf("kind %d, descr 0x%lx", kind,
+ (unsigned long)(hhdr -> hb_descr));
}
}
}
@@ -388,12 +380,12 @@ ptr_t p;
register oh * ohdr = (oh *)GC_base(p);
GC_ASSERT(!I_HOLD_LOCK());
- GC_err_printf1("0x%lx (", ((unsigned long)ohdr + sizeof(oh)));
+ GC_err_printf("%p (", ((ptr_t)ohdr + sizeof(oh)));
GC_err_puts(ohdr -> oh_string);
# ifdef SHORT_DBG_HDRS
- GC_err_printf1(":%ld, ", (unsigned long)(ohdr -> oh_int));
+ GC_err_printf(":%ld, ", (unsigned long)(ohdr -> oh_int));
# else
- GC_err_printf2(":%ld, sz=%ld, ", (unsigned long)(ohdr -> oh_int),
+ GC_err_printf(":%ld, sz=%ld, ", (unsigned long)(ohdr -> oh_int),
(unsigned long)(ohdr -> oh_sz));
# endif
GC_print_type((ptr_t)(ohdr + 1));
@@ -401,12 +393,7 @@ ptr_t p;
PRINT_CALL_CHAIN(ohdr);
}
-# if defined(__STDC__) || defined(__cplusplus)
- void GC_debug_print_heap_obj_proc(ptr_t p)
-# else
- void GC_debug_print_heap_obj_proc(p)
- ptr_t p;
-# endif
+void GC_debug_print_heap_obj_proc(ptr_t p)
{
GC_ASSERT(!I_HOLD_LOCK());
if (GC_HAS_DEBUG_INFO(p)) {
@@ -417,17 +404,15 @@ ptr_t p;
}
#ifndef SHORT_DBG_HDRS
-void GC_print_smashed_obj(p, clobbered_addr)
-ptr_t p, clobbered_addr;
+void GC_print_smashed_obj(ptr_t p, ptr_t clobbered_addr)
{
register oh * ohdr = (oh *)GC_base(p);
GC_ASSERT(!I_HOLD_LOCK());
- GC_err_printf2("0x%lx in object at 0x%lx(", (unsigned long)clobbered_addr,
- (unsigned long)p);
+ GC_err_printf("%p in object at %p(", clobbered_addr, p);
if (clobbered_addr <= (ptr_t)(&(ohdr -> oh_sz))
|| ohdr -> oh_string == 0) {
- GC_err_printf1("<smashed>, appr. sz = %ld)\n",
+ GC_err_printf("<smashed>, appr. sz = %ld)\n",
(GC_size((ptr_t)ohdr) - DEBUG_BYTES));
} else {
if (ohdr -> oh_string[0] == '\0') {
@@ -435,20 +420,20 @@ ptr_t p, clobbered_addr;
} else {
GC_err_puts(ohdr -> oh_string);
}
- GC_err_printf2(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int),
+ GC_err_printf(":%ld, sz=%ld)\n", (unsigned long)(ohdr -> oh_int),
(unsigned long)(ohdr -> oh_sz));
PRINT_CALL_CHAIN(ohdr);
}
}
#endif
-void GC_check_heap_proc GC_PROTO((void));
+void GC_check_heap_proc (void);
-void GC_print_all_smashed_proc GC_PROTO((void));
+void GC_print_all_smashed_proc (void);
-void GC_do_nothing() {}
+void GC_do_nothing(void) {}
-void GC_start_debugging()
+void GC_start_debugging(void)
{
# ifndef SHORT_DBG_HDRS
GC_check_heap = GC_check_heap_proc;
@@ -464,36 +449,21 @@ void GC_start_debugging()
size_t GC_debug_header_size = sizeof(oh);
-# if defined(__STDC__) || defined(__cplusplus)
- void GC_debug_register_displacement(GC_word offset)
-# else
- void GC_debug_register_displacement(offset)
- GC_word offset;
-# endif
+void GC_debug_register_displacement(size_t offset)
{
GC_register_displacement(offset);
GC_register_displacement((word)sizeof(oh) + offset);
}
-# ifdef __STDC__
- GC_PTR GC_debug_malloc(size_t lb, GC_EXTRA_PARAMS)
-# else
- GC_PTR GC_debug_malloc(lb, s, i)
- size_t lb;
- char * s;
- int i;
-# ifdef GC_ADD_CALLER
- --> GC_ADD_CALLER not implemented for K&R C
-# endif
-# endif
+void * GC_debug_malloc(size_t lb, GC_EXTRA_PARAMS)
{
- GC_PTR result = GC_malloc(lb + DEBUG_BYTES);
+ void * result = GC_malloc(lb + DEBUG_BYTES);
if (result == 0) {
- GC_err_printf1("GC_debug_malloc(%ld) returning NIL (",
- (unsigned long) lb);
+ GC_err_printf("GC_debug_malloc(%lu) returning NIL (",
+ (unsigned long) lb);
GC_err_puts(s);
- GC_err_printf1(":%ld)\n", (unsigned long)i);
+ GC_err_printf(":%ld)\n", (unsigned long)i);
return(0);
}
if (!GC_debugging_started) {
@@ -503,25 +473,15 @@ size_t GC_debug_header_size = sizeof(oh);
return (GC_store_debug_info(result, (word)lb, s, (word)i));
}
-# ifdef __STDC__
- GC_PTR GC_debug_malloc_ignore_off_page(size_t lb, GC_EXTRA_PARAMS)
-# else
- GC_PTR GC_debug_malloc_ignore_off_page(lb, s, i)
- size_t lb;
- char * s;
- int i;
-# ifdef GC_ADD_CALLER
- --> GC_ADD_CALLER not implemented for K&R C
-# endif
-# endif
+void * GC_debug_malloc_ignore_off_page(size_t lb, GC_EXTRA_PARAMS)
{
- GC_PTR result = GC_malloc_ignore_off_page(lb + DEBUG_BYTES);
+ void * result = GC_malloc_ignore_off_page(lb + DEBUG_BYTES);
if (result == 0) {
- GC_err_printf1("GC_debug_malloc_ignore_off_page(%ld) returning NIL (",
+ GC_err_printf("GC_debug_malloc_ignore_off_page(%lu) returning NIL (",
(unsigned long) lb);
GC_err_puts(s);
- GC_err_printf1(":%ld)\n", (unsigned long)i);
+ GC_err_printf(":%lu)\n", (unsigned long)i);
return(0);
}
if (!GC_debugging_started) {
@@ -531,25 +491,15 @@ size_t GC_debug_header_size = sizeof(oh);
return (GC_store_debug_info(result, (word)lb, s, (word)i));
}
-# ifdef __STDC__
- GC_PTR GC_debug_malloc_atomic_ignore_off_page(size_t lb, GC_EXTRA_PARAMS)
-# else
- GC_PTR GC_debug_malloc_atomic_ignore_off_page(lb, s, i)
- size_t lb;
- char * s;
- int i;
-# ifdef GC_ADD_CALLER
- --> GC_ADD_CALLER not implemented for K&R C
-# endif
-# endif
+void * GC_debug_malloc_atomic_ignore_off_page(size_t lb, GC_EXTRA_PARAMS)
{
- GC_PTR result = GC_malloc_atomic_ignore_off_page(lb + DEBUG_BYTES);
+ void * result = GC_malloc_atomic_ignore_off_page(lb + DEBUG_BYTES);
if (result == 0) {
- GC_err_printf1("GC_debug_malloc_atomic_ignore_off_page(%ld)"
+ GC_err_printf("GC_debug_malloc_atomic_ignore_off_page(%lu)"
" returning NIL (", (unsigned long) lb);
GC_err_puts(s);
- GC_err_printf1(":%ld)\n", (unsigned long)i);
+ GC_err_printf(":%lu)\n", (unsigned long)i);
return(0);
}
if (!GC_debugging_started) {
@@ -568,12 +518,12 @@ size_t GC_debug_header_size = sizeof(oh);
* We assume debugging was started in collector initialization,
* and we already hold the GC lock.
*/
- GC_PTR GC_debug_generic_malloc_inner(size_t lb, int k)
+ void * GC_debug_generic_malloc_inner(size_t lb, int k)
{
- GC_PTR result = GC_generic_malloc_inner(lb + DEBUG_BYTES, k);
+ void * result = GC_generic_malloc_inner(lb + DEBUG_BYTES, k);
if (result == 0) {
- GC_err_printf1("GC internal allocation (%ld bytes) returning NIL\n",
+ GC_err_printf("GC internal allocation (%lu bytes) returning NIL\n",
(unsigned long) lb);
return(0);
}
@@ -581,13 +531,13 @@ size_t GC_debug_header_size = sizeof(oh);
return (GC_store_debug_info_inner(result, (word)lb, "INTERNAL", (word)0));
}
- GC_PTR GC_debug_generic_malloc_inner_ignore_off_page(size_t lb, int k)
+ void * GC_debug_generic_malloc_inner_ignore_off_page(size_t lb, int k)
{
- GC_PTR result = GC_generic_malloc_inner_ignore_off_page(
+ void * result = GC_generic_malloc_inner_ignore_off_page(
lb + DEBUG_BYTES, k);
if (result == 0) {
- GC_err_printf1("GC internal allocation (%ld bytes) returning NIL\n",
+ GC_err_printf("GC internal allocation (%lu bytes) returning NIL\n",
(unsigned long) lb);
return(0);
}
@@ -597,22 +547,15 @@ size_t GC_debug_header_size = sizeof(oh);
# endif
#ifdef STUBBORN_ALLOC
-# ifdef __STDC__
- GC_PTR GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS)
-# else
- GC_PTR GC_debug_malloc_stubborn(lb, s, i)
- size_t lb;
- char * s;
- int i;
-# endif
+void * GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS)
{
- GC_PTR result = GC_malloc_stubborn(lb + DEBUG_BYTES);
+ void * result = GC_malloc_stubborn(lb + DEBUG_BYTES);
if (result == 0) {
- GC_err_printf1("GC_debug_malloc(%ld) returning NIL (",
- (unsigned long) lb);
+ GC_err_printf("GC_debug_malloc(%lu) returning NIL (",
+ (unsigned long) lb);
GC_err_puts(s);
- GC_err_printf1(":%ld)\n", (unsigned long)i);
+ GC_err_printf(":%lu)\n", (unsigned long)i);
return(0);
}
if (!GC_debugging_started) {
@@ -622,41 +565,35 @@ size_t GC_debug_header_size = sizeof(oh);
return (GC_store_debug_info(result, (word)lb, s, (word)i));
}
-void GC_debug_change_stubborn(p)
-GC_PTR p;
+void GC_debug_change_stubborn(void *p)
{
- register GC_PTR q = GC_base(p);
- register hdr * hhdr;
+ void * q = GC_base(p);
+ hdr * hhdr;
if (q == 0) {
- GC_err_printf1("Bad argument: 0x%lx to GC_debug_change_stubborn\n",
- (unsigned long) p);
+ GC_err_printf("Bad argument: %p to GC_debug_change_stubborn\n", p);
ABORT("GC_debug_change_stubborn: bad arg");
}
hhdr = HDR(q);
if (hhdr -> hb_obj_kind != STUBBORN) {
- GC_err_printf1("GC_debug_change_stubborn arg not stubborn: 0x%lx\n",
- (unsigned long) p);
+ GC_err_printf("GC_debug_change_stubborn arg not stubborn: %p\n", p);
ABORT("GC_debug_change_stubborn: arg not stubborn");
}
GC_change_stubborn(q);
}
-void GC_debug_end_stubborn_change(p)
-GC_PTR p;
+void GC_debug_end_stubborn_change(void *p)
{
- register GC_PTR q = GC_base(p);
+ register void * q = GC_base(p);
register hdr * hhdr;
if (q == 0) {
- GC_err_printf1("Bad argument: 0x%lx to GC_debug_end_stubborn_change\n",
- (unsigned long) p);
+ GC_err_printf("Bad argument: %p to GC_debug_end_stubborn_change\n", p);
ABORT("GC_debug_end_stubborn_change: bad arg");
}
hhdr = HDR(q);
if (hhdr -> hb_obj_kind != STUBBORN) {
- GC_err_printf1("debug_end_stubborn_change arg not stubborn: 0x%lx\n",
- (unsigned long) p);
+ GC_err_printf("debug_end_stubborn_change arg not stubborn: %p\n", p);
ABORT("GC_debug_end_stubborn_change: arg not stubborn");
}
GC_end_stubborn_change(q);
@@ -664,46 +601,32 @@ GC_PTR p;
#else /* !STUBBORN_ALLOC */
-# ifdef __STDC__
- GC_PTR GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS)
-# else
- GC_PTR GC_debug_malloc_stubborn(lb, s, i)
- size_t lb;
- char * s;
- int i;
-# endif
+void * GC_debug_malloc_stubborn(size_t lb, GC_EXTRA_PARAMS)
{
return GC_debug_malloc(lb, OPT_RA s, i);
}
void GC_debug_change_stubborn(p)
-GC_PTR p;
+void * p;
{
}
void GC_debug_end_stubborn_change(p)
-GC_PTR p;
+void * p;
{
}
#endif /* !STUBBORN_ALLOC */
-# ifdef __STDC__
- GC_PTR GC_debug_malloc_atomic(size_t lb, GC_EXTRA_PARAMS)
-# else
- GC_PTR GC_debug_malloc_atomic(lb, s, i)
- size_t lb;
- char * s;
- int i;
-# endif
+void * GC_debug_malloc_atomic(size_t lb, GC_EXTRA_PARAMS)
{
- GC_PTR result = GC_malloc_atomic(lb + DEBUG_BYTES);
+ void * result = GC_malloc_atomic(lb + DEBUG_BYTES);
if (result == 0) {
- GC_err_printf1("GC_debug_malloc_atomic(%ld) returning NIL (",
+ GC_err_printf("GC_debug_malloc_atomic(%lu) returning NIL (",
(unsigned long) lb);
GC_err_puts(s);
- GC_err_printf1(":%ld)\n", (unsigned long)i);
+ GC_err_printf(":%lu)\n", (unsigned long)i);
return(0);
}
if (!GC_debugging_started) {
@@ -713,22 +636,15 @@ GC_PTR p;
return (GC_store_debug_info(result, (word)lb, s, (word)i));
}
-# ifdef __STDC__
- GC_PTR GC_debug_malloc_uncollectable(size_t lb, GC_EXTRA_PARAMS)
-# else
- GC_PTR GC_debug_malloc_uncollectable(lb, s, i)
- size_t lb;
- char * s;
- int i;
-# endif
+void * GC_debug_malloc_uncollectable(size_t lb, GC_EXTRA_PARAMS)
{
- GC_PTR result = GC_malloc_uncollectable(lb + UNCOLLECTABLE_DEBUG_BYTES);
+ void * result = GC_malloc_uncollectable(lb + UNCOLLECTABLE_DEBUG_BYTES);
if (result == 0) {
- GC_err_printf1("GC_debug_malloc_uncollectable(%ld) returning NIL (",
+ GC_err_printf("GC_debug_malloc_uncollectable(%lu) returning NIL (",
(unsigned long) lb);
GC_err_puts(s);
- GC_err_printf1(":%ld)\n", (unsigned long)i);
+ GC_err_printf(":%lu)\n", (unsigned long)i);
return(0);
}
if (!GC_debugging_started) {
@@ -739,24 +655,17 @@ GC_PTR p;
}
#ifdef ATOMIC_UNCOLLECTABLE
-# ifdef __STDC__
- GC_PTR GC_debug_malloc_atomic_uncollectable(size_t lb, GC_EXTRA_PARAMS)
-# else
- GC_PTR GC_debug_malloc_atomic_uncollectable(lb, s, i)
- size_t lb;
- char * s;
- int i;
-# endif
+void * GC_debug_malloc_atomic_uncollectable(size_t lb, GC_EXTRA_PARAMS)
{
- GC_PTR result =
+ void * result =
GC_malloc_atomic_uncollectable(lb + UNCOLLECTABLE_DEBUG_BYTES);
if (result == 0) {
- GC_err_printf1(
- "GC_debug_malloc_atomic_uncollectable(%ld) returning NIL (",
+ GC_err_printf(
+ "GC_debug_malloc_atomic_uncollectable(%lu) returning NIL (",
(unsigned long) lb);
GC_err_puts(s);
- GC_err_printf1(":%ld)\n", (unsigned long)i);
+ GC_err_printf(":%lu)\n", (unsigned long)i);
return(0);
}
if (!GC_debugging_started) {
@@ -767,36 +676,29 @@ GC_PTR p;
}
#endif /* ATOMIC_UNCOLLECTABLE */
-# ifdef __STDC__
- void GC_debug_free(GC_PTR p)
-# else
- void GC_debug_free(p)
- GC_PTR p;
-# endif
+void GC_debug_free(void * p)
{
- register GC_PTR base;
- register ptr_t clobbered;
+ ptr_t base;
+ ptr_t clobbered;
if (0 == p) return;
base = GC_base(p);
if (base == 0) {
- GC_err_printf1("Attempt to free invalid pointer %lx\n",
- (unsigned long)p);
+ GC_err_printf("Attempt to free invalid pointer %p\n", p);
ABORT("free(invalid pointer)");
}
if ((ptr_t)p - (ptr_t)base != sizeof(oh)) {
- GC_err_printf1(
- "GC_debug_free called on pointer %lx wo debugging info\n",
- (unsigned long)p);
+ GC_err_printf(
+ "GC_debug_free called on pointer %p wo debugging info\n", p);
} else {
# ifndef SHORT_DBG_HDRS
clobbered = GC_check_annotated_obj((oh *)base);
if (clobbered != 0) {
if (((oh *)base) -> oh_sz == GC_size(base)) {
- GC_err_printf0(
+ GC_err_printf(
"GC_debug_free: found previously deallocated (?) object at ");
} else {
- GC_err_printf0("GC_debug_free: found smashed location at ");
+ GC_err_printf("GC_debug_free: found smashed location at ");
}
GC_print_smashed_obj(p, clobbered);
}
@@ -807,7 +709,7 @@ GC_PTR p;
if (GC_find_leak) {
GC_free(base);
} else {
- register hdr * hhdr = HDR(p);
+ hdr * hhdr = HDR(p);
GC_bool uncollectable = FALSE;
if (hhdr -> hb_obj_kind == UNCOLLECTABLE) {
@@ -822,52 +724,42 @@ GC_PTR p;
GC_free(base);
} else {
size_t i;
- size_t obj_sz = hhdr -> hb_sz - BYTES_TO_WORDS(sizeof(oh));
+ size_t obj_sz = BYTES_TO_WORDS(hhdr -> hb_sz - sizeof(oh));
for (i = 0; i < obj_sz; ++i) ((word *)p)[i] = 0xdeadbeef;
- GC_ASSERT((word *)p + i == (word *)base + hhdr -> hb_sz);
+ GC_ASSERT((word *)p + i == (word *)(base + hhdr -> hb_sz));
}
} /* !GC_find_leak */
}
#ifdef THREADS
-extern void GC_free_inner(GC_PTR p);
+extern void GC_free_inner(void * p);
/* Used internally; we assume it's called correctly. */
-void GC_debug_free_inner(GC_PTR p)
+void GC_debug_free_inner(void * p)
{
GC_free_inner(GC_base(p));
}
#endif
-# ifdef __STDC__
- GC_PTR GC_debug_realloc(GC_PTR p, size_t lb, GC_EXTRA_PARAMS)
-# else
- GC_PTR GC_debug_realloc(p, lb, s, i)
- GC_PTR p;
- size_t lb;
- char *s;
- int i;
-# endif
+void * GC_debug_realloc(void * p, size_t lb, GC_EXTRA_PARAMS)
{
- register GC_PTR base = GC_base(p);
- register ptr_t clobbered;
- register GC_PTR result;
- register size_t copy_sz = lb;
- register size_t old_sz;
- register hdr * hhdr;
+ void * base = GC_base(p);
+ ptr_t clobbered;
+ void * result;
+ size_t copy_sz = lb;
+ size_t old_sz;
+ hdr * hhdr;
if (p == 0) return(GC_debug_malloc(lb, OPT_RA s, i));
if (base == 0) {
- GC_err_printf1(
- "Attempt to reallocate invalid pointer %lx\n", (unsigned long)p);
+ GC_err_printf("Attempt to reallocate invalid pointer %p\n", p);
ABORT("realloc(invalid pointer)");
}
if ((ptr_t)p - (ptr_t)base != sizeof(oh)) {
- GC_err_printf1(
- "GC_debug_realloc called on pointer %lx wo debugging info\n",
- (unsigned long)p);
+ GC_err_printf(
+ "GC_debug_realloc called on pointer %p wo debugging info\n", p);
return(GC_realloc(p, lb));
}
hhdr = HDR(base);
@@ -892,7 +784,7 @@ void GC_debug_free_inner(GC_PTR p)
break;
# endif
default:
- GC_err_printf0("GC_debug_realloc: encountered bad kind\n");
+ GC_err_printf("GC_debug_realloc: encountered bad kind\n");
ABORT("bad kind");
}
# ifdef SHORT_DBG_HDRS
@@ -900,7 +792,7 @@ void GC_debug_free_inner(GC_PTR p)
# else
clobbered = GC_check_annotated_obj((oh *)base);
if (clobbered != 0) {
- GC_err_printf0("GC_debug_realloc: found smashed location at ");
+ GC_err_printf("GC_debug_realloc: found smashed location at ");
GC_print_smashed_obj(p, clobbered);
}
old_sz = ((oh *)base) -> oh_sz;
@@ -922,12 +814,7 @@ void GC_debug_free_inner(GC_PTR p)
ptr_t GC_smashed[MAX_SMASHED];
unsigned GC_n_smashed = 0;
-# if defined(__STDC__) || defined(__cplusplus)
- void GC_add_smashed(ptr_t smashed)
-# else
- void GC_add_smashed(smashed)
- ptr_t smashed;
-#endif
+void GC_add_smashed(ptr_t smashed)
{
GC_ASSERT(GC_is_marked(GC_base(smashed)));
GC_smashed[GC_n_smashed] = smashed;
@@ -938,13 +825,13 @@ unsigned GC_n_smashed = 0;
}
/* Print all objects on the list. Clear the list. */
-void GC_print_all_smashed_proc ()
+void GC_print_all_smashed_proc(void)
{
unsigned i;
GC_ASSERT(!I_HOLD_LOCK());
if (GC_n_smashed == 0) return;
- GC_err_printf0("GC_check_heap_block: found smashed heap objects:\n");
+ GC_err_printf("GC_check_heap_block: found smashed heap objects:\n");
for (i = 0; i < GC_n_smashed; ++i) {
GC_print_smashed_obj(GC_base(GC_smashed[i]), GC_smashed[i]);
GC_smashed[i] = 0;
@@ -952,37 +839,32 @@ void GC_print_all_smashed_proc ()
GC_n_smashed = 0;
}
-/* Check all marked objects in the given block for validity */
+/* Check all marked objects in the given block for validity */
+/* Avoid GC_apply_to_each_object for performance reasons. */
/*ARGSUSED*/
-# if defined(__STDC__) || defined(__cplusplus)
- void GC_check_heap_block(register struct hblk *hbp, word dummy)
-# else
- void GC_check_heap_block(hbp, dummy)
- register struct hblk *hbp; /* ptr to current heap block */
- word dummy;
-# endif
+void GC_check_heap_block(struct hblk *hbp, word dummy)
{
- register struct hblkhdr * hhdr = HDR(hbp);
- register word sz = hhdr -> hb_sz;
- register int word_no;
- register word *p, *plim;
+ struct hblkhdr * hhdr = HDR(hbp);
+ size_t sz = hhdr -> hb_sz;
+ int bit_no;
+ unsigned char *p, *plim;
- p = (word *)(hbp->hb_body);
- word_no = 0;
- if (sz > MAXOBJSZ) {
+ p = hbp->hb_body;
+ bit_no = 0;
+ if (sz > MAXOBJBYTES) {
plim = p;
} else {
- plim = (word *)((((word)hbp) + HBLKSIZE) - WORDS_TO_BYTES(sz));
+ plim = hbp->hb_body + HBLKSIZE - sz;
}
/* go through all words in block */
while( p <= plim ) {
- if( mark_bit_from_hdr(hhdr, word_no)
+ if( mark_bit_from_hdr(hhdr, bit_no)
&& GC_HAS_DEBUG_INFO((ptr_t)p)) {
ptr_t clobbered = GC_check_annotated_obj((oh *)p);
if (clobbered != 0) GC_add_smashed(clobbered);
}
- word_no += sz;
+ bit_no += MARK_BIT_OFFSET(sz);
p += sz;
}
}
@@ -990,14 +872,12 @@ void GC_print_all_smashed_proc ()
/* This assumes that all accessible objects are marked, and that */
/* I hold the allocation lock. Normally called by collector. */
-void GC_check_heap_proc()
+void GC_check_heap_proc(void)
{
# ifndef SMALL_CONFIG
-# ifdef ALIGN_DOUBLE
- GC_STATIC_ASSERT((sizeof(oh) & (2 * sizeof(word) - 1)) == 0);
-# else
- GC_STATIC_ASSERT((sizeof(oh) & (sizeof(word) - 1)) == 0);
-# endif
+ /* Ignore gcc no effect warning on the following. */
+ GC_STATIC_ASSERT((sizeof(oh) & (GRANULE_BYTES - 1)) == 0);
+ /* FIXME: Should we check for twice that alignment? */
# endif
GC_apply_to_all_blocks(GC_check_heap_block, (word)0);
}
@@ -1006,16 +886,10 @@ void GC_check_heap_proc()
struct closure {
GC_finalization_proc cl_fn;
- GC_PTR cl_data;
+ void * cl_data;
};
-# ifdef __STDC__
- void * GC_make_closure(GC_finalization_proc fn, void * data)
-# else
- GC_PTR GC_make_closure(fn, data)
- GC_finalization_proc fn;
- GC_PTR data;
-# endif
+void * GC_make_closure(GC_finalization_proc fn, void * data)
{
struct closure * result =
# ifdef DBG_HDRS_ALL
@@ -1027,34 +901,25 @@ struct closure {
result -> cl_fn = fn;
result -> cl_data = data;
- return((GC_PTR)result);
+ return((void *)result);
}
-# ifdef __STDC__
- void GC_debug_invoke_finalizer(void * obj, void * data)
-# else
- void GC_debug_invoke_finalizer(obj, data)
- char * obj;
- char * data;
-# endif
+void GC_debug_invoke_finalizer(void * obj, void * data)
{
register struct closure * cl = (struct closure *) data;
- (*(cl -> cl_fn))((GC_PTR)((char *)obj + sizeof(oh)), cl -> cl_data);
+ (*(cl -> cl_fn))((void *)((char *)obj + sizeof(oh)), cl -> cl_data);
}
/* Set ofn and ocd to reflect the values we got back. */
-static void store_old (obj, my_old_fn, my_old_cd, ofn, ocd)
-GC_PTR obj;
-GC_finalization_proc my_old_fn;
-struct closure * my_old_cd;
-GC_finalization_proc *ofn;
-GC_PTR *ocd;
+static void store_old (void *obj, GC_finalization_proc my_old_fn,
+ struct closure *my_old_cd, GC_finalization_proc *ofn,
+ void **ocd)
{
if (0 != my_old_fn) {
if (my_old_fn != GC_debug_invoke_finalizer) {
- GC_err_printf1("Debuggable object at 0x%lx had non-debug finalizer.\n",
- obj);
+ GC_err_printf("Debuggable object at %p had non-debug finalizer.\n",
+ obj);
/* This should probably be fatal. */
} else {
if (ofn) *ofn = my_old_cd -> cl_fn;
@@ -1066,26 +931,17 @@ GC_PTR *ocd;
}
}
-# ifdef __STDC__
- void GC_debug_register_finalizer(GC_PTR obj, GC_finalization_proc fn,
- GC_PTR cd, GC_finalization_proc *ofn,
- GC_PTR *ocd)
-# else
- void GC_debug_register_finalizer(obj, fn, cd, ofn, ocd)
- GC_PTR obj;
- GC_finalization_proc fn;
- GC_PTR cd;
- GC_finalization_proc *ofn;
- GC_PTR *ocd;
-# endif
+void GC_debug_register_finalizer(void * obj, GC_finalization_proc fn,
+ void * cd, GC_finalization_proc *ofn,
+ void * *ocd)
{
GC_finalization_proc my_old_fn;
- GC_PTR my_old_cd;
+ void * my_old_cd;
ptr_t base = GC_base(obj);
if (0 == base) return;
if ((ptr_t)obj - base != sizeof(oh)) {
- GC_err_printf1(
- "GC_debug_register_finalizer called with non-base-pointer 0x%lx\n",
+ GC_err_printf(
+ "GC_debug_register_finalizer called with non-base-pointer %p\n",
obj);
}
if (0 == fn) {
@@ -1097,28 +953,19 @@ GC_PTR *ocd;
store_old(obj, my_old_fn, (struct closure *)my_old_cd, ofn, ocd);
}
-# ifdef __STDC__
- void GC_debug_register_finalizer_no_order
- (GC_PTR obj, GC_finalization_proc fn,
- GC_PTR cd, GC_finalization_proc *ofn,
- GC_PTR *ocd)
-# else
- void GC_debug_register_finalizer_no_order
- (obj, fn, cd, ofn, ocd)
- GC_PTR obj;
- GC_finalization_proc fn;
- GC_PTR cd;
- GC_finalization_proc *ofn;
- GC_PTR *ocd;
-# endif
+void GC_debug_register_finalizer_no_order
+ (void * obj, GC_finalization_proc fn,
+ void * cd, GC_finalization_proc *ofn,
+ void * *ocd)
{
GC_finalization_proc my_old_fn;
- GC_PTR my_old_cd;
+ void * my_old_cd;
ptr_t base = GC_base(obj);
if (0 == base) return;
if ((ptr_t)obj - base != sizeof(oh)) {
- GC_err_printf1(
- "GC_debug_register_finalizer_no_order called with non-base-pointer 0x%lx\n",
+ GC_err_printf(
+ "GC_debug_register_finalizer_no_order called with "
+ "non-base-pointer %p\n",
obj);
}
if (0 == fn) {
@@ -1131,29 +978,19 @@ GC_PTR *ocd;
store_old(obj, my_old_fn, (struct closure *)my_old_cd, ofn, ocd);
}
-# ifdef __STDC__
- void GC_debug_register_finalizer_ignore_self
- (GC_PTR obj, GC_finalization_proc fn,
- GC_PTR cd, GC_finalization_proc *ofn,
- GC_PTR *ocd)
-# else
- void GC_debug_register_finalizer_ignore_self
- (obj, fn, cd, ofn, ocd)
- GC_PTR obj;
- GC_finalization_proc fn;
- GC_PTR cd;
- GC_finalization_proc *ofn;
- GC_PTR *ocd;
-# endif
+void GC_debug_register_finalizer_ignore_self
+ (void * obj, GC_finalization_proc fn,
+ void * cd, GC_finalization_proc *ofn,
+ void * *ocd)
{
GC_finalization_proc my_old_fn;
- GC_PTR my_old_cd;
+ void * my_old_cd;
ptr_t base = GC_base(obj);
if (0 == base) return;
if ((ptr_t)obj - base != sizeof(oh)) {
- GC_err_printf1(
- "GC_debug_register_finalizer_ignore_self called with non-base-pointer 0x%lx\n",
- obj);
+ GC_err_printf(
+ "GC_debug_register_finalizer_ignore_self called with "
+ "non-base-pointer %p\n", obj);
}
if (0 == fn) {
GC_register_finalizer_ignore_self(base, 0, 0, &my_old_fn, &my_old_cd);
@@ -1171,15 +1008,12 @@ GC_PTR *ocd;
# define RA
#endif
-GC_PTR GC_debug_malloc_replacement(lb)
-size_t lb;
+void * GC_debug_malloc_replacement(size_t lb)
{
return GC_debug_malloc(lb, RA "unknown", 0);
}
-GC_PTR GC_debug_realloc_replacement(p, lb)
-GC_PTR p;
-size_t lb;
+void * GC_debug_realloc_replacement(void *p, size_t lb)
{
return GC_debug_realloc(p, lb, RA "unknown", 0);
}
diff --git a/digimars.mak b/digimars.mak
index 9778fee..41178fd 100644
--- a/digimars.mak
+++ b/digimars.mak
@@ -3,7 +3,7 @@
# Written by Walter Bright
-DEFINES=-DNDEBUG -DSILENT -DGC_BUILD -D_WINDOWS -DGC_DLL -DALL_INTERIOR_POINTERS -D__STDC__ -DWIN32_THREADS
+DEFINES=-DNDEBUG -DGC_BUILD -D_WINDOWS -DGC_DLL -DALL_INTERIOR_POINTERS -D__STDC__ -DWIN32_THREADS
CFLAGS=-Iinclude $(DEFINES) -wx -g
LFLAGS=/ma/implib/co
CC=sc
@@ -61,7 +61,7 @@ gctest.exe : gc.lib tests\test.obj
sc -ogctest.exe tests\test.obj gc.lib
tests\test.obj : tests\test.c
- $(CC) -c -g -DNDEBUG -DSILENT -DGC_BUILD -D_WINDOWS -DGC_DLL \
+ $(CC) -c -g -DNDEBUG -DGC_BUILD -D_WINDOWS -DGC_DLL \
-DALL_INTERIOR_POINTERS -DWIN32_THREADS \
-Iinclude tests\test.c -otests\test.obj
diff --git a/doc/Makefile.in b/doc/Makefile.in
index bf7d9a5..708fd51 100644
--- a/doc/Makefile.in
+++ b/doc/Makefile.in
@@ -105,7 +105,7 @@ OBJDUMP = @OBJDUMP@
PACKAGE = @PACKAGE@
RANLIB = @RANLIB@
STRIP = @STRIP@
-THREADDLLIBS = @THREADDLLIBS@
+THREADLIBS = @THREADLIBS@
UNWINDLIBS = @UNWINDLIBS@
VERSION = @VERSION@
addincludes = @addincludes@
diff --git a/doc/README b/doc/README
index b7820d5..ff77113 100644
--- a/doc/README
+++ b/doc/README
@@ -28,7 +28,7 @@ are GPL'ed, but with an exception that should cover all uses in the
collector. (If you are concerned about such things, I recommend you look
at the notice in config.guess or ltmain.sh.)
-This is version 6.4 of a conservative garbage collector for C and C++.
+This is version 6.3 of a conservative garbage collector for C and C++.
You might find a more recent version of this at
diff --git a/doc/README.changes b/doc/README.changes
index 265e06c..78a4e06 100644
--- a/doc/README.changes
+++ b/doc/README.changes
@@ -2077,16 +2077,13 @@ Since 6.3alpha5:
Adrian Bunk for the patches).
- Integrated NetBSD/OpenBSD patches from Marc Recht and Matthias Drochner.
-Since gc6.3alpha6:
+Since 6.3alpha6:
- Compile test_cpp.cc with CXXCOMPILE instead of COMPILE.
- Very large allocations could cause a collector hang. Correct
calculation of GC_collect_at_heapsize.
- GC_print_hblkfreelist printed some bogus results if USE_MUNMAP
was defined.
- - The generic GC_THREADS macro didn't work correctly on Solaris,
- since the implementation failed to include gc_config_macros.h
- before deciding whether or not to compile the rest of the file.
- - Threadlibs.c failed to expand the generic GC_THREADS macro.
+ - Include gc_config_macros.h in threadlibs.c.
- Correct MacOSX thread stop code. (Thanks to Dick Porter.)
- SMALL_OBJ definition was off by one. This could cause crashes
at startup. (Thanks to Zoltan Varga for narrowing this down to
@@ -2096,12 +2093,12 @@ Since gc6.3alpha6:
- Changed X86_64 implementation to use SA_SIGINFO in the MPROTECT_VDB
implementation. The old approach appears to have been broken by
recent kernels.
- - Add GC_ATTR_UNUSED to eliminate a warning in gc_allocator.h. (Thanks
+ - Added GC_ATTR_UNUSED to eliminate a warning in gc_allocator.h (Thanks
to Andrew Begel.)
- Fix GC_task_self declaration in os_dep.c. (Thanks to Andrew Pinski.)
- Increase INITIAL_BUF_SZ in os_dep.c for Solaris /proc reads.
-Since 6.3:
+Since gc6.3:
- Merge gcconfig.h changes from gcc tree.
- Unconditionally include gc_priv.h in solaris_pthreads.c, win32_threads.h,
aix_irix_threads.c, and solaris_threads.c to get thread definitions.
@@ -2111,7 +2108,7 @@ Since 6.3:
- Go ahead and split large blocks in GC_allochblk_nth if GC_dont_gc
is set. (Thanks to Alexander Petrossian.)
- GC_PRINT_BACK_HEIGHT would deadlock with thread support.
- - Let in_progress_space in backgraph.s grow dynamically.
+ - Let in_progress_space in backgraph.s grow dyanmically.
- Fix README.solaris2. The GC_thr_init() hack doesn't work anymore.
- Convert GC_finalizer_mem_freed to bytes in allchblk.c.
- Add missing declaration for GC_generic_malloc_words_small_inner.
@@ -2131,46 +2128,91 @@ Since 6.3:
(Thanks to Peter Colson.)
- Changed "int stack_size" declaration in pthread_support.c to use
size_t. (Only mattered with GC_ASSERTIONS enabled.)
- - Added CRIS (etrax) support. (Thanks to Simon Posnjak and
- Hans-Peter Nilsson.)
- - Removed GC_IGNORE_FB frame buffer recognition, and replaced
- it with a check that the mapping type is MEM_IMAGE.
- In theory, this should work much better, but it is a high
- risk change for win32. (Thanks to Ashley Bone for the crucial
- experimental data behind this, and to Rutger Ovidus for
- some further experiments.)
- - Fixed print_block_list to print the correct kind number for
- STUBBORN. (Thanks to Rutger Ovidus.)
- - GC_allochblk_nth incremented GC_words_wasted by bytes rather than
- words.
- - Consider GC_words_wasted in GC_adj_words_allocd only if it is within
- reason. (A hack to avoid some extremely unlikely scenarios in which
- we manage to allocate only "wasted" space. 7.0 has a better fix.)
- - Changed PowerPC GC_clear implementation to use lwsync instead of
- eieio, since the documentation recommends against eieio, and
- it seems to be incorrect if the preceding memory op is a load.
- - Fixed print_block_list to print the correct kind number for
- STUBBORN. (Thanks to Rutger Ovidus.)
- - GC_allochblk_nth incremented GC_words_wasted by bytes rather than
- words.
- - Have configure.in generate an error if it is asked to support
- pthreads, but doesn't know how to.
- - Added Kazuhiro Inaoka's patch for Renesas M32R support.
- - Have the GNU build mechanism link with -ldl. Rename THREADLIBS
- to THREADDLLIBS to reflect this. (Thanks to Sven Verdoolaege.)
- - Added Hannes Mehnert's patch for FreeBSD/SPARC support.
- - Merged some FreeBSD specific patches to threadlibs.c and dyn_load.c.
- (Thanks tp John Merryweather Cooper.)
- - Define MPROTECT_VDB on MACOSX only if threads are being used, since the
- dirty page tracking mechanism uses threads. (This avoids an undefined
- reference to _GC_darwin_register_mach_handler_thread.)
- - By popular demand, use __libc symbols only if we are built with
- USE_LIBC_PRIVATES, which is off by default, and not otherwise documented.
- - Ignore GC_enable_incremental() requests when KEEP_BACK_PTRS is set.
- The GC itself will dirty lots of pages in this cases, probably making
- it counterproductive on all platforms. And the DARWIN port crashes.
+
+
+Since gc6.4:
+ - Remove GC_PROTO, VOLATILE, GC_PTR, and GC_CONST. Assume ANSI C compiler
+ and use ANSI constructs unconditionally.
+ - Introduce #elif and #error in some of the appropriate places.
+ - Remove GC_printf cruft. Use stdargs.
+ - Remove separate Solaris threads support. Use the more generic Posix
+ implementation.
+ - Use atomic_ops for atomic operations and memory barriers.
+ - Clean up MPROTECT_VDB implementation. Use SA_SIGINFO wherever
+ possible.
+ - Remove broken SIGNALS stuff.
+ - Use size_t instead of word, where appropriate.
+ - Add .S.o rule to Makefile.am.
+ - Officially unsupport SunOS4, several old flavors of M68K (SunOS4,
+ A/UX, HP), IBM PC/RTs and RISCOS/Irix4. (I doubt the old code worked.
+ If anyone cares, these should be easy to resurrect.)
+ - Add EXPECT() in some critical places.
+ - Redefined hb_sz and hb_body to deal with bytes rather than words.
+ This affected a great deal of code. I would like to consistently use
+ byte offsets and sizes where there's not a convincing reason to do
+ otherwise.
+ - Redefined several other variables (GC_mem_found, GC_words_allocd)
+ etc. to use units of bytes. Most of these were also renamed to
+ reflect that fact.
+ - Killed as many "register" declarations as possible.
+ - Partially replaced stubborn allocation with manual write barrier.
+ It's currently broken.
+ - Restructured mark code, to allow mark bits to be kept either on
+ a per allocation granule or per object basis. The emphasis is
+ now on the -DUSE_MARK_BYTES option, since individual bits perform
+ quite badly on hyperthreaded P4s, and are probably suboptimal on
+ other architectures. -DUSE_MARK_BITS is currently broken, and may
+ be resurrected only for the single-threaded case. This significantly
+ reduced the cache footprint required by auxiliary GC data structures.
+ It also reduces space overhead for small heaps. It probably slows
+ things down slightly if interior pointers are very common.
+ - As part of the above, we now maintain an approximate count of set
+ mark bits in each heap block.
+ - As part of the above, the semantics of hb_map changed drastically.
+ For MARK_BIT_PER_OBJ, it doesn't exist. For MARK_BIT_PER_GRANULE,
+ it is purely a way to replace a mod instruction with a table lookup.
+ (Somewhat to my surprise, this still wins on modern hardware.)
+ - Removed PRINTSTATS, GATHERSTATS, and SILENT macros. Everything is
+ now controlled by GC_print_stats variable and GC_PRINT_STATS
+ and new GC_PRINT_VERBOSE_STATS environment variables.
+ - Add GC_log_printf and use it consistently for logging output.
+ - Unconditionally count the objects we reclaim in the sweep phase.
+ For thread local allocation, we need that anyway, and we expect
+ that's increasingly the only case that matters. And it simplifies
+ the code. In general expect minor performance hacks that benefit
+ only the single-threaded case to disappear.
+ - Remove GC_quiet from gc.h and elsewhere.
+ - Changed the heap expansion heuristic, and the definition of
+ GC_free_space_divisor, to refer to live data size, instead of total
+ heap size. I believe this is much more robust. It wasn't previously
+ possible, because we didn't have access to live data size.
+ - Thread local allocation added the extra byte in twice: Once in
+ thread_local_alloc, and once in malloc_many.
+ - Removed GC_malloc_words_small and GC_gcj_fast_malloc. A new
+ mechanism based on the thread local allocation data structures
+ is expected to be added instead. This should allow inlined code
+ that is both fast and doesn't rely on collector internals.
+ - Changed both free lists and reclaim lists to be indexed by granules
+ instead of words, norming halving their size.
+ - MERGE_SIZE is now the only option, and the macro was removed.
+ (Without it, we need a memory reference to GC_all_interior_pointers
+ anyway. Thus it costs us nothing.)
+ - Change GC_size_map to map to granules instead of words. Make sure
+ that every possible size up to TINY_FREELISTS is present.
+ - Split of macros need for fast inline allocation into gc_tiny_fl.h
+ in anticipation of a new inline allocator that doesn't rely on GC
+ internals.
+ - Changed thread local allocation to use GRANULE_BYTES and TINY_FREELISTS
+ in anticipation of a merge with the inline allocation code.
+ - Removed ALIGN_DOUBLE. This is mostly handled by GRANULE_BYTES.
+ - Make locking on most platforms conditional on GC_need_to_lock.
To do:
+ - Use thread-local allocation code by default.
+ - Fix USE_MARK_BITS.
+ - Fix stubborn allocation.
+ - function wrapping, conditional locking??
+ - Finish replacing stubborn allocation with manual write barrier??
- The USE_MUNMAP code should really use a separate data structure
indexed by physical page to keep track of time since last use of
a page. Using hblk headers means we lose track of ages when
diff --git a/doc/README.environment b/doc/README.environment
index 686e948..f2ec428 100644
--- a/doc/README.environment
+++ b/doc/README.environment
@@ -15,11 +15,11 @@ GC_LOOP_ON_ABORT - Causes the collector abort routine to enter a tight loop.
result in an infinite loop in a handler, allowing
similar debugging techniques.
-GC_PRINT_STATS - Turn on as much logging as is easily feasible without
- adding signifcant runtime overhead. Doesn't work if
- the collector is built with SMALL_CONFIG. Overridden
- by setting GC_quiet. On by default if the collector
- was built without -DSILENT.
+GC_PRINT_STATS - Turn on GC logging. Not functional with -DSMALL_CONFIG.
+
+GC_LOG_FILE - The name of the log file. Stderr by default.
+
+GC_PRINT_VERBOSE_STATS - Turn on even more logging.
GC_DUMP_REGULARLY - Generate a GC debugging dump GC_dump() on startup
and during every collection. Very verbose. Useful
@@ -47,7 +47,7 @@ GC_NPROCS=<n> - Linux w/threads only. Explicitly sets the number of processors
first spinning.
GC_MARKERS=<n> - Linux w/threads and parallel marker only. Set the number
- of marker threads. This is normaly set to the number of
+ of marker threads. This is normally set to the number of
processors. It is safer to adjust GC_MARKERS than GC_NPROCS,
since GC_MARKERS has no impact on the lock implementation.
@@ -115,7 +115,6 @@ GC_IGNORE_FB[=<n>] - (Win32 only.) Try to avoid treating a mapped
are never honored, eliminating this risk for most,
but not all, applications. This feature is likely to disappear
if/when we find a less disgusting "solution".
- IN VERSION 6.4 AND LATER, THIS SHOULD BE UNNECESSARY.
The following turn on runtime flags that are also program settable. Checked
only during initialization. We expect that they will usually be set through
@@ -149,3 +148,10 @@ GC_ALL_INTERIOR_POINTERS - Turns on GC_all_interior_pointers and thus interior
pointer recognition.
GC_DONT_GC - Turns off garbage collection. Use cautiously.
+
+GC_TRACE=addr - Intended for collector debugging. Requires that the collector
+ have been built with ENABLE_TRACE defined. Causes the debugger
+ to log information about the tracing of address ranges containing
+ addr. Typically addr is the address that contains a pointer to
+ an object that mysteriously failed to get marked. Addr must be
+ specified as a hexadecimal integer.
diff --git a/doc/README.solaris2 b/doc/README.solaris2
index 31e7500..6ed61dc 100644
--- a/doc/README.solaris2
+++ b/doc/README.solaris2
@@ -43,7 +43,9 @@ can result in unpleasant heap growth. But it seems better than the
race/deadlock issues we had before.
If solaris_threads are used on an X86 processor with malloc redirected to
-GC_malloc a deadlock is likely to result.
+GC_malloc, it is necessary to call GC_thr_init explicitly before forking the
+first thread. (This avoids a deadlock arising from calling GC_thr_init
+with the allocation lock held.)
It appears that there is a problem in using gc_cpp.h in conjunction with
Solaris threads and Sun's C++ runtime. Apparently the overloaded new operator
diff --git a/dyn_load.c b/dyn_load.c
index fdb6b30..a35928d 100644
--- a/dyn_load.c
+++ b/dyn_load.c
@@ -51,7 +51,7 @@
#if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(MSWINCE)) \
&& !defined(PCR)
-#if !defined(SUNOS4) && !defined(SUNOS5DL) && !defined(IRIX5) && \
+#if !defined(SUNOS5DL) && !defined(IRIX5) && \
!defined(MSWIN32) && !defined(MSWINCE) && \
!(defined(ALPHA) && defined(OSF1)) && \
!defined(HPUX) && !(defined(LINUX) && defined(__ELF__)) && \
@@ -70,15 +70,6 @@
# include <dlfcn.h>
# include <link.h>
#endif
-#ifdef SUNOS4
-# include <dlfcn.h>
-# include <link.h>
-# include <a.out.h>
- /* struct link_map field overrides */
-# define l_next lm_next
-# define l_addr lm_addr
-# define l_name lm_name
-#endif
#if defined(NETBSD)
# include <machine/elf_machdep.h>
@@ -96,25 +87,17 @@
/* Newer versions of GNU/Linux define this macro. We
* define it similarly for any ELF systems that don't. */
# ifndef ElfW
-# if defined(FREEBSD)
-# if __ELF_WORD_SIZE == 32
+# ifdef NETBSD
+# if ELFSIZE == 32
# define ElfW(type) Elf32_##type
# else
# define ElfW(type) Elf64_##type
# endif
# else
-# ifdef NETBSD
-# if ELFSIZE == 32
-# define ElfW(type) Elf32_##type
-# else
-# define ElfW(type) Elf64_##type
-# endif
+# if !defined(ELF_CLASS) || ELF_CLASS == ELFCLASS32
+# define ElfW(type) Elf32_##type
# else
-# if !defined(ELF_CLASS) || ELF_CLASS == ELFCLASS32
-# define ElfW(type) Elf32_##type
-# else
-# define ElfW(type) Elf64_##type
-# endif
+# define ElfW(type) Elf64_##type
# endif
# endif
# endif
@@ -172,47 +155,7 @@ GC_FirstDLOpenedLinkMap()
# define dlopen GC_dlopen
# endif
-#if defined(SUNOS4) && !defined(USE_PROC_FOR_LIBRARIES)
-
-#ifdef LINT
- struct link_dynamic _DYNAMIC;
-#endif
-
-static struct link_map *
-GC_FirstDLOpenedLinkMap()
-{
- extern struct link_dynamic _DYNAMIC;
-
- if( &_DYNAMIC == 0) {
- return(0);
- }
- return(_DYNAMIC.ld_un.ld_1->ld_loaded);
-}
-
-/* Return the address of the ld.so allocated common symbol */
-/* with the least address, or 0 if none. */
-static ptr_t GC_first_common()
-{
- ptr_t result = 0;
- extern struct link_dynamic _DYNAMIC;
- struct rtc_symb * curr_symbol;
-
- if( &_DYNAMIC == 0) {
- return(0);
- }
- curr_symbol = _DYNAMIC.ldd -> ldd_cp;
- for (; curr_symbol != 0; curr_symbol = curr_symbol -> rtc_next) {
- if (result == 0
- || (ptr_t)(curr_symbol -> rtc_sp -> n_value) < result) {
- result = (ptr_t)(curr_symbol -> rtc_sp -> n_value);
- }
- }
- return(result);
-}
-
-#endif /* SUNOS4 ... */
-
-# if defined(SUNOS4) || defined(SUNOS5DL)
+# if defined(SUNOS5DL)
/* Add dynamic library data sections to the root set. */
# if !defined(PCR) && !defined(GC_SOLARIS_THREADS) && defined(THREADS)
# ifndef SRC_M3
@@ -229,15 +172,6 @@ void GC_register_dynamic_libraries()
for (lm = GC_FirstDLOpenedLinkMap();
lm != (struct link_map *) 0; lm = lm->l_next)
{
-# ifdef SUNOS4
- struct exec *e;
-
- e = (struct exec *) lm->lm_addr;
- GC_add_roots_inner(
- ((char *) (N_DATOFF(*e) + lm->lm_addr)),
- ((char *) (N_BSSADDR(*e) + e->a_bss + lm->lm_addr)),
- TRUE);
-# endif
# ifdef SUNOS5DL
ElfW(Ehdr) * e;
ElfW(Phdr) * p;
@@ -267,19 +201,6 @@ void GC_register_dynamic_libraries()
}
# endif
}
-# ifdef SUNOS4
- {
- static ptr_t common_start = 0;
- ptr_t common_end;
- extern ptr_t GC_find_limit();
-
- if (common_start == 0) common_start = GC_first_common();
- if (common_start != 0) {
- common_end = GC_find_limit(common_start, TRUE);
- GC_add_roots_inner((char *)common_start, (char *)common_end, TRUE);
- }
- }
-# endif
}
# endif /* !USE_PROC ... */
@@ -501,12 +422,6 @@ GC_FirstDLOpenedLinkMap()
if( cachedResult == 0 ) {
int tag;
for( dp = _DYNAMIC; (tag = dp->d_tag) != 0; dp++ ) {
- /* FIXME: The DT_DEBUG header is not mandated by the */
- /* ELF spec. This code appears to be dependent on */
- /* idiosynchracies of older GNU tool chains. If this code */
- /* fails for you, the real problem is probably that it is */
- /* being used at all. You should be getting the */
- /* dl_iterate_phdr version. */
if( tag == DT_DEBUG ) {
struct link_map *lm
= ((struct r_debug *)(dp->d_un.d_ptr))->r_map;
@@ -610,7 +525,7 @@ void GC_register_dynamic_libraries()
}
}
if (ioctl(fd, PIOCNMAP, &needed_sz) < 0) {
- GC_err_printf2("fd = %d, errno = %d\n", fd, errno);
+ GC_err_printf("fd = %d, errno = %d\n", fd, errno);
ABORT("/proc PIOCNMAP ioctl failed");
}
if (needed_sz >= current_sz) {
@@ -620,7 +535,7 @@ void GC_register_dynamic_libraries()
(current_sz * sizeof(prmap_t)));
}
if (ioctl(fd, PIOCMAP, addr_map) < 0) {
- GC_err_printf4("fd = %d, errno = %d, needed_sz = %d, addr_map = 0x%X\n",
+ GC_err_printf("fd = %d, errno = %d, needed_sz = %d, addr_map = 0x%X\n",
fd, errno, needed_sz, addr_map);
ABORT("/proc PIOCMAP ioctl failed");
};
@@ -753,10 +668,6 @@ void GC_register_dynamic_libraries()
# define HAVE_REGISTER_MAIN_STATIC_DATA
- /* The frame buffer testing code is dead in this version. */
- /* We leave it here temporarily in case the switch to just */
- /* testing for MEM_IMAGE sections causes un expected */
- /* problems. */
GC_bool GC_warn_fb = TRUE; /* Warn about traced likely */
/* graphics memory. */
GC_bool GC_disallow_ignore_fb = FALSE;
@@ -771,27 +682,25 @@ void GC_register_dynamic_libraries()
/* Should [start, start+len) be treated as a frame buffer */
/* and ignored? */
- /* Unfortunately, we currently are not quite sure how to tell */
- /* this automatically, and rely largely on user input. */
- /* We expect that any mapping with type MEM_MAPPED (which */
- /* apparently excludes library data sections) can be safely */
- /* ignored. But we're too chicken to do that in this */
- /* version. */
+ /* Unfortunately, we currently have no real way to tell */
+ /* automatically, and rely largely on user input. */
+ /* FIXME: If we had more data on this phenomenon (e.g. */
+ /* is start aligned to a MB multiple?) we should be able to */
+ /* do better. */
/* Based on a very limited sample, it appears that: */
- /* - Frame buffer mappings appear as mappings of large */
- /* length, usually a bit less than a power of two. */
- /* - The definition of "a bit less" in the above cannot */
- /* be made more precise. */
- /* - Have a starting address at best 64K aligned. */
- /* - Have type == MEM_MAPPED. */
- static GC_bool is_frame_buffer(ptr_t start, size_t len, DWORD tp)
+ /* - Frame buffer mappings appear as mappings of length */
+ /* 2**n MB - 192K. (We guess the 192K can vary a bit.) */
+ /* - Have a stating address at best 64K aligned. */
+ /* I'd love more information about the mapping, since I */
+ /* can't reproduce the problem. */
+ static GC_bool is_frame_buffer(ptr_t start, size_t len)
{
static GC_bool initialized = FALSE;
# define MB (1024*1024)
# define DEFAULT_FB_MB 15
# define MIN_FB_MB 3
- if (GC_disallow_ignore_fb || tp != MEM_MAPPED) return FALSE;
+ if (GC_disallow_ignore_fb) return FALSE;
if (!initialized) {
char * ignore_fb_string = GETENV("GC_IGNORE_FB");
@@ -833,10 +742,10 @@ void GC_register_dynamic_libraries()
# ifdef DEBUG_VIRTUALQUERY
void GC_dump_meminfo(MEMORY_BASIC_INFORMATION *buf)
{
- GC_printf4("BaseAddress = %lx, AllocationBase = %lx, RegionSize = %lx(%lu)\n",
+ GC_printf("BaseAddress = %lx, AllocationBase = %lx, RegionSize = %lx(%lu)\n",
buf -> BaseAddress, buf -> AllocationBase, buf -> RegionSize,
buf -> RegionSize);
- GC_printf4("\tAllocationProtect = %lx, State = %lx, Protect = %lx, "
+ GC_printf("\tAllocationProtect = %lx, State = %lx, Protect = %lx, "
"Type = %lx\n",
buf -> AllocationProtect, buf -> State, buf -> Protect,
buf -> Type);
@@ -880,11 +789,7 @@ void GC_register_dynamic_libraries()
&& (protect == PAGE_EXECUTE_READWRITE
|| protect == PAGE_READWRITE)
&& !GC_is_heap_base(buf.AllocationBase)
- /* This used to check for
- * !is_frame_buffer(p, buf.RegionSize, buf.Type)
- * instead of just checking for MEM_IMAGE.
- * If something breaks, change it back. */
- && buf.Type == MEM_IMAGE) {
+ && !is_frame_buffer(p, buf.RegionSize)) {
# ifdef DEBUG_VIRTUALQUERY
GC_dump_meminfo(&buf);
# endif
@@ -940,15 +845,15 @@ void GC_register_dynamic_libraries()
/* Check status AFTER checking moduleid because */
/* of a bug in the non-shared ldr_next_module stub */
if (status != 0 ) {
- GC_printf1("dynamic_load: status = %ld\n", (long)status);
+ GC_printf("dynamic_load: status = %d\n", status);
{
extern char *sys_errlist[];
extern int sys_nerr;
extern int errno;
if (errno <= sys_nerr) {
- GC_printf1("dynamic_load: %s\n", (long)sys_errlist[errno]);
+ GC_printf("dynamic_load: %s\n", sys_errlist[errno]);
} else {
- GC_printf1("dynamic_load: %d\n", (long)errno);
+ GC_printf("dynamic_load: %d\n", errno);
}
}
ABORT("ldr_next_module failed");
@@ -1039,9 +944,9 @@ void GC_register_dynamic_libraries()
break; /* Moved past end of shared library list --> finished */
} else {
if (errno <= sys_nerr) {
- GC_printf1("dynamic_load: %s\n", (long) sys_errlist[errno]);
+ GC_printf("dynamic_load: %s\n", sys_errlist[errno]);
} else {
- GC_printf1("dynamic_load: %d\n", (long) errno);
+ GC_printf("dynamic_load: %d\n", errno);
}
ABORT("shl_get failed");
}
@@ -1049,16 +954,16 @@ void GC_register_dynamic_libraries()
}
# ifdef VERBOSE
- GC_printf0("---Shared library---\n");
- GC_printf1("\tfilename = \"%s\"\n", shl_desc->filename);
- GC_printf1("\tindex = %d\n", index);
- GC_printf1("\thandle = %08x\n",
+ GC_printf("---Shared library---\n");
+ GC_printf("\tfilename = \"%s\"\n", shl_desc->filename);
+ GC_printf("\tindex = %d\n", index);
+ GC_printf("\thandle = %08x\n",
(unsigned long) shl_desc->handle);
- GC_printf1("\ttext seg. start = %08x\n", shl_desc->tstart);
- GC_printf1("\ttext seg. end = %08x\n", shl_desc->tend);
- GC_printf1("\tdata seg. start = %08x\n", shl_desc->dstart);
- GC_printf1("\tdata seg. end = %08x\n", shl_desc->dend);
- GC_printf1("\tref. count = %lu\n", shl_desc->ref_count);
+ GC_printf("\ttext seg. start = %08x\n", shl_desc->tstart);
+ GC_printf("\ttext seg. end = %08x\n", shl_desc->tend);
+ GC_printf("\tdata seg. start = %08x\n", shl_desc->dstart);
+ GC_printf("\tdata seg. end = %08x\n", shl_desc->dend);
+ GC_printf("\tref. count = %lu\n", shl_desc->ref_count);
# endif
/* register shared library's data segment as a garbage collection root */
@@ -1143,18 +1048,18 @@ static void GC_dyld_image_add(struct mach_header* hdr, unsigned long slide) {
for(i=0;i<sizeof(GC_dyld_sections)/sizeof(GC_dyld_sections[0]);i++) {
sec = getsectbynamefromheader(
hdr,GC_dyld_sections[i].seg,GC_dyld_sections[i].sect);
- if(sec == NULL || sec->size == 0) continue;
- start = slide + sec->addr;
- end = start + sec->size;
-# ifdef DARWIN_DEBUG
- GC_printf4("Adding section at %p-%p (%lu bytes) from image %s\n",
- start,end,sec->size,GC_dyld_name_for_hdr(hdr));
-# endif
- GC_add_roots((char*)start,(char*)end);
- }
+ if(sec == NULL || sec->size == 0) continue;
+ start = slide + sec->addr;
+ end = start + sec->size;
# ifdef DARWIN_DEBUG
- GC_print_static_roots();
+ GC_printf("Adding section at %p-%p (%lu bytes) from image %s\n",
+ start,end,sec->size,GC_dyld_name_for_hdr(hdr));
# endif
+ GC_add_roots((char*)start,(char*)end);
+ }
+# ifdef DARWIN_DEBUG
+ GC_print_static_roots();
+# endif
}
/* This should never be called by a thread holding the lock */
@@ -1167,15 +1072,15 @@ static void GC_dyld_image_remove(struct mach_header* hdr, unsigned long slide) {
if(sec == NULL || sec->size == 0) continue;
start = slide + sec->addr;
end = start + sec->size;
-# ifdef DARWIN_DEBUG
- GC_printf4("Removing section at %p-%p (%lu bytes) from image %s\n",
- start,end,sec->size,GC_dyld_name_for_hdr(hdr));
-# endif
- GC_remove_roots((char*)start,(char*)end);
- }
# ifdef DARWIN_DEBUG
- GC_print_static_roots();
+ GC_printf("Removing section at %p-%p (%lu bytes) from image %s\n",
+ start,end,sec->size,GC_dyld_name_for_hdr(hdr));
# endif
+ GC_remove_roots((char*)start,(char*)end);
+ }
+# ifdef DARWIN_DEBUG
+ GC_print_static_roots();
+# endif
}
void GC_register_dynamic_libraries() {
@@ -1196,7 +1101,7 @@ void GC_init_dyld() {
if(initialized) return;
# ifdef DARWIN_DEBUG
- GC_printf0("Registering dyld callbacks...\n");
+ GC_printf("Registering dyld callbacks...\n");
# endif
/* Apple's Documentation:
@@ -1220,7 +1125,7 @@ void GC_init_dyld() {
if (bind_fully_env == NULL) {
# ifdef DARWIN_DEBUG
- GC_printf0("Forcing full bind of GC code...\n");
+ GC_printf("Forcing full bind of GC code...\n");
# endif
if(!_dyld_bind_fully_image_containing_address((unsigned long*)GC_malloc))
diff --git a/finalize.c b/finalize.c
index 893f825..e31b0de 100644
--- a/finalize.c
+++ b/finalize.c
@@ -85,7 +85,7 @@ static signed_word log_fo_table_size = -1;
word GC_fo_entries = 0;
-void GC_push_finalizer_structures GC_PROTO((void))
+void GC_push_finalizer_structures(void)
{
GC_push_all((ptr_t)(&dl_head), (ptr_t)(&dl_head) + sizeof(word));
GC_push_all((ptr_t)(&fo_head), (ptr_t)(&fo_head) + sizeof(word));
@@ -98,9 +98,8 @@ void GC_push_finalizer_structures GC_PROTO((void))
/* *table is a pointer to an array of hash headers. If we succeed, we */
/* update both *table and *log_size_ptr. */
/* Lock is held. Signals are disabled. */
-void GC_grow_table(table, log_size_ptr)
-struct hash_chain_entry ***table;
-signed_word * log_size_ptr;
+void GC_grow_table(struct hash_chain_entry ***table,
+ signed_word *log_size_ptr)
{
register word i;
register struct hash_chain_entry *p;
@@ -108,6 +107,7 @@ signed_word * log_size_ptr;
register int log_new_size = log_old_size + 1;
word old_size = ((log_old_size == -1)? 0: (1 << log_old_size));
register word new_size = 1 << log_new_size;
+ /* FIXME: Power of 2 size often gets rounded up to one more page. */
struct hash_chain_entry **new_table = (struct hash_chain_entry **)
GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE(
(size_t)new_size * sizeof(struct hash_chain_entry *), NORMAL);
@@ -135,30 +135,17 @@ signed_word * log_size_ptr;
*table = new_table;
}
-# if defined(__STDC__) || defined(__cplusplus)
- int GC_register_disappearing_link(GC_PTR * link)
-# else
- int GC_register_disappearing_link(link)
- GC_PTR * link;
-# endif
+int GC_register_disappearing_link(void * * link)
{
ptr_t base;
- base = (ptr_t)GC_base((GC_PTR)link);
+ base = (ptr_t)GC_base((void *)link);
if (base == 0)
ABORT("Bad arg to GC_register_disappearing_link");
return(GC_general_register_disappearing_link(link, base));
}
-# if defined(__STDC__) || defined(__cplusplus)
- int GC_general_register_disappearing_link(GC_PTR * link,
- GC_PTR obj)
-# else
- int GC_general_register_disappearing_link(link, obj)
- GC_PTR * link;
- GC_PTR obj;
-# endif
-
+int GC_general_register_disappearing_link(void * * link, void * obj)
{
struct disappearing_link *curr_dl;
int index;
@@ -168,25 +155,16 @@ signed_word * log_size_ptr;
if ((word)link & (ALIGNMENT-1))
ABORT("Bad arg to GC_general_register_disappearing_link");
# ifdef THREADS
- DISABLE_SIGNALS();
LOCK();
# endif
if (log_dl_table_size == -1
|| GC_dl_entries > ((word)1 << log_dl_table_size)) {
-# ifndef THREADS
- DISABLE_SIGNALS();
-# endif
GC_grow_table((struct hash_chain_entry ***)(&dl_head),
&log_dl_table_size);
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf1("Grew dl table to %lu entries\n",
- (unsigned long)(1 << log_dl_table_size));
- }
-# endif
-# ifndef THREADS
- ENABLE_SIGNALS();
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("Grew dl table to %u entries\n",
+ (1 << log_dl_table_size));
+ }
}
index = HASH2(link, log_dl_table_size);
curr_dl = dl_head[index];
@@ -195,7 +173,6 @@ signed_word * log_size_ptr;
curr_dl -> dl_hidden_obj = HIDE_POINTER(obj);
# ifdef THREADS
UNLOCK();
- ENABLE_SIGNALS();
# endif
return(1);
}
@@ -205,7 +182,6 @@ signed_word * log_size_ptr;
if (0 == new_dl) {
# ifdef THREADS
UNLOCK();
- ENABLE_SIGNALS();
# endif
new_dl = (struct disappearing_link *)
GC_oom_fn(sizeof(struct disappearing_link));
@@ -215,7 +191,6 @@ signed_word * log_size_ptr;
}
/* It's not likely we'll make it here, but ... */
# ifdef THREADS
- DISABLE_SIGNALS();
LOCK();
# endif
}
@@ -226,23 +201,16 @@ signed_word * log_size_ptr;
GC_dl_entries++;
# ifdef THREADS
UNLOCK();
- ENABLE_SIGNALS();
# endif
return(0);
}
-# if defined(__STDC__) || defined(__cplusplus)
- int GC_unregister_disappearing_link(GC_PTR * link)
-# else
- int GC_unregister_disappearing_link(link)
- GC_PTR * link;
-# endif
+int GC_unregister_disappearing_link(void * * link)
{
struct disappearing_link *curr_dl, *prev_dl;
int index;
DCL_LOCK_STATE;
- DISABLE_SIGNALS();
LOCK();
index = HASH2(link, log_dl_table_size);
if (((unsigned long)link & (ALIGNMENT-1))) goto out;
@@ -256,11 +224,10 @@ signed_word * log_size_ptr;
}
GC_dl_entries--;
UNLOCK();
- ENABLE_SIGNALS();
# ifdef DBG_HDRS_ALL
dl_set_next(curr_dl, 0);
# else
- GC_free((GC_PTR)curr_dl);
+ GC_free((void *)curr_dl);
# endif
return(1);
}
@@ -269,32 +236,29 @@ signed_word * log_size_ptr;
}
out:
UNLOCK();
- ENABLE_SIGNALS();
return(0);
}
/* Possible finalization_marker procedures. Note that mark stack */
/* overflow is handled by the caller, and is not a disaster. */
-GC_API void GC_normal_finalize_mark_proc(p)
-ptr_t p;
+GC_API void GC_normal_finalize_mark_proc(ptr_t p)
{
hdr * hhdr = HDR(p);
- PUSH_OBJ((word *)p, hhdr, GC_mark_stack_top,
+ PUSH_OBJ(p, hhdr, GC_mark_stack_top,
&(GC_mark_stack[GC_mark_stack_size]));
}
/* This only pays very partial attention to the mark descriptor. */
/* It does the right thing for normal and atomic objects, and treats */
/* most others as normal. */
-GC_API void GC_ignore_self_finalize_mark_proc(p)
-ptr_t p;
+GC_API void GC_ignore_self_finalize_mark_proc(ptr_t p)
{
hdr * hhdr = HDR(p);
word descr = hhdr -> hb_descr;
ptr_t q, r;
ptr_t scan_limit;
- ptr_t target_limit = p + WORDS_TO_BYTES(hhdr -> hb_sz) - 1;
+ ptr_t target_limit = p + hhdr -> hb_sz - 1;
if ((descr & GC_DS_TAGS) == GC_DS_LENGTH) {
scan_limit = p + descr - sizeof(word);
@@ -304,14 +268,13 @@ ptr_t p;
for (q = p; q <= scan_limit; q += ALIGNMENT) {
r = *(ptr_t *)q;
if (r < p || r > target_limit) {
- GC_PUSH_ONE_HEAP((word)r, q);
+ GC_PUSH_ONE_HEAP(r, q);
}
}
}
/*ARGSUSED*/
-GC_API void GC_null_finalize_mark_proc(p)
-ptr_t p;
+GC_API void GC_null_finalize_mark_proc(ptr_t p)
{
}
@@ -325,13 +288,10 @@ ptr_t p;
/* marking for finalization ordering. Any objects marked */
/* by that procedure will be guaranteed to not have been */
/* finalized when this finalizer is invoked. */
-GC_API void GC_register_finalizer_inner(obj, fn, cd, ofn, ocd, mp)
-GC_PTR obj;
-GC_finalization_proc fn;
-GC_PTR cd;
-GC_finalization_proc * ofn;
-GC_PTR * ocd;
-finalization_mark_proc * mp;
+GC_API void GC_register_finalizer_inner(void * obj,
+ GC_finalization_proc fn, void *cd,
+ GC_finalization_proc *ofn, void **ocd,
+ finalization_mark_proc mp)
{
ptr_t base;
struct finalizable_object * curr_fo, * prev_fo;
@@ -341,25 +301,16 @@ finalization_mark_proc * mp;
DCL_LOCK_STATE;
# ifdef THREADS
- DISABLE_SIGNALS();
LOCK();
# endif
if (log_fo_table_size == -1
|| GC_fo_entries > ((word)1 << log_fo_table_size)) {
-# ifndef THREADS
- DISABLE_SIGNALS();
-# endif
GC_grow_table((struct hash_chain_entry ***)(&fo_head),
&log_fo_table_size);
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf1("Grew fo table to %lu entries\n",
- (unsigned long)(1 << log_fo_table_size));
- }
-# endif
-# ifndef THREADS
- ENABLE_SIGNALS();
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("Grew fo table to %u entries\n",
+ (1 << log_fo_table_size));
+ }
}
/* in the THREADS case signals are disabled and we hold allocation */
/* lock; otherwise neither is true. Proceed carefully. */
@@ -367,12 +318,13 @@ finalization_mark_proc * mp;
index = HASH2(base, log_fo_table_size);
prev_fo = 0; curr_fo = fo_head[index];
while (curr_fo != 0) {
+ GC_ASSERT(GC_size(curr_fo) >= sizeof(struct finalizable_object));
if (curr_fo -> fo_hidden_base == HIDE_POINTER(base)) {
/* Interruption by a signal in the middle of this */
/* should be safe. The client may see only *ocd */
/* updated, but we'll declare that to be his */
/* problem. */
- if (ocd) *ocd = (GC_PTR) curr_fo -> fo_client_data;
+ if (ocd) *ocd = (void *) (curr_fo -> fo_client_data);
if (ofn) *ofn = curr_fo -> fo_fn;
/* Delete the structure for base. */
if (prev_fo == 0) {
@@ -386,7 +338,7 @@ finalization_mark_proc * mp;
/* estimate will only make the table larger than */
/* necessary. */
# if !defined(THREADS) && !defined(DBG_HDRS_ALL)
- GC_free((GC_PTR)curr_fo);
+ GC_free((void *)curr_fo);
# endif
} else {
curr_fo -> fo_fn = fn;
@@ -402,7 +354,6 @@ finalization_mark_proc * mp;
}
# ifdef THREADS
UNLOCK();
- ENABLE_SIGNALS();
# endif
return;
}
@@ -414,7 +365,6 @@ finalization_mark_proc * mp;
if (fn == 0) {
# ifdef THREADS
UNLOCK();
- ENABLE_SIGNALS();
# endif
return;
}
@@ -423,16 +373,15 @@ finalization_mark_proc * mp;
/* We won't collect it, hence finalizer wouldn't be run. */
# ifdef THREADS
UNLOCK();
- ENABLE_SIGNALS();
# endif
return;
}
new_fo = (struct finalizable_object *)
GC_INTERNAL_MALLOC(sizeof(struct finalizable_object),NORMAL);
- if (0 == new_fo) {
+ GC_ASSERT(GC_size(new_fo) >= sizeof(struct finalizable_object));
+ if (EXPECT(0 == new_fo, FALSE)) {
# ifdef THREADS
UNLOCK();
- ENABLE_SIGNALS();
# endif
new_fo = (struct finalizable_object *)
GC_oom_fn(sizeof(struct finalizable_object));
@@ -442,7 +391,6 @@ finalization_mark_proc * mp;
}
/* It's not likely we'll make it here, but ... */
# ifdef THREADS
- DISABLE_SIGNALS();
LOCK();
# endif
}
@@ -456,63 +404,35 @@ finalization_mark_proc * mp;
fo_head[index] = new_fo;
# ifdef THREADS
UNLOCK();
- ENABLE_SIGNALS();
# endif
}
-# if defined(__STDC__)
- void GC_register_finalizer(void * obj,
+void GC_register_finalizer(void * obj,
GC_finalization_proc fn, void * cd,
GC_finalization_proc *ofn, void ** ocd)
-# else
- void GC_register_finalizer(obj, fn, cd, ofn, ocd)
- GC_PTR obj;
- GC_finalization_proc fn;
- GC_PTR cd;
- GC_finalization_proc * ofn;
- GC_PTR * ocd;
-# endif
{
GC_register_finalizer_inner(obj, fn, cd, ofn,
ocd, GC_normal_finalize_mark_proc);
}
-# if defined(__STDC__)
- void GC_register_finalizer_ignore_self(void * obj,
+void GC_register_finalizer_ignore_self(void * obj,
GC_finalization_proc fn, void * cd,
GC_finalization_proc *ofn, void ** ocd)
-# else
- void GC_register_finalizer_ignore_self(obj, fn, cd, ofn, ocd)
- GC_PTR obj;
- GC_finalization_proc fn;
- GC_PTR cd;
- GC_finalization_proc * ofn;
- GC_PTR * ocd;
-# endif
{
GC_register_finalizer_inner(obj, fn, cd, ofn,
ocd, GC_ignore_self_finalize_mark_proc);
}
-# if defined(__STDC__)
- void GC_register_finalizer_no_order(void * obj,
+void GC_register_finalizer_no_order(void * obj,
GC_finalization_proc fn, void * cd,
GC_finalization_proc *ofn, void ** ocd)
-# else
- void GC_register_finalizer_no_order(obj, fn, cd, ofn, ocd)
- GC_PTR obj;
- GC_finalization_proc fn;
- GC_PTR cd;
- GC_finalization_proc * ofn;
- GC_PTR * ocd;
-# endif
{
GC_register_finalizer_inner(obj, fn, cd, ofn,
ocd, GC_null_finalize_mark_proc);
}
#ifndef NO_DEBUGGING
-void GC_dump_finalization()
+void GC_dump_finalization(void)
{
struct disappearing_link * curr_dl;
struct finalizable_object * curr_fo;
@@ -521,19 +441,19 @@ void GC_dump_finalization()
int fo_size = (log_fo_table_size == -1 ) ? 0 : (1 << log_fo_table_size);
int i;
- GC_printf0("Disappearing links:\n");
+ GC_printf("Disappearing links:\n");
for (i = 0; i < dl_size; i++) {
for (curr_dl = dl_head[i]; curr_dl != 0; curr_dl = dl_next(curr_dl)) {
real_ptr = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_obj);
real_link = (ptr_t)REVEAL_POINTER(curr_dl -> dl_hidden_link);
- GC_printf2("Object: 0x%lx, Link:0x%lx\n", real_ptr, real_link);
+ GC_printf("Object: %p, Link:%p\n", real_ptr, real_link);
}
}
- GC_printf0("Finalizers:\n");
+ GC_printf("Finalizers:\n");
for (i = 0; i < fo_size; i++) {
for (curr_fo = fo_head[i]; curr_fo != 0; curr_fo = fo_next(curr_fo)) {
real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
- GC_printf1("Finalizable object: 0x%lx\n", real_ptr);
+ GC_printf("Finalizable object: %p\n", real_ptr);
}
}
}
@@ -541,7 +461,7 @@ void GC_dump_finalization()
/* Called with world stopped. Cause disappearing links to disappear, */
/* and invoke finalizers. */
-void GC_finalize()
+void GC_finalize(void)
{
struct disappearing_link * curr_dl, * prev_dl, * next_dl;
struct finalizable_object * curr_fo, * prev_fo, * next_fo;
@@ -579,6 +499,7 @@ void GC_finalize()
GC_ASSERT(GC_mark_state == MS_NONE);
for (i = 0; i < fo_size; i++) {
for (curr_fo = fo_head[i]; curr_fo != 0; curr_fo = fo_next(curr_fo)) {
+ GC_ASSERT(GC_size(curr_fo) >= sizeof(struct finalizable_object));
real_ptr = (ptr_t)REVEAL_POINTER(curr_fo -> fo_hidden_base);
if (!GC_is_marked(real_ptr)) {
GC_MARKED_FOR_FINALIZATION(real_ptr);
@@ -591,7 +512,7 @@ void GC_finalize()
}
/* Enqueue for finalization all objects that are still */
/* unreachable. */
- GC_words_finalized = 0;
+ GC_bytes_finalized = 0;
for (i = 0; i < fo_size; i++) {
curr_fo = fo_head[i];
prev_fo = 0;
@@ -616,9 +537,9 @@ void GC_finalize()
/* see it. */
curr_fo -> fo_hidden_base =
(word) REVEAL_POINTER(curr_fo -> fo_hidden_base);
- GC_words_finalized +=
- ALIGNED_WORDS(curr_fo -> fo_object_size)
- + ALIGNED_WORDS(sizeof(struct finalizable_object));
+ GC_bytes_finalized +=
+ curr_fo -> fo_object_size
+ + sizeof(struct finalizable_object);
GC_ASSERT(GC_is_marked(GC_base((ptr_t)curr_fo)));
curr_fo = next_fo;
} else {
@@ -671,7 +592,7 @@ void GC_finalize()
/* Enqueue all remaining finalizers to be run - Assumes lock is
* held, and signals are disabled */
-void GC_enqueue_all_finalizers()
+void GC_enqueue_all_finalizers(void)
{
struct finalizable_object * curr_fo, * prev_fo, * next_fo;
ptr_t real_ptr;
@@ -679,7 +600,7 @@ void GC_enqueue_all_finalizers()
int fo_size;
fo_size = (log_fo_table_size == -1 ) ? 0 : (1 << log_fo_table_size);
- GC_words_finalized = 0;
+ GC_bytes_finalized = 0;
for (i = 0; i < fo_size; i++) {
curr_fo = fo_head[i];
prev_fo = 0;
@@ -706,9 +627,8 @@ void GC_enqueue_all_finalizers()
curr_fo -> fo_hidden_base =
(word) REVEAL_POINTER(curr_fo -> fo_hidden_base);
- GC_words_finalized +=
- ALIGNED_WORDS(curr_fo -> fo_object_size)
- + ALIGNED_WORDS(sizeof(struct finalizable_object));
+ GC_bytes_finalized +=
+ curr_fo -> fo_object_size + sizeof(struct finalizable_object);
curr_fo = next_fo;
}
}
@@ -730,55 +650,49 @@ void GC_enqueue_all_finalizers()
* This routine is externally callable, so is called without
* the allocation lock.
*/
-GC_API void GC_finalize_all()
+GC_API void GC_finalize_all(void)
{
DCL_LOCK_STATE;
- DISABLE_SIGNALS();
LOCK();
while (GC_fo_entries > 0) {
GC_enqueue_all_finalizers();
UNLOCK();
- ENABLE_SIGNALS();
GC_INVOKE_FINALIZERS();
- DISABLE_SIGNALS();
LOCK();
}
UNLOCK();
- ENABLE_SIGNALS();
}
#endif
/* Returns true if it is worth calling GC_invoke_finalizers. (Useful if */
/* finalizers can only be called from some kind of `safe state' and */
/* getting into that safe state is expensive.) */
-int GC_should_invoke_finalizers GC_PROTO((void))
+int GC_should_invoke_finalizers(void)
{
return GC_finalize_now != 0;
}
/* Invoke finalizers for all objects that are ready to be finalized. */
/* Should be called without allocation lock. */
-int GC_invoke_finalizers()
+int GC_invoke_finalizers(void)
{
struct finalizable_object * curr_fo;
int count = 0;
- word mem_freed_before;
+ word bytes_freed_before;
DCL_LOCK_STATE;
while (GC_finalize_now != 0) {
# ifdef THREADS
- DISABLE_SIGNALS();
LOCK();
# endif
if (count == 0) {
- mem_freed_before = GC_mem_freed;
+ bytes_freed_before = GC_bytes_freed;
}
curr_fo = GC_finalize_now;
# ifdef THREADS
if (curr_fo != 0) GC_finalize_now = fo_next(curr_fo);
UNLOCK();
- ENABLE_SIGNALS();
if (curr_fo == 0) break;
# else
GC_finalize_now = fo_next(curr_fo);
@@ -792,22 +706,22 @@ int GC_invoke_finalizers()
/* This is probably a bad idea. It throws off accounting if */
/* nearly all objects are finalizable. O.w. it shouldn't */
/* matter. */
- GC_free((GC_PTR)curr_fo);
+ GC_free((void *)curr_fo);
# endif
}
- if (count != 0 && mem_freed_before != GC_mem_freed) {
+ if (count != 0 && bytes_freed_before != GC_bytes_freed) {
LOCK();
- GC_finalizer_mem_freed += (GC_mem_freed - mem_freed_before);
+ GC_finalizer_bytes_freed += (GC_bytes_freed - bytes_freed_before);
UNLOCK();
}
return count;
}
-void (* GC_finalizer_notifier)() = (void (*) GC_PROTO((void)))0;
+void (* GC_finalizer_notifier)() = (void (*) (void))0;
static GC_word last_finalizer_notification = 0;
-void GC_notify_or_invoke_finalizers GC_PROTO((void))
+void GC_notify_or_invoke_finalizers(void)
{
/* This is a convenient place to generate backtraces if appropriate, */
/* since that code is not callable with the allocation lock. */
@@ -816,10 +730,10 @@ void GC_notify_or_invoke_finalizers GC_PROTO((void))
if (GC_gc_no > last_back_trace_gc_no) {
word i;
-
+
# ifdef KEEP_BACK_PTRS
LOCK();
- /* Stops when GC_gc_no wraps; that's OK. */
+ /* Stops when GC_gc_no wraps; that's OK. */
last_back_trace_gc_no = (word)(-1); /* disable others. */
for (i = 0; i < GC_backtraces; ++i) {
/* FIXME: This tolerates concurrent heap mutation, */
@@ -847,28 +761,21 @@ void GC_notify_or_invoke_finalizers GC_PROTO((void))
# endif /* Otherwise GC can run concurrently and add more */
return;
}
- if (GC_finalizer_notifier != (void (*) GC_PROTO((void)))0
+ if (GC_finalizer_notifier != (void (*) (void))0
&& last_finalizer_notification != GC_gc_no) {
last_finalizer_notification = GC_gc_no;
GC_finalizer_notifier();
}
}
-# ifdef __STDC__
- GC_PTR GC_call_with_alloc_lock(GC_fn_type fn,
- GC_PTR client_data)
-# else
- GC_PTR GC_call_with_alloc_lock(fn, client_data)
- GC_fn_type fn;
- GC_PTR client_data;
-# endif
+void * GC_call_with_alloc_lock(GC_fn_type fn, void * client_data)
{
- GC_PTR result;
+ void * result;
DCL_LOCK_STATE;
# ifdef THREADS
- DISABLE_SIGNALS();
LOCK();
+ /* FIXME - This looks wrong!! */
SET_LOCK_HOLDER();
# endif
result = (*fn)(client_data);
@@ -877,22 +784,21 @@ void GC_notify_or_invoke_finalizers GC_PROTO((void))
UNSET_LOCK_HOLDER();
# endif /* o.w. UNLOCK() does it implicitly */
UNLOCK();
- ENABLE_SIGNALS();
# endif
return(result);
}
#if !defined(NO_DEBUGGING)
-void GC_print_finalization_stats()
+void GC_print_finalization_stats(void)
{
struct finalizable_object *fo = GC_finalize_now;
size_t ready = 0;
- GC_printf2("%lu finalization table entries; %lu disappearing links\n",
+ GC_printf("%u finalization table entries; %u disappearing links\n",
GC_fo_entries, GC_dl_entries);
for (; 0 != fo; fo = fo_next(fo)) ++ready;
- GC_printf1("%lu objects are eligible for immediate finalization\n", ready);
+ GC_printf("%u objects are eligible for immediate finalization\n", ready);
}
#endif /* NO_DEBUGGING */
diff --git a/gc.mak b/gc.mak
index 5f0b546..73cad89 100644
--- a/gc.mak
+++ b/gc.mak
@@ -114,8 +114,8 @@ CLEAN :
CPP=cl.exe
# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /YX /c
-# ADD CPP /nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "SILENT" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "GC_WIN32_THREADS" /FR /YX /c
-CPP_PROJ=/nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "SILENT" /D "GC_BUILD" /D\
+# ADD CPP /nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "GC_WIN32_THREADS" /FR /YX /c
+CPP_PROJ=/nologo /MD /W3 /GX /O2 /I include /D "NDEBUG" /D "GC_BUILD" /D\
"WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D\
"GC_WIN32_THREADS" /FR"$(INTDIR)/" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/" /c
CPP_OBJS=.\Release/
@@ -296,8 +296,8 @@ CLEAN :
CPP=cl.exe
# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /Zi /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /YX /c
-# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG" /D "SILENT" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "GC_WIN32_THREADS" /FR /YX /c
-CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG" /D "SILENT" /D "GC_BUILD"\
+# ADD CPP /nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG" /D "GC_BUILD" /D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D "GC_WIN32_THREADS" /FR /YX /c
+CPP_PROJ=/nologo /MDd /W3 /Gm /GX /Zi /Od /I include /D "_DEBUG" /D "GC_BUILD"\
/D "WIN32" /D "_WINDOWS" /D "ALL_INTERIOR_POINTERS" /D "__STDC__" /D\
"GC_WIN32_THREADS" /FR"$(INTDIR)/" /Fp"$(INTDIR)/gc.pch" /YX /Fo"$(INTDIR)/"\
/Fd"$(INTDIR)/" /c
diff --git a/gc_dlopen.c b/gc_dlopen.c
index 4c690ed..79aaeb4 100644
--- a/gc_dlopen.c
+++ b/gc_dlopen.c
@@ -65,9 +65,7 @@
#ifdef GC_USE_LD_WRAP
void * __wrap_dlopen(const char *path, int mode)
#else
- void * GC_dlopen(path, mode)
- GC_CONST char * path;
- int mode;
+ void * GC_dlopen(const char *path, int mode)
#endif
{
void * result;
diff --git a/gcc_support.c b/gcc_support.c
deleted file mode 100644
index e8a7b82..0000000
--- a/gcc_support.c
+++ /dev/null
@@ -1,516 +0,0 @@
-/***************************************************************************
-
-Interface between g++ and Boehm GC
-
- Copyright (c) 1991-1995 by Xerox Corporation. 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 copy this code for any purpose,
- provided the above notices are retained on all copies.
-
- Last modified on Sun Jul 16 23:21:14 PDT 1995 by ellis
-
-This module provides runtime support for implementing the
-Ellis/Detlefs GC proposal, "Safe, Efficient Garbage Collection for
-C++", within g++, using its -fgc-keyword extension. It defines
-versions of __builtin_new, __builtin_new_gc, __builtin_vec_new,
-__builtin_vec_new_gc, __builtin_delete, and __builtin_vec_delete that
-invoke the Bohem GC. It also implements the WeakPointer.h interface.
-
-This module assumes the following configuration options of the Boehm GC:
-
- -DALL_INTERIOR_POINTERS
- -DDONT_ADD_BYTE_AT_END
-
-This module adds its own required padding to the end of objects to
-support C/C++ "one-past-the-object" pointer semantics.
-
-****************************************************************************/
-
-#include <stddef.h>
-#include "gc.h"
-
-#if defined(__STDC__)
-# define PROTO( args ) args
-#else
-# define PROTO( args ) ()
-# endif
-
-#define BITSPERBYTE 8
- /* What's the portable way to do this? */
-
-
-typedef void (*vfp) PROTO(( void ));
-extern vfp __new_handler;
-extern void __default_new_handler PROTO(( void ));
-
-
-/* A destructor_proc is the compiler generated procedure representing a
-C++ destructor. The "flag" argument is a hidden argument following some
-compiler convention. */
-
-typedef (*destructor_proc) PROTO(( void* this, int flag ));
-
-
-/***************************************************************************
-
-A BI_header is the header the compiler adds to the front of
-new-allocated arrays of objects with destructors. The header is
-padded out to a double, because that's what the compiler does to
-ensure proper alignment of array elements on some architectures.
-
-int NUM_ARRAY_ELEMENTS (void* o)
- returns the number of array elements for array object o.
-
-char* FIRST_ELEMENT_P (void* o)
- returns the address of the first element of array object o.
-
-***************************************************************************/
-
-typedef struct BI_header {
- int nelts;
- char padding [sizeof( double ) - sizeof( int )];
- /* Better way to do this? */
-} BI_header;
-
-#define NUM_ARRAY_ELEMENTS( o ) \
- (((BI_header*) o)->nelts)
-
-#define FIRST_ELEMENT_P( o ) \
- ((char*) o + sizeof( BI_header ))
-
-
-/***************************************************************************
-
-The __builtin_new routines add a descriptor word to the end of each
-object. The descriptor serves two purposes.
-
-First, the descriptor acts as padding, implementing C/C++ pointer
-semantics. C and C++ allow a valid array pointer to be incremented
-one past the end of an object. The extra padding ensures that the
-collector will recognize that such a pointer points to the object and
-not the next object in memory.
-
-Second, the descriptor stores three extra pieces of information,
-whether an object has a registered finalizer (destructor), whether it
-may have any weak pointers referencing it, and for collectible arrays,
-the element size of the array. The element size is required for the
-array's finalizer to iterate through the elements of the array. (An
-alternative design would have the compiler generate a finalizer
-procedure for each different array type. But given the overhead of
-finalization, there isn't any efficiency to be gained by that.)
-
-The descriptor must be added to non-collectible as well as collectible
-objects, since the Ellis/Detlefs proposal allows "pointer to gc T" to
-be assigned to a "pointer to T", which could then be deleted. Thus,
-__builtin_delete must determine at runtime whether an object is
-collectible, whether it has weak pointers referencing it, and whether
-it may have a finalizer that needs unregistering. Though
-GC_REGISTER_FINALIZER doesn't care if you ask it to unregister a
-finalizer for an object that doesn't have one, it is a non-trivial
-procedure that does a hash look-up, etc. The descriptor trades a
-little extra space for a significant increase in time on the fast path
-through delete. (A similar argument applies to
-GC_UNREGISTER_DISAPPEARING_LINK).
-
-For non-array types, the space for the descriptor could be shrunk to a
-single byte for storing the "has finalizer" flag. But this would save
-space only on arrays of char (whose size is not a multiple of the word
-size) and structs whose largest member is less than a word in size
-(very infrequent). And it would require that programmers actually
-remember to call "delete[]" instead of "delete" (which they should,
-but there are probably lots of buggy programs out there). For the
-moment, the space savings seems not worthwhile, especially considering
-that the Boehm GC is already quite space competitive with other
-malloc's.
-
-
-Given a pointer o to the base of an object:
-
-Descriptor* DESCRIPTOR (void* o)
- returns a pointer to the descriptor for o.
-
-The implementation of descriptors relies on the fact that the GC
-implementation allocates objects in units of the machine's natural
-word size (e.g. 32 bits on a SPARC, 64 bits on an Alpha).
-
-**************************************************************************/
-
-typedef struct Descriptor {
- unsigned has_weak_pointers: 1;
- unsigned has_finalizer: 1;
- unsigned element_size: BITSPERBYTE * sizeof( unsigned ) - 2;
-} Descriptor;
-
-#define DESCRIPTOR( o ) \
- ((Descriptor*) ((char*)(o) + GC_size( o ) - sizeof( Descriptor )))
-
-
-/**************************************************************************
-
-Implementations of global operator new() and operator delete()
-
-***************************************************************************/
-
-
-void* __builtin_new( size )
- size_t size;
- /*
- For non-gc non-array types, the compiler generates calls to
- __builtin_new, which allocates non-collected storage via
- GC_MALLOC_UNCOLLECTABLE. This ensures that the non-collected
- storage will be part of the collector's root set, required by the
- Ellis/Detlefs semantics. */
-{
- vfp handler = __new_handler ? __new_handler : __default_new_handler;
-
- while (1) {
- void* o = GC_MALLOC_UNCOLLECTABLE( size + sizeof( Descriptor ) );
- if (o != 0) return o;
- (*handler) ();}}
-
-
-void* __builtin_vec_new( size )
- size_t size;
- /*
- For non-gc array types, the compiler generates calls to
- __builtin_vec_new. */
-{
- return __builtin_new( size );}
-
-
-void* __builtin_new_gc( size )
- size_t size;
- /*
- For gc non-array types, the compiler generates calls to
- __builtin_new_gc, which allocates collected storage via
- GC_MALLOC. */
-{
- vfp handler = __new_handler ? __new_handler : __default_new_handler;
-
- while (1) {
- void* o = GC_MALLOC( size + sizeof( Descriptor ) );
- if (o != 0) return o;
- (*handler) ();}}
-
-
-void* __builtin_new_gc_a( size )
- size_t size;
- /*
- For non-pointer-containing gc non-array types, the compiler
- generates calls to __builtin_new_gc_a, which allocates collected
- storage via GC_MALLOC_ATOMIC. */
-{
- vfp handler = __new_handler ? __new_handler : __default_new_handler;
-
- while (1) {
- void* o = GC_MALLOC_ATOMIC( size + sizeof( Descriptor ) );
- if (o != 0) return o;
- (*handler) ();}}
-
-
-void* __builtin_vec_new_gc( size )
- size_t size;
- /*
- For gc array types, the compiler generates calls to
- __builtin_vec_new_gc. */
-{
- return __builtin_new_gc( size );}
-
-
-void* __builtin_vec_new_gc_a( size )
- size_t size;
- /*
- For non-pointer-containing gc array types, the compiler generates
- calls to __builtin_vec_new_gc_a. */
-{
- return __builtin_new_gc_a( size );}
-
-
-static void call_destructor( o, data )
- void* o;
- void* data;
- /*
- call_destructor is the GC finalizer proc registered for non-array
- gc objects with destructors. Its client data is the destructor
- proc, which it calls with the magic integer 2, a special flag
- obeying the compiler convention for destructors. */
-{
- ((destructor_proc) data)( o, 2 );}
-
-
-void* __builtin_new_gc_dtor( o, d )
- void* o;
- destructor_proc d;
- /*
- The compiler generates a call to __builtin_new_gc_dtor to register
- the destructor "d" of a non-array gc object "o" as a GC finalizer.
- The destructor is registered via
- GC_REGISTER_FINALIZER_IGNORE_SELF, which causes the collector to
- ignore pointers from the object to itself when determining when
- the object can be finalized. This is necessary due to the self
- pointers used in the internal representation of multiply-inherited
- objects. */
-{
- Descriptor* desc = DESCRIPTOR( o );
-
- GC_REGISTER_FINALIZER_IGNORE_SELF( o, call_destructor, d, 0, 0 );
- desc->has_finalizer = 1;}
-
-
-static void call_array_destructor( o, data )
- void* o;
- void* data;
- /*
- call_array_destructor is the GC finalizer proc registered for gc
- array objects whose elements have destructors. Its client data is
- the destructor proc. It iterates through the elements of the
- array in reverse order, calling the destructor on each. */
-{
- int num = NUM_ARRAY_ELEMENTS( o );
- Descriptor* desc = DESCRIPTOR( o );
- size_t size = desc->element_size;
- char* first_p = FIRST_ELEMENT_P( o );
- char* p = first_p + (num - 1) * size;
-
- if (num > 0) {
- while (1) {
- ((destructor_proc) data)( p, 2 );
- if (p == first_p) break;
- p -= size;}}}
-
-
-void* __builtin_vec_new_gc_dtor( first_elem, d, element_size )
- void* first_elem;
- destructor_proc d;
- size_t element_size;
- /*
- The compiler generates a call to __builtin_vec_new_gc_dtor to
- register the destructor "d" of a gc array object as a GC
- finalizer. "first_elem" points to the first element of the array,
- *not* the beginning of the object (this makes the generated call
- to this function smaller). The elements of the array are of size
- "element_size". The destructor is registered as in
- _builtin_new_gc_dtor. */
-{
- void* o = (char*) first_elem - sizeof( BI_header );
- Descriptor* desc = DESCRIPTOR( o );
-
- GC_REGISTER_FINALIZER_IGNORE_SELF( o, call_array_destructor, d, 0, 0 );
- desc->element_size = element_size;
- desc->has_finalizer = 1;}
-
-
-void __builtin_delete( o )
- void* o;
- /*
- The compiler generates calls to __builtin_delete for operator
- delete(). The GC currently requires that any registered
- finalizers be unregistered before explicitly freeing an object.
- If the object has any weak pointers referencing it, we can't
- actually free it now. */
-{
- if (o != 0) {
- Descriptor* desc = DESCRIPTOR( o );
- if (desc->has_finalizer) GC_REGISTER_FINALIZER( o, 0, 0, 0, 0 );
- if (! desc->has_weak_pointers) GC_FREE( o );}}
-
-
-void __builtin_vec_delete( o )
- void* o;
- /*
- The compiler generates calls to __builitn_vec_delete for operator
- delete[](). */
-{
- __builtin_delete( o );}
-
-
-/**************************************************************************
-
-Implementations of the template class WeakPointer from WeakPointer.h
-
-***************************************************************************/
-
-typedef struct WeakPointer {
- void* pointer;
-} WeakPointer;
-
-
-void* _WeakPointer_New( t )
- void* t;
-{
- if (t == 0) {
- return 0;}
- else {
- void* base = GC_base( t );
- WeakPointer* wp =
- (WeakPointer*) GC_MALLOC_ATOMIC( sizeof( WeakPointer ) );
- Descriptor* desc = DESCRIPTOR( base );
-
- wp->pointer = t;
- desc->has_weak_pointers = 1;
- GC_general_register_disappearing_link( &wp->pointer, base );
- return wp;}}
-
-
-static void* PointerWithLock( wp )
- WeakPointer* wp;
-{
- if (wp == 0 || wp->pointer == 0) {
- return 0;}
- else {
- return (void*) wp->pointer;}}
-
-
-void* _WeakPointer_Pointer( wp )
- WeakPointer* wp;
-{
- return (void*) GC_call_with_alloc_lock( PointerWithLock, wp );}
-
-
-typedef struct EqualClosure {
- WeakPointer* wp1;
- WeakPointer* wp2;
-} EqualClosure;
-
-
-static void* EqualWithLock( ec )
- EqualClosure* ec;
-{
- if (ec->wp1 == 0 || ec->wp2 == 0) {
- return (void*) (ec->wp1 == ec->wp2);}
- else {
- return (void*) (ec->wp1->pointer == ec->wp2->pointer);}}
-
-
-int _WeakPointer_Equal( wp1, wp2 )
- WeakPointer* wp1;
- WeakPointer* wp2;
-{
- EqualClosure ec;
-
- ec.wp1 = wp1;
- ec.wp2 = wp2;
- return (int) GC_call_with_alloc_lock( EqualWithLock, &ec );}
-
-
-int _WeakPointer_Hash( wp )
- WeakPointer* wp;
-{
- return (int) _WeakPointer_Pointer( wp );}
-
-
-/**************************************************************************
-
-Implementations of the template class CleanUp from WeakPointer.h
-
-***************************************************************************/
-
-typedef struct Closure {
- void (*c) PROTO(( void* d, void* t ));
- ptrdiff_t t_offset;
- void* d;
-} Closure;
-
-
-static void _CleanUp_CallClosure( obj, data )
- void* obj;
- void* data;
-{
- Closure* closure = (Closure*) data;
- closure->c( closure->d, (char*) obj + closure->t_offset );}
-
-
-void _CleanUp_Set( t, c, d )
- void* t;
- void (*c) PROTO(( void* d, void* t ));
- void* d;
-{
- void* base = GC_base( t );
- Descriptor* desc = DESCRIPTOR( t );
-
- if (c == 0) {
- GC_REGISTER_FINALIZER_IGNORE_SELF( base, 0, 0, 0, 0 );
- desc->has_finalizer = 0;}
- else {
- Closure* closure = (Closure*) GC_MALLOC( sizeof( Closure ) );
- closure->c = c;
- closure->t_offset = (char*) t - (char*) base;
- closure->d = d;
- GC_REGISTER_FINALIZER_IGNORE_SELF( base, _CleanUp_CallClosure,
- closure, 0, 0 );
- desc->has_finalizer = 1;}}
-
-
-void _CleanUp_Call( t )
- void* t;
-{
- /* ? Aren't we supposed to deactivate weak pointers to t too?
- Why? */
- void* base = GC_base( t );
- void* d;
- GC_finalization_proc f;
-
- GC_REGISTER_FINALIZER( base, 0, 0, &f, &d );
- f( base, d );}
-
-
-typedef struct QueueElem {
- void* o;
- GC_finalization_proc f;
- void* d;
- struct QueueElem* next;
-} QueueElem;
-
-
-void* _CleanUp_Queue_NewHead()
-{
- return GC_MALLOC( sizeof( QueueElem ) );}
-
-
-static void _CleanUp_Queue_Enqueue( obj, data )
- void* obj;
- void* data;
-{
- QueueElem* q = (QueueElem*) data;
- QueueElem* head = q->next;
-
- q->o = obj;
- q->next = head->next;
- head->next = q;}
-
-
-void _CleanUp_Queue_Set( h, t )
- void* h;
- void* t;
-{
- QueueElem* head = (QueueElem*) h;
- void* base = GC_base( t );
- void* d;
- GC_finalization_proc f;
- QueueElem* q = (QueueElem*) GC_MALLOC( sizeof( QueueElem ) );
-
- GC_REGISTER_FINALIZER( base, _CleanUp_Queue_Enqueue, q, &f, &d );
- q->f = f;
- q->d = d;
- q->next = head;}
-
-
-int _CleanUp_Queue_Call( h )
- void* h;
-{
- QueueElem* head = (QueueElem*) h;
- QueueElem* q = head->next;
-
- if (q == 0) {
- return 0;}
- else {
- head->next = q->next;
- q->next = 0;
- if (q->f != 0) q->f( q->o, q->d );
- return 1;}}
-
-
-
diff --git a/gcj_mlc.c b/gcj_mlc.c
index 8b1da82..31aed25 100644
--- a/gcj_mlc.c
+++ b/gcj_mlc.c
@@ -1,6 +1,6 @@
/*
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
- * Copyright (c) 1999 by Hewlett-Packard Company. All rights reserved.
+ * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P.
*
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
@@ -58,20 +58,16 @@ void GC_init_gcj_malloc(int mp_index, void * /* really GC_mark_proc */mp)
DCL_LOCK_STATE;
GC_init(); /* In case it's not already done. */
- DISABLE_SIGNALS();
LOCK();
if (GC_gcj_malloc_initialized) {
UNLOCK();
- ENABLE_SIGNALS();
return;
}
GC_gcj_malloc_initialized = TRUE;
ignore_gcj_info = (0 != GETENV("GC_IGNORE_GCJ_INFO"));
-# ifdef CONDPRINT
- if (GC_print_stats && ignore_gcj_info) {
- GC_printf0("Gcj-style type information is disabled!\n");
- }
-# endif
+ if (GC_print_stats && ignore_gcj_info) {
+ GC_log_printf("Gcj-style type information is disabled!\n");
+ }
GC_ASSERT(GC_mark_procs[mp_index] == (GC_mark_proc)0); /* unused */
GC_mark_procs[mp_index] = (GC_mark_proc)mp;
if (mp_index >= GC_n_mark_procs) ABORT("GC_init_gcj_malloc: bad index");
@@ -103,16 +99,15 @@ void GC_init_gcj_malloc(int mp_index, void * /* really GC_mark_proc */mp)
FALSE, TRUE);
}
UNLOCK();
- ENABLE_SIGNALS();
}
-ptr_t GC_clear_stack();
+void * GC_clear_stack(void *);
#define GENERAL_MALLOC(lb,k) \
- (GC_PTR)GC_clear_stack(GC_generic_malloc_inner((word)lb, k))
+ GC_clear_stack(GC_generic_malloc_inner((word)lb, k))
#define GENERAL_MALLOC_IOP(lb,k) \
- (GC_PTR)GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb, k))
+ GC_clear_stack(GC_generic_malloc_inner_ignore_off_page(lb, k))
/* We need a mechanism to release the lock and invoke finalizers. */
/* We don't really have an opportunity to do this on a rarely executed */
@@ -138,18 +133,14 @@ static void maybe_finalize()
/* This adds a byte at the end of the object if GC_malloc would.*/
void * GC_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr)
{
-register ptr_t op;
-register ptr_t * opp;
-register word lw;
-DCL_LOCK_STATE;
+ ptr_t op;
+ ptr_t * opp;
+ word lg;
+ DCL_LOCK_STATE;
- if( EXPECT(SMALL_OBJ(lb), 1) ) {
-# ifdef MERGE_SIZES
- lw = GC_size_map[lb];
-# else
- lw = ALIGNED_WORDS(lb);
-# endif
- opp = &(GC_gcjobjfreelist[lw]);
+ if(SMALL_OBJ(lb)) {
+ lg = GC_size_map[lb];
+ opp = &(GC_gcjobjfreelist[lg]);
LOCK();
op = *opp;
if(EXPECT(op == 0, 0)) {
@@ -159,12 +150,10 @@ DCL_LOCK_STATE;
UNLOCK();
return(GC_oom_fn(lb));
}
-# ifdef MERGE_SIZES
- lw = GC_size_map[lb]; /* May have been uninitialized. */
-# endif
+ lw = GC_size_map[lb]; /* May have been uninitialized. */
} else {
*opp = obj_link(op);
- GC_words_allocd += lw;
+ GC_bytes_allocd += GRANULES_TO_BYTES(lg);
}
*(void **)op = ptr_to_struct_containing_descr;
GC_ASSERT(((void **)op)[1] == 0);
@@ -180,15 +169,15 @@ DCL_LOCK_STATE;
*(void **)op = ptr_to_struct_containing_descr;
UNLOCK();
}
- return((GC_PTR) op);
+ return((void *) op);
}
/* Similar to GC_gcj_malloc, but add debug info. This is allocated */
/* with GC_gcj_debug_kind. */
-GC_PTR GC_debug_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr,
+void * GC_debug_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr,
GC_EXTRA_PARAMS)
{
- GC_PTR result;
+ void * result;
/* We're careful to avoid extra calls, which could */
/* confuse the backtrace. */
@@ -213,92 +202,25 @@ GC_PTR GC_debug_gcj_malloc(size_t lb, void * ptr_to_struct_containing_descr,
return (GC_store_debug_info(result, (word)lb, s, (word)i));
}
-/* Similar to GC_gcj_malloc, but the size is in words, and we don't */
-/* adjust it. The size is assumed to be such that it can be */
-/* allocated as a small object. */
-void * GC_gcj_fast_malloc(size_t lw, void * ptr_to_struct_containing_descr)
-{
-ptr_t op;
-ptr_t * opp;
-DCL_LOCK_STATE;
-
- opp = &(GC_gcjobjfreelist[lw]);
- LOCK();
- op = *opp;
- if( EXPECT(op == 0, 0) ) {
- maybe_finalize();
- op = (ptr_t)GC_clear_stack(
- GC_generic_malloc_words_small_inner(lw, GC_gcj_kind));
- if (0 == op) {
- UNLOCK();
- return GC_oom_fn(WORDS_TO_BYTES(lw));
- }
- } else {
- *opp = obj_link(op);
- GC_words_allocd += lw;
- }
- *(void **)op = ptr_to_struct_containing_descr;
- UNLOCK();
- return((GC_PTR) op);
-}
-
-/* And a debugging version of the above: */
-void * GC_debug_gcj_fast_malloc(size_t lw,
- void * ptr_to_struct_containing_descr,
- GC_EXTRA_PARAMS)
-{
- GC_PTR result;
- size_t lb = WORDS_TO_BYTES(lw);
-
- /* We clone the code from GC_debug_gcj_malloc, so that we */
- /* dont end up with extra frames on the stack, which could */
- /* confuse the backtrace. */
- LOCK();
- maybe_finalize();
- result = GC_generic_malloc_inner(lb + DEBUG_BYTES, GC_gcj_debug_kind);
- if (result == 0) {
- UNLOCK();
- GC_err_printf2("GC_debug_gcj_fast_malloc(%ld, 0x%lx) returning NIL (",
- (unsigned long) lw,
- (unsigned long) ptr_to_struct_containing_descr);
- GC_err_puts(s);
- GC_err_printf1(":%ld)\n", (unsigned long)i);
- return GC_oom_fn(WORDS_TO_BYTES(lw));
- }
- *((void **)((ptr_t)result + sizeof(oh))) = ptr_to_struct_containing_descr;
- UNLOCK();
- if (!GC_debugging_started) {
- GC_start_debugging();
- }
- ADD_CALL_CHAIN(result, ra);
- return (GC_store_debug_info(result, (word)lb, s, (word)i));
-}
-
void * GC_gcj_malloc_ignore_off_page(size_t lb,
void * ptr_to_struct_containing_descr)
{
-register ptr_t op;
-register ptr_t * opp;
-register word lw;
-DCL_LOCK_STATE;
+ ptr_t op;
+ ptr_t * opp;
+ word lg;
+ DCL_LOCK_STATE;
- if( SMALL_OBJ(lb) ) {
-# ifdef MERGE_SIZES
- lw = GC_size_map[lb];
-# else
- lw = ALIGNED_WORDS(lb);
-# endif
- opp = &(GC_gcjobjfreelist[lw]);
+ if(SMALL_OBJ(lb)) {
+ lg = GC_size_map[lb];
+ opp = &(GC_gcjobjfreelist[lg]);
LOCK();
if( (op = *opp) == 0 ) {
maybe_finalize();
op = (ptr_t)GENERAL_MALLOC_IOP(lb, GC_gcj_kind);
-# ifdef MERGE_SIZES
- lw = GC_size_map[lb]; /* May have been uninitialized. */
-# endif
+ lg = GC_size_map[lb]; /* May have been uninitialized. */
} else {
*opp = obj_link(op);
- GC_words_allocd += lw;
+ GC_bytes_allocd += GRANULES_TO_BYTES(lg);
}
*(void **)op = ptr_to_struct_containing_descr;
UNLOCK();
@@ -311,7 +233,7 @@ DCL_LOCK_STATE;
}
UNLOCK();
}
- return((GC_PTR) op);
+ return((void *) op);
}
#else
diff --git a/headers.c b/headers.c
index b7be1d8..8b14b4b 100644
--- a/headers.c
+++ b/headers.c
@@ -33,17 +33,75 @@ bottom_index * GC_all_bottom_indices_end = 0;
/* bottom_index. */
/* Non-macro version of header location routine */
-hdr * GC_find_header(h)
-ptr_t h;
+hdr * GC_find_header(ptr_t h)
{
# ifdef HASH_TL
- register hdr * result;
+ hdr * result;
GET_HDR(h, result);
return(result);
# else
return(HDR_INNER(h));
# endif
}
+
+/* Handle a header cache miss. Returns a pointer to the */
+/* header corresponding to p, if p can possibly be a valid */
+/* object pointer, and 0 otherwise. */
+/* GUARANTEED to return 0 for a pointer past the first page */
+/* of an object unless both GC_all_interior_pointers is set */
+/* and p is in fact a valid object pointer. */
+#ifdef PRINT_BLACK_LIST
+ hdr * GC_header_cache_miss(ptr_t p, hdr_cache_entry *hce, ptr_t source)
+#else
+ hdr * GC_header_cache_miss(ptr_t p, hdr_cache_entry *hce)
+#endif
+{
+ hdr *hhdr;
+ HC_MISS();
+ GET_HDR(p, hhdr);
+ if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
+ if (GC_all_interior_pointers) {
+ if (hhdr != 0) {
+ ptr_t current = p;
+
+ current = (ptr_t)HBLKPTR(current);
+ do {
+ current = current - HBLKSIZE*(word)hhdr;
+ hhdr = HDR(current);
+ } while(IS_FORWARDING_ADDR_OR_NIL(hhdr));
+ /* current points to near the start of the large object */
+ if (hhdr -> hb_flags & IGNORE_OFF_PAGE
+ || HBLK_IS_FREE(hhdr))
+ return 0;
+ if (p - current >= (ptrdiff_t)(hhdr->hb_sz)) {
+ GC_ADD_TO_BLACK_LIST_NORMAL(p, source);
+ /* Pointer past the end of the block */
+ return 0;
+ }
+ } else {
+ GC_ADD_TO_BLACK_LIST_NORMAL(p, source);
+ }
+ return hhdr;
+ /* Pointers past the first page are probably too rare */
+ /* to add them to the cache. We don't. */
+ /* And correctness relies on the fact that we don't. */
+ } else {
+ if (hhdr == 0) {
+ GC_ADD_TO_BLACK_LIST_NORMAL(p, source);
+ }
+ return 0;
+ }
+ } else {
+ if (HBLK_IS_FREE(hhdr)) {
+ GC_ADD_TO_BLACK_LIST_NORMAL(p, source);
+ return 0;
+ } else {
+ hce -> block_addr = (word)(p) >> LOG_HBLKSIZE;
+ hce -> hce_hdr = hhdr;
+ return hhdr;
+ }
+ }
+}
/* Routines to dynamically allocate collector data structures that will */
/* never be freed. */
@@ -53,18 +111,12 @@ static ptr_t scratch_free_ptr = 0;
/* GC_scratch_last_end_ptr is end point of last obtained scratch area. */
/* GC_scratch_end_ptr is end point of current scratch area. */
-ptr_t GC_scratch_alloc(bytes)
-register word bytes;
+ptr_t GC_scratch_alloc(size_t bytes)
{
register ptr_t result = scratch_free_ptr;
-# ifdef ALIGN_DOUBLE
-# define GRANULARITY (2 * sizeof(word))
-# else
-# define GRANULARITY sizeof(word)
-# endif
- bytes += GRANULARITY-1;
- bytes &= ~(GRANULARITY-1);
+ bytes += GRANULE_BYTES-1;
+ bytes &= ~(GRANULE_BYTES-1);
scratch_free_ptr += bytes;
if (scratch_free_ptr <= GC_scratch_end_ptr) {
return(result);
@@ -86,9 +138,8 @@ register word bytes;
}
result = (ptr_t)GET_MEM(bytes_to_get);
if (result == 0) {
-# ifdef PRINTSTATS
- GC_printf0("Out of memory - trying to allocate less\n");
-# endif
+ if (GC_print_stats)
+ GC_printf("Out of memory - trying to allocate less\n");
scratch_free_ptr -= bytes;
bytes_to_get = bytes;
# ifdef USE_MMAP
@@ -107,7 +158,7 @@ register word bytes;
static hdr * hdr_free_list = 0;
/* Return an uninitialized header */
-static hdr * alloc_hdr()
+static hdr * alloc_hdr(void)
{
register hdr * result;
@@ -120,21 +171,18 @@ static hdr * alloc_hdr()
return(result);
}
-static void free_hdr(hhdr)
-hdr * hhdr;
+static void free_hdr(hdr * hhdr)
{
hhdr -> hb_next = (struct hblk *) hdr_free_list;
hdr_free_list = hhdr;
}
-hdr * GC_invalid_header;
-
#ifdef USE_HDR_CACHE
word GC_hdr_cache_hits = 0;
word GC_hdr_cache_misses = 0;
#endif
-void GC_init_headers()
+void GC_init_headers(void)
{
register unsigned i;
@@ -143,14 +191,11 @@ void GC_init_headers()
for (i = 0; i < TOP_SZ; i++) {
GC_top_index[i] = GC_all_nils;
}
- GC_invalid_header = alloc_hdr();
- GC_invalidate_map(GC_invalid_header);
}
/* Make sure that there is a bottom level index block for address addr */
/* Return FALSE on failure. */
-static GC_bool get_index(addr)
-word addr;
+static GC_bool get_index(word addr)
{
word hi = (word)(addr) >> (LOG_BOTTOM_SZ + LOG_HBLKSIZE);
bottom_index * r;
@@ -201,8 +246,7 @@ word addr;
/* Install a header for block h. */
/* The header is uninitialized. */
/* Returns the header or 0 on failure. */
-struct hblkhdr * GC_install_header(h)
-register struct hblk * h;
+struct hblkhdr * GC_install_header(struct hblk *h)
{
hdr * result;
@@ -216,9 +260,7 @@ register struct hblk * h;
}
/* Set up forwarding counts for block h of size sz */
-GC_bool GC_install_counts(h, sz)
-register struct hblk * h;
-register word sz; /* bytes */
+GC_bool GC_install_counts(struct hblk *h, size_t sz/* bytes */)
{
register struct hblk * hbp;
register int i;
@@ -235,8 +277,7 @@ register word sz; /* bytes */
}
/* Remove the header for block h */
-void GC_remove_header(h)
-register struct hblk * h;
+void GC_remove_header(struct hblk *h)
{
hdr ** ha;
@@ -246,9 +287,7 @@ register struct hblk * h;
}
/* Remove forwarding counts for h */
-void GC_remove_counts(h, sz)
-register struct hblk * h;
-register word sz; /* bytes */
+void GC_remove_counts(struct hblk *h, size_t sz/* bytes */)
{
register struct hblk * hbp;
@@ -259,18 +298,17 @@ register word sz; /* bytes */
/* Apply fn to all allocated blocks */
/*VARARGS1*/
-void GC_apply_to_all_blocks(fn, client_data)
-void (*fn) GC_PROTO((struct hblk *h, word client_data));
-word client_data;
+void GC_apply_to_all_blocks(void (*fn)(struct hblk *h, word client_data),
+ word client_data)
{
- register int j;
- register bottom_index * index_p;
+ int j;
+ bottom_index * index_p;
for (index_p = GC_all_bottom_indices; index_p != 0;
index_p = index_p -> asc_link) {
for (j = BOTTOM_SZ-1; j >= 0;) {
if (!IS_FORWARDING_ADDR_OR_NIL(index_p->index[j])) {
- if (index_p->index[j]->hb_map != GC_invalid_map) {
+ if (!HBLK_IS_FREE(index_p->index[j])) {
(*fn)(((struct hblk *)
(((index_p->key << LOG_BOTTOM_SZ) + (word)j)
<< LOG_HBLKSIZE)),
@@ -288,8 +326,7 @@ word client_data;
/* Get the next valid block whose address is at least h */
/* Return 0 if there is none. */
-struct hblk * GC_next_used_block(h)
-struct hblk * h;
+struct hblk * GC_next_used_block(struct hblk *h)
{
register bottom_index * bi;
register word j = ((word)h >> LOG_HBLKSIZE) & (BOTTOM_SZ-1);
@@ -307,7 +344,7 @@ struct hblk * h;
if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
j++;
} else {
- if (hhdr->hb_map != GC_invalid_map) {
+ if (!HBLK_IS_FREE(hhdr)) {
return((struct hblk *)
(((bi -> key << LOG_BOTTOM_SZ) + j)
<< LOG_HBLKSIZE));
@@ -325,8 +362,7 @@ struct hblk * h;
/* Get the last (highest address) block whose address is */
/* at most h. Return 0 if there is none. */
/* Unlike the above, this may return a free block. */
-struct hblk * GC_prev_block(h)
-struct hblk * h;
+struct hblk * GC_prev_block(struct hblk *h)
{
register bottom_index * bi;
register signed_word j = ((word)h >> LOG_HBLKSIZE) & (BOTTOM_SZ-1);
diff --git a/if_mach.c b/if_mach.c
index 3dcccf2..d6e0a70 100644
--- a/if_mach.c
+++ b/if_mach.c
@@ -5,10 +5,7 @@
# include <string.h>
# include <unistd.h>
-int main(argc, argv, envp)
-int argc;
-char ** argv;
-char ** envp;
+int main(int argc, char **argv, char **envp)
{
if (argc < 4) goto Usage;
if (strcmp(MACH_TYPE, argv[1]) != 0) return(0);
diff --git a/if_not_there.c b/if_not_there.c
index 8691e92..7af6fba 100644
--- a/if_not_there.c
+++ b/if_not_there.c
@@ -8,10 +8,7 @@
#include <dirent.h>
#endif /* __DJGPP__ */
-int main(argc, argv, envp)
-int argc;
-char ** argv;
-char ** envp;
+int main(int argc, char **argv, char **envp)
{
FILE * f;
#ifdef __DJGPP__
diff --git a/include/Makefile.am b/include/Makefile.am
index 306026b..5bc68dd 100644
--- a/include/Makefile.am
+++ b/include/Makefile.am
@@ -17,7 +17,7 @@
#
pkginclude_HEADERS = gc.h gc_typed.h gc_inl.h \
gc_inline.h gc_mark.h gc_cpp.h \
- weakpointer.h gc_alloc.h new_gc_alloc.h \
+ weakpointer.h new_gc_alloc.h \
gc_allocator.h gc_backptr.h \
gc_gcj.h gc_local_alloc.h leak_detector.h \
gc_amiga_redirects.h gc_pthread_redirects.h \
@@ -28,7 +28,7 @@ pkginclude_HEADERS = gc.h gc_typed.h gc_inl.h \
dist_noinst_HEADERS = private/gc_hdrs.h \
private/gc_priv.h private/gcconfig.h \
private/gc_pmark.h private/gc_locks.h \
- private/solaris_threads.h private/dbg_mlc.h \
+ private/dbg_mlc.h \
private/specific.h private/cord_pos.h \
private/pthread_support.h private/pthread_stop_world.h \
private/darwin_semaphore.h private/darwin_stop_world.h \
diff --git a/include/Makefile.in b/include/Makefile.in
index ff95e78..1a1b58f 100644
--- a/include/Makefile.in
+++ b/include/Makefile.in
@@ -105,7 +105,7 @@ OBJDUMP = @OBJDUMP@
PACKAGE = @PACKAGE@
RANLIB = @RANLIB@
STRIP = @STRIP@
-THREADDLLIBS = @THREADDLLIBS@
+THREADLIBS = @THREADLIBS@
UNWINDLIBS = @UNWINDLIBS@
VERSION = @VERSION@
addincludes = @addincludes@
@@ -121,7 +121,7 @@ target_all = @target_all@
#
pkginclude_HEADERS = gc.h gc_typed.h gc_inl.h \
gc_inline.h gc_mark.h gc_cpp.h \
- weakpointer.h gc_alloc.h new_gc_alloc.h \
+ weakpointer.h new_gc_alloc.h \
gc_allocator.h gc_backptr.h \
gc_gcj.h gc_local_alloc.h leak_detector.h \
gc_amiga_redirects.h gc_pthread_redirects.h \
@@ -133,7 +133,7 @@ pkginclude_HEADERS = gc.h gc_typed.h gc_inl.h \
dist_noinst_HEADERS = private/gc_hdrs.h \
private/gc_priv.h private/gcconfig.h \
private/gc_pmark.h private/gc_locks.h \
- private/solaris_threads.h private/dbg_mlc.h \
+ private/dbg_mlc.h \
private/specific.h private/cord_pos.h \
private/pthread_support.h private/pthread_stop_world.h \
private/darwin_semaphore.h private/darwin_stop_world.h \
diff --git a/include/gc.h b/include/gc.h
index 5f15170..064b018 100644
--- a/include/gc.h
+++ b/include/gc.h
@@ -32,16 +32,6 @@
# include "gc_config_macros.h"
-# if defined(__STDC__) || defined(__cplusplus)
-# define GC_PROTO(args) args
- typedef void * GC_PTR;
-# define GC_CONST const
-# else
-# define GC_PROTO(args) ()
- typedef char * GC_PTR;
-# define GC_CONST
-# endif
-
# ifdef __cplusplus
extern "C" {
# endif
@@ -83,7 +73,7 @@ GC_API int GC_parallel; /* GC is parallelized for performance on */
/* Public R/W variables */
-GC_API GC_PTR (*GC_oom_fn) GC_PROTO((size_t bytes_requested));
+GC_API void * (*GC_oom_fn) (size_t bytes_requested);
/* When there is insufficient memory to satisfy */
/* an allocation request, we return */
/* (*GC_oom_fn)(). By default this just */
@@ -110,11 +100,6 @@ GC_API int GC_all_interior_pointers;
/* pointer recognition. */
/* MUST BE 0 or 1. */
-GC_API int GC_quiet; /* Disable statistics output. Only matters if */
- /* collector has been compiled with statistics */
- /* enabled. This involves a performance cost, */
- /* and is thus not the default. */
-
GC_API int GC_finalize_on_demand;
/* If nonzero, finalizers will only be run in */
/* response to an explicit GC_invoke_finalizers */
@@ -189,15 +174,16 @@ GC_API int GC_no_dls;
GC_API GC_word GC_free_space_divisor;
/* We try to make sure that we allocate at */
/* least N/GC_free_space_divisor bytes between */
- /* collections, where N is the heap size plus */
+ /* collections, where N is twice the number */
+ /* of traced bytes, plus the number of untraced */
+ /* bytes (bytes in "atomic" objects), plus */
/* a rough estimate of the root set size. */
+ /* N approximates GC tracing work per GC. */
/* Initially, GC_free_space_divisor = 3. */
/* Increasing its value will use less space */
/* but more collection time. Decreasing it */
/* will appreciably decrease collection time */
/* at the expense of space. */
- /* GC_free_space_divisor = 1 will effectively */
- /* disable collections. */
GC_API GC_word GC_max_retries;
/* The maximum number of GCs attempted before */
@@ -205,7 +191,7 @@ GC_API GC_word GC_max_retries;
/* expansion fails. Initially 0. */
-GC_API char *GC_stackbottom; /* Cool end of user stack. */
+GC_API char *GC_stackbottom; /* Cool end of user stack. */
/* May be set in the client prior to */
/* calling any GC_ routines. This */
/* avoids some overhead, and */
@@ -247,7 +233,7 @@ GC_API unsigned long GC_time_limit;
* to call this somehow (e.g. from a constructor) before doing any allocation.
* For win32 threads, it needs to be called explicitly.
*/
-GC_API void GC_init GC_PROTO((void));
+GC_API void GC_init(void);
/*
* general purpose allocation routines, with roughly malloc calling conv.
@@ -265,14 +251,14 @@ GC_API void GC_init GC_PROTO((void));
* starting in 6.0. GC_malloc_stubborn is an alias for GC_malloc unless
* the collector is built with STUBBORN_ALLOC defined.
*/
-GC_API GC_PTR GC_malloc GC_PROTO((size_t size_in_bytes));
-GC_API GC_PTR GC_malloc_atomic GC_PROTO((size_t size_in_bytes));
-GC_API GC_PTR GC_malloc_uncollectable GC_PROTO((size_t size_in_bytes));
-GC_API GC_PTR GC_malloc_stubborn GC_PROTO((size_t size_in_bytes));
+GC_API void * GC_malloc(size_t size_in_bytes);
+GC_API void * GC_malloc_atomic(size_t size_in_bytes);
+GC_API void * GC_malloc_uncollectable(size_t size_in_bytes);
+GC_API void * GC_malloc_stubborn(size_t size_in_bytes);
/* The following is only defined if the library has been suitably */
/* compiled: */
-GC_API GC_PTR GC_malloc_atomic_uncollectable GC_PROTO((size_t size_in_bytes));
+GC_API void * GC_malloc_atomic_uncollectable(size_t size_in_bytes);
/* Explicitly deallocate an object. Dangerous if used incorrectly. */
/* Requires a pointer to the base of an object. */
@@ -280,7 +266,7 @@ GC_API GC_PTR GC_malloc_atomic_uncollectable GC_PROTO((size_t size_in_bytes));
/* An object should not be enable for finalization when it is */
/* explicitly deallocated. */
/* GC_free(0) is a no-op, as required by ANSI C for free. */
-GC_API void GC_free GC_PROTO((GC_PTR object_addr));
+GC_API void GC_free(void * object_addr);
/*
* Stubborn objects may be changed only if the collector is explicitly informed.
@@ -297,8 +283,8 @@ GC_API void GC_free GC_PROTO((GC_PTR object_addr));
* do so. The same applies to dropping stubborn objects that are still
* changeable.
*/
-GC_API void GC_change_stubborn GC_PROTO((GC_PTR));
-GC_API void GC_end_stubborn_change GC_PROTO((GC_PTR));
+GC_API void GC_change_stubborn(void *);
+GC_API void GC_end_stubborn_change(void *);
/* Return a pointer to the base (lowest address) of an object given */
/* a pointer to a location within the object. */
@@ -310,13 +296,13 @@ GC_API void GC_end_stubborn_change GC_PROTO((GC_PTR));
/* object. */
/* Note that a deallocated object in the garbage collected heap */
/* may be considered valid, even if it has been deallocated with */
-/* GC_free. */
-GC_API GC_PTR GC_base GC_PROTO((GC_PTR displaced_pointer));
+/* GC_free. */
+GC_API void * GC_base(void * displaced_pointer);
/* Given a pointer to the base of an object, return its size in bytes. */
/* The returned size may be slightly larger than what was originally */
/* requested. */
-GC_API size_t GC_size GC_PROTO((GC_PTR object_addr));
+GC_API size_t GC_size(void * object_addr);
/* For compatibility with C library. This is occasionally faster than */
/* a malloc followed by a bcopy. But if you rely on that, either here */
@@ -326,35 +312,33 @@ GC_API size_t GC_size GC_PROTO((GC_PTR object_addr));
/* If the argument is stubborn, the result will have changes enabled. */
/* It is an error to have changes enabled for the original object. */
/* Follows ANSI comventions for NULL old_object. */
-GC_API GC_PTR GC_realloc
- GC_PROTO((GC_PTR old_object, size_t new_size_in_bytes));
+GC_API void * GC_realloc(void * old_object, size_t new_size_in_bytes);
/* Explicitly increase the heap size. */
/* Returns 0 on failure, 1 on success. */
-GC_API int GC_expand_hp GC_PROTO((size_t number_of_bytes));
+GC_API int GC_expand_hp(size_t number_of_bytes);
/* Limit the heap size to n bytes. Useful when you're debugging, */
/* especially on systems that don't handle running out of memory well. */
/* n == 0 ==> unbounded. This is the default. */
-GC_API void GC_set_max_heap_size GC_PROTO((GC_word n));
+GC_API void GC_set_max_heap_size(GC_word n);
/* Inform the collector that a certain section of statically allocated */
/* memory contains no pointers to garbage collected memory. Thus it */
/* need not be scanned. This is sometimes important if the application */
/* maps large read/write files into the address space, which could be */
/* mistaken for dynamic library data segments on some systems. */
-GC_API void GC_exclude_static_roots GC_PROTO((GC_PTR start, GC_PTR finish));
+GC_API void GC_exclude_static_roots(void * low_address,
+ void * high_address_plus_1);
/* Clear the set of root segments. Wizards only. */
-GC_API void GC_clear_roots GC_PROTO((void));
+GC_API void GC_clear_roots(void);
/* Add a root segment. Wizards only. */
-GC_API void GC_add_roots GC_PROTO((char * low_address,
- char * high_address_plus_1));
+GC_API void GC_add_roots(void * low_address, void * high_address_plus_1);
/* Remove a root segment. Wizards only. */
-GC_API void GC_remove_roots GC_PROTO((char * low_address,
- char * high_address_plus_1));
+GC_API void GC_remove_roots(void * low_address, void * high_address_plus_1);
/* Add a displacement to the set of those considered valid by the */
/* collector. GC_register_displacement(n) means that if p was returned */
@@ -368,14 +352,14 @@ GC_API void GC_remove_roots GC_PROTO((char * low_address,
/* retention. */
/* This is a no-op if the collector has recognition of */
/* arbitrary interior pointers enabled, which is now the default. */
-GC_API void GC_register_displacement GC_PROTO((GC_word n));
+GC_API void GC_register_displacement(size_t n);
/* The following version should be used if any debugging allocation is */
/* being done. */
-GC_API void GC_debug_register_displacement GC_PROTO((GC_word n));
+GC_API void GC_debug_register_displacement(size_t n);
/* Explicitly trigger a full, world-stop collection. */
-GC_API void GC_gcollect GC_PROTO((void));
+GC_API void GC_gcollect(void);
/* Trigger a full world-stopped collection. Abort the collection if */
/* and when stop_func returns a nonzero value. Stop_func will be */
@@ -386,32 +370,32 @@ GC_API void GC_gcollect GC_PROTO((void));
/* aborted collections do no useful work; the next collection needs */
/* to start from the beginning. */
/* Return 0 if the collection was aborted, 1 if it succeeded. */
-typedef int (* GC_stop_func) GC_PROTO((void));
-GC_API int GC_try_to_collect GC_PROTO((GC_stop_func stop_func));
+typedef int (* GC_stop_func)(void);
+GC_API int GC_try_to_collect(GC_stop_func stop_func);
/* Return the number of bytes in the heap. Excludes collector private */
/* data structures. Includes empty blocks and fragmentation loss. */
/* Includes some pages that were allocated but never written. */
-GC_API size_t GC_get_heap_size GC_PROTO((void));
+GC_API size_t GC_get_heap_size(void);
/* Return a lower bound on the number of free bytes in the heap. */
-GC_API size_t GC_get_free_bytes GC_PROTO((void));
+GC_API size_t GC_get_free_bytes(void);
/* Return the number of bytes allocated since the last collection. */
-GC_API size_t GC_get_bytes_since_gc GC_PROTO((void));
+GC_API size_t GC_get_bytes_since_gc(void);
/* Return the total number of bytes allocated in this process. */
/* Never decreases, except due to wrapping. */
-GC_API size_t GC_get_total_bytes GC_PROTO((void));
+GC_API size_t GC_get_total_bytes(void);
/* Disable garbage collection. Even GC_gcollect calls will be */
/* ineffective. */
-GC_API void GC_disable GC_PROTO((void));
+GC_API void GC_disable(void);
/* Reenable garbage collection. GC_disable() and GC_enable() calls */
/* nest. Garbage collection is enabled if the number of calls to both */
/* both functions is equal. */
-GC_API void GC_enable GC_PROTO((void));
+GC_API void GC_enable(void);
/* Enable incremental/generational collection. */
/* Not advisable unless dirty bits are */
@@ -425,7 +409,7 @@ GC_API void GC_enable GC_PROTO((void));
/* Causes GC_local_gcj_malloc() to revert to */
/* locked allocation. Must be called */
/* before any GC_local_gcj_malloc() calls. */
-GC_API void GC_enable_incremental GC_PROTO((void));
+GC_API void GC_enable_incremental(void);
/* Does incremental mode write-protect pages? Returns zero or */
/* more of the following, or'ed together: */
@@ -435,7 +419,7 @@ GC_API void GC_enable_incremental GC_PROTO((void));
#define GC_PROTECTS_STACK 8 /* Probably impractical. */
#define GC_PROTECTS_NONE 0
-GC_API int GC_incremental_protection_needs GC_PROTO((void));
+GC_API int GC_incremental_protection_needs(void);
/* Perform some garbage collection work, if appropriate. */
/* Return 0 if there is no more work to be done. */
@@ -444,7 +428,7 @@ GC_API int GC_incremental_protection_needs GC_PROTO((void));
/* progress requires it, e.g. if incremental collection is */
/* disabled. It is reasonable to call this in a wait loop */
/* until it returns 0. */
-GC_API int GC_collect_a_little GC_PROTO((void));
+GC_API int GC_collect_a_little(void);
/* Allocate an object of size lb bytes. The client guarantees that */
/* as long as the object is live, it will be referenced by a pointer */
@@ -460,8 +444,8 @@ GC_API int GC_collect_a_little GC_PROTO((void));
/* for arrays likely to be larger than 100K or so. For other systems, */
/* or if the collector is not configured to recognize all interior */
/* pointers, the threshold is normally much higher. */
-GC_API GC_PTR GC_malloc_ignore_off_page GC_PROTO((size_t lb));
-GC_API GC_PTR GC_malloc_atomic_ignore_off_page GC_PROTO((size_t lb));
+GC_API void * GC_malloc_ignore_off_page(size_t lb);
+GC_API void * GC_malloc_atomic_ignore_off_page(size_t lb);
#if defined(__sgi) && !defined(__GNUC__) && _COMPILER_VERSION >= 720
# define GC_ADD_CALLER
@@ -511,32 +495,29 @@ GC_API GC_PTR GC_malloc_atomic_ignore_off_page GC_PROTO((size_t lb));
#ifdef GC_ADD_CALLER
# define GC_EXTRAS GC_RETURN_ADDR, __FILE__, __LINE__
-# define GC_EXTRA_PARAMS GC_word ra, GC_CONST char * s, int i
+# define GC_EXTRA_PARAMS GC_word ra, const char * s, int i
#else
# define GC_EXTRAS __FILE__, __LINE__
-# define GC_EXTRA_PARAMS GC_CONST char * s, int i
+# define GC_EXTRA_PARAMS const char * s, int i
#endif
/* Debugging (annotated) allocation. GC_gcollect will check */
/* objects allocated in this way for overwrites, etc. */
-GC_API GC_PTR GC_debug_malloc
- GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS));
-GC_API GC_PTR GC_debug_malloc_atomic
- GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS));
-GC_API GC_PTR GC_debug_malloc_uncollectable
- GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS));
-GC_API GC_PTR GC_debug_malloc_stubborn
- GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS));
-GC_API GC_PTR GC_debug_malloc_ignore_off_page
- GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS));
-GC_API GC_PTR GC_debug_malloc_atomic_ignore_off_page
- GC_PROTO((size_t size_in_bytes, GC_EXTRA_PARAMS));
-GC_API void GC_debug_free GC_PROTO((GC_PTR object_addr));
-GC_API GC_PTR GC_debug_realloc
- GC_PROTO((GC_PTR old_object, size_t new_size_in_bytes,
- GC_EXTRA_PARAMS));
-GC_API void GC_debug_change_stubborn GC_PROTO((GC_PTR));
-GC_API void GC_debug_end_stubborn_change GC_PROTO((GC_PTR));
+GC_API void * GC_debug_malloc(size_t size_in_bytes, GC_EXTRA_PARAMS);
+GC_API void * GC_debug_malloc_atomic(size_t size_in_bytes, GC_EXTRA_PARAMS);
+GC_API void * GC_debug_malloc_uncollectable
+ (size_t size_in_bytes, GC_EXTRA_PARAMS);
+GC_API void * GC_debug_malloc_stubborn
+ (size_t size_in_bytes, GC_EXTRA_PARAMS);
+GC_API void * GC_debug_malloc_ignore_off_page
+ (size_t size_in_bytes, GC_EXTRA_PARAMS);
+GC_API void * GC_debug_malloc_atomic_ignore_off_page
+ (size_t size_in_bytes, GC_EXTRA_PARAMS);
+GC_API void GC_debug_free (void * object_addr);
+GC_API void * GC_debug_realloc
+ (void * old_object, size_t new_size_in_bytes, GC_EXTRA_PARAMS);
+GC_API void GC_debug_change_stubborn(void *);
+GC_API void GC_debug_end_stubborn_change(void *);
/* Routines that allocate objects with debug information (like the */
/* above), but just fill in dummy file and line number information. */
@@ -550,9 +531,9 @@ GC_API void GC_debug_end_stubborn_change GC_PROTO((GC_PTR));
/* platforms it may be more convenient not to recompile, e.g. for */
/* leak detection. This can be accomplished by instructing the */
/* linker to replace malloc/realloc with these. */
-GC_API GC_PTR GC_debug_malloc_replacement GC_PROTO((size_t size_in_bytes));
-GC_API GC_PTR GC_debug_realloc_replacement
- GC_PROTO((GC_PTR object_addr, size_t size_in_bytes));
+GC_API void * GC_debug_malloc_replacement (size_t size_in_bytes);
+GC_API void * GC_debug_realloc_replacement
+ (void * object_addr, size_t size_in_bytes);
# ifdef GC_DEBUG
# define GC_MALLOC(sz) GC_debug_malloc(sz, GC_EXTRAS)
@@ -616,15 +597,14 @@ GC_API GC_PTR GC_debug_realloc_replacement
/* with Alan Demers, Dan Greene, Carl Hauser, Barry Hayes, */
/* Christian Jacobi, and Russ Atkinson. It's not perfect, and */
/* probably nobody else agrees with it. Hans-J. Boehm 3/13/92 */
-typedef void (*GC_finalization_proc)
- GC_PROTO((GC_PTR obj, GC_PTR client_data));
+typedef void (*GC_finalization_proc) (void * obj, void * client_data);
-GC_API void GC_register_finalizer
- GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
- GC_finalization_proc *ofn, GC_PTR *ocd));
+GC_API void GC_register_finalizer(void * obj, GC_finalization_proc fn,
+ void * cd, GC_finalization_proc *ofn,
+ void * *ocd);
GC_API void GC_debug_register_finalizer
- GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
- GC_finalization_proc *ofn, GC_PTR *ocd));
+ (void * obj, GC_finalization_proc fn, void * cd,
+ GC_finalization_proc *ofn, void * *ocd);
/* When obj is no longer accessible, invoke */
/* (*fn)(obj, cd). If a and b are inaccessible, and */
/* a points to b (after disappearing links have been */
@@ -668,22 +648,22 @@ GC_API void GC_debug_register_finalizer
/* Note that cd will still be viewed as accessible, even if it */
/* refers to the object itself. */
GC_API void GC_register_finalizer_ignore_self
- GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
- GC_finalization_proc *ofn, GC_PTR *ocd));
+ (void * obj, GC_finalization_proc fn, void * cd,
+ GC_finalization_proc *ofn, void * *ocd);
GC_API void GC_debug_register_finalizer_ignore_self
- GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
- GC_finalization_proc *ofn, GC_PTR *ocd));
+ (void * obj, GC_finalization_proc fn, void * cd,
+ GC_finalization_proc *ofn, void * *ocd);
/* Another version of the above. It ignores all cycles. */
/* It should probably only be used by Java implementations. */
/* Note that cd will still be viewed as accessible, even if it */
/* refers to the object itself. */
GC_API void GC_register_finalizer_no_order
- GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
- GC_finalization_proc *ofn, GC_PTR *ocd));
+ (void * obj, GC_finalization_proc fn, void * cd,
+ GC_finalization_proc *ofn, void * *ocd);
GC_API void GC_debug_register_finalizer_no_order
- GC_PROTO((GC_PTR obj, GC_finalization_proc fn, GC_PTR cd,
- GC_finalization_proc *ofn, GC_PTR *ocd));
+ (void * obj, GC_finalization_proc fn, void * cd,
+ GC_finalization_proc *ofn, void * *ocd);
/* The following routine may be used to break cycles between */
@@ -693,7 +673,7 @@ GC_API void GC_debug_register_finalizer_no_order
/* where p is a pointer that is not followed by finalization */
/* code, and should not be considered in determining */
/* finalization order. */
-GC_API int GC_register_disappearing_link GC_PROTO((GC_PTR * /* link */));
+GC_API int GC_register_disappearing_link(void * * link );
/* Link should point to a field of a heap allocated */
/* object obj. *link will be cleared when obj is */
/* found to be inaccessible. This happens BEFORE any */
@@ -713,8 +693,7 @@ GC_API int GC_register_disappearing_link GC_PROTO((GC_PTR * /* link */));
/* otherwise. */
/* Only exists for backward compatibility. See below: */
-GC_API int GC_general_register_disappearing_link
- GC_PROTO((GC_PTR * /* link */, GC_PTR obj));
+GC_API int GC_general_register_disappearing_link (void * * link, void * obj);
/* A slight generalization of the above. *link is */
/* cleared when obj first becomes inaccessible. This */
/* can be used to implement weak pointers easily and */
@@ -732,15 +711,15 @@ GC_API int GC_general_register_disappearing_link
/* the object containing link. Explicitly deallocating */
/* obj may or may not cause link to eventually be */
/* cleared. */
-GC_API int GC_unregister_disappearing_link GC_PROTO((GC_PTR * /* link */));
+GC_API int GC_unregister_disappearing_link (void * * link);
/* Returns 0 if link was not actually registered. */
/* Undoes a registration by either of the above two */
/* routines. */
/* Returns !=0 if GC_invoke_finalizers has something to do. */
-GC_API int GC_should_invoke_finalizers GC_PROTO((void));
+GC_API int GC_should_invoke_finalizers(void);
-GC_API int GC_invoke_finalizers GC_PROTO((void));
+GC_API int GC_invoke_finalizers(void);
/* Run finalizers for all objects that are ready to */
/* be finalized. Return the number of finalizers */
/* that were run. Normally this is also called */
@@ -750,11 +729,11 @@ GC_API int GC_invoke_finalizers GC_PROTO((void));
/* GC_set_warn_proc can be used to redirect or filter warning messages. */
/* p may not be a NULL pointer. */
-typedef void (*GC_warn_proc) GC_PROTO((char *msg, GC_word arg));
-GC_API GC_warn_proc GC_set_warn_proc GC_PROTO((GC_warn_proc p));
+typedef void (*GC_warn_proc) (char *msg, GC_word arg);
+GC_API GC_warn_proc GC_set_warn_proc(GC_warn_proc p);
/* Returns old warning procedure. */
-GC_API GC_word GC_set_free_space_divisor GC_PROTO((GC_word value));
+GC_API GC_word GC_set_free_space_divisor(GC_word value);
/* Set free_space_divisor. See above for definition. */
/* Returns old value. */
@@ -769,15 +748,14 @@ GC_API GC_word GC_set_free_space_divisor GC_PROTO((GC_word value));
# if defined(I_HIDE_POINTERS) || defined(GC_I_HIDE_POINTERS)
typedef GC_word GC_hidden_pointer;
# define HIDE_POINTER(p) (~(GC_hidden_pointer)(p))
-# define REVEAL_POINTER(p) ((GC_PTR)(HIDE_POINTER(p)))
+# define REVEAL_POINTER(p) ((void *)(HIDE_POINTER(p)))
/* Converting a hidden pointer to a real pointer requires verifying */
/* that the object still exists. This involves acquiring the */
/* allocator lock to avoid a race with the collector. */
# endif /* I_HIDE_POINTERS */
-typedef GC_PTR (*GC_fn_type) GC_PROTO((GC_PTR client_data));
-GC_API GC_PTR GC_call_with_alloc_lock
- GC_PROTO((GC_fn_type fn, GC_PTR client_data));
+typedef void * (*GC_fn_type) (void * client_data);
+GC_API void * GC_call_with_alloc_lock (GC_fn_type fn, void * client_data);
/* The following routines are primarily intended for use with a */
/* preprocessor which inserts calls to check C pointer arithmetic. */
@@ -788,14 +766,14 @@ GC_API GC_PTR GC_call_with_alloc_lock
/* Returns the first argument. */
/* Succeeds if neither p nor q points to the heap. */
/* May succeed if both p and q point to between heap objects. */
-GC_API GC_PTR GC_same_obj GC_PROTO((GC_PTR p, GC_PTR q));
+GC_API void * GC_same_obj (void * p, void * q);
/* Checked pointer pre- and post- increment operations. Note that */
/* the second argument is in units of bytes, not multiples of the */
/* object size. This should either be invoked from a macro, or the */
/* call should be automatically generated. */
-GC_API GC_PTR GC_pre_incr GC_PROTO((GC_PTR *p, size_t how_much));
-GC_API GC_PTR GC_post_incr GC_PROTO((GC_PTR *p, size_t how_much));
+GC_API void * GC_pre_incr (void * *p, size_t how_much);
+GC_API void * GC_post_incr (void * *p, size_t how_much);
/* Check that p is visible */
/* to the collector as a possibly pointer containing location. */
@@ -805,14 +783,14 @@ GC_API GC_PTR GC_post_incr GC_PROTO((GC_PTR *p, size_t how_much));
/* untyped allocations. The idea is that it should be possible, though */
/* slow, to add such a call to all indirect pointer stores.) */
/* Currently useless for multithreaded worlds. */
-GC_API GC_PTR GC_is_visible GC_PROTO((GC_PTR p));
+GC_API void * GC_is_visible (void * p);
/* Check that if p is a pointer to a heap page, then it points to */
/* a valid displacement within a heap object. */
/* Fail conspicuously if this property does not hold. */
/* Uninteresting with GC_all_interior_pointers. */
/* Always returns its argument. */
-GC_API GC_PTR GC_is_valid_displacement GC_PROTO((GC_PTR p));
+GC_API void * GC_is_valid_displacement (void * p);
/* Safer, but slow, pointer addition. Probably useful mainly with */
/* a preprocessor. Useful only for heap pointers. */
@@ -848,25 +826,18 @@ GC_API GC_PTR GC_is_valid_displacement GC_PROTO((GC_PTR p));
/* Safer assignment of a pointer to a nonstack location. */
#ifdef GC_DEBUG
-# ifdef __STDC__
# define GC_PTR_STORE(p, q) \
(*(void **)GC_is_visible(p) = GC_is_valid_displacement(q))
-# else
-# define GC_PTR_STORE(p, q) \
- (*(char **)GC_is_visible(p) = GC_is_valid_displacement(q))
-# endif
#else /* !GC_DEBUG */
# define GC_PTR_STORE(p, q) *((p) = (q))
#endif
/* Functions called to report pointer checking errors */
-GC_API void (*GC_same_obj_print_proc) GC_PROTO((GC_PTR p, GC_PTR q));
+GC_API void (*GC_same_obj_print_proc) (void * p, void * q);
-GC_API void (*GC_is_valid_displacement_print_proc)
- GC_PROTO((GC_PTR p));
+GC_API void (*GC_is_valid_displacement_print_proc) (void * p);
-GC_API void (*GC_is_visible_print_proc)
- GC_PROTO((GC_PTR p));
+GC_API void (*GC_is_visible_print_proc) (void * p);
/* For pthread support, we generally need to intercept a number of */
@@ -883,11 +854,10 @@ GC_API void (*GC_is_visible_print_proc)
/* This returns a list of objects, linked through their first */
/* word. Its use can greatly reduce lock contention problems, since */
/* the allocation lock can be acquired and released many fewer times. */
-/* lb must be large enough to hold the pointer field. */
/* It is used internally by gc_local_alloc.h, which provides a simpler */
/* programming interface on Linux. */
-GC_PTR GC_malloc_many(size_t lb);
-#define GC_NEXT(p) (*(GC_PTR *)(p)) /* Retrieve the next element */
+void * GC_malloc_many(size_t lb);
+#define GC_NEXT(p) (*(void * *)(p)) /* Retrieve the next element */
/* in returned list. */
extern void GC_thr_init(); /* Needed for Solaris/X86 */
diff --git a/include/gc_alloc.h b/include/gc_alloc.h
deleted file mode 100644
index c50a758..0000000
--- a/include/gc_alloc.h
+++ /dev/null
@@ -1,383 +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 C++ header file that is intended to replace the SGI STL
-// alloc.h. This assumes SGI STL version < 3.0.
-//
-// This assumes the collector has been compiled with -DATOMIC_UNCOLLECTABLE
-// and -DALL_INTERIOR_POINTERS. We also recommend
-// -DREDIRECT_MALLOC=GC_uncollectable_malloc.
-//
-// 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.
-//
-// This code assumes that the collector itself has been compiled with a
-// compiler that defines __STDC__ .
-//
-
-#include "gc.h"
-
-#ifndef GC_ALLOC_H
-
-#define GC_ALLOC_H
-#define __ALLOC_H // Prevent inclusion of the default version. Ugly.
-#define __SGI_STL_ALLOC_H
-#define __SGI_STL_INTERNAL_ALLOC_H
-
-#ifndef __ALLOC
-# define __ALLOC alloc
-#endif
-
-#include <stddef.h>
-#include <string.h>
-
-// The following is just replicated from the conventional SGI alloc.h:
-
-template<class T, class alloc>
-class simple_alloc {
-
-public:
- static T *allocate(size_t n)
- { return 0 == n? 0 : (T*) alloc::allocate(n * sizeof (T)); }
- static T *allocate(void)
- { return (T*) alloc::allocate(sizeof (T)); }
- static void deallocate(T *p, size_t n)
- { if (0 != n) alloc::deallocate(p, n * sizeof (T)); }
- static void deallocate(T *p)
- { alloc::deallocate(p, sizeof (T)); }
-};
-
-#include "gc.h"
-
-// The following need to match collector data structures.
-// We can't include gc_priv.h, since that pulls in way too much stuff.
-// This should eventually be factored out into another include file.
-
-extern "C" {
- extern void ** const GC_objfreelist_ptr;
- extern void ** const GC_aobjfreelist_ptr;
- extern void ** const GC_uobjfreelist_ptr;
- extern void ** const GC_auobjfreelist_ptr;
-
- extern void GC_incr_words_allocd(size_t words);
- extern void GC_incr_mem_freed(size_t words);
-
- extern char * GC_generic_malloc_words_small(size_t word, int kind);
-}
-
-// 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_bytes_per_word = sizeof(char *) };
-
-enum { GC_byte_alignment = 8 };
-
-enum { GC_word_alignment = GC_byte_alignment/GC_bytes_per_word };
-
-inline void * &GC_obj_link(void * p)
-{ return *(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_words_recently_allocd;
-
- // Same for uncollectable mmory. Not yet reflected in either
- // GC_words_recently_allocd or GC_non_gc_bytes.
- static size_t GC_uncollectable_words_recently_allocd;
-
- // Similar counter for explicitly deallocated memory.
- static size_t GC_mem_recently_freed;
-
- // Again for uncollectable memory.
- static size_t GC_uncollectable_mem_recently_freed;
-
- static void * GC_out_of_line_malloc(size_t nwords, int kind);
-};
-
-template <int dummy>
-size_t GC_aux_template<dummy>::GC_words_recently_allocd = 0;
-
-template <int dummy>
-size_t GC_aux_template<dummy>::GC_uncollectable_words_recently_allocd = 0;
-
-template <int dummy>
-size_t GC_aux_template<dummy>::GC_mem_recently_freed = 0;
-
-template <int dummy>
-size_t GC_aux_template<dummy>::GC_uncollectable_mem_recently_freed = 0;
-
-template <int dummy>
-void * GC_aux_template<dummy>::GC_out_of_line_malloc(size_t nwords, int kind)
-{
- GC_words_recently_allocd += GC_uncollectable_words_recently_allocd;
- GC_non_gc_bytes +=
- GC_bytes_per_word * GC_uncollectable_words_recently_allocd;
- GC_uncollectable_words_recently_allocd = 0;
-
- GC_mem_recently_freed += GC_uncollectable_mem_recently_freed;
- GC_non_gc_bytes -=
- GC_bytes_per_word * GC_uncollectable_mem_recently_freed;
- GC_uncollectable_mem_recently_freed = 0;
-
- GC_incr_words_allocd(GC_words_recently_allocd);
- GC_words_recently_allocd = 0;
-
- GC_incr_mem_freed(GC_mem_recently_freed);
- GC_mem_recently_freed = 0;
-
- return GC_generic_malloc_words_small(nwords, kind);
-}
-
-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 noop, 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) return GC_malloc(n);
- flh = GC_objfreelist_ptr + nwords;
- if (0 == (op = *flh)) {
- return GC_aux::GC_out_of_line_malloc(nwords, GC_NORMAL);
- }
- *flh = GC_obj_link(op);
- GC_aux::GC_words_recently_allocd += nwords;
- 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) return GC_malloc_atomic(n);
- flh = GC_aobjfreelist_ptr + nwords;
- if (0 == (op = *flh)) {
- return GC_aux::GC_out_of_line_malloc(nwords, GC_PTRFREE);
- }
- *flh = GC_obj_link(op);
- GC_aux::GC_words_recently_allocd += nwords;
- return op;
- }
- static void deallocate(void *p, size_t n)
- {
- size_t nwords = GC_round_up(n);
- void ** flh;
-
- if (n > GC_max_fast_bytes) {
- GC_free(p);
- } else {
- flh = GC_objfreelist_ptr + nwords;
- GC_obj_link(p) = *flh;
- memset((char *)p + GC_bytes_per_word, 0,
- GC_bytes_per_word * (nwords - 1));
- *flh = p;
- GC_aux::GC_mem_recently_freed += nwords;
- }
- }
- static void ptr_free_deallocate(void *p, size_t n)
- {
- size_t nwords = GC_round_up(n);
- void ** flh;
-
- if (n > GC_max_fast_bytes) {
- GC_free(p);
- } else {
- flh = GC_aobjfreelist_ptr + nwords;
- GC_obj_link(p) = *flh;
- *flh = p;
- GC_aux::GC_mem_recently_freed += nwords;
- }
- }
-};
-
-typedef single_client_gc_alloc_template<0> single_client_gc_alloc;
-
-// Once more, for uncollectable objects.
-template <int dummy>
-class single_client_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) return GC_malloc_uncollectable(n);
- flh = GC_uobjfreelist_ptr + nwords;
- if (0 == (op = *flh)) {
- return GC_aux::GC_out_of_line_malloc(nwords, GC_UNCOLLECTABLE);
- }
- *flh = GC_obj_link(op);
- GC_aux::GC_uncollectable_words_recently_allocd += nwords;
- 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) return GC_malloc_atomic_uncollectable(n);
- flh = GC_auobjfreelist_ptr + nwords;
- if (0 == (op = *flh)) {
- return GC_aux::GC_out_of_line_malloc(nwords, GC_AUNCOLLECTABLE);
- }
- *flh = GC_obj_link(op);
- GC_aux::GC_uncollectable_words_recently_allocd += nwords;
- return op;
- }
- static void deallocate(void *p, size_t n)
- {
- size_t nwords = GC_round_up_uncollectable(n);
- void ** flh;
-
- if (n > GC_max_fast_bytes) {
- GC_free(p);
- } else {
- flh = GC_uobjfreelist_ptr + nwords;
- GC_obj_link(p) = *flh;
- *flh = p;
- GC_aux::GC_uncollectable_mem_recently_freed += nwords;
- }
- }
- static void ptr_free_deallocate(void *p, size_t n)
- {
- size_t nwords = GC_round_up_uncollectable(n);
- void ** flh;
-
- if (n > GC_max_fast_bytes) {
- GC_free(p);
- } else {
- flh = GC_auobjfreelist_ptr + nwords;
- GC_obj_link(p) = *flh;
- *flh = p;
- GC_aux::GC_uncollectable_mem_recently_freed += nwords;
- }
- }
-};
-
-typedef single_client_alloc_template<0> single_client_alloc;
-
-template < int dummy >
-class gc_alloc_template {
- public:
- static void * allocate(size_t n) { return GC_malloc(n); }
- static void * ptr_free_allocate(size_t n)
- { return GC_malloc_atomic(n); }
- 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 alloc_template {
- public:
- static void * allocate(size_t n) { return GC_malloc_uncollectable(n); }
- static void * ptr_free_allocate(size_t n)
- { return GC_malloc_atomic_uncollectable(n); }
- static void deallocate(void *p, size_t) { GC_free(p); }
- static void ptr_free_deallocate(void *p, size_t) { GC_free(p); }
-};
-
-typedef alloc_template < 0 > alloc;
-
-#ifdef _SGI_SOURCE
-
-// We want to specialize simple_alloc so that it does the right thing
-// for all pointerfree types. At the moment there is no portable way to
-// even approximate that. The following approximation should work for
-// SGI compilers, and perhaps some others.
-
-# define __GC_SPECIALIZE(T,alloc) \
-class simple_alloc<T, alloc> { \
-public: \
- static T *allocate(size_t n) \
- { return 0 == n? 0 : \
- (T*) alloc::ptr_free_allocate(n * sizeof (T)); } \
- static T *allocate(void) \
- { return (T*) alloc::ptr_free_allocate(sizeof (T)); } \
- static void deallocate(T *p, size_t n) \
- { if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
- static void deallocate(T *p) \
- { alloc::ptr_free_deallocate(p, sizeof (T)); } \
-};
-
-__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, alloc)
-__GC_SPECIALIZE(int, alloc)
-__GC_SPECIALIZE(unsigned, alloc)
-__GC_SPECIALIZE(float, alloc)
-__GC_SPECIALIZE(double, 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_alloc)
-__GC_SPECIALIZE(int, single_client_alloc)
-__GC_SPECIALIZE(unsigned, single_client_alloc)
-__GC_SPECIALIZE(float, single_client_alloc)
-__GC_SPECIALIZE(double, single_client_alloc)
-
-#ifdef __STL_USE_STD_ALLOCATORS
-
-???copy stuff from stl_alloc.h or remove it to a different file ???
-
-#endif /* __STL_USE_STD_ALLOCATORS */
-
-#endif /* _SGI_SOURCE */
-
-#endif /* GC_ALLOC_H */
diff --git a/include/gc_config_macros.h b/include/gc_config_macros.h
index d8d3114..bdae6a9 100644
--- a/include/gc_config_macros.h
+++ b/include/gc_config_macros.h
@@ -97,11 +97,14 @@
# endif
#endif /* GC_THREADS */
-#if defined(GC_THREADS) && !defined(GC_PTHREADS) && \
- (defined(_WIN32) || defined(_MSC_VER) || defined(__CYGWIN__) \
+#if defined(GC_THREADS) && !defined(GC_PTHREADS) && !defined(GC_WIN32_THREADS) \
+ && (defined(_WIN32) || defined(_MSC_VER) || defined(__CYGWIN__) \
|| defined(__MINGW32__) || defined(__BORLANDC__) \
|| defined(_WIN32_WCE))
# define GC_WIN32_THREADS
+# if defined(__CYGWIN__)
+# define GC_PTHREADS
+# endif
#endif
#if defined(GC_SOLARIS_PTHREADS) && !defined(GC_SOLARIS_THREADS)
diff --git a/include/gc_gcj.h b/include/gc_gcj.h
index 5e79e27..df5c6c7 100644
--- a/include/gc_gcj.h
+++ b/include/gc_gcj.h
@@ -71,18 +71,6 @@ extern void * GC_debug_gcj_malloc(size_t lb,
void * ptr_to_struct_containing_descr,
GC_EXTRA_PARAMS);
-/* Similar to the above, but the size is in words, and we don't */
-/* adjust it. The size is assumed to be such that it can be */
-/* allocated as a small object. */
-/* Unless it is known that the collector is not configured */
-/* with USE_MARK_BYTES and unless it is known that the object */
-/* has weak alignment requirements, lw must be even. */
-extern void * GC_gcj_fast_malloc(size_t lw,
- void * ptr_to_struct_containing_descr);
-extern void * GC_debug_gcj_fast_malloc(size_t lw,
- void * ptr_to_struct_containing_descr,
- GC_EXTRA_PARAMS);
-
/* Similar to GC_gcj_malloc, but assumes that a pointer to near the */
/* beginning of the resulting object is always maintained. */
extern void * GC_gcj_malloc_ignore_off_page(size_t lb,
diff --git a/include/gc_inl.h b/include/gc_inl.h
index c535cfd..73d63ec 100644
--- a/include/gc_inl.h
+++ b/include/gc_inl.h
@@ -13,6 +13,8 @@
*/
/* Boehm, October 3, 1995 2:07 pm PDT */
+#error FIXME: This needs to be updated.
+
# ifndef GC_PRIVATE_H
# include "private/gc_priv.h"
# endif
@@ -58,7 +60,7 @@
obj_link(op) = 0; \
GC_words_allocd += (n); \
FASTUNLOCK(); \
- (result) = (GC_PTR) op; \
+ (result) = (void *) op; \
} \
}
@@ -80,7 +82,7 @@
obj_link(op) = 0; \
GC_words_allocd += (n); \
FASTUNLOCK(); \
- (result) = (GC_PTR) op; \
+ (result) = (void *) op; \
} \
}
@@ -103,5 +105,5 @@
} \
((word *)op)[0] = (word)(first); \
((word *)op)[1] = (word)(second); \
- (result) = (GC_PTR) op; \
+ (result) = (void *) op; \
}
diff --git a/include/gc_local_alloc.h b/include/gc_local_alloc.h
index 1874c7b..7a7b7bb 100644
--- a/include/gc_local_alloc.h
+++ b/include/gc_local_alloc.h
@@ -49,14 +49,12 @@
# include "gc_gcj.h"
#endif
-/* We assume ANSI C for this interface. */
+void * GC_local_malloc(size_t bytes);
-GC_PTR GC_local_malloc(size_t bytes);
-
-GC_PTR GC_local_malloc_atomic(size_t bytes);
+void * GC_local_malloc_atomic(size_t bytes);
#if defined(GC_GCJ_SUPPORT)
- GC_PTR GC_local_gcj_malloc(size_t bytes,
+ void * GC_local_gcj_malloc(size_t bytes,
void * ptr_to_struct_containing_descr);
#endif
diff --git a/include/gc_mark.h b/include/gc_mark.h
index 953bb74..79f5a8b 100644
--- a/include/gc_mark.h
+++ b/include/gc_mark.h
@@ -53,9 +53,9 @@
/* case correctly somehow. */
# define GC_PROC_BYTES 100
struct GC_ms_entry;
-typedef struct GC_ms_entry * (*GC_mark_proc) GC_PROTO((
+typedef struct GC_ms_entry * (*GC_mark_proc) (
GC_word * addr, struct GC_ms_entry * mark_stack_ptr,
- struct GC_ms_entry * mark_stack_limit, GC_word env));
+ struct GC_ms_entry * mark_stack_limit, GC_word env);
# define GC_LOG_MAX_MARK_PROCS 6
# define GC_MAX_MARK_PROCS (1 << GC_LOG_MAX_MARK_PROCS)
@@ -106,8 +106,8 @@ typedef struct GC_ms_entry * (*GC_mark_proc) GC_PROTO((
/* held. */
#define GC_INDIR_PER_OBJ_BIAS 0x10
-extern GC_PTR GC_least_plausible_heap_addr;
-extern GC_PTR GC_greatest_plausible_heap_addr;
+extern void * GC_least_plausible_heap_addr;
+extern void * GC_greatest_plausible_heap_addr;
/* Bounds on the heap. Guaranteed valid */
/* Likely to include future heap expansion. */
@@ -130,10 +130,10 @@ extern GC_PTR GC_greatest_plausible_heap_addr;
/* which would tie the client code to a fixed collector version.) */
/* Note that mark procedures should explicitly call FIXUP_POINTER() */
/* if required. */
-struct GC_ms_entry *GC_mark_and_push
- GC_PROTO((GC_PTR obj,
- struct GC_ms_entry * mark_stack_ptr,
- struct GC_ms_entry * mark_stack_limit, GC_PTR *src));
+struct GC_ms_entry *GC_mark_and_push(void * obj,
+ struct GC_ms_entry * mark_stack_ptr,
+ struct GC_ms_entry * mark_stack_limit,
+ void * *src);
#define GC_MARK_AND_PUSH(obj, msp, lim, src) \
(((GC_word)obj >= (GC_word)GC_least_plausible_heap_addr && \
@@ -146,29 +146,29 @@ extern size_t GC_debug_header_size;
/* the GC_debug routines. */
/* Defined as a variable so that client mark procedures don't */
/* need to be recompiled for collector version changes. */
-#define GC_USR_PTR_FROM_BASE(p) ((GC_PTR)((char *)(p) + GC_debug_header_size))
+#define GC_USR_PTR_FROM_BASE(p) ((void *)((char *)(p) + GC_debug_header_size))
/* And some routines to support creation of new "kinds", e.g. with */
/* custom mark procedures, by language runtimes. */
/* The _inner versions assume the caller holds the allocation lock. */
/* Return a new free list array. */
-void ** GC_new_free_list GC_PROTO((void));
-void ** GC_new_free_list_inner GC_PROTO((void));
+void ** GC_new_free_list(void);
+void ** GC_new_free_list_inner(void);
/* Return a new kind, as specified. */
-int GC_new_kind GC_PROTO((void **free_list, GC_word mark_descriptor_template,
- int add_size_to_descriptor, int clear_new_objects));
+int GC_new_kind(void **free_list, GC_word mark_descriptor_template,
+ int add_size_to_descriptor, int clear_new_objects);
/* The last two parameters must be zero or one. */
-int GC_new_kind_inner GC_PROTO((void **free_list,
- GC_word mark_descriptor_template,
- int add_size_to_descriptor,
- int clear_new_objects));
+int GC_new_kind_inner(void **free_list,
+ GC_word mark_descriptor_template,
+ int add_size_to_descriptor,
+ int clear_new_objects);
/* Return a new mark procedure identifier, suitable for use as */
/* the first argument in GC_MAKE_PROC. */
-int GC_new_proc GC_PROTO((GC_mark_proc));
-int GC_new_proc_inner GC_PROTO((GC_mark_proc));
+int GC_new_proc(GC_mark_proc);
+int GC_new_proc_inner(GC_mark_proc);
/* Allocate an object of a given kind. Note that in multithreaded */
/* contexts, this is usually unsafe for kinds that have the descriptor */
@@ -176,11 +176,9 @@ int GC_new_proc_inner GC_PROTO((GC_mark_proc));
/* the descriptor is not correct. Even in the single-threaded case, */
/* we need to be sure that cleared objects on a free list don't */
/* cause a GC crash if they are accidentally traced. */
-/* ptr_t */char * GC_generic_malloc GC_PROTO((GC_word lb, int k));
+void * GC_generic_malloc(size_t lb, int k);
-/* FIXME - Should return void *, but that requires other changes. */
-
-typedef void (*GC_describe_type_fn) GC_PROTO((void *p, char *out_buf));
+typedef void (*GC_describe_type_fn) (void *p, char *out_buf);
/* A procedure which */
/* produces a human-readable */
/* description of the "type" of object */
@@ -194,7 +192,7 @@ typedef void (*GC_describe_type_fn) GC_PROTO((void *p, char *out_buf));
/* global free list. */
# define GC_TYPE_DESCR_LEN 40
-void GC_register_describe_type_fn GC_PROTO((int kind, GC_describe_type_fn knd));
+void GC_register_describe_type_fn(int kind, GC_describe_type_fn knd);
/* Register a describe_type function */
/* to be used when printing objects */
/* of a particular kind. */
diff --git a/include/gc_tiny_fl.h b/include/gc_tiny_fl.h
new file mode 100644
index 0000000..537bc34
--- /dev/null
+++ b/include/gc_tiny_fl.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P.
+ *
+ * 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 TINY_FL_H
+#define TINY_FL_H
+/*
+ * Constants and data structures for "tiny" free lists.
+ * These are used for thread-local allocation or in-lined allocators.
+ * Each global free list also essentially starts with one of these.
+ * However, global free lists are known to the GC. "Tiny" free lists
+ * are basically private to the client. Their contents are viewed as
+ * "in use" and marked accordingly by the core of the GC.
+ *
+ * Note that inlined code might know about the layout of these and the constants
+ * involved. Thus any change here may invalidate clients, and such changes should
+ * be avoided. Hence we keep this as simple as possible.
+ */
+
+/*
+ * We always set GRANULE_BYTES to twice the length of a pointer.
+ * This means that all allocation requests are rounded up to the next
+ * multiple of 16 on 64-bit architectures or 8 on 32-bit architectures.
+ * This appears to be a reasonable compromise between fragmentation overhead
+ * and space usage for mark bits (usually mark bytes).
+ * On many 64-bit architectures some memory references require 16-byte
+ * alignment, making this necessary anyway.
+ * For a few 32-bit architecture (e.g. 86), we may also need 16-byte alignment
+ * for certain memory references. But currently that does not seem to be the
+ * default for all conventional malloc implementations, so we ignore that
+ * problem.
+ * It would always be safe, and often useful, to be able to allocate very
+ * small objects with smaller alignment. But that would cost us mark bit
+ * space, so we no longer do so.
+ */
+#ifndef GC_GRANULE_BYTES
+# if defined(__LP64__) || defined (_LP64) || defined(_WIN64) || defined(__s390x__) \
+ || defined(__x86_64__) || defined(__alpha__) || defined(__powerpc64__) \
+ || defined(__arch64__)
+# define GC_GRANULE_BYTES 16
+# else
+# define GC_GRANULE_BYTES 8
+# endif
+#endif /* !GC_GRANULE_BYTES */
+
+/* A "tiny" free list header contains TINY_FREELISTS pointers to */
+/* singly linked lists of objects of different sizes, the ith one */
+/* containing objects i granules in size. Note that there is a list */
+/* of size zero objects. */
+#ifndef GC_TINY_FREELISTS
+# if GC_GRANULE_BYTES == 16
+# define GC_TINY_FREELISTS 25
+# else
+# define GC_TINY_FREELISTS 33 /* Up to and including 256 bytes */
+# endif
+#endif /* !GC_TINY_FREELISTS */
+
+#endif /* TINY_FL_H */
diff --git a/include/gc_typed.h b/include/gc_typed.h
index 905734b..1086acd 100644
--- a/include/gc_typed.h
+++ b/include/gc_typed.h
@@ -47,7 +47,7 @@ typedef GC_word * GC_bitmap;
typedef GC_word GC_descr;
-GC_API GC_descr GC_make_descriptor GC_PROTO((GC_bitmap bm, size_t len));
+GC_API GC_descr GC_make_descriptor(GC_bitmap bm, size_t len);
/* Return a type descriptor for the object whose layout */
/* is described by the argument. */
/* The least significant bit of the first word is one */
@@ -74,19 +74,17 @@ GC_API GC_descr GC_make_descriptor GC_PROTO((GC_bitmap bm, size_t len));
/* ... */
/* T_descr = GC_make_descriptor(T_bitmap, GC_WORD_LEN(T)); */
-GC_API GC_PTR GC_malloc_explicitly_typed
- GC_PROTO((size_t size_in_bytes, GC_descr d));
+GC_API void * GC_malloc_explicitly_typed(size_t size_in_bytes, GC_descr d);
/* Allocate an object whose layout is described by d. */
/* The resulting object MAY NOT BE PASSED TO REALLOC. */
/* The returned object is cleared. */
-GC_API GC_PTR GC_malloc_explicitly_typed_ignore_off_page
- GC_PROTO((size_t size_in_bytes, GC_descr d));
+GC_API void * GC_malloc_explicitly_typed_ignore_off_page
+ (size_t size_in_bytes, GC_descr d);
-GC_API GC_PTR GC_calloc_explicitly_typed
- GC_PROTO((size_t nelements,
- size_t element_size_in_bytes,
- GC_descr d));
+GC_API void * GC_calloc_explicitly_typed(size_t nelements,
+ size_t element_size_in_bytes,
+ GC_descr d);
/* Allocate an array of nelements elements, each of the */
/* given size, and with the given descriptor. */
/* The elemnt size must be a multiple of the byte */
diff --git a/include/new_gc_alloc.h b/include/new_gc_alloc.h
index 7546638..7668e49 100644
--- a/include/new_gc_alloc.h
+++ b/include/new_gc_alloc.h
@@ -88,10 +88,11 @@ extern "C" {
extern void ** const GC_uobjfreelist_ptr;
extern void ** const GC_auobjfreelist_ptr;
- extern void GC_incr_words_allocd(size_t words);
- extern void GC_incr_mem_freed(size_t words);
+ extern void GC_incr_bytes_allocd(size_t bytes);
+ extern void GC_incr_mem_freed(size_t words); /* FIXME: use bytes */
extern char * GC_generic_malloc_words_small(size_t word, int kind);
+ /* FIXME: Doesn't exist anymore. */
}
// Object kinds; must match PTRFREE, NORMAL, UNCOLLECTABLE, and
@@ -130,51 +131,50 @@ 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_words_recently_allocd;
+ static size_t GC_bytes_recently_allocd;
// Same for uncollectable mmory. Not yet reflected in either
- // GC_words_recently_allocd or GC_non_gc_bytes.
- static size_t GC_uncollectable_words_recently_allocd;
+ // 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_mem_recently_freed;
+ static size_t GC_bytes_recently_freed;
// Again for uncollectable memory.
- static size_t GC_uncollectable_mem_recently_freed;
+ 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_words_recently_allocd = 0;
+size_t GC_aux_template<dummy>::GC_bytes_recently_allocd = 0;
template <int dummy>
-size_t GC_aux_template<dummy>::GC_uncollectable_words_recently_allocd = 0;
+size_t GC_aux_template<dummy>::GC_uncollectable_bytes_recently_allocd = 0;
template <int dummy>
-size_t GC_aux_template<dummy>::GC_mem_recently_freed = 0;
+size_t GC_aux_template<dummy>::GC_bytes_recently_freed = 0;
template <int dummy>
-size_t GC_aux_template<dummy>::GC_uncollectable_mem_recently_freed = 0;
+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)
{
- GC_words_recently_allocd += GC_uncollectable_words_recently_allocd;
+ GC_bytes_recently_allocd += GC_uncollectable_bytes_recently_allocd;
GC_non_gc_bytes +=
- GC_bytes_per_word * GC_uncollectable_words_recently_allocd;
- GC_uncollectable_words_recently_allocd = 0;
+ GC_uncollectable_bytes_recently_allocd;
+ GC_uncollectable_bytes_recently_allocd = 0;
- GC_mem_recently_freed += GC_uncollectable_mem_recently_freed;
- GC_non_gc_bytes -=
- GC_bytes_per_word * GC_uncollectable_mem_recently_freed;
- GC_uncollectable_mem_recently_freed = 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_words_allocd(GC_words_recently_allocd);
- GC_words_recently_allocd = 0;
+ GC_incr_bytes_allocd(GC_bytes_recently_allocd);
+ GC_bytes_recently_allocd = 0;
- GC_incr_mem_freed(GC_mem_recently_freed);
- GC_mem_recently_freed = 0;
+ GC_incr_mem_freed(GC_bytes_per_word(GC_bytes_recently_freed));
+ GC_bytes_recently_freed = 0;
return GC_generic_malloc_words_small(nwords, kind);
}
@@ -200,7 +200,7 @@ class single_client_gc_alloc_template {
return GC_aux::GC_out_of_line_malloc(nwords, GC_NORMAL);
}
*flh = GC_obj_link(op);
- GC_aux::GC_words_recently_allocd += nwords;
+ GC_aux::GC_bytes_recently_allocd += nwords * GC_bytes_per_word;
return op;
}
static void * ptr_free_allocate(size_t n)
@@ -215,7 +215,7 @@ class single_client_gc_alloc_template {
return GC_aux::GC_out_of_line_malloc(nwords, GC_PTRFREE);
}
*flh = GC_obj_link(op);
- GC_aux::GC_words_recently_allocd += nwords;
+ GC_aux::GC_bytes_recently_allocd += nwords * GC_bytes_per_word;
return op;
}
static void deallocate(void *p, size_t n)
@@ -231,7 +231,7 @@ class single_client_gc_alloc_template {
memset(reinterpret_cast<char *>(p) + GC_bytes_per_word, 0,
GC_bytes_per_word * (nwords - 1));
*flh = p;
- GC_aux::GC_mem_recently_freed += nwords;
+ GC_aux::GC_bytes_recently_freed += nwords * GC_bytes_per_word;
}
}
static void ptr_free_deallocate(void *p, size_t n)
@@ -245,7 +245,7 @@ class single_client_gc_alloc_template {
flh = GC_aobjfreelist_ptr + nwords;
GC_obj_link(p) = *flh;
*flh = p;
- GC_aux::GC_mem_recently_freed += nwords;
+ GC_aux::GC_bytes_recently_freed += nwords * GC_bytes_per_word;
}
}
};
@@ -268,7 +268,8 @@ class single_client_traceable_alloc_template {
return GC_aux::GC_out_of_line_malloc(nwords, GC_UNCOLLECTABLE);
}
*flh = GC_obj_link(op);
- GC_aux::GC_uncollectable_words_recently_allocd += nwords;
+ GC_aux::GC_uncollectable_bytes_recently_allocd +=
+ nwords * GC_bytes_per_word;
return op;
}
static void * ptr_free_allocate(size_t n)
@@ -283,7 +284,8 @@ class single_client_traceable_alloc_template {
return GC_aux::GC_out_of_line_malloc(nwords, GC_AUNCOLLECTABLE);
}
*flh = GC_obj_link(op);
- GC_aux::GC_uncollectable_words_recently_allocd += nwords;
+ GC_aux::GC_uncollectable_bytes_recently_allocd +=
+ nwords * GC_bytes_per_word;
return op;
}
static void deallocate(void *p, size_t n)
@@ -297,7 +299,8 @@ class single_client_traceable_alloc_template {
flh = GC_uobjfreelist_ptr + nwords;
GC_obj_link(p) = *flh;
*flh = p;
- GC_aux::GC_uncollectable_mem_recently_freed += nwords;
+ GC_aux::GC_uncollectable_bytes_recently_freed +=
+ nwords * GC_bytes_per_word;
}
}
static void ptr_free_deallocate(void *p, size_t n)
@@ -311,7 +314,8 @@ class single_client_traceable_alloc_template {
flh = GC_auobjfreelist_ptr + nwords;
GC_obj_link(p) = *flh;
*flh = p;
- GC_aux::GC_uncollectable_mem_recently_freed += nwords;
+ GC_aux::GC_uncollectable_bytes_recently_freed +=
+ nwords * GC_bytes_per_word;
}
}
};
diff --git a/include/private/dbg_mlc.h b/include/private/dbg_mlc.h
index e0a994d..fcd027c 100644
--- a/include/private/dbg_mlc.h
+++ b/include/private/dbg_mlc.h
@@ -38,7 +38,7 @@
/* get them anyway. */
typedef GC_word GC_hidden_pointer;
# define HIDE_POINTER(p) (~(GC_hidden_pointer)(p))
-# define REVEAL_POINTER(p) ((GC_PTR)(HIDE_POINTER(p)))
+# define REVEAL_POINTER(p) ((void *)(HIDE_POINTER(p)))
#endif /* HIDE_POINTER */
# define START_FLAG ((word)0xfedcedcb)
@@ -95,12 +95,12 @@ typedef struct {
# ifdef MAKE_BACK_GRAPH
GC_hidden_pointer oh_bg_ptr;
# endif
-# if defined(ALIGN_DOUBLE) && \
- (defined(KEEP_BACK_PTRS) != defined(MAKE_BACK_GRAPH))
+# if defined(KEEP_BACK_PTRS) != defined(MAKE_BACK_GRAPH)
+ /* Keep double-pointer-sized alignment. */
word oh_dummy;
# endif
# endif
- GC_CONST char * oh_string; /* object descriptor string */
+ const char * oh_string; /* object descriptor string */
word oh_int; /* object descriptor integers */
# ifdef NEED_CALLINFO
struct callinfo oh_ci[NFRAMES];
@@ -132,17 +132,20 @@ typedef struct {
/* lock. */
/* PRINT_CALL_CHAIN prints the call chain stored in an object */
/* to stderr. It requires that we do not hold the lock. */
-#ifdef SAVE_CALL_CHAIN
+#if defined(SAVE_CALL_CHAIN)
+ struct callinfo;
+ void GC_save_callers(struct callinfo info[NFRAMES]);
+ void GC_print_callers(struct callinfo info[NFRAMES]);
# define ADD_CALL_CHAIN(base, ra) GC_save_callers(((oh *)(base)) -> oh_ci)
# define PRINT_CALL_CHAIN(base) GC_print_callers(((oh *)(base)) -> oh_ci)
-#else
-# ifdef GC_ADD_CALLER
+#elif defined(GC_ADD_CALLER)
+ struct callinfo;
+ void GC_print_callers(struct callinfo info[NFRAMES]);
# define ADD_CALL_CHAIN(base, ra) ((oh *)(base)) -> oh_ci[0].ci_pc = (ra)
# define PRINT_CALL_CHAIN(base) GC_print_callers(((oh *)(base)) -> oh_ci)
-# else
+#else
# define ADD_CALL_CHAIN(base, ra)
# define PRINT_CALL_CHAIN(base)
-# endif
#endif
# ifdef GC_ADD_CALLER
diff --git a/include/private/gc_hdrs.h b/include/private/gc_hdrs.h
index 70dfefe..80a29d8 100644
--- a/include/private/gc_hdrs.h
+++ b/include/private/gc_hdrs.h
@@ -28,7 +28,7 @@ typedef struct hblkhdr hdr;
* This defines HDR, GET_HDR, and SET_HDR, the main macros used to
* retrieve and set object headers.
*
- * Since 5.0 alpha 5, we can also take advantage of a header lookup
+ * We take advantage of a header lookup
* cache. This is a locally declared direct mapped cache, used inside
* the marker. The HC_GET_HDR macro uses and maintains this
* cache. Assuming we get reasonable hit rates, this shaves a few
@@ -60,22 +60,6 @@ typedef struct hblkhdr hdr;
/* #define COUNT_HDR_CACHE_HITS */
-extern hdr * GC_invalid_header; /* header for an imaginary block */
- /* containing no objects. */
-
-
-/* Check whether p and corresponding hhdr point to long or invalid */
-/* object. If so, advance hhdr to */
-/* beginning of block, or set hhdr to GC_invalid_header. */
-#define ADVANCE(p, hhdr, source) \
- { \
- hdr * new_hdr = GC_invalid_header; \
- p = GC_find_start(p, hhdr, &new_hdr); \
- hhdr = new_hdr; \
- }
-
-#ifdef USE_HDR_CACHE
-
# ifdef COUNT_HDR_CACHE_HITS
extern word GC_hdr_cache_hits;
extern word GC_hdr_cache_misses;
@@ -96,7 +80,7 @@ extern hdr * GC_invalid_header; /* header for an imaginary block */
# define DECLARE_HDR_CACHE \
hdr_cache_entry hdr_cache[HDR_CACHE_SIZE]
-# define INIT_HDR_CACHE BZERO(hdr_cache, sizeof(hdr_cache));
+# define INIT_HDR_CACHE BZERO(hdr_cache, sizeof(hdr_cache))
# define HCE(h) hdr_cache + (((word)(h) >> LOG_HBLKSIZE) & (HDR_CACHE_SIZE-1))
@@ -105,44 +89,33 @@ extern hdr * GC_invalid_header; /* header for an imaginary block */
# define HCE_HDR(h) ((hce) -> hce_hdr)
+#ifdef PRINT_BLACK_LIST
+ hdr * GC_header_cache_miss(ptr_t p, hdr_cache_entry *hce, ptr_t source);
+# define HEADER_CACHE_MISS(p, hce, source) \
+ GC_header_cache_miss(p, hce, source)
+#else
+ hdr * GC_header_cache_miss(ptr_t p, hdr_cache_entry *hce);
+# define HEADER_CACHE_MISS(p, hce, source) GC_header_cache_miss(p, hce)
+#endif
-/* Analogous to GET_HDR, except that in the case of large objects, it */
-/* Returns the header for the object beginning, and updates p. */
-/* Returns GC_invalid_header instead of 0. All of this saves a branch */
-/* in the fast path. */
-# define HC_GET_HDR(p, hhdr, source) \
+/* Set hhdr to the header for p. Analogous to GET_HDR below, */
+/* except that in the case of large objects, it */
+/* gets the header for the object beginning, if GC_all_interior_ptrs */
+/* is set. */
+/* Returns zero if p points to somewhere other than the first page */
+/* of an object, and it is not a valid pointer to the object. */
+# define HC_GET_HDR(p, hhdr, source, exit_label) \
{ \
hdr_cache_entry * hce = HCE(p); \
- if (HCE_VALID_FOR(hce, p)) { \
+ if (EXPECT(HCE_VALID_FOR(hce, p), 1)) { \
HC_HIT(); \
hhdr = hce -> hce_hdr; \
} else { \
- HC_MISS(); \
- GET_HDR(p, hhdr); \
- if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { \
- ADVANCE(p, hhdr, source); \
- } else { \
- hce -> block_addr = (word)(p) >> LOG_HBLKSIZE; \
- hce -> hce_hdr = hhdr; \
- } \
+ hhdr = HEADER_CACHE_MISS(p, hce, source); \
+ if (0 == hhdr) goto exit_label; \
} \
}
-#else /* !USE_HDR_CACHE */
-
-# define DECLARE_HDR_CACHE
-
-# define INIT_HDR_CACHE
-
-# define HC_GET_HDR(p, hhdr, source) \
- { \
- GET_HDR(p, hhdr); \
- if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) { \
- ADVANCE(p, hhdr, source); \
- } \
- }
-#endif
-
typedef struct bi {
hdr * index[BOTTOM_SZ];
/*
diff --git a/include/private/gc_locks.h b/include/private/gc_locks.h
index 5e2de6d..b69d2b8 100644
--- a/include/private/gc_locks.h
+++ b/include/private/gc_locks.h
@@ -18,6 +18,8 @@
#ifndef GC_LOCKS_H
#define GC_LOCKS_H
+#include <atomic_ops.h>
+
/*
* Mutual exclusion between allocator/collector routines.
* Needed if there is more than one allocator thread.
@@ -31,8 +33,7 @@
* FASTLOCK is otherwise immune to interruption, provided it is
* not restarted.
* DCL_LOCK_STATE declares any local variables needed by LOCK and UNLOCK
- * and/or DISABLE_SIGNALS and ENABLE_SIGNALS and/or FASTLOCK.
- * (There is currently no equivalent for FASTLOCK.)
+ * and/or FASTLOCK.
*
* In the PARALLEL_MARK case, we also need to define a number of
* other inline finctions here:
@@ -43,7 +44,7 @@
*
*/
# ifdef THREADS
- void GC_noop1 GC_PROTO((word));
+ void GC_noop1(word);
# ifdef PCR_OBSOLETE /* Faster, but broken with multiple lwp's */
# include "th/PCR_Th.h"
# include "th/PCR_ThCrSec.h"
@@ -76,474 +77,16 @@
# define LOCK() RT0u__inCritical++
# define UNLOCK() RT0u__inCritical--
# endif
-# ifdef GC_SOLARIS_THREADS
-# include <thread.h>
-# include <signal.h>
- extern mutex_t GC_allocate_ml;
-# define LOCK() mutex_lock(&GC_allocate_ml);
-# define UNLOCK() mutex_unlock(&GC_allocate_ml);
-# endif
-
-/* Try to define GC_TEST_AND_SET and a matching GC_CLEAR for spin lock */
-/* acquisition and release. We need this for correct operation of the */
-/* incremental GC. */
-# ifdef __GNUC__
-# if defined(I386)
- inline static int GC_test_and_set(volatile unsigned int *addr) {
- int oldval;
- /* Note: the "xchg" instruction does not need a "lock" prefix */
- __asm__ __volatile__("xchgl %0, %1"
- : "=r"(oldval), "=m"(*(addr))
- : "0"(1), "m"(*(addr)) : "memory");
- return oldval;
- }
-# define GC_TEST_AND_SET_DEFINED
-# endif
-# if defined(IA64)
-# if defined(__INTEL_COMPILER)
-# include <ia64intrin.h>
-# endif
- inline static int GC_test_and_set(volatile unsigned int *addr) {
- long oldval, n = 1;
-# ifndef __INTEL_COMPILER
- __asm__ __volatile__("xchg4 %0=%1,%2"
- : "=r"(oldval), "=m"(*addr)
- : "r"(n), "1"(*addr) : "memory");
-# else
- oldval = _InterlockedExchange(addr, n);
-# endif
- return oldval;
- }
-# define GC_TEST_AND_SET_DEFINED
- /* Should this handle post-increment addressing?? */
- inline static void GC_clear(volatile unsigned int *addr) {
-# ifndef __INTEL_COMPILER
- __asm__ __volatile__("st4.rel %0=r0" : "=m" (*addr) : : "memory");
-# else
- // there is no st4 but I can use xchg I hope
- _InterlockedExchange(addr, 0);
-# endif
- }
-# define GC_CLEAR_DEFINED
-# endif
-# ifdef SPARC
- inline static int GC_test_and_set(volatile unsigned int *addr) {
- int oldval;
-
- __asm__ __volatile__("ldstub %1,%0"
- : "=r"(oldval), "=m"(*addr)
- : "m"(*addr) : "memory");
- return oldval;
- }
-# define GC_TEST_AND_SET_DEFINED
-# endif
-# ifdef M68K
- /* Contributed by Tony Mantler. I'm not sure how well it was */
- /* tested. */
- inline static int GC_test_and_set(volatile unsigned int *addr) {
- char oldval; /* this must be no longer than 8 bits */
-
- /* The return value is semi-phony. */
- /* 'tas' sets bit 7 while the return */
- /* value pretends bit 0 was set */
- __asm__ __volatile__(
- "tas %1@; sne %0; negb %0"
- : "=d" (oldval)
- : "a" (addr) : "memory");
- return oldval;
- }
-# define GC_TEST_AND_SET_DEFINED
-# endif
-# if defined(POWERPC)
- inline static int GC_test_and_set(volatile unsigned int *addr) {
- int oldval;
- int temp = 1; /* locked value */
-
- __asm__ __volatile__(
- "1:\tlwarx %0,0,%3\n" /* load and reserve */
- "\tcmpwi %0, 0\n" /* if load is */
- "\tbne 2f\n" /* non-zero, return already set */
- "\tstwcx. %2,0,%1\n" /* else store conditional */
- "\tbne- 1b\n" /* retry if lost reservation */
- "\tsync\n" /* import barrier */
- "2:\t\n" /* oldval is zero if we set */
- : "=&r"(oldval), "=p"(addr)
- : "r"(temp), "1"(addr)
- : "cr0","memory");
- return oldval;
- }
-# define GC_TEST_AND_SET_DEFINED
- inline static void GC_clear(volatile unsigned int *addr) {
- __asm__ __volatile__("lwsync" : : : "memory");
- *(addr) = 0;
- }
-# define GC_CLEAR_DEFINED
-# endif
-# if defined(ALPHA)
- inline static int GC_test_and_set(volatile unsigned int * addr)
- {
- unsigned long oldvalue;
- unsigned long temp;
-
- __asm__ __volatile__(
- "1: ldl_l %0,%1\n"
- " and %0,%3,%2\n"
- " bne %2,2f\n"
- " xor %0,%3,%0\n"
- " stl_c %0,%1\n"
-# ifdef __ELF__
- " beq %0,3f\n"
-# else
- " beq %0,1b\n"
-# endif
- " mb\n"
- "2:\n"
-# ifdef __ELF__
- ".section .text2,\"ax\"\n"
- "3: br 1b\n"
- ".previous"
-# endif
- :"=&r" (temp), "=m" (*addr), "=&r" (oldvalue)
- :"Ir" (1), "m" (*addr)
- :"memory");
- return oldvalue;
- }
-# define GC_TEST_AND_SET_DEFINED
- inline static void GC_clear(volatile unsigned int *addr) {
- __asm__ __volatile__("mb" : : : "memory");
- *(addr) = 0;
- }
-# define GC_CLEAR_DEFINED
-# endif /* ALPHA */
-# ifdef ARM32
- inline static int GC_test_and_set(volatile unsigned int *addr) {
- int oldval;
- /* SWP on ARM is very similar to XCHG on x86. Doesn't lock the
- * bus because there are no SMP ARM machines. If/when there are,
- * this code will likely need to be updated. */
- /* See linuxthreads/sysdeps/arm/pt-machine.h in glibc-2.1 */
- __asm__ __volatile__("swp %0, %1, [%2]"
- : "=r"(oldval)
- : "r"(1), "r"(addr)
- : "memory");
- return oldval;
- }
-# define GC_TEST_AND_SET_DEFINED
-# endif /* ARM32 */
-# ifdef CRIS
- inline static int GC_test_and_set(volatile unsigned int *addr) {
- /* Ripped from linuxthreads/sysdeps/cris/pt-machine.h. */
- /* Included with Hans-Peter Nilsson's permission. */
- register unsigned long int ret;
-
- /* Note the use of a dummy output of *addr to expose the write.
- * The memory barrier is to stop *other* writes being moved past
- * this code.
- */
- __asm__ __volatile__("clearf\n"
- "0:\n\t"
- "movu.b [%2],%0\n\t"
- "ax\n\t"
- "move.b %3,[%2]\n\t"
- "bwf 0b\n\t"
- "clearf"
- : "=&r" (ret), "=m" (*addr)
- : "r" (addr), "r" ((int) 1), "m" (*addr)
- : "memory");
- return ret;
- }
-# define GC_TEST_AND_SET_DEFINED
-# endif /* CRIS */
-# ifdef S390
- inline static int GC_test_and_set(volatile unsigned int *addr) {
- int ret;
- __asm__ __volatile__ (
- " l %0,0(%2)\n"
- "0: cs %0,%1,0(%2)\n"
- " jl 0b"
- : "=&d" (ret)
- : "d" (1), "a" (addr)
- : "cc", "memory");
- return ret;
- }
-# endif
-# endif /* __GNUC__ */
-# if (defined(ALPHA) && !defined(__GNUC__))
-# ifndef OSF1
- --> We currently assume that if gcc is not used, we are
- --> running under Tru64.
-# endif
-# include <machine/builtins.h>
-# include <c_asm.h>
-# define GC_test_and_set(addr) __ATOMIC_EXCH_LONG(addr, 1)
-# define GC_TEST_AND_SET_DEFINED
-# define GC_clear(addr) { asm("mb"); *(volatile unsigned *)addr = 0; }
-# define GC_CLEAR_DEFINED
-# endif
-# if defined(MSWIN32)
-# define GC_test_and_set(addr) InterlockedExchange((LPLONG)addr,1)
-# define GC_TEST_AND_SET_DEFINED
-# endif
-# ifdef MIPS
-# ifdef LINUX
-# include <sys/tas.h>
-# define GC_test_and_set(addr) _test_and_set((int *) addr,1)
-# define GC_TEST_AND_SET_DEFINED
-# elif __mips < 3 || !(defined (_ABIN32) || defined(_ABI64)) \
- || !defined(_COMPILER_VERSION) || _COMPILER_VERSION < 700
-# ifdef __GNUC__
-# define GC_test_and_set(addr) _test_and_set((void *)addr,1)
-# else
-# define GC_test_and_set(addr) test_and_set((void *)addr,1)
-# endif
-# else
-# define GC_test_and_set(addr) __test_and_set32((void *)addr,1)
-# define GC_clear(addr) __lock_release(addr);
-# define GC_CLEAR_DEFINED
-# endif
-# define GC_TEST_AND_SET_DEFINED
-# endif /* MIPS */
-# if defined(_AIX)
-# include <sys/atomic_op.h>
-# if (defined(_POWER) || defined(_POWERPC))
-# if defined(__GNUC__)
- inline static void GC_memsync() {
- __asm__ __volatile__ ("sync" : : : "memory");
- }
-# else
-# ifndef inline
-# define inline __inline
-# endif
-# pragma mc_func GC_memsync { \
- "7c0004ac" /* sync (same opcode used for dcs)*/ \
- }
-# endif
-# else
-# error dont know how to memsync
-# endif
- inline static int GC_test_and_set(volatile unsigned int * addr) {
- int oldvalue = 0;
- if (compare_and_swap((void *)addr, &oldvalue, 1)) {
- GC_memsync();
- return 0;
- } else return 1;
- }
-# define GC_TEST_AND_SET_DEFINED
- inline static void GC_clear(volatile unsigned int *addr) {
- GC_memsync();
- *(addr) = 0;
- }
-# define GC_CLEAR_DEFINED
-
-# endif
-# if 0 /* defined(HP_PA) */
- /* The official recommendation seems to be to not use ldcw from */
- /* user mode. Since multithreaded incremental collection doesn't */
- /* work anyway on HP_PA, this shouldn't be a major loss. */
-
- /* "set" means 0 and "clear" means 1 here. */
-# define GC_test_and_set(addr) !GC_test_and_clear(addr);
-# define GC_TEST_AND_SET_DEFINED
-# define GC_clear(addr) GC_noop1((word)(addr)); *(volatile unsigned int *)addr = 1;
- /* The above needs a memory barrier! */
-# define GC_CLEAR_DEFINED
-# endif
-# if defined(GC_TEST_AND_SET_DEFINED) && !defined(GC_CLEAR_DEFINED)
-# ifdef __GNUC__
- inline static void GC_clear(volatile unsigned int *addr) {
- /* Try to discourage gcc from moving anything past this. */
- __asm__ __volatile__(" " : : : "memory");
- *(addr) = 0;
- }
-# else
- /* The function call in the following should prevent the */
- /* compiler from moving assignments to below the UNLOCK. */
-# define GC_clear(addr) GC_noop1((word)(addr)); \
- *((volatile unsigned int *)(addr)) = 0;
-# endif
-# define GC_CLEAR_DEFINED
-# endif /* !GC_CLEAR_DEFINED */
-
-# if !defined(GC_TEST_AND_SET_DEFINED)
+# if !defined(AO_have_test_and_set_acquire)
# define USE_PTHREAD_LOCKS
# endif
-# if defined(GC_PTHREADS) && !defined(GC_SOLARIS_THREADS) \
- && !defined(GC_IRIX_THREADS) && !defined(GC_WIN32_THREADS)
+
+# if defined(GC_PTHREADS) \
+ && !defined(GC_IRIX_THREADS) && !defined(GC_WIN32_THREADS)
# define NO_THREAD (pthread_t)(-1)
# include <pthread.h>
-# if defined(PARALLEL_MARK)
- /* We need compare-and-swap to update mark bits, where it's */
- /* performance critical. If USE_MARK_BYTES is defined, it is */
- /* no longer needed for this purpose. However we use it in */
- /* either case to implement atomic fetch-and-add, though that's */
- /* less performance critical, and could perhaps be done with */
- /* a lock. */
-# if defined(GENERIC_COMPARE_AND_SWAP)
- /* Probably not useful, except for debugging. */
- /* We do use GENERIC_COMPARE_AND_SWAP on PA_RISC, but we */
- /* minimize its use. */
- extern pthread_mutex_t GC_compare_and_swap_lock;
-
- /* Note that if GC_word updates are not atomic, a concurrent */
- /* reader should acquire GC_compare_and_swap_lock. On */
- /* currently supported platforms, such updates are atomic. */
- extern GC_bool GC_compare_and_exchange(volatile GC_word *addr,
- GC_word old, GC_word new_val);
-# endif /* GENERIC_COMPARE_AND_SWAP */
-# if defined(I386)
-# if !defined(GENERIC_COMPARE_AND_SWAP)
- /* Returns TRUE if the comparison succeeded. */
- inline static GC_bool GC_compare_and_exchange(volatile GC_word *addr,
- GC_word old,
- GC_word new_val)
- {
- char result;
- __asm__ __volatile__("lock; cmpxchgl %2, %0; setz %1"
- : "+m"(*(addr)), "=r"(result)
- : "r" (new_val), "a"(old) : "memory");
- return (GC_bool) result;
- }
-# endif /* !GENERIC_COMPARE_AND_SWAP */
- inline static void GC_memory_barrier()
- {
- /* We believe the processor ensures at least processor */
- /* consistent ordering. Thus a compiler barrier */
- /* should suffice. */
- __asm__ __volatile__("" : : : "memory");
- }
-# endif /* I386 */
-
-# if defined(POWERPC)
-# if !defined(GENERIC_COMPARE_AND_SWAP)
- /* Returns TRUE if the comparison succeeded. */
- inline static GC_bool GC_compare_and_exchange(volatile GC_word *addr,
- GC_word old, GC_word new_val)
- {
- int result, dummy;
- __asm__ __volatile__(
- "1:\tlwarx %0,0,%5\n"
- "\tcmpw %0,%4\n"
- "\tbne 2f\n"
- "\tstwcx. %3,0,%2\n"
- "\tbne- 1b\n"
- "\tsync\n"
- "\tli %1, 1\n"
- "\tb 3f\n"
- "2:\tli %1, 0\n"
- "3:\t\n"
- : "=&r" (dummy), "=r" (result), "=p" (addr)
- : "r" (new_val), "r" (old), "2"(addr)
- : "cr0","memory");
- return (GC_bool) result;
- }
-# endif /* !GENERIC_COMPARE_AND_SWAP */
- inline static void GC_memory_barrier()
- {
- __asm__ __volatile__("sync" : : : "memory");
- }
-# endif /* POWERPC */
-
-# if defined(IA64)
-# if !defined(GENERIC_COMPARE_AND_SWAP)
- inline static GC_bool GC_compare_and_exchange(volatile GC_word *addr,
- GC_word old, GC_word new_val)
- {
- unsigned long oldval;
- __asm__ __volatile__("mov ar.ccv=%4 ;; cmpxchg8.rel %0=%1,%2,ar.ccv"
- : "=r"(oldval), "=m"(*addr)
- : "r"(new_val), "1"(*addr), "r"(old) : "memory");
- return (oldval == old);
- }
-# endif /* !GENERIC_COMPARE_AND_SWAP */
-# if 0
- /* Shouldn't be needed; we use volatile stores instead. */
- inline static void GC_memory_barrier()
- {
- __asm__ __volatile__("mf" : : : "memory");
- }
-# endif /* 0 */
-# endif /* IA64 */
-# if defined(ALPHA)
-# if !defined(GENERIC_COMPARE_AND_SWAP)
-# if defined(__GNUC__)
- inline static GC_bool GC_compare_and_exchange(volatile GC_word *addr,
- GC_word old, GC_word new_val)
- {
- unsigned long was_equal;
- unsigned long temp;
-
- __asm__ __volatile__(
- "1: ldq_l %0,%1\n"
- " cmpeq %0,%4,%2\n"
- " mov %3,%0\n"
- " beq %2,2f\n"
- " stq_c %0,%1\n"
- " beq %0,1b\n"
- "2:\n"
- " mb\n"
- :"=&r" (temp), "=m" (*addr), "=&r" (was_equal)
- : "r" (new_val), "Ir" (old)
- :"memory");
- return was_equal;
- }
-# else /* !__GNUC__ */
- inline static GC_bool GC_compare_and_exchange(volatile GC_word *addr,
- GC_word old, GC_word new_val)
- {
- return __CMP_STORE_QUAD(addr, old, new_val, addr);
- }
-# endif /* !__GNUC__ */
-# endif /* !GENERIC_COMPARE_AND_SWAP */
-# ifdef __GNUC__
- inline static void GC_memory_barrier()
- {
- __asm__ __volatile__("mb" : : : "memory");
- }
-# else
-# define GC_memory_barrier() asm("mb")
-# endif /* !__GNUC__ */
-# endif /* ALPHA */
-# if defined(S390)
-# if !defined(GENERIC_COMPARE_AND_SWAP)
- inline static GC_bool GC_compare_and_exchange(volatile C_word *addr,
- GC_word old, GC_word new_val)
- {
- int retval;
- __asm__ __volatile__ (
-# ifndef __s390x__
- " cs %1,%2,0(%3)\n"
-# else
- " csg %1,%2,0(%3)\n"
-# endif
- " ipm %0\n"
- " srl %0,28\n"
- : "=&d" (retval), "+d" (old)
- : "d" (new_val), "a" (addr)
- : "cc", "memory");
- return retval == 0;
- }
-# endif
-# endif
-# if !defined(GENERIC_COMPARE_AND_SWAP)
- /* Returns the original value of *addr. */
- inline static GC_word GC_atomic_add(volatile GC_word *addr,
- GC_word how_much)
- {
- GC_word old;
- do {
- old = *addr;
- } while (!GC_compare_and_exchange(addr, old, old+how_much));
- return old;
- }
-# else /* GENERIC_COMPARE_AND_SWAP */
- /* So long as a GC_word can be atomically updated, it should */
- /* be OK to read *addr without a lock. */
- extern GC_word GC_atomic_add(volatile GC_word *addr, GC_word how_much);
-# endif /* GENERIC_COMPARE_AND_SWAP */
-
-# endif /* PARALLEL_MARK */
# if !defined(THREAD_LOCAL_ALLOC) && !defined(USE_PTHREAD_LOCKS)
/* In the THREAD_LOCAL_ALLOC case, the allocation lock tends to */
@@ -556,74 +99,64 @@
/* Allocation lock holder. Only set if acquired by client through */
/* GC_call_with_alloc_lock. */
# ifdef GC_ASSERTIONS
-# define LOCK() \
- { if (GC_test_and_set(&GC_allocate_lock)) GC_lock(); \
+# define UNCOND_LOCK() \
+ { if (AO_test_and_set_acquire(&GC_allocate_lock)) GC_lock(); \
SET_LOCK_HOLDER(); }
-# define UNLOCK() \
+# define UNCOND_UNLOCK() \
{ GC_ASSERT(I_HOLD_LOCK()); UNSET_LOCK_HOLDER(); \
- GC_clear(&GC_allocate_lock); }
+ AO_CLEAR(&GC_allocate_lock); }
# else
-# define LOCK() \
- { if (GC_test_and_set(&GC_allocate_lock)) GC_lock(); }
-# define UNLOCK() \
- GC_clear(&GC_allocate_lock)
+# define UNCOND_LOCK() \
+ { if (AO_test_and_set_acquire(&GC_allocate_lock)) GC_lock(); }
+# define UNCOND_UNLOCK() \
+ AO_CLEAR(&GC_allocate_lock)
# endif /* !GC_ASSERTIONS */
-# if 0
- /* Another alternative for OSF1 might be: */
-# include <sys/mman.h>
- extern msemaphore GC_allocate_semaphore;
-# define LOCK() { if (msem_lock(&GC_allocate_semaphore, MSEM_IF_NOWAIT) \
- != 0) GC_lock(); else GC_allocate_lock = 1; }
- /* The following is INCORRECT, since the memory model is too weak. */
- /* Is this true? Presumably msem_unlock has the right semantics? */
- /* - HB */
-# define UNLOCK() { GC_allocate_lock = 0; \
- msem_unlock(&GC_allocate_semaphore, 0); }
-# endif /* 0 */
# else /* THREAD_LOCAL_ALLOC || USE_PTHREAD_LOCKS */
# ifndef USE_PTHREAD_LOCKS
# define USE_PTHREAD_LOCKS
# endif
-# endif /* THREAD_LOCAL_ALLOC */
-# ifdef USE_PTHREAD_LOCKS
+# endif /* THREAD_LOCAL_ALLOC || USE_PTHREAD_LOCK */
+# ifdef USE_PTHREAD_LOCKS
# include <pthread.h>
extern pthread_mutex_t GC_allocate_ml;
# ifdef GC_ASSERTIONS
-# define LOCK() \
+# define UNCOND_LOCK() \
{ GC_lock(); \
SET_LOCK_HOLDER(); }
-# define UNLOCK() \
+# define UNCOND_UNLOCK() \
{ GC_ASSERT(I_HOLD_LOCK()); UNSET_LOCK_HOLDER(); \
pthread_mutex_unlock(&GC_allocate_ml); }
# else /* !GC_ASSERTIONS */
# if defined(NO_PTHREAD_TRYLOCK)
-# define LOCK() GC_lock();
+# define UNCOND_LOCK() GC_lock();
# else /* !defined(NO_PTHREAD_TRYLOCK) */
-# define LOCK() \
+# define UNCOND_LOCK() \
{ if (0 != pthread_mutex_trylock(&GC_allocate_ml)) GC_lock(); }
# endif
-# define UNLOCK() pthread_mutex_unlock(&GC_allocate_ml)
+# define UNCOND_UNLOCK() pthread_mutex_unlock(&GC_allocate_ml)
# endif /* !GC_ASSERTIONS */
-# endif /* USE_PTHREAD_LOCKS */
-# define SET_LOCK_HOLDER() GC_lock_holder = pthread_self()
-# define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD
-# define I_HOLD_LOCK() (pthread_equal(GC_lock_holder, pthread_self()))
- extern VOLATILE GC_bool GC_collecting;
-# define ENTER_GC() GC_collecting = 1;
-# define EXIT_GC() GC_collecting = 0;
- extern void GC_lock(void);
- extern pthread_t GC_lock_holder;
-# ifdef GC_ASSERTIONS
+# endif /* USE_PTHREAD_LOCKS */
+# define SET_LOCK_HOLDER() GC_lock_holder = pthread_self()
+# define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD
+# define I_HOLD_LOCK() (!GC_need_to_lock \
+ || pthread_equal(GC_lock_holder, pthread_self()))
+ extern volatile GC_bool GC_collecting;
+# define ENTER_GC() GC_collecting = 1;
+# define EXIT_GC() GC_collecting = 0;
+ extern void GC_lock(void);
+ extern pthread_t GC_lock_holder;
+# ifdef GC_ASSERTIONS
extern pthread_t GC_mark_lock_holder;
-# endif
+# endif
# endif /* GC_PTHREADS with linux_threads.c implementation */
+
# if defined(GC_IRIX_THREADS)
# include <pthread.h>
/* This probably should never be included, but I can't test */
/* on Irix anymore. */
# include <mutex.h>
- extern volatile unsigned int GC_allocate_lock;
+ extern volatile AO_TS_t GC_allocate_lock;
/* This is not a mutex because mutexes that obey the (optional) */
/* POSIX scheduling rules are subject to convoys in high contention */
/* applications. This is basically a spin lock. */
@@ -635,26 +168,28 @@
# define NO_THREAD (pthread_t)(-1)
# define UNSET_LOCK_HOLDER() GC_lock_holder = NO_THREAD
# define I_HOLD_LOCK() (pthread_equal(GC_lock_holder, pthread_self()))
-# define LOCK() { if (GC_test_and_set(&GC_allocate_lock)) GC_lock(); }
-# define UNLOCK() GC_clear(&GC_allocate_lock);
- extern VOLATILE GC_bool GC_collecting;
+# define UNCOND_LOCK() { if (AO_test_and_set_acquire(&GC_allocate_lock)) \
+ GC_lock(); }
+# define UNCOND_UNLOCK() AO_CLEAR(&GC_allocate_lock);
+ extern volatile GC_bool GC_collecting;
# define ENTER_GC() \
{ \
GC_collecting = 1; \
}
# define EXIT_GC() GC_collecting = 0;
# endif /* GC_IRIX_THREADS */
+
# if defined(GC_WIN32_THREADS)
# if defined(GC_PTHREADS)
# include <pthread.h>
extern pthread_mutex_t GC_allocate_ml;
-# define LOCK() pthread_mutex_lock(&GC_allocate_ml)
-# define UNLOCK() pthread_mutex_unlock(&GC_allocate_ml)
+# define UNCOND_LOCK() pthread_mutex_lock(&GC_allocate_ml)
+# define UNCOND_UNLOCK() pthread_mutex_unlock(&GC_allocate_ml)
# else
# include <windows.h>
GC_API CRITICAL_SECTION GC_allocate_ml;
-# define LOCK() EnterCriticalSection(&GC_allocate_ml);
-# define UNLOCK() LeaveCriticalSection(&GC_allocate_ml);
+# define UNCOND_LOCK() EnterCriticalSection(&GC_allocate_ml);
+# define UNCOND_UNLOCK() LeaveCriticalSection(&GC_allocate_ml);
# endif
# endif
# ifndef SET_LOCK_HOLDER
@@ -668,6 +203,14 @@
# define LOCK()
# define UNLOCK()
# endif /* !THREADS */
+
+#if defined(UNCOND_LOCK) && !defined(LOCK)
+ extern GC_bool GC_need_to_lock;
+ /* At least two thread running; need to lock. */
+# define LOCK() if (GC_need_to_lock) { UNCOND_LOCK(); }
+# define UNLOCK() if (GC_need_to_lock) { UNCOND_UNLOCK(); }
+#endif
+
# ifndef SET_LOCK_HOLDER
# define SET_LOCK_HOLDER()
# define UNSET_LOCK_HOLDER()
@@ -675,6 +218,7 @@
/* Used on platforms were locks can be reacquired, */
/* so it doesn't matter if we lie. */
# endif
+
# ifndef ENTER_GC
# define ENTER_GC()
# define EXIT_GC()
@@ -683,6 +227,7 @@
# ifndef DCL_LOCK_STATE
# define DCL_LOCK_STATE
# endif
+
# ifndef FASTLOCK
# define FASTLOCK() LOCK()
# define FASTLOCK_SUCCEEDED() TRUE
diff --git a/include/private/gc_pmark.h b/include/private/gc_pmark.h
index 5198191..03d3af1 100644
--- a/include/private/gc_pmark.h
+++ b/include/private/gc_pmark.h
@@ -60,18 +60,18 @@ extern word GC_n_mark_procs;
#define GC_MARK_STACK_DISCARDS (INITIAL_MARK_STACK_SIZE/8)
typedef struct GC_ms_entry {
- GC_word * mse_start; /* First word of object */
+ ptr_t mse_start; /* First word of object */
GC_word mse_descr; /* Descriptor; low order two bits are tags, */
/* identifying the upper 30 bits as one of the */
/* following: */
} mse;
-extern word GC_mark_stack_size;
+extern size_t GC_mark_stack_size;
extern mse * GC_mark_stack_limit;
#ifdef PARALLEL_MARK
- extern mse * VOLATILE GC_mark_stack_top;
+ extern mse * volatile GC_mark_stack_top;
#else
extern mse * GC_mark_stack_top;
#endif
@@ -117,11 +117,6 @@ extern mse * GC_mark_stack;
/* once it returns to 0, it */
/* stays zero for the cycle. */
/* GC_mark_stack_top is also protected by mark lock. */
- extern mse * VOLATILE GC_first_nonempty;
- /* Lowest entry on mark stack */
- /* that may be nonempty. */
- /* Updated only by initiating */
- /* thread. */
/*
* GC_notify_all_marker() is used when GC_help_wanted is first set,
* when the last helper becomes inactive,
@@ -134,21 +129,9 @@ extern mse * GC_mark_stack;
/* Return a pointer to within 1st page of object. */
/* Set *new_hdr_p to corr. hdr. */
-#ifdef __STDC__
- ptr_t GC_find_start(ptr_t current, hdr *hhdr, hdr **new_hdr_p);
-#else
- ptr_t GC_find_start();
-#endif
-
-mse * GC_signal_mark_stack_overflow GC_PROTO((mse *msp));
+ptr_t GC_find_start(ptr_t current, hdr *hhdr, hdr **new_hdr_p);
-# ifdef GATHERSTATS
-# define ADD_TO_ATOMIC(sz) GC_atomic_in_use += (sz)
-# define ADD_TO_COMPOSITE(sz) GC_composite_in_use += (sz)
-# else
-# define ADD_TO_ATOMIC(sz)
-# define ADD_TO_COMPOSITE(sz)
-# endif
+mse * GC_signal_mark_stack_overflow(mse *msp);
/* Push the object obj with corresponding heap block header hhdr onto */
/* the mark stack. */
@@ -156,10 +139,7 @@ mse * GC_signal_mark_stack_overflow GC_PROTO((mse *msp));
{ \
register word _descr = (hhdr) -> hb_descr; \
\
- if (_descr == 0) { \
- ADD_TO_ATOMIC((hhdr) -> hb_sz); \
- } else { \
- ADD_TO_COMPOSITE((hhdr) -> hb_sz); \
+ if (_descr != 0) { \
mark_stack_top++; \
if (mark_stack_top >= mark_stack_limit) { \
mark_stack_top = GC_signal_mark_stack_overflow(mark_stack_top); \
@@ -177,94 +157,207 @@ mse * GC_signal_mark_stack_overflow GC_PROTO((mse *msp));
source, exit_label) \
{ \
hdr * my_hhdr; \
- ptr_t my_current = current; \
- \
- GET_HDR(my_current, my_hhdr); \
- if (IS_FORWARDING_ADDR_OR_NIL(my_hhdr)) { \
- hdr * new_hdr = GC_invalid_header; \
- my_current = GC_find_start(my_current, my_hhdr, &new_hdr); \
- my_hhdr = new_hdr; \
- } \
- PUSH_CONTENTS_HDR(my_current, mark_stack_top, mark_stack_limit, \
- source, exit_label, my_hhdr); \
-exit_label: ; \
-}
-
-/* As above, but use header cache for header lookup. */
-# define HC_PUSH_CONTENTS(current, mark_stack_top, mark_stack_limit, \
- source, exit_label) \
-{ \
- hdr * my_hhdr; \
- ptr_t my_current = current; \
\
- HC_GET_HDR(my_current, my_hhdr, source); \
- PUSH_CONTENTS_HDR(my_current, mark_stack_top, mark_stack_limit, \
- source, exit_label, my_hhdr); \
+ HC_GET_HDR(current, my_hhdr, source, exit_label); \
+ PUSH_CONTENTS_HDR(current, mark_stack_top, mark_stack_limit, \
+ source, exit_label, my_hhdr, TRUE); \
exit_label: ; \
}
/* Set mark bit, exit if it was already set. */
-# ifdef USE_MARK_BYTES
- /* Unlike the mark bit case, there is a race here, and we may set */
- /* the bit twice in the concurrent case. This can result in the */
- /* object being pushed twice. But that's only a performance issue. */
-# define SET_MARK_BIT_EXIT_IF_SET(hhdr,displ,exit_label) \
+# ifdef USE_MARK_BITS
+/* FIXME: untested */
+# if defined(THREADS)
+ /* Introduces a benign race as in the byte case. */
+# define OR_WORD_EXIT_IF_SET(addr, mask, label) \
+ if (!(*(addr) & (mask))) { \
+ AO_or((AO_t *)(addr), (mask); \
+ } else { \
+ goto label; \
+ }
+# else /* !THREADS */
+# define OR_WORD_EXIT_IF_SET(addr, mask, label) \
+ if (!(*(addr) & (mask))) { \
+ *(addr) |= (mask); \
+ } else { \
+ goto label; \
+ }
+# endif
+# define SET_MARK_BIT_EXIT_IF_SET(hhdr,bit_no,exit_label) \
{ \
- register VOLATILE char * mark_byte_addr = \
- hhdr -> hb_marks + ((displ) >> 1); \
- register char mark_byte = *mark_byte_addr; \
+ word * mark_word_addr = hhdr -> hb_marks + divWORDSZ(bit_no); \
+ \
+ OR_WORD_EXIT_IF_SET(mark_word_addr, (word)1 << modWORDSZ(bit_no), \
+ exit_label); \
+ }
+# endif
+
+
+#if defined(I386) && defined(__GNUC__)
+# define LONG_MULT(hprod, lprod, x, y) { \
+ asm("mull %2" : "=a"(lprod), "=d"(hprod) : "g"(y), "0"(x)); \
+ }
+#else /* No in-line X86 assembly code */
+# define LONG_MULT(hprod, lprod, x, y) { \
+ unsigned long long prod = (unsigned long long)x \
+ * (unsigned long long)y; \
+ hprod = prod >> 32; \
+ lprod = (unsigned32)prod; \
+ }
+#endif
+
+ /* There is a race here, and we may set */
+ /* the bit twice in the concurrent case. This can result in the */
+ /* object being pushed twice. But that's only a performance issue. */
+# define SET_MARK_BIT_EXIT_IF_SET(hhdr,bit_no,exit_label) \
+ { \
+ char * mark_byte_addr = (char *)hhdr -> hb_marks + (bit_no); \
+ char mark_byte = *mark_byte_addr; \
\
if (mark_byte) goto exit_label; \
*mark_byte_addr = 1; \
}
-# else
-# define SET_MARK_BIT_EXIT_IF_SET(hhdr,displ,exit_label) \
- { \
- register word * mark_word_addr = hhdr -> hb_marks + divWORDSZ(displ); \
- \
- OR_WORD_EXIT_IF_SET(mark_word_addr, (word)1 << modWORDSZ(displ), \
- exit_label); \
- }
-# endif /* USE_MARK_BYTES */
+#ifdef PARALLEL_MARK
+# define INCR_MARKS(hhdr) \
+ AO_store(&(hhdr -> hb_n_marks), AO_load(&(hhdr -> hb_n_marks))+1);
+#else
+# define INCR_MARKS(hhdr) ++(hhdr -> hb_n_marks)
+#endif
+
+#ifdef ENABLE_TRACE
+# define TRACE(source, cmd) \
+ if (GC_trace_addr != 0 && (ptr_t)(source) == GC_trace_addr) cmd
+# define TRACE_TARGET(target, cmd) \
+ if (GC_trace_addr != 0 && (target) == *(ptr_t *)GC_trace_addr) cmd
+#else
+# define TRACE(source, cmd)
+# define TRACE_TARGET(source, cmd)
+#endif
/* If the mark bit corresponding to current is not set, set it, and */
-/* push the contents of the object on the mark stack. For a small */
-/* object we assume that current is the (possibly interior) pointer */
-/* to the object. For large objects we assume that current points */
-/* to somewhere inside the first page of the object. If */
-/* GC_all_interior_pointers is set, it may have been previously */
-/* adjusted to make that true. */
+/* push the contents of the object on the mark stack. Current points */
+/* to the bginning of the object. We rely on the fact that the */
+/* preceding header calculation will succeed for a pointer past the */
+/* forst page of an object, only if it is in fact a valid pointer */
+/* to the object. Thus we can omit the otherwise necessary tests */
+/* here. Note in particular tha the "displ" value is the displacement */
+/* from the beggining of the heap block, which may itself be in the */
+/* interior of a large object. */
+#ifdef MARK_BIT_PER_GRANULE
# define PUSH_CONTENTS_HDR(current, mark_stack_top, mark_stack_limit, \
- source, exit_label, hhdr) \
+ source, exit_label, hhdr, do_offset_check) \
{ \
- int displ; /* Displacement in block; first bytes, then words */ \
- int map_entry; \
- \
- displ = HBLKDISPL(current); \
- map_entry = MAP_ENTRY((hhdr -> hb_map), displ); \
- displ = BYTES_TO_WORDS(displ); \
- if (map_entry > CPP_MAX_OFFSET) { \
- if (map_entry == OFFSET_TOO_BIG) { \
- map_entry = displ % (hhdr -> hb_sz); \
- displ -= map_entry; \
- if (displ + (hhdr -> hb_sz) > BYTES_TO_WORDS(HBLKSIZE)) { \
- GC_ADD_TO_BLACK_LIST_NORMAL((word)current, source); \
+ size_t displ = HBLKDISPL(current); /* Displacement in block; in bytes. */\
+ /* displ is always within range. If current doesn't point to */ \
+ /* first block, then we are in the all_interior_pointers case, and */ \
+ /* it is safe to use any displacement value. */ \
+ size_t gran_displ = BYTES_TO_GRANULES(displ); \
+ size_t gran_offset = hhdr -> hb_map[gran_displ]; \
+ size_t byte_offset = displ & (GRANULE_BYTES - 1); \
+ ptr_t base = current; \
+ /* The following always fails for large block references. */ \
+ if (EXPECT((gran_offset | byte_offset) != 0, FALSE)) { \
+ if (hhdr -> hb_large_block) { \
+ /* gran_offset is bogus. */ \
+ size_t obj_displ; \
+ base = (ptr_t)(hhdr -> hb_block); \
+ obj_displ = (ptr_t)(current) - base; \
+ if (obj_displ != displ) { \
+ GC_ASSERT(obj_displ < hhdr -> hb_sz); \
+ /* Must be in all_interior_pointer case, not first block */ \
+ /* already did validity check on cache miss. */ \
+ ; \
+ } else { \
+ if (do_offset_check && !GC_valid_offsets[obj_displ]) { \
+ GC_ADD_TO_BLACK_LIST_NORMAL(current, source); \
+ goto exit_label; \
+ } \
+ } \
+ gran_displ = 0; \
+ GC_ASSERT(hhdr -> hb_sz > HBLKSIZE || \
+ hhdr -> hb_block == HBLKPTR(current)); \
+ GC_ASSERT((ptr_t)(hhdr -> hb_block) <= (ptr_t) current); \
+ } else { \
+ size_t obj_displ = GRANULES_TO_BYTES(gran_offset) \
+ + byte_offset; \
+ if (do_offset_check && !GC_valid_offsets[obj_displ]) { \
+ GC_ADD_TO_BLACK_LIST_NORMAL(current, source); \
goto exit_label; \
} \
+ gran_displ -= gran_offset; \
+ base -= obj_displ; \
+ } \
+ } \
+ GC_ASSERT(hhdr == GC_find_header(base)); \
+ GC_ASSERT(gran_displ % BYTES_TO_GRANULES(hhdr -> hb_sz) == 0); \
+ TRACE(source, GC_log_printf("GC:%d: passed validity tests\n",GC_gc_no)); \
+ SET_MARK_BIT_EXIT_IF_SET(hhdr, gran_displ, exit_label); \
+ TRACE(source, GC_log_printf("GC:%d: previously unmarked\n",GC_gc_no)); \
+ TRACE_TARGET(base, \
+ GC_log_printf("GC:%d: marking %p from %p instead\n", GC_gc_no, \
+ base, source)); \
+ INCR_MARKS(hhdr); \
+ GC_STORE_BACK_PTR((ptr_t)source, base); \
+ PUSH_OBJ(base, hhdr, mark_stack_top, mark_stack_limit); \
+}
+#endif /* MARK_BIT_PER_GRANULE */
+
+#ifdef MARK_BIT_PER_OBJ
+# define PUSH_CONTENTS_HDR(current, mark_stack_top, mark_stack_limit, \
+ source, exit_label, hhdr, do_offset_check) \
+{ \
+ size_t displ = HBLKDISPL(current); /* Displacement in block; in bytes. */\
+ unsigned32 low_prod, high_prod, offset_fraction; \
+ unsigned32 inv_sz = hhdr -> hb_inv_sz; \
+ ptr_t base = current; \
+ LONG_MULT(high_prod, low_prod, displ, inv_sz); \
+ /* product is > and within sz_in_bytes of displ * sz_in_bytes * 2**32 */ \
+ if (EXPECT(low_prod >> 16 != 0, FALSE)) { \
+ FIXME: fails if offset is a multiple of HBLKSIZE which becomes 0 \
+ if (inv_sz == LARGE_INV_SZ) { \
+ size_t obj_displ; \
+ base = (ptr_t)(hhdr -> hb_block); \
+ obj_displ = (ptr_t)(current) - base; \
+ if (obj_displ != displ) { \
+ GC_ASSERT(obj_displ < hhdr -> hb_sz); \
+ /* Must be in all_interior_pointer case, not first block */ \
+ /* already did validity check on cache miss. */ \
+ ; \
+ } else { \
+ if (do_offset_check && !GC_valid_offsets[obj_displ]) { \
+ GC_ADD_TO_BLACK_LIST_NORMAL(current, source); \
+ goto exit_label; \
+ } \
+ } \
+ GC_ASSERT(hhdr -> hb_sz > HBLKSIZE || \
+ hhdr -> hb_block == HBLKPTR(current)); \
+ GC_ASSERT((ptr_t)(hhdr -> hb_block) < (ptr_t) current); \
} else { \
- GC_ADD_TO_BLACK_LIST_NORMAL((word)current, source); goto exit_label; \
+ /* Accurate enough if HBLKSIZE <= 2**15. */ \
+ GC_ASSERT(HBLKSIZE <= (1 << 15)); \
+ size_t obj_displ = (((low_prod >> 16) + 1) * (hhdr -> hb_sz)) >> 16; \
+ if (do_offset_check && !GC_valid_offsets[obj_displ]) { \
+ GC_ADD_TO_BLACK_LIST_NORMAL(current, source); \
+ goto exit_label; \
+ } \
+ base -= obj_displ; \
} \
- } else { \
- displ -= map_entry; \
} \
- GC_ASSERT(displ >= 0 && displ < MARK_BITS_PER_HBLK); \
- SET_MARK_BIT_EXIT_IF_SET(hhdr, displ, exit_label); \
- GC_STORE_BACK_PTR((ptr_t)source, (ptr_t)HBLKPTR(current) \
- + WORDS_TO_BYTES(displ)); \
- PUSH_OBJ(((word *)(HBLKPTR(current)) + displ), hhdr, \
- mark_stack_top, mark_stack_limit) \
+ /* May get here for pointer to start of block not at */ \
+ /* beginning of object. If so, it's valid, and we're fine. */ \
+ GC_ASSERT(high_prod >= 0 && high_prod <= HBLK_OBJS(hhdr -> hb_sz)); \
+ TRACE(source, GC_log_printf("GC:%d: passed validity tests\n",GC_gc_no)); \
+ SET_MARK_BIT_EXIT_IF_SET(hhdr, high_prod, exit_label); \
+ TRACE(source, GC_log_printf("GC:%d: previously unmarked\n",GC_gc_no)); \
+ TRACE_TARGET(base, \
+ GC_log_printf("GC:%d: marking %p from %p instead\n", GC_gc_no, \
+ base, source)); \
+ INCR_MARKS(hhdr); \
+ GC_STORE_BACK_PTR((ptr_t)source, base); \
+ PUSH_OBJ(base, hhdr, mark_stack_top, mark_stack_limit); \
}
+#endif /* MARK_BIT_PER_OBJ */
#if defined(PRINT_BLACK_LIST) || defined(KEEP_BACK_PTRS)
# define PUSH_ONE_CHECKED_STACK(p, source) \
@@ -285,13 +378,13 @@ exit_label: ; \
# if NEED_FIXUP_POINTER
/* Try both the raw version and the fixed up one. */
# define GC_PUSH_ONE_STACK(p, source) \
- if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \
- && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \
+ if ((p) >= (ptr_t)GC_least_plausible_heap_addr \
+ && (p) < (ptr_t)GC_greatest_plausible_heap_addr) { \
PUSH_ONE_CHECKED_STACK(p, source); \
} \
FIXUP_POINTER(p); \
- if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \
- && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \
+ if ((p) >= (ptr_t)GC_least_plausible_heap_addr \
+ && (p) < (ptr_t)GC_greatest_plausible_heap_addr) { \
PUSH_ONE_CHECKED_STACK(p, source); \
}
# else /* !NEED_FIXUP_POINTER */
@@ -305,22 +398,22 @@ exit_label: ; \
/*
* As above, but interior pointer recognition as for
- * normal for heap pointers.
+ * normal heap pointers.
*/
# define GC_PUSH_ONE_HEAP(p,source) \
FIXUP_POINTER(p); \
- if ((ptr_t)(p) >= (ptr_t)GC_least_plausible_heap_addr \
- && (ptr_t)(p) < (ptr_t)GC_greatest_plausible_heap_addr) { \
+ if ((p) >= (ptr_t)GC_least_plausible_heap_addr \
+ && (p) < (ptr_t)GC_greatest_plausible_heap_addr) { \
GC_mark_stack_top = GC_mark_and_push( \
- (GC_PTR)(p), GC_mark_stack_top, \
- GC_mark_stack_limit, (GC_PTR *)(source)); \
+ (void *)(p), GC_mark_stack_top, \
+ GC_mark_stack_limit, (void * *)(source)); \
}
/* Mark starting at mark stack entry top (incl.) down to */
/* mark stack entry bottom (incl.). Stop after performing */
/* about one page worth of work. Return the new mark stack */
/* top entry. */
-mse * GC_mark_from GC_PROTO((mse * top, mse * bottom, mse *limit));
+mse * GC_mark_from(mse * top, mse * bottom, mse *limit);
#define MARK_FROM_MARK_STACK() \
GC_mark_stack_top = GC_mark_from(GC_mark_stack_top, \
diff --git a/include/private/gc_priv.h b/include/private/gc_priv.h
index e5bd52b..06d8a15 100644
--- a/include/private/gc_priv.h
+++ b/include/private/gc_priv.h
@@ -2,7 +2,7 @@
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
* Copyright (c) 1996-1999 by Silicon Graphics. All rights reserved.
- * Copyright (c) 1999-2001 by Hewlett-Packard Company. All rights reserved.
+ * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P.
*
*
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
@@ -19,17 +19,6 @@
# ifndef GC_PRIVATE_H
# define GC_PRIVATE_H
-#if defined(mips) && defined(SYSTYPE_BSD) && defined(sony_news)
- /* sony RISC NEWS, NEWSOS 4 */
-# define BSD_TIME
-/* typedef long ptrdiff_t; -- necessary on some really old systems */
-#endif
-
-#if defined(mips) && defined(SYSTYPE_BSD43)
- /* MIPS RISCOS 4 */
-# define BSD_TIME
-#endif
-
#ifdef DGUX
# include <sys/types.h>
# include <sys/time.h>
@@ -52,6 +41,7 @@
typedef GC_word word;
typedef GC_signed_word signed_word;
+typedef unsigned int unsigned32;
typedef int GC_bool;
# define TRUE 1
@@ -64,30 +54,27 @@ typedef char * ptr_t; /* A generic pointer to which we can add */
# ifndef GCCONFIG_H
# include "gcconfig.h"
+# ifndef USE_MARK_BYTES
+# define USE_MARK_BYTES
+# endif
# endif
# ifndef HEADERS_H
# include "gc_hdrs.h"
# endif
-#if defined(__STDC__)
-# include <stdlib.h>
-# if !(defined( sony_news ) )
-# include <stddef.h>
-# endif
-# define VOLATILE volatile
-#else
-# ifdef MSWIN32
-# include <stdlib.h>
-# endif
-# define VOLATILE
-#endif
+# include <stdlib.h>
+# if !(defined( sony_news ) )
+# include <stddef.h>
+# endif
-#if 0 /* defined(__GNUC__) doesn't work yet */
+#if __GNUC__ >= 3
# define EXPECT(expr, outcome) __builtin_expect(expr,outcome)
+# define INLINE inline
/* Equivalent to (expr), but predict that usually (expr)==outcome. */
#else
# define EXPECT(expr, outcome) (expr)
+# define INLINE
#endif /* __GNUC__ */
# ifndef GC_LOCKS_H
@@ -97,13 +84,13 @@ typedef char * ptr_t; /* A generic pointer to which we can add */
# ifdef STACK_GROWS_DOWN
# define COOLER_THAN >
# define HOTTER_THAN <
-# define MAKE_COOLER(x,y) if ((word)(x)+(y) > (word)(x)) {(x) += (y);} \
- else {(x) = (word)ONES;}
+# define MAKE_COOLER(x,y) if ((x)+(y) > (x)) {(x) += (y);} \
+ else {(x) = (ptr_t)ONES;}
# define MAKE_HOTTER(x,y) (x) -= (y)
# else
# define COOLER_THAN <
# define HOTTER_THAN >
-# define MAKE_COOLER(x,y) if ((word)(x)-(y) < (word)(x)) {(x) -= (y);} else {(x) = 0;}
+# define MAKE_COOLER(x,y) if ((x)-(y) < (x)) {(x) -= (y);} else {(x) = 0;}
# define MAKE_HOTTER(x,y) (x) += (y)
# endif
@@ -159,72 +146,15 @@ typedef char * ptr_t; /* A generic pointer to which we can add */
/* This is now really controlled at startup, */
/* through GC_all_interior_pointers. */
-#define PRINTSTATS /* Print garbage collection statistics */
- /* For less verbose output, undefine in reclaim.c */
-
-#define PRINTTIMES /* Print the amount of time consumed by each garbage */
- /* collection. */
-
-#define PRINTBLOCKS /* Print object sizes associated with heap blocks, */
- /* whether the objects are atomic or composite, and */
- /* whether or not the block was found to be empty */
- /* during the reclaim phase. Typically generates */
- /* about one screenful per garbage collection. */
-#undef PRINTBLOCKS
-
-#ifdef SILENT
-# ifdef PRINTSTATS
-# undef PRINTSTATS
-# endif
-# ifdef PRINTTIMES
-# undef PRINTTIMES
-# endif
-# ifdef PRINTNBLOCKS
-# undef PRINTNBLOCKS
-# endif
-#endif
-
-#if defined(PRINTSTATS) && !defined(GATHERSTATS)
-# define GATHERSTATS
-#endif
-
-#if defined(PRINTSTATS) || !defined(SMALL_CONFIG)
-# define CONDPRINT /* Print some things if GC_print_stats is set */
-#endif
#define GC_INVOKE_FINALIZERS() GC_notify_or_invoke_finalizers()
-#define MERGE_SIZES /* Round up some object sizes, so that fewer distinct */
- /* free lists are actually maintained. This applies */
- /* only to the top level routines in misc.c, not to */
- /* user generated code that calls GC_allocobj and */
- /* GC_allocaobj directly. */
- /* Slows down average programs slightly. May however */
- /* substantially reduce fragmentation if allocation */
- /* request sizes are widely scattered. */
- /* May save significant amounts of space for obj_map */
- /* entries. */
-
-#if defined(USE_MARK_BYTES) && !defined(ALIGN_DOUBLE)
-# define ALIGN_DOUBLE
- /* We use one byte for every 2 words, which doesn't allow for */
- /* odd numbered words to have mark bits. */
-#endif
-
-#if defined(GC_GCJ_SUPPORT) && ALIGNMENT < 8 && !defined(ALIGN_DOUBLE)
- /* GCJ's Hashtable synchronization code requires 64-bit alignment. */
-# define ALIGN_DOUBLE
-#endif
-
-/* ALIGN_DOUBLE requires MERGE_SIZES at present. */
-# if defined(ALIGN_DOUBLE) && !defined(MERGE_SIZES)
-# define MERGE_SIZES
-# endif
-
#if !defined(DONT_ADD_BYTE_AT_END)
# define EXTRA_BYTES GC_all_interior_pointers
+# define MAX_EXTRA_BYTES 1
#else
# define EXTRA_BYTES 0
+# define MAX_EXTRA_BYTES 0
#endif
@@ -263,9 +193,9 @@ typedef char * ptr_t; /* A generic pointer to which we can add */
/* Fill in the pc and argument information for up to NFRAMES of my */
/* callers. Ignore my frame and my callers frame. */
struct callinfo;
-void GC_save_callers GC_PROTO((struct callinfo info[NFRAMES]));
+void GC_save_callers(struct callinfo info[NFRAMES]);
-void GC_print_callers GC_PROTO((struct callinfo info[NFRAMES]));
+void GC_print_callers(struct callinfo info[NFRAMES]);
#endif
@@ -275,7 +205,7 @@ void GC_print_callers GC_PROTO((struct callinfo info[NFRAMES]));
# if NARGS > 0
word ci_arg[NARGS]; /* bit-wise complement to avoid retention */
# endif
-# if defined(ALIGN_DOUBLE) && (NFRAMES * (NARGS + 1)) % 2 == 1
+# if (NFRAMES * (NARGS + 1)) % 2 == 1
/* Likely alignment problem. */
word ci_dummy;
# endif
@@ -362,39 +292,8 @@ void GC_print_callers GC_PROTO((struct callinfo info[NFRAMES]));
# define BCOPY(x,y,n) memcpy(y, x, (size_t)(n))
# define BZERO(x,n) memset(x, 0, (size_t)(n))
# else
-# define BCOPY(x,y,n) bcopy((char *)(x),(char *)(y),(int)(n))
-# define BZERO(x,n) bzero((char *)(x),(int)(n))
-# endif
-
-/* Delay any interrupts or signals that may abort this thread. Data */
-/* structures are in a consistent state outside this pair of calls. */
-/* ANSI C allows both to be empty (though the standard isn't very */
-/* clear on that point). Standard malloc implementations are usually */
-/* neither interruptable nor thread-safe, and thus correspond to */
-/* empty definitions. */
-/* It probably doesn't make any sense to declare these to be nonempty */
-/* if the code is being optimized, since signal safety relies on some */
-/* ordering constraints that are typically not obeyed by optimizing */
-/* compilers. */
-# ifdef PCR
-# define DISABLE_SIGNALS() \
- PCR_Th_SetSigMask(PCR_allSigsBlocked,&GC_old_sig_mask)
-# define ENABLE_SIGNALS() \
- PCR_Th_SetSigMask(&GC_old_sig_mask, NIL)
-# else
-# if defined(THREADS) || defined(AMIGA) \
- || defined(MSWIN32) || defined(MSWINCE) || defined(MACOS) \
- || defined(DJGPP) || defined(NO_SIGNALS)
- /* Also useful for debugging. */
- /* Should probably use thr_sigsetmask for GC_SOLARIS_THREADS. */
-# define DISABLE_SIGNALS()
-# define ENABLE_SIGNALS()
-# else
-# define DISABLE_SIGNALS() GC_disable_signals()
- void GC_disable_signals();
-# define ENABLE_SIGNALS() GC_enable_signals()
- void GC_enable_signals();
-# endif
+# define BCOPY(x,y,n) bcopy((void *)(x),(void *)(y),(size_t)(n))
+# define BZERO(x,n) bzero((void *)(x),(size_t)(n))
# endif
/*
@@ -430,7 +329,7 @@ void GC_print_callers GC_PROTO((struct callinfo info[NFRAMES]));
# ifdef SMALL_CONFIG
# define ABORT(msg) abort();
# else
- GC_API void GC_abort GC_PROTO((GC_CONST char * msg));
+ GC_API void GC_abort(const char * msg);
# define ABORT(msg) GC_abort(msg);
# endif
# endif
@@ -491,12 +390,45 @@ extern GC_warn_proc GC_current_warn_proc;
# endif
#endif
+/* The first TINY_FREELISTS free lists correspond to the first */
+/* TINY_FREELISTS multiples of GRANULE_BYTES, i.e. we keep */
+/* separate free lists for each multiple of GRANULE_BYTES */
+/* up to (TINY_FREELISTS-1) * GRANULE_BYTES. After that they */
+/* may be spread out further. */
+#include "../gc_tiny_fl.h"
+#define GRANULE_BYTES GC_GRANULE_BYTES
+#define TINY_FREELISTS GC_TINY_FREELISTS
+
#define WORDSZ ((word)CPP_WORDSZ)
#define SIGNB ((word)1 << (WORDSZ-1))
#define BYTES_PER_WORD ((word)(sizeof (word)))
#define ONES ((word)(signed_word)(-1))
#define divWORDSZ(n) ((n) >> LOGWL) /* divide n by size of word */
+#if GRANULE_BYTES == 8
+# define BYTES_TO_GRANULES(n) ((n)>>3)
+# define GRANULES_TO_BYTES(n) ((n)<<3)
+# if CPP_WORDSZ == 64
+# define GRANULES_TO_WORDS(n) (n)
+# elif CPP_WORDSZ == 32
+# define GRANULES_TO_WORDS(n) ((n)<<1)
+# else
+# define GRANULES_TO_WORDS(n) BYTES_TO_WORDS(GRANULES_TO_BYTES(n))
+# endif
+#elif GRANULE_BYTES == 16
+# define BYTES_TO_GRANULES(n) ((n)>>4)
+# define GRANULES_TO_BYTES(n) ((n)<<4)
+# if CPP_WORDSZ == 64
+# define GRANULES_TO_WORDS(n) ((n)<<1)
+# elif CPP_WORDSZ == 32
+# define GRANULES_TO_WORDS(n) ((n)<<2)
+# else
+# define GRANULES_TO_WORDS(n) BYTES_TO_WORDS(GRANULES_TO_BYTES(n))
+# endif
+#else
+# error Bad GRANULE_BYTES value
+#endif
+
/*********************/
/* */
/* Size Parameters */
@@ -541,17 +473,20 @@ extern GC_warn_proc GC_current_warn_proc;
# undef HBLKSIZE
#endif
# define CPP_HBLKSIZE (1 << CPP_LOG_HBLKSIZE)
-# define LOG_HBLKSIZE ((word)CPP_LOG_HBLKSIZE)
-# define HBLKSIZE ((word)CPP_HBLKSIZE)
+# define LOG_HBLKSIZE ((size_t)CPP_LOG_HBLKSIZE)
+# define HBLKSIZE ((size_t)CPP_HBLKSIZE)
-/* max size objects supported by freelist (larger objects may be */
-/* allocated, but less efficiently) */
+/* max size objects supported by freelist (larger objects are */
+/* allocated directly with allchblk(), by rounding to the next */
+/* multiple of HBLKSIZE. */
#define CPP_MAXOBJBYTES (CPP_HBLKSIZE/2)
-#define MAXOBJBYTES ((word)CPP_MAXOBJBYTES)
-#define CPP_MAXOBJSZ BYTES_TO_WORDS(CPP_MAXOBJBYTES)
-#define MAXOBJSZ ((word)CPP_MAXOBJSZ)
+#define MAXOBJBYTES ((size_t)CPP_MAXOBJBYTES)
+#define CPP_MAXOBJWORDS BYTES_TO_WORDS(CPP_MAXOBJBYTES)
+#define MAXOBJWORDS ((size_t)CPP_MAXOBJWORDS)
+#define CPP_MAXOBJGRANULES BYTES_TO_GRANULES(CPP_MAXOBJBYTES)
+#define MAXOBJGRANULES ((size_t)CPP_MAXOBJGRANULES)
# define divHBLKSZ(n) ((n) >> LOG_HBLKSIZE)
@@ -572,26 +507,20 @@ extern GC_warn_proc GC_current_warn_proc;
/* Round up byte allocation requests to integral number of words, etc. */
# define ROUNDED_UP_WORDS(n) \
BYTES_TO_WORDS((n) + (WORDS_TO_BYTES(1) - 1 + EXTRA_BYTES))
-# ifdef ALIGN_DOUBLE
-# define ALIGNED_WORDS(n) \
- (BYTES_TO_WORDS((n) + WORDS_TO_BYTES(2) - 1 + EXTRA_BYTES) & ~1)
+# define ROUNDED_UP_GRANULES(n) \
+ BYTES_TO_GRANULES((n) + (GRANULE_BYTES - 1 + EXTRA_BYTES))
+# if MAX_EXTRA_BYTES == 0
+# define SMALL_OBJ(bytes) EXPECT((bytes) <= (MAXOBJBYTES), 1)
# else
-# define ALIGNED_WORDS(n) ROUNDED_UP_WORDS(n)
+# define SMALL_OBJ(bytes) \
+ (EXPECT((bytes) <= (MAXOBJBYTES - MAX_EXTRA_BYTES), 1) || \
+ (bytes) <= (MAXOBJBYTES - EXTRA_BYTES))
+ /* This really just tests bytes <= MAXOBJBYTES - EXTRA_BYTES. */
+ /* But we try to avoid looking up EXTRA_BYTES. */
# endif
-# define SMALL_OBJ(bytes) ((bytes) <= (MAXOBJBYTES - EXTRA_BYTES))
# define ADD_SLOP(bytes) ((bytes) + EXTRA_BYTES)
# ifndef MIN_WORDS
- /* MIN_WORDS is the size of the smallest allocated object. */
- /* 1 and 2 are the only valid values. */
- /* 2 must be used if: */
- /* - GC_gcj_malloc can be used for objects of requested */
- /* size smaller than 2 words, or */
- /* - USE_MARK_BYTES is defined. */
-# if defined(USE_MARK_BYTES) || defined(GC_GCJ_SUPPORT)
-# define MIN_WORDS 2 /* Smallest allocated object. */
-# else
-# define MIN_WORDS 1
-# endif
+# define MIN_WORDS 2 /* FIXME: obsolete */
# endif
@@ -649,43 +578,43 @@ typedef word page_hash_table[PHT_SIZE];
/* heap block header */
#define HBLKMASK (HBLKSIZE-1)
-#define BITS_PER_HBLK (CPP_HBLKSIZE * 8)
-
-#define MARK_BITS_PER_HBLK (BITS_PER_HBLK/CPP_WORDSZ)
+#define MARK_BITS_PER_HBLK (HBLKSIZE/GRANULE_BYTES)
/* upper bound */
- /* We allocate 1 bit/word, unless USE_MARK_BYTES */
- /* is defined. Only the first word */
- /* in each object is actually marked. */
+ /* We allocate 1 bit per allocation granule. */
+ /* If MARK_BIT_PER_GRANULE is defined, we use */
+ /* every nth bit, where n is the number of */
+ /* allocation granules per object. If */
+ /* MARK_BIT_PER_OBJ is defined, we only use the */
+ /* initial group of mark bits, and it is safe */
+ /* to allocate smaller header for large objects. */
# ifdef USE_MARK_BYTES
-# define MARK_BITS_SZ (MARK_BITS_PER_HBLK/2)
+# define MARK_BITS_SZ (MARK_BITS_PER_HBLK + 1)
/* Unlike the other case, this is in units of bytes. */
- /* We actually allocate only every second mark bit, since we */
- /* force all objects to be doubleword aligned. */
- /* However, each mark bit is allocated as a byte. */
+ /* Since we force doubleword alignment, we need at most one */
+ /* mark bit per 2 words. But we do allocate and set one */
+ /* extra mark bit to avoid an explicit check for the */
+ /* partial object at the end of each block. */
# else
-# define MARK_BITS_SZ (MARK_BITS_PER_HBLK/CPP_WORDSZ)
+# define MARK_BITS_SZ (MARK_BITS_PER_HBLK/CPP_WORDSZ + 1)
# endif
+#ifdef PARALLEL_MARK
+# include <atomic_ops.h>
+ typedef AO_t counter_t;
+#else
+ typedef size_t counter_t;
+#endif
+
/* We maintain layout maps for heap blocks containing objects of a given */
/* size. Each entry in this map describes a byte offset and has the */
/* following type. */
-typedef unsigned char map_entry_type;
-
struct hblkhdr {
- word hb_sz; /* If in use, size in words, of objects in the block. */
- /* if free, the size in bytes of the whole block */
struct hblk * hb_next; /* Link field for hblk free list */
/* and for lists of chunks waiting to be */
/* reclaimed. */
struct hblk * hb_prev; /* Backwards link for free list. */
- word hb_descr; /* object descriptor for marking. See */
- /* mark.h. */
- map_entry_type * hb_map;
- /* A pointer to a pointer validity map of the block. */
- /* See GC_obj_map. */
- /* Valid for all blocks with headers. */
- /* Free blocks point to GC_invalid_map. */
+ struct hblk * hb_block; /* The corresponding block. */
unsigned char hb_obj_kind;
/* Kind of objects in the block. Each kind */
/* identifies a mark procedure and a set of */
@@ -700,6 +629,7 @@ struct hblkhdr {
/* GC_remap must be invoked on it */
/* before it can be reallocated. */
/* Only set with USE_MUNMAP. */
+# define FREE_BLK 4 /* Block is free, i.e. not in use. */
unsigned short hb_last_reclaimed;
/* Value of GC_gc_no when block was */
/* last allocated or swept. May wrap. */
@@ -708,43 +638,67 @@ struct hblkhdr {
/* when the header was allocated, or */
/* when the size of the block last */
/* changed. */
+ size_t hb_sz; /* If in use, size in bytes, of objects in the block. */
+ /* if free, the size in bytes of the whole block */
+ word hb_descr; /* object descriptor for marking. See */
+ /* mark.h. */
+# ifdef MARK_BIT_PER_OBJ
+ unsigned32 hb_inv_sz; /* A good upper bound for 2**32/hb_sz. */
+ /* For large objects, we use */
+ /* LARGE_INV_SZ. */
+# define LARGE_INV_SZ (1 << 16)
+# else
+ unsigned char hb_large_block;
+ short * hb_map; /* Essentially a table of remainders */
+ /* mod BYTES_TO_GRANULES(hb_sz), except */
+ /* for large blocks. See GC_obj_map. */
+# endif
+ counter_t hb_n_marks; /* Number of set mark bits, excluding */
+ /* the one always set at the end. */
+ /* Currently it is concurrently */
+ /* updated and hence only a lower bound.*/
+ /* But a zero value does gurantee that */
+ /* the block contains no marked */
+ /* objects. */
# ifdef USE_MARK_BYTES
union {
char _hb_marks[MARK_BITS_SZ];
/* The i'th byte is 1 if the object */
- /* starting at word 2i is marked, 0 o.w. */
+ /* starting at granule i or object i is */
+ /* marked, 0 o.w. */
+ /* The mark bit for the "one past the */
+ /* end" object is always set to avoid a */
+ /* special case test in the marker. */
word dummy; /* Force word alignment of mark bytes. */
} _mark_byte_union;
# define hb_marks _mark_byte_union._hb_marks
+# define ANY_INDEX 23 /* Random mark bit index for assertions */
# else
word hb_marks[MARK_BITS_SZ];
- /* Bit i in the array refers to the */
- /* object starting at the ith word (header */
- /* INCLUDED) in the heap block. */
- /* The lsb of word 0 is numbered 0. */
- /* Unused bits are invalid, and are */
- /* occasionally set, e.g for uncollectable */
- /* objects. */
# endif /* !USE_MARK_BYTES */
};
/* heap block body */
-# define BODY_SZ (HBLKSIZE/sizeof(word))
+# define HBLK_WORDS (HBLKSIZE/sizeof(word))
+# define HBLK_GRANULES (HBLKSIZE/GRANULE_BYTES)
+
+/* The number of objects in a block dedicated to a certain size. */
+/* may erroneously yield zero (instead of one) for large objects. */
+# define HBLK_OBJS(sz_in_bytes) (HBLKSIZE/(sz_in_bytes))
struct hblk {
- word hb_body[BODY_SZ];
+ char hb_body[HBLKSIZE];
};
-# define HBLK_IS_FREE(hdr) ((hdr) -> hb_map == GC_invalid_map)
+# define HBLK_IS_FREE(hdr) (((hdr) -> hb_flags & FREE_BLK) != 0)
-# define OBJ_SZ_TO_BLOCKS(sz) \
- divHBLKSZ(WORDS_TO_BYTES(sz) + HBLKSIZE-1)
+# define OBJ_SZ_TO_BLOCKS(sz) divHBLKSZ(sz + HBLKSIZE-1)
/* Size of block (in units of HBLKSIZE) needed to hold objects of */
- /* given sz (in words). */
+ /* given sz (in bytes). */
/* Object free list link */
-# define obj_link(p) (*(ptr_t *)(p))
+# define obj_link(p) (*(void **)(p))
# define LOG_MAX_MARK_PROCS 6
# define MAX_MARK_PROCS (1 << LOG_MAX_MARK_PROCS)
@@ -820,7 +774,7 @@ struct roots {
/* compiled. */
struct _GC_arrays {
- word _heapsize;
+ word _heapsize; /* Heap size in bytes. */
word _max_heapsize;
word _requested_heapsize; /* Heap size due to explicit expansion */
ptr_t _last_heap_addr;
@@ -837,29 +791,29 @@ struct _GC_arrays {
/* Maximum number of bytes that were ever allocated in */
/* large object blocks. This is used to help decide when it */
/* is safe to split up a large block. */
- word _words_allocd_before_gc;
+ word _bytes_allocd_before_gc;
/* Number of words allocated before this */
/* collection cycle. */
# ifndef SEPARATE_GLOBALS
- word _words_allocd;
+ word _bytes_allocd;
/* Number of words allocated during this collection cycle */
# endif
- word _words_wasted;
+ word _bytes_wasted;
/* Number of words wasted due to internal fragmentation */
/* in large objects, or due to dropping blacklisted */
/* blocks, since last gc. Approximate. */
- word _words_finalized;
- /* Approximate number of words in objects (and headers) */
+ word _bytes_finalized;
+ /* Approximate number of bytes in objects (and headers) */
/* That became ready for finalization in the last */
/* collection. */
word _non_gc_bytes_at_gc;
/* Number of explicitly managed bytes of storage */
/* at last collection. */
- word _mem_freed;
- /* Number of explicitly deallocated words of memory */
+ word _bytes_freed;
+ /* Number of explicitly deallocated bytes of memory */
/* since last collection. */
- word _finalizer_mem_freed;
- /* Words of memory explicitly deallocated while */
+ word _finalizer_bytes_freed;
+ /* Bytes of memory explicitly deallocated while */
/* finalizers were running. Used to approximate mem. */
/* explicitly deallocated by finalizers. */
ptr_t _scratch_end_ptr;
@@ -872,77 +826,61 @@ struct _GC_arrays {
/* by DS_PROC mark descriptors. See gc_mark.h. */
# ifndef SEPARATE_GLOBALS
- ptr_t _objfreelist[MAXOBJSZ+1];
+ void *_objfreelist[MAXOBJGRANULES+1];
/* free list for objects */
- ptr_t _aobjfreelist[MAXOBJSZ+1];
+ void *_aobjfreelist[MAXOBJGRANULES+1];
/* free list for atomic objs */
# endif
- ptr_t _uobjfreelist[MAXOBJSZ+1];
+ void *_uobjfreelist[MAXOBJGRANULES+1];
/* uncollectable but traced objs */
/* objects on this and auobjfreelist */
/* are always marked, except during */
/* garbage collections. */
# ifdef ATOMIC_UNCOLLECTABLE
- ptr_t _auobjfreelist[MAXOBJSZ+1];
+ void *_auobjfreelist[MAXOBJGRANULES+1];
# endif
/* uncollectable but traced objs */
-# ifdef GATHERSTATS
word _composite_in_use;
/* Number of words in accessible composite */
/* objects. */
word _atomic_in_use;
/* Number of words in accessible atomic */
/* objects. */
-# endif
# ifdef USE_MUNMAP
word _unmapped_bytes;
# endif
-# ifdef MERGE_SIZES
- unsigned _size_map[WORDS_TO_BYTES(MAXOBJSZ+1)];
+
+ unsigned _size_map[MAXOBJBYTES+1];
/* Number of words to allocate for a given allocation request in */
/* bytes. */
-# endif
# ifdef STUBBORN_ALLOC
- ptr_t _sobjfreelist[MAXOBJSZ+1];
+ ptr_t _sobjfreelist[MAXOBJGRANULES+1];
# endif
/* free list for immutable objects */
- map_entry_type * _obj_map[MAXOBJSZ+1];
+# ifdef MARK_BIT_PER_GRANULE
+ short * _obj_map[MAXOBJGRANULES+1];
/* If not NIL, then a pointer to a map of valid */
- /* object addresses. _obj_map[sz][i] is j if the */
- /* address block_start+i is a valid pointer */
- /* to an object at block_start + */
- /* WORDS_TO_BYTES(BYTES_TO_WORDS(i) - j) */
- /* I.e. j is a word displacement from the */
- /* object beginning. */
- /* The entry is OBJ_INVALID if the corresponding */
- /* address is not a valid pointer. It is */
- /* OFFSET_TOO_BIG if the value j would be too */
- /* large to fit in the entry. (Note that the */
- /* size of these entries matters, both for */
- /* space consumption and for cache utilization.) */
-# define OFFSET_TOO_BIG 0xfe
-# define OBJ_INVALID 0xff
-# define MAP_ENTRY(map, bytes) (map)[bytes]
-# define MAP_ENTRIES HBLKSIZE
-# define MAP_SIZE MAP_ENTRIES
-# define CPP_MAX_OFFSET (OFFSET_TOO_BIG - 1)
-# define MAX_OFFSET ((word)CPP_MAX_OFFSET)
- /* The following are used only if GC_all_interior_ptrs != 0 */
-# define VALID_OFFSET_SZ \
- (CPP_MAX_OFFSET > WORDS_TO_BYTES(CPP_MAXOBJSZ)? \
- CPP_MAX_OFFSET+1 \
- : WORDS_TO_BYTES(CPP_MAXOBJSZ)+1)
- char _valid_offsets[VALID_OFFSET_SZ];
+ /* object addresses. */
+ /* _obj_map[sz_in_granules][i] is */
+ /* i % sz_in_granules. */
+ /* This is now used purely to replace a */
+ /* division in the marker by a table lookup. */
+ /* _obj_map[0] is used for large objects and */
+ /* contains all nonzero entries. This gets us */
+ /* out of the marker fast path without an extra */
+ /* test. */
+# define MAP_LEN BYTES_TO_GRANULES(HBLKSIZE)
+# endif
+# define VALID_OFFSET_SZ HBLKSIZE
+ char _valid_offsets[VALID_OFFSET_SZ];
/* GC_valid_offsets[i] == TRUE ==> i */
/* is registered as a displacement. */
- char _modws_valid_offsets[sizeof(word)];
+ char _modws_valid_offsets[sizeof(word)];
/* GC_valid_offsets[i] ==> */
/* GC_modws_valid_offsets[i%sizeof(word)] */
-# define OFFSET_VALID(displ) \
- (GC_all_interior_pointers || GC_valid_offsets[displ])
# ifdef STUBBORN_ALLOC
page_hash_table _changed_pages;
/* Stubborn object pages that were changes since last call to */
@@ -956,7 +894,7 @@ struct _GC_arrays {
/* GC_read_dirty. */
# endif
# ifdef MPROTECT_VDB
- VOLATILE page_hash_table _dirty_pages;
+ volatile page_hash_table _dirty_pages;
/* Pages dirtied since last GC_read_dirty. */
# endif
# ifdef PROC_VDB
@@ -994,6 +932,9 @@ struct _GC_arrays {
/* Block header index; see gc_headers.h */
bottom_index * _all_nils;
bottom_index * _top_index [TOP_SZ];
+#ifdef ENABLE_TRACE
+ ptr_t _trace_addr;
+#endif
#ifdef SAVE_CALL_CHAIN
struct callinfo _last_stack[NFRAMES]; /* Stack at last garbage collection.*/
/* Useful for debugging mysterious */
@@ -1009,7 +950,7 @@ GC_API GC_FAR struct _GC_arrays GC_arrays;
# ifndef SEPARATE_GLOBALS
# define GC_objfreelist GC_arrays._objfreelist
# define GC_aobjfreelist GC_arrays._aobjfreelist
-# define GC_words_allocd GC_arrays._words_allocd
+# define GC_bytes_allocd GC_arrays._bytes_allocd
# endif
# define GC_uobjfreelist GC_arrays._uobjfreelist
# ifdef ATOMIC_UNCOLLECTABLE
@@ -1022,26 +963,31 @@ GC_API GC_FAR struct _GC_arrays GC_arrays;
# define GC_changed_pages GC_arrays._changed_pages
# define GC_prev_changed_pages GC_arrays._prev_changed_pages
# endif
-# define GC_obj_map GC_arrays._obj_map
+# ifdef MARK_BIT_PER_GRANULE
+# define GC_obj_map GC_arrays._obj_map
+# endif
# define GC_last_heap_addr GC_arrays._last_heap_addr
# define GC_prev_heap_addr GC_arrays._prev_heap_addr
-# define GC_words_wasted GC_arrays._words_wasted
+# define GC_bytes_wasted GC_arrays._bytes_wasted
# define GC_large_free_bytes GC_arrays._large_free_bytes
# define GC_large_allocd_bytes GC_arrays._large_allocd_bytes
# define GC_max_large_allocd_bytes GC_arrays._max_large_allocd_bytes
-# define GC_words_finalized GC_arrays._words_finalized
+# define GC_bytes_finalized GC_arrays._bytes_finalized
# define GC_non_gc_bytes_at_gc GC_arrays._non_gc_bytes_at_gc
-# define GC_mem_freed GC_arrays._mem_freed
-# define GC_finalizer_mem_freed GC_arrays._finalizer_mem_freed
+# define GC_bytes_freed GC_arrays._bytes_freed
+# define GC_finalizer_bytes_freed GC_arrays._finalizer_bytes_freed
# define GC_scratch_end_ptr GC_arrays._scratch_end_ptr
# define GC_scratch_last_end_ptr GC_arrays._scratch_last_end_ptr
# define GC_mark_procs GC_arrays._mark_procs
# define GC_heapsize GC_arrays._heapsize
# define GC_max_heapsize GC_arrays._max_heapsize
# define GC_requested_heapsize GC_arrays._requested_heapsize
-# define GC_words_allocd_before_gc GC_arrays._words_allocd_before_gc
+# define GC_bytes_allocd_before_gc GC_arrays._bytes_allocd_before_gc
# define GC_heap_sects GC_arrays._heap_sects
# define GC_last_stack GC_arrays._last_stack
+#ifdef ENABLE_TRACE
+#define GC_trace_addr GC_arrays._trace_addr
+#endif
# ifdef USE_MUNMAP
# define GC_unmapped_bytes GC_arrays._unmapped_bytes
# endif
@@ -1065,13 +1011,9 @@ GC_API GC_FAR struct _GC_arrays GC_arrays;
# ifdef PROC_VDB
# define GC_written_pages GC_arrays._written_pages
# endif
-# ifdef GATHERSTATS
-# define GC_composite_in_use GC_arrays._composite_in_use
-# define GC_atomic_in_use GC_arrays._atomic_in_use
-# endif
-# ifdef MERGE_SIZES
-# define GC_size_map GC_arrays._size_map
-# endif
+# define GC_composite_in_use GC_arrays._composite_in_use
+# define GC_atomic_in_use GC_arrays._atomic_in_use
+# define GC_size_map GC_arrays._size_map
# define beginGC_arrays ((ptr_t)(&GC_arrays))
# define endGC_arrays (((ptr_t)(&GC_arrays)) + (sizeof GC_arrays))
@@ -1082,12 +1024,13 @@ GC_API GC_FAR struct _GC_arrays GC_arrays;
# define MAXOBJKINDS 16
extern struct obj_kind {
- ptr_t *ok_freelist; /* Array of free listheaders for this kind of object */
+ void **ok_freelist; /* Array of free listheaders for this kind of object */
/* Point either to GC_arrays or to storage allocated */
/* with GC_scratch_alloc. */
struct hblk **ok_reclaim_list;
/* List headers for lists of blocks waiting to be */
/* swept. */
+ /* Indexed by object size in granules. */
word ok_descriptor; /* Descriptor template for objects in this */
/* block. */
GC_bool ok_relocate_descr;
@@ -1106,14 +1049,14 @@ extern struct obj_kind {
/* introduce maintenance problems. */
#ifdef SEPARATE_GLOBALS
- word GC_words_allocd;
+ word GC_bytes_allocd;
/* Number of words allocated during this collection cycle */
- ptr_t GC_objfreelist[MAXOBJSZ+1];
+ ptr_t GC_objfreelist[MAXOBJGRANULES+1];
/* free list for NORMAL objects */
# define beginGC_objfreelist ((ptr_t)(&GC_objfreelist))
# define endGC_objfreelist (beginGC_objfreelist + sizeof(GC_objfreelist))
- ptr_t GC_aobjfreelist[MAXOBJSZ+1];
+ ptr_t GC_aobjfreelist[MAXOBJGRANULES+1];
/* free list for atomic (PTRFREE) objs */
# define beginGC_aobjfreelist ((ptr_t)(&GC_aobjfreelist))
# define endGC_aobjfreelist (beginGC_aobjfreelist + sizeof(GC_aobjfreelist))
@@ -1157,10 +1100,6 @@ extern word GC_black_list_spacing;
/* "stack-blacklisted", i.e. that are */
/* problematic in the interior of an object. */
-extern map_entry_type * GC_invalid_map;
- /* Pointer to the nowhere valid hblk map */
- /* Blocks pointing to this map are free. */
-
extern struct hblk * GC_hblkfreelist[];
/* List of completely empty heap blocks */
/* Linked through hb_next field of */
@@ -1243,17 +1182,16 @@ extern long GC_large_alloc_warn_suppressed;
/* Mark bit operations */
/*
- * Retrieve, set, clear the mark bit corresponding
- * to the nth word in a given heap block.
+ * Retrieve, set, clear the nth mark bit in a given heap block.
*
- * (Recall that bit n corresponds to object beginning at word n
+ * (Recall that bit n corresponds to nth object or allocation granule
* relative to the beginning of the block, including unused words)
*/
#ifdef USE_MARK_BYTES
-# define mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[(n) >> 1])
-# define set_mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[(n)>>1]) = 1
-# define clear_mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[(n)>>1]) = 0
+# define mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[n])
+# define set_mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[n]) = 1
+# define clear_mark_bit_from_hdr(hhdr,n) ((hhdr)->hb_marks[n]) = 0
#else /* !USE_MARK_BYTES */
# define mark_bit_from_hdr(hhdr,n) (((hhdr)->hb_marks[divWORDSZ(n)] \
>> (modWORDSZ(n))) & (word)1)
@@ -1264,70 +1202,85 @@ extern long GC_large_alloc_warn_suppressed;
&= ~((word)1 << modWORDSZ(n))
#endif /* !USE_MARK_BYTES */
+#ifdef MARK_BIT_PER_OBJ
+# define MARK_BIT_NO(offset, sz) ((offset)/(sz))
+ /* Get the mark bit index corresponding to the given byte */
+ /* offset and size (in bytes). */
+# define MARK_BIT_OFFSET(sz) 1
+ /* Spacing between useful mark bits. */
+# define IF_PER_OBJ(x) x
+# define FINAL_MARK_BIT(sz) ((sz) > MAXOBJBYTES? 1 : HBLK_OBJS(sz))
+ /* Position of final, always set, mark bit. */
+#else /* MARK_BIT_PER_GRANULE */
+# define MARK_BIT_NO(offset, sz) BYTES_TO_GRANULES((offset))
+# define MARK_BIT_OFFSET(sz) BYTES_TO_GRANULES(sz)
+# define IF_PER_OBJ(x)
+# define FINAL_MARK_BIT(sz) \
+ ((sz) > MAXOBJBYTES? MARK_BITS_PER_HBLK \
+ : BYTES_TO_GRANULES(sz * HBLK_OBJS(sz)))
+#endif
+
/* Important internal collector routines */
-ptr_t GC_approx_sp GC_PROTO((void));
+ptr_t GC_approx_sp(void);
-GC_bool GC_should_collect GC_PROTO((void));
+GC_bool GC_should_collect(void);
-void GC_apply_to_all_blocks GC_PROTO(( \
- void (*fn) GC_PROTO((struct hblk *h, word client_data)), \
- word client_data));
+void GC_apply_to_all_blocks(void (*fn) (struct hblk *h, word client_data),
+ word client_data);
/* Invoke fn(hbp, client_data) for each */
/* allocated heap block. */
-struct hblk * GC_next_used_block GC_PROTO((struct hblk * h));
+struct hblk * GC_next_used_block(struct hblk * h);
/* Return first in-use block >= h */
-struct hblk * GC_prev_block GC_PROTO((struct hblk * h));
+struct hblk * GC_prev_block(struct hblk * h);
/* Return last block <= h. Returned block */
/* is managed by GC, but may or may not be in */
/* use. */
-void GC_mark_init GC_PROTO((void));
-void GC_clear_marks GC_PROTO((void)); /* Clear mark bits for all heap objects. */
-void GC_invalidate_mark_state GC_PROTO((void));
+void GC_mark_init(void);
+void GC_clear_marks(void); /* Clear mark bits for all heap objects. */
+void GC_invalidate_mark_state(void);
/* Tell the marker that marked */
/* objects may point to unmarked */
/* ones, and roots may point to */
/* unmarked objects. */
/* Reset mark stack. */
-GC_bool GC_mark_stack_empty GC_PROTO((void));
-GC_bool GC_mark_some GC_PROTO((ptr_t cold_gc_frame));
+GC_bool GC_mark_stack_empty(void);
+GC_bool GC_mark_some(ptr_t cold_gc_frame);
/* Perform about one pages worth of marking */
/* work of whatever kind is needed. Returns */
/* quickly if no collection is in progress. */
/* Return TRUE if mark phase finished. */
-void GC_initiate_gc GC_PROTO((void));
+void GC_initiate_gc(void);
/* initiate collection. */
/* If the mark state is invalid, this */
/* becomes full colleection. Otherwise */
/* it's partial. */
-void GC_push_all GC_PROTO((ptr_t bottom, ptr_t top));
+void GC_push_all(ptr_t bottom, ptr_t top);
/* Push everything in a range */
/* onto mark stack. */
-void GC_push_selected GC_PROTO(( \
- ptr_t bottom, \
- ptr_t top, \
- int (*dirty_fn) GC_PROTO((struct hblk *h)), \
- void (*push_fn) GC_PROTO((ptr_t bottom, ptr_t top)) ));
+void GC_push_selected(ptr_t bottom, ptr_t top,
+ int (*dirty_fn) (struct hblk *h),
+ void (*push_fn) (ptr_t bottom, ptr_t top) );
/* Push all pages h in [b,t) s.t. */
/* select_fn(h) != 0 onto mark stack. */
#ifndef SMALL_CONFIG
- void GC_push_conditional GC_PROTO((ptr_t b, ptr_t t, GC_bool all));
+ void GC_push_conditional (ptr_t b, ptr_t t, GC_bool all);
#else
# define GC_push_conditional(b, t, all) GC_push_all(b, t)
#endif
/* Do either of the above, depending */
/* on the third arg. */
-void GC_push_all_stack GC_PROTO((ptr_t b, ptr_t t));
+void GC_push_all_stack (ptr_t b, ptr_t t);
/* As above, but consider */
/* interior pointers as valid */
-void GC_push_all_eager GC_PROTO((ptr_t b, ptr_t t));
+void GC_push_all_eager (ptr_t b, ptr_t t);
/* Same as GC_push_all_stack, but */
/* ensures that stack is scanned */
/* immediately, not just scheduled */
/* for scanning. */
#ifndef THREADS
- void GC_push_all_stack_partially_eager GC_PROTO(( \
- ptr_t bottom, ptr_t top, ptr_t cold_gc_frame ));
+ void GC_push_all_stack_partially_eager(ptr_t bottom, ptr_t top,
+ ptr_t cold_gc_frame);
/* Similar to GC_push_all_eager, but only the */
/* part hotter than cold_gc_frame is scanned */
/* immediately. Needed to ensure that callee- */
@@ -1339,46 +1292,46 @@ void GC_push_all_eager GC_PROTO((ptr_t b, ptr_t t));
/* stacks are scheduled for scanning in *GC_push_other_roots, which */
/* is thread-package-specific. */
#endif
-void GC_push_current_stack GC_PROTO((ptr_t cold_gc_frame));
+void GC_push_current_stack(ptr_t cold_gc_frame);
/* Push enough of the current stack eagerly to */
/* ensure that callee-save registers saved in */
/* GC frames are scanned. */
/* In the non-threads case, schedule entire */
/* stack for scanning. */
-void GC_push_roots GC_PROTO((GC_bool all, ptr_t cold_gc_frame));
+void GC_push_roots(GC_bool all, ptr_t cold_gc_frame);
/* Push all or dirty roots. */
-extern void (*GC_push_other_roots) GC_PROTO((void));
+extern void (*GC_push_other_roots)(void);
/* Push system or application specific roots */
/* onto the mark stack. In some environments */
/* (e.g. threads environments) this is */
/* predfined to be non-zero. A client supplied */
/* replacement should also call the original */
/* function. */
-extern void GC_push_gc_structures GC_PROTO((void));
+extern void GC_push_gc_structures(void);
/* Push GC internal roots. These are normally */
/* included in the static data segment, and */
/* Thus implicitly pushed. But we must do this */
/* explicitly if normal root processing is */
/* disabled. Calls the following: */
- extern void GC_push_finalizer_structures GC_PROTO((void));
- extern void GC_push_stubborn_structures GC_PROTO((void));
+ extern void GC_push_finalizer_structures(void);
+ extern void GC_push_stubborn_structures (void);
# ifdef THREADS
- extern void GC_push_thread_structures GC_PROTO((void));
+ extern void GC_push_thread_structures (void);
# endif
-extern void (*GC_start_call_back) GC_PROTO((void));
+extern void (*GC_start_call_back) (void);
/* Called at start of full collections. */
/* Not called if 0. Called with allocation */
/* lock held. */
/* 0 by default. */
# if defined(USE_GENERIC_PUSH_REGS)
- void GC_generic_push_regs GC_PROTO((ptr_t cold_gc_frame));
+ void GC_generic_push_regs(ptr_t cold_gc_frame);
# else
- void GC_push_regs GC_PROTO((void));
+ void GC_push_regs(void);
# endif
# if defined(SPARC) || defined(IA64)
/* Cause all stacked registers to be saved in memory. Return a */
/* pointer to the top of the corresponding memory stack. */
- word GC_save_regs_in_stack GC_PROTO((void));
+ word GC_save_regs_in_stack(void);
# endif
/* Push register contents onto mark stack. */
/* If NURSERY is defined, the default push */
@@ -1388,9 +1341,9 @@ extern void (*GC_start_call_back) GC_PROTO((void));
extern void (*GC_push_proc)(ptr_t);
# endif
# if defined(MSWIN32) || defined(MSWINCE)
- void __cdecl GC_push_one GC_PROTO((word p));
+ void __cdecl GC_push_one(word p);
# else
- void GC_push_one GC_PROTO((word p));
+ void GC_push_one(word p);
/* If p points to an object, mark it */
/* and push contents on the mark stack */
/* Pointer recognition test always */
@@ -1399,133 +1352,144 @@ extern void (*GC_start_call_back) GC_PROTO((void));
/* stack. */
# endif
# if defined(PRINT_BLACK_LIST) || defined(KEEP_BACK_PTRS)
- void GC_mark_and_push_stack GC_PROTO((word p, ptr_t source));
+ void GC_mark_and_push_stack(ptr_t p, ptr_t source);
/* Ditto, omits plausibility test */
# else
- void GC_mark_and_push_stack GC_PROTO((word p));
+ void GC_mark_and_push_stack(ptr_t p);
# endif
-void GC_push_marked GC_PROTO((struct hblk * h, hdr * hhdr));
+void GC_push_marked(struct hblk * h, hdr * hhdr);
/* Push contents of all marked objects in h onto */
/* mark stack. */
#ifdef SMALL_CONFIG
# define GC_push_next_marked_dirty(h) GC_push_next_marked(h)
#else
- struct hblk * GC_push_next_marked_dirty GC_PROTO((struct hblk * h));
+ struct hblk * GC_push_next_marked_dirty(struct hblk * h);
/* Invoke GC_push_marked on next dirty block above h. */
/* Return a pointer just past the end of this block. */
#endif /* !SMALL_CONFIG */
-struct hblk * GC_push_next_marked GC_PROTO((struct hblk * h));
+struct hblk * GC_push_next_marked(struct hblk * h);
/* Ditto, but also mark from clean pages. */
-struct hblk * GC_push_next_marked_uncollectable GC_PROTO((struct hblk * h));
+struct hblk * GC_push_next_marked_uncollectable(struct hblk * h);
/* Ditto, but mark only from uncollectable pages. */
-GC_bool GC_stopped_mark GC_PROTO((GC_stop_func stop_func));
+GC_bool GC_stopped_mark(GC_stop_func stop_func);
/* Stop world and mark from all roots */
/* and rescuers. */
-void GC_clear_hdr_marks GC_PROTO((hdr * hhdr));
+void GC_clear_hdr_marks(hdr * hhdr);
/* Clear the mark bits in a header */
-void GC_set_hdr_marks GC_PROTO((hdr * hhdr));
+void GC_set_hdr_marks(hdr * hhdr);
/* Set the mark bits in a header */
-void GC_set_fl_marks GC_PROTO((ptr_t p));
+void GC_set_fl_marks(ptr_t p);
/* Set all mark bits associated with */
/* a free list. */
-void GC_add_roots_inner GC_PROTO((char * b, char * e, GC_bool tmp));
-void GC_remove_roots_inner GC_PROTO((char * b, char * e));
-GC_bool GC_is_static_root GC_PROTO((ptr_t p));
+#ifdef GC_ASSERTIONS
+ void GC_check_fl_marks(ptr_t p);
+ /* Check that all mark bits */
+ /* associated with a free list are */
+ /* set. Abort if not. */
+#endif
+void GC_add_roots_inner(ptr_t b, ptr_t e, GC_bool tmp);
+void GC_remove_roots_inner(ptr_t b, ptr_t e);
+GC_bool GC_is_static_root(ptr_t p);
/* Is the address p in one of the registered static */
/* root sections? */
# if defined(MSWIN32) || defined(_WIN32_WCE_EMULATION)
-GC_bool GC_is_tmp_root GC_PROTO((ptr_t p));
+GC_bool GC_is_tmp_root(ptr_t p);
/* Is the address p in one of the temporary static */
/* root sections? */
# endif
-void GC_register_dynamic_libraries GC_PROTO((void));
+void GC_register_dynamic_libraries(void);
/* Add dynamic library data sections to the root set. */
+void GC_cond_register_dynamic_libraries(void);
+ /* Remove and reregister dynamic libraries if we're */
+ /* configured to do that at each GC. */
-GC_bool GC_register_main_static_data GC_PROTO((void));
+GC_bool GC_register_main_static_data(void);
/* We need to register the main data segment. Returns */
/* TRUE unless this is done implicitly as part of */
/* dynamic library registration. */
/* Machine dependent startup routines */
-ptr_t GC_get_stack_base GC_PROTO((void)); /* Cold end of stack */
+ptr_t GC_get_stack_base(void); /* Cold end of stack */
#ifdef IA64
- ptr_t GC_get_register_stack_base GC_PROTO((void));
+ ptr_t GC_get_register_stack_base(void);
/* Cold end of register stack. */
#endif
-void GC_register_data_segments GC_PROTO((void));
+void GC_register_data_segments(void);
/* Black listing: */
-void GC_bl_init GC_PROTO((void));
+void GC_bl_init(void);
# ifdef PRINT_BLACK_LIST
- void GC_add_to_black_list_normal GC_PROTO((word p, ptr_t source));
+ void GC_add_to_black_list_normal(word p, ptr_t source);
/* Register bits as a possible future false */
/* reference from the heap or static data */
# define GC_ADD_TO_BLACK_LIST_NORMAL(bits, source) \
if (GC_all_interior_pointers) { \
- GC_add_to_black_list_stack(bits, (ptr_t)(source)); \
+ GC_add_to_black_list_stack((word)(bits), (source)); \
} else { \
- GC_add_to_black_list_normal(bits, (ptr_t)(source)); \
+ GC_add_to_black_list_normal((word)(bits), (source)); \
}
# else
- void GC_add_to_black_list_normal GC_PROTO((word p));
+ void GC_add_to_black_list_normal(word p);
# define GC_ADD_TO_BLACK_LIST_NORMAL(bits, source) \
if (GC_all_interior_pointers) { \
- GC_add_to_black_list_stack(bits); \
+ GC_add_to_black_list_stack((word)(bits)); \
} else { \
- GC_add_to_black_list_normal(bits); \
+ GC_add_to_black_list_normal((word)(bits)); \
}
# endif
# ifdef PRINT_BLACK_LIST
- void GC_add_to_black_list_stack GC_PROTO((word p, ptr_t source));
+ void GC_add_to_black_list_stack(word p, ptr_t source);
+# define GC_ADD_TO_BLACK_LIST_STACK(bits, source) \
+ GC_add_to_black_list_stack((word)(bits), (source))
# else
- void GC_add_to_black_list_stack GC_PROTO((word p));
+ void GC_add_to_black_list_stack(word p);
+# define GC_ADD_TO_BLACK_LIST_STACK(bits, source) \
+ GC_add_to_black_list_stack((word)(bits))
# endif
-struct hblk * GC_is_black_listed GC_PROTO((struct hblk * h, word len));
+struct hblk * GC_is_black_listed(struct hblk * h, word len);
/* If there are likely to be false references */
/* to a block starting at h of the indicated */
/* length, then return the next plausible */
/* starting location for h that might avoid */
/* these false references. */
-void GC_promote_black_lists GC_PROTO((void));
+void GC_promote_black_lists(void);
/* Declare an end to a black listing phase. */
-void GC_unpromote_black_lists GC_PROTO((void));
+void GC_unpromote_black_lists(void);
/* Approximately undo the effect of the above. */
/* This actually loses some information, but */
/* only in a reasonably safe way. */
-word GC_number_stack_black_listed GC_PROTO(( \
- struct hblk *start, struct hblk *endp1));
+word GC_number_stack_black_listed(struct hblk *start, struct hblk *endp1);
/* Return the number of (stack) blacklisted */
/* blocks in the range for statistical */
/* purposes. */
-ptr_t GC_scratch_alloc GC_PROTO((word bytes));
+ptr_t GC_scratch_alloc(size_t bytes);
/* GC internal memory allocation for */
/* small objects. Deallocation is not */
/* possible. */
/* Heap block layout maps: */
-void GC_invalidate_map GC_PROTO((hdr * hhdr));
- /* Remove the object map associated */
- /* with the block. This identifies */
- /* the block as invalid to the mark */
- /* routines. */
-GC_bool GC_add_map_entry GC_PROTO((word sz));
+GC_bool GC_add_map_entry(size_t sz);
/* Add a heap block map for objects of */
/* size sz to obj_map. */
/* Return FALSE on failure. */
-void GC_register_displacement_inner GC_PROTO((word offset));
+void GC_register_displacement_inner(size_t offset);
/* Version of GC_register_displacement */
/* that assumes lock is already held */
/* and signals are already disabled. */
+
+void GC_initialize_offsets(void);
+ /* Initialize GC_valid_offsets, */
+ /* depending on current */
+ /* GC_all_interior_pointers settings. */
/* hblk allocation: */
-void GC_new_hblk GC_PROTO((word size_in_words, int kind));
+void GC_new_hblk(size_t size_in_granules, int kind);
/* Allocate a new heap block, and build */
/* a free list in it. */
-ptr_t GC_build_fl GC_PROTO((struct hblk *h, word sz,
- GC_bool clear, ptr_t list));
+ptr_t GC_build_fl(struct hblk *h, size_t words, GC_bool clear, ptr_t list);
/* Build a free list for objects of */
/* size sz in block h. Append list to */
/* end of the free lists. Possibly */
@@ -1533,56 +1497,55 @@ ptr_t GC_build_fl GC_PROTO((struct hblk *h, word sz,
/* called by GC_new_hblk, but also */
/* called explicitly without GC lock. */
-struct hblk * GC_allochblk GC_PROTO(( \
- word size_in_words, int kind, unsigned flags));
+struct hblk * GC_allochblk (size_t size_in_bytes, int kind, unsigned flags);
/* Allocate a heap block, inform */
/* the marker that block is valid */
/* for objects of indicated size. */
-ptr_t GC_alloc_large GC_PROTO((word lw, int k, unsigned flags));
- /* Allocate a large block of size lw words. */
+ptr_t GC_alloc_large (size_t lb, int k, unsigned flags);
+ /* Allocate a large block of size lb bytes. */
/* The block is not cleared. */
/* Flags is 0 or IGNORE_OFF_PAGE. */
/* Calls GC_allchblk to do the actual */
/* allocation, but also triggers GC and/or */
/* heap expansion as appropriate. */
- /* Does not update GC_words_allocd, but does */
+ /* Does not update GC_bytes_allocd, but does */
/* other accounting. */
-ptr_t GC_alloc_large_and_clear GC_PROTO((word lw, int k, unsigned flags));
+ptr_t GC_alloc_large_and_clear(size_t lb, int k, unsigned flags);
/* As above, but clear block if appropriate */
/* for kind k. */
-void GC_freehblk GC_PROTO((struct hblk * p));
+void GC_freehblk(struct hblk * p);
/* Deallocate a heap block and mark it */
/* as invalid. */
/* Misc GC: */
-void GC_init_inner GC_PROTO((void));
-GC_bool GC_expand_hp_inner GC_PROTO((word n));
-void GC_start_reclaim GC_PROTO((int abort_if_found));
+void GC_init_inner(void);
+GC_bool GC_expand_hp_inner(word n);
+void GC_start_reclaim(int abort_if_found);
/* Restore unmarked objects to free */
/* lists, or (if abort_if_found is */
/* TRUE) report them. */
/* Sweeping of small object pages is */
/* largely deferred. */
-void GC_continue_reclaim GC_PROTO((word sz, int kind));
+void GC_continue_reclaim(size_t sz, int kind);
/* Sweep pages of the given size and */
/* kind, as long as possible, and */
/* as long as the corr. free list is */
- /* empty. */
-void GC_reclaim_or_delete_all GC_PROTO((void));
+ /* empty. Sz is in granules. */
+void GC_reclaim_or_delete_all(void);
/* Arrange for all reclaim lists to be */
/* empty. Judiciously choose between */
/* sweeping and discarding each page. */
-GC_bool GC_reclaim_all GC_PROTO((GC_stop_func stop_func, GC_bool ignore_old));
+GC_bool GC_reclaim_all(GC_stop_func stop_func, GC_bool ignore_old);
/* Reclaim all blocks. Abort (in a */
/* consistent state) if f returns TRUE. */
-GC_bool GC_block_empty GC_PROTO((hdr * hhdr));
+GC_bool GC_block_empty(hdr * hhdr);
/* Block completely unmarked? */
-GC_bool GC_never_stop_func GC_PROTO((void));
+GC_bool GC_never_stop_func(void);
/* Returns FALSE. */
-GC_bool GC_try_to_collect_inner GC_PROTO((GC_stop_func f));
+GC_bool GC_try_to_collect_inner(GC_stop_func f);
/* Collect; caller must have acquired */
/* lock and disabled signals. */
@@ -1591,11 +1554,10 @@ GC_bool GC_try_to_collect_inner GC_PROTO((GC_stop_func f));
/* successfully. */
# define GC_gcollect_inner() \
(void) GC_try_to_collect_inner(GC_never_stop_func)
-void GC_finish_collection GC_PROTO((void));
+void GC_finish_collection(void);
/* Finish collection. Mark bits are */
/* consistent and lock is still held. */
-GC_bool GC_collect_or_expand GC_PROTO(( \
- word needed_blocks, GC_bool ignore_off_page));
+GC_bool GC_collect_or_expand(word needed_blocks, GC_bool ignore_off_page);
/* Collect or expand heap in an attempt */
/* make the indicated number of free */
/* blocks available. Should be called */
@@ -1605,17 +1567,17 @@ GC_bool GC_collect_or_expand GC_PROTO(( \
extern GC_bool GC_is_initialized; /* GC_init() has been run. */
#if defined(MSWIN32) || defined(MSWINCE)
- void GC_deinit GC_PROTO((void));
+ void GC_deinit(void);
/* Free any resources allocated by */
/* GC_init */
#endif
-void GC_collect_a_little_inner GC_PROTO((int n));
+void GC_collect_a_little_inner(int n);
/* Do n units worth of garbage */
/* collection work, if appropriate. */
/* A unit is an amount appropriate for */
/* HBLKSIZE bytes of allocation. */
-/* ptr_t GC_generic_malloc GC_PROTO((word lb, int k)); */
+/* void * GC_generic_malloc(size_t lb, int k); */
/* Allocate an object of the given */
/* kind. By default, there are only */
/* a few kinds: composite(pointerfree), */
@@ -1626,99 +1588,106 @@ void GC_collect_a_little_inner GC_PROTO((int n));
/* communicate object layout info */
/* to the collector. */
/* The actual decl is in gc_mark.h. */
-ptr_t GC_generic_malloc_ignore_off_page GC_PROTO((size_t b, int k));
+void * GC_generic_malloc_ignore_off_page(size_t b, int k);
/* As above, but pointers past the */
/* first page of the resulting object */
/* are ignored. */
-ptr_t GC_generic_malloc_inner GC_PROTO((word lb, int k));
+void * GC_generic_malloc_inner(size_t lb, int k);
/* Ditto, but I already hold lock, etc. */
-ptr_t GC_generic_malloc_words_small_inner GC_PROTO((word lw, int k));
- /* Analogous to the above, but assumes */
- /* a small object size, and bypasses */
- /* MERGE_SIZES mechanism. */
-ptr_t GC_generic_malloc_words_small GC_PROTO((size_t lw, int k));
- /* As above, but size in units of words */
- /* Bypasses MERGE_SIZES. Assumes */
- /* words <= MAXOBJSZ. */
-ptr_t GC_generic_malloc_inner_ignore_off_page GC_PROTO((size_t lb, int k));
+void * GC_generic_malloc_inner_ignore_off_page(size_t lb, int k);
/* Allocate an object, where */
/* the client guarantees that there */
/* will always be a pointer to the */
/* beginning of the object while the */
/* object is live. */
-ptr_t GC_allocobj GC_PROTO((word sz, int kind));
+void GC_generic_malloc_many(size_t lb, int k, void **result);
+ /* Store a pointer to a list of newly */
+ /* allocated objects of kind k and size */
+ /* lb in *result. */
+ /* Caler must make sure that *result is */
+ /* traced even if objects are ptrfree. */
+ptr_t GC_allocobj(size_t sz, int kind);
/* Make the indicated */
/* free list nonempty, and return its */
- /* head. */
+ /* head. Sz is in granules. */
-void GC_free_inner(GC_PTR p);
+void GC_free_inner(void * p);
+void GC_debug_free_inner(void * p);
-void GC_init_headers GC_PROTO((void));
-struct hblkhdr * GC_install_header GC_PROTO((struct hblk *h));
+void GC_init_headers(void);
+struct hblkhdr * GC_install_header(struct hblk *h);
/* Install a header for block h. */
/* Return 0 on failure, or the header */
/* otherwise. */
-GC_bool GC_install_counts GC_PROTO((struct hblk * h, word sz));
+GC_bool GC_install_counts(struct hblk * h, size_t sz);
/* Set up forwarding counts for block */
/* h of size sz. */
/* Return FALSE on failure. */
-void GC_remove_header GC_PROTO((struct hblk * h));
+void GC_remove_header(struct hblk * h);
/* Remove the header for block h. */
-void GC_remove_counts GC_PROTO((struct hblk * h, word sz));
+void GC_remove_counts(struct hblk * h, size_t sz);
/* Remove forwarding counts for h. */
-hdr * GC_find_header GC_PROTO((ptr_t h)); /* Debugging only. */
+hdr * GC_find_header(ptr_t h); /* Debugging only. */
-void GC_finalize GC_PROTO((void));
+void GC_finalize(void);
/* Perform all indicated finalization actions */
/* on unmarked objects. */
/* Unreachable finalizable objects are enqueued */
/* for processing by GC_invoke_finalizers. */
/* Invoked with lock. */
-void GC_notify_or_invoke_finalizers GC_PROTO((void));
+void GC_notify_or_invoke_finalizers(void);
/* If GC_finalize_on_demand is not set, invoke */
/* eligible finalizers. Otherwise: */
/* Call *GC_finalizer_notifier if there are */
/* finalizers to be run, and we haven't called */
/* this procedure yet this GC cycle. */
-GC_API GC_PTR GC_make_closure GC_PROTO((GC_finalization_proc fn, GC_PTR data));
-GC_API void GC_debug_invoke_finalizer GC_PROTO((GC_PTR obj, GC_PTR data));
+GC_API void * GC_make_closure(GC_finalization_proc fn, void * data);
+GC_API void GC_debug_invoke_finalizer(void * obj, void * data);
/* Auxiliary fns to make finalization work */
/* correctly with displaced pointers introduced */
/* by the debugging allocators. */
-void GC_add_to_heap GC_PROTO((struct hblk *p, word bytes));
+void GC_add_to_heap(struct hblk *p, size_t bytes);
/* Add a HBLKSIZE aligned chunk to the heap. */
-void GC_print_obj GC_PROTO((ptr_t p));
+void GC_print_obj(ptr_t p);
/* P points to somewhere inside an object with */
/* debugging info. Print a human readable */
/* description of the object to stderr. */
-extern void (*GC_check_heap) GC_PROTO((void));
+extern void (*GC_check_heap)(void);
/* Check that all objects in the heap with */
/* debugging info are intact. */
/* Add any that are not to GC_smashed list. */
-extern void (*GC_print_all_smashed) GC_PROTO((void));
+extern void (*GC_print_all_smashed) (void);
/* Print GC_smashed if it's not empty. */
/* Clear GC_smashed list. */
-extern void GC_print_all_errors GC_PROTO((void));
+extern void GC_print_all_errors (void);
/* Print smashed and leaked objects, if any. */
/* Clear the lists of such objects. */
-extern void (*GC_print_heap_obj) GC_PROTO((ptr_t p));
+extern void (*GC_print_heap_obj) (ptr_t p);
/* If possible print s followed by a more */
/* detailed description of the object */
/* referred to by p. */
#if defined(LINUX) && defined(__ELF__) && !defined(SMALL_CONFIG)
- void GC_print_address_map GC_PROTO((void));
+ void GC_print_address_map (void);
/* Print an address map of the process. */
#endif
extern GC_bool GC_have_errors; /* We saw a smashed or leaked object. */
/* Call error printing routine */
/* occasionally. */
-extern GC_bool GC_print_stats; /* Produce at least some logging output */
- /* Set from environment variable. */
+
+#ifndef SMALL_CONFIG
+ extern int GC_print_stats; /* Nonzero generates basic GC log. */
+ /* VERBOSE generates add'l messages. */
+#else
+# define GC_print_stats 0
+ /* Will this keep the message character strings from the executable? */
+ /* It should ... */
+#endif
+#define VERBOSE 2
#ifndef NO_DEBUGGING
extern GC_bool GC_dump_regularly; /* Generate regular debugging dumps. */
@@ -1741,8 +1710,8 @@ extern GC_bool GC_print_back_height;
/* Macros used for collector internal allocation. */
/* These assume the collector lock is held. */
#ifdef DBG_HDRS_ALL
- extern GC_PTR GC_debug_generic_malloc_inner(size_t lb, int k);
- extern GC_PTR GC_debug_generic_malloc_inner_ignore_off_page(size_t lb,
+ extern void * GC_debug_generic_malloc_inner(size_t lb, int k);
+ extern void * GC_debug_generic_malloc_inner_ignore_off_page(size_t lb,
int k);
# define GC_INTERNAL_MALLOC GC_debug_generic_malloc_inner
# define GC_INTERNAL_MALLOC_IGNORE_OFF_PAGE \
@@ -1767,50 +1736,50 @@ extern GC_bool GC_print_back_height;
#ifdef USE_MUNMAP
void GC_unmap_old(void);
void GC_merge_unmapped(void);
- void GC_unmap(ptr_t start, word bytes);
- void GC_remap(ptr_t start, word bytes);
- void GC_unmap_gap(ptr_t start1, word bytes1, ptr_t start2, word bytes2);
+ void GC_unmap(ptr_t start, size_t bytes);
+ void GC_remap(ptr_t start, size_t bytes);
+ void GC_unmap_gap(ptr_t start1, size_t bytes1, ptr_t start2, size_t bytes2);
#endif
/* Virtual dirty bit implementation: */
/* Each implementation exports the following: */
-void GC_read_dirty GC_PROTO((void));
+void GC_read_dirty(void);
/* Retrieve dirty bits. */
-GC_bool GC_page_was_dirty GC_PROTO((struct hblk *h));
+GC_bool GC_page_was_dirty(struct hblk *h);
/* Read retrieved dirty bits. */
-GC_bool GC_page_was_ever_dirty GC_PROTO((struct hblk *h));
+GC_bool GC_page_was_ever_dirty(struct hblk *h);
/* Could the page contain valid heap pointers? */
-void GC_is_fresh GC_PROTO((struct hblk *h, word n));
+void GC_is_fresh(struct hblk *h, word n);
/* Assert the region currently contains no */
/* valid pointers. */
-void GC_remove_protection GC_PROTO((struct hblk *h, word nblocks,
- GC_bool pointerfree));
+void GC_remove_protection(struct hblk *h, word nblocks,
+ GC_bool pointerfree);
/* h is about to be writteni or allocated. Ensure */
/* that it's not write protected by the virtual */
/* dirty bit implementation. */
-void GC_dirty_init GC_PROTO((void));
+void GC_dirty_init(void);
/* Slow/general mark bit manipulation: */
-GC_API GC_bool GC_is_marked GC_PROTO((ptr_t p));
-void GC_clear_mark_bit GC_PROTO((ptr_t p));
-void GC_set_mark_bit GC_PROTO((ptr_t p));
+GC_API GC_bool GC_is_marked(ptr_t p);
+void GC_clear_mark_bit(ptr_t p);
+void GC_set_mark_bit(ptr_t p);
/* Stubborn objects: */
-void GC_read_changed GC_PROTO((void)); /* Analogous to GC_read_dirty */
-GC_bool GC_page_was_changed GC_PROTO((struct hblk * h));
+void GC_read_changed(void); /* Analogous to GC_read_dirty */
+GC_bool GC_page_was_changed(struct hblk * h);
/* Analogous to GC_page_was_dirty */
-void GC_clean_changing_list GC_PROTO((void));
+void GC_clean_changing_list(void);
/* Collect obsolete changing list entries */
-void GC_stubborn_init GC_PROTO((void));
+void GC_stubborn_init(void);
/* Debugging print routines: */
-void GC_print_block_list GC_PROTO((void));
-void GC_print_hblkfreelist GC_PROTO((void));
-void GC_print_heap_sects GC_PROTO((void));
-void GC_print_static_roots GC_PROTO((void));
-void GC_print_finalization_stats GC_PROTO((void));
-void GC_dump GC_PROTO((void));
+void GC_print_block_list(void);
+void GC_print_hblkfreelist(void);
+void GC_print_heap_sects(void);
+void GC_print_static_roots(void);
+void GC_print_finalization_stats(void);
+void GC_dump(void);
#ifdef KEEP_BACK_PTRS
void GC_store_back_pointer(ptr_t source, ptr_t dest);
@@ -1833,50 +1802,22 @@ void GC_dump GC_PROTO((void));
# endif
# endif
-void GC_noop1 GC_PROTO((word));
+void GC_noop1(word);
/* Logging and diagnostic output: */
-GC_API void GC_printf GC_PROTO((GC_CONST char * format, long, long, long, long, long, long));
+GC_API void GC_printf (const char * format, ...);
/* A version of printf that doesn't allocate, */
- /* is restricted to long arguments, and */
- /* (unfortunately) doesn't use varargs for */
- /* portability. Restricted to 6 args and */
/* 1K total output length. */
/* (We use sprintf. Hopefully that doesn't */
/* allocate for long arguments.) */
-# define GC_printf0(f) GC_printf(f, 0l, 0l, 0l, 0l, 0l, 0l)
-# define GC_printf1(f,a) GC_printf(f, (long)a, 0l, 0l, 0l, 0l, 0l)
-# define GC_printf2(f,a,b) GC_printf(f, (long)a, (long)b, 0l, 0l, 0l, 0l)
-# define GC_printf3(f,a,b,c) GC_printf(f, (long)a, (long)b, (long)c, 0l, 0l, 0l)
-# define GC_printf4(f,a,b,c,d) GC_printf(f, (long)a, (long)b, (long)c, \
- (long)d, 0l, 0l)
-# define GC_printf5(f,a,b,c,d,e) GC_printf(f, (long)a, (long)b, (long)c, \
- (long)d, (long)e, 0l)
-# define GC_printf6(f,a,b,c,d,e,g) GC_printf(f, (long)a, (long)b, (long)c, \
- (long)d, (long)e, (long)g)
-
-GC_API void GC_err_printf GC_PROTO((GC_CONST char * format, long, long, long, long, long, long));
-# define GC_err_printf0(f) GC_err_puts(f)
-# define GC_err_printf1(f,a) GC_err_printf(f, (long)a, 0l, 0l, 0l, 0l, 0l)
-# define GC_err_printf2(f,a,b) GC_err_printf(f, (long)a, (long)b, 0l, 0l, 0l, 0l)
-# define GC_err_printf3(f,a,b,c) GC_err_printf(f, (long)a, (long)b, (long)c, \
- 0l, 0l, 0l)
-# define GC_err_printf4(f,a,b,c,d) GC_err_printf(f, (long)a, (long)b, \
- (long)c, (long)d, 0l, 0l)
-# define GC_err_printf5(f,a,b,c,d,e) GC_err_printf(f, (long)a, (long)b, \
- (long)c, (long)d, \
- (long)e, 0l)
-# define GC_err_printf6(f,a,b,c,d,e,g) GC_err_printf(f, (long)a, (long)b, \
- (long)c, (long)d, \
- (long)e, (long)g)
- /* Ditto, writes to stderr. */
-
-void GC_err_puts GC_PROTO((GC_CONST char *s));
+GC_API void GC_err_printf(const char * format, ...);
+GC_API void GC_log_printf(const char * format, ...);
+void GC_err_puts(const char *s);
/* Write s to stderr, don't buffer, don't add */
/* newlines, don't ... */
#if defined(LINUX) && !defined(SMALL_CONFIG)
- void GC_err_write GC_PROTO((GC_CONST char *buf, size_t len));
+ void GC_err_write(const char *buf, size_t len);
/* Write buf to stderr, don't buffer, don't add */
/* newlines, don't ... */
#endif
@@ -1884,7 +1825,7 @@ void GC_err_puts GC_PROTO((GC_CONST char *s));
# ifdef GC_ASSERTIONS
# define GC_ASSERT(expr) if(!(expr)) {\
- GC_err_printf2("Assertion failure: %s:%ld\n", \
+ GC_err_printf("Assertion failure: %s:%ld\n", \
__FILE__, (unsigned long)__LINE__); \
ABORT("assertion failure"); }
# else
diff --git a/include/private/gcconfig.h b/include/private/gcconfig.h
index 280b48b..0760e9f 100644
--- a/include/private/gcconfig.h
+++ b/include/private/gcconfig.h
@@ -68,14 +68,10 @@
# endif
# endif
# if defined(sun) && defined(mc68000)
-# define M68K
-# define SUNOS4
-# define mach_type_known
+# error SUNOS4 no longer supported
# endif
# if defined(hp9000s300)
-# define M68K
-# define HP
-# define mach_type_known
+# error M68K based HP machines no longer supported.
# endif
# if defined(OPENBSD) && defined(m68k)
# define M68K
@@ -123,12 +119,7 @@
# if defined(ultrix) || defined(__ultrix)
# define ULTRIX
# else
-# if defined(_SYSTYPE_SVR4) || defined(SYSTYPE_SVR4) \
- || defined(__SYSTYPE_SVR4__)
-# define IRIX5 /* or IRIX 6.X */
-# else
-# define RISCOS /* or IRIX 4.X */
-# endif
+# define IRIX5 /* or IRIX 6.X */
# endif
# endif /* !LINUX */
# if defined(__NetBSD__) && defined(__MIPSEL__)
@@ -159,22 +150,17 @@
# define mach_type_known
# endif
# if defined(ibm032)
-# define RT
-# define mach_type_known
+# error IBM PC/RT no longer supported.
# endif
# if defined(sun) && (defined(sparc) || defined(__sparc))
# define SPARC
/* Test for SunOS 5.x */
# include <errno.h>
-# ifdef ECHRNG
-# define SUNOS5
-# else
-# define SUNOS4
-# endif
+# define SUNOS5
# define mach_type_known
# endif
# if defined(sparc) && defined(unix) && !defined(sun) && !defined(linux) \
- && !defined(__OpenBSD__) && !defined(__NetBSD__) && !defined(__FreeBSD__)
+ && !defined(__OpenBSD__) && !(__NetBSD__)
# define SPARC
# define DRSNX
# define mach_type_known
@@ -198,9 +184,7 @@
# define mach_type_known
# endif
# if defined(_AUX_SOURCE)
-# define M68K
-# define SYSV
-# define mach_type_known
+# error A/UX no longer supported
# endif
# if defined(_PA_RISC1_0) || defined(_PA_RISC1_1) || defined(_PA_RISC2_0) \
|| defined(hppa) || defined(__hppa__)
@@ -236,12 +220,6 @@
# define ARM32
# define mach_type_known
# endif
-# if defined(LINUX) && defined(__cris__)
-# ifndef CRIS
-# define CRIS
-# endif
-# define mach_type_known
-# endif
# if defined(LINUX) && (defined(powerpc) || defined(__powerpc__) || defined(powerpc64) || defined(__powerpc64__))
# define POWERPC
# define mach_type_known
@@ -262,10 +240,6 @@
# define SH
# define mach_type_known
# endif
-# if defined(LINUX) && defined(__m32r__)
-# define M32R
-# define mach_type_known
-# endif
# if defined(__alpha) || defined(__alpha__)
# define ALPHA
# if !defined(LINUX) && !defined(NETBSD) && !defined(OPENBSD) && !defined(FREEBSD)
@@ -328,10 +302,6 @@
# define X86_64
# define mach_type_known
# endif
-# if defined(FREEBSD) && defined(__sparc__)
-# define SPARC
-# define mach_type_known
-#endif
# if defined(bsdi) && (defined(i386) || defined(__i386__))
# define I386
# define BSDI
@@ -448,15 +418,14 @@
/* Or manually define the machine type here. A machine type is */
/* characterized by the architecture. Some */
/* machine types are further subdivided by OS. */
-/* the macros ULTRIX, RISCOS, and BSD to distinguish. */
-/* Note that SGI IRIX is treated identically to RISCOS. */
+/* Macros such as LINUX, FREEBSD, etc. distinguish them. */
/* SYSV on an M68K actually means A/UX. */
/* The distinction in these cases is usually the stack starting address */
# ifndef mach_type_known
--> unknown machine type
# endif
/* Mapping is: M68K ==> Motorola 680X0 */
- /* (SUNOS4,HP,NEXT, and SYSV (A/UX), */
+ /* (NEXT, and SYSV (A/UX), */
/* MACOS and AMIGA variants) */
/* I386 ==> Intel 386 */
/* (SEQUENT, OS2, SCO, LINUX, NETBSD, */
@@ -464,16 +433,14 @@
/* BSDI,SUNOS5, NEXT, other variants) */
/* NS32K ==> Encore Multimax */
/* MIPS ==> R2000 or R3000 */
- /* (RISCOS, ULTRIX variants) */
+ /* (ULTRIX variants) */
/* VAX ==> DEC VAX */
/* (BSD, ULTRIX variants) */
/* RS6000 ==> IBM RS/6000 AIX3.X */
- /* RT ==> IBM PC/RT */
/* HP_PA ==> HP9000/700 & /800 */
/* HP/UX, LINUX */
/* SPARC ==> SPARC v7/v8/v9 */
- /* (SUNOS4, SUNOS5, LINUX, */
- /* DRSNX variants) */
+ /* (SUNOS5, LINUX, DRSNX variants) */
/* ALPHA ==> DEC Alpha */
/* (OSF1 and LINUX variants) */
/* M88K ==> Motorola 88XX0 */
@@ -492,8 +459,6 @@
/* POWERPC ==> IBM/Apple PowerPC */
/* (MACOS(<=9),DARWIN(incl.MACOSX),*/
/* LINUX, NETBSD, NOSYS variants) */
- /* CRIS ==> Axis Etrax */
- /* M32R ==> Renesas M32R */
/*
@@ -529,9 +494,6 @@
* cause failures on alpha*-*-* with ``-msmall-data or -fpic'' or mips-*-*
* without any special options.
*
- * ALIGN_DOUBLE of GC_malloc should return blocks aligned to twice
- * the pointer size.
- *
* STACKBOTTOM is the cool end of the stack, which is usually the
* highest address in the stack.
* Under PCR or OS/2, we have other ways of finding thread stacks.
@@ -683,43 +645,6 @@
# define DATASTART ((ptr_t)((((word) (etext)) + 0xfff) & ~0xfff))
# endif
# endif
-# ifdef SUNOS4
-# define OS_TYPE "SUNOS4"
- extern char etext[];
-# define DATASTART ((ptr_t)((((word) (etext)) + 0x1ffff) & ~0x1ffff))
-# define HEURISTIC1 /* differs */
-# define DYNAMIC_LOADING
-# endif
-# ifdef HP
-# define OS_TYPE "HP"
- extern char etext[];
-# define DATASTART ((ptr_t)((((word) (etext)) + 0xfff) & ~0xfff))
-# define STACKBOTTOM ((ptr_t) 0xffeffffc)
- /* empirically determined. seems to work. */
-# include <unistd.h>
-# define GETPAGESIZE() sysconf(_SC_PAGE_SIZE)
-# endif
-# ifdef SYSV
-# define OS_TYPE "SYSV"
- extern etext[];
-# define DATASTART ((ptr_t)((((word) (etext)) + 0x3fffff) \
- & ~0x3fffff) \
- +((word)etext & 0x1fff))
- /* This only works for shared-text binaries with magic number 0413.
- The other sorts of SysV binaries put the data at the end of the text,
- in which case the default of etext would work. Unfortunately,
- handling both would require having the magic-number available.
- -- Parag
- */
-# define STACKBOTTOM ((ptr_t)0xFFFFFFFE)
- /* The stack starts at the top of memory, but */
- /* 0x0 cannot be used as setjump_test complains */
- /* that the stack direction is incorrect. Two */
- /* bytes down from 0x0 should be safe enough. */
- /* --Parag */
-# include <sys/mmu.h>
-# define GETPAGESIZE() PAGESIZE /* Is this still right? */
-# endif
# ifdef AMIGA
# define OS_TYPE "AMIGA"
/* STACKBOTTOM and DATASTART handled specially */
@@ -786,10 +711,8 @@
# define USE_MMAP_ANON
# define USE_ASM_PUSH_REGS
/* This is potentially buggy. It needs more testing. See the comments in
- os_dep.c. It relies on threads to track writes. */
-# ifdef GC_DARWIN_THREADS
-# define MPROTECT_VDB
-# endif
+ os_dep.c */
+# define MPROTECT_VDB
# include <unistd.h>
# define GETPAGESIZE() getpagesize()
# if defined(USE_PPC_PREFETCH) && defined(__GNUC__)
@@ -840,13 +763,6 @@
# endif
# endif
-# ifdef RT
-# define MACH_TYPE "RT"
-# define ALIGNMENT 4
-# define DATASTART ((ptr_t) 0x10000000)
-# define STACKBOTTOM ((ptr_t) 0x1fffd800)
-# endif
-
# ifdef SPARC
# define MACH_TYPE "SPARC"
# if defined(__arch64__) || defined(__sparcv9)
@@ -857,13 +773,12 @@
# define ALIGNMENT 4 /* Required by hardware */
# define CPP_WORDSZ 32
# endif
-# define ALIGN_DOUBLE
# ifdef SUNOS5
# define OS_TYPE "SUNOS5"
extern int _etext[];
extern int _end[];
- extern ptr_t GC_SysVGetDataStart();
-# define DATASTART GC_SysVGetDataStart(0x10000, _etext)
+ extern ptr_t GC_SysVGetDataStart(size_t, ptr_t);
+# define DATASTART GC_SysVGetDataStart(0x10000, (ptr_t)_etext)
# define DATAEND (_end)
# if !defined(USE_MMAP) && defined(REDIRECT_MALLOC)
# define USE_MMAP
@@ -896,30 +811,11 @@
/* Solaris 5.4 installation. Weird. */
# define DYNAMIC_LOADING
# endif
-# ifdef SUNOS4
-# define OS_TYPE "SUNOS4"
- /* [If you have a weak stomach, don't read this.] */
- /* We would like to use: */
-/* # define DATASTART ((ptr_t)((((word) (etext)) + 0x1fff) & ~0x1fff)) */
- /* This fails occasionally, due to an ancient, but very */
- /* persistent ld bug. etext is set 32 bytes too high. */
- /* We instead read the text segment size from the a.out */
- /* header, which happens to be mapped into our address space */
- /* at the start of the text segment. The detective work here */
- /* was done by Robert Ehrlich, Manuel Serrano, and Bernard */
- /* Serpette of INRIA. */
- /* This assumes ZMAGIC, i.e. demand-loadable executables. */
-# define TEXTSTART 0x2000
-# define DATASTART ((ptr_t)(*(int *)(TEXTSTART+0x4)+TEXTSTART))
-# define MPROTECT_VDB
-# define HEURISTIC1
-# define DYNAMIC_LOADING
-# endif
# ifdef DRSNX
# define OS_TYPE "DRSNX"
- extern ptr_t GC_SysVGetDataStart();
+ extern ptr_t GC_SysVGetDataStart(size_t, ptr_t);
extern int etext[];
-# define DATASTART GC_SysVGetDataStart(0x10000, etext)
+# define DATASTART GC_SysVGetDataStart(0x10000, (ptr_t)etext)
# define MPROTECT_VDB
# define STACKBOTTOM ((ptr_t) 0xdfff0000)
# define DYNAMIC_LOADING
@@ -935,13 +831,13 @@
extern int _etext[];
# define DATAEND (_end)
# define SVR4
- extern ptr_t GC_SysVGetDataStart();
+ extern ptr_t GC_SysVGetDataStart(size_t, ptr_t);
# ifdef __arch64__
-# define DATASTART GC_SysVGetDataStart(0x100000, _etext)
+# define DATASTART GC_SysVGetDataStart(0x100000, (ptr_t)_etext)
/* libc_stack_end is not set reliably for sparc64 */
# define STACKBOTTOM ((ptr_t) 0x80000000000ULL)
# else
-# define DATASTART GC_SysVGetDataStart(0x10000, _etext)
+# define DATASTART GC_SysVGetDataStart(0x10000, (ptr_t)_etext)
# define LINUX_STACKBOTTOM
# endif
# endif
@@ -962,23 +858,6 @@
# define DATASTART ((ptr_t)(etext))
# endif
# endif
-# ifdef FREEBSD
-# define OS_TYPE "FREEBSD"
-# define SIG_SUSPEND SIGUSR1
-# define SIG_THR_RESTART SIGUSR2
-# define FREEBSD_STACKBOTTOM
-# ifdef __ELF__
-# define DYNAMIC_LOADING
-# endif
- extern char etext[];
- extern char edata[];
- extern char end[];
-# define NEED_FIND_LIMIT
-# define DATASTART ((ptr_t)(&etext))
-# define DATAEND (GC_find_limit (DATASTART, TRUE))
-# define DATASTART2 ((ptr_t)(&edata))
-# define DATAEND2 ((ptr_t)(&end))
-# endif
# endif
# ifdef I386
@@ -994,10 +873,6 @@
/* Borland. */
/* Ivan Demakov: For Watcom the option is -zp4. */
# endif
-# ifndef SMALL_CONFIG
-# define ALIGN_DOUBLE /* Not strictly necessary, but may give speed */
- /* improvement on Pentiums. */
-# endif
# ifdef HAVE_BUILTIN_UNWIND_INIT
# define USE_GENERIC_PUSH_REGS
# endif
@@ -1017,8 +892,8 @@
# ifdef SUNOS5
# define OS_TYPE "SUNOS5"
extern int _etext[], _end[];
- extern ptr_t GC_SysVGetDataStart();
-# define DATASTART GC_SysVGetDataStart(0x1000, _etext)
+ extern ptr_t GC_SysVGetDataStart(size_t, ptr_t);
+# define DATASTART GC_SysVGetDataStart(0x1000, (ptr_t)_etext)
# define DATAEND (_end)
/* # define STACKBOTTOM ((ptr_t)(_start)) worked through 2.7, */
/* but reportedly breaks under 2.8. It appears that the stack */
@@ -1065,8 +940,8 @@
# ifdef DGUX
# define OS_TYPE "DGUX"
extern int _etext, _end;
- extern ptr_t GC_SysVGetDataStart();
-# define DATASTART GC_SysVGetDataStart(0x1000, &_etext)
+ extern ptr_t GC_SysVGetDataStart(size_t, ptr_t);
+# define DATASTART GC_SysVGetDataStart(0x1000, (ptr_t)(&_etext))
# define DATAEND (&_end)
# define STACK_GROWS_DOWN
# define HEURISTIC2
@@ -1234,8 +1109,8 @@
# define DYNAMIC_LOADING
# endif
extern char etext[];
- extern char * GC_FreeBSDGetDataStart();
-# define DATASTART GC_FreeBSDGetDataStart(0x1000, &etext)
+ extern char * GC_FreeBSDGetDataStart(size_t, ptr_t);
+# define DATASTART GC_FreeBSDGetDataStart(0x1000, (ptr_t)etext)
# endif
# ifdef NETBSD
# define OS_TYPE "NETBSD"
@@ -1351,12 +1226,6 @@
# define OS_TYPE "ULTRIX"
# define ALIGNMENT 4
# endif
-# ifdef RISCOS
-# define HEURISTIC2
-# define DATASTART (ptr_t)0x10000000
-# define OS_TYPE "RISCOS"
-# define ALIGNMENT 4 /* Required by hardware */
-# endif
# ifdef IRIX5
# define HEURISTIC2
extern int _fdata[];
@@ -1377,12 +1246,8 @@
# ifdef _MIPS_SZPTR
# define CPP_WORDSZ _MIPS_SZPTR
# define ALIGNMENT (_MIPS_SZPTR/8)
-# if CPP_WORDSZ != 64
-# define ALIGN_DOUBLE
-# endif
# else
# define ALIGNMENT 4
-# define ALIGN_DOUBLE
# endif
# define DYNAMIC_LOADING
# endif
@@ -1449,7 +1314,6 @@
# else
# define CPP_WORDSZ 32
# define ALIGNMENT 4
-# define ALIGN_DOUBLE
# endif
# if !defined(GC_HPUX_THREADS) && !defined(GC_LINUX_THREADS)
# ifndef LINUX /* For now. */
@@ -1609,7 +1473,6 @@
# ifdef HPUX
# ifdef _ILP32
# define CPP_WORDSZ 32
-# define ALIGN_DOUBLE
/* Requires 8 byte alignment for malloc */
# define ALIGNMENT 4
# else
@@ -1617,7 +1480,6 @@
---> unknown ABI
# endif
# define CPP_WORDSZ 64
-# define ALIGN_DOUBLE
/* Requires 16 byte alignment for malloc */
# define ALIGNMENT 8
# endif
@@ -1645,8 +1507,6 @@
# endif
# ifdef LINUX
# define CPP_WORDSZ 64
-# define ALIGN_DOUBLE
- /* Requires 16 byte alignment for malloc */
# define ALIGNMENT 8
# define OS_TYPE "LINUX"
/* The following works on NUE and older kernels: */
@@ -1704,13 +1564,13 @@
# define CPP_WORDSZ 32 /* Is this possible? */
# endif
# define ALIGNMENT 8
+# define STRTOULL _strtoui64
# endif
# endif
# ifdef M88K
# define MACH_TYPE "M88K"
# define ALIGNMENT 4
-# define ALIGN_DOUBLE
extern int etext[];
# ifdef CX_UX
# define OS_TYPE "CX_UX"
@@ -1718,8 +1578,8 @@
# endif
# ifdef DGUX
# define OS_TYPE "DGUX"
- extern ptr_t GC_SysVGetDataStart();
-# define DATASTART GC_SysVGetDataStart(0x10000, etext)
+ extern ptr_t GC_SysVGetDataStart(size_t, ptr_t);
+# define DATASTART GC_SysVGetDataStart(0x10000, (ptr_t)etext)
# endif
# define STACKBOTTOM ((char*)0xf0000000) /* determined empirically */
# endif
@@ -1735,8 +1595,8 @@
extern int etext[];
extern int _etext[];
extern int _end[];
- extern ptr_t GC_SysVGetDataStart();
-# define DATASTART GC_SysVGetDataStart(0x10000, _etext)
+ extern ptr_t GC_SysVGetDataStart(size_t, ptr_t);
+# define DATASTART GC_SysVGetDataStart(0x10000, (ptr_t)_etext)
# define DATAEND (_end)
# define HEURISTIC2
# endif
@@ -1834,19 +1694,6 @@
# endif
#endif
-# ifdef CRIS
-# define MACH_TYPE "CRIS"
-# define CPP_WORDSZ 32
-# define ALIGNMENT 1
-# define OS_TYPE "LINUX"
-# define DYNAMIC_LOADING
-# define LINUX_STACKBOTTOM
-# define USE_GENERIC_PUSH_REGS
-# define SEARCH_FOR_DATA_START
- extern int _end[];
-# define DATAEND (_end)
-# endif
-
# ifdef SH
# define MACH_TYPE "SH"
# define ALIGNMENT 4
@@ -1879,23 +1726,6 @@
# define DATAEND /* not needed */
# endif
-# ifdef M32R
-# define CPP_WORDSZ 32
-# define MACH_TYPE "M32R"
-# define ALIGNMENT 4
-# ifdef LINUX
-# define OS_TYPE "LINUX"
-# define LINUX_STACKBOTTOM
-# undef STACK_GRAN
-# define STACK_GRAN 0x10000000
-# define USE_GENERIC_PUSH_REGS
-# define DYNAMIC_LOADING
-# define SEARCH_FOR_DATA_START
- extern int _end[];
-# define DATAEND (_end)
-# endif
-# endif
-
# ifdef X86_64
# define MACH_TYPE "X86_64"
# define ALIGNMENT 8
@@ -1982,7 +1812,8 @@
# endif
# ifndef GETPAGESIZE
-# if defined(SUNOS5) || defined(IRIX5)
+# if defined(SUNOS5) || defined(IRIX5) || defined(LINUX) \
+ || defined(NETBSD) || defined(FREEBSD) || defined(HPUX)
# include <unistd.h>
# endif
# define GETPAGESIZE() getpagesize()
@@ -2011,7 +1842,7 @@
# if defined(SVR4) || defined(LINUX) || defined(IRIX5) || defined(HPUX) \
|| defined(OPENBSD) || defined(NETBSD) || defined(FREEBSD) \
- || defined(DGUX) || defined(BSD) || defined(SUNOS4) \
+ || defined(DGUX) || defined(BSD) \
|| defined(_AIX) || defined(DARWIN) || defined(OSF1)
# define UNIX_LIKE /* Basic Unix-like system calls work. */
# endif
@@ -2119,7 +1950,7 @@
# endif
# if defined(HP_PA) || defined(M88K) || defined(POWERPC) && !defined(DARWIN) \
- || defined(LINT) || defined(MSWINCE) || defined(ARM32) || defined(CRIS) \
+ || defined(LINT) || defined(MSWINCE) || defined(ARM32) \
|| (defined(I386) && defined(__LCC__))
/* Use setjmp based hack to mark from callee-save registers. */
/* The define should move to the individual platform */
@@ -2168,7 +1999,7 @@
# ifdef SAVE_CALL_CHAIN
# ifndef SAVE_CALL_COUNT
# define NFRAMES 6 /* Number of frames to save. Even for */
- /* alignment reasons. */
+ /* alignment reasons. */
# else
# define NFRAMES ((SAVE_CALL_COUNT + 1) & ~1)
# endif
@@ -2203,6 +2034,14 @@
# define FIXUP_POINTER(p)
# endif
+# if !defined(MARK_BIT_PER_GRANULE) && !defined(MARK_BIT_PER_OBJ)
+# define MARK_BIT_PER_GRANULE /* Usually faster */
+# endif
+
+# if defined(MARK_BIT_PER_GRANULE) && defined(MARK_BIT_PER_OBJ)
+# error Define only one of MARK_BIT_PER_GRANULE and MARK_BIT_PER_OBJ.
+# endif
+
#ifdef GC_PRIVATE_H
/* This relies on some type definitions from gc_priv.h, from */
/* where it's normally included. */
diff --git a/include/private/pthread_support.h b/include/private/pthread_support.h
index d52e4da..b173382 100644
--- a/include/private/pthread_support.h
+++ b/include/private/pthread_support.h
@@ -50,22 +50,21 @@ typedef struct GC_Thread_Rep {
/* reclamation of any data it might */
/* reference. */
# ifdef THREAD_LOCAL_ALLOC
-# if CPP_WORDSZ == 64 && defined(ALIGN_DOUBLE)
-# define GRANULARITY 16
-# define NFREELISTS 49
-# else
-# define GRANULARITY 8
-# define NFREELISTS 65
-# endif
- /* The ith free list corresponds to size i*GRANULARITY */
-# define INDEX_FROM_BYTES(n) ((ADD_SLOP(n) + GRANULARITY - 1)/GRANULARITY)
-# define BYTES_FROM_INDEX(i) ((i) * GRANULARITY - EXTRA_BYTES)
+ /* The ith free list corresponds to size i*GRANULE_BYTES */
+ /* Convert the number of requested bytes to a suitable free */
+ /* list index, adding EXTRA_BYTES if appripriate. */
+# define INDEX_FROM_REQUESTED_BYTES(n) \
+ ((ADD_SLOP(n) + GRANULE_BYTES - 1)/GRANULE_BYTES)
+ /* Convert a free list index to the actual size of objects */
+ /* on that list, including extra space we added. Not an */
+ /* inverse of the above. */
+# define RAW_BYTES_FROM_INDEX(i) ((i) * GRANULE_BYTES)
# define SMALL_ENOUGH(bytes) (ADD_SLOP(bytes) <= \
- (NFREELISTS-1)*GRANULARITY)
- ptr_t ptrfree_freelists[NFREELISTS];
- ptr_t normal_freelists[NFREELISTS];
+ (TINY_FREELISTS-1)*GRANULE_BYTES)
+ void * ptrfree_freelists[TINY_FREELISTS];
+ void * normal_freelists[TINY_FREELISTS];
# ifdef GC_GCJ_SUPPORT
- ptr_t gcj_freelists[NFREELISTS];
+ void * gcj_freelists[TINY_FREELISTS];
# endif
/* Free lists contain either a pointer or a small count */
/* reflecting the number of granules allocated at that */
@@ -78,7 +77,7 @@ typedef struct GC_Thread_Rep {
/* >= HBLKSIZE => pointer to nonempty free list. */
/* > DIRECT_GRANULES, < HBLKSIZE ==> transition to */
/* local alloc, equivalent to 0. */
-# define DIRECT_GRANULES (HBLKSIZE/GRANULARITY)
+# define DIRECT_GRANULES (HBLKSIZE/GRANULE_BYTES)
/* Don't use local free lists for up to this much */
/* allocation. */
# endif
diff --git a/include/private/solaris_threads.h b/include/private/solaris_threads.h
deleted file mode 100644
index b1f6262..0000000
--- a/include/private/solaris_threads.h
+++ /dev/null
@@ -1,37 +0,0 @@
-#ifdef GC_SOLARIS_THREADS
-
-/* The set of all known threads. We intercept thread creation and */
-/* joins. We never actually create detached threads. We allocate all */
-/* new thread stacks ourselves. These allow us to maintain this */
-/* data structure. */
-/* Protected by GC_thr_lock. */
-/* Some of this should be declared volatile, but that's incosnsistent */
-/* with some library routine declarations. In particular, the */
-/* definition of cond_t doesn't mention volatile! */
- typedef struct GC_Thread_Rep {
- struct GC_Thread_Rep * next;
- thread_t id;
- word flags;
-# define FINISHED 1 /* Thread has exited. */
-# define DETACHED 2 /* Thread is intended to be detached. */
-# define CLIENT_OWNS_STACK 4
- /* Stack was supplied by client. */
-# define SUSPNDED 8 /* Currently suspended. */
- /* SUSPENDED is used insystem header. */
- ptr_t stack;
- size_t stack_size;
- cond_t join_cv;
- void * status;
- } * GC_thread;
- extern GC_thread GC_new_thread(thread_t id);
-
- extern GC_bool GC_thr_initialized;
- extern volatile GC_thread GC_threads[];
- extern size_t GC_min_stack_sz;
- extern size_t GC_page_sz;
- extern void GC_thr_init(void);
- extern ptr_t GC_stack_alloc(size_t * stack_size);
- extern void GC_stack_free(ptr_t stack, size_t size);
-
-# endif /* GC_SOLARIS_THREADS */
-
diff --git a/include/private/specific.h b/include/private/specific.h
index d04e19f..fc2e8f9 100644
--- a/include/private/specific.h
+++ b/include/private/specific.h
@@ -13,6 +13,7 @@
*/
#include <errno.h>
+#include "atomic_ops.h"
/* Called during key creation or setspecific. */
/* For the GC we already hold lock. */
@@ -34,7 +35,7 @@
/* value. This invariant must be preserved at ALL times, since */
/* asynchronous reads are allowed. */
typedef struct thread_specific_entry {
- unsigned long qtid; /* quick thread id, only for cache */
+ volatile AO_t qtid; /* quick thread id, only for cache */
void * value;
struct thread_specific_entry *next;
pthread_t thread;
diff --git a/mach_dep.c b/mach_dep.c
index c0d01b3..b11ad6a 100644
--- a/mach_dep.c
+++ b/mach_dep.c
@@ -94,7 +94,7 @@ void GC_push_regs()
asm("pushl r6"); asm("calls $1,_GC_push_one");
# define HAVE_PUSH_REGS
# endif
-# if defined(M68K) && (defined(SUNOS4) || defined(NEXT))
+# if defined(M68K) && defined(NEXT)
/* M68K SUNOS - could be replaced by generic code */
/* a0, a1 and d1 are caller save */
/* and therefore are on stack or dead. */
@@ -465,7 +465,7 @@ ptr_t cold_gc_frame;
/* the stack. Return sp. */
# ifdef SPARC
asm(" .seg \"text\"");
-# if defined(SVR4) || defined(NETBSD) || defined(FREEBSD)
+# if defined(SVR4) || defined(NETBSD)
asm(" .globl GC_save_regs_in_stack");
asm("GC_save_regs_in_stack:");
asm(" .type GC_save_regs_in_stack,#function");
@@ -547,14 +547,9 @@ ptr_t cold_gc_frame;
#ifndef SPARC
--> fix it
#endif
-# ifdef SUNOS4
- asm(".globl _GC_clear_stack_inner");
- asm("_GC_clear_stack_inner:");
-# else
- asm(".globl GC_clear_stack_inner");
- asm("GC_clear_stack_inner:");
- asm(".type GC_save_regs_in_stack,#function");
-# endif
+ asm(".globl GC_clear_stack_inner");
+ asm("GC_clear_stack_inner:");
+ asm(".type GC_save_regs_in_stack,#function");
#if defined(__arch64__) || defined(__sparcv9)
asm("mov %sp,%o2"); /* Save sp */
asm("add %sp,2047-8,%o3"); /* p = sp+bias-8 */
diff --git a/malloc.c b/malloc.c
index cb3f376..879aa94 100644
--- a/malloc.c
+++ b/malloc.c
@@ -1,7 +1,7 @@
/*
* Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
* Copyright (c) 1991-1994 by Xerox Corporation. All rights reserved.
- * Copyright (c) 2000 by Hewlett-Packard Company. All rights reserved.
+ * Copyright (c) 1999-2004 Hewlett-Packard Development Company, L.P.
*
* THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
* OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
@@ -12,53 +12,52 @@
* provided the above notices are retained, and a notice that the code was
* modified is included with the above copyright notice.
*/
-/* Boehm, February 7, 1996 4:32 pm PST */
#include <stdio.h>
#include "private/gc_priv.h"
-extern ptr_t GC_clear_stack(); /* in misc.c, behaves like identity */
-void GC_extend_size_map(); /* in misc.c. */
+extern void * GC_clear_stack(void *); /* in misc.c, behaves like identity */
+void GC_extend_size_map(size_t); /* in misc.c. */
/* Allocate reclaim list for kind: */
/* Return TRUE on success */
-GC_bool GC_alloc_reclaim_list(kind)
-register struct obj_kind * kind;
+GC_bool GC_alloc_reclaim_list(struct obj_kind *kind)
{
struct hblk ** result = (struct hblk **)
- GC_scratch_alloc((MAXOBJSZ+1) * sizeof(struct hblk *));
+ GC_scratch_alloc((MAXOBJGRANULES+1) * sizeof(struct hblk *));
if (result == 0) return(FALSE);
- BZERO(result, (MAXOBJSZ+1)*sizeof(struct hblk *));
+ BZERO(result, (MAXOBJGRANULES+1)*sizeof(struct hblk *));
kind -> ok_reclaim_list = result;
return(TRUE);
}
-/* Allocate a large block of size lw words. */
+/* Allocate a large block of size lb bytes. */
/* The block is not cleared. */
/* Flags is 0 or IGNORE_OFF_PAGE. */
/* We hold the allocation lock. */
-ptr_t GC_alloc_large(lw, k, flags)
-word lw;
-int k;
-unsigned flags;
+/* EXTRA_BYTES were already added to lb. */
+ptr_t GC_alloc_large(size_t lb, int k, unsigned flags)
{
struct hblk * h;
- word n_blocks = OBJ_SZ_TO_BLOCKS(lw);
+ word n_blocks;
ptr_t result;
+ /* Round up to a multiple of a granule. */
+ lb = (lb + GRANULE_BYTES - 1) & ~(GRANULE_BYTES - 1);
+ n_blocks = OBJ_SZ_TO_BLOCKS(lb);
if (!GC_is_initialized) GC_init_inner();
/* Do our share of marking work */
if(GC_incremental && !GC_dont_gc)
GC_collect_a_little_inner((int)n_blocks);
- h = GC_allochblk(lw, k, flags);
+ h = GC_allochblk(lb, k, flags);
# ifdef USE_MUNMAP
if (0 == h) {
GC_merge_unmapped();
- h = GC_allochblk(lw, k, flags);
+ h = GC_allochblk(lb, k, flags);
}
# endif
while (0 == h && GC_collect_or_expand(n_blocks, (flags != 0))) {
- h = GC_allochblk(lw, k, flags);
+ h = GC_allochblk(lb, k, flags);
}
if (h == 0) {
result = 0;
@@ -69,8 +68,8 @@ unsigned flags;
if (GC_large_allocd_bytes > GC_max_large_allocd_bytes)
GC_max_large_allocd_bytes = GC_large_allocd_bytes;
}
- result = (ptr_t) (h -> hb_body);
- GC_words_wasted += BYTES_TO_WORDS(total_bytes) - lw;
+ result = h -> hb_body;
+ GC_bytes_wasted += total_bytes - lb;
}
return result;
}
@@ -78,13 +77,11 @@ unsigned flags;
/* Allocate a large block of size lb bytes. Clear if appropriate. */
/* We hold the allocation lock. */
-ptr_t GC_alloc_large_and_clear(lw, k, flags)
-word lw;
-int k;
-unsigned flags;
+/* EXTRA_BYTES were already added to lb. */
+ptr_t GC_alloc_large_and_clear(size_t lb, int k, unsigned flags)
{
- ptr_t result = GC_alloc_large(lw, k, flags);
- word n_blocks = OBJ_SZ_TO_BLOCKS(lw);
+ ptr_t result = GC_alloc_large(lb, k, flags);
+ word n_blocks = OBJ_SZ_TO_BLOCKS(lb);
if (0 == result) return 0;
if (GC_debugging_started || GC_obj_kinds[k].ok_init) {
@@ -100,60 +97,34 @@ unsigned flags;
/* require special handling on allocation. */
/* First a version that assumes we already */
/* hold lock: */
-ptr_t GC_generic_malloc_inner(lb, k)
-register word lb;
-register int k;
+void * GC_generic_malloc_inner(size_t lb, int k)
{
-register word lw;
-register ptr_t op;
-register ptr_t *opp;
+size_t lg;
+void *op;
+void **opp;
- if( SMALL_OBJ(lb) ) {
+ if(SMALL_OBJ(lb)) {
register struct obj_kind * kind = GC_obj_kinds + k;
-# ifdef MERGE_SIZES
- lw = GC_size_map[lb];
-# else
- lw = ALIGNED_WORDS(lb);
- if (lw == 0) lw = MIN_WORDS;
-# endif
- opp = &(kind -> ok_freelist[lw]);
+ lg = GC_size_map[lb];
+ opp = &(kind -> ok_freelist[lg]);
if( (op = *opp) == 0 ) {
-# ifdef MERGE_SIZES
- if (GC_size_map[lb] == 0) {
- if (!GC_is_initialized) GC_init_inner();
- if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
- return(GC_generic_malloc_inner(lb, k));
- }
-# else
- if (!GC_is_initialized) {
- GC_init_inner();
- return(GC_generic_malloc_inner(lb, k));
- }
-# endif
+ if (GC_size_map[lb] == 0) {
+ if (!GC_is_initialized) GC_init_inner();
+ if (GC_size_map[lb] == 0) GC_extend_size_map(lb);
+ return(GC_generic_malloc_inner(lb, k));
+ }
if (kind -> ok_reclaim_list == 0) {
if (!GC_alloc_reclaim_list(kind)) goto out;
}
- op = GC_allocobj(lw, k);
+ op = GC_allocobj(lg, k);
if (op == 0) goto out;
}
- /* Here everything is in a consistent state. */
- /* We assume the following assignment is */
- /* atomic. If we get aborted */
- /* after the assignment, we lose an object, */
- /* but that's benign. */
- /* Volatile declarations may need to be added */
- /* to prevent the compiler from breaking things.*/
- /* If we only execute the second of the */
- /* following assignments, we lose the free */
- /* list, but that should still be OK, at least */
- /* for garbage collected memory. */
*opp = obj_link(op);
obj_link(op) = 0;
} else {
- lw = ROUNDED_UP_WORDS(lb);
- op = (ptr_t)GC_alloc_large_and_clear(lw, k, 0);
+ op = (ptr_t)GC_alloc_large_and_clear(ADD_SLOP(lb), k, 0);
}
- GC_words_allocd += lw;
+ GC_bytes_allocd += GRANULES_TO_BYTES(lg);
out:
return op;
@@ -162,46 +133,41 @@ out:
/* Allocate a composite object of size n bytes. The caller guarantees */
/* that pointers past the first page are not relevant. Caller holds */
/* allocation lock. */
-ptr_t GC_generic_malloc_inner_ignore_off_page(lb, k)
-register size_t lb;
-register int k;
+void * GC_generic_malloc_inner_ignore_off_page(size_t lb, int k)
{
- register word lw;
- ptr_t op;
+ word lb_adjusted;
+ void * op;
if (lb <= HBLKSIZE)
- return(GC_generic_malloc_inner((word)lb, k));
- lw = ROUNDED_UP_WORDS(lb);
- op = (ptr_t)GC_alloc_large_and_clear(lw, k, IGNORE_OFF_PAGE);
- GC_words_allocd += lw;
+ return(GC_generic_malloc_inner(lb, k));
+ lb_adjusted = ADD_SLOP(lb);
+ op = GC_alloc_large_and_clear(lb_adjusted, k, IGNORE_OFF_PAGE);
+ GC_bytes_allocd += lb_adjusted;
return op;
}
-ptr_t GC_generic_malloc(lb, k)
-register word lb;
-register int k;
+void * GC_generic_malloc(size_t lb, int k)
{
- ptr_t result;
+ void * result;
DCL_LOCK_STATE;
if (GC_have_errors) GC_print_all_errors();
GC_INVOKE_FINALIZERS();
if (SMALL_OBJ(lb)) {
- DISABLE_SIGNALS();
LOCK();
result = GC_generic_malloc_inner((word)lb, k);
UNLOCK();
- ENABLE_SIGNALS();
} else {
- word lw;
+ size_t lw;
+ size_t lb_rounded;
word n_blocks;
GC_bool init;
lw = ROUNDED_UP_WORDS(lb);
- n_blocks = OBJ_SZ_TO_BLOCKS(lw);
+ lb_rounded = WORDS_TO_BYTES(lw);
+ n_blocks = OBJ_SZ_TO_BLOCKS(lb_rounded);
init = GC_obj_kinds[k].ok_init;
- DISABLE_SIGNALS();
LOCK();
- result = (ptr_t)GC_alloc_large(lw, k, 0);
+ result = (ptr_t)GC_alloc_large(lb_rounded, k, 0);
if (0 != result) {
if (GC_debugging_started) {
BZERO(result, n_blocks * HBLKSIZE);
@@ -216,9 +182,8 @@ register int k;
# endif
}
}
- GC_words_allocd += lw;
+ GC_bytes_allocd += lb_rounded;
UNLOCK();
- ENABLE_SIGNALS();
if (init && !GC_debugging_started && 0 != result) {
BZERO(result, n_blocks * HBLKSIZE);
}
@@ -232,65 +197,46 @@ register int k;
#define GENERAL_MALLOC(lb,k) \
- (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))
+ GC_clear_stack(GC_generic_malloc(lb, k))
/* We make the GC_clear_stack_call a tail call, hoping to get more of */
/* the stack. */
/* Allocate lb bytes of atomic (pointerfree) data */
-# ifdef __STDC__
- GC_PTR GC_malloc_atomic(size_t lb)
-# else
- GC_PTR GC_malloc_atomic(lb)
- size_t lb;
-# endif
+void * GC_malloc_atomic(size_t lb)
{
-register ptr_t op;
-register ptr_t * opp;
-register word lw;
-DCL_LOCK_STATE;
+ void *op;
+ void ** opp;
+ size_t lg;
+ DCL_LOCK_STATE;
- if( EXPECT(SMALL_OBJ(lb), 1) ) {
-# ifdef MERGE_SIZES
- lw = GC_size_map[lb];
-# else
- lw = ALIGNED_WORDS(lb);
-# endif
- opp = &(GC_aobjfreelist[lw]);
+ if(SMALL_OBJ(lb)) {
+ lg = GC_size_map[lb];
+ opp = &(GC_aobjfreelist[lg]);
FASTLOCK();
if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0) ) {
FASTUNLOCK();
return(GENERAL_MALLOC((word)lb, PTRFREE));
}
- /* See above comment on signals. */
*opp = obj_link(op);
- GC_words_allocd += lw;
+ GC_bytes_allocd += GRANULES_TO_BYTES(lg);
FASTUNLOCK();
- return((GC_PTR) op);
+ return((void *) op);
} else {
return(GENERAL_MALLOC((word)lb, PTRFREE));
}
}
/* Allocate lb bytes of composite (pointerful) data */
-# ifdef __STDC__
- GC_PTR GC_malloc(size_t lb)
-# else
- GC_PTR GC_malloc(lb)
- size_t lb;
-# endif
+void * GC_malloc(size_t lb)
{
-register ptr_t op;
-register ptr_t *opp;
-register word lw;
-DCL_LOCK_STATE;
+ void *op;
+ void **opp;
+ size_t lg;
+ DCL_LOCK_STATE;
- if( EXPECT(SMALL_OBJ(lb), 1) ) {
-# ifdef MERGE_SIZES
- lw = GC_size_map[lb];
-# else
- lw = ALIGNED_WORDS(lb);
-# endif
- opp = &(GC_objfreelist[lw]);
+ if(SMALL_OBJ(lb)) {
+ lg = GC_size_map[lb];
+ opp = (void **)&(GC_objfreelist[lg]);
FASTLOCK();
if( EXPECT(!FASTLOCK_SUCCEEDED() || (op = *opp) == 0, 0) ) {
FASTUNLOCK();
@@ -304,11 +250,11 @@ DCL_LOCK_STATE;
>= (word)GC_least_plausible_heap_addr);
*opp = obj_link(op);
obj_link(op) = 0;
- GC_words_allocd += lw;
+ GC_bytes_allocd += GRANULES_TO_BYTES(lg);
FASTUNLOCK();
- return((GC_PTR) op);
+ return op;
} else {
- return(GENERAL_MALLOC((word)lb, NORMAL));
+ return(GENERAL_MALLOC(lb, NORMAL));
}
}
@@ -326,12 +272,7 @@ DCL_LOCK_STATE;
# define GC_debug_malloc_replacement(lb) \
GC_debug_malloc(lb, RA "unknown", 0)
-# ifdef __STDC__
- GC_PTR malloc(size_t lb)
-# else
- GC_PTR malloc(lb)
- size_t lb;
-# endif
+void * malloc(size_t lb)
{
/* It might help to manually inline the GC_malloc call here. */
/* But any decent compiler should reduce the extra procedure call */
@@ -346,27 +287,17 @@ DCL_LOCK_STATE;
*/
if (!GC_is_initialized) return sbrk(lb);
# endif /* I386 && GC_SOLARIS_THREADS */
- return((GC_PTR)REDIRECT_MALLOC(lb));
+ return((void *)REDIRECT_MALLOC(lb));
}
-# ifdef __STDC__
- GC_PTR calloc(size_t n, size_t lb)
-# else
- GC_PTR calloc(n, lb)
- size_t n, lb;
-# endif
- {
- return((GC_PTR)REDIRECT_MALLOC(n*lb));
- }
+void * calloc(size_t n, size_t lb)
+{
+ return((void *)REDIRECT_MALLOC(n*lb));
+}
#ifndef strdup
# include <string.h>
-# ifdef __STDC__
- char *strdup(const char *s)
-# else
- char *strdup(s)
- char *s;
-# endif
+ char *strdup(const char *s)
{
size_t len = strlen(s) + 1;
char * result = ((char *)REDIRECT_MALLOC(len+1));
@@ -383,25 +314,23 @@ DCL_LOCK_STATE;
# endif /* REDIRECT_MALLOC */
/* Explicitly deallocate an object p. */
-# ifdef __STDC__
- void GC_free(GC_PTR p)
-# else
- void GC_free(p)
- GC_PTR p;
-# endif
+void GC_free(void * p)
{
- register struct hblk *h;
- register hdr *hhdr;
- register signed_word sz;
- register ptr_t * flh;
- register int knd;
- register struct obj_kind * ok;
+ struct hblk *h;
+ hdr *hhdr;
+ size_t sz; /* In bytes */
+ size_t ngranules; /* sz in granules */
+ void **flh;
+ int knd;
+ struct obj_kind * ok;
DCL_LOCK_STATE;
if (p == 0) return;
/* Required by ANSI. It's not my fault ... */
h = HBLKPTR(p);
hhdr = HDR(h);
+ sz = hhdr -> hb_sz;
+ ngranules = BYTES_TO_GRANULES(sz);
GC_ASSERT(GC_base(p) == p);
# if defined(REDIRECT_MALLOC) && \
(defined(GC_SOLARIS_THREADS) || defined(GC_LINUX_THREADS) \
@@ -413,38 +342,31 @@ DCL_LOCK_STATE;
if (0 == hhdr) return;
# endif
knd = hhdr -> hb_obj_kind;
- sz = hhdr -> hb_sz;
ok = &GC_obj_kinds[knd];
- if (EXPECT((sz <= MAXOBJSZ), 1)) {
+ if (EXPECT((ngranules <= MAXOBJGRANULES), 1)) {
# ifdef THREADS
- DISABLE_SIGNALS();
LOCK();
# endif
- GC_mem_freed += sz;
- /* A signal here can make GC_mem_freed and GC_non_gc_bytes */
- /* inconsistent. We claim this is benign. */
- if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
+ GC_bytes_freed += sz;
+ if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= sz;
/* Its unnecessary to clear the mark bit. If the */
/* object is reallocated, it doesn't matter. O.w. the */
/* collector will do it, since it's on a free list. */
if (ok -> ok_init) {
- BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
+ BZERO((word *)p + 1, sz-sizeof(word));
}
- flh = &(ok -> ok_freelist[sz]);
+ flh = &(ok -> ok_freelist[ngranules]);
obj_link(p) = *flh;
*flh = (ptr_t)p;
# ifdef THREADS
UNLOCK();
- ENABLE_SIGNALS();
# endif
} else {
- DISABLE_SIGNALS();
LOCK();
- GC_mem_freed += sz;
- if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
+ GC_bytes_freed += sz;
+ if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= sz;
GC_freehblk(h);
UNLOCK();
- ENABLE_SIGNALS();
}
}
@@ -452,33 +374,35 @@ DCL_LOCK_STATE;
/* Only used for internally allocated objects, so we can take some */
/* shortcuts. */
#ifdef THREADS
-void GC_free_inner(GC_PTR p)
+void GC_free_inner(void * p)
{
- register struct hblk *h;
- register hdr *hhdr;
- register signed_word sz;
- register ptr_t * flh;
- register int knd;
- register struct obj_kind * ok;
+ struct hblk *h;
+ hdr *hhdr;
+ size_t sz; /* bytes */
+ size_t ngranules; /* sz in granules */
+ void ** flh;
+ int knd;
+ struct obj_kind * ok;
DCL_LOCK_STATE;
h = HBLKPTR(p);
hhdr = HDR(h);
knd = hhdr -> hb_obj_kind;
sz = hhdr -> hb_sz;
+ ngranules = BYTES_TO_GRANULES(sz);
ok = &GC_obj_kinds[knd];
- if (sz <= MAXOBJSZ) {
- GC_mem_freed += sz;
- if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
+ if (ngranules <= MAXOBJGRANULES) {
+ GC_bytes_freed += sz;
+ if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= sz;
if (ok -> ok_init) {
- BZERO((word *)p + 1, WORDS_TO_BYTES(sz-1));
+ BZERO((word *)p + 1, sz-sizeof(word));
}
- flh = &(ok -> ok_freelist[sz]);
+ flh = &(ok -> ok_freelist[ngranules]);
obj_link(p) = *flh;
*flh = (ptr_t)p;
} else {
- GC_mem_freed += sz;
- if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= WORDS_TO_BYTES(sz);
+ GC_bytes_freed += sz;
+ if (IS_UNCOLLECTABLE(knd)) GC_non_gc_bytes -= sz;
GC_freehblk(h);
}
}
@@ -488,12 +412,7 @@ void GC_free_inner(GC_PTR p)
# define REDIRECT_FREE GC_free
# endif
# ifdef REDIRECT_FREE
-# ifdef __STDC__
- void free(GC_PTR p)
-# else
- void free(p)
- GC_PTR p;
-# endif
+ void free(void * p)
{
# ifndef IGNORE_FREE
REDIRECT_FREE(p);
diff --git a/mallocx.c b/mallocx.c
index d45f21e..11567ff 100644
--- a/mallocx.c
+++ b/mallocx.c
@@ -31,17 +31,15 @@ GC_bool GC_alloc_reclaim_list(); /* in malloc.c */
/* Some externally visible but unadvertised variables to allow access to */
/* free lists from inlined allocators without including gc_priv.h */
/* or introducing dependencies on internal data structure layouts. */
-ptr_t * GC_CONST GC_objfreelist_ptr = GC_objfreelist;
-ptr_t * GC_CONST GC_aobjfreelist_ptr = GC_aobjfreelist;
-ptr_t * GC_CONST GC_uobjfreelist_ptr = GC_uobjfreelist;
+void ** const GC_objfreelist_ptr = GC_objfreelist;
+void ** const GC_aobjfreelist_ptr = GC_aobjfreelist;
+void ** const GC_uobjfreelist_ptr = GC_uobjfreelist;
# ifdef ATOMIC_UNCOLLECTABLE
- ptr_t * GC_CONST GC_auobjfreelist_ptr = GC_auobjfreelist;
+ void ** const GC_auobjfreelist_ptr = GC_auobjfreelist;
# endif
-GC_PTR GC_generic_or_special_malloc(lb,knd)
-word lb;
-int knd;
+void * GC_generic_or_special_malloc(size_t lb, int knd)
{
switch(knd) {
# ifdef STUBBORN_ALLOC
@@ -68,26 +66,19 @@ int knd;
/* lb bytes. The object may be (and quite likely will be) moved. */
/* The kind (e.g. atomic) is the same as that of the old. */
/* Shrinking of large blocks is not implemented well. */
-# ifdef __STDC__
- GC_PTR GC_realloc(GC_PTR p, size_t lb)
-# else
- GC_PTR GC_realloc(p,lb)
- GC_PTR p;
- size_t lb;
-# endif
+void * GC_realloc(void * p, size_t lb)
{
-register struct hblk * h;
-register hdr * hhdr;
-register word sz; /* Current size in bytes */
-register word orig_sz; /* Original sz in bytes */
-int obj_kind;
+ struct hblk * h;
+ hdr * hhdr;
+ size_t sz; /* Current size in bytes */
+ size_t orig_sz; /* Original sz in bytes */
+ int obj_kind;
if (p == 0) return(GC_malloc(lb)); /* Required by ANSI */
h = HBLKPTR(p);
hhdr = HDR(h);
sz = hhdr -> hb_sz;
obj_kind = hhdr -> hb_obj_kind;
- sz = WORDS_TO_BYTES(sz);
orig_sz = sz;
if (sz > MAXOBJBYTES) {
@@ -95,10 +86,16 @@ int obj_kind;
register word descr;
sz = (sz+HBLKSIZE-1) & (~HBLKMASK);
- hhdr -> hb_sz = BYTES_TO_WORDS(sz);
+ hhdr -> hb_sz = sz;
descr = GC_obj_kinds[obj_kind].ok_descriptor;
if (GC_obj_kinds[obj_kind].ok_relocate_descr) descr += sz;
hhdr -> hb_descr = descr;
+# ifdef MARK_BIT_PER_OBJ
+ GC_ASSERT(hhdr -> hb_inv_sz == LARGE_INV_SZ);
+# else
+ GC_ASSERT(hhdr -> hb_large_block &&
+ hhdr -> hb_map[ANY_INDEX] == 1);
+# endif
if (IS_UNCOLLECTABLE(obj_kind)) GC_non_gc_bytes += (sz - orig_sz);
/* Extra area is already cleared by GC_alloc_large_and_clear. */
}
@@ -116,7 +113,7 @@ int obj_kind;
return(p);
} else {
/* shrink */
- GC_PTR result =
+ void * result =
GC_generic_or_special_malloc((word)lb, obj_kind);
if (result == 0) return(0);
@@ -130,7 +127,7 @@ int obj_kind;
}
} else {
/* grow */
- GC_PTR result =
+ void * result =
GC_generic_or_special_malloc((word)lb, obj_kind);
if (result == 0) return(0);
@@ -157,13 +154,7 @@ int obj_kind;
# define GC_debug_realloc_replacement(p, lb) \
GC_debug_realloc(p, lb, RA "unknown", 0)
-# ifdef __STDC__
- GC_PTR realloc(GC_PTR p, size_t lb)
-# else
- GC_PTR realloc(p,lb)
- GC_PTR p;
- size_t lb;
-# endif
+void * realloc(void * p, size_t lb)
{
return(REDIRECT_REALLOC(p, lb));
}
@@ -174,12 +165,11 @@ int obj_kind;
/* The same thing, except caller does not hold allocation lock. */
/* We avoid holding allocation lock while we clear memory. */
-ptr_t GC_generic_malloc_ignore_off_page(lb, k)
-register size_t lb;
-register int k;
+void * GC_generic_malloc_ignore_off_page(size_t lb, int k)
{
- register ptr_t result;
- word lw;
+ void *result;
+ size_t lw;
+ size_t lb_rounded;
word n_blocks;
GC_bool init;
DCL_LOCK_STATE;
@@ -187,13 +177,13 @@ register int k;
if (SMALL_OBJ(lb))
return(GC_generic_malloc((word)lb, k));
lw = ROUNDED_UP_WORDS(lb);
- n_blocks = OBJ_SZ_TO_BLOCKS(lw);
+ lb_rounded = WORDS_TO_BYTES(lw);
+ n_blocks = OBJ_SZ_TO_BLOCKS(lb_rounded);
init = GC_obj_kinds[k].ok_init;
if (GC_have_errors) GC_print_all_errors();
GC_INVOKE_FINALIZERS();
- DISABLE_SIGNALS();
LOCK();
- result = (ptr_t)GC_alloc_large(lw, k, IGNORE_OFF_PAGE);
+ result = (ptr_t)GC_alloc_large(ADD_SLOP(lb), k, IGNORE_OFF_PAGE);
if (0 != result) {
if (GC_debugging_started) {
BZERO(result, n_blocks * HBLKSIZE);
@@ -208,9 +198,8 @@ register int k;
# endif
}
}
- GC_words_allocd += lw;
+ GC_bytes_allocd += lb_rounded;
UNLOCK();
- ENABLE_SIGNALS();
if (0 == result) {
return((*GC_oom_fn)(lb));
} else {
@@ -221,108 +210,43 @@ register int k;
}
}
-# if defined(__STDC__) || defined(__cplusplus)
- void * GC_malloc_ignore_off_page(size_t lb)
-# else
- char * GC_malloc_ignore_off_page(lb)
- register size_t lb;
-# endif
+void * GC_malloc_ignore_off_page(size_t lb)
{
- return((GC_PTR)GC_generic_malloc_ignore_off_page(lb, NORMAL));
+ return((void *)GC_generic_malloc_ignore_off_page(lb, NORMAL));
}
-# if defined(__STDC__) || defined(__cplusplus)
- void * GC_malloc_atomic_ignore_off_page(size_t lb)
-# else
- char * GC_malloc_atomic_ignore_off_page(lb)
- register size_t lb;
-# endif
+void * GC_malloc_atomic_ignore_off_page(size_t lb)
{
- return((GC_PTR)GC_generic_malloc_ignore_off_page(lb, PTRFREE));
+ return((void *)GC_generic_malloc_ignore_off_page(lb, PTRFREE));
}
-/* Increment GC_words_allocd from code that doesn't have direct access */
+/* Increment GC_bytes_allocd from code that doesn't have direct access */
/* to GC_arrays. */
-# ifdef __STDC__
-void GC_incr_words_allocd(size_t n)
+void GC_incr_bytes_allocd(size_t n)
{
- GC_words_allocd += n;
-}
-
-/* The same for GC_mem_freed. */
-void GC_incr_mem_freed(size_t n)
-{
- GC_mem_freed += n;
-}
-# endif /* __STDC__ */
-
-/* Analogous to the above, but assumes a small object size, and */
-/* bypasses MERGE_SIZES mechanism. Used by gc_inline.h. */
-ptr_t GC_generic_malloc_words_small_inner(lw, k)
-register word lw;
-register int k;
-{
-register ptr_t op;
-register ptr_t *opp;
-register struct obj_kind * kind = GC_obj_kinds + k;
-
- opp = &(kind -> ok_freelist[lw]);
- if( (op = *opp) == 0 ) {
- if (!GC_is_initialized) {
- GC_init_inner();
- }
- if (kind -> ok_reclaim_list != 0 || GC_alloc_reclaim_list(kind)) {
- op = GC_clear_stack(GC_allocobj((word)lw, k));
- }
- if (op == 0) {
- UNLOCK();
- ENABLE_SIGNALS();
- return ((*GC_oom_fn)(WORDS_TO_BYTES(lw)));
- }
- }
- *opp = obj_link(op);
- obj_link(op) = 0;
- GC_words_allocd += lw;
- return((ptr_t)op);
+ GC_bytes_allocd += n;
}
-/* Analogous to the above, but assumes a small object size, and */
-/* bypasses MERGE_SIZES mechanism. Used by gc_inline.h. */
-#ifdef __STDC__
- ptr_t GC_generic_malloc_words_small(size_t lw, int k)
-#else
- ptr_t GC_generic_malloc_words_small(lw, k)
- register word lw;
- register int k;
-#endif
+/* The same for GC_bytes_freed. */
+void GC_incr_bytes_freed(size_t n)
{
-register ptr_t op;
-DCL_LOCK_STATE;
-
- if (GC_have_errors) GC_print_all_errors();
- GC_INVOKE_FINALIZERS();
- DISABLE_SIGNALS();
- LOCK();
- op = GC_generic_malloc_words_small_inner(lw, k);
- UNLOCK();
- ENABLE_SIGNALS();
- return((ptr_t)op);
+ GC_bytes_freed += n;
}
#if defined(THREADS) && !defined(SRC_M3)
-extern signed_word GC_mem_found; /* Protected by GC lock. */
+extern signed_word GC_bytes_found; /* Protected by GC lock. */
#ifdef PARALLEL_MARK
-volatile signed_word GC_words_allocd_tmp = 0;
- /* Number of words of memory allocated since */
+volatile signed_word GC_bytes_allocd_tmp = 0;
+ /* Number of bytes of memory allocated since */
/* we released the GC lock. Instead of */
/* reacquiring the GC lock just to add this in, */
/* we add it in the next time we reacquire */
/* the lock. (Atomically adding it doesn't */
/* work, since we would have to atomically */
/* update it in GC_malloc, which is too */
- /* expensive. */
+ /* expensive.) */
#endif /* PARALLEL_MARK */
/* See reclaim.c: */
@@ -337,40 +261,34 @@ extern ptr_t GC_reclaim_generic();
/* GC_malloc_many or friends to replenish it. (We do not round up */
/* object sizes, since a call indicates the intention to consume many */
/* objects of exactly this size.) */
+/* We assume that the size is a multiple of GRANULE_BYTES. */
/* We return the free-list by assigning it to *result, since it is */
/* not safe to return, e.g. a linked list of pointer-free objects, */
/* since the collector would not retain the entire list if it were */
/* invoked just as we were returning. */
/* Note that the client should usually clear the link field. */
-void GC_generic_malloc_many(lb, k, result)
-register word lb;
-register int k;
-ptr_t *result;
+void GC_generic_malloc_many(size_t lb, int k, void **result)
{
-ptr_t op;
-ptr_t p;
-ptr_t *opp;
-word lw;
-word my_words_allocd = 0;
+void *op;
+void *p;
+void **opp;
+size_t lw; /* Length in words. */
+size_t lg; /* Length in granules. */
+word my_bytes_allocd = 0;
struct obj_kind * ok = &(GC_obj_kinds[k]);
DCL_LOCK_STATE;
-# if defined(GATHERSTATS) || defined(PARALLEL_MARK)
-# define COUNT_ARG , &my_words_allocd
-# else
-# define COUNT_ARG
-# define NEED_TO_COUNT
-# endif
+ GC_ASSERT((lb & (GRANULE_BYTES-1)) == 0);
if (!SMALL_OBJ(lb)) {
op = GC_generic_malloc(lb, k);
if(0 != op) obj_link(op) = 0;
*result = op;
return;
}
- lw = ALIGNED_WORDS(lb);
+ lw = BYTES_TO_WORDS(lb);
+ lg = BYTES_TO_GRANULES(lb);
if (GC_have_errors) GC_print_all_errors();
GC_INVOKE_FINALIZERS();
- DISABLE_SIGNALS();
LOCK();
if (!GC_is_initialized) GC_init_inner();
/* Do our share of marking work */
@@ -386,55 +304,45 @@ DCL_LOCK_STATE;
struct hblk * hbp;
hdr * hhdr;
- rlh += lw;
+ rlh += lg;
while ((hbp = *rlh) != 0) {
hhdr = HDR(hbp);
*rlh = hhdr -> hb_next;
+ GC_ASSERT(hhdr -> hb_sz == lb);
hhdr -> hb_last_reclaimed = (unsigned short) GC_gc_no;
# ifdef PARALLEL_MARK
{
- signed_word my_words_allocd_tmp = GC_words_allocd_tmp;
+ signed_word my_bytes_allocd_tmp = GC_bytes_allocd_tmp;
- GC_ASSERT(my_words_allocd_tmp >= 0);
+ GC_ASSERT(my_bytes_allocd_tmp >= 0);
/* We only decrement it while holding the GC lock. */
/* Thus we can't accidentally adjust it down in more */
/* than one thread simultaneously. */
- if (my_words_allocd_tmp != 0) {
- (void)GC_atomic_add(
- (volatile GC_word *)(&GC_words_allocd_tmp),
- (GC_word)(-my_words_allocd_tmp));
- GC_words_allocd += my_words_allocd_tmp;
+ if (my_bytes_allocd_tmp != 0) {
+ (void)AO_fetch_and_add(
+ (volatile AO_t *)(&GC_bytes_allocd_tmp),
+ (AO_t)(-my_bytes_allocd_tmp));
+ GC_bytes_allocd += my_bytes_allocd_tmp;
}
}
GC_acquire_mark_lock();
++ GC_fl_builder_count;
UNLOCK();
- ENABLE_SIGNALS();
GC_release_mark_lock();
# endif
- op = GC_reclaim_generic(hbp, hhdr, lw,
- ok -> ok_init, 0 COUNT_ARG);
+ op = GC_reclaim_generic(hbp, hhdr, lb,
+ ok -> ok_init, 0, &my_bytes_allocd);
if (op != 0) {
-# ifdef NEED_TO_COUNT
- /* We are neither gathering statistics, nor marking in */
- /* parallel. Thus GC_reclaim_generic doesn't count */
- /* for us. */
- for (p = op; p != 0; p = obj_link(p)) {
- my_words_allocd += lw;
- }
-# endif
-# if defined(GATHERSTATS)
- /* We also reclaimed memory, so we need to adjust */
- /* that count. */
- /* This should be atomic, so the results may be */
- /* inaccurate. */
- GC_mem_found += my_words_allocd;
-# endif
+ /* We also reclaimed memory, so we need to adjust */
+ /* that count. */
+ /* This should be atomic, so the results may be */
+ /* inaccurate. */
+ GC_bytes_found += my_bytes_allocd;
# ifdef PARALLEL_MARK
*result = op;
- (void)GC_atomic_add(
- (volatile GC_word *)(&GC_words_allocd_tmp),
- (GC_word)(my_words_allocd));
+ (void)AO_fetch_and_add(
+ (volatile AO_t *)(&GC_bytes_allocd_tmp),
+ (AO_t)(my_bytes_allocd));
GC_acquire_mark_lock();
-- GC_fl_builder_count;
if (GC_fl_builder_count == 0) GC_notify_all_builder();
@@ -442,7 +350,7 @@ DCL_LOCK_STATE;
(void) GC_clear_stack(0);
return;
# else
- GC_words_allocd += my_words_allocd;
+ GC_bytes_allocd += my_bytes_allocd;
goto out;
# endif
}
@@ -451,7 +359,6 @@ DCL_LOCK_STATE;
-- GC_fl_builder_count;
if (GC_fl_builder_count == 0) GC_notify_all_builder();
GC_release_mark_lock();
- DISABLE_SIGNALS();
LOCK();
/* GC lock is needed for reclaim list access. We */
/* must decrement fl_builder_count before reaquiring GC */
@@ -462,33 +369,31 @@ DCL_LOCK_STATE;
/* Next try to use prefix of global free list if there is one. */
/* We don't refill it, but we need to use it up before allocating */
/* a new block ourselves. */
- opp = &(GC_obj_kinds[k].ok_freelist[lw]);
+ opp = &(GC_obj_kinds[k].ok_freelist[lg]);
if ( (op = *opp) != 0 ) {
*opp = 0;
- my_words_allocd = 0;
+ my_bytes_allocd = 0;
for (p = op; p != 0; p = obj_link(p)) {
- my_words_allocd += lw;
- if (my_words_allocd >= BODY_SZ) {
+ my_bytes_allocd += lb;
+ if (my_bytes_allocd >= HBLKSIZE) {
*opp = obj_link(p);
obj_link(p) = 0;
break;
}
}
- GC_words_allocd += my_words_allocd;
+ GC_bytes_allocd += my_bytes_allocd;
goto out;
}
/* Next try to allocate a new block worth of objects of this size. */
{
- struct hblk *h = GC_allochblk(lw, k, 0);
+ struct hblk *h = GC_allochblk(lb, k, 0);
if (h != 0) {
if (IS_UNCOLLECTABLE(k)) GC_set_hdr_marks(HDR(h));
- GC_words_allocd += BYTES_TO_WORDS(HBLKSIZE)
- - BYTES_TO_WORDS(HBLKSIZE) % lw;
+ GC_bytes_allocd += HBLKSIZE - HBLKSIZE % lb;
# ifdef PARALLEL_MARK
GC_acquire_mark_lock();
++ GC_fl_builder_count;
UNLOCK();
- ENABLE_SIGNALS();
GC_release_mark_lock();
# endif
@@ -515,14 +420,15 @@ DCL_LOCK_STATE;
out:
*result = op;
UNLOCK();
- ENABLE_SIGNALS();
(void) GC_clear_stack(0);
}
-GC_PTR GC_malloc_many(size_t lb)
+void * GC_malloc_many(size_t lb)
{
- ptr_t result;
- GC_generic_malloc_many(lb, NORMAL, &result);
+ void *result;
+ GC_generic_malloc_many(((lb + EXTRA_BYTES + GRANULE_BYTES-1)
+ & ~(GRANULE_BYTES-1)),
+ NORMAL, &result);
return result;
}
@@ -531,40 +437,31 @@ GC_PTR GC_malloc_many(size_t lb)
# endif
/* Allocate lb bytes of pointerful, traced, but not collectable data */
-# ifdef __STDC__
- GC_PTR GC_malloc_uncollectable(size_t lb)
-# else
- GC_PTR GC_malloc_uncollectable(lb)
- size_t lb;
-# endif
+void * GC_malloc_uncollectable(size_t lb)
{
-register ptr_t op;
-register ptr_t *opp;
-register word lw;
-DCL_LOCK_STATE;
+ void *op;
+ void **opp;
+ size_t lg;
+ DCL_LOCK_STATE;
if( SMALL_OBJ(lb) ) {
-# ifdef MERGE_SIZES
- if (EXTRA_BYTES != 0 && lb != 0) lb--;
+ if (EXTRA_BYTES != 0 && lb != 0) lb--;
/* We don't need the extra byte, since this won't be */
/* collected anyway. */
- lw = GC_size_map[lb];
-# else
- lw = ALIGNED_WORDS(lb);
-# endif
- opp = &(GC_uobjfreelist[lw]);
+ lg = GC_size_map[lb];
+ opp = &(GC_uobjfreelist[lg]);
FASTLOCK();
if( FASTLOCK_SUCCEEDED() && (op = *opp) != 0 ) {
/* See above comment on signals. */
*opp = obj_link(op);
obj_link(op) = 0;
- GC_words_allocd += lw;
+ GC_bytes_allocd += GRANULES_TO_BYTES(lg);
/* Mark bit ws already set on free list. It will be */
/* cleared only temporarily during a collection, as a */
/* result of the normal free list mark bit clearing. */
- GC_non_gc_bytes += WORDS_TO_BYTES(lw);
+ GC_non_gc_bytes += GRANULES_TO_BYTES(lg);
FASTUNLOCK();
- return((GC_PTR) op);
+ return((void *) op);
}
FASTUNLOCK();
op = (ptr_t)GC_generic_malloc((word)lb, UNCOLLECTABLE);
@@ -577,35 +474,30 @@ DCL_LOCK_STATE;
/* mark bits. */
{
register struct hblk * h;
+ size_t lb;
h = HBLKPTR(op);
- lw = HDR(h) -> hb_sz;
+ lb = HDR(h) -> hb_sz;
- DISABLE_SIGNALS();
LOCK();
GC_set_mark_bit(op);
- GC_non_gc_bytes += WORDS_TO_BYTES(lw);
+ GC_non_gc_bytes += lb;
UNLOCK();
- ENABLE_SIGNALS();
- return((GC_PTR) op);
+ return((void *) op);
}
}
-#ifdef __STDC__
/* Not well tested nor integrated. */
/* Debug version is tricky and currently missing. */
#include <limits.h>
-GC_PTR GC_memalign(size_t align, size_t lb)
+void * GC_memalign(size_t align, size_t lb)
{
size_t new_lb;
size_t offset;
ptr_t result;
-# ifdef ALIGN_DOUBLE
- if (align <= WORDS_TO_BYTES(2) && lb > align) return GC_malloc(lb);
-# endif
- if (align <= WORDS_TO_BYTES(1)) return GC_malloc(lb);
+ if (align <= GRANULE_BYTES) return GC_malloc(lb);
if (align >= HBLKSIZE/2 || lb >= HBLKSIZE/2) {
if (align > HBLKSIZE) return GC_oom_fn(LONG_MAX-1024) /* Fail */;
return GC_malloc(lb <= HBLKSIZE? HBLKSIZE : lb);
@@ -623,71 +515,60 @@ GC_PTR GC_memalign(size_t align, size_t lb)
GC_register_displacement(offset);
}
}
- result = (GC_PTR) ((ptr_t)result + offset);
+ result = (void *) ((ptr_t)result + offset);
GC_ASSERT((word)result % align == 0);
return result;
}
-#endif
# ifdef ATOMIC_UNCOLLECTABLE
/* Allocate lb bytes of pointerfree, untraced, uncollectable data */
/* This is normally roughly equivalent to the system malloc. */
/* But it may be useful if malloc is redefined. */
-# ifdef __STDC__
- GC_PTR GC_malloc_atomic_uncollectable(size_t lb)
-# else
- GC_PTR GC_malloc_atomic_uncollectable(lb)
- size_t lb;
-# endif
+void * GC_malloc_atomic_uncollectable(size_t lb)
{
-register ptr_t op;
-register ptr_t *opp;
-register word lw;
-DCL_LOCK_STATE;
+ void *op;
+ void **opp;
+ size_t lg;
+ DCL_LOCK_STATE;
if( SMALL_OBJ(lb) ) {
-# ifdef MERGE_SIZES
- if (EXTRA_BYTES != 0 && lb != 0) lb--;
+ if (EXTRA_BYTES != 0 && lb != 0) lb--;
/* We don't need the extra byte, since this won't be */
/* collected anyway. */
- lw = GC_size_map[lb];
-# else
- lw = ALIGNED_WORDS(lb);
-# endif
- opp = &(GC_auobjfreelist[lw]);
+ lg = GC_size_map[lg];
+ opp = &(GC_auobjfreelist[lg]);
FASTLOCK();
if( FASTLOCK_SUCCEEDED() && (op = *opp) != 0 ) {
/* See above comment on signals. */
*opp = obj_link(op);
obj_link(op) = 0;
- GC_words_allocd += lw;
+ GC_bytes_allocd += GRANULES_TO_BYTES(lg);
/* Mark bit was already set while object was on free list. */
- GC_non_gc_bytes += WORDS_TO_BYTES(lw);
+ GC_non_gc_bytes += GRANULES_TO_BYTES(lg);
FASTUNLOCK();
- return((GC_PTR) op);
+ return((void *) op);
}
FASTUNLOCK();
- op = (ptr_t)GC_generic_malloc((word)lb, AUNCOLLECTABLE);
+ op = (ptr_t)GC_generic_malloc(lb, AUNCOLLECTABLE);
} else {
- op = (ptr_t)GC_generic_malloc((word)lb, AUNCOLLECTABLE);
+ op = (ptr_t)GC_generic_malloc(lb, AUNCOLLECTABLE);
}
if (0 == op) return(0);
/* We don't need the lock here, since we have an undisguised */
/* pointer. We do need to hold the lock while we adjust */
/* mark bits. */
{
- register struct hblk * h;
+ struct hblk * h;
+ size_t lb;
h = HBLKPTR(op);
- lw = HDR(h) -> hb_sz;
+ lb = HDR(h) -> hb_sz;
- DISABLE_SIGNALS();
LOCK();
GC_set_mark_bit(op);
- GC_non_gc_bytes += WORDS_TO_BYTES(lw);
+ GC_non_gc_bytes += lb;
UNLOCK();
- ENABLE_SIGNALS();
- return((GC_PTR) op);
+ return((void *) op);
}
}
diff --git a/mark.c b/mark.c
index 1d39ca0..2197474 100644
--- a/mark.c
+++ b/mark.c
@@ -32,10 +32,9 @@
#endif
/* Single argument version, robust against whole program analysis. */
-void GC_noop1(x)
-word x;
+void GC_noop1(word x)
{
- static VOLATILE word sink;
+ static volatile word sink;
sink = x;
}
@@ -104,12 +103,20 @@ word GC_n_rescuing_pages; /* Number of dirty pages we marked from */
mse * GC_mark_stack;
-mse * GC_mark_stack_limit;
+mse * GC_mark_stack_limit;;
-word GC_mark_stack_size = 0;
+size_t GC_mark_stack_size = 0;
#ifdef PARALLEL_MARK
- mse * VOLATILE GC_mark_stack_top;
+# include "atomic_ops.h"
+
+ mse * volatile GC_mark_stack_top;
+ /* Updated only with mark lock held, but read asynchronously. */
+ volatile AO_t GC_first_nonempty;
+ /* Lowest entry on mark stack */
+ /* that may be nonempty. */
+ /* Updated only by initiating */
+ /* thread. */
#else
mse * GC_mark_stack_top;
#endif
@@ -126,48 +133,54 @@ GC_bool GC_objects_are_marked = FALSE; /* Are there collectable marked */
/* Is a collection in progress? Note that this can return true in the */
/* nonincremental case, if a collection has been abandoned and the */
/* mark state is now MS_INVALID. */
-GC_bool GC_collection_in_progress()
+GC_bool GC_collection_in_progress(void)
{
return(GC_mark_state != MS_NONE);
}
/* clear all mark bits in the header */
-void GC_clear_hdr_marks(hhdr)
-register hdr * hhdr;
+void GC_clear_hdr_marks(hdr *hhdr)
{
+ int last_bit = FINAL_MARK_BIT(hhdr -> hb_sz);
+
# ifdef USE_MARK_BYTES
BZERO(hhdr -> hb_marks, MARK_BITS_SZ);
+ hhdr -> hb_marks[last_bit] = 1;
# else
BZERO(hhdr -> hb_marks, MARK_BITS_SZ*sizeof(word));
+ set_mark_bit_from_hdr(hhdr, last_bit);
# endif
+ hhdr -> hb_n_marks = 0;
}
/* Set all mark bits in the header. Used for uncollectable blocks. */
-void GC_set_hdr_marks(hhdr)
-register hdr * hhdr;
+void GC_set_hdr_marks(hdr *hhdr)
{
- register int i;
+ int i;
+ size_t sz = hhdr -> hb_sz;
+ int n_marks = FINAL_MARK_BIT(sz);
- for (i = 0; i < MARK_BITS_SZ; ++i) {
-# ifdef USE_MARK_BYTES
+# ifdef USE_MARK_BYTES
+ for (i = 0; i <= n_marks; i += MARK_BIT_OFFSET(sz)) {
hhdr -> hb_marks[i] = 1;
-# else
+ }
+# else
+ for (i = 0; i < divWORDSZ(n_marks + WORDSZ); ++i) {
hhdr -> hb_marks[i] = ONES;
-# endif
- }
+ }
+# endif
+# ifdef MARK_BIT_PER_OBJ
+ hhdr -> hb_n_marks = n_marks - 1;
+# else
+ hhdr -> hb_n_marks = HBLK_OBJS(sz);
+# endif
}
/*
* Clear all mark bits associated with block h.
*/
/*ARGSUSED*/
-# if defined(__STDC__) || defined(__cplusplus)
- static void clear_marks_for_block(struct hblk *h, word dummy)
-# else
- static void clear_marks_for_block(h, dummy)
- struct hblk *h;
- word dummy;
-# endif
+static void clear_marks_for_block(struct hblk *h, word dummy)
{
register hdr * hhdr = HDR(h);
@@ -179,34 +192,47 @@ register hdr * hhdr;
}
/* Slow but general routines for setting/clearing/asking about mark bits */
-void GC_set_mark_bit(p)
-ptr_t p;
+void GC_set_mark_bit(ptr_t p)
{
- register struct hblk *h = HBLKPTR(p);
- register hdr * hhdr = HDR(h);
- register int word_no = (word *)p - (word *)h;
+ struct hblk *h = HBLKPTR(p);
+ hdr * hhdr = HDR(h);
+ int bit_no = MARK_BIT_NO(p - (ptr_t)h, hhdr -> hb_sz);
- set_mark_bit_from_hdr(hhdr, word_no);
+ if (!mark_bit_from_hdr(hhdr, bit_no)) {
+ set_mark_bit_from_hdr(hhdr, bit_no);
+ ++hhdr -> hb_n_marks;
+ }
}
-void GC_clear_mark_bit(p)
-ptr_t p;
+void GC_clear_mark_bit(ptr_t p)
{
- register struct hblk *h = HBLKPTR(p);
- register hdr * hhdr = HDR(h);
- register int word_no = (word *)p - (word *)h;
+ struct hblk *h = HBLKPTR(p);
+ hdr * hhdr = HDR(h);
+ int bit_no = MARK_BIT_NO(p - (ptr_t)h, hhdr -> hb_sz);
- clear_mark_bit_from_hdr(hhdr, word_no);
+ if (mark_bit_from_hdr(hhdr, bit_no)) {
+ int n_marks;
+ clear_mark_bit_from_hdr(hhdr, bit_no);
+ n_marks = hhdr -> hb_n_marks - 1;
+# ifdef THREADS
+ if (n_marks != 0)
+ hhdr -> hb_n_marks = n_marks;
+ /* Don't decrement to zero. The counts are approximate due to */
+ /* concurrency issues, but we need to ensure that a count of */
+ /* zero implies an empty block. */
+# else
+ hhdr -> hb_n_marks = n_marks;
+# endif
+ }
}
-GC_bool GC_is_marked(p)
-ptr_t p;
+GC_bool GC_is_marked(ptr_t p)
{
- register struct hblk *h = HBLKPTR(p);
- register hdr * hhdr = HDR(h);
- register int word_no = (word *)p - (word *)h;
+ struct hblk *h = HBLKPTR(p);
+ hdr * hhdr = HDR(h);
+ int bit_no = MARK_BIT_NO(p - (ptr_t)h, hhdr -> hb_sz);
- return(mark_bit_from_hdr(hhdr, word_no));
+ return(mark_bit_from_hdr(hhdr, bit_no));
}
@@ -215,24 +241,18 @@ ptr_t p;
* the marker invariant, and sets GC_mark_state to reflect this.
* (This implicitly starts marking to reestablish the invariant.)
*/
-void GC_clear_marks()
+void GC_clear_marks(void)
{
GC_apply_to_all_blocks(clear_marks_for_block, (word)0);
GC_objects_are_marked = FALSE;
GC_mark_state = MS_INVALID;
scan_ptr = 0;
-# ifdef GATHERSTATS
- /* Counters reflect currently marked objects: reset here */
- GC_composite_in_use = 0;
- GC_atomic_in_use = 0;
-# endif
-
}
/* Initiate a garbage collection. Initiates a full collection if the */
/* mark state is invalid. */
/*ARGSUSED*/
-void GC_initiate_gc()
+void GC_initiate_gc(void)
{
if (GC_dirty_maintained) GC_read_dirty();
# ifdef STUBBORN_ALLOC
@@ -256,7 +276,7 @@ void GC_initiate_gc()
}
-static void alloc_mark_stack();
+static void alloc_mark_stack(size_t);
/* Perform a small amount of marking. */
/* We try to touch roughly a page of memory. */
@@ -272,11 +292,9 @@ static void alloc_mark_stack();
/* exception handler, in case Windows unmaps one of our root */
/* segments. See below. In either case, we acquire the */
/* allocator lock long before we get here. */
- GC_bool GC_mark_some_inner(cold_gc_frame)
- ptr_t cold_gc_frame;
+ GC_bool GC_mark_some_inner(ptr_t cold_gc_frame)
#else
- GC_bool GC_mark_some(cold_gc_frame)
- ptr_t cold_gc_frame;
+ GC_bool GC_mark_some(ptr_t cold_gc_frame)
#endif
{
switch(GC_mark_state) {
@@ -295,12 +313,10 @@ static void alloc_mark_stack();
} else {
scan_ptr = GC_push_next_marked_dirty(scan_ptr);
if (scan_ptr == 0) {
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf1("Marked from %lu dirty pages\n",
- (unsigned long)GC_n_rescuing_pages);
- }
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("Marked from %u dirty pages\n",
+ GC_n_rescuing_pages);
+ }
GC_push_roots(FALSE, cold_gc_frame);
GC_objects_are_marked = TRUE;
if (GC_mark_state != MS_INVALID) {
@@ -344,7 +360,7 @@ static void alloc_mark_stack();
/* the allocation lock. */
if (GC_parallel) {
GC_do_parallel_mark();
- GC_ASSERT(GC_mark_stack_top < GC_first_nonempty);
+ GC_ASSERT(GC_mark_stack_top < (mse *)GC_first_nonempty);
GC_mark_stack_top = GC_mark_stack - 1;
if (GC_mark_stack_too_small) {
alloc_mark_stack(2*GC_mark_stack_size);
@@ -442,8 +458,7 @@ static void alloc_mark_stack();
# endif /* __GNUC__ */
- GC_bool GC_mark_some(cold_gc_frame)
- ptr_t cold_gc_frame;
+ GC_bool GC_mark_some(ptr_t cold_gc_frame)
{
GC_bool ret_val;
@@ -494,12 +509,10 @@ handle_ex:
# endif /* __GNUC__ */
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf0("Caught ACCESS_VIOLATION in marker. "
- "Memory mapping disappeared.\n");
- }
-# endif /* CONDPRINT */
+ if (GC_print_stats) {
+ GC_log_printf("Caught ACCESS_VIOLATION in marker. "
+ "Memory mapping disappeared.\n");
+ }
/* We have bad roots on the stack. Discard mark stack. */
/* Rescan from marked objects. Redetermine roots. */
@@ -525,79 +538,31 @@ rm_handler:
#endif /* MSWIN32 */
-GC_bool GC_mark_stack_empty()
+GC_bool GC_mark_stack_empty(void)
{
return(GC_mark_stack_top < GC_mark_stack);
}
-#ifdef PROF_MARKER
- word GC_prof_array[10];
-# define PROF(n) GC_prof_array[n]++
-#else
-# define PROF(n)
-#endif
-
-/* Given a pointer to someplace other than a small object page or the */
-/* first page of a large object, either: */
-/* - return a pointer to somewhere in the first page of the large */
-/* object, if current points to a large object. */
-/* In this case *hhdr is replaced with a pointer to the header */
-/* for the large object. */
-/* - just return current if it does not point to a large object. */
-/*ARGSUSED*/
-ptr_t GC_find_start(current, hhdr, new_hdr_p)
-register ptr_t current;
-register hdr *hhdr, **new_hdr_p;
-{
- if (GC_all_interior_pointers) {
- if (hhdr != 0) {
- register ptr_t orig = current;
-
- current = (ptr_t)HBLKPTR(current);
- do {
- current = current - HBLKSIZE*(word)hhdr;
- hhdr = HDR(current);
- } while(IS_FORWARDING_ADDR_OR_NIL(hhdr));
- /* current points to near the start of the large object */
- if (hhdr -> hb_flags & IGNORE_OFF_PAGE) return(orig);
- if ((word *)orig - (word *)current
- >= (ptrdiff_t)(hhdr->hb_sz)) {
- /* Pointer past the end of the block */
- return(orig);
- }
- *new_hdr_p = hhdr;
- return(current);
- } else {
- return(current);
- }
- } else {
- return(current);
- }
-}
-
-void GC_invalidate_mark_state()
+void GC_invalidate_mark_state(void)
{
GC_mark_state = MS_INVALID;
GC_mark_stack_top = GC_mark_stack-1;
}
-mse * GC_signal_mark_stack_overflow(msp)
-mse * msp;
+mse * GC_signal_mark_stack_overflow(mse *msp)
{
GC_mark_state = MS_INVALID;
GC_mark_stack_too_small = TRUE;
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf1("Mark stack overflow; current size = %lu entries\n",
- GC_mark_stack_size);
- }
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("Mark stack overflow; current size = %lu entries\n",
+ GC_mark_stack_size);
+ }
return(msp - GC_MARK_STACK_DISCARDS);
}
/*
* Mark objects pointed to by the regions described by
- * mark stack entries between GC_mark_stack and GC_mark_stack_top,
+ * mark stack entries between mark_stack and mark_stack_top,
* inclusive. Assumes the upper limit of a mark stack entry
* is never 0. A mark stack entry never has size 0.
* We try to traverse on the order of a hblk of memory before we return.
@@ -609,19 +574,16 @@ mse * msp;
* encoding, we optionally maintain a cache for the block address to
* header mapping, we prefetch when an object is "grayed", etc.
*/
-mse * GC_mark_from(mark_stack_top, mark_stack, mark_stack_limit)
-mse * mark_stack_top;
-mse * mark_stack;
-mse * mark_stack_limit;
+mse * GC_mark_from(mse *mark_stack_top, mse *mark_stack, mse *mark_stack_limit)
{
int credit = HBLKSIZE; /* Remaining credit for marking work */
- register word * current_p; /* Pointer to current candidate ptr. */
- register word current; /* Candidate pointer. */
- register word * limit; /* (Incl) limit of current candidate */
+ ptr_t current_p; /* Pointer to current candidate ptr. */
+ word current; /* Candidate pointer. */
+ ptr_t limit; /* (Incl) limit of current candidate */
/* range */
- register word descr;
- register ptr_t greatest_ha = GC_greatest_plausible_heap_addr;
- register ptr_t least_ha = GC_least_plausible_heap_addr;
+ word descr;
+ ptr_t greatest_ha = GC_greatest_plausible_heap_addr;
+ ptr_t least_ha = GC_least_plausible_heap_addr;
DECLARE_HDR_CACHE;
# define SPLIT_RANGE_WORDS 128 /* Must be power of 2. */
@@ -652,6 +614,13 @@ mse * mark_stack_limit;
/* stack. */
GC_ASSERT(descr < (word)GC_greatest_plausible_heap_addr
- (word)GC_least_plausible_heap_addr);
+# ifdef ENABLE_TRACE
+ if (GC_trace_addr >= current_p
+ && GC_trace_addr < current_p + descr) {
+ GC_log_printf("GC:%d Large section; start %p len %lu\n",
+ GC_gc_no, current_p, (unsigned long) descr);
+ }
+# endif /* ENABLE_TRACE */
# ifdef PARALLEL_MARK
# define SHARE_BYTES 2048
if (descr > SHARE_BYTES && GC_parallel
@@ -662,49 +631,84 @@ mse * mark_stack_limit;
/* makes sure we handle */
/* misaligned pointers. */
mark_stack_top++;
- current_p = (word *) ((char *)current_p + new_size);
+# ifdef ENABLE_TRACE
+ if (GC_trace_addr >= current_p
+ && GC_trace_addr < current_p + descr) {
+ GC_log_printf("GC:%d splitting (parallel) %p at %p\n",
+ GC_gc_no, current_p, current_p + new_size);
+ }
+# endif /* ENABLE_TRACE */
+ current_p += new_size;
descr -= new_size;
goto retry;
}
# endif /* PARALLEL_MARK */
mark_stack_top -> mse_start =
- limit = current_p + SPLIT_RANGE_WORDS-1;
+ limit = current_p + WORDS_TO_BYTES(SPLIT_RANGE_WORDS-1);
mark_stack_top -> mse_descr =
descr - WORDS_TO_BYTES(SPLIT_RANGE_WORDS-1);
+# ifdef ENABLE_TRACE
+ if (GC_trace_addr >= current_p
+ && GC_trace_addr < current_p + descr) {
+ GC_log_printf("GC:%d splitting %p at %p\n",
+ GC_gc_no, current_p, limit);
+ }
+# endif /* ENABLE_TRACE */
/* Make sure that pointers overlapping the two ranges are */
/* considered. */
- limit = (word *)((char *)limit + sizeof(word) - ALIGNMENT);
+ limit += sizeof(word) - ALIGNMENT;
break;
case GC_DS_BITMAP:
mark_stack_top--;
+# ifdef ENABLE_TRACE
+ if (GC_trace_addr >= current_p
+ && GC_trace_addr < current_p + WORDS_TO_BYTES(WORDSZ-2)) {
+ GC_log_printf("GC:%d Tracing from %p bitmap descr %lu\n",
+ GC_gc_no, current_p, (unsigned long) descr);
+ }
+# endif /* ENABLE_TRACE */
descr &= ~GC_DS_TAGS;
credit -= WORDS_TO_BYTES(WORDSZ/2); /* guess */
while (descr != 0) {
if ((signed_word)descr < 0) {
- current = *current_p;
+ current = *(word *)current_p;
FIXUP_POINTER(current);
if ((ptr_t)current >= least_ha && (ptr_t)current < greatest_ha) {
PREFETCH((ptr_t)current);
- HC_PUSH_CONTENTS((ptr_t)current, mark_stack_top,
+# ifdef ENABLE_TRACE
+ if (GC_trace_addr == current_p) {
+ GC_log_printf("GC:%d Considering(3) %p -> %p\n",
+ GC_gc_no, current_p, (ptr_t) current);
+ }
+# endif /* ENABLE_TRACE */
+ PUSH_CONTENTS((ptr_t)current, mark_stack_top,
mark_stack_limit, current_p, exit1);
}
}
descr <<= 1;
- ++ current_p;
+ current_p += sizeof(word);
}
continue;
case GC_DS_PROC:
mark_stack_top--;
+# ifdef ENABLE_TRACE
+ if (GC_trace_addr >= current_p
+ && GC_base(current_p) != 0
+ && GC_base(current_p) == GC_base(GC_trace_addr)) {
+ GC_log_printf("GC:%d Tracing from %p proc descr %lu\n",
+ GC_gc_no, current_p, (unsigned long) descr);
+ }
+# endif /* ENABLE_TRACE */
credit -= GC_PROC_BYTES;
mark_stack_top =
(*PROC(descr))
- (current_p, mark_stack_top,
+ ((word *)current_p, mark_stack_top,
mark_stack_limit, ENV(descr));
continue;
case GC_DS_PER_OBJECT:
if ((signed_word)descr >= 0) {
/* Descriptor is in the object. */
- descr = *(word *)((ptr_t)current_p + descr - GC_DS_PER_OBJECT);
+ descr = *(word *)(current_p + descr - GC_DS_PER_OBJECT);
} else {
/* Descriptor is in type descriptor pointed to by first */
/* word in object. */
@@ -727,7 +731,7 @@ mse * mark_stack_limit;
}
if (0 == descr) {
/* Can happen either because we generated a 0 descriptor */
- /* or we saw a pointer to a free object. */
+ /* or we saw a pointer to a free object. */
mark_stack_top--;
continue;
}
@@ -735,12 +739,19 @@ mse * mark_stack_limit;
}
} else /* Small object with length descriptor */ {
mark_stack_top--;
- limit = (word *)(((ptr_t)current_p) + (word)descr);
+ limit = current_p + (word)descr;
}
+# ifdef ENABLE_TRACE
+ if (GC_trace_addr >= current_p
+ && GC_trace_addr < limit) {
+ GC_log_printf("GC:%d Tracing from %p len %lu\n",
+ GC_gc_no, current_p, (unsigned long) descr);
+ }
+# endif /* ENABLE_TRACE */
/* The simple case in which we're scanning a range. */
GC_ASSERT(!((word)current_p & (ALIGNMENT-1)));
- credit -= (ptr_t)limit - (ptr_t)current_p;
- limit -= 1;
+ credit -= limit - current_p;
+ limit -= sizeof(word);
{
# define PREF_DIST 4
@@ -754,11 +765,11 @@ mse * mark_stack_limit;
/* generating slightly better code. Overall gcc code quality */
/* for this loop is still not great. */
for(;;) {
- PREFETCH((ptr_t)limit - PREF_DIST*CACHE_LINE_SIZE);
+ PREFETCH(limit - PREF_DIST*CACHE_LINE_SIZE);
GC_ASSERT(limit >= current_p);
- deferred = *limit;
+ deferred = *(word *)limit;
FIXUP_POINTER(deferred);
- limit = (word *)((char *)limit - ALIGNMENT);
+ limit -= ALIGNMENT;
if ((ptr_t)deferred >= least_ha && (ptr_t)deferred < greatest_ha) {
PREFETCH((ptr_t)deferred);
break;
@@ -766,9 +777,9 @@ mse * mark_stack_limit;
if (current_p > limit) goto next_object;
/* Unroll once, so we don't do too many of the prefetches */
/* based on limit. */
- deferred = *limit;
+ deferred = *(word *)limit;
FIXUP_POINTER(deferred);
- limit = (word *)((char *)limit - ALIGNMENT);
+ limit -= ALIGNMENT;
if ((ptr_t)deferred >= least_ha && (ptr_t)deferred < greatest_ha) {
PREFETCH((ptr_t)deferred);
break;
@@ -779,26 +790,38 @@ mse * mark_stack_limit;
while (current_p <= limit) {
/* Empirically, unrolling this loop doesn't help a lot. */
- /* Since HC_PUSH_CONTENTS expands to a lot of code, */
+ /* Since PUSH_CONTENTS expands to a lot of code, */
/* we don't. */
- current = *current_p;
+ current = *(word *)current_p;
FIXUP_POINTER(current);
- PREFETCH((ptr_t)current_p + PREF_DIST*CACHE_LINE_SIZE);
+ PREFETCH(current_p + PREF_DIST*CACHE_LINE_SIZE);
if ((ptr_t)current >= least_ha && (ptr_t)current < greatest_ha) {
/* Prefetch the contents of the object we just pushed. It's */
/* likely we will need them soon. */
PREFETCH((ptr_t)current);
- HC_PUSH_CONTENTS((ptr_t)current, mark_stack_top,
+# ifdef ENABLE_TRACE
+ if (GC_trace_addr == current_p) {
+ GC_log_printf("GC:%d Considering(1) %p -> %p\n",
+ GC_gc_no, current_p, (ptr_t) current);
+ }
+# endif /* ENABLE_TRACE */
+ PUSH_CONTENTS((ptr_t)current, mark_stack_top,
mark_stack_limit, current_p, exit2);
}
- current_p = (word *)((char *)current_p + ALIGNMENT);
+ current_p += ALIGNMENT;
}
# ifndef SMALL_CONFIG
/* We still need to mark the entry we previously prefetched. */
- /* We alrady know that it passes the preliminary pointer */
+ /* We already know that it passes the preliminary pointer */
/* validity test. */
- HC_PUSH_CONTENTS((ptr_t)deferred, mark_stack_top,
+# ifdef ENABLE_TRACE
+ if (GC_trace_addr == current_p) {
+ GC_log_printf("GC:%d Considering(2) %p -> %p\n",
+ GC_gc_no, current_p, (ptr_t) deferred);
+ }
+# endif /* ENABLE_TRACE */
+ PUSH_CONTENTS((ptr_t)deferred, mark_stack_top,
mark_stack_limit, current_p, exit4);
next_object:;
# endif
@@ -813,7 +836,6 @@ mse * mark_stack_limit;
GC_bool GC_help_wanted = FALSE;
unsigned GC_helper_count = 0;
unsigned GC_active_count = 0;
-mse * VOLATILE GC_first_nonempty;
word GC_mark_no = 0;
#define LOCAL_MARK_STACK_SIZE HBLKSIZE
@@ -834,33 +856,20 @@ mse * GC_steal_mark_stack(mse * low, mse * high, mse * local,
mse *top = local - 1;
unsigned i = 0;
- /* Make sure that prior writes to the mark stack are visible. */
- /* On some architectures, the fact that the reads are */
- /* volatile should suffice. */
-# if !defined(IA64) && !defined(HP_PA) && !defined(I386)
- GC_memory_barrier();
-# endif
GC_ASSERT(high >= low-1 && high - low + 1 <= GC_mark_stack_size);
for (p = low; p <= high && i <= max; ++p) {
- word descr = *(volatile word *) &(p -> mse_descr);
- /* In the IA64 memory model, the following volatile store is */
- /* ordered after this read of descr. Thus a thread must read */
- /* the original nonzero value. HP_PA appears to be similar, */
- /* and if I'm reading the P4 spec correctly, X86 is probably */
- /* also OK. In some other cases we need a barrier. */
-# if !defined(IA64) && !defined(HP_PA) && !defined(I386)
- GC_memory_barrier();
-# endif
+ word descr = AO_load((volatile AO_t *) &(p -> mse_descr));
if (descr != 0) {
- *(volatile word *) &(p -> mse_descr) = 0;
+ /* Must be ordered after read of descr: */
+ AO_store_release_write((volatile AO_t *) &(p -> mse_descr), 0);
/* More than one thread may get this entry, but that's only */
/* a minor performance problem. */
++top;
top -> mse_descr = descr;
top -> mse_start = p -> mse_start;
- GC_ASSERT( top -> mse_descr & GC_DS_TAGS != GC_DS_LENGTH ||
- top -> mse_descr < GC_greatest_plausible_heap_addr
- - GC_least_plausible_heap_addr);
+ GC_ASSERT( (top -> mse_descr & GC_DS_TAGS) != GC_DS_LENGTH ||
+ top -> mse_descr < GC_greatest_plausible_heap_addr
+ - GC_least_plausible_heap_addr);
/* If this is a big object, count it as */
/* size/256 + 1 objects. */
++i;
@@ -882,25 +891,22 @@ void GC_return_mark_stack(mse * low, mse * high)
if (high < low) return;
stack_size = high - low + 1;
GC_acquire_mark_lock();
- my_top = GC_mark_stack_top;
+ my_top = GC_mark_stack_top; /* Concurrent modification impossible. */
my_start = my_top + 1;
if (my_start - GC_mark_stack + stack_size > GC_mark_stack_size) {
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf0("No room to copy back mark stack.");
- }
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("No room to copy back mark stack.");
+ }
GC_mark_state = MS_INVALID;
GC_mark_stack_too_small = TRUE;
/* We drop the local mark stack. We'll fix things later. */
} else {
BCOPY(low, my_start, stack_size * sizeof(mse));
- GC_ASSERT(GC_mark_stack_top = my_top);
-# if !defined(IA64) && !defined(HP_PA)
- GC_memory_barrier();
-# endif
- /* On IA64, the volatile write acts as a release barrier. */
- GC_mark_stack_top = my_top + stack_size;
+ GC_ASSERT((mse *)AO_load((volatile AO_t *)(&GC_mark_stack_top))
+ == my_top);
+ AO_store_release_write((volatile AO_t *)(&GC_mark_stack_top),
+ (AO_t)(my_top + stack_size));
+ /* Ensures visibility of previously written stack contents. */
}
GC_release_mark_lock();
GC_notify_all_marker();
@@ -930,15 +936,15 @@ void GC_do_local_mark(mse *local_mark_stack, mse *local_top)
return;
}
}
- if (GC_mark_stack_top < GC_first_nonempty &&
- GC_active_count < GC_helper_count
+ if ((mse *)AO_load((volatile AO_t *)(&GC_mark_stack_top))
+ < (mse *)AO_load(&GC_first_nonempty)
+ && GC_active_count < GC_helper_count
&& local_top > local_mark_stack + 1) {
/* Try to share the load, since the main stack is empty, */
/* and helper threads are waiting for a refill. */
/* The entries near the bottom of the stack are likely */
/* to require more work. Thus we return those, eventhough */
/* it's harder. */
- mse * p;
mse * new_bottom = local_mark_stack
+ (local_top - local_mark_stack)/2;
GC_ASSERT(new_bottom > local_mark_stack
@@ -968,41 +974,44 @@ void GC_mark_local(mse *local_mark_stack, int id)
GC_acquire_mark_lock();
GC_active_count++;
- my_first_nonempty = GC_first_nonempty;
- GC_ASSERT(GC_first_nonempty >= GC_mark_stack &&
- GC_first_nonempty <= GC_mark_stack_top + 1);
-# ifdef PRINTSTATS
- GC_printf1("Starting mark helper %lu\n", (unsigned long)id);
-# endif
+ my_first_nonempty = (mse *)AO_load(&GC_first_nonempty);
+ GC_ASSERT((mse *)AO_load(&GC_first_nonempty) >= GC_mark_stack &&
+ (mse *)AO_load(&GC_first_nonempty) <=
+ (mse *)AO_load((volatile AO_t *)(&GC_mark_stack_top)) + 1);
+ if (GC_print_stats == VERBOSE)
+ GC_log_printf("Starting mark helper %lu\n", (unsigned long)id);
GC_release_mark_lock();
for (;;) {
size_t n_on_stack;
size_t n_to_get;
- mse *next;
mse * my_top;
mse * local_top;
- mse * global_first_nonempty = GC_first_nonempty;
+ mse * global_first_nonempty = (mse *)AO_load(&GC_first_nonempty);
GC_ASSERT(my_first_nonempty >= GC_mark_stack &&
- my_first_nonempty <= GC_mark_stack_top + 1);
+ my_first_nonempty <=
+ (mse *)AO_load((volatile AO_t *)(&GC_mark_stack_top)) + 1);
GC_ASSERT(global_first_nonempty >= GC_mark_stack &&
- global_first_nonempty <= GC_mark_stack_top + 1);
+ global_first_nonempty <=
+ (mse *)AO_load((volatile AO_t *)(&GC_mark_stack_top)) + 1);
if (my_first_nonempty < global_first_nonempty) {
my_first_nonempty = global_first_nonempty;
} else if (global_first_nonempty < my_first_nonempty) {
- GC_compare_and_exchange((word *)(&GC_first_nonempty),
- (word) global_first_nonempty,
- (word) my_first_nonempty);
+ AO_compare_and_swap(&GC_first_nonempty,
+ (AO_t) global_first_nonempty,
+ (AO_t) my_first_nonempty);
/* If this fails, we just go ahead, without updating */
/* GC_first_nonempty. */
}
/* Perhaps we should also update GC_first_nonempty, if it */
/* is less. But that would require using atomic updates. */
- my_top = GC_mark_stack_top;
+ my_top = (mse *)AO_load_acquire((volatile AO_t *)(&GC_mark_stack_top));
n_on_stack = my_top - my_first_nonempty + 1;
if (0 == n_on_stack) {
GC_acquire_mark_lock();
my_top = GC_mark_stack_top;
+ /* Asynchronous modification impossible here, */
+ /* since we hold mark lock. */
n_on_stack = my_top - my_first_nonempty + 1;
if (0 == n_on_stack) {
GC_active_count--;
@@ -1011,14 +1020,15 @@ void GC_mark_local(mse *local_mark_stack, int id)
/* on the stack. */
if (0 == GC_active_count) GC_notify_all_marker();
while (GC_active_count > 0
- && GC_first_nonempty > GC_mark_stack_top) {
+ && (mse *)AO_load(&GC_first_nonempty)
+ > GC_mark_stack_top) {
/* We will be notified if either GC_active_count */
/* reaches zero, or if more objects are pushed on */
/* the global mark stack. */
GC_wait_marker();
}
if (GC_active_count == 0 &&
- GC_first_nonempty > GC_mark_stack_top) {
+ (mse *)AO_load(&GC_first_nonempty) > GC_mark_stack_top) {
GC_bool need_to_notify = FALSE;
/* The above conditions can't be falsified while we */
/* hold the mark lock, since neither */
@@ -1028,10 +1038,9 @@ void GC_mark_local(mse *local_mark_stack, int id)
/* both conditions actually held simultaneously. */
GC_helper_count--;
if (0 == GC_helper_count) need_to_notify = TRUE;
-# ifdef PRINTSTATS
- GC_printf1(
+ if (GC_print_stats == VERBOSE)
+ GC_log_printf(
"Finished mark helper %lu\n", (unsigned long)id);
-# endif
GC_release_mark_lock();
if (need_to_notify) GC_notify_all_marker();
return;
@@ -1052,7 +1061,8 @@ void GC_mark_local(mse *local_mark_stack, int id)
local_mark_stack, n_to_get,
&my_first_nonempty);
GC_ASSERT(my_first_nonempty >= GC_mark_stack &&
- my_first_nonempty <= GC_mark_stack_top + 1);
+ my_first_nonempty <=
+ (mse *)AO_load((volatile AO_t *)(&GC_mark_stack_top)) + 1);
GC_do_local_mark(local_mark_stack, local_top);
}
}
@@ -1064,8 +1074,6 @@ void GC_mark_local(mse *local_mark_stack, int id)
void GC_do_parallel_mark()
{
mse local_mark_stack[LOCAL_MARK_STACK_SIZE];
- mse * local_top;
- mse * my_top;
GC_acquire_mark_lock();
GC_ASSERT(I_HOLD_LOCK());
@@ -1073,11 +1081,10 @@ void GC_do_parallel_mark()
/* all the time, especially since it's cheap. */
if (GC_help_wanted || GC_active_count != 0 || GC_helper_count != 0)
ABORT("Tried to start parallel mark in bad state");
-# ifdef PRINTSTATS
- GC_printf1("Starting marking for mark phase number %lu\n",
+ if (GC_print_stats == VERBOSE)
+ GC_log_printf("Starting marking for mark phase number %lu\n",
(unsigned long)GC_mark_no);
-# endif
- GC_first_nonempty = GC_mark_stack;
+ GC_first_nonempty = (AO_t)GC_mark_stack;
GC_active_count = 0;
GC_helper_count = 1;
GC_help_wanted = TRUE;
@@ -1090,11 +1097,10 @@ void GC_do_parallel_mark()
/* Done; clean up. */
while (GC_helper_count > 0) GC_wait_marker();
/* GC_helper_count cannot be incremented while GC_help_wanted == FALSE */
-# ifdef PRINTSTATS
- GC_printf1(
+ if (GC_print_stats == VERBOSE)
+ GC_log_printf(
"Finished marking for mark phase number %lu\n",
(unsigned long)GC_mark_no);
-# endif
GC_mark_no++;
GC_release_mark_lock();
GC_notify_all_marker();
@@ -1107,12 +1113,11 @@ void GC_help_marker(word my_mark_no)
{
mse local_mark_stack[LOCAL_MARK_STACK_SIZE];
unsigned my_id;
- mse * my_first_nonempty;
if (!GC_parallel) return;
GC_acquire_mark_lock();
while (GC_mark_no < my_mark_no
- || !GC_help_wanted && GC_mark_no == my_mark_no) {
+ || (!GC_help_wanted && GC_mark_no == my_mark_no)) {
GC_wait_marker();
}
my_id = GC_helper_count;
@@ -1130,10 +1135,9 @@ void GC_help_marker(word my_mark_no)
#endif /* PARALLEL_MARK */
-/* Allocate or reallocate space for mark stack of size s words */
-/* May silently fail. */
-static void alloc_mark_stack(n)
-word n;
+/* Allocate or reallocate space for mark stack of size n entries. */
+/* May silently fail. */
+static void alloc_mark_stack(size_t n)
{
mse * new_stack = (mse *)GC_scratch_alloc(n * sizeof(struct GC_ms_entry));
@@ -1153,23 +1157,19 @@ word n;
GC_mark_stack = new_stack;
GC_mark_stack_size = n;
GC_mark_stack_limit = new_stack + n;
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf1("Grew mark stack to %lu frames\n",
- (unsigned long) GC_mark_stack_size);
- }
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("Grew mark stack to %lu frames\n",
+ (unsigned long) GC_mark_stack_size);
+ }
} else {
-# ifdef CONDPRINT
- if (GC_print_stats) {
- GC_printf1("Failed to grow mark stack to %lu frames\n",
- (unsigned long) n);
- }
-# endif
+ if (GC_print_stats) {
+ GC_log_printf("Failed to grow mark stack to %lu frames\n",
+ (unsigned long) n);
+ }
}
} else {
if (new_stack == 0) {
- GC_err_printf0("No space for mark stack\n");
+ GC_err_printf("No space for mark stack\n");
EXIT();
}
GC_mark_stack = new_stack;
@@ -1209,7 +1209,7 @@ ptr_t top;
length += GC_DS_TAGS;
length &= ~GC_DS_TAGS;
# endif
- GC_mark_stack_top -> mse_start = (word *)bottom;
+ GC_mark_stack_top -> mse_start = bottom;
GC_mark_stack_top -> mse_descr = length;
}
@@ -1223,13 +1223,11 @@ ptr_t top;
* or if it marks each object before pushing it, thus ensuring progress
* in the event of a stack overflow.)
*/
-void GC_push_selected(bottom, top, dirty_fn, push_fn)
-ptr_t bottom;
-ptr_t top;
-int (*dirty_fn) GC_PROTO((struct hblk * h));
-void (*push_fn) GC_PROTO((ptr_t bottom, ptr_t top));
+void GC_push_selected(ptr_t bottom, ptr_t top,
+ int (*dirty_fn) (struct hblk *),
+ void (*push_fn) (ptr_t, ptr_t))
{
- register struct hblk * h;
+ struct hblk * h;
bottom = (ptr_t)(((long) bottom + ALIGNMENT-1) & ~(ALIGNMENT-1));
top = (ptr_t)(((long) top) & ~(ALIGNMENT-1));
@@ -1280,10 +1278,7 @@ void (*push_fn) GC_PROTO((ptr_t bottom, ptr_t top));
#endif
-void GC_push_conditional(bottom, top, all)
-ptr_t bottom;
-ptr_t top;
-int all;
+void GC_push_conditional(ptr_t bottom, ptr_t top, GC_bool all)
{
if (all) {
if (GC_dirty_maintained) {
@@ -1303,32 +1298,45 @@ int all;
#endif
# if defined(MSWIN32) || defined(MSWINCE)
- void __cdecl GC_push_one(p)
+ void __cdecl GC_push_one(word p)
# else
- void GC_push_one(p)
+ void GC_push_one(word p)
# endif
-word p;
{
- GC_PUSH_ONE_STACK(p, MARKED_FROM_REGISTER);
+ GC_PUSH_ONE_STACK((ptr_t)p, MARKED_FROM_REGISTER);
}
-struct GC_ms_entry *GC_mark_and_push(obj, mark_stack_ptr, mark_stack_limit, src)
-GC_PTR obj;
-struct GC_ms_entry * mark_stack_ptr;
-struct GC_ms_entry * mark_stack_limit;
-GC_PTR *src;
+struct GC_ms_entry *GC_mark_and_push(void *obj,
+ mse *mark_stack_ptr,
+ mse *mark_stack_limit,
+ void **src)
{
- PREFETCH(obj);
- PUSH_CONTENTS(obj, mark_stack_ptr /* modified */, mark_stack_limit, src,
- was_marked /* internally generated exit label */);
- return mark_stack_ptr;
-}
+ hdr * hhdr;
+
+ PREFETCH(obj);
+ GET_HDR(obj, hhdr);
+ if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr),FALSE)) {
+ if (GC_all_interior_pointers) {
+ hhdr = GC_find_header(GC_base(obj));
+ if (hhdr == 0) {
+ GC_ADD_TO_BLACK_LIST_NORMAL(obj, src);
+ return mark_stack_ptr;
+ }
+ } else {
+ GC_ADD_TO_BLACK_LIST_NORMAL(obj, src);
+ return mark_stack_ptr;
+ }
+ }
+ if (EXPECT(HBLK_IS_FREE(hhdr),0)) {
+ GC_ADD_TO_BLACK_LIST_NORMAL(obj, src);
+ return mark_stack_ptr;
+ }
-# ifdef __STDC__
-# define BASE(p) (word)GC_base((void *)(p))
-# else
-# define BASE(p) (word)GC_base((char *)(p))
-# endif
+ PUSH_CONTENTS_HDR(obj, mark_stack_ptr /* modified */, mark_stack_limit,
+ src, was_marked, hhdr, TRUE);
+ was_marked:
+ return mark_stack_ptr;
+}
/* Mark and push (i.e. gray) a single object p onto the main */
/* mark stack. Consider p to be valid if it is an interior */
@@ -1338,62 +1346,38 @@ GC_PTR *src;
/* Mark bits are NOT atomically updated. Thus this must be the */
/* only thread setting them. */
# if defined(PRINT_BLACK_LIST) || defined(KEEP_BACK_PTRS)
- void GC_mark_and_push_stack(p, source)
- ptr_t source;
+ void GC_mark_and_push_stack(ptr_t p, ptr_t source)
# else
- void GC_mark_and_push_stack(p)
+ void GC_mark_and_push_stack(ptr_t p)
# define source 0
# endif
-register word p;
{
- register word r;
- register hdr * hhdr;
- register int displ;
+ hdr * hhdr;
+ ptr_t r = p;
+ PREFETCH(p);
GET_HDR(p, hhdr);
- if (IS_FORWARDING_ADDR_OR_NIL(hhdr)) {
+ if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr),FALSE)) {
if (hhdr != 0) {
- r = BASE(p);
+ r = GC_base(p);
hhdr = HDR(r);
- displ = BYTES_TO_WORDS(HBLKDISPL(r));
}
- } else {
- register map_entry_type map_entry;
-
- displ = HBLKDISPL(p);
- map_entry = MAP_ENTRY((hhdr -> hb_map), displ);
- if (map_entry >= MAX_OFFSET) {
- if (map_entry == OFFSET_TOO_BIG || !GC_all_interior_pointers) {
- r = BASE(p);
- displ = BYTES_TO_WORDS(HBLKDISPL(r));
- if (r == 0) hhdr = 0;
- } else {
- /* Offset invalid, but map reflects interior pointers */
- hhdr = 0;
- }
- } else {
- displ = BYTES_TO_WORDS(displ);
- displ -= map_entry;
- r = (word)((word *)(HBLKPTR(p)) + displ);
- }
- }
- /* If hhdr != 0 then r == GC_base(p), only we did it faster. */
- /* displ is the word index within the block. */
- if (hhdr == 0) {
-# ifdef PRINT_BLACK_LIST
- GC_add_to_black_list_stack(p, source);
-# else
- GC_add_to_black_list_stack(p);
-# endif
-# undef source /* In case we had to define it. */
- } else {
- if (!mark_bit_from_hdr(hhdr, displ)) {
- set_mark_bit_from_hdr(hhdr, displ);
- GC_STORE_BACK_PTR(source, (ptr_t)r);
- PUSH_OBJ((word *)r, hhdr, GC_mark_stack_top,
- GC_mark_stack_limit);
+ if (hhdr == 0) {
+ GC_ADD_TO_BLACK_LIST_STACK(p, source);
+ return;
}
}
+ if (EXPECT(HBLK_IS_FREE(hhdr),0)) {
+ GC_ADD_TO_BLACK_LIST_NORMAL(p, src);
+ return;
+ }
+ PUSH_CONTENTS_HDR(r, GC_mark_stack_top, GC_mark_stack_limit,
+ source, mark_and_push_exit, hhdr, FALSE);
+ mark_and_push_exit: ;
+ /* We silently ignore pointers to near the end of a block, */
+ /* which is very mildly suboptimal. */
+ /* FIXME: We should probably add a header word to address */
+ /* this. */
}
# ifdef TRACE_BUF
@@ -1403,7 +1387,7 @@ register word p;
struct trace_entry {
char * kind;
word gc_no;
- word words_allocd;
+ word bytes_allocd;
word arg1;
word arg2;
} GC_trace_buf[TRACE_ENTRIES];
@@ -1414,7 +1398,7 @@ void GC_add_trace_entry(char *kind, word arg1, word arg2)
{
GC_trace_buf[GC_trace_buf_ptr].kind = kind;
GC_trace_buf[GC_trace_buf_ptr].gc_no = GC_gc_no;
- GC_trace_buf[GC_trace_buf_ptr].words_allocd = GC_words_allocd;
+ GC_trace_buf[GC_trace_buf_ptr].bytes_allocd = GC_bytes_allocd;
GC_trace_buf[GC_trace_buf_ptr].arg1 = arg1 ^ 0x80000000;
GC_trace_buf[GC_trace_buf_ptr].arg2 = arg2 ^ 0x80000000;
GC_trace_buf_ptr++;
@@ -1431,8 +1415,8 @@ void GC_print_trace(word gc_no, GC_bool lock)
if (i < 0) i = TRACE_ENTRIES-1;
p = GC_trace_buf + i;
if (p -> gc_no < gc_no || p -> kind == 0) return;
- printf("Trace:%s (gc:%d,words:%d) 0x%X, 0x%X\n",
- p -> kind, p -> gc_no, p -> words_allocd,
+ printf("Trace:%s (gc:%d,bytes:%d) 0x%X, 0x%X\n",
+ p -> kind, p -> gc_no, p -> bytes_allocd,
(p -> arg1) ^ 0x80000000, (p -> arg2) ^ 0x80000000);
}
printf("Trace incomplete\n");
@@ -1446,9 +1430,7 @@ void GC_print_trace(word gc_no, GC_bool lock)
* and scans the entire region immediately, in case the contents
* change.
*/
-void GC_push_all_eager(bottom, top)
-ptr_t bottom;
-ptr_t top;
+void GC_push_all_eager(ptr_t bottom, ptr_t top)
{
word * b = (word *)(((word) bottom + ALIGNMENT-1) & ~(ALIGNMENT-1));
word * t = (word *)(((word) top) & ~(ALIGNMENT-1));
@@ -1464,9 +1446,9 @@ ptr_t top;
/* check all pointers in range and push if they appear */
/* to be valid. */
lim = t - 1 /* longword */;
- for (p = b; p <= lim; p = (word *)(((char *)p) + ALIGNMENT)) {
+ for (p = b; p <= lim; p = (word *)(((ptr_t)p) + ALIGNMENT)) {
q = *p;
- GC_PUSH_ONE_STACK(q, p);
+ GC_PUSH_ONE_STACK((ptr_t)q, p);
}
# undef GC_greatest_plausible_heap_addr
# undef GC_least_plausible_heap_addr
@@ -1480,10 +1462,8 @@ ptr_t top;
* Cold_gc_frame delimits the stack section that must be scanned
* eagerly. A zero value indicates that no eager scanning is needed.
*/
-void GC_push_all_stack_partially_eager(bottom, top, cold_gc_frame)
-ptr_t bottom;
-ptr_t top;
-ptr_t cold_gc_frame;
+void GC_push_all_stack_partially_eager(ptr_t bottom, ptr_t top,
+ ptr_t cold_gc_frame)
{
if (!NEED_FIXUP_POINTER && GC_all_interior_pointers) {
# define EAGER_BYTES 1024
@@ -1511,9 +1491,7 @@ ptr_t cold_gc_frame;
}
#endif /* !THREADS */
-void GC_push_all_stack(bottom, top)
-ptr_t bottom;
-ptr_t top;
+void GC_push_all_stack(ptr_t bottom, ptr_t top)
{
if (!NEED_FIXUP_POINTER && GC_all_interior_pointers) {
GC_push_all(bottom, top);
@@ -1525,9 +1503,7 @@ ptr_t top;
#if !defined(SMALL_CONFIG) && !defined(USE_MARK_BYTES)
/* Push all objects reachable from marked objects in the given block */
/* of size 1 objects. */
-void GC_push_marked1(h, hhdr)
-struct hblk *h;
-register hdr * hhdr;
+void GC_push_marked1(struct hblk *h, hdr *hhdr)
{
word * mark_word_addr = &(hhdr->hb_marks[0]);
register word *p;
@@ -1573,9 +1549,7 @@ register hdr * hhdr;
/* Push all objects reachable from marked objects in the given block */
/* of size 2 objects. */
-void GC_push_marked2(h, hhdr)
-struct hblk *h;
-register hdr * hhdr;
+void GC_push_marked2(struct hblk *h, hdr *hhdr)
{
word * mark_word_addr = &(hhdr->hb_marks[0]);
register word *p;
@@ -1622,9 +1596,7 @@ register hdr * hhdr;
/* of size 4 objects. */
/* There is a risk of mark stack overflow here. But we handle that. */
/* And only unmarked objects get pushed, so it's not very likely. */
-void GC_push_marked4(h, hhdr)
-struct hblk *h;
-register hdr * hhdr;
+void GC_push_marked4(struct hblk *h, hdr *hhdr)
{
word * mark_word_addr = &(hhdr->hb_marks[0]);
register word *p;
@@ -1676,30 +1648,28 @@ register hdr * hhdr;
#endif /* SMALL_CONFIG */
/* Push all objects reachable from marked objects in the given block */
-void GC_push_marked(h, hhdr)
-struct hblk *h;
-register hdr * hhdr;
+void GC_push_marked(struct hblk *h, hdr *hhdr)
{
- register int sz = hhdr -> hb_sz;
- register int descr = hhdr -> hb_descr;
- register word * p;
- register int word_no;
- register word * lim;
- register mse * GC_mark_stack_top_reg;
- register mse * mark_stack_limit = GC_mark_stack_limit;
+ int sz = hhdr -> hb_sz;
+ int descr = hhdr -> hb_descr;
+ ptr_t p;
+ int bit_no;
+ ptr_t lim;
+ mse * GC_mark_stack_top_reg;
+ mse * mark_stack_limit = GC_mark_stack_limit;
/* Some quick shortcuts: */
if ((0 | GC_DS_LENGTH) == descr) return;
if (GC_block_empty(hhdr)/* nothing marked */) return;
GC_n_rescuing_pages++;
GC_objects_are_marked = TRUE;
- if (sz > MAXOBJSZ) {
- lim = (word *)h;
+ if (sz > MAXOBJBYTES) {
+ lim = h -> hb_body;
} else {
- lim = (word *)(h + 1) - sz;
+ lim = (h + 1)->hb_body - sz;
}
- switch(sz) {
+ switch(BYTES_TO_WORDS(sz)) {
# if !defined(SMALL_CONFIG) && !defined(USE_MARK_BYTES)
case 1:
GC_push_marked1(h, hhdr);
@@ -1716,15 +1686,11 @@ register hdr * hhdr;
# endif
default:
GC_mark_stack_top_reg = GC_mark_stack_top;
- for (p = (word *)h, word_no = 0; p <= lim; p += sz, word_no += sz) {
- if (mark_bit_from_hdr(hhdr, word_no)) {
+ for (p = h -> hb_body, bit_no = 0; p <= lim;
+ p += sz, bit_no += MARK_BIT_OFFSET(sz)) {
+ if (mark_bit_from_hdr(hhdr, bit_no)) {
/* Mark from fields inside the object */
- PUSH_OBJ((word *)p, hhdr, GC_mark_stack_top_reg, mark_stack_limit);
-# ifdef GATHERSTATS
- /* Subtract this object from total, since it was */
- /* added in twice. */
- GC_composite_in_use -= sz;
-# endif
+ PUSH_OBJ(p, hhdr, GC_mark_stack_top_reg, mark_stack_limit);
}
}
GC_mark_stack_top = GC_mark_stack_top_reg;
@@ -1733,17 +1699,14 @@ register hdr * hhdr;
#ifndef SMALL_CONFIG
/* Test whether any page in the given block is dirty */
-GC_bool GC_block_was_dirty(h, hhdr)
-struct hblk *h;
-register hdr * hhdr;
+GC_bool GC_block_was_dirty(struct hblk *h, hdr *hhdr)
{
- register int sz = hhdr -> hb_sz;
+ int sz = hhdr -> hb_sz;
- if (sz <= MAXOBJSZ) {
+ if (sz <= MAXOBJBYTES) {
return(GC_page_was_dirty(h));
} else {
- register ptr_t p = (ptr_t)h;
- sz = WORDS_TO_BYTES(sz);
+ ptr_t p = (ptr_t)h;
while (p < (ptr_t)h + sz) {
if (GC_page_was_dirty((struct hblk *)p)) return(TRUE);
p += HBLKSIZE;
@@ -1754,30 +1717,32 @@ register hdr * hhdr;
#endif /* SMALL_CONFIG */
/* Similar to GC_push_next_marked, but return address of next block */
-struct hblk * GC_push_next_marked(h)
-struct hblk *h;
+struct hblk * GC_push_next_marked(struct hblk *h)
{
- register hdr * hhdr;
+ hdr * hhdr = HDR(h);
- h = GC_next_used_block(h);
- if (h == 0) return(0);
- hhdr = HDR(h);
+ if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr), FALSE)) {
+ h = GC_next_used_block(h);
+ if (h == 0) return(0);
+ hhdr = GC_find_header((ptr_t)h);
+ }
GC_push_marked(h, hhdr);
return(h + OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz));
}
#ifndef SMALL_CONFIG
/* Identical to above, but mark only from dirty pages */
-struct hblk * GC_push_next_marked_dirty(h)
-struct hblk *h;
+struct hblk * GC_push_next_marked_dirty(struct hblk *h)
{
- register hdr * hhdr;
+ hdr * hhdr = HDR(h);
if (!GC_dirty_maintained) { ABORT("dirty bits not set up"); }
for (;;) {
- h = GC_next_used_block(h);
- if (h == 0) return(0);
- hhdr = HDR(h);
+ if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr), FALSE)) {
+ h = GC_next_used_block(h);
+ if (h == 0) return(0);
+ hhdr = GC_find_header((ptr_t)h);
+ }
# ifdef STUBBORN_ALLOC
if (hhdr -> hb_obj_kind == STUBBORN) {
if (GC_page_was_changed(h) && GC_block_was_dirty(h, hhdr)) {
@@ -1790,6 +1755,7 @@ struct hblk *h;
if (GC_block_was_dirty(h, hhdr)) break;
# endif
h += OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz);
+ hhdr = HDR(h);
}
GC_push_marked(h, hhdr);
return(h + OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz));
@@ -1798,20 +1764,21 @@ struct hblk *h;
/* Similar to above, but for uncollectable pages. Needed since we */
/* do not clear marks for such pages, even for full collections. */
-struct hblk * GC_push_next_marked_uncollectable(h)
-struct hblk *h;
+struct hblk * GC_push_next_marked_uncollectable(struct hblk *h)
{
- register hdr * hhdr = HDR(h);
+ hdr * hhdr = HDR(h);
for (;;) {
- h = GC_next_used_block(h);
- if (h == 0) return(0);
- hhdr = HDR(h);
+ if (EXPECT(IS_FORWARDING_ADDR_OR_NIL(hhdr), FALSE)) {
+ h = GC_next_used_block(h);
+ if (h == 0) return(0);
+ hhdr = GC_find_header((ptr_t)h);
+ }
if (hhdr -> hb_obj_kind == UNCOLLECTABLE) break;
h += OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz);
+ hhdr = HDR(h);
}
GC_push_marked(h, hhdr);
return(h + OBJ_SZ_TO_BLOCKS(hhdr -> hb_sz));
}
-
diff --git a/mark_rts.c b/mark_rts.c
index 55eb5d5..50ac09a 100644
--- a/mark_rts.c
+++ b/mark_rts.c
@@ -40,26 +40,26 @@ static int n_root_sets = 0;
# if !defined(NO_DEBUGGING)
/* For debugging: */
-void GC_print_static_roots()
+void GC_print_static_roots(void)
{
register int i;
size_t total = 0;
for (i = 0; i < n_root_sets; i++) {
- GC_printf2("From 0x%lx to 0x%lx ",
- (unsigned long) GC_static_roots[i].r_start,
- (unsigned long) GC_static_roots[i].r_end);
+ GC_printf("From %p to %p ",
+ GC_static_roots[i].r_start,
+ GC_static_roots[i].r_end);
if (GC_static_roots[i].r_tmp) {
- GC_printf0(" (temporary)\n");
+ GC_printf(" (temporary)\n");
} else {
- GC_printf0("\n");
+ GC_printf("\n");
}
total += GC_static_roots[i].r_end - GC_static_roots[i].r_start;
}
- GC_printf1("Total size: %ld\n", (unsigned long) total);
+ GC_printf("Total size: %ld\n", (unsigned long) total);
if (GC_root_size != total) {
- GC_printf1("GC_root_size incorrect: %ld!!\n",
- (unsigned long) GC_root_size);
+ GC_printf("GC_root_size incorrect: %ld!!\n",
+ (unsigned long) GC_root_size);
}
}
# endif /* NO_DEBUGGING */
@@ -67,8 +67,7 @@ void GC_print_static_roots()
/* Primarily for debugging support: */
/* Is the address p in one of the registered static */
/* root sections? */
-GC_bool GC_is_static_root(p)
-ptr_t p;
+GC_bool GC_is_static_root(ptr_t p)
{
static int last_root_set = MAX_ROOT_SETS;
register int i;
@@ -98,8 +97,7 @@ ptr_t p;
-- really defined in gc_priv.h
*/
-static int rt_hash(addr)
-char * addr;
+static INLINE int rt_hash(ptr_t addr)
{
word result = (word) addr;
# if CPP_WORDSZ > 8*LOG_RT_SIZE
@@ -116,11 +114,10 @@ char * addr;
/* Is a range starting at b already in the table? If so return a */
/* pointer to it, else NIL. */
-struct roots * GC_roots_present(b)
-char *b;
+struct roots * GC_roots_present(ptr_t b)
{
- register int h = rt_hash(b);
- register struct roots *p = GC_root_index[h];
+ int h = rt_hash(b);
+ struct roots *p = GC_root_index[h];
while (p != 0) {
if (p -> r_start == (ptr_t)b) return(p);
@@ -130,10 +127,9 @@ char *b;
}
/* Add the given root structure to the index. */
-static void add_roots_to_index(p)
-struct roots *p;
+static void add_roots_to_index(struct roots *p)
{
- register int h = rt_hash(p -> r_start);
+ int h = rt_hash(p -> r_start);
p -> r_next = GC_root_index[h];
GC_root_index[h] = p;
@@ -150,16 +146,13 @@ struct roots *p;
word GC_root_size = 0;
-void GC_add_roots(b, e)
-char * b; char * e;
+void GC_add_roots(void *b, void *e)
{
DCL_LOCK_STATE;
- DISABLE_SIGNALS();
LOCK();
- GC_add_roots_inner(b, e, FALSE);
+ GC_add_roots_inner((ptr_t)b, (ptr_t)e, FALSE);
UNLOCK();
- ENABLE_SIGNALS();
}
@@ -169,9 +162,7 @@ char * b; char * e;
/* them correctly.) */
/* Tmp specifies that the interval may be deleted before */
/* reregistering dynamic libraries. */
-void GC_add_roots_inner(b, e, tmp)
-char * b; char * e;
-GC_bool tmp;
+void GC_add_roots_inner(ptr_t b, ptr_t e, GC_bool tmp)
{
struct roots * old;
@@ -187,14 +178,14 @@ GC_bool tmp;
for (i = 0; i < n_root_sets; i++) {
old = GC_static_roots + i;
- if ((ptr_t)b <= old -> r_end && (ptr_t)e >= old -> r_start) {
- if ((ptr_t)b < old -> r_start) {
- old -> r_start = (ptr_t)b;
- GC_root_size += (old -> r_start - (ptr_t)b);
+ if (b <= old -> r_end && e >= old -> r_start) {
+ if (b < old -> r_start) {
+ old -> r_start = b;
+ GC_root_size += (old -> r_start - b);
}
- if ((ptr_t)e > old -> r_end) {
- old -> r_end = (ptr_t)e;
- GC_root_size += ((ptr_t)e - old -> r_end);
+ if (e > old -> r_end) {
+ old -> r_end = e;
+ GC_root_size += (e - old -> r_end);
}
old -> r_tmp &= tmp;
break;
@@ -206,23 +197,23 @@ GC_bool tmp;
for (i++; i < n_root_sets; i++) {
other = GC_static_roots + i;
- b = (char *)(other -> r_start);
- e = (char *)(other -> r_end);
- if ((ptr_t)b <= old -> r_end && (ptr_t)e >= old -> r_start) {
- if ((ptr_t)b < old -> r_start) {
- old -> r_start = (ptr_t)b;
- GC_root_size += (old -> r_start - (ptr_t)b);
+ b = other -> r_start;
+ e = other -> r_end;
+ if (b <= old -> r_end && e >= old -> r_start) {
+ if (b < old -> r_start) {
+ old -> r_start = b;
+ GC_root_size += (old -> r_start - b);
}
- if ((ptr_t)e > old -> r_end) {
- old -> r_end = (ptr_t)e;
- GC_root_size += ((ptr_t)e - old -> r_end);
+ if (e > old -> r_end) {
+ old -> r_end = e;
+ GC_root_size += (e - old -> r_end);
}
old -> r_tmp &= other -> r_tmp;
/* Delete this entry. */
GC_root_size -= (other -> r_end - other -> r_start);
other -> r_start = GC_static_roots[n_root_sets-1].r_start;
other -> r_end = GC_static_roots[n_root_sets-1].r_end;
- n_root_sets--;
+ n_root_sets--;
}
}
return;
@@ -231,10 +222,10 @@ GC_bool tmp;
# else
old = GC_roots_present(b);
if (old != 0) {
- if ((ptr_t)e <= old -> r_end) /* already there */ return;
+ if (e <= old -> r_end) /* already there */ return;
/* else extend */
- GC_root_size += (ptr_t)e - old -> r_end;
- old -> r_end = (ptr_t)e;
+ GC_root_size += e - old -> r_end;
+ old -> r_end = e;
return;
}
# endif
@@ -248,17 +239,16 @@ GC_bool tmp;
GC_static_roots[n_root_sets].r_next = 0;
# endif
add_roots_to_index(GC_static_roots + n_root_sets);
- GC_root_size += (ptr_t)e - (ptr_t)b;
+ GC_root_size += e - b;
n_root_sets++;
}
static GC_bool roots_were_cleared = FALSE;
-void GC_clear_roots GC_PROTO((void))
+void GC_clear_roots (void)
{
DCL_LOCK_STATE;
- DISABLE_SIGNALS();
LOCK();
roots_were_cleared = TRUE;
n_root_sets = 0;
@@ -271,12 +261,10 @@ void GC_clear_roots GC_PROTO((void))
}
# endif
UNLOCK();
- ENABLE_SIGNALS();
}
/* Internal use only; lock held. */
-static void GC_remove_root_at_pos(i)
-int i;
+static void GC_remove_root_at_pos(int i)
{
GC_root_size -= (GC_static_roots[i].r_end - GC_static_roots[i].r_start);
GC_static_roots[i].r_start = GC_static_roots[n_root_sets-1].r_start;
@@ -286,9 +274,9 @@ int i;
}
#if !defined(MSWIN32) && !defined(MSWINCE)
-static void GC_rebuild_root_index()
+static void GC_rebuild_root_index(void)
{
- register int i;
+ int i;
for (i = 0; i < RT_SIZE; i++) GC_root_index[i] = 0;
for (i = 0; i < n_root_sets; i++)
@@ -297,9 +285,9 @@ static void GC_rebuild_root_index()
#endif
/* Internal use only; lock held. */
-void GC_remove_tmp_roots()
+void GC_remove_tmp_roots(void)
{
- register int i;
+ int i;
for (i = 0; i < n_root_sets; ) {
if (GC_static_roots[i].r_tmp) {
@@ -314,25 +302,22 @@ void GC_remove_tmp_roots()
}
#if !defined(MSWIN32) && !defined(MSWINCE)
-void GC_remove_roots(b, e)
-char * b; char * e;
+void GC_remove_roots(void *b, void *e)
{
DCL_LOCK_STATE;
- DISABLE_SIGNALS();
LOCK();
- GC_remove_roots_inner(b, e);
+ GC_remove_roots_inner((ptr_t)b, (ptr_t)e);
UNLOCK();
- ENABLE_SIGNALS();
}
/* Should only be called when the lock is held */
-void GC_remove_roots_inner(b,e)
-char * b; char * e;
+void GC_remove_roots_inner(ptr_t b, ptr_t e)
{
int i;
for (i = 0; i < n_root_sets; ) {
- if (GC_static_roots[i].r_start >= (ptr_t)b && GC_static_roots[i].r_end <= (ptr_t)e) {
+ if (GC_static_roots[i].r_start >= b
+ && GC_static_roots[i].r_end <= e) {
GC_remove_root_at_pos(i);
} else {
i++;
@@ -345,8 +330,7 @@ char * b; char * e;
#if defined(MSWIN32) || defined(_WIN32_WCE_EMULATION)
/* Workaround for the OS mapping and unmapping behind our back: */
/* Is the address p in one of the temporary static root sections? */
-GC_bool GC_is_tmp_root(p)
-ptr_t p;
+GC_bool GC_is_tmp_root(ptr_t p)
{
static int last_root_set = MAX_ROOT_SETS;
register int i;
@@ -366,7 +350,7 @@ ptr_t p;
}
#endif /* MSWIN32 || _WIN32_WCE_EMULATION */
-ptr_t GC_approx_sp()
+ptr_t GC_approx_sp(void)
{
word dummy;
@@ -398,8 +382,7 @@ size_t GC_excl_table_entries = 0; /* Number of entries in use. */
/* Return the first exclusion range that includes an address >= start_addr */
/* Assumes the exclusion table contains at least one entry (namely the */
/* GC data structures). */
-struct exclusion * GC_next_exclusion(start_addr)
-ptr_t start_addr;
+struct exclusion * GC_next_exclusion(ptr_t start_addr)
{
size_t low = 0;
size_t high = GC_excl_table_entries - 1;
@@ -418,9 +401,7 @@ ptr_t start_addr;
return GC_excl_table + low;
}
-void GC_exclude_static_roots(start, finish)
-GC_PTR start;
-GC_PTR finish;
+void GC_exclude_static_roots(void *start, void *finish)
{
struct exclusion * next;
size_t next_index, i;
@@ -454,10 +435,7 @@ GC_PTR finish;
}
/* Invoke push_conditional on ranges that are not excluded. */
-void GC_push_conditional_with_exclusions(bottom, top, all)
-ptr_t bottom;
-ptr_t top;
-int all;
+void GC_push_conditional_with_exclusions(ptr_t bottom, ptr_t top, GC_bool all)
{
struct exclusion * next;
ptr_t excl_start;
@@ -479,8 +457,7 @@ int all;
* to ensure that callee-save registers saved in collector frames have been
* seen.
*/
-void GC_push_current_stack(cold_gc_frame)
-ptr_t cold_gc_frame;
+void GC_push_current_stack(ptr_t cold_gc_frame)
{
# if defined(THREADS)
if (0 == cold_gc_frame) return;
@@ -532,20 +509,19 @@ ptr_t cold_gc_frame;
* Push GC internal roots. Only called if there is some reason to believe
* these would not otherwise get registered.
*/
-void GC_push_gc_structures GC_PROTO((void))
+void GC_push_gc_structures(void)
{
GC_push_finalizer_structures();
- GC_push_stubborn_structures();
# if defined(THREADS)
GC_push_thread_structures();
# endif
}
#ifdef THREAD_LOCAL_ALLOC
- void GC_mark_thread_local_free_lists();
+ void GC_mark_thread_local_free_lists(void);
#endif
-void GC_cond_register_dynamic_libraries()
+void GC_cond_register_dynamic_libraries(void)
{
# if (defined(DYNAMIC_LOADING) || defined(MSWIN32) || defined(MSWINCE) \
|| defined(PCR)) && !defined(SRC_M3)
@@ -565,9 +541,7 @@ void GC_cond_register_dynamic_libraries()
* A zero value indicates that it's OK to miss some
* register values.
*/
-void GC_push_roots(all, cold_gc_frame)
-GC_bool all;
-ptr_t cold_gc_frame;
+void GC_push_roots(GC_bool all, ptr_t cold_gc_frame)
{
int i;
int kind;
@@ -598,7 +572,7 @@ ptr_t cold_gc_frame;
/* saves us the trouble of scanning them, and possibly that of */
/* marking the freelists. */
for (kind = 0; kind < GC_n_kinds; kind++) {
- GC_PTR base = GC_base(GC_obj_kinds[kind].ok_freelist);
+ void *base = GC_base(GC_obj_kinds[kind].ok_freelist);
if (0 != base) {
GC_set_mark_bit(base);
}
@@ -615,7 +589,7 @@ ptr_t cold_gc_frame;
/* If the world is not stopped, this is unsafe. It is */
/* also unnecessary, since we will do this again with the */
/* world stopped. */
-# ifdef THREAD_LOCAL_ALLOC
+# if defined(THREAD_LOCAL_ALLOC) && !defined(DBG_HDRS_ALL)
if (GC_world_stopped) GC_mark_thread_local_free_lists();
# endif
diff --git a/misc.c b/misc.c
index 52567b7..b286026 100644
--- a/misc.c
+++ b/misc.c
@@ -17,6 +17,7 @@
#include <stdio.h>
#include <limits.h>
+#include <stdarg.h>
#ifndef _WIN32_WCE
#include <signal.h>
#endif
@@ -34,6 +35,14 @@
# include <tchar.h>
#endif
+#ifdef UNIX_LIKE
+# include <fcntl.h>
+# include <sys/types.h>
+# include <sys/stat.h>
+
+ int GC_log; /* Forward decl, so we can set it. */
+#endif
+
# ifdef THREADS
# ifdef PCR
# include "il/PCR_IL.h"
@@ -91,10 +100,10 @@ GC_FAR struct _GC_arrays GC_arrays /* = { 0 } */;
GC_bool GC_debugging_started = FALSE;
/* defined here so we don't have to load debug_malloc.o */
-void (*GC_check_heap) GC_PROTO((void)) = (void (*) GC_PROTO((void)))0;
-void (*GC_print_all_smashed) GC_PROTO((void)) = (void (*) GC_PROTO((void)))0;
+void (*GC_check_heap) (void) = (void (*) (void))0;
+void (*GC_print_all_smashed) (void) = (void (*) (void))0;
-void (*GC_start_call_back) GC_PROTO((void)) = (void (*) GC_PROTO((void)))0;
+void (*GC_start_call_back) (void) = (void (*) (void))0;
ptr_t GC_stackbottom = 0;
@@ -108,7 +117,9 @@ GC_bool GC_dont_precollect = 0;
GC_bool GC_quiet = 0;
-GC_bool GC_print_stats = 0;
+#ifndef SMALL_CONFIG
+ GC_bool GC_print_stats = 0;
+#endif
GC_bool GC_print_back_height = 0;
@@ -140,118 +151,87 @@ long GC_large_alloc_warn_suppressed = 0;
/* Number of warnings suppressed so far. */
/*ARGSUSED*/
-GC_PTR GC_default_oom_fn GC_PROTO((size_t bytes_requested))
+void * GC_default_oom_fn(size_t bytes_requested)
{
return(0);
}
-GC_PTR (*GC_oom_fn) GC_PROTO((size_t bytes_requested)) = GC_default_oom_fn;
+void * (*GC_oom_fn) (size_t bytes_requested) = GC_default_oom_fn;
-extern signed_word GC_mem_found;
-
-void * GC_project2(arg1, arg2)
-void *arg1;
-void *arg2;
+void * GC_project2(void *arg1, void *arg2)
{
return arg2;
}
-# ifdef MERGE_SIZES
- /* Set things up so that GC_size_map[i] >= words(i), */
- /* but not too much bigger */
- /* and so that size_map contains relatively few distinct entries */
- /* This is stolen from Russ Atkinson's Cedar quantization */
- /* alogrithm (but we precompute it). */
-
-
- void GC_init_size_map()
- {
- register unsigned i;
-
- /* Map size 0 to something bigger. */
- /* This avoids problems at lower levels. */
- /* One word objects don't have to be 2 word aligned, */
- /* unless we're using mark bytes. */
- for (i = 0; i < sizeof(word); i++) {
- GC_size_map[i] = MIN_WORDS;
- }
-# if MIN_WORDS > 1
- GC_size_map[sizeof(word)] = MIN_WORDS;
-# else
- GC_size_map[sizeof(word)] = ROUNDED_UP_WORDS(sizeof(word));
-# endif
- for (i = sizeof(word) + 1; i <= 8 * sizeof(word); i++) {
- GC_size_map[i] = ALIGNED_WORDS(i);
- }
- for (i = 8*sizeof(word) + 1; i <= 16 * sizeof(word); i++) {
- GC_size_map[i] = (ROUNDED_UP_WORDS(i) + 1) & (~1);
- }
-# ifdef GC_GCJ_SUPPORT
- /* Make all sizes up to 32 words predictable, so that a */
- /* compiler can statically perform the same computation, */
- /* or at least a computation that results in similar size */
- /* classes. */
- for (i = 16*sizeof(word) + 1; i <= 32 * sizeof(word); i++) {
- GC_size_map[i] = (ROUNDED_UP_WORDS(i) + 3) & (~3);
- }
-# endif
- /* We leave the rest of the array to be filled in on demand. */
+/* Set things up so that GC_size_map[i] >= granules(i), */
+/* but not too much bigger */
+/* and so that size_map contains relatively few distinct entries */
+/* This was originally stolen from Russ Atkinson's Cedar */
+/* quantization alogrithm (but we precompute it). */
+void GC_init_size_map(void)
+{
+ register unsigned i;
+
+ /* Map size 0 to something bigger. */
+ /* This avoids problems at lower levels. */
+ GC_size_map[0] = 1;
+ for (i = 1; i <= GRANULES_TO_BYTES(TINY_FREELISTS-1) - EXTRA_BYTES; i++) {
+ GC_size_map[i] = ROUNDED_UP_GRANULES(i);
+ GC_ASSERT(GC_size_map[i] < TINY_FREELISTS);
}
+ /* We leave the rest of the array to be filled in on demand. */
+}
+
+/* Fill in additional entries in GC_size_map, including the ith one */
+/* We assume the ith entry is currently 0. */
+/* Note that a filled in section of the array ending at n always */
+/* has length at least n/4. */
+void GC_extend_size_map(size_t i)
+{
+ size_t orig_granule_sz = ROUNDED_UP_GRANULES(i);
+ size_t granule_sz = orig_granule_sz;
+ size_t byte_sz = GRANULES_TO_BYTES(granule_sz);
+ /* The size we try to preserve. */
+ /* Close to i, unless this would */
+ /* introduce too many distinct sizes. */
+ size_t smaller_than_i = byte_sz - (byte_sz >> 3);
+ size_t much_smaller_than_i = byte_sz - (byte_sz >> 2);
+ size_t low_limit; /* The lowest indexed entry we */
+ /* initialize. */
+ size_t j;
- /* Fill in additional entries in GC_size_map, including the ith one */
- /* We assume the ith entry is currently 0. */
- /* Note that a filled in section of the array ending at n always */
- /* has length at least n/4. */
- void GC_extend_size_map(i)
- word i;
+ if (GC_size_map[smaller_than_i] == 0) {
+ low_limit = much_smaller_than_i;
+ while (GC_size_map[low_limit] != 0) low_limit++;
+ } else {
+ low_limit = smaller_than_i + 1;
+ while (GC_size_map[low_limit] != 0) low_limit++;
+ granule_sz = ROUNDED_UP_GRANULES(low_limit);
+ granule_sz += granule_sz >> 3;
+ if (granule_sz < orig_granule_sz) granule_sz = orig_granule_sz;
+ }
+ /* For these larger sizes, we use an even number of granules. */
+ /* This makes it easier to, for example, construct a 16byte-aligned */
+ /* allocator even if GRANULE_BYTES is 8. */
+ granule_sz += 1;
+ granule_sz &= ~1;
+ if (granule_sz > MAXOBJGRANULES) {
+ granule_sz = MAXOBJGRANULES;
+ }
+ /* If we can fit the same number of larger objects in a block, */
+ /* do so. */
{
- word orig_word_sz = ROUNDED_UP_WORDS(i);
- word word_sz = orig_word_sz;
- register word byte_sz = WORDS_TO_BYTES(word_sz);
- /* The size we try to preserve. */
- /* Close to to i, unless this would */
- /* introduce too many distinct sizes. */
- word smaller_than_i = byte_sz - (byte_sz >> 3);
- word much_smaller_than_i = byte_sz - (byte_sz >> 2);
- register word low_limit; /* The lowest indexed entry we */
- /* initialize. */
- register word j;
-
- if (GC_size_map[smaller_than_i] == 0) {
- low_limit = much_smaller_than_i;
- while (GC_size_map[low_limit] != 0) low_limit++;
- } else {
- low_limit = smaller_than_i + 1;
- while (GC_size_map[low_limit] != 0) low_limit++;
- word_sz = ROUNDED_UP_WORDS(low_limit);
- word_sz += word_sz >> 3;
- if (word_sz < orig_word_sz) word_sz = orig_word_sz;
- }
-# ifdef ALIGN_DOUBLE
- word_sz += 1;
- word_sz &= ~1;
-# endif
- if (word_sz > MAXOBJSZ) {
- word_sz = MAXOBJSZ;
- }
- /* If we can fit the same number of larger objects in a block, */
- /* do so. */
- {
- size_t number_of_objs = BODY_SZ/word_sz;
- word_sz = BODY_SZ/number_of_objs;
-# ifdef ALIGN_DOUBLE
- word_sz &= ~1;
-# endif
- }
- byte_sz = WORDS_TO_BYTES(word_sz);
- if (GC_all_interior_pointers) {
- /* We need one extra byte; don't fill in GC_size_map[byte_sz] */
- byte_sz -= EXTRA_BYTES;
- }
-
- for (j = low_limit; j <= byte_sz; j++) GC_size_map[j] = word_sz;
+ size_t number_of_objs = HBLK_GRANULES/granule_sz;
+ granule_sz = HBLK_GRANULES/number_of_objs;
+ granule_sz &= ~1;
}
-# endif
+ byte_sz = GRANULES_TO_BYTES(granule_sz);
+ /* We may need one extra byte; */
+ /* don't always fill in GC_size_map[byte_sz] */
+ byte_sz -= EXTRA_BYTES;
+
+ for (j = low_limit; j <= byte_sz; j++) GC_size_map[j] = granule_sz;
+}
/*
@@ -270,28 +250,26 @@ word GC_stack_last_cleared = 0; /* GC_no when we last did this */
# define CLEAR_SIZE 213 /* Granularity for GC_clear_stack_inner */
# define DEGRADE_RATE 50
-word GC_min_sp; /* Coolest stack pointer value from which we've */
+ptr_t GC_min_sp; /* Coolest stack pointer value from which we've */
/* already cleared the stack. */
-word GC_high_water;
+ptr_t GC_high_water;
/* "hottest" stack pointer value we have seen */
/* recently. Degrades over time. */
-word GC_words_allocd_at_reset;
+word GC_bytes_allocd_at_reset;
#if defined(ASM_CLEAR_CODE)
- extern ptr_t GC_clear_stack_inner();
+ extern void *GC_clear_stack_inner(void *, ptr_t);
#else
/* Clear the stack up to about limit. Return arg. */
/*ARGSUSED*/
-ptr_t GC_clear_stack_inner(arg, limit)
-ptr_t arg;
-word limit;
+void * GC_clear_stack_inner(void *arg, ptr_t limit)
{
word dummy[CLEAR_SIZE];
BZERO(dummy, CLEAR_SIZE*sizeof(word));
- if ((word)(dummy) COOLER_THAN limit) {
+ if ((ptr_t)(dummy) COOLER_THAN limit) {
(void) GC_clear_stack_inner(arg, limit);
}
/* Make sure the recursive call is not a tail call, and the bzero */
@@ -304,10 +282,9 @@ word limit;
/* Clear some of the inaccessible part of the stack. Returns its */
/* argument, so it can be used in a tail call position, hence clearing */
/* another frame. */
-ptr_t GC_clear_stack(arg)
-ptr_t arg;
+void * GC_clear_stack(void *arg)
{
- register word sp = (word)GC_approx_sp(); /* Hotter than actual sp */
+ ptr_t sp = GC_approx_sp(); /* Hotter than actual sp */
# ifdef THREADS
word dummy[SMALL_CLEAR_SIZE];
static unsigned random_no = 0;
@@ -315,7 +292,7 @@ ptr_t arg;
/* Used to occasionally clear a bigger */
/* chunk. */
# endif
- register word limit;
+ ptr_t limit;
# define SLOP 400
/* Extra bytes we clear every time. This clears our own */
@@ -336,7 +313,8 @@ ptr_t arg;
if (++random_no % 13 == 0) {
limit = sp;
MAKE_HOTTER(limit, BIG_CLEAR_SIZE*sizeof(word));
- limit &= ~0xf; /* Make it sufficiently aligned for assembly */
+ limit = (ptr_t)((word)limit & ~0xf);
+ /* Make it sufficiently aligned for assembly */
/* implementations of GC_clear_stack_inner. */
return GC_clear_stack_inner(arg, limit);
} else {
@@ -346,10 +324,10 @@ ptr_t arg;
# else
if (GC_gc_no > GC_stack_last_cleared) {
/* Start things over, so we clear the entire stack again */
- if (GC_stack_last_cleared == 0) GC_high_water = (word) GC_stackbottom;
+ if (GC_stack_last_cleared == 0) GC_high_water = (ptr_t)GC_stackbottom;
GC_min_sp = GC_high_water;
GC_stack_last_cleared = GC_gc_no;
- GC_words_allocd_at_reset = GC_words_allocd;
+ GC_bytes_allocd_at_reset = GC_bytes_allocd;
}
/* Adjust GC_high_water */
MAKE_COOLER(GC_high_water, WORDS_TO_BYTES(DEGRADE_RATE) + GC_SLOP);
@@ -360,17 +338,17 @@ ptr_t arg;
limit = GC_min_sp;
MAKE_HOTTER(limit, SLOP);
if (sp COOLER_THAN limit) {
- limit &= ~0xf; /* Make it sufficiently aligned for assembly */
+ limit = (ptr_t)((word)limit & ~0xf);
+ /* Make it sufficiently aligned for assembly */
/* implementations of GC_clear_stack_inner. */
GC_min_sp = sp;
return(GC_clear_stack_inner(arg, limit));
- } else if (WORDS_TO_BYTES(GC_words_allocd - GC_words_allocd_at_reset)
- > CLEAR_THRESHOLD) {
+ } else if (GC_bytes_allocd - GC_bytes_allocd_at_reset > CLEAR_THRESHOLD) {
/* Restart clearing process, but limit how much clearing we do. */
GC_min_sp = sp;
MAKE_HOTTER(GC_min_sp, CLEAR_THRESHOLD/4);
if (GC_min_sp HOTTER_THAN GC_high_water) GC_min_sp = GC_high_water;
- GC_words_allocd_at_reset = GC_words_allocd;
+ GC_bytes_allocd_at_reset = GC_bytes_allocd;
}
return(arg);
# endif
@@ -379,20 +357,15 @@ ptr_t arg;
/* Return a pointer to the base address of p, given a pointer to a */
/* an address within an object. Return 0 o.w. */
-# ifdef __STDC__
- GC_PTR GC_base(GC_PTR p)
-# else
- GC_PTR GC_base(p)
- GC_PTR p;
-# endif
+void * GC_base(void * p)
{
- register word r;
- register struct hblk *h;
- register bottom_index *bi;
- register hdr *candidate_hdr;
- register word limit;
+ ptr_t r;
+ struct hblk *h;
+ bottom_index *bi;
+ hdr *candidate_hdr;
+ ptr_t limit;
- r = (word)p;
+ r = p;
if (!GC_is_initialized) return 0;
h = HBLKPTR(r);
GET_BI(r, bi);
@@ -402,78 +375,64 @@ ptr_t arg;
/* to the beginning. */
while (IS_FORWARDING_ADDR_OR_NIL(candidate_hdr)) {
h = FORWARDED_ADDR(h,candidate_hdr);
- r = (word)h;
+ r = (ptr_t)h;
candidate_hdr = HDR(h);
}
- if (candidate_hdr -> hb_map == GC_invalid_map) return(0);
+ if (HBLK_IS_FREE(candidate_hdr)) return(0);
/* Make sure r points to the beginning of the object */
- r &= ~(WORDS_TO_BYTES(1) - 1);
+ r = (ptr_t)((word)r & ~(WORDS_TO_BYTES(1) - 1));
{
- register int offset = HBLKDISPL(r);
- register signed_word sz = candidate_hdr -> hb_sz;
- register signed_word map_entry;
-
- map_entry = MAP_ENTRY((candidate_hdr -> hb_map), offset);
- if (map_entry > CPP_MAX_OFFSET) {
- map_entry = (signed_word)(BYTES_TO_WORDS(offset)) % sz;
- }
- r -= WORDS_TO_BYTES(map_entry);
- limit = r + WORDS_TO_BYTES(sz);
- if (limit > (word)(h + 1)
- && sz <= BYTES_TO_WORDS(HBLKSIZE)) {
+ int offset = HBLKDISPL(r);
+ signed_word sz = candidate_hdr -> hb_sz;
+ int obj_displ = offset % sz;
+
+ r -= obj_displ;
+ limit = r + sz;
+ if (limit > (ptr_t)(h + 1) && sz <= HBLKSIZE) {
return(0);
}
- if ((word)p >= limit) return(0);
+ if ((ptr_t)p >= limit) return(0);
}
- return((GC_PTR)r);
+ return((void *)r);
}
/* Return the size of an object, given a pointer to its base. */
/* (For small obects this also happens to work from interior pointers, */
/* but that shouldn't be relied upon.) */
-# ifdef __STDC__
- size_t GC_size(GC_PTR p)
-# else
- size_t GC_size(p)
- GC_PTR p;
-# endif
+size_t GC_size(void * p)
{
- register int sz;
- register hdr * hhdr = HDR(p);
+ hdr * hhdr = HDR(p);
- sz = WORDS_TO_BYTES(hhdr -> hb_sz);
- return(sz);
+ return hhdr -> hb_sz;
}
-size_t GC_get_heap_size GC_PROTO(())
+size_t GC_get_heap_size(void)
{
- return ((size_t) GC_heapsize);
+ return GC_heapsize;
}
-size_t GC_get_free_bytes GC_PROTO(())
+size_t GC_get_free_bytes(void)
{
- return ((size_t) GC_large_free_bytes);
+ return GC_large_free_bytes;
}
-size_t GC_get_bytes_since_gc GC_PROTO(())
+size_t GC_get_bytes_since_gc(void)
{
- return ((size_t) WORDS_TO_BYTES(GC_words_allocd));
+ return GC_bytes_allocd;
}
-size_t GC_get_total_bytes GC_PROTO(())
+size_t GC_get_total_bytes(void)
{
- return ((size_t) WORDS_TO_BYTES(GC_words_allocd+GC_words_allocd_before_gc));
+ return GC_bytes_allocd+GC_bytes_allocd_before_gc;
}
GC_bool GC_is_initialized = FALSE;
-void GC_init()
+void GC_init(void)
{
DCL_LOCK_STATE;
- DISABLE_SIGNALS();
-
#if defined(GC_WIN32_THREADS) && !defined(GC_PTHREADS)
if (!GC_is_initialized) {
BOOL (WINAPI *pfn) (LPCRITICAL_SECTION, DWORD) = NULL;
@@ -491,7 +450,6 @@ void GC_init()
LOCK();
GC_init_inner();
UNLOCK();
- ENABLE_SIGNALS();
# if defined(PARALLEL_MARK) || defined(THREAD_LOCAL_ALLOC)
/* Make sure marker threads and started and thread local */
@@ -518,7 +476,7 @@ void GC_init()
#endif
#ifdef MSWIN32
- extern void GC_init_win32 GC_PROTO((void));
+ extern void GC_init_win32(void);
#endif
extern void GC_setpagesize();
@@ -530,23 +488,23 @@ extern GC_bool GC_no_win32_dlls;
# define GC_no_win32_dlls FALSE
#endif
-void GC_exit_check GC_PROTO((void))
+void GC_exit_check(void)
{
GC_gcollect();
}
#ifdef SEARCH_FOR_DATA_START
- extern void GC_init_linux_data_start GC_PROTO((void));
+ extern void GC_init_linux_data_start(void);
#endif
#ifdef UNIX_LIKE
-extern void GC_set_and_save_fault_handler GC_PROTO((void (*handler)(int)));
+extern void GC_set_and_save_fault_handler(void (*handler)(int));
static void looping_handler(sig)
int sig;
{
- GC_err_printf1("Caught signal %d: looping in handler\n", sig);
+ GC_err_printf("Caught signal %d: looping in handler\n", sig);
for(;;);
}
@@ -576,15 +534,30 @@ void GC_init_inner()
word initial_heap_sz = (word)MINHINCR;
if (GC_is_initialized) return;
-# ifdef PRINTSTATS
- GC_print_stats = 1;
-# endif
# if defined(MSWIN32) || defined(MSWINCE)
InitializeCriticalSection(&GC_write_cs);
# endif
- if (0 != GETENV("GC_PRINT_STATS")) {
- GC_print_stats = 1;
- }
+# if (!defined(SMALL_CONFIG))
+ if (0 != GETENV("GC_PRINT_STATS")) {
+ GC_print_stats = 1;
+ }
+ if (0 != GETENV("GC_PRINT_VERBOSE_STATS")) {
+ GC_print_stats = VERBOSE;
+ }
+# if defined(UNIX_LIKE)
+ {
+ char * file_name = GETENV("GC_LOG_FILE");
+ if (0 != file_name) {
+ int log_d = open(file_name, O_CREAT|O_WRONLY|O_APPEND, 0666);
+ if (log_d < 0) {
+ GC_log_printf("Failed to open %s as log file\n", file_name);
+ } else {
+ GC_log = log_d;
+ }
+ }
+ }
+# endif
+# endif
# ifndef NO_DEBUGGING
if (0 != GETENV("GC_DUMP_REGULARLY")) {
GC_dump_regularly = 1;
@@ -601,9 +574,7 @@ void GC_init_inner()
# endif
if (0 != GETENV("GC_FIND_LEAK")) {
GC_find_leak = 1;
-# ifdef __STDC__
- atexit(GC_exit_check);
-# endif
+ atexit(GC_exit_check);
}
if (0 != GETENV("GC_ALL_INTERIOR_POINTERS")) {
GC_all_interior_pointers = 1;
@@ -618,6 +589,23 @@ void GC_init_inner()
GC_large_alloc_warn_interval = LONG_MAX;
}
{
+ char * addr_string = GETENV("GC_TRACE");
+ if (0 != addr_string) {
+# ifndef ENABLE_TRACE
+ WARN("Tracing not enabled: Ignoring GC_TRACE value\n", 0);
+# else
+# ifdef STRTOULL
+ long long addr = strtoull(addr_string, NULL, 16);
+# else
+ long addr = strtoul(addr_string, NULL, 16);
+# endif
+ if (addr < 0x1000)
+ WARN("Unlikely trace address: 0x%lx", (unsigned long)addr);
+ GC_trace_addr = (ptr_t)addr;
+# endif
+ }
+ }
+ {
char * time_limit_string = GETENV("GC_PAUSE_TIME_TARGET");
if (0 != time_limit_string) {
long time_limit = atol(time_limit_string);
@@ -689,6 +677,7 @@ void GC_init_inner()
# endif
}
# endif
+ /* Ignore gcc -Wall warnings on the following. */
GC_STATIC_ASSERT(sizeof (ptr_t) == sizeof(word));
GC_STATIC_ASSERT(sizeof (signed_word) == sizeof(word));
GC_STATIC_ASSERT(sizeof (struct hblk) == HBLKSIZE);
@@ -743,19 +732,12 @@ void GC_init_inner()
}
}
if (!GC_expand_hp_inner(initial_heap_sz)) {
- GC_err_printf0("Can't start up: not enough memory\n");
+ GC_err_printf("Can't start up: not enough memory\n");
EXIT();
}
- /* Preallocate large object map. It's otherwise inconvenient to */
- /* deal with failure. */
- if (!GC_add_map_entry((word)0)) {
- GC_err_printf0("Can't start up: not enough memory\n");
- EXIT();
- }
+ GC_initialize_offsets();
GC_register_displacement_inner(0L);
-# ifdef MERGE_SIZES
- GC_init_size_map();
-# endif
+ GC_init_size_map();
# ifdef PCR
if (PCR_IL_Lock(PCR_Bool_false, PCR_allSigsBlocked, PCR_waitForever)
!= PCR_ERes_okay) {
@@ -773,7 +755,7 @@ void GC_init_inner()
# ifndef GC_SOLARIS_THREADS
GC_dirty_init();
# endif
- GC_ASSERT(GC_words_allocd == 0)
+ GC_ASSERT(GC_bytes_allocd == 0)
GC_incremental = TRUE;
}
# endif /* !SMALL_CONFIG */
@@ -802,16 +784,12 @@ void GC_init_inner()
# endif
}
-void GC_enable_incremental GC_PROTO(())
+void GC_enable_incremental(void)
{
-# if !defined(SMALL_CONFIG) && !defined(KEEP_BACK_PTRS)
- /* If we are keeping back pointers, the GC itself dirties all */
- /* pages on which objects have been marked, making */
- /* incremental GC pointless. */
+# if !defined(SMALL_CONFIG)
if (!GC_find_leak) {
DCL_LOCK_STATE;
- DISABLE_SIGNALS();
LOCK();
if (GC_incremental) goto out;
GC_setpagesize();
@@ -827,10 +805,9 @@ void GC_enable_incremental GC_PROTO(())
if (GC_dont_gc) {
/* Can't easily do it. */
UNLOCK();
- ENABLE_SIGNALS();
return;
}
- if (GC_words_allocd > 0) {
+ if (GC_bytes_allocd > 0) {
/* There may be unmarked reachable objects */
GC_gcollect_inner();
} /* else we're OK in assuming everything's */
@@ -840,7 +817,6 @@ void GC_enable_incremental GC_PROTO(())
GC_incremental = TRUE;
out:
UNLOCK();
- ENABLE_SIGNALS();
}
# endif
}
@@ -859,7 +835,7 @@ out:
}
int GC_write(buf, len)
- GC_CONST char * buf;
+ const char * buf;
size_t len;
{
BOOL tmp;
@@ -888,6 +864,7 @@ out:
#if defined(OS2) || defined(MACOS)
FILE * GC_stdout = NULL;
FILE * GC_stderr = NULL;
+FILE * GC_log = NULL;
int GC_tmp; /* Should really be local ... */
void GC_set_files()
@@ -904,6 +881,7 @@ int GC_tmp; /* Should really be local ... */
#if !defined(OS2) && !defined(MACOS) && !defined(MSWIN32) && !defined(MSWINCE)
int GC_stdout = 1;
int GC_stderr = 2;
+ int GC_log = 2;
# if !defined(AMIGA)
# include <unistd.h>
# endif
@@ -913,7 +891,7 @@ int GC_tmp; /* Should really be local ... */
&& !defined(MACOS) && !defined(ECOS) && !defined(NOSYS)
int GC_write(fd, buf, len)
int fd;
-GC_CONST char *buf;
+const char *buf;
size_t len;
{
register int bytes_written = 0;
@@ -962,71 +940,75 @@ int GC_write(fd, buf, len)
# endif
#endif
+#define BUFSZ 1024
/* A version of printf that is unlikely to call malloc, and is thus safer */
/* to call from the collector in case malloc has been bound to GC_malloc. */
-/* Assumes that no more than 1023 characters are written at once. */
-/* Assumes that all arguments have been converted to something of the */
-/* same size as long, and that the format conversions expect something */
-/* of that size. */
-void GC_printf(format, a, b, c, d, e, f)
-GC_CONST char * format;
-long a, b, c, d, e, f;
+/* Floating point arguments ans formats should be avoided, since fp */
+/* conversion is more likely to allocate. */
+/* Assumes that no more than BUFSZ-1 characters are written at once. */
+void GC_printf(const char *format, ...)
{
- char buf[1025];
+ va_list args;
+ char buf[BUFSZ+1];
+ va_start(args, format);
if (GC_quiet) return;
- buf[1024] = 0x15;
- (void) sprintf(buf, format, a, b, c, d, e, f);
- if (buf[1024] != 0x15) ABORT("GC_printf clobbered stack");
+ buf[BUFSZ] = 0x15;
+ (void) vsnprintf(buf, BUFSZ, format, args);
+ va_end(args);
+ if (buf[BUFSZ] != 0x15) ABORT("GC_printf clobbered stack");
if (WRITE(GC_stdout, buf, strlen(buf)) < 0) ABORT("write to stdout failed");
}
-void GC_err_printf(format, a, b, c, d, e, f)
-GC_CONST char * format;
-long a, b, c, d, e, f;
+void GC_err_printf(const char *format, ...)
{
- char buf[1025];
+ va_list args;
+ char buf[BUFSZ+1];
- buf[1024] = 0x15;
- (void) sprintf(buf, format, a, b, c, d, e, f);
- if (buf[1024] != 0x15) ABORT("GC_err_printf clobbered stack");
+ va_start(args, format);
+ buf[BUFSZ] = 0x15;
+ (void) vsnprintf(buf, BUFSZ, format, args);
+ va_end(args);
+ if (buf[BUFSZ] != 0x15) ABORT("GC_printf clobbered stack");
if (WRITE(GC_stderr, buf, strlen(buf)) < 0) ABORT("write to stderr failed");
}
+void GC_log_printf(const char *format, ...)
+{
+ va_list args;
+ char buf[BUFSZ+1];
+
+ va_start(args, format);
+ buf[BUFSZ] = 0x15;
+ (void) vsnprintf(buf, BUFSZ, format, args);
+ va_end(args);
+ if (buf[BUFSZ] != 0x15) ABORT("GC_printf clobbered stack");
+ if (WRITE(GC_log, buf, strlen(buf)) < 0) ABORT("write to log failed");
+}
+
void GC_err_puts(s)
-GC_CONST char *s;
+const char *s;
{
if (WRITE(GC_stderr, s, strlen(s)) < 0) ABORT("write to stderr failed");
}
#if defined(LINUX) && !defined(SMALL_CONFIG)
void GC_err_write(buf, len)
-GC_CONST char *buf;
+const char *buf;
size_t len;
{
if (WRITE(GC_stderr, buf, len) < 0) ABORT("write to stderr failed");
}
#endif
-# if defined(__STDC__) || defined(__cplusplus)
- void GC_default_warn_proc(char *msg, GC_word arg)
-# else
- void GC_default_warn_proc(msg, arg)
- char *msg;
- GC_word arg;
-# endif
+void GC_default_warn_proc(char *msg, GC_word arg)
{
- GC_err_printf1(msg, (unsigned long)arg);
+ GC_err_printf(msg, arg);
}
GC_warn_proc GC_current_warn_proc = GC_default_warn_proc;
-# if defined(__STDC__) || defined(__cplusplus)
- GC_warn_proc GC_set_warn_proc(GC_warn_proc p)
-# else
- GC_warn_proc GC_set_warn_proc(p)
- GC_warn_proc p;
-# endif
+GC_warn_proc GC_set_warn_proc(GC_warn_proc p)
{
GC_warn_proc result;
@@ -1040,12 +1022,7 @@ GC_warn_proc GC_current_warn_proc = GC_default_warn_proc;
return(result);
}
-# if defined(__STDC__) || defined(__cplusplus)
- GC_word GC_set_free_space_divisor (GC_word value)
-# else
- GC_word GC_set_free_space_divisor (value)
- GC_word value;
-# endif
+GC_word GC_set_free_space_divisor (GC_word value)
{
GC_word old = GC_free_space_divisor;
GC_free_space_divisor = value;
@@ -1054,12 +1031,12 @@ GC_warn_proc GC_current_warn_proc = GC_default_warn_proc;
#ifndef PCR
void GC_abort(msg)
-GC_CONST char * msg;
+const char * msg;
{
# if defined(MSWIN32)
(void) MessageBoxA(NULL, msg, "Fatal error in gc", MB_ICONERROR|MB_OK);
# else
- GC_err_printf1("%s\n", msg);
+ GC_err_printf("%s\n", msg);
# endif
if (GETENV("GC_LOOP_ON_ABORT") != NULL) {
/* In many cases it's easier to debug a running process. */
@@ -1093,31 +1070,28 @@ void GC_disable()
/* Helper procedures for new kind creation. */
void ** GC_new_free_list_inner()
{
- void *result = GC_INTERNAL_MALLOC((MAXOBJSZ+1)*sizeof(ptr_t), PTRFREE);
+ void *result = GC_INTERNAL_MALLOC((MAXOBJGRANULES+1)*sizeof(ptr_t),
+ PTRFREE);
if (result == 0) ABORT("Failed to allocate freelist for new kind");
- BZERO(result, (MAXOBJSZ+1)*sizeof(ptr_t));
+ BZERO(result, (MAXOBJGRANULES+1)*sizeof(ptr_t));
return result;
}
void ** GC_new_free_list()
{
void *result;
- LOCK(); DISABLE_SIGNALS();
+ LOCK();
result = GC_new_free_list_inner();
- UNLOCK(); ENABLE_SIGNALS();
+ UNLOCK();
return result;
}
-int GC_new_kind_inner(fl, descr, adjust, clear)
-void **fl;
-GC_word descr;
-int adjust;
-int clear;
+int GC_new_kind_inner(void **fl, GC_word descr, int adjust, int clear)
{
int result = GC_n_kinds++;
if (GC_n_kinds > MAXOBJKINDS) ABORT("Too many kinds");
- GC_obj_kinds[result].ok_freelist = (ptr_t *)fl;
+ GC_obj_kinds[result].ok_freelist = fl;
GC_obj_kinds[result].ok_reclaim_list = 0;
GC_obj_kinds[result].ok_descriptor = descr;
GC_obj_kinds[result].ok_relocate_descr = adjust;
@@ -1125,21 +1099,16 @@ int clear;
return result;
}
-int GC_new_kind(fl, descr, adjust, clear)
-void **fl;
-GC_word descr;
-int adjust;
-int clear;
+int GC_new_kind(void **fl, GC_word descr, int adjust, int clear)
{
int result;
- LOCK(); DISABLE_SIGNALS();
+ LOCK();
result = GC_new_kind_inner(fl, descr, adjust, clear);
- UNLOCK(); ENABLE_SIGNALS();
+ UNLOCK();
return result;
}
-int GC_new_proc_inner(proc)
-GC_mark_proc proc;
+int GC_new_proc_inner(GC_mark_proc proc)
{
int result = GC_n_mark_procs++;
@@ -1148,13 +1117,12 @@ GC_mark_proc proc;
return result;
}
-int GC_new_proc(proc)
-GC_mark_proc proc;
+int GC_new_proc(GC_mark_proc proc)
{
int result;
- LOCK(); DISABLE_SIGNALS();
+ LOCK();
result = GC_new_proc_inner(proc);
- UNLOCK(); ENABLE_SIGNALS();
+ UNLOCK();
return result;
}
@@ -1163,15 +1131,15 @@ GC_mark_proc proc;
void GC_dump()
{
- GC_printf0("***Static roots:\n");
+ GC_printf("***Static roots:\n");
GC_print_static_roots();
- GC_printf0("\n***Heap sections:\n");
+ GC_printf("\n***Heap sections:\n");
GC_print_heap_sects();
- GC_printf0("\n***Free blocks:\n");
+ GC_printf("\n***Free blocks:\n");
GC_print_hblkfreelist();
- GC_printf0("\n***Blocks in use:\n");
+ GC_printf("\n***Blocks in use:\n");
GC_print_block_list();
- GC_printf0("\n***Finalization statistics:\n");
+ GC_printf("\n***Finalization statistics:\n");
GC_print_finalization_stats();
}
diff --git a/new_hblk.c b/new_hblk.c
index e5580e4..5d5a56f 100644
--- a/new_hblk.c
+++ b/new_hblk.c
@@ -14,7 +14,7 @@
*
* This file contains the functions:
* ptr_t GC_build_flXXX(h, old_fl)
- * void GC_new_hblk(n)
+ * void GC_new_hblk(size)
*/
/* Boehm, May 19, 1994 2:09 pm PDT */
@@ -24,37 +24,14 @@
#ifndef SMALL_CONFIG
/*
- * Build a free list for size 1 objects inside hblk h. Set the last link to
+ * Build a free list for size 2 (words) cleared objects inside hblk h.
+ * Set the last link to
* be ofl. Return a pointer tpo the first free list entry.
*/
-ptr_t GC_build_fl1(h, ofl)
-struct hblk *h;
-ptr_t ofl;
+ptr_t GC_build_fl_clear2(struct hblk *h, ptr_t ofl)
{
- register word * p = h -> hb_body;
- register word * lim = (word *)(h + 1);
-
- p[0] = (word)ofl;
- p[1] = (word)(p);
- p[2] = (word)(p+1);
- p[3] = (word)(p+2);
- p += 4;
- for (; p < lim; p += 4) {
- p[0] = (word)(p-1);
- p[1] = (word)(p);
- p[2] = (word)(p+1);
- p[3] = (word)(p+2);
- };
- return((ptr_t)(p-1));
-}
-
-/* The same for size 2 cleared objects */
-ptr_t GC_build_fl_clear2(h, ofl)
-struct hblk *h;
-ptr_t ofl;
-{
- register word * p = h -> hb_body;
- register word * lim = (word *)(h + 1);
+ word * p = (word *)(h -> hb_body);
+ word * lim = (word *)(h + 1);
p[0] = (word)ofl;
p[1] = 0;
@@ -70,33 +47,11 @@ ptr_t ofl;
return((ptr_t)(p-2));
}
-/* The same for size 3 cleared objects */
-ptr_t GC_build_fl_clear3(h, ofl)
-struct hblk *h;
-ptr_t ofl;
-{
- register word * p = h -> hb_body;
- register word * lim = (word *)(h + 1) - 2;
-
- p[0] = (word)ofl;
- p[1] = 0;
- p[2] = 0;
- p += 3;
- for (; p < lim; p += 3) {
- p[0] = (word)(p-3);
- p[1] = 0;
- p[2] = 0;
- };
- return((ptr_t)(p-3));
-}
-
/* The same for size 4 cleared objects */
-ptr_t GC_build_fl_clear4(h, ofl)
-struct hblk *h;
-ptr_t ofl;
+ptr_t GC_build_fl_clear4(struct hblk *h, ptr_t ofl)
{
- register word * p = h -> hb_body;
- register word * lim = (word *)(h + 1);
+ word * p = (word *)(h -> hb_body);
+ word * lim = (word *)(h + 1);
p[0] = (word)ofl;
p[1] = 0;
@@ -113,12 +68,10 @@ ptr_t ofl;
}
/* The same for size 2 uncleared objects */
-ptr_t GC_build_fl2(h, ofl)
-struct hblk *h;
-ptr_t ofl;
+ptr_t GC_build_fl2(struct hblk *h, ptr_t ofl)
{
- register word * p = h -> hb_body;
- register word * lim = (word *)(h + 1);
+ word * p = (word *)(h -> hb_body);
+ word * lim = (word *)(h + 1);
p[0] = (word)ofl;
p[2] = (word)p;
@@ -131,12 +84,10 @@ ptr_t ofl;
}
/* The same for size 4 uncleared objects */
-ptr_t GC_build_fl4(h, ofl)
-struct hblk *h;
-ptr_t ofl;
+ptr_t GC_build_fl4(struct hblk *h, ptr_t ofl)
{
- register word * p = h -> hb_body;
- register word * lim = (word *)(h + 1);
+ word * p = (word *)(h -> hb_body);
+ word * lim = (word *)(h + 1);
p[0] = (word)ofl;
p[4] = (word)p;
@@ -158,11 +109,7 @@ ptr_t ofl;
/* This could be called without the main GC lock, if we ensure that */
/* there is no concurrent collection which might reclaim objects that */
/* we have not yet allocated. */
-ptr_t GC_build_fl(h, sz, clear, list)
-struct hblk *h;
-word sz;
-GC_bool clear;
-ptr_t list;
+ptr_t GC_build_fl(struct hblk *h, size_t sz, GC_bool clear, ptr_t list)
{
word *p, *prev;
word *last_object; /* points to last object in new hblk */
@@ -179,18 +126,11 @@ ptr_t list;
/* the difference is less significant. */
# ifndef SMALL_CONFIG
switch (sz) {
- case 1: return GC_build_fl1(h, list);
case 2: if (clear) {
return GC_build_fl_clear2(h, list);
} else {
return GC_build_fl2(h, list);
}
- case 3: if (clear) {
- return GC_build_fl_clear3(h, list);
- } else {
- /* It's messy to do better than the default here. */
- break;
- }
case 4: if (clear) {
return GC_build_fl_clear4(h, list);
} else {
@@ -205,8 +145,8 @@ ptr_t list;
if (clear) BZERO(h, HBLKSIZE);
/* Add objects to free list */
- p = &(h -> hb_body[sz]); /* second object in *h */
- prev = &(h -> hb_body[0]); /* One object behind p */
+ p = (word *)(h -> hb_body) + sz; /* second object in *h */
+ prev = (word *)(h -> hb_body); /* One object behind p */
last_object = (word *)((char *)h + HBLKSIZE);
last_object -= sz;
/* Last place for last object to start */
@@ -228,36 +168,34 @@ ptr_t list;
return ((ptr_t)p);
}
+
/*
- * Allocate a new heapblock for small objects of size n.
+ * Allocate a new heapblock for small objects of size gran granules.
* Add all of the heapblock's objects to the free list for objects
* of that size.
* Set all mark bits if objects are uncollectable.
* Will fail to do anything if we are out of memory.
*/
-void GC_new_hblk(sz, kind)
-register word sz;
-int kind;
+void GC_new_hblk(size_t gran, int kind)
{
- register struct hblk *h; /* the new heap block */
- register GC_bool clear = GC_obj_kinds[kind].ok_init;
+ struct hblk *h; /* the new heap block */
+ GC_bool clear = GC_obj_kinds[kind].ok_init;
-# ifdef PRINTSTATS
- if ((sizeof (struct hblk)) > HBLKSIZE) {
- ABORT("HBLK SZ inconsistency");
- }
-# endif
+ /* Ignore gcc "no effect" warning on the following: */
+ GC_STATIC_ASSERT((sizeof (struct hblk)) == HBLKSIZE);
+
if (GC_debugging_started) clear = TRUE;
/* Allocate a new heap block */
- h = GC_allochblk(sz, kind, 0);
+ h = GC_allochblk(GRANULES_TO_BYTES(gran), kind, 0);
if (h == 0) return;
/* Mark all objects if appropriate. */
if (IS_UNCOLLECTABLE(kind)) GC_set_hdr_marks(HDR(h));
/* Build the free list */
- GC_obj_kinds[kind].ok_freelist[sz] =
- GC_build_fl(h, sz, clear, GC_obj_kinds[kind].ok_freelist[sz]);
+ GC_obj_kinds[kind].ok_freelist[gran] =
+ GC_build_fl(h, GRANULES_TO_WORDS(gran), clear,
+ GC_obj_kinds[kind].ok_freelist[gran]);
}
diff --git a/obj_map.c b/obj_map.c
index d002d65..3b9a09d 100644
--- a/obj_map.c
+++ b/obj_map.c
@@ -21,127 +21,70 @@
# include "private/gc_priv.h"
-map_entry_type * GC_invalid_map = 0;
-
-/* Invalidate the object map associated with a block. Free blocks */
-/* are identified by invalid maps. */
-void GC_invalidate_map(hhdr)
-hdr *hhdr;
-{
- register int displ;
-
- if (GC_invalid_map == 0) {
- GC_invalid_map = (map_entry_type *)GC_scratch_alloc(MAP_SIZE);
- if (GC_invalid_map == 0) {
- GC_err_printf0(
- "Cant initialize GC_invalid_map: insufficient memory\n");
- EXIT();
- }
- for (displ = 0; displ < HBLKSIZE; displ++) {
- MAP_ENTRY(GC_invalid_map, displ) = OBJ_INVALID;
- }
- }
- hhdr -> hb_map = GC_invalid_map;
-}
-
/* Consider pointers that are offset bytes displaced from the beginning */
/* of an object to be valid. */
-# if defined(__STDC__) || defined(__cplusplus)
- void GC_register_displacement(GC_word offset)
-# else
- void GC_register_displacement(offset)
- GC_word offset;
-# endif
+void GC_register_displacement(size_t offset)
{
DCL_LOCK_STATE;
- DISABLE_SIGNALS();
LOCK();
GC_register_displacement_inner(offset);
UNLOCK();
- ENABLE_SIGNALS();
}
-void GC_register_displacement_inner(offset)
-word offset;
+void GC_register_displacement_inner(size_t offset)
{
- register unsigned i;
- word map_entry = BYTES_TO_WORDS(offset);
-
if (offset >= VALID_OFFSET_SZ) {
ABORT("Bad argument to GC_register_displacement");
}
- if (map_entry > MAX_OFFSET) map_entry = OFFSET_TOO_BIG;
if (!GC_valid_offsets[offset]) {
GC_valid_offsets[offset] = TRUE;
GC_modws_valid_offsets[offset % sizeof(word)] = TRUE;
- if (!GC_all_interior_pointers) {
- for (i = 0; i <= MAXOBJSZ; i++) {
- if (GC_obj_map[i] != 0) {
- if (i == 0) {
- GC_obj_map[i][offset] = (map_entry_type)map_entry;
- } else {
- register unsigned j;
- register unsigned lb = WORDS_TO_BYTES(i);
-
- if (offset < lb) {
- for (j = offset; j < HBLKSIZE; j += lb) {
- GC_obj_map[i][j] = (map_entry_type)map_entry;
- }
- }
- }
- }
- }
- }
}
}
-
-/* Add a heap block map for objects of size sz to obj_map. */
-/* Return FALSE on failure. */
-GC_bool GC_add_map_entry(sz)
-word sz;
+#ifdef MARK_BIT_PER_GRANULE
+/* Add a heap block map for objects of size granules to obj_map. */
+/* Return FALSE on failure. */
+/* A size of 0 granules is used for large objects. */
+GC_bool GC_add_map_entry(size_t granules)
{
- register unsigned obj_start;
- register unsigned displ;
- register map_entry_type * new_map;
- word map_entry;
+ unsigned displ;
+ short * new_map;
- if (sz > MAXOBJSZ) sz = 0;
- if (GC_obj_map[sz] != 0) {
+ if (granules > BYTES_TO_GRANULES(MAXOBJBYTES)) granules = 0;
+ if (GC_obj_map[granules] != 0) {
return(TRUE);
}
- new_map = (map_entry_type *)GC_scratch_alloc(MAP_SIZE);
+ new_map = (short *)GC_scratch_alloc(MAP_LEN * sizeof(short));
if (new_map == 0) return(FALSE);
-# ifdef PRINTSTATS
- GC_printf1("Adding block map for size %lu\n", (unsigned long)sz);
-# endif
- for (displ = 0; displ < HBLKSIZE; displ++) {
- MAP_ENTRY(new_map,displ) = OBJ_INVALID;
- }
- if (sz == 0) {
- for(displ = 0; displ <= HBLKSIZE; displ++) {
- if (OFFSET_VALID(displ)) {
- map_entry = BYTES_TO_WORDS(displ);
- if (map_entry > MAX_OFFSET) map_entry = OFFSET_TOO_BIG;
- MAP_ENTRY(new_map,displ) = (map_entry_type)map_entry;
- }
- }
+ if (GC_print_stats)
+ GC_printf("Adding block map for size of %u granules (%u bytes)\n",
+ (unsigned)granules, (unsigned)(GRANULES_TO_BYTES(granules)));
+ if (granules == 0) {
+ for (displ = 0; displ < BYTES_TO_GRANULES(HBLKSIZE); displ++) {
+ new_map[displ] = 1; /* Nonzero to get us out of marker fast path. */
+ }
} else {
- for (obj_start = 0;
- obj_start + WORDS_TO_BYTES(sz) <= HBLKSIZE;
- obj_start += WORDS_TO_BYTES(sz)) {
- for (displ = 0; displ < WORDS_TO_BYTES(sz); displ++) {
- if (OFFSET_VALID(displ)) {
- map_entry = BYTES_TO_WORDS(displ);
- if (map_entry > MAX_OFFSET) map_entry = OFFSET_TOO_BIG;
- MAP_ENTRY(new_map, obj_start + displ) =
- (map_entry_type)map_entry;
- }
- }
- }
+ for (displ = 0; displ < BYTES_TO_GRANULES(HBLKSIZE); displ++) {
+ new_map[displ] = displ % granules;
+ }
}
- GC_obj_map[sz] = new_map;
+ GC_obj_map[granules] = new_map;
return(TRUE);
}
+#endif
+
+static GC_bool offsets_initialized = FALSE;
+
+void GC_initialize_offsets(void)
+{
+ if (!offsets_initialized) {
+ int i;
+ if (GC_all_interior_pointers) {
+ for (i = 0; i < VALID_OFFSET_SZ; ++i) GC_valid_offsets[i] = TRUE;
+ }
+ offsets_initialized = TRUE;
+ }
+}
diff --git a/os_dep.c b/os_dep.c
index f5c7467..45037b1 100644
--- a/os_dep.c
+++ b/os_dep.c
@@ -15,6 +15,9 @@
*/
# include "private/gc_priv.h"
+# ifdef THREADS
+# include "atomic_ops.h"
+# endif
# if defined(LINUX) && !defined(POWERPC)
# include <linux/version.h>
@@ -48,7 +51,7 @@
# if !defined(OS2) && !defined(PCR) && !defined(AMIGA) && !defined(MACOS) \
&& !defined(MSWINCE)
# include <sys/types.h>
-# if !defined(MSWIN32) && !defined(SUNOS4)
+# if !defined(MSWIN32)
# include <unistd.h>
# endif
# endif
@@ -71,10 +74,6 @@
# define NEED_FIND_LIMIT
# endif
-# if (defined(SUNOS4) && defined(DYNAMIC_LOADING)) && !defined(PCR)
-# define NEED_FIND_LIMIT
-# endif
-
# if (defined(SVR4) || defined(AUX) || defined(DGUX) \
|| (defined(LINUX) && defined(SPARC))) && !defined(PCR)
# define NEED_FIND_LIMIT
@@ -334,7 +333,7 @@ char *GC_parse_map_entry(char *buf_ptr, word *start, word *end,
void GC_init_linux_data_start()
{
- extern ptr_t GC_find_limit();
+ extern ptr_t GC_find_limit(ptr_t, GC_bool);
# ifdef LINUX
/* Try the easy approaches first: */
@@ -388,9 +387,9 @@ static void *tiny_sbrk(ptrdiff_t increment)
#if (defined(NETBSD) || defined(OPENBSD)) && defined(__ELF__)
ptr_t GC_data_start;
- void GC_init_netbsd_elf()
+ void GC_init_netbsd_elf(void)
{
- extern ptr_t GC_find_limit();
+ extern ptr_t GC_find_limit(ptr_t, GC_bool);
extern char **environ;
/* This may need to be environ, without the underscore, for */
/* some versions. */
@@ -531,12 +530,12 @@ static SIGSET_T old_mask;
static SIGSET_T dummy;
-#if defined(PRINTSTATS) && !defined(THREADS)
+#if defined(GC_ASSERTIONS) && !defined(THREADS)
# define CHECK_SIGNALS
int GC_sig_disabled = 0;
#endif
-void GC_disable_signals()
+void GC_disable_signals(void)
{
if (!mask_initialized) {
SIG_FILL(new_mask);
@@ -565,7 +564,7 @@ void GC_disable_signals()
SIGSETMASK(old_mask,new_mask);
}
-void GC_enable_signals()
+void GC_enable_signals(void)
{
# ifdef CHECK_SIGNALS
if (GC_sig_disabled != 1) ABORT("Unmatched enable");
@@ -588,7 +587,7 @@ void GC_enable_signals()
word GC_page_size;
# if defined(MSWIN32) || defined(MSWINCE)
- void GC_setpagesize()
+ void GC_setpagesize(void)
{
GetSystemInfo(&GC_sysinfo);
GC_page_size = GC_sysinfo.dwPageSize;
@@ -597,13 +596,13 @@ word GC_page_size;
# else
# if defined(MPROTECT_VDB) || defined(PROC_VDB) || defined(USE_MMAP) \
|| defined(USE_MUNMAP)
- void GC_setpagesize()
+ void GC_setpagesize(void)
{
GC_page_size = GETPAGESIZE();
}
# else
/* It's acceptable to fake it. */
- void GC_setpagesize()
+ void GC_setpagesize(void)
{
GC_page_size = HBLKSIZE;
}
@@ -642,7 +641,7 @@ word GC_get_writable_length(ptr_t p, ptr_t *base)
return(buf.RegionSize);
}
-ptr_t GC_get_stack_base()
+ptr_t GC_get_stack_base(void)
{
int dummy;
ptr_t sp = (ptr_t)(&dummy);
@@ -657,7 +656,7 @@ ptr_t GC_get_stack_base()
# ifdef BEOS
# include <kernel/OS.h>
-ptr_t GC_get_stack_base(){
+ptr_t GC_get_stack_base(void){
thread_info th;
get_thread_info(find_thread(NULL),&th);
return th.stack_end;
@@ -667,13 +666,13 @@ ptr_t GC_get_stack_base(){
# ifdef OS2
-ptr_t GC_get_stack_base()
+ptr_t GC_get_stack_base(void)
{
PTIB ptib;
PPIB ppib;
if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
- GC_err_printf0("DosGetInfoBlocks failed\n");
+ GC_err_printf("DosGetInfoBlocks failed\n");
ABORT("DosGetInfoBlocks failed\n");
}
return((ptr_t)(ptib -> tib_pstacklimit));
@@ -689,11 +688,7 @@ ptr_t GC_get_stack_base()
# if defined(NEED_FIND_LIMIT) || defined(UNIX_LIKE)
-# ifdef __STDC__
- typedef void (*handler)(int);
-# else
- typedef void (*handler)();
-# endif
+ typedef void (*handler)(int);
# if defined(SUNOS5SIGS) || defined(IRIX5) || defined(OSF1) \
|| defined(HURD) || defined(NETBSD)
@@ -706,12 +701,7 @@ ptr_t GC_get_stack_base()
static handler old_segv_handler, old_bus_handler;
# endif
-# ifdef __STDC__
- void GC_set_and_save_fault_handler(handler h)
-# else
- void GC_set_and_save_fault_handler(h)
- handler h;
-# endif
+ void GC_set_and_save_fault_handler(handler h)
{
# if defined(SUNOS5SIGS) || defined(IRIX5) \
|| defined(OSF1) || defined(HURD) || defined(NETBSD)
@@ -756,18 +746,17 @@ ptr_t GC_get_stack_base()
/* static */ JMP_BUF GC_jmp_buf;
/*ARGSUSED*/
- void GC_fault_handler(sig)
- int sig;
+ void GC_fault_handler(int sig)
{
LONGJMP(GC_jmp_buf, 1);
}
- void GC_setup_temporary_fault_handler()
+ void GC_setup_temporary_fault_handler(void)
{
GC_set_and_save_fault_handler(GC_fault_handler);
}
- void GC_reset_fault_handler()
+ void GC_reset_fault_handler(void)
{
# if defined(SUNOS5SIGS) || defined(IRIX5) \
|| defined(OSF1) || defined(HURD) || defined(NETBSD)
@@ -787,11 +776,9 @@ ptr_t GC_get_stack_base()
/* Return the first nonaddressible location > p (up) or */
/* the smallest location q s.t. [q,p) is addressable (!up). */
/* We assume that p (up) or p-1 (!up) is addressable. */
- ptr_t GC_find_limit(p, up)
- ptr_t p;
- GC_bool up;
+ ptr_t GC_find_limit(ptr_t p, GC_bool up)
{
- static VOLATILE ptr_t result;
+ static volatile ptr_t result;
/* Needs to be static, since otherwise it may not be */
/* preserved across the longjmp. Can safely be */
/* static since it's only called once, with the */
@@ -820,7 +807,7 @@ ptr_t GC_get_stack_base()
# endif
#if defined(ECOS) || defined(NOSYS)
- ptr_t GC_get_stack_base()
+ ptr_t GC_get_stack_base(void)
{
return STACKBOTTOM;
}
@@ -858,10 +845,8 @@ ptr_t GC_get_stack_base()
# define STAT_SKIP 27 /* Number of fields preceding startstack */
/* field in /proc/self/stat */
-#ifdef USE_LIBC_PRIVATES
# pragma weak __libc_stack_end
extern ptr_t __libc_stack_end;
-#endif
# ifdef IA64
/* Try to read the backing store base from /proc/self/maps. */
@@ -880,7 +865,8 @@ ptr_t GC_get_stack_base()
buf_ptr = GC_parse_map_entry(buf_ptr, &start, &end, prot_buf, &maj_dev);
if (buf_ptr == NULL) return current_best;
if (prot_buf[1] == 'w' && maj_dev == 0) {
- if (end < (word)(&dummy) && start > current_best) current_best = start;
+ if (end < (word)(&dummy) && start > current_best)
+ current_best = start;
}
}
return current_best;
@@ -891,33 +877,30 @@ ptr_t GC_get_stack_base()
return GC_apply_to_maps(backing_store_base_from_maps);
}
-# ifdef USE_LIBC_PRIVATES
-# pragma weak __libc_ia64_register_backing_store_base
- extern ptr_t __libc_ia64_register_backing_store_base;
-# endif
+# pragma weak __libc_ia64_register_backing_store_base
+ extern ptr_t __libc_ia64_register_backing_store_base;
ptr_t GC_get_register_stack_base(void)
{
-# ifdef USE_LIBC_PRIVATES
- if (0 != &__libc_ia64_register_backing_store_base
- && 0 != __libc_ia64_register_backing_store_base) {
- /* Glibc 2.2.4 has a bug such that for dynamically linked */
- /* executables __libc_ia64_register_backing_store_base is */
- /* defined but uninitialized during constructor calls. */
- /* Hence we check for both nonzero address and value. */
- return __libc_ia64_register_backing_store_base;
- }
-# endif
- word result = backing_store_base_from_proc();
- if (0 == result) {
+ if (0 != &__libc_ia64_register_backing_store_base
+ && 0 != __libc_ia64_register_backing_store_base) {
+ /* Glibc 2.2.4 has a bug such that for dynamically linked */
+ /* executables __libc_ia64_register_backing_store_base is */
+ /* defined but uninitialized during constructor calls. */
+ /* Hence we check for both nonzero address and value. */
+ return __libc_ia64_register_backing_store_base;
+ } else {
+ word result = backing_store_base_from_proc();
+ if (0 == result) {
/* Use dumb heuristics. Works only for default configuration. */
result = (word)GC_stackbottom - BACKING_STORE_DISPLACEMENT;
result += BACKING_STORE_ALIGNMENT - 1;
result &= ~(BACKING_STORE_ALIGNMENT - 1);
/* Verify that it's at least readable. If not, we goofed. */
GC_noop1(*(word *)result);
+ }
+ return (ptr_t)result;
}
- return (ptr_t)result;
}
# endif
@@ -940,7 +923,6 @@ ptr_t GC_get_stack_base()
/* since the correct value of __libc_stack_end never */
/* becomes visible to us. The second test works around */
/* this. */
-# ifdef USE_LIBC_PRIVATES
if (0 != &__libc_stack_end && 0 != __libc_stack_end ) {
# ifdef IA64
/* Some versions of glibc set the address 16 bytes too */
@@ -953,7 +935,6 @@ ptr_t GC_get_stack_base()
return __libc_stack_end;
# endif
}
-# endif
f = open("/proc/self/stat", O_RDONLY);
if (f < 0 || STAT_READ(f, stat_buf, STAT_BUF_SIZE) < 2 * STAT_SKIP) {
ABORT("Couldn't read /proc/self/stat");
@@ -1004,13 +985,12 @@ ptr_t GC_get_stack_base()
#if !defined(BEOS) && !defined(AMIGA) && !defined(MSWIN32) \
&& !defined(MSWINCE) && !defined(OS2) && !defined(NOSYS) && !defined(ECOS)
-ptr_t GC_get_stack_base()
+ptr_t GC_get_stack_base(void)
{
-# if defined(HEURISTIC1) || defined(HEURISTIC2) || \
- defined(LINUX_STACKBOTTOM) || defined(FREEBSD_STACKBOTTOM)
- word dummy;
- ptr_t result;
+# if defined(HEURISTIC1) || defined(HEURISTIC2)
+ word dummy;
# endif
+ ptr_t result;
# define STACKBOTTOM_ALIGNMENT_M1 ((word)STACK_GRAN - 1)
@@ -1072,7 +1052,7 @@ ptr_t GC_get_stack_base()
# ifdef OS2
-void GC_register_data_segments()
+void GC_register_data_segments(void)
{
PTIB ptib;
PPIB ppib;
@@ -1087,12 +1067,12 @@ void GC_register_data_segments()
if (DosGetInfoBlocks(&ptib, &ppib) != NO_ERROR) {
- GC_err_printf0("DosGetInfoBlocks failed\n");
+ GC_err_printf("DosGetInfoBlocks failed\n");
ABORT("DosGetInfoBlocks failed\n");
}
module_handle = ppib -> pib_hmte;
if (DosQueryModuleName(module_handle, PBUFSIZ, path) != NO_ERROR) {
- GC_err_printf0("DosQueryModuleName failed\n");
+ GC_err_printf("DosQueryModuleName failed\n");
ABORT("DosGetInfoBlocks failed\n");
}
myexefile = fopen(path, "rb");
@@ -1153,7 +1133,7 @@ void GC_register_data_segments()
if (!(flags & OBJWRITE)) continue;
if (!(flags & OBJREAD)) continue;
if (flags & OBJINVALID) {
- GC_err_printf0("Object with invalid pages?\n");
+ GC_err_printf("Object with invalid pages?\n");
continue;
}
GC_add_roots_inner(O32_BASE(seg), O32_BASE(seg)+O32_SIZE(seg), FALSE);
@@ -1177,7 +1157,7 @@ void GC_register_data_segments()
/* the structured exception handling issues. But we now have */
/* assembly code to do that right. */
- void GC_init_win32()
+ void GC_init_win32(void)
{
/* if we're running under win32s, assume that no DLLs will be loaded */
DWORD v = GetVersion();
@@ -1271,11 +1251,9 @@ void GC_register_data_segments()
free(new_l); return;
}
}
-# ifdef CONDPRINT
- if (GC_print_stats)
- GC_printf1("Found new system malloc AllocationBase at 0x%lx\n",
- candidate);
-# endif
+ if (GC_print_stats)
+ GC_log_printf("Found new system malloc AllocationBase at %p\n",
+ candidate);
new_l -> allocation_base = candidate;
new_l -> next = GC_malloc_heap_l;
GC_malloc_heap_l = new_l;
@@ -1352,9 +1330,7 @@ void GC_register_data_segments()
# if (defined(SVR4) || defined(AUX) || defined(DGUX) \
|| (defined(LINUX) && defined(SPARC))) && !defined(PCR)
-ptr_t GC_SysVGetDataStart(max_page_size, etext_addr)
-int max_page_size;
-int * etext_addr;
+ptr_t GC_SysVGetDataStart(size_t max_page_size, ptr_t etext_addr)
{
word text_end = ((word)(etext_addr) + sizeof(word) - 1)
& ~(sizeof(word) - 1);
@@ -1362,7 +1338,7 @@ int * etext_addr;
word next_page = ((text_end + (word)max_page_size - 1)
& ~((word)max_page_size - 1));
word page_offset = (text_end & ((word)max_page_size - 1));
- VOLATILE char * result = (char *)(next_page + page_offset);
+ volatile char * result = (char *)(next_page + page_offset);
/* Note that this isnt equivalent to just adding */
/* max_page_size to &etext if &etext is at a page boundary */
@@ -1390,22 +1366,20 @@ int * etext_addr;
/* For now we don't assume that there is always an empty page after */
/* etext. But in some cases there actually seems to be slightly more. */
/* This also deals with holes between read-only data and writable data. */
-ptr_t GC_FreeBSDGetDataStart(max_page_size, etext_addr)
-int max_page_size;
-int * etext_addr;
+ptr_t GC_FreeBSDGetDataStart(size_t max_page_size, ptr_t etext_addr)
{
word text_end = ((word)(etext_addr) + sizeof(word) - 1)
& ~(sizeof(word) - 1);
/* etext rounded to word boundary */
- VOLATILE word next_page = (text_end + (word)max_page_size - 1)
+ volatile word next_page = (text_end + (word)max_page_size - 1)
& ~((word)max_page_size - 1);
- VOLATILE ptr_t result = (ptr_t)text_end;
+ volatile ptr_t result = (ptr_t)text_end;
GC_setup_temporary_fault_handler();
if (SETJMP(GC_jmp_buf) == 0) {
/* Try reading at the address. */
/* This should happen before there is another thread. */
for (; next_page < (word)(DATAEND); next_page += (word)max_page_size)
- *(VOLATILE char *)next_page;
+ *(volatile char *)next_page;
GC_reset_fault_handler();
} else {
GC_reset_fault_handler();
@@ -1426,7 +1400,7 @@ int * etext_addr;
#else /* !OS2 && !Windows && !AMIGA */
-void GC_register_data_segments()
+void GC_register_data_segments(void)
{
# if !defined(PCR) && !defined(SRC_M3) && !defined(MACOS)
# if defined(REDIRECT_MALLOC) && defined(GC_SOLARIS_THREADS)
@@ -1437,11 +1411,11 @@ void GC_register_data_segments()
/* hanging from it. We're on thin ice here ... */
extern caddr_t sbrk();
- GC_add_roots_inner(DATASTART, (char *)sbrk(0), FALSE);
+ GC_add_roots_inner(DATASTART, (ptr_t)sbrk(0), FALSE);
# else
- GC_add_roots_inner(DATASTART, (char *)(DATAEND), FALSE);
+ GC_add_roots_inner(DATASTART, (ptr_t)(DATAEND), FALSE);
# if defined(DATASTART2)
- GC_add_roots_inner(DATASTART2, (char *)(DATAEND2), FALSE);
+ GC_add_roots_inner(DATASTART2, (ptr_t)(DATAEND2), FALSE);
# endif
# endif
# endif
@@ -1495,22 +1469,14 @@ void GC_register_data_segments()
&& !defined(MSWIN32) && !defined(MSWINCE) \
&& !defined(MACOS) && !defined(DOS4GW)
-# ifdef SUNOS4
- extern caddr_t sbrk();
-# endif
-# ifdef __STDC__
-# define SBRK_ARG_T ptrdiff_t
-# else
-# define SBRK_ARG_T int
-# endif
+# define SBRK_ARG_T ptrdiff_t
# ifdef RS6000
/* The compiler seems to generate speculative reads one past the end of */
/* an allocated object. Hence we need to make sure that the page */
/* following the last heap page is also mapped. */
-ptr_t GC_unix_get_mem(bytes)
-word bytes;
+ptr_t GC_unix_get_mem(word bytes)
{
caddr_t cur_brk = (caddr_t)sbrk(0);
caddr_t result;
@@ -1567,8 +1533,7 @@ word bytes;
# define HEAP_START 0
#endif
-ptr_t GC_unix_get_mem(bytes)
-word bytes;
+ptr_t GC_unix_get_mem(word bytes)
{
void *result;
static ptr_t last_addr = HEAP_START;
@@ -1605,8 +1570,7 @@ word bytes;
}
#else /* Not RS6000, not USE_MMAP */
-ptr_t GC_unix_get_mem(bytes)
-word bytes;
+ptr_t GC_unix_get_mem(word bytes)
{
ptr_t result;
# ifdef IRIX5
@@ -1668,8 +1632,7 @@ SYSTEM_INFO GC_sysinfo;
word GC_n_heap_bases = 0;
-ptr_t GC_win32_get_mem(bytes)
-word bytes;
+ptr_t GC_win32_get_mem(word bytes)
{
ptr_t result;
@@ -1700,7 +1663,7 @@ word bytes;
return(result);
}
-void GC_win32_free_heap ()
+void GC_win32_free_heap(void)
{
if (GC_no_win32_dlls) {
while (GC_n_heap_bases > 0) {
@@ -1721,8 +1684,7 @@ void GC_win32_free_heap ()
# ifdef MSWINCE
word GC_n_heap_bases = 0;
-ptr_t GC_wince_get_mem(bytes)
-word bytes;
+ptr_t GC_wince_get_mem(word bytes)
{
ptr_t result;
word i;
@@ -1792,7 +1754,7 @@ word bytes;
/* Compute a page aligned starting address for the unmap */
/* operation on a block of size bytes starting at start. */
/* Return 0 if the block is too small to make this feasible. */
-ptr_t GC_unmap_start(ptr_t start, word bytes)
+ptr_t GC_unmap_start(ptr_t start, size_t bytes)
{
ptr_t result = start;
/* Round start to next page boundary. */
@@ -1804,7 +1766,7 @@ ptr_t GC_unmap_start(ptr_t start, word bytes)
/* Compute end address for an unmap operation on the indicated */
/* block. */
-ptr_t GC_unmap_end(ptr_t start, word bytes)
+ptr_t GC_unmap_end(ptr_t start, size_t bytes)
{
ptr_t end_addr = start + bytes;
end_addr = (ptr_t)((word)end_addr & ~(GC_page_size - 1));
@@ -1822,7 +1784,7 @@ ptr_t GC_unmap_end(ptr_t start, word bytes)
/* We assume that GC_remap is called on exactly the same range */
/* as a previous call to GC_unmap. It is safe to consistently */
/* round the endpoints in both places. */
-void GC_unmap(ptr_t start, word bytes)
+void GC_unmap(ptr_t start, size_t bytes)
{
ptr_t start_addr = GC_unmap_start(start, bytes);
ptr_t end_addr = GC_unmap_end(start, bytes);
@@ -1857,7 +1819,7 @@ void GC_unmap(ptr_t start, word bytes)
}
-void GC_remap(ptr_t start, word bytes)
+void GC_remap(ptr_t start, size_t bytes)
{
ptr_t start_addr = GC_unmap_start(start, bytes);
ptr_t end_addr = GC_unmap_end(start, bytes);
@@ -1892,9 +1854,9 @@ void GC_remap(ptr_t start, word bytes)
result = mprotect(start_addr, len,
PROT_READ | PROT_WRITE | OPT_PROT_EXEC);
if (result != 0) {
- GC_err_printf3(
- "Mprotect failed at 0x%lx (length %ld) with errno %ld\n",
- start_addr, len, errno);
+ GC_err_printf(
+ "Mprotect failed at %p (length %ld) with errno %d\n",
+ start_addr, (unsigned long)len, errno);
ABORT("Mprotect remapping failed");
}
GC_unmapped_bytes -= len;
@@ -1905,7 +1867,7 @@ void GC_remap(ptr_t start, word bytes)
/* be merged. Unmap the whole block. This typically requires */
/* that we unmap a small section in the middle that was not previously */
/* unmapped due to alignment constraints. */
-void GC_unmap_gap(ptr_t start1, word bytes1, ptr_t start2, word bytes2)
+void GC_unmap_gap(ptr_t start1, size_t bytes1, ptr_t start2, size_t bytes2)
{
ptr_t start1_addr = GC_unmap_start(start1, bytes1);
ptr_t end1_addr = GC_unmap_end(start1, bytes1);
@@ -1913,7 +1875,7 @@ void GC_unmap_gap(ptr_t start1, word bytes1, ptr_t start2, word bytes2)
ptr_t end2_addr = GC_unmap_end(start2, bytes2);
ptr_t start_addr = end1_addr;
ptr_t end_addr = start2_addr;
- word len;
+ size_t len;
GC_ASSERT(start1 + bytes1 == start2);
if (0 == start1_addr) start_addr = GC_unmap_start(start1, bytes1 + bytes2);
if (0 == start2_addr) end_addr = GC_unmap_end(start1, bytes1 + bytes2);
@@ -1945,7 +1907,7 @@ void GC_unmap_gap(ptr_t start1, word bytes1, ptr_t start2, word bytes2)
/* environment, this is also responsible for marking from */
/* thread stacks. */
#ifndef THREADS
-void (*GC_push_other_roots)() = 0;
+void (*GC_push_other_roots)(void) = 0;
#else /* THREADS */
# ifdef PCR
@@ -1970,7 +1932,7 @@ PCR_ERes GC_push_old_obj(void *p, size_t size, PCR_Any data)
}
-void GC_default_push_other_roots GC_PROTO((void))
+void GC_default_push_other_roots(void)
{
/* Traverse data allocated by previous memory managers. */
{
@@ -1998,24 +1960,20 @@ void GC_default_push_other_roots GC_PROTO((void))
--> misconfigured
# endif
-void GC_push_thread_structures GC_PROTO((void))
+void GC_push_thread_structures(void)
{
/* Not our responsibibility. */
}
-extern void ThreadF__ProcessStacks();
+extern void ThreadF__ProcessStacks(void);
-void GC_push_thread_stack(start, stop)
-word start, stop;
+void GC_push_thread_stack(word start, word stop)
{
GC_push_all_stack((ptr_t)start, (ptr_t)stop + sizeof(word));
}
/* Push routine with M3 specific calling convention. */
-GC_m3_push_root(dummy1, p, dummy2, dummy3)
-word *p;
-ptr_t dummy1, dummy2;
-int dummy3;
+GC_m3_push_root(ptr_t dummy1, word *p, ptr_t dummy2, int dummy3)
{
word q = *p;
@@ -2026,13 +1984,13 @@ int dummy3;
typedef struct { int elts[1]; } RefTypeSet;
RefTypeSet GC_TracedRefTypes = {{0x1}};
-void GC_default_push_other_roots GC_PROTO((void))
+void GC_default_push_other_roots(void)
{
/* Use the M3 provided routine for finding static roots. */
/* This is a bit dubious, since it presumes no C roots. */
/* We handle the collector roots explicitly in GC_push_roots */
RTMain__GlobalMapProc(GC_m3_push_root, 0, GC_TracedRefTypes);
- if (GC_words_allocd > 0) {
+ if (GC_bytes_allocd > 0) {
ThreadF__ProcessStacks(GC_push_thread_stack);
}
/* Otherwise this isn't absolutely necessary, and we have */
@@ -2044,25 +2002,37 @@ void GC_default_push_other_roots GC_PROTO((void))
# if defined(GC_SOLARIS_THREADS) || defined(GC_PTHREADS) || \
defined(GC_WIN32_THREADS)
-extern void GC_push_all_stacks();
+extern void GC_push_all_stacks(void);
-void GC_default_push_other_roots GC_PROTO((void))
+void GC_default_push_other_roots(void)
{
GC_push_all_stacks();
}
# endif /* GC_SOLARIS_THREADS || GC_PTHREADS */
-void (*GC_push_other_roots) GC_PROTO((void)) = GC_default_push_other_roots;
+void (*GC_push_other_roots)(void) = GC_default_push_other_roots;
#endif /* THREADS */
/*
* Routines for accessing dirty bits on virtual pages.
- * We plan to eventually implement four strategies for doing so:
+ * There are five ways to maintain this information:
* DEFAULT_VDB: A simple dummy implementation that treats every page
* as possibly dirty. This makes incremental collection
* useless, but the implementation is still correct.
+ * MANUAL_VDB: Stacks and static data are always considered dirty.
+ * Heap pages are considered dirty if GC_dirty(p) has been
+ * called on some pointer p pointing to somewhere inside
+ * an object on that page. A GC_dirty() call on a large
+ * object directly dirties only a single page, but for
+ * MANUAL_VDB we are careful to treat an object with a dirty
+ * page as completely dirty.
+ * In order to avoid races, an object must be marked dirty
+ * after it is written, and a reference to the object
+ * must be kept on a stack or in a register in the interim.
+ * In this mode, an object directly reachable from the
+ * stack at the time of a collection is treated as dirty.
* PCR_VDB: Use PPCRs virtual dirty bit facility.
* PROC_VDB: Use the /proc facility for reading dirty bits. Only
* works under some SVR4 variants. Even then, it may be
@@ -2088,17 +2058,16 @@ GC_bool GC_dirty_maintained = FALSE;
/* written. */
/* Initialize virtual dirty bit implementation. */
-void GC_dirty_init()
+void GC_dirty_init(void)
{
-# ifdef PRINTSTATS
- GC_printf0("Initializing DEFAULT_VDB...\n");
-# endif
+ if (GC_print_stats == VERBOSE)
+ GC_log_printf("Initializing DEFAULT_VDB...\n");
GC_dirty_maintained = TRUE;
}
/* Retrieve system dirty bits for heap to a local buffer. */
/* Restore the systems notion of which pages are dirty. */
-void GC_read_dirty()
+void GC_read_dirty(void)
{}
/* Is the HBLKSIZE sized page at h marked dirty in the local buffer? */
@@ -2106,8 +2075,7 @@ void GC_read_dirty()
/* of the pages overlapping h are dirty. This routine may err on the */
/* side of labelling pages as dirty (and this implementation does). */
/*ARGSUSED*/
-GC_bool GC_page_was_dirty(h)
-struct hblk *h;
+GC_bool GC_page_was_dirty(struct hblk *h)
{
return(TRUE);
}
@@ -2121,16 +2089,13 @@ struct hblk *h;
/* Could any valid GC heap pointer ever have been written to this page? */
/*ARGSUSED*/
-GC_bool GC_page_was_ever_dirty(h)
-struct hblk *h;
+GC_bool GC_page_was_ever_dirty(struct hblk *h)
{
return(TRUE);
}
/* Reset the n pages starting at h to "was never dirty" status. */
-void GC_is_fresh(h, n)
-struct hblk *h;
-word n;
+void GC_is_fresh(struct hblk *h, word n)
{
}
@@ -2142,15 +2107,62 @@ word n;
/* pointer-free system call buffers in the heap are */
/* not protected. */
/*ARGSUSED*/
-void GC_remove_protection(h, nblocks, is_ptrfree)
-struct hblk *h;
-word nblocks;
-GC_bool is_ptrfree;
+void GC_remove_protection(struct hblk *h, word nblocks, GC_bool is_ptrfree)
{
}
# endif /* DEFAULT_VDB */
+# ifdef MANUAL_VDB
+
+/* Initialize virtual dirty bit implementation. */
+void GC_dirty_init(void)
+{
+ if (GC_print_stats == VERBOSE)
+ GC_log_printf("Initializing MANUAL_VDB...\n");
+ /* FIXME - implement me. */
+ GC_dirty_maintained = TRUE;
+}
+
+/* Retrieve system dirty bits for heap to a local buffer. */
+/* Restore the systems notion of which pages are dirty. */
+void GC_read_dirty(void)
+{
+ /* FIXME - implement me. */
+}
+
+/* Is the HBLKSIZE sized page at h marked dirty in the local buffer? */
+/* If the actual page size is different, this returns TRUE if any */
+/* of the pages overlapping h are dirty. This routine may err on the */
+/* side of labelling pages as dirty (and this implementation does). */
+/*ARGSUSED*/
+GC_bool GC_page_was_dirty(struct hblk *h)
+{
+ /* FIXME - implement me. */
+ return(TRUE);
+}
+
+
+/* Could any valid GC heap pointer ever have been written to this page? */
+/*ARGSUSED*/
+GC_bool GC_page_was_ever_dirty(struct hblk *h)
+{
+ /* FIXME - implement me. */
+ return(TRUE);
+}
+
+/* Reset the n pages starting at h to "was never dirty" status. */
+void GC_is_fresh(struct hblk *h, word n)
+{
+}
+
+/*ARGSUSED*/
+void GC_remove_protection(struct hblk *h, word nblocks, GC_bool is_ptrfree)
+{
+}
+
+# endif /* MANUAL_VDB */
+
# ifdef MPROTECT_VDB
@@ -2168,7 +2180,6 @@ GC_bool is_ptrfree;
* heap, and do even that only if we are on a platform on which those
* are not protected. Another alternative is to wrap system calls
* (see example for read below), but the current implementation holds
- * a lock across blocking calls, making it problematic for multithreaded
* applications.
* We assume the page size is a multiple of HBLKSIZE.
* We prefer them to be the same. We avoid protecting POINTERFREE
@@ -2220,7 +2231,7 @@ GC_bool is_ptrfree;
if (!VirtualProtect((addr), (len), PAGE_EXECUTE_READ, \
&protect_junk)) { \
DWORD last_error = GetLastError(); \
- GC_printf1("Last error code: %lx\n", last_error); \
+ GC_printf("Last error code: %lx\n", last_error); \
ABORT("VirtualProtect failed"); \
}
# define UNPROTECT(addr, len) \
@@ -2231,88 +2242,33 @@ GC_bool is_ptrfree;
# endif /* !DARWIN */
# endif /* MSWIN32 || MSWINCE || DARWIN */
-#if defined(SUNOS4) || (defined(FREEBSD) && !defined(SUNOS5SIGS))
- typedef void (* SIG_PF)();
-#endif /* SUNOS4 || (FREEBSD && !SUNOS5SIGS) */
-
-#if defined(SUNOS5SIGS) || defined(OSF1) || defined(LINUX) \
- || defined(HURD)
-# ifdef __STDC__
- typedef void (* SIG_PF)(int);
-# else
- typedef void (* SIG_PF)();
-# endif
-#endif /* SUNOS5SIGS || OSF1 || LINUX || HURD */
-
#if defined(MSWIN32)
- typedef LPTOP_LEVEL_EXCEPTION_FILTER SIG_PF;
+ typedef LPTOP_LEVEL_EXCEPTION_FILTER SIG_HNDLR_PTR;
# undef SIG_DFL
# define SIG_DFL (LPTOP_LEVEL_EXCEPTION_FILTER) (-1)
-#endif
-#if defined(MSWINCE)
- typedef LONG (WINAPI *SIG_PF)(struct _EXCEPTION_POINTERS *);
+#elif defined(MSWINCE)
+ typedef LONG (WINAPI *SIG_HNDLR_PTR)(struct _EXCEPTION_POINTERS *);
# undef SIG_DFL
-# define SIG_DFL (SIG_PF) (-1)
+# define SIG_DFL (SIG_HNDLR_PTR) (-1)
+#elif defined(DARWIN)
+ typedef void (* SIG_HNDLR_PTR)();
+#else
+ typedef void (* SIG_HNDLR_PTR)(int, siginfo_t *, void *);
+ typedef void (* PLAIN_HNDLR_PTR)(int);
#endif
-#if defined(IRIX5) || defined(OSF1) || defined(HURD)
- typedef void (* REAL_SIG_PF)(int, int, struct sigcontext *);
-#endif /* IRIX5 || OSF1 || HURD */
-
-#if defined(SUNOS5SIGS)
-# if defined(HPUX) || defined(FREEBSD)
-# define SIGINFO_T siginfo_t
-# else
-# define SIGINFO_T struct siginfo
-# endif
-# ifdef __STDC__
- typedef void (* REAL_SIG_PF)(int, SIGINFO_T *, void *);
-# else
- typedef void (* REAL_SIG_PF)();
-# endif
-#endif /* SUNOS5SIGS */
-
-#if defined(LINUX)
-# if __GLIBC__ > 2 || __GLIBC__ == 2 && __GLIBC_MINOR__ >= 2
- typedef struct sigcontext s_c;
-# else /* glibc < 2.2 */
-# include <linux/version.h>
-# if (LINUX_VERSION_CODE >= 0x20100) && !defined(M68K) || defined(ALPHA) || defined(ARM32)
- typedef struct sigcontext s_c;
-# else
- typedef struct sigcontext_struct s_c;
-# endif
-# endif /* glibc < 2.2 */
-# if defined(ALPHA) || defined(M68K)
- typedef void (* REAL_SIG_PF)(int, int, s_c *);
-# else
-# if defined(IA64) || defined(HP_PA) || defined(X86_64)
- typedef void (* REAL_SIG_PF)(int, siginfo_t *, s_c *);
- /* FIXME: */
- /* According to SUSV3, the last argument should have type */
- /* void * or ucontext_t * */
-# else
- typedef void (* REAL_SIG_PF)(int, s_c);
-# endif
+#if defined(__GLIBC__)
+# if __GLIBC__ < 2 || __GLIBC__ == 2 && __GLIBC_MINOR__ < 2
+# error glibc too old?
# endif
-# ifdef ALPHA
- /* Retrieve fault address from sigcontext structure by decoding */
- /* instruction. */
- char * get_fault_addr(s_c *sc) {
- unsigned instr;
- word faultaddr;
-
- instr = *((unsigned *)(sc->sc_pc));
- faultaddr = sc->sc_regs[(instr >> 16) & 0x1f];
- faultaddr += (word) (((int)instr << 16) >> 16);
- return (char *)faultaddr;
- }
-# endif /* !ALPHA */
-# endif /* LINUX */
+#endif
#ifndef DARWIN
-SIG_PF GC_old_bus_handler;
-SIG_PF GC_old_segv_handler; /* Also old MSWIN32 ACCESS_VIOLATION filter */
+SIG_HNDLR_PTR GC_old_bus_handler;
+GC_bool GC_old_bus_handler_used_si;
+SIG_HNDLR_PTR GC_old_segv_handler;
+ /* Also old MSWIN32 ACCESS_VIOLATION filter */
+GC_bool GC_old_segv_handler_used_si;
#endif /* !DARWIN */
#if defined(THREADS)
@@ -2323,16 +2279,17 @@ SIG_PF GC_old_segv_handler; /* Also old MSWIN32 ACCESS_VIOLATION filter */
/* safe fallback algorithm of setting all bits in the word. */
/* Contention should be very rare, so we do the minimum to handle it */
/* correctly. */
-#ifdef GC_TEST_AND_SET_DEFINED
- static VOLATILE unsigned int fault_handler_lock = 0;
- void async_set_pht_entry_from_index(VOLATILE page_hash_table db, int index) {
- while (GC_test_and_set(&fault_handler_lock)) {}
+#ifdef AO_HAVE_test_and_set_acquire
+ static volatile AO_TS_t fault_handler_lock = 0;
+ void async_set_pht_entry_from_index(volatile page_hash_table db, int index) {
+ while (AO_test_and_set_acquire(&fault_handler_lock) == AO_TS_SET) {}
/* Could also revert to set_pht_entry_from_index_safe if initial */
/* GC_test_and_set fails. */
set_pht_entry_from_index(db, index);
- GC_clear(&fault_handler_lock);
+ AO_CLEAR(&fault_handler_lock);
}
-#else /* !GC_TEST_AND_SET_DEFINED */
+#else /* !AO_have_test_and_set_acquire */
+# error No test-and_set operation: Introduces a race.
/* THIS IS INCORRECT! The dirty bit vector may be temporarily wrong, */
/* just before we notice the conflict and correct it. We may end up */
/* looking at it while it's wrong. But this requires contention */
@@ -2340,8 +2297,8 @@ SIG_PF GC_old_segv_handler; /* Also old MSWIN32 ACCESS_VIOLATION filter */
/* fail than the old code, which had no reported failures. Thus we */
/* leave it this way while we think of something better, or support */
/* GC_test_and_set on the remaining platforms. */
- static VOLATILE word currently_updating = 0;
- void async_set_pht_entry_from_index(VOLATILE page_hash_table db, int index) {
+ static volatile word currently_updating = 0;
+ void async_set_pht_entry_from_index(volatile page_hash_table db, int index) {
unsigned int update_dummy;
currently_updating = (word)(&update_dummy);
set_pht_entry_from_index(db, index);
@@ -2357,182 +2314,72 @@ SIG_PF GC_old_segv_handler; /* Also old MSWIN32 ACCESS_VIOLATION filter */
/* returning us to a safe state, though not soon enough. */
}
}
-#endif /* !GC_TEST_AND_SET_DEFINED */
+#endif /* !AO_HAVE_test_and_set_acquire */
#else /* !THREADS */
# define async_set_pht_entry_from_index(db, index) \
set_pht_entry_from_index(db, index)
#endif /* !THREADS */
-/*ARGSUSED*/
#if !defined(DARWIN)
-# if defined (SUNOS4) || (defined(FREEBSD) && !defined(SUNOS5SIGS))
- void GC_write_fault_handler(sig, code, scp, addr)
- int sig, code;
- struct sigcontext *scp;
- char * addr;
-# ifdef SUNOS4
-# define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
-# define CODE_OK (FC_CODE(code) == FC_PROT \
- || (FC_CODE(code) == FC_OBJERR \
- && FC_ERRNO(code) == FC_PROT))
-# endif
-# ifdef FREEBSD
-# define SIG_OK (sig == SIGBUS)
-# define CODE_OK TRUE
-# endif
-# endif /* SUNOS4 || (FREEBSD && !SUNOS5SIGS) */
-
-# if defined(IRIX5) || defined(OSF1) || defined(HURD)
# include <errno.h>
- void GC_write_fault_handler(int sig, int code, struct sigcontext *scp)
-# ifdef OSF1
+# if defined(FREEBSD)
+# define SIG_OK (sig == SIGBUS)
+# define CODE_OK (code == BUS_PAGE_FAULT)
+# elif defined(OSF1)
# define SIG_OK (sig == SIGSEGV)
# define CODE_OK (code == 2 /* experimentally determined */)
-# endif
-# ifdef IRIX5
+# elif defined(IRIX5)
# define SIG_OK (sig == SIGSEGV)
# define CODE_OK (code == EACCES)
-# endif
-# ifdef HURD
+# elif defined(HURD)
# define SIG_OK (sig == SIGBUS || sig == SIGSEGV)
# define CODE_OK TRUE
-# endif
-# endif /* IRIX5 || OSF1 || HURD */
-
-# if defined(LINUX)
-# if defined(ALPHA) || defined(M68K)
- void GC_write_fault_handler(int sig, int code, s_c * sc)
-# else
-# if defined(IA64) || defined(HP_PA) || defined(X86_64)
- void GC_write_fault_handler(int sig, siginfo_t * si, s_c * scp)
-# else
-# if defined(ARM32)
- void GC_write_fault_handler(int sig, int a2, int a3, int a4, s_c sc)
-# else
- void GC_write_fault_handler(int sig, s_c sc)
-# endif
-# endif
-# endif
-# define SIG_OK (sig == SIGSEGV)
-# define CODE_OK TRUE
+# elif defined(LINUX)
+# define SIG_OK (sig == SIGSEGV)
+# define CODE_OK TRUE
/* Empirically c.trapno == 14, on IA32, but is that useful? */
/* Should probably consider alignment issues on other */
/* architectures. */
-# endif /* LINUX */
-
-# if defined(SUNOS5SIGS)
-# ifdef __STDC__
- void GC_write_fault_handler(int sig, SIGINFO_T *scp, void * context)
-# else
- void GC_write_fault_handler(sig, scp, context)
- int sig;
- SIGINFO_T *scp;
- void * context;
-# endif
-# ifdef HPUX
+# elif defined(HPUX)
# define SIG_OK (sig == SIGSEGV || sig == SIGBUS)
# define CODE_OK (scp -> si_code == SEGV_ACCERR) \
|| (scp -> si_code == BUS_ADRERR) \
|| (scp -> si_code == BUS_UNKNOWN) \
|| (scp -> si_code == SEGV_UNKNOWN) \
|| (scp -> si_code == BUS_OBJERR)
-# else
-# ifdef FREEBSD
-# define SIG_OK (sig == SIGBUS)
-# define CODE_OK (scp -> si_code == BUS_PAGE_FAULT)
-# else
-# define SIG_OK (sig == SIGSEGV)
-# define CODE_OK (scp -> si_code == SEGV_ACCERR)
-# endif
+# elif defined(FREEBSD)
+# define SIG_OK (sig == SIGBUS)
+# define CODE_OK (scp -> si_code == BUS_PAGE_FAULT)
+# elif defined(SUNOS5SIGS)
+# define SIG_OK (sig == SIGSEGV)
+# define CODE_OK (scp -> si_code == SEGV_ACCERR)
+# elif defined(MSWIN32) || defined(MSWINCE)
+# define SIG_OK (exc_info -> ExceptionRecord -> ExceptionCode \
+ == STATUS_ACCESS_VIOLATION)
+# define CODE_OK (exc_info -> ExceptionRecord -> ExceptionInformation[0] \
+ == 1) /* Write fault */
# endif
-# endif /* SUNOS5SIGS */
# if defined(MSWIN32) || defined(MSWINCE)
LONG WINAPI GC_write_fault_handler(struct _EXCEPTION_POINTERS *exc_info)
-# define SIG_OK (exc_info -> ExceptionRecord -> ExceptionCode == \
- STATUS_ACCESS_VIOLATION)
-# define CODE_OK (exc_info -> ExceptionRecord -> ExceptionInformation[0] == 1)
- /* Write fault */
+# else
+# include <ucontext.h>
+ /*ARGSUSED*/
+ void GC_write_fault_handler(int sig, siginfo_t *si, void *raw_sc)
# endif /* MSWIN32 || MSWINCE */
{
- register unsigned i;
-# if defined(HURD)
- char *addr = (char *) code;
-# endif
-# ifdef IRIX5
- char * addr = (char *) (size_t) (scp -> sc_badvaddr);
-# endif
-# if defined(OSF1) && defined(ALPHA)
- char * addr = (char *) (scp -> sc_traparg_a0);
-# endif
-# ifdef SUNOS5SIGS
- char * addr = (char *) (scp -> si_addr);
-# endif
-# ifdef LINUX
-# if defined(I386)
- char * addr = (char *) (sc.cr2);
-# else
-# if defined(M68K)
- char * addr = NULL;
-
- struct sigcontext *scp = (struct sigcontext *)(sc);
-
- int format = (scp->sc_formatvec >> 12) & 0xf;
- unsigned long *framedata = (unsigned long *)(scp + 1);
- unsigned long ea;
-
- if (format == 0xa || format == 0xb) {
- /* 68020/030 */
- ea = framedata[2];
- } else if (format == 7) {
- /* 68040 */
- ea = framedata[3];
- if (framedata[1] & 0x08000000) {
- /* correct addr on misaligned access */
- ea = (ea+4095)&(~4095);
- }
- } else if (format == 4) {
- /* 68060 */
- ea = framedata[0];
- if (framedata[1] & 0x08000000) {
- /* correct addr on misaligned access */
- ea = (ea+4095)&(~4095);
- }
- }
- addr = (char *)ea;
-# else
-# ifdef ALPHA
- char * addr = get_fault_addr(sc);
-# else
-# if defined(IA64) || defined(HP_PA) || defined(X86_64)
- char * addr = si -> si_addr;
- /* I believe this is claimed to work on all platforms for */
- /* Linux 2.3.47 and later. Hopefully we don't have to */
- /* worry about earlier kernels on IA64. */
-# else
-# if defined(POWERPC)
- char * addr = (char *) (sc.regs->dar);
-# else
-# if defined(ARM32)
- char * addr = (char *)sc.fault_address;
-# else
-# if defined(CRIS)
- char * addr = (char *)sc.regs.csraddr;
-# else
- --> architecture not supported
-# endif
-# endif
-# endif
-# endif
-# endif
-# endif
-# endif
+# if !defined(MSWIN32) && !defined(MSWINCE)
+ int code = si -> si_code; /* Ignore gcc unused var. warning. */
+ ucontext_t * scp = (ucontext_t *)raw_sc;
+ /* Ignore gcc unused var. warning. */
+ char *addr = si -> si_addr;
# endif
# if defined(MSWIN32) || defined(MSWINCE)
char * addr = (char *) (exc_info -> ExceptionRecord
-> ExceptionInformation[1]);
# define sig SIGSEGV
# endif
+ unsigned i;
if (SIG_OK && CODE_OK) {
register struct hblk * h =
@@ -2556,53 +2403,38 @@ SIG_PF GC_old_segv_handler; /* Also old MSWIN32 ACCESS_VIOLATION filter */
/* sequence, which often depends on SA_SIGINFO. */
/* Heap blocks now begin and end on page boundaries */
- SIG_PF old_handler;
+ SIG_HNDLR_PTR old_handler;
+ GC_bool used_si;
if (sig == SIGSEGV) {
old_handler = GC_old_segv_handler;
+ used_si = GC_old_segv_handler_used_si;
} else {
old_handler = GC_old_bus_handler;
+ used_si = GC_old_bus_handler_used_si;
}
- if (old_handler == SIG_DFL) {
+ if (old_handler == (SIG_HNDLR_PTR)SIG_DFL) {
# if !defined(MSWIN32) && !defined(MSWINCE)