1 /* Implement classes and message passing for Objective C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004 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 2, 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 COPYING. If not, write to
20 the Free Software Foundation, 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
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"
53 #include "langhooks.h"
64 #include "diagnostic.h"
66 #include "tree-iterator.h"
69 /* This is the default way of generating a method name. */
70 /* I am not sure it is really correct.
71 Perhaps there's a danger that it will make name conflicts
72 if method names contain underscores. -- rms. */
73 #ifndef OBJC_GEN_METHOD_LABEL
74 #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
77 sprintf ((BUF), "_%s_%s_%s_%s", \
78 ((IS_INST) ? "i" : "c"), \
80 ((CAT_NAME)? (CAT_NAME) : ""), \
82 for (temp = (BUF); *temp; temp++) \
83 if (*temp == ':') *temp = '_'; \
87 /* These need specifying. */
88 #ifndef OBJC_FORWARDING_STACK_OFFSET
89 #define OBJC_FORWARDING_STACK_OFFSET 0
92 #ifndef OBJC_FORWARDING_MIN_OFFSET
93 #define OBJC_FORWARDING_MIN_OFFSET 0
96 /* Set up for use of obstacks. */
100 /* This obstack is used to accumulate the encoding of a data type. */
101 static struct obstack util_obstack
;
103 /* This points to the beginning of obstack contents, so we can free
104 the whole contents. */
107 /* The version identifies which language generation and runtime
108 the module (file) was compiled for, and is recorded in the
109 module descriptor. */
111 #define OBJC_VERSION (flag_next_runtime ? 5 : 8)
112 #define PROTOCOL_VERSION 2
114 /* (Decide if these can ever be validly changed.) */
115 #define OBJC_ENCODE_INLINE_DEFS 0
116 #define OBJC_ENCODE_DONT_INLINE_DEFS 1
118 /*** Private Interface (procedures) ***/
120 /* Used by compile_file. */
122 static void init_objc (void);
123 static void finish_objc (void);
125 /* Code generation. */
127 static void synth_module_prologue (void);
128 static tree
objc_build_constructor (tree
, tree
);
129 static rtx
build_module_descriptor (void);
130 static tree
init_module_descriptor (tree
);
131 static tree
build_objc_method_call (int, tree
, tree
, tree
, tree
);
132 static void generate_strings (void);
133 static tree
get_proto_encoding (tree
);
134 static void build_selector_translation_table (void);
136 static tree
objc_add_static_instance (tree
, tree
);
138 static void build_objc_exception_stuff (void);
139 static void build_next_objc_exception_stuff (void);
141 static tree
build_ivar_template (void);
142 static tree
build_method_template (void);
143 static tree
build_private_template (tree
);
144 static void build_class_template (void);
145 static void build_selector_template (void);
146 static void build_category_template (void);
147 static tree
lookup_method_in_hash_lists (tree
, int);
148 static void build_super_template (void);
149 static tree
build_category_initializer (tree
, tree
, tree
, tree
, tree
, tree
);
150 static tree
build_protocol_initializer (tree
, tree
, tree
, tree
, tree
);
151 static void synth_forward_declarations (void);
152 static int ivar_list_length (tree
);
153 static tree
get_class_ivars (tree
, int);
154 static void generate_ivar_lists (void);
155 static void generate_dispatch_tables (void);
156 static void generate_shared_structures (void);
157 static tree
generate_protocol_list (tree
);
158 static void build_protocol_reference (tree
);
160 static tree
build_keyword_selector (tree
);
161 static tree
synth_id_with_class_suffix (const char *, tree
);
163 static void generate_static_references (void);
164 static int check_methods_accessible (tree
, tree
, int);
165 static void encode_aggregate_within (tree
, int, int, int, int);
166 static const char *objc_demangle (const char *);
167 static void objc_expand_function_end (void);
169 /* Hash tables to manage the global pool of method prototypes. */
171 hash
*nst_method_hash_list
= 0;
172 hash
*cls_method_hash_list
= 0;
174 static size_t hash_func (tree
);
175 static void hash_init (void);
176 static void hash_enter (hash
*, tree
);
177 static hash
hash_lookup (hash
*, tree
);
178 static void hash_add_attr (hash
, tree
);
179 static tree
lookup_method (tree
, tree
);
180 static tree
lookup_method_static (tree
, tree
, int);
181 static void add_method_to_hash_list (hash
*, tree
);
182 static tree
add_class (tree
);
183 static void add_category (tree
, tree
);
184 static inline tree
lookup_category (tree
, tree
);
188 class_names
, /* class, category, protocol, module names */
189 meth_var_names
, /* method and variable names */
190 meth_var_types
/* method and variable type descriptors */
193 static tree
add_objc_string (tree
, enum string_section
);
194 static tree
get_objc_string_decl (tree
, enum string_section
);
195 static tree
build_objc_string_decl (enum string_section
);
196 static tree
build_selector_reference_decl (void);
198 /* Protocol additions. */
200 static tree
add_protocol (tree
);
201 static tree
lookup_protocol (tree
);
202 static void check_protocol_recursively (tree
, tree
);
203 static tree
lookup_and_install_protocols (tree
);
207 static void encode_type_qualifiers (tree
);
208 static void encode_pointer (tree
, int, int);
209 static void encode_array (tree
, int, int);
210 static void encode_aggregate (tree
, int, int);
211 static void encode_next_bitfield (int);
212 static void encode_gnu_bitfield (int, tree
, int);
213 static void encode_type (tree
, int, int);
214 static void encode_field_decl (tree
, int, int);
216 static void really_start_method (tree
, tree
);
217 static int comp_method_with_proto (tree
, tree
);
218 static int objc_types_are_equivalent (tree
, tree
);
219 static int comp_proto_with_proto (tree
, tree
);
220 static tree
get_arg_type_list (tree
, int, int);
221 static tree
objc_expr_last (tree
);
222 static void synth_self_and_ucmd_args (void);
224 /* Utilities for debugging and error diagnostics. */
226 static void warn_with_method (const char *, int, tree
);
227 static void error_with_ivar (const char *, tree
, tree
);
228 static char *gen_method_decl (tree
, char *);
229 static char *gen_declaration (tree
, char *);
230 static void gen_declaration_1 (tree
, char *);
231 static char *gen_declarator (tree
, char *, const char *);
232 static int is_complex_decl (tree
);
233 static void adorn_decl (tree
, char *);
234 static void dump_interface (FILE *, tree
);
236 /* Everything else. */
238 static tree
define_decl (tree
, tree
);
239 static tree
lookup_method_in_protocol_list (tree
, tree
, int);
240 static tree
lookup_protocol_in_reflist (tree
, tree
);
241 static tree
create_builtin_decl (enum tree_code
, tree
, const char *);
242 static void setup_string_decl (void);
243 static int check_string_class_template (void);
244 static tree
my_build_string (int, const char *);
245 static void build_objc_symtab_template (void);
246 static tree
init_def_list (tree
);
247 static tree
init_objc_symtab (tree
);
248 static tree
build_metadata_decl (const char *, tree
);
249 static void forward_declare_categories (void);
250 static void generate_objc_symtab_decl (void);
251 static tree
build_selector (tree
);
252 static tree
build_typed_selector_reference (tree
, tree
);
253 static tree
build_selector_reference (tree
);
254 static tree
build_class_reference_decl (void);
255 static void add_class_reference (tree
);
256 static tree
build_protocol_template (void);
257 static tree
build_descriptor_table_initializer (tree
, tree
);
258 static tree
build_method_prototype_list_template (tree
, int);
259 static tree
build_method_prototype_template (void);
260 static tree
objc_method_parm_type (tree
);
261 static int objc_encoded_type_size (tree
);
262 static tree
encode_method_prototype (tree
);
263 static tree
generate_descriptor_table (tree
, const char *, int, tree
, tree
);
264 static void generate_method_descriptors (tree
);
265 static void generate_protocol_references (tree
);
266 static void generate_protocols (void);
267 static void check_ivars (tree
, tree
);
268 static tree
build_ivar_list_template (tree
, int);
269 static tree
build_method_list_template (tree
, int);
270 static tree
build_ivar_list_initializer (tree
, tree
);
271 static tree
generate_ivars_list (tree
, const char *, int, tree
);
272 static tree
build_dispatch_table_initializer (tree
, tree
);
273 static tree
generate_dispatch_table (tree
, const char *, int, tree
);
274 static tree
build_shared_structure_initializer (tree
, tree
, tree
, tree
,
275 tree
, int, tree
, tree
, tree
);
276 static void generate_category (tree
);
277 static int is_objc_type_qualifier (tree
);
278 static tree
adjust_type_for_id_default (tree
);
279 static tree
check_duplicates (hash
, int, int);
280 static tree
receiver_is_class_object (tree
, int, int);
281 static int check_methods (tree
, tree
, int);
282 static int conforms_to_protocol (tree
, tree
);
283 static void check_protocol (tree
, const char *, const char *);
284 static void check_protocols (tree
, const char *, const char *);
285 static void gen_declspecs (tree
, char *, int);
286 static void generate_classref_translation_entry (tree
);
287 static void handle_class_ref (tree
);
288 static void generate_struct_by_value_array (void)
290 static void mark_referenced_methods (void);
291 static void generate_objc_image_info (void);
293 /*** Private Interface (data) ***/
295 /* Reserved tag definitions. */
298 #define TAG_OBJECT "objc_object"
299 #define TAG_CLASS "objc_class"
300 #define TAG_SUPER "objc_super"
301 #define TAG_SELECTOR "objc_selector"
303 #define UTAG_CLASS "_objc_class"
304 #define UTAG_IVAR "_objc_ivar"
305 #define UTAG_IVAR_LIST "_objc_ivar_list"
306 #define UTAG_METHOD "_objc_method"
307 #define UTAG_METHOD_LIST "_objc_method_list"
308 #define UTAG_CATEGORY "_objc_category"
309 #define UTAG_MODULE "_objc_module"
310 #define UTAG_SYMTAB "_objc_symtab"
311 #define UTAG_SUPER "_objc_super"
312 #define UTAG_SELECTOR "_objc_selector"
314 #define UTAG_PROTOCOL "_objc_protocol"
315 #define UTAG_METHOD_PROTOTYPE "_objc_method_prototype"
316 #define UTAG_METHOD_PROTOTYPE_LIST "_objc__method_prototype_list"
318 /* Note that the string object global name is only needed for the
320 #define STRING_OBJECT_GLOBAL_FORMAT "_%sClassReference"
322 #define PROTOCOL_OBJECT_CLASS_NAME "Protocol"
324 static const char *TAG_GETCLASS
;
325 static const char *TAG_GETMETACLASS
;
326 static const char *TAG_MSGSEND
;
327 static const char *TAG_MSGSENDSUPER
;
328 /* The NeXT Objective-C messenger may have two extra entry points, for use
329 when returning a structure. */
330 static const char *TAG_MSGSEND_STRET
;
331 static const char *TAG_MSGSENDSUPER_STRET
;
332 static const char *TAG_EXECCLASS
;
333 static const char *default_constant_string_class_name
;
335 /* Runtime metadata flags. */
336 #define CLS_FACTORY 0x0001L
337 #define CLS_META 0x0002L
339 #define OBJC_MODIFIER_STATIC 0x00000001
340 #define OBJC_MODIFIER_FINAL 0x00000002
341 #define OBJC_MODIFIER_PUBLIC 0x00000004
342 #define OBJC_MODIFIER_PRIVATE 0x00000008
343 #define OBJC_MODIFIER_PROTECTED 0x00000010
344 #define OBJC_MODIFIER_NATIVE 0x00000020
345 #define OBJC_MODIFIER_SYNCHRONIZED 0x00000040
346 #define OBJC_MODIFIER_ABSTRACT 0x00000080
347 #define OBJC_MODIFIER_VOLATILE 0x00000100
348 #define OBJC_MODIFIER_TRANSIENT 0x00000200
349 #define OBJC_MODIFIER_NONE_SPECIFIED 0x80000000
351 #define TAG_MSGSEND_NONNIL "objc_msgSendNonNil"
352 #define TAG_MSGSEND_NONNIL_STRET "objc_msgSendNonNil_stret"
353 #define TAG_EXCEPTIONEXTRACT "objc_exception_extract"
354 #define TAG_EXCEPTIONTRYENTER "objc_exception_try_enter"
355 #define TAG_EXCEPTIONTRYEXIT "objc_exception_try_exit"
356 #define TAG_EXCEPTIONMATCH "objc_exception_match"
357 #define TAG_EXCEPTIONTHROW "objc_exception_throw"
358 #define TAG_SYNCENTER "objc_sync_enter"
359 #define TAG_SYNCEXIT "objc_sync_exit"
360 #define TAG_SETJMP "_setjmp"
361 #define TAG_RETURN_STRUCT "objc_return_struct"
363 #define UTAG_EXCDATA "_objc_exception_data"
365 /* The OCTI_... enumeration itself is in objc/objc-act.h. */
366 tree objc_global_trees
[OCTI_MAX
];
368 static void handle_impent (struct imp_entry
*);
370 struct imp_entry
*imp_list
= 0;
371 int imp_count
= 0; /* `@implementation' */
372 int cat_count
= 0; /* `@category' */
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 FILE *gen_declaration_file
;
393 /* Tells "encode_pointer/encode_aggregate" whether we are generating
394 type descriptors for instance variables (as opposed to methods).
395 Type descriptors for instance variables contain more information
396 than methods (for static typing and embedded structures). */
398 static int generating_instance_variables
= 0;
400 /* Some platforms pass small structures through registers versus
401 through an invisible pointer. Determine at what size structure is
402 the transition point between the two possibilities. */
405 generate_struct_by_value_array (void)
408 tree field_decl
, field_decl_chain
;
410 int aggregate_in_mem
[32];
413 /* Presumably no platform passes 32 byte structures in a register. */
414 for (i
= 1; i
< 32; i
++)
418 /* Create an unnamed struct that has `i' character components */
419 type
= start_struct (RECORD_TYPE
, NULL_TREE
);
421 strcpy (buffer
, "c1");
422 field_decl
= create_builtin_decl (FIELD_DECL
,
425 field_decl_chain
= field_decl
;
427 for (j
= 1; j
< i
; j
++)
429 sprintf (buffer
, "c%d", j
+ 1);
430 field_decl
= create_builtin_decl (FIELD_DECL
,
433 chainon (field_decl_chain
, field_decl
);
435 finish_struct (type
, field_decl_chain
, NULL_TREE
);
437 aggregate_in_mem
[i
] = aggregate_value_p (type
, 0);
438 if (!aggregate_in_mem
[i
])
442 /* We found some structures that are returned in registers instead of memory
443 so output the necessary data. */
446 for (i
= 31; i
>= 0; i
--)
447 if (!aggregate_in_mem
[i
])
449 printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n\n", i
);
451 /* The first member of the structure is always 0 because we don't handle
452 structures with 0 members */
453 printf ("static int struct_forward_array[] = {\n 0");
455 for (j
= 1; j
<= i
; j
++)
456 printf (", %d", aggregate_in_mem
[j
]);
466 if (c_objc_common_init () == false)
469 /* Force the line number back to 0; check_newline will have
470 raised it to 1, which will make the builtin functions appear
471 not to be built in. */
474 /* If gen_declaration desired, open the output file. */
475 if (flag_gen_declaration
)
477 register char * const dumpname
= concat (dump_base_name
, ".decl", NULL
);
478 gen_declaration_file
= fopen (dumpname
, "w");
479 if (gen_declaration_file
== 0)
480 fatal_error ("can't open %s: %m", dumpname
);
484 if (flag_next_runtime
)
486 TAG_GETCLASS
= "objc_getClass";
487 TAG_GETMETACLASS
= "objc_getMetaClass";
488 TAG_MSGSEND
= "objc_msgSend";
489 TAG_MSGSENDSUPER
= "objc_msgSendSuper";
490 TAG_MSGSEND_STRET
= "objc_msgSend_stret";
491 TAG_MSGSENDSUPER_STRET
= "objc_msgSendSuper_stret";
492 TAG_EXECCLASS
= "__objc_execClass";
493 default_constant_string_class_name
= "NSConstantString";
497 TAG_GETCLASS
= "objc_get_class";
498 TAG_GETMETACLASS
= "objc_get_meta_class";
499 TAG_MSGSEND
= "objc_msg_lookup";
500 TAG_MSGSENDSUPER
= "objc_msg_lookup_super";
501 /* GNU runtime does not provide special functions to support
502 structure-returning methods. */
503 TAG_EXECCLASS
= "__objc_exec_class";
504 default_constant_string_class_name
= "NXConstantString";
505 flag_typed_selectors
= 1;
508 objc_ellipsis_node
= make_node (ERROR_MARK
);
512 if (print_struct_values
)
513 generate_struct_by_value_array ();
521 mark_referenced_methods ();
522 c_objc_common_finish_file ();
524 /* Finalize Objective-C runtime data. No need to generate tables
525 and code if only checking syntax. */
526 if (!flag_syntax_only
)
529 if (gen_declaration_file
)
530 fclose (gen_declaration_file
);
534 define_decl (tree declarator
, tree declspecs
)
536 tree decl
= start_decl (declarator
, declspecs
, 0, NULL_TREE
);
537 finish_decl (decl
, NULL_TREE
, NULL_TREE
);
541 /* Return the first occurrence of a method declaration corresponding
542 to sel_name in rproto_list. Search rproto_list recursively.
543 If is_class is 0, search for instance methods, otherwise for class
546 lookup_method_in_protocol_list (tree rproto_list
, tree sel_name
,
552 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
554 p
= TREE_VALUE (rproto
);
556 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
558 if ((fnd
= lookup_method (is_class
559 ? PROTOCOL_CLS_METHODS (p
)
560 : PROTOCOL_NST_METHODS (p
), sel_name
)))
562 else if (PROTOCOL_LIST (p
))
563 fnd
= lookup_method_in_protocol_list (PROTOCOL_LIST (p
),
568 ; /* An identifier...if we could not find a protocol. */
579 lookup_protocol_in_reflist (tree rproto_list
, tree lproto
)
583 /* Make sure the protocol is supported by the object on the rhs. */
584 if (TREE_CODE (lproto
) == PROTOCOL_INTERFACE_TYPE
)
587 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
589 p
= TREE_VALUE (rproto
);
591 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
596 else if (PROTOCOL_LIST (p
))
597 fnd
= lookup_protocol_in_reflist (PROTOCOL_LIST (p
), lproto
);
606 ; /* An identifier...if we could not find a protocol. */
612 /* Return true if TYPE is 'id'. */
615 objc_is_object_id (tree type
)
617 return OBJC_TYPE_NAME (type
) == objc_object_id
;
621 objc_is_class_id (tree type
)
623 return OBJC_TYPE_NAME (type
) == objc_class_id
;
626 /* Return 1 if LHS and RHS are compatible types for assignment or
627 various other operations. Return 0 if they are incompatible, and
628 return -1 if we choose to not decide (because the types are really
629 just C types, not ObjC specific ones). When the operation is
630 REFLEXIVE (typically comparisons), check for compatibility in
631 either direction; when it's not (typically assignments), don't.
633 This function is called in two cases: when both lhs and rhs are
634 pointers to records (in which case we check protocols too), and
635 when both lhs and rhs are records (in which case we check class
638 Warnings about classes/protocols not implementing a protocol are
639 emitted here (multiple of those warnings might be emitted for a
640 single line!); generic warnings about incompatible assignments and
641 lacks of casts in comparisons are/must be emitted by the caller if
646 objc_comptypes (tree lhs
, tree rhs
, int reflexive
)
648 /* New clause for protocols. */
650 /* Here we manage the case of a POINTER_TYPE = POINTER_TYPE. We only
651 manage the ObjC ones, and leave the rest to the C code. */
652 if (TREE_CODE (lhs
) == POINTER_TYPE
653 && TREE_CODE (TREE_TYPE (lhs
)) == RECORD_TYPE
654 && TREE_CODE (rhs
) == POINTER_TYPE
655 && TREE_CODE (TREE_TYPE (rhs
)) == RECORD_TYPE
)
657 int lhs_is_proto
= IS_PROTOCOL_QUALIFIED_ID (lhs
);
658 int rhs_is_proto
= IS_PROTOCOL_QUALIFIED_ID (rhs
);
662 tree lproto
, lproto_list
= TYPE_PROTOCOL_LIST (lhs
);
663 tree rproto
, rproto_list
;
666 /* <Protocol> = <Protocol> */
669 rproto_list
= TYPE_PROTOCOL_LIST (rhs
);
673 /* An assignment between objects of type 'id
674 <Protocol>'; make sure the protocol on the lhs is
675 supported by the object on the rhs. */
676 for (lproto
= lproto_list
; lproto
;
677 lproto
= TREE_CHAIN (lproto
))
679 p
= TREE_VALUE (lproto
);
680 rproto
= lookup_protocol_in_reflist (rproto_list
, p
);
684 ("object does not conform to the `%s' protocol",
685 IDENTIFIER_POINTER (PROTOCOL_NAME (p
)));
691 /* Obscure case - a comparison between two objects
692 of type 'id <Protocol>'. Check that either the
693 protocol on the lhs is supported by the object on
694 the rhs, or viceversa. */
696 /* Check if the protocol on the lhs is supported by the
697 object on the rhs. */
698 for (lproto
= lproto_list
; lproto
;
699 lproto
= TREE_CHAIN (lproto
))
701 p
= TREE_VALUE (lproto
);
702 rproto
= lookup_protocol_in_reflist (rproto_list
, p
);
706 /* Check failed - check if the protocol on the rhs
707 is supported by the object on the lhs. */
708 for (rproto
= rproto_list
; rproto
;
709 rproto
= TREE_CHAIN (rproto
))
711 p
= TREE_VALUE (rproto
);
712 lproto
= lookup_protocol_in_reflist (lproto_list
,
717 /* This check failed too: incompatible */
727 /* <Protocol> = <class> * */
728 else if (TYPED_OBJECT (TREE_TYPE (rhs
)))
730 tree rname
= OBJC_TYPE_NAME (TREE_TYPE (rhs
));
733 /* Make sure the protocol is supported by the object on
735 for (lproto
= lproto_list
; lproto
; lproto
= TREE_CHAIN (lproto
))
737 p
= TREE_VALUE (lproto
);
739 rinter
= lookup_interface (rname
);
741 while (rinter
&& !rproto
)
745 rproto_list
= CLASS_PROTOCOL_LIST (rinter
);
746 rproto
= lookup_protocol_in_reflist (rproto_list
, p
);
747 /* If the underlying ObjC class does not have
748 the protocol we're looking for, check for "one-off"
749 protocols (e.g., `NSObject<MyProt> *foo;') attached
753 rproto_list
= TYPE_PROTOCOL_LIST (TREE_TYPE (rhs
));
754 rproto
= lookup_protocol_in_reflist (rproto_list
, p
);
757 /* Check for protocols adopted by categories. */
758 cat
= CLASS_CATEGORY_LIST (rinter
);
759 while (cat
&& !rproto
)
761 rproto_list
= CLASS_PROTOCOL_LIST (cat
);
762 rproto
= lookup_protocol_in_reflist (rproto_list
, p
);
763 cat
= CLASS_CATEGORY_LIST (cat
);
766 rinter
= lookup_interface (CLASS_SUPER_NAME (rinter
));
770 warning ("class `%s' does not implement the `%s' protocol",
771 IDENTIFIER_POINTER (OBJC_TYPE_NAME (TREE_TYPE (rhs
))),
772 IDENTIFIER_POINTER (PROTOCOL_NAME (p
)));
776 /* <Protocol> = id */
777 else if (objc_is_object_id (TREE_TYPE (rhs
)))
781 /* <Protocol> = Class */
782 else if (objc_is_class_id (TREE_TYPE (rhs
)))
786 /* <Protocol> = ?? : let comptypes decide. */
789 else if (rhs_is_proto
)
791 /* <class> * = <Protocol> */
792 if (TYPED_OBJECT (TREE_TYPE (lhs
)))
796 tree rname
= OBJC_TYPE_NAME (TREE_TYPE (lhs
));
798 tree rproto
, rproto_list
= TYPE_PROTOCOL_LIST (rhs
);
800 /* Make sure the protocol is supported by the object on
802 for (rproto
= rproto_list
; rproto
;
803 rproto
= TREE_CHAIN (rproto
))
805 tree p
= TREE_VALUE (rproto
);
807 rinter
= lookup_interface (rname
);
809 while (rinter
&& !lproto
)
813 tree lproto_list
= CLASS_PROTOCOL_LIST (rinter
);
814 lproto
= lookup_protocol_in_reflist (lproto_list
, p
);
815 /* If the underlying ObjC class does not
816 have the protocol we're looking for,
817 check for "one-off" protocols (e.g.,
818 `NSObject<MyProt> *foo;') attached to the
822 lproto_list
= TYPE_PROTOCOL_LIST
824 lproto
= lookup_protocol_in_reflist
828 /* Check for protocols adopted by categories. */
829 cat
= CLASS_CATEGORY_LIST (rinter
);
830 while (cat
&& !lproto
)
832 lproto_list
= CLASS_PROTOCOL_LIST (cat
);
833 lproto
= lookup_protocol_in_reflist (lproto_list
,
835 cat
= CLASS_CATEGORY_LIST (cat
);
838 rinter
= lookup_interface (CLASS_SUPER_NAME
843 warning ("class `%s' does not implement the `%s' protocol",
844 IDENTIFIER_POINTER (OBJC_TYPE_NAME
846 IDENTIFIER_POINTER (PROTOCOL_NAME (p
)));
853 /* id = <Protocol> */
854 else if (objc_is_object_id (TREE_TYPE (lhs
)))
858 /* Class = <Protocol> */
859 else if (objc_is_class_id (TREE_TYPE (lhs
)))
863 /* ??? = <Protocol> : let comptypes decide */
871 /* Attention: we shouldn't defer to comptypes here. One bad
872 side effect would be that we might loose the REFLEXIVE
875 lhs
= TREE_TYPE (lhs
);
876 rhs
= TREE_TYPE (rhs
);
880 if (TREE_CODE (lhs
) != RECORD_TYPE
|| TREE_CODE (rhs
) != RECORD_TYPE
)
882 /* Nothing to do with ObjC - let immediately comptypes take
883 responsibility for checking. */
887 /* `id' = `<class> *' `<class> *' = `id': always allow it.
889 'Object *o = [[Object alloc] init]; falls
890 in the case <class> * = `id'.
892 if ((objc_is_object_id (lhs
) && TYPED_OBJECT (rhs
))
893 || (objc_is_object_id (rhs
) && TYPED_OBJECT (lhs
)))
896 /* `id' = `Class', `Class' = `id' */
898 else if ((objc_is_object_id (lhs
) && objc_is_class_id (rhs
))
899 || (objc_is_class_id (lhs
) && objc_is_object_id (rhs
)))
902 /* `Class' != `<class> *' && `<class> *' != `Class'! */
903 else if ((OBJC_TYPE_NAME (lhs
) == objc_class_id
&& TYPED_OBJECT (rhs
))
904 || (OBJC_TYPE_NAME (rhs
) == objc_class_id
&& TYPED_OBJECT (lhs
)))
907 /* `<class> *' = `<class> *' */
909 else if (TYPED_OBJECT (lhs
) && TYPED_OBJECT (rhs
))
911 tree lname
= OBJC_TYPE_NAME (lhs
);
912 tree rname
= OBJC_TYPE_NAME (rhs
);
918 /* If the left hand side is a super class of the right hand side,
920 for (inter
= lookup_interface (rname
); inter
;
921 inter
= lookup_interface (CLASS_SUPER_NAME (inter
)))
922 if (lname
== CLASS_SUPER_NAME (inter
))
925 /* Allow the reverse when reflexive. */
927 for (inter
= lookup_interface (lname
); inter
;
928 inter
= lookup_interface (CLASS_SUPER_NAME (inter
)))
929 if (rname
== CLASS_SUPER_NAME (inter
))
935 /* Not an ObjC type - let comptypes do the check. */
939 /* Called from finish_decl. */
942 objc_check_decl (tree decl
)
944 tree type
= TREE_TYPE (decl
);
946 if (TREE_CODE (type
) != RECORD_TYPE
)
948 if (TYPE_NAME (type
) && (type
= is_class_name (TYPE_NAME (type
))))
949 error ("statically allocated instance of Objective-C class `%s'",
950 IDENTIFIER_POINTER (type
));
953 /* Implement static typing. At this point, we know we have an interface. */
956 get_static_reference (tree interface
, tree protocols
)
958 tree type
= xref_tag (RECORD_TYPE
, interface
);
962 tree t
, m
= TYPE_MAIN_VARIANT (type
);
964 t
= copy_node (type
);
966 /* Add this type to the chain of variants of TYPE. */
967 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
968 TYPE_NEXT_VARIANT (m
) = t
;
970 /* Look up protocols and install in lang specific list. Note
971 that the protocol list can have a different lifetime than T! */
972 SET_TYPE_PROTOCOL_LIST (t
, lookup_and_install_protocols (protocols
));
974 /* This forces a new pointer type to be created later
975 (in build_pointer_type)...so that the new template
976 we just created will actually be used...what a hack! */
977 if (TYPE_POINTER_TO (t
))
978 TYPE_POINTER_TO (t
) = NULL_TREE
;
986 /* Return a declaration corresponding to a protocol list qualified 'id'. */
988 get_protocol_reference (tree protocols
)
990 tree type_decl
= lookup_name (objc_id_id
);
993 if (type_decl
&& TREE_CODE (type_decl
) == TYPE_DECL
)
995 type
= TREE_TYPE (type_decl
);
996 if (TYPE_MAIN_VARIANT (type
) != objc_id_type
)
997 warning ("unexpected type for `id' (%s)",
998 gen_declaration (type
, errbuf
));
1002 error ("undefined type `id', please import <objc/objc.h>");
1003 return error_mark_node
;
1006 /* This clause creates a new pointer type that is qualified with
1007 the protocol specification...this info is used later to do more
1008 elaborate type checking. */
1012 tree t
, m
= TYPE_MAIN_VARIANT (type
);
1014 t
= copy_node (type
);
1016 /* Add this type to the chain of variants of TYPE. */
1017 TYPE_NEXT_VARIANT (t
) = TYPE_NEXT_VARIANT (m
);
1018 TYPE_NEXT_VARIANT (m
) = t
;
1020 /* Look up protocols...and install in lang specific list */
1021 SET_TYPE_PROTOCOL_LIST (t
, lookup_and_install_protocols (protocols
));
1023 /* This forces a new pointer type to be created later
1024 (in build_pointer_type)...so that the new template
1025 we just created will actually be used...what a hack! */
1026 if (TYPE_POINTER_TO (t
))
1027 TYPE_POINTER_TO (t
) = NULL_TREE
;
1034 /* Check for circular dependencies in protocols. The arguments are
1035 PROTO, the protocol to check, and LIST, a list of protocol it
1039 check_protocol_recursively (tree proto
, tree list
)
1043 for (p
= list
; p
; p
= TREE_CHAIN (p
))
1045 tree pp
= TREE_VALUE (p
);
1047 if (TREE_CODE (pp
) == IDENTIFIER_NODE
)
1048 pp
= lookup_protocol (pp
);
1051 fatal_error ("protocol `%s' has circular dependency",
1052 IDENTIFIER_POINTER (PROTOCOL_NAME (pp
)));
1054 check_protocol_recursively (proto
, PROTOCOL_LIST (pp
));
1058 /* Look up PROTOCOLS, and return a list of those that are found.
1059 If none are found, return NULL. */
1062 lookup_and_install_protocols (tree protocols
)
1065 tree return_value
= NULL_TREE
;
1067 for (proto
= protocols
; proto
; proto
= TREE_CHAIN (proto
))
1069 tree ident
= TREE_VALUE (proto
);
1070 tree p
= lookup_protocol (ident
);
1073 error ("cannot find protocol declaration for `%s'",
1074 IDENTIFIER_POINTER (ident
));
1076 return_value
= chainon (return_value
,
1077 build_tree_list (NULL_TREE
, p
));
1080 return return_value
;
1083 /* Create and push a decl for a built-in external variable or field NAME.
1085 TYPE is its data type. */
1088 create_builtin_decl (enum tree_code code
, tree type
, const char *name
)
1090 tree decl
= build_decl (code
, get_identifier (name
), type
);
1092 if (code
== VAR_DECL
)
1094 TREE_STATIC (decl
) = 1;
1095 make_decl_rtl (decl
, 0);
1097 DECL_ARTIFICIAL (decl
) = 1;
1103 /* Find the decl for the constant string class. */
1106 setup_string_decl (void)
1108 if (!string_class_decl
)
1110 if (!constant_string_global_id
)
1114 /* %s in format will provide room for terminating null */
1115 length
= strlen (STRING_OBJECT_GLOBAL_FORMAT
)
1116 + strlen (constant_string_class_name
);
1117 name
= xmalloc (length
);
1118 sprintf (name
, STRING_OBJECT_GLOBAL_FORMAT
,
1119 constant_string_class_name
);
1120 constant_string_global_id
= get_identifier (name
);
1122 string_class_decl
= lookup_name (constant_string_global_id
);
1126 /* Purpose: "play" parser, creating/installing representations
1127 of the declarations that are required by Objective-C.
1131 type_spec--------->sc_spec
1132 (tree_list) (tree_list)
1135 identifier_node identifier_node */
1138 synth_module_prologue (void)
1142 /* Defined in `objc.h' */
1143 objc_object_id
= get_identifier (TAG_OBJECT
);
1145 objc_object_reference
= xref_tag (RECORD_TYPE
, objc_object_id
);
1147 objc_id_type
= build_pointer_type (objc_object_reference
);
1149 objc_id_id
= get_identifier (TYPE_ID
);
1150 objc_class_id
= get_identifier (TAG_CLASS
);
1152 objc_class_type
= build_pointer_type (xref_tag (RECORD_TYPE
, objc_class_id
));
1153 temp_type
= get_identifier (PROTOCOL_OBJECT_CLASS_NAME
);
1154 objc_declare_class (tree_cons (NULL_TREE
, temp_type
, NULL_TREE
));
1155 objc_protocol_type
= build_pointer_type (xref_tag (RECORD_TYPE
, temp_type
));
1157 /* Declare type of selector-objects that represent an operation name. */
1159 if (flag_next_runtime
)
1160 /* `struct objc_selector *' */
1162 = build_pointer_type (xref_tag (RECORD_TYPE
,
1163 get_identifier (TAG_SELECTOR
)));
1165 /* `const struct objc_selector *' */
1167 = build_pointer_type
1168 (build_qualified_type (xref_tag (RECORD_TYPE
,
1169 get_identifier (TAG_SELECTOR
)),
1172 /* Declare receiver type used for dispatching messages to 'super'. */
1174 /* `struct objc_super *' */
1175 objc_super_type
= build_pointer_type (xref_tag (RECORD_TYPE
,
1176 get_identifier (TAG_SUPER
)));
1178 if (flag_next_runtime
)
1180 /* NB: In order to call one of the ..._stret (struct-returning)
1181 functions, the function *MUST* first be cast to a signature that
1182 corresponds to the actual ObjC method being invoked. This is
1183 what is done by the build_objc_method_call() routine below. */
1185 /* id objc_msgSend (id, SEL, ...); */
1186 /* id objc_msgSendNonNil (id, SEL, ...); */
1187 /* id objc_msgSend_stret (id, SEL, ...); */
1188 /* id objc_msgSendNonNil_stret (id, SEL, ...); */
1190 = build_function_type (objc_id_type
,
1191 tree_cons (NULL_TREE
, objc_id_type
,
1192 tree_cons (NULL_TREE
,
1195 umsg_decl
= builtin_function (TAG_MSGSEND
,
1196 temp_type
, 0, NOT_BUILT_IN
,
1198 umsg_nonnil_decl
= builtin_function (TAG_MSGSEND_NONNIL
,
1199 temp_type
, 0, NOT_BUILT_IN
,
1201 umsg_stret_decl
= builtin_function (TAG_MSGSEND_STRET
,
1202 temp_type
, 0, NOT_BUILT_IN
,
1204 umsg_nonnil_stret_decl
= builtin_function (TAG_MSGSEND_NONNIL_STRET
,
1205 temp_type
, 0, NOT_BUILT_IN
,
1208 /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
1209 /* id objc_msgSendSuper_stret (struct objc_super *, SEL, ...); */
1211 = build_function_type (objc_id_type
,
1212 tree_cons (NULL_TREE
, objc_super_type
,
1213 tree_cons (NULL_TREE
,
1216 umsg_super_decl
= builtin_function (TAG_MSGSENDSUPER
,
1217 temp_type
, 0, NOT_BUILT_IN
,
1219 umsg_super_stret_decl
= builtin_function (TAG_MSGSENDSUPER_STRET
,
1220 temp_type
, 0, NOT_BUILT_IN
, 0,
1225 /* GNU runtime messenger entry points. */
1227 /* typedef id (*IMP)(id, SEL, ...); */
1229 = build_pointer_type
1230 (build_function_type (objc_id_type
,
1231 tree_cons (NULL_TREE
, objc_id_type
,
1232 tree_cons (NULL_TREE
,
1236 /* IMP objc_msg_lookup (id, SEL); */
1238 = build_function_type (IMP_type
,
1239 tree_cons (NULL_TREE
, objc_id_type
,
1240 tree_cons (NULL_TREE
,
1243 umsg_decl
= builtin_function (TAG_MSGSEND
,
1244 temp_type
, 0, NOT_BUILT_IN
,
1247 /* IMP objc_msg_lookup_super (struct objc_super *, SEL); */
1249 = build_function_type (IMP_type
,
1250 tree_cons (NULL_TREE
, objc_super_type
,
1251 tree_cons (NULL_TREE
,
1254 umsg_super_decl
= builtin_function (TAG_MSGSENDSUPER
,
1255 temp_type
, 0, NOT_BUILT_IN
,
1259 /* id objc_getClass (const char *); */
1261 temp_type
= build_function_type (objc_id_type
,
1262 tree_cons (NULL_TREE
,
1263 const_string_type_node
,
1267 = builtin_function (TAG_GETCLASS
, temp_type
, 0, NOT_BUILT_IN
,
1270 /* id objc_getMetaClass (const char *); */
1272 objc_get_meta_class_decl
1273 = builtin_function (TAG_GETMETACLASS
, temp_type
, 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
1275 build_super_template ();
1276 build_objc_exception_stuff ();
1277 if (flag_next_runtime
)
1278 build_next_objc_exception_stuff ();
1280 /* static SEL _OBJC_SELECTOR_TABLE[]; */
1282 if (! flag_next_runtime
)
1284 if (flag_typed_selectors
)
1286 /* Suppress outputting debug symbols, because
1287 dbxout_init hasn'r been called yet. */
1288 enum debug_info_type save_write_symbols
= write_symbols
;
1289 const struct gcc_debug_hooks
*const save_hooks
= debug_hooks
;
1290 write_symbols
= NO_DEBUG
;
1291 debug_hooks
= &do_nothing_debug_hooks
;
1293 build_selector_template ();
1294 temp_type
= build_array_type (objc_selector_template
, NULL_TREE
);
1296 write_symbols
= save_write_symbols
;
1297 debug_hooks
= save_hooks
;
1300 temp_type
= build_array_type (objc_selector_type
, NULL_TREE
);
1302 layout_type (temp_type
);
1303 UOBJC_SELECTOR_TABLE_decl
1304 = create_builtin_decl (VAR_DECL
, temp_type
,
1305 "_OBJC_SELECTOR_TABLE");
1307 /* Avoid warning when not sending messages. */
1308 TREE_USED (UOBJC_SELECTOR_TABLE_decl
) = 1;
1311 /* Forward declare constant_string_id and constant_string_type. */
1312 if (!constant_string_class_name
)
1313 constant_string_class_name
= default_constant_string_class_name
;
1315 constant_string_id
= get_identifier (constant_string_class_name
);
1316 objc_declare_class (tree_cons (NULL_TREE
, constant_string_id
, NULL_TREE
));
1318 /* Pre-build the following entities - for speed/convenience. */
1319 self_id
= get_identifier ("self");
1320 ucmd_id
= get_identifier ("_cmd");
1322 /* The C++ front-end does not appear to grok __attribute__((__unused__)). */
1323 unused_list
= build_tree_list (get_identifier ("__unused__"), NULL_TREE
);
1327 /* Ensure that the ivar list for NSConstantString/NXConstantString
1328 (or whatever was specified via `-fconstant-string-class')
1329 contains fields at least as large as the following three, so that
1330 the runtime can stomp on them with confidence:
1332 struct STRING_OBJECT_CLASS_NAME
1336 unsigned int length;
1340 check_string_class_template (void)
1342 tree field_decl
= TYPE_FIELDS (constant_string_type
);
1344 #define AT_LEAST_AS_LARGE_AS(F, T) \
1345 (F && TREE_CODE (F) == FIELD_DECL \
1346 && (TREE_INT_CST_LOW (DECL_SIZE (F)) \
1347 >= TREE_INT_CST_LOW (TYPE_SIZE (T))))
1349 if (!AT_LEAST_AS_LARGE_AS (field_decl
, ptr_type_node
))
1352 field_decl
= TREE_CHAIN (field_decl
);
1353 if (!AT_LEAST_AS_LARGE_AS (field_decl
, ptr_type_node
))
1356 field_decl
= TREE_CHAIN (field_decl
);
1357 return AT_LEAST_AS_LARGE_AS (field_decl
, unsigned_type_node
);
1359 #undef AT_LEAST_AS_LARGE_AS
1362 /* Avoid calling `check_string_class_template ()' more than once. */
1363 static GTY(()) int string_layout_checked
;
1365 /* Custom build_string which sets TREE_TYPE! */
1368 my_build_string (int len
, const char *str
)
1370 return fix_string_type (build_string (len
, str
));
1373 /* Given a chain of STRING_CST's, build a static instance of
1374 NXConstantString which points at the concatenation of those
1375 strings. We place the string object in the __string_objects
1376 section of the __OBJC segment. The Objective-C runtime will
1377 initialize the isa pointers of the string objects to point at the
1378 NXConstantString class object. */
1381 build_objc_string_object (tree string
)
1383 tree initlist
, constructor
, constant_string_class
;
1387 string
= fix_string_type (string
);
1389 constant_string_class
= lookup_interface (constant_string_id
);
1390 if (!constant_string_class
1391 || !(constant_string_type
1392 = CLASS_STATIC_TEMPLATE (constant_string_class
)))
1394 error ("cannot find interface declaration for `%s'",
1395 IDENTIFIER_POINTER (constant_string_id
));
1396 return error_mark_node
;
1399 /* Call to 'combine_strings' has been moved above. */
1400 TREE_SET_CODE (string
, STRING_CST
);
1401 length
= TREE_STRING_LENGTH (string
) - 1;
1403 if (!string_layout_checked
)
1405 /* The NSConstantString/NXConstantString ivar layout is now
1407 if (!check_string_class_template ())
1409 error ("interface `%s' does not have valid constant string layout",
1410 IDENTIFIER_POINTER (constant_string_id
));
1411 return error_mark_node
;
1413 add_class_reference (constant_string_id
);
1415 fields
= TYPE_FIELDS (constant_string_type
);
1417 /* & ((NXConstantString) { NULL, string, length }) */
1419 if (flag_next_runtime
)
1421 /* For the NeXT runtime, we can generate a literal reference
1422 to the string class, don't need to run a constructor. */
1423 setup_string_decl ();
1424 if (string_class_decl
== NULL_TREE
)
1426 error ("cannot find reference tag for class `%s'",
1427 IDENTIFIER_POINTER (constant_string_id
));
1428 return error_mark_node
;
1430 initlist
= build_tree_list
1432 copy_node (build_unary_op (ADDR_EXPR
, string_class_decl
, 0)));
1436 initlist
= build_tree_list (fields
, build_int_2 (0, 0));
1439 fields
= TREE_CHAIN (fields
);
1442 = tree_cons (fields
, copy_node (build_unary_op (ADDR_EXPR
, string
, 1)),
1445 fields
= TREE_CHAIN (fields
);
1447 initlist
= tree_cons (fields
, build_int_2 (length
, 0), initlist
);
1448 constructor
= objc_build_constructor (constant_string_type
,
1449 nreverse (initlist
));
1451 if (!flag_next_runtime
)
1454 = objc_add_static_instance (constructor
, constant_string_type
);
1457 return (build_unary_op (ADDR_EXPR
, constructor
, 1));
1460 /* Declare a static instance of CLASS_DECL initialized by CONSTRUCTOR. */
1462 static GTY(()) int num_static_inst
;
1465 objc_add_static_instance (tree constructor
, tree class_decl
)
1470 /* Find the list of static instances for the CLASS_DECL. Create one if
1472 for (chain
= &objc_static_instances
;
1473 *chain
&& TREE_VALUE (*chain
) != class_decl
;
1474 chain
= &TREE_CHAIN (*chain
));
1477 *chain
= tree_cons (NULL_TREE
, class_decl
, NULL_TREE
);
1478 add_objc_string (OBJC_TYPE_NAME (class_decl
), class_names
);
1481 sprintf (buf
, "_OBJC_INSTANCE_%d", num_static_inst
++);
1482 decl
= build_decl (VAR_DECL
, get_identifier (buf
), class_decl
);
1483 DECL_COMMON (decl
) = 1;
1484 TREE_STATIC (decl
) = 1;
1485 DECL_ARTIFICIAL (decl
) = 1;
1486 DECL_INITIAL (decl
) = constructor
;
1488 /* We may be writing something else just now.
1489 Postpone till end of input. */
1490 DECL_DEFER_OUTPUT (decl
) = 1;
1491 pushdecl_top_level (decl
);
1492 rest_of_decl_compilation (decl
, 0, 1, 0);
1494 /* Add the DECL to the head of this CLASS' list. */
1495 TREE_PURPOSE (*chain
) = tree_cons (NULL_TREE
, decl
, TREE_PURPOSE (*chain
));
1500 /* Build a static constant CONSTRUCTOR
1501 with type TYPE and elements ELTS. */
1504 objc_build_constructor (tree type
, tree elts
)
1506 tree constructor
, f
, e
;
1508 /* ??? Most of the places that we build constructors, we don't fill in
1509 the type of integers properly. Convert them all en masse. */
1510 if (TREE_CODE (type
) == ARRAY_TYPE
)
1512 f
= TREE_TYPE (type
);
1513 if (TREE_CODE (f
) == POINTER_TYPE
|| TREE_CODE (f
) == INTEGER_TYPE
)
1514 for (e
= elts
; e
; e
= TREE_CHAIN (e
))
1515 TREE_VALUE (e
) = convert (f
, TREE_VALUE (e
));
1519 f
= TYPE_FIELDS (type
);
1520 for (e
= elts
; e
&& f
; e
= TREE_CHAIN (e
), f
= TREE_CHAIN (f
))
1521 if (TREE_CODE (TREE_TYPE (f
)) == POINTER_TYPE
1522 || TREE_CODE (TREE_TYPE (f
)) == INTEGER_TYPE
)
1523 TREE_VALUE (e
) = convert (TREE_TYPE (f
), TREE_VALUE (e
));
1526 constructor
= build_constructor (type
, elts
);
1527 TREE_CONSTANT (constructor
) = 1;
1528 TREE_STATIC (constructor
) = 1;
1529 TREE_READONLY (constructor
) = 1;
1532 /* zlaski 2001-Apr-02: mark this as a call to a constructor, as required by
1533 build_unary_op (wasn't true in 2.7.2.1 days) */
1534 TREE_HAS_CONSTRUCTOR (constructor
) = 1;
1539 /* Take care of defining and initializing _OBJC_SYMBOLS. */
1541 /* Predefine the following data type:
1549 void *defs[cls_def_cnt + cat_def_cnt];
1553 build_objc_symtab_template (void)
1555 tree field_decl
, field_decl_chain
;
1557 objc_symtab_template
1558 = start_struct (RECORD_TYPE
, get_identifier (UTAG_SYMTAB
));
1560 /* long sel_ref_cnt; */
1562 field_decl
= create_builtin_decl (FIELD_DECL
,
1563 long_integer_type_node
,
1565 field_decl_chain
= field_decl
;
1569 field_decl
= create_builtin_decl (FIELD_DECL
,
1570 build_pointer_type (objc_selector_type
),
1572 chainon (field_decl_chain
, field_decl
);
1574 /* short cls_def_cnt; */
1576 field_decl
= create_builtin_decl (FIELD_DECL
,
1577 short_integer_type_node
,
1579 chainon (field_decl_chain
, field_decl
);
1581 /* short cat_def_cnt; */
1583 field_decl
= create_builtin_decl (FIELD_DECL
,
1584 short_integer_type_node
,
1586 chainon (field_decl_chain
, field_decl
);
1588 if (imp_count
|| cat_count
|| !flag_next_runtime
)
1590 /* void *defs[imp_count + cat_count (+ 1)]; */
1591 /* NB: The index is one less than the size of the array. */
1592 int index
= imp_count
+ cat_count
1593 + (flag_next_runtime
? -1: 0);
1594 field_decl
= create_builtin_decl
1598 build_index_type (build_int_2 (index
, 0))),
1600 chainon (field_decl_chain
, field_decl
);
1603 finish_struct (objc_symtab_template
, field_decl_chain
, NULL_TREE
);
1606 /* Create the initial value for the `defs' field of _objc_symtab.
1607 This is a CONSTRUCTOR. */
1610 init_def_list (tree type
)
1612 tree expr
, initlist
= NULL_TREE
;
1613 struct imp_entry
*impent
;
1616 for (impent
= imp_list
; impent
; impent
= impent
->next
)
1618 if (TREE_CODE (impent
->imp_context
) == CLASS_IMPLEMENTATION_TYPE
)
1620 expr
= build_unary_op (ADDR_EXPR
, impent
->class_decl
, 0);
1621 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
1626 for (impent
= imp_list
; impent
; impent
= impent
->next
)
1628 if (TREE_CODE (impent
->imp_context
) == CATEGORY_IMPLEMENTATION_TYPE
)
1630 expr
= build_unary_op (ADDR_EXPR
, impent
->class_decl
, 0);
1631 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
1635 if (!flag_next_runtime
)
1637 /* statics = { ..., _OBJC_STATIC_INSTANCES, ... } */
1640 if (static_instances_decl
)
1641 expr
= build_unary_op (ADDR_EXPR
, static_instances_decl
, 0);
1643 expr
= build_int_2 (0, 0);
1645 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
1648 return objc_build_constructor (type
, nreverse (initlist
));
1651 /* Construct the initial value for all of _objc_symtab. */
1654 init_objc_symtab (tree type
)
1658 /* sel_ref_cnt = { ..., 5, ... } */
1660 initlist
= build_tree_list (NULL_TREE
, build_int_2 (0, 0));
1662 /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
1664 if (flag_next_runtime
|| ! sel_ref_chain
)
1665 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
1667 initlist
= tree_cons (NULL_TREE
,
1668 build_unary_op (ADDR_EXPR
,
1669 UOBJC_SELECTOR_TABLE_decl
, 1),
1672 /* cls_def_cnt = { ..., 5, ... } */
1674 initlist
= tree_cons (NULL_TREE
, build_int_2 (imp_count
, 0), initlist
);
1676 /* cat_def_cnt = { ..., 5, ... } */
1678 initlist
= tree_cons (NULL_TREE
, build_int_2 (cat_count
, 0), initlist
);
1680 /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
1682 if (imp_count
|| cat_count
|| !flag_next_runtime
)
1685 tree field
= TYPE_FIELDS (type
);
1686 field
= TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (field
))));
1688 initlist
= tree_cons (NULL_TREE
, init_def_list (TREE_TYPE (field
)),
1692 return objc_build_constructor (type
, nreverse (initlist
));
1695 /* Generate forward declarations for metadata such as
1696 'OBJC_CLASS_...'. */
1699 build_metadata_decl (const char *name
, tree type
)
1701 tree decl
, decl_specs
;
1702 /* extern struct TYPE NAME_<name>; */
1703 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_EXTERN
]);
1704 decl_specs
= tree_cons (NULL_TREE
, type
, decl_specs
);
1705 decl
= define_decl (synth_id_with_class_suffix
1707 objc_implementation_context
),
1709 TREE_USED (decl
) = 1;
1710 DECL_ARTIFICIAL (decl
) = 1;
1711 TREE_PUBLIC (decl
) = 0;
1715 /* Push forward-declarations of all the categories so that
1716 init_def_list can use them in a CONSTRUCTOR. */
1719 forward_declare_categories (void)
1721 struct imp_entry
*impent
;
1722 tree sav
= objc_implementation_context
;
1724 for (impent
= imp_list
; impent
; impent
= impent
->next
)
1726 if (TREE_CODE (impent
->imp_context
) == CATEGORY_IMPLEMENTATION_TYPE
)
1728 /* Set an invisible arg to synth_id_with_class_suffix. */
1729 objc_implementation_context
= impent
->imp_context
;
1730 /* extern struct objc_category _OBJC_CATEGORY_<name>; */
1731 impent
->class_decl
= build_metadata_decl ("_OBJC_CATEGORY",
1732 objc_category_template
);
1735 objc_implementation_context
= sav
;
1738 /* Create the declaration of _OBJC_SYMBOLS, with type `struct _objc_symtab'
1739 and initialized appropriately. */
1742 generate_objc_symtab_decl (void)
1746 if (!objc_category_template
)
1747 build_category_template ();
1749 /* forward declare categories */
1751 forward_declare_categories ();
1753 if (!objc_symtab_template
)
1754 build_objc_symtab_template ();
1756 sc_spec
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_STATIC
]);
1758 UOBJC_SYMBOLS_decl
= start_decl (get_identifier ("_OBJC_SYMBOLS"),
1759 tree_cons (NULL_TREE
,
1760 objc_symtab_template
, sc_spec
),
1764 TREE_USED (UOBJC_SYMBOLS_decl
) = 1;
1765 DECL_IGNORED_P (UOBJC_SYMBOLS_decl
) = 1;
1766 DECL_ARTIFICIAL (UOBJC_SYMBOLS_decl
) = 1;
1767 finish_decl (UOBJC_SYMBOLS_decl
,
1768 init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl
)),
1773 init_module_descriptor (tree type
)
1775 tree initlist
, expr
;
1777 /* version = { 1, ... } */
1779 expr
= build_int_2 (OBJC_VERSION
, 0);
1780 initlist
= build_tree_list (NULL_TREE
, expr
);
1782 /* size = { ..., sizeof (struct objc_module), ... } */
1784 expr
= size_in_bytes (objc_module_template
);
1785 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
1787 /* name = { ..., "foo.m", ... } */
1789 expr
= add_objc_string (get_identifier (input_filename
), class_names
);
1790 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
1792 /* symtab = { ..., _OBJC_SYMBOLS, ... } */
1794 if (UOBJC_SYMBOLS_decl
)
1795 expr
= build_unary_op (ADDR_EXPR
, UOBJC_SYMBOLS_decl
, 0);
1797 expr
= build_int_2 (0, 0);
1798 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
1800 return objc_build_constructor (type
, nreverse (initlist
));
1803 /* Write out the data structures to describe Objective C classes defined.
1804 If appropriate, compile and output a setup function to initialize them.
1805 Return a symbol_ref to the function to call to initialize the Objective C
1806 data structures for this file (and perhaps for other files also).
1808 struct objc_module { ... } _OBJC_MODULE = { ... }; */
1811 build_module_descriptor (void)
1813 tree decl_specs
, field_decl
, field_decl_chain
;
1815 objc_module_template
1816 = start_struct (RECORD_TYPE
, get_identifier (UTAG_MODULE
));
1820 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_LONG
]);
1821 field_decl
= get_identifier ("version");
1822 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
1823 field_decl_chain
= field_decl
;
1827 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_LONG
]);
1828 field_decl
= get_identifier ("size");
1829 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
1830 chainon (field_decl_chain
, field_decl
);
1834 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]);
1835 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("name"));
1836 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
1837 chainon (field_decl_chain
, field_decl
);
1839 /* struct objc_symtab *symtab; */
1841 decl_specs
= get_identifier (UTAG_SYMTAB
);
1842 decl_specs
= build_tree_list (NULL_TREE
, xref_tag (RECORD_TYPE
, decl_specs
));
1843 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("symtab"));
1844 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
1845 chainon (field_decl_chain
, field_decl
);
1847 finish_struct (objc_module_template
, field_decl_chain
, NULL_TREE
);
1849 /* Create an instance of "objc_module". */
1851 decl_specs
= tree_cons (NULL_TREE
, objc_module_template
,
1852 build_tree_list (NULL_TREE
,
1853 ridpointers
[(int) RID_STATIC
]));
1855 UOBJC_MODULES_decl
= start_decl (get_identifier ("_OBJC_MODULES"),
1856 decl_specs
, 1, NULL_TREE
);
1858 DECL_ARTIFICIAL (UOBJC_MODULES_decl
) = 1;
1859 DECL_IGNORED_P (UOBJC_MODULES_decl
) = 1;
1860 DECL_CONTEXT (UOBJC_MODULES_decl
) = NULL_TREE
;
1862 finish_decl (UOBJC_MODULES_decl
,
1863 init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl
)),
1866 /* Mark the decl to avoid "defined but not used" warning. */
1867 DECL_IN_SYSTEM_HEADER (UOBJC_MODULES_decl
) = 1;
1869 /* Generate a constructor call for the module descriptor.
1870 This code was generated by reading the grammar rules
1871 of c-parse.in; Therefore, it may not be the most efficient
1872 way of generating the requisite code. */
1874 if (flag_next_runtime
)
1878 tree parms
, execclass_decl
, decelerator
, void_list_node_1
;
1879 tree init_function_name
, init_function_decl
, compound
;
1881 /* Declare void __objc_execClass (void *); */
1883 void_list_node_1
= build_tree_list (NULL_TREE
, void_type_node
);
1884 execclass_decl
= build_decl (FUNCTION_DECL
,
1885 get_identifier (TAG_EXECCLASS
),
1886 build_function_type (void_type_node
,
1887 tree_cons (NULL_TREE
, ptr_type_node
,
1890 DECL_EXTERNAL (execclass_decl
) = 1;
1891 DECL_ARTIFICIAL (execclass_decl
) = 1;
1892 TREE_PUBLIC (execclass_decl
) = 1;
1893 pushdecl (execclass_decl
);
1894 rest_of_decl_compilation (execclass_decl
, 0, 0, 0);
1895 assemble_external (execclass_decl
);
1897 /* void _GLOBAL_$I$<gnyf> () {objc_execClass (&L_OBJC_MODULES);} */
1899 init_function_name
= get_file_function_name ('I');
1900 start_function (void_list_node_1
,
1901 build_nt (CALL_EXPR
, init_function_name
,
1902 tree_cons (NULL_TREE
, NULL_TREE
,
1906 store_parm_decls ();
1907 compound
= c_begin_compound_stmt (true);
1909 init_function_decl
= current_function_decl
;
1910 TREE_PUBLIC (init_function_decl
) = ! targetm
.have_ctors_dtors
;
1911 TREE_USED (init_function_decl
) = 1;
1912 /* Don't let this one be deferred. */
1913 DECL_INLINE (init_function_decl
) = 0;
1914 DECL_UNINLINABLE (init_function_decl
) = 1;
1917 = build_tree_list (NULL_TREE
,
1918 build_unary_op (ADDR_EXPR
, UOBJC_MODULES_decl
, 0));
1919 decelerator
= build_function_call (execclass_decl
, parms
);
1921 add_stmt (decelerator
);
1922 add_stmt (c_end_compound_stmt (compound
, true));
1926 return XEXP (DECL_RTL (init_function_decl
), 0);
1930 /* Return the DECL of the string IDENT in the SECTION. */
1933 get_objc_string_decl (tree ident
, enum string_section section
)
1937 if (section
== class_names
)
1938 chain
= class_names_chain
;
1939 else if (section
== meth_var_names
)
1940 chain
= meth_var_names_chain
;
1941 else if (section
== meth_var_types
)
1942 chain
= meth_var_types_chain
;
1946 for (; chain
!= 0; chain
= TREE_CHAIN (chain
))
1947 if (TREE_VALUE (chain
) == ident
)
1948 return (TREE_PURPOSE (chain
));
1954 /* Output references to all statically allocated objects. Return the DECL
1955 for the array built. */
1958 generate_static_references (void)
1960 tree decls
= NULL_TREE
, ident
, decl_spec
, expr_decl
, expr
= NULL_TREE
;
1961 tree class_name
, class, decl
, initlist
;
1962 tree cl_chain
, in_chain
, type
;
1963 int num_inst
, num_class
;
1966 if (flag_next_runtime
)
1969 for (cl_chain
= objc_static_instances
, num_class
= 0;
1970 cl_chain
; cl_chain
= TREE_CHAIN (cl_chain
), num_class
++)
1972 for (num_inst
= 0, in_chain
= TREE_PURPOSE (cl_chain
);
1973 in_chain
; num_inst
++, in_chain
= TREE_CHAIN (in_chain
));
1975 sprintf (buf
, "_OBJC_STATIC_INSTANCES_%d", num_class
);
1976 ident
= get_identifier (buf
);
1978 expr_decl
= build_nt (ARRAY_REF
, ident
, NULL_TREE
);
1979 decl_spec
= tree_cons (NULL_TREE
, build_pointer_type (void_type_node
),
1980 build_tree_list (NULL_TREE
,
1981 ridpointers
[(int) RID_STATIC
]));
1982 decl
= start_decl (expr_decl
, decl_spec
, 1, NULL_TREE
);
1983 DECL_CONTEXT (decl
) = 0;
1984 DECL_ARTIFICIAL (decl
) = 1;
1986 /* Output {class_name, ...}. */
1987 class = TREE_VALUE (cl_chain
);
1988 class_name
= get_objc_string_decl (OBJC_TYPE_NAME (class), class_names
);
1989 initlist
= build_tree_list (NULL_TREE
,
1990 build_unary_op (ADDR_EXPR
, class_name
, 1));
1992 /* Output {..., instance, ...}. */
1993 for (in_chain
= TREE_PURPOSE (cl_chain
);
1994 in_chain
; in_chain
= TREE_CHAIN (in_chain
))
1996 expr
= build_unary_op (ADDR_EXPR
, TREE_VALUE (in_chain
), 1);
1997 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
2000 /* Output {..., NULL}. */
2001 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
2003 expr
= objc_build_constructor (TREE_TYPE (decl
), nreverse (initlist
));
2004 finish_decl (decl
, expr
, NULL_TREE
);
2005 TREE_USED (decl
) = 1;
2007 type
= build_array_type (build_pointer_type (void_type_node
), 0);
2008 decl
= build_decl (VAR_DECL
, ident
, type
);
2009 TREE_USED (decl
) = 1;
2010 TREE_STATIC (decl
) = 1;
2012 = tree_cons (NULL_TREE
, build_unary_op (ADDR_EXPR
, decl
, 1), decls
);
2015 decls
= tree_cons (NULL_TREE
, build_int_2 (0, 0), decls
);
2016 ident
= get_identifier ("_OBJC_STATIC_INSTANCES");
2017 expr_decl
= build_nt (ARRAY_REF
, ident
, NULL_TREE
);
2018 decl_spec
= tree_cons (NULL_TREE
, build_pointer_type (void_type_node
),
2019 build_tree_list (NULL_TREE
,
2020 ridpointers
[(int) RID_STATIC
]));
2021 static_instances_decl
2022 = start_decl (expr_decl
, decl_spec
, 1, NULL_TREE
);
2023 TREE_USED (static_instances_decl
) = 1;
2024 DECL_CONTEXT (static_instances_decl
) = 0;
2025 DECL_ARTIFICIAL (static_instances_decl
) = 1;
2026 expr
= objc_build_constructor (TREE_TYPE (static_instances_decl
),
2028 finish_decl (static_instances_decl
, expr
, NULL_TREE
);
2031 /* Output all strings. */
2034 generate_strings (void)
2036 tree sc_spec
, decl_specs
, expr_decl
;
2037 tree chain
, string_expr
;
2040 for (chain
= class_names_chain
; chain
; chain
= TREE_CHAIN (chain
))
2042 string
= TREE_VALUE (chain
);
2043 decl
= TREE_PURPOSE (chain
);
2045 = tree_cons (NULL_TREE
, ridpointers
[(int) RID_STATIC
], NULL_TREE
);
2046 decl_specs
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_CHAR
], sc_spec
);
2047 expr_decl
= build_nt (ARRAY_REF
, DECL_NAME (decl
), NULL_TREE
);
2048 decl
= start_decl (expr_decl
, decl_specs
, 1, NULL_TREE
);
2049 DECL_CONTEXT (decl
) = NULL_TREE
;
2050 string_expr
= my_build_string (IDENTIFIER_LENGTH (string
) + 1,
2051 IDENTIFIER_POINTER (string
));
2052 finish_decl (decl
, string_expr
, NULL_TREE
);
2055 for (chain
= meth_var_names_chain
; chain
; chain
= TREE_CHAIN (chain
))
2057 string
= TREE_VALUE (chain
);
2058 decl
= TREE_PURPOSE (chain
);
2060 = tree_cons (NULL_TREE
, ridpointers
[(int) RID_STATIC
], NULL_TREE
);
2061 decl_specs
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_CHAR
], sc_spec
);
2062 expr_decl
= build_nt (ARRAY_REF
, DECL_NAME (decl
), NULL_TREE
);
2063 decl
= start_decl (expr_decl
, decl_specs
, 1, NULL_TREE
);
2064 DECL_CONTEXT (decl
) = NULL_TREE
;
2065 string_expr
= my_build_string (IDENTIFIER_LENGTH (string
) + 1,
2066 IDENTIFIER_POINTER (string
));
2067 finish_decl (decl
, string_expr
, NULL_TREE
);
2070 for (chain
= meth_var_types_chain
; chain
; chain
= TREE_CHAIN (chain
))
2072 string
= TREE_VALUE (chain
);
2073 decl
= TREE_PURPOSE (chain
);
2075 = tree_cons (NULL_TREE
, ridpointers
[(int) RID_STATIC
], NULL_TREE
);
2076 decl_specs
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_CHAR
], sc_spec
);
2077 expr_decl
= build_nt (ARRAY_REF
, DECL_NAME (decl
), NULL_TREE
);
2078 decl
= start_decl (expr_decl
, decl_specs
, 1, NULL_TREE
);
2079 DECL_CONTEXT (decl
) = NULL_TREE
;
2080 string_expr
= my_build_string (IDENTIFIER_LENGTH (string
) + 1,
2081 IDENTIFIER_POINTER (string
));
2082 finish_decl (decl
, string_expr
, NULL_TREE
);
2086 static GTY(()) int selector_reference_idx
;
2089 build_selector_reference_decl (void)
2094 sprintf (buf
, "_OBJC_SELECTOR_REFERENCES_%d", selector_reference_idx
++);
2096 ident
= get_identifier (buf
);
2098 decl
= build_decl (VAR_DECL
, ident
, objc_selector_type
);
2099 DECL_EXTERNAL (decl
) = 1;
2100 TREE_PUBLIC (decl
) = 0;
2101 TREE_USED (decl
) = 1;
2102 DECL_ARTIFICIAL (decl
) = 1;
2103 DECL_CONTEXT (decl
) = 0;
2105 make_decl_rtl (decl
, 0);
2106 pushdecl_top_level (decl
);
2111 /* Just a handy wrapper for add_objc_string. */
2114 build_selector (tree ident
)
2116 tree expr
= add_objc_string (ident
, meth_var_names
);
2117 if (flag_typed_selectors
)
2120 return build_c_cast (objc_selector_type
, expr
); /* cast! */
2124 build_selector_translation_table (void)
2126 tree sc_spec
, decl_specs
;
2127 tree chain
, initlist
= NULL_TREE
;
2129 tree decl
= NULL_TREE
, var_decl
, name
;
2131 for (chain
= sel_ref_chain
; chain
; chain
= TREE_CHAIN (chain
))
2135 if (warn_selector
&& objc_implementation_context
)
2139 for (method_chain
= meth_var_names_chain
;
2141 method_chain
= TREE_CHAIN (method_chain
))
2143 if (TREE_VALUE (method_chain
) == TREE_VALUE (chain
))
2151 /* Adjust line number for warning message. */
2152 int save_lineno
= input_line
;
2153 if (flag_next_runtime
&& TREE_PURPOSE (chain
))
2154 input_line
= DECL_SOURCE_LINE (TREE_PURPOSE (chain
));
2155 warning ("creating selector for non existant method %s",
2156 IDENTIFIER_POINTER (TREE_VALUE (chain
)));
2157 input_line
= save_lineno
;
2161 expr
= build_selector (TREE_VALUE (chain
));
2163 if (flag_next_runtime
)
2165 name
= DECL_NAME (TREE_PURPOSE (chain
));
2167 sc_spec
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_STATIC
]);
2169 /* static SEL _OBJC_SELECTOR_REFERENCES_n = ...; */
2170 decl_specs
= tree_cons (NULL_TREE
, objc_selector_type
, sc_spec
);
2174 /* The `decl' that is returned from start_decl is the one that we
2175 forward declared in `build_selector_reference' */
2176 decl
= start_decl (var_decl
, decl_specs
, 1, NULL_TREE
);
2179 /* add one for the '\0' character */
2180 offset
+= IDENTIFIER_LENGTH (TREE_VALUE (chain
)) + 1;
2182 if (flag_next_runtime
)
2183 finish_decl (decl
, expr
, NULL_TREE
);
2186 if (flag_typed_selectors
)
2188 tree eltlist
= NULL_TREE
;
2189 tree encoding
= get_proto_encoding (TREE_PURPOSE (chain
));
2190 eltlist
= tree_cons (NULL_TREE
, expr
, NULL_TREE
);
2191 eltlist
= tree_cons (NULL_TREE
, encoding
, eltlist
);
2192 expr
= objc_build_constructor (objc_selector_template
,
2193 nreverse (eltlist
));
2195 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
2200 if (! flag_next_runtime
)
2202 /* Cause the variable and its initial value to be actually output. */
2203 DECL_EXTERNAL (UOBJC_SELECTOR_TABLE_decl
) = 0;
2204 TREE_STATIC (UOBJC_SELECTOR_TABLE_decl
) = 1;
2205 /* NULL terminate the list and fix the decl for output. */
2206 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
2207 DECL_INITIAL (UOBJC_SELECTOR_TABLE_decl
) = objc_ellipsis_node
;
2208 initlist
= objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl
),
2209 nreverse (initlist
));
2210 finish_decl (UOBJC_SELECTOR_TABLE_decl
, initlist
, NULL_TREE
);
2211 current_function_decl
= NULL_TREE
;
2216 get_proto_encoding (tree proto
)
2221 if (! METHOD_ENCODING (proto
))
2223 encoding
= encode_method_prototype (proto
);
2224 METHOD_ENCODING (proto
) = encoding
;
2227 encoding
= METHOD_ENCODING (proto
);
2229 return add_objc_string (encoding
, meth_var_types
);
2232 return build_int_2 (0, 0);
2235 /* sel_ref_chain is a list whose "value" fields will be instances of
2236 identifier_node that represent the selector. */
2239 build_typed_selector_reference (tree ident
, tree prototype
)
2241 tree
*chain
= &sel_ref_chain
;
2247 if (TREE_PURPOSE (*chain
) == prototype
&& TREE_VALUE (*chain
) == ident
)
2248 goto return_at_index
;
2251 chain
= &TREE_CHAIN (*chain
);
2254 *chain
= tree_cons (prototype
, ident
, NULL_TREE
);
2257 expr
= build_unary_op (ADDR_EXPR
,
2258 build_array_ref (UOBJC_SELECTOR_TABLE_decl
,
2259 build_int_2 (index
, 0)),
2261 return build_c_cast (objc_selector_type
, expr
);
2265 build_selector_reference (tree ident
)
2267 tree
*chain
= &sel_ref_chain
;
2273 if (TREE_VALUE (*chain
) == ident
)
2274 return (flag_next_runtime
2275 ? TREE_PURPOSE (*chain
)
2276 : build_array_ref (UOBJC_SELECTOR_TABLE_decl
,
2277 build_int_2 (index
, 0)));
2280 chain
= &TREE_CHAIN (*chain
);
2283 expr
= build_selector_reference_decl ();
2285 *chain
= tree_cons (expr
, ident
, NULL_TREE
);
2287 return (flag_next_runtime
2289 : build_array_ref (UOBJC_SELECTOR_TABLE_decl
,
2290 build_int_2 (index
, 0)));
2293 static GTY(()) int class_reference_idx
;
2296 build_class_reference_decl (void)
2301 sprintf (buf
, "_OBJC_CLASS_REFERENCES_%d", class_reference_idx
++);
2303 ident
= get_identifier (buf
);
2305 decl
= build_decl (VAR_DECL
, ident
, objc_class_type
);
2306 DECL_EXTERNAL (decl
) = 1;
2307 TREE_PUBLIC (decl
) = 0;
2308 TREE_USED (decl
) = 1;
2309 DECL_CONTEXT (decl
) = 0;
2310 DECL_ARTIFICIAL (decl
) = 1;
2312 make_decl_rtl (decl
, 0);
2313 pushdecl_top_level (decl
);
2318 /* Create a class reference, but don't create a variable to reference
2322 add_class_reference (tree ident
)
2326 if ((chain
= cls_ref_chain
))
2331 if (ident
== TREE_VALUE (chain
))
2335 chain
= TREE_CHAIN (chain
);
2339 /* Append to the end of the list */
2340 TREE_CHAIN (tail
) = tree_cons (NULL_TREE
, ident
, NULL_TREE
);
2343 cls_ref_chain
= tree_cons (NULL_TREE
, ident
, NULL_TREE
);
2346 /* Get a class reference, creating it if necessary. Also create the
2347 reference variable. */
2350 get_class_reference (tree ident
)
2355 if (processing_template_decl
)
2356 /* Must wait until template instantiation time. */
2357 return build_min_nt (CLASS_REFERENCE_EXPR
, ident
);
2358 if (TREE_CODE (ident
) == TYPE_DECL
)
2359 ident
= DECL_NAME (ident
);
2363 if (!(ident
= is_class_name (ident
)))
2365 error ("`%s' is not an Objective-C class name or alias",
2366 IDENTIFIER_POINTER (orig_ident
));
2367 return error_mark_node
;
2370 if (flag_next_runtime
&& !flag_zero_link
)
2375 for (chain
= &cls_ref_chain
; *chain
; chain
= &TREE_CHAIN (*chain
))
2376 if (TREE_VALUE (*chain
) == ident
)
2378 if (! TREE_PURPOSE (*chain
))
2379 TREE_PURPOSE (*chain
) = build_class_reference_decl ();
2381 return TREE_PURPOSE (*chain
);
2384 decl
= build_class_reference_decl ();
2385 *chain
= tree_cons (decl
, ident
, NULL_TREE
);
2392 add_class_reference (ident
);
2394 params
= build_tree_list (NULL_TREE
,
2395 my_build_string (IDENTIFIER_LENGTH (ident
) + 1,
2396 IDENTIFIER_POINTER (ident
)));
2398 assemble_external (objc_get_class_decl
);
2399 return build_function_call (objc_get_class_decl
, params
);
2403 /* For each string section we have a chain which maps identifier nodes
2404 to decls for the strings. */
2407 add_objc_string (tree ident
, enum string_section section
)
2411 if (section
== class_names
)
2412 chain
= &class_names_chain
;
2413 else if (section
== meth_var_names
)
2414 chain
= &meth_var_names_chain
;
2415 else if (section
== meth_var_types
)
2416 chain
= &meth_var_types_chain
;
2422 if (TREE_VALUE (*chain
) == ident
)
2423 return build_unary_op (ADDR_EXPR
, TREE_PURPOSE (*chain
), 1);
2425 chain
= &TREE_CHAIN (*chain
);
2428 decl
= build_objc_string_decl (section
);
2430 *chain
= tree_cons (decl
, ident
, NULL_TREE
);
2432 return build_unary_op (ADDR_EXPR
, decl
, 1);
2435 static GTY(()) int class_names_idx
;
2436 static GTY(()) int meth_var_names_idx
;
2437 static GTY(()) int meth_var_types_idx
;
2440 build_objc_string_decl (enum string_section section
)
2445 if (section
== class_names
)
2446 sprintf (buf
, "_OBJC_CLASS_NAME_%d", class_names_idx
++);
2447 else if (section
== meth_var_names
)
2448 sprintf (buf
, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx
++);
2449 else if (section
== meth_var_types
)
2450 sprintf (buf
, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx
++);
2452 ident
= get_identifier (buf
);
2454 decl
= build_decl (VAR_DECL
, ident
, build_array_type (char_type_node
, 0));
2455 DECL_EXTERNAL (decl
) = 1;
2456 TREE_PUBLIC (decl
) = 0;
2457 TREE_USED (decl
) = 1;
2458 TREE_CONSTANT (decl
) = 1;
2459 DECL_CONTEXT (decl
) = 0;
2460 DECL_ARTIFICIAL (decl
) = 1;
2462 make_decl_rtl (decl
, 0);
2463 pushdecl_top_level (decl
);
2470 objc_declare_alias (tree alias_ident
, tree class_ident
)
2472 tree underlying_class
;
2475 if (current_namespace
!= global_namespace
) {
2476 error ("Objective-C declarations may only appear in global scope");
2478 #endif /* OBJCPLUS */
2480 if (!(underlying_class
= is_class_name (class_ident
)))
2481 warning ("cannot find class `%s'", IDENTIFIER_POINTER (class_ident
));
2482 else if (is_class_name (alias_ident
))
2483 warning ("class `%s' already exists", IDENTIFIER_POINTER (alias_ident
));
2485 alias_chain
= tree_cons (underlying_class
, alias_ident
, alias_chain
);
2489 objc_declare_class (tree ident_list
)
2493 if (current_namespace
!= global_namespace
) {
2494 error ("Objective-C declarations may only appear in global scope");
2496 #endif /* OBJCPLUS */
2498 for (list
= ident_list
; list
; list
= TREE_CHAIN (list
))
2500 tree ident
= TREE_VALUE (list
);
2502 if (! is_class_name (ident
))
2504 tree record
= lookup_name (ident
);
2506 if (record
&& ! TREE_STATIC_TEMPLATE (record
))
2508 error ("`%s' redeclared as different kind of symbol",
2509 IDENTIFIER_POINTER (ident
));
2510 error ("%Jprevious declaration of '%D'",
2514 record
= xref_tag (RECORD_TYPE
, ident
);
2515 TREE_STATIC_TEMPLATE (record
) = 1;
2516 class_chain
= tree_cons (NULL_TREE
, ident
, class_chain
);
2522 is_class_name (tree ident
)
2526 if (ident
&& TREE_CODE (ident
) == IDENTIFIER_NODE
2527 && identifier_global_value (ident
))
2528 ident
= identifier_global_value (ident
);
2529 while (ident
&& TREE_CODE (ident
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (ident
))
2530 ident
= TYPE_NAME (DECL_ORIGINAL_TYPE (ident
));
2533 if (ident
&& TREE_CODE (ident
) == RECORD_TYPE
)
2534 ident
= TYPE_NAME (ident
);
2535 if (ident
&& TREE_CODE (ident
) == TYPE_DECL
)
2536 ident
= DECL_NAME (ident
);
2538 if (!ident
|| TREE_CODE (ident
) != IDENTIFIER_NODE
)
2541 if (lookup_interface (ident
))
2544 for (chain
= class_chain
; chain
; chain
= TREE_CHAIN (chain
))
2546 if (ident
== TREE_VALUE (chain
))
2550 for (chain
= alias_chain
; chain
; chain
= TREE_CHAIN (chain
))
2552 if (ident
== TREE_VALUE (chain
))
2553 return TREE_PURPOSE (chain
);
2559 /* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
2560 class instance. This is needed by other parts of the compiler to
2561 handle ObjC types gracefully. */
2564 objc_is_object_ptr (tree type
)
2566 type
= TYPE_MAIN_VARIANT (type
);
2567 if (!type
|| TREE_CODE (type
) != POINTER_TYPE
)
2569 /* NB: This function may be called before the ObjC front-end has
2570 been initialized, in which case OBJC_ID_TYPE will be NULL. */
2571 if (objc_id_type
&& type
&& TYPE_P (type
)
2573 || TREE_TYPE (type
) == TREE_TYPE (objc_class_type
)))
2575 return is_class_name (OBJC_TYPE_NAME (TREE_TYPE (type
)));
2579 lookup_interface (tree ident
)
2584 if (ident
&& TREE_CODE (ident
) == TYPE_DECL
)
2585 ident
= DECL_NAME (ident
);
2587 for (chain
= interface_chain
; chain
; chain
= TREE_CHAIN (chain
))
2589 if (ident
== CLASS_NAME (chain
))
2595 /* Implement @defs (<classname>) within struct bodies. */
2598 get_class_ivars_from_name (tree class_name
)
2600 tree interface
= lookup_interface (class_name
);
2601 tree field
, fields
= NULL_TREE
;
2605 tree raw_ivar
= get_class_ivars (interface
, 1);
2607 /* Regenerate the FIELD_DECLs for the enclosing struct. */
2608 for (; raw_ivar
; raw_ivar
= TREE_CHAIN (raw_ivar
))
2610 field
= grokfield (TREE_PURPOSE (TREE_VALUE (raw_ivar
)),
2611 TREE_PURPOSE (raw_ivar
),
2612 TREE_VALUE (TREE_VALUE (raw_ivar
)));
2614 finish_member_declaration (field
);
2616 fields
= chainon (fields
, field
);
2621 error ("cannot find interface declaration for `%s'",
2622 IDENTIFIER_POINTER (class_name
));
2627 /* Used by: build_private_template, continue_class,
2628 and for @defs constructs. */
2631 get_class_ivars (tree interface
, int raw
)
2633 tree my_name
, super_name
, ivar_chain
;
2635 my_name
= CLASS_NAME (interface
);
2636 super_name
= CLASS_SUPER_NAME (interface
);
2638 ivar_chain
= CLASS_RAW_IVARS (interface
);
2641 ivar_chain
= CLASS_IVARS (interface
);
2642 /* Save off a pristine copy of the leaf ivars (i.e, those not
2643 inherited from a super class). */
2644 if (!CLASS_OWN_IVARS (interface
))
2645 CLASS_OWN_IVARS (interface
) = copy_list (ivar_chain
);
2651 tree super_interface
= lookup_interface (super_name
);
2653 if (!super_interface
)
2655 /* fatal did not work with 2 args...should fix */
2656 error ("cannot find interface declaration for `%s', superclass of `%s'",
2657 IDENTIFIER_POINTER (super_name
),
2658 IDENTIFIER_POINTER (my_name
));
2659 exit (FATAL_EXIT_CODE
);
2662 if (super_interface
== interface
)
2663 fatal_error ("circular inheritance in interface declaration for `%s'",
2664 IDENTIFIER_POINTER (super_name
));
2666 interface
= super_interface
;
2667 my_name
= CLASS_NAME (interface
);
2668 super_name
= CLASS_SUPER_NAME (interface
);
2670 op1
= (raw
? CLASS_RAW_IVARS (interface
) : CLASS_OWN_IVARS (interface
));
2673 tree head
= copy_list (op1
);
2675 /* Prepend super class ivars...make a copy of the list, we
2676 do not want to alter the original. */
2677 chainon (head
, ivar_chain
);
2686 objc_create_temporary_var (tree type
)
2690 decl
= build_decl (VAR_DECL
, NULL_TREE
, type
);
2691 TREE_USED (decl
) = 1;
2692 DECL_ARTIFICIAL (decl
) = 1;
2693 DECL_IGNORED_P (decl
) = 1;
2694 DECL_CONTEXT (decl
) = current_function_decl
;
2699 /* Exception handling constructs. We begin by having the parser do most
2700 of the work and passing us blocks. What we do next depends on whether
2701 we're doing "native" exception handling or legacy Darwin setjmp exceptions.
2702 We abstract all of this in a handful of appropriately named routines. */
2704 /* Stack of open try blocks. */
2706 struct objc_try_context
2708 struct objc_try_context
*outer
;
2710 /* Statements (or statement lists) as processed by the parser. */
2714 /* Some file position locations. */
2715 location_t try_locus
;
2716 location_t end_try_locus
;
2717 location_t end_catch_locus
;
2718 location_t finally_locus
;
2719 location_t end_finally_locus
;
2721 /* A STATEMENT_LIST of CATCH_EXPRs, appropriate for sticking into op1
2722 of a TRY_CATCH_EXPR. Even when doing Darwin setjmp. */
2725 /* The CATCH_EXPR of an open @catch clause. */
2728 /* The VAR_DECL holding the Darwin equivalent of EXC_PTR_EXPR. */
2734 static struct objc_try_context
*cur_try_context
;
2736 /* This hook, called via lang_eh_runtime_type, generates a runtime object
2737 that represents TYPE. For Objective-C, this is just the class name. */
2738 /* ??? Isn't there a class object or some such? Is it easy to get? */
2741 objc_eh_runtime_type (tree type
)
2743 return add_objc_string (OBJC_TYPE_NAME (TREE_TYPE (type
)), class_names
);
2746 /* Initialize exception handling. */
2749 objc_init_exceptions (void)
2751 static bool done
= false;
2757 if (!flag_objc_exceptions
)
2758 warning ("use %<-fobjc-exceptions%> to enable Objective-C "
2759 "exception syntax");
2761 if (!flag_objc_sjlj_exceptions
)
2763 c_eh_initialized_p
= true;
2764 eh_personality_libfunc
2765 = init_one_libfunc (USING_SJLJ_EXCEPTIONS
2766 ? "__gnu_objc_personality_sj0"
2767 : "__gnu_objc_personality_v0");
2768 using_eh_for_cleanups ();
2769 lang_eh_runtime_type
= objc_eh_runtime_type
;
2773 /* Build an EXC_PTR_EXPR, or the moral equivalent. In the case of Darwin,
2774 we'll arrange for it to be initialized (and associated with a binding)
2778 objc_build_exc_ptr (void)
2780 if (flag_objc_sjlj_exceptions
)
2782 tree var
= cur_try_context
->caught_decl
;
2785 var
= objc_create_temporary_var (objc_id_type
);
2786 cur_try_context
->caught_decl
= var
;
2791 return build (EXC_PTR_EXPR
, objc_id_type
);
2794 /* Build "objc_exception_try_exit(&_stack)". */
2797 next_sjlj_build_try_exit (void)
2800 t
= build_fold_addr_expr (cur_try_context
->stack_decl
);
2801 t
= tree_cons (NULL
, t
, NULL
);
2802 t
= build_function_call (objc_exception_try_exit_decl
, t
);
2807 objc_exception_try_enter (&_stack);
2808 if (_setjmp(&_stack.buf))
2812 Return the COND_EXPR. Note that the THEN and ELSE fields are left
2813 empty, ready for the caller to fill them in. */
2816 next_sjlj_build_enter_and_setjmp (void)
2818 tree t
, enter
, sj
, cond
;
2820 t
= build_fold_addr_expr (cur_try_context
->stack_decl
);
2821 t
= tree_cons (NULL
, t
, NULL
);
2822 enter
= build_function_call (objc_exception_try_enter_decl
, t
);
2824 t
= build_component_ref (cur_try_context
->stack_decl
,
2825 get_identifier ("buf"));
2826 t
= build_fold_addr_expr (t
);
2827 t
= convert (ptr_type_node
, t
);
2828 t
= tree_cons (NULL
, t
, NULL
);
2829 sj
= build_function_call (objc_setjmp_decl
, t
);
2831 cond
= build (COMPOUND_EXPR
, TREE_TYPE (sj
), enter
, sj
);
2832 cond
= lang_hooks
.truthvalue_conversion (cond
);
2834 return build (COND_EXPR
, void_type_node
, cond
, NULL
, NULL
);
2838 DECL = objc_exception_extract(&_stack);
2842 next_sjlj_build_exc_extract (tree decl
)
2846 t
= build_fold_addr_expr (cur_try_context
->stack_decl
);
2847 t
= tree_cons (NULL
, t
, NULL
);
2848 t
= build_function_call (objc_exception_extract_decl
, t
);
2849 t
= convert (TREE_TYPE (decl
), t
);
2850 t
= build (MODIFY_EXPR
, void_type_node
, decl
, t
);
2856 if (objc_exception_match(obj_get_class(TYPE), _caught)
2863 objc_exception_try_exit(&_stack);
2865 from the sequence of CATCH_EXPRs in the current try context. */
2868 next_sjlj_build_catch_list (void)
2870 tree_stmt_iterator i
= tsi_start (cur_try_context
->catch_list
);
2872 tree
*last
= &catch_seq
;
2873 bool saw_id
= false;
2875 for (; !tsi_end_p (i
); tsi_next (&i
))
2877 tree stmt
= tsi_stmt (i
);
2878 tree type
= CATCH_TYPES (stmt
);
2879 tree body
= CATCH_BODY (stmt
);
2891 if (type
== error_mark_node
)
2892 cond
= error_mark_node
;
2895 args
= tree_cons (NULL
, cur_try_context
->caught_decl
, NULL
);
2896 t
= get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type
)));
2897 args
= tree_cons (NULL
, t
, args
);
2898 t
= build_function_call (objc_exception_match_decl
, args
);
2899 cond
= lang_hooks
.truthvalue_conversion (t
);
2901 t
= build (COND_EXPR
, void_type_node
, cond
, body
, NULL
);
2902 SET_EXPR_LOCUS (t
, EXPR_LOCUS (stmt
));
2905 last
= &COND_EXPR_ELSE (t
);
2911 t
= build (MODIFY_EXPR
, void_type_node
, cur_try_context
->rethrow_decl
,
2912 cur_try_context
->caught_decl
);
2913 annotate_with_locus (t
, cur_try_context
->end_catch_locus
);
2914 append_to_statement_list (t
, last
);
2916 t
= next_sjlj_build_try_exit ();
2917 annotate_with_locus (t
, cur_try_context
->end_catch_locus
);
2918 append_to_statement_list (t
, last
);
2924 /* Build a complete @try-@catch-@finally block for legacy Darwin setjmp
2925 exception handling. We aim to build:
2928 struct _objc_exception_data _stack;
2929 id volatile _rethrow = 0;
2932 objc_exception_try_enter (&_stack);
2933 if (_setjmp(&_stack.buf))
2935 id _caught = objc_exception_extract(&_stack);
2936 objc_exception_try_enter (&_stack);
2937 if (_setjmp(&_stack.buf))
2938 _rethrow = objc_exception_extract(&_stack);
2948 objc_exception_try_exit(&_stack);
2951 objc_exception_throw(_rethrow);
2955 If CATCH-LIST is empty, we can omit all of the block containing
2956 "_caught" except for the setting of _rethrow. Note the use of
2957 a real TRY_FINALLY_EXPR here, which is not involved in EH per-se,
2958 but handles goto and other exits from the block. */
2961 next_sjlj_build_try_catch_finally (void)
2963 tree rethrow_decl
, stack_decl
, t
;
2964 tree catch_seq
, try_fin
, bind
;
2966 /* Create the declarations involved. */
2967 t
= xref_tag (RECORD_TYPE
, get_identifier (UTAG_EXCDATA
));
2968 stack_decl
= objc_create_temporary_var (t
);
2969 cur_try_context
->stack_decl
= stack_decl
;
2971 rethrow_decl
= objc_create_temporary_var (objc_id_type
);
2972 cur_try_context
->rethrow_decl
= rethrow_decl
;
2973 TREE_THIS_VOLATILE (rethrow_decl
) = 1;
2974 TREE_CHAIN (rethrow_decl
) = stack_decl
;
2976 /* Build the outermost varible binding level. */
2977 bind
= build (BIND_EXPR
, void_type_node
, rethrow_decl
, NULL
, NULL
);
2978 annotate_with_locus (bind
, cur_try_context
->try_locus
);
2979 TREE_SIDE_EFFECTS (bind
) = 1;
2981 /* Initialize rethrow_decl. */
2982 t
= build (MODIFY_EXPR
, void_type_node
, rethrow_decl
,
2983 convert (objc_id_type
, null_pointer_node
));
2984 annotate_with_locus (t
, cur_try_context
->try_locus
);
2985 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
2987 /* Build the outermost TRY_FINALLY_EXPR. */
2988 try_fin
= build (TRY_FINALLY_EXPR
, void_type_node
, NULL
, NULL
);
2989 annotate_with_locus (try_fin
, cur_try_context
->try_locus
);
2990 TREE_SIDE_EFFECTS (try_fin
) = 1;
2991 append_to_statement_list (try_fin
, &BIND_EXPR_BODY (bind
));
2993 /* Create the complete catch sequence. */
2994 if (cur_try_context
->catch_list
)
2996 tree caught_decl
= objc_build_exc_ptr ();
2997 catch_seq
= build_stmt (BIND_EXPR
, caught_decl
, NULL
, NULL
);
2999 t
= next_sjlj_build_exc_extract (caught_decl
);
3000 append_to_statement_list (t
, &BIND_EXPR_BODY (catch_seq
));
3002 t
= next_sjlj_build_enter_and_setjmp ();
3003 COND_EXPR_THEN (t
) = next_sjlj_build_exc_extract (rethrow_decl
);
3004 COND_EXPR_ELSE (t
) = next_sjlj_build_catch_list ();
3005 append_to_statement_list (t
, &BIND_EXPR_BODY (catch_seq
));
3008 catch_seq
= next_sjlj_build_exc_extract (rethrow_decl
);
3009 annotate_with_locus (catch_seq
, cur_try_context
->end_try_locus
);
3011 /* Build the main register-and-try if statement. */
3012 t
= next_sjlj_build_enter_and_setjmp ();
3013 annotate_with_locus (t
, cur_try_context
->try_locus
);
3014 COND_EXPR_THEN (t
) = catch_seq
;
3015 COND_EXPR_ELSE (t
) = cur_try_context
->try_body
;
3016 TREE_OPERAND (try_fin
, 0) = t
;
3018 /* Build the complete FINALLY statement list. */
3019 t
= next_sjlj_build_try_exit ();
3020 t
= build_stmt (COND_EXPR
,
3021 lang_hooks
.truthvalue_conversion (rethrow_decl
),
3023 annotate_with_locus (t
, cur_try_context
->finally_locus
);
3024 append_to_statement_list (t
, &TREE_OPERAND (try_fin
, 1));
3026 append_to_statement_list (cur_try_context
->finally_body
,
3027 &TREE_OPERAND (try_fin
, 1));
3029 t
= tree_cons (NULL
, rethrow_decl
, NULL
);
3030 t
= build_function_call (objc_exception_throw_decl
, t
);
3031 t
= build_stmt (COND_EXPR
,
3032 lang_hooks
.truthvalue_conversion (rethrow_decl
),
3034 annotate_with_locus (t
, cur_try_context
->end_finally_locus
);
3035 append_to_statement_list (t
, &TREE_OPERAND (try_fin
, 1));
3040 /* Called just after parsing the @try and its associated BODY. We now
3041 must prepare for the tricky bits -- handling the catches and finally. */
3044 objc_begin_try_stmt (location_t try_locus
, tree body
)
3046 struct objc_try_context
*c
= xcalloc (1, sizeof (*c
));
3047 c
->outer
= cur_try_context
;
3049 c
->try_locus
= try_locus
;
3050 c
->end_try_locus
= input_location
;
3051 cur_try_context
= c
;
3053 objc_init_exceptions ();
3056 /* Called just after parsing "@catch (parm)". Open a binding level,
3057 enter PARM into the binding level, and initialize it. Leave the
3058 binding level open while the body of the compound statement is parsed. */
3061 objc_begin_catch_clause (tree parm
)
3063 tree compound
, decl
, type
, t
;
3065 /* Begin a new scope that the entire catch clause will live in. */
3066 compound
= c_begin_compound_stmt (1);
3068 /* Turn the raw declarator/declspecs into a decl in the current scope. */
3069 decl
= define_decl (TREE_VALUE (TREE_PURPOSE (parm
)),
3070 TREE_PURPOSE (TREE_PURPOSE (parm
)));
3072 /* Since a decl is required here by syntax, don't warn if its unused. */
3073 /* ??? As opposed to __attribute__((unused))? Anyway, this appears to
3074 be what the previous objc implementation did. */
3075 TREE_USED (decl
) = 1;
3077 /* Verify that the type of the catch is valid. It must be a pointer
3078 to an Objective-C class, or "id" (which is catch-all). */
3079 type
= TREE_TYPE (decl
);
3080 if (POINTER_TYPE_P (type
) && objc_is_object_id (TREE_TYPE (type
)))
3082 else if (!POINTER_TYPE_P (type
) || !TYPED_OBJECT (TREE_TYPE (type
)))
3084 error ("@catch parameter is not a known Objective-C class type");
3085 type
= error_mark_node
;
3087 else if (cur_try_context
->catch_list
)
3089 /* Examine previous @catch clauses and see if we've already
3090 caught the type in question. */
3091 tree_stmt_iterator i
= tsi_start (cur_try_context
->catch_list
);
3092 for (; !tsi_end_p (i
); tsi_next (&i
))
3094 tree stmt
= tsi_stmt (i
);
3095 t
= CATCH_TYPES (stmt
);
3096 if (t
== error_mark_node
)
3098 if (!t
|| objc_comptypes (TREE_TYPE (t
), TREE_TYPE (type
), 0) == 1)
3100 warning ("exception of type %<%T%> will be caught",
3102 warning ("%H by earlier handler for %<%T%>",
3103 EXPR_LOCUS (stmt
), TREE_TYPE (t
? t
: objc_id_type
));
3109 /* Record the data for the catch in the try context so that we can
3110 finalize it later. */
3111 t
= build_stmt (CATCH_EXPR
, type
, compound
);
3112 cur_try_context
->current_catch
= t
;
3114 /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */
3115 t
= objc_build_exc_ptr ();
3116 t
= convert (TREE_TYPE (decl
), t
);
3117 t
= build (MODIFY_EXPR
, void_type_node
, decl
, t
);
3121 /* Called just after parsing the closing brace of a @catch clause. Close
3122 the open binding level, and record a CATCH_EXPR for it. */
3125 objc_finish_catch_clause (void)
3127 tree c
= cur_try_context
->current_catch
;
3128 cur_try_context
->current_catch
= NULL
;
3129 cur_try_context
->end_catch_locus
= input_location
;
3131 CATCH_BODY (c
) = c_end_compound_stmt (CATCH_BODY (c
), 1);
3132 append_to_statement_list (c
, &cur_try_context
->catch_list
);
3135 /* Called after parsing a @finally clause and its associated BODY.
3136 Record the body for later placement. */
3139 objc_build_finally_clause (location_t finally_locus
, tree body
)
3141 cur_try_context
->finally_body
= body
;
3142 cur_try_context
->finally_locus
= finally_locus
;
3143 cur_try_context
->end_finally_locus
= input_location
;
3146 /* Called to finalize a @try construct. */
3149 objc_finish_try_stmt (void)
3151 struct objc_try_context
*c
= cur_try_context
;
3154 if (c
->catch_list
== NULL
&& c
->finally_body
== NULL
)
3155 error ("`@try' without `@catch' or `@finally'");
3157 /* If we're doing Darwin setjmp exceptions, build the big nasty. */
3158 if (flag_objc_sjlj_exceptions
)
3160 if (!cur_try_context
->finally_body
)
3162 cur_try_context
->finally_locus
= input_location
;
3163 cur_try_context
->end_finally_locus
= input_location
;
3165 stmt
= next_sjlj_build_try_catch_finally ();
3169 /* Otherwise, nest the CATCH inside a FINALLY. */
3173 stmt
= build_stmt (TRY_CATCH_EXPR
, stmt
, c
->catch_list
);
3174 annotate_with_locus (stmt
, cur_try_context
->try_locus
);
3176 if (c
->finally_body
)
3178 stmt
= build_stmt (TRY_FINALLY_EXPR
, stmt
, c
->finally_body
);
3179 annotate_with_locus (stmt
, cur_try_context
->try_locus
);
3184 cur_try_context
= c
->outer
;
3189 objc_build_throw_stmt (tree throw_expr
)
3193 if (throw_expr
== NULL
)
3195 /* If we're not inside a @catch block, there is no "current
3196 exception" to be rethrown. */
3197 if (cur_try_context
== NULL
3198 || cur_try_context
->current_catch
== NULL
)
3200 error ("%<@throw%> (rethrow) used outside of a @catch block");
3204 /* Otherwise the object is still sitting in the EXC_PTR_EXPR
3205 value that we get from the runtime. */
3206 throw_expr
= objc_build_exc_ptr ();
3209 /* A throw is just a call to the runtime throw function with the
3210 object as a parameter. */
3211 func_params
= tree_cons (NULL
, throw_expr
, NULL
);
3212 add_stmt (build_function_call (objc_exception_throw_decl
, func_params
));
3214 objc_init_exceptions ();
3218 objc_build_synchronized (location_t start_locus
, tree mutex
, tree body
)
3222 /* First lock the mutex. */
3223 mutex
= save_expr (mutex
);
3224 args
= tree_cons (NULL
, mutex
, NULL
);
3225 call
= build_function_call (objc_sync_enter_decl
, args
);
3226 annotate_with_locus (call
, start_locus
);
3229 /* Build the mutex unlock. */
3230 args
= tree_cons (NULL
, mutex
, NULL
);
3231 call
= build_function_call (objc_sync_exit_decl
, args
);
3232 annotate_with_locus (call
, input_location
);
3234 /* Put the that and the body in a TRY_FINALLY. */
3235 objc_begin_try_stmt (start_locus
, body
);
3236 objc_build_finally_clause (input_location
, call
);
3237 objc_finish_try_stmt ();
3241 /* Predefine the following data type:
3243 struct _objc_exception_data
3249 /* The following yuckiness should prevent users from having to #include
3250 <setjmp.h> in their code... */
3252 #ifdef TARGET_POWERPC
3253 /* snarfed from /usr/include/ppc/setjmp.h */
3254 #define _JBLEN (26 + 36 + 129 + 1)
3256 /* snarfed from /usr/include/i386/{setjmp,signal}.h */
3261 build_next_objc_exception_stuff (void)
3263 tree field_decl
, field_decl_chain
, index
, temp_type
;
3265 /* Suppress outputting debug symbols, because
3266 dbxout_init hasn't been called yet. */
3267 enum debug_info_type save_write_symbols
= write_symbols
;
3268 const struct gcc_debug_hooks
*save_hooks
= debug_hooks
;
3270 write_symbols
= NO_DEBUG
;
3271 debug_hooks
= &do_nothing_debug_hooks
;
3273 objc_exception_data_template
3274 = start_struct (RECORD_TYPE
, get_identifier (UTAG_EXCDATA
));
3276 /* int buf[_JBLEN]; */
3278 index
= build_index_type (build_int_2 (_JBLEN
- 1, 0));
3279 field_decl
= create_builtin_decl (FIELD_DECL
,
3280 build_array_type (integer_type_node
, index
),
3282 field_decl_chain
= field_decl
;
3284 /* void *pointers[4]; */
3286 index
= build_index_type (build_int_2 (4 - 1, 0));
3287 field_decl
= create_builtin_decl (FIELD_DECL
,
3288 build_array_type (ptr_type_node
, index
),
3290 chainon (field_decl_chain
, field_decl
);
3292 finish_struct (objc_exception_data_template
, field_decl_chain
, NULL_TREE
);
3294 /* int _setjmp(...); */
3295 /* If the user includes <setjmp.h>, this shall be superseded by
3296 'int _setjmp(jmp_buf);' */
3297 temp_type
= build_function_type (integer_type_node
, NULL_TREE
);
3299 = builtin_function (TAG_SETJMP
, temp_type
, 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
3301 /* id objc_exception_extract(struct _objc_exception_data *); */
3303 = build_function_type (objc_id_type
,
3304 tree_cons (NULL_TREE
,
3305 build_pointer_type (objc_exception_data_template
),
3307 objc_exception_extract_decl
3308 = builtin_function (TAG_EXCEPTIONEXTRACT
, temp_type
, 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
3309 /* void objc_exception_try_enter(struct _objc_exception_data *); */
3310 /* void objc_exception_try_exit(struct _objc_exception_data *); */
3312 = build_function_type (void_type_node
,
3313 tree_cons (NULL_TREE
,
3314 build_pointer_type (objc_exception_data_template
),
3316 objc_exception_try_enter_decl
3317 = builtin_function (TAG_EXCEPTIONTRYENTER
, temp_type
, 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
3318 objc_exception_try_exit_decl
3319 = builtin_function (TAG_EXCEPTIONTRYEXIT
, temp_type
, 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
3321 /* int objc_exception_match(id, id); */
3323 = build_function_type (integer_type_node
,
3324 tree_cons (NULL_TREE
, objc_id_type
,
3325 tree_cons (NULL_TREE
, objc_id_type
,
3327 objc_exception_match_decl
3328 = builtin_function (TAG_EXCEPTIONMATCH
, temp_type
, 0, NOT_BUILT_IN
, NULL
, NULL_TREE
);
3330 write_symbols
= save_write_symbols
;
3331 debug_hooks
= save_hooks
;
3335 build_objc_exception_stuff (void)
3337 tree noreturn_list
, nothrow_list
, temp_type
;
3339 noreturn_list
= tree_cons (get_identifier ("noreturn"), NULL
, NULL
);
3340 nothrow_list
= tree_cons (get_identifier ("nothrow"), NULL
, NULL
);
3342 /* void objc_exception_throw(id) __attribute__((noreturn)); */
3343 /* void objc_sync_enter(id); */
3344 /* void objc_sync_exit(id); */
3345 temp_type
= build_function_type (void_type_node
,
3346 tree_cons (NULL_TREE
, objc_id_type
,
3348 objc_exception_throw_decl
3349 = builtin_function (TAG_EXCEPTIONTHROW
, temp_type
, 0, NOT_BUILT_IN
, NULL
,
3351 objc_sync_enter_decl
3352 = builtin_function (TAG_SYNCENTER
, temp_type
, 0, NOT_BUILT_IN
,
3353 NULL
, nothrow_list
);
3355 = builtin_function (TAG_SYNCEXIT
, temp_type
, 0, NOT_BUILT_IN
,
3356 NULL
, nothrow_list
);
3360 /* struct <classname> {
3361 struct objc_class *isa;
3366 build_private_template (tree
class)
3370 if (CLASS_STATIC_TEMPLATE (class))
3372 uprivate_record
= CLASS_STATIC_TEMPLATE (class);
3373 ivar_context
= TYPE_FIELDS (CLASS_STATIC_TEMPLATE (class));
3377 uprivate_record
= start_struct (RECORD_TYPE
, CLASS_NAME (class));
3378 ivar_context
= get_class_ivars (class, 0);
3380 finish_struct (uprivate_record
, ivar_context
, NULL_TREE
);
3382 CLASS_STATIC_TEMPLATE (class) = uprivate_record
;
3384 /* mark this record as class template - for class type checking */
3385 TREE_STATIC_TEMPLATE (uprivate_record
) = 1;
3389 = groktypename (build_tree_list (build_tree_list (NULL_TREE
,
3391 build1 (INDIRECT_REF
, NULL_TREE
,
3394 return ivar_context
;
3397 /* Begin code generation for protocols... */
3399 /* struct objc_protocol {
3400 char *protocol_name;
3401 struct objc_protocol **protocol_list;
3402 struct objc_method_desc *instance_methods;
3403 struct objc_method_desc *class_methods;
3407 build_protocol_template (void)
3409 tree decl_specs
, field_decl
, field_decl_chain
;
3412 template = start_struct (RECORD_TYPE
, get_identifier (UTAG_PROTOCOL
));
3414 /* struct objc_class *isa; */
3416 decl_specs
= build_tree_list (NULL_TREE
, xref_tag (RECORD_TYPE
,
3417 get_identifier (UTAG_CLASS
)));
3418 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("isa"));
3419 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3420 field_decl_chain
= field_decl
;
3422 /* char *protocol_name; */
3424 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]);
3426 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("protocol_name"));
3427 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3428 chainon (field_decl_chain
, field_decl
);
3430 /* struct objc_protocol **protocol_list; */
3432 decl_specs
= build_tree_list (NULL_TREE
, template);
3434 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("protocol_list"));
3435 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, field_decl
);
3436 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3437 chainon (field_decl_chain
, field_decl
);
3439 /* struct objc_method_list *instance_methods; */
3442 = build_tree_list (NULL_TREE
,
3443 xref_tag (RECORD_TYPE
,
3444 get_identifier (UTAG_METHOD_PROTOTYPE_LIST
)));
3446 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("instance_methods"));
3447 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3448 chainon (field_decl_chain
, field_decl
);
3450 /* struct objc_method_list *class_methods; */
3453 = build_tree_list (NULL_TREE
,
3454 xref_tag (RECORD_TYPE
,
3455 get_identifier (UTAG_METHOD_PROTOTYPE_LIST
)));
3457 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("class_methods"));
3458 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3459 chainon (field_decl_chain
, field_decl
);
3461 return finish_struct (template, field_decl_chain
, NULL_TREE
);
3465 build_descriptor_table_initializer (tree type
, tree entries
)
3467 tree initlist
= NULL_TREE
;
3471 tree eltlist
= NULL_TREE
;
3474 = tree_cons (NULL_TREE
,
3475 build_selector (METHOD_SEL_NAME (entries
)), NULL_TREE
);
3477 = tree_cons (NULL_TREE
,
3478 add_objc_string (METHOD_ENCODING (entries
),
3483 = tree_cons (NULL_TREE
,
3484 objc_build_constructor (type
, nreverse (eltlist
)),
3487 entries
= TREE_CHAIN (entries
);
3491 return objc_build_constructor (build_array_type (type
, 0),
3492 nreverse (initlist
));
3495 /* struct objc_method_prototype_list {
3497 struct objc_method_prototype {
3504 build_method_prototype_list_template (tree list_type
, int size
)
3506 tree objc_ivar_list_record
;
3507 tree decl_specs
, field_decl
, field_decl_chain
;
3509 /* Generate an unnamed struct definition. */
3511 objc_ivar_list_record
= start_struct (RECORD_TYPE
, NULL_TREE
);
3513 /* int method_count; */
3515 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_INT
]);
3516 field_decl
= get_identifier ("method_count");
3517 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3518 field_decl_chain
= field_decl
;
3520 /* struct objc_method method_list[]; */
3522 decl_specs
= build_tree_list (NULL_TREE
, list_type
);
3523 field_decl
= build_nt (ARRAY_REF
, get_identifier ("method_list"),
3524 build_int_2 (size
, 0));
3525 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3526 chainon (field_decl_chain
, field_decl
);
3528 finish_struct (objc_ivar_list_record
, field_decl_chain
, NULL_TREE
);
3530 return objc_ivar_list_record
;
3534 build_method_prototype_template (void)
3537 tree decl_specs
, field_decl
, field_decl_chain
;
3540 = start_struct (RECORD_TYPE
, get_identifier (UTAG_METHOD_PROTOTYPE
));
3542 /* struct objc_selector *_cmd; */
3543 decl_specs
= tree_cons (NULL_TREE
, xref_tag (RECORD_TYPE
,
3544 get_identifier (TAG_SELECTOR
)), NULL_TREE
);
3545 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("_cmd"));
3546 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3547 field_decl_chain
= field_decl
;
3549 decl_specs
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_CHAR
], NULL_TREE
);
3551 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("method_types"));
3552 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3553 chainon (field_decl_chain
, field_decl
);
3555 finish_struct (proto_record
, field_decl_chain
, NULL_TREE
);
3557 return proto_record
;
3561 objc_method_parm_type (tree type
)
3563 type
= groktypename (TREE_TYPE (type
));
3564 if (TREE_CODE (type
) == TYPE_DECL
)
3565 type
= TREE_TYPE (type
);
3566 return TYPE_MAIN_VARIANT (type
);
3570 objc_encoded_type_size (tree type
)
3572 int sz
= int_size_in_bytes (type
);
3574 /* Make all integer and enum types at least as large
3576 if (sz
> 0 && (TREE_CODE (type
) == INTEGER_TYPE
3577 || TREE_CODE (type
) == BOOLEAN_TYPE
3578 || TREE_CODE (type
) == ENUMERAL_TYPE
))
3579 sz
= MAX (sz
, int_size_in_bytes (integer_type_node
));
3580 /* Treat arrays as pointers, since that's how they're
3582 else if (TREE_CODE (type
) == ARRAY_TYPE
)
3583 sz
= int_size_in_bytes (ptr_type_node
);
3588 encode_method_prototype (tree method_decl
)
3595 /* ONEWAY and BYCOPY, for remote object are the only method qualifiers. */
3596 encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_decl
)));
3598 /* Encode return type. */
3599 encode_type (objc_method_parm_type (method_decl
),
3600 obstack_object_size (&util_obstack
),
3601 OBJC_ENCODE_INLINE_DEFS
);
3604 /* The first two arguments (self and _cmd) are pointers; account for
3606 i
= int_size_in_bytes (ptr_type_node
);
3607 parm_offset
= 2 * i
;
3608 for (parms
= METHOD_SEL_ARGS (method_decl
); parms
;
3609 parms
= TREE_CHAIN (parms
))
3611 tree type
= objc_method_parm_type (parms
);
3612 int sz
= objc_encoded_type_size (type
);
3614 /* If a type size is not known, bail out. */
3617 error ("%Jtype '%D' does not have a known size",
3619 /* Pretend that the encoding succeeded; the compilation will
3620 fail nevertheless. */
3621 goto finish_encoding
;
3626 sprintf (buf
, "%d@0:%d", parm_offset
, i
);
3627 obstack_grow (&util_obstack
, buf
, strlen (buf
));
3629 /* Argument types. */
3630 parm_offset
= 2 * i
;
3631 for (parms
= METHOD_SEL_ARGS (method_decl
); parms
;
3632 parms
= TREE_CHAIN (parms
))
3634 tree type
= objc_method_parm_type (parms
);
3636 /* Process argument qualifiers for user supplied arguments. */
3637 encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (parms
)));
3640 encode_type (type
, obstack_object_size (&util_obstack
),
3641 OBJC_ENCODE_INLINE_DEFS
);
3643 /* Compute offset. */
3644 sprintf (buf
, "%d", parm_offset
);
3645 parm_offset
+= objc_encoded_type_size (type
);
3647 obstack_grow (&util_obstack
, buf
, strlen (buf
));
3651 obstack_1grow (&util_obstack
, '\0');
3652 result
= get_identifier (obstack_finish (&util_obstack
));
3653 obstack_free (&util_obstack
, util_firstobj
);
3658 generate_descriptor_table (tree type
, const char *name
, int size
, tree list
,
3661 tree sc_spec
, decl_specs
, decl
, initlist
;
3663 sc_spec
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_STATIC
], NULL_TREE
);
3664 decl_specs
= tree_cons (NULL_TREE
, type
, sc_spec
);
3666 decl
= start_decl (synth_id_with_class_suffix (name
, proto
),
3667 decl_specs
, 1, NULL_TREE
);
3668 DECL_CONTEXT (decl
) = NULL_TREE
;
3670 initlist
= build_tree_list (NULL_TREE
, build_int_2 (size
, 0));
3671 initlist
= tree_cons (NULL_TREE
, list
, initlist
);
3673 finish_decl (decl
, objc_build_constructor (type
, nreverse (initlist
)),
3680 generate_method_descriptors (tree protocol
)
3682 tree initlist
, chain
, method_list_template
;
3683 tree cast
, variable_length_type
;
3686 if (!objc_method_prototype_template
)
3687 objc_method_prototype_template
= build_method_prototype_template ();
3689 cast
= build_tree_list (build_tree_list (NULL_TREE
, xref_tag (RECORD_TYPE
,
3690 get_identifier (UTAG_METHOD_PROTOTYPE_LIST
))),
3692 variable_length_type
= groktypename (cast
);
3694 chain
= PROTOCOL_CLS_METHODS (protocol
);
3697 size
= list_length (chain
);
3699 method_list_template
3700 = build_method_prototype_list_template (objc_method_prototype_template
,
3704 = build_descriptor_table_initializer (objc_method_prototype_template
,
3707 UOBJC_CLASS_METHODS_decl
3708 = generate_descriptor_table (method_list_template
,
3709 "_OBJC_PROTOCOL_CLASS_METHODS",
3710 size
, initlist
, protocol
);
3711 TREE_TYPE (UOBJC_CLASS_METHODS_decl
) = variable_length_type
;
3714 UOBJC_CLASS_METHODS_decl
= 0;
3716 chain
= PROTOCOL_NST_METHODS (protocol
);
3719 size
= list_length (chain
);
3721 method_list_template
3722 = build_method_prototype_list_template (objc_method_prototype_template
,
3725 = build_descriptor_table_initializer (objc_method_prototype_template
,
3728 UOBJC_INSTANCE_METHODS_decl
3729 = generate_descriptor_table (method_list_template
,
3730 "_OBJC_PROTOCOL_INSTANCE_METHODS",
3731 size
, initlist
, protocol
);
3732 TREE_TYPE (UOBJC_INSTANCE_METHODS_decl
) = variable_length_type
;
3735 UOBJC_INSTANCE_METHODS_decl
= 0;
3739 generate_protocol_references (tree plist
)
3743 /* Forward declare protocols referenced. */
3744 for (lproto
= plist
; lproto
; lproto
= TREE_CHAIN (lproto
))
3746 tree proto
= TREE_VALUE (lproto
);
3748 if (TREE_CODE (proto
) == PROTOCOL_INTERFACE_TYPE
3749 && PROTOCOL_NAME (proto
))
3751 if (! PROTOCOL_FORWARD_DECL (proto
))
3752 build_protocol_reference (proto
);
3754 if (PROTOCOL_LIST (proto
))
3755 generate_protocol_references (PROTOCOL_LIST (proto
));
3760 /* For each protocol which was referenced either from a @protocol()
3761 expression, or because a class/category implements it (then a
3762 pointer to the protocol is stored in the struct describing the
3763 class/category), we create a statically allocated instance of the
3764 Protocol class. The code is written in such a way as to generate
3765 as few Protocol objects as possible; we generate a unique Protocol
3766 instance for each protocol, and we don't generate a Protocol
3767 instance if the protocol is never referenced (either from a
3768 @protocol() or from a class/category implementation). These
3769 statically allocated objects can be referred to via the static
3770 (that is, private to this module) symbols _OBJC_PROTOCOL_n.
3772 The statically allocated Protocol objects that we generate here
3773 need to be fixed up at runtime in order to be used: the 'isa'
3774 pointer of the objects need to be set up to point to the 'Protocol'
3775 class, as known at runtime.
3777 The NeXT runtime fixes up all protocols at program startup time,
3778 before main() is entered. It uses a low-level trick to look up all
3779 those symbols, then loops on them and fixes them up.
3781 The GNU runtime as well fixes up all protocols before user code
3782 from the module is executed; it requires pointers to those symbols
3783 to be put in the objc_symtab (which is then passed as argument to
3784 the function __objc_exec_class() which the compiler sets up to be
3785 executed automatically when the module is loaded); setup of those
3786 Protocol objects happen in two ways in the GNU runtime: all
3787 Protocol objects referred to by a class or category implementation
3788 are fixed up when the class/category is loaded; all Protocol
3789 objects referred to by a @protocol() expression are added by the
3790 compiler to the list of statically allocated instances to fixup
3791 (the same list holding the statically allocated constant string
3792 objects). Because, as explained above, the compiler generates as
3793 few Protocol objects as possible, some Protocol object might end up
3794 being referenced multiple times when compiled with the GNU runtime,
3795 and end up being fixed up multiple times at runtime inizialization.
3796 But that doesn't hurt, it's just a little inefficient. */
3799 generate_protocols (void)
3802 tree sc_spec
, decl_specs
, decl
;
3803 tree initlist
, protocol_name_expr
, refs_decl
, refs_expr
;
3806 if (! objc_protocol_template
)
3807 objc_protocol_template
= build_protocol_template ();
3809 /* If a protocol was directly referenced, pull in indirect references. */
3810 for (p
= protocol_chain
; p
; p
= TREE_CHAIN (p
))
3811 if (PROTOCOL_FORWARD_DECL (p
) && PROTOCOL_LIST (p
))
3812 generate_protocol_references (PROTOCOL_LIST (p
));
3814 for (p
= protocol_chain
; p
; p
= TREE_CHAIN (p
))
3816 tree nst_methods
= PROTOCOL_NST_METHODS (p
);
3817 tree cls_methods
= PROTOCOL_CLS_METHODS (p
);
3819 /* If protocol wasn't referenced, don't generate any code. */
3820 if (! PROTOCOL_FORWARD_DECL (p
))
3823 /* Make sure we link in the Protocol class. */
3824 add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME
));
3828 if (! METHOD_ENCODING (nst_methods
))
3830 encoding
= encode_method_prototype (nst_methods
);
3831 METHOD_ENCODING (nst_methods
) = encoding
;
3833 nst_methods
= TREE_CHAIN (nst_methods
);
3838 if (! METHOD_ENCODING (cls_methods
))
3840 encoding
= encode_method_prototype (cls_methods
);
3841 METHOD_ENCODING (cls_methods
) = encoding
;
3844 cls_methods
= TREE_CHAIN (cls_methods
);
3846 generate_method_descriptors (p
);
3848 if (PROTOCOL_LIST (p
))
3849 refs_decl
= generate_protocol_list (p
);
3853 /* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
3855 sc_spec
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_STATIC
],
3857 decl_specs
= tree_cons (NULL_TREE
, objc_protocol_template
, sc_spec
);
3859 decl
= start_decl (synth_id_with_class_suffix ("_OBJC_PROTOCOL", p
),
3860 decl_specs
, 1, NULL_TREE
);
3862 DECL_CONTEXT (decl
) = NULL_TREE
;
3864 protocol_name_expr
= add_objc_string (PROTOCOL_NAME (p
), class_names
);
3870 (build_tree_list (build_tree_list (NULL_TREE
,
3871 objc_protocol_template
),
3872 build1 (INDIRECT_REF
, NULL_TREE
,
3873 build1 (INDIRECT_REF
, NULL_TREE
,
3876 refs_expr
= build_unary_op (ADDR_EXPR
, refs_decl
, 0);
3877 TREE_TYPE (refs_expr
) = cast_type2
;
3880 refs_expr
= build_int_2 (0, 0);
3882 /* UOBJC_INSTANCE_METHODS_decl/UOBJC_CLASS_METHODS_decl are set
3883 by generate_method_descriptors, which is called above. */
3884 initlist
= build_protocol_initializer (TREE_TYPE (decl
),
3885 protocol_name_expr
, refs_expr
,
3886 UOBJC_INSTANCE_METHODS_decl
,
3887 UOBJC_CLASS_METHODS_decl
);
3888 finish_decl (decl
, initlist
, NULL_TREE
);
3890 /* Mark the decl as used to avoid "defined but not used" warning. */
3891 TREE_USED (decl
) = 1;
3896 build_protocol_initializer (tree type
, tree protocol_name
,
3897 tree protocol_list
, tree instance_methods
,
3900 tree initlist
= NULL_TREE
, expr
;
3903 cast_type
= groktypename
3905 (build_tree_list (NULL_TREE
,
3906 xref_tag (RECORD_TYPE
,
3907 get_identifier (UTAG_CLASS
))),
3908 build1 (INDIRECT_REF
, NULL_TREE
, NULL_TREE
)));
3910 /* Filling the "isa" in with one allows the runtime system to
3911 detect that the version change...should remove before final release. */
3913 expr
= build_int_2 (PROTOCOL_VERSION
, 0);
3914 TREE_TYPE (expr
) = cast_type
;
3915 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
3916 initlist
= tree_cons (NULL_TREE
, protocol_name
, initlist
);
3917 initlist
= tree_cons (NULL_TREE
, protocol_list
, initlist
);
3919 if (!instance_methods
)
3920 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
3923 expr
= build_unary_op (ADDR_EXPR
, instance_methods
, 0);
3924 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
3928 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
3931 expr
= build_unary_op (ADDR_EXPR
, class_methods
, 0);
3932 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
3935 return objc_build_constructor (type
, nreverse (initlist
));
3938 /* struct objc_category {
3939 char *category_name;
3941 struct objc_method_list *instance_methods;
3942 struct objc_method_list *class_methods;
3943 struct objc_protocol_list *protocols;
3947 build_category_template (void)
3949 tree decl_specs
, field_decl
, field_decl_chain
;
3951 objc_category_template
= start_struct (RECORD_TYPE
,
3952 get_identifier (UTAG_CATEGORY
));
3953 /* char *category_name; */
3955 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]);
3957 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("category_name"));
3958 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3959 field_decl_chain
= field_decl
;
3961 /* char *class_name; */
3963 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]);
3964 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("class_name"));
3965 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3966 chainon (field_decl_chain
, field_decl
);
3968 /* struct objc_method_list *instance_methods; */
3970 decl_specs
= build_tree_list (NULL_TREE
,
3971 xref_tag (RECORD_TYPE
,
3972 get_identifier (UTAG_METHOD_LIST
)));
3974 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("instance_methods"));
3975 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3976 chainon (field_decl_chain
, field_decl
);
3978 /* struct objc_method_list *class_methods; */
3980 decl_specs
= build_tree_list (NULL_TREE
,
3981 xref_tag (RECORD_TYPE
,
3982 get_identifier (UTAG_METHOD_LIST
)));
3984 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("class_methods"));
3985 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3986 chainon (field_decl_chain
, field_decl
);
3988 /* struct objc_protocol **protocol_list; */
3990 decl_specs
= build_tree_list (NULL_TREE
,
3991 xref_tag (RECORD_TYPE
,
3992 get_identifier (UTAG_PROTOCOL
)));
3994 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("protocol_list"));
3995 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, field_decl
);
3996 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
3997 chainon (field_decl_chain
, field_decl
);
3999 finish_struct (objc_category_template
, field_decl_chain
, NULL_TREE
);
4002 /* struct objc_selector {
4008 build_selector_template (void)
4011 tree decl_specs
, field_decl
, field_decl_chain
;
4013 objc_selector_template
4014 = start_struct (RECORD_TYPE
, get_identifier (UTAG_SELECTOR
));
4018 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VOID
]);
4019 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("sel_id"));
4020 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4021 field_decl_chain
= field_decl
;
4023 /* char *sel_type; */
4025 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]);
4026 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("sel_type"));
4027 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4028 chainon (field_decl_chain
, field_decl
);
4030 finish_struct (objc_selector_template
, field_decl_chain
, NULL_TREE
);
4033 /* struct objc_class {
4034 struct objc_class *isa;
4035 struct objc_class *super_class;
4040 struct objc_ivar_list *ivars;
4041 struct objc_method_list *methods;
4042 if (flag_next_runtime)
4043 struct objc_cache *cache;
4045 struct sarray *dtable;
4046 struct objc_class *subclass_list;
4047 struct objc_class *sibling_class;
4049 struct objc_protocol_list *protocols;
4050 if (flag_next_runtime)
4052 void *gc_object_type;
4055 /* NB: The 'sel_id' and 'gc_object_type' fields are not being used by
4056 the NeXT/Apple runtime; still, the compiler must generate them to
4057 maintain backward binary compatibility (and to allow for future
4061 build_class_template (void)
4063 tree decl_specs
, field_decl
, field_decl_chain
;
4066 = start_struct (RECORD_TYPE
, get_identifier (UTAG_CLASS
));
4068 /* struct objc_class *isa; */
4070 decl_specs
= build_tree_list (NULL_TREE
, objc_class_template
);
4071 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("isa"));
4072 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4073 field_decl_chain
= field_decl
;
4075 /* struct objc_class *super_class; */
4077 decl_specs
= build_tree_list (NULL_TREE
, objc_class_template
);
4079 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("super_class"));
4080 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4081 chainon (field_decl_chain
, field_decl
);
4085 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]);
4086 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("name"));
4087 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4088 chainon (field_decl_chain
, field_decl
);
4092 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_LONG
]);
4093 field_decl
= get_identifier ("version");
4094 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4095 chainon (field_decl_chain
, field_decl
);
4099 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_LONG
]);
4100 field_decl
= get_identifier ("info");
4101 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4102 chainon (field_decl_chain
, field_decl
);
4104 /* long instance_size; */
4106 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_LONG
]);
4107 field_decl
= get_identifier ("instance_size");
4108 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4109 chainon (field_decl_chain
, field_decl
);
4111 /* struct objc_ivar_list *ivars; */
4113 decl_specs
= build_tree_list (NULL_TREE
,
4114 xref_tag (RECORD_TYPE
,
4115 get_identifier (UTAG_IVAR_LIST
)));
4116 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("ivars"));
4117 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4118 chainon (field_decl_chain
, field_decl
);
4120 /* struct objc_method_list *methods; */
4122 decl_specs
= build_tree_list (NULL_TREE
,
4123 xref_tag (RECORD_TYPE
,
4124 get_identifier (UTAG_METHOD_LIST
)));
4125 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("methods"));
4126 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4127 chainon (field_decl_chain
, field_decl
);
4129 if (flag_next_runtime
)
4131 /* struct objc_cache *cache; */
4133 decl_specs
= build_tree_list (NULL_TREE
,
4134 xref_tag (RECORD_TYPE
,
4135 get_identifier ("objc_cache")));
4136 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("cache"));
4137 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4138 chainon (field_decl_chain
, field_decl
);
4142 /* struct sarray *dtable; */
4144 decl_specs
= build_tree_list (NULL_TREE
,
4145 xref_tag (RECORD_TYPE
,
4146 get_identifier ("sarray")));
4147 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("dtable"));
4148 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4149 chainon (field_decl_chain
, field_decl
);
4151 /* struct objc_class *subclass_list; */
4153 decl_specs
= build_tree_list (NULL_TREE
, objc_class_template
);
4155 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("subclass_list"));
4156 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4157 chainon (field_decl_chain
, field_decl
);
4159 /* struct objc_class *sibling_class; */
4161 decl_specs
= build_tree_list (NULL_TREE
, objc_class_template
);
4163 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("sibling_class"));
4164 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4165 chainon (field_decl_chain
, field_decl
);
4168 /* struct objc_protocol **protocol_list; */
4170 decl_specs
= build_tree_list (NULL_TREE
,
4171 xref_tag (RECORD_TYPE
,
4172 get_identifier (UTAG_PROTOCOL
)));
4174 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("protocol_list"));
4176 = build1 (INDIRECT_REF
, NULL_TREE
, field_decl
);
4177 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4178 chainon (field_decl_chain
, field_decl
);
4180 if (flag_next_runtime
)
4184 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VOID
]);
4185 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("sel_id"));
4187 = grokfield (field_decl
, decl_specs
, NULL_TREE
);
4188 chainon (field_decl_chain
, field_decl
);
4191 /* void *gc_object_type; */
4193 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_VOID
]);
4194 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("gc_object_type"));
4195 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4196 chainon (field_decl_chain
, field_decl
);
4198 finish_struct (objc_class_template
, field_decl_chain
, NULL_TREE
);
4201 /* Generate appropriate forward declarations for an implementation. */
4204 synth_forward_declarations (void)
4208 /* static struct objc_class _OBJC_CLASS_<my_name>; */
4209 UOBJC_CLASS_decl
= build_metadata_decl ("_OBJC_CLASS",
4210 objc_class_template
);
4212 /* static struct objc_class _OBJC_METACLASS_<my_name>; */
4213 UOBJC_METACLASS_decl
= build_metadata_decl ("_OBJC_METACLASS",
4214 objc_class_template
);
4216 /* Pre-build the following entities - for speed/convenience. */
4218 an_id
= get_identifier ("super_class");
4219 ucls_super_ref
= build_component_ref (UOBJC_CLASS_decl
, an_id
);
4220 uucls_super_ref
= build_component_ref (UOBJC_METACLASS_decl
, an_id
);
4224 error_with_ivar (const char *message
, tree decl
, tree rawdecl
)
4226 error ("%J%s `%s'", decl
,
4227 message
, gen_declaration (rawdecl
, errbuf
));
4232 check_ivars (tree inter
, tree imp
)
4234 tree intdecls
= CLASS_IVARS (inter
);
4235 tree impdecls
= CLASS_IVARS (imp
);
4236 tree rawintdecls
= CLASS_RAW_IVARS (inter
);
4237 tree rawimpdecls
= CLASS_RAW_IVARS (imp
);
4244 if (intdecls
&& TREE_CODE (intdecls
) == TYPE_DECL
)
4245 intdecls
= TREE_CHAIN (intdecls
);
4247 if (intdecls
== 0 && impdecls
== 0)
4249 if (intdecls
== 0 || impdecls
== 0)
4251 error ("inconsistent instance variable specification");
4255 t1
= TREE_TYPE (intdecls
); t2
= TREE_TYPE (impdecls
);
4257 if (!comptypes (t1
, t2
)
4258 || !tree_int_cst_equal (TREE_VALUE (TREE_VALUE (rawintdecls
)),
4259 TREE_VALUE (TREE_VALUE (rawimpdecls
))))
4261 if (DECL_NAME (intdecls
) == DECL_NAME (impdecls
))
4263 error_with_ivar ("conflicting instance variable type",
4264 impdecls
, rawimpdecls
);
4265 error_with_ivar ("previous declaration of",
4266 intdecls
, rawintdecls
);
4268 else /* both the type and the name don't match */
4270 error ("inconsistent instance variable specification");
4275 else if (DECL_NAME (intdecls
) != DECL_NAME (impdecls
))
4277 error_with_ivar ("conflicting instance variable name",
4278 impdecls
, rawimpdecls
);
4279 error_with_ivar ("previous declaration of",
4280 intdecls
, rawintdecls
);
4283 intdecls
= TREE_CHAIN (intdecls
);
4284 impdecls
= TREE_CHAIN (impdecls
);
4285 rawintdecls
= TREE_CHAIN (rawintdecls
);
4286 rawimpdecls
= TREE_CHAIN (rawimpdecls
);
4290 /* Set 'objc_super_template' to the data type node for 'struct _objc_super'.
4291 This needs to be done just once per compilation. */
4294 build_super_template (void)
4296 tree decl_specs
, field_decl
, field_decl_chain
;
4298 /* Suppress outputting debug symbols, because
4299 dbxout_init hasn't been called yet. */
4300 enum debug_info_type save_write_symbols
= write_symbols
;
4301 const struct gcc_debug_hooks
*save_hooks
= debug_hooks
;
4303 write_symbols
= NO_DEBUG
;
4304 debug_hooks
= &do_nothing_debug_hooks
;
4306 objc_super_template
= start_struct (RECORD_TYPE
, get_identifier (UTAG_SUPER
));
4308 /* struct objc_object *self; */
4310 decl_specs
= build_tree_list (NULL_TREE
, objc_object_reference
);
4311 field_decl
= get_identifier ("self");
4312 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, field_decl
);
4313 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4314 field_decl_chain
= field_decl
;
4317 /* struct objc_class *super_class; */
4319 /* struct objc_class *class; */
4322 decl_specs
= get_identifier (UTAG_CLASS
);
4323 decl_specs
= build_tree_list (NULL_TREE
, xref_tag (RECORD_TYPE
, decl_specs
));
4325 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("super_class"));
4327 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("class"));
4330 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4331 chainon (field_decl_chain
, field_decl
);
4333 finish_struct (objc_super_template
, field_decl_chain
, NULL_TREE
);
4335 write_symbols
= save_write_symbols
;
4336 debug_hooks
= save_hooks
;
4339 /* struct objc_ivar {
4346 build_ivar_template (void)
4348 tree objc_ivar_id
, objc_ivar_record
;
4349 tree decl_specs
, field_decl
, field_decl_chain
;
4351 objc_ivar_id
= get_identifier (UTAG_IVAR
);
4352 objc_ivar_record
= start_struct (RECORD_TYPE
, objc_ivar_id
);
4354 /* char *ivar_name; */
4356 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]);
4357 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("ivar_name"));
4359 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4360 field_decl_chain
= field_decl
;
4362 /* char *ivar_type; */
4364 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_CHAR
]);
4365 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("ivar_type"));
4367 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4368 chainon (field_decl_chain
, field_decl
);
4370 /* int ivar_offset; */
4372 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_INT
]);
4373 field_decl
= get_identifier ("ivar_offset");
4375 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4376 chainon (field_decl_chain
, field_decl
);
4378 finish_struct (objc_ivar_record
, field_decl_chain
, NULL_TREE
);
4380 return objc_ivar_record
;
4385 struct objc_ivar ivar_list[ivar_count];
4389 build_ivar_list_template (tree list_type
, int size
)
4391 tree objc_ivar_list_record
;
4392 tree decl_specs
, field_decl
, field_decl_chain
;
4394 objc_ivar_list_record
= start_struct (RECORD_TYPE
, NULL_TREE
);
4396 /* int ivar_count; */
4398 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_INT
]);
4399 field_decl
= get_identifier ("ivar_count");
4401 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4402 field_decl_chain
= field_decl
;
4404 /* struct objc_ivar ivar_list[]; */
4406 decl_specs
= build_tree_list (NULL_TREE
, list_type
);
4407 field_decl
= build_nt (ARRAY_REF
, get_identifier ("ivar_list"),
4408 build_int_2 (size
, 0));
4410 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4411 chainon (field_decl_chain
, field_decl
);
4413 finish_struct (objc_ivar_list_record
, field_decl_chain
, NULL_TREE
);
4415 return objc_ivar_list_record
;
4421 struct objc_method method_list[method_count];
4425 build_method_list_template (tree list_type
, int size
)
4427 tree objc_ivar_list_record
;
4428 tree decl_specs
, field_decl
, field_decl_chain
;
4430 objc_ivar_list_record
= start_struct (RECORD_TYPE
, NULL_TREE
);
4432 /* int method_next; */
4437 xref_tag (RECORD_TYPE
,
4438 get_identifier (UTAG_METHOD_PROTOTYPE_LIST
)));
4440 = build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("method_next"));
4441 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4442 field_decl_chain
= field_decl
;
4444 /* int method_count; */
4446 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_INT
]);
4447 field_decl
= get_identifier ("method_count");
4449 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4450 chainon (field_decl_chain
, field_decl
);
4452 /* struct objc_method method_list[]; */
4454 decl_specs
= build_tree_list (NULL_TREE
, list_type
);
4455 field_decl
= build_nt (ARRAY_REF
, get_identifier ("method_list"),
4456 build_int_2 (size
, 0));
4458 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4459 chainon (field_decl_chain
, field_decl
);
4461 finish_struct (objc_ivar_list_record
, field_decl_chain
, NULL_TREE
);
4463 return objc_ivar_list_record
;
4467 build_ivar_list_initializer (tree type
, tree field_decl
)
4469 tree initlist
= NULL_TREE
;
4473 tree ivar
= NULL_TREE
;
4476 if (DECL_NAME (field_decl
))
4477 ivar
= tree_cons (NULL_TREE
,
4478 add_objc_string (DECL_NAME (field_decl
),
4482 /* Unnamed bit-field ivar (yuck). */
4483 ivar
= tree_cons (NULL_TREE
, build_int_2 (0, 0), ivar
);
4486 encode_field_decl (field_decl
,
4487 obstack_object_size (&util_obstack
),
4488 OBJC_ENCODE_DONT_INLINE_DEFS
);
4490 /* Null terminate string. */
4491 obstack_1grow (&util_obstack
, 0);
4495 add_objc_string (get_identifier (obstack_finish (&util_obstack
)),
4498 obstack_free (&util_obstack
, util_firstobj
);
4501 ivar
= tree_cons (NULL_TREE
, byte_position (field_decl
), ivar
);
4502 initlist
= tree_cons (NULL_TREE
,
4503 objc_build_constructor (type
, nreverse (ivar
)),
4506 field_decl
= TREE_CHAIN (field_decl
);
4507 while (field_decl
&& TREE_CODE (field_decl
) != FIELD_DECL
);
4511 return objc_build_constructor (build_array_type (type
, 0),
4512 nreverse (initlist
));
4516 generate_ivars_list (tree type
, const char *name
, int size
, tree list
)
4518 tree sc_spec
, decl_specs
, decl
, initlist
;
4520 sc_spec
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_STATIC
], NULL_TREE
);
4521 decl_specs
= tree_cons (NULL_TREE
, type
, sc_spec
);
4523 decl
= start_decl (synth_id_with_class_suffix (name
, objc_implementation_context
),
4524 decl_specs
, 1, NULL_TREE
);
4526 initlist
= build_tree_list (NULL_TREE
, build_int_2 (size
, 0));
4527 initlist
= tree_cons (NULL_TREE
, list
, initlist
);
4530 objc_build_constructor (TREE_TYPE (decl
), nreverse (initlist
)),
4536 /* Count only the fields occurring in T. */
4538 ivar_list_length (tree t
)
4542 for (; t
; t
= TREE_CHAIN (t
))
4543 if (TREE_CODE (t
) == FIELD_DECL
)
4550 generate_ivar_lists (void)
4552 tree initlist
, ivar_list_template
, chain
;
4553 tree cast
, variable_length_type
;
4556 generating_instance_variables
= 1;
4558 if (!objc_ivar_template
)
4559 objc_ivar_template
= build_ivar_template ();
4563 (build_tree_list (NULL_TREE
, xref_tag (RECORD_TYPE
,
4564 get_identifier (UTAG_IVAR_LIST
))),
4566 variable_length_type
= groktypename (cast
);
4568 /* Only generate class variables for the root of the inheritance
4569 hierarchy since these will be the same for every class. */
4571 if (CLASS_SUPER_NAME (implementation_template
) == NULL_TREE
4572 && (chain
= TYPE_FIELDS (objc_class_template
)))
4574 size
= ivar_list_length (chain
);
4576 ivar_list_template
= build_ivar_list_template (objc_ivar_template
, size
);
4577 initlist
= build_ivar_list_initializer (objc_ivar_template
, chain
);
4579 UOBJC_CLASS_VARIABLES_decl
4580 = generate_ivars_list (ivar_list_template
, "_OBJC_CLASS_VARIABLES",
4582 TREE_TYPE (UOBJC_CLASS_VARIABLES_decl
) = variable_length_type
;
4585 UOBJC_CLASS_VARIABLES_decl
= 0;
4587 chain
= CLASS_IVARS (implementation_template
);
4590 size
= ivar_list_length (chain
);
4591 ivar_list_template
= build_ivar_list_template (objc_ivar_template
, size
);
4592 initlist
= build_ivar_list_initializer (objc_ivar_template
, chain
);
4594 UOBJC_INSTANCE_VARIABLES_decl
4595 = generate_ivars_list (ivar_list_template
, "_OBJC_INSTANCE_VARIABLES",
4597 TREE_TYPE (UOBJC_INSTANCE_VARIABLES_decl
) = variable_length_type
;
4600 UOBJC_INSTANCE_VARIABLES_decl
= 0;
4602 generating_instance_variables
= 0;
4606 build_dispatch_table_initializer (tree type
, tree entries
)
4608 tree initlist
= NULL_TREE
;
4612 tree elemlist
= NULL_TREE
;
4614 elemlist
= tree_cons (NULL_TREE
,
4615 build_selector (METHOD_SEL_NAME (entries
)),
4618 /* Generate the method encoding if we don't have one already. */
4619 if (! METHOD_ENCODING (entries
))
4620 METHOD_ENCODING (entries
) =
4621 encode_method_prototype (entries
);
4623 elemlist
= tree_cons (NULL_TREE
,
4624 add_objc_string (METHOD_ENCODING (entries
),
4628 elemlist
= tree_cons (NULL_TREE
,
4629 build_unary_op (ADDR_EXPR
,
4630 METHOD_DEFINITION (entries
), 1),
4633 initlist
= tree_cons (NULL_TREE
,
4634 objc_build_constructor (type
, nreverse (elemlist
)),
4637 entries
= TREE_CHAIN (entries
);
4641 return objc_build_constructor (build_array_type (type
, 0),
4642 nreverse (initlist
));
4645 /* To accomplish method prototyping without generating all kinds of
4646 inane warnings, the definition of the dispatch table entries were
4649 struct objc_method { SEL _cmd; ...; id (*_imp)(); };
4651 struct objc_method { SEL _cmd; ...; void *_imp; }; */
4654 build_method_template (void)
4657 tree decl_specs
, field_decl
, field_decl_chain
;
4659 _SLT_record
= start_struct (RECORD_TYPE
, get_identifier (UTAG_METHOD
));
4661 /* struct objc_selector *_cmd; */
4662 decl_specs
= tree_cons (NULL_TREE
,
4663 xref_tag (RECORD_TYPE
,
4664 get_identifier (TAG_SELECTOR
)),
4666 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("_cmd"));
4668 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4669 field_decl_chain
= field_decl
;
4671 decl_specs
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_CHAR
], NULL_TREE
);
4672 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
,
4673 get_identifier ("method_types"));
4674 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4675 chainon (field_decl_chain
, field_decl
);
4679 decl_specs
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_VOID
], NULL_TREE
);
4680 field_decl
= build1 (INDIRECT_REF
, NULL_TREE
, get_identifier ("_imp"));
4681 field_decl
= grokfield (field_decl
, decl_specs
, NULL_TREE
);
4682 chainon (field_decl_chain
, field_decl
);
4684 finish_struct (_SLT_record
, field_decl_chain
, NULL_TREE
);
4691 generate_dispatch_table (tree type
, const char *name
, int size
, tree list
)
4693 tree sc_spec
, decl_specs
, decl
, initlist
;
4695 sc_spec
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_STATIC
], NULL_TREE
);
4696 decl_specs
= tree_cons (NULL_TREE
, type
, sc_spec
);
4698 decl
= start_decl (synth_id_with_class_suffix (name
, objc_implementation_context
),
4699 decl_specs
, 1, NULL_TREE
);
4701 initlist
= build_tree_list (NULL_TREE
, build_int_2 (0, 0));
4702 initlist
= tree_cons (NULL_TREE
, build_int_2 (size
, 0), initlist
);
4703 initlist
= tree_cons (NULL_TREE
, list
, initlist
);
4706 objc_build_constructor (TREE_TYPE (decl
), nreverse (initlist
)),
4713 mark_referenced_methods (void)
4715 struct imp_entry
*impent
;
4718 for (impent
= imp_list
; impent
; impent
= impent
->next
)
4720 chain
= CLASS_CLS_METHODS (impent
->imp_context
);
4723 cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain
)));
4724 chain
= TREE_CHAIN (chain
);
4727 chain
= CLASS_NST_METHODS (impent
->imp_context
);
4730 cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain
)));
4731 chain
= TREE_CHAIN (chain
);
4737 generate_dispatch_tables (void)
4739 tree initlist
, chain
, method_list_template
;
4740 tree cast
, variable_length_type
;
4743 if (!objc_method_template
)
4744 objc_method_template
= build_method_template ();
4748 (build_tree_list (NULL_TREE
,
4749 xref_tag (RECORD_TYPE
,
4750 get_identifier (UTAG_METHOD_LIST
))),
4753 variable_length_type
= groktypename (cast
);
4755 chain
= CLASS_CLS_METHODS (objc_implementation_context
);
4758 size
= list_length (chain
);
4760 method_list_template
4761 = build_method_list_template (objc_method_template
, size
);
4763 = build_dispatch_table_initializer (objc_method_template
, chain
);
4765 UOBJC_CLASS_METHODS_decl
4766 = generate_dispatch_table (method_list_template
,
4767 ((TREE_CODE (objc_implementation_context
)
4768 == CLASS_IMPLEMENTATION_TYPE
)
4769 ? "_OBJC_CLASS_METHODS"
4770 : "_OBJC_CATEGORY_CLASS_METHODS"),
4772 TREE_TYPE (UOBJC_CLASS_METHODS_decl
) = variable_length_type
;
4775 UOBJC_CLASS_METHODS_decl
= 0;
4777 chain
= CLASS_NST_METHODS (objc_implementation_context
);
4780 size
= list_length (chain
);
4782 method_list_template
4783 = build_method_list_template (objc_method_template
, size
);
4785 = build_dispatch_table_initializer (objc_method_template
, chain
);
4787 if (TREE_CODE (objc_implementation_context
) == CLASS_IMPLEMENTATION_TYPE
)
4788 UOBJC_INSTANCE_METHODS_decl
4789 = generate_dispatch_table (method_list_template
,
4790 "_OBJC_INSTANCE_METHODS",
4793 /* We have a category. */
4794 UOBJC_INSTANCE_METHODS_decl
4795 = generate_dispatch_table (method_list_template
,
4796 "_OBJC_CATEGORY_INSTANCE_METHODS",
4798 TREE_TYPE (UOBJC_INSTANCE_METHODS_decl
) = variable_length_type
;
4801 UOBJC_INSTANCE_METHODS_decl
= 0;
4805 generate_protocol_list (tree i_or_p
)
4807 tree initlist
, decl_specs
, sc_spec
;
4808 tree refs_decl
, expr_decl
, lproto
, e
, plist
;
4812 if (TREE_CODE (i_or_p
) == CLASS_INTERFACE_TYPE
4813 || TREE_CODE (i_or_p
) == CATEGORY_INTERFACE_TYPE
)
4814 plist
= CLASS_PROTOCOL_LIST (i_or_p
);
4815 else if (TREE_CODE (i_or_p
) == PROTOCOL_INTERFACE_TYPE
)
4816 plist
= PROTOCOL_LIST (i_or_p
);
4820 cast_type
= groktypename
4822 (build_tree_list (NULL_TREE
,
4823 xref_tag (RECORD_TYPE
,
4824 get_identifier (UTAG_PROTOCOL
))),
4825 build1 (INDIRECT_REF
, NULL_TREE
, NULL_TREE
)));
4828 for (lproto
= plist
; lproto
; lproto
= TREE_CHAIN (lproto
))
4829 if (TREE_CODE (TREE_VALUE (lproto
)) == PROTOCOL_INTERFACE_TYPE
4830 && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto
)))
4833 /* Build initializer. */
4834 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), NULL_TREE
);
4836 e
= build_int_2 (size
, 0);
4837 TREE_TYPE (e
) = cast_type
;
4838 initlist
= tree_cons (NULL_TREE
, e
, initlist
);
4840 for (lproto
= plist
; lproto
; lproto
= TREE_CHAIN (lproto
))
4842 tree pval
= TREE_VALUE (lproto
);
4844 if (TREE_CODE (pval
) == PROTOCOL_INTERFACE_TYPE
4845 && PROTOCOL_FORWARD_DECL (pval
))
4847 e
= build_unary_op (ADDR_EXPR
, PROTOCOL_FORWARD_DECL (pval
), 0);
4848 initlist
= tree_cons (NULL_TREE
, e
, initlist
);
4852 /* static struct objc_protocol *refs[n]; */
4854 sc_spec
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_STATIC
], NULL_TREE
);
4855 decl_specs
= tree_cons (NULL_TREE
, xref_tag (RECORD_TYPE
,
4856 get_identifier (UTAG_PROTOCOL
)),
4859 if (TREE_CODE (i_or_p
) == PROTOCOL_INTERFACE_TYPE
)
4860 expr_decl
= build_nt (ARRAY_REF
,
4861 synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS",
4863 build_int_2 (size
+ 2, 0));
4864 else if (TREE_CODE (i_or_p
) == CLASS_INTERFACE_TYPE
)
4865 expr_decl
= build_nt (ARRAY_REF
,
4866 synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS",
4868 build_int_2 (size
+ 2, 0));
4869 else if (TREE_CODE (i_or_p
) == CATEGORY_INTERFACE_TYPE
)
4871 = build_nt (ARRAY_REF
,
4872 synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS",
4874 build_int_2 (size
+ 2, 0));
4878 expr_decl
= build1 (INDIRECT_REF
, NULL_TREE
, expr_decl
);
4880 refs_decl
= start_decl (expr_decl
, decl_specs
, 1, NULL_TREE
);
4881 DECL_CONTEXT (refs_decl
) = NULL_TREE
;
4883 finish_decl (refs_decl
, objc_build_constructor (TREE_TYPE (refs_decl
),
4884 nreverse (initlist
)),
4891 build_category_initializer (tree type
, tree cat_name
, tree class_name
,
4892 tree instance_methods
, tree class_methods
,
4895 tree initlist
= NULL_TREE
, expr
;
4897 initlist
= tree_cons (NULL_TREE
, cat_name
, initlist
);
4898 initlist
= tree_cons (NULL_TREE
, class_name
, initlist
);
4900 if (!instance_methods
)
4901 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
4904 expr
= build_unary_op (ADDR_EXPR
, instance_methods
, 0);
4905 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
4908 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
4911 expr
= build_unary_op (ADDR_EXPR
, class_methods
, 0);
4912 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
4915 /* protocol_list = */
4917 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
4920 tree cast_type2
= groktypename
4922 (build_tree_list (NULL_TREE
,
4923 xref_tag (RECORD_TYPE
,
4924 get_identifier (UTAG_PROTOCOL
))),
4925 build1 (INDIRECT_REF
, NULL_TREE
,
4926 build1 (INDIRECT_REF
, NULL_TREE
, NULL_TREE
))));
4928 expr
= build_unary_op (ADDR_EXPR
, protocol_list
, 0);
4929 TREE_TYPE (expr
) = cast_type2
;
4930 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
4933 return objc_build_constructor (type
, nreverse (initlist
));
4936 /* struct objc_class {
4937 struct objc_class *isa;
4938 struct objc_class *super_class;
4943 struct objc_ivar_list *ivars;
4944 struct objc_method_list *methods;
4945 if (flag_next_runtime)
4946 struct objc_cache *cache;
4948 struct sarray *dtable;
4949 struct objc_class *subclass_list;
4950 struct objc_class *sibling_class;
4952 struct objc_protocol_list *protocols;
4953 if (flag_next_runtime)
4955 void *gc_object_type;
4959 build_shared_structure_initializer (tree type
, tree isa
, tree super
,
4960 tree name
, tree size
, int status
,
4961 tree dispatch_table
, tree ivar_list
,
4964 tree initlist
= NULL_TREE
, expr
;
4967 initlist
= tree_cons (NULL_TREE
, isa
, initlist
);
4970 initlist
= tree_cons (NULL_TREE
, super
, initlist
);
4973 initlist
= tree_cons (NULL_TREE
, default_conversion (name
), initlist
);
4976 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
4979 initlist
= tree_cons (NULL_TREE
, build_int_2 (status
, 0), initlist
);
4981 /* instance_size = */
4982 initlist
= tree_cons (NULL_TREE
, size
, initlist
);
4984 /* objc_ivar_list = */
4986 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
4989 expr
= build_unary_op (ADDR_EXPR
, ivar_list
, 0);
4990 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
4993 /* objc_method_list = */
4994 if (!dispatch_table
)
4995 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
4998 expr
= build_unary_op (ADDR_EXPR
, dispatch_table
, 0);
4999 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
5002 if (flag_next_runtime
)
5003 /* method_cache = */
5004 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
5008 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
5010 /* subclass_list = */
5011 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
5013 /* sibling_class = */
5014 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
5017 /* protocol_list = */
5018 if (! protocol_list
)
5019 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
5025 (build_tree_list (NULL_TREE
,
5026 xref_tag (RECORD_TYPE
,
5027 get_identifier (UTAG_PROTOCOL
))),
5028 build1 (INDIRECT_REF
, NULL_TREE
,
5029 build1 (INDIRECT_REF
, NULL_TREE
, NULL_TREE
))));
5031 expr
= build_unary_op (ADDR_EXPR
, protocol_list
, 0);
5032 TREE_TYPE (expr
) = cast_type2
;
5033 initlist
= tree_cons (NULL_TREE
, expr
, initlist
);
5036 if (flag_next_runtime
)
5038 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
5040 /* gc_object_type = NULL */
5041 initlist
= tree_cons (NULL_TREE
, build_int_2 (0, 0), initlist
);
5043 return objc_build_constructor (type
, nreverse (initlist
));
5046 /* Retrieve category interface CAT_NAME (if any) associated with CLASS. */
5049 lookup_category (tree
class, tree cat_name
)
5051 tree category
= CLASS_CATEGORY_LIST (class);
5053 while (category
&& CLASS_SUPER_NAME (category
) != cat_name
)
5054 category
= CLASS_CATEGORY_LIST (category
);
5058 /* static struct objc_category _OBJC_CATEGORY_<name> = { ... }; */
5061 generate_category (tree cat
)
5063 tree sc_spec
, decl_specs
, decl
;
5064 tree initlist
, cat_name_expr
, class_name_expr
;
5065 tree protocol_decl
, category
;
5067 add_class_reference (CLASS_NAME (cat
));
5068 cat_name_expr
= add_objc_string (CLASS_SUPER_NAME (cat
), class_names
);
5070 class_name_expr
= add_objc_string (CLASS_NAME (cat
), class_names
);
5072 category
= lookup_category (implementation_template
,
5073 CLASS_SUPER_NAME (cat
));
5075 if (category
&& CLASS_PROTOCOL_LIST (category
))
5077 generate_protocol_references (CLASS_PROTOCOL_LIST (category
));
5078 protocol_decl
= generate_protocol_list (category
);
5083 sc_spec
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_STATIC
], NULL_TREE
);
5084 decl_specs
= tree_cons (NULL_TREE
, objc_category_template
, sc_spec
);
5086 decl
= start_decl (synth_id_with_class_suffix ("_OBJC_CATEGORY",
5087 objc_implementation_context
),
5088 decl_specs
, 1, NULL_TREE
);
5090 initlist
= build_category_initializer (TREE_TYPE (decl
),
5091 cat_name_expr
, class_name_expr
,
5092 UOBJC_INSTANCE_METHODS_decl
,
5093 UOBJC_CLASS_METHODS_decl
,
5096 finish_decl (decl
, initlist
, NULL_TREE
);
5099 /* static struct objc_class _OBJC_METACLASS_Foo={ ... };
5100 static struct objc_class _OBJC_CLASS_Foo={ ... }; */
5103 generate_shared_structures (void)
5105 tree sc_spec
, decl_specs
, decl
;
5106 tree name_expr
, super_expr
, root_expr
;
5107 tree my_root_id
= NULL_TREE
, my_super_id
= NULL_TREE
;
5108 tree cast_type
, initlist
, protocol_decl
;
5110 my_super_id
= CLASS_SUPER_NAME (implementation_template
);
5113 add_class_reference (my_super_id
);
5115 /* Compute "my_root_id" - this is required for code generation.
5116 the "isa" for all meta class structures points to the root of
5117 the inheritance hierarchy (e.g. "__Object")... */
5118 my_root_id
= my_super_id
;
5121 tree my_root_int
= lookup_interface (my_root_id
);
5123 if (my_root_int
&& CLASS_SUPER_NAME (my_root_int
))
5124 my_root_id
= CLASS_SUPER_NAME (my_root_int
);
5131 /* No super class. */
5132 my_root_id
= CLASS_NAME (implementation_template
);
5135 = groktypename (build_tree_list (build_tree_list (NULL_TREE
,
5136 objc_class_template
),
5137 build1 (INDIRECT_REF
,
5138 NULL_TREE
, NULL_TREE
)));
5140 name_expr
= add_objc_string (CLASS_NAME (implementation_template
),
5143 /* Install class `isa' and `super' pointers at runtime. */
5146 super_expr
= add_objc_string (my_super_id
, class_names
);
5147 super_expr
= build_c_cast (cast_type
, super_expr
); /* cast! */
5150 super_expr
= build_int_2 (0, 0);
5152 root_expr
= add_objc_string (my_root_id
, class_names
);
5153 root_expr
= build_c_cast (cast_type
, root_expr
); /* cast! */
5155 if (CLASS_PROTOCOL_LIST (implementation_template
))
5157 generate_protocol_references
5158 (CLASS_PROTOCOL_LIST (implementation_template
));
5159 protocol_decl
= generate_protocol_list (implementation_template
);
5164 /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */
5166 sc_spec
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_STATIC
]);
5167 decl_specs
= tree_cons (NULL_TREE
, objc_class_template
, sc_spec
);
5169 decl
= start_decl (DECL_NAME (UOBJC_METACLASS_decl
), decl_specs
, 1,
5173 = build_shared_structure_initializer
5175 root_expr
, super_expr
, name_expr
,
5176 convert (integer_type_node
, TYPE_SIZE_UNIT (objc_class_template
)),
5178 UOBJC_CLASS_METHODS_decl
,
5179 UOBJC_CLASS_VARIABLES_decl
,
5182 finish_decl (decl
, initlist
, NULL_TREE
);
5184 /* static struct objc_class _OBJC_CLASS_Foo={ ... }; */
5186 decl
= start_decl (DECL_NAME (UOBJC_CLASS_decl
), decl_specs
, 1,
5190 = build_shared_structure_initializer
5192 build_unary_op (ADDR_EXPR
, UOBJC_METACLASS_decl
, 0),
5193 super_expr
, name_expr
,
5194 convert (integer_type_node
,
5195 TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE
5196 (implementation_template
))),
5198 UOBJC_INSTANCE_METHODS_decl
,
5199 UOBJC_INSTANCE_VARIABLES_decl
,
5202 finish_decl (decl
, initlist
, NULL_TREE
);
5206 synth_id_with_class_suffix (const char *preamble
, tree ctxt
)
5209 if (TREE_CODE (ctxt
) == CLASS_IMPLEMENTATION_TYPE
5210 || TREE_CODE (ctxt
) == CLASS_INTERFACE_TYPE
)
5212 const char *const class_name
5213 = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context
));
5214 string
= (char *) alloca (strlen (preamble
) + strlen (class_name
) + 3);
5215 sprintf (string
, "%s_%s", preamble
,
5216 IDENTIFIER_POINTER (CLASS_NAME (ctxt
)));
5218 else if (TREE_CODE (ctxt
) == CATEGORY_IMPLEMENTATION_TYPE
5219 || TREE_CODE (ctxt
) == CATEGORY_INTERFACE_TYPE
)
5221 /* We have a category. */
5222 const char *const class_name
5223 = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context
));
5224 const char *const class_super_name
5225 = IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context
));
5226 string
= (char *) alloca (strlen (preamble
)
5227 + strlen (class_name
)
5228 + strlen (class_super_name
)
5230 sprintf (string
, "%s_%s_%s", preamble
, class_name
, class_super_name
);
5232 else if (TREE_CODE (ctxt
) == PROTOCOL_INTERFACE_TYPE
)
5234 const char *protocol_name
= IDENTIFIER_POINTER (PROTOCOL_NAME (ctxt
));
5236 = (char *) alloca (strlen (preamble
) + strlen (protocol_name
) + 3);
5237 sprintf (string
, "%s_%s", preamble
, protocol_name
);
5242 return get_identifier (string
);
5246 is_objc_type_qualifier (tree node
)
5248 return (TREE_CODE (node
) == IDENTIFIER_NODE
5249 && (node
== ridpointers
[(int) RID_CONST
]
5250 || node
== ridpointers
[(int) RID_VOLATILE
]
5251 || node
== ridpointers
[(int) RID_IN
]
5252 || node
== ridpointers
[(int) RID_OUT
]
5253 || node
== ridpointers
[(int) RID_INOUT
]
5254 || node
== ridpointers
[(int) RID_BYCOPY
]
5255 || node
== ridpointers
[(int) RID_BYREF
]
5256 || node
== ridpointers
[(int) RID_ONEWAY
]));
5259 /* If type is empty or only type qualifiers are present, add default
5260 type of id (otherwise grokdeclarator will default to int). */
5263 adjust_type_for_id_default (tree type
)
5265 tree declspecs
, chain
;
5268 return build_tree_list (build_tree_list (NULL_TREE
, objc_object_reference
),
5269 build1 (INDIRECT_REF
, NULL_TREE
, NULL_TREE
));
5271 declspecs
= TREE_PURPOSE (type
);
5273 /* Determine if a typespec is present. */
5274 for (chain
= declspecs
;
5276 chain
= TREE_CHAIN (chain
))
5278 if (TYPED_OBJECT (TREE_VALUE (chain
))
5279 && !(TREE_VALUE (type
)
5280 && TREE_CODE (TREE_VALUE (type
)) == INDIRECT_REF
))
5281 error ("can not use an object as parameter to a method\n");
5282 if (!is_objc_type_qualifier (TREE_VALUE (chain
)))
5286 return build_tree_list (tree_cons (NULL_TREE
, objc_object_reference
,
5288 build1 (INDIRECT_REF
, NULL_TREE
, NULL_TREE
));
5293 selector ':' '(' typename ')' identifier
5296 Transform an Objective-C keyword argument into
5297 the C equivalent parameter declarator.
5299 In: key_name, an "identifier_node" (optional).
5300 arg_type, a "tree_list" (optional).
5301 arg_name, an "identifier_node".
5303 Note: It would be really nice to strongly type the preceding
5304 arguments in the function prototype; however, then I
5305 could not use the "accessor" macros defined in "tree.h".
5307 Out: an instance of "keyword_decl". */
5310 build_keyword_decl (tree key_name
, tree arg_type
, tree arg_name
)
5314 /* If no type is specified, default to "id". */
5315 arg_type
= adjust_type_for_id_default (arg_type
);
5317 keyword_decl
= make_node (KEYWORD_DECL
);
5319 TREE_TYPE (keyword_decl
) = arg_type
;
5320 KEYWORD_ARG_NAME (keyword_decl
) = arg_name
;
5321 KEYWORD_KEY_NAME (keyword_decl
) = key_name
;
5323 return keyword_decl
;
5326 /* Given a chain of keyword_decl's, synthesize the full keyword selector. */
5329 build_keyword_selector (tree selector
)
5332 tree key_chain
, key_name
;
5335 /* Scan the selector to see how much space we'll need. */
5336 for (key_chain
= selector
; key_chain
; key_chain
= TREE_CHAIN (key_chain
))
5338 if (TREE_CODE (selector
) == KEYWORD_DECL
)
5339 key_name
= KEYWORD_KEY_NAME (key_chain
);
5340 else if (TREE_CODE (selector
) == TREE_LIST
)
5341 key_name
= TREE_PURPOSE (key_chain
);
5346 len
+= IDENTIFIER_LENGTH (key_name
) + 1;
5348 /* Just a ':' arg. */
5352 buf
= (char *) alloca (len
+ 1);
5353 /* Start the buffer out as an empty string. */
5356 for (key_chain
= selector
; key_chain
; key_chain
= TREE_CHAIN (key_chain
))
5358 if (TREE_CODE (selector
) == KEYWORD_DECL
)
5359 key_name
= KEYWORD_KEY_NAME (key_chain
);
5360 else if (TREE_CODE (selector
) == TREE_LIST
)
5362 key_name
= TREE_PURPOSE (key_chain
);
5363 /* The keyword decl chain will later be used as a function argument
5364 chain. Unhook the selector itself so as to not confuse other
5365 parts of the compiler. */
5366 TREE_PURPOSE (key_chain
) = NULL_TREE
;
5372 strcat (buf
, IDENTIFIER_POINTER (key_name
));
5376 return get_identifier (buf
);
5379 /* Used for declarations and definitions. */
5382 build_method_decl (enum tree_code code
, tree ret_type
, tree selector
,
5387 /* If no type is specified, default to "id". */
5388 ret_type
= adjust_type_for_id_default (ret_type
);
5390 method_decl
= make_node (code
);
5391 TREE_TYPE (method_decl
) = ret_type
;
5393 /* If we have a keyword selector, create an identifier_node that
5394 represents the full selector name (`:' included)... */
5395 if (TREE_CODE (selector
) == KEYWORD_DECL
)
5397 METHOD_SEL_NAME (method_decl
) = build_keyword_selector (selector
);
5398 METHOD_SEL_ARGS (method_decl
) = selector
;
5399 METHOD_ADD_ARGS (method_decl
) = add_args
;
5403 METHOD_SEL_NAME (method_decl
) = selector
;
5404 METHOD_SEL_ARGS (method_decl
) = NULL_TREE
;
5405 METHOD_ADD_ARGS (method_decl
) = NULL_TREE
;
5411 #define METHOD_DEF 0
5412 #define METHOD_REF 1
5414 /* Used by `build_objc_method_call' and `comp_proto_with_proto'. Return
5415 an argument list for method METH. CONTEXT is either METHOD_DEF or
5416 METHOD_REF, saying whether we are trying to define a method or call
5417 one. SUPERFLAG says this is for a send to super; this makes a
5418 difference for the NeXT calling sequence in which the lookup and
5419 the method call are done together. If METH is null, user-defined
5420 arguments (i.e., beyond self and _cmd) shall be represented by `...'. */
5423 get_arg_type_list (tree meth
, int context
, int superflag
)
5427 /* Receiver type. */
5428 if (flag_next_runtime
&& superflag
)
5429 arglist
= build_tree_list (NULL_TREE
, objc_super_type
);
5430 else if (context
== METHOD_DEF
)
5431 arglist
= build_tree_list (NULL_TREE
, TREE_TYPE (self_decl
));
5433 arglist
= build_tree_list (NULL_TREE
, objc_id_type
);
5435 /* Selector type - will eventually change to `int'. */
5436 chainon (arglist
, build_tree_list (NULL_TREE
, objc_selector_type
));
5438 /* No actual method prototype given -- assume that remaining arguments
5443 /* Build a list of argument types. */
5444 for (akey
= METHOD_SEL_ARGS (meth
); akey
; akey
= TREE_CHAIN (akey
))
5446 tree arg_decl
= groktypename_in_parm_context (TREE_TYPE (akey
));
5447 chainon (arglist
, build_tree_list (NULL_TREE
, TREE_TYPE (arg_decl
)));
5450 if (METHOD_ADD_ARGS (meth
) == objc_ellipsis_node
)
5451 /* We have a `, ...' immediately following the selector,
5452 finalize the arglist...simulate get_parm_info (true). */
5454 else if (METHOD_ADD_ARGS (meth
))
5456 /* we have a variable length selector */
5457 tree add_arg_list
= TREE_CHAIN (METHOD_ADD_ARGS (meth
));
5458 chainon (arglist
, add_arg_list
);
5461 /* finalize the arglist...simulate get_parm_info (false) */
5462 chainon (arglist
, void_list_node
);
5468 check_duplicates (hash hsh
, int methods
, int is_class
)
5470 tree meth
= NULL_TREE
;
5478 /* We have two or more methods with the same name but
5482 warning ("multiple %s named `%c%s' found",
5483 methods
? "methods" : "selectors",
5484 (is_class
? '+' : '-'),
5485 IDENTIFIER_POINTER (METHOD_SEL_NAME (meth
)));
5487 warn_with_method (methods
? "using" : "found",
5488 ((TREE_CODE (meth
) == INSTANCE_METHOD_DECL
)
5492 for (loop
= hsh
->list
; loop
; loop
= loop
->next
)
5493 warn_with_method ("also found",
5494 ((TREE_CODE (loop
->value
) == INSTANCE_METHOD_DECL
)
5503 /* If RECEIVER is a class reference, return the identifier node for
5504 the referenced class. RECEIVER is created by get_class_reference,
5505 so we check the exact form created depending on which runtimes are
5509 receiver_is_class_object (tree receiver
, int self
, int super
)
5511 tree chain
, exp
, arg
;
5513 /* The receiver is 'self' or 'super' in the context of a class method. */
5514 if (objc_method_context
5515 && TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
5518 ? CLASS_SUPER_NAME (implementation_template
)
5519 : CLASS_NAME (implementation_template
));
5521 if (flag_next_runtime
)
5523 /* The receiver is a variable created by
5524 build_class_reference_decl. */
5525 if (TREE_CODE (receiver
) == VAR_DECL
5526 && TREE_TYPE (TREE_TYPE (receiver
)) == TREE_TYPE (objc_class_type
))
5527 /* Look up the identifier. */
5528 for (chain
= cls_ref_chain
; chain
; chain
= TREE_CHAIN (chain
))
5529 if (TREE_PURPOSE (chain
) == receiver
)
5530 return TREE_VALUE (chain
);
5533 /* The receiver is a function call that returns an id. Check if
5534 it is a call to objc_getClass, if so, pick up the class name. */
5535 if (TREE_CODE (receiver
) == CALL_EXPR
5536 && (exp
= TREE_OPERAND (receiver
, 0))
5537 && TREE_CODE (exp
) == ADDR_EXPR
5538 && (exp
= TREE_OPERAND (exp
, 0))
5539 && TREE_CODE (exp
) == FUNCTION_DECL
5540 /* For some reason, we sometimes wind up with multiple FUNCTION_DECL
5541 prototypes for objc_get_class(). Thankfully, they seem to share the
5542 same function type. */
5543 && TREE_TYPE (exp
) == TREE_TYPE (objc_get_class_decl
)
5544 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp
)), TAG_GETCLASS
)
5545 /* We have a call to objc_get_class/objc_getClass! */
5546 && (arg
= TREE_OPERAND (receiver
, 1))
5547 && TREE_CODE (arg
) == TREE_LIST
5548 && (arg
= TREE_VALUE (arg
)))
5551 if (TREE_CODE (arg
) == ADDR_EXPR
5552 && (arg
= TREE_OPERAND (arg
, 0))
5553 && TREE_CODE (arg
) == STRING_CST
)
5554 /* Finally, we have the class name. */
5555 return get_identifier (TREE_STRING_POINTER (arg
));
5560 /* If we are currently building a message expr, this holds
5561 the identifier of the selector of the message. This is
5562 used when printing warnings about argument mismatches. */
5564 static tree current_objc_message_selector
= 0;
5567 objc_message_selector (void)
5569 return current_objc_message_selector
;
5572 /* Construct an expression for sending a message.
5573 MESS has the object to send to in TREE_PURPOSE
5574 and the argument list (including selector) in TREE_VALUE.
5576 (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
5577 (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */
5580 build_message_expr (tree mess
)
5582 tree receiver
= TREE_PURPOSE (mess
);
5584 tree args
= TREE_VALUE (mess
);
5585 tree method_params
= NULL_TREE
;
5587 if (TREE_CODE (receiver
) == ERROR_MARK
)
5588 return error_mark_node
;
5590 /* Obtain the full selector name. */
5591 if (TREE_CODE (args
) == IDENTIFIER_NODE
)
5592 /* A unary selector. */
5594 else if (TREE_CODE (args
) == TREE_LIST
)
5595 sel_name
= build_keyword_selector (args
);
5599 /* Build the parameter list to give to the method. */
5600 if (TREE_CODE (args
) == TREE_LIST
)
5602 tree chain
= args
, prev
= NULL_TREE
;
5604 /* We have a keyword selector--check for comma expressions. */
5607 tree element
= TREE_VALUE (chain
);
5609 /* We have a comma expression, must collapse... */
5610 if (TREE_CODE (element
) == TREE_LIST
)
5613 TREE_CHAIN (prev
) = element
;
5618 chain
= TREE_CHAIN (chain
);
5620 method_params
= args
;
5624 if (processing_template_decl
)
5625 /* Must wait until template instantiation time. */
5626 return build_min_nt (MESSAGE_SEND_EXPR
, receiver
, sel_name
,
5630 return finish_message_expr (receiver
, sel_name
, method_params
);
5633 /* Look up method SEL_NAME that would be suitable for receiver
5634 of type 'id' (if IS_CLASS is zero) or 'Class' (if IS_CLASS is
5635 nonzero), and report on any duplicates. */
5638 lookup_method_in_hash_lists (tree sel_name
, int is_class
)
5640 hash method_prototype
= NULL
;
5643 method_prototype
= hash_lookup (nst_method_hash_list
,
5646 if (!method_prototype
)
5648 method_prototype
= hash_lookup (cls_method_hash_list
,
5653 return check_duplicates (method_prototype
, 1, is_class
);
5656 /* The 'finish_message_expr' routine is called from within
5657 'build_message_expr' for non-template functions. In the case of
5658 C++ template functions, it is called from 'build_expr_from_tree'
5659 (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded. */
5662 finish_message_expr (tree receiver
, tree sel_name
, tree method_params
)
5664 tree method_prototype
= NULL_TREE
, rprotos
= NULL_TREE
, rtype
;
5665 tree selector
, retval
, class_tree
;
5666 int self
, super
, have_cast
;
5668 /* Extract the receiver of the message, as well as its type
5669 (where the latter may take the form of a cast or be inferred
5670 from the implementation context). */
5672 while (TREE_CODE (rtype
) == COMPOUND_EXPR
5673 || TREE_CODE (rtype
) == MODIFY_EXPR
5674 || TREE_CODE (rtype
) == NOP_EXPR
5675 || TREE_CODE (rtype
) == COMPONENT_REF
)
5676 rtype
= TREE_OPERAND (rtype
, 0);
5677 self
= (rtype
== self_decl
);
5678 super
= (rtype
== UOBJC_SUPER_decl
);
5679 rtype
= TREE_TYPE (receiver
);
5680 have_cast
= (TREE_CODE (receiver
) == NOP_EXPR
5681 || (TREE_CODE (receiver
) == COMPOUND_EXPR
5682 && !IS_SUPER (rtype
)));
5684 /* If the receiver is a class object, retrieve the corresponding
5685 @interface, if one exists. */
5686 class_tree
= receiver_is_class_object (receiver
, self
, super
);
5688 /* Now determine the receiver type (if an explicit cast has not been
5693 rtype
= lookup_interface (class_tree
);
5694 /* Handle `self' and `super'. */
5697 if (!CLASS_SUPER_NAME (implementation_template
))
5699 error ("no super class declared in @interface for `%s'",
5700 IDENTIFIER_POINTER (CLASS_NAME (implementation_template
)));
5701 return error_mark_node
;
5703 rtype
= lookup_interface (CLASS_SUPER_NAME (implementation_template
));
5706 rtype
= lookup_interface (CLASS_NAME (implementation_template
));
5709 /* If receiver is of type `id' or `Class' (or if the @interface for a
5710 class is not visible), we shall be satisfied with the existence of
5711 any instance or class method. */
5712 if (!rtype
|| IS_ID (rtype
)
5713 || TREE_TYPE (rtype
) == TREE_TYPE (objc_class_type
))
5716 rtype
= xref_tag (RECORD_TYPE
, class_tree
);
5717 else if (IS_ID (rtype
))
5719 rprotos
= TYPE_PROTOCOL_LIST (rtype
);
5723 class_tree
= TYPE_NAME (rtype
) = get_identifier ("Class");
5727 = lookup_method_in_protocol_list (rprotos
, sel_name
,
5728 class_tree
!= NULL_TREE
);
5729 if (!method_prototype
&& !rprotos
)
5731 = lookup_method_in_hash_lists (sel_name
,
5732 class_tree
!= NULL_TREE
);
5736 tree orig_rtype
= rtype
, saved_rtype
;
5738 if (TREE_CODE (rtype
) == POINTER_TYPE
)
5739 rtype
= TREE_TYPE (rtype
);
5740 /* Traverse typedef aliases */
5741 while (TREE_CODE (rtype
) == RECORD_TYPE
&& TYPE_NAME (rtype
)
5742 && TREE_CODE (TYPE_NAME (rtype
)) == TYPE_DECL
5743 && DECL_ORIGINAL_TYPE (TYPE_NAME (rtype
)))
5744 rtype
= DECL_ORIGINAL_TYPE (TYPE_NAME (rtype
));
5745 saved_rtype
= rtype
;
5746 if (TYPED_OBJECT (rtype
))
5748 rprotos
= TYPE_PROTOCOL_LIST (rtype
);
5749 rtype
= lookup_interface (OBJC_TYPE_NAME (rtype
));
5751 /* If we could not find an @interface declaration, we must have
5752 only seen a @class declaration; so, we cannot say anything
5753 more intelligent about which methods the receiver will
5756 rtype
= saved_rtype
;
5757 else if (TREE_CODE (rtype
) == CLASS_INTERFACE_TYPE
5758 || TREE_CODE (rtype
) == CLASS_IMPLEMENTATION_TYPE
)
5760 /* We have a valid ObjC class name. Look up the method name
5761 in the published @interface for the class (and its
5764 = lookup_method_static (rtype
, sel_name
, class_tree
!= NULL_TREE
);
5766 /* If the method was not found in the @interface, it may still
5767 exist locally as part of the @implementation. */
5768 if (!method_prototype
&& objc_implementation_context
5769 && CLASS_NAME (objc_implementation_context
)
5770 == OBJC_TYPE_NAME (rtype
))
5774 ? CLASS_CLS_METHODS (objc_implementation_context
)
5775 : CLASS_NST_METHODS (objc_implementation_context
)),
5778 /* If we haven't found a candidate method by now, try looking for
5779 it in the protocol list. */
5780 if (!method_prototype
&& rprotos
)
5782 = lookup_method_in_protocol_list (rprotos
, sel_name
,
5783 class_tree
!= NULL_TREE
);
5787 warning ("invalid receiver type `%s'",
5788 gen_declaration (orig_rtype
, errbuf
));
5789 rtype
= rprotos
= NULL_TREE
;
5793 if (!method_prototype
)
5795 static bool warn_missing_methods
= false;
5798 warning ("`%s' may not respond to `%c%s'",
5799 IDENTIFIER_POINTER (OBJC_TYPE_NAME (rtype
)),
5800 (class_tree
? '+' : '-'),
5801 IDENTIFIER_POINTER (sel_name
));
5803 warning ("`%c%s' not implemented by protocol(s)",
5804 (class_tree
? '+' : '-'),
5805 IDENTIFIER_POINTER (sel_name
));
5806 if (!warn_missing_methods
)
5808 warning ("(Messages without a matching method signature");
5809 warning ("will be assumed to return `id' and accept");
5810 warning ("`...' as arguments.)");
5811 warn_missing_methods
= true;
5815 /* Save the selector name for printing error messages. */
5816 current_objc_message_selector
= sel_name
;
5818 /* Build the parameters list for looking up the method.
5819 These are the object itself and the selector. */
5821 if (flag_typed_selectors
)
5822 selector
= build_typed_selector_reference (sel_name
, method_prototype
);
5824 selector
= build_selector_reference (sel_name
);
5826 retval
= build_objc_method_call (super
, method_prototype
,
5828 selector
, method_params
);
5830 current_objc_message_selector
= 0;
5835 /* Build a tree expression to send OBJECT the operation SELECTOR,
5836 looking up the method on object LOOKUP_OBJECT (often same as OBJECT),
5837 assuming the method has prototype METHOD_PROTOTYPE.
5838 (That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.)
5839 Use METHOD_PARAMS as list of args to pass to the method.
5840 If SUPER_FLAG is nonzero, we look up the superclass's method. */
5843 build_objc_method_call (int super_flag
, tree method_prototype
,
5844 tree lookup_object
, tree selector
,
5847 tree sender
= (super_flag
? umsg_super_decl
:
5848 (!flag_next_runtime
|| flag_nil_receivers
5850 : umsg_nonnil_decl
));
5851 tree rcv_p
= (super_flag
? objc_super_type
: objc_id_type
);
5853 /* If a prototype for the method to be called exists, then cast
5854 the sender's return type and arguments to match that of the method.
5855 Otherwise, leave sender as is. */
5858 ? groktypename (TREE_TYPE (method_prototype
))
5861 = build_pointer_type
5862 (build_function_type
5865 (method_prototype
, METHOD_REF
, super_flag
)));
5867 lookup_object
= build_c_cast (rcv_p
, lookup_object
);
5869 if (flag_next_runtime
)
5871 /* If we are returning a struct in memory, and the address
5872 of that memory location is passed as a hidden first
5873 argument, then change which messenger entry point this
5874 expr will call. NB: Note that sender_cast remains
5875 unchanged (it already has a struct return type). */
5876 if (!targetm
.calls
.struct_value_rtx (0, 0)
5877 && (TREE_CODE (ret_type
) == RECORD_TYPE
5878 || TREE_CODE (ret_type
) == UNION_TYPE
)
5879 && targetm
.calls
.return_in_memory (ret_type
, 0))
5880 sender
= (super_flag
? umsg_super_stret_decl
:
5881 flag_nil_receivers
? umsg_stret_decl
: umsg_nonnil_stret_decl
);
5883 method_params
= tree_cons (NULL_TREE
, lookup_object
,
5884 tree_cons (NULL_TREE
, selector
,
5886 TREE_USED (sender
) = 1;
5887 assemble_external (sender
);
5888 /* We want to cast the sender, not convert it. */
5889 return build_function_call (build_c_cast (sender_cast
, sender
),
5894 /* This is the portable (GNU) way. */
5895 tree method
, object
;
5897 /* First, call the lookup function to get a pointer to the method,
5898 then cast the pointer, then call it with the method arguments.
5899 Use SAVE_EXPR to avoid evaluating the receiver twice. */
5900 lookup_object
= save_expr (lookup_object
);
5901 object
= (super_flag
? self_decl
: lookup_object
);
5902 TREE_USED (sender
) = 1;
5903 assemble_external (sender
);
5905 = build_function_call (sender
,
5906 tree_cons (NULL_TREE
, lookup_object
,
5907 tree_cons (NULL_TREE
, selector
,
5910 /* Pass the object to the method. */
5911 TREE_USED (method
) = 1;
5912 assemble_external (method
);
5913 return build_function_call
5914 (build_c_cast (sender_cast
, method
),
5915 tree_cons (NULL_TREE
, object
,
5916 tree_cons (NULL_TREE
, selector
, method_params
)));
5921 build_protocol_reference (tree p
)
5923 tree decl
, ident
, ptype
;
5925 /* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
5927 ident
= synth_id_with_class_suffix ("_OBJC_PROTOCOL", p
);
5929 = groktypename (build_tree_list (build_tree_list (NULL_TREE
,
5930 objc_protocol_template
),
5933 if (identifier_global_value (ident
))
5934 decl
= identifier_global_value (ident
); /* Set by pushdecl. */
5937 decl
= build_decl (VAR_DECL
, ident
, ptype
);
5938 DECL_EXTERNAL (decl
) = 1;
5939 TREE_PUBLIC (decl
) = 0;
5940 TREE_USED (decl
) = 1;
5941 DECL_ARTIFICIAL (decl
) = 1;
5943 make_decl_rtl (decl
, 0);
5944 pushdecl_top_level (decl
);
5947 PROTOCOL_FORWARD_DECL (p
) = decl
;
5950 /* This function is called by the parser when (and only when) a
5951 @protocol() expression is found, in order to compile it. */
5953 build_protocol_expr (tree protoname
)
5956 tree p
= lookup_protocol (protoname
);
5960 error ("cannot find protocol declaration for `%s'",
5961 IDENTIFIER_POINTER (protoname
));
5962 return error_mark_node
;
5965 if (!PROTOCOL_FORWARD_DECL (p
))
5966 build_protocol_reference (p
);
5968 expr
= build_unary_op (ADDR_EXPR
, PROTOCOL_FORWARD_DECL (p
), 0);
5970 /* ??? Ideally we'd build the reference with objc_protocol_type directly,
5971 if we have it, rather than converting it here. */
5972 expr
= convert (objc_protocol_type
, expr
);
5974 /* The @protocol() expression is being compiled into a pointer to a
5975 statically allocated instance of the Protocol class. To become
5976 usable at runtime, the 'isa' pointer of the instance need to be
5977 fixed up at runtime by the runtime library, to point to the
5978 actual 'Protocol' class. */
5980 /* For the GNU runtime, put the static Protocol instance in the list
5981 of statically allocated instances, so that we make sure that its
5982 'isa' pointer is fixed up at runtime by the GNU runtime library
5983 to point to the Protocol class (at runtime, when loading the
5984 module, the GNU runtime library loops on the statically allocated
5985 instances (as found in the defs field in objc_symtab) and fixups
5986 all the 'isa' pointers of those objects). */
5987 if (! flag_next_runtime
)
5989 /* This type is a struct containing the fields of a Protocol
5990 object. (Cfr. objc_protocol_type instead is the type of a pointer
5991 to such a struct). */
5992 tree protocol_struct_type
= xref_tag
5993 (RECORD_TYPE
, get_identifier (PROTOCOL_OBJECT_CLASS_NAME
));
5996 /* Look for the list of Protocol statically allocated instances
5997 to fixup at runtime. Create a new list to hold Protocol
5998 statically allocated instances, if the list is not found. At
5999 present there is only another list, holding NSConstantString
6000 static instances to be fixed up at runtime. */
6001 for (chain
= &objc_static_instances
;
6002 *chain
&& TREE_VALUE (*chain
) != protocol_struct_type
;
6003 chain
= &TREE_CHAIN (*chain
));
6006 *chain
= tree_cons (NULL_TREE
, protocol_struct_type
, NULL_TREE
);
6007 add_objc_string (OBJC_TYPE_NAME (protocol_struct_type
),
6011 /* Add this statically allocated instance to the Protocol list. */
6012 TREE_PURPOSE (*chain
) = tree_cons (NULL_TREE
,
6013 PROTOCOL_FORWARD_DECL (p
),
6014 TREE_PURPOSE (*chain
));
6021 /* This function is called by the parser when a @selector() expression
6022 is found, in order to compile it. It is only called by the parser
6023 and only to compile a @selector(). */
6025 build_selector_expr (tree selnamelist
)
6029 /* Obtain the full selector name. */
6030 if (TREE_CODE (selnamelist
) == IDENTIFIER_NODE
)
6031 /* A unary selector. */
6032 selname
= selnamelist
;
6033 else if (TREE_CODE (selnamelist
) == TREE_LIST
)
6034 selname
= build_keyword_selector (selnamelist
);
6038 /* If we are required to check @selector() expressions as they
6039 are found, check that the selector has been declared. */
6040 if (warn_undeclared_selector
)
6042 /* Look the selector up in the list of all known class and
6043 instance methods (up to this line) to check that the selector
6047 /* First try with instance methods. */
6048 hsh
= hash_lookup (nst_method_hash_list
, selname
);
6050 /* If not found, try with class methods. */
6053 hsh
= hash_lookup (cls_method_hash_list
, selname
);
6056 /* If still not found, print out a warning. */
6059 warning ("undeclared selector `%s'", IDENTIFIER_POINTER (selname
));
6064 if (flag_typed_selectors
)
6065 return build_typed_selector_reference (selname
, 0);
6067 return build_selector_reference (selname
);
6071 build_encode_expr (tree type
)
6076 encode_type (type
, obstack_object_size (&util_obstack
),
6077 OBJC_ENCODE_INLINE_DEFS
);
6078 obstack_1grow (&util_obstack
, 0); /* null terminate string */
6079 string
= obstack_finish (&util_obstack
);
6081 /* Synthesize a string that represents the encoded struct/union. */
6082 result
= my_build_string (strlen (string
) + 1, string
);
6083 obstack_free (&util_obstack
, util_firstobj
);
6088 build_ivar_reference (tree id
)
6090 if (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
)
6092 /* Historically, a class method that produced objects (factory
6093 method) would assign `self' to the instance that it
6094 allocated. This would effectively turn the class method into
6095 an instance method. Following this assignment, the instance
6096 variables could be accessed. That practice, while safe,
6097 violates the simple rule that a class method should not refer
6098 to an instance variable. It's better to catch the cases
6099 where this is done unknowingly than to support the above
6101 warning ("instance variable `%s' accessed in class method",
6102 IDENTIFIER_POINTER (id
));
6103 TREE_TYPE (self_decl
) = objc_instance_type
; /* cast */
6106 return build_component_ref (build_indirect_ref (self_decl
, "->"), id
);
6109 /* Compute a hash value for a given method SEL_NAME. */
6112 hash_func (tree sel_name
)
6114 const unsigned char *s
6115 = (const unsigned char *)IDENTIFIER_POINTER (sel_name
);
6119 h
= h
* 67 + *s
++ - 113;
6126 nst_method_hash_list
6127 = (hash
*) ggc_alloc_cleared (SIZEHASHTABLE
* sizeof (hash
));
6128 cls_method_hash_list
6129 = (hash
*) ggc_alloc_cleared (SIZEHASHTABLE
* sizeof (hash
));
6132 /* WARNING!!!! hash_enter is called with a method, and will peek
6133 inside to find its selector! But hash_lookup is given a selector
6134 directly, and looks for the selector that's inside the found
6135 entry's key (method) for comparison. */
6138 hash_enter (hash
*hashlist
, tree method
)
6141 int slot
= hash_func (METHOD_SEL_NAME (method
)) % SIZEHASHTABLE
;
6143 obj
= (hash
) ggc_alloc (sizeof (struct hashed_entry
));
6145 obj
->next
= hashlist
[slot
];
6148 hashlist
[slot
] = obj
; /* append to front */
6152 hash_lookup (hash
*hashlist
, tree sel_name
)
6156 target
= hashlist
[hash_func (sel_name
) % SIZEHASHTABLE
];
6160 if (sel_name
== METHOD_SEL_NAME (target
->key
))
6163 target
= target
->next
;
6169 hash_add_attr (hash entry
, tree value
)
6173 obj
= (attr
) ggc_alloc (sizeof (struct hashed_attribute
));
6174 obj
->next
= entry
->list
;
6177 entry
->list
= obj
; /* append to front */
6181 lookup_method (tree mchain
, tree method
)
6185 if (TREE_CODE (method
) == IDENTIFIER_NODE
)
6188 key
= METHOD_SEL_NAME (method
);
6192 if (METHOD_SEL_NAME (mchain
) == key
)
6195 mchain
= TREE_CHAIN (mchain
);
6201 lookup_method_static (tree interface
, tree ident
, int is_class
)
6203 tree meth
= NULL_TREE
, root_inter
= NULL_TREE
;
6204 tree inter
= interface
;
6208 tree chain
= is_class
? CLASS_CLS_METHODS (inter
) : CLASS_NST_METHODS (inter
);
6209 tree category
= inter
;
6211 /* First, look up the method in the class itself. */
6212 if ((meth
= lookup_method (chain
, ident
)))
6215 /* Failing that, look for the method in each category of the class. */
6216 while ((category
= CLASS_CATEGORY_LIST (category
)))
6218 chain
= is_class
? CLASS_CLS_METHODS (category
) : CLASS_NST_METHODS (category
);
6220 /* Check directly in each category. */
6221 if ((meth
= lookup_method (chain
, ident
)))
6224 /* Failing that, check in each category's protocols. */
6225 if (CLASS_PROTOCOL_LIST (category
))
6227 if ((meth
= (lookup_method_in_protocol_list
6228 (CLASS_PROTOCOL_LIST (category
), ident
, is_class
))))
6233 /* If not found in categories, check in protocols of the main class. */
6234 if (CLASS_PROTOCOL_LIST (inter
))
6236 if ((meth
= (lookup_method_in_protocol_list
6237 (CLASS_PROTOCOL_LIST (inter
), ident
, is_class
))))
6241 /* Failing that, climb up the inheritance hierarchy. */
6243 inter
= lookup_interface (CLASS_SUPER_NAME (inter
));
6247 /* If no class (factory) method was found, check if an _instance_
6248 method of the same name exists in the root class. This is what
6249 the Objective-C runtime will do. If an instance method was not
6251 return is_class
? lookup_method_static (root_inter
, ident
, 0): NULL_TREE
;
6254 /* Add the method to the hash list if it doesn't contain an identical
6257 add_method_to_hash_list (hash
*hash_list
, tree method
)
6261 if (!(hsh
= hash_lookup (hash_list
, METHOD_SEL_NAME (method
))))
6263 /* Install on a global chain. */
6264 hash_enter (hash_list
, method
);
6268 /* Check types against those; if different, add to a list. */
6270 int already_there
= comp_proto_with_proto (method
, hsh
->key
);
6271 for (loop
= hsh
->list
; !already_there
&& loop
; loop
= loop
->next
)
6272 already_there
|= comp_proto_with_proto (method
, loop
->value
);
6274 hash_add_attr (hsh
, method
);
6279 objc_add_method (tree
class, tree method
, int is_class
)
6283 if (!(mth
= lookup_method (is_class
? CLASS_CLS_METHODS (class) : CLASS_NST_METHODS (class), method
)))
6285 /* put method on list in reverse order */
6288 TREE_CHAIN (method
) = CLASS_CLS_METHODS (class);
6289 CLASS_CLS_METHODS (class) = method
;
6293 TREE_CHAIN (method
) = CLASS_NST_METHODS (class);
6294 CLASS_NST_METHODS (class) = method
;
6299 /* When processing an @interface for a class or category, give hard
6300 errors on methods with identical selectors but differing argument
6301 and/or return types. We do not do this for @implementations, because
6302 C/C++ will do it for us (i.e., there will be duplicate function
6303 definition errors). */
6304 if ((TREE_CODE (class) == CLASS_INTERFACE_TYPE
6305 || TREE_CODE (class) == CATEGORY_INTERFACE_TYPE
)
6306 && !comp_proto_with_proto (method
, mth
))
6307 error ("duplicate declaration of method `%c%s'",
6308 is_class
? '+' : '-', IDENTIFIER_POINTER (METHOD_SEL_NAME (mth
)));
6312 add_method_to_hash_list (cls_method_hash_list
, method
);
6315 add_method_to_hash_list (nst_method_hash_list
, method
);
6317 /* Instance methods in root classes (and categories thereof)
6318 may acts as class methods as a last resort. */
6319 if (TREE_CODE (class) == CATEGORY_INTERFACE_TYPE
6320 || TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE
)
6321 class = lookup_interface (CLASS_NAME (class));
6323 if (TREE_CODE (class) != PROTOCOL_INTERFACE_TYPE
6324 && !CLASS_SUPER_NAME (class))
6325 add_method_to_hash_list (cls_method_hash_list
, method
);
6332 add_class (tree
class)
6334 /* Put interfaces on list in reverse order. */
6335 TREE_CHAIN (class) = interface_chain
;
6336 interface_chain
= class;
6337 return interface_chain
;
6341 add_category (tree
class, tree category
)
6343 /* Put categories on list in reverse order. */
6344 tree cat
= lookup_category (class, CLASS_SUPER_NAME (category
));
6348 warning ("duplicate interface declaration for category `%s(%s)'",
6349 IDENTIFIER_POINTER (CLASS_NAME (class)),
6350 IDENTIFIER_POINTER (CLASS_SUPER_NAME (category
)));
6354 CLASS_CATEGORY_LIST (category
) = CLASS_CATEGORY_LIST (class);
6355 CLASS_CATEGORY_LIST (class) = category
;
6359 /* Called after parsing each instance variable declaration. Necessary to
6360 preserve typedefs and implement public/private...
6362 PUBLIC is 1 for public, 0 for protected, and 2 for private. */
6365 add_instance_variable (tree
class, int public, tree declarator
,
6366 tree declspecs
, tree width
)
6368 tree field_decl
= grokfield (declarator
, declspecs
, width
);
6369 tree field_type
= TREE_TYPE (field_decl
);
6370 const char *ivar_name
= DECL_NAME (field_decl
)
6371 ? IDENTIFIER_POINTER (DECL_NAME (field_decl
))
6376 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
6378 error ("illegal reference type specified for instance variable `%s'",
6380 /* Return class as is without adding this ivar. */
6385 if (field_type
== error_mark_node
|| !TYPE_SIZE (field_type
)
6386 || TYPE_SIZE (field_type
) == error_mark_node
6387 /* 'type[0]' is allowed, but 'type[]' is not! */
6389 || (TYPE_SIZE (field_type
) == bitsize_zero_node
6390 && !TREE_OPERAND (declarator
, 1))
6394 error ("instance variable `%s' has unknown size", ivar_name
);
6395 /* Return class as is without adding this ivar. */
6400 /* zlaski 2001-Apr-24: C++ classes with non-trivial constructors and/or destructors
6401 cannot be ivars; ditto for classes with vtables. */
6402 if(IS_AGGR_TYPE (field_type
) && (TYPE_NEEDS_CONSTRUCTING (field_type
)
6403 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
) || TYPE_POLYMORPHIC_P (field_type
)))
6405 const char *type_name
= IDENTIFIER_POINTER (OBJC_TYPE_NAME (field_type
));
6406 if(TYPE_POLYMORPHIC_P (field_type
)) {
6407 /* vtable pointers are Real Bad(tm), since Obj-C cannot initialize them */
6408 error ("type `%s' has virtual member functions", type_name
);
6409 error ("illegal aggregate type `%s' specified for instance variable `%s'",
6410 type_name
, ivar_name
);
6411 /* Return class as is without adding this ivar. */
6414 /* user-defined constructors and destructors are not known to Obj-C and
6415 hence will not be called. This may or may not be a problem. */
6416 if (TYPE_NEEDS_CONSTRUCTING (field_type
))
6417 warning ("type `%s' has a user-defined constructor", type_name
);
6418 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
))
6419 warning ("type `%s' has a user-defined destructor", type_name
);
6420 warning ("C++ constructors and destructors will not be invoked for Objective-C fields");
6424 /* Overload the public attribute, it is not used for FIELD_DECLs. */
6428 TREE_PUBLIC (field_decl
) = 0;
6429 TREE_PRIVATE (field_decl
) = 0;
6430 TREE_PROTECTED (field_decl
) = 1;
6434 TREE_PUBLIC (field_decl
) = 1;
6435 TREE_PRIVATE (field_decl
) = 0;
6436 TREE_PROTECTED (field_decl
) = 0;
6440 TREE_PUBLIC (field_decl
) = 0;
6441 TREE_PRIVATE (field_decl
) = 1;
6442 TREE_PROTECTED (field_decl
) = 0;
6447 raw_decl
= build_tree_list (declspecs
, build_tree_list (declarator
, width
));
6448 CLASS_RAW_IVARS (class) = chainon (CLASS_RAW_IVARS (class), raw_decl
);
6449 CLASS_IVARS (class) = chainon (CLASS_IVARS (class), field_decl
);
6454 is_ivar (tree decl_chain
, tree ident
)
6456 for ( ; decl_chain
; decl_chain
= TREE_CHAIN (decl_chain
))
6457 if (DECL_NAME (decl_chain
) == ident
)
6462 /* True if the ivar is private and we are not in its implementation. */
6465 is_private (tree decl
)
6467 return (TREE_PRIVATE (decl
)
6468 && ! is_ivar (CLASS_IVARS (implementation_template
),
6472 /* We have an instance variable reference;, check to see if it is public. */
6475 objc_is_public (tree expr
, tree identifier
)
6477 tree basetype
= TREE_TYPE (expr
);
6478 enum tree_code code
= TREE_CODE (basetype
);
6481 if (code
== RECORD_TYPE
)
6483 if (TREE_STATIC_TEMPLATE (basetype
))
6485 if (!lookup_interface (OBJC_TYPE_NAME (basetype
)))
6487 error ("cannot find interface declaration for `%s'",
6488 IDENTIFIER_POINTER (OBJC_TYPE_NAME (basetype
)));
6492 if ((decl
= is_ivar (TYPE_FIELDS (basetype
), identifier
)))
6494 if (TREE_PUBLIC (decl
))
6497 /* Important difference between the Stepstone translator:
6498 all instance variables should be public within the context
6499 of the implementation. */
6500 if (objc_implementation_context
6501 && (((TREE_CODE (objc_implementation_context
)
6502 == CLASS_IMPLEMENTATION_TYPE
)
6503 || (TREE_CODE (objc_implementation_context
)
6504 == CATEGORY_IMPLEMENTATION_TYPE
))
6505 && (CLASS_NAME (objc_implementation_context
)
6506 == OBJC_TYPE_NAME (basetype
))))
6508 int private = is_private (decl
);
6511 error ("instance variable `%s' is declared private",
6512 IDENTIFIER_POINTER (DECL_NAME (decl
)));
6516 /* The 2.95.2 compiler sometimes allowed C functions to access
6517 non-@public ivars. We will let this slide for now... */
6518 if (!objc_method_context
)
6520 warning ("instance variable `%s' is %s; "
6521 "this will be a hard error in the future",
6522 IDENTIFIER_POINTER (identifier
),
6523 TREE_PRIVATE (decl
) ? "@private" : "@protected");
6527 error ("instance variable `%s' is declared %s",
6528 IDENTIFIER_POINTER (identifier
),
6529 TREE_PRIVATE (decl
) ? "private" : "protected");
6534 else if (objc_implementation_context
&& (basetype
== objc_object_reference
))
6536 TREE_TYPE (expr
) = uprivate_record
;
6537 warning ("static access to object of type `id'");
6544 /* Make sure all entries in CHAIN are also in LIST. */
6547 check_methods (tree chain
, tree list
, int mtype
)
6553 if (!lookup_method (list
, chain
))
6557 if (TREE_CODE (objc_implementation_context
)
6558 == CLASS_IMPLEMENTATION_TYPE
)
6559 warning ("incomplete implementation of class `%s'",
6560 IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context
)));
6561 else if (TREE_CODE (objc_implementation_context
)
6562 == CATEGORY_IMPLEMENTATION_TYPE
)
6563 warning ("incomplete implementation of category `%s'",
6564 IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context
)));
6568 warning ("method definition for `%c%s' not found",
6569 mtype
, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain
)));
6572 chain
= TREE_CHAIN (chain
);
6578 /* Check if CLASS, or its superclasses, explicitly conforms to PROTOCOL. */
6581 conforms_to_protocol (tree
class, tree protocol
)
6583 if (TREE_CODE (protocol
) == PROTOCOL_INTERFACE_TYPE
)
6585 tree p
= CLASS_PROTOCOL_LIST (class);
6586 while (p
&& TREE_VALUE (p
) != protocol
)
6591 tree super
= (CLASS_SUPER_NAME (class)
6592 ? lookup_interface (CLASS_SUPER_NAME (class))
6594 int tmp
= super
? conforms_to_protocol (super
, protocol
) : 0;
6603 /* Make sure all methods in CHAIN are accessible as MTYPE methods in
6604 CONTEXT. This is one of two mechanisms to check protocol integrity. */
6607 check_methods_accessible (tree chain
, tree context
, int mtype
)
6611 tree base_context
= context
;
6615 context
= base_context
;
6619 list
= CLASS_CLS_METHODS (context
);
6621 list
= CLASS_NST_METHODS (context
);
6623 if (lookup_method (list
, chain
))
6626 else if (TREE_CODE (context
) == CLASS_IMPLEMENTATION_TYPE
6627 || TREE_CODE (context
) == CLASS_INTERFACE_TYPE
)
6628 context
= (CLASS_SUPER_NAME (context
)
6629 ? lookup_interface (CLASS_SUPER_NAME (context
))
6632 else if (TREE_CODE (context
) == CATEGORY_IMPLEMENTATION_TYPE
6633 || TREE_CODE (context
) == CATEGORY_INTERFACE_TYPE
)
6634 context
= (CLASS_NAME (context
)
6635 ? lookup_interface (CLASS_NAME (context
))
6641 if (context
== NULL_TREE
)
6645 if (TREE_CODE (objc_implementation_context
)
6646 == CLASS_IMPLEMENTATION_TYPE
)
6647 warning ("incomplete implementation of class `%s'",
6649 (CLASS_NAME (objc_implementation_context
)));
6650 else if (TREE_CODE (objc_implementation_context
)
6651 == CATEGORY_IMPLEMENTATION_TYPE
)
6652 warning ("incomplete implementation of category `%s'",
6654 (CLASS_SUPER_NAME (objc_implementation_context
)));
6657 warning ("method definition for `%c%s' not found",
6658 mtype
, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain
)));
6661 chain
= TREE_CHAIN (chain
); /* next method... */
6666 /* Check whether the current interface (accessible via
6667 'objc_implementation_context') actually implements protocol P, along
6668 with any protocols that P inherits. */
6671 check_protocol (tree p
, const char *type
, const char *name
)
6673 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
6677 /* Ensure that all protocols have bodies! */
6680 f1
= check_methods (PROTOCOL_CLS_METHODS (p
),
6681 CLASS_CLS_METHODS (objc_implementation_context
),
6683 f2
= check_methods (PROTOCOL_NST_METHODS (p
),
6684 CLASS_NST_METHODS (objc_implementation_context
),
6689 f1
= check_methods_accessible (PROTOCOL_CLS_METHODS (p
),
6690 objc_implementation_context
,
6692 f2
= check_methods_accessible (PROTOCOL_NST_METHODS (p
),
6693 objc_implementation_context
,
6698 warning ("%s `%s' does not fully implement the `%s' protocol",
6699 type
, name
, IDENTIFIER_POINTER (PROTOCOL_NAME (p
)));
6702 /* Check protocols recursively. */
6703 if (PROTOCOL_LIST (p
))
6705 tree subs
= PROTOCOL_LIST (p
);
6707 lookup_interface (CLASS_SUPER_NAME (implementation_template
));
6711 tree sub
= TREE_VALUE (subs
);
6713 /* If the superclass does not conform to the protocols
6714 inherited by P, then we must! */
6715 if (!super_class
|| !conforms_to_protocol (super_class
, sub
))
6716 check_protocol (sub
, type
, name
);
6717 subs
= TREE_CHAIN (subs
);
6722 /* Check whether the current interface (accessible via
6723 'objc_implementation_context') actually implements the protocols listed
6727 check_protocols (tree proto_list
, const char *type
, const char *name
)
6729 for ( ; proto_list
; proto_list
= TREE_CHAIN (proto_list
))
6731 tree p
= TREE_VALUE (proto_list
);
6733 check_protocol (p
, type
, name
);
6737 /* Make sure that the class CLASS_NAME is defined
6738 CODE says which kind of thing CLASS_NAME ought to be.
6739 It can be CLASS_INTERFACE_TYPE, CLASS_IMPLEMENTATION_TYPE,
6740 CATEGORY_INTERFACE_TYPE, or CATEGORY_IMPLEMENTATION_TYPE. */
6743 start_class (enum tree_code code
, tree class_name
, tree super_name
,
6749 if (current_namespace
!= global_namespace
) {
6750 error ("Objective-C declarations may only appear in global scope");
6752 #endif /* OBJCPLUS */
6754 if (objc_implementation_context
)
6756 warning ("`@end' missing in implementation context");
6757 finish_class (objc_implementation_context
);
6758 objc_ivar_chain
= NULL_TREE
;
6759 objc_implementation_context
= NULL_TREE
;
6762 class = make_node (code
);
6763 TYPE_BINFO (class) = make_tree_vec (CLASS_BINFO_ELTS
);
6765 CLASS_NAME (class) = class_name
;
6766 CLASS_SUPER_NAME (class) = super_name
;
6767 CLASS_CLS_METHODS (class) = NULL_TREE
;
6769 if (! is_class_name (class_name
)
6770 && (decl
= lookup_name (class_name
)))
6772 error ("`%s' redeclared as different kind of symbol",
6773 IDENTIFIER_POINTER (class_name
));
6774 error ("%Jprevious declaration of '%D'",
6778 if (code
== CLASS_IMPLEMENTATION_TYPE
)
6783 for (chain
= implemented_classes
; chain
; chain
= TREE_CHAIN (chain
))
6784 if (TREE_VALUE (chain
) == class_name
)
6786 error ("reimplementation of class `%s'",
6787 IDENTIFIER_POINTER (class_name
));
6788 return error_mark_node
;
6790 implemented_classes
= tree_cons (NULL_TREE
, class_name
,
6791 implemented_classes
);
6794 /* Reset for multiple classes per file. */
6797 objc_implementation_context
= class;
6799 /* Lookup the interface for this implementation. */
6801 if (!(implementation_template
= lookup_interface (class_name
)))
6803 warning ("cannot find interface declaration for `%s'",
6804 IDENTIFIER_POINTER (class_name
));
6805 add_class (implementation_template
= objc_implementation_context
);
6808 /* If a super class has been specified in the implementation,
6809 insure it conforms to the one specified in the interface. */
6812 && (super_name
!= CLASS_SUPER_NAME (implementation_template
)))
6814 tree previous_name
= CLASS_SUPER_NAME (implementation_template
);
6815 const char *const name
=
6816 previous_name
? IDENTIFIER_POINTER (previous_name
) : "";
6817 error ("conflicting super class name `%s'",
6818 IDENTIFIER_POINTER (super_name
));
6819 error ("previous declaration of `%s'", name
);
6822 else if (! super_name
)
6824 CLASS_SUPER_NAME (objc_implementation_context
)
6825 = CLASS_SUPER_NAME (implementation_template
);
6829 else if (code
== CLASS_INTERFACE_TYPE
)
6831 if (lookup_interface (class_name
))
6833 error ("duplicate interface declaration for class `%s'",
6835 warning ("duplicate interface declaration for class `%s'",
6837 IDENTIFIER_POINTER (class_name
));
6842 CLASS_PROTOCOL_LIST (class)
6843 = lookup_and_install_protocols (protocol_list
);
6846 else if (code
== CATEGORY_INTERFACE_TYPE
)
6848 tree class_category_is_assoc_with
;
6850 /* For a category, class_name is really the name of the class that
6851 the following set of methods will be associated with. We must
6852 find the interface so that can derive the objects template. */
6854 if (!(class_category_is_assoc_with
= lookup_interface (class_name
)))
6856 error ("cannot find interface declaration for `%s'",
6857 IDENTIFIER_POINTER (class_name
));
6858 exit (FATAL_EXIT_CODE
);
6861 add_category (class_category_is_assoc_with
, class);
6864 CLASS_PROTOCOL_LIST (class)
6865 = lookup_and_install_protocols (protocol_list
);
6868 else if (code
== CATEGORY_IMPLEMENTATION_TYPE
)
6870 /* Reset for multiple classes per file. */
6873 objc_implementation_context
= class;
6875 /* For a category, class_name is really the name of the class that
6876 the following set of methods will be associated with. We must
6877 find the interface so that can derive the objects template. */
6879 if (!(implementation_template
= lookup_interface (class_name
)))
6881 error ("cannot find interface declaration for `%s'",
6882 IDENTIFIER_POINTER (class_name
));
6883 exit (FATAL_EXIT_CODE
);
6890 continue_class (tree
class)
6892 if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE
6893 || TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE
)
6895 struct imp_entry
*imp_entry
;
6898 /* Check consistency of the instance variables. */
6900 if (CLASS_IVARS (class))
6901 check_ivars (implementation_template
, class);
6903 /* code generation */
6905 ivar_context
= build_private_template (implementation_template
);
6907 if (!objc_class_template
)
6908 build_class_template ();
6910 imp_entry
= (struct imp_entry
*) ggc_alloc (sizeof (struct imp_entry
));
6912 imp_entry
->next
= imp_list
;
6913 imp_entry
->imp_context
= class;
6914 imp_entry
->imp_template
= implementation_template
;
6916 synth_forward_declarations ();
6917 imp_entry
->class_decl
= UOBJC_CLASS_decl
;
6918 imp_entry
->meta_decl
= UOBJC_METACLASS_decl
;
6920 /* Append to front and increment count. */
6921 imp_list
= imp_entry
;
6922 if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE
)
6927 return ivar_context
;
6930 else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE
)
6932 if (!CLASS_STATIC_TEMPLATE (class))
6934 tree record
= start_struct (RECORD_TYPE
, CLASS_NAME (class));
6935 finish_struct (record
, get_class_ivars (class, 0), NULL_TREE
);
6936 CLASS_STATIC_TEMPLATE (class) = record
;
6938 /* Mark this record as a class template for static typing. */
6939 TREE_STATIC_TEMPLATE (record
) = 1;
6946 return error_mark_node
;
6949 /* This is called once we see the "@end" in an interface/implementation. */
6952 finish_class (tree
class)
6954 if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE
)
6956 /* All code generation is done in finish_objc. */
6958 if (implementation_template
!= objc_implementation_context
)
6960 /* Ensure that all method listed in the interface contain bodies. */
6961 check_methods (CLASS_CLS_METHODS (implementation_template
),
6962 CLASS_CLS_METHODS (objc_implementation_context
), '+');
6963 check_methods (CLASS_NST_METHODS (implementation_template
),
6964 CLASS_NST_METHODS (objc_implementation_context
), '-');
6966 if (CLASS_PROTOCOL_LIST (implementation_template
))
6967 check_protocols (CLASS_PROTOCOL_LIST (implementation_template
),
6969 IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context
)));
6973 else if (TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE
)
6975 tree category
= lookup_category (implementation_template
, CLASS_SUPER_NAME (class));
6979 /* Ensure all method listed in the interface contain bodies. */
6980 check_methods (CLASS_CLS_METHODS (category
),
6981 CLASS_CLS_METHODS (objc_implementation_context
), '+');
6982 check_methods (CLASS_NST_METHODS (category
),
6983 CLASS_NST_METHODS (objc_implementation_context
), '-');
6985 if (CLASS_PROTOCOL_LIST (category
))
6986 check_protocols (CLASS_PROTOCOL_LIST (category
),
6988 IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context
)));
6992 else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE
)
6995 const char *class_name
= IDENTIFIER_POINTER (CLASS_NAME (class));
6996 char *string
= (char *) alloca (strlen (class_name
) + 3);
6998 /* extern struct objc_object *_<my_name>; */
7000 sprintf (string
, "_%s", class_name
);
7002 decl_specs
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_EXTERN
]);
7003 decl_specs
= tree_cons (NULL_TREE
, objc_object_reference
, decl_specs
);
7004 define_decl (build1 (INDIRECT_REF
, NULL_TREE
, get_identifier (string
)),
7010 add_protocol (tree protocol
)
7012 /* Put protocol on list in reverse order. */
7013 TREE_CHAIN (protocol
) = protocol_chain
;
7014 protocol_chain
= protocol
;
7015 return protocol_chain
;
7019 lookup_protocol (tree ident
)
7023 for (chain
= protocol_chain
; chain
; chain
= TREE_CHAIN (chain
))
7024 if (ident
== PROTOCOL_NAME (chain
))
7030 /* This function forward declares the protocols named by NAMES. If
7031 they are already declared or defined, the function has no effect. */
7034 objc_declare_protocols (tree names
)
7039 if (current_namespace
!= global_namespace
) {
7040 error ("Objective-C declarations may only appear in global scope");
7042 #endif /* OBJCPLUS */
7044 for (list
= names
; list
; list
= TREE_CHAIN (list
))
7046 tree name
= TREE_VALUE (list
);
7048 if (lookup_protocol (name
) == NULL_TREE
)
7050 tree protocol
= make_node (PROTOCOL_INTERFACE_TYPE
);
7052 TYPE_BINFO (protocol
) = make_tree_vec (2);
7053 PROTOCOL_NAME (protocol
) = name
;
7054 PROTOCOL_LIST (protocol
) = NULL_TREE
;
7055 add_protocol (protocol
);
7056 PROTOCOL_DEFINED (protocol
) = 0;
7057 PROTOCOL_FORWARD_DECL (protocol
) = NULL_TREE
;
7063 start_protocol (enum tree_code code
, tree name
, tree list
)
7068 if (current_namespace
!= global_namespace
) {
7069 error ("Objective-C declarations may only appear in global scope");
7071 #endif /* OBJCPLUS */
7073 /* This is as good a place as any. Need to invoke
7074 push_tag_toplevel. */
7075 if (!objc_protocol_template
)
7076 objc_protocol_template
= build_protocol_template ();
7078 protocol
= lookup_protocol (name
);
7082 protocol
= make_node (code
);
7083 TYPE_BINFO (protocol
) = make_tree_vec (2);
7085 PROTOCOL_NAME (protocol
) = name
;
7086 PROTOCOL_LIST (protocol
) = lookup_and_install_protocols (list
);
7087 add_protocol (protocol
);
7088 PROTOCOL_DEFINED (protocol
) = 1;
7089 PROTOCOL_FORWARD_DECL (protocol
) = NULL_TREE
;
7091 check_protocol_recursively (protocol
, list
);
7093 else if (! PROTOCOL_DEFINED (protocol
))
7095 PROTOCOL_DEFINED (protocol
) = 1;
7096 PROTOCOL_LIST (protocol
) = lookup_and_install_protocols (list
);
7098 check_protocol_recursively (protocol
, list
);
7102 warning ("duplicate declaration for protocol `%s'",
7103 IDENTIFIER_POINTER (name
));
7109 finish_protocol (tree protocol ATTRIBUTE_UNUSED
)
7114 /* "Encode" a data type into a string, which grows in util_obstack.
7115 ??? What is the FORMAT? Someone please document this! */
7118 encode_type_qualifiers (tree declspecs
)
7122 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
7124 if (ridpointers
[(int) RID_CONST
] == TREE_VALUE (spec
))
7125 obstack_1grow (&util_obstack
, 'r');
7126 else if (ridpointers
[(int) RID_IN
] == TREE_VALUE (spec
))
7127 obstack_1grow (&util_obstack
, 'n');
7128 else if (ridpointers
[(int) RID_INOUT
] == TREE_VALUE (spec
))
7129 obstack_1grow (&util_obstack
, 'N');
7130 else if (ridpointers
[(int) RID_OUT
] == TREE_VALUE (spec
))
7131 obstack_1grow (&util_obstack
, 'o');
7132 else if (ridpointers
[(int) RID_BYCOPY
] == TREE_VALUE (spec
))
7133 obstack_1grow (&util_obstack
, 'O');
7134 else if (ridpointers
[(int) RID_BYREF
] == TREE_VALUE (spec
))
7135 obstack_1grow (&util_obstack
, 'R');
7136 else if (ridpointers
[(int) RID_ONEWAY
] == TREE_VALUE (spec
))
7137 obstack_1grow (&util_obstack
, 'V');
7141 /* Encode a pointer type. */
7144 encode_pointer (tree type
, int curtype
, int format
)
7146 tree pointer_to
= TREE_TYPE (type
);
7148 if (TREE_CODE (pointer_to
) == RECORD_TYPE
)
7150 if (OBJC_TYPE_NAME (pointer_to
)
7151 && TREE_CODE (OBJC_TYPE_NAME (pointer_to
)) == IDENTIFIER_NODE
)
7153 const char *name
= IDENTIFIER_POINTER (OBJC_TYPE_NAME (pointer_to
));
7155 if (strcmp (name
, TAG_OBJECT
) == 0) /* '@' */
7157 obstack_1grow (&util_obstack
, '@');
7160 else if (TREE_STATIC_TEMPLATE (pointer_to
))
7162 if (generating_instance_variables
)
7164 obstack_1grow (&util_obstack
, '@');
7165 obstack_1grow (&util_obstack
, '"');
7166 obstack_grow (&util_obstack
, name
, strlen (name
));
7167 obstack_1grow (&util_obstack
, '"');
7172 obstack_1grow (&util_obstack
, '@');
7176 else if (strcmp (name
, TAG_CLASS
) == 0) /* '#' */
7178 obstack_1grow (&util_obstack
, '#');
7181 else if (strcmp (name
, TAG_SELECTOR
) == 0) /* ':' */
7183 obstack_1grow (&util_obstack
, ':');
7188 else if (TREE_CODE (pointer_to
) == INTEGER_TYPE
7189 && TYPE_MODE (pointer_to
) == QImode
)
7191 tree pname
= TREE_CODE (OBJC_TYPE_NAME (pointer_to
)) == IDENTIFIER_NODE
7192 ? OBJC_TYPE_NAME (pointer_to
)
7193 : DECL_NAME (OBJC_TYPE_NAME (pointer_to
));
7195 if (!flag_next_runtime
|| strcmp (IDENTIFIER_POINTER (pname
), "BOOL"))
7197 obstack_1grow (&util_obstack
, '*');
7202 /* We have a type that does not get special treatment. */
7204 /* NeXT extension */
7205 obstack_1grow (&util_obstack
, '^');
7206 encode_type (pointer_to
, curtype
, format
);
7210 encode_array (tree type
, int curtype
, int format
)
7212 tree an_int_cst
= TYPE_SIZE (type
);
7213 tree array_of
= TREE_TYPE (type
);
7216 /* An incomplete array is treated like a pointer. */
7217 if (an_int_cst
== NULL
)
7219 encode_pointer (type
, curtype
, format
);
7223 sprintf (buffer
, "[%ld",
7224 (long) (TREE_INT_CST_LOW (an_int_cst
)
7225 / TREE_INT_CST_LOW (TYPE_SIZE (array_of
))));
7227 obstack_grow (&util_obstack
, buffer
, strlen (buffer
));
7228 encode_type (array_of
, curtype
, format
);
7229 obstack_1grow (&util_obstack
, ']');
7234 encode_aggregate_within (tree type
, int curtype
, int format
, int left
,
7238 /* NB: aggregates that are pointed to have slightly different encoding
7239 rules in that you never encode the names of instance variables. */
7241 = (obstack_object_size (&util_obstack
) > 0
7242 && *(obstack_next_free (&util_obstack
) - 1) == '^');
7244 = ((format
== OBJC_ENCODE_INLINE_DEFS
|| generating_instance_variables
)
7245 && (!pointed_to
|| obstack_object_size (&util_obstack
) - curtype
== 1));
7247 /* Traverse struct aliases; it is important to get the
7248 original struct and its tag name (if any). */
7249 type
= TYPE_MAIN_VARIANT (type
);
7250 name
= OBJC_TYPE_NAME (type
);
7251 /* Open parenth/bracket. */
7252 obstack_1grow (&util_obstack
, left
);
7254 /* Encode the struct/union tag name, or '?' if a tag was
7255 not provided. Typedef aliases do not qualify. */
7256 if (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
7258 /* Did this struct have a tag? */
7259 && !TYPE_WAS_ANONYMOUS (type
)
7262 obstack_grow (&util_obstack
,
7263 IDENTIFIER_POINTER (name
),
7264 strlen (IDENTIFIER_POINTER (name
)));
7266 obstack_1grow (&util_obstack
, '?');
7268 /* Encode the types (and possibly names) of the inner fields,
7270 if (inline_contents
)
7272 tree fields
= TYPE_FIELDS (type
);
7274 obstack_1grow (&util_obstack
, '=');
7275 for (; fields
; fields
= TREE_CHAIN (fields
))
7278 /* C++ static members, and things that are not fields at all,
7279 should not appear in the encoding. */
7280 if (TREE_CODE (fields
) != FIELD_DECL
|| TREE_STATIC (fields
))
7283 if (generating_instance_variables
&& !pointed_to
)
7285 tree fname
= DECL_NAME (fields
);
7287 obstack_1grow (&util_obstack
, '"');
7288 if (fname
&& TREE_CODE (fname
) == IDENTIFIER_NODE
)
7289 obstack_grow (&util_obstack
,
7290 IDENTIFIER_POINTER (fname
),
7291 strlen (IDENTIFIER_POINTER (fname
)));
7292 obstack_1grow (&util_obstack
, '"');
7294 encode_field_decl (fields
, curtype
, format
);
7297 /* Close parenth/bracket. */
7298 obstack_1grow (&util_obstack
, right
);
7302 encode_aggregate (tree type
, int curtype
, int format
)
7304 enum tree_code code
= TREE_CODE (type
);
7310 encode_aggregate_within (type
, curtype
, format
, '{', '}');
7315 encode_aggregate_within (type
, curtype
, format
, '(', ')');
7320 obstack_1grow (&util_obstack
, 'i');
7328 /* Encode a bitfield NeXT-style (i.e., without a bit offset or the underlying
7332 encode_next_bitfield (int width
)
7335 sprintf (buffer
, "b%d", width
);
7336 obstack_grow (&util_obstack
, buffer
, strlen (buffer
));
7339 /* FORMAT will be OBJC_ENCODE_INLINE_DEFS or OBJC_ENCODE_DONT_INLINE_DEFS. */
7341 encode_type (tree type
, int curtype
, int format
)
7343 enum tree_code code
= TREE_CODE (type
);
7346 if (code
== INTEGER_TYPE
)
7348 switch (GET_MODE_BITSIZE (TYPE_MODE (type
)))
7350 case 8: c
= TYPE_UNSIGNED (type
) ? 'C' : 'c'; break;
7351 case 16: c
= TYPE_UNSIGNED (type
) ? 'S' : 's'; break;
7353 if (type
== long_unsigned_type_node
7354 || type
== long_integer_type_node
)
7355 c
= TYPE_UNSIGNED (type
) ? 'L' : 'l';
7357 c
= TYPE_UNSIGNED (type
) ? 'I' : 'i';
7359 case 64: c
= TYPE_UNSIGNED (type
) ? 'Q' : 'q'; break;
7362 obstack_1grow (&util_obstack
, c
);
7365 else if (code
== REAL_TYPE
)
7367 /* Floating point types. */
7368 switch (GET_MODE_BITSIZE (TYPE_MODE (type
)))
7370 case 32: c
= 'f'; break;
7372 case 128: c
= 'd'; break;
7375 obstack_1grow (&util_obstack
, c
);
7378 else if (code
== VOID_TYPE
)
7379 obstack_1grow (&util_obstack
, 'v');
7381 else if (code
== BOOLEAN_TYPE
)
7382 obstack_1grow (&util_obstack
, 'B');
7384 else if (code
== ARRAY_TYPE
)
7385 encode_array (type
, curtype
, format
);
7387 else if (code
== POINTER_TYPE
)
7388 encode_pointer (type
, curtype
, format
);
7390 else if (code
== RECORD_TYPE
|| code
== UNION_TYPE
|| code
== ENUMERAL_TYPE
)
7391 encode_aggregate (type
, curtype
, format
);
7393 else if (code
== FUNCTION_TYPE
) /* '?' */
7394 obstack_1grow (&util_obstack
, '?');
7398 encode_gnu_bitfield (int position
, tree type
, int size
)
7400 enum tree_code code
= TREE_CODE (type
);
7402 char charType
= '?';
7404 if (code
== INTEGER_TYPE
)
7406 if (integer_zerop (TYPE_MIN_VALUE (type
)))
7408 /* Unsigned integer types. */
7410 if (TYPE_MODE (type
) == QImode
)
7412 else if (TYPE_MODE (type
) == HImode
)
7414 else if (TYPE_MODE (type
) == SImode
)
7416 if (type
== long_unsigned_type_node
)
7421 else if (TYPE_MODE (type
) == DImode
)
7426 /* Signed integer types. */
7428 if (TYPE_MODE (type
) == QImode
)
7430 else if (TYPE_MODE (type
) == HImode
)
7432 else if (TYPE_MODE (type
) == SImode
)
7434 if (type
== long_integer_type_node
)
7440 else if (TYPE_MODE (type
) == DImode
)
7444 else if (code
== ENUMERAL_TYPE
)
7449 sprintf (buffer
, "b%d%c%d", position
, charType
, size
);
7450 obstack_grow (&util_obstack
, buffer
, strlen (buffer
));
7454 encode_field_decl (tree field_decl
, int curtype
, int format
)
7459 /* C++ static members, and things that are not fields at all,
7460 should not appear in the encoding. */
7461 if (TREE_CODE (field_decl
) != FIELD_DECL
|| TREE_STATIC (field_decl
))
7465 type
= TREE_TYPE (field_decl
);
7467 /* Generate the bitfield typing information, if needed. Note the difference
7468 between GNU and NeXT runtimes. */
7469 if (DECL_BIT_FIELD_TYPE (field_decl
))
7471 int size
= tree_low_cst (DECL_SIZE (field_decl
), 1);
7473 if (flag_next_runtime
)
7474 encode_next_bitfield (size
);
7476 encode_gnu_bitfield (int_bit_position (field_decl
),
7477 DECL_BIT_FIELD_TYPE (field_decl
), size
);
7480 encode_type (TREE_TYPE (field_decl
), curtype
, format
);
7484 objc_expr_last (tree complex_expr
)
7489 while ((next
= TREE_OPERAND (complex_expr
, 0)))
7490 complex_expr
= next
;
7492 return complex_expr
;
7496 synth_self_and_ucmd_args (void)
7500 if (objc_method_context
7501 && TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
)
7502 decl_specs
= build_tree_list (NULL_TREE
, uprivate_record
);
7504 /* Really a `struct objc_class *'. However, we allow people to
7505 assign to self, which changes its type midstream. */
7506 decl_specs
= build_tree_list (NULL_TREE
, objc_object_reference
);
7508 push_parm_decl (build_tree_list
7509 (build_tree_list (decl_specs
,
7510 build1 (INDIRECT_REF
, NULL_TREE
, self_id
)),
7513 decl_specs
= build_tree_list (NULL_TREE
, TREE_TYPE (objc_selector_type
));
7514 push_parm_decl (build_tree_list
7515 (build_tree_list (decl_specs
,
7516 build1 (INDIRECT_REF
, NULL_TREE
, ucmd_id
)),
7520 /* Transform a method definition into a function definition as follows:
7521 - synthesize the first two arguments, "self" and "_cmd". */
7524 start_method_def (tree method
)
7526 /* Required to implement _msgSuper. */
7527 objc_method_context
= method
;
7528 UOBJC_SUPER_decl
= NULL_TREE
;
7530 /* Must be called BEFORE start_function. */
7532 declare_parm_level ();
7534 /* Generate prototype declarations for arguments..."new-style". */
7535 synth_self_and_ucmd_args ();
7537 /* Generate argument declarations if a keyword_decl. */
7538 if (METHOD_SEL_ARGS (method
))
7540 tree arglist
= METHOD_SEL_ARGS (method
);
7543 tree arg_spec
= TREE_PURPOSE (TREE_TYPE (arglist
));
7544 tree arg_decl
= TREE_VALUE (TREE_TYPE (arglist
));
7548 tree last_expr
= objc_expr_last (arg_decl
);
7550 /* Unite the abstract decl with its name. */
7551 TREE_OPERAND (last_expr
, 0) = KEYWORD_ARG_NAME (arglist
);
7552 push_parm_decl (build_tree_list
7553 (build_tree_list (arg_spec
, arg_decl
),
7557 /* Unhook: restore the abstract declarator. */
7558 TREE_OPERAND (last_expr
, 0) = NULL_TREE
;
7563 push_parm_decl (build_tree_list
7564 (build_tree_list (arg_spec
,
7565 KEYWORD_ARG_NAME (arglist
)),
7568 arglist
= TREE_CHAIN (arglist
);
7573 if (METHOD_ADD_ARGS (method
) != NULL_TREE
7574 && METHOD_ADD_ARGS (method
) != objc_ellipsis_node
)
7576 /* We have a variable length selector - in "prototype" format. */
7577 tree akey
= TREE_PURPOSE (METHOD_ADD_ARGS (method
));
7580 /* This must be done prior to calling pushdecl. pushdecl is
7581 going to change our chain on us. */
7582 tree nextkey
= TREE_CHAIN (akey
);
7590 warn_with_method (const char *message
, int mtype
, tree method
)
7592 /* Add a readable method name to the warning. */
7593 warning ("%J%s `%c%s'", method
,
7594 message
, mtype
, gen_method_decl (method
, errbuf
));
7597 /* Return 1 if METHOD is consistent with PROTO. */
7600 comp_method_with_proto (tree method
, tree proto
)
7602 /* Create a function template node at most once. */
7603 if (!function1_template
)
7604 function1_template
= make_node (FUNCTION_TYPE
);
7606 /* Install argument types - normally set by build_function_type. */
7607 TYPE_ARG_TYPES (function1_template
) = get_arg_type_list (proto
, METHOD_DEF
, 0);
7609 /* install return type */
7610 TREE_TYPE (function1_template
) = groktypename (TREE_TYPE (proto
));
7612 return comptypes (TREE_TYPE (METHOD_DEFINITION (method
)), function1_template
);
7615 /* Return 1 if TYPE1 is equivalent to TYPE2. */
7618 objc_types_are_equivalent (tree type1
, tree type2
)
7622 if (TYPE_MAIN_VARIANT (type1
) != TYPE_MAIN_VARIANT (type2
))
7624 type1
= TYPE_PROTOCOL_LIST (type1
);
7625 type2
= TYPE_PROTOCOL_LIST (type2
);
7626 if (list_length (type1
) == list_length (type2
))
7628 for (; type2
; type2
= TREE_CHAIN (type2
))
7629 if (!lookup_protocol_in_reflist (type1
, TREE_VALUE (type2
)))
7636 /* Return 1 if PROTO1 is equivalent to PROTO2. */
7639 comp_proto_with_proto (tree proto1
, tree proto2
)
7643 /* The following test is needed in case there are hashing
7645 if (METHOD_SEL_NAME (proto1
) != METHOD_SEL_NAME (proto2
))
7648 /* Compare return types. */
7649 type1
= groktypename (TREE_TYPE (proto1
));
7650 type2
= groktypename (TREE_TYPE (proto2
));
7652 if (!objc_types_are_equivalent (type1
, type2
))
7655 /* Compare argument types. */
7656 for (type1
= get_arg_type_list (proto1
, METHOD_REF
, 0),
7657 type2
= get_arg_type_list (proto2
, METHOD_REF
, 0);
7659 type1
= TREE_CHAIN (type1
), type2
= TREE_CHAIN (type2
))
7661 if (!objc_types_are_equivalent (TREE_VALUE (type1
), TREE_VALUE (type2
)))
7665 return (!type1
&& !type2
);
7668 /* - Generate an identifier for the function. the format is "_n_cls",
7669 where 1 <= n <= nMethods, and cls is the name the implementation we
7671 - Install the return type from the method declaration.
7672 - If we have a prototype, check for type consistency. */
7675 really_start_method (tree method
, tree parmlist
)
7677 tree sc_spec
, ret_spec
, ret_decl
, decl_specs
;
7678 tree method_decl
, method_id
;
7679 const char *sel_name
, *class_name
, *cat_name
;
7682 /* Synth the storage class & assemble the return type. */
7683 sc_spec
= tree_cons (NULL_TREE
, ridpointers
[(int) RID_STATIC
], NULL_TREE
);
7684 ret_spec
= TREE_PURPOSE (TREE_TYPE (method
));
7685 decl_specs
= chainon (sc_spec
, ret_spec
);
7687 sel_name
= IDENTIFIER_POINTER (METHOD_SEL_NAME (method
));
7688 class_name
= IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context
));
7689 cat_name
= ((TREE_CODE (objc_implementation_context
)
7690 == CLASS_IMPLEMENTATION_TYPE
)
7692 : IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context
)));
7695 /* Make sure this is big enough for any plausible method label. */
7696 buf
= (char *) alloca (50 + strlen (sel_name
) + strlen (class_name
)
7697 + (cat_name
? strlen (cat_name
) : 0));
7699 OBJC_GEN_METHOD_LABEL (buf
, TREE_CODE (method
) == INSTANCE_METHOD_DECL
,
7700 class_name
, cat_name
, sel_name
, method_slot
);
7702 method_id
= get_identifier (buf
);
7705 /* Objective-C methods cannot be overloaded, so we don't need
7706 the type encoding appended. It looks bad anyway... */
7707 push_lang_context (lang_name_c
);
7710 method_decl
= build_nt (CALL_EXPR
, method_id
, parmlist
, NULL_TREE
);
7712 /* Check the declarator portion of the return type for the method. */
7713 if ((ret_decl
= TREE_VALUE (TREE_TYPE (method
))))
7715 /* Unite the complex decl (specified in the abstract decl) with the
7716 function decl just synthesized..(int *), (int (*)()), (int (*)[]). */
7717 tree save_expr
= objc_expr_last (ret_decl
);
7719 TREE_OPERAND (save_expr
, 0) = method_decl
;
7720 method_decl
= ret_decl
;
7722 /* Fool the parser into thinking it is starting a function. */
7723 start_function (decl_specs
, method_decl
, NULL_TREE
);
7725 /* Unhook: this has the effect of restoring the abstract declarator. */
7726 TREE_OPERAND (save_expr
, 0) = NULL_TREE
;
7731 TREE_VALUE (TREE_TYPE (method
)) = method_decl
;
7733 /* Fool the parser into thinking it is starting a function. */
7734 start_function (decl_specs
, method_decl
, NULL_TREE
);
7736 /* Unhook: this has the effect of restoring the abstract declarator. */
7737 TREE_VALUE (TREE_TYPE (method
)) = NULL_TREE
;
7741 /* set self_decl from the first argument...this global is used by
7742 * build_ivar_reference().build_indirect_ref().
7744 self_decl
= DECL_ARGUMENTS (current_function_decl
);
7746 /* snaroff (3/28/96): when compiling with -Wall, this suppresses
7747 * the following: warning:unused parameter `struct objc_selector * _cmd'
7749 TREE_USED (self_decl
) = 1;
7750 TREE_USED (TREE_CHAIN (self_decl
)) = 1;
7751 /* Ditto for the underlying (static) C function. */
7752 TREE_USED (current_function_decl
) = 1;
7753 pop_lang_context ();
7756 METHOD_DEFINITION (method
) = current_function_decl
;
7758 /* Check consistency...start_function, pushdecl, duplicate_decls. */
7760 if (implementation_template
!= objc_implementation_context
)
7763 = lookup_method_static (implementation_template
,
7764 METHOD_SEL_NAME (method
),
7765 TREE_CODE (method
) == CLASS_METHOD_DECL
);
7769 if (!comp_method_with_proto (method
, proto
))
7771 char type
= (TREE_CODE (method
) == INSTANCE_METHOD_DECL
? '-' : '+');
7773 warn_with_method ("conflicting types for", type
, method
);
7774 warn_with_method ("previous declaration of", type
, proto
);
7779 /* We have a method @implementation even though we did not
7780 see a corresponding @interface declaration (which is allowed
7781 by Objective-C rules). Go ahead and place the method in
7782 the @interface anyway, so that message dispatch lookups
7784 tree interface
= implementation_template
;
7786 if (TREE_CODE (objc_implementation_context
)
7787 == CATEGORY_IMPLEMENTATION_TYPE
)
7788 interface
= lookup_category
7790 CLASS_SUPER_NAME (objc_implementation_context
));
7793 objc_add_method (interface
, copy_node (method
),
7794 TREE_CODE (method
) == CLASS_METHOD_DECL
);
7799 /* The following routine is always called...this "architecture" is to
7800 accommodate "old-style" variable length selectors.
7802 - a:a b:b // prototype ; id c; id d; // old-style. */
7805 continue_method_def (void)
7809 if (METHOD_ADD_ARGS (objc_method_context
) == objc_ellipsis_node
)
7810 /* We have a `, ...' immediately following the selector. */
7811 parmlist
= get_parm_info (/*ellipsis=*/true);
7813 parmlist
= get_parm_info (/*ellipsis=*/false);
7816 /* Set self_decl from the first argument...this global is used by
7817 build_ivar_reference calling build_indirect_ref. */
7818 self_decl
= TREE_PURPOSE (parmlist
);
7819 #endif /* !OBJCPLUS */
7822 really_start_method (objc_method_context
, parmlist
);
7823 store_parm_decls ();
7826 static void *UOBJC_SUPER_scope
= 0;
7828 /* _n_Method (id self, SEL sel, ...)
7830 struct objc_super _S;
7831 _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
7835 get_super_receiver (void)
7837 if (objc_method_context
)
7839 tree super_expr
, super_expr_list
;
7841 if (!UOBJC_SUPER_decl
)
7843 UOBJC_SUPER_decl
= start_decl (get_identifier (TAG_SUPER
),
7844 build_tree_list (NULL_TREE
,
7845 objc_super_template
),
7848 finish_decl (UOBJC_SUPER_decl
, NULL_TREE
, NULL_TREE
);
7850 /* This prevents `unused variable' warnings when compiling with -Wall. */
7851 TREE_USED (UOBJC_SUPER_decl
) = 1;
7852 DECL_ARTIFICIAL (UOBJC_SUPER_decl
) = 1;
7854 UOBJC_SUPER_scope
= get_current_scope ();
7857 /* Set receiver to self. */
7858 super_expr
= build_component_ref (UOBJC_SUPER_decl
, self_id
);
7859 super_expr
= build_modify_expr (super_expr
, NOP_EXPR
, self_decl
);
7860 super_expr_list
= build_tree_list (NULL_TREE
, super_expr
);
7862 /* Set class to begin searching. */
7864 super_expr
= build_component_ref (UOBJC_SUPER_decl
,
7865 get_identifier ("super_class"));
7867 super_expr
= build_component_ref (UOBJC_SUPER_decl
,
7868 get_identifier ("class"));
7871 if (TREE_CODE (objc_implementation_context
) == CLASS_IMPLEMENTATION_TYPE
)
7873 /* [_cls, __cls]Super are "pre-built" in
7874 synth_forward_declarations. */
7876 super_expr
= build_modify_expr (super_expr
, NOP_EXPR
,
7877 ((TREE_CODE (objc_method_context
)
7878 == INSTANCE_METHOD_DECL
)
7880 : uucls_super_ref
));
7884 /* We have a category. */
7886 tree super_name
= CLASS_SUPER_NAME (implementation_template
);
7889 /* Barf if super used in a category of Object. */
7892 error ("no super class declared in interface for `%s'",
7893 IDENTIFIER_POINTER (CLASS_NAME (implementation_template
)));
7894 return error_mark_node
;
7897 if (flag_next_runtime
&& !flag_zero_link
)
7899 super_class
= get_class_reference (super_name
);
7900 if (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
)
7901 /* If we are in a class method, we must retrieve the
7902 _metaclass_ for the current class, pointed at by
7903 the class's "isa" pointer. The following assumes that
7904 "isa" is the first ivar in a class (which it must be). */
7906 = build_indirect_ref
7907 (build_c_cast (build_pointer_type (objc_class_type
),
7908 super_class
), "unary *");
7912 add_class_reference (super_name
);
7913 super_class
= (TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
7914 ? objc_get_class_decl
: objc_get_meta_class_decl
);
7915 assemble_external (super_class
);
7917 = build_function_call
7921 my_build_string (IDENTIFIER_LENGTH (super_name
) + 1,
7922 IDENTIFIER_POINTER (super_name
))));
7926 = build_modify_expr (super_expr
, NOP_EXPR
,
7927 build_c_cast (TREE_TYPE (super_expr
),
7931 chainon (super_expr_list
, build_tree_list (NULL_TREE
, super_expr
));
7933 super_expr
= build_unary_op (ADDR_EXPR
, UOBJC_SUPER_decl
, 0);
7934 chainon (super_expr_list
, build_tree_list (NULL_TREE
, super_expr
));
7936 return build_compound_expr (super_expr_list
);
7940 error ("[super ...] must appear in a method context");
7941 return error_mark_node
;
7945 /* When exiting a scope, sever links to a 'super' declaration (if any)
7946 therein contained. */
7949 objc_clear_super_receiver (void)
7951 if (objc_method_context
7952 && UOBJC_SUPER_scope
== get_current_scope ()) {
7953 UOBJC_SUPER_decl
= 0;
7954 UOBJC_SUPER_scope
= 0;
7959 objc_expand_function_end (void)
7961 /* This routine may also get called for C functions, including those
7962 nested within ObjC methods. In such cases, method encoding is
7964 if (objc_method_context
== NULL_TREE
7965 || DECL_INITIAL (objc_method_context
) != current_function_decl
)
7968 METHOD_ENCODING (objc_method_context
)
7969 = encode_method_prototype (objc_method_context
);
7973 finish_method_def (void)
7975 lang_expand_function_end
= objc_expand_function_end
;
7976 /* We cannot validly inline ObjC methods, at least not without a language
7977 extension to declare that a method need not be dynamically
7978 dispatched, so suppress all thoughts of doing so. */
7979 DECL_INLINE (current_function_decl
) = 0;
7980 DECL_UNINLINABLE (current_function_decl
) = 1;
7983 lang_expand_function_end
= NULL
;
7985 /* Required to implement _msgSuper. This must be done AFTER finish_function,
7986 since the optimizer may find "may be used before set" errors. */
7987 objc_method_context
= NULL_TREE
;
7992 lang_report_error_function (tree decl
)
7994 if (objc_method_context
)
7996 fprintf (stderr
, "In method `%s'\n",
7997 IDENTIFIER_POINTER (METHOD_SEL_NAME (objc_method_context
)));
8007 is_complex_decl (tree type
)
8009 return (TREE_CODE (type
) == ARRAY_TYPE
8010 || TREE_CODE (type
) == FUNCTION_TYPE
8011 || (TREE_CODE (type
) == POINTER_TYPE
&& ! IS_ID (type
)));
8015 /* Code to convert a decl node into text for a declaration in C. */
8017 static char tmpbuf
[256];
8020 adorn_decl (tree decl
, char *str
)
8022 enum tree_code code
= TREE_CODE (decl
);
8024 if (code
== ARRAY_REF
)
8026 tree an_int_cst
= TREE_OPERAND (decl
, 1);
8028 if (an_int_cst
&& TREE_CODE (an_int_cst
) == INTEGER_CST
)
8029 sprintf (str
+ strlen (str
), "[%ld]",
8030 (long) TREE_INT_CST_LOW (an_int_cst
));
8035 else if (code
== ARRAY_TYPE
)
8037 tree an_int_cst
= TYPE_SIZE (decl
);
8038 tree array_of
= TREE_TYPE (decl
);
8040 if (an_int_cst
&& TREE_CODE (an_int_cst
) == INTEGER_TYPE
)
8041 sprintf (str
+ strlen (str
), "[%ld]",
8042 (long) (TREE_INT_CST_LOW (an_int_cst
)
8043 / TREE_INT_CST_LOW (TYPE_SIZE (array_of
))));
8048 else if (code
== CALL_EXPR
)
8050 tree chain
= TREE_PURPOSE (TREE_OPERAND (decl
, 1));
8055 gen_declaration_1 (chain
, str
);
8056 chain
= TREE_CHAIN (chain
);
8063 else if (code
== FUNCTION_TYPE
)
8065 tree chain
= TYPE_ARG_TYPES (decl
);
8068 while (chain
&& TREE_VALUE (chain
) != void_type_node
)
8070 gen_declaration_1 (TREE_VALUE (chain
), str
);
8071 chain
= TREE_CHAIN (chain
);
8072 if (chain
&& TREE_VALUE (chain
) != void_type_node
)
8078 else if (code
== INDIRECT_REF
)
8080 strcpy (tmpbuf
, "*");
8081 if (TREE_TYPE (decl
) && TREE_CODE (TREE_TYPE (decl
)) == TREE_LIST
)
8085 for (chain
= nreverse (copy_list (TREE_TYPE (decl
)));
8087 chain
= TREE_CHAIN (chain
))
8089 if (TREE_CODE (TREE_VALUE (chain
)) == IDENTIFIER_NODE
)
8091 strcat (tmpbuf
, " ");
8092 strcat (tmpbuf
, IDENTIFIER_POINTER (TREE_VALUE (chain
)));
8096 strcat (tmpbuf
, " ");
8098 strcat (tmpbuf
, str
);
8099 strcpy (str
, tmpbuf
);
8102 else if (code
== POINTER_TYPE
)
8104 strcpy (tmpbuf
, "*");
8105 if (TYPE_READONLY (decl
) || TYPE_VOLATILE (decl
))
8107 if (TYPE_READONLY (decl
))
8108 strcat (tmpbuf
, " const");
8109 if (TYPE_VOLATILE (decl
))
8110 strcat (tmpbuf
, " volatile");
8112 strcat (tmpbuf
, " ");
8114 strcat (tmpbuf
, str
);
8115 strcpy (str
, tmpbuf
);
8120 gen_declarator (tree decl
, char *buf
, const char *name
)
8124 enum tree_code code
= TREE_CODE (decl
);
8134 op
= TREE_OPERAND (decl
, 0);
8136 /* We have a pointer to a function or array...(*)(), (*)[] */
8137 if ((code
== ARRAY_REF
|| code
== CALL_EXPR
)
8138 && op
&& TREE_CODE (op
) == INDIRECT_REF
)
8141 str
= gen_declarator (op
, buf
, name
);
8145 strcpy (tmpbuf
, "(");
8146 strcat (tmpbuf
, str
);
8147 strcat (tmpbuf
, ")");
8148 strcpy (str
, tmpbuf
);
8151 adorn_decl (decl
, str
);
8160 /* This clause is done iteratively rather than recursively. */
8163 op
= (is_complex_decl (TREE_TYPE (decl
))
8164 ? TREE_TYPE (decl
) : NULL_TREE
);
8166 adorn_decl (decl
, str
);
8168 /* We have a pointer to a function or array...(*)(), (*)[] */
8169 if (code
== POINTER_TYPE
8170 && op
&& (TREE_CODE (op
) == FUNCTION_TYPE
8171 || TREE_CODE (op
) == ARRAY_TYPE
))
8173 strcpy (tmpbuf
, "(");
8174 strcat (tmpbuf
, str
);
8175 strcat (tmpbuf
, ")");
8176 strcpy (str
, tmpbuf
);
8179 decl
= (is_complex_decl (TREE_TYPE (decl
))
8180 ? TREE_TYPE (decl
) : NULL_TREE
);
8183 while (decl
&& (code
= TREE_CODE (decl
)))
8188 case IDENTIFIER_NODE
:
8189 /* Will only happen if we are processing a "raw" expr-decl. */
8190 strcpy (buf
, IDENTIFIER_POINTER (decl
));
8201 /* We have an abstract declarator or a _DECL node. */
8209 gen_declspecs (tree declspecs
, char *buf
, int raw
)
8215 for (chain
= nreverse (copy_list (declspecs
));
8216 chain
; chain
= TREE_CHAIN (chain
))
8218 tree aspec
= TREE_VALUE (chain
);
8220 if (TREE_CODE (aspec
) == IDENTIFIER_NODE
)
8221 strcat (buf
, IDENTIFIER_POINTER (aspec
));
8222 else if (TREE_CODE (aspec
) == RECORD_TYPE
)
8224 if (OBJC_TYPE_NAME (aspec
))
8226 tree protocol_list
= TYPE_PROTOCOL_LIST (aspec
);
8228 if (! TREE_STATIC_TEMPLATE (aspec
))
8229 strcat (buf
, "struct ");
8230 strcat (buf
, IDENTIFIER_POINTER (OBJC_TYPE_NAME (aspec
)));
8235 tree chain
= protocol_list
;
8242 (PROTOCOL_NAME (TREE_VALUE (chain
))));
8243 chain
= TREE_CHAIN (chain
);
8252 strcat (buf
, "untagged struct");
8255 else if (TREE_CODE (aspec
) == UNION_TYPE
)
8257 if (OBJC_TYPE_NAME (aspec
))
8259 if (! TREE_STATIC_TEMPLATE (aspec
))
8260 strcat (buf
, "union ");
8261 strcat (buf
, IDENTIFIER_POINTER (OBJC_TYPE_NAME (aspec
)));
8264 strcat (buf
, "untagged union");
8267 else if (TREE_CODE (aspec
) == ENUMERAL_TYPE
)
8269 if (OBJC_TYPE_NAME (aspec
))
8271 if (! TREE_STATIC_TEMPLATE (aspec
))
8272 strcat (buf
, "enum ");
8273 strcat (buf
, IDENTIFIER_POINTER (OBJC_TYPE_NAME (aspec
)));
8276 strcat (buf
, "untagged enum");
8279 else if (TREE_CODE (aspec
) == TYPE_DECL
&& DECL_NAME (aspec
))
8280 strcat (buf
, IDENTIFIER_POINTER (DECL_NAME (aspec
)));
8282 else if (IS_ID (aspec
))
8284 tree protocol_list
= TYPE_PROTOCOL_LIST (aspec
);
8289 tree chain
= protocol_list
;
8296 (PROTOCOL_NAME (TREE_VALUE (chain
))));
8297 chain
= TREE_CHAIN (chain
);
8304 if (TREE_CHAIN (chain
))
8310 /* Type qualifiers. */
8311 if (TYPE_READONLY (declspecs
))
8312 strcat (buf
, "const ");
8313 if (TYPE_VOLATILE (declspecs
))
8314 strcat (buf
, "volatile ");
8316 switch (TREE_CODE (declspecs
))
8318 /* Type specifiers. */
8321 declspecs
= TYPE_MAIN_VARIANT (declspecs
);
8323 /* Signed integer types. */
8325 if (declspecs
== short_integer_type_node
)
8326 strcat (buf
, "short int ");
8327 else if (declspecs
== integer_type_node
)
8328 strcat (buf
, "int ");
8329 else if (declspecs
== long_integer_type_node
)
8330 strcat (buf
, "long int ");
8331 else if (declspecs
== long_long_integer_type_node
)
8332 strcat (buf
, "long long int ");
8333 else if (declspecs
== signed_char_type_node
8334 || declspecs
== char_type_node
)
8335 strcat (buf
, "char ");
8337 /* Unsigned integer types. */
8339 else if (declspecs
== short_unsigned_type_node
)
8340 strcat (buf
, "unsigned short ");
8341 else if (declspecs
== unsigned_type_node
)
8342 strcat (buf
, "unsigned int ");
8343 else if (declspecs
== long_unsigned_type_node
)
8344 strcat (buf
, "unsigned long ");
8345 else if (declspecs
== long_long_unsigned_type_node
)
8346 strcat (buf
, "unsigned long long ");
8347 else if (declspecs
== unsigned_char_type_node
)
8348 strcat (buf
, "unsigned char ");
8352 declspecs
= TYPE_MAIN_VARIANT (declspecs
);
8354 if (declspecs
== float_type_node
)
8355 strcat (buf
, "float ");
8356 else if (declspecs
== double_type_node
)
8357 strcat (buf
, "double ");
8358 else if (declspecs
== long_double_type_node
)
8359 strcat (buf
, "long double ");
8363 if (OBJC_TYPE_NAME (declspecs
)
8364 && TREE_CODE (OBJC_TYPE_NAME (declspecs
)) == IDENTIFIER_NODE
)
8366 tree protocol_list
= TYPE_PROTOCOL_LIST (declspecs
);
8368 if (! TREE_STATIC_TEMPLATE (declspecs
))
8369 strcat (buf
, "struct ");
8370 strcat (buf
, IDENTIFIER_POINTER (OBJC_TYPE_NAME (declspecs
)));
8374 tree chain
= protocol_list
;
8381 (PROTOCOL_NAME (TREE_VALUE (chain
))));
8382 chain
= TREE_CHAIN (chain
);
8391 strcat (buf
, "untagged struct");
8397 if (OBJC_TYPE_NAME (declspecs
)
8398 && TREE_CODE (OBJC_TYPE_NAME (declspecs
)) == IDENTIFIER_NODE
)
8400 strcat (buf
, "union ");
8401 strcat (buf
, IDENTIFIER_POINTER (OBJC_TYPE_NAME (declspecs
)));
8406 strcat (buf
, "untagged union ");
8410 if (OBJC_TYPE_NAME (declspecs
)
8411 && TREE_CODE (OBJC_TYPE_NAME (declspecs
)) == IDENTIFIER_NODE
)
8413 strcat (buf
, "enum ");
8414 strcat (buf
, IDENTIFIER_POINTER (OBJC_TYPE_NAME (declspecs
)));
8419 strcat (buf
, "untagged enum ");
8423 strcat (buf
, "void ");
8428 tree protocol_list
= TYPE_PROTOCOL_LIST (declspecs
);
8433 tree chain
= protocol_list
;
8440 (PROTOCOL_NAME (TREE_VALUE (chain
))));
8441 chain
= TREE_CHAIN (chain
);
8457 /* Given a tree node, produce a printable description of it in the given
8458 buffer, overwriting the buffer. */
8461 gen_declaration (tree atype_or_adecl
, char *buf
)
8464 gen_declaration_1 (atype_or_adecl
, buf
);
8468 /* Given a tree node, append a printable description to the end of the
8472 gen_declaration_1 (tree atype_or_adecl
, char *buf
)
8476 if (TREE_CODE (atype_or_adecl
) == TREE_LIST
)
8478 tree declspecs
; /* "identifier_node", "record_type" */
8479 tree declarator
; /* "array_ref", "indirect_ref", "call_expr"... */
8480 tree width
= NULL_TREE
; /* for bitfields */
8482 /* We have a "raw", abstract declarator (typename). */
8483 declarator
= TREE_VALUE (atype_or_adecl
);
8484 /* In the case of raw ivars, the declarator itself is a list,
8485 and contains bitfield widths. */
8486 if (declarator
&& TREE_CODE (declarator
) == TREE_LIST
)
8488 width
= TREE_VALUE (declarator
);
8489 declarator
= TREE_PURPOSE (declarator
);
8491 declspecs
= TREE_PURPOSE (atype_or_adecl
);
8493 gen_declspecs (declspecs
, buf
, 1);
8497 strcat (buf
, gen_declarator (declarator
, declbuf
, ""));
8500 sprintf (buf
+ strlen (buf
), ": " HOST_WIDE_INT_PRINT_UNSIGNED
,
8501 TREE_INT_CST_LOW (width
));
8507 tree declspecs
; /* "integer_type", "real_type", "record_type"... */
8508 tree declarator
; /* "array_type", "function_type", "pointer_type". */
8510 if (TREE_CODE (atype_or_adecl
) == FIELD_DECL
8511 || TREE_CODE (atype_or_adecl
) == PARM_DECL
8512 || TREE_CODE (atype_or_adecl
) == FUNCTION_DECL
)
8513 atype
= TREE_TYPE (atype_or_adecl
);
8515 /* Assume we have a *_type node. */
8516 atype
= atype_or_adecl
;
8518 if (is_complex_decl (atype
))
8522 /* Get the declaration specifier; it is at the end of the list. */
8523 declarator
= chain
= atype
;
8525 chain
= TREE_TYPE (chain
); /* not TREE_CHAIN (chain); */
8526 while (is_complex_decl (chain
));
8533 declarator
= NULL_TREE
;
8536 gen_declspecs (declspecs
, buf
, 0);
8538 if (TREE_CODE (atype_or_adecl
) == FIELD_DECL
8539 || TREE_CODE (atype_or_adecl
) == PARM_DECL
8540 || TREE_CODE (atype_or_adecl
) == FUNCTION_DECL
)
8542 const char *const decl_name
=
8543 (DECL_NAME (atype_or_adecl
)
8544 ? IDENTIFIER_POINTER (DECL_NAME (atype_or_adecl
)) : "");
8549 strcat (buf
, gen_declarator (declarator
, declbuf
, decl_name
));
8552 else if (decl_name
[0])
8555 strcat (buf
, decl_name
);
8558 else if (declarator
)
8561 strcat (buf
, gen_declarator (declarator
, declbuf
, ""));
8566 #define RAW_TYPESPEC(meth) (TREE_VALUE (TREE_PURPOSE (TREE_TYPE (meth))))
8568 /* Given a method tree, put a printable description into the given
8569 buffer (overwriting) and return a pointer to the buffer. */
8572 gen_method_decl (tree method
, char *buf
)
8577 if (RAW_TYPESPEC (method
) != objc_object_reference
)
8580 gen_declaration_1 (TREE_TYPE (method
), buf
);
8584 chain
= METHOD_SEL_ARGS (method
);
8587 /* We have a chain of keyword_decls. */
8590 if (KEYWORD_KEY_NAME (chain
))
8591 strcat (buf
, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain
)));
8594 if (RAW_TYPESPEC (chain
) != objc_object_reference
)
8597 gen_declaration_1 (TREE_TYPE (chain
), buf
);
8601 strcat (buf
, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain
)));
8602 if ((chain
= TREE_CHAIN (chain
)))
8607 if (METHOD_ADD_ARGS (method
) == objc_ellipsis_node
)
8608 strcat (buf
, ", ...");
8609 else if (METHOD_ADD_ARGS (method
))
8611 /* We have a tree list node as generate by get_parm_info. */
8612 chain
= TREE_PURPOSE (METHOD_ADD_ARGS (method
));
8614 /* Know we have a chain of parm_decls. */
8618 gen_declaration_1 (chain
, buf
);
8619 chain
= TREE_CHAIN (chain
);
8625 /* We have a unary selector. */
8626 strcat (buf
, IDENTIFIER_POINTER (METHOD_SEL_NAME (method
)));
8634 /* Dump an @interface declaration of the supplied class CHAIN to the
8635 supplied file FP. Used to implement the -gen-decls option (which
8636 prints out an @interface declaration of all classes compiled in
8637 this run); potentially useful for debugging the compiler too. */
8639 dump_interface (FILE *fp
, tree chain
)
8641 /* FIXME: A heap overflow here whenever a method (or ivar)
8642 declaration is so long that it doesn't fit in the buffer. The
8643 code and all the related functions should be rewritten to avoid
8644 using fixed size buffers. */
8645 char *buf
= (char *) xmalloc (1024 * 10);
8646 const char *my_name
= IDENTIFIER_POINTER (CLASS_NAME (chain
));
8647 tree ivar_decls
= CLASS_RAW_IVARS (chain
);
8648 tree nst_methods
= CLASS_NST_METHODS (chain
);
8649 tree cls_methods
= CLASS_CLS_METHODS (chain
);
8651 fprintf (fp
, "\n@interface %s", my_name
);
8653 /* CLASS_SUPER_NAME is used to store the superclass name for
8654 classes, and the category name for categories. */
8655 if (CLASS_SUPER_NAME (chain
))
8657 const char *name
= IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain
));
8659 if (TREE_CODE (chain
) == CATEGORY_IMPLEMENTATION_TYPE
8660 || TREE_CODE (chain
) == CATEGORY_INTERFACE_TYPE
)
8662 fprintf (fp
, " (%s)\n", name
);
8666 fprintf (fp
, " : %s\n", name
);
8672 /* FIXME - the following doesn't seem to work at the moment. */
8675 fprintf (fp
, "{\n");
8678 fprintf (fp
, "\t%s;\n", gen_declaration (ivar_decls
, buf
));
8679 ivar_decls
= TREE_CHAIN (ivar_decls
);
8682 fprintf (fp
, "}\n");
8687 fprintf (fp
, "- %s;\n", gen_method_decl (nst_methods
, buf
));
8688 nst_methods
= TREE_CHAIN (nst_methods
);
8693 fprintf (fp
, "+ %s;\n", gen_method_decl (cls_methods
, buf
));
8694 cls_methods
= TREE_CHAIN (cls_methods
);
8697 fprintf (fp
, "@end\n");
8700 /* Demangle function for Objective-C */
8702 objc_demangle (const char *mangled
)
8704 char *demangled
, *cp
;
8706 if (mangled
[0] == '_' &&
8707 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
8710 cp
= demangled
= xmalloc(strlen(mangled
) + 2);
8711 if (mangled
[1] == 'i')
8712 *cp
++ = '-'; /* for instance method */
8714 *cp
++ = '+'; /* for class method */
8715 *cp
++ = '['; /* opening left brace */
8716 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
8717 while (*cp
&& *cp
== '_')
8718 cp
++; /* skip any initial underbars in class name */
8719 cp
= strchr(cp
, '_'); /* find first non-initial underbar */
8722 free(demangled
); /* not mangled name */
8725 if (cp
[1] == '_') /* easy case: no category name */
8727 *cp
++ = ' '; /* replace two '_' with one ' ' */
8728 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
8732 *cp
++ = '('; /* less easy case: category name */
8733 cp
= strchr(cp
, '_');
8736 free(demangled
); /* not mangled name */
8740 *cp
++ = ' '; /* overwriting 1st char of method name... */
8741 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
8743 while (*cp
&& *cp
== '_')
8744 cp
++; /* skip any initial underbars in method name */
8747 *cp
= ':'; /* replace remaining '_' with ':' */
8748 *cp
++ = ']'; /* closing right brace */
8749 *cp
++ = 0; /* string terminator */
8753 return mangled
; /* not an objc mangled name */
8757 objc_printable_name (tree decl
, int kind ATTRIBUTE_UNUSED
)
8759 return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl
)));
8765 gcc_obstack_init (&util_obstack
);
8766 util_firstobj
= (char *) obstack_finish (&util_obstack
);
8768 errbuf
= (char *) xmalloc (BUFSIZE
);
8770 synth_module_prologue ();
8776 struct imp_entry
*impent
;
8778 /* The internally generated initializers appear to have missing braces.
8779 Don't warn about this. */
8780 int save_warn_missing_braces
= warn_missing_braces
;
8781 warn_missing_braces
= 0;
8783 /* A missing @end may not be detected by the parser. */
8784 if (objc_implementation_context
)
8786 warning ("`@end' missing in implementation context");
8787 finish_class (objc_implementation_context
);
8788 objc_ivar_chain
= NULL_TREE
;
8789 objc_implementation_context
= NULL_TREE
;
8792 /* Process the static instances here because initialization of objc_symtab
8794 if (objc_static_instances
)
8795 generate_static_references ();
8797 if (imp_list
|| class_names_chain
8798 || meth_var_names_chain
|| meth_var_types_chain
|| sel_ref_chain
)
8799 generate_objc_symtab_decl ();
8801 for (impent
= imp_list
; impent
; impent
= impent
->next
)
8803 objc_implementation_context
= impent
->imp_context
;
8804 implementation_template
= impent
->imp_template
;
8806 UOBJC_CLASS_decl
= impent
->class_decl
;
8807 UOBJC_METACLASS_decl
= impent
->meta_decl
;
8809 /* Dump the @interface of each class as we compile it, if the
8810 -gen-decls option is in use. TODO: Dump the classes in the
8811 order they were found, rather than in reverse order as we
8813 if (flag_gen_declaration
)
8815 dump_interface (gen_declaration_file
, objc_implementation_context
);
8818 if (TREE_CODE (objc_implementation_context
) == CLASS_IMPLEMENTATION_TYPE
)
8820 /* all of the following reference the string pool... */
8821 generate_ivar_lists ();
8822 generate_dispatch_tables ();
8823 generate_shared_structures ();
8827 generate_dispatch_tables ();
8828 generate_category (objc_implementation_context
);
8832 /* If we are using an array of selectors, we must always
8833 finish up the array decl even if no selectors were used. */
8834 if (! flag_next_runtime
|| sel_ref_chain
)
8835 build_selector_translation_table ();
8838 generate_protocols ();
8840 if (flag_replace_objc_classes
&& imp_list
)
8841 generate_objc_image_info ();
8843 if (objc_implementation_context
|| class_names_chain
|| objc_static_instances
8844 || meth_var_names_chain
|| meth_var_types_chain
|| sel_ref_chain
)
8846 /* Arrange for ObjC data structures to be initialized at run time. */
8847 rtx init_sym
= build_module_descriptor ();
8848 if (init_sym
&& targetm
.have_ctors_dtors
)
8849 (* targetm
.asm_out
.constructor
) (init_sym
, DEFAULT_INIT_PRIORITY
);
8852 /* Dump the class references. This forces the appropriate classes
8853 to be linked into the executable image, preserving unix archive
8854 semantics. This can be removed when we move to a more dynamically
8855 linked environment. */
8857 for (chain
= cls_ref_chain
; chain
; chain
= TREE_CHAIN (chain
))
8859 handle_class_ref (chain
);
8860 if (TREE_PURPOSE (chain
))
8861 generate_classref_translation_entry (chain
);
8864 for (impent
= imp_list
; impent
; impent
= impent
->next
)
8865 handle_impent (impent
);
8867 /* Dump the string table last. */
8869 generate_strings ();
8876 /* Run through the selector hash tables and print a warning for any
8877 selector which has multiple methods. */
8879 for (slot
= 0; slot
< SIZEHASHTABLE
; slot
++)
8881 for (hsh
= cls_method_hash_list
[slot
]; hsh
; hsh
= hsh
->next
)
8882 check_duplicates (hsh
, 0, 1);
8883 for (hsh
= nst_method_hash_list
[slot
]; hsh
; hsh
= hsh
->next
)
8884 check_duplicates (hsh
, 0, 1);
8888 warn_missing_braces
= save_warn_missing_braces
;
8891 /* Subroutines of finish_objc. */
8894 generate_classref_translation_entry (tree chain
)
8896 tree expr
, name
, decl_specs
, decl
, sc_spec
;
8899 type
= TREE_TYPE (TREE_PURPOSE (chain
));
8901 expr
= add_objc_string (TREE_VALUE (chain
), class_names
);
8902 expr
= build_c_cast (type
, expr
); /* cast! */
8904 name
= DECL_NAME (TREE_PURPOSE (chain
));
8906 sc_spec
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_STATIC
]);
8908 /* static struct objc_class * _OBJC_CLASS_REFERENCES_n = ...; */
8909 decl_specs
= tree_cons (NULL_TREE
, type
, sc_spec
);
8911 /* The decl that is returned from start_decl is the one that we
8912 forward declared in build_class_reference. */
8913 decl
= start_decl (name
, decl_specs
, 1, NULL_TREE
);
8914 DECL_CONTEXT (decl
) = NULL_TREE
;
8915 finish_decl (decl
, expr
, NULL_TREE
);
8920 handle_class_ref (tree chain
)
8922 const char *name
= IDENTIFIER_POINTER (TREE_VALUE (chain
));
8923 char *string
= (char *) alloca (strlen (name
) + 30);
8927 sprintf (string
, "%sobjc_class_name_%s",
8928 (flag_next_runtime
? "." : "__"), name
);
8930 #ifdef ASM_DECLARE_UNRESOLVED_REFERENCE
8931 if (flag_next_runtime
)
8933 ASM_DECLARE_UNRESOLVED_REFERENCE (asm_out_file
, string
);
8938 /* Make a decl for this name, so we can use its address in a tree. */
8939 decl
= build_decl (VAR_DECL
, get_identifier (string
), char_type_node
);
8940 DECL_EXTERNAL (decl
) = 1;
8941 TREE_PUBLIC (decl
) = 1;
8944 rest_of_decl_compilation (decl
, 0, 0, 0);
8946 /* Make a decl for the address. */
8947 sprintf (string
, "%sobjc_class_ref_%s",
8948 (flag_next_runtime
? "." : "__"), name
);
8949 exp
= build1 (ADDR_EXPR
, string_type_node
, decl
);
8950 decl
= build_decl (VAR_DECL
, get_identifier (string
), string_type_node
);
8951 DECL_INITIAL (decl
) = exp
;
8952 TREE_STATIC (decl
) = 1;
8953 TREE_USED (decl
) = 1;
8956 rest_of_decl_compilation (decl
, 0, 0, 0);
8960 handle_impent (struct imp_entry
*impent
)
8964 objc_implementation_context
= impent
->imp_context
;
8965 implementation_template
= impent
->imp_template
;
8967 if (TREE_CODE (impent
->imp_context
) == CLASS_IMPLEMENTATION_TYPE
)
8969 const char *const class_name
=
8970 IDENTIFIER_POINTER (CLASS_NAME (impent
->imp_context
));
8972 string
= (char *) alloca (strlen (class_name
) + 30);
8974 sprintf (string
, "%sobjc_class_name_%s",
8975 (flag_next_runtime
? "." : "__"), class_name
);
8977 else if (TREE_CODE (impent
->imp_context
) == CATEGORY_IMPLEMENTATION_TYPE
)
8979 const char *const class_name
=
8980 IDENTIFIER_POINTER (CLASS_NAME (impent
->imp_context
));
8981 const char *const class_super_name
=
8982 IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent
->imp_context
));
8984 string
= (char *) alloca (strlen (class_name
)
8985 + strlen (class_super_name
) + 30);
8987 /* Do the same for categories. Even though no references to
8988 these symbols are generated automatically by the compiler, it
8989 gives you a handle to pull them into an archive by hand. */
8990 sprintf (string
, "*%sobjc_category_name_%s_%s",
8991 (flag_next_runtime
? "." : "__"), class_name
, class_super_name
);
8996 #ifdef ASM_DECLARE_CLASS_REFERENCE
8997 if (flag_next_runtime
)
8999 ASM_DECLARE_CLASS_REFERENCE (asm_out_file
, string
);
9007 init
= build_int_2 (0, 0);
9008 TREE_TYPE (init
) = c_common_type_for_size (BITS_PER_WORD
, 1);
9009 decl
= build_decl (VAR_DECL
, get_identifier (string
), TREE_TYPE (init
));
9010 TREE_PUBLIC (decl
) = 1;
9011 TREE_READONLY (decl
) = 1;
9012 TREE_USED (decl
) = 1;
9013 TREE_CONSTANT (decl
) = 1;
9014 DECL_CONTEXT (decl
) = 0;
9015 DECL_ARTIFICIAL (decl
) = 1;
9016 DECL_INITIAL (decl
) = init
;
9017 assemble_variable (decl
, 1, 0, 0);
9021 /* The Fix-and-Continue functionality available in Mac OS X 10.3 and
9022 later requires that ObjC translation units participating in F&C be
9023 specially marked. The following routine accomplishes this. */
9025 /* static int _OBJC_IMAGE_INFO[2] = { 0, 1 }; */
9028 generate_objc_image_info (void)
9030 tree sc_spec
, decl
, initlist
;
9032 sc_spec
= build_tree_list (NULL_TREE
, ridpointers
[(int) RID_STATIC
]);
9034 = start_decl (get_identifier ("_OBJC_IMAGE_INFO"),
9035 tree_cons (NULL_TREE
,
9038 build_index_type (build_int_2 (1, 0))),
9043 initlist
= build_tree_list (NULL_TREE
, build_int_2 (0, 0));
9044 initlist
= tree_cons (NULL_TREE
, build_int_2 (1, 0), initlist
);
9045 initlist
= build_constructor (TREE_TYPE (decl
), nreverse (initlist
));
9047 TREE_USED (decl
) = DECL_IGNORED_P (decl
) = DECL_ARTIFICIAL (decl
) = 1;
9048 TREE_CONSTANT (initlist
) = TREE_STATIC (initlist
) = 1;
9049 finish_decl (decl
, initlist
, NULL_TREE
);
9052 /* Look up ID as an instance variable. */
9055 lookup_objc_ivar (tree id
)
9059 if (objc_method_context
&& !strcmp (IDENTIFIER_POINTER (id
), "super"))
9060 /* We have a message to super. */
9061 return get_super_receiver ();
9062 else if (objc_method_context
&& (decl
= is_ivar (objc_ivar_chain
, id
)))
9064 if (is_private (decl
))
9067 return build_ivar_reference (id
);
9073 #include "gt-objc-objc-act.h"
9074 #include "gtype-objc.h"