gcc/libobjc/sarray.c

524 lines
14 KiB
C
Raw Normal View History

/* Sparse Arrays for Objective C dispatch tables
Copyright (C) 1993-2013 Free Software Foundation, Inc.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
#include "objc-private/common.h"
#include "objc-private/sarray.h"
2010-10-12 18:17:18 +02:00
#include "objc/runtime.h" /* For objc_malloc */
#include "objc/thr.h" /* For objc_mutex_lock */
In libobjc/: 2011-06-07 Nicola Pero <nicola.pero@meta-innovation.com> In libobjc/: 2011-06-07 Nicola Pero <nicola.pero@meta-innovation.com> Removed the Traditional Objective-C runtime public API. * Makefile.in (OBJC_DEPRECATED_H): Variable removed. (install-headers): Do not create the objc/deprecated directory and do not install the deprecated headers. (OBJC_H): Removed encoding.h and objc-api.h. * Object.m: Removed all methods with the exception of -class and -isEqual:. Updated includes. ([-class]): Use Modern API. * objc/Object.h: Do not include deprecated/Object.h. * objc/deprecated/Object.h: Removed. * linking.m (__objc_linking): Call [Object class] instead of [Object name]. * Protocol.m: Removed all methods with the exception of -isEqual:. Updated includes. * objc/Protocol.h: Do not include deprecated/Protocol.h. * objc/deprecated/Protocol.h: Removed. * objc/deprecated/struct_objc_symtab.h: Removed. * objc/deprecated/struct_objc_module.h: Removed. * objc/deprecated/struct_objc_ivar.h: Removed. * objc/deprecated/struct_objc_ivar_list.h: Removed. * objc/deprecated/struct_objc_method.h: Removed. * objc/deprecated/struct_objc_method_list.h: Removed. * objc/deprecated/struct_objc_protocol_list.h: Removed. * objc/deprecated/struct_objc_category.h: Removed. * objc/deprecated/MetaClass.h: Removed. * objc/deprecated/objc_msg_sendv.h: Removed. * objc/deprecated/README: Removed. * objc/deprecated/struct_objc_class.h: Removed. * objc/deprecated/struct_objc_protocol.h: Removed. * objc/deprecated/struct_objc_selector.h: Removed. * objc/encoding.h: Removed. * objc/message.h (struct objc_super): Removed the definition for the Traditional Objective-C runtime API. * objc/objc.h: Do not include objc/objc-decls.h. deprecated/struct_objc_selector.h, deprecated/MetaClass.h, deprecated/struct_objc_class.h, deprecated/struct_objc_protocol.h and deprecated/objc_msg_sendv.h. Uncommented new definition of Protocol *. * objc/objc-api.h: Removed. * objc/runtime.h: Updated comments. Removed check to detect concurrent usage of Traditional and Modern APIs. * objc-private/module-abi-8.h: Always define struct objc_class and struct objc_protocol. (struct objc_protocol_list): Changed type of 'list' argument from 'Protocol *' to 'struct objc_protocol *'. (class_get_instance_size): Added. * objc-private/protocols.h (__objc_protocols_add_protocol): Take a 'struct objc_protocol *' as argument, not a 'Protocol *'. * objc-private/runtime.h: Updated comments. * objc-private/selector.h (struct objc_selector, sel_eq): Added. * class.c: Include objc-private/selector.h. (objc_get_meta_class): Return a Class instead of a MetaClass. * encoding.c (method_get_next_argument): Removed. (method_get_first_argument): Removed. (method_get_nth_argument): Removed. * gc.c: Include objc/runtime.h instead of objc/encoding.h. Include objc-private/module-abi-8.h and ctype.h. * protocols.c (__objc_protocols_add_protocol): Take a 'struct objc_protocl *' as argument, not a 'Protocol *'. (class_addProtocol): Added casts to 'struct objc_protocol *' and 'Protocol *'. (class_copyProtocolList): Likewise. (protocol_conformsToProtocol): Likewise. (protocol_copyProtocolList): Likewise. * sarray.c: Include objc-private/module-abi-8.h. * sendmsg.c (method_get_next_argument): Removed. (method_get_first_argument): Removed. (method_get_nth_argument): Removed. (objc_msg_sendv): Removed. (arglist_t, retval_t): New. (class_get_class_method): Take a 'Class', not 'MetaClass', argument. * thr.c: Include module-abi-8.h. From-SVN: r174765
2011-06-07 21:37:35 +02:00
#include "objc-private/module-abi-8.h"
#include "objc-private/runtime.h"
#include <stdio.h>
#include <string.h> /* For memset */
#include <assert.h> /* For assert */
int nbuckets = 0; /* !T:MUTEX */
int nindices = 0; /* !T:MUTEX */
int narrays = 0; /* !T:MUTEX */
int idxsize = 0; /* !T:MUTEX */
static void *first_free_data = NULL; /* !T:MUTEX */
#ifdef OBJC_SPARSE2
const char *__objc_sparse2_id = "2 level sparse indices";
#endif
#ifdef OBJC_SPARSE3
const char *__objc_sparse3_id = "3 level sparse indices";
#endif
/* This function removes any structures left over from free operations
that were not safe in a multi-threaded environment. */
void
sarray_remove_garbage (void)
{
void **vp;
void *np;
objc_mutex_lock (__objc_runtime_mutex);
vp = first_free_data;
first_free_data = NULL;
while (vp)
{
np = *vp;
objc_free (vp);
vp = np;
}
objc_mutex_unlock (__objc_runtime_mutex);
}
/* Free a block of dynamically allocated memory. If we are in
multi-threaded mode, it is ok to free it. If not, we add it to the
garbage heap to be freed later. */
static void
sarray_free_garbage (void *vp)
{
objc_mutex_lock (__objc_runtime_mutex);
if (__objc_runtime_threads_alive == 1)
{
objc_free (vp);
if (first_free_data)
sarray_remove_garbage ();
}
else
{
*(void **)vp = first_free_data;
first_free_data = vp;
}
objc_mutex_unlock (__objc_runtime_mutex);
}
/* sarray_at_put copies data in such a way as to be thread reader
safe. */
void
sarray_at_put (struct sarray *array, sidx index, void *element)
{
#ifdef OBJC_SPARSE3
struct sindex **the_index;
struct sindex *new_index;
#endif
struct sbucket **the_bucket;
struct sbucket *new_bucket;
#ifdef OBJC_SPARSE3
size_t ioffset;
#endif
size_t boffset;
size_t eoffset;
#ifdef PRECOMPUTE_SELECTORS
union sofftype xx;
xx.idx = index;
#ifdef OBJC_SPARSE3
ioffset = xx.off.ioffset;
#endif
boffset = xx.off.boffset;
eoffset = xx.off.eoffset;
#else /* not PRECOMPUTE_SELECTORS */
#ifdef OBJC_SPARSE3
ioffset = index/INDEX_CAPACITY;
boffset = (index/BUCKET_SIZE)%INDEX_SIZE;
eoffset = index%BUCKET_SIZE;
#else
boffset = index/BUCKET_SIZE;
eoffset = index%BUCKET_SIZE;
#endif
#endif /* not PRECOMPUTE_SELECTORS */
assert (soffset_decode (index) < array->capacity); /* Range check */
#ifdef OBJC_SPARSE3
the_index = &(array->indices[ioffset]);
the_bucket = &((*the_index)->buckets[boffset]);
#else
the_bucket = &(array->buckets[boffset]);
#endif
if ((*the_bucket)->elems[eoffset] == element)
return; /* Great! we just avoided a lazy copy. */
#ifdef OBJC_SPARSE3
/* First, perform lazy copy/allocation of index if needed. */
if ((*the_index) == array->empty_index)
{
/* The index was previously empty, allocate a new. */
new_index = (struct sindex *) objc_malloc (sizeof (struct sindex));
memcpy (new_index, array->empty_index, sizeof (struct sindex));
new_index->version.version = array->version.version;
*the_index = new_index; /* Prepared for install. */
the_bucket = &((*the_index)->buckets[boffset]);
nindices += 1;
}
else if ((*the_index)->version.version != array->version.version)
{
/* This index must be lazy copied. */
struct sindex *old_index = *the_index;
new_index = (struct sindex *) objc_malloc (sizeof (struct sindex));
memcpy (new_index, old_index, sizeof (struct sindex));
new_index->version.version = array->version.version;
*the_index = new_index; /* Prepared for install. */
the_bucket = &((*the_index)->buckets[boffset]);
nindices += 1;
}
#endif /* OBJC_SPARSE3 */
/* Next, perform lazy allocation/copy of the bucket if needed. */
if ((*the_bucket) == array->empty_bucket)
{
/* The bucket was previously empty (or something like that),
allocate a new. This is the effect of `lazy' allocation. */
new_bucket = (struct sbucket *) objc_malloc (sizeof (struct sbucket));
memcpy ((void *) new_bucket, (const void *) array->empty_bucket,
sizeof (struct sbucket));
new_bucket->version.version = array->version.version;
*the_bucket = new_bucket; /* Prepared for install. */
nbuckets += 1;
}
else if ((*the_bucket)->version.version != array->version.version)
{
/* Perform lazy copy. */
struct sbucket *old_bucket = *the_bucket;
new_bucket = (struct sbucket *) objc_malloc (sizeof (struct sbucket));
memcpy (new_bucket, old_bucket, sizeof (struct sbucket));
new_bucket->version.version = array->version.version;
*the_bucket = new_bucket; /* Prepared for install. */
nbuckets += 1;
}
(*the_bucket)->elems[eoffset] = element;
}
void
sarray_at_put_safe (struct sarray *array, sidx index, void *element)
{
if (soffset_decode (index) >= array->capacity)
sarray_realloc (array, soffset_decode (index) + 1);
sarray_at_put (array, index, element);
}
struct sarray *
sarray_new (int size, void *default_element)
{
struct sarray *arr;
#ifdef OBJC_SPARSE3
size_t num_indices = ((size - 1)/(INDEX_CAPACITY)) + 1;
struct sindex **new_indices;
#else /* OBJC_SPARSE2 */
size_t num_indices = ((size - 1)/BUCKET_SIZE) + 1;
struct sbucket **new_buckets;
#endif
size_t counter;
assert (size > 0);
/* Allocate core array. */
arr = (struct sarray *) objc_malloc (sizeof (struct sarray));
arr->version.version = 0;
/* Initialize members. */
#ifdef OBJC_SPARSE3
arr->capacity = num_indices*INDEX_CAPACITY;
new_indices = (struct sindex **)
objc_malloc (sizeof (struct sindex *) * num_indices);
arr->empty_index = (struct sindex *) objc_malloc (sizeof (struct sindex));
arr->empty_index->version.version = 0;
narrays += 1;
idxsize += num_indices;
nindices += 1;
#else /* OBJC_SPARSE2 */
arr->capacity = num_indices*BUCKET_SIZE;
new_buckets = (struct sbucket **)
objc_malloc (sizeof (struct sbucket *) * num_indices);
narrays += 1;
idxsize += num_indices;
#endif
arr->empty_bucket = (struct sbucket *) objc_malloc (sizeof (struct sbucket));
arr->empty_bucket->version.version = 0;
nbuckets += 1;
arr->ref_count = 1;
arr->is_copy_of = (struct sarray *) 0;
for (counter = 0; counter < BUCKET_SIZE; counter++)
arr->empty_bucket->elems[counter] = default_element;
#ifdef OBJC_SPARSE3
for (counter = 0; counter < INDEX_SIZE; counter++)
arr->empty_index->buckets[counter] = arr->empty_bucket;
for (counter = 0; counter < num_indices; counter++)
new_indices[counter] = arr->empty_index;
#else /* OBJC_SPARSE2 */
for (counter = 0; counter < num_indices; counter++)
new_buckets[counter] = arr->empty_bucket;
#endif
#ifdef OBJC_SPARSE3
arr->indices = new_indices;
#else /* OBJC_SPARSE2 */
arr->buckets = new_buckets;
#endif
return arr;
}
/* Reallocate the sparse array to hold `newsize' entries Note: We
really allocate and then free. We have to do this to ensure that
any concurrent readers notice the update. */
void
sarray_realloc (struct sarray *array, int newsize)
{
#ifdef OBJC_SPARSE3
size_t old_max_index = (array->capacity - 1)/INDEX_CAPACITY;
size_t new_max_index = ((newsize - 1)/INDEX_CAPACITY);
size_t rounded_size = (new_max_index + 1) * INDEX_CAPACITY;
struct sindex **new_indices;
struct sindex **old_indices;
#else /* OBJC_SPARSE2 */
size_t old_max_index = (array->capacity - 1)/BUCKET_SIZE;
size_t new_max_index = ((newsize - 1)/BUCKET_SIZE);
size_t rounded_size = (new_max_index + 1) * BUCKET_SIZE;
struct sbucket **new_buckets;
struct sbucket **old_buckets;
#endif
size_t counter;
assert (newsize > 0);
/* The size is the same, just ignore the request. */
if (rounded_size <= array->capacity)
return;
assert (array->ref_count == 1); /* stop if lazy copied... */
/* We are asked to extend the array -- allocate new bucket table,
and insert empty_bucket in newly allocated places. */
if (rounded_size > array->capacity)
{
#ifdef OBJC_SPARSE3
new_max_index += 4;
rounded_size = (new_max_index + 1) * INDEX_CAPACITY;
#else /* OBJC_SPARSE2 */
new_max_index += 4;
rounded_size = (new_max_index + 1) * BUCKET_SIZE;
#endif
/* Update capacity. */
array->capacity = rounded_size;
#ifdef OBJC_SPARSE3
/* Alloc to force re-read by any concurrent readers. */
old_indices = array->indices;
new_indices = (struct sindex **)
objc_malloc ((new_max_index + 1) * sizeof (struct sindex *));
#else /* OBJC_SPARSE2 */
old_buckets = array->buckets;
new_buckets = (struct sbucket **)
objc_malloc ((new_max_index + 1) * sizeof (struct sbucket *));
#endif
/* Copy buckets below old_max_index (they are still valid). */
for (counter = 0; counter <= old_max_index; counter++ )
{
#ifdef OBJC_SPARSE3
new_indices[counter] = old_indices[counter];
#else /* OBJC_SPARSE2 */
new_buckets[counter] = old_buckets[counter];
#endif
}
#ifdef OBJC_SPARSE3
/* Reset entries above old_max_index to empty_bucket. */
for (counter = old_max_index + 1; counter <= new_max_index; counter++)
new_indices[counter] = array->empty_index;
#else /* OBJC_SPARSE2 */
/* Reset entries above old_max_index to empty_bucket. */
for (counter = old_max_index + 1; counter <= new_max_index; counter++)
new_buckets[counter] = array->empty_bucket;
#endif
#ifdef OBJC_SPARSE3
/* Install the new indices. */
array->indices = new_indices;
#else /* OBJC_SPARSE2 */
array->buckets = new_buckets;
#endif
#ifdef OBJC_SPARSE3
/* Free the old indices. */
sarray_free_garbage (old_indices);
#else /* OBJC_SPARSE2 */
sarray_free_garbage (old_buckets);
#endif
idxsize += (new_max_index-old_max_index);
return;
}
}
/* Free a sparse array allocated with sarray_new */
void
sarray_free (struct sarray *array) {
#ifdef OBJC_SPARSE3
size_t old_max_index = (array->capacity - 1)/INDEX_CAPACITY;
struct sindex **old_indices;
#else
size_t old_max_index = (array->capacity - 1)/BUCKET_SIZE;
struct sbucket **old_buckets;
#endif
size_t counter = 0;
assert (array->ref_count != 0); /* Freed multiple times!!! */
if (--(array->ref_count) != 0) /* There exists copies of me */
return;
#ifdef OBJC_SPARSE3
old_indices = array->indices;
#else
old_buckets = array->buckets;
#endif
/* Free all entries that do not point to empty_bucket. */
for (counter = 0; counter <= old_max_index; counter++ )
{
#ifdef OBJC_SPARSE3
struct sindex *idx = old_indices[counter];
if ((idx != array->empty_index)
&& (idx->version.version == array->version.version))
{
int c2;
for (c2 = 0; c2 < INDEX_SIZE; c2++)
{
struct sbucket *bkt = idx->buckets[c2];
if ((bkt != array->empty_bucket)
&& (bkt->version.version == array->version.version))
{
sarray_free_garbage (bkt);
nbuckets -= 1;
}
}
sarray_free_garbage (idx);
nindices -= 1;
}
#else /* OBJC_SPARSE2 */
struct sbucket *bkt = old_buckets[counter];
if ((bkt != array->empty_bucket)
&& (bkt->version.version == array->version.version))
{
sarray_free_garbage (bkt);
nbuckets -= 1;
}
#endif
}
#ifdef OBJC_SPARSE3
/* Free empty_index. */
if (array->empty_index->version.version == array->version.version)
{
sarray_free_garbage (array->empty_index);
nindices -= 1;
}
#endif
/* Free empty_bucket. */
if (array->empty_bucket->version.version == array->version.version)
{
sarray_free_garbage (array->empty_bucket);
nbuckets -= 1;
}
idxsize -= (old_max_index + 1);
narrays -= 1;
#ifdef OBJC_SPARSE3
/* Free bucket table. */
sarray_free_garbage (array->indices);
#else
/* Free bucket table. */
sarray_free_garbage (array->buckets);
#endif
[multiple changes] 2004-05-25 Andrew Pinski <pinskia@physics.uc.edu> Merge from the libobjc-branch 2004-02-09 Andrew Pinski <pinskia@physics.uc.edu> * Makefile.in (OBJC_H): Change objc-deps.h to objc-decls.h. 2004-02-03 Andrew Pinski <pinskia@physics.uc.edu> * Makefile.in (OBJC_H): Add objc-deps.h. 2004-01-27 Nicola Pero <n.pero@mi.flashnet.it> * Protocol.m ([-conformsTo:]): If the argument is nil, return NO. ([-hash], [-isEqual:]): New methods. 2004-01-27 Richard Frith-Macdonald <rfm@gnu.org> * sarray.c (sarray_free): Add a better comment. 2004-01-27 Adam Fedor <fedor@gnu.org> * hash.c (hash_add): Cast cachep to int. * selector.c (__sel_register_typed_name): Cast soffset_decode to int. 2004-01-27 Alexander Malmberg <alexander@malmberg.org> * selector.c: Rename register_selectors_from_list to __objc_register_selectors_from_list. Update caller. (__objc_register_selectors_from_list): Lock __objc_runtime_mutex while registering selectors. Use __sel_register_typed_name instead of sel_register_typed_name. Check for NULL method_name:s. (pool_alloc_selector): New function. (__sel_register_typed_name): Use pool_alloc_selector to allocate selector structures. * sendmsg.c (class_add_method_list): Use __objc_register_selectors_from_list. * objc/runtime.h: Add __objc_register_selectors_from_list. 2004-01-25 Adam Fedor <fedor@gnu.org> Nicola Pero <n.pero@mi.flashnet.it> Andrew Pinski <pinskia@physics.uc.edu> * objc/objc-decls.h: New file. * objc/objc-api.h (_objc_lookup_class): Mark as export. (_objc_load_callback): Likewise. (_objc_object_alloc): Likewise. (_objc_object_copy): Likewise. (_objc_object_dispose): Likewise. 2004-01-25 Andrew Pinski <pinskia@physics.uc.edu> * archive.c: s/__inline__/inline * sendmsg.c: Likewise. * encoding.c: Remove FIXME about the warning about unused variable. * sendmsg.c: Add a FIXME comment saying that this should be using libffi. * Makefile.in (LIBTOOL): Use @LIBTOOL@ now as it works. From-SVN: r82253
2004-05-25 21:10:54 +02:00
/* If this is a copy of another array, we free it (which might just
decrement its reference count so it will be freed when no longer
in use). */
if (array->is_copy_of)
sarray_free (array->is_copy_of);
/* Free array. */
sarray_free_garbage (array);
}
/* This is a lazy copy. Only the core of the structure is actually
copied. */
struct sarray *
sarray_lazy_copy (struct sarray *oarr)
{
struct sarray *arr;
#ifdef OBJC_SPARSE3
size_t num_indices = ((oarr->capacity - 1)/INDEX_CAPACITY) + 1;
struct sindex **new_indices;
#else /* OBJC_SPARSE2 */
size_t num_indices = ((oarr->capacity - 1)/BUCKET_SIZE) + 1;
struct sbucket **new_buckets;
#endif
/* Allocate core array. */
arr = (struct sarray *) objc_malloc (sizeof (struct sarray)); /* !!! */
arr->version.version = oarr->version.version + 1;
#ifdef OBJC_SPARSE3
arr->empty_index = oarr->empty_index;
#endif
arr->empty_bucket = oarr->empty_bucket;
arr->ref_count = 1;
oarr->ref_count += 1;
arr->is_copy_of = oarr;
arr->capacity = oarr->capacity;
#ifdef OBJC_SPARSE3
/* Copy bucket table. */
new_indices = (struct sindex **)
objc_malloc (sizeof (struct sindex *) * num_indices);
memcpy (new_indices, oarr->indices, sizeof (struct sindex *) * num_indices);
arr->indices = new_indices;
#else
/* Copy bucket table. */
new_buckets = (struct sbucket **)
objc_malloc (sizeof (struct sbucket *) * num_indices);
memcpy (new_buckets, oarr->buckets, sizeof (struct sbucket *) * num_indices);
arr->buckets = new_buckets;
#endif
idxsize += num_indices;
narrays += 1;
return arr;
}