OSDN Git Service

PR ada/60703
[pf3gnuchains/gcc-fork.git] / libobjc / selector.c
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
5
6 This file is part of GCC.
7
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.
11
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.
16
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.
20
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/>.  */
25
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.  */
36
37 /* Initial selector hash table size. Value doesn't matter much.  */
38 #define SELECTOR_HASH_SIZE 128
39
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 */
44
45 /* Number of selectors stored in each of the above tables.  */
46 unsigned int __objc_selector_max_index = 0;     /* !T:MUTEX */
47
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);
52
53 void __objc_init_selector_tables (void)
54 {
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);
61 }  
62
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)
70 {
71   int i;
72
73   for (i = 0; selectors[i].sel_id; ++i)
74     {
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);
83     }
84 }
85
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)
90 {
91   struct objc_method_list * method_list;
92
93   method_list = class->methods;
94   while (method_list)
95     {
96       __objc_register_selectors_from_list (method_list);
97       method_list = method_list->method_next;
98     }
99 }
100
101
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.
105
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)
110 {
111   int i = 0;
112
113   objc_mutex_lock (__objc_runtime_mutex);
114   while (i < method_list->method_count)
115     {
116       Method method = &method_list->method_list[i];
117       if (method->method_name)
118         {
119           method->method_name
120             = __sel_register_typed_name ((const char *) method->method_name,
121                                          method->method_types, 0, YES);
122         }
123       i += 1;
124     }
125   objc_mutex_unlock (__objc_runtime_mutex);
126 }
127
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)
135 {
136   int i = 0;
137   
138   objc_mutex_lock (__objc_runtime_mutex);
139   while (i < method_list->count)
140     {
141       struct objc_method_description *method = &method_list->list[i];
142       if (method->name)
143         {
144           method->name
145             = __sel_register_typed_name ((const char *) method->name,
146                                          method->types, 0, YES);
147         }
148       i += 1;
149     }
150   objc_mutex_unlock (__objc_runtime_mutex);
151 }
152
153 /* Register instance methods as class methods for root classes.  */
154 void __objc_register_instance_methods_to_class (Class class)
155 {
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;
161
162   /* Only if a root class. */
163   if (class->super_class)
164     return;
165
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];
172   
173   /* Iterate through the method lists for the class.  */
174   while (method_list)
175     {
176       int i;
177       
178       /* Iterate through the methods from this method list.  */
179       for (i = 0; i < method_list->method_count; i++)
180         {
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))
185             {
186               /* This instance method isn't a class method.  Add it
187                  into the new_list. */
188               *curr_method = *mth;
189               
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];
197             }
198         }
199
200       method_list = method_list->method_next;
201     }
202
203   /* If we created any new class methods then attach the method list
204      to the class.  */
205   if (new_list->method_count)
206     {
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;
212     }
213   else
214     objc_free(new_list);
215   
216   __objc_update_dispatch_table_for_class (class->class_pointer);
217 }
218
219 BOOL
220 sel_isEqual (SEL s1, SEL s2)
221 {
222   if (s1 == 0 || s2 == 0)
223     return s1 == s2;
224   else
225     return s1->sel_id == s2->sel_id;
226 }
227
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)
232 {
233   if (! t1 || ! t2)
234     return NO;
235   while (*t1 && *t2)
236     {
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++;
251     }
252   return NO;
253 }
254
255 /* Return selector representing name.  */
256 SEL
257 sel_get_any_uid (const char *name)
258 {
259   struct objc_list *l;
260   sidx i;
261
262   objc_mutex_lock (__objc_runtime_mutex);
263
264   i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
265   if (soffset_decode (i) == 0)
266     {
267       objc_mutex_unlock (__objc_runtime_mutex);
268       return 0;
269     }
270
271   l = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
272   objc_mutex_unlock (__objc_runtime_mutex);
273
274   if (l == 0)
275     return 0;
276
277   return (SEL) l->head;
278 }
279
280 SEL
281 sel_getTypedSelector (const char *name)
282 {
283   sidx i;
284
285   if (name == NULL)
286     return NULL;
287   
288   objc_mutex_lock (__objc_runtime_mutex);
289   
290   /* Look for a typed selector.  */
291   i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
292   if (i != 0)
293     {
294       struct objc_list *l;
295       SEL returnValue = NULL;
296
297       for (l = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
298            l; l = l->tail)
299         {
300           SEL s = (SEL) l->head;
301           if (s->sel_types)
302             {
303               if (returnValue == NULL)
304                 {
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;
309                 }
310               else
311                 {
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
322                     {
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;
327                     }
328                 }
329             }
330         }
331
332       if (returnValue != NULL)
333         {
334           objc_mutex_unlock (__objc_runtime_mutex);
335           return returnValue;
336         }
337     }
338
339   /* No typed selector found.  Return NULL.  */
340   objc_mutex_unlock (__objc_runtime_mutex);
341   return 0;
342 }
343
344 SEL *
345 sel_copyTypedSelectorList (const char *name, unsigned int *numberOfReturnedSelectors)
346 {
347   unsigned int count = 0;
348   SEL *returnValue = NULL;
349   sidx i;
350   
351   if (name == NULL)
352     {
353       if (numberOfReturnedSelectors)
354         *numberOfReturnedSelectors = 0;
355       return NULL;
356     }
357
358   objc_mutex_lock (__objc_runtime_mutex);
359
360   /* Count how many selectors we have.  */
361   i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
362   if (i != 0)
363     {
364       struct objc_list *selector_list = NULL;
365       selector_list = (struct objc_list *) sarray_get_safe (__objc_selector_array, i);
366
367       /* Count how many selectors we have.  */
368       {
369         struct objc_list *l;
370         for (l = selector_list; l; l = l->tail)
371           count++;
372       }
373
374       if (count != 0)
375         {
376           /* Allocate enough memory to hold them.  */
377           returnValue = (SEL *)(malloc (sizeof (SEL) * (count + 1)));
378           
379           /* Copy the selectors.  */
380           {
381             unsigned int j;
382             for (j = 0; j < count; j++)
383               {
384                 returnValue[j] = (SEL)(selector_list->head);
385                 selector_list = selector_list->tail;
386               }
387             returnValue[j] = NULL;
388           }
389         }
390     }      
391
392   objc_mutex_unlock (__objc_runtime_mutex);
393   
394   if (numberOfReturnedSelectors)
395     *numberOfReturnedSelectors = count;
396   
397   return returnValue;
398 }
399
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)
403 {
404   const char *ret;
405
406   if (selector == NULL)
407     return "<null selector>";
408   
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;
417 }
418
419 BOOL
420 sel_is_mapped (SEL selector)
421 {
422   unsigned int idx = soffset_decode ((sidx)selector->sel_id);
423   return ((idx > 0) && (idx <= __objc_selector_max_index));
424 }
425
426 const char *sel_getTypeEncoding (SEL selector)
427 {
428   if (selector)
429     return selector->sel_types;
430   else
431     return 0;
432 }
433
434 /* The uninstalled dispatch table.  */
435 extern struct sarray *__objc_uninstalled_dtable;
436
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.
443
444    Note that the objc_selector:s allocated from
445    __sel_register_typed_name are never freed.
446
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;
453
454 static struct objc_selector *
455 pool_alloc_selector(void)
456 {
457   if (!selector_pool_left)
458     {
459       selector_pool = objc_malloc (sizeof (struct objc_selector)
460                                    * SELECTOR_POOL_SIZE);
461       selector_pool_left = SELECTOR_POOL_SIZE;
462     }
463   return &selector_pool[--selector_pool_left];
464 }
465
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)
481 {
482   struct objc_selector *j;
483   sidx i;
484   struct objc_list *l;
485
486   i = (sidx) objc_hash_value_for_key (__objc_selector_hash, name);
487   if (soffset_decode (i) != 0)
488     {
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)
493         {
494           SEL s = (SEL)l->head;
495           if (types == 0 || s->sel_types == 0)
496             {
497               if (s->sel_types == types)
498                 {
499                   if (orig)
500                     {
501                       orig->sel_id = (void *)i;
502                       return orig;
503                     }
504                   else
505                     return s;
506                 }
507             }
508           else if (sel_types_match (s->sel_types, types))
509             {
510               if (orig)
511                 {
512                   orig->sel_id = (void *)i;
513                   return orig;
514                 }
515               else
516                 return s;
517             }
518         }
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 ();
525       
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
532         {
533           j->sel_types = (char *)objc_malloc (strlen (types) + 1);
534           strcpy ((char *)j->sel_types, types);
535         }
536       l = (struct objc_list *)sarray_get_safe (__objc_selector_array, i);
537     }
538   else
539     {
540       /* There are no other selectors with this name registered in the
541          runtime tables.  */
542       const char *new_name;
543
544       /* Determine i.  */
545       __objc_selector_max_index += 1;
546       i = soffset_encode (__objc_selector_max_index);
547
548       /* Prepare the selector.  */
549       if (orig)
550         j = orig;
551       else
552         j = pool_alloc_selector ();
553       
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
560         {
561           j->sel_types = (char *)objc_malloc (strlen (types) + 1);
562           strcpy ((char *)j->sel_types, types);
563         }
564
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.  */
569       
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
575         {
576           new_name = (char *)objc_malloc (strlen (name) + 1);
577           strcpy ((char *)new_name, name);
578         }
579       
580       /* This maps the sel_id to the name.  */
581       sarray_at_put_safe (__objc_selector_names, i, (void *)new_name);
582
583       /* This maps the name to the sel_id.  */
584       objc_hash_add (&__objc_selector_hash, (void *)new_name, (void *)i);
585
586       l = 0;
587     }
588
589   DEBUG_PRINTF ("Record selector %s[%s] as: %ld\n", name, types, 
590                 (long)soffset_decode (i));
591
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);
595
596   sarray_realloc (__objc_uninstalled_dtable, __objc_selector_max_index + 1);
597   
598   return (SEL)j;
599 }
600
601 SEL
602 sel_registerName (const char *name)
603 {
604   SEL ret;
605
606   if (name == NULL)
607     return NULL;
608     
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);
614   
615   return ret;
616 }
617
618 SEL
619 sel_registerTypedName (const char *name, const char *type)
620 {
621   SEL ret;
622
623   if (name == NULL)
624     return NULL;
625
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);
632   
633   return ret;
634 }
635
636 /* Return the selector representing name.  */
637 SEL
638 sel_getUid (const char *name)
639 {
640   return sel_registerTypedName (name, 0);
641 }