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
4 Free Software Foundation, Inc.
5 Contributed by Steve Naroff.
7 This file is part of GCC.
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)
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.
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/>. */
25 #include "coretypes.h"
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"
41 #include "langhooks.h"
50 #include "diagnostic-core.h"
53 #include "tree-iterator.h"
55 #include "langhooks-def.h"
57 /* For default_tree_printer (). */
58 #include "tree-pretty-print.h"
60 /* For enum gimplify_status */
63 #define OBJC_VOID_AT_END void_list_node
65 static unsigned int should_call_super_dealloc = 0;
67 /* When building Objective-C++, we are not linking against the C front-end
68 and so need to replicate the C tree-construction functions in some way. */
70 #define OBJCP_REMAP_FUNCTIONS
71 #include "objcp-decl.h"
74 /* This is the default way of generating a method name. */
75 /* This has the problem that "test_method:argument:" and
76 "test:method_argument:" will generate the same name
77 ("_i_Test__test_method_argument_" for an instance method of the
78 class "Test"), so you can't have them both in the same class!
79 Moreover, the demangling (going from
80 "_i_Test__test_method_argument" back to the original name) is
81 undefined because there are two correct ways of demangling the
83 #ifndef OBJC_GEN_METHOD_LABEL
84 #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
87 sprintf ((BUF), "_%s_%s_%s_%s", \
88 ((IS_INST) ? "i" : "c"), \
90 ((CAT_NAME)? (CAT_NAME) : ""), \
92 for (temp = (BUF); *temp; temp++) \
93 if (*temp == ':') *temp = '_'; \
97 /* These need specifying. */
98 #ifndef OBJC_FORWARDING_STACK_OFFSET
99 #define OBJC_FORWARDING_STACK_OFFSET 0
102 #ifndef OBJC_FORWARDING_MIN_OFFSET
103 #define OBJC_FORWARDING_MIN_OFFSET 0
106 /* Set up for use of obstacks. */
110 /* This obstack is used to accumulate the encoding of a data type. */
111 static struct obstack util_obstack;
113 /* This points to the beginning of obstack contents, so we can free
114 the whole contents. */
117 /* The version identifies which language generation and runtime
118 the module (file) was compiled for, and is recorded in the
119 module descriptor. */
121 #define OBJC_VERSION (flag_next_runtime ? 6 : 8)
122 #define PROTOCOL_VERSION 2
124 /* (Decide if these can ever be validly changed.) */
125 #define OBJC_ENCODE_INLINE_DEFS 0
126 #define OBJC_ENCODE_DONT_INLINE_DEFS 1
128 /*** Private Interface (procedures) ***/
130 /* Used by compile_file. */
132 static void init_objc (void);
133 static void finish_objc (void);
135 /* Code generation. */
137 static tree objc_build_constructor (tree, VEC(constructor_elt,gc) *);
138 static tree build_objc_method_call (location_t, int, tree, tree, tree, tree);
139 static tree get_proto_encoding (tree);
140 static tree lookup_interface (tree);
141 static tree objc_add_static_instance (tree, tree);
143 static tree start_class (enum tree_code, tree, tree, tree, tree);
144 static tree continue_class (tree);
145 static void finish_class (tree);
146 static void start_method_def (tree);
148 static void objc_start_function (tree, tree, tree, tree);
150 static void objc_start_function (tree, tree, tree, struct c_arg_info *);
152 static tree start_protocol (enum tree_code, tree, tree, tree);
153 static tree build_method_decl (enum tree_code, tree, tree, tree, bool);
154 static tree objc_add_method (tree, tree, int, bool);
155 static tree add_instance_variable (tree, objc_ivar_visibility_kind, tree);
156 static tree build_ivar_reference (tree);
157 static tree is_ivar (tree, tree);
159 static void build_objc_exception_stuff (void);
160 static void build_next_objc_exception_stuff (void);
162 /* We only need the following for ObjC; ObjC++ will use C++'s definition
163 of DERIVED_FROM_P. */
165 static bool objc_derived_from_p (tree, tree);
166 #define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD)
170 static void objc_gen_property_data (tree, tree);
171 static void objc_synthesize_getter (tree, tree, tree);
172 static void objc_synthesize_setter (tree, tree, tree);
173 static char *objc_build_property_setter_name (tree);
174 static int match_proto_with_proto (tree, tree, int);
175 static tree lookup_property (tree, tree);
176 static tree lookup_property_in_list (tree, tree);
177 static tree lookup_property_in_protocol_list (tree, tree);
178 static void build_objc_property_accessor_helpers (void);
180 static void objc_xref_basetypes (tree, tree);
182 static void build_class_template (void);
183 static void build_selector_template (void);
184 static void build_category_template (void);
185 static void build_super_template (void);
186 static tree build_protocol_initializer (tree, tree, tree, tree, tree);
187 static tree get_class_ivars (tree, bool);
188 static tree generate_protocol_list (tree);
189 static void build_protocol_reference (tree);
191 static void build_fast_enumeration_state_template (void);
194 static void objc_generate_cxx_cdtors (void);
198 static void objc_decl_method_attributes (tree*, tree, int);
199 static tree build_keyword_selector (tree);
200 static const char *synth_id_with_class_suffix (const char *, tree);
202 /* Hash tables to manage the global pool of method prototypes. */
204 hash *nst_method_hash_list = 0;
205 hash *cls_method_hash_list = 0;
207 /* Hash tables to manage the global pool of class names. */
209 hash *cls_name_hash_list = 0;
210 hash *als_name_hash_list = 0;
212 static void hash_class_name_enter (hash *, tree, tree);
213 static hash hash_class_name_lookup (hash *, tree);
215 static hash hash_lookup (hash *, tree);
216 static tree lookup_method (tree, tree);
217 static tree lookup_method_static (tree, tree, int);
219 static tree add_class (tree, tree);
220 static void add_category (tree, tree);
221 static inline tree lookup_category (tree, tree);
225 class_names, /* class, category, protocol, module names */
226 meth_var_names, /* method and variable names */
227 meth_var_types /* method and variable type descriptors */
230 static tree add_objc_string (tree, enum string_section);
231 static void build_selector_table_decl (void);
235 static tree lookup_protocol (tree, bool, bool);
236 static tree lookup_and_install_protocols (tree, bool);
240 static void encode_type_qualifiers (tree);
241 static void encode_type (tree, int, int);
242 static void encode_field_decl (tree, int, int);
245 static void really_start_method (tree, tree);
247 static void really_start_method (tree, struct c_arg_info *);
249 static int comp_proto_with_proto (tree, tree, int);
250 static tree get_arg_type_list (tree, int, int);
251 static tree objc_decay_parm_type (tree);
252 static void objc_push_parm (tree);
254 static tree objc_get_parm_info (int);
256 static struct c_arg_info *objc_get_parm_info (int);
259 /* Utilities for debugging and error diagnostics. */
261 static char *gen_type_name (tree);
262 static char *gen_type_name_0 (tree);
263 static char *gen_method_decl (tree);
264 static char *gen_declaration (tree);
266 /* Everything else. */
268 static tree create_field_decl (tree, const char *);
269 static void add_class_reference (tree);
270 static void build_protocol_template (void);
271 static tree encode_method_prototype (tree);
272 static void generate_classref_translation_entry (tree);
273 static void handle_class_ref (tree);
274 static void generate_struct_by_value_array (void)
276 static void mark_referenced_methods (void);
277 static void generate_objc_image_info (void);
278 static bool objc_type_valid_for_messaging (tree type, bool allow_classes);
280 /*** Private Interface (data) ***/
282 /* Reserved tag definitions. */
284 #define OBJECT_TYPEDEF_NAME "id"
285 #define CLASS_TYPEDEF_NAME "Class"
287 #define TAG_OBJECT "objc_object"
288 #define TAG_CLASS "objc_class"
289 #define TAG_SUPER "objc_super"
290 #define TAG_SELECTOR "objc_selector"
292 #define UTAG_CLASS "_objc_class"
293 #define UTAG_IVAR "_objc_ivar"
294 #define UTAG_IVAR_LIST "_objc_ivar_list"
295 #define UTAG_METHOD "_objc_method"
296 #define UTAG_METHOD_LIST "_objc_method_list"
297 #define UTAG_CATEGORY "_objc_category"
298 #define UTAG_MODULE "_objc_module"
299 #define UTAG_SYMTAB "_objc_symtab"
300 #define UTAG_SUPER "_objc_super"
301 #define UTAG_SELECTOR "_objc_selector"
303 #define UTAG_PROTOCOL "_objc_protocol"
304 #define UTAG_METHOD_PROTOTYPE "_objc_method_prototype"
305 #define UTAG_METHOD_PROTOTYPE_LIST "_objc__method_prototype_list"
307 /* Note that the string object global name is only needed for the
309 #define STRING_OBJECT_GLOBAL_FORMAT "_%sClassReference"
311 #define PROTOCOL_OBJECT_CLASS_NAME "Protocol"
313 #define TAG_ENUMERATION_MUTATION "objc_enumerationMutation"
314 #define TAG_FAST_ENUMERATION_STATE "__objcFastEnumerationState"
316 static const char *TAG_GETCLASS;
317 static const char *TAG_GETMETACLASS;
318 static const char *TAG_MSGSEND;
319 static const char *TAG_MSGSENDSUPER;
320 /* The NeXT Objective-C messenger may have two extra entry points, for use
321 when returning a structure. */
322 static const char *TAG_MSGSEND_STRET;
323 static const char *TAG_MSGSENDSUPER_STRET;
324 static const char *default_constant_string_class_name;
326 /* Runtime metadata flags. */
327 #define CLS_FACTORY 0x0001L
328 #define CLS_META 0x0002L
329 #define CLS_HAS_CXX_STRUCTORS 0x2000L
331 #define OBJC_MODIFIER_STATIC 0x00000001
332 #define OBJC_MODIFIER_FINAL 0x00000002
333 #define OBJC_MODIFIER_PUBLIC 0x00000004
334 #define OBJC_MODIFIER_PRIVATE 0x00000008
335 #define OBJC_MODIFIER_PROTECTED 0x00000010
336 #define OBJC_MODIFIER_NATIVE 0x00000020
337 #define OBJC_MODIFIER_SYNCHRONIZED 0x00000040
338 #define OBJC_MODIFIER_ABSTRACT 0x00000080
339 #define OBJC_MODIFIER_VOLATILE 0x00000100
340 #define OBJC_MODIFIER_TRANSIENT 0x00000200
341 #define OBJC_MODIFIER_NONE_SPECIFIED 0x80000000
343 /* NeXT-specific tags. */
345 #define TAG_MSGSEND_NONNIL "objc_msgSendNonNil"
346 #define TAG_MSGSEND_NONNIL_STRET "objc_msgSendNonNil_stret"
347 #define TAG_EXCEPTIONEXTRACT "objc_exception_extract"
348 #define TAG_EXCEPTIONTRYENTER "objc_exception_try_enter"
349 #define TAG_EXCEPTIONTRYEXIT "objc_exception_try_exit"
350 #define TAG_EXCEPTIONMATCH "objc_exception_match"
351 #define TAG_EXCEPTIONTHROW "objc_exception_throw"
352 #define TAG_SYNCENTER "objc_sync_enter"
353 #define TAG_SYNCEXIT "objc_sync_exit"
354 #define TAG_SETJMP "_setjmp"
355 #define UTAG_EXCDATA "_objc_exception_data"
357 #define TAG_ASSIGNIVAR "objc_assign_ivar"
358 #define TAG_ASSIGNGLOBAL "objc_assign_global"
359 #define TAG_ASSIGNSTRONGCAST "objc_assign_strongCast"
361 /* Branch entry points. All that matters here are the addresses;
362 functions with these names do not really exist in libobjc. */
364 #define TAG_MSGSEND_FAST "objc_msgSend_Fast"
365 #define TAG_ASSIGNIVAR_FAST "objc_assign_ivar_Fast"
367 #define TAG_CXX_CONSTRUCT ".cxx_construct"
368 #define TAG_CXX_DESTRUCT ".cxx_destruct"
370 /* GNU-specific tags. */
372 #define TAG_EXECCLASS "__objc_exec_class"
373 #define TAG_GNUINIT "__objc_gnu_init"
375 /* Flags for lookup_method_static(). */
377 /* Look for class methods. */
378 #define OBJC_LOOKUP_CLASS 1
379 /* Do not examine superclasses. */
380 #define OBJC_LOOKUP_NO_SUPER 2
381 /* Disable returning an instance method of a root class when a class
382 method can't be found. */
383 #define OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS 4
385 /* The OCTI_... enumeration itself is in objc/objc-act.h. */
386 tree objc_global_trees[OCTI_MAX];
388 static void handle_impent (struct imp_entry *);
390 struct imp_entry *imp_list = 0;
391 int imp_count = 0; /* `@implementation' */
392 int cat_count = 0; /* `@category' */
394 objc_ivar_visibility_kind objc_ivar_visibility;
396 /* Use to generate method labels. */
397 static int method_slot = 0;
399 /* Flag to say whether methods in a protocol are optional or
401 static bool objc_method_optional_flag = false;
403 static int objc_collecting_ivars = 0;
405 /* Flag that is set to 'true' while we are processing a class
406 extension. Since a class extension just "reopens" the main
407 @interface, this can be used to determine if we are in the main
408 @interface, or in a class extension. */
409 static bool objc_in_class_extension = false;
413 static char *errbuf; /* Buffer for error diagnostics */
415 /* An array of all the local variables in the current function that
416 need to be marked as volatile. */
417 VEC(tree,gc) *local_variables_to_volatilize = NULL;
420 static int flag_typed_selectors;
422 /* Store all constructed constant strings in a hash table so that
423 they get uniqued properly. */
425 struct GTY(()) string_descriptor {
426 /* The literal argument . */
429 /* The resulting constant string. */
433 static GTY((param_is (struct string_descriptor))) htab_t string_htab;
435 FILE *gen_declaration_file;
437 /* Tells "encode_pointer/encode_aggregate" whether we are generating
438 type descriptors for instance variables (as opposed to methods).
439 Type descriptors for instance variables contain more information
440 than methods (for static typing and embedded structures). */
442 static int generating_instance_variables = 0;
444 /* For building an objc struct. These may not be used when this file
445 is compiled as part of obj-c++. */
447 static bool objc_building_struct;
448 static struct c_struct_parse_info *objc_struct_info ATTRIBUTE_UNUSED;
450 /* Start building a struct for objc. */
453 objc_start_struct (tree name)
455 gcc_assert (!objc_building_struct);
456 objc_building_struct = true;
457 return start_struct (input_location, RECORD_TYPE, name, &objc_struct_info);
460 /* Finish building a struct for objc. */
463 objc_finish_struct (tree type, tree fieldlist)
465 gcc_assert (objc_building_struct);
466 objc_building_struct = false;
467 return finish_struct (input_location, type, fieldlist, NULL_TREE,
472 build_sized_array_type (tree base_type, int size)
474 tree index_type = build_index_type (build_int_cst (NULL_TREE, size - 1));
475 return build_array_type (base_type, index_type);
479 add_field_decl (tree type, const char *name, tree **chain)
481 tree field = create_field_decl (type, name);
485 *chain = &DECL_CHAIN (field);
490 /* Create a temporary variable of type 'type'. If 'name' is set, uses
491 the specified name, else use no name. Returns the declaration of
492 the type. The 'name' is mostly useful for debugging.
495 objc_create_temporary_var (tree type, const char *name)
501 decl = build_decl (input_location,
502 VAR_DECL, get_identifier (name), type);
506 decl = build_decl (input_location,
507 VAR_DECL, NULL_TREE, type);
509 TREE_USED (decl) = 1;
510 DECL_ARTIFICIAL (decl) = 1;
511 DECL_IGNORED_P (decl) = 1;
512 DECL_CONTEXT (decl) = current_function_decl;
517 /* Some platforms pass small structures through registers versus
518 through an invisible pointer. Determine at what size structure is
519 the transition point between the two possibilities. */
522 generate_struct_by_value_array (void)
527 int aggregate_in_mem[32];
530 /* Presumably no platform passes 32 byte structures in a register. */
531 for (i = 1; i < 32; i++)
536 /* Create an unnamed struct that has `i' character components */
537 type = objc_start_struct (NULL_TREE);
539 strcpy (buffer, "c1");
540 decls = add_field_decl (char_type_node, buffer, &chain);
542 for (j = 1; j < i; j++)
544 sprintf (buffer, "c%d", j + 1);
545 add_field_decl (char_type_node, buffer, &chain);
547 objc_finish_struct (type, decls);
549 aggregate_in_mem[i] = aggregate_value_p (type, 0);
550 if (!aggregate_in_mem[i])
554 /* We found some structures that are returned in registers instead of memory
555 so output the necessary data. */
558 for (i = 31; i >= 0; i--)
559 if (!aggregate_in_mem[i])
561 printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n\n", i);
563 /* The first member of the structure is always 0 because we don't handle
564 structures with 0 members */
565 printf ("static int struct_forward_array[] = {\n 0");
567 for (j = 1; j <= i; j++)
568 printf (", %d", aggregate_in_mem[j]);
579 if (cxx_init () == false)
581 if (c_objc_common_init () == false)
585 /* If gen_declaration desired, open the output file. */
586 if (flag_gen_declaration)
588 register char * const dumpname = concat (dump_base_name, ".decl", NULL);
589 gen_declaration_file = fopen (dumpname, "w");
590 if (gen_declaration_file == 0)
591 fatal_error ("can%'t open %s: %m", dumpname);
595 if (flag_next_runtime)
597 TAG_GETCLASS = "objc_getClass";
598 TAG_GETMETACLASS = "objc_getMetaClass";
599 TAG_MSGSEND = "objc_msgSend";
600 TAG_MSGSENDSUPER = "objc_msgSendSuper";
601 TAG_MSGSEND_STRET = "objc_msgSend_stret";
602 TAG_MSGSENDSUPER_STRET = "objc_msgSendSuper_stret";
603 default_constant_string_class_name = "NSConstantString";
607 TAG_GETCLASS = "objc_get_class";
608 TAG_GETMETACLASS = "objc_get_meta_class";
609 TAG_MSGSEND = "objc_msg_lookup";
610 TAG_MSGSENDSUPER = "objc_msg_lookup_super";
611 /* GNU runtime does not provide special functions to support
612 structure-returning methods. */
613 default_constant_string_class_name = "NXConstantString";
614 flag_typed_selectors = 1;
615 /* GNU runtime does not need the compiler to change code
616 in order to do GC. */
619 warning_at (0, 0, "%<-fobjc-gc%> is ignored for %<-fgnu-runtime%>");
626 if (print_struct_values && !flag_compare_debug)
627 generate_struct_by_value_array ();
630 if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
631 using_eh_for_cleanups ();
637 /* This is called automatically (at the very end of compilation) by
638 c_write_global_declarations and cp_write_global_declarations. */
640 objc_write_global_declarations (void)
642 mark_referenced_methods ();
644 /* Finalize Objective-C runtime data. */
647 if (gen_declaration_file)
648 fclose (gen_declaration_file);
651 /* Return the first occurrence of a method declaration corresponding
652 to sel_name in rproto_list. Search rproto_list recursively.
653 If is_class is 0, search for instance methods, otherwise for class
656 lookup_method_in_protocol_list (tree rproto_list, tree sel_name,
661 for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
663 p = TREE_VALUE (rproto);
666 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
668 /* First, search the @required protocol methods. */
670 m = lookup_method (PROTOCOL_CLS_METHODS (p), sel_name);
672 m = lookup_method (PROTOCOL_NST_METHODS (p), sel_name);
677 /* If still not found, search the @optional protocol methods. */
679 m = lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (p), sel_name);
681 m = lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (p), sel_name);
686 /* If still not found, search the attached protocols. */
687 if (PROTOCOL_LIST (p))
688 m = lookup_method_in_protocol_list (PROTOCOL_LIST (p),
695 ; /* An identifier...if we could not find a protocol. */
703 lookup_protocol_in_reflist (tree rproto_list, tree lproto)
707 /* Make sure the protocol is supported by the object on the rhs. */
708 if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE)
711 for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
713 p = TREE_VALUE (rproto);
715 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
720 else if (PROTOCOL_LIST (p))
721 fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto);
730 ; /* An identifier...if we could not find a protocol. */
737 objc_start_class_interface (tree klass, tree super_class,
738 tree protos, tree attributes)
740 if (flag_objc1_only && attributes)
741 error_at (input_location, "class attributes are not available in Objective-C 1.0");
743 objc_interface_context
745 = start_class (CLASS_INTERFACE_TYPE, klass, super_class, protos, attributes);
746 objc_ivar_visibility = OBJC_IVAR_VIS_PROTECTED;
750 objc_start_category_interface (tree klass, tree categ,
751 tree protos, tree attributes)
756 error_at (input_location, "category attributes are not available in Objective-C 1.0");
758 warning_at (input_location, OPT_Wattributes,
759 "category attributes are not available in this version"
760 " of the compiler, (ignored)");
762 if (categ == NULL_TREE)
765 error_at (input_location, "class extensions are not available in Objective-C 1.0");
768 /* Iterate over all the classes and categories implemented
769 up to now in this compilation unit. */
772 for (t = imp_list; t; t = t->next)
774 /* If we find a class @implementation with the same name
775 as the one we are extending, produce an error. */
776 if (TREE_CODE (t->imp_context) == CLASS_IMPLEMENTATION_TYPE
777 && IDENTIFIER_POINTER (CLASS_NAME (t->imp_context)) == IDENTIFIER_POINTER (klass))
778 error_at (input_location,
779 "class extension for class %qE declared after its %<@implementation%>",
784 objc_interface_context
785 = start_class (CATEGORY_INTERFACE_TYPE, klass, categ, protos, NULL_TREE);
787 = continue_class (objc_interface_context);
791 objc_start_protocol (tree name, tree protos, tree attributes)
793 if (flag_objc1_only && attributes)
794 error_at (input_location, "protocol attributes are not available in Objective-C 1.0");
796 objc_interface_context
797 = start_protocol (PROTOCOL_INTERFACE_TYPE, name, protos, attributes);
798 objc_method_optional_flag = false;
802 objc_continue_interface (void)
805 = continue_class (objc_interface_context);
809 objc_finish_interface (void)
811 finish_class (objc_interface_context);
812 objc_interface_context = NULL_TREE;
813 objc_method_optional_flag = false;
814 objc_in_class_extension = false;
818 objc_start_class_implementation (tree klass, tree super_class)
820 objc_implementation_context
822 = start_class (CLASS_IMPLEMENTATION_TYPE, klass, super_class, NULL_TREE,
824 objc_ivar_visibility = OBJC_IVAR_VIS_PROTECTED;
828 objc_start_category_implementation (tree klass, tree categ)
830 objc_implementation_context
831 = start_class (CATEGORY_IMPLEMENTATION_TYPE, klass, categ, NULL_TREE,
834 = continue_class (objc_implementation_context);
838 objc_continue_implementation (void)
841 = continue_class (objc_implementation_context);
845 objc_finish_implementation (void)
848 if (flag_objc_call_cxx_cdtors)
849 objc_generate_cxx_cdtors ();
852 if (objc_implementation_context)
854 finish_class (objc_implementation_context);
855 objc_ivar_chain = NULL_TREE;
856 objc_implementation_context = NULL_TREE;
859 warning (0, "%<@end%> must appear in an @implementation context");
863 objc_set_visibility (objc_ivar_visibility_kind visibility)
865 if (visibility == OBJC_IVAR_VIS_PACKAGE)
868 error ("%<@package%> is not available in Objective-C 1.0");
870 warning (0, "%<@package%> presently has the same effect as %<@public%>");
872 objc_ivar_visibility = visibility;
876 objc_set_method_opt (bool optional)
881 error_at (input_location, "%<@optional%> is not available in Objective-C 1.0");
883 error_at (input_location, "%<@required%> is not available in Objective-C 1.0");
886 objc_method_optional_flag = optional;
887 if (!objc_interface_context
888 || TREE_CODE (objc_interface_context) != PROTOCOL_INTERFACE_TYPE)
891 error ("%<@optional%> is allowed in @protocol context only");
893 error ("%<@required%> is allowed in @protocol context only");
894 objc_method_optional_flag = false;
898 /* This routine looks for a given PROPERTY in a list of CLASS, CATEGORY, or
901 lookup_property_in_list (tree chain, tree property)
904 for (x = CLASS_PROPERTY_DECL (chain); x; x = TREE_CHAIN (x))
905 if (PROPERTY_NAME (x) == property)
910 /* This routine looks for a given PROPERTY in the tree chain of RPROTO_LIST. */
911 static tree lookup_property_in_protocol_list (tree rproto_list, tree property)
914 for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
916 tree p = TREE_VALUE (rproto);
917 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
919 if ((x = lookup_property_in_list (p, property)))
921 if (PROTOCOL_LIST (p))
922 return lookup_property_in_protocol_list (PROTOCOL_LIST (p), property);
926 ; /* An identifier...if we could not find a protocol. */
932 /* This routine looks up the PROPERTY in current INTERFACE, its categories and up the
933 chain of interface hierarchy. */
935 lookup_property (tree interface_type, tree property)
937 tree inter = interface_type;
941 if ((x = lookup_property_in_list (inter, property)))
943 /* Failing that, look for the property in each category of the class. */
945 while ((category = CLASS_CATEGORY_LIST (category)))
947 if ((x = lookup_property_in_list (category, property)))
950 /* When checking a category, also check the protocols
951 attached with the category itself. */
952 if (CLASS_PROTOCOL_LIST (category)
953 && (x = lookup_property_in_protocol_list
954 (CLASS_PROTOCOL_LIST (category), property)))
958 /* Failing to find in categories, look for property in protocol list. */
959 if (CLASS_PROTOCOL_LIST (inter)
960 && (x = lookup_property_in_protocol_list
961 (CLASS_PROTOCOL_LIST (inter), property)))
964 /* Failing that, climb up the inheritance hierarchy. */
965 inter = lookup_interface (CLASS_SUPER_NAME (inter));
970 /* This routine is called by the parser when a
971 @property... declaration is found. 'decl' is the declaration of
972 the property (type/identifier), and the other arguments represent
973 property attributes that may have been specified in the Objective-C
974 declaration. 'parsed_property_readonly' is 'true' if the attribute
975 'readonly' was specified, and 'false' if not; similarly for the
976 other bool parameters. 'parsed_property_getter_ident' is NULL_TREE
977 if the attribute 'getter' was not specified, and is the identifier
978 corresponding to the specified getter if it was; similarly for
979 'parsed_property_setter_ident'. */
981 objc_add_property_declaration (location_t location, tree decl,
982 bool parsed_property_readonly, bool parsed_property_readwrite,
983 bool parsed_property_assign, bool parsed_property_retain,
984 bool parsed_property_copy, bool parsed_property_nonatomic,
985 tree parsed_property_getter_ident, tree parsed_property_setter_ident)
989 /* 'property_readonly' and 'property_assign_semantics' are the final
990 attributes of the property after all parsed attributes have been
991 considered (eg, if we parsed no 'readonly' and no 'readwrite', ie
992 parsed_property_readonly = false and parsed_property_readwrite =
993 false, then property_readonly will be false because the default
995 bool property_readonly = false;
996 objc_property_assign_semantics property_assign_semantics = OBJC_PROPERTY_ASSIGN;
997 bool property_extension_in_class_extension = false;
1000 error_at (input_location, "%<@property%> is not available in Objective-C 1.0");
1002 if (parsed_property_readonly && parsed_property_readwrite)
1004 error_at (location, "%<readonly%> attribute conflicts with %<readwrite%> attribute");
1005 /* In case of conflicting attributes (here and below), after
1006 producing an error, we pick one of the attributes and keep
1008 property_readonly = false;
1012 if (parsed_property_readonly)
1013 property_readonly = true;
1015 if (parsed_property_readwrite)
1016 property_readonly = false;
1019 if (parsed_property_readonly && parsed_property_setter_ident)
1021 error_at (location, "%<readonly%> attribute conflicts with %<setter%> attribute");
1022 property_readonly = false;
1025 if (parsed_property_assign && parsed_property_retain)
1027 error_at (location, "%<assign%> attribute conflicts with %<retain%> attribute");
1028 property_assign_semantics = OBJC_PROPERTY_RETAIN;
1030 else if (parsed_property_assign && parsed_property_copy)
1032 error_at (location, "%<assign%> attribute conflicts with %<copy%> attribute");
1033 property_assign_semantics = OBJC_PROPERTY_COPY;
1035 else if (parsed_property_retain && parsed_property_copy)
1037 error_at (location, "%<retain%> attribute conflicts with %<copy%> attribute");
1038 property_assign_semantics = OBJC_PROPERTY_COPY;
1042 if (parsed_property_assign)
1043 property_assign_semantics = OBJC_PROPERTY_ASSIGN;
1045 if (parsed_property_retain)
1046 property_assign_semantics = OBJC_PROPERTY_RETAIN;
1048 if (parsed_property_copy)
1049 property_assign_semantics = OBJC_PROPERTY_COPY;
1052 if (!objc_interface_context)
1054 error_at (location, "property declaration not in @interface or @protocol context");
1058 /* At this point we know that we are either in an interface, a
1059 category, or a protocol. */
1061 /* We expect a FIELD_DECL from the parser. Make sure we didn't get
1062 something else, as that would confuse the checks below. */
1063 if (TREE_CODE (decl) != FIELD_DECL)
1065 error_at (location, "invalid property declaration");
1069 /* Do some spot-checks for the most obvious invalid types. */
1071 if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1073 error_at (location, "property can not be an array");
1077 /* The C++/ObjC++ parser seems to reject the ':' for a bitfield when
1078 parsing, while the C/ObjC parser accepts it and gives us a
1079 FIELD_DECL with a DECL_INITIAL set. So we use the DECL_INITIAL
1080 to check for a bitfield when doing ObjC. */
1082 if (DECL_INITIAL (decl))
1084 /* A @property is not an actual variable, but it is a way to
1085 describe a pair of accessor methods, so its type (which is
1086 the type of the return value of the getter and the first
1087 argument of the setter) can't be a bitfield (as return values
1088 and arguments of functions can not be bitfields). The
1089 underlying instance variable could be a bitfield, but that is
1090 a different matter. */
1091 error_at (location, "property can not be a bit-field");
1096 /* TODO: Check that the property type is an Objective-C object or a
1099 /* Implement -Wproperty-assign-default (which is enabled by default). */
1100 if (warn_property_assign_default
1101 /* If garbage collection is not being used, then 'assign' is
1102 valid for objects (and typically used for delegates) but it
1103 is wrong in most cases (since most objects need to be
1104 retained or copied in setters). Warn users when 'assign' is
1106 && property_assign_semantics == OBJC_PROPERTY_ASSIGN
1107 /* Read-only properties are never assigned, so the assignment
1108 semantics do not matter in that case. */
1109 && !property_readonly
1112 /* Please note that it would make sense to default to 'assign'
1113 for non-{Objective-C objects}, and to 'retain' for
1114 Objective-C objects. But that would break compatibility with
1116 if (!parsed_property_assign && !parsed_property_retain && !parsed_property_copy)
1118 /* Use 'false' so we do not warn for Class objects. */
1119 if (objc_type_valid_for_messaging (TREE_TYPE (decl), false))
1121 warning_at (location,
1123 "object property %qD has no %<assign%>, %<retain%> or %<copy%> attribute; assuming %<assign%>",
1126 "%<assign%> can be unsafe for Objective-C objects; please state explicitly if you need it");
1131 if (property_assign_semantics == OBJC_PROPERTY_RETAIN
1132 && !objc_type_valid_for_messaging (TREE_TYPE (decl), true))
1133 error_at (location, "%<retain%> attribute is only valid for Objective-C objects");
1135 if (property_assign_semantics == OBJC_PROPERTY_COPY
1136 && !objc_type_valid_for_messaging (TREE_TYPE (decl), true))
1137 error_at (location, "%<copy%> attribute is only valid for Objective-C objects");
1139 /* Now determine the final property getter and setter names. They
1140 will be stored in the PROPERTY_DECL, from which they'll always be
1141 extracted and used. */
1143 /* Adjust, or fill in, setter and getter names. We overwrite the
1144 parsed_property_setter_ident and parsed_property_getter_ident
1145 with the final setter and getter identifiers that will be
1147 if (parsed_property_setter_ident)
1149 /* The setter should be terminated by ':', but the parser only
1150 gives us an identifier without ':'. So, we need to add ':'
1152 const char *parsed_setter = IDENTIFIER_POINTER (parsed_property_setter_ident);
1153 size_t length = strlen (parsed_setter);
1154 char *final_setter = (char *)alloca (length + 2);
1156 sprintf (final_setter, "%s:", parsed_setter);
1157 parsed_property_setter_ident = get_identifier (final_setter);
1161 if (!property_readonly)
1162 parsed_property_setter_ident = get_identifier (objc_build_property_setter_name
1163 (DECL_NAME (decl)));
1166 if (!parsed_property_getter_ident)
1167 parsed_property_getter_ident = DECL_NAME (decl);
1169 /* Check for duplicate property declarations. We first check the
1170 immediate context for a property with the same name. Any such
1171 declarations are an error, unless this is a class extension and
1172 we are extending a property from readonly to readwrite. */
1173 for (x = CLASS_PROPERTY_DECL (objc_interface_context); x; x = TREE_CHAIN (x))
1175 if (PROPERTY_NAME (x) == DECL_NAME (decl))
1177 if (objc_in_class_extension
1178 && property_readonly == 0
1179 && PROPERTY_READONLY (x) == 1)
1181 /* This is a class extension, and we are extending an
1182 existing readonly property to a readwrite one.
1184 property_extension_in_class_extension = true;
1189 location_t original_location = DECL_SOURCE_LOCATION (x);
1191 error_at (location, "redeclaration of property %qD", decl);
1193 if (original_location != UNKNOWN_LOCATION)
1194 inform (original_location, "originally specified here");
1200 /* If x is not NULL_TREE, we must be in a class extension and we're
1201 extending a readonly property. In that case, no point in
1202 searching for another declaration. */
1205 /* We now need to check for existing property declarations (in
1206 the superclass, other categories or protocols) and check that
1207 the new declaration is not in conflict with existing
1210 /* Search for a previous, existing declaration of a property
1211 with the same name in superclasses, protocols etc. If one is
1212 found, it will be in the 'x' variable. */
1214 /* Note that, for simplicity, the following may search again the
1215 local context. That's Ok as nothing will be found (else we'd
1216 have thrown an error above); it's only a little inefficient,
1217 but the code is simpler. */
1218 switch (TREE_CODE (objc_interface_context))
1220 case CLASS_INTERFACE_TYPE:
1221 /* Look up the property in the current @interface (which
1222 will find nothing), then its protocols and categories and
1224 x = lookup_property (objc_interface_context, DECL_NAME (decl));
1226 case CATEGORY_INTERFACE_TYPE:
1227 /* Look up the property in the main @interface, then
1228 protocols and categories (one of them is ours, and will
1229 find nothing) and superclasses. */
1230 x = lookup_property (lookup_interface (CLASS_NAME (objc_interface_context)),
1233 case PROTOCOL_INTERFACE_TYPE:
1234 /* Looks up the property in any protocols attached to the
1235 current protocol. */
1236 if (PROTOCOL_LIST (objc_interface_context))
1238 x = lookup_property_in_protocol_list (PROTOCOL_LIST (objc_interface_context),
1249 /* An existing property was found; check that it has the same
1250 types, or it is compatible. */
1251 location_t original_location = DECL_SOURCE_LOCATION (x);
1253 if (PROPERTY_NONATOMIC (x) != parsed_property_nonatomic)
1255 warning_at (location, 0,
1256 "'nonatomic' attribute of property %qD conflicts with previous declaration", decl);
1258 if (original_location != UNKNOWN_LOCATION)
1259 inform (original_location, "originally specified here");
1263 if (PROPERTY_GETTER_NAME (x) != parsed_property_getter_ident)
1265 warning_at (location, 0,
1266 "'getter' attribute of property %qD conflicts with previous declaration", decl);
1268 if (original_location != UNKNOWN_LOCATION)
1269 inform (original_location, "originally specified here");
1273 /* We can only compare the setter names if both the old and new property have a setter. */
1274 if (!property_readonly && !PROPERTY_READONLY(x))
1276 if (PROPERTY_SETTER_NAME (x) != parsed_property_setter_ident)
1278 warning_at (location, 0,
1279 "'setter' attribute of property %qD conflicts with previous declaration", decl);
1281 if (original_location != UNKNOWN_LOCATION)
1282 inform (original_location, "originally specified here");
1287 if (PROPERTY_ASSIGN_SEMANTICS (x) != property_assign_semantics)
1289 warning_at (location, 0,
1290 "assign semantics attributes of property %qD conflict with previous declaration", decl);
1292 if (original_location != UNKNOWN_LOCATION)
1293 inform (original_location, "originally specified here");
1297 /* It's ok to have a readonly property that becomes a readwrite, but not vice versa. */
1298 if (PROPERTY_READONLY (x) == 0 && property_readonly == 1)
1300 warning_at (location, 0,
1301 "'readonly' attribute of property %qD conflicts with previous declaration", decl);
1303 if (original_location != UNKNOWN_LOCATION)
1304 inform (original_location, "originally specified here");
1308 /* We now check that the new and old property declarations have
1309 the same types (or compatible one). In the Objective-C
1310 tradition of loose type checking, we do type-checking but
1311 only generate warnings (not errors) if they do not match.
1312 For non-readonly properties, the types must match exactly;
1313 for readonly properties, it is allowed to use a "more
1314 specialized" type in the new property declaration. Eg, the
1315 superclass has a getter returning (NSArray *) and the
1316 subclass a getter returning (NSMutableArray *). The object's
1317 getter returns an (NSMutableArray *); but if you cast the
1318 object to the superclass, which is allowed, you'd still
1319 expect the getter to return an (NSArray *), which works since
1320 an (NSMutableArray *) is an (NSArray *) too. So, the set of
1321 objects belonging to the type of the new @property should be
1322 a subset of the set of objects belonging to the type of the
1323 old @property. This is what "specialization" means. And the
1324 reason it only applies to readonly properties is that for a
1325 readwrite property the setter would have the opposite
1326 requirement - ie that the superclass type is more specialized
1327 then the subclass one; hence the only way to satisfy both
1328 constraints is that the types match. */
1330 /* If the types are not the same in the C sense, we warn ... */
1331 if (!comptypes (TREE_TYPE (x), TREE_TYPE (decl))
1332 /* ... unless the property is readonly, in which case we
1333 allow a new, more specialized, declaration. */
1334 && (!property_readonly
1335 || !objc_compare_types (TREE_TYPE (x),
1336 TREE_TYPE (decl), -5, NULL_TREE)))
1338 warning_at (location, 0,
1339 "type of property %qD conflicts with previous declaration", decl);
1340 if (original_location != UNKNOWN_LOCATION)
1341 inform (original_location, "originally specified here");
1345 /* If we are in a class extension and we're extending a readonly
1346 property in the main @interface, we'll just update the
1347 existing property with the readwrite flag and potentially the
1349 if (property_extension_in_class_extension)
1351 PROPERTY_READONLY (x) = 0;
1352 PROPERTY_SETTER_NAME (x) = parsed_property_setter_ident;
1357 /* Create a PROPERTY_DECL node. */
1358 property_decl = make_node (PROPERTY_DECL);
1360 /* Copy the basic information from the original decl. */
1361 TREE_TYPE (property_decl) = TREE_TYPE (decl);
1362 DECL_SOURCE_LOCATION (property_decl) = DECL_SOURCE_LOCATION (decl);
1363 TREE_DEPRECATED (property_decl) = TREE_DEPRECATED (decl);
1365 /* Add property-specific information. */
1366 PROPERTY_NAME (property_decl) = DECL_NAME (decl);
1367 PROPERTY_GETTER_NAME (property_decl) = parsed_property_getter_ident;
1368 PROPERTY_SETTER_NAME (property_decl) = parsed_property_setter_ident;
1369 PROPERTY_READONLY (property_decl) = property_readonly;
1370 PROPERTY_NONATOMIC (property_decl) = parsed_property_nonatomic;
1371 PROPERTY_ASSIGN_SEMANTICS (property_decl) = property_assign_semantics;
1372 PROPERTY_IVAR_NAME (property_decl) = NULL_TREE;
1373 PROPERTY_DYNAMIC (property_decl) = 0;
1375 /* Remember the fact that the property was found in the @optional
1376 section in a @protocol, or not. */
1377 if (objc_method_optional_flag)
1378 PROPERTY_OPTIONAL (property_decl) = 1;
1380 PROPERTY_OPTIONAL (property_decl) = 0;
1382 /* Note that PROPERTY_GETTER_NAME is always set for all
1383 PROPERTY_DECLs, and PROPERTY_SETTER_NAME is always set for all
1384 PROPERTY_DECLs where PROPERTY_READONLY == 0. Any time we deal
1385 with a getter or setter, we should get the PROPERTY_DECL and use
1386 PROPERTY_GETTER_NAME and PROPERTY_SETTER_NAME to know the correct
1389 /* Add the PROPERTY_DECL to the list of properties for the class. */
1390 TREE_CHAIN (property_decl) = CLASS_PROPERTY_DECL (objc_interface_context);
1391 CLASS_PROPERTY_DECL (objc_interface_context) = property_decl;
1394 /* This is a subroutine of objc_maybe_build_component_ref. Search the
1395 list of methods in the interface (and, failing that, the local list
1396 in the implementation, and failing that, the protocol list)
1397 provided for a 'setter' or 'getter' for 'component' with default
1398 names (ie, if 'component' is "name", then search for "name" and
1399 "setName:"). It is also possible to specify a different
1400 'getter_name' (this is used for @optional readonly properties). If
1401 any is found, then create an artificial property that uses them.
1402 Return NULL_TREE if 'getter' or 'setter' could not be found. */
1404 maybe_make_artificial_property_decl (tree interface, tree implementation,
1405 tree protocol_list, tree component, bool is_class,
1408 tree setter_name = get_identifier (objc_build_property_setter_name (component));
1409 tree getter = NULL_TREE;
1410 tree setter = NULL_TREE;
1412 if (getter_name == NULL_TREE)
1413 getter_name = component;
1415 /* First, check the @interface and all superclasses. */
1420 /* Using instance methods of the root class as accessors is most
1421 likely unwanted and can be extremely confusing (and, most
1422 importantly, other Objective-C 2.0 compilers do not do it).
1425 flags = OBJC_LOOKUP_CLASS | OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS;
1427 getter = lookup_method_static (interface, getter_name, flags);
1428 setter = lookup_method_static (interface, setter_name, flags);
1431 /* Second, check the local @implementation context. */
1432 if (!getter && !setter)
1438 getter = lookup_method (CLASS_CLS_METHODS (implementation), getter_name);
1439 setter = lookup_method (CLASS_CLS_METHODS (implementation), setter_name);
1443 getter = lookup_method (CLASS_NST_METHODS (implementation), getter_name);
1444 setter = lookup_method (CLASS_NST_METHODS (implementation), setter_name);
1449 /* Try the protocol_list if we didn't find anything in the
1450 @interface and in the @implementation. */
1451 if (!getter && !setter)
1453 getter = lookup_method_in_protocol_list (protocol_list, getter_name, is_class);
1454 setter = lookup_method_in_protocol_list (protocol_list, setter_name, is_class);
1457 /* There needs to be at least a getter or setter for this to be a
1458 valid 'object.component' syntax. */
1459 if (getter || setter)
1461 /* Yes ... determine the type of the expression. */
1466 type = TREE_VALUE (TREE_TYPE (getter));
1468 type = TREE_VALUE (TREE_TYPE (METHOD_SEL_ARGS (setter)));
1470 /* Create an artificial property declaration with the
1471 information we collected on the type and getter/setter
1473 property_decl = make_node (PROPERTY_DECL);
1475 TREE_TYPE (property_decl) = type;
1476 DECL_SOURCE_LOCATION (property_decl) = input_location;
1477 TREE_DEPRECATED (property_decl) = 0;
1478 DECL_ARTIFICIAL (property_decl) = 1;
1480 /* Add property-specific information. Note that one of
1481 PROPERTY_GETTER_NAME or PROPERTY_SETTER_NAME may refer to a
1482 non-existing method; this will generate an error when the
1483 expression is later compiled. At this stage we don't know if
1484 the getter or setter will be used, so we can't generate an
1486 PROPERTY_NAME (property_decl) = component;
1487 PROPERTY_GETTER_NAME (property_decl) = getter_name;
1488 PROPERTY_SETTER_NAME (property_decl) = setter_name;
1489 PROPERTY_READONLY (property_decl) = 0;
1490 PROPERTY_NONATOMIC (property_decl) = 0;
1491 PROPERTY_ASSIGN_SEMANTICS (property_decl) = 0;
1492 PROPERTY_IVAR_NAME (property_decl) = NULL_TREE;
1493 PROPERTY_DYNAMIC (property_decl) = 0;
1494 PROPERTY_OPTIONAL (property_decl) = 0;
1497 PROPERTY_HAS_NO_GETTER (property_decl) = 1;
1499 /* The following is currently unused, but it's nice to have
1500 there. We may use it if we need in the future. */
1502 PROPERTY_HAS_NO_SETTER (property_decl) = 1;
1504 return property_decl;
1510 /* This hook routine is invoked by the parser when an expression such
1511 as 'xxx.yyy' is parsed. We get a chance to process these
1512 expressions in a way that is specified to Objective-C (to implement
1513 the Objective-C 2.0 dot-syntax, properties, or non-fragile ivars).
1514 If the expression is not an Objective-C specified expression, we
1515 should return NULL_TREE; else we return the expression.
1517 At the moment this only implements dot-syntax and properties (not
1518 non-fragile ivars yet), ie 'object.property' or 'object.component'
1519 where 'component' is not a declared property, but a valid getter or
1520 setter for it could be found. */
1522 objc_maybe_build_component_ref (tree object, tree property_ident)
1527 /* If we are in Objective-C 1.0 mode, dot-syntax and properties are
1529 if (flag_objc1_only)
1532 /* Try to determine if 'object' is an Objective-C object or not. If
1534 if (object == NULL_TREE || object == error_mark_node
1535 || (rtype = TREE_TYPE (object)) == NULL_TREE)
1538 if (property_ident == NULL_TREE || property_ident == error_mark_node
1539 || TREE_CODE (property_ident) != IDENTIFIER_NODE)
1542 /* The following analysis of 'object' is similar to the one used for
1543 the 'receiver' of a method invocation. We need to determine what
1544 'object' is and find the appropriate property (either declared,
1545 or artificial) for it (in the same way as we need to find the
1546 appropriate method prototype for a method invocation). There are
1547 some simplifications here though: "object.property" is invalid if
1548 "object" has a type of "id" or "Class"; it must at least have a
1549 protocol attached to it, and "object" is never a class name as
1550 that is done by objc_build_class_component_ref. Finally, we
1551 don't know if this really is a dot-syntax expression, so we want
1552 to make a quick exit if it is not; for this reason, we try to
1553 postpone checks after determining that 'object' looks like an
1554 Objective-C object. */
1556 if (objc_is_id (rtype))
1558 /* This is the case that the 'object' is of type 'id' or
1561 /* Check if at least it is of type 'id <Protocol>' or 'Class
1562 <Protocol>'; if so, look the property up in the
1564 if (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype)))
1566 tree rprotos = TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype));
1570 /* No point looking up declared @properties if we are
1571 dealing with a class. Classes have no declared
1573 if (!IS_CLASS (rtype))
1574 x = lookup_property_in_protocol_list (rprotos, property_ident);
1578 /* Ok, no property. Maybe it was an
1579 object.component dot-syntax without a declared
1580 property (this is valid for classes too). Look
1581 for getter/setter methods and internally declare
1582 an artifical property based on them if found. */
1583 x = maybe_make_artificial_property_decl (NULL_TREE,
1590 else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x))
1592 /* This is a special, complicated case. If the
1593 property is optional, and is read-only, then the
1594 property is always used for reading, but an
1595 eventual existing non-property setter can be used
1596 for writing. We create an artificial property
1597 decl copying the getter from the optional
1598 property, and looking up the setter in the
1600 x = maybe_make_artificial_property_decl (NULL_TREE,
1605 PROPERTY_GETTER_NAME (x));
1609 else if (objc_method_context)
1611 /* Else, if we are inside a method it could be the case of
1612 'super' or 'self'. */
1613 tree interface_type = NULL_TREE;
1615 while (TREE_CODE (t) == COMPOUND_EXPR
1616 || TREE_CODE (t) == MODIFY_EXPR
1617 || CONVERT_EXPR_P (t)
1618 || TREE_CODE (t) == COMPONENT_REF)
1619 t = TREE_OPERAND (t, 0);
1621 if (t == UOBJC_SUPER_decl)
1622 interface_type = lookup_interface (CLASS_SUPER_NAME (implementation_template));
1623 else if (t == self_decl)
1624 interface_type = lookup_interface (CLASS_NAME (implementation_template));
1628 if (TREE_CODE (objc_method_context) != CLASS_METHOD_DECL)
1629 x = lookup_property (interface_type, property_ident);
1633 /* Try the dot-syntax without a declared property.
1634 If this is an access to 'self', it is possible
1635 that they may refer to a setter/getter that is
1636 not declared in the interface, but exists locally
1637 in the implementation. In that case, get the
1638 implementation context and use it. */
1639 tree implementation = NULL_TREE;
1642 implementation = objc_implementation_context;
1644 x = maybe_make_artificial_property_decl
1645 (interface_type, implementation, NULL_TREE,
1647 (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL),
1650 else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x))
1652 tree implementation = NULL_TREE;
1655 implementation = objc_implementation_context;
1657 x = maybe_make_artificial_property_decl (interface_type,
1662 PROPERTY_GETTER_NAME (x));
1669 /* This is the case where we have more information on 'rtype'. */
1670 tree basetype = TYPE_MAIN_VARIANT (rtype);
1672 /* Skip the pointer - if none, it's not an Objective-C object or
1674 if (basetype != NULL_TREE && TREE_CODE (basetype) == POINTER_TYPE)
1675 basetype = TREE_TYPE (basetype);
1679 /* Traverse typedefs. */
1680 while (basetype != NULL_TREE
1681 && TREE_CODE (basetype) == RECORD_TYPE
1682 && OBJC_TYPE_NAME (basetype)
1683 && TREE_CODE (OBJC_TYPE_NAME (basetype)) == TYPE_DECL
1684 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype)))
1685 basetype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype));
1687 if (basetype != NULL_TREE && TYPED_OBJECT (basetype))
1689 tree interface_type = TYPE_OBJC_INTERFACE (basetype);
1690 tree protocol_list = TYPE_OBJC_PROTOCOL_LIST (basetype);
1693 && (TREE_CODE (interface_type) == CLASS_INTERFACE_TYPE
1694 || TREE_CODE (interface_type) == CATEGORY_INTERFACE_TYPE
1695 || TREE_CODE (interface_type) == PROTOCOL_INTERFACE_TYPE))
1697 /* Not sure 'rtype' could ever be a class here! Just
1698 for safety we keep the checks. */
1699 if (!IS_CLASS (rtype))
1701 x = lookup_property (interface_type, property_ident);
1704 x = lookup_property_in_protocol_list (protocol_list,
1710 /* Try the dot-syntax without a declared property.
1711 If we are inside a method implementation, it is
1712 possible that they may refer to a setter/getter
1713 that is not declared in the interface, but exists
1714 locally in the implementation. In that case, get
1715 the implementation context and use it. */
1716 tree implementation = NULL_TREE;
1718 if (objc_implementation_context
1719 && CLASS_NAME (objc_implementation_context)
1720 == OBJC_TYPE_NAME (interface_type))
1721 implementation = objc_implementation_context;
1723 x = maybe_make_artificial_property_decl (interface_type,
1730 else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x))
1732 tree implementation = NULL_TREE;
1734 if (objc_implementation_context
1735 && CLASS_NAME (objc_implementation_context)
1736 == OBJC_TYPE_NAME (interface_type))
1737 implementation = objc_implementation_context;
1739 x = maybe_make_artificial_property_decl (interface_type,
1744 PROPERTY_GETTER_NAME (x));
1754 tree deprecated_method_prototype = NULL_TREE;
1756 /* We have an additional nasty problem here; if this
1757 PROPERTY_REF needs to become a 'getter', then the conversion
1758 from PROPERTY_REF into a getter call happens in gimplify,
1759 after the selector table has already been generated and when
1760 it is too late to add another selector to it. To work around
1761 the problem, we always create the getter call at this stage,
1762 which puts the selector in the table. Note that if the
1763 PROPERTY_REF becomes a 'setter' instead of a 'getter', then
1764 we have added a selector too many to the selector table.
1765 This is a little inefficient.
1767 Also note that method calls to 'self' and 'super' require the
1768 context (self_decl, UOBJS_SUPER_decl,
1769 objc_implementation_context etc) to be built correctly; this
1770 is yet another reason why building the call at the gimplify
1771 stage (when this context has been lost) is not very
1772 practical. If we build it at this stage, we know it will
1773 always be built correctly.
1775 If the PROPERTY_HAS_NO_GETTER() (ie, it is an artificial
1776 property decl created to deal with a dotsyntax not really
1777 referring to an existing property) then do not try to build a
1778 call to the getter as there is no getter. */
1779 if (PROPERTY_HAS_NO_GETTER (x))
1780 getter_call = NULL_TREE;
1782 getter_call = objc_finish_message_expr
1783 (object, PROPERTY_GETTER_NAME (x), NULL_TREE,
1784 /* Disable the immediate deprecation warning if the getter
1785 is deprecated, but record the fact that the getter is
1786 deprecated by setting PROPERTY_REF_DEPRECATED_GETTER to
1787 the method prototype. */
1788 &deprecated_method_prototype);
1790 expression = build4 (PROPERTY_REF, TREE_TYPE(x), object, x, getter_call,
1791 deprecated_method_prototype);
1792 SET_EXPR_LOCATION (expression, input_location);
1793 TREE_SIDE_EFFECTS (expression) = 1;
1801 /* This hook routine is invoked by the parser when an expression such
1802 as 'xxx.yyy' is parsed, and 'xxx' is a class name. This is the
1803 Objective-C 2.0 dot-syntax applied to classes, so we need to
1804 convert it into a setter/getter call on the class. */
1806 objc_build_class_component_ref (tree class_name, tree property_ident)
1811 if (flag_objc1_only)
1812 error_at (input_location, "the dot syntax is not available in Objective-C 1.0");
1814 if (class_name == NULL_TREE || class_name == error_mark_node
1815 || TREE_CODE (class_name) != IDENTIFIER_NODE)
1816 return error_mark_node;
1818 if (property_ident == NULL_TREE || property_ident == error_mark_node
1819 || TREE_CODE (property_ident) != IDENTIFIER_NODE)
1822 object = objc_get_class_reference (class_name);
1825 /* We know that 'class_name' is an Objective-C class name as the
1826 parser won't call this function if it is not. This is only a
1827 double-check for safety. */
1828 error_at (input_location, "could not find class %qE", class_name);
1829 return error_mark_node;
1832 rtype = lookup_interface (class_name);
1835 /* Again, this should never happen, but we do check. */
1836 error_at (input_location, "could not find interface for class %qE", class_name);
1837 return error_mark_node;
1841 if (TREE_DEPRECATED (rtype))
1842 warning (OPT_Wdeprecated_declarations, "class %qE is deprecated", class_name);
1845 x = maybe_make_artificial_property_decl (rtype, NULL_TREE, NULL_TREE,
1853 tree deprecated_method_prototype = NULL_TREE;
1855 if (PROPERTY_HAS_NO_GETTER (x))
1856 getter_call = NULL_TREE;
1858 getter_call = objc_finish_message_expr
1859 (object, PROPERTY_GETTER_NAME (x), NULL_TREE,
1860 &deprecated_method_prototype);
1862 expression = build4 (PROPERTY_REF, TREE_TYPE(x), object, x, getter_call,
1863 deprecated_method_prototype);
1864 SET_EXPR_LOCATION (expression, input_location);
1865 TREE_SIDE_EFFECTS (expression) = 1;
1871 error_at (input_location, "could not find setter/getter for %qE in class %qE",
1872 property_ident, class_name);
1873 return error_mark_node;
1881 /* This is used because we don't want to expose PROPERTY_REF to the
1882 C/C++ frontends. Maybe we should! */
1884 objc_is_property_ref (tree node)
1886 if (node && TREE_CODE (node) == PROPERTY_REF)
1892 /* This function builds a setter call for a PROPERTY_REF (real, for a
1893 declared property, or artificial, for a dot-syntax accessor which
1894 is not corresponding to a property). 'lhs' must be a PROPERTY_REF
1895 (the caller must check this beforehand). 'rhs' is the value to
1896 assign to the property. A plain setter call is returned, or
1897 error_mark_node if the property is readonly. */
1900 objc_build_setter_call (tree lhs, tree rhs)
1902 tree object_expr = PROPERTY_REF_OBJECT (lhs);
1903 tree property_decl = PROPERTY_REF_PROPERTY_DECL (lhs);
1905 if (PROPERTY_READONLY (property_decl))
1907 error ("readonly property can not be set");
1908 return error_mark_node;
1912 tree setter_argument = build_tree_list (NULL_TREE, rhs);
1915 /* TODO: Check that the setter return type is 'void'. */
1917 /* TODO: Decay arguments in C. */
1918 setter = objc_finish_message_expr (object_expr,
1919 PROPERTY_SETTER_NAME (property_decl),
1920 setter_argument, NULL);
1924 /* Unreachable, but the compiler may not realize. */
1925 return error_mark_node;
1928 /* This hook routine is called when a MODIFY_EXPR is being built. We
1929 check what is being modified; if it is a PROPERTY_REF, we need to
1930 generate a 'setter' function call for the property. If this is not
1931 a PROPERTY_REF, we return NULL_TREE and the C/C++ frontend will go
1932 on creating their MODIFY_EXPR.
1934 This is used for example if you write
1938 where 'count' is a property. The left-hand side creates a
1939 PROPERTY_REF, and then the compiler tries to generate a MODIFY_EXPR
1940 to assign something to it. We intercept that here, and generate a
1941 call to the 'setter' method instead. */
1943 objc_maybe_build_modify_expr (tree lhs, tree rhs)
1945 if (lhs && TREE_CODE (lhs) == PROPERTY_REF)
1947 /* Building a simple call to the setter method would work for cases such as
1951 but wouldn't work for cases such as
1953 count = object2.count = 1;
1955 to get these to work with very little effort, we build a
1956 compound statement which does the setter call (to set the
1957 property to 'rhs'), but which can also be evaluated returning
1958 the 'rhs'. So, we want to create the following:
1960 (temp = rhs; [object setProperty: temp]; temp)
1962 tree temp_variable_decl, bind;
1963 /* s1, s2 and s3 are the tree statements that we need in the
1964 compound expression. */
1965 tree s1, s2, s3, compound_expr;
1967 /* TODO: If 'rhs' is a constant, we could maybe do without the
1968 'temp' variable ? */
1970 /* Declare __objc_property_temp in a local bind. */
1971 temp_variable_decl = objc_create_temporary_var (TREE_TYPE (rhs), "__objc_property_temp");
1972 DECL_SOURCE_LOCATION (temp_variable_decl) = input_location;
1973 bind = build3 (BIND_EXPR, void_type_node, temp_variable_decl, NULL, NULL);
1974 SET_EXPR_LOCATION (bind, input_location);
1975 TREE_SIDE_EFFECTS (bind) = 1;
1978 /* Now build the compound statement. */
1980 /* s1: __objc_property_temp = rhs */
1981 s1 = build_modify_expr (input_location, temp_variable_decl, NULL_TREE,
1983 input_location, rhs, NULL_TREE);
1984 SET_EXPR_LOCATION (s1, input_location);
1986 /* s2: [object setProperty: __objc_property_temp] */
1987 s2 = objc_build_setter_call (lhs, temp_variable_decl);
1989 /* This happens if building the setter failed because the property
1991 if (s2 == error_mark_node)
1992 return error_mark_node;
1994 SET_EXPR_LOCATION (s2, input_location);
1996 /* s3: __objc_property_temp */
1997 s3 = convert (TREE_TYPE (lhs), temp_variable_decl);
1999 /* Now build the compound statement (s1, s2, s3) */
2000 compound_expr = build_compound_expr (input_location, build_compound_expr (input_location, s1, s2), s3);
2002 /* Without this, with -Wall you get a 'valued computed is not
2003 used' every time there is a "object.property = x" where the
2004 value of the resulting MODIFY_EXPR is not used. That is
2005 correct (maybe a more sophisticated implementation could
2006 avoid generating the compound expression if not needed), but
2007 we need to turn it off. */
2008 TREE_NO_WARNING (compound_expr) = 1;
2009 return compound_expr;
2015 /* This hook is called by the frontend when one of the four unary
2016 expressions PREINCREMENT_EXPR, POSTINCREMENT_EXPR,
2017 PREDECREMENT_EXPR and POSTDECREMENT_EXPR is being built with an
2018 argument which is a PROPERTY_REF. For example, this happens if you have
2022 where 'count' is a property. We need to use the 'getter' and
2023 'setter' for the property in an appropriate way to build the
2024 appropriate expression. 'code' is the code for the expression (one
2025 of the four mentioned above); 'argument' is the PROPERTY_REF, and
2026 'increment' is how much we need to add or subtract. */
2028 objc_build_incr_expr_for_property_ref (location_t location,
2029 enum tree_code code,
2030 tree argument, tree increment)
2032 /* Here are the expressions that we want to build:
2034 For PREINCREMENT_EXPR / PREDECREMENT_EXPR:
2035 (temp = [object property] +/- increment, [object setProperty: temp], temp)
2037 For POSTINCREMENT_EXPR / POSTECREMENT_EXPR:
2038 (temp = [object property], [object setProperty: temp +/- increment], temp) */
2040 tree temp_variable_decl, bind;
2041 /* s1, s2 and s3 are the tree statements that we need in the
2042 compound expression. */
2043 tree s1, s2, s3, compound_expr;
2046 if (!argument || TREE_CODE (argument) != PROPERTY_REF)
2047 return error_mark_node;
2049 /* Declare __objc_property_temp in a local bind. */
2050 temp_variable_decl = objc_create_temporary_var (TREE_TYPE (argument), "__objc_property_temp");
2051 DECL_SOURCE_LOCATION (temp_variable_decl) = location;
2052 bind = build3 (BIND_EXPR, void_type_node, temp_variable_decl, NULL, NULL);
2053 SET_EXPR_LOCATION (bind, location);
2054 TREE_SIDE_EFFECTS (bind) = 1;
2057 /* Now build the compound statement. */
2059 /* Note that the 'getter' is generated at gimplify time; at this
2060 time, we can simply put the property_ref (ie, argument) wherever
2061 we want the getter ultimately to be. */
2063 /* s1: __objc_property_temp = [object property] <+/- increment> */
2066 case PREINCREMENT_EXPR:
2067 /* __objc_property_temp = [object property] + increment */
2068 s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE,
2070 location, build2 (PLUS_EXPR, TREE_TYPE (argument),
2071 argument, increment), NULL_TREE);
2073 case PREDECREMENT_EXPR:
2074 /* __objc_property_temp = [object property] - increment */
2075 s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE,
2077 location, build2 (MINUS_EXPR, TREE_TYPE (argument),
2078 argument, increment), NULL_TREE);
2080 case POSTINCREMENT_EXPR:
2081 case POSTDECREMENT_EXPR:
2082 /* __objc_property_temp = [object property] */
2083 s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE,
2085 location, argument, NULL_TREE);
2091 /* s2: [object setProperty: __objc_property_temp <+/- increment>] */
2094 case PREINCREMENT_EXPR:
2095 case PREDECREMENT_EXPR:
2096 /* [object setProperty: __objc_property_temp] */
2097 s2 = objc_build_setter_call (argument, temp_variable_decl);
2099 case POSTINCREMENT_EXPR:
2100 /* [object setProperty: __objc_property_temp + increment] */
2101 s2 = objc_build_setter_call (argument,
2102 build2 (PLUS_EXPR, TREE_TYPE (argument),
2103 temp_variable_decl, increment));
2105 case POSTDECREMENT_EXPR:
2106 /* [object setProperty: __objc_property_temp - increment] */
2107 s2 = objc_build_setter_call (argument,
2108 build2 (MINUS_EXPR, TREE_TYPE (argument),
2109 temp_variable_decl, increment));
2115 /* This happens if building the setter failed because the property
2117 if (s2 == error_mark_node)
2118 return error_mark_node;
2120 SET_EXPR_LOCATION (s2, location);
2122 /* s3: __objc_property_temp */
2123 s3 = convert (TREE_TYPE (argument), temp_variable_decl);
2125 /* Now build the compound statement (s1, s2, s3) */
2126 compound_expr = build_compound_expr (location, build_compound_expr (location, s1, s2), s3);
2128 /* Prevent C++ from warning with -Wall that "right operand of comma
2129 operator has no effect". */
2130 TREE_NO_WARNING (compound_expr) = 1;
2131 return compound_expr;
2135 objc_build_method_signature (bool is_class_method, tree rettype, tree selector,
2136 tree optparms, bool ellipsis)
2138 if (is_class_method)
2139 return build_method_decl (CLASS_METHOD_DECL, rettype, selector,
2140 optparms, ellipsis);
2142 return build_method_decl (INSTANCE_METHOD_DECL, rettype, selector,
2143 optparms, ellipsis);
2147 objc_add_method_declaration (bool is_class_method, tree decl, tree attributes)
2149 if (!objc_interface_context)
2151 /* PS: At the moment, due to how the parser works, it should be
2152 impossible to get here. But it's good to have the check in
2153 case the parser changes.
2155 fatal_error ("method declaration not in @interface context");
2158 if (flag_objc1_only && attributes)
2159 error_at (input_location, "method attributes are not available in Objective-C 1.0");
2161 objc_decl_method_attributes (&decl, attributes, 0);
2162 objc_add_method (objc_interface_context,
2165 objc_method_optional_flag);
2168 /* Return 'true' if the method definition could be started, and
2169 'false' if not (because we are outside an @implementation context).
2172 objc_start_method_definition (bool is_class_method, tree decl, tree attributes)
2174 if (!objc_implementation_context)
2176 error ("method definition not in @implementation context");
2180 if (decl != NULL_TREE && METHOD_SEL_NAME (decl) == error_mark_node)
2184 /* Indicate no valid break/continue context by setting these variables
2185 to some non-null, non-label value. We'll notice and emit the proper
2186 error message in c_finish_bc_stmt. */
2187 c_break_label = c_cont_label = size_zero_node;
2191 warning_at (input_location, 0, "method attributes can not be specified in @implementation context");
2193 objc_decl_method_attributes (&decl, attributes, 0);
2195 objc_add_method (objc_implementation_context,
2198 /* is optional */ false);
2199 start_method_def (decl);
2204 objc_add_instance_variable (tree decl)
2206 (void) add_instance_variable (objc_ivar_context,
2207 objc_ivar_visibility,
2211 /* Return true if TYPE is 'id'. */
2214 objc_is_object_id (tree type)
2216 return OBJC_TYPE_NAME (type) == objc_object_id;
2220 objc_is_class_id (tree type)
2222 return OBJC_TYPE_NAME (type) == objc_class_id;
2225 /* Construct a C struct with same name as KLASS, a base struct with tag
2226 SUPER_NAME (if any), and FIELDS indicated. */
2229 objc_build_struct (tree klass, tree fields, tree super_name)
2231 tree name = CLASS_NAME (klass);
2232 tree s = objc_start_struct (name);
2233 tree super = (super_name ? xref_tag (RECORD_TYPE, super_name) : NULL_TREE);
2235 VEC(tree,heap) *objc_info = NULL;
2240 /* Prepend a packed variant of the base class into the layout. This
2241 is necessary to preserve ObjC ABI compatibility. */
2242 tree base = build_decl (input_location,
2243 FIELD_DECL, NULL_TREE, super);
2244 tree field = TYPE_FIELDS (super);
2246 while (field && DECL_CHAIN (field)
2247 && TREE_CODE (DECL_CHAIN (field)) == FIELD_DECL)
2248 field = DECL_CHAIN (field);
2250 /* For ObjC ABI purposes, the "packed" size of a base class is
2251 the sum of the offset and the size (in bits) of the last field
2254 = (field && TREE_CODE (field) == FIELD_DECL
2255 ? size_binop (PLUS_EXPR,
2256 size_binop (PLUS_EXPR,
2259 convert (bitsizetype,
2260 DECL_FIELD_OFFSET (field)),
2261 bitsize_int (BITS_PER_UNIT)),
2262 DECL_FIELD_BIT_OFFSET (field)),
2264 : bitsize_zero_node);
2265 DECL_SIZE_UNIT (base)
2266 = size_binop (FLOOR_DIV_EXPR, convert (sizetype, DECL_SIZE (base)),
2267 size_int (BITS_PER_UNIT));
2268 DECL_ARTIFICIAL (base) = 1;
2269 DECL_ALIGN (base) = 1;
2270 DECL_FIELD_CONTEXT (base) = s;
2272 DECL_FIELD_IS_BASE (base) = 1;
2275 TREE_NO_WARNING (fields) = 1; /* Suppress C++ ABI warnings -- we */
2276 #endif /* are following the ObjC ABI here. */
2277 DECL_CHAIN (base) = fields;
2281 /* NB: Calling finish_struct() may cause type TYPE_OBJC_INFO
2282 information in all variants of this RECORD_TYPE to be destroyed
2283 (this is because the C frontend manipulates TYPE_LANG_SPECIFIC
2284 for something else and then will change all variants to use the
2285 same resulting TYPE_LANG_SPECIFIC, ignoring the fact that we use
2286 it for ObjC protocols and that such propagation will make all
2287 variants use the same objc_info), but it is therein that we store
2288 protocol conformance info (e.g., 'NSObject <MyProtocol>').
2289 Hence, we must save the ObjC-specific information before calling
2290 finish_struct(), and then reinstate it afterwards. */
2292 for (t = TYPE_MAIN_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t))
2294 INIT_TYPE_OBJC_INFO (t);
2295 VEC_safe_push (tree, heap, objc_info, TYPE_OBJC_INFO (t));
2298 s = objc_finish_struct (s, fields);
2300 for (i = 0, t = TYPE_MAIN_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t), i++)
2302 /* We now want to restore the different TYPE_OBJC_INFO, but we
2303 have the additional problem that the C frontend doesn't just
2304 copy TYPE_LANG_SPECIFIC from one variant to the other; it
2305 actually makes all of them the *same* TYPE_LANG_SPECIFIC. As
2306 we need a different TYPE_OBJC_INFO for each (and
2307 TYPE_OBJC_INFO is a field in TYPE_LANG_SPECIFIC), we need to
2308 make a copy of each TYPE_LANG_SPECIFIC before we modify
2310 if (TYPE_LANG_SPECIFIC (t))
2312 /* Create a copy of TYPE_LANG_SPECIFIC. */
2313 struct lang_type *old_lang_type = TYPE_LANG_SPECIFIC (t);
2314 ALLOC_OBJC_TYPE_LANG_SPECIFIC (t);
2315 memcpy (TYPE_LANG_SPECIFIC (t), old_lang_type,
2316 SIZEOF_OBJC_TYPE_LANG_SPECIFIC);
2320 /* Just create a new one. */
2321 ALLOC_OBJC_TYPE_LANG_SPECIFIC (t);
2323 /* Replace TYPE_OBJC_INFO with the saved one. This restores any
2324 protocol information that may have been associated with the
2326 TYPE_OBJC_INFO (t) = VEC_index (tree, objc_info, i);
2327 /* Replace the IDENTIFIER_NODE with an actual @interface now
2329 TYPE_OBJC_INTERFACE (t) = klass;
2331 VEC_free (tree, heap, objc_info);
2333 /* Use TYPE_BINFO structures to point at the super class, if any. */
2334 objc_xref_basetypes (s, super);
2336 /* Mark this struct as a class template. */
2337 CLASS_STATIC_TEMPLATE (klass) = s;
2342 /* Mark DECL as being 'volatile' for purposes of Darwin
2343 _setjmp()/_longjmp() exception handling. Called from
2344 objc_mark_locals_volatile(). */
2346 objc_volatilize_decl (tree decl)
2348 /* Do not mess with variables that are 'static' or (already)
2350 if (!TREE_THIS_VOLATILE (decl) && !TREE_STATIC (decl)
2351 && (TREE_CODE (decl) == VAR_DECL
2352 || TREE_CODE (decl) == PARM_DECL))
2354 if (local_variables_to_volatilize == NULL)
2355 local_variables_to_volatilize = VEC_alloc (tree, gc, 8);
2357 VEC_safe_push (tree, gc, local_variables_to_volatilize, decl);
2361 /* Called when parsing of a function completes; if any local variables
2362 in the function were marked as variables to volatilize, change them
2363 to volatile. We do this at the end of the function when the
2364 warnings about discarding 'volatile' have already been produced.
2365 We are making the variables as volatile just to force the compiler
2366 to preserve them between setjmp/longjmp, but we don't want warnings
2367 for them as they aren't really volatile. */
2369 objc_finish_function (void)
2371 /* If there are any local variables to volatilize, volatilize them. */
2372 if (local_variables_to_volatilize)
2376 FOR_EACH_VEC_ELT (tree, local_variables_to_volatilize, i, decl)
2378 tree t = TREE_TYPE (decl);
2380 t = build_qualified_type (t, TYPE_QUALS (t) | TYPE_QUAL_VOLATILE);
2381 TREE_TYPE (decl) = t;
2382 TREE_THIS_VOLATILE (decl) = 1;
2383 TREE_SIDE_EFFECTS (decl) = 1;
2384 DECL_REGISTER (decl) = 0;
2386 C_DECL_REGISTER (decl) = 0;
2390 /* Now we delete the vector. This sets it to NULL as well. */
2391 VEC_free (tree, gc, local_variables_to_volatilize);
2395 /* Check if protocol PROTO is adopted (directly or indirectly) by class CLS
2396 (including its categories and superclasses) or by object type TYP.
2397 Issue a warning if PROTO is not adopted anywhere and WARN is set. */
2400 objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn)
2402 bool class_type = (cls != NULL_TREE);
2408 /* Check protocols adopted by the class and its categories. */
2409 for (c = cls; c; c = CLASS_CATEGORY_LIST (c))
2411 if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c), proto))
2415 /* Repeat for superclasses. */
2416 cls = lookup_interface (CLASS_SUPER_NAME (cls));
2419 /* Check for any protocols attached directly to the object type. */
2420 if (TYPE_HAS_OBJC_INFO (typ))
2422 if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ), proto))
2429 gen_type_name_0 (class_type ? typ : TYPE_POINTER_TO (typ));
2430 /* NB: Types 'id' and 'Class' cannot reasonably be described as
2431 "implementing" a given protocol, since they do not have an
2434 warning (0, "class %qs does not implement the %qE protocol",
2435 identifier_to_locale (errbuf), PROTOCOL_NAME (proto));
2437 warning (0, "type %qs does not conform to the %qE protocol",
2438 identifier_to_locale (errbuf), PROTOCOL_NAME (proto));
2444 /* Check if class RCLS and instance struct type RTYP conform to at least the
2445 same protocols that LCLS and LTYP conform to. */
2448 objc_compare_protocols (tree lcls, tree ltyp, tree rcls, tree rtyp, bool warn)
2451 bool have_lproto = false;
2455 /* NB: We do _not_ look at categories defined for LCLS; these may or
2456 may not get loaded in, and therefore it is unreasonable to require
2457 that RCLS/RTYP must implement any of their protocols. */
2458 for (p = CLASS_PROTOCOL_LIST (lcls); p; p = TREE_CHAIN (p))
2462 if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
2466 /* Repeat for superclasses. */
2467 lcls = lookup_interface (CLASS_SUPER_NAME (lcls));
2470 /* Check for any protocols attached directly to the object type. */
2471 if (TYPE_HAS_OBJC_INFO (ltyp))
2473 for (p = TYPE_OBJC_PROTOCOL_LIST (ltyp); p; p = TREE_CHAIN (p))
2477 if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
2482 /* NB: If LTYP and LCLS have no protocols to search for, return 'true'
2483 vacuously, _unless_ RTYP is a protocol-qualified 'id'. We can get
2484 away with simply checking for 'id' or 'Class' (!RCLS), since this
2485 routine will not get called in other cases. */
2486 return have_lproto || (rcls != NULL_TREE);
2489 /* Given two types TYPE1 and TYPE2, return their least common ancestor.
2490 Both TYPE1 and TYPE2 must be pointers, and already determined to be
2491 compatible by objc_compare_types() below. */
2494 objc_common_type (tree type1, tree type2)
2496 tree inner1 = TREE_TYPE (type1), inner2 = TREE_TYPE (type2);
2498 while (POINTER_TYPE_P (inner1))
2500 inner1 = TREE_TYPE (inner1);
2501 inner2 = TREE_TYPE (inner2);
2504 /* If one type is derived from another, return the base type. */
2505 if (DERIVED_FROM_P (inner1, inner2))
2507 else if (DERIVED_FROM_P (inner2, inner1))
2510 /* If both types are 'Class', return 'Class'. */
2511 if (objc_is_class_id (inner1) && objc_is_class_id (inner2))
2512 return objc_class_type;
2514 /* Otherwise, return 'id'. */
2515 return objc_object_type;
2518 /* Determine if it is permissible to assign (if ARGNO is greater than -3)
2519 an instance of RTYP to an instance of LTYP or to compare the two
2520 (if ARGNO is equal to -3), per ObjC type system rules. Before
2521 returning 'true', this routine may issue warnings related to, e.g.,
2522 protocol conformance. When returning 'false', the routine must
2523 produce absolutely no warnings; the C or C++ front-end will do so
2524 instead, if needed. If either LTYP or RTYP is not an Objective-C
2525 type, the routine must return 'false'.
2527 The ARGNO parameter is encoded as follows:
2528 >= 1 Parameter number (CALLEE contains function being called);
2532 -3 Comparison (LTYP and RTYP may match in either direction);
2533 -4 Silent comparison (for C++ overload resolution);
2534 -5 Silent "specialization" comparison for RTYP to be a "specialization"
2535 of LTYP (a specialization means that RTYP is LTYP plus some constraints,
2536 so that each object of type RTYP is also of type LTYP). This is used
2537 when comparing property types. */
2540 objc_compare_types (tree ltyp, tree rtyp, int argno, tree callee)
2542 tree lcls, rcls, lproto, rproto;
2543 bool pointers_compatible;
2545 /* We must be dealing with pointer types */
2546 if (!POINTER_TYPE_P (ltyp) || !POINTER_TYPE_P (rtyp))
2551 ltyp = TREE_TYPE (ltyp); /* Remove indirections. */
2552 rtyp = TREE_TYPE (rtyp);
2554 while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp));
2556 /* We must also handle function pointers, since ObjC is a bit more
2557 lenient than C or C++ on this. */
2558 if (TREE_CODE (ltyp) == FUNCTION_TYPE && TREE_CODE (rtyp) == FUNCTION_TYPE)
2560 /* Return types must be covariant. */
2561 if (!comptypes (TREE_TYPE (ltyp), TREE_TYPE (rtyp))
2562 && !objc_compare_types (TREE_TYPE (ltyp), TREE_TYPE (rtyp),
2566 /* Argument types must be contravariant. */
2567 for (ltyp = TYPE_ARG_TYPES (ltyp), rtyp = TYPE_ARG_TYPES (rtyp);
2568 ltyp && rtyp; ltyp = TREE_CHAIN (ltyp), rtyp = TREE_CHAIN (rtyp))
2570 if (!comptypes (TREE_VALUE (rtyp), TREE_VALUE (ltyp))
2571 && !objc_compare_types (TREE_VALUE (rtyp), TREE_VALUE (ltyp),
2576 return (ltyp == rtyp);
2579 /* Past this point, we are only interested in ObjC class instances,
2580 or 'id' or 'Class'. */
2581 if (TREE_CODE (ltyp) != RECORD_TYPE || TREE_CODE (rtyp) != RECORD_TYPE)
2584 if (!objc_is_object_id (ltyp) && !objc_is_class_id (ltyp)
2585 && !TYPE_HAS_OBJC_INFO (ltyp))
2588 if (!objc_is_object_id (rtyp) && !objc_is_class_id (rtyp)
2589 && !TYPE_HAS_OBJC_INFO (rtyp))
2592 /* Past this point, we are committed to returning 'true' to the caller
2593 (unless performing a silent comparison; see below). However, we can
2594 still warn about type and/or protocol mismatches. */
2596 if (TYPE_HAS_OBJC_INFO (ltyp))
2598 lcls = TYPE_OBJC_INTERFACE (ltyp);
2599 lproto = TYPE_OBJC_PROTOCOL_LIST (ltyp);
2602 lcls = lproto = NULL_TREE;
2604 if (TYPE_HAS_OBJC_INFO (rtyp))
2606 rcls = TYPE_OBJC_INTERFACE (rtyp);
2607 rproto = TYPE_OBJC_PROTOCOL_LIST (rtyp);
2610 rcls = rproto = NULL_TREE;
2612 /* If we could not find an @interface declaration, we must have
2613 only seen a @class declaration; for purposes of type comparison,
2614 treat it as a stand-alone (root) class. */
2616 if (lcls && TREE_CODE (lcls) == IDENTIFIER_NODE)
2619 if (rcls && TREE_CODE (rcls) == IDENTIFIER_NODE)
2622 /* If either type is an unqualified 'id', we're done. This is because
2623 an 'id' can be assigned to or from any type with no warnings. */
2626 if ((!lproto && objc_is_object_id (ltyp))
2627 || (!rproto && objc_is_object_id (rtyp)))
2632 /* For property checks, though, an 'id' is considered the most
2633 general type of object, hence if you try to specialize an
2634 'NSArray *' (ltyp) property with an 'id' (rtyp) one, we need
2636 if (!lproto && objc_is_object_id (ltyp))
2640 pointers_compatible = (TYPE_MAIN_VARIANT (ltyp) == TYPE_MAIN_VARIANT (rtyp));
2642 /* If the underlying types are the same, and at most one of them has
2643 a protocol list, we do not need to issue any diagnostics. */
2644 if (pointers_compatible && (!lproto || !rproto))
2647 /* If exactly one of the types is 'Class', issue a diagnostic; any
2648 exceptions of this rule have already been handled. */
2649 if (objc_is_class_id (ltyp) ^ objc_is_class_id (rtyp))
2650 pointers_compatible = false;
2651 /* Otherwise, check for inheritance relations. */
2654 if (!pointers_compatible)
2656 /* Again, if any of the two is an 'id', we're satisfied,
2657 unless we're comparing properties, in which case only an
2658 'id' on the left-hand side (old property) is good
2662 = (objc_is_object_id (ltyp) || objc_is_object_id (rtyp));
2664 pointers_compatible = objc_is_object_id (ltyp);
2667 if (!pointers_compatible)
2668 pointers_compatible = DERIVED_FROM_P (ltyp, rtyp);
2670 if (!pointers_compatible && (argno == -3 || argno == -4))
2671 pointers_compatible = DERIVED_FROM_P (rtyp, ltyp);
2674 /* If the pointers match modulo protocols, check for protocol conformance
2676 if (pointers_compatible)
2678 pointers_compatible = objc_compare_protocols (lcls, ltyp, rcls, rtyp,
2681 if (!pointers_compatible && argno == -3)
2682 pointers_compatible = objc_compare_protocols (rcls, rtyp, lcls, ltyp,
2686 if (!pointers_compatible)
2688 /* The two pointers are not exactly compatible. Issue a warning, unless
2689 we are performing a silent comparison, in which case return 'false'
2691 /* NB: For the time being, we shall make our warnings look like their
2692 C counterparts. In the future, we may wish to make them more
2701 warning (0, "comparison of distinct Objective-C types lacks a cast");
2705 warning (0, "initialization from distinct Objective-C type");
2709 warning (0, "assignment from distinct Objective-C type");
2713 warning (0, "distinct Objective-C type in return");
2717 warning (0, "passing argument %d of %qE from distinct "
2718 "Objective-C type", argno, callee);
2726 /* This routine is similar to objc_compare_types except that function-pointers are
2727 excluded. This is because, caller assumes that common types are of (id, Object*)
2728 variety and calls objc_common_type to obtain a common type. There is no commonolty
2729 between two function-pointers in this regard. */
2732 objc_have_common_type (tree ltyp, tree rtyp, int argno, tree callee)
2734 if (objc_compare_types (ltyp, rtyp, argno, callee))
2736 /* exclude function-pointer types. */
2739 ltyp = TREE_TYPE (ltyp); /* Remove indirections. */
2740 rtyp = TREE_TYPE (rtyp);
2742 while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp));
2743 return !(TREE_CODE (ltyp) == FUNCTION_TYPE && TREE_CODE (rtyp) == FUNCTION_TYPE);
2749 /* Determine if CHILD is derived from PARENT. The routine assumes that
2750 both parameters are RECORD_TYPEs, and is non-reflexive. */
2753 objc_derived_from_p (tree parent, tree child)
2755 parent = TYPE_MAIN_VARIANT (parent);
2757 for (child = TYPE_MAIN_VARIANT (child);
2758 TYPE_BINFO (child) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child));)
2760 child = TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO
2761 (TYPE_BINFO (child),
2764 if (child == parent)
2773 objc_build_component_ref (tree datum, tree component)
2775 /* If COMPONENT is NULL, the caller is referring to the anonymous
2776 base class field. */
2779 tree base = TYPE_FIELDS (TREE_TYPE (datum));
2781 return build3 (COMPONENT_REF, TREE_TYPE (base), datum, base, NULL_TREE);
2784 /* The 'build_component_ref' routine has been removed from the C++
2785 front-end, but 'finish_class_member_access_expr' seems to be
2786 a worthy substitute. */
2788 return finish_class_member_access_expr (datum, component, false,
2789 tf_warning_or_error);
2791 return build_component_ref (input_location, datum, component);
2795 /* Recursively copy inheritance information rooted at BINFO. To do this,
2796 we emulate the song and dance performed by cp/tree.c:copy_binfo(). */
2799 objc_copy_binfo (tree binfo)
2801 tree btype = BINFO_TYPE (binfo);
2802 tree binfo2 = make_tree_binfo (BINFO_N_BASE_BINFOS (binfo));
2806 BINFO_TYPE (binfo2) = btype;
2807 BINFO_OFFSET (binfo2) = BINFO_OFFSET (binfo);
2808 BINFO_BASE_ACCESSES (binfo2) = BINFO_BASE_ACCESSES (binfo);
2810 /* Recursively copy base binfos of BINFO. */
2811 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
2813 tree base_binfo2 = objc_copy_binfo (base_binfo);
2815 BINFO_INHERITANCE_CHAIN (base_binfo2) = binfo2;
2816 BINFO_BASE_APPEND (binfo2, base_binfo2);
2822 /* Record superclass information provided in BASETYPE for ObjC class REF.
2823 This is loosely based on cp/decl.c:xref_basetypes(). */
2826 objc_xref_basetypes (tree ref, tree basetype)
2828 tree binfo = make_tree_binfo (basetype ? 1 : 0);
2830 TYPE_BINFO (ref) = binfo;
2831 BINFO_OFFSET (binfo) = size_zero_node;
2832 BINFO_TYPE (binfo) = ref;
2836 tree base_binfo = objc_copy_binfo (TYPE_BINFO (basetype));
2838 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
2839 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, 1);
2840 BINFO_BASE_APPEND (binfo, base_binfo);
2841 BINFO_BASE_ACCESS_APPEND (binfo, access_public_node);
2845 /* Called from finish_decl. */
2848 objc_check_decl (tree decl)
2850 tree type = TREE_TYPE (decl);
2852 if (TREE_CODE (type) != RECORD_TYPE)
2854 if (OBJC_TYPE_NAME (type) && (type = objc_is_class_name (OBJC_TYPE_NAME (type))))
2855 error ("statically allocated instance of Objective-C class %qE",
2860 objc_check_global_decl (tree decl)
2862 tree id = DECL_NAME (decl);
2863 if (objc_is_class_name (id) && global_bindings_p())
2864 error ("redeclaration of Objective-C class %qs", IDENTIFIER_POINTER (id));
2867 /* Construct a PROTOCOLS-qualified variant of INTERFACE, where
2868 INTERFACE may either name an Objective-C class, or refer to the
2869 special 'id' or 'Class' types. If INTERFACE is not a valid ObjC
2870 type, just return it unchanged. This function is often called when
2871 PROTOCOLS is NULL_TREE, in which case we simply look up the
2872 appropriate INTERFACE. */
2875 objc_get_protocol_qualified_type (tree interface, tree protocols)
2877 /* If INTERFACE is not provided, default to 'id'. */
2878 tree type = (interface ? objc_is_id (interface) : objc_object_type);
2879 bool is_ptr = (type != NULL_TREE);
2883 type = objc_is_class_name (interface);
2887 /* If looking at a typedef, retrieve the precise type it
2889 if (TREE_CODE (interface) == IDENTIFIER_NODE)
2890 interface = identifier_global_value (interface);
2892 type = ((interface && TREE_CODE (interface) == TYPE_DECL
2893 && DECL_ORIGINAL_TYPE (interface))
2894 ? DECL_ORIGINAL_TYPE (interface)
2895 : xref_tag (RECORD_TYPE, type));
2899 /* This case happens when we are given an 'interface' which
2900 is not a valid class name. For example if a typedef was
2901 used, and 'interface' really is the identifier of the
2902 typedef, but when you resolve it you don't get an
2903 Objective-C class, but something else, such as 'int'.
2904 This is an error; protocols make no sense unless you use
2905 them with Objective-C objects. */
2906 error_at (input_location, "only Objective-C object types can be qualified with a protocol");
2908 /* Try to recover. Ignore the invalid class name, and treat
2909 the object as an 'id' to silence further warnings about
2911 type = objc_object_type;
2918 type = build_variant_type_copy (type);
2920 /* For pointers (i.e., 'id' or 'Class'), attach the protocol(s)
2924 tree orig_pointee_type = TREE_TYPE (type);
2925 TREE_TYPE (type) = build_variant_type_copy (orig_pointee_type);
2927 /* Set up the canonical type information. */
2928 TYPE_CANONICAL (type)
2929 = TYPE_CANONICAL (TYPE_POINTER_TO (orig_pointee_type));
2931 TYPE_POINTER_TO (TREE_TYPE (type)) = type;
2932 type = TREE_TYPE (type);
2935 /* Look up protocols and install in lang specific list. */
2936 DUP_TYPE_OBJC_INFO (type, TYPE_MAIN_VARIANT (type));
2937 TYPE_OBJC_PROTOCOL_LIST (type) = lookup_and_install_protocols
2938 (protocols, /* definition_required */ false);
2940 /* For RECORD_TYPEs, point to the @interface; for 'id' and 'Class',
2941 return the pointer to the new pointee variant. */
2943 type = TYPE_POINTER_TO (type);
2945 TYPE_OBJC_INTERFACE (type)
2946 = TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type));
2952 /* Check for circular dependencies in protocols. The arguments are
2953 PROTO, the protocol to check, and LIST, a list of protocol it
2957 check_protocol_recursively (tree proto, tree list)
2961 for (p = list; p; p = TREE_CHAIN (p))
2963 tree pp = TREE_VALUE (p);
2965 if (TREE_CODE (pp) == IDENTIFIER_NODE)
2966 pp = lookup_protocol (pp, /* warn if deprecated */ false,
2967 /* definition_required */ false);
2970 fatal_error ("protocol %qE has circular dependency",
2971 PROTOCOL_NAME (pp));
2973 check_protocol_recursively (proto, PROTOCOL_LIST (pp));
2977 /* Look up PROTOCOLS, and return a list of those that are found. If
2978 none are found, return NULL. Note that this function will emit a
2979 warning if a protocol is found and is deprecated. If
2980 'definition_required', then warn if the protocol is found but is
2981 not defined (ie, if we only saw a forward-declaration of the
2982 protocol (as in "@protocol NSObject;") not a real definition with
2983 the list of methods). */
2985 lookup_and_install_protocols (tree protocols, bool definition_required)
2988 tree return_value = NULL_TREE;
2990 if (protocols == error_mark_node)
2993 for (proto = protocols; proto; proto = TREE_CHAIN (proto))
2995 tree ident = TREE_VALUE (proto);
2996 tree p = lookup_protocol (ident, /* warn_if_deprecated */ true,
2997 definition_required);
3000 return_value = chainon (return_value,
3001 build_tree_list (NULL_TREE, p));
3002 else if (ident != error_mark_node)
3003 error ("cannot find protocol declaration for %qE",
3007 return return_value;
3010 /* Create a declaration for field NAME of a given TYPE. */
3013 create_field_decl (tree type, const char *name)
3015 return build_decl (input_location,
3016 FIELD_DECL, get_identifier (name), type);
3019 /* Create a global, static declaration for variable NAME of a given TYPE. The
3020 finish_var_decl() routine will need to be called on it afterwards. */
3023 start_var_decl (tree type, const char *name)
3025 tree var = build_decl (input_location,
3026 VAR_DECL, get_identifier (name), type);
3028 TREE_STATIC (var) = 1;
3029 DECL_INITIAL (var) = error_mark_node; /* A real initializer is coming... */
3030 DECL_IGNORED_P (var) = 1;
3031 DECL_ARTIFICIAL (var) = 1;
3032 DECL_CONTEXT (var) = NULL_TREE;
3034 DECL_THIS_STATIC (var) = 1; /* squash redeclaration errors */
3040 /* Finish off the variable declaration created by start_var_decl(). */
3043 finish_var_decl (tree var, tree initializer)
3045 finish_decl (var, input_location, initializer, NULL_TREE, NULL_TREE);
3048 /* Find the decl for the constant string class reference. This is only
3049 used for the NeXT runtime. */
3052 setup_string_decl (void)
3057 /* %s in format will provide room for terminating null */
3058 length = strlen (STRING_OBJECT_GLOBAL_FORMAT)
3059 + strlen (constant_string_class_name);
3060 name = XNEWVEC (char, length);
3061 sprintf (name, STRING_OBJECT_GLOBAL_FORMAT,
3062 constant_string_class_name);
3063 constant_string_global_id = get_identifier (name);
3064 string_class_decl = lookup_name (constant_string_global_id);
3066 return string_class_decl;
3069 /* Purpose: "play" parser, creating/installing representations
3070 of the declarations that are required by Objective-C.
3074 type_spec--------->sc_spec
3075 (tree_list) (tree_list)
3078 identifier_node identifier_node */
3081 synth_module_prologue (void)
3084 enum debug_info_type save_write_symbols = write_symbols;
3085 const struct gcc_debug_hooks *const save_hooks = debug_hooks;
3087 /* Suppress outputting debug symbols, because
3088 dbxout_init hasn't been called yet. */
3089 write_symbols = NO_DEBUG;
3090 debug_hooks = &do_nothing_debug_hooks;
3093 push_lang_context (lang_name_c); /* extern "C" */
3096 /* The following are also defined in <objc/objc.h> and friends. */
3098 objc_object_id = get_identifier (TAG_OBJECT);
3099 objc_class_id = get_identifier (TAG_CLASS);
3101 objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
3102 objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id);
3104 objc_object_type = build_pointer_type (objc_object_reference);
3105 objc_class_type = build_pointer_type (objc_class_reference);
3107 objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME);
3108 objc_class_name = get_identifier (CLASS_TYPEDEF_NAME);
3110 /* Declare the 'id' and 'Class' typedefs. */
3112 type = lang_hooks.decls.pushdecl (build_decl (input_location,
3116 TREE_NO_WARNING (type) = 1;
3117 type = lang_hooks.decls.pushdecl (build_decl (input_location,
3121 TREE_NO_WARNING (type) = 1;
3123 /* Forward-declare '@interface Protocol'. */
3125 type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
3126 objc_declare_class (tree_cons (NULL_TREE, type, NULL_TREE));
3127 objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
3130 /* Declare type of selector-objects that represent an operation name. */
3132 if (flag_next_runtime)
3133 /* `struct objc_selector *' */
3135 = build_pointer_type (xref_tag (RECORD_TYPE,
3136 get_identifier (TAG_SELECTOR)));
3138 /* `const struct objc_selector *' */
3140 = build_pointer_type
3141 (build_qualified_type (xref_tag (RECORD_TYPE,
3142 get_identifier (TAG_SELECTOR)),
3145 /* Declare receiver type used for dispatching messages to 'super'. */
3147 /* `struct objc_super *' */
3148 objc_super_type = build_pointer_type (xref_tag (RECORD_TYPE,
3149 get_identifier (TAG_SUPER)));
3151 /* Declare pointers to method and ivar lists. */
3152 objc_method_list_ptr = build_pointer_type
3153 (xref_tag (RECORD_TYPE,
3154 get_identifier (UTAG_METHOD_LIST)));
3155 objc_method_proto_list_ptr
3156 = build_pointer_type (xref_tag (RECORD_TYPE,
3157 get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
3158 objc_ivar_list_ptr = build_pointer_type
3159 (xref_tag (RECORD_TYPE,
3160 get_identifier (UTAG_IVAR_LIST)));
3162 /* TREE_NOTHROW is cleared for the message-sending functions,
3163 because the function that gets called can throw in Obj-C++, or
3164 could itself call something that can throw even in Obj-C. */
3166 if (flag_next_runtime)
3168 /* NB: In order to call one of the ..._stret (struct-returning)
3169 functions, the function *MUST* first be cast to a signature that
3170 corresponds to the actual ObjC method being invoked. This is
3171 what is done by the build_objc_method_call() routine below. */
3173 /* id objc_msgSend (id, SEL, ...); */
3174 /* id objc_msgSendNonNil (id, SEL, ...); */
3175 /* id objc_msgSend_stret (id, SEL, ...); */
3176 /* id objc_msgSendNonNil_stret (id, SEL, ...); */
3178 = build_varargs_function_type_list (objc_object_type,
3182 umsg_decl = add_builtin_function (TAG_MSGSEND,
3183 type, 0, NOT_BUILT_IN,
3185 umsg_nonnil_decl = add_builtin_function (TAG_MSGSEND_NONNIL,
3186 type, 0, NOT_BUILT_IN,
3188 umsg_stret_decl = add_builtin_function (TAG_MSGSEND_STRET,
3189 type, 0, NOT_BUILT_IN,
3191 umsg_nonnil_stret_decl = add_builtin_function (TAG_MSGSEND_NONNIL_STRET,
3192 type, 0, NOT_BUILT_IN,
3195 /* These can throw, because the function that gets called can throw
3196 in Obj-C++, or could itself call something that can throw even
3198 TREE_NOTHROW (umsg_decl) = 0;
3199 TREE_NOTHROW (umsg_nonnil_decl) = 0;
3200 TREE_NOTHROW (umsg_stret_decl) = 0;
3201 TREE_NOTHROW (umsg_nonnil_stret_decl) = 0;
3203 /* id objc_msgSend_Fast (id, SEL, ...)
3204 __attribute__ ((hard_coded_address (OFFS_MSGSEND_FAST))); */
3205 #ifdef OFFS_MSGSEND_FAST
3206 umsg_fast_decl = add_builtin_function (TAG_MSGSEND_FAST,
3207 type, 0, NOT_BUILT_IN,
3209 TREE_NOTHROW (umsg_fast_decl) = 0;
3210 DECL_ATTRIBUTES (umsg_fast_decl)
3211 = tree_cons (get_identifier ("hard_coded_address"),
3212 build_int_cst (NULL_TREE, OFFS_MSGSEND_FAST),
3215 /* No direct dispatch available. */
3216 umsg_fast_decl = umsg_decl;
3219 /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
3220 /* id objc_msgSendSuper_stret (struct objc_super *, SEL, ...); */
3222 = build_varargs_function_type_list (objc_object_type,
3226 umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
3227 type, 0, NOT_BUILT_IN,
3229 umsg_super_stret_decl = add_builtin_function (TAG_MSGSENDSUPER_STRET,
3230 type, 0, NOT_BUILT_IN, 0,
3232 TREE_NOTHROW (umsg_super_decl) = 0;
3233 TREE_NOTHROW (umsg_super_stret_decl) = 0;
3237 /* GNU runtime messenger entry points. */
3239 /* typedef id (*IMP)(id, SEL, ...); */
3241 build_varargs_function_type_list (objc_object_type,
3245 tree IMP_type = build_pointer_type (ftype);
3247 /* IMP objc_msg_lookup (id, SEL); */
3248 type = build_function_type_list (IMP_type,
3252 umsg_decl = add_builtin_function (TAG_MSGSEND,
3253 type, 0, NOT_BUILT_IN,
3255 TREE_NOTHROW (umsg_decl) = 0;
3257 /* IMP objc_msg_lookup_super (struct objc_super *, SEL); */
3259 = build_function_type_list (IMP_type,
3263 umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
3264 type, 0, NOT_BUILT_IN,
3266 TREE_NOTHROW (umsg_super_decl) = 0;
3268 /* The following GNU runtime entry point is called to initialize
3271 __objc_exec_class (void *); */
3273 = build_function_type_list (void_type_node,
3276 execclass_decl = add_builtin_function (TAG_EXECCLASS,
3277 type, 0, NOT_BUILT_IN,
3281 /* id objc_getClass (const char *); */
3283 type = build_function_type_list (objc_object_type,
3284 const_string_type_node,
3288 = add_builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN,
3291 /* id objc_getMetaClass (const char *); */
3293 objc_get_meta_class_decl
3294 = add_builtin_function (TAG_GETMETACLASS, type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
3296 build_class_template ();
3297 build_super_template ();
3298 build_protocol_template ();
3299 build_category_template ();
3300 build_objc_exception_stuff ();
3302 /* Declare objc_getProperty, object_setProperty and other property
3303 accessor helpers. */
3304 build_objc_property_accessor_helpers ();
3306 if (flag_next_runtime)
3307 build_next_objc_exception_stuff ();
3309 /* static SEL _OBJC_SELECTOR_TABLE[]; */
3311 if (! flag_next_runtime)
3312 build_selector_table_decl ();
3314 /* Forward declare constant_string_id and constant_string_type. */
3315 if (!constant_string_class_name)
3316 constant_string_class_name = default_constant_string_class_name;
3318 constant_string_id = get_identifier (constant_string_class_name);
3319 objc_declare_class (tree_cons (NULL_TREE, constant_string_id, NULL_TREE));
3321 /* Pre-build the following entities - for speed/convenience. */
3322 self_id = get_identifier ("self");
3323 ucmd_id = get_identifier ("_cmd");
3325 /* Declare struct _objc_fast_enumeration_state { ... }; */
3326 build_fast_enumeration_state_template ();
3328 /* void objc_enumeration_mutation (id) */
3329 type = build_function_type (void_type_node,
3330 tree_cons (NULL_TREE, objc_object_type, NULL_TREE));
3331 objc_enumeration_mutation_decl
3332 = add_builtin_function (TAG_ENUMERATION_MUTATION, type, 0, NOT_BUILT_IN,
3334 TREE_NOTHROW (objc_enumeration_mutation_decl) = 0;
3337 pop_lang_context ();
3340 write_symbols = save_write_symbols;
3341 debug_hooks = save_hooks;
3344 /* Ensure that the ivar list for NSConstantString/NXConstantString
3345 (or whatever was specified via `-fconstant-string-class')
3346 contains fields at least as large as the following three, so that
3347 the runtime can stomp on them with confidence:
3349 struct STRING_OBJECT_CLASS_NAME
3353 unsigned int length;
3357 check_string_class_template (void)
3359 tree field_decl = objc_get_class_ivars (constant_string_id);
3361 #define AT_LEAST_AS_LARGE_AS(F, T) \
3362 (F && TREE_CODE (F) == FIELD_DECL \
3363 && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \
3364 >= TREE_INT_CST_LOW (TYPE_SIZE (T))))
3366 if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
3369 field_decl = DECL_CHAIN (field_decl);
3370 if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
3373 field_decl = DECL_CHAIN (field_decl);
3374 return AT_LEAST_AS_LARGE_AS (field_decl, unsigned_type_node);
3376 #undef AT_LEAST_AS_LARGE_AS
3379 /* Avoid calling `check_string_class_template ()' more than once. */
3380 static GTY(()) int string_layout_checked;
3382 /* Construct an internal string layout to be used as a template for
3383 creating NSConstantString/NXConstantString instances. */
3386 objc_build_internal_const_str_type (void)
3388 tree type = (*lang_hooks.types.make_type) (RECORD_TYPE);
3389 tree fields = build_decl (input_location,
3390 FIELD_DECL, NULL_TREE, ptr_type_node);
3391 tree field = build_decl (input_location,
3392 FIELD_DECL, NULL_TREE, ptr_type_node);
3394 DECL_CHAIN (field) = fields; fields = field;
3395 field = build_decl (input_location,
3396 FIELD_DECL, NULL_TREE, unsigned_type_node);
3397 DECL_CHAIN (field) = fields; fields = field;
3398 /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in
3400 finish_builtin_struct (type, "__builtin_ObjCString",
3406 /* Custom build_string which sets TREE_TYPE! */
3409 my_build_string (int len, const char *str)
3411 return fix_string_type (build_string (len, str));
3414 /* Build a string with contents STR and length LEN and convert it to a
3418 my_build_string_pointer (int len, const char *str)
3420 tree string = my_build_string (len, str);
3421 tree ptrtype = build_pointer_type (TREE_TYPE (TREE_TYPE (string)));
3422 return build1 (ADDR_EXPR, ptrtype, string);
3426 string_hash (const void *ptr)
3428 const_tree const str = ((const struct string_descriptor *)ptr)->literal;
3429 const unsigned char *p = (const unsigned char *) TREE_STRING_POINTER (str);
3430 int i, len = TREE_STRING_LENGTH (str);
3433 for (i = 0; i < len; i++)
3434 h = ((h * 613) + p[i]);
3440 string_eq (const void *ptr1, const void *ptr2)
3442 const_tree const str1 = ((const struct string_descriptor *)ptr1)->literal;
3443 const_tree const str2 = ((const struct string_descriptor *)ptr2)->literal;
3444 int len1 = TREE_STRING_LENGTH (str1);
3446 return (len1 == TREE_STRING_LENGTH (str2)
3447 && !memcmp (TREE_STRING_POINTER (str1), TREE_STRING_POINTER (str2),
3451 /* Given a chain of STRING_CST's, build a static instance of
3452 NXConstantString which points at the concatenation of those
3453 strings. We place the string object in the __string_objects
3454 section of the __OBJC segment. The Objective-C runtime will
3455 initialize the isa pointers of the string objects to point at the
3456 NXConstantString class object. */
3459 objc_build_string_object (tree string)
3461 tree constant_string_class;
3464 struct string_descriptor *desc, key;
3467 /* Prep the string argument. */
3468 string = fix_string_type (string);
3469 TREE_SET_CODE (string, STRING_CST);
3470 length = TREE_STRING_LENGTH (string) - 1;
3472 /* The target may have different ideas on how to construct an ObjC string
3473 literal. On Darwin (Mac OS X), for example, we may wish to obtain a
3474 constant CFString reference instead.
3475 At present, this is only supported for the NeXT runtime. */
3476 if (flag_next_runtime && targetcm.objc_construct_string_object)
3478 tree constructor = (*targetcm.objc_construct_string_object) (string);
3480 return build1 (NOP_EXPR, objc_object_type, constructor);
3483 /* Check whether the string class being used actually exists and has the
3484 correct ivar layout. */
3485 if (!string_layout_checked)
3487 string_layout_checked = -1;
3488 constant_string_class = lookup_interface (constant_string_id);
3489 internal_const_str_type = objc_build_internal_const_str_type ();
3491 if (!constant_string_class
3492 || !(constant_string_type
3493 = CLASS_STATIC_TEMPLATE (constant_string_class)))
3494 error ("cannot find interface declaration for %qE",
3495 constant_string_id);
3496 /* The NSConstantString/NXConstantString ivar layout is now known. */
3497 else if (!check_string_class_template ())
3498 error ("interface %qE does not have valid constant string layout",
3499 constant_string_id);
3500 /* For the NeXT runtime, we can generate a literal reference
3501 to the string class, don't need to run a constructor. */
3502 else if (flag_next_runtime && !setup_string_decl ())
3503 error ("cannot find reference tag for class %qE",
3504 constant_string_id);
3507 string_layout_checked = 1; /* Success! */
3508 add_class_reference (constant_string_id);
3512 if (string_layout_checked == -1)
3513 return error_mark_node;
3515 /* Perhaps we already constructed a constant string just like this one? */
3516 key.literal = string;
3517 loc = htab_find_slot (string_htab, &key, INSERT);
3518 desc = (struct string_descriptor *) *loc;
3522 tree var, constructor;
3523 VEC(constructor_elt,gc) *v = NULL;
3524 *loc = desc = ggc_alloc_string_descriptor ();
3525 desc->literal = string;
3527 /* GNU: (NXConstantString *) & ((__builtin_ObjCString) { NULL, string, length }) */
3528 /* NeXT: (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length }) */
3529 fields = TYPE_FIELDS (internal_const_str_type);
3530 CONSTRUCTOR_APPEND_ELT (v, fields,
3532 ? build_unary_op (input_location,
3533 ADDR_EXPR, string_class_decl, 0)
3534 : build_int_cst (NULL_TREE, 0));
3535 fields = DECL_CHAIN (fields);
3536 CONSTRUCTOR_APPEND_ELT (v, fields,
3537 build_unary_op (input_location,
3538 ADDR_EXPR, string, 1));
3539 fields = DECL_CHAIN (fields);
3540 CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, length));
3541 constructor = objc_build_constructor (internal_const_str_type, v);
3543 if (!flag_next_runtime)
3545 = objc_add_static_instance (constructor, constant_string_type);
3548 var = build_decl (input_location,
3549 CONST_DECL, NULL, TREE_TYPE (constructor));
3550 DECL_INITIAL (var) = constructor;
3551 TREE_STATIC (var) = 1;
3552 pushdecl_top_level (var);
3555 desc->constructor = constructor;
3558 addr = convert (build_pointer_type (constant_string_type),
3559 build_unary_op (input_location,
3560 ADDR_EXPR, desc->constructor, 1));
3565 /* Declare a static instance of CLASS_DECL initialized by CONSTRUCTOR. */
3567 static GTY(()) int num_static_inst;
3570 objc_add_static_instance (tree constructor, tree class_decl)
3575 /* Find the list of static instances for the CLASS_DECL. Create one if
3577 for (chain = &objc_static_instances;
3578 *chain && TREE_VALUE (*chain) != class_decl;
3579 chain = &TREE_CHAIN (*chain));
3582 *chain = tree_cons (NULL_TREE, class_decl, NULL_TREE);
3583 add_objc_string (OBJC_TYPE_NAME (class_decl), class_names);
3586 sprintf (buf, "_OBJC_INSTANCE_%d", num_static_inst++);
3587 decl = build_decl (input_location,
3588 VAR_DECL, get_identifier (buf), class_decl);
3589 TREE_STATIC (decl) = 1;
3590 DECL_ARTIFICIAL (decl) = 1;
3591 TREE_USED (decl) = 1;
3592 DECL_INITIAL (decl) = constructor;
3594 /* We may be writing something else just now.
3595 Postpone till end of input. */
3596 DECL_DEFER_OUTPUT (decl) = 1;
3597 pushdecl_top_level (decl);
3598 rest_of_decl_compilation (decl, 1, 0);
3600 /* Add the DECL to the head of this CLASS' list. */
3601 TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, decl, TREE_PURPOSE (*chain));
3606 /* Build a static constant CONSTRUCTOR
3607 with type TYPE and elements ELTS. */
3610 objc_build_constructor (tree type, VEC(constructor_elt,gc) *elts)
3612 tree constructor = build_constructor (type, elts);
3614 TREE_CONSTANT (constructor) = 1;
3615 TREE_STATIC (constructor) = 1;
3616 TREE_READONLY (constructor) = 1;
3619 /* Adjust for impedance mismatch. We should figure out how to build
3620 CONSTRUCTORs that consistently please both the C and C++ gods. */
3621 if (!VEC_index (constructor_elt, elts, 0)->index)
3622 TREE_TYPE (constructor) = init_list_type_node;
3628 /* Take care of defining and initializing _OBJC_SYMBOLS. */
3630 /* Predefine the following data type:
3638 void *defs[cls_def_cnt + cat_def_cnt];
3642 build_objc_symtab_template (void)
3644 tree fields, *chain = NULL;
3646 objc_symtab_template = objc_start_struct (get_identifier (UTAG_SYMTAB));
3648 /* long sel_ref_cnt; */
3649 fields = add_field_decl (long_integer_type_node, "sel_ref_cnt", &chain);
3652 add_field_decl (build_pointer_type (objc_selector_type), "refs", &chain);
3654 /* short cls_def_cnt; */
3655 add_field_decl (short_integer_type_node, "cls_def_cnt", &chain);
3657 /* short cat_def_cnt; */
3658 add_field_decl (short_integer_type_node, "cat_def_cnt", &chain);
3660 if (imp_count || cat_count || !flag_next_runtime)
3662 /* void *defs[imp_count + cat_count (+ 1)]; */
3663 /* NB: The index is one less than the size of the array. */
3664 int index = imp_count + cat_count + (flag_next_runtime ? -1: 0);
3665 tree array_type = build_sized_array_type (ptr_type_node, index + 1);
3666 add_field_decl (array_type, "defs", &chain);
3669 objc_finish_struct (objc_symtab_template, fields);
3672 /* Create the initial value for the `defs' field of _objc_symtab.
3673 This is a CONSTRUCTOR. */
3676 init_def_list (tree type)
3679 struct imp_entry *impent;
3680 VEC(constructor_elt,gc) *v = NULL;
3683 for (impent = imp_list; impent; impent = impent->next)
3685 if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
3687 expr = build_unary_op (input_location,
3688 ADDR_EXPR, impent->class_decl, 0);
3689 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
3694 for (impent = imp_list; impent; impent = impent->next)
3696 if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
3698 expr = build_unary_op (input_location,
3699 ADDR_EXPR, impent->class_decl, 0);
3700 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
3704 if (!flag_next_runtime)
3706 /* statics = { ..., _OBJC_STATIC_INSTANCES, ... } */
3707 if (static_instances_decl)
3708 expr = build_unary_op (input_location,
3709 ADDR_EXPR, static_instances_decl, 0);
3711 expr = integer_zero_node;
3713 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
3716 return objc_build_constructor (type, v);
3719 /* Construct the initial value for all of _objc_symtab. */
3722 init_objc_symtab (tree type)
3724 VEC(constructor_elt,gc) *v = NULL;
3726 /* sel_ref_cnt = { ..., 5, ... } */
3728 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
3729 build_int_cst (long_integer_type_node, 0));
3731 /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
3733 if (flag_next_runtime || ! sel_ref_chain)
3734 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, convert (
3735 build_pointer_type (objc_selector_type),
3736 integer_zero_node));
3739 tree expr = build_unary_op (input_location, ADDR_EXPR,
3740 UOBJC_SELECTOR_TABLE_decl, 1);
3742 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
3743 convert (build_pointer_type (objc_selector_type),
3747 /* cls_def_cnt = { ..., 5, ... } */
3749 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
3750 build_int_cst (short_integer_type_node, imp_count));
3752 /* cat_def_cnt = { ..., 5, ... } */
3754 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
3755 build_int_cst (short_integer_type_node, cat_count));
3757 /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
3759 if (imp_count || cat_count || !flag_next_runtime)
3762 tree field = TYPE_FIELDS (type);
3763 field = DECL_CHAIN (DECL_CHAIN (DECL_CHAIN (DECL_CHAIN (field))));
3765 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init_def_list (TREE_TYPE (field)));
3768 return objc_build_constructor (type, v);
3771 /* Generate forward declarations for metadata such as
3772 'OBJC_CLASS_...'. */
3775 build_metadata_decl (const char *name, tree type)
3779 /* struct TYPE NAME_<name>; */
3780 decl = start_var_decl (type, synth_id_with_class_suffix
3782 objc_implementation_context));
3787 /* Push forward-declarations of all the categories so that
3788 init_def_list can use them in a CONSTRUCTOR. */
3791 forward_declare_categories (void)
3793 struct imp_entry *impent;
3794 tree sav = objc_implementation_context;
3796 for (impent = imp_list; impent; impent = impent->next)
3798 if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
3800 /* Set an invisible arg to synth_id_with_class_suffix. */
3801 objc_implementation_context = impent->imp_context;
3802 /* extern struct objc_category _OBJC_CATEGORY_<name>; */
3803 impent->class_decl = build_metadata_decl ("_OBJC_CATEGORY",
3804 objc_category_template);
3807 objc_implementation_context = sav;
3810 /* Create the declaration of _OBJC_SYMBOLS, with type `struct _objc_symtab'
3811 and initialized appropriately. */
3814 generate_objc_symtab_decl (void)
3817 build_objc_symtab_template ();
3818 UOBJC_SYMBOLS_decl = start_var_decl (objc_symtab_template, "_OBJC_SYMBOLS");
3819 finish_var_decl (UOBJC_SYMBOLS_decl,
3820 init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl)));
3824 init_module_descriptor (tree type)
3827 VEC(constructor_elt,gc) *v = NULL;
3829 /* version = { 1, ... } */
3831 expr = build_int_cst (long_integer_type_node, OBJC_VERSION);
3832 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
3834 /* size = { ..., sizeof (struct _objc_module), ... } */
3836 expr = convert (long_integer_type_node,
3837 size_in_bytes (objc_module_template));
3838 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
3840 /* Don't provide any file name for security reasons. */
3841 /* name = { ..., "", ... } */
3843 expr = add_objc_string (get_identifier (""), class_names);
3844 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
3846 /* symtab = { ..., _OBJC_SYMBOLS, ... } */
3848 if (UOBJC_SYMBOLS_decl)
3849 expr = build_unary_op (input_location,
3850 ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
3852 expr = null_pointer_node;
3853 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
3855 return objc_build_constructor (type, v);
3858 /* Write out the data structures to describe Objective C classes defined.
3860 struct _objc_module { ... } _OBJC_MODULE = { ... }; */
3863 build_module_descriptor (void)
3865 tree decls, *chain = NULL;
3868 push_lang_context (lang_name_c); /* extern "C" */
3871 objc_module_template = objc_start_struct (get_identifier (UTAG_MODULE));
3874 decls = add_field_decl (long_integer_type_node, "version", &chain);
3877 add_field_decl (long_integer_type_node, "size", &chain);
3880 add_field_decl (string_type_node, "name", &chain);
3882 /* struct _objc_symtab *symtab; */
3883 add_field_decl (build_pointer_type (xref_tag (RECORD_TYPE,
3884 get_identifier (UTAG_SYMTAB))),
3887 objc_finish_struct (objc_module_template, decls);
3889 /* Create an instance of "_objc_module". */
3890 UOBJC_MODULES_decl = start_var_decl (objc_module_template, "_OBJC_MODULES");
3891 /* This is the root of the metadata for defined classes and categories, it
3892 is referenced by the runtime and, therefore, needed. */
3893 DECL_PRESERVE_P (UOBJC_MODULES_decl) = 1;
3894 finish_var_decl (UOBJC_MODULES_decl,
3895 init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl)));
3898 pop_lang_context ();
3902 /* The GNU runtime requires us to provide a static initializer function
3905 static void __objc_gnu_init (void) {
3906 __objc_exec_class (&L_OBJC_MODULES);
3910 build_module_initializer_routine (void)
3915 push_lang_context (lang_name_c); /* extern "C" */
3918 objc_push_parm (build_decl (input_location,
3919 PARM_DECL, NULL_TREE, void_type_node));
3921 objc_start_function (get_identifier (TAG_GNUINIT),
3922 build_function_type_list (void_type_node, NULL_TREE),
3923 NULL_TREE, NULL_TREE);
3925 objc_start_function (get_identifier (TAG_GNUINIT),
3926 build_function_type_list (void_type_node, NULL_TREE),
3927 NULL_TREE, objc_get_parm_info (0));
3929 body = c_begin_compound_stmt (true);
3930 add_stmt (build_function_call
3935 build_unary_op (input_location, ADDR_EXPR,
3936 UOBJC_MODULES_decl, 0))));
3937 add_stmt (c_end_compound_stmt (input_location, body, true));
3939 TREE_PUBLIC (current_function_decl) = 0;
3942 /* For Objective-C++, we will need to call __objc_gnu_init
3943 from objc_generate_static_init_call() below. */
3944 DECL_STATIC_CONSTRUCTOR (current_function_decl) = 1;
3947 GNU_INIT_decl = current_function_decl;
3951 pop_lang_context ();
3956 /* Return 1 if the __objc_gnu_init function has been synthesized and needs
3957 to be called by the module initializer routine. */
3960 objc_static_init_needed_p (void)
3962 return (GNU_INIT_decl != NULL_TREE);
3965 /* Generate a call to the __objc_gnu_init initializer function. */
3968 objc_generate_static_init_call (tree ctors ATTRIBUTE_UNUSED)
3970 add_stmt (build_stmt (input_location, EXPR_STMT,
3971 build_function_call (input_location,
3972 GNU_INIT_decl, NULL_TREE)));
3976 #endif /* OBJCPLUS */
3978 /* Return the DECL of the string IDENT in the SECTION. */
3981 get_objc_string_decl (tree ident, enum string_section section)
3988 chain = class_names_chain;
3990 case meth_var_names:
3991 chain = meth_var_names_chain;
3993 case meth_var_types:
3994 chain = meth_var_types_chain;
4000 for (; chain != 0; chain = TREE_CHAIN (chain))
4001 if (TREE_VALUE (chain) == ident)
4002 return (TREE_PURPOSE (chain));
4008 /* Output references to all statically allocated objects. Return the DECL
4009 for the array built. */
4012 generate_static_references (void)
4014 tree expr = NULL_TREE;
4015 tree class_name, klass, decl;
4016 tree cl_chain, in_chain, type
4017 = build_array_type (build_pointer_type (void_type_node), NULL_TREE);
4018 int num_inst, num_class;
4020 VEC(constructor_elt,gc) *decls = NULL;
4022 if (flag_next_runtime)
4025 for (cl_chain = objc_static_instances, num_class = 0;
4026 cl_chain; cl_chain = TREE_CHAIN (cl_chain), num_class++)
4028 VEC(constructor_elt,gc) *v = NULL;
4030 for (num_inst = 0, in_chain = TREE_PURPOSE (cl_chain);
4031 in_chain; num_inst++, in_chain = TREE_CHAIN (in_chain));
4033 sprintf (buf, "_OBJC_STATIC_INSTANCES_%d", num_class);
4034 decl = start_var_decl (type, buf);
4036 /* Output {class_name, ...}. */
4037 klass = TREE_VALUE (cl_chain);
4038 class_name = get_objc_string_decl (OBJC_TYPE_NAME (klass), class_names);
4039 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
4040 build_unary_op (input_location,
4041 ADDR_EXPR, class_name, 1));
4043 /* Output {..., instance, ...}. */
4044 for (in_chain = TREE_PURPOSE (cl_chain);
4045 in_chain; in_chain = TREE_CHAIN (in_chain))
4047 expr = build_unary_op (input_location,
4048 ADDR_EXPR, TREE_VALUE (in_chain), 1);
4049 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
4052 /* Output {..., NULL}. */
4053 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
4055 expr = objc_build_constructor (TREE_TYPE (decl), v);
4056 finish_var_decl (decl, expr);
4057 CONSTRUCTOR_APPEND_ELT (decls, NULL_TREE,
4058 build_unary_op (input_location,
4059 ADDR_EXPR, decl, 1));
4062 CONSTRUCTOR_APPEND_ELT (decls, NULL_TREE, build_int_cst (NULL_TREE, 0));
4063 expr = objc_build_constructor (type, decls);
4064 static_instances_decl = start_var_decl (type, "_OBJC_STATIC_INSTANCES");
4065 finish_var_decl (static_instances_decl, expr);
4068 static GTY(()) int selector_reference_idx;
4071 build_selector_reference_decl (void)
4076 sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", selector_reference_idx++);
4077 decl = start_var_decl (objc_selector_type, buf);
4083 build_selector_table_decl (void)
4087 if (flag_typed_selectors)
4089 build_selector_template ();
4090 temp = build_array_type (objc_selector_template, NULL_TREE);
4093 temp = build_array_type (objc_selector_type, NULL_TREE);
4095 UOBJC_SELECTOR_TABLE_decl = start_var_decl (temp, "_OBJC_SELECTOR_TABLE");
4098 /* Just a handy wrapper for add_objc_string. */
4101 build_selector (tree ident)
4103 return convert (objc_selector_type,
4104 add_objc_string (ident, meth_var_names));
4107 /* Used only by build_*_selector_translation_table (). */
4109 diagnose_missing_method (tree meth, location_t here)
4113 for (method_chain = meth_var_names_chain;
4115 method_chain = TREE_CHAIN (method_chain))
4117 if (TREE_VALUE (method_chain) == meth)
4125 warning_at (here, 0, "creating selector for nonexistent method %qE",
4130 build_next_selector_translation_table (void)
4133 for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
4136 tree decl = TREE_PURPOSE (chain);
4137 if (warn_selector && objc_implementation_context)
4141 loc = DECL_SOURCE_LOCATION (decl);
4143 loc = input_location;
4144 diagnose_missing_method (TREE_VALUE (chain), loc);
4147 expr = build_selector (TREE_VALUE (chain));
4151 /* Entries of this form are used for references to methods.
4152 The runtime re-writes these on start-up, but the compiler can't see
4153 that and optimizes it away unless we force it. */
4154 DECL_PRESERVE_P (decl) = 1;
4155 finish_var_decl (decl, expr);
4161 build_gnu_selector_translation_table (void)
4165 tree decl = NULL_TREE;*/
4166 VEC(constructor_elt,gc) *inits = NULL;
4168 for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
4172 if (warn_selector && objc_implementation_context)
4173 diagnose_missing_method (TREE_VALUE (chain), input_location);
4175 expr = build_selector (TREE_VALUE (chain));
4176 /* add one for the '\0' character
4177 offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1;*/
4180 if (flag_typed_selectors)
4182 VEC(constructor_elt,gc) *v = NULL;
4183 tree encoding = get_proto_encoding (TREE_PURPOSE (chain));
4184 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
4185 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, encoding);
4186 expr = objc_build_constructor (objc_selector_template, v);
4189 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
4191 } /* each element in the chain */
4194 /* Cause the selector table (previously forward-declared)
4195 to be actually output. */
4198 if (flag_typed_selectors)
4200 VEC(constructor_elt,gc) *v = NULL;
4201 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node);
4202 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node);
4203 expr = objc_build_constructor (objc_selector_template, v);
4206 expr = integer_zero_node;
4208 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
4209 expr = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
4211 finish_var_decl (UOBJC_SELECTOR_TABLE_decl, expr);
4216 get_proto_encoding (tree proto)
4221 if (! METHOD_ENCODING (proto))
4223 encoding = encode_method_prototype (proto);
4224 METHOD_ENCODING (proto) = encoding;
4227 encoding = METHOD_ENCODING (proto);
4229 return add_objc_string (encoding, meth_var_types);
4232 return build_int_cst (NULL_TREE, 0);
4235 /* sel_ref_chain is a list whose "value" fields will be instances of
4236 identifier_node that represent the selector. LOC is the location of
4240 build_typed_selector_reference (location_t loc, tree ident, tree prototype)
4242 tree *chain = &sel_ref_chain;
4248 if (TREE_PURPOSE (*chain) == prototype && TREE_VALUE (*chain) == ident)
4249 goto return_at_index;
4252 chain = &TREE_CHAIN (*chain);
4255 *chain = tree_cons (prototype, ident, NULL_TREE);
4258 expr = build_unary_op (loc, ADDR_EXPR,
4259 build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
4260 build_int_cst (NULL_TREE, index)),
4262 return convert (objc_selector_type, expr);
4266 build_selector_reference (location_t loc, tree ident)
4268 tree *chain = &sel_ref_chain;
4274 if (TREE_VALUE (*chain) == ident)
4275 return (flag_next_runtime
4276 ? TREE_PURPOSE (*chain)
4277 : build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
4278 build_int_cst (NULL_TREE, index)));
4281 chain = &TREE_CHAIN (*chain);
4284 expr = (flag_next_runtime ? build_selector_reference_decl (): NULL_TREE);
4286 *chain = tree_cons (expr, ident, NULL_TREE);
4288 return (flag_next_runtime
4290 : build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
4291 build_int_cst (NULL_TREE, index)));
4294 static GTY(()) int class_reference_idx;
4297 build_class_reference_decl (void)
4302 sprintf (buf, "_OBJC_CLASS_REFERENCES_%d", class_reference_idx++);
4303 decl = start_var_decl (objc_class_type, buf);
4308 /* Create a class reference, but don't create a variable to reference
4312 add_class_reference (tree ident)
4316 if ((chain = cls_ref_chain))
4321 if (ident == TREE_VALUE (chain))
4325 chain = TREE_CHAIN (chain);
4329 /* Append to the end of the list */
4330 TREE_CHAIN (tail) = tree_cons (NULL_TREE, ident, NULL_TREE);
4333 cls_ref_chain = tree_cons (NULL_TREE, ident, NULL_TREE);
4336 /* Get a class reference, creating it if necessary. Also create the
4337 reference variable. */
4339 objc_get_class_reference (tree ident)
4341 tree orig_ident = (DECL_P (ident)
4344 ? OBJC_TYPE_NAME (ident)
4346 bool local_scope = false;
4349 if (processing_template_decl)
4350 /* Must wait until template instantiation time. */
4351 return build_min_nt (CLASS_REFERENCE_EXPR, ident);
4354 if (TREE_CODE (ident) == TYPE_DECL)
4355 ident = (DECL_ORIGINAL_TYPE (ident)
4356 ? DECL_ORIGINAL_TYPE (ident)
4357 : TREE_TYPE (ident));
4361 && CP_TYPE_CONTEXT (ident) != global_namespace)
4365 if (local_scope || !(ident = objc_is_class_name (ident)))
4367 error ("%qE is not an Objective-C class name or alias",
4369 return error_mark_node;
4372 if (flag_next_runtime && !flag_zero_link)
4377 for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
4378 if (TREE_VALUE (*chain) == ident)
4380 if (! TREE_PURPOSE (*chain))
4381 TREE_PURPOSE (*chain) = build_class_reference_decl ();
4383 return TREE_PURPOSE (*chain);
4386 decl = build_class_reference_decl ();
4387 *chain = tree_cons (decl, ident, NULL_TREE);
4394 add_class_reference (ident);
4396 params = build_tree_list (NULL_TREE,
4397 my_build_string_pointer
4398 (IDENTIFIER_LENGTH (ident) + 1,
4399 IDENTIFIER_POINTER (ident)));
4401 assemble_external (objc_get_class_decl);
4402 return build_function_call (input_location, objc_get_class_decl, params);
4406 /* For each string section we have a chain which maps identifier nodes
4407 to decls for the strings. */
4409 static GTY(()) int class_names_idx;
4410 static GTY(()) int meth_var_names_idx;
4411 static GTY(()) int meth_var_types_idx;
4414 add_objc_string (tree ident, enum string_section section)
4416 tree *chain, decl, type, string_expr;
4423 chain = &class_names_chain;
4424 sprintf (buf, "_OBJC_CLASS_NAME_%d", class_names_idx++);
4426 case meth_var_names:
4427 chain = &meth_var_names_chain;
4428 sprintf (buf, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);
4430 case meth_var_types:
4431 chain = &meth_var_types_chain;
4432 sprintf (buf, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);
4440 if (TREE_VALUE (*chain) == ident)
4441 return convert (string_type_node,
4442 build_unary_op (input_location,
4443 ADDR_EXPR, TREE_PURPOSE (*chain), 1));
4445 chain = &TREE_CHAIN (*chain);
4448 type = build_sized_array_type (char_type_node, IDENTIFIER_LENGTH (ident) + 1);
4449 decl = start_var_decl (type, buf);
4450 string_expr = my_build_string (IDENTIFIER_LENGTH (ident) + 1,
4451 IDENTIFIER_POINTER (ident));
4452 TREE_CONSTANT (decl) = 1;
4453 finish_var_decl (decl, string_expr);
4455 *chain = tree_cons (decl, ident, NULL_TREE);
4457 return convert (string_type_node, build_unary_op (input_location,
4458 ADDR_EXPR, decl, 1));
4462 objc_declare_alias (tree alias_ident, tree class_ident)
4464 tree underlying_class;
4467 if (current_namespace != global_namespace) {
4468 error ("Objective-C declarations may only appear in global scope");
4470 #endif /* OBJCPLUS */
4472 if (!(underlying_class = objc_is_class_name (class_ident)))
4473 warning (0, "cannot find class %qE", class_ident);
4474 else if (objc_is_class_name (alias_ident))
4475 warning (0, "class %qE already exists", alias_ident);
4478 /* Implement @compatibility_alias as a typedef. */
4480 push_lang_context (lang_name_c); /* extern "C" */
4482 lang_hooks.decls.pushdecl (build_decl
4486 xref_tag (RECORD_TYPE, underlying_class)));
4488 pop_lang_context ();
4490 hash_class_name_enter (als_name_hash_list, alias_ident,
4496 objc_declare_class (tree ident_list)
4500 if (current_namespace != global_namespace) {
4501 error ("Objective-C declarations may only appear in global scope");
4503 #endif /* OBJCPLUS */
4505 for (list = ident_list; list; list = TREE_CHAIN (list))
4507 tree ident = TREE_VALUE (list);
4509 if (! objc_is_class_name (ident))
4511 tree record = lookup_name (ident), type = record;
4515 if (TREE_CODE (record) == TYPE_DECL)
4516 type = DECL_ORIGINAL_TYPE (record) ?
4517 DECL_ORIGINAL_TYPE (record) :
4520 if (!TYPE_HAS_OBJC_INFO (type)
4521 || !TYPE_OBJC_INTERFACE (type))
4523 error ("%qE redeclared as different kind of symbol",
4525 error ("previous declaration of %q+D",
4530 record = xref_tag (RECORD_TYPE, ident);
4531 INIT_TYPE_OBJC_INFO (record);
4532 /* In the case of a @class declaration, we store the ident
4533 in the TYPE_OBJC_INTERFACE. If later an @interface is
4534 found, we'll replace the ident with the interface. */
4535 TYPE_OBJC_INTERFACE (record) = ident;
4536 hash_class_name_enter (cls_name_hash_list, ident, NULL_TREE);
4542 objc_is_class_name (tree ident)
4546 if (ident && TREE_CODE (ident) == IDENTIFIER_NODE
4547 && identifier_global_value (ident))
4548 ident = identifier_global_value (ident);
4549 while (ident && TREE_CODE (ident) == TYPE_DECL && DECL_ORIGINAL_TYPE (ident))
4550 ident = OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident));
4552 if (ident && TREE_CODE (ident) == RECORD_TYPE)
4553 ident = OBJC_TYPE_NAME (ident);
4555 if (ident && TREE_CODE (ident) == TYPE_DECL)
4557 tree type = TREE_TYPE (ident);
4558 if (type && TREE_CODE (type) == TEMPLATE_TYPE_PARM)
4560 ident = DECL_NAME (ident);
4563 if (!ident || TREE_CODE (ident) != IDENTIFIER_NODE)
4566 if (lookup_interface (ident))
4569 target = hash_class_name_lookup (cls_name_hash_list, ident);
4573 target = hash_class_name_lookup (als_name_hash_list, ident);
4576 gcc_assert (target->list && target->list->value);
4577 return target->list->value;
4583 /* Check whether TYPE is either 'id' or 'Class'. */
4586 objc_is_id (tree type)
4588 if (type && TREE_CODE (type) == IDENTIFIER_NODE
4589 && identifier_global_value (type))
4590 type = identifier_global_value (type);
4592 if (type && TREE_CODE (type) == TYPE_DECL)
4593 type = TREE_TYPE (type);
4595 /* NB: This function may be called before the ObjC front-end has
4596 been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL. */
4597 return (objc_object_type && type
4598 && (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type))
4603 /* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
4604 class instance. This is needed by other parts of the compiler to
4605 handle ObjC types gracefully. */
4608 objc_is_object_ptr (tree type)
4612 type = TYPE_MAIN_VARIANT (type);
4613 if (!POINTER_TYPE_P (type))
4616 ret = objc_is_id (type);
4618 ret = objc_is_class_name (TREE_TYPE (type));
4624 objc_is_gcable_type (tree type, int or_strong_p)
4630 if (objc_is_id (TYPE_MAIN_VARIANT (type)))
4632 if (or_strong_p && lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type)))
4634 if (TREE_CODE (type) != POINTER_TYPE && TREE_CODE (type) != INDIRECT_REF)
4636 type = TREE_TYPE (type);
4637 if (TREE_CODE (type) != RECORD_TYPE)
4639 name = TYPE_NAME (type);
4640 return (objc_is_class_name (name) != NULL_TREE);
4644 objc_substitute_decl (tree expr, tree oldexpr, tree newexpr)
4646 if (expr == oldexpr)
4649 switch (TREE_CODE (expr))
4652 return objc_build_component_ref
4653 (objc_substitute_decl (TREE_OPERAND (expr, 0),
4656 DECL_NAME (TREE_OPERAND (expr, 1)));
4658 return build_array_ref (input_location,
4659 objc_substitute_decl (TREE_OPERAND (expr, 0),
4662 TREE_OPERAND (expr, 1));
4664 return build_indirect_ref (input_location,
4665 objc_substitute_decl (TREE_OPERAND (expr, 0),
4667 newexpr), RO_ARROW);
4674 objc_build_ivar_assignment (tree outervar, tree lhs, tree rhs)
4677 /* The LHS parameter contains the expression 'outervar->memberspec';
4678 we need to transform it into '&((typeof(outervar) *) 0)->memberspec',
4679 where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]').
4682 = objc_substitute_decl
4683 (lhs, outervar, convert (TREE_TYPE (outervar), integer_zero_node));
4685 = (flag_objc_direct_dispatch
4686 ? objc_assign_ivar_fast_decl
4687 : objc_assign_ivar_decl);
4689 offs = convert (integer_type_node, build_unary_op (input_location,
4690 ADDR_EXPR, offs, 0));
4692 func_params = tree_cons (NULL_TREE,
4693 convert (objc_object_type, rhs),
4694 tree_cons (NULL_TREE, convert (objc_object_type, outervar),
4695 tree_cons (NULL_TREE, offs,
4698 assemble_external (func);
4699 return build_function_call (input_location, func, func_params);
4703 objc_build_global_assignment (tree lhs, tree rhs)
4705 tree func_params = tree_cons (NULL_TREE,
4706 convert (objc_object_type, rhs),
4707 tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
4708 build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
4711 assemble_external (objc_assign_global_decl);
4712 return build_function_call (input_location,
4713 objc_assign_global_decl, func_params);
4717 objc_build_strong_cast_assignment (tree lhs, tree rhs)
4719 tree func_params = tree_cons (NULL_TREE,
4720 convert (objc_object_type, rhs),
4721 tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
4722 build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
4725 assemble_external (objc_assign_strong_cast_decl);
4726 return build_function_call (input_location,
4727 objc_assign_strong_cast_decl, func_params);
4731 objc_is_gcable_p (tree expr)
4733 return (TREE_CODE (expr) == COMPONENT_REF
4734 ? objc_is_gcable_p (TREE_OPERAND (expr, 1))
4735 : TREE_CODE (expr) == ARRAY_REF
4736 ? (objc_is_gcable_p (TREE_TYPE (expr))
4737 || objc_is_gcable_p (TREE_OPERAND (expr, 0)))
4738 : TREE_CODE (expr) == ARRAY_TYPE
4739 ? objc_is_gcable_p (TREE_TYPE (expr))
4741 ? objc_is_gcable_type (expr, 1)
4742 : (objc_is_gcable_p (TREE_TYPE (expr))
4744 && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr)))));
4748 objc_is_ivar_reference_p (tree expr)
4750 return (TREE_CODE (expr) == ARRAY_REF
4751 ? objc_is_ivar_reference_p (TREE_OPERAND (expr, 0))
4752 : TREE_CODE (expr) == COMPONENT_REF
4753 ? TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL
4758 objc_is_global_reference_p (tree expr)
4760 return (TREE_CODE (expr) == INDIRECT_REF || TREE_CODE (expr) == PLUS_EXPR
4761 ? objc_is_global_reference_p (TREE_OPERAND (expr, 0))
4763 ? (DECL_FILE_SCOPE_P (expr) || TREE_STATIC (expr))
4768 objc_generate_write_barrier (tree lhs, enum tree_code modifycode, tree rhs)
4770 tree result = NULL_TREE, outer;
4771 int strong_cast_p = 0, outer_gc_p = 0, indirect_p = 0;
4773 /* This function is currently only used with the next runtime with
4774 garbage collection enabled (-fobjc-gc). */
4775 gcc_assert (flag_next_runtime);
4777 /* See if we have any lhs casts, and strip them out. NB: The lvalue casts
4778 will have been transformed to the form '*(type *)&expr'. */
4779 if (TREE_CODE (lhs) == INDIRECT_REF)
4781 outer = TREE_OPERAND (lhs, 0);
4783 while (!strong_cast_p
4784 && (CONVERT_EXPR_P (outer)
4785 || TREE_CODE (outer) == NON_LVALUE_EXPR))
4787 tree lhstype = TREE_TYPE (outer);
4789 /* Descend down the cast chain, and record the first objc_gc
4791 if (POINTER_TYPE_P (lhstype))
4794 = lookup_attribute ("objc_gc",
4795 TYPE_ATTRIBUTES (TREE_TYPE (lhstype)));
4801 outer = TREE_OPERAND (outer, 0);
4805 /* If we have a __strong cast, it trumps all else. */
4808 if (modifycode != NOP_EXPR)
4809 goto invalid_pointer_arithmetic;
4811 if (warn_assign_intercept)
4812 warning (0, "strong-cast assignment has been intercepted");
4814 result = objc_build_strong_cast_assignment (lhs, rhs);
4819 /* the lhs must be of a suitable type, regardless of its underlying
4821 if (!objc_is_gcable_p (lhs))
4827 && (TREE_CODE (outer) == COMPONENT_REF
4828 || TREE_CODE (outer) == ARRAY_REF))
4829 outer = TREE_OPERAND (outer, 0);
4831 if (TREE_CODE (outer) == INDIRECT_REF)
4833 outer = TREE_OPERAND (outer, 0);
4837 outer_gc_p = objc_is_gcable_p (outer);
4839 /* Handle ivar assignments. */
4840 if (objc_is_ivar_reference_p (lhs))
4842 /* if the struct to the left of the ivar is not an Objective-C object (__strong
4843 doesn't cut it here), the best we can do here is suggest a cast. */
4844 if (!objc_is_gcable_type (TREE_TYPE (outer), 0))
4846 /* We may still be able to use the global write barrier... */
4847 if (!indirect_p && objc_is_global_reference_p (outer))
4848 goto global_reference;
4851 if (modifycode == NOP_EXPR)
4853 if (warn_assign_intercept)
4854 warning (0, "strong-cast may possibly be needed");
4860 if (modifycode != NOP_EXPR)
4861 goto invalid_pointer_arithmetic;
4863 if (warn_assign_intercept)
4864 warning (0, "instance variable assignment has been intercepted");
4866 result = objc_build_ivar_assignment (outer, lhs, rhs);
4871 /* Likewise, intercept assignment to global/static variables if their type is
4873 if (objc_is_global_reference_p (outer))
4879 if (modifycode != NOP_EXPR)
4881 invalid_pointer_arithmetic:
4883 warning (0, "pointer arithmetic for garbage-collected objects not allowed");
4888 if (warn_assign_intercept)
4889 warning (0, "global/static variable assignment has been intercepted");
4891 result = objc_build_global_assignment (lhs, rhs);
4894 /* In all other cases, fall back to the normal mechanism. */
4899 struct GTY(()) interface_tuple {
4904 static GTY ((param_is (struct interface_tuple))) htab_t interface_htab;
4907 hash_interface (const void *p)
4909 const struct interface_tuple *d = (const struct interface_tuple *) p;
4910 return IDENTIFIER_HASH_VALUE (d->id);
4914 eq_interface (const void *p1, const void *p2)
4916 const struct interface_tuple *d = (const struct interface_tuple *) p1;
4921 lookup_interface (tree ident)
4924 if (ident && TREE_CODE (ident) == TYPE_DECL)
4925 ident = DECL_NAME (ident);
4928 if (ident == NULL_TREE || TREE_CODE (ident) != IDENTIFIER_NODE)
4932 struct interface_tuple **slot;
4937 slot = (struct interface_tuple **)
4938 htab_find_slot_with_hash (interface_htab, ident,
4939 IDENTIFIER_HASH_VALUE (ident),
4942 i = (*slot)->class_name;
4948 /* Implement @defs (<classname>) within struct bodies. */
4951 objc_get_class_ivars (tree class_name)
4953 tree interface = lookup_interface (class_name);
4956 return get_class_ivars (interface, true);
4958 error ("cannot find interface declaration for %qE",
4961 return error_mark_node;
4964 /* Called when checking the variables in a struct. If we are not
4965 doing the ivars list inside an @interface context, then returns
4966 fieldlist unchanged. Else, returns the list of class ivars.
4969 objc_get_interface_ivars (tree fieldlist)
4971 if (!objc_collecting_ivars || !objc_interface_context
4972 || TREE_CODE (objc_interface_context) != CLASS_INTERFACE_TYPE
4973 || CLASS_SUPER_NAME (objc_interface_context) == NULL_TREE)
4976 return get_class_ivars (objc_interface_context, true);
4979 /* Used by: build_private_template, continue_class,
4980 and for @defs constructs. */
4983 get_class_ivars (tree interface, bool inherited)
4985 tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface));
4987 /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared
4988 by the current class (i.e., they do not include super-class ivars).
4989 However, the CLASS_IVARS list will be side-effected by a call to
4990 finish_struct(), which will fill in field offsets. */
4991 if (!CLASS_IVARS (interface))
4992 CLASS_IVARS (interface) = ivar_chain;
4997 while (CLASS_SUPER_NAME (interface))
4999 /* Prepend super-class ivars. */
5000 interface = lookup_interface (CLASS_SUPER_NAME (interface));
5001 ivar_chain = chainon (copy_list (CLASS_RAW_IVARS (interface)),
5009 /* Exception handling constructs. We begin by having the parser do most
5010 of the work and passing us blocks. What we do next depends on whether
5011 we're doing "native" exception handling or legacy Darwin setjmp exceptions.
5012 We abstract all of this in a handful of appropriately named routines. */
5014 /* Stack of open try blocks. */
5016 struct objc_try_context
5018 struct objc_try_context *outer;
5020 /* Statements (or statement lists) as processed by the parser. */
5024 /* Some file position locations. */
5025 location_t try_locus;
5026 location_t end_try_locus;
5027 location_t end_catch_locus;
5028 location_t finally_locus;
5029 location_t end_finally_locus;
5031 /* A STATEMENT_LIST of CATCH_EXPRs, appropriate for sticking into op1
5032 of a TRY_CATCH_EXPR. Even when doing Darwin setjmp. */
5035 /* The CATCH_EXPR of an open @catch clause. */
5038 /* The VAR_DECL holding the Darwin equivalent of __builtin_eh_pointer. */
5044 static struct objc_try_context *cur_try_context;
5046 static GTY(()) tree objc_eh_personality_decl;
5048 /* This hook, called via lang_eh_runtime_type, generates a runtime object
5049 that represents TYPE. For Objective-C, this is just the class name. */
5050 /* ??? Isn't there a class object or some such? Is it easy to get? */
5054 objc_eh_runtime_type (tree type)
5056 /* Use 'ErrorMarkNode' as class name when error_mark_node is found
5057 to prevent an ICE. Note that we know that the compiler will
5058 terminate with an error and this 'ErrorMarkNode' class name will
5059 never be actually used. */
5060 if (type == error_mark_node)
5061 return add_objc_string (get_identifier ("ErrorMarkNode"), class_names);
5063 return add_objc_string (OBJC_TYPE_NAME (TREE_TYPE (type)), class_names);
5067 objc_eh_personality (void)
5069 if (!flag_objc_sjlj_exceptions && !objc_eh_personality_decl)
5070 objc_eh_personality_decl = build_personality_function
5074 return objc_eh_personality_decl;
5079 objc_maybe_warn_exceptions (location_t loc)
5081 /* -fobjc-exceptions is required to enable Objective-C exceptions.
5082 For example, on Darwin, ObjC exceptions require a sufficiently
5083 recent version of the runtime, so the user must ask for them
5084 explicitly. On other platforms, at the moment -fobjc-exceptions
5085 triggers -fexceptions which again is required for exceptions to
5087 if (!flag_objc_exceptions)
5089 /* Warn only once per compilation unit. */
5090 static bool warned = false;
5094 error_at (loc, "%<-fobjc-exceptions%> is required to enable Objective-C exception syntax");
5100 /* Build __builtin_eh_pointer, or the moral equivalent. In the case
5101 of Darwin, we'll arrange for it to be initialized (and associated
5102 with a binding) later. */
5105 objc_build_exc_ptr (void)
5107 if (flag_objc_sjlj_exceptions)
5109 tree var = cur_try_context->caught_decl;
5112 var = objc_create_temporary_var (objc_object_type, NULL);
5113 cur_try_context->caught_decl = var;
5120 t = built_in_decls[BUILT_IN_EH_POINTER];
5121 t = build_call_expr (t, 1, integer_zero_node);
5122 return fold_convert (objc_object_type, t);
5126 /* Build "objc_exception_try_exit(&_stack)". */
5129 next_sjlj_build_try_exit (void)
5132 t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
5133 t = tree_cons (NULL, t, NULL);
5134 t = build_function_call (input_location,
5135 objc_exception_try_exit_decl, t);
5140 objc_exception_try_enter (&_stack);
5141 if (_setjmp(&_stack.buf))
5145 Return the COND_EXPR. Note that the THEN and ELSE fields are left
5146 empty, ready for the caller to fill them in. */
5149 next_sjlj_build_enter_and_setjmp (void)
5151 tree t, enter, sj, cond;
5153 t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
5154 t = tree_cons (NULL, t, NULL);
5155 enter = build_function_call (input_location,
5156 objc_exception_try_enter_decl, t);
5158 t = objc_build_component_ref (cur_try_context->stack_decl,
5159 get_identifier ("buf"));
5160 t = build_fold_addr_expr_loc (input_location, t);
5162 /* Convert _setjmp argument to type that is expected. */
5163 if (prototype_p (TREE_TYPE (objc_setjmp_decl)))
5164 t = convert (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl))), t);
5166 t = convert (ptr_type_node, t);
5168 t = convert (ptr_type_node, t);
5170 t = tree_cons (NULL, t, NULL);
5171 sj = build_function_call (input_location,
5172 objc_setjmp_decl, t);
5174 cond = build2 (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj);
5175 cond = c_common_truthvalue_conversion (input_location, cond);
5177 return build3 (COND_EXPR, void_type_node, cond, NULL, NULL);
5182 DECL = objc_exception_extract(&_stack); */
5185 next_sjlj_build_exc_extract (tree decl)
5189 t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
5190 t = tree_cons (NULL, t, NULL);
5191 t = build_function_call (input_location,
5192 objc_exception_extract_decl, t);
5193 t = convert (TREE_TYPE (decl), t);
5194 t = build2 (MODIFY_EXPR, void_type_node, decl, t);
5200 if (objc_exception_match(obj_get_class(TYPE), _caught)
5207 objc_exception_try_exit(&_stack);
5209 from the sequence of CATCH_EXPRs in the current try context. */
5212 next_sjlj_build_catch_list (void)
5214 tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
5216 tree *last = &catch_seq;
5217 bool saw_id = false;
5219 for (; !tsi_end_p (i); tsi_next (&i))
5221 tree stmt = tsi_stmt (i);
5222 tree type = CATCH_TYPES (stmt);
5223 tree body = CATCH_BODY (stmt);
5235 if (type == error_mark_node)
5236 cond = error_mark_node;
5239 args = tree_cons (NULL, cur_try_context->caught_decl, NULL);
5240 t = objc_get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type)));
5241 args = tree_cons (NULL, t, args);
5242 t = build_function_call (input_location,
5243 objc_exception_match_decl, args);
5244 cond = c_common_truthvalue_conversion (input_location, t);
5246 t = build3 (COND_EXPR, void_type_node, cond, body, NULL);
5247 SET_EXPR_LOCATION (t, EXPR_LOCATION (stmt));
5250 last = &COND_EXPR_ELSE (t);
5256 t = build2 (MODIFY_EXPR, void_type_node, cur_try_context->rethrow_decl,
5257 cur_try_context->caught_decl);
5258 SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
5259 append_to_statement_list (t, last);
5261 t = next_sjlj_build_try_exit ();
5262 SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
5263 append_to_statement_list (t, last);
5269 /* Build a complete @try-@catch-@finally block for legacy Darwin setjmp
5270 exception handling. We aim to build:
5273 struct _objc_exception_data _stack;
5277 objc_exception_try_enter (&_stack);
5278 if (_setjmp(&_stack.buf))
5280 id _caught = objc_exception_extract(&_stack);
5281 objc_exception_try_enter (&_stack);
5282 if (_setjmp(&_stack.buf))
5283 _rethrow = objc_exception_extract(&_stack);
5293 objc_exception_try_exit(&_stack);
5296 objc_exception_throw(_rethrow);
5300 If CATCH-LIST is empty, we can omit all of the block containing
5301 "_caught" except for the setting of _rethrow. Note the use of
5302 a real TRY_FINALLY_EXPR here, which is not involved in EH per-se,
5303 but handles goto and other exits from the block. */
5306 next_sjlj_build_try_catch_finally (void)
5308 tree rethrow_decl, stack_decl, t;
5309 tree catch_seq, try_fin, bind;
5311 /* Create the declarations involved. */
5312 t = xref_tag (RECORD_TYPE, get_identifier (UTAG_EXCDATA));
5313 stack_decl = objc_create_temporary_var (t, NULL);
5314 cur_try_context->stack_decl = stack_decl;
5316 rethrow_decl = objc_create_temporary_var (objc_object_type, NULL);
5317 cur_try_context->rethrow_decl = rethrow_decl;
5318 TREE_CHAIN (rethrow_decl) = stack_decl;
5320 /* Build the outermost variable binding level. */
5321 bind = build3 (BIND_EXPR, void_type_node, rethrow_decl, NULL, NULL);
5322 SET_EXPR_LOCATION (bind, cur_try_context->try_locus);
5323 TREE_SIDE_EFFECTS (bind) = 1;
5325 /* Initialize rethrow_decl. */
5326 t = build2 (MODIFY_EXPR, void_type_node, rethrow_decl,
5327 convert (objc_object_type, null_pointer_node));
5328 SET_EXPR_LOCATION (t, cur_try_context->try_locus);
5329 append_to_statement_list (t, &BIND_EXPR_BODY (bind));
5331 /* Build the outermost TRY_FINALLY_EXPR. */
5332 try_fin = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
5333 SET_EXPR_LOCATION (try_fin, cur_try_context->try_locus);
5334 TREE_SIDE_EFFECTS (try_fin) = 1;
5335 append_to_statement_list (try_fin, &BIND_EXPR_BODY (bind));
5337 /* Create the complete catch sequence. */
5338 if (cur_try_context->catch_list)
5340 tree caught_decl = objc_build_exc_ptr ();
5341 catch_seq = build_stmt (input_location, BIND_EXPR, caught_decl, NULL, NULL);
5342 TREE_SIDE_EFFECTS (catch_seq) = 1;
5344 t = next_sjlj_build_exc_extract (caught_decl);
5345 append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
5347 t = next_sjlj_build_enter_and_setjmp ();
5348 COND_EXPR_THEN (t) = next_sjlj_build_exc_extract (rethrow_decl);
5349 COND_EXPR_ELSE (t) = next_sjlj_build_catch_list ();
5350 append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
5353 catch_seq = next_sjlj_build_exc_extract (rethrow_decl);
5354 SET_EXPR_LOCATION (catch_seq, cur_try_context->end_try_locus);
5356 /* Build the main register-and-try if statement. */
5357 t = next_sjlj_build_enter_and_setjmp ();
5358 SET_EXPR_LOCATION (t, cur_try_context->try_locus);
5359 COND_EXPR_THEN (t) = catch_seq;
5360 COND_EXPR_ELSE (t) = cur_try_context->try_body;
5361 TREE_OPERAND (try_fin, 0) = t;
5363 /* Build the complete FINALLY statement list. */
5364 t = next_sjlj_build_try_exit ();
5365 t = build_stmt (input_location, COND_EXPR,
5366 c_common_truthvalue_conversion
5367 (input_location, rethrow_decl),
5369 SET_EXPR_LOCATION (t, cur_try_context->finally_locus);
5370 append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
5372 append_to_statement_list (cur_try_context->finally_body,
5373 &TREE_OPERAND (try_fin, 1));
5375 t = tree_cons (NULL, rethrow_decl, NULL);
5376 t = build_function_call (input_location,
5377 objc_exception_throw_decl, t);
5378 t = build_stmt (input_location, COND_EXPR,
5379 c_common_truthvalue_conversion (input_location,
5382 SET_EXPR_LOCATION (t, cur_try_context->end_finally_locus);
5383 append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
5388 /* Called just after parsing the @try and its associated BODY. We now
5389 must prepare for the tricky bits -- handling the catches and finally. */
5392 objc_begin_try_stmt (location_t try_locus, tree body)
5394 struct objc_try_context *c = XCNEW (struct objc_try_context);
5395 c->outer = cur_try_context;
5397 c->try_locus = try_locus;
5398 c->end_try_locus = input_location;
5399 cur_try_context = c;
5401 /* Collect the list of local variables. We'll mark them as volatile
5402 at the end of compilation of this function to prevent them being
5403 clobbered by setjmp/longjmp. */
5404 if (flag_objc_sjlj_exceptions)
5405 objc_mark_locals_volatile (NULL);
5408 /* Called just after parsing "@catch (parm)". Open a binding level,
5409 enter DECL into the binding level, and initialize it. Leave the
5410 binding level open while the body of the compound statement is
5411 parsed. If DECL is NULL_TREE, then we are compiling "@catch(...)"
5412 which we compile as "@catch(id tmp_variable)". */
5415 objc_begin_catch_clause (tree decl)
5417 tree compound, type, t;
5419 /* Begin a new scope that the entire catch clause will live in. */
5420 compound = c_begin_compound_stmt (true);
5422 /* Create the appropriate declaration for the argument. */
5423 if (decl == error_mark_node)
5424 type = error_mark_node;
5427 if (decl == NULL_TREE)
5429 /* If @catch(...) was specified, create a temporary variable of
5430 type 'id' and use it. */
5431 decl = objc_create_temporary_var (objc_object_type, "__objc_generic_catch_var");
5432 DECL_SOURCE_LOCATION (decl) = input_location;
5436 /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL. */
5437 decl = build_decl (input_location,
5438 VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
5440 lang_hooks.decls.pushdecl (decl);
5442 /* Mark the declaration as used so you never any warnings whether
5443 you use the exception argument or not. TODO: Implement a
5444 -Wunused-exception-parameter flag, which would cause warnings
5445 if exception parameter is not used. */
5446 TREE_USED (decl) = 1;
5447 DECL_READ_P (decl) = 1;
5449 type = TREE_TYPE (decl);
5452 /* Verify that the type of the catch is valid. It must be a pointer
5453 to an Objective-C class, or "id" (which is catch-all). */
5454 if (type == error_mark_node)
5456 ;/* Just keep going. */
5458 else if (!objc_type_valid_for_messaging (type, false))
5460 error ("@catch parameter is not a known Objective-C class type");
5461 type = error_mark_node;
5463 else if (TYPE_HAS_OBJC_INFO (TREE_TYPE (type))
5464 && TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (type)))
5466 error ("@catch parameter can not be protocol-qualified");
5467 type = error_mark_node;
5469 else if (objc_is_object_id (TREE_TYPE (type)))
5473 /* If 'type' was built using typedefs, we need to get rid of
5474 them and get a simple pointer to the class. */
5475 bool is_typedef = false;
5476 tree x = TYPE_MAIN_VARIANT (type);
5478 /* Skip from the pointer to the pointee. */
5479 if (TREE_CODE (x) == POINTER_TYPE)
5482 /* Traverse typedef aliases */
5483 while (TREE_CODE (x) == RECORD_TYPE && OBJC_TYPE_NAME (x)
5484 && TREE_CODE (OBJC_TYPE_NAME (x)) == TYPE_DECL
5485 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x)))
5488 x = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x));
5491 /* If it was a typedef, build a pointer to the final, original
5494 type = build_pointer_type (x);
5496 if (cur_try_context->catch_list)
5498 /* Examine previous @catch clauses and see if we've already
5499 caught the type in question. */
5500 tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
5501 for (; !tsi_end_p (i); tsi_next (&i))
5503 tree stmt = tsi_stmt (i);
5504 t = CATCH_TYPES (stmt);
5505 if (t == error_mark_node)
5507 if (!t || DERIVED_FROM_P (TREE_TYPE (t), TREE_TYPE (type)))
5509 warning (0, "exception of type %<%T%> will be caught",
5511 warning_at (EXPR_LOCATION (stmt), 0, " by earlier handler for %<%T%>",
5512 TREE_TYPE (t ? t : objc_object_type));
5519 /* Record the data for the catch in the try context so that we can
5520 finalize it later. */
5521 t = build_stmt (input_location, CATCH_EXPR, type, compound);
5522 cur_try_context->current_catch = t;
5524 /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */
5525 t = objc_build_exc_ptr ();
5526 t = convert (TREE_TYPE (decl), t);
5527 t = build2 (MODIFY_EXPR, void_type_node, decl, t);
5531 /* Called just after parsing the closing brace of a @catch clause. Close
5532 the open binding level, and record a CATCH_EXPR for it. */
5535 objc_finish_catch_clause (void)
5537 tree c = cur_try_context->current_catch;
5538 cur_try_context->current_catch = NULL;
5539 cur_try_context->end_catch_locus = input_location;
5541 CATCH_BODY (c) = c_end_compound_stmt (input_location, CATCH_BODY (c), 1);
5542 append_to_statement_list (c, &cur_try_context->catch_list);
5545 /* Called after parsing a @finally clause and its associated BODY.
5546 Record the body for later placement. */
5549 objc_build_finally_clause (location_t finally_locus, tree body)
5551 cur_try_context->finally_body = body;
5552 cur_try_context->finally_locus = finally_locus;
5553 cur_try_context->end_finally_locus = input_location;
5556 /* Called to finalize a @try construct. */
5559 objc_finish_try_stmt (void)
5561 struct objc_try_context *c = cur_try_context;
5564 if (c->catch_list == NULL && c->finally_body == NULL)
5565 error ("%<@try%> without %<@catch%> or %<@finally%>");
5567 /* If we're doing Darwin setjmp exceptions, build the big nasty. */
5568 if (flag_objc_sjlj_exceptions)
5570 bool save = in_late_binary_op;
5571 in_late_binary_op = true;
5572 if (!cur_try_context->finally_body)
5574 cur_try_context->finally_locus = input_location;
5575 cur_try_context->end_finally_locus = input_location;
5577 stmt = next_sjlj_build_try_catch_finally ();
5578 in_late_binary_op = save;
5582 /* Otherwise, nest the CATCH inside a FINALLY. */
5586 stmt = build_stmt (input_location, TRY_CATCH_EXPR, stmt, c->catch_list);
5587 SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
5589 if (c->finally_body)
5591 stmt = build_stmt (input_location, TRY_FINALLY_EXPR, stmt, c->finally_body);
5592 SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
5597 cur_try_context = c->outer;
5603 objc_build_throw_stmt (location_t loc, tree throw_expr)
5607 objc_maybe_warn_exceptions (loc);
5609 if (throw_expr == NULL)
5611 /* If we're not inside a @catch block, there is no "current
5612 exception" to be rethrown. */
5613 if (cur_try_context == NULL
5614 || cur_try_context->current_catch == NULL)
5616 error_at (loc, "%<@throw%> (rethrow) used outside of a @catch block");
5617 return error_mark_node;
5620 /* Otherwise the object is still sitting in the EXC_PTR_EXPR
5621 value that we get from the runtime. */
5622 throw_expr = objc_build_exc_ptr ();
5624 else if (throw_expr != error_mark_node)
5626 if (!objc_type_valid_for_messaging (TREE_TYPE (throw_expr), true))
5628 error_at (loc, "%<@throw%> argument is not an object");
5629 return error_mark_node;
5633 /* A throw is just a call to the runtime throw function with the
5634 object as a parameter. */
5635 args = tree_cons (NULL, throw_expr, NULL);
5636 return add_stmt (build_function_call (loc,
5637 objc_exception_throw_decl, args));
5641 objc_build_synchronized (location_t start_locus, tree object_expr, tree body)
5643 /* object_expr should never be NULL; but in case it is, convert it to
5645 if (object_expr == NULL)
5646 object_expr = error_mark_node;
5648 /* Validate object_expr. If not valid, set it to error_mark_node. */
5649 if (object_expr != error_mark_node)
5651 if (!objc_type_valid_for_messaging (TREE_TYPE (object_expr), true))
5653 error_at (start_locus, "%<@synchronized%> argument is not an object");
5654 object_expr = error_mark_node;
5658 if (object_expr == error_mark_node)
5660 /* If we found an error, we simply ignore the '@synchronized'.
5661 Compile the body so we can keep going with minimal
5663 return add_stmt (body);
5670 /* objc_sync_enter (object_expr); */
5671 object_expr = save_expr (object_expr);
5672 args = tree_cons (NULL, object_expr, NULL);
5673 call = build_function_call (input_location,
5674 objc_sync_enter_decl, args);
5675 SET_EXPR_LOCATION (call, start_locus);
5678 /* Build "objc_sync_exit (object_expr);" but do not add it yet;
5679 it goes inside the @finalize() clause. */
5680 args = tree_cons (NULL, object_expr, NULL);
5681 call = build_function_call (input_location,
5682 objc_sync_exit_decl, args);
5683 SET_EXPR_LOCATION (call, input_location);
5685 /* @try { body; } */
5686 objc_begin_try_stmt (start_locus, body);
5688 /* @finally { objc_sync_exit (object_expr); } */
5689 objc_build_finally_clause (input_location, call);
5691 /* End of try statement. */
5692 return objc_finish_try_stmt ();
5697 /* Predefine the following data type:
5699 struct _objc_exception_data
5701 int buf[OBJC_JBLEN];
5705 /* The following yuckiness should prevent users from having to #include
5706 <setjmp.h> in their code... */
5708 /* Define to a harmless positive value so the below code doesn't die. */
5710 #define OBJC_JBLEN 18
5714 build_next_objc_exception_stuff (void)
5716 tree decls, temp_type, *chain = NULL;
5718 objc_exception_data_template
5719 = objc_start_struct (get_identifier (UTAG_EXCDATA));
5721 /* int buf[OBJC_JBLEN]; */
5723 temp_type = build_sized_array_type (integer_type_node, OBJC_JBLEN);
5724 decls = add_field_decl (temp_type, "buf", &chain);
5726 /* void *pointers[4]; */
5728 temp_type = build_sized_array_type (ptr_type_node, 4);
5729 add_field_decl (temp_type, "pointers", &chain);
5731 objc_finish_struct (objc_exception_data_template, decls);
5733 /* int _setjmp(...); */
5734 /* If the user includes <setjmp.h>, this shall be superseded by
5735 'int _setjmp(jmp_buf);' */
5736 temp_type = build_varargs_function_type_list (integer_type_node, NULL_TREE);
5738 = add_builtin_function (TAG_SETJMP, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
5740 /* id objc_exception_extract(struct _objc_exception_data *); */
5742 = build_function_type_list (objc_object_type,
5743 build_pointer_type (objc_exception_data_template),
5745 objc_exception_extract_decl
5746 = add_builtin_function (TAG_EXCEPTIONEXTRACT, temp_type, 0, NOT_BUILT_IN, NULL,
5748 /* void objc_exception_try_enter(struct _objc_exception_data *); */
5749 /* void objc_exception_try_exit(struct _objc_exception_data *); */
5751 = build_function_type_list (void_type_node,
5752 build_pointer_type (objc_exception_data_template),
5754 objc_exception_try_enter_decl
5755 = add_builtin_function (TAG_EXCEPTIONTRYENTER, temp_type, 0, NOT_BUILT_IN, NULL,
5757 objc_exception_try_exit_decl
5758 = add_builtin_function (TAG_EXCEPTIONTRYEXIT, temp_type, 0, NOT_BUILT_IN, NULL,
5761 /* int objc_exception_match(id, id); */
5763 = build_function_type_list (integer_type_node,
5764 objc_object_type, objc_object_type, NULL_TREE);
5765 objc_exception_match_decl
5766 = add_builtin_function (TAG_EXCEPTIONMATCH, temp_type, 0, NOT_BUILT_IN, NULL,
5769 /* id objc_assign_ivar (id, id, unsigned int); */
5770 /* id objc_assign_ivar_Fast (id, id, unsigned int)
5771 __attribute__ ((hard_coded_address (OFFS_ASSIGNIVAR_FAST))); */
5773 = build_function_type_list (objc_object_type,
5778 objc_assign_ivar_decl
5779 = add_builtin_function (TAG_ASSIGNIVAR, temp_type, 0, NOT_BUILT_IN,
5781 #ifdef OFFS_ASSIGNIVAR_FAST
5782 objc_assign_ivar_fast_decl
5783 = add_builtin_function (TAG_ASSIGNIVAR_FAST, temp_type, 0,
5784 NOT_BUILT_IN, NULL, NULL_TREE);
5785 DECL_ATTRIBUTES (objc_assign_ivar_fast_decl)
5786 = tree_cons (get_identifier ("hard_coded_address"),
5787 build_int_cst (NULL_TREE, OFFS_ASSIGNIVAR_FAST),
5790 /* Default to slower ivar method. */
5791 objc_assign_ivar_fast_decl = objc_assign_ivar_decl;
5794 /* id objc_assign_global (id, id *); */
5795 /* id objc_assign_strongCast (id, id *); */
5796 temp_type = build_function_type_list (objc_object_type,
5798 build_pointer_type (objc_object_type),
5800 objc_assign_global_decl
5801 = add_builtin_function (TAG_ASSIGNGLOBAL, temp_type, 0, NOT_BUILT_IN, NULL,
5803 objc_assign_strong_cast_decl
5804 = add_builtin_function (TAG_ASSIGNSTRONGCAST, temp_type, 0, NOT_BUILT_IN, NULL,
5809 build_objc_exception_stuff (void)
5811 tree noreturn_list, nothrow_list, temp_type;
5813 noreturn_list = tree_cons (get_identifier ("noreturn"), NULL, NULL);
5814 nothrow_list = tree_cons (get_identifier ("nothrow"), NULL, NULL);
5816 /* void objc_exception_throw(id) __attribute__((noreturn)); */
5817 /* void objc_sync_enter(id); */
5818 /* void objc_sync_exit(id); */
5819 temp_type = build_function_type_list (void_type_node,
5822 objc_exception_throw_decl
5823 = add_builtin_function (TAG_EXCEPTIONTHROW, temp_type, 0, NOT_BUILT_IN, NULL,
5825 objc_sync_enter_decl
5826 = add_builtin_function (TAG_SYNCENTER, temp_type, 0, NOT_BUILT_IN,
5827 NULL, nothrow_list);
5829 = add_builtin_function (TAG_SYNCEXIT, temp_type, 0, NOT_BUILT_IN,
5830 NULL, nothrow_list);
5833 /* Construct a C struct corresponding to ObjC class CLASS, with the same
5836 struct <classname> {
5837 struct _objc_class *isa;
5842 build_private_template (tree klass)
5844 if (!CLASS_STATIC_TEMPLATE (klass))
5846 tree record = objc_build_struct (klass,
5847 get_class_ivars (klass, false),
5848 CLASS_SUPER_NAME (klass));
5850 /* Set the TREE_USED bit for this struct, so that stab generator
5851 can emit stabs for this struct type. */
5852 if (flag_debug_only_used_symbols && TYPE_STUB_DECL (record))
5853 TREE_USED (TYPE_STUB_DECL (record)) = 1;
5855 /* Copy the attributes from the class to the type. */
5856 if (TREE_DEPRECATED (klass))
5857 TREE_DEPRECATED (record) = 1;
5861 /* Begin code generation for protocols... */
5863 /* struct _objc_protocol {
5864 struct _objc_class *isa;
5865 char *protocol_name;
5866 struct _objc_protocol **protocol_list;
5867 struct _objc__method_prototype_list *instance_methods;
5868 struct _objc__method_prototype_list *class_methods;
5872 build_protocol_template (void)
5874 tree ptype, decls, *chain = NULL;
5876 objc_protocol_template = objc_start_struct (get_identifier (UTAG_PROTOCOL));
5878 /* struct _objc_class *isa; */
5879 ptype = build_pointer_type (xref_tag (RECORD_TYPE,
5880 get_identifier (UTAG_CLASS)));
5881 decls = add_field_decl (ptype, "isa", &chain);
5883 /* char *protocol_name; */
5884 add_field_decl (string_type_node, "protocol_name", &chain);
5886 /* struct _objc_protocol **protocol_list; */
5887 ptype = build_pointer_type (build_pointer_type (objc_protocol_template));
5888 add_field_decl (ptype, "protocol_list", &chain);
5890 /* struct _objc__method_prototype_list *instance_methods; */
5891 add_field_decl (objc_method_proto_list_ptr, "instance_methods", &chain);
5893 /* struct _objc__method_prototype_list *class_methods; */
5894 add_field_decl (objc_method_proto_list_ptr, "class_methods", &chain);
5896 objc_finish_struct (objc_protocol_template, decls);
5900 build_descriptor_table_initializer (tree type, tree entries)
5902 VEC(constructor_elt,gc) *inits = NULL;
5906 VEC(constructor_elt,gc) *elts = NULL;
5908 CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE,
5909 build_selector (METHOD_SEL_NAME (entries)));
5910 CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE,
5911 add_objc_string (METHOD_ENCODING (entries),
5914 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
5915 objc_build_constructor (type, elts));
5917 entries = DECL_CHAIN (entries);
5921 return objc_build_constructor (build_array_type (type, 0), inits);
5924 /* struct objc_method_prototype_list {
5926 struct objc_method_prototype {
5933 build_method_prototype_list_template (tree list_type, int size)
5935 tree objc_ivar_list_record;
5936 tree array_type, decls, *chain = NULL;
5938 /* Generate an unnamed struct definition. */
5940 objc_ivar_list_record = objc_start_struct (NULL_TREE);
5942 /* int method_count; */
5943 decls = add_field_decl (integer_type_node, "method_count", &chain);
5945 /* struct objc_method method_list[]; */
5946 array_type = build_sized_array_type (list_type, size);
5947 add_field_decl (array_type, "method_list", &chain);
5949 objc_finish_struct (objc_ivar_list_record, decls);
5951 return objc_ivar_list_record;
5955 build_method_prototype_template (void)
5958 tree decls, *chain = NULL;
5960 proto_record = objc_start_struct (get_identifier (UTAG_METHOD_PROTOTYPE));
5963 decls = add_field_decl (objc_selector_type, "_cmd", &chain);
5965 /* char *method_types; */
5966 add_field_decl (string_type_node, "method_types", &chain);
5968 objc_finish_struct (proto_record, decls);
5970 return proto_record;
5974 objc_method_parm_type (tree type)
5976 type = TREE_VALUE (TREE_TYPE (type));
5977 if (TREE_CODE (type) == TYPE_DECL)
5978 type = TREE_TYPE (type);
5983 objc_encoded_type_size (tree type)
5985 int sz = int_size_in_bytes (type);
5987 /* Make all integer and enum types at least as large
5989 if (sz > 0 && INTEGRAL_TYPE_P (type))
5990 sz = MAX (sz, int_size_in_bytes (integer_type_node));
5991 /* Treat arrays as pointers, since that's how they're
5993 else if (TREE_CODE (type) == ARRAY_TYPE)
5994 sz = int_size_in_bytes (ptr_type_node);
5998 /* Encode a method prototype.
6000 The format is described in gcc/doc/objc.texi, section 'Method
6004 encode_method_prototype (tree method_decl)
6011 /* ONEWAY and BYCOPY, for remote object are the only method qualifiers. */
6012 encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_decl)));
6014 /* Encode return type. */
6015 encode_type (objc_method_parm_type (method_decl),
6016 obstack_object_size (&util_obstack),
6017 OBJC_ENCODE_INLINE_DEFS);
6020 /* The first two arguments (self and _cmd) are pointers; account for
6022 i = int_size_in_bytes (ptr_type_node);
6023 parm_offset = 2 * i;
6024 for (parms = METHOD_SEL_ARGS (method_decl); parms;
6025 parms = DECL_CHAIN (parms))
6027 tree type = objc_method_parm_type (parms);
6028 int sz = objc_encoded_type_size (type);
6030 /* If a type size is not known, bail out. */
6033 error_at (DECL_SOURCE_LOCATION (method_decl),
6034 "type %qT does not have a known size",
6036 /* Pretend that the encoding succeeded; the compilation will
6037 fail nevertheless. */
6038 goto finish_encoding;
6043 sprintf (buf, "%d@0:%d", parm_offset, i);
6044 obstack_grow (&util_obstack, buf, strlen (buf));
6046 /* Argument types. */
6047 parm_offset = 2 * i;
6048 for (parms = METHOD_SEL_ARGS (method_decl); parms;
6049 parms = DECL_CHAIN (parms))
6051 tree type = objc_method_parm_type (parms);
6053 /* Process argument qualifiers for user supplied arguments. */
6054 encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (parms)));
6057 encode_type (type, obstack_object_size (&util_obstack),
6058 OBJC_ENCODE_INLINE_DEFS);
6060 /* Compute offset. */
6061 sprintf (buf, "%d", parm_offset);
6062 parm_offset += objc_encoded_type_size (type);
6064 obstack_grow (&util_obstack, buf, strlen (buf));
6068 obstack_1grow (&util_obstack, '\0');
6069 result = get_identifier (XOBFINISH (&util_obstack, char *));
6070 obstack_free (&util_obstack, util_firstobj);
6075 generate_descriptor_table (tree type, const char *name, int size, tree list,
6079 VEC(constructor_elt,gc) *v = NULL;
6081 decl = start_var_decl (type, synth_id_with_class_suffix (name, proto));
6083 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size));
6084 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, list);
6086 finish_var_decl (decl, objc_build_constructor (type, v));
6092 generate_method_descriptors (tree protocol)
6094 tree initlist, chain, method_list_template;
6097 if (!objc_method_prototype_template)
6098 objc_method_prototype_template = build_method_prototype_template ();
6100 chain = PROTOCOL_CLS_METHODS (protocol);
6103 size = list_length (chain);
6105 method_list_template
6106 = build_method_prototype_list_template (objc_method_prototype_template,
6110 = build_descriptor_table_initializer (objc_method_prototype_template,
6113 UOBJC_CLASS_METHODS_decl
6114 = generate_descriptor_table (method_list_template,
6115 "_OBJC_PROTOCOL_CLASS_METHODS",
6116 size, initlist, protocol);
6119 UOBJC_CLASS_METHODS_decl = 0;
6121 chain = PROTOCOL_NST_METHODS (protocol);
6124 size = list_length (chain);
6126 method_list_template
6127 = build_method_prototype_list_template (objc_method_prototype_template,
6130 = build_descriptor_table_initializer (objc_method_prototype_template,
6133 UOBJC_INSTANCE_METHODS_decl
6134 = generate_descriptor_table (method_list_template,
6135 "_OBJC_PROTOCOL_INSTANCE_METHODS",
6136 size, initlist, protocol);
6139 UOBJC_INSTANCE_METHODS_decl = 0;
6143 generate_protocol_references (tree plist)
6147 /* Forward declare protocols referenced. */
6148 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
6150 tree proto = TREE_VALUE (lproto);
6152 if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE
6153 && PROTOCOL_NAME (proto))
6155 if (! PROTOCOL_FORWARD_DECL (proto))
6156 build_protocol_reference (proto);
6158 if (PROTOCOL_LIST (proto))
6159 generate_protocol_references (PROTOCOL_LIST (proto));
6164 /* Generate either '- .cxx_construct' or '- .cxx_destruct' for the
6168 objc_generate_cxx_ctor_or_dtor (bool dtor)
6170 tree fn, body, compound_stmt, ivar;
6172 /* - (id) .cxx_construct { ... return self; } */
6173 /* - (void) .cxx_construct { ... } */
6175 objc_start_method_definition
6176 (false /* is_class_method */,
6177 objc_build_method_signature (false /* is_class_method */,
6178 build_tree_list (NULL_TREE,
6181 : objc_object_type),
6182 get_identifier (dtor
6184 : TAG_CXX_CONSTRUCT),
6185 make_node (TREE_LIST),
6187 body = begin_function_body ();
6188 compound_stmt = begin_compound_stmt (0);
6190 ivar = CLASS_IVARS (implementation_template);
6191 /* Destroy ivars in reverse order. */
6193 ivar = nreverse (copy_list (ivar));
6195 for (; ivar; ivar = TREE_CHAIN (ivar))
6197 if (TREE_CODE (ivar) == FIELD_DECL)
6199 tree type = TREE_TYPE (ivar);
6201 /* Call the ivar's default constructor or destructor. Do not
6202 call the destructor unless a corresponding constructor call
6203 has also been made (or is not needed). */
6204 if (MAYBE_CLASS_TYPE_P (type)
6206 ? (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6207 && (!TYPE_NEEDS_CONSTRUCTING (type)
6208 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
6209 : (TYPE_NEEDS_CONSTRUCTING (type)
6210 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))))
6212 (build_special_member_call
6213 (build_ivar_reference (DECL_NAME (ivar)),
6214 dtor ? complete_dtor_identifier : complete_ctor_identifier,
6215 NULL, type, LOOKUP_NORMAL, tf_warning_or_error));
6219 /* The constructor returns 'self'. */
6221 finish_return_stmt (self_decl);
6223 finish_compound_stmt (compound_stmt);
6224 finish_function_body (body);
6225 fn = current_function_decl;
6227 objc_finish_method_definition (fn);
6230 /* The following routine will examine the current @interface for any
6231 non-POD C++ ivars requiring non-trivial construction and/or
6232 destruction, and then synthesize special '- .cxx_construct' and/or
6233 '- .cxx_destruct' methods which will run the appropriate
6234 construction or destruction code. Note that ivars inherited from
6235 super-classes are _not_ considered. */
6237 objc_generate_cxx_cdtors (void)
6239 bool need_ctor = false, need_dtor = false;
6242 /* Error case, due to possibly an extra @end. */
6243 if (!objc_implementation_context)
6246 /* We do not want to do this for categories, since they do not have
6249 if (TREE_CODE (objc_implementation_context) != CLASS_IMPLEMENTATION_TYPE)
6252 /* First, determine if we even need a constructor and/or destructor. */
6254 for (ivar = CLASS_IVARS (implementation_template); ivar;
6255 ivar = TREE_CHAIN (ivar))
6257 if (TREE_CODE (ivar) == FIELD_DECL)
6259 tree type = TREE_TYPE (ivar);
6261 if (MAYBE_CLASS_TYPE_P (type))
6263 if (TYPE_NEEDS_CONSTRUCTING (type)
6264 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
6265 /* NB: If a default constructor is not available, we will not
6266 be able to initialize this ivar; the add_instance_variable()
6267 routine will already have warned about this. */
6270 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
6271 && (!TYPE_NEEDS_CONSTRUCTING (type)
6272 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
6273 /* NB: If a default constructor is not available, we will not
6274 call the destructor either, for symmetry. */
6280 /* Generate '- .cxx_construct' if needed. */
6283 objc_generate_cxx_ctor_or_dtor (false);
6285 /* Generate '- .cxx_destruct' if needed. */
6288 objc_generate_cxx_ctor_or_dtor (true);
6290 /* The 'imp_list' variable points at an imp_entry record for the current
6291 @implementation. Record the existence of '- .cxx_construct' and/or
6292 '- .cxx_destruct' methods therein; it will be included in the
6293 metadata for the class. */
6294 if (flag_next_runtime)
6295 imp_list->has_cxx_cdtors = (need_ctor || need_dtor);
6299 /* For each protocol which was referenced either from a @protocol()
6300 expression, or because a class/category implements it (then a
6301 pointer to the protocol is stored in the struct describing the
6302 class/category), we create a statically allocated instance of the
6303 Protocol class. The code is written in such a way as to generate
6304 as few Protocol objects as possible; we generate a unique Protocol
6305 instance for each protocol, and we don't generate a Protocol
6306 instance if the protocol is never referenced (either from a
6307 @protocol() or from a class/category implementation). These
6308 statically allocated objects can be referred to via the static
6309 (that is, private to this module) symbols _OBJC_PROTOCOL_n.
6311 The statically allocated Protocol objects that we generate here
6312 need to be fixed up at runtime in order to be used: the 'isa'
6313 pointer of the objects need to be set up to point to the 'Protocol'
6314 class, as known at runtime.
6316 The NeXT runtime fixes up all protocols at program startup time,
6317 before main() is entered. It uses a low-level trick to look up all
6318 those symbols, then loops on them and fixes them up.
6320 The GNU runtime as well fixes up all protocols before user code
6321 from the module is executed; it requires pointers to those symbols
6322 to be put in the objc_symtab (which is then passed as argument to
6323 the function __objc_exec_class() which the compiler sets up to be
6324 executed automatically when the module is loaded); setup of those
6325 Protocol objects happen in two ways in the GNU runtime: all
6326 Protocol objects referred to by a class or category implementation
6327 are fixed up when the class/category is loaded; all Protocol
6328 objects referred to by a @protocol() expression are added by the
6329 compiler to the list of statically allocated instances to fixup
6330 (the same list holding the statically allocated constant string
6331 objects). Because, as explained above, the compiler generates as
6332 few Protocol objects as possible, some Protocol object might end up
6333 being referenced multiple times when compiled with the GNU runtime,
6334 and end up being fixed up multiple times at runtime initialization.
6335 But that doesn't hurt, it's just a little inefficient. */
6338 generate_protocols (void)
6342 tree initlist, protocol_name_expr, refs_decl, refs_expr;
6344 /* If a protocol was directly referenced, pull in indirect references. */
6345 for (p = protocol_chain; p; p = TREE_CHAIN (p))
6346 if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p))
6347 generate_protocol_references (PROTOCOL_LIST (p));
6349 for (p = protocol_chain; p; p = TREE_CHAIN (p))
6351 tree nst_methods = PROTOCOL_NST_METHODS (p);
6352 tree cls_methods = PROTOCOL_CLS_METHODS (p);
6354 /* If protocol wasn't referenced, don't generate any code. */
6355 decl = PROTOCOL_FORWARD_DECL (p);
6360 /* Make sure we link in the Protocol class. */
6361 add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
6365 if (! METHOD_ENCODING (nst_methods))
6367 encoding = encode_method_prototype (nst_methods);
6368 METHOD_ENCODING (nst_methods) = encoding;
6370 nst_methods = DECL_CHAIN (nst_methods);
6375 if (! METHOD_ENCODING (cls_methods))
6377 encoding = encode_method_prototype (cls_methods);
6378 METHOD_ENCODING (cls_methods) = encoding;
6381 cls_methods = DECL_CHAIN (cls_methods);
6383 generate_method_descriptors (p);
6385 if (PROTOCOL_LIST (p))
6386 refs_decl = generate_protocol_list (p);
6390 /* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
6391 protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
6394 refs_expr = convert (build_pointer_type (build_pointer_type
6395 (objc_protocol_template)),
6396 build_unary_op (input_location,
6397 ADDR_EXPR, refs_decl, 0));
6399 refs_expr = build_int_cst (NULL_TREE, 0);
6401 /* UOBJC_INSTANCE_METHODS_decl/UOBJC_CLASS_METHODS_decl are set
6402 by generate_method_descriptors, which is called above. */
6403 initlist = build_protocol_initializer (TREE_TYPE (decl),
6404 protocol_name_expr, refs_expr,
6405 UOBJC_INSTANCE_METHODS_decl,
6406 UOBJC_CLASS_METHODS_decl);
6407 finish_var_decl (decl, initlist);
6412 build_protocol_initializer (tree type, tree protocol_name,
6413 tree protocol_list, tree instance_methods,
6417 tree cast_type = build_pointer_type
6418 (xref_tag (RECORD_TYPE,
6419 get_identifier (UTAG_CLASS)));
6420 VEC(constructor_elt,gc) *inits = NULL;
6422 /* Filling the "isa" in with one allows the runtime system to
6423 detect that the version change...should remove before final release. */
6425 expr = build_int_cst (cast_type, PROTOCOL_VERSION);
6426 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
6427 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_name);
6428 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_list);
6430 if (!instance_methods)
6431 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, 0));
6434 expr = convert (objc_method_proto_list_ptr,
6435 build_unary_op (input_location,
6436 ADDR_EXPR, instance_methods, 0));
6437 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
6441 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, 0));
6444 expr = convert (objc_method_proto_list_ptr,
6445 build_unary_op (input_location,
6446 ADDR_EXPR, class_methods, 0));
6447 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
6450 return objc_build_constructor (type, inits);
6453 /* struct _objc_category {
6454 char *category_name;
6456 struct _objc_method_list *instance_methods;
6457 struct _objc_method_list *class_methods;
6458 struct _objc_protocol_list *protocols;
6462 build_category_template (void)
6464 tree ptype, decls, *chain = NULL;
6466 objc_category_template = objc_start_struct (get_identifier (UTAG_CATEGORY));
6468 /* char *category_name; */
6469 decls = add_field_decl (string_type_node, "category_name", &chain);
6471 /* char *class_name; */
6472 add_field_decl (string_type_node, "class_name", &chain);
6474 /* struct _objc_method_list *instance_methods; */
6475 add_field_decl (objc_method_list_ptr, "instance_methods", &chain);
6477 /* struct _objc_method_list *class_methods; */
6478 add_field_decl (objc_method_list_ptr, "class_methods", &chain);
6480 /* struct _objc_protocol **protocol_list; */
6481 ptype = build_pointer_type (build_pointer_type (objc_protocol_template));
6482 add_field_decl (ptype, "protocol_list", &chain);
6484 objc_finish_struct (objc_category_template, decls);
6487 /* struct _objc_selector {
6493 build_selector_template (void)
6495 tree decls, *chain = NULL;
6497 objc_selector_template = objc_start_struct (get_identifier (UTAG_SELECTOR));
6500 decls = add_field_decl (objc_selector_type, "sel_id", &chain);
6502 /* char *sel_type; */
6503 add_field_decl (string_type_node, "sel_type", &chain);
6505 objc_finish_struct (objc_selector_template, decls);
6508 /* struct _objc_class {
6509 struct _objc_class *isa;
6510 struct _objc_class *super_class;
6515 struct _objc_ivar_list *ivars;
6516 struct _objc_method_list *methods;
6517 #ifdef __NEXT_RUNTIME__
6518 struct objc_cache *cache;
6520 struct sarray *dtable;
6521 struct _objc_class *subclass_list;
6522 struct _objc_class *sibling_class;
6524 struct _objc_protocol_list *protocols;
6525 #ifdef __NEXT_RUNTIME__
6528 void *gc_object_type;
6531 /* NB: The 'sel_id' and 'gc_object_type' fields are not being used by
6532 the NeXT/Apple runtime; still, the compiler must generate them to
6533 maintain backward binary compatibility (and to allow for future
6537 build_class_template (void)
6539 tree ptype, decls, *chain = NULL;
6541 objc_class_template = objc_start_struct (get_identifier (UTAG_CLASS));
6543 /* struct _objc_class *isa; */
6544 decls = add_field_decl (build_pointer_type (objc_class_template),
6547 /* struct _objc_class *super_class; */
6548 add_field_decl (build_pointer_type (objc_class_template),
6549 "super_class", &chain);
6552 add_field_decl (string_type_node, "name", &chain);
6555 add_field_decl (long_integer_type_node, "version", &chain);
6558 add_field_decl (long_integer_type_node, "info", &chain);
6560 /* long instance_size; */
6561 add_field_decl (long_integer_type_node, "instance_size", &chain);
6563 /* struct _objc_ivar_list *ivars; */
6564 add_field_decl (objc_ivar_list_ptr,"ivars", &chain);
6566 /* struct _objc_method_list *methods; */
6567 add_field_decl (objc_method_list_ptr, "methods", &chain);
6569 if (flag_next_runtime)
6571 /* struct objc_cache *cache; */
6572 ptype = build_pointer_type (xref_tag (RECORD_TYPE,
6573 get_identifier ("objc_cache")));
6574 add_field_decl (ptype, "cache", &chain);
6578 /* struct sarray *dtable; */
6579 ptype = build_pointer_type(xref_tag (RECORD_TYPE,
6580 get_identifier ("sarray")));
6581 add_field_decl (ptype, "dtable", &chain);
6583 /* struct objc_class *subclass_list; */
6584 ptype = build_pointer_type (objc_class_template);
6585 add_field_decl (ptype, "subclass_list", &chain);
6587 /* struct objc_class *sibling_class; */
6588 ptype = build_pointer_type (objc_class_template);
6589 add_field_decl (ptype, "sibling_class", &chain);
6592 /* struct _objc_protocol **protocol_list; */
6593 ptype = build_pointer_type (build_pointer_type
6594 (xref_tag (RECORD_TYPE,
6595 get_identifier (UTAG_PROTOCOL))));
6596 add_field_decl (ptype, "protocol_list", &chain);
6598 if (flag_next_runtime)
6601 add_field_decl (build_pointer_type (void_type_node), "sel_id", &chain);
6604 /* void *gc_object_type; */
6605 add_field_decl (build_pointer_type (void_type_node),
6606 "gc_object_type", &chain);
6608 objc_finish_struct (objc_class_template, decls);
6611 /* Generate appropriate forward declarations for an implementation. */
6614 synth_forward_declarations (void)
6618 /* static struct objc_class _OBJC_CLASS_<my_name>; */
6619 UOBJC_CLASS_decl = build_metadata_decl ("_OBJC_CLASS",
6620 objc_class_template);
6622 /* static struct objc_class _OBJC_METACLASS_<my_name>; */
6623 UOBJC_METACLASS_decl = build_metadata_decl ("_OBJC_METACLASS",
6624 objc_class_template);
6626 /* Pre-build the following entities - for speed/convenience. */
6628 an_id = get_identifier ("super_class");
6629 ucls_super_ref = objc_build_component_ref (UOBJC_CLASS_decl, an_id);
6630 uucls_super_ref = objc_build_component_ref (UOBJC_METACLASS_decl, an_id);
6634 error_with_ivar (const char *message, tree decl)
6636 error_at (DECL_SOURCE_LOCATION (decl), "%s %qs",
6637 message, identifier_to_locale (gen_declaration (decl)));
6642 check_ivars (tree inter, tree imp)
6644 tree intdecls = CLASS_RAW_IVARS (inter);
6645 tree impdecls = CLASS_RAW_IVARS (imp);
6652 if (intdecls && TREE_CODE (intdecls) == TYPE_DECL)
6653 intdecls = TREE_CHAIN (intdecls);
6655 if (intdecls == 0 && impdecls == 0)
6657 if (intdecls == 0 || impdecls == 0)
6659 error ("inconsistent instance variable specification");
6663 t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls);
6665 if (!comptypes (t1, t2)
6666 || !tree_int_cst_equal (DECL_INITIAL (intdecls),
6667 DECL_INITIAL (impdecls)))
6669 if (DECL_NAME (intdecls) == DECL_NAME (impdecls))
6671 error_with_ivar ("conflicting instance variable type",
6673 error_with_ivar ("previous declaration of",
6676 else /* both the type and the name don't match */
6678 error ("inconsistent instance variable specification");
6683 else if (DECL_NAME (intdecls) != DECL_NAME (impdecls))
6685 error_with_ivar ("conflicting instance variable name",
6687 error_with_ivar ("previous declaration of",
6691 intdecls = DECL_CHAIN (intdecls);
6692 impdecls = DECL_CHAIN (impdecls);
6696 /* Set 'objc_super_template' to the data type node for 'struct _objc_super'.
6697 This needs to be done just once per compilation. */
6699 /* struct _objc_super {
6700 struct _objc_object *self;
6701 struct _objc_class *super_class;
6705 build_super_template (void)
6707 tree decls, *chain = NULL;
6709 objc_super_template = objc_start_struct (get_identifier (UTAG_SUPER));
6711 /* struct _objc_object *self; */
6712 decls = add_field_decl (objc_object_type, "self", &chain);
6714 /* struct _objc_class *super_class; */
6715 add_field_decl (build_pointer_type (objc_class_template),
6716 "super_class", &chain);
6718 objc_finish_struct (objc_super_template, decls);
6721 /* struct _objc_ivar {
6728 build_ivar_template (void)
6730 tree objc_ivar_id, objc_ivar_record;
6731 tree decls, *chain = NULL;
6733 objc_ivar_id = get_identifier (UTAG_IVAR);
6734 objc_ivar_record = objc_start_struct (objc_ivar_id);
6736 /* char *ivar_name; */
6737 decls = add_field_decl (string_type_node, "ivar_name", &chain);
6739 /* char *ivar_type; */
6740 add_field_decl (string_type_node, "ivar_type", &chain);
6742 /* int ivar_offset; */
6743 add_field_decl (integer_type_node, "ivar_offset", &chain);
6745 objc_finish_struct (objc_ivar_record, decls);
6747 return objc_ivar_record;
6752 struct objc_ivar ivar_list[ivar_count];
6756 build_ivar_list_template (tree list_type, int size)
6758 tree objc_ivar_list_record;
6759 tree array_type, decls, *chain = NULL;
6761 objc_ivar_list_record = objc_start_struct (NULL_TREE);
6763 /* int ivar_count; */
6764 decls = add_field_decl (integer_type_node, "ivar_count", &chain);
6766 /* struct objc_ivar ivar_list[]; */
6767 array_type = build_sized_array_type (list_type, size);
6768 add_field_decl (array_type, "ivar_list", &chain);
6770 objc_finish_struct (objc_ivar_list_record, decls);
6772 return objc_ivar_list_record;
6776 struct _objc__method_prototype_list *method_next;
6778 struct objc_method method_list[method_count];
6782 build_method_list_template (tree list_type, int size)
6784 tree objc_ivar_list_record;
6785 tree array_type, decls, *chain = NULL;
6787 objc_ivar_list_record = objc_start_struct (NULL_TREE);
6789 /* struct _objc__method_prototype_list *method_next; */
6790 decls = add_field_decl (objc_method_proto_list_ptr, "method_next", &chain);
6792 /* int method_count; */
6793 add_field_decl (integer_type_node, "method_count", &chain);
6795 /* struct objc_method method_list[]; */
6796 array_type = build_sized_array_type (list_type, size);
6797 add_field_decl (array_type, "method_list", &chain);
6799 objc_finish_struct (objc_ivar_list_record, decls);
6801 return objc_ivar_list_record;
6805 build_ivar_list_initializer (tree type, tree field_decl)
6807 VEC(constructor_elt,gc) *inits = NULL;
6811 VEC(constructor_elt,gc) *ivar = NULL;
6815 if (DECL_NAME (field_decl))
6816 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE,
6817 add_objc_string (DECL_NAME (field_decl),
6820 /* Unnamed bit-field ivar (yuck). */
6821 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, build_int_cst (NULL_TREE, 0));
6824 encode_field_decl (field_decl,
6825 obstack_object_size (&util_obstack),
6826 OBJC_ENCODE_DONT_INLINE_DEFS);
6828 /* Null terminate string. */
6829 obstack_1grow (&util_obstack, 0);
6830 id = add_objc_string (get_identifier (XOBFINISH (&util_obstack, char *)),
6832 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, id);
6833 obstack_free (&util_obstack, util_firstobj);
6836 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, byte_position (field_decl));
6837 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
6838 objc_build_constructor (type, ivar));
6840 field_decl = DECL_CHAIN (field_decl);
6841 while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
6845 return objc_build_constructor (build_array_type (type, 0), inits);
6849 generate_ivars_list (tree type, const char *name, int size, tree list)
6852 VEC(constructor_elt,gc) *inits = NULL;
6854 decl = start_var_decl (type, synth_id_with_class_suffix
6855 (name, objc_implementation_context));
6857 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, size));
6858 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, list);
6860 finish_var_decl (decl,
6861 objc_build_constructor (TREE_TYPE (decl), inits));
6866 /* Count only the fields occurring in T. */
6869 ivar_list_length (tree t)
6873 for (; t; t = DECL_CHAIN (t))
6874 if (TREE_CODE (t) == FIELD_DECL)
6881 generate_ivar_lists (void)
6883 tree initlist, ivar_list_template, chain;
6886 generating_instance_variables = 1;
6888 if (!objc_ivar_template)
6889 objc_ivar_template = build_ivar_template ();
6891 /* Only generate class variables for the root of the inheritance
6892 hierarchy since these will be the same for every class. */
6894 if (CLASS_SUPER_NAME (implementation_template) == NULL_TREE
6895 && (chain = TYPE_FIELDS (objc_class_template)))
6897 size = ivar_list_length (chain);
6899 ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
6900 initlist = build_ivar_list_initializer (objc_ivar_template, chain);
6902 UOBJC_CLASS_VARIABLES_decl
6903 = generate_ivars_list (ivar_list_template, "_OBJC_CLASS_VARIABLES",
6907 UOBJC_CLASS_VARIABLES_decl = 0;
6909 chain = CLASS_IVARS (implementation_template);
6912 size = ivar_list_length (chain);
6913 ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
6914 initlist = build_ivar_list_initializer (objc_ivar_template, chain);
6916 UOBJC_INSTANCE_VARIABLES_decl
6917 = generate_ivars_list (ivar_list_template, "_OBJC_INSTANCE_VARIABLES",
6921 UOBJC_INSTANCE_VARIABLES_decl = 0;
6923 generating_instance_variables = 0;
6927 build_dispatch_table_initializer (tree type, tree entries)
6929 VEC(constructor_elt,gc) *inits = NULL;
6933 VEC(constructor_elt,gc) *elems = NULL;
6936 CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE,
6937 build_selector (METHOD_SEL_NAME (entries)));
6939 /* Generate the method encoding if we don't have one already. */
6940 if (! METHOD_ENCODING (entries))
6941 METHOD_ENCODING (entries) =
6942 encode_method_prototype (entries);
6944 CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE,
6945 add_objc_string (METHOD_ENCODING (entries),
6948 expr = convert (ptr_type_node,
6949 build_unary_op (input_location, ADDR_EXPR,
6950 METHOD_DEFINITION (entries), 1));
6951 CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE, expr);
6953 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
6954 objc_build_constructor (type, elems));
6956 entries = DECL_CHAIN (entries);
6960 return objc_build_constructor (build_array_type (type, 0), inits);
6963 /* To accomplish method prototyping without generating all kinds of
6964 inane warnings, the definition of the dispatch table entries were
6967 struct objc_method { SEL _cmd; ...; id (*_imp)(); };
6969 struct objc_method { SEL _cmd; ...; void *_imp; }; */
6972 build_method_template (void)
6975 tree decls, *chain = NULL;
6977 _SLT_record = objc_start_struct (get_identifier (UTAG_METHOD));
6980 decls = add_field_decl (objc_selector_type, "_cmd", &chain);
6982 /* char *method_types; */
6983 add_field_decl (string_type_node, "method_types", &chain);
6986 add_field_decl (build_pointer_type (void_type_node), "_imp", &chain);
6988 objc_finish_struct (_SLT_record, decls);
6995 generate_dispatch_table (tree type, const char *name, int size, tree list)
6998 VEC(constructor_elt,gc) *v = NULL;
7000 decl = start_var_decl (type, synth_id_with_class_suffix
7001 (name, objc_implementation_context));
7003 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node);
7004 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (integer_type_node, size));
7005 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, list);
7007 finish_var_decl (decl,
7008 objc_build_constructor (TREE_TYPE (decl), v));
7014 mark_referenced_methods (void)
7016 struct imp_entry *impent;
7019 for (impent = imp_list; impent; impent = impent->next)
7021 chain = CLASS_CLS_METHODS (impent->imp_context);
7024 cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain)));
7025 chain = DECL_CHAIN (chain);
7028 chain = CLASS_NST_METHODS (impent->imp_context);
7031 cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain)));
7032 chain = DECL_CHAIN (chain);
7038 generate_dispatch_tables (void)
7040 tree initlist, chain, method_list_template;
7043 if (!objc_method_template)
7044 objc_method_template = build_method_template ();
7046 chain = CLASS_CLS_METHODS (objc_implementation_context);
7049 size = list_length (chain);
7051 method_list_template
7052 = build_method_list_template (objc_method_template, size);
7054 = build_dispatch_table_initializer (objc_method_template, chain);
7056 UOBJC_CLASS_METHODS_decl
7057 = generate_dispatch_table (method_list_template,
7058 ((TREE_CODE (objc_implementation_context)
7059 == CLASS_IMPLEMENTATION_TYPE)
7060 ? "_OBJC_CLASS_METHODS"
7061 : "_OBJC_CATEGORY_CLASS_METHODS"),
7065 UOBJC_CLASS_METHODS_decl = 0;
7067 chain = CLASS_NST_METHODS (objc_implementation_context);
7070 size = list_length (chain);
7072 method_list_template
7073 = build_method_list_template (objc_method_template, size);
7075 = build_dispatch_table_initializer (objc_method_template, chain);
7077 if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
7078 UOBJC_INSTANCE_METHODS_decl
7079 = generate_dispatch_table (method_list_template,
7080 "_OBJC_INSTANCE_METHODS",
7083 /* We have a category. */
7084 UOBJC_INSTANCE_METHODS_decl
7085 = generate_dispatch_table (method_list_template,
7086 "_OBJC_CATEGORY_INSTANCE_METHODS",
7090 UOBJC_INSTANCE_METHODS_decl = 0;
7094 generate_protocol_list (tree i_or_p)
7096 tree array_type, ptype, refs_decl, lproto, e, plist;
7098 const char *ref_name;
7099 VEC(constructor_elt,gc) *v = NULL;
7101 switch (TREE_CODE (i_or_p))
7103 case CLASS_INTERFACE_TYPE:
7104 case CATEGORY_INTERFACE_TYPE:
7105 plist = CLASS_PROTOCOL_LIST (i_or_p);
7107 case PROTOCOL_INTERFACE_TYPE:
7108 plist = PROTOCOL_LIST (i_or_p);
7115 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
7116 if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
7117 && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto)))
7120 /* Build initializer. */
7121 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7122 e = build_int_cst (build_pointer_type (objc_protocol_template), size);
7123 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e);
7125 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
7127 tree pval = TREE_VALUE (lproto);
7129 if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
7130 && PROTOCOL_FORWARD_DECL (pval))
7132 e = build_unary_op (input_location, ADDR_EXPR,
7133 PROTOCOL_FORWARD_DECL (pval), 0);
7134 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e);
7138 /* static struct objc_protocol *refs[n]; */
7140 switch (TREE_CODE (i_or_p))
7142 case PROTOCOL_INTERFACE_TYPE:
7143 ref_name = synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS", i_or_p);
7145 case CLASS_INTERFACE_TYPE:
7146 ref_name = synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS", i_or_p);
7148 case CATEGORY_INTERFACE_TYPE:
7149 ref_name = synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS", i_or_p);
7155 ptype = build_pointer_type (objc_protocol_template);
7156 array_type = build_sized_array_type (ptype, size + 3);
7157 refs_decl = start_var_decl (array_type, ref_name);
7159 finish_var_decl (refs_decl,
7160 objc_build_constructor (TREE_TYPE (refs_decl), v));
7166 build_category_initializer (tree type, tree cat_name, tree class_name,
7167 tree instance_methods, tree class_methods,
7171 VEC(constructor_elt,gc) *v = NULL;
7173 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, cat_name);
7174 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, class_name);
7176 if (!instance_methods)
7177 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7180 expr = convert (objc_method_list_ptr,
7181 build_unary_op (input_location, ADDR_EXPR,
7182 instance_methods, 0));
7183 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
7186 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7189 expr = convert (objc_method_list_ptr,
7190 build_unary_op (input_location, ADDR_EXPR,
7192 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
7195 /* protocol_list = */
7197 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7200 expr = convert (build_pointer_type
7202 (objc_protocol_template)),
7203 build_unary_op (input_location, ADDR_EXPR,
7205 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
7208 return objc_build_constructor (type, v);
7211 /* struct _objc_class {
7212 struct objc_class *isa;
7213 struct objc_class *super_class;
7218 struct objc_ivar_list *ivars;
7219 struct objc_method_list *methods;
7220 if (flag_next_runtime)
7221 struct objc_cache *cache;
7223 struct sarray *dtable;
7224 struct objc_class *subclass_list;
7225 struct objc_class *sibling_class;
7227 struct objc_protocol_list *protocols;
7228 if (flag_next_runtime)
7230 void *gc_object_type;
7234 build_shared_structure_initializer (tree type, tree isa, tree super,
7235 tree name, tree size, int status,
7236 tree dispatch_table, tree ivar_list,
7240 VEC(constructor_elt,gc) *v = NULL;
7243 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, isa);
7246 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, super);
7249 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, default_conversion (name));
7252 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
7253 build_int_cst (long_integer_type_node, 0));
7256 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
7257 build_int_cst (long_integer_type_node, status));
7259 /* instance_size = */
7260 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
7261 convert (long_integer_type_node, size));
7263 /* objc_ivar_list = */
7265 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7268 expr = convert (objc_ivar_list_ptr,
7269 build_unary_op (input_location, ADDR_EXPR,
7271 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
7274 /* objc_method_list = */
7275 if (!dispatch_table)
7276 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7279 expr = convert (objc_method_list_ptr,
7280 build_unary_op (input_location, ADDR_EXPR,
7281 dispatch_table, 0));
7282 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
7285 if (flag_next_runtime)
7286 /* method_cache = */
7287 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7291 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7293 /* subclass_list = */
7294 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7296 /* sibling_class = */
7297 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7300 /* protocol_list = */
7301 if (! protocol_list)
7302 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7305 expr = convert (build_pointer_type
7307 (objc_protocol_template)),
7308 build_unary_op (input_location, ADDR_EXPR,
7310 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
7313 if (flag_next_runtime)
7315 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7317 /* gc_object_type = NULL */
7318 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
7320 return objc_build_constructor (type, v);
7323 /* Retrieve category interface CAT_NAME (if any) associated with CLASS. */
7326 lookup_category (tree klass, tree cat_name)
7328 tree category = CLASS_CATEGORY_LIST (klass);
7330 while (category && CLASS_SUPER_NAME (category) != cat_name)
7331 category = CLASS_CATEGORY_LIST (category);
7335 /* static struct objc_category _OBJC_CATEGORY_<name> = { ... }; */
7338 generate_category (struct imp_entry *impent)
7340 tree initlist, cat_name_expr, class_name_expr;
7341 tree protocol_decl, category;
7342 tree cat = impent->imp_context;
7344 implementation_template = impent->imp_template;
7345 UOBJC_CLASS_decl = impent->class_decl;
7346 UOBJC_METACLASS_decl = impent->meta_decl;
7348 add_class_reference (CLASS_NAME (cat));
7349 cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names);
7351 class_name_expr = add_objc_string (CLASS_NAME (cat), class_names);
7353 category = lookup_category (implementation_template,
7354 CLASS_SUPER_NAME (cat));
7356 if (category && CLASS_PROTOCOL_LIST (category))
7358 generate_protocol_references (CLASS_PROTOCOL_LIST (category));
7359 protocol_decl = generate_protocol_list (category);
7364 initlist = build_category_initializer (TREE_TYPE (UOBJC_CLASS_decl),
7365 cat_name_expr, class_name_expr,
7366 UOBJC_INSTANCE_METHODS_decl,
7367 UOBJC_CLASS_METHODS_decl,
7369 /* Finish and initialize the forward decl. */
7370 finish_var_decl (UOBJC_CLASS_decl, initlist);
7373 /* static struct objc_class _OBJC_METACLASS_Foo={ ... };
7374 static struct objc_class _OBJC_CLASS_Foo={ ... }; */
7377 generate_shared_structures (struct imp_entry *impent)
7379 tree name_expr, super_expr, root_expr;
7380 tree my_root_id, my_super_id;
7381 tree cast_type, initlist, protocol_decl;
7384 objc_implementation_context = impent->imp_context;
7385 implementation_template = impent->imp_template;
7386 UOBJC_CLASS_decl = impent->class_decl;
7387 UOBJC_METACLASS_decl = impent->meta_decl;
7388 cls_flags = impent->has_cxx_cdtors ? CLS_HAS_CXX_STRUCTORS : 0 ;
7390 my_super_id = CLASS_SUPER_NAME (implementation_template);
7393 add_class_reference (my_super_id);
7395 /* Compute "my_root_id" - this is required for code generation.
7396 the "isa" for all meta class structures points to the root of
7397 the inheritance hierarchy (e.g. "__Object")... */
7398 my_root_id = my_super_id;
7401 tree my_root_int = lookup_interface (my_root_id);
7403 if (my_root_int && CLASS_SUPER_NAME (my_root_int))
7404 my_root_id = CLASS_SUPER_NAME (my_root_int);
7411 /* No super class. */
7412 my_root_id = CLASS_NAME (implementation_template);
7414 cast_type = build_pointer_type (objc_class_template);
7415 name_expr = add_objc_string (CLASS_NAME (implementation_template),
7418 /* Install class `isa' and `super' pointers at runtime. */
7420 super_expr = add_objc_string (my_super_id, class_names);
7422 super_expr = integer_zero_node;
7424 super_expr = build_c_cast (input_location,
7425 cast_type, super_expr); /* cast! */
7427 root_expr = add_objc_string (my_root_id, class_names);
7428 root_expr = build_c_cast (input_location, cast_type, root_expr); /* cast! */
7430 if (CLASS_PROTOCOL_LIST (implementation_template))
7432 generate_protocol_references
7433 (CLASS_PROTOCOL_LIST (implementation_template));
7434 protocol_decl = generate_protocol_list (implementation_template);
7439 /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */
7442 = build_shared_structure_initializer
7443 (TREE_TYPE (UOBJC_METACLASS_decl),
7444 root_expr, super_expr, name_expr,
7445 convert (integer_type_node, TYPE_SIZE_UNIT (objc_class_template)),
7447 UOBJC_CLASS_METHODS_decl,
7448 UOBJC_CLASS_VARIABLES_decl,
7451 finish_var_decl (UOBJC_METACLASS_decl, initlist);
7453 /* static struct objc_class _OBJC_CLASS_Foo={ ... }; */
7456 = build_shared_structure_initializer
7457 (TREE_TYPE (UOBJC_CLASS_decl),
7458 build_unary_op (input_location, ADDR_EXPR, UOBJC_METACLASS_decl, 0),
7459 super_expr, name_expr,
7460 convert (integer_type_node,
7461 TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE
7462 (implementation_template))),
7463 1 /*CLS_FACTORY*/ | cls_flags,
7464 UOBJC_INSTANCE_METHODS_decl,
7465 UOBJC_INSTANCE_VARIABLES_decl,
7468 finish_var_decl (UOBJC_CLASS_decl, initlist);
7473 synth_id_with_class_suffix (const char *preamble, tree ctxt)
7475 static char string[BUFSIZE];
7477 switch (TREE_CODE (ctxt))
7479 case CLASS_IMPLEMENTATION_TYPE:
7480 case CLASS_INTERFACE_TYPE:
7481 sprintf (string, "%s_%s", preamble,
7482 IDENTIFIER_POINTER (CLASS_NAME (ctxt)));
7484 case CATEGORY_IMPLEMENTATION_TYPE:
7485 case CATEGORY_INTERFACE_TYPE:
7487 /* We have a category. */
7488 const char *const class_name
7489 = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
7490 const char *const class_super_name
7491 = IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context));
7492 sprintf (string, "%s_%s_%s", preamble, class_name, class_super_name);
7495 case PROTOCOL_INTERFACE_TYPE:
7497 const char *protocol_name = IDENTIFIER_POINTER (PROTOCOL_NAME (ctxt));
7498 sprintf (string, "%s_%s", preamble, protocol_name);
7508 /* If type is empty or only type qualifiers are present, add default
7509 type of id (otherwise grokdeclarator will default to int). */
7511 adjust_type_for_id_default (tree type)
7514 type = make_node (TREE_LIST);
7516 if (!TREE_VALUE (type))
7517 TREE_VALUE (type) = objc_object_type;
7518 else if (TREE_CODE (TREE_VALUE (type)) == RECORD_TYPE
7519 && TYPED_OBJECT (TREE_VALUE (type)))
7520 error ("can not use an object as parameter to a method");
7525 /* Return a KEYWORD_DECL built using the specified key_name, arg_type,
7526 arg_name and attributes. (TODO: Rename KEYWORD_DECL to
7527 OBJC_METHOD_PARM_DECL ?)
7529 A KEYWORD_DECL is a tree representing the declaration of a
7530 parameter of an Objective-C method. It is produced when parsing a
7531 fragment of Objective-C method declaration of the form
7534 selector ':' '(' typename ')' identifier
7536 For example, take the Objective-C method
7538 -(NSString *)pathForResource:(NSString *)resource ofType:(NSString *)type;
7540 the two fragments "pathForResource:(NSString *)resource" and
7541 "ofType:(NSString *)type" will generate a KEYWORD_DECL each. The
7542 KEYWORD_DECL stores the 'key_name' (eg, identifier for
7543 "pathForResource"), the 'arg_type' (eg, tree representing a
7544 NSString *), the 'arg_name' (eg identifier for "resource") and
7545 potentially some attributes (for example, a tree representing
7546 __attribute__ ((unused)) if such an attribute was attached to a
7547 certain parameter). You can access this information using the
7548 TREE_TYPE (for arg_type), KEYWORD_ARG_NAME (for arg_name),
7549 KEYWORD_KEY_NAME (for key_name), DECL_ATTRIBUTES (for attributes).
7551 'key_name' is an identifier node (and is optional as you can omit
7552 it in Objective-C methods).
7553 'arg_type' is a tree list (and is optional too if no parameter type
7555 'arg_name' is an identifier node and is required.
7556 'attributes' is an optional tree containing parameter attributes. */
7558 objc_build_keyword_decl (tree key_name, tree arg_type,
7559 tree arg_name, tree attributes)
7563 if (flag_objc1_only && attributes)
7564 error_at (input_location, "method argument attributes are not available in Objective-C 1.0");
7566 /* If no type is specified, default to "id". */
7567 arg_type = adjust_type_for_id_default (arg_type);
7569 keyword_decl = make_node (KEYWORD_DECL);
7571 TREE_TYPE (keyword_decl) = arg_type;
7572 KEYWORD_ARG_NAME (keyword_decl) = arg_name;
7573 KEYWORD_KEY_NAME (keyword_decl) = key_name;
7574 DECL_ATTRIBUTES (keyword_decl) = attributes;
7576 return keyword_decl;
7579 /* Given a chain of keyword_decl's, synthesize the full keyword selector. */
7581 build_keyword_selector (tree selector)
7584 tree key_chain, key_name;
7587 /* Scan the selector to see how much space we'll need. */
7588 for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
7590 switch (TREE_CODE (selector))
7593 key_name = KEYWORD_KEY_NAME (key_chain);
7596 key_name = TREE_PURPOSE (key_chain);
7603 len += IDENTIFIER_LENGTH (key_name) + 1;
7605 /* Just a ':' arg. */
7609 buf = (char *) alloca (len + 1);
7610 /* Start the buffer out as an empty string. */
7613 for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
7615 switch (TREE_CODE (selector))
7618 key_name = KEYWORD_KEY_NAME (key_chain);
7621 key_name = TREE_PURPOSE (key_chain);
7622 /* The keyword decl chain will later be used as a function
7623 argument chain. Unhook the selector itself so as to not
7624 confuse other parts of the compiler. */
7625 TREE_PURPOSE (key_chain) = NULL_TREE;
7632 strcat (buf, IDENTIFIER_POINTER (key_name));
7636 return get_identifier (buf);
7639 /* Used for declarations and definitions. */
7642 build_method_decl (enum tree_code code, tree ret_type, tree selector,
7643 tree add_args, bool ellipsis)
7647 /* If no type is specified, default to "id". */
7648 ret_type = adjust_type_for_id_default (ret_type);
7650 /* Note how a method_decl has a TREE_TYPE which is not the function
7651 type of the function implementing the method, but only the return
7652 type of the method. We may want to change this, and store the
7653 entire function type in there (eg, it may be used to simplify
7654 dealing with attributes below). */
7655 method_decl = make_node (code);
7656 TREE_TYPE (method_decl) = ret_type;
7658 /* If we have a keyword selector, create an identifier_node that
7659 represents the full selector name (`:' included)... */
7660 if (TREE_CODE (selector) == KEYWORD_DECL)
7662 METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector);
7663 METHOD_SEL_ARGS (method_decl) = selector;
7664 METHOD_ADD_ARGS (method_decl) = add_args;
7665 METHOD_ADD_ARGS_ELLIPSIS_P (method_decl) = ellipsis;
7669 METHOD_SEL_NAME (method_decl) = selector;
7670 METHOD_SEL_ARGS (method_decl) = NULL_TREE;
7671 METHOD_ADD_ARGS (method_decl) = NULL_TREE;
7677 #define METHOD_DEF 0
7678 #define METHOD_REF 1
7680 /* This routine processes objective-c method attributes. */
7683 objc_decl_method_attributes (tree *node, tree attributes, int flags)
7685 /* TODO: Replace the hackery below. An idea would be to store the
7686 full function type in the method declaration (for example in
7687 TREE_TYPE) and then expose ObjC method declarations to c-family
7688 and they could deal with them by simply treating them as
7691 /* Because of the dangers in the hackery below, we filter out any
7692 attribute that we do not know about. For the ones we know about,
7693 we know that they work with the hackery. For the other ones,
7694 there is no guarantee, so we have to filter them out. */
7695 tree filtered_attributes = NULL_TREE;
7700 for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute))
7702 tree name = TREE_PURPOSE (attribute);
7704 if (is_attribute_p ("deprecated", name)
7705 || is_attribute_p ("sentinel", name)
7706 || is_attribute_p ("noreturn", name))
7708 /* An attribute that we support; add it to the filtered
7710 filtered_attributes = chainon (filtered_attributes,
7711 copy_node (attribute));
7713 else if (is_attribute_p ("format", name))
7715 /* "format" is special because before adding it to the
7716 filtered attributes we need to adjust the specified
7717 format by adding the hidden function parameters for
7718 an Objective-C method (self, _cmd). */
7719 tree new_attribute = copy_node (attribute);
7721 /* Check the arguments specified with the attribute, and
7722 modify them adding 2 for the two hidden arguments.
7723 Note how this differs from C++; according to the
7724 specs, C++ does not do it so you have to add the +1
7725 yourself. For Objective-C, instead, the compiler
7726 adds the +2 for you. */
7728 /* The attribute arguments have not been checked yet, so
7729 we need to be careful as they could be missing or
7730 invalid. If anything looks wrong, we skip the
7731 process and the compiler will complain about it later
7732 when it validates the attribute. */
7733 /* Check that we have at least three arguments. */
7734 if (TREE_VALUE (new_attribute)
7735 && TREE_CHAIN (TREE_VALUE (new_attribute))
7736 && TREE_CHAIN (TREE_CHAIN (TREE_VALUE (new_attribute))))
7738 tree second_argument = TREE_CHAIN (TREE_VALUE (new_attribute));
7739 tree third_argument = TREE_CHAIN (second_argument);
7742 /* This is the second argument, the "string-index",
7743 which specifies the index of the format string
7745 number = TREE_VALUE (second_argument);
7747 && TREE_CODE (number) == INTEGER_CST
7748 && TREE_INT_CST_HIGH (number) == 0)
7750 TREE_VALUE (second_argument)
7751 = build_int_cst (integer_type_node,
7752 TREE_INT_CST_LOW (number) + 2);
7755 /* This is the third argument, the "first-to-check",
7756 which specifies the index of the first argument to
7757 check. This could be 0, meaning it is not available,
7758 in which case we don't need to add 2. Add 2 if not
7760 number = TREE_VALUE (third_argument);
7762 && TREE_CODE (number) == INTEGER_CST
7763 && TREE_INT_CST_HIGH (number) == 0
7764 && TREE_INT_CST_LOW (number) != 0)
7766 TREE_VALUE (third_argument)
7767 = build_int_cst (integer_type_node,
7768 TREE_INT_CST_LOW (number) + 2);
7771 filtered_attributes = chainon (filtered_attributes,
7775 warning (OPT_Wattributes, "%qE attribute directive ignored", name);
7779 if (filtered_attributes)
7781 /* This hackery changes the TREE_TYPE of the ObjC method
7782 declaration to be a function type, so that decl_attributes
7783 will treat the ObjC method as if it was a function. Some
7784 attributes (sentinel, format) will be applied to the function
7785 type, changing it in place; so after calling decl_attributes,
7786 we extract the function type attributes and store them in
7787 METHOD_TYPE_ATTRIBUTES. Some other attributes (noreturn,
7788 deprecated) are applied directly to the method declaration
7789 (by setting TREE_DEPRECATED and TREE_THIS_VOLATILE) so there
7790 is nothing to do. */
7791 tree saved_type = TREE_TYPE (*node);
7792 TREE_TYPE (*node) = build_function_type
7793 (TREE_VALUE (saved_type), get_arg_type_list (*node, METHOD_REF, 0));
7794 decl_attributes (node, filtered_attributes, flags);
7795 METHOD_TYPE_ATTRIBUTES (*node) = TYPE_ATTRIBUTES (TREE_TYPE (*node));
7796 TREE_TYPE (*node) = saved_type;
7801 objc_method_decl (enum tree_code opcode)
7803 return opcode == INSTANCE_METHOD_DECL || opcode == CLASS_METHOD_DECL;
7806 /* Used by `build_objc_method_call' and `comp_proto_with_proto'. Return
7807 an argument list for method METH. CONTEXT is either METHOD_DEF or
7808 METHOD_REF, saying whether we are trying to define a method or call
7809 one. SUPERFLAG says this is for a send to super; this makes a
7810 difference for the NeXT calling sequence in which the lookup and
7811 the method call are done together. If METH is null, user-defined
7812 arguments (i.e., beyond self and _cmd) shall be represented by `...'. */
7815 get_arg_type_list (tree meth, int context, int superflag)
7819 /* Receiver type. */
7820 if (flag_next_runtime && superflag)
7821 arglist = build_tree_list (NULL_TREE, objc_super_type);
7822 else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
7823 arglist = build_tree_list (NULL_TREE, objc_instance_type);
7825 arglist = build_tree_list (NULL_TREE, objc_object_type);
7827 /* Selector type - will eventually change to `int'. */
7828 chainon (arglist, build_tree_list (NULL_TREE, objc_selector_type));
7830 /* No actual method prototype given -- assume that remaining arguments
7835 /* Build a list of argument types. */
7836 for (akey = METHOD_SEL_ARGS (meth); akey; akey = DECL_CHAIN (akey))
7838 tree arg_type = TREE_VALUE (TREE_TYPE (akey));
7840 /* Decay argument types for the underlying C function as appropriate. */
7841 arg_type = objc_decay_parm_type (arg_type);
7843 chainon (arglist, build_tree_list (NULL_TREE, arg_type));
7846 if (METHOD_ADD_ARGS (meth))
7848 for (akey = TREE_CHAIN (METHOD_ADD_ARGS (meth));
7849 akey; akey = TREE_CHAIN (akey))
7851 tree arg_type = TREE_TYPE (TREE_VALUE (akey));
7853 arg_type = objc_decay_parm_type (arg_type);
7855 chainon (arglist, build_tree_list (NULL_TREE, arg_type));
7858 if (!METHOD_ADD_ARGS_ELLIPSIS_P (meth))
7859 goto lack_of_ellipsis;
7864 chainon (arglist, OBJC_VOID_AT_END);
7871 check_duplicates (hash hsh, int methods, int is_class)
7873 tree meth = NULL_TREE;
7881 /* We have two or more methods with the same name but
7885 /* But just how different are those types? If
7886 -Wno-strict-selector-match is specified, we shall not
7887 complain if the differences are solely among types with
7888 identical size and alignment. */
7889 if (!warn_strict_selector_match)
7891 for (loop = hsh->list; loop; loop = loop->next)
7892 if (!comp_proto_with_proto (meth, loop->value, 0))
7901 bool type = TREE_CODE (meth) == INSTANCE_METHOD_DECL;
7903 warning_at (input_location, 0,
7904 "multiple methods named %<%c%E%> found",
7905 (is_class ? '+' : '-'),
7906 METHOD_SEL_NAME (meth));
7907 inform (DECL_SOURCE_LOCATION (meth), "using %<%c%s%>",
7909 identifier_to_locale (gen_method_decl (meth)));
7913 bool type = TREE_CODE (meth) == INSTANCE_METHOD_DECL;
7915 warning_at (input_location, 0,
7916 "multiple selectors named %<%c%E%> found",
7917 (is_class ? '+' : '-'),
7918 METHOD_SEL_NAME (meth));
7919 inform (DECL_SOURCE_LOCATION (meth), "found %<%c%s%>",
7921 identifier_to_locale (gen_method_decl (meth)));
7924 for (loop = hsh->list; loop; loop = loop->next)
7926 bool type = TREE_CODE (loop->value) == INSTANCE_METHOD_DECL;
7928 inform (DECL_SOURCE_LOCATION (loop->value), "also found %<%c%s%>",
7930 identifier_to_locale (gen_method_decl (loop->value)));
7937 /* If RECEIVER is a class reference, return the identifier node for
7938 the referenced class. RECEIVER is created by objc_get_class_reference,
7939 so we check the exact form created depending on which runtimes are
7943 receiver_is_class_object (tree receiver, int self, int super)
7945 tree chain, exp, arg;
7947 /* The receiver is 'self' or 'super' in the context of a class method. */
7948 if (objc_method_context
7949 && TREE_CODE (objc_method_context) == CLASS_METHOD_DECL
7952 ? CLASS_SUPER_NAME (implementation_template)
7953 : CLASS_NAME (implementation_template));
7955 if (flag_next_runtime)
7957 /* The receiver is a variable created by
7958 build_class_reference_decl. */
7959 if (TREE_CODE (receiver) == VAR_DECL && IS_CLASS (TREE_TYPE (receiver)))
7960 /* Look up the identifier. */
7961 for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
7962 if (TREE_PURPOSE (chain) == receiver)
7963 return TREE_VALUE (chain);
7966 /* The receiver is a function call that returns an id. Check if
7967 it is a call to objc_getClass, if so, pick up the class name. */
7968 if (TREE_CODE (receiver) == CALL_EXPR
7969 && (exp = CALL_EXPR_FN (receiver))
7970 && TREE_CODE (exp) == ADDR_EXPR
7971 && (exp = TREE_OPERAND (exp, 0))
7972 && TREE_CODE (exp) == FUNCTION_DECL
7973 /* For some reason, we sometimes wind up with multiple FUNCTION_DECL
7974 prototypes for objc_get_class(). Thankfully, they seem to share the
7975 same function type. */
7976 && TREE_TYPE (exp) == TREE_TYPE (objc_get_class_decl)
7977 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp)), TAG_GETCLASS)
7978 /* We have a call to objc_get_class/objc_getClass! */
7979 && (arg = CALL_EXPR_ARG (receiver, 0)))
7982 if (TREE_CODE (arg) == ADDR_EXPR
7983 && (arg = TREE_OPERAND (arg, 0))
7984 && TREE_CODE (arg) == STRING_CST)
7985 /* Finally, we have the class name. */
7986 return get_identifier (TREE_STRING_POINTER (arg));
7991 /* If we are currently building a message expr, this holds
7992 the identifier of the selector of the message. This is
7993 used when printing warnings about argument mismatches. */
7995 static tree current_objc_message_selector = 0;
7998 objc_message_selector (void)
8000 return current_objc_message_selector;
8003 /* Construct an expression for sending a message.
8004 MESS has the object to send to in TREE_PURPOSE
8005 and the argument list (including selector) in TREE_VALUE.
8007 (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
8008 (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */
8011 objc_build_message_expr (tree mess)
8013 tree receiver = TREE_PURPOSE (mess);
8016 tree args = TREE_PURPOSE (TREE_VALUE (mess));
8018 tree args = TREE_VALUE (mess);
8020 tree method_params = NULL_TREE;
8022 if (TREE_CODE (receiver) == ERROR_MARK || TREE_CODE (args) == ERROR_MARK)
8023 return error_mark_node;
8025 /* Obtain the full selector name. */
8026 switch (TREE_CODE (args))
8028 case IDENTIFIER_NODE:
8029 /* A unary selector. */
8033 sel_name = build_keyword_selector (args);
8039 /* Build the parameter list to give to the method. */
8040 if (TREE_CODE (args) == TREE_LIST)
8042 method_params = chainon (args, TREE_VALUE (TREE_VALUE (mess)));
8045 tree chain = args, prev = NULL_TREE;
8047 /* We have a keyword selector--check for comma expressions. */
8050 tree element = TREE_VALUE (chain);
8052 /* We have a comma expression, must collapse... */
8053 if (TREE_CODE (element) == TREE_LIST)
8056 TREE_CHAIN (prev) = element;
8061 chain = TREE_CHAIN (chain);
8063 method_params = args;
8068 if (processing_template_decl)
8069 /* Must wait until template instantiation time. */
8070 return build_min_nt (MESSAGE_SEND_EXPR, receiver, sel_name,
8074 return objc_finish_message_expr (receiver, sel_name, method_params, NULL);
8077 /* Look up method SEL_NAME that would be suitable for receiver
8078 of type 'id' (if IS_CLASS is zero) or 'Class' (if IS_CLASS is
8079 nonzero), and report on any duplicates. */
8082 lookup_method_in_hash_lists (tree sel_name, int is_class)
8084 hash method_prototype = NULL;
8087 method_prototype = hash_lookup (nst_method_hash_list,
8090 if (!method_prototype)
8092 method_prototype = hash_lookup (cls_method_hash_list,
8097 return check_duplicates (method_prototype, 1, is_class);
8100 /* The 'objc_finish_message_expr' routine is called from within
8101 'objc_build_message_expr' for non-template functions. In the case of
8102 C++ template functions, it is called from 'build_expr_from_tree'
8103 (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded.
8105 If the DEPRECATED_METHOD_PROTOTYPE argument is NULL, then we warn
8106 if the method being used is deprecated. If it is not NULL, instead
8107 of deprecating, we set *DEPRECATED_METHOD_PROTOTYPE to the method
8108 prototype that was used and is deprecated. This is useful for
8109 getter calls that are always generated when compiling dot-syntax
8110 expressions, even if they may not be used. In that case, we don't
8111 want the warning immediately; we produce it (if needed) at gimplify
8112 stage when we are sure that the deprecated getter is being
8115 objc_finish_message_expr (tree receiver, tree sel_name, tree method_params,
8116 tree *deprecated_method_prototype)
8118 tree method_prototype = NULL_TREE, rprotos = NULL_TREE, rtype;
8119 tree selector, retval, class_tree;
8120 int self, super, have_cast;
8122 /* We have used the receiver, so mark it as read. */
8123 mark_exp_read (receiver);
8125 /* Extract the receiver of the message, as well as its type
8126 (where the latter may take the form of a cast or be inferred
8127 from the implementation context). */
8129 while (TREE_CODE (rtype) == COMPOUND_EXPR
8130 || TREE_CODE (rtype) == MODIFY_EXPR
8131 || CONVERT_EXPR_P (rtype)
8132 || TREE_CODE (rtype) == COMPONENT_REF)
8133 rtype = TREE_OPERAND (rtype, 0);
8135 self = (rtype == self_decl);
8136 super = (rtype == UOBJC_SUPER_decl);
8137 rtype = TREE_TYPE (receiver);
8139 have_cast = (TREE_CODE (receiver) == NOP_EXPR
8140 || (TREE_CODE (receiver) == COMPOUND_EXPR
8141 && !IS_SUPER (rtype)));
8143 /* If we are calling [super dealloc], reset our warning flag. */
8144 if (super && !strcmp ("dealloc", IDENTIFIER_POINTER (sel_name)))
8145 should_call_super_dealloc = 0;
8147 /* If the receiver is a class object, retrieve the corresponding
8148 @interface, if one exists. */
8149 class_tree = receiver_is_class_object (receiver, self, super);
8151 /* Now determine the receiver type (if an explicit cast has not been
8156 rtype = lookup_interface (class_tree);
8157 /* Handle `self' and `super'. */
8160 if (!CLASS_SUPER_NAME (implementation_template))
8162 error ("no super class declared in @interface for %qE",
8163 CLASS_NAME (implementation_template));
8164 return error_mark_node;
8166 rtype = lookup_interface (CLASS_SUPER_NAME (implementation_template));
8169 rtype = lookup_interface (CLASS_NAME (implementation_template));
8172 /* If receiver is of type `id' or `Class' (or if the @interface for a
8173 class is not visible), we shall be satisfied with the existence of
8174 any instance or class method. */
8175 if (objc_is_id (rtype))
8177 class_tree = (IS_CLASS (rtype) ? objc_class_name : NULL_TREE);
8178 rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))
8179 ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype))
8185 /* If messaging 'id <Protos>' or 'Class <Proto>', first search
8186 in protocols themselves for the method prototype. */
8188 = lookup_method_in_protocol_list (rprotos, sel_name,
8189 class_tree != NULL_TREE);
8191 /* If messaging 'Class <Proto>' but did not find a class method
8192 prototype, search for an instance method instead, and warn
8193 about having done so. */
8194 if (!method_prototype && !rtype && class_tree != NULL_TREE)
8197 = lookup_method_in_protocol_list (rprotos, sel_name, 0);
8199 if (method_prototype)
8200 warning (0, "found %<-%E%> instead of %<+%E%> in protocol(s)",
8201 sel_name, sel_name);
8207 tree orig_rtype = rtype;
8209 if (TREE_CODE (rtype) == POINTER_TYPE)
8210 rtype = TREE_TYPE (rtype);
8211 /* Traverse typedef aliases */
8212 while (TREE_CODE (rtype) == RECORD_TYPE && OBJC_TYPE_NAME (rtype)
8213 && TREE_CODE (OBJC_TYPE_NAME (rtype)) == TYPE_DECL
8214 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype)))
8215 rtype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype));
8216 if (TYPED_OBJECT (rtype))
8218 rprotos = TYPE_OBJC_PROTOCOL_LIST (rtype);
8219 rtype = TYPE_OBJC_INTERFACE (rtype);
8221 /* If we could not find an @interface declaration, we must have
8222 only seen a @class declaration; so, we cannot say anything
8223 more intelligent about which methods the receiver will
8225 if (!rtype || TREE_CODE (rtype) == IDENTIFIER_NODE)
8228 /* We could not find an @interface declaration, yet Message maybe in a
8229 @class's protocol. */
8230 if (!method_prototype && rprotos)
8232 = lookup_method_in_protocol_list (rprotos, sel_name, 0);
8234 else if (TREE_CODE (rtype) == CLASS_INTERFACE_TYPE
8235 || TREE_CODE (rtype) == CLASS_IMPLEMENTATION_TYPE)
8237 /* We have a valid ObjC class name. Look up the method name
8238 in the published @interface for the class (and its
8241 = lookup_method_static (rtype, sel_name, class_tree != NULL_TREE);
8243 /* If the method was not found in the @interface, it may still
8244 exist locally as part of the @implementation. */
8245 if (!method_prototype && objc_implementation_context
8246 && CLASS_NAME (objc_implementation_context)
8247 == OBJC_TYPE_NAME (rtype))
8251 ? CLASS_CLS_METHODS (objc_implementation_context)
8252 : CLASS_NST_METHODS (objc_implementation_context)),
8255 /* If we haven't found a candidate method by now, try looking for
8256 it in the protocol list. */
8257 if (!method_prototype && rprotos)
8259 = lookup_method_in_protocol_list (rprotos, sel_name,
8260 class_tree != NULL_TREE);
8264 warning (0, "invalid receiver type %qs",
8265 identifier_to_locale (gen_type_name (orig_rtype)));
8266 /* After issuing the "invalid receiver" warning, perform method
8267 lookup as if we were messaging 'id'. */
8268 rtype = rprotos = NULL_TREE;
8273 /* For 'id' or 'Class' receivers, search in the global hash table
8274 as a last resort. For all receivers, warn if protocol searches
8276 if (!method_prototype)
8279 warning (0, "%<%c%E%> not found in protocol(s)",
8280 (class_tree ? '+' : '-'),
8285 = lookup_method_in_hash_lists (sel_name, class_tree != NULL_TREE);
8288 if (!method_prototype)
8290 static bool warn_missing_methods = false;
8293 warning (0, "%qE may not respond to %<%c%E%>",
8294 OBJC_TYPE_NAME (rtype),
8295 (class_tree ? '+' : '-'),
8297 /* If we are messaging an 'id' or 'Class' object and made it here,
8298 then we have failed to find _any_ instance or class method,
8301 warning (0, "no %<%c%E%> method found",
8302 (class_tree ? '+' : '-'),
8305 if (!warn_missing_methods)
8307 warning_at (input_location,
8308 0, "(Messages without a matching method signature");
8309 warning_at (input_location,
8310 0, "will be assumed to return %<id%> and accept");
8311 warning_at (input_location,
8312 0, "%<...%> as arguments.)");
8313 warn_missing_methods = true;
8318 /* Warn if the method is deprecated, but not if the receiver is
8319 a generic 'id'. 'id' is used to cast an object to a generic
8320 object of an unspecified class; in that case, we'll use
8321 whatever method prototype we can find to get the method
8322 argument and return types, but it is not appropriate to
8323 produce deprecation warnings since we don't know the class
8324 that the object will be of at runtime. The @interface(s) for
8325 that class may not even be available to the compiler right
8326 now, and it is perfectly possible that the method is marked
8327 as non-deprecated in such @interface(s).
8329 In practice this makes sense since casting an object to 'id'
8330 is often used precisely to turn off warnings associated with
8331 the object being of a particular class. */
8332 if (TREE_DEPRECATED (method_prototype) && rtype != NULL_TREE)
8334 if (deprecated_method_prototype)
8335 *deprecated_method_prototype = method_prototype;
8337 warn_deprecated_use (method_prototype, NULL_TREE);
8342 /* Save the selector name for printing error messages. */
8343 current_objc_message_selector = sel_name;
8345 /* Build the parameters list for looking up the method.
8346 These are the object itself and the selector. */
8348 if (flag_typed_selectors)
8349 selector = build_typed_selector_reference (input_location,
8350 sel_name, method_prototype);
8352 selector = build_selector_reference (input_location, sel_name);
8354 retval = build_objc_method_call (input_location, super, method_prototype,
8356 selector, method_params);
8358 current_objc_message_selector = 0;
8363 /* Build a tree expression to send OBJECT the operation SELECTOR,
8364 looking up the method on object LOOKUP_OBJECT (often same as OBJECT),
8365 assuming the method has prototype METHOD_PROTOTYPE.
8366 (That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.)
8367 LOC is the location of the expression to build.
8368 Use METHOD_PARAMS as list of args to pass to the method.
8369 If SUPER_FLAG is nonzero, we look up the superclass's method. */
8372 build_objc_method_call (location_t loc, int super_flag, tree method_prototype,
8373 tree lookup_object, tree selector,
8376 tree sender = (super_flag ? umsg_super_decl :
8377 (!flag_next_runtime || flag_nil_receivers
8378 ? (flag_objc_direct_dispatch
8381 : umsg_nonnil_decl));
8382 tree rcv_p = (super_flag ? objc_super_type : objc_object_type);
8383 VEC(tree, gc) *parms = NULL;
8384 unsigned nparm = (method_params ? list_length (method_params) : 0);
8386 /* If a prototype for the method to be called exists, then cast
8387 the sender's return type and arguments to match that of the method.
8388 Otherwise, leave sender as is. */
8391 ? TREE_VALUE (TREE_TYPE (method_prototype))
8392 : objc_object_type);
8394 tree method_param_types =
8395 get_arg_type_list (method_prototype, METHOD_REF, super_flag);
8396 tree ftype = build_function_type (ret_type, method_param_types);
8400 if (method_prototype && METHOD_TYPE_ATTRIBUTES (method_prototype))
8401 ftype = build_type_attribute_variant (ftype,
8402 METHOD_TYPE_ATTRIBUTES
8403 (method_prototype));
8405 sender_cast = build_pointer_type (ftype);
8407 lookup_object = build_c_cast (loc, rcv_p, lookup_object);
8409 /* Use SAVE_EXPR to avoid evaluating the receiver twice. */
8410 lookup_object = save_expr (lookup_object);
8412 /* Param list + 2 slots for object and selector. */
8413 parms = VEC_alloc (tree, gc, nparm + 2);
8415 if (flag_next_runtime)
8417 /* If we are returning a struct in memory, and the address
8418 of that memory location is passed as a hidden first
8419 argument, then change which messenger entry point this
8420 expr will call. NB: Note that sender_cast remains
8421 unchanged (it already has a struct return type). */
8422 if (!targetm.calls.struct_value_rtx (0, 0)
8423 && (TREE_CODE (ret_type) == RECORD_TYPE
8424 || TREE_CODE (ret_type) == UNION_TYPE)
8425 && targetm.calls.return_in_memory (ret_type, 0))
8426 sender = (super_flag ? umsg_super_stret_decl :
8427 flag_nil_receivers ? umsg_stret_decl : umsg_nonnil_stret_decl);
8429 method = build_fold_addr_expr_loc (input_location, sender);
8430 /* Pass the object to the method. */
8431 VEC_quick_push (tree, parms, lookup_object);
8435 /* This is the portable (GNU) way. */
8436 /* First, call the lookup function to get a pointer to the method,
8437 then cast the pointer, then call it with the method arguments. */
8438 VEC(tree, gc) *tv = VEC_alloc (tree, gc, 2);
8439 VEC_quick_push (tree, tv, lookup_object);
8440 VEC_quick_push (tree, tv, selector);
8441 method = build_function_call_vec (loc, sender, tv, NULL);
8442 VEC_free (tree, gc, tv);
8444 /* Pass the appropriate object to the method. */
8445 VEC_quick_push (tree, parms, (super_flag ? self_decl : lookup_object));
8448 /* Pass the selector to the method. */
8449 VEC_quick_push (tree, parms, selector);
8450 /* Now append the remainder of the parms. */
8452 for (; method_params; method_params = TREE_CHAIN (method_params))
8453 VEC_quick_push (tree, parms, TREE_VALUE (method_params));
8455 /* Build an obj_type_ref, with the correct cast for the method call. */
8456 t = build3 (OBJ_TYPE_REF, sender_cast, method,
8457 lookup_object, size_zero_node);
8458 t = build_function_call_vec (loc, t, parms, NULL);\
8459 VEC_free (tree, gc, parms);
8464 build_protocol_reference (tree p)
8467 const char *proto_name;
8469 /* static struct _objc_protocol _OBJC_PROTOCOL_<mumble>; */
8471 proto_name = synth_id_with_class_suffix ("_OBJC_PROTOCOL", p);
8472 decl = start_var_decl (objc_protocol_template, proto_name);
8474 PROTOCOL_FORWARD_DECL (p) = decl;
8477 /* This function is called by the parser when (and only when) a
8478 @protocol() expression is found, in order to compile it. */
8480 objc_build_protocol_expr (tree protoname)
8483 tree p = lookup_protocol (protoname, /* warn if deprecated */ true,
8484 /* definition_required */ false);
8488 error ("cannot find protocol declaration for %qE",
8490 return error_mark_node;
8493 if (!PROTOCOL_FORWARD_DECL (p))
8494 build_protocol_reference (p);
8496 expr = build_unary_op (input_location,
8497 ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
8499 /* ??? Ideally we'd build the reference with objc_protocol_type directly,
8500 if we have it, rather than converting it here. */
8501 expr = convert (objc_protocol_type, expr);
8503 /* The @protocol() expression is being compiled into a pointer to a
8504 statically allocated instance of the Protocol class. To become
8505 usable at runtime, the 'isa' pointer of the instance need to be
8506 fixed up at runtime by the runtime library, to point to the
8507 actual 'Protocol' class. */
8509 /* For the GNU runtime, put the static Protocol instance in the list
8510 of statically allocated instances, so that we make sure that its
8511 'isa' pointer is fixed up at runtime by the GNU runtime library
8512 to point to the Protocol class (at runtime, when loading the
8513 module, the GNU runtime library loops on the statically allocated
8514 instances (as found in the defs field in objc_symtab) and fixups
8515 all the 'isa' pointers of those objects). */
8516 if (! flag_next_runtime)
8518 /* This type is a struct containing the fields of a Protocol
8519 object. (Cfr. objc_protocol_type instead is the type of a pointer
8520 to such a struct). */
8521 tree protocol_struct_type = xref_tag
8522 (RECORD_TYPE, get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
8525 /* Look for the list of Protocol statically allocated instances
8526 to fixup at runtime. Create a new list to hold Protocol
8527 statically allocated instances, if the list is not found. At
8528 present there is only another list, holding NSConstantString
8529 static instances to be fixed up at runtime. */
8530 for (chain = &objc_static_instances;
8531 *chain && TREE_VALUE (*chain) != protocol_struct_type;
8532 chain = &TREE_CHAIN (*chain));
8535 *chain = tree_cons (NULL_TREE, protocol_struct_type, NULL_TREE);
8536 add_objc_string (OBJC_TYPE_NAME (protocol_struct_type),
8540 /* Add this statically allocated instance to the Protocol list. */
8541 TREE_PURPOSE (*chain) = tree_cons (NULL_TREE,
8542 PROTOCOL_FORWARD_DECL (p),
8543 TREE_PURPOSE (*chain));
8550 /* This function is called by the parser when a @selector() expression
8551 is found, in order to compile it. It is only called by the parser
8552 and only to compile a @selector(). LOC is the location of the
8555 objc_build_selector_expr (location_t loc, tree selnamelist)
8559 /* Obtain the full selector name. */
8560 switch (TREE_CODE (selnamelist))
8562 case IDENTIFIER_NODE:
8563 /* A unary selector. */
8564 selname = selnamelist;
8567 selname = build_keyword_selector (selnamelist);
8573 /* If we are required to check @selector() expressions as they
8574 are found, check that the selector has been declared. */
8575 if (warn_undeclared_selector)
8577 /* Look the selector up in the list of all known class and
8578 instance methods (up to this line) to check that the selector
8582 /* First try with instance methods. */
8583 hsh = hash_lookup (nst_method_hash_list, selname);
8585 /* If not found, try with class methods. */
8588 hsh = hash_lookup (cls_method_hash_list, selname);
8591 /* If still not found, print out a warning. */
8594 warning (0, "undeclared selector %qE", selname);
8599 if (flag_typed_selectors)
8600 return build_typed_selector_reference (loc, selname, 0);
8602 return build_selector_reference (loc, selname);
8605 /* This is used to implement @encode(). See gcc/doc/objc.texi,
8606 section '@encode'. */
8608 objc_build_encode_expr (tree type)
8613 encode_type (type, obstack_object_size (&util_obstack),
8614 OBJC_ENCODE_INLINE_DEFS);
8615 obstack_1grow (&util_obstack, 0); /* null terminate string */
8616 string = XOBFINISH (&util_obstack, const char *);
8618 /* Synthesize a string that represents the encoded struct/union. */
8619 result = my_build_string (strlen (string) + 1, string);
8620 obstack_free (&util_obstack, util_firstobj);
8625 build_ivar_reference (tree id)
8627 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
8629 /* Historically, a class method that produced objects (factory
8630 method) would assign `self' to the instance that it
8631 allocated. This would effectively turn the class method into
8632 an instance method. Following this assignment, the instance
8633 variables could be accessed. That practice, while safe,
8634 violates the simple rule that a class method should not refer
8635 to an instance variable. It's better to catch the cases
8636 where this is done unknowingly than to support the above
8638 warning (0, "instance variable %qE accessed in class method",
8640 self_decl = convert (objc_instance_type, self_decl); /* cast */
8643 return objc_build_component_ref (build_indirect_ref (input_location,
8644 self_decl, RO_ARROW),
8648 /* Compute a hash value for a given method SEL_NAME. */
8651 hash_func (tree sel_name)
8653 const unsigned char *s
8654 = (const unsigned char *)IDENTIFIER_POINTER (sel_name);
8658 h = h * 67 + *s++ - 113;
8665 nst_method_hash_list = ggc_alloc_cleared_vec_hash (SIZEHASHTABLE);
8666 cls_method_hash_list = ggc_alloc_cleared_vec_hash (SIZEHASHTABLE);
8668 cls_name_hash_list = ggc_alloc_cleared_vec_hash (SIZEHASHTABLE);
8669 als_name_hash_list = ggc_alloc_cleared_vec_hash (SIZEHASHTABLE);
8671 /* Initialize the hash table used to hold the constant string objects. */
8672 string_htab = htab_create_ggc (31, string_hash,
8676 /* This routine adds sel_name to the hash list. sel_name is a class or alias
8677 name for the class. If alias name, then value is its underlying class.
8678 If class, the value is NULL_TREE. */
8681 hash_class_name_enter (hash *hashlist, tree sel_name, tree value)
8684 int slot = hash_func (sel_name) % SIZEHASHTABLE;
8686 obj = ggc_alloc_hashed_entry ();
8687 if (value != NULL_TREE)
8689 /* Save the underlying class for the 'alias' in the hash table */
8690 attr obj_attr = ggc_alloc_hashed_attribute ();
8691 obj_attr->value = value;
8692 obj->list = obj_attr;
8696 obj->next = hashlist[slot];
8697 obj->key = sel_name;
8699 hashlist[slot] = obj; /* append to front */
8704 Searches in the hash table looking for a match for class or alias name.
8708 hash_class_name_lookup (hash *hashlist, tree sel_name)
8712 target = hashlist[hash_func (sel_name) % SIZEHASHTABLE];
8716 if (sel_name == target->key)
8719 target = target->next;
8724 /* WARNING!!!! hash_enter is called with a method, and will peek
8725 inside to find its selector! But hash_lookup is given a selector
8726 directly, and looks for the selector that's inside the found
8727 entry's key (method) for comparison. */
8730 hash_enter (hash *hashlist, tree method)
8733 int slot = hash_func (METHOD_SEL_NAME (method)) % SIZEHASHTABLE;
8735 obj = ggc_alloc_hashed_entry ();
8737 obj->next = hashlist[slot];
8740 hashlist[slot] = obj; /* append to front */
8744 hash_lookup (hash *hashlist, tree sel_name)
8748 target = hashlist[hash_func (sel_name) % SIZEHASHTABLE];
8752 if (sel_name == METHOD_SEL_NAME (target->key))
8755 target = target->next;
8761 hash_add_attr (hash entry, tree value)
8765 obj = ggc_alloc_hashed_attribute ();
8766 obj->next = entry->list;
8769 entry->list = obj; /* append to front */
8773 lookup_method (tree mchain, tree method)
8777 if (TREE_CODE (method) == IDENTIFIER_NODE)
8780 key = METHOD_SEL_NAME (method);
8784 if (METHOD_SEL_NAME (mchain) == key)
8787 mchain = DECL_CHAIN (mchain);
8792 /* Look up a class (if OBJC_LOOKUP_CLASS is set in FLAGS) or instance
8793 method in INTERFACE, along with any categories and protocols
8794 attached thereto. If method is not found, and the
8795 OBJC_LOOKUP_NO_SUPER is _not_ set in FLAGS, recursively examine the
8796 INTERFACE's superclass. If OBJC_LOOKUP_CLASS is set,
8797 OBJC_LOOKUP_NO_SUPER is clear, and no suitable class method could
8798 be found in INTERFACE or any of its superclasses, look for an
8799 _instance_ method of the same name in the root class as a last
8800 resort. This behaviour can be turned off by using
8801 OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS.
8803 If a suitable method cannot be found, return NULL_TREE. */
8806 lookup_method_static (tree interface, tree ident, int flags)
8808 tree meth = NULL_TREE, root_inter = NULL_TREE;
8809 tree inter = interface;
8810 int is_class = (flags & OBJC_LOOKUP_CLASS);
8811 int no_superclasses = (flags & OBJC_LOOKUP_NO_SUPER);
8812 int no_instance_methods_of_root_class = (flags & OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS);
8816 tree chain = is_class ? CLASS_CLS_METHODS (inter) : CLASS_NST_METHODS (inter);
8817 tree category = inter;
8819 /* First, look up the method in the class itself. */
8820 if ((meth = lookup_method (chain, ident)))
8823 /* Failing that, look for the method in each category of the class. */
8824 while ((category = CLASS_CATEGORY_LIST (category)))
8826 chain = is_class ? CLASS_CLS_METHODS (category) : CLASS_NST_METHODS (category);
8828 /* Check directly in each category. */
8829 if ((meth = lookup_method (chain, ident)))
8832 /* Failing that, check in each category's protocols. */
8833 if (CLASS_PROTOCOL_LIST (category))
8835 if ((meth = (lookup_method_in_protocol_list
8836 (CLASS_PROTOCOL_LIST (category), ident, is_class))))
8841 /* If not found in categories, check in protocols of the main class. */
8842 if (CLASS_PROTOCOL_LIST (inter))
8844 if ((meth = (lookup_method_in_protocol_list
8845 (CLASS_PROTOCOL_LIST (inter), ident, is_class))))
8849 /* If we were instructed not to look in superclasses, don't. */
8850 if (no_superclasses)
8853 /* Failing that, climb up the inheritance hierarchy. */
8855 inter = lookup_interface (CLASS_SUPER_NAME (inter));
8859 if (is_class && !no_instance_methods_of_root_class)
8861 /* If no class (factory) method was found, check if an _instance_
8862 method of the same name exists in the root class. This is what
8863 the Objective-C runtime will do. */
8864 return lookup_method_static (root_inter, ident, 0);
8868 /* If an instance method was not found, return 0. */
8873 /* Add the method to the hash list if it doesn't contain an identical
8877 add_method_to_hash_list (hash *hash_list, tree method)
8881 if (!(hsh = hash_lookup (hash_list, METHOD_SEL_NAME (method))))
8883 /* Install on a global chain. */
8884 hash_enter (hash_list, method);
8888 /* Check types against those; if different, add to a list. */
8890 int already_there = comp_proto_with_proto (method, hsh->key, 1);
8891 for (loop = hsh->list; !already_there && loop; loop = loop->next)
8892 already_there |= comp_proto_with_proto (method, loop->value, 1);
8894 hash_add_attr (hsh, method);
8899 objc_add_method (tree klass, tree method, int is_class, bool is_optional)
8901 tree existing_method = NULL_TREE;
8903 /* The first thing we do is look up the method in the list of
8904 methods already defined in the interface (or implementation). */
8906 existing_method = lookup_method (CLASS_CLS_METHODS (klass), method);
8908 existing_method = lookup_method (CLASS_NST_METHODS (klass), method);
8910 /* In the case of protocols, we have a second list of methods to
8911 consider, the list of optional ones. */
8912 if (TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE)
8914 /* @required methods are added to the protocol's normal list.
8915 @optional methods are added to the protocol's OPTIONAL lists.
8916 Note that adding the methods to the optional lists disables
8917 checking that the methods are implemented by classes
8918 implementing the protocol, since these checks only use the
8919 CLASS_CLS_METHODS and CLASS_NST_METHODS. */
8921 /* First of all, if the method to add is @optional, and we found
8922 it already existing as @required, emit an error. */
8923 if (is_optional && existing_method)
8925 error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time",
8926 (is_class ? '+' : '-'),
8927 METHOD_SEL_NAME (existing_method));
8928 inform (DECL_SOURCE_LOCATION (existing_method),
8929 "previous declaration of %<%c%E%> as %<@required%>",
8930 (is_class ? '+' : '-'),
8931 METHOD_SEL_NAME (existing_method));
8934 /* Now check the list of @optional methods if we didn't find the
8935 method in the @required list. */
8936 if (!existing_method)
8939 existing_method = lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (klass), method);
8941 existing_method = lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (klass), method);
8943 if (!is_optional && existing_method)
8945 error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time",
8946 (is_class ? '+' : '-'),
8947 METHOD_SEL_NAME (existing_method));
8948 inform (DECL_SOURCE_LOCATION (existing_method),
8949 "previous declaration of %<%c%E%> as %<@optional%>",
8950 (is_class ? '+' : '-'),
8951 METHOD_SEL_NAME (existing_method));
8956 /* If the method didn't exist already, add it. */
8957 if (!existing_method)
8963 /* Put the method on the list in reverse order. */
8964 TREE_CHAIN (method) = PROTOCOL_OPTIONAL_CLS_METHODS (klass);
8965 PROTOCOL_OPTIONAL_CLS_METHODS (klass) = method;
8969 TREE_CHAIN (method) = PROTOCOL_OPTIONAL_NST_METHODS (klass);
8970 PROTOCOL_OPTIONAL_NST_METHODS (klass) = method;
8977 DECL_CHAIN (method) = CLASS_CLS_METHODS (klass);
8978 CLASS_CLS_METHODS (klass) = method;
8982 DECL_CHAIN (method) = CLASS_NST_METHODS (klass);
8983 CLASS_NST_METHODS (klass) = method;
8989 /* The method was already defined. Check that the types match
8990 for an @interface for a class or category, or for a
8991 @protocol. Give hard errors on methods with identical
8992 selectors but differing argument and/or return types. We do
8993 not do this for @implementations, because C/C++ will do it
8994 for us (i.e., there will be duplicate function definition
8996 if ((TREE_CODE (klass) == CLASS_INTERFACE_TYPE
8997 || TREE_CODE (klass) == CATEGORY_INTERFACE_TYPE
8998 /* Starting with GCC 4.6, we emit the same error for
8999 protocols too. The situation is identical to
9000 @interfaces as there is no possible meaningful reason
9001 for defining the same method with different signatures
9002 in the very same @protocol. If that was allowed,
9003 whenever the protocol is used (both at compile and run
9004 time) there wouldn't be any meaningful way to decide
9005 which of the two method signatures should be used. */
9006 || TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE)
9007 && !comp_proto_with_proto (method, existing_method, 1))
9009 error ("duplicate declaration of method %<%c%E%> with conflicting types",
9010 (is_class ? '+' : '-'),
9011 METHOD_SEL_NAME (existing_method));
9012 inform (DECL_SOURCE_LOCATION (existing_method),
9013 "previous declaration of %<%c%E%>",
9014 (is_class ? '+' : '-'),
9015 METHOD_SEL_NAME (existing_method));
9020 add_method_to_hash_list (cls_method_hash_list, method);
9023 add_method_to_hash_list (nst_method_hash_list, method);
9025 /* Instance methods in root classes (and categories thereof)
9026 may act as class methods as a last resort. We also add
9027 instance methods listed in @protocol declarations to
9028 the class hash table, on the assumption that @protocols
9029 may be adopted by root classes or categories. */
9030 if (TREE_CODE (klass) == CATEGORY_INTERFACE_TYPE
9031 || TREE_CODE (klass) == CATEGORY_IMPLEMENTATION_TYPE)
9032 klass = lookup_interface (CLASS_NAME (klass));
9034 if (TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE
9035 || !CLASS_SUPER_NAME (klass))
9036 add_method_to_hash_list (cls_method_hash_list, method);
9043 add_class (tree class_name, tree name)
9045 struct interface_tuple **slot;
9047 /* Put interfaces on list in reverse order. */
9048 TREE_CHAIN (class_name) = interface_chain;
9049 interface_chain = class_name;
9051 if (interface_htab == NULL)
9052 interface_htab = htab_create_ggc (31, hash_interface, eq_interface, NULL);
9053 slot = (struct interface_tuple **)
9054 htab_find_slot_with_hash (interface_htab, name,
9055 IDENTIFIER_HASH_VALUE (name),
9059 *slot = ggc_alloc_cleared_interface_tuple ();
9062 (*slot)->class_name = class_name;
9064 return interface_chain;
9068 add_category (tree klass, tree category)
9070 /* Put categories on list in reverse order. */
9071 tree cat = lookup_category (klass, CLASS_SUPER_NAME (category));
9075 warning (0, "duplicate interface declaration for category %<%E(%E)%>",
9077 CLASS_SUPER_NAME (category));
9081 CLASS_CATEGORY_LIST (category) = CLASS_CATEGORY_LIST (klass);
9082 CLASS_CATEGORY_LIST (klass) = category;
9086 /* Called after parsing each instance variable declaration. Necessary to
9087 preserve typedefs and implement public/private...
9089 VISIBILITY is 1 for public, 0 for protected, and 2 for private. */
9092 add_instance_variable (tree klass, objc_ivar_visibility_kind visibility,
9095 tree field_type = TREE_TYPE (field_decl);
9096 const char *ivar_name = DECL_NAME (field_decl)
9097 ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (field_decl)))
9101 if (TREE_CODE (field_type) == REFERENCE_TYPE)
9103 error ("illegal reference type specified for instance variable %qs",
9105 /* Return class as is without adding this ivar. */
9110 if (field_type == error_mark_node || !TYPE_SIZE (field_type)
9111 || TYPE_SIZE (field_type) == error_mark_node)
9112 /* 'type[0]' is allowed, but 'type[]' is not! */
9114 error ("instance variable %qs has unknown size", ivar_name);
9115 /* Return class as is without adding this ivar. */
9120 /* Check if the ivar being added has a non-POD C++ type. If so, we will
9121 need to either (1) warn the user about it or (2) generate suitable
9122 constructor/destructor call from '- .cxx_construct' or '- .cxx_destruct'
9123 methods (if '-fobjc-call-cxx-cdtors' was specified). */
9124 if (MAYBE_CLASS_TYPE_P (field_type)
9125 && (TYPE_NEEDS_CONSTRUCTING (field_type)
9126 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type)
9127 || TYPE_POLYMORPHIC_P (field_type)))
9129 tree type_name = OBJC_TYPE_NAME (field_type);
9131 if (flag_objc_call_cxx_cdtors)
9133 /* Since the ObjC runtime will be calling the constructors and
9134 destructors for us, the only thing we can't handle is the lack
9135 of a default constructor. */
9136 if (TYPE_NEEDS_CONSTRUCTING (field_type)
9137 && !TYPE_HAS_DEFAULT_CONSTRUCTOR (field_type))
9139 warning (0, "type %qE has no default constructor to call",
9142 /* If we cannot call a constructor, we should also avoid
9143 calling the destructor, for symmetry. */
9144 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type))
9145 warning (0, "destructor for %qE shall not be run either",
9151 static bool warn_cxx_ivars = false;
9153 if (TYPE_POLYMORPHIC_P (field_type))
9155 /* Vtable pointers are Real Bad(tm), since Obj-C cannot
9157 error ("type %qE has virtual member functions", type_name);
9158 error ("illegal aggregate type %qE specified "
9159 "for instance variable %qs",
9160 type_name, ivar_name);
9161 /* Return class as is without adding this ivar. */
9165 /* User-defined constructors and destructors are not known to Obj-C
9166 and hence will not be called. This may or may not be a problem. */
9167 if (TYPE_NEEDS_CONSTRUCTING (field_type))
9168 warning (0, "type %qE has a user-defined constructor", type_name);
9169 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type))
9170 warning (0, "type %qE has a user-defined destructor", type_name);
9172 if (!warn_cxx_ivars)
9174 warning (0, "C++ constructors and destructors will not "
9175 "be invoked for Objective-C fields");
9176 warn_cxx_ivars = true;
9182 /* Overload the public attribute, it is not used for FIELD_DECLs. */
9185 case OBJC_IVAR_VIS_PROTECTED:
9186 TREE_PUBLIC (field_decl) = 0;
9187 TREE_PRIVATE (field_decl) = 0;
9188 TREE_PROTECTED (field_decl) = 1;
9191 case OBJC_IVAR_VIS_PACKAGE:
9192 /* TODO: Implement the package variant. */
9193 case OBJC_IVAR_VIS_PUBLIC:
9194 TREE_PUBLIC (field_decl) = 1;
9195 TREE_PRIVATE (field_decl) = 0;
9196 TREE_PROTECTED (field_decl) = 0;
9199 case OBJC_IVAR_VIS_PRIVATE:
9200 TREE_PUBLIC (field_decl) = 0;
9201 TREE_PRIVATE (field_decl) = 1;
9202 TREE_PROTECTED (field_decl) = 0;
9207 CLASS_RAW_IVARS (klass) = chainon (CLASS_RAW_IVARS (klass), field_decl);
9214 is_ivar (tree decl_chain, tree ident)
9216 for ( ; decl_chain; decl_chain = DECL_CHAIN (decl_chain))
9217 if (DECL_NAME (decl_chain) == ident)
9222 /* True if the ivar is private and we are not in its implementation. */
9225 is_private (tree decl)
9227 return (TREE_PRIVATE (decl)
9228 && ! is_ivar (CLASS_IVARS (implementation_template),
9232 /* We have an instance variable reference;, check to see if it is public. */
9235 objc_is_public (tree expr, tree identifier)
9237 tree basetype, decl;
9240 if (processing_template_decl)
9244 if (TREE_TYPE (expr) == error_mark_node)
9247 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
9249 if (basetype && TREE_CODE (basetype) == RECORD_TYPE)
9251 if (TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype))
9253 tree klass = lookup_interface (OBJC_TYPE_NAME (basetype));
9257 error ("cannot find interface declaration for %qE",
9258 OBJC_TYPE_NAME (basetype));
9262 if ((decl = is_ivar (get_class_ivars (klass, true), identifier)))
9264 if (TREE_PUBLIC (decl))
9267 /* Important difference between the Stepstone translator:
9268 all instance variables should be public within the context
9269 of the implementation. */
9270 if (objc_implementation_context
9271 && ((TREE_CODE (objc_implementation_context)
9272 == CLASS_IMPLEMENTATION_TYPE)
9273 || (TREE_CODE (objc_implementation_context)
9274 == CATEGORY_IMPLEMENTATION_TYPE)))
9276 tree curtype = TYPE_MAIN_VARIANT
9277 (CLASS_STATIC_TEMPLATE
9278 (implementation_template));
9280 if (basetype == curtype
9281 || DERIVED_FROM_P (basetype, curtype))
9283 int priv = is_private (decl);
9286 error ("instance variable %qE is declared private",
9293 /* The 2.95.2 compiler sometimes allowed C functions to access
9294 non-@public ivars. We will let this slide for now... */
9295 if (!objc_method_context)
9297 warning (0, "instance variable %qE is %s; "
9298 "this will be a hard error in the future",
9300 TREE_PRIVATE (decl) ? "@private" : "@protected");
9304 error ("instance variable %qE is declared %s",
9306 TREE_PRIVATE (decl) ? "private" : "protected");
9315 /* Make sure all methods in CHAIN (a list of method declarations from
9316 an @interface or a @protocol) are in IMPLEMENTATION (the
9317 implementation context). This is used to check for example that
9318 all methods declared in an @interface were implemented in an
9321 Some special methods (property setters/getters) are special and if
9322 they are not found in IMPLEMENTATION, we look them up in its
9326 check_methods (tree chain, tree implementation, int mtype)
9331 if (mtype == (int)'+')
9332 list = CLASS_CLS_METHODS (implementation);
9334 list = CLASS_NST_METHODS (implementation);
9338 /* If the method is associated with a dynamic property, then it
9339 is Ok not to have the method implementation, as it will be
9340 generated dynamically at runtime. To decide if the method is
9341 associated with a @dynamic property, we search the list of
9342 @synthesize and @dynamic for this implementation, and look
9343 for any @dynamic property with the same setter or getter name
9346 for (x = IMPL_PROPERTY_DECL (implementation); x; x = TREE_CHAIN (x))
9347 if (PROPERTY_DYNAMIC (x)
9348 && (PROPERTY_GETTER_NAME (x) == METHOD_SEL_NAME (chain)
9349 || PROPERTY_SETTER_NAME (x) == METHOD_SEL_NAME (chain)))
9354 chain = TREE_CHAIN (chain); /* next method... */
9358 if (!lookup_method (list, chain))
9360 /* If the method is a property setter/getter, we'll still
9361 allow it to be missing if it is implemented by
9362 'interface' or any of its superclasses. */
9363 tree property = METHOD_PROPERTY_CONTEXT (chain);
9366 /* Note that since this is a property getter/setter, it
9367 is obviously an instance method. */
9368 tree interface = NULL_TREE;
9370 /* For a category, first check the main class
9372 if (TREE_CODE (implementation) == CATEGORY_IMPLEMENTATION_TYPE)
9374 interface = lookup_interface (CLASS_NAME (implementation));
9376 /* If the method is found in the main class, it's Ok. */
9377 if (lookup_method (CLASS_NST_METHODS (interface), chain))
9379 chain = DECL_CHAIN (chain);
9383 /* Else, get the superclass. */
9384 if (CLASS_SUPER_NAME (interface))
9385 interface = lookup_interface (CLASS_SUPER_NAME (interface));
9387 interface = NULL_TREE;
9390 /* Get the superclass for classes. */
9391 if (TREE_CODE (implementation) == CLASS_IMPLEMENTATION_TYPE)
9393 if (CLASS_SUPER_NAME (implementation))
9394 interface = lookup_interface (CLASS_SUPER_NAME (implementation));
9396 interface = NULL_TREE;
9399 /* Now, interface is the superclass, if any; go check it. */
9402 if (lookup_method_static (interface, chain, 0))
9404 chain = DECL_CHAIN (chain);
9408 /* Else, fall through - warn. */
9412 switch (TREE_CODE (implementation))
9414 case CLASS_IMPLEMENTATION_TYPE:
9415 warning (0, "incomplete implementation of class %qE",
9416 CLASS_NAME (implementation));
9418 case CATEGORY_IMPLEMENTATION_TYPE:
9419 warning (0, "incomplete implementation of category %qE",
9420 CLASS_SUPER_NAME (implementation));
9428 warning (0, "method definition for %<%c%E%> not found",
9429 mtype, METHOD_SEL_NAME (chain));
9432 chain = DECL_CHAIN (chain);
9438 /* Check if KLASS, or its superclasses, explicitly conforms to PROTOCOL. */
9441 conforms_to_protocol (tree klass, tree protocol)
9443 if (TREE_CODE (protocol) == PROTOCOL_INTERFACE_TYPE)
9445 tree p = CLASS_PROTOCOL_LIST (klass);
9446 while (p && TREE_VALUE (p) != protocol)
9451 tree super = (CLASS_SUPER_NAME (klass)
9452 ? lookup_interface (CLASS_SUPER_NAME (klass))
9454 int tmp = super ? conforms_to_protocol (super, protocol) : 0;
9463 /* Make sure all methods in CHAIN are accessible as MTYPE methods in
9464 CONTEXT. This is one of two mechanisms to check protocol integrity. */
9467 check_methods_accessible (tree chain, tree context, int mtype)
9471 tree base_context = context;
9475 /* If the method is associated with a dynamic property, then it
9476 is Ok not to have the method implementation, as it will be
9477 generated dynamically at runtime. Search for any @dynamic
9478 property with the same setter or getter name as this
9479 method. TODO: Use a hashtable lookup. */
9481 for (x = IMPL_PROPERTY_DECL (base_context); x; x = TREE_CHAIN (x))
9482 if (PROPERTY_DYNAMIC (x)
9483 && (PROPERTY_GETTER_NAME (x) == METHOD_SEL_NAME (chain)
9484 || PROPERTY_SETTER_NAME (x) == METHOD_SEL_NAME (chain)))
9489 chain = TREE_CHAIN (chain); /* next method... */
9493 context = base_context;
9497 list = CLASS_CLS_METHODS (context);
9499 list = CLASS_NST_METHODS (context);
9501 if (lookup_method (list, chain))
9504 switch (TREE_CODE (context))
9506 case CLASS_IMPLEMENTATION_TYPE:
9507 case CLASS_INTERFACE_TYPE:
9508 context = (CLASS_SUPER_NAME (context)
9509 ? lookup_interface (CLASS_SUPER_NAME (context))
9512 case CATEGORY_IMPLEMENTATION_TYPE:
9513 case CATEGORY_INTERFACE_TYPE:
9514 context = (CLASS_NAME (context)
9515 ? lookup_interface (CLASS_NAME (context))
9523 if (context == NULL_TREE)
9527 switch (TREE_CODE (objc_implementation_context))
9529 case CLASS_IMPLEMENTATION_TYPE:
9530 warning (0, "incomplete implementation of class %qE",
9531 CLASS_NAME (objc_implementation_context));
9533 case CATEGORY_IMPLEMENTATION_TYPE:
9534 warning (0, "incomplete implementation of category %qE",
9535 CLASS_SUPER_NAME (objc_implementation_context));
9542 warning (0, "method definition for %<%c%E%> not found",
9543 mtype, METHOD_SEL_NAME (chain));
9546 chain = TREE_CHAIN (chain); /* next method... */
9551 /* Check whether the current interface (accessible via
9552 'objc_implementation_context') actually implements protocol P, along
9553 with any protocols that P inherits. */
9556 check_protocol (tree p, const char *type, tree name)
9558 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
9562 /* Ensure that all protocols have bodies! */
9565 f1 = check_methods (PROTOCOL_CLS_METHODS (p),
9566 objc_implementation_context,
9568 f2 = check_methods (PROTOCOL_NST_METHODS (p),
9569 objc_implementation_context,
9574 f1 = check_methods_accessible (PROTOCOL_CLS_METHODS (p),
9575 objc_implementation_context,
9577 f2 = check_methods_accessible (PROTOCOL_NST_METHODS (p),
9578 objc_implementation_context,
9583 warning (0, "%s %qE does not fully implement the %qE protocol",
9584 type, name, PROTOCOL_NAME (p));
9587 /* Check protocols recursively. */
9588 if (PROTOCOL_LIST (p))
9590 tree subs = PROTOCOL_LIST (p);
9592 lookup_interface (CLASS_SUPER_NAME (implementation_template));
9596 tree sub = TREE_VALUE (subs);
9598 /* If the superclass does not conform to the protocols
9599 inherited by P, then we must! */
9600 if (!super_class || !conforms_to_protocol (super_class, sub))
9601 check_protocol (sub, type, name);
9602 subs = TREE_CHAIN (subs);
9607 /* Check whether the current interface (accessible via
9608 'objc_implementation_context') actually implements the protocols listed
9612 check_protocols (tree proto_list, const char *type, tree name)
9614 for ( ; proto_list; proto_list = TREE_CHAIN (proto_list))
9616 tree p = TREE_VALUE (proto_list);
9618 check_protocol (p, type, name);
9622 /* Make sure that the class CLASS_NAME is defined CODE says which kind
9623 of thing CLASS_NAME ought to be. It can be CLASS_INTERFACE_TYPE,
9624 CLASS_IMPLEMENTATION_TYPE, CATEGORY_INTERFACE_TYPE, or
9625 CATEGORY_IMPLEMENTATION_TYPE. For a CATEGORY_INTERFACE_TYPE,
9626 SUPER_NAME is the name of the category. For a class extension,
9627 CODE is CATEGORY_INTERFACE_TYPE and SUPER_NAME is NULL_TREE. */
9629 start_class (enum tree_code code, tree class_name, tree super_name,
9630 tree protocol_list, tree attributes)
9632 tree klass = NULL_TREE;
9636 if (current_namespace != global_namespace)
9638 error ("Objective-C declarations may only appear in global scope");
9640 #endif /* OBJCPLUS */
9642 if (objc_implementation_context)
9644 warning (0, "%<@end%> missing in implementation context");
9645 finish_class (objc_implementation_context);
9646 objc_ivar_chain = NULL_TREE;
9647 objc_implementation_context = NULL_TREE;
9650 /* If this is a class extension, we'll be "reopening" the existing
9651 CLASS_INTERFACE_TYPE, so in that case there is no need to create
9653 if (code != CATEGORY_INTERFACE_TYPE || super_name != NULL_TREE)
9655 klass = make_node (code);
9656 TYPE_LANG_SLOT_1 (klass) = make_tree_vec (CLASS_LANG_SLOT_ELTS);
9659 /* Check for existence of the super class, if one was specified. Note
9660 that we must have seen an @interface, not just a @class. If we
9661 are looking at a @compatibility_alias, traverse it first. */
9662 if ((code == CLASS_INTERFACE_TYPE || code == CLASS_IMPLEMENTATION_TYPE)
9665 tree super = objc_is_class_name (super_name);
9666 tree super_interface = NULL_TREE;
9669 super_interface = lookup_interface (super);
9671 if (!super_interface)
9673 error ("cannot find interface declaration for %qE, superclass of %qE",
9674 super ? super : super_name,
9676 super_name = NULL_TREE;
9680 if (TREE_DEPRECATED (super_interface))
9681 warning (OPT_Wdeprecated_declarations, "class %qE is deprecated",
9687 if (code != CATEGORY_INTERFACE_TYPE || super_name != NULL_TREE)
9689 CLASS_NAME (klass) = class_name;
9690 CLASS_SUPER_NAME (klass) = super_name;
9691 CLASS_CLS_METHODS (klass) = NULL_TREE;
9694 if (! objc_is_class_name (class_name)
9695 && (decl = lookup_name (class_name)))
9697 error ("%qE redeclared as different kind of symbol",
9699 error ("previous declaration of %q+D",
9705 case CLASS_IMPLEMENTATION_TYPE:
9709 for (chain = implemented_classes; chain; chain = TREE_CHAIN (chain))
9710 if (TREE_VALUE (chain) == class_name)
9712 error ("reimplementation of class %qE",
9714 /* TODO: error message saying where it was previously
9718 if (chain == NULL_TREE)
9719 implemented_classes = tree_cons (NULL_TREE, class_name,
9720 implemented_classes);
9723 /* Reset for multiple classes per file. */
9726 objc_implementation_context = klass;
9728 /* Lookup the interface for this implementation. */
9730 if (!(implementation_template = lookup_interface (class_name)))
9732 warning (0, "cannot find interface declaration for %qE",
9734 add_class (implementation_template = objc_implementation_context,
9738 /* If a super class has been specified in the implementation,
9739 insure it conforms to the one specified in the interface. */
9742 && (super_name != CLASS_SUPER_NAME (implementation_template)))
9744 tree previous_name = CLASS_SUPER_NAME (implementation_template);
9745 error ("conflicting super class name %qE",
9748 error ("previous declaration of %qE", previous_name);
9750 error ("previous declaration");
9753 else if (! super_name)
9755 CLASS_SUPER_NAME (objc_implementation_context)
9756 = CLASS_SUPER_NAME (implementation_template);
9760 case CLASS_INTERFACE_TYPE:
9761 if (lookup_interface (class_name))
9763 error ("duplicate interface declaration for class %qE", class_name);
9765 warning (0, "duplicate interface declaration for class %qE", class_name);
9768 add_class (klass, class_name);
9771 CLASS_PROTOCOL_LIST (klass)
9772 = lookup_and_install_protocols (protocol_list, /* definition_required */ true);
9774 /* Determine if 'deprecated', the only attribute we recognize
9775 for classes, was used. Ignore all other attributes for now,
9776 but store them in the klass. */
9780 for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute))
9782 tree name = TREE_PURPOSE (attribute);
9784 if (is_attribute_p ("deprecated", name))
9785 TREE_DEPRECATED (klass) = 1;
9787 warning (OPT_Wattributes, "%qE attribute directive ignored", name);
9789 TYPE_ATTRIBUTES (klass) = attributes;
9793 case CATEGORY_INTERFACE_TYPE:
9795 tree class_category_is_assoc_with;
9797 /* For a category, class_name is really the name of the class that
9798 the following set of methods will be associated with. We must
9799 find the interface so that can derive the objects template. */
9800 if (!(class_category_is_assoc_with = lookup_interface (class_name)))
9802 error ("cannot find interface declaration for %qE",
9804 exit (FATAL_EXIT_CODE);
9808 if (TREE_DEPRECATED (class_category_is_assoc_with))
9809 warning (OPT_Wdeprecated_declarations, "class %qE is deprecated",
9812 if (super_name == NULL_TREE)
9814 /* This is a class extension. Get the original
9815 interface, and continue working on it. */
9816 objc_in_class_extension = true;
9817 klass = class_category_is_assoc_with;
9821 /* Append protocols to the original protocol
9823 CLASS_PROTOCOL_LIST (klass)
9824 = chainon (CLASS_PROTOCOL_LIST (klass),
9825 lookup_and_install_protocols
9827 /* definition_required */ true));
9832 add_category (class_category_is_assoc_with, klass);
9835 CLASS_PROTOCOL_LIST (klass)
9836 = lookup_and_install_protocols
9837 (protocol_list, /* definition_required */ true);
9843 case CATEGORY_IMPLEMENTATION_TYPE:
9844 /* Reset for multiple classes per file. */
9847 objc_implementation_context = klass;
9849 /* For a category, class_name is really the name of the class that
9850 the following set of methods will be associated with. We must
9851 find the interface so that can derive the objects template. */
9853 if (!(implementation_template = lookup_interface (class_name)))
9855 error ("cannot find interface declaration for %qE",
9857 exit (FATAL_EXIT_CODE);
9867 continue_class (tree klass)
9869 switch (TREE_CODE (klass))
9871 case CLASS_IMPLEMENTATION_TYPE:
9872 case CATEGORY_IMPLEMENTATION_TYPE:
9874 struct imp_entry *imp_entry;
9876 /* Check consistency of the instance variables. */
9878 if (CLASS_RAW_IVARS (klass))
9879 check_ivars (implementation_template, klass);
9881 /* code generation */
9883 push_lang_context (lang_name_c);
9885 build_private_template (implementation_template);
9886 uprivate_record = CLASS_STATIC_TEMPLATE (implementation_template);
9887 objc_instance_type = build_pointer_type (uprivate_record);
9889 imp_entry = ggc_alloc_imp_entry ();
9891 imp_entry->next = imp_list;
9892 imp_entry->imp_context = klass;
9893 imp_entry->imp_template = implementation_template;
9895 synth_forward_declarations ();
9896 imp_entry->class_decl = UOBJC_CLASS_decl;
9897 imp_entry->meta_decl = UOBJC_METACLASS_decl;
9898 imp_entry->has_cxx_cdtors = 0;
9900 /* Append to front and increment count. */
9901 imp_list = imp_entry;
9902 if (TREE_CODE (klass) == CLASS_IMPLEMENTATION_TYPE)
9907 pop_lang_context ();
9908 #endif /* OBJCPLUS */
9910 return get_class_ivars (implementation_template, true);
9913 case CLASS_INTERFACE_TYPE:
9915 if (objc_in_class_extension)
9918 push_lang_context (lang_name_c);
9919 #endif /* OBJCPLUS */
9920 objc_collecting_ivars = 1;
9921 build_private_template (klass);
9922 objc_collecting_ivars = 0;
9924 pop_lang_context ();
9925 #endif /* OBJCPLUS */
9930 return error_mark_node;
9934 /* This routine builds name of the setter synthesized function. */
9936 objc_build_property_setter_name (tree ident)
9938 /* TODO: Use alloca to allocate buffer of appropriate size. */
9939 static char string[BUFSIZE];
9940 sprintf (string, "set%s:", IDENTIFIER_POINTER (ident));
9941 string[3] = TOUPPER (string[3]);
9945 /* This routine prepares the declarations of the property accessor
9946 helper functions (objc_getProperty(), etc) that are used when
9947 @synthesize is used. */
9949 build_objc_property_accessor_helpers (void)
9953 /* Declare the following function:
9955 objc_getProperty (id self, SEL _cmd,
9956 ptrdiff_t offset, BOOL is_atomic); */
9957 type = build_function_type_list (objc_object_type,
9963 objc_getProperty_decl = add_builtin_function ("objc_getProperty",
9964 type, 0, NOT_BUILT_IN,
9966 TREE_NOTHROW (objc_getProperty_decl) = 0;
9968 /* Declare the following function:
9970 objc_setProperty (id self, SEL _cmd,
9971 ptrdiff_t offset, id new_value,
9972 BOOL is_atomic, BOOL should_copy); */
9973 type = build_function_type_list (void_type_node,
9981 objc_setProperty_decl = add_builtin_function ("objc_setProperty",
9982 type, 0, NOT_BUILT_IN,
9984 TREE_NOTHROW (objc_setProperty_decl) = 0;
9986 /* This is the type of all of the following functions
9987 (objc_copyStruct(), objc_getPropertyStruct() and
9988 objc_setPropertyStruct()). */
9989 type = build_function_type_list (void_type_node,
9991 const_ptr_type_node,
9997 if (flag_next_runtime)
9999 /* Declare the following function:
10001 objc_copyStruct (void *destination, const void *source,
10002 ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */
10003 objc_copyStruct_decl = add_builtin_function ("objc_copyStruct",
10004 type, 0, NOT_BUILT_IN,
10006 TREE_NOTHROW (objc_copyStruct_decl) = 0;
10007 objc_getPropertyStruct_decl = NULL_TREE;
10008 objc_setPropertyStruct_decl = NULL_TREE;
10012 objc_copyStruct_decl = NULL_TREE;
10014 /* Declare the following function:
10016 objc_getPropertyStruct (void *destination, const void *source,
10017 ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */
10018 objc_getPropertyStruct_decl = add_builtin_function ("objc_getPropertyStruct",
10019 type, 0, NOT_BUILT_IN,
10021 TREE_NOTHROW (objc_getPropertyStruct_decl) = 0;
10022 /* Declare the following function:
10024 objc_setPropertyStruct (void *destination, const void *source,
10025 ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */
10026 objc_setPropertyStruct_decl = add_builtin_function ("objc_setPropertyStruct",
10027 type, 0, NOT_BUILT_IN,
10029 TREE_NOTHROW (objc_setPropertyStruct_decl) = 0;
10033 /* This looks up an ivar in a class (including superclasses). */
10035 lookup_ivar (tree interface, tree instance_variable_name)
10041 for (decl_chain = CLASS_IVARS (interface); decl_chain; decl_chain = DECL_CHAIN (decl_chain))
10042 if (DECL_NAME (decl_chain) == instance_variable_name)
10045 /* Not found. Search superclass if any. */
10046 if (CLASS_SUPER_NAME (interface))
10047 interface = lookup_interface (CLASS_SUPER_NAME (interface));
10053 /* This routine synthesizes a 'getter' method. This is only called
10054 for @synthesize properties. */
10056 objc_synthesize_getter (tree klass, tree class_methods ATTRIBUTE_UNUSED, tree property)
10058 location_t location = DECL_SOURCE_LOCATION (property);
10063 /* If user has implemented a getter with same name then do nothing. */
10064 if (lookup_method (CLASS_NST_METHODS (objc_implementation_context),
10065 PROPERTY_GETTER_NAME (property)))
10068 /* Find declaration of the property getter in the interface (or
10069 superclass, or protocol). There must be one. */
10070 decl = lookup_method_static (klass, PROPERTY_GETTER_NAME (property), 0);
10072 /* If one not declared in the interface, this condition has already
10073 been reported as user error (because property was not declared in
10078 /* Adapt the 'decl'. Use the source location of the @synthesize
10079 statement for error messages. */
10080 decl = copy_node (decl);
10081 DECL_SOURCE_LOCATION (decl) = location;
10083 objc_start_method_definition (false /* is_class_method */, decl, NULL_TREE);
10084 body = c_begin_compound_stmt (true);
10086 /* Now we need to decide how we build the getter. There are three
10089 for 'copy' or 'retain' properties we need to use the
10090 objc_getProperty() accessor helper which knows about retain and
10091 copy. It supports both 'nonatomic' and 'atomic' access.
10093 for 'nonatomic, assign' properties we can access the instance
10094 variable directly. 'nonatomic' means we don't have to use locks,
10095 and 'assign' means we don't have to worry about retain or copy.
10096 If you combine the two, it means we can just access the instance
10099 for 'atomic, assign' properties we use objc_copyStruct() (for the
10100 next runtime) or objc_getPropertyStruct() (for the GNU runtime). */
10101 switch (PROPERTY_ASSIGN_SEMANTICS (property))
10103 case OBJC_PROPERTY_RETAIN:
10104 case OBJC_PROPERTY_COPY:
10106 /* We build "return objc_getProperty (self, _cmd, offset, is_atomic);" */
10107 tree cmd, ivar, offset, is_atomic;
10108 cmd = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
10110 /* Find the ivar to compute the offset. */
10111 ivar = lookup_ivar (klass, PROPERTY_IVAR_NAME (property));
10112 if (!ivar || is_private (ivar))
10114 /* This should never happen. */
10115 error_at (location,
10116 "can not find instance variable associated with property");
10117 ret_val = error_mark_node;
10120 offset = byte_position (ivar);
10122 if (PROPERTY_NONATOMIC (property))
10123 is_atomic = boolean_false_node;
10125 is_atomic = boolean_true_node;
10127 ret_val = build_function_call
10129 /* Function prototype. */
10130 objc_getProperty_decl,
10132 tree_cons /* self */
10133 (NULL_TREE, self_decl,
10134 tree_cons /* _cmd */
10136 tree_cons /* offset */
10137 (NULL_TREE, offset,
10138 tree_cons /* is_atomic */
10139 (NULL_TREE, is_atomic, NULL_TREE)))));
10142 case OBJC_PROPERTY_ASSIGN:
10143 if (PROPERTY_NONATOMIC (property))
10145 /* We build "return self->PROPERTY_IVAR_NAME;" */
10146 ret_val = objc_lookup_ivar (NULL_TREE, PROPERTY_IVAR_NAME (property));
10152 <property type> __objc_property_temp;
10153 objc_getPropertyStruct (&__objc_property_temp,
10154 &(self->PROPERTY_IVAR_NAME),
10155 sizeof (type of self->PROPERTY_IVAR_NAME),
10158 return __objc_property_temp;
10160 For the NeXT runtime, we need to use objc_copyStruct
10161 instead of objc_getPropertyStruct. */
10162 tree objc_property_temp_decl, function_decl, function_call;
10163 tree size_of, is_atomic;
10165 objc_property_temp_decl = objc_create_temporary_var (TREE_TYPE (property), "__objc_property_temp");
10166 DECL_SOURCE_LOCATION (objc_property_temp_decl) = location;
10167 objc_property_temp_decl = lang_hooks.decls.pushdecl (objc_property_temp_decl);
10169 /* sizeof (ivar type). Since the ivar and the property have
10170 the same type, there is no need to lookup the ivar. */
10171 size_of = c_sizeof_or_alignof_type (location, TREE_TYPE (property),
10172 true /* is_sizeof */,
10173 false /* complain */);
10175 if (PROPERTY_NONATOMIC (property))
10176 is_atomic = boolean_false_node;
10178 is_atomic = boolean_true_node;
10180 if (flag_next_runtime)
10181 function_decl = objc_copyStruct_decl;
10183 function_decl = objc_getPropertyStruct_decl;
10185 function_call = build_function_call
10187 /* Function prototype. */
10190 tree_cons /* &__objc_property_temp_decl */
10191 /* Warning: note that using build_fold_addr_expr_loc()
10192 here causes invalid code to be generated. */
10193 (NULL_TREE, build_unary_op (location, ADDR_EXPR, objc_property_temp_decl, 0),
10194 tree_cons /* &(self->PROPERTY_IVAR_NAME); */
10195 (NULL_TREE, build_fold_addr_expr_loc (location,
10197 (NULL_TREE, PROPERTY_IVAR_NAME (property))),
10198 tree_cons /* sizeof (PROPERTY_IVAR) */
10199 (NULL_TREE, size_of,
10200 tree_cons /* is_atomic */
10201 (NULL_TREE, is_atomic,
10202 /* TODO: This is currently ignored by the GNU
10203 runtime, but what about the next one ? */
10204 tree_cons /* has_strong */
10205 (NULL_TREE, boolean_true_node, NULL_TREE))))));
10207 add_stmt (function_call);
10209 ret_val = objc_property_temp_decl;
10213 gcc_unreachable ();
10216 gcc_assert (ret_val);
10219 finish_return_stmt (ret_val);
10221 c_finish_return (location, ret_val, NULL_TREE);
10224 add_stmt (c_end_compound_stmt (location, body, true));
10225 fn = current_function_decl;
10227 finish_function ();
10229 objc_finish_method_definition (fn);
10232 /* This routine synthesizes a 'setter' method. */
10235 objc_synthesize_setter (tree klass, tree class_methods ATTRIBUTE_UNUSED, tree property)
10237 location_t location = DECL_SOURCE_LOCATION (property);
10240 tree new_value, statement;
10242 /* If user has implemented a setter with same name then do nothing. */
10243 if (lookup_method (CLASS_NST_METHODS (objc_implementation_context),
10244 PROPERTY_SETTER_NAME (property)))
10247 /* Find declaration of the property setter in the interface (or
10248 superclass, or protocol). There must be one. */
10249 decl = lookup_method_static (klass, PROPERTY_SETTER_NAME (property), 0);
10251 /* If one not declared in the interface, this condition has already
10252 been reported as user error (because property was not declared in
10257 /* Adapt the 'decl'. Use the source location of the @synthesize
10258 statement for error messages. */
10259 decl = copy_node (decl);
10260 DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (property);
10262 objc_start_method_definition (false /* is_class_method */, decl, NULL_TREE);
10264 body = c_begin_compound_stmt (true);
10266 /* The 'new_value' is the only argument to the method, which is the
10267 3rd argument of the function, after self and _cmd. We use twice
10268 TREE_CHAIN to move forward two arguments. */
10269 new_value = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (current_function_decl)));
10271 /* This would presumably happen if the user has specified a
10272 prototype for the setter that does not have an argument! */
10273 if (new_value == NULL_TREE)
10275 /* TODO: This should be caught much earlier than this. */
10276 error_at (DECL_SOURCE_LOCATION (decl), "invalid setter, it must have one argument");
10277 /* Try to recover somehow. */
10278 new_value = error_mark_node;
10281 /* Now we need to decide how we build the setter. There are three
10284 for 'copy' or 'retain' properties we need to use the
10285 objc_setProperty() accessor helper which knows about retain and
10286 copy. It supports both 'nonatomic' and 'atomic' access.
10288 for 'nonatomic, assign' properties we can access the instance
10289 variable directly. 'nonatomic' means we don't have to use locks,
10290 and 'assign' means we don't have to worry about retain or copy.
10291 If you combine the two, it means we can just access the instance
10294 for 'atomic, assign' properties we use objc_copyStruct() (for the
10295 next runtime) or objc_setPropertyStruct() (for the GNU runtime). */
10296 switch (PROPERTY_ASSIGN_SEMANTICS (property))
10298 case OBJC_PROPERTY_RETAIN:
10299 case OBJC_PROPERTY_COPY:
10301 /* We build "objc_setProperty (self, _cmd, new_value, offset, is_atomic, should_copy);" */
10302 tree cmd, ivar, offset, is_atomic, should_copy;
10303 cmd = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
10305 /* Find the ivar to compute the offset. */
10306 ivar = lookup_ivar (klass, PROPERTY_IVAR_NAME (property));
10307 if (!ivar || is_private (ivar))
10309 error_at (location,
10310 "can not find instance variable associated with property");
10311 statement = error_mark_node;
10314 offset = byte_position (ivar);
10316 if (PROPERTY_NONATOMIC (property))
10317 is_atomic = boolean_false_node;
10319 is_atomic = boolean_true_node;
10321 if (PROPERTY_ASSIGN_SEMANTICS (property) == OBJC_PROPERTY_COPY)
10322 should_copy = boolean_true_node;
10324 should_copy = boolean_false_node;
10326 statement = build_function_call
10328 /* Function prototype. */
10329 objc_setProperty_decl,
10331 tree_cons /* self */
10332 (NULL_TREE, self_decl,
10333 tree_cons /* _cmd */
10335 tree_cons /* offset */
10336 (NULL_TREE, offset,
10337 tree_cons /* new_value */
10338 (NULL_TREE, new_value,
10339 tree_cons /* is_atomic */
10340 (NULL_TREE, is_atomic,
10341 tree_cons /* should_copy */
10342 (NULL_TREE, should_copy, NULL_TREE)))))));
10345 case OBJC_PROPERTY_ASSIGN:
10346 if (PROPERTY_NONATOMIC (property))
10348 /* We build "self->PROPERTY_IVAR_NAME = new_value;" */
10349 statement = build_modify_expr
10351 objc_lookup_ivar (NULL_TREE, PROPERTY_IVAR_NAME (property)),
10352 NULL_TREE, NOP_EXPR,
10353 location, new_value, NULL_TREE);
10359 objc_setPropertyStruct (&(self->PROPERTY_IVAR_NAME),
10361 sizeof (type of self->PROPERTY_IVAR_NAME),
10365 For the NeXT runtime, we need to use objc_copyStruct
10366 instead of objc_getPropertyStruct. */
10367 tree function_decl, size_of, is_atomic;
10369 /* sizeof (ivar type). Since the ivar and the property have
10370 the same type, there is no need to lookup the ivar. */
10371 size_of = c_sizeof_or_alignof_type (location, TREE_TYPE (property),
10372 true /* is_sizeof */,
10373 false /* complain */);
10375 if (PROPERTY_NONATOMIC (property))
10376 is_atomic = boolean_false_node;
10378 is_atomic = boolean_true_node;
10380 if (flag_next_runtime)
10381 function_decl = objc_copyStruct_decl;
10383 function_decl = objc_setPropertyStruct_decl;
10385 statement = build_function_call
10387 /* Function prototype. */
10390 tree_cons /* &(self->PROPERTY_IVAR_NAME); */
10391 (NULL_TREE, build_fold_addr_expr_loc (location,
10393 (NULL_TREE, PROPERTY_IVAR_NAME (property))),
10394 tree_cons /* &new_value */
10395 (NULL_TREE, build_fold_addr_expr_loc (location, new_value),
10396 tree_cons /* sizeof (PROPERTY_IVAR) */
10397 (NULL_TREE, size_of,
10398 tree_cons /* is_atomic */
10399 (NULL_TREE, is_atomic,
10400 /* TODO: This is currently ignored by the GNU
10401 runtime, but what about the next one ? */
10402 tree_cons /* has_strong */
10403 (NULL_TREE, boolean_true_node, NULL_TREE))))));
10407 gcc_unreachable ();
10409 gcc_assert (statement);
10411 add_stmt (statement);
10412 add_stmt (c_end_compound_stmt (location, body, true));
10413 fn = current_function_decl;
10415 finish_function ();
10417 objc_finish_method_definition (fn);
10420 /* This function is a sub-routine of objc_add_synthesize_declaration.
10421 It is called for each property to synthesize once we have
10422 determined that the context is Ok. */
10424 objc_add_synthesize_declaration_for_property (location_t location, tree interface,
10425 tree property_name, tree ivar_name)
10427 /* Find the @property declaration. */
10431 /* Check that synthesize or dynamic has not already been used for
10432 the same property. */
10433 for (property = IMPL_PROPERTY_DECL (objc_implementation_context); property; property = TREE_CHAIN (property))
10434 if (PROPERTY_NAME (property) == property_name)
10436 location_t original_location = DECL_SOURCE_LOCATION (property);
10438 if (PROPERTY_DYNAMIC (property))
10439 error_at (location, "property %qs already specified in %<@dynamic%>",
10440 IDENTIFIER_POINTER (property_name));
10442 error_at (location, "property %qs already specified in %<@synthesize%>",
10443 IDENTIFIER_POINTER (property_name));
10445 if (original_location != UNKNOWN_LOCATION)
10446 inform (original_location, "originally specified here");
10450 /* Check that the property is declared in the interface. It could
10451 also be declared in a superclass or protocol. */
10452 property = lookup_property (interface, property_name);
10456 error_at (location, "no declaration of property %qs found in the interface",
10457 IDENTIFIER_POINTER (property_name));
10462 /* We have to copy the property, because we want to chain it to
10463 the implementation context, and we want to store the source
10464 location of the @synthesize, not of the original
10466 property = copy_node (property);
10467 DECL_SOURCE_LOCATION (property) = location;
10470 /* Determine PROPERTY_IVAR_NAME. */
10471 if (ivar_name == NULL_TREE)
10472 ivar_name = property_name;
10474 /* Check that the instance variable exists. You can only use an
10475 instance variable from the same class, not one from the
10476 superclass (this makes sense as it allows us to check that an
10477 instance variable is only used in one synthesized property). */
10479 tree ivar = is_ivar (CLASS_IVARS (interface), ivar_name);
10483 error_at (location, "ivar %qs used by %<@synthesize%> declaration must be an existing ivar",
10484 IDENTIFIER_POINTER (property_name));
10488 if (DECL_BIT_FIELD_TYPE (ivar))
10489 type_of_ivar = DECL_BIT_FIELD_TYPE (ivar);
10491 type_of_ivar = TREE_TYPE (ivar);
10493 /* If the instance variable has a different C type, we throw an error ... */
10494 if (!comptypes (TREE_TYPE (property), type_of_ivar)
10495 /* ... unless the property is readonly, in which case we allow
10496 the instance variable to be more specialized (this means we
10497 can generate the getter all right and it works). */
10498 && (!PROPERTY_READONLY (property)
10499 || !objc_compare_types (TREE_TYPE (property),
10500 type_of_ivar, -5, NULL_TREE)))
10502 location_t original_location = DECL_SOURCE_LOCATION (ivar);
10504 error_at (location, "property %qs is using instance variable %qs of incompatible type",
10505 IDENTIFIER_POINTER (property_name),
10506 IDENTIFIER_POINTER (ivar_name));
10508 if (original_location != UNKNOWN_LOCATION)
10509 inform (original_location, "originally specified here");
10512 /* If the instance variable is a bitfield, the property must be
10513 'assign', 'nonatomic' because the runtime getter/setter helper
10514 do not work with bitfield instance variables. */
10515 if (DECL_BIT_FIELD_TYPE (ivar))
10517 /* If there is an error, we return and not generate any
10518 getter/setter because trying to set up the runtime
10519 getter/setter helper calls with bitfields is at high risk
10522 if (PROPERTY_ASSIGN_SEMANTICS (property) != OBJC_PROPERTY_ASSIGN)
10524 location_t original_location = DECL_SOURCE_LOCATION (ivar);
10526 error_at (location, "'assign' property %qs is using bit-field instance variable %qs",
10527 IDENTIFIER_POINTER (property_name),
10528 IDENTIFIER_POINTER (ivar_name));
10530 if (original_location != UNKNOWN_LOCATION)
10531 inform (original_location, "originally specified here");
10535 if (!PROPERTY_NONATOMIC (property))
10537 location_t original_location = DECL_SOURCE_LOCATION (ivar);
10539 error_at (location, "'atomic' property %qs is using bit-field instance variable %qs",
10540 IDENTIFIER_POINTER (property_name),
10541 IDENTIFIER_POINTER (ivar_name));
10543 if (original_location != UNKNOWN_LOCATION)
10544 inform (original_location, "originally specified here");
10550 /* Check that no other property is using the same instance
10552 for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x))
10553 if (PROPERTY_IVAR_NAME (x) == ivar_name)
10555 location_t original_location = DECL_SOURCE_LOCATION (x);
10557 error_at (location, "property %qs is using the same instance variable as property %qs",
10558 IDENTIFIER_POINTER (property_name),
10559 IDENTIFIER_POINTER (PROPERTY_NAME (x)));
10561 if (original_location != UNKNOWN_LOCATION)
10562 inform (original_location, "originally specified here");
10564 /* We keep going on. This won't cause the compiler to fail;
10565 the failure would most likely be at runtime. */
10568 /* Note that a @synthesize (and only a @synthesize) always sets
10569 PROPERTY_IVAR_NAME to a non-NULL_TREE. You can recognize a
10570 @synthesize by that. */
10571 PROPERTY_IVAR_NAME (property) = ivar_name;
10573 /* PROPERTY_SETTER_NAME and PROPERTY_GETTER_NAME are copied from the
10574 original declaration; they are always set (with the exception of
10575 PROPERTY_SETTER_NAME not being set if PROPERTY_READONLY == 1). */
10577 /* Add the property to the list of properties for current implementation. */
10578 TREE_CHAIN (property) = IMPL_PROPERTY_DECL (objc_implementation_context);
10579 IMPL_PROPERTY_DECL (objc_implementation_context) = property;
10581 /* Note how we don't actually synthesize the getter/setter here; it
10582 would be very natural, but we may miss the fact that the user has
10583 implemented his own getter/setter later on in the @implementation
10584 (in which case we shouldn't generate getter/setter). We wait
10585 until we have parsed it all before generating the code. */
10588 /* This function is called by the parser after a @synthesize
10589 expression is parsed. 'location' is the location of the
10590 @synthesize expression, and 'property_and_ivar_list' is a chained
10591 list of the property and ivar names. */
10593 objc_add_synthesize_declaration (location_t location, tree property_and_ivar_list)
10595 tree interface, chain;
10597 if (flag_objc1_only)
10598 error_at (input_location, "%<@synthesize%> is not available in Objective-C 1.0");
10600 if (property_and_ivar_list == error_mark_node)
10603 if (!objc_implementation_context)
10605 /* We can get here only in Objective-C; the Objective-C++ parser
10606 detects the problem while parsing, outputs the error
10607 "misplaced '@synthesize' Objective-C++ construct" and skips
10608 the declaration. */
10609 error_at (location, "%<@synthesize%> not in @implementation context");
10613 if (TREE_CODE (objc_implementation_context) == CATEGORY_IMPLEMENTATION_TYPE)
10615 error_at (location, "%<@synthesize%> can not be used in categories");
10619 interface = lookup_interface (CLASS_NAME (objc_implementation_context));
10622 /* I can't see how this could happen, but it is good as a safety check. */
10623 error_at (location,
10624 "%<@synthesize%> requires the @interface of the class to be available");
10628 /* Now, iterate over the properties and do each of them. */
10629 for (chain = property_and_ivar_list; chain; chain = TREE_CHAIN (chain))
10631 objc_add_synthesize_declaration_for_property (location, interface, TREE_VALUE (chain),
10632 TREE_PURPOSE (chain));
10636 /* This function is a sub-routine of objc_add_dynamic_declaration. It
10637 is called for each property to mark as dynamic once we have
10638 determined that the context is Ok. */
10640 objc_add_dynamic_declaration_for_property (location_t location, tree interface,
10641 tree property_name)
10643 /* Find the @property declaration. */
10646 /* Check that synthesize or dynamic has not already been used for
10647 the same property. */
10648 for (property = IMPL_PROPERTY_DECL (objc_implementation_context); property; property = TREE_CHAIN (property))
10649 if (PROPERTY_NAME (property) == property_name)
10651 location_t original_location = DECL_SOURCE_LOCATION (property);
10653 if (PROPERTY_DYNAMIC (property))
10654 error_at (location, "property %qs already specified in %<@dynamic%>",
10655 IDENTIFIER_POINTER (property_name));
10657 error_at (location, "property %qs already specified in %<@synthesize%>",
10658 IDENTIFIER_POINTER (property_name));
10660 if (original_location != UNKNOWN_LOCATION)
10661 inform (original_location, "originally specified here");
10665 /* Check that the property is declared in the interface. It could
10666 also be declared in a superclass or protocol. */
10667 property = lookup_property (interface, property_name);
10671 error_at (location, "no declaration of property %qs found in the interface",
10672 IDENTIFIER_POINTER (property_name));
10677 /* We have to copy the property, because we want to chain it to
10678 the implementation context, and we want to store the source
10679 location of the @synthesize, not of the original
10681 property = copy_node (property);
10682 DECL_SOURCE_LOCATION (property) = location;
10685 /* Note that a @dynamic (and only a @dynamic) always sets
10686 PROPERTY_DYNAMIC to 1. You can recognize a @dynamic by that.
10687 (actually, as explained above, PROPERTY_DECL generated by
10688 @property and associated with a @dynamic property are also marked
10689 as PROPERTY_DYNAMIC). */
10690 PROPERTY_DYNAMIC (property) = 1;
10692 /* Add the property to the list of properties for current implementation. */
10693 TREE_CHAIN (property) = IMPL_PROPERTY_DECL (objc_implementation_context);
10694 IMPL_PROPERTY_DECL (objc_implementation_context) = property;
10697 /* This function is called by the parser after a @dynamic expression
10698 is parsed. 'location' is the location of the @dynamic expression,
10699 and 'property_list' is a chained list of all the property
10702 objc_add_dynamic_declaration (location_t location, tree property_list)
10704 tree interface, chain;
10706 if (flag_objc1_only)
10707 error_at (input_location, "%<@dynamic%> is not available in Objective-C 1.0");
10709 if (property_list == error_mark_node)
10712 if (!objc_implementation_context)
10714 /* We can get here only in Objective-C; the Objective-C++ parser
10715 detects the problem while parsing, outputs the error
10716 "misplaced '@dynamic' Objective-C++ construct" and skips the
10718 error_at (location, "%<@dynamic%> not in @implementation context");
10722 /* @dynamic is allowed in categories. */
10723 switch (TREE_CODE (objc_implementation_context))
10725 case CLASS_IMPLEMENTATION_TYPE:
10726 interface = lookup_interface (CLASS_NAME (objc_implementation_context));
10728 case CATEGORY_IMPLEMENTATION_TYPE:
10729 interface = lookup_category (implementation_template,
10730 CLASS_SUPER_NAME (objc_implementation_context));
10733 gcc_unreachable ();
10738 /* I can't see how this could happen, but it is good as a safety check. */
10739 error_at (location,
10740 "%<@dynamic%> requires the @interface of the class to be available");
10744 /* Now, iterate over the properties and do each of them. */
10745 for (chain = property_list; chain; chain = TREE_CHAIN (chain))
10747 objc_add_dynamic_declaration_for_property (location, interface, TREE_VALUE (chain));
10751 /* Main routine to generate code/data for all the property information for
10752 current implementation (class or category). CLASS is the interface where
10753 ivars are declared. CLASS_METHODS is where methods are found which
10754 could be a class or a category depending on whether we are implementing
10755 property of a class or a category. */
10758 objc_gen_property_data (tree klass, tree class_methods)
10762 for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x))
10764 /* @dynamic property - nothing to check or synthesize. */
10765 if (PROPERTY_DYNAMIC (x))
10768 /* @synthesize property - need to synthesize the accessors. */
10769 if (PROPERTY_IVAR_NAME (x))
10771 objc_synthesize_getter (klass, class_methods, x);
10773 if (PROPERTY_READONLY (x) == 0)
10774 objc_synthesize_setter (klass, class_methods, x);
10779 gcc_unreachable ();
10783 /* This is called once we see the "@end" in an interface/implementation. */
10786 finish_class (tree klass)
10788 switch (TREE_CODE (klass))
10790 case CLASS_IMPLEMENTATION_TYPE:
10792 /* All code generation is done in finish_objc. */
10794 /* Generate what needed for property; setters, getters, etc. */
10795 objc_gen_property_data (implementation_template, implementation_template);
10797 if (implementation_template != objc_implementation_context)
10799 /* Ensure that all method listed in the interface contain bodies. */
10800 check_methods (CLASS_CLS_METHODS (implementation_template),
10801 objc_implementation_context, '+');
10802 check_methods (CLASS_NST_METHODS (implementation_template),
10803 objc_implementation_context, '-');
10805 if (CLASS_PROTOCOL_LIST (implementation_template))
10806 check_protocols (CLASS_PROTOCOL_LIST (implementation_template),
10808 CLASS_NAME (objc_implementation_context));
10812 case CATEGORY_IMPLEMENTATION_TYPE:
10814 tree category = lookup_category (implementation_template, CLASS_SUPER_NAME (klass));
10818 /* Generate what needed for property; setters, getters, etc. */
10819 objc_gen_property_data (implementation_template, category);
10821 /* Ensure all method listed in the interface contain bodies. */
10822 check_methods (CLASS_CLS_METHODS (category),
10823 objc_implementation_context, '+');
10824 check_methods (CLASS_NST_METHODS (category),
10825 objc_implementation_context, '-');
10827 if (CLASS_PROTOCOL_LIST (category))
10828 check_protocols (CLASS_PROTOCOL_LIST (category),
10830 CLASS_SUPER_NAME (objc_implementation_context));
10834 case CLASS_INTERFACE_TYPE:
10835 case CATEGORY_INTERFACE_TYPE:
10836 case PROTOCOL_INTERFACE_TYPE:
10838 /* Process properties of the class. */
10840 for (x = CLASS_PROPERTY_DECL (objc_interface_context); x; x = TREE_CHAIN (x))
10842 /* Now we check that the appropriate getter is declared,
10843 and if not, we declare one ourselves. */
10844 tree getter_decl = lookup_method (CLASS_NST_METHODS (klass),
10845 PROPERTY_GETTER_NAME (x));
10849 /* TODO: Check that the declaration is consistent with the property. */
10854 /* Generate an instance method declaration for the
10855 getter; for example "- (id) name;". In general it
10856 will be of the form
10857 -(type)property_getter_name; */
10858 tree rettype = build_tree_list (NULL_TREE, TREE_TYPE (x));
10859 getter_decl = build_method_decl (INSTANCE_METHOD_DECL,
10860 rettype, PROPERTY_GETTER_NAME (x),
10862 if (PROPERTY_OPTIONAL (x))
10863 objc_add_method (objc_interface_context, getter_decl, false, true);
10865 objc_add_method (objc_interface_context, getter_decl, false, false);
10866 TREE_DEPRECATED (getter_decl) = TREE_DEPRECATED (x);
10867 METHOD_PROPERTY_CONTEXT (getter_decl) = x;
10870 if (PROPERTY_READONLY (x) == 0)
10872 /* Now we check that the appropriate setter is declared,
10873 and if not, we declare on ourselves. */
10874 tree setter_decl = lookup_method (CLASS_NST_METHODS (klass),
10875 PROPERTY_SETTER_NAME (x));
10879 /* TODO: Check that the declaration is consistent with the property. */
10884 /* The setter name is something like 'setName:'.
10885 We need the substring 'setName' to build the
10886 method declaration due to how the declaration
10887 works. TODO: build_method_decl() will then
10888 generate back 'setName:' from 'setName'; it
10889 would be more efficient to hook into there. */
10890 const char *full_setter_name = IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x));
10891 size_t length = strlen (full_setter_name);
10892 char *setter_name = (char *) alloca (length);
10893 tree ret_type, selector, arg_type, arg_name;
10895 strcpy (setter_name, full_setter_name);
10896 setter_name[length - 1] = '\0';
10897 ret_type = build_tree_list (NULL_TREE, void_type_node);
10898 arg_type = build_tree_list (NULL_TREE, TREE_TYPE (x));
10899 arg_name = get_identifier ("_value");
10900 selector = objc_build_keyword_decl (get_identifier (setter_name),
10901 arg_type, arg_name, NULL);
10902 setter_decl = build_method_decl (INSTANCE_METHOD_DECL,
10903 ret_type, selector,
10904 build_tree_list (NULL_TREE, NULL_TREE),
10906 if (PROPERTY_OPTIONAL (x))
10907 objc_add_method (objc_interface_context, setter_decl, false, true);
10909 objc_add_method (objc_interface_context, setter_decl, false, false);
10910 TREE_DEPRECATED (setter_decl) = TREE_DEPRECATED (x);
10911 METHOD_PROPERTY_CONTEXT (setter_decl) = x;
10918 gcc_unreachable ();
10924 add_protocol (tree protocol)
10926 /* Put protocol on list in reverse order. */
10927 TREE_CHAIN (protocol) = protocol_chain;
10928 protocol_chain = protocol;
10929 return protocol_chain;
10932 /* Check that a protocol is defined, and, recursively, that all
10933 protocols that this protocol conforms to are defined too. */
10935 check_that_protocol_is_defined (tree protocol)
10937 if (!PROTOCOL_DEFINED (protocol))
10938 warning (0, "definition of protocol %qE not found",
10939 PROTOCOL_NAME (protocol));
10941 /* If the protocol itself conforms to other protocols, check them
10942 too, recursively. */
10943 if (PROTOCOL_LIST (protocol))
10947 for (p = PROTOCOL_LIST (p); p; p = TREE_CHAIN (p))
10948 check_that_protocol_is_defined (TREE_VALUE (p));
10952 /* Looks up a protocol. If 'warn_if_deprecated' is true, a warning is
10953 emitted if the protocol is deprecated. If 'definition_required' is
10954 true, a warning is emitted if a full @protocol definition has not
10957 lookup_protocol (tree ident, bool warn_if_deprecated, bool definition_required)
10961 for (chain = protocol_chain; chain; chain = TREE_CHAIN (chain))
10962 if (ident == PROTOCOL_NAME (chain))
10964 if (warn_if_deprecated && TREE_DEPRECATED (chain))
10966 /* It would be nice to use warn_deprecated_use() here, but
10967 we are using TREE_CHAIN (which is supposed to be the
10968 TYPE_STUB_DECL for a TYPE) for something different. */
10969 warning (OPT_Wdeprecated_declarations, "protocol %qE is deprecated",
10970 PROTOCOL_NAME (chain));
10973 if (definition_required)
10974 check_that_protocol_is_defined (chain);
10982 /* This function forward declares the protocols named by NAMES. If
10983 they are already declared or defined, the function has no effect. */
10986 objc_declare_protocols (tree names, tree attributes)
10989 bool deprecated = false;
10992 if (current_namespace != global_namespace) {
10993 error ("Objective-C declarations may only appear in global scope");
10995 #endif /* OBJCPLUS */
10997 /* Determine if 'deprecated', the only attribute we recognize for
10998 protocols, was used. Ignore all other attributes. */
11002 for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute))
11004 tree name = TREE_PURPOSE (attribute);
11006 if (is_attribute_p ("deprecated", name))
11009 warning (OPT_Wattributes, "%qE attribute directive ignored", name);
11013 for (list = names; list; list = TREE_CHAIN (list))
11015 tree name = TREE_VALUE (list);
11017 if (lookup_protocol (name, /* warn if deprecated */ false,
11018 /* definition_required */ false) == NULL_TREE)
11020 tree protocol = make_node (PROTOCOL_INTERFACE_TYPE);
11022 TYPE_LANG_SLOT_1 (protocol)
11023 = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS);
11024 PROTOCOL_NAME (protocol) = name;
11025 PROTOCOL_LIST (protocol) = NULL_TREE;
11026 add_protocol (protocol);
11027 PROTOCOL_DEFINED (protocol) = 0;
11028 PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
11032 TYPE_ATTRIBUTES (protocol) = attributes;
11034 TREE_DEPRECATED (protocol) = 1;
11041 start_protocol (enum tree_code code, tree name, tree list, tree attributes)
11044 bool deprecated = false;
11047 if (current_namespace != global_namespace) {
11048 error ("Objective-C declarations may only appear in global scope");
11050 #endif /* OBJCPLUS */
11052 /* Determine if 'deprecated', the only attribute we recognize for
11053 protocols, was used. Ignore all other attributes. */
11057 for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute))
11059 tree name = TREE_PURPOSE (attribute);
11061 if (is_attribute_p ("deprecated", name))
11064 warning (OPT_Wattributes, "%qE attribute directive ignored", name);
11068 protocol = lookup_protocol (name, /* warn_if_deprecated */ false,
11069 /* definition_required */ false);
11073 protocol = make_node (code);
11074 TYPE_LANG_SLOT_1 (protocol) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS);
11076 PROTOCOL_NAME (protocol) = name;
11077 PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list, /* definition_required */ false);
11078 add_protocol (protocol);
11079 PROTOCOL_DEFINED (protocol) = 1;
11080 PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
11082 check_protocol_recursively (protocol, list);
11084 else if (! PROTOCOL_DEFINED (protocol))
11086 PROTOCOL_DEFINED (protocol) = 1;
11087 PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list, /* definition_required */ false);
11089 check_protocol_recursively (protocol, list);
11093 warning (0, "duplicate declaration for protocol %qE",
11099 TYPE_ATTRIBUTES (protocol) = attributes;
11101 TREE_DEPRECATED (protocol) = 1;
11108 /* "Encode" a data type into a string, which grows in util_obstack.
11110 The format is described in gcc/doc/objc.texi, section 'Type
11113 Most of the encode_xxx functions have a 'type' argument, which is
11114 the type to encode, and an integer 'curtype' argument, which is the
11115 index in the encoding string of the beginning of the encoding of
11116 the current type, and allows you to find what characters have
11117 already been written for the current type (they are the ones in the
11118 current encoding string starting from 'curtype').
11120 For example, if we are encoding a method which returns 'int' and
11121 takes a 'char **' argument, then when we get to the point of
11122 encoding the 'char **' argument, the encoded string already
11123 contains 'i12@0:4' (assuming a pointer size of 4 bytes). So,
11124 'curtype' will be set to 7 when starting to encode 'char **'.
11125 During the whole of the encoding of 'char **', 'curtype' will be
11126 fixed at 7, so the routine encoding the second pointer can find out
11127 that it's actually encoding a pointer to a pointer by looking
11128 backwards at what has already been encoded for the current type,
11129 and seeing there is a "^" (meaning a pointer) in there.
11133 /* Encode type qualifiers encodes one of the "PQ" Objective-C
11134 keywords, ie 'in', 'out', 'inout', 'bycopy', 'byref', 'oneway'.
11135 'const', instead, is encoded directly as part of the type.
11139 encode_type_qualifiers (tree declspecs)
11143 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
11145 /* FIXME: Shouldn't we use token->keyword here ? */
11146 if (ridpointers[(int) RID_IN] == TREE_VALUE (spec))
11147 obstack_1grow (&util_obstack, 'n');
11148 else if (ridpointers[(int) RID_INOUT] == TREE_VALUE (spec))
11149 obstack_1grow (&util_obstack, 'N');
11150 else if (ridpointers[(int) RID_OUT] == TREE_VALUE (spec))
11151 obstack_1grow (&util_obstack, 'o');
11152 else if (ridpointers[(int) RID_BYCOPY] == TREE_VALUE (spec))
11153 obstack_1grow (&util_obstack, 'O');
11154 else if (ridpointers[(int) RID_BYREF] == TREE_VALUE (spec))
11155 obstack_1grow (&util_obstack, 'R');
11156 else if (ridpointers[(int) RID_ONEWAY] == TREE_VALUE (spec))
11157 obstack_1grow (&util_obstack, 'V');
11159 gcc_unreachable ();
11163 /* Determine if a pointee is marked read-only. Only used by the NeXT
11164 runtime to be compatible with gcc-3.3. */
11167 pointee_is_readonly (tree pointee)
11169 while (POINTER_TYPE_P (pointee))
11170 pointee = TREE_TYPE (pointee);
11172 return TYPE_READONLY (pointee);
11175 /* Encode a pointer type. */
11178 encode_pointer (tree type, int curtype, int format)
11180 tree pointer_to = TREE_TYPE (type);
11182 if (flag_next_runtime)
11184 /* This code is used to be compatible with gcc-3.3. */
11185 /* For historical/compatibility reasons, the read-only qualifier
11186 of the pointee gets emitted _before_ the '^'. The read-only
11187 qualifier of the pointer itself gets ignored, _unless_ we are
11188 looking at a typedef! Also, do not emit the 'r' for anything
11189 but the outermost type! */
11190 if (!generating_instance_variables
11191 && (obstack_object_size (&util_obstack) - curtype <= 1)
11192 && (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
11193 ? TYPE_READONLY (type)
11194 : pointee_is_readonly (pointer_to)))
11195 obstack_1grow (&util_obstack, 'r');
11198 if (TREE_CODE (pointer_to) == RECORD_TYPE)
11200 if (OBJC_TYPE_NAME (pointer_to)
11201 && TREE_CODE (OBJC_TYPE_NAME (pointer_to)) == IDENTIFIER_NODE)
11203 const char *name = IDENTIFIER_POINTER (OBJC_TYPE_NAME (pointer_to));
11205 if (strcmp (name, TAG_OBJECT) == 0) /* '@' */
11207 obstack_1grow (&util_obstack, '@');
11210 else if (TYPE_HAS_OBJC_INFO (pointer_to)
11211 && TYPE_OBJC_INTERFACE (pointer_to))
11213 if (generating_instance_variables)
11215 obstack_1grow (&util_obstack, '@');
11216 obstack_1grow (&util_obstack, '"');
11217 obstack_grow (&util_obstack, name, strlen (name));
11218 obstack_1grow (&util_obstack, '"');
11223 obstack_1grow (&util_obstack, '@');
11227 else if (strcmp (name, TAG_CLASS) == 0) /* '#' */
11229 obstack_1grow (&util_obstack, '#');
11232 else if (strcmp (name, TAG_SELECTOR) == 0) /* ':' */
11234 obstack_1grow (&util_obstack, ':');
11239 else if (TREE_CODE (pointer_to) == INTEGER_TYPE
11240 && TYPE_MODE (pointer_to) == QImode)
11242 tree pname = TREE_CODE (OBJC_TYPE_NAME (pointer_to)) == IDENTIFIER_NODE
11243 ? OBJC_TYPE_NAME (pointer_to)
11244 : DECL_NAME (OBJC_TYPE_NAME (pointer_to));
11246 /* (BOOL *) are an exception and are encoded as ^c, while all
11247 other pointers to char are encoded as *. */
11248 if (strcmp (IDENTIFIER_POINTER (pname), "BOOL"))
11250 if (!flag_next_runtime)
11252 /* The NeXT runtime adds the 'r' before getting here. */
11254 /* It appears that "r*" means "const char *" rather than
11255 "char *const". "char *const" is encoded as "*",
11256 which is identical to "char *", so the "const" is
11257 unfortunately lost. */
11258 if (TYPE_READONLY (pointer_to))
11259 obstack_1grow (&util_obstack, 'r');
11262 obstack_1grow (&util_obstack, '*');
11267 /* We have a normal pointer type that does not get special treatment. */
11268 obstack_1grow (&util_obstack, '^');
11269 encode_type (pointer_to, curtype, format);
11273 encode_array (tree type, int curtype, int format)
11275 tree an_int_cst = TYPE_SIZE (type);
11276 tree array_of = TREE_TYPE (type);
11279 if (an_int_cst == NULL)
11281 /* We are trying to encode an incomplete array. An incomplete
11282 array is forbidden as part of an instance variable. */
11283 if (generating_instance_variables)
11285 /* TODO: Detect this error earlier. */
11286 error ("instance variable has unknown size");
11290 /* So the only case in which an incomplete array could occur is
11291 if we are encoding the arguments or return value of a method.
11292 In that case, an incomplete array argument or return value
11293 (eg, -(void)display: (char[])string) is treated like a
11294 pointer because that is how the compiler does the function
11295 call. A special, more complicated case, is when the
11296 incomplete array is the last member of a struct (eg, if we
11297 are encoding "struct { unsigned long int a;double b[];}"),
11298 which is again part of a method argument/return value. In
11299 that case, we really need to communicate to the runtime that
11300 there is an incomplete array (not a pointer!) there. So, we
11301 detect that special case and encode it as a zero-length
11304 Try to detect that we are part of a struct. We do this by
11305 searching for '=' in the type encoding for the current type.
11306 NB: This hack assumes that you can't use '=' as part of a C
11310 char *enc = obstack_base (&util_obstack) + curtype;
11311 if (memchr (enc, '=',
11312 obstack_object_size (&util_obstack) - curtype) == NULL)
11314 /* We are not inside a struct. Encode the array as a
11316 encode_pointer (type, curtype, format);
11321 /* Else, we are in a struct, and we encode it as a zero-length
11323 sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)0);
11325 else if (TREE_INT_CST_LOW (TYPE_SIZE (array_of)) == 0)
11326 sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)0);
11328 sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC,
11329 TREE_INT_CST_LOW (an_int_cst)
11330 / TREE_INT_CST_LOW (TYPE_SIZE (array_of)));
11332 obstack_grow (&util_obstack, buffer, strlen (buffer));
11333 encode_type (array_of, curtype, format);
11334 obstack_1grow (&util_obstack, ']');
11338 /* Encode a vector. The vector type is a GCC extension to C. */
11340 encode_vector (tree type, int curtype, int format)
11342 tree vector_of = TREE_TYPE (type);
11345 /* Vectors are like simple fixed-size arrays. */
11347 /* Output ![xx,yy,<code>] where xx is the vector_size, yy is the
11348 alignment of the vector, and <code> is the base type. Eg, int
11349 __attribute__ ((vector_size (16))) gets encoded as ![16,32,i]
11350 assuming that the alignment is 32 bytes. We include size and
11351 alignment in bytes so that the runtime does not have to have any
11352 knowledge of the actual types.
11354 sprintf (buffer, "![" HOST_WIDE_INT_PRINT_DEC ",%d",
11355 /* We want to compute the equivalent of sizeof (<vector>).
11356 Code inspired by c_sizeof_or_alignof_type. */
11357 ((TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type))
11358 / (TYPE_PRECISION (char_type_node) / BITS_PER_UNIT))),
11359 /* We want to compute the equivalent of __alignof__
11360 (<vector>). Code inspired by
11361 c_sizeof_or_alignof_type. */
11362 TYPE_ALIGN_UNIT (type));
11363 obstack_grow (&util_obstack, buffer, strlen (buffer));
11364 encode_type (vector_of, curtype, format);
11365 obstack_1grow (&util_obstack, ']');
11370 encode_aggregate_fields (tree type, bool pointed_to, int curtype, int format)
11372 tree field = TYPE_FIELDS (type);
11374 for (; field; field = DECL_CHAIN (field))
11377 /* C++ static members, and things that are not field at all,
11378 should not appear in the encoding. */
11379 if (TREE_CODE (field) != FIELD_DECL || TREE_STATIC (field))
11383 /* Recursively encode fields of embedded base classes. */
11384 if (DECL_ARTIFICIAL (field) && !DECL_NAME (field)
11385 && TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
11387 encode_aggregate_fields (TREE_TYPE (field),
11388 pointed_to, curtype, format);
11392 if (generating_instance_variables && !pointed_to)
11394 tree fname = DECL_NAME (field);
11396 obstack_1grow (&util_obstack, '"');
11398 if (fname && TREE_CODE (fname) == IDENTIFIER_NODE)
11399 obstack_grow (&util_obstack,
11400 IDENTIFIER_POINTER (fname),
11401 strlen (IDENTIFIER_POINTER (fname)));
11403 obstack_1grow (&util_obstack, '"');
11406 encode_field_decl (field, curtype, format);
11411 encode_aggregate_within (tree type, int curtype, int format, int left,
11415 /* NB: aggregates that are pointed to have slightly different encoding
11416 rules in that you never encode the names of instance variables. */
11417 int ob_size = obstack_object_size (&util_obstack);
11418 bool inline_contents = false;
11419 bool pointed_to = false;
11421 if (flag_next_runtime)
11423 if (ob_size > 0 && *(obstack_next_free (&util_obstack) - 1) == '^')
11426 if ((format == OBJC_ENCODE_INLINE_DEFS || generating_instance_variables)
11427 && (!pointed_to || ob_size - curtype == 1
11428 || (ob_size - curtype == 2
11429 && *(obstack_next_free (&util_obstack) - 2) == 'r')))
11430 inline_contents = true;
11434 /* c0 and c1 are the last two characters in the encoding of the
11435 current type; if the last two characters were '^' or '^r',
11436 then we are encoding an aggregate that is "pointed to". The
11437 comment above applies: in that case we should avoid encoding
11438 the names of instance variables.
11440 char c1 = ob_size > 1 ? *(obstack_next_free (&util_obstack) - 2) : 0;
11441 char c0 = ob_size > 0 ? *(obstack_next_free (&util_obstack) - 1) : 0;
11443 if (c0 == '^' || (c1 == '^' && c0 == 'r'))
11446 if (format == OBJC_ENCODE_INLINE_DEFS || generating_instance_variables)
11449 inline_contents = true;
11452 /* Note that the check (ob_size - curtype < 2) prevents
11453 infinite recursion when encoding a structure which is
11454 a linked list (eg, struct node { struct node *next;
11455 }). Each time we follow a pointer, we add one
11456 character to ob_size, and curtype is fixed, so after
11457 at most two pointers we stop inlining contents and
11460 The other case where we don't inline is "^r", which
11461 is a pointer to a constant struct.
11463 if ((ob_size - curtype <= 2) && !(c0 == 'r'))
11464 inline_contents = true;
11469 /* Traverse struct aliases; it is important to get the
11470 original struct and its tag name (if any). */
11471 type = TYPE_MAIN_VARIANT (type);
11472 name = OBJC_TYPE_NAME (type);
11473 /* Open parenth/bracket. */
11474 obstack_1grow (&util_obstack, left);
11476 /* Encode the struct/union tag name, or '?' if a tag was
11477 not provided. Typedef aliases do not qualify. */
11479 /* For compatibility with the NeXT runtime, ObjC++ encodes template
11480 args as a composite struct tag name. */
11481 if (name && TREE_CODE (name) == IDENTIFIER_NODE
11482 /* Did this struct have a tag? */
11483 && !TYPE_WAS_ANONYMOUS (type))
11484 obstack_grow (&util_obstack,
11485 decl_as_string (type, TFF_DECL_SPECIFIERS | TFF_UNQUALIFIED_NAME),
11486 strlen (decl_as_string (type, TFF_DECL_SPECIFIERS | TFF_UNQUALIFIED_NAME)));
11488 if (name && TREE_CODE (name) == IDENTIFIER_NODE)
11489 obstack_grow (&util_obstack,
11490 IDENTIFIER_POINTER (name),
11491 strlen (IDENTIFIER_POINTER (name)));
11494 obstack_1grow (&util_obstack, '?');
11496 /* Encode the types (and possibly names) of the inner fields,
11498 if (inline_contents)
11500 obstack_1grow (&util_obstack, '=');
11501 encode_aggregate_fields (type, pointed_to, curtype, format);
11503 /* Close parenth/bracket. */
11504 obstack_1grow (&util_obstack, right);
11507 /* Encode a bitfield NeXT-style (i.e., without a bit offset or the underlying
11511 encode_next_bitfield (int width)
11514 sprintf (buffer, "b%d", width);
11515 obstack_grow (&util_obstack, buffer, strlen (buffer));
11519 /* Encodes 'type', ignoring type qualifiers (which you should encode
11520 beforehand if needed) with the exception of 'const', which is
11521 encoded by encode_type. See above for the explanation of
11522 'curtype'. 'format' can be OBJC_ENCODE_INLINE_DEFS or
11523 OBJC_ENCODE_DONT_INLINE_DEFS.
11526 encode_type (tree type, int curtype, int format)
11528 enum tree_code code = TREE_CODE (type);
11530 /* Ignore type qualifiers other than 'const' when encoding a
11533 if (type == error_mark_node)
11536 if (!flag_next_runtime)
11538 if (TYPE_READONLY (type))
11539 obstack_1grow (&util_obstack, 'r');
11544 case ENUMERAL_TYPE:
11545 if (flag_next_runtime)
11547 /* Kludge for backwards-compatibility with gcc-3.3: enums
11548 are always encoded as 'i' no matter what type they
11549 actually are (!). */
11550 obstack_1grow (&util_obstack, 'i');
11553 /* Else, they are encoded exactly like the integer type that is
11554 used by the compiler to store them. */
11558 switch (GET_MODE_BITSIZE (TYPE_MODE (type)))
11560 case 8: c = TYPE_UNSIGNED (type) ? 'C' : 'c'; break;
11561 case 16: c = TYPE_UNSIGNED (type) ? 'S' : 's'; break;
11564 tree int_type = type;
11565 if (flag_next_runtime)
11567 /* Another legacy kludge for compatiblity with
11568 gcc-3.3: 32-bit longs are encoded as 'l' or 'L',
11569 but not always. For typedefs, we need to use 'i'
11570 or 'I' instead if encoding a struct field, or a
11572 int_type = ((!generating_instance_variables
11573 && (obstack_object_size (&util_obstack)
11574 == (unsigned) curtype))
11575 ? TYPE_MAIN_VARIANT (type)
11578 if (int_type == long_unsigned_type_node
11579 || int_type == long_integer_type_node)
11580 c = TYPE_UNSIGNED (type) ? 'L' : 'l';
11582 c = TYPE_UNSIGNED (type) ? 'I' : 'i';
11585 case 64: c = TYPE_UNSIGNED (type) ? 'Q' : 'q'; break;
11586 case 128: c = TYPE_UNSIGNED (type) ? 'T' : 't'; break;
11587 default: gcc_unreachable ();
11589 obstack_1grow (&util_obstack, c);
11595 /* Floating point types. */
11596 switch (GET_MODE_BITSIZE (TYPE_MODE (type)))
11598 case 32: c = 'f'; break;
11599 case 64: c = 'd'; break;
11601 case 128: c = 'D'; break;
11602 default: gcc_unreachable ();
11604 obstack_1grow (&util_obstack, c);
11608 obstack_1grow (&util_obstack, 'v');
11612 obstack_1grow (&util_obstack, 'B');
11616 encode_array (type, curtype, format);
11621 case REFERENCE_TYPE:
11623 encode_pointer (type, curtype, format);
11627 encode_aggregate_within (type, curtype, format, '{', '}');
11631 encode_aggregate_within (type, curtype, format, '(', ')');
11634 case FUNCTION_TYPE: /* '?' means an unknown type. */
11635 obstack_1grow (&util_obstack, '?');
11639 /* A complex is encoded as 'j' followed by the inner type (eg,
11640 "_Complex int" is encoded as 'ji'). */
11641 obstack_1grow (&util_obstack, 'j');
11642 encode_type (TREE_TYPE (type), curtype, format);
11646 encode_vector (type, curtype, format);
11650 warning (0, "unknown type %s found during Objective-C encoding",
11651 gen_type_name (type));
11652 obstack_1grow (&util_obstack, '?');
11656 if (flag_next_runtime)
11658 /* Super-kludge. Some ObjC qualifier and type combinations need
11659 to be rearranged for compatibility with gcc-3.3. */
11660 if (code == POINTER_TYPE && obstack_object_size (&util_obstack) >= 3)
11662 char *enc = obstack_base (&util_obstack) + curtype;
11664 /* Rewrite "in const" from "nr" to "rn". */
11665 if (curtype >= 1 && !strncmp (enc - 1, "nr", 2))
11666 strncpy (enc - 1, "rn", 2);
11672 encode_gnu_bitfield (int position, tree type, int size)
11674 enum tree_code code = TREE_CODE (type);
11676 char charType = '?';
11678 /* This code is only executed for the GNU runtime, so we can ignore
11679 the NeXT runtime kludge of always encoding enums as 'i' no matter
11680 what integers they actually are. */
11681 if (code == INTEGER_TYPE || code == ENUMERAL_TYPE)
11683 if (integer_zerop (TYPE_MIN_VALUE (type)))
11684 /* Unsigned integer types. */
11686 switch (TYPE_MODE (type))
11689 charType = 'C'; break;
11691 charType = 'S'; break;
11694 if (type == long_unsigned_type_node)
11701 charType = 'Q'; break;
11703 gcc_unreachable ();
11707 /* Signed integer types. */
11709 switch (TYPE_MODE (type))
11712 charType = 'c'; break;
11714 charType = 's'; break;
11717 if (type == long_integer_type_node)
11724 charType = 'q'; break;
11726 gcc_unreachable ();
11732 /* Do not do any encoding, produce an error and keep going. */
11733 error ("trying to encode non-integer type as a bitfield");
11737 sprintf (buffer, "b%d%c%d", position, charType, size);
11738 obstack_grow (&util_obstack, buffer, strlen (buffer));
11742 encode_field_decl (tree field_decl, int curtype, int format)
11745 /* C++ static members, and things that are not fields at all,
11746 should not appear in the encoding. */
11747 if (TREE_CODE (field_decl) != FIELD_DECL || TREE_STATIC (field_decl))
11751 /* Generate the bitfield typing information, if needed. Note the difference
11752 between GNU and NeXT runtimes. */
11753 if (DECL_BIT_FIELD_TYPE (field_decl))
11755 int size = tree_low_cst (DECL_SIZE (field_decl), 1);
11757 if (flag_next_runtime)
11758 encode_next_bitfield (size);
11760 encode_gnu_bitfield (int_bit_position (field_decl),
11761 DECL_BIT_FIELD_TYPE (field_decl), size);
11764 encode_type (TREE_TYPE (field_decl), curtype, format);
11767 /* Decay array and function parameters into pointers. */
11770 objc_decay_parm_type (tree type)
11772 if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == FUNCTION_TYPE)
11773 type = build_pointer_type (TREE_CODE (type) == ARRAY_TYPE
11780 static GTY(()) tree objc_parmlist = NULL_TREE;
11782 /* Append PARM to a list of formal parameters of a method, making a necessary
11783 array-to-pointer adjustment along the way. */
11786 objc_push_parm (tree parm)
11790 if (TREE_TYPE (parm) == error_mark_node)
11792 objc_parmlist = chainon (objc_parmlist, parm);
11796 /* Decay arrays and functions into pointers. */
11797 type = objc_decay_parm_type (TREE_TYPE (parm));
11799 /* If the parameter type has been decayed, a new PARM_DECL needs to be
11801 if (type != TREE_TYPE (parm))
11802 parm = build_decl (input_location, PARM_DECL, DECL_NAME (parm), type);
11804 DECL_ARG_TYPE (parm)
11805 = lang_hooks.types.type_promotes_to (TREE_TYPE (parm));
11807 /* Record constancy and volatility. */
11808 c_apply_type_quals_to_decl
11809 ((TYPE_READONLY (TREE_TYPE (parm)) ? TYPE_QUAL_CONST : 0)
11810 | (TYPE_RESTRICT (TREE_TYPE (parm)) ? TYPE_QUAL_RESTRICT : 0)
11811 | (TYPE_VOLATILE (TREE_TYPE (parm)) ? TYPE_QUAL_VOLATILE : 0), parm);
11813 objc_parmlist = chainon (objc_parmlist, parm);
11816 /* Retrieve the formal parameter list constructed via preceding calls to
11817 objc_push_parm(). */
11821 objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED)
11823 static struct c_arg_info *
11824 objc_get_parm_info (int have_ellipsis)
11828 tree parm_info = objc_parmlist;
11829 objc_parmlist = NULL_TREE;
11833 tree parm_info = objc_parmlist;
11834 struct c_arg_info *arg_info;
11835 /* The C front-end requires an elaborate song and dance at
11838 declare_parm_level ();
11841 tree next = DECL_CHAIN (parm_info);
11843 DECL_CHAIN (parm_info) = NULL_TREE;
11844 parm_info = pushdecl (parm_info);
11845 finish_decl (parm_info, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
11848 arg_info = get_parm_info (have_ellipsis);
11850 objc_parmlist = NULL_TREE;
11855 /* Synthesize the formal parameters 'id self' and 'SEL _cmd' needed for ObjC
11856 method definitions. In the case of instance methods, we can be more
11857 specific as to the type of 'self'. */
11860 synth_self_and_ucmd_args (void)
11864 if (objc_method_context
11865 && TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL)
11866 self_type = objc_instance_type;
11868 /* Really a `struct objc_class *'. However, we allow people to
11869 assign to self, which changes its type midstream. */
11870 self_type = objc_object_type;
11873 objc_push_parm (build_decl (input_location,
11874 PARM_DECL, self_id, self_type));
11877 objc_push_parm (build_decl (input_location,
11878 PARM_DECL, ucmd_id, objc_selector_type));
11881 /* Transform an Objective-C method definition into a static C function
11882 definition, synthesizing the first two arguments, "self" and "_cmd",
11886 start_method_def (tree method)
11892 struct c_arg_info *parm_info;
11894 int have_ellipsis = 0;
11896 /* If we are defining a "dealloc" method in a non-root class, we
11897 will need to check if a [super dealloc] is missing, and warn if
11899 if(CLASS_SUPER_NAME (objc_implementation_context)
11900 && !strcmp ("dealloc", IDENTIFIER_POINTER (METHOD_SEL_NAME (method))))
11901 should_call_super_dealloc = 1;
11903 should_call_super_dealloc = 0;
11905 /* Required to implement _msgSuper. */
11906 objc_method_context = method;
11907 UOBJC_SUPER_decl = NULL_TREE;
11909 /* Generate prototype declarations for arguments..."new-style". */
11910 synth_self_and_ucmd_args ();
11912 /* Generate argument declarations if a keyword_decl. */
11913 parmlist = METHOD_SEL_ARGS (method);
11916 /* parmlist is a KEYWORD_DECL. */
11917 tree type = TREE_VALUE (TREE_TYPE (parmlist));
11920 parm = build_decl (input_location,
11921 PARM_DECL, KEYWORD_ARG_NAME (parmlist), type);
11922 decl_attributes (&parm, DECL_ATTRIBUTES (parmlist), 0);
11923 objc_push_parm (parm);
11924 parmlist = DECL_CHAIN (parmlist);
11927 if (METHOD_ADD_ARGS (method))
11931 for (akey = TREE_CHAIN (METHOD_ADD_ARGS (method));
11932 akey; akey = TREE_CHAIN (akey))
11934 objc_push_parm (TREE_VALUE (akey));
11937 if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
11941 parm_info = objc_get_parm_info (have_ellipsis);
11943 really_start_method (objc_method_context, parm_info);
11946 /* Return 1 if TYPE1 is equivalent to TYPE2 for purposes of method
11949 objc_types_are_equivalent (tree type1, tree type2)
11951 if (type1 == type2)
11954 /* Strip away indirections. */
11955 while ((TREE_CODE (type1) == ARRAY_TYPE || TREE_CODE (type1) == POINTER_TYPE)
11956 && (TREE_CODE (type1) == TREE_CODE (type2)))
11957 type1 = TREE_TYPE (type1), type2 = TREE_TYPE (type2);
11958 if (TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
11961 /* Compare the protocol lists. */
11962 type1 = (TYPE_HAS_OBJC_INFO (type1)
11963 ? TYPE_OBJC_PROTOCOL_LIST (type1)
11965 type2 = (TYPE_HAS_OBJC_INFO (type2)
11966 ? TYPE_OBJC_PROTOCOL_LIST (type2)
11969 /* If there are no protocols (most common case), the types are
11971 if (type1 == NULL_TREE && type2 == NULL_TREE)
11974 /* If one has protocols, and the other one hasn't, they are not
11976 if ((type1 == NULL_TREE && type2 != NULL_TREE)
11977 || (type1 != NULL_TREE && type2 == NULL_TREE))
11981 /* Else, both have protocols, and we need to do the full
11982 comparison. It is possible that either type1 or type2
11983 contain some duplicate protocols in the list, so we can't
11984 even just compare list_length as a first check. */
11987 for (t = type2; t; t = TREE_CHAIN (t))
11988 if (!lookup_protocol_in_reflist (type1, TREE_VALUE (t)))
11991 for (t = type1; t; t = TREE_CHAIN (t))
11992 if (!lookup_protocol_in_reflist (type2, TREE_VALUE (t)))
11999 /* Return 1 if TYPE1 has the same size and alignment as TYPE2. */
12002 objc_types_share_size_and_alignment (tree type1, tree type2)
12004 return (simple_cst_equal (TYPE_SIZE (type1), TYPE_SIZE (type2))
12005 && TYPE_ALIGN (type1) == TYPE_ALIGN (type2));
12008 /* Return 1 if PROTO1 is equivalent to PROTO2
12009 for purposes of method overloading. Ordinarily, the type signatures
12010 should match up exactly, unless STRICT is zero, in which case we
12011 shall allow differences in which the size and alignment of a type
12015 comp_proto_with_proto (tree proto1, tree proto2, int strict)
12017 /* The following test is needed in case there are hashing
12019 if (METHOD_SEL_NAME (proto1) != METHOD_SEL_NAME (proto2))
12022 return match_proto_with_proto (proto1, proto2, strict);
12026 match_proto_with_proto (tree proto1, tree proto2, int strict)
12030 /* Compare return types. */
12031 type1 = TREE_VALUE (TREE_TYPE (proto1));
12032 type2 = TREE_VALUE (TREE_TYPE (proto2));
12034 if (!objc_types_are_equivalent (type1, type2)
12035 && (strict || !objc_types_share_size_and_alignment (type1, type2)))
12038 /* Compare argument types. */
12039 for (type1 = get_arg_type_list (proto1, METHOD_REF, 0),
12040 type2 = get_arg_type_list (proto2, METHOD_REF, 0);
12042 type1 = TREE_CHAIN (type1), type2 = TREE_CHAIN (type2))
12044 if (!objc_types_are_equivalent (TREE_VALUE (type1), TREE_VALUE (type2))
12046 || !objc_types_share_size_and_alignment (TREE_VALUE (type1),
12047 TREE_VALUE (type2))))
12051 return (!type1 && !type2);
12054 /* Fold an OBJ_TYPE_REF expression for ObjC method dispatches, where
12055 this occurs. ObjC method dispatches are _not_ like C++ virtual
12056 member function dispatches, and we account for the difference here. */
12059 objc_fold_obj_type_ref (tree ref, tree known_type)
12061 objc_fold_obj_type_ref (tree ref ATTRIBUTE_UNUSED,
12062 tree known_type ATTRIBUTE_UNUSED)
12066 tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
12068 /* If the receiver does not have virtual member functions, there
12069 is nothing we can (or need to) do here. */
12073 /* Let C++ handle C++ virtual functions. */
12074 return cp_fold_obj_type_ref (ref, known_type);
12076 /* For plain ObjC, we currently do not need to do anything. */
12082 objc_start_function (tree name, tree type, tree attrs,
12086 struct c_arg_info *params
12090 tree fndecl = build_decl (input_location,
12091 FUNCTION_DECL, name, type);
12094 DECL_ARGUMENTS (fndecl) = params;
12095 DECL_INITIAL (fndecl) = error_mark_node;
12096 DECL_EXTERNAL (fndecl) = 0;
12097 TREE_STATIC (fndecl) = 1;
12098 retrofit_lang_decl (fndecl);
12099 cplus_decl_attributes (&fndecl, attrs, 0);
12100 start_preparsed_function (fndecl, attrs, /*flags=*/SF_DEFAULT);
12102 current_function_returns_value = 0; /* Assume, until we see it does. */
12103 current_function_returns_null = 0;
12104 decl_attributes (&fndecl, attrs, 0);
12105 announce_function (fndecl);
12106 DECL_INITIAL (fndecl) = error_mark_node;
12107 DECL_EXTERNAL (fndecl) = 0;
12108 TREE_STATIC (fndecl) = 1;
12109 current_function_decl = pushdecl (fndecl);
12111 declare_parm_level ();
12112 DECL_RESULT (current_function_decl)
12113 = build_decl (input_location,
12114 RESULT_DECL, NULL_TREE,
12115 TREE_TYPE (TREE_TYPE (current_function_decl)));
12116 DECL_ARTIFICIAL (DECL_RESULT (current_function_decl)) = 1;
12117 DECL_IGNORED_P (DECL_RESULT (current_function_decl)) = 1;
12118 start_fname_decls ();
12119 store_parm_decls_from (params);
12122 TREE_USED (current_function_decl) = 1;
12125 /* - Generate an identifier for the function. the format is "_n_cls",
12126 where 1 <= n <= nMethods, and cls is the name the implementation we
12128 - Install the return type from the method declaration.
12129 - If we have a prototype, check for type consistency. */
12132 really_start_method (tree method,
12136 struct c_arg_info *parmlist
12140 tree ret_type, meth_type;
12142 const char *sel_name, *class_name, *cat_name;
12145 /* Synth the storage class & assemble the return type. */
12146 ret_type = TREE_VALUE (TREE_TYPE (method));
12148 sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method));
12149 class_name = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
12150 cat_name = ((TREE_CODE (objc_implementation_context)
12151 == CLASS_IMPLEMENTATION_TYPE)
12153 : IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
12156 /* Make sure this is big enough for any plausible method label. */
12157 buf = (char *) alloca (50 + strlen (sel_name) + strlen (class_name)
12158 + (cat_name ? strlen (cat_name) : 0));
12160 OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL,
12161 class_name, cat_name, sel_name, method_slot);
12163 method_id = get_identifier (buf);
12166 /* Objective-C methods cannot be overloaded, so we don't need
12167 the type encoding appended. It looks bad anyway... */
12168 push_lang_context (lang_name_c);
12172 = build_function_type (ret_type,
12173 get_arg_type_list (method, METHOD_DEF, 0));
12174 objc_start_function (method_id, meth_type, NULL_TREE, parmlist);
12176 /* Set self_decl from the first argument. */
12177 self_decl = DECL_ARGUMENTS (current_function_decl);
12179 /* Suppress unused warnings. */
12180 TREE_USED (self_decl) = 1;
12181 DECL_READ_P (self_decl) = 1;
12182 TREE_USED (DECL_CHAIN (self_decl)) = 1;
12183 DECL_READ_P (DECL_CHAIN (self_decl)) = 1;
12185 pop_lang_context ();
12188 METHOD_DEFINITION (method) = current_function_decl;
12190 /* Check consistency...start_function, pushdecl, duplicate_decls. */
12192 if (implementation_template != objc_implementation_context)
12195 = lookup_method_static (implementation_template,
12196 METHOD_SEL_NAME (method),
12197 ((TREE_CODE (method) == CLASS_METHOD_DECL)
12198 | OBJC_LOOKUP_NO_SUPER));
12202 if (!comp_proto_with_proto (method, proto, 1))
12204 bool type = TREE_CODE (method) == INSTANCE_METHOD_DECL;
12206 warning_at (DECL_SOURCE_LOCATION (method), 0,
12207 "conflicting types for %<%c%s%>",
12208 (type ? '-' : '+'),
12209 identifier_to_locale (gen_method_decl (method)));
12210 inform (DECL_SOURCE_LOCATION (proto),
12211 "previous declaration of %<%c%s%>",
12212 (type ? '-' : '+'),
12213 identifier_to_locale (gen_method_decl (proto)));
12217 /* If the method in the @interface was deprecated, mark
12218 the implemented method as deprecated too. It should
12219 never be used for messaging (when the deprecation
12220 warnings are produced), but just in case. */
12221 if (TREE_DEPRECATED (proto))
12222 TREE_DEPRECATED (method) = 1;
12224 /* If the method in the @interface was marked as
12225 'noreturn', mark the function implementing the method
12226 as 'noreturn' too. */
12227 TREE_THIS_VOLATILE (current_function_decl) = TREE_THIS_VOLATILE (proto);
12232 /* We have a method @implementation even though we did not
12233 see a corresponding @interface declaration (which is allowed
12234 by Objective-C rules). Go ahead and place the method in
12235 the @interface anyway, so that message dispatch lookups
12237 tree interface = implementation_template;
12239 if (TREE_CODE (objc_implementation_context)
12240 == CATEGORY_IMPLEMENTATION_TYPE)
12241 interface = lookup_category
12243 CLASS_SUPER_NAME (objc_implementation_context));
12246 objc_add_method (interface, copy_node (method),
12247 TREE_CODE (method) == CLASS_METHOD_DECL,
12248 /* is_optional= */ false);
12253 static void *UOBJC_SUPER_scope = 0;
12255 /* _n_Method (id self, SEL sel, ...)
12257 struct objc_super _S;
12258 _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
12262 get_super_receiver (void)
12264 if (objc_method_context)
12266 tree super_expr, super_expr_list;
12268 if (!UOBJC_SUPER_decl)
12270 UOBJC_SUPER_decl = build_decl (input_location,
12271 VAR_DECL, get_identifier (TAG_SUPER),
12272 objc_super_template);
12273 /* This prevents `unused variable' warnings when compiling with -Wall. */
12274 TREE_USED (UOBJC_SUPER_decl) = 1;
12275 DECL_READ_P (UOBJC_SUPER_decl) = 1;
12276 lang_hooks.decls.pushdecl (UOBJC_SUPER_decl);
12277 finish_decl (UOBJC_SUPER_decl, input_location, NULL_TREE, NULL_TREE,
12279 UOBJC_SUPER_scope = objc_get_current_scope ();
12282 /* Set receiver to self. */
12283 super_expr = objc_build_component_ref (UOBJC_SUPER_decl, self_id);
12284 super_expr = build_modify_expr (input_location, super_expr, NULL_TREE,
12285 NOP_EXPR, input_location, self_decl,
12287 super_expr_list = super_expr;
12289 /* Set class to begin searching. */
12290 super_expr = objc_build_component_ref (UOBJC_SUPER_decl,
12291 get_identifier ("super_class"));
12293 if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
12295 /* [_cls, __cls]Super are "pre-built" in
12296 synth_forward_declarations. */
12298 super_expr = build_modify_expr (input_location, super_expr,
12299 NULL_TREE, NOP_EXPR,
12301 ((TREE_CODE (objc_method_context)
12302 == INSTANCE_METHOD_DECL)
12304 : uucls_super_ref),
12309 /* We have a category. */
12311 tree super_name = CLASS_SUPER_NAME (implementation_template);
12314 /* Barf if super used in a category of Object. */
12317 error ("no super class declared in interface for %qE",
12318 CLASS_NAME (implementation_template));
12319 return error_mark_node;
12322 if (flag_next_runtime && !flag_zero_link)
12324 super_class = objc_get_class_reference (super_name);
12325 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
12326 /* If we are in a class method, we must retrieve the
12327 _metaclass_ for the current class, pointed at by
12328 the class's "isa" pointer. The following assumes that
12329 "isa" is the first ivar in a class (which it must be). */
12331 = build_indirect_ref
12333 build_c_cast (input_location,
12334 build_pointer_type (objc_class_type),
12335 super_class), RO_UNARY_STAR);
12339 add_class_reference (super_name);
12340 super_class = (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
12341 ? objc_get_class_decl : objc_get_meta_class_decl);
12342 assemble_external (super_class);
12344 = build_function_call
12349 my_build_string_pointer
12350 (IDENTIFIER_LENGTH (super_name) + 1,
12351 IDENTIFIER_POINTER (super_name))));
12355 = build_modify_expr (input_location, super_expr, NULL_TREE,
12358 build_c_cast (input_location,
12359 TREE_TYPE (super_expr),
12364 super_expr_list = build_compound_expr (input_location,
12365 super_expr_list, super_expr);
12367 super_expr = build_unary_op (input_location,
12368 ADDR_EXPR, UOBJC_SUPER_decl, 0);
12369 super_expr_list = build_compound_expr (input_location,
12370 super_expr_list, super_expr);
12372 return super_expr_list;
12376 error ("[super ...] must appear in a method context");
12377 return error_mark_node;
12381 /* When exiting a scope, sever links to a 'super' declaration (if any)
12382 therein contained. */
12385 objc_clear_super_receiver (void)
12387 if (objc_method_context
12388 && UOBJC_SUPER_scope == objc_get_current_scope ()) {
12389 UOBJC_SUPER_decl = 0;
12390 UOBJC_SUPER_scope = 0;
12395 objc_finish_method_definition (tree fndecl)
12397 /* We cannot validly inline ObjC methods, at least not without a language
12398 extension to declare that a method need not be dynamically
12399 dispatched, so suppress all thoughts of doing so. */
12400 DECL_UNINLINABLE (fndecl) = 1;
12403 /* The C++ front-end will have called finish_function() for us. */
12404 finish_function ();
12407 METHOD_ENCODING (objc_method_context)
12408 = encode_method_prototype (objc_method_context);
12410 /* Required to implement _msgSuper. This must be done AFTER finish_function,
12411 since the optimizer may find "may be used before set" errors. */
12412 objc_method_context = NULL_TREE;
12414 if (should_call_super_dealloc)
12415 warning (0, "method possibly missing a [super dealloc] call");
12418 /* Given a tree DECL node, produce a printable description of it in the given
12419 buffer, overwriting the buffer. */
12422 gen_declaration (tree decl)
12428 gen_type_name_0 (TREE_TYPE (decl));
12430 if (DECL_NAME (decl))
12432 if (!POINTER_TYPE_P (TREE_TYPE (decl)))
12433 strcat (errbuf, " ");
12435 strcat (errbuf, IDENTIFIER_POINTER (DECL_NAME (decl)));
12438 if (DECL_INITIAL (decl)
12439 && TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST)
12440 sprintf (errbuf + strlen (errbuf), ": " HOST_WIDE_INT_PRINT_DEC,
12441 TREE_INT_CST_LOW (DECL_INITIAL (decl)));
12447 /* Given a tree TYPE node, produce a printable description of it in the given
12448 buffer, overwriting the buffer. */
12451 gen_type_name_0 (tree type)
12453 tree orig = type, proto;
12455 if (TYPE_P (type) && TYPE_NAME (type))
12456 type = TYPE_NAME (type);
12457 else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
12459 tree inner = TREE_TYPE (type);
12461 while (TREE_CODE (inner) == ARRAY_TYPE)
12462 inner = TREE_TYPE (inner);
12464 gen_type_name_0 (inner);
12466 if (!POINTER_TYPE_P (inner))
12467 strcat (errbuf, " ");
12469 if (POINTER_TYPE_P (type))
12470 strcat (errbuf, "*");
12472 while (type != inner)
12474 strcat (errbuf, "[");
12476 if (TYPE_DOMAIN (type))
12480 sprintf (sz, HOST_WIDE_INT_PRINT_DEC,
12482 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1));
12483 strcat (errbuf, sz);
12486 strcat (errbuf, "]");
12487 type = TREE_TYPE (type);
12490 goto exit_function;
12493 if (TREE_CODE (type) == TYPE_DECL && DECL_NAME (type))
12494 type = DECL_NAME (type);
12496 strcat (errbuf, TREE_CODE (type) == IDENTIFIER_NODE
12497 ? IDENTIFIER_POINTER (type)
12500 /* For 'id' and 'Class', adopted protocols are stored in the pointee. */
12501 if (objc_is_id (orig))
12502 orig = TREE_TYPE (orig);
12504 proto = TYPE_HAS_OBJC_INFO (orig) ? TYPE_OBJC_PROTOCOL_LIST (orig) : NULL_TREE;
12508 strcat (errbuf, " <");
12512 IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto))));
12513 proto = TREE_CHAIN (proto);
12514 strcat (errbuf, proto ? ", " : ">");
12523 gen_type_name (tree type)
12527 return gen_type_name_0 (type);
12530 /* Given a method tree, put a printable description into the given
12531 buffer (overwriting) and return a pointer to the buffer. */
12534 gen_method_decl (tree method)
12538 strcpy (errbuf, "("); /* NB: Do _not_ call strcat() here. */
12539 gen_type_name_0 (TREE_VALUE (TREE_TYPE (method)));
12540 strcat (errbuf, ")");
12541 chain = METHOD_SEL_ARGS (method);
12545 /* We have a chain of keyword_decls. */
12548 if (KEYWORD_KEY_NAME (chain))
12549 strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain)));
12551 strcat (errbuf, ":(");
12552 gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain)));
12553 strcat (errbuf, ")");
12555 strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain)));
12556 if ((chain = DECL_CHAIN (chain)))
12557 strcat (errbuf, " ");
12561 if (METHOD_ADD_ARGS (method))
12563 chain = TREE_CHAIN (METHOD_ADD_ARGS (method));
12565 /* Know we have a chain of parm_decls. */
12568 strcat (errbuf, ", ");
12569 gen_type_name_0 (TREE_TYPE (TREE_VALUE (chain)));
12570 chain = TREE_CHAIN (chain);
12573 if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
12574 strcat (errbuf, ", ...");
12579 /* We have a unary selector. */
12580 strcat (errbuf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
12588 /* Dump an @interface declaration of the supplied class CHAIN to the
12589 supplied file FP. Used to implement the -gen-decls option (which
12590 prints out an @interface declaration of all classes compiled in
12591 this run); potentially useful for debugging the compiler too. */
12593 dump_interface (FILE *fp, tree chain)
12595 /* FIXME: A heap overflow here whenever a method (or ivar)
12596 declaration is so long that it doesn't fit in the buffer. The
12597 code and all the related functions should be rewritten to avoid
12598 using fixed size buffers. */
12599 const char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain));
12600 tree ivar_decls = CLASS_RAW_IVARS (chain);
12601 tree nst_methods = CLASS_NST_METHODS (chain);
12602 tree cls_methods = CLASS_CLS_METHODS (chain);
12604 fprintf (fp, "\n@interface %s", my_name);
12606 /* CLASS_SUPER_NAME is used to store the superclass name for
12607 classes, and the category name for categories. */
12608 if (CLASS_SUPER_NAME (chain))
12610 const char *name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain));
12612 switch (TREE_CODE (chain))
12614 case CATEGORY_IMPLEMENTATION_TYPE:
12615 case CATEGORY_INTERFACE_TYPE:
12616 fprintf (fp, " (%s)\n", name);
12619 fprintf (fp, " : %s\n", name);
12624 fprintf (fp, "\n");
12626 /* FIXME - the following doesn't seem to work at the moment. */
12629 fprintf (fp, "{\n");
12632 fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls));
12633 ivar_decls = TREE_CHAIN (ivar_decls);
12635 while (ivar_decls);
12636 fprintf (fp, "}\n");
12639 while (nst_methods)
12641 fprintf (fp, "- %s;\n", gen_method_decl (nst_methods));
12642 nst_methods = TREE_CHAIN (nst_methods);
12645 while (cls_methods)
12647 fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods));
12648 cls_methods = TREE_CHAIN (cls_methods);
12651 fprintf (fp, "@end\n");
12655 /* Produce the pretty printing for an Objective-C method. This is
12656 currently unused, but could be handy while reorganizing the pretty
12657 printing to be more robust. */
12658 static const char *
12659 objc_pretty_print_method (bool is_class_method,
12660 const char *class_name,
12661 const char *category_name,
12662 const char *selector)
12666 char *result = XNEWVEC (char, strlen (class_name) + strlen (category_name)
12667 + strlen (selector) + 7);
12669 if (is_class_method)
12670 sprintf (result, "+[%s(%s) %s]", class_name, category_name, selector);
12672 sprintf (result, "-[%s(%s) %s]", class_name, category_name, selector);
12678 char *result = XNEWVEC (char, strlen (class_name)
12679 + strlen (selector) + 5);
12681 if (is_class_method)
12682 sprintf (result, "+[%s %s]", class_name, selector);
12684 sprintf (result, "-[%s %s]", class_name, selector);
12691 /* Demangle function for Objective-C. Attempt to demangle the
12692 function name associated with a method (eg, going from
12693 "_i_NSObject__class" to "-[NSObject class]"); usually for the
12694 purpose of pretty printing or error messages. Return the demangled
12695 name, or NULL if the string is not an Objective-C mangled method
12698 Because of how the mangling is done, any method that has a '_' in
12699 its original name is at risk of being demangled incorrectly. In
12700 some cases there are multiple valid ways to demangle a method name
12701 and there is no way we can decide.
12703 TODO: objc_demangle() can't always get it right; the right way to
12704 get this correct for all method names would be to store the
12705 Objective-C method name somewhere in the function decl. Then,
12706 there is no demangling to do; we'd just pull the method name out of
12707 the decl. As an additional bonus, when printing error messages we
12708 could check for such a method name, and if we find it, we know the
12709 function is actually an Objective-C method and we could print error
12710 messages saying "In method '+[NSObject class]" instead of "In
12711 function '+[NSObject class]" as we do now. */
12712 static const char *
12713 objc_demangle (const char *mangled)
12715 char *demangled, *cp;
12717 /* First of all, if the name is too short it can't be an Objective-C
12718 mangled method name. */
12719 if (mangled[0] == '\0' || mangled[1] == '\0' || mangled[2] == '\0')
12722 /* If the name looks like an already demangled one, return it
12723 unchanged. This should only happen on Darwin, where method names
12724 are mangled differently into a pretty-print form (such as
12725 '+[NSObject class]', see darwin.h). In that case, demangling is
12726 a no-op, but we need to return the demangled name if it was an
12727 ObjC one, and return NULL if not. We should be safe as no C/C++
12728 function can start with "-[" or "+[". */
12729 if ((mangled[0] == '-' || mangled[0] == '+')
12730 && (mangled[1] == '['))
12733 if (mangled[0] == '_' &&
12734 (mangled[1] == 'i' || mangled[1] == 'c') &&
12737 cp = demangled = XNEWVEC (char, strlen(mangled) + 2);
12738 if (mangled[1] == 'i')
12739 *cp++ = '-'; /* for instance method */
12741 *cp++ = '+'; /* for class method */
12742 *cp++ = '['; /* opening left brace */
12743 strcpy(cp, mangled+3); /* tack on the rest of the mangled name */
12744 while (*cp && *cp == '_')
12745 cp++; /* skip any initial underbars in class name */
12746 cp = strchr(cp, '_'); /* find first non-initial underbar */
12749 free(demangled); /* not mangled name */
12752 if (cp[1] == '_') /* easy case: no category name */
12754 *cp++ = ' '; /* replace two '_' with one ' ' */
12755 strcpy(cp, mangled + (cp - demangled) + 2);
12759 *cp++ = '('; /* less easy case: category name */
12760 cp = strchr(cp, '_');
12763 free(demangled); /* not mangled name */
12767 *cp++ = ' '; /* overwriting 1st char of method name... */
12768 strcpy(cp, mangled + (cp - demangled)); /* get it back */
12770 /* Now we have the method name. We need to generally replace
12771 '_' with ':' but trying to preserve '_' if it could only have
12772 been in the mangled string because it was already in the
12773 original name. In cases where it's ambiguous, we assume that
12774 any '_' originated from a ':'. */
12776 /* Initial '_'s in method name can't have been generating by
12777 converting ':'s. Skip them. */
12778 while (*cp && *cp == '_')
12781 /* If the method name does not end with '_', then it has no
12782 arguments and there was no replacement of ':'s with '_'s
12783 during mangling. Check for that case, and skip any
12784 replacement if so. This at least guarantees that methods
12785 with no arguments are always demangled correctly (unless the
12786 original name ends with '_'). */
12787 if (*(mangled + strlen (mangled) - 1) != '_')
12789 /* Skip to the end. */
12795 /* Replace remaining '_' with ':'. This may get it wrong if
12796 there were '_'s in the original name. In most cases it
12797 is impossible to disambiguate. */
12802 *cp++ = ']'; /* closing right brace */
12803 *cp++ = 0; /* string terminator */
12807 return NULL; /* not an objc mangled name */
12810 /* Try to pretty-print a decl. If the 'decl' is an Objective-C
12811 specific decl, return the printable name for it. If not, return
12814 objc_maybe_printable_name (tree decl, int v ATTRIBUTE_UNUSED)
12816 switch (TREE_CODE (decl))
12818 case FUNCTION_DECL:
12819 return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl)));
12822 /* The following happens when we are printing a deprecation
12823 warning for a method. The warn_deprecation() will end up
12824 trying to print the decl for INSTANCE_METHOD_DECL or
12825 CLASS_METHOD_DECL. It would be nice to be able to print
12826 "-[NSObject autorelease] is deprecated", but to do that, we'd
12827 need to store the class and method name in the method decl,
12828 which we currently don't do. For now, just return the name
12829 of the method. We don't return NULL, because that may
12830 trigger further attempts to pretty-print the decl in C/C++,
12831 but they wouldn't know how to pretty-print it. */
12832 case INSTANCE_METHOD_DECL:
12833 case CLASS_METHOD_DECL:
12834 return IDENTIFIER_POINTER (DECL_NAME (decl));
12836 /* This happens when printing a deprecation warning for a
12837 property. We may want to consider some sort of pretty
12838 printing (eg, include the class name where it was declared
12840 case PROPERTY_DECL:
12841 return IDENTIFIER_POINTER (PROPERTY_NAME (decl));
12849 /* Return a printable name for 'decl'. This first tries
12850 objc_maybe_printable_name(), and if that fails, it returns the name
12851 in the decl. This is used as LANG_HOOKS_DECL_PRINTABLE_NAME for
12852 Objective-C; in Objective-C++, setting the hook is not enough
12853 because lots of C++ Front-End code calls cxx_printable_name,
12854 dump_decl and other C++ functions directly. So instead we have
12855 modified dump_decl to call objc_maybe_printable_name directly. */
12857 objc_printable_name (tree decl, int v)
12859 const char *demangled_name = objc_maybe_printable_name (decl, v);
12861 if (demangled_name != NULL)
12862 return demangled_name;
12864 return IDENTIFIER_POINTER (DECL_NAME (decl));
12870 gcc_obstack_init (&util_obstack);
12871 util_firstobj = (char *) obstack_finish (&util_obstack);
12873 errbuf = XNEWVEC (char, 1024 * 10);
12875 synth_module_prologue ();
12881 struct imp_entry *impent;
12883 /* The internally generated initializers appear to have missing braces.
12884 Don't warn about this. */
12885 int save_warn_missing_braces = warn_missing_braces;
12886 warn_missing_braces = 0;
12888 /* A missing @end may not be detected by the parser. */
12889 if (objc_implementation_context)
12891 warning (0, "%<@end%> missing in implementation context");
12892 finish_class (objc_implementation_context);
12893 objc_ivar_chain = NULL_TREE;
12894 objc_implementation_context = NULL_TREE;
12897 /* Process the static instances here because initialization of objc_symtab
12898 depends on them. */
12899 if (objc_static_instances)
12900 generate_static_references ();
12902 /* forward declare categories */
12904 forward_declare_categories ();
12906 for (impent = imp_list; impent; impent = impent->next)
12908 objc_implementation_context = impent->imp_context;
12909 implementation_template = impent->imp_template;
12911 /* FIXME: This needs reworking to be more obvious. */
12913 UOBJC_CLASS_decl = impent->class_decl;
12914 UOBJC_METACLASS_decl = impent->meta_decl;
12916 /* Dump the @interface of each class as we compile it, if the
12917 -gen-decls option is in use. TODO: Dump the classes in the
12918 order they were found, rather than in reverse order as we
12920 if (flag_gen_declaration)
12922 dump_interface (gen_declaration_file, objc_implementation_context);
12925 if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
12927 /* all of the following reference the string pool... */
12928 generate_ivar_lists ();
12929 generate_dispatch_tables ();
12930 generate_shared_structures (impent);
12934 generate_dispatch_tables ();
12935 generate_category (impent);
12938 impent->class_decl = UOBJC_CLASS_decl;
12939 impent->meta_decl = UOBJC_METACLASS_decl;
12942 /* If we are using an array of selectors, we must always
12943 finish up the array decl even if no selectors were used. */
12944 if (flag_next_runtime)
12945 build_next_selector_translation_table ();
12947 build_gnu_selector_translation_table ();
12949 if (protocol_chain)
12950 generate_protocols ();
12952 if (flag_next_runtime)
12953 generate_objc_image_info ();
12955 if (imp_list || class_names_chain
12956 || meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
12957 generate_objc_symtab_decl ();
12959 /* Arrange for ObjC data structures to be initialized at run time. */
12960 if (objc_implementation_context || class_names_chain || objc_static_instances
12961 || meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
12963 build_module_descriptor ();
12965 if (!flag_next_runtime)
12966 build_module_initializer_routine ();
12969 /* Dump the class references. This forces the appropriate classes
12970 to be linked into the executable image, preserving unix archive
12971 semantics. This can be removed when we move to a more dynamically
12972 linked environment. */
12974 for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
12976 handle_class_ref (chain);
12977 if (TREE_PURPOSE (chain))
12978 generate_classref_translation_entry (chain);
12981 for (impent = imp_list; impent; impent = impent->next)
12982 handle_impent (impent);
12989 /* Run through the selector hash tables and print a warning for any
12990 selector which has multiple methods. */
12992 for (slot = 0; slot < SIZEHASHTABLE; slot++)
12994 for (hsh = cls_method_hash_list[slot]; hsh; hsh = hsh->next)
12995 check_duplicates (hsh, 0, 1);
12996 for (hsh = nst_method_hash_list[slot]; hsh; hsh = hsh->next)
12997 check_duplicates (hsh, 0, 1);
13001 warn_missing_braces = save_warn_missing_braces;
13004 /* Subroutines of finish_objc. */
13007 generate_classref_translation_entry (tree chain)
13009 tree expr, decl, type;
13011 decl = TREE_PURPOSE (chain);
13012 type = TREE_TYPE (decl);
13014 expr = add_objc_string (TREE_VALUE (chain), class_names);
13015 expr = convert (type, expr); /* cast! */
13017 /* This is a class reference. It is re-written by the runtime,
13018 but will be optimized away unless we force it. */
13019 DECL_PRESERVE_P (decl) = 1;
13020 finish_var_decl (decl, expr);
13025 handle_class_ref (tree chain)
13027 const char *name = IDENTIFIER_POINTER (TREE_VALUE (chain));
13028 char *string = (char *) alloca (strlen (name) + 30);
13032 sprintf (string, "%sobjc_class_name_%s",
13033 (flag_next_runtime ? "." : "__"), name);
13035 #ifdef ASM_DECLARE_UNRESOLVED_REFERENCE
13036 if (flag_next_runtime)
13038 ASM_DECLARE_UNRESOLVED_REFERENCE (asm_out_file, string);
13043 /* Make a decl for this name, so we can use its address in a tree. */
13044 decl = build_decl (input_location,
13045 VAR_DECL, get_identifier (string), TREE_TYPE (integer_zero_node));
13046 DECL_EXTERNAL (decl) = 1;
13047 TREE_PUBLIC (decl) = 1;
13049 finish_var_decl (decl, 0);
13051 /* Make a decl for the address. */
13052 sprintf (string, "%sobjc_class_ref_%s",
13053 (flag_next_runtime ? "." : "__"), name);
13054 exp = build1 (ADDR_EXPR, string_type_node, decl);
13055 decl = build_decl (input_location,
13056 VAR_DECL, get_identifier (string), string_type_node);
13057 TREE_STATIC (decl) = 1;
13058 TREE_USED (decl) = 1;
13059 DECL_READ_P (decl) = 1;
13060 DECL_ARTIFICIAL (decl) = 1;
13061 DECL_INITIAL (decl) = error_mark_node;
13063 /* We must force the reference. */
13064 DECL_PRESERVE_P (decl) = 1;
13067 finish_var_decl (decl, exp);
13071 handle_impent (struct imp_entry *impent)
13075 objc_implementation_context = impent->imp_context;
13076 implementation_template = impent->imp_template;
13078 switch (TREE_CODE (impent->imp_context))
13080 case CLASS_IMPLEMENTATION_TYPE:
13082 const char *const class_name =
13083 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
13085 string = (char *) alloca (strlen (class_name) + 30);
13087 sprintf (string, "%sobjc_class_name_%s",
13088 (flag_next_runtime ? "." : "__"), class_name);
13091 case CATEGORY_IMPLEMENTATION_TYPE:
13093 const char *const class_name =
13094 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
13095 const char *const class_super_name =
13096 IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context));
13098 string = (char *) alloca (strlen (class_name)
13099 + strlen (class_super_name) + 30);
13101 /* Do the same for categories. Even though no references to
13102 these symbols are generated automatically by the compiler,
13103 it gives you a handle to pull them into an archive by
13105 sprintf (string, "*%sobjc_category_name_%s_%s",
13106 (flag_next_runtime ? "." : "__"), class_name, class_super_name);
13113 #ifdef ASM_DECLARE_CLASS_REFERENCE
13114 if (flag_next_runtime)
13116 ASM_DECLARE_CLASS_REFERENCE (asm_out_file, string);
13124 init = integer_zero_node;
13125 decl = build_decl (input_location,
13126 VAR_DECL, get_identifier (string), TREE_TYPE (init));
13127 TREE_PUBLIC (decl) = 1;
13128 TREE_READONLY (decl) = 1;
13129 TREE_USED (decl) = 1;
13130 TREE_CONSTANT (decl) = 1;
13131 DECL_CONTEXT (decl) = NULL_TREE;
13132 DECL_ARTIFICIAL (decl) = 1;
13133 TREE_STATIC (decl) = 1;
13134 DECL_INITIAL (decl) = error_mark_node; /* A real initializer is coming... */
13135 /* We must force the reference. */
13136 DECL_PRESERVE_P (decl) = 1;
13138 finish_var_decl(decl, init) ;
13142 /* The Fix-and-Continue functionality available in Mac OS X 10.3 and
13143 later requires that ObjC translation units participating in F&C be
13144 specially marked. The following routine accomplishes this. */
13146 /* static int _OBJC_IMAGE_INFO[2] = { 0, 1 }; */
13149 generate_objc_image_info (void)
13153 = ((flag_replace_objc_classes && imp_count ? 1 : 0)
13154 | (flag_objc_gc ? 2 : 0));
13155 VEC(constructor_elt,gc) *v = NULL;
13159 return; /* No need for an image_info entry. */
13161 array_type = build_sized_array_type (integer_type_node, 2);
13163 decl = start_var_decl (array_type, "_OBJC_IMAGE_INFO");
13165 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node);
13166 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (integer_type_node, flags));
13167 /* If we need this (determined above) it is because the runtime wants to
13168 refer to it in a manner hidden from the compiler. So we must force the
13170 DECL_PRESERVE_P (decl) = 1;
13171 finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), v));
13174 /* Routine is called to issue diagnostic when reference to a private
13175 ivar is made and no other variable with same name is found in
13178 objc_diagnose_private_ivar (tree id)
13181 if (!objc_method_context)
13183 ivar = is_ivar (objc_ivar_chain, id);
13184 if (ivar && is_private (ivar))
13186 error ("instance variable %qs is declared private",
13187 IDENTIFIER_POINTER (id));
13193 /* Look up ID as an instance variable. OTHER contains the result of
13194 the C or C++ lookup, which we may want to use instead. */
13195 /* To use properties inside an instance method, use self.property. */
13197 objc_lookup_ivar (tree other, tree id)
13201 /* If we are not inside of an ObjC method, ivar lookup makes no sense. */
13202 if (!objc_method_context)
13205 if (!strcmp (IDENTIFIER_POINTER (id), "super"))
13206 /* We have a message to super. */
13207 return get_super_receiver ();
13209 /* In a class method, look up an instance variable only as a last
13211 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL
13212 && other && other != error_mark_node)
13215 /* Look up the ivar, but do not use it if it is not accessible. */
13216 ivar = is_ivar (objc_ivar_chain, id);
13218 if (!ivar || is_private (ivar))
13221 /* In an instance method, a local variable (or parameter) may hide the
13222 instance variable. */
13223 if (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
13224 && other && other != error_mark_node
13226 && CP_DECL_CONTEXT (other) != global_namespace)
13228 && !DECL_FILE_SCOPE_P (other))
13231 warning (0, "local declaration of %qE hides instance variable", id);
13236 /* At this point, we are either in an instance method with no obscuring
13237 local definitions, or in a class method with no alternate definitions
13239 return build_ivar_reference (id);
13242 /* Possibly rewrite a function CALL into an OBJ_TYPE_REF expression. This
13243 needs to be done if we are calling a function through a cast. */
13246 objc_rewrite_function_call (tree function, tree first_param)
13248 if (TREE_CODE (function) == NOP_EXPR
13249 && TREE_CODE (TREE_OPERAND (function, 0)) == ADDR_EXPR
13250 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (function, 0), 0))
13253 function = build3 (OBJ_TYPE_REF, TREE_TYPE (function),
13254 TREE_OPERAND (function, 0),
13255 first_param, size_zero_node);
13261 /* This is called to "gimplify" a PROPERTY_REF node. It builds the
13262 corresponding 'getter' function call. Note that we assume the
13263 PROPERTY_REF to be valid since we generated it while parsing. */
13265 objc_gimplify_property_ref (tree *expr_p)
13267 tree getter = PROPERTY_REF_GETTER_CALL (*expr_p);
13270 if (getter == NULL_TREE)
13272 tree property_decl = PROPERTY_REF_PROPERTY_DECL (*expr_p);
13273 /* This can happen if DECL_ARTIFICIAL (*expr_p), but
13274 should be impossible for real properties, which always
13276 error_at (EXPR_LOCATION (*expr_p), "no %qs getter found",
13277 IDENTIFIER_POINTER (PROPERTY_NAME (property_decl)));
13278 /* Try to recover from the error to prevent an ICE. We take
13279 zero and cast it to the type of the property. */
13280 *expr_p = convert (TREE_TYPE (property_decl),
13281 integer_zero_node);
13285 if (PROPERTY_REF_DEPRECATED_GETTER (*expr_p))
13287 /* PROPERTY_REF_DEPRECATED_GETTER contains the method prototype
13288 that is deprecated. */
13289 warn_deprecated_use (PROPERTY_REF_DEPRECATED_GETTER (*expr_p),
13295 /* In C++, a getter which returns an aggregate value results in a
13296 target_expr which initializes a temporary to the call
13298 if (TREE_CODE (getter) == TARGET_EXPR)
13300 gcc_assert (MAYBE_CLASS_TYPE_P (TREE_TYPE (getter)));
13301 gcc_assert (TREE_CODE (TREE_OPERAND (getter, 0)) == VAR_DECL);
13302 call_exp = TREE_OPERAND (getter, 1);
13305 gcc_assert (TREE_CODE (call_exp) == CALL_EXPR);
13307 *expr_p = call_exp;
13310 /* This is called when "gimplifying" the trees. We need to gimplify
13311 the Objective-C/Objective-C++ specific trees, then hand over the
13312 process to C/C++. */
13314 objc_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
13316 enum tree_code code = TREE_CODE (*expr_p);
13319 /* Look for the special case of OBJC_TYPE_REF with the address
13320 of a function in OBJ_TYPE_REF_EXPR (presumably objc_msgSend
13321 or one of its cousins). */
13323 if (TREE_CODE (OBJ_TYPE_REF_EXPR (*expr_p)) == ADDR_EXPR
13324 && TREE_CODE (TREE_OPERAND (OBJ_TYPE_REF_EXPR (*expr_p), 0))
13327 enum gimplify_status r0, r1;
13329 /* Postincrements in OBJ_TYPE_REF_OBJECT don't affect the
13330 value of the OBJ_TYPE_REF, so force them to be emitted
13331 during subexpression evaluation rather than after the
13332 OBJ_TYPE_REF. This permits objc_msgSend calls in
13333 Objective C to use direct rather than indirect calls when
13334 the object expression has a postincrement. */
13335 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, NULL,
13336 is_gimple_val, fb_rvalue);
13337 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
13338 is_gimple_val, fb_rvalue);
13340 return MIN (r0, r1);
13344 objc_gimplify_property_ref (expr_p);
13345 /* Do not return yet; let C/C++ gimplify the resulting expression. */
13352 return (enum gimplify_status) cp_gimplify_expr (expr_p, pre_p, post_p);
13354 return (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p);
13358 /* This routine returns true if TYPE is a valid objc object type,
13359 suitable for messaging; false otherwise. If 'accept_class' is
13360 'true', then a Class object is considered valid for messaging and
13361 'true' is returned if 'type' refers to a Class. If 'accept_class'
13362 is 'false', then a Class object is not considered valid for
13363 messaging and 'false' is returned in that case. */
13366 objc_type_valid_for_messaging (tree type, bool accept_classes)
13368 if (!POINTER_TYPE_P (type))
13371 /* Remove the pointer indirection; don't remove more than one
13372 otherwise we'd consider "NSObject **" a valid type for messaging,
13374 type = TREE_TYPE (type);
13376 if (TREE_CODE (type) != RECORD_TYPE)
13379 if (objc_is_object_id (type))
13382 if (objc_is_class_id (type))
13383 return accept_classes;
13385 if (TYPE_HAS_OBJC_INFO (type))
13391 /* Begin code generation for fast enumeration (foreach) ... */
13395 struct __objcFastEnumerationState
13397 unsigned long state;
13399 unsigned long *mutationsPtr;
13400 unsigned long extra[5];
13403 Confusingly enough, NSFastEnumeration is then defined by libraries
13404 to be the same structure.
13408 build_fast_enumeration_state_template (void)
13410 tree decls, *chain = NULL;
13413 objc_fast_enumeration_state_template = objc_start_struct (get_identifier
13414 (TAG_FAST_ENUMERATION_STATE));
13416 /* unsigned long state; */
13417 decls = add_field_decl (long_unsigned_type_node, "state", &chain);
13419 /* id *itemsPtr; */
13420 add_field_decl (build_pointer_type (objc_object_type),
13421 "itemsPtr", &chain);
13423 /* unsigned long *mutationsPtr; */
13424 add_field_decl (build_pointer_type (long_unsigned_type_node),
13425 "mutationsPtr", &chain);
13427 /* unsigned long extra[5]; */
13428 add_field_decl (build_sized_array_type (long_unsigned_type_node, 5),
13432 objc_finish_struct (objc_fast_enumeration_state_template, decls);
13436 'objc_finish_foreach_loop()' generates the code for an Objective-C
13437 foreach loop. The 'location' argument is the location of the 'for'
13438 that starts the loop. The 'object_expression' is the expression of
13439 the 'object' that iterates; the 'collection_expression' is the
13440 expression of the collection that we iterate over (we need to make
13441 sure we evaluate this only once); the 'for_body' is the set of
13442 statements to be executed in each iteration; 'break_label' and
13443 'continue_label' are the break and continue labels which we need to
13444 emit since the <statements> may be jumping to 'break_label' (if they
13445 contain 'break') or to 'continue_label' (if they contain
13450 for (<object expression> in <collection expression>)
13453 which is compiled into the following blurb:
13456 id __objc_foreach_collection;
13457 __objc_fast_enumeration_state __objc_foreach_enum_state;
13458 unsigned long __objc_foreach_batchsize;
13459 id __objc_foreach_items[16];
13460 __objc_foreach_collection = <collection expression>;
13461 __objc_foreach_enum_state = { 0 };
13462 __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16];
13464 if (__objc_foreach_batchsize == 0)
13465 <object expression> = nil;
13468 unsigned long __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr;
13471 unsigned long __objc_foreach_index;
13472 __objc_foreach_index = 0;
13475 if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>);
13476 <object expression> = enumState.itemsPtr[__objc_foreach_index];
13477 <statements> [PS: inside <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label]
13480 __objc_foreach_index++;
13481 if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object;
13482 __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16];
13484 if (__objc_foreach_batchsize != 0) goto next_batch;
13485 <object expression> = nil;
13490 'statements' may contain a 'continue' or 'break' instruction, which
13491 the user expects to 'continue' or 'break' the entire foreach loop.
13492 We are provided the labels that 'break' and 'continue' jump to, so
13493 we place them where we want them to jump to when they pick them.
13495 Optimization TODO: we could cache the IMP of
13496 countByEnumeratingWithState:objects:count:.
13499 /* If you need to debug objc_finish_foreach_loop(), uncomment the following line. */
13500 /* #define DEBUG_OBJC_FINISH_FOREACH_LOOP 1 */
13502 #ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP
13503 #include "tree-pretty-print.h"
13507 objc_finish_foreach_loop (location_t location, tree object_expression, tree collection_expression, tree for_body,
13508 tree break_label, tree continue_label)
13510 /* A tree representing the __objcFastEnumerationState struct type,
13511 or NSFastEnumerationState struct, whatever we are using. */
13512 tree objc_fast_enumeration_state_type;
13514 /* The trees representing the declarations of each of the local variables. */
13515 tree objc_foreach_collection_decl;
13516 tree objc_foreach_enum_state_decl;
13517 tree objc_foreach_items_decl;
13518 tree objc_foreach_batchsize_decl;
13519 tree objc_foreach_mutations_pointer_decl;
13520 tree objc_foreach_index_decl;
13522 /* A tree representing the selector countByEnumeratingWithState:objects:count:. */
13523 tree selector_name;
13525 /* A tree representing the local bind. */
13528 /* A tree representing the external 'if (__objc_foreach_batchsize)' */
13531 /* A tree representing the 'else' part of 'first_if' */
13534 /* A tree representing the 'next_batch' label. */
13535 tree next_batch_label_decl;
13537 /* A tree representing the binding after the 'next_batch' label. */
13538 tree next_batch_bind;
13540 /* A tree representing the 'next_object' label. */
13541 tree next_object_label_decl;
13543 /* Temporary variables. */
13547 if (flag_objc1_only)
13548 error_at (location, "fast enumeration is not available in Objective-C 1.0");
13550 if (object_expression == error_mark_node)
13553 if (collection_expression == error_mark_node)
13556 if (!objc_type_valid_for_messaging (TREE_TYPE (object_expression), true))
13558 error_at (location, "iterating variable in fast enumeration is not an object");
13562 if (!objc_type_valid_for_messaging (TREE_TYPE (collection_expression), true))
13564 error_at (location, "collection in fast enumeration is not an object");
13568 /* TODO: Check that object_expression is either a variable
13569 declaration, or an lvalue. */
13571 /* This kludge is an idea from apple. We use the
13572 __objcFastEnumerationState struct implicitly defined by the
13573 compiler, unless a NSFastEnumerationState struct has been defined
13574 (by a Foundation library such as GNUstep Base) in which case, we
13577 objc_fast_enumeration_state_type = objc_fast_enumeration_state_template;
13579 tree objc_NSFastEnumeration_type = lookup_name (get_identifier ("NSFastEnumerationState"));
13581 if (objc_NSFastEnumeration_type)
13583 /* TODO: We really need to check that
13584 objc_NSFastEnumeration_type is the same as ours! */
13585 if (TREE_CODE (objc_NSFastEnumeration_type) == TYPE_DECL)
13587 /* If it's a typedef, use the original type. */
13588 if (DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type))
13589 objc_fast_enumeration_state_type = DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type);
13591 objc_fast_enumeration_state_type = TREE_TYPE (objc_NSFastEnumeration_type);
13597 /* Done by c-parser.c. */
13600 /* Done by c-parser.c. */
13602 /* Disable warnings that 'object' is unused. For example the code
13604 for (id object in collection)
13607 which can be used to count how many objects there are in the
13608 collection is fine and should generate no warnings even if
13609 'object' is technically unused. */
13610 TREE_USED (object_expression) = 1;
13611 if (DECL_P (object_expression))
13612 DECL_READ_P (object_expression) = 1;
13614 /* id __objc_foreach_collection */
13615 objc_foreach_collection_decl = objc_create_temporary_var (objc_object_type, "__objc_foreach_collection");
13617 /* __objcFastEnumerationState __objc_foreach_enum_state; */
13618 objc_foreach_enum_state_decl = objc_create_temporary_var (objc_fast_enumeration_state_type, "__objc_foreach_enum_state");
13619 TREE_CHAIN (objc_foreach_enum_state_decl) = objc_foreach_collection_decl;
13621 /* id __objc_foreach_items[16]; */
13622 objc_foreach_items_decl = objc_create_temporary_var (build_sized_array_type (objc_object_type, 16), "__objc_foreach_items");
13623 TREE_CHAIN (objc_foreach_items_decl) = objc_foreach_enum_state_decl;
13625 /* unsigned long __objc_foreach_batchsize; */
13626 objc_foreach_batchsize_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_batchsize");
13627 TREE_CHAIN (objc_foreach_batchsize_decl) = objc_foreach_items_decl;
13629 /* Generate the local variable binding. */
13630 bind = build3 (BIND_EXPR, void_type_node, objc_foreach_batchsize_decl, NULL, NULL);
13631 SET_EXPR_LOCATION (bind, location);
13632 TREE_SIDE_EFFECTS (bind) = 1;
13634 /* __objc_foreach_collection = <collection expression>; */
13635 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_collection_decl, collection_expression);
13636 SET_EXPR_LOCATION (t, location);
13637 append_to_statement_list (t, &BIND_EXPR_BODY (bind));
13639 /* __objc_foreach_enum_state.state = 0; */
13640 t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl,
13641 get_identifier ("state")),
13642 build_int_cst (long_unsigned_type_node, 0));
13643 SET_EXPR_LOCATION (t, location);
13644 append_to_statement_list (t, &BIND_EXPR_BODY (bind));
13646 /* __objc_foreach_enum_state.itemsPtr = NULL; */
13647 t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl,
13648 get_identifier ("itemsPtr")),
13649 null_pointer_node);
13650 SET_EXPR_LOCATION (t, location);
13651 append_to_statement_list (t, &BIND_EXPR_BODY (bind));
13653 /* __objc_foreach_enum_state.mutationsPtr = NULL; */
13654 t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl,
13655 get_identifier ("mutationsPtr")),
13656 null_pointer_node);
13657 SET_EXPR_LOCATION (t, location);
13658 append_to_statement_list (t, &BIND_EXPR_BODY (bind));
13660 /* __objc_foreach_enum_state.extra[0] = 0; */
13661 /* __objc_foreach_enum_state.extra[1] = 0; */
13662 /* __objc_foreach_enum_state.extra[2] = 0; */
13663 /* __objc_foreach_enum_state.extra[3] = 0; */
13664 /* __objc_foreach_enum_state.extra[4] = 0; */
13665 for (i = 0; i < 5 ; i++)
13667 t = build2 (MODIFY_EXPR, void_type_node,
13668 build_array_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl,
13669 get_identifier ("extra")),
13670 build_int_cst (NULL_TREE, i)),
13671 build_int_cst (long_unsigned_type_node, 0));
13672 SET_EXPR_LOCATION (t, location);
13673 append_to_statement_list (t, &BIND_EXPR_BODY (bind));
13676 /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */
13677 selector_name = get_identifier ("countByEnumeratingWithState:objects:count:");
13679 t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name,
13681 tree_cons /* &__objc_foreach_enum_state */
13682 (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl),
13683 tree_cons /* __objc_foreach_items */
13684 (NULL_TREE, objc_foreach_items_decl,
13686 (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL);
13688 /* In C, we need to decay the __objc_foreach_items array that we are passing. */
13690 struct c_expr array;
13691 array.value = objc_foreach_items_decl;
13692 t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name,
13694 tree_cons /* &__objc_foreach_enum_state */
13695 (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl),
13696 tree_cons /* __objc_foreach_items */
13697 (NULL_TREE, default_function_array_conversion (location, array).value,
13699 (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL);
13702 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_batchsize_decl,
13703 convert (long_unsigned_type_node, t));
13704 SET_EXPR_LOCATION (t, location);
13705 append_to_statement_list (t, &BIND_EXPR_BODY (bind));
13707 /* if (__objc_foreach_batchsize == 0) */
13708 first_if = build3 (COND_EXPR, void_type_node,
13711 (c_common_truthvalue_conversion
13713 build_binary_op (location,
13715 objc_foreach_batchsize_decl,
13716 build_int_cst (long_unsigned_type_node, 0), 1)),
13718 /* Then block (we fill it in later). */
13720 /* Else block (we fill it in later). */
13722 SET_EXPR_LOCATION (first_if, location);
13723 append_to_statement_list (first_if, &BIND_EXPR_BODY (bind));
13725 /* then <object expression> = nil; */
13726 t = build2 (MODIFY_EXPR, void_type_node, object_expression, convert (objc_object_type, null_pointer_node));
13727 SET_EXPR_LOCATION (t, location);
13728 COND_EXPR_THEN (first_if) = t;
13730 /* Now we build the 'else' part of the if; once we finish building
13731 it, we attach it to first_if as the 'else' part. */
13736 /* unsigned long __objc_foreach_mutations_pointer; */
13737 objc_foreach_mutations_pointer_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_mutations_pointer");
13739 /* Generate the local variable binding. */
13740 first_else = build3 (BIND_EXPR, void_type_node, objc_foreach_mutations_pointer_decl, NULL, NULL);
13741 SET_EXPR_LOCATION (first_else, location);
13742 TREE_SIDE_EFFECTS (first_else) = 1;
13744 /* __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr; */
13745 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_mutations_pointer_decl,
13746 build_indirect_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl,
13747 get_identifier ("mutationsPtr")),
13749 SET_EXPR_LOCATION (t, location);
13750 append_to_statement_list (t, &BIND_EXPR_BODY (first_else));
13753 next_batch_label_decl = create_artificial_label (location);
13754 t = build1 (LABEL_EXPR, void_type_node, next_batch_label_decl);
13755 SET_EXPR_LOCATION (t, location);
13756 append_to_statement_list (t, &BIND_EXPR_BODY (first_else));
13760 /* unsigned long __objc_foreach_index; */
13761 objc_foreach_index_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_index");
13763 /* Generate the local variable binding. */
13764 next_batch_bind = build3 (BIND_EXPR, void_type_node, objc_foreach_index_decl, NULL, NULL);
13765 SET_EXPR_LOCATION (next_batch_bind, location);
13766 TREE_SIDE_EFFECTS (next_batch_bind) = 1;
13767 append_to_statement_list (next_batch_bind, &BIND_EXPR_BODY (first_else));
13769 /* __objc_foreach_index = 0; */
13770 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_index_decl,
13771 build_int_cst (long_unsigned_type_node, 0));
13772 SET_EXPR_LOCATION (t, location);
13773 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
13776 next_object_label_decl = create_artificial_label (location);
13777 t = build1 (LABEL_EXPR, void_type_node, next_object_label_decl);
13778 SET_EXPR_LOCATION (t, location);
13779 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
13781 /* if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>); */
13782 t = build3 (COND_EXPR, void_type_node,
13785 (c_common_truthvalue_conversion
13790 objc_foreach_mutations_pointer_decl,
13791 build_indirect_ref (location,
13792 objc_build_component_ref (objc_foreach_enum_state_decl,
13793 get_identifier ("mutationsPtr")),
13794 RO_UNARY_STAR), 1)),
13797 build_function_call (input_location,
13798 objc_enumeration_mutation_decl,
13799 tree_cons (NULL, collection_expression, NULL)),
13802 SET_EXPR_LOCATION (t, location);
13803 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
13805 /* <object expression> = enumState.itemsPtr[__objc_foreach_index]; */
13806 t = build2 (MODIFY_EXPR, void_type_node, object_expression,
13807 build_array_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl,
13808 get_identifier ("itemsPtr")),
13809 objc_foreach_index_decl));
13810 SET_EXPR_LOCATION (t, location);
13811 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
13813 /* <statements> [PS: in <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label] */
13814 append_to_statement_list (for_body, &BIND_EXPR_BODY (next_batch_bind));
13816 /* continue_label: */
13817 if (continue_label)
13819 t = build1 (LABEL_EXPR, void_type_node, continue_label);
13820 SET_EXPR_LOCATION (t, location);
13821 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
13824 /* __objc_foreach_index++; */
13825 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_index_decl,
13826 build_binary_op (location,
13828 objc_foreach_index_decl,
13829 build_int_cst (long_unsigned_type_node, 1), 1));
13830 SET_EXPR_LOCATION (t, location);
13831 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
13833 /* if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object; */
13834 t = build3 (COND_EXPR, void_type_node,
13837 (c_common_truthvalue_conversion
13839 build_binary_op (location,
13841 objc_foreach_index_decl,
13842 objc_foreach_batchsize_decl, 1)),
13845 build1 (GOTO_EXPR, void_type_node, next_object_label_decl),
13848 SET_EXPR_LOCATION (t, location);
13849 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
13851 /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */
13853 t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name,
13855 tree_cons /* &__objc_foreach_enum_state */
13856 (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl),
13857 tree_cons /* __objc_foreach_items */
13858 (NULL_TREE, objc_foreach_items_decl,
13860 (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL);
13862 /* In C, we need to decay the __objc_foreach_items array that we are passing. */
13864 struct c_expr array;
13865 array.value = objc_foreach_items_decl;
13866 t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name,
13868 tree_cons /* &__objc_foreach_enum_state */
13869 (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl),
13870 tree_cons /* __objc_foreach_items */
13871 (NULL_TREE, default_function_array_conversion (location, array).value,
13873 (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL);
13876 t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_batchsize_decl,
13877 convert (long_unsigned_type_node, t));
13878 SET_EXPR_LOCATION (t, location);
13879 append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
13883 /* if (__objc_foreach_batchsize != 0) goto next_batch; */
13884 t = build3 (COND_EXPR, void_type_node,
13887 (c_common_truthvalue_conversion
13889 build_binary_op (location,
13891 objc_foreach_batchsize_decl,
13892 build_int_cst (long_unsigned_type_node, 0), 1)),
13895 build1 (GOTO_EXPR, void_type_node, next_batch_label_decl),
13898 SET_EXPR_LOCATION (t, location);
13899 append_to_statement_list (t, &BIND_EXPR_BODY (first_else));
13901 /* <object expression> = nil; */
13902 t = build2 (MODIFY_EXPR, void_type_node, object_expression, convert (objc_object_type, null_pointer_node));
13903 SET_EXPR_LOCATION (t, location);
13904 append_to_statement_list (t, &BIND_EXPR_BODY (first_else));
13909 t = build1 (LABEL_EXPR, void_type_node, break_label);
13910 SET_EXPR_LOCATION (t, location);
13911 append_to_statement_list (t, &BIND_EXPR_BODY (first_else));
13915 COND_EXPR_ELSE (first_if) = first_else;
13917 /* Do the whole thing. */
13920 #ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP
13921 /* This will print to stderr the whole blurb generated by the
13922 compiler while compiling (assuming the compiler doesn't crash
13923 before getting here).
13925 debug_generic_stmt (bind);
13929 /* Done by c-parser.c */
13932 /* Return true if we have an NxString object pointer. */
13935 objc_string_ref_type_p (tree strp)
13938 if (!strp || TREE_CODE (strp) != POINTER_TYPE)
13941 tmv = TYPE_MAIN_VARIANT (TREE_TYPE (strp));
13942 tmv = OBJC_TYPE_NAME (tmv);
13944 && TREE_CODE (tmv) == IDENTIFIER_NODE
13945 && IDENTIFIER_POINTER (tmv)
13946 && !strncmp (IDENTIFIER_POINTER (tmv), "NSString", 8));
13949 /* At present the behavior of this is undefined and it does nothing. */
13951 objc_check_format_arg (tree ARG_UNUSED (format_arg),
13952 tree ARG_UNUSED (args_list))
13956 #include "gt-objc-objc-act.h"