OSDN Git Service

a0b66baf6a2e3e923c0fb93c30c30ef98caf7404
[pf3gnuchains/gcc-fork.git] / libobjc / sendmsg.c
1 /* GNU Objective C Runtime message lookup 
2    Copyright (C) 1993, 1995, 1996, 1997, 1998,
3    2001, 2002, 2004 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 2, 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 You should have received a copy of the GNU General Public License along with
18 GCC; see the file COPYING.  If not, write to the Free Software
19 Foundation, 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA.  */
21
22 /* As a special exception, if you link this library with files compiled with
23    GCC to produce an executable, this does not cause the resulting executable
24    to be covered by the GNU General Public License. This exception does not
25    however invalidate any other reasons why the executable file might be
26    covered by the GNU General Public License.  */
27
28 /* FIXME: This file has no business including tm.h.  */
29 /* FIXME: This should be using libffi instead of __builtin_apply
30    and friends.  */
31
32 #include "tconfig.h"
33 #include "coretypes.h"
34 #include "tm.h"
35 #include "objc/runtime.h"
36 #include "objc/sarray.h"
37 #include "objc/encoding.h"
38 #include "runtime-info.h"
39
40 /* This is how we hack STRUCT_VALUE to be 1 or 0.   */
41 #define gen_rtx(args...) 1
42 #define gen_rtx_MEM(args...) 1
43 #define gen_rtx_REG(args...) 1
44 #define rtx int
45
46 #if ! defined (STRUCT_VALUE) || STRUCT_VALUE == 0
47 #define INVISIBLE_STRUCT_RETURN 1
48 #else
49 #define INVISIBLE_STRUCT_RETURN 0
50 #endif
51
52 /* The uninstalled dispatch table */
53 struct sarray *__objc_uninstalled_dtable = 0;   /* !T:MUTEX */
54
55 /* Two hooks for method forwarding. If either is set, it is invoked
56  * to return a function that performs the real forwarding.  If both
57  * are set, the result of __objc_msg_forward2 will be preferred over
58  * that of __objc_msg_forward.  If both return NULL or are unset,
59  * the libgcc based functions (__builtin_apply and friends) are
60  * used.
61  */
62 IMP (*__objc_msg_forward) (SEL) = NULL;
63 IMP (*__objc_msg_forward2) (id, SEL) = NULL;
64
65 /* Send +initialize to class */
66 static void __objc_send_initialize (Class);
67
68 static void __objc_install_dispatch_table_for_class (Class);
69
70 /* Forward declare some functions */
71 static void __objc_init_install_dtable (id, SEL);
72
73 /* Various forwarding functions that are used based upon the
74    return type for the selector.
75    __objc_block_forward for structures.
76    __objc_double_forward for floats/doubles.
77    __objc_word_forward for pointers or types that fit in registers. */
78 static double __objc_double_forward (id, SEL, ...);
79 static id __objc_word_forward (id, SEL, ...);
80 typedef struct { id many[8]; } __big;
81 #if INVISIBLE_STRUCT_RETURN 
82 static __big 
83 #else
84 static id
85 #endif
86 __objc_block_forward (id, SEL, ...);
87 static Method_t search_for_method_in_hierarchy (Class class, SEL sel);
88 Method_t search_for_method_in_list (MethodList_t list, SEL op);
89 id nil_method (id, SEL);
90
91 /* Given a selector, return the proper forwarding implementation. */
92 inline
93 IMP
94 __objc_get_forward_imp (id rcv, SEL sel)
95 {
96   /* If a custom forwarding hook was registered, try getting a forwarding
97      function from it. There are two forward routine hooks, one that
98      takes the receiver as an argument and one that does not. */
99   if (__objc_msg_forward2)
100     {
101       IMP result;
102       if ((result = __objc_msg_forward2 (rcv, sel)) != NULL)
103        return result;
104     }
105   if (__objc_msg_forward)
106     {
107       IMP result;
108       if ((result = __objc_msg_forward (sel)) != NULL) 
109         return result;
110     }
111
112   /* In all other cases, use the default forwarding functions built using
113      __builtin_apply and friends.  */
114     {
115       const char *t = sel->sel_types;
116
117       if (t && (*t == '[' || *t == '(' || *t == '{')
118 #ifdef OBJC_MAX_STRUCT_BY_VALUE
119           && objc_sizeof_type (t) > OBJC_MAX_STRUCT_BY_VALUE
120 #endif
121           )
122         return (IMP)__objc_block_forward;
123       else if (t && (*t == 'f' || *t == 'd'))
124         return (IMP)__objc_double_forward;
125       else
126         return (IMP)__objc_word_forward;
127     }
128 }
129
130 /* Given a class and selector, return the selector's implementation.  */
131 inline
132 IMP
133 get_imp (Class class, SEL sel)
134 {
135   /* In a vanilla implementation we would first check if the dispatch
136      table is installed.  Here instead, to get more speed in the
137      standard case (that the dispatch table is installed) we first try
138      to get the imp using brute force.  Only if that fails, we do what
139      we should have been doing from the very beginning, that is, check
140      if the dispatch table needs to be installed, install it if it's
141      not installed, and retrieve the imp from the table if it's
142      installed.  */
143   void *res = sarray_get_safe (class->dtable, (size_t) sel->sel_id);
144   if (res == 0)
145     {
146       /* Not a valid method */
147       if (class->dtable == __objc_uninstalled_dtable)
148         {
149           /* The dispatch table needs to be installed. */
150           objc_mutex_lock (__objc_runtime_mutex);
151
152            /* Double-checked locking pattern: Check
153               __objc_uninstalled_dtable again in case another thread
154               installed the dtable while we were waiting for the lock
155               to be released.  */
156          if (class->dtable == __objc_uninstalled_dtable)
157            {
158              __objc_install_dispatch_table_for_class (class);
159            }
160
161           objc_mutex_unlock (__objc_runtime_mutex);
162           /* Call ourselves with the installed dispatch table
163              and get the real method */
164           res = get_imp (class, sel);
165         }
166       else
167         {
168           /* The dispatch table has been installed.  */
169
170          /* Get the method from the dispatch table (we try to get it
171             again in case another thread has installed the dtable just
172             after we invoked sarray_get_safe, but before we checked
173             class->dtable == __objc_uninstalled_dtable).
174          */
175           res = sarray_get_safe (class->dtable, (size_t) sel->sel_id);
176           if (res == 0)
177             {
178               /* The dispatch table has been installed, and the method
179                  is not in the dispatch table.  So the method just
180                  doesn't exist for the class.  Return the forwarding
181                  implementation. */
182              res = __objc_get_forward_imp ((id)class, sel);
183             }
184         }
185     }
186   return res;
187 }
188
189 /* Query if an object can respond to a selector, returns YES if the
190 object implements the selector otherwise NO.  Does not check if the
191 method can be forwarded. */
192 inline
193 BOOL
194 __objc_responds_to (id object, SEL sel)
195 {
196   void *res;
197
198   /* Install dispatch table if need be */
199   if (object->class_pointer->dtable == __objc_uninstalled_dtable)
200     {
201       objc_mutex_lock (__objc_runtime_mutex);
202       if (object->class_pointer->dtable == __objc_uninstalled_dtable)
203         {
204           __objc_install_dispatch_table_for_class (object->class_pointer);
205         }
206       objc_mutex_unlock (__objc_runtime_mutex);
207     }
208
209   /* Get the method from the dispatch table */
210   res = sarray_get_safe (object->class_pointer->dtable, (size_t) sel->sel_id);
211   return (res != 0);
212 }
213
214 /* This is the lookup function.  All entries in the table are either a 
215    valid method *or* zero.  If zero then either the dispatch table
216    needs to be installed or it doesn't exist and forwarding is attempted. */
217 inline
218 IMP
219 objc_msg_lookup (id receiver, SEL op)
220 {
221   IMP result;
222   if (receiver)
223     {
224       result = sarray_get_safe (receiver->class_pointer->dtable, 
225                                 (sidx)op->sel_id);
226       if (result == 0)
227         {
228           /* Not a valid method */
229           if (receiver->class_pointer->dtable == __objc_uninstalled_dtable)
230             {
231               /* The dispatch table needs to be installed.
232                  This happens on the very first method call to the class. */
233               __objc_init_install_dtable (receiver, op);
234
235               /* Get real method for this in newly installed dtable */
236               result = get_imp (receiver->class_pointer, op);
237             }
238           else
239             {
240               /* The dispatch table has been installed.  Check again
241                  if the method exists (just in case the dispatch table
242                  has been installed by another thread after we did the
243                  previous check that the method exists).
244               */
245               result = sarray_get_safe (receiver->class_pointer->dtable,
246                                         (sidx)op->sel_id);
247               if (result == 0)
248                 {
249                   /* If the method still just doesn't exist for the
250                      class, attempt to forward the method. */
251                   result = __objc_get_forward_imp (receiver, op);
252                 }
253             }
254         }
255       return result;
256     }
257   else
258     return (IMP)nil_method;
259 }
260
261 IMP
262 objc_msg_lookup_super (Super_t super, SEL sel)
263 {
264   if (super->self)
265     return get_imp (super->class, sel);
266   else
267     return (IMP)nil_method;
268 }
269
270 int method_get_sizeof_arguments (Method *);
271
272 retval_t
273 objc_msg_sendv (id object, SEL op, arglist_t arg_frame)
274 {
275   Method *m = class_get_instance_method (object->class_pointer, op);
276   const char *type;
277   *((id *) method_get_first_argument (m, arg_frame, &type)) = object;
278   *((SEL *) method_get_next_argument (arg_frame, &type)) = op;
279   return __builtin_apply ((apply_t) m->method_imp, 
280                           arg_frame,
281                           method_get_sizeof_arguments (m));
282 }
283
284 void
285 __objc_init_dispatch_tables ()
286 {
287   __objc_uninstalled_dtable = sarray_new (200, 0);
288 }
289
290 /* This function is called by objc_msg_lookup when the
291    dispatch table needs to be installed; thus it is called once
292    for each class, namely when the very first message is sent to it. */
293 static void
294 __objc_init_install_dtable (id receiver, SEL op __attribute__ ((__unused__)))
295 {
296   objc_mutex_lock (__objc_runtime_mutex);
297   
298   /* This may happen, if the programmer has taken the address of a 
299      method before the dtable was initialized... too bad for him! */
300   if (receiver->class_pointer->dtable != __objc_uninstalled_dtable)
301     {
302       objc_mutex_unlock (__objc_runtime_mutex);
303       return;
304     }
305   
306   if (CLS_ISCLASS (receiver->class_pointer))
307     {
308       /* receiver is an ordinary object */
309       assert (CLS_ISCLASS (receiver->class_pointer));
310
311       /* install instance methods table */
312       __objc_install_dispatch_table_for_class (receiver->class_pointer);
313
314       /* call +initialize -- this will in turn install the factory 
315          dispatch table if not already done :-) */
316       __objc_send_initialize (receiver->class_pointer);
317     }
318   else
319     {
320       /* receiver is a class object */
321       assert (CLS_ISCLASS ((Class)receiver));
322       assert (CLS_ISMETA (receiver->class_pointer));
323
324       /* Install real dtable for factory methods */
325       __objc_install_dispatch_table_for_class (receiver->class_pointer);
326
327       __objc_send_initialize ((Class)receiver);
328     }
329   objc_mutex_unlock (__objc_runtime_mutex);
330 }
331
332 /* Install dummy table for class which causes the first message to
333    that class (or instances hereof) to be initialized properly */
334 void
335 __objc_install_premature_dtable (Class class)
336 {
337   assert (__objc_uninstalled_dtable);
338   class->dtable = __objc_uninstalled_dtable;
339 }   
340
341 /* Send +initialize to class if not already done */
342 static void
343 __objc_send_initialize (Class class)
344 {
345   /* This *must* be a class object */
346   assert (CLS_ISCLASS (class));
347   assert (! CLS_ISMETA (class));
348
349   if (! CLS_ISINITIALIZED (class))
350     {
351       CLS_SETINITIALIZED (class);
352       CLS_SETINITIALIZED (class->class_pointer);
353
354       /* Create the garbage collector type memory description */
355       __objc_generate_gc_type_description (class);
356
357       if (class->super_class)
358         __objc_send_initialize (class->super_class);
359
360       {
361         SEL          op = sel_register_name ("initialize");
362         IMP          imp = 0;
363         MethodList_t method_list = class->class_pointer->methods;
364
365         while (method_list) {
366           int i;
367           Method_t method;
368
369           for (i = 0; i < method_list->method_count; i++) {
370             method = &(method_list->method_list[i]);
371             if (method->method_name
372                 && method->method_name->sel_id == op->sel_id) {
373               imp = method->method_imp;
374               break;
375             }
376           }
377
378           if (imp)
379             break;
380
381           method_list = method_list->method_next;
382
383         }
384         if (imp)
385             (*imp) ((id) class, op);
386                 
387       }
388     }
389 }
390
391 /* Walk on the methods list of class and install the methods in the reverse
392    order of the lists. Since methods added by categories are before the methods
393    of class in the methods list, this allows categories to substitute methods
394    declared in class. However if more than one category replaces the same
395    method nothing is guaranteed about what method will be used.
396    Assumes that __objc_runtime_mutex is locked down. */
397 static void
398 __objc_install_methods_in_dtable (Class class, MethodList_t method_list)
399 {
400   int i;
401
402   if (! method_list)
403     return;
404
405   if (method_list->method_next)
406     __objc_install_methods_in_dtable (class, method_list->method_next);
407
408   for (i = 0; i < method_list->method_count; i++)
409     {
410       Method_t method = &(method_list->method_list[i]);
411       sarray_at_put_safe (class->dtable,
412                           (sidx) method->method_name->sel_id,
413                           method->method_imp);
414     }
415 }
416
417 /* Assumes that __objc_runtime_mutex is locked down. */
418 static void
419 __objc_install_dispatch_table_for_class (Class class)
420 {
421   Class super;
422
423   /* If the class has not yet had its class links resolved, we must 
424      re-compute all class links */
425   if (! CLS_ISRESOLV (class))
426     __objc_resolve_class_links ();
427
428   super = class->super_class;
429
430   if (super != 0 && (super->dtable == __objc_uninstalled_dtable))
431     __objc_install_dispatch_table_for_class (super);
432
433   /* Allocate dtable if necessary */
434   if (super == 0)
435     {
436       objc_mutex_lock (__objc_runtime_mutex);
437       class->dtable = sarray_new (__objc_selector_max_index, 0);
438       objc_mutex_unlock (__objc_runtime_mutex);
439     }
440   else
441     class->dtable = sarray_lazy_copy (super->dtable);
442
443   __objc_install_methods_in_dtable (class, class->methods);
444 }
445
446 void
447 __objc_update_dispatch_table_for_class (Class class)
448 {
449   Class next;
450   struct sarray *arr;
451
452   /* not yet installed -- skip it */
453   if (class->dtable == __objc_uninstalled_dtable) 
454     return;
455
456   objc_mutex_lock (__objc_runtime_mutex);
457
458   arr = class->dtable;
459   __objc_install_premature_dtable (class); /* someone might require it... */
460   sarray_free (arr);                       /* release memory */
461
462   /* could have been lazy... */
463   __objc_install_dispatch_table_for_class (class); 
464
465   if (class->subclass_list)     /* Traverse subclasses */
466     for (next = class->subclass_list; next; next = next->sibling_class)
467       __objc_update_dispatch_table_for_class (next);
468
469   objc_mutex_unlock (__objc_runtime_mutex);
470 }
471
472
473 /* This function adds a method list to a class.  This function is
474    typically called by another function specific to the run-time.  As
475    such this function does not worry about thread safe issues.
476
477    This one is only called for categories. Class objects have their
478    methods installed right away, and their selectors are made into
479    SEL's by the function __objc_register_selectors_from_class. */
480 void
481 class_add_method_list (Class class, MethodList_t list)
482 {
483   /* Passing of a linked list is not allowed.  Do multiple calls.  */
484   assert (! list->method_next);
485
486   __objc_register_selectors_from_list(list);
487
488   /* Add the methods to the class's method list.  */
489   list->method_next = class->methods;
490   class->methods = list;
491
492   /* Update the dispatch table of class */
493   __objc_update_dispatch_table_for_class (class);
494 }
495
496 Method_t
497 class_get_instance_method (Class class, SEL op)
498 {
499   return search_for_method_in_hierarchy (class, op);
500 }
501
502 Method_t
503 class_get_class_method (MetaClass class, SEL op)
504 {
505   return search_for_method_in_hierarchy (class, op);
506 }
507
508
509 /* Search for a method starting from the current class up its hierarchy.
510    Return a pointer to the method's method structure if found.  NULL
511    otherwise. */   
512
513 static Method_t
514 search_for_method_in_hierarchy (Class cls, SEL sel)
515 {
516   Method_t method = NULL;
517   Class class;
518
519   if (! sel_is_mapped (sel))
520     return NULL;
521
522   /* Scan the method list of the class.  If the method isn't found in the
523      list then step to its super class. */
524   for (class = cls; ((! method) && class); class = class->super_class)
525     method = search_for_method_in_list (class->methods, sel);
526
527   return method;
528 }
529
530
531
532 /* Given a linked list of method and a method's name.  Search for the named
533    method's method structure.  Return a pointer to the method's method
534    structure if found.  NULL otherwise. */  
535 Method_t
536 search_for_method_in_list (MethodList_t list, SEL op)
537 {
538   MethodList_t method_list = list;
539
540   if (! sel_is_mapped (op))
541     return NULL;
542
543   /* If not found then we'll search the list.  */
544   while (method_list)
545     {
546       int i;
547
548       /* Search the method list.  */
549       for (i = 0; i < method_list->method_count; ++i)
550         {
551           Method_t method = &method_list->method_list[i];
552
553           if (method->method_name)
554             if (method->method_name->sel_id == op->sel_id)
555               return method;
556         }
557
558       /* The method wasn't found.  Follow the link to the next list of
559          methods.  */
560       method_list = method_list->method_next;
561     }
562
563   return NULL;
564 }
565
566 static retval_t __objc_forward (id object, SEL sel, arglist_t args);
567
568 /* Forwarding pointers/integers through the normal registers */
569 static id
570 __objc_word_forward (id rcv, SEL op, ...)
571 {
572   void *args, *res;
573
574   args = __builtin_apply_args ();
575   res = __objc_forward (rcv, op, args);
576   if (res)
577     __builtin_return (res);
578   else
579     return res;
580 }
581
582 /* Specific routine for forwarding floats/double because of
583    architectural differences on some processors.  i386s for
584    example which uses a floating point stack versus general
585    registers for floating point numbers.  This forward routine 
586    makes sure that GCC restores the proper return values */
587 static double
588 __objc_double_forward (id rcv, SEL op, ...)
589 {
590   void *args, *res;
591
592   args = __builtin_apply_args ();
593   res = __objc_forward (rcv, op, args);
594   __builtin_return (res);
595 }
596
597 #if INVISIBLE_STRUCT_RETURN
598 static __big
599 #else
600 static id
601 #endif
602 __objc_block_forward (id rcv, SEL op, ...)
603 {
604   void *args, *res;
605
606   args = __builtin_apply_args ();
607   res = __objc_forward (rcv, op, args);
608   if (res)
609     __builtin_return (res);
610   else
611 #if INVISIBLE_STRUCT_RETURN
612     return (__big) {{0, 0, 0, 0, 0, 0, 0, 0}};
613 #else
614     return nil;
615 #endif
616 }
617
618
619 /* This function is installed in the dispatch table for all methods which are
620    not implemented.  Thus, it is called when a selector is not recognized. */
621 static retval_t
622 __objc_forward (id object, SEL sel, arglist_t args)
623 {
624   IMP imp;
625   static SEL frwd_sel = 0;                      /* !T:SAFE2 */
626   SEL err_sel;
627
628   /* first try if the object understands forward:: */
629   if (! frwd_sel)
630     frwd_sel = sel_get_any_uid ("forward::");
631
632   if (__objc_responds_to (object, frwd_sel))
633     {
634       imp = get_imp (object->class_pointer, frwd_sel);
635       return (*imp) (object, frwd_sel, sel, args);
636     }
637
638   /* If the object recognizes the doesNotRecognize: method then we're going
639      to send it. */
640   err_sel = sel_get_any_uid ("doesNotRecognize:");
641   if (__objc_responds_to (object, err_sel))
642     {
643       imp = get_imp (object->class_pointer, err_sel);
644       return (*imp) (object, err_sel, sel);
645     }
646   
647   /* The object doesn't recognize the method.  Check for responding to
648      error:.  If it does then sent it. */
649   {
650     char msg[256 + strlen ((const char *) sel_get_name (sel))
651              + strlen ((const char *) object->class_pointer->name)];
652
653     sprintf (msg, "(%s) %s does not recognize %s",
654              (CLS_ISMETA (object->class_pointer)
655               ? "class"
656               : "instance" ),
657              object->class_pointer->name, sel_get_name (sel));
658
659     err_sel = sel_get_any_uid ("error:");
660     if (__objc_responds_to (object, err_sel))
661       {
662         imp = get_imp (object->class_pointer, err_sel);
663         return (*imp) (object, sel_get_any_uid ("error:"), msg);
664       }
665
666     /* The object doesn't respond to doesNotRecognize: or error:;  Therefore,
667        a default action is taken. */
668     objc_error (object, OBJC_ERR_UNIMPLEMENTED, "%s\n", msg);
669
670     return 0;
671   }
672 }
673
674 void
675 __objc_print_dtable_stats ()
676 {
677   int total = 0;
678
679   objc_mutex_lock (__objc_runtime_mutex);
680
681 #ifdef OBJC_SPARSE2
682   printf ("memory usage: (%s)\n", "2-level sparse arrays");
683 #else
684   printf ("memory usage: (%s)\n", "3-level sparse arrays");
685 #endif
686
687   printf ("arrays: %d = %ld bytes\n", narrays, 
688           (long) narrays * sizeof (struct sarray));
689   total += narrays * sizeof (struct sarray);
690   printf ("buckets: %d = %ld bytes\n", nbuckets, 
691           (long) nbuckets * sizeof (struct sbucket));
692   total += nbuckets * sizeof (struct sbucket);
693
694   printf ("idxtables: %d = %ld bytes\n",
695           idxsize, (long) idxsize * sizeof (void *));
696   total += idxsize * sizeof (void *);
697   printf ("-----------------------------------\n");
698   printf ("total: %d bytes\n", total);
699   printf ("===================================\n");
700
701   objc_mutex_unlock (__objc_runtime_mutex);
702 }
703
704 /* Returns the uninstalled dispatch table indicator.
705  If a class' dispatch table points to __objc_uninstalled_dtable
706  then that means it needs its dispatch table to be installed. */
707 inline
708 struct sarray *
709 objc_get_uninstalled_dtable ()
710 {
711   return __objc_uninstalled_dtable;
712 }