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 } 642