Several of the structures now end with an array of structures that may
have other fields added to them that the runtime doesn't know about yet
by a compiler. Rather than indexing into them directly, we must call an
accessor to find the correct address.
A few of the places where accesses were replaced were in functions where
it is safe because they only deal with versions of the structures that
are dynamically allocated (and will therefore have the correct size).
This was done to simplify future auditing: these fields should be
accessed directly only from the accessor functions in the header and
from the upgraders (currently in legacy.c).
Also fix a few bugs where the sizes weren't being filled in.
Added fields to the end of the class structure for strong / weak ivar bitmaps (not yet generated by any compiler).
Fixed definition of __sync_swap() so that it works on GCC again.
Weak references are still not supported, but code that doesn't use them (i.e. any code that wants to be compatible with OS X 10.6) will work fine.
The current implementation is VERY inefficient and has a large number of missed optimisation opportunities: this is the 'make it right' phase, and should be almost equivalent to explicit retain / release code.
allocations and all deallocations. It's now possible to implement
malloc_history entirely parsing the dump file (or doing /dev/fd style tricks
send it straight to a monitoring process).
registered to be copied on heap assignment. By default, this is just
_NSConcreteStackBlock. Other classes can be registered (LanguageKit should
register BlockClosure to make sure that Smalltalk works).
Fred: This makes the stuff that we discussed briefly at FOSDEM possible in GC
mode: We can allocate a GSStackEvent subclass of NSEvent on the stack. If it
implements a -copy method that returns an NSEvent and is registered with the
runtime in this way, then any code that assigns it anywhere on the heap will
end up implicitly creating a heap copy.
- Add objc_gc_collectable_address() to determine whether a pointer is managed
by the GC
- If LIBOBJC_CANARIES is set (optionally to a random number seed) then store a
canary value after every allocation returned by
objc_gc_allocate_collectable() and, when it is finalised, check that the
canary has not been modified, aborting if it has. This catches some
heap-buffer overflows, and currently causes GNUstep to abort.
- If LIBOBJC_LOG_ALLOCATIONS is set to a file name, log all GC-managed
allocations to that file. This gives something like malloc_history on OS X.
- objc_memmove_collectable() now guarantees that all copied pointers remain
visible to the GC at all times (which was the point of the function - the
original implementation was just a quick stub).
does run-time detection of whether to use GC calls objc_collecting_enabled()
(sometimes indirectly, via NSGarbageCollector) to see if we're in GC mode.
After any of these calls, it is not safe to switch modes.
Store the refcount structures inside the hash table, rather than in a chained structure. This uses less space and should be easier for the GC to scan (less cache used).
- __strong pointers, preventing objects from being freed
_ __weak pointers are automatically freed when the last remaining __strong pointer goes away
- objc_gc_{retain,release}_np() functions, which can be used to implement CFRetain() and CFRelease() (adds an reference count - the object will not be collected until after its last retain is gone.
David Chisnall
theraven
thebeing