diff options
Diffstat (limited to '')
| -rw-r--r-- | gc/doc/README.changes | 1408 |
1 files changed, 1408 insertions, 0 deletions
diff --git a/gc/doc/README.changes b/gc/doc/README.changes new file mode 100644 index 0000000..c018c8b --- /dev/null +++ b/gc/doc/README.changes @@ -0,0 +1,1408 @@ +This is a rough history of garbage collector bugs and versions. + +This has been maintained with varying diligence over the years. + +I made an attempt to include recent contributors here. I apologize for any +omissions. + +------------------------- + + Version 1.3 and immediately preceding versions contained spurious +assembly language assignments to TMP_SP. Only the assignment in the PC/RT +code is necessary. On other machines, with certain compiler options, +the assignments can lead to an unsaved register being overwritten. +Known to cause problems under SunOS 3.5 WITHOUT the -O option. (With +-O the compiler recognizes it as dead code. It probably shouldn't, +but that's another story.) + + Version 1.4 and earlier versions used compile time determined values +for the stack base. This no longer works on Sun 3s, since Sun 3/80s use +a different stack base. We now use a straightforward heuristic on all +machines on which it is known to work (incl. Sun 3s) and compile-time +determined values for the rest. There should really be library calls +to determine such values. + + Version 1.5 and earlier did not ensure 8 byte alignment for objects +allocated on a sparc based machine. + + Version 1.8 added ULTRIX support in gc_private.h. + + Version 1.9 fixed a major bug in gc_realloc. + + Version 2.0 introduced a consistent naming convention for collector +routines and added support for registering dynamic library data segments +in the standard mark_roots.c. Most of the data structures were revamped. +The treatment of interior pointers was completely changed. Finalization +was added. Support for locking was added. Object kinds were added. +We added a black listing facility to avoid allocating at addresses known +to occur as integers somewhere in the address space. Much of this +was accomplished by adapting ideas and code from the PCR collector. +The test program was changed and expanded. + + Version 2.1 was the first stable version since 1.9, and added support +for PPCR. + + Version 2.2 added debugging allocation, and fixed various bugs. Among them: +- GC_realloc could fail to extend the size of the object for certain large object sizes. +- A blatant subscript range error in GC_printf, which unfortunately + wasn't exercised on machines with sufficient stack alignment constraints. +- GC_register_displacement did the wrong thing if it was called after + any allocation had taken place. +- The leak finding code would eventually break after 2048 byte + byte objects leaked. +- interface.c didn't compile. +- The heap size remained much too small for large stacks. +- The stack clearing code behaved badly for large stacks, and perhaps + on HP/PA machines. + + Version 2.3 added ALL_INTERIOR_POINTERS and fixed the following bugs: +- Missing declaration of etext in the A/UX version. +- Some PCR root-finding problems. +- Blacklisting was not 100% effective, because the plausible future + heap bounds were being miscalculated. +- GC_realloc didn't handle out-of-memory correctly. +- GC_base could return a nonzero value for addresses inside free blocks. +- test.c wasn't really thread safe, and could erroneously report failure + in a multithreaded environment. (The locking primitives need to be + replaced for other threads packages.) +- GC_CONS was thoroughly broken. +- On a SPARC with dynamic linking, signals stayed diabled while the + client code was running. + (Thanks to Manuel Serrano at INRIA for reporting the last two.) + + Version 2.4 added GC_free_space_divisor as a tuning knob, added + support for OS/2 and linux, and fixed the following bugs: +- On machines with unaligned pointers (e.g. Sun 3), every 128th word could + fail to be considered for marking. +- Dynamic_load.c erroneously added 4 bytes to the length of the data and + bss sections of the dynamic library. This could result in a bad memory + reference if the actual length was a multiple of a page. (Observed on + Sun 3. Can probably also happen on a Sun 4.) + (Thanks to Robert Brazile for pointing out that the Sun 3 version + was broken. Dynamic library handling is still broken on Sun 3s + under 4.1.1U1, but apparently not 4.1.1. If you have such a machine, + use -Bstatic.) + + Version 2.5 fixed the following bugs: +- Removed an explicit call to exit(1) +- Fixed calls to GC_printf and GC_err_printf, so the correct number of + arguments are always supplied. The OS/2 C compiler gets confused if + the number of actuals and the number of formals differ. (ANSI C + doesn't require this to work. The ANSI sanctioned way of doing things + causes too many compatibility problems.) + + Version 3.0 added generational/incremental collection and stubborn + objects. + + Version 3.1 added the following features: +- A workaround for a SunOS 4.X SPARC C compiler + misfeature that caused problems when the collector was turned into + a dynamic library. +- A fix for a bug in GC_base that could result in a memory fault. +- A fix for a performance bug (and several other misfeatures) pointed + out by Dave Detlefs and Al Dosser. +- Use of dirty bit information for static data under Solaris 2.X. +- DEC Alpha/OSF1 support (thanks to Al Dosser). +- Incremental collection on more platforms. +- A more refined heap expansion policy. Less space usage by default. +- Various minor enhancements to reduce space usage, and to reduce + the amount of memory scanned by the collector. +- Uncollectable allocation without per object overhead. +- More conscientious handling of out-of-memory conditions. +- Fixed a bug in debugging stubborn allocation. +- Fixed a bug that resulted in occasional erroneous reporting of smashed + objects with debugging allocation. +- Fixed bogus leak reports of size 4096 blocks with FIND_LEAK. + + Version 3.2 fixed a serious and not entirely repeatable bug in + the incremental collector. It appeared only when dirty bit info + on the roots was available, which is normally only under Solaris. + It also added GC_general_register_disappearing_link, and some + testing code. Interface.c disappeared. + + Version 3.3 fixes several bugs and adds new ports: +- PCR-specific bugs. +- Missing locking in GC_free, redundant FASTUNLOCK + in GC_malloc_stubborn, and 2 bugs in + GC_unregister_disappearing_link. + All of the above were pointed out by Neil Sharman + (neil@cs.mu.oz.au). +- Common symbols allocated by the SunOS4.X dynamic loader + were not included in the root set. +- Bug in GC_finalize (reported by Brian Beuning and Al Dosser) +- Merged Amiga port from Jesper Peterson (untested) +- Merged NeXT port from Thomas Funke (significantly + modified and untested) + + Version 3.4: +- Fixed a performance bug in GC_realloc. +- Updated the amiga port. +- Added NetBSD and 386BSD ports. +- Added cord library. +- Added trivial performance enhancement for + ALL_INTERIOR_POINTERS. (Don't scan last word.) + + Version 3.5 +- Minor collections now mark from roots only once, if that + doesn't cause an excessive pause. +- The stack clearing heuristic was refined to prevent anomalies + with very heavily recursive programs and sparse stacks. +- Fixed a bug that prevented mark stack growth in some cases. + GC_objects_are_marked should be set to TRUE after a call + to GC_push_roots and as part of GC_push_marked, since + both can now set mark bits. I think this is only a performance + bug, but I wouldn't bet on it. It's certainly very hard to argue + that the old version was correct. +- Fixed an incremental collection bug that prevented it from + working at all when HBLKSIZE != getpagesize() +- Changed dynamic_loading.c to include gc_priv.h before testing + DYNAMIC_LOADING. SunOS dynamic library scanning + must have been broken in 3.4. +- Object size rounding now adapts to program behavior. +- Added a workaround (provided by Manuel Serrano and + colleagues) to a long-standing SunOS 4.X (and 3.X?) ld bug + that I had incorrectly assumed to have been squished. + The collector was broken if the text segment size was within + 32 bytes of a multiple of 8K bytes, and if the beginning of + the data segment contained interesting roots. The workaround + assumes a demand-loadable executable. The original may have + have "worked" in some other cases. +- Added dynamic library support under IRIX5. +- Added support for EMX under OS/2 (thanks to Ari Huttunen). + +Version 3.6: +- fixed a bug in the mark stack growth code that was introduced + in 3.4. +- fixed Makefile to work around DEC AXP compiler tail recursion + bug. + +Version 3.7: +- Added a workaround for an HP/UX compiler bug. +- Fixed another stack clearing performance bug. Reworked + that code once more. + +Version 4.0: +- Added support for Solaris threads (which was possible + only by reimplementing some fraction of Solaris threads, + since Sun doesn't currently make the thread debugging + interface available). +- Added non-threads win32 and win32S support. +- (Grudgingly, with suitable muttering of obscenities) renamed + files so that the collector distribution could live on a FAT + file system. Files that are guaranteed to be useless on + a PC still have long names. Gc_inline.h and gc_private.h + still exist, but now just include gc_inl.h and gc_priv.h. +- Fixed a really obscure bug in finalization that could cause + undetected mark stack overflows. (I would be surprised if + any real code ever tickled this one.) +- Changed finalization code to dynamically resize the hash + tables it maintains. (This probably does not matter for well- + -written code. It no doubt does for C++ code that overuses + destructors.) +- Added typed allocation primitives. Rewrote the marker to + accommodate them with more reasonable efficiency. This + change should also speed up marking for GC_malloc allocated + objects a little. See gc_typed.h for new primitives. +- Improved debugging facilities slightly. Allocation time + stack traces are now kept by default on SPARC/SUNOS4. + (Thanks to Scott Schwartz.) +- Added better support for small heap applications. +- Significantly extended cord package. Fixed a bug in the + implementation of lazily read files. Printf and friends now + have cord variants. Cord traversals are a bit faster. +- Made ALL_INTERIOR_POINTERS recognition the default. +- Fixed de so that it can run in constant space, independent + of file size. Added simple string searching to cords and de. +- Added the Hull-Ellis C++ interface. +- Added dynamic library support for OSF/1. + (Thanks to Al Dosser and Tim Bingham at DEC.) +- Changed argument to GC_expand_hp to be expressed + in units of bytes instead of heap blocks. (Necessary + since the heap block size now varies depending on + configuration. The old version was never very clean.) +- Added GC_get_heap_size(). The previous "equivalent" + was broken. +- Restructured the Makefile a bit. + +Since version 4.0: +- Changed finalization implementation to guarantee that + finalization procedures are called outside of the allocation + lock, making direct use of the interface a little less dangerous. + MAY BREAK EXISTING CLIENTS that assume finalizers + are protected by a lock. Since there seem to be few multithreaded + clients that use finalization, this is hopefully not much of + a problem. +- Fixed a gross bug in CORD_prev. +- Fixed a bug in blacklst.c that could result in unbounded + heap growth during startup on machines that do not clear + memory obtained from the OS (e.g. win32S). +- Ported de editor to win32/win32S. (This is now the only + version with a mouse-sensitive UI.) +- Added GC_malloc_ignore_off_page to allocate large arrays + in the presence of ALL_INTERIOR_POINTERS. +- Changed GC_call_with_alloc_lock to not disable signals in + the single-threaded case. +- Reduced retry count in GC_collect_or_expand for garbage + collecting when out of memory. +- Made uncollectable allocations bypass black-listing, as they + should. +- Fixed a bug in typed_test in test.c that could cause (legitimate) + GC crashes. +- Fixed some potential synchronization problems in finalize.c +- Fixed a real locking problem in typd_mlc.c. +- Worked around an AIX 3.2 compiler feature that results in + out of bounds memory references. +- Partially worked around an IRIX5.2 beta problem (which may + or may not persist to the final release). +- Fixed a bug in the heap integrity checking code that could + result in explicitly deallocated objects being identified as + smashed. Fixed a bug in the dbg_mlc stack saving code + that caused old argument pointers to be considered live. +- Fixed a bug in CORD_ncmp (and hence CORD_str). +- Repaired the OS2 port, which had suffered from bit rot + in 4.0. Worked around what appears to be CSet/2 V1.0 + optimizer bug. +- Fixed a Makefile bug for target "c++". + +Since version 4.1: +- Multiple bug fixes/workarounds in the Solaris threads version. + (It occasionally failed to locate some register contents for + marking. It also turns out that thr_suspend and friends are + unreliable in Solaris 2.3. Dirty bit reads appear + to be unreliable under some weird + circumstances. My stack marking code + contained a serious performance bug. The new code is + extremely defensive, and has not failed in several cpu + hours of testing. But no guarantees ...) +- Added MacOS support (thanks to Patrick Beard.) +- Fixed several syntactic bugs in gc_c++.h and friends. (These + didn't bother g++, but did bother most other compilers.) + Fixed gc_c++.h finalization interface. (It didn't.) +- 64 bit alignment for allocated objects was not guaranteed in a + few cases in which it should have been. +- Added GC_malloc_atomic_ignore_off_page. +- Added GC_collect_a_little. +- Added some prototypes to gc.h. +- Some other minor bug fixes (notably in Makefile). +- Fixed OS/2 / EMX port (thanks to Ari Huttunen). +- Fixed AmigaDOS port. (thanks to Michel Schinz). +- Fixed the DATASTART definition under Solaris. There + was a 1 in 16K chance of the collector missing the first + 64K of static data (and thus crashing). +- Fixed some blatant anachronisms in the README file. +- Fixed PCR-Makefile for upcoming PPCR release. + +Since version 4.2: +- Fixed SPARC alignment problem with GC_DEBUG. +- Fixed Solaris threads /proc workaround. The real + problem was an interaction with mprotect. +- Incorporated fix from Patrick Beard for gc_c++.h (now gc_cpp.h). +- Slightly improved allocator space utilization by + fixing the GC_size_map mechanism. +- Integrated some Sony News and MIPS RISCos 4.51 + patches. (Thanks to Nobuyuki Hikichi of + Software Research Associates, Inc. Japan) +- Fixed HP_PA alignment problem. (Thanks to + xjam@cork.cs.berkeley.edu.) +- Added GC_same_obj and friends. Changed GC_base + to return 0 for pointers past the end of large objects. + Improved GC_base performance with ALL_INTERIOR_POINTERS + on machines with a slow integer mod operation. + Added GC_PTR_ADD, GC_PTR_STORE, etc. to prepare + for preprocessor. +- changed the default on most UNIX machines to be that + signals are not disabled during critical GC operations. + This is still ANSI-conforming, though somewhat dangerous + in the presence of signal handlers. But the performance + cost of the alternative is sometimes problematic. + Can be changed back with a minor Makefile edit. +- renamed IS_STRING in gc.h, to CORD_IS_STRING, thus + following my own naming convention. Added the function + CORD_to_const_char_star. +- Fixed a gross bug in GC_finalize. Symptom: occasional + address faults in that function. (Thanks to Anselm + Baird-Smith (Anselm.BairdSmith@inria.fr) +- Added port to ICL DRS6000 running DRS/NX. Restructured + things a bit to factor out common code, and remove obsolete + code. Collector should now run under SUNOS5 with either + mprotect or /proc dirty bits. (Thanks to Douglas Steel + (doug@wg.icl.co.uk)). +- More bug fixes and workarounds for Solaris 2.X. (These were + mostly related to putting the collector in a dynamic library, + which didn't really work before. Also SOLARIS_THREADS + didn't interact well with dl_open.) Thanks to btlewis@eng.sun.com. +- Fixed a serious performance bug on the DEC Alpha. The text + segment was getting registered as part of the root set. + (Amazingly, the result was still fast enough that the bug + was not conspicuous.) The fix works on OSF/1, version 1.3. + Hopefully it also works on other versions of OSF/1 ... +- Fixed a bug in GC_clear_roots. +- Fixed a bug in GC_generic_malloc_words_small that broke + gc_inl.h. (Reported by Antoine de Maricourt. I broke it + in trying to tweak the Mac port.) +- Fixed some problems with cord/de under Linux. +- Fixed some cord problems, notably with CORD_riter4. +- Added DG/UX port. + Thanks to Ben A. Mesander (ben@piglet.cr.usgs.gov) +- Added finalization registration routines with weaker ordering + constraints. (This is necessary for C++ finalization with + multiple inheritance, since the compiler often adds self-cycles.) +- Filled the holes in the SCO port. (Thanks to Michael Arnoldus + <chime@proinf.dk>.) +- John Ellis' additions to the C++ support: From John: + +* I completely rewrote the documentation in the interface gc_c++.h +(later renamed gc_cpp.h). I've tried to make it both clearer and more +precise. + +* The definition of accessibility now ignores pointers from an +finalizable object (an object with a clean-up function) to itself. +This allows objects with virtual base classes to be finalizable by the +collector. Compilers typically implement virtual base classes using +pointers from an object to itself, which under the old definition of +accessibility prevented objects with virtual base classes from ever +being collected or finalized. + +* gc_cleanup now includes gc as a virtual base. This was enabled by +the change in the definition of accessibility. + +* I added support for operator new[]. Since most (all?) compilers +don't yet support operator new[], it is conditionalized on +-DOPERATOR_NEW_ARRAY. The code is untested, but its trivial and looks +correct. + +* The test program test_gc_c++ (later renamed test_cpp.cc) +tries to test for the C++-specific functionality not tested by the +other programs. +- Added <unistd.h> include to misc.c. (Needed for ppcr.) +- Added PowerMac port. (Thanks to Patrick Beard again.) +- Fixed "srcdir"-related Makefile problems. Changed things so + that all externally visible include files always appear in the + include subdirectory of the source. Made gc.h directly + includable from C++ code. (These were at Per + Bothner's suggestion.) +- Changed Intel code to also mark from ebp (Kevin Warne's + suggestion). +- Renamed C++ related files so they could live in a FAT + file system. (Charles Fiterman's suggestion.) +- Changed Windows NT Makefile to include C++ support in + gc.lib. Added C++ test as Makefile target. + +Since version 4.3: + - ASM_CLEAR_CODE was erroneously defined for HP + PA machines, resulting in a compile error. + - Fixed OS/2 Makefile to create a library. (Thanks to + Mark Boulter (mboulter@vnet.ibm.com)). + - Gc_cleanup objects didn't work if they were created on + the stack. Fixed. + - One copy of Gc_cpp.h in the distribution was out of + synch, and failed to document some known compiler + problems with explicit destructor invocation. Partially + fixed. There are probably other compilers on which + gc_cleanup is miscompiled. + - Fixed Makefile to pass C compiler flags to C++ compiler. + - Added Mac fixes. + - Fixed os_dep.c to work around what appears to be + a new and different VirtualQuery bug under newer + versions of win32S. + - GC_non_gc_bytes was not correctly maintained by + GC_free. Fixed. Thanks to James Clark (jjc@jclark.com). + - Added GC_set_max_heap_size. + - Changed allocation code to ignore blacklisting if it is preventing + use of a very large block of memory. This has the advantage + that naive code allocating very large objects is much more + likely to work. The downside is you might no + longer find out that such code should really use + GC_malloc_ignore_off_page. + - Changed GC_printf under win32 to close and reopen the file + between calls. FAT file systems otherwise make the log file + useless for debugging. + - Added GC_try_to_collect and GC_get_bytes_since_gc. These + allow starting an abortable collection during idle times. + This facility does not require special OS support. (Thanks to + Michael Spertus of Geodesic Systems for suggesting this. It was + actually an easy addition. Kumar Srikantan previously added a similar + facility to a now ancient version of the collector. At the time + this was much harder, and the result was less convincing.) + - Added some support for the Borland development environment. (Thanks + to John Ellis and Michael Spertus.) + - Removed a misfeature from checksums.c that caused unexpected + heap growth. (Thanks to Scott Schwartz.) + - Changed finalize.c to call WARN if it encounters a finalization cycle. + WARN is defined in gc_priv.h to write a message, usually to stdout. + In many environments, this may be inappropriate. + - Renamed NO_PARAMS in gc.h to GC_NO_PARAMS, thus adhering to my own + naming convention. + - Added GC_set_warn_proc to intercept warnings. + - Fixed Amiga port. (Thanks to Michel Schinz (schinz@alphanet.ch).) + - Fixed a bug in mark.c that could result in an access to unmapped + memory from GC_mark_from_mark_stack on machines with unaligned + pointers. + - Fixed a win32 specific performance bug that could result in scanning of + objects allocated with the system malloc. + - Added REDIRECT_MALLOC. + +Since version 4.4: + - Fixed many minor and one major README bugs. (Thanks to Franklin Chen + (chen@adi.com) for pointing out many of them.) + - Fixed ALPHA/OSF/1 dynamic library support. (Thanks to Jonathan Bachrach + (jonathan@harlequin.com)). + - Added incremental GC support (MPROTECT_VDB) for Linux (with some + help from Bruno Haible). + - Altered SPARC recognition tests in gc.h and config.h (mostly as + suggested by Fergus Henderson). + - Added basic incremental GC support for win32, as implemented by + Windows NT and Windows 95. GC_enable_incremental is a noop + under win32s, which doesn't implement enough of the VM interface. + - Added -DLARGE_CONFIG. + - Fixed GC_..._ignore_off_page to also function without + -DALL_INTERIOR_POINTERS. + - (Hopefully) fixed RS/6000 port. (Only the test was broken.) + - Fixed a performance bug in the nonincremental collector running + on machines supporting incremental collection with MPROTECT_VDB + (e.g. SunOS 4, DEC AXP). This turned into a correctness bug under + win32s with win32 incremental collection. (Not all memory protection + was disabled.) + - Fixed some ppcr related bit rot. + - Caused dynamic libraries to be unregistered before reregistering. + The old way turned out to be a performance bug on some machines. + - GC_root_size was not properly maintained under MSWIN32. + - Added -DNO_DEBUGGING and GC_dump. + - Fixed a couple of bugs arising with SOLARIS_THREADS + + REDIRECT_MALLOC. + - Added NetBSD/M68K port. (Thanks to Peter Seebach + <seebs@taniemarie.solon.com>.) + - Fixed a serious realloc bug. For certain object sizes, the collector + wouldn't scan the expanded part of the object. (Thanks to Clay Spence + (cds@peanut.sarnoff.com) for noticing the problem, and helping me to + track it down.) + +Since version 4.5: + - Added Linux ELF support. (Thanks to Arrigo Triulzi <arrigo@ic.ac.uk>.) + - GC_base crashed if it was called before any other GC_ routines. + This could happen if a gc_cleanup object was allocated outside the heap + before any heap allocation. + - The heap expansion heuristic was not stable if all objects had finalization + enabled. Fixed finalize.c to count memory in finalization queue and + avoid explicit deallocation. Changed alloc.c to also consider this count. + (This is still not recommended. It's expensive if nothing else.) Thanks + to John Ellis for pointing this out. + - GC_malloc_uncollectable(0) was broken. Thanks to Phong Vo for pointing + this out. + - The collector didn't compile under Linux 1.3.X. (Thanks to Fred Gilham for + pointing this out.) The current workaround is ugly, but expected to be + temporary. + - Fixed a formatting problem for SPARC stack traces. + - Fixed some '=='s in os_dep.c that should have been assignments. + Fortunately these were in code that should never be executed anyway. + (Thanks to Fergus Henderson.) + - Fixed the heap block allocator to only drop blacklisted blocks in small + chunks. Made BL_LIMIT self adjusting. (Both of these were in response + to heap growth observed by Paul Graham.) + - Fixed the Metrowerks/68K Mac code to also mark from a6. (Thanks + to Patrick Beard.) + - Significantly updated README.debugging. + - Fixed some problems with longjmps out of signal handlers, especially under + Solaris. Added a workaround for the fact that siglongjmp doesn't appear to + do the right thing with -lthread under Solaris. + - Added MSDOS/djgpp port. (Thanks to Mitch Harris (maharri@uiuc.edu).) + - Added "make reserved_namespace" and "make user_namespace". The + first renames ALL "GC_xxx" identifiers as "_GC_xxx". The second is the + inverse transformation. Note that doing this is guaranteed to break all + clients written for the other names. + - descriptor field for kind NORMAL in GC_obj_kinds with ADD_BYTE_AT_END + defined should be -ALIGNMENT not WORDS_TO_BYTES(-1). This is + a serious bug on machines with pointer alignment of less than a word. + - GC_ignore_self_finalize_mark_proc didn't handle pointers to very near the + end of the object correctly. Caused failures of the C++ test on a DEC Alpha + with g++. + - gc_inl.h still had problems. Partially fixed. Added warnings at the + beginning to hopefully specify the remaining dangers. + - Added DATAEND definition to config.h. + - Fixed some of the .h file organization. Fixed "make floppy". + +Since version 4.6: + - Fixed some compilation problems with -DCHECKSUMS (thanks to Ian Searle) + - Updated some Mac specific files to synchronize with Patrick Beard. + - Fixed a serious bug for machines with non-word-aligned pointers. + (Thanks to Patrick Beard for pointing out the problem. The collector + should fail almost any conceivable test immediately on such machines.) + +Since version 4.7: + - Changed a "comment" in a MacOS specific part of mach-dep.c that caused + gcc to fail on other platforms. + +Since version 4.8 + - More README.debugging fixes. + - Objects ready for finalization, but not finalized in the same GC + cycle, could be prematurely collected. This occasionally happened + in test_cpp. + - Too little memory was obtained from the system for very large + objects. That could cause a heap explosion if these objects were + not contiguous (e.g. under PCR), and too much of them was blacklisted. + - Due to an improper initialization, the collector was too hesitant to + allocate blacklisted objects immediately after system startup. + - Moved GC_arrays from the data into the bss segment by not explicitly + initializing it to zero. This significantly + reduces the size of executables, and probably avoids some disk accesses + on program startup. It's conceivable that it might break a port that I + didn't test. + - Fixed EMX_MAKEFILE to reflect the gc_c++.h to gc_cpp.h renaming which + occurred a while ago. + +Since 4.9: + - Fixed a typo around a call to GC_collect_or_expand in alloc.c. It broke + handling of out of memory. (Thanks to Patrick Beard for noticing.) + +Since 4.10: + - Rationalized (hopefully) GC_try_to_collect in an incremental collection + environment. It appeared to not handle a call while a collection was in + progress, and was otherwise too conservative. + - Merged GC_reclaim_or_delete_all into GC_reclaim_all to get rid of some + code. + - Added Patrick Beard's Mac fixes, with substantial completely untested + modifications. + - Fixed the MPROTECT_VDB code to deal with large pages and imprecise + fault addresses (as on an UltraSPARC running Solaris 2.5). Note that this + was not a problem in the default configuration, which uses PROC_VDB. + - The DEC Alpha assembly code needed to restore $gp between calls. + Thanks to Fergus Henderson for tracking this down and supplying a + patch. + - The write command for "de" was completely broken for large files. + I used the easiest portable fix, which involved changing the semantics + so that f.new is written instead of overwriting f. That's safer anyway. + - Added README.solaris2 with a discussion of the possible problems of + mixing the collector's sbrk allocation with malloc/realloc. + - Changed the data segment starting address for SGI machines. The + old code failed under IRIX6. + - Required double word alignment for MIPS. + - Various minor fixes to remove warnings. + - Attempted to fix some Solaris threads problems reported by Zhiying Chen. + In particular, the collector could try to fork a thread with the + world stopped as part of GC_thr_init. It also failed to deal with + the case in which the original thread terminated before the whole + process did. + - Added -DNO_EXECUTE_PERMISSION. This has a major performance impact + on the incremental collector under Irix, and perhaps under other + operating systems. + - Added some code to support allocating the heap with mmap. This may + be preferable under some circumstances. + - Integrated dynamic library support for HP. + (Thanks to Knut Tvedten <knuttv@ifi.uio.no>.) + - Integrated James Clark's win32 threads support, and made a number + of changes to it, many of which were suggested by Pontus Rydin. + This is still not 100% solid. + - Integrated Alistair Crooks' support for UTS4 running on an Amdahl + 370-class machine. + - Fixed a serious bug in explicitly typed allocation. Objects requiring + large descriptors where handled in a way that usually resulted in + a segmentation fault in the marker. (Thanks to Jeremy Fitzhardinge + for helping to track this down.) + - Added partial support for GNU win32 development. (Thanks to Fergus + Henderson.) + - Added optional support for Java-style finalization semantics. (Thanks + to Patrick Bridges.) This is recommended only for Java implementations. + - GC_malloc_uncollectable faulted instead of returning 0 when out of + memory. (Thanks to dan@math.uiuc.edu for noticing.) + - Calls to GC_base before the collector was initialized failed on a + DEC Alpha. (Thanks to Matthew Flatt.) + - Added base pointer checking to GC_REGISTER_FINALIZER in debugging + mode, at the suggestion of Jeremy Fitzhardinge. + - GC_debug_realloc failed for uncollectable objects. (Thanks to + Jeremy Fitzhardinge.) + - Explicitly typed allocation could crash if it ran out of memory. + (Thanks to Jeremy Fitzhardinge.) + - Added minimal support for a DEC Alpha running Linux. + - Fixed a problem with allocation of objects whose size overflowed + ptrdiff_t. (This now fails unconditionally, as it should.) + - Added the beginning of Irix pthread support. + - Integrated Xiaokun Zhu's fixes for djgpp 2.01. + - Added SGI-style STL allocator support (gc_alloc.h). + - Fixed a serious bug in README.solaris2. Multithreaded programs must include + gc.h with SOLARIS_THREADS defined. + - Changed GC_free so it actually deallocates uncollectable objects. + (Thanks to Peter Chubb for pointing out the problem.) + - Added Linux ELF support for dynamic libararies. (Thanks again to + Patrick Bridges.) + - Changed the Borland cc configuration so that the assembler is not + required. + - Fixed a bug in the C++ test that caused it to fail in 64-bit + environments. + +Since 4.11: + - Fixed ElfW definition in dyn_load.c. (Thanks to Fergus Henderson.) + This prevented the dynamic library support from compiling on some + older ELF Linux systems. + - Fixed UTS4 port (which I apparently mangled during the integration) + (Thanks to again to Alistair Crooks.) + - "Make C++" failed on Suns with SC4.0, due to a problem with "bool". + Fixed in gc_priv.h. + - Added more pieces for GNU win32. (Thanks to Timothy N. Newsham.) + The current state of things should suffice for at least some + applications. + - Changed the out of memory retry count handling as suggested by + Kenjiro Taura. (This matters only if GC_max_retries > 0, which + is no longer the default.) + - If a /proc read failed repeatedly, GC_written_pages was not updated + correctly. (Thanks to Peter Chubb for diagnosing this.) + - Under unlikely circumstances, the allocator could infinite loop in + an out of memory situation. (Thanks again to Kenjiro Taura for + identifying the problem and supplying a fix.) + - Fixed a syntactic error in the DJGPP code. (Thanks to Fergus + Henderson for finding this by inspection.) Also fixed a test program + problem with DJGPP (Thanks to Peter Monks.) + - Atomic uncollectable objects were not treated correctly by the + incremental collector. This resulted in weird log statistics and + occasional performance problems. (Thanks to Peter Chubb for pointing + this out.) + - Fixed some problems resulting from compilers that dont define + __STDC__. In this case void * and char * were used inconsistently + in some cases. (Void * should not have been used at all. If + you have an ANSI superset compiler that does not define __STDC__, + please compile with -D__STDC__=0. Thanks to Manuel Serrano and others + for pointing out the problem.) + - Fixed a compilation problem on Irix with -n32 and -DIRIX_THREADS. + Also fixed some other IRIX_THREADS problems which may or may not have + had observable symptoms. + - Fixed an HP PA compilation problem in dyn_load.c. (Thanks to + Philippe Queinnec.) + - SEGV fault handlers sometimes did not get reset correctly. (Thanks + to David Pickens.) + - Added a fix for SOLARIS_THREADS on Intel. (Thanks again to David + Pickens.) This probably needs more work to become functional. + - Fixed struct sigcontext_struct in os_dep.c for compilation under + Linux 2.1.X. (Thanks to Fergus Henderson.) + - Changed the DJGPP STACKBOTTOM and DATASTART values to those suggested + by Kristian Kristensen. These may still not be right, but it is + it is likely to work more often than what was there before. They may + even be exactly right. + - Added a #include <string.h> to test_cpp.cc. This appears to help + with HP/UX and gcc. (Thanks to assar@sics.se.) + - Version 4.11 failed to run in incremental mode on recent 64-bit Irix + kernels. This was a problem related to page unaligned heap segments. + Changed the code to page align heap sections on all platforms. + (I had mistakenly identified this as a kernel problem earlier. + It was not.) + - Version 4.11 did not make allocated storage executable, except on + one or two platforms, due to a bug in a #if test. (Thanks to Dave + Grove for pointing this out.) + - Added sparc_sunos4_mach_dep.s to support Sun's compilers under SunOS4. + - Added GC_exclude_static_roots. + - Fixed the object size mapping algorithm. This shouldn't matter, + but the old code was ugly. + - Heap checking code could die if one of the allocated objects was + larger than its base address. (Unsigned underflow problem. Thanks + to Clay Spence for isolating the problem.) + - Added RS6000 (AIX) dynamic library support and fixed STACK_BOTTOM. + (Thanks to Fred Stearns.) + - Added Fergus Henderson's patches for improved robustness with large + heaps and lots of blacklisting. + - Added Peter Chubb's changes to support Solaris Pthreads, to support + MMAP allocation in Solaris, to allow Solaris to find dynamic libraries + through /proc, to add malloc_typed_ignore_off_page, and a few other + minor features and bug fixes. + - The Solaris 2 port should not use sbrk. I received confirmation from + Sun that the use of sbrk and malloc in the same program is not + supported. The collector now defines USE_MMAP by default on Solaris. + - Replaced the djgpp makefile with Gary Leavens' version. + - Fixed MSWIN32 detection test. + - Added Fergus Henderson's patches to allow putting the collector into + a DLL under GNU win32. + - Added Ivan V. Demakov's port to Watcom C on X86. + - Added Ian Piumarta's Linux/PowerPC port. + - On Brian Burton's suggestion added PointerFreeGC to the placement + options in gc_cpp.h. This is of course unsafe, and may be controversial. + On the other hand, it seems to be needed often enough that it's worth + adding as a standard facility. + +Since 4.12: + - Fixed a crucial bug in the Watcom port. There was a redundant decl + of GC_push_one in gc_priv.h. + - Added FINALIZE_ON_DEMAND. + - Fixed some pre-ANSI cc problems in test.c. + - Removed getpagesize() use for Solaris. It seems to be missing in one + or two versions. + - Fixed bool handling for SPARCCompiler version 4.2. + - Fixed some files in include that had gotten unlinked from the main + copy. + - Some RS/6000 fixes (missing casts). Thanks to Toralf Foerster. + - Fixed several problems in GC_debug_realloc, affecting mostly the + FIND_LEAK case. + - GC_exclude_static_roots contained a buggy unsigned comparison to + terminate a loop. (Thanks to Wilson Ho.) + - CORD_str failed if the substring occurred at the last possible position. + (Only affects cord users.) + - Fixed Linux code to deal with RedHat 5.0 and integrated Peter Bigot's + os_dep.c code for dealing with various Linux versions. + - Added workaround for Irix pthreads sigaction bug and possible signal + misdirection problems. +Since alpha1: + - Changed RS6000 STACKBOTTOM. + - Integrated Patrick Beard's Mac changes. + - Alpha1 didn't compile on Irix m.n, m < 6. + - Replaced Makefile.dj with a new one from Gary Leavens. + - Added Andrew Stitcher's changes to support SCO OpenServer. + - Added PRINT_BLACK_LIST, to allow debugging of high densities of false + pointers. + - Added code to debug allocator to keep track of return address + in GC_malloc caller, thus giving a bit more context. + - Changed default behavior of large block allocator to more + aggressively avoid fragmentation. This is likely to slow down the + collector when it succeeds at reducing space cost. + - Integrated Fergus Henderson's CYGWIN32 changes. They are untested, + but needed for newer versions. + - USE_MMAP had some serious bugs. This caused the collector to fail + consistently on Solaris with -DSMALL_CONFIG. + - Added Linux threads support, thanks largely to Fergus Henderson. +Since alpha2: + - Fixed more Linux threads problems. + - Changed default GC_free_space_divisor to 3 with new large block allocation. + (Thanks to Matthew Flatt for some measurements that suggest the old + value sometimes favors space too much over time.) + - More CYGWIN32 fixes. + - Integrated Tyson-Dowd's Linux-M68K port. + - Minor HP PA and DEC UNIX fixes from Fergus Henderson. + - Integrated Christoffe Raffali's Linux-SPARC changes. + - Allowed for one more GC fixup iteration after a full GC in incremental + mode. Some quick measurements suggested that this significantly + reduces pause times even with smaller GC_RATE values. + - Moved some more GC data structures into GC_arrays. This decreases + pause times and GC overhead, but makes debugging slightly less convenient. + - Fixed namespace pollution problem ("excl_table"). + - Made GC_incremental a constant for -DSMALL_CONFIG, hopefully shrinking + that slightly. + - Added some win32 threads fixes. + - Integrated Ivan Demakov and David Stes' Watcom fixes. + - Various other minor fixes contributed by many people. + - Renamed config.h to gcconfig.h, since config.h tends to be used for + many other things. + - Integrated Matthew Flatt's support for 68K MacOS "far globals". + - Fixed up some of the dynamic library Makefile targets for consistency + across platforms. + - Fixed a USE_MMAP typo that caused out-of-memory handling to fail + on Solaris. + - Added code to test.c to test thread creation a bit more. + - Integrated GC_win32_free_heap, as suggested by Ivan Demakov. + - Fixed Solaris 2.7 stack base finding problem. (This may actually + have been done in an earlier alpha release.) +Since alpha3: + - Fixed MSWIN32 recognition test, which interfered with cygwin. + - Removed unnecessary gc_watcom.asm from distribution. Removed + some obsolete README.win32 text. + - Added Alpha Linux incremental GC support. (Thanks to Philipp Tomsich + for code for retrieving the fault address in a signal handler.) + Changed Linux signal handler context argument to be a pointer. + - Took care of some new warnings generated by the 7.3 SGI compiler. + - Integrated Phillip Musumeci's FreeBSD/ELF fixes. + - -DIRIX_THREADS was broken with the -o32 ABI (typo in gc_priv.h> + +Since 4.13: + - Fixed GC_print_source_ptr to not use a prototype. + - generalized CYGWIN test. + - gc::new did the wrong thing with PointerFreeGC placement. + (Thanks to Rauli Ruohonen.) + - In the ALL_INTERIOR_POINTERS (default) case, some callee-save register + values could fail to be scanned if the register was saved and + reused in a GC frame. This showed up in verbose mode with gctest + compiled with an unreleased SGI compiler. I vaguely recall an old + bug report that may have been related. The bug was probably quite old. + (The problem was that the stack scanning could be deferred until + after the relevant frame was overwritten, and the new save location + might be outside the scanned area. Fixed by more eager stack scanning.) + - PRINT_BLACK_LIST had some problems. A few source addresses were garbage. + - Replaced Makefile.dj and added -I flags to cord make targets. + (Thanks to Gary Leavens.) + - GC_try_to_collect was broken with the nonincremental collector. + - gc_cleanup destructors could pass the wrong address to + GC_register_finalizer_ignore_self in the presence of multiple + inheritance. (Thanks to Darrell Schiebel.) + - Changed PowerPC Linux stack finding code. + +Since 4.14alpha1 + - -DSMALL_CONFIG did not work reliably with large (> 4K) pages. + Recycling the mark stack during expansion could result in a size + zero heap segment, which confused things. (This was probably also an + issue with the normal config and huge pages.) + - Did more work to make sure that callee-save registers were scanned + completely, even with the setjmp-based code. Added USE_GENERIC_PUSH_REGS + macro to facilitate testing on machines I have access to. + - Added code to explicitly push register contents for win32 threads. + This seems to be necessary. (Thanks to Pierre de Rop.) + +Since 4.14alpha2 + - changed STACKBOTTOM for DJGPP (Thanks to Salvador Eduardo Tropea). + +Since 4.14 + - Reworked large block allocator. Now uses multiple doubly linked free + lists to approximate best fit. + - Changed heap expansion heuristic. Entirely free blocks are no longer + counted towards the heap size. This seems to have a major impact on + heap size stability; the old version could expand the heap way too + much in the presence of large block fragmentation. + - added -DGC_ASSERTIONS and some simple assertions inside the collector. + This is mainlyt for collector debugging. + - added -DUSE_MUNMAP to allow the heap to shrink. Suupported on only + a few UNIX-like platforms for now. + - added GC_dump_regions() for debugging of fragmentation issues. + - Changed PowerPC pointer alignment under Linux to 4. (This needs + checking by someone who has one. The suggestions came to me via a + rather circuitous path.) + - Changed the Linux/Alpha port to walk the data segment backwards until + it encounters a SIGSEGV. The old way to find the start of the data + segment broke with a recent release. + - cordxtra.c needed to call GC_REGISTER_FINALIZER instead of + GC_register_finalizer, so that it would continue to work with GC_DEBUG. + - allochblk sometimes cleared the wrong block for debugging purposes + when it dropped blacklisted blocks. This could result in spurious + error reports with GC_DEBUG. + - added MACOS X Server support. (Thanks to Andrew Stone.) + - Changed the Solaris threads code to ignore stack limits > 8 MB with + a warning. Empirically, it is not safe to access arbitrary pages + in such large stacks. And the dirty bit implementation does not + guarantee that none of them will be accessed. + - Integrated Martin Tauchmann's Amiga changes. + - Integrated James Dominy's OpenBSD/SPARC port. + +Since 5.0alpha1 + - Fixed bugs introduced in alpha1 (OpenBSD & large block initialization). + - Added -DKEEP_BACK_PTRS and backptr.h interface. (The implementation + idea came from Al Demers.) + +Since 5.0alpha2 + - Added some highly incomplete code to support a copied young generation. + Comments on nursery.h are appreciated. + - Changed -DFIND_LEAK, -DJAVA_FINALIZATION, and -DFINALIZE_ON_DEMAND, + so the same effect could be obtained with a runtime switch. This is + a step towards standardizing on a single dynamic GC library. + - Significantly changed the way leak detection is handled, as a consequence + of the above. + +Since 5.0 alpha3 + - Added protection fault handling patch for Linux/M68K from Fergus + Henderson and Roman Hodek. + - Removed the tests for SGI_SOURCE in new_gc_alloc.h. This was causing that + interface to fail on nonSGI platforms. + - Changed the Linux stack finding code to use /proc, after changing it + to use HEURISTIC1. (Thanks to David Mossberger for pointing out the + /proc hook.) + - Added HP/UX incremental GC support and HP/UX 11 thread support. + Thread support is currently still flakey. + - Added basic Linux/IA64 support. + - Integrated Anthony Green's PicoJava support. + - Integrated Scott Ananian's StrongARM/NetBSD support. + - Fixed some fairly serious performance bugs in the incremental + collector. These have probably been there essentially forever. + (Mark bits were sometimes set before scanning dirty pages. + The reclaim phase unnecessarily dirtied full small object pages.) + - Changed the reclaim phase to ignore nearly full pages to avoid + touching them. + - Limited GC_black_list_spacing to roughly the heap growth increment. + - Changed full collection triggering heuristic to decrease full GC + frequency by default, but to explicitly trigger full GCs during + heap growth. This doesn't always improve things, but on average it's + probably a win. + - GC_debug_free(0, ...) failed. Thanks to Fergus Henderson for the + bug report and fix. + +Since 5.0 alpha4 + - GC_malloc_explicitly_typed and friends sometimes failed to + initialize first word. + - Added allocation routines and support in the marker for mark descriptors + in a type structure referenced by the first word of an object. This was + introduced to support gcj, but hopefully in a way that makes it + generically useful. + - Added GC_requested_heapsize, and inhibited collections in nonincremental + mode if the actual used heap size is less than what was explicitly + requested. + - The Solaris pthreads version of GC_pthread_create didn't handle a NULL + attribute pointer. Solaris thread support used the wrong default thread + stack size. (Thanks to Melissa O'Neill for the patch.) + - Changed PUSH_CONTENTS macro to no longer modify first parameter. + This usually doesn't matter, but it was certainly an accident waiting + to happen ... + - Added GC_register_finalizer_no_order and friends to gc.h. They're + needed by Java implementations. + - Integrated a fix for a win32 deadlock resulting from clock() calling + malloc. (Thanks to Chris Dodd.) + - Integrated Hiroshi Kawashima's port to Linux/MIPS. This was designed + for a handheld platform, and may or may not be sufficient for other + machines. + - Fixed a va_arg problem with the %c specifier in cordprnt.c. It appears + that this was always broken, but recent versions of gcc are the first to + report the (statically detectable) bug. + - Added an attempt at a more general solution to dlopen races/deadlocks. + GC_dlopen now temporarily disables collection. Still not ideal, but ... + - Added -DUSE_I686_PREFETCH, -DUSE_3DNOW_PREFETCH, and support for IA64 + prefetch instructions. May improve performance measurably, but I'm not + sure the code will run correctly on processors that don't support the + instruction. Won't build except with very recent gcc. + - Added caching for header lookups in the marker. This seems to result + in a barely measurable performance gain. Added support for interleaved + lookups of two pointers, but unconfigured that since the performance + gain is currently near zero, and it adds to code size. + - Changed Linux DATA_START definition to check both data_start and + __data_start, since nothing else seems to be portable. + - Added -DUSE_LD_WRAP to optionally take advantage of the GNU ld function + wrapping mechanism. Probably currently useful only on Linux. + - Moved some variables for the scratch allocator into GC_arrays, on + Martin Hirzel's suggestion. + - Fixed a win32 threads bug that caused the collector to not look for + interior pointers from one of the thread stacks without + ALL_INTERIOR_POINTERS. (Thanks to Jeff Sturm.) + - Added Mingw32 support. (Thanks again to Jeff Sturm for the patch.) + - Changed the alpha port to use the generic register scanning code instead + of alpha_mach_dep.s. Alpha_mach_dep.s doesn't look for pointers in fp + registers, but gcc sometimes spills pointers there. (Thanks to Manuel + Serrano for helping me debug this by email.) Changed the IA64 code to + do something similar for similar reasons. + +[5.0alpha5 doesn't really exist, but it may have escaped.] + +Since 5.0alpha6: + - -DREDIRECT_MALLOC was broken in alpha6. Fixed. + - Cleaned up gc_ccp.h slightly, thus also causing the HP C++ compiler to + accept it. + - Removed accidental reference to dbg_mlc.c, which caused dbg_mlc.o to be + linked into every executable. + - Added PREFETCH to bitmap marker. Changed it to use the header cache. + - GC_push_marked sometimes pushed one object too many, resulting in a + segmentation fault in GC_mark_from_mark_stack. This was probably an old + bug. It finally showed up in gctest on win32. + - Gc_priv.h erroneously #defined GC_incremental to be TRUE instead of FALSE + when SMALL_CONFIG was defined. This was no doubt a major performance bug for + the default win32 configuration. + - Removed -DSMALL_CONFIG from NT_MAKEFILE. It seemed like an anchronism now + that the average PC has 64MB or so. + - Integrated Bryce McKinley's patches for linux threads and dynamic loading + from the libgcj tree. Turned on dynamic loading support for Linux/PPC. + - Changed the stack finding code to use environ on HP/UX. (Thanks + to Gustavo Rodriguez-Rivera for the suggestion.) This should probably + be done on other platforms, too. Since I can't test those, that'll + wait until after 5.0. + +Since 5.0alpha7: + - Fixed threadlibs.c for linux threads. -DUSE_LD_WRAP was broken and + -ldl was omitted. Fixed Linux stack finding code to handle + -DUSE_LD_WRAP correctly. + - Added MSWIN32 exception handler around marker, so that the collector + can recover from root segments that are unmapped during the collection. + This caused occasional failures under Windows 98, and may also be + an issue under Windows NT/2000. + +Since 5.0 + - Fixed a gc.h header bug which showed up under Irix. (Thanks to + Dan Sullivan.) + - Fixed a typo in GC_double_descr in typd_mlc.c. + This probably could result in objects described by array descriptors not + getting traced correctly. (Thanks to Ben Hutchings for pointing this out.) + - The block nearly full tests in reclaim.c were not correct for 64 bit + environments. This could result in unnecessary heap growth under unlikely + conditions. + +Since 5.1 + - dyn_load.c declared GC_scratch_last_end_ptr as an extern even if it + was defined as a macro. This prevented the collector from building on + Irix. + - We quietly assumed that indirect mark descriptors were never 0. + Our own typed allocation interface violated that. This could result + in segmentation faults in the marker with typed allocation. + - Fixed a _DUSE_MUNMAP bug in the heap block allocation code. + (Thanks to Ben Hutchings for the patch.) + - Taught the collector about VC++ handling array operator new. + (Thanks again to Ben Hutchings for the patch.) + - The two copies of gc_hdrs.h had diverged. Made one a link to the other + again. + +Since 5.2 (A few 5.2 patches are not in 6.0alpha1) + - Fixed _end declaration for OSF1. + - There were lots of spurious leak reports in leak detection mode, caused + by the fact that some pages were not being swept, and hence unmarked + objects weren't making it onto free lists. (This bug dated back to 5.0.) + - Fixed a typo in the liblinuxgc.so Makefile rule. + - Added the GetExitCodeThread to Win32 GC_stop_world to (mostly) work + around a Windows 95 GetOpenFileName problem. (Thanks to Jacob Navia.) + +Since 5.3 + - Fixed a typo that prevented compilation with -DUSE_3DNOW_PREFETCH. + (Thanks to Shawn Wagner for actually testing this.) + - Fixed GC_is_thread_stack in solaris_threads.c. It forgot to return a value + in the common case. I wonder why nobody noticed? + - Fixed another silly syntax problem in GC_double_descr. (Thanks to + Fergus Henderson for finding it.) + - Fixed a GC_gcj_malloc bug: It tended to release the allocator lock twice. + +Since 5.4 (A few 5.3 patches are not in 6.0alpha2) + - Added HP/PA prefetch support. + - Added -DDBG_HDRS_ALL and -DSHORT_DBG_HDRS to reduce the cost and improve + the reliability of generating pointer backtrace information, e.g. in + the Bigloo environment. + - Added parallel marking support (-DPARALLEL_MARK). This currently + works only under IA32 and IA64 Linux, but it shouldn't be hard to adapt + to other platforms. This is intended to be a lighter-weight (less + new code, probably not as scalable) solution than the work by Toshio Endo + et al, at the University of Tokyo. A number of their ideas were + reused, though the code wasn't, and the underlying data structure + is significantly different. In particular, we keep the global mark + stack as a single shared data structure, but most of the work is done + on smaller thread-local mark stacks. + - Changed GC_malloc_many to be cheaper, and to require less mutual exclusion + with -DPARALLEL_MARK. + - Added full support for thread local allocation under Linux + (-DTHREAD_LOCAL_ALLOC). This is a thin veneer on GC_malloc_many, and + should be easily portable to other platforms, especially those that + support pthreads. + - CLEAR_DOUBLE was not always getting invoked when it should have been. + - GC_gcj_malloc and friends used different out of memory handling than + everything else, probably because I forgot about one when I implemented + the other. They now both call GC_oom_fn(), not GC_oom_action(). + - Integrated Jakub Jelinek's fixes for Linux/SPARC. + - Moved GC_objfreelist, GC_aobjfreelist, and GC_words_allocd out of + GC_arrays, and separately registered the first two as excluded roots. + This makes code compiled with gc_inl.h less dependent on the + collector version. (It would be nice to remove the inclusion of + gc_priv.h by gc_inl.h completely, but we're not there yet. The + locking definitions in gc_priv.h are still referenced.) + This change was later coniditoned on SEPARATE_GLOBALS, which + is not defined by default, since it involves a performance hit. + - Register GC_obj_kinds separately as an excluded root region. The + attempt to register it with GC_arrays was usually failing. (This wasn't + serious, but seemed to generate some confusion.) + - Moved backptr.h to gc_backptr.h. + +Since 6.0alpha1 + - Added USE_MARK_BYTES to reduce the need for compare-and-swap on platforms + for which that's expensive. + - Fixed a locking bug ib GC_gcj_malloc and some locking assertion problems. + - Added a missing volatile to OR_WORD and renamed the parameter to + GC_compare_and_swap so it's not a C++ reserved word. (Thanks to + Toshio Endo for pointing out both of those.) + - Changed Linux dynamic library registration code to look at /proc/self/maps + instead of the rld data structures when REDIRECT_MALLOC is defined. + Otherwise some of the rld data data structures may be prematurely garbage + collected. (Thanks to Eric Benson for helping to track this down.) + - Fixed USE_LD_WRAP a bit more, so it should now work without threads. + - Renamed XXX_THREADS macros to GC_XXX_THREADS for namespace correctness. + Tomporarily added some backward compatibility definitions. Renamed + USE_LD_WRAP to GC_USE_LD_WRAP. + - Many MACOSX POWERPC changes, some additions to the gctest output, and + a few minor generic bug fixes. (Thanks to Dietmar Planitzer.) + +Since 6.0 alpha2 + - Fixed the /proc/self/maps code to not seek, since that apparently is not + reliable across all interesting kernels. + - Fixed some compilation problems in the absence of PARALLEL_MARK + (introduced in alpha2). + - Fixed an algorithmic problem with PARALLEL_MARK. If work needs to + be given back to the main mark "stack", the BOTTOM entries of the local + stack should be given away, not the top ones. This has substantial + performance impact, especially for > 2 processors, from what I can tell. + - Extracted gc_lock.h from gc_priv.h. This should eventually make it a + bit easier to avoid including gc_priv.h in clients. + - Moved all include files to include/ and removed duplicate links to the + same file. The old scheme was a bad idea because it was too easy to get the + copies out of sync, and many systems don't support hard links. + Unfortunately, it's likely that I broke some of the non-Unix Makefiles in + the process, although I tried to update them appropriately. + - Removed the partial support for a copied nursery. It's not clear that + this would be a tremendous win, since we don't consistently lose to + generational copying collectors. And it would significantly complicate + many things. May be reintroduced if/when it really turns out to win. + - Removed references to IRIX_JDK_THREADS, since I believe there never + were and never will be any clients. + - Added some code to linux_threads.c to possibly support HPUX threads + using the Linux code. Unfortunately, it doesn't work yet, and is + currently disabled. + - Added support under Linux/X86 for saving the call chain, both in (debug) + objects for client debugging, and in GC_arrays._last_stack for GC + debugging. This was previously supported only under Solaris. It is + not enabled by default under X86, since it requires that code be compiled + to explicitly dave frame pointers on the call stack. (With gcc this + currently happens by default, but is often turned off explicitly.) + To turn it on, define SAVE_CALL_CHAIN. + +Since 6.0 alpha3 + - Moved up the detection of mostly full blocks to the initiatiation of the + sweep phase. This eliminates some lock conention in the PARALLEL_MARK case, + as multiple threads try to look at mostly full blocks concurrently. + - Restored the code in GC_malloc_many that grabs a prefix of the global + free list. This avoids the case in which every GC_malloc_many call + tries and fails to allocate a new heap block, and the returns a single + object from the global free list. + - Some minor fixes in new_hblk.c. (Attempted to build free lists in order + of increasing addresses instead of decreasing addresses for cache performance + reasons. But this seems to be only a very minor gain with -DEAGER_SWEEP, + and a loss in other cases. So the change was backed out.) + - Fixed some of the documentation. (Thanks in large part to Fergus + Henderson.) + - Fixed the Linux USE_PROC_FOR_LIBRARIES code to deal with apps that perform + large numbers of mmaps. (Thanks to Eric Benson.) Also fixed that code to + deal with short reads. + - Added GC_get_total_bytes(). + - Fixed leak detection mode to avoid spurious messages under linuxthreads. + (This should also now be easy for the other supported threads packages. + But the code is tricky enough that I'm hesitant to do it without being able + to test. Everything allocated in the GC thread support itself should be + explicitly deallocated.) + - Made it possible (with luck) to redirect malloc to GC_local_malloc. + +Since 6.0 alpha4 + - Changed the definition of GC_pause in linux_threads.c to use a volatile + asm. Some versions of gcc apparently optimize away writes to local volatile + variables. This caused poor locking behaviour starting at about + 4 processors. + - Added GC_start_blocking(), GC_end_blocking() calls and wrapper for sleep + to linux_threads.c. + The first two calls could be used to generally avoid sending GC signals to + blocked threads, avoiding both premature wakeups and unnecessary overhead. + - Fixed a serious bug in thread-local allocation. At thread termination, + GC_free could get called on small integers. Changed the code for thread + termination to more efficiently return left-over free-lists. + - Integrated Kjetil Matheussen's BeOS support. + - Rearranged the directory structure to create the doc and tests + subdirectories. + - Sort of integrated Eric Benson's patch for OSF1. This provided basic + OSF1 thread support by suitably extending hpux_irix_threads.c. Based + on earlier email conversations with David Butenhof, I suspect that it + will be more reliable in the long run to base this on linux_threads.c + instead. Thus I attempted to patch up linux_threads.c based on Eric's code. + The result is almost certainly broken, but hopefully close enough that + someone with access to a machine can pick it up. + - Integrated lots of minor changes from the NetBSD distribution. (These + were supplied by David Brownlee. I'm not sure about the original + authors.) + - Hacked a bit more on the HP/UX thread-support in linux_threads.c. It + now appears to work in the absence of incremental collection. Renamed + hpux_irix_threads.c back to irix_threads.c, and removed the attempt to + support HPUX there. + - Changed gc.h to define _REENTRANT in cases in which it should already + have been defined. It is still safer to also define it on the command + line. + +Since 6.0alpha5: + - Changed the definition of DATASTART on ALPHA and IA64, where data_start + and __data_start are not defined by earlier versions of glibc. This might + need to be fixed on other platforms as well. + - Changed the way the stack base and backing store base are found on IA64. + This should now remain reliable on future kernels. But since it relies + on /proc, it will no longer work in the simulated NUE environment. + - Made the call to random() in dbg_mlc.c with -DKEEP_BACK_PTRS dependent + on the OS. On non-Unix systems, rand() should be used instead. Handled + small RAND_MAX. (Thanks to Peter Ross for pointing this out.) + - Fixed the cord make rules to create the cord subdirectory, if necessary. + (Thanks to Doug Moen.) + - Changed fo_object_size calculation in finalize.c. Turned finalization + of nonheap object into a no-op. Removed anachronism from GC_size() + implementation. + - Changed GC_push_dirty call in solaris_threads.c to GC_push_selected. + It was missed in a previous renaming. (Thanks to Vladimir Tsichevski + for pointing this out.) + - Arranged to not not mask SIGABRT in linux_threads.c. (Thanks to Bryce + McKinlay.) + - Added GC_no_dls hook for applications that want to register their own + roots. + - Integrated Kjetil Matheussen's Amiga changes. + - Added FREEBSD_STACKBOTTOM. Changed the X86/FreeBSD port to use it. + (Thanks to Matthew Flatt.) + - Added pthread_detach interception for platforms supported by linux_threads.c + and irix_threads.c. Should also be added for Solaris? + - Changed the USE_MMAP code to check for the case in which we got the + high end of the address space, i.e. mem_ptr + mem_sz == 0. It appears + that this can happen under Solaris 7. It seems to be allowed by what + I would claim is an oversight in the mmap specification. (Thanks to Toshio + Endo for pointing out the problem.) + - Cleanup of linux_threads.c. Some code was originally cloned from + irix_threads.c and now unnecessary. Some comments were obviously wrong. + - (Mostly) fixed a longstanding problem with setting of dirty bits from + a signal handler. In the presence of threads, dirty bits could get lost, + since the etting of a bit in the bit vector was not atomic with respect + to other updates. The fix is 100% correct only for platforms for which + GC_test_and_set is defined. The goal is to make that all platforms with + thread support. Matters only if incremental GC and threads are both + enabled. + - made GC_all_interior_pointers (a.k.a. ALL_INTERIOR_POINTERS) an + initialization time, instead of build-time option. This is a + nontrivial, high risk change. It should slow down the code measurably + only if MERGE_SIZES is not defined, which is a very nonstandard + configuration. + - Added doc/README.environment, and implemented what it describes. This + allows a number of additional configuration options to be set through + the environment. It documents a few previously undocumented options. + - Integrated Eric Benson's leak testing improvements. + - Removed the option to throw away the beginning of each page (DISCARD_WORDS). + This became less and less useful as processors enforce stricter alignment. + And it hadn't been tested in ages, and was thus probably broken anyway. + +Since 6.0alpha6: + - Added GC_finalizer_notifier. Fixed GC_finalize_on_demand. (The variable + actually wasn't being tested at the right points. The build-time flag + was.) + - Added Tom Tromey's S390 Linux patch. + - Added code to push GC_finalize_now in GC_push_finalizer_structures. + (Thanks to Matthew Flatt.) + - Added GC_push_gc_structures() to push all GC internal roots. + - Integrated some FreeBSD changes from Matthew Flatt. + - It looks like USRSTACK is not always correctly defined under Solaris. + Hacked gcconfig.h to attempt to work around the problem. The result + is not well tested. (Thanks again to Matthew Flatt for pointing this + out. The gross hack is mine. - HB) + - Added Ji-Yong Chung's win32 threads and C++ fixes. + - Arranged for hpux_test_and_clear.s to no longer be needed or built. + It was causing build problems with gas, and it's not clear this is + better than the pthreads alternative on this platform. + - Some MINGW32 fixes from Hubert Garavel. + - Added Initial Hitachi SH4 port from Kaz Kojima. + - Ported thread-local allocation and parallel mark code to HP/UX on PA_RISC. + - Made include/gc_mark.h more public and separated out the really private + pieces. This is probably still not quite sufficient for clients that + want to supply their own kind of type information. But it's a start. + This involved lots of identifier renaming to make it namespace clean. + - Added GC_dont_precollect for clients that need complete control over + the root set. + - GC_is_visible didn't do the right thing with gcj objects. (Not that + many people are likely to care, but ...) + - Don't redefine read with GC_USE_LD_WRAP. + - Initial port to LINUX/HP_PA. Incremental collection and threads are not + yet supported. (Incremental collection should work if you have the + right kernel. Threads may work with a sufficiently patched pthread + library.) + - Changed gcconfig.h to recognize __i386__ as an alternative to i386 in + many places. (Thanks to Benjamin Lerman.) + - Made win32_threads.c more tolerant of detaching a thread that it didn't + know about. (Thanks to Paul Nash.) + - Added Makefile.am and configure.in from gcc to the distribution, with + minimal changes. For the moment, those are just placeholders. In the + future, we're planning to switch to a GNU-style build environment for + Un*x-like systems, though the old Makefile will remain as a backup. + - Turned off STUBBORN_ALLOC by default, and added it back as a Makefile + option. + - Redistributed some functions between malloc.c and mallocx.c, so that + simple statically linked apps no longer pull in mallocx.o. + - Changed large object allocation to clear the first and last few words + of each block before releassing the lock. Otherwise the marker could see + objects with nonsensical type descriptors. + - Fixed a couple of subtle problems that could result in not recognizing + interior pointers from the stack. (I believe these were introduced + in 6.0alpha6.) + - GC_debug_free_inner called GC_free, which tried to reacquire the + allocator lock, and hence deadlocked. (DBG_HDRS_ALL probably never worked + with threads?) + - Fixed several problems with back traces. Accidental references to a free + list could cause the free list pointer to be overwritten by a back pointer. + There seemed to be some problems with the encoding of root and finalizer + references. + +Since 6.0alpha7: + - Changed GC_debug_malloc_replacement and GC_debug_realloc_replacement + so that they compile under Irix. (Thanks to Dave Love.) + - Updated powerpc_macosx_mach_dep.s so that it works if the collector + is in a dynamic library. (Thanks to Andrew Begel.) + - Transformed README.debugging into debugging.html, updating and + expanding it in the process. Added gcdescr.html and tree.html + from the web site to the GC distribution. + - Fixed several problems related to PRINT_BLACK_LIST. This involved + restructuring some of the marker macros. + - Fixed some problems with the sizing of objects with debug information. + Finalization was broken KEEP_BACK_PTRS or PRINT_BLACK_LIST. Reduced the + object size with SHORT_DEBUG_HDRS by another word. + - The "Needed to allocate blacklisted ..." warning had inadvertently + been turned off by default, due to a buggy test in allchblk.c. Turned + it back on. + - Removed the marker macros to deal with 2 pointers in interleaved fashion. + They were messy and the performance improvement seemed minimal. We'll + leave such scheduling issues to the compiler. + - Changed Linux/PowerPC test to also check for __powerpc__ in response + to a discussion on the gcc mailing list. + - On Matthew Flatt's suggestion removed the "static" from the jmp_buf + declaration in GC_generic_push_regs. This was causing problems in + systems that register all of their own roots. It looks far more correct + to me without the "static" anyway. + - Fixed several problems with thread local allocation of pointerfree or + typed objects. The collector was reclaiming thread-local free lists, since + it wasn't following the link fields. + - There was apparently a long-standing race condition related to multithreaded + incremental collection. A collection could be started and a thread stopped + between the memory unprotect system call and the setting of the + corresponding dirt bit. I believe this did not affect Solaris or PCR, which + use a different dirty-bit implementation. Fixed this by installing + signal handlers with sigaction instead of signal, and disabling the thread + suspend signal while in the write-protect handler. (It is unclear + whether this scenario ever actually occurred. I found it while tracking + down the following:) + - Incremental collection did not cooperate correctly with the PARALLEL_MARK + implementation of GC_malloc_many or the local_malloc primitves. It still + doesn't work well, but it shouldn't lose memory anymore. + - Integrated some changes from the gcc source tree that I had previously + missed. (Thanks to Bryce McKinley for the reminder/diff.) + - Added Makefile.direct as a copy of the default Makefile, which would + normally be overwritten if configure is run. + - Changed the gc.tar target in Makefile.direct to embed the version number + in the gc directory name. This will affect future tar file distributions. + - Changed the Irix dynamic library finding code to no longer try to + eliminate writable text segments under Irix6.x, since that is probably no + longer necessary, and can apparently be unsafe on occasion. (Thanks to + Shiro Kawai for pointing this out.) + - GC_cleanup with GC_DEBUG enabled passed a real object base address to + GC_debug_register_finalizer_ignore_self, which expected a pointer past the + debug header. Call GC_register_finalizer_ignore_self instead, even with + debugging enabled. (Thanks to Jean-Daniel Fekete for catching this.) + - The collector didn't build with call chain saving enabled but NARGS=0. + (Thanks to Maarten Thibaut.) + - Fixed up the GNU-style build files enough so that they work in some + obvious cases. + - Added initial port to Digital Mars compiler for win32. (Thanks to Walter + Bright.) + +Since 6.0alpha8: + - added README.macros. + - Made gc.mak a symbolic link to work around winzip's tendency to ignore + hard links. + - Simplified the setting of NEED_FIND_LIMIT in os_dep.c, possibly breaking + it on untested platforms. + - Integrated initial GNU HURD port. (Thanks to Chris Lingard and Igor + Khavkine.) + - A few more fixes for Digital Mars compiler. + - Fixed gcc version recognition. Renamed OPERATOR_NEW_ARRAY to + GC_OPERATOR_NEW_ARRAY. Changed GC_OPERATOR_NEW_ARRAY to be the default. + It can be overridden with -DGC_NO_OPERATOR_NEW_ARRAY. (Thanks to + Cesar Eduardo Barros.) + - Changed the byte size to free-list mapping in thread local allocation + so that size 0 allocations are handled correctly. + - Fixed Linux/MIPS stackbottom for new toolchain. (Thanks to Ryan Murray.) + - Changed finalization registration to invoke GC_oom_fn when it runs out + of memory. + - Removed lvalue cast in finalize.c. This caused some debug configurations + not to build with some non-gcc compilers. + +Since 6.0alpha9: + - Two more bug fixes for KEEP_BACK_PTRS and DBG_HDRS_ALL. + - Fixed a stack clearing problem that resulted in SIGILL with a + misaligned stack pointer for multithreaded SPARC builds. + - Integrated another HURD patch (thanks to Igor Khavkine). + + +To do: + - There seem to be outstanding issues on Solaris/X86, possibly with + finding the data segment starting address. Information/patches would + ne appreciated. + - New_gc_alloc.h is apparently no longer compatible with the latest C++ + standard library in gcc3.0. (This isn't technically a bug, since it only + claimed compatibility with the SGI STL. But we may need a new C++ STL + allocator interface.) + - Very large root set sizes (> 16 MB or so) could cause the collector + to abort with an unexpected mark stack overflow. (Thanks again to + Peter Chubb.) NOT YET FIXED. Workaround is to increase the initial + size. + - The SGI version of the collector marks from mmapped pages, even + if they are not part of dynamic library static data areas. This + causes performance problems with some SGI libraries that use mmap + as a bitmap allocator. NOT YET FIXED. It may be possible to turn + off DYNAMIC_LOADING in the collector as a workaround. It may also + be possible to conditionally intercept mmap and use GC_exclude_static_roots. + The real fix is to walk rld data structures, which looks possible. + - Incremental collector should handle large objects better. Currently, + it looks like the whole object is treated as dirty if any part of it + is. + - Cord/cordprnt.c doesn't build on a few platforms (notably PowerPC), since + we make some unwarranted assumptions about how varargs are handled. This + currently makes the cord-aware versions of printf unusable on some platforms. + Fixing this is unfortunately not trivial. |