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