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 Free Software Foundation, Inc.
4 Contributed by Steve Naroff.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3, or (at your option)
13 GCC is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
23 /* Purpose: This module implements the Objective-C 4.0 language.
25 compatibility issues (with the Stepstone translator):
27 - does not recognize the following 3.3 constructs.
28 @requires, @classes, @messages, = (...)
29 - methods with variable arguments must conform to ANSI standard.
30 - tagged structure definitions that appear in BOTH the interface
31 and implementation are not allowed.
32 - public/private: all instance variables are public within the
33 context of the implementation...I consider this to be a bug in
35 - statically allocated objects are not supported. the user will
36 receive an error if this service is requested.
38 code generation `options':
44 #include "coretypes.h"
61 #include "langhooks.h"
72 #include "diagnostic.h"
75 #include "tree-iterator.h"
78 #include "langhooks-def.h"
80 #define OBJC_VOID_AT_END void_list_node
82 static unsigned int should_call_super_dealloc = 0;
84 /* When building Objective-C++, we need in_late_binary_op. */
86 bool in_late_binary_op = false;
89 /* When building Objective-C++, we are not linking against the C front-end
90 and so need to replicate the C tree-construction functions in some way. */
92 #define OBJCP_REMAP_FUNCTIONS
93 #include "objcp-decl.h"
96 /* This is the default way of generating a method name. */
97 /* I am not sure it is really correct.
98 Perhaps there's a danger that it will make name conflicts
99 if method names contain underscores. -- rms. */
100 #ifndef OBJC_GEN_METHOD_LABEL
101 #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
104 sprintf ((BUF), "_%s_%s_%s_%s", \
105 ((IS_INST) ? "i" : "c"), \
107 ((CAT_NAME)? (CAT_NAME) : ""), \
109 for (temp = (BUF); *temp; temp++) \
110 if (*temp == ':') *temp = '_'; \
114 /* These need specifying. */
115 #ifndef OBJC_FORWARDING_STACK_OFFSET
116 #define OBJC_FORWARDING_STACK_OFFSET 0
119 #ifndef OBJC_FORWARDING_MIN_OFFSET
120 #define OBJC_FORWARDING_MIN_OFFSET 0
123 /* Set up for use of obstacks. */
127 /* This obstack is used to accumulate the encoding of a data type. */
128 static struct obstack util_obstack;
130 /* This points to the beginning of obstack contents, so we can free
131 the whole contents. */
134 /* The version identifies which language generation and runtime
135 the module (file) was compiled for, and is recorded in the
136 module descriptor. */
138 #define OBJC_VERSION (flag_next_runtime ? 6 : 8)
139 #define PROTOCOL_VERSION 2
141 /* (Decide if these can ever be validly changed.) */
142 #define OBJC_ENCODE_INLINE_DEFS 0
143 #define OBJC_ENCODE_DONT_INLINE_DEFS 1
145 /*** Private Interface (procedures) ***/
147 /* Used by compile_file. */
149 static void init_objc (void);
150 static void finish_objc (void);
152 /* Code generation. */
154 static tree objc_build_constructor (tree, tree);
155 static tree build_objc_method_call (location_t, int, tree, tree, tree, tree);
156 static tree get_proto_encoding (tree);
157 static tree lookup_interface (tree);
158 static tree objc_add_static_instance (tree, tree);
160 static tree start_class (enum tree_code, tree, tree, tree);
161 static tree continue_class (tree);
162 static void finish_class (tree);
163 static void start_method_def (tree);
165 static void objc_start_function (tree, tree, tree, tree);
167 static void objc_start_function (tree, tree, tree, struct c_arg_info *);
169 static tree start_protocol (enum tree_code, tree, tree);
170 static tree build_method_decl (enum tree_code, tree, tree, tree, bool);
171 static tree objc_add_method (tree, tree, int);
172 static tree add_instance_variable (tree, int, tree);
173 static tree build_ivar_reference (tree);
174 static tree is_ivar (tree, tree);
176 static void build_objc_exception_stuff (void);
177 static void build_next_objc_exception_stuff (void);
179 /* We only need the following for ObjC; ObjC++ will use C++'s definition
180 of DERIVED_FROM_P. */
182 static bool objc_derived_from_p (tree, tree);
183 #define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD)
185 static void objc_xref_basetypes (tree, tree);
187 static void build_class_template (void);
188 static void build_selector_template (void);
189 static void build_category_template (void);
190 static void build_super_template (void);
191 static tree build_protocol_initializer (tree, tree, tree, tree, tree);
192 static tree get_class_ivars (tree, bool);
193 static tree generate_protocol_list (tree);
194 static void build_protocol_reference (tree);
197 static void objc_generate_cxx_cdtors (void);
200 static const char *synth_id_with_class_suffix (const char *, tree);
202 /* Hash tables to manage the global pool of method prototypes. */
204 hash *nst_method_hash_list = 0;
205 hash *cls_method_hash_list = 0;
207 static hash hash_lookup (hash *, tree);
208 static tree lookup_method (tree, tree);
209 static tree lookup_method_static (tree, tree, int);
213 class_names, /* class, category, protocol, module names */
214 meth_var_names, /* method and variable names */
215 meth_var_types /* method and variable type descriptors */
218 static tree add_objc_string (tree, enum string_section);
219 static tree build_objc_string_decl (enum string_section);
220 static void build_selector_table_decl (void);
222 /* Protocol additions. */
224 static tree lookup_protocol (tree);
225 static tree lookup_and_install_protocols (tree);
229 static void encode_type_qualifiers (tree);
230 static void encode_type (tree, int, int);
231 static void encode_field_decl (tree, int, int);
234 static void really_start_method (tree, tree);
236 static void really_start_method (tree, struct c_arg_info *);
238 static int comp_proto_with_proto (tree, tree, int);
239 static void objc_push_parm (tree);
241 static tree objc_get_parm_info (int);
243 static struct c_arg_info *objc_get_parm_info (int);
246 /* Utilities for debugging and error diagnostics. */
248 static char *gen_type_name (tree);
249 static char *gen_type_name_0 (tree);
250 static char *gen_method_decl (tree);
251 static char *gen_declaration (tree);
253 /* Everything else. */
255 static tree create_field_decl (tree, const char *);
256 static void add_class_reference (tree);
257 static void build_protocol_template (void);
258 static tree encode_method_prototype (tree);
259 static void generate_classref_translation_entry (tree);
260 static void handle_class_ref (tree);
261 static void generate_struct_by_value_array (void)
263 static void mark_referenced_methods (void);
264 static void generate_objc_image_info (void);
266 /*** Private Interface (data) ***/
268 /* Reserved tag definitions. */
270 #define OBJECT_TYPEDEF_NAME "id"
271 #define CLASS_TYPEDEF_NAME "Class"
273 #define TAG_OBJECT "objc_object"
274 #define TAG_CLASS "objc_class"
275 #define TAG_SUPER "objc_super"
276 #define TAG_SELECTOR "objc_selector"
278 #define UTAG_CLASS "_objc_class"
279 #define UTAG_IVAR "_objc_ivar"
280 #define UTAG_IVAR_LIST "_objc_ivar_list"
281 #define UTAG_METHOD "_objc_method"
282 #define UTAG_METHOD_LIST "_objc_method_list"
283 #define UTAG_CATEGORY "_objc_category"
284 #define UTAG_MODULE "_objc_module"
285 #define UTAG_SYMTAB "_objc_symtab"
286 #define UTAG_SUPER "_objc_super"
287 #define UTAG_SELECTOR "_objc_selector"
289 #define UTAG_PROTOCOL "_objc_protocol"
290 #define UTAG_METHOD_PROTOTYPE "_objc_method_prototype"
291 #define UTAG_METHOD_PROTOTYPE_LIST "_objc__method_prototype_list"
293 /* Note that the string object global name is only needed for the
295 #define STRING_OBJECT_GLOBAL_FORMAT "_%sClassReference"
297 #define PROTOCOL_OBJECT_CLASS_NAME "Protocol"
299 static const char *TAG_GETCLASS;
300 static const char *TAG_GETMETACLASS;
301 static const char *TAG_MSGSEND;
302 static const char *TAG_MSGSENDSUPER;
303 /* The NeXT Objective-C messenger may have two extra entry points, for use
304 when returning a structure. */
305 static const char *TAG_MSGSEND_STRET;
306 static const char *TAG_MSGSENDSUPER_STRET;
307 static const char *default_constant_string_class_name;
309 /* Runtime metadata flags. */
310 #define CLS_FACTORY 0x0001L
311 #define CLS_META 0x0002L
312 #define CLS_HAS_CXX_STRUCTORS 0x2000L
314 #define OBJC_MODIFIER_STATIC 0x00000001
315 #define OBJC_MODIFIER_FINAL 0x00000002
316 #define OBJC_MODIFIER_PUBLIC 0x00000004
317 #define OBJC_MODIFIER_PRIVATE 0x00000008
318 #define OBJC_MODIFIER_PROTECTED 0x00000010
319 #define OBJC_MODIFIER_NATIVE 0x00000020
320 #define OBJC_MODIFIER_SYNCHRONIZED 0x00000040
321 #define OBJC_MODIFIER_ABSTRACT 0x00000080
322 #define OBJC_MODIFIER_VOLATILE 0x00000100
323 #define OBJC_MODIFIER_TRANSIENT 0x00000200
324 #define OBJC_MODIFIER_NONE_SPECIFIED 0x80000000
326 /* NeXT-specific tags. */
328 #define TAG_MSGSEND_NONNIL "objc_msgSendNonNil"
329 #define TAG_MSGSEND_NONNIL_STRET "objc_msgSendNonNil_stret"
330 #define TAG_EXCEPTIONEXTRACT "objc_exception_extract"
331 #define TAG_EXCEPTIONTRYENTER "objc_exception_try_enter"
332 #define TAG_EXCEPTIONTRYEXIT "objc_exception_try_exit"
333 #define TAG_EXCEPTIONMATCH "objc_exception_match"
334 #define TAG_EXCEPTIONTHROW "objc_exception_throw"
335 #define TAG_SYNCENTER "objc_sync_enter"
336 #define TAG_SYNCEXIT "objc_sync_exit"
337 #define TAG_SETJMP "_setjmp"
338 #define UTAG_EXCDATA "_objc_exception_data"
340 #define TAG_ASSIGNIVAR "objc_assign_ivar"
341 #define TAG_ASSIGNGLOBAL "objc_assign_global"
342 #define TAG_ASSIGNSTRONGCAST "objc_assign_strongCast"
344 /* Branch entry points. All that matters here are the addresses;
345 functions with these names do not really exist in libobjc. */
347 #define TAG_MSGSEND_FAST "objc_msgSend_Fast"
348 #define TAG_ASSIGNIVAR_FAST "objc_assign_ivar_Fast"
350 #define TAG_CXX_CONSTRUCT ".cxx_construct"
351 #define TAG_CXX_DESTRUCT ".cxx_destruct"
353 /* GNU-specific tags. */
355 #define TAG_EXECCLASS "__objc_exec_class"
356 #define TAG_GNUINIT "__objc_gnu_init"
358 /* Flags for lookup_method_static(). */
359 #define OBJC_LOOKUP_CLASS 1 /* Look for class methods. */
360 #define OBJC_LOOKUP_NO_SUPER 2 /* Do not examine superclasses. */
362 /* The OCTI_... enumeration itself is in objc/objc-act.h. */
363 tree objc_global_trees[OCTI_MAX];
365 static void handle_impent (struct imp_entry *);
367 struct imp_entry *imp_list = 0;
368 int imp_count = 0; /* `@implementation' */
369 int cat_count = 0; /* `@category' */
371 enum tree_code objc_inherit_code;
372 int objc_public_flag;
374 /* Use to generate method labels. */
375 static int method_slot = 0;
379 static char *errbuf; /* Buffer for error diagnostics */
381 /* Data imported from tree.c. */
383 extern enum debug_info_type write_symbols;
385 /* Data imported from toplev.c. */
387 extern const char *dump_base_name;
389 static int flag_typed_selectors;
391 /* Store all constructed constant strings in a hash table so that
392 they get uniqued properly. */
394 struct GTY(()) string_descriptor {
395 /* The literal argument . */
398 /* The resulting constant string. */
402 static GTY((param_is (struct string_descriptor))) htab_t string_htab;
404 /* Store the EH-volatilized types in a hash table, for easy retrieval. */
405 struct GTY(()) volatilized_type {
409 static GTY((param_is (struct volatilized_type))) htab_t volatilized_htab;
411 FILE *gen_declaration_file;
413 /* Tells "encode_pointer/encode_aggregate" whether we are generating
414 type descriptors for instance variables (as opposed to methods).
415 Type descriptors for instance variables contain more information
416 than methods (for static typing and embedded structures). */
418 static int generating_instance_variables = 0;
420 /* For building an objc struct. These may not be used when this file
421 is compiled as part of obj-c++. */
423 static bool objc_building_struct;
424 static struct c_struct_parse_info *objc_struct_info ATTRIBUTE_UNUSED;
426 /* Start building a struct for objc. */
429 objc_start_struct (tree name)
431 gcc_assert (!objc_building_struct);
432 objc_building_struct = true;
433 return start_struct (input_location, RECORD_TYPE, name, &objc_struct_info);
436 /* Finish building a struct for objc. */
439 objc_finish_struct (tree type, tree fieldlist)
441 gcc_assert (objc_building_struct);
442 objc_building_struct = false;
443 return finish_struct (input_location, type, fieldlist, NULL_TREE,
447 /* Some platforms pass small structures through registers versus
448 through an invisible pointer. Determine at what size structure is
449 the transition point between the two possibilities. */
452 generate_struct_by_value_array (void)
455 tree field_decl, field_decl_chain;
457 int aggregate_in_mem[32];
460 /* Presumably no platform passes 32 byte structures in a register. */
461 for (i = 1; i < 32; i++)
465 /* Create an unnamed struct that has `i' character components */
466 type = objc_start_struct (NULL_TREE);
468 strcpy (buffer, "c1");
469 field_decl = create_field_decl (char_type_node,
471 field_decl_chain = field_decl;
473 for (j = 1; j < i; j++)
475 sprintf (buffer, "c%d", j + 1);
476 field_decl = create_field_decl (char_type_node,
478 chainon (field_decl_chain, field_decl);
480 objc_finish_struct (type, field_decl_chain);
482 aggregate_in_mem[i] = aggregate_value_p (type, 0);
483 if (!aggregate_in_mem[i])
487 /* We found some structures that are returned in registers instead of memory
488 so output the necessary data. */
491 for (i = 31; i >= 0; i--)
492 if (!aggregate_in_mem[i])
494 printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n\n", i);
496 /* The first member of the structure is always 0 because we don't handle
497 structures with 0 members */
498 printf ("static int struct_forward_array[] = {\n 0");
500 for (j = 1; j <= i; j++)
501 printf (", %d", aggregate_in_mem[j]);
512 if (cxx_init () == false)
514 if (c_objc_common_init () == false)
518 /* If gen_declaration desired, open the output file. */
519 if (flag_gen_declaration)
521 register char * const dumpname = concat (dump_base_name, ".decl", NULL);
522 gen_declaration_file = fopen (dumpname, "w");
523 if (gen_declaration_file == 0)
524 fatal_error ("can't open %s: %m", dumpname);
528 if (flag_next_runtime)
530 TAG_GETCLASS = "objc_getClass";
531 TAG_GETMETACLASS = "objc_getMetaClass";
532 TAG_MSGSEND = "objc_msgSend";
533 TAG_MSGSENDSUPER = "objc_msgSendSuper";
534 TAG_MSGSEND_STRET = "objc_msgSend_stret";
535 TAG_MSGSENDSUPER_STRET = "objc_msgSendSuper_stret";
536 default_constant_string_class_name = "NSConstantString";
540 TAG_GETCLASS = "objc_get_class";
541 TAG_GETMETACLASS = "objc_get_meta_class";
542 TAG_MSGSEND = "objc_msg_lookup";
543 TAG_MSGSENDSUPER = "objc_msg_lookup_super";
544 /* GNU runtime does not provide special functions to support
545 structure-returning methods. */
546 default_constant_string_class_name = "NXConstantString";
547 flag_typed_selectors = 1;
552 if (print_struct_values && !flag_compare_debug)
553 generate_struct_by_value_array ();
559 objc_finish_file (void)
561 mark_referenced_methods ();
564 /* We need to instantiate templates _before_ we emit ObjC metadata;
565 if we do not, some metadata (such as selectors) may go missing. */
567 instantiate_pending_templates (0);
570 /* Finalize Objective-C runtime data. No need to generate tables
571 and code if only checking syntax, or if generating a PCH file. */
572 if (!flag_syntax_only && !pch_file)
575 if (gen_declaration_file)
576 fclose (gen_declaration_file);
579 /* Return the first occurrence of a method declaration corresponding
580 to sel_name in rproto_list. Search rproto_list recursively.
581 If is_class is 0, search for instance methods, otherwise for class
584 lookup_method_in_protocol_list (tree rproto_list, tree sel_name,
590 for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
592 p = TREE_VALUE (rproto);
594 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
596 if ((fnd = lookup_method (is_class
597 ? PROTOCOL_CLS_METHODS (p)
598 : PROTOCOL_NST_METHODS (p), sel_name)))
600 else if (PROTOCOL_LIST (p))
601 fnd = lookup_method_in_protocol_list (PROTOCOL_LIST (p),
606 ; /* An identifier...if we could not find a protocol. */
617 lookup_protocol_in_reflist (tree rproto_list, tree lproto)
621 /* Make sure the protocol is supported by the object on the rhs. */
622 if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE)
625 for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
627 p = TREE_VALUE (rproto);
629 if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
634 else if (PROTOCOL_LIST (p))
635 fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto);
644 ; /* An identifier...if we could not find a protocol. */
651 objc_start_class_interface (tree klass, tree super_class, tree protos)
653 objc_interface_context
655 = start_class (CLASS_INTERFACE_TYPE, klass, super_class, protos);
656 objc_public_flag = 0;
660 objc_start_category_interface (tree klass, tree categ, tree protos)
662 objc_interface_context
663 = start_class (CATEGORY_INTERFACE_TYPE, klass, categ, protos);
665 = continue_class (objc_interface_context);
669 objc_start_protocol (tree name, tree protos)
671 objc_interface_context
672 = start_protocol (PROTOCOL_INTERFACE_TYPE, name, protos);
676 objc_continue_interface (void)
679 = continue_class (objc_interface_context);
683 objc_finish_interface (void)
685 finish_class (objc_interface_context);
686 objc_interface_context = NULL_TREE;
690 objc_start_class_implementation (tree klass, tree super_class)
692 objc_implementation_context
694 = start_class (CLASS_IMPLEMENTATION_TYPE, klass, super_class, NULL_TREE);
695 objc_public_flag = 0;
699 objc_start_category_implementation (tree klass, tree categ)
701 objc_implementation_context
702 = start_class (CATEGORY_IMPLEMENTATION_TYPE, klass, categ, NULL_TREE);
704 = continue_class (objc_implementation_context);
708 objc_continue_implementation (void)
711 = continue_class (objc_implementation_context);
715 objc_finish_implementation (void)
718 if (flag_objc_call_cxx_cdtors)
719 objc_generate_cxx_cdtors ();
722 if (objc_implementation_context)
724 finish_class (objc_implementation_context);
725 objc_ivar_chain = NULL_TREE;
726 objc_implementation_context = NULL_TREE;
729 warning (0, "%<@end%> must appear in an @implementation context");
733 objc_set_visibility (int visibility)
735 objc_public_flag = visibility;
739 objc_set_method_type (enum tree_code type)
741 objc_inherit_code = (type == PLUS_EXPR
743 : INSTANCE_METHOD_DECL);
747 objc_build_method_signature (tree rettype, tree selector,
748 tree optparms, bool ellipsis)
750 return build_method_decl (objc_inherit_code, rettype, selector,
755 objc_add_method_declaration (tree decl)
757 if (!objc_interface_context)
758 fatal_error ("method declaration not in @interface context");
760 objc_add_method (objc_interface_context,
762 objc_inherit_code == CLASS_METHOD_DECL);
766 objc_start_method_definition (tree decl)
768 if (!objc_implementation_context)
769 fatal_error ("method definition not in @implementation context");
771 objc_add_method (objc_implementation_context,
773 objc_inherit_code == CLASS_METHOD_DECL);
774 start_method_def (decl);
778 objc_add_instance_variable (tree decl)
780 (void) add_instance_variable (objc_ivar_context,
785 /* Return 1 if IDENT is an ObjC/ObjC++ reserved keyword in the context of
789 objc_is_reserved_word (tree ident)
791 unsigned char code = C_RID_CODE (ident);
793 return (OBJC_IS_AT_KEYWORD (code)
794 || code == RID_CLASS || code == RID_PUBLIC
795 || code == RID_PROTECTED || code == RID_PRIVATE
796 || code == RID_TRY || code == RID_THROW || code == RID_CATCH);
799 /* Return true if TYPE is 'id'. */
802 objc_is_object_id (tree type)
804 return OBJC_TYPE_NAME (type) == objc_object_id;
808 objc_is_class_id (tree type)
810 return OBJC_TYPE_NAME (type) == objc_class_id;
813 /* Construct a C struct with same name as KLASS, a base struct with tag
814 SUPER_NAME (if any), and FIELDS indicated. */
817 objc_build_struct (tree klass, tree fields, tree super_name)
819 tree name = CLASS_NAME (klass);
820 tree s = objc_start_struct (name);
821 tree super = (super_name ? xref_tag (RECORD_TYPE, super_name) : NULL_TREE);
822 tree t, objc_info = NULL_TREE;
826 /* Prepend a packed variant of the base class into the layout. This
827 is necessary to preserve ObjC ABI compatibility. */
828 tree base = build_decl (input_location,
829 FIELD_DECL, NULL_TREE, super);
830 tree field = TYPE_FIELDS (super);
832 while (field && TREE_CHAIN (field)
833 && TREE_CODE (TREE_CHAIN (field)) == FIELD_DECL)
834 field = TREE_CHAIN (field);
836 /* For ObjC ABI purposes, the "packed" size of a base class is
837 the sum of the offset and the size (in bits) of the last field
840 = (field && TREE_CODE (field) == FIELD_DECL
841 ? size_binop (PLUS_EXPR,
842 size_binop (PLUS_EXPR,
845 convert (bitsizetype,
846 DECL_FIELD_OFFSET (field)),
847 bitsize_int (BITS_PER_UNIT)),
848 DECL_FIELD_BIT_OFFSET (field)),
850 : bitsize_zero_node);
851 DECL_SIZE_UNIT (base)
852 = size_binop (FLOOR_DIV_EXPR, convert (sizetype, DECL_SIZE (base)),
853 size_int (BITS_PER_UNIT));
854 DECL_ARTIFICIAL (base) = 1;
855 DECL_ALIGN (base) = 1;
856 DECL_FIELD_CONTEXT (base) = s;
858 DECL_FIELD_IS_BASE (base) = 1;
861 TREE_NO_WARNING (fields) = 1; /* Suppress C++ ABI warnings -- we */
862 #endif /* are following the ObjC ABI here. */
863 TREE_CHAIN (base) = fields;
867 /* NB: Calling finish_struct() may cause type TYPE_LANG_SPECIFIC fields
868 in all variants of this RECORD_TYPE to be clobbered, but it is therein
869 that we store protocol conformance info (e.g., 'NSObject <MyProtocol>').
870 Hence, we must squirrel away the ObjC-specific information before calling
871 finish_struct(), and then reinstate it afterwards. */
873 for (t = TYPE_NEXT_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t))
875 if (!TYPE_HAS_OBJC_INFO (t))
877 INIT_TYPE_OBJC_INFO (t);
878 TYPE_OBJC_INTERFACE (t) = klass;
881 = chainon (objc_info,
882 build_tree_list (NULL_TREE, TYPE_OBJC_INFO (t)));
885 /* Point the struct at its related Objective-C class. */
886 INIT_TYPE_OBJC_INFO (s);
887 TYPE_OBJC_INTERFACE (s) = klass;
889 s = objc_finish_struct (s, fields);
891 for (t = TYPE_NEXT_VARIANT (s); t;
892 t = TYPE_NEXT_VARIANT (t), objc_info = TREE_CHAIN (objc_info))
894 TYPE_OBJC_INFO (t) = TREE_VALUE (objc_info);
895 /* Replace the IDENTIFIER_NODE with an actual @interface. */
896 TYPE_OBJC_INTERFACE (t) = klass;
899 /* Use TYPE_BINFO structures to point at the super class, if any. */
900 objc_xref_basetypes (s, super);
902 /* Mark this struct as a class template. */
903 CLASS_STATIC_TEMPLATE (klass) = s;
908 /* Build a type differing from TYPE only in that TYPE_VOLATILE is set.
909 Unlike tree.c:build_qualified_type(), preserve TYPE_LANG_SPECIFIC in the
912 objc_build_volatilized_type (tree type)
916 /* Check if we have not constructed the desired variant already. */
917 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
919 /* The type qualifiers must (obviously) match up. */
920 if (!TYPE_VOLATILE (t)
921 || (TYPE_READONLY (t) != TYPE_READONLY (type))
922 || (TYPE_RESTRICT (t) != TYPE_RESTRICT (type)))
925 /* For pointer types, the pointees (and hence their TYPE_LANG_SPECIFIC
926 info, if any) must match up. */
927 if (POINTER_TYPE_P (t)
928 && (TREE_TYPE (t) != TREE_TYPE (type)))
931 /* Everything matches up! */
935 /* Ok, we could not re-use any of the pre-existing variants. Create
937 t = build_variant_type_copy (type);
938 TYPE_VOLATILE (t) = 1;
940 /* Set up the canonical type information. */
941 if (TYPE_STRUCTURAL_EQUALITY_P (type))
942 SET_TYPE_STRUCTURAL_EQUALITY (t);
943 else if (TYPE_CANONICAL (type) != type)
944 TYPE_CANONICAL (t) = objc_build_volatilized_type (TYPE_CANONICAL (type));
946 TYPE_CANONICAL (t) = t;
951 /* Mark DECL as being 'volatile' for purposes of Darwin
952 _setjmp()/_longjmp() exception handling. Called from
953 objc_mark_locals_volatile(). */
955 objc_volatilize_decl (tree decl)
957 /* Do not mess with variables that are 'static' or (already)
959 if (!TREE_THIS_VOLATILE (decl) && !TREE_STATIC (decl)
960 && (TREE_CODE (decl) == VAR_DECL
961 || TREE_CODE (decl) == PARM_DECL))
963 tree t = TREE_TYPE (decl);
964 struct volatilized_type key;
967 t = objc_build_volatilized_type (t);
969 loc = htab_find_slot (volatilized_htab, &key, INSERT);
973 *loc = ggc_alloc (sizeof (key));
974 ((struct volatilized_type *) *loc)->type = t;
977 TREE_TYPE (decl) = t;
978 TREE_THIS_VOLATILE (decl) = 1;
979 TREE_SIDE_EFFECTS (decl) = 1;
980 DECL_REGISTER (decl) = 0;
982 C_DECL_REGISTER (decl) = 0;
987 /* Check if protocol PROTO is adopted (directly or indirectly) by class CLS
988 (including its categories and superclasses) or by object type TYP.
989 Issue a warning if PROTO is not adopted anywhere and WARN is set. */
992 objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn)
994 bool class_type = (cls != NULL_TREE);
1000 /* Check protocols adopted by the class and its categories. */
1001 for (c = cls; c; c = CLASS_CATEGORY_LIST (c))
1003 if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c), proto))
1007 /* Repeat for superclasses. */
1008 cls = lookup_interface (CLASS_SUPER_NAME (cls));
1011 /* Check for any protocols attached directly to the object type. */
1012 if (TYPE_HAS_OBJC_INFO (typ))
1014 if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ), proto))
1021 gen_type_name_0 (class_type ? typ : TYPE_POINTER_TO (typ));
1022 /* NB: Types 'id' and 'Class' cannot reasonably be described as
1023 "implementing" a given protocol, since they do not have an
1026 warning (0, "class %qs does not implement the %qE protocol",
1027 identifier_to_locale (errbuf), PROTOCOL_NAME (proto));
1029 warning (0, "type %qs does not conform to the %qE protocol",
1030 identifier_to_locale (errbuf), PROTOCOL_NAME (proto));
1036 /* Check if class RCLS and instance struct type RTYP conform to at least the
1037 same protocols that LCLS and LTYP conform to. */
1040 objc_compare_protocols (tree lcls, tree ltyp, tree rcls, tree rtyp, bool warn)
1043 bool have_lproto = false;
1047 /* NB: We do _not_ look at categories defined for LCLS; these may or
1048 may not get loaded in, and therefore it is unreasonable to require
1049 that RCLS/RTYP must implement any of their protocols. */
1050 for (p = CLASS_PROTOCOL_LIST (lcls); p; p = TREE_CHAIN (p))
1054 if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
1058 /* Repeat for superclasses. */
1059 lcls = lookup_interface (CLASS_SUPER_NAME (lcls));
1062 /* Check for any protocols attached directly to the object type. */
1063 if (TYPE_HAS_OBJC_INFO (ltyp))
1065 for (p = TYPE_OBJC_PROTOCOL_LIST (ltyp); p; p = TREE_CHAIN (p))
1069 if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
1074 /* NB: If LTYP and LCLS have no protocols to search for, return 'true'
1075 vacuously, _unless_ RTYP is a protocol-qualified 'id'. We can get
1076 away with simply checking for 'id' or 'Class' (!RCLS), since this
1077 routine will not get called in other cases. */
1078 return have_lproto || (rcls != NULL_TREE);
1081 /* Determine if it is permissible to assign (if ARGNO is greater than -3)
1082 an instance of RTYP to an instance of LTYP or to compare the two
1083 (if ARGNO is equal to -3), per ObjC type system rules. Before
1084 returning 'true', this routine may issue warnings related to, e.g.,
1085 protocol conformance. When returning 'false', the routine must
1086 produce absolutely no warnings; the C or C++ front-end will do so
1087 instead, if needed. If either LTYP or RTYP is not an Objective-C type,
1088 the routine must return 'false'.
1090 The ARGNO parameter is encoded as follows:
1091 >= 1 Parameter number (CALLEE contains function being called);
1095 -3 Comparison (LTYP and RTYP may match in either direction). */
1098 objc_compare_types (tree ltyp, tree rtyp, int argno, tree callee)
1100 tree lcls, rcls, lproto, rproto;
1101 bool pointers_compatible;
1103 /* We must be dealing with pointer types */
1104 if (!POINTER_TYPE_P (ltyp) || !POINTER_TYPE_P (rtyp))
1109 ltyp = TREE_TYPE (ltyp); /* Remove indirections. */
1110 rtyp = TREE_TYPE (rtyp);
1112 while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp));
1114 /* Past this point, we are only interested in ObjC class instances,
1115 or 'id' or 'Class'. */
1116 if (TREE_CODE (ltyp) != RECORD_TYPE || TREE_CODE (rtyp) != RECORD_TYPE)
1119 if (!objc_is_object_id (ltyp) && !objc_is_class_id (ltyp)
1120 && !TYPE_HAS_OBJC_INFO (ltyp))
1123 if (!objc_is_object_id (rtyp) && !objc_is_class_id (rtyp)
1124 && !TYPE_HAS_OBJC_INFO (rtyp))
1127 /* Past this point, we are committed to returning 'true' to the caller.
1128 However, we can still warn about type and/or protocol mismatches. */
1130 if (TYPE_HAS_OBJC_INFO (ltyp))
1132 lcls = TYPE_OBJC_INTERFACE (ltyp);
1133 lproto = TYPE_OBJC_PROTOCOL_LIST (ltyp);
1136 lcls = lproto = NULL_TREE;
1138 if (TYPE_HAS_OBJC_INFO (rtyp))
1140 rcls = TYPE_OBJC_INTERFACE (rtyp);
1141 rproto = TYPE_OBJC_PROTOCOL_LIST (rtyp);
1144 rcls = rproto = NULL_TREE;
1146 /* If we could not find an @interface declaration, we must have
1147 only seen a @class declaration; for purposes of type comparison,
1148 treat it as a stand-alone (root) class. */
1150 if (lcls && TREE_CODE (lcls) == IDENTIFIER_NODE)
1153 if (rcls && TREE_CODE (rcls) == IDENTIFIER_NODE)
1156 /* If either type is an unqualified 'id', we're done. */
1157 if ((!lproto && objc_is_object_id (ltyp))
1158 || (!rproto && objc_is_object_id (rtyp)))
1161 pointers_compatible = (TYPE_MAIN_VARIANT (ltyp) == TYPE_MAIN_VARIANT (rtyp));
1163 /* If the underlying types are the same, and at most one of them has
1164 a protocol list, we do not need to issue any diagnostics. */
1165 if (pointers_compatible && (!lproto || !rproto))
1168 /* If exactly one of the types is 'Class', issue a diagnostic; any
1169 exceptions of this rule have already been handled. */
1170 if (objc_is_class_id (ltyp) ^ objc_is_class_id (rtyp))
1171 pointers_compatible = false;
1172 /* Otherwise, check for inheritance relations. */
1175 if (!pointers_compatible)
1177 = (objc_is_object_id (ltyp) || objc_is_object_id (rtyp));
1179 if (!pointers_compatible)
1180 pointers_compatible = DERIVED_FROM_P (ltyp, rtyp);
1182 if (!pointers_compatible && argno == -3)
1183 pointers_compatible = DERIVED_FROM_P (rtyp, ltyp);
1186 /* If the pointers match modulo protocols, check for protocol conformance
1188 if (pointers_compatible)
1190 pointers_compatible = objc_compare_protocols (lcls, ltyp, rcls, rtyp,
1193 if (!pointers_compatible && argno == -3)
1194 pointers_compatible = objc_compare_protocols (rcls, rtyp, lcls, ltyp,
1198 if (!pointers_compatible)
1200 /* NB: For the time being, we shall make our warnings look like their
1201 C counterparts. In the future, we may wish to make them more
1206 warning (0, "comparison of distinct Objective-C types lacks a cast");
1210 warning (0, "initialization from distinct Objective-C type");
1214 warning (0, "assignment from distinct Objective-C type");
1218 warning (0, "distinct Objective-C type in return");
1222 warning (0, "passing argument %d of %qE from distinct "
1223 "Objective-C type", argno, callee);
1231 /* Check if LTYP and RTYP have the same type qualifiers. If either type
1232 lives in the volatilized hash table, ignore the 'volatile' bit when
1233 making the comparison. */
1236 objc_type_quals_match (tree ltyp, tree rtyp)
1238 int lquals = TYPE_QUALS (ltyp), rquals = TYPE_QUALS (rtyp);
1239 struct volatilized_type key;
1243 if (htab_find_slot (volatilized_htab, &key, NO_INSERT))
1244 lquals &= ~TYPE_QUAL_VOLATILE;
1248 if (htab_find_slot (volatilized_htab, &key, NO_INSERT))
1249 rquals &= ~TYPE_QUAL_VOLATILE;
1251 return (lquals == rquals);
1255 /* Determine if CHILD is derived from PARENT. The routine assumes that
1256 both parameters are RECORD_TYPEs, and is non-reflexive. */
1259 objc_derived_from_p (tree parent, tree child)
1261 parent = TYPE_MAIN_VARIANT (parent);
1263 for (child = TYPE_MAIN_VARIANT (child);
1264 TYPE_BINFO (child) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child));)
1266 child = TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO
1267 (TYPE_BINFO (child),
1270 if (child == parent)
1279 objc_build_component_ref (tree datum, tree component)
1281 /* If COMPONENT is NULL, the caller is referring to the anonymous
1282 base class field. */
1285 tree base = TYPE_FIELDS (TREE_TYPE (datum));
1287 return build3 (COMPONENT_REF, TREE_TYPE (base), datum, base, NULL_TREE);
1290 /* The 'build_component_ref' routine has been removed from the C++
1291 front-end, but 'finish_class_member_access_expr' seems to be
1292 a worthy substitute. */
1294 return finish_class_member_access_expr (datum, component, false,
1295 tf_warning_or_error);
1297 return build_component_ref (input_location, datum, component);
1301 /* Recursively copy inheritance information rooted at BINFO. To do this,
1302 we emulate the song and dance performed by cp/tree.c:copy_binfo(). */
1305 objc_copy_binfo (tree binfo)
1307 tree btype = BINFO_TYPE (binfo);
1308 tree binfo2 = make_tree_binfo (BINFO_N_BASE_BINFOS (binfo));
1312 BINFO_TYPE (binfo2) = btype;
1313 BINFO_OFFSET (binfo2) = BINFO_OFFSET (binfo);
1314 BINFO_BASE_ACCESSES (binfo2) = BINFO_BASE_ACCESSES (binfo);
1316 /* Recursively copy base binfos of BINFO. */
1317 for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1319 tree base_binfo2 = objc_copy_binfo (base_binfo);
1321 BINFO_INHERITANCE_CHAIN (base_binfo2) = binfo2;
1322 BINFO_BASE_APPEND (binfo2, base_binfo2);
1328 /* Record superclass information provided in BASETYPE for ObjC class REF.
1329 This is loosely based on cp/decl.c:xref_basetypes(). */
1332 objc_xref_basetypes (tree ref, tree basetype)
1334 tree binfo = make_tree_binfo (basetype ? 1 : 0);
1336 TYPE_BINFO (ref) = binfo;
1337 BINFO_OFFSET (binfo) = size_zero_node;
1338 BINFO_TYPE (binfo) = ref;
1342 tree base_binfo = objc_copy_binfo (TYPE_BINFO (basetype));
1344 BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
1345 BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, 1);
1346 BINFO_BASE_APPEND (binfo, base_binfo);
1347 BINFO_BASE_ACCESS_APPEND (binfo, access_public_node);
1352 volatilized_hash (const void *ptr)
1354 const_tree const typ = ((const struct volatilized_type *)ptr)->type;
1356 return htab_hash_pointer(typ);
1360 volatilized_eq (const void *ptr1, const void *ptr2)
1362 const_tree const typ1 = ((const struct volatilized_type *)ptr1)->type;
1363 const_tree const typ2 = ((const struct volatilized_type *)ptr2)->type;
1365 return typ1 == typ2;
1368 /* Called from finish_decl. */
1371 objc_check_decl (tree decl)
1373 tree type = TREE_TYPE (decl);
1375 if (TREE_CODE (type) != RECORD_TYPE)
1377 if (OBJC_TYPE_NAME (type) && (type = objc_is_class_name (OBJC_TYPE_NAME (type))))
1378 error ("statically allocated instance of Objective-C class %qE",
1382 /* Construct a PROTOCOLS-qualified variant of INTERFACE, where INTERFACE may
1383 either name an Objective-C class, or refer to the special 'id' or 'Class'
1384 types. If INTERFACE is not a valid ObjC type, just return it unchanged. */
1387 objc_get_protocol_qualified_type (tree interface, tree protocols)
1389 /* If INTERFACE is not provided, default to 'id'. */
1390 tree type = (interface ? objc_is_id (interface) : objc_object_type);
1391 bool is_ptr = (type != NULL_TREE);
1395 type = objc_is_class_name (interface);
1398 type = xref_tag (RECORD_TYPE, type);
1405 type = build_variant_type_copy (type);
1407 /* For pointers (i.e., 'id' or 'Class'), attach the protocol(s)
1411 tree orig_pointee_type = TREE_TYPE (type);
1412 TREE_TYPE (type) = build_variant_type_copy (orig_pointee_type);
1414 /* Set up the canonical type information. */
1415 TYPE_CANONICAL (type)
1416 = TYPE_CANONICAL (TYPE_POINTER_TO (orig_pointee_type));
1418 TYPE_POINTER_TO (TREE_TYPE (type)) = type;
1419 type = TREE_TYPE (type);
1422 /* Look up protocols and install in lang specific list. */
1423 DUP_TYPE_OBJC_INFO (type, TYPE_MAIN_VARIANT (type));
1424 TYPE_OBJC_PROTOCOL_LIST (type) = lookup_and_install_protocols (protocols);
1426 /* For RECORD_TYPEs, point to the @interface; for 'id' and 'Class',
1427 return the pointer to the new pointee variant. */
1429 type = TYPE_POINTER_TO (type);
1431 TYPE_OBJC_INTERFACE (type)
1432 = TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type));
1438 /* Check for circular dependencies in protocols. The arguments are
1439 PROTO, the protocol to check, and LIST, a list of protocol it
1443 check_protocol_recursively (tree proto, tree list)
1447 for (p = list; p; p = TREE_CHAIN (p))
1449 tree pp = TREE_VALUE (p);
1451 if (TREE_CODE (pp) == IDENTIFIER_NODE)
1452 pp = lookup_protocol (pp);
1455 fatal_error ("protocol %qE has circular dependency",
1456 PROTOCOL_NAME (pp));
1458 check_protocol_recursively (proto, PROTOCOL_LIST (pp));
1462 /* Look up PROTOCOLS, and return a list of those that are found.
1463 If none are found, return NULL. */
1466 lookup_and_install_protocols (tree protocols)
1469 tree return_value = NULL_TREE;
1471 for (proto = protocols; proto; proto = TREE_CHAIN (proto))
1473 tree ident = TREE_VALUE (proto);
1474 tree p = lookup_protocol (ident);
1477 return_value = chainon (return_value,
1478 build_tree_list (NULL_TREE, p));
1479 else if (ident != error_mark_node)
1480 error ("cannot find protocol declaration for %qE",
1484 return return_value;
1487 /* Create a declaration for field NAME of a given TYPE. */
1490 create_field_decl (tree type, const char *name)
1492 return build_decl (input_location,
1493 FIELD_DECL, get_identifier (name), type);
1496 /* Create a global, static declaration for variable NAME of a given TYPE. The
1497 finish_var_decl() routine will need to be called on it afterwards. */
1500 start_var_decl (tree type, const char *name)
1502 tree var = build_decl (input_location,
1503 VAR_DECL, get_identifier (name), type);
1505 TREE_STATIC (var) = 1;
1506 DECL_INITIAL (var) = error_mark_node; /* A real initializer is coming... */
1507 DECL_IGNORED_P (var) = 1;
1508 DECL_ARTIFICIAL (var) = 1;
1509 DECL_CONTEXT (var) = NULL_TREE;
1511 DECL_THIS_STATIC (var) = 1; /* squash redeclaration errors */
1517 /* Finish off the variable declaration created by start_var_decl(). */
1520 finish_var_decl (tree var, tree initializer)
1522 finish_decl (var, input_location, initializer, NULL_TREE, NULL_TREE);
1523 /* Ensure that the variable actually gets output. */
1524 mark_decl_referenced (var);
1525 /* Mark the decl to avoid "defined but not used" warning. */
1526 TREE_USED (var) = 1;
1529 /* Find the decl for the constant string class reference. This is only
1530 used for the NeXT runtime. */
1533 setup_string_decl (void)
1538 /* %s in format will provide room for terminating null */
1539 length = strlen (STRING_OBJECT_GLOBAL_FORMAT)
1540 + strlen (constant_string_class_name);
1541 name = XNEWVEC (char, length);
1542 sprintf (name, STRING_OBJECT_GLOBAL_FORMAT,
1543 constant_string_class_name);
1544 constant_string_global_id = get_identifier (name);
1545 string_class_decl = lookup_name (constant_string_global_id);
1547 return string_class_decl;
1550 /* Purpose: "play" parser, creating/installing representations
1551 of the declarations that are required by Objective-C.
1555 type_spec--------->sc_spec
1556 (tree_list) (tree_list)
1559 identifier_node identifier_node */
1562 synth_module_prologue (void)
1565 enum debug_info_type save_write_symbols = write_symbols;
1566 const struct gcc_debug_hooks *const save_hooks = debug_hooks;
1568 /* Suppress outputting debug symbols, because
1569 dbxout_init hasn't been called yet. */
1570 write_symbols = NO_DEBUG;
1571 debug_hooks = &do_nothing_debug_hooks;
1574 push_lang_context (lang_name_c); /* extern "C" */
1577 /* The following are also defined in <objc/objc.h> and friends. */
1579 objc_object_id = get_identifier (TAG_OBJECT);
1580 objc_class_id = get_identifier (TAG_CLASS);
1582 objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
1583 objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id);
1585 objc_object_type = build_pointer_type (objc_object_reference);
1586 objc_class_type = build_pointer_type (objc_class_reference);
1588 objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME);
1589 objc_class_name = get_identifier (CLASS_TYPEDEF_NAME);
1591 /* Declare the 'id' and 'Class' typedefs. */
1593 type = lang_hooks.decls.pushdecl (build_decl (input_location,
1597 TREE_NO_WARNING (type) = 1;
1598 type = lang_hooks.decls.pushdecl (build_decl (input_location,
1602 TREE_NO_WARNING (type) = 1;
1604 /* Forward-declare '@interface Protocol'. */
1606 type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
1607 objc_declare_class (tree_cons (NULL_TREE, type, NULL_TREE));
1608 objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
1611 /* Declare type of selector-objects that represent an operation name. */
1613 if (flag_next_runtime)
1614 /* `struct objc_selector *' */
1616 = build_pointer_type (xref_tag (RECORD_TYPE,
1617 get_identifier (TAG_SELECTOR)));
1619 /* `const struct objc_selector *' */
1621 = build_pointer_type
1622 (build_qualified_type (xref_tag (RECORD_TYPE,
1623 get_identifier (TAG_SELECTOR)),
1626 /* Declare receiver type used for dispatching messages to 'super'. */
1628 /* `struct objc_super *' */
1629 objc_super_type = build_pointer_type (xref_tag (RECORD_TYPE,
1630 get_identifier (TAG_SUPER)));
1632 /* Declare pointers to method and ivar lists. */
1633 objc_method_list_ptr = build_pointer_type
1634 (xref_tag (RECORD_TYPE,
1635 get_identifier (UTAG_METHOD_LIST)));
1636 objc_method_proto_list_ptr
1637 = build_pointer_type (xref_tag (RECORD_TYPE,
1638 get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
1639 objc_ivar_list_ptr = build_pointer_type
1640 (xref_tag (RECORD_TYPE,
1641 get_identifier (UTAG_IVAR_LIST)));
1643 /* TREE_NOTHROW is cleared for the message-sending functions,
1644 because the function that gets called can throw in Obj-C++, or
1645 could itself call something that can throw even in Obj-C. */
1647 if (flag_next_runtime)
1649 /* NB: In order to call one of the ..._stret (struct-returning)
1650 functions, the function *MUST* first be cast to a signature that
1651 corresponds to the actual ObjC method being invoked. This is
1652 what is done by the build_objc_method_call() routine below. */
1654 /* id objc_msgSend (id, SEL, ...); */
1655 /* id objc_msgSendNonNil (id, SEL, ...); */
1656 /* id objc_msgSend_stret (id, SEL, ...); */
1657 /* id objc_msgSendNonNil_stret (id, SEL, ...); */
1659 = build_function_type (objc_object_type,
1660 tree_cons (NULL_TREE, objc_object_type,
1661 tree_cons (NULL_TREE, objc_selector_type,
1663 umsg_decl = add_builtin_function (TAG_MSGSEND,
1664 type, 0, NOT_BUILT_IN,
1666 umsg_nonnil_decl = add_builtin_function (TAG_MSGSEND_NONNIL,
1667 type, 0, NOT_BUILT_IN,
1669 umsg_stret_decl = add_builtin_function (TAG_MSGSEND_STRET,
1670 type, 0, NOT_BUILT_IN,
1672 umsg_nonnil_stret_decl = add_builtin_function (TAG_MSGSEND_NONNIL_STRET,
1673 type, 0, NOT_BUILT_IN,
1676 /* These can throw, because the function that gets called can throw
1677 in Obj-C++, or could itself call something that can throw even
1679 TREE_NOTHROW (umsg_decl) = 0;
1680 TREE_NOTHROW (umsg_nonnil_decl) = 0;
1681 TREE_NOTHROW (umsg_stret_decl) = 0;
1682 TREE_NOTHROW (umsg_nonnil_stret_decl) = 0;
1684 /* id objc_msgSend_Fast (id, SEL, ...)
1685 __attribute__ ((hard_coded_address (OFFS_MSGSEND_FAST))); */
1686 #ifdef OFFS_MSGSEND_FAST
1687 umsg_fast_decl = add_builtin_function (TAG_MSGSEND_FAST,
1688 type, 0, NOT_BUILT_IN,
1690 TREE_NOTHROW (umsg_fast_decl) = 0;
1691 DECL_ATTRIBUTES (umsg_fast_decl)
1692 = tree_cons (get_identifier ("hard_coded_address"),
1693 build_int_cst (NULL_TREE, OFFS_MSGSEND_FAST),
1696 /* No direct dispatch available. */
1697 umsg_fast_decl = umsg_decl;
1700 /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
1701 /* id objc_msgSendSuper_stret (struct objc_super *, SEL, ...); */
1703 = build_function_type (objc_object_type,
1704 tree_cons (NULL_TREE, objc_super_type,
1705 tree_cons (NULL_TREE, objc_selector_type,
1707 umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
1708 type, 0, NOT_BUILT_IN,
1710 umsg_super_stret_decl = add_builtin_function (TAG_MSGSENDSUPER_STRET,
1711 type, 0, NOT_BUILT_IN, 0,
1713 TREE_NOTHROW (umsg_super_decl) = 0;
1714 TREE_NOTHROW (umsg_super_stret_decl) = 0;
1718 /* GNU runtime messenger entry points. */
1720 /* typedef id (*IMP)(id, SEL, ...); */
1722 = build_pointer_type
1723 (build_function_type (objc_object_type,
1724 tree_cons (NULL_TREE, objc_object_type,
1725 tree_cons (NULL_TREE, objc_selector_type,
1728 /* IMP objc_msg_lookup (id, SEL); */
1730 = build_function_type (IMP_type,
1731 tree_cons (NULL_TREE, objc_object_type,
1732 tree_cons (NULL_TREE, objc_selector_type,
1733 OBJC_VOID_AT_END)));
1734 umsg_decl = add_builtin_function (TAG_MSGSEND,
1735 type, 0, NOT_BUILT_IN,
1737 TREE_NOTHROW (umsg_decl) = 0;
1739 /* IMP objc_msg_lookup_super (struct objc_super *, SEL); */
1741 = build_function_type (IMP_type,
1742 tree_cons (NULL_TREE, objc_super_type,
1743 tree_cons (NULL_TREE, objc_selector_type,
1744 OBJC_VOID_AT_END)));
1745 umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
1746 type, 0, NOT_BUILT_IN,
1748 TREE_NOTHROW (umsg_super_decl) = 0;
1750 /* The following GNU runtime entry point is called to initialize
1753 __objc_exec_class (void *); */
1755 = build_function_type (void_type_node,
1756 tree_cons (NULL_TREE, ptr_type_node,
1758 execclass_decl = add_builtin_function (TAG_EXECCLASS,
1759 type, 0, NOT_BUILT_IN,
1763 /* id objc_getClass (const char *); */
1765 type = build_function_type (objc_object_type,
1766 tree_cons (NULL_TREE,
1767 const_string_type_node,
1771 = add_builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN,
1774 /* id objc_getMetaClass (const char *); */
1776 objc_get_meta_class_decl
1777 = add_builtin_function (TAG_GETMETACLASS, type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
1779 build_class_template ();
1780 build_super_template ();
1781 build_protocol_template ();
1782 build_category_template ();
1783 build_objc_exception_stuff ();
1785 if (flag_next_runtime)
1786 build_next_objc_exception_stuff ();
1788 /* static SEL _OBJC_SELECTOR_TABLE[]; */
1790 if (! flag_next_runtime)
1791 build_selector_table_decl ();
1793 /* Forward declare constant_string_id and constant_string_type. */
1794 if (!constant_string_class_name)
1795 constant_string_class_name = default_constant_string_class_name;
1797 constant_string_id = get_identifier (constant_string_class_name);
1798 objc_declare_class (tree_cons (NULL_TREE, constant_string_id, NULL_TREE));
1800 /* Pre-build the following entities - for speed/convenience. */
1801 self_id = get_identifier ("self");
1802 ucmd_id = get_identifier ("_cmd");
1805 pop_lang_context ();
1808 write_symbols = save_write_symbols;
1809 debug_hooks = save_hooks;
1812 /* Ensure that the ivar list for NSConstantString/NXConstantString
1813 (or whatever was specified via `-fconstant-string-class')
1814 contains fields at least as large as the following three, so that
1815 the runtime can stomp on them with confidence:
1817 struct STRING_OBJECT_CLASS_NAME
1821 unsigned int length;
1825 check_string_class_template (void)
1827 tree field_decl = objc_get_class_ivars (constant_string_id);
1829 #define AT_LEAST_AS_LARGE_AS(F, T) \
1830 (F && TREE_CODE (F) == FIELD_DECL \
1831 && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \
1832 >= TREE_INT_CST_LOW (TYPE_SIZE (T))))
1834 if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
1837 field_decl = TREE_CHAIN (field_decl);
1838 if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
1841 field_decl = TREE_CHAIN (field_decl);
1842 return AT_LEAST_AS_LARGE_AS (field_decl, unsigned_type_node);
1844 #undef AT_LEAST_AS_LARGE_AS
1847 /* Avoid calling `check_string_class_template ()' more than once. */
1848 static GTY(()) int string_layout_checked;
1850 /* Construct an internal string layout to be used as a template for
1851 creating NSConstantString/NXConstantString instances. */
1854 objc_build_internal_const_str_type (void)
1856 tree type = (*lang_hooks.types.make_type) (RECORD_TYPE);
1857 tree fields = build_decl (input_location,
1858 FIELD_DECL, NULL_TREE, ptr_type_node);
1859 tree field = build_decl (input_location,
1860 FIELD_DECL, NULL_TREE, ptr_type_node);
1862 TREE_CHAIN (field) = fields; fields = field;
1863 field = build_decl (input_location,
1864 FIELD_DECL, NULL_TREE, unsigned_type_node);
1865 TREE_CHAIN (field) = fields; fields = field;
1866 /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in
1868 finish_builtin_struct (type, "__builtin_ObjCString",
1874 /* Custom build_string which sets TREE_TYPE! */
1877 my_build_string (int len, const char *str)
1879 return fix_string_type (build_string (len, str));
1882 /* Build a string with contents STR and length LEN and convert it to a
1886 my_build_string_pointer (int len, const char *str)
1888 tree string = my_build_string (len, str);
1889 tree ptrtype = build_pointer_type (TREE_TYPE (TREE_TYPE (string)));
1890 return build1 (ADDR_EXPR, ptrtype, string);
1894 string_hash (const void *ptr)
1896 const_tree const str = ((const struct string_descriptor *)ptr)->literal;
1897 const unsigned char *p = (const unsigned char *) TREE_STRING_POINTER (str);
1898 int i, len = TREE_STRING_LENGTH (str);
1901 for (i = 0; i < len; i++)
1902 h = ((h * 613) + p[i]);
1908 string_eq (const void *ptr1, const void *ptr2)
1910 const_tree const str1 = ((const struct string_descriptor *)ptr1)->literal;
1911 const_tree const str2 = ((const struct string_descriptor *)ptr2)->literal;
1912 int len1 = TREE_STRING_LENGTH (str1);
1914 return (len1 == TREE_STRING_LENGTH (str2)
1915 && !memcmp (TREE_STRING_POINTER (str1), TREE_STRING_POINTER (str2),
1919 /* Given a chain of STRING_CST's, build a static instance of
1920 NXConstantString which points at the concatenation of those
1921 strings. We place the string object in the __string_objects
1922 section of the __OBJC segment. The Objective-C runtime will
1923 initialize the isa pointers of the string objects to point at the
1924 NXConstantString class object. */
1927 objc_build_string_object (tree string)
1929 tree initlist, constructor, constant_string_class;
1932 struct string_descriptor *desc, key;
1935 /* Prep the string argument. */
1936 string = fix_string_type (string);
1937 TREE_SET_CODE (string, STRING_CST);
1938 length = TREE_STRING_LENGTH (string) - 1;
1940 /* Check whether the string class being used actually exists and has the
1941 correct ivar layout. */
1942 if (!string_layout_checked)
1944 string_layout_checked = -1;
1945 constant_string_class = lookup_interface (constant_string_id);
1946 internal_const_str_type = objc_build_internal_const_str_type ();
1948 if (!constant_string_class
1949 || !(constant_string_type
1950 = CLASS_STATIC_TEMPLATE (constant_string_class)))
1951 error ("cannot find interface declaration for %qE",
1952 constant_string_id);
1953 /* The NSConstantString/NXConstantString ivar layout is now known. */
1954 else if (!check_string_class_template ())
1955 error ("interface %qE does not have valid constant string layout",
1956 constant_string_id);
1957 /* For the NeXT runtime, we can generate a literal reference
1958 to the string class, don't need to run a constructor. */
1959 else if (flag_next_runtime && !setup_string_decl ())
1960 error ("cannot find reference tag for class %qE",
1961 constant_string_id);
1964 string_layout_checked = 1; /* Success! */
1965 add_class_reference (constant_string_id);
1969 if (string_layout_checked == -1)
1970 return error_mark_node;
1972 /* Perhaps we already constructed a constant string just like this one? */
1973 key.literal = string;
1974 loc = htab_find_slot (string_htab, &key, INSERT);
1975 desc = (struct string_descriptor *) *loc;
1980 *loc = desc = GGC_NEW (struct string_descriptor);
1981 desc->literal = string;
1983 /* GNU: (NXConstantString *) & ((__builtin_ObjCString) { NULL, string, length }) */
1984 /* NeXT: (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length }) */
1985 fields = TYPE_FIELDS (internal_const_str_type);
1987 = build_tree_list (fields,
1989 ? build_unary_op (input_location,
1990 ADDR_EXPR, string_class_decl, 0)
1991 : build_int_cst (NULL_TREE, 0));
1992 fields = TREE_CHAIN (fields);
1993 initlist = tree_cons (fields, build_unary_op (input_location,
1994 ADDR_EXPR, string, 1),
1996 fields = TREE_CHAIN (fields);
1997 initlist = tree_cons (fields, build_int_cst (NULL_TREE, length),
1999 constructor = objc_build_constructor (internal_const_str_type,
2000 nreverse (initlist));
2002 if (!flag_next_runtime)
2004 = objc_add_static_instance (constructor, constant_string_type);
2007 var = build_decl (input_location,
2008 CONST_DECL, NULL, TREE_TYPE (constructor));
2009 DECL_INITIAL (var) = constructor;
2010 TREE_STATIC (var) = 1;
2011 pushdecl_top_level (var);
2014 desc->constructor = constructor;
2017 addr = convert (build_pointer_type (constant_string_type),
2018 build_unary_op (input_location,
2019 ADDR_EXPR, desc->constructor, 1));
2024 /* Declare a static instance of CLASS_DECL initialized by CONSTRUCTOR. */
2026 static GTY(()) int num_static_inst;
2029 objc_add_static_instance (tree constructor, tree class_decl)
2034 /* Find the list of static instances for the CLASS_DECL. Create one if
2036 for (chain = &objc_static_instances;
2037 *chain && TREE_VALUE (*chain) != class_decl;
2038 chain = &TREE_CHAIN (*chain));
2041 *chain = tree_cons (NULL_TREE, class_decl, NULL_TREE);
2042 add_objc_string (OBJC_TYPE_NAME (class_decl), class_names);
2045 sprintf (buf, "_OBJC_INSTANCE_%d", num_static_inst++);
2046 decl = build_decl (input_location,
2047 VAR_DECL, get_identifier (buf), class_decl);
2048 TREE_STATIC (decl) = 1;
2049 DECL_ARTIFICIAL (decl) = 1;
2050 TREE_USED (decl) = 1;
2051 DECL_INITIAL (decl) = constructor;
2053 /* We may be writing something else just now.
2054 Postpone till end of input. */
2055 DECL_DEFER_OUTPUT (decl) = 1;
2056 pushdecl_top_level (decl);
2057 rest_of_decl_compilation (decl, 1, 0);
2059 /* Add the DECL to the head of this CLASS' list. */
2060 TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, decl, TREE_PURPOSE (*chain));
2065 /* Build a static constant CONSTRUCTOR
2066 with type TYPE and elements ELTS. */
2069 objc_build_constructor (tree type, tree elts)
2071 tree constructor = build_constructor_from_list (type, elts);
2073 TREE_CONSTANT (constructor) = 1;
2074 TREE_STATIC (constructor) = 1;
2075 TREE_READONLY (constructor) = 1;
2078 /* Adjust for impedance mismatch. We should figure out how to build
2079 CONSTRUCTORs that consistently please both the C and C++ gods. */
2080 if (!TREE_PURPOSE (elts))
2081 TREE_TYPE (constructor) = init_list_type_node;
2087 /* Take care of defining and initializing _OBJC_SYMBOLS. */
2089 /* Predefine the following data type:
2097 void *defs[cls_def_cnt + cat_def_cnt];
2101 build_objc_symtab_template (void)
2103 tree field_decl, field_decl_chain;
2105 objc_symtab_template = objc_start_struct (get_identifier (UTAG_SYMTAB));
2107 /* long sel_ref_cnt; */
2108 field_decl = create_field_decl (long_integer_type_node, "sel_ref_cnt");
2109 field_decl_chain = field_decl;
2112 field_decl = create_field_decl (build_pointer_type (objc_selector_type),
2114 chainon (field_decl_chain, field_decl);
2116 /* short cls_def_cnt; */
2117 field_decl = create_field_decl (short_integer_type_node, "cls_def_cnt");
2118 chainon (field_decl_chain, field_decl);
2120 /* short cat_def_cnt; */
2121 field_decl = create_field_decl (short_integer_type_node,
2123 chainon (field_decl_chain, field_decl);
2125 if (imp_count || cat_count || !flag_next_runtime)
2127 /* void *defs[imp_count + cat_count (+ 1)]; */
2128 /* NB: The index is one less than the size of the array. */
2129 int index = imp_count + cat_count
2130 + (flag_next_runtime? -1: 0);
2131 field_decl = create_field_decl
2134 build_index_type (build_int_cst (NULL_TREE, index))),
2136 chainon (field_decl_chain, field_decl);
2139 objc_finish_struct (objc_symtab_template, field_decl_chain);
2142 /* Create the initial value for the `defs' field of _objc_symtab.
2143 This is a CONSTRUCTOR. */
2146 init_def_list (tree type)
2148 tree expr, initlist = NULL_TREE;
2149 struct imp_entry *impent;
2152 for (impent = imp_list; impent; impent = impent->next)
2154 if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
2156 expr = build_unary_op (input_location,
2157 ADDR_EXPR, impent->class_decl, 0);
2158 initlist = tree_cons (NULL_TREE, expr, initlist);
2163 for (impent = imp_list; impent; impent = impent->next)
2165 if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
2167 expr = build_unary_op (input_location,
2168 ADDR_EXPR, impent->class_decl, 0);
2169 initlist = tree_cons (NULL_TREE, expr, initlist);
2173 if (!flag_next_runtime)
2175 /* statics = { ..., _OBJC_STATIC_INSTANCES, ... } */
2178 if (static_instances_decl)
2179 expr = build_unary_op (input_location,
2180 ADDR_EXPR, static_instances_decl, 0);
2182 expr = build_int_cst (NULL_TREE, 0);
2184 initlist = tree_cons (NULL_TREE, expr, initlist);
2187 return objc_build_constructor (type, nreverse (initlist));
2190 /* Construct the initial value for all of _objc_symtab. */
2193 init_objc_symtab (tree type)
2197 /* sel_ref_cnt = { ..., 5, ... } */
2199 initlist = build_tree_list (NULL_TREE,
2200 build_int_cst (long_integer_type_node, 0));
2202 /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
2204 if (flag_next_runtime || ! sel_ref_chain)
2205 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
2208 = tree_cons (NULL_TREE,
2209 convert (build_pointer_type (objc_selector_type),
2210 build_unary_op (input_location, ADDR_EXPR,
2211 UOBJC_SELECTOR_TABLE_decl, 1)),
2214 /* cls_def_cnt = { ..., 5, ... } */
2216 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, imp_count), initlist);
2218 /* cat_def_cnt = { ..., 5, ... } */
2220 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, cat_count), initlist);
2222 /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
2224 if (imp_count || cat_count || !flag_next_runtime)
2227 tree field = TYPE_FIELDS (type);
2228 field = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (field))));
2230 initlist = tree_cons (NULL_TREE, init_def_list (TREE_TYPE (field)),
2234 return objc_build_constructor (type, nreverse (initlist));
2237 /* Generate forward declarations for metadata such as
2238 'OBJC_CLASS_...'. */
2241 build_metadata_decl (const char *name, tree type)
2245 /* struct TYPE NAME_<name>; */
2246 decl = start_var_decl (type, synth_id_with_class_suffix
2248 objc_implementation_context));
2253 /* Push forward-declarations of all the categories so that
2254 init_def_list can use them in a CONSTRUCTOR. */
2257 forward_declare_categories (void)
2259 struct imp_entry *impent;
2260 tree sav = objc_implementation_context;
2262 for (impent = imp_list; impent; impent = impent->next)
2264 if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
2266 /* Set an invisible arg to synth_id_with_class_suffix. */
2267 objc_implementation_context = impent->imp_context;
2268 /* extern struct objc_category _OBJC_CATEGORY_<name>; */
2269 impent->class_decl = build_metadata_decl ("_OBJC_CATEGORY",
2270 objc_category_template);
2273 objc_implementation_context = sav;
2276 /* Create the declaration of _OBJC_SYMBOLS, with type `struct _objc_symtab'
2277 and initialized appropriately. */
2280 generate_objc_symtab_decl (void)
2282 /* forward declare categories */
2284 forward_declare_categories ();
2286 build_objc_symtab_template ();
2287 UOBJC_SYMBOLS_decl = start_var_decl (objc_symtab_template, "_OBJC_SYMBOLS");
2288 finish_var_decl (UOBJC_SYMBOLS_decl,
2289 init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl)));
2293 init_module_descriptor (tree type)
2295 tree initlist, expr;
2297 /* version = { 1, ... } */
2299 expr = build_int_cst (long_integer_type_node, OBJC_VERSION);
2300 initlist = build_tree_list (NULL_TREE, expr);
2302 /* size = { ..., sizeof (struct _objc_module), ... } */
2304 expr = convert (long_integer_type_node,
2305 size_in_bytes (objc_module_template));
2306 initlist = tree_cons (NULL_TREE, expr, initlist);
2308 /* Don't provide any file name for security reasons. */
2309 /* name = { ..., "", ... } */
2311 expr = add_objc_string (get_identifier (""), class_names);
2312 initlist = tree_cons (NULL_TREE, expr, initlist);
2314 /* symtab = { ..., _OBJC_SYMBOLS, ... } */
2316 if (UOBJC_SYMBOLS_decl)
2317 expr = build_unary_op (input_location,
2318 ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
2320 expr = build_int_cst (NULL_TREE, 0);
2321 initlist = tree_cons (NULL_TREE, expr, initlist);
2323 return objc_build_constructor (type, nreverse (initlist));
2326 /* Write out the data structures to describe Objective C classes defined.
2328 struct _objc_module { ... } _OBJC_MODULE = { ... }; */
2331 build_module_descriptor (void)
2333 tree field_decl, field_decl_chain;
2336 push_lang_context (lang_name_c); /* extern "C" */
2339 objc_module_template = objc_start_struct (get_identifier (UTAG_MODULE));
2342 field_decl = create_field_decl (long_integer_type_node, "version");
2343 field_decl_chain = field_decl;
2346 field_decl = create_field_decl (long_integer_type_node, "size");
2347 chainon (field_decl_chain, field_decl);
2350 field_decl = create_field_decl (string_type_node, "name");
2351 chainon (field_decl_chain, field_decl);
2353 /* struct _objc_symtab *symtab; */
2355 = create_field_decl (build_pointer_type
2356 (xref_tag (RECORD_TYPE,
2357 get_identifier (UTAG_SYMTAB))),
2359 chainon (field_decl_chain, field_decl);
2361 objc_finish_struct (objc_module_template, field_decl_chain);
2363 /* Create an instance of "_objc_module". */
2364 UOBJC_MODULES_decl = start_var_decl (objc_module_template, "_OBJC_MODULES");
2365 finish_var_decl (UOBJC_MODULES_decl,
2366 init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl)));
2369 pop_lang_context ();
2373 /* The GNU runtime requires us to provide a static initializer function
2376 static void __objc_gnu_init (void) {
2377 __objc_exec_class (&L_OBJC_MODULES);
2381 build_module_initializer_routine (void)
2386 push_lang_context (lang_name_c); /* extern "C" */
2389 objc_push_parm (build_decl (input_location,
2390 PARM_DECL, NULL_TREE, void_type_node));
2391 objc_start_function (get_identifier (TAG_GNUINIT),
2392 build_function_type (void_type_node,
2394 NULL_TREE, objc_get_parm_info (0));
2396 body = c_begin_compound_stmt (true);
2397 add_stmt (build_function_call
2402 build_unary_op (input_location, ADDR_EXPR,
2403 UOBJC_MODULES_decl, 0))));
2404 add_stmt (c_end_compound_stmt (input_location, body, true));
2406 TREE_PUBLIC (current_function_decl) = 0;
2409 /* For Objective-C++, we will need to call __objc_gnu_init
2410 from objc_generate_static_init_call() below. */
2411 DECL_STATIC_CONSTRUCTOR (current_function_decl) = 1;
2414 GNU_INIT_decl = current_function_decl;
2418 pop_lang_context ();
2423 /* Return 1 if the __objc_gnu_init function has been synthesized and needs
2424 to be called by the module initializer routine. */
2427 objc_static_init_needed_p (void)
2429 return (GNU_INIT_decl != NULL_TREE);
2432 /* Generate a call to the __objc_gnu_init initializer function. */
2435 objc_generate_static_init_call (tree ctors ATTRIBUTE_UNUSED)
2437 add_stmt (build_stmt (input_location, EXPR_STMT,
2438 build_function_call (input_location,
2439 GNU_INIT_decl, NULL_TREE)));
2443 #endif /* OBJCPLUS */
2445 /* Return the DECL of the string IDENT in the SECTION. */
2448 get_objc_string_decl (tree ident, enum string_section section)
2452 if (section == class_names)
2453 chain = class_names_chain;
2454 else if (section == meth_var_names)
2455 chain = meth_var_names_chain;
2456 else if (section == meth_var_types)
2457 chain = meth_var_types_chain;
2461 for (; chain != 0; chain = TREE_CHAIN (chain))
2462 if (TREE_VALUE (chain) == ident)
2463 return (TREE_PURPOSE (chain));
2469 /* Output references to all statically allocated objects. Return the DECL
2470 for the array built. */
2473 generate_static_references (void)
2475 tree decls = NULL_TREE, expr = NULL_TREE;
2476 tree class_name, klass, decl, initlist;
2477 tree cl_chain, in_chain, type
2478 = build_array_type (build_pointer_type (void_type_node), NULL_TREE);
2479 int num_inst, num_class;
2482 if (flag_next_runtime)
2485 for (cl_chain = objc_static_instances, num_class = 0;
2486 cl_chain; cl_chain = TREE_CHAIN (cl_chain), num_class++)
2488 for (num_inst = 0, in_chain = TREE_PURPOSE (cl_chain);
2489 in_chain; num_inst++, in_chain = TREE_CHAIN (in_chain));
2491 sprintf (buf, "_OBJC_STATIC_INSTANCES_%d", num_class);
2492 decl = start_var_decl (type, buf);
2494 /* Output {class_name, ...}. */
2495 klass = TREE_VALUE (cl_chain);
2496 class_name = get_objc_string_decl (OBJC_TYPE_NAME (klass), class_names);
2497 initlist = build_tree_list (NULL_TREE,
2498 build_unary_op (input_location,
2499 ADDR_EXPR, class_name, 1));
2501 /* Output {..., instance, ...}. */
2502 for (in_chain = TREE_PURPOSE (cl_chain);
2503 in_chain; in_chain = TREE_CHAIN (in_chain))
2505 expr = build_unary_op (input_location,
2506 ADDR_EXPR, TREE_VALUE (in_chain), 1);
2507 initlist = tree_cons (NULL_TREE, expr, initlist);
2510 /* Output {..., NULL}. */
2511 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
2513 expr = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
2514 finish_var_decl (decl, expr);
2516 = tree_cons (NULL_TREE, build_unary_op (input_location,
2517 ADDR_EXPR, decl, 1), decls);
2520 decls = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), decls);
2521 expr = objc_build_constructor (type, nreverse (decls));
2522 static_instances_decl = start_var_decl (type, "_OBJC_STATIC_INSTANCES");
2523 finish_var_decl (static_instances_decl, expr);
2526 static GTY(()) int selector_reference_idx;
2529 build_selector_reference_decl (void)
2534 sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", selector_reference_idx++);
2535 decl = start_var_decl (objc_selector_type, buf);
2541 build_selector_table_decl (void)
2545 if (flag_typed_selectors)
2547 build_selector_template ();
2548 temp = build_array_type (objc_selector_template, NULL_TREE);
2551 temp = build_array_type (objc_selector_type, NULL_TREE);
2553 UOBJC_SELECTOR_TABLE_decl = start_var_decl (temp, "_OBJC_SELECTOR_TABLE");
2556 /* Just a handy wrapper for add_objc_string. */
2559 build_selector (tree ident)
2561 return convert (objc_selector_type,
2562 add_objc_string (ident, meth_var_names));
2566 build_selector_translation_table (void)
2568 tree chain, initlist = NULL_TREE;
2570 tree decl = NULL_TREE;
2572 for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
2576 if (warn_selector && objc_implementation_context)
2580 for (method_chain = meth_var_names_chain;
2582 method_chain = TREE_CHAIN (method_chain))
2584 if (TREE_VALUE (method_chain) == TREE_VALUE (chain))
2593 if (flag_next_runtime && TREE_PURPOSE (chain))
2594 loc = DECL_SOURCE_LOCATION (TREE_PURPOSE (chain));
2596 loc = input_location;
2597 warning_at (loc, 0, "creating selector for nonexistent method %qE",
2598 TREE_VALUE (chain));
2602 expr = build_selector (TREE_VALUE (chain));
2603 /* add one for the '\0' character */
2604 offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1;
2606 if (flag_next_runtime)
2608 decl = TREE_PURPOSE (chain);
2609 finish_var_decl (decl, expr);
2613 if (flag_typed_selectors)
2615 tree eltlist = NULL_TREE;
2616 tree encoding = get_proto_encoding (TREE_PURPOSE (chain));
2617 eltlist = tree_cons (NULL_TREE, expr, NULL_TREE);
2618 eltlist = tree_cons (NULL_TREE, encoding, eltlist);
2619 expr = objc_build_constructor (objc_selector_template,
2620 nreverse (eltlist));
2623 initlist = tree_cons (NULL_TREE, expr, initlist);
2627 if (! flag_next_runtime)
2629 /* Cause the selector table (previously forward-declared)
2630 to be actually output. */
2631 initlist = tree_cons (NULL_TREE,
2632 flag_typed_selectors
2633 ? objc_build_constructor
2634 (objc_selector_template,
2635 tree_cons (NULL_TREE,
2636 build_int_cst (NULL_TREE, 0),
2637 tree_cons (NULL_TREE,
2638 build_int_cst (NULL_TREE, 0),
2640 : build_int_cst (NULL_TREE, 0), initlist);
2641 initlist = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
2642 nreverse (initlist));
2643 finish_var_decl (UOBJC_SELECTOR_TABLE_decl, initlist);
2648 get_proto_encoding (tree proto)
2653 if (! METHOD_ENCODING (proto))
2655 encoding = encode_method_prototype (proto);
2656 METHOD_ENCODING (proto) = encoding;
2659 encoding = METHOD_ENCODING (proto);
2661 return add_objc_string (encoding, meth_var_types);
2664 return build_int_cst (NULL_TREE, 0);
2667 /* sel_ref_chain is a list whose "value" fields will be instances of
2668 identifier_node that represent the selector. LOC is the location of
2672 build_typed_selector_reference (location_t loc, tree ident, tree prototype)
2674 tree *chain = &sel_ref_chain;
2680 if (TREE_PURPOSE (*chain) == prototype && TREE_VALUE (*chain) == ident)
2681 goto return_at_index;
2684 chain = &TREE_CHAIN (*chain);
2687 *chain = tree_cons (prototype, ident, NULL_TREE);
2690 expr = build_unary_op (loc, ADDR_EXPR,
2691 build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2692 build_int_cst (NULL_TREE, index)),
2694 return convert (objc_selector_type, expr);
2698 build_selector_reference (location_t loc, tree ident)
2700 tree *chain = &sel_ref_chain;
2706 if (TREE_VALUE (*chain) == ident)
2707 return (flag_next_runtime
2708 ? TREE_PURPOSE (*chain)
2709 : build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2710 build_int_cst (NULL_TREE, index)));
2713 chain = &TREE_CHAIN (*chain);
2716 expr = (flag_next_runtime ? build_selector_reference_decl (): NULL_TREE);
2718 *chain = tree_cons (expr, ident, NULL_TREE);
2720 return (flag_next_runtime
2722 : build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2723 build_int_cst (NULL_TREE, index)));
2726 static GTY(()) int class_reference_idx;
2729 build_class_reference_decl (void)
2734 sprintf (buf, "_OBJC_CLASS_REFERENCES_%d", class_reference_idx++);
2735 decl = start_var_decl (objc_class_type, buf);
2740 /* Create a class reference, but don't create a variable to reference
2744 add_class_reference (tree ident)
2748 if ((chain = cls_ref_chain))
2753 if (ident == TREE_VALUE (chain))
2757 chain = TREE_CHAIN (chain);
2761 /* Append to the end of the list */
2762 TREE_CHAIN (tail) = tree_cons (NULL_TREE, ident, NULL_TREE);
2765 cls_ref_chain = tree_cons (NULL_TREE, ident, NULL_TREE);
2768 /* Get a class reference, creating it if necessary. Also create the
2769 reference variable. */
2772 objc_get_class_reference (tree ident)
2774 tree orig_ident = (DECL_P (ident)
2777 ? OBJC_TYPE_NAME (ident)
2779 bool local_scope = false;
2782 if (processing_template_decl)
2783 /* Must wait until template instantiation time. */
2784 return build_min_nt (CLASS_REFERENCE_EXPR, ident);
2787 if (TREE_CODE (ident) == TYPE_DECL)
2788 ident = (DECL_ORIGINAL_TYPE (ident)
2789 ? DECL_ORIGINAL_TYPE (ident)
2790 : TREE_TYPE (ident));
2793 if (TYPE_P (ident) && TYPE_CONTEXT (ident)
2794 && TYPE_CONTEXT (ident) != global_namespace)
2798 if (local_scope || !(ident = objc_is_class_name (ident)))
2800 error ("%qE is not an Objective-C class name or alias",
2802 return error_mark_node;
2805 if (flag_next_runtime && !flag_zero_link)
2810 for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
2811 if (TREE_VALUE (*chain) == ident)
2813 if (! TREE_PURPOSE (*chain))
2814 TREE_PURPOSE (*chain) = build_class_reference_decl ();
2816 return TREE_PURPOSE (*chain);
2819 decl = build_class_reference_decl ();
2820 *chain = tree_cons (decl, ident, NULL_TREE);
2827 add_class_reference (ident);
2829 params = build_tree_list (NULL_TREE,
2830 my_build_string_pointer
2831 (IDENTIFIER_LENGTH (ident) + 1,
2832 IDENTIFIER_POINTER (ident)));
2834 assemble_external (objc_get_class_decl);
2835 return build_function_call (input_location, objc_get_class_decl, params);
2839 /* For each string section we have a chain which maps identifier nodes
2840 to decls for the strings. */
2843 add_objc_string (tree ident, enum string_section section)
2845 tree *chain, decl, type, string_expr;
2847 if (section == class_names)
2848 chain = &class_names_chain;
2849 else if (section == meth_var_names)
2850 chain = &meth_var_names_chain;
2851 else if (section == meth_var_types)
2852 chain = &meth_var_types_chain;
2858 if (TREE_VALUE (*chain) == ident)
2859 return convert (string_type_node,
2860 build_unary_op (input_location,
2861 ADDR_EXPR, TREE_PURPOSE (*chain), 1));
2863 chain = &TREE_CHAIN (*chain);
2866 decl = build_objc_string_decl (section);
2868 type = build_array_type
2871 (build_int_cst (NULL_TREE,
2872 IDENTIFIER_LENGTH (ident))));
2873 decl = start_var_decl (type, IDENTIFIER_POINTER (DECL_NAME (decl)));
2874 string_expr = my_build_string (IDENTIFIER_LENGTH (ident) + 1,
2875 IDENTIFIER_POINTER (ident));
2876 finish_var_decl (decl, string_expr);
2878 *chain = tree_cons (decl, ident, NULL_TREE);
2880 return convert (string_type_node, build_unary_op (input_location,
2881 ADDR_EXPR, decl, 1));
2884 static GTY(()) int class_names_idx;
2885 static GTY(()) int meth_var_names_idx;
2886 static GTY(()) int meth_var_types_idx;
2889 build_objc_string_decl (enum string_section section)
2894 if (section == class_names)
2895 sprintf (buf, "_OBJC_CLASS_NAME_%d", class_names_idx++);
2896 else if (section == meth_var_names)
2897 sprintf (buf, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);
2898 else if (section == meth_var_types)
2899 sprintf (buf, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);
2901 ident = get_identifier (buf);
2903 decl = build_decl (input_location,
2904 VAR_DECL, ident, build_array_type (char_type_node, 0));
2905 DECL_EXTERNAL (decl) = 1;
2906 TREE_PUBLIC (decl) = 0;
2907 TREE_USED (decl) = 1;
2908 TREE_CONSTANT (decl) = 1;
2909 DECL_CONTEXT (decl) = 0;
2910 DECL_ARTIFICIAL (decl) = 1;
2912 DECL_THIS_STATIC (decl) = 1; /* squash redeclaration errors */
2915 make_decl_rtl (decl);
2916 pushdecl_top_level (decl);
2923 objc_declare_alias (tree alias_ident, tree class_ident)
2925 tree underlying_class;
2928 if (current_namespace != global_namespace) {
2929 error ("Objective-C declarations may only appear in global scope");
2931 #endif /* OBJCPLUS */
2933 if (!(underlying_class = objc_is_class_name (class_ident)))
2934 warning (0, "cannot find class %qE", class_ident);
2935 else if (objc_is_class_name (alias_ident))
2936 warning (0, "class %qE already exists", alias_ident);
2939 /* Implement @compatibility_alias as a typedef. */
2941 push_lang_context (lang_name_c); /* extern "C" */
2943 lang_hooks.decls.pushdecl (build_decl
2947 xref_tag (RECORD_TYPE, underlying_class)));
2949 pop_lang_context ();
2951 alias_chain = tree_cons (underlying_class, alias_ident, alias_chain);
2956 objc_declare_class (tree ident_list)
2960 if (current_namespace != global_namespace) {
2961 error ("Objective-C declarations may only appear in global scope");
2963 #endif /* OBJCPLUS */
2965 for (list = ident_list; list; list = TREE_CHAIN (list))
2967 tree ident = TREE_VALUE (list);
2969 if (! objc_is_class_name (ident))
2971 tree record = lookup_name (ident), type = record;
2975 if (TREE_CODE (record) == TYPE_DECL)
2976 type = DECL_ORIGINAL_TYPE (record);
2978 if (!TYPE_HAS_OBJC_INFO (type)
2979 || !TYPE_OBJC_INTERFACE (type))
2981 error ("%qE redeclared as different kind of symbol",
2983 error ("previous declaration of %q+D",
2988 record = xref_tag (RECORD_TYPE, ident);
2989 INIT_TYPE_OBJC_INFO (record);
2990 TYPE_OBJC_INTERFACE (record) = ident;
2991 class_chain = tree_cons (NULL_TREE, ident, class_chain);
2997 objc_is_class_name (tree ident)
3001 if (ident && TREE_CODE (ident) == IDENTIFIER_NODE
3002 && identifier_global_value (ident))
3003 ident = identifier_global_value (ident);
3004 while (ident && TREE_CODE (ident) == TYPE_DECL && DECL_ORIGINAL_TYPE (ident))
3005 ident = OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident));
3007 if (ident && TREE_CODE (ident) == RECORD_TYPE)
3008 ident = OBJC_TYPE_NAME (ident);
3010 if (ident && TREE_CODE (ident) == TYPE_DECL)
3011 ident = DECL_NAME (ident);
3013 if (!ident || TREE_CODE (ident) != IDENTIFIER_NODE)
3016 if (lookup_interface (ident))
3019 for (chain = class_chain; chain; chain = TREE_CHAIN (chain))
3021 if (ident == TREE_VALUE (chain))
3025 for (chain = alias_chain; chain; chain = TREE_CHAIN (chain))
3027 if (ident == TREE_VALUE (chain))
3028 return TREE_PURPOSE (chain);
3034 /* Check whether TYPE is either 'id' or 'Class'. */
3037 objc_is_id (tree type)
3039 if (type && TREE_CODE (type) == IDENTIFIER_NODE
3040 && identifier_global_value (type))
3041 type = identifier_global_value (type);
3043 if (type && TREE_CODE (type) == TYPE_DECL)
3044 type = TREE_TYPE (type);
3046 /* NB: This function may be called before the ObjC front-end has
3047 been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL. */
3048 return (objc_object_type && type
3049 && (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type))
3054 /* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
3055 class instance. This is needed by other parts of the compiler to
3056 handle ObjC types gracefully. */
3059 objc_is_object_ptr (tree type)
3063 type = TYPE_MAIN_VARIANT (type);
3064 if (!POINTER_TYPE_P (type))
3067 ret = objc_is_id (type);
3069 ret = objc_is_class_name (TREE_TYPE (type));
3075 objc_is_gcable_type (tree type, int or_strong_p)
3081 if (objc_is_id (TYPE_MAIN_VARIANT (type)))
3083 if (or_strong_p && lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type)))
3085 if (TREE_CODE (type) != POINTER_TYPE && TREE_CODE (type) != INDIRECT_REF)
3087 type = TREE_TYPE (type);
3088 if (TREE_CODE (type) != RECORD_TYPE)
3090 name = TYPE_NAME (type);
3091 return (objc_is_class_name (name) != NULL_TREE);
3095 objc_substitute_decl (tree expr, tree oldexpr, tree newexpr)
3097 if (expr == oldexpr)
3100 switch (TREE_CODE (expr))
3103 return objc_build_component_ref
3104 (objc_substitute_decl (TREE_OPERAND (expr, 0),
3107 DECL_NAME (TREE_OPERAND (expr, 1)));
3109 return build_array_ref (input_location,
3110 objc_substitute_decl (TREE_OPERAND (expr, 0),
3113 TREE_OPERAND (expr, 1));
3115 return build_indirect_ref (input_location,
3116 objc_substitute_decl (TREE_OPERAND (expr, 0),
3125 objc_build_ivar_assignment (tree outervar, tree lhs, tree rhs)
3128 /* The LHS parameter contains the expression 'outervar->memberspec';
3129 we need to transform it into '&((typeof(outervar) *) 0)->memberspec',
3130 where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]').
3133 = objc_substitute_decl
3134 (lhs, outervar, convert (TREE_TYPE (outervar), integer_zero_node));
3136 = (flag_objc_direct_dispatch
3137 ? objc_assign_ivar_fast_decl
3138 : objc_assign_ivar_decl);
3140 offs = convert (integer_type_node, build_unary_op (input_location,
3141 ADDR_EXPR, offs, 0));
3143 func_params = tree_cons (NULL_TREE,
3144 convert (objc_object_type, rhs),
3145 tree_cons (NULL_TREE, convert (objc_object_type, outervar),
3146 tree_cons (NULL_TREE, offs,
3149 assemble_external (func);
3150 return build_function_call (input_location, func, func_params);
3154 objc_build_global_assignment (tree lhs, tree rhs)
3156 tree func_params = tree_cons (NULL_TREE,
3157 convert (objc_object_type, rhs),
3158 tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
3159 build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
3162 assemble_external (objc_assign_global_decl);
3163 return build_function_call (input_location,
3164 objc_assign_global_decl, func_params);
3168 objc_build_strong_cast_assignment (tree lhs, tree rhs)
3170 tree func_params = tree_cons (NULL_TREE,
3171 convert (objc_object_type, rhs),
3172 tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
3173 build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
3176 assemble_external (objc_assign_strong_cast_decl);
3177 return build_function_call (input_location,
3178 objc_assign_strong_cast_decl, func_params);
3182 objc_is_gcable_p (tree expr)
3184 return (TREE_CODE (expr) == COMPONENT_REF
3185 ? objc_is_gcable_p (TREE_OPERAND (expr, 1))
3186 : TREE_CODE (expr) == ARRAY_REF
3187 ? (objc_is_gcable_p (TREE_TYPE (expr))
3188 || objc_is_gcable_p (TREE_OPERAND (expr, 0)))
3189 : TREE_CODE (expr) == ARRAY_TYPE
3190 ? objc_is_gcable_p (TREE_TYPE (expr))
3192 ? objc_is_gcable_type (expr, 1)
3193 : (objc_is_gcable_p (TREE_TYPE (expr))
3195 && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr)))));
3199 objc_is_ivar_reference_p (tree expr)
3201 return (TREE_CODE (expr) == ARRAY_REF
3202 ? objc_is_ivar_reference_p (TREE_OPERAND (expr, 0))
3203 : TREE_CODE (expr) == COMPONENT_REF
3204 ? TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL
3209 objc_is_global_reference_p (tree expr)
3211 return (TREE_CODE (expr) == INDIRECT_REF || TREE_CODE (expr) == PLUS_EXPR
3212 ? objc_is_global_reference_p (TREE_OPERAND (expr, 0))
3214 ? (!DECL_CONTEXT (expr) || TREE_STATIC (expr))
3219 objc_generate_write_barrier (tree lhs, enum tree_code modifycode, tree rhs)
3221 tree result = NULL_TREE, outer;
3222 int strong_cast_p = 0, outer_gc_p = 0, indirect_p = 0;
3224 /* See if we have any lhs casts, and strip them out. NB: The lvalue casts
3225 will have been transformed to the form '*(type *)&expr'. */
3226 if (TREE_CODE (lhs) == INDIRECT_REF)
3228 outer = TREE_OPERAND (lhs, 0);
3230 while (!strong_cast_p
3231 && (CONVERT_EXPR_P (outer)
3232 || TREE_CODE (outer) == NON_LVALUE_EXPR))
3234 tree lhstype = TREE_TYPE (outer);
3236 /* Descend down the cast chain, and record the first objc_gc
3238 if (POINTER_TYPE_P (lhstype))
3241 = lookup_attribute ("objc_gc",
3242 TYPE_ATTRIBUTES (TREE_TYPE (lhstype)));
3248 outer = TREE_OPERAND (outer, 0);
3252 /* If we have a __strong cast, it trumps all else. */
3255 if (modifycode != NOP_EXPR)
3256 goto invalid_pointer_arithmetic;
3258 if (warn_assign_intercept)
3259 warning (0, "strong-cast assignment has been intercepted");
3261 result = objc_build_strong_cast_assignment (lhs, rhs);
3266 /* the lhs must be of a suitable type, regardless of its underlying
3268 if (!objc_is_gcable_p (lhs))
3274 && (TREE_CODE (outer) == COMPONENT_REF
3275 || TREE_CODE (outer) == ARRAY_REF))
3276 outer = TREE_OPERAND (outer, 0);
3278 if (TREE_CODE (outer) == INDIRECT_REF)
3280 outer = TREE_OPERAND (outer, 0);
3284 outer_gc_p = objc_is_gcable_p (outer);
3286 /* Handle ivar assignments. */
3287 if (objc_is_ivar_reference_p (lhs))
3289 /* if the struct to the left of the ivar is not an Objective-C object (__strong
3290 doesn't cut it here), the best we can do here is suggest a cast. */
3291 if (!objc_is_gcable_type (TREE_TYPE (outer), 0))
3293 /* We may still be able to use the global write barrier... */
3294 if (!indirect_p && objc_is_global_reference_p (outer))
3295 goto global_reference;
3298 if (modifycode == NOP_EXPR)
3300 if (warn_assign_intercept)
3301 warning (0, "strong-cast may possibly be needed");
3307 if (modifycode != NOP_EXPR)
3308 goto invalid_pointer_arithmetic;
3310 if (warn_assign_intercept)
3311 warning (0, "instance variable assignment has been intercepted");
3313 result = objc_build_ivar_assignment (outer, lhs, rhs);
3318 /* Likewise, intercept assignment to global/static variables if their type is
3320 if (objc_is_global_reference_p (outer))
3326 if (modifycode != NOP_EXPR)
3328 invalid_pointer_arithmetic:
3330 warning (0, "pointer arithmetic for garbage-collected objects not allowed");
3335 if (warn_assign_intercept)
3336 warning (0, "global/static variable assignment has been intercepted");
3338 result = objc_build_global_assignment (lhs, rhs);
3341 /* In all other cases, fall back to the normal mechanism. */
3346 struct GTY(()) interface_tuple {
3351 static GTY ((param_is (struct interface_tuple))) htab_t interface_htab;
3354 hash_interface (const void *p)
3356 const struct interface_tuple *d = (const struct interface_tuple *) p;
3357 return IDENTIFIER_HASH_VALUE (d->id);
3361 eq_interface (const void *p1, const void *p2)
3363 const struct interface_tuple *d = (const struct interface_tuple *) p1;
3368 lookup_interface (tree ident)
3371 if (ident && TREE_CODE (ident) == TYPE_DECL)
3372 ident = DECL_NAME (ident);
3375 if (ident == NULL_TREE || TREE_CODE (ident) != IDENTIFIER_NODE)
3379 struct interface_tuple **slot;
3384 slot = (struct interface_tuple **)
3385 htab_find_slot_with_hash (interface_htab, ident,
3386 IDENTIFIER_HASH_VALUE (ident),
3389 i = (*slot)->class_name;
3395 /* Implement @defs (<classname>) within struct bodies. */
3398 objc_get_class_ivars (tree class_name)
3400 tree interface = lookup_interface (class_name);
3403 return get_class_ivars (interface, true);
3405 error ("cannot find interface declaration for %qE",
3408 return error_mark_node;
3411 /* Used by: build_private_template, continue_class,
3412 and for @defs constructs. */
3415 get_class_ivars (tree interface, bool inherited)
3417 tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface));
3419 /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared
3420 by the current class (i.e., they do not include super-class ivars).
3421 However, the CLASS_IVARS list will be side-effected by a call to
3422 finish_struct(), which will fill in field offsets. */
3423 if (!CLASS_IVARS (interface))
3424 CLASS_IVARS (interface) = ivar_chain;
3429 while (CLASS_SUPER_NAME (interface))
3431 /* Prepend super-class ivars. */
3432 interface = lookup_interface (CLASS_SUPER_NAME (interface));
3433 ivar_chain = chainon (copy_list (CLASS_RAW_IVARS (interface)),
3441 objc_create_temporary_var (tree type)
3445 decl = build_decl (input_location,
3446 VAR_DECL, NULL_TREE, type);
3447 TREE_USED (decl) = 1;
3448 DECL_ARTIFICIAL (decl) = 1;
3449 DECL_IGNORED_P (decl) = 1;
3450 DECL_CONTEXT (decl) = current_function_decl;
3455 /* Exception handling constructs. We begin by having the parser do most
3456 of the work and passing us blocks. What we do next depends on whether
3457 we're doing "native" exception handling or legacy Darwin setjmp exceptions.
3458 We abstract all of this in a handful of appropriately named routines. */
3460 /* Stack of open try blocks. */
3462 struct objc_try_context
3464 struct objc_try_context *outer;
3466 /* Statements (or statement lists) as processed by the parser. */
3470 /* Some file position locations. */
3471 location_t try_locus;
3472 location_t end_try_locus;
3473 location_t end_catch_locus;
3474 location_t finally_locus;
3475 location_t end_finally_locus;
3477 /* A STATEMENT_LIST of CATCH_EXPRs, appropriate for sticking into op1
3478 of a TRY_CATCH_EXPR. Even when doing Darwin setjmp. */
3481 /* The CATCH_EXPR of an open @catch clause. */
3484 /* The VAR_DECL holding the Darwin equivalent of __builtin_eh_pointer. */
3490 static struct objc_try_context *cur_try_context;
3492 static GTY(()) tree objc_eh_personality_decl;
3494 /* This hook, called via lang_eh_runtime_type, generates a runtime object
3495 that represents TYPE. For Objective-C, this is just the class name. */
3496 /* ??? Isn't there a class object or some such? Is it easy to get? */
3500 objc_eh_runtime_type (tree type)
3502 return add_objc_string (OBJC_TYPE_NAME (TREE_TYPE (type)), class_names);
3506 objc_eh_personality (void)
3508 if (!flag_objc_sjlj_exceptions
3509 && !objc_eh_personality_decl)
3510 objc_eh_personality_decl
3511 = build_personality_function (USING_SJLJ_EXCEPTIONS
3512 ? "__gnu_objc_personality_sj0"
3513 : "__gnu_objc_personality_v0");
3515 return objc_eh_personality_decl;
3519 /* Build __builtin_eh_pointer, or the moral equivalent. In the case
3520 of Darwin, we'll arrange for it to be initialized (and associated
3521 with a binding) later. */
3524 objc_build_exc_ptr (void)
3526 if (flag_objc_sjlj_exceptions)
3528 tree var = cur_try_context->caught_decl;
3531 var = objc_create_temporary_var (objc_object_type);
3532 cur_try_context->caught_decl = var;
3539 t = built_in_decls[BUILT_IN_EH_POINTER];
3540 t = build_call_expr (t, 1, integer_zero_node);
3541 return fold_convert (objc_object_type, t);
3545 /* Build "objc_exception_try_exit(&_stack)". */
3548 next_sjlj_build_try_exit (void)
3551 t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
3552 t = tree_cons (NULL, t, NULL);
3553 t = build_function_call (input_location,
3554 objc_exception_try_exit_decl, t);
3559 objc_exception_try_enter (&_stack);
3560 if (_setjmp(&_stack.buf))
3564 Return the COND_EXPR. Note that the THEN and ELSE fields are left
3565 empty, ready for the caller to fill them in. */
3568 next_sjlj_build_enter_and_setjmp (void)
3570 tree t, enter, sj, cond;
3572 t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
3573 t = tree_cons (NULL, t, NULL);
3574 enter = build_function_call (input_location,
3575 objc_exception_try_enter_decl, t);
3577 t = objc_build_component_ref (cur_try_context->stack_decl,
3578 get_identifier ("buf"));
3579 t = build_fold_addr_expr_loc (input_location, t);
3581 /* Convert _setjmp argument to type that is expected. */
3582 if (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl)))
3583 t = convert (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl))), t);
3585 t = convert (ptr_type_node, t);
3587 t = convert (ptr_type_node, t);
3589 t = tree_cons (NULL, t, NULL);
3590 sj = build_function_call (input_location,
3591 objc_setjmp_decl, t);
3593 cond = build2 (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj);
3594 cond = c_common_truthvalue_conversion (input_location, cond);
3596 return build3 (COND_EXPR, void_type_node, cond, NULL, NULL);
3601 DECL = objc_exception_extract(&_stack); */
3604 next_sjlj_build_exc_extract (tree decl)
3608 t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
3609 t = tree_cons (NULL, t, NULL);
3610 t = build_function_call (input_location,
3611 objc_exception_extract_decl, t);
3612 t = convert (TREE_TYPE (decl), t);
3613 t = build2 (MODIFY_EXPR, void_type_node, decl, t);
3619 if (objc_exception_match(obj_get_class(TYPE), _caught)
3626 objc_exception_try_exit(&_stack);
3628 from the sequence of CATCH_EXPRs in the current try context. */
3631 next_sjlj_build_catch_list (void)
3633 tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
3635 tree *last = &catch_seq;
3636 bool saw_id = false;
3638 for (; !tsi_end_p (i); tsi_next (&i))
3640 tree stmt = tsi_stmt (i);
3641 tree type = CATCH_TYPES (stmt);
3642 tree body = CATCH_BODY (stmt);
3654 if (type == error_mark_node)
3655 cond = error_mark_node;
3658 args = tree_cons (NULL, cur_try_context->caught_decl, NULL);
3659 t = objc_get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type)));
3660 args = tree_cons (NULL, t, args);
3661 t = build_function_call (input_location,
3662 objc_exception_match_decl, args);
3663 cond = c_common_truthvalue_conversion (input_location, t);
3665 t = build3 (COND_EXPR, void_type_node, cond, body, NULL);
3666 SET_EXPR_LOCATION (t, EXPR_LOCATION (stmt));
3669 last = &COND_EXPR_ELSE (t);
3675 t = build2 (MODIFY_EXPR, void_type_node, cur_try_context->rethrow_decl,
3676 cur_try_context->caught_decl);
3677 SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
3678 append_to_statement_list (t, last);
3680 t = next_sjlj_build_try_exit ();
3681 SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
3682 append_to_statement_list (t, last);
3688 /* Build a complete @try-@catch-@finally block for legacy Darwin setjmp
3689 exception handling. We aim to build:
3692 struct _objc_exception_data _stack;
3696 objc_exception_try_enter (&_stack);
3697 if (_setjmp(&_stack.buf))
3699 id _caught = objc_exception_extract(&_stack);
3700 objc_exception_try_enter (&_stack);
3701 if (_setjmp(&_stack.buf))
3702 _rethrow = objc_exception_extract(&_stack);
3712 objc_exception_try_exit(&_stack);
3715 objc_exception_throw(_rethrow);
3719 If CATCH-LIST is empty, we can omit all of the block containing
3720 "_caught" except for the setting of _rethrow. Note the use of
3721 a real TRY_FINALLY_EXPR here, which is not involved in EH per-se,
3722 but handles goto and other exits from the block. */
3725 next_sjlj_build_try_catch_finally (void)
3727 tree rethrow_decl, stack_decl, t;
3728 tree catch_seq, try_fin, bind;
3730 /* Create the declarations involved. */
3731 t = xref_tag (RECORD_TYPE, get_identifier (UTAG_EXCDATA));
3732 stack_decl = objc_create_temporary_var (t);
3733 cur_try_context->stack_decl = stack_decl;
3735 rethrow_decl = objc_create_temporary_var (objc_object_type);
3736 cur_try_context->rethrow_decl = rethrow_decl;
3737 TREE_CHAIN (rethrow_decl) = stack_decl;
3739 /* Build the outermost variable binding level. */
3740 bind = build3 (BIND_EXPR, void_type_node, rethrow_decl, NULL, NULL);
3741 SET_EXPR_LOCATION (bind, cur_try_context->try_locus);
3742 TREE_SIDE_EFFECTS (bind) = 1;
3744 /* Initialize rethrow_decl. */
3745 t = build2 (MODIFY_EXPR, void_type_node, rethrow_decl,
3746 convert (objc_object_type, null_pointer_node));
3747 SET_EXPR_LOCATION (t, cur_try_context->try_locus);
3748 append_to_statement_list (t, &BIND_EXPR_BODY (bind));
3750 /* Build the outermost TRY_FINALLY_EXPR. */
3751 try_fin = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
3752 SET_EXPR_LOCATION (try_fin, cur_try_context->try_locus);
3753 TREE_SIDE_EFFECTS (try_fin) = 1;
3754 append_to_statement_list (try_fin, &BIND_EXPR_BODY (bind));
3756 /* Create the complete catch sequence. */
3757 if (cur_try_context->catch_list)
3759 tree caught_decl = objc_build_exc_ptr ();
3760 catch_seq = build_stmt (input_location, BIND_EXPR, caught_decl, NULL, NULL);
3761 TREE_SIDE_EFFECTS (catch_seq) = 1;
3763 t = next_sjlj_build_exc_extract (caught_decl);
3764 append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
3766 t = next_sjlj_build_enter_and_setjmp ();
3767 COND_EXPR_THEN (t) = next_sjlj_build_exc_extract (rethrow_decl);
3768 COND_EXPR_ELSE (t) = next_sjlj_build_catch_list ();
3769 append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
3772 catch_seq = next_sjlj_build_exc_extract (rethrow_decl);
3773 SET_EXPR_LOCATION (catch_seq, cur_try_context->end_try_locus);
3775 /* Build the main register-and-try if statement. */
3776 t = next_sjlj_build_enter_and_setjmp ();
3777 SET_EXPR_LOCATION (t, cur_try_context->try_locus);
3778 COND_EXPR_THEN (t) = catch_seq;
3779 COND_EXPR_ELSE (t) = cur_try_context->try_body;
3780 TREE_OPERAND (try_fin, 0) = t;
3782 /* Build the complete FINALLY statement list. */
3783 t = next_sjlj_build_try_exit ();
3784 t = build_stmt (input_location, COND_EXPR,
3785 c_common_truthvalue_conversion
3786 (input_location, rethrow_decl),
3788 SET_EXPR_LOCATION (t, cur_try_context->finally_locus);
3789 append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
3791 append_to_statement_list (cur_try_context->finally_body,
3792 &TREE_OPERAND (try_fin, 1));
3794 t = tree_cons (NULL, rethrow_decl, NULL);
3795 t = build_function_call (input_location,
3796 objc_exception_throw_decl, t);
3797 t = build_stmt (input_location, COND_EXPR,
3798 c_common_truthvalue_conversion (input_location,
3801 SET_EXPR_LOCATION (t, cur_try_context->end_finally_locus);
3802 append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
3807 /* Called just after parsing the @try and its associated BODY. We now
3808 must prepare for the tricky bits -- handling the catches and finally. */
3811 objc_begin_try_stmt (location_t try_locus, tree body)
3813 struct objc_try_context *c = XCNEW (struct objc_try_context);
3814 c->outer = cur_try_context;
3816 c->try_locus = try_locus;
3817 c->end_try_locus = input_location;
3818 cur_try_context = c;
3820 if (flag_objc_sjlj_exceptions)
3822 /* On Darwin, ObjC exceptions require a sufficiently recent
3823 version of the runtime, so the user must ask for them explicitly. */
3824 if (!flag_objc_exceptions)
3825 warning (0, "use %<-fobjc-exceptions%> to enable Objective-C "
3826 "exception syntax");
3829 if (flag_objc_sjlj_exceptions)
3830 objc_mark_locals_volatile (NULL);
3833 /* Called just after parsing "@catch (parm)". Open a binding level,
3834 enter DECL into the binding level, and initialize it. Leave the
3835 binding level open while the body of the compound statement is parsed. */
3838 objc_begin_catch_clause (tree decl)
3840 tree compound, type, t;
3842 /* Begin a new scope that the entire catch clause will live in. */
3843 compound = c_begin_compound_stmt (true);
3845 /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL. */
3846 decl = build_decl (input_location,
3847 VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
3848 lang_hooks.decls.pushdecl (decl);
3850 /* Since a decl is required here by syntax, don't warn if its unused. */
3851 /* ??? As opposed to __attribute__((unused))? Anyway, this appears to
3852 be what the previous objc implementation did. */
3853 TREE_USED (decl) = 1;
3855 /* Verify that the type of the catch is valid. It must be a pointer
3856 to an Objective-C class, or "id" (which is catch-all). */
3857 type = TREE_TYPE (decl);
3859 if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
3861 else if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type)))
3863 error ("@catch parameter is not a known Objective-C class type");
3864 type = error_mark_node;
3866 else if (cur_try_context->catch_list)
3868 /* Examine previous @catch clauses and see if we've already
3869 caught the type in question. */
3870 tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
3871 for (; !tsi_end_p (i); tsi_next (&i))
3873 tree stmt = tsi_stmt (i);
3874 t = CATCH_TYPES (stmt);
3875 if (t == error_mark_node)
3877 if (!t || DERIVED_FROM_P (TREE_TYPE (t), TREE_TYPE (type)))
3879 warning (0, "exception of type %<%T%> will be caught",
3881 warning_at (EXPR_LOCATION (stmt), 0, " by earlier handler for %<%T%>",
3882 TREE_TYPE (t ? t : objc_object_type));
3888 /* Record the data for the catch in the try context so that we can
3889 finalize it later. */
3890 t = build_stmt (input_location, CATCH_EXPR, type, compound);
3891 cur_try_context->current_catch = t;
3893 /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */
3894 t = objc_build_exc_ptr ();
3895 t = convert (TREE_TYPE (decl), t);
3896 t = build2 (MODIFY_EXPR, void_type_node, decl, t);
3900 /* Called just after parsing the closing brace of a @catch clause. Close
3901 the open binding level, and record a CATCH_EXPR for it. */
3904 objc_finish_catch_clause (void)
3906 tree c = cur_try_context->current_catch;
3907 cur_try_context->current_catch = NULL;
3908 cur_try_context->end_catch_locus = input_location;
3910 CATCH_BODY (c) = c_end_compound_stmt (input_location, CATCH_BODY (c), 1);
3911 append_to_statement_list (c, &cur_try_context->catch_list);
3914 /* Called after parsing a @finally clause and its associated BODY.
3915 Record the body for later placement. */
3918 objc_build_finally_clause (location_t finally_locus, tree body)
3920 cur_try_context->finally_body = body;
3921 cur_try_context->finally_locus = finally_locus;
3922 cur_try_context->end_finally_locus = input_location;
3925 /* Called to finalize a @try construct. */
3928 objc_finish_try_stmt (void)
3930 struct objc_try_context *c = cur_try_context;
3933 if (c->catch_list == NULL && c->finally_body == NULL)
3934 error ("%<@try%> without %<@catch%> or %<@finally%>");
3936 /* If we're doing Darwin setjmp exceptions, build the big nasty. */
3937 if (flag_objc_sjlj_exceptions)
3939 bool save = in_late_binary_op;
3940 in_late_binary_op = true;
3941 if (!cur_try_context->finally_body)
3943 cur_try_context->finally_locus = input_location;
3944 cur_try_context->end_finally_locus = input_location;
3946 stmt = next_sjlj_build_try_catch_finally ();
3947 in_late_binary_op = save;
3951 /* Otherwise, nest the CATCH inside a FINALLY. */
3955 stmt = build_stmt (input_location, TRY_CATCH_EXPR, stmt, c->catch_list);
3956 SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
3958 if (c->finally_body)
3960 stmt = build_stmt (input_location, TRY_FINALLY_EXPR, stmt, c->finally_body);
3961 SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
3966 cur_try_context = c->outer;
3972 objc_build_throw_stmt (location_t loc, tree throw_expr)
3976 if (flag_objc_sjlj_exceptions)
3978 /* On Darwin, ObjC exceptions require a sufficiently recent
3979 version of the runtime, so the user must ask for them explicitly. */
3980 if (!flag_objc_exceptions)
3981 warning (0, "use %<-fobjc-exceptions%> to enable Objective-C "
3982 "exception syntax");
3985 if (throw_expr == NULL)
3987 /* If we're not inside a @catch block, there is no "current
3988 exception" to be rethrown. */
3989 if (cur_try_context == NULL
3990 || cur_try_context->current_catch == NULL)
3992 error_at (loc, "%<@throw%> (rethrow) used outside of a @catch block");
3996 /* Otherwise the object is still sitting in the EXC_PTR_EXPR
3997 value that we get from the runtime. */
3998 throw_expr = objc_build_exc_ptr ();
4001 /* A throw is just a call to the runtime throw function with the
4002 object as a parameter. */
4003 args = tree_cons (NULL, throw_expr, NULL);
4004 return add_stmt (build_function_call (loc,
4005 objc_exception_throw_decl, args));
4009 objc_build_synchronized (location_t start_locus, tree mutex, tree body)
4013 /* First lock the mutex. */
4014 mutex = save_expr (mutex);
4015 args = tree_cons (NULL, mutex, NULL);
4016 call = build_function_call (input_location,
4017 objc_sync_enter_decl, args);
4018 SET_EXPR_LOCATION (call, start_locus);
4021 /* Build the mutex unlock. */
4022 args = tree_cons (NULL, mutex, NULL);
4023 call = build_function_call (input_location,
4024 objc_sync_exit_decl, args);
4025 SET_EXPR_LOCATION (call, input_location);
4027 /* Put the that and the body in a TRY_FINALLY. */
4028 objc_begin_try_stmt (start_locus, body);
4029 objc_build_finally_clause (input_location, call);
4030 return objc_finish_try_stmt ();
4034 /* Predefine the following data type:
4036 struct _objc_exception_data
4038 int buf[OBJC_JBLEN];
4042 /* The following yuckiness should prevent users from having to #include
4043 <setjmp.h> in their code... */
4045 /* Define to a harmless positive value so the below code doesn't die. */
4047 #define OBJC_JBLEN 18
4051 build_next_objc_exception_stuff (void)
4053 tree field_decl, field_decl_chain, index, temp_type;
4055 objc_exception_data_template
4056 = objc_start_struct (get_identifier (UTAG_EXCDATA));
4058 /* int buf[OBJC_JBLEN]; */
4060 index = build_index_type (build_int_cst (NULL_TREE, OBJC_JBLEN - 1));
4061 field_decl = create_field_decl (build_array_type (integer_type_node, index),
4063 field_decl_chain = field_decl;
4065 /* void *pointers[4]; */
4067 index = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
4068 field_decl = create_field_decl (build_array_type (ptr_type_node, index),
4070 chainon (field_decl_chain, field_decl);
4072 objc_finish_struct (objc_exception_data_template, field_decl_chain);
4074 /* int _setjmp(...); */
4075 /* If the user includes <setjmp.h>, this shall be superseded by
4076 'int _setjmp(jmp_buf);' */
4077 temp_type = build_function_type (integer_type_node, NULL_TREE);
4079 = add_builtin_function (TAG_SETJMP, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
4081 /* id objc_exception_extract(struct _objc_exception_data *); */
4083 = build_function_type (objc_object_type,
4084 tree_cons (NULL_TREE,
4085 build_pointer_type (objc_exception_data_template),
4087 objc_exception_extract_decl
4088 = add_builtin_function (TAG_EXCEPTIONEXTRACT, temp_type, 0, NOT_BUILT_IN, NULL,
4090 /* void objc_exception_try_enter(struct _objc_exception_data *); */
4091 /* void objc_exception_try_exit(struct _objc_exception_data *); */
4093 = build_function_type (void_type_node,
4094 tree_cons (NULL_TREE,
4095 build_pointer_type (objc_exception_data_template),
4097 objc_exception_try_enter_decl
4098 = add_builtin_function (TAG_EXCEPTIONTRYENTER, temp_type, 0, NOT_BUILT_IN, NULL,
4100 objc_exception_try_exit_decl
4101 = add_builtin_function (TAG_EXCEPTIONTRYEXIT, temp_type, 0, NOT_BUILT_IN, NULL,
4104 /* int objc_exception_match(id, id); */
4106 = build_function_type (integer_type_node,
4107 tree_cons (NULL_TREE, objc_object_type,
4108 tree_cons (NULL_TREE, objc_object_type,
4109 OBJC_VOID_AT_END)));
4110 objc_exception_match_decl
4111 = add_builtin_function (TAG_EXCEPTIONMATCH, temp_type, 0, NOT_BUILT_IN, NULL,
4114 /* id objc_assign_ivar (id, id, unsigned int); */
4115 /* id objc_assign_ivar_Fast (id, id, unsigned int)
4116 __attribute__ ((hard_coded_address (OFFS_ASSIGNIVAR_FAST))); */
4118 = build_function_type (objc_object_type,
4120 (NULL_TREE, objc_object_type,
4121 tree_cons (NULL_TREE, objc_object_type,
4122 tree_cons (NULL_TREE,
4124 OBJC_VOID_AT_END))));
4125 objc_assign_ivar_decl
4126 = add_builtin_function (TAG_ASSIGNIVAR, temp_type, 0, NOT_BUILT_IN,
4128 #ifdef OFFS_ASSIGNIVAR_FAST
4129 objc_assign_ivar_fast_decl
4130 = add_builtin_function (TAG_ASSIGNIVAR_FAST, temp_type, 0,
4131 NOT_BUILT_IN, NULL, NULL_TREE);
4132 DECL_ATTRIBUTES (objc_assign_ivar_fast_decl)
4133 = tree_cons (get_identifier ("hard_coded_address"),
4134 build_int_cst (NULL_TREE, OFFS_ASSIGNIVAR_FAST),
4137 /* Default to slower ivar method. */
4138 objc_assign_ivar_fast_decl = objc_assign_ivar_decl;
4141 /* id objc_assign_global (id, id *); */
4142 /* id objc_assign_strongCast (id, id *); */
4143 temp_type = build_function_type (objc_object_type,
4144 tree_cons (NULL_TREE, objc_object_type,
4145 tree_cons (NULL_TREE, build_pointer_type (objc_object_type),
4146 OBJC_VOID_AT_END)));
4147 objc_assign_global_decl
4148 = add_builtin_function (TAG_ASSIGNGLOBAL, temp_type, 0, NOT_BUILT_IN, NULL,
4150 objc_assign_strong_cast_decl
4151 = add_builtin_function (TAG_ASSIGNSTRONGCAST, temp_type, 0, NOT_BUILT_IN, NULL,
4156 build_objc_exception_stuff (void)
4158 tree noreturn_list, nothrow_list, temp_type;
4160 noreturn_list = tree_cons (get_identifier ("noreturn"), NULL, NULL);
4161 nothrow_list = tree_cons (get_identifier ("nothrow"), NULL, NULL);
4163 /* void objc_exception_throw(id) __attribute__((noreturn)); */
4164 /* void objc_sync_enter(id); */
4165 /* void objc_sync_exit(id); */
4166 temp_type = build_function_type (void_type_node,
4167 tree_cons (NULL_TREE, objc_object_type,
4169 objc_exception_throw_decl
4170 = add_builtin_function (TAG_EXCEPTIONTHROW, temp_type, 0, NOT_BUILT_IN, NULL,
4172 objc_sync_enter_decl
4173 = add_builtin_function (TAG_SYNCENTER, temp_type, 0, NOT_BUILT_IN,
4174 NULL, nothrow_list);
4176 = add_builtin_function (TAG_SYNCEXIT, temp_type, 0, NOT_BUILT_IN,
4177 NULL, nothrow_list);
4180 /* Construct a C struct corresponding to ObjC class CLASS, with the same
4183 struct <classname> {
4184 struct _objc_class *isa;
4189 build_private_template (tree klass)
4191 if (!CLASS_STATIC_TEMPLATE (klass))
4193 tree record = objc_build_struct (klass,
4194 get_class_ivars (klass, false),
4195 CLASS_SUPER_NAME (klass));
4197 /* Set the TREE_USED bit for this struct, so that stab generator
4198 can emit stabs for this struct type. */
4199 if (flag_debug_only_used_symbols && TYPE_STUB_DECL (record))
4200 TREE_USED (TYPE_STUB_DECL (record)) = 1;
4204 /* Begin code generation for protocols... */
4206 /* struct _objc_protocol {
4207 struct _objc_class *isa;
4208 char *protocol_name;
4209 struct _objc_protocol **protocol_list;
4210 struct _objc__method_prototype_list *instance_methods;
4211 struct _objc__method_prototype_list *class_methods;
4215 build_protocol_template (void)
4217 tree field_decl, field_decl_chain;
4219 objc_protocol_template = objc_start_struct (get_identifier (UTAG_PROTOCOL));
4221 /* struct _objc_class *isa; */
4222 field_decl = create_field_decl (build_pointer_type
4223 (xref_tag (RECORD_TYPE,
4224 get_identifier (UTAG_CLASS))),
4226 field_decl_chain = field_decl;
4228 /* char *protocol_name; */
4229 field_decl = create_field_decl (string_type_node, "protocol_name");
4230 chainon (field_decl_chain, field_decl);
4232 /* struct _objc_protocol **protocol_list; */
4233 field_decl = create_field_decl (build_pointer_type
4235 (objc_protocol_template)),
4237 chainon (field_decl_chain, field_decl);
4239 /* struct _objc__method_prototype_list *instance_methods; */
4240 field_decl = create_field_decl (objc_method_proto_list_ptr,
4241 "instance_methods");
4242 chainon (field_decl_chain, field_decl);
4244 /* struct _objc__method_prototype_list *class_methods; */
4245 field_decl = create_field_decl (objc_method_proto_list_ptr,
4247 chainon (field_decl_chain, field_decl);
4249 objc_finish_struct (objc_protocol_template, field_decl_chain);
4253 build_descriptor_table_initializer (tree type, tree entries)
4255 tree initlist = NULL_TREE;
4259 tree eltlist = NULL_TREE;
4262 = tree_cons (NULL_TREE,
4263 build_selector (METHOD_SEL_NAME (entries)), NULL_TREE);
4265 = tree_cons (NULL_TREE,
4266 add_objc_string (METHOD_ENCODING (entries),
4271 = tree_cons (NULL_TREE,
4272 objc_build_constructor (type, nreverse (eltlist)),
4275 entries = TREE_CHAIN (entries);
4279 return objc_build_constructor (build_array_type (type, 0),
4280 nreverse (initlist));
4283 /* struct objc_method_prototype_list {
4285 struct objc_method_prototype {
4292 build_method_prototype_list_template (tree list_type, int size)
4294 tree objc_ivar_list_record;
4295 tree field_decl, field_decl_chain;
4297 /* Generate an unnamed struct definition. */
4299 objc_ivar_list_record = objc_start_struct (NULL_TREE);
4301 /* int method_count; */
4302 field_decl = create_field_decl (integer_type_node, "method_count");
4303 field_decl_chain = field_decl;
4305 /* struct objc_method method_list[]; */
4306 field_decl = create_field_decl (build_array_type
4309 (build_int_cst (NULL_TREE, size - 1))),
4311 chainon (field_decl_chain, field_decl);
4313 objc_finish_struct (objc_ivar_list_record, field_decl_chain);
4315 return objc_ivar_list_record;
4319 build_method_prototype_template (void)
4322 tree field_decl, field_decl_chain;
4324 proto_record = objc_start_struct (get_identifier (UTAG_METHOD_PROTOTYPE));
4327 field_decl = create_field_decl (objc_selector_type, "_cmd");
4328 field_decl_chain = field_decl;
4330 /* char *method_types; */
4331 field_decl = create_field_decl (string_type_node, "method_types");
4332 chainon (field_decl_chain, field_decl);
4334 objc_finish_struct (proto_record, field_decl_chain);
4336 return proto_record;
4340 objc_method_parm_type (tree type)
4342 type = TREE_VALUE (TREE_TYPE (type));
4343 if (TREE_CODE (type) == TYPE_DECL)
4344 type = TREE_TYPE (type);
4349 objc_encoded_type_size (tree type)
4351 int sz = int_size_in_bytes (type);
4353 /* Make all integer and enum types at least as large
4355 if (sz > 0 && INTEGRAL_TYPE_P (type))
4356 sz = MAX (sz, int_size_in_bytes (integer_type_node));
4357 /* Treat arrays as pointers, since that's how they're
4359 else if (TREE_CODE (type) == ARRAY_TYPE)
4360 sz = int_size_in_bytes (ptr_type_node);
4365 encode_method_prototype (tree method_decl)
4372 /* ONEWAY and BYCOPY, for remote object are the only method qualifiers. */
4373 encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_decl)));
4375 /* Encode return type. */
4376 encode_type (objc_method_parm_type (method_decl),
4377 obstack_object_size (&util_obstack),
4378 OBJC_ENCODE_INLINE_DEFS);
4381 /* The first two arguments (self and _cmd) are pointers; account for
4383 i = int_size_in_bytes (ptr_type_node);
4384 parm_offset = 2 * i;
4385 for (parms = METHOD_SEL_ARGS (method_decl); parms;
4386 parms = TREE_CHAIN (parms))
4388 tree type = objc_method_parm_type (parms);
4389 int sz = objc_encoded_type_size (type);
4391 /* If a type size is not known, bail out. */
4394 error ("type %q+D does not have a known size",
4396 /* Pretend that the encoding succeeded; the compilation will
4397 fail nevertheless. */
4398 goto finish_encoding;
4403 sprintf (buf, "%d@0:%d", parm_offset, i);
4404 obstack_grow (&util_obstack, buf, strlen (buf));
4406 /* Argument types. */
4407 parm_offset = 2 * i;
4408 for (parms = METHOD_SEL_ARGS (method_decl); parms;
4409 parms = TREE_CHAIN (parms))
4411 tree type = objc_method_parm_type (parms);
4413 /* Process argument qualifiers for user supplied arguments. */
4414 encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (parms)));
4417 encode_type (type, obstack_object_size (&util_obstack),
4418 OBJC_ENCODE_INLINE_DEFS);
4420 /* Compute offset. */
4421 sprintf (buf, "%d", parm_offset);
4422 parm_offset += objc_encoded_type_size (type);
4424 obstack_grow (&util_obstack, buf, strlen (buf));
4428 obstack_1grow (&util_obstack, '\0');
4429 result = get_identifier (XOBFINISH (&util_obstack, char *));
4430 obstack_free (&util_obstack, util_firstobj);
4435 generate_descriptor_table (tree type, const char *name, int size, tree list,
4438 tree decl, initlist;
4440 decl = start_var_decl (type, synth_id_with_class_suffix (name, proto));
4442 initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size));
4443 initlist = tree_cons (NULL_TREE, list, initlist);
4445 finish_var_decl (decl, objc_build_constructor (type, nreverse (initlist)));
4451 generate_method_descriptors (tree protocol)
4453 tree initlist, chain, method_list_template;
4456 if (!objc_method_prototype_template)
4457 objc_method_prototype_template = build_method_prototype_template ();
4459 chain = PROTOCOL_CLS_METHODS (protocol);
4462 size = list_length (chain);
4464 method_list_template
4465 = build_method_prototype_list_template (objc_method_prototype_template,
4469 = build_descriptor_table_initializer (objc_method_prototype_template,
4472 UOBJC_CLASS_METHODS_decl
4473 = generate_descriptor_table (method_list_template,
4474 "_OBJC_PROTOCOL_CLASS_METHODS",
4475 size, initlist, protocol);
4478 UOBJC_CLASS_METHODS_decl = 0;
4480 chain = PROTOCOL_NST_METHODS (protocol);
4483 size = list_length (chain);
4485 method_list_template
4486 = build_method_prototype_list_template (objc_method_prototype_template,
4489 = build_descriptor_table_initializer (objc_method_prototype_template,
4492 UOBJC_INSTANCE_METHODS_decl
4493 = generate_descriptor_table (method_list_template,
4494 "_OBJC_PROTOCOL_INSTANCE_METHODS",
4495 size, initlist, protocol);
4498 UOBJC_INSTANCE_METHODS_decl = 0;
4502 generate_protocol_references (tree plist)
4506 /* Forward declare protocols referenced. */
4507 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
4509 tree proto = TREE_VALUE (lproto);
4511 if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE
4512 && PROTOCOL_NAME (proto))
4514 if (! PROTOCOL_FORWARD_DECL (proto))
4515 build_protocol_reference (proto);
4517 if (PROTOCOL_LIST (proto))
4518 generate_protocol_references (PROTOCOL_LIST (proto));
4523 /* Generate either '- .cxx_construct' or '- .cxx_destruct' for the
4527 objc_generate_cxx_ctor_or_dtor (bool dtor)
4529 tree fn, body, compound_stmt, ivar;
4531 /* - (id) .cxx_construct { ... return self; } */
4532 /* - (void) .cxx_construct { ... } */
4534 objc_set_method_type (MINUS_EXPR);
4535 objc_start_method_definition
4536 (objc_build_method_signature (build_tree_list (NULL_TREE,
4539 : objc_object_type),
4540 get_identifier (dtor
4542 : TAG_CXX_CONSTRUCT),
4543 make_node (TREE_LIST),
4545 body = begin_function_body ();
4546 compound_stmt = begin_compound_stmt (0);
4548 ivar = CLASS_IVARS (implementation_template);
4549 /* Destroy ivars in reverse order. */
4551 ivar = nreverse (copy_list (ivar));
4553 for (; ivar; ivar = TREE_CHAIN (ivar))
4555 if (TREE_CODE (ivar) == FIELD_DECL)
4557 tree type = TREE_TYPE (ivar);
4559 /* Call the ivar's default constructor or destructor. Do not
4560 call the destructor unless a corresponding constructor call
4561 has also been made (or is not needed). */
4562 if (MAYBE_CLASS_TYPE_P (type)
4564 ? (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4565 && (!TYPE_NEEDS_CONSTRUCTING (type)
4566 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4567 : (TYPE_NEEDS_CONSTRUCTING (type)
4568 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))))
4570 (build_special_member_call
4571 (build_ivar_reference (DECL_NAME (ivar)),
4572 dtor ? complete_dtor_identifier : complete_ctor_identifier,
4573 NULL, type, LOOKUP_NORMAL, tf_warning_or_error));
4577 /* The constructor returns 'self'. */
4579 finish_return_stmt (self_decl);
4581 finish_compound_stmt (compound_stmt);
4582 finish_function_body (body);
4583 fn = current_function_decl;
4585 objc_finish_method_definition (fn);
4588 /* The following routine will examine the current @interface for any
4589 non-POD C++ ivars requiring non-trivial construction and/or
4590 destruction, and then synthesize special '- .cxx_construct' and/or
4591 '- .cxx_destruct' methods which will run the appropriate
4592 construction or destruction code. Note that ivars inherited from
4593 super-classes are _not_ considered. */
4595 objc_generate_cxx_cdtors (void)
4597 bool need_ctor = false, need_dtor = false;
4600 /* We do not want to do this for categories, since they do not have
4603 if (TREE_CODE (objc_implementation_context) != CLASS_IMPLEMENTATION_TYPE)
4606 /* First, determine if we even need a constructor and/or destructor. */
4608 for (ivar = CLASS_IVARS (implementation_template); ivar;
4609 ivar = TREE_CHAIN (ivar))
4611 if (TREE_CODE (ivar) == FIELD_DECL)
4613 tree type = TREE_TYPE (ivar);
4615 if (MAYBE_CLASS_TYPE_P (type))
4617 if (TYPE_NEEDS_CONSTRUCTING (type)
4618 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
4619 /* NB: If a default constructor is not available, we will not
4620 be able to initialize this ivar; the add_instance_variable()
4621 routine will already have warned about this. */
4624 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4625 && (!TYPE_NEEDS_CONSTRUCTING (type)
4626 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4627 /* NB: If a default constructor is not available, we will not
4628 call the destructor either, for symmetry. */
4634 /* Generate '- .cxx_construct' if needed. */
4637 objc_generate_cxx_ctor_or_dtor (false);
4639 /* Generate '- .cxx_destruct' if needed. */
4642 objc_generate_cxx_ctor_or_dtor (true);
4644 /* The 'imp_list' variable points at an imp_entry record for the current
4645 @implementation. Record the existence of '- .cxx_construct' and/or
4646 '- .cxx_destruct' methods therein; it will be included in the
4647 metadata for the class. */
4648 if (flag_next_runtime)
4649 imp_list->has_cxx_cdtors = (need_ctor || need_dtor);
4653 /* For each protocol which was referenced either from a @protocol()
4654 expression, or because a class/category implements it (then a
4655 pointer to the protocol is stored in the struct describing the
4656 class/category), we create a statically allocated instance of the
4657 Protocol class. The code is written in such a way as to generate
4658 as few Protocol objects as possible; we generate a unique Protocol
4659 instance for each protocol, and we don't generate a Protocol
4660 instance if the protocol is never referenced (either from a
4661 @protocol() or from a class/category implementation). These
4662 statically allocated objects can be referred to via the static
4663 (that is, private to this module) symbols _OBJC_PROTOCOL_n.
4665 The statically allocated Protocol objects that we generate here
4666 need to be fixed up at runtime in order to be used: the 'isa'
4667 pointer of the objects need to be set up to point to the 'Protocol'
4668 class, as known at runtime.
4670 The NeXT runtime fixes up all protocols at program startup time,
4671 before main() is entered. It uses a low-level trick to look up all
4672 those symbols, then loops on them and fixes them up.
4674 The GNU runtime as well fixes up all protocols before user code
4675 from the module is executed; it requires pointers to those symbols
4676 to be put in the objc_symtab (which is then passed as argument to
4677 the function __objc_exec_class() which the compiler sets up to be
4678 executed automatically when the module is loaded); setup of those
4679 Protocol objects happen in two ways in the GNU runtime: all
4680 Protocol objects referred to by a class or category implementation
4681 are fixed up when the class/category is loaded; all Protocol
4682 objects referred to by a @protocol() expression are added by the
4683 compiler to the list of statically allocated instances to fixup
4684 (the same list holding the statically allocated constant string
4685 objects). Because, as explained above, the compiler generates as
4686 few Protocol objects as possible, some Protocol object might end up
4687 being referenced multiple times when compiled with the GNU runtime,
4688 and end up being fixed up multiple times at runtime initialization.
4689 But that doesn't hurt, it's just a little inefficient. */
4692 generate_protocols (void)
4696 tree initlist, protocol_name_expr, refs_decl, refs_expr;
4698 /* If a protocol was directly referenced, pull in indirect references. */
4699 for (p = protocol_chain; p; p = TREE_CHAIN (p))
4700 if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p))
4701 generate_protocol_references (PROTOCOL_LIST (p));
4703 for (p = protocol_chain; p; p = TREE_CHAIN (p))
4705 tree nst_methods = PROTOCOL_NST_METHODS (p);
4706 tree cls_methods = PROTOCOL_CLS_METHODS (p);
4708 /* If protocol wasn't referenced, don't generate any code. */
4709 decl = PROTOCOL_FORWARD_DECL (p);
4714 /* Make sure we link in the Protocol class. */
4715 add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
4719 if (! METHOD_ENCODING (nst_methods))
4721 encoding = encode_method_prototype (nst_methods);
4722 METHOD_ENCODING (nst_methods) = encoding;
4724 nst_methods = TREE_CHAIN (nst_methods);
4729 if (! METHOD_ENCODING (cls_methods))
4731 encoding = encode_method_prototype (cls_methods);
4732 METHOD_ENCODING (cls_methods) = encoding;
4735 cls_methods = TREE_CHAIN (cls_methods);
4737 generate_method_descriptors (p);
4739 if (PROTOCOL_LIST (p))
4740 refs_decl = generate_protocol_list (p);
4744 /* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
4745 protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
4748 refs_expr = convert (build_pointer_type (build_pointer_type
4749 (objc_protocol_template)),
4750 build_unary_op (input_location,
4751 ADDR_EXPR, refs_decl, 0));
4753 refs_expr = build_int_cst (NULL_TREE, 0);
4755 /* UOBJC_INSTANCE_METHODS_decl/UOBJC_CLASS_METHODS_decl are set
4756 by generate_method_descriptors, which is called above. */
4757 initlist = build_protocol_initializer (TREE_TYPE (decl),
4758 protocol_name_expr, refs_expr,
4759 UOBJC_INSTANCE_METHODS_decl,
4760 UOBJC_CLASS_METHODS_decl);
4761 finish_var_decl (decl, initlist);
4766 build_protocol_initializer (tree type, tree protocol_name,
4767 tree protocol_list, tree instance_methods,
4770 tree initlist = NULL_TREE, expr;
4771 tree cast_type = build_pointer_type
4772 (xref_tag (RECORD_TYPE,
4773 get_identifier (UTAG_CLASS)));
4775 /* Filling the "isa" in with one allows the runtime system to
4776 detect that the version change...should remove before final release. */
4778 expr = build_int_cst (cast_type, PROTOCOL_VERSION);
4779 initlist = tree_cons (NULL_TREE, expr, initlist);
4780 initlist = tree_cons (NULL_TREE, protocol_name, initlist);
4781 initlist = tree_cons (NULL_TREE, protocol_list, initlist);
4783 if (!instance_methods)
4784 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
4787 expr = convert (objc_method_proto_list_ptr,
4788 build_unary_op (input_location,
4789 ADDR_EXPR, instance_methods, 0));
4790 initlist = tree_cons (NULL_TREE, expr, initlist);
4794 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
4797 expr = convert (objc_method_proto_list_ptr,
4798 build_unary_op (input_location,
4799 ADDR_EXPR, class_methods, 0));
4800 initlist = tree_cons (NULL_TREE, expr, initlist);
4803 return objc_build_constructor (type, nreverse (initlist));
4806 /* struct _objc_category {
4807 char *category_name;
4809 struct _objc_method_list *instance_methods;
4810 struct _objc_method_list *class_methods;
4811 struct _objc_protocol_list *protocols;
4815 build_category_template (void)
4817 tree field_decl, field_decl_chain;
4819 objc_category_template = objc_start_struct (get_identifier (UTAG_CATEGORY));
4821 /* char *category_name; */
4822 field_decl = create_field_decl (string_type_node, "category_name");
4823 field_decl_chain = field_decl;
4825 /* char *class_name; */
4826 field_decl = create_field_decl (string_type_node, "class_name");
4827 chainon (field_decl_chain, field_decl);
4829 /* struct _objc_method_list *instance_methods; */
4830 field_decl = create_field_decl (objc_method_list_ptr,
4831 "instance_methods");
4832 chainon (field_decl_chain, field_decl);
4834 /* struct _objc_method_list *class_methods; */
4835 field_decl = create_field_decl (objc_method_list_ptr,
4837 chainon (field_decl_chain, field_decl);
4839 /* struct _objc_protocol **protocol_list; */
4840 field_decl = create_field_decl (build_pointer_type
4842 (objc_protocol_template)),
4844 chainon (field_decl_chain, field_decl);
4846 objc_finish_struct (objc_category_template, field_decl_chain);
4849 /* struct _objc_selector {
4855 build_selector_template (void)
4857 tree field_decl, field_decl_chain;
4859 objc_selector_template = objc_start_struct (get_identifier (UTAG_SELECTOR));
4862 field_decl = create_field_decl (objc_selector_type, "sel_id");
4863 field_decl_chain = field_decl;
4865 /* char *sel_type; */
4866 field_decl = create_field_decl (string_type_node, "sel_type");
4867 chainon (field_decl_chain, field_decl);
4869 objc_finish_struct (objc_selector_template, field_decl_chain);
4872 /* struct _objc_class {
4873 struct _objc_class *isa;
4874 struct _objc_class *super_class;
4879 struct _objc_ivar_list *ivars;
4880 struct _objc_method_list *methods;
4881 #ifdef __NEXT_RUNTIME__
4882 struct objc_cache *cache;
4884 struct sarray *dtable;
4885 struct _objc_class *subclass_list;
4886 struct _objc_class *sibling_class;
4888 struct _objc_protocol_list *protocols;
4889 #ifdef __NEXT_RUNTIME__
4892 void *gc_object_type;
4895 /* NB: The 'sel_id' and 'gc_object_type' fields are not being used by
4896 the NeXT/Apple runtime; still, the compiler must generate them to
4897 maintain backward binary compatibility (and to allow for future
4901 build_class_template (void)
4903 tree field_decl, field_decl_chain;
4905 objc_class_template = objc_start_struct (get_identifier (UTAG_CLASS));
4907 /* struct _objc_class *isa; */
4908 field_decl = create_field_decl (build_pointer_type (objc_class_template),
4910 field_decl_chain = field_decl;
4912 /* struct _objc_class *super_class; */
4913 field_decl = create_field_decl (build_pointer_type (objc_class_template),
4915 chainon (field_decl_chain, field_decl);
4918 field_decl = create_field_decl (string_type_node, "name");
4919 chainon (field_decl_chain, field_decl);
4922 field_decl = create_field_decl (long_integer_type_node, "version");
4923 chainon (field_decl_chain, field_decl);
4926 field_decl = create_field_decl (long_integer_type_node, "info");
4927 chainon (field_decl_chain, field_decl);
4929 /* long instance_size; */
4930 field_decl = create_field_decl (long_integer_type_node, "instance_size");
4931 chainon (field_decl_chain, field_decl);
4933 /* struct _objc_ivar_list *ivars; */
4934 field_decl = create_field_decl (objc_ivar_list_ptr,
4936 chainon (field_decl_chain, field_decl);
4938 /* struct _objc_method_list *methods; */
4939 field_decl = create_field_decl (objc_method_list_ptr,
4941 chainon (field_decl_chain, field_decl);
4943 if (flag_next_runtime)
4945 /* struct objc_cache *cache; */
4946 field_decl = create_field_decl (build_pointer_type
4947 (xref_tag (RECORD_TYPE,
4951 chainon (field_decl_chain, field_decl);
4955 /* struct sarray *dtable; */
4956 field_decl = create_field_decl (build_pointer_type
4957 (xref_tag (RECORD_TYPE,
4961 chainon (field_decl_chain, field_decl);
4963 /* struct objc_class *subclass_list; */
4964 field_decl = create_field_decl (build_pointer_type
4965 (objc_class_template),
4967 chainon (field_decl_chain, field_decl);
4969 /* struct objc_class *sibling_class; */
4970 field_decl = create_field_decl (build_pointer_type
4971 (objc_class_template),
4973 chainon (field_decl_chain, field_decl);
4976 /* struct _objc_protocol **protocol_list; */
4977 field_decl = create_field_decl (build_pointer_type
4979 (xref_tag (RECORD_TYPE,
4983 chainon (field_decl_chain, field_decl);
4985 if (flag_next_runtime)
4988 field_decl = create_field_decl (build_pointer_type (void_type_node),
4990 chainon (field_decl_chain, field_decl);
4993 /* void *gc_object_type; */
4994 field_decl = create_field_decl (build_pointer_type (void_type_node),
4996 chainon (field_decl_chain, field_decl);
4998 objc_finish_struct (objc_class_template, field_decl_chain);
5001 /* Generate appropriate forward declarations for an implementation. */
5004 synth_forward_declarations (void)
5008 /* static struct objc_class _OBJC_CLASS_<my_name>; */
5009 UOBJC_CLASS_decl = build_metadata_decl ("_OBJC_CLASS",
5010 objc_class_template);
5012 /* static struct objc_class _OBJC_METACLASS_<my_name>; */
5013 UOBJC_METACLASS_decl = build_metadata_decl ("_OBJC_METACLASS",
5014 objc_class_template);
5016 /* Pre-build the following entities - for speed/convenience. */
5018 an_id = get_identifier ("super_class");
5019 ucls_super_ref = objc_build_component_ref (UOBJC_CLASS_decl, an_id);
5020 uucls_super_ref = objc_build_component_ref (UOBJC_METACLASS_decl, an_id);
5024 error_with_ivar (const char *message, tree decl)
5026 error_at (DECL_SOURCE_LOCATION (decl), "%s %qs",
5027 message, identifier_to_locale (gen_declaration (decl)));
5032 check_ivars (tree inter, tree imp)
5034 tree intdecls = CLASS_RAW_IVARS (inter);
5035 tree impdecls = CLASS_RAW_IVARS (imp);
5042 if (intdecls && TREE_CODE (intdecls) == TYPE_DECL)
5043 intdecls = TREE_CHAIN (intdecls);
5045 if (intdecls == 0 && impdecls == 0)
5047 if (intdecls == 0 || impdecls == 0)
5049 error ("inconsistent instance variable specification");
5053 t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls);
5055 if (!comptypes (t1, t2)
5056 || !tree_int_cst_equal (DECL_INITIAL (intdecls),
5057 DECL_INITIAL (impdecls)))
5059 if (DECL_NAME (intdecls) == DECL_NAME (impdecls))
5061 error_with_ivar ("conflicting instance variable type",
5063 error_with_ivar ("previous declaration of",
5066 else /* both the type and the name don't match */
5068 error ("inconsistent instance variable specification");
5073 else if (DECL_NAME (intdecls) != DECL_NAME (impdecls))
5075 error_with_ivar ("conflicting instance variable name",
5077 error_with_ivar ("previous declaration of",
5081 intdecls = TREE_CHAIN (intdecls);
5082 impdecls = TREE_CHAIN (impdecls);
5086 /* Set 'objc_super_template' to the data type node for 'struct _objc_super'.
5087 This needs to be done just once per compilation. */
5089 /* struct _objc_super {
5090 struct _objc_object *self;
5091 struct _objc_class *super_class;
5095 build_super_template (void)
5097 tree field_decl, field_decl_chain;
5099 objc_super_template = objc_start_struct (get_identifier (UTAG_SUPER));
5101 /* struct _objc_object *self; */
5102 field_decl = create_field_decl (objc_object_type, "self");
5103 field_decl_chain = field_decl;
5105 /* struct _objc_class *super_class; */
5106 field_decl = create_field_decl (build_pointer_type (objc_class_template),
5108 chainon (field_decl_chain, field_decl);
5110 objc_finish_struct (objc_super_template, field_decl_chain);
5113 /* struct _objc_ivar {
5120 build_ivar_template (void)
5122 tree objc_ivar_id, objc_ivar_record;
5123 tree field_decl, field_decl_chain;
5125 objc_ivar_id = get_identifier (UTAG_IVAR);
5126 objc_ivar_record = objc_start_struct (objc_ivar_id);
5128 /* char *ivar_name; */
5129 field_decl = create_field_decl (string_type_node, "ivar_name");
5130 field_decl_chain = field_decl;
5132 /* char *ivar_type; */
5133 field_decl = create_field_decl (string_type_node, "ivar_type");
5134 chainon (field_decl_chain, field_decl);
5136 /* int ivar_offset; */
5137 field_decl = create_field_decl (integer_type_node, "ivar_offset");
5138 chainon (field_decl_chain, field_decl);
5140 objc_finish_struct (objc_ivar_record, field_decl_chain);
5142 return objc_ivar_record;
5147 struct objc_ivar ivar_list[ivar_count];
5151 build_ivar_list_template (tree list_type, int size)
5153 tree objc_ivar_list_record;
5154 tree field_decl, field_decl_chain;
5156 objc_ivar_list_record = objc_start_struct (NULL_TREE);
5158 /* int ivar_count; */
5159 field_decl = create_field_decl (integer_type_node, "ivar_count");
5160 field_decl_chain = field_decl;
5162 /* struct objc_ivar ivar_list[]; */
5163 field_decl = create_field_decl (build_array_type
5166 (build_int_cst (NULL_TREE, size - 1))),
5168 chainon (field_decl_chain, field_decl);
5170 objc_finish_struct (objc_ivar_list_record, field_decl_chain);
5172 return objc_ivar_list_record;
5176 struct _objc__method_prototype_list *method_next;
5178 struct objc_method method_list[method_count];
5182 build_method_list_template (tree list_type, int size)
5184 tree objc_ivar_list_record;
5185 tree field_decl, field_decl_chain;
5187 objc_ivar_list_record = objc_start_struct (NULL_TREE);
5189 /* struct _objc__method_prototype_list *method_next; */
5190 field_decl = create_field_decl (objc_method_proto_list_ptr,
5192 field_decl_chain = field_decl;
5194 /* int method_count; */
5195 field_decl = create_field_decl (integer_type_node, "method_count");
5196 chainon (field_decl_chain, field_decl);
5198 /* struct objc_method method_list[]; */
5199 field_decl = create_field_decl (build_array_type
5202 (build_int_cst (NULL_TREE, size - 1))),
5204 chainon (field_decl_chain, field_decl);
5206 objc_finish_struct (objc_ivar_list_record, field_decl_chain);
5208 return objc_ivar_list_record;
5212 build_ivar_list_initializer (tree type, tree field_decl)
5214 tree initlist = NULL_TREE;
5218 tree ivar = NULL_TREE;
5221 if (DECL_NAME (field_decl))
5222 ivar = tree_cons (NULL_TREE,
5223 add_objc_string (DECL_NAME (field_decl),
5227 /* Unnamed bit-field ivar (yuck). */
5228 ivar = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), ivar);
5231 encode_field_decl (field_decl,
5232 obstack_object_size (&util_obstack),
5233 OBJC_ENCODE_DONT_INLINE_DEFS);
5235 /* Null terminate string. */
5236 obstack_1grow (&util_obstack, 0);
5240 add_objc_string (get_identifier (XOBFINISH (&util_obstack, char *)),
5243 obstack_free (&util_obstack, util_firstobj);
5246 ivar = tree_cons (NULL_TREE, byte_position (field_decl), ivar);
5247 initlist = tree_cons (NULL_TREE,
5248 objc_build_constructor (type, nreverse (ivar)),
5251 field_decl = TREE_CHAIN (field_decl);
5252 while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
5256 return objc_build_constructor (build_array_type (type, 0),
5257 nreverse (initlist));
5261 generate_ivars_list (tree type, const char *name, int size, tree list)
5263 tree decl, initlist;
5265 decl = start_var_decl (type, synth_id_with_class_suffix
5266 (name, objc_implementation_context));
5268 initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size));
5269 initlist = tree_cons (NULL_TREE, list, initlist);
5271 finish_var_decl (decl,
5272 objc_build_constructor (TREE_TYPE (decl),
5273 nreverse (initlist)));
5278 /* Count only the fields occurring in T. */
5281 ivar_list_length (tree t)
5285 for (; t; t = TREE_CHAIN (t))
5286 if (TREE_CODE (t) == FIELD_DECL)
5293 generate_ivar_lists (void)
5295 tree initlist, ivar_list_template, chain;
5298 generating_instance_variables = 1;
5300 if (!objc_ivar_template)
5301 objc_ivar_template = build_ivar_template ();
5303 /* Only generate class variables for the root of the inheritance
5304 hierarchy since these will be the same for every class. */
5306 if (CLASS_SUPER_NAME (implementation_template) == NULL_TREE
5307 && (chain = TYPE_FIELDS (objc_class_template)))
5309 size = ivar_list_length (chain);
5311 ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
5312 initlist = build_ivar_list_initializer (objc_ivar_template, chain);
5314 UOBJC_CLASS_VARIABLES_decl
5315 = generate_ivars_list (ivar_list_template, "_OBJC_CLASS_VARIABLES",
5319 UOBJC_CLASS_VARIABLES_decl = 0;
5321 chain = CLASS_IVARS (implementation_template);
5324 size = ivar_list_length (chain);
5325 ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
5326 initlist = build_ivar_list_initializer (objc_ivar_template, chain);
5328 UOBJC_INSTANCE_VARIABLES_decl
5329 = generate_ivars_list (ivar_list_template, "_OBJC_INSTANCE_VARIABLES",
5333 UOBJC_INSTANCE_VARIABLES_decl = 0;
5335 generating_instance_variables = 0;
5339 build_dispatch_table_initializer (tree type, tree entries)
5341 tree initlist = NULL_TREE;
5345 tree elemlist = NULL_TREE;
5347 elemlist = tree_cons (NULL_TREE,
5348 build_selector (METHOD_SEL_NAME (entries)),
5351 /* Generate the method encoding if we don't have one already. */
5352 if (! METHOD_ENCODING (entries))
5353 METHOD_ENCODING (entries) =
5354 encode_method_prototype (entries);
5356 elemlist = tree_cons (NULL_TREE,
5357 add_objc_string (METHOD_ENCODING (entries),
5362 = tree_cons (NULL_TREE,
5363 convert (ptr_type_node,
5364 build_unary_op (input_location, ADDR_EXPR,
5365 METHOD_DEFINITION (entries), 1)),
5368 initlist = tree_cons (NULL_TREE,
5369 objc_build_constructor (type, nreverse (elemlist)),
5372 entries = TREE_CHAIN (entries);
5376 return objc_build_constructor (build_array_type (type, 0),
5377 nreverse (initlist));
5380 /* To accomplish method prototyping without generating all kinds of
5381 inane warnings, the definition of the dispatch table entries were
5384 struct objc_method { SEL _cmd; ...; id (*_imp)(); };
5386 struct objc_method { SEL _cmd; ...; void *_imp; }; */
5389 build_method_template (void)
5392 tree field_decl, field_decl_chain;
5394 _SLT_record = objc_start_struct (get_identifier (UTAG_METHOD));
5397 field_decl = create_field_decl (objc_selector_type, "_cmd");
5398 field_decl_chain = field_decl;
5400 /* char *method_types; */
5401 field_decl = create_field_decl (string_type_node, "method_types");
5402 chainon (field_decl_chain, field_decl);
5405 field_decl = create_field_decl (build_pointer_type (void_type_node),
5407 chainon (field_decl_chain, field_decl);
5409 objc_finish_struct (_SLT_record, field_decl_chain);
5416 generate_dispatch_table (tree type, const char *name, int size, tree list)
5418 tree decl, initlist;
5420 decl = start_var_decl (type, synth_id_with_class_suffix
5421 (name, objc_implementation_context));
5423 initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 0));
5424 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, size), initlist);
5425 initlist = tree_cons (NULL_TREE, list, initlist);
5427 finish_var_decl (decl,
5428 objc_build_constructor (TREE_TYPE (decl),
5429 nreverse (initlist)));
5435 mark_referenced_methods (void)
5437 struct imp_entry *impent;
5440 for (impent = imp_list; impent; impent = impent->next)
5442 chain = CLASS_CLS_METHODS (impent->imp_context);
5445 cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain)));
5446 chain = TREE_CHAIN (chain);
5449 chain = CLASS_NST_METHODS (impent->imp_context);
5452 cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain)));
5453 chain = TREE_CHAIN (chain);
5459 generate_dispatch_tables (void)
5461 tree initlist, chain, method_list_template;
5464 if (!objc_method_template)
5465 objc_method_template = build_method_template ();
5467 chain = CLASS_CLS_METHODS (objc_implementation_context);
5470 size = list_length (chain);
5472 method_list_template
5473 = build_method_list_template (objc_method_template, size);
5475 = build_dispatch_table_initializer (objc_method_template, chain);
5477 UOBJC_CLASS_METHODS_decl
5478 = generate_dispatch_table (method_list_template,
5479 ((TREE_CODE (objc_implementation_context)
5480 == CLASS_IMPLEMENTATION_TYPE)
5481 ? "_OBJC_CLASS_METHODS"
5482 : "_OBJC_CATEGORY_CLASS_METHODS"),
5486 UOBJC_CLASS_METHODS_decl = 0;
5488 chain = CLASS_NST_METHODS (objc_implementation_context);
5491 size = list_length (chain);
5493 method_list_template
5494 = build_method_list_template (objc_method_template, size);
5496 = build_dispatch_table_initializer (objc_method_template, chain);
5498 if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
5499 UOBJC_INSTANCE_METHODS_decl
5500 = generate_dispatch_table (method_list_template,
5501 "_OBJC_INSTANCE_METHODS",
5504 /* We have a category. */
5505 UOBJC_INSTANCE_METHODS_decl
5506 = generate_dispatch_table (method_list_template,
5507 "_OBJC_CATEGORY_INSTANCE_METHODS",
5511 UOBJC_INSTANCE_METHODS_decl = 0;
5515 generate_protocol_list (tree i_or_p)
5518 tree refs_decl, lproto, e, plist;
5520 const char *ref_name;
5522 if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE
5523 || TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
5524 plist = CLASS_PROTOCOL_LIST (i_or_p);
5525 else if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
5526 plist = PROTOCOL_LIST (i_or_p);
5531 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
5532 if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
5533 && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto)))
5536 /* Build initializer. */
5537 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), NULL_TREE);
5538 e = build_int_cst (build_pointer_type (objc_protocol_template), size);
5539 initlist = tree_cons (NULL_TREE, e, initlist);
5541 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
5543 tree pval = TREE_VALUE (lproto);
5545 if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
5546 && PROTOCOL_FORWARD_DECL (pval))
5548 e = build_unary_op (input_location, ADDR_EXPR,
5549 PROTOCOL_FORWARD_DECL (pval), 0);
5550 initlist = tree_cons (NULL_TREE, e, initlist);
5554 /* static struct objc_protocol *refs[n]; */
5556 if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
5557 ref_name = synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS", i_or_p);
5558 else if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE)
5559 ref_name = synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS", i_or_p);
5560 else if (TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
5561 ref_name = synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS", i_or_p);
5565 refs_decl = start_var_decl
5567 (build_pointer_type (objc_protocol_template),
5568 build_index_type (build_int_cst (NULL_TREE, size + 2))),
5571 finish_var_decl (refs_decl, objc_build_constructor (TREE_TYPE (refs_decl),
5572 nreverse (initlist)));
5578 build_category_initializer (tree type, tree cat_name, tree class_name,
5579 tree instance_methods, tree class_methods,
5582 tree initlist = NULL_TREE, expr;
5584 initlist = tree_cons (NULL_TREE, cat_name, initlist);
5585 initlist = tree_cons (NULL_TREE, class_name, initlist);
5587 if (!instance_methods)
5588 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5591 expr = convert (objc_method_list_ptr,
5592 build_unary_op (input_location, ADDR_EXPR,
5593 instance_methods, 0));
5594 initlist = tree_cons (NULL_TREE, expr, initlist);
5597 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5600 expr = convert (objc_method_list_ptr,
5601 build_unary_op (input_location, ADDR_EXPR,
5603 initlist = tree_cons (NULL_TREE, expr, initlist);
5606 /* protocol_list = */
5608 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5611 expr = convert (build_pointer_type
5613 (objc_protocol_template)),
5614 build_unary_op (input_location, ADDR_EXPR,
5616 initlist = tree_cons (NULL_TREE, expr, initlist);
5619 return objc_build_constructor (type, nreverse (initlist));
5622 /* struct _objc_class {
5623 struct objc_class *isa;
5624 struct objc_class *super_class;
5629 struct objc_ivar_list *ivars;
5630 struct objc_method_list *methods;
5631 if (flag_next_runtime)
5632 struct objc_cache *cache;
5634 struct sarray *dtable;
5635 struct objc_class *subclass_list;
5636 struct objc_class *sibling_class;
5638 struct objc_protocol_list *protocols;
5639 if (flag_next_runtime)
5641 void *gc_object_type;
5645 build_shared_structure_initializer (tree type, tree isa, tree super,
5646 tree name, tree size, int status,
5647 tree dispatch_table, tree ivar_list,
5650 tree initlist = NULL_TREE, expr;
5653 initlist = tree_cons (NULL_TREE, isa, initlist);
5656 initlist = tree_cons (NULL_TREE, super, initlist);
5659 initlist = tree_cons (NULL_TREE, default_conversion (name), initlist);
5662 initlist = tree_cons (NULL_TREE, build_int_cst (long_integer_type_node, 0),
5666 initlist = tree_cons (NULL_TREE,
5667 build_int_cst (long_integer_type_node, status),
5670 /* instance_size = */
5671 initlist = tree_cons (NULL_TREE, convert (long_integer_type_node, size),
5674 /* objc_ivar_list = */
5676 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5679 expr = convert (objc_ivar_list_ptr,
5680 build_unary_op (input_location, ADDR_EXPR,
5682 initlist = tree_cons (NULL_TREE, expr, initlist);
5685 /* objc_method_list = */
5686 if (!dispatch_table)
5687 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5690 expr = convert (objc_method_list_ptr,
5691 build_unary_op (input_location, ADDR_EXPR,
5692 dispatch_table, 0));
5693 initlist = tree_cons (NULL_TREE, expr, initlist);
5696 if (flag_next_runtime)
5697 /* method_cache = */
5698 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5702 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5704 /* subclass_list = */
5705 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5707 /* sibling_class = */
5708 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5711 /* protocol_list = */
5712 if (! protocol_list)
5713 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5716 expr = convert (build_pointer_type
5718 (objc_protocol_template)),
5719 build_unary_op (input_location, ADDR_EXPR,
5721 initlist = tree_cons (NULL_TREE, expr, initlist);
5724 if (flag_next_runtime)
5726 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5728 /* gc_object_type = NULL */
5729 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
5731 return objc_build_constructor (type, nreverse (initlist));
5734 /* Retrieve category interface CAT_NAME (if any) associated with CLASS. */
5737 lookup_category (tree klass, tree cat_name)
5739 tree category = CLASS_CATEGORY_LIST (klass);
5741 while (category && CLASS_SUPER_NAME (category) != cat_name)
5742 category = CLASS_CATEGORY_LIST (category);
5746 /* static struct objc_category _OBJC_CATEGORY_<name> = { ... }; */
5749 generate_category (tree cat)
5752 tree initlist, cat_name_expr, class_name_expr;
5753 tree protocol_decl, category;
5755 add_class_reference (CLASS_NAME (cat));
5756 cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names);
5758 class_name_expr = add_objc_string (CLASS_NAME (cat), class_names);
5760 category = lookup_category (implementation_template,
5761 CLASS_SUPER_NAME (cat));
5763 if (category && CLASS_PROTOCOL_LIST (category))
5765 generate_protocol_references (CLASS_PROTOCOL_LIST (category));
5766 protocol_decl = generate_protocol_list (category);
5771 decl = start_var_decl (objc_category_template,
5772 synth_id_with_class_suffix
5773 ("_OBJC_CATEGORY", objc_implementation_context));
5775 initlist = build_category_initializer (TREE_TYPE (decl),
5776 cat_name_expr, class_name_expr,
5777 UOBJC_INSTANCE_METHODS_decl,
5778 UOBJC_CLASS_METHODS_decl,
5781 finish_var_decl (decl, initlist);
5784 /* static struct objc_class _OBJC_METACLASS_Foo={ ... };
5785 static struct objc_class _OBJC_CLASS_Foo={ ... }; */
5788 generate_shared_structures (int cls_flags)
5791 tree name_expr, super_expr, root_expr;
5792 tree my_root_id = NULL_TREE, my_super_id = NULL_TREE;
5793 tree cast_type, initlist, protocol_decl;
5795 my_super_id = CLASS_SUPER_NAME (implementation_template);
5798 add_class_reference (my_super_id);
5800 /* Compute "my_root_id" - this is required for code generation.
5801 the "isa" for all meta class structures points to the root of
5802 the inheritance hierarchy (e.g. "__Object")... */
5803 my_root_id = my_super_id;
5806 tree my_root_int = lookup_interface (my_root_id);
5808 if (my_root_int && CLASS_SUPER_NAME (my_root_int))
5809 my_root_id = CLASS_SUPER_NAME (my_root_int);
5816 /* No super class. */
5817 my_root_id = CLASS_NAME (implementation_template);
5819 cast_type = build_pointer_type (objc_class_template);
5820 name_expr = add_objc_string (CLASS_NAME (implementation_template),
5823 /* Install class `isa' and `super' pointers at runtime. */
5826 super_expr = add_objc_string (my_super_id, class_names);
5827 super_expr = build_c_cast (input_location,
5828 cast_type, super_expr); /* cast! */
5831 super_expr = build_int_cst (NULL_TREE, 0);
5833 root_expr = add_objc_string (my_root_id, class_names);
5834 root_expr = build_c_cast (input_location, cast_type, root_expr); /* cast! */
5836 if (CLASS_PROTOCOL_LIST (implementation_template))
5838 generate_protocol_references
5839 (CLASS_PROTOCOL_LIST (implementation_template));
5840 protocol_decl = generate_protocol_list (implementation_template);
5845 /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */
5847 decl = start_var_decl (objc_class_template,
5849 (DECL_NAME (UOBJC_METACLASS_decl)));
5852 = build_shared_structure_initializer
5854 root_expr, super_expr, name_expr,
5855 convert (integer_type_node, TYPE_SIZE_UNIT (objc_class_template)),
5857 UOBJC_CLASS_METHODS_decl,
5858 UOBJC_CLASS_VARIABLES_decl,
5861 finish_var_decl (decl, initlist);
5863 /* static struct objc_class _OBJC_CLASS_Foo={ ... }; */
5865 decl = start_var_decl (objc_class_template,
5867 (DECL_NAME (UOBJC_CLASS_decl)));
5870 = build_shared_structure_initializer
5872 build_unary_op (input_location, ADDR_EXPR, UOBJC_METACLASS_decl, 0),
5873 super_expr, name_expr,
5874 convert (integer_type_node,
5875 TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE
5876 (implementation_template))),
5877 1 /*CLS_FACTORY*/ | cls_flags,
5878 UOBJC_INSTANCE_METHODS_decl,
5879 UOBJC_INSTANCE_VARIABLES_decl,
5882 finish_var_decl (decl, initlist);
5887 synth_id_with_class_suffix (const char *preamble, tree ctxt)
5889 static char string[BUFSIZE];
5891 if (TREE_CODE (ctxt) == CLASS_IMPLEMENTATION_TYPE
5892 || TREE_CODE (ctxt) == CLASS_INTERFACE_TYPE)
5894 sprintf (string, "%s_%s", preamble,
5895 IDENTIFIER_POINTER (CLASS_NAME (ctxt)));
5897 else if (TREE_CODE (ctxt) == CATEGORY_IMPLEMENTATION_TYPE
5898 || TREE_CODE (ctxt) == CATEGORY_INTERFACE_TYPE)
5900 /* We have a category. */
5901 const char *const class_name
5902 = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
5903 const char *const class_super_name
5904 = IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context));
5905 sprintf (string, "%s_%s_%s", preamble, class_name, class_super_name);
5907 else if (TREE_CODE (ctxt) == PROTOCOL_INTERFACE_TYPE)
5909 const char *protocol_name = IDENTIFIER_POINTER (PROTOCOL_NAME (ctxt));
5910 sprintf (string, "%s_%s", preamble, protocol_name);
5918 /* If type is empty or only type qualifiers are present, add default
5919 type of id (otherwise grokdeclarator will default to int). */
5922 adjust_type_for_id_default (tree type)
5925 type = make_node (TREE_LIST);
5927 if (!TREE_VALUE (type))
5928 TREE_VALUE (type) = objc_object_type;
5929 else if (TREE_CODE (TREE_VALUE (type)) == RECORD_TYPE
5930 && TYPED_OBJECT (TREE_VALUE (type)))
5931 error ("can not use an object as parameter to a method");
5938 selector ':' '(' typename ')' identifier
5941 Transform an Objective-C keyword argument into
5942 the C equivalent parameter declarator.
5944 In: key_name, an "identifier_node" (optional).
5945 arg_type, a "tree_list" (optional).
5946 arg_name, an "identifier_node".
5948 Note: It would be really nice to strongly type the preceding
5949 arguments in the function prototype; however, then I
5950 could not use the "accessor" macros defined in "tree.h".
5952 Out: an instance of "keyword_decl". */
5955 objc_build_keyword_decl (tree key_name, tree arg_type, tree arg_name)
5959 /* If no type is specified, default to "id". */
5960 arg_type = adjust_type_for_id_default (arg_type);
5962 keyword_decl = make_node (KEYWORD_DECL);
5964 TREE_TYPE (keyword_decl) = arg_type;
5965 KEYWORD_ARG_NAME (keyword_decl) = arg_name;
5966 KEYWORD_KEY_NAME (keyword_decl) = key_name;
5968 return keyword_decl;
5971 /* Given a chain of keyword_decl's, synthesize the full keyword selector. */
5974 build_keyword_selector (tree selector)
5977 tree key_chain, key_name;
5980 /* Scan the selector to see how much space we'll need. */
5981 for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
5983 if (TREE_CODE (selector) == KEYWORD_DECL)
5984 key_name = KEYWORD_KEY_NAME (key_chain);
5985 else if (TREE_CODE (selector) == TREE_LIST)
5986 key_name = TREE_PURPOSE (key_chain);
5991 len += IDENTIFIER_LENGTH (key_name) + 1;
5993 /* Just a ':' arg. */
5997 buf = (char *) alloca (len + 1);
5998 /* Start the buffer out as an empty string. */
6001 for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
6003 if (TREE_CODE (selector) == KEYWORD_DECL)
6004 key_name = KEYWORD_KEY_NAME (key_chain);
6005 else if (TREE_CODE (selector) == TREE_LIST)
6007 key_name = TREE_PURPOSE (key_chain);
6008 /* The keyword decl chain will later be used as a function argument
6009 chain. Unhook the selector itself so as to not confuse other
6010 parts of the compiler. */
6011 TREE_PURPOSE (key_chain) = NULL_TREE;
6017 strcat (buf, IDENTIFIER_POINTER (key_name));
6021 return get_identifier (buf);
6024 /* Used for declarations and definitions. */
6027 build_method_decl (enum tree_code code, tree ret_type, tree selector,
6028 tree add_args, bool ellipsis)
6032 /* If no type is specified, default to "id". */
6033 ret_type = adjust_type_for_id_default (ret_type);
6035 method_decl = make_node (code);
6036 TREE_TYPE (method_decl) = ret_type;
6038 /* If we have a keyword selector, create an identifier_node that
6039 represents the full selector name (`:' included)... */
6040 if (TREE_CODE (selector) == KEYWORD_DECL)
6042 METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector);
6043 METHOD_SEL_ARGS (method_decl) = selector;
6044 METHOD_ADD_ARGS (method_decl) = add_args;
6045 METHOD_ADD_ARGS_ELLIPSIS_P (method_decl) = ellipsis;
6049 METHOD_SEL_NAME (method_decl) = selector;
6050 METHOD_SEL_ARGS (method_decl) = NULL_TREE;
6051 METHOD_ADD_ARGS (method_decl) = NULL_TREE;
6057 #define METHOD_DEF 0
6058 #define METHOD_REF 1
6060 /* Used by `build_objc_method_call' and `comp_proto_with_proto'. Return
6061 an argument list for method METH. CONTEXT is either METHOD_DEF or
6062 METHOD_REF, saying whether we are trying to define a method or call
6063 one. SUPERFLAG says this is for a send to super; this makes a
6064 difference for the NeXT calling sequence in which the lookup and
6065 the method call are done together. If METH is null, user-defined
6066 arguments (i.e., beyond self and _cmd) shall be represented by `...'. */
6069 get_arg_type_list (tree meth, int context, int superflag)
6073 /* Receiver type. */
6074 if (flag_next_runtime && superflag)
6075 arglist = build_tree_list (NULL_TREE, objc_super_type);
6076 else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
6077 arglist = build_tree_list (NULL_TREE, objc_instance_type);
6079 arglist = build_tree_list (NULL_TREE, objc_object_type);
6081 /* Selector type - will eventually change to `int'. */
6082 chainon (arglist, build_tree_list (NULL_TREE, objc_selector_type));
6084 /* No actual method prototype given -- assume that remaining arguments
6089 /* Build a list of argument types. */
6090 for (akey = METHOD_SEL_ARGS (meth); akey; akey = TREE_CHAIN (akey))
6092 tree arg_type = TREE_VALUE (TREE_TYPE (akey));
6094 /* Decay arrays and functions into pointers. */
6095 if (TREE_CODE (arg_type) == ARRAY_TYPE)
6096 arg_type = build_pointer_type (TREE_TYPE (arg_type));
6097 else if (TREE_CODE (arg_type) == FUNCTION_TYPE)
6098 arg_type = build_pointer_type (arg_type);
6100 chainon (arglist, build_tree_list (NULL_TREE, arg_type));
6103 if (METHOD_ADD_ARGS (meth))
6105 for (akey = TREE_CHAIN (METHOD_ADD_ARGS (meth));
6106 akey; akey = TREE_CHAIN (akey))
6108 tree arg_type = TREE_TYPE (TREE_VALUE (akey));
6110 chainon (arglist, build_tree_list (NULL_TREE, arg_type));
6113 if (!METHOD_ADD_ARGS_ELLIPSIS_P (meth))
6114 goto lack_of_ellipsis;
6119 chainon (arglist, OBJC_VOID_AT_END);
6126 check_duplicates (hash hsh, int methods, int is_class)
6128 tree meth = NULL_TREE;
6136 /* We have two or more methods with the same name but
6140 /* But just how different are those types? If
6141 -Wno-strict-selector-match is specified, we shall not
6142 complain if the differences are solely among types with
6143 identical size and alignment. */
6144 if (!warn_strict_selector_match)
6146 for (loop = hsh->list; loop; loop = loop->next)
6147 if (!comp_proto_with_proto (meth, loop->value, 0))
6156 bool type = TREE_CODE (meth) == INSTANCE_METHOD_DECL;
6158 warning_at (input_location, 0,
6159 "multiple methods named %<%c%E%> found",
6160 (is_class ? '+' : '-'),
6161 METHOD_SEL_NAME (meth));
6162 inform (DECL_SOURCE_LOCATION (meth), "using %<%c%s%>",
6164 identifier_to_locale (gen_method_decl (meth)));
6168 bool type = TREE_CODE (meth) == INSTANCE_METHOD_DECL;
6170 warning_at (input_location, 0,
6171 "multiple selectors named %<%c%E%> found",
6172 (is_class ? '+' : '-'),
6173 METHOD_SEL_NAME (meth));
6174 inform (DECL_SOURCE_LOCATION (meth), "found %<%c%s%>",
6176 identifier_to_locale (gen_method_decl (meth)));
6179 for (loop = hsh->list; loop; loop = loop->next)
6181 bool type = TREE_CODE (loop->value) == INSTANCE_METHOD_DECL;
6183 inform (DECL_SOURCE_LOCATION (loop->value), "also found %<%c%s%>",
6185 identifier_to_locale (gen_method_decl (loop->value)));
6192 /* If RECEIVER is a class reference, return the identifier node for
6193 the referenced class. RECEIVER is created by objc_get_class_reference,
6194 so we check the exact form created depending on which runtimes are
6198 receiver_is_class_object (tree receiver, int self, int super)
6200 tree chain, exp, arg;
6202 /* The receiver is 'self' or 'super' in the context of a class method. */
6203 if (objc_method_context
6204 && TREE_CODE (objc_method_context) == CLASS_METHOD_DECL
6207 ? CLASS_SUPER_NAME (implementation_template)
6208 : CLASS_NAME (implementation_template));
6210 if (flag_next_runtime)
6212 /* The receiver is a variable created by
6213 build_class_reference_decl. */
6214 if (TREE_CODE (receiver) == VAR_DECL && IS_CLASS (TREE_TYPE (receiver)))
6215 /* Look up the identifier. */
6216 for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
6217 if (TREE_PURPOSE (chain) == receiver)
6218 return TREE_VALUE (chain);
6221 /* The receiver is a function call that returns an id. Check if
6222 it is a call to objc_getClass, if so, pick up the class name. */
6223 if (TREE_CODE (receiver) == CALL_EXPR
6224 && (exp = CALL_EXPR_FN (receiver))
6225 && TREE_CODE (exp) == ADDR_EXPR
6226 && (exp = TREE_OPERAND (exp, 0))
6227 && TREE_CODE (exp) == FUNCTION_DECL
6228 /* For some reason, we sometimes wind up with multiple FUNCTION_DECL
6229 prototypes for objc_get_class(). Thankfully, they seem to share the
6230 same function type. */
6231 && TREE_TYPE (exp) == TREE_TYPE (objc_get_class_decl)
6232 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp)), TAG_GETCLASS)
6233 /* We have a call to objc_get_class/objc_getClass! */
6234 && (arg = CALL_EXPR_ARG (receiver, 0)))
6237 if (TREE_CODE (arg) == ADDR_EXPR
6238 && (arg = TREE_OPERAND (arg, 0))
6239 && TREE_CODE (arg) == STRING_CST)
6240 /* Finally, we have the class name. */
6241 return get_identifier (TREE_STRING_POINTER (arg));
6246 /* If we are currently building a message expr, this holds
6247 the identifier of the selector of the message. This is
6248 used when printing warnings about argument mismatches. */
6250 static tree current_objc_message_selector = 0;
6253 objc_message_selector (void)
6255 return current_objc_message_selector;
6258 /* Construct an expression for sending a message.
6259 MESS has the object to send to in TREE_PURPOSE
6260 and the argument list (including selector) in TREE_VALUE.
6262 (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
6263 (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */
6266 objc_build_message_expr (tree mess)
6268 tree receiver = TREE_PURPOSE (mess);
6271 tree args = TREE_PURPOSE (TREE_VALUE (mess));
6273 tree args = TREE_VALUE (mess);
6275 tree method_params = NULL_TREE;
6277 if (TREE_CODE (receiver) == ERROR_MARK || TREE_CODE (args) == ERROR_MARK)
6278 return error_mark_node;
6280 /* Obtain the full selector name. */
6281 if (TREE_CODE (args) == IDENTIFIER_NODE)
6282 /* A unary selector. */
6284 else if (TREE_CODE (args) == TREE_LIST)
6285 sel_name = build_keyword_selector (args);
6289 /* Build the parameter list to give to the method. */
6290 if (TREE_CODE (args) == TREE_LIST)
6292 method_params = chainon (args, TREE_VALUE (TREE_VALUE (mess)));
6295 tree chain = args, prev = NULL_TREE;
6297 /* We have a keyword selector--check for comma expressions. */
6300 tree element = TREE_VALUE (chain);
6302 /* We have a comma expression, must collapse... */
6303 if (TREE_CODE (element) == TREE_LIST)
6306 TREE_CHAIN (prev) = element;
6311 chain = TREE_CHAIN (chain);
6313 method_params = args;
6318 if (processing_template_decl)
6319 /* Must wait until template instantiation time. */
6320 return build_min_nt (MESSAGE_SEND_EXPR, receiver, sel_name,
6324 return objc_finish_message_expr (receiver, sel_name, method_params);
6327 /* Look up method SEL_NAME that would be suitable for receiver
6328 of type 'id' (if IS_CLASS is zero) or 'Class' (if IS_CLASS is
6329 nonzero), and report on any duplicates. */
6332 lookup_method_in_hash_lists (tree sel_name, int is_class)
6334 hash method_prototype = NULL;
6337 method_prototype = hash_lookup (nst_method_hash_list,
6340 if (!method_prototype)
6342 method_prototype = hash_lookup (cls_method_hash_list,
6347 return check_duplicates (method_prototype, 1, is_class);
6350 /* The 'objc_finish_message_expr' routine is called from within
6351 'objc_build_message_expr' for non-template functions. In the case of
6352 C++ template functions, it is called from 'build_expr_from_tree'
6353 (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded. */
6356 objc_finish_message_expr (tree receiver, tree sel_name, tree method_params)
6358 tree method_prototype = NULL_TREE, rprotos = NULL_TREE, rtype;
6359 tree selector, retval, class_tree;
6360 int self, super, have_cast;
6362 /* Extract the receiver of the message, as well as its type
6363 (where the latter may take the form of a cast or be inferred
6364 from the implementation context). */
6366 while (TREE_CODE (rtype) == COMPOUND_EXPR
6367 || TREE_CODE (rtype) == MODIFY_EXPR
6368 || CONVERT_EXPR_P (rtype)
6369 || TREE_CODE (rtype) == COMPONENT_REF)
6370 rtype = TREE_OPERAND (rtype, 0);
6371 self = (rtype == self_decl);
6372 super = (rtype == UOBJC_SUPER_decl);
6373 rtype = TREE_TYPE (receiver);
6374 have_cast = (TREE_CODE (receiver) == NOP_EXPR
6375 || (TREE_CODE (receiver) == COMPOUND_EXPR
6376 && !IS_SUPER (rtype)));
6378 /* If we are calling [super dealloc], reset our warning flag. */
6379 if (super && !strcmp ("dealloc", IDENTIFIER_POINTER (sel_name)))
6380 should_call_super_dealloc = 0;
6382 /* If the receiver is a class object, retrieve the corresponding
6383 @interface, if one exists. */
6384 class_tree = receiver_is_class_object (receiver, self, super);
6386 /* Now determine the receiver type (if an explicit cast has not been
6391 rtype = lookup_interface (class_tree);
6392 /* Handle `self' and `super'. */
6395 if (!CLASS_SUPER_NAME (implementation_template))
6397 error ("no super class declared in @interface for %qE",
6398 CLASS_NAME (implementation_template));
6399 return error_mark_node;
6401 rtype = lookup_interface (CLASS_SUPER_NAME (implementation_template));
6404 rtype = lookup_interface (CLASS_NAME (implementation_template));
6407 /* If receiver is of type `id' or `Class' (or if the @interface for a
6408 class is not visible), we shall be satisfied with the existence of
6409 any instance or class method. */
6410 if (objc_is_id (rtype))
6412 class_tree = (IS_CLASS (rtype) ? objc_class_name : NULL_TREE);
6413 rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))
6414 ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype))
6420 /* If messaging 'id <Protos>' or 'Class <Proto>', first search
6421 in protocols themselves for the method prototype. */
6423 = lookup_method_in_protocol_list (rprotos, sel_name,
6424 class_tree != NULL_TREE);
6426 /* If messaging 'Class <Proto>' but did not find a class method
6427 prototype, search for an instance method instead, and warn
6428 about having done so. */
6429 if (!method_prototype && !rtype && class_tree != NULL_TREE)
6432 = lookup_method_in_protocol_list (rprotos, sel_name, 0);
6434 if (method_prototype)
6435 warning (0, "found %<-%E%> instead of %<+%E%> in protocol(s)",
6436 sel_name, sel_name);
6442 tree orig_rtype = rtype;
6444 if (TREE_CODE (rtype) == POINTER_TYPE)
6445 rtype = TREE_TYPE (rtype);
6446 /* Traverse typedef aliases */
6447 while (TREE_CODE (rtype) == RECORD_TYPE && OBJC_TYPE_NAME (rtype)
6448 && TREE_CODE (OBJC_TYPE_NAME (rtype)) == TYPE_DECL
6449 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype)))
6450 rtype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype));
6451 if (TYPED_OBJECT (rtype))
6453 rprotos = TYPE_OBJC_PROTOCOL_LIST (rtype);
6454 rtype = TYPE_OBJC_INTERFACE (rtype);
6456 /* If we could not find an @interface declaration, we must have
6457 only seen a @class declaration; so, we cannot say anything
6458 more intelligent about which methods the receiver will
6460 if (!rtype || TREE_CODE (rtype) == IDENTIFIER_NODE)
6462 else if (TREE_CODE (rtype) == CLASS_INTERFACE_TYPE
6463 || TREE_CODE (rtype) == CLASS_IMPLEMENTATION_TYPE)
6465 /* We have a valid ObjC class name. Look up the method name
6466 in the published @interface for the class (and its
6469 = lookup_method_static (rtype, sel_name, class_tree != NULL_TREE);
6471 /* If the method was not found in the @interface, it may still
6472 exist locally as part of the @implementation. */
6473 if (!method_prototype && objc_implementation_context
6474 && CLASS_NAME (objc_implementation_context)
6475 == OBJC_TYPE_NAME (rtype))
6479 ? CLASS_CLS_METHODS (objc_implementation_context)
6480 : CLASS_NST_METHODS (objc_implementation_context)),
6483 /* If we haven't found a candidate method by now, try looking for
6484 it in the protocol list. */
6485 if (!method_prototype && rprotos)
6487 = lookup_method_in_protocol_list (rprotos, sel_name,
6488 class_tree != NULL_TREE);
6492 warning (0, "invalid receiver type %qs",
6493 identifier_to_locale (gen_type_name (orig_rtype)));
6494 /* After issuing the "invalid receiver" warning, perform method
6495 lookup as if we were messaging 'id'. */
6496 rtype = rprotos = NULL_TREE;
6501 /* For 'id' or 'Class' receivers, search in the global hash table
6502 as a last resort. For all receivers, warn if protocol searches
6504 if (!method_prototype)
6507 warning (0, "%<%c%E%> not found in protocol(s)",
6508 (class_tree ? '+' : '-'),
6513 = lookup_method_in_hash_lists (sel_name, class_tree != NULL_TREE);
6516 if (!method_prototype)
6518 static bool warn_missing_methods = false;
6521 warning (0, "%qE may not respond to %<%c%E%>",
6522 OBJC_TYPE_NAME (rtype),
6523 (class_tree ? '+' : '-'),
6525 /* If we are messaging an 'id' or 'Class' object and made it here,
6526 then we have failed to find _any_ instance or class method,
6529 warning (0, "no %<%c%E%> method found",
6530 (class_tree ? '+' : '-'),
6533 if (!warn_missing_methods)
6535 warning_at (input_location,
6536 0, "(Messages without a matching method signature");
6537 warning_at (input_location,
6538 0, "will be assumed to return %<id%> and accept");
6539 warning_at (input_location,
6540 0, "%<...%> as arguments.)");
6541 warn_missing_methods = true;
6545 /* Save the selector name for printing error messages. */
6546 current_objc_message_selector = sel_name;
6548 /* Build the parameters list for looking up the method.
6549 These are the object itself and the selector. */
6551 if (flag_typed_selectors)
6552 selector = build_typed_selector_reference (input_location,
6553 sel_name, method_prototype);
6555 selector = build_selector_reference (input_location, sel_name);
6557 retval = build_objc_method_call (input_location, super, method_prototype,
6559 selector, method_params);
6561 current_objc_message_selector = 0;
6566 /* Build a tree expression to send OBJECT the operation SELECTOR,
6567 looking up the method on object LOOKUP_OBJECT (often same as OBJECT),
6568 assuming the method has prototype METHOD_PROTOTYPE.
6569 (That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.)
6570 LOC is the location of the expression to build.
6571 Use METHOD_PARAMS as list of args to pass to the method.
6572 If SUPER_FLAG is nonzero, we look up the superclass's method. */
6575 build_objc_method_call (location_t loc, int super_flag, tree method_prototype,
6576 tree lookup_object, tree selector,
6579 tree sender = (super_flag ? umsg_super_decl :
6580 (!flag_next_runtime || flag_nil_receivers
6581 ? (flag_objc_direct_dispatch
6584 : umsg_nonnil_decl));
6585 tree rcv_p = (super_flag ? objc_super_type : objc_object_type);
6587 /* If a prototype for the method to be called exists, then cast
6588 the sender's return type and arguments to match that of the method.
6589 Otherwise, leave sender as is. */
6592 ? TREE_VALUE (TREE_TYPE (method_prototype))
6593 : objc_object_type);
6595 = build_pointer_type
6596 (build_function_type
6599 (method_prototype, METHOD_REF, super_flag)));
6602 lookup_object = build_c_cast (loc, rcv_p, lookup_object);
6604 /* Use SAVE_EXPR to avoid evaluating the receiver twice. */
6605 lookup_object = save_expr (lookup_object);
6607 if (flag_next_runtime)
6609 /* If we are returning a struct in memory, and the address
6610 of that memory location is passed as a hidden first
6611 argument, then change which messenger entry point this
6612 expr will call. NB: Note that sender_cast remains
6613 unchanged (it already has a struct return type). */
6614 if (!targetm.calls.struct_value_rtx (0, 0)
6615 && (TREE_CODE (ret_type) == RECORD_TYPE
6616 || TREE_CODE (ret_type) == UNION_TYPE)
6617 && targetm.calls.return_in_memory (ret_type, 0))
6618 sender = (super_flag ? umsg_super_stret_decl :
6619 flag_nil_receivers ? umsg_stret_decl : umsg_nonnil_stret_decl);
6621 method_params = tree_cons (NULL_TREE, lookup_object,
6622 tree_cons (NULL_TREE, selector,
6624 method = build_fold_addr_expr_loc (input_location, sender);
6628 /* This is the portable (GNU) way. */
6631 /* First, call the lookup function to get a pointer to the method,
6632 then cast the pointer, then call it with the method arguments. */
6634 object = (super_flag ? self_decl : lookup_object);
6636 t = tree_cons (NULL_TREE, selector, NULL_TREE);
6637 t = tree_cons (NULL_TREE, lookup_object, t);
6638 method = build_function_call (loc, sender, t);
6640 /* Pass the object to the method. */
6641 method_params = tree_cons (NULL_TREE, object,
6642 tree_cons (NULL_TREE, selector,
6646 /* ??? Selector is not at this point something we can use inside
6647 the compiler itself. Set it to garbage for the nonce. */
6648 t = build3 (OBJ_TYPE_REF, sender_cast, method, lookup_object, size_zero_node);
6649 return build_function_call (loc,
6654 build_protocol_reference (tree p)
6657 const char *proto_name;
6659 /* static struct _objc_protocol _OBJC_PROTOCOL_<mumble>; */
6661 proto_name = synth_id_with_class_suffix ("_OBJC_PROTOCOL", p);
6662 decl = start_var_decl (objc_protocol_template, proto_name);
6664 PROTOCOL_FORWARD_DECL (p) = decl;
6667 /* This function is called by the parser when (and only when) a
6668 @protocol() expression is found, in order to compile it. */
6670 objc_build_protocol_expr (tree protoname)
6673 tree p = lookup_protocol (protoname);
6677 error ("cannot find protocol declaration for %qE",
6679 return error_mark_node;
6682 if (!PROTOCOL_FORWARD_DECL (p))
6683 build_protocol_reference (p);
6685 expr = build_unary_op (input_location,
6686 ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
6688 /* ??? Ideally we'd build the reference with objc_protocol_type directly,
6689 if we have it, rather than converting it here. */
6690 expr = convert (objc_protocol_type, expr);
6692 /* The @protocol() expression is being compiled into a pointer to a
6693 statically allocated instance of the Protocol class. To become
6694 usable at runtime, the 'isa' pointer of the instance need to be
6695 fixed up at runtime by the runtime library, to point to the
6696 actual 'Protocol' class. */
6698 /* For the GNU runtime, put the static Protocol instance in the list
6699 of statically allocated instances, so that we make sure that its
6700 'isa' pointer is fixed up at runtime by the GNU runtime library
6701 to point to the Protocol class (at runtime, when loading the
6702 module, the GNU runtime library loops on the statically allocated
6703 instances (as found in the defs field in objc_symtab) and fixups
6704 all the 'isa' pointers of those objects). */
6705 if (! flag_next_runtime)
6707 /* This type is a struct containing the fields of a Protocol
6708 object. (Cfr. objc_protocol_type instead is the type of a pointer
6709 to such a struct). */
6710 tree protocol_struct_type = xref_tag
6711 (RECORD_TYPE, get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
6714 /* Look for the list of Protocol statically allocated instances
6715 to fixup at runtime. Create a new list to hold Protocol
6716 statically allocated instances, if the list is not found. At
6717 present there is only another list, holding NSConstantString
6718 static instances to be fixed up at runtime. */
6719 for (chain = &objc_static_instances;
6720 *chain && TREE_VALUE (*chain) != protocol_struct_type;
6721 chain = &TREE_CHAIN (*chain));
6724 *chain = tree_cons (NULL_TREE, protocol_struct_type, NULL_TREE);
6725 add_objc_string (OBJC_TYPE_NAME (protocol_struct_type),
6729 /* Add this statically allocated instance to the Protocol list. */
6730 TREE_PURPOSE (*chain) = tree_cons (NULL_TREE,
6731 PROTOCOL_FORWARD_DECL (p),
6732 TREE_PURPOSE (*chain));
6739 /* This function is called by the parser when a @selector() expression
6740 is found, in order to compile it. It is only called by the parser
6741 and only to compile a @selector(). LOC is the location of the
6744 objc_build_selector_expr (location_t loc, tree selnamelist)
6748 /* Obtain the full selector name. */
6749 if (TREE_CODE (selnamelist) == IDENTIFIER_NODE)
6750 /* A unary selector. */
6751 selname = selnamelist;
6752 else if (TREE_CODE (selnamelist) == TREE_LIST)
6753 selname = build_keyword_selector (selnamelist);
6757 /* If we are required to check @selector() expressions as they
6758 are found, check that the selector has been declared. */
6759 if (warn_undeclared_selector)
6761 /* Look the selector up in the list of all known class and
6762 instance methods (up to this line) to check that the selector
6766 /* First try with instance methods. */
6767 hsh = hash_lookup (nst_method_hash_list, selname);
6769 /* If not found, try with class methods. */
6772 hsh = hash_lookup (cls_method_hash_list, selname);
6775 /* If still not found, print out a warning. */
6778 warning (0, "undeclared selector %qE", selname);
6783 if (flag_typed_selectors)
6784 return build_typed_selector_reference (loc, selname, 0);
6786 return build_selector_reference (loc, selname);
6790 objc_build_encode_expr (tree type)
6795 encode_type (type, obstack_object_size (&util_obstack),
6796 OBJC_ENCODE_INLINE_DEFS);
6797 obstack_1grow (&util_obstack, 0); /* null terminate string */
6798 string = XOBFINISH (&util_obstack, const char *);
6800 /* Synthesize a string that represents the encoded struct/union. */
6801 result = my_build_string (strlen (string) + 1, string);
6802 obstack_free (&util_obstack, util_firstobj);
6807 build_ivar_reference (tree id)
6809 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
6811 /* Historically, a class method that produced objects (factory
6812 method) would assign `self' to the instance that it
6813 allocated. This would effectively turn the class method into
6814 an instance method. Following this assignment, the instance
6815 variables could be accessed. That practice, while safe,
6816 violates the simple rule that a class method should not refer
6817 to an instance variable. It's better to catch the cases
6818 where this is done unknowingly than to support the above
6820 warning (0, "instance variable %qE accessed in class method",
6822 self_decl = convert (objc_instance_type, self_decl); /* cast */
6825 return objc_build_component_ref (build_indirect_ref (input_location,
6826 self_decl, "->"), id);
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. */
8113 if (name && TREE_CODE (name) == IDENTIFIER_NODE
8115 /* Did this struct have a tag? */
8116 && !TYPE_WAS_ANONYMOUS (type)
8119 obstack_grow (&util_obstack,
8120 IDENTIFIER_POINTER (name),
8121 strlen (IDENTIFIER_POINTER (name)));
8123 obstack_1grow (&util_obstack, '?');
8125 /* Encode the types (and possibly names) of the inner fields,
8127 if (inline_contents)
8129 obstack_1grow (&util_obstack, '=');
8130 encode_aggregate_fields (type, pointed_to, curtype, format);
8132 /* Close parenth/bracket. */
8133 obstack_1grow (&util_obstack, right);
8137 encode_aggregate (tree type, int curtype, int format)
8139 enum tree_code code = TREE_CODE (type);
8145 encode_aggregate_within (type, curtype, format, '{', '}');
8150 encode_aggregate_within (type, curtype, format, '(', ')');
8155 obstack_1grow (&util_obstack, 'i');
8163 /* Encode a bitfield NeXT-style (i.e., without a bit offset or the underlying
8167 encode_next_bitfield (int width)
8170 sprintf (buffer, "b%d", width);
8171 obstack_grow (&util_obstack, buffer, strlen (buffer));
8174 /* FORMAT will be OBJC_ENCODE_INLINE_DEFS or OBJC_ENCODE_DONT_INLINE_DEFS. */
8176 encode_type (tree type, int curtype, int format)
8178 enum tree_code code = TREE_CODE (type);
8181 if (type == error_mark_node)
8184 if (TYPE_READONLY (type))
8185 obstack_1grow (&util_obstack, 'r');
8187 if (code == INTEGER_TYPE)
8189 switch (GET_MODE_BITSIZE (TYPE_MODE (type)))
8191 case 8: c = TYPE_UNSIGNED (type) ? 'C' : 'c'; break;
8192 case 16: c = TYPE_UNSIGNED (type) ? 'S' : 's'; break;
8194 if (type == long_unsigned_type_node
8195 || type == long_integer_type_node)
8196 c = TYPE_UNSIGNED (type) ? 'L' : 'l';
8198 c = TYPE_UNSIGNED (type) ? 'I' : 'i';
8200 case 64: c = TYPE_UNSIGNED (type) ? 'Q' : 'q'; break;
8203 obstack_1grow (&util_obstack, c);
8206 else if (code == REAL_TYPE)
8208 /* Floating point types. */
8209 switch (GET_MODE_BITSIZE (TYPE_MODE (type)))
8211 case 32: c = 'f'; break;
8214 case 128: c = 'd'; break;
8217 obstack_1grow (&util_obstack, c);
8220 else if (code == VOID_TYPE)
8221 obstack_1grow (&util_obstack, 'v');
8223 else if (code == BOOLEAN_TYPE)
8224 obstack_1grow (&util_obstack, 'B');
8226 else if (code == ARRAY_TYPE)
8227 encode_array (type, curtype, format);
8229 else if (code == POINTER_TYPE)
8230 encode_pointer (type, curtype, format);
8232 else if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
8233 encode_aggregate (type, curtype, format);
8235 else if (code == FUNCTION_TYPE) /* '?' */
8236 obstack_1grow (&util_obstack, '?');
8238 else if (code == COMPLEX_TYPE)
8240 obstack_1grow (&util_obstack, 'j');
8241 encode_type (TREE_TYPE (type), curtype, format);
8246 encode_gnu_bitfield (int position, tree type, int size)
8248 enum tree_code code = TREE_CODE (type);
8250 char charType = '?';
8252 if (code == INTEGER_TYPE)
8254 if (integer_zerop (TYPE_MIN_VALUE (type)))
8256 /* Unsigned integer types. */
8258 if (TYPE_MODE (type) == QImode)
8260 else if (TYPE_MODE (type) == HImode)
8262 else if (TYPE_MODE (type) == SImode)
8264 if (type == long_unsigned_type_node)
8269 else if (TYPE_MODE (type) == DImode)
8274 /* Signed integer types. */
8276 if (TYPE_MODE (type) == QImode)
8278 else if (TYPE_MODE (type) == HImode)
8280 else if (TYPE_MODE (type) == SImode)
8282 if (type == long_integer_type_node)
8288 else if (TYPE_MODE (type) == DImode)
8292 else if (code == ENUMERAL_TYPE)
8297 sprintf (buffer, "b%d%c%d", position, charType, size);
8298 obstack_grow (&util_obstack, buffer, strlen (buffer));
8302 encode_field_decl (tree field_decl, int curtype, int format)
8305 /* C++ static members, and things that are not fields at all,
8306 should not appear in the encoding. */
8307 if (TREE_CODE (field_decl) != FIELD_DECL || TREE_STATIC (field_decl))
8311 /* Generate the bitfield typing information, if needed. Note the difference
8312 between GNU and NeXT runtimes. */
8313 if (DECL_BIT_FIELD_TYPE (field_decl))
8315 int size = tree_low_cst (DECL_SIZE (field_decl), 1);
8317 if (flag_next_runtime)
8318 encode_next_bitfield (size);
8320 encode_gnu_bitfield (int_bit_position (field_decl),
8321 DECL_BIT_FIELD_TYPE (field_decl), size);
8324 encode_type (TREE_TYPE (field_decl), curtype, format);
8327 static GTY(()) tree objc_parmlist = NULL_TREE;
8329 /* Append PARM to a list of formal parameters of a method, making a necessary
8330 array-to-pointer adjustment along the way. */
8333 objc_push_parm (tree parm)
8335 bool relayout_needed = false;
8337 if (TREE_TYPE (parm) == error_mark_node)
8339 objc_parmlist = chainon (objc_parmlist, parm);
8343 /* Decay arrays and functions into pointers. */
8344 if (TREE_CODE (TREE_TYPE (parm)) == ARRAY_TYPE)
8346 TREE_TYPE (parm) = build_pointer_type (TREE_TYPE (TREE_TYPE (parm)));
8347 relayout_needed = true;
8349 else if (TREE_CODE (TREE_TYPE (parm)) == FUNCTION_TYPE)
8351 TREE_TYPE (parm) = build_pointer_type (TREE_TYPE (parm));
8352 relayout_needed = true;
8355 if (relayout_needed)
8356 relayout_decl (parm);
8359 DECL_ARG_TYPE (parm)
8360 = lang_hooks.types.type_promotes_to (TREE_TYPE (parm));
8362 /* Record constancy and volatility. */
8363 c_apply_type_quals_to_decl
8364 ((TYPE_READONLY (TREE_TYPE (parm)) ? TYPE_QUAL_CONST : 0)
8365 | (TYPE_RESTRICT (TREE_TYPE (parm)) ? TYPE_QUAL_RESTRICT : 0)
8366 | (TYPE_VOLATILE (TREE_TYPE (parm)) ? TYPE_QUAL_VOLATILE : 0), parm);
8368 objc_parmlist = chainon (objc_parmlist, parm);
8371 /* Retrieve the formal parameter list constructed via preceding calls to
8372 objc_push_parm(). */
8376 objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED)
8378 static struct c_arg_info *
8379 objc_get_parm_info (int have_ellipsis)
8383 tree parm_info = objc_parmlist;
8384 objc_parmlist = NULL_TREE;
8388 tree parm_info = objc_parmlist;
8389 struct c_arg_info *arg_info;
8390 /* The C front-end requires an elaborate song and dance at
8393 declare_parm_level ();
8396 tree next = TREE_CHAIN (parm_info);
8398 TREE_CHAIN (parm_info) = NULL_TREE;
8399 parm_info = pushdecl (parm_info);
8400 finish_decl (parm_info, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
8403 arg_info = get_parm_info (have_ellipsis);
8405 objc_parmlist = NULL_TREE;
8410 /* Synthesize the formal parameters 'id self' and 'SEL _cmd' needed for ObjC
8411 method definitions. In the case of instance methods, we can be more
8412 specific as to the type of 'self'. */
8415 synth_self_and_ucmd_args (void)
8419 if (objc_method_context
8420 && TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL)
8421 self_type = objc_instance_type;
8423 /* Really a `struct objc_class *'. However, we allow people to
8424 assign to self, which changes its type midstream. */
8425 self_type = objc_object_type;
8428 objc_push_parm (build_decl (input_location,
8429 PARM_DECL, self_id, self_type));
8432 objc_push_parm (build_decl (input_location,
8433 PARM_DECL, ucmd_id, objc_selector_type));
8436 /* Transform an Objective-C method definition into a static C function
8437 definition, synthesizing the first two arguments, "self" and "_cmd",
8441 start_method_def (tree method)
8447 struct c_arg_info *parm_info;
8449 int have_ellipsis = 0;
8451 /* If we are defining a "dealloc" method in a non-root class, we
8452 will need to check if a [super dealloc] is missing, and warn if
8454 if(CLASS_SUPER_NAME (objc_implementation_context)
8455 && !strcmp ("dealloc", IDENTIFIER_POINTER (METHOD_SEL_NAME (method))))
8456 should_call_super_dealloc = 1;
8458 should_call_super_dealloc = 0;
8460 /* Required to implement _msgSuper. */
8461 objc_method_context = method;
8462 UOBJC_SUPER_decl = NULL_TREE;
8464 /* Generate prototype declarations for arguments..."new-style". */
8465 synth_self_and_ucmd_args ();
8467 /* Generate argument declarations if a keyword_decl. */
8468 parmlist = METHOD_SEL_ARGS (method);
8471 tree type = TREE_VALUE (TREE_TYPE (parmlist)), parm;
8473 parm = build_decl (input_location,
8474 PARM_DECL, KEYWORD_ARG_NAME (parmlist), type);
8475 objc_push_parm (parm);
8476 parmlist = TREE_CHAIN (parmlist);
8479 if (METHOD_ADD_ARGS (method))
8483 for (akey = TREE_CHAIN (METHOD_ADD_ARGS (method));
8484 akey; akey = TREE_CHAIN (akey))
8486 objc_push_parm (TREE_VALUE (akey));
8489 if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
8493 parm_info = objc_get_parm_info (have_ellipsis);
8495 really_start_method (objc_method_context, parm_info);
8498 /* Return 1 if TYPE1 is equivalent to TYPE2
8499 for purposes of method overloading. */
8502 objc_types_are_equivalent (tree type1, tree type2)
8507 /* Strip away indirections. */
8508 while ((TREE_CODE (type1) == ARRAY_TYPE || TREE_CODE (type1) == POINTER_TYPE)
8509 && (TREE_CODE (type1) == TREE_CODE (type2)))
8510 type1 = TREE_TYPE (type1), type2 = TREE_TYPE (type2);
8511 if (TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
8514 type1 = (TYPE_HAS_OBJC_INFO (type1)
8515 ? TYPE_OBJC_PROTOCOL_LIST (type1)
8517 type2 = (TYPE_HAS_OBJC_INFO (type2)
8518 ? TYPE_OBJC_PROTOCOL_LIST (type2)
8521 if (list_length (type1) == list_length (type2))
8523 for (; type2; type2 = TREE_CHAIN (type2))
8524 if (!lookup_protocol_in_reflist (type1, TREE_VALUE (type2)))
8531 /* Return 1 if TYPE1 has the same size and alignment as TYPE2. */
8534 objc_types_share_size_and_alignment (tree type1, tree type2)
8536 return (simple_cst_equal (TYPE_SIZE (type1), TYPE_SIZE (type2))
8537 && TYPE_ALIGN (type1) == TYPE_ALIGN (type2));
8540 /* Return 1 if PROTO1 is equivalent to PROTO2
8541 for purposes of method overloading. Ordinarily, the type signatures
8542 should match up exactly, unless STRICT is zero, in which case we
8543 shall allow differences in which the size and alignment of a type
8547 comp_proto_with_proto (tree proto1, tree proto2, int strict)
8551 /* The following test is needed in case there are hashing
8553 if (METHOD_SEL_NAME (proto1) != METHOD_SEL_NAME (proto2))
8556 /* Compare return types. */
8557 type1 = TREE_VALUE (TREE_TYPE (proto1));
8558 type2 = TREE_VALUE (TREE_TYPE (proto2));
8560 if (!objc_types_are_equivalent (type1, type2)
8561 && (strict || !objc_types_share_size_and_alignment (type1, type2)))
8564 /* Compare argument types. */
8565 for (type1 = get_arg_type_list (proto1, METHOD_REF, 0),
8566 type2 = get_arg_type_list (proto2, METHOD_REF, 0);
8568 type1 = TREE_CHAIN (type1), type2 = TREE_CHAIN (type2))
8570 if (!objc_types_are_equivalent (TREE_VALUE (type1), TREE_VALUE (type2))
8572 || !objc_types_share_size_and_alignment (TREE_VALUE (type1),
8573 TREE_VALUE (type2))))
8577 return (!type1 && !type2);
8580 /* Fold an OBJ_TYPE_REF expression for ObjC method dispatches, where
8581 this occurs. ObjC method dispatches are _not_ like C++ virtual
8582 member function dispatches, and we account for the difference here. */
8585 objc_fold_obj_type_ref (tree ref, tree known_type)
8587 objc_fold_obj_type_ref (tree ref ATTRIBUTE_UNUSED,
8588 tree known_type ATTRIBUTE_UNUSED)
8592 tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
8594 /* If the receiver does not have virtual member functions, there
8595 is nothing we can (or need to) do here. */
8599 /* Let C++ handle C++ virtual functions. */
8600 return cp_fold_obj_type_ref (ref, known_type);
8602 /* For plain ObjC, we currently do not need to do anything. */
8608 objc_start_function (tree name, tree type, tree attrs,
8612 struct c_arg_info *params
8616 tree fndecl = build_decl (input_location,
8617 FUNCTION_DECL, name, type);
8620 DECL_ARGUMENTS (fndecl) = params;
8621 DECL_INITIAL (fndecl) = error_mark_node;
8622 DECL_EXTERNAL (fndecl) = 0;
8623 TREE_STATIC (fndecl) = 1;
8624 retrofit_lang_decl (fndecl);
8625 cplus_decl_attributes (&fndecl, attrs, 0);
8626 start_preparsed_function (fndecl, attrs, /*flags=*/SF_DEFAULT);
8628 current_function_returns_value = 0; /* Assume, until we see it does. */
8629 current_function_returns_null = 0;
8631 decl_attributes (&fndecl, attrs, 0);
8632 announce_function (fndecl);
8633 DECL_INITIAL (fndecl) = error_mark_node;
8634 DECL_EXTERNAL (fndecl) = 0;
8635 TREE_STATIC (fndecl) = 1;
8636 current_function_decl = pushdecl (fndecl);
8638 declare_parm_level ();
8639 DECL_RESULT (current_function_decl)
8640 = build_decl (input_location,
8641 RESULT_DECL, NULL_TREE,
8642 TREE_TYPE (TREE_TYPE (current_function_decl)));
8643 DECL_ARTIFICIAL (DECL_RESULT (current_function_decl)) = 1;
8644 DECL_IGNORED_P (DECL_RESULT (current_function_decl)) = 1;
8645 start_fname_decls ();
8646 store_parm_decls_from (params);
8649 TREE_USED (current_function_decl) = 1;
8652 /* - Generate an identifier for the function. the format is "_n_cls",
8653 where 1 <= n <= nMethods, and cls is the name the implementation we
8655 - Install the return type from the method declaration.
8656 - If we have a prototype, check for type consistency. */
8659 really_start_method (tree method,
8663 struct c_arg_info *parmlist
8667 tree ret_type, meth_type;
8669 const char *sel_name, *class_name, *cat_name;
8672 /* Synth the storage class & assemble the return type. */
8673 ret_type = TREE_VALUE (TREE_TYPE (method));
8675 sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method));
8676 class_name = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
8677 cat_name = ((TREE_CODE (objc_implementation_context)
8678 == CLASS_IMPLEMENTATION_TYPE)
8680 : IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
8683 /* Make sure this is big enough for any plausible method label. */
8684 buf = (char *) alloca (50 + strlen (sel_name) + strlen (class_name)
8685 + (cat_name ? strlen (cat_name) : 0));
8687 OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL,
8688 class_name, cat_name, sel_name, method_slot);
8690 method_id = get_identifier (buf);
8693 /* Objective-C methods cannot be overloaded, so we don't need
8694 the type encoding appended. It looks bad anyway... */
8695 push_lang_context (lang_name_c);
8699 = build_function_type (ret_type,
8700 get_arg_type_list (method, METHOD_DEF, 0));
8701 objc_start_function (method_id, meth_type, NULL_TREE, parmlist);
8703 /* Set self_decl from the first argument. */
8704 self_decl = DECL_ARGUMENTS (current_function_decl);
8706 /* Suppress unused warnings. */
8707 TREE_USED (self_decl) = 1;
8708 TREE_USED (TREE_CHAIN (self_decl)) = 1;
8710 pop_lang_context ();
8713 METHOD_DEFINITION (method) = current_function_decl;
8715 /* Check consistency...start_function, pushdecl, duplicate_decls. */
8717 if (implementation_template != objc_implementation_context)
8720 = lookup_method_static (implementation_template,
8721 METHOD_SEL_NAME (method),
8722 ((TREE_CODE (method) == CLASS_METHOD_DECL)
8723 | OBJC_LOOKUP_NO_SUPER));
8727 if (!comp_proto_with_proto (method, proto, 1))
8729 bool type = TREE_CODE (method) == INSTANCE_METHOD_DECL;
8731 warning_at (DECL_SOURCE_LOCATION (method), 0,
8732 "conflicting types for %<%c%s%>",
8734 identifier_to_locale (gen_method_decl (method)));
8735 inform (DECL_SOURCE_LOCATION (proto),
8736 "previous declaration of %<%c%s%>",
8738 identifier_to_locale (gen_method_decl (proto)));
8743 /* We have a method @implementation even though we did not
8744 see a corresponding @interface declaration (which is allowed
8745 by Objective-C rules). Go ahead and place the method in
8746 the @interface anyway, so that message dispatch lookups
8748 tree interface = implementation_template;
8750 if (TREE_CODE (objc_implementation_context)
8751 == CATEGORY_IMPLEMENTATION_TYPE)
8752 interface = lookup_category
8754 CLASS_SUPER_NAME (objc_implementation_context));
8757 objc_add_method (interface, copy_node (method),
8758 TREE_CODE (method) == CLASS_METHOD_DECL);
8763 static void *UOBJC_SUPER_scope = 0;
8765 /* _n_Method (id self, SEL sel, ...)
8767 struct objc_super _S;
8768 _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
8772 get_super_receiver (void)
8774 if (objc_method_context)
8776 tree super_expr, super_expr_list;
8778 if (!UOBJC_SUPER_decl)
8780 UOBJC_SUPER_decl = build_decl (input_location,
8781 VAR_DECL, get_identifier (TAG_SUPER),
8782 objc_super_template);
8783 /* This prevents `unused variable' warnings when compiling with -Wall. */
8784 TREE_USED (UOBJC_SUPER_decl) = 1;
8785 lang_hooks.decls.pushdecl (UOBJC_SUPER_decl);
8786 finish_decl (UOBJC_SUPER_decl, input_location, NULL_TREE, NULL_TREE,
8788 UOBJC_SUPER_scope = objc_get_current_scope ();
8791 /* Set receiver to self. */
8792 super_expr = objc_build_component_ref (UOBJC_SUPER_decl, self_id);
8793 super_expr = build_modify_expr (input_location, super_expr, NULL_TREE,
8794 NOP_EXPR, input_location, self_decl,
8796 super_expr_list = super_expr;
8798 /* Set class to begin searching. */
8799 super_expr = objc_build_component_ref (UOBJC_SUPER_decl,
8800 get_identifier ("super_class"));
8802 if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
8804 /* [_cls, __cls]Super are "pre-built" in
8805 synth_forward_declarations. */
8807 super_expr = build_modify_expr (input_location, super_expr,
8808 NULL_TREE, NOP_EXPR,
8810 ((TREE_CODE (objc_method_context)
8811 == INSTANCE_METHOD_DECL)
8818 /* We have a category. */
8820 tree super_name = CLASS_SUPER_NAME (implementation_template);
8823 /* Barf if super used in a category of Object. */
8826 error ("no super class declared in interface for %qE",
8827 CLASS_NAME (implementation_template));
8828 return error_mark_node;
8831 if (flag_next_runtime && !flag_zero_link)
8833 super_class = objc_get_class_reference (super_name);
8834 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
8835 /* If we are in a class method, we must retrieve the
8836 _metaclass_ for the current class, pointed at by
8837 the class's "isa" pointer. The following assumes that
8838 "isa" is the first ivar in a class (which it must be). */
8840 = build_indirect_ref
8842 build_c_cast (input_location,
8843 build_pointer_type (objc_class_type),
8844 super_class), "unary *");
8848 add_class_reference (super_name);
8849 super_class = (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
8850 ? objc_get_class_decl : objc_get_meta_class_decl);
8851 assemble_external (super_class);
8853 = build_function_call
8858 my_build_string_pointer
8859 (IDENTIFIER_LENGTH (super_name) + 1,
8860 IDENTIFIER_POINTER (super_name))));
8864 = build_modify_expr (input_location, super_expr, NULL_TREE,
8867 build_c_cast (input_location,
8868 TREE_TYPE (super_expr),
8873 super_expr_list = build_compound_expr (input_location,
8874 super_expr_list, super_expr);
8876 super_expr = build_unary_op (input_location,
8877 ADDR_EXPR, UOBJC_SUPER_decl, 0);
8878 super_expr_list = build_compound_expr (input_location,
8879 super_expr_list, super_expr);
8881 return super_expr_list;
8885 error ("[super ...] must appear in a method context");
8886 return error_mark_node;
8890 /* When exiting a scope, sever links to a 'super' declaration (if any)
8891 therein contained. */
8894 objc_clear_super_receiver (void)
8896 if (objc_method_context
8897 && UOBJC_SUPER_scope == objc_get_current_scope ()) {
8898 UOBJC_SUPER_decl = 0;
8899 UOBJC_SUPER_scope = 0;
8904 objc_finish_method_definition (tree fndecl)
8906 /* We cannot validly inline ObjC methods, at least not without a language
8907 extension to declare that a method need not be dynamically
8908 dispatched, so suppress all thoughts of doing so. */
8909 DECL_UNINLINABLE (fndecl) = 1;
8912 /* The C++ front-end will have called finish_function() for us. */
8916 METHOD_ENCODING (objc_method_context)
8917 = encode_method_prototype (objc_method_context);
8919 /* Required to implement _msgSuper. This must be done AFTER finish_function,
8920 since the optimizer may find "may be used before set" errors. */
8921 objc_method_context = NULL_TREE;
8923 if (should_call_super_dealloc)
8924 warning (0, "method possibly missing a [super dealloc] call");
8927 /* Given a tree DECL node, produce a printable description of it in the given
8928 buffer, overwriting the buffer. */
8931 gen_declaration (tree decl)
8937 gen_type_name_0 (TREE_TYPE (decl));
8939 if (DECL_NAME (decl))
8941 if (!POINTER_TYPE_P (TREE_TYPE (decl)))
8942 strcat (errbuf, " ");
8944 strcat (errbuf, IDENTIFIER_POINTER (DECL_NAME (decl)));
8947 if (DECL_INITIAL (decl)
8948 && TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST)
8949 sprintf (errbuf + strlen (errbuf), ": " HOST_WIDE_INT_PRINT_DEC,
8950 TREE_INT_CST_LOW (DECL_INITIAL (decl)));
8956 /* Given a tree TYPE node, produce a printable description of it in the given
8957 buffer, overwriting the buffer. */
8960 gen_type_name_0 (tree type)
8962 tree orig = type, proto;
8964 if (TYPE_P (type) && TYPE_NAME (type))
8965 type = TYPE_NAME (type);
8966 else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
8968 tree inner = TREE_TYPE (type);
8970 while (TREE_CODE (inner) == ARRAY_TYPE)
8971 inner = TREE_TYPE (inner);
8973 gen_type_name_0 (inner);
8975 if (!POINTER_TYPE_P (inner))
8976 strcat (errbuf, " ");
8978 if (POINTER_TYPE_P (type))
8979 strcat (errbuf, "*");
8981 while (type != inner)
8983 strcat (errbuf, "[");
8985 if (TYPE_DOMAIN (type))
8989 sprintf (sz, HOST_WIDE_INT_PRINT_DEC,
8991 (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1));
8992 strcat (errbuf, sz);
8995 strcat (errbuf, "]");
8996 type = TREE_TYPE (type);
9002 if (TREE_CODE (type) == TYPE_DECL && DECL_NAME (type))
9003 type = DECL_NAME (type);
9005 strcat (errbuf, TREE_CODE (type) == IDENTIFIER_NODE
9006 ? IDENTIFIER_POINTER (type)
9009 /* For 'id' and 'Class', adopted protocols are stored in the pointee. */
9010 if (objc_is_id (orig))
9011 orig = TREE_TYPE (orig);
9013 proto = TYPE_HAS_OBJC_INFO (orig) ? TYPE_OBJC_PROTOCOL_LIST (orig) : NULL_TREE;
9017 strcat (errbuf, " <");
9021 IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto))));
9022 proto = TREE_CHAIN (proto);
9023 strcat (errbuf, proto ? ", " : ">");
9032 gen_type_name (tree type)
9036 return gen_type_name_0 (type);
9039 /* Given a method tree, put a printable description into the given
9040 buffer (overwriting) and return a pointer to the buffer. */
9043 gen_method_decl (tree method)
9047 strcpy (errbuf, "("); /* NB: Do _not_ call strcat() here. */
9048 gen_type_name_0 (TREE_VALUE (TREE_TYPE (method)));
9049 strcat (errbuf, ")");
9050 chain = METHOD_SEL_ARGS (method);
9054 /* We have a chain of keyword_decls. */
9057 if (KEYWORD_KEY_NAME (chain))
9058 strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain)));
9060 strcat (errbuf, ":(");
9061 gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain)));
9062 strcat (errbuf, ")");
9064 strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain)));
9065 if ((chain = TREE_CHAIN (chain)))
9066 strcat (errbuf, " ");
9070 if (METHOD_ADD_ARGS (method))
9072 chain = TREE_CHAIN (METHOD_ADD_ARGS (method));
9074 /* Know we have a chain of parm_decls. */
9077 strcat (errbuf, ", ");
9078 gen_type_name_0 (TREE_TYPE (TREE_VALUE (chain)));
9079 chain = TREE_CHAIN (chain);
9082 if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
9083 strcat (errbuf, ", ...");
9088 /* We have a unary selector. */
9089 strcat (errbuf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
9097 /* Dump an @interface declaration of the supplied class CHAIN to the
9098 supplied file FP. Used to implement the -gen-decls option (which
9099 prints out an @interface declaration of all classes compiled in
9100 this run); potentially useful for debugging the compiler too. */
9102 dump_interface (FILE *fp, tree chain)
9104 /* FIXME: A heap overflow here whenever a method (or ivar)
9105 declaration is so long that it doesn't fit in the buffer. The
9106 code and all the related functions should be rewritten to avoid
9107 using fixed size buffers. */
9108 const char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain));
9109 tree ivar_decls = CLASS_RAW_IVARS (chain);
9110 tree nst_methods = CLASS_NST_METHODS (chain);
9111 tree cls_methods = CLASS_CLS_METHODS (chain);
9113 fprintf (fp, "\n@interface %s", my_name);
9115 /* CLASS_SUPER_NAME is used to store the superclass name for
9116 classes, and the category name for categories. */
9117 if (CLASS_SUPER_NAME (chain))
9119 const char *name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain));
9121 if (TREE_CODE (chain) == CATEGORY_IMPLEMENTATION_TYPE
9122 || TREE_CODE (chain) == CATEGORY_INTERFACE_TYPE)
9124 fprintf (fp, " (%s)\n", name);
9128 fprintf (fp, " : %s\n", name);
9134 /* FIXME - the following doesn't seem to work at the moment. */
9137 fprintf (fp, "{\n");
9140 fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls));
9141 ivar_decls = TREE_CHAIN (ivar_decls);
9144 fprintf (fp, "}\n");
9149 fprintf (fp, "- %s;\n", gen_method_decl (nst_methods));
9150 nst_methods = TREE_CHAIN (nst_methods);
9155 fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods));
9156 cls_methods = TREE_CHAIN (cls_methods);
9159 fprintf (fp, "@end\n");
9162 /* Demangle function for Objective-C */
9164 objc_demangle (const char *mangled)
9166 char *demangled, *cp;
9168 if (mangled[0] == '_' &&
9169 (mangled[1] == 'i' || mangled[1] == 'c') &&
9172 cp = demangled = XNEWVEC (char, strlen(mangled) + 2);
9173 if (mangled[1] == 'i')
9174 *cp++ = '-'; /* for instance method */
9176 *cp++ = '+'; /* for class method */
9177 *cp++ = '['; /* opening left brace */
9178 strcpy(cp, mangled+3); /* tack on the rest of the mangled name */
9179 while (*cp && *cp == '_')
9180 cp++; /* skip any initial underbars in class name */
9181 cp = strchr(cp, '_'); /* find first non-initial underbar */
9184 free(demangled); /* not mangled name */
9187 if (cp[1] == '_') /* easy case: no category name */
9189 *cp++ = ' '; /* replace two '_' with one ' ' */
9190 strcpy(cp, mangled + (cp - demangled) + 2);
9194 *cp++ = '('; /* less easy case: category name */
9195 cp = strchr(cp, '_');
9198 free(demangled); /* not mangled name */
9202 *cp++ = ' '; /* overwriting 1st char of method name... */
9203 strcpy(cp, mangled + (cp - demangled)); /* get it back */
9205 while (*cp && *cp == '_')
9206 cp++; /* skip any initial underbars in method name */
9209 *cp = ':'; /* replace remaining '_' with ':' */
9210 *cp++ = ']'; /* closing right brace */
9211 *cp++ = 0; /* string terminator */
9215 return mangled; /* not an objc mangled name */
9219 objc_printable_name (tree decl, int kind ATTRIBUTE_UNUSED)
9221 return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl)));
9227 gcc_obstack_init (&util_obstack);
9228 util_firstobj = (char *) obstack_finish (&util_obstack);
9230 errbuf = XNEWVEC (char, 1024 * 10);
9232 synth_module_prologue ();
9238 struct imp_entry *impent;
9240 /* The internally generated initializers appear to have missing braces.
9241 Don't warn about this. */
9242 int save_warn_missing_braces = warn_missing_braces;
9243 warn_missing_braces = 0;
9245 /* A missing @end may not be detected by the parser. */
9246 if (objc_implementation_context)
9248 warning (0, "%<@end%> missing in implementation context");
9249 finish_class (objc_implementation_context);
9250 objc_ivar_chain = NULL_TREE;
9251 objc_implementation_context = NULL_TREE;
9254 /* Process the static instances here because initialization of objc_symtab
9256 if (objc_static_instances)
9257 generate_static_references ();
9259 if (imp_list || class_names_chain
9260 || meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
9261 generate_objc_symtab_decl ();
9263 for (impent = imp_list; impent; impent = impent->next)
9265 objc_implementation_context = impent->imp_context;
9266 implementation_template = impent->imp_template;
9268 UOBJC_CLASS_decl = impent->class_decl;
9269 UOBJC_METACLASS_decl = impent->meta_decl;
9271 /* Dump the @interface of each class as we compile it, if the
9272 -gen-decls option is in use. TODO: Dump the classes in the
9273 order they were found, rather than in reverse order as we
9275 if (flag_gen_declaration)
9277 dump_interface (gen_declaration_file, objc_implementation_context);
9280 if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
9282 /* all of the following reference the string pool... */
9283 generate_ivar_lists ();
9284 generate_dispatch_tables ();
9285 generate_shared_structures (impent->has_cxx_cdtors
9286 ? CLS_HAS_CXX_STRUCTORS
9291 generate_dispatch_tables ();
9292 generate_category (objc_implementation_context);
9296 /* If we are using an array of selectors, we must always
9297 finish up the array decl even if no selectors were used. */
9298 if (! flag_next_runtime || sel_ref_chain)
9299 build_selector_translation_table ();
9302 generate_protocols ();
9304 if ((flag_replace_objc_classes && imp_list) || flag_objc_gc)
9305 generate_objc_image_info ();
9307 /* Arrange for ObjC data structures to be initialized at run time. */
9308 if (objc_implementation_context || class_names_chain || objc_static_instances
9309 || meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
9311 build_module_descriptor ();
9313 if (!flag_next_runtime)
9314 build_module_initializer_routine ();
9317 /* Dump the class references. This forces the appropriate classes
9318 to be linked into the executable image, preserving unix archive
9319 semantics. This can be removed when we move to a more dynamically
9320 linked environment. */
9322 for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
9324 handle_class_ref (chain);
9325 if (TREE_PURPOSE (chain))
9326 generate_classref_translation_entry (chain);
9329 for (impent = imp_list; impent; impent = impent->next)
9330 handle_impent (impent);
9337 /* Run through the selector hash tables and print a warning for any
9338 selector which has multiple methods. */
9340 for (slot = 0; slot < SIZEHASHTABLE; slot++)
9342 for (hsh = cls_method_hash_list[slot]; hsh; hsh = hsh->next)
9343 check_duplicates (hsh, 0, 1);
9344 for (hsh = nst_method_hash_list[slot]; hsh; hsh = hsh->next)
9345 check_duplicates (hsh, 0, 1);
9349 warn_missing_braces = save_warn_missing_braces;
9352 /* Subroutines of finish_objc. */
9355 generate_classref_translation_entry (tree chain)
9357 tree expr, decl, type;
9359 decl = TREE_PURPOSE (chain);
9360 type = TREE_TYPE (decl);
9362 expr = add_objc_string (TREE_VALUE (chain), class_names);
9363 expr = convert (type, expr); /* cast! */
9365 /* The decl that is the one that we
9366 forward declared in build_class_reference. */
9367 finish_var_decl (decl, expr);
9372 handle_class_ref (tree chain)
9374 const char *name = IDENTIFIER_POINTER (TREE_VALUE (chain));
9375 char *string = (char *) alloca (strlen (name) + 30);
9379 sprintf (string, "%sobjc_class_name_%s",
9380 (flag_next_runtime ? "." : "__"), name);
9382 #ifdef ASM_DECLARE_UNRESOLVED_REFERENCE
9383 if (flag_next_runtime)
9385 ASM_DECLARE_UNRESOLVED_REFERENCE (asm_out_file, string);
9390 /* Make a decl for this name, so we can use its address in a tree. */
9391 decl = build_decl (input_location,
9392 VAR_DECL, get_identifier (string), char_type_node);
9393 DECL_EXTERNAL (decl) = 1;
9394 TREE_PUBLIC (decl) = 1;
9397 rest_of_decl_compilation (decl, 0, 0);
9399 /* Make a decl for the address. */
9400 sprintf (string, "%sobjc_class_ref_%s",
9401 (flag_next_runtime ? "." : "__"), name);
9402 exp = build1 (ADDR_EXPR, string_type_node, decl);
9403 decl = build_decl (input_location,
9404 VAR_DECL, get_identifier (string), string_type_node);
9405 DECL_INITIAL (decl) = exp;
9406 TREE_STATIC (decl) = 1;
9407 TREE_USED (decl) = 1;
9408 /* Force the output of the decl as this forces the reference of the class. */
9409 mark_decl_referenced (decl);
9412 rest_of_decl_compilation (decl, 0, 0);
9416 handle_impent (struct imp_entry *impent)
9420 objc_implementation_context = impent->imp_context;
9421 implementation_template = impent->imp_template;
9423 if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
9425 const char *const class_name =
9426 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
9428 string = (char *) alloca (strlen (class_name) + 30);
9430 sprintf (string, "%sobjc_class_name_%s",
9431 (flag_next_runtime ? "." : "__"), class_name);
9433 else if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
9435 const char *const class_name =
9436 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
9437 const char *const class_super_name =
9438 IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context));
9440 string = (char *) alloca (strlen (class_name)
9441 + strlen (class_super_name) + 30);
9443 /* Do the same for categories. Even though no references to
9444 these symbols are generated automatically by the compiler, it
9445 gives you a handle to pull them into an archive by hand. */
9446 sprintf (string, "*%sobjc_category_name_%s_%s",
9447 (flag_next_runtime ? "." : "__"), class_name, class_super_name);
9452 #ifdef ASM_DECLARE_CLASS_REFERENCE
9453 if (flag_next_runtime)
9455 ASM_DECLARE_CLASS_REFERENCE (asm_out_file, string);
9463 init = build_int_cst (c_common_type_for_size (BITS_PER_WORD, 1), 0);
9464 decl = build_decl (input_location,
9465 VAR_DECL, get_identifier (string), TREE_TYPE (init));
9466 TREE_PUBLIC (decl) = 1;
9467 TREE_READONLY (decl) = 1;
9468 TREE_USED (decl) = 1;
9469 TREE_CONSTANT (decl) = 1;
9470 DECL_CONTEXT (decl) = 0;
9471 DECL_ARTIFICIAL (decl) = 1;
9472 DECL_INITIAL (decl) = init;
9473 assemble_variable (decl, 1, 0, 0);
9477 /* The Fix-and-Continue functionality available in Mac OS X 10.3 and
9478 later requires that ObjC translation units participating in F&C be
9479 specially marked. The following routine accomplishes this. */
9481 /* static int _OBJC_IMAGE_INFO[2] = { 0, 1 }; */
9484 generate_objc_image_info (void)
9486 tree decl, initlist;
9488 = ((flag_replace_objc_classes && imp_list ? 1 : 0)
9489 | (flag_objc_gc ? 2 : 0));
9491 decl = start_var_decl (build_array_type
9493 build_index_type (build_int_cst (NULL_TREE, 2 - 1))),
9494 "_OBJC_IMAGE_INFO");
9496 initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 0));
9497 initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), initlist);
9498 initlist = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
9500 finish_var_decl (decl, initlist);
9503 /* Look up ID as an instance variable. OTHER contains the result of
9504 the C or C++ lookup, which we may want to use instead. */
9507 objc_lookup_ivar (tree other, tree id)
9511 /* If we are not inside of an ObjC method, ivar lookup makes no sense. */
9512 if (!objc_method_context)
9515 if (!strcmp (IDENTIFIER_POINTER (id), "super"))
9516 /* We have a message to super. */
9517 return get_super_receiver ();
9519 /* In a class method, look up an instance variable only as a last
9521 if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL
9522 && other && other != error_mark_node)
9525 /* Look up the ivar, but do not use it if it is not accessible. */
9526 ivar = is_ivar (objc_ivar_chain, id);
9528 if (!ivar || is_private (ivar))
9531 /* In an instance method, a local variable (or parameter) may hide the
9532 instance variable. */
9533 if (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
9534 && other && other != error_mark_node
9536 && CP_DECL_CONTEXT (other) != global_namespace)
9538 && !DECL_FILE_SCOPE_P (other))
9541 warning (0, "local declaration of %qE hides instance variable",
9547 /* At this point, we are either in an instance method with no obscuring
9548 local definitions, or in a class method with no alternate definitions
9550 return build_ivar_reference (id);
9553 /* Possibly rewrite a function CALL into an OBJ_TYPE_REF expression. This
9554 needs to be done if we are calling a function through a cast. */
9557 objc_rewrite_function_call (tree function, tree first_param)
9559 if (TREE_CODE (function) == NOP_EXPR
9560 && TREE_CODE (TREE_OPERAND (function, 0)) == ADDR_EXPR
9561 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (function, 0), 0))
9564 function = build3 (OBJ_TYPE_REF, TREE_TYPE (function),
9565 TREE_OPERAND (function, 0),
9566 first_param, size_zero_node);
9572 /* Look for the special case of OBJC_TYPE_REF with the address of
9573 a function in OBJ_TYPE_REF_EXPR (presumably objc_msgSend or one
9577 objc_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
9579 enum gimplify_status r0, r1;
9580 if (TREE_CODE (*expr_p) == OBJ_TYPE_REF
9581 && TREE_CODE (OBJ_TYPE_REF_EXPR (*expr_p)) == ADDR_EXPR
9582 && TREE_CODE (TREE_OPERAND (OBJ_TYPE_REF_EXPR (*expr_p), 0))
9585 /* Postincrements in OBJ_TYPE_REF_OBJECT don't affect the
9586 value of the OBJ_TYPE_REF, so force them to be emitted
9587 during subexpression evaluation rather than after the
9588 OBJ_TYPE_REF. This permits objc_msgSend calls in Objective
9589 C to use direct rather than indirect calls when the
9590 object expression has a postincrement. */
9591 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, NULL,
9592 is_gimple_val, fb_rvalue);
9593 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
9594 is_gimple_val, fb_rvalue);
9596 return MIN (r0, r1);
9600 return (enum gimplify_status) cp_gimplify_expr (expr_p, pre_p, post_p);
9602 return (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p);
9606 #include "gt-objc-objc-act.h"