1 /* Implement classes and message passing for Objective C. 2 Copyright (C) 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001, 3 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011 4 Free Software Foundation, Inc. 5 Contributed by Steve Naroff. 6 7 This file is part of GCC. 8 9 GCC is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3, or (at your option) 12 any later version. 13 14 GCC is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with GCC; see the file COPYING3. If not see 21 <http://www.gnu.org/licenses/>. */ 22 23 #include "config.h" 24 #include "system.h" 25 #include "coretypes.h" 26 #include "tm.h" 27 #include "tree.h" 28 29 #ifdef OBJCPLUS 30 #include "cp-tree.h" 31 #else 32 #include "c-tree.h" 33 #include "c-lang.h" 34 #endif 35 36 #include "c-family/c-common.h" 37 #include "c-family/c-objc.h" 38 #include "c-family/c-pragma.h" 39 #include "c-family/c-format.h" 40 #include "flags.h" 41 #include "langhooks.h" 42 #include "objc-act.h" 43 #include "objc-map.h" 44 #include "input.h" 45 #include "function.h" 46 #include "output.h" 47 #include "toplev.h" 48 #include "ggc.h" 49 #include "debug.h" 50 #include "c-family/c-target.h" 51 #include "diagnostic-core.h" 52 #include "intl.h" 53 #include "cgraph.h" 54 #include "tree-iterator.h" 55 #include "hashtab.h" 56 #include "langhooks-def.h" 57 /* Different initialization, code gen and meta data generation for each 58 runtime. */ 59 #include "objc-runtime-hooks.h" 60 /* Routines used mainly by the runtimes. */ 61 #include "objc-runtime-shared-support.h" 62 /* For default_tree_printer (). */ 63 #include "tree-pretty-print.h" 64 65 /* For enum gimplify_status */ 66 #include "gimple.h" 67 68 /* For encode_method_prototype(). */ 69 #include "objc-encoding.h" 70 71 static unsigned int should_call_super_dealloc = 0; 72 73 /* When building Objective-C++, we are not linking against the C front-end 74 and so need to replicate the C tree-construction functions in some way. */ 75 #ifdef OBJCPLUS 76 #define OBJCP_REMAP_FUNCTIONS 77 #include "objcp-decl.h" 78 #endif /* OBJCPLUS */ 79 80 /* This is the default way of generating a method name. */ 81 /* This has the problem that "test_method:argument:" and 82 "test:method_argument:" will generate the same name 83 ("_i_Test__test_method_argument_" for an instance method of the 84 class "Test"), so you can't have them both in the same class! 85 Moreover, the demangling (going from 86 "_i_Test__test_method_argument" back to the original name) is 87 undefined because there are two correct ways of demangling the 88 name. */ 89 #ifndef OBJC_GEN_METHOD_LABEL 90 #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \ 91 do { \ 92 char *temp; \ 93 sprintf ((BUF), "_%s_%s_%s_%s", \ 94 ((IS_INST) ? "i" : "c"), \ 95 (CLASS_NAME), \ 96 ((CAT_NAME)? (CAT_NAME) : ""), \ 97 (SEL_NAME)); \ 98 for (temp = (BUF); *temp; temp++) \ 99 if (*temp == ':') *temp = '_'; \ 100 } while (0) 101 #endif 102 103 /* These need specifying. */ 104 #ifndef OBJC_FORWARDING_STACK_OFFSET 105 #define OBJC_FORWARDING_STACK_OFFSET 0 106 #endif 107 108 #ifndef OBJC_FORWARDING_MIN_OFFSET 109 #define OBJC_FORWARDING_MIN_OFFSET 0 110 #endif 111 112 /*** Private Interface (procedures) ***/ 113 114 /* Init stuff. */ 115 static void synth_module_prologue (void); 116 117 /* Code generation. */ 118 119 static tree start_class (enum tree_code, tree, tree, tree, tree); 120 static tree continue_class (tree); 121 static void finish_class (tree); 122 static void start_method_def (tree, tree); 123 124 static tree start_protocol (enum tree_code, tree, tree, tree); 125 static tree build_method_decl (enum tree_code, tree, tree, tree, bool); 126 static tree objc_add_method (tree, tree, int, bool); 127 static tree add_instance_variable (tree, objc_ivar_visibility_kind, tree); 128 static tree build_ivar_reference (tree); 129 static tree is_ivar (tree, tree); 130 131 /* We only need the following for ObjC; ObjC++ will use C++'s definition 132 of DERIVED_FROM_P. */ 133 #ifndef OBJCPLUS 134 static bool objc_derived_from_p (tree, tree); 135 #define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD) 136 #endif 137 138 /* Property. */ 139 static void objc_gen_property_data (tree, tree); 140 static void objc_synthesize_getter (tree, tree, tree); 141 static void objc_synthesize_setter (tree, tree, tree); 142 static tree lookup_property (tree, tree); 143 static tree lookup_property_in_list (tree, tree); 144 static tree lookup_property_in_protocol_list (tree, tree); 145 static void build_common_objc_property_accessor_helpers (void); 146 147 static void objc_xref_basetypes (tree, tree); 148 149 static tree get_class_ivars (tree, bool); 150 151 static void build_fast_enumeration_state_template (void); 152 153 #ifdef OBJCPLUS 154 static void objc_generate_cxx_cdtors (void); 155 #endif 156 157 /* objc attribute */ 158 static void objc_decl_method_attributes (tree*, tree, int); 159 static tree build_keyword_selector (tree); 160 161 static void hash_init (void); 162 163 /* Hash tables to manage the global pool of method prototypes. Each 164 of these maps map a method name (selector) identifier to either a 165 single tree (for methods with a single method prototype) or a 166 TREE_VEC (for methods with multiple method prototypes). */ 167 static GTY(()) objc_map_t instance_method_map = 0; 168 static GTY(()) objc_map_t class_method_map = 0; 169 170 /* Hash tables to manage the global pool of class names. */ 171 172 static GTY(()) objc_map_t class_name_map = 0; 173 static GTY(()) objc_map_t alias_name_map = 0; 174 175 static tree lookup_method (tree, tree); 176 static tree lookup_method_static (tree, tree, int); 177 178 static void interface_hash_init (void); 179 static tree add_interface (tree, tree); 180 static void add_category (tree, tree); 181 static inline tree lookup_category (tree, tree); 182 183 /* Protocols. */ 184 185 static tree lookup_protocol (tree, bool, bool); 186 static tree lookup_and_install_protocols (tree, bool); 187 188 #ifdef OBJCPLUS 189 static void really_start_method (tree, tree); 190 #else 191 static void really_start_method (tree, struct c_arg_info *); 192 #endif 193 static int comp_proto_with_proto (tree, tree, int); 194 static tree objc_decay_parm_type (tree); 195 196 /* Utilities for debugging and error diagnostics. */ 197 198 static char *gen_type_name (tree); 199 static char *gen_type_name_0 (tree); 200 static char *gen_method_decl (tree); 201 static char *gen_declaration (tree); 202 203 /* Everything else. */ 204 205 static void generate_struct_by_value_array (void) ATTRIBUTE_NORETURN; 206 207 static void mark_referenced_methods (void); 208 static bool objc_type_valid_for_messaging (tree type, bool allow_classes); 209 static tree check_duplicates (tree, int, int); 210 211 /*** Private Interface (data) ***/ 212 /* Flags for lookup_method_static(). */ 213 214 /* Look for class methods. */ 215 #define OBJC_LOOKUP_CLASS 1 216 /* Do not examine superclasses. */ 217 #define OBJC_LOOKUP_NO_SUPER 2 218 /* Disable returning an instance method of a root class when a class 219 method can't be found. */ 220 #define OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS 4 221 222 /* The OCTI_... enumeration itself is in objc/objc-act.h. */ 223 tree objc_global_trees[OCTI_MAX]; 224 225 struct imp_entry *imp_list = 0; 226 int imp_count = 0; /* `@implementation' */ 227 int cat_count = 0; /* `@category' */ 228 229 objc_ivar_visibility_kind objc_ivar_visibility; 230 231 /* Use to generate method labels. */ 232 static int method_slot = 0; 233 234 /* Flag to say whether methods in a protocol are optional or 235 required. */ 236 static bool objc_method_optional_flag = false; 237 238 static int objc_collecting_ivars = 0; 239 240 /* Flag that is set to 'true' while we are processing a class 241 extension. Since a class extension just "reopens" the main 242 @interface, this can be used to determine if we are in the main 243 @interface, or in a class extension. */ 244 static bool objc_in_class_extension = false; 245 246 static char *errbuf; /* Buffer for error diagnostics */ 247 248 /* An array of all the local variables in the current function that 249 need to be marked as volatile. */ 250 VEC(tree,gc) *local_variables_to_volatilize = NULL; 251 252 /* Store all constructed constant strings in a hash table so that 253 they get uniqued properly. */ 254 255 struct GTY(()) string_descriptor { 256 /* The literal argument . */ 257 tree literal; 258 259 /* The resulting constant string. */ 260 tree constructor; 261 }; 262 263 static GTY((param_is (struct string_descriptor))) htab_t string_htab; 264 265 FILE *gen_declaration_file; 266 267 /* Hooks for stuff that differs between runtimes. */ 268 objc_runtime_hooks runtime; 269 270 /* Create a temporary variable of type 'type'. If 'name' is set, uses 271 the specified name, else use no name. Returns the declaration of 272 the type. The 'name' is mostly useful for debugging. 273 */ 274 tree 275 objc_create_temporary_var (tree type, const char *name) 276 { 277 tree decl; 278 279 if (name != NULL) 280 { 281 decl = build_decl (input_location, 282 VAR_DECL, get_identifier (name), type); 283 } 284 else 285 { 286 decl = build_decl (input_location, 287 VAR_DECL, NULL_TREE, type); 288 } 289 TREE_USED (decl) = 1; 290 DECL_ARTIFICIAL (decl) = 1; 291 DECL_IGNORED_P (decl) = 1; 292 DECL_CONTEXT (decl) = current_function_decl; 293 294 return decl; 295 } 296 297 /* Some platforms pass small structures through registers versus 298 through an invisible pointer. Determine at what size structure is 299 the transition point between the two possibilities. */ 300 301 static void 302 generate_struct_by_value_array (void) 303 { 304 tree type; 305 tree decls; 306 int i, j; 307 int aggregate_in_mem[32]; 308 int found = 0; 309 310 /* Presumably no platform passes 32 byte structures in a register. */ 311 /* ??? As an example, m64/ppc/Darwin can pass up to 8*long+13*double 312 in registers. */ 313 for (i = 1; i < 32; i++) 314 { 315 char buffer[5]; 316 tree *chain = NULL; 317 318 /* Create an unnamed struct that has `i' character components */ 319 type = objc_start_struct (NULL_TREE); 320 321 strcpy (buffer, "c1"); 322 decls = add_field_decl (char_type_node, buffer, &chain); 323 324 for (j = 1; j < i; j++) 325 { 326 sprintf (buffer, "c%d", j + 1); 327 add_field_decl (char_type_node, buffer, &chain); 328 } 329 objc_finish_struct (type, decls); 330 331 aggregate_in_mem[i] = aggregate_value_p (type, 0); 332 if (!aggregate_in_mem[i]) 333 found = 1; 334 } 335 336 /* We found some structures that are returned in registers instead of memory 337 so output the necessary data. */ 338 if (found) 339 { 340 for (i = 31; i >= 0; i--) 341 if (!aggregate_in_mem[i]) 342 break; 343 printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n", i); 344 } 345 346 exit (0); 347 } 348 349 bool 350 objc_init (void) 351 { 352 bool ok; 353 #ifdef OBJCPLUS 354 if (cxx_init () == false) 355 #else 356 if (c_objc_common_init () == false) 357 #endif 358 return false; 359 360 /* print_struct_values is triggered by -print-runtime-info (used 361 when building libobjc, with an empty file as input). It does not 362 require any ObjC setup, and it never returns. 363 364 -fcompare-debug is used to check the compiler output; we are 365 executed twice, once with flag_compare_debug set, and once with 366 it not set. If the flag is used together with 367 -print-runtime-info, we want to print the runtime info only once, 368 else it would be output in duplicate. So we check 369 flag_compare_debug to output it in only one of the invocations. 370 371 As a side effect, this also that means -fcompare-debug 372 -print-runtime-info will run the compiler twice, and compare the 373 generated assembler file; the first time the compiler exits 374 immediately (producing no file), and the second time it compiles 375 an empty file. This checks, as a side effect, that compiling an 376 empty file produces no assembler output. */ 377 if (print_struct_values && !flag_compare_debug) 378 generate_struct_by_value_array (); 379 380 /* Set up stuff used by FE parser and all runtimes. */ 381 errbuf = XNEWVEC (char, 1024 * 10); 382 interface_hash_init (); 383 hash_init (); 384 objc_encoding_init (); 385 /* ... and then check flags and set-up for the selected runtime ... */ 386 if (flag_next_runtime && flag_objc_abi >= 2) 387 ok = objc_next_runtime_abi_02_init (&runtime); 388 else if (flag_next_runtime) 389 ok = objc_next_runtime_abi_01_init (&runtime); 390 else 391 ok = objc_gnu_runtime_abi_01_init (&runtime); 392 393 /* If that part of the setup failed - bail out immediately. */ 394 if (!ok) 395 return false; 396 397 /* Generate general types and push runtime-specific decls to file scope. */ 398 synth_module_prologue (); 399 400 return true; 401 } 402 403 /* This is called automatically (at the very end of compilation) by 404 c_write_global_declarations and cp_write_global_declarations. */ 405 void 406 objc_write_global_declarations (void) 407 { 408 mark_referenced_methods (); 409 410 /* A missing @end might not be detected by the parser. */ 411 if (objc_implementation_context) 412 { 413 warning (0, "%<@end%> missing in implementation context"); 414 finish_class (objc_implementation_context); 415 objc_ivar_chain = NULL_TREE; 416 objc_implementation_context = NULL_TREE; 417 } 418 419 if (warn_selector) 420 { 421 objc_map_iterator_t i; 422 423 objc_map_iterator_initialize (class_method_map, &i); 424 while (objc_map_iterator_move_to_next (class_method_map, &i)) 425 check_duplicates (objc_map_iterator_current_value (class_method_map, i), 0, 1); 426 427 objc_map_iterator_initialize (instance_method_map, &i); 428 while (objc_map_iterator_move_to_next (instance_method_map, &i)) 429 check_duplicates (objc_map_iterator_current_value (instance_method_map, i), 0, 0); 430 } 431 432 /* TODO: consider an early exit here if either errorcount or sorrycount 433 is non-zero. Not only is it wasting time to generate the metadata, 434 it needlessly imposes need to re-check for things that are already 435 determined to be errors. */ 436 437 /* Finalize Objective-C runtime data. No need to generate tables 438 and code if only checking syntax, or if generating a PCH file. */ 439 if (!flag_syntax_only && !pch_file) 440 { 441 location_t saved_location; 442 443 /* If gen_declaration desired, open the output file. */ 444 if (flag_gen_declaration) 445 { 446 char * const dumpname = concat (dump_base_name, ".decl", NULL); 447 gen_declaration_file = fopen (dumpname, "w"); 448 if (gen_declaration_file == 0) 449 fatal_error ("can%'t open %s: %m", dumpname); 450 free (dumpname); 451 } 452 453 /* Set the input location to BUILTINS_LOCATION. This is good 454 for error messages, in case any is generated while producing 455 the metadata, but it also silences warnings that would be 456 produced when compiling with -Wpadded in case when padding is 457 automatically added to the built-in runtime data structure 458 declarations. We know about this padding, and it is fine; we 459 don't want users to see any warnings about it if they use 460 -Wpadded. */ 461 saved_location = input_location; 462 input_location = BUILTINS_LOCATION; 463 464 /* Compute and emit the meta-data tables for this runtime. */ 465 (*runtime.generate_metadata) (); 466 467 /* Restore the original location, just in case it mattered. */ 468 input_location = saved_location; 469 470 /* ... and then close any declaration file we opened. */ 471 if (gen_declaration_file) 472 fclose (gen_declaration_file); 473 } 474 } 475 476 /* Return the first occurrence of a method declaration corresponding 477 to sel_name in rproto_list. Search rproto_list recursively. 478 If is_class is 0, search for instance methods, otherwise for class 479 methods. */ 480 static tree 481 lookup_method_in_protocol_list (tree rproto_list, tree sel_name, 482 int is_class) 483 { 484 tree rproto, p, m; 485 486 for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto)) 487 { 488 p = TREE_VALUE (rproto); 489 m = NULL_TREE; 490 491 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE) 492 { 493 /* First, search the @required protocol methods. */ 494 if (is_class) 495 m = lookup_method (PROTOCOL_CLS_METHODS (p), sel_name); 496 else 497 m = lookup_method (PROTOCOL_NST_METHODS (p), sel_name); 498 499 if (m) 500 return m; 501 502 /* If still not found, search the @optional protocol methods. */ 503 if (is_class) 504 m = lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (p), sel_name); 505 else 506 m = lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (p), sel_name); 507 508 if (m) 509 return m; 510 511 /* If still not found, search the attached protocols. */ 512 if (PROTOCOL_LIST (p)) 513 m = lookup_method_in_protocol_list (PROTOCOL_LIST (p), 514 sel_name, is_class); 515 if (m) 516 return m; 517 } 518 else 519 { 520 ; /* An identifier...if we could not find a protocol. */ 521 } 522 } 523 524 return 0; 525 } 526 527 static tree 528 lookup_protocol_in_reflist (tree rproto_list, tree lproto) 529 { 530 tree rproto, p; 531 532 /* Make sure the protocol is supported by the object on the rhs. */ 533 if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE) 534 { 535 tree fnd = 0; 536 for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto)) 537 { 538 p = TREE_VALUE (rproto); 539 540 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE) 541 { 542 if (lproto == p) 543 fnd = lproto; 544 545 else if (PROTOCOL_LIST (p)) 546 fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto); 547 } 548 549 if (fnd) 550 return fnd; 551 } 552 } 553 else 554 { 555 ; /* An identifier...if we could not find a protocol. */ 556 } 557 558 return 0; 559 } 560 561 void 562 objc_start_class_interface (tree klass, tree super_class, 563 tree protos, tree attributes) 564 { 565 if (flag_objc1_only && attributes) 566 error_at (input_location, "class attributes are not available in Objective-C 1.0"); 567 568 objc_interface_context 569 = objc_ivar_context 570 = start_class (CLASS_INTERFACE_TYPE, klass, super_class, protos, attributes); 571 objc_ivar_visibility = OBJC_IVAR_VIS_PROTECTED; 572 } 573 574 void 575 objc_start_category_interface (tree klass, tree categ, 576 tree protos, tree attributes) 577 { 578 if (attributes) 579 { 580 if (flag_objc1_only) 581 error_at (input_location, "category attributes are not available in Objective-C 1.0"); 582 else 583 warning_at (input_location, OPT_Wattributes, 584 "category attributes are not available in this version" 585 " of the compiler, (ignored)"); 586 } 587 if (categ == NULL_TREE) 588 { 589 if (flag_objc1_only) 590 error_at (input_location, "class extensions are not available in Objective-C 1.0"); 591 else 592 { 593 /* Iterate over all the classes and categories implemented 594 up to now in this compilation unit. */ 595 struct imp_entry *t; 596 597 for (t = imp_list; t; t = t->next) 598 { 599 /* If we find a class @implementation with the same name 600 as the one we are extending, produce an error. */ 601 if (TREE_CODE (t->imp_context) == CLASS_IMPLEMENTATION_TYPE 602 && IDENTIFIER_POINTER (CLASS_NAME (t->imp_context)) == IDENTIFIER_POINTER (klass)) 603 error_at (input_location, 604 "class extension for class %qE declared after its %<@implementation%>", 605 klass); 606 } 607 } 608 } 609 objc_interface_context 610 = start_class (CATEGORY_INTERFACE_TYPE, klass, categ, protos, NULL_TREE); 611 objc_ivar_chain 612 = continue_class (objc_interface_context); 613 } 614 615 void 616 objc_start_protocol (tree name, tree protos, tree attributes) 617 { 618 if (flag_objc1_only && attributes) 619 error_at (input_location, "protocol attributes are not available in Objective-C 1.0"); 620 621 objc_interface_context 622 = start_protocol (PROTOCOL_INTERFACE_TYPE, name, protos, attributes); 623 objc_method_optional_flag = false; 624 } 625 626 void 627 objc_continue_interface (void) 628 { 629 objc_ivar_chain 630 = continue_class (objc_interface_context); 631 } 632 633 void 634 objc_finish_interface (void) 635 { 636 finish_class (objc_interface_context); 637 objc_interface_context = NULL_TREE; 638 objc_method_optional_flag = false; 639 objc_in_class_extension = false; 640 } 641 642 void 643 objc_start_class_implementation (tree klass, tree super_class) 644 { 645 objc_implementation_context 646 = objc_ivar_context 647 = start_class (CLASS_IMPLEMENTATION_TYPE, klass, super_class, NULL_TREE, 648 NULL_TREE); 649 objc_ivar_visibility = OBJC_IVAR_VIS_PROTECTED; 650 } 651 652 void 653 objc_start_category_implementation (tree klass, tree categ) 654 { 655 objc_implementation_context 656 = start_class (CATEGORY_IMPLEMENTATION_TYPE, klass, categ, NULL_TREE, 657 NULL_TREE); 658 objc_ivar_chain 659 = continue_class (objc_implementation_context); 660 } 661 662 void 663 objc_continue_implementation (void) 664 { 665 objc_ivar_chain 666 = continue_class (objc_implementation_context); 667 } 668 669 void 670 objc_finish_implementation (void) 671 { 672 #ifdef OBJCPLUS 673 if (flag_objc_call_cxx_cdtors) 674 objc_generate_cxx_cdtors (); 675 #endif 676 677 if (objc_implementation_context) 678 { 679 finish_class (objc_implementation_context); 680 objc_ivar_chain = NULL_TREE; 681 objc_implementation_context = NULL_TREE; 682 } 683 else 684 warning (0, "%<@end%> must appear in an @implementation context"); 685 } 686 687 void 688 objc_set_visibility (objc_ivar_visibility_kind visibility) 689 { 690 if (visibility == OBJC_IVAR_VIS_PACKAGE) 691 { 692 if (flag_objc1_only) 693 error ("%<@package%> is not available in Objective-C 1.0"); 694 else 695 warning (0, "%<@package%> presently has the same effect as %<@public%>"); 696 } 697 objc_ivar_visibility = visibility; 698 } 699 700 void 701 objc_set_method_opt (bool optional) 702 { 703 if (flag_objc1_only) 704 { 705 if (optional) 706 error_at (input_location, "%<@optional%> is not available in Objective-C 1.0"); 707 else 708 error_at (input_location, "%<@required%> is not available in Objective-C 1.0"); 709 } 710 711 objc_method_optional_flag = optional; 712 if (!objc_interface_context 713 || TREE_CODE (objc_interface_context) != PROTOCOL_INTERFACE_TYPE) 714 { 715 if (optional) 716 error ("%<@optional%> is allowed in @protocol context only"); 717 else 718 error ("%<@required%> is allowed in @protocol context only"); 719 objc_method_optional_flag = false; 720 } 721 } 722 723 /* This routine looks for a given PROPERTY in a list of CLASS, CATEGORY, or 724 PROTOCOL. */ 725 static tree 726 lookup_property_in_list (tree chain, tree property) 727 { 728 tree x; 729 for (x = CLASS_PROPERTY_DECL (chain); x; x = TREE_CHAIN (x)) 730 if (PROPERTY_NAME (x) == property) 731 return x; 732 return NULL_TREE; 733 } 734 735 /* This routine looks for a given PROPERTY in the tree chain of RPROTO_LIST. */ 736 static tree lookup_property_in_protocol_list (tree rproto_list, tree property) 737 { 738 tree rproto, x; 739 for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto)) 740 { 741 tree p = TREE_VALUE (rproto); 742 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE) 743 { 744 if ((x = lookup_property_in_list (p, property))) 745 return x; 746 if (PROTOCOL_LIST (p)) 747 return lookup_property_in_protocol_list (PROTOCOL_LIST (p), property); 748 } 749 else 750 { 751 ; /* An identifier...if we could not find a protocol. */ 752 } 753 } 754 return NULL_TREE; 755 } 756 757 /* This routine looks up the PROPERTY in current INTERFACE, its categories and up the 758 chain of interface hierarchy. */ 759 static tree 760 lookup_property (tree interface_type, tree property) 761 { 762 tree inter = interface_type; 763 while (inter) 764 { 765 tree x, category; 766 if ((x = lookup_property_in_list (inter, property))) 767 return x; 768 /* Failing that, look for the property in each category of the class. */ 769 category = inter; 770 while ((category = CLASS_CATEGORY_LIST (category))) 771 { 772 if ((x = lookup_property_in_list (category, property))) 773 return x; 774 775 /* When checking a category, also check the protocols 776 attached with the category itself. */ 777 if (CLASS_PROTOCOL_LIST (category) 778 && (x = lookup_property_in_protocol_list 779 (CLASS_PROTOCOL_LIST (category), property))) 780 return x; 781 } 782 783 /* Failing to find in categories, look for property in protocol list. */ 784 if (CLASS_PROTOCOL_LIST (inter) 785 && (x = lookup_property_in_protocol_list 786 (CLASS_PROTOCOL_LIST (inter), property))) 787 return x; 788 789 /* Failing that, climb up the inheritance hierarchy. */ 790 inter = lookup_interface (CLASS_SUPER_NAME (inter)); 791 } 792 return inter; 793 } 794 795 /* This routine is called by the parser when a 796 @property... declaration is found. 'decl' is the declaration of 797 the property (type/identifier), and the other arguments represent 798 property attributes that may have been specified in the Objective-C 799 declaration. 'parsed_property_readonly' is 'true' if the attribute 800 'readonly' was specified, and 'false' if not; similarly for the 801 other bool parameters. 'parsed_property_getter_ident' is NULL_TREE 802 if the attribute 'getter' was not specified, and is the identifier 803 corresponding to the specified getter if it was; similarly for 804 'parsed_property_setter_ident'. */ 805 void 806 objc_add_property_declaration (location_t location, tree decl, 807 bool parsed_property_readonly, bool parsed_property_readwrite, 808 bool parsed_property_assign, bool parsed_property_retain, 809 bool parsed_property_copy, bool parsed_property_nonatomic, 810 tree parsed_property_getter_ident, tree parsed_property_setter_ident) 811 { 812 tree property_decl; 813 tree x; 814 /* 'property_readonly' and 'property_assign_semantics' are the final 815 attributes of the property after all parsed attributes have been 816 considered (eg, if we parsed no 'readonly' and no 'readwrite', ie 817 parsed_property_readonly = false and parsed_property_readwrite = 818 false, then property_readonly will be false because the default 819 is readwrite). */ 820 bool property_readonly = false; 821 objc_property_assign_semantics property_assign_semantics = OBJC_PROPERTY_ASSIGN; 822 bool property_extension_in_class_extension = false; 823 824 if (flag_objc1_only) 825 error_at (input_location, "%<@property%> is not available in Objective-C 1.0"); 826 827 if (parsed_property_readonly && parsed_property_readwrite) 828 { 829 error_at (location, "%<readonly%> attribute conflicts with %<readwrite%> attribute"); 830 /* In case of conflicting attributes (here and below), after 831 producing an error, we pick one of the attributes and keep 832 going. */ 833 property_readonly = false; 834 } 835 else 836 { 837 if (parsed_property_readonly) 838 property_readonly = true; 839 840 if (parsed_property_readwrite) 841 property_readonly = false; 842 } 843 844 if (parsed_property_readonly && parsed_property_setter_ident) 845 { 846 error_at (location, "%<readonly%> attribute conflicts with %<setter%> attribute"); 847 property_readonly = false; 848 } 849 850 if (parsed_property_assign && parsed_property_retain) 851 { 852 error_at (location, "%<assign%> attribute conflicts with %<retain%> attribute"); 853 property_assign_semantics = OBJC_PROPERTY_RETAIN; 854 } 855 else if (parsed_property_assign && parsed_property_copy) 856 { 857 error_at (location, "%<assign%> attribute conflicts with %<copy%> attribute"); 858 property_assign_semantics = OBJC_PROPERTY_COPY; 859 } 860 else if (parsed_property_retain && parsed_property_copy) 861 { 862 error_at (location, "%<retain%> attribute conflicts with %<copy%> attribute"); 863 property_assign_semantics = OBJC_PROPERTY_COPY; 864 } 865 else 866 { 867 if (parsed_property_assign) 868 property_assign_semantics = OBJC_PROPERTY_ASSIGN; 869 870 if (parsed_property_retain) 871 property_assign_semantics = OBJC_PROPERTY_RETAIN; 872 873 if (parsed_property_copy) 874 property_assign_semantics = OBJC_PROPERTY_COPY; 875 } 876 877 if (!objc_interface_context) 878 { 879 error_at (location, "property declaration not in @interface or @protocol context"); 880 return; 881 } 882 883 /* At this point we know that we are either in an interface, a 884 category, or a protocol. */ 885 886 /* We expect a FIELD_DECL from the parser. Make sure we didn't get 887 something else, as that would confuse the checks below. */ 888 if (TREE_CODE (decl) != FIELD_DECL) 889 { 890 error_at (location, "invalid property declaration"); 891 return; 892 } 893 894 /* Do some spot-checks for the most obvious invalid types. */ 895 896 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) 897 { 898 error_at (location, "property can not be an array"); 899 return; 900 } 901 902 /* The C++/ObjC++ parser seems to reject the ':' for a bitfield when 903 parsing, while the C/ObjC parser accepts it and gives us a 904 FIELD_DECL with a DECL_INITIAL set. So we use the DECL_INITIAL 905 to check for a bitfield when doing ObjC. */ 906 #ifndef OBJCPLUS 907 if (DECL_INITIAL (decl)) 908 { 909 /* A @property is not an actual variable, but it is a way to 910 describe a pair of accessor methods, so its type (which is 911 the type of the return value of the getter and the first 912 argument of the setter) can't be a bitfield (as return values 913 and arguments of functions can not be bitfields). The 914 underlying instance variable could be a bitfield, but that is 915 a different matter. */ 916 error_at (location, "property can not be a bit-field"); 917 return; 918 } 919 #endif 920 921 /* TODO: Check that the property type is an Objective-C object or a 922 "POD". */ 923 924 /* Implement -Wproperty-assign-default (which is enabled by default). */ 925 if (warn_property_assign_default 926 /* If garbage collection is not being used, then 'assign' is 927 valid for objects (and typically used for delegates) but it 928 is wrong in most cases (since most objects need to be 929 retained or copied in setters). Warn users when 'assign' is 930 used implicitly. */ 931 && property_assign_semantics == OBJC_PROPERTY_ASSIGN 932 /* Read-only properties are never assigned, so the assignment 933 semantics do not matter in that case. */ 934 && !property_readonly 935 && !flag_objc_gc) 936 { 937 /* Please note that it would make sense to default to 'assign' 938 for non-{Objective-C objects}, and to 'retain' for 939 Objective-C objects. But that would break compatibility with 940 other compilers. */ 941 if (!parsed_property_assign && !parsed_property_retain && !parsed_property_copy) 942 { 943 /* Use 'false' so we do not warn for Class objects. */ 944 if (objc_type_valid_for_messaging (TREE_TYPE (decl), false)) 945 { 946 warning_at (location, 947 0, 948 "object property %qD has no %<assign%>, %<retain%> or %<copy%> attribute; assuming %<assign%>", 949 decl); 950 inform (location, 951 "%<assign%> can be unsafe for Objective-C objects; please state explicitly if you need it"); 952 } 953 } 954 } 955 956 if (property_assign_semantics == OBJC_PROPERTY_RETAIN 957 && !objc_type_valid_for_messaging (TREE_TYPE (decl), true)) 958 error_at (location, "%<retain%> attribute is only valid for Objective-C objects"); 959 960 if (property_assign_semantics == OBJC_PROPERTY_COPY 961 && !objc_type_valid_for_messaging (TREE_TYPE (decl), true)) 962 error_at (location, "%<copy%> attribute is only valid for Objective-C objects"); 963 964 /* Now determine the final property getter and setter names. They 965 will be stored in the PROPERTY_DECL, from which they'll always be 966 extracted and used. */ 967 968 /* Adjust, or fill in, setter and getter names. We overwrite the 969 parsed_property_setter_ident and parsed_property_getter_ident 970 with the final setter and getter identifiers that will be 971 used. */ 972 if (parsed_property_setter_ident) 973 { 974 /* The setter should be terminated by ':', but the parser only 975 gives us an identifier without ':'. So, we need to add ':' 976 at the end. */ 977 const char *parsed_setter = IDENTIFIER_POINTER (parsed_property_setter_ident); 978 size_t length = strlen (parsed_setter); 979 char *final_setter = (char *)alloca (length + 2); 980 981 sprintf (final_setter, "%s:", parsed_setter); 982 parsed_property_setter_ident = get_identifier (final_setter); 983 } 984 else 985 { 986 if (!property_readonly) 987 parsed_property_setter_ident = get_identifier (objc_build_property_setter_name 988 (DECL_NAME (decl))); 989 } 990 991 if (!parsed_property_getter_ident) 992 parsed_property_getter_ident = DECL_NAME (decl); 993 994 /* Check for duplicate property declarations. We first check the 995 immediate context for a property with the same name. Any such 996 declarations are an error, unless this is a class extension and 997 we are extending a property from readonly to readwrite. */ 998 for (x = CLASS_PROPERTY_DECL (objc_interface_context); x; x = TREE_CHAIN (x)) 999 { 1000 if (PROPERTY_NAME (x) == DECL_NAME (decl)) 1001 { 1002 if (objc_in_class_extension 1003 && property_readonly == 0 1004 && PROPERTY_READONLY (x) == 1) 1005 { 1006 /* This is a class extension, and we are extending an 1007 existing readonly property to a readwrite one. 1008 That's fine. :-) */ 1009 property_extension_in_class_extension = true; 1010 break; 1011 } 1012 else 1013 { 1014 location_t original_location = DECL_SOURCE_LOCATION (x); 1015 1016 error_at (location, "redeclaration of property %qD", decl); 1017 1018 if (original_location != UNKNOWN_LOCATION) 1019 inform (original_location, "originally specified here"); 1020 return; 1021 } 1022 } 1023 } 1024 1025 /* If x is not NULL_TREE, we must be in a class extension and we're 1026 extending a readonly property. In that case, no point in 1027 searching for another declaration. */ 1028 if (x == NULL_TREE) 1029 { 1030 /* We now need to check for existing property declarations (in 1031 the superclass, other categories or protocols) and check that 1032 the new declaration is not in conflict with existing 1033 ones. */ 1034 1035 /* Search for a previous, existing declaration of a property 1036 with the same name in superclasses, protocols etc. If one is 1037 found, it will be in the 'x' variable. */ 1038 1039 /* Note that, for simplicity, the following may search again the 1040 local context. That's Ok as nothing will be found (else we'd 1041 have thrown an error above); it's only a little inefficient, 1042 but the code is simpler. */ 1043 switch (TREE_CODE (objc_interface_context)) 1044 { 1045 case CLASS_INTERFACE_TYPE: 1046 /* Look up the property in the current @interface (which 1047 will find nothing), then its protocols and categories and 1048 superclasses. */ 1049 x = lookup_property (objc_interface_context, DECL_NAME (decl)); 1050 break; 1051 case CATEGORY_INTERFACE_TYPE: 1052 /* Look up the property in the main @interface, then 1053 protocols and categories (one of them is ours, and will 1054 find nothing) and superclasses. */ 1055 x = lookup_property (lookup_interface (CLASS_NAME (objc_interface_context)), 1056 DECL_NAME (decl)); 1057 break; 1058 case PROTOCOL_INTERFACE_TYPE: 1059 /* Looks up the property in any protocols attached to the 1060 current protocol. */ 1061 if (PROTOCOL_LIST (objc_interface_context)) 1062 { 1063 x = lookup_property_in_protocol_list (PROTOCOL_LIST (objc_interface_context), 1064 DECL_NAME (decl)); 1065 } 1066 break; 1067 default: 1068 gcc_unreachable (); 1069 } 1070 } 1071 1072 if (x != NULL_TREE) 1073 { 1074 /* An existing property was found; check that it has the same 1075 types, or it is compatible. */ 1076 location_t original_location = DECL_SOURCE_LOCATION (x); 1077 1078 if (PROPERTY_NONATOMIC (x) != parsed_property_nonatomic) 1079 { 1080 warning_at (location, 0, 1081 "'nonatomic' attribute of property %qD conflicts with previous declaration", decl); 1082 1083 if (original_location != UNKNOWN_LOCATION) 1084 inform (original_location, "originally specified here"); 1085 return; 1086 } 1087 1088 if (PROPERTY_GETTER_NAME (x) != parsed_property_getter_ident) 1089 { 1090 warning_at (location, 0, 1091 "'getter' attribute of property %qD conflicts with previous declaration", decl); 1092 1093 if (original_location != UNKNOWN_LOCATION) 1094 inform (original_location, "originally specified here"); 1095 return; 1096 } 1097 1098 /* We can only compare the setter names if both the old and new property have a setter. */ 1099 if (!property_readonly && !PROPERTY_READONLY(x)) 1100 { 1101 if (PROPERTY_SETTER_NAME (x) != parsed_property_setter_ident) 1102 { 1103 warning_at (location, 0, 1104 "'setter' attribute of property %qD conflicts with previous declaration", decl); 1105 1106 if (original_location != UNKNOWN_LOCATION) 1107 inform (original_location, "originally specified here"); 1108 return; 1109 } 1110 } 1111 1112 if (PROPERTY_ASSIGN_SEMANTICS (x) != property_assign_semantics) 1113 { 1114 warning_at (location, 0, 1115 "assign semantics attributes of property %qD conflict with previous declaration", decl); 1116 1117 if (original_location != UNKNOWN_LOCATION) 1118 inform (original_location, "originally specified here"); 1119 return; 1120 } 1121 1122 /* It's ok to have a readonly property that becomes a readwrite, but not vice versa. */ 1123 if (PROPERTY_READONLY (x) == 0 && property_readonly == 1) 1124 { 1125 warning_at (location, 0, 1126 "'readonly' attribute of property %qD conflicts with previous declaration", decl); 1127 1128 if (original_location != UNKNOWN_LOCATION) 1129 inform (original_location, "originally specified here"); 1130 return; 1131 } 1132 1133 /* We now check that the new and old property declarations have 1134 the same types (or compatible one). In the Objective-C 1135 tradition of loose type checking, we do type-checking but 1136 only generate warnings (not errors) if they do not match. 1137 For non-readonly properties, the types must match exactly; 1138 for readonly properties, it is allowed to use a "more 1139 specialized" type in the new property declaration. Eg, the 1140 superclass has a getter returning (NSArray *) and the 1141 subclass a getter returning (NSMutableArray *). The object's 1142 getter returns an (NSMutableArray *); but if you cast the 1143 object to the superclass, which is allowed, you'd still 1144 expect the getter to return an (NSArray *), which works since 1145 an (NSMutableArray *) is an (NSArray *) too. So, the set of 1146 objects belonging to the type of the new @property should be 1147 a subset of the set of objects belonging to the type of the 1148 old @property. This is what "specialization" means. And the 1149 reason it only applies to readonly properties is that for a 1150 readwrite property the setter would have the opposite 1151 requirement - ie that the superclass type is more specialized 1152 then the subclass one; hence the only way to satisfy both 1153 constraints is that the types match. */ 1154 1155 /* If the types are not the same in the C sense, we warn ... */ 1156 if (!comptypes (TREE_TYPE (x), TREE_TYPE (decl)) 1157 /* ... unless the property is readonly, in which case we 1158 allow a new, more specialized, declaration. */ 1159 && (!property_readonly 1160 || !objc_compare_types (TREE_TYPE (x), 1161 TREE_TYPE (decl), -5, NULL_TREE))) 1162 { 1163 warning_at (location, 0, 1164 "type of property %qD conflicts with previous declaration", decl); 1165 if (original_location != UNKNOWN_LOCATION) 1166 inform (original_location, "originally specified here"); 1167 return; 1168 } 1169 1170 /* If we are in a class extension and we're extending a readonly 1171 property in the main @interface, we'll just update the 1172 existing property with the readwrite flag and potentially the 1173 new setter name. */ 1174 if (property_extension_in_class_extension) 1175 { 1176 PROPERTY_READONLY (x) = 0; 1177 PROPERTY_SETTER_NAME (x) = parsed_property_setter_ident; 1178 return; 1179 } 1180 } 1181 1182 /* Create a PROPERTY_DECL node. */ 1183 property_decl = make_node (PROPERTY_DECL); 1184 1185 /* Copy the basic information from the original decl. */ 1186 TREE_TYPE (property_decl) = TREE_TYPE (decl); 1187 DECL_SOURCE_LOCATION (property_decl) = DECL_SOURCE_LOCATION (decl); 1188 TREE_DEPRECATED (property_decl) = TREE_DEPRECATED (decl); 1189 1190 /* Add property-specific information. */ 1191 PROPERTY_NAME (property_decl) = DECL_NAME (decl); 1192 PROPERTY_GETTER_NAME (property_decl) = parsed_property_getter_ident; 1193 PROPERTY_SETTER_NAME (property_decl) = parsed_property_setter_ident; 1194 PROPERTY_READONLY (property_decl) = property_readonly; 1195 PROPERTY_NONATOMIC (property_decl) = parsed_property_nonatomic; 1196 PROPERTY_ASSIGN_SEMANTICS (property_decl) = property_assign_semantics; 1197 PROPERTY_IVAR_NAME (property_decl) = NULL_TREE; 1198 PROPERTY_DYNAMIC (property_decl) = 0; 1199 1200 /* Remember the fact that the property was found in the @optional 1201 section in a @protocol, or not. */ 1202 if (objc_method_optional_flag) 1203 PROPERTY_OPTIONAL (property_decl) = 1; 1204 else 1205 PROPERTY_OPTIONAL (property_decl) = 0; 1206 1207 /* Note that PROPERTY_GETTER_NAME is always set for all 1208 PROPERTY_DECLs, and PROPERTY_SETTER_NAME is always set for all 1209 PROPERTY_DECLs where PROPERTY_READONLY == 0. Any time we deal 1210 with a getter or setter, we should get the PROPERTY_DECL and use 1211 PROPERTY_GETTER_NAME and PROPERTY_SETTER_NAME to know the correct 1212 names. */ 1213 1214 /* Add the PROPERTY_DECL to the list of properties for the class. */ 1215 TREE_CHAIN (property_decl) = CLASS_PROPERTY_DECL (objc_interface_context); 1216 CLASS_PROPERTY_DECL (objc_interface_context) = property_decl; 1217 } 1218 1219 /* This is a subroutine of objc_maybe_build_component_ref. Search the 1220 list of methods in the interface (and, failing that, the local list 1221 in the implementation, and failing that, the protocol list) 1222 provided for a 'setter' or 'getter' for 'component' with default 1223 names (ie, if 'component' is "name", then search for "name" and 1224 "setName:"). It is also possible to specify a different 1225 'getter_name' (this is used for @optional readonly properties). If 1226 any is found, then create an artificial property that uses them. 1227 Return NULL_TREE if 'getter' or 'setter' could not be found. */ 1228 static tree 1229 maybe_make_artificial_property_decl (tree interface, tree implementation, 1230 tree protocol_list, tree component, bool is_class, 1231 tree getter_name) 1232 { 1233 tree setter_name = get_identifier (objc_build_property_setter_name (component)); 1234 tree getter = NULL_TREE; 1235 tree setter = NULL_TREE; 1236 1237 if (getter_name == NULL_TREE) 1238 getter_name = component; 1239 1240 /* First, check the @interface and all superclasses. */ 1241 if (interface) 1242 { 1243 int flags = 0; 1244 1245 /* Using instance methods of the root class as accessors is most 1246 likely unwanted and can be extremely confusing (and, most 1247 importantly, other Objective-C 2.0 compilers do not do it). 1248 Turn it off. */ 1249 if (is_class) 1250 flags = OBJC_LOOKUP_CLASS | OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS; 1251 1252 getter = lookup_method_static (interface, getter_name, flags); 1253 setter = lookup_method_static (interface, setter_name, flags); 1254 } 1255 1256 /* Second, check the local @implementation context. */ 1257 if (!getter && !setter) 1258 { 1259 if (implementation) 1260 { 1261 if (is_class) 1262 { 1263 getter = lookup_method (CLASS_CLS_METHODS (implementation), getter_name); 1264 setter = lookup_method (CLASS_CLS_METHODS (implementation), setter_name); 1265 } 1266 else 1267 { 1268 getter = lookup_method (CLASS_NST_METHODS (implementation), getter_name); 1269 setter = lookup_method (CLASS_NST_METHODS (implementation), setter_name); 1270 } 1271 } 1272 } 1273 1274 /* Try the protocol_list if we didn't find anything in the 1275 @interface and in the @implementation. */ 1276 if (!getter && !setter) 1277 { 1278 getter = lookup_method_in_protocol_list (protocol_list, getter_name, is_class); 1279 setter = lookup_method_in_protocol_list (protocol_list, setter_name, is_class); 1280 } 1281 1282 /* There needs to be at least a getter or setter for this to be a 1283 valid 'object.component' syntax. */ 1284 if (getter || setter) 1285 { 1286 /* Yes ... determine the type of the expression. */ 1287 tree property_decl; 1288 tree type; 1289 1290 if (getter) 1291 type = TREE_VALUE (TREE_TYPE (getter)); 1292 else 1293 type = TREE_VALUE (TREE_TYPE (METHOD_SEL_ARGS (setter))); 1294 1295 /* Create an artificial property declaration with the 1296 information we collected on the type and getter/setter 1297 names. */ 1298 property_decl = make_node (PROPERTY_DECL); 1299 1300 TREE_TYPE (property_decl) = type; 1301 DECL_SOURCE_LOCATION (property_decl) = input_location; 1302 TREE_DEPRECATED (property_decl) = 0; 1303 DECL_ARTIFICIAL (property_decl) = 1; 1304 1305 /* Add property-specific information. Note that one of 1306 PROPERTY_GETTER_NAME or PROPERTY_SETTER_NAME may refer to a 1307 non-existing method; this will generate an error when the 1308 expression is later compiled. At this stage we don't know if 1309 the getter or setter will be used, so we can't generate an 1310 error. */ 1311 PROPERTY_NAME (property_decl) = component; 1312 PROPERTY_GETTER_NAME (property_decl) = getter_name; 1313 PROPERTY_SETTER_NAME (property_decl) = setter_name; 1314 PROPERTY_READONLY (property_decl) = 0; 1315 PROPERTY_NONATOMIC (property_decl) = 0; 1316 PROPERTY_ASSIGN_SEMANTICS (property_decl) = 0; 1317 PROPERTY_IVAR_NAME (property_decl) = NULL_TREE; 1318 PROPERTY_DYNAMIC (property_decl) = 0; 1319 PROPERTY_OPTIONAL (property_decl) = 0; 1320 1321 if (!getter) 1322 PROPERTY_HAS_NO_GETTER (property_decl) = 1; 1323 1324 /* The following is currently unused, but it's nice to have 1325 there. We may use it if we need in the future. */ 1326 if (!setter) 1327 PROPERTY_HAS_NO_SETTER (property_decl) = 1; 1328 1329 return property_decl; 1330 } 1331 1332 return NULL_TREE; 1333 } 1334 1335 /* This hook routine is invoked by the parser when an expression such 1336 as 'xxx.yyy' is parsed. We get a chance to process these 1337 expressions in a way that is specified to Objective-C (to implement 1338 the Objective-C 2.0 dot-syntax, properties, or non-fragile ivars). 1339 If the expression is not an Objective-C specified expression, we 1340 should return NULL_TREE; else we return the expression. 1341 1342 At the moment this only implements dot-syntax and properties (not 1343 non-fragile ivars yet), ie 'object.property' or 'object.component' 1344 where 'component' is not a declared property, but a valid getter or 1345 setter for it could be found. */ 1346 tree 1347 objc_maybe_build_component_ref (tree object, tree property_ident) 1348 { 1349 tree x = NULL_TREE; 1350 tree rtype; 1351 1352 /* If we are in Objective-C 1.0 mode, dot-syntax and properties are 1353 not available. */ 1354 if (flag_objc1_only) 1355 return NULL_TREE; 1356 1357 /* Try to determine if 'object' is an Objective-C object or not. If 1358 not, return. */ 1359 if (object == NULL_TREE || object == error_mark_node 1360 || (rtype = TREE_TYPE (object)) == NULL_TREE) 1361 return NULL_TREE; 1362 1363 if (property_ident == NULL_TREE || property_ident == error_mark_node 1364 || TREE_CODE (property_ident) != IDENTIFIER_NODE) 1365 return NULL_TREE; 1366 1367 /* The following analysis of 'object' is similar to the one used for 1368 the 'receiver' of a method invocation. We need to determine what 1369 'object' is and find the appropriate property (either declared, 1370 or artificial) for it (in the same way as we need to find the 1371 appropriate method prototype for a method invocation). There are 1372 some simplifications here though: "object.property" is invalid if 1373 "object" has a type of "id" or "Class"; it must at least have a 1374 protocol attached to it, and "object" is never a class name as 1375 that is done by objc_build_class_component_ref. Finally, we 1376 don't know if this really is a dot-syntax expression, so we want 1377 to make a quick exit if it is not; for this reason, we try to 1378 postpone checks after determining that 'object' looks like an 1379 Objective-C object. */ 1380 1381 if (objc_is_id (rtype)) 1382 { 1383 /* This is the case that the 'object' is of type 'id' or 1384 'Class'. */ 1385 1386 /* Check if at least it is of type 'id <Protocol>' or 'Class 1387 <Protocol>'; if so, look the property up in the 1388 protocols. */ 1389 if (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))) 1390 { 1391 tree rprotos = TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype)); 1392 1393 if (rprotos) 1394 { 1395 /* No point looking up declared @properties if we are 1396 dealing with a class. Classes have no declared 1397 properties. */ 1398 if (!IS_CLASS (rtype)) 1399 x = lookup_property_in_protocol_list (rprotos, property_ident); 1400 1401 if (x == NULL_TREE) 1402 { 1403 /* Ok, no property. Maybe it was an 1404 object.component dot-syntax without a declared 1405 property (this is valid for classes too). Look 1406 for getter/setter methods and internally declare 1407 an artifical property based on them if found. */ 1408 x = maybe_make_artificial_property_decl (NULL_TREE, 1409 NULL_TREE, 1410 rprotos, 1411 property_ident, 1412 IS_CLASS (rtype), 1413 NULL_TREE); 1414 } 1415 else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x)) 1416 { 1417 /* This is a special, complicated case. If the 1418 property is optional, and is read-only, then the 1419 property is always used for reading, but an 1420 eventual existing non-property setter can be used 1421 for writing. We create an artificial property 1422 decl copying the getter from the optional 1423 property, and looking up the setter in the 1424 interface. */ 1425 x = maybe_make_artificial_property_decl (NULL_TREE, 1426 NULL_TREE, 1427 rprotos, 1428 property_ident, 1429 false, 1430 PROPERTY_GETTER_NAME (x)); 1431 } 1432 } 1433 } 1434 else if (objc_method_context) 1435 { 1436 /* Else, if we are inside a method it could be the case of 1437 'super' or 'self'. */ 1438 tree interface_type = NULL_TREE; 1439 tree t = object; 1440 while (TREE_CODE (t) == COMPOUND_EXPR 1441 || TREE_CODE (t) == MODIFY_EXPR 1442 || CONVERT_EXPR_P (t) 1443 || TREE_CODE (t) == COMPONENT_REF) 1444 t = TREE_OPERAND (t, 0); 1445 1446 if (t == UOBJC_SUPER_decl) 1447 interface_type = lookup_interface (CLASS_SUPER_NAME (implementation_template)); 1448 else if (t == self_decl) 1449 interface_type = lookup_interface (CLASS_NAME (implementation_template)); 1450 1451 if (interface_type) 1452 { 1453 if (TREE_CODE (objc_method_context) != CLASS_METHOD_DECL) 1454 x = lookup_property (interface_type, property_ident); 1455 1456 if (x == NULL_TREE) 1457 { 1458 /* Try the dot-syntax without a declared property. 1459 If this is an access to 'self', it is possible 1460 that they may refer to a setter/getter that is 1461 not declared in the interface, but exists locally 1462 in the implementation. In that case, get the 1463 implementation context and use it. */ 1464 tree implementation = NULL_TREE; 1465 1466 if (t == self_decl) 1467 implementation = objc_implementation_context; 1468 1469 x = maybe_make_artificial_property_decl 1470 (interface_type, implementation, NULL_TREE, 1471 property_ident, 1472 (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL), 1473 NULL_TREE); 1474 } 1475 else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x)) 1476 { 1477 tree implementation = NULL_TREE; 1478 1479 if (t == self_decl) 1480 implementation = objc_implementation_context; 1481 1482 x = maybe_make_artificial_property_decl (interface_type, 1483 implementation, 1484 NULL_TREE, 1485 property_ident, 1486 false, 1487 PROPERTY_GETTER_NAME (x)); 1488 } 1489 } 1490 } 1491 } 1492 else 1493 { 1494 /* This is the case where we have more information on 'rtype'. */ 1495 tree basetype = TYPE_MAIN_VARIANT (rtype); 1496 1497 /* Skip the pointer - if none, it's not an Objective-C object or 1498 class. */ 1499 if (basetype != NULL_TREE && TREE_CODE (basetype) == POINTER_TYPE) 1500 basetype = TREE_TYPE (basetype); 1501 else 1502 return NULL_TREE; 1503 1504 /* Traverse typedefs. */ 1505 while (basetype != NULL_TREE 1506 && TREE_CODE (basetype) == RECORD_TYPE 1507 && OBJC_TYPE_NAME (basetype) 1508 && TREE_CODE (OBJC_TYPE_NAME (basetype)) == TYPE_DECL 1509 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype))) 1510 basetype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype)); 1511 1512 if (basetype != NULL_TREE && TYPED_OBJECT (basetype)) 1513 { 1514 tree interface_type = TYPE_OBJC_INTERFACE (basetype); 1515 tree protocol_list = TYPE_OBJC_PROTOCOL_LIST (basetype); 1516 1517 if (interface_type 1518 && (TREE_CODE (interface_type) == CLASS_INTERFACE_TYPE 1519 || TREE_CODE (interface_type) == CATEGORY_INTERFACE_TYPE 1520 || TREE_CODE (interface_type) == PROTOCOL_INTERFACE_TYPE)) 1521 { 1522 /* Not sure 'rtype' could ever be a class here! Just 1523 for safety we keep the checks. */ 1524 if (!IS_CLASS (rtype)) 1525 { 1526 x = lookup_property (interface_type, property_ident); 1527 1528 if (x == NULL_TREE) 1529 x = lookup_property_in_protocol_list (protocol_list, 1530 property_ident); 1531 } 1532 1533 if (x == NULL_TREE) 1534 { 1535 /* Try the dot-syntax without a declared property. 1536 If we are inside a method implementation, it is 1537 possible that they may refer to a setter/getter 1538 that is not declared in the interface, but exists 1539 locally in the implementation. In that case, get 1540 the implementation context and use it. */ 1541 tree implementation = NULL_TREE; 1542 1543 if (objc_implementation_context 1544 && CLASS_NAME (objc_implementation_context) 1545 == OBJC_TYPE_NAME (interface_type)) 1546 implementation = objc_implementation_context; 1547 1548 x = maybe_make_artificial_property_decl (interface_type, 1549 implementation, 1550 protocol_list, 1551 property_ident, 1552 IS_CLASS (rtype), 1553 NULL_TREE); 1554 } 1555 else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x)) 1556 { 1557 tree implementation = NULL_TREE; 1558 1559 if (objc_implementation_context 1560 && CLASS_NAME (objc_implementation_context) 1561 == OBJC_TYPE_NAME (interface_type)) 1562 implementation = objc_implementation_context; 1563 1564 x = maybe_make_artificial_property_decl (interface_type, 1565 implementation, 1566 protocol_list, 1567 property_ident, 1568 false, 1569 PROPERTY_GETTER_NAME (x)); 1570 } 1571 } 1572 } 1573 } 1574 1575 if (x) 1576 { 1577 tree expression; 1578 tree getter_call; 1579 tree deprecated_method_prototype = NULL_TREE; 1580 1581 /* We have an additional nasty problem here; if this 1582 PROPERTY_REF needs to become a 'getter', then the conversion 1583 from PROPERTY_REF into a getter call happens in gimplify, 1584 after the selector table has already been generated and when 1585 it is too late to add another selector to it. To work around 1586 the problem, we always create the getter call at this stage, 1587 which puts the selector in the table. Note that if the 1588 PROPERTY_REF becomes a 'setter' instead of a 'getter', then 1589 we have added a selector too many to the selector table. 1590 This is a little inefficient. 1591 1592 Also note that method calls to 'self' and 'super' require the 1593 context (self_decl, UOBJS_SUPER_decl, 1594 objc_implementation_context etc) to be built correctly; this 1595 is yet another reason why building the call at the gimplify 1596 stage (when this context has been lost) is not very 1597 practical. If we build it at this stage, we know it will 1598 always be built correctly. 1599 1600 If the PROPERTY_HAS_NO_GETTER() (ie, it is an artificial 1601 property decl created to deal with a dotsyntax not really 1602 referring to an existing property) then do not try to build a 1603 call to the getter as there is no getter. */ 1604 if (PROPERTY_HAS_NO_GETTER (x)) 1605 getter_call = NULL_TREE; 1606 else 1607 getter_call = objc_finish_message_expr 1608 (object, PROPERTY_GETTER_NAME (x), NULL_TREE, 1609 /* Disable the immediate deprecation warning if the getter 1610 is deprecated, but record the fact that the getter is 1611 deprecated by setting PROPERTY_REF_DEPRECATED_GETTER to 1612 the method prototype. */ 1613 &deprecated_method_prototype); 1614 1615 expression = build4 (PROPERTY_REF, TREE_TYPE(x), object, x, getter_call, 1616 deprecated_method_prototype); 1617 SET_EXPR_LOCATION (expression, input_location); 1618 TREE_SIDE_EFFECTS (expression) = 1; 1619 1620 return expression; 1621 } 1622 1623 return NULL_TREE; 1624 } 1625 1626 /* This hook routine is invoked by the parser when an expression such 1627 as 'xxx.yyy' is parsed, and 'xxx' is a class name. This is the 1628 Objective-C 2.0 dot-syntax applied to classes, so we need to 1629 convert it into a setter/getter call on the class. */ 1630 tree 1631 objc_build_class_component_ref (tree class_name, tree property_ident) 1632 { 1633 tree x = NULL_TREE; 1634 tree object, rtype; 1635 1636 if (flag_objc1_only) 1637 error_at (input_location, "the dot syntax is not available in Objective-C 1.0"); 1638 1639 if (class_name == NULL_TREE || class_name == error_mark_node 1640 || TREE_CODE (class_name) != IDENTIFIER_NODE) 1641 return error_mark_node; 1642 1643 if (property_ident == NULL_TREE || property_ident == error_mark_node 1644 || TREE_CODE (property_ident) != IDENTIFIER_NODE) 1645 return NULL_TREE; 1646 1647 object = objc_get_class_reference (class_name); 1648 if (!object) 1649 { 1650 /* We know that 'class_name' is an Objective-C class name as the 1651 parser won't call this function if it is not. This is only a 1652 double-check for safety. */ 1653 error_at (input_location, "could not find class %qE", class_name); 1654 return error_mark_node; 1655 } 1656 1657 rtype = lookup_interface (class_name); 1658 if (!rtype) 1659 { 1660 /* Again, this should never happen, but we do check. */ 1661 error_at (input_location, "could not find interface for class %qE", class_name); 1662 return error_mark_node; 1663 } 1664 else 1665 { 1666 if (TREE_DEPRECATED (rtype)) 1667 warning (OPT_Wdeprecated_declarations, "class %qE is deprecated", class_name); 1668 } 1669 1670 x = maybe_make_artificial_property_decl (rtype, NULL_TREE, NULL_TREE, 1671 property_ident, 1672 true, NULL_TREE); 1673 1674 if (x) 1675 { 1676 tree expression; 1677 tree getter_call; 1678 tree deprecated_method_prototype = NULL_TREE; 1679 1680 if (PROPERTY_HAS_NO_GETTER (x)) 1681 getter_call = NULL_TREE; 1682 else 1683 getter_call = objc_finish_message_expr 1684 (object, PROPERTY_GETTER_NAME (x), NULL_TREE, 1685 &deprecated_method_prototype); 1686 1687 expression = build4 (PROPERTY_REF, TREE_TYPE(x), object, x, getter_call, 1688 deprecated_method_prototype); 1689 SET_EXPR_LOCATION (expression, input_location); 1690 TREE_SIDE_EFFECTS (expression) = 1; 1691 1692 return expression; 1693 } 1694 else 1695 { 1696 error_at (input_location, "could not find setter/getter for %qE in class %qE", 1697 property_ident, class_name); 1698 return error_mark_node; 1699 } 1700 1701 return NULL_TREE; 1702 } 1703 1704 1705 1706 /* This is used because we don't want to expose PROPERTY_REF to the 1707 C/C++ frontends. Maybe we should! */ 1708 bool 1709 objc_is_property_ref (tree node) 1710 { 1711 if (node && TREE_CODE (node) == PROPERTY_REF) 1712 return true; 1713 else 1714 return false; 1715 } 1716 1717 /* This function builds a setter call for a PROPERTY_REF (real, for a 1718 declared property, or artificial, for a dot-syntax accessor which 1719 is not corresponding to a property). 'lhs' must be a PROPERTY_REF 1720 (the caller must check this beforehand). 'rhs' is the value to 1721 assign to the property. A plain setter call is returned, or 1722 error_mark_node if the property is readonly. */ 1723 1724 static tree 1725 objc_build_setter_call (tree lhs, tree rhs) 1726 { 1727 tree object_expr = PROPERTY_REF_OBJECT (lhs); 1728 tree property_decl = PROPERTY_REF_PROPERTY_DECL (lhs); 1729 1730 if (PROPERTY_READONLY (property_decl)) 1731 { 1732 error ("readonly property can not be set"); 1733 return error_mark_node; 1734 } 1735 else 1736 { 1737 tree setter_argument = build_tree_list (NULL_TREE, rhs); 1738 tree setter; 1739 1740 /* TODO: Check that the setter return type is 'void'. */ 1741 1742 /* TODO: Decay arguments in C. */ 1743 setter = objc_finish_message_expr (object_expr, 1744 PROPERTY_SETTER_NAME (property_decl), 1745 setter_argument, NULL); 1746 return setter; 1747 } 1748 1749 /* Unreachable, but the compiler may not realize. */ 1750 return error_mark_node; 1751 } 1752 1753 /* This hook routine is called when a MODIFY_EXPR is being built. We 1754 check what is being modified; if it is a PROPERTY_REF, we need to 1755 generate a 'setter' function call for the property. If this is not 1756 a PROPERTY_REF, we return NULL_TREE and the C/C++ frontend will go 1757 on creating their MODIFY_EXPR. 1758 1759 This is used for example if you write 1760 1761 object.count = 1; 1762 1763 where 'count' is a property. The left-hand side creates a 1764 PROPERTY_REF, and then the compiler tries to generate a MODIFY_EXPR 1765 to assign something to it. We intercept that here, and generate a 1766 call to the 'setter' method instead. */ 1767 tree 1768 objc_maybe_build_modify_expr (tree lhs, tree rhs) 1769 { 1770 if (lhs && TREE_CODE (lhs) == PROPERTY_REF) 1771 { 1772 /* Building a simple call to the setter method would work for cases such as 1773 1774 object.count = 1; 1775 1776 but wouldn't work for cases such as 1777 1778 count = object2.count = 1; 1779 1780 to get these to work with very little effort, we build a 1781 compound statement which does the setter call (to set the 1782 property to 'rhs'), but which can also be evaluated returning 1783 the 'rhs'. If the 'rhs' has no side effects, we can simply 1784 evaluate it twice, building 1785 1786 ([object setProperty: rhs]; rhs) 1787 1788 If it has side effects, we put it in a temporary variable first, 1789 so we create the following: 1790 1791 (temp = rhs; [object setProperty: temp]; temp) 1792 1793 setter_argument is rhs in the first case, and temp in the second 1794 case. 1795 */ 1796 tree setter_argument; 1797 1798 /* s1, s2 and s3 are the tree statements that we need in the 1799 compound expression. */ 1800 tree s1, s2, s3, compound_expr; 1801 1802 if (TREE_SIDE_EFFECTS (rhs)) 1803 { 1804 tree bind; 1805 1806 /* Declare __objc_property_temp in a local bind. */ 1807 setter_argument = objc_create_temporary_var (TREE_TYPE (rhs), "__objc_property_temp"); 1808 DECL_SOURCE_LOCATION (setter_argument) = input_location; 1809 bind = build3 (BIND_EXPR, void_type_node, setter_argument, NULL, NULL); 1810 SET_EXPR_LOCATION (bind, input_location); 1811 TREE_SIDE_EFFECTS (bind) = 1; 1812 add_stmt (bind); 1813 1814 /* s1: x = rhs */ 1815 s1 = build_modify_expr (input_location, setter_argument, NULL_TREE, 1816 NOP_EXPR, 1817 input_location, rhs, NULL_TREE); 1818 SET_EXPR_LOCATION (s1, input_location); 1819 } 1820 else 1821 { 1822 /* No s1. */ 1823 setter_argument = rhs; 1824 s1 = NULL_TREE; 1825 } 1826 1827 /* Now build the compound statement. */ 1828 1829 /* s2: [object setProperty: x] */ 1830 s2 = objc_build_setter_call (lhs, setter_argument); 1831 1832 /* This happens if building the setter failed because the 1833 property is readonly. */ 1834 if (s2 == error_mark_node) 1835 return error_mark_node; 1836 1837 SET_EXPR_LOCATION (s2, input_location); 1838 1839 /* s3: x */ 1840 s3 = convert (TREE_TYPE (lhs), setter_argument); 1841 1842 /* Now build the compound statement (s1, s2, s3) or (s2, s3) as 1843 appropriate. */ 1844 if (s1) 1845 compound_expr = build_compound_expr (input_location, build_compound_expr (input_location, s1, s2), s3); 1846 else 1847 compound_expr = build_compound_expr (input_location, s2, s3); 1848 1849 /* Without this, with -Wall you get a 'valued computed is not 1850 used' every time there is a "object.property = x" where the 1851 value of the resulting MODIFY_EXPR is not used. That is 1852 correct (maybe a more sophisticated implementation could 1853 avoid generating the compound expression if not needed), but 1854 we need to turn it off. */ 1855 TREE_NO_WARNING (compound_expr) = 1; 1856 return compound_expr; 1857 } 1858 else 1859 return NULL_TREE; 1860 } 1861 1862 /* This hook is called by the frontend when one of the four unary 1863 expressions PREINCREMENT_EXPR, POSTINCREMENT_EXPR, 1864 PREDECREMENT_EXPR and POSTDECREMENT_EXPR is being built with an 1865 argument which is a PROPERTY_REF. For example, this happens if you have 1866 1867 object.count++; 1868 1869 where 'count' is a property. We need to use the 'getter' and 1870 'setter' for the property in an appropriate way to build the 1871 appropriate expression. 'code' is the code for the expression (one 1872 of the four mentioned above); 'argument' is the PROPERTY_REF, and 1873 'increment' is how much we need to add or subtract. */ 1874 tree 1875 objc_build_incr_expr_for_property_ref (location_t location, 1876 enum tree_code code, 1877 tree argument, tree increment) 1878 { 1879 /* Here are the expressions that we want to build: 1880 1881 For PREINCREMENT_EXPR / PREDECREMENT_EXPR: 1882 (temp = [object property] +/- increment, [object setProperty: temp], temp) 1883 1884 For POSTINCREMENT_EXPR / POSTECREMENT_EXPR: 1885 (temp = [object property], [object setProperty: temp +/- increment], temp) */ 1886 1887 tree temp_variable_decl, bind; 1888 /* s1, s2 and s3 are the tree statements that we need in the 1889 compound expression. */ 1890 tree s1, s2, s3, compound_expr; 1891 1892 /* Safety check. */ 1893 if (!argument || TREE_CODE (argument) != PROPERTY_REF) 1894 return error_mark_node; 1895 1896 /* Declare __objc_property_temp in a local bind. */ 1897 temp_variable_decl = objc_create_temporary_var (TREE_TYPE (argument), "__objc_property_temp"); 1898 DECL_SOURCE_LOCATION (temp_variable_decl) = location; 1899 bind = build3 (BIND_EXPR, void_type_node, temp_variable_decl, NULL, NULL); 1900 SET_EXPR_LOCATION (bind, location); 1901 TREE_SIDE_EFFECTS (bind) = 1; 1902 add_stmt (bind); 1903 1904 /* Now build the compound statement. */ 1905 1906 /* Note that the 'getter' is generated at gimplify time; at this 1907 time, we can simply put the property_ref (ie, argument) wherever 1908 we want the getter ultimately to be. */ 1909 1910 /* s1: __objc_property_temp = [object property] <+/- increment> */ 1911 switch (code) 1912 { 1913 case PREINCREMENT_EXPR: 1914 /* __objc_property_temp = [object property] + increment */ 1915 s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE, 1916 NOP_EXPR, 1917 location, build2 (PLUS_EXPR, TREE_TYPE (argument), 1918 argument, increment), NULL_TREE); 1919 break; 1920 case PREDECREMENT_EXPR: 1921 /* __objc_property_temp = [object property] - increment */ 1922 s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE, 1923 NOP_EXPR, 1924 location, build2 (MINUS_EXPR, TREE_TYPE (argument), 1925 argument, increment), NULL_TREE); 1926 break; 1927 case POSTINCREMENT_EXPR: 1928 case POSTDECREMENT_EXPR: 1929 /* __objc_property_temp = [object property] */ 1930 s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE, 1931 NOP_EXPR, 1932 location, argument, NULL_TREE); 1933 break; 1934 default: 1935 gcc_unreachable (); 1936 } 1937 1938 /* s2: [object setProperty: __objc_property_temp <+/- increment>] */ 1939 switch (code) 1940 { 1941 case PREINCREMENT_EXPR: 1942 case PREDECREMENT_EXPR: 1943 /* [object setProperty: __objc_property_temp] */ 1944 s2 = objc_build_setter_call (argument, temp_variable_decl); 1945 break; 1946 case POSTINCREMENT_EXPR: 1947 /* [object setProperty: __objc_property_temp + increment] */ 1948 s2 = objc_build_setter_call (argument, 1949 build2 (PLUS_EXPR, TREE_TYPE (argument), 1950 temp_variable_decl, increment)); 1951 break; 1952 case POSTDECREMENT_EXPR: 1953 /* [object setProperty: __objc_property_temp - increment] */ 1954 s2 = objc_build_setter_call (argument, 1955 build2 (MINUS_EXPR, TREE_TYPE (argument), 1956 temp_variable_decl, increment)); 1957 break; 1958 default: 1959 gcc_unreachable (); 1960 } 1961 1962 /* This happens if building the setter failed because the property 1963 is readonly. */ 1964 if (s2 == error_mark_node) 1965 return error_mark_node; 1966 1967 SET_EXPR_LOCATION (s2, location); 1968 1969 /* s3: __objc_property_temp */ 1970 s3 = convert (TREE_TYPE (argument), temp_variable_decl); 1971 1972 /* Now build the compound statement (s1, s2, s3) */ 1973 compound_expr = build_compound_expr (location, build_compound_expr (location, s1, s2), s3); 1974 1975 /* Prevent C++ from warning with -Wall that "right operand of comma 1976 operator has no effect". */ 1977 TREE_NO_WARNING (compound_expr) = 1; 1978 return compound_expr; 1979 } 1980 1981 tree 1982 objc_build_method_signature (bool is_class_method, tree rettype, tree selector, 1983 tree optparms, bool ellipsis) 1984 { 1985 if (is_class_method) 1986 return build_method_decl (CLASS_METHOD_DECL, rettype, selector, 1987 optparms, ellipsis); 1988 else 1989 return build_method_decl (INSTANCE_METHOD_DECL, rettype, selector, 1990 optparms, ellipsis); 1991 } 1992 1993 void 1994 objc_add_method_declaration (bool is_class_method, tree decl, tree attributes) 1995 { 1996 if (!objc_interface_context) 1997 { 1998 /* PS: At the moment, due to how the parser works, it should be 1999 impossible to get here. But it's good to have the check in 2000 case the parser changes. 2001 */ 2002 fatal_error ("method declaration not in @interface context"); 2003 } 2004 2005 if (flag_objc1_only && attributes) 2006 error_at (input_location, "method attributes are not available in Objective-C 1.0"); 2007 2008 objc_decl_method_attributes (&decl, attributes, 0); 2009 objc_add_method (objc_interface_context, 2010 decl, 2011 is_class_method, 2012 objc_method_optional_flag); 2013 } 2014 2015 /* Return 'true' if the method definition could be started, and 2016 'false' if not (because we are outside an @implementation context). 2017 EXPR is NULL or an expression that needs to be evaluated for the 2018 side effects of array size expressions in the parameters. 2019 */ 2020 bool 2021 objc_start_method_definition (bool is_class_method, tree decl, tree attributes, 2022 tree expr) 2023 { 2024 if (!objc_implementation_context) 2025 { 2026 error ("method definition not in @implementation context"); 2027 return false; 2028 } 2029 2030 if (decl != NULL_TREE && METHOD_SEL_NAME (decl) == error_mark_node) 2031 return false; 2032 2033 #ifndef OBJCPLUS 2034 /* Indicate no valid break/continue context by setting these variables 2035 to some non-null, non-label value. We'll notice and emit the proper 2036 error message in c_finish_bc_stmt. */ 2037 c_break_label = c_cont_label = size_zero_node; 2038 #endif 2039 2040 if (attributes) 2041 warning_at (input_location, 0, "method attributes can not be specified in @implementation context"); 2042 else 2043 objc_decl_method_attributes (&decl, attributes, 0); 2044 2045 objc_add_method (objc_implementation_context, 2046 decl, 2047 is_class_method, 2048 /* is optional */ false); 2049 start_method_def (decl, expr); 2050 return true; 2051 } 2052 2053 void 2054 objc_add_instance_variable (tree decl) 2055 { 2056 (void) add_instance_variable (objc_ivar_context, 2057 objc_ivar_visibility, 2058 decl); 2059 } 2060 2061 /* Construct a C struct with same name as KLASS, a base struct with tag 2062 SUPER_NAME (if any), and FIELDS indicated. */ 2063 2064 static tree 2065 objc_build_struct (tree klass, tree fields, tree super_name) 2066 { 2067 tree name = CLASS_NAME (klass); 2068 tree s = objc_start_struct (name); 2069 tree super = (super_name ? xref_tag (RECORD_TYPE, super_name) : NULL_TREE); 2070 tree t; 2071 VEC(tree,heap) *objc_info = NULL; 2072 int i; 2073 2074 if (super) 2075 { 2076 /* Prepend a packed variant of the base class into the layout. This 2077 is necessary to preserve ObjC ABI compatibility. */ 2078 tree base = build_decl (input_location, 2079 FIELD_DECL, NULL_TREE, super); 2080 tree field = TYPE_FIELDS (super); 2081 2082 while (field && DECL_CHAIN (field) 2083 && TREE_CODE (DECL_CHAIN (field)) == FIELD_DECL) 2084 field = DECL_CHAIN (field); 2085 2086 /* For ObjC ABI purposes, the "packed" size of a base class is 2087 the sum of the offset and the size (in bits) of the last field 2088 in the class. */ 2089 DECL_SIZE (base) 2090 = (field && TREE_CODE (field) == FIELD_DECL 2091 ? size_binop (PLUS_EXPR, 2092 size_binop (PLUS_EXPR, 2093 size_binop 2094 (MULT_EXPR, 2095 convert (bitsizetype, 2096 DECL_FIELD_OFFSET (field)), 2097 bitsize_int (BITS_PER_UNIT)), 2098 DECL_FIELD_BIT_OFFSET (field)), 2099 DECL_SIZE (field)) 2100 : bitsize_zero_node); 2101 DECL_SIZE_UNIT (base) 2102 = size_binop (FLOOR_DIV_EXPR, convert (sizetype, DECL_SIZE (base)), 2103 size_int (BITS_PER_UNIT)); 2104 DECL_ARTIFICIAL (base) = 1; 2105 DECL_ALIGN (base) = 1; 2106 DECL_FIELD_CONTEXT (base) = s; 2107 #ifdef OBJCPLUS 2108 DECL_FIELD_IS_BASE (base) = 1; 2109 2110 if (fields) 2111 TREE_NO_WARNING (fields) = 1; /* Suppress C++ ABI warnings -- we */ 2112 #endif /* are following the ObjC ABI here. */ 2113 DECL_CHAIN (base) = fields; 2114 fields = base; 2115 } 2116 2117 /* NB: Calling finish_struct() may cause type TYPE_OBJC_INFO 2118 information in all variants of this RECORD_TYPE to be destroyed 2119 (this is because the C frontend manipulates TYPE_LANG_SPECIFIC 2120 for something else and then will change all variants to use the 2121 same resulting TYPE_LANG_SPECIFIC, ignoring the fact that we use 2122 it for ObjC protocols and that such propagation will make all 2123 variants use the same objc_info), but it is therein that we store 2124 protocol conformance info (e.g., 'NSObject <MyProtocol>'). 2125 Hence, we must save the ObjC-specific information before calling 2126 finish_struct(), and then reinstate it afterwards. */ 2127 2128 for (t = TYPE_MAIN_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t)) 2129 { 2130 INIT_TYPE_OBJC_INFO (t); 2131 VEC_safe_push (tree, heap, objc_info, TYPE_OBJC_INFO (t)); 2132 } 2133 2134 s = objc_finish_struct (s, fields); 2135 2136 for (i = 0, t = TYPE_MAIN_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t), i++) 2137 { 2138 /* We now want to restore the different TYPE_OBJC_INFO, but we 2139 have the additional problem that the C frontend doesn't just 2140 copy TYPE_LANG_SPECIFIC from one variant to the other; it 2141 actually makes all of them the *same* TYPE_LANG_SPECIFIC. As 2142 we need a different TYPE_OBJC_INFO for each (and 2143 TYPE_OBJC_INFO is a field in TYPE_LANG_SPECIFIC), we need to 2144 make a copy of each TYPE_LANG_SPECIFIC before we modify 2145 TYPE_OBJC_INFO. */ 2146 if (TYPE_LANG_SPECIFIC (t)) 2147 { 2148 /* Create a copy of TYPE_LANG_SPECIFIC. */ 2149 struct lang_type *old_lang_type = TYPE_LANG_SPECIFIC (t); 2150 ALLOC_OBJC_TYPE_LANG_SPECIFIC (t); 2151 memcpy (TYPE_LANG_SPECIFIC (t), old_lang_type, 2152 SIZEOF_OBJC_TYPE_LANG_SPECIFIC); 2153 } 2154 else 2155 { 2156 /* Just create a new one. */ 2157 ALLOC_OBJC_TYPE_LANG_SPECIFIC (t); 2158 } 2159 /* Replace TYPE_OBJC_INFO with the saved one. This restores any 2160 protocol information that may have been associated with the 2161 type. */ 2162 TYPE_OBJC_INFO (t) = VEC_index (tree, objc_info, i); 2163 /* Replace the IDENTIFIER_NODE with an actual @interface now 2164 that we have it. */ 2165 TYPE_OBJC_INTERFACE (t) = klass; 2166 } 2167 VEC_free (tree, heap, objc_info); 2168 2169 /* Use TYPE_BINFO structures to point at the super class, if any. */ 2170 objc_xref_basetypes (s, super); 2171 2172 /* Mark this struct as a class template. */ 2173 CLASS_STATIC_TEMPLATE (klass) = s; 2174 2175 return s; 2176 } 2177 2178 /* Mark DECL as being 'volatile' for purposes of Darwin 2179 _setjmp()/_longjmp() exception handling. Called from 2180 objc_mark_locals_volatile(). */ 2181 void 2182 objc_volatilize_decl (tree decl) 2183 { 2184 /* Do not mess with variables that are 'static' or (already) 2185 'volatile'. */ 2186 if (!TREE_THIS_VOLATILE (decl) && !TREE_STATIC (decl) 2187 && (TREE_CODE (decl) == VAR_DECL 2188 || TREE_CODE (decl) == PARM_DECL)) 2189 { 2190 if (local_variables_to_volatilize == NULL) 2191 local_variables_to_volatilize = VEC_alloc (tree, gc, 8); 2192 2193 VEC_safe_push (tree, gc, local_variables_to_volatilize, decl); 2194 } 2195 } 2196 2197 /* Called when parsing of a function completes; if any local variables 2198 in the function were marked as variables to volatilize, change them 2199 to volatile. We do this at the end of the function when the 2200 warnings about discarding 'volatile' have already been produced. 2201 We are making the variables as volatile just to force the compiler 2202 to preserve them between setjmp/longjmp, but we don't want warnings 2203 for them as they aren't really volatile. */ 2204 void 2205 objc_finish_function (void) 2206 { 2207 /* If there are any local variables to volatilize, volatilize them. */ 2208 if (local_variables_to_volatilize) 2209 { 2210 int i; 2211 tree decl; 2212 FOR_EACH_VEC_ELT (tree, local_variables_to_volatilize, i, decl) 2213 { 2214 tree t = TREE_TYPE (decl); 2215 2216 t = build_qualified_type (t, TYPE_QUALS (t) | TYPE_QUAL_VOLATILE); 2217 TREE_TYPE (decl) = t; 2218 TREE_THIS_VOLATILE (decl) = 1; 2219 TREE_SIDE_EFFECTS (decl) = 1; 2220 DECL_REGISTER (decl) = 0; 2221 #ifndef OBJCPLUS 2222 C_DECL_REGISTER (decl) = 0; 2223 #endif 2224 } 2225 2226 /* Now we delete the vector. This sets it to NULL as well. */ 2227 VEC_free (tree, gc, local_variables_to_volatilize); 2228 } 2229 } 2230 2231 /* Check if protocol PROTO is adopted (directly or indirectly) by class CLS 2232 (including its categories and superclasses) or by object type TYP. 2233 Issue a warning if PROTO is not adopted anywhere and WARN is set. */ 2234 2235 static bool 2236 objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn) 2237 { 2238 bool class_type = (cls != NULL_TREE); 2239 2240 while (cls) 2241 { 2242 tree c; 2243 2244 /* Check protocols adopted by the class and its categories. */ 2245 for (c = cls; c; c = CLASS_CATEGORY_LIST (c)) 2246 { 2247 if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c), proto)) 2248 return true; 2249 } 2250 2251 /* Repeat for superclasses. */ 2252 cls = lookup_interface (CLASS_SUPER_NAME (cls)); 2253 } 2254 2255 /* Check for any protocols attached directly to the object type. */ 2256 if (TYPE_HAS_OBJC_INFO (typ)) 2257 { 2258 if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ), proto)) 2259 return true; 2260 } 2261 2262 if (warn) 2263 { 2264 *errbuf = 0; 2265 gen_type_name_0 (class_type ? typ : TYPE_POINTER_TO (typ)); 2266 /* NB: Types 'id' and 'Class' cannot reasonably be described as 2267 "implementing" a given protocol, since they do not have an 2268 implementation. */ 2269 if (class_type) 2270 warning (0, "class %qs does not implement the %qE protocol", 2271 identifier_to_locale (errbuf), PROTOCOL_NAME (proto)); 2272 else 2273 warning (0, "type %qs does not conform to the %qE protocol", 2274 identifier_to_locale (errbuf), PROTOCOL_NAME (proto)); 2275 } 2276 2277 return false; 2278 } 2279 2280 /* Check if class RCLS and instance struct type RTYP conform to at least the 2281 same protocols that LCLS and LTYP conform to. */ 2282 2283 static bool 2284 objc_compare_protocols (tree lcls, tree ltyp, tree rcls, tree rtyp, bool warn) 2285 { 2286 tree p; 2287 bool have_lproto = false; 2288 2289 while (lcls) 2290 { 2291 /* NB: We do _not_ look at categories defined for LCLS; these may or 2292 may not get loaded in, and therefore it is unreasonable to require 2293 that RCLS/RTYP must implement any of their protocols. */ 2294 for (p = CLASS_PROTOCOL_LIST (lcls); p; p = TREE_CHAIN (p)) 2295 { 2296 have_lproto = true; 2297 2298 if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn)) 2299 return warn; 2300 } 2301 2302 /* Repeat for superclasses. */ 2303 lcls = lookup_interface (CLASS_SUPER_NAME (lcls)); 2304 } 2305 2306 /* Check for any protocols attached directly to the object type. */ 2307 if (TYPE_HAS_OBJC_INFO (ltyp)) 2308 { 2309 for (p = TYPE_OBJC_PROTOCOL_LIST (ltyp); p; p = TREE_CHAIN (p)) 2310 { 2311 have_lproto = true; 2312 2313 if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn)) 2314 return warn; 2315 } 2316 } 2317 2318 /* NB: If LTYP and LCLS have no protocols to search for, return 'true' 2319 vacuously, _unless_ RTYP is a protocol-qualified 'id'. We can get 2320 away with simply checking for 'id' or 'Class' (!RCLS), since this 2321 routine will not get called in other cases. */ 2322 return have_lproto || (rcls != NULL_TREE); 2323 } 2324 2325 /* Given two types TYPE1 and TYPE2, return their least common ancestor. 2326 Both TYPE1 and TYPE2 must be pointers, and already determined to be 2327 compatible by objc_compare_types() below. */ 2328 2329 tree 2330 objc_common_type (tree type1, tree type2) 2331 { 2332 tree inner1 = TREE_TYPE (type1), inner2 = TREE_TYPE (type2); 2333 2334 while (POINTER_TYPE_P (inner1)) 2335 { 2336 inner1 = TREE_TYPE (inner1); 2337 inner2 = TREE_TYPE (inner2); 2338 } 2339 2340 /* If one type is derived from another, return the base type. */ 2341 if (DERIVED_FROM_P (inner1, inner2)) 2342 return type1; 2343 else if (DERIVED_FROM_P (inner2, inner1)) 2344 return type2; 2345 2346 /* If both types are 'Class', return 'Class'. */ 2347 if (objc_is_class_id (inner1) && objc_is_class_id (inner2)) 2348 return objc_class_type; 2349 2350 /* Otherwise, return 'id'. */ 2351 return objc_object_type; 2352 } 2353 2354 /* Determine if it is permissible to assign (if ARGNO is greater than -3) 2355 an instance of RTYP to an instance of LTYP or to compare the two 2356 (if ARGNO is equal to -3), per ObjC type system rules. Before 2357 returning 'true', this routine may issue warnings related to, e.g., 2358 protocol conformance. When returning 'false', the routine must 2359 produce absolutely no warnings; the C or C++ front-end will do so 2360 instead, if needed. If either LTYP or RTYP is not an Objective-C 2361 type, the routine must return 'false'. 2362 2363 The ARGNO parameter is encoded as follows: 2364 >= 1 Parameter number (CALLEE contains function being called); 2365 0 Return value; 2366 -1 Assignment; 2367 -2 Initialization; 2368 -3 Comparison (LTYP and RTYP may match in either direction); 2369 -4 Silent comparison (for C++ overload resolution); 2370 -5 Silent "specialization" comparison for RTYP to be a "specialization" 2371 of LTYP (a specialization means that RTYP is LTYP plus some constraints, 2372 so that each object of type RTYP is also of type LTYP). This is used 2373 when comparing property types. */ 2374 2375 bool 2376 objc_compare_types (tree ltyp, tree rtyp, int argno, tree callee) 2377 { 2378 tree lcls, rcls, lproto, rproto; 2379 bool pointers_compatible; 2380 2381 /* We must be dealing with pointer types */ 2382 if (!POINTER_TYPE_P (ltyp) || !POINTER_TYPE_P (rtyp)) 2383 return false; 2384 2385 do 2386 { 2387 ltyp = TREE_TYPE (ltyp); /* Remove indirections. */ 2388 rtyp = TREE_TYPE (rtyp); 2389 } 2390 while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp)); 2391 2392 /* We must also handle function pointers, since ObjC is a bit more 2393 lenient than C or C++ on this. */ 2394 if (TREE_CODE (ltyp) == FUNCTION_TYPE && TREE_CODE (rtyp) == FUNCTION_TYPE) 2395 { 2396 function_args_iterator liter, riter; 2397 2398 /* Return types must be covariant. */ 2399 if (!comptypes (TREE_TYPE (ltyp), TREE_TYPE (rtyp)) 2400 && !objc_compare_types (TREE_TYPE (ltyp), TREE_TYPE (rtyp), 2401 argno, callee)) 2402 return false; 2403 2404 /* Argument types must be contravariant. */ 2405 function_args_iter_init (&liter, ltyp); 2406 function_args_iter_init (&riter, rtyp); 2407 2408 while (1) 2409 { 2410 ltyp = function_args_iter_cond (&liter); 2411 rtyp = function_args_iter_cond (&riter); 2412 2413 /* If we've exhaused both lists simulateously, we're done. */ 2414 if (ltyp == NULL_TREE && rtyp == NULL_TREE) 2415 break; 2416 2417 /* If one list is shorter than the other, they fail to match. */ 2418 if (ltyp == NULL_TREE || rtyp == NULL_TREE) 2419 return false; 2420 2421 if (!comptypes (rtyp, ltyp) 2422 && !objc_compare_types (rtyp, ltyp, argno, callee)) 2423 return false; 2424 2425 function_args_iter_next (&liter); 2426 function_args_iter_next (&riter); 2427 } 2428 2429 return true; 2430 } 2431 2432 /* Past this point, we are only interested in ObjC class instances, 2433 or 'id' or 'Class'. */ 2434 if (TREE_CODE (ltyp) != RECORD_TYPE || TREE_CODE (rtyp) != RECORD_TYPE) 2435 return false; 2436 2437 if (!objc_is_object_id (ltyp) && !objc_is_class_id (ltyp) 2438 && !TYPE_HAS_OBJC_INFO (ltyp)) 2439 return false; 2440 2441 if (!objc_is_object_id (rtyp) && !objc_is_class_id (rtyp) 2442 && !TYPE_HAS_OBJC_INFO (rtyp)) 2443 return false; 2444 2445 /* Past this point, we are committed to returning 'true' to the caller 2446 (unless performing a silent comparison; see below). However, we can 2447 still warn about type and/or protocol mismatches. */ 2448 2449 if (TYPE_HAS_OBJC_INFO (ltyp)) 2450 { 2451 lcls = TYPE_OBJC_INTERFACE (ltyp); 2452 lproto = TYPE_OBJC_PROTOCOL_LIST (ltyp); 2453 } 2454 else 2455 lcls = lproto = NULL_TREE; 2456 2457 if (TYPE_HAS_OBJC_INFO (rtyp)) 2458 { 2459 rcls = TYPE_OBJC_INTERFACE (rtyp); 2460 rproto = TYPE_OBJC_PROTOCOL_LIST (rtyp); 2461 } 2462 else 2463 rcls = rproto = NULL_TREE; 2464 2465 /* If we could not find an @interface declaration, we must have 2466 only seen a @class declaration; for purposes of type comparison, 2467 treat it as a stand-alone (root) class. */ 2468 2469 if (lcls && TREE_CODE (lcls) == IDENTIFIER_NODE) 2470 lcls = NULL_TREE; 2471 2472 if (rcls && TREE_CODE (rcls) == IDENTIFIER_NODE) 2473 rcls = NULL_TREE; 2474 2475 /* If either type is an unqualified 'id', we're done. This is because 2476 an 'id' can be assigned to or from any type with no warnings. */ 2477 if (argno != -5) 2478 { 2479 if ((!lproto && objc_is_object_id (ltyp)) 2480 || (!rproto && objc_is_object_id (rtyp))) 2481 return true; 2482 } 2483 else 2484 { 2485 /* For property checks, though, an 'id' is considered the most 2486 general type of object, hence if you try to specialize an 2487 'NSArray *' (ltyp) property with an 'id' (rtyp) one, we need 2488 to warn. */ 2489 if (!lproto && objc_is_object_id (ltyp)) 2490 return true; 2491 } 2492 2493 pointers_compatible = (TYPE_MAIN_VARIANT (ltyp) == TYPE_MAIN_VARIANT (rtyp)); 2494 2495 /* If the underlying types are the same, and at most one of them has 2496 a protocol list, we do not need to issue any diagnostics. */ 2497 if (pointers_compatible && (!lproto || !rproto)) 2498 return true; 2499 2500 /* If exactly one of the types is 'Class', issue a diagnostic; any 2501 exceptions of this rule have already been handled. */ 2502 if (objc_is_class_id (ltyp) ^ objc_is_class_id (rtyp)) 2503 pointers_compatible = false; 2504 /* Otherwise, check for inheritance relations. */ 2505 else 2506 { 2507 if (!pointers_compatible) 2508 { 2509 /* Again, if any of the two is an 'id', we're satisfied, 2510 unless we're comparing properties, in which case only an 2511 'id' on the left-hand side (old property) is good 2512 enough. */ 2513 if (argno != -5) 2514 pointers_compatible 2515 = (objc_is_object_id (ltyp) || objc_is_object_id (rtyp)); 2516 else 2517 pointers_compatible = objc_is_object_id (ltyp); 2518 } 2519 2520 if (!pointers_compatible) 2521 pointers_compatible = DERIVED_FROM_P (ltyp, rtyp); 2522 2523 if (!pointers_compatible && (argno == -3 || argno == -4)) 2524 pointers_compatible = DERIVED_FROM_P (rtyp, ltyp); 2525 } 2526 2527 /* If the pointers match modulo protocols, check for protocol conformance 2528 mismatches. */ 2529 if (pointers_compatible) 2530 { 2531 pointers_compatible = objc_compare_protocols (lcls, ltyp, rcls, rtyp, 2532 argno != -3); 2533 2534 if (!pointers_compatible && argno == -3) 2535 pointers_compatible = objc_compare_protocols (rcls, rtyp, lcls, ltyp, 2536 argno != -3); 2537 } 2538 2539 if (!pointers_compatible) 2540 { 2541 /* The two pointers are not exactly compatible. Issue a warning, unless 2542 we are performing a silent comparison, in which case return 'false' 2543 instead. */ 2544 /* NB: For the time being, we shall make our warnings look like their 2545 C counterparts. In the future, we may wish to make them more 2546 ObjC-specific. */ 2547 switch (argno) 2548 { 2549 case -5: 2550 case -4: 2551 return false; 2552 2553 case -3: 2554 warning (0, "comparison of distinct Objective-C types lacks a cast"); 2555 break; 2556 2557 case -2: 2558 warning (0, "initialization from distinct Objective-C type"); 2559 break; 2560 2561 case -1: 2562 warning (0, "assignment from distinct Objective-C type"); 2563 break; 2564 2565 case 0: 2566 warning (0, "distinct Objective-C type in return"); 2567 break; 2568 2569 default: 2570 warning (0, "passing argument %d of %qE from distinct " 2571 "Objective-C type", argno, callee); 2572 break; 2573 } 2574 } 2575 2576 return true; 2577 } 2578 2579 /* This routine is similar to objc_compare_types except that function-pointers are 2580 excluded. This is because, caller assumes that common types are of (id, Object*) 2581 variety and calls objc_common_type to obtain a common type. There is no commonolty 2582 between two function-pointers in this regard. */ 2583 2584 bool 2585 objc_have_common_type (tree ltyp, tree rtyp, int argno, tree callee) 2586 { 2587 if (objc_compare_types (ltyp, rtyp, argno, callee)) 2588 { 2589 /* exclude function-pointer types. */ 2590 do 2591 { 2592 ltyp = TREE_TYPE (ltyp); /* Remove indirections. */ 2593 rtyp = TREE_TYPE (rtyp); 2594 } 2595 while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp)); 2596 return !(TREE_CODE (ltyp) == FUNCTION_TYPE && TREE_CODE (rtyp) == FUNCTION_TYPE); 2597 } 2598 return false; 2599 } 2600 2601 #ifndef OBJCPLUS 2602 /* Determine if CHILD is derived from PARENT. The routine assumes that 2603 both parameters are RECORD_TYPEs, and is non-reflexive. */ 2604 2605 static bool 2606 objc_derived_from_p (tree parent, tree child) 2607 { 2608 parent = TYPE_MAIN_VARIANT (parent); 2609 2610 for (child = TYPE_MAIN_VARIANT (child); 2611 TYPE_BINFO (child) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child));) 2612 { 2613 child = TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO 2614 (TYPE_BINFO (child), 2615 0))); 2616 2617 if (child == parent) 2618 return true; 2619 } 2620 2621 return false; 2622 } 2623 #endif 2624 2625 tree 2626 objc_build_component_ref (tree datum, tree component) 2627 { 2628 /* If COMPONENT is NULL, the caller is referring to the anonymous 2629 base class field. */ 2630 if (!component) 2631 { 2632 tree base = TYPE_FIELDS (TREE_TYPE (datum)); 2633 2634 return build3 (COMPONENT_REF, TREE_TYPE (base), datum, base, NULL_TREE); 2635 } 2636 2637 /* The 'build_component_ref' routine has been removed from the C++ 2638 front-end, but 'finish_class_member_access_expr' seems to be 2639 a worthy substitute. */ 2640 #ifdef OBJCPLUS 2641 return finish_class_member_access_expr (datum, component, false, 2642 tf_warning_or_error); 2643 #else 2644 return build_component_ref (input_location, datum, component); 2645 #endif 2646 } 2647 2648 /* Recursively copy inheritance information rooted at BINFO. To do this, 2649 we emulate the song and dance performed by cp/tree.c:copy_binfo(). */ 2650 2651 static tree 2652 objc_copy_binfo (tree binfo) 2653 { 2654 tree btype = BINFO_TYPE (binfo); 2655 tree binfo2 = make_tree_binfo (BINFO_N_BASE_BINFOS (binfo)); 2656 tree base_binfo; 2657 int ix; 2658 2659 BINFO_TYPE (binfo2) = btype; 2660 BINFO_OFFSET (binfo2) = BINFO_OFFSET (binfo); 2661 BINFO_BASE_ACCESSES (binfo2) = BINFO_BASE_ACCESSES (binfo); 2662 2663 /* Recursively copy base binfos of BINFO. */ 2664 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++) 2665 { 2666 tree base_binfo2 = objc_copy_binfo (base_binfo); 2667 2668 BINFO_INHERITANCE_CHAIN (base_binfo2) = binfo2; 2669 BINFO_BASE_APPEND (binfo2, base_binfo2); 2670 } 2671 2672 return binfo2; 2673 } 2674 2675 /* Record superclass information provided in BASETYPE for ObjC class REF. 2676 This is loosely based on cp/decl.c:xref_basetypes(). */ 2677 2678 static void 2679 objc_xref_basetypes (tree ref, tree basetype) 2680 { 2681 tree binfo = make_tree_binfo (basetype ? 1 : 0); 2682 2683 TYPE_BINFO (ref) = binfo; 2684 BINFO_OFFSET (binfo) = size_zero_node; 2685 BINFO_TYPE (binfo) = ref; 2686 2687 if (basetype) 2688 { 2689 tree base_binfo = objc_copy_binfo (TYPE_BINFO (basetype)); 2690 2691 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo; 2692 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, 1); 2693 BINFO_BASE_APPEND (binfo, base_binfo); 2694 BINFO_BASE_ACCESS_APPEND (binfo, access_public_node); 2695 } 2696 } 2697 2698 /* Called from finish_decl. */ 2699 2700 void 2701 objc_check_decl (tree decl) 2702 { 2703 tree type = TREE_TYPE (decl); 2704 2705 if (TREE_CODE (type) != RECORD_TYPE) 2706 return; 2707 if (OBJC_TYPE_NAME (type) && (type = objc_is_class_name (OBJC_TYPE_NAME (type)))) 2708 error ("statically allocated instance of Objective-C class %qE", 2709 type); 2710 } 2711 2712 void 2713 objc_check_global_decl (tree decl) 2714 { 2715 tree id = DECL_NAME (decl); 2716 if (objc_is_class_name (id) && global_bindings_p()) 2717 error ("redeclaration of Objective-C class %qs", IDENTIFIER_POINTER (id)); 2718 } 2719 2720 /* Construct a PROTOCOLS-qualified variant of INTERFACE, where 2721 INTERFACE may either name an Objective-C class, or refer to the 2722 special 'id' or 'Class' types. If INTERFACE is not a valid ObjC 2723 type, just return it unchanged. This function is often called when 2724 PROTOCOLS is NULL_TREE, in which case we simply look up the 2725 appropriate INTERFACE. */ 2726 2727 tree 2728 objc_get_protocol_qualified_type (tree interface, tree protocols) 2729 { 2730 /* If INTERFACE is not provided, default to 'id'. */ 2731 tree type = (interface ? objc_is_id (interface) : objc_object_type); 2732 bool is_ptr = (type != NULL_TREE); 2733 2734 if (!is_ptr) 2735 { 2736 type = objc_is_class_name (interface); 2737 2738 if (type) 2739 { 2740 /* If looking at a typedef, retrieve the precise type it 2741 describes. */ 2742 if (TREE_CODE (interface) == IDENTIFIER_NODE) 2743 interface = identifier_global_value (interface); 2744 2745 type = ((interface && TREE_CODE (interface) == TYPE_DECL 2746 && DECL_ORIGINAL_TYPE (interface)) 2747 ? DECL_ORIGINAL_TYPE (interface) 2748 : xref_tag (RECORD_TYPE, type)); 2749 } 2750 else 2751 { 2752 /* This case happens when we are given an 'interface' which 2753 is not a valid class name. For example if a typedef was 2754 used, and 'interface' really is the identifier of the 2755 typedef, but when you resolve it you don't get an 2756 Objective-C class, but something else, such as 'int'. 2757 This is an error; protocols make no sense unless you use 2758 them with Objective-C objects. */ 2759 error_at (input_location, "only Objective-C object types can be qualified with a protocol"); 2760 2761 /* Try to recover. Ignore the invalid class name, and treat 2762 the object as an 'id' to silence further warnings about 2763 the class. */ 2764 type = objc_object_type; 2765 is_ptr = true; 2766 } 2767 } 2768 2769 if (protocols) 2770 { 2771 type = build_variant_type_copy (type); 2772 2773 /* For pointers (i.e., 'id' or 'Class'), attach the protocol(s) 2774 to the pointee. */ 2775 if (is_ptr) 2776 { 2777 tree orig_pointee_type = TREE_TYPE (type); 2778 TREE_TYPE (type) = build_variant_type_copy (orig_pointee_type); 2779 2780 /* Set up the canonical type information. */ 2781 TYPE_CANONICAL (type) 2782 = TYPE_CANONICAL (TYPE_POINTER_TO (orig_pointee_type)); 2783 2784 TYPE_POINTER_TO (TREE_TYPE (type)) = type; 2785 type = TREE_TYPE (type); 2786 } 2787 2788 /* Look up protocols and install in lang specific list. */ 2789 DUP_TYPE_OBJC_INFO (type, TYPE_MAIN_VARIANT (type)); 2790 TYPE_OBJC_PROTOCOL_LIST (type) = lookup_and_install_protocols 2791 (protocols, /* definition_required */ false); 2792 2793 /* For RECORD_TYPEs, point to the @interface; for 'id' and 'Class', 2794 return the pointer to the new pointee variant. */ 2795 if (is_ptr) 2796 type = TYPE_POINTER_TO (type); 2797 else 2798 TYPE_OBJC_INTERFACE (type) 2799 = TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type)); 2800 } 2801 2802 return type; 2803 } 2804 2805 /* Check for circular dependencies in protocols. The arguments are 2806 PROTO, the protocol to check, and LIST, a list of protocol it 2807 conforms to. */ 2808 2809 static void 2810 check_protocol_recursively (tree proto, tree list) 2811 { 2812 tree p; 2813 2814 for (p = list; p; p = TREE_CHAIN (p)) 2815 { 2816 tree pp = TREE_VALUE (p); 2817 2818 if (TREE_CODE (pp) == IDENTIFIER_NODE) 2819 pp = lookup_protocol (pp, /* warn if deprecated */ false, 2820 /* definition_required */ false); 2821 2822 if (pp == proto) 2823 fatal_error ("protocol %qE has circular dependency", 2824 PROTOCOL_NAME (pp)); 2825 if (pp) 2826 check_protocol_recursively (proto, PROTOCOL_LIST (pp)); 2827 } 2828 } 2829 2830 /* Look up PROTOCOLS, and return a list of those that are found. If 2831 none are found, return NULL. Note that this function will emit a 2832 warning if a protocol is found and is deprecated. If 2833 'definition_required', then warn if the protocol is found but is 2834 not defined (ie, if we only saw a forward-declaration of the 2835 protocol (as in "@protocol NSObject;") not a real definition with 2836 the list of methods). */ 2837 static tree 2838 lookup_and_install_protocols (tree protocols, bool definition_required) 2839 { 2840 tree proto; 2841 tree return_value = NULL_TREE; 2842 2843 if (protocols == error_mark_node) 2844 return NULL; 2845 2846 for (proto = protocols; proto; proto = TREE_CHAIN (proto)) 2847 { 2848 tree ident = TREE_VALUE (proto); 2849 tree p = lookup_protocol (ident, /* warn_if_deprecated */ true, 2850 definition_required); 2851 2852 if (p) 2853 return_value = chainon (return_value, 2854 build_tree_list (NULL_TREE, p)); 2855 else if (ident != error_mark_node) 2856 error ("cannot find protocol declaration for %qE", 2857 ident); 2858 } 2859 2860 return return_value; 2861 } 2862 2863 static void 2864 build_common_objc_exception_stuff (void) 2865 { 2866 tree noreturn_list, nothrow_list, temp_type; 2867 2868 noreturn_list = tree_cons (get_identifier ("noreturn"), NULL, NULL); 2869 nothrow_list = tree_cons (get_identifier ("nothrow"), NULL, NULL); 2870 2871 /* void objc_exception_throw(id) __attribute__((noreturn)); */ 2872 /* void objc_sync_enter(id); */ 2873 /* void objc_sync_exit(id); */ 2874 temp_type = build_function_type_list (void_type_node, 2875 objc_object_type, 2876 NULL_TREE); 2877 objc_exception_throw_decl 2878 = add_builtin_function (TAG_EXCEPTIONTHROW, temp_type, 0, NOT_BUILT_IN, NULL, 2879 noreturn_list); 2880 /* Make sure that objc_exception_throw (id) claims that it may throw an 2881 exception. */ 2882 TREE_NOTHROW (objc_exception_throw_decl) = 0; 2883 2884 objc_sync_enter_decl 2885 = add_builtin_function (TAG_SYNCENTER, temp_type, 0, NOT_BUILT_IN, 2886 NULL, nothrow_list); 2887 2888 objc_sync_exit_decl 2889 = add_builtin_function (TAG_SYNCEXIT, temp_type, 0, NOT_BUILT_IN, 2890 NULL, nothrow_list); 2891 } 2892 2893 /* Purpose: "play" parser, creating/installing representations 2894 of the declarations that are required by Objective-C. 2895 2896 Model: 2897 2898 type_spec--------->sc_spec 2899 (tree_list) (tree_list) 2900 | | 2901 | | 2902 identifier_node identifier_node */ 2903 2904 static void 2905 synth_module_prologue (void) 2906 { 2907 tree type; 2908 enum debug_info_type save_write_symbols = write_symbols; 2909 const struct gcc_debug_hooks *const save_hooks = debug_hooks; 2910 2911 /* Suppress outputting debug symbols, because 2912 dbxout_init hasn't been called yet. */ 2913 write_symbols = NO_DEBUG; 2914 debug_hooks = &do_nothing_debug_hooks; 2915 2916 #ifdef OBJCPLUS 2917 push_lang_context (lang_name_c); /* extern "C" */ 2918 #endif 2919 2920 /* The following are also defined in <objc/objc.h> and friends. */ 2921 2922 objc_object_id = get_identifier (TAG_OBJECT); 2923 objc_class_id = get_identifier (TAG_CLASS); 2924 2925 objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id); 2926 objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id); 2927 2928 objc_object_type = build_pointer_type (objc_object_reference); 2929 objc_class_type = build_pointer_type (objc_class_reference); 2930 2931 objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME); 2932 objc_class_name = get_identifier (CLASS_TYPEDEF_NAME); 2933 2934 /* Declare the 'id' and 'Class' typedefs. */ 2935 type = lang_hooks.decls.pushdecl (build_decl (input_location, 2936 TYPE_DECL, 2937 objc_object_name, 2938 objc_object_type)); 2939 TREE_NO_WARNING (type) = 1; 2940 2941 type = lang_hooks.decls.pushdecl (build_decl (input_location, 2942 TYPE_DECL, 2943 objc_class_name, 2944 objc_class_type)); 2945 TREE_NO_WARNING (type) = 1; 2946 2947 /* Forward-declare '@interface Protocol'. */ 2948 type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME); 2949 objc_declare_class (type); 2950 objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE, type)); 2951 2952 /* Declare receiver type used for dispatching messages to 'super'. */ 2953 /* `struct objc_super *' */ 2954 objc_super_type = build_pointer_type (xref_tag (RECORD_TYPE, 2955 get_identifier (TAG_SUPER))); 2956 2957 /* Declare pointers to method and ivar lists. */ 2958 objc_method_list_ptr = build_pointer_type 2959 (xref_tag (RECORD_TYPE, 2960 get_identifier (UTAG_METHOD_LIST))); 2961 objc_method_proto_list_ptr 2962 = build_pointer_type (xref_tag (RECORD_TYPE, 2963 get_identifier (UTAG_METHOD_PROTOTYPE_LIST))); 2964 objc_ivar_list_ptr = build_pointer_type 2965 (xref_tag (RECORD_TYPE, 2966 get_identifier (UTAG_IVAR_LIST))); 2967 2968 build_common_objc_exception_stuff (); 2969 2970 /* Set-up runtime-specific templates, message and exception stuff. */ 2971 (*runtime.initialize) (); 2972 2973 /* Declare objc_getProperty, object_setProperty and other property 2974 accessor helpers. */ 2975 build_common_objc_property_accessor_helpers (); 2976 2977 /* Forward declare constant_string_id and constant_string_type. */ 2978 if (!constant_string_class_name) 2979 constant_string_class_name = runtime.default_constant_string_class_name; 2980 constant_string_id = get_identifier (constant_string_class_name); 2981 objc_declare_class (constant_string_id); 2982 2983 /* Pre-build the following entities - for speed/convenience. */ 2984 self_id = get_identifier ("self"); 2985 ucmd_id = get_identifier ("_cmd"); 2986 2987 /* Declare struct _objc_fast_enumeration_state { ... }; */ 2988 build_fast_enumeration_state_template (); 2989 2990 /* void objc_enumeration_mutation (id) */ 2991 type = build_function_type_list (void_type_node, 2992 objc_object_type, NULL_TREE); 2993 objc_enumeration_mutation_decl 2994 = add_builtin_function (TAG_ENUMERATION_MUTATION, type, 0, NOT_BUILT_IN, 2995 NULL, NULL_TREE); 2996 TREE_NOTHROW (objc_enumeration_mutation_decl) = 0; 2997 2998 #ifdef OBJCPLUS 2999 pop_lang_context (); 3000 #endif 3001 3002 write_symbols = save_write_symbols; 3003 debug_hooks = save_hooks; 3004 } 3005 3006 /* --- const strings --- */ 3007 3008 /* Ensure that the ivar list for NSConstantString/NXConstantString 3009 (or whatever was specified via `-fconstant-string-class') 3010 contains fields at least as large as the following three, so that 3011 the runtime can stomp on them with confidence: 3012 3013 struct STRING_OBJECT_CLASS_NAME 3014 { 3015 Object isa; 3016 char *cString; 3017 unsigned int length; 3018 }; */ 3019 3020 static int 3021 check_string_class_template (void) 3022 { 3023 tree field_decl = objc_get_class_ivars (constant_string_id); 3024 3025 #define AT_LEAST_AS_LARGE_AS(F, T) \ 3026 (F && TREE_CODE (F) == FIELD_DECL \ 3027 && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \ 3028 >= TREE_INT_CST_LOW (TYPE_SIZE (T)))) 3029 3030 if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node)) 3031 return 0; 3032 3033 field_decl = DECL_CHAIN (field_decl); 3034 if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node)) 3035 return 0; 3036 3037 field_decl = DECL_CHAIN (field_decl); 3038 return AT_LEAST_AS_LARGE_AS (field_decl, unsigned_type_node); 3039 3040 #undef AT_LEAST_AS_LARGE_AS 3041 } 3042 3043 /* Avoid calling `check_string_class_template ()' more than once. */ 3044 static GTY(()) int string_layout_checked; 3045 3046 /* Construct an internal string layout to be used as a template for 3047 creating NSConstantString/NXConstantString instances. */ 3048 3049 static tree 3050 objc_build_internal_const_str_type (void) 3051 { 3052 tree type = (*lang_hooks.types.make_type) (RECORD_TYPE); 3053 tree fields = build_decl (input_location, 3054 FIELD_DECL, NULL_TREE, ptr_type_node); 3055 tree field = build_decl (input_location, 3056 FIELD_DECL, NULL_TREE, ptr_type_node); 3057 3058 DECL_CHAIN (field) = fields; fields = field; 3059 field = build_decl (input_location, 3060 FIELD_DECL, NULL_TREE, unsigned_type_node); 3061 DECL_CHAIN (field) = fields; fields = field; 3062 /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in 3063 reverse order! */ 3064 finish_builtin_struct (type, "__builtin_ObjCString", 3065 fields, NULL_TREE); 3066 3067 return type; 3068 } 3069 3070 /* Custom build_string which sets TREE_TYPE! */ 3071 3072 tree 3073 my_build_string (int len, const char *str) 3074 { 3075 return fix_string_type (build_string (len, str)); 3076 } 3077 3078 /* Build a string with contents STR and length LEN and convert it to a 3079 pointer. */ 3080 3081 tree 3082 my_build_string_pointer (int len, const char *str) 3083 { 3084 tree string = my_build_string (len, str); 3085 tree ptrtype = build_pointer_type (TREE_TYPE (TREE_TYPE (string))); 3086 return build1 (ADDR_EXPR, ptrtype, string); 3087 } 3088 3089 static hashval_t 3090 string_hash (const void *ptr) 3091 { 3092 const_tree const str = ((const struct string_descriptor *)ptr)->literal; 3093 const unsigned char *p = (const unsigned char *) TREE_STRING_POINTER (str); 3094 int i, len = TREE_STRING_LENGTH (str); 3095 hashval_t h = len; 3096 3097 for (i = 0; i < len; i++) 3098 h = ((h * 613) + p[i]); 3099 3100 return h; 3101 } 3102 3103 static int 3104 string_eq (const void *ptr1, const void *ptr2) 3105 { 3106 const_tree const str1 = ((const struct string_descriptor *)ptr1)->literal; 3107 const_tree const str2 = ((const struct string_descriptor *)ptr2)->literal; 3108 int len1 = TREE_STRING_LENGTH (str1); 3109 3110 return (len1 == TREE_STRING_LENGTH (str2) 3111 && !memcmp (TREE_STRING_POINTER (str1), TREE_STRING_POINTER (str2), 3112 len1)); 3113 } 3114 3115 /* Given a chain of STRING_CST's, build a static instance of 3116 NXConstantString which points at the concatenation of those 3117 strings. We place the string object in the __string_objects 3118 section of the __OBJC segment. The Objective-C runtime will 3119 initialize the isa pointers of the string objects to point at the 3120 NXConstantString class object. */ 3121 3122 tree 3123 objc_build_string_object (tree string) 3124 { 3125 tree constant_string_class; 3126 int length; 3127 tree addr; 3128 struct string_descriptor *desc, key; 3129 void **loc; 3130 3131 /* We should be passed a STRING_CST. */ 3132 gcc_checking_assert (TREE_CODE (string) == STRING_CST); 3133 length = TREE_STRING_LENGTH (string) - 1; 3134 3135 /* The target may have different ideas on how to construct an ObjC string 3136 literal. On Darwin (Mac OS X), for example, we may wish to obtain a 3137 constant CFString reference instead. 3138 At present, this is only supported for the NeXT runtime. */ 3139 if (flag_next_runtime 3140 && targetcm.objc_construct_string_object) 3141 { 3142 tree constructor = (*targetcm.objc_construct_string_object) (string); 3143 if (constructor) 3144 return build1 (NOP_EXPR, objc_object_type, constructor); 3145 } 3146 3147 /* Check whether the string class being used actually exists and has the 3148 correct ivar layout. */ 3149 if (!string_layout_checked) 3150 { 3151 string_layout_checked = -1; 3152 constant_string_class = lookup_interface (constant_string_id); 3153 internal_const_str_type = objc_build_internal_const_str_type (); 3154 3155 if (!constant_string_class 3156 || !(constant_string_type 3157 = CLASS_STATIC_TEMPLATE (constant_string_class))) 3158 error ("cannot find interface declaration for %qE", 3159 constant_string_id); 3160 /* The NSConstantString/NXConstantString ivar layout is now known. */ 3161 else if (!check_string_class_template ()) 3162 error ("interface %qE does not have valid constant string layout", 3163 constant_string_id); 3164 /* If the runtime can generate a literal reference to the string class, 3165 don't need to run a constructor. */ 3166 else if (!(*runtime.setup_const_string_class_decl)()) 3167 error ("cannot find reference tag for class %qE", constant_string_id); 3168 else 3169 { 3170 string_layout_checked = 1; /* Success! */ 3171 add_class_reference (constant_string_id); 3172 } 3173 } 3174 3175 if (string_layout_checked == -1) 3176 return error_mark_node; 3177 3178 /* Perhaps we already constructed a constant string just like this one? */ 3179 key.literal = string; 3180 loc = htab_find_slot (string_htab, &key, INSERT); 3181 desc = (struct string_descriptor *) *loc; 3182 3183 if (!desc) 3184 { 3185 *loc = desc = ggc_alloc_string_descriptor (); 3186 desc->literal = string; 3187 desc->constructor = 3188 (*runtime.build_const_string_constructor) (input_location, string, length); 3189 } 3190 3191 addr = convert (build_pointer_type (constant_string_type), 3192 build_unary_op (input_location, 3193 ADDR_EXPR, desc->constructor, 1)); 3194 3195 return addr; 3196 } 3197 3198 /* Build a static constant CONSTRUCTOR 3199 with type TYPE and elements ELTS. */ 3200 3201 tree 3202 objc_build_constructor (tree type, VEC(constructor_elt,gc) *elts) 3203 { 3204 tree constructor = build_constructor (type, elts); 3205 3206 TREE_CONSTANT (constructor) = 1; 3207 TREE_STATIC (constructor) = 1; 3208 TREE_READONLY (constructor) = 1; 3209 3210 #ifdef OBJCPLUS 3211 /* Adjust for impedance mismatch. We should figure out how to build 3212 CONSTRUCTORs that consistently please both the C and C++ gods. */ 3213 if (!VEC_index (constructor_elt, elts, 0)->index) 3214 TREE_TYPE (constructor) = init_list_type_node; 3215 #endif 3216 3217 return constructor; 3218 } 3219 3220 /* Return the DECL of the string IDENT in the SECTION. */ 3221 3222 tree 3223 get_objc_string_decl (tree ident, enum string_section section) 3224 { 3225 tree chain; 3226 3227 switch (section) 3228 { 3229 case class_names: 3230 chain = class_names_chain; 3231 break; 3232 case meth_var_names: 3233 chain = meth_var_names_chain; 3234 break; 3235 case meth_var_types: 3236 chain = meth_var_types_chain; 3237 break; 3238 case prop_names_attr: 3239 chain = prop_names_attr_chain; 3240 break; 3241 default: 3242 gcc_unreachable (); 3243 } 3244 3245 for (; chain != 0; chain = TREE_CHAIN (chain)) 3246 if (TREE_VALUE (chain) == ident) 3247 return (TREE_PURPOSE (chain)); 3248 3249 /* We didn't find the entry. */ 3250 return NULL_TREE; 3251 } 3252 3253 /* Create a class reference, but don't create a variable to reference 3254 it. */ 3255 3256 void 3257 add_class_reference (tree ident) 3258 { 3259 tree chain; 3260 3261 if ((chain = cls_ref_chain)) 3262 { 3263 tree tail; 3264 do 3265 { 3266 if (ident == TREE_VALUE (chain)) 3267 return; 3268 3269 tail = chain; 3270 chain = TREE_CHAIN (chain); 3271 } 3272 while (chain); 3273 3274 /* Append to the end of the list */ 3275 TREE_CHAIN (tail) = tree_cons (NULL_TREE, ident, NULL_TREE); 3276 } 3277 else 3278 cls_ref_chain = tree_cons (NULL_TREE, ident, NULL_TREE); 3279 } 3280 3281 /* Get a class reference, creating it if necessary. Also create the 3282 reference variable. */ 3283 tree 3284 objc_get_class_reference (tree ident) 3285 { 3286 tree orig_ident = (DECL_P (ident) 3287 ? DECL_NAME (ident) 3288 : TYPE_P (ident) 3289 ? OBJC_TYPE_NAME (ident) 3290 : ident); 3291 bool local_scope = false; 3292 3293 #ifdef OBJCPLUS 3294 if (processing_template_decl) 3295 /* Must wait until template instantiation time. */ 3296 return build_min_nt (CLASS_REFERENCE_EXPR, ident); 3297 #endif 3298 3299 if (TREE_CODE (ident) == TYPE_DECL) 3300 ident = (DECL_ORIGINAL_TYPE (ident) 3301 ? DECL_ORIGINAL_TYPE (ident) 3302 : TREE_TYPE (ident)); 3303 3304 #ifdef OBJCPLUS 3305 if (TYPE_P (ident) 3306 && CP_TYPE_CONTEXT (ident) != global_namespace) 3307 local_scope = true; 3308 #endif 3309 3310 if (local_scope || !(ident = objc_is_class_name (ident))) 3311 { 3312 error ("%qE is not an Objective-C class name or alias", 3313 orig_ident); 3314 return error_mark_node; 3315 } 3316 3317 return (*runtime.get_class_reference) (ident); 3318 } 3319 3320 void 3321 objc_declare_alias (tree alias_ident, tree class_ident) 3322 { 3323 tree underlying_class; 3324 3325 #ifdef OBJCPLUS 3326 if (current_namespace != global_namespace) { 3327 error ("Objective-C declarations may only appear in global scope"); 3328 } 3329 #endif /* OBJCPLUS */ 3330 3331 if (!(underlying_class = objc_is_class_name (class_ident))) 3332 warning (0, "cannot find class %qE", class_ident); 3333 else if (objc_is_class_name (alias_ident)) 3334 warning (0, "class %qE already exists", alias_ident); 3335 else 3336 { 3337 /* Implement @compatibility_alias as a typedef. */ 3338 #ifdef OBJCPLUS 3339 push_lang_context (lang_name_c); /* extern "C" */ 3340 #endif 3341 lang_hooks.decls.pushdecl (build_decl 3342 (input_location, 3343 TYPE_DECL, 3344 alias_ident, 3345 xref_tag (RECORD_TYPE, underlying_class))); 3346 #ifdef OBJCPLUS 3347 pop_lang_context (); 3348 #endif 3349 objc_map_put (alias_name_map, alias_ident, underlying_class); 3350 } 3351 } 3352 3353 void 3354 objc_declare_class (tree identifier) 3355 { 3356 #ifdef OBJCPLUS 3357 if (current_namespace != global_namespace) { 3358 error ("Objective-C declarations may only appear in global scope"); 3359 } 3360 #endif /* OBJCPLUS */ 3361 3362 if (! objc_is_class_name (identifier)) 3363 { 3364 tree record = lookup_name (identifier), type = record; 3365 3366 if (record) 3367 { 3368 if (TREE_CODE (record) == TYPE_DECL) 3369 type = DECL_ORIGINAL_TYPE (record) 3370 ? DECL_ORIGINAL_TYPE (record) 3371 : TREE_TYPE (record); 3372 3373 if (!TYPE_HAS_OBJC_INFO (type) 3374 || !TYPE_OBJC_INTERFACE (type)) 3375 { 3376 error ("%qE redeclared as different kind of symbol", 3377 identifier); 3378 error ("previous declaration of %q+D", 3379 record); 3380 } 3381 } 3382 3383 record = xref_tag (RECORD_TYPE, identifier); 3384 INIT_TYPE_OBJC_INFO (record); 3385 /* In the case of a @class declaration, we store the ident in 3386 the TYPE_OBJC_INTERFACE. If later an @interface is found, 3387 we'll replace the ident with the interface. */ 3388 TYPE_OBJC_INTERFACE (record) = identifier; 3389 objc_map_put (class_name_map, identifier, NULL_TREE); 3390 } 3391 } 3392 3393 tree 3394 objc_is_class_name (tree ident) 3395 { 3396 if (ident && TREE_CODE (ident) == IDENTIFIER_NODE) 3397 { 3398 tree t = identifier_global_value (ident); 3399 if (t) 3400 ident = t; 3401 } 3402 3403 while (ident && TREE_CODE (ident) == TYPE_DECL && DECL_ORIGINAL_TYPE (ident)) 3404 ident = OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident)); 3405 3406 if (ident && TREE_CODE (ident) == RECORD_TYPE) 3407 ident = OBJC_TYPE_NAME (ident); 3408 #ifdef OBJCPLUS 3409 if (ident && TREE_CODE (ident) == TYPE_DECL) 3410 { 3411 tree type = TREE_TYPE (ident); 3412 if (type && TREE_CODE (type) == TEMPLATE_TYPE_PARM) 3413 return NULL_TREE; 3414 ident = DECL_NAME (ident); 3415 } 3416 #endif 3417 if (!ident || TREE_CODE (ident) != IDENTIFIER_NODE) 3418 return NULL_TREE; 3419 3420 if (lookup_interface (ident)) 3421 return ident; 3422 3423 { 3424 tree target; 3425 3426 target = objc_map_get (class_name_map, ident); 3427 if (target != OBJC_MAP_NOT_FOUND) 3428 return ident; 3429 3430 target = objc_map_get (alias_name_map, ident); 3431 if (target != OBJC_MAP_NOT_FOUND) 3432 return target; 3433 } 3434 3435 return 0; 3436 } 3437 3438 /* Check whether TYPE is either 'id' or 'Class'. */ 3439 3440 tree 3441 objc_is_id (tree type) 3442 { 3443 if (type && TREE_CODE (type) == IDENTIFIER_NODE) 3444 { 3445 tree t = identifier_global_value (type); 3446 if (t) 3447 type = t; 3448 } 3449 3450 if (type && TREE_CODE (type) == TYPE_DECL) 3451 type = TREE_TYPE (type); 3452 3453 /* NB: This function may be called before the ObjC front-end has 3454 been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL. */ 3455 return (objc_object_type && type 3456 && (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type)) 3457 ? type 3458 : NULL_TREE); 3459 } 3460 3461 /* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC 3462 class instance. This is needed by other parts of the compiler to 3463 handle ObjC types gracefully. */ 3464 3465 tree 3466 objc_is_object_ptr (tree type) 3467 { 3468 tree ret; 3469 3470 type = TYPE_MAIN_VARIANT (type); 3471 if (!POINTER_TYPE_P (type)) 3472 return 0; 3473 3474 ret = objc_is_id (type); 3475 if (!ret) 3476 ret = objc_is_class_name (TREE_TYPE (type)); 3477 3478 return ret; 3479 } 3480 3481 static int 3482 objc_is_gcable_type (tree type, int or_strong_p) 3483 { 3484 tree name; 3485 3486 if (!TYPE_P (type)) 3487 return 0; 3488 if (objc_is_id (TYPE_MAIN_VARIANT (type))) 3489 return 1; 3490 if (or_strong_p && lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type))) 3491 return 1; 3492 if (TREE_CODE (type) != POINTER_TYPE && TREE_CODE (type) != INDIRECT_REF) 3493 return 0; 3494 type = TREE_TYPE (type); 3495 if (TREE_CODE (type) != RECORD_TYPE) 3496 return 0; 3497 name = TYPE_NAME (type); 3498 return (objc_is_class_name (name) != NULL_TREE); 3499 } 3500 3501 static tree 3502 objc_substitute_decl (tree expr, tree oldexpr, tree newexpr) 3503 { 3504 if (expr == oldexpr) 3505 return newexpr; 3506 3507 switch (TREE_CODE (expr)) 3508 { 3509 case COMPONENT_REF: 3510 return objc_build_component_ref 3511 (objc_substitute_decl (TREE_OPERAND (expr, 0), 3512 oldexpr, 3513 newexpr), 3514 DECL_NAME (TREE_OPERAND (expr, 1))); 3515 case ARRAY_REF: 3516 return build_array_ref (input_location, 3517 objc_substitute_decl (TREE_OPERAND (expr, 0), 3518 oldexpr, 3519 newexpr), 3520 TREE_OPERAND (expr, 1)); 3521 case INDIRECT_REF: 3522 return build_indirect_ref (input_location, 3523 objc_substitute_decl (TREE_OPERAND (expr, 0), 3524 oldexpr, 3525 newexpr), RO_ARROW); 3526 default: 3527 return expr; 3528 } 3529 } 3530 3531 static tree 3532 objc_build_ivar_assignment (tree outervar, tree lhs, tree rhs) 3533 { 3534 tree func_params; 3535 /* The LHS parameter contains the expression 'outervar->memberspec'; 3536 we need to transform it into '&((typeof(outervar) *) 0)->memberspec', 3537 where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]'). 3538 */ 3539 tree offs 3540 = objc_substitute_decl 3541 (lhs, outervar, convert (TREE_TYPE (outervar), integer_zero_node)); 3542 tree func 3543 = (flag_objc_direct_dispatch 3544 ? objc_assign_ivar_fast_decl 3545 : objc_assign_ivar_decl); 3546 3547 offs = convert (integer_type_node, build_unary_op (input_location, 3548 ADDR_EXPR, offs, 0)); 3549 offs = fold (offs); 3550 func_params = tree_cons (NULL_TREE, 3551 convert (objc_object_type, rhs), 3552 tree_cons (NULL_TREE, convert (objc_object_type, outervar), 3553 tree_cons (NULL_TREE, offs, 3554 NULL_TREE))); 3555 3556 assemble_external (func); 3557 return build_function_call (input_location, func, func_params); 3558 } 3559 3560 static tree 3561 objc_build_global_assignment (tree lhs, tree rhs) 3562 { 3563 tree func_params = tree_cons (NULL_TREE, 3564 convert (objc_object_type, rhs), 3565 tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type), 3566 build_unary_op (input_location, ADDR_EXPR, lhs, 0)), 3567 NULL_TREE)); 3568 3569 assemble_external (objc_assign_global_decl); 3570 return build_function_call (input_location, 3571 objc_assign_global_decl, func_params); 3572 } 3573 3574 static tree 3575 objc_build_strong_cast_assignment (tree lhs, tree rhs) 3576 { 3577 tree func_params = tree_cons (NULL_TREE, 3578 convert (objc_object_type, rhs), 3579 tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type), 3580 build_unary_op (input_location, ADDR_EXPR, lhs, 0)), 3581 NULL_TREE)); 3582 3583 assemble_external (objc_assign_strong_cast_decl); 3584 return build_function_call (input_location, 3585 objc_assign_strong_cast_decl, func_params); 3586 } 3587 3588 static int 3589 objc_is_gcable_p (tree expr) 3590 { 3591 return (TREE_CODE (expr) == COMPONENT_REF 3592 ? objc_is_gcable_p (TREE_OPERAND (expr, 1)) 3593 : TREE_CODE (expr) == ARRAY_REF 3594 ? (objc_is_gcable_p (TREE_TYPE (expr)) 3595 || objc_is_gcable_p (TREE_OPERAND (expr, 0))) 3596 : TREE_CODE (expr) == ARRAY_TYPE 3597 ? objc_is_gcable_p (TREE_TYPE (expr)) 3598 : TYPE_P (expr) 3599 ? objc_is_gcable_type (expr, 1) 3600 : (objc_is_gcable_p (TREE_TYPE (expr)) 3601 || (DECL_P (expr) 3602 && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr))))); 3603 } 3604 3605 static int 3606 objc_is_ivar_reference_p (tree expr) 3607 { 3608 return (TREE_CODE (expr) == ARRAY_REF 3609 ? objc_is_ivar_reference_p (TREE_OPERAND (expr, 0)) 3610 : TREE_CODE (expr) == COMPONENT_REF 3611 ? TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL 3612 : 0); 3613 } 3614 3615 static int 3616 objc_is_global_reference_p (tree expr) 3617 { 3618 return (TREE_CODE (expr) == INDIRECT_REF || TREE_CODE (expr) == PLUS_EXPR 3619 ? objc_is_global_reference_p (TREE_OPERAND (expr, 0)) 3620 : DECL_P (expr) 3621 ? (DECL_FILE_SCOPE_P (expr) || TREE_STATIC (expr)) 3622 : 0); 3623 } 3624 3625 tree 3626 objc_generate_write_barrier (tree lhs, enum tree_code modifycode, tree rhs) 3627 { 3628 tree result = NULL_TREE, outer; 3629 int strong_cast_p = 0, outer_gc_p = 0, indirect_p = 0; 3630 3631 /* This function is currently only used with the next runtime with 3632 garbage collection enabled (-fobjc-gc). */ 3633 gcc_assert (flag_next_runtime); 3634 3635 /* See if we have any lhs casts, and strip them out. NB: The lvalue casts 3636 will have been transformed to the form '*(type *)&expr'. */ 3637 if (TREE_CODE (lhs) == INDIRECT_REF) 3638 { 3639 outer = TREE_OPERAND (lhs, 0); 3640 3641 while (!strong_cast_p 3642 && (CONVERT_EXPR_P (outer) 3643 || TREE_CODE (outer) == NON_LVALUE_EXPR)) 3644 { 3645 tree lhstype = TREE_TYPE (outer); 3646 3647 /* Descend down the cast chain, and record the first objc_gc 3648 attribute found. */ 3649 if (POINTER_TYPE_P (lhstype)) 3650 { 3651 tree attr 3652 = lookup_attribute ("objc_gc", 3653 TYPE_ATTRIBUTES (TREE_TYPE (lhstype))); 3654 3655 if (attr) 3656 strong_cast_p = 1; 3657 } 3658 3659 outer = TREE_OPERAND (outer, 0); 3660 } 3661 } 3662 3663 /* If we have a __strong cast, it trumps all else. */ 3664 if (strong_cast_p) 3665 { 3666 if (modifycode != NOP_EXPR) 3667 goto invalid_pointer_arithmetic; 3668 3669 if (warn_assign_intercept) 3670 warning (0, "strong-cast assignment has been intercepted"); 3671 3672 result = objc_build_strong_cast_assignment (lhs, rhs); 3673 3674 goto exit_point; 3675 } 3676 3677 /* the lhs must be of a suitable type, regardless of its underlying 3678 structure. */ 3679 if (!objc_is_gcable_p (lhs)) 3680 goto exit_point; 3681 3682 outer = lhs; 3683 3684 while (outer 3685 && (TREE_CODE (outer) == COMPONENT_REF 3686 || TREE_CODE (outer) == ARRAY_REF)) 3687 outer = TREE_OPERAND (outer, 0); 3688 3689 if (TREE_CODE (outer) == INDIRECT_REF) 3690 { 3691 outer = TREE_OPERAND (outer, 0); 3692 indirect_p = 1; 3693 } 3694 3695 outer_gc_p = objc_is_gcable_p (outer); 3696 3697 /* Handle ivar assignments. */ 3698 if (objc_is_ivar_reference_p (lhs)) 3699 { 3700 /* if the struct to the left of the ivar is not an Objective-C object (__strong 3701 doesn't cut it here), the best we can do here is suggest a cast. */ 3702 if (!objc_is_gcable_type (TREE_TYPE (outer), 0)) 3703 { 3704 /* We may still be able to use the global write barrier... */ 3705 if (!indirect_p && objc_is_global_reference_p (outer)) 3706 goto global_reference; 3707 3708 suggest_cast: 3709 if (modifycode == NOP_EXPR) 3710 { 3711 if (warn_assign_intercept) 3712 warning (0, "strong-cast may possibly be needed"); 3713 } 3714 3715 goto exit_point; 3716 } 3717 3718 if (modifycode != NOP_EXPR) 3719 goto invalid_pointer_arithmetic; 3720 3721 if (warn_assign_intercept) 3722 warning (0, "instance variable assignment has been intercepted"); 3723 3724 result = objc_build_ivar_assignment (outer, lhs, rhs); 3725 3726 goto exit_point; 3727 } 3728 3729 /* Likewise, intercept assignment to global/static variables if their type is 3730 GC-marked. */ 3731 if (objc_is_global_reference_p (outer)) 3732 { 3733 if (indirect_p) 3734 goto suggest_cast; 3735 3736 global_reference: 3737 if (modifycode != NOP_EXPR) 3738 { 3739 invalid_pointer_arithmetic: 3740 if (outer_gc_p) 3741 warning (0, "pointer arithmetic for garbage-collected objects not allowed"); 3742 3743 goto exit_point; 3744 } 3745 3746 if (warn_assign_intercept) 3747 warning (0, "global/static variable assignment has been intercepted"); 3748 3749 result = objc_build_global_assignment (lhs, rhs); 3750 } 3751 3752 /* In all other cases, fall back to the normal mechanism. */ 3753 exit_point: 3754 return result; 3755 } 3756 3757 /* Implementation of the table mapping a class name (as an identifier) 3758 to a class node. The two public functions for it are 3759 lookup_interface() and add_interface(). add_interface() is only 3760 used in this file, so we can make it static. */ 3761 3762 static GTY(()) objc_map_t interface_map; 3763 3764 static void 3765 interface_hash_init (void) 3766 { 3767 interface_map = objc_map_alloc_ggc (200); 3768 } 3769 3770 static tree 3771 add_interface (tree class_name, tree name) 3772 { 3773 /* Put interfaces on list in reverse order. */ 3774 TREE_CHAIN (class_name) = interface_chain; 3775 interface_chain = class_name; 3776 3777 /* Add it to the map. */ 3778 objc_map_put (interface_map, name, class_name); 3779 3780 return interface_chain; 3781 } 3782 3783 tree 3784 lookup_interface (tree ident) 3785 { 3786 #ifdef OBJCPLUS 3787 if (ident && TREE_CODE (ident) == TYPE_DECL) 3788 ident = DECL_NAME (ident); 3789 #endif 3790 3791 if (ident == NULL_TREE || TREE_CODE (ident) != IDENTIFIER_NODE) 3792 return NULL_TREE; 3793 3794 { 3795 tree interface = objc_map_get (interface_map, ident); 3796 3797 if (interface == OBJC_MAP_NOT_FOUND) 3798 return NULL_TREE; 3799 else 3800 return interface; 3801 } 3802 } 3803 3804 3805 3806 /* Implement @defs (<classname>) within struct bodies. */ 3807 3808 tree 3809 objc_get_class_ivars (tree class_name) 3810 { 3811 tree interface = lookup_interface (class_name); 3812 3813 if (interface) 3814 return get_class_ivars (interface, true); 3815 3816 error ("cannot find interface declaration for %qE", 3817 class_name); 3818 3819 return error_mark_node; 3820 } 3821 3822 3823 /* Functions used by the hashtable for field duplicates in 3824 objc_detect_field_duplicates(). Ideally, we'd use a standard 3825 key-value dictionary hashtable , and store as keys the field names, 3826 and as values the actual declarations (used to print nice error 3827 messages with the locations). But, the hashtable we are using only 3828 allows us to store keys in the hashtable, without values (it looks 3829 more like a set). So, we store the DECLs, but define equality as 3830 DECLs having the same name, and hash as the hash of the name. */ 3831 static hashval_t 3832 hash_instance_variable (const PTR p) 3833 { 3834 const_tree q = (const_tree)p; 3835 return (hashval_t) ((intptr_t)(DECL_NAME (q)) >> 3); 3836 } 3837 3838 static int 3839 eq_instance_variable (const PTR p1, const PTR p2) 3840 { 3841 const_tree a = (const_tree)p1; 3842 const_tree b = (const_tree)p2; 3843 return DECL_NAME (a) == DECL_NAME (b); 3844 } 3845 3846 /* Called when checking the variables in a struct. If we are not 3847 doing the ivars list inside an @interface context, then return 3848 false. Else, perform the check for duplicate ivars, then return 3849 true. The check for duplicates checks if an instance variable with 3850 the same name exists in the class or in a superclass. If 3851 'check_superclasses_only' is set to true, then it is assumed that 3852 checks for instance variables in the same class has already been 3853 performed (this is the case for ObjC++) and only the instance 3854 variables of superclasses are checked. */ 3855 bool 3856 objc_detect_field_duplicates (bool check_superclasses_only) 3857 { 3858 if (!objc_collecting_ivars || !objc_interface_context 3859 || TREE_CODE (objc_interface_context) != CLASS_INTERFACE_TYPE) 3860 return false; 3861 3862 /* We have two ways of doing this check: 3863 3864 "direct comparison": we iterate over the instance variables and 3865 compare them directly. This works great for small numbers of 3866 instance variables (such as 10 or 20), which are extremely common. 3867 But it will potentially take forever for the pathological case with 3868 a huge number (eg, 10k) of instance variables. 3869 3870 "hashtable": we use a hashtable, which requires a single sweep 3871 through the list of instances variables. This is much slower for a 3872 small number of variables, and we only use it for large numbers. 3873 3874 To decide which one to use, we need to get an idea of how many 3875 instance variables we have to compare. */ 3876 { 3877 unsigned int number_of_ivars_to_check = 0; 3878 { 3879 tree ivar; 3880 for (ivar = CLASS_RAW_IVARS (objc_interface_context); 3881 ivar; ivar = DECL_CHAIN (ivar)) 3882 { 3883 /* Ignore anonymous ivars. */ 3884 if (DECL_NAME (ivar)) 3885 number_of_ivars_to_check++; 3886 } 3887 } 3888 3889 /* Exit if there is nothing to do. */ 3890 if (number_of_ivars_to_check == 0) 3891 return true; 3892 3893 /* In case that there are only 1 or 2 instance variables to check, 3894 we always use direct comparison. If there are more, it is 3895 worth iterating over the instance variables in the superclass 3896 to count how many there are (note that this has the same cost 3897 as checking 1 instance variable by direct comparison, which is 3898 why we skip this check in the case of 1 or 2 ivars and just do 3899 the direct comparison) and then decide if it worth using a 3900 hashtable. */ 3901 if (number_of_ivars_to_check > 2) 3902 { 3903 unsigned int number_of_superclass_ivars = 0; 3904 { 3905 tree interface; 3906 for (interface = lookup_interface (CLASS_SUPER_NAME (objc_interface_context)); 3907 interface; interface = lookup_interface (CLASS_SUPER_NAME (interface))) 3908 { 3909 tree ivar; 3910 for (ivar = CLASS_RAW_IVARS (interface); 3911 ivar; ivar = DECL_CHAIN (ivar)) 3912 number_of_superclass_ivars++; 3913 } 3914 } 3915 3916 /* We use a hashtable if we have over 10k comparisons. */ 3917 if (number_of_ivars_to_check * (number_of_superclass_ivars 3918 + (number_of_ivars_to_check / 2)) 3919 > 10000) 3920 { 3921 /* First, build the hashtable by putting all the instance 3922 variables of superclasses in it. */ 3923 htab_t htab = htab_create (37, hash_instance_variable, 3924 eq_instance_variable, NULL); 3925 tree interface; 3926 for (interface = lookup_interface (CLASS_SUPER_NAME 3927 (objc_interface_context)); 3928 interface; interface = lookup_interface 3929 (CLASS_SUPER_NAME (interface))) 3930 { 3931 tree ivar; 3932 for (ivar = CLASS_RAW_IVARS (interface); ivar; 3933 ivar = DECL_CHAIN (ivar)) 3934 { 3935 if (DECL_NAME (ivar) != NULL_TREE) 3936 { 3937 void **slot = htab_find_slot (htab, ivar, INSERT); 3938 /* Do not check for duplicate instance 3939 variables in superclasses. Errors have 3940 already been generated. */ 3941 *slot = ivar; 3942 } 3943 } 3944 } 3945 3946 /* Now, we go through all the instance variables in the 3947 class, and check that they are not in the 3948 hashtable. */ 3949 if (check_superclasses_only) 3950 { 3951 tree ivar; 3952 for (ivar = CLASS_RAW_IVARS (objc_interface_context); ivar; 3953 ivar = DECL_CHAIN (ivar)) 3954 { 3955 if (DECL_NAME (ivar) != NULL_TREE) 3956 { 3957 tree duplicate_ivar = (tree)(htab_find (htab, ivar)); 3958 if (duplicate_ivar != HTAB_EMPTY_ENTRY) 3959 { 3960 error_at (DECL_SOURCE_LOCATION (ivar), 3961 "duplicate instance variable %q+D", 3962 ivar); 3963 inform (DECL_SOURCE_LOCATION (duplicate_ivar), 3964 "previous declaration of %q+D", 3965 duplicate_ivar); 3966 /* FIXME: Do we need the following ? */ 3967 /* DECL_NAME (ivar) = NULL_TREE; */ 3968 } 3969 } 3970 } 3971 } 3972 else 3973 { 3974 /* If we're checking for duplicates in the class as 3975 well, we insert variables in the hashtable as we 3976 check them, so if a duplicate follows, it will be 3977 caught. */ 3978 tree ivar; 3979 for (ivar = CLASS_RAW_IVARS (objc_interface_context); ivar; 3980 ivar = DECL_CHAIN (ivar)) 3981 { 3982 if (DECL_NAME (ivar) != NULL_TREE) 3983 { 3984 void **slot = htab_find_slot (htab, ivar, INSERT); 3985 if (*slot) 3986 { 3987 tree duplicate_ivar = (tree)(*slot); 3988 error_at (DECL_SOURCE_LOCATION (ivar), 3989 "duplicate instance variable %q+D", 3990 ivar); 3991 inform (DECL_SOURCE_LOCATION (duplicate_ivar), 3992 "previous declaration of %q+D", 3993 duplicate_ivar); 3994 /* FIXME: Do we need the following ? */ 3995 /* DECL_NAME (ivar) = NULL_TREE; */ 3996 } 3997 *slot = ivar; 3998 } 3999 } 4000 } 4001 htab_delete (htab); 4002 return true; 4003 } 4004 } 4005 } 4006 4007 /* This is the "direct comparison" approach, which is used in most 4008 non-pathological cases. */ 4009 { 4010 /* Walk up to class hierarchy, starting with this class (this is 4011 the external loop, because lookup_interface() is expensive, and 4012 we want to do it few times). */ 4013 tree interface = objc_interface_context; 4014 4015 if (check_superclasses_only) 4016 interface = lookup_interface (CLASS_SUPER_NAME (interface)); 4017 4018 for ( ; interface; interface = lookup_interface 4019 (CLASS_SUPER_NAME (interface))) 4020 { 4021 tree ivar_being_checked; 4022 4023 for (ivar_being_checked = CLASS_RAW_IVARS (objc_interface_context); 4024 ivar_being_checked; 4025 ivar_being_checked = DECL_CHAIN (ivar_being_checked)) 4026 { 4027 tree decl; 4028 4029 /* Ignore anonymous ivars. */ 4030 if (DECL_NAME (ivar_being_checked) == NULL_TREE) 4031 continue; 4032 4033 /* Note how we stop when we find the ivar we are checking 4034 (this can only happen in the main class, not 4035 superclasses), to avoid comparing things twice 4036 (otherwise, for each ivar, you'd compare A to B then B 4037 to A, and get duplicated error messages). */ 4038 for (decl = CLASS_RAW_IVARS (interface); 4039 decl && decl != ivar_being_checked; 4040 decl = DECL_CHAIN (decl)) 4041 { 4042 if (DECL_NAME (ivar_being_checked) == DECL_NAME (decl)) 4043 { 4044 error_at (DECL_SOURCE_LOCATION (ivar_being_checked), 4045 "duplicate instance variable %q+D", 4046 ivar_being_checked); 4047 inform (DECL_SOURCE_LOCATION (decl), 4048 "previous declaration of %q+D", 4049 decl); 4050 /* FIXME: Do we need the following ? */ 4051 /* DECL_NAME (ivar_being_checked) = NULL_TREE; */ 4052 } 4053 } 4054 } 4055 } 4056 } 4057 return true; 4058 } 4059 4060 /* Used by: build_private_template, continue_class, 4061 and for @defs constructs. */ 4062 4063 static tree 4064 get_class_ivars (tree interface, bool inherited) 4065 { 4066 tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface)); 4067 4068 /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared 4069 by the current class (i.e., they do not include super-class ivars). 4070 However, the CLASS_IVARS list will be side-effected by a call to 4071 finish_struct(), which will fill in field offsets. */ 4072 if (!CLASS_IVARS (interface)) 4073 CLASS_IVARS (interface) = ivar_chain; 4074 4075 if (!inherited) 4076 return ivar_chain; 4077 4078 while (CLASS_SUPER_NAME (interface)) 4079 { 4080 /* Prepend super-class ivars. */ 4081 interface = lookup_interface (CLASS_SUPER_NAME (interface)); 4082 ivar_chain = chainon (copy_list (CLASS_RAW_IVARS (interface)), 4083 ivar_chain); 4084 } 4085 4086 return ivar_chain; 4087 } 4088 4089 void 4090 objc_maybe_warn_exceptions (location_t loc) 4091 { 4092 /* -fobjc-exceptions is required to enable Objective-C exceptions. 4093 For example, on Darwin, ObjC exceptions require a sufficiently 4094 recent version of the runtime, so the user must ask for them 4095 explicitly. On other platforms, at the moment -fobjc-exceptions 4096 triggers -fexceptions which again is required for exceptions to 4097 work. */ 4098 if (!flag_objc_exceptions) 4099 { 4100 /* Warn only once per compilation unit. */ 4101 static bool warned = false; 4102 4103 if (!warned) 4104 { 4105 error_at (loc, "%<-fobjc-exceptions%> is required to enable Objective-C exception syntax"); 4106 warned = true; 4107 } 4108 } 4109 } 4110 4111 static struct objc_try_context *cur_try_context; 4112 4113 /* Called just after parsing the @try and its associated BODY. We now 4114 must prepare for the tricky bits -- handling the catches and finally. */ 4115 4116 void 4117 objc_begin_try_stmt (location_t try_locus, tree body) 4118 { 4119 struct objc_try_context *c = XCNEW (struct objc_try_context); 4120 c->outer = cur_try_context; 4121 c->try_body = body; 4122 c->try_locus = try_locus; 4123 c->end_try_locus = input_location; 4124 cur_try_context = c; 4125 4126 /* Collect the list of local variables. We'll mark them as volatile 4127 at the end of compilation of this function to prevent them being 4128 clobbered by setjmp/longjmp. */ 4129 if (flag_objc_sjlj_exceptions) 4130 objc_mark_locals_volatile (NULL); 4131 } 4132 4133 /* Called just after parsing "@catch (parm)". Open a binding level, 4134 enter DECL into the binding level, and initialize it. Leave the 4135 binding level open while the body of the compound statement is 4136 parsed. If DECL is NULL_TREE, then we are compiling "@catch(...)" 4137 which we compile as "@catch(id tmp_variable)". */ 4138 4139 void 4140 objc_begin_catch_clause (tree decl) 4141 { 4142 tree compound, type, t; 4143 bool ellipsis = false; 4144 4145 /* Begin a new scope that the entire catch clause will live in. */ 4146 compound = c_begin_compound_stmt (true); 4147 4148 /* Create the appropriate declaration for the argument. */ 4149 if (decl == error_mark_node) 4150 type = error_mark_node; 4151 else 4152 { 4153 if (decl == NULL_TREE) 4154 { 4155 /* If @catch(...) was specified, create a temporary variable of 4156 type 'id' and use it. */ 4157 decl = objc_create_temporary_var (objc_object_type, "__objc_generic_catch_var"); 4158 DECL_SOURCE_LOCATION (decl) = input_location; 4159 /* ... but allow the runtime to differentiate between ellipsis and the 4160 case of @catch (id xyz). */ 4161 ellipsis = true; 4162 } 4163 else 4164 { 4165 /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL. */ 4166 decl = build_decl (input_location, 4167 VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl)); 4168 } 4169 lang_hooks.decls.pushdecl (decl); 4170 4171 /* Mark the declaration as used so you never any warnings whether 4172 you use the exception argument or not. TODO: Implement a 4173 -Wunused-exception-parameter flag, which would cause warnings 4174 if exception parameter is not used. */ 4175 TREE_USED (decl) = 1; 4176 DECL_READ_P (decl) = 1; 4177 4178 type = TREE_TYPE (decl); 4179 } 4180 4181 /* Verify that the type of the catch is valid. It must be a pointer 4182 to an Objective-C class, or "id" (which is catch-all). */ 4183 if (type == error_mark_node) 4184 { 4185 ;/* Just keep going. */ 4186 } 4187 else if (!objc_type_valid_for_messaging (type, false)) 4188 { 4189 error ("@catch parameter is not a known Objective-C class type"); 4190 type = error_mark_node; 4191 } 4192 else if (TYPE_HAS_OBJC_INFO (TREE_TYPE (type)) 4193 && TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (type))) 4194 { 4195 error ("@catch parameter can not be protocol-qualified"); 4196 type = error_mark_node; 4197 } 4198 else if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type))) 4199 /* @catch (id xyz) or @catch (...) but we note this for runtimes that 4200 identify 'id'. */ 4201 ; 4202 else 4203 { 4204 /* If 'type' was built using typedefs, we need to get rid of 4205 them and get a simple pointer to the class. */ 4206 bool is_typedef = false; 4207 tree x = TYPE_MAIN_VARIANT (type); 4208 4209 /* Skip from the pointer to the pointee. */ 4210 if (TREE_CODE (x) == POINTER_TYPE) 4211 x = TREE_TYPE (x); 4212 4213 /* Traverse typedef aliases */ 4214 while (TREE_CODE (x) == RECORD_TYPE && OBJC_TYPE_NAME (x) 4215 && TREE_CODE (OBJC_TYPE_NAME (x)) == TYPE_DECL 4216 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x))) 4217 { 4218 is_typedef = true; 4219 x = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x)); 4220 } 4221 4222 /* If it was a typedef, build a pointer to the final, original 4223 class. */ 4224 if (is_typedef) 4225 type = build_pointer_type (x); 4226 4227 if (cur_try_context->catch_list) 4228 { 4229 /* Examine previous @catch clauses and see if we've already 4230 caught the type in question. */ 4231 tree_stmt_iterator i = tsi_start (cur_try_context->catch_list); 4232 for (; !tsi_end_p (i); tsi_next (&i)) 4233 { 4234 tree stmt = tsi_stmt (i); 4235 t = CATCH_TYPES (stmt); 4236 if (t == error_mark_node) 4237 continue; 4238 if (!t || DERIVED_FROM_P (TREE_TYPE (t), TREE_TYPE (type))) 4239 { 4240 warning (0, "exception of type %<%T%> will be caught", 4241 TREE_TYPE (type)); 4242 warning_at (EXPR_LOCATION (stmt), 0, " by earlier handler for %<%T%>", 4243 TREE_TYPE (t ? t : objc_object_type)); 4244 break; 4245 } 4246 } 4247 } 4248 } 4249 4250 t = (*runtime.begin_catch) (&cur_try_context, type, decl, compound, ellipsis); 4251 add_stmt (t); 4252 } 4253 4254 /* Called just after parsing the closing brace of a @catch clause. Close 4255 the open binding level, and record a CATCH_EXPR for it. */ 4256 4257 void 4258 objc_finish_catch_clause (void) 4259 { 4260 tree c = cur_try_context->current_catch; 4261 cur_try_context->current_catch = NULL; 4262 cur_try_context->end_catch_locus = input_location; 4263 4264 CATCH_BODY (c) = c_end_compound_stmt (input_location, CATCH_BODY (c), 1); 4265 4266 (*runtime.finish_catch) (&cur_try_context, c); 4267 } 4268 4269 /* Called after parsing a @finally clause and its associated BODY. 4270 Record the body for later placement. */ 4271 4272 void 4273 objc_build_finally_clause (location_t finally_locus, tree body) 4274 { 4275 cur_try_context->finally_body = body; 4276 cur_try_context->finally_locus = finally_locus; 4277 cur_try_context->end_finally_locus = input_location; 4278 } 4279 4280 /* Called to finalize a @try construct. */ 4281 4282 tree 4283 objc_finish_try_stmt (void) 4284 { 4285 struct objc_try_context *c = cur_try_context; 4286 tree stmt; 4287 4288 if (c->catch_list == NULL && c->finally_body == NULL) 4289 error ("%<@try%> without %<@catch%> or %<@finally%>"); 4290 4291 stmt = (*runtime.finish_try_stmt) (&cur_try_context); 4292 add_stmt (stmt); 4293 4294 cur_try_context = c->outer; 4295 free (c); 4296 return stmt; 4297 } 4298 4299 tree 4300 objc_build_throw_stmt (location_t loc, tree throw_expr) 4301 { 4302 bool rethrown = false; 4303 4304 objc_maybe_warn_exceptions (loc); 4305 4306 /* Don't waste time trying to build something if we're already dead. */ 4307 if (throw_expr == error_mark_node) 4308 return error_mark_node; 4309 4310 if (throw_expr == NULL) 4311 { 4312 /* If we're not inside a @catch block, there is no "current 4313 exception" to be rethrown. */ 4314 if (cur_try_context == NULL 4315 || cur_try_context->current_catch == NULL) 4316 { 4317 error_at (loc, "%<@throw%> (rethrow) used outside of a @catch block"); 4318 return error_mark_node; 4319 } 4320 4321 /* Otherwise the object is still sitting in the EXC_PTR_EXPR 4322 value that we get from the runtime. */ 4323 throw_expr = (*runtime.build_exc_ptr) (&cur_try_context); 4324 rethrown = true; 4325 } 4326 else 4327 { 4328 if (!objc_type_valid_for_messaging (TREE_TYPE (throw_expr), true)) 4329 { 4330 error_at (loc, "%<@throw%> argument is not an object"); 4331 return error_mark_node; 4332 } 4333 } 4334 4335 return (*runtime.build_throw_stmt) (loc, throw_expr, rethrown); 4336 } 4337 4338 tree 4339 objc_build_synchronized (location_t start_locus, tree object_expr, tree body) 4340 { 4341 /* object_expr should never be NULL; but in case it is, convert it to 4342 error_mark_node. */ 4343 if (object_expr == NULL) 4344 object_expr = error_mark_node; 4345 4346 /* Validate object_expr. If not valid, set it to error_mark_node. */ 4347 if (object_expr != error_mark_node) 4348 { 4349 if (!objc_type_valid_for_messaging (TREE_TYPE (object_expr), true)) 4350 { 4351 error_at (start_locus, "%<@synchronized%> argument is not an object"); 4352 object_expr = error_mark_node; 4353 } 4354 } 4355 4356 if (object_expr == error_mark_node) 4357 { 4358 /* If we found an error, we simply ignore the '@synchronized'. 4359 Compile the body so we can keep going with minimal 4360 casualties. */ 4361 return add_stmt (body); 4362 } 4363 else 4364 { 4365 tree call; 4366 tree args; 4367 4368 /* objc_sync_enter (object_expr); */ 4369 object_expr = save_expr (object_expr); 4370 args = tree_cons (NULL, object_expr, NULL); 4371 call = build_function_call (input_location, 4372 objc_sync_enter_decl, args); 4373 SET_EXPR_LOCATION (call, start_locus); 4374 add_stmt (call); 4375 4376 /* Build "objc_sync_exit (object_expr);" but do not add it yet; 4377 it goes inside the @finalize() clause. */ 4378 args = tree_cons (NULL, object_expr, NULL); 4379 call = build_function_call (input_location, 4380 objc_sync_exit_decl, args); 4381 SET_EXPR_LOCATION (call, input_location); 4382 4383 /* @try { body; } */ 4384 objc_begin_try_stmt (start_locus, body); 4385 4386 /* @finally { objc_sync_exit (object_expr); } */ 4387 objc_build_finally_clause (input_location, call); 4388 4389 /* End of try statement. */ 4390 return objc_finish_try_stmt (); 4391 } 4392 } 4393 4394 /* Construct a C struct corresponding to ObjC class CLASS, with the same 4395 name as the class: 4396 4397 struct <classname> { 4398 struct _objc_class *isa; 4399 ... 4400 }; */ 4401 4402 static void 4403 build_private_template (tree klass) 4404 { 4405 if (!CLASS_STATIC_TEMPLATE (klass)) 4406 { 4407 tree record = objc_build_struct (klass, 4408 get_class_ivars (klass, false), 4409 CLASS_SUPER_NAME (klass)); 4410 4411 /* Set the TREE_USED bit for this struct, so that stab generator 4412 can emit stabs for this struct type. */ 4413 if (flag_debug_only_used_symbols && TYPE_STUB_DECL (record)) 4414 TREE_USED (TYPE_STUB_DECL (record)) = 1; 4415 4416 /* Copy the attributes from the class to the type. */ 4417 if (TREE_DEPRECATED (klass)) 4418 TREE_DEPRECATED (record) = 1; 4419 } 4420 } 4421 4422 /* Generate either '- .cxx_construct' or '- .cxx_destruct' for the 4423 current class. */ 4424 #ifdef OBJCPLUS 4425 static void 4426 objc_generate_cxx_ctor_or_dtor (bool dtor) 4427 { 4428 tree fn, body, compound_stmt, ivar; 4429 4430 /* - (id) .cxx_construct { ... return self; } */ 4431 /* - (void) .cxx_construct { ... } */ 4432 4433 objc_start_method_definition 4434 (false /* is_class_method */, 4435 objc_build_method_signature (false /* is_class_method */, 4436 build_tree_list (NULL_TREE, 4437 dtor 4438 ? void_type_node 4439 : objc_object_type), 4440 get_identifier (dtor 4441 ? TAG_CXX_DESTRUCT 4442 : TAG_CXX_CONSTRUCT), 4443 make_node (TREE_LIST), 4444 false), NULL, NULL_TREE); 4445 body = begin_function_body (); 4446 compound_stmt = begin_compound_stmt (0); 4447 4448 ivar = CLASS_IVARS (implementation_template); 4449 /* Destroy ivars in reverse order. */ 4450 if (dtor) 4451 ivar = nreverse (copy_list (ivar)); 4452 4453 for (; ivar; ivar = TREE_CHAIN (ivar)) 4454 { 4455 if (TREE_CODE (ivar) == FIELD_DECL) 4456 { 4457 tree type = TREE_TYPE (ivar); 4458 4459 /* Call the ivar's default constructor or destructor. Do not 4460 call the destructor unless a corresponding constructor call 4461 has also been made (or is not needed). */ 4462 if (MAYBE_CLASS_TYPE_P (type) 4463 && (dtor 4464 ? (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) 4465 && (!TYPE_NEEDS_CONSTRUCTING (type) 4466 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type))) 4467 : (TYPE_NEEDS_CONSTRUCTING (type) 4468 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))) 4469 finish_expr_stmt 4470 (build_special_member_call 4471 (build_ivar_reference (DECL_NAME (ivar)), 4472 dtor ? complete_dtor_identifier : complete_ctor_identifier, 4473 NULL, type, LOOKUP_NORMAL, tf_warning_or_error)); 4474 } 4475 } 4476 4477 /* The constructor returns 'self'. */ 4478 if (!dtor) 4479 finish_return_stmt (self_decl); 4480 4481 finish_compound_stmt (compound_stmt); 4482 finish_function_body (body); 4483 fn = current_function_decl; 4484 finish_function (); 4485 objc_finish_method_definition (fn); 4486 } 4487 4488 /* The following routine will examine the current @interface for any 4489 non-POD C++ ivars requiring non-trivial construction and/or 4490 destruction, and then synthesize special '- .cxx_construct' and/or 4491 '- .cxx_destruct' methods which will run the appropriate 4492 construction or destruction code. Note that ivars inherited from 4493 super-classes are _not_ considered. */ 4494 static void 4495 objc_generate_cxx_cdtors (void) 4496 { 4497 bool need_ctor = false, need_dtor = false; 4498 tree ivar; 4499 4500 /* Error case, due to possibly an extra @end. */ 4501 if (!objc_implementation_context) 4502 return; 4503 4504 /* We do not want to do this for categories, since they do not have 4505 their own ivars. */ 4506 4507 if (TREE_CODE (objc_implementation_context) != CLASS_IMPLEMENTATION_TYPE) 4508 return; 4509 4510 /* First, determine if we even need a constructor and/or destructor. */ 4511 4512 for (ivar = CLASS_IVARS (implementation_template); ivar; 4513 ivar = TREE_CHAIN (ivar)) 4514 { 4515 if (TREE_CODE (ivar) == FIELD_DECL) 4516 { 4517 tree type = TREE_TYPE (ivar); 4518 4519 if (MAYBE_CLASS_TYPE_P (type)) 4520 { 4521 if (TYPE_NEEDS_CONSTRUCTING (type) 4522 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) 4523 /* NB: If a default constructor is not available, we will not 4524 be able to initialize this ivar; the add_instance_variable() 4525 routine will already have warned about this. */ 4526 need_ctor = true; 4527 4528 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) 4529 && (!TYPE_NEEDS_CONSTRUCTING (type) 4530 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type))) 4531 /* NB: If a default constructor is not available, we will not 4532 call the destructor either, for symmetry. */ 4533 need_dtor = true; 4534 } 4535 } 4536 } 4537 4538 /* Generate '- .cxx_construct' if needed. */ 4539 4540 if (need_ctor) 4541 objc_generate_cxx_ctor_or_dtor (false); 4542 4543 /* Generate '- .cxx_destruct' if needed. */ 4544 4545 if (need_dtor) 4546 objc_generate_cxx_ctor_or_dtor (true); 4547 4548 /* The 'imp_list' variable points at an imp_entry record for the current 4549 @implementation. Record the existence of '- .cxx_construct' and/or 4550 '- .cxx_destruct' methods therein; it will be included in the 4551 metadata for the class if the runtime needs it. */ 4552 imp_list->has_cxx_cdtors = (need_ctor || need_dtor); 4553 } 4554 #endif 4555 4556 static void 4557 error_with_ivar (const char *message, tree decl) 4558 { 4559 error_at (DECL_SOURCE_LOCATION (decl), "%s %qs", 4560 message, identifier_to_locale (gen_declaration (decl))); 4561 4562 } 4563 4564 static void 4565 check_ivars (tree inter, tree imp) 4566 { 4567 tree intdecls = CLASS_RAW_IVARS (inter); 4568 tree impdecls = CLASS_RAW_IVARS (imp); 4569 4570 while (1) 4571 { 4572 tree t1, t2; 4573 4574 #ifdef OBJCPLUS 4575 if (intdecls && TREE_CODE (intdecls) == TYPE_DECL) 4576 intdecls = TREE_CHAIN (intdecls); 4577 #endif 4578 if (intdecls == 0 && impdecls == 0) 4579 break; 4580 if (intdecls == 0 || impdecls == 0) 4581 { 4582 error ("inconsistent instance variable specification"); 4583 break; 4584 } 4585 4586 t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls); 4587 4588 if (!comptypes (t1, t2) 4589 || !tree_int_cst_equal (DECL_INITIAL (intdecls), 4590 DECL_INITIAL (impdecls))) 4591 { 4592 if (DECL_NAME (intdecls) == DECL_NAME (impdecls)) 4593 { 4594 error_with_ivar ("conflicting instance variable type", 4595 impdecls); 4596 error_with_ivar ("previous declaration of", 4597 intdecls); 4598 } 4599 else /* both the type and the name don't match */ 4600 { 4601 error ("inconsistent instance variable specification"); 4602 break; 4603 } 4604 } 4605 4606 else if (DECL_NAME (intdecls) != DECL_NAME (impdecls)) 4607 { 4608 error_with_ivar ("conflicting instance variable name", 4609 impdecls); 4610 error_with_ivar ("previous declaration of", 4611 intdecls); 4612 } 4613 4614 intdecls = DECL_CHAIN (intdecls); 4615 impdecls = DECL_CHAIN (impdecls); 4616 } 4617 } 4618 4619 4620 static void 4621 mark_referenced_methods (void) 4622 { 4623 struct imp_entry *impent; 4624 tree chain; 4625 4626 for (impent = imp_list; impent; impent = impent->next) 4627 { 4628 chain = CLASS_CLS_METHODS (impent->imp_context); 4629 while (chain) 4630 { 4631 cgraph_mark_needed_node ( 4632 cgraph_get_create_node (METHOD_DEFINITION (chain))); 4633 chain = DECL_CHAIN (chain); 4634 } 4635 4636 chain = CLASS_NST_METHODS (impent->imp_context); 4637 while (chain) 4638 { 4639 cgraph_mark_needed_node ( 4640 cgraph_get_create_node (METHOD_DEFINITION (chain))); 4641 chain = DECL_CHAIN (chain); 4642 } 4643 } 4644 } 4645 4646 /* If type is empty or only type qualifiers are present, add default 4647 type of id (otherwise grokdeclarator will default to int). */ 4648 static inline tree 4649 adjust_type_for_id_default (tree type) 4650 { 4651 if (!type) 4652 type = make_node (TREE_LIST); 4653 4654 if (!TREE_VALUE (type)) 4655 TREE_VALUE (type) = objc_object_type; 4656 else if (TREE_CODE (TREE_VALUE (type)) == RECORD_TYPE 4657 && TYPED_OBJECT (TREE_VALUE (type))) 4658 error ("can not use an object as parameter to a method"); 4659 4660 return type; 4661 } 4662 4663 /* Return a KEYWORD_DECL built using the specified key_name, arg_type, 4664 arg_name and attributes. (TODO: Rename KEYWORD_DECL to 4665 OBJC_METHOD_PARM_DECL ?) 4666 4667 A KEYWORD_DECL is a tree representing the declaration of a 4668 parameter of an Objective-C method. It is produced when parsing a 4669 fragment of Objective-C method declaration of the form 4670 4671 keyworddecl: 4672 selector ':' '(' typename ')' identifier 4673 4674 For example, take the Objective-C method 4675 4676 -(NSString *)pathForResource:(NSString *)resource ofType:(NSString *)type; 4677 4678 the two fragments "pathForResource:(NSString *)resource" and 4679 "ofType:(NSString *)type" will generate a KEYWORD_DECL each. The 4680 KEYWORD_DECL stores the 'key_name' (eg, identifier for 4681 "pathForResource"), the 'arg_type' (eg, tree representing a 4682 NSString *), the 'arg_name' (eg identifier for "resource") and 4683 potentially some attributes (for example, a tree representing 4684 __attribute__ ((unused)) if such an attribute was attached to a 4685 certain parameter). You can access this information using the 4686 TREE_TYPE (for arg_type), KEYWORD_ARG_NAME (for arg_name), 4687 KEYWORD_KEY_NAME (for key_name), DECL_ATTRIBUTES (for attributes). 4688 4689 'key_name' is an identifier node (and is optional as you can omit 4690 it in Objective-C methods). 4691 'arg_type' is a tree list (and is optional too if no parameter type 4692 was specified). 4693 'arg_name' is an identifier node and is required. 4694 'attributes' is an optional tree containing parameter attributes. */ 4695 tree 4696 objc_build_keyword_decl (tree key_name, tree arg_type, 4697 tree arg_name, tree attributes) 4698 { 4699 tree keyword_decl; 4700 4701 if (flag_objc1_only && attributes) 4702 error_at (input_location, "method argument attributes are not available in Objective-C 1.0"); 4703 4704 /* If no type is specified, default to "id". */ 4705 arg_type = adjust_type_for_id_default (arg_type); 4706 4707 keyword_decl = make_node (KEYWORD_DECL); 4708 4709 TREE_TYPE (keyword_decl) = arg_type; 4710 KEYWORD_ARG_NAME (keyword_decl) = arg_name; 4711 KEYWORD_KEY_NAME (keyword_decl) = key_name; 4712 DECL_ATTRIBUTES (keyword_decl) = attributes; 4713 4714 return keyword_decl; 4715 } 4716 4717 /* Given a chain of keyword_decl's, synthesize the full keyword selector. */ 4718 static tree 4719 build_keyword_selector (tree selector) 4720 { 4721 int len = 0; 4722 tree key_chain, key_name; 4723 char *buf; 4724 4725 /* Scan the selector to see how much space we'll need. */ 4726 for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain)) 4727 { 4728 switch (TREE_CODE (selector)) 4729 { 4730 case KEYWORD_DECL: 4731 key_name = KEYWORD_KEY_NAME (key_chain); 4732 break; 4733 case TREE_LIST: 4734 key_name = TREE_PURPOSE (key_chain); 4735 break; 4736 default: 4737 gcc_unreachable (); 4738 } 4739 4740 if (key_name) 4741 len += IDENTIFIER_LENGTH (key_name) + 1; 4742 else 4743 /* Just a ':' arg. */ 4744 len++; 4745 } 4746 4747 buf = (char *) alloca (len + 1); 4748 /* Start the buffer out as an empty string. */ 4749 buf[0] = '\0'; 4750 4751 for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain)) 4752 { 4753 switch (TREE_CODE (selector)) 4754 { 4755 case KEYWORD_DECL: 4756 key_name = KEYWORD_KEY_NAME (key_chain); 4757 break; 4758 case TREE_LIST: 4759 key_name = TREE_PURPOSE (key_chain); 4760 /* The keyword decl chain will later be used as a function 4761 argument chain. Unhook the selector itself so as to not 4762 confuse other parts of the compiler. */ 4763 TREE_PURPOSE (key_chain) = NULL_TREE; 4764 break; 4765 default: 4766 gcc_unreachable (); 4767 } 4768 4769 if (key_name) 4770 strcat (buf, IDENTIFIER_POINTER (key_name)); 4771 strcat (buf, ":"); 4772 } 4773 4774 return get_identifier_with_length (buf, len); 4775 } 4776 4777 /* Used for declarations and definitions. */ 4778 4779 static tree 4780 build_method_decl (enum tree_code code, tree ret_type, tree selector, 4781 tree add_args, bool ellipsis) 4782 { 4783 tree method_decl; 4784 4785 /* If no type is specified, default to "id". */ 4786 ret_type = adjust_type_for_id_default (ret_type); 4787 4788 /* Note how a method_decl has a TREE_TYPE which is not the function 4789 type of the function implementing the method, but only the return 4790 type of the method. We may want to change this, and store the 4791 entire function type in there (eg, it may be used to simplify 4792 dealing with attributes below). */ 4793 method_decl = make_node (code); 4794 TREE_TYPE (method_decl) = ret_type; 4795 4796 /* If we have a keyword selector, create an identifier_node that 4797 represents the full selector name (`:' included)... */ 4798 if (TREE_CODE (selector) == KEYWORD_DECL) 4799 { 4800 METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector); 4801 METHOD_SEL_ARGS (method_decl) = selector; 4802 METHOD_ADD_ARGS (method_decl) = add_args; 4803 METHOD_ADD_ARGS_ELLIPSIS_P (method_decl) = ellipsis; 4804 } 4805 else 4806 { 4807 METHOD_SEL_NAME (method_decl) = selector; 4808 METHOD_SEL_ARGS (method_decl) = NULL_TREE; 4809 METHOD_ADD_ARGS (method_decl) = NULL_TREE; 4810 } 4811 4812 return method_decl; 4813 } 4814 4815 /* This routine processes objective-c method attributes. */ 4816 4817 static void 4818 objc_decl_method_attributes (tree *node, tree attributes, int flags) 4819 { 4820 /* TODO: Replace the hackery below. An idea would be to store the 4821 full function type in the method declaration (for example in 4822 TREE_TYPE) and then expose ObjC method declarations to c-family 4823 and they could deal with them by simply treating them as 4824 functions. */ 4825 4826 /* Because of the dangers in the hackery below, we filter out any 4827 attribute that we do not know about. For the ones we know about, 4828 we know that they work with the hackery. For the other ones, 4829 there is no guarantee, so we have to filter them out. */ 4830 tree filtered_attributes = NULL_TREE; 4831 4832 if (attributes) 4833 { 4834 tree attribute; 4835 for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute)) 4836 { 4837 tree name = TREE_PURPOSE (attribute); 4838 4839 if (is_attribute_p ("deprecated", name) 4840 || is_attribute_p ("sentinel", name) 4841 || is_attribute_p ("noreturn", name)) 4842 { 4843 /* An attribute that we support; add it to the filtered 4844 attributes. */ 4845 filtered_attributes = chainon (filtered_attributes, 4846 copy_node (attribute)); 4847 } 4848 else if (is_attribute_p ("format", name)) 4849 { 4850 /* "format" is special because before adding it to the 4851 filtered attributes we need to adjust the specified 4852 format by adding the hidden function parameters for 4853 an Objective-C method (self, _cmd). */ 4854 tree new_attribute = copy_node (attribute); 4855 4856 /* Check the arguments specified with the attribute, and 4857 modify them adding 2 for the two hidden arguments. 4858 Note how this differs from C++; according to the 4859 specs, C++ does not do it so you have to add the +1 4860 yourself. For Objective-C, instead, the compiler 4861 adds the +2 for you. */ 4862 4863 /* The attribute arguments have not been checked yet, so 4864 we need to be careful as they could be missing or 4865 invalid. If anything looks wrong, we skip the 4866 process and the compiler will complain about it later 4867 when it validates the attribute. */ 4868 /* Check that we have at least three arguments. */ 4869 if (TREE_VALUE (new_attribute) 4870 && TREE_CHAIN (TREE_VALUE (new_attribute)) 4871 && TREE_CHAIN (TREE_CHAIN (TREE_VALUE (new_attribute)))) 4872 { 4873 tree second_argument = TREE_CHAIN (TREE_VALUE (new_attribute)); 4874 tree third_argument = TREE_CHAIN (second_argument); 4875 tree number; 4876 4877 /* This is the second argument, the "string-index", 4878 which specifies the index of the format string 4879 argument. Add 2. */ 4880 number = TREE_VALUE (second_argument); 4881 if (number 4882 && TREE_CODE (number) == INTEGER_CST 4883 && TREE_INT_CST_HIGH (number) == 0) 4884 { 4885 TREE_VALUE (second_argument) 4886 = build_int_cst (integer_type_node, 4887 TREE_INT_CST_LOW (number) + 2); 4888 } 4889 4890 /* This is the third argument, the "first-to-check", 4891 which specifies the index of the first argument to 4892 check. This could be 0, meaning it is not available, 4893 in which case we don't need to add 2. Add 2 if not 4894 0. */ 4895 number = TREE_VALUE (third_argument); 4896 if (number 4897 && TREE_CODE (number) == INTEGER_CST 4898 && TREE_INT_CST_HIGH (number) == 0 4899 && TREE_INT_CST_LOW (number) != 0) 4900 { 4901 TREE_VALUE (third_argument) 4902 = build_int_cst (integer_type_node, 4903 TREE_INT_CST_LOW (number) + 2); 4904 } 4905 } 4906 filtered_attributes = chainon (filtered_attributes, 4907 new_attribute); 4908 } 4909 else if (is_attribute_p ("nonnull", name)) 4910 { 4911 /* We need to fixup all the argument indexes by adding 2 4912 for the two hidden arguments of an Objective-C method 4913 invocation, similat to what we do above for the 4914 "format" attribute. */ 4915 /* FIXME: This works great in terms of implementing the 4916 functionality, but the warnings that are produced by 4917 nonnull do mention the argument index (while the 4918 format ones don't). For example, you could get 4919 "warning: null argument where non-null required 4920 (argument 3)". Now in that message, "argument 3" 4921 includes the 2 hidden arguments; it would be much 4922 more friendly to call it "argument 1", as that would 4923 be consistent with __attribute__ ((nonnnull (1))). 4924 To do this, we'd need to have the C family code that 4925 checks the arguments know about adding/removing 2 to 4926 the argument index ... or alternatively we could 4927 maybe store the "printable" argument index in 4928 addition to the actual argument index ? Some 4929 refactoring is needed to do this elegantly. */ 4930 tree new_attribute = copy_node (attribute); 4931 tree argument = TREE_VALUE (attribute); 4932 while (argument != NULL_TREE) 4933 { 4934 /* Get the value of the argument and add 2. */ 4935 tree number = TREE_VALUE (argument); 4936 if (number 4937 && TREE_CODE (number) == INTEGER_CST 4938 && TREE_INT_CST_HIGH (number) == 0 4939 && TREE_INT_CST_LOW (number) != 0) 4940 { 4941 TREE_VALUE (argument) 4942 = build_int_cst (integer_type_node, 4943 TREE_INT_CST_LOW (number) + 2); 4944 } 4945 argument = TREE_CHAIN (argument); 4946 } 4947 4948 filtered_attributes = chainon (filtered_attributes, 4949 new_attribute); 4950 } 4951 else 4952 warning (OPT_Wattributes, "%qE attribute directive ignored", name); 4953 } 4954 } 4955 4956 if (filtered_attributes) 4957 { 4958 /* This hackery changes the TREE_TYPE of the ObjC method 4959 declaration to be a function type, so that decl_attributes 4960 will treat the ObjC method as if it was a function. Some 4961 attributes (sentinel, format) will be applied to the function 4962 type, changing it in place; so after calling decl_attributes, 4963 we extract the function type attributes and store them in 4964 METHOD_TYPE_ATTRIBUTES. Some other attributes (noreturn, 4965 deprecated) are applied directly to the method declaration 4966 (by setting TREE_DEPRECATED and TREE_THIS_VOLATILE) so there 4967 is nothing to do. */ 4968 tree saved_type = TREE_TYPE (*node); 4969 TREE_TYPE (*node) 4970 = build_function_type_for_method (TREE_VALUE (saved_type), *node, 4971 METHOD_REF, 0); 4972 decl_attributes (node, filtered_attributes, flags); 4973 METHOD_TYPE_ATTRIBUTES (*node) = TYPE_ATTRIBUTES (TREE_TYPE (*node)); 4974 TREE_TYPE (*node) = saved_type; 4975 } 4976 } 4977 4978 bool 4979 objc_method_decl (enum tree_code opcode) 4980 { 4981 return opcode == INSTANCE_METHOD_DECL || opcode == CLASS_METHOD_DECL; 4982 } 4983 4984 /* Return a function type for METHOD with RETURN_TYPE. CONTEXT is 4985 either METHOD_DEF or METHOD_REF, indicating whether we are defining a 4986 method or calling one. SUPER_FLAG indicates whether this is a send 4987 to super; this makes a difference for the NeXT calling sequence in 4988 which the lookup and the method call are done together. If METHOD is 4989 NULL, user-defined arguments (i.e., beyond self and _cmd) shall be 4990 represented as varargs. */ 4991 4992 tree 4993 build_function_type_for_method (tree return_type, tree method, 4994 int context, bool super_flag) 4995 { 4996 VEC(tree,gc) *argtypes = make_tree_vector (); 4997 tree t, ftype; 4998 bool is_varargs = false; 4999 5000 (*runtime.get_arg_type_list_base) (&argtypes, method, context, super_flag); 5001 5002 /* No actual method prototype given; remaining args passed as varargs. */ 5003 if (method == NULL_TREE) 5004 { 5005 is_varargs = true; 5006 goto build_ftype; 5007 } 5008 5009 for (t = METHOD_SEL_ARGS (method); t; t = DECL_CHAIN (t)) 5010 { 5011 tree arg_type = TREE_VALUE (TREE_TYPE (t)); 5012 5013 /* Decay argument types for the underlying C function as 5014 appropriate. */ 5015 arg_type = objc_decay_parm_type (arg_type); 5016 5017 VEC_safe_push (tree, gc, argtypes, arg_type); 5018 } 5019 5020 if (METHOD_ADD_ARGS (method)) 5021 { 5022 for (t = TREE_CHAIN (METHOD_ADD_ARGS (method)); 5023 t; t = TREE_CHAIN (t)) 5024 { 5025 tree arg_type = TREE_TYPE (TREE_VALUE (t)); 5026 5027 arg_type = objc_decay_parm_type (arg_type); 5028 5029 VEC_safe_push (tree, gc, argtypes, arg_type); 5030 } 5031 5032 if (METHOD_ADD_ARGS_ELLIPSIS_P (method)) 5033 is_varargs = true; 5034 } 5035 5036 build_ftype: 5037 if (is_varargs) 5038 ftype = build_varargs_function_type_vec (return_type, argtypes); 5039 else 5040 ftype = build_function_type_vec (return_type, argtypes); 5041 5042 release_tree_vector (argtypes); 5043 return ftype; 5044 } 5045 5046 /* The 'method' argument is a tree; this tree could either be a single 5047 method, which is returned, or could be a TREE_VEC containing a list 5048 of methods. In that case, the first one is returned, and warnings 5049 are issued as appropriate. */ 5050 static tree 5051 check_duplicates (tree method, int methods, int is_class) 5052 { 5053 tree first_method; 5054 size_t i; 5055 5056 if (method == NULL_TREE) 5057 return NULL_TREE; 5058 5059 if (TREE_CODE (method) != TREE_VEC) 5060 return method; 5061 5062 /* We have two or more methods with the same name but different 5063 types. */ 5064 first_method = TREE_VEC_ELT (method, 0); 5065 5066 /* But just how different are those types? If 5067 -Wno-strict-selector-match is specified, we shall not complain if 5068 the differences are solely among types with identical size and 5069 alignment. */ 5070 if (!warn_strict_selector_match) 5071 { 5072 for (i = 0; i < (size_t) TREE_VEC_LENGTH (method); i++) 5073 if (!comp_proto_with_proto (first_method, TREE_VEC_ELT (method, i), 0)) 5074 goto issue_warning; 5075 5076 return first_method; 5077 } 5078 5079 issue_warning: 5080 if (methods) 5081 { 5082 bool type = TREE_CODE (first_method) == INSTANCE_METHOD_DECL; 5083 5084 warning_at (input_location, 0, 5085 "multiple methods named %<%c%E%> found", 5086 (is_class ? '+' : '-'), 5087 METHOD_SEL_NAME (first_method)); 5088 inform (DECL_SOURCE_LOCATION (first_method), "using %<%c%s%>", 5089 (type ? '-' : '+'), 5090 identifier_to_locale (gen_method_decl (first_method))); 5091 } 5092 else 5093 { 5094 bool type = TREE_CODE (first_method) == INSTANCE_METHOD_DECL; 5095 5096 warning_at (input_location, 0, 5097 "multiple selectors named %<%c%E%> found", 5098 (is_class ? '+' : '-'), 5099 METHOD_SEL_NAME (first_method)); 5100 inform (DECL_SOURCE_LOCATION (first_method), "found %<%c%s%>", 5101 (type ? '-' : '+'), 5102 identifier_to_locale (gen_method_decl (first_method))); 5103 } 5104 5105 for (i = 0; i < (size_t) TREE_VEC_LENGTH (method); i++) 5106 { 5107 bool type = TREE_CODE (TREE_VEC_ELT (method, i)) == INSTANCE_METHOD_DECL; 5108 5109 inform (DECL_SOURCE_LOCATION (TREE_VEC_ELT (method, i)), "also found %<%c%s%>", 5110 (type ? '-' : '+'), 5111 identifier_to_locale (gen_method_decl (TREE_VEC_ELT (method, i)))); 5112 } 5113 5114 return first_method; 5115 } 5116 5117 /* If RECEIVER is a class reference, return the identifier node for 5118 the referenced class. RECEIVER is created by objc_get_class_reference, 5119 so we check the exact form created depending on which runtimes are 5120 used. */ 5121 5122 static tree 5123 receiver_is_class_object (tree receiver, int self, int super) 5124 { 5125 tree exp, arg; 5126 5127 /* The receiver is 'self' or 'super' in the context of a class method. */ 5128 if (objc_method_context 5129 && TREE_CODE (objc_method_context) == CLASS_METHOD_DECL 5130 && (self || super)) 5131 return (super 5132 ? CLASS_SUPER_NAME (implementation_template) 5133 : CLASS_NAME (implementation_template)); 5134 5135 /* The runtime might encapsulate things its own way. */ 5136 exp = (*runtime.receiver_is_class_object) (receiver); 5137 if (exp) 5138 return exp; 5139 5140 /* The receiver is a function call that returns an id. Check if 5141 it is a call to objc_getClass, if so, pick up the class name. 5142 5143 This is required by the GNU runtime, which compiles 5144 5145 [NSObject alloc] 5146 5147 into 5148 5149 [objc_get_class ("NSObject") alloc]; 5150 5151 and then, to check that the receiver responds to the +alloc 5152 method, needs to be able to determine that the objc_get_class() 5153 call returns the NSObject class and not just a generic Class 5154 pointer. 5155 5156 But, traditionally this is enabled for all runtimes, not just the 5157 GNU one, which means that the compiler is smarter than you'd 5158 expect when dealing with objc_getClass(). For example, with the 5159 Apple runtime, in the code 5160 5161 [objc_getClass ("NSObject") alloc]; 5162 5163 the compiler will recognize the objc_getClass() call as special 5164 (due to the code below) and so will know that +alloc is called on 5165 the 'NSObject' class, and can perform the corresponding checks. 5166 5167 Programmers can disable this behaviour by casting the results of 5168 objc_getClass() to 'Class' (this may seem weird because 5169 objc_getClass() is already declared to return 'Class', but the 5170 compiler treats it as a special function). This may be useful if 5171 the class is never declared, and the compiler would complain 5172 about a missing @interface for it. Then, you can do 5173 5174 [(Class)objc_getClass ("MyClassNeverDeclared") alloc]; 5175 5176 to silence the warnings. */ 5177 if (TREE_CODE (receiver) == CALL_EXPR 5178 && (exp = CALL_EXPR_FN (receiver)) 5179 && TREE_CODE (exp) == ADDR_EXPR 5180 && (exp = TREE_OPERAND (exp, 0)) 5181 && TREE_CODE (exp) == FUNCTION_DECL 5182 /* For some reason, we sometimes wind up with multiple FUNCTION_DECL 5183 prototypes for objc_get_class(). Thankfully, they seem to share the 5184 same function type. */ 5185 && TREE_TYPE (exp) == TREE_TYPE (objc_get_class_decl) 5186 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp)), runtime.tag_getclass) 5187 /* We have a call to objc_get_class/objc_getClass! */ 5188 && (arg = CALL_EXPR_ARG (receiver, 0))) 5189 { 5190 STRIP_NOPS (arg); 5191 if (TREE_CODE (arg) == ADDR_EXPR 5192 && (arg = TREE_OPERAND (arg, 0)) 5193 && TREE_CODE (arg) == STRING_CST) 5194 /* Finally, we have the class name. */ 5195 return get_identifier (TREE_STRING_POINTER (arg)); 5196 } 5197 return 0; 5198 } 5199 5200 /* If we are currently building a message expr, this holds 5201 the identifier of the selector of the message. This is 5202 used when printing warnings about argument mismatches. */ 5203 5204 static tree current_objc_message_selector = 0; 5205 5206 tree 5207 objc_message_selector (void) 5208 { 5209 return current_objc_message_selector; 5210 } 5211 5212 /* Construct an expression for sending a message. 5213 MESS has the object to send to in TREE_PURPOSE 5214 and the argument list (including selector) in TREE_VALUE. 5215 5216 (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...); 5217 (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */ 5218 5219 tree 5220 objc_build_message_expr (tree receiver, tree message_args) 5221 { 5222 tree sel_name; 5223 #ifdef OBJCPLUS 5224 tree args = TREE_PURPOSE (message_args); 5225 #else 5226 tree args = message_args; 5227 #endif 5228 tree method_params = NULL_TREE; 5229 5230 if (TREE_CODE (receiver) == ERROR_MARK || TREE_CODE (args) == ERROR_MARK) 5231 return error_mark_node; 5232 5233 /* Obtain the full selector name. */ 5234 switch (TREE_CODE (args)) 5235 { 5236 case IDENTIFIER_NODE: 5237 /* A unary selector. */ 5238 sel_name = args; 5239 break; 5240 case TREE_LIST: 5241 sel_name = build_keyword_selector (args); 5242 break; 5243 default: 5244 gcc_unreachable (); 5245 } 5246 5247 /* Build the parameter list to give to the method. */ 5248 if (TREE_CODE (args) == TREE_LIST) 5249 #ifdef OBJCPLUS 5250 method_params = chainon (args, TREE_VALUE (message_args)); 5251 #else 5252 { 5253 tree chain = args, prev = NULL_TREE; 5254 5255 /* We have a keyword selector--check for comma expressions. */ 5256 while (chain) 5257 { 5258 tree element = TREE_VALUE (chain); 5259 5260 /* We have a comma expression, must collapse... */ 5261 if (TREE_CODE (element) == TREE_LIST) 5262 { 5263 if (prev) 5264 TREE_CHAIN (prev) = element; 5265 else 5266 args = element; 5267 } 5268 prev = chain; 5269 chain = TREE_CHAIN (chain); 5270 } 5271 method_params = args; 5272 } 5273 #endif 5274 5275 #ifdef OBJCPLUS 5276 if (processing_template_decl) 5277 /* Must wait until template instantiation time. */ 5278 return build_min_nt (MESSAGE_SEND_EXPR, receiver, sel_name, 5279 method_params); 5280 #endif 5281 5282 return objc_finish_message_expr (receiver, sel_name, method_params, NULL); 5283 } 5284 5285 /* Look up method SEL_NAME that would be suitable for receiver 5286 of type 'id' (if IS_CLASS is zero) or 'Class' (if IS_CLASS is 5287 nonzero), and report on any duplicates. */ 5288 5289 static tree 5290 lookup_method_in_hash_lists (tree sel_name, int is_class) 5291 { 5292 tree method_prototype = OBJC_MAP_NOT_FOUND; 5293 5294 if (!is_class) 5295 method_prototype = objc_map_get (instance_method_map, sel_name); 5296 5297 if (method_prototype == OBJC_MAP_NOT_FOUND) 5298 { 5299 method_prototype = objc_map_get (class_method_map, sel_name); 5300 is_class = 1; 5301 5302 if (method_prototype == OBJC_MAP_NOT_FOUND) 5303 return NULL_TREE; 5304 } 5305 5306 return check_duplicates (method_prototype, 1, is_class); 5307 } 5308 5309 /* The 'objc_finish_message_expr' routine is called from within 5310 'objc_build_message_expr' for non-template functions. In the case of 5311 C++ template functions, it is called from 'build_expr_from_tree' 5312 (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded. 5313 5314 If the DEPRECATED_METHOD_PROTOTYPE argument is NULL, then we warn 5315 if the method being used is deprecated. If it is not NULL, instead 5316 of deprecating, we set *DEPRECATED_METHOD_PROTOTYPE to the method 5317 prototype that was used and is deprecated. This is useful for 5318 getter calls that are always generated when compiling dot-syntax 5319 expressions, even if they may not be used. In that case, we don't 5320 want the warning immediately; we produce it (if needed) at gimplify 5321 stage when we are sure that the deprecated getter is being 5322 used. */ 5323 tree 5324 objc_finish_message_expr (tree receiver, tree sel_name, tree method_params, 5325 tree *deprecated_method_prototype) 5326 { 5327 tree method_prototype = NULL_TREE, rprotos = NULL_TREE, rtype; 5328 tree retval, class_tree; 5329 int self, super, have_cast; 5330 5331 /* We have used the receiver, so mark it as read. */ 5332 mark_exp_read (receiver); 5333 5334 /* Extract the receiver of the message, as well as its type 5335 (where the latter may take the form of a cast or be inferred 5336 from the implementation context). */ 5337 rtype = receiver; 5338 while (TREE_CODE (rtype) == COMPOUND_EXPR 5339 || TREE_CODE (rtype) == MODIFY_EXPR 5340 || CONVERT_EXPR_P (rtype) 5341 || TREE_CODE (rtype) == COMPONENT_REF) 5342 rtype = TREE_OPERAND (rtype, 0); 5343 5344 /* self is 1 if this is a message to self, 0 otherwise */ 5345 self = (rtype == self_decl); 5346 5347 /* super is 1 if this is a message to super, 0 otherwise. */ 5348 super = (rtype == UOBJC_SUPER_decl); 5349 5350 /* rtype is the type of the receiver. */ 5351 rtype = TREE_TYPE (receiver); 5352 5353 /* have_cast is 1 if the receiver is casted. */ 5354 have_cast = (TREE_CODE (receiver) == NOP_EXPR 5355 || (TREE_CODE (receiver) == COMPOUND_EXPR 5356 && !IS_SUPER (rtype))); 5357 5358 /* If we are calling [super dealloc], reset our warning flag. */ 5359 if (super && !strcmp ("dealloc", IDENTIFIER_POINTER (sel_name))) 5360 should_call_super_dealloc = 0; 5361 5362 /* If the receiver is a class object, retrieve the corresponding 5363 @interface, if one exists. class_tree is the class name 5364 identifier, or NULL_TREE if this is not a class method or the 5365 class name could not be determined (as in the case "Class c; [c 5366 method];"). */ 5367 class_tree = receiver_is_class_object (receiver, self, super); 5368 5369 /* Now determine the receiver type (if an explicit cast has not been 5370 provided). */ 5371 if (!have_cast) 5372 { 5373 if (class_tree) 5374 { 5375 /* We are here when we have no cast, and we have a class 5376 name. So, this is a plain method to a class object, as 5377 in [NSObject alloc]. Find the interface corresponding to 5378 the class name. */ 5379 rtype = lookup_interface (class_tree); 5380 5381 if (rtype == NULL_TREE) 5382 { 5383 /* If 'rtype' is NULL_TREE at this point it means that 5384 we have seen no @interface corresponding to that 5385 class name, only a @class declaration (alternatively, 5386 this was a call such as [objc_getClass("SomeClass") 5387 alloc], where we've never seen the @interface of 5388 SomeClass). So, we have a class name (class_tree) 5389 but no actual details of the class methods. We won't 5390 be able to check that the class responds to the 5391 method, and we will have to guess the method 5392 prototype. Emit a warning, then keep going (this 5393 will use any method with a matching name, as if the 5394 receiver was of type 'Class'). */ 5395 warning (0, "@interface of class %qE not found", class_tree); 5396 } 5397 } 5398 /* Handle `self' and `super'. */ 5399 else if (super) 5400 { 5401 if (!CLASS_SUPER_NAME (implementation_template)) 5402 { 5403 error ("no super class declared in @interface for %qE", 5404 CLASS_NAME (implementation_template)); 5405 return error_mark_node; 5406 } 5407 rtype = lookup_interface (CLASS_SUPER_NAME (implementation_template)); 5408 } 5409 else if (self) 5410 rtype = lookup_interface (CLASS_NAME (implementation_template)); 5411 } 5412 5413 if (objc_is_id (rtype)) 5414 { 5415 /* The receiver is of type 'id' or 'Class' (with or without some 5416 protocols attached to it). */ 5417 5418 /* We set class_tree to the identifier for 'Class' if this is a 5419 class method, and to NULL_TREE if not. */ 5420 class_tree = (IS_CLASS (rtype) ? objc_class_name : NULL_TREE); 5421 5422 /* 'rprotos' is the list of protocols that the receiver 5423 supports. */ 5424 rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype)) 5425 ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype)) 5426 : NULL_TREE); 5427 5428 /* We have no information on the type, and we set it to 5429 NULL_TREE. */ 5430 rtype = NULL_TREE; 5431 5432 /* If there are any protocols, check that the method we are 5433 calling appears in the protocol list. If there are no 5434 protocols, this is a message to 'id' or 'Class' and we accept 5435 any method that exists. */ 5436 if (rprotos) 5437 { 5438 /* If messaging 'id <Protos>' or 'Class <Proto>', first 5439 search in protocols themselves for the method 5440 prototype. */ 5441 method_prototype 5442 = lookup_method_in_protocol_list (rprotos, sel_name, 5443 class_tree != NULL_TREE); 5444 5445 /* If messaging 'Class <Proto>' but did not find a class 5446 method prototype, search for an instance method instead, 5447 and warn about having done so. */ 5448 if (!method_prototype && !rtype && class_tree != NULL_TREE) 5449 { 5450 method_prototype 5451 = lookup_method_in_protocol_list (rprotos, sel_name, 0); 5452 5453 if (method_prototype) 5454 warning (0, "found %<-%E%> instead of %<+%E%> in protocol(s)", 5455 sel_name, sel_name); 5456 } 5457 } 5458 } 5459 else if (rtype) 5460 { 5461 /* We have a receiver type which is more specific than 'id' or 5462 'Class'. */ 5463 tree orig_rtype = rtype; 5464 5465 if (TREE_CODE (rtype) == POINTER_TYPE) 5466 rtype = TREE_TYPE (rtype); 5467 /* Traverse typedef aliases */ 5468 while (TREE_CODE (rtype) == RECORD_TYPE && OBJC_TYPE_NAME (rtype) 5469 && TREE_CODE (OBJC_TYPE_NAME (rtype)) == TYPE_DECL 5470 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype))) 5471 rtype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype)); 5472 if (TYPED_OBJECT (rtype)) 5473 { 5474 rprotos = TYPE_OBJC_PROTOCOL_LIST (rtype); 5475 rtype = TYPE_OBJC_INTERFACE (rtype); 5476 } 5477 if (!rtype || TREE_CODE (rtype) == IDENTIFIER_NODE) 5478 { 5479 /* If we could not find an @interface declaration, we must 5480 have only seen a @class declaration; so, we cannot say 5481 anything more intelligent about which methods the 5482 receiver will understand. Note that this only happens 5483 for instance methods; for class methods to a class where 5484 we have only seen a @class declaration, 5485 lookup_interface() above would have set rtype to 5486 NULL_TREE. */ 5487 if (rprotos) 5488 { 5489 /* We could not find an @interface declaration, yet, if 5490 there are protocols attached to the type, we can 5491 still look up the method in the protocols. Ie, we 5492 are in the following case: 5493 5494 @class MyClass; 5495 MyClass<MyProtocol> *x; 5496 [x method]; 5497 5498 If 'MyProtocol' has the method 'method', we can check 5499 and retrieve the method prototype. */ 5500 method_prototype 5501 = lookup_method_in_protocol_list (rprotos, sel_name, 0); 5502 5503 /* At this point, if we have found the method_prototype, 5504 we are quite happy. The details of the class are 5505 irrelevant. If we haven't found it, a warning will 5506 have been produced that the method could not be found 5507 in the protocol, and we won't produce further 5508 warnings (please note that this means that "@class 5509 MyClass; MyClass <MyProtocol> *x;" is exactly 5510 equivalent to "id <MyProtocol> x", which isn't too 5511 satisfactory but it's not easy to see how to do 5512 better). */ 5513 } 5514 else 5515 { 5516 if (rtype) 5517 { 5518 /* We could not find an @interface declaration, and 5519 there are no protocols attached to the receiver, 5520 so we can't complete the check that the receiver 5521 responds to the method, and we can't retrieve the 5522 method prototype. But, because the receiver has 5523 a well-specified class, the programmer did want 5524 this check to be performed. Emit a warning, then 5525 keep going as if it was an 'id'. To remove the 5526 warning, either include an @interface for the 5527 class, or cast the receiver to 'id'. Note that 5528 rtype is an IDENTIFIER_NODE at this point. */ 5529 warning (0, "@interface of class %qE not found", rtype); 5530 } 5531 } 5532 5533 rtype = NULL_TREE; 5534 } 5535 else if (TREE_CODE (rtype) == CLASS_INTERFACE_TYPE 5536 || TREE_CODE (rtype) == CLASS_IMPLEMENTATION_TYPE) 5537 { 5538 /* We have a valid ObjC class name with an associated 5539 @interface. Look up the method name in the published 5540 @interface for the class (and its superclasses). */ 5541 method_prototype 5542 = lookup_method_static (rtype, sel_name, class_tree != NULL_TREE); 5543 5544 /* If the method was not found in the @interface, it may still 5545 exist locally as part of the @implementation. */ 5546 if (!method_prototype && objc_implementation_context 5547 && CLASS_NAME (objc_implementation_context) 5548 == OBJC_TYPE_NAME (rtype)) 5549 method_prototype 5550 = lookup_method 5551 ((class_tree 5552 ? CLASS_CLS_METHODS (objc_implementation_context) 5553 : CLASS_NST_METHODS (objc_implementation_context)), 5554 sel_name); 5555 5556 /* If we haven't found a candidate method by now, try looking for 5557 it in the protocol list. */ 5558 if (!method_prototype && rprotos) 5559 method_prototype 5560 = lookup_method_in_protocol_list (rprotos, sel_name, 5561 class_tree != NULL_TREE); 5562 } 5563 else 5564 { 5565 /* We have a type, but it's not an Objective-C type (!). */ 5566 warning (0, "invalid receiver type %qs", 5567 identifier_to_locale (gen_type_name (orig_rtype))); 5568 /* After issuing the "invalid receiver" warning, perform method 5569 lookup as if we were messaging 'id'. */ 5570 rtype = rprotos = NULL_TREE; 5571 } 5572 } 5573 /* Note that rtype could also be NULL_TREE. This happens if we are 5574 messaging a class by name, but the class was only 5575 forward-declared using @class. */ 5576 5577 /* For 'id' or 'Class' receivers, search in the global hash table as 5578 a last resort. For all receivers, warn if protocol searches have 5579 failed. */ 5580 if (!method_prototype) 5581 { 5582 if (rprotos) 5583 warning (0, "%<%c%E%> not found in protocol(s)", 5584 (class_tree ? '+' : '-'), 5585 sel_name); 5586 5587 if (!rtype) 5588 method_prototype 5589 = lookup_method_in_hash_lists (sel_name, class_tree != NULL_TREE); 5590 } 5591 5592 if (!method_prototype) 5593 { 5594 static bool warn_missing_methods = false; 5595 5596 if (rtype) 5597 warning (0, "%qE may not respond to %<%c%E%>", 5598 OBJC_TYPE_NAME (rtype), 5599 (class_tree ? '+' : '-'), 5600 sel_name); 5601 /* If we are messaging an 'id' or 'Class' object and made it here, 5602 then we have failed to find _any_ instance or class method, 5603 respectively. */ 5604 else 5605 warning (0, "no %<%c%E%> method found", 5606 (class_tree ? '+' : '-'), 5607 sel_name); 5608 5609 if (!warn_missing_methods) 5610 { 5611 warning_at (input_location, 5612 0, "(Messages without a matching method signature"); 5613 warning_at (input_location, 5614 0, "will be assumed to return %<id%> and accept"); 5615 warning_at (input_location, 5616 0, "%<...%> as arguments.)"); 5617 warn_missing_methods = true; 5618 } 5619 } 5620 else 5621 { 5622 /* Warn if the method is deprecated, but not if the receiver is 5623 a generic 'id'. 'id' is used to cast an object to a generic 5624 object of an unspecified class; in that case, we'll use 5625 whatever method prototype we can find to get the method 5626 argument and return types, but it is not appropriate to 5627 produce deprecation warnings since we don't know the class 5628 that the object will be of at runtime. The @interface(s) for 5629 that class may not even be available to the compiler right 5630 now, and it is perfectly possible that the method is marked 5631 as non-deprecated in such @interface(s). 5632 5633 In practice this makes sense since casting an object to 'id' 5634 is often used precisely to turn off warnings associated with 5635 the object being of a particular class. */ 5636 if (TREE_DEPRECATED (method_prototype) && rtype != NULL_TREE) 5637 { 5638 if (deprecated_method_prototype) 5639 *deprecated_method_prototype = method_prototype; 5640 else 5641 warn_deprecated_use (method_prototype, NULL_TREE); 5642 } 5643 } 5644 5645 /* Save the selector name for printing error messages. */ 5646 current_objc_message_selector = sel_name; 5647 5648 /* Build the method call. 5649 TODO: Get the location from somewhere that will work for delayed 5650 expansion. */ 5651 5652 retval = (*runtime.build_objc_method_call) (input_location, method_prototype, 5653 receiver, rtype, sel_name, 5654 method_params, super); 5655 5656 current_objc_message_selector = 0; 5657 5658 return retval; 5659 } 5660 5661 5662 /* This routine creates a static variable used to implement @protocol(MyProtocol) 5663 expression. This variable will be initialized to global protocol_t meta-data 5664 pointer. */ 5665 5666 /* This function is called by the parser when (and only when) a 5667 @protocol() expression is found, in order to compile it. */ 5668 tree 5669 objc_build_protocol_expr (tree protoname) 5670 { 5671 tree p = lookup_protocol (protoname, /* warn if deprecated */ true, 5672 /* definition_required */ false); 5673 5674 if (!p) 5675 { 5676 error ("cannot find protocol declaration for %qE", protoname); 5677 return error_mark_node; 5678 } 5679 5680 return (*runtime.get_protocol_reference) (input_location, p); 5681 } 5682 5683 /* This function is called by the parser when a @selector() expression 5684 is found, in order to compile it. It is only called by the parser 5685 and only to compile a @selector(). LOC is the location of the 5686 @selector. */ 5687 tree 5688 objc_build_selector_expr (location_t loc, tree selnamelist) 5689 { 5690 tree selname; 5691 5692 /* Obtain the full selector name. */ 5693 switch (TREE_CODE (selnamelist)) 5694 { 5695 case IDENTIFIER_NODE: 5696 /* A unary selector. */ 5697 selname = selnamelist; 5698 break; 5699 case TREE_LIST: 5700 selname = build_keyword_selector (selnamelist); 5701 break; 5702 default: 5703 gcc_unreachable (); 5704 } 5705 5706 /* If we are required to check @selector() expressions as they 5707 are found, check that the selector has been declared. */ 5708 if (warn_undeclared_selector) 5709 { 5710 /* Look the selector up in the list of all known class and 5711 instance methods (up to this line) to check that the selector 5712 exists. */ 5713 tree method; 5714 5715 /* First try with instance methods. */ 5716 method = objc_map_get (instance_method_map, selname); 5717 5718 /* If not found, try with class methods. */ 5719 if (method == OBJC_MAP_NOT_FOUND) 5720 { 5721 method = objc_map_get (class_method_map, selname); 5722 5723 /* If still not found, print out a warning. */ 5724 if (method == OBJC_MAP_NOT_FOUND) 5725 warning (0, "undeclared selector %qE", selname); 5726 } 5727 } 5728 5729 /* The runtimes do this differently, most particularly, GNU has typed 5730 selectors, whilst NeXT does not. */ 5731 return (*runtime.build_selector_reference) (loc, selname, NULL_TREE); 5732 } 5733 5734 static tree 5735 build_ivar_reference (tree id) 5736 { 5737 tree base; 5738 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL) 5739 { 5740 /* Historically, a class method that produced objects (factory 5741 method) would assign `self' to the instance that it 5742 allocated. This would effectively turn the class method into 5743 an instance method. Following this assignment, the instance 5744 variables could be accessed. That practice, while safe, 5745 violates the simple rule that a class method should not refer 5746 to an instance variable. It's better to catch the cases 5747 where this is done unknowingly than to support the above 5748 paradigm. */ 5749 warning (0, "instance variable %qE accessed in class method", 5750 id); 5751 self_decl = convert (objc_instance_type, self_decl); /* cast */ 5752 } 5753 5754 base = build_indirect_ref (input_location, self_decl, RO_ARROW); 5755 return (*runtime.build_ivar_reference) (input_location, base, id); 5756 } 5757 5758 static void 5759 hash_init (void) 5760 { 5761 instance_method_map = objc_map_alloc_ggc (1000); 5762 class_method_map = objc_map_alloc_ggc (1000); 5763 5764 class_name_map = objc_map_alloc_ggc (200); 5765 alias_name_map = objc_map_alloc_ggc (200); 5766 5767 /* Initialize the hash table used to hold the constant string objects. */ 5768 string_htab = htab_create_ggc (31, string_hash, 5769 string_eq, NULL); 5770 } 5771 5772 /* Use the following to add a method to class_method_map or 5773 instance_method_map. It will add the method, keyed by the 5774 METHOD_SEL_NAME. If the method already exists, but with one or 5775 more different prototypes, it will store a TREE_VEC in the map, 5776 with the method prototypes in the vector. */ 5777 static void 5778 insert_method_into_method_map (bool class_method, tree method) 5779 { 5780 tree method_name = METHOD_SEL_NAME (method); 5781 tree existing_entry; 5782 objc_map_t map; 5783 5784 if (class_method) 5785 map = class_method_map; 5786 else 5787 map = instance_method_map; 5788 5789 /* Check if the method already exists in the map. */ 5790 existing_entry = objc_map_get (map, method_name); 5791 5792 /* If not, we simply add it to the map. */ 5793 if (existing_entry == OBJC_MAP_NOT_FOUND) 5794 objc_map_put (map, method_name, method); 5795 else 5796 { 5797 tree new_entry; 5798 5799 /* If an entry already exists, it's more complicated. We'll 5800 have to check whether the method prototype is the same or 5801 not. */ 5802 if (TREE_CODE (existing_entry) != TREE_VEC) 5803 { 5804 /* If the method prototypes are the same, there is nothing 5805 to do. */ 5806 if (comp_proto_with_proto (method, existing_entry, 1)) 5807 return; 5808 5809 /* If not, create a vector to store both the method already 5810 in the map, and the new one that we are adding. */ 5811 new_entry = make_tree_vec (2); 5812 5813 TREE_VEC_ELT (new_entry, 0) = existing_entry; 5814 TREE_VEC_ELT (new_entry, 1) = method; 5815 } 5816 else 5817 { 5818 /* An entry already exists, and it's already a vector. This 5819 means that at least 2 different method prototypes were 5820 already found, and we're considering registering yet 5821 another one. */ 5822 size_t i; 5823 5824 /* Check all the existing prototypes. If any matches the 5825 one we need to add, there is nothing to do because it's 5826 already there. */ 5827 for (i = 0; i < (size_t) TREE_VEC_LENGTH (existing_entry); i++) 5828 if (comp_proto_with_proto (method, TREE_VEC_ELT (existing_entry, i), 1)) 5829 return; 5830 5831 /* Else, create a new, bigger vector and add the new method 5832 at the end of it. This is inefficient but extremely 5833 rare; in any sane program most methods have a single 5834 prototype, and very few, if any, will have more than 5835 2! */ 5836 new_entry = make_tree_vec (TREE_VEC_LENGTH (existing_entry) + 1); 5837 5838 /* Copy the methods from the existing vector. */ 5839 for (i = 0; i < (size_t) TREE_VEC_LENGTH (existing_entry); i++) 5840 TREE_VEC_ELT (new_entry, i) = TREE_VEC_ELT (existing_entry, i); 5841 5842 /* Add the new method at the end. */ 5843 TREE_VEC_ELT (new_entry, i) = method; 5844 } 5845 5846 /* Store the new vector in the map. */ 5847 objc_map_put (map, method_name, new_entry); 5848 } 5849 } 5850 5851 5852 static tree 5853 lookup_method (tree mchain, tree method) 5854 { 5855 tree key; 5856 5857 if (TREE_CODE (method) == IDENTIFIER_NODE) 5858 key = method; 5859 else 5860 key = METHOD_SEL_NAME (method); 5861 5862 while (mchain) 5863 { 5864 if (METHOD_SEL_NAME (mchain) == key) 5865 return mchain; 5866 5867 mchain = DECL_CHAIN (mchain); 5868 } 5869 return NULL_TREE; 5870 } 5871 5872 /* Look up a class (if OBJC_LOOKUP_CLASS is set in FLAGS) or instance 5873 method in INTERFACE, along with any categories and protocols 5874 attached thereto. If method is not found, and the 5875 OBJC_LOOKUP_NO_SUPER is _not_ set in FLAGS, recursively examine the 5876 INTERFACE's superclass. If OBJC_LOOKUP_CLASS is set, 5877 OBJC_LOOKUP_NO_SUPER is clear, and no suitable class method could 5878 be found in INTERFACE or any of its superclasses, look for an 5879 _instance_ method of the same name in the root class as a last 5880 resort. This behaviour can be turned off by using 5881 OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS. 5882 5883 If a suitable method cannot be found, return NULL_TREE. */ 5884 5885 static tree 5886 lookup_method_static (tree interface, tree ident, int flags) 5887 { 5888 tree meth = NULL_TREE, root_inter = NULL_TREE; 5889 tree inter = interface; 5890 int is_class = (flags & OBJC_LOOKUP_CLASS); 5891 int no_superclasses = (flags & OBJC_LOOKUP_NO_SUPER); 5892 int no_instance_methods_of_root_class = (flags & OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS); 5893 5894 while (inter) 5895 { 5896 tree chain = is_class ? CLASS_CLS_METHODS (inter) : CLASS_NST_METHODS (inter); 5897 tree category = inter; 5898 5899 /* First, look up the method in the class itself. */ 5900 if ((meth = lookup_method (chain, ident))) 5901 return meth; 5902 5903 /* Failing that, look for the method in each category of the class. */ 5904 while ((category = CLASS_CATEGORY_LIST (category))) 5905 { 5906 chain = is_class ? CLASS_CLS_METHODS (category) : CLASS_NST_METHODS (category); 5907 5908 /* Check directly in each category. */ 5909 if ((meth = lookup_method (chain, ident))) 5910 return meth; 5911 5912 /* Failing that, check in each category's protocols. */ 5913 if (CLASS_PROTOCOL_LIST (category)) 5914 { 5915 if ((meth = (lookup_method_in_protocol_list 5916 (CLASS_PROTOCOL_LIST (category), ident, is_class)))) 5917 return meth; 5918 } 5919 } 5920 5921 /* If not found in categories, check in protocols of the main class. */ 5922 if (CLASS_PROTOCOL_LIST (inter)) 5923 { 5924 if ((meth = (lookup_method_in_protocol_list 5925 (CLASS_PROTOCOL_LIST (inter), ident, is_class)))) 5926 return meth; 5927 } 5928 5929 /* If we were instructed not to look in superclasses, don't. */ 5930 if (no_superclasses) 5931 return NULL_TREE; 5932 5933 /* Failing that, climb up the inheritance hierarchy. */ 5934 root_inter = inter; 5935 inter = lookup_interface (CLASS_SUPER_NAME (inter)); 5936 } 5937 while (inter); 5938 5939 if (is_class && !no_instance_methods_of_root_class) 5940 { 5941 /* If no class (factory) method was found, check if an _instance_ 5942 method of the same name exists in the root class. This is what 5943 the Objective-C runtime will do. */ 5944 return lookup_method_static (root_inter, ident, 0); 5945 } 5946 else 5947 { 5948 /* If an instance method was not found, return 0. */ 5949 return NULL_TREE; 5950 } 5951 } 5952 5953 static tree 5954 objc_add_method (tree klass, tree method, int is_class, bool is_optional) 5955 { 5956 tree existing_method = NULL_TREE; 5957 5958 /* The first thing we do is look up the method in the list of 5959 methods already defined in the interface (or implementation). */ 5960 if (is_class) 5961 existing_method = lookup_method (CLASS_CLS_METHODS (klass), method); 5962 else 5963 existing_method = lookup_method (CLASS_NST_METHODS (klass), method); 5964 5965 /* In the case of protocols, we have a second list of methods to 5966 consider, the list of optional ones. */ 5967 if (TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE) 5968 { 5969 /* @required methods are added to the protocol's normal list. 5970 @optional methods are added to the protocol's OPTIONAL lists. 5971 Note that adding the methods to the optional lists disables 5972 checking that the methods are implemented by classes 5973 implementing the protocol, since these checks only use the 5974 CLASS_CLS_METHODS and CLASS_NST_METHODS. */ 5975 5976 /* First of all, if the method to add is @optional, and we found 5977 it already existing as @required, emit an error. */ 5978 if (is_optional && existing_method) 5979 { 5980 error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time", 5981 (is_class ? '+' : '-'), 5982 METHOD_SEL_NAME (existing_method)); 5983 inform (DECL_SOURCE_LOCATION (existing_method), 5984 "previous declaration of %<%c%E%> as %<@required%>", 5985 (is_class ? '+' : '-'), 5986 METHOD_SEL_NAME (existing_method)); 5987 } 5988 5989 /* Now check the list of @optional methods if we didn't find the 5990 method in the @required list. */ 5991 if (!existing_method) 5992 { 5993 if (is_class) 5994 existing_method = lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (klass), method); 5995 else 5996 existing_method = lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (klass), method); 5997 5998 if (!is_optional && existing_method) 5999 { 6000 error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time", 6001 (is_class ? '+' : '-'), 6002 METHOD_SEL_NAME (existing_method)); 6003 inform (DECL_SOURCE_LOCATION (existing_method), 6004 "previous declaration of %<%c%E%> as %<@optional%>", 6005 (is_class ? '+' : '-'), 6006 METHOD_SEL_NAME (existing_method)); 6007 } 6008 } 6009 } 6010 6011 /* If the method didn't exist already, add it. */ 6012 if (!existing_method) 6013 { 6014 if (is_optional) 6015 { 6016 if (is_class) 6017 { 6018 /* Put the method on the list in reverse order. */ 6019 TREE_CHAIN (method) = PROTOCOL_OPTIONAL_CLS_METHODS (klass); 6020 PROTOCOL_OPTIONAL_CLS_METHODS (klass) = method; 6021 } 6022 else 6023 { 6024 TREE_CHAIN (method) = PROTOCOL_OPTIONAL_NST_METHODS (klass); 6025 PROTOCOL_OPTIONAL_NST_METHODS (klass) = method; 6026 } 6027 } 6028 else 6029 { 6030 if (is_class) 6031 { 6032 DECL_CHAIN (method) = CLASS_CLS_METHODS (klass); 6033 CLASS_CLS_METHODS (klass) = method; 6034 } 6035 else 6036 { 6037 DECL_CHAIN (method) = CLASS_NST_METHODS (klass); 6038 CLASS_NST_METHODS (klass) = method; 6039 } 6040 } 6041 } 6042 else 6043 { 6044 /* The method was already defined. Check that the types match 6045 for an @interface for a class or category, or for a 6046 @protocol. Give hard errors on methods with identical 6047 selectors but differing argument and/or return types. We do 6048 not do this for @implementations, because C/C++ will do it 6049 for us (i.e., there will be duplicate function definition 6050 errors). */ 6051 if ((TREE_CODE (klass) == CLASS_INTERFACE_TYPE 6052 || TREE_CODE (klass) == CATEGORY_INTERFACE_TYPE 6053 /* Starting with GCC 4.6, we emit the same error for 6054 protocols too. The situation is identical to 6055 @interfaces as there is no possible meaningful reason 6056 for defining the same method with different signatures 6057 in the very same @protocol. If that was allowed, 6058 whenever the protocol is used (both at compile and run 6059 time) there wouldn't be any meaningful way to decide 6060 which of the two method signatures should be used. */ 6061 || TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE) 6062 && !comp_proto_with_proto (method, existing_method, 1)) 6063 { 6064 error ("duplicate declaration of method %<%c%E%> with conflicting types", 6065 (is_class ? '+' : '-'), 6066 METHOD_SEL_NAME (existing_method)); 6067 inform (DECL_SOURCE_LOCATION (existing_method), 6068 "previous declaration of %<%c%E%>", 6069 (is_class ? '+' : '-'), 6070 METHOD_SEL_NAME (existing_method)); 6071 } 6072 } 6073 6074 if (is_class) 6075 insert_method_into_method_map (true, method); 6076 else 6077 { 6078 insert_method_into_method_map (false, method); 6079 6080 /* Instance methods in root classes (and categories thereof) 6081 may act as class methods as a last resort. We also add 6082 instance methods listed in @protocol declarations to 6083 the class hash table, on the assumption that @protocols 6084 may be adopted by root classes or categories. */ 6085 if (TREE_CODE (klass) == CATEGORY_INTERFACE_TYPE 6086 || TREE_CODE (klass) == CATEGORY_IMPLEMENTATION_TYPE) 6087 klass = lookup_interface (CLASS_NAME (klass)); 6088 6089 if (TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE 6090 || !CLASS_SUPER_NAME (klass)) 6091 insert_method_into_method_map (true, method); 6092 } 6093 6094 return method; 6095 } 6096 6097 static void 6098 add_category (tree klass, tree category) 6099 { 6100 /* Put categories on list in reverse order. */ 6101 tree cat = lookup_category (klass, CLASS_SUPER_NAME (category)); 6102 6103 if (cat) 6104 { 6105 warning (0, "duplicate interface declaration for category %<%E(%E)%>", 6106 CLASS_NAME (klass), 6107 CLASS_SUPER_NAME (category)); 6108 } 6109 else 6110 { 6111 CLASS_CATEGORY_LIST (category) = CLASS_CATEGORY_LIST (klass); 6112 CLASS_CATEGORY_LIST (klass) = category; 6113 } 6114 } 6115 6116 #ifndef OBJCPLUS 6117 /* A flexible array member is a C99 extension where you can use 6118 "type[]" at the end of a struct to mean a variable-length array. 6119 6120 In Objective-C, instance variables are fundamentally members of a 6121 struct, but the struct can always be extended by subclassing; hence 6122 we need to detect and forbid all instance variables declared using 6123 flexible array members. 6124 6125 No check for this is needed in Objective-C++, since C++ does not 6126 have flexible array members. */ 6127 6128 /* Determine whether TYPE is a structure with a flexible array member, 6129 a union containing such a structure (possibly recursively) or an 6130 array of such structures or unions. These are all invalid as 6131 instance variable. */ 6132 static bool 6133 flexible_array_type_p (tree type) 6134 { 6135 tree x; 6136 switch (TREE_CODE (type)) 6137 { 6138 case RECORD_TYPE: 6139 x = TYPE_FIELDS (type); 6140 if (x == NULL_TREE) 6141 return false; 6142 while (DECL_CHAIN (x) != NULL_TREE) 6143 x = DECL_CHAIN (x); 6144 if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE 6145 && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE 6146 && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE 6147 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE) 6148 return true; 6149 return false; 6150 case UNION_TYPE: 6151 for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x)) 6152 { 6153 if (flexible_array_type_p (TREE_TYPE (x))) 6154 return true; 6155 } 6156 return false; 6157 /* Note that we also check for arrays of something that uses a flexible array member. */ 6158 case ARRAY_TYPE: 6159 if (flexible_array_type_p (TREE_TYPE (type))) 6160 return true; 6161 return false; 6162 default: 6163 return false; 6164 } 6165 } 6166 #endif 6167 6168 /* Produce a printable version of an ivar name. This is only used 6169 inside add_instance_variable. */ 6170 static const char * 6171 printable_ivar_name (tree field_decl) 6172 { 6173 if (DECL_NAME (field_decl)) 6174 return identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (field_decl))); 6175 else 6176 return _("<unnamed>"); 6177 } 6178 6179 /* Called after parsing each instance variable declaration. Necessary to 6180 preserve typedefs and implement public/private... 6181 6182 VISIBILITY is 1 for public, 0 for protected, and 2 for private. */ 6183 6184 static tree 6185 add_instance_variable (tree klass, objc_ivar_visibility_kind visibility, 6186 tree field_decl) 6187 { 6188 tree field_type = TREE_TYPE (field_decl); 6189 6190 #ifdef OBJCPLUS 6191 if (TREE_CODE (field_type) == REFERENCE_TYPE) 6192 { 6193 error ("illegal reference type specified for instance variable %qs", 6194 printable_ivar_name (field_decl)); 6195 /* Return class as is without adding this ivar. */ 6196 return klass; 6197 } 6198 #endif 6199 6200 if (field_type == error_mark_node || !TYPE_SIZE (field_type) 6201 || TYPE_SIZE (field_type) == error_mark_node) 6202 /* 'type[0]' is allowed, but 'type[]' is not! */ 6203 { 6204 error ("instance variable %qs has unknown size", 6205 printable_ivar_name (field_decl)); 6206 /* Return class as is without adding this ivar. */ 6207 return klass; 6208 } 6209 6210 #ifndef OBJCPLUS 6211 /* Also, in C reject a struct with a flexible array member. Ie, 6212 6213 struct A { int x; int[] y; }; 6214 6215 @interface X 6216 { 6217 struct A instance_variable; 6218 } 6219 @end 6220 6221 is not valid because if the class is subclassed, we wouldn't be able 6222 to calculate the offset of the next instance variable. */ 6223 if (flexible_array_type_p (field_type)) 6224 { 6225 error ("instance variable %qs uses flexible array member", 6226 printable_ivar_name (field_decl)); 6227 /* Return class as is without adding this ivar. */ 6228 return klass; 6229 } 6230 #endif 6231 6232 #ifdef OBJCPLUS 6233 /* Check if the ivar being added has a non-POD C++ type. If so, we will 6234 need to either (1) warn the user about it or (2) generate suitable 6235 constructor/destructor call from '- .cxx_construct' or '- .cxx_destruct' 6236 methods (if '-fobjc-call-cxx-cdtors' was specified). */ 6237 if (MAYBE_CLASS_TYPE_P (field_type) 6238 && (TYPE_NEEDS_CONSTRUCTING (field_type) 6239 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type) 6240 || TYPE_POLYMORPHIC_P (field_type))) 6241 { 6242 tree type_name = OBJC_TYPE_NAME (field_type); 6243 6244 if (flag_objc_call_cxx_cdtors) 6245 { 6246 /* Since the ObjC runtime will be calling the constructors and 6247 destructors for us, the only thing we can't handle is the lack 6248 of a default constructor. */ 6249 if (TYPE_NEEDS_CONSTRUCTING (field_type) 6250 && !TYPE_HAS_DEFAULT_CONSTRUCTOR (field_type)) 6251 { 6252 warning (0, "type %qE has no default constructor to call", 6253 type_name); 6254 6255 /* If we cannot call a constructor, we should also avoid 6256 calling the destructor, for symmetry. */ 6257 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type)) 6258 warning (0, "destructor for %qE shall not be run either", 6259 type_name); 6260 } 6261 } 6262 else 6263 { 6264 static bool warn_cxx_ivars = false; 6265 6266 if (TYPE_POLYMORPHIC_P (field_type)) 6267 { 6268 /* Vtable pointers are Real Bad(tm), since Obj-C cannot 6269 initialize them. */ 6270 error ("type %qE has virtual member functions", type_name); 6271 error ("illegal aggregate type %qE specified " 6272 "for instance variable %qs", 6273 type_name, printable_ivar_name (field_decl)); 6274 /* Return class as is without adding this ivar. */ 6275 return klass; 6276 } 6277 6278 /* User-defined constructors and destructors are not known to Obj-C 6279 and hence will not be called. This may or may not be a problem. */ 6280 if (TYPE_NEEDS_CONSTRUCTING (field_type)) 6281 warning (0, "type %qE has a user-defined constructor", type_name); 6282 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type)) 6283 warning (0, "type %qE has a user-defined destructor", type_name); 6284 6285 if (!warn_cxx_ivars) 6286 { 6287 warning (0, "C++ constructors and destructors will not " 6288 "be invoked for Objective-C fields"); 6289 warn_cxx_ivars = true; 6290 } 6291 } 6292 } 6293 #endif 6294 6295 /* Overload the public attribute, it is not used for FIELD_DECLs. */ 6296 switch (visibility) 6297 { 6298 case OBJC_IVAR_VIS_PROTECTED: 6299 TREE_PUBLIC (field_decl) = 0; 6300 TREE_PRIVATE (field_decl) = 0; 6301 TREE_PROTECTED (field_decl) = 1; 6302 break; 6303 6304 case OBJC_IVAR_VIS_PACKAGE: 6305 /* TODO: Implement the package variant. */ 6306 case OBJC_IVAR_VIS_PUBLIC: 6307 TREE_PUBLIC (field_decl) = 1; 6308 TREE_PRIVATE (field_decl) = 0; 6309 TREE_PROTECTED (field_decl) = 0; 6310 break; 6311 6312 case OBJC_IVAR_VIS_PRIVATE: 6313 TREE_PUBLIC (field_decl) = 0; 6314 TREE_PRIVATE (field_decl) = 1; 6315 TREE_PROTECTED (field_decl) = 0; 6316 break; 6317 6318 } 6319 6320 CLASS_RAW_IVARS (klass) = chainon (CLASS_RAW_IVARS (klass), field_decl); 6321 6322 return klass; 6323 } 6324 6325 /* True if the ivar is private and we are not in its implementation. */ 6326 6327 static int 6328 is_private (tree decl) 6329 { 6330 return (TREE_PRIVATE (decl) 6331 && ! is_ivar (CLASS_IVARS (implementation_template), 6332 DECL_NAME (decl))); 6333 } 6334 6335 /* Searches all the instance variables of 'klass' and of its 6336 superclasses for an instance variable whose name (identifier) is 6337 'ivar_name_ident'. Return the declaration (DECL) of the instance 6338 variable, if found, or NULL_TREE, if not found. */ 6339 static inline tree 6340 ivar_of_class (tree klass, tree ivar_name_ident) 6341 { 6342 /* First, look up the ivar in CLASS_RAW_IVARS. */ 6343 tree decl_chain = CLASS_RAW_IVARS (klass); 6344 6345 for ( ; decl_chain; decl_chain = DECL_CHAIN (decl_chain)) 6346 if (DECL_NAME (decl_chain) == ivar_name_ident) 6347 return decl_chain; 6348 6349 /* If not found, search up the class hierarchy. */ 6350 while (CLASS_SUPER_NAME (klass)) 6351 { 6352 klass = lookup_interface (CLASS_SUPER_NAME (klass)); 6353 6354 decl_chain = CLASS_RAW_IVARS (klass); 6355 6356 for ( ; decl_chain; decl_chain = DECL_CHAIN (decl_chain)) 6357 if (DECL_NAME (decl_chain) == ivar_name_ident) 6358 return decl_chain; 6359 } 6360 6361 return NULL_TREE; 6362 } 6363 6364 /* We have an instance variable reference;, check to see if it is public. */ 6365 6366 int 6367 objc_is_public (tree expr, tree identifier) 6368 { 6369 tree basetype, decl; 6370 6371 #ifdef OBJCPLUS 6372 if (processing_template_decl) 6373 return 1; 6374 #endif 6375 6376 if (TREE_TYPE (expr) == error_mark_node) 6377 return 1; 6378 6379 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr)); 6380 6381 if (basetype && TREE_CODE (basetype) == RECORD_TYPE) 6382 { 6383 if (TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype)) 6384 { 6385 tree klass = lookup_interface (OBJC_TYPE_NAME (basetype)); 6386 6387 if (!klass) 6388 { 6389 error ("cannot find interface declaration for %qE", 6390 OBJC_TYPE_NAME (basetype)); 6391 return 0; 6392 } 6393 6394 if ((decl = ivar_of_class (klass, identifier))) 6395 { 6396 if (TREE_PUBLIC (decl)) 6397 return 1; 6398 6399 /* Important difference between the Stepstone translator: 6400 all instance variables should be public within the context 6401 of the implementation. */ 6402 if (objc_implementation_context 6403 && ((TREE_CODE (objc_implementation_context) 6404 == CLASS_IMPLEMENTATION_TYPE) 6405 || (TREE_CODE (objc_implementation_context) 6406 == CATEGORY_IMPLEMENTATION_TYPE))) 6407 { 6408 tree curtype = TYPE_MAIN_VARIANT 6409 (CLASS_STATIC_TEMPLATE 6410 (implementation_template)); 6411 6412 if (basetype == curtype 6413 || DERIVED_FROM_P (basetype, curtype)) 6414 { 6415 int priv = is_private (decl); 6416 6417 if (priv) 6418 error ("instance variable %qE is declared private", 6419 DECL_NAME (decl)); 6420 6421 return !priv; 6422 } 6423 } 6424 6425 /* The 2.95.2 compiler sometimes allowed C functions to access 6426 non-@public ivars. We will let this slide for now... */ 6427 if (!objc_method_context) 6428 { 6429 warning (0, "instance variable %qE is %s; " 6430 "this will be a hard error in the future", 6431 identifier, 6432 TREE_PRIVATE (decl) ? "@private" : "@protected"); 6433 return 1; 6434 } 6435 6436 error ("instance variable %qE is declared %s", 6437 identifier, 6438 TREE_PRIVATE (decl) ? "private" : "protected"); 6439 return 0; 6440 } 6441 } 6442 } 6443 6444 return 1; 6445 } 6446 6447 /* Make sure all methods in CHAIN (a list of method declarations from 6448 an @interface or a @protocol) are in IMPLEMENTATION (the 6449 implementation context). This is used to check for example that 6450 all methods declared in an @interface were implemented in an 6451 @implementation. 6452 6453 Some special methods (property setters/getters) are special and if 6454 they are not found in IMPLEMENTATION, we look them up in its 6455 superclasses. */ 6456 6457 static int 6458 check_methods (tree chain, tree implementation, int mtype) 6459 { 6460 int first = 1; 6461 tree list; 6462 6463 if (mtype == (int)'+') 6464 list = CLASS_CLS_METHODS (implementation); 6465 else 6466 list = CLASS_NST_METHODS (implementation); 6467 6468 while (chain) 6469 { 6470 /* If the method is associated with a dynamic property, then it 6471 is Ok not to have the method implementation, as it will be 6472 generated dynamically at runtime. To decide if the method is 6473 associated with a @dynamic property, we search the list of 6474 @synthesize and @dynamic for this implementation, and look 6475 for any @dynamic property with the same setter or getter name 6476 as this method. */ 6477 tree x; 6478 for (x = IMPL_PROPERTY_DECL (implementation); x; x = TREE_CHAIN (x)) 6479 if (PROPERTY_DYNAMIC (x) 6480 && (PROPERTY_GETTER_NAME (x) == METHOD_SEL_NAME (chain) 6481 || PROPERTY_SETTER_NAME (x) == METHOD_SEL_NAME (chain))) 6482 break; 6483 6484 if (x != NULL_TREE) 6485 { 6486 chain = TREE_CHAIN (chain); /* next method... */ 6487 continue; 6488 } 6489 6490 if (!lookup_method (list, chain)) 6491 { 6492 /* If the method is a property setter/getter, we'll still 6493 allow it to be missing if it is implemented by 6494 'interface' or any of its superclasses. */ 6495 tree property = METHOD_PROPERTY_CONTEXT (chain); 6496 if (property) 6497 { 6498 /* Note that since this is a property getter/setter, it 6499 is obviously an instance method. */ 6500 tree interface = NULL_TREE; 6501 6502 /* For a category, first check the main class 6503 @interface. */ 6504 if (TREE_CODE (implementation) == CATEGORY_IMPLEMENTATION_TYPE) 6505 { 6506 interface = lookup_interface (CLASS_NAME (implementation)); 6507 6508 /* If the method is found in the main class, it's Ok. */ 6509 if (lookup_method (CLASS_NST_METHODS (interface), chain)) 6510 { 6511 chain = DECL_CHAIN (chain); 6512 continue; 6513 } 6514 6515 /* Else, get the superclass. */ 6516 if (CLASS_SUPER_NAME (interface)) 6517 interface = lookup_interface (CLASS_SUPER_NAME (interface)); 6518 else 6519 interface = NULL_TREE; 6520 } 6521 6522 /* Get the superclass for classes. */ 6523 if (TREE_CODE (implementation) == CLASS_IMPLEMENTATION_TYPE) 6524 { 6525 if (CLASS_SUPER_NAME (implementation)) 6526 interface = lookup_interface (CLASS_SUPER_NAME (implementation)); 6527 else 6528 interface = NULL_TREE; 6529 } 6530 6531 /* Now, interface is the superclass, if any; go check it. */ 6532 if (interface) 6533 { 6534 if (lookup_method_static (interface, chain, 0)) 6535 { 6536 chain = DECL_CHAIN (chain); 6537 continue; 6538 } 6539 } 6540 /* Else, fall through - warn. */ 6541 } 6542 if (first) 6543 { 6544 switch (TREE_CODE (implementation)) 6545 { 6546 case CLASS_IMPLEMENTATION_TYPE: 6547 warning (0, "incomplete implementation of class %qE", 6548 CLASS_NAME (implementation)); 6549 break; 6550 case CATEGORY_IMPLEMENTATION_TYPE: 6551 warning (0, "incomplete implementation of category %qE", 6552 CLASS_SUPER_NAME (implementation)); 6553 break; 6554 default: 6555 gcc_unreachable (); 6556 } 6557 first = 0; 6558 } 6559 6560 warning (0, "method definition for %<%c%E%> not found", 6561 mtype, METHOD_SEL_NAME (chain)); 6562 } 6563 6564 chain = DECL_CHAIN (chain); 6565 } 6566 6567 return first; 6568 } 6569 6570 /* Check if KLASS, or its superclasses, explicitly conforms to PROTOCOL. */ 6571 6572 static int 6573 conforms_to_protocol (tree klass, tree protocol) 6574 { 6575 if (TREE_CODE (protocol) == PROTOCOL_INTERFACE_TYPE) 6576 { 6577 tree p = CLASS_PROTOCOL_LIST (klass); 6578 while (p && TREE_VALUE (p) != protocol) 6579 p = TREE_CHAIN (p); 6580 6581 if (!p) 6582 { 6583 tree super = (CLASS_SUPER_NAME (klass) 6584 ? lookup_interface (CLASS_SUPER_NAME (klass)) 6585 : NULL_TREE); 6586 int tmp = super ? conforms_to_protocol (super, protocol) : 0; 6587 if (!tmp) 6588 return 0; 6589 } 6590 } 6591 6592 return 1; 6593 } 6594 6595 /* Make sure all methods in CHAIN are accessible as MTYPE methods in 6596 CONTEXT. This is one of two mechanisms to check protocol integrity. */ 6597 6598 static int 6599 check_methods_accessible (tree chain, tree context, int mtype) 6600 { 6601 int first = 1; 6602 tree list; 6603 tree base_context = context; 6604 6605 while (chain) 6606 { 6607 /* If the method is associated with a dynamic property, then it 6608 is Ok not to have the method implementation, as it will be 6609 generated dynamically at runtime. Search for any @dynamic 6610 property with the same setter or getter name as this 6611 method. TODO: Use a hashtable lookup. */ 6612 tree x; 6613 for (x = IMPL_PROPERTY_DECL (base_context); x; x = TREE_CHAIN (x)) 6614 if (PROPERTY_DYNAMIC (x) 6615 && (PROPERTY_GETTER_NAME (x) == METHOD_SEL_NAME (chain) 6616 || PROPERTY_SETTER_NAME (x) == METHOD_SEL_NAME (chain))) 6617 break; 6618 6619 if (x != NULL_TREE) 6620 { 6621 chain = TREE_CHAIN (chain); /* next method... */ 6622 continue; 6623 } 6624 6625 context = base_context; 6626 while (context) 6627 { 6628 if (mtype == '+') 6629 list = CLASS_CLS_METHODS (context); 6630 else 6631 list = CLASS_NST_METHODS (context); 6632 6633 if (lookup_method (list, chain)) 6634 break; 6635 6636 switch (TREE_CODE (context)) 6637 { 6638 case CLASS_IMPLEMENTATION_TYPE: 6639 case CLASS_INTERFACE_TYPE: 6640 context = (CLASS_SUPER_NAME (context) 6641 ? lookup_interface (CLASS_SUPER_NAME (context)) 6642 : NULL_TREE); 6643 break; 6644 case CATEGORY_IMPLEMENTATION_TYPE: 6645 case CATEGORY_INTERFACE_TYPE: 6646 context = (CLASS_NAME (context) 6647 ? lookup_interface (CLASS_NAME (context)) 6648 : NULL_TREE); 6649 break; 6650 default: 6651 gcc_unreachable (); 6652 } 6653 } 6654 6655 if (context == NULL_TREE) 6656 { 6657 if (first) 6658 { 6659 switch (TREE_CODE (objc_implementation_context)) 6660 { 6661 case CLASS_IMPLEMENTATION_TYPE: 6662 warning (0, "incomplete implementation of class %qE", 6663 CLASS_NAME (objc_implementation_context)); 6664 break; 6665 case CATEGORY_IMPLEMENTATION_TYPE: 6666 warning (0, "incomplete implementation of category %qE", 6667 CLASS_SUPER_NAME (objc_implementation_context)); 6668 break; 6669 default: 6670 gcc_unreachable (); 6671 } 6672 first = 0; 6673 } 6674 warning (0, "method definition for %<%c%E%> not found", 6675 mtype, METHOD_SEL_NAME (chain)); 6676 } 6677 6678 chain = TREE_CHAIN (chain); /* next method... */ 6679 } 6680 return first; 6681 } 6682 6683 /* Check whether the current interface (accessible via 6684 'objc_implementation_context') actually implements protocol P, along 6685 with any protocols that P inherits. */ 6686 6687 static void 6688 check_protocol (tree p, const char *type, tree name) 6689 { 6690 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE) 6691 { 6692 int f1, f2; 6693 6694 /* Ensure that all protocols have bodies! */ 6695 if (warn_protocol) 6696 { 6697 f1 = check_methods (PROTOCOL_CLS_METHODS (p), 6698 objc_implementation_context, 6699 '+'); 6700 f2 = check_methods (PROTOCOL_NST_METHODS (p), 6701 objc_implementation_context, 6702 '-'); 6703 } 6704 else 6705 { 6706 f1 = check_methods_accessible (PROTOCOL_CLS_METHODS (p), 6707 objc_implementation_context, 6708 '+'); 6709 f2 = check_methods_accessible (PROTOCOL_NST_METHODS (p), 6710 objc_implementation_context, 6711 '-'); 6712 } 6713 6714 if (!f1 || !f2) 6715 warning (0, "%s %qE does not fully implement the %qE protocol", 6716 type, name, PROTOCOL_NAME (p)); 6717 } 6718 6719 /* Check protocols recursively. */ 6720 if (PROTOCOL_LIST (p)) 6721 { 6722 tree subs = PROTOCOL_LIST (p); 6723 tree super_class = 6724 lookup_interface (CLASS_SUPER_NAME (implementation_template)); 6725 6726 while (subs) 6727 { 6728 tree sub = TREE_VALUE (subs); 6729 6730 /* If the superclass does not conform to the protocols 6731 inherited by P, then we must! */ 6732 if (!super_class || !conforms_to_protocol (super_class, sub)) 6733 check_protocol (sub, type, name); 6734 subs = TREE_CHAIN (subs); 6735 } 6736 } 6737 } 6738 6739 /* Check whether the current interface (accessible via 6740 'objc_implementation_context') actually implements the protocols listed 6741 in PROTO_LIST. */ 6742 6743 static void 6744 check_protocols (tree proto_list, const char *type, tree name) 6745 { 6746 for ( ; proto_list; proto_list = TREE_CHAIN (proto_list)) 6747 { 6748 tree p = TREE_VALUE (proto_list); 6749 6750 check_protocol (p, type, name); 6751 } 6752 } 6753 6754 /* Make sure that the class CLASS_NAME is defined CODE says which kind 6755 of thing CLASS_NAME ought to be. It can be CLASS_INTERFACE_TYPE, 6756 CLASS_IMPLEMENTATION_TYPE, CATEGORY_INTERFACE_TYPE, or 6757 CATEGORY_IMPLEMENTATION_TYPE. For a CATEGORY_INTERFACE_TYPE, 6758 SUPER_NAME is the name of the category. For a class extension, 6759 CODE is CATEGORY_INTERFACE_TYPE and SUPER_NAME is NULL_TREE. */ 6760 static tree 6761 start_class (enum tree_code code, tree class_name, tree super_name, 6762 tree protocol_list, tree attributes) 6763 { 6764 tree klass = NULL_TREE; 6765 tree decl; 6766 6767 #ifdef OBJCPLUS 6768 if (current_namespace != global_namespace) 6769 { 6770 error ("Objective-C declarations may only appear in global scope"); 6771 } 6772 #endif /* OBJCPLUS */ 6773 6774 if (objc_implementation_context) 6775 { 6776 warning (0, "%<@end%> missing in implementation context"); 6777 finish_class (objc_implementation_context); 6778 objc_ivar_chain = NULL_TREE; 6779 objc_implementation_context = NULL_TREE; 6780 } 6781 6782 /* If this is a class extension, we'll be "reopening" the existing 6783 CLASS_INTERFACE_TYPE, so in that case there is no need to create 6784 a new node. */ 6785 if (code != CATEGORY_INTERFACE_TYPE || super_name != NULL_TREE) 6786 { 6787 klass = make_node (code); 6788 TYPE_LANG_SLOT_1 (klass) = make_tree_vec (CLASS_LANG_SLOT_ELTS); 6789 } 6790 6791 /* Check for existence of the super class, if one was specified. Note 6792 that we must have seen an @interface, not just a @class. If we 6793 are looking at a @compatibility_alias, traverse it first. */ 6794 if ((code == CLASS_INTERFACE_TYPE || code == CLASS_IMPLEMENTATION_TYPE) 6795 && super_name) 6796 { 6797 tree super = objc_is_class_name (super_name); 6798 tree super_interface = NULL_TREE; 6799 6800 if (super) 6801 super_interface = lookup_interface (super); 6802 6803 if (!super_interface) 6804 { 6805 error ("cannot find interface declaration for %qE, superclass of %qE", 6806 super ? super : super_name, 6807 class_name); 6808 super_name = NULL_TREE; 6809 } 6810 else 6811 { 6812 if (TREE_DEPRECATED (super_interface)) 6813 warning (OPT_Wdeprecated_declarations, "class %qE is deprecated", 6814 super); 6815 super_name = super; 6816 } 6817 } 6818 6819 if (code != CATEGORY_INTERFACE_TYPE || super_name != NULL_TREE) 6820 { 6821 CLASS_NAME (klass) = class_name; 6822 CLASS_SUPER_NAME (klass) = super_name; 6823 CLASS_CLS_METHODS (klass) = NULL_TREE; 6824 } 6825 6826 if (! objc_is_class_name (class_name) 6827 && (decl = lookup_name (class_name))) 6828 { 6829 error ("%qE redeclared as different kind of symbol", 6830 class_name); 6831 error ("previous declaration of %q+D", 6832 decl); 6833 } 6834 6835 switch (code) 6836 { 6837 case CLASS_IMPLEMENTATION_TYPE: 6838 { 6839 tree chain; 6840 6841 for (chain = implemented_classes; chain; chain = TREE_CHAIN (chain)) 6842 if (TREE_VALUE (chain) == class_name) 6843 { 6844 error ("reimplementation of class %qE", 6845 class_name); 6846 /* TODO: error message saying where it was previously 6847 implemented. */ 6848 break; 6849 } 6850 if (chain == NULL_TREE) 6851 implemented_classes = tree_cons (NULL_TREE, class_name, 6852 implemented_classes); 6853 } 6854 6855 /* Reset for multiple classes per file. */ 6856 method_slot = 0; 6857 6858 objc_implementation_context = klass; 6859 6860 /* Lookup the interface for this implementation. */ 6861 6862 if (!(implementation_template = lookup_interface (class_name))) 6863 { 6864 warning (0, "cannot find interface declaration for %qE", 6865 class_name); 6866 add_interface (implementation_template = objc_implementation_context, 6867 class_name); 6868 } 6869 6870 /* If a super class has been specified in the implementation, 6871 insure it conforms to the one specified in the interface. */ 6872 6873 if (super_name 6874 && (super_name != CLASS_SUPER_NAME (implementation_template))) 6875 { 6876 tree previous_name = CLASS_SUPER_NAME (implementation_template); 6877 error ("conflicting super class name %qE", 6878 super_name); 6879 if (previous_name) 6880 error ("previous declaration of %qE", previous_name); 6881 else 6882 error ("previous declaration"); 6883 } 6884 6885 else if (! super_name) 6886 { 6887 CLASS_SUPER_NAME (objc_implementation_context) 6888 = CLASS_SUPER_NAME (implementation_template); 6889 } 6890 break; 6891 6892 case CLASS_INTERFACE_TYPE: 6893 if (lookup_interface (class_name)) 6894 #ifdef OBJCPLUS 6895 error ("duplicate interface declaration for class %qE", class_name); 6896 #else 6897 warning (0, "duplicate interface declaration for class %qE", class_name); 6898 #endif 6899 else 6900 add_interface (klass, class_name); 6901 6902 if (protocol_list) 6903 CLASS_PROTOCOL_LIST (klass) 6904 = lookup_and_install_protocols (protocol_list, /* definition_required */ true); 6905 6906 if (attributes) 6907 { 6908 tree attribute; 6909 for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute)) 6910 { 6911 tree name = TREE_PURPOSE (attribute); 6912 6913 /* TODO: Document what the objc_exception attribute is/does. */ 6914 /* We handle the 'deprecated' and (undocumented) 'objc_exception' 6915 attributes. */ 6916 if (is_attribute_p ("deprecated", name)) 6917 TREE_DEPRECATED (klass) = 1; 6918 else if (is_attribute_p ("objc_exception", name)) 6919 CLASS_HAS_EXCEPTION_ATTR (klass) = 1; 6920 else 6921 /* Warn about and ignore all others for now, but store them. */ 6922 warning (OPT_Wattributes, "%qE attribute directive ignored", name); 6923 } 6924 TYPE_ATTRIBUTES (klass) = attributes; 6925 } 6926 break; 6927 6928 case CATEGORY_INTERFACE_TYPE: 6929 { 6930 tree class_category_is_assoc_with; 6931 6932 /* For a category, class_name is really the name of the class that 6933 the following set of methods will be associated with. We must 6934 find the interface so that can derive the objects template. */ 6935 if (!(class_category_is_assoc_with = lookup_interface (class_name))) 6936 { 6937 error ("cannot find interface declaration for %qE", 6938 class_name); 6939 exit (FATAL_EXIT_CODE); 6940 } 6941 else 6942 { 6943 if (TREE_DEPRECATED (class_category_is_assoc_with)) 6944 warning (OPT_Wdeprecated_declarations, "class %qE is deprecated", 6945 class_name); 6946 6947 if (super_name == NULL_TREE) 6948 { 6949 /* This is a class extension. Get the original 6950 interface, and continue working on it. */ 6951 objc_in_class_extension = true; 6952 klass = class_category_is_assoc_with; 6953 6954 if (protocol_list) 6955 { 6956 /* Append protocols to the original protocol 6957 list. */ 6958 CLASS_PROTOCOL_LIST (klass) 6959 = chainon (CLASS_PROTOCOL_LIST (klass), 6960 lookup_and_install_protocols 6961 (protocol_list, 6962 /* definition_required */ true)); 6963 } 6964 } 6965 else 6966 { 6967 add_category (class_category_is_assoc_with, klass); 6968 6969 if (protocol_list) 6970 CLASS_PROTOCOL_LIST (klass) 6971 = lookup_and_install_protocols 6972 (protocol_list, /* definition_required */ true); 6973 } 6974 } 6975 } 6976 break; 6977 6978 case CATEGORY_IMPLEMENTATION_TYPE: 6979 /* Reset for multiple classes per file. */ 6980 method_slot = 0; 6981 6982 objc_implementation_context = klass; 6983 6984 /* For a category, class_name is really the name of the class that 6985 the following set of methods will be associated with. We must 6986 find the interface so that can derive the objects template. */ 6987 6988 if (!(implementation_template = lookup_interface (class_name))) 6989 { 6990 error ("cannot find interface declaration for %qE", 6991 class_name); 6992 exit (FATAL_EXIT_CODE); 6993 } 6994 break; 6995 default: 6996 gcc_unreachable (); 6997 } 6998 return klass; 6999 } 7000 7001 static tree 7002 continue_class (tree klass) 7003 { 7004 switch (TREE_CODE (klass)) 7005 { 7006 case CLASS_IMPLEMENTATION_TYPE: 7007 case CATEGORY_IMPLEMENTATION_TYPE: 7008 { 7009 struct imp_entry *imp_entry; 7010 7011 /* Check consistency of the instance variables. */ 7012 7013 if (CLASS_RAW_IVARS (klass)) 7014 check_ivars (implementation_template, klass); 7015 7016 /* code generation */ 7017 #ifdef OBJCPLUS 7018 push_lang_context (lang_name_c); 7019 #endif 7020 build_private_template (implementation_template); 7021 uprivate_record = CLASS_STATIC_TEMPLATE (implementation_template); 7022 objc_instance_type = build_pointer_type (uprivate_record); 7023 7024 imp_entry = ggc_alloc_imp_entry (); 7025 7026 imp_entry->next = imp_list; 7027 imp_entry->imp_context = klass; 7028 imp_entry->imp_template = implementation_template; 7029 ucls_super_ref = uucls_super_ref = NULL; 7030 if (TREE_CODE (klass) == CLASS_IMPLEMENTATION_TYPE) 7031 { 7032 imp_entry->class_decl = (*runtime.class_decl) (klass); 7033 imp_entry->meta_decl = (*runtime.metaclass_decl) (klass); 7034 } 7035 else 7036 { 7037 imp_entry->class_decl = (*runtime.category_decl) (klass); 7038 imp_entry->meta_decl = NULL; 7039 } 7040 imp_entry->has_cxx_cdtors = 0; 7041 7042 /* Append to front and increment count. */ 7043 imp_list = imp_entry; 7044 if (TREE_CODE (klass) == CLASS_IMPLEMENTATION_TYPE) 7045 imp_count++; 7046 else 7047 cat_count++; 7048 #ifdef OBJCPLUS 7049 pop_lang_context (); 7050 #endif /* OBJCPLUS */ 7051 7052 return get_class_ivars (implementation_template, true); 7053 break; 7054 } 7055 case CLASS_INTERFACE_TYPE: 7056 { 7057 if (objc_in_class_extension) 7058 return NULL_TREE; 7059 #ifdef OBJCPLUS 7060 push_lang_context (lang_name_c); 7061 #endif /* OBJCPLUS */ 7062 objc_collecting_ivars = 1; 7063 build_private_template (klass); 7064 objc_collecting_ivars = 0; 7065 #ifdef OBJCPLUS 7066 pop_lang_context (); 7067 #endif /* OBJCPLUS */ 7068 return NULL_TREE; 7069 break; 7070 } 7071 default: 7072 return error_mark_node; 7073 } 7074 } 7075 7076 /* This routine builds name of the setter synthesized function. */ 7077 char * 7078 objc_build_property_setter_name (tree ident) 7079 { 7080 /* TODO: Use alloca to allocate buffer of appropriate size. */ 7081 static char string[BUFSIZE]; 7082 sprintf (string, "set%s:", IDENTIFIER_POINTER (ident)); 7083 string[3] = TOUPPER (string[3]); 7084 return string; 7085 } 7086 7087 /* This routine prepares the declarations of the property accessor 7088 helper functions (objc_getProperty(), etc) that are used when 7089 @synthesize is used. 7090 7091 runtime-specific routines are built in the respective runtime 7092 initialize functions. */ 7093 static void 7094 build_common_objc_property_accessor_helpers (void) 7095 { 7096 tree type; 7097 7098 /* Declare the following function: 7099 id 7100 objc_getProperty (id self, SEL _cmd, 7101 ptrdiff_t offset, BOOL is_atomic); */ 7102 type = build_function_type_list (objc_object_type, 7103 objc_object_type, 7104 objc_selector_type, 7105 ptrdiff_type_node, 7106 boolean_type_node, 7107 NULL_TREE); 7108 objc_getProperty_decl = add_builtin_function ("objc_getProperty", 7109 type, 0, NOT_BUILT_IN, 7110 NULL, NULL_TREE); 7111 TREE_NOTHROW (objc_getProperty_decl) = 0; 7112 7113 /* Declare the following function: 7114 void 7115 objc_setProperty (id self, SEL _cmd, 7116 ptrdiff_t offset, id new_value, 7117 BOOL is_atomic, BOOL should_copy); */ 7118 type = build_function_type_list (void_type_node, 7119 objc_object_type, 7120 objc_selector_type, 7121 ptrdiff_type_node, 7122 objc_object_type, 7123 boolean_type_node, 7124 boolean_type_node, 7125 NULL_TREE); 7126 objc_setProperty_decl = add_builtin_function ("objc_setProperty", 7127 type, 0, NOT_BUILT_IN, 7128 NULL, NULL_TREE); 7129 TREE_NOTHROW (objc_setProperty_decl) = 0; 7130 } 7131 7132 /* This looks up an ivar in a class (including superclasses). */ 7133 static tree 7134 lookup_ivar (tree interface, tree instance_variable_name) 7135 { 7136 while (interface) 7137 { 7138 tree decl_chain; 7139 7140 for (decl_chain = CLASS_IVARS (interface); decl_chain; decl_chain = DECL_CHAIN (decl_chain)) 7141 if (DECL_NAME (decl_chain) == instance_variable_name) 7142 return decl_chain; 7143 7144 /* Not found. Search superclass if any. */ 7145 if (CLASS_SUPER_NAME (interface)) 7146 interface = lookup_interface (CLASS_SUPER_NAME (interface)); 7147 } 7148 7149 return NULL_TREE; 7150 } 7151 7152 /* This routine synthesizes a 'getter' method. This is only called 7153 for @synthesize properties. */ 7154 static void 7155 objc_synthesize_getter (tree klass, tree class_methods ATTRIBUTE_UNUSED, tree property) 7156 { 7157 location_t location = DECL_SOURCE_LOCATION (property); 7158 tree fn, decl; 7159 tree body; 7160 tree ret_val; 7161 7162 /* If user has implemented a getter with same name then do nothing. */ 7163 if (lookup_method (CLASS_NST_METHODS (objc_implementation_context), 7164 PROPERTY_GETTER_NAME (property))) 7165 return; 7166 7167 /* Find declaration of the property getter in the interface (or 7168 superclass, or protocol). There must be one. */ 7169 decl = lookup_method_static (klass, PROPERTY_GETTER_NAME (property), 0); 7170 7171 /* If one not declared in the interface, this condition has already 7172 been reported as user error (because property was not declared in 7173 the interface). */ 7174 if (!decl) 7175 return; 7176 7177 /* Adapt the 'decl'. Use the source location of the @synthesize 7178 statement for error messages. */ 7179 decl = copy_node (decl); 7180 DECL_SOURCE_LOCATION (decl) = location; 7181 7182 objc_start_method_definition (false /* is_class_method */, decl, NULL_TREE, 7183 NULL_TREE); 7184 body = c_begin_compound_stmt (true); 7185 7186 /* Now we need to decide how we build the getter. There are three 7187 cases: 7188 7189 for 'copy' or 'retain' properties we need to use the 7190 objc_getProperty() accessor helper which knows about retain and 7191 copy. It supports both 'nonatomic' and 'atomic' access. 7192 7193 for 'nonatomic, assign' properties we can access the instance 7194 variable directly. 'nonatomic' means we don't have to use locks, 7195 and 'assign' means we don't have to worry about retain or copy. 7196 If you combine the two, it means we can just access the instance 7197 variable directly. 7198 7199 for 'atomic, assign' properties we use objc_copyStruct() (for the 7200 next runtime) or objc_getPropertyStruct() (for the GNU runtime). */ 7201 switch (PROPERTY_ASSIGN_SEMANTICS (property)) 7202 { 7203 case OBJC_PROPERTY_RETAIN: 7204 case OBJC_PROPERTY_COPY: 7205 { 7206 /* We build "return objc_getProperty (self, _cmd, offset, is_atomic);" */ 7207 tree cmd, ivar, offset, is_atomic; 7208 cmd = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl)); 7209 7210 /* Find the ivar to compute the offset. */ 7211 ivar = lookup_ivar (klass, PROPERTY_IVAR_NAME (property)); 7212 if (!ivar || is_private (ivar)) 7213 { 7214 /* This should never happen. */ 7215 error_at (location, 7216 "can not find instance variable associated with property"); 7217 ret_val = error_mark_node; 7218 break; 7219 } 7220 offset = byte_position (ivar); 7221 7222 if (PROPERTY_NONATOMIC (property)) 7223 is_atomic = boolean_false_node; 7224 else 7225 is_atomic = boolean_true_node; 7226 7227 ret_val = build_function_call 7228 (location, 7229 /* Function prototype. */ 7230 objc_getProperty_decl, 7231 /* Parameters. */ 7232 tree_cons /* self */ 7233 (NULL_TREE, self_decl, 7234 tree_cons /* _cmd */ 7235 (NULL_TREE, cmd, 7236 tree_cons /* offset */ 7237 (NULL_TREE, offset, 7238 tree_cons /* is_atomic */ 7239 (NULL_TREE, is_atomic, NULL_TREE))))); 7240 } 7241 break; 7242 case OBJC_PROPERTY_ASSIGN: 7243 if (PROPERTY_NONATOMIC (property)) 7244 { 7245 /* We build "return self->PROPERTY_IVAR_NAME;" */ 7246 ret_val = objc_lookup_ivar (NULL_TREE, PROPERTY_IVAR_NAME (property)); 7247 break; 7248 } 7249 else 7250 { 7251 /* We build 7252 <property type> __objc_property_temp; 7253 objc_getPropertyStruct (&__objc_property_temp, 7254 &(self->PROPERTY_IVAR_NAME), 7255 sizeof (type of self->PROPERTY_IVAR_NAME), 7256 is_atomic, 7257 false) 7258 return __objc_property_temp; 7259 7260 For the NeXT runtime, we need to use objc_copyStruct 7261 instead of objc_getPropertyStruct. */ 7262 tree objc_property_temp_decl, function_decl, function_call; 7263 tree size_of, is_atomic; 7264 7265 objc_property_temp_decl = objc_create_temporary_var (TREE_TYPE (property), "__objc_property_temp"); 7266 DECL_SOURCE_LOCATION (objc_property_temp_decl) = location; 7267 objc_property_temp_decl = lang_hooks.decls.pushdecl (objc_property_temp_decl); 7268 7269 /* sizeof (ivar type). Since the ivar and the property have 7270 the same type, there is no need to lookup the ivar. */ 7271 size_of = c_sizeof_or_alignof_type (location, TREE_TYPE (property), 7272 true /* is_sizeof */, 7273 false /* complain */); 7274 7275 if (PROPERTY_NONATOMIC (property)) 7276 is_atomic = boolean_false_node; 7277 else 7278 is_atomic = boolean_true_node; 7279 7280 if (objc_copyStruct_decl) 7281 function_decl = objc_copyStruct_decl; 7282 else 7283 function_decl = objc_getPropertyStruct_decl; 7284 7285 function_call = build_function_call 7286 (location, 7287 /* Function prototype. */ 7288 function_decl, 7289 /* Parameters. */ 7290 tree_cons /* &__objc_property_temp_decl */ 7291 /* Warning: note that using build_fold_addr_expr_loc() 7292 here causes invalid code to be generated. */ 7293 (NULL_TREE, build_unary_op (location, ADDR_EXPR, objc_property_temp_decl, 0), 7294 tree_cons /* &(self->PROPERTY_IVAR_NAME); */ 7295 (NULL_TREE, build_fold_addr_expr_loc (location, 7296 objc_lookup_ivar 7297 (NULL_TREE, PROPERTY_IVAR_NAME (property))), 7298 tree_cons /* sizeof (PROPERTY_IVAR) */ 7299 (NULL_TREE, size_of, 7300 tree_cons /* is_atomic */ 7301 (NULL_TREE, is_atomic, 7302 /* TODO: This is currently ignored by the GNU 7303 runtime, but what about the next one ? */ 7304 tree_cons /* has_strong */ 7305 (NULL_TREE, boolean_true_node, NULL_TREE)))))); 7306 7307 add_stmt (function_call); 7308 7309 ret_val = objc_property_temp_decl; 7310 } 7311 break; 7312 default: 7313 gcc_unreachable (); 7314 } 7315 7316 gcc_assert (ret_val); 7317 7318 #ifdef OBJCPLUS 7319 finish_return_stmt (ret_val); 7320 #else 7321 c_finish_return (location, ret_val, NULL_TREE); 7322 #endif 7323 7324 add_stmt (c_end_compound_stmt (location, body, true)); 7325 fn = current_function_decl; 7326 #ifdef OBJCPLUS 7327 finish_function (); 7328 #endif 7329 objc_finish_method_definition (fn); 7330 } 7331 7332 /* This routine synthesizes a 'setter' method. */ 7333 7334 static void 7335 objc_synthesize_setter (tree klass, tree class_methods ATTRIBUTE_UNUSED, tree property) 7336 { 7337 location_t location = DECL_SOURCE_LOCATION (property); 7338 tree fn, decl; 7339 tree body; 7340 tree new_value, statement; 7341 7342 /* If user has implemented a setter with same name then do nothing. */ 7343 if (lookup_method (CLASS_NST_METHODS (objc_implementation_context), 7344 PROPERTY_SETTER_NAME (property))) 7345 return; 7346 7347 /* Find declaration of the property setter in the interface (or 7348 superclass, or protocol). There must be one. */ 7349 decl = lookup_method_static (klass, PROPERTY_SETTER_NAME (property), 0); 7350 7351 /* If one not declared in the interface, this condition has already 7352 been reported as user error (because property was not declared in 7353 the interface). */ 7354 if (!decl) 7355 return; 7356 7357 /* Adapt the 'decl'. Use the source location of the @synthesize 7358 statement for error messages. */ 7359 decl = copy_node (decl); 7360 DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (property); 7361 7362 objc_start_method_definition (false /* is_class_method */, decl, NULL_TREE, 7363 NULL_TREE); 7364 7365 body = c_begin_compound_stmt (true); 7366 7367 /* The 'new_value' is the only argument to the method, which is the 7368 3rd argument of the function, after self and _cmd. We use twice 7369 TREE_CHAIN to move forward two arguments. */ 7370 new_value = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (current_function_decl))); 7371 7372 /* This would presumably happen if the user has specified a 7373 prototype for the setter that does not have an argument! */ 7374 if (new_value == NULL_TREE) 7375 { 7376 /* TODO: This should be caught much earlier than this. */ 7377 error_at (DECL_SOURCE_LOCATION (decl), "invalid setter, it must have one argument"); 7378 /* Try to recover somehow. */ 7379 new_value = error_mark_node; 7380 } 7381 7382 /* Now we need to decide how we build the setter. There are three 7383 cases: 7384 7385 for 'copy' or 'retain' properties we need to use the 7386 objc_setProperty() accessor helper which knows about retain and 7387 copy. It supports both 'nonatomic' and 'atomic' access. 7388 7389 for 'nonatomic, assign' properties we can access the instance 7390 variable directly. 'nonatomic' means we don't have to use locks, 7391 and 'assign' means we don't have to worry about retain or copy. 7392 If you combine the two, it means we can just access the instance 7393 variable directly. 7394 7395 for 'atomic, assign' properties we use objc_copyStruct() (for the 7396 next runtime) or objc_setPropertyStruct() (for the GNU runtime). */ 7397 switch (PROPERTY_ASSIGN_SEMANTICS (property)) 7398 { 7399 case OBJC_PROPERTY_RETAIN: 7400 case OBJC_PROPERTY_COPY: 7401 { 7402 /* We build "objc_setProperty (self, _cmd, new_value, offset, is_atomic, should_copy);" */ 7403 tree cmd, ivar, offset, is_atomic, should_copy; 7404 cmd = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl)); 7405 7406 /* Find the ivar to compute the offset. */ 7407 ivar = lookup_ivar (klass, PROPERTY_IVAR_NAME (property)); 7408 if (!ivar || is_private (ivar)) 7409 { 7410 error_at (location, 7411 "can not find instance variable associated with property"); 7412 statement = error_mark_node; 7413 break; 7414 } 7415 offset = byte_position (ivar); 7416 7417 if (PROPERTY_NONATOMIC (property)) 7418 is_atomic = boolean_false_node; 7419 else 7420 is_atomic = boolean_true_node; 7421 7422 if (PROPERTY_ASSIGN_SEMANTICS (property) == OBJC_PROPERTY_COPY) 7423 should_copy = boolean_true_node; 7424 else 7425 should_copy = boolean_false_node; 7426 7427 statement = build_function_call 7428 (location, 7429 /* Function prototype. */ 7430 objc_setProperty_decl, 7431 /* Parameters. */ 7432 tree_cons /* self */ 7433 (NULL_TREE, self_decl, 7434 tree_cons /* _cmd */ 7435 (NULL_TREE, cmd, 7436 tree_cons /* offset */ 7437 (NULL_TREE, offset, 7438 tree_cons /* new_value */ 7439 (NULL_TREE, new_value, 7440 tree_cons /* is_atomic */ 7441 (NULL_TREE, is_atomic, 7442 tree_cons /* should_copy */ 7443 (NULL_TREE, should_copy, NULL_TREE))))))); 7444 } 7445 break; 7446 case OBJC_PROPERTY_ASSIGN: 7447 if (PROPERTY_NONATOMIC (property)) 7448 { 7449 /* We build "self->PROPERTY_IVAR_NAME = new_value;" */ 7450 statement = build_modify_expr 7451 (location, 7452 objc_lookup_ivar (NULL_TREE, PROPERTY_IVAR_NAME (property)), 7453 NULL_TREE, NOP_EXPR, 7454 location, new_value, NULL_TREE); 7455 break; 7456 } 7457 else 7458 { 7459 /* We build 7460 objc_setPropertyStruct (&(self->PROPERTY_IVAR_NAME), 7461 &new_value, 7462 sizeof (type of self->PROPERTY_IVAR_NAME), 7463 is_atomic, 7464 false) 7465 7466 For the NeXT runtime, we need to use objc_copyStruct 7467 instead of objc_getPropertyStruct. */ 7468 tree function_decl, size_of, is_atomic; 7469 7470 /* sizeof (ivar type). Since the ivar and the property have 7471 the same type, there is no need to lookup the ivar. */ 7472 size_of = c_sizeof_or_alignof_type (location, TREE_TYPE (property), 7473 true /* is_sizeof */, 7474 false /* complain */); 7475 7476 if (PROPERTY_NONATOMIC (property)) 7477 is_atomic = boolean_false_node; 7478 else 7479 is_atomic = boolean_true_node; 7480 7481 if (objc_copyStruct_decl) 7482 function_decl = objc_copyStruct_decl; 7483 else 7484 function_decl = objc_setPropertyStruct_decl; 7485 7486 statement = build_function_call 7487 (location, 7488 /* Function prototype. */ 7489 function_decl, 7490 /* Parameters. */ 7491 tree_cons /* &(self->PROPERTY_IVAR_NAME); */ 7492 (NULL_TREE, build_fold_addr_expr_loc (location, 7493 objc_lookup_ivar 7494 (NULL_TREE, PROPERTY_IVAR_NAME (property))), 7495 tree_cons /* &new_value */ 7496 (NULL_TREE, build_fold_addr_expr_loc (location, new_value), 7497 tree_cons /* sizeof (PROPERTY_IVAR) */ 7498 (NULL_TREE, size_of, 7499 tree_cons /* is_atomic */ 7500 (NULL_TREE, is_atomic, 7501 /* TODO: This is currently ignored by the GNU 7502 runtime, but what about the next one ? */ 7503 tree_cons /* has_strong */ 7504 (NULL_TREE, boolean_true_node, NULL_TREE)))))); 7505 } 7506 break; 7507 default: 7508 gcc_unreachable (); 7509 } 7510 gcc_assert (statement); 7511 7512 add_stmt (statement); 7513 add_stmt (c_end_compound_stmt (location, body, true)); 7514 fn = current_function_decl; 7515 #ifdef OBJCPLUS 7516 finish_function (); 7517 #endif 7518 objc_finish_method_definition (fn); 7519 } 7520 7521 /* This function is a sub-routine of objc_add_synthesize_declaration. 7522 It is called for each property to synthesize once we have 7523 determined that the context is Ok. */ 7524 static void 7525 objc_add_synthesize_declaration_for_property (location_t location, tree interface, 7526 tree property_name, tree ivar_name) 7527 { 7528 /* Find the @property declaration. */ 7529 tree property; 7530 tree x; 7531 7532 /* Check that synthesize or dynamic has not already been used for 7533 the same property. */ 7534 for (property = IMPL_PROPERTY_DECL (objc_implementation_context); property; property = TREE_CHAIN (property)) 7535 if (PROPERTY_NAME (property) == property_name) 7536 { 7537 location_t original_location = DECL_SOURCE_LOCATION (property); 7538 7539 if (PROPERTY_DYNAMIC (property)) 7540 error_at (location, "property %qs already specified in %<@dynamic%>", 7541 IDENTIFIER_POINTER (property_name)); 7542 else 7543 error_at (location, "property %qs already specified in %<@synthesize%>", 7544 IDENTIFIER_POINTER (property_name)); 7545 7546 if (original_location != UNKNOWN_LOCATION) 7547 inform (original_location, "originally specified here"); 7548 return; 7549 } 7550 7551 /* Check that the property is declared in the interface. It could 7552 also be declared in a superclass or protocol. */ 7553 property = lookup_property (interface, property_name); 7554 7555 if (!property) 7556 { 7557 error_at (location, "no declaration of property %qs found in the interface", 7558 IDENTIFIER_POINTER (property_name)); 7559 return; 7560 } 7561 else 7562 { 7563 /* We have to copy the property, because we want to chain it to 7564 the implementation context, and we want to store the source 7565 location of the @synthesize, not of the original 7566 @property. */ 7567 property = copy_node (property); 7568 DECL_SOURCE_LOCATION (property) = location; 7569 } 7570 7571 /* Determine PROPERTY_IVAR_NAME. */ 7572 if (ivar_name == NULL_TREE) 7573 ivar_name = property_name; 7574 7575 /* Check that the instance variable exists. You can only use an 7576 instance variable from the same class, not one from the 7577 superclass (this makes sense as it allows us to check that an 7578 instance variable is only used in one synthesized property). */ 7579 { 7580 tree ivar = is_ivar (CLASS_IVARS (interface), ivar_name); 7581 tree type_of_ivar; 7582 if (!ivar) 7583 { 7584 error_at (location, "ivar %qs used by %<@synthesize%> declaration must be an existing ivar", 7585 IDENTIFIER_POINTER (property_name)); 7586 return; 7587 } 7588 7589 if (DECL_BIT_FIELD_TYPE (ivar)) 7590 type_of_ivar = DECL_BIT_FIELD_TYPE (ivar); 7591 else 7592 type_of_ivar = TREE_TYPE (ivar); 7593 7594 /* If the instance variable has a different C type, we throw an error ... */ 7595 if (!comptypes (TREE_TYPE (property), type_of_ivar) 7596 /* ... unless the property is readonly, in which case we allow 7597 the instance variable to be more specialized (this means we 7598 can generate the getter all right and it works). */ 7599 && (!PROPERTY_READONLY (property) 7600 || !objc_compare_types (TREE_TYPE (property), 7601 type_of_ivar, -5, NULL_TREE))) 7602 { 7603 location_t original_location = DECL_SOURCE_LOCATION (ivar); 7604 7605 error_at (location, "property %qs is using instance variable %qs of incompatible type", 7606 IDENTIFIER_POINTER (property_name), 7607 IDENTIFIER_POINTER (ivar_name)); 7608 7609 if (original_location != UNKNOWN_LOCATION) 7610 inform (original_location, "originally specified here"); 7611 } 7612 7613 /* If the instance variable is a bitfield, the property must be 7614 'assign', 'nonatomic' because the runtime getter/setter helper 7615 do not work with bitfield instance variables. */ 7616 if (DECL_BIT_FIELD_TYPE (ivar)) 7617 { 7618 /* If there is an error, we return and not generate any 7619 getter/setter because trying to set up the runtime 7620 getter/setter helper calls with bitfields is at high risk 7621 of ICE. */ 7622 7623 if (PROPERTY_ASSIGN_SEMANTICS (property) != OBJC_PROPERTY_ASSIGN) 7624 { 7625 location_t original_location = DECL_SOURCE_LOCATION (ivar); 7626 7627 error_at (location, "'assign' property %qs is using bit-field instance variable %qs", 7628 IDENTIFIER_POINTER (property_name), 7629 IDENTIFIER_POINTER (ivar_name)); 7630 7631 if (original_location != UNKNOWN_LOCATION) 7632 inform (original_location, "originally specified here"); 7633 return; 7634 } 7635 7636 if (!PROPERTY_NONATOMIC (property)) 7637 { 7638 location_t original_location = DECL_SOURCE_LOCATION (ivar); 7639 7640 error_at (location, "'atomic' property %qs is using bit-field instance variable %qs", 7641 IDENTIFIER_POINTER (property_name), 7642 IDENTIFIER_POINTER (ivar_name)); 7643 7644 if (original_location != UNKNOWN_LOCATION) 7645 inform (original_location, "originally specified here"); 7646 return; 7647 } 7648 } 7649 } 7650 7651 /* Check that no other property is using the same instance 7652 variable. */ 7653 for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x)) 7654 if (PROPERTY_IVAR_NAME (x) == ivar_name) 7655 { 7656 location_t original_location = DECL_SOURCE_LOCATION (x); 7657 7658 error_at (location, "property %qs is using the same instance variable as property %qs", 7659 IDENTIFIER_POINTER (property_name), 7660 IDENTIFIER_POINTER (PROPERTY_NAME (x))); 7661 7662 if (original_location != UNKNOWN_LOCATION) 7663 inform (original_location, "originally specified here"); 7664 7665 /* We keep going on. This won't cause the compiler to fail; 7666 the failure would most likely be at runtime. */ 7667 } 7668 7669 /* Note that a @synthesize (and only a @synthesize) always sets 7670 PROPERTY_IVAR_NAME to a non-NULL_TREE. You can recognize a 7671 @synthesize by that. */ 7672 PROPERTY_IVAR_NAME (property) = ivar_name; 7673 7674 /* PROPERTY_SETTER_NAME and PROPERTY_GETTER_NAME are copied from the 7675 original declaration; they are always set (with the exception of 7676 PROPERTY_SETTER_NAME not being set if PROPERTY_READONLY == 1). */ 7677 7678 /* Add the property to the list of properties for current implementation. */ 7679 TREE_CHAIN (property) = IMPL_PROPERTY_DECL (objc_implementation_context); 7680 IMPL_PROPERTY_DECL (objc_implementation_context) = property; 7681 7682 /* Note how we don't actually synthesize the getter/setter here; it 7683 would be very natural, but we may miss the fact that the user has 7684 implemented his own getter/setter later on in the @implementation 7685 (in which case we shouldn't generate getter/setter). We wait 7686 until we have parsed it all before generating the code. */ 7687 } 7688 7689 /* This function is called by the parser after a @synthesize 7690 expression is parsed. 'location' is the location of the 7691 @synthesize expression, and 'property_and_ivar_list' is a chained 7692 list of the property and ivar names. */ 7693 void 7694 objc_add_synthesize_declaration (location_t location, tree property_and_ivar_list) 7695 { 7696 tree interface, chain; 7697 7698 if (flag_objc1_only) 7699 error_at (input_location, "%<@synthesize%> is not available in Objective-C 1.0"); 7700 7701 if (property_and_ivar_list == error_mark_node) 7702 return; 7703 7704 if (!objc_implementation_context) 7705 { 7706 /* We can get here only in Objective-C; the Objective-C++ parser 7707 detects the problem while parsing, outputs the error 7708 "misplaced '@synthesize' Objective-C++ construct" and skips 7709 the declaration. */ 7710 error_at (location, "%<@synthesize%> not in @implementation context"); 7711 return; 7712 } 7713 7714 if (TREE_CODE (objc_implementation_context) == CATEGORY_IMPLEMENTATION_TYPE) 7715 { 7716 error_at (location, "%<@synthesize%> can not be used in categories"); 7717 return; 7718 } 7719 7720 interface = lookup_interface (CLASS_NAME (objc_implementation_context)); 7721 if (!interface) 7722 { 7723 /* I can't see how this could happen, but it is good as a safety check. */ 7724 error_at (location, 7725 "%<@synthesize%> requires the @interface of the class to be available"); 7726 return; 7727 } 7728 7729 /* Now, iterate over the properties and do each of them. */ 7730 for (chain = property_and_ivar_list; chain; chain = TREE_CHAIN (chain)) 7731 { 7732 objc_add_synthesize_declaration_for_property (location, interface, TREE_VALUE (chain), 7733 TREE_PURPOSE (chain)); 7734 } 7735 } 7736 7737 /* This function is a sub-routine of objc_add_dynamic_declaration. It 7738 is called for each property to mark as dynamic once we have 7739 determined that the context is Ok. */ 7740 static void 7741 objc_add_dynamic_declaration_for_property (location_t location, tree interface, 7742 tree property_name) 7743 { 7744 /* Find the @property declaration. */ 7745 tree property; 7746 7747 /* Check that synthesize or dynamic has not already been used for 7748 the same property. */ 7749 for (property = IMPL_PROPERTY_DECL (objc_implementation_context); property; property = TREE_CHAIN (property)) 7750 if (PROPERTY_NAME (property) == property_name) 7751 { 7752 location_t original_location = DECL_SOURCE_LOCATION (property); 7753 7754 if (PROPERTY_DYNAMIC (property)) 7755 error_at (location, "property %qs already specified in %<@dynamic%>", 7756 IDENTIFIER_POINTER (property_name)); 7757 else 7758 error_at (location, "property %qs already specified in %<@synthesize%>", 7759 IDENTIFIER_POINTER (property_name)); 7760 7761 if (original_location != UNKNOWN_LOCATION) 7762 inform (original_location, "originally specified here"); 7763 return; 7764 } 7765 7766 /* Check that the property is declared in the interface. It could 7767 also be declared in a superclass or protocol. */ 7768 property = lookup_property (interface, property_name); 7769 7770 if (!property) 7771 { 7772 error_at (location, "no declaration of property %qs found in the interface", 7773 IDENTIFIER_POINTER (property_name)); 7774 return; 7775 } 7776 else 7777 { 7778 /* We have to copy the property, because we want to chain it to 7779 the implementation context, and we want to store the source 7780 location of the @synthesize, not of the original 7781 @property. */ 7782 property = copy_node (property); 7783 DECL_SOURCE_LOCATION (property) = location; 7784 } 7785 7786 /* Note that a @dynamic (and only a @dynamic) always sets 7787 PROPERTY_DYNAMIC to 1. You can recognize a @dynamic by that. 7788 (actually, as explained above, PROPERTY_DECL generated by 7789 @property and associated with a @dynamic property are also marked 7790 as PROPERTY_DYNAMIC). */ 7791 PROPERTY_DYNAMIC (property) = 1; 7792 7793 /* Add the property to the list of properties for current implementation. */ 7794 TREE_CHAIN (property) = IMPL_PROPERTY_DECL (objc_implementation_context); 7795 IMPL_PROPERTY_DECL (objc_implementation_context) = property; 7796 } 7797 7798 /* This function is called by the parser after a @dynamic expression 7799 is parsed. 'location' is the location of the @dynamic expression, 7800 and 'property_list' is a chained list of all the property 7801 names. */ 7802 void 7803 objc_add_dynamic_declaration (location_t location, tree property_list) 7804 { 7805 tree interface, chain; 7806 7807 if (flag_objc1_only) 7808 error_at (input_location, "%<@dynamic%> is not available in Objective-C 1.0"); 7809 7810 if (property_list == error_mark_node) 7811 return; 7812 7813 if (!objc_implementation_context) 7814 { 7815 /* We can get here only in Objective-C; the Objective-C++ parser 7816 detects the problem while parsing, outputs the error 7817 "misplaced '@dynamic' Objective-C++ construct" and skips the 7818 declaration. */ 7819 error_at (location, "%<@dynamic%> not in @implementation context"); 7820 return; 7821 } 7822 7823 /* @dynamic is allowed in categories. */ 7824 switch (TREE_CODE (objc_implementation_context)) 7825 { 7826 case CLASS_IMPLEMENTATION_TYPE: 7827 interface = lookup_interface (CLASS_NAME (objc_implementation_context)); 7828 break; 7829 case CATEGORY_IMPLEMENTATION_TYPE: 7830 interface = lookup_category (implementation_template, 7831 CLASS_SUPER_NAME (objc_implementation_context)); 7832 break; 7833 default: 7834 gcc_unreachable (); 7835 } 7836 7837 if (!interface) 7838 { 7839 /* I can't see how this could happen, but it is good as a safety check. */ 7840 error_at (location, 7841 "%<@dynamic%> requires the @interface of the class to be available"); 7842 return; 7843 } 7844 7845 /* Now, iterate over the properties and do each of them. */ 7846 for (chain = property_list; chain; chain = TREE_CHAIN (chain)) 7847 { 7848 objc_add_dynamic_declaration_for_property (location, interface, TREE_VALUE (chain)); 7849 } 7850 } 7851 7852 /* Main routine to generate code/data for all the property information for 7853 current implementation (class or category). CLASS is the interface where 7854 ivars are declared. CLASS_METHODS is where methods are found which 7855 could be a class or a category depending on whether we are implementing 7856 property of a class or a category. */ 7857 7858 static void 7859 objc_gen_property_data (tree klass, tree class_methods) 7860 { 7861 tree x; 7862 7863 for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x)) 7864 { 7865 /* @dynamic property - nothing to check or synthesize. */ 7866 if (PROPERTY_DYNAMIC (x)) 7867 continue; 7868 7869 /* @synthesize property - need to synthesize the accessors. */ 7870 if (PROPERTY_IVAR_NAME (x)) 7871 { 7872 objc_synthesize_getter (klass, class_methods, x); 7873 7874 if (PROPERTY_READONLY (x) == 0) 7875 objc_synthesize_setter (klass, class_methods, x); 7876 7877 continue; 7878 } 7879 7880 gcc_unreachable (); 7881 } 7882 } 7883 7884 /* This is called once we see the "@end" in an interface/implementation. */ 7885 7886 static void 7887 finish_class (tree klass) 7888 { 7889 switch (TREE_CODE (klass)) 7890 { 7891 case CLASS_IMPLEMENTATION_TYPE: 7892 { 7893 /* All metadata generation is done in runtime.generate_metadata(). */ 7894 7895 /* Generate what needed for property; setters, getters, etc. */ 7896 objc_gen_property_data (implementation_template, implementation_template); 7897 7898 if (implementation_template != objc_implementation_context) 7899 { 7900 /* Ensure that all method listed in the interface contain bodies. */ 7901 check_methods (CLASS_CLS_METHODS (implementation_template), 7902 objc_implementation_context, '+'); 7903 check_methods (CLASS_NST_METHODS (implementation_template), 7904 objc_implementation_context, '-'); 7905 7906 if (CLASS_PROTOCOL_LIST (implementation_template)) 7907 check_protocols (CLASS_PROTOCOL_LIST (implementation_template), 7908 "class", 7909 CLASS_NAME (objc_implementation_context)); 7910 } 7911 break; 7912 } 7913 case CATEGORY_IMPLEMENTATION_TYPE: 7914 { 7915 tree category = lookup_category (implementation_template, CLASS_SUPER_NAME (klass)); 7916 7917 if (category) 7918 { 7919 /* Generate what needed for property; setters, getters, etc. */ 7920 objc_gen_property_data (implementation_template, category); 7921 7922 /* Ensure all method listed in the interface contain bodies. */ 7923 check_methods (CLASS_CLS_METHODS (category), 7924 objc_implementation_context, '+'); 7925 check_methods (CLASS_NST_METHODS (category), 7926 objc_implementation_context, '-'); 7927 7928 if (CLASS_PROTOCOL_LIST (category)) 7929 check_protocols (CLASS_PROTOCOL_LIST (category), 7930 "category", 7931 CLASS_SUPER_NAME (objc_implementation_context)); 7932 } 7933 break; 7934 } 7935 case CLASS_INTERFACE_TYPE: 7936 case CATEGORY_INTERFACE_TYPE: 7937 case PROTOCOL_INTERFACE_TYPE: 7938 { 7939 /* Process properties of the class. */ 7940 tree x; 7941 for (x = CLASS_PROPERTY_DECL (objc_interface_context); x; x = TREE_CHAIN (x)) 7942 { 7943 /* Now we check that the appropriate getter is declared, 7944 and if not, we declare one ourselves. */ 7945 tree getter_decl = lookup_method (CLASS_NST_METHODS (klass), 7946 PROPERTY_GETTER_NAME (x)); 7947 7948 if (getter_decl) 7949 { 7950 /* TODO: Check that the declaration is consistent with the property. */ 7951 ; 7952 } 7953 else 7954 { 7955 /* Generate an instance method declaration for the 7956 getter; for example "- (id) name;". In general it 7957 will be of the form 7958 -(type)property_getter_name; */ 7959 tree rettype = build_tree_list (NULL_TREE, TREE_TYPE (x)); 7960 getter_decl = build_method_decl (INSTANCE_METHOD_DECL, 7961 rettype, PROPERTY_GETTER_NAME (x), 7962 NULL_TREE, false); 7963 if (PROPERTY_OPTIONAL (x)) 7964 objc_add_method (objc_interface_context, getter_decl, false, true); 7965 else 7966 objc_add_method (objc_interface_context, getter_decl, false, false); 7967 TREE_DEPRECATED (getter_decl) = TREE_DEPRECATED (x); 7968 METHOD_PROPERTY_CONTEXT (getter_decl) = x; 7969 } 7970 7971 if (PROPERTY_READONLY (x) == 0) 7972 { 7973 /* Now we check that the appropriate setter is declared, 7974 and if not, we declare on ourselves. */ 7975 tree setter_decl = lookup_method (CLASS_NST_METHODS (klass), 7976 PROPERTY_SETTER_NAME (x)); 7977 7978 if (setter_decl) 7979 { 7980 /* TODO: Check that the declaration is consistent with the property. */ 7981 ; 7982 } 7983 else 7984 { 7985 /* The setter name is something like 'setName:'. 7986 We need the substring 'setName' to build the 7987 method declaration due to how the declaration 7988 works. TODO: build_method_decl() will then 7989 generate back 'setName:' from 'setName'; it 7990 would be more efficient to hook into there. */ 7991 const char *full_setter_name = IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x)); 7992 size_t length = strlen (full_setter_name); 7993 char *setter_name = (char *) alloca (length); 7994 tree ret_type, selector, arg_type, arg_name; 7995 7996 strcpy (setter_name, full_setter_name); 7997 setter_name[length - 1] = '\0'; 7998 ret_type = build_tree_list (NULL_TREE, void_type_node); 7999 arg_type = build_tree_list (NULL_TREE, TREE_TYPE (x)); 8000 arg_name = get_identifier ("_value"); 8001 selector = objc_build_keyword_decl (get_identifier (setter_name), 8002 arg_type, arg_name, NULL); 8003 setter_decl = build_method_decl (INSTANCE_METHOD_DECL, 8004 ret_type, selector, 8005 build_tree_list (NULL_TREE, NULL_TREE), 8006 false); 8007 if (PROPERTY_OPTIONAL (x)) 8008 objc_add_method (objc_interface_context, setter_decl, false, true); 8009 else 8010 objc_add_method (objc_interface_context, setter_decl, false, false); 8011 TREE_DEPRECATED (setter_decl) = TREE_DEPRECATED (x); 8012 METHOD_PROPERTY_CONTEXT (setter_decl) = x; 8013 } 8014 } 8015 } 8016 break; 8017 } 8018 default: 8019 gcc_unreachable (); 8020 break; 8021 } 8022 } 8023 8024 static tree 8025 add_protocol (tree protocol) 8026 { 8027 /* Put protocol on list in reverse order. */ 8028 TREE_CHAIN (protocol) = protocol_chain; 8029 protocol_chain = protocol; 8030 return protocol_chain; 8031 } 8032 8033 /* Check that a protocol is defined, and, recursively, that all 8034 protocols that this protocol conforms to are defined too. */ 8035 static void 8036 check_that_protocol_is_defined (tree protocol) 8037 { 8038 if (!PROTOCOL_DEFINED (protocol)) 8039 warning (0, "definition of protocol %qE not found", 8040 PROTOCOL_NAME (protocol)); 8041 8042 /* If the protocol itself conforms to other protocols, check them 8043 too, recursively. */ 8044 if (PROTOCOL_LIST (protocol)) 8045 { 8046 tree p; 8047 8048 for (p = PROTOCOL_LIST (protocol); p; p = TREE_CHAIN (p)) 8049 check_that_protocol_is_defined (TREE_VALUE (p)); 8050 } 8051 } 8052 8053 /* Looks up a protocol. If 'warn_if_deprecated' is true, a warning is 8054 emitted if the protocol is deprecated. If 'definition_required' is 8055 true, a warning is emitted if a full @protocol definition has not 8056 been seen. */ 8057 static tree 8058 lookup_protocol (tree ident, bool warn_if_deprecated, bool definition_required) 8059 { 8060 tree chain; 8061 8062 for (chain = protocol_chain; chain; chain = TREE_CHAIN (chain)) 8063 if (ident == PROTOCOL_NAME (chain)) 8064 { 8065 if (warn_if_deprecated && TREE_DEPRECATED (chain)) 8066 { 8067 /* It would be nice to use warn_deprecated_use() here, but 8068 we are using TREE_CHAIN (which is supposed to be the 8069 TYPE_STUB_DECL for a TYPE) for something different. */ 8070 warning (OPT_Wdeprecated_declarations, "protocol %qE is deprecated", 8071 PROTOCOL_NAME (chain)); 8072 } 8073 8074 if (definition_required) 8075 check_that_protocol_is_defined (chain); 8076 8077 return chain; 8078 } 8079 8080 return NULL_TREE; 8081 } 8082 8083 /* This function forward declares the protocols named by NAMES. If 8084 they are already declared or defined, the function has no effect. */ 8085 8086 void 8087 objc_declare_protocol (tree name, tree attributes) 8088 { 8089 bool deprecated = false; 8090 8091 #ifdef OBJCPLUS 8092 if (current_namespace != global_namespace) { 8093 error ("Objective-C declarations may only appear in global scope"); 8094 } 8095 #endif /* OBJCPLUS */ 8096 8097 /* Determine if 'deprecated', the only attribute we recognize for 8098 protocols, was used. Ignore all other attributes. */ 8099 if (attributes) 8100 { 8101 tree attribute; 8102 for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute)) 8103 { 8104 tree name = TREE_PURPOSE (attribute); 8105 8106 if (is_attribute_p ("deprecated", name)) 8107 deprecated = true; 8108 else 8109 warning (OPT_Wattributes, "%qE attribute directive ignored", name); 8110 } 8111 } 8112 8113 if (lookup_protocol (name, /* warn if deprecated */ false, 8114 /* definition_required */ false) == NULL_TREE) 8115 { 8116 tree protocol = make_node (PROTOCOL_INTERFACE_TYPE); 8117 8118 TYPE_LANG_SLOT_1 (protocol) 8119 = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS); 8120 PROTOCOL_NAME (protocol) = name; 8121 PROTOCOL_LIST (protocol) = NULL_TREE; 8122 add_protocol (protocol); 8123 PROTOCOL_DEFINED (protocol) = 0; 8124 PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE; 8125 8126 if (attributes) 8127 { 8128 /* TODO: Do we need to store the attributes here ? */ 8129 TYPE_ATTRIBUTES (protocol) = attributes; 8130 if (deprecated) 8131 TREE_DEPRECATED (protocol) = 1; 8132 } 8133 } 8134 } 8135 8136 static tree 8137 start_protocol (enum tree_code code, tree name, tree list, tree attributes) 8138 { 8139 tree protocol; 8140 bool deprecated = false; 8141 8142 #ifdef OBJCPLUS 8143 if (current_namespace != global_namespace) { 8144 error ("Objective-C declarations may only appear in global scope"); 8145 } 8146 #endif /* OBJCPLUS */ 8147 8148 /* Determine if 'deprecated', the only attribute we recognize for 8149 protocols, was used. Ignore all other attributes. */ 8150 if (attributes) 8151 { 8152 tree attribute; 8153 for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute)) 8154 { 8155 tree name = TREE_PURPOSE (attribute); 8156 8157 if (is_attribute_p ("deprecated", name)) 8158 deprecated = true; 8159 else 8160 warning (OPT_Wattributes, "%qE attribute directive ignored", name); 8161 } 8162 } 8163 8164 protocol = lookup_protocol (name, /* warn_if_deprecated */ false, 8165 /* definition_required */ false); 8166 8167 if (!protocol) 8168 { 8169 protocol = make_node (code); 8170 TYPE_LANG_SLOT_1 (protocol) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS); 8171 8172 PROTOCOL_NAME (protocol) = name; 8173 PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list, /* definition_required */ false); 8174 add_protocol (protocol); 8175 PROTOCOL_DEFINED (protocol) = 1; 8176 PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE; 8177 8178 check_protocol_recursively (protocol, list); 8179 } 8180 else if (! PROTOCOL_DEFINED (protocol)) 8181 { 8182 PROTOCOL_DEFINED (protocol) = 1; 8183 PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list, /* definition_required */ false); 8184 8185 check_protocol_recursively (protocol, list); 8186 } 8187 else 8188 { 8189 warning (0, "duplicate declaration for protocol %qE", 8190 name); 8191 } 8192 8193 if (attributes) 8194 { 8195 TYPE_ATTRIBUTES (protocol) = attributes; 8196 if (deprecated) 8197 TREE_DEPRECATED (protocol) = 1; 8198 } 8199 8200 return protocol; 8201 } 8202 8203 /* Decay array and function parameters into pointers. */ 8204 8205 static tree 8206 objc_decay_parm_type (tree type) 8207 { 8208 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == FUNCTION_TYPE) 8209 type = build_pointer_type (TREE_CODE (type) == ARRAY_TYPE 8210 ? TREE_TYPE (type) 8211 : type); 8212 8213 return type; 8214 } 8215 8216 static GTY(()) tree objc_parmlist = NULL_TREE; 8217 8218 /* Append PARM to a list of formal parameters of a method, making a necessary 8219 array-to-pointer adjustment along the way. */ 8220 8221 void 8222 objc_push_parm (tree parm) 8223 { 8224 tree type; 8225 8226 if (TREE_TYPE (parm) == error_mark_node) 8227 { 8228 objc_parmlist = chainon (objc_parmlist, parm); 8229 return; 8230 } 8231 8232 /* Decay arrays and functions into pointers. */ 8233 type = objc_decay_parm_type (TREE_TYPE (parm)); 8234 8235 /* If the parameter type has been decayed, a new PARM_DECL needs to be 8236 built as well. */ 8237 if (type != TREE_TYPE (parm)) 8238 parm = build_decl (input_location, PARM_DECL, DECL_NAME (parm), type); 8239 8240 DECL_ARG_TYPE (parm) 8241 = lang_hooks.types.type_promotes_to (TREE_TYPE (parm)); 8242 8243 /* Record constancy and volatility. */ 8244 c_apply_type_quals_to_decl 8245 ((TYPE_READONLY (TREE_TYPE (parm)) ? TYPE_QUAL_CONST : 0) 8246 | (TYPE_RESTRICT (TREE_TYPE (parm)) ? TYPE_QUAL_RESTRICT : 0) 8247 | (TYPE_VOLATILE (TREE_TYPE (parm)) ? TYPE_QUAL_VOLATILE : 0), parm); 8248 8249 objc_parmlist = chainon (objc_parmlist, parm); 8250 } 8251 8252 /* Retrieve the formal parameter list constructed via preceding calls to 8253 objc_push_parm(). */ 8254 8255 #ifdef OBJCPLUS 8256 tree 8257 objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED, 8258 tree expr ATTRIBUTE_UNUSED) 8259 { 8260 tree parm_info = objc_parmlist; 8261 objc_parmlist = NULL_TREE; 8262 8263 return parm_info; 8264 } 8265 #else 8266 struct c_arg_info * 8267 objc_get_parm_info (int have_ellipsis, tree expr) 8268 { 8269 tree parm_info = objc_parmlist; 8270 struct c_arg_info *arg_info; 8271 /* The C front-end requires an elaborate song and dance at 8272 this point. */ 8273 push_scope (); 8274 declare_parm_level (); 8275 while (parm_info) 8276 { 8277 tree next = DECL_CHAIN (parm_info); 8278 8279 DECL_CHAIN (parm_info) = NULL_TREE; 8280 parm_info = pushdecl (parm_info); 8281 finish_decl (parm_info, input_location, NULL_TREE, NULL_TREE, NULL_TREE); 8282 parm_info = next; 8283 } 8284 arg_info = get_parm_info (have_ellipsis, expr); 8285 pop_scope (); 8286 objc_parmlist = NULL_TREE; 8287 return arg_info; 8288 } 8289 #endif 8290 8291 /* Synthesize the formal parameters 'id self' and 'SEL _cmd' needed for ObjC 8292 method definitions. In the case of instance methods, we can be more 8293 specific as to the type of 'self'. */ 8294 8295 static void 8296 synth_self_and_ucmd_args (void) 8297 { 8298 tree self_type; 8299 8300 if (objc_method_context 8301 && TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL) 8302 self_type = objc_instance_type; 8303 else 8304 /* Really a `struct objc_class *'. However, we allow people to 8305 assign to self, which changes its type midstream. */ 8306 self_type = objc_object_type; 8307 8308 /* id self; */ 8309 objc_push_parm (build_decl (input_location, 8310 PARM_DECL, self_id, self_type)); 8311 8312 /* SEL _cmd; */ 8313 objc_push_parm (build_decl (input_location, 8314 PARM_DECL, ucmd_id, objc_selector_type)); 8315 } 8316 8317 /* Transform an Objective-C method definition into a static C function 8318 definition, synthesizing the first two arguments, "self" and "_cmd", 8319 in the process. EXPR is NULL or an expression that needs to be 8320 evaluated for the side effects of array size expressions in the 8321 parameters. */ 8322 8323 static void 8324 start_method_def (tree method, tree expr) 8325 { 8326 tree parmlist; 8327 #ifdef OBJCPLUS 8328 tree parm_info; 8329 #else 8330 struct c_arg_info *parm_info; 8331 #endif 8332 int have_ellipsis = 0; 8333 8334 /* If we are defining a "dealloc" method in a non-root class, we 8335 will need to check if a [super dealloc] is missing, and warn if 8336 it is. */ 8337 if(CLASS_SUPER_NAME (objc_implementation_context) 8338 && !strcmp ("dealloc", IDENTIFIER_POINTER (METHOD_SEL_NAME (method)))) 8339 should_call_super_dealloc = 1; 8340 else 8341 should_call_super_dealloc = 0; 8342 8343 /* Required to implement _msgSuper. */ 8344 objc_method_context = method; 8345 UOBJC_SUPER_decl = NULL_TREE; 8346 8347 /* Generate prototype declarations for arguments..."new-style". */ 8348 synth_self_and_ucmd_args (); 8349 8350 /* Generate argument declarations if a keyword_decl. */ 8351 parmlist = METHOD_SEL_ARGS (method); 8352 while (parmlist) 8353 { 8354 /* parmlist is a KEYWORD_DECL. */ 8355 tree type = TREE_VALUE (TREE_TYPE (parmlist)); 8356 tree parm; 8357 8358 parm = build_decl (input_location, 8359 PARM_DECL, KEYWORD_ARG_NAME (parmlist), type); 8360 decl_attributes (&parm, DECL_ATTRIBUTES (parmlist), 0); 8361 objc_push_parm (parm); 8362 parmlist = DECL_CHAIN (parmlist); 8363 } 8364 8365 if (METHOD_ADD_ARGS (method)) 8366 { 8367 tree akey; 8368 8369 for (akey = TREE_CHAIN (METHOD_ADD_ARGS (method)); 8370 akey; akey = TREE_CHAIN (akey)) 8371 { 8372 objc_push_parm (TREE_VALUE (akey)); 8373 } 8374 8375 if (METHOD_ADD_ARGS_ELLIPSIS_P (method)) 8376 have_ellipsis = 1; 8377 } 8378 8379 parm_info = objc_get_parm_info (have_ellipsis, expr); 8380 8381 really_start_method (objc_method_context, parm_info); 8382 } 8383 8384 /* Return 1 if TYPE1 is equivalent to TYPE2 for purposes of method 8385 overloading. */ 8386 static int 8387 objc_types_are_equivalent (tree type1, tree type2) 8388 { 8389 if (type1 == type2) 8390 return 1; 8391 8392 /* Strip away indirections. */ 8393 while ((TREE_CODE (type1) == ARRAY_TYPE || TREE_CODE (type1) == POINTER_TYPE) 8394 && (TREE_CODE (type1) == TREE_CODE (type2))) 8395 type1 = TREE_TYPE (type1), type2 = TREE_TYPE (type2); 8396 if (TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2)) 8397 return 0; 8398 8399 /* Compare the protocol lists. */ 8400 type1 = (TYPE_HAS_OBJC_INFO (type1) 8401 ? TYPE_OBJC_PROTOCOL_LIST (type1) 8402 : NULL_TREE); 8403 type2 = (TYPE_HAS_OBJC_INFO (type2) 8404 ? TYPE_OBJC_PROTOCOL_LIST (type2) 8405 : NULL_TREE); 8406 8407 /* If there are no protocols (most common case), the types are 8408 identical. */ 8409 if (type1 == NULL_TREE && type2 == NULL_TREE) 8410 return 1; 8411 8412 /* If one has protocols, and the other one hasn't, they are not 8413 identical. */ 8414 if ((type1 == NULL_TREE && type2 != NULL_TREE) 8415 || (type1 != NULL_TREE && type2 == NULL_TREE)) 8416 return 0; 8417 else 8418 { 8419 /* Else, both have protocols, and we need to do the full 8420 comparison. It is possible that either type1 or type2 8421 contain some duplicate protocols in the list, so we can't 8422 even just compare list_length as a first check. */ 8423 tree t; 8424 8425 for (t = type2; t; t = TREE_CHAIN (t)) 8426 if (!lookup_protocol_in_reflist (type1, TREE_VALUE (t))) 8427 return 0; 8428 8429 for (t = type1; t; t = TREE_CHAIN (t)) 8430 if (!lookup_protocol_in_reflist (type2, TREE_VALUE (t))) 8431 return 0; 8432 8433 return 1; 8434 } 8435 } 8436 8437 /* Return 1 if TYPE1 has the same size and alignment as TYPE2. */ 8438 8439 static int 8440 objc_types_share_size_and_alignment (tree type1, tree type2) 8441 { 8442 return (simple_cst_equal (TYPE_SIZE (type1), TYPE_SIZE (type2)) 8443 && TYPE_ALIGN (type1) == TYPE_ALIGN (type2)); 8444 } 8445 8446 /* Return 1 if PROTO1 is equivalent to PROTO2 8447 for purposes of method overloading. Ordinarily, the type signatures 8448 should match up exactly, unless STRICT is zero, in which case we 8449 shall allow differences in which the size and alignment of a type 8450 is the same. */ 8451 8452 static int 8453 comp_proto_with_proto (tree proto1, tree proto2, int strict) 8454 { 8455 tree type1, type2; 8456 8457 /* The following test is needed in case there are hashing 8458 collisions. */ 8459 if (METHOD_SEL_NAME (proto1) != METHOD_SEL_NAME (proto2)) 8460 return 0; 8461 8462 /* Compare return types. */ 8463 type1 = TREE_VALUE (TREE_TYPE (proto1)); 8464 type2 = TREE_VALUE (TREE_TYPE (proto2)); 8465 8466 if (!objc_types_are_equivalent (type1, type2) 8467 && (strict || !objc_types_share_size_and_alignment (type1, type2))) 8468 return 0; 8469 8470 /* Compare argument types. */ 8471 8472 /* The first argument (objc_object_type) is always the same, no need 8473 to compare. */ 8474 8475 /* The second argument (objc_selector_type) is always the same, no 8476 need to compare. */ 8477 8478 /* Compare the other arguments. */ 8479 { 8480 tree arg1, arg2; 8481 8482 /* Compare METHOD_SEL_ARGS. */ 8483 for (arg1 = METHOD_SEL_ARGS (proto1), arg2 = METHOD_SEL_ARGS (proto2); 8484 arg1 && arg2; 8485 arg1 = DECL_CHAIN (arg1), arg2 = DECL_CHAIN (arg2)) 8486 { 8487 type1 = TREE_VALUE (TREE_TYPE (arg1)); 8488 type2 = TREE_VALUE (TREE_TYPE (arg2)); 8489 8490 /* FIXME: Do we need to decay argument types to compare them ? */ 8491 type1 = objc_decay_parm_type (type1); 8492 type2 = objc_decay_parm_type (type2); 8493 8494 if (!objc_types_are_equivalent (type1, type2) 8495 && (strict || !objc_types_share_size_and_alignment (type1, type2))) 8496 return 0; 8497 } 8498 8499 /* The loop ends when arg1 or arg2 are NULL. Make sure they are 8500 both NULL. */ 8501 if (arg1 != arg2) 8502 return 0; 8503 8504 /* Compare METHOD_ADD_ARGS. */ 8505 if ((METHOD_ADD_ARGS (proto1) && !METHOD_ADD_ARGS (proto2)) 8506 || (METHOD_ADD_ARGS (proto2) && !METHOD_ADD_ARGS (proto1))) 8507 return 0; 8508 8509 if (METHOD_ADD_ARGS (proto1)) 8510 { 8511 for (arg1 = TREE_CHAIN (METHOD_ADD_ARGS (proto1)), arg2 = TREE_CHAIN (METHOD_ADD_ARGS (proto2)); 8512 arg1 && arg2; 8513 arg1 = TREE_CHAIN (arg1), arg2 = TREE_CHAIN (arg2)) 8514 { 8515 type1 = TREE_TYPE (TREE_VALUE (arg1)); 8516 type2 = TREE_TYPE (TREE_VALUE (arg2)); 8517 8518 /* FIXME: Do we need to decay argument types to compare them ? */ 8519 type1 = objc_decay_parm_type (type1); 8520 type2 = objc_decay_parm_type (type2); 8521 8522 if (!objc_types_are_equivalent (type1, type2) 8523 && (strict || !objc_types_share_size_and_alignment (type1, type2))) 8524 return 0; 8525 } 8526 } 8527 8528 /* The loop ends when arg1 or arg2 are NULL. Make sure they are 8529 both NULL. */ 8530 if (arg1 != arg2) 8531 return 0; 8532 8533 /* Compare METHOD_ADD_ARGS_ELLIPSIS_P. */ 8534 if (METHOD_ADD_ARGS_ELLIPSIS_P (proto1) != METHOD_ADD_ARGS_ELLIPSIS_P (proto2)) 8535 return 0; 8536 } 8537 8538 /* Success. */ 8539 return 1; 8540 } 8541 8542 /* This routine returns true if TYPE is a valid objc object type, 8543 suitable for messaging; false otherwise. If 'accept_class' is 8544 'true', then a Class object is considered valid for messaging and 8545 'true' is returned if 'type' refers to a Class. If 'accept_class' 8546 is 'false', then a Class object is not considered valid for 8547 messaging and 'false' is returned in that case. */ 8548 8549 static bool 8550 objc_type_valid_for_messaging (tree type, bool accept_classes) 8551 { 8552 if (!POINTER_TYPE_P (type)) 8553 return false; 8554 8555 /* Remove the pointer indirection; don't remove more than one 8556 otherwise we'd consider "NSObject **" a valid type for messaging, 8557 which it isn't. */ 8558 type = TREE_TYPE (type); 8559 8560 if (TREE_CODE (type) != RECORD_TYPE) 8561 return false; 8562 8563 if (objc_is_object_id (type)) 8564 return true; 8565 8566 if (objc_is_class_id (type)) 8567 return accept_classes; 8568 8569 if (TYPE_HAS_OBJC_INFO (type)) 8570 return true; 8571 8572 return false; 8573 } 8574 8575 void 8576 objc_start_function (tree name, tree type, tree attrs, 8577 #ifdef OBJCPLUS 8578 tree params 8579 #else 8580 struct c_arg_info *params 8581 #endif 8582 ) 8583 { 8584 tree fndecl = build_decl (input_location, 8585 FUNCTION_DECL, name, type); 8586 8587 #ifdef OBJCPLUS 8588 DECL_ARGUMENTS (fndecl) = params; 8589 DECL_INITIAL (fndecl) = error_mark_node; 8590 DECL_EXTERNAL (fndecl) = 0; 8591 TREE_STATIC (fndecl) = 1; 8592 retrofit_lang_decl (fndecl); 8593 cplus_decl_attributes (&fndecl, attrs, 0); 8594 start_preparsed_function (fndecl, attrs, /*flags=*/SF_DEFAULT); 8595 #else 8596 current_function_returns_value = 0; /* Assume, until we see it does. */ 8597 current_function_returns_null = 0; 8598 decl_attributes (&fndecl, attrs, 0); 8599 announce_function (fndecl); 8600 DECL_INITIAL (fndecl) = error_mark_node; 8601 DECL_EXTERNAL (fndecl) = 0; 8602 TREE_STATIC (fndecl) = 1; 8603 current_function_decl = pushdecl (fndecl); 8604 push_scope (); 8605 declare_parm_level (); 8606 DECL_RESULT (current_function_decl) 8607 = build_decl (input_location, 8608 RESULT_DECL, NULL_TREE, 8609 TREE_TYPE (TREE_TYPE (current_function_decl))); 8610 DECL_ARTIFICIAL (DECL_RESULT (current_function_decl)) = 1; 8611 DECL_IGNORED_P (DECL_RESULT (current_function_decl)) = 1; 8612 start_fname_decls (); 8613 store_parm_decls_from (params); 8614 #endif 8615 8616 TREE_USED (current_function_decl) = 1; 8617 } 8618 8619 /* - Generate an identifier for the function. the format is "_n_cls", 8620 where 1 <= n <= nMethods, and cls is the name the implementation we 8621 are processing. 8622 - Install the return type from the method declaration. 8623 - If we have a prototype, check for type consistency. */ 8624 8625 static void 8626 really_start_method (tree method, 8627 #ifdef OBJCPLUS 8628 tree parmlist 8629 #else 8630 struct c_arg_info *parmlist 8631 #endif 8632 ) 8633 { 8634 tree ret_type, meth_type; 8635 tree method_id; 8636 const char *sel_name, *class_name, *cat_name; 8637 char *buf; 8638 8639 /* Synth the storage class & assemble the return type. */ 8640 ret_type = TREE_VALUE (TREE_TYPE (method)); 8641 8642 sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method)); 8643 class_name = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context)); 8644 cat_name = ((TREE_CODE (objc_implementation_context) 8645 == CLASS_IMPLEMENTATION_TYPE) 8646 ? NULL 8647 : IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context))); 8648 method_slot++; 8649 8650 /* Make sure this is big enough for any plausible method label. */ 8651 buf = (char *) alloca (50 + strlen (sel_name) + strlen (class_name) 8652 + (cat_name ? strlen (cat_name) : 0)); 8653 8654 OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL, 8655 class_name, cat_name, sel_name, method_slot); 8656 8657 method_id = get_identifier (buf); 8658 8659 #ifdef OBJCPLUS 8660 /* Objective-C methods cannot be overloaded, so we don't need 8661 the type encoding appended. It looks bad anyway... */ 8662 push_lang_context (lang_name_c); 8663 #endif 8664 8665 meth_type = build_function_type_for_method (ret_type, method, METHOD_DEF, 0); 8666 objc_start_function (method_id, meth_type, NULL_TREE, parmlist); 8667 8668 /* Set self_decl from the first argument. */ 8669 self_decl = DECL_ARGUMENTS (current_function_decl); 8670 8671 /* Suppress unused warnings. */ 8672 TREE_USED (self_decl) = 1; 8673 DECL_READ_P (self_decl) = 1; 8674 TREE_USED (DECL_CHAIN (self_decl)) = 1; 8675 DECL_READ_P (DECL_CHAIN (self_decl)) = 1; 8676 #ifdef OBJCPLUS 8677 pop_lang_context (); 8678 #endif 8679 8680 METHOD_DEFINITION (method) = current_function_decl; 8681 8682 /* Check consistency...start_function, pushdecl, duplicate_decls. */ 8683 8684 if (implementation_template != objc_implementation_context) 8685 { 8686 tree proto 8687 = lookup_method_static (implementation_template, 8688 METHOD_SEL_NAME (method), 8689 ((TREE_CODE (method) == CLASS_METHOD_DECL) 8690 | OBJC_LOOKUP_NO_SUPER)); 8691 8692 if (proto) 8693 { 8694 if (!comp_proto_with_proto (method, proto, 1)) 8695 { 8696 bool type = TREE_CODE (method) == INSTANCE_METHOD_DECL; 8697 8698 warning_at (DECL_SOURCE_LOCATION (method), 0, 8699 "conflicting types for %<%c%s%>", 8700 (type ? '-' : '+'), 8701 identifier_to_locale (gen_method_decl (method))); 8702 inform (DECL_SOURCE_LOCATION (proto), 8703 "previous declaration of %<%c%s%>", 8704 (type ? '-' : '+'), 8705 identifier_to_locale (gen_method_decl (proto))); 8706 } 8707 else 8708 { 8709 /* If the method in the @interface was deprecated, mark 8710 the implemented method as deprecated too. It should 8711 never be used for messaging (when the deprecation 8712 warnings are produced), but just in case. */ 8713 if (TREE_DEPRECATED (proto)) 8714 TREE_DEPRECATED (method) = 1; 8715 8716 /* If the method in the @interface was marked as 8717 'noreturn', mark the function implementing the method 8718 as 'noreturn' too. */ 8719 TREE_THIS_VOLATILE (current_function_decl) = TREE_THIS_VOLATILE (proto); 8720 } 8721 } 8722 else 8723 { 8724 /* We have a method @implementation even though we did not 8725 see a corresponding @interface declaration (which is allowed 8726 by Objective-C rules). Go ahead and place the method in 8727 the @interface anyway, so that message dispatch lookups 8728 will see it. */ 8729 tree interface = implementation_template; 8730 8731 if (TREE_CODE (objc_implementation_context) 8732 == CATEGORY_IMPLEMENTATION_TYPE) 8733 interface = lookup_category 8734 (interface, 8735 CLASS_SUPER_NAME (objc_implementation_context)); 8736 8737 if (interface) 8738 objc_add_method (interface, copy_node (method), 8739 TREE_CODE (method) == CLASS_METHOD_DECL, 8740 /* is_optional= */ false); 8741 } 8742 } 8743 } 8744 8745 static void *UOBJC_SUPER_scope = 0; 8746 8747 /* _n_Method (id self, SEL sel, ...) 8748 { 8749 struct objc_super _S; 8750 _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...); 8751 } */ 8752 8753 static tree 8754 get_super_receiver (void) 8755 { 8756 if (objc_method_context) 8757 { 8758 tree super_expr, super_expr_list, class_expr; 8759 bool inst_meth; 8760 if (!UOBJC_SUPER_decl) 8761 { 8762 UOBJC_SUPER_decl = build_decl (input_location, 8763 VAR_DECL, get_identifier (TAG_SUPER), 8764 objc_super_template); 8765 /* This prevents `unused variable' warnings when compiling with -Wall. */ 8766 TREE_USED (UOBJC_SUPER_decl) = 1; 8767 DECL_READ_P (UOBJC_SUPER_decl) = 1; 8768 lang_hooks.decls.pushdecl (UOBJC_SUPER_decl); 8769 finish_decl (UOBJC_SUPER_decl, input_location, NULL_TREE, NULL_TREE, 8770 NULL_TREE); 8771 UOBJC_SUPER_scope = objc_get_current_scope (); 8772 } 8773 8774 /* Set receiver to self. */ 8775 super_expr = objc_build_component_ref (UOBJC_SUPER_decl, self_id); 8776 super_expr = build_modify_expr (input_location, super_expr, NULL_TREE, 8777 NOP_EXPR, input_location, self_decl, 8778 NULL_TREE); 8779 super_expr_list = super_expr; 8780 8781 /* Set class to begin searching. */ 8782 /* Get the ident for the superclass class field & build a ref to it. 8783 ??? maybe we should just name the field the same for all runtimes. */ 8784 super_expr = (*runtime.super_superclassfield_ident) (); 8785 super_expr = objc_build_component_ref (UOBJC_SUPER_decl, super_expr); 8786 8787 gcc_assert (imp_list->imp_context == objc_implementation_context 8788 && imp_list->imp_template == implementation_template); 8789 inst_meth = (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL); 8790 8791 if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE) 8792 class_expr = (*runtime.get_class_super_ref) (input_location, 8793 imp_list, inst_meth); 8794 else 8795 /* We have a category. */ 8796 { 8797 tree super_name = CLASS_SUPER_NAME (imp_list->imp_template); 8798 tree super_class; 8799 8800 /* Barf if super used in a category of a root object. */ 8801 if (!super_name) 8802 { 8803 error ("no super class declared in interface for %qE", 8804 CLASS_NAME (imp_list->imp_template)); 8805 return error_mark_node; 8806 } 8807 8808 super_class = (*runtime.get_category_super_ref) (input_location, 8809 imp_list, inst_meth); 8810 class_expr = build_c_cast (input_location, 8811 TREE_TYPE (super_expr), super_class); 8812 } 8813 8814 super_expr = build_modify_expr (input_location, super_expr, NULL_TREE, 8815 NOP_EXPR, 8816 input_location, class_expr, NULL_TREE); 8817 8818 super_expr_list = build_compound_expr (input_location, 8819 super_expr_list, super_expr); 8820 8821 super_expr = build_unary_op (input_location, 8822 ADDR_EXPR, UOBJC_SUPER_decl, 0); 8823 super_expr_list = build_compound_expr (input_location, 8824 super_expr_list, super_expr); 8825 8826 return super_expr_list; 8827 } 8828 else 8829 { 8830 error ("[super ...] must appear in a method context"); 8831 return error_mark_node; 8832 } 8833 } 8834 8835 /* When exiting a scope, sever links to a 'super' declaration (if any) 8836 therein contained. */ 8837 8838 void 8839 objc_clear_super_receiver (void) 8840 { 8841 if (objc_method_context 8842 && UOBJC_SUPER_scope == objc_get_current_scope ()) 8843 { 8844 UOBJC_SUPER_decl = 0; 8845 UOBJC_SUPER_scope = 0; 8846 } 8847 } 8848 8849 void 8850 objc_finish_method_definition (tree fndecl) 8851 { 8852 /* We cannot validly inline ObjC methods, at least not without a language 8853 extension to declare that a method need not be dynamically 8854 dispatched, so suppress all thoughts of doing so. */ 8855 DECL_UNINLINABLE (fndecl) = 1; 8856 8857 #ifndef OBJCPLUS 8858 /* The C++ front-end will have called finish_function() for us. */ 8859 finish_function (); 8860 #endif 8861 8862 METHOD_ENCODING (objc_method_context) 8863 = encode_method_prototype (objc_method_context); 8864 8865 /* Required to implement _msgSuper. This must be done AFTER finish_function, 8866 since the optimizer may find "may be used before set" errors. */ 8867 objc_method_context = NULL_TREE; 8868 8869 if (should_call_super_dealloc) 8870 warning (0, "method possibly missing a [super dealloc] call"); 8871 } 8872 8873 /* Given a tree DECL node, produce a printable description of it in the given 8874 buffer, overwriting the buffer. */ 8875 8876 static char * 8877 gen_declaration (tree decl) 8878 { 8879 errbuf[0] = '\0'; 8880 8881 if (DECL_P (decl)) 8882 { 8883 gen_type_name_0 (TREE_TYPE (decl)); 8884 8885 if (DECL_NAME (decl)) 8886 { 8887 if (!POINTER_TYPE_P (TREE_TYPE (decl))) 8888 strcat (errbuf, " "); 8889 8890 strcat (errbuf, IDENTIFIER_POINTER (DECL_NAME (decl))); 8891 } 8892 8893 if (DECL_INITIAL (decl) 8894 && TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST) 8895 sprintf (errbuf + strlen (errbuf), ": " HOST_WIDE_INT_PRINT_DEC, 8896 TREE_INT_CST_LOW (DECL_INITIAL (decl))); 8897 } 8898 8899 return errbuf; 8900 } 8901 8902 /* Given a tree TYPE node, produce a printable description of it in the given 8903 buffer, overwriting the buffer. */ 8904 8905 static char * 8906 gen_type_name_0 (tree type) 8907 { 8908 tree orig = type, proto; 8909 8910 if (TYPE_P (type) && TYPE_NAME (type)) 8911 type = TYPE_NAME (type); 8912 else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE) 8913 { 8914 tree inner = TREE_TYPE (type); 8915 8916 while (TREE_CODE (inner) == ARRAY_TYPE) 8917 inner = TREE_TYPE (inner); 8918 8919 gen_type_name_0 (inner); 8920 8921 if (!POINTER_TYPE_P (inner)) 8922 strcat (errbuf, " "); 8923 8924 if (POINTER_TYPE_P (type)) 8925 strcat (errbuf, "*"); 8926 else 8927 while (type != inner) 8928 { 8929 strcat (errbuf, "["); 8930 8931 if (TYPE_DOMAIN (type)) 8932 { 8933 char sz[20]; 8934 8935 sprintf (sz, HOST_WIDE_INT_PRINT_DEC, 8936 (TREE_INT_CST_LOW 8937 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1)); 8938 strcat (errbuf, sz); 8939 } 8940 8941 strcat (errbuf, "]"); 8942 type = TREE_TYPE (type); 8943 } 8944 8945 goto exit_function; 8946 } 8947 8948 if (TREE_CODE (type) == TYPE_DECL && DECL_NAME (type)) 8949 type = DECL_NAME (type); 8950 8951 strcat (errbuf, TREE_CODE (type) == IDENTIFIER_NODE 8952 ? IDENTIFIER_POINTER (type) 8953 : ""); 8954 8955 /* For 'id' and 'Class', adopted protocols are stored in the pointee. */ 8956 if (objc_is_id (orig)) 8957 orig = TREE_TYPE (orig); 8958 8959 proto = TYPE_HAS_OBJC_INFO (orig) ? TYPE_OBJC_PROTOCOL_LIST (orig) : NULL_TREE; 8960 8961 if (proto) 8962 { 8963 strcat (errbuf, " <"); 8964 8965 while (proto) { 8966 strcat (errbuf, 8967 IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto)))); 8968 proto = TREE_CHAIN (proto); 8969 strcat (errbuf, proto ? ", " : ">"); 8970 } 8971 } 8972 8973 exit_function: 8974 return errbuf; 8975 } 8976 8977 static char * 8978 gen_type_name (tree type) 8979 { 8980 errbuf[0] = '\0'; 8981 8982 return gen_type_name_0 (type); 8983 } 8984 8985 /* Given a method tree, put a printable description into the given 8986 buffer (overwriting) and return a pointer to the buffer. */ 8987 8988 static char * 8989 gen_method_decl (tree method) 8990 { 8991 tree chain; 8992 8993 strcpy (errbuf, "("); /* NB: Do _not_ call strcat() here. */ 8994 gen_type_name_0 (TREE_VALUE (TREE_TYPE (method))); 8995 strcat (errbuf, ")"); 8996 chain = METHOD_SEL_ARGS (method); 8997 8998 if (chain) 8999 { 9000 /* We have a chain of keyword_decls. */ 9001 do 9002 { 9003 if (KEYWORD_KEY_NAME (chain)) 9004 strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain))); 9005 9006 strcat (errbuf, ":("); 9007 gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain))); 9008 strcat (errbuf, ")"); 9009 9010 strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain))); 9011 if ((chain = DECL_CHAIN (chain))) 9012 strcat (errbuf, " "); 9013 } 9014 while (chain); 9015 9016 if (METHOD_ADD_ARGS (method)) 9017 { 9018 chain = TREE_CHAIN (METHOD_ADD_ARGS (method)); 9019 9020 /* Know we have a chain of parm_decls. */ 9021 while (chain) 9022 { 9023 strcat (errbuf, ", "); 9024 gen_type_name_0 (TREE_TYPE (TREE_VALUE (chain))); 9025 chain = TREE_CHAIN (chain); 9026 } 9027 9028 if (METHOD_ADD_ARGS_ELLIPSIS_P (method)) 9029 strcat (errbuf, ", ..."); 9030 } 9031 } 9032 9033 else 9034 /* We have a unary selector. */ 9035 strcat (errbuf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method))); 9036 9037 return errbuf; 9038 } 9039 9040 /* Debug info. */ 9041 9042 9043 /* Dump an @interface declaration of the supplied class CHAIN to the 9044 supplied file FP. Used to implement the -gen-decls option (which 9045 prints out an @interface declaration of all classes compiled in 9046 this run); potentially useful for debugging the compiler too. */ 9047 void 9048 dump_interface (FILE *fp, tree chain) 9049 { 9050 /* FIXME: A heap overflow here whenever a method (or ivar) 9051 declaration is so long that it doesn't fit in the buffer. The 9052 code and all the related functions should be rewritten to avoid 9053 using fixed size buffers. */ 9054 const char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain)); 9055 tree ivar_decls = CLASS_RAW_IVARS (chain); 9056 tree nst_methods = CLASS_NST_METHODS (chain); 9057 tree cls_methods = CLASS_CLS_METHODS (chain); 9058 9059 fprintf (fp, "\n@interface %s", my_name); 9060 9061 /* CLASS_SUPER_NAME is used to store the superclass name for 9062 classes, and the category name for categories. */ 9063 if (CLASS_SUPER_NAME (chain)) 9064 { 9065 const char *name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain)); 9066 9067 switch (TREE_CODE (chain)) 9068 { 9069 case CATEGORY_IMPLEMENTATION_TYPE: 9070 case CATEGORY_INTERFACE_TYPE: 9071 fprintf (fp, " (%s)\n", name); 9072 break; 9073 default: 9074 fprintf (fp, " : %s\n", name); 9075 break; 9076 } 9077 } 9078 else 9079 fprintf (fp, "\n"); 9080 9081 /* FIXME - the following doesn't seem to work at the moment. */ 9082 if (ivar_decls) 9083 { 9084 fprintf (fp, "{\n"); 9085 do 9086 { 9087 fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls)); 9088 ivar_decls = TREE_CHAIN (ivar_decls); 9089 } 9090 while (ivar_decls); 9091 fprintf (fp, "}\n"); 9092 } 9093 9094 while (nst_methods) 9095 { 9096 fprintf (fp, "- %s;\n", gen_method_decl (nst_methods)); 9097 nst_methods = TREE_CHAIN (nst_methods); 9098 } 9099 9100 while (cls_methods) 9101 { 9102 fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods)); 9103 cls_methods = TREE_CHAIN (cls_methods); 9104 } 9105 9106 fprintf (fp, "@end\n"); 9107 } 9108 9109 #if 0 9110 /* Produce the pretty printing for an Objective-C method. This is 9111 currently unused, but could be handy while reorganizing the pretty 9112 printing to be more robust. */ 9113 static const char * 9114 objc_pretty_print_method (bool is_class_method, 9115 const char *class_name, 9116 const char *category_name, 9117 const char *selector) 9118 { 9119 if (category_name) 9120 { 9121 char *result = XNEWVEC (char, strlen (class_name) + strlen (category_name) 9122 + strlen (selector) + 7); 9123 9124 if (is_class_method) 9125 sprintf (result, "+[%s(%s) %s]", class_name, category_name, selector); 9126 else 9127 sprintf (result, "-[%s(%s) %s]", class_name, category_name, selector); 9128 9129 return result; 9130 } 9131 else 9132 { 9133 char *result = XNEWVEC (char, strlen (class_name) 9134 + strlen (selector) + 5); 9135 9136 if (is_class_method) 9137 sprintf (result, "+[%s %s]", class_name, selector); 9138 else 9139 sprintf (result, "-[%s %s]", class_name, selector); 9140 9141 return result; 9142 } 9143 } 9144 #endif 9145 9146 /* Demangle function for Objective-C. Attempt to demangle the 9147 function name associated with a method (eg, going from 9148 "_i_NSObject__class" to "-[NSObject class]"); usually for the 9149 purpose of pretty printing or error messages. Return the demangled 9150 name, or NULL if the string is not an Objective-C mangled method 9151 name. 9152 9153 Because of how the mangling is done, any method that has a '_' in 9154 its original name is at risk of being demangled incorrectly. In 9155 some cases there are multiple valid ways to demangle a method name 9156 and there is no way we can decide. 9157 9158 TODO: objc_demangle() can't always get it right; the right way to 9159 get this correct for all method names would be to store the 9160 Objective-C method name somewhere in the function decl. Then, 9161 there is no demangling to do; we'd just pull the method name out of 9162 the decl. As an additional bonus, when printing error messages we 9163 could check for such a method name, and if we find it, we know the 9164 function is actually an Objective-C method and we could print error 9165 messages saying "In method '+[NSObject class]" instead of "In 9166 function '+[NSObject class]" as we do now. */ 9167 static const char * 9168 objc_demangle (const char *mangled) 9169 { 9170 char *demangled, *cp; 9171 9172 /* First of all, if the name is too short it can't be an Objective-C 9173 mangled method name. */ 9174 if (mangled[0] == '\0' || mangled[1] == '\0' || mangled[2] == '\0') 9175 return NULL; 9176 9177 /* If the name looks like an already demangled one, return it 9178 unchanged. This should only happen on Darwin, where method names 9179 are mangled differently into a pretty-print form (such as 9180 '+[NSObject class]', see darwin.h). In that case, demangling is 9181 a no-op, but we need to return the demangled name if it was an 9182 ObjC one, and return NULL if not. We should be safe as no C/C++ 9183 function can start with "-[" or "+[". */ 9184 if ((mangled[0] == '-' || mangled[0] == '+') 9185 && (mangled[1] == '[')) 9186 return mangled; 9187 9188 if (mangled[0] == '_' && 9189 (mangled[1] == 'i' || mangled[1] == 'c') && 9190 mangled[2] == '_') 9191 { 9192 cp = demangled = XNEWVEC (char, strlen(mangled) + 2); 9193 if (mangled[1] == 'i') 9194 *cp++ = '-'; /* for instance method */ 9195 else 9196 *cp++ = '+'; /* for class method */ 9197 *cp++ = '['; /* opening left brace */ 9198 strcpy(cp, mangled+3); /* tack on the rest of the mangled name */ 9199 while (*cp && *cp == '_') 9200 cp++; /* skip any initial underbars in class name */ 9201 cp = strchr(cp, '_'); /* find first non-initial underbar */ 9202 if (cp == NULL) 9203 { 9204 free(demangled); /* not mangled name */ 9205 return NULL; 9206 } 9207 if (cp[1] == '_') /* easy case: no category name */ 9208 { 9209 *cp++ = ' '; /* replace two '_' with one ' ' */ 9210 strcpy(cp, mangled + (cp - demangled) + 2); 9211 } 9212 else 9213 { 9214 *cp++ = '('; /* less easy case: category name */ 9215 cp = strchr(cp, '_'); 9216 if (cp == 0) 9217 { 9218 free(demangled); /* not mangled name */ 9219 return NULL; 9220 } 9221 *cp++ = ')'; 9222 *cp++ = ' '; /* overwriting 1st char of method name... */ 9223 strcpy(cp, mangled + (cp - demangled)); /* get it back */ 9224 } 9225 /* Now we have the method name. We need to generally replace 9226 '_' with ':' but trying to preserve '_' if it could only have 9227 been in the mangled string because it was already in the 9228 original name. In cases where it's ambiguous, we assume that 9229 any '_' originated from a ':'. */ 9230 9231 /* Initial '_'s in method name can't have been generating by 9232 converting ':'s. Skip them. */ 9233 while (*cp && *cp == '_') 9234 cp++; 9235 9236 /* If the method name does not end with '_', then it has no 9237 arguments and there was no replacement of ':'s with '_'s 9238 during mangling. Check for that case, and skip any 9239 replacement if so. This at least guarantees that methods 9240 with no arguments are always demangled correctly (unless the 9241 original name ends with '_'). */ 9242 if (*(mangled + strlen (mangled) - 1) != '_') 9243 { 9244 /* Skip to the end. */ 9245 for (; *cp; cp++) 9246 ; 9247 } 9248 else 9249 { 9250 /* Replace remaining '_' with ':'. This may get it wrong if 9251 there were '_'s in the original name. In most cases it 9252 is impossible to disambiguate. */ 9253 for (; *cp; cp++) 9254 if (*cp == '_') 9255 *cp = ':'; 9256 } 9257 *cp++ = ']'; /* closing right brace */ 9258 *cp++ = 0; /* string terminator */ 9259 return demangled; 9260 } 9261 else 9262 return NULL; /* not an objc mangled name */ 9263 } 9264 9265 /* Try to pretty-print a decl. If the 'decl' is an Objective-C 9266 specific decl, return the printable name for it. If not, return 9267 NULL. */ 9268 const char * 9269 objc_maybe_printable_name (tree decl, int v ATTRIBUTE_UNUSED) 9270 { 9271 switch (TREE_CODE (decl)) 9272 { 9273 case FUNCTION_DECL: 9274 return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl))); 9275 break; 9276 9277 /* The following happens when we are printing a deprecation 9278 warning for a method. The warn_deprecation() will end up 9279 trying to print the decl for INSTANCE_METHOD_DECL or 9280 CLASS_METHOD_DECL. It would be nice to be able to print 9281 "-[NSObject autorelease] is deprecated", but to do that, we'd 9282 need to store the class and method name in the method decl, 9283 which we currently don't do. For now, just return the name 9284 of the method. We don't return NULL, because that may 9285 trigger further attempts to pretty-print the decl in C/C++, 9286 but they wouldn't know how to pretty-print it. */ 9287 case INSTANCE_METHOD_DECL: 9288 case CLASS_METHOD_DECL: 9289 return IDENTIFIER_POINTER (DECL_NAME (decl)); 9290 break; 9291 /* This happens when printing a deprecation warning for a 9292 property. We may want to consider some sort of pretty 9293 printing (eg, include the class name where it was declared 9294 ?). */ 9295 case PROPERTY_DECL: 9296 return IDENTIFIER_POINTER (PROPERTY_NAME (decl)); 9297 break; 9298 default: 9299 return NULL; 9300 break; 9301 } 9302 } 9303 9304 /* Return a printable name for 'decl'. This first tries 9305 objc_maybe_printable_name(), and if that fails, it returns the name 9306 in the decl. This is used as LANG_HOOKS_DECL_PRINTABLE_NAME for 9307 Objective-C; in Objective-C++, setting the hook is not enough 9308 because lots of C++ Front-End code calls cxx_printable_name, 9309 dump_decl and other C++ functions directly. So instead we have 9310 modified dump_decl to call objc_maybe_printable_name directly. */ 9311 const char * 9312 objc_printable_name (tree decl, int v) 9313 { 9314 const char *demangled_name = objc_maybe_printable_name (decl, v); 9315 9316 if (demangled_name != NULL) 9317 return demangled_name; 9318 else 9319 return IDENTIFIER_POINTER (DECL_NAME (decl)); 9320 } 9321 9322 /* Routine is called to issue diagnostic when reference to a private 9323 ivar is made and no other variable with same name is found in 9324 current scope. */ 9325 bool 9326 objc_diagnose_private_ivar (tree id) 9327 { 9328 tree ivar; 9329 if (!objc_method_context) 9330 return false; 9331 ivar = is_ivar (objc_ivar_chain, id); 9332 if (ivar && is_private (ivar)) 9333 { 9334 error ("instance variable %qs is declared private", 9335 IDENTIFIER_POINTER (id)); 9336 return true; 9337 } 9338 return false; 9339 } 9340 9341 /* Look up ID as an instance variable. OTHER contains the result of 9342 the C or C++ lookup, which we may want to use instead. */ 9343 /* To use properties inside an instance method, use self.property. */ 9344 tree 9345 objc_lookup_ivar (tree other, tree id) 9346 { 9347 tree ivar; 9348 9349 /* If we are not inside of an ObjC method, ivar lookup makes no sense. */ 9350 if (!objc_method_context) 9351 return other; 9352 9353 if (!strcmp (IDENTIFIER_POINTER (id), "super")) 9354 /* We have a message to super. */ 9355 return get_super_receiver (); 9356 9357 /* In a class method, look up an instance variable only as a last 9358 resort. */ 9359 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL 9360 && other && other != error_mark_node) 9361 return other; 9362 9363 /* Look up the ivar, but do not use it if it is not accessible. */ 9364 ivar = is_ivar (objc_ivar_chain, id); 9365 9366 if (!ivar || is_private (ivar)) 9367 return other; 9368 9369 /* In an instance method, a local variable (or parameter) may hide the 9370 instance variable. */ 9371 if (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL 9372 && other && other != error_mark_node 9373 #ifdef OBJCPLUS 9374 && CP_DECL_CONTEXT (other) != global_namespace) 9375 #else 9376 && !DECL_FILE_SCOPE_P (other)) 9377 #endif 9378 { 9379 warning (0, "local declaration of %qE hides instance variable", id); 9380 9381 return other; 9382 } 9383 9384 /* At this point, we are either in an instance method with no obscuring 9385 local definitions, or in a class method with no alternate definitions 9386 at all. */ 9387 return build_ivar_reference (id); 9388 } 9389 9390 /* Possibly rewrite a function CALL into an OBJ_TYPE_REF expression. This 9391 needs to be done if we are calling a function through a cast. */ 9392 9393 tree 9394 objc_rewrite_function_call (tree function, tree first_param) 9395 { 9396 if (TREE_CODE (function) == NOP_EXPR 9397 && TREE_CODE (TREE_OPERAND (function, 0)) == ADDR_EXPR 9398 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (function, 0), 0)) 9399 == FUNCTION_DECL) 9400 { 9401 function = build3 (OBJ_TYPE_REF, TREE_TYPE (function), 9402 TREE_OPERAND (function, 0), 9403 first_param, size_zero_node); 9404 } 9405 9406 return function; 9407 } 9408 9409 /* This is called to "gimplify" a PROPERTY_REF node. It builds the 9410 corresponding 'getter' function call. Note that we assume the 9411 PROPERTY_REF to be valid since we generated it while parsing. */ 9412 static void 9413 objc_gimplify_property_ref (tree *expr_p) 9414 { 9415 tree getter = PROPERTY_REF_GETTER_CALL (*expr_p); 9416 tree call_exp; 9417 9418 if (getter == NULL_TREE) 9419 { 9420 tree property_decl = PROPERTY_REF_PROPERTY_DECL (*expr_p); 9421 /* This can happen if DECL_ARTIFICIAL (*expr_p), but 9422 should be impossible for real properties, which always 9423 have a getter. */ 9424 error_at (EXPR_LOCATION (*expr_p), "no %qs getter found", 9425 IDENTIFIER_POINTER (PROPERTY_NAME (property_decl))); 9426 /* Try to recover from the error to prevent an ICE. We take 9427 zero and cast it to the type of the property. */ 9428 *expr_p = convert (TREE_TYPE (property_decl), 9429 integer_zero_node); 9430 return; 9431 } 9432 9433 if (PROPERTY_REF_DEPRECATED_GETTER (*expr_p)) 9434 { 9435 /* PROPERTY_REF_DEPRECATED_GETTER contains the method prototype 9436 that is deprecated. */ 9437 warn_deprecated_use (PROPERTY_REF_DEPRECATED_GETTER (*expr_p), 9438 NULL_TREE); 9439 } 9440 9441 call_exp = getter; 9442 #ifdef OBJCPLUS 9443 /* In C++, a getter which returns an aggregate value results in a 9444 target_expr which initializes a temporary to the call 9445 expression. */ 9446 if (TREE_CODE (getter) == TARGET_EXPR) 9447 { 9448 gcc_assert (MAYBE_CLASS_TYPE_P (TREE_TYPE (getter))); 9449 gcc_assert (TREE_CODE (TREE_OPERAND (getter, 0)) == VAR_DECL); 9450 call_exp = TREE_OPERAND (getter, 1); 9451 } 9452 #endif 9453 gcc_assert (TREE_CODE (call_exp) == CALL_EXPR); 9454 9455 *expr_p = call_exp; 9456 } 9457 9458 /* This is called when "gimplifying" the trees. We need to gimplify 9459 the Objective-C/Objective-C++ specific trees, then hand over the 9460 process to C/C++. */ 9461 int 9462 objc_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) 9463 { 9464 enum tree_code code = TREE_CODE (*expr_p); 9465 switch (code) 9466 { 9467 /* Look for the special case of OBJC_TYPE_REF with the address 9468 of a function in OBJ_TYPE_REF_EXPR (presumably objc_msgSend 9469 or one of its cousins). */ 9470 case OBJ_TYPE_REF: 9471 if (TREE_CODE (OBJ_TYPE_REF_EXPR (*expr_p)) == ADDR_EXPR 9472 && TREE_CODE (TREE_OPERAND (OBJ_TYPE_REF_EXPR (*expr_p), 0)) 9473 == FUNCTION_DECL) 9474 { 9475 enum gimplify_status r0, r1; 9476 9477 /* Postincrements in OBJ_TYPE_REF_OBJECT don't affect the 9478 value of the OBJ_TYPE_REF, so force them to be emitted 9479 during subexpression evaluation rather than after the 9480 OBJ_TYPE_REF. This permits objc_msgSend calls in 9481 Objective C to use direct rather than indirect calls when 9482 the object expression has a postincrement. */ 9483 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, NULL, 9484 is_gimple_val, fb_rvalue); 9485 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p, 9486 is_gimple_val, fb_rvalue); 9487 9488 return MIN (r0, r1); 9489 } 9490 break; 9491 case PROPERTY_REF: 9492 objc_gimplify_property_ref (expr_p); 9493 /* Do not return yet; let C/C++ gimplify the resulting expression. */ 9494 break; 9495 default: 9496 break; 9497 } 9498 9499 #ifdef OBJCPLUS 9500 return (enum gimplify_status) cp_gimplify_expr (expr_p, pre_p, post_p); 9501 #else 9502 return (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p); 9503 #endif 9504 } 9505 9506 /* --- FAST ENUMERATION --- */ 9507 /* Begin code generation for fast enumeration (foreach) ... */ 9508 9509 /* Defines 9510 9511 struct __objcFastEnumerationState 9512 { 9513 unsigned long state; 9514 id *itemsPtr; 9515 unsigned long *mutationsPtr; 9516 unsigned long extra[5]; 9517 }; 9518 9519 Confusingly enough, NSFastEnumeration is then defined by libraries 9520 to be the same structure. 9521 */ 9522 9523 static void 9524 build_fast_enumeration_state_template (void) 9525 { 9526 tree decls, *chain = NULL; 9527 9528 /* { */ 9529 objc_fast_enumeration_state_template = objc_start_struct (get_identifier 9530 (TAG_FAST_ENUMERATION_STATE)); 9531 9532 /* unsigned long state; */ 9533 decls = add_field_decl (long_unsigned_type_node, "state", &chain); 9534 9535 /* id *itemsPtr; */ 9536 add_field_decl (build_pointer_type (objc_object_type), 9537 "itemsPtr", &chain); 9538 9539 /* unsigned long *mutationsPtr; */ 9540 add_field_decl (build_pointer_type (long_unsigned_type_node), 9541 "mutationsPtr", &chain); 9542 9543 /* unsigned long extra[5]; */ 9544 add_field_decl (build_sized_array_type (long_unsigned_type_node, 5), 9545 "extra", &chain); 9546 9547 /* } */ 9548 objc_finish_struct (objc_fast_enumeration_state_template, decls); 9549 } 9550 9551 /* 9552 'objc_finish_foreach_loop()' generates the code for an Objective-C 9553 foreach loop. The 'location' argument is the location of the 'for' 9554 that starts the loop. The 'object_expression' is the expression of 9555 the 'object' that iterates; the 'collection_expression' is the 9556 expression of the collection that we iterate over (we need to make 9557 sure we evaluate this only once); the 'for_body' is the set of 9558 statements to be executed in each iteration; 'break_label' and 9559 'continue_label' are the break and continue labels which we need to 9560 emit since the <statements> may be jumping to 'break_label' (if they 9561 contain 'break') or to 'continue_label' (if they contain 9562 'continue'). 9563 9564 The syntax is 9565 9566 for (<object expression> in <collection expression>) 9567 <statements> 9568 9569 which is compiled into the following blurb: 9570 9571 { 9572 id __objc_foreach_collection; 9573 __objc_fast_enumeration_state __objc_foreach_enum_state; 9574 unsigned long __objc_foreach_batchsize; 9575 id __objc_foreach_items[16]; 9576 __objc_foreach_collection = <collection expression>; 9577 __objc_foreach_enum_state = { 0 }; 9578 __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; 9579 9580 if (__objc_foreach_batchsize == 0) 9581 <object expression> = nil; 9582 else 9583 { 9584 unsigned long __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr; 9585 next_batch: 9586 { 9587 unsigned long __objc_foreach_index; 9588 __objc_foreach_index = 0; 9589 9590 next_object: 9591 if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>); 9592 <object expression> = enumState.itemsPtr[__objc_foreach_index]; 9593 <statements> [PS: inside <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label] 9594 9595 continue_label: 9596 __objc_foreach_index++; 9597 if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object; 9598 __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; 9599 } 9600 if (__objc_foreach_batchsize != 0) goto next_batch; 9601 <object expression> = nil; 9602 break_label: 9603 } 9604 } 9605 9606 'statements' may contain a 'continue' or 'break' instruction, which 9607 the user expects to 'continue' or 'break' the entire foreach loop. 9608 We are provided the labels that 'break' and 'continue' jump to, so 9609 we place them where we want them to jump to when they pick them. 9610 9611 Optimization TODO: we could cache the IMP of 9612 countByEnumeratingWithState:objects:count:. 9613 */ 9614 9615 /* If you need to debug objc_finish_foreach_loop(), uncomment the following line. */ 9616 /* #define DEBUG_OBJC_FINISH_FOREACH_LOOP 1 */ 9617 9618 #ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP 9619 #include "tree-pretty-print.h" 9620 #endif 9621 9622 void 9623 objc_finish_foreach_loop (location_t location, tree object_expression, tree collection_expression, tree for_body, 9624 tree break_label, tree continue_label) 9625 { 9626 /* A tree representing the __objcFastEnumerationState struct type, 9627 or NSFastEnumerationState struct, whatever we are using. */ 9628 tree objc_fast_enumeration_state_type; 9629 9630 /* The trees representing the declarations of each of the local variables. */ 9631 tree objc_foreach_collection_decl; 9632 tree objc_foreach_enum_state_decl; 9633 tree objc_foreach_items_decl; 9634 tree objc_foreach_batchsize_decl; 9635 tree objc_foreach_mutations_pointer_decl; 9636 tree objc_foreach_index_decl; 9637 9638 /* A tree representing the selector countByEnumeratingWithState:objects:count:. */ 9639 tree selector_name; 9640 9641 /* A tree representing the local bind. */ 9642 tree bind; 9643 9644 /* A tree representing the external 'if (__objc_foreach_batchsize)' */ 9645 tree first_if; 9646 9647 /* A tree representing the 'else' part of 'first_if' */ 9648 tree first_else; 9649 9650 /* A tree representing the 'next_batch' label. */ 9651 tree next_batch_label_decl; 9652 9653 /* A tree representing the binding after the 'next_batch' label. */ 9654 tree next_batch_bind; 9655 9656 /* A tree representing the 'next_object' label. */ 9657 tree next_object_label_decl; 9658 9659 /* Temporary variables. */ 9660 tree t; 9661 int i; 9662 9663 if (flag_objc1_only) 9664 error_at (location, "fast enumeration is not available in Objective-C 1.0"); 9665 9666 if (object_expression == error_mark_node) 9667 return; 9668 9669 if (collection_expression == error_mark_node) 9670 return; 9671 9672 if (!objc_type_valid_for_messaging (TREE_TYPE (object_expression), true)) 9673 { 9674 error_at (location, "iterating variable in fast enumeration is not an object"); 9675 return; 9676 } 9677 9678 if (!objc_type_valid_for_messaging (TREE_TYPE (collection_expression), true)) 9679 { 9680 error_at (location, "collection in fast enumeration is not an object"); 9681 return; 9682 } 9683 9684 /* TODO: Check that object_expression is either a variable 9685 declaration, or an lvalue. */ 9686 9687 /* This kludge is an idea from apple. We use the 9688 __objcFastEnumerationState struct implicitly defined by the 9689 compiler, unless a NSFastEnumerationState struct has been defined 9690 (by a Foundation library such as GNUstep Base) in which case, we 9691 use that one. 9692 */ 9693 objc_fast_enumeration_state_type = objc_fast_enumeration_state_template; 9694 { 9695 tree objc_NSFastEnumeration_type = lookup_name (get_identifier ("NSFastEnumerationState")); 9696 9697 if (objc_NSFastEnumeration_type) 9698 { 9699 /* TODO: We really need to check that 9700 objc_NSFastEnumeration_type is the same as ours! */ 9701 if (TREE_CODE (objc_NSFastEnumeration_type) == TYPE_DECL) 9702 { 9703 /* If it's a typedef, use the original type. */ 9704 if (DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type)) 9705 objc_fast_enumeration_state_type = DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type); 9706 else 9707 objc_fast_enumeration_state_type = TREE_TYPE (objc_NSFastEnumeration_type); 9708 } 9709 } 9710 } 9711 9712 /* { */ 9713 /* Done by c-parser.c. */ 9714 9715 /* type object; */ 9716 /* Done by c-parser.c. */ 9717 9718 /* Disable warnings that 'object' is unused. For example the code 9719 9720 for (id object in collection) 9721 i++; 9722 9723 which can be used to count how many objects there are in the 9724 collection is fine and should generate no warnings even if 9725 'object' is technically unused. */ 9726 TREE_USED (object_expression) = 1; 9727 if (DECL_P (object_expression)) 9728 DECL_READ_P (object_expression) = 1; 9729 9730 /* id __objc_foreach_collection */ 9731 objc_foreach_collection_decl = objc_create_temporary_var (objc_object_type, "__objc_foreach_collection"); 9732 9733 /* __objcFastEnumerationState __objc_foreach_enum_state; */ 9734 objc_foreach_enum_state_decl = objc_create_temporary_var (objc_fast_enumeration_state_type, "__objc_foreach_enum_state"); 9735 TREE_CHAIN (objc_foreach_enum_state_decl) = objc_foreach_collection_decl; 9736 9737 /* id __objc_foreach_items[16]; */ 9738 objc_foreach_items_decl = objc_create_temporary_var (build_sized_array_type (objc_object_type, 16), "__objc_foreach_items"); 9739 TREE_CHAIN (objc_foreach_items_decl) = objc_foreach_enum_state_decl; 9740 9741 /* unsigned long __objc_foreach_batchsize; */ 9742 objc_foreach_batchsize_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_batchsize"); 9743 TREE_CHAIN (objc_foreach_batchsize_decl) = objc_foreach_items_decl; 9744 9745 /* Generate the local variable binding. */ 9746 bind = build3 (BIND_EXPR, void_type_node, objc_foreach_batchsize_decl, NULL, NULL); 9747 SET_EXPR_LOCATION (bind, location); 9748 TREE_SIDE_EFFECTS (bind) = 1; 9749 9750 /* __objc_foreach_collection = <collection expression>; */ 9751 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_collection_decl, collection_expression); 9752 SET_EXPR_LOCATION (t, location); 9753 append_to_statement_list (t, &BIND_EXPR_BODY (bind)); 9754 /* We have used 'collection_expression'. */ 9755 mark_exp_read (collection_expression); 9756 9757 /* __objc_foreach_enum_state.state = 0; */ 9758 t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl, 9759 get_identifier ("state")), 9760 build_int_cst (long_unsigned_type_node, 0)); 9761 SET_EXPR_LOCATION (t, location); 9762 append_to_statement_list (t, &BIND_EXPR_BODY (bind)); 9763 9764 /* __objc_foreach_enum_state.itemsPtr = NULL; */ 9765 t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl, 9766 get_identifier ("itemsPtr")), 9767 null_pointer_node); 9768 SET_EXPR_LOCATION (t, location); 9769 append_to_statement_list (t, &BIND_EXPR_BODY (bind)); 9770 9771 /* __objc_foreach_enum_state.mutationsPtr = NULL; */ 9772 t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl, 9773 get_identifier ("mutationsPtr")), 9774 null_pointer_node); 9775 SET_EXPR_LOCATION (t, location); 9776 append_to_statement_list (t, &BIND_EXPR_BODY (bind)); 9777 9778 /* __objc_foreach_enum_state.extra[0] = 0; */ 9779 /* __objc_foreach_enum_state.extra[1] = 0; */ 9780 /* __objc_foreach_enum_state.extra[2] = 0; */ 9781 /* __objc_foreach_enum_state.extra[3] = 0; */ 9782 /* __objc_foreach_enum_state.extra[4] = 0; */ 9783 for (i = 0; i < 5 ; i++) 9784 { 9785 t = build2 (MODIFY_EXPR, void_type_node, 9786 build_array_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl, 9787 get_identifier ("extra")), 9788 build_int_cst (NULL_TREE, i)), 9789 build_int_cst (long_unsigned_type_node, 0)); 9790 SET_EXPR_LOCATION (t, location); 9791 append_to_statement_list (t, &BIND_EXPR_BODY (bind)); 9792 } 9793 9794 /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */ 9795 selector_name = get_identifier ("countByEnumeratingWithState:objects:count:"); 9796 #ifdef OBJCPLUS 9797 t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name, 9798 /* Parameters. */ 9799 tree_cons /* &__objc_foreach_enum_state */ 9800 (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl), 9801 tree_cons /* __objc_foreach_items */ 9802 (NULL_TREE, objc_foreach_items_decl, 9803 tree_cons /* 16 */ 9804 (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL); 9805 #else 9806 /* In C, we need to decay the __objc_foreach_items array that we are passing. */ 9807 { 9808 struct c_expr array; 9809 array.value = objc_foreach_items_decl; 9810 t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name, 9811 /* Parameters. */ 9812 tree_cons /* &__objc_foreach_enum_state */ 9813 (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl), 9814 tree_cons /* __objc_foreach_items */ 9815 (NULL_TREE, default_function_array_conversion (location, array).value, 9816 tree_cons /* 16 */ 9817 (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL); 9818 } 9819 #endif 9820 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_batchsize_decl, 9821 convert (long_unsigned_type_node, t)); 9822 SET_EXPR_LOCATION (t, location); 9823 append_to_statement_list (t, &BIND_EXPR_BODY (bind)); 9824 9825 /* if (__objc_foreach_batchsize == 0) */ 9826 first_if = build3 (COND_EXPR, void_type_node, 9827 /* Condition. */ 9828 c_fully_fold 9829 (c_common_truthvalue_conversion 9830 (location, 9831 build_binary_op (location, 9832 EQ_EXPR, 9833 objc_foreach_batchsize_decl, 9834 build_int_cst (long_unsigned_type_node, 0), 1)), 9835 false, NULL), 9836 /* Then block (we fill it in later). */ 9837 NULL_TREE, 9838 /* Else block (we fill it in later). */ 9839 NULL_TREE); 9840 SET_EXPR_LOCATION (first_if, location); 9841 append_to_statement_list (first_if, &BIND_EXPR_BODY (bind)); 9842 9843 /* then <object expression> = nil; */ 9844 t = build2 (MODIFY_EXPR, void_type_node, object_expression, convert (objc_object_type, null_pointer_node)); 9845 SET_EXPR_LOCATION (t, location); 9846 COND_EXPR_THEN (first_if) = t; 9847 9848 /* Now we build the 'else' part of the if; once we finish building 9849 it, we attach it to first_if as the 'else' part. */ 9850 9851 /* else */ 9852 /* { */ 9853 9854 /* unsigned long __objc_foreach_mutations_pointer; */ 9855 objc_foreach_mutations_pointer_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_mutations_pointer"); 9856 9857 /* Generate the local variable binding. */ 9858 first_else = build3 (BIND_EXPR, void_type_node, objc_foreach_mutations_pointer_decl, NULL, NULL); 9859 SET_EXPR_LOCATION (first_else, location); 9860 TREE_SIDE_EFFECTS (first_else) = 1; 9861 9862 /* __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr; */ 9863 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_mutations_pointer_decl, 9864 build_indirect_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl, 9865 get_identifier ("mutationsPtr")), 9866 RO_UNARY_STAR)); 9867 SET_EXPR_LOCATION (t, location); 9868 append_to_statement_list (t, &BIND_EXPR_BODY (first_else)); 9869 9870 /* next_batch: */ 9871 next_batch_label_decl = create_artificial_label (location); 9872 t = build1 (LABEL_EXPR, void_type_node, next_batch_label_decl); 9873 SET_EXPR_LOCATION (t, location); 9874 append_to_statement_list (t, &BIND_EXPR_BODY (first_else)); 9875 9876 /* { */ 9877 9878 /* unsigned long __objc_foreach_index; */ 9879 objc_foreach_index_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_index"); 9880 9881 /* Generate the local variable binding. */ 9882 next_batch_bind = build3 (BIND_EXPR, void_type_node, objc_foreach_index_decl, NULL, NULL); 9883 SET_EXPR_LOCATION (next_batch_bind, location); 9884 TREE_SIDE_EFFECTS (next_batch_bind) = 1; 9885 append_to_statement_list (next_batch_bind, &BIND_EXPR_BODY (first_else)); 9886 9887 /* __objc_foreach_index = 0; */ 9888 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_index_decl, 9889 build_int_cst (long_unsigned_type_node, 0)); 9890 SET_EXPR_LOCATION (t, location); 9891 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); 9892 9893 /* next_object: */ 9894 next_object_label_decl = create_artificial_label (location); 9895 t = build1 (LABEL_EXPR, void_type_node, next_object_label_decl); 9896 SET_EXPR_LOCATION (t, location); 9897 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); 9898 9899 /* if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>); */ 9900 t = build3 (COND_EXPR, void_type_node, 9901 /* Condition. */ 9902 c_fully_fold 9903 (c_common_truthvalue_conversion 9904 (location, 9905 build_binary_op 9906 (location, 9907 NE_EXPR, 9908 objc_foreach_mutations_pointer_decl, 9909 build_indirect_ref (location, 9910 objc_build_component_ref (objc_foreach_enum_state_decl, 9911 get_identifier ("mutationsPtr")), 9912 RO_UNARY_STAR), 1)), 9913 false, NULL), 9914 /* Then block. */ 9915 build_function_call (input_location, 9916 objc_enumeration_mutation_decl, 9917 tree_cons (NULL, collection_expression, NULL)), 9918 /* Else block. */ 9919 NULL_TREE); 9920 SET_EXPR_LOCATION (t, location); 9921 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); 9922 9923 /* <object expression> = enumState.itemsPtr[__objc_foreach_index]; */ 9924 t = build2 (MODIFY_EXPR, void_type_node, object_expression, 9925 build_array_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl, 9926 get_identifier ("itemsPtr")), 9927 objc_foreach_index_decl)); 9928 SET_EXPR_LOCATION (t, location); 9929 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); 9930 9931 /* <statements> [PS: in <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label] */ 9932 append_to_statement_list (for_body, &BIND_EXPR_BODY (next_batch_bind)); 9933 9934 /* continue_label: */ 9935 if (continue_label) 9936 { 9937 t = build1 (LABEL_EXPR, void_type_node, continue_label); 9938 SET_EXPR_LOCATION (t, location); 9939 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); 9940 } 9941 9942 /* __objc_foreach_index++; */ 9943 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_index_decl, 9944 build_binary_op (location, 9945 PLUS_EXPR, 9946 objc_foreach_index_decl, 9947 build_int_cst (long_unsigned_type_node, 1), 1)); 9948 SET_EXPR_LOCATION (t, location); 9949 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); 9950 9951 /* if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object; */ 9952 t = build3 (COND_EXPR, void_type_node, 9953 /* Condition. */ 9954 c_fully_fold 9955 (c_common_truthvalue_conversion 9956 (location, 9957 build_binary_op (location, 9958 LT_EXPR, 9959 objc_foreach_index_decl, 9960 objc_foreach_batchsize_decl, 1)), 9961 false, NULL), 9962 /* Then block. */ 9963 build1 (GOTO_EXPR, void_type_node, next_object_label_decl), 9964 /* Else block. */ 9965 NULL_TREE); 9966 SET_EXPR_LOCATION (t, location); 9967 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); 9968 9969 /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */ 9970 #ifdef OBJCPLUS 9971 t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name, 9972 /* Parameters. */ 9973 tree_cons /* &__objc_foreach_enum_state */ 9974 (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl), 9975 tree_cons /* __objc_foreach_items */ 9976 (NULL_TREE, objc_foreach_items_decl, 9977 tree_cons /* 16 */ 9978 (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL); 9979 #else 9980 /* In C, we need to decay the __objc_foreach_items array that we are passing. */ 9981 { 9982 struct c_expr array; 9983 array.value = objc_foreach_items_decl; 9984 t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name, 9985 /* Parameters. */ 9986 tree_cons /* &__objc_foreach_enum_state */ 9987 (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl), 9988 tree_cons /* __objc_foreach_items */ 9989 (NULL_TREE, default_function_array_conversion (location, array).value, 9990 tree_cons /* 16 */ 9991 (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL); 9992 } 9993 #endif 9994 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_batchsize_decl, 9995 convert (long_unsigned_type_node, t)); 9996 SET_EXPR_LOCATION (t, location); 9997 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); 9998 9999 /* } */ 10000 10001 /* if (__objc_foreach_batchsize != 0) goto next_batch; */ 10002 t = build3 (COND_EXPR, void_type_node, 10003 /* Condition. */ 10004 c_fully_fold 10005 (c_common_truthvalue_conversion 10006 (location, 10007 build_binary_op (location, 10008 NE_EXPR, 10009 objc_foreach_batchsize_decl, 10010 build_int_cst (long_unsigned_type_node, 0), 1)), 10011 false, NULL), 10012 /* Then block. */ 10013 build1 (GOTO_EXPR, void_type_node, next_batch_label_decl), 10014 /* Else block. */ 10015 NULL_TREE); 10016 SET_EXPR_LOCATION (t, location); 10017 append_to_statement_list (t, &BIND_EXPR_BODY (first_else)); 10018 10019 /* <object expression> = nil; */ 10020 t = build2 (MODIFY_EXPR, void_type_node, object_expression, convert (objc_object_type, null_pointer_node)); 10021 SET_EXPR_LOCATION (t, location); 10022 append_to_statement_list (t, &BIND_EXPR_BODY (first_else)); 10023 10024 /* break_label: */ 10025 if (break_label) 10026 { 10027 t = build1 (LABEL_EXPR, void_type_node, break_label); 10028 SET_EXPR_LOCATION (t, location); 10029 append_to_statement_list (t, &BIND_EXPR_BODY (first_else)); 10030 } 10031 10032 /* } */ 10033 COND_EXPR_ELSE (first_if) = first_else; 10034 10035 /* Do the whole thing. */ 10036 add_stmt (bind); 10037 10038 #ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP 10039 /* This will print to stderr the whole blurb generated by the 10040 compiler while compiling (assuming the compiler doesn't crash 10041 before getting here). 10042 */ 10043 debug_generic_stmt (bind); 10044 #endif 10045 10046 /* } */ 10047 /* Done by c-parser.c */ 10048 } 10049 10050 /* --- SUPPORT FOR FORMAT ARG CHECKING --- */ 10051 /* Return true if we have an NxString object pointer. */ 10052 10053 bool 10054 objc_string_ref_type_p (tree strp) 10055 { 10056 tree tmv; 10057 if (!strp || TREE_CODE (strp) != POINTER_TYPE) 10058 return false; 10059 10060 tmv = TYPE_MAIN_VARIANT (TREE_TYPE (strp)); 10061 tmv = OBJC_TYPE_NAME (tmv); 10062 return (tmv 10063 && TREE_CODE (tmv) == IDENTIFIER_NODE 10064 && IDENTIFIER_POINTER (tmv) 10065 && !strncmp (IDENTIFIER_POINTER (tmv), "NSString", 8)); 10066 } 10067 10068 /* At present the behavior of this is undefined and it does nothing. */ 10069 void 10070 objc_check_format_arg (tree ARG_UNUSED (format_arg), 10071 tree ARG_UNUSED (args_list)) 10072 { 10073 } 10074 10075 void 10076 objc_common_init_ts (void) 10077 { 10078 c_common_init_ts (); 10079 10080 MARK_TS_DECL_NON_COMMON (CLASS_METHOD_DECL); 10081 MARK_TS_DECL_NON_COMMON (INSTANCE_METHOD_DECL); 10082 MARK_TS_DECL_NON_COMMON (KEYWORD_DECL); 10083 MARK_TS_DECL_NON_COMMON (PROPERTY_DECL); 10084 10085 MARK_TS_COMMON (CLASS_INTERFACE_TYPE); 10086 MARK_TS_COMMON (PROTOCOL_INTERFACE_TYPE); 10087 MARK_TS_COMMON (CLASS_IMPLEMENTATION_TYPE); 10088 10089 MARK_TS_TYPED (MESSAGE_SEND_EXPR); 10090 MARK_TS_TYPED (PROPERTY_REF); 10091 } 10092 10093 #include "gt-objc-objc-act.h" 10094