gcc/
[official-gcc.git] / libobjc / selector.c
blob55ca7064bd2c80c3fc62de282464fc63a2673faf
1 /* GNU Objective C Runtime selector related functions
2 Copyright (C) 1993, 1995, 1996, 1997, 2002, 2004, 2009, 2010
3 Free Software Foundation, Inc.
4 Contributed by Kresten Krab Thorup
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under the
9 terms of the GNU General Public License as published by the Free Software
10 Foundation; either version 3, or (at your option) any later version.
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
14 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
15 details.
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 <http://www.gnu.org/licenses/>. */
26 #include "objc-private/common.h"
27 #include "objc/runtime.h"
28 #include "objc/thr.h"
29 #include "objc-private/hash.h"
30 #include "objc-private/objc-list.h"
31 #include "objc-private/module-abi-8.h"
32 #include "objc-private/runtime.h"
33 #include "objc-private/sarray.h"
34 #include "objc-private/selector.h"
35 #include <stdlib.h> /* For malloc. */
37 /* Initial selector hash table size. Value doesn't matter much. */
38 #define SELECTOR_HASH_SIZE 128
40 /* Tables mapping selector names to uid and opposite. */
41 static struct sarray *__objc_selector_array = 0; /* uid -> sel !T:MUTEX */
42 static struct sarray *__objc_selector_names = 0; /* uid -> name !T:MUTEX */
43 static cache_ptr __objc_selector_hash = 0; /* name -> uid !T:MUTEX */
45 /* Number of selectors stored in each of the above tables. */
46 unsigned int __objc_selector_max_index = 0; /* !T:MUTEX */
48 /* Forward-declare an internal function. */
49 static SEL
50 __sel_register_typed_name (const char *name, const char *types,
51 struct objc_selector *orig, BOOL is_const);
53 void __objc_init_selector_tables (void)
55 __objc_selector_array = sarray_new (SELECTOR_HASH_SIZE, 0);
56 __objc_selector_names = sarray_new (SELECTOR_HASH_SIZE, 0);
57 __objc_selector_hash
58 = objc_hash_new (SELECTOR_HASH_SIZE,
59 (hash_func_type) objc_hash_string,
60 (compare_func_type) objc_compare_strings);
63 /* Register a bunch of selectors from the table of selectors in a
64 module. 'selectors' should not be NULL. The list is terminated by
65 a selectors with a NULL sel_id. The selectors are assumed to
66 contain the 'name' in the sel_id field; this is replaced with the
67 final selector id after they are registered. */
68 void
69 __objc_register_selectors_from_module (struct objc_selector *selectors)
71 int i;
73 for (i = 0; selectors[i].sel_id; ++i)
75 const char *name, *type;
76 name = (char *) selectors[i].sel_id;
77 type = (char *) selectors[i].sel_types;
78 /* Constructors are constant static data and we can safely store
79 pointers to them in the runtime structures, so we set
80 is_const == YES. */
81 __sel_register_typed_name (name, type, (struct objc_selector *) &(selectors[i]),
82 /* is_const */ YES);
86 /* This routine is given a class and records all of the methods in its
87 class structure in the record table. */
88 void
89 __objc_register_selectors_from_class (Class class)
91 struct objc_method_list * method_list;
93 method_list = class->methods;
94 while (method_list)
96 __objc_register_selectors_from_list (method_list);
97 method_list = method_list->method_next;
102 /* This routine is given a list of methods and records each of the
103 methods in the record table. This is the routine that does the
104 actual recording work.
106 The name and type pointers in the method list must be permanent and
107 immutable. */
108 void
109 __objc_register_selectors_from_list (struct objc_method_list *method_list)
111 int i = 0;
113 objc_mutex_lock (__objc_runtime_mutex);
114 while (i < method_list->method_count)
116 Method method = &method_list->method_list[i];
117 if (method->method_name)
119 method->method_name
120 = __sel_register_typed_name ((const char *) method->method_name,
121 method->method_types, 0, YES);
123 i += 1;
125 objc_mutex_unlock (__objc_runtime_mutex);
128 /* The same as __objc_register_selectors_from_list, but works on a
129 struct objc_method_description_list* instead of a struct
130 objc_method_list*. This is only used for protocols, which have
131 lists of method descriptions, not methods. */
132 void
133 __objc_register_selectors_from_description_list
134 (struct objc_method_description_list *method_list)
136 int i = 0;
138 objc_mutex_lock (__objc_runtime_mutex);
139 while (i < method_list->count)
141 struct objc_method_description *method = &method_list->list[i];
142 if (method->name)
144 method->name
145 = __sel_register_typed_name ((const char *) method->name,
146 method->types, 0, YES);
148 i += 1;
150 objc_mutex_unlock (__objc_runtime_mutex);
153 /* Register instance methods as class methods for root classes. */
154 void __objc_register_instance_methods_to_class (Class class)
156 struct objc_method_list *method_list;
157 struct objc_method_list *class_method_list;
158 int max_methods_no = 16;
159 struct objc_method_list *new_list;
160 Method curr_method;
162 /* Only if a root class. */
163 if (class->super_class)
164 return;
166 /* Allocate a method list to hold the new class methods. */
167 new_list = objc_calloc (sizeof (struct objc_method_list)
168 + sizeof (struct objc_method[max_methods_no]), 1);
169 method_list = class->methods;
170 class_method_list = class->class_pointer->methods;
171 curr_method = &new_list->method_list[0];
173 /* Iterate through the method lists for the class. */
174 while (method_list)
176 int i;
178 /* Iterate through the methods from this method list. */
179 for (i = 0; i < method_list->method_count; i++)
181 Method mth = &method_list->method_list[i];
182 if (mth->method_name
183 && ! search_for_method_in_list (class_method_list,
184 mth->method_name))
186 /* This instance method isn't a class method. Add it
187 into the new_list. */
188 *curr_method = *mth;
190 /* Reallocate the method list if necessary. */
191 if (++new_list->method_count == max_methods_no)
192 new_list =
193 objc_realloc (new_list, sizeof (struct objc_method_list)
194 + sizeof (struct
195 objc_method[max_methods_no += 16]));
196 curr_method = &new_list->method_list[new_list->method_count];
200 method_list = method_list->method_next;
203 /* If we created any new class methods then attach the method list
204 to the class. */
205 if (new_list->method_count)
207 new_list =
208 objc_realloc (new_list, sizeof (struct objc_method_list)
209 + sizeof (struct objc_method[new_list->method_count]));
210 new_list->method_next = class->class_pointer->methods;
211 class->class_pointer->methods = new_list;
213 else
214 objc_free(new_list);
216 __objc_update_dispatch_table_for_class (class->class_pointer);
219 BOOL
220 sel_isEqual (SEL s1, SEL s2)
222 if (s1 == 0 || s2 == 0)
223 return s1 == s2;
224 else
225 return s1->sel_id == s2->sel_id;
228 /* Return YES iff t1 and t2 have same method types. Ignore the
229 argframe layout. */
230 static BOOL
231 sel_types_match (const char *t1, const char *t2)
233 if (! t1 || ! t2)
234 return NO;
235 while (*t1 && *t2)
237 if (*t1 == '+') t1++;
238 if (*t2 == '+') t2++;
239 while (isdigit ((unsigned char) *t1)) t1++;
240 while (isdigit ((unsigned char) *t2)) t2++;
241 /* xxx Remove these next two lines when qualifiers are put in
242 all selectors, not just Protocol selectors. */
243 t1 = objc_skip_type_qualifiers (t1);
244 t2 = objc_skip_type_qualifiers (t2);
245 if (! *t1 && ! *t2)
246 return YES;
247 if (*t1 != *t2)
248 return NO;
249 t1++;
250 t2++;
252 return NO;
255 /* Return selector representing name. */
257 sel_get_any_uid (const char *name)
259 struct objc_list *l;
260 sidx i;
262 objc_mutex_lock (__objc_runtime_mutex);
264 i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
265 if (soffset_decode (i) == 0)
267 objc_mutex_unlock (__objc_runtime_mutex);
268 return 0;
271 l = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
272 objc_mutex_unlock (__objc_runtime_mutex);
274 if (l == 0)
275 return 0;
277 return (SEL) l->head;
281 sel_getTypedSelector (const char *name)
283 sidx i;
285 if (name == NULL)
286 return NULL;
288 objc_mutex_lock (__objc_runtime_mutex);
290 /* Look for a typed selector. */
291 i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
292 if (i != 0)
294 struct objc_list *l;
295 SEL returnValue = NULL;
297 for (l = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
298 l; l = l->tail)
300 SEL s = (SEL) l->head;
301 if (s->sel_types)
303 if (returnValue == NULL)
305 /* First typed selector that we find. Keep it in
306 returnValue, but keep checking as we want to
307 detect conflicts. */
308 returnValue = s;
310 else
312 /* We had already found a typed selectors, so we
313 have multiple ones. Double-check that they have
314 different types, just in case for some reason we
315 got duplicates with the same types. If so, it's
316 OK, we'll ignore the duplicate. */
317 if (returnValue->sel_types == s->sel_types)
318 continue;
319 else if (sel_types_match (returnValue->sel_types, s->sel_types))
320 continue;
321 else
323 /* The types of the two selectors are different;
324 it's a conflict. Too bad. Return NULL. */
325 objc_mutex_unlock (__objc_runtime_mutex);
326 return NULL;
332 if (returnValue != NULL)
334 objc_mutex_unlock (__objc_runtime_mutex);
335 return returnValue;
339 /* No typed selector found. Return NULL. */
340 objc_mutex_unlock (__objc_runtime_mutex);
341 return 0;
344 SEL *
345 sel_copyTypedSelectorList (const char *name, unsigned int *numberOfReturnedSelectors)
347 unsigned int count = 0;
348 SEL *returnValue = NULL;
349 sidx i;
351 if (name == NULL)
353 if (numberOfReturnedSelectors)
354 *numberOfReturnedSelectors = 0;
355 return NULL;
358 objc_mutex_lock (__objc_runtime_mutex);
360 /* Count how many selectors we have. */
361 i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
362 if (i != 0)
364 struct objc_list *selector_list = NULL;
365 selector_list = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
367 /* Count how many selectors we have. */
369 struct objc_list *l;
370 for (l = selector_list; l; l = l->tail)
371 count++;
374 if (count != 0)
376 /* Allocate enough memory to hold them. */
377 returnValue = (SEL *)(malloc (sizeof (SEL) * (count + 1)));
379 /* Copy the selectors. */
381 unsigned int j;
382 for (j = 0; j < count; j++)
384 returnValue[j] = (SEL)(selector_list->head);
385 selector_list = selector_list->tail;
387 returnValue[j] = NULL;
392 objc_mutex_unlock (__objc_runtime_mutex);
394 if (numberOfReturnedSelectors)
395 *numberOfReturnedSelectors = count;
397 return returnValue;
400 /* Get the name of a selector. If the selector is unknown, the empty
401 string "" is returned. */
402 const char *sel_getName (SEL selector)
404 const char *ret;
406 if (selector == NULL)
407 return "<null selector>";
409 objc_mutex_lock (__objc_runtime_mutex);
410 if ((soffset_decode ((sidx)selector->sel_id) > 0)
411 && (soffset_decode ((sidx)selector->sel_id) <= __objc_selector_max_index))
412 ret = sarray_get_safe (__objc_selector_names, (sidx) selector->sel_id);
413 else
414 ret = 0;
415 objc_mutex_unlock (__objc_runtime_mutex);
416 return ret;
419 BOOL
420 sel_is_mapped (SEL selector)
422 unsigned int idx = soffset_decode ((sidx)selector->sel_id);
423 return ((idx > 0) && (idx <= __objc_selector_max_index));
426 const char *sel_getTypeEncoding (SEL selector)
428 if (selector)
429 return selector->sel_types;
430 else
431 return 0;
434 /* The uninstalled dispatch table. */
435 extern struct sarray *__objc_uninstalled_dtable;
437 /* __sel_register_typed_name allocates lots of struct objc_selector:s
438 of 8 (16, if pointers are 64 bits) bytes at startup. To reduce the
439 number of malloc calls and memory lost to malloc overhead, we
440 allocate objc_selector:s in blocks here. This is only called from
441 __sel_register_typed_name, and __sel_register_typed_name may only
442 be called when __objc_runtime_mutex is locked.
444 Note that the objc_selector:s allocated from
445 __sel_register_typed_name are never freed.
447 62 because 62 * sizeof (struct objc_selector) = 496 (992). This
448 should let malloc add some overhead and use a nice, round 512
449 (1024) byte chunk. */
450 #define SELECTOR_POOL_SIZE 62
451 static struct objc_selector *selector_pool;
452 static int selector_pool_left;
454 static struct objc_selector *
455 pool_alloc_selector(void)
457 if (!selector_pool_left)
459 selector_pool = objc_malloc (sizeof (struct objc_selector)
460 * SELECTOR_POOL_SIZE);
461 selector_pool_left = SELECTOR_POOL_SIZE;
463 return &selector_pool[--selector_pool_left];
466 /* Store the passed selector name in the selector record and return
467 its selector value (value returned by sel_get_uid). Assume that
468 the calling function has locked down __objc_runtime_mutex. The
469 'is_const' parameter tells us if the name and types parameters are
470 really constant or not. If YES then they are constant and we can
471 just store the pointers. If NO then we need to copy name and types
472 because the pointers may disappear later on. If the 'orig'
473 parameter is not NULL, then we are registering a selector from a
474 module, and 'orig' is that selector. In this case, we can put the
475 selector in the tables if needed, and orig->sel_id is updated with
476 the selector ID of the registered selector, and 'orig' is
477 returned. */
478 static SEL
479 __sel_register_typed_name (const char *name, const char *types,
480 struct objc_selector *orig, BOOL is_const)
482 struct objc_selector *j;
483 sidx i;
484 struct objc_list *l;
486 i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
487 if (soffset_decode (i) != 0)
489 /* There are already selectors with that name. Examine them to
490 see if the one we're registering already exists. */
491 for (l = (struct objc_list *)sarray_get_safe (__objc_selector_array, i);
492 l; l = l->tail)
494 SEL s = (SEL)l->head;
495 if (types == 0 || s->sel_types == 0)
497 if (s->sel_types == types)
499 if (orig)
501 orig->sel_id = (void *)i;
502 return orig;
504 else
505 return s;
508 else if (sel_types_match (s->sel_types, types))
510 if (orig)
512 orig->sel_id = (void *)i;
513 return orig;
515 else
516 return s;
519 /* A selector with this specific name/type combination does not
520 exist yet. We need to register it. */
521 if (orig)
522 j = orig;
523 else
524 j = pool_alloc_selector ();
526 j->sel_id = (void *)i;
527 /* Can we use the pointer or must we copy types ? Don't copy if
528 NULL. */
529 if ((is_const) || (types == 0))
530 j->sel_types = types;
531 else
533 j->sel_types = (char *)objc_malloc (strlen (types) + 1);
534 strcpy ((char *)j->sel_types, types);
536 l = (struct objc_list *)sarray_get_safe (__objc_selector_array, i);
538 else
540 /* There are no other selectors with this name registered in the
541 runtime tables. */
542 const char *new_name;
544 /* Determine i. */
545 __objc_selector_max_index += 1;
546 i = soffset_encode (__objc_selector_max_index);
548 /* Prepare the selector. */
549 if (orig)
550 j = orig;
551 else
552 j = pool_alloc_selector ();
554 j->sel_id = (void *)i;
555 /* Can we use the pointer or must we copy types ? Don't copy if
556 NULL. */
557 if (is_const || (types == 0))
558 j->sel_types = types;
559 else
561 j->sel_types = (char *)objc_malloc (strlen (types) + 1);
562 strcpy ((char *)j->sel_types, types);
565 /* Since this is the first selector with this name, we need to
566 register the correspondence between 'i' (the sel_id) and
567 'name' (the actual string) in __objc_selector_names and
568 __objc_selector_hash. */
570 /* Can we use the pointer or must we copy name ? Don't copy if
571 NULL. (FIXME: Can the name really be NULL here ?) */
572 if (is_const || (name == 0))
573 new_name = name;
574 else
576 new_name = (char *)objc_malloc (strlen (name) + 1);
577 strcpy ((char *)new_name, name);
580 /* This maps the sel_id to the name. */
581 sarray_at_put_safe (__objc_selector_names, i, (void *)new_name);
583 /* This maps the name to the sel_id. */
584 objc_hash_add (&__objc_selector_hash, (void *)new_name, (void *)i);
586 l = 0;
589 DEBUG_PRINTF ("Record selector %s[%s] as: %ld\n", name, types,
590 (long)soffset_decode (i));
592 /* Now add the selector to the list of selectors with that id. */
593 l = list_cons ((void *)j, l);
594 sarray_at_put_safe (__objc_selector_array, i, (void *)l);
596 sarray_realloc (__objc_uninstalled_dtable, __objc_selector_max_index + 1);
598 return (SEL)j;
602 sel_registerName (const char *name)
604 SEL ret;
606 if (name == NULL)
607 return NULL;
609 objc_mutex_lock (__objc_runtime_mutex);
610 /* Assume that name is not constant static memory and needs to be
611 copied before put into a runtime structure. is_const == NO. */
612 ret = __sel_register_typed_name (name, 0, 0, NO);
613 objc_mutex_unlock (__objc_runtime_mutex);
615 return ret;
619 sel_registerTypedName (const char *name, const char *type)
621 SEL ret;
623 if (name == NULL)
624 return NULL;
626 objc_mutex_lock (__objc_runtime_mutex);
627 /* Assume that name and type are not constant static memory and need
628 to be copied before put into a runtime structure. is_const ==
629 NO. */
630 ret = __sel_register_typed_name (name, type, 0, NO);
631 objc_mutex_unlock (__objc_runtime_mutex);
633 return ret;
636 /* Return the selector representing name. */
638 sel_getUid (const char *name)
640 return sel_registerTypedName (name, 0);