PR lto/49123
[official-gcc.git] / libobjc / sendmsg.c
blob0cb375db39ba0113a3f8aa48c426a58fb01f6152
1 /* GNU Objective C Runtime message lookup
2 Copyright (C) 1993, 1995, 1996, 1997, 1998,
3 2001, 2002, 2004, 2009, 2010 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 /* Uncommented the following line to enable debug logging. Use this
27 only while debugging the runtime. */
28 /* #define DEBUG 1 */
30 /* FIXME: This file has no business including tm.h. */
31 /* FIXME: This should be using libffi instead of __builtin_apply
32 and friends. */
34 #include "objc-private/common.h"
35 #include "objc-private/error.h"
36 #include "tconfig.h"
37 #include "coretypes.h"
38 #include "tm.h"
39 #include "objc/runtime.h"
40 #include "objc/message.h" /* For objc_msg_lookup(), objc_msg_lookup_super(). */
41 #include "objc/thr.h"
42 #include "objc-private/module-abi-8.h"
43 #include "objc-private/runtime.h"
44 #include "objc-private/sarray.h"
45 #include "objc-private/selector.h" /* For sel_is_mapped() */
46 #include "runtime-info.h"
47 #include <assert.h> /* For assert */
48 #include <string.h> /* For strlen */
50 /* This is how we hack STRUCT_VALUE to be 1 or 0. */
51 #define gen_rtx(args...) 1
52 #define gen_rtx_MEM(args...) 1
53 #define gen_rtx_REG(args...) 1
54 /* Already defined in gcc/coretypes.h. So prevent double definition warning. */
55 #undef rtx
56 #define rtx int
58 #if ! defined (STRUCT_VALUE) || STRUCT_VALUE == 0
59 #define INVISIBLE_STRUCT_RETURN 1
60 #else
61 #define INVISIBLE_STRUCT_RETURN 0
62 #endif
64 /* The uninstalled dispatch table. */
65 struct sarray *__objc_uninstalled_dtable = 0; /* !T:MUTEX */
67 /* Two hooks for method forwarding. If either is set, it is invoked to
68 * return a function that performs the real forwarding. If both are
69 * set, the result of __objc_msg_forward2 will be preferred over that
70 * of __objc_msg_forward. If both return NULL or are unset, the
71 * libgcc based functions (__builtin_apply and friends) are used. */
72 IMP (*__objc_msg_forward) (SEL) = NULL;
73 IMP (*__objc_msg_forward2) (id, SEL) = NULL;
75 /* Send +initialize to class. */
76 static void __objc_send_initialize (Class);
78 static void __objc_install_dispatch_table_for_class (Class);
80 /* Forward declare some functions. */
81 static void __objc_init_install_dtable (id, SEL);
83 /* Various forwarding functions that are used based upon the
84 return type for the selector.
85 __objc_block_forward for structures.
86 __objc_double_forward for floats/doubles.
87 __objc_word_forward for pointers or types that fit in registers. */
88 static double __objc_double_forward (id, SEL, ...);
89 static id __objc_word_forward (id, SEL, ...);
90 typedef struct { id many[8]; } __big;
91 #if INVISIBLE_STRUCT_RETURN
92 static __big
93 #else
94 static id
95 #endif
96 __objc_block_forward (id, SEL, ...);
97 static struct objc_method * search_for_method_in_hierarchy (Class class, SEL sel);
98 struct objc_method * search_for_method_in_list (struct objc_method_list * list, SEL op);
99 id nil_method (id, SEL);
101 /* Given a selector, return the proper forwarding implementation. */
102 inline
104 __objc_get_forward_imp (id rcv, SEL sel)
106 /* If a custom forwarding hook was registered, try getting a
107 forwarding function from it. There are two forward routine hooks,
108 one that takes the receiver as an argument and one that does
109 not. */
110 if (__objc_msg_forward2)
112 IMP result;
113 if ((result = __objc_msg_forward2 (rcv, sel)) != NULL)
114 return result;
116 if (__objc_msg_forward)
118 IMP result;
119 if ((result = __objc_msg_forward (sel)) != NULL)
120 return result;
123 /* In all other cases, use the default forwarding functions built
124 using __builtin_apply and friends. */
126 const char *t = sel->sel_types;
128 if (t && (*t == '[' || *t == '(' || *t == '{')
129 #ifdef OBJC_MAX_STRUCT_BY_VALUE
130 && objc_sizeof_type (t) > OBJC_MAX_STRUCT_BY_VALUE
131 #endif
133 return (IMP)__objc_block_forward;
134 else if (t && (*t == 'f' || *t == 'd'))
135 return (IMP)__objc_double_forward;
136 else
137 return (IMP)__objc_word_forward;
141 /* Selectors for +resolveClassMethod: and +resolveInstanceMethod:.
142 These are set up at startup. */
143 static SEL selector_resolveClassMethod = NULL;
144 static SEL selector_resolveInstanceMethod = NULL;
146 /* Internal routines use to resolve a class method using
147 +resolveClassMethod:. 'class' is always a non-Nil class (*not* a
148 meta-class), and 'sel' is the selector that we are trying to
149 resolve. This must be called when class is not Nil, and the
150 dispatch table for class methods has already been installed.
152 This routine tries to call +resolveClassMethod: to give an
153 opportunity to resolve the method. If +resolveClassMethod: returns
154 YES, it tries looking up the method again, and if found, it returns
155 it. Else, it returns NULL. */
156 static inline
158 __objc_resolve_class_method (Class class, SEL sel)
160 /* We need to lookup +resolveClassMethod:. */
161 BOOL (*resolveMethodIMP) (id, SEL, SEL);
163 /* The dispatch table for class methods is already installed and we
164 don't want any forwarding to happen when looking up this method,
165 so we just look it up directly. Note that if 'sel' is precisely
166 +resolveClassMethod:, this would look it up yet again and find
167 nothing. That's no problem and there's no recursion. */
168 resolveMethodIMP = (BOOL (*) (id, SEL, SEL))sarray_get_safe
169 (class->class_pointer->dtable, (size_t) selector_resolveClassMethod->sel_id);
171 if (resolveMethodIMP && resolveMethodIMP ((id)class, selector_resolveClassMethod, sel))
173 /* +resolveClassMethod: returned YES. Look the method up again.
174 We already know the dtable is installed. */
176 /* TODO: There is the case where +resolveClassMethod: is buggy
177 and returned YES without actually adding the method. We
178 could maybe print an error message. */
179 return sarray_get_safe (class->class_pointer->dtable, (size_t) sel->sel_id);
182 return NULL;
185 /* Internal routines use to resolve a instance method using
186 +resolveInstanceMethod:. 'class' is always a non-Nil class, and
187 'sel' is the selector that we are trying to resolve. This must be
188 called when class is not Nil, and the dispatch table for instance
189 methods has already been installed.
191 This routine tries to call +resolveInstanceMethod: to give an
192 opportunity to resolve the method. If +resolveInstanceMethod:
193 returns YES, it tries looking up the method again, and if found, it
194 returns it. Else, it returns NULL. */
195 static inline
197 __objc_resolve_instance_method (Class class, SEL sel)
199 /* We need to lookup +resolveInstanceMethod:. */
200 BOOL (*resolveMethodIMP) (id, SEL, SEL);
202 /* The dispatch table for class methods may not be already installed
203 so we have to install it if needed. */
204 resolveMethodIMP = sarray_get_safe (class->class_pointer->dtable,
205 (size_t) selector_resolveInstanceMethod->sel_id);
206 if (resolveMethodIMP == 0)
208 /* Try again after installing the dtable. */
209 if (class->class_pointer->dtable == __objc_uninstalled_dtable)
211 objc_mutex_lock (__objc_runtime_mutex);
212 if (class->class_pointer->dtable == __objc_uninstalled_dtable)
213 __objc_install_dispatch_table_for_class (class->class_pointer);
214 objc_mutex_unlock (__objc_runtime_mutex);
216 resolveMethodIMP = sarray_get_safe (class->class_pointer->dtable,
217 (size_t) selector_resolveInstanceMethod->sel_id);
220 if (resolveMethodIMP && resolveMethodIMP ((id)class, selector_resolveInstanceMethod, sel))
222 /* +resolveInstanceMethod: returned YES. Look the method up
223 again. We already know the dtable is installed. */
225 /* TODO: There is the case where +resolveInstanceMethod: is
226 buggy and returned YES without actually adding the method.
227 We could maybe print an error message. */
228 return sarray_get_safe (class->dtable, (size_t) sel->sel_id);
231 return NULL;
234 /* Given a class and selector, return the selector's
235 implementation. */
236 inline
238 get_imp (Class class, SEL sel)
240 /* In a vanilla implementation we would first check if the dispatch
241 table is installed. Here instead, to get more speed in the
242 standard case (that the dispatch table is installed) we first try
243 to get the imp using brute force. Only if that fails, we do what
244 we should have been doing from the very beginning, that is, check
245 if the dispatch table needs to be installed, install it if it's
246 not installed, and retrieve the imp from the table if it's
247 installed. */
248 void *res = sarray_get_safe (class->dtable, (size_t) sel->sel_id);
249 if (res == 0)
251 /* Not a valid method. */
252 if (class->dtable == __objc_uninstalled_dtable)
254 /* The dispatch table needs to be installed. */
255 objc_mutex_lock (__objc_runtime_mutex);
257 /* Double-checked locking pattern: Check
258 __objc_uninstalled_dtable again in case another thread
259 installed the dtable while we were waiting for the lock
260 to be released. */
261 if (class->dtable == __objc_uninstalled_dtable)
263 __objc_install_dispatch_table_for_class (class);
266 objc_mutex_unlock (__objc_runtime_mutex);
267 /* Call ourselves with the installed dispatch table and get
268 the real method. */
269 res = get_imp (class, sel);
271 else
273 /* The dispatch table has been installed. */
275 /* Get the method from the dispatch table (we try to get it
276 again in case another thread has installed the dtable just
277 after we invoked sarray_get_safe, but before we checked
278 class->dtable == __objc_uninstalled_dtable). */
279 res = sarray_get_safe (class->dtable, (size_t) sel->sel_id);
280 if (res == 0)
282 /* The dispatch table has been installed, and the method
283 is not in the dispatch table. So the method just
284 doesn't exist for the class. */
286 /* Try going through the +resolveClassMethod: or
287 +resolveInstanceMethod: process. */
288 if (CLS_ISMETA (class))
290 /* We have the meta class, but we need to invoke the
291 +resolveClassMethod: method on the class. So, we
292 need to obtain the class from the meta class,
293 which we do using the fact that both the class
294 and the meta-class have the same name. */
295 Class realClass = objc_lookUpClass (class->name);
296 if (realClass)
297 res = __objc_resolve_class_method (realClass, sel);
299 else
300 res = __objc_resolve_instance_method (class, sel);
302 if (res == 0)
304 /* If that fails, then return the forwarding
305 implementation. We don't know the receiver (only
306 its class), so we have to pass 'nil' as the first
307 argument. Passing the class as first argument is
308 wrong because the class is not the receiver; it
309 can result in us calling a class method when we
310 want an instance method of the same name. */
311 res = __objc_get_forward_imp (nil, sel);
316 return res;
319 /* The new name of get_imp(). */
321 class_getMethodImplementation (Class class_, SEL selector)
323 if (class_ == Nil || selector == NULL)
324 return NULL;
326 /* get_imp is inlined, so we're good. */
327 return get_imp (class_, selector);
330 /* Given a method, return its implementation. This has been replaced
331 by method_getImplementation() in the modern API. */
333 method_get_imp (struct objc_method * method)
335 return (method != (struct objc_method *)0) ? method->method_imp : (IMP)0;
338 /* Query if an object can respond to a selector, returns YES if the
339 object implements the selector otherwise NO. Does not check if the
340 method can be forwarded. */
341 inline
342 BOOL
343 __objc_responds_to (id object, SEL sel)
345 void *res;
347 /* Install dispatch table if need be. */
348 if (object->class_pointer->dtable == __objc_uninstalled_dtable)
350 objc_mutex_lock (__objc_runtime_mutex);
351 if (object->class_pointer->dtable == __objc_uninstalled_dtable)
353 __objc_install_dispatch_table_for_class (object->class_pointer);
355 objc_mutex_unlock (__objc_runtime_mutex);
358 /* Get the method from the dispatch table. */
359 res = sarray_get_safe (object->class_pointer->dtable, (size_t) sel->sel_id);
360 return (res != 0);
363 BOOL
364 class_respondsToSelector (Class class_, SEL selector)
366 void *res;
368 if (class_ == Nil || selector == NULL)
369 return NO;
371 /* Install dispatch table if need be. */
372 if (class_->dtable == __objc_uninstalled_dtable)
374 objc_mutex_lock (__objc_runtime_mutex);
375 if (class_->dtable == __objc_uninstalled_dtable)
377 __objc_install_dispatch_table_for_class (class_);
379 objc_mutex_unlock (__objc_runtime_mutex);
382 /* Get the method from the dispatch table. */
383 res = sarray_get_safe (class_->dtable, (size_t) selector->sel_id);
384 return (res != 0);
387 /* This is the lookup function. All entries in the table are either a
388 valid method *or* zero. If zero then either the dispatch table
389 needs to be installed or it doesn't exist and forwarding is
390 attempted. */
392 objc_msg_lookup (id receiver, SEL op)
394 IMP result;
395 if (receiver)
397 result = sarray_get_safe (receiver->class_pointer->dtable,
398 (sidx)op->sel_id);
399 if (result == 0)
401 /* Not a valid method. */
402 if (receiver->class_pointer->dtable == __objc_uninstalled_dtable)
404 /* The dispatch table needs to be installed. This
405 happens on the very first method call to the
406 class. */
407 __objc_init_install_dtable (receiver, op);
409 /* Get real method for this in newly installed
410 dtable. */
411 result = get_imp (receiver->class_pointer, op);
413 else
415 /* The dispatch table has been installed. Check again
416 if the method exists (just in case the dispatch table
417 has been installed by another thread after we did the
418 previous check that the method exists). */
419 result = sarray_get_safe (receiver->class_pointer->dtable,
420 (sidx)op->sel_id);
421 if (result == 0)
423 /* Try going through the +resolveClassMethod: or
424 +resolveInstanceMethod: process. */
425 if (CLS_ISMETA (receiver->class_pointer))
426 result = __objc_resolve_class_method ((Class)receiver, op);
427 else
428 result = __objc_resolve_instance_method (receiver->class_pointer,
429 op);
431 if (result == 0)
433 /* If the method still just doesn't exist for
434 the class, attempt to forward the method. */
435 result = __objc_get_forward_imp (receiver, op);
440 return result;
442 else
443 return (IMP)nil_method;
447 objc_msg_lookup_super (struct objc_super *super, SEL sel)
449 if (super->self)
450 return get_imp (super->super_class, sel);
451 else
452 return (IMP)nil_method;
455 /* Temporarily defined here until objc_msg_sendv() goes away. */
456 char *method_get_first_argument (struct objc_method *,
457 arglist_t argframe,
458 const char **type);
459 char *method_get_next_argument (arglist_t argframe,
460 const char **type);
461 int method_get_sizeof_arguments (struct objc_method *);
463 struct objc_method *
464 class_get_instance_method (Class class, SEL op);
466 retval_t
467 objc_msg_sendv (id object, SEL op, arglist_t arg_frame)
469 struct objc_method *m = class_get_instance_method (object->class_pointer, op);
470 const char *type;
471 *((id *) method_get_first_argument (m, arg_frame, &type)) = object;
472 *((SEL *) method_get_next_argument (arg_frame, &type)) = op;
473 return __builtin_apply ((apply_t) m->method_imp,
474 arg_frame,
475 method_get_sizeof_arguments (m));
478 void
479 __objc_init_dispatch_tables ()
481 __objc_uninstalled_dtable = sarray_new (200, 0);
483 /* TODO: It would be cool to register typed selectors here. */
484 selector_resolveClassMethod = sel_registerName ("resolveClassMethod:");
485 selector_resolveInstanceMethod =sel_registerName ("resolveInstanceMethod:");
488 /* This function is called by objc_msg_lookup when the dispatch table
489 needs to be installed; thus it is called once for each class,
490 namely when the very first message is sent to it. */
491 static void
492 __objc_init_install_dtable (id receiver, SEL op __attribute__ ((__unused__)))
494 objc_mutex_lock (__objc_runtime_mutex);
496 /* This may happen, if the programmer has taken the address of a
497 method before the dtable was initialized... too bad for him! */
498 if (receiver->class_pointer->dtable != __objc_uninstalled_dtable)
500 objc_mutex_unlock (__objc_runtime_mutex);
501 return;
504 if (CLS_ISCLASS (receiver->class_pointer))
506 /* receiver is an ordinary object. */
507 assert (CLS_ISCLASS (receiver->class_pointer));
509 /* Install instance methods table. */
510 __objc_install_dispatch_table_for_class (receiver->class_pointer);
512 /* Call +initialize -- this will in turn install the factory
513 dispatch table if not already done. :-) */
514 __objc_send_initialize (receiver->class_pointer);
516 else
518 /* receiver is a class object. */
519 assert (CLS_ISCLASS ((Class)receiver));
520 assert (CLS_ISMETA (receiver->class_pointer));
522 /* Install real dtable for factory methods. */
523 __objc_install_dispatch_table_for_class (receiver->class_pointer);
525 __objc_send_initialize ((Class)receiver);
527 objc_mutex_unlock (__objc_runtime_mutex);
530 /* Install dummy table for class which causes the first message to
531 that class (or instances hereof) to be initialized properly. */
532 void
533 __objc_install_premature_dtable (Class class)
535 assert (__objc_uninstalled_dtable);
536 class->dtable = __objc_uninstalled_dtable;
539 /* Send +initialize to class if not already done. */
540 static void
541 __objc_send_initialize (Class class)
543 /* This *must* be a class object. */
544 assert (CLS_ISCLASS (class));
545 assert (! CLS_ISMETA (class));
547 if (! CLS_ISINITIALIZED (class))
549 DEBUG_PRINTF ("+initialize: need to initialize class '%s'\n", class->name);
550 CLS_SETINITIALIZED (class);
551 CLS_SETINITIALIZED (class->class_pointer);
553 /* Create the garbage collector type memory description. */
554 __objc_generate_gc_type_description (class);
556 if (class->super_class)
557 __objc_send_initialize (class->super_class);
560 SEL op = sel_registerName ("initialize");
561 IMP imp = 0;
562 struct objc_method_list * method_list = class->class_pointer->methods;
564 while (method_list)
566 int i;
567 struct objc_method * method;
569 for (i = 0; i < method_list->method_count; i++)
571 method = &(method_list->method_list[i]);
572 if (method->method_name
573 && method->method_name->sel_id == op->sel_id)
575 imp = method->method_imp;
576 break;
580 if (imp)
581 break;
583 method_list = method_list->method_next;
585 if (imp)
587 DEBUG_PRINTF (" begin of [%s +initialize]\n", class->name);
588 (*imp) ((id) class, op);
589 DEBUG_PRINTF (" end of [%s +initialize]\n", class->name);
591 #ifdef DEBUG
592 else
594 DEBUG_PRINTF (" class '%s' has no +initialize method\n", class->name);
596 #endif
601 /* Walk on the methods list of class and install the methods in the
602 reverse order of the lists. Since methods added by categories are
603 before the methods of class in the methods list, this allows
604 categories to substitute methods declared in class. However if
605 more than one category replaces the same method nothing is
606 guaranteed about what method will be used. Assumes that
607 __objc_runtime_mutex is locked down. */
608 static void
609 __objc_install_methods_in_dtable (Class class, struct objc_method_list * method_list)
611 int i;
613 if (! method_list)
614 return;
616 if (method_list->method_next)
617 __objc_install_methods_in_dtable (class, method_list->method_next);
619 for (i = 0; i < method_list->method_count; i++)
621 struct objc_method * method = &(method_list->method_list[i]);
622 sarray_at_put_safe (class->dtable,
623 (sidx) method->method_name->sel_id,
624 method->method_imp);
628 /* Assumes that __objc_runtime_mutex is locked down. */
629 static void
630 __objc_install_dispatch_table_for_class (Class class)
632 Class super;
634 /* If the class has not yet had its class links resolved, we must
635 re-compute all class links. */
636 if (! CLS_ISRESOLV (class))
637 __objc_resolve_class_links ();
639 DEBUG_PRINTF ("__objc_install_dispatch_table_for_class (%s)\n", class->name);
641 super = class->super_class;
643 if (super != 0 && (super->dtable == __objc_uninstalled_dtable))
644 __objc_install_dispatch_table_for_class (super);
646 /* Allocate dtable if necessary. */
647 if (super == 0)
649 objc_mutex_lock (__objc_runtime_mutex);
650 class->dtable = sarray_new (__objc_selector_max_index, 0);
651 objc_mutex_unlock (__objc_runtime_mutex);
653 else
654 class->dtable = sarray_lazy_copy (super->dtable);
656 __objc_install_methods_in_dtable (class, class->methods);
659 void
660 __objc_update_dispatch_table_for_class (Class class)
662 Class next;
663 struct sarray *arr;
665 /* Not yet installed -- skip it. */
666 if (class->dtable == __objc_uninstalled_dtable)
667 return;
669 DEBUG_PRINTF (" _objc_update_dispatch_table_for_class (%s)\n", class->name);
671 objc_mutex_lock (__objc_runtime_mutex);
673 arr = class->dtable;
674 __objc_install_premature_dtable (class); /* someone might require it... */
675 sarray_free (arr); /* release memory */
677 /* Could have been lazy... */
678 __objc_install_dispatch_table_for_class (class);
680 if (class->subclass_list) /* Traverse subclasses. */
681 for (next = class->subclass_list; next; next = next->sibling_class)
682 __objc_update_dispatch_table_for_class (next);
684 objc_mutex_unlock (__objc_runtime_mutex);
687 /* This function adds a method list to a class. This function is
688 typically called by another function specific to the run-time. As
689 such this function does not worry about thread safe issues.
691 This one is only called for categories. Class objects have their
692 methods installed right away, and their selectors are made into
693 SEL's by the function __objc_register_selectors_from_class. */
694 void
695 class_add_method_list (Class class, struct objc_method_list * list)
697 /* Passing of a linked list is not allowed. Do multiple calls. */
698 assert (! list->method_next);
700 __objc_register_selectors_from_list(list);
702 /* Add the methods to the class's method list. */
703 list->method_next = class->methods;
704 class->methods = list;
706 /* Update the dispatch table of class. */
707 __objc_update_dispatch_table_for_class (class);
710 struct objc_method *
711 class_get_instance_method (Class class, SEL op)
713 return search_for_method_in_hierarchy (class, op);
716 struct objc_method *
717 class_get_class_method (MetaClass class, SEL op)
719 return search_for_method_in_hierarchy (class, op);
722 struct objc_method *
723 class_getInstanceMethod (Class class_, SEL selector)
725 struct objc_method *m;
727 if (class_ == Nil || selector == NULL)
728 return NULL;
730 m = search_for_method_in_hierarchy (class_, selector);
731 if (m)
732 return m;
734 /* Try going through +resolveInstanceMethod:, and do the search
735 again if successful. */
736 if (__objc_resolve_instance_method (class_, selector))
737 return search_for_method_in_hierarchy (class_, selector);
739 return NULL;
742 struct objc_method *
743 class_getClassMethod (Class class_, SEL selector)
745 struct objc_method *m;
747 if (class_ == Nil || selector == NULL)
748 return NULL;
750 m = search_for_method_in_hierarchy (class_->class_pointer,
751 selector);
752 if (m)
753 return m;
755 /* Try going through +resolveClassMethod:, and do the search again
756 if successful. */
757 if (__objc_resolve_class_method (class_, selector))
758 return search_for_method_in_hierarchy (class_->class_pointer,
759 selector);
761 return NULL;
764 BOOL
765 class_addMethod (Class class_, SEL selector, IMP implementation,
766 const char *method_types)
768 struct objc_method_list *method_list;
769 struct objc_method *method;
770 const char *method_name;
772 if (class_ == Nil || selector == NULL || implementation == NULL
773 || method_types == NULL || (strcmp (method_types, "") == 0))
774 return NO;
776 method_name = sel_getName (selector);
777 if (method_name == NULL)
778 return NO;
780 /* If the method already exists in the class, return NO. It is fine
781 if the method already exists in the superclass; in that case, we
782 are overriding it. */
783 if (CLS_IS_IN_CONSTRUCTION (class_))
785 /* The class only contains a list of methods; they have not been
786 registered yet, ie, the method_name of each of them is still
787 a string, not a selector. Iterate manually over them to
788 check if we have already added the method. */
789 struct objc_method_list * method_list = class_->methods;
790 while (method_list)
792 int i;
794 /* Search the method list. */
795 for (i = 0; i < method_list->method_count; ++i)
797 struct objc_method * method = &method_list->method_list[i];
799 if (method->method_name
800 && strcmp ((char *)method->method_name, method_name) == 0)
801 return NO;
804 /* The method wasn't found. Follow the link to the next list of
805 methods. */
806 method_list = method_list->method_next;
808 /* The method wasn't found. It's a new one. Go ahead and add
809 it. */
811 else
813 /* Do the standard lookup. This assumes the selectors are
814 mapped. */
815 if (search_for_method_in_list (class_->methods, selector))
816 return NO;
819 method_list = (struct objc_method_list *)objc_calloc (1, sizeof (struct objc_method_list));
820 method_list->method_count = 1;
822 method = &(method_list->method_list[0]);
823 method->method_name = objc_malloc (strlen (method_name) + 1);
824 strcpy ((char *)method->method_name, method_name);
826 method->method_types = objc_malloc (strlen (method_types) + 1);
827 strcpy ((char *)method->method_types, method_types);
829 method->method_imp = implementation;
831 if (CLS_IS_IN_CONSTRUCTION (class_))
833 /* We only need to add the method to the list. It will be
834 registered with the runtime when the class pair is registered
835 (if ever). */
836 method_list->method_next = class_->methods;
837 class_->methods = method_list;
839 else
841 /* Add the method to a live class. */
842 objc_mutex_lock (__objc_runtime_mutex);
843 class_add_method_list (class_, method_list);
844 objc_mutex_unlock (__objc_runtime_mutex);
847 return YES;
851 class_replaceMethod (Class class_, SEL selector, IMP implementation,
852 const char *method_types)
854 struct objc_method * method;
856 if (class_ == Nil || selector == NULL || implementation == NULL
857 || method_types == NULL)
858 return NULL;
860 method = search_for_method_in_hierarchy (class_, selector);
862 if (method)
864 return method_setImplementation (method, implementation);
866 else
868 class_addMethod (class_, selector, implementation, method_types);
869 return NULL;
873 /* Search for a method starting from the current class up its
874 hierarchy. Return a pointer to the method's method structure if
875 found. NULL otherwise. */
876 static struct objc_method *
877 search_for_method_in_hierarchy (Class cls, SEL sel)
879 struct objc_method * method = NULL;
880 Class class;
882 if (! sel_is_mapped (sel))
883 return NULL;
885 /* Scan the method list of the class. If the method isn't found in
886 the list then step to its super class. */
887 for (class = cls; ((! method) && class); class = class->super_class)
888 method = search_for_method_in_list (class->methods, sel);
890 return method;
895 /* Given a linked list of method and a method's name. Search for the
896 named method's method structure. Return a pointer to the method's
897 method structure if found. NULL otherwise. */
898 struct objc_method *
899 search_for_method_in_list (struct objc_method_list * list, SEL op)
901 struct objc_method_list * method_list = list;
903 if (! sel_is_mapped (op))
904 return NULL;
906 /* If not found then we'll search the list. */
907 while (method_list)
909 int i;
911 /* Search the method list. */
912 for (i = 0; i < method_list->method_count; ++i)
914 struct objc_method * method = &method_list->method_list[i];
916 if (method->method_name)
917 if (method->method_name->sel_id == op->sel_id)
918 return method;
921 /* The method wasn't found. Follow the link to the next list of
922 methods. */
923 method_list = method_list->method_next;
926 return NULL;
929 static retval_t __objc_forward (id object, SEL sel, arglist_t args);
931 /* Forwarding pointers/integers through the normal registers. */
932 static id
933 __objc_word_forward (id rcv, SEL op, ...)
935 void *args, *res;
937 args = __builtin_apply_args ();
938 res = __objc_forward (rcv, op, args);
939 if (res)
940 __builtin_return (res);
941 else
942 return res;
945 /* Specific routine for forwarding floats/double because of
946 architectural differences on some processors. i386s for example
947 which uses a floating point stack versus general registers for
948 floating point numbers. This forward routine makes sure that GCC
949 restores the proper return values. */
950 static double
951 __objc_double_forward (id rcv, SEL op, ...)
953 void *args, *res;
955 args = __builtin_apply_args ();
956 res = __objc_forward (rcv, op, args);
957 __builtin_return (res);
960 #if INVISIBLE_STRUCT_RETURN
961 static __big
962 #else
963 static id
964 #endif
965 __objc_block_forward (id rcv, SEL op, ...)
967 void *args, *res;
969 args = __builtin_apply_args ();
970 res = __objc_forward (rcv, op, args);
971 if (res)
972 __builtin_return (res);
973 else
974 #if INVISIBLE_STRUCT_RETURN
975 return (__big) {{0, 0, 0, 0, 0, 0, 0, 0}};
976 #else
977 return nil;
978 #endif
982 /* This function is installed in the dispatch table for all methods
983 which are not implemented. Thus, it is called when a selector is
984 not recognized. */
985 static retval_t
986 __objc_forward (id object, SEL sel, arglist_t args)
988 IMP imp;
989 static SEL frwd_sel = 0; /* !T:SAFE2 */
990 SEL err_sel;
992 /* First try if the object understands forward::. */
993 if (! frwd_sel)
994 frwd_sel = sel_get_any_uid ("forward::");
996 if (__objc_responds_to (object, frwd_sel))
998 imp = get_imp (object->class_pointer, frwd_sel);
999 return (*imp) (object, frwd_sel, sel, args);
1002 /* If the object recognizes the doesNotRecognize: method then we're
1003 going to send it. */
1004 err_sel = sel_get_any_uid ("doesNotRecognize:");
1005 if (__objc_responds_to (object, err_sel))
1007 imp = get_imp (object->class_pointer, err_sel);
1008 return (*imp) (object, err_sel, sel);
1011 /* The object doesn't recognize the method. Check for responding to
1012 error:. If it does then sent it. */
1014 char msg[256 + strlen ((const char *) sel_getName (sel))
1015 + strlen ((const char *) object->class_pointer->name)];
1017 sprintf (msg, "(%s) %s does not recognize %s",
1018 (CLS_ISMETA (object->class_pointer)
1019 ? "class"
1020 : "instance" ),
1021 object->class_pointer->name, sel_getName (sel));
1023 /* TODO: support for error: is surely deprecated ? */
1024 err_sel = sel_get_any_uid ("error:");
1025 if (__objc_responds_to (object, err_sel))
1027 imp = get_imp (object->class_pointer, err_sel);
1028 return (*imp) (object, sel_get_any_uid ("error:"), msg);
1031 /* The object doesn't respond to doesNotRecognize: or error:;
1032 Therefore, a default action is taken. */
1033 _objc_abort ("%s\n", msg);
1035 return 0;
1039 void
1040 __objc_print_dtable_stats (void)
1042 int total = 0;
1044 objc_mutex_lock (__objc_runtime_mutex);
1046 #ifdef OBJC_SPARSE2
1047 printf ("memory usage: (%s)\n", "2-level sparse arrays");
1048 #else
1049 printf ("memory usage: (%s)\n", "3-level sparse arrays");
1050 #endif
1052 printf ("arrays: %d = %ld bytes\n", narrays,
1053 (long) ((size_t) narrays * sizeof (struct sarray)));
1054 total += narrays * sizeof (struct sarray);
1055 printf ("buckets: %d = %ld bytes\n", nbuckets,
1056 (long) ((size_t) nbuckets * sizeof (struct sbucket)));
1057 total += nbuckets * sizeof (struct sbucket);
1059 printf ("idxtables: %d = %ld bytes\n",
1060 idxsize, (long) ((size_t) idxsize * sizeof (void *)));
1061 total += idxsize * sizeof (void *);
1062 printf ("-----------------------------------\n");
1063 printf ("total: %d bytes\n", total);
1064 printf ("===================================\n");
1066 objc_mutex_unlock (__objc_runtime_mutex);
1069 /* Returns the uninstalled dispatch table indicator. If a class'
1070 dispatch table points to __objc_uninstalled_dtable then that means
1071 it needs its dispatch table to be installed. */
1072 struct sarray *
1073 objc_get_uninstalled_dtable (void)
1075 return __objc_uninstalled_dtable;