libobjc/sendmsg.c

   1 /* GNU Objective C Runtime message lookup
   2    Copyright (C) 1993, 1995, 1996, 1997, 1998 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       __objc_send_initialize((Class)receiver);
 248     }
 249   objc_mutex_unlock(__objc_runtime_mutex);
 250 }
 251
 252 /* Install dummy table for class which causes the first message to
 253    that class (or instances hereof) to be initialized properly */
 254 void
 255 __objc_install_premature_dtable(Class class)
 256 {
 257   assert(__objc_uninstalled_dtable);
 258   class->dtable = __objc_uninstalled_dtable;
 259 }
 260
 261 /* Send +initialize to class if not already done */
 262 static void
 263 __objc_send_initialize(Class class)
 264 {
 265   /* This *must* be a class object */
 266   assert(CLS_ISCLASS(class));
 267   assert(!CLS_ISMETA(class));
 268
 269   if (!CLS_ISINITIALIZED(class))
 270     {
 271       CLS_SETINITIALIZED(class);
 272       CLS_SETINITIALIZED(class->class_pointer);
 273
 274       /* Create the garbage collector type memory description */
 275       __objc_generate_gc_type_description (class);
 276
 277       if(class->super_class)
 278         __objc_send_initialize(class->super_class);
 279
 280       {
 281         SEL          op = sel_register_name ("initialize");
 282         IMP          imp = 0;
 283         MethodList_t method_list = class->class_pointer->methods;
 284
 285         while (method_list) {
 286           int i;
 287           Method_t method;
 288
 289           for (i = 0; i< method_list->method_count; i++) {
 290             method = &(method_list->method_list[i]);
 291             if (method->method_name
 292                 && method->method_name->sel_id == op->sel_id) {
 293               imp = method->method_imp;
 294               break;
 295             }
 296           }
 297
 298           if (imp)
 299             break;
 300
 301           method_list = method_list->method_next;
 302
 303         }
 304         if (imp)
 305             (*imp)((id)class, op);
 306
 307       }
 308     }
 309 }
 310
 311 /* Walk on the methods list of class and install the methods in the reverse
 312    order of the lists. Since methods added by categories are before the methods
 313    of class in the methods list, this allows categories to substitute methods
 314    declared in class. However if more than one category replaces the same
 315    method nothing is guaranteed about what method will be used.
 316    Assumes that __objc_runtime_mutex is locked down. */
 317 static void
 318 __objc_install_methods_in_dtable (Class class, MethodList_t method_list)
 319 {
 320   int i;
 321
 322   if (!method_list)
 323     return;
 324
 325   if (method_list->method_next)
 326     __objc_install_methods_in_dtable (class, method_list->method_next);
 327
 328   for (i = 0; i < method_list->method_count; i++)
 329     {
 330       Method_t method = &(method_list->method_list[i]);
 331       sarray_at_put_safe (class->dtable,
 332                           (sidx) method->method_name->sel_id,
 333                           method->method_imp);
 334     }
 335 }
 336
 337 /* Assumes that __objc_runtime_mutex is locked down. */
 338 static void
 339 __objc_install_dispatch_table_for_class (Class class)
 340 {
 341   Class super;
 342
 343   /* If the class has not yet had its class links resolved, we must
 344      re-compute all class links */
 345   if(!CLS_ISRESOLV(class))
 346     __objc_resolve_class_links();
 347
 348   super = class->super_class;
 349
 350   if (super != 0 && (super->dtable == __objc_uninstalled_dtable))
 351     __objc_install_dispatch_table_for_class (super);
 352
 353   /* Allocate dtable if necessary */
 354   if (super == 0)
 355     {
 356       objc_mutex_lock(__objc_runtime_mutex);
 357       class->dtable = sarray_new (__objc_selector_max_index, 0);
 358       objc_mutex_unlock(__objc_runtime_mutex);
 359     }
 360   else
 361     class->dtable = sarray_lazy_copy (super->dtable);
 362
 363   __objc_install_methods_in_dtable (class, class->methods);
 364 }
 365
 366 void
 367 __objc_update_dispatch_table_for_class (Class class)
 368 {
 369   Class next;
 370   struct sarray *arr;
 371
 372   /* not yet installed -- skip it */
 373   if (class->dtable == __objc_uninstalled_dtable)
 374     return;
 375
 376   objc_mutex_lock(__objc_runtime_mutex);
 377
 378   arr = class->dtable;
 379   __objc_install_premature_dtable (class); /* someone might require it... */
 380   sarray_free (arr);                       /* release memory */
 381
 382   /* could have been lazy... */
 383   __objc_install_dispatch_table_for_class (class);
 384
 385   if (class->subclass_list)     /* Traverse subclasses */
 386     for (next = class->subclass_list; next; next = next->sibling_class)
 387       __objc_update_dispatch_table_for_class (next);
 388
 389   objc_mutex_unlock(__objc_runtime_mutex);
 390 }
 391
 392
 393 /* This function adds a method list to a class.  This function is
 394    typically called by another function specific to the run-time.  As
 395    such this function does not worry about thread safe issues.
 396
 397    This one is only called for categories. Class objects have their
 398    methods installed right away, and their selectors are made into
 399    SEL's by the function __objc_register_selectors_from_class. */
 400 void
 401 class_add_method_list (Class class, MethodList_t list)
 402 {
 403   int i;
 404
 405   /* Passing of a linked list is not allowed.  Do multiple calls.  */
 406   assert (!list->method_next);
 407
 408   /* Check for duplicates.  */
 409   for (i = 0; i < list->method_count; ++i)
 410     {
 411       Method_t method = &list->method_list[i];
 412
 413       if (method->method_name)  /* Sometimes these are NULL */
 414         {
 415           /* This is where selector names are transmogrified to SEL's */
 416           method->method_name =
 417             sel_register_typed_name ((const char*)method->method_name,
 418                                      method->method_types);
 419         }
 420     }
 421
 422   /* Add the methods to the class's method list.  */
 423   list->method_next = class->methods;
 424   class->methods = list;
 425
 426   /* Update the dispatch table of class */
 427   __objc_update_dispatch_table_for_class (class);
 428 }
 429
 430 Method_t
 431 class_get_instance_method(Class class, SEL op)
 432 {
 433   return search_for_method_in_hierarchy(class, op);
 434 }
 435
 436 Method_t
 437 class_get_class_method(MetaClass class, SEL op)
 438 {
 439   return search_for_method_in_hierarchy(class, op);
 440 }
 441
 442
 443 /* Search for a method starting from the current class up its hierarchy.
 444    Return a pointer to the method's method structure if found.  NULL
 445    otherwise. */
 446
 447 static Method_t
 448 search_for_method_in_hierarchy (Class cls, SEL sel)
 449 {
 450   Method_t method = NULL;
 451   Class class;
 452
 453   if (! sel_is_mapped (sel))
 454     return NULL;
 455
 456   /* Scan the method list of the class.  If the method isn't found in the
 457      list then step to its super class. */
 458   for (class = cls; ((! method) && class); class = class->super_class)
 459     method = search_for_method_in_list (class->methods, sel);
 460
 461   return method;
 462 }
 463
 464
 465
 466 /* Given a linked list of method and a method's name.  Search for the named
 467    method's method structure.  Return a pointer to the method's method
 468    structure if found.  NULL otherwise. */
 469 Method_t
 470 search_for_method_in_list (MethodList_t list, SEL op)
 471 {
 472   MethodList_t method_list = list;
 473
 474   if (! sel_is_mapped (op))
 475     return NULL;
 476
 477   /* If not found then we'll search the list.  */
 478   while (method_list)
 479     {
 480       int i;
 481
 482       /* Search the method list.  */
 483       for (i = 0; i < method_list->method_count; ++i)
 484         {
 485           Method_t method = &method_list->method_list[i];
 486
 487           if (method->method_name)
 488             if (method->method_name->sel_id == op->sel_id)
 489               return method;
 490         }
 491
 492       /* The method wasn't found.  Follow the link to the next list of
 493          methods.  */
 494       method_list = method_list->method_next;
 495     }
 496
 497   return NULL;
 498 }
 499
 500 static retval_t __objc_forward (id object, SEL sel, arglist_t args);
 501
 502 /* Forwarding pointers/integers through the normal registers */
 503 static id
 504 __objc_word_forward (id rcv, SEL op, ...)
 505 {
 506   void *args, *res;
 507
 508   args = __builtin_apply_args ();
 509   res = __objc_forward (rcv, op, args);
 510   if (res)
 511     __builtin_return (res);
 512   else
 513     return res;
 514 }
 515
 516 /* Specific routine for forwarding floats/double because of
 517    architectural differences on some processors.  i386s for
 518    example which uses a floating point stack versus general
 519    registers for floating point numbers.  This forward routine
 520    makes sure that GCC restores the proper return values */
 521 static double
 522 __objc_double_forward (id rcv, SEL op, ...)
 523 {
 524   void *args, *res;
 525
 526   args = __builtin_apply_args ();
 527   res = __objc_forward (rcv, op, args);
 528   __builtin_return (res);
 529 }
 530
 531 #if INVISIBLE_STRUCT_RETURN
 532 static __big
 533 #else
 534 static id
 535 #endif
 536 __objc_block_forward (id rcv, SEL op, ...)
 537 {
 538   void *args, *res;
 539
 540   args = __builtin_apply_args ();
 541   res = __objc_forward (rcv, op, args);
 542   if (res)
 543     __builtin_return (res);
 544   else
 545 #if INVISIBLE_STRUCT_RETURN
 546     return (__big) {{0, 0, 0, 0, 0, 0, 0, 0}};
 547 #else
 548     return nil;
 549 #endif
 550 }
 551
 552
 553 /* This function is installed in the dispatch table for all methods which are
 554    not implemented.  Thus, it is called when a selector is not recognized. */
 555 static retval_t
 556 __objc_forward (id object, SEL sel, arglist_t args)
 557 {
 558   IMP imp;
 559   static SEL frwd_sel = 0;                      /* !T:SAFE2 */
 560   SEL err_sel;
 561
 562   /* first try if the object understands forward:: */
 563   if (!frwd_sel)
 564     frwd_sel = sel_get_any_uid("forward::");
 565
 566   if (__objc_responds_to (object, frwd_sel))
 567     {
 568       imp = get_imp(object->class_pointer, frwd_sel);
 569       return (*imp)(object, frwd_sel, sel, args);
 570     }
 571
 572   /* If the object recognizes the doesNotRecognize: method then we're going
 573      to send it. */
 574   err_sel = sel_get_any_uid ("doesNotRecognize:");
 575   if (__objc_responds_to (object, err_sel))
 576     {
 577       imp = get_imp (object->class_pointer, err_sel);
 578       return (*imp) (object, err_sel, sel);
 579     }
 580
 581   /* The object doesn't recognize the method.  Check for responding to
 582      error:.  If it does then sent it. */
 583   {
 584     size_t strlen (const char*);
 585     char msg[256 + strlen ((const char*)sel_get_name (sel))
 586              + strlen ((const char*)object->class_pointer->name)];
 587
 588     sprintf (msg, "(%s) %s does not recognize %s",
 589              (CLS_ISMETA(object->class_pointer)
 590               ? "class"
 591               : "instance" ),
 592              object->class_pointer->name, sel_get_name (sel));
 593
 594     err_sel = sel_get_any_uid ("error:");
 595     if (__objc_responds_to (object, err_sel))
 596       {
 597         imp = get_imp (object->class_pointer, err_sel);
 598         return (*imp) (object, sel_get_any_uid ("error:"), msg);
 599       }
 600
 601     /* The object doesn't respond to doesNotRecognize: or error:;  Therefore,
 602        a default action is taken. */
 603     objc_error (object, OBJC_ERR_UNIMPLEMENTED, "%s\n", msg);
 604
 605     return 0;
 606   }
 607 }
 608
 609 void
 610 __objc_print_dtable_stats()
 611 {
 612   int total = 0;
 613
 614   objc_mutex_lock(__objc_runtime_mutex);
 615
 616   printf("memory usage: (%s)\n",
 617 #ifdef OBJC_SPARSE2
 618          "2-level sparse arrays"
 619 #else
 620          "3-level sparse arrays"
 621 #endif
 622          );
 623
 624   printf("arrays: %d = %ld bytes\n", narrays,
 625          (long)narrays*sizeof(struct sarray));
 626   total += narrays*sizeof(struct sarray);
 627   printf("buckets: %d = %ld bytes\n", nbuckets,
 628          (long)nbuckets*sizeof(struct sbucket));
 629   total += nbuckets*sizeof(struct sbucket);
 630
 631   printf("idxtables: %d = %ld bytes\n", idxsize, (long)idxsize*sizeof(void*));
 632   total += idxsize*sizeof(void*);
 633   printf("-----------------------------------\n");
 634   printf("total: %d bytes\n", total);
 635   printf("===================================\n");
 636
 637   objc_mutex_unlock(__objc_runtime_mutex);
 638 }
 639
 640 /* Returns the uninstalled dispatch table indicator.
 641  If a class' dispatch table points to __objc_uninstalled_dtable
 642  then that means it needs its dispatch table to be installed. */
 643 __inline__
 644 struct sarray*
 645 objc_get_uninstalled_dtable()
 646 {
 647   return __objc_uninstalled_dtable;
 648 }