240 lines
5.8 KiB
C
240 lines
5.8 KiB
C
/* Sparse Arrays for Objective C dispatch tables
|
||
Copyright (C) 1993, 1995, 1996, 2004, 2009 Free Software Foundation, Inc.
|
||
Contributed by Kresten Krab Thorup.
|
||
|
||
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/>. */
|
||
|
||
#ifndef __sarray_INCLUDE_GNU
|
||
#define __sarray_INCLUDE_GNU
|
||
|
||
#define OBJC_SPARSE2 /* 2-level sparse array */
|
||
/* #define OBJC_SPARSE3 */ /* 3-level sparse array */
|
||
|
||
#ifdef OBJC_SPARSE2
|
||
extern const char* __objc_sparse2_id;
|
||
#endif
|
||
|
||
#ifdef OBJC_SPARSE3
|
||
extern const char* __objc_sparse3_id;
|
||
#endif
|
||
|
||
#include <stddef.h>
|
||
|
||
#ifdef __cplusplus
|
||
extern "C" {
|
||
#endif /* __cplusplus */
|
||
|
||
extern int nbuckets; /* for stats */
|
||
extern int nindices;
|
||
extern int narrays;
|
||
extern int idxsize;
|
||
|
||
/* An unsigned integer of same size as a pointer */
|
||
#define SIZET_BITS (sizeof(size_t)*8)
|
||
|
||
#if defined(__sparc__) || defined(OBJC_SPARSE2)
|
||
#define PRECOMPUTE_SELECTORS
|
||
#endif
|
||
|
||
#ifdef OBJC_SPARSE3
|
||
|
||
/* Buckets are 8 words each */
|
||
#define BUCKET_BITS 3
|
||
#define BUCKET_SIZE (1<<BUCKET_BITS)
|
||
#define BUCKET_MASK (BUCKET_SIZE-1)
|
||
|
||
/* Indices are 16 words each */
|
||
#define INDEX_BITS 4
|
||
#define INDEX_SIZE (1<<INDEX_BITS)
|
||
#define INDEX_MASK (INDEX_SIZE-1)
|
||
|
||
#define INDEX_CAPACITY (BUCKET_SIZE*INDEX_SIZE)
|
||
|
||
#else /* OBJC_SPARSE2 */
|
||
|
||
/* Buckets are 32 words each */
|
||
#define BUCKET_BITS 5
|
||
#define BUCKET_SIZE (1<<BUCKET_BITS)
|
||
#define BUCKET_MASK (BUCKET_SIZE-1)
|
||
|
||
#endif /* OBJC_SPARSE2 */
|
||
|
||
typedef size_t sidx;
|
||
|
||
#ifdef PRECOMPUTE_SELECTORS
|
||
|
||
struct soffset {
|
||
#ifdef OBJC_SPARSE3
|
||
unsigned int unused : SIZET_BITS/4;
|
||
unsigned int eoffset : SIZET_BITS/4;
|
||
unsigned int boffset : SIZET_BITS/4;
|
||
unsigned int ioffset : SIZET_BITS/4;
|
||
#else /* OBJC_SPARSE2 */
|
||
#ifdef __sparc__
|
||
unsigned long boffset : (SIZET_BITS - 2) - BUCKET_BITS;
|
||
unsigned int eoffset : BUCKET_BITS;
|
||
unsigned int unused : 2;
|
||
#else
|
||
unsigned int boffset : SIZET_BITS/2;
|
||
unsigned int eoffset : SIZET_BITS/2;
|
||
#endif
|
||
#endif /* OBJC_SPARSE2 */
|
||
};
|
||
|
||
union sofftype {
|
||
struct soffset off;
|
||
sidx idx;
|
||
};
|
||
|
||
#endif /* not PRECOMPUTE_SELECTORS */
|
||
|
||
union sversion {
|
||
int version;
|
||
void *next_free;
|
||
};
|
||
|
||
struct sbucket {
|
||
void* elems[BUCKET_SIZE]; /* elements stored in array */
|
||
union sversion version; /* used for copy-on-write */
|
||
};
|
||
|
||
#ifdef OBJC_SPARSE3
|
||
|
||
struct sindex {
|
||
struct sbucket* buckets[INDEX_SIZE];
|
||
union sversion version; /* used for copy-on-write */
|
||
};
|
||
|
||
#endif /* OBJC_SPARSE3 */
|
||
|
||
struct sarray {
|
||
#ifdef OBJC_SPARSE3
|
||
struct sindex** indices;
|
||
struct sindex* empty_index;
|
||
#else /* OBJC_SPARSE2 */
|
||
struct sbucket** buckets;
|
||
#endif /* OBJC_SPARSE2 */
|
||
struct sbucket* empty_bucket;
|
||
union sversion version; /* used for copy-on-write */
|
||
short ref_count;
|
||
struct sarray* is_copy_of;
|
||
size_t capacity;
|
||
};
|
||
|
||
struct sarray* sarray_new(int, void* default_element);
|
||
void sarray_free(struct sarray*);
|
||
struct sarray* sarray_lazy_copy(struct sarray*);
|
||
void sarray_realloc(struct sarray*, int new_size);
|
||
void sarray_at_put(struct sarray*, sidx indx, void* elem);
|
||
void sarray_at_put_safe(struct sarray*, sidx indx, void* elem);
|
||
|
||
struct sarray* sarray_hard_copy(struct sarray*); /* ... like the name? */
|
||
void sarray_remove_garbage(void);
|
||
|
||
|
||
#ifdef PRECOMPUTE_SELECTORS
|
||
/* Transform soffset values to ints and vica verca */
|
||
static inline unsigned int
|
||
soffset_decode(sidx indx)
|
||
{
|
||
union sofftype x;
|
||
x.idx = indx;
|
||
#ifdef OBJC_SPARSE3
|
||
return x.off.eoffset
|
||
+ (x.off.boffset*BUCKET_SIZE)
|
||
+ (x.off.ioffset*INDEX_CAPACITY);
|
||
#else /* OBJC_SPARSE2 */
|
||
return x.off.eoffset + (x.off.boffset*BUCKET_SIZE);
|
||
#endif /* OBJC_SPARSE2 */
|
||
}
|
||
|
||
static inline sidx
|
||
soffset_encode(size_t offset)
|
||
{
|
||
union sofftype x;
|
||
x.off.eoffset = offset%BUCKET_SIZE;
|
||
#ifdef OBJC_SPARSE3
|
||
x.off.boffset = (offset/BUCKET_SIZE)%INDEX_SIZE;
|
||
x.off.ioffset = offset/INDEX_CAPACITY;
|
||
#else /* OBJC_SPARSE2 */
|
||
x.off.boffset = offset/BUCKET_SIZE;
|
||
#endif
|
||
return (sidx)x.idx;
|
||
}
|
||
|
||
#else /* not PRECOMPUTE_SELECTORS */
|
||
|
||
static inline size_t
|
||
soffset_decode(sidx indx)
|
||
{
|
||
return indx;
|
||
}
|
||
|
||
static inline sidx
|
||
soffset_encode(size_t offset)
|
||
{
|
||
return offset;
|
||
}
|
||
#endif /* not PRECOMPUTE_SELECTORS */
|
||
|
||
/* Get element from the Sparse array `array' at offset `indx' */
|
||
|
||
static inline void* sarray_get(struct sarray* array, sidx indx)
|
||
{
|
||
#ifdef PRECOMPUTE_SELECTORS
|
||
union sofftype x;
|
||
x.idx = indx;
|
||
#ifdef OBJC_SPARSE3
|
||
return
|
||
array->
|
||
indices[x.off.ioffset]->
|
||
buckets[x.off.boffset]->
|
||
elems[x.off.eoffset];
|
||
#else /* OBJC_SPARSE2 */
|
||
return array->buckets[x.off.boffset]->elems[x.off.eoffset];
|
||
#endif /* OBJC_SPARSE2 */
|
||
#else /* not PRECOMPUTE_SELECTORS */
|
||
#ifdef OBJC_SPARSE3
|
||
return array->
|
||
indices[indx/INDEX_CAPACITY]->
|
||
buckets[(indx/BUCKET_SIZE)%INDEX_SIZE]->
|
||
elems[indx%BUCKET_SIZE];
|
||
#else /* OBJC_SPARSE2 */
|
||
return array->buckets[indx/BUCKET_SIZE]->elems[indx%BUCKET_SIZE];
|
||
#endif /* not OBJC_SPARSE3 */
|
||
#endif /* not PRECOMPUTE_SELECTORS */
|
||
}
|
||
|
||
static inline void* sarray_get_safe(struct sarray* array, sidx indx)
|
||
{
|
||
if(soffset_decode(indx) < array->capacity)
|
||
return sarray_get(array, indx);
|
||
else
|
||
return (array->empty_bucket->elems[0]);
|
||
}
|
||
|
||
#ifdef __cplusplus
|
||
}
|
||
#endif /* __cplusplus */
|
||
|
||
#endif /* __sarray_INCLUDE_GNU */
|