1 /* GNU Runtime ABI version 8 2 Copyright (C) 2011-2015 Free Software Foundation, Inc. 3 Contributed by Iain Sandoe (split from objc-act.c) 4 5 This file is part of GCC. 6 7 GCC is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3, or (at your option) 10 any later version. 11 12 GCC is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with GCC; see the file COPYING3. If not see 19 <http://www.gnu.org/licenses/>. */ 20 21 #include "config.h" 22 #include "system.h" 23 #include "coretypes.h" 24 #include "hash-set.h" 25 #include "machmode.h" 26 #include "vec.h" 27 #include "double-int.h" 28 #include "input.h" 29 #include "alias.h" 30 #include "symtab.h" 31 #include "options.h" 32 #include "wide-int.h" 33 #include "inchash.h" 34 #include "tree.h" 35 #include "fold-const.h" 36 #include "stringpool.h" 37 38 #ifdef OBJCPLUS 39 #include "cp/cp-tree.h" 40 #else 41 #include "c/c-tree.h" 42 #include "c/c-lang.h" 43 #endif 44 45 #include "langhooks.h" 46 #include "c-family/c-objc.h" 47 #include "objc-act.h" 48 49 /* When building Objective-C++, we are not linking against the C front-end 50 and so need to replicate the C tree-construction functions in some way. */ 51 #ifdef OBJCPLUS 52 #define OBJCP_REMAP_FUNCTIONS 53 #include "objcp-decl.h" 54 #endif /* OBJCPLUS */ 55 56 #include "toplev.h" 57 #include "ggc.h" 58 #include "tree-iterator.h" 59 60 #include "objc-runtime-hooks.h" 61 #include "objc-runtime-shared-support.h" 62 #include "objc-encoding.h" 63 64 /* GNU runtime private definitions. */ 65 #define DEF_CONSTANT_STRING_CLASS_NAME "NXConstantString" 66 67 #define TAG_GETCLASS "objc_get_class" 68 #define TAG_GETMETACLASS "objc_get_meta_class" 69 70 #define TAG_MSGSEND "objc_msg_lookup" 71 #define TAG_MSGSENDSUPER "objc_msg_lookup_super" 72 73 /* GNU-specific tags. */ 74 75 #define TAG_EXECCLASS "__objc_exec_class" 76 #define TAG_GNUINIT "__objc_gnu_init" 77 78 /* The version identifies which language generation and runtime 79 the module (file) was compiled for, and is recorded in the 80 module descriptor. */ 81 #define OBJC_VERSION 8 82 83 #define PROTOCOL_VERSION 2 84 85 /* This macro provides a method of removing ambiguity between runtimes 86 when LTO is in use on targets supporting multiple runtimes. 87 88 For example, at present, any target that includes an implementation of 89 the NeXT runtime needs to place Objective-C meta-data into specific 90 named sections. This should _not_ be done for the GNU runtime, and the 91 following macro is used to attach Objective-C private attributes that may 92 be used to identify the runtime for which the meta-data are intended. */ 93 94 #define OBJCMETA(DECL,VERS,KIND) \ 95 if (VERS) \ 96 DECL_ATTRIBUTES (DECL) = build_tree_list ((VERS), (KIND)); 97 98 static void gnu_runtime_01_initialize (void); 99 100 static void build_selector_template (void); 101 102 static tree gnu_runtime_abi_01_super_superclassfield_id (void); 103 104 static tree gnu_runtime_abi_01_class_decl (tree); 105 static tree gnu_runtime_abi_01_metaclass_decl (tree); 106 static tree gnu_runtime_abi_01_category_decl (tree); 107 static tree gnu_runtime_abi_01_protocol_decl (tree); 108 static tree gnu_runtime_abi_01_string_decl (tree, const char *, string_section); 109 110 static tree gnu_runtime_abi_01_get_class_reference (tree); 111 static tree gnu_runtime_abi_01_build_typed_selector_reference (location_t, tree, 112 tree); 113 static tree gnu_runtime_abi_01_get_protocol_reference (location_t, tree); 114 static tree gnu_runtime_abi_01_build_ivar_ref (location_t, tree, tree); 115 static tree gnu_runtime_abi_01_get_class_super_ref (location_t, struct imp_entry *, bool); 116 static tree gnu_runtime_abi_01_get_category_super_ref (location_t, struct imp_entry *, bool); 117 118 static tree gnu_runtime_abi_01_receiver_is_class_object (tree); 119 static void gnu_runtime_abi_01_get_arg_type_list_base (vec<tree, va_gc> **, 120 tree, int, int); 121 static tree gnu_runtime_abi_01_build_objc_method_call (location_t, tree, tree, 122 tree, tree, tree, int); 123 124 static bool gnu_runtime_abi_01_setup_const_string_class_decl (void); 125 static tree gnu_runtime_abi_01_build_const_string_constructor (location_t, tree,int); 126 127 static void objc_generate_v1_gnu_metadata (void); 128 129 static tree objc_eh_runtime_type (tree type); 130 static tree objc_eh_personality (void); 131 static tree objc_build_exc_ptr (struct objc_try_context **); 132 static tree build_throw_stmt (location_t, tree, bool); 133 static tree begin_catch (struct objc_try_context **, tree, tree, tree, bool); 134 static void finish_catch (struct objc_try_context **, tree); 135 static tree finish_try_stmt (struct objc_try_context **); 136 137 bool 138 objc_gnu_runtime_abi_01_init (objc_runtime_hooks *rthooks) 139 { 140 /* GNU runtime does not need the compiler to change code in order to do GC. */ 141 if (flag_objc_gc) 142 { 143 warning_at (0, 0, "%<-fobjc-gc%> is ignored for %<-fgnu-runtime%>"); 144 flag_objc_gc = 0; 145 } 146 147 /* Although I guess we could, we don't currently support SJLJ exceptions for the 148 GNU runtime. */ 149 if (flag_objc_sjlj_exceptions) 150 { 151 inform (UNKNOWN_LOCATION, "%<-fobjc-sjlj-exceptions%> is ignored for %<-fgnu-runtime%>"); 152 flag_objc_sjlj_exceptions = 0; 153 } 154 155 /* TODO: Complain if -fobjc-abi-version=N was used. */ 156 157 /* TODO: Complain if -fobj-nilcheck was used. */ 158 159 rthooks->initialize = gnu_runtime_01_initialize; 160 rthooks->default_constant_string_class_name = DEF_CONSTANT_STRING_CLASS_NAME; 161 rthooks->tag_getclass = TAG_GETCLASS; 162 rthooks->super_superclassfield_ident = gnu_runtime_abi_01_super_superclassfield_id; 163 164 rthooks->class_decl = gnu_runtime_abi_01_class_decl; 165 rthooks->metaclass_decl = gnu_runtime_abi_01_metaclass_decl; 166 rthooks->category_decl = gnu_runtime_abi_01_category_decl; 167 rthooks->protocol_decl = gnu_runtime_abi_01_protocol_decl; 168 rthooks->string_decl = gnu_runtime_abi_01_string_decl; 169 170 rthooks->get_class_reference = gnu_runtime_abi_01_get_class_reference; 171 rthooks->build_selector_reference = gnu_runtime_abi_01_build_typed_selector_reference; 172 rthooks->get_protocol_reference = gnu_runtime_abi_01_get_protocol_reference; 173 rthooks->build_ivar_reference = gnu_runtime_abi_01_build_ivar_ref; 174 rthooks->get_class_super_ref = gnu_runtime_abi_01_get_class_super_ref; 175 rthooks->get_category_super_ref = gnu_runtime_abi_01_get_category_super_ref; 176 177 rthooks->receiver_is_class_object = gnu_runtime_abi_01_receiver_is_class_object; 178 rthooks->get_arg_type_list_base = gnu_runtime_abi_01_get_arg_type_list_base; 179 rthooks->build_objc_method_call = gnu_runtime_abi_01_build_objc_method_call; 180 181 rthooks->setup_const_string_class_decl = 182 gnu_runtime_abi_01_setup_const_string_class_decl; 183 rthooks->build_const_string_constructor = 184 gnu_runtime_abi_01_build_const_string_constructor; 185 186 rthooks->build_throw_stmt = build_throw_stmt; 187 rthooks->build_exc_ptr = objc_build_exc_ptr; 188 rthooks->begin_catch = begin_catch; 189 rthooks->finish_catch = finish_catch; 190 rthooks->finish_try_stmt = finish_try_stmt; 191 192 rthooks->generate_metadata = objc_generate_v1_gnu_metadata; 193 return true; 194 } 195 196 static void build_selector_table_decl (void); 197 static void build_class_template (void); 198 static void build_category_template (void); 199 static void build_protocol_template (void); 200 201 static GTY(()) tree objc_meta; 202 static GTY(()) tree meta_base; 203 204 static void gnu_runtime_01_initialize (void) 205 { 206 tree type, ftype, IMP_type; 207 208 /* We do not need to mark GNU ObjC metadata for different sections, 209 however, we do need to make sure that it is not mistaken for NeXT 210 metadata. */ 211 objc_meta = get_identifier ("OBJC1METG"); 212 meta_base = get_identifier ("NONE"); 213 214 /* Declare type of selector-objects that represent an operation name. */ 215 /* `const struct objc_selector *' */ 216 type = xref_tag (RECORD_TYPE, get_identifier (TAG_SELECTOR)); 217 type = build_qualified_type (type, TYPE_QUAL_CONST); 218 objc_selector_type = build_pointer_type (type); 219 220 /* typedef id (*IMP)(id, SEL, ...); */ 221 ftype = build_varargs_function_type_list (objc_object_type, 222 objc_object_type, 223 objc_selector_type, 224 NULL_TREE); 225 226 IMP_type = build_pointer_type (ftype); 227 228 build_class_template (); 229 build_super_template (); 230 build_protocol_template (); 231 build_category_template (); 232 233 /* GNU runtime messenger entry points. */ 234 /* TREE_NOTHROW is cleared for the message-sending functions, 235 because the function that gets called can throw in Obj-C++, or 236 could itself call something that can throw even in Obj-C. */ 237 238 /* IMP objc_msg_lookup (id, SEL); */ 239 type = build_function_type_list (IMP_type, 240 objc_object_type, 241 objc_selector_type, 242 NULL_TREE); 243 244 umsg_decl = add_builtin_function (TAG_MSGSEND, 245 type, 0, NOT_BUILT_IN, 246 NULL, NULL_TREE); 247 TREE_NOTHROW (umsg_decl) = 0; 248 249 /* IMP objc_msg_lookup_super (struct objc_super *, SEL); */ 250 type = build_function_type_list (IMP_type, 251 objc_super_type, 252 objc_selector_type, 253 NULL_TREE); 254 255 umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER, 256 type, 0, NOT_BUILT_IN, 257 NULL, NULL_TREE); 258 TREE_NOTHROW (umsg_super_decl) = 0; 259 260 /* The following GNU runtime entry point is called to initialize 261 each module: 262 263 __objc_exec_class (void *); */ 264 type = build_function_type_list (void_type_node, 265 ptr_type_node, 266 NULL_TREE); 267 268 execclass_decl = add_builtin_function (TAG_EXECCLASS, 269 type, 0, NOT_BUILT_IN, 270 NULL, NULL_TREE); 271 272 type = build_function_type_list (objc_object_type, 273 const_string_type_node, 274 NULL_TREE); 275 276 /* id objc_getClass (const char *); */ 277 objc_get_class_decl 278 = add_builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN, 279 NULL, NULL_TREE); 280 281 /* id objc_getMetaClass (const char *); */ 282 objc_get_meta_class_decl = add_builtin_function (TAG_GETMETACLASS, type, 283 0, NOT_BUILT_IN, NULL, 284 NULL_TREE); 285 286 /* static SEL _OBJC_SELECTOR_TABLE[]; */ 287 build_selector_table_decl (); 288 289 /* Stuff for properties. 290 The codegen relies on this being NULL for GNU. */ 291 objc_copyStruct_decl = NULL_TREE; 292 293 /* This is the type of all of the following functions 294 bjc_getPropertyStruct() and objc_setPropertyStruct(). */ 295 type = build_function_type_list (void_type_node, 296 ptr_type_node, 297 const_ptr_type_node, 298 ptrdiff_type_node, 299 boolean_type_node, 300 boolean_type_node, 301 NULL_TREE); 302 303 /* Declare the following function: 304 void 305 objc_getPropertyStruct (void *destination, const void *source, 306 ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */ 307 objc_getPropertyStruct_decl = add_builtin_function ("objc_getPropertyStruct", 308 type, 0, NOT_BUILT_IN, 309 NULL, NULL_TREE); 310 TREE_NOTHROW (objc_getPropertyStruct_decl) = 0; 311 /* Declare the following function: 312 void 313 objc_setPropertyStruct (void *destination, const void *source, 314 ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */ 315 objc_setPropertyStruct_decl = add_builtin_function ("objc_setPropertyStruct", 316 type, 0, NOT_BUILT_IN, 317 NULL, NULL_TREE); 318 TREE_NOTHROW (objc_setPropertyStruct_decl) = 0; 319 320 using_eh_for_cleanups (); 321 lang_hooks.eh_runtime_type = objc_eh_runtime_type; 322 lang_hooks.eh_personality = objc_eh_personality; 323 } 324 325 /* --- templates --- */ 326 /* struct _objc_selector { 327 SEL sel_id; 328 char *sel_type; 329 }; */ 330 331 static void 332 build_selector_template (void) 333 { 334 tree decls, *chain = NULL; 335 336 objc_selector_template = objc_start_struct (get_identifier (UTAG_SELECTOR)); 337 338 /* SEL sel_id; */ 339 decls = add_field_decl (objc_selector_type, "sel_id", &chain); 340 341 /* char *sel_type; */ 342 add_field_decl (string_type_node, "sel_type", &chain); 343 344 objc_finish_struct (objc_selector_template, decls); 345 } 346 347 /* struct _objc_class { 348 struct _objc_class *isa; 349 struct _objc_class *super_class; 350 char *name; 351 long version; 352 long info; 353 long instance_size; 354 struct _objc_ivar_list *ivars; 355 struct _objc_method_list *methods; 356 struct sarray *dtable; 357 struct _objc_class *subclass_list; 358 struct _objc_class *sibling_class; 359 struct _objc_protocol_list *protocols; 360 void *gc_object_type; 361 }; */ 362 363 static void 364 build_class_template (void) 365 { 366 tree ptype, decls, *chain = NULL; 367 368 objc_class_template = objc_start_struct (get_identifier (UTAG_CLASS)); 369 370 /* struct _objc_class *isa; */ 371 decls = add_field_decl (build_pointer_type (objc_class_template), 372 "isa", &chain); 373 374 /* struct _objc_class *super_class; */ 375 add_field_decl (build_pointer_type (objc_class_template), 376 "super_class", &chain); 377 378 /* char *name; */ 379 add_field_decl (string_type_node, "name", &chain); 380 381 /* long version; */ 382 add_field_decl (long_integer_type_node, "version", &chain); 383 384 /* long info; */ 385 add_field_decl (long_integer_type_node, "info", &chain); 386 387 /* long instance_size; */ 388 add_field_decl (long_integer_type_node, "instance_size", &chain); 389 390 /* struct _objc_ivar_list *ivars; */ 391 add_field_decl (objc_ivar_list_ptr,"ivars", &chain); 392 393 /* struct _objc_method_list *methods; */ 394 add_field_decl (objc_method_list_ptr, "methods", &chain); 395 396 /* struct sarray *dtable; */ 397 ptype = build_pointer_type(xref_tag (RECORD_TYPE, 398 get_identifier ("sarray"))); 399 add_field_decl (ptype, "dtable", &chain); 400 401 /* struct objc_class *subclass_list; */ 402 ptype = build_pointer_type (objc_class_template); 403 add_field_decl (ptype, "subclass_list", &chain); 404 405 /* struct objc_class *sibling_class; */ 406 ptype = build_pointer_type (objc_class_template); 407 add_field_decl (ptype, "sibling_class", &chain); 408 409 /* struct _objc_protocol **protocol_list; */ 410 ptype = build_pointer_type (build_pointer_type 411 (xref_tag (RECORD_TYPE, 412 get_identifier (UTAG_PROTOCOL)))); 413 add_field_decl (ptype, "protocol_list", &chain); 414 415 /* void *gc_object_type; */ 416 add_field_decl (build_pointer_type (void_type_node), 417 "gc_object_type", &chain); 418 419 objc_finish_struct (objc_class_template, decls); 420 } 421 422 /* struct _objc_category { 423 char *category_name; 424 char *class_name; 425 struct _objc_method_list *instance_methods; 426 struct _objc_method_list *class_methods; 427 struct _objc_protocol_list *protocols; 428 }; */ 429 430 static void 431 build_category_template (void) 432 { 433 tree ptype, decls, *chain = NULL; 434 435 objc_category_template = objc_start_struct (get_identifier (UTAG_CATEGORY)); 436 437 /* char *category_name; */ 438 decls = add_field_decl (string_type_node, "category_name", &chain); 439 440 /* char *class_name; */ 441 add_field_decl (string_type_node, "class_name", &chain); 442 443 /* struct _objc_method_list *instance_methods; */ 444 add_field_decl (objc_method_list_ptr, "instance_methods", &chain); 445 446 /* struct _objc_method_list *class_methods; */ 447 add_field_decl (objc_method_list_ptr, "class_methods", &chain); 448 449 /* struct _objc_protocol **protocol_list; */ 450 ptype = build_pointer_type (build_pointer_type (objc_protocol_template)); 451 add_field_decl (ptype, "protocol_list", &chain); 452 453 objc_finish_struct (objc_category_template, decls); 454 } 455 456 /* struct _objc_protocol { 457 struct _objc_class *isa; 458 char *protocol_name; 459 struct _objc_protocol **protocol_list; 460 struct _objc__method_prototype_list *instance_methods; 461 struct _objc__method_prototype_list *class_methods; 462 }; */ 463 464 static void 465 build_protocol_template (void) 466 { 467 tree ptype, decls, *chain = NULL; 468 469 objc_protocol_template = objc_start_struct (get_identifier (UTAG_PROTOCOL)); 470 471 /* struct _objc_class *isa; */ 472 ptype = build_pointer_type (xref_tag (RECORD_TYPE, 473 get_identifier (UTAG_CLASS))); 474 decls = add_field_decl (ptype, "isa", &chain); 475 476 /* char *protocol_name; */ 477 add_field_decl (string_type_node, "protocol_name", &chain); 478 479 /* struct _objc_protocol **protocol_list; */ 480 ptype = build_pointer_type (build_pointer_type (objc_protocol_template)); 481 add_field_decl (ptype, "protocol_list", &chain); 482 483 /* struct _objc__method_prototype_list *instance_methods; */ 484 add_field_decl (objc_method_proto_list_ptr, "instance_methods", &chain); 485 486 /* struct _objc__method_prototype_list *class_methods; */ 487 add_field_decl (objc_method_proto_list_ptr, "class_methods", &chain); 488 489 objc_finish_struct (objc_protocol_template, decls); 490 } 491 492 /* --- names, decls + identifiers --- */ 493 494 static void 495 build_selector_table_decl (void) 496 { 497 tree temp; 498 499 build_selector_template (); 500 temp = build_array_type (objc_selector_template, NULL_TREE); 501 502 UOBJC_SELECTOR_TABLE_decl = start_var_decl (temp, "_OBJC_SELECTOR_TABLE"); 503 OBJCMETA (UOBJC_SELECTOR_TABLE_decl, objc_meta, meta_base); 504 } 505 506 507 static tree 508 gnu_runtime_abi_01_super_superclassfield_id (void) 509 { 510 if (!super_superclassfield_id) 511 super_superclassfield_id = get_identifier ("super_class"); 512 return super_superclassfield_id; 513 } 514 515 516 static tree 517 gnu_runtime_abi_01_class_decl (tree klass) 518 { 519 tree decl; 520 char buf[BUFSIZE]; 521 snprintf (buf, BUFSIZE, "_OBJC_Class_%s", 522 IDENTIFIER_POINTER (CLASS_NAME (klass))); 523 decl = start_var_decl (objc_class_template, buf); 524 OBJCMETA (decl, objc_meta, meta_base); 525 return decl; 526 } 527 528 static tree 529 gnu_runtime_abi_01_metaclass_decl (tree klass) 530 { 531 tree decl; 532 char buf[BUFSIZE]; 533 snprintf (buf, BUFSIZE, "_OBJC_MetaClass_%s", 534 IDENTIFIER_POINTER (CLASS_NAME (klass))); 535 decl = start_var_decl (objc_class_template, buf); 536 OBJCMETA (decl, objc_meta, meta_base); 537 return decl; 538 } 539 540 static tree 541 gnu_runtime_abi_01_category_decl (tree klass) 542 { 543 tree decl; 544 char buf[BUFSIZE]; 545 snprintf (buf, BUFSIZE, "_OBJC_Category_%s_on_%s", 546 IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass)), 547 IDENTIFIER_POINTER (CLASS_NAME (klass))); 548 decl = start_var_decl (objc_category_template, buf); 549 OBJCMETA (decl, objc_meta, meta_base); 550 return decl; 551 } 552 553 static tree 554 gnu_runtime_abi_01_protocol_decl (tree p) 555 { 556 tree decl; 557 char buf[BUFSIZE]; 558 559 /* static struct _objc_protocol _OBJC_Protocol_<mumble>; */ 560 snprintf (buf, BUFSIZE, "_OBJC_Protocol_%s", 561 IDENTIFIER_POINTER (PROTOCOL_NAME (p))); 562 decl = start_var_decl (objc_protocol_template, buf); 563 OBJCMETA (decl, objc_meta, meta_base); 564 return decl; 565 } 566 567 static tree 568 gnu_runtime_abi_01_string_decl (tree type, const char *name, 569 string_section where ATTRIBUTE_UNUSED) 570 { 571 tree decl = start_var_decl (type, name); 572 OBJCMETA (decl, objc_meta, meta_base); 573 return decl; 574 } 575 576 /* --- entry --- */ 577 578 static tree 579 gnu_runtime_abi_01_get_class_reference (tree ident) 580 { 581 tree params; 582 583 add_class_reference (ident); 584 585 params = build_tree_list (NULL_TREE, my_build_string_pointer 586 (IDENTIFIER_LENGTH (ident) + 1, 587 IDENTIFIER_POINTER (ident))); 588 589 return build_function_call (input_location, objc_get_class_decl, params); 590 } 591 592 /* Used by build_function_type_for_method. Append the types for 593 receiver & _cmd at the start of a method argument list to ARGTYPES. 594 CONTEXT is either METHOD_DEF or METHOD_REF, saying whether we are 595 trying to define a method or call one. SUPERFLAG says this is for a 596 send to super. METH may be NULL, in the case that there is no 597 prototype. */ 598 599 static void 600 gnu_runtime_abi_01_get_arg_type_list_base (vec<tree, va_gc> **argtypes, 601 tree meth, int context, 602 int superflag ATTRIBUTE_UNUSED) 603 { 604 tree receiver_type; 605 606 if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL) 607 receiver_type = objc_instance_type; 608 else 609 receiver_type = objc_object_type; 610 611 vec_safe_push (*argtypes, receiver_type); 612 /* Selector type - will eventually change to `int'. */ 613 vec_safe_push (*argtypes, objc_selector_type); 614 } 615 616 /* Unused for GNU runtime. */ 617 static tree 618 gnu_runtime_abi_01_receiver_is_class_object (tree a ATTRIBUTE_UNUSED) 619 { 620 return NULL_TREE; 621 } 622 623 /* sel_ref_chain is a list whose "value" fields will be instances of 624 identifier_node that represent the selector. LOC is the location of 625 the @selector. */ 626 627 static tree 628 gnu_runtime_abi_01_build_typed_selector_reference (location_t loc, tree ident, 629 tree prototype) 630 { 631 tree *chain = &sel_ref_chain; 632 tree expr; 633 int index = 0; 634 635 while (*chain) 636 { 637 /* When we do a lookup for @selector () we have no idea of the 638 prototype - so match the first we find. */ 639 if (TREE_VALUE (*chain) == ident 640 && (!prototype || TREE_PURPOSE (*chain) == prototype)) 641 goto return_at_index; 642 643 index++; 644 chain = &TREE_CHAIN (*chain); 645 } 646 647 *chain = tree_cons (prototype, ident, NULL_TREE); 648 649 /* TODO: Use a vec and keep this in it to (a) avoid re-creating and 650 (b) provide better diagnostics for the first time an undefined 651 selector is used. */ 652 return_at_index: 653 expr = build_unary_op (loc, ADDR_EXPR, 654 build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl, 655 build_int_cst (NULL_TREE, index)), 656 1); 657 return convert (objc_selector_type, expr); 658 } 659 660 /* Build a tree expression to send OBJECT the operation SELECTOR, 661 looking up the method on object LOOKUP_OBJECT (often same as OBJECT), 662 assuming the method has prototype METHOD_PROTOTYPE. 663 (That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.) 664 LOC is the location of the expression to build. 665 Use METHOD_PARAMS as list of args to pass to the method. 666 If SUPER_FLAG is nonzero, we look up the superclass's method. */ 667 668 static tree 669 build_objc_method_call (location_t loc, int super_flag, tree method_prototype, 670 tree lookup_object, tree selector, 671 tree method_params) 672 { 673 tree sender = (super_flag ? umsg_super_decl 674 : (flag_objc_direct_dispatch ? umsg_fast_decl 675 : umsg_decl)); 676 tree rcv_p = (super_flag ? objc_super_type : objc_object_type); 677 vec<tree, va_gc> *parms; 678 vec<tree, va_gc> *tv; 679 unsigned nparm = (method_params ? list_length (method_params) : 0); 680 681 /* If a prototype for the method to be called exists, then cast 682 the sender's return type and arguments to match that of the method. 683 Otherwise, leave sender as is. */ 684 tree ret_type 685 = (method_prototype 686 ? TREE_VALUE (TREE_TYPE (method_prototype)) 687 : objc_object_type); 688 tree ftype 689 = build_function_type_for_method (ret_type, method_prototype, 690 METHOD_REF, super_flag); 691 tree sender_cast; 692 tree method, t; 693 694 if (method_prototype && METHOD_TYPE_ATTRIBUTES (method_prototype)) 695 ftype = build_type_attribute_variant (ftype, 696 METHOD_TYPE_ATTRIBUTES 697 (method_prototype)); 698 699 sender_cast = build_pointer_type (ftype); 700 701 lookup_object = build_c_cast (loc, rcv_p, lookup_object); 702 703 /* Use SAVE_EXPR to avoid evaluating the receiver twice. */ 704 lookup_object = save_expr (lookup_object); 705 706 /* Param list + 2 slots for object and selector. */ 707 vec_alloc (parms, nparm + 2); 708 vec_alloc (tv, 2); 709 710 /* First, call the lookup function to get a pointer to the method, 711 then cast the pointer, then call it with the method arguments. */ 712 tv->quick_push (lookup_object); 713 tv->quick_push (selector); 714 method = build_function_call_vec (loc, vNULL, sender, tv, NULL); 715 vec_free (tv); 716 717 /* Pass the appropriate object to the method. */ 718 parms->quick_push ((super_flag ? self_decl : lookup_object)); 719 720 /* Pass the selector to the method. */ 721 parms->quick_push (selector); 722 /* Now append the remainder of the parms. */ 723 if (nparm) 724 for (; method_params; method_params = TREE_CHAIN (method_params)) 725 parms->quick_push (TREE_VALUE (method_params)); 726 727 /* Build an obj_type_ref, with the correct cast for the method call. */ 728 t = build3 (OBJ_TYPE_REF, sender_cast, method, lookup_object, size_zero_node); 729 t = build_function_call_vec (loc, vNULL, t, parms, NULL); 730 vec_free (parms); 731 return t; 732 } 733 734 static tree 735 gnu_runtime_abi_01_build_objc_method_call (location_t loc, 736 tree method_prototype, 737 tree receiver, 738 tree rtype ATTRIBUTE_UNUSED, 739 tree sel_name, 740 tree method_params, 741 int super ATTRIBUTE_UNUSED) 742 { 743 tree selector = 744 gnu_runtime_abi_01_build_typed_selector_reference (loc, 745 sel_name, 746 method_prototype); 747 748 return build_objc_method_call (loc, super, method_prototype, receiver, 749 selector, method_params); 750 } 751 752 static tree 753 gnu_runtime_abi_01_get_protocol_reference (location_t loc, tree p) 754 { 755 tree expr, protocol_struct_type, *chain; 756 if (!PROTOCOL_FORWARD_DECL (p)) 757 PROTOCOL_FORWARD_DECL (p) = gnu_runtime_abi_01_protocol_decl (p); 758 759 expr = build_unary_op (loc, ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0); 760 761 /* ??? Ideally we'd build the reference with objc_protocol_type directly, 762 if we have it, rather than converting it here. */ 763 expr = convert (objc_protocol_type, expr); 764 765 /* The @protocol() expression is being compiled into a pointer to a 766 statically allocated instance of the Protocol class. To become 767 usable at runtime, the 'isa' pointer of the instance need to be 768 fixed up at runtime by the runtime library, to point to the 769 actual 'Protocol' class. */ 770 771 /* For the GNU runtime, put the static Protocol instance in the list 772 of statically allocated instances, so that we make sure that its 773 'isa' pointer is fixed up at runtime by the GNU runtime library 774 to point to the Protocol class (at runtime, when loading the 775 module, the GNU runtime library loops on the statically allocated 776 instances (as found in the defs field in objc_symtab) and fixups 777 all the 'isa' pointers of those objects). */ 778 779 /* This type is a struct containing the fields of a Protocol 780 object. (Cfr. objc_protocol_type instead is the type of a pointer 781 to such a struct). */ 782 protocol_struct_type = xref_tag (RECORD_TYPE, 783 get_identifier (PROTOCOL_OBJECT_CLASS_NAME)); 784 785 /* Look for the list of Protocol statically allocated instances 786 to fixup at runtime. Create a new list to hold Protocol 787 statically allocated instances, if the list is not found. At 788 present there is only another list, holding NSConstantString 789 static instances to be fixed up at runtime. */ 790 791 for (chain = &objc_static_instances; 792 *chain && TREE_VALUE (*chain) != protocol_struct_type; 793 chain = &TREE_CHAIN (*chain)); 794 795 if (!*chain) 796 { 797 *chain = tree_cons (NULL_TREE, protocol_struct_type, NULL_TREE); 798 add_objc_string (OBJC_TYPE_NAME (protocol_struct_type), 799 class_names); 800 } 801 802 /* Add this statically allocated instance to the Protocol list. */ 803 TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, 804 PROTOCOL_FORWARD_DECL (p), 805 TREE_PURPOSE (*chain)); 806 return expr; 807 } 808 809 /* For ABI 8 an IVAR is just a fixed offset in the class struct. */ 810 811 static tree 812 gnu_runtime_abi_01_build_ivar_ref (location_t loc ATTRIBUTE_UNUSED, 813 tree base, tree id) 814 { 815 return objc_build_component_ref (base, id); 816 } 817 818 /* We build super class references as we need them (but keep them once 819 built for the sake of efficiency). */ 820 821 static tree 822 gnu_runtime_abi_01_get_class_super_ref (location_t loc ATTRIBUTE_UNUSED, 823 struct imp_entry *imp, bool inst_meth) 824 { 825 if (inst_meth) 826 { 827 if (!ucls_super_ref) 828 ucls_super_ref = 829 objc_build_component_ref (imp->class_decl, 830 get_identifier ("super_class")); 831 return ucls_super_ref; 832 } 833 else 834 { 835 if (!uucls_super_ref) 836 uucls_super_ref = 837 objc_build_component_ref (imp->meta_decl, 838 get_identifier ("super_class")); 839 return uucls_super_ref; 840 } 841 } 842 843 static tree 844 gnu_runtime_abi_01_get_category_super_ref (location_t loc ATTRIBUTE_UNUSED, 845 struct imp_entry *imp, bool inst_meth) 846 { 847 tree super_name = CLASS_SUPER_NAME (imp->imp_template); 848 tree super_class; 849 850 add_class_reference (super_name); 851 super_class = (inst_meth ? objc_get_class_decl : objc_get_meta_class_decl); 852 super_name = my_build_string_pointer (IDENTIFIER_LENGTH (super_name) + 1, 853 IDENTIFIER_POINTER (super_name)); 854 /* super_class = get_{meta_}class("CLASS_SUPER_NAME"); */ 855 return build_function_call (input_location, 856 super_class, 857 build_tree_list (NULL_TREE, super_name)); 858 } 859 860 static bool 861 gnu_runtime_abi_01_setup_const_string_class_decl (void) 862 { 863 /* Do nothing, and create no error. */ 864 return true; 865 } 866 867 /* Declare a static instance of CLASS_DECL initialized by CONSTRUCTOR. */ 868 869 static GTY(()) int num_static_inst; 870 871 static tree 872 objc_add_static_instance (tree constructor, tree class_decl) 873 { 874 tree *chain, decl; 875 char buf[BUFSIZE]; 876 877 /* Find the list of static instances for the CLASS_DECL. Create one if 878 not found. */ 879 for (chain = &objc_static_instances; 880 *chain && TREE_VALUE (*chain) != class_decl; 881 chain = &TREE_CHAIN (*chain)); 882 if (!*chain) 883 { 884 *chain = tree_cons (NULL_TREE, class_decl, NULL_TREE); 885 add_objc_string (OBJC_TYPE_NAME (class_decl), class_names); 886 } 887 888 snprintf (buf, BUFSIZE, "_OBJC_INSTANCE_%d", num_static_inst++); 889 decl = build_decl (input_location, 890 VAR_DECL, get_identifier (buf), class_decl); 891 TREE_STATIC (decl) = 1; 892 DECL_ARTIFICIAL (decl) = 1; 893 TREE_USED (decl) = 1; 894 DECL_INITIAL (decl) = constructor; 895 DECL_CONTEXT (decl) = NULL; 896 OBJCMETA (decl, objc_meta, meta_base); 897 898 /* We may be writing something else just now. 899 Postpone till end of input. */ 900 DECL_DEFER_OUTPUT (decl) = 1; 901 pushdecl_top_level (decl); 902 rest_of_decl_compilation (decl, 1, 0); 903 904 /* Add the DECL to the head of this CLASS' list. */ 905 TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, decl, TREE_PURPOSE (*chain)); 906 907 return decl; 908 } 909 910 static tree 911 gnu_runtime_abi_01_build_const_string_constructor (location_t loc, tree string, 912 int length) 913 { 914 tree constructor, fields; 915 vec<constructor_elt, va_gc> *v = NULL; 916 917 /* GNU: (NXConstantString *) & ((__builtin_ObjCString) { NULL, string, length }) */ 918 fields = TYPE_FIELDS (internal_const_str_type); 919 CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, 0)); 920 921 fields = DECL_CHAIN (fields); 922 CONSTRUCTOR_APPEND_ELT (v, fields, build_unary_op (loc, 923 ADDR_EXPR, string, 1)); 924 925 fields = DECL_CHAIN (fields); 926 CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, length)); 927 constructor = objc_build_constructor (internal_const_str_type, v); 928 929 constructor = objc_add_static_instance (constructor, constant_string_type); 930 return constructor; 931 } 932 933 /* --- metadata - module initializer --- */ 934 935 /* The GNU runtime requires us to provide a static initializer function 936 for each module: 937 938 static void __objc_gnu_init (void) { 939 __objc_exec_class (&L_OBJC_MODULES); 940 } */ 941 942 943 static void 944 build_module_initializer_routine (void) 945 { 946 tree body; 947 948 #ifdef OBJCPLUS 949 push_lang_context (lang_name_c); /* extern "C" */ 950 #endif 951 952 objc_push_parm (build_decl (input_location, 953 PARM_DECL, NULL_TREE, void_type_node)); 954 #ifdef OBJCPLUS 955 objc_start_function (get_identifier (TAG_GNUINIT), 956 build_function_type_list (void_type_node, NULL_TREE), 957 NULL_TREE, NULL_TREE); 958 #else 959 objc_start_function (get_identifier (TAG_GNUINIT), 960 build_function_type_list (void_type_node, NULL_TREE), 961 NULL_TREE, objc_get_parm_info (0, NULL_TREE)); 962 #endif 963 body = c_begin_compound_stmt (true); 964 add_stmt (build_function_call 965 (input_location, 966 execclass_decl, 967 build_tree_list 968 (NULL_TREE, 969 build_unary_op (input_location, ADDR_EXPR, 970 UOBJC_MODULES_decl, 0)))); 971 add_stmt (c_end_compound_stmt (input_location, body, true)); 972 973 TREE_PUBLIC (current_function_decl) = 0; 974 975 #ifndef OBJCPLUS 976 /* For Objective-C++, we will need to call __objc_gnu_init 977 from objc_generate_static_init_call() below. */ 978 DECL_STATIC_CONSTRUCTOR (current_function_decl) = 1; 979 #endif 980 981 GNU_INIT_decl = current_function_decl; 982 finish_function (); 983 984 #ifdef OBJCPLUS 985 pop_lang_context (); 986 #endif 987 } 988 989 #ifdef OBJCPLUS 990 /* Return 1 if the __objc_gnu_init function has been synthesized and needs 991 to be called by the module initializer routine. */ 992 993 int 994 objc_static_init_needed_p (void) 995 { 996 return (GNU_INIT_decl != NULL_TREE); 997 } 998 999 /* Generate a call to the __objc_gnu_init initializer function. */ 1000 1001 tree 1002 objc_generate_static_init_call (tree ctors ATTRIBUTE_UNUSED) 1003 { 1004 add_stmt (build_stmt (input_location, EXPR_STMT, 1005 build_function_call (input_location, 1006 GNU_INIT_decl, NULL_TREE))); 1007 1008 return ctors; 1009 } 1010 #endif /* OBJCPLUS */ 1011 1012 /* --- Output GNU Meta-data --- */ 1013 1014 static void 1015 generate_classref_translation_entry (tree chain) 1016 { 1017 tree expr, decl, type; 1018 1019 decl = TREE_PURPOSE (chain); 1020 type = TREE_TYPE (decl); 1021 1022 expr = add_objc_string (TREE_VALUE (chain), class_names); 1023 expr = convert (type, expr); /* cast! */ 1024 1025 /* This is a class reference. It is re-written by the runtime, 1026 but will be optimized away unless we force it. */ 1027 DECL_PRESERVE_P (decl) = 1; 1028 OBJCMETA (decl, objc_meta, meta_base); 1029 finish_var_decl (decl, expr); 1030 return; 1031 } 1032 1033 1034 static void 1035 handle_impent (struct imp_entry *impent) 1036 { 1037 char *string; 1038 1039 /* objc_implementation_context = impent->imp_context; 1040 implementation_template = impent->imp_template;*/ 1041 1042 switch (TREE_CODE (impent->imp_context)) 1043 { 1044 case CLASS_IMPLEMENTATION_TYPE: 1045 { 1046 const char *const class_name = 1047 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)); 1048 1049 string = (char *) alloca (strlen (class_name) + 30); 1050 1051 sprintf (string, "__objc_class_name_%s", class_name); 1052 break; 1053 } 1054 case CATEGORY_IMPLEMENTATION_TYPE: 1055 { 1056 const char *const class_name = 1057 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)); 1058 const char *const class_super_name = 1059 IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context)); 1060 1061 string = (char *) alloca (strlen (class_name) 1062 + strlen (class_super_name) + 30); 1063 1064 /* Do the same for categories. Even though no references to 1065 these symbols are generated automatically by the compiler, 1066 it gives you a handle to pull them into an archive by 1067 hand. */ 1068 sprintf (string, "*__objc_category_name_%s_%s", class_name, class_super_name); 1069 break; 1070 } 1071 default: 1072 return; 1073 } 1074 1075 { 1076 tree decl, init; 1077 1078 init = integer_zero_node; 1079 decl = build_decl (input_location, 1080 VAR_DECL, get_identifier (string), TREE_TYPE (init)); 1081 TREE_PUBLIC (decl) = 1; 1082 TREE_READONLY (decl) = 1; 1083 TREE_USED (decl) = 1; 1084 TREE_CONSTANT (decl) = 1; 1085 DECL_CONTEXT (decl) = NULL_TREE; 1086 DECL_ARTIFICIAL (decl) = 1; 1087 TREE_STATIC (decl) = 1; 1088 DECL_INITIAL (decl) = error_mark_node; /* A real initializer is coming... */ 1089 /* We must force the reference. */ 1090 DECL_PRESERVE_P (decl) = 1; 1091 1092 finish_var_decl(decl, init) ; 1093 } 1094 } 1095 1096 tree 1097 build_protocol_initializer (tree type, tree protocol_name, tree protocol_list, 1098 tree inst_methods, tree class_methods) 1099 { 1100 tree expr, ttyp; 1101 location_t loc; 1102 vec<constructor_elt, va_gc> *inits = NULL; 1103 1104 /* TODO: pass the loc in or find it from args. */ 1105 loc = input_location; 1106 ttyp = build_pointer_type (xref_tag (RECORD_TYPE, 1107 get_identifier (UTAG_CLASS))); 1108 /* Filling the "isa" in with a version allows the runtime system to 1109 detect this ... */ 1110 expr = build_int_cst (ttyp, PROTOCOL_VERSION); 1111 1112 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 1113 1114 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_name); 1115 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_list); 1116 1117 ttyp = objc_method_proto_list_ptr; 1118 if (inst_methods) 1119 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0)); 1120 else 1121 expr = convert (ttyp, null_pointer_node); 1122 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 1123 1124 if (class_methods) 1125 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0)); 1126 else 1127 expr = convert (ttyp, null_pointer_node); 1128 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 1129 1130 return objc_build_constructor (type, inits); 1131 } 1132 1133 static tree 1134 generate_protocol_list (tree i_or_p, tree klass_ctxt) 1135 { 1136 tree array_type, ptype, refs_decl, lproto, e, plist; 1137 vec<constructor_elt, va_gc> *v = NULL; 1138 char buf[BUFSIZE]; 1139 int size = 0; 1140 1141 switch (TREE_CODE (i_or_p)) 1142 { 1143 case CLASS_INTERFACE_TYPE: 1144 case CATEGORY_INTERFACE_TYPE: 1145 plist = CLASS_PROTOCOL_LIST (i_or_p); 1146 break; 1147 case PROTOCOL_INTERFACE_TYPE: 1148 plist = PROTOCOL_LIST (i_or_p); 1149 break; 1150 default: 1151 gcc_unreachable (); 1152 } 1153 1154 /* Compute size. */ 1155 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) 1156 if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE 1157 && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto))) 1158 size++; 1159 1160 /* Build initializer. */ 1161 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); 1162 e = build_int_cst (build_pointer_type (objc_protocol_template), size); 1163 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e); 1164 1165 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) 1166 { 1167 tree pval = TREE_VALUE (lproto); 1168 1169 if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE 1170 && PROTOCOL_FORWARD_DECL (pval)) 1171 { 1172 tree fwref = PROTOCOL_FORWARD_DECL (pval); 1173 location_t loc = DECL_SOURCE_LOCATION (fwref) ; 1174 e = build_unary_op (loc, ADDR_EXPR, fwref, 0); 1175 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e); 1176 } 1177 } 1178 1179 /* static struct objc_protocol *refs[n]; */ 1180 1181 switch (TREE_CODE (i_or_p)) 1182 { 1183 case PROTOCOL_INTERFACE_TYPE: 1184 snprintf (buf, BUFSIZE, "_OBJC_ProtocolRefs_%s", 1185 IDENTIFIER_POINTER (PROTOCOL_NAME (i_or_p))); 1186 break; 1187 case CLASS_INTERFACE_TYPE: 1188 snprintf (buf, BUFSIZE, "_OBJC_ClassProtocols_%s", 1189 IDENTIFIER_POINTER (CLASS_NAME (i_or_p))); 1190 break; 1191 case CATEGORY_INTERFACE_TYPE: 1192 snprintf (buf, BUFSIZE, "_OBJC_CategoryProtocols_%s_%s", 1193 IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt)), 1194 IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass_ctxt))); 1195 break; 1196 default: 1197 gcc_unreachable (); 1198 } 1199 1200 ptype = build_pointer_type (objc_protocol_template); 1201 array_type = build_sized_array_type (ptype, size + 3); 1202 refs_decl = start_var_decl (array_type, buf); 1203 OBJCMETA (refs_decl, objc_meta, meta_base); 1204 finish_var_decl (refs_decl, 1205 objc_build_constructor (TREE_TYPE (refs_decl), v)); 1206 1207 return refs_decl; 1208 } 1209 1210 static tree 1211 generate_v1_meth_descriptor_table (tree chain, tree protocol, const char *prefix) 1212 { 1213 tree method_list_template, initlist, decl; 1214 int size; 1215 vec<constructor_elt, va_gc> *v = NULL; 1216 char buf[BUFSIZE]; 1217 1218 if (!chain || !prefix) 1219 return NULL_TREE; 1220 1221 if (!objc_method_prototype_template) 1222 objc_method_prototype_template = build_method_prototype_template (); 1223 1224 size = list_length (chain); 1225 method_list_template = 1226 build_method_prototype_list_template (objc_method_prototype_template, 1227 size); 1228 snprintf (buf, BUFSIZE, "%s_%s", prefix, 1229 IDENTIFIER_POINTER (PROTOCOL_NAME (protocol))); 1230 1231 decl = start_var_decl (method_list_template, buf); 1232 1233 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size)); 1234 initlist = 1235 build_descriptor_table_initializer (objc_method_prototype_template, 1236 chain); 1237 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist); 1238 OBJCMETA (decl, objc_meta, meta_base); 1239 finish_var_decl (decl, objc_build_constructor (method_list_template, v)); 1240 return decl; 1241 } 1242 1243 /* For each protocol which was referenced either from a @protocol() 1244 expression, or because a class/category implements it (then a 1245 pointer to the protocol is stored in the struct describing the 1246 class/category), we create a statically allocated instance of the 1247 Protocol class. The code is written in such a way as to generate 1248 as few Protocol objects as possible; we generate a unique Protocol 1249 instance for each protocol, and we don't generate a Protocol 1250 instance if the protocol is never referenced (either from a 1251 @protocol() or from a class/category implementation). These 1252 statically allocated objects can be referred to via the static 1253 (that is, private to this module) symbols _OBJC_PROTOCOL_n. 1254 1255 The statically allocated Protocol objects that we generate here 1256 need to be fixed up at runtime in order to be used: the 'isa' 1257 pointer of the objects need to be set up to point to the 'Protocol' 1258 class, as known at runtime. 1259 1260 The GNU runtime fixes up all protocols before user code from the module 1261 is executed; it requires pointers to those symbols 1262 to be put in the objc_symtab (which is then passed as argument to 1263 the function __objc_exec_class() which the compiler sets up to be 1264 executed automatically when the module is loaded); setup of those 1265 Protocol objects happen in two ways in the GNU runtime: all 1266 Protocol objects referred to by a class or category implementation 1267 are fixed up when the class/category is loaded; all Protocol 1268 objects referred to by a @protocol() expression are added by the 1269 compiler to the list of statically allocated instances to fixup 1270 (the same list holding the statically allocated constant string 1271 objects). Because, as explained above, the compiler generates as 1272 few Protocol objects as possible, some Protocol object might end up 1273 being referenced multiple times when compiled with the GNU runtime, 1274 and end up being fixed up multiple times at runtime initialization. 1275 But that doesn't hurt, it's just a little inefficient. */ 1276 1277 static void 1278 generate_protocols (void) 1279 { 1280 tree p, encoding; 1281 tree decl; 1282 tree initlist, protocol_name_expr, refs_decl, refs_expr; 1283 1284 /* If a protocol was directly referenced, pull in indirect references. */ 1285 for (p = protocol_chain; p; p = TREE_CHAIN (p)) 1286 if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p)) 1287 generate_protocol_references (PROTOCOL_LIST (p)); 1288 1289 for (p = protocol_chain; p; p = TREE_CHAIN (p)) 1290 { 1291 tree nst_methods = PROTOCOL_NST_METHODS (p); 1292 tree cls_methods = PROTOCOL_CLS_METHODS (p); 1293 1294 /* If protocol wasn't referenced, don't generate any code. */ 1295 decl = PROTOCOL_FORWARD_DECL (p); 1296 1297 if (!decl) 1298 continue; 1299 1300 /* Make sure we link in the Protocol class. */ 1301 add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME)); 1302 1303 while (nst_methods) 1304 { 1305 if (! METHOD_ENCODING (nst_methods)) 1306 { 1307 encoding = encode_method_prototype (nst_methods); 1308 METHOD_ENCODING (nst_methods) = encoding; 1309 } 1310 nst_methods = DECL_CHAIN (nst_methods); 1311 } 1312 1313 UOBJC_INSTANCE_METHODS_decl = 1314 generate_v1_meth_descriptor_table (PROTOCOL_NST_METHODS (p), p, 1315 "_OBJC_PROTOCOL_INSTANCE_METHODS"); 1316 1317 while (cls_methods) 1318 { 1319 if (! METHOD_ENCODING (cls_methods)) 1320 { 1321 encoding = encode_method_prototype (cls_methods); 1322 METHOD_ENCODING (cls_methods) = encoding; 1323 } 1324 1325 cls_methods = DECL_CHAIN (cls_methods); 1326 } 1327 1328 UOBJC_CLASS_METHODS_decl = 1329 generate_v1_meth_descriptor_table (PROTOCOL_CLS_METHODS (p), p, 1330 "_OBJC_PROTOCOL_CLASS_METHODS"); 1331 /* generate_method_descriptors (p);*/ 1332 1333 if (PROTOCOL_LIST (p)) 1334 refs_decl = generate_protocol_list (p, NULL_TREE); 1335 else 1336 refs_decl = 0; 1337 1338 /* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */ 1339 protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names); 1340 1341 if (refs_decl) 1342 refs_expr = convert (build_pointer_type (build_pointer_type 1343 (objc_protocol_template)), 1344 build_unary_op (input_location, 1345 ADDR_EXPR, refs_decl, 0)); 1346 else 1347 refs_expr = build_int_cst (NULL_TREE, 0); 1348 1349 /* UOBJC_INSTANCE_METHODS_decl/UOBJC_CLASS_METHODS_decl are set 1350 by generate_method_descriptors, which is called above. */ 1351 initlist = build_protocol_initializer (TREE_TYPE (decl), 1352 protocol_name_expr, refs_expr, 1353 UOBJC_INSTANCE_METHODS_decl, 1354 UOBJC_CLASS_METHODS_decl); 1355 finish_var_decl (decl, initlist); 1356 } 1357 } 1358 1359 static tree 1360 generate_dispatch_table (tree chain, const char *name) 1361 { 1362 tree decl, method_list_template, initlist; 1363 vec<constructor_elt, va_gc> *v = NULL; 1364 int size = list_length (chain); 1365 1366 if (!objc_method_template) 1367 objc_method_template = build_method_template (); 1368 1369 method_list_template = build_method_list_template (objc_method_template, 1370 size); 1371 initlist = build_dispatch_table_initializer (objc_method_template, chain); 1372 1373 decl = start_var_decl (method_list_template, name); 1374 1375 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node); 1376 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 1377 build_int_cst (integer_type_node, size)); 1378 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist); 1379 1380 OBJCMETA (decl, objc_meta, meta_base); 1381 finish_var_decl (decl, 1382 objc_build_constructor (TREE_TYPE (decl), v)); 1383 1384 return decl; 1385 } 1386 1387 /* Init a category. */ 1388 static tree 1389 build_category_initializer (tree type, tree cat_name, tree class_name, 1390 tree inst_methods, tree class_methods, 1391 tree protocol_list) 1392 { 1393 tree expr, ltyp; 1394 location_t loc; 1395 vec<constructor_elt, va_gc> *v = NULL; 1396 1397 /* TODO: pass the loc in or find it from args. */ 1398 /* TODO: pass the loc in or find it from args. */ 1399 loc = UNKNOWN_LOCATION; 1400 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, cat_name); 1401 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, class_name); 1402 1403 ltyp = objc_method_list_ptr; 1404 if (inst_methods) 1405 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0)); 1406 else 1407 expr = convert (ltyp, null_pointer_node); 1408 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1409 1410 if (class_methods) 1411 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0)); 1412 else 1413 expr = convert (ltyp, null_pointer_node); 1414 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1415 1416 /* protocol_list = */ 1417 ltyp = build_pointer_type (build_pointer_type (objc_protocol_template)); 1418 if (protocol_list) 1419 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, protocol_list, 0)); 1420 else 1421 expr = convert (ltyp, null_pointer_node); 1422 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1423 1424 return objc_build_constructor (type, v); 1425 } 1426 1427 /* static struct objc_category _OBJC_CATEGORY_<name> = { ... }; */ 1428 1429 static void 1430 generate_category (struct imp_entry *impent) 1431 { 1432 tree initlist, cat_name_expr, class_name_expr; 1433 tree protocol_decl, category, cat_decl; 1434 tree inst_methods = NULL_TREE, class_methods = NULL_TREE; 1435 tree cat = impent->imp_context; 1436 char buf[BUFSIZE]; 1437 1438 cat_decl = impent->class_decl; 1439 1440 add_class_reference (CLASS_NAME (cat)); 1441 cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names); 1442 1443 class_name_expr = add_objc_string (CLASS_NAME (cat), class_names); 1444 1445 category = lookup_category (impent->imp_template, CLASS_SUPER_NAME (cat)); 1446 1447 if (category && CLASS_PROTOCOL_LIST (category)) 1448 { 1449 generate_protocol_references (CLASS_PROTOCOL_LIST (category)); 1450 protocol_decl = generate_protocol_list (category, cat); 1451 } 1452 else 1453 protocol_decl = 0; 1454 1455 if (CLASS_NST_METHODS (cat)) 1456 { 1457 snprintf (buf, BUFSIZE, "_OBJC_CategoryInstanceMethods_%s_%s", 1458 IDENTIFIER_POINTER (CLASS_NAME (cat)), 1459 IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat))); 1460 inst_methods = generate_dispatch_table (CLASS_NST_METHODS (cat), buf); 1461 } 1462 1463 if (CLASS_CLS_METHODS (cat)) 1464 { 1465 snprintf (buf, BUFSIZE, "_OBJC_CategoryClassMethods_%s_%s", 1466 IDENTIFIER_POINTER (CLASS_NAME (cat)), 1467 IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat))); 1468 class_methods = generate_dispatch_table (CLASS_CLS_METHODS (cat), buf); 1469 } 1470 1471 initlist = build_category_initializer (TREE_TYPE (cat_decl), 1472 cat_name_expr, class_name_expr, 1473 inst_methods, class_methods, 1474 protocol_decl); 1475 /* Finish and initialize the forward decl. */ 1476 finish_var_decl (cat_decl, initlist); 1477 impent->class_decl = cat_decl; 1478 } 1479 1480 /* struct _objc_class { 1481 struct objc_class *isa; 1482 struct objc_class *super_class; 1483 char *name; 1484 long version; 1485 long info; 1486 long instance_size; 1487 struct objc_ivar_list *ivars; 1488 struct objc_method_list *methods; 1489 struct sarray *dtable; 1490 struct objc_class *subclass_list; 1491 struct objc_class *sibling_class; 1492 struct objc_protocol_list *protocols; 1493 void *gc_object_type; 1494 }; */ 1495 1496 static tree 1497 build_shared_structure_initializer (tree type, tree isa, tree super, 1498 tree name, tree size, int status, 1499 tree dispatch_table, tree ivar_list, 1500 tree protocol_list) 1501 { 1502 tree expr, ltyp; 1503 vec<constructor_elt, va_gc> *v = NULL; 1504 1505 /* isa = */ 1506 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, isa); 1507 1508 /* super_class = */ 1509 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, super); 1510 1511 /* name = */ 1512 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, default_conversion (name)); 1513 1514 /* version = */ 1515 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 1516 build_int_cst (long_integer_type_node, 0)); 1517 1518 /* info = */ 1519 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 1520 build_int_cst (long_integer_type_node, status)); 1521 1522 /* instance_size = */ 1523 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 1524 convert (long_integer_type_node, size)); 1525 1526 /* objc_ivar_list = */ 1527 if (!ivar_list) 1528 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 1529 build_int_cst (objc_ivar_list_ptr, 0)); 1530 else 1531 { 1532 expr = convert (objc_ivar_list_ptr, 1533 build_unary_op (input_location, ADDR_EXPR, 1534 ivar_list, 0)); 1535 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1536 } 1537 1538 /* objc_method_list = */ 1539 if (!dispatch_table) 1540 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 1541 convert (objc_method_list_ptr, null_pointer_node)); 1542 else 1543 { 1544 expr = convert (objc_method_list_ptr, 1545 build_unary_op (input_location, ADDR_EXPR, 1546 dispatch_table, 0)); 1547 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1548 } 1549 1550 /* FIXME: Remove NeXT runtime code. */ 1551 if (flag_next_runtime) 1552 { 1553 ltyp = build_pointer_type (xref_tag (RECORD_TYPE, 1554 get_identifier ("objc_cache"))); 1555 /* method_cache = */ 1556 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, convert (ltyp, null_pointer_node)); 1557 } 1558 else 1559 { 1560 /* dtable = */ 1561 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); 1562 1563 /* subclass_list = */ 1564 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); 1565 1566 /* sibling_class = */ 1567 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); 1568 } 1569 1570 /* protocol_list = */ 1571 ltyp = build_pointer_type (build_pointer_type (objc_protocol_template)); 1572 if (! protocol_list) 1573 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (ltyp, 0)); 1574 else 1575 { 1576 expr = convert (ltyp, 1577 build_unary_op (input_location, ADDR_EXPR, 1578 protocol_list, 0)); 1579 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1580 } 1581 1582 /* FIXME: Remove NeXT runtime code. */ 1583 if (flag_next_runtime) 1584 /* sel_id = NULL */ 1585 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); 1586 1587 /* gc_object_type = NULL */ 1588 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); 1589 1590 return objc_build_constructor (type, v); 1591 } 1592 1593 1594 static tree 1595 generate_ivars_list (tree chain, const char *name) 1596 { 1597 tree initlist, ivar_list_template, decl; 1598 int size; 1599 vec<constructor_elt, va_gc> *inits = NULL; 1600 1601 if (!chain) 1602 return NULL_TREE; 1603 1604 if (!objc_ivar_template) 1605 objc_ivar_template = build_ivar_template (); 1606 1607 size = ivar_list_length (chain); 1608 1609 generating_instance_variables = 1; 1610 ivar_list_template = build_ivar_list_template (objc_ivar_template, size); 1611 initlist = build_ivar_list_initializer (objc_ivar_template, chain); 1612 generating_instance_variables = 0; 1613 1614 decl = start_var_decl (ivar_list_template, name); 1615 1616 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, size)); 1617 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist); 1618 1619 OBJCMETA (decl, objc_meta, meta_base); 1620 finish_var_decl (decl, 1621 objc_build_constructor (TREE_TYPE (decl), inits)); 1622 1623 return decl; 1624 } 1625 1626 /* static struct objc_class _OBJC_METACLASS_Foo={ ... }; 1627 static struct objc_class _OBJC_CLASS_Foo={ ... }; */ 1628 1629 static void 1630 generate_class_structures (struct imp_entry *impent) 1631 { 1632 tree name_expr, super_expr, root_expr, class_decl, meta_decl; 1633 tree my_root_id, my_super_id; 1634 tree cast_type, initlist, protocol_decl; 1635 tree inst_methods = NULL_TREE, class_methods = NULL_TREE; 1636 tree chain, inst_ivars = NULL_TREE, class_ivars = NULL_TREE; 1637 location_t loc; 1638 char buf[BUFSIZE]; 1639 int cls_flags = 0 ; 1640 1641 /* objc_implementation_context = impent->imp_context; 1642 implementation_template = impent->imp_template;*/ 1643 class_decl = impent->class_decl; 1644 meta_decl = impent->meta_decl; 1645 /* UOBJC_CLASS_decl = impent->class_decl; 1646 UOBJC_METACLASS_decl = impent->meta_decl;*/ 1647 1648 loc = DECL_SOURCE_LOCATION (impent->class_decl); 1649 1650 my_super_id = CLASS_SUPER_NAME (impent->imp_template); 1651 if (my_super_id) 1652 { 1653 add_class_reference (my_super_id); 1654 1655 /* Compute "my_root_id" - this is required for code generation. 1656 the "isa" for all meta class structures points to the root of 1657 the inheritance hierarchy (e.g. "__Object")... */ 1658 my_root_id = my_super_id; 1659 do 1660 { 1661 tree my_root_int = lookup_interface (my_root_id); 1662 1663 if (my_root_int && CLASS_SUPER_NAME (my_root_int)) 1664 my_root_id = CLASS_SUPER_NAME (my_root_int); 1665 else 1666 break; 1667 } 1668 while (1); 1669 } 1670 else 1671 /* No super class. */ 1672 my_root_id = CLASS_NAME (impent->imp_template); 1673 1674 cast_type = build_pointer_type (objc_class_template); 1675 name_expr = add_objc_string (CLASS_NAME (impent->imp_template), 1676 class_names); 1677 1678 /* Install class `isa' and `super' pointers at runtime. */ 1679 if (my_super_id) 1680 super_expr = add_objc_string (my_super_id, class_names); 1681 else 1682 super_expr = null_pointer_node; 1683 1684 super_expr = build_c_cast (loc, cast_type, super_expr); 1685 1686 root_expr = add_objc_string (my_root_id, class_names); 1687 root_expr = build_c_cast (loc, cast_type, root_expr); 1688 1689 if (CLASS_PROTOCOL_LIST (impent->imp_template)) 1690 { 1691 generate_protocol_references (CLASS_PROTOCOL_LIST (impent->imp_template)); 1692 protocol_decl = generate_protocol_list (impent->imp_template, 1693 impent->imp_context); 1694 } 1695 else 1696 protocol_decl = NULL_TREE; 1697 1698 if (CLASS_CLS_METHODS (impent->imp_context)) 1699 { 1700 snprintf (buf, BUFSIZE, "_OBJC_ClassMethods_%s", 1701 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); 1702 class_methods = generate_dispatch_table (CLASS_CLS_METHODS (impent->imp_context), 1703 buf); 1704 } 1705 1706 if (CLASS_SUPER_NAME (impent->imp_template) == NULL_TREE 1707 && (chain = TYPE_FIELDS (objc_class_template))) 1708 { 1709 snprintf (buf, BUFSIZE, "_OBJC_ClassIvars_%s", 1710 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); 1711 class_ivars = generate_ivars_list (chain, buf); 1712 } 1713 1714 /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */ 1715 1716 initlist = 1717 build_shared_structure_initializer 1718 (TREE_TYPE (meta_decl), 1719 root_expr, super_expr, name_expr, 1720 convert (integer_type_node, 1721 TYPE_SIZE_UNIT (objc_class_template)), 1722 CLS_META, class_methods, class_ivars, 1723 protocol_decl); 1724 1725 finish_var_decl (meta_decl, initlist); 1726 impent->meta_decl = meta_decl; 1727 1728 /* static struct objc_class _OBJC_CLASS_Foo={ ... }; */ 1729 if (CLASS_NST_METHODS (impent->imp_context)) 1730 { 1731 snprintf (buf, BUFSIZE, "_OBJC_InstanceMethods_%s", 1732 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); 1733 inst_methods = generate_dispatch_table (CLASS_NST_METHODS (impent->imp_context), 1734 buf); 1735 } 1736 1737 if ((chain = CLASS_IVARS (impent->imp_template))) 1738 { 1739 snprintf (buf, BUFSIZE, "_OBJC_InstanceIvars_%s", 1740 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); 1741 inst_ivars = generate_ivars_list (chain, buf); 1742 } 1743 1744 initlist = 1745 build_shared_structure_initializer 1746 (TREE_TYPE (class_decl), 1747 build_unary_op (loc, ADDR_EXPR, meta_decl, 0), 1748 super_expr, name_expr, 1749 convert (integer_type_node, 1750 TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE 1751 (impent->imp_template))), 1752 CLS_FACTORY | cls_flags, inst_methods, inst_ivars, 1753 protocol_decl); 1754 1755 finish_var_decl (class_decl, initlist); 1756 impent->class_decl = class_decl; 1757 } 1758 1759 /* --- Output GNU Metadata --- */ 1760 1761 /* TODO: Make this into an array of refs. */ 1762 static void 1763 handle_class_ref (tree chain) 1764 { 1765 const char *name = IDENTIFIER_POINTER (TREE_VALUE (chain)); 1766 char *string = (char *) alloca (strlen (name) + 30); 1767 tree decl; 1768 tree exp; 1769 1770 sprintf (string, "__objc_class_name_%s", name); 1771 1772 /* Make a decl for this name, so we can use its address in a tree. */ 1773 decl = build_decl (input_location, 1774 VAR_DECL, get_identifier (string), TREE_TYPE (integer_zero_node)); 1775 DECL_EXTERNAL (decl) = 1; 1776 TREE_PUBLIC (decl) = 1; 1777 DECL_CONTEXT (decl) = NULL_TREE; 1778 finish_var_decl (decl, 0); 1779 1780 /* Make a decl for the address. */ 1781 sprintf (string, "__objc_class_ref_%s", name); 1782 exp = build1 (ADDR_EXPR, string_type_node, decl); 1783 decl = build_decl (input_location, 1784 VAR_DECL, get_identifier (string), string_type_node); 1785 TREE_STATIC (decl) = 1; 1786 TREE_USED (decl) = 1; 1787 DECL_READ_P (decl) = 1; 1788 DECL_ARTIFICIAL (decl) = 1; 1789 DECL_INITIAL (decl) = error_mark_node; 1790 1791 /* We must force the reference. */ 1792 DECL_PRESERVE_P (decl) = 1; 1793 1794 DECL_CONTEXT (decl) = NULL_TREE; 1795 finish_var_decl (decl, exp); 1796 } 1797 1798 static tree 1799 get_proto_encoding (tree proto) 1800 { 1801 tree encoding; 1802 if (proto) 1803 { 1804 if (! METHOD_ENCODING (proto)) 1805 { 1806 encoding = encode_method_prototype (proto); 1807 METHOD_ENCODING (proto) = encoding; 1808 } 1809 else 1810 encoding = METHOD_ENCODING (proto); 1811 1812 return add_objc_string (encoding, meth_var_types); 1813 } 1814 else 1815 return build_int_cst (NULL_TREE, 0); 1816 } 1817 1818 static void 1819 build_gnu_selector_translation_table (void) 1820 { 1821 tree chain, expr; 1822 vec<constructor_elt, va_gc> *inits = NULL; 1823 vec<constructor_elt, va_gc> *v ; 1824 1825 /* Cause the selector table (previously forward-declared) 1826 to be actually output. */ 1827 1828 for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain)) 1829 { 1830 tree encoding; 1831 if (warn_selector) 1832 { 1833 /* TODO: improve on the location for the diagnostic. */ 1834 location_t loc = input_location; 1835 diagnose_missing_method (TREE_VALUE (chain), loc); 1836 } 1837 1838 v = NULL; 1839 expr = build_selector (TREE_VALUE (chain)); 1840 encoding = get_proto_encoding (TREE_PURPOSE (chain)); 1841 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1842 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, encoding); 1843 expr = objc_build_constructor (objc_selector_template, v); 1844 1845 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 1846 } /* each element in the chain */ 1847 1848 /* List terminator. */ 1849 v = NULL; 1850 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node); 1851 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node); 1852 expr = objc_build_constructor (objc_selector_template, v); 1853 1854 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 1855 expr = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl), 1856 inits); 1857 finish_var_decl (UOBJC_SELECTOR_TABLE_decl, expr); 1858 } 1859 1860 /* Output references to all statically allocated objects. Return the DECL 1861 for the array built. */ 1862 1863 static void 1864 generate_static_references (void) 1865 { 1866 tree expr = NULL_TREE; 1867 tree class_name, klass, decl; 1868 tree cl_chain, in_chain, type 1869 = build_array_type (build_pointer_type (void_type_node), NULL_TREE); 1870 int num_inst, num_class; 1871 char buf[BUFSIZE]; 1872 vec<constructor_elt, va_gc> *decls = NULL; 1873 1874 /* FIXME: Remove NeXT runtime code. */ 1875 if (flag_next_runtime) 1876 gcc_unreachable (); 1877 1878 for (cl_chain = objc_static_instances, num_class = 0; 1879 cl_chain; cl_chain = TREE_CHAIN (cl_chain), num_class++) 1880 { 1881 vec<constructor_elt, va_gc> *v = NULL; 1882 1883 for (num_inst = 0, in_chain = TREE_PURPOSE (cl_chain); 1884 in_chain; num_inst++, in_chain = TREE_CHAIN (in_chain)); 1885 1886 snprintf (buf, BUFSIZE, "_OBJC_STATIC_INSTANCES_%d", num_class); 1887 decl = start_var_decl (type, buf); 1888 1889 /* Output {class_name, ...}. */ 1890 klass = TREE_VALUE (cl_chain); 1891 class_name = get_objc_string_decl (OBJC_TYPE_NAME (klass), class_names); 1892 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 1893 build_unary_op (input_location, 1894 ADDR_EXPR, class_name, 1)); 1895 1896 /* Output {..., instance, ...}. */ 1897 for (in_chain = TREE_PURPOSE (cl_chain); 1898 in_chain; in_chain = TREE_CHAIN (in_chain)) 1899 { 1900 expr = build_unary_op (input_location, 1901 ADDR_EXPR, TREE_VALUE (in_chain), 1); 1902 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1903 } 1904 1905 /* Output {..., NULL}. */ 1906 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); 1907 1908 expr = objc_build_constructor (TREE_TYPE (decl), v); 1909 OBJCMETA (decl, objc_meta, meta_base); 1910 finish_var_decl (decl, expr); 1911 CONSTRUCTOR_APPEND_ELT (decls, NULL_TREE, 1912 build_unary_op (input_location, 1913 ADDR_EXPR, decl, 1)); 1914 } 1915 1916 CONSTRUCTOR_APPEND_ELT (decls, NULL_TREE, build_int_cst (NULL_TREE, 0)); 1917 expr = objc_build_constructor (type, decls); 1918 static_instances_decl = start_var_decl (type, "_OBJC_STATIC_INSTANCES"); 1919 OBJCMETA (static_instances_decl, objc_meta, meta_base); 1920 finish_var_decl (static_instances_decl, expr); 1921 } 1922 1923 /* Create the initial value for the `defs' field of _objc_symtab. 1924 This is a CONSTRUCTOR. */ 1925 1926 static tree 1927 init_def_list (tree type) 1928 { 1929 tree expr; 1930 struct imp_entry *impent; 1931 location_t loc; 1932 vec<constructor_elt, va_gc> *v = NULL; 1933 1934 if (imp_count) 1935 for (impent = imp_list; impent; impent = impent->next) 1936 { 1937 if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE) 1938 { 1939 loc = DECL_SOURCE_LOCATION (impent->class_decl); 1940 expr = build_unary_op (loc, 1941 ADDR_EXPR, impent->class_decl, 0); 1942 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1943 } 1944 } 1945 1946 if (cat_count) 1947 for (impent = imp_list; impent; impent = impent->next) 1948 { 1949 if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE) 1950 { 1951 loc = DECL_SOURCE_LOCATION (impent->class_decl); 1952 expr = build_unary_op (loc, 1953 ADDR_EXPR, impent->class_decl, 0); 1954 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1955 } 1956 } 1957 1958 loc = UNKNOWN_LOCATION; 1959 /* statics = { ..., _OBJC_STATIC_INSTANCES, ... } */ 1960 if (static_instances_decl) 1961 expr = build_unary_op (loc, ADDR_EXPR, static_instances_decl, 0); 1962 else 1963 expr = integer_zero_node; 1964 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 1965 1966 return objc_build_constructor (type, v); 1967 } 1968 1969 /* Take care of defining and initializing _OBJC_SYMBOLS. */ 1970 1971 /* Predefine the following data type: 1972 1973 struct _objc_symtab 1974 { 1975 long sel_ref_cnt; 1976 SEL *refs; 1977 short cls_def_cnt; 1978 short cat_def_cnt; 1979 void *defs[cls_def_cnt + cat_def_cnt]; 1980 }; */ 1981 1982 static void 1983 build_objc_symtab_template (void) 1984 { 1985 tree fields, array_type, *chain = NULL; 1986 int index; 1987 1988 objc_symtab_template = objc_start_struct (get_identifier (UTAG_SYMTAB)); 1989 1990 /* long sel_ref_cnt; */ 1991 fields = add_field_decl (long_integer_type_node, "sel_ref_cnt", &chain); 1992 1993 /* SEL *refs; */ 1994 add_field_decl (build_pointer_type (objc_selector_type), "refs", &chain); 1995 1996 /* short cls_def_cnt; */ 1997 add_field_decl (short_integer_type_node, "cls_def_cnt", &chain); 1998 1999 /* short cat_def_cnt; */ 2000 add_field_decl (short_integer_type_node, "cat_def_cnt", &chain); 2001 2002 /* Note that padding will be added here on LP64. */ 2003 2004 /* void *defs[imp_count + cat_count (+ 1)]; */ 2005 /* NB: The index is one less than the size of the array. */ 2006 index = imp_count + cat_count; 2007 array_type = build_sized_array_type (ptr_type_node, index + 1); 2008 add_field_decl (array_type, "defs", &chain); 2009 2010 objc_finish_struct (objc_symtab_template, fields); 2011 } 2012 /* Construct the initial value for all of _objc_symtab. */ 2013 2014 static tree 2015 init_objc_symtab (tree type) 2016 { 2017 tree field, expr, ltyp; 2018 location_t loc; 2019 vec<constructor_elt, va_gc> *v = NULL; 2020 2021 loc = UNKNOWN_LOCATION; 2022 2023 /* sel_ref_cnt = { ..., 5, ... } */ 2024 2025 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 2026 build_int_cst (long_integer_type_node, 0)); 2027 2028 /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */ 2029 2030 ltyp = build_pointer_type (objc_selector_type); 2031 if (sel_ref_chain) 2032 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, 2033 UOBJC_SELECTOR_TABLE_decl, 1)); 2034 else 2035 expr = convert (ltyp, null_pointer_node); 2036 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 2037 2038 /* cls_def_cnt = { ..., 5, ... } */ 2039 2040 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 2041 build_int_cst (short_integer_type_node, imp_count)); 2042 2043 /* cat_def_cnt = { ..., 5, ... } */ 2044 2045 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 2046 build_int_cst (short_integer_type_node, cat_count)); 2047 2048 /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */ 2049 2050 field = TYPE_FIELDS (type); 2051 field = DECL_CHAIN (DECL_CHAIN (DECL_CHAIN (DECL_CHAIN (field)))); 2052 2053 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init_def_list (TREE_TYPE (field))); 2054 2055 return objc_build_constructor (type, v); 2056 } 2057 2058 /* Create the declaration of _OBJC_SYMBOLS, with type `struct _objc_symtab' 2059 and initialized appropriately. */ 2060 2061 static void 2062 generate_objc_symtab_decl (void) 2063 { 2064 build_objc_symtab_template (); 2065 UOBJC_SYMBOLS_decl = start_var_decl (objc_symtab_template, "_OBJC_SYMBOLS"); 2066 OBJCMETA (UOBJC_SYMBOLS_decl, objc_meta, meta_base); 2067 finish_var_decl (UOBJC_SYMBOLS_decl, 2068 init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl))); 2069 } 2070 2071 static void 2072 objc_generate_v1_gnu_metadata (void) 2073 { 2074 struct imp_entry *impent; 2075 tree chain; 2076 2077 /* Process the static instances here because initialization of objc_symtab 2078 depends on them. */ 2079 if (objc_static_instances) 2080 generate_static_references (); 2081 2082 objc_implementation_context = 2083 implementation_template = 2084 UOBJC_CLASS_decl = 2085 UOBJC_METACLASS_decl = NULL_TREE; 2086 2087 for (impent = imp_list; impent; impent = impent->next) 2088 { 2089 /* If -gen-decls is present, Dump the @interface of each class. 2090 TODO: Dump the classes in the order they were found, rather than in 2091 reverse order as we are doing now. */ 2092 if (flag_gen_declaration) 2093 dump_interface (gen_declaration_file, impent->imp_context); 2094 2095 /* all of the following reference the string pool... */ 2096 if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE) 2097 generate_class_structures (impent); 2098 else 2099 generate_category (impent); 2100 } 2101 2102 /* If we are using an array of selectors, we must always 2103 finish up the array decl even if no selectors were used. */ 2104 build_gnu_selector_translation_table (); 2105 2106 if (protocol_chain) 2107 generate_protocols (); 2108 2109 /* Arrange for ObjC data structures to be initialized at run time. */ 2110 /* FIXME: Have some more elegant way to determine if we need to 2111 generate objc_symtab_decl or not, instead of checking these 2112 global symbols. */ 2113 if (imp_list || class_names_chain 2114 || meth_var_names_chain || meth_var_types_chain || sel_ref_chain 2115 || prop_names_attr_chain) 2116 generate_objc_symtab_decl (); 2117 2118 if (imp_list || class_names_chain || objc_static_instances 2119 || meth_var_names_chain || meth_var_types_chain || sel_ref_chain) 2120 { 2121 /* Make sure that the meta-data are identified as being 2122 GNU-runtime. */ 2123 build_module_descriptor (OBJC_VERSION, 2124 build_tree_list (objc_meta, meta_base)); 2125 build_module_initializer_routine (); 2126 } 2127 2128 /* Dump the class references. This forces the appropriate classes 2129 to be linked into the executable image, preserving unix archive 2130 semantics. This can be removed when we move to a more dynamically 2131 linked environment. */ 2132 2133 for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain)) 2134 { 2135 handle_class_ref (chain); 2136 if (TREE_PURPOSE (chain)) 2137 generate_classref_translation_entry (chain); 2138 } 2139 2140 for (impent = imp_list; impent; impent = impent->next) 2141 handle_impent (impent); 2142 2143 generate_strings (); 2144 } 2145 2146 /* --- exceptions --- */ 2147 2148 static GTY(()) tree objc_eh_personality_decl; 2149 2150 static tree 2151 objc_eh_runtime_type (tree type) 2152 { 2153 tree ident, eh_id, decl, str; 2154 2155 if (type == error_mark_node 2156 || errorcount || sorrycount) 2157 { 2158 /* Use 'ErrorMarkNode' as class name when error_mark_node is found 2159 to prevent an ICE. Note that we know that the compiler will 2160 terminate with an error and this 'ErrorMarkNode' class name will 2161 never be actually used. */ 2162 ident = get_identifier ("ErrorMarkNode"); 2163 goto make_err_class; 2164 } 2165 2166 if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type))) 2167 /* We don't want to identify 'id' for GNU. Instead, build a 0 2168 entry in the exceptions table. */ 2169 return null_pointer_node; 2170 2171 if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type))) 2172 { 2173 #ifdef OBJCPLUS 2174 /* This routine is also called for c++ catch clauses; in which case, 2175 we use the c++ typeinfo decl. */ 2176 return build_eh_type_type (type); 2177 #else 2178 error ("non-objective-c type '%T' cannot be caught", type); 2179 ident = get_identifier ("ErrorMarkNode"); 2180 goto make_err_class; 2181 #endif 2182 } 2183 else 2184 ident = OBJC_TYPE_NAME (TREE_TYPE (type)); 2185 2186 make_err_class: 2187 /* If this class was already referenced, then it will be output during 2188 meta-data emission, so we don't need to do it here. */ 2189 decl = get_objc_string_decl (ident, class_names); 2190 eh_id = add_objc_string (ident, class_names); 2191 if (!decl) 2192 { 2193 /* Not found ... so we need to build it - from the freshly-entered id. */ 2194 decl = get_objc_string_decl (ident, class_names); 2195 str = my_build_string (IDENTIFIER_LENGTH (ident) + 1, 2196 IDENTIFIER_POINTER (ident)); 2197 /* We have to finalize this var here, because this might be called after 2198 all the other metadata strings have been emitted. */ 2199 finish_var_decl (decl, str); 2200 } 2201 return eh_id; 2202 } 2203 2204 static tree 2205 objc_eh_personality (void) 2206 { 2207 if (!objc_eh_personality_decl) 2208 #ifndef OBJCPLUS 2209 objc_eh_personality_decl = build_personality_function ("gnu_objc"); 2210 #else 2211 objc_eh_personality_decl = build_personality_function ("gxx"); 2212 #endif 2213 return objc_eh_personality_decl; 2214 } 2215 2216 /* -- interfaces --- */ 2217 2218 static tree 2219 build_throw_stmt (location_t loc, tree throw_expr, bool rethrown ATTRIBUTE_UNUSED) 2220 { 2221 tree t; 2222 vec<tree, va_gc> *parms; 2223 vec_alloc (parms, 1); 2224 /* A throw is just a call to the runtime throw function with the 2225 object as a parameter. */ 2226 parms->quick_push (throw_expr); 2227 t = build_function_call_vec (loc, vNULL, objc_exception_throw_decl, parms, 2228 NULL); 2229 vec_free (parms); 2230 return add_stmt (t); 2231 } 2232 2233 /* Build __builtin_eh_pointer. */ 2234 2235 static tree 2236 objc_build_exc_ptr (struct objc_try_context **x ATTRIBUTE_UNUSED) 2237 { 2238 tree t; 2239 t = builtin_decl_explicit (BUILT_IN_EH_POINTER); 2240 t = build_call_expr (t, 1, integer_zero_node); 2241 return fold_convert (objc_object_type, t); 2242 } 2243 2244 static tree 2245 begin_catch (struct objc_try_context **cur_try_context, tree type, 2246 tree decl, tree compound, bool ellipsis ATTRIBUTE_UNUSED) 2247 { 2248 tree t; 2249 /* Record the data for the catch in the try context so that we can 2250 finalize it later. */ 2251 if (ellipsis) 2252 t = build_stmt (input_location, CATCH_EXPR, NULL, compound); 2253 else 2254 t = build_stmt (input_location, CATCH_EXPR, type, compound); 2255 (*cur_try_context)->current_catch = t; 2256 2257 /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */ 2258 t = objc_build_exc_ptr (cur_try_context); 2259 t = convert (TREE_TYPE (decl), t); 2260 return build2 (MODIFY_EXPR, void_type_node, decl, t); 2261 } 2262 2263 static void 2264 finish_catch (struct objc_try_context **cur_try_context, tree current_catch) 2265 { 2266 append_to_statement_list (current_catch, &((*cur_try_context)->catch_list)); 2267 } 2268 2269 static tree 2270 finish_try_stmt (struct objc_try_context **cur_try_context) 2271 { 2272 struct objc_try_context *c = *cur_try_context; 2273 tree stmt = c->try_body; 2274 if (c->catch_list) 2275 stmt = build_stmt (c->try_locus, TRY_CATCH_EXPR, stmt, c->catch_list); 2276 if (c->finally_body) 2277 stmt = build_stmt (c->try_locus, TRY_FINALLY_EXPR, stmt, c->finally_body); 2278 return stmt; 2279 } 2280 2281 #include "gt-objc-objc-gnu-runtime-abi-01.h" 2282