gcc/objc/sendmsg.c

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