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/>. */
24 /* Purpose: This module implements the Objective-C 4.0 language.
26 compatibility issues (with the Stepstone translator):
28 - does not recognize the following 3.3 constructs.
29 @requires, @classes, @messages, = (...)
30 - methods with variable arguments must conform to ANSI standard.
31 - tagged structure definitions that appear in BOTH the interface
32 and implementation are not allowed.
33 - public/private: all instance variables are public within the
34 context of the implementation...I consider this to be a bug in
36 - statically allocated objects are not supported. the user will
37 receive an error if this service is requested.
39 code generation `options':
45 #include "coretypes.h"
59 #include "langhooks.h"
62 #include "except.h" /* For USING_SJLJ_EXCEPTIONS. */
69 #include "diagnostic-core.h"
72 #include "tree-iterator.h"
74 #include "langhooks-def.h"
76 /* For enum gimplify_status */
79 #define OBJC_VOID_AT_END void_list_node
81 static unsigned int should_call_super_dealloc = 0;
83 /* When building Objective-C++, we need in_late_binary_op. */
85 bool in_late_binary_op = false;
88 /* When building Objective-C++, we are not linking against the C front-end
89 and so need to replicate the C tree-construction functions in some way. */
91 #define OBJCP_REMAP_FUNCTIONS
92 #include "objcp-decl.h"
95 /* This is the default way of generating a method name. */
96 /* I am not sure it is really correct.
97 Perhaps there's a danger that it will make name conflicts
98 if method names contain underscores. -- rms. */
99 #ifndef OBJC_GEN_METHOD_LABEL
100 #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
103 sprintf ((BUF), "_%s_%s_%s_%s", \
104 ((IS_INST) ? "i" : "c"), \
106 ((CAT_NAME)? (CAT_NAME) : ""), \
108 for (temp = (BUF); *temp; temp++) \
109 if (*temp == ':') *temp = '_'; \
113 /* These need specifying. */
114 #ifndef OBJC_FORWARDING_STACK_OFFSET
115 #define OBJC_FORWARDING_STACK_OFFSET 0
118 #ifndef OBJC_FORWARDING_MIN_OFFSET
119 #define OBJC_FORWARDING_MIN_OFFSET 0
122 /* Set up for use of obstacks. */
126 /* This obstack is used to accumulate the encoding of a data type. */
127 static struct obstack util_obstack;
129 /* This points to the beginning of obstack contents, so we can free
130 the whole contents. */
133 /* The version identifies which language generation and runtime
134 the module (file) was compiled for, and is recorded in the
135 module descriptor. */
137 #define OBJC_VERSION (flag_next_runtime ? 6 : 8)
138 #define PROTOCOL_VERSION 2
140 /* (Decide if these can ever be validly changed.) */
141 #define OBJC_ENCODE_INLINE_DEFS 0
142 #define OBJC_ENCODE_DONT_INLINE_DEFS 1
144 /*** Private Interface (procedures) ***/
146 /* Used by compile_file. */
148 static void init_objc (void);
149 static void finish_objc (void);
151 /* Code generation. */
153 static tree objc_build_constructor (tree, VEC(constructor_elt,gc) *);
154 static tree build_objc_method_call (location_t, int, tree, tree, tree, tree);
155 static tree get_proto_encoding (tree);
156 static tree lookup_interface (tree);
157 static tree objc_add_static_instance (tree, tree);
159 static tree start_class (enum tree_code, tree, tree, tree);
160 static tree continue_class (tree);
161 static void finish_class (tree);
162 static void start_method_def (tree);
164 static void objc_start_function (tree, tree, tree, tree);
166 static void objc_start_function (tree, tree, tree, struct c_arg_info *);
168 static tree start_protocol (enum tree_code, tree, tree);
169 static tree build_method_decl (enum tree_code, tree, tree, tree, bool);
170 static tree objc_add_method (tree, tree, int);
171 static tree add_instance_variable (tree, int, tree);
172 static tree build_ivar_reference (tree);
173 static tree is_ivar (tree, tree);
175 static void build_objc_exception_stuff (void);
176 static void build_next_objc_exception_stuff (void);
178 /* We only need the following for ObjC; ObjC++ will use C++'s definition
179 of DERIVED_FROM_P. */
181 static bool objc_derived_from_p (tree, tree);
182 #define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD)
184 static void objc_xref_basetypes (tree, tree);
186 static void build_class_template (void);
187 static void build_selector_template (void);
188 static void build_category_template (void);
189 static void build_super_template (void);
190 static tree build_protocol_initializer (tree, tree, tree, tree, tree);
191 static tree get_class_ivars (tree, bool);
192 static tree generate_protocol_list (tree);
193 static void build_protocol_reference (tree);
196 static void objc_generate_cxx_cdtors (void);
199 static const char *synth_id_with_class_suffix (const char *, tree);
201 /* Hash tables to manage the global pool of method prototypes. */
203 hash *nst_method_hash_list = 0;
204 hash *cls_method_hash_list = 0;
206 static hash hash_lookup (hash *, tree);
207 static tree lookup_method (tree, tree);
208 static tree lookup_method_static (tree, tree, int);
212 class_names, /* class, category, protocol, module names */
213 meth_var_names, /* method and variable names */
214 meth_var_types /* method and variable type descriptors */
217 static tree add_objc_string (tree, enum string_section);
218 static tree build_objc_string_decl (enum string_section);
219 static void build_selector_table_decl (void);
221 /* Protocol additions. */
223 static tree lookup_protocol (tree);
224 static tree lookup_and_install_protocols (tree);
228 static void encode_type_qualifiers (tree);
229 static void encode_type (tree, int, int);
230 static void encode_field_decl (tree, int, int);
233 static void really_start_method (tree, tree);
235 static void really_start_method (tree, struct c_arg_info *);
237 static int comp_proto_with_proto (tree, tree, int);
238 static void objc_push_parm (tree);
240 static tree objc_get_parm_info (int);
242 static struct c_arg_info *objc_get_parm_info (int);
245 /* Utilities for debugging and error diagnostics. */
247 static char *gen_type_name (tree);
248 static char *gen_type_name_0 (tree);
249 static char *gen_method_decl (tree);
250 static char *gen_declaration (tree);
252 /* Everything else. */
254 static tree create_field_decl (tree, const char *);
255 static void add_class_reference (tree);
256 static void build_protocol_template (void);
257 static tree encode_method_prototype (tree);
258 static void generate_classref_translation_entry (tree);
259 static void handle_class_ref (tree);
260 static void generate_struct_by_value_array (void)
262 static void mark_referenced_methods (void);
263 static void generate_objc_image_info (void);
265 /*** Private Interface (data) ***/
267 /* Reserved tag definitions. */
269 #define OBJECT_TYPEDEF_NAME "id"
270 #define CLASS_TYPEDEF_NAME "Class"
272 #define TAG_OBJECT "objc_object"
273 #define TAG_CLASS "objc_class"
274 #define TAG_SUPER "objc_super"
275 #define TAG_SELECTOR "objc_selector"
277 #define UTAG_CLASS "_objc_class"
278 #define UTAG_IVAR "_objc_ivar"
279 #define UTAG_IVAR_LIST "_objc_ivar_list"
280 #define UTAG_METHOD "_objc_method"
281 #define UTAG_METHOD_LIST "_objc_method_list"
282 #define UTAG_CATEGORY "_objc_category"
283 #define UTAG_MODULE "_objc_module"
284 #define UTAG_SYMTAB "_objc_symtab"
285 #define UTAG_SUPER "_objc_super"
286 #define UTAG_SELECTOR "_objc_selector"
288 #define UTAG_PROTOCOL "_objc_protocol"
289 #define UTAG_METHOD_PROTOTYPE "_objc_method_prototype"
290 #define UTAG_METHOD_PROTOTYPE_LIST "_objc__method_prototype_list"
292 /* Note that the string object global name is only needed for the
294 #define STRING_OBJECT_GLOBAL_FORMAT "_%sClassReference"
296 #define PROTOCOL_OBJECT_CLASS_NAME "Protocol"
298 static const char *TAG_GETCLASS;
299 static const char *TAG_GETMETACLASS;
300 static const char *TAG_MSGSEND;
301 static const char *TAG_MSGSENDSUPER;
302 /* The NeXT Objective-C messenger may have two extra entry points, for use
303 when returning a structure. */
304 static const char *TAG_MSGSEND_STRET;
305 static const char *TAG_MSGSENDSUPER_STRET;
306 static const char *default_constant_string_class_name;
308 /* Runtime metadata flags. */
309 #define CLS_FACTORY 0x0001L
310 #define CLS_META 0x0002L
311 #define CLS_HAS_CXX_STRUCTORS 0x2000L
313 #define OBJC_MODIFIER_STATIC 0x00000001
314 #define OBJC_MODIFIER_FINAL 0x00000002
315 #define OBJC_MODIFIER_PUBLIC 0x00000004
316 #define OBJC_MODIFIER_PRIVATE 0x00000008
317 #define OBJC_MODIFIER_PROTECTED 0x00000010
318 #define OBJC_MODIFIER_NATIVE 0x00000020
319 #define OBJC_MODIFIER_SYNCHRONIZED 0x00000040
320 #define OBJC_MODIFIER_ABSTRACT 0x00000080
321 #define OBJC_MODIFIER_VOLATILE 0x00000100
322 #define OBJC_MODIFIER_TRANSIENT 0x00000200
323 #define OBJC_MODIFIER_NONE_SPECIFIED 0x80000000
325 /* NeXT-specific tags. */
327 #define TAG_MSGSEND_NONNIL "objc_msgSendNonNil"
328 #define TAG_MSGSEND_NONNIL_STRET "objc_msgSendNonNil_stret"
329 #define TAG_EXCEPTIONEXTRACT "objc_exception_extract"
330 #define TAG_EXCEPTIONTRYENTER "objc_exception_try_enter"
331 #define TAG_EXCEPTIONTRYEXIT "objc_exception_try_exit"
332 #define TAG_EXCEPTIONMATCH "objc_exception_match"
333 #define TAG_EXCEPTIONTHROW "objc_exception_throw"
334 #define TAG_SYNCENTER "objc_sync_enter"
335 #define TAG_SYNCEXIT "objc_sync_exit"
336 #define TAG_SETJMP "_setjmp"
337 #define UTAG_EXCDATA "_objc_exception_data"
339 #define TAG_ASSIGNIVAR "objc_assign_ivar"
340 #define TAG_ASSIGNGLOBAL "objc_assign_global"
341 #define TAG_ASSIGNSTRONGCAST "objc_assign_strongCast"
343 /* Branch entry points. All that matters here are the addresses;
344 functions with these names do not really exist in libobjc. */
346 #define TAG_MSGSEND_FAST "objc_msgSend_Fast"
347 #define TAG_ASSIGNIVAR_FAST "objc_assign_ivar_Fast"
349 #define TAG_CXX_CONSTRUCT ".cxx_construct"
350 #define TAG_CXX_DESTRUCT ".cxx_destruct"
352 /* GNU-specific tags. */
354 #define TAG_EXECCLASS "__objc_exec_class"
355 #define TAG_GNUINIT "__objc_gnu_init"
357 /* Flags for lookup_method_static(). */
358 #define OBJC_LOOKUP_CLASS 1 /* Look for class methods. */
359 #define OBJC_LOOKUP_NO_SUPER 2 /* Do not examine superclasses. */
361 /* The OCTI_... enumeration itself is in objc/objc-act.h. */
362 tree objc_global_trees[OCTI_MAX];
364 static void handle_impent (struct imp_entry *);
366 struct imp_entry *imp_list = 0;
367 int imp_count = 0; /* `@implementation' */
368 int cat_count = 0; /* `@category' */
370 enum tree_code objc_inherit_code;
371 int objc_public_flag;
373 /* Use to generate method labels. */
374 static int method_slot = 0;
378 static char *errbuf; /* Buffer for error diagnostics */
380 /* Data imported from tree.c. */
382 extern enum debug_info_type write_symbols;
384 /* Data imported from toplev.c. */
386 extern const char *dump_base_name;
388 static int flag_typed_selectors;
390 /* Store all constructed constant strings in a hash table so that
391 they get uniqued properly. */
393 struct GTY(()) string_descriptor {
394 /* The literal argument . */
397 /* The resulting constant string. */
401 static GTY((param_is (struct string_descriptor))) htab_t string_htab;
403 /* Store the EH-volatilized types in a hash table, for easy retrieval. */
404 struct GTY(()) volatilized_type {
408 static GTY((param_is (struct volatilized_type))) htab_t volatilized_htab;
410 FILE *gen_declaration_file;
412 /* Tells "encode_pointer/encode_aggregate" whether we are generating
413 type descriptors for instance variables (as opposed to methods).
414 Type descriptors for instance variables contain more information
415 than methods (for static typing and embedded structures). */
417 static int generating_instance_variables = 0;
419 /* For building an objc struct. These may not be used when this file
420 is compiled as part of obj-c++. */
422 static bool objc_building_struct;
423 static struct c_struct_parse_info *objc_struct_info ATTRIBUTE_UNUSED;
425 /* Start building a struct for objc. */
428 objc_start_struct (tree name)
430 gcc_assert (!objc_building_struct);
431 objc_building_struct = true;
432 return start_struct (input_location, RECORD_TYPE, name, &objc_struct_info);
435 /* Finish building a struct for objc. */
438 objc_finish_struct (tree type, tree fieldlist)
440 gcc_assert (objc_building_struct);
441 objc_building_struct = false;
442 return finish_struct (input_location, type, fieldlist, NULL_TREE,
446 /* Some platforms pass small structures through registers versus
447 through an invisible pointer. Determine at what size structure is
448 the transition point between the two possibilities. */
451 generate_struct_by_value_array (void)
454 tree field_decl, field_decl_chain;
456 int aggregate_in_mem[32];
459 /* Presumably no platform passes 32 byte structures in a register. */
460 for (i = 1; i < 32; i++)
464 /* Create an unnamed struct that has `i' character components */
465 type = objc_start_struct (NULL_TREE);
467 strcpy (buffer, "c1");
468 field_decl = create_field_decl (char_type_node,
470 field_decl_chain = field_decl;
472 for (j = 1; j < i; j++)
474 sprintf (buffer, "c%d", j + 1);
475 field_decl = create_field_decl (char_type_node,
477 chainon (field_decl_chain, field_decl);
479 objc_finish_struct (type, field_decl_chain);
481 aggregate_in_mem[i] = aggregate_value_p (type, 0);
482 if (!aggregate_in_mem[i])
486 /* We found some structures that are returned in registers instead of memory
487 so output the necessary data. */
490 for (i = 31; i >= 0; i--)
491 if (!aggregate_in_mem[i])
493 printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n\n", i);
495 /* The first member of the structure is always 0 because we don't handle
496 structures with 0 members */
497 printf ("static int struct_forward_array[] = {\n 0");
499 for (j = 1; j <= i; j++)
500 printf (", %d", aggregate_in_mem[j]);
511 if (cxx_init () == false)
513 if (c_objc_common_init () == false)
517 /* If gen_declaration desired, open the output file. */
518 if (flag_gen_declaration)
520 register char * const dumpname = concat (dump_base_name, ".decl", NULL);
521 gen_declaration_file = fopen (dumpname, "w");
522 if (gen_declaration_file == 0)
523 fatal_error ("can't open %s: %m", dumpname);
527 if (flag_next_runtime)
529 TAG_GETCLASS = "objc_getClass";
530 TAG_GETMETACLASS = "objc_getMetaClass";
531 TAG_MSGSEND = "objc_msgSend";
532 TAG_MSGSENDSUPER = "objc_msgSendSuper";
533 TAG_MSGSEND_STRET = "objc_msgSend_stret";
534 TAG_MSGSENDSUPER_STRET = "objc_msgSendSuper_stret";
535 default_constant_string_class_name = "NSConstantString";
539 TAG_GETCLASS = "objc_get_class";
540 TAG_GETMETACLASS = "objc_get_meta_class";
541 TAG_MSGSEND = "objc_msg_lookup";
542 TAG_MSGSENDSUPER = "objc_msg_lookup_super";
543 /* GNU runtime does not provide special functions to support
544 structure-returning methods. */
545 default_constant_string_class_name = "NXConstantString";
546 flag_typed_selectors = 1;
547 /* GNU runtime does not need the compiler to change code
548 in order to do GC. */
551 warning_at (0, 0, "%<-fobjc-gc%> is ignored for %<-fgnu-runtime%>");
558 if (print_struct_values && !flag_compare_debug)
559 generate_struct_by_value_array ();
565 objc_finish_file (void)
567 mark_referenced_methods ();
570 /* We need to instantiate templates _before_ we emit ObjC metadata;
571 if we do not, some metadata (such as selectors) may go missing. */
573 instantiate_pending_templates (0);
576 /* Finalize Objective-C runtime data. No need to generate tables
577 and code if only checking syntax, or if generating a PCH file. */
578 if (!flag_syntax_only && !pch_file)
581 if (gen_declaration_file)
582 fclose (gen_declaration_file);
585 /* Return the first occurrence of a method declaration corresponding
586 to sel_name in rproto_list. Search rproto_list recursively.
587 If is_class is 0, search for instance methods, otherwise for class
590 lookup_method_in_protocol_list (tree rproto_list, tree sel_name,
596 for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
598 p = TREE_VALUE (rproto);
600 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
602 if ((fnd = lookup_method (is_class
603 ? PROTOCOL_CLS_METHODS (p)
604 : PROTOCOL_NST_METHODS (p), sel_name)))
606 else if (PROTOCOL_LIST (p))
607 fnd = lookup_method_in_protocol_list (PROTOCOL_LIST (p),
612 ; /* An identifier...if we could not find a protocol. */
623 lookup_protocol_in_reflist (tree rproto_list, tree lproto)
627 /* Make sure the protocol is supported by the object on the rhs. */
628 if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE)
631 for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
633 p = TREE_VALUE (rproto);
635 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
640 else if (PROTOCOL_LIST (p))
641 fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto);
650 ; /* An identifier...if we could not find a protocol. */
657 objc_start_class_interface (tree klass, tree super_class, tree protos)
659 objc_interface_context
661 = start_class (CLASS_INTERFACE_TYPE, klass, super_class, protos);
662 objc_public_flag = 0;
666 objc_start_category_interface (tree klass, tree categ, tree protos)
668 objc_interface_context
669 = start_class (CATEGORY_INTERFACE_TYPE, klass, categ, protos);
671 = continue_class (objc_interface_context);
675 objc_start_protocol (tree name, tree protos)
677 objc_interface_context
678 = start_protocol (PROTOCOL_INTERFACE_TYPE, name, protos);
682 objc_continue_interface (void)
685 = continue_class (objc_interface_context);
689 objc_finish_interface (void)
691 finish_class (objc_interface_context);
692 objc_interface_context = NULL_TREE;
696 objc_start_class_implementation (tree klass, tree super_class)
698 objc_implementation_context
700 = start_class (CLASS_IMPLEMENTATION_TYPE, klass, super_class, NULL_TREE);
701 objc_public_flag = 0;
705 objc_start_category_implementation (tree klass, tree categ)
707 objc_implementation_context
708 = start_class (CATEGORY_IMPLEMENTATION_TYPE, klass, categ, NULL_TREE);
710 = continue_class (objc_implementation_context);
714 objc_continue_implementation (void)
717 = continue_class (objc_implementation_context);
721 objc_finish_implementation (void)
724 if (flag_objc_call_cxx_cdtors)
725 objc_generate_cxx_cdtors ();
728 if (objc_implementation_context)
730 finish_class (objc_implementation_context);
731 objc_ivar_chain = NULL_TREE;
732 objc_implementation_context = NULL_TREE;
735 warning (0, "%<@end%> must appear in an @implementation context");
739 objc_set_visibility (int visibility)
741 objc_public_flag = visibility;
745 objc_set_method_type (enum tree_code type)
747 objc_inherit_code = (type == PLUS_EXPR
749 : INSTANCE_METHOD_DECL);
753 objc_build_method_signature (tree rettype, tree selector,
754 tree optparms, bool ellipsis)
756 return build_method_decl (objc_inherit_code, rettype, selector,
761 objc_add_method_declaration (tree decl)
763 if (!objc_interface_context)
764 fatal_error ("method declaration not in @interface context");
766 objc_add_method (objc_interface_context,
768 objc_inherit_code == CLASS_METHOD_DECL);
772 objc_start_method_definition (tree decl)
774 if (!objc_implementation_context)
775 fatal_error ("method definition not in @implementation context");
777 objc_add_method (objc_implementation_context,
779 objc_inherit_code == CLASS_METHOD_DECL);
780 start_method_def (decl);
784 objc_add_instance_variable (tree decl)
786 (void) add_instance_variable (objc_ivar_context,
791 /* Return 1 if IDENT is an ObjC/ObjC++ reserved keyword in the context of
795 objc_is_reserved_word (tree ident)
797 unsigned char code = C_RID_CODE (ident);
799 return (OBJC_IS_AT_KEYWORD (code)
800 || code == RID_CLASS || code == RID_PUBLIC
801 || code == RID_PROTECTED || code == RID_PRIVATE
802 || code == RID_TRY || code == RID_THROW || code == RID_CATCH);
805 /* Return true if TYPE is 'id'. */
808 objc_is_object_id (tree type)
810 return OBJC_TYPE_NAME (type) == objc_object_id;
814 objc_is_class_id (tree type)
816 return OBJC_TYPE_NAME (type) == objc_class_id;
819 /* Construct a C struct with same name as KLASS, a base struct with tag
820 SUPER_NAME (if any), and FIELDS indicated. */
823 objc_build_struct (tree klass, tree fields, tree super_name)
825 tree name = CLASS_NAME (klass);
826 tree s = objc_start_struct (name);
827 tree super = (super_name ? xref_tag (RECORD_TYPE, super_name) : NULL_TREE);
828 tree t, objc_info = NULL_TREE;
832 /* Prepend a packed variant of the base class into the layout. This
833 is necessary to preserve ObjC ABI compatibility. */
834 tree base = build_decl (input_location,
835 FIELD_DECL, NULL_TREE, super);
836 tree field = TYPE_FIELDS (super);
838 while (field && TREE_CHAIN (field)
839 && TREE_CODE (TREE_CHAIN (field)) == FIELD_DECL)
840 field = TREE_CHAIN (field);
842 /* For ObjC ABI purposes, the "packed" size of a base class is
843 the sum of the offset and the size (in bits) of the last field
846 = (field && TREE_CODE (field) == FIELD_DECL
847 ? size_binop (PLUS_EXPR,
848 size_binop (PLUS_EXPR,
851 convert (bitsizetype,
852 DECL_FIELD_OFFSET (field)),
853 bitsize_int (BITS_PER_UNIT)),
854 DECL_FIELD_BIT_OFFSET (field)),
856 : bitsize_zero_node);
857 DECL_SIZE_UNIT (base)
858 = size_binop (FLOOR_DIV_EXPR, convert (sizetype, DECL_SIZE (base)),
859 size_int (BITS_PER_UNIT));
860 DECL_ARTIFICIAL (base) = 1;
861 DECL_ALIGN (base) = 1;
862 DECL_FIELD_CONTEXT (base) = s;
864 DECL_FIELD_IS_BASE (base) = 1;
867 TREE_NO_WARNING (fields) = 1; /* Suppress C++ ABI warnings -- we */
868 #endif /* are following the ObjC ABI here. */
869 TREE_CHAIN (base) = fields;
873 /* NB: Calling finish_struct() may cause type TYPE_LANG_SPECIFIC fields
874 in all variants of this RECORD_TYPE to be clobbered, but it is therein
875 that we store protocol conformance info (e.g., 'NSObject <MyProtocol>').
876 Hence, we must squirrel away the ObjC-specific information before calling
877 finish_struct(), and then reinstate it afterwards. */
879 for (t = TYPE_NEXT_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t))
881 if (!TYPE_HAS_OBJC_INFO (t))
883 INIT_TYPE_OBJC_INFO (t);
884 TYPE_OBJC_INTERFACE (t) = klass;
887 = chainon (objc_info,
888 build_tree_list (NULL_TREE, TYPE_OBJC_INFO (t)));
891 /* Point the struct at its related Objective-C class. */
892 INIT_TYPE_OBJC_INFO (s);
893 TYPE_OBJC_INTERFACE (s) = klass;
895 s = objc_finish_struct (s, fields);
897 for (t = TYPE_NEXT_VARIANT (s); t;
898 t = TYPE_NEXT_VARIANT (t), objc_info = TREE_CHAIN (objc_info))
900 TYPE_OBJC_INFO (t) = TREE_VALUE (objc_info);
901 /* Replace the IDENTIFIER_NODE with an actual @interface. */
902 TYPE_OBJC_INTERFACE (t) = klass;
905 /* Use TYPE_BINFO structures to point at the super class, if any. */
906 objc_xref_basetypes (s, super);
908 /* Mark this struct as a class template. */
909 CLASS_STATIC_TEMPLATE (klass) = s;
914 /* Build a type differing from TYPE only in that TYPE_VOLATILE is set.
915 Unlike tree.c:build_qualified_type(), preserve TYPE_LANG_SPECIFIC in the
918 objc_build_volatilized_type (tree type)
922 /* Check if we have not constructed the desired variant already. */
923 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
925 /* The type qualifiers must (obviously) match up. */
926 if (!TYPE_VOLATILE (t)
927 || (TYPE_READONLY (t) != TYPE_READONLY (type))
928 || (TYPE_RESTRICT (t) != TYPE_RESTRICT (type)))
931 /* For pointer types, the pointees (and hence their TYPE_LANG_SPECIFIC
932 info, if any) must match up. */
933 if (POINTER_TYPE_P (t)
934 && (TREE_TYPE (t) != TREE_TYPE (type)))
937 /* Everything matches up! */
941 /* Ok, we could not re-use any of the pre-existing variants. Create
943 t = build_variant_type_copy (type);
944 TYPE_VOLATILE (t) = 1;
946 /* Set up the canonical type information. */
947 if (TYPE_STRUCTURAL_EQUALITY_P (type))
948 SET_TYPE_STRUCTURAL_EQUALITY (t);
949 else if (TYPE_CANONICAL (type) != type)
950 TYPE_CANONICAL (t) = objc_build_volatilized_type (TYPE_CANONICAL (type));
952 TYPE_CANONICAL (t) = t;
957 /* Mark DECL as being 'volatile' for purposes of Darwin
958 _setjmp()/_longjmp() exception handling. Called from
959 objc_mark_locals_volatile(). */
961 objc_volatilize_decl (tree decl)
963 /* Do not mess with variables that are 'static' or (already)
965 if (!TREE_THIS_VOLATILE (decl) && !TREE_STATIC (decl)
966 && (TREE_CODE (decl) == VAR_DECL
967 || TREE_CODE (decl) == PARM_DECL))
969 tree t = TREE_TYPE (decl);
970 struct volatilized_type key;
973 t = objc_build_volatilized_type (t);
975 loc = htab_find_slot (volatilized_htab, &key, INSERT);
979 *loc = ggc_alloc (sizeof (key));
980 ((struct volatilized_type *) *loc)->type = t;
983 TREE_TYPE (decl) = t;
984 TREE_THIS_VOLATILE (decl) = 1;
985 TREE_SIDE_EFFECTS (decl) = 1;
986 DECL_REGISTER (decl) = 0;
988 C_DECL_REGISTER (decl) = 0;
993 /* Check if protocol PROTO is adopted (directly or indirectly) by class CLS
994 (including its categories and superclasses) or by object type TYP.
995 Issue a warning if PROTO is not adopted anywhere and WARN is set. */
998 objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn)
1000 bool class_type = (cls != NULL_TREE);
1006 /* Check protocols adopted by the class and its categories. */
1007 for (c = cls; c; c = CLASS_CATEGORY_LIST (c))
1009 if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c), proto))
1013 /* Repeat for superclasses. */
1014 cls = lookup_interface (CLASS_SUPER_NAME (cls));
1017 /* Check for any protocols attached directly to the object type. */
1018 if (TYPE_HAS_OBJC_INFO (typ))
1020 if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ), proto))
1027 gen_type_name_0 (class_type ? typ : TYPE_POINTER_TO (typ));
1028 /* NB: Types 'id' and 'Class' cannot reasonably be described as
1029 "implementing" a given protocol, since they do not have an
1032 warning (0, "class %qs does not implement the %qE protocol",
1033 identifier_to_locale (errbuf), PROTOCOL_NAME (proto));
1035 warning (0, "type %qs does not conform to the %qE protocol",
1036 identifier_to_locale (errbuf), PROTOCOL_NAME (proto));
1042 /* Check if class RCLS and instance struct type RTYP conform to at least the
1043 same protocols that LCLS and LTYP conform to. */
1046 objc_compare_protocols (tree lcls, tree ltyp, tree rcls, tree rtyp, bool warn)
1049 bool have_lproto = false;
1053 /* NB: We do _not_ look at categories defined for LCLS; these may or
1054 may not get loaded in, and therefore it is unreasonable to require
1055 that RCLS/RTYP must implement any of their protocols. */
1056 for (p = CLASS_PROTOCOL_LIST (lcls); p; p = TREE_CHAIN (p))
1060 if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
1064 /* Repeat for superclasses. */
1065 lcls = lookup_interface (CLASS_SUPER_NAME (lcls));
1068 /* Check for any protocols attached directly to the object type. */
1069 if (TYPE_HAS_OBJC_INFO (ltyp))
1071 for (p = TYPE_OBJC_PROTOCOL_LIST (ltyp); p; p = TREE_CHAIN (p))
1075 if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
1080 /* NB: If LTYP and LCLS have no protocols to search for, return 'true'
1081 vacuously, _unless_ RTYP is a protocol-qualified 'id'. We can get
1082 away with simply checking for 'id' or 'Class' (!RCLS), since this
1083 routine will not get called in other cases. */
1084 return have_lproto || (rcls != NULL_TREE);
1087 /* Determine if it is permissible to assign (if ARGNO is greater than -3)
1088 an instance of RTYP to an instance of LTYP or to compare the two
1089 (if ARGNO is equal to -3), per ObjC type system rules. Before
1090 returning 'true', this routine may issue warnings related to, e.g.,
1091 protocol conformance. When returning 'false', the routine must
1092 produce absolutely no warnings; the C or C++ front-end will do so
1093 instead, if needed. If either LTYP or RTYP is not an Objective-C type,
1094 the routine must return 'false'.
1096 The ARGNO parameter is encoded as follows:
1097 >= 1 Parameter number (CALLEE contains function being called);
1101 -3 Comparison (LTYP and RTYP may match in either direction). */
1104 objc_compare_types (tree ltyp, tree rtyp, int argno, tree callee)
1106 tree lcls, rcls, lproto, rproto;
1107 bool pointers_compatible;
1109 /* We must be dealing with pointer types */
1110 if (!POINTER_TYPE_P (ltyp) || !POINTER_TYPE_P (rtyp))
1115 ltyp = TREE_TYPE (ltyp); /* Remove indirections. */
1116 rtyp = TREE_TYPE (rtyp);
1118 while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp));
1120 /* Past this point, we are only interested in ObjC class instances,
1121 or 'id' or 'Class'. */
1122 if (TREE_CODE (ltyp) != RECORD_TYPE || TREE_CODE (rtyp) != RECORD_TYPE)
1125 if (!objc_is_object_id (ltyp) && !objc_is_class_id (ltyp)
1126 && !TYPE_HAS_OBJC_INFO (ltyp))
1129 if (!objc_is_object_id (rtyp) && !objc_is_class_id (rtyp)
1130 && !TYPE_HAS_OBJC_INFO (rtyp))
1133 /* Past this point, we are committed to returning 'true' to the caller.
1134 However, we can still warn about type and/or protocol mismatches. */
1136 if (TYPE_HAS_OBJC_INFO (ltyp))
1138 lcls = TYPE_OBJC_INTERFACE (ltyp);
1139 lproto = TYPE_OBJC_PROTOCOL_LIST (ltyp);
1142 lcls = lproto = NULL_TREE;
1144 if (TYPE_HAS_OBJC_INFO (rtyp))
1146 rcls = TYPE_OBJC_INTERFACE (rtyp);
1147 rproto = TYPE_OBJC_PROTOCOL_LIST (rtyp);
1150 rcls = rproto = NULL_TREE;
1152 /* If we could not find an @interface declaration, we must have
1153 only seen a @class declaration; for purposes of type comparison,
1154 treat it as a stand-alone (root) class. */
1156 if (lcls && TREE_CODE (lcls) == IDENTIFIER_NODE)
1159 if (rcls && TREE_CODE (rcls) == IDENTIFIER_NODE)
1162 /* If either type is an unqualified 'id', we're done. */
1163 if ((!lproto && objc_is_object_id (ltyp))
1164 || (!rproto && objc_is_object_id (rtyp)))
1167 pointers_compatible = (TYPE_MAIN_VARIANT (ltyp) == TYPE_MAIN_VARIANT (rtyp));
1169 /* If the underlying types are the same, and at most one of them has
1170 a protocol list, we do not need to issue any diagnostics. */
1171 if (pointers_compatible && (!lproto || !rproto))
1174 /* If exactly one of the types is 'Class', issue a diagnostic; any
1175 exceptions of this rule have already been handled. */
1176 if (objc_is_class_id (ltyp) ^ objc_is_class_id (rtyp))
1177 pointers_compatible = false;
1178 /* Otherwise, check for inheritance relations. */
1181 if (!pointers_compatible)
1183 = (objc_is_object_id (ltyp) || objc_is_object_id (rtyp));
1185 if (!pointers_compatible)
1186 pointers_compatible = DERIVED_FROM_P (ltyp, rtyp);
1188 if (!pointers_compatible && argno == -3)
1189 pointers_compatible = DERIVED_FROM_P (rtyp, ltyp);
1192 /* If the pointers match modulo protocols, check for protocol conformance
1194 if (pointers_compatible)
1196 pointers_compatible = objc_compare_protocols (lcls, ltyp, rcls, rtyp,
1199 if (!pointers_compatible && argno == -3)
1200 pointers_compatible = objc_compare_protocols (rcls, rtyp, lcls, ltyp,
1204 if (!pointers_compatible)
1206 /* NB: For the time being, we shall make our warnings look like their
1207 C counterparts. In the future, we may wish to make them more
1212 warning (0, "comparison of distinct Objective-C types lacks a cast");
1216 warning (0, "initialization from distinct Objective-C type");
1220 warning (0, "assignment from distinct Objective-C type");
1224 warning (0, "distinct Objective-C type in return");
1228 warning (0, "passing argument %d of %qE from distinct "
1229 "Objective-C type", argno, callee);
1237 /* Check if LTYP and RTYP have the same type qualifiers. If either type
1238 lives in the volatilized hash table, ignore the 'volatile' bit when
1239 making the comparison. */
1242 objc_type_quals_match (tree ltyp, tree rtyp)
1244 int lquals = TYPE_QUALS (ltyp), rquals = TYPE_QUALS (rtyp);
1245 struct volatilized_type key;
1249 if (htab_find_slot (volatilized_htab, &key, NO_INSERT))
1250 lquals &= ~TYPE_QUAL_VOLATILE;
1254 if (htab_find_slot (volatilized_htab, &key, NO_INSERT))
1255 rquals &= ~TYPE_QUAL_VOLATILE;
1257 return (lquals == rquals);
1261 /* Determine if CHILD is derived from PARENT. The routine assumes that
1262 both parameters are RECORD_TYPEs, and is non-reflexive. */
1265 objc_derived_from_p (tree parent, tree child)
1267 parent = TYPE_MAIN_VARIANT (parent);
1269 for (child = TYPE_MAIN_VARIANT (child);
1270 TYPE_BINFO (child) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child));)
1272 child = TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO
1273 (TYPE_BINFO (child),
1276 if (child == parent)
1285 objc_build_component_ref (tree datum, tree component)
1287 /* If COMPONENT is NULL, the caller is referring to the anonymous
1288 base class field. */
1291 tree base = TYPE_FIELDS (TREE_TYPE (datum));
1293 return build3 (COMPONENT_REF, TREE_TYPE (base), datum, base, NULL_TREE);
1296 /* The 'build_component_ref' routine has been removed from the C++
1297 front-end, but 'finish_class_member_access_expr' seems to be
1298 a worthy substitute. */
1300 return finish_class_member_access_expr (datum, component, false,
1301 tf_warning_or_error);
1303 return build_component_ref (input_location, datum, component);
1307 /* Recursively copy inheritance information rooted at BINFO. To do this,
1308 we emulate the song and dance performed by cp/tree.c:copy_binfo(). */
1311 objc_copy_binfo (tree binfo)
1313 tree btype = BINFO_TYPE (binfo);
1314 tree binfo2 = make_tree_binfo (BINFO_N_BASE_BINFOS (binfo));
1318 BINFO_TYPE (binfo2) = btype;
1319 BINFO_OFFSET (binfo2) = BINFO_OFFSET (binfo);
1320 BINFO_BASE_ACCESSES (binfo2) = BINFO_BASE_ACCESSES (binfo);
1322 /* Recursively copy base binfos of BINFO. */
1323 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1325 tree base_binfo2 = objc_copy_binfo (base_binfo);
1327 BINFO_INHERITANCE_CHAIN (base_binfo2) = binfo2;
1328 BINFO_BASE_APPEND (binfo2, base_binfo2);
1334 /* Record superclass information provided in BASETYPE for ObjC class REF.
1335 This is loosely based on cp/decl.c:xref_basetypes(). */
1338 objc_xref_basetypes (tree ref, tree basetype)
1340 tree binfo = make_tree_binfo (basetype ? 1 : 0);
1342 TYPE_BINFO (ref) = binfo;
1343 BINFO_OFFSET (binfo) = size_zero_node;
1344 BINFO_TYPE (binfo) = ref;
1348 tree base_binfo = objc_copy_binfo (TYPE_BINFO (basetype));
1350 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
1351 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, 1);
1352 BINFO_BASE_APPEND (binfo, base_binfo);
1353 BINFO_BASE_ACCESS_APPEND (binfo, access_public_node);
1358 volatilized_hash (const void *ptr)
1360 const_tree const typ = ((const struct volatilized_type *)ptr)->type;
1362 return htab_hash_pointer(typ);
1366 volatilized_eq (const void *ptr1, const void *ptr2)
1368 const_tree const typ1 = ((const struct volatilized_type *)ptr1)->type;
1369 const_tree const typ2 = ((const struct volatilized_type *)ptr2)->type;
1371 return typ1 == typ2;
1374 /* Called from finish_decl. */
1377 objc_check_decl (tree decl)
1379 tree type = TREE_TYPE (decl);
1381 if (TREE_CODE (type) != RECORD_TYPE)
1383 if (OBJC_TYPE_NAME (type) && (type = objc_is_class_name (OBJC_TYPE_NAME (type))))
1384 error ("statically allocated instance of Objective-C class %qE",
1388 /* Construct a PROTOCOLS-qualified variant of INTERFACE, where INTERFACE may
1389 either name an Objective-C class, or refer to the special 'id' or 'Class'
1390 types. If INTERFACE is not a valid ObjC type, just return it unchanged. */
1393 objc_get_protocol_qualified_type (tree interface, tree protocols)
1395 /* If INTERFACE is not provided, default to 'id'. */
1396 tree type = (interface ? objc_is_id (interface) : objc_object_type);
1397 bool is_ptr = (type != NULL_TREE);
1401 type = objc_is_class_name (interface);
1404 type = xref_tag (RECORD_TYPE, type);
1411 type = build_variant_type_copy (type);
1413 /* For pointers (i.e., 'id' or 'Class'), attach the protocol(s)
1417 tree orig_pointee_type = TREE_TYPE (type);
1418 TREE_TYPE (type) = build_variant_type_copy (orig_pointee_type);
1420 /* Set up the canonical type information. */
1421 TYPE_CANONICAL (type)
1422 = TYPE_CANONICAL (TYPE_POINTER_TO (orig_pointee_type));
1424 TYPE_POINTER_TO (TREE_TYPE (type)) = type;
1425 type = TREE_TYPE (type);
1428 /* Look up protocols and install in lang specific list. */
1429 DUP_TYPE_OBJC_INFO (type, TYPE_MAIN_VARIANT (type));
1430 TYPE_OBJC_PROTOCOL_LIST (type) = lookup_and_install_protocols (protocols);
1432 /* For RECORD_TYPEs, point to the @interface; for 'id' and 'Class',
1433 return the pointer to the new pointee variant. */
1435 type = TYPE_POINTER_TO (type);
1437 TYPE_OBJC_INTERFACE (type)
1438 = TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type));
1444 /* Check for circular dependencies in protocols. The arguments are
1445 PROTO, the protocol to check, and LIST, a list of protocol it
1449 check_protocol_recursively (tree proto, tree list)
1453 for (p = list; p; p = TREE_CHAIN (p))
1455 tree pp = TREE_VALUE (p);
1457 if (TREE_CODE (pp) == IDENTIFIER_NODE)
1458 pp = lookup_protocol (pp);
1461 fatal_error ("protocol %qE has circular dependency",
1462 PROTOCOL_NAME (pp));
1464 check_protocol_recursively (proto, PROTOCOL_LIST (pp));
1468 /* Look up PROTOCOLS, and return a list of those that are found.
1469 If none are found, return NULL. */
1472 lookup_and_install_protocols (tree protocols)
1475 tree return_value = NULL_TREE;
1477 for (proto = protocols; proto; proto = TREE_CHAIN (proto))
1479 tree ident = TREE_VALUE (proto);
1480 tree p = lookup_protocol (ident);
1483 return_value = chainon (return_value,
1484 build_tree_list (NULL_TREE, p));
1485 else if (ident != error_mark_node)
1486 error ("cannot find protocol declaration for %qE",
1490 return return_value;
1493 /* Create a declaration for field NAME of a given TYPE. */
1496 create_field_decl (tree type, const char *name)
1498 return build_decl (input_location,
1499 FIELD_DECL, get_identifier (name), type);
1502 /* Create a global, static declaration for variable NAME of a given TYPE. The
1503 finish_var_decl() routine will need to be called on it afterwards. */
1506 start_var_decl (tree type, const char *name)
1508 tree var = build_decl (input_location,
1509 VAR_DECL, get_identifier (name), type);
1511 TREE_STATIC (var) = 1;
1512 DECL_INITIAL (var) = error_mark_node; /* A real initializer is coming... */
1513 DECL_IGNORED_P (var) = 1;
1514 DECL_ARTIFICIAL (var) = 1;
1515 DECL_CONTEXT (var) = NULL_TREE;
1517 DECL_THIS_STATIC (var) = 1; /* squash redeclaration errors */
1523 /* Finish off the variable declaration created by start_var_decl(). */
1526 finish_var_decl (tree var, tree initializer)
1528 finish_decl (var, input_location, initializer, NULL_TREE, NULL_TREE);
1529 /* Ensure that the variable actually gets output. */
1530 mark_decl_referenced (var);
1531 /* Mark the decl to avoid "defined but not used" warning. */
1532 TREE_USED (var) = 1;
1533 DECL_READ_P (var) = 1;
1534 /* We reserve the right for the runtime to use/modify these variables
1535 in ways that are opaque to us. */
1536 DECL_PRESERVE_P (var) = 1;
1539 /* Find the decl for the constant string class reference. This is only
1540 used for the NeXT runtime. */
1543 setup_string_decl (void)
1548 /* %s in format will provide room for terminating null */
1549 length = strlen (STRING_OBJECT_GLOBAL_FORMAT)
1550 + strlen (constant_string_class_name);
1551 name = XNEWVEC (char, length);
1552 sprintf (name, STRING_OBJECT_GLOBAL_FORMAT,
1553 constant_string_class_name);
1554 constant_string_global_id = get_identifier (name);
1555 string_class_decl = lookup_name (constant_string_global_id);
1557 return string_class_decl;
1560 /* Purpose: "play" parser, creating/installing representations
1561 of the declarations that are required by Objective-C.
1565 type_spec--------->sc_spec
1566 (tree_list) (tree_list)
1569 identifier_node identifier_node */
1572 synth_module_prologue (void)
1575 enum debug_info_type save_write_symbols = write_symbols;
1576 const struct gcc_debug_hooks *const save_hooks = debug_hooks;
1578 /* Suppress outputting debug symbols, because
1579 dbxout_init hasn't been called yet. */
1580 write_symbols = NO_DEBUG;
1581 debug_hooks = &do_nothing_debug_hooks;
1584 push_lang_context (lang_name_c); /* extern "C" */
1587 /* The following are also defined in <objc/objc.h> and friends. */
1589 objc_object_id = get_identifier (TAG_OBJECT);
1590 objc_class_id = get_identifier (TAG_CLASS);
1592 objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
1593 objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id);
1595 objc_object_type = build_pointer_type (objc_object_reference);
1596 objc_class_type = build_pointer_type (objc_class_reference);
1598 objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME);
1599 objc_class_name = get_identifier (CLASS_TYPEDEF_NAME);
1601 /* Declare the 'id' and 'Class' typedefs. */
1603 type = lang_hooks.decls.pushdecl (build_decl (input_location,
1607 TREE_NO_WARNING (type) = 1;
1608 type = lang_hooks.decls.pushdecl (build_decl (input_location,
1612 TREE_NO_WARNING (type) = 1;
1614 /* Forward-declare '@interface Protocol'. */
1616 type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
1617 objc_declare_class (tree_cons (NULL_TREE, type, NULL_TREE));
1618 objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
1621 /* Declare type of selector-objects that represent an operation name. */
1623 if (flag_next_runtime)
1624 /* `struct objc_selector *' */
1626 = build_pointer_type (xref_tag (RECORD_TYPE,
1627 get_identifier (TAG_SELECTOR)));
1629 /* `const struct objc_selector *' */
1631 = build_pointer_type
1632 (build_qualified_type (xref_tag (RECORD_TYPE,
1633 get_identifier (TAG_SELECTOR)),
1636 /* Declare receiver type used for dispatching messages to 'super'. */
1638 /* `struct objc_super *' */
1639 objc_super_type = build_pointer_type (xref_tag (RECORD_TYPE,
1640 get_identifier (TAG_SUPER)));
1642 /* Declare pointers to method and ivar lists. */
1643 objc_method_list_ptr = build_pointer_type
1644 (xref_tag (RECORD_TYPE,
1645 get_identifier (UTAG_METHOD_LIST)));
1646 objc_method_proto_list_ptr
1647 = build_pointer_type (xref_tag (RECORD_TYPE,
1648 get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
1649 objc_ivar_list_ptr = build_pointer_type
1650 (xref_tag (RECORD_TYPE,
1651 get_identifier (UTAG_IVAR_LIST)));
1653 /* TREE_NOTHROW is cleared for the message-sending functions,
1654 because the function that gets called can throw in Obj-C++, or
1655 could itself call something that can throw even in Obj-C. */
1657 if (flag_next_runtime)
1659 /* NB: In order to call one of the ..._stret (struct-returning)
1660 functions, the function *MUST* first be cast to a signature that
1661 corresponds to the actual ObjC method being invoked. This is
1662 what is done by the build_objc_method_call() routine below. */
1664 /* id objc_msgSend (id, SEL, ...); */
1665 /* id objc_msgSendNonNil (id, SEL, ...); */
1666 /* id objc_msgSend_stret (id, SEL, ...); */
1667 /* id objc_msgSendNonNil_stret (id, SEL, ...); */
1669 = build_varargs_function_type_list (objc_object_type,
1673 umsg_decl = add_builtin_function (TAG_MSGSEND,
1674 type, 0, NOT_BUILT_IN,
1676 umsg_nonnil_decl = add_builtin_function (TAG_MSGSEND_NONNIL,
1677 type, 0, NOT_BUILT_IN,
1679 umsg_stret_decl = add_builtin_function (TAG_MSGSEND_STRET,
1680 type, 0, NOT_BUILT_IN,
1682 umsg_nonnil_stret_decl = add_builtin_function (TAG_MSGSEND_NONNIL_STRET,
1683 type, 0, NOT_BUILT_IN,
1686 /* These can throw, because the function that gets called can throw
1687 in Obj-C++, or could itself call something that can throw even
1689 TREE_NOTHROW (umsg_decl) = 0;
1690 TREE_NOTHROW (umsg_nonnil_decl) = 0;
1691 TREE_NOTHROW (umsg_stret_decl) = 0;
1692 TREE_NOTHROW (umsg_nonnil_stret_decl) = 0;
1694 /* id objc_msgSend_Fast (id, SEL, ...)
1695 __attribute__ ((hard_coded_address (OFFS_MSGSEND_FAST))); */
1696 #ifdef OFFS_MSGSEND_FAST
1697 umsg_fast_decl = add_builtin_function (TAG_MSGSEND_FAST,
1698 type, 0, NOT_BUILT_IN,
1700 TREE_NOTHROW (umsg_fast_decl) = 0;
1701 DECL_ATTRIBUTES (umsg_fast_decl)
1702 = tree_cons (get_identifier ("hard_coded_address"),
1703 build_int_cst (NULL_TREE, OFFS_MSGSEND_FAST),
1706 /* No direct dispatch available. */
1707 umsg_fast_decl = umsg_decl;
1710 /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
1711 /* id objc_msgSendSuper_stret (struct objc_super *, SEL, ...); */
1713 = build_varargs_function_type_list (objc_object_type,
1717 umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
1718 type, 0, NOT_BUILT_IN,
1720 umsg_super_stret_decl = add_builtin_function (TAG_MSGSENDSUPER_STRET,
1721 type, 0, NOT_BUILT_IN, 0,
1723 TREE_NOTHROW (umsg_super_decl) = 0;
1724 TREE_NOTHROW (umsg_super_stret_decl) = 0;
1728 /* GNU runtime messenger entry points. */
1730 /* typedef id (*IMP)(id, SEL, ...); */
1732 build_varargs_function_type_list (objc_object_type,
1736 tree IMP_type = build_pointer_type (ftype);
1738 /* IMP objc_msg_lookup (id, SEL); */
1739 type = build_function_type_list (IMP_type,
1743 umsg_decl = add_builtin_function (TAG_MSGSEND,
1744 type, 0, NOT_BUILT_IN,
1746 TREE_NOTHROW (umsg_decl) = 0;
1748 /* IMP objc_msg_lookup_super (struct objc_super *, SEL); */
1750 = build_function_type_list (IMP_type,
1754 umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
1755 type, 0, NOT_BUILT_IN,
1757 TREE_NOTHROW (umsg_super_decl) = 0;
1759 /* The following GNU runtime entry point is called to initialize
1762 __objc_exec_class (void *); */
1764 = build_function_type_list (void_type_node,
1767 execclass_decl = add_builtin_function (TAG_EXECCLASS,
1768 type, 0, NOT_BUILT_IN,
1772 /* id objc_getClass (const char *); */
1774 type = build_function_type_list (objc_object_type,
1775 const_string_type_node,
1779 = add_builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN,
1782 /* id objc_getMetaClass (const char *); */
1784 objc_get_meta_class_decl
1785 = add_builtin_function (TAG_GETMETACLASS, type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
1787 build_class_template ();
1788 build_super_template ();
1789 build_protocol_template ();
1790 build_category_template ();
1791 build_objc_exception_stuff ();
1793 if (flag_next_runtime)
1794 build_next_objc_exception_stuff ();
1796 /* static SEL _OBJC_SELECTOR_TABLE[]; */
1798 if (! flag_next_runtime)
1799 build_selector_table_decl ();
1801 /* Forward declare constant_string_id and constant_string_type. */
1802 if (!constant_string_class_name)
1803 constant_string_class_name = default_constant_string_class_name;
1805 constant_string_id = get_identifier (constant_string_class_name);
1806 objc_declare_class (tree_cons (NULL_TREE, constant_string_id, NULL_TREE));
1808 /* Pre-build the following entities - for speed/convenience. */
1809 self_id = get_identifier ("self");
1810 ucmd_id = get_identifier ("_cmd");
1813 pop_lang_context ();
1816 write_symbols = save_write_symbols;
1817 debug_hooks = save_hooks;
1820 /* Ensure that the ivar list for NSConstantString/NXConstantString
1821 (or whatever was specified via `-fconstant-string-class')
1822 contains fields at least as large as the following three, so that
1823 the runtime can stomp on them with confidence:
1825 struct STRING_OBJECT_CLASS_NAME
1829 unsigned int length;
1833 check_string_class_template (void)
1835 tree field_decl = objc_get_class_ivars (constant_string_id);
1837 #define AT_LEAST_AS_LARGE_AS(F, T) \
1838 (F && TREE_CODE (F) == FIELD_DECL \
1839 && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \
1840 >= TREE_INT_CST_LOW (TYPE_SIZE (T))))
1842 if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
1845 field_decl = TREE_CHAIN (field_decl);
1846 if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
1849 field_decl = TREE_CHAIN (field_decl);
1850 return AT_LEAST_AS_LARGE_AS (field_decl, unsigned_type_node);
1852 #undef AT_LEAST_AS_LARGE_AS
1855 /* Avoid calling `check_string_class_template ()' more than once. */
1856 static GTY(()) int string_layout_checked;
1858 /* Construct an internal string layout to be used as a template for
1859 creating NSConstantString/NXConstantString instances. */
1862 objc_build_internal_const_str_type (void)
1864 tree type = (*lang_hooks.types.make_type) (RECORD_TYPE);
1865 tree fields = build_decl (input_location,
1866 FIELD_DECL, NULL_TREE, ptr_type_node);
1867 tree field = build_decl (input_location,
1868 FIELD_DECL, NULL_TREE, ptr_type_node);
1870 TREE_CHAIN (field) = fields; fields = field;
1871 field = build_decl (input_location,
1872 FIELD_DECL, NULL_TREE, unsigned_type_node);
1873 TREE_CHAIN (field) = fields; fields = field;
1874 /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in
1876 finish_builtin_struct (type, "__builtin_ObjCString",
1882 /* Custom build_string which sets TREE_TYPE! */
1885 my_build_string (int len, const char *str)
1887 return fix_string_type (build_string (len, str));
1890 /* Build a string with contents STR and length LEN and convert it to a
1894 my_build_string_pointer (int len, const char *str)
1896 tree string = my_build_string (len, str);
1897 tree ptrtype = build_pointer_type (TREE_TYPE (TREE_TYPE (string)));
1898 return build1 (ADDR_EXPR, ptrtype, string);
1902 string_hash (const void *ptr)
1904 const_tree const str = ((const struct string_descriptor *)ptr)->literal;
1905 const unsigned char *p = (const unsigned char *) TREE_STRING_POINTER (str);
1906 int i, len = TREE_STRING_LENGTH (str);
1909 for (i = 0; i < len; i++)
1910 h = ((h * 613) + p[i]);
1916 string_eq (const void *ptr1, const void *ptr2)
1918 const_tree const str1 = ((const struct string_descriptor *)ptr1)->literal;
1919 const_tree const str2 = ((const struct string_descriptor *)ptr2)->literal;
1920 int len1 = TREE_STRING_LENGTH (str1);
1922 return (len1 == TREE_STRING_LENGTH (str2)
1923 && !memcmp (TREE_STRING_POINTER (str1), TREE_STRING_POINTER (str2),
1927 /* Given a chain of STRING_CST's, build a static instance of
1928 NXConstantString which points at the concatenation of those
1929 strings. We place the string object in the __string_objects
1930 section of the __OBJC segment. The Objective-C runtime will
1931 initialize the isa pointers of the string objects to point at the
1932 NXConstantString class object. */
1935 objc_build_string_object (tree string)
1937 tree constructor, constant_string_class;
1940 struct string_descriptor *desc, key;
1943 /* Prep the string argument. */
1944 string = fix_string_type (string);
1945 TREE_SET_CODE (string, STRING_CST);
1946 length = TREE_STRING_LENGTH (string) - 1;
1948 /* Check whether the string class being used actually exists and has the
1949 correct ivar layout. */
1950 if (!string_layout_checked)
1952 string_layout_checked = -1;
1953 constant_string_class = lookup_interface (constant_string_id);
1954 internal_const_str_type = objc_build_internal_const_str_type ();
1956 if (!constant_string_class
1957 || !(constant_string_type
1958 = CLASS_STATIC_TEMPLATE (constant_string_class)))
1959 error ("cannot find interface declaration for %qE",
1960 constant_string_id);
1961 /* The NSConstantString/NXConstantString ivar layout is now known. */
1962 else if (!check_string_class_template ())
1963 error ("interface %qE does not have valid constant string layout",
1964 constant_string_id);
1965 /* For the NeXT runtime, we can generate a literal reference
1966 to the string class, don't need to run a constructor. */
1967 else if (flag_next_runtime && !setup_string_decl ())
1968 error ("cannot find reference tag for class %qE",
1969 constant_string_id);
1972 string_layout_checked = 1; /* Success! */
1973 add_class_reference (constant_string_id);
1977 if (string_layout_checked == -1)
1978 return error_mark_node;
1980 /* Perhaps we already constructed a constant string just like this one? */
1981 key.literal = string;
1982 loc = htab_find_slot (string_htab, &key, INSERT);
1983 desc = (struct string_descriptor *) *loc;
1988 VEC(constructor_elt,gc) *v = NULL;
1989 *loc = desc = GGC_NEW (struct string_descriptor);
1990 desc->literal = string;
1992 /* GNU: (NXConstantString *) & ((__builtin_ObjCString) { NULL, string, length }) */
1993 /* NeXT: (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length }) */
1994 fields = TYPE_FIELDS (internal_const_str_type);
1995 CONSTRUCTOR_APPEND_ELT (v, fields,
1997 ? build_unary_op (input_location,
1998 ADDR_EXPR, string_class_decl, 0)
1999 : build_int_cst (NULL_TREE, 0));
2000 fields = TREE_CHAIN (fields);
2001 CONSTRUCTOR_APPEND_ELT (v, fields,
2002 build_unary_op (input_location,
2003 ADDR_EXPR, string, 1));
2004 fields = TREE_CHAIN (fields);
2005 CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, length));
2006 constructor = objc_build_constructor (internal_const_str_type, v);
2008 if (!flag_next_runtime)
2010 = objc_add_static_instance (constructor, constant_string_type);
2013 var = build_decl (input_location,
2014 CONST_DECL, NULL, TREE_TYPE (constructor));
2015 DECL_INITIAL (var) = constructor;
2016 TREE_STATIC (var) = 1;
2017 pushdecl_top_level (var);
2020 desc->constructor = constructor;
2023 addr = convert (build_pointer_type (constant_string_type),
2024 build_unary_op (input_location,
2025 ADDR_EXPR, desc->constructor, 1));
2030 /* Declare a static instance of CLASS_DECL initialized by CONSTRUCTOR. */
2032 static GTY(()) int num_static_inst;
2035 objc_add_static_instance (tree constructor, tree class_decl)
2040 /* Find the list of static instances for the CLASS_DECL. Create one if
2042 for (chain = &objc_static_instances;
2043 *chain && TREE_VALUE (*chain) != class_decl;
2044 chain = &TREE_CHAIN (*chain));
2047 *chain = tree_cons (NULL_TREE, class_decl, NULL_TREE);
2048 add_objc_string (OBJC_TYPE_NAME (class_decl), class_names);
2051 sprintf (buf, "_OBJC_INSTANCE_%d", num_static_inst++);
2052 decl = build_decl (input_location,
2053 VAR_DECL, get_identifier (buf), class_decl);
2054 TREE_STATIC (decl) = 1;
2055 DECL_ARTIFICIAL (decl) = 1;
2056 TREE_USED (decl) = 1;
2057 DECL_INITIAL (decl) = constructor;
2059 /* We may be writing something else just now.
2060 Postpone till end of input. */
2061 DECL_DEFER_OUTPUT (decl) = 1;
2062 pushdecl_top_level (decl);
2063 rest_of_decl_compilation (decl, 1, 0);
2065 /* Add the DECL to the head of this CLASS' list. */
2066 TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, decl, TREE_PURPOSE (*chain));
2071 /* Build a static constant CONSTRUCTOR
2072 with type TYPE and elements ELTS. */
2075 objc_build_constructor (tree type, VEC(constructor_elt,gc) *elts)
2077 tree constructor = build_constructor (type, elts);
2079 TREE_CONSTANT (constructor) = 1;
2080 TREE_STATIC (constructor) = 1;
2081 TREE_READONLY (constructor) = 1;
2084 /* Adjust for impedance mismatch. We should figure out how to build
2085 CONSTRUCTORs that consistently please both the C and C++ gods. */
2086 if (!VEC_index (constructor_elt, elts, 0)->index)
2087 TREE_TYPE (constructor) = init_list_type_node;
2093 /* Take care of defining and initializing _OBJC_SYMBOLS. */
2095 /* Predefine the following data type:
2103 void *defs[cls_def_cnt + cat_def_cnt];
2107 build_objc_symtab_template (void)
2109 tree field_decl, field_decl_chain;
2111 objc_symtab_template = objc_start_struct (get_identifier (UTAG_SYMTAB));
2113 /* long sel_ref_cnt; */
2114 field_decl = create_field_decl (long_integer_type_node, "sel_ref_cnt");
2115 field_decl_chain = field_decl;
2118 field_decl = create_field_decl (build_pointer_type (objc_selector_type),
2120 chainon (field_decl_chain, field_decl);
2122 /* short cls_def_cnt; */
2123 field_decl = create_field_decl (short_integer_type_node, "cls_def_cnt");
2124 chainon (field_decl_chain, field_decl);
2126 /* short cat_def_cnt; */
2127 field_decl = create_field_decl (short_integer_type_node,
2129 chainon (field_decl_chain, field_decl);
2131 if (imp_count || cat_count || !flag_next_runtime)
2133 /* void *defs[imp_count + cat_count (+ 1)]; */
2134 /* NB: The index is one less than the size of the array. */
2135 int index = imp_count + cat_count
2136 + (flag_next_runtime? -1: 0);
2137 field_decl = create_field_decl
2140 build_index_type (build_int_cst (NULL_TREE, index))),
2142 chainon (field_decl_chain, field_decl);
2145 objc_finish_struct (objc_symtab_template, field_decl_chain);
2148 /* Create the initial value for the `defs' field of _objc_symtab.
2149 This is a CONSTRUCTOR. */
2152 init_def_list (tree type)
2155 struct imp_entry *impent;
2156 VEC(constructor_elt,gc) *v = NULL;
2159 for (impent = imp_list; impent; impent = impent->next)
2161 if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
2163 expr = build_unary_op (input_location,
2164 ADDR_EXPR, impent->class_decl, 0);
2165 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2170 for (impent = imp_list; impent; impent = impent->next)
2172 if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
2174 expr = build_unary_op (input_location,
2175 ADDR_EXPR, impent->class_decl, 0);
2176 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2180 if (!flag_next_runtime)
2182 /* statics = { ..., _OBJC_STATIC_INSTANCES, ... } */
2183 if (static_instances_decl)
2184 expr = build_unary_op (input_location,
2185 ADDR_EXPR, static_instances_decl, 0);
2187 expr = build_int_cst (NULL_TREE, 0);
2189 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2192 return objc_build_constructor (type, v);
2195 /* Construct the initial value for all of _objc_symtab. */
2198 init_objc_symtab (tree type)
2200 VEC(constructor_elt,gc) *v = NULL;
2202 /* sel_ref_cnt = { ..., 5, ... } */
2204 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
2205 build_int_cst (long_integer_type_node, 0));
2207 /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
2209 if (flag_next_runtime || ! sel_ref_chain)
2210 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
2213 tree expr = build_unary_op (input_location, ADDR_EXPR,
2214 UOBJC_SELECTOR_TABLE_decl, 1);
2216 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
2217 convert (build_pointer_type (objc_selector_type),
2221 /* cls_def_cnt = { ..., 5, ... } */
2223 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, imp_count));
2225 /* cat_def_cnt = { ..., 5, ... } */
2227 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, cat_count));
2229 /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
2231 if (imp_count || cat_count || !flag_next_runtime)
2234 tree field = TYPE_FIELDS (type);
2235 field = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (field))));
2237 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init_def_list (TREE_TYPE (field)));
2240 return objc_build_constructor (type, v);
2243 /* Generate forward declarations for metadata such as
2244 'OBJC_CLASS_...'. */
2247 build_metadata_decl (const char *name, tree type)
2251 /* struct TYPE NAME_<name>; */
2252 decl = start_var_decl (type, synth_id_with_class_suffix
2254 objc_implementation_context));
2259 /* Push forward-declarations of all the categories so that
2260 init_def_list can use them in a CONSTRUCTOR. */
2263 forward_declare_categories (void)
2265 struct imp_entry *impent;
2266 tree sav = objc_implementation_context;
2268 for (impent = imp_list; impent; impent = impent->next)
2270 if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
2272 /* Set an invisible arg to synth_id_with_class_suffix. */
2273 objc_implementation_context = impent->imp_context;
2274 /* extern struct objc_category _OBJC_CATEGORY_<name>; */
2275 impent->class_decl = build_metadata_decl ("_OBJC_CATEGORY",
2276 objc_category_template);
2279 objc_implementation_context = sav;
2282 /* Create the declaration of _OBJC_SYMBOLS, with type `struct _objc_symtab'
2283 and initialized appropriately. */
2286 generate_objc_symtab_decl (void)
2288 /* forward declare categories */
2290 forward_declare_categories ();
2292 build_objc_symtab_template ();
2293 UOBJC_SYMBOLS_decl = start_var_decl (objc_symtab_template, "_OBJC_SYMBOLS");
2294 finish_var_decl (UOBJC_SYMBOLS_decl,
2295 init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl)));
2299 init_module_descriptor (tree type)
2302 VEC(constructor_elt,gc) *v = NULL;
2304 /* version = { 1, ... } */
2306 expr = build_int_cst (long_integer_type_node, OBJC_VERSION);
2307 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2309 /* size = { ..., sizeof (struct _objc_module), ... } */
2311 expr = convert (long_integer_type_node,
2312 size_in_bytes (objc_module_template));
2313 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2315 /* Don't provide any file name for security reasons. */
2316 /* name = { ..., "", ... } */
2318 expr = add_objc_string (get_identifier (""), class_names);
2319 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2321 /* symtab = { ..., _OBJC_SYMBOLS, ... } */
2323 if (UOBJC_SYMBOLS_decl)
2324 expr = build_unary_op (input_location,
2325 ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
2327 expr = build_int_cst (NULL_TREE, 0);
2328 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2330 return objc_build_constructor (type, v);
2333 /* Write out the data structures to describe Objective C classes defined.
2335 struct _objc_module { ... } _OBJC_MODULE = { ... }; */
2338 build_module_descriptor (void)
2340 tree field_decl, field_decl_chain;
2343 push_lang_context (lang_name_c); /* extern "C" */
2346 objc_module_template = objc_start_struct (get_identifier (UTAG_MODULE));
2349 field_decl = create_field_decl (long_integer_type_node, "version");
2350 field_decl_chain = field_decl;
2353 field_decl = create_field_decl (long_integer_type_node, "size");
2354 chainon (field_decl_chain, field_decl);
2357 field_decl = create_field_decl (string_type_node, "name");
2358 chainon (field_decl_chain, field_decl);
2360 /* struct _objc_symtab *symtab; */
2362 = create_field_decl (build_pointer_type
2363 (xref_tag (RECORD_TYPE,
2364 get_identifier (UTAG_SYMTAB))),
2366 chainon (field_decl_chain, field_decl);
2368 objc_finish_struct (objc_module_template, field_decl_chain);
2370 /* Create an instance of "_objc_module". */
2371 UOBJC_MODULES_decl = start_var_decl (objc_module_template, "_OBJC_MODULES");
2372 finish_var_decl (UOBJC_MODULES_decl,
2373 init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl)));
2376 pop_lang_context ();
2380 /* The GNU runtime requires us to provide a static initializer function
2383 static void __objc_gnu_init (void) {
2384 __objc_exec_class (&L_OBJC_MODULES);
2388 build_module_initializer_routine (void)
2393 push_lang_context (lang_name_c); /* extern "C" */
2396 objc_push_parm (build_decl (input_location,
2397 PARM_DECL, NULL_TREE, void_type_node));
2399 objc_start_function (get_identifier (TAG_GNUINIT),
2400 build_function_type_list (void_type_node, NULL_TREE),
2401 NULL_TREE, NULL_TREE);
2403 objc_start_function (get_identifier (TAG_GNUINIT),
2404 build_function_type_list (void_type_node, NULL_TREE),
2405 NULL_TREE, objc_get_parm_info (0));
2407 body = c_begin_compound_stmt (true);
2408 add_stmt (build_function_call
2413 build_unary_op (input_location, ADDR_EXPR,
2414 UOBJC_MODULES_decl, 0))));
2415 add_stmt (c_end_compound_stmt (input_location, body, true));
2417 TREE_PUBLIC (current_function_decl) = 0;
2420 /* For Objective-C++, we will need to call __objc_gnu_init
2421 from objc_generate_static_init_call() below. */
2422 DECL_STATIC_CONSTRUCTOR (current_function_decl) = 1;
2425 GNU_INIT_decl = current_function_decl;
2429 pop_lang_context ();
2434 /* Return 1 if the __objc_gnu_init function has been synthesized and needs
2435 to be called by the module initializer routine. */
2438 objc_static_init_needed_p (void)
2440 return (GNU_INIT_decl != NULL_TREE);
2443 /* Generate a call to the __objc_gnu_init initializer function. */
2446 objc_generate_static_init_call (tree ctors ATTRIBUTE_UNUSED)
2448 add_stmt (build_stmt (input_location, EXPR_STMT,
2449 build_function_call (input_location,
2450 GNU_INIT_decl, NULL_TREE)));
2454 #endif /* OBJCPLUS */
2456 /* Return the DECL of the string IDENT in the SECTION. */
2459 get_objc_string_decl (tree ident, enum string_section section)
2463 if (section == class_names)
2464 chain = class_names_chain;
2465 else if (section == meth_var_names)
2466 chain = meth_var_names_chain;
2467 else if (section == meth_var_types)
2468 chain = meth_var_types_chain;
2472 for (; chain != 0; chain = TREE_CHAIN (chain))
2473 if (TREE_VALUE (chain) == ident)
2474 return (TREE_PURPOSE (chain));
2480 /* Output references to all statically allocated objects. Return the DECL
2481 for the array built. */
2484 generate_static_references (void)
2486 tree expr = NULL_TREE;
2487 tree class_name, klass, decl;
2488 tree cl_chain, in_chain, type
2489 = build_array_type (build_pointer_type (void_type_node), NULL_TREE);
2490 int num_inst, num_class;
2492 VEC(constructor_elt,gc) *decls = NULL;
2494 if (flag_next_runtime)
2497 for (cl_chain = objc_static_instances, num_class = 0;
2498 cl_chain; cl_chain = TREE_CHAIN (cl_chain), num_class++)
2500 VEC(constructor_elt,gc) *v = NULL;
2502 for (num_inst = 0, in_chain = TREE_PURPOSE (cl_chain);
2503 in_chain; num_inst++, in_chain = TREE_CHAIN (in_chain));
2505 sprintf (buf, "_OBJC_STATIC_INSTANCES_%d", num_class);
2506 decl = start_var_decl (type, buf);
2508 /* Output {class_name, ...}. */
2509 klass = TREE_VALUE (cl_chain);
2510 class_name = get_objc_string_decl (OBJC_TYPE_NAME (klass), class_names);
2511 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
2512 build_unary_op (input_location,
2513 ADDR_EXPR, class_name, 1));
2515 /* Output {..., instance, ...}. */
2516 for (in_chain = TREE_PURPOSE (cl_chain);
2517 in_chain; in_chain = TREE_CHAIN (in_chain))
2519 expr = build_unary_op (input_location,
2520 ADDR_EXPR, TREE_VALUE (in_chain), 1);
2521 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2524 /* Output {..., NULL}. */
2525 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
2527 expr = objc_build_constructor (TREE_TYPE (decl), v);
2528 finish_var_decl (decl, expr);
2529 CONSTRUCTOR_APPEND_ELT (decls, NULL_TREE,
2530 build_unary_op (input_location,
2531 ADDR_EXPR, decl, 1));
2534 CONSTRUCTOR_APPEND_ELT (decls, NULL_TREE, build_int_cst (NULL_TREE, 0));
2535 expr = objc_build_constructor (type, decls);
2536 static_instances_decl = start_var_decl (type, "_OBJC_STATIC_INSTANCES");
2537 finish_var_decl (static_instances_decl, expr);
2540 static GTY(()) int selector_reference_idx;
2543 build_selector_reference_decl (void)
2548 sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", selector_reference_idx++);
2549 decl = start_var_decl (objc_selector_type, buf);
2555 build_selector_table_decl (void)
2559 if (flag_typed_selectors)
2561 build_selector_template ();
2562 temp = build_array_type (objc_selector_template, NULL_TREE);
2565 temp = build_array_type (objc_selector_type, NULL_TREE);
2567 UOBJC_SELECTOR_TABLE_decl = start_var_decl (temp, "_OBJC_SELECTOR_TABLE");
2570 /* Just a handy wrapper for add_objc_string. */
2573 build_selector (tree ident)
2575 return convert (objc_selector_type,
2576 add_objc_string (ident, meth_var_names));
2580 build_selector_translation_table (void)
2584 tree decl = NULL_TREE;
2585 VEC(constructor_elt,gc) *inits = NULL;
2587 for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
2591 if (warn_selector && objc_implementation_context)
2595 for (method_chain = meth_var_names_chain;
2597 method_chain = TREE_CHAIN (method_chain))
2599 if (TREE_VALUE (method_chain) == TREE_VALUE (chain))
2608 if (flag_next_runtime && TREE_PURPOSE (chain))
2609 loc = DECL_SOURCE_LOCATION (TREE_PURPOSE (chain));
2611 loc = input_location;
2612 warning_at (loc, 0, "creating selector for nonexistent method %qE",
2613 TREE_VALUE (chain));
2617 expr = build_selector (TREE_VALUE (chain));
2618 /* add one for the '\0' character */
2619 offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1;
2621 if (flag_next_runtime)
2623 decl = TREE_PURPOSE (chain);
2624 finish_var_decl (decl, expr);
2628 if (flag_typed_selectors)
2630 VEC(constructor_elt,gc) *v = NULL;
2631 tree encoding = get_proto_encoding (TREE_PURPOSE (chain));
2632 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2633 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, encoding);
2634 expr = objc_build_constructor (objc_selector_template, v);
2637 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
2641 if (! flag_next_runtime)
2643 /* Cause the selector table (previously forward-declared)
2644 to be actually output. */
2647 if (flag_typed_selectors)
2649 VEC(constructor_elt,gc) *v = NULL;
2650 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
2651 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
2652 expr = objc_build_constructor (objc_selector_template, v);
2655 expr = build_int_cst (NULL_TREE, 0);
2657 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
2658 expr = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
2660 finish_var_decl (UOBJC_SELECTOR_TABLE_decl, expr);
2665 get_proto_encoding (tree proto)
2670 if (! METHOD_ENCODING (proto))
2672 encoding = encode_method_prototype (proto);
2673 METHOD_ENCODING (proto) = encoding;
2676 encoding = METHOD_ENCODING (proto);
2678 return add_objc_string (encoding, meth_var_types);
2681 return build_int_cst (NULL_TREE, 0);
2684 /* sel_ref_chain is a list whose "value" fields will be instances of
2685 identifier_node that represent the selector. LOC is the location of
2689 build_typed_selector_reference (location_t loc, tree ident, tree prototype)
2691 tree *chain = &sel_ref_chain;
2697 if (TREE_PURPOSE (*chain) == prototype && TREE_VALUE (*chain) == ident)
2698 goto return_at_index;
2701 chain = &TREE_CHAIN (*chain);
2704 *chain = tree_cons (prototype, ident, NULL_TREE);
2707 expr = build_unary_op (loc, ADDR_EXPR,
2708 build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2709 build_int_cst (NULL_TREE, index)),
2711 return convert (objc_selector_type, expr);
2715 build_selector_reference (location_t loc, tree ident)
2717 tree *chain = &sel_ref_chain;
2723 if (TREE_VALUE (*chain) == ident)
2724 return (flag_next_runtime
2725 ? TREE_PURPOSE (*chain)
2726 : build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2727 build_int_cst (NULL_TREE, index)));
2730 chain = &TREE_CHAIN (*chain);
2733 expr = (flag_next_runtime ? build_selector_reference_decl (): NULL_TREE);
2735 *chain = tree_cons (expr, ident, NULL_TREE);
2737 return (flag_next_runtime
2739 : build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2740 build_int_cst (NULL_TREE, index)));
2743 static GTY(()) int class_reference_idx;
2746 build_class_reference_decl (void)
2751 sprintf (buf, "_OBJC_CLASS_REFERENCES_%d", class_reference_idx++);
2752 decl = start_var_decl (objc_class_type, buf);
2757 /* Create a class reference, but don't create a variable to reference
2761 add_class_reference (tree ident)
2765 if ((chain = cls_ref_chain))
2770 if (ident == TREE_VALUE (chain))
2774 chain = TREE_CHAIN (chain);
2778 /* Append to the end of the list */
2779 TREE_CHAIN (tail) = tree_cons (NULL_TREE, ident, NULL_TREE);
2782 cls_ref_chain = tree_cons (NULL_TREE, ident, NULL_TREE);
2785 /* Get a class reference, creating it if necessary. Also create the
2786 reference variable. */
2789 objc_get_class_reference (tree ident)
2791 tree orig_ident = (DECL_P (ident)
2794 ? OBJC_TYPE_NAME (ident)
2796 bool local_scope = false;
2799 if (processing_template_decl)
2800 /* Must wait until template instantiation time. */
2801 return build_min_nt (CLASS_REFERENCE_EXPR, ident);
2804 if (TREE_CODE (ident) == TYPE_DECL)
2805 ident = (DECL_ORIGINAL_TYPE (ident)
2806 ? DECL_ORIGINAL_TYPE (ident)
2807 : TREE_TYPE (ident));
2810 if (TYPE_P (ident) && TYPE_CONTEXT (ident)
2811 && TYPE_CONTEXT (ident) != global_namespace)
2815 if (local_scope || !(ident = objc_is_class_name (ident)))
2817 error ("%qE is not an Objective-C class name or alias",
2819 return error_mark_node;
2822 if (flag_next_runtime && !flag_zero_link)
2827 for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
2828 if (TREE_VALUE (*chain) == ident)
2830 if (! TREE_PURPOSE (*chain))
2831 TREE_PURPOSE (*chain) = build_class_reference_decl ();
2833 return TREE_PURPOSE (*chain);
2836 decl = build_class_reference_decl ();
2837 *chain = tree_cons (decl, ident, NULL_TREE);
2844 add_class_reference (ident);
2846 params = build_tree_list (NULL_TREE,
2847 my_build_string_pointer
2848 (IDENTIFIER_LENGTH (ident) + 1,
2849 IDENTIFIER_POINTER (ident)));
2851 assemble_external (objc_get_class_decl);
2852 return build_function_call (input_location, objc_get_class_decl, params);
2856 /* For each string section we have a chain which maps identifier nodes
2857 to decls for the strings. */
2860 add_objc_string (tree ident, enum string_section section)
2862 tree *chain, decl, type, string_expr;
2864 if (section == class_names)
2865 chain = &class_names_chain;
2866 else if (section == meth_var_names)
2867 chain = &meth_var_names_chain;
2868 else if (section == meth_var_types)
2869 chain = &meth_var_types_chain;
2875 if (TREE_VALUE (*chain) == ident)
2876 return convert (string_type_node,
2877 build_unary_op (input_location,
2878 ADDR_EXPR, TREE_PURPOSE (*chain), 1));
2880 chain = &TREE_CHAIN (*chain);
2883 decl = build_objc_string_decl (section);
2885 type = build_array_type
2888 (build_int_cst (NULL_TREE,
2889 IDENTIFIER_LENGTH (ident))));
2890 decl = start_var_decl (type, IDENTIFIER_POINTER (DECL_NAME (decl)));
2891 string_expr = my_build_string (IDENTIFIER_LENGTH (ident) + 1,
2892 IDENTIFIER_POINTER (ident));
2893 finish_var_decl (decl, string_expr);
2895 *chain = tree_cons (decl, ident, NULL_TREE);
2897 return convert (string_type_node, build_unary_op (input_location,
2898 ADDR_EXPR, decl, 1));
2901 static GTY(()) int class_names_idx;
2902 static GTY(()) int meth_var_names_idx;
2903 static GTY(()) int meth_var_types_idx;
2906 build_objc_string_decl (enum string_section section)
2911 if (section == class_names)
2912 sprintf (buf, "_OBJC_CLASS_NAME_%d", class_names_idx++);
2913 else if (section == meth_var_names)
2914 sprintf (buf, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);
2915 else if (section == meth_var_types)
2916 sprintf (buf, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);
2918 ident = get_identifier (buf);
2920 decl = build_decl (input_location,
2921 VAR_DECL, ident, build_array_type (char_type_node, 0));
2922 DECL_EXTERNAL (decl) = 1;
2923 TREE_PUBLIC (decl) = 0;
2924 TREE_USED (decl) = 1;
2925 TREE_CONSTANT (decl) = 1;
2926 DECL_CONTEXT (decl) = 0;
2927 DECL_ARTIFICIAL (decl) = 1;
2929 DECL_THIS_STATIC (decl) = 1; /* squash redeclaration errors */
2932 make_decl_rtl (decl);
2933 pushdecl_top_level (decl);
2940 objc_declare_alias (tree alias_ident, tree class_ident)
2942 tree underlying_class;
2945 if (current_namespace != global_namespace) {
2946 error ("Objective-C declarations may only appear in global scope");
2948 #endif /* OBJCPLUS */
2950 if (!(underlying_class = objc_is_class_name (class_ident)))
2951 warning (0, "cannot find class %qE", class_ident);
2952 else if (objc_is_class_name (alias_ident))
2953 warning (0, "class %qE already exists", alias_ident);
2956 /* Implement @compatibility_alias as a typedef. */
2958 push_lang_context (lang_name_c); /* extern "C" */
2960 lang_hooks.decls.pushdecl (build_decl
2964 xref_tag (RECORD_TYPE, underlying_class)));
2966 pop_lang_context ();
2968 alias_chain = tree_cons (underlying_class, alias_ident, alias_chain);
2973 objc_declare_class (tree ident_list)
2977 if (current_namespace != global_namespace) {
2978 error ("Objective-C declarations may only appear in global scope");
2980 #endif /* OBJCPLUS */
2982 for (list = ident_list; list; list = TREE_CHAIN (list))
2984 tree ident = TREE_VALUE (list);
2986 if (! objc_is_class_name (ident))
2988 tree record = lookup_name (ident), type = record;
2992 if (TREE_CODE (record) == TYPE_DECL)
2993 type = DECL_ORIGINAL_TYPE (record);
2995 if (!TYPE_HAS_OBJC_INFO (type)
2996 || !TYPE_OBJC_INTERFACE (type))
2998 error ("%qE redeclared as different kind of symbol",
3000 error ("previous declaration of %q+D",
3005 record = xref_tag (RECORD_TYPE, ident);
3006 INIT_TYPE_OBJC_INFO (record);
3007 TYPE_OBJC_INTERFACE (record) = ident;
3008 class_chain = tree_cons (NULL_TREE, ident, class_chain);
3014 objc_is_class_name (tree ident)
3018 if (ident && TREE_CODE (ident) == IDENTIFIER_NODE
3019 && identifier_global_value (ident))
3020 ident = identifier_global_value (ident);
3021 while (ident && TREE_CODE (ident) == TYPE_DECL && DECL_ORIGINAL_TYPE (ident))
3022 ident = OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident));
3024 if (ident && TREE_CODE (ident) == RECORD_TYPE)
3025 ident = OBJC_TYPE_NAME (ident);
3027 if (ident && TREE_CODE (ident) == TYPE_DECL)
3028 ident = DECL_NAME (ident);
3030 if (!ident || TREE_CODE (ident) != IDENTIFIER_NODE)
3033 if (lookup_interface (ident))
3036 for (chain = class_chain; chain; chain = TREE_CHAIN (chain))
3038 if (ident == TREE_VALUE (chain))
3042 for (chain = alias_chain; chain; chain = TREE_CHAIN (chain))
3044 if (ident == TREE_VALUE (chain))
3045 return TREE_PURPOSE (chain);
3051 /* Check whether TYPE is either 'id' or 'Class'. */
3054 objc_is_id (tree type)
3056 if (type && TREE_CODE (type) == IDENTIFIER_NODE
3057 && identifier_global_value (type))
3058 type = identifier_global_value (type);
3060 if (type && TREE_CODE (type) == TYPE_DECL)
3061 type = TREE_TYPE (type);
3063 /* NB: This function may be called before the ObjC front-end has
3064 been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL. */
3065 return (objc_object_type && type
3066 && (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type))
3071 /* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
3072 class instance. This is needed by other parts of the compiler to
3073 handle ObjC types gracefully. */
3076 objc_is_object_ptr (tree type)
3080 type = TYPE_MAIN_VARIANT (type);
3081 if (!POINTER_TYPE_P (type))
3084 ret = objc_is_id (type);
3086 ret = objc_is_class_name (TREE_TYPE (type));
3092 objc_is_gcable_type (tree type, int or_strong_p)
3098 if (objc_is_id (TYPE_MAIN_VARIANT (type)))
3100 if (or_strong_p && lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type)))
3102 if (TREE_CODE (type) != POINTER_TYPE && TREE_CODE (type) != INDIRECT_REF)
3104 type = TREE_TYPE (type);
3105 if (TREE_CODE (type) != RECORD_TYPE)
3107 name = TYPE_NAME (type);
3108 return (objc_is_class_name (name) != NULL_TREE);
3112 objc_substitute_decl (tree expr, tree oldexpr, tree newexpr)
3114 if (expr == oldexpr)
3117 switch (TREE_CODE (expr))
3120 return objc_build_component_ref
3121 (objc_substitute_decl (TREE_OPERAND (expr, 0),
3124 DECL_NAME (TREE_OPERAND (expr, 1)));
3126 return build_array_ref (input_location,
3127 objc_substitute_decl (TREE_OPERAND (expr, 0),
3130 TREE_OPERAND (expr, 1));
3132 return build_indirect_ref (input_location,
3133 objc_substitute_decl (TREE_OPERAND (expr, 0),
3135 newexpr), RO_ARROW);
3142 objc_build_ivar_assignment (tree outervar, tree lhs, tree rhs)
3145 /* The LHS parameter contains the expression 'outervar->memberspec';
3146 we need to transform it into '&((typeof(outervar) *) 0)->memberspec',
3147 where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]').
3150 = objc_substitute_decl
3151 (lhs, outervar, convert (TREE_TYPE (outervar), integer_zero_node));
3153 = (flag_objc_direct_dispatch
3154 ? objc_assign_ivar_fast_decl
3155 : objc_assign_ivar_decl);
3157 offs = convert (integer_type_node, build_unary_op (input_location,
3158 ADDR_EXPR, offs, 0));
3160 func_params = tree_cons (NULL_TREE,
3161 convert (objc_object_type, rhs),
3162 tree_cons (NULL_TREE, convert (objc_object_type, outervar),
3163 tree_cons (NULL_TREE, offs,
3166 assemble_external (func);
3167 return build_function_call (input_location, func, func_params);
3171 objc_build_global_assignment (tree lhs, tree rhs)
3173 tree func_params = tree_cons (NULL_TREE,
3174 convert (objc_object_type, rhs),
3175 tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
3176 build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
3179 assemble_external (objc_assign_global_decl);
3180 return build_function_call (input_location,
3181 objc_assign_global_decl, func_params);
3185 objc_build_strong_cast_assignment (tree lhs, tree rhs)
3187 tree func_params = tree_cons (NULL_TREE,
3188 convert (objc_object_type, rhs),
3189 tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
3190 build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
3193 assemble_external (objc_assign_strong_cast_decl);
3194 return build_function_call (input_location,
3195 objc_assign_strong_cast_decl, func_params);
3199 objc_is_gcable_p (tree expr)
3201 return (TREE_CODE (expr) == COMPONENT_REF
3202 ? objc_is_gcable_p (TREE_OPERAND (expr, 1))
3203 : TREE_CODE (expr) == ARRAY_REF
3204 ? (objc_is_gcable_p (TREE_TYPE (expr))
3205 || objc_is_gcable_p (TREE_OPERAND (expr, 0)))
3206 : TREE_CODE (expr) == ARRAY_TYPE
3207 ? objc_is_gcable_p (TREE_TYPE (expr))
3209 ? objc_is_gcable_type (expr, 1)
3210 : (objc_is_gcable_p (TREE_TYPE (expr))
3212 && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr)))));
3216 objc_is_ivar_reference_p (tree expr)
3218 return (TREE_CODE (expr) == ARRAY_REF
3219 ? objc_is_ivar_reference_p (TREE_OPERAND (expr, 0))
3220 : TREE_CODE (expr) == COMPONENT_REF
3221 ? TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL
3226 objc_is_global_reference_p (tree expr)
3228 return (TREE_CODE (expr) == INDIRECT_REF || TREE_CODE (expr) == PLUS_EXPR
3229 ? objc_is_global_reference_p (TREE_OPERAND (expr, 0))
3231 ? (!DECL_CONTEXT (expr) || TREE_STATIC (expr))
3236 objc_generate_write_barrier (tree lhs, enum tree_code modifycode, tree rhs)
3238 tree result = NULL_TREE, outer;
3239 int strong_cast_p = 0, outer_gc_p = 0, indirect_p = 0;
3241 /* See if we have any lhs casts, and strip them out. NB: The lvalue casts
3242 will have been transformed to the form '*(type *)&expr'. */
3243 if (TREE_CODE (lhs) == INDIRECT_REF)
3245 outer = TREE_OPERAND (lhs, 0);
3247 while (!strong_cast_p
3248 && (CONVERT_EXPR_P (outer)
3249 || TREE_CODE (outer) == NON_LVALUE_EXPR))
3251 tree lhstype = TREE_TYPE (outer);
3253 /* Descend down the cast chain, and record the first objc_gc
3255 if (POINTER_TYPE_P (lhstype))
3258 = lookup_attribute ("objc_gc",
3259 TYPE_ATTRIBUTES (TREE_TYPE (lhstype)));
3265 outer = TREE_OPERAND (outer, 0);
3269 /* If we have a __strong cast, it trumps all else. */
3272 if (modifycode != NOP_EXPR)
3273 goto invalid_pointer_arithmetic;
3275 if (warn_assign_intercept)
3276 warning (0, "strong-cast assignment has been intercepted");
3278 result = objc_build_strong_cast_assignment (lhs, rhs);
3283 /* the lhs must be of a suitable type, regardless of its underlying
3285 if (!objc_is_gcable_p (lhs))
3291 && (TREE_CODE (outer) == COMPONENT_REF
3292 || TREE_CODE (outer) == ARRAY_REF))
3293 outer = TREE_OPERAND (outer, 0);
3295 if (TREE_CODE (outer) == INDIRECT_REF)
3297 outer = TREE_OPERAND (outer, 0);
3301 outer_gc_p = objc_is_gcable_p (outer);
3303 /* Handle ivar assignments. */
3304 if (objc_is_ivar_reference_p (lhs))
3306 /* if the struct to the left of the ivar is not an Objective-C object (__strong
3307 doesn't cut it here), the best we can do here is suggest a cast. */
3308 if (!objc_is_gcable_type (TREE_TYPE (outer), 0))
3310 /* We may still be able to use the global write barrier... */
3311 if (!indirect_p && objc_is_global_reference_p (outer))
3312 goto global_reference;
3315 if (modifycode == NOP_EXPR)
3317 if (warn_assign_intercept)
3318 warning (0, "strong-cast may possibly be needed");
3324 if (modifycode != NOP_EXPR)
3325 goto invalid_pointer_arithmetic;
3327 if (warn_assign_intercept)
3328 warning (0, "instance variable assignment has been intercepted");
3330 result = objc_build_ivar_assignment (outer, lhs, rhs);
3335 /* Likewise, intercept assignment to global/static variables if their type is
3337 if (objc_is_global_reference_p (outer))
3343 if (modifycode != NOP_EXPR)
3345 invalid_pointer_arithmetic:
3347 warning (0, "pointer arithmetic for garbage-collected objects not allowed");
3352 if (warn_assign_intercept)
3353 warning (0, "global/static variable assignment has been intercepted");
3355 result = objc_build_global_assignment (lhs, rhs);
3358 /* In all other cases, fall back to the normal mechanism. */
3363 struct GTY(()) interface_tuple {
3368 static GTY ((param_is (struct interface_tuple))) htab_t interface_htab;
3371 hash_interface (const void *p)
3373 const struct interface_tuple *d = (const struct interface_tuple *) p;
3374 return IDENTIFIER_HASH_VALUE (d->id);
3378 eq_interface (const void *p1, const void *p2)
3380 const struct interface_tuple *d = (const struct interface_tuple *) p1;
3385 lookup_interface (tree ident)
3388 if (ident && TREE_CODE (ident) == TYPE_DECL)
3389 ident = DECL_NAME (ident);
3392 if (ident == NULL_TREE || TREE_CODE (ident) != IDENTIFIER_NODE)
3396 struct interface_tuple **slot;
3401 slot = (struct interface_tuple **)
3402 htab_find_slot_with_hash (interface_htab, ident,
3403 IDENTIFIER_HASH_VALUE (ident),
3406 i = (*slot)->class_name;
3412 /* Implement @defs (<classname>) within struct bodies. */
3415 objc_get_class_ivars (tree class_name)
3417 tree interface = lookup_interface (class_name);
3420 return get_class_ivars (interface, true);
3422 error ("cannot find interface declaration for %qE",
3425 return error_mark_node;
3428 /* Used by: build_private_template, continue_class,
3429 and for @defs constructs. */
3432 get_class_ivars (tree interface, bool inherited)
3434 tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface));
3436 /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared
3437 by the current class (i.e., they do not include super-class ivars).
3438 However, the CLASS_IVARS list will be side-effected by a call to
3439 finish_struct(), which will fill in field offsets. */
3440 if (!CLASS_IVARS (interface))
3441 CLASS_IVARS (interface) = ivar_chain;
3446 while (CLASS_SUPER_NAME (interface))
3448 /* Prepend super-class ivars. */
3449 interface = lookup_interface (CLASS_SUPER_NAME (interface));
3450 ivar_chain = chainon (copy_list (CLASS_RAW_IVARS (interface)),
3458 objc_create_temporary_var (tree type)
3462 decl = build_decl (input_location,
3463 VAR_DECL, NULL_TREE, type);
3464 TREE_USED (decl) = 1;
3465 DECL_ARTIFICIAL (decl) = 1;
3466 DECL_IGNORED_P (decl) = 1;
3467 DECL_CONTEXT (decl) = current_function_decl;
3472 /* Exception handling constructs. We begin by having the parser do most
3473 of the work and passing us blocks. What we do next depends on whether
3474 we're doing "native" exception handling or legacy Darwin setjmp exceptions.
3475 We abstract all of this in a handful of appropriately named routines. */
3477 /* Stack of open try blocks. */
3479 struct objc_try_context
3481 struct objc_try_context *outer;
3483 /* Statements (or statement lists) as processed by the parser. */
3487 /* Some file position locations. */
3488 location_t try_locus;
3489 location_t end_try_locus;
3490 location_t end_catch_locus;
3491 location_t finally_locus;
3492 location_t end_finally_locus;
3494 /* A STATEMENT_LIST of CATCH_EXPRs, appropriate for sticking into op1
3495 of a TRY_CATCH_EXPR. Even when doing Darwin setjmp. */
3498 /* The CATCH_EXPR of an open @catch clause. */
3501 /* The VAR_DECL holding the Darwin equivalent of __builtin_eh_pointer. */
3507 static struct objc_try_context *cur_try_context;
3509 static GTY(()) tree objc_eh_personality_decl;
3511 /* This hook, called via lang_eh_runtime_type, generates a runtime object
3512 that represents TYPE. For Objective-C, this is just the class name. */
3513 /* ??? Isn't there a class object or some such? Is it easy to get? */
3517 objc_eh_runtime_type (tree type)
3519 return add_objc_string (OBJC_TYPE_NAME (TREE_TYPE (type)), class_names);
3523 objc_eh_personality (void)
3525 if (!flag_objc_sjlj_exceptions
3526 && !objc_eh_personality_decl)
3527 objc_eh_personality_decl
3528 = build_personality_function (USING_SJLJ_EXCEPTIONS
3529 ? "__gnu_objc_personality_sj0"
3530 : "__gnu_objc_personality_v0");
3532 return objc_eh_personality_decl;
3536 /* Build __builtin_eh_pointer, or the moral equivalent. In the case
3537 of Darwin, we'll arrange for it to be initialized (and associated
3538 with a binding) later. */
3541 objc_build_exc_ptr (void)
3543 if (flag_objc_sjlj_exceptions)
3545 tree var = cur_try_context->caught_decl;
3548 var = objc_create_temporary_var (objc_object_type);
3549 cur_try_context->caught_decl = var;
3556 t = built_in_decls[BUILT_IN_EH_POINTER];
3557 t = build_call_expr (t, 1, integer_zero_node);
3558 return fold_convert (objc_object_type, t);
3562 /* Build "objc_exception_try_exit(&_stack)". */
3565 next_sjlj_build_try_exit (void)
3568 t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
3569 t = tree_cons (NULL, t, NULL);
3570 t = build_function_call (input_location,
3571 objc_exception_try_exit_decl, t);
3576 objc_exception_try_enter (&_stack);
3577 if (_setjmp(&_stack.buf))
3581 Return the COND_EXPR. Note that the THEN and ELSE fields are left
3582 empty, ready for the caller to fill them in. */
3585 next_sjlj_build_enter_and_setjmp (void)
3587 tree t, enter, sj, cond;
3589 t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
3590 t = tree_cons (NULL, t, NULL);
3591 enter = build_function_call (input_location,
3592 objc_exception_try_enter_decl, t);
3594 t = objc_build_component_ref (cur_try_context->stack_decl,
3595 get_identifier ("buf"));
3596 t = build_fold_addr_expr_loc (input_location, t);
3598 /* Convert _setjmp argument to type that is expected. */
3599 if (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl)))
3600 t = convert (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl))), t);
3602 t = convert (ptr_type_node, t);
3604 t = convert (ptr_type_node, t);
3606 t = tree_cons (NULL, t, NULL);
3607 sj = build_function_call (input_location,
3608 objc_setjmp_decl, t);
3610 cond = build2 (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj);
3611 cond = c_common_truthvalue_conversion (input_location, cond);
3613 return build3 (COND_EXPR, void_type_node, cond, NULL, NULL);
3618 DECL = objc_exception_extract(&_stack); */
3621 next_sjlj_build_exc_extract (tree decl)
3625 t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
3626 t = tree_cons (NULL, t, NULL);
3627 t = build_function_call (input_location,
3628 objc_exception_extract_decl, t);
3629 t = convert (TREE_TYPE (decl), t);
3630 t = build2 (MODIFY_EXPR, void_type_node, decl, t);
3636 if (objc_exception_match(obj_get_class(TYPE), _caught)
3643 objc_exception_try_exit(&_stack);
3645 from the sequence of CATCH_EXPRs in the current try context. */
3648 next_sjlj_build_catch_list (void)
3650 tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
3652 tree *last = &catch_seq;
3653 bool saw_id = false;
3655 for (; !tsi_end_p (i); tsi_next (&i))
3657 tree stmt = tsi_stmt (i);
3658 tree type = CATCH_TYPES (stmt);
3659 tree body = CATCH_BODY (stmt);
3671 if (type == error_mark_node)
3672 cond = error_mark_node;
3675 args = tree_cons (NULL, cur_try_context->caught_decl, NULL);
3676 t = objc_get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type)));
3677 args = tree_cons (NULL, t, args);
3678 t = build_function_call (input_location,
3679 objc_exception_match_decl, args);
3680 cond = c_common_truthvalue_conversion (input_location, t);
3682 t = build3 (COND_EXPR, void_type_node, cond, body, NULL);
3683 SET_EXPR_LOCATION (t, EXPR_LOCATION (stmt));
3686 last = &COND_EXPR_ELSE (t);
3692 t = build2 (MODIFY_EXPR, void_type_node, cur_try_context->rethrow_decl,
3693 cur_try_context->caught_decl);
3694 SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
3695 append_to_statement_list (t, last);
3697 t = next_sjlj_build_try_exit ();
3698 SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
3699 append_to_statement_list (t, last);
3705 /* Build a complete @try-@catch-@finally block for legacy Darwin setjmp
3706 exception handling. We aim to build:
3709 struct _objc_exception_data _stack;
3713 objc_exception_try_enter (&_stack);
3714 if (_setjmp(&_stack.buf))
3716 id _caught = objc_exception_extract(&_stack);
3717 objc_exception_try_enter (&_stack);
3718 if (_setjmp(&_stack.buf))
3719 _rethrow = objc_exception_extract(&_stack);
3729 objc_exception_try_exit(&_stack);
3732 objc_exception_throw(_rethrow);
3736 If CATCH-LIST is empty, we can omit all of the block containing
3737 "_caught" except for the setting of _rethrow. Note the use of
3738 a real TRY_FINALLY_EXPR here, which is not involved in EH per-se,
3739 but handles goto and other exits from the block. */
3742 next_sjlj_build_try_catch_finally (void)
3744 tree rethrow_decl, stack_decl, t;
3745 tree catch_seq, try_fin, bind;
3747 /* Create the declarations involved. */
3748 t = xref_tag (RECORD_TYPE, get_identifier (UTAG_EXCDATA));
3749 stack_decl = objc_create_temporary_var (t);
3750 cur_try_context->stack_decl = stack_decl;
3752 rethrow_decl = objc_create_temporary_var (objc_object_type);
3753 cur_try_context->rethrow_decl = rethrow_decl;
3754 TREE_CHAIN (rethrow_decl) = stack_decl;
3756 /* Build the outermost variable binding level. */
3757 bind = build3 (BIND_EXPR, void_type_node, rethrow_decl, NULL, NULL);
3758 SET_EXPR_LOCATION (bind, cur_try_context->try_locus);
3759 TREE_SIDE_EFFECTS (bind) = 1;
3761 /* Initialize rethrow_decl. */
3762 t = build2 (MODIFY_EXPR, void_type_node, rethrow_decl,
3763 convert (objc_object_type, null_pointer_node));
3764 SET_EXPR_LOCATION (t, cur_try_context->try_locus);
3765 append_to_statement_list (t, &BIND_EXPR_BODY (bind));
3767 /* Build the outermost TRY_FINALLY_EXPR. */
3768 try_fin = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
3769 SET_EXPR_LOCATION (try_fin, cur_try_context->try_locus);
3770 TREE_SIDE_EFFECTS (try_fin) = 1;
3771 append_to_statement_list (try_fin, &BIND_EXPR_BODY (bind));
3773 /* Create the complete catch sequence. */
3774 if (cur_try_context->catch_list)
3776 tree caught_decl = objc_build_exc_ptr ();
3777 catch_seq = build_stmt (input_location, BIND_EXPR, caught_decl, NULL, NULL);
3778 TREE_SIDE_EFFECTS (catch_seq) = 1;
3780 t = next_sjlj_build_exc_extract (caught_decl);
3781 append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
3783 t = next_sjlj_build_enter_and_setjmp ();
3784 COND_EXPR_THEN (t) = next_sjlj_build_exc_extract (rethrow_decl);
3785 COND_EXPR_ELSE (t) = next_sjlj_build_catch_list ();
3786 append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
3789 catch_seq = next_sjlj_build_exc_extract (rethrow_decl);
3790 SET_EXPR_LOCATION (catch_seq, cur_try_context->end_try_locus);
3792 /* Build the main register-and-try if statement. */
3793 t = next_sjlj_build_enter_and_setjmp ();
3794 SET_EXPR_LOCATION (t, cur_try_context->try_locus);
3795 COND_EXPR_THEN (t) = catch_seq;
3796 COND_EXPR_ELSE (t) = cur_try_context->try_body;
3797 TREE_OPERAND (try_fin, 0) = t;
3799 /* Build the complete FINALLY statement list. */
3800 t = next_sjlj_build_try_exit ();
3801 t = build_stmt (input_location, COND_EXPR,
3802 c_common_truthvalue_conversion
3803 (input_location, rethrow_decl),
3805 SET_EXPR_LOCATION (t, cur_try_context->finally_locus);
3806 append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
3808 append_to_statement_list (cur_try_context->finally_body,
3809 &TREE_OPERAND (try_fin, 1));
3811 t = tree_cons (NULL, rethrow_decl, NULL);
3812 t = build_function_call (input_location,
3813 objc_exception_throw_decl, t);
3814 t = build_stmt (input_location, COND_EXPR,
3815 c_common_truthvalue_conversion (input_location,
3818 SET_EXPR_LOCATION (t, cur_try_context->end_finally_locus);
3819 append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
3824 /* Called just after parsing the @try and its associated BODY. We now
3825 must prepare for the tricky bits -- handling the catches and finally. */
3828 objc_begin_try_stmt (location_t try_locus, tree body)
3830 struct objc_try_context *c = XCNEW (struct objc_try_context);
3831 c->outer = cur_try_context;
3833 c->try_locus = try_locus;
3834 c->end_try_locus = input_location;
3835 cur_try_context = c;
3837 if (flag_objc_sjlj_exceptions)
3839 /* On Darwin, ObjC exceptions require a sufficiently recent
3840 version of the runtime, so the user must ask for them explicitly. */
3841 if (!flag_objc_exceptions)
3842 warning (0, "use %<-fobjc-exceptions%> to enable Objective-C "
3843 "exception syntax");
3846 if (flag_objc_sjlj_exceptions)
3847 objc_mark_locals_volatile (NULL);
3850 /* Called just after parsing "@catch (parm)". Open a binding level,
3851 enter DECL into the binding level, and initialize it. Leave the
3852 binding level open while the body of the compound statement is parsed. */
3855 objc_begin_catch_clause (tree decl)
3857 tree compound, type, t;
3859 /* Begin a new scope that the entire catch clause will live in. */
3860 compound = c_begin_compound_stmt (true);
3862 /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL. */
3863 decl = build_decl (input_location,
3864 VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
3865 lang_hooks.decls.pushdecl (decl);
3867 /* Since a decl is required here by syntax, don't warn if its unused. */
3868 /* ??? As opposed to __attribute__((unused))? Anyway, this appears to
3869 be what the previous objc implementation did. */
3870 TREE_USED (decl) = 1;
3871 DECL_READ_P (decl) = 1;
3873 /* Verify that the type of the catch is valid. It must be a pointer
3874 to an Objective-C class, or "id" (which is catch-all). */
3875 type = TREE_TYPE (decl);
3877 if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
3879 else if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type)))
3881 error ("@catch parameter is not a known Objective-C class type");
3882 type = error_mark_node;
3884 else if (cur_try_context->catch_list)
3886 /* Examine previous @catch clauses and see if we've already
3887 caught the type in question. */
3888 tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
3889 for (; !tsi_end_p (i); tsi_next (&i))
3891 tree stmt = tsi_stmt (i);
3892 t = CATCH_TYPES (stmt);
3893 if (t == error_mark_node)
3895 if (!t || DERIVED_FROM_P (TREE_TYPE (t), TREE_TYPE (type)))
3897 warning (0, "exception of type %<%T%> will be caught",
3899 warning_at (EXPR_LOCATION (stmt), 0, " by earlier handler for %<%T%>",
3900 TREE_TYPE (t ? t : objc_object_type));
3906 /* Record the data for the catch in the try context so that we can
3907 finalize it later. */
3908 t = build_stmt (input_location, CATCH_EXPR, type, compound);
3909 cur_try_context->current_catch = t;
3911 /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */
3912 t = objc_build_exc_ptr ();
3913 t = convert (TREE_TYPE (decl), t);
3914 t = build2 (MODIFY_EXPR, void_type_node, decl, t);
3918 /* Called just after parsing the closing brace of a @catch clause. Close
3919 the open binding level, and record a CATCH_EXPR for it. */
3922 objc_finish_catch_clause (void)
3924 tree c = cur_try_context->current_catch;
3925 cur_try_context->current_catch = NULL;
3926 cur_try_context->end_catch_locus = input_location;
3928 CATCH_BODY (c) = c_end_compound_stmt (input_location, CATCH_BODY (c), 1);
3929 append_to_statement_list (c, &cur_try_context->catch_list);
3932 /* Called after parsing a @finally clause and its associated BODY.
3933 Record the body for later placement. */
3936 objc_build_finally_clause (location_t finally_locus, tree body)
3938 cur_try_context->finally_body = body;
3939 cur_try_context->finally_locus = finally_locus;
3940 cur_try_context->end_finally_locus = input_location;
3943 /* Called to finalize a @try construct. */
3946 objc_finish_try_stmt (void)
3948 struct objc_try_context *c = cur_try_context;
3951 if (c->catch_list == NULL && c->finally_body == NULL)
3952 error ("%<@try%> without %<@catch%> or %<@finally%>");
3954 /* If we're doing Darwin setjmp exceptions, build the big nasty. */
3955 if (flag_objc_sjlj_exceptions)
3957 bool save = in_late_binary_op;
3958 in_late_binary_op = true;
3959 if (!cur_try_context->finally_body)
3961 cur_try_context->finally_locus = input_location;
3962 cur_try_context->end_finally_locus = input_location;
3964 stmt = next_sjlj_build_try_catch_finally ();
3965 in_late_binary_op = save;
3969 /* Otherwise, nest the CATCH inside a FINALLY. */
3973 stmt = build_stmt (input_location, TRY_CATCH_EXPR, stmt, c->catch_list);
3974 SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
3976 if (c->finally_body)
3978 stmt = build_stmt (input_location, TRY_FINALLY_EXPR, stmt, c->finally_body);
3979 SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
3984 cur_try_context = c->outer;
3990 objc_build_throw_stmt (location_t loc, tree throw_expr)
3994 if (flag_objc_sjlj_exceptions)
3996 /* On Darwin, ObjC exceptions require a sufficiently recent
3997 version of the runtime, so the user must ask for them explicitly. */
3998 if (!flag_objc_exceptions)
3999 warning (0, "use %<-fobjc-exceptions%> to enable Objective-C "
4000 "exception syntax");
4003 if (throw_expr == NULL)
4005 /* If we're not inside a @catch block, there is no "current
4006 exception" to be rethrown. */
4007 if (cur_try_context == NULL
4008 || cur_try_context->current_catch == NULL)
4010 error_at (loc, "%<@throw%> (rethrow) used outside of a @catch block");
4014 /* Otherwise the object is still sitting in the EXC_PTR_EXPR
4015 value that we get from the runtime. */
4016 throw_expr = objc_build_exc_ptr ();
4019 /* A throw is just a call to the runtime throw function with the
4020 object as a parameter. */
4021 args = tree_cons (NULL, throw_expr, NULL);
4022 return add_stmt (build_function_call (loc,
4023 objc_exception_throw_decl, args));
4027 objc_build_synchronized (location_t start_locus, tree mutex, tree body)
4031 /* First lock the mutex. */
4032 mutex = save_expr (mutex);
4033 args = tree_cons (NULL, mutex, NULL);
4034 call = build_function_call (input_location,
4035 objc_sync_enter_decl, args);
4036 SET_EXPR_LOCATION (call, start_locus);
4039 /* Build the mutex unlock. */
4040 args = tree_cons (NULL, mutex, NULL);
4041 call = build_function_call (input_location,
4042 objc_sync_exit_decl, args);
4043 SET_EXPR_LOCATION (call, input_location);
4045 /* Put the that and the body in a TRY_FINALLY. */
4046 objc_begin_try_stmt (start_locus, body);
4047 objc_build_finally_clause (input_location, call);
4048 return objc_finish_try_stmt ();
4052 /* Predefine the following data type:
4054 struct _objc_exception_data
4056 int buf[OBJC_JBLEN];
4060 /* The following yuckiness should prevent users from having to #include
4061 <setjmp.h> in their code... */
4063 /* Define to a harmless positive value so the below code doesn't die. */
4065 #define OBJC_JBLEN 18
4069 build_next_objc_exception_stuff (void)
4071 tree field_decl, field_decl_chain, index, temp_type;
4073 objc_exception_data_template
4074 = objc_start_struct (get_identifier (UTAG_EXCDATA));
4076 /* int buf[OBJC_JBLEN]; */
4078 index = build_index_type (build_int_cst (NULL_TREE, OBJC_JBLEN - 1));
4079 field_decl = create_field_decl (build_array_type (integer_type_node, index),
4081 field_decl_chain = field_decl;
4083 /* void *pointers[4]; */
4085 index = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
4086 field_decl = create_field_decl (build_array_type (ptr_type_node, index),
4088 chainon (field_decl_chain, field_decl);
4090 objc_finish_struct (objc_exception_data_template, field_decl_chain);
4092 /* int _setjmp(...); */
4093 /* If the user includes <setjmp.h>, this shall be superseded by
4094 'int _setjmp(jmp_buf);' */
4095 temp_type = build_varargs_function_type_list (integer_type_node, NULL_TREE);
4097 = add_builtin_function (TAG_SETJMP, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
4099 /* id objc_exception_extract(struct _objc_exception_data *); */
4101 = build_function_type_list (objc_object_type,
4102 build_pointer_type (objc_exception_data_template),
4104 objc_exception_extract_decl
4105 = add_builtin_function (TAG_EXCEPTIONEXTRACT, temp_type, 0, NOT_BUILT_IN, NULL,
4107 /* void objc_exception_try_enter(struct _objc_exception_data *); */
4108 /* void objc_exception_try_exit(struct _objc_exception_data *); */
4110 = build_function_type_list (void_type_node,
4111 build_pointer_type (objc_exception_data_template),
4113 objc_exception_try_enter_decl
4114 = add_builtin_function (TAG_EXCEPTIONTRYENTER, temp_type, 0, NOT_BUILT_IN, NULL,
4116 objc_exception_try_exit_decl
4117 = add_builtin_function (TAG_EXCEPTIONTRYEXIT, temp_type, 0, NOT_BUILT_IN, NULL,
4120 /* int objc_exception_match(id, id); */
4122 = build_function_type_list (integer_type_node,
4123 objc_object_type, objc_object_type, NULL_TREE);
4124 objc_exception_match_decl
4125 = add_builtin_function (TAG_EXCEPTIONMATCH, temp_type, 0, NOT_BUILT_IN, NULL,
4128 /* id objc_assign_ivar (id, id, unsigned int); */
4129 /* id objc_assign_ivar_Fast (id, id, unsigned int)
4130 __attribute__ ((hard_coded_address (OFFS_ASSIGNIVAR_FAST))); */
4132 = build_function_type_list (objc_object_type,
4137 objc_assign_ivar_decl
4138 = add_builtin_function (TAG_ASSIGNIVAR, temp_type, 0, NOT_BUILT_IN,
4140 #ifdef OFFS_ASSIGNIVAR_FAST
4141 objc_assign_ivar_fast_decl
4142 = add_builtin_function (TAG_ASSIGNIVAR_FAST, temp_type, 0,
4143 NOT_BUILT_IN, NULL, NULL_TREE);
4144 DECL_ATTRIBUTES (objc_assign_ivar_fast_decl)
4145 = tree_cons (get_identifier ("hard_coded_address"),
4146 build_int_cst (NULL_TREE, OFFS_ASSIGNIVAR_FAST),
4149 /* Default to slower ivar method. */
4150 objc_assign_ivar_fast_decl = objc_assign_ivar_decl;
4153 /* id objc_assign_global (id, id *); */
4154 /* id objc_assign_strongCast (id, id *); */
4155 temp_type = build_function_type_list (objc_object_type,
4157 build_pointer_type (objc_object_type),
4159 objc_assign_global_decl
4160 = add_builtin_function (TAG_ASSIGNGLOBAL, temp_type, 0, NOT_BUILT_IN, NULL,
4162 objc_assign_strong_cast_decl
4163 = add_builtin_function (TAG_ASSIGNSTRONGCAST, temp_type, 0, NOT_BUILT_IN, NULL,
4168 build_objc_exception_stuff (void)
4170 tree noreturn_list, nothrow_list, temp_type;
4172 noreturn_list = tree_cons (get_identifier ("noreturn"), NULL, NULL);
4173 nothrow_list = tree_cons (get_identifier ("nothrow"), NULL, NULL);
4175 /* void objc_exception_throw(id) __attribute__((noreturn)); */
4176 /* void objc_sync_enter(id); */
4177 /* void objc_sync_exit(id); */
4178 temp_type = build_function_type_list (void_type_node,
4181 objc_exception_throw_decl
4182 = add_builtin_function (TAG_EXCEPTIONTHROW, temp_type, 0, NOT_BUILT_IN, NULL,
4184 objc_sync_enter_decl
4185 = add_builtin_function (TAG_SYNCENTER, temp_type, 0, NOT_BUILT_IN,
4186 NULL, nothrow_list);
4188 = add_builtin_function (TAG_SYNCEXIT, temp_type, 0, NOT_BUILT_IN,
4189 NULL, nothrow_list);
4192 /* Construct a C struct corresponding to ObjC class CLASS, with the same
4195 struct <classname> {
4196 struct _objc_class *isa;
4201 build_private_template (tree klass)
4203 if (!CLASS_STATIC_TEMPLATE (klass))
4205 tree record = objc_build_struct (klass,
4206 get_class_ivars (klass, false),
4207 CLASS_SUPER_NAME (klass));
4209 /* Set the TREE_USED bit for this struct, so that stab generator
4210 can emit stabs for this struct type. */
4211 if (flag_debug_only_used_symbols && TYPE_STUB_DECL (record))
4212 TREE_USED (TYPE_STUB_DECL (record)) = 1;
4216 /* Begin code generation for protocols... */
4218 /* struct _objc_protocol {
4219 struct _objc_class *isa;
4220 char *protocol_name;
4221 struct _objc_protocol **protocol_list;
4222 struct _objc__method_prototype_list *instance_methods;
4223 struct _objc__method_prototype_list *class_methods;
4227 build_protocol_template (void)
4229 tree field_decl, field_decl_chain;
4231 objc_protocol_template = objc_start_struct (get_identifier (UTAG_PROTOCOL));
4233 /* struct _objc_class *isa; */
4234 field_decl = create_field_decl (build_pointer_type
4235 (xref_tag (RECORD_TYPE,
4236 get_identifier (UTAG_CLASS))),
4238 field_decl_chain = field_decl;
4240 /* char *protocol_name; */
4241 field_decl = create_field_decl (string_type_node, "protocol_name");
4242 chainon (field_decl_chain, field_decl);
4244 /* struct _objc_protocol **protocol_list; */
4245 field_decl = create_field_decl (build_pointer_type
4247 (objc_protocol_template)),
4249 chainon (field_decl_chain, field_decl);
4251 /* struct _objc__method_prototype_list *instance_methods; */
4252 field_decl = create_field_decl (objc_method_proto_list_ptr,
4253 "instance_methods");
4254 chainon (field_decl_chain, field_decl);
4256 /* struct _objc__method_prototype_list *class_methods; */
4257 field_decl = create_field_decl (objc_method_proto_list_ptr,
4259 chainon (field_decl_chain, field_decl);
4261 objc_finish_struct (objc_protocol_template, field_decl_chain);
4265 build_descriptor_table_initializer (tree type, tree entries)
4267 VEC(constructor_elt,gc) *inits = NULL;
4271 VEC(constructor_elt,gc) *elts = NULL;
4273 CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE,
4274 build_selector (METHOD_SEL_NAME (entries)));
4275 CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE,
4276 add_objc_string (METHOD_ENCODING (entries),
4279 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
4280 objc_build_constructor (type, elts));
4282 entries = TREE_CHAIN (entries);
4286 return objc_build_constructor (build_array_type (type, 0), inits);
4289 /* struct objc_method_prototype_list {
4291 struct objc_method_prototype {
4298 build_method_prototype_list_template (tree list_type, int size)
4300 tree objc_ivar_list_record;
4301 tree field_decl, field_decl_chain;
4303 /* Generate an unnamed struct definition. */
4305 objc_ivar_list_record = objc_start_struct (NULL_TREE);
4307 /* int method_count; */
4308 field_decl = create_field_decl (integer_type_node, "method_count");
4309 field_decl_chain = field_decl;
4311 /* struct objc_method method_list[]; */
4312 field_decl = create_field_decl (build_array_type
4315 (build_int_cst (NULL_TREE, size - 1))),
4317 chainon (field_decl_chain, field_decl);
4319 objc_finish_struct (objc_ivar_list_record, field_decl_chain);
4321 return objc_ivar_list_record;
4325 build_method_prototype_template (void)
4328 tree field_decl, field_decl_chain;
4330 proto_record = objc_start_struct (get_identifier (UTAG_METHOD_PROTOTYPE));
4333 field_decl = create_field_decl (objc_selector_type, "_cmd");
4334 field_decl_chain = field_decl;
4336 /* char *method_types; */
4337 field_decl = create_field_decl (string_type_node, "method_types");
4338 chainon (field_decl_chain, field_decl);
4340 objc_finish_struct (proto_record, field_decl_chain);
4342 return proto_record;
4346 objc_method_parm_type (tree type)
4348 type = TREE_VALUE (TREE_TYPE (type));
4349 if (TREE_CODE (type) == TYPE_DECL)
4350 type = TREE_TYPE (type);
4355 objc_encoded_type_size (tree type)
4357 int sz = int_size_in_bytes (type);
4359 /* Make all integer and enum types at least as large
4361 if (sz > 0 && INTEGRAL_TYPE_P (type))
4362 sz = MAX (sz, int_size_in_bytes (integer_type_node));
4363 /* Treat arrays as pointers, since that's how they're
4365 else if (TREE_CODE (type) == ARRAY_TYPE)
4366 sz = int_size_in_bytes (ptr_type_node);
4371 encode_method_prototype (tree method_decl)
4378 /* ONEWAY and BYCOPY, for remote object are the only method qualifiers. */
4379 encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_decl)));
4381 /* Encode return type. */
4382 encode_type (objc_method_parm_type (method_decl),
4383 obstack_object_size (&util_obstack),
4384 OBJC_ENCODE_INLINE_DEFS);
4387 /* The first two arguments (self and _cmd) are pointers; account for
4389 i = int_size_in_bytes (ptr_type_node);
4390 parm_offset = 2 * i;
4391 for (parms = METHOD_SEL_ARGS (method_decl); parms;
4392 parms = TREE_CHAIN (parms))
4394 tree type = objc_method_parm_type (parms);
4395 int sz = objc_encoded_type_size (type);
4397 /* If a type size is not known, bail out. */
4400 error ("type %q+D does not have a known size",
4402 /* Pretend that the encoding succeeded; the compilation will
4403 fail nevertheless. */
4404 goto finish_encoding;
4409 sprintf (buf, "%d@0:%d", parm_offset, i);
4410 obstack_grow (&util_obstack, buf, strlen (buf));
4412 /* Argument types. */
4413 parm_offset = 2 * i;
4414 for (parms = METHOD_SEL_ARGS (method_decl); parms;
4415 parms = TREE_CHAIN (parms))
4417 tree type = objc_method_parm_type (parms);
4419 /* Process argument qualifiers for user supplied arguments. */
4420 encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (parms)));
4423 encode_type (type, obstack_object_size (&util_obstack),
4424 OBJC_ENCODE_INLINE_DEFS);
4426 /* Compute offset. */
4427 sprintf (buf, "%d", parm_offset);
4428 parm_offset += objc_encoded_type_size (type);
4430 obstack_grow (&util_obstack, buf, strlen (buf));
4434 obstack_1grow (&util_obstack, '\0');
4435 result = get_identifier (XOBFINISH (&util_obstack, char *));
4436 obstack_free (&util_obstack, util_firstobj);
4441 generate_descriptor_table (tree type, const char *name, int size, tree list,
4445 VEC(constructor_elt,gc) *v = NULL;
4447 decl = start_var_decl (type, synth_id_with_class_suffix (name, proto));
4449 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size));
4450 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, list);
4452 finish_var_decl (decl, objc_build_constructor (type, v));
4458 generate_method_descriptors (tree protocol)
4460 tree initlist, chain, method_list_template;
4463 if (!objc_method_prototype_template)
4464 objc_method_prototype_template = build_method_prototype_template ();
4466 chain = PROTOCOL_CLS_METHODS (protocol);
4469 size = list_length (chain);
4471 method_list_template
4472 = build_method_prototype_list_template (objc_method_prototype_template,
4476 = build_descriptor_table_initializer (objc_method_prototype_template,
4479 UOBJC_CLASS_METHODS_decl
4480 = generate_descriptor_table (method_list_template,
4481 "_OBJC_PROTOCOL_CLASS_METHODS",
4482 size, initlist, protocol);
4485 UOBJC_CLASS_METHODS_decl = 0;
4487 chain = PROTOCOL_NST_METHODS (protocol);
4490 size = list_length (chain);
4492 method_list_template
4493 = build_method_prototype_list_template (objc_method_prototype_template,
4496 = build_descriptor_table_initializer (objc_method_prototype_template,
4499 UOBJC_INSTANCE_METHODS_decl
4500 = generate_descriptor_table (method_list_template,
4501 "_OBJC_PROTOCOL_INSTANCE_METHODS",
4502 size, initlist, protocol);
4505 UOBJC_INSTANCE_METHODS_decl = 0;
4509 generate_protocol_references (tree plist)
4513 /* Forward declare protocols referenced. */
4514 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
4516 tree proto = TREE_VALUE (lproto);
4518 if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE
4519 && PROTOCOL_NAME (proto))
4521 if (! PROTOCOL_FORWARD_DECL (proto))
4522 build_protocol_reference (proto);
4524 if (PROTOCOL_LIST (proto))
4525 generate_protocol_references (PROTOCOL_LIST (proto));
4530 /* Generate either '- .cxx_construct' or '- .cxx_destruct' for the
4534 objc_generate_cxx_ctor_or_dtor (bool dtor)
4536 tree fn, body, compound_stmt, ivar;
4538 /* - (id) .cxx_construct { ... return self; } */
4539 /* - (void) .cxx_construct { ... } */
4541 objc_set_method_type (MINUS_EXPR);
4542 objc_start_method_definition
4543 (objc_build_method_signature (build_tree_list (NULL_TREE,
4546 : objc_object_type),
4547 get_identifier (dtor
4549 : TAG_CXX_CONSTRUCT),
4550 make_node (TREE_LIST),
4552 body = begin_function_body ();
4553 compound_stmt = begin_compound_stmt (0);
4555 ivar = CLASS_IVARS (implementation_template);
4556 /* Destroy ivars in reverse order. */
4558 ivar = nreverse (copy_list (ivar));
4560 for (; ivar; ivar = TREE_CHAIN (ivar))
4562 if (TREE_CODE (ivar) == FIELD_DECL)
4564 tree type = TREE_TYPE (ivar);
4566 /* Call the ivar's default constructor or destructor. Do not
4567 call the destructor unless a corresponding constructor call
4568 has also been made (or is not needed). */
4569 if (MAYBE_CLASS_TYPE_P (type)
4571 ? (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4572 && (!TYPE_NEEDS_CONSTRUCTING (type)
4573 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4574 : (TYPE_NEEDS_CONSTRUCTING (type)
4575 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))))
4577 (build_special_member_call
4578 (build_ivar_reference (DECL_NAME (ivar)),
4579 dtor ? complete_dtor_identifier : complete_ctor_identifier,
4580 NULL, type, LOOKUP_NORMAL, tf_warning_or_error));
4584 /* The constructor returns 'self'. */
4586 finish_return_stmt (self_decl);
4588 finish_compound_stmt (compound_stmt);
4589 finish_function_body (body);
4590 fn = current_function_decl;
4592 objc_finish_method_definition (fn);
4595 /* The following routine will examine the current @interface for any
4596 non-POD C++ ivars requiring non-trivial construction and/or
4597 destruction, and then synthesize special '- .cxx_construct' and/or
4598 '- .cxx_destruct' methods which will run the appropriate
4599 construction or destruction code. Note that ivars inherited from
4600 super-classes are _not_ considered. */
4602 objc_generate_cxx_cdtors (void)
4604 bool need_ctor = false, need_dtor = false;
4607 /* We do not want to do this for categories, since they do not have
4610 if (TREE_CODE (objc_implementation_context) != CLASS_IMPLEMENTATION_TYPE)
4613 /* First, determine if we even need a constructor and/or destructor. */
4615 for (ivar = CLASS_IVARS (implementation_template); ivar;
4616 ivar = TREE_CHAIN (ivar))
4618 if (TREE_CODE (ivar) == FIELD_DECL)
4620 tree type = TREE_TYPE (ivar);
4622 if (MAYBE_CLASS_TYPE_P (type))
4624 if (TYPE_NEEDS_CONSTRUCTING (type)
4625 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
4626 /* NB: If a default constructor is not available, we will not
4627 be able to initialize this ivar; the add_instance_variable()
4628 routine will already have warned about this. */
4631 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4632 && (!TYPE_NEEDS_CONSTRUCTING (type)
4633 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4634 /* NB: If a default constructor is not available, we will not
4635 call the destructor either, for symmetry. */
4641 /* Generate '- .cxx_construct' if needed. */
4644 objc_generate_cxx_ctor_or_dtor (false);
4646 /* Generate '- .cxx_destruct' if needed. */
4649 objc_generate_cxx_ctor_or_dtor (true);
4651 /* The 'imp_list' variable points at an imp_entry record for the current
4652 @implementation. Record the existence of '- .cxx_construct' and/or
4653 '- .cxx_destruct' methods therein; it will be included in the
4654 metadata for the class. */
4655 if (flag_next_runtime)
4656 imp_list->has_cxx_cdtors = (need_ctor || need_dtor);
4660 /* For each protocol which was referenced either from a @protocol()
4661 expression, or because a class/category implements it (then a
4662 pointer to the protocol is stored in the struct describing the
4663 class/category), we create a statically allocated instance of the
4664 Protocol class. The code is written in such a way as to generate
4665 as few Protocol objects as possible; we generate a unique Protocol
4666 instance for each protocol, and we don't generate a Protocol
4667 instance if the protocol is never referenced (either from a
4668 @protocol() or from a class/category implementation). These
4669 statically allocated objects can be referred to via the static
4670 (that is, private to this module) symbols _OBJC_PROTOCOL_n.
4672 The statically allocated Protocol objects that we generate here
4673 need to be fixed up at runtime in order to be used: the 'isa'
4674 pointer of the objects need to be set up to point to the 'Protocol'
4675 class, as known at runtime.
4677 The NeXT runtime fixes up all protocols at program startup time,
4678 before main() is entered. It uses a low-level trick to look up all
4679 those symbols, then loops on them and fixes them up.
4681 The GNU runtime as well fixes up all protocols before user code
4682 from the module is executed; it requires pointers to those symbols
4683 to be put in the objc_symtab (which is then passed as argument to
4684 the function __objc_exec_class() which the compiler sets up to be
4685 executed automatically when the module is loaded); setup of those
4686 Protocol objects happen in two ways in the GNU runtime: all
4687 Protocol objects referred to by a class or category implementation
4688 are fixed up when the class/category is loaded; all Protocol
4689 objects referred to by a @protocol() expression are added by the
4690 compiler to the list of statically allocated instances to fixup
4691 (the same list holding the statically allocated constant string
4692 objects). Because, as explained above, the compiler generates as
4693 few Protocol objects as possible, some Protocol object might end up
4694 being referenced multiple times when compiled with the GNU runtime,
4695 and end up being fixed up multiple times at runtime initialization.
4696 But that doesn't hurt, it's just a little inefficient. */
4699 generate_protocols (void)
4703 tree initlist, protocol_name_expr, refs_decl, refs_expr;
4705 /* If a protocol was directly referenced, pull in indirect references. */
4706 for (p = protocol_chain; p; p = TREE_CHAIN (p))
4707 if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p))
4708 generate_protocol_references (PROTOCOL_LIST (p));
4710 for (p = protocol_chain; p; p = TREE_CHAIN (p))
4712 tree nst_methods = PROTOCOL_NST_METHODS (p);
4713 tree cls_methods = PROTOCOL_CLS_METHODS (p);
4715 /* If protocol wasn't referenced, don't generate any code. */
4716 decl = PROTOCOL_FORWARD_DECL (p);
4721 /* Make sure we link in the Protocol class. */
4722 add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
4726 if (! METHOD_ENCODING (nst_methods))
4728 encoding = encode_method_prototype (nst_methods);
4729 METHOD_ENCODING (nst_methods) = encoding;
4731 nst_methods = TREE_CHAIN (nst_methods);
4736 if (! METHOD_ENCODING (cls_methods))
4738 encoding = encode_method_prototype (cls_methods);
4739 METHOD_ENCODING (cls_methods) = encoding;
4742 cls_methods = TREE_CHAIN (cls_methods);
4744 generate_method_descriptors (p);
4746 if (PROTOCOL_LIST (p))
4747 refs_decl = generate_protocol_list (p);
4751 /* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
4752 protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
4755 refs_expr = convert (build_pointer_type (build_pointer_type
4756 (objc_protocol_template)),
4757 build_unary_op (input_location,
4758 ADDR_EXPR, refs_decl, 0));
4760 refs_expr = build_int_cst (NULL_TREE, 0);
4762 /* UOBJC_INSTANCE_METHODS_decl/UOBJC_CLASS_METHODS_decl are set
4763 by generate_method_descriptors, which is called above. */
4764 initlist = build_protocol_initializer (TREE_TYPE (decl),
4765 protocol_name_expr, refs_expr,
4766 UOBJC_INSTANCE_METHODS_decl,
4767 UOBJC_CLASS_METHODS_decl);
4768 finish_var_decl (decl, initlist);
4773 build_protocol_initializer (tree type, tree protocol_name,
4774 tree protocol_list, tree instance_methods,
4778 tree cast_type = build_pointer_type
4779 (xref_tag (RECORD_TYPE,
4780 get_identifier (UTAG_CLASS)));
4781 VEC(constructor_elt,gc) *inits = NULL;
4783 /* Filling the "isa" in with one allows the runtime system to
4784 detect that the version change...should remove before final release. */
4786 expr = build_int_cst (cast_type, PROTOCOL_VERSION);
4787 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
4788 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_name);
4789 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_list);
4791 if (!instance_methods)
4792 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, 0));
4795 expr = convert (objc_method_proto_list_ptr,
4796 build_unary_op (input_location,
4797 ADDR_EXPR, instance_methods, 0));
4798 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
4802 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, 0));
4805 expr = convert (objc_method_proto_list_ptr,
4806 build_unary_op (input_location,
4807 ADDR_EXPR, class_methods, 0));
4808 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
4811 return objc_build_constructor (type, inits);
4814 /* struct _objc_category {
4815 char *category_name;
4817 struct _objc_method_list *instance_methods;
4818 struct _objc_method_list *class_methods;
4819 struct _objc_protocol_list *protocols;
4823 build_category_template (void)
4825 tree field_decl, field_decl_chain;
4827 objc_category_template = objc_start_struct (get_identifier (UTAG_CATEGORY));
4829 /* char *category_name; */
4830 field_decl = create_field_decl (string_type_node, "category_name");
4831 field_decl_chain = field_decl;
4833 /* char *class_name; */
4834 field_decl = create_field_decl (string_type_node, "class_name");
4835 chainon (field_decl_chain, field_decl);
4837 /* struct _objc_method_list *instance_methods; */
4838 field_decl = create_field_decl (objc_method_list_ptr,
4839 "instance_methods");
4840 chainon (field_decl_chain, field_decl);
4842 /* struct _objc_method_list *class_methods; */
4843 field_decl = create_field_decl (objc_method_list_ptr,
4845 chainon (field_decl_chain, field_decl);
4847 /* struct _objc_protocol **protocol_list; */
4848 field_decl = create_field_decl (build_pointer_type
4850 (objc_protocol_template)),
4852 chainon (field_decl_chain, field_decl);
4854 objc_finish_struct (objc_category_template, field_decl_chain);
4857 /* struct _objc_selector {
4863 build_selector_template (void)
4865 tree field_decl, field_decl_chain;
4867 objc_selector_template = objc_start_struct (get_identifier (UTAG_SELECTOR));
4870 field_decl = create_field_decl (objc_selector_type, "sel_id");
4871 field_decl_chain = field_decl;
4873 /* char *sel_type; */
4874 field_decl = create_field_decl (string_type_node, "sel_type");
4875 chainon (field_decl_chain, field_decl);
4877 objc_finish_struct (objc_selector_template, field_decl_chain);
4880 /* struct _objc_class {
4881 struct _objc_class *isa;
4882 struct _objc_class *super_class;
4887 struct _objc_ivar_list *ivars;
4888 struct _objc_method_list *methods;
4889 #ifdef __NEXT_RUNTIME__
4890 struct objc_cache *cache;
4892 struct sarray *dtable;
4893 struct _objc_class *subclass_list;
4894 struct _objc_class *sibling_class;
4896 struct _objc_protocol_list *protocols;
4897 #ifdef __NEXT_RUNTIME__
4900 void *gc_object_type;
4903 /* NB: The 'sel_id' and 'gc_object_type' fields are not being used by
4904 the NeXT/Apple runtime; still, the compiler must generate them to
4905 maintain backward binary compatibility (and to allow for future
4909 build_class_template (void)
4911 tree field_decl, field_decl_chain;
4913 objc_class_template = objc_start_struct (get_identifier (UTAG_CLASS));
4915 /* struct _objc_class *isa; */
4916 field_decl = create_field_decl (build_pointer_type (objc_class_template),
4918 field_decl_chain = field_decl;
4920 /* struct _objc_class *super_class; */
4921 field_decl = create_field_decl (build_pointer_type (objc_class_template),
4923 chainon (field_decl_chain, field_decl);
4926 field_decl = create_field_decl (string_type_node, "name");
4927 chainon (field_decl_chain, field_decl);
4930 field_decl = create_field_decl (long_integer_type_node, "version");
4931 chainon (field_decl_chain, field_decl);
4934 field_decl = create_field_decl (long_integer_type_node, "info");
4935 chainon (field_decl_chain, field_decl);
4937 /* long instance_size; */
4938 field_decl = create_field_decl (long_integer_type_node, "instance_size");
4939 chainon (field_decl_chain, field_decl);
4941 /* struct _objc_ivar_list *ivars; */
4942 field_decl = create_field_decl (objc_ivar_list_ptr,
4944 chainon (field_decl_chain, field_decl);
4946 /* struct _objc_method_list *methods; */
4947 field_decl = create_field_decl (objc_method_list_ptr,
4949 chainon (field_decl_chain, field_decl);
4951 if (flag_next_runtime)
4953 /* struct objc_cache *cache; */
4954 field_decl = create_field_decl (build_pointer_type
4955 (xref_tag (RECORD_TYPE,
4959 chainon (field_decl_chain, field_decl);
4963 /* struct sarray *dtable; */
4964 field_decl = create_field_decl (build_pointer_type
4965 (xref_tag (RECORD_TYPE,
4969 chainon (field_decl_chain, field_decl);
4971 /* struct objc_class *subclass_list; */
4972 field_decl = create_field_decl (build_pointer_type
4973 (objc_class_template),
4975 chainon (field_decl_chain, field_decl);
4977 /* struct objc_class *sibling_class; */
4978 field_decl = create_field_decl (build_pointer_type
4979 (objc_class_template),
4981 chainon (field_decl_chain, field_decl);
4984 /* struct _objc_protocol **protocol_list; */
4985 field_decl = create_field_decl (build_pointer_type
4987 (xref_tag (RECORD_TYPE,
4991 chainon (field_decl_chain, field_decl);
4993 if (flag_next_runtime)
4996 field_decl = create_field_decl (build_pointer_type (void_type_node),
4998 chainon (field_decl_chain, field_decl);
5001 /* void *gc_object_type; */
5002 field_decl = create_field_decl (build_pointer_type (void_type_node),
5004 chainon (field_decl_chain, field_decl);
5006 objc_finish_struct (objc_class_template, field_decl_chain);
5009 /* Generate appropriate forward declarations for an implementation. */
5012 synth_forward_declarations (void)
5016 /* static struct objc_class _OBJC_CLASS_<my_name>; */
5017 UOBJC_CLASS_decl = build_metadata_decl ("_OBJC_CLASS",
5018 objc_class_template);
5020 /* static struct objc_class _OBJC_METACLASS_<my_name>; */
5021 UOBJC_METACLASS_decl = build_metadata_decl ("_OBJC_METACLASS",
5022 objc_class_template);
5024 /* Pre-build the following entities - for speed/convenience. */
5026 an_id = get_identifier ("super_class");
5027 ucls_super_ref = objc_build_component_ref (UOBJC_CLASS_decl, an_id);
5028 uucls_super_ref = objc_build_component_ref (UOBJC_METACLASS_decl, an_id);
5032 error_with_ivar (const char *message, tree decl)
5034 error_at (DECL_SOURCE_LOCATION (decl), "%s %qs",
5035 message, identifier_to_locale (gen_declaration (decl)));
5040 check_ivars (tree inter, tree imp)
5042 tree intdecls = CLASS_RAW_IVARS (inter);
5043 tree impdecls = CLASS_RAW_IVARS (imp);
5050 if (intdecls && TREE_CODE (intdecls) == TYPE_DECL)
5051 intdecls = TREE_CHAIN (intdecls);
5053 if (intdecls == 0 && impdecls == 0)
5055 if (intdecls == 0 || impdecls == 0)
5057 error ("inconsistent instance variable specification");
5061 t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls);
5063 if (!comptypes (t1, t2)
5064 || !tree_int_cst_equal (DECL_INITIAL (intdecls),
5065 DECL_INITIAL (impdecls)))
5067 if (DECL_NAME (intdecls) == DECL_NAME (impdecls))
5069 error_with_ivar ("conflicting instance variable type",
5071 error_with_ivar ("previous declaration of",
5074 else /* both the type and the name don't match */
5076 error ("inconsistent instance variable specification");
5081 else if (DECL_NAME (intdecls) != DECL_NAME (impdecls))
5083 error_with_ivar ("conflicting instance variable name",
5085 error_with_ivar ("previous declaration of",
5089 intdecls = TREE_CHAIN (intdecls);
5090 impdecls = TREE_CHAIN (impdecls);
5094 /* Set 'objc_super_template' to the data type node for 'struct _objc_super'.
5095 This needs to be done just once per compilation. */
5097 /* struct _objc_super {
5098 struct _objc_object *self;
5099 struct _objc_class *super_class;
5103 build_super_template (void)
5105 tree field_decl, field_decl_chain;
5107 objc_super_template = objc_start_struct (get_identifier (UTAG_SUPER));
5109 /* struct _objc_object *self; */
5110 field_decl = create_field_decl (objc_object_type, "self");
5111 field_decl_chain = field_decl;
5113 /* struct _objc_class *super_class; */
5114 field_decl = create_field_decl (build_pointer_type (objc_class_template),
5116 chainon (field_decl_chain, field_decl);
5118 objc_finish_struct (objc_super_template, field_decl_chain);
5121 /* struct _objc_ivar {
5128 build_ivar_template (void)
5130 tree objc_ivar_id, objc_ivar_record;
5131 tree field_decl, field_decl_chain;
5133 objc_ivar_id = get_identifier (UTAG_IVAR);
5134 objc_ivar_record = objc_start_struct (objc_ivar_id);
5136 /* char *ivar_name; */
5137 field_decl = create_field_decl (string_type_node, "ivar_name");
5138 field_decl_chain = field_decl;
5140 /* char *ivar_type; */
5141 field_decl = create_field_decl (string_type_node, "ivar_type");
5142 chainon (field_decl_chain, field_decl);
5144 /* int ivar_offset; */
5145 field_decl = create_field_decl (integer_type_node, "ivar_offset");
5146 chainon (field_decl_chain, field_decl);
5148 objc_finish_struct (objc_ivar_record, field_decl_chain);
5150 return objc_ivar_record;
5155 struct objc_ivar ivar_list[ivar_count];
5159 build_ivar_list_template (tree list_type, int size)
5161 tree objc_ivar_list_record;
5162 tree field_decl, field_decl_chain;
5164 objc_ivar_list_record = objc_start_struct (NULL_TREE);
5166 /* int ivar_count; */
5167 field_decl = create_field_decl (integer_type_node, "ivar_count");
5168 field_decl_chain = field_decl;
5170 /* struct objc_ivar ivar_list[]; */
5171 field_decl = create_field_decl (build_array_type
5174 (build_int_cst (NULL_TREE, size - 1))),
5176 chainon (field_decl_chain, field_decl);
5178 objc_finish_struct (objc_ivar_list_record, field_decl_chain);
5180 return objc_ivar_list_record;
5184 struct _objc__method_prototype_list *method_next;
5186 struct objc_method method_list[method_count];
5190 build_method_list_template (tree list_type, int size)
5192 tree objc_ivar_list_record;
5193 tree field_decl, field_decl_chain;
5195 objc_ivar_list_record = objc_start_struct (NULL_TREE);
5197 /* struct _objc__method_prototype_list *method_next; */
5198 field_decl = create_field_decl (objc_method_proto_list_ptr,
5200 field_decl_chain = field_decl;
5202 /* int method_count; */
5203 field_decl = create_field_decl (integer_type_node, "method_count");
5204 chainon (field_decl_chain, field_decl);
5206 /* struct objc_method method_list[]; */
5207 field_decl = create_field_decl (build_array_type
5210 (build_int_cst (NULL_TREE, size - 1))),
5212 chainon (field_decl_chain, field_decl);
5214 objc_finish_struct (objc_ivar_list_record, field_decl_chain);
5216 return objc_ivar_list_record;
5220 build_ivar_list_initializer (tree type, tree field_decl)
5222 VEC(constructor_elt,gc) *inits = NULL;
5226 VEC(constructor_elt,gc) *ivar = NULL;
5230 if (DECL_NAME (field_decl))
5231 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE,
5232 add_objc_string (DECL_NAME (field_decl),
5235 /* Unnamed bit-field ivar (yuck). */
5236 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, build_int_cst (NULL_TREE, 0));
5239 encode_field_decl (field_decl,
5240 obstack_object_size (&util_obstack),
5241 OBJC_ENCODE_DONT_INLINE_DEFS);
5243 /* Null terminate string. */
5244 obstack_1grow (&util_obstack, 0);
5245 id = add_objc_string (get_identifier (XOBFINISH (&util_obstack, char *)),
5247 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, id);
5248 obstack_free (&util_obstack, util_firstobj);
5251 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, byte_position (field_decl));
5252 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
5253 objc_build_constructor (type, ivar));
5255 field_decl = TREE_CHAIN (field_decl);
5256 while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
5260 return objc_build_constructor (build_array_type (type, 0), inits);
5264 generate_ivars_list (tree type, const char *name, int size, tree list)
5267 VEC(constructor_elt,gc) *inits = NULL;
5269 decl = start_var_decl (type, synth_id_with_class_suffix
5270 (name, objc_implementation_context));
5272 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, size));
5273 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, list);
5275 finish_var_decl (decl,
5276 objc_build_constructor (TREE_TYPE (decl), inits));
5281 /* Count only the fields occurring in T. */
5284 ivar_list_length (tree t)
5288 for (; t; t = TREE_CHAIN (t))
5289 if (TREE_CODE (t) == FIELD_DECL)
5296 generate_ivar_lists (void)
5298 tree initlist, ivar_list_template, chain;
5301 generating_instance_variables = 1;
5303 if (!objc_ivar_template)
5304 objc_ivar_template = build_ivar_template ();
5306 /* Only generate class variables for the root of the inheritance
5307 hierarchy since these will be the same for every class. */
5309 if (CLASS_SUPER_NAME (implementation_template) == NULL_TREE
5310 && (chain = TYPE_FIELDS (objc_class_template)))
5312 size = ivar_list_length (chain);
5314 ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
5315 initlist = build_ivar_list_initializer (objc_ivar_template, chain);
5317 UOBJC_CLASS_VARIABLES_decl
5318 = generate_ivars_list (ivar_list_template, "_OBJC_CLASS_VARIABLES",
5322 UOBJC_CLASS_VARIABLES_decl = 0;
5324 chain = CLASS_IVARS (implementation_template);
5327 size = ivar_list_length (chain);
5328 ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
5329 initlist = build_ivar_list_initializer (objc_ivar_template, chain);
5331 UOBJC_INSTANCE_VARIABLES_decl
5332 = generate_ivars_list (ivar_list_template, "_OBJC_INSTANCE_VARIABLES",
5336 UOBJC_INSTANCE_VARIABLES_decl = 0;
5338 generating_instance_variables = 0;
5342 build_dispatch_table_initializer (tree type, tree entries)
5344 VEC(constructor_elt,gc) *inits = NULL;
5348 VEC(constructor_elt,gc) *elems = NULL;
5351 CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE,
5352 build_selector (METHOD_SEL_NAME (entries)));
5354 /* Generate the method encoding if we don't have one already. */
5355 if (! METHOD_ENCODING (entries))
5356 METHOD_ENCODING (entries) =
5357 encode_method_prototype (entries);
5359 CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE,
5360 add_objc_string (METHOD_ENCODING (entries),
5363 expr = convert (ptr_type_node,
5364 build_unary_op (input_location, ADDR_EXPR,
5365 METHOD_DEFINITION (entries), 1));
5366 CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE, expr);
5368 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
5369 objc_build_constructor (type, elems));
5371 entries = TREE_CHAIN (entries);
5375 return objc_build_constructor (build_array_type (type, 0), inits);
5378 /* To accomplish method prototyping without generating all kinds of
5379 inane warnings, the definition of the dispatch table entries were
5382 struct objc_method { SEL _cmd; ...; id (*_imp)(); };
5384 struct objc_method { SEL _cmd; ...; void *_imp; }; */
5387 build_method_template (void)
5390 tree field_decl, field_decl_chain;
5392 _SLT_record = objc_start_struct (get_identifier (UTAG_METHOD));
5395 field_decl = create_field_decl (objc_selector_type, "_cmd");
5396 field_decl_chain = field_decl;
5398 /* char *method_types; */
5399 field_decl = create_field_decl (string_type_node, "method_types");
5400 chainon (field_decl_chain, field_decl);
5403 field_decl = create_field_decl (build_pointer_type (void_type_node),
5405 chainon (field_decl_chain, field_decl);
5407 objc_finish_struct (_SLT_record, field_decl_chain);
5414 generate_dispatch_table (tree type, const char *name, int size, tree list)
5417 VEC(constructor_elt,gc) *v = NULL;
5419 decl = start_var_decl (type, synth_id_with_class_suffix
5420 (name, objc_implementation_context));
5422 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5423 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size));
5424 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, list);
5426 finish_var_decl (decl,
5427 objc_build_constructor (TREE_TYPE (decl), v));
5433 mark_referenced_methods (void)
5435 struct imp_entry *impent;
5438 for (impent = imp_list; impent; impent = impent->next)
5440 chain = CLASS_CLS_METHODS (impent->imp_context);
5443 cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain)));
5444 chain = TREE_CHAIN (chain);
5447 chain = CLASS_NST_METHODS (impent->imp_context);
5450 cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain)));
5451 chain = TREE_CHAIN (chain);
5457 generate_dispatch_tables (void)
5459 tree initlist, chain, method_list_template;
5462 if (!objc_method_template)
5463 objc_method_template = build_method_template ();
5465 chain = CLASS_CLS_METHODS (objc_implementation_context);
5468 size = list_length (chain);
5470 method_list_template
5471 = build_method_list_template (objc_method_template, size);
5473 = build_dispatch_table_initializer (objc_method_template, chain);
5475 UOBJC_CLASS_METHODS_decl
5476 = generate_dispatch_table (method_list_template,
5477 ((TREE_CODE (objc_implementation_context)
5478 == CLASS_IMPLEMENTATION_TYPE)
5479 ? "_OBJC_CLASS_METHODS"
5480 : "_OBJC_CATEGORY_CLASS_METHODS"),
5484 UOBJC_CLASS_METHODS_decl = 0;
5486 chain = CLASS_NST_METHODS (objc_implementation_context);
5489 size = list_length (chain);
5491 method_list_template
5492 = build_method_list_template (objc_method_template, size);
5494 = build_dispatch_table_initializer (objc_method_template, chain);
5496 if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
5497 UOBJC_INSTANCE_METHODS_decl
5498 = generate_dispatch_table (method_list_template,
5499 "_OBJC_INSTANCE_METHODS",
5502 /* We have a category. */
5503 UOBJC_INSTANCE_METHODS_decl
5504 = generate_dispatch_table (method_list_template,
5505 "_OBJC_CATEGORY_INSTANCE_METHODS",
5509 UOBJC_INSTANCE_METHODS_decl = 0;
5513 generate_protocol_list (tree i_or_p)
5515 tree refs_decl, lproto, e, plist;
5517 const char *ref_name;
5518 VEC(constructor_elt,gc) *v = NULL;
5520 if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE
5521 || TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
5522 plist = CLASS_PROTOCOL_LIST (i_or_p);
5523 else if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
5524 plist = PROTOCOL_LIST (i_or_p);
5529 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
5530 if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
5531 && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto)))
5534 /* Build initializer. */
5535 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5536 e = build_int_cst (build_pointer_type (objc_protocol_template), size);
5537 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e);
5539 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
5541 tree pval = TREE_VALUE (lproto);
5543 if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
5544 && PROTOCOL_FORWARD_DECL (pval))
5546 e = build_unary_op (input_location, ADDR_EXPR,
5547 PROTOCOL_FORWARD_DECL (pval), 0);
5548 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e);
5552 /* static struct objc_protocol *refs[n]; */
5554 if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
5555 ref_name = synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS", i_or_p);
5556 else if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE)
5557 ref_name = synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS", i_or_p);
5558 else if (TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
5559 ref_name = synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS", i_or_p);
5563 refs_decl = start_var_decl
5565 (build_pointer_type (objc_protocol_template),
5566 build_index_type (build_int_cst (NULL_TREE, size + 2))),
5569 finish_var_decl (refs_decl,
5570 objc_build_constructor (TREE_TYPE (refs_decl), v));
5576 build_category_initializer (tree type, tree cat_name, tree class_name,
5577 tree instance_methods, tree class_methods,
5581 VEC(constructor_elt,gc) *v = NULL;
5583 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, cat_name);
5584 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, class_name);
5586 if (!instance_methods)
5587 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5590 expr = convert (objc_method_list_ptr,
5591 build_unary_op (input_location, ADDR_EXPR,
5592 instance_methods, 0));
5593 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
5596 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5599 expr = convert (objc_method_list_ptr,
5600 build_unary_op (input_location, ADDR_EXPR,
5602 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
5605 /* protocol_list = */
5607 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5610 expr = convert (build_pointer_type
5612 (objc_protocol_template)),
5613 build_unary_op (input_location, ADDR_EXPR,
5615 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
5618 return objc_build_constructor (type, v);
5621 /* struct _objc_class {
5622 struct objc_class *isa;
5623 struct objc_class *super_class;
5628 struct objc_ivar_list *ivars;
5629 struct objc_method_list *methods;
5630 if (flag_next_runtime)
5631 struct objc_cache *cache;
5633 struct sarray *dtable;
5634 struct objc_class *subclass_list;
5635 struct objc_class *sibling_class;
5637 struct objc_protocol_list *protocols;
5638 if (flag_next_runtime)
5640 void *gc_object_type;
5644 build_shared_structure_initializer (tree type, tree isa, tree super,
5645 tree name, tree size, int status,
5646 tree dispatch_table, tree ivar_list,
5650 VEC(constructor_elt,gc) *v = NULL;
5653 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, isa);
5656 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, super);
5659 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, default_conversion (name));
5662 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
5663 build_int_cst (long_integer_type_node, 0));
5666 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
5667 build_int_cst (long_integer_type_node, status));
5669 /* instance_size = */
5670 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
5671 convert (long_integer_type_node, size));
5673 /* objc_ivar_list = */
5675 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5678 expr = convert (objc_ivar_list_ptr,
5679 build_unary_op (input_location, ADDR_EXPR,
5681 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
5684 /* objc_method_list = */
5685 if (!dispatch_table)
5686 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5689 expr = convert (objc_method_list_ptr,
5690 build_unary_op (input_location, ADDR_EXPR,
5691 dispatch_table, 0));
5692 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
5695 if (flag_next_runtime)
5696 /* method_cache = */
5697 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5701 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5703 /* subclass_list = */
5704 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5706 /* sibling_class = */
5707 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5710 /* protocol_list = */
5711 if (! protocol_list)
5712 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5715 expr = convert (build_pointer_type
5717 (objc_protocol_template)),
5718 build_unary_op (input_location, ADDR_EXPR,
5720 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
5723 if (flag_next_runtime)
5725 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5727 /* gc_object_type = NULL */
5728 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
5730 return objc_build_constructor (type, v);
5733 /* Retrieve category interface CAT_NAME (if any) associated with CLASS. */
5736 lookup_category (tree klass, tree cat_name)
5738 tree category = CLASS_CATEGORY_LIST (klass);
5740 while (category && CLASS_SUPER_NAME (category) != cat_name)
5741 category = CLASS_CATEGORY_LIST (category);
5745 /* static struct objc_category _OBJC_CATEGORY_<name> = { ... }; */
5748 generate_category (tree cat)
5751 tree initlist, cat_name_expr, class_name_expr;
5752 tree protocol_decl, category;
5754 add_class_reference (CLASS_NAME (cat));
5755 cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names);
5757 class_name_expr = add_objc_string (CLASS_NAME (cat), class_names);
5759 category = lookup_category (implementation_template,
5760 CLASS_SUPER_NAME (cat));
5762 if (category && CLASS_PROTOCOL_LIST (category))
5764 generate_protocol_references (CLASS_PROTOCOL_LIST (category));
5765 protocol_decl = generate_protocol_list (category);
5770 decl = start_var_decl (objc_category_template,
5771 synth_id_with_class_suffix
5772 ("_OBJC_CATEGORY", objc_implementation_context));
5774 initlist = build_category_initializer (TREE_TYPE (decl),
5775 cat_name_expr, class_name_expr,
5776 UOBJC_INSTANCE_METHODS_decl,
5777 UOBJC_CLASS_METHODS_decl,
5780 finish_var_decl (decl, initlist);
5783 /* static struct objc_class _OBJC_METACLASS_Foo={ ... };
5784 static struct objc_class _OBJC_CLASS_Foo={ ... }; */
5787 generate_shared_structures (int cls_flags)
5790 tree name_expr, super_expr, root_expr;
5791 tree my_root_id = NULL_TREE, my_super_id = NULL_TREE;
5792 tree cast_type, initlist, protocol_decl;
5794 my_super_id = CLASS_SUPER_NAME (implementation_template);
5797 add_class_reference (my_super_id);
5799 /* Compute "my_root_id" - this is required for code generation.
5800 the "isa" for all meta class structures points to the root of
5801 the inheritance hierarchy (e.g. "__Object")... */
5802 my_root_id = my_super_id;
5805 tree my_root_int = lookup_interface (my_root_id);
5807 if (my_root_int && CLASS_SUPER_NAME (my_root_int))
5808 my_root_id = CLASS_SUPER_NAME (my_root_int);
5815 /* No super class. */
5816 my_root_id = CLASS_NAME (implementation_template);
5818 cast_type = build_pointer_type (objc_class_template);
5819 name_expr = add_objc_string (CLASS_NAME (implementation_template),
5822 /* Install class `isa' and `super' pointers at runtime. */
5825 super_expr = add_objc_string (my_super_id, class_names);
5826 super_expr = build_c_cast (input_location,
5827 cast_type, super_expr); /* cast! */
5830 super_expr = build_int_cst (NULL_TREE, 0);
5832 root_expr = add_objc_string (my_root_id, class_names);
5833 root_expr = build_c_cast (input_location, cast_type, root_expr); /* cast! */
5835 if (CLASS_PROTOCOL_LIST (implementation_template))
5837 generate_protocol_references
5838 (CLASS_PROTOCOL_LIST (implementation_template));
5839 protocol_decl = generate_protocol_list (implementation_template);
5844 /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */
5846 decl = start_var_decl (objc_class_template,
5848 (DECL_NAME (UOBJC_METACLASS_decl)));
5851 = build_shared_structure_initializer
5853 root_expr, super_expr, name_expr,
5854 convert (integer_type_node, TYPE_SIZE_UNIT (objc_class_template)),
5856 UOBJC_CLASS_METHODS_decl,
5857 UOBJC_CLASS_VARIABLES_decl,
5860 finish_var_decl (decl, initlist);
5862 /* static struct objc_class _OBJC_CLASS_Foo={ ... }; */
5864 decl = start_var_decl (objc_class_template,
5866 (DECL_NAME (UOBJC_CLASS_decl)));
5869 = build_shared_structure_initializer
5871 build_unary_op (input_location, ADDR_EXPR, UOBJC_METACLASS_decl, 0),
5872 super_expr, name_expr,
5873 convert (integer_type_node,
5874 TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE
5875 (implementation_template))),
5876 1 /*CLS_FACTORY*/ | cls_flags,
5877 UOBJC_INSTANCE_METHODS_decl,
5878 UOBJC_INSTANCE_VARIABLES_decl,
5881 finish_var_decl (decl, initlist);
5886 synth_id_with_class_suffix (const char *preamble, tree ctxt)
5888 static char string[BUFSIZE];
5890 if (TREE_CODE (ctxt) == CLASS_IMPLEMENTATION_TYPE
5891 || TREE_CODE (ctxt) == CLASS_INTERFACE_TYPE)
5893 sprintf (string, "%s_%s", preamble,
5894 IDENTIFIER_POINTER (CLASS_NAME (ctxt)));
5896 else if (TREE_CODE (ctxt) == CATEGORY_IMPLEMENTATION_TYPE
5897 || TREE_CODE (ctxt) == CATEGORY_INTERFACE_TYPE)
5899 /* We have a category. */
5900 const char *const class_name
5901 = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
5902 const char *const class_super_name
5903 = IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context));
5904 sprintf (string, "%s_%s_%s", preamble, class_name, class_super_name);
5906 else if (TREE_CODE (ctxt) == PROTOCOL_INTERFACE_TYPE)
5908 const char *protocol_name = IDENTIFIER_POINTER (PROTOCOL_NAME (ctxt));
5909 sprintf (string, "%s_%s", preamble, protocol_name);
5917 /* If type is empty or only type qualifiers are present, add default
5918 type of id (otherwise grokdeclarator will default to int). */
5921 adjust_type_for_id_default (tree type)
5924 type = make_node (TREE_LIST);
5926 if (!TREE_VALUE (type))
5927 TREE_VALUE (type) = objc_object_type;
5928 else if (TREE_CODE (TREE_VALUE (type)) == RECORD_TYPE
5929 && TYPED_OBJECT (TREE_VALUE (type)))
5930 error ("can not use an object as parameter to a method");
5937 selector ':' '(' typename ')' identifier
5940 Transform an Objective-C keyword argument into
5941 the C equivalent parameter declarator.
5943 In: key_name, an "identifier_node" (optional).
5944 arg_type, a "tree_list" (optional).
5945 arg_name, an "identifier_node".
5947 Note: It would be really nice to strongly type the preceding
5948 arguments in the function prototype; however, then I
5949 could not use the "accessor" macros defined in "tree.h".
5951 Out: an instance of "keyword_decl". */
5954 objc_build_keyword_decl (tree key_name, tree arg_type, tree arg_name)
5958 /* If no type is specified, default to "id". */
5959 arg_type = adjust_type_for_id_default (arg_type);
5961 keyword_decl = make_node (KEYWORD_DECL);
5963 TREE_TYPE (keyword_decl) = arg_type;
5964 KEYWORD_ARG_NAME (keyword_decl) = arg_name;
5965 KEYWORD_KEY_NAME (keyword_decl) = key_name;
5967 return keyword_decl;
5970 /* Given a chain of keyword_decl's, synthesize the full keyword selector. */
5973 build_keyword_selector (tree selector)
5976 tree key_chain, key_name;
5979 /* Scan the selector to see how much space we'll need. */
5980 for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
5982 if (TREE_CODE (selector) == KEYWORD_DECL)
5983 key_name = KEYWORD_KEY_NAME (key_chain);
5984 else if (TREE_CODE (selector) == TREE_LIST)
5985 key_name = TREE_PURPOSE (key_chain);
5990 len += IDENTIFIER_LENGTH (key_name) + 1;
5992 /* Just a ':' arg. */
5996 buf = (char *) alloca (len + 1);
5997 /* Start the buffer out as an empty string. */
6000 for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
6002 if (TREE_CODE (selector) == KEYWORD_DECL)
6003 key_name = KEYWORD_KEY_NAME (key_chain);
6004 else if (TREE_CODE (selector) == TREE_LIST)
6006 key_name = TREE_PURPOSE (key_chain);
6007 /* The keyword decl chain will later be used as a function argument
6008 chain. Unhook the selector itself so as to not confuse other
6009 parts of the compiler. */
6010 TREE_PURPOSE (key_chain) = NULL_TREE;
6016 strcat (buf, IDENTIFIER_POINTER (key_name));
6020 return get_identifier (buf);
6023 /* Used for declarations and definitions. */
6026 build_method_decl (enum tree_code code, tree ret_type, tree selector,
6027 tree add_args, bool ellipsis)
6031 /* If no type is specified, default to "id". */
6032 ret_type = adjust_type_for_id_default (ret_type);
6034 method_decl = make_node (code);
6035 TREE_TYPE (method_decl) = ret_type;
6037 /* If we have a keyword selector, create an identifier_node that
6038 represents the full selector name (`:' included)... */
6039 if (TREE_CODE (selector) == KEYWORD_DECL)
6041 METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector);
6042 METHOD_SEL_ARGS (method_decl) = selector;
6043 METHOD_ADD_ARGS (method_decl) = add_args;
6044 METHOD_ADD_ARGS_ELLIPSIS_P (method_decl) = ellipsis;
6048 METHOD_SEL_NAME (method_decl) = selector;
6049 METHOD_SEL_ARGS (method_decl) = NULL_TREE;
6050 METHOD_ADD_ARGS (method_decl) = NULL_TREE;
6056 #define METHOD_DEF 0
6057 #define METHOD_REF 1
6059 /* Used by `build_objc_method_call' and `comp_proto_with_proto'. Return
6060 an argument list for method METH. CONTEXT is either METHOD_DEF or
6061 METHOD_REF, saying whether we are trying to define a method or call
6062 one. SUPERFLAG says this is for a send to super; this makes a
6063 difference for the NeXT calling sequence in which the lookup and
6064 the method call are done together. If METH is null, user-defined
6065 arguments (i.e., beyond self and _cmd) shall be represented by `...'. */
6068 get_arg_type_list (tree meth, int context, int superflag)
6072 /* Receiver type. */
6073 if (flag_next_runtime && superflag)
6074 arglist = build_tree_list (NULL_TREE, objc_super_type);
6075 else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
6076 arglist = build_tree_list (NULL_TREE, objc_instance_type);
6078 arglist = build_tree_list (NULL_TREE, objc_object_type);
6080 /* Selector type - will eventually change to `int'. */
6081 chainon (arglist, build_tree_list (NULL_TREE, objc_selector_type));
6083 /* No actual method prototype given -- assume that remaining arguments
6088 /* Build a list of argument types. */
6089 for (akey = METHOD_SEL_ARGS (meth); akey; akey = TREE_CHAIN (akey))
6091 tree arg_type = TREE_VALUE (TREE_TYPE (akey));
6093 /* Decay arrays and functions into pointers. */
6094 if (TREE_CODE (arg_type) == ARRAY_TYPE)
6095 arg_type = build_pointer_type (TREE_TYPE (arg_type));
6096 else if (TREE_CODE (arg_type) == FUNCTION_TYPE)
6097 arg_type = build_pointer_type (arg_type);
6099 chainon (arglist, build_tree_list (NULL_TREE, arg_type));
6102 if (METHOD_ADD_ARGS (meth))
6104 for (akey = TREE_CHAIN (METHOD_ADD_ARGS (meth));
6105 akey; akey = TREE_CHAIN (akey))
6107 tree arg_type = TREE_TYPE (TREE_VALUE (akey));
6109 chainon (arglist, build_tree_list (NULL_TREE, arg_type));
6112 if (!METHOD_ADD_ARGS_ELLIPSIS_P (meth))
6113 goto lack_of_ellipsis;
6118 chainon (arglist, OBJC_VOID_AT_END);
6125 check_duplicates (hash hsh, int methods, int is_class)
6127 tree meth = NULL_TREE;
6135 /* We have two or more methods with the same name but
6139 /* But just how different are those types? If
6140 -Wno-strict-selector-match is specified, we shall not
6141 complain if the differences are solely among types with
6142 identical size and alignment. */
6143 if (!warn_strict_selector_match)
6145 for (loop = hsh->list; loop; loop = loop->next)
6146 if (!comp_proto_with_proto (meth, loop->value, 0))
6155 bool type = TREE_CODE (meth) == INSTANCE_METHOD_DECL;
6157 warning_at (input_location, 0,
6158 "multiple methods named %<%c%E%> found",
6159 (is_class ? '+' : '-'),
6160 METHOD_SEL_NAME (meth));
6161 inform (DECL_SOURCE_LOCATION (meth), "using %<%c%s%>",
6163 identifier_to_locale (gen_method_decl (meth)));
6167 bool type = TREE_CODE (meth) == INSTANCE_METHOD_DECL;
6169 warning_at (input_location, 0,
6170 "multiple selectors named %<%c%E%> found",
6171 (is_class ? '+' : '-'),
6172 METHOD_SEL_NAME (meth));
6173 inform (DECL_SOURCE_LOCATION (meth), "found %<%c%s%>",
6175 identifier_to_locale (gen_method_decl (meth)));
6178 for (loop = hsh->list; loop; loop = loop->next)
6180 bool type = TREE_CODE (loop->value) == INSTANCE_METHOD_DECL;
6182 inform (DECL_SOURCE_LOCATION (loop->value), "also found %<%c%s%>",
6184 identifier_to_locale (gen_method_decl (loop->value)));
6191 /* If RECEIVER is a class reference, return the identifier node for
6192 the referenced class. RECEIVER is created by objc_get_class_reference,
6193 so we check the exact form created depending on which runtimes are
6197 receiver_is_class_object (tree receiver, int self, int super)
6199 tree chain, exp, arg;
6201 /* The receiver is 'self' or 'super' in the context of a class method. */
6202 if (objc_method_context
6203 && TREE_CODE (objc_method_context) == CLASS_METHOD_DECL
6206 ? CLASS_SUPER_NAME (implementation_template)
6207 : CLASS_NAME (implementation_template));
6209 if (flag_next_runtime)
6211 /* The receiver is a variable created by
6212 build_class_reference_decl. */
6213 if (TREE_CODE (receiver) == VAR_DECL && IS_CLASS (TREE_TYPE (receiver)))
6214 /* Look up the identifier. */
6215 for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
6216 if (TREE_PURPOSE (chain) == receiver)
6217 return TREE_VALUE (chain);
6220 /* The receiver is a function call that returns an id. Check if
6221 it is a call to objc_getClass, if so, pick up the class name. */
6222 if (TREE_CODE (receiver) == CALL_EXPR
6223 && (exp = CALL_EXPR_FN (receiver))
6224 && TREE_CODE (exp) == ADDR_EXPR
6225 && (exp = TREE_OPERAND (exp, 0))
6226 && TREE_CODE (exp) == FUNCTION_DECL
6227 /* For some reason, we sometimes wind up with multiple FUNCTION_DECL
6228 prototypes for objc_get_class(). Thankfully, they seem to share the
6229 same function type. */
6230 && TREE_TYPE (exp) == TREE_TYPE (objc_get_class_decl)
6231 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp)), TAG_GETCLASS)
6232 /* We have a call to objc_get_class/objc_getClass! */
6233 && (arg = CALL_EXPR_ARG (receiver, 0)))
6236 if (TREE_CODE (arg) == ADDR_EXPR
6237 && (arg = TREE_OPERAND (arg, 0))
6238 && TREE_CODE (arg) == STRING_CST)
6239 /* Finally, we have the class name. */
6240 return get_identifier (TREE_STRING_POINTER (arg));
6245 /* If we are currently building a message expr, this holds
6246 the identifier of the selector of the message. This is
6247 used when printing warnings about argument mismatches. */
6249 static tree current_objc_message_selector = 0;
6252 objc_message_selector (void)
6254 return current_objc_message_selector;
6257 /* Construct an expression for sending a message.
6258 MESS has the object to send to in TREE_PURPOSE
6259 and the argument list (including selector) in TREE_VALUE.
6261 (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
6262 (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */
6265 objc_build_message_expr (tree mess)
6267 tree receiver = TREE_PURPOSE (mess);
6270 tree args = TREE_PURPOSE (TREE_VALUE (mess));
6272 tree args = TREE_VALUE (mess);
6274 tree method_params = NULL_TREE;
6276 if (TREE_CODE (receiver) == ERROR_MARK || TREE_CODE (args) == ERROR_MARK)
6277 return error_mark_node;
6279 /* Obtain the full selector name. */
6280 if (TREE_CODE (args) == IDENTIFIER_NODE)
6281 /* A unary selector. */
6283 else if (TREE_CODE (args) == TREE_LIST)
6284 sel_name = build_keyword_selector (args);
6288 /* Build the parameter list to give to the method. */
6289 if (TREE_CODE (args) == TREE_LIST)
6291 method_params = chainon (args, TREE_VALUE (TREE_VALUE (mess)));
6294 tree chain = args, prev = NULL_TREE;
6296 /* We have a keyword selector--check for comma expressions. */
6299 tree element = TREE_VALUE (chain);
6301 /* We have a comma expression, must collapse... */
6302 if (TREE_CODE (element) == TREE_LIST)
6305 TREE_CHAIN (prev) = element;
6310 chain = TREE_CHAIN (chain);
6312 method_params = args;
6317 if (processing_template_decl)
6318 /* Must wait until template instantiation time. */
6319 return build_min_nt (MESSAGE_SEND_EXPR, receiver, sel_name,
6323 return objc_finish_message_expr (receiver, sel_name, method_params);
6326 /* Look up method SEL_NAME that would be suitable for receiver
6327 of type 'id' (if IS_CLASS is zero) or 'Class' (if IS_CLASS is
6328 nonzero), and report on any duplicates. */
6331 lookup_method_in_hash_lists (tree sel_name, int is_class)
6333 hash method_prototype = NULL;
6336 method_prototype = hash_lookup (nst_method_hash_list,
6339 if (!method_prototype)
6341 method_prototype = hash_lookup (cls_method_hash_list,
6346 return check_duplicates (method_prototype, 1, is_class);
6349 /* The 'objc_finish_message_expr' routine is called from within
6350 'objc_build_message_expr' for non-template functions. In the case of
6351 C++ template functions, it is called from 'build_expr_from_tree'
6352 (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded. */
6355 objc_finish_message_expr (tree receiver, tree sel_name, tree method_params)
6357 tree method_prototype = NULL_TREE, rprotos = NULL_TREE, rtype;
6358 tree selector, retval, class_tree;
6359 int self, super, have_cast;
6361 /* Extract the receiver of the message, as well as its type
6362 (where the latter may take the form of a cast or be inferred
6363 from the implementation context). */
6365 while (TREE_CODE (rtype) == COMPOUND_EXPR
6366 || TREE_CODE (rtype) == MODIFY_EXPR
6367 || CONVERT_EXPR_P (rtype)
6368 || TREE_CODE (rtype) == COMPONENT_REF)
6369 rtype = TREE_OPERAND (rtype, 0);
6370 self = (rtype == self_decl);
6371 super = (rtype == UOBJC_SUPER_decl);
6372 rtype = TREE_TYPE (receiver);
6373 have_cast = (TREE_CODE (receiver) == NOP_EXPR
6374 || (TREE_CODE (receiver) == COMPOUND_EXPR
6375 && !IS_SUPER (rtype)));
6377 /* If we are calling [super dealloc], reset our warning flag. */
6378 if (super && !strcmp ("dealloc", IDENTIFIER_POINTER (sel_name)))
6379 should_call_super_dealloc = 0;
6381 /* If the receiver is a class object, retrieve the corresponding
6382 @interface, if one exists. */
6383 class_tree = receiver_is_class_object (receiver, self, super);
6385 /* Now determine the receiver type (if an explicit cast has not been
6390 rtype = lookup_interface (class_tree);
6391 /* Handle `self' and `super'. */
6394 if (!CLASS_SUPER_NAME (implementation_template))
6396 error ("no super class declared in @interface for %qE",
6397 CLASS_NAME (implementation_template));
6398 return error_mark_node;
6400 rtype = lookup_interface (CLASS_SUPER_NAME (implementation_template));
6403 rtype = lookup_interface (CLASS_NAME (implementation_template));
6406 /* If receiver is of type `id' or `Class' (or if the @interface for a
6407 class is not visible), we shall be satisfied with the existence of
6408 any instance or class method. */
6409 if (objc_is_id (rtype))
6411 class_tree = (IS_CLASS (rtype) ? objc_class_name : NULL_TREE);
6412 rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))
6413 ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype))
6419 /* If messaging 'id <Protos>' or 'Class <Proto>', first search
6420 in protocols themselves for the method prototype. */
6422 = lookup_method_in_protocol_list (rprotos, sel_name,
6423 class_tree != NULL_TREE);
6425 /* If messaging 'Class <Proto>' but did not find a class method
6426 prototype, search for an instance method instead, and warn
6427 about having done so. */
6428 if (!method_prototype && !rtype && class_tree != NULL_TREE)
6431 = lookup_method_in_protocol_list (rprotos, sel_name, 0);
6433 if (method_prototype)
6434 warning (0, "found %<-%E%> instead of %<+%E%> in protocol(s)",
6435 sel_name, sel_name);
6441 tree orig_rtype = rtype;
6443 if (TREE_CODE (rtype) == POINTER_TYPE)
6444 rtype = TREE_TYPE (rtype);
6445 /* Traverse typedef aliases */
6446 while (TREE_CODE (rtype) == RECORD_TYPE && OBJC_TYPE_NAME (rtype)
6447 && TREE_CODE (OBJC_TYPE_NAME (rtype)) == TYPE_DECL
6448 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype)))
6449 rtype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype));
6450 if (TYPED_OBJECT (rtype))
6452 rprotos = TYPE_OBJC_PROTOCOL_LIST (rtype);
6453 rtype = TYPE_OBJC_INTERFACE (rtype);
6455 /* If we could not find an @interface declaration, we must have
6456 only seen a @class declaration; so, we cannot say anything
6457 more intelligent about which methods the receiver will
6459 if (!rtype || TREE_CODE (rtype) == IDENTIFIER_NODE)
6461 else if (TREE_CODE (rtype) == CLASS_INTERFACE_TYPE
6462 || TREE_CODE (rtype) == CLASS_IMPLEMENTATION_TYPE)
6464 /* We have a valid ObjC class name. Look up the method name
6465 in the published @interface for the class (and its
6468 = lookup_method_static (rtype, sel_name, class_tree != NULL_TREE);
6470 /* If the method was not found in the @interface, it may still
6471 exist locally as part of the @implementation. */
6472 if (!method_prototype && objc_implementation_context
6473 && CLASS_NAME (objc_implementation_context)
6474 == OBJC_TYPE_NAME (rtype))
6478 ? CLASS_CLS_METHODS (objc_implementation_context)
6479 : CLASS_NST_METHODS (objc_implementation_context)),
6482 /* If we haven't found a candidate method by now, try looking for
6483 it in the protocol list. */
6484 if (!method_prototype && rprotos)
6486 = lookup_method_in_protocol_list (rprotos, sel_name,
6487 class_tree != NULL_TREE);
6491 warning (0, "invalid receiver type %qs",
6492 identifier_to_locale (gen_type_name (orig_rtype)));
6493 /* After issuing the "invalid receiver" warning, perform method
6494 lookup as if we were messaging 'id'. */
6495 rtype = rprotos = NULL_TREE;
6500 /* For 'id' or 'Class' receivers, search in the global hash table
6501 as a last resort. For all receivers, warn if protocol searches
6503 if (!method_prototype)
6506 warning (0, "%<%c%E%> not found in protocol(s)",
6507 (class_tree ? '+' : '-'),
6512 = lookup_method_in_hash_lists (sel_name, class_tree != NULL_TREE);
6515 if (!method_prototype)
6517 static bool warn_missing_methods = false;
6520 warning (0, "%qE may not respond to %<%c%E%>",
6521 OBJC_TYPE_NAME (rtype),
6522 (class_tree ? '+' : '-'),
6524 /* If we are messaging an 'id' or 'Class' object and made it here,
6525 then we have failed to find _any_ instance or class method,
6528 warning (0, "no %<%c%E%> method found",
6529 (class_tree ? '+' : '-'),
6532 if (!warn_missing_methods)
6534 warning_at (input_location,
6535 0, "(Messages without a matching method signature");
6536 warning_at (input_location,
6537 0, "will be assumed to return %<id%> and accept");
6538 warning_at (input_location,
6539 0, "%<...%> as arguments.)");
6540 warn_missing_methods = true;
6544 /* Save the selector name for printing error messages. */
6545 current_objc_message_selector = sel_name;
6547 /* Build the parameters list for looking up the method.
6548 These are the object itself and the selector. */
6550 if (flag_typed_selectors)
6551 selector = build_typed_selector_reference (input_location,
6552 sel_name, method_prototype);
6554 selector = build_selector_reference (input_location, sel_name);
6556 retval = build_objc_method_call (input_location, super, method_prototype,
6558 selector, method_params);
6560 current_objc_message_selector = 0;
6565 /* Build a tree expression to send OBJECT the operation SELECTOR,
6566 looking up the method on object LOOKUP_OBJECT (often same as OBJECT),
6567 assuming the method has prototype METHOD_PROTOTYPE.
6568 (That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.)
6569 LOC is the location of the expression to build.
6570 Use METHOD_PARAMS as list of args to pass to the method.
6571 If SUPER_FLAG is nonzero, we look up the superclass's method. */
6574 build_objc_method_call (location_t loc, int super_flag, tree method_prototype,
6575 tree lookup_object, tree selector,
6578 tree sender = (super_flag ? umsg_super_decl :
6579 (!flag_next_runtime || flag_nil_receivers
6580 ? (flag_objc_direct_dispatch
6583 : umsg_nonnil_decl));
6584 tree rcv_p = (super_flag ? objc_super_type : objc_object_type);
6586 /* If a prototype for the method to be called exists, then cast
6587 the sender's return type and arguments to match that of the method.
6588 Otherwise, leave sender as is. */
6591 ? TREE_VALUE (TREE_TYPE (method_prototype))
6592 : objc_object_type);
6594 = build_pointer_type
6595 (build_function_type
6598 (method_prototype, METHOD_REF, super_flag)));
6601 lookup_object = build_c_cast (loc, rcv_p, lookup_object);
6603 /* Use SAVE_EXPR to avoid evaluating the receiver twice. */
6604 lookup_object = save_expr (lookup_object);
6606 if (flag_next_runtime)
6608 /* If we are returning a struct in memory, and the address
6609 of that memory location is passed as a hidden first
6610 argument, then change which messenger entry point this
6611 expr will call. NB: Note that sender_cast remains
6612 unchanged (it already has a struct return type). */
6613 if (!targetm.calls.struct_value_rtx (0, 0)
6614 && (TREE_CODE (ret_type) == RECORD_TYPE
6615 || TREE_CODE (ret_type) == UNION_TYPE)
6616 && targetm.calls.return_in_memory (ret_type, 0))
6617 sender = (super_flag ? umsg_super_stret_decl :
6618 flag_nil_receivers ? umsg_stret_decl : umsg_nonnil_stret_decl);
6620 method_params = tree_cons (NULL_TREE, lookup_object,
6621 tree_cons (NULL_TREE, selector,
6623 method = build_fold_addr_expr_loc (input_location, sender);
6627 /* This is the portable (GNU) way. */
6630 /* First, call the lookup function to get a pointer to the method,
6631 then cast the pointer, then call it with the method arguments. */
6633 object = (super_flag ? self_decl : lookup_object);
6635 t = tree_cons (NULL_TREE, selector, NULL_TREE);
6636 t = tree_cons (NULL_TREE, lookup_object, t);
6637 method = build_function_call (loc, sender, t);
6639 /* Pass the object to the method. */
6640 method_params = tree_cons (NULL_TREE, object,
6641 tree_cons (NULL_TREE, selector,
6645 /* ??? Selector is not at this point something we can use inside
6646 the compiler itself. Set it to garbage for the nonce. */
6647 t = build3 (OBJ_TYPE_REF, sender_cast, method, lookup_object, size_zero_node);
6648 return build_function_call (loc,
6653 build_protocol_reference (tree p)
6656 const char *proto_name;
6658 /* static struct _objc_protocol _OBJC_PROTOCOL_<mumble>; */
6660 proto_name = synth_id_with_class_suffix ("_OBJC_PROTOCOL", p);
6661 decl = start_var_decl (objc_protocol_template, proto_name);
6663 PROTOCOL_FORWARD_DECL (p) = decl;
6666 /* This function is called by the parser when (and only when) a
6667 @protocol() expression is found, in order to compile it. */
6669 objc_build_protocol_expr (tree protoname)
6672 tree p = lookup_protocol (protoname);
6676 error ("cannot find protocol declaration for %qE",
6678 return error_mark_node;
6681 if (!PROTOCOL_FORWARD_DECL (p))
6682 build_protocol_reference (p);
6684 expr = build_unary_op (input_location,
6685 ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
6687 /* ??? Ideally we'd build the reference with objc_protocol_type directly,
6688 if we have it, rather than converting it here. */
6689 expr = convert (objc_protocol_type, expr);
6691 /* The @protocol() expression is being compiled into a pointer to a
6692 statically allocated instance of the Protocol class. To become
6693 usable at runtime, the 'isa' pointer of the instance need to be
6694 fixed up at runtime by the runtime library, to point to the
6695 actual 'Protocol' class. */
6697 /* For the GNU runtime, put the static Protocol instance in the list
6698 of statically allocated instances, so that we make sure that its
6699 'isa' pointer is fixed up at runtime by the GNU runtime library
6700 to point to the Protocol class (at runtime, when loading the
6701 module, the GNU runtime library loops on the statically allocated
6702 instances (as found in the defs field in objc_symtab) and fixups
6703 all the 'isa' pointers of those objects). */
6704 if (! flag_next_runtime)
6706 /* This type is a struct containing the fields of a Protocol
6707 object. (Cfr. objc_protocol_type instead is the type of a pointer
6708 to such a struct). */
6709 tree protocol_struct_type = xref_tag
6710 (RECORD_TYPE, get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
6713 /* Look for the list of Protocol statically allocated instances
6714 to fixup at runtime. Create a new list to hold Protocol
6715 statically allocated instances, if the list is not found. At
6716 present there is only another list, holding NSConstantString
6717 static instances to be fixed up at runtime. */
6718 for (chain = &objc_static_instances;
6719 *chain && TREE_VALUE (*chain) != protocol_struct_type;
6720 chain = &TREE_CHAIN (*chain));
6723 *chain = tree_cons (NULL_TREE, protocol_struct_type, NULL_TREE);
6724 add_objc_string (OBJC_TYPE_NAME (protocol_struct_type),
6728 /* Add this statically allocated instance to the Protocol list. */
6729 TREE_PURPOSE (*chain) = tree_cons (NULL_TREE,
6730 PROTOCOL_FORWARD_DECL (p),
6731 TREE_PURPOSE (*chain));
6738 /* This function is called by the parser when a @selector() expression
6739 is found, in order to compile it. It is only called by the parser
6740 and only to compile a @selector(). LOC is the location of the
6743 objc_build_selector_expr (location_t loc, tree selnamelist)
6747 /* Obtain the full selector name. */
6748 if (TREE_CODE (selnamelist) == IDENTIFIER_NODE)
6749 /* A unary selector. */
6750 selname = selnamelist;
6751 else if (TREE_CODE (selnamelist) == TREE_LIST)
6752 selname = build_keyword_selector (selnamelist);
6756 /* If we are required to check @selector() expressions as they
6757 are found, check that the selector has been declared. */
6758 if (warn_undeclared_selector)
6760 /* Look the selector up in the list of all known class and
6761 instance methods (up to this line) to check that the selector
6765 /* First try with instance methods. */
6766 hsh = hash_lookup (nst_method_hash_list, selname);
6768 /* If not found, try with class methods. */
6771 hsh = hash_lookup (cls_method_hash_list, selname);
6774 /* If still not found, print out a warning. */
6777 warning (0, "undeclared selector %qE", selname);
6782 if (flag_typed_selectors)
6783 return build_typed_selector_reference (loc, selname, 0);
6785 return build_selector_reference (loc, selname);
6789 objc_build_encode_expr (tree type)
6794 encode_type (type, obstack_object_size (&util_obstack),
6795 OBJC_ENCODE_INLINE_DEFS);
6796 obstack_1grow (&util_obstack, 0); /* null terminate string */
6797 string = XOBFINISH (&util_obstack, const char *);
6799 /* Synthesize a string that represents the encoded struct/union. */
6800 result = my_build_string (strlen (string) + 1, string);
6801 obstack_free (&util_obstack, util_firstobj);
6806 build_ivar_reference (tree id)
6808 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
6810 /* Historically, a class method that produced objects (factory
6811 method) would assign `self' to the instance that it
6812 allocated. This would effectively turn the class method into
6813 an instance method. Following this assignment, the instance
6814 variables could be accessed. That practice, while safe,
6815 violates the simple rule that a class method should not refer
6816 to an instance variable. It's better to catch the cases
6817 where this is done unknowingly than to support the above
6819 warning (0, "instance variable %qE accessed in class method",
6821 self_decl = convert (objc_instance_type, self_decl); /* cast */
6824 return objc_build_component_ref (build_indirect_ref (input_location,
6825 self_decl, RO_ARROW),
6829 /* Compute a hash value for a given method SEL_NAME. */
6832 hash_func (tree sel_name)
6834 const unsigned char *s
6835 = (const unsigned char *)IDENTIFIER_POINTER (sel_name);
6839 h = h * 67 + *s++ - 113;
6846 nst_method_hash_list
6847 = (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
6848 cls_method_hash_list
6849 = (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
6851 /* Initialize the hash table used to hold the constant string objects. */
6852 string_htab = htab_create_ggc (31, string_hash,
6855 /* Initialize the hash table used to hold EH-volatilized types. */
6856 volatilized_htab = htab_create_ggc (31, volatilized_hash,
6857 volatilized_eq, NULL);
6860 /* WARNING!!!! hash_enter is called with a method, and will peek
6861 inside to find its selector! But hash_lookup is given a selector
6862 directly, and looks for the selector that's inside the found
6863 entry's key (method) for comparison. */
6866 hash_enter (hash *hashlist, tree method)
6869 int slot = hash_func (METHOD_SEL_NAME (method)) % SIZEHASHTABLE;
6871 obj = (hash) ggc_alloc (sizeof (struct hashed_entry));
6873 obj->next = hashlist[slot];
6876 hashlist[slot] = obj; /* append to front */
6880 hash_lookup (hash *hashlist, tree sel_name)
6884 target = hashlist[hash_func (sel_name) % SIZEHASHTABLE];
6888 if (sel_name == METHOD_SEL_NAME (target->key))
6891 target = target->next;
6897 hash_add_attr (hash entry, tree value)
6901 obj = (attr) ggc_alloc (sizeof (struct hashed_attribute));
6902 obj->next = entry->list;
6905 entry->list = obj; /* append to front */
6909 lookup_method (tree mchain, tree method)
6913 if (TREE_CODE (method) == IDENTIFIER_NODE)
6916 key = METHOD_SEL_NAME (method);
6920 if (METHOD_SEL_NAME (mchain) == key)
6923 mchain = TREE_CHAIN (mchain);
6928 /* Look up a class (if OBJC_LOOKUP_CLASS is set in FLAGS) or instance method
6929 in INTERFACE, along with any categories and protocols attached thereto.
6930 If method is not found, and the OBJC_LOOKUP_NO_SUPER is _not_ set in FLAGS,
6931 recursively examine the INTERFACE's superclass. If OBJC_LOOKUP_CLASS is
6932 set, OBJC_LOOKUP_NO_SUPER is cleared, and no suitable class method could
6933 be found in INTERFACE or any of its superclasses, look for an _instance_
6934 method of the same name in the root class as a last resort.
6936 If a suitable method cannot be found, return NULL_TREE. */
6939 lookup_method_static (tree interface, tree ident, int flags)
6941 tree meth = NULL_TREE, root_inter = NULL_TREE;
6942 tree inter = interface;
6943 int is_class = (flags & OBJC_LOOKUP_CLASS);
6944 int no_superclasses = (flags & OBJC_LOOKUP_NO_SUPER);
6948 tree chain = is_class ? CLASS_CLS_METHODS (inter) : CLASS_NST_METHODS (inter);
6949 tree category = inter;
6951 /* First, look up the method in the class itself. */
6952 if ((meth = lookup_method (chain, ident)))
6955 /* Failing that, look for the method in each category of the class. */
6956 while ((category = CLASS_CATEGORY_LIST (category)))
6958 chain = is_class ? CLASS_CLS_METHODS (category) : CLASS_NST_METHODS (category);
6960 /* Check directly in each category. */
6961 if ((meth = lookup_method (chain, ident)))
6964 /* Failing that, check in each category's protocols. */
6965 if (CLASS_PROTOCOL_LIST (category))
6967 if ((meth = (lookup_method_in_protocol_list
6968 (CLASS_PROTOCOL_LIST (category), ident, is_class))))
6973 /* If not found in categories, check in protocols of the main class. */
6974 if (CLASS_PROTOCOL_LIST (inter))
6976 if ((meth = (lookup_method_in_protocol_list
6977 (CLASS_PROTOCOL_LIST (inter), ident, is_class))))
6981 /* If we were instructed not to look in superclasses, don't. */
6982 if (no_superclasses)
6985 /* Failing that, climb up the inheritance hierarchy. */
6987 inter = lookup_interface (CLASS_SUPER_NAME (inter));
6991 /* If no class (factory) method was found, check if an _instance_
6992 method of the same name exists in the root class. This is what
6993 the Objective-C runtime will do. If an instance method was not
6995 return is_class ? lookup_method_static (root_inter, ident, 0): NULL_TREE;
6998 /* Add the method to the hash list if it doesn't contain an identical
7002 add_method_to_hash_list (hash *hash_list, tree method)
7006 if (!(hsh = hash_lookup (hash_list, METHOD_SEL_NAME (method))))
7008 /* Install on a global chain. */
7009 hash_enter (hash_list, method);
7013 /* Check types against those; if different, add to a list. */
7015 int already_there = comp_proto_with_proto (method, hsh->key, 1);
7016 for (loop = hsh->list; !already_there && loop; loop = loop->next)
7017 already_there |= comp_proto_with_proto (method, loop->value, 1);
7019 hash_add_attr (hsh, method);
7024 objc_add_method (tree klass, tree method, int is_class)
7028 if (!(mth = lookup_method (is_class
7029 ? CLASS_CLS_METHODS (klass)
7030 : CLASS_NST_METHODS (klass), method)))
7032 /* put method on list in reverse order */
7035 TREE_CHAIN (method) = CLASS_CLS_METHODS (klass);
7036 CLASS_CLS_METHODS (klass) = method;
7040 TREE_CHAIN (method) = CLASS_NST_METHODS (klass);
7041 CLASS_NST_METHODS (klass) = method;
7046 /* When processing an @interface for a class or category, give hard
7047 errors on methods with identical selectors but differing argument
7048 and/or return types. We do not do this for @implementations, because
7049 C/C++ will do it for us (i.e., there will be duplicate function
7050 definition errors). */
7051 if ((TREE_CODE (klass) == CLASS_INTERFACE_TYPE
7052 || TREE_CODE (klass) == CATEGORY_INTERFACE_TYPE)
7053 && !comp_proto_with_proto (method, mth, 1))
7054 error ("duplicate declaration of method %<%c%E%>",
7055 is_class ? '+' : '-',
7056 METHOD_SEL_NAME (mth));
7060 add_method_to_hash_list (cls_method_hash_list, method);
7063 add_method_to_hash_list (nst_method_hash_list, method);
7065 /* Instance methods in root classes (and categories thereof)
7066 may act as class methods as a last resort. We also add
7067 instance methods listed in @protocol declarations to
7068 the class hash table, on the assumption that @protocols
7069 may be adopted by root classes or categories. */
7070 if (TREE_CODE (klass) == CATEGORY_INTERFACE_TYPE
7071 || TREE_CODE (klass) == CATEGORY_IMPLEMENTATION_TYPE)
7072 klass = lookup_interface (CLASS_NAME (klass));
7074 if (TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE
7075 || !CLASS_SUPER_NAME (klass))
7076 add_method_to_hash_list (cls_method_hash_list, method);
7083 add_class (tree class_name, tree name)
7085 struct interface_tuple **slot;
7087 /* Put interfaces on list in reverse order. */
7088 TREE_CHAIN (class_name) = interface_chain;
7089 interface_chain = class_name;
7091 if (interface_htab == NULL)
7092 interface_htab = htab_create_ggc (31, hash_interface, eq_interface, NULL);
7093 slot = (struct interface_tuple **)
7094 htab_find_slot_with_hash (interface_htab, name,
7095 IDENTIFIER_HASH_VALUE (name),
7099 *slot = (struct interface_tuple *) ggc_alloc_cleared (sizeof (struct interface_tuple));
7102 (*slot)->class_name = class_name;
7104 return interface_chain;
7108 add_category (tree klass, tree category)
7110 /* Put categories on list in reverse order. */
7111 tree cat = lookup_category (klass, CLASS_SUPER_NAME (category));
7115 warning (0, "duplicate interface declaration for category %<%E(%E)%>",
7117 CLASS_SUPER_NAME (category));
7121 CLASS_CATEGORY_LIST (category) = CLASS_CATEGORY_LIST (klass);
7122 CLASS_CATEGORY_LIST (klass) = category;
7126 /* Called after parsing each instance variable declaration. Necessary to
7127 preserve typedefs and implement public/private...
7129 VISIBILITY is 1 for public, 0 for protected, and 2 for private. */
7132 add_instance_variable (tree klass, int visibility, tree field_decl)
7134 tree field_type = TREE_TYPE (field_decl);
7135 const char *ivar_name = DECL_NAME (field_decl)
7136 ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (field_decl)))
7140 if (TREE_CODE (field_type) == REFERENCE_TYPE)
7142 error ("illegal reference type specified for instance variable %qs",
7144 /* Return class as is without adding this ivar. */
7149 if (field_type == error_mark_node || !TYPE_SIZE (field_type)
7150 || TYPE_SIZE (field_type) == error_mark_node)
7151 /* 'type[0]' is allowed, but 'type[]' is not! */
7153 error ("instance variable %qs has unknown size", ivar_name);
7154 /* Return class as is without adding this ivar. */
7159 /* Check if the ivar being added has a non-POD C++ type. If so, we will
7160 need to either (1) warn the user about it or (2) generate suitable
7161 constructor/destructor call from '- .cxx_construct' or '- .cxx_destruct'
7162 methods (if '-fobjc-call-cxx-cdtors' was specified). */
7163 if (MAYBE_CLASS_TYPE_P (field_type)
7164 && (TYPE_NEEDS_CONSTRUCTING (field_type)
7165 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type)
7166 || TYPE_POLYMORPHIC_P (field_type)))
7168 tree type_name = OBJC_TYPE_NAME (field_type);
7170 if (flag_objc_call_cxx_cdtors)
7172 /* Since the ObjC runtime will be calling the constructors and
7173 destructors for us, the only thing we can't handle is the lack
7174 of a default constructor. */
7175 if (TYPE_NEEDS_CONSTRUCTING (field_type)
7176 && !TYPE_HAS_DEFAULT_CONSTRUCTOR (field_type))
7178 warning (0, "type %qE has no default constructor to call",
7181 /* If we cannot call a constructor, we should also avoid
7182 calling the destructor, for symmetry. */
7183 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type))
7184 warning (0, "destructor for %qE shall not be run either",
7190 static bool warn_cxx_ivars = false;
7192 if (TYPE_POLYMORPHIC_P (field_type))
7194 /* Vtable pointers are Real Bad(tm), since Obj-C cannot
7196 error ("type %qE has virtual member functions", type_name);
7197 error ("illegal aggregate type %qE specified "
7198 "for instance variable %qs",
7199 type_name, ivar_name);
7200 /* Return class as is without adding this ivar. */
7204 /* User-defined constructors and destructors are not known to Obj-C
7205 and hence will not be called. This may or may not be a problem. */
7206 if (TYPE_NEEDS_CONSTRUCTING (field_type))
7207 warning (0, "type %qE has a user-defined constructor", type_name);
7208 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type))
7209 warning (0, "type %qE has a user-defined destructor", type_name);
7211 if (!warn_cxx_ivars)
7213 warning (0, "C++ constructors and destructors will not "
7214 "be invoked for Objective-C fields");
7215 warn_cxx_ivars = true;
7221 /* Overload the public attribute, it is not used for FIELD_DECLs. */
7225 TREE_PUBLIC (field_decl) = 0;
7226 TREE_PRIVATE (field_decl) = 0;
7227 TREE_PROTECTED (field_decl) = 1;
7231 TREE_PUBLIC (field_decl) = 1;
7232 TREE_PRIVATE (field_decl) = 0;
7233 TREE_PROTECTED (field_decl) = 0;
7237 TREE_PUBLIC (field_decl) = 0;
7238 TREE_PRIVATE (field_decl) = 1;
7239 TREE_PROTECTED (field_decl) = 0;
7244 CLASS_RAW_IVARS (klass) = chainon (CLASS_RAW_IVARS (klass), field_decl);
7250 is_ivar (tree decl_chain, tree ident)
7252 for ( ; decl_chain; decl_chain = TREE_CHAIN (decl_chain))
7253 if (DECL_NAME (decl_chain) == ident)
7258 /* True if the ivar is private and we are not in its implementation. */
7261 is_private (tree decl)
7263 return (TREE_PRIVATE (decl)
7264 && ! is_ivar (CLASS_IVARS (implementation_template),
7268 /* We have an instance variable reference;, check to see if it is public. */
7271 objc_is_public (tree expr, tree identifier)
7273 tree basetype, decl;
7276 if (processing_template_decl)
7280 if (TREE_TYPE (expr) == error_mark_node)
7283 basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
7285 if (basetype && TREE_CODE (basetype) == RECORD_TYPE)
7287 if (TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype))
7289 tree klass = lookup_interface (OBJC_TYPE_NAME (basetype));
7293 error ("cannot find interface declaration for %qE",
7294 OBJC_TYPE_NAME (basetype));
7298 if ((decl = is_ivar (get_class_ivars (klass, true), identifier)))
7300 if (TREE_PUBLIC (decl))
7303 /* Important difference between the Stepstone translator:
7304 all instance variables should be public within the context
7305 of the implementation. */
7306 if (objc_implementation_context
7307 && ((TREE_CODE (objc_implementation_context)
7308 == CLASS_IMPLEMENTATION_TYPE)
7309 || (TREE_CODE (objc_implementation_context)
7310 == CATEGORY_IMPLEMENTATION_TYPE)))
7312 tree curtype = TYPE_MAIN_VARIANT
7313 (CLASS_STATIC_TEMPLATE
7314 (implementation_template));
7316 if (basetype == curtype
7317 || DERIVED_FROM_P (basetype, curtype))
7319 int priv = is_private (decl);
7322 error ("instance variable %qE is declared private",
7329 /* The 2.95.2 compiler sometimes allowed C functions to access
7330 non-@public ivars. We will let this slide for now... */
7331 if (!objc_method_context)
7333 warning (0, "instance variable %qE is %s; "
7334 "this will be a hard error in the future",
7336 TREE_PRIVATE (decl) ? "@private" : "@protected");
7340 error ("instance variable %qE is declared %s",
7342 TREE_PRIVATE (decl) ? "private" : "protected");
7351 /* Make sure all entries in CHAIN are also in LIST. */
7354 check_methods (tree chain, tree list, int mtype)
7360 if (!lookup_method (list, chain))
7364 if (TREE_CODE (objc_implementation_context)
7365 == CLASS_IMPLEMENTATION_TYPE)
7366 warning (0, "incomplete implementation of class %qE",
7367 CLASS_NAME (objc_implementation_context));
7368 else if (TREE_CODE (objc_implementation_context)
7369 == CATEGORY_IMPLEMENTATION_TYPE)
7370 warning (0, "incomplete implementation of category %qE",
7371 CLASS_SUPER_NAME (objc_implementation_context));
7375 warning (0, "method definition for %<%c%E%> not found",
7376 mtype, METHOD_SEL_NAME (chain));
7379 chain = TREE_CHAIN (chain);
7385 /* Check if KLASS, or its superclasses, explicitly conforms to PROTOCOL. */
7388 conforms_to_protocol (tree klass, tree protocol)
7390 if (TREE_CODE (protocol) == PROTOCOL_INTERFACE_TYPE)
7392 tree p = CLASS_PROTOCOL_LIST (klass);
7393 while (p && TREE_VALUE (p) != protocol)
7398 tree super = (CLASS_SUPER_NAME (klass)
7399 ? lookup_interface (CLASS_SUPER_NAME (klass))
7401 int tmp = super ? conforms_to_protocol (super, protocol) : 0;
7410 /* Make sure all methods in CHAIN are accessible as MTYPE methods in
7411 CONTEXT. This is one of two mechanisms to check protocol integrity. */
7414 check_methods_accessible (tree chain, tree context, int mtype)
7418 tree base_context = context;
7422 context = base_context;
7426 list = CLASS_CLS_METHODS (context);
7428 list = CLASS_NST_METHODS (context);
7430 if (lookup_method (list, chain))
7433 else if (TREE_CODE (context) == CLASS_IMPLEMENTATION_TYPE
7434 || TREE_CODE (context) == CLASS_INTERFACE_TYPE)
7435 context = (CLASS_SUPER_NAME (context)
7436 ? lookup_interface (CLASS_SUPER_NAME (context))
7439 else if (TREE_CODE (context) == CATEGORY_IMPLEMENTATION_TYPE
7440 || TREE_CODE (context) == CATEGORY_INTERFACE_TYPE)
7441 context = (CLASS_NAME (context)
7442 ? lookup_interface (CLASS_NAME (context))
7448 if (context == NULL_TREE)
7452 if (TREE_CODE (objc_implementation_context)
7453 == CLASS_IMPLEMENTATION_TYPE)
7454 warning (0, "incomplete implementation of class %qE",
7455 CLASS_NAME (objc_implementation_context));
7456 else if (TREE_CODE (objc_implementation_context)
7457 == CATEGORY_IMPLEMENTATION_TYPE)
7458 warning (0, "incomplete implementation of category %qE",
7459 CLASS_SUPER_NAME (objc_implementation_context));
7462 warning (0, "method definition for %<%c%E%> not found",
7463 mtype, METHOD_SEL_NAME (chain));
7466 chain = TREE_CHAIN (chain); /* next method... */
7471 /* Check whether the current interface (accessible via
7472 'objc_implementation_context') actually implements protocol P, along
7473 with any protocols that P inherits. */
7476 check_protocol (tree p, const char *type, tree name)
7478 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
7482 /* Ensure that all protocols have bodies! */
7485 f1 = check_methods (PROTOCOL_CLS_METHODS (p),
7486 CLASS_CLS_METHODS (objc_implementation_context),
7488 f2 = check_methods (PROTOCOL_NST_METHODS (p),
7489 CLASS_NST_METHODS (objc_implementation_context),
7494 f1 = check_methods_accessible (PROTOCOL_CLS_METHODS (p),
7495 objc_implementation_context,
7497 f2 = check_methods_accessible (PROTOCOL_NST_METHODS (p),
7498 objc_implementation_context,
7503 warning (0, "%s %qE does not fully implement the %qE protocol",
7504 type, name, PROTOCOL_NAME (p));
7507 /* Check protocols recursively. */
7508 if (PROTOCOL_LIST (p))
7510 tree subs = PROTOCOL_LIST (p);
7512 lookup_interface (CLASS_SUPER_NAME (implementation_template));
7516 tree sub = TREE_VALUE (subs);
7518 /* If the superclass does not conform to the protocols
7519 inherited by P, then we must! */
7520 if (!super_class || !conforms_to_protocol (super_class, sub))
7521 check_protocol (sub, type, name);
7522 subs = TREE_CHAIN (subs);
7527 /* Check whether the current interface (accessible via
7528 'objc_implementation_context') actually implements the protocols listed
7532 check_protocols (tree proto_list, const char *type, tree name)
7534 for ( ; proto_list; proto_list = TREE_CHAIN (proto_list))
7536 tree p = TREE_VALUE (proto_list);
7538 check_protocol (p, type, name);
7542 /* Make sure that the class CLASS_NAME is defined
7543 CODE says which kind of thing CLASS_NAME ought to be.
7544 It can be CLASS_INTERFACE_TYPE, CLASS_IMPLEMENTATION_TYPE,
7545 CATEGORY_INTERFACE_TYPE, or CATEGORY_IMPLEMENTATION_TYPE. */
7548 start_class (enum tree_code code, tree class_name, tree super_name,
7554 if (current_namespace != global_namespace) {
7555 error ("Objective-C declarations may only appear in global scope");
7557 #endif /* OBJCPLUS */
7559 if (objc_implementation_context)
7561 warning (0, "%<@end%> missing in implementation context");
7562 finish_class (objc_implementation_context);
7563 objc_ivar_chain = NULL_TREE;
7564 objc_implementation_context = NULL_TREE;
7567 klass = make_node (code);
7568 TYPE_LANG_SLOT_1 (klass) = make_tree_vec (CLASS_LANG_SLOT_ELTS);
7570 /* Check for existence of the super class, if one was specified. Note
7571 that we must have seen an @interface, not just a @class. If we
7572 are looking at a @compatibility_alias, traverse it first. */
7573 if ((code == CLASS_INTERFACE_TYPE || code == CLASS_IMPLEMENTATION_TYPE)
7576 tree super = objc_is_class_name (super_name);
7578 if (!super || !lookup_interface (super))
7580 error ("cannot find interface declaration for %qE, superclass of %qE",
7581 super ? super : super_name,
7583 super_name = NULL_TREE;
7589 CLASS_NAME (klass) = class_name;
7590 CLASS_SUPER_NAME (klass) = super_name;
7591 CLASS_CLS_METHODS (klass) = NULL_TREE;
7593 if (! objc_is_class_name (class_name)
7594 && (decl = lookup_name (class_name)))
7596 error ("%qE redeclared as different kind of symbol",
7598 error ("previous declaration of %q+D",
7602 if (code == CLASS_IMPLEMENTATION_TYPE)
7607 for (chain = implemented_classes; chain; chain = TREE_CHAIN (chain))
7608 if (TREE_VALUE (chain) == class_name)
7610 error ("reimplementation of class %qE",
7612 return error_mark_node;
7614 implemented_classes = tree_cons (NULL_TREE, class_name,
7615 implemented_classes);
7618 /* Reset for multiple classes per file. */
7621 objc_implementation_context = klass;
7623 /* Lookup the interface for this implementation. */
7625 if (!(implementation_template = lookup_interface (class_name)))
7627 warning (0, "cannot find interface declaration for %qE",
7629 add_class (implementation_template = objc_implementation_context,
7633 /* If a super class has been specified in the implementation,
7634 insure it conforms to the one specified in the interface. */
7637 && (super_name != CLASS_SUPER_NAME (implementation_template)))
7639 tree previous_name = CLASS_SUPER_NAME (implementation_template);
7640 error ("conflicting super class name %qE",
7643 error ("previous declaration of %qE", previous_name);
7645 error ("previous declaration");
7648 else if (! super_name)
7650 CLASS_SUPER_NAME (objc_implementation_context)
7651 = CLASS_SUPER_NAME (implementation_template);
7655 else if (code == CLASS_INTERFACE_TYPE)
7657 if (lookup_interface (class_name))
7659 error ("duplicate interface declaration for class %qE",
7661 warning (0, "duplicate interface declaration for class %qE",
7665 add_class (klass, class_name);
7668 CLASS_PROTOCOL_LIST (klass)
7669 = lookup_and_install_protocols (protocol_list);
7672 else if (code == CATEGORY_INTERFACE_TYPE)
7674 tree class_category_is_assoc_with;
7676 /* For a category, class_name is really the name of the class that
7677 the following set of methods will be associated with. We must
7678 find the interface so that can derive the objects template. */
7680 if (!(class_category_is_assoc_with = lookup_interface (class_name)))
7682 error ("cannot find interface declaration for %qE",
7684 exit (FATAL_EXIT_CODE);
7687 add_category (class_category_is_assoc_with, klass);
7690 CLASS_PROTOCOL_LIST (klass)
7691 = lookup_and_install_protocols (protocol_list);
7694 else if (code == CATEGORY_IMPLEMENTATION_TYPE)
7696 /* Reset for multiple classes per file. */
7699 objc_implementation_context = klass;
7701 /* For a category, class_name is really the name of the class that
7702 the following set of methods will be associated with. We must
7703 find the interface so that can derive the objects template. */
7705 if (!(implementation_template = lookup_interface (class_name)))
7707 error ("cannot find interface declaration for %qE",
7709 exit (FATAL_EXIT_CODE);
7716 continue_class (tree klass)
7718 if (TREE_CODE (klass) == CLASS_IMPLEMENTATION_TYPE
7719 || TREE_CODE (klass) == CATEGORY_IMPLEMENTATION_TYPE)
7721 struct imp_entry *imp_entry;
7723 /* Check consistency of the instance variables. */
7725 if (CLASS_RAW_IVARS (klass))
7726 check_ivars (implementation_template, klass);
7728 /* code generation */
7731 push_lang_context (lang_name_c);
7734 build_private_template (implementation_template);
7735 uprivate_record = CLASS_STATIC_TEMPLATE (implementation_template);
7736 objc_instance_type = build_pointer_type (uprivate_record);
7738 imp_entry = (struct imp_entry *) ggc_alloc (sizeof (struct imp_entry));
7740 imp_entry->next = imp_list;
7741 imp_entry->imp_context = klass;
7742 imp_entry->imp_template = implementation_template;
7744 synth_forward_declarations ();
7745 imp_entry->class_decl = UOBJC_CLASS_decl;
7746 imp_entry->meta_decl = UOBJC_METACLASS_decl;
7747 imp_entry->has_cxx_cdtors = 0;
7749 /* Append to front and increment count. */
7750 imp_list = imp_entry;
7751 if (TREE_CODE (klass) == CLASS_IMPLEMENTATION_TYPE)
7757 pop_lang_context ();
7758 #endif /* OBJCPLUS */
7760 return get_class_ivars (implementation_template, true);
7763 else if (TREE_CODE (klass) == CLASS_INTERFACE_TYPE)
7766 push_lang_context (lang_name_c);
7767 #endif /* OBJCPLUS */
7769 build_private_template (klass);
7772 pop_lang_context ();
7773 #endif /* OBJCPLUS */
7779 return error_mark_node;
7782 /* This is called once we see the "@end" in an interface/implementation. */
7785 finish_class (tree klass)
7787 if (TREE_CODE (klass) == CLASS_IMPLEMENTATION_TYPE)
7789 /* All code generation is done in finish_objc. */
7791 if (implementation_template != objc_implementation_context)
7793 /* Ensure that all method listed in the interface contain bodies. */
7794 check_methods (CLASS_CLS_METHODS (implementation_template),
7795 CLASS_CLS_METHODS (objc_implementation_context), '+');
7796 check_methods (CLASS_NST_METHODS (implementation_template),
7797 CLASS_NST_METHODS (objc_implementation_context), '-');
7799 if (CLASS_PROTOCOL_LIST (implementation_template))
7800 check_protocols (CLASS_PROTOCOL_LIST (implementation_template),
7802 CLASS_NAME (objc_implementation_context));
7806 else if (TREE_CODE (klass) == CATEGORY_IMPLEMENTATION_TYPE)
7808 tree category = lookup_category (implementation_template, CLASS_SUPER_NAME (klass));
7812 /* Ensure all method listed in the interface contain bodies. */
7813 check_methods (CLASS_CLS_METHODS (category),
7814 CLASS_CLS_METHODS (objc_implementation_context), '+');
7815 check_methods (CLASS_NST_METHODS (category),
7816 CLASS_NST_METHODS (objc_implementation_context), '-');
7818 if (CLASS_PROTOCOL_LIST (category))
7819 check_protocols (CLASS_PROTOCOL_LIST (category),
7821 CLASS_SUPER_NAME (objc_implementation_context));
7827 add_protocol (tree protocol)
7829 /* Put protocol on list in reverse order. */
7830 TREE_CHAIN (protocol) = protocol_chain;
7831 protocol_chain = protocol;
7832 return protocol_chain;
7836 lookup_protocol (tree ident)
7840 for (chain = protocol_chain; chain; chain = TREE_CHAIN (chain))
7841 if (ident == PROTOCOL_NAME (chain))
7847 /* This function forward declares the protocols named by NAMES. If
7848 they are already declared or defined, the function has no effect. */
7851 objc_declare_protocols (tree names)
7856 if (current_namespace != global_namespace) {
7857 error ("Objective-C declarations may only appear in global scope");
7859 #endif /* OBJCPLUS */
7861 for (list = names; list; list = TREE_CHAIN (list))
7863 tree name = TREE_VALUE (list);
7865 if (lookup_protocol (name) == NULL_TREE)
7867 tree protocol = make_node (PROTOCOL_INTERFACE_TYPE);
7869 TYPE_LANG_SLOT_1 (protocol)
7870 = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS);
7871 PROTOCOL_NAME (protocol) = name;
7872 PROTOCOL_LIST (protocol) = NULL_TREE;
7873 add_protocol (protocol);
7874 PROTOCOL_DEFINED (protocol) = 0;
7875 PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
7881 start_protocol (enum tree_code code, tree name, tree list)
7886 if (current_namespace != global_namespace) {
7887 error ("Objective-C declarations may only appear in global scope");
7889 #endif /* OBJCPLUS */
7891 protocol = lookup_protocol (name);
7895 protocol = make_node (code);
7896 TYPE_LANG_SLOT_1 (protocol) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS);
7898 PROTOCOL_NAME (protocol) = name;
7899 PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list);
7900 add_protocol (protocol);
7901 PROTOCOL_DEFINED (protocol) = 1;
7902 PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
7904 check_protocol_recursively (protocol, list);
7906 else if (! PROTOCOL_DEFINED (protocol))
7908 PROTOCOL_DEFINED (protocol) = 1;
7909 PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list);
7911 check_protocol_recursively (protocol, list);
7915 warning (0, "duplicate declaration for protocol %qE",
7922 /* "Encode" a data type into a string, which grows in util_obstack.
7923 ??? What is the FORMAT? Someone please document this! */
7926 encode_type_qualifiers (tree declspecs)
7930 for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
7932 if (ridpointers[(int) RID_IN] == TREE_VALUE (spec))
7933 obstack_1grow (&util_obstack, 'n');
7934 else if (ridpointers[(int) RID_INOUT] == TREE_VALUE (spec))
7935 obstack_1grow (&util_obstack, 'N');
7936 else if (ridpointers[(int) RID_OUT] == TREE_VALUE (spec))
7937 obstack_1grow (&util_obstack, 'o');
7938 else if (ridpointers[(int) RID_BYCOPY] == TREE_VALUE (spec))
7939 obstack_1grow (&util_obstack, 'O');
7940 else if (ridpointers[(int) RID_BYREF] == TREE_VALUE (spec))
7941 obstack_1grow (&util_obstack, 'R');
7942 else if (ridpointers[(int) RID_ONEWAY] == TREE_VALUE (spec))
7943 obstack_1grow (&util_obstack, 'V');
7947 /* Encode a pointer type. */
7950 encode_pointer (tree type, int curtype, int format)
7952 tree pointer_to = TREE_TYPE (type);
7954 if (TREE_CODE (pointer_to) == RECORD_TYPE)
7956 if (OBJC_TYPE_NAME (pointer_to)
7957 && TREE_CODE (OBJC_TYPE_NAME (pointer_to)) == IDENTIFIER_NODE)
7959 const char *name = IDENTIFIER_POINTER (OBJC_TYPE_NAME (pointer_to));
7961 if (strcmp (name, TAG_OBJECT) == 0) /* '@' */
7963 obstack_1grow (&util_obstack, '@');
7966 else if (TYPE_HAS_OBJC_INFO (pointer_to)
7967 && TYPE_OBJC_INTERFACE (pointer_to))
7969 if (generating_instance_variables)
7971 obstack_1grow (&util_obstack, '@');
7972 obstack_1grow (&util_obstack, '"');
7973 obstack_grow (&util_obstack, name, strlen (name));
7974 obstack_1grow (&util_obstack, '"');
7979 obstack_1grow (&util_obstack, '@');
7983 else if (strcmp (name, TAG_CLASS) == 0) /* '#' */
7985 obstack_1grow (&util_obstack, '#');
7988 else if (strcmp (name, TAG_SELECTOR) == 0) /* ':' */
7990 obstack_1grow (&util_obstack, ':');
7995 else if (TREE_CODE (pointer_to) == INTEGER_TYPE
7996 && TYPE_MODE (pointer_to) == QImode)
7998 tree pname = TREE_CODE (OBJC_TYPE_NAME (pointer_to)) == IDENTIFIER_NODE
7999 ? OBJC_TYPE_NAME (pointer_to)
8000 : DECL_NAME (OBJC_TYPE_NAME (pointer_to));
8002 if (!flag_next_runtime || strcmp (IDENTIFIER_POINTER (pname), "BOOL"))
8004 /* It appears that "r*" means "const char *" rather than
8006 if (TYPE_READONLY (pointer_to))
8007 obstack_1grow (&util_obstack, 'r');
8009 obstack_1grow (&util_obstack, '*');
8014 /* We have a type that does not get special treatment. */
8016 /* NeXT extension */
8017 obstack_1grow (&util_obstack, '^');
8018 encode_type (pointer_to, curtype, format);
8022 encode_array (tree type, int curtype, int format)
8024 tree an_int_cst = TYPE_SIZE (type);
8025 tree array_of = TREE_TYPE (type);
8028 /* An incomplete array is treated like a pointer. */
8029 if (an_int_cst == NULL)
8031 encode_pointer (type, curtype, format);
8035 if (TREE_INT_CST_LOW (TYPE_SIZE (array_of)) == 0)
8036 sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)0);
8038 sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC,
8039 TREE_INT_CST_LOW (an_int_cst)
8040 / TREE_INT_CST_LOW (TYPE_SIZE (array_of)));
8042 obstack_grow (&util_obstack, buffer, strlen (buffer));
8043 encode_type (array_of, curtype, format);
8044 obstack_1grow (&util_obstack, ']');
8049 encode_aggregate_fields (tree type, int pointed_to, int curtype, int format)
8051 tree field = TYPE_FIELDS (type);
8053 for (; field; field = TREE_CHAIN (field))
8056 /* C++ static members, and things that are not field at all,
8057 should not appear in the encoding. */
8058 if (TREE_CODE (field) != FIELD_DECL || TREE_STATIC (field))
8062 /* Recursively encode fields of embedded base classes. */
8063 if (DECL_ARTIFICIAL (field) && !DECL_NAME (field)
8064 && TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
8066 encode_aggregate_fields (TREE_TYPE (field),
8067 pointed_to, curtype, format);
8071 if (generating_instance_variables && !pointed_to)
8073 tree fname = DECL_NAME (field);
8075 obstack_1grow (&util_obstack, '"');
8077 if (fname && TREE_CODE (fname) == IDENTIFIER_NODE)
8078 obstack_grow (&util_obstack,
8079 IDENTIFIER_POINTER (fname),
8080 strlen (IDENTIFIER_POINTER (fname)));
8082 obstack_1grow (&util_obstack, '"');
8085 encode_field_decl (field, curtype, format);
8090 encode_aggregate_within (tree type, int curtype, int format, int left,
8094 /* NB: aggregates that are pointed to have slightly different encoding
8095 rules in that you never encode the names of instance variables. */
8096 int ob_size = obstack_object_size (&util_obstack);
8097 char c1 = ob_size > 1 ? *(obstack_next_free (&util_obstack) - 2) : 0;
8098 char c0 = ob_size > 0 ? *(obstack_next_free (&util_obstack) - 1) : 0;
8099 int pointed_to = (c0 == '^' || (c1 == '^' && c0 == 'r'));
8101 = ((format == OBJC_ENCODE_INLINE_DEFS || generating_instance_variables)
8102 && (!pointed_to || ob_size - curtype == (c1 == 'r' ? 2 : 1)));
8104 /* Traverse struct aliases; it is important to get the
8105 original struct and its tag name (if any). */
8106 type = TYPE_MAIN_VARIANT (type);
8107 name = OBJC_TYPE_NAME (type);
8108 /* Open parenth/bracket. */
8109 obstack_1grow (&util_obstack, left);
8111 /* Encode the struct/union tag name, or '?' if a tag was
8112 not provided. Typedef aliases do not qualify. */
8114 /* For compatibility with the NeXT runtime, ObjC++ encodes template
8115 args as a composite struct tag name. */
8116 if (name && TREE_CODE (name) == IDENTIFIER_NODE
8117 /* Did this struct have a tag? */
8118 && !TYPE_WAS_ANONYMOUS (type))
8119 obstack_grow (&util_obstack,
8120 decl_as_string (type, TFF_DECL_SPECIFIERS | TFF_UNQUALIFIED_NAME),
8121 strlen (decl_as_string (type, TFF_DECL_SPECIFIERS | TFF_UNQUALIFIED_NAME)));
8123 if (name && TREE_CODE (name) == IDENTIFIER_NODE)
8124 obstack_grow (&util_obstack,
8125 IDENTIFIER_POINTER (name),
8126 strlen (IDENTIFIER_POINTER (name)));
8129 obstack_1grow (&util_obstack, '?');
8131 /* Encode the types (and possibly names) of the inner fields,
8133 if (inline_contents)
8135 obstack_1grow (&util_obstack, '=');
8136 encode_aggregate_fields (type, pointed_to, curtype, format);
8138 /* Close parenth/bracket. */
8139 obstack_1grow (&util_obstack, right);
8143 encode_aggregate (tree type, int curtype, int format)
8145 enum tree_code code = TREE_CODE (type);
8151 encode_aggregate_within (type, curtype, format, '{', '}');
8156 encode_aggregate_within (type, curtype, format, '(', ')');
8161 obstack_1grow (&util_obstack, 'i');
8169 /* Encode a bitfield NeXT-style (i.e., without a bit offset or the underlying
8173 encode_next_bitfield (int width)
8176 sprintf (buffer, "b%d", width);
8177 obstack_grow (&util_obstack, buffer, strlen (buffer));
8180 /* FORMAT will be OBJC_ENCODE_INLINE_DEFS or OBJC_ENCODE_DONT_INLINE_DEFS. */
8182 encode_type (tree type, int curtype, int format)
8184 enum tree_code code = TREE_CODE (type);
8187 if (type == error_mark_node)
8190 if (TYPE_READONLY (type))
8191 obstack_1grow (&util_obstack, 'r');
8193 if (code == INTEGER_TYPE)
8195 switch (GET_MODE_BITSIZE (TYPE_MODE (type)))
8197 case 8: c = TYPE_UNSIGNED (type) ? 'C' : 'c'; break;
8198 case 16: c = TYPE_UNSIGNED (type) ? 'S' : 's'; break;
8200 if (type == long_unsigned_type_node
8201 || type == long_integer_type_node)
8202 c = TYPE_UNSIGNED (type) ? 'L' : 'l';
8204 c = TYPE_UNSIGNED (type) ? 'I' : 'i';
8206 case 64: c = TYPE_UNSIGNED (type) ? 'Q' : 'q'; break;
8209 obstack_1grow (&util_obstack, c);
8212 else if (code == REAL_TYPE)
8214 /* Floating point types. */
8215 switch (GET_MODE_BITSIZE (TYPE_MODE (type)))
8217 case 32: c = 'f'; break;
8220 case 128: c = 'd'; break;
8223 obstack_1grow (&util_obstack, c);
8226 else if (code == VOID_TYPE)
8227 obstack_1grow (&util_obstack, 'v');
8229 else if (code == BOOLEAN_TYPE)
8230 obstack_1grow (&util_obstack, 'B');
8232 else if (code == ARRAY_TYPE)
8233 encode_array (type, curtype, format);
8235 else if (code == POINTER_TYPE)
8236 encode_pointer (type, curtype, format);
8238 else if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
8239 encode_aggregate (type, curtype, format);
8241 else if (code == FUNCTION_TYPE) /* '?' */
8242 obstack_1grow (&util_obstack, '?');
8244 else if (code == COMPLEX_TYPE)
8246 obstack_1grow (&util_obstack, 'j');
8247 encode_type (TREE_TYPE (type), curtype, format);
8252 encode_gnu_bitfield (int position, tree type, int size)
8254 enum tree_code code = TREE_CODE (type);
8256 char charType = '?';
8258 if (code == INTEGER_TYPE)
8260 if (integer_zerop (TYPE_MIN_VALUE (type)))
8262 /* Unsigned integer types. */
8264 if (TYPE_MODE (type) == QImode)
8266 else if (TYPE_MODE (type) == HImode)
8268 else if (TYPE_MODE (type) == SImode)
8270 if (type == long_unsigned_type_node)
8275 else if (TYPE_MODE (type) == DImode)
8280 /* Signed integer types. */
8282 if (TYPE_MODE (type) == QImode)
8284 else if (TYPE_MODE (type) == HImode)
8286 else if (TYPE_MODE (type) == SImode)
8288 if (type == long_integer_type_node)
8294 else if (TYPE_MODE (type) == DImode)
8298 else if (code == ENUMERAL_TYPE)
8303 sprintf (buffer, "b%d%c%d", position, charType, size);
8304 obstack_grow (&util_obstack, buffer, strlen (buffer));
8308 encode_field_decl (tree field_decl, int curtype, int format)
8311 /* C++ static members, and things that are not fields at all,
8312 should not appear in the encoding. */
8313 if (TREE_CODE (field_decl) != FIELD_DECL || TREE_STATIC (field_decl))
8317 /* Generate the bitfield typing information, if needed. Note the difference
8318 between GNU and NeXT runtimes. */
8319 if (DECL_BIT_FIELD_TYPE (field_decl))
8321 int size = tree_low_cst (DECL_SIZE (field_decl), 1);
8323 if (flag_next_runtime)
8324 encode_next_bitfield (size);
8326 encode_gnu_bitfield (int_bit_position (field_decl),
8327 DECL_BIT_FIELD_TYPE (field_decl), size);
8330 encode_type (TREE_TYPE (field_decl), curtype, format);
8333 static GTY(()) tree objc_parmlist = NULL_TREE;
8335 /* Append PARM to a list of formal parameters of a method, making a necessary
8336 array-to-pointer adjustment along the way. */
8339 objc_push_parm (tree parm)
8341 bool relayout_needed = false;
8343 if (TREE_TYPE (parm) == error_mark_node)
8345 objc_parmlist = chainon (objc_parmlist, parm);
8349 /* Decay arrays and functions into pointers. */
8350 if (TREE_CODE (TREE_TYPE (parm)) == ARRAY_TYPE)
8352 TREE_TYPE (parm) = build_pointer_type (TREE_TYPE (TREE_TYPE (parm)));
8353 relayout_needed = true;
8355 else if (TREE_CODE (TREE_TYPE (parm)) == FUNCTION_TYPE)
8357 TREE_TYPE (parm) = build_pointer_type (TREE_TYPE (parm));
8358 relayout_needed = true;
8361 if (relayout_needed)
8362 relayout_decl (parm);
8365 DECL_ARG_TYPE (parm)
8366 = lang_hooks.types.type_promotes_to (TREE_TYPE (parm));
8368 /* Record constancy and volatility. */
8369 c_apply_type_quals_to_decl
8370 ((TYPE_READONLY (TREE_TYPE (parm)) ? TYPE_QUAL_CONST : 0)
8371 | (TYPE_RESTRICT (TREE_TYPE (parm)) ? TYPE_QUAL_RESTRICT : 0)
8372 | (TYPE_VOLATILE (TREE_TYPE (parm)) ? TYPE_QUAL_VOLATILE : 0), parm);
8374 objc_parmlist = chainon (objc_parmlist, parm);
8377 /* Retrieve the formal parameter list constructed via preceding calls to
8378 objc_push_parm(). */
8382 objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED)
8384 static struct c_arg_info *
8385 objc_get_parm_info (int have_ellipsis)
8389 tree parm_info = objc_parmlist;
8390 objc_parmlist = NULL_TREE;
8394 tree parm_info = objc_parmlist;
8395 struct c_arg_info *arg_info;
8396 /* The C front-end requires an elaborate song and dance at
8399 declare_parm_level ();
8402 tree next = TREE_CHAIN (parm_info);
8404 TREE_CHAIN (parm_info) = NULL_TREE;
8405 parm_info = pushdecl (parm_info);
8406 finish_decl (parm_info, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
8409 arg_info = get_parm_info (have_ellipsis);
8411 objc_parmlist = NULL_TREE;
8416 /* Synthesize the formal parameters 'id self' and 'SEL _cmd' needed for ObjC
8417 method definitions. In the case of instance methods, we can be more
8418 specific as to the type of 'self'. */
8421 synth_self_and_ucmd_args (void)
8425 if (objc_method_context
8426 && TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL)
8427 self_type = objc_instance_type;
8429 /* Really a `struct objc_class *'. However, we allow people to
8430 assign to self, which changes its type midstream. */
8431 self_type = objc_object_type;
8434 objc_push_parm (build_decl (input_location,
8435 PARM_DECL, self_id, self_type));
8438 objc_push_parm (build_decl (input_location,
8439 PARM_DECL, ucmd_id, objc_selector_type));
8442 /* Transform an Objective-C method definition into a static C function
8443 definition, synthesizing the first two arguments, "self" and "_cmd",
8447 start_method_def (tree method)
8453 struct c_arg_info *parm_info;
8455 int have_ellipsis = 0;
8457 /* If we are defining a "dealloc" method in a non-root class, we
8458 will need to check if a [super dealloc] is missing, and warn if
8460 if(CLASS_SUPER_NAME (objc_implementation_context)
8461 && !strcmp ("dealloc", IDENTIFIER_POINTER (METHOD_SEL_NAME (method))))
8462 should_call_super_dealloc = 1;
8464 should_call_super_dealloc = 0;
8466 /* Required to implement _msgSuper. */
8467 objc_method_context = method;
8468 UOBJC_SUPER_decl = NULL_TREE;
8470 /* Generate prototype declarations for arguments..."new-style". */
8471 synth_self_and_ucmd_args ();
8473 /* Generate argument declarations if a keyword_decl. */
8474 parmlist = METHOD_SEL_ARGS (method);
8477 tree type = TREE_VALUE (TREE_TYPE (parmlist)), parm;
8479 parm = build_decl (input_location,
8480 PARM_DECL, KEYWORD_ARG_NAME (parmlist), type);
8481 objc_push_parm (parm);
8482 parmlist = TREE_CHAIN (parmlist);
8485 if (METHOD_ADD_ARGS (method))
8489 for (akey = TREE_CHAIN (METHOD_ADD_ARGS (method));
8490 akey; akey = TREE_CHAIN (akey))
8492 objc_push_parm (TREE_VALUE (akey));
8495 if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
8499 parm_info = objc_get_parm_info (have_ellipsis);
8501 really_start_method (objc_method_context, parm_info);
8504 /* Return 1 if TYPE1 is equivalent to TYPE2
8505 for purposes of method overloading. */
8508 objc_types_are_equivalent (tree type1, tree type2)
8513 /* Strip away indirections. */
8514 while ((TREE_CODE (type1) == ARRAY_TYPE || TREE_CODE (type1) == POINTER_TYPE)
8515 && (TREE_CODE (type1) == TREE_CODE (type2)))
8516 type1 = TREE_TYPE (type1), type2 = TREE_TYPE (type2);
8517 if (TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
8520 type1 = (TYPE_HAS_OBJC_INFO (type1)
8521 ? TYPE_OBJC_PROTOCOL_LIST (type1)
8523 type2 = (TYPE_HAS_OBJC_INFO (type2)
8524 ? TYPE_OBJC_PROTOCOL_LIST (type2)
8527 if (list_length (type1) == list_length (type2))
8529 for (; type2; type2 = TREE_CHAIN (type2))
8530 if (!lookup_protocol_in_reflist (type1, TREE_VALUE (type2)))
8537 /* Return 1 if TYPE1 has the same size and alignment as TYPE2. */
8540 objc_types_share_size_and_alignment (tree type1, tree type2)
8542 return (simple_cst_equal (TYPE_SIZE (type1), TYPE_SIZE (type2))
8543 && TYPE_ALIGN (type1) == TYPE_ALIGN (type2));
8546 /* Return 1 if PROTO1 is equivalent to PROTO2
8547 for purposes of method overloading. Ordinarily, the type signatures
8548 should match up exactly, unless STRICT is zero, in which case we
8549 shall allow differences in which the size and alignment of a type
8553 comp_proto_with_proto (tree proto1, tree proto2, int strict)
8557 /* The following test is needed in case there are hashing
8559 if (METHOD_SEL_NAME (proto1) != METHOD_SEL_NAME (proto2))
8562 /* Compare return types. */
8563 type1 = TREE_VALUE (TREE_TYPE (proto1));
8564 type2 = TREE_VALUE (TREE_TYPE (proto2));
8566 if (!objc_types_are_equivalent (type1, type2)
8567 && (strict || !objc_types_share_size_and_alignment (type1, type2)))
8570 /* Compare argument types. */
8571 for (type1 = get_arg_type_list (proto1, METHOD_REF, 0),
8572 type2 = get_arg_type_list (proto2, METHOD_REF, 0);
8574 type1 = TREE_CHAIN (type1), type2 = TREE_CHAIN (type2))
8576 if (!objc_types_are_equivalent (TREE_VALUE (type1), TREE_VALUE (type2))
8578 || !objc_types_share_size_and_alignment (TREE_VALUE (type1),
8579 TREE_VALUE (type2))))
8583 return (!type1 && !type2);
8586 /* Fold an OBJ_TYPE_REF expression for ObjC method dispatches, where
8587 this occurs. ObjC method dispatches are _not_ like C++ virtual
8588 member function dispatches, and we account for the difference here. */
8591 objc_fold_obj_type_ref (tree ref, tree known_type)
8593 objc_fold_obj_type_ref (tree ref ATTRIBUTE_UNUSED,
8594 tree known_type ATTRIBUTE_UNUSED)
8598 tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
8600 /* If the receiver does not have virtual member functions, there
8601 is nothing we can (or need to) do here. */
8605 /* Let C++ handle C++ virtual functions. */
8606 return cp_fold_obj_type_ref (ref, known_type);
8608 /* For plain ObjC, we currently do not need to do anything. */
8614 objc_start_function (tree name, tree type, tree attrs,
8618 struct c_arg_info *params
8622 tree fndecl = build_decl (input_location,
8623 FUNCTION_DECL, name, type);
8626 DECL_ARGUMENTS (fndecl) = params;
8627 DECL_INITIAL (fndecl) = error_mark_node;
8628 DECL_EXTERNAL (fndecl) = 0;
8629 TREE_STATIC (fndecl) = 1;
8630 retrofit_lang_decl (fndecl);
8631 cplus_decl_attributes (&fndecl, attrs, 0);
8632 start_preparsed_function (fndecl, attrs, /*flags=*/SF_DEFAULT);
8634 current_function_returns_value = 0; /* Assume, until we see it does. */
8635 current_function_returns_null = 0;
8637 decl_attributes (&fndecl, attrs, 0);
8638 announce_function (fndecl);
8639 DECL_INITIAL (fndecl) = error_mark_node;
8640 DECL_EXTERNAL (fndecl) = 0;
8641 TREE_STATIC (fndecl) = 1;
8642 current_function_decl = pushdecl (fndecl);
8644 declare_parm_level ();
8645 DECL_RESULT (current_function_decl)
8646 = build_decl (input_location,
8647 RESULT_DECL, NULL_TREE,
8648 TREE_TYPE (TREE_TYPE (current_function_decl)));
8649 DECL_ARTIFICIAL (DECL_RESULT (current_function_decl)) = 1;
8650 DECL_IGNORED_P (DECL_RESULT (current_function_decl)) = 1;
8651 start_fname_decls ();
8652 store_parm_decls_from (params);
8655 TREE_USED (current_function_decl) = 1;
8658 /* - Generate an identifier for the function. the format is "_n_cls",
8659 where 1 <= n <= nMethods, and cls is the name the implementation we
8661 - Install the return type from the method declaration.
8662 - If we have a prototype, check for type consistency. */
8665 really_start_method (tree method,
8669 struct c_arg_info *parmlist
8673 tree ret_type, meth_type;
8675 const char *sel_name, *class_name, *cat_name;
8678 /* Synth the storage class & assemble the return type. */
8679 ret_type = TREE_VALUE (TREE_TYPE (method));
8681 sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method));
8682 class_name = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
8683 cat_name = ((TREE_CODE (objc_implementation_context)
8684 == CLASS_IMPLEMENTATION_TYPE)
8686 : IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
8689 /* Make sure this is big enough for any plausible method label. */
8690 buf = (char *) alloca (50 + strlen (sel_name) + strlen (class_name)
8691 + (cat_name ? strlen (cat_name) : 0));
8693 OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL,
8694 class_name, cat_name, sel_name, method_slot);
8696 method_id = get_identifier (buf);
8699 /* Objective-C methods cannot be overloaded, so we don't need
8700 the type encoding appended. It looks bad anyway... */
8701 push_lang_context (lang_name_c);
8705 = build_function_type (ret_type,
8706 get_arg_type_list (method, METHOD_DEF, 0));
8707 objc_start_function (method_id, meth_type, NULL_TREE, parmlist);
8709 /* Set self_decl from the first argument. */
8710 self_decl = DECL_ARGUMENTS (current_function_decl);
8712 /* Suppress unused warnings. */
8713 TREE_USED (self_decl) = 1;
8714 DECL_READ_P (self_decl) = 1;
8715 TREE_USED (TREE_CHAIN (self_decl)) = 1;
8716 DECL_READ_P (TREE_CHAIN (self_decl)) = 1;
8718 pop_lang_context ();
8721 METHOD_DEFINITION (method) = current_function_decl;
8723 /* Check consistency...start_function, pushdecl, duplicate_decls. */
8725 if (implementation_template != objc_implementation_context)
8728 = lookup_method_static (implementation_template,
8729 METHOD_SEL_NAME (method),
8730 ((TREE_CODE (method) == CLASS_METHOD_DECL)
8731 | OBJC_LOOKUP_NO_SUPER));
8735 if (!comp_proto_with_proto (method, proto, 1))
8737 bool type = TREE_CODE (method) == INSTANCE_METHOD_DECL;
8739 warning_at (DECL_SOURCE_LOCATION (method), 0,
8740 "conflicting types for %<%c%s%>",
8742 identifier_to_locale (gen_method_decl (method)));
8743 inform (DECL_SOURCE_LOCATION (proto),
8744 "previous declaration of %<%c%s%>",
8746 identifier_to_locale (gen_method_decl (proto)));
8751 /* We have a method @implementation even though we did not
8752 see a corresponding @interface declaration (which is allowed
8753 by Objective-C rules). Go ahead and place the method in
8754 the @interface anyway, so that message dispatch lookups
8756 tree interface = implementation_template;
8758 if (TREE_CODE (objc_implementation_context)
8759 == CATEGORY_IMPLEMENTATION_TYPE)
8760 interface = lookup_category
8762 CLASS_SUPER_NAME (objc_implementation_context));
8765 objc_add_method (interface, copy_node (method),
8766 TREE_CODE (method) == CLASS_METHOD_DECL);
8771 static void *UOBJC_SUPER_scope = 0;
8773 /* _n_Method (id self, SEL sel, ...)
8775 struct objc_super _S;
8776 _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
8780 get_super_receiver (void)
8782 if (objc_method_context)
8784 tree super_expr, super_expr_list;
8786 if (!UOBJC_SUPER_decl)
8788 UOBJC_SUPER_decl = build_decl (input_location,
8789 VAR_DECL, get_identifier (TAG_SUPER),
8790 objc_super_template);
8791 /* This prevents `unused variable' warnings when compiling with -Wall. */
8792 TREE_USED (UOBJC_SUPER_decl) = 1;
8793 DECL_READ_P (UOBJC_SUPER_decl) = 1;
8794 lang_hooks.decls.pushdecl (UOBJC_SUPER_decl);
8795 finish_decl (UOBJC_SUPER_decl, input_location, NULL_TREE, NULL_TREE,
8797 UOBJC_SUPER_scope = objc_get_current_scope ();
8800 /* Set receiver to self. */
8801 super_expr = objc_build_component_ref (UOBJC_SUPER_decl, self_id);
8802 super_expr = build_modify_expr (input_location, super_expr, NULL_TREE,
8803 NOP_EXPR, input_location, self_decl,
8805 super_expr_list = super_expr;
8807 /* Set class to begin searching. */
8808 super_expr = objc_build_component_ref (UOBJC_SUPER_decl,
8809 get_identifier ("super_class"));
8811 if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
8813 /* [_cls, __cls]Super are "pre-built" in
8814 synth_forward_declarations. */
8816 super_expr = build_modify_expr (input_location, super_expr,
8817 NULL_TREE, NOP_EXPR,
8819 ((TREE_CODE (objc_method_context)
8820 == INSTANCE_METHOD_DECL)
8827 /* We have a category. */
8829 tree super_name = CLASS_SUPER_NAME (implementation_template);
8832 /* Barf if super used in a category of Object. */
8835 error ("no super class declared in interface for %qE",
8836 CLASS_NAME (implementation_template));
8837 return error_mark_node;
8840 if (flag_next_runtime && !flag_zero_link)
8842 super_class = objc_get_class_reference (super_name);
8843 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
8844 /* If we are in a class method, we must retrieve the
8845 _metaclass_ for the current class, pointed at by
8846 the class's "isa" pointer. The following assumes that
8847 "isa" is the first ivar in a class (which it must be). */
8849 = build_indirect_ref
8851 build_c_cast (input_location,
8852 build_pointer_type (objc_class_type),
8853 super_class), RO_UNARY_STAR);
8857 add_class_reference (super_name);
8858 super_class = (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
8859 ? objc_get_class_decl : objc_get_meta_class_decl);
8860 assemble_external (super_class);
8862 = build_function_call
8867 my_build_string_pointer
8868 (IDENTIFIER_LENGTH (super_name) + 1,
8869 IDENTIFIER_POINTER (super_name))));
8873 = build_modify_expr (input_location, super_expr, NULL_TREE,
8876 build_c_cast (input_location,
8877 TREE_TYPE (super_expr),
8882 super_expr_list = build_compound_expr (input_location,
8883 super_expr_list, super_expr);
8885 super_expr = build_unary_op (input_location,
8886 ADDR_EXPR, UOBJC_SUPER_decl, 0);
8887 super_expr_list = build_compound_expr (input_location,
8888 super_expr_list, super_expr);
8890 return super_expr_list;
8894 error ("[super ...] must appear in a method context");
8895 return error_mark_node;
8899 /* When exiting a scope, sever links to a 'super' declaration (if any)
8900 therein contained. */
8903 objc_clear_super_receiver (void)
8905 if (objc_method_context
8906 && UOBJC_SUPER_scope == objc_get_current_scope ()) {
8907 UOBJC_SUPER_decl = 0;
8908 UOBJC_SUPER_scope = 0;
8913 objc_finish_method_definition (tree fndecl)
8915 /* We cannot validly inline ObjC methods, at least not without a language
8916 extension to declare that a method need not be dynamically
8917 dispatched, so suppress all thoughts of doing so. */
8918 DECL_UNINLINABLE (fndecl) = 1;
8921 /* The C++ front-end will have called finish_function() for us. */
8925 METHOD_ENCODING (objc_method_context)
8926 = encode_method_prototype (objc_method_context);
8928 /* Required to implement _msgSuper. This must be done AFTER finish_function,
8929 since the optimizer may find "may be used before set" errors. */
8930 objc_method_context = NULL_TREE;
8932 if (should_call_super_dealloc)
8933 warning (0, "method possibly missing a [super dealloc] call");
8936 /* Given a tree DECL node, produce a printable description of it in the given
8937 buffer, overwriting the buffer. */
8940 gen_declaration (tree decl)
8946 gen_type_name_0 (TREE_TYPE (decl));
8948 if (DECL_NAME (decl))
8950 if (!POINTER_TYPE_P (TREE_TYPE (decl)))
8951 strcat (errbuf, " ");
8953 strcat (errbuf, IDENTIFIER_POINTER (DECL_NAME (decl)));
8956 if (DECL_INITIAL (decl)
8957 && TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST)
8958 sprintf (errbuf + strlen (errbuf), ": " HOST_WIDE_INT_PRINT_DEC,
8959 TREE_INT_CST_LOW (DECL_INITIAL (decl)));
8965 /* Given a tree TYPE node, produce a printable description of it in the given
8966 buffer, overwriting the buffer. */
8969 gen_type_name_0 (tree type)
8971 tree orig = type, proto;
8973 if (TYPE_P (type) && TYPE_NAME (type))
8974 type = TYPE_NAME (type);
8975 else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
8977 tree inner = TREE_TYPE (type);
8979 while (TREE_CODE (inner) == ARRAY_TYPE)
8980 inner = TREE_TYPE (inner);
8982 gen_type_name_0 (inner);
8984 if (!POINTER_TYPE_P (inner))
8985 strcat (errbuf, " ");
8987 if (POINTER_TYPE_P (type))
8988 strcat (errbuf, "*");
8990 while (type != inner)
8992 strcat (errbuf, "[");
8994 if (TYPE_DOMAIN (type))
8998 sprintf (sz, HOST_WIDE_INT_PRINT_DEC,
9000 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1));
9001 strcat (errbuf, sz);
9004 strcat (errbuf, "]");
9005 type = TREE_TYPE (type);
9011 if (TREE_CODE (type) == TYPE_DECL && DECL_NAME (type))
9012 type = DECL_NAME (type);
9014 strcat (errbuf, TREE_CODE (type) == IDENTIFIER_NODE
9015 ? IDENTIFIER_POINTER (type)
9018 /* For 'id' and 'Class', adopted protocols are stored in the pointee. */
9019 if (objc_is_id (orig))
9020 orig = TREE_TYPE (orig);
9022 proto = TYPE_HAS_OBJC_INFO (orig) ? TYPE_OBJC_PROTOCOL_LIST (orig) : NULL_TREE;
9026 strcat (errbuf, " <");
9030 IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto))));
9031 proto = TREE_CHAIN (proto);
9032 strcat (errbuf, proto ? ", " : ">");
9041 gen_type_name (tree type)
9045 return gen_type_name_0 (type);
9048 /* Given a method tree, put a printable description into the given
9049 buffer (overwriting) and return a pointer to the buffer. */
9052 gen_method_decl (tree method)
9056 strcpy (errbuf, "("); /* NB: Do _not_ call strcat() here. */
9057 gen_type_name_0 (TREE_VALUE (TREE_TYPE (method)));
9058 strcat (errbuf, ")");
9059 chain = METHOD_SEL_ARGS (method);
9063 /* We have a chain of keyword_decls. */
9066 if (KEYWORD_KEY_NAME (chain))
9067 strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain)));
9069 strcat (errbuf, ":(");
9070 gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain)));
9071 strcat (errbuf, ")");
9073 strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain)));
9074 if ((chain = TREE_CHAIN (chain)))
9075 strcat (errbuf, " ");
9079 if (METHOD_ADD_ARGS (method))
9081 chain = TREE_CHAIN (METHOD_ADD_ARGS (method));
9083 /* Know we have a chain of parm_decls. */
9086 strcat (errbuf, ", ");
9087 gen_type_name_0 (TREE_TYPE (TREE_VALUE (chain)));
9088 chain = TREE_CHAIN (chain);
9091 if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
9092 strcat (errbuf, ", ...");
9097 /* We have a unary selector. */
9098 strcat (errbuf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
9106 /* Dump an @interface declaration of the supplied class CHAIN to the
9107 supplied file FP. Used to implement the -gen-decls option (which
9108 prints out an @interface declaration of all classes compiled in
9109 this run); potentially useful for debugging the compiler too. */
9111 dump_interface (FILE *fp, tree chain)
9113 /* FIXME: A heap overflow here whenever a method (or ivar)
9114 declaration is so long that it doesn't fit in the buffer. The
9115 code and all the related functions should be rewritten to avoid
9116 using fixed size buffers. */
9117 const char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain));
9118 tree ivar_decls = CLASS_RAW_IVARS (chain);
9119 tree nst_methods = CLASS_NST_METHODS (chain);
9120 tree cls_methods = CLASS_CLS_METHODS (chain);
9122 fprintf (fp, "\n@interface %s", my_name);
9124 /* CLASS_SUPER_NAME is used to store the superclass name for
9125 classes, and the category name for categories. */
9126 if (CLASS_SUPER_NAME (chain))
9128 const char *name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain));
9130 if (TREE_CODE (chain) == CATEGORY_IMPLEMENTATION_TYPE
9131 || TREE_CODE (chain) == CATEGORY_INTERFACE_TYPE)
9133 fprintf (fp, " (%s)\n", name);
9137 fprintf (fp, " : %s\n", name);
9143 /* FIXME - the following doesn't seem to work at the moment. */
9146 fprintf (fp, "{\n");
9149 fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls));
9150 ivar_decls = TREE_CHAIN (ivar_decls);
9153 fprintf (fp, "}\n");
9158 fprintf (fp, "- %s;\n", gen_method_decl (nst_methods));
9159 nst_methods = TREE_CHAIN (nst_methods);
9164 fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods));
9165 cls_methods = TREE_CHAIN (cls_methods);
9168 fprintf (fp, "@end\n");
9171 /* Demangle function for Objective-C */
9173 objc_demangle (const char *mangled)
9175 char *demangled, *cp;
9177 if (mangled[0] == '_' &&
9178 (mangled[1] == 'i' || mangled[1] == 'c') &&
9181 cp = demangled = XNEWVEC (char, strlen(mangled) + 2);
9182 if (mangled[1] == 'i')
9183 *cp++ = '-'; /* for instance method */
9185 *cp++ = '+'; /* for class method */
9186 *cp++ = '['; /* opening left brace */
9187 strcpy(cp, mangled+3); /* tack on the rest of the mangled name */
9188 while (*cp && *cp == '_')
9189 cp++; /* skip any initial underbars in class name */
9190 cp = strchr(cp, '_'); /* find first non-initial underbar */
9193 free(demangled); /* not mangled name */
9196 if (cp[1] == '_') /* easy case: no category name */
9198 *cp++ = ' '; /* replace two '_' with one ' ' */
9199 strcpy(cp, mangled + (cp - demangled) + 2);
9203 *cp++ = '('; /* less easy case: category name */
9204 cp = strchr(cp, '_');
9207 free(demangled); /* not mangled name */
9211 *cp++ = ' '; /* overwriting 1st char of method name... */
9212 strcpy(cp, mangled + (cp - demangled)); /* get it back */
9214 while (*cp && *cp == '_')
9215 cp++; /* skip any initial underbars in method name */
9218 *cp = ':'; /* replace remaining '_' with ':' */
9219 *cp++ = ']'; /* closing right brace */
9220 *cp++ = 0; /* string terminator */
9224 return mangled; /* not an objc mangled name */
9228 objc_printable_name (tree decl, int kind ATTRIBUTE_UNUSED)
9230 return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl)));
9236 gcc_obstack_init (&util_obstack);
9237 util_firstobj = (char *) obstack_finish (&util_obstack);
9239 errbuf = XNEWVEC (char, 1024 * 10);
9241 synth_module_prologue ();
9247 struct imp_entry *impent;
9249 /* The internally generated initializers appear to have missing braces.
9250 Don't warn about this. */
9251 int save_warn_missing_braces = warn_missing_braces;
9252 warn_missing_braces = 0;
9254 /* A missing @end may not be detected by the parser. */
9255 if (objc_implementation_context)
9257 warning (0, "%<@end%> missing in implementation context");
9258 finish_class (objc_implementation_context);
9259 objc_ivar_chain = NULL_TREE;
9260 objc_implementation_context = NULL_TREE;
9263 /* Process the static instances here because initialization of objc_symtab
9265 if (objc_static_instances)
9266 generate_static_references ();
9268 if (imp_list || class_names_chain
9269 || meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
9270 generate_objc_symtab_decl ();
9272 for (impent = imp_list; impent; impent = impent->next)
9274 objc_implementation_context = impent->imp_context;
9275 implementation_template = impent->imp_template;
9277 UOBJC_CLASS_decl = impent->class_decl;
9278 UOBJC_METACLASS_decl = impent->meta_decl;
9280 /* Dump the @interface of each class as we compile it, if the
9281 -gen-decls option is in use. TODO: Dump the classes in the
9282 order they were found, rather than in reverse order as we
9284 if (flag_gen_declaration)
9286 dump_interface (gen_declaration_file, objc_implementation_context);
9289 if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
9291 /* all of the following reference the string pool... */
9292 generate_ivar_lists ();
9293 generate_dispatch_tables ();
9294 generate_shared_structures (impent->has_cxx_cdtors
9295 ? CLS_HAS_CXX_STRUCTORS
9300 generate_dispatch_tables ();
9301 generate_category (objc_implementation_context);
9305 /* If we are using an array of selectors, we must always
9306 finish up the array decl even if no selectors were used. */
9307 if (! flag_next_runtime || sel_ref_chain)
9308 build_selector_translation_table ();
9311 generate_protocols ();
9313 if ((flag_replace_objc_classes && imp_list) || flag_objc_gc)
9314 generate_objc_image_info ();
9316 /* Arrange for ObjC data structures to be initialized at run time. */
9317 if (objc_implementation_context || class_names_chain || objc_static_instances
9318 || meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
9320 build_module_descriptor ();
9322 if (!flag_next_runtime)
9323 build_module_initializer_routine ();
9326 /* Dump the class references. This forces the appropriate classes
9327 to be linked into the executable image, preserving unix archive
9328 semantics. This can be removed when we move to a more dynamically
9329 linked environment. */
9331 for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
9333 handle_class_ref (chain);
9334 if (TREE_PURPOSE (chain))
9335 generate_classref_translation_entry (chain);
9338 for (impent = imp_list; impent; impent = impent->next)
9339 handle_impent (impent);
9346 /* Run through the selector hash tables and print a warning for any
9347 selector which has multiple methods. */
9349 for (slot = 0; slot < SIZEHASHTABLE; slot++)
9351 for (hsh = cls_method_hash_list[slot]; hsh; hsh = hsh->next)
9352 check_duplicates (hsh, 0, 1);
9353 for (hsh = nst_method_hash_list[slot]; hsh; hsh = hsh->next)
9354 check_duplicates (hsh, 0, 1);
9358 warn_missing_braces = save_warn_missing_braces;
9361 /* Subroutines of finish_objc. */
9364 generate_classref_translation_entry (tree chain)
9366 tree expr, decl, type;
9368 decl = TREE_PURPOSE (chain);
9369 type = TREE_TYPE (decl);
9371 expr = add_objc_string (TREE_VALUE (chain), class_names);
9372 expr = convert (type, expr); /* cast! */
9374 /* The decl that is the one that we
9375 forward declared in build_class_reference. */
9376 finish_var_decl (decl, expr);
9381 handle_class_ref (tree chain)
9383 const char *name = IDENTIFIER_POINTER (TREE_VALUE (chain));
9384 char *string = (char *) alloca (strlen (name) + 30);
9388 sprintf (string, "%sobjc_class_name_%s",
9389 (flag_next_runtime ? "." : "__"), name);
9391 #ifdef ASM_DECLARE_UNRESOLVED_REFERENCE
9392 if (flag_next_runtime)
9394 ASM_DECLARE_UNRESOLVED_REFERENCE (asm_out_file, string);
9399 /* Make a decl for this name, so we can use its address in a tree. */
9400 decl = build_decl (input_location,
9401 VAR_DECL, get_identifier (string), char_type_node);
9402 DECL_EXTERNAL (decl) = 1;
9403 TREE_PUBLIC (decl) = 1;
9406 rest_of_decl_compilation (decl, 0, 0);
9408 /* Make a decl for the address. */
9409 sprintf (string, "%sobjc_class_ref_%s",
9410 (flag_next_runtime ? "." : "__"), name);
9411 exp = build1 (ADDR_EXPR, string_type_node, decl);
9412 decl = build_decl (input_location,
9413 VAR_DECL, get_identifier (string), string_type_node);
9414 DECL_INITIAL (decl) = exp;
9415 TREE_STATIC (decl) = 1;
9416 TREE_USED (decl) = 1;
9417 DECL_READ_P (decl) = 1;
9418 /* Force the output of the decl as this forces the reference of the class. */
9419 mark_decl_referenced (decl);
9422 rest_of_decl_compilation (decl, 0, 0);
9426 handle_impent (struct imp_entry *impent)
9430 objc_implementation_context = impent->imp_context;
9431 implementation_template = impent->imp_template;
9433 if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
9435 const char *const class_name =
9436 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
9438 string = (char *) alloca (strlen (class_name) + 30);
9440 sprintf (string, "%sobjc_class_name_%s",
9441 (flag_next_runtime ? "." : "__"), class_name);
9443 else if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
9445 const char *const class_name =
9446 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
9447 const char *const class_super_name =
9448 IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context));
9450 string = (char *) alloca (strlen (class_name)
9451 + strlen (class_super_name) + 30);
9453 /* Do the same for categories. Even though no references to
9454 these symbols are generated automatically by the compiler, it
9455 gives you a handle to pull them into an archive by hand. */
9456 sprintf (string, "*%sobjc_category_name_%s_%s",
9457 (flag_next_runtime ? "." : "__"), class_name, class_super_name);
9462 #ifdef ASM_DECLARE_CLASS_REFERENCE
9463 if (flag_next_runtime)
9465 ASM_DECLARE_CLASS_REFERENCE (asm_out_file, string);
9473 init = build_int_cst (c_common_type_for_size (BITS_PER_WORD, 1), 0);
9474 decl = build_decl (input_location,
9475 VAR_DECL, get_identifier (string), TREE_TYPE (init));
9476 TREE_PUBLIC (decl) = 1;
9477 TREE_READONLY (decl) = 1;
9478 TREE_USED (decl) = 1;
9479 TREE_CONSTANT (decl) = 1;
9480 DECL_CONTEXT (decl) = 0;
9481 DECL_ARTIFICIAL (decl) = 1;
9482 DECL_INITIAL (decl) = init;
9483 assemble_variable (decl, 1, 0, 0);
9487 /* The Fix-and-Continue functionality available in Mac OS X 10.3 and
9488 later requires that ObjC translation units participating in F&C be
9489 specially marked. The following routine accomplishes this. */
9491 /* static int _OBJC_IMAGE_INFO[2] = { 0, 1 }; */
9494 generate_objc_image_info (void)
9498 = ((flag_replace_objc_classes && imp_list ? 1 : 0)
9499 | (flag_objc_gc ? 2 : 0));
9500 VEC(constructor_elt,gc) *v = NULL;
9502 decl = start_var_decl (build_array_type
9504 build_index_type (build_int_cst (NULL_TREE, 2 - 1))),
9505 "_OBJC_IMAGE_INFO");
9507 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
9508 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, flags));
9510 finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), v));
9513 /* Look up ID as an instance variable. OTHER contains the result of
9514 the C or C++ lookup, which we may want to use instead. */
9517 objc_lookup_ivar (tree other, tree id)
9521 /* If we are not inside of an ObjC method, ivar lookup makes no sense. */
9522 if (!objc_method_context)
9525 if (!strcmp (IDENTIFIER_POINTER (id), "super"))
9526 /* We have a message to super. */
9527 return get_super_receiver ();
9529 /* In a class method, look up an instance variable only as a last
9531 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL
9532 && other && other != error_mark_node)
9535 /* Look up the ivar, but do not use it if it is not accessible. */
9536 ivar = is_ivar (objc_ivar_chain, id);
9538 if (!ivar || is_private (ivar))
9541 /* In an instance method, a local variable (or parameter) may hide the
9542 instance variable. */
9543 if (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
9544 && other && other != error_mark_node
9546 && CP_DECL_CONTEXT (other) != global_namespace)
9548 && !DECL_FILE_SCOPE_P (other))
9551 warning (0, "local declaration of %qE hides instance variable",
9557 /* At this point, we are either in an instance method with no obscuring
9558 local definitions, or in a class method with no alternate definitions
9560 return build_ivar_reference (id);
9563 /* Possibly rewrite a function CALL into an OBJ_TYPE_REF expression. This
9564 needs to be done if we are calling a function through a cast. */
9567 objc_rewrite_function_call (tree function, tree first_param)
9569 if (TREE_CODE (function) == NOP_EXPR
9570 && TREE_CODE (TREE_OPERAND (function, 0)) == ADDR_EXPR
9571 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (function, 0), 0))
9574 function = build3 (OBJ_TYPE_REF, TREE_TYPE (function),
9575 TREE_OPERAND (function, 0),
9576 first_param, size_zero_node);
9582 /* Look for the special case of OBJC_TYPE_REF with the address of
9583 a function in OBJ_TYPE_REF_EXPR (presumably objc_msgSend or one
9587 objc_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
9589 enum gimplify_status r0, r1;
9590 if (TREE_CODE (*expr_p) == OBJ_TYPE_REF
9591 && TREE_CODE (OBJ_TYPE_REF_EXPR (*expr_p)) == ADDR_EXPR
9592 && TREE_CODE (TREE_OPERAND (OBJ_TYPE_REF_EXPR (*expr_p), 0))
9595 /* Postincrements in OBJ_TYPE_REF_OBJECT don't affect the
9596 value of the OBJ_TYPE_REF, so force them to be emitted
9597 during subexpression evaluation rather than after the
9598 OBJ_TYPE_REF. This permits objc_msgSend calls in Objective
9599 C to use direct rather than indirect calls when the
9600 object expression has a postincrement. */
9601 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, NULL,
9602 is_gimple_val, fb_rvalue);
9603 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
9604 is_gimple_val, fb_rvalue);
9606 return MIN (r0, r1);
9610 return (enum gimplify_status) cp_gimplify_expr (expr_p, pre_p, post_p);
9612 return (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p);
9616 #include "gt-objc-objc-act.h"