]>
Commit | Line | Data |
---|---|---|
88e17b57 | 1 | /* GNU Objective C Runtime message lookup |
0fc39d8a | 2 | Copyright (C) 1993, 1995, 1996, 1997, 1998, |
435317e2 | 3 | 2001, 2002, 2004 Free Software Foundation, Inc. |
88e17b57 BE |
4 | Contributed by Kresten Krab Thorup |
5 | ||
38709cad | 6 | This file is part of GCC. |
88e17b57 | 7 | |
38709cad | 8 | GCC is free software; you can redistribute it and/or modify it under the |
88e17b57 BE |
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 | ||
38709cad | 12 | GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
88e17b57 BE |
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 | |
38709cad | 18 | GCC; see the file COPYING. If not, write to the Free Software |
88e17b57 BE |
19 | Foundation, 59 Temple Place - Suite 330, |
20 | Boston, MA 02111-1307, 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 | ||
4977bab6 | 28 | /* FIXME: This file has no business including tm.h. */ |
435317e2 AP |
29 | /* FIXME: This should be using libffi instead of __builtin_apply |
30 | and friends. */ | |
4977bab6 | 31 | |
bce1b489 | 32 | #include "tconfig.h" |
4977bab6 ZW |
33 | #include "coretypes.h" |
34 | #include "tm.h" | |
88e17b57 BE |
35 | #include "runtime.h" |
36 | #include "sarray.h" | |
37 | #include "encoding.h" | |
38 | #include "runtime-info.h" | |
39 | ||
435317e2 | 40 | /* This is how we hack STRUCT_VALUE to be 1 or 0. */ |
88e17b57 BE |
41 | #define gen_rtx(args...) 1 |
42 | #define gen_rtx_MEM(args...) 1 | |
68b61df9 | 43 | #define gen_rtx_REG(args...) 1 |
88e17b57 BE |
44 | #define rtx int |
45 | ||
40165636 | 46 | #if ! defined (STRUCT_VALUE) || STRUCT_VALUE == 0 |
88e17b57 BE |
47 | #define INVISIBLE_STRUCT_RETURN 1 |
48 | #else | |
49 | #define INVISIBLE_STRUCT_RETURN 0 | |
50 | #endif | |
51 | ||
52 | /* The uninstalled dispatch table */ | |
40165636 | 53 | struct sarray *__objc_uninstalled_dtable = 0; /* !T:MUTEX */ |
88e17b57 | 54 | |
68b61df9 OP |
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. */ | |
40165636 | 58 | IMP (*__objc_msg_forward) (SEL) = NULL; |
68b61df9 | 59 | |
88e17b57 | 60 | /* Send +initialize to class */ |
40165636 | 61 | static void __objc_send_initialize (Class); |
88e17b57 BE |
62 | |
63 | static void __objc_install_dispatch_table_for_class (Class); | |
64 | ||
65 | /* Forward declare some functions */ | |
40165636 | 66 | static void __objc_init_install_dtable (id, SEL); |
88e17b57 BE |
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 | */ | |
40165636 RB |
74 | static double __objc_double_forward (id, SEL, ...); |
75 | static id __objc_word_forward (id, SEL, ...); | |
88e17b57 BE |
76 | typedef struct { id many[8]; } __big; |
77 | #if INVISIBLE_STRUCT_RETURN | |
78 | static __big | |
79 | #else | |
80 | static id | |
81 | #endif | |
40165636 | 82 | __objc_block_forward (id, SEL, ...); |
88e17b57 | 83 | static Method_t search_for_method_in_hierarchy (Class class, SEL sel); |
40165636 | 84 | Method_t search_for_method_in_list (MethodList_t list, SEL op); |
faaa30fe | 85 | id nil_method (id, SEL); |
40165636 RB |
86 | |
87 | /* Given a selector, return the proper forwarding implementation. */ | |
435317e2 | 88 | inline |
40165636 RB |
89 | IMP |
90 | __objc_get_forward_imp (SEL sel) | |
91 | { | |
bd8d449d NP |
92 | /* If a custom forwarding hook was registered, try getting a forwarding |
93 | * function from it. */ | |
40165636 RB |
94 | if (__objc_msg_forward) |
95 | { | |
96 | IMP result; | |
bd8d449d | 97 | if ((result = __objc_msg_forward (sel)) != NULL) |
40165636 RB |
98 | return result; |
99 | } | |
bd8d449d NP |
100 | |
101 | /* In all other cases, use the default forwarding functions built using | |
102 | * __builtin_apply and friends. */ | |
40165636 RB |
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 | } | |
88e17b57 BE |
118 | |
119 | /* Given a class and selector, return the selector's implementation. */ | |
435317e2 | 120 | inline |
88e17b57 BE |
121 | IMP |
122 | get_imp (Class class, SEL sel) | |
123 | { | |
c19f8e35 NP |
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. */ | |
40165636 | 132 | void *res = sarray_get_safe (class->dtable, (size_t) sel->sel_id); |
88e17b57 BE |
133 | if (res == 0) |
134 | { | |
135 | /* Not a valid method */ | |
40165636 | 136 | if (class->dtable == __objc_uninstalled_dtable) |
88e17b57 BE |
137 | { |
138 | /* The dispatch table needs to be installed. */ | |
40165636 | 139 | objc_mutex_lock (__objc_runtime_mutex); |
c19f8e35 NP |
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 | ||
40165636 | 150 | objc_mutex_unlock (__objc_runtime_mutex); |
88e17b57 BE |
151 | /* Call ourselves with the installed dispatch table |
152 | and get the real method */ | |
40165636 | 153 | res = get_imp (class, sel); |
88e17b57 BE |
154 | } |
155 | else | |
156 | { | |
c19f8e35 NP |
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 | } | |
88e17b57 BE |
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. */ | |
435317e2 | 181 | inline |
88e17b57 BE |
182 | BOOL |
183 | __objc_responds_to (id object, SEL sel) | |
184 | { | |
40165636 | 185 | void *res; |
88e17b57 BE |
186 | |
187 | /* Install dispatch table if need be */ | |
188 | if (object->class_pointer->dtable == __objc_uninstalled_dtable) | |
189 | { | |
40165636 | 190 | objc_mutex_lock (__objc_runtime_mutex); |
c19f8e35 NP |
191 | if (object->class_pointer->dtable == __objc_uninstalled_dtable) |
192 | { | |
193 | __objc_install_dispatch_table_for_class (object->class_pointer); | |
194 | } | |
40165636 | 195 | objc_mutex_unlock (__objc_runtime_mutex); |
88e17b57 BE |
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. */ | |
435317e2 | 206 | inline |
88e17b57 | 207 | IMP |
40165636 | 208 | objc_msg_lookup (id receiver, SEL op) |
88e17b57 BE |
209 | { |
210 | IMP result; | |
40165636 | 211 | if (receiver) |
88e17b57 BE |
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 */ | |
40165636 | 218 | if (receiver->class_pointer->dtable == __objc_uninstalled_dtable) |
88e17b57 BE |
219 | { |
220 | /* The dispatch table needs to be installed. | |
221 | This happens on the very first method call to the class. */ | |
40165636 | 222 | __objc_init_install_dtable (receiver, op); |
88e17b57 BE |
223 | |
224 | /* Get real method for this in newly installed dtable */ | |
40165636 | 225 | result = get_imp (receiver->class_pointer, op); |
88e17b57 BE |
226 | } |
227 | else | |
228 | { | |
c19f8e35 NP |
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 | } | |
88e17b57 BE |
242 | } |
243 | } | |
244 | return result; | |
245 | } | |
246 | else | |
faaa30fe | 247 | return (IMP)nil_method; |
88e17b57 BE |
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 | |
faaa30fe | 256 | return (IMP)nil_method; |
88e17b57 BE |
257 | } |
258 | ||
40165636 | 259 | int method_get_sizeof_arguments (Method *); |
88e17b57 BE |
260 | |
261 | retval_t | |
40165636 | 262 | objc_msg_sendv (id object, SEL op, arglist_t arg_frame) |
88e17b57 | 263 | { |
40165636 | 264 | Method *m = class_get_instance_method (object->class_pointer, op); |
88e17b57 | 265 | const char *type; |
40165636 RB |
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)); | |
88e17b57 BE |
271 | } |
272 | ||
273 | void | |
40165636 | 274 | __objc_init_dispatch_tables () |
88e17b57 | 275 | { |
40165636 | 276 | __objc_uninstalled_dtable = sarray_new (200, 0); |
88e17b57 BE |
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 | |
40165636 | 283 | __objc_init_install_dtable (id receiver, SEL op __attribute__ ((__unused__))) |
88e17b57 | 284 | { |
c19f8e35 NP |
285 | objc_mutex_lock (__objc_runtime_mutex); |
286 | ||
88e17b57 BE |
287 | /* This may happen, if the programmer has taken the address of a |
288 | method before the dtable was initialized... too bad for him! */ | |
40165636 | 289 | if (receiver->class_pointer->dtable != __objc_uninstalled_dtable) |
c19f8e35 NP |
290 | { |
291 | objc_mutex_unlock (__objc_runtime_mutex); | |
292 | return; | |
293 | } | |
294 | ||
40165636 | 295 | if (CLS_ISCLASS (receiver->class_pointer)) |
88e17b57 BE |
296 | { |
297 | /* receiver is an ordinary object */ | |
40165636 | 298 | assert (CLS_ISCLASS (receiver->class_pointer)); |
88e17b57 BE |
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 :-) */ | |
40165636 | 305 | __objc_send_initialize (receiver->class_pointer); |
88e17b57 BE |
306 | } |
307 | else | |
308 | { | |
309 | /* receiver is a class object */ | |
40165636 RB |
310 | assert (CLS_ISCLASS ((Class)receiver)); |
311 | assert (CLS_ISMETA (receiver->class_pointer)); | |
88e17b57 BE |
312 | |
313 | /* Install real dtable for factory methods */ | |
314 | __objc_install_dispatch_table_for_class (receiver->class_pointer); | |
315 | ||
40165636 | 316 | __objc_send_initialize ((Class)receiver); |
88e17b57 | 317 | } |
40165636 | 318 | objc_mutex_unlock (__objc_runtime_mutex); |
88e17b57 BE |
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 | |
40165636 | 324 | __objc_install_premature_dtable (Class class) |
88e17b57 | 325 | { |
40165636 | 326 | assert (__objc_uninstalled_dtable); |
88e17b57 BE |
327 | class->dtable = __objc_uninstalled_dtable; |
328 | } | |
329 | ||
330 | /* Send +initialize to class if not already done */ | |
331 | static void | |
40165636 | 332 | __objc_send_initialize (Class class) |
88e17b57 BE |
333 | { |
334 | /* This *must* be a class object */ | |
40165636 RB |
335 | assert (CLS_ISCLASS (class)); |
336 | assert (! CLS_ISMETA (class)); | |
88e17b57 | 337 | |
40165636 | 338 | if (! CLS_ISINITIALIZED (class)) |
88e17b57 | 339 | { |
40165636 RB |
340 | CLS_SETINITIALIZED (class); |
341 | CLS_SETINITIALIZED (class->class_pointer); | |
88e17b57 BE |
342 | |
343 | /* Create the garbage collector type memory description */ | |
344 | __objc_generate_gc_type_description (class); | |
345 | ||
40165636 RB |
346 | if (class->super_class) |
347 | __objc_send_initialize (class->super_class); | |
88e17b57 BE |
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 | ||
40165636 | 358 | for (i = 0; i < method_list->method_count; i++) { |
88e17b57 BE |
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) | |
40165636 | 374 | (*imp) ((id) class, op); |
88e17b57 BE |
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 | ||
40165636 | 391 | if (! method_list) |
88e17b57 BE |
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 */ | |
40165636 RB |
414 | if (! CLS_ISRESOLV (class)) |
415 | __objc_resolve_class_links (); | |
88e17b57 BE |
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 | { | |
40165636 | 425 | objc_mutex_lock (__objc_runtime_mutex); |
88e17b57 | 426 | class->dtable = sarray_new (__objc_selector_max_index, 0); |
40165636 | 427 | objc_mutex_unlock (__objc_runtime_mutex); |
88e17b57 BE |
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 | ||
40165636 | 445 | objc_mutex_lock (__objc_runtime_mutex); |
88e17b57 BE |
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 | ||
40165636 | 458 | objc_mutex_unlock (__objc_runtime_mutex); |
88e17b57 BE |
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 | |
435317e2 | 468 | SEL's by the function __objc_register_selectors_from_class. */ |
88e17b57 BE |
469 | void |
470 | class_add_method_list (Class class, MethodList_t list) | |
471 | { | |
88e17b57 | 472 | /* Passing of a linked list is not allowed. Do multiple calls. */ |
40165636 | 473 | assert (! list->method_next); |
88e17b57 | 474 | |
435317e2 | 475 | __objc_register_selectors_from_list(list); |
88e17b57 BE |
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 | |
40165636 | 486 | class_get_instance_method (Class class, SEL op) |
88e17b57 | 487 | { |
40165636 | 488 | return search_for_method_in_hierarchy (class, op); |
88e17b57 BE |
489 | } |
490 | ||
491 | Method_t | |
40165636 | 492 | class_get_class_method (MetaClass class, SEL op) |
88e17b57 | 493 | { |
40165636 | 494 | return search_for_method_in_hierarchy (class, op); |
88e17b57 BE |
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:: */ | |
40165636 RB |
618 | if (! frwd_sel) |
619 | frwd_sel = sel_get_any_uid ("forward::"); | |
88e17b57 BE |
620 | |
621 | if (__objc_responds_to (object, frwd_sel)) | |
622 | { | |
40165636 RB |
623 | imp = get_imp (object->class_pointer, frwd_sel); |
624 | return (*imp) (object, frwd_sel, sel, args); | |
88e17b57 BE |
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 | { | |
40165636 RB |
639 | char msg[256 + strlen ((const char *) sel_get_name (sel)) |
640 | + strlen ((const char *) object->class_pointer->name)]; | |
88e17b57 BE |
641 | |
642 | sprintf (msg, "(%s) %s does not recognize %s", | |
40165636 | 643 | (CLS_ISMETA (object->class_pointer) |
88e17b57 BE |
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 | |
40165636 | 664 | __objc_print_dtable_stats () |
88e17b57 BE |
665 | { |
666 | int total = 0; | |
667 | ||
40165636 | 668 | objc_mutex_lock (__objc_runtime_mutex); |
88e17b57 | 669 | |
88e17b57 | 670 | #ifdef OBJC_SPARSE2 |
40165636 | 671 | printf ("memory usage: (%s)\n", "2-level sparse arrays"); |
88e17b57 | 672 | #else |
40165636 | 673 | printf ("memory usage: (%s)\n", "3-level sparse arrays"); |
88e17b57 | 674 | #endif |
88e17b57 | 675 | |
40165636 RB |
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); | |
88e17b57 BE |
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. */ | |
435317e2 | 696 | inline |
40165636 RB |
697 | struct sarray * |
698 | objc_get_uninstalled_dtable () | |
88e17b57 BE |
699 | { |
700 | return __objc_uninstalled_dtable; | |
701 | } |