1 /* Implement classes and message passing for Objective C.
2 Copyright (C) 1992-2015 Free Software Foundation, Inc.
3 Contributed by Steve Naroff.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
29 #include "fold-const.h"
30 #include "stringpool.h"
31 #include "stor-layout.h"
35 #include "cp/cp-tree.h"
41 #include "c-family/c-common.h"
42 #include "c-family/c-objc.h"
43 #include "c-family/c-pragma.h"
44 #include "c-family/c-format.h"
46 #include "langhooks.h"
49 #include "hard-reg-set.h"
53 #include "c-family/c-target.h"
54 #include "diagnostic-core.h"
56 #include "plugin-api.h"
59 #include "tree-iterator.h"
60 #include "langhooks-def.h"
61 /* Different initialization, code gen and meta data generation for each
63 #include "objc-runtime-hooks.h"
64 /* Routines used mainly by the runtimes. */
65 #include "objc-runtime-shared-support.h"
66 /* For default_tree_printer (). */
67 #include "tree-pretty-print.h"
69 /* For enum gimplify_status */
70 #include "gimple-expr.h"
73 /* For encode_method_prototype(). */
74 #include "objc-encoding.h"
76 static unsigned int should_call_super_dealloc
= 0;
78 /* When building Objective-C++, we are not linking against the C front-end
79 and so need to replicate the C tree-construction functions in some way. */
81 #define OBJCP_REMAP_FUNCTIONS
82 #include "objcp-decl.h"
85 /* This is the default way of generating a method name. */
86 /* This has the problem that "test_method:argument:" and
87 "test:method_argument:" will generate the same name
88 ("_i_Test__test_method_argument_" for an instance method of the
89 class "Test"), so you can't have them both in the same class!
90 Moreover, the demangling (going from
91 "_i_Test__test_method_argument" back to the original name) is
92 undefined because there are two correct ways of demangling the
94 #ifndef OBJC_GEN_METHOD_LABEL
95 #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
98 sprintf ((BUF), "_%s_%s_%s_%s", \
99 ((IS_INST) ? "i" : "c"), \
101 ((CAT_NAME)? (CAT_NAME) : ""), \
103 for (temp = (BUF); *temp; temp++) \
104 if (*temp == ':') *temp = '_'; \
108 /* These need specifying. */
109 #ifndef OBJC_FORWARDING_STACK_OFFSET
110 #define OBJC_FORWARDING_STACK_OFFSET 0
113 #ifndef OBJC_FORWARDING_MIN_OFFSET
114 #define OBJC_FORWARDING_MIN_OFFSET 0
117 /*** Private Interface (procedures) ***/
120 static void synth_module_prologue (void);
122 /* Code generation. */
124 static tree
start_class (enum tree_code
, tree
, tree
, tree
, tree
);
125 static tree
continue_class (tree
);
126 static void finish_class (tree
);
127 static void start_method_def (tree
, tree
);
129 static tree
start_protocol (enum tree_code
, tree
, tree
, tree
);
130 static tree
build_method_decl (enum tree_code
, tree
, tree
, tree
, bool);
131 static tree
objc_add_method (tree
, tree
, int, bool);
132 static tree
add_instance_variable (tree
, objc_ivar_visibility_kind
, tree
);
133 static tree
build_ivar_reference (tree
);
134 static tree
is_ivar (tree
, tree
);
136 /* We only need the following for ObjC; ObjC++ will use C++'s definition
137 of DERIVED_FROM_P. */
139 static bool objc_derived_from_p (tree
, tree
);
140 #define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD)
144 static void objc_gen_property_data (tree
, tree
);
145 static void objc_synthesize_getter (tree
, tree
, tree
);
146 static void objc_synthesize_setter (tree
, tree
, tree
);
147 static tree
lookup_property (tree
, tree
);
148 static tree
lookup_property_in_list (tree
, tree
);
149 static tree
lookup_property_in_protocol_list (tree
, tree
);
150 static void build_common_objc_property_accessor_helpers (void);
152 static void objc_xref_basetypes (tree
, tree
);
154 static tree
get_class_ivars (tree
, bool);
156 static void build_fast_enumeration_state_template (void);
159 static void objc_generate_cxx_cdtors (void);
163 static void objc_decl_method_attributes (tree
*, tree
, int);
164 static tree
build_keyword_selector (tree
);
166 static void hash_init (void);
168 /* Hash tables to manage the global pool of method prototypes. Each
169 of these maps map a method name (selector) identifier to either a
170 single tree (for methods with a single method prototype) or a
171 TREE_VEC (for methods with multiple method prototypes). */
172 static GTY(()) objc_map_t instance_method_map
= 0;
173 static GTY(()) objc_map_t class_method_map
= 0;
175 /* Hash tables to manage the global pool of class names. */
177 static GTY(()) objc_map_t class_name_map
= 0;
178 static GTY(()) objc_map_t alias_name_map
= 0;
180 static tree
lookup_method (tree
, tree
);
181 static tree
lookup_method_static (tree
, tree
, int);
183 static void interface_hash_init (void);
184 static tree
add_interface (tree
, tree
);
185 static void add_category (tree
, tree
);
186 static inline tree
lookup_category (tree
, tree
);
190 static tree
lookup_protocol (tree
, bool, bool);
191 static tree
lookup_and_install_protocols (tree
, bool);
194 static void really_start_method (tree
, tree
);
196 static void really_start_method (tree
, struct c_arg_info
*);
198 static int comp_proto_with_proto (tree
, tree
, int);
199 static tree
objc_decay_parm_type (tree
);
201 /* Utilities for debugging and error diagnostics. */
203 static char *gen_type_name (tree
);
204 static char *gen_type_name_0 (tree
);
205 static char *gen_method_decl (tree
);
206 static char *gen_declaration (tree
);
208 /* Everything else. */
210 static void generate_struct_by_value_array (void) ATTRIBUTE_NORETURN
;
212 static void mark_referenced_methods (void);
213 static bool objc_type_valid_for_messaging (tree type
, bool allow_classes
);
214 static tree
check_duplicates (tree
, int, int);
216 /*** Private Interface (data) ***/
217 /* Flags for lookup_method_static(). */
219 /* Look for class methods. */
220 #define OBJC_LOOKUP_CLASS 1
221 /* Do not examine superclasses. */
222 #define OBJC_LOOKUP_NO_SUPER 2
223 /* Disable returning an instance method of a root class when a class
224 method can't be found. */
225 #define OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS 4
227 /* The OCTI_... enumeration itself is in objc/objc-act.h. */
228 tree objc_global_trees
[OCTI_MAX
];
230 struct imp_entry
*imp_list
= 0;
231 int imp_count
= 0; /* `@implementation' */
232 int cat_count
= 0; /* `@category' */
234 objc_ivar_visibility_kind objc_ivar_visibility
, objc_default_ivar_visibility
;
236 /* Use to generate method labels. */
237 static int method_slot
= 0;
239 /* Flag to say whether methods in a protocol are optional or
241 static bool objc_method_optional_flag
= false;
243 static int objc_collecting_ivars
= 0;
245 /* Flag that is set to 'true' while we are processing a class
246 extension. Since a class extension just "reopens" the main
247 @interface, this can be used to determine if we are in the main
248 @interface, or in a class extension. */
249 static bool objc_in_class_extension
= false;
251 static char *errbuf
; /* Buffer for error diagnostics */
253 /* An array of all the local variables in the current function that
254 need to be marked as volatile. */
255 vec
<tree
, va_gc
> *local_variables_to_volatilize
= NULL
;
257 /* Store all constructed constant strings in a hash table so that
258 they get uniqued properly. */
260 struct GTY((for_user
)) string_descriptor
{
261 /* The literal argument . */
264 /* The resulting constant string. */
268 struct objc_string_hasher
: ggc_hasher
<string_descriptor
*>
270 static hashval_t
hash (string_descriptor
*);
271 static bool equal (string_descriptor
*, string_descriptor
*);
274 static GTY(()) hash_table
<objc_string_hasher
> *string_htab
;
276 FILE *gen_declaration_file
;
278 /* Hooks for stuff that differs between runtimes. */
279 objc_runtime_hooks runtime
;
281 /* Create a temporary variable of type 'type'. If 'name' is set, uses
282 the specified name, else use no name. Returns the declaration of
283 the type. The 'name' is mostly useful for debugging.
286 objc_create_temporary_var (tree type
, const char *name
)
292 decl
= build_decl (input_location
,
293 VAR_DECL
, get_identifier (name
), type
);
297 decl
= build_decl (input_location
,
298 VAR_DECL
, NULL_TREE
, type
);
300 TREE_USED (decl
) = 1;
301 DECL_ARTIFICIAL (decl
) = 1;
302 DECL_IGNORED_P (decl
) = 1;
303 DECL_CONTEXT (decl
) = current_function_decl
;
308 /* Some platforms pass small structures through registers versus
309 through an invisible pointer. Determine at what size structure is
310 the transition point between the two possibilities. */
313 generate_struct_by_value_array (void)
318 int aggregate_in_mem
[32];
321 /* Presumably no platform passes 32 byte structures in a register. */
322 /* ??? As an example, m64/ppc/Darwin can pass up to 8*long+13*double
324 for (i
= 1; i
< 32; i
++)
329 /* Create an unnamed struct that has `i' character components */
330 type
= objc_start_struct (NULL_TREE
);
332 strcpy (buffer
, "c1");
333 decls
= add_field_decl (char_type_node
, buffer
, &chain
);
335 for (j
= 1; j
< i
; j
++)
337 sprintf (buffer
, "c%d", j
+ 1);
338 add_field_decl (char_type_node
, buffer
, &chain
);
340 objc_finish_struct (type
, decls
);
342 aggregate_in_mem
[i
] = aggregate_value_p (type
, 0);
343 if (!aggregate_in_mem
[i
])
347 /* We found some structures that are returned in registers instead of memory
348 so output the necessary data. */
351 for (i
= 31; i
>= 0; i
--)
352 if (!aggregate_in_mem
[i
])
354 printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n", i
);
365 if (cxx_init () == false)
367 if (c_objc_common_init () == false)
371 /* print_struct_values is triggered by -print-runtime-info (used
372 when building libobjc, with an empty file as input). It does not
373 require any ObjC setup, and it never returns.
375 -fcompare-debug is used to check the compiler output; we are
376 executed twice, once with flag_compare_debug set, and once with
377 it not set. If the flag is used together with
378 -print-runtime-info, we want to print the runtime info only once,
379 else it would be output in duplicate. So we check
380 flag_compare_debug to output it in only one of the invocations.
382 As a side effect, this also that means -fcompare-debug
383 -print-runtime-info will run the compiler twice, and compare the
384 generated assembler file; the first time the compiler exits
385 immediately (producing no file), and the second time it compiles
386 an empty file. This checks, as a side effect, that compiling an
387 empty file produces no assembler output. */
388 if (print_struct_values
&& !flag_compare_debug
)
389 generate_struct_by_value_array ();
391 /* Set up stuff used by FE parser and all runtimes. */
392 errbuf
= XNEWVEC (char, 1024 * 10);
393 interface_hash_init ();
395 objc_encoding_init ();
396 /* ... and then check flags and set-up for the selected runtime ... */
397 if (flag_next_runtime
&& flag_objc_abi
>= 2)
398 ok
= objc_next_runtime_abi_02_init (&runtime
);
399 else if (flag_next_runtime
)
400 ok
= objc_next_runtime_abi_01_init (&runtime
);
402 ok
= objc_gnu_runtime_abi_01_init (&runtime
);
404 /* If that part of the setup failed - bail out immediately. */
408 /* Determine the default visibility for instance variables. */
409 switch (default_ivar_visibility
)
411 case IVAR_VISIBILITY_PRIVATE
:
412 objc_default_ivar_visibility
= OBJC_IVAR_VIS_PRIVATE
;
414 case IVAR_VISIBILITY_PUBLIC
:
415 objc_default_ivar_visibility
= OBJC_IVAR_VIS_PUBLIC
;
417 case IVAR_VISIBILITY_PACKAGE
:
418 objc_default_ivar_visibility
= OBJC_IVAR_VIS_PACKAGE
;
421 objc_default_ivar_visibility
= OBJC_IVAR_VIS_PROTECTED
;
424 /* Generate general types and push runtime-specific decls to file scope. */
425 synth_module_prologue ();
430 /* This is called at the end of parsing by the C/C++ parsers. */
432 objc_write_global_declarations (void)
434 mark_referenced_methods ();
436 /* A missing @end might not be detected by the parser. */
437 if (objc_implementation_context
)
439 warning (0, "%<@end%> missing in implementation context");
440 finish_class (objc_implementation_context
);
441 objc_ivar_chain
= NULL_TREE
;
442 objc_implementation_context
= NULL_TREE
;
447 objc_map_iterator_t i
;
449 objc_map_iterator_initialize (class_method_map
, &i
);
450 while (objc_map_iterator_move_to_next (class_method_map
, &i
))
451 check_duplicates (objc_map_iterator_current_value (class_method_map
, i
), 0, 1);
453 objc_map_iterator_initialize (instance_method_map
, &i
);
454 while (objc_map_iterator_move_to_next (instance_method_map
, &i
))
455 check_duplicates (objc_map_iterator_current_value (instance_method_map
, i
), 0, 0);
458 /* TODO: consider an early exit here if either errorcount or sorrycount
459 is non-zero. Not only is it wasting time to generate the metadata,
460 it needlessly imposes need to re-check for things that are already
461 determined to be errors. */
463 /* Finalize Objective-C runtime data. No need to generate tables
464 and code if only checking syntax, or if generating a PCH file. */
465 if (!flag_syntax_only
&& !pch_file
)
467 location_t saved_location
;
469 /* If gen_declaration desired, open the output file. */
470 if (flag_gen_declaration
)
472 char * const dumpname
= concat (dump_base_name
, ".decl", NULL
);
473 gen_declaration_file
= fopen (dumpname
, "w");
474 if (gen_declaration_file
== 0)
475 fatal_error (input_location
, "can%'t open %s: %m", dumpname
);
479 /* Set the input location to BUILTINS_LOCATION. This is good
480 for error messages, in case any is generated while producing
481 the metadata, but it also silences warnings that would be
482 produced when compiling with -Wpadded in case when padding is
483 automatically added to the built-in runtime data structure
484 declarations. We know about this padding, and it is fine; we
485 don't want users to see any warnings about it if they use
487 saved_location
= input_location
;
488 input_location
= BUILTINS_LOCATION
;
490 /* Compute and emit the meta-data tables for this runtime. */
491 (*runtime
.generate_metadata
) ();
493 /* Restore the original location, just in case it mattered. */
494 input_location
= saved_location
;
496 /* ... and then close any declaration file we opened. */
497 if (gen_declaration_file
)
498 fclose (gen_declaration_file
);
502 /* Return the first occurrence of a method declaration corresponding
503 to sel_name in rproto_list. Search rproto_list recursively.
504 If is_class is 0, search for instance methods, otherwise for class
507 lookup_method_in_protocol_list (tree rproto_list
, tree sel_name
,
512 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
514 p
= TREE_VALUE (rproto
);
517 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
519 /* First, search the @required protocol methods. */
521 m
= lookup_method (PROTOCOL_CLS_METHODS (p
), sel_name
);
523 m
= lookup_method (PROTOCOL_NST_METHODS (p
), sel_name
);
528 /* If still not found, search the @optional protocol methods. */
530 m
= lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (p
), sel_name
);
532 m
= lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (p
), sel_name
);
537 /* If still not found, search the attached protocols. */
538 if (PROTOCOL_LIST (p
))
539 m
= lookup_method_in_protocol_list (PROTOCOL_LIST (p
),
546 ; /* An identifier...if we could not find a protocol. */
554 lookup_protocol_in_reflist (tree rproto_list
, tree lproto
)
558 /* Make sure the protocol is supported by the object on the rhs. */
559 if (TREE_CODE (lproto
) == PROTOCOL_INTERFACE_TYPE
)
562 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
564 p
= TREE_VALUE (rproto
);
566 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
571 else if (PROTOCOL_LIST (p
))
572 fnd
= lookup_protocol_in_reflist (PROTOCOL_LIST (p
), lproto
);
581 ; /* An identifier...if we could not find a protocol. */
588 objc_start_class_interface (tree klass
, tree super_class
,
589 tree protos
, tree attributes
)
591 if (flag_objc1_only
&& attributes
)
592 error_at (input_location
, "class attributes are not available in Objective-C 1.0");
594 objc_interface_context
596 = start_class (CLASS_INTERFACE_TYPE
, klass
, super_class
, protos
, attributes
);
597 objc_ivar_visibility
= objc_default_ivar_visibility
;
601 objc_start_category_interface (tree klass
, tree categ
,
602 tree protos
, tree attributes
)
607 error_at (input_location
, "category attributes are not available in Objective-C 1.0");
609 warning_at (input_location
, OPT_Wattributes
,
610 "category attributes are not available in this version"
611 " of the compiler, (ignored)");
613 if (categ
== NULL_TREE
)
616 error_at (input_location
, "class extensions are not available in Objective-C 1.0");
619 /* Iterate over all the classes and categories implemented
620 up to now in this compilation unit. */
623 for (t
= imp_list
; t
; t
= t
->next
)
625 /* If we find a class @implementation with the same name
626 as the one we are extending, produce an error. */
627 if (TREE_CODE (t
->imp_context
) == CLASS_IMPLEMENTATION_TYPE
628 && IDENTIFIER_POINTER (CLASS_NAME (t
->imp_context
)) == IDENTIFIER_POINTER (klass
))
629 error_at (input_location
,
630 "class extension for class %qE declared after its %<@implementation%>",
635 objc_interface_context
636 = start_class (CATEGORY_INTERFACE_TYPE
, klass
, categ
, protos
, NULL_TREE
);
638 = continue_class (objc_interface_context
);
642 objc_start_protocol (tree name
, tree protos
, tree attributes
)
644 if (flag_objc1_only
&& attributes
)
645 error_at (input_location
, "protocol attributes are not available in Objective-C 1.0");
647 objc_interface_context
648 = start_protocol (PROTOCOL_INTERFACE_TYPE
, name
, protos
, attributes
);
649 objc_method_optional_flag
= false;
653 objc_continue_interface (void)
656 = continue_class (objc_interface_context
);
660 objc_finish_interface (void)
662 finish_class (objc_interface_context
);
663 objc_interface_context
= NULL_TREE
;
664 objc_method_optional_flag
= false;
665 objc_in_class_extension
= false;
669 objc_start_class_implementation (tree klass
, tree super_class
)
671 objc_implementation_context
673 = start_class (CLASS_IMPLEMENTATION_TYPE
, klass
, super_class
, NULL_TREE
,
675 objc_ivar_visibility
= objc_default_ivar_visibility
;
679 objc_start_category_implementation (tree klass
, tree categ
)
681 objc_implementation_context
682 = start_class (CATEGORY_IMPLEMENTATION_TYPE
, klass
, categ
, NULL_TREE
,
685 = continue_class (objc_implementation_context
);
689 objc_continue_implementation (void)
692 = continue_class (objc_implementation_context
);
696 objc_finish_implementation (void)
699 if (flag_objc_call_cxx_cdtors
)
700 objc_generate_cxx_cdtors ();
703 if (objc_implementation_context
)
705 finish_class (objc_implementation_context
);
706 objc_ivar_chain
= NULL_TREE
;
707 objc_implementation_context
= NULL_TREE
;
710 warning (0, "%<@end%> must appear in an @implementation context");
714 objc_set_visibility (objc_ivar_visibility_kind visibility
)
716 if (visibility
== OBJC_IVAR_VIS_PACKAGE
)
719 error ("%<@package%> is not available in Objective-C 1.0");
721 warning (0, "%<@package%> presently has the same effect as %<@public%>");
723 objc_ivar_visibility
= visibility
;
727 objc_set_method_opt (bool optional
)
732 error_at (input_location
, "%<@optional%> is not available in Objective-C 1.0");
734 error_at (input_location
, "%<@required%> is not available in Objective-C 1.0");
737 objc_method_optional_flag
= optional
;
738 if (!objc_interface_context
739 || TREE_CODE (objc_interface_context
) != PROTOCOL_INTERFACE_TYPE
)
742 error ("%<@optional%> is allowed in @protocol context only");
744 error ("%<@required%> is allowed in @protocol context only");
745 objc_method_optional_flag
= false;
749 /* This routine looks for a given PROPERTY in a list of CLASS, CATEGORY, or
752 lookup_property_in_list (tree chain
, tree property
)
755 for (x
= CLASS_PROPERTY_DECL (chain
); x
; x
= TREE_CHAIN (x
))
756 if (PROPERTY_NAME (x
) == property
)
761 /* This routine looks for a given PROPERTY in the tree chain of RPROTO_LIST. */
762 static tree
lookup_property_in_protocol_list (tree rproto_list
, tree property
)
765 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
767 tree p
= TREE_VALUE (rproto
);
768 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
770 if ((x
= lookup_property_in_list (p
, property
)))
772 if (PROTOCOL_LIST (p
))
773 return lookup_property_in_protocol_list (PROTOCOL_LIST (p
), property
);
777 ; /* An identifier...if we could not find a protocol. */
783 /* This routine looks up the PROPERTY in current INTERFACE, its categories and up the
784 chain of interface hierarchy. */
786 lookup_property (tree interface_type
, tree property
)
788 tree inter
= interface_type
;
792 if ((x
= lookup_property_in_list (inter
, property
)))
794 /* Failing that, look for the property in each category of the class. */
796 while ((category
= CLASS_CATEGORY_LIST (category
)))
798 if ((x
= lookup_property_in_list (category
, property
)))
801 /* When checking a category, also check the protocols
802 attached with the category itself. */
803 if (CLASS_PROTOCOL_LIST (category
)
804 && (x
= lookup_property_in_protocol_list
805 (CLASS_PROTOCOL_LIST (category
), property
)))
809 /* Failing to find in categories, look for property in protocol list. */
810 if (CLASS_PROTOCOL_LIST (inter
)
811 && (x
= lookup_property_in_protocol_list
812 (CLASS_PROTOCOL_LIST (inter
), property
)))
815 /* Failing that, climb up the inheritance hierarchy. */
816 inter
= lookup_interface (CLASS_SUPER_NAME (inter
));
821 /* This routine is called by the parser when a
822 @property... declaration is found. 'decl' is the declaration of
823 the property (type/identifier), and the other arguments represent
824 property attributes that may have been specified in the Objective-C
825 declaration. 'parsed_property_readonly' is 'true' if the attribute
826 'readonly' was specified, and 'false' if not; similarly for the
827 other bool parameters. 'parsed_property_getter_ident' is NULL_TREE
828 if the attribute 'getter' was not specified, and is the identifier
829 corresponding to the specified getter if it was; similarly for
830 'parsed_property_setter_ident'. */
832 objc_add_property_declaration (location_t location
, tree decl
,
833 bool parsed_property_readonly
, bool parsed_property_readwrite
,
834 bool parsed_property_assign
, bool parsed_property_retain
,
835 bool parsed_property_copy
, bool parsed_property_nonatomic
,
836 tree parsed_property_getter_ident
, tree parsed_property_setter_ident
)
840 /* 'property_readonly' and 'property_assign_semantics' are the final
841 attributes of the property after all parsed attributes have been
842 considered (eg, if we parsed no 'readonly' and no 'readwrite', ie
843 parsed_property_readonly = false and parsed_property_readwrite =
844 false, then property_readonly will be false because the default
846 bool property_readonly
= false;
847 objc_property_assign_semantics property_assign_semantics
= OBJC_PROPERTY_ASSIGN
;
848 bool property_extension_in_class_extension
= false;
851 error_at (input_location
, "%<@property%> is not available in Objective-C 1.0");
853 if (parsed_property_readonly
&& parsed_property_readwrite
)
855 error_at (location
, "%<readonly%> attribute conflicts with %<readwrite%> attribute");
856 /* In case of conflicting attributes (here and below), after
857 producing an error, we pick one of the attributes and keep
859 property_readonly
= false;
863 if (parsed_property_readonly
)
864 property_readonly
= true;
866 if (parsed_property_readwrite
)
867 property_readonly
= false;
870 if (parsed_property_readonly
&& parsed_property_setter_ident
)
872 error_at (location
, "%<readonly%> attribute conflicts with %<setter%> attribute");
873 property_readonly
= false;
876 if (parsed_property_assign
&& parsed_property_retain
)
878 error_at (location
, "%<assign%> attribute conflicts with %<retain%> attribute");
879 property_assign_semantics
= OBJC_PROPERTY_RETAIN
;
881 else if (parsed_property_assign
&& parsed_property_copy
)
883 error_at (location
, "%<assign%> attribute conflicts with %<copy%> attribute");
884 property_assign_semantics
= OBJC_PROPERTY_COPY
;
886 else if (parsed_property_retain
&& parsed_property_copy
)
888 error_at (location
, "%<retain%> attribute conflicts with %<copy%> attribute");
889 property_assign_semantics
= OBJC_PROPERTY_COPY
;
893 if (parsed_property_assign
)
894 property_assign_semantics
= OBJC_PROPERTY_ASSIGN
;
896 if (parsed_property_retain
)
897 property_assign_semantics
= OBJC_PROPERTY_RETAIN
;
899 if (parsed_property_copy
)
900 property_assign_semantics
= OBJC_PROPERTY_COPY
;
903 if (!objc_interface_context
)
905 error_at (location
, "property declaration not in @interface or @protocol context");
909 /* At this point we know that we are either in an interface, a
910 category, or a protocol. */
912 /* We expect a FIELD_DECL from the parser. Make sure we didn't get
913 something else, as that would confuse the checks below. */
914 if (TREE_CODE (decl
) != FIELD_DECL
)
916 error_at (location
, "invalid property declaration");
920 /* Do some spot-checks for the most obvious invalid types. */
922 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
924 error_at (location
, "property can not be an array");
928 /* The C++/ObjC++ parser seems to reject the ':' for a bitfield when
929 parsing, while the C/ObjC parser accepts it and gives us a
930 FIELD_DECL with a DECL_INITIAL set. So we use the DECL_INITIAL
931 to check for a bitfield when doing ObjC. */
933 if (DECL_INITIAL (decl
))
935 /* A @property is not an actual variable, but it is a way to
936 describe a pair of accessor methods, so its type (which is
937 the type of the return value of the getter and the first
938 argument of the setter) can't be a bitfield (as return values
939 and arguments of functions can not be bitfields). The
940 underlying instance variable could be a bitfield, but that is
941 a different matter. */
942 error_at (location
, "property can not be a bit-field");
947 /* TODO: Check that the property type is an Objective-C object or a
950 /* Implement -Wproperty-assign-default (which is enabled by default). */
951 if (warn_property_assign_default
952 /* If garbage collection is not being used, then 'assign' is
953 valid for objects (and typically used for delegates) but it
954 is wrong in most cases (since most objects need to be
955 retained or copied in setters). Warn users when 'assign' is
957 && property_assign_semantics
== OBJC_PROPERTY_ASSIGN
958 /* Read-only properties are never assigned, so the assignment
959 semantics do not matter in that case. */
960 && !property_readonly
963 /* Please note that it would make sense to default to 'assign'
964 for non-{Objective-C objects}, and to 'retain' for
965 Objective-C objects. But that would break compatibility with
967 if (!parsed_property_assign
&& !parsed_property_retain
&& !parsed_property_copy
)
969 /* Use 'false' so we do not warn for Class objects. */
970 if (objc_type_valid_for_messaging (TREE_TYPE (decl
), false))
972 warning_at (location
,
974 "object property %qD has no %<assign%>, %<retain%> or %<copy%> attribute; assuming %<assign%>",
977 "%<assign%> can be unsafe for Objective-C objects; please state explicitly if you need it");
982 if (property_assign_semantics
== OBJC_PROPERTY_RETAIN
983 && !objc_type_valid_for_messaging (TREE_TYPE (decl
), true))
984 error_at (location
, "%<retain%> attribute is only valid for Objective-C objects");
986 if (property_assign_semantics
== OBJC_PROPERTY_COPY
987 && !objc_type_valid_for_messaging (TREE_TYPE (decl
), true))
988 error_at (location
, "%<copy%> attribute is only valid for Objective-C objects");
990 /* Now determine the final property getter and setter names. They
991 will be stored in the PROPERTY_DECL, from which they'll always be
992 extracted and used. */
994 /* Adjust, or fill in, setter and getter names. We overwrite the
995 parsed_property_setter_ident and parsed_property_getter_ident
996 with the final setter and getter identifiers that will be
998 if (parsed_property_setter_ident
)
1000 /* The setter should be terminated by ':', but the parser only
1001 gives us an identifier without ':'. So, we need to add ':'
1003 const char *parsed_setter
= IDENTIFIER_POINTER (parsed_property_setter_ident
);
1004 size_t length
= strlen (parsed_setter
);
1005 char *final_setter
= (char *)alloca (length
+ 2);
1007 sprintf (final_setter
, "%s:", parsed_setter
);
1008 parsed_property_setter_ident
= get_identifier (final_setter
);
1012 if (!property_readonly
)
1013 parsed_property_setter_ident
= get_identifier (objc_build_property_setter_name
1014 (DECL_NAME (decl
)));
1017 if (!parsed_property_getter_ident
)
1018 parsed_property_getter_ident
= DECL_NAME (decl
);
1020 /* Check for duplicate property declarations. We first check the
1021 immediate context for a property with the same name. Any such
1022 declarations are an error, unless this is a class extension and
1023 we are extending a property from readonly to readwrite. */
1024 for (x
= CLASS_PROPERTY_DECL (objc_interface_context
); x
; x
= TREE_CHAIN (x
))
1026 if (PROPERTY_NAME (x
) == DECL_NAME (decl
))
1028 if (objc_in_class_extension
1029 && property_readonly
== 0
1030 && PROPERTY_READONLY (x
) == 1)
1032 /* This is a class extension, and we are extending an
1033 existing readonly property to a readwrite one.
1035 property_extension_in_class_extension
= true;
1040 location_t original_location
= DECL_SOURCE_LOCATION (x
);
1042 error_at (location
, "redeclaration of property %qD", decl
);
1044 if (original_location
!= UNKNOWN_LOCATION
)
1045 inform (original_location
, "originally specified here");
1051 /* If x is not NULL_TREE, we must be in a class extension and we're
1052 extending a readonly property. In that case, no point in
1053 searching for another declaration. */
1056 /* We now need to check for existing property declarations (in
1057 the superclass, other categories or protocols) and check that
1058 the new declaration is not in conflict with existing
1061 /* Search for a previous, existing declaration of a property
1062 with the same name in superclasses, protocols etc. If one is
1063 found, it will be in the 'x' variable. */
1065 /* Note that, for simplicity, the following may search again the
1066 local context. That's Ok as nothing will be found (else we'd
1067 have thrown an error above); it's only a little inefficient,
1068 but the code is simpler. */
1069 switch (TREE_CODE (objc_interface_context
))
1071 case CLASS_INTERFACE_TYPE
:
1072 /* Look up the property in the current @interface (which
1073 will find nothing), then its protocols and categories and
1075 x
= lookup_property (objc_interface_context
, DECL_NAME (decl
));
1077 case CATEGORY_INTERFACE_TYPE
:
1078 /* Look up the property in the main @interface, then
1079 protocols and categories (one of them is ours, and will
1080 find nothing) and superclasses. */
1081 x
= lookup_property (lookup_interface (CLASS_NAME (objc_interface_context
)),
1084 case PROTOCOL_INTERFACE_TYPE
:
1085 /* Looks up the property in any protocols attached to the
1086 current protocol. */
1087 if (PROTOCOL_LIST (objc_interface_context
))
1089 x
= lookup_property_in_protocol_list (PROTOCOL_LIST (objc_interface_context
),
1100 /* An existing property was found; check that it has the same
1101 types, or it is compatible. */
1102 location_t original_location
= DECL_SOURCE_LOCATION (x
);
1104 if (PROPERTY_NONATOMIC (x
) != parsed_property_nonatomic
)
1106 warning_at (location
, 0,
1107 "'nonatomic' attribute of property %qD conflicts with previous declaration", decl
);
1109 if (original_location
!= UNKNOWN_LOCATION
)
1110 inform (original_location
, "originally specified here");
1114 if (PROPERTY_GETTER_NAME (x
) != parsed_property_getter_ident
)
1116 warning_at (location
, 0,
1117 "'getter' attribute of property %qD conflicts with previous declaration", decl
);
1119 if (original_location
!= UNKNOWN_LOCATION
)
1120 inform (original_location
, "originally specified here");
1124 /* We can only compare the setter names if both the old and new property have a setter. */
1125 if (!property_readonly
&& !PROPERTY_READONLY(x
))
1127 if (PROPERTY_SETTER_NAME (x
) != parsed_property_setter_ident
)
1129 warning_at (location
, 0,
1130 "'setter' attribute of property %qD conflicts with previous declaration", decl
);
1132 if (original_location
!= UNKNOWN_LOCATION
)
1133 inform (original_location
, "originally specified here");
1138 if (PROPERTY_ASSIGN_SEMANTICS (x
) != property_assign_semantics
)
1140 warning_at (location
, 0,
1141 "assign semantics attributes of property %qD conflict with previous declaration", decl
);
1143 if (original_location
!= UNKNOWN_LOCATION
)
1144 inform (original_location
, "originally specified here");
1148 /* It's ok to have a readonly property that becomes a readwrite, but not vice versa. */
1149 if (PROPERTY_READONLY (x
) == 0 && property_readonly
== 1)
1151 warning_at (location
, 0,
1152 "'readonly' attribute of property %qD conflicts with previous declaration", decl
);
1154 if (original_location
!= UNKNOWN_LOCATION
)
1155 inform (original_location
, "originally specified here");
1159 /* We now check that the new and old property declarations have
1160 the same types (or compatible one). In the Objective-C
1161 tradition of loose type checking, we do type-checking but
1162 only generate warnings (not errors) if they do not match.
1163 For non-readonly properties, the types must match exactly;
1164 for readonly properties, it is allowed to use a "more
1165 specialized" type in the new property declaration. Eg, the
1166 superclass has a getter returning (NSArray *) and the
1167 subclass a getter returning (NSMutableArray *). The object's
1168 getter returns an (NSMutableArray *); but if you cast the
1169 object to the superclass, which is allowed, you'd still
1170 expect the getter to return an (NSArray *), which works since
1171 an (NSMutableArray *) is an (NSArray *) too. So, the set of
1172 objects belonging to the type of the new @property should be
1173 a subset of the set of objects belonging to the type of the
1174 old @property. This is what "specialization" means. And the
1175 reason it only applies to readonly properties is that for a
1176 readwrite property the setter would have the opposite
1177 requirement - ie that the superclass type is more specialized
1178 then the subclass one; hence the only way to satisfy both
1179 constraints is that the types match. */
1181 /* If the types are not the same in the C sense, we warn ... */
1182 if (!comptypes (TREE_TYPE (x
), TREE_TYPE (decl
))
1183 /* ... unless the property is readonly, in which case we
1184 allow a new, more specialized, declaration. */
1185 && (!property_readonly
1186 || !objc_compare_types (TREE_TYPE (x
),
1187 TREE_TYPE (decl
), -5, NULL_TREE
)))
1189 warning_at (location
, 0,
1190 "type of property %qD conflicts with previous declaration", decl
);
1191 if (original_location
!= UNKNOWN_LOCATION
)
1192 inform (original_location
, "originally specified here");
1196 /* If we are in a class extension and we're extending a readonly
1197 property in the main @interface, we'll just update the
1198 existing property with the readwrite flag and potentially the
1200 if (property_extension_in_class_extension
)
1202 PROPERTY_READONLY (x
) = 0;
1203 PROPERTY_SETTER_NAME (x
) = parsed_property_setter_ident
;
1208 /* Create a PROPERTY_DECL node. */
1209 property_decl
= make_node (PROPERTY_DECL
);
1211 /* Copy the basic information from the original decl. */
1212 TREE_TYPE (property_decl
) = TREE_TYPE (decl
);
1213 DECL_SOURCE_LOCATION (property_decl
) = DECL_SOURCE_LOCATION (decl
);
1214 TREE_DEPRECATED (property_decl
) = TREE_DEPRECATED (decl
);
1216 /* Add property-specific information. */
1217 PROPERTY_NAME (property_decl
) = DECL_NAME (decl
);
1218 PROPERTY_GETTER_NAME (property_decl
) = parsed_property_getter_ident
;
1219 PROPERTY_SETTER_NAME (property_decl
) = parsed_property_setter_ident
;
1220 PROPERTY_READONLY (property_decl
) = property_readonly
;
1221 PROPERTY_NONATOMIC (property_decl
) = parsed_property_nonatomic
;
1222 PROPERTY_ASSIGN_SEMANTICS (property_decl
) = property_assign_semantics
;
1223 PROPERTY_IVAR_NAME (property_decl
) = NULL_TREE
;
1224 PROPERTY_DYNAMIC (property_decl
) = 0;
1226 /* Remember the fact that the property was found in the @optional
1227 section in a @protocol, or not. */
1228 if (objc_method_optional_flag
)
1229 PROPERTY_OPTIONAL (property_decl
) = 1;
1231 PROPERTY_OPTIONAL (property_decl
) = 0;
1233 /* Note that PROPERTY_GETTER_NAME is always set for all
1234 PROPERTY_DECLs, and PROPERTY_SETTER_NAME is always set for all
1235 PROPERTY_DECLs where PROPERTY_READONLY == 0. Any time we deal
1236 with a getter or setter, we should get the PROPERTY_DECL and use
1237 PROPERTY_GETTER_NAME and PROPERTY_SETTER_NAME to know the correct
1240 /* Add the PROPERTY_DECL to the list of properties for the class. */
1241 TREE_CHAIN (property_decl
) = CLASS_PROPERTY_DECL (objc_interface_context
);
1242 CLASS_PROPERTY_DECL (objc_interface_context
) = property_decl
;
1245 /* This is a subroutine of objc_maybe_build_component_ref. Search the
1246 list of methods in the interface (and, failing that, the local list
1247 in the implementation, and failing that, the protocol list)
1248 provided for a 'setter' or 'getter' for 'component' with default
1249 names (ie, if 'component' is "name", then search for "name" and
1250 "setName:"). It is also possible to specify a different
1251 'getter_name' (this is used for @optional readonly properties). If
1252 any is found, then create an artificial property that uses them.
1253 Return NULL_TREE if 'getter' or 'setter' could not be found. */
1255 maybe_make_artificial_property_decl (tree interface
, tree implementation
,
1256 tree protocol_list
, tree component
, bool is_class
,
1259 tree setter_name
= get_identifier (objc_build_property_setter_name (component
));
1260 tree getter
= NULL_TREE
;
1261 tree setter
= NULL_TREE
;
1263 if (getter_name
== NULL_TREE
)
1264 getter_name
= component
;
1266 /* First, check the @interface and all superclasses. */
1271 /* Using instance methods of the root class as accessors is most
1272 likely unwanted and can be extremely confusing (and, most
1273 importantly, other Objective-C 2.0 compilers do not do it).
1276 flags
= OBJC_LOOKUP_CLASS
| OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS
;
1278 getter
= lookup_method_static (interface
, getter_name
, flags
);
1279 setter
= lookup_method_static (interface
, setter_name
, flags
);
1282 /* Second, check the local @implementation context. */
1283 if (!getter
&& !setter
)
1289 getter
= lookup_method (CLASS_CLS_METHODS (implementation
), getter_name
);
1290 setter
= lookup_method (CLASS_CLS_METHODS (implementation
), setter_name
);
1294 getter
= lookup_method (CLASS_NST_METHODS (implementation
), getter_name
);
1295 setter
= lookup_method (CLASS_NST_METHODS (implementation
), setter_name
);
1300 /* Try the protocol_list if we didn't find anything in the
1301 @interface and in the @implementation. */
1302 if (!getter
&& !setter
)
1304 getter
= lookup_method_in_protocol_list (protocol_list
, getter_name
, is_class
);
1305 setter
= lookup_method_in_protocol_list (protocol_list
, setter_name
, is_class
);
1308 /* There needs to be at least a getter or setter for this to be a
1309 valid 'object.component' syntax. */
1310 if (getter
|| setter
)
1312 /* Yes ... determine the type of the expression. */
1317 type
= TREE_VALUE (TREE_TYPE (getter
));
1319 type
= TREE_VALUE (TREE_TYPE (METHOD_SEL_ARGS (setter
)));
1321 /* Create an artificial property declaration with the
1322 information we collected on the type and getter/setter
1324 property_decl
= make_node (PROPERTY_DECL
);
1326 TREE_TYPE (property_decl
) = type
;
1327 DECL_SOURCE_LOCATION (property_decl
) = input_location
;
1328 TREE_DEPRECATED (property_decl
) = 0;
1329 DECL_ARTIFICIAL (property_decl
) = 1;
1331 /* Add property-specific information. Note that one of
1332 PROPERTY_GETTER_NAME or PROPERTY_SETTER_NAME may refer to a
1333 non-existing method; this will generate an error when the
1334 expression is later compiled. At this stage we don't know if
1335 the getter or setter will be used, so we can't generate an
1337 PROPERTY_NAME (property_decl
) = component
;
1338 PROPERTY_GETTER_NAME (property_decl
) = getter_name
;
1339 PROPERTY_SETTER_NAME (property_decl
) = setter_name
;
1340 PROPERTY_READONLY (property_decl
) = 0;
1341 PROPERTY_NONATOMIC (property_decl
) = 0;
1342 PROPERTY_ASSIGN_SEMANTICS (property_decl
) = 0;
1343 PROPERTY_IVAR_NAME (property_decl
) = NULL_TREE
;
1344 PROPERTY_DYNAMIC (property_decl
) = 0;
1345 PROPERTY_OPTIONAL (property_decl
) = 0;
1348 PROPERTY_HAS_NO_GETTER (property_decl
) = 1;
1350 /* The following is currently unused, but it's nice to have
1351 there. We may use it if we need in the future. */
1353 PROPERTY_HAS_NO_SETTER (property_decl
) = 1;
1355 return property_decl
;
1361 /* This hook routine is invoked by the parser when an expression such
1362 as 'xxx.yyy' is parsed. We get a chance to process these
1363 expressions in a way that is specified to Objective-C (to implement
1364 the Objective-C 2.0 dot-syntax, properties, or non-fragile ivars).
1365 If the expression is not an Objective-C specified expression, we
1366 should return NULL_TREE; else we return the expression.
1368 At the moment this only implements dot-syntax and properties (not
1369 non-fragile ivars yet), ie 'object.property' or 'object.component'
1370 where 'component' is not a declared property, but a valid getter or
1371 setter for it could be found. */
1373 objc_maybe_build_component_ref (tree object
, tree property_ident
)
1378 /* If we are in Objective-C 1.0 mode, dot-syntax and properties are
1380 if (flag_objc1_only
)
1383 /* Try to determine if 'object' is an Objective-C object or not. If
1385 if (object
== NULL_TREE
|| object
== error_mark_node
1386 || (rtype
= TREE_TYPE (object
)) == NULL_TREE
)
1389 if (property_ident
== NULL_TREE
|| property_ident
== error_mark_node
1390 || TREE_CODE (property_ident
) != IDENTIFIER_NODE
)
1393 /* The following analysis of 'object' is similar to the one used for
1394 the 'receiver' of a method invocation. We need to determine what
1395 'object' is and find the appropriate property (either declared,
1396 or artificial) for it (in the same way as we need to find the
1397 appropriate method prototype for a method invocation). There are
1398 some simplifications here though: "object.property" is invalid if
1399 "object" has a type of "id" or "Class"; it must at least have a
1400 protocol attached to it, and "object" is never a class name as
1401 that is done by objc_build_class_component_ref. Finally, we
1402 don't know if this really is a dot-syntax expression, so we want
1403 to make a quick exit if it is not; for this reason, we try to
1404 postpone checks after determining that 'object' looks like an
1405 Objective-C object. */
1407 if (objc_is_id (rtype
))
1409 /* This is the case that the 'object' is of type 'id' or
1412 /* Check if at least it is of type 'id <Protocol>' or 'Class
1413 <Protocol>'; if so, look the property up in the
1415 if (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype
)))
1417 tree rprotos
= TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype
));
1421 /* No point looking up declared @properties if we are
1422 dealing with a class. Classes have no declared
1424 if (!IS_CLASS (rtype
))
1425 x
= lookup_property_in_protocol_list (rprotos
, property_ident
);
1429 /* Ok, no property. Maybe it was an
1430 object.component dot-syntax without a declared
1431 property (this is valid for classes too). Look
1432 for getter/setter methods and internally declare
1433 an artificial property based on them if found. */
1434 x
= maybe_make_artificial_property_decl (NULL_TREE
,
1441 else if (PROPERTY_OPTIONAL (x
) && PROPERTY_READONLY (x
))
1443 /* This is a special, complicated case. If the
1444 property is optional, and is read-only, then the
1445 property is always used for reading, but an
1446 eventual existing non-property setter can be used
1447 for writing. We create an artificial property
1448 decl copying the getter from the optional
1449 property, and looking up the setter in the
1451 x
= maybe_make_artificial_property_decl (NULL_TREE
,
1456 PROPERTY_GETTER_NAME (x
));
1460 else if (objc_method_context
)
1462 /* Else, if we are inside a method it could be the case of
1463 'super' or 'self'. */
1464 tree interface_type
= NULL_TREE
;
1466 while (TREE_CODE (t
) == COMPOUND_EXPR
1467 || TREE_CODE (t
) == MODIFY_EXPR
1468 || CONVERT_EXPR_P (t
)
1469 || TREE_CODE (t
) == COMPONENT_REF
)
1470 t
= TREE_OPERAND (t
, 0);
1472 if (t
== UOBJC_SUPER_decl
)
1473 interface_type
= lookup_interface (CLASS_SUPER_NAME (implementation_template
));
1474 else if (t
== self_decl
)
1475 interface_type
= lookup_interface (CLASS_NAME (implementation_template
));
1479 if (TREE_CODE (objc_method_context
) != CLASS_METHOD_DECL
)
1480 x
= lookup_property (interface_type
, property_ident
);
1484 /* Try the dot-syntax without a declared property.
1485 If this is an access to 'self', it is possible
1486 that they may refer to a setter/getter that is
1487 not declared in the interface, but exists locally
1488 in the implementation. In that case, get the
1489 implementation context and use it. */
1490 tree implementation
= NULL_TREE
;
1493 implementation
= objc_implementation_context
;
1495 x
= maybe_make_artificial_property_decl
1496 (interface_type
, implementation
, NULL_TREE
,
1498 (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
),
1501 else if (PROPERTY_OPTIONAL (x
) && PROPERTY_READONLY (x
))
1503 tree implementation
= NULL_TREE
;
1506 implementation
= objc_implementation_context
;
1508 x
= maybe_make_artificial_property_decl (interface_type
,
1513 PROPERTY_GETTER_NAME (x
));
1520 /* This is the case where we have more information on 'rtype'. */
1521 tree basetype
= TYPE_MAIN_VARIANT (rtype
);
1523 /* Skip the pointer - if none, it's not an Objective-C object or
1525 if (basetype
!= NULL_TREE
&& TREE_CODE (basetype
) == POINTER_TYPE
)
1526 basetype
= TREE_TYPE (basetype
);
1530 /* Traverse typedefs. */
1531 while (basetype
!= NULL_TREE
1532 && TREE_CODE (basetype
) == RECORD_TYPE
1533 && OBJC_TYPE_NAME (basetype
)
1534 && TREE_CODE (OBJC_TYPE_NAME (basetype
)) == TYPE_DECL
1535 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype
)))
1536 basetype
= DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype
));
1538 if (basetype
!= NULL_TREE
&& TYPED_OBJECT (basetype
))
1540 tree interface_type
= TYPE_OBJC_INTERFACE (basetype
);
1541 tree protocol_list
= TYPE_OBJC_PROTOCOL_LIST (basetype
);
1544 && (TREE_CODE (interface_type
) == CLASS_INTERFACE_TYPE
1545 || TREE_CODE (interface_type
) == CATEGORY_INTERFACE_TYPE
1546 || TREE_CODE (interface_type
) == PROTOCOL_INTERFACE_TYPE
))
1548 /* Not sure 'rtype' could ever be a class here! Just
1549 for safety we keep the checks. */
1550 if (!IS_CLASS (rtype
))
1552 x
= lookup_property (interface_type
, property_ident
);
1555 x
= lookup_property_in_protocol_list (protocol_list
,
1561 /* Try the dot-syntax without a declared property.
1562 If we are inside a method implementation, it is
1563 possible that they may refer to a setter/getter
1564 that is not declared in the interface, but exists
1565 locally in the implementation. In that case, get
1566 the implementation context and use it. */
1567 tree implementation
= NULL_TREE
;
1569 if (objc_implementation_context
1570 && CLASS_NAME (objc_implementation_context
)
1571 == OBJC_TYPE_NAME (interface_type
))
1572 implementation
= objc_implementation_context
;
1574 x
= maybe_make_artificial_property_decl (interface_type
,
1581 else if (PROPERTY_OPTIONAL (x
) && PROPERTY_READONLY (x
))
1583 tree implementation
= NULL_TREE
;
1585 if (objc_implementation_context
1586 && CLASS_NAME (objc_implementation_context
)
1587 == OBJC_TYPE_NAME (interface_type
))
1588 implementation
= objc_implementation_context
;
1590 x
= maybe_make_artificial_property_decl (interface_type
,
1595 PROPERTY_GETTER_NAME (x
));
1605 tree deprecated_method_prototype
= NULL_TREE
;
1607 /* We have an additional nasty problem here; if this
1608 PROPERTY_REF needs to become a 'getter', then the conversion
1609 from PROPERTY_REF into a getter call happens in gimplify,
1610 after the selector table has already been generated and when
1611 it is too late to add another selector to it. To work around
1612 the problem, we always create the getter call at this stage,
1613 which puts the selector in the table. Note that if the
1614 PROPERTY_REF becomes a 'setter' instead of a 'getter', then
1615 we have added a selector too many to the selector table.
1616 This is a little inefficient.
1618 Also note that method calls to 'self' and 'super' require the
1619 context (self_decl, UOBJS_SUPER_decl,
1620 objc_implementation_context etc) to be built correctly; this
1621 is yet another reason why building the call at the gimplify
1622 stage (when this context has been lost) is not very
1623 practical. If we build it at this stage, we know it will
1624 always be built correctly.
1626 If the PROPERTY_HAS_NO_GETTER() (ie, it is an artificial
1627 property decl created to deal with a dotsyntax not really
1628 referring to an existing property) then do not try to build a
1629 call to the getter as there is no getter. */
1630 if (PROPERTY_HAS_NO_GETTER (x
))
1631 getter_call
= NULL_TREE
;
1633 getter_call
= objc_finish_message_expr
1634 (object
, PROPERTY_GETTER_NAME (x
), NULL_TREE
,
1635 /* Disable the immediate deprecation warning if the getter
1636 is deprecated, but record the fact that the getter is
1637 deprecated by setting PROPERTY_REF_DEPRECATED_GETTER to
1638 the method prototype. */
1639 &deprecated_method_prototype
);
1641 expression
= build4 (PROPERTY_REF
, TREE_TYPE(x
), object
, x
, getter_call
,
1642 deprecated_method_prototype
);
1643 SET_EXPR_LOCATION (expression
, input_location
);
1644 TREE_SIDE_EFFECTS (expression
) = 1;
1652 /* This hook routine is invoked by the parser when an expression such
1653 as 'xxx.yyy' is parsed, and 'xxx' is a class name. This is the
1654 Objective-C 2.0 dot-syntax applied to classes, so we need to
1655 convert it into a setter/getter call on the class. */
1657 objc_build_class_component_ref (tree class_name
, tree property_ident
)
1662 if (flag_objc1_only
)
1663 error_at (input_location
, "the dot syntax is not available in Objective-C 1.0");
1665 if (class_name
== NULL_TREE
|| class_name
== error_mark_node
1666 || TREE_CODE (class_name
) != IDENTIFIER_NODE
)
1667 return error_mark_node
;
1669 if (property_ident
== NULL_TREE
|| property_ident
== error_mark_node
1670 || TREE_CODE (property_ident
) != IDENTIFIER_NODE
)
1673 object
= objc_get_class_reference (class_name
);
1676 /* We know that 'class_name' is an Objective-C class name as the
1677 parser won't call this function if it is not. This is only a
1678 double-check for safety. */
1679 error_at (input_location
, "could not find class %qE", class_name
);
1680 return error_mark_node
;
1683 rtype
= lookup_interface (class_name
);
1686 /* Again, this should never happen, but we do check. */
1687 error_at (input_location
, "could not find interface for class %qE", class_name
);
1688 return error_mark_node
;
1692 if (TREE_DEPRECATED (rtype
))
1693 warning (OPT_Wdeprecated_declarations
, "class %qE is deprecated", class_name
);
1696 x
= maybe_make_artificial_property_decl (rtype
, NULL_TREE
, NULL_TREE
,
1704 tree deprecated_method_prototype
= NULL_TREE
;
1706 if (PROPERTY_HAS_NO_GETTER (x
))
1707 getter_call
= NULL_TREE
;
1709 getter_call
= objc_finish_message_expr
1710 (object
, PROPERTY_GETTER_NAME (x
), NULL_TREE
,
1711 &deprecated_method_prototype
);
1713 expression
= build4 (PROPERTY_REF
, TREE_TYPE(x
), object
, x
, getter_call
,
1714 deprecated_method_prototype
);
1715 SET_EXPR_LOCATION (expression
, input_location
);
1716 TREE_SIDE_EFFECTS (expression
) = 1;
1722 error_at (input_location
, "could not find setter/getter for %qE in class %qE",
1723 property_ident
, class_name
);
1724 return error_mark_node
;
1732 /* This is used because we don't want to expose PROPERTY_REF to the
1733 C/C++ frontends. Maybe we should! */
1735 objc_is_property_ref (tree node
)
1737 if (node
&& TREE_CODE (node
) == PROPERTY_REF
)
1743 /* This function builds a setter call for a PROPERTY_REF (real, for a
1744 declared property, or artificial, for a dot-syntax accessor which
1745 is not corresponding to a property). 'lhs' must be a PROPERTY_REF
1746 (the caller must check this beforehand). 'rhs' is the value to
1747 assign to the property. A plain setter call is returned, or
1748 error_mark_node if the property is readonly. */
1751 objc_build_setter_call (tree lhs
, tree rhs
)
1753 tree object_expr
= PROPERTY_REF_OBJECT (lhs
);
1754 tree property_decl
= PROPERTY_REF_PROPERTY_DECL (lhs
);
1756 if (PROPERTY_READONLY (property_decl
))
1758 error ("readonly property can not be set");
1759 return error_mark_node
;
1763 tree setter_argument
= build_tree_list (NULL_TREE
, rhs
);
1766 /* TODO: Check that the setter return type is 'void'. */
1768 /* TODO: Decay arguments in C. */
1769 setter
= objc_finish_message_expr (object_expr
,
1770 PROPERTY_SETTER_NAME (property_decl
),
1771 setter_argument
, NULL
);
1775 /* Unreachable, but the compiler may not realize. */
1776 return error_mark_node
;
1779 /* This hook routine is called when a MODIFY_EXPR is being built. We
1780 check what is being modified; if it is a PROPERTY_REF, we need to
1781 generate a 'setter' function call for the property. If this is not
1782 a PROPERTY_REF, we return NULL_TREE and the C/C++ frontend will go
1783 on creating their MODIFY_EXPR.
1785 This is used for example if you write
1789 where 'count' is a property. The left-hand side creates a
1790 PROPERTY_REF, and then the compiler tries to generate a MODIFY_EXPR
1791 to assign something to it. We intercept that here, and generate a
1792 call to the 'setter' method instead. */
1794 objc_maybe_build_modify_expr (tree lhs
, tree rhs
)
1796 if (lhs
&& TREE_CODE (lhs
) == PROPERTY_REF
)
1798 /* Building a simple call to the setter method would work for cases such as
1802 but wouldn't work for cases such as
1804 count = object2.count = 1;
1806 to get these to work with very little effort, we build a
1807 compound statement which does the setter call (to set the
1808 property to 'rhs'), but which can also be evaluated returning
1809 the 'rhs'. If the 'rhs' has no side effects, we can simply
1810 evaluate it twice, building
1812 ([object setProperty: rhs]; rhs)
1814 If it has side effects, we put it in a temporary variable first,
1815 so we create the following:
1817 (temp = rhs; [object setProperty: temp]; temp)
1819 setter_argument is rhs in the first case, and temp in the second
1822 tree setter_argument
;
1824 /* s1, s2 and s3 are the tree statements that we need in the
1825 compound expression. */
1826 tree s1
, s2
, s3
, compound_expr
;
1828 if (TREE_SIDE_EFFECTS (rhs
))
1832 /* Declare __objc_property_temp in a local bind. */
1833 setter_argument
= objc_create_temporary_var (TREE_TYPE (rhs
), "__objc_property_temp");
1834 DECL_SOURCE_LOCATION (setter_argument
) = input_location
;
1835 bind
= build3 (BIND_EXPR
, void_type_node
, setter_argument
, NULL
, NULL
);
1836 SET_EXPR_LOCATION (bind
, input_location
);
1837 TREE_SIDE_EFFECTS (bind
) = 1;
1841 s1
= build_modify_expr (input_location
, setter_argument
, NULL_TREE
,
1843 input_location
, rhs
, NULL_TREE
);
1844 SET_EXPR_LOCATION (s1
, input_location
);
1849 setter_argument
= rhs
;
1853 /* Now build the compound statement. */
1855 /* s2: [object setProperty: x] */
1856 s2
= objc_build_setter_call (lhs
, setter_argument
);
1858 /* This happens if building the setter failed because the
1859 property is readonly. */
1860 if (s2
== error_mark_node
)
1861 return error_mark_node
;
1863 SET_EXPR_LOCATION (s2
, input_location
);
1866 s3
= convert (TREE_TYPE (lhs
), setter_argument
);
1868 /* Now build the compound statement (s1, s2, s3) or (s2, s3) as
1871 compound_expr
= build_compound_expr (input_location
, build_compound_expr (input_location
, s1
, s2
), s3
);
1873 compound_expr
= build_compound_expr (input_location
, s2
, s3
);
1875 /* Without this, with -Wall you get a 'valued computed is not
1876 used' every time there is a "object.property = x" where the
1877 value of the resulting MODIFY_EXPR is not used. That is
1878 correct (maybe a more sophisticated implementation could
1879 avoid generating the compound expression if not needed), but
1880 we need to turn it off. */
1881 TREE_NO_WARNING (compound_expr
) = 1;
1882 return compound_expr
;
1888 /* This hook is called by the frontend when one of the four unary
1889 expressions PREINCREMENT_EXPR, POSTINCREMENT_EXPR,
1890 PREDECREMENT_EXPR and POSTDECREMENT_EXPR is being built with an
1891 argument which is a PROPERTY_REF. For example, this happens if you have
1895 where 'count' is a property. We need to use the 'getter' and
1896 'setter' for the property in an appropriate way to build the
1897 appropriate expression. 'code' is the code for the expression (one
1898 of the four mentioned above); 'argument' is the PROPERTY_REF, and
1899 'increment' is how much we need to add or subtract. */
1901 objc_build_incr_expr_for_property_ref (location_t location
,
1902 enum tree_code code
,
1903 tree argument
, tree increment
)
1905 /* Here are the expressions that we want to build:
1907 For PREINCREMENT_EXPR / PREDECREMENT_EXPR:
1908 (temp = [object property] +/- increment, [object setProperty: temp], temp)
1910 For POSTINCREMENT_EXPR / POSTECREMENT_EXPR:
1911 (temp = [object property], [object setProperty: temp +/- increment], temp) */
1913 tree temp_variable_decl
, bind
;
1914 /* s1, s2 and s3 are the tree statements that we need in the
1915 compound expression. */
1916 tree s1
, s2
, s3
, compound_expr
;
1919 if (!argument
|| TREE_CODE (argument
) != PROPERTY_REF
)
1920 return error_mark_node
;
1922 /* Declare __objc_property_temp in a local bind. */
1923 temp_variable_decl
= objc_create_temporary_var (TREE_TYPE (argument
), "__objc_property_temp");
1924 DECL_SOURCE_LOCATION (temp_variable_decl
) = location
;
1925 bind
= build3 (BIND_EXPR
, void_type_node
, temp_variable_decl
, NULL
, NULL
);
1926 SET_EXPR_LOCATION (bind
, location
);
1927 TREE_SIDE_EFFECTS (bind
) = 1;
1930 /* Now build the compound statement. */
1932 /* Note that the 'getter' is generated at gimplify time; at this
1933 time, we can simply put the property_ref (ie, argument) wherever
1934 we want the getter ultimately to be. */
1936 /* s1: __objc_property_temp = [object property] <+/- increment> */
1939 case PREINCREMENT_EXPR
:
1940 /* __objc_property_temp = [object property] + increment */
1941 s1
= build_modify_expr (location
, temp_variable_decl
, NULL_TREE
,
1943 location
, build2 (PLUS_EXPR
, TREE_TYPE (argument
),
1944 argument
, increment
), NULL_TREE
);
1946 case PREDECREMENT_EXPR
:
1947 /* __objc_property_temp = [object property] - increment */
1948 s1
= build_modify_expr (location
, temp_variable_decl
, NULL_TREE
,
1950 location
, build2 (MINUS_EXPR
, TREE_TYPE (argument
),
1951 argument
, increment
), NULL_TREE
);
1953 case POSTINCREMENT_EXPR
:
1954 case POSTDECREMENT_EXPR
:
1955 /* __objc_property_temp = [object property] */
1956 s1
= build_modify_expr (location
, temp_variable_decl
, NULL_TREE
,
1958 location
, argument
, NULL_TREE
);
1964 /* s2: [object setProperty: __objc_property_temp <+/- increment>] */
1967 case PREINCREMENT_EXPR
:
1968 case PREDECREMENT_EXPR
:
1969 /* [object setProperty: __objc_property_temp] */
1970 s2
= objc_build_setter_call (argument
, temp_variable_decl
);
1972 case POSTINCREMENT_EXPR
:
1973 /* [object setProperty: __objc_property_temp + increment] */
1974 s2
= objc_build_setter_call (argument
,
1975 build2 (PLUS_EXPR
, TREE_TYPE (argument
),
1976 temp_variable_decl
, increment
));
1978 case POSTDECREMENT_EXPR
:
1979 /* [object setProperty: __objc_property_temp - increment] */
1980 s2
= objc_build_setter_call (argument
,
1981 build2 (MINUS_EXPR
, TREE_TYPE (argument
),
1982 temp_variable_decl
, increment
));
1988 /* This happens if building the setter failed because the property
1990 if (s2
== error_mark_node
)
1991 return error_mark_node
;
1993 SET_EXPR_LOCATION (s2
, location
);
1995 /* s3: __objc_property_temp */
1996 s3
= convert (TREE_TYPE (argument
), temp_variable_decl
);
1998 /* Now build the compound statement (s1, s2, s3) */
1999 compound_expr
= build_compound_expr (location
, build_compound_expr (location
, s1
, s2
), s3
);
2001 /* Prevent C++ from warning with -Wall that "right operand of comma
2002 operator has no effect". */
2003 TREE_NO_WARNING (compound_expr
) = 1;
2004 return compound_expr
;
2008 objc_build_method_signature (bool is_class_method
, tree rettype
, tree selector
,
2009 tree optparms
, bool ellipsis
)
2011 if (is_class_method
)
2012 return build_method_decl (CLASS_METHOD_DECL
, rettype
, selector
,
2013 optparms
, ellipsis
);
2015 return build_method_decl (INSTANCE_METHOD_DECL
, rettype
, selector
,
2016 optparms
, ellipsis
);
2020 objc_add_method_declaration (bool is_class_method
, tree decl
, tree attributes
)
2022 if (!objc_interface_context
)
2024 /* PS: At the moment, due to how the parser works, it should be
2025 impossible to get here. But it's good to have the check in
2026 case the parser changes.
2028 fatal_error (input_location
,
2029 "method declaration not in @interface context");
2032 if (flag_objc1_only
&& attributes
)
2033 error_at (input_location
, "method attributes are not available in Objective-C 1.0");
2035 objc_decl_method_attributes (&decl
, attributes
, 0);
2036 objc_add_method (objc_interface_context
,
2039 objc_method_optional_flag
);
2042 /* Return 'true' if the method definition could be started, and
2043 'false' if not (because we are outside an @implementation context).
2044 EXPR is NULL or an expression that needs to be evaluated for the
2045 side effects of array size expressions in the parameters.
2048 objc_start_method_definition (bool is_class_method
, tree decl
, tree attributes
,
2051 if (!objc_implementation_context
)
2053 error ("method definition not in @implementation context");
2057 if (decl
!= NULL_TREE
&& METHOD_SEL_NAME (decl
) == error_mark_node
)
2061 /* Indicate no valid break/continue context by setting these variables
2062 to some non-null, non-label value. We'll notice and emit the proper
2063 error message in c_finish_bc_stmt. */
2064 c_break_label
= c_cont_label
= size_zero_node
;
2068 warning_at (input_location
, 0, "method attributes can not be specified in @implementation context");
2070 objc_decl_method_attributes (&decl
, attributes
, 0);
2072 objc_add_method (objc_implementation_context
,
2075 /* is optional */ false);
2076 start_method_def (decl
, expr
);
2081 objc_add_instance_variable (tree decl
)
2083 (void) add_instance_variable (objc_ivar_context
,
2084 objc_ivar_visibility
,
2088 /* Construct a C struct with same name as KLASS, a base struct with tag
2089 SUPER_NAME (if any), and FIELDS indicated. */
2092 objc_build_struct (tree klass
, tree fields
, tree super_name
)
2094 tree name
= CLASS_NAME (klass
);
2095 tree s
= objc_start_struct (name
);
2096 tree super
= (super_name
? xref_tag (RECORD_TYPE
, super_name
) : NULL_TREE
);
2098 vec
<tree
> objc_info
= vNULL
;
2103 /* Prepend a packed variant of the base class into the layout. This
2104 is necessary to preserve ObjC ABI compatibility. */
2105 tree base
= build_decl (input_location
,
2106 FIELD_DECL
, NULL_TREE
, super
);
2107 tree field
= TYPE_FIELDS (super
);
2109 while (field
&& DECL_CHAIN (field
)
2110 && TREE_CODE (DECL_CHAIN (field
)) == FIELD_DECL
)
2111 field
= DECL_CHAIN (field
);
2113 /* For ObjC ABI purposes, the "packed" size of a base class is
2114 the sum of the offset and the size (in bits) of the last field
2117 = (field
&& TREE_CODE (field
) == FIELD_DECL
2118 ? size_binop (PLUS_EXPR
,
2119 size_binop (PLUS_EXPR
,
2122 convert (bitsizetype
,
2123 DECL_FIELD_OFFSET (field
)),
2124 bitsize_int (BITS_PER_UNIT
)),
2125 DECL_FIELD_BIT_OFFSET (field
)),
2127 : bitsize_zero_node
);
2128 DECL_SIZE_UNIT (base
)
2129 = size_binop (FLOOR_DIV_EXPR
, convert (sizetype
, DECL_SIZE (base
)),
2130 size_int (BITS_PER_UNIT
));
2131 DECL_ARTIFICIAL (base
) = 1;
2132 DECL_ALIGN (base
) = 1;
2133 DECL_FIELD_CONTEXT (base
) = s
;
2135 DECL_FIELD_IS_BASE (base
) = 1;
2138 TREE_NO_WARNING (fields
) = 1; /* Suppress C++ ABI warnings -- we */
2139 #endif /* are following the ObjC ABI here. */
2140 DECL_CHAIN (base
) = fields
;
2144 /* NB: Calling finish_struct() may cause type TYPE_OBJC_INFO
2145 information in all variants of this RECORD_TYPE to be destroyed
2146 (this is because the C frontend manipulates TYPE_LANG_SPECIFIC
2147 for something else and then will change all variants to use the
2148 same resulting TYPE_LANG_SPECIFIC, ignoring the fact that we use
2149 it for ObjC protocols and that such propagation will make all
2150 variants use the same objc_info), but it is therein that we store
2151 protocol conformance info (e.g., 'NSObject <MyProtocol>').
2152 Hence, we must save the ObjC-specific information before calling
2153 finish_struct(), and then reinstate it afterwards. */
2155 for (t
= TYPE_MAIN_VARIANT (s
); t
; t
= TYPE_NEXT_VARIANT (t
))
2157 INIT_TYPE_OBJC_INFO (t
);
2158 objc_info
.safe_push (TYPE_OBJC_INFO (t
));
2161 s
= objc_finish_struct (s
, fields
);
2163 for (i
= 0, t
= TYPE_MAIN_VARIANT (s
); t
; t
= TYPE_NEXT_VARIANT (t
), i
++)
2165 /* We now want to restore the different TYPE_OBJC_INFO, but we
2166 have the additional problem that the C frontend doesn't just
2167 copy TYPE_LANG_SPECIFIC from one variant to the other; it
2168 actually makes all of them the *same* TYPE_LANG_SPECIFIC. As
2169 we need a different TYPE_OBJC_INFO for each (and
2170 TYPE_OBJC_INFO is a field in TYPE_LANG_SPECIFIC), we need to
2171 make a copy of each TYPE_LANG_SPECIFIC before we modify
2173 if (TYPE_LANG_SPECIFIC (t
))
2175 /* Create a copy of TYPE_LANG_SPECIFIC. */
2176 struct lang_type
*old_lang_type
= TYPE_LANG_SPECIFIC (t
);
2177 ALLOC_OBJC_TYPE_LANG_SPECIFIC (t
);
2178 memcpy (TYPE_LANG_SPECIFIC (t
), old_lang_type
,
2179 SIZEOF_OBJC_TYPE_LANG_SPECIFIC
);
2183 /* Just create a new one. */
2184 ALLOC_OBJC_TYPE_LANG_SPECIFIC (t
);
2186 /* Replace TYPE_OBJC_INFO with the saved one. This restores any
2187 protocol information that may have been associated with the
2189 TYPE_OBJC_INFO (t
) = objc_info
[i
];
2190 /* Replace the IDENTIFIER_NODE with an actual @interface now
2192 TYPE_OBJC_INTERFACE (t
) = klass
;
2194 objc_info
.release ();
2196 /* Use TYPE_BINFO structures to point at the super class, if any. */
2197 objc_xref_basetypes (s
, super
);
2199 /* Mark this struct as a class template. */
2200 CLASS_STATIC_TEMPLATE (klass
) = s
;
2205 /* Mark DECL as being 'volatile' for purposes of Darwin
2206 _setjmp()/_longjmp() exception handling. Called from
2207 objc_mark_locals_volatile(). */
2209 objc_volatilize_decl (tree decl
)
2211 /* Do not mess with variables that are 'static' or (already)
2213 if (!TREE_THIS_VOLATILE (decl
) && !TREE_STATIC (decl
)
2214 && (TREE_CODE (decl
) == VAR_DECL
2215 || TREE_CODE (decl
) == PARM_DECL
))
2217 if (local_variables_to_volatilize
== NULL
)
2218 vec_alloc (local_variables_to_volatilize
, 8);
2220 vec_safe_push (local_variables_to_volatilize
, decl
);
2224 /* Called when parsing of a function completes; if any local variables
2225 in the function were marked as variables to volatilize, change them
2226 to volatile. We do this at the end of the function when the
2227 warnings about discarding 'volatile' have already been produced.
2228 We are making the variables as volatile just to force the compiler
2229 to preserve them between setjmp/longjmp, but we don't want warnings
2230 for them as they aren't really volatile. */
2232 objc_finish_function (void)
2234 /* If there are any local variables to volatilize, volatilize them. */
2235 if (local_variables_to_volatilize
)
2239 FOR_EACH_VEC_ELT (*local_variables_to_volatilize
, i
, decl
)
2241 tree t
= TREE_TYPE (decl
);
2243 t
= build_qualified_type (t
, TYPE_QUALS (t
) | TYPE_QUAL_VOLATILE
);
2244 TREE_TYPE (decl
) = t
;
2245 TREE_THIS_VOLATILE (decl
) = 1;
2246 TREE_SIDE_EFFECTS (decl
) = 1;
2247 DECL_REGISTER (decl
) = 0;
2249 C_DECL_REGISTER (decl
) = 0;
2253 /* Now we delete the vector. This sets it to NULL as well. */
2254 vec_free (local_variables_to_volatilize
);
2258 /* Check if protocol PROTO is adopted (directly or indirectly) by class CLS
2259 (including its categories and superclasses) or by object type TYP.
2260 Issue a warning if PROTO is not adopted anywhere and WARN is set. */
2263 objc_lookup_protocol (tree proto
, tree cls
, tree typ
, bool warn
)
2265 bool class_type
= (cls
!= NULL_TREE
);
2271 /* Check protocols adopted by the class and its categories. */
2272 for (c
= cls
; c
; c
= CLASS_CATEGORY_LIST (c
))
2274 if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c
), proto
))
2278 /* Repeat for superclasses. */
2279 cls
= lookup_interface (CLASS_SUPER_NAME (cls
));
2282 /* Check for any protocols attached directly to the object type. */
2283 if (TYPE_HAS_OBJC_INFO (typ
))
2285 if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ
), proto
))
2292 gen_type_name_0 (class_type
? typ
: TYPE_POINTER_TO (typ
));
2293 /* NB: Types 'id' and 'Class' cannot reasonably be described as
2294 "implementing" a given protocol, since they do not have an
2297 warning (0, "class %qs does not implement the %qE protocol",
2298 identifier_to_locale (errbuf
), PROTOCOL_NAME (proto
));
2300 warning (0, "type %qs does not conform to the %qE protocol",
2301 identifier_to_locale (errbuf
), PROTOCOL_NAME (proto
));
2307 /* Check if class RCLS and instance struct type RTYP conform to at least the
2308 same protocols that LCLS and LTYP conform to. */
2311 objc_compare_protocols (tree lcls
, tree ltyp
, tree rcls
, tree rtyp
, bool warn
)
2314 bool have_lproto
= false;
2318 /* NB: We do _not_ look at categories defined for LCLS; these may or
2319 may not get loaded in, and therefore it is unreasonable to require
2320 that RCLS/RTYP must implement any of their protocols. */
2321 for (p
= CLASS_PROTOCOL_LIST (lcls
); p
; p
= TREE_CHAIN (p
))
2325 if (!objc_lookup_protocol (TREE_VALUE (p
), rcls
, rtyp
, warn
))
2329 /* Repeat for superclasses. */
2330 lcls
= lookup_interface (CLASS_SUPER_NAME (lcls
));
2333 /* Check for any protocols attached directly to the object type. */
2334 if (TYPE_HAS_OBJC_INFO (ltyp
))
2336 for (p
= TYPE_OBJC_PROTOCOL_LIST (ltyp
); p
; p
= TREE_CHAIN (p
))
2340 if (!objc_lookup_protocol (TREE_VALUE (p
), rcls
, rtyp
, warn
))
2345 /* NB: If LTYP and LCLS have no protocols to search for, return 'true'
2346 vacuously, _unless_ RTYP is a protocol-qualified 'id'. We can get
2347 away with simply checking for 'id' or 'Class' (!RCLS), since this
2348 routine will not get called in other cases. */
2349 return have_lproto
|| (rcls
!= NULL_TREE
);
2352 /* Given two types TYPE1 and TYPE2, return their least common ancestor.
2353 Both TYPE1 and TYPE2 must be pointers, and already determined to be
2354 compatible by objc_compare_types() below. */
2357 objc_common_type (tree type1
, tree type2
)
2359 tree inner1
= TREE_TYPE (type1
), inner2
= TREE_TYPE (type2
);
2361 while (POINTER_TYPE_P (inner1
))
2363 inner1
= TREE_TYPE (inner1
);
2364 inner2
= TREE_TYPE (inner2
);
2367 /* If one type is derived from another, return the base type. */
2368 if (DERIVED_FROM_P (inner1
, inner2
))
2370 else if (DERIVED_FROM_P (inner2
, inner1
))
2373 /* If both types are 'Class', return 'Class'. */
2374 if (objc_is_class_id (inner1
) && objc_is_class_id (inner2
))
2375 return objc_class_type
;
2377 /* Otherwise, return 'id'. */
2378 return objc_object_type
;
2381 /* Determine if it is permissible to assign (if ARGNO is greater than -3)
2382 an instance of RTYP to an instance of LTYP or to compare the two
2383 (if ARGNO is equal to -3), per ObjC type system rules. Before
2384 returning 'true', this routine may issue warnings related to, e.g.,
2385 protocol conformance. When returning 'false', the routine must
2386 produce absolutely no warnings; the C or C++ front-end will do so
2387 instead, if needed. If either LTYP or RTYP is not an Objective-C
2388 type, the routine must return 'false'.
2390 The ARGNO parameter is encoded as follows:
2391 >= 1 Parameter number (CALLEE contains function being called);
2395 -3 Comparison (LTYP and RTYP may match in either direction);
2396 -4 Silent comparison (for C++ overload resolution);
2397 -5 Silent "specialization" comparison for RTYP to be a "specialization"
2398 of LTYP (a specialization means that RTYP is LTYP plus some constraints,
2399 so that each object of type RTYP is also of type LTYP). This is used
2400 when comparing property types. */
2403 objc_compare_types (tree ltyp
, tree rtyp
, int argno
, tree callee
)
2405 tree lcls
, rcls
, lproto
, rproto
;
2406 bool pointers_compatible
;
2408 /* We must be dealing with pointer types */
2409 if (!POINTER_TYPE_P (ltyp
) || !POINTER_TYPE_P (rtyp
))
2414 ltyp
= TREE_TYPE (ltyp
); /* Remove indirections. */
2415 rtyp
= TREE_TYPE (rtyp
);
2417 while (POINTER_TYPE_P (ltyp
) && POINTER_TYPE_P (rtyp
));
2419 /* We must also handle function pointers, since ObjC is a bit more
2420 lenient than C or C++ on this. */
2421 if (TREE_CODE (ltyp
) == FUNCTION_TYPE
&& TREE_CODE (rtyp
) == FUNCTION_TYPE
)
2423 function_args_iterator liter
, riter
;
2425 /* Return types must be covariant. */
2426 if (!comptypes (TREE_TYPE (ltyp
), TREE_TYPE (rtyp
))
2427 && !objc_compare_types (TREE_TYPE (ltyp
), TREE_TYPE (rtyp
),
2431 /* Argument types must be contravariant. */
2432 function_args_iter_init (&liter
, ltyp
);
2433 function_args_iter_init (&riter
, rtyp
);
2437 ltyp
= function_args_iter_cond (&liter
);
2438 rtyp
= function_args_iter_cond (&riter
);
2440 /* If we've exhaused both lists simulateously, we're done. */
2441 if (ltyp
== NULL_TREE
&& rtyp
== NULL_TREE
)
2444 /* If one list is shorter than the other, they fail to match. */
2445 if (ltyp
== NULL_TREE
|| rtyp
== NULL_TREE
)
2448 if (!comptypes (rtyp
, ltyp
)
2449 && !objc_compare_types (rtyp
, ltyp
, argno
, callee
))
2452 function_args_iter_next (&liter
);
2453 function_args_iter_next (&riter
);
2459 /* Past this point, we are only interested in ObjC class instances,
2460 or 'id' or 'Class'. */
2461 if (TREE_CODE (ltyp
) != RECORD_TYPE
|| TREE_CODE (rtyp
) != RECORD_TYPE
)
2464 if (!objc_is_object_id (ltyp
) && !objc_is_class_id (ltyp
)
2465 && !TYPE_HAS_OBJC_INFO (ltyp
))
2468 if (!objc_is_object_id (rtyp
) && !objc_is_class_id (rtyp
)
2469 && !TYPE_HAS_OBJC_INFO (rtyp
))
2472 /* Past this point, we are committed to returning 'true' to the caller
2473 (unless performing a silent comparison; see below). However, we can
2474 still warn about type and/or protocol mismatches. */
2476 if (TYPE_HAS_OBJC_INFO (ltyp
))
2478 lcls
= TYPE_OBJC_INTERFACE (ltyp
);
2479 lproto
= TYPE_OBJC_PROTOCOL_LIST (ltyp
);
2482 lcls
= lproto
= NULL_TREE
;
2484 if (TYPE_HAS_OBJC_INFO (rtyp
))
2486 rcls
= TYPE_OBJC_INTERFACE (rtyp
);
2487 rproto
= TYPE_OBJC_PROTOCOL_LIST (rtyp
);
2490 rcls
= rproto
= NULL_TREE
;
2492 /* If we could not find an @interface declaration, we must have
2493 only seen a @class declaration; for purposes of type comparison,
2494 treat it as a stand-alone (root) class. */
2496 if (lcls
&& TREE_CODE (lcls
) == IDENTIFIER_NODE
)
2499 if (rcls
&& TREE_CODE (rcls
) == IDENTIFIER_NODE
)
2502 /* If either type is an unqualified 'id', we're done. This is because
2503 an 'id' can be assigned to or from any type with no warnings. */
2506 if ((!lproto
&& objc_is_object_id (ltyp
))
2507 || (!rproto
&& objc_is_object_id (rtyp
)))
2512 /* For property checks, though, an 'id' is considered the most
2513 general type of object, hence if you try to specialize an
2514 'NSArray *' (ltyp) property with an 'id' (rtyp) one, we need
2516 if (!lproto
&& objc_is_object_id (ltyp
))
2520 pointers_compatible
= (TYPE_MAIN_VARIANT (ltyp
) == TYPE_MAIN_VARIANT (rtyp
));
2522 /* If the underlying types are the same, and at most one of them has
2523 a protocol list, we do not need to issue any diagnostics. */
2524 if (pointers_compatible
&& (!lproto
|| !rproto
))
2527 /* If exactly one of the types is 'Class', issue a diagnostic; any
2528 exceptions of this rule have already been handled. */
2529 if (objc_is_class_id (ltyp
) ^ objc_is_class_id (rtyp
))
2530 pointers_compatible
= false;
2531 /* Otherwise, check for inheritance relations. */
2534 if (!pointers_compatible
)
2536 /* Again, if any of the two is an 'id', we're satisfied,
2537 unless we're comparing properties, in which case only an
2538 'id' on the left-hand side (old property) is good
2542 = (objc_is_object_id (ltyp
) || objc_is_object_id (rtyp
));
2544 pointers_compatible
= objc_is_object_id (ltyp
);
2547 if (!pointers_compatible
)
2548 pointers_compatible
= DERIVED_FROM_P (ltyp
, rtyp
);
2550 if (!pointers_compatible
&& (argno
== -3 || argno
== -4))
2551 pointers_compatible
= DERIVED_FROM_P (rtyp
, ltyp
);
2554 /* If the pointers match modulo protocols, check for protocol conformance
2556 if (pointers_compatible
)
2558 pointers_compatible
= objc_compare_protocols (lcls
, ltyp
, rcls
, rtyp
,
2561 if (!pointers_compatible
&& argno
== -3)
2562 pointers_compatible
= objc_compare_protocols (rcls
, rtyp
, lcls
, ltyp
,
2566 if (!pointers_compatible
)
2568 /* The two pointers are not exactly compatible. Issue a warning, unless
2569 we are performing a silent comparison, in which case return 'false'
2571 /* NB: For the time being, we shall make our warnings look like their
2572 C counterparts. In the future, we may wish to make them more
2581 warning (0, "comparison of distinct Objective-C types lacks a cast");
2585 warning (0, "initialization from distinct Objective-C type");
2589 warning (0, "assignment from distinct Objective-C type");
2593 warning (0, "distinct Objective-C type in return");
2597 warning (0, "passing argument %d of %qE from distinct "
2598 "Objective-C type", argno
, callee
);
2606 /* This routine is similar to objc_compare_types except that function-pointers are
2607 excluded. This is because, caller assumes that common types are of (id, Object*)
2608 variety and calls objc_common_type to obtain a common type. There is no commonolty
2609 between two function-pointers in this regard. */
2612 objc_have_common_type (tree ltyp
, tree rtyp
, int argno
, tree callee
)
2614 if (objc_compare_types (ltyp
, rtyp
, argno
, callee
))
2616 /* exclude function-pointer types. */
2619 ltyp
= TREE_TYPE (ltyp
); /* Remove indirections. */
2620 rtyp
= TREE_TYPE (rtyp
);
2622 while (POINTER_TYPE_P (ltyp
) && POINTER_TYPE_P (rtyp
));
2623 return !(TREE_CODE (ltyp
) == FUNCTION_TYPE
&& TREE_CODE (rtyp
) == FUNCTION_TYPE
);
2629 /* Determine if CHILD is derived from PARENT. The routine assumes that
2630 both parameters are RECORD_TYPEs, and is non-reflexive. */
2633 objc_derived_from_p (tree parent
, tree child
)
2635 parent
= TYPE_MAIN_VARIANT (parent
);
2637 for (child
= TYPE_MAIN_VARIANT (child
);
2638 TYPE_BINFO (child
) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child
));)
2640 child
= TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO
2641 (TYPE_BINFO (child
),
2644 if (child
== parent
)
2653 objc_build_component_ref (tree datum
, tree component
)
2655 /* If COMPONENT is NULL, the caller is referring to the anonymous
2656 base class field. */
2659 tree base
= TYPE_FIELDS (TREE_TYPE (datum
));
2661 return build3 (COMPONENT_REF
, TREE_TYPE (base
), datum
, base
, NULL_TREE
);
2664 /* The 'build_component_ref' routine has been removed from the C++
2665 front-end, but 'finish_class_member_access_expr' seems to be
2666 a worthy substitute. */
2668 return finish_class_member_access_expr (datum
, component
, false,
2669 tf_warning_or_error
);
2671 return build_component_ref (input_location
, datum
, component
);
2675 /* Recursively copy inheritance information rooted at BINFO. To do this,
2676 we emulate the song and dance performed by cp/tree.c:copy_binfo(). */
2679 objc_copy_binfo (tree binfo
)
2681 tree btype
= BINFO_TYPE (binfo
);
2682 tree binfo2
= make_tree_binfo (BINFO_N_BASE_BINFOS (binfo
));
2686 BINFO_TYPE (binfo2
) = btype
;
2687 BINFO_OFFSET (binfo2
) = BINFO_OFFSET (binfo
);
2688 BINFO_BASE_ACCESSES (binfo2
) = BINFO_BASE_ACCESSES (binfo
);
2690 /* Recursively copy base binfos of BINFO. */
2691 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2693 tree base_binfo2
= objc_copy_binfo (base_binfo
);
2695 BINFO_INHERITANCE_CHAIN (base_binfo2
) = binfo2
;
2696 BINFO_BASE_APPEND (binfo2
, base_binfo2
);
2702 /* Record superclass information provided in BASETYPE for ObjC class REF.
2703 This is loosely based on cp/decl.c:xref_basetypes(). */
2706 objc_xref_basetypes (tree ref
, tree basetype
)
2709 tree binfo
= make_tree_binfo (basetype
? 1 : 0);
2710 TYPE_BINFO (ref
) = binfo
;
2711 BINFO_OFFSET (binfo
) = size_zero_node
;
2712 BINFO_TYPE (binfo
) = ref
;
2714 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
2715 for (variant
= ref
; variant
; variant
= TYPE_NEXT_VARIANT (variant
))
2716 TYPE_BINFO (variant
) = binfo
;
2720 tree base_binfo
= objc_copy_binfo (TYPE_BINFO (basetype
));
2722 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
2723 vec_alloc (BINFO_BASE_ACCESSES (binfo
), 1);
2724 BINFO_BASE_APPEND (binfo
, base_binfo
);
2725 BINFO_BASE_ACCESS_APPEND (binfo
, access_public_node
);
2729 /* Called from finish_decl. */
2732 objc_check_decl (tree decl
)
2734 tree type
= TREE_TYPE (decl
);
2736 if (TREE_CODE (type
) != RECORD_TYPE
)
2738 if (OBJC_TYPE_NAME (type
) && (type
= objc_is_class_name (OBJC_TYPE_NAME (type
))))
2739 error ("statically allocated instance of Objective-C class %qE",
2744 objc_check_global_decl (tree decl
)
2746 tree id
= DECL_NAME (decl
);
2747 if (objc_is_class_name (id
) && global_bindings_p())
2748 error ("redeclaration of Objective-C class %qs", IDENTIFIER_POINTER (id
));
2751 /* Construct a PROTOCOLS-qualified variant of INTERFACE, where
2752 INTERFACE may either name an Objective-C class, or refer to the
2753 special 'id' or 'Class' types. If INTERFACE is not a valid ObjC
2754 type, just return it unchanged. This function is often called when
2755 PROTOCOLS is NULL_TREE, in which case we simply look up the
2756 appropriate INTERFACE. */
2759 objc_get_protocol_qualified_type (tree interface
, tree protocols
)
2761 /* If INTERFACE is not provided, default to 'id'. */
2762 tree type
= (interface
? objc_is_id (interface
) : objc_object_type
);
2763 bool is_ptr
= (type
!= NULL_TREE
);
2767 type
= objc_is_class_name (interface
);
2771 /* If looking at a typedef, retrieve the precise type it
2773 if (TREE_CODE (interface
) == IDENTIFIER_NODE
)
2774 interface
= identifier_global_value (interface
);
2776 type
= ((interface
&& TREE_CODE (interface
) == TYPE_DECL
2777 && DECL_ORIGINAL_TYPE (interface
))
2778 ? DECL_ORIGINAL_TYPE (interface
)
2779 : xref_tag (RECORD_TYPE
, type
));
2783 /* This case happens when we are given an 'interface' which
2784 is not a valid class name. For example if a typedef was
2785 used, and 'interface' really is the identifier of the
2786 typedef, but when you resolve it you don't get an
2787 Objective-C class, but something else, such as 'int'.
2788 This is an error; protocols make no sense unless you use
2789 them with Objective-C objects. */
2790 error_at (input_location
, "only Objective-C object types can be qualified with a protocol");
2792 /* Try to recover. Ignore the invalid class name, and treat
2793 the object as an 'id' to silence further warnings about
2795 type
= objc_object_type
;
2802 type
= build_variant_type_copy (type
);
2804 /* For pointers (i.e., 'id' or 'Class'), attach the protocol(s)
2808 tree orig_pointee_type
= TREE_TYPE (type
);
2809 TREE_TYPE (type
) = build_variant_type_copy (orig_pointee_type
);
2811 /* Set up the canonical type information. */
2812 TYPE_CANONICAL (type
)
2813 = TYPE_CANONICAL (TYPE_POINTER_TO (orig_pointee_type
));
2815 TYPE_POINTER_TO (TREE_TYPE (type
)) = type
;
2816 type
= TREE_TYPE (type
);
2819 /* Look up protocols and install in lang specific list. */
2820 DUP_TYPE_OBJC_INFO (type
, TYPE_MAIN_VARIANT (type
));
2821 TYPE_OBJC_PROTOCOL_LIST (type
) = lookup_and_install_protocols
2822 (protocols
, /* definition_required */ false);
2824 /* For RECORD_TYPEs, point to the @interface; for 'id' and 'Class',
2825 return the pointer to the new pointee variant. */
2827 type
= TYPE_POINTER_TO (type
);
2829 TYPE_OBJC_INTERFACE (type
)
2830 = TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type
));
2836 /* Check for circular dependencies in protocols. The arguments are
2837 PROTO, the protocol to check, and LIST, a list of protocol it
2841 check_protocol_recursively (tree proto
, tree list
)
2845 for (p
= list
; p
; p
= TREE_CHAIN (p
))
2847 tree pp
= TREE_VALUE (p
);
2849 if (TREE_CODE (pp
) == IDENTIFIER_NODE
)
2850 pp
= lookup_protocol (pp
, /* warn if deprecated */ false,
2851 /* definition_required */ false);
2854 fatal_error (input_location
, "protocol %qE has circular dependency",
2855 PROTOCOL_NAME (pp
));
2857 check_protocol_recursively (proto
, PROTOCOL_LIST (pp
));
2861 /* Look up PROTOCOLS, and return a list of those that are found. If
2862 none are found, return NULL. Note that this function will emit a
2863 warning if a protocol is found and is deprecated. If
2864 'definition_required', then warn if the protocol is found but is
2865 not defined (ie, if we only saw a forward-declaration of the
2866 protocol (as in "@protocol NSObject;") not a real definition with
2867 the list of methods). */
2869 lookup_and_install_protocols (tree protocols
, bool definition_required
)
2872 tree return_value
= NULL_TREE
;
2874 if (protocols
== error_mark_node
)
2877 for (proto
= protocols
; proto
; proto
= TREE_CHAIN (proto
))
2879 tree ident
= TREE_VALUE (proto
);
2880 tree p
= lookup_protocol (ident
, /* warn_if_deprecated */ true,
2881 definition_required
);
2884 return_value
= chainon (return_value
,
2885 build_tree_list (NULL_TREE
, p
));
2886 else if (ident
!= error_mark_node
)
2887 error ("cannot find protocol declaration for %qE",
2891 return return_value
;
2895 build_common_objc_exception_stuff (void)
2897 tree noreturn_list
, nothrow_list
, temp_type
;
2899 noreturn_list
= tree_cons (get_identifier ("noreturn"), NULL
, NULL
);
2900 nothrow_list
= tree_cons (get_identifier ("nothrow"), NULL
, NULL
);
2902 /* void objc_exception_throw(id) __attribute__((noreturn)); */
2903 /* void objc_sync_enter(id); */
2904 /* void objc_sync_exit(id); */
2905 temp_type
= build_function_type_list (void_type_node
,
2908 objc_exception_throw_decl
2909 = add_builtin_function (TAG_EXCEPTIONTHROW
, temp_type
, 0, NOT_BUILT_IN
, NULL
,
2911 /* Make sure that objc_exception_throw (id) claims that it may throw an
2913 TREE_NOTHROW (objc_exception_throw_decl
) = 0;
2915 objc_sync_enter_decl
2916 = add_builtin_function (TAG_SYNCENTER
, temp_type
, 0, NOT_BUILT_IN
,
2917 NULL
, nothrow_list
);
2920 = add_builtin_function (TAG_SYNCEXIT
, temp_type
, 0, NOT_BUILT_IN
,
2921 NULL
, nothrow_list
);
2924 /* Purpose: "play" parser, creating/installing representations
2925 of the declarations that are required by Objective-C.
2929 type_spec--------->sc_spec
2930 (tree_list) (tree_list)
2933 identifier_node identifier_node */
2936 synth_module_prologue (void)
2939 enum debug_info_type save_write_symbols
= write_symbols
;
2940 const struct gcc_debug_hooks
*const save_hooks
= debug_hooks
;
2942 /* Suppress outputting debug symbols, because
2943 dbxout_init hasn't been called yet. */
2944 write_symbols
= NO_DEBUG
;
2945 debug_hooks
= &do_nothing_debug_hooks
;
2948 push_lang_context (lang_name_c
); /* extern "C" */
2951 /* The following are also defined in <objc/objc.h> and friends. */
2953 objc_object_id
= get_identifier (TAG_OBJECT
);
2954 objc_class_id
= get_identifier (TAG_CLASS
);
2956 objc_object_reference
= xref_tag (RECORD_TYPE
, objc_object_id
);
2957 objc_class_reference
= xref_tag (RECORD_TYPE
, objc_class_id
);
2959 objc_object_type
= build_pointer_type (objc_object_reference
);
2960 objc_class_type
= build_pointer_type (objc_class_reference
);
2962 objc_object_name
= get_identifier (OBJECT_TYPEDEF_NAME
);
2963 objc_class_name
= get_identifier (CLASS_TYPEDEF_NAME
);
2965 /* Declare the 'id' and 'Class' typedefs. */
2966 type
= lang_hooks
.decls
.pushdecl (build_decl (input_location
,
2970 TREE_NO_WARNING (type
) = 1;
2972 type
= lang_hooks
.decls
.pushdecl (build_decl (input_location
,
2976 TREE_NO_WARNING (type
) = 1;
2978 /* Forward-declare '@interface Protocol'. */
2979 type
= get_identifier (PROTOCOL_OBJECT_CLASS_NAME
);
2980 objc_declare_class (type
);
2981 objc_protocol_type
= build_pointer_type (xref_tag (RECORD_TYPE
, type
));
2983 /* Declare receiver type used for dispatching messages to 'super'. */
2984 /* `struct objc_super *' */
2985 objc_super_type
= build_pointer_type (xref_tag (RECORD_TYPE
,
2986 get_identifier (TAG_SUPER
)));
2988 /* Declare pointers to method and ivar lists. */
2989 objc_method_list_ptr
= build_pointer_type
2990 (xref_tag (RECORD_TYPE
,
2991 get_identifier (UTAG_METHOD_LIST
)));
2992 objc_method_proto_list_ptr
2993 = build_pointer_type (xref_tag (RECORD_TYPE
,
2994 get_identifier (UTAG_METHOD_PROTOTYPE_LIST
)));
2995 objc_ivar_list_ptr
= build_pointer_type
2996 (xref_tag (RECORD_TYPE
,
2997 get_identifier (UTAG_IVAR_LIST
)));
2999 build_common_objc_exception_stuff ();
3001 /* Set-up runtime-specific templates, message and exception stuff. */
3002 (*runtime
.initialize
) ();
3004 /* Declare objc_getProperty, object_setProperty and other property
3005 accessor helpers. */
3006 build_common_objc_property_accessor_helpers ();
3008 /* Forward declare constant_string_id and constant_string_type. */
3009 if (!constant_string_class_name
)
3010 constant_string_class_name
= runtime
.default_constant_string_class_name
;
3011 constant_string_id
= get_identifier (constant_string_class_name
);
3012 objc_declare_class (constant_string_id
);
3014 /* Pre-build the following entities - for speed/convenience. */
3015 self_id
= get_identifier ("self");
3016 ucmd_id
= get_identifier ("_cmd");
3018 /* Declare struct _objc_fast_enumeration_state { ... }; */
3019 build_fast_enumeration_state_template ();
3021 /* void objc_enumeration_mutation (id) */
3022 type
= build_function_type_list (void_type_node
,
3023 objc_object_type
, NULL_TREE
);
3024 objc_enumeration_mutation_decl
3025 = add_builtin_function (TAG_ENUMERATION_MUTATION
, type
, 0, NOT_BUILT_IN
,
3027 TREE_NOTHROW (objc_enumeration_mutation_decl
) = 0;
3030 pop_lang_context ();
3033 write_symbols
= save_write_symbols
;
3034 debug_hooks
= save_hooks
;
3037 /* --- const strings --- */
3039 /* Ensure that the ivar list for NSConstantString/NXConstantString
3040 (or whatever was specified via `-fconstant-string-class')
3041 contains fields at least as large as the following three, so that
3042 the runtime can stomp on them with confidence:
3044 struct STRING_OBJECT_CLASS_NAME
3048 unsigned int length;
3052 check_string_class_template (void)
3054 tree field_decl
= objc_get_class_ivars (constant_string_id
);
3056 #define AT_LEAST_AS_LARGE_AS(F, T) \
3057 (F && TREE_CODE (F) == FIELD_DECL \
3058 && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \
3059 >= TREE_INT_CST_LOW (TYPE_SIZE (T))))
3061 if (!AT_LEAST_AS_LARGE_AS (field_decl
, ptr_type_node
))
3064 field_decl
= DECL_CHAIN (field_decl
);
3065 if (!AT_LEAST_AS_LARGE_AS (field_decl
, ptr_type_node
))
3068 field_decl
= DECL_CHAIN (field_decl
);
3069 return AT_LEAST_AS_LARGE_AS (field_decl
, unsigned_type_node
);
3071 #undef AT_LEAST_AS_LARGE_AS
3074 /* Avoid calling `check_string_class_template ()' more than once. */
3075 static GTY(()) int string_layout_checked
;
3077 /* Construct an internal string layout to be used as a template for
3078 creating NSConstantString/NXConstantString instances. */
3081 objc_build_internal_const_str_type (void)
3083 tree type
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
3084 tree fields
= build_decl (input_location
,
3085 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
3086 tree field
= build_decl (input_location
,
3087 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
3089 DECL_CHAIN (field
) = fields
; fields
= field
;
3090 field
= build_decl (input_location
,
3091 FIELD_DECL
, NULL_TREE
, unsigned_type_node
);
3092 DECL_CHAIN (field
) = fields
; fields
= field
;
3093 /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in
3095 finish_builtin_struct (type
, "__builtin_ObjCString",
3101 /* Custom build_string which sets TREE_TYPE! */
3104 my_build_string (int len
, const char *str
)
3106 return fix_string_type (build_string (len
, str
));
3109 /* Build a string with contents STR and length LEN and convert it to a
3113 my_build_string_pointer (int len
, const char *str
)
3115 tree string
= my_build_string (len
, str
);
3116 tree ptrtype
= build_pointer_type (TREE_TYPE (TREE_TYPE (string
)));
3117 return build1 (ADDR_EXPR
, ptrtype
, string
);
3121 objc_string_hasher::hash (string_descriptor
*ptr
)
3123 const_tree
const str
= ptr
->literal
;
3124 const unsigned char *p
= (const unsigned char *) TREE_STRING_POINTER (str
);
3125 int i
, len
= TREE_STRING_LENGTH (str
);
3128 for (i
= 0; i
< len
; i
++)
3129 h
= ((h
* 613) + p
[i
]);
3135 objc_string_hasher::equal (string_descriptor
*ptr1
, string_descriptor
*ptr2
)
3137 const_tree
const str1
= ptr1
->literal
;
3138 const_tree
const str2
= ptr2
->literal
;
3139 int len1
= TREE_STRING_LENGTH (str1
);
3141 return (len1
== TREE_STRING_LENGTH (str2
)
3142 && !memcmp (TREE_STRING_POINTER (str1
), TREE_STRING_POINTER (str2
),
3146 /* Given a chain of STRING_CST's, build a static instance of
3147 NXConstantString which points at the concatenation of those
3148 strings. We place the string object in the __string_objects
3149 section of the __OBJC segment. The Objective-C runtime will
3150 initialize the isa pointers of the string objects to point at the
3151 NXConstantString class object. */
3154 objc_build_string_object (tree string
)
3156 tree constant_string_class
;
3159 struct string_descriptor
*desc
, key
;
3161 /* We should be passed a STRING_CST. */
3162 gcc_checking_assert (TREE_CODE (string
) == STRING_CST
);
3163 length
= TREE_STRING_LENGTH (string
) - 1;
3165 /* The target may have different ideas on how to construct an ObjC string
3166 literal. On Darwin (Mac OS X), for example, we may wish to obtain a
3167 constant CFString reference instead.
3168 At present, this is only supported for the NeXT runtime. */
3169 if (flag_next_runtime
3170 && targetcm
.objc_construct_string_object
)
3172 tree constructor
= (*targetcm
.objc_construct_string_object
) (string
);
3174 return build1 (NOP_EXPR
, objc_object_type
, constructor
);
3177 /* Check whether the string class being used actually exists and has the
3178 correct ivar layout. */
3179 if (!string_layout_checked
)
3181 string_layout_checked
= -1;
3182 constant_string_class
= lookup_interface (constant_string_id
);
3183 internal_const_str_type
= objc_build_internal_const_str_type ();
3185 if (!constant_string_class
3186 || !(constant_string_type
3187 = CLASS_STATIC_TEMPLATE (constant_string_class
)))
3188 error ("cannot find interface declaration for %qE",
3189 constant_string_id
);
3190 /* The NSConstantString/NXConstantString ivar layout is now known. */
3191 else if (!check_string_class_template ())
3192 error ("interface %qE does not have valid constant string layout",
3193 constant_string_id
);
3194 /* If the runtime can generate a literal reference to the string class,
3195 don't need to run a constructor. */
3196 else if (!(*runtime
.setup_const_string_class_decl
)())
3197 error ("cannot find reference tag for class %qE", constant_string_id
);
3200 string_layout_checked
= 1; /* Success! */
3201 add_class_reference (constant_string_id
);
3205 if (string_layout_checked
== -1)
3206 return error_mark_node
;
3208 /* Perhaps we already constructed a constant string just like this one? */
3209 key
.literal
= string
;
3210 string_descriptor
**loc
= string_htab
->find_slot (&key
, INSERT
);
3215 *loc
= desc
= ggc_alloc
<string_descriptor
> ();
3216 desc
->literal
= string
;
3218 (*runtime
.build_const_string_constructor
) (input_location
, string
, length
);
3221 addr
= convert (build_pointer_type (constant_string_type
),
3222 build_unary_op (input_location
,
3223 ADDR_EXPR
, desc
->constructor
, 1));
3228 /* Build a static constant CONSTRUCTOR
3229 with type TYPE and elements ELTS. */
3232 objc_build_constructor (tree type
, vec
<constructor_elt
, va_gc
> *elts
)
3234 tree constructor
= build_constructor (type
, elts
);
3236 TREE_CONSTANT (constructor
) = 1;
3237 TREE_STATIC (constructor
) = 1;
3238 TREE_READONLY (constructor
) = 1;
3241 /* Adjust for impedance mismatch. We should figure out how to build
3242 CONSTRUCTORs that consistently please both the C and C++ gods. */
3243 if (!(*elts
)[0].index
)
3244 TREE_TYPE (constructor
) = init_list_type_node
;
3250 /* Return the DECL of the string IDENT in the SECTION. */
3253 get_objc_string_decl (tree ident
, enum string_section section
)
3260 chain
= class_names_chain
;
3262 case meth_var_names
:
3263 chain
= meth_var_names_chain
;
3265 case meth_var_types
:
3266 chain
= meth_var_types_chain
;
3268 case prop_names_attr
:
3269 chain
= prop_names_attr_chain
;
3275 for (; chain
!= 0; chain
= TREE_CHAIN (chain
))
3276 if (TREE_VALUE (chain
) == ident
)
3277 return (TREE_PURPOSE (chain
));
3279 /* We didn't find the entry. */
3283 /* Create a class reference, but don't create a variable to reference
3287 add_class_reference (tree ident
)
3291 if ((chain
= cls_ref_chain
))
3296 if (ident
== TREE_VALUE (chain
))
3300 chain
= TREE_CHAIN (chain
);
3304 /* Append to the end of the list */
3305 TREE_CHAIN (tail
) = tree_cons (NULL_TREE
, ident
, NULL_TREE
);
3308 cls_ref_chain
= tree_cons (NULL_TREE
, ident
, NULL_TREE
);
3311 /* Get a class reference, creating it if necessary. Also create the
3312 reference variable. */
3314 objc_get_class_reference (tree ident
)
3316 tree orig_ident
= (DECL_P (ident
)
3319 ? OBJC_TYPE_NAME (ident
)
3321 bool local_scope
= false;
3324 if (processing_template_decl
)
3325 /* Must wait until template instantiation time. */
3326 return build_min_nt_loc (UNKNOWN_LOCATION
, CLASS_REFERENCE_EXPR
, ident
);
3329 if (TREE_CODE (ident
) == TYPE_DECL
)
3330 ident
= (DECL_ORIGINAL_TYPE (ident
)
3331 ? DECL_ORIGINAL_TYPE (ident
)
3332 : TREE_TYPE (ident
));
3336 && CP_TYPE_CONTEXT (ident
) != global_namespace
)
3340 if (local_scope
|| !(ident
= objc_is_class_name (ident
)))
3342 error ("%qE is not an Objective-C class name or alias",
3344 return error_mark_node
;
3347 return (*runtime
.get_class_reference
) (ident
);
3351 objc_declare_alias (tree alias_ident
, tree class_ident
)
3353 tree underlying_class
;
3356 if (current_namespace
!= global_namespace
) {
3357 error ("Objective-C declarations may only appear in global scope");
3359 #endif /* OBJCPLUS */
3361 if (!(underlying_class
= objc_is_class_name (class_ident
)))
3362 warning (0, "cannot find class %qE", class_ident
);
3363 else if (objc_is_class_name (alias_ident
))
3364 warning (0, "class %qE already exists", alias_ident
);
3367 /* Implement @compatibility_alias as a typedef. */
3369 push_lang_context (lang_name_c
); /* extern "C" */
3371 lang_hooks
.decls
.pushdecl (build_decl
3375 xref_tag (RECORD_TYPE
, underlying_class
)));
3377 pop_lang_context ();
3379 objc_map_put (alias_name_map
, alias_ident
, underlying_class
);
3384 objc_declare_class (tree identifier
)
3387 if (current_namespace
!= global_namespace
) {
3388 error ("Objective-C declarations may only appear in global scope");
3390 #endif /* OBJCPLUS */
3392 if (! objc_is_class_name (identifier
))
3394 tree record
= lookup_name (identifier
), type
= record
;
3398 if (TREE_CODE (record
) == TYPE_DECL
)
3399 type
= DECL_ORIGINAL_TYPE (record
)
3400 ? DECL_ORIGINAL_TYPE (record
)
3401 : TREE_TYPE (record
);
3403 if (!TYPE_HAS_OBJC_INFO (type
)
3404 || !TYPE_OBJC_INTERFACE (type
))
3406 error ("%qE redeclared as different kind of symbol",
3408 error ("previous declaration of %q+D",
3413 record
= xref_tag (RECORD_TYPE
, identifier
);
3414 INIT_TYPE_OBJC_INFO (record
);
3415 /* In the case of a @class declaration, we store the ident in
3416 the TYPE_OBJC_INTERFACE. If later an @interface is found,
3417 we'll replace the ident with the interface. */
3418 TYPE_OBJC_INTERFACE (record
) = identifier
;
3419 objc_map_put (class_name_map
, identifier
, NULL_TREE
);
3424 objc_is_class_name (tree ident
)
3426 if (ident
&& TREE_CODE (ident
) == IDENTIFIER_NODE
)
3428 tree t
= identifier_global_value (ident
);
3433 while (ident
&& TREE_CODE (ident
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (ident
))
3434 ident
= OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident
));
3436 if (ident
&& TREE_CODE (ident
) == RECORD_TYPE
)
3437 ident
= OBJC_TYPE_NAME (ident
);
3439 if (ident
&& TREE_CODE (ident
) == TYPE_DECL
)
3441 tree type
= TREE_TYPE (ident
);
3442 if (type
&& TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
3444 ident
= DECL_NAME (ident
);
3447 if (!ident
|| TREE_CODE (ident
) != IDENTIFIER_NODE
)
3450 if (lookup_interface (ident
))
3456 target
= objc_map_get (class_name_map
, ident
);
3457 if (target
!= OBJC_MAP_NOT_FOUND
)
3460 target
= objc_map_get (alias_name_map
, ident
);
3461 if (target
!= OBJC_MAP_NOT_FOUND
)
3468 /* Check whether TYPE is either 'id' or 'Class'. */
3471 objc_is_id (tree type
)
3473 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
)
3475 tree t
= identifier_global_value (type
);
3480 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
3481 type
= TREE_TYPE (type
);
3483 /* NB: This function may be called before the ObjC front-end has
3484 been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL. */
3485 return (objc_object_type
&& type
3486 && (IS_ID (type
) || IS_CLASS (type
) || IS_SUPER (type
))
3491 /* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
3492 class instance. This is needed by other parts of the compiler to
3493 handle ObjC types gracefully. */
3496 objc_is_object_ptr (tree type
)
3500 type
= TYPE_MAIN_VARIANT (type
);
3501 if (!POINTER_TYPE_P (type
))
3504 ret
= objc_is_id (type
);
3506 ret
= objc_is_class_name (TREE_TYPE (type
));
3512 objc_is_gcable_type (tree type
, int or_strong_p
)
3518 if (objc_is_id (TYPE_MAIN_VARIANT (type
)))
3520 if (or_strong_p
&& lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type
)))
3522 if (TREE_CODE (type
) != POINTER_TYPE
&& TREE_CODE (type
) != INDIRECT_REF
)
3524 type
= TREE_TYPE (type
);
3525 if (TREE_CODE (type
) != RECORD_TYPE
)
3527 name
= TYPE_NAME (type
);
3528 return (objc_is_class_name (name
) != NULL_TREE
);
3532 objc_substitute_decl (tree expr
, tree oldexpr
, tree newexpr
)
3534 if (expr
== oldexpr
)
3537 switch (TREE_CODE (expr
))
3540 return objc_build_component_ref
3541 (objc_substitute_decl (TREE_OPERAND (expr
, 0),
3544 DECL_NAME (TREE_OPERAND (expr
, 1)));
3546 return build_array_ref (input_location
,
3547 objc_substitute_decl (TREE_OPERAND (expr
, 0),
3550 TREE_OPERAND (expr
, 1));
3552 return build_indirect_ref (input_location
,
3553 objc_substitute_decl (TREE_OPERAND (expr
, 0),
3555 newexpr
), RO_ARROW
);
3562 objc_build_ivar_assignment (tree outervar
, tree lhs
, tree rhs
)
3565 /* The LHS parameter contains the expression 'outervar->memberspec';
3566 we need to transform it into '&((typeof(outervar) *) 0)->memberspec',
3567 where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]').
3570 = objc_substitute_decl
3571 (lhs
, outervar
, convert (TREE_TYPE (outervar
), integer_zero_node
));
3573 = (flag_objc_direct_dispatch
3574 ? objc_assign_ivar_fast_decl
3575 : objc_assign_ivar_decl
);
3577 offs
= convert (integer_type_node
, build_unary_op (input_location
,
3578 ADDR_EXPR
, offs
, 0));
3580 func_params
= tree_cons (NULL_TREE
,
3581 convert (objc_object_type
, rhs
),
3582 tree_cons (NULL_TREE
, convert (objc_object_type
, outervar
),
3583 tree_cons (NULL_TREE
, offs
,
3586 return build_function_call (input_location
, func
, func_params
);
3590 objc_build_global_assignment (tree lhs
, tree rhs
)
3592 tree func_params
= tree_cons (NULL_TREE
,
3593 convert (objc_object_type
, rhs
),
3594 tree_cons (NULL_TREE
, convert (build_pointer_type (objc_object_type
),
3595 build_unary_op (input_location
, ADDR_EXPR
, lhs
, 0)),
3598 return build_function_call (input_location
,
3599 objc_assign_global_decl
, func_params
);
3603 objc_build_strong_cast_assignment (tree lhs
, tree rhs
)
3605 tree func_params
= tree_cons (NULL_TREE
,
3606 convert (objc_object_type
, rhs
),
3607 tree_cons (NULL_TREE
, convert (build_pointer_type (objc_object_type
),
3608 build_unary_op (input_location
, ADDR_EXPR
, lhs
, 0)),
3611 return build_function_call (input_location
,
3612 objc_assign_strong_cast_decl
, func_params
);
3616 objc_is_gcable_p (tree expr
)
3618 return (TREE_CODE (expr
) == COMPONENT_REF
3619 ? objc_is_gcable_p (TREE_OPERAND (expr
, 1))
3620 : TREE_CODE (expr
) == ARRAY_REF
3621 ? (objc_is_gcable_p (TREE_TYPE (expr
))
3622 || objc_is_gcable_p (TREE_OPERAND (expr
, 0)))
3623 : TREE_CODE (expr
) == ARRAY_TYPE
3624 ? objc_is_gcable_p (TREE_TYPE (expr
))
3626 ? objc_is_gcable_type (expr
, 1)
3627 : (objc_is_gcable_p (TREE_TYPE (expr
))
3629 && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr
)))));
3633 objc_is_ivar_reference_p (tree expr
)
3635 return (TREE_CODE (expr
) == ARRAY_REF
3636 ? objc_is_ivar_reference_p (TREE_OPERAND (expr
, 0))
3637 : TREE_CODE (expr
) == COMPONENT_REF
3638 ? TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
3643 objc_is_global_reference_p (tree expr
)
3645 return (TREE_CODE (expr
) == INDIRECT_REF
|| TREE_CODE (expr
) == PLUS_EXPR
3646 ? objc_is_global_reference_p (TREE_OPERAND (expr
, 0))
3648 ? (DECL_FILE_SCOPE_P (expr
) || TREE_STATIC (expr
))
3653 objc_generate_write_barrier (tree lhs
, enum tree_code modifycode
, tree rhs
)
3655 tree result
= NULL_TREE
, outer
;
3656 int strong_cast_p
= 0, outer_gc_p
= 0, indirect_p
= 0;
3658 /* This function is currently only used with the next runtime with
3659 garbage collection enabled (-fobjc-gc). */
3660 gcc_assert (flag_next_runtime
);
3662 /* See if we have any lhs casts, and strip them out. NB: The lvalue casts
3663 will have been transformed to the form '*(type *)&expr'. */
3664 if (TREE_CODE (lhs
) == INDIRECT_REF
)
3666 outer
= TREE_OPERAND (lhs
, 0);
3668 while (!strong_cast_p
3669 && (CONVERT_EXPR_P (outer
)
3670 || TREE_CODE (outer
) == NON_LVALUE_EXPR
))
3672 tree lhstype
= TREE_TYPE (outer
);
3674 /* Descend down the cast chain, and record the first objc_gc
3676 if (POINTER_TYPE_P (lhstype
))
3679 = lookup_attribute ("objc_gc",
3680 TYPE_ATTRIBUTES (TREE_TYPE (lhstype
)));
3686 outer
= TREE_OPERAND (outer
, 0);
3690 /* If we have a __strong cast, it trumps all else. */
3693 if (modifycode
!= NOP_EXPR
)
3694 goto invalid_pointer_arithmetic
;
3696 if (warn_assign_intercept
)
3697 warning (0, "strong-cast assignment has been intercepted");
3699 result
= objc_build_strong_cast_assignment (lhs
, rhs
);
3704 /* the lhs must be of a suitable type, regardless of its underlying
3706 if (!objc_is_gcable_p (lhs
))
3712 && (TREE_CODE (outer
) == COMPONENT_REF
3713 || TREE_CODE (outer
) == ARRAY_REF
))
3714 outer
= TREE_OPERAND (outer
, 0);
3716 if (TREE_CODE (outer
) == INDIRECT_REF
)
3718 outer
= TREE_OPERAND (outer
, 0);
3722 outer_gc_p
= objc_is_gcable_p (outer
);
3724 /* Handle ivar assignments. */
3725 if (objc_is_ivar_reference_p (lhs
))
3727 /* if the struct to the left of the ivar is not an Objective-C object (__strong
3728 doesn't cut it here), the best we can do here is suggest a cast. */
3729 if (!objc_is_gcable_type (TREE_TYPE (outer
), 0))
3731 /* We may still be able to use the global write barrier... */
3732 if (!indirect_p
&& objc_is_global_reference_p (outer
))
3733 goto global_reference
;
3736 if (modifycode
== NOP_EXPR
)
3738 if (warn_assign_intercept
)
3739 warning (0, "strong-cast may possibly be needed");
3745 if (modifycode
!= NOP_EXPR
)
3746 goto invalid_pointer_arithmetic
;
3748 if (warn_assign_intercept
)
3749 warning (0, "instance variable assignment has been intercepted");
3751 result
= objc_build_ivar_assignment (outer
, lhs
, rhs
);
3756 /* Likewise, intercept assignment to global/static variables if their type is
3758 if (objc_is_global_reference_p (outer
))
3764 if (modifycode
!= NOP_EXPR
)
3766 invalid_pointer_arithmetic
:
3768 warning (0, "pointer arithmetic for garbage-collected objects not allowed");
3773 if (warn_assign_intercept
)
3774 warning (0, "global/static variable assignment has been intercepted");
3776 result
= objc_build_global_assignment (lhs
, rhs
);
3779 /* In all other cases, fall back to the normal mechanism. */
3784 /* Implementation of the table mapping a class name (as an identifier)
3785 to a class node. The two public functions for it are
3786 lookup_interface() and add_interface(). add_interface() is only
3787 used in this file, so we can make it static. */
3789 static GTY(()) objc_map_t interface_map
;
3792 interface_hash_init (void)
3794 interface_map
= objc_map_alloc_ggc (200);
3798 add_interface (tree class_name
, tree name
)
3800 /* Put interfaces on list in reverse order. */
3801 TREE_CHAIN (class_name
) = interface_chain
;
3802 interface_chain
= class_name
;
3804 /* Add it to the map. */
3805 objc_map_put (interface_map
, name
, class_name
);
3807 return interface_chain
;
3811 lookup_interface (tree ident
)
3814 if (ident
&& TREE_CODE (ident
) == TYPE_DECL
)
3815 ident
= DECL_NAME (ident
);
3818 if (ident
== NULL_TREE
|| TREE_CODE (ident
) != IDENTIFIER_NODE
)
3822 tree interface
= objc_map_get (interface_map
, ident
);
3824 if (interface
== OBJC_MAP_NOT_FOUND
)
3833 /* Implement @defs (<classname>) within struct bodies. */
3836 objc_get_class_ivars (tree class_name
)
3838 tree interface
= lookup_interface (class_name
);
3841 return get_class_ivars (interface
, true);
3843 error ("cannot find interface declaration for %qE",
3846 return error_mark_node
;
3850 /* Functions used by the hashtable for field duplicates in
3851 objc_detect_field_duplicates(). Ideally, we'd use a standard
3852 key-value dictionary hashtable , and store as keys the field names,
3853 and as values the actual declarations (used to print nice error
3854 messages with the locations). But, the hashtable we are using only
3855 allows us to store keys in the hashtable, without values (it looks
3856 more like a set). So, we store the DECLs, but define equality as
3857 DECLs having the same name, and hash as the hash of the name. */
3859 struct decl_name_hash
: nofree_ptr_hash
<tree_node
>
3861 static inline hashval_t
hash (const tree_node
*);
3862 static inline bool equal (const tree_node
*, const tree_node
*);
3866 decl_name_hash::hash (const tree_node
*q
)
3868 return (hashval_t
) ((intptr_t)(DECL_NAME (q
)) >> 3);
3872 decl_name_hash::equal (const tree_node
*a
, const tree_node
*b
)
3874 return DECL_NAME (a
) == DECL_NAME (b
);
3877 /* Called when checking the variables in a struct. If we are not
3878 doing the ivars list inside an @interface context, then return
3879 false. Else, perform the check for duplicate ivars, then return
3880 true. The check for duplicates checks if an instance variable with
3881 the same name exists in the class or in a superclass. If
3882 'check_superclasses_only' is set to true, then it is assumed that
3883 checks for instance variables in the same class has already been
3884 performed (this is the case for ObjC++) and only the instance
3885 variables of superclasses are checked. */
3887 objc_detect_field_duplicates (bool check_superclasses_only
)
3889 if (!objc_collecting_ivars
|| !objc_interface_context
3890 || TREE_CODE (objc_interface_context
) != CLASS_INTERFACE_TYPE
)
3893 /* We have two ways of doing this check:
3895 "direct comparison": we iterate over the instance variables and
3896 compare them directly. This works great for small numbers of
3897 instance variables (such as 10 or 20), which are extremely common.
3898 But it will potentially take forever for the pathological case with
3899 a huge number (eg, 10k) of instance variables.
3901 "hashtable": we use a hashtable, which requires a single sweep
3902 through the list of instances variables. This is much slower for a
3903 small number of variables, and we only use it for large numbers.
3905 To decide which one to use, we need to get an idea of how many
3906 instance variables we have to compare. */
3908 unsigned int number_of_ivars_to_check
= 0;
3911 for (ivar
= CLASS_RAW_IVARS (objc_interface_context
);
3912 ivar
; ivar
= DECL_CHAIN (ivar
))
3914 /* Ignore anonymous ivars. */
3915 if (DECL_NAME (ivar
))
3916 number_of_ivars_to_check
++;
3920 /* Exit if there is nothing to do. */
3921 if (number_of_ivars_to_check
== 0)
3924 /* In case that there are only 1 or 2 instance variables to check,
3925 we always use direct comparison. If there are more, it is
3926 worth iterating over the instance variables in the superclass
3927 to count how many there are (note that this has the same cost
3928 as checking 1 instance variable by direct comparison, which is
3929 why we skip this check in the case of 1 or 2 ivars and just do
3930 the direct comparison) and then decide if it worth using a
3932 if (number_of_ivars_to_check
> 2)
3934 unsigned int number_of_superclass_ivars
= 0;
3937 for (interface
= lookup_interface (CLASS_SUPER_NAME (objc_interface_context
));
3938 interface
; interface
= lookup_interface (CLASS_SUPER_NAME (interface
)))
3941 for (ivar
= CLASS_RAW_IVARS (interface
);
3942 ivar
; ivar
= DECL_CHAIN (ivar
))
3943 number_of_superclass_ivars
++;
3947 /* We use a hashtable if we have over 10k comparisons. */
3948 if (number_of_ivars_to_check
* (number_of_superclass_ivars
3949 + (number_of_ivars_to_check
/ 2))
3952 /* First, build the hashtable by putting all the instance
3953 variables of superclasses in it. */
3954 hash_table
<decl_name_hash
> htab (37);
3956 for (interface
= lookup_interface (CLASS_SUPER_NAME
3957 (objc_interface_context
));
3958 interface
; interface
= lookup_interface
3959 (CLASS_SUPER_NAME (interface
)))
3962 for (ivar
= CLASS_RAW_IVARS (interface
); ivar
;
3963 ivar
= DECL_CHAIN (ivar
))
3965 if (DECL_NAME (ivar
) != NULL_TREE
)
3967 tree_node
**slot
= htab
.find_slot (ivar
, INSERT
);
3968 /* Do not check for duplicate instance
3969 variables in superclasses. Errors have
3970 already been generated. */
3976 /* Now, we go through all the instance variables in the
3977 class, and check that they are not in the
3979 if (check_superclasses_only
)
3982 for (ivar
= CLASS_RAW_IVARS (objc_interface_context
); ivar
;
3983 ivar
= DECL_CHAIN (ivar
))
3985 if (DECL_NAME (ivar
) != NULL_TREE
)
3987 tree duplicate_ivar
= htab
.find (ivar
);
3988 if (duplicate_ivar
!= HTAB_EMPTY_ENTRY
)
3990 error_at (DECL_SOURCE_LOCATION (ivar
),
3991 "duplicate instance variable %q+D",
3993 inform (DECL_SOURCE_LOCATION (duplicate_ivar
),
3994 "previous declaration of %q+D",
3996 /* FIXME: Do we need the following ? */
3997 /* DECL_NAME (ivar) = NULL_TREE; */
4004 /* If we're checking for duplicates in the class as
4005 well, we insert variables in the hashtable as we
4006 check them, so if a duplicate follows, it will be
4009 for (ivar
= CLASS_RAW_IVARS (objc_interface_context
); ivar
;
4010 ivar
= DECL_CHAIN (ivar
))
4012 if (DECL_NAME (ivar
) != NULL_TREE
)
4014 tree_node
**slot
= htab
.find_slot (ivar
, INSERT
);
4017 tree duplicate_ivar
= (tree
)(*slot
);
4018 error_at (DECL_SOURCE_LOCATION (ivar
),
4019 "duplicate instance variable %q+D",
4021 inform (DECL_SOURCE_LOCATION (duplicate_ivar
),
4022 "previous declaration of %q+D",
4024 /* FIXME: Do we need the following ? */
4025 /* DECL_NAME (ivar) = NULL_TREE; */
4036 /* This is the "direct comparison" approach, which is used in most
4037 non-pathological cases. */
4039 /* Walk up to class hierarchy, starting with this class (this is
4040 the external loop, because lookup_interface() is expensive, and
4041 we want to do it few times). */
4042 tree interface
= objc_interface_context
;
4044 if (check_superclasses_only
)
4045 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
4047 for ( ; interface
; interface
= lookup_interface
4048 (CLASS_SUPER_NAME (interface
)))
4050 tree ivar_being_checked
;
4052 for (ivar_being_checked
= CLASS_RAW_IVARS (objc_interface_context
);
4054 ivar_being_checked
= DECL_CHAIN (ivar_being_checked
))
4058 /* Ignore anonymous ivars. */
4059 if (DECL_NAME (ivar_being_checked
) == NULL_TREE
)
4062 /* Note how we stop when we find the ivar we are checking
4063 (this can only happen in the main class, not
4064 superclasses), to avoid comparing things twice
4065 (otherwise, for each ivar, you'd compare A to B then B
4066 to A, and get duplicated error messages). */
4067 for (decl
= CLASS_RAW_IVARS (interface
);
4068 decl
&& decl
!= ivar_being_checked
;
4069 decl
= DECL_CHAIN (decl
))
4071 if (DECL_NAME (ivar_being_checked
) == DECL_NAME (decl
))
4073 error_at (DECL_SOURCE_LOCATION (ivar_being_checked
),
4074 "duplicate instance variable %q+D",
4075 ivar_being_checked
);
4076 inform (DECL_SOURCE_LOCATION (decl
),
4077 "previous declaration of %q+D",
4079 /* FIXME: Do we need the following ? */
4080 /* DECL_NAME (ivar_being_checked) = NULL_TREE; */
4089 /* Used by: build_private_template, continue_class,
4090 and for @defs constructs. */
4093 get_class_ivars (tree interface
, bool inherited
)
4095 tree ivar_chain
= copy_list (CLASS_RAW_IVARS (interface
));
4097 /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared
4098 by the current class (i.e., they do not include super-class ivars).
4099 However, the CLASS_IVARS list will be side-effected by a call to
4100 finish_struct(), which will fill in field offsets. */
4101 if (!CLASS_IVARS (interface
))
4102 CLASS_IVARS (interface
) = ivar_chain
;
4107 while (CLASS_SUPER_NAME (interface
))
4109 /* Prepend super-class ivars. */
4110 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
4111 ivar_chain
= chainon (copy_list (CLASS_RAW_IVARS (interface
)),
4119 objc_maybe_warn_exceptions (location_t loc
)
4121 /* -fobjc-exceptions is required to enable Objective-C exceptions.
4122 For example, on Darwin, ObjC exceptions require a sufficiently
4123 recent version of the runtime, so the user must ask for them
4124 explicitly. On other platforms, at the moment -fobjc-exceptions
4125 triggers -fexceptions which again is required for exceptions to
4127 if (!flag_objc_exceptions
)
4129 /* Warn only once per compilation unit. */
4130 static bool warned
= false;
4134 error_at (loc
, "%<-fobjc-exceptions%> is required to enable Objective-C exception syntax");
4140 static struct objc_try_context
*cur_try_context
;
4142 /* Called just after parsing the @try and its associated BODY. We now
4143 must prepare for the tricky bits -- handling the catches and finally. */
4146 objc_begin_try_stmt (location_t try_locus
, tree body
)
4148 struct objc_try_context
*c
= XCNEW (struct objc_try_context
);
4149 c
->outer
= cur_try_context
;
4151 c
->try_locus
= try_locus
;
4152 c
->end_try_locus
= input_location
;
4153 cur_try_context
= c
;
4155 /* Collect the list of local variables. We'll mark them as volatile
4156 at the end of compilation of this function to prevent them being
4157 clobbered by setjmp/longjmp. */
4158 if (flag_objc_sjlj_exceptions
)
4159 objc_mark_locals_volatile (NULL
);
4162 /* Called just after parsing "@catch (parm)". Open a binding level,
4163 enter DECL into the binding level, and initialize it. Leave the
4164 binding level open while the body of the compound statement is
4165 parsed. If DECL is NULL_TREE, then we are compiling "@catch(...)"
4166 which we compile as "@catch(id tmp_variable)". */
4169 objc_begin_catch_clause (tree decl
)
4171 tree compound
, type
, t
;
4172 bool ellipsis
= false;
4174 /* Begin a new scope that the entire catch clause will live in. */
4175 compound
= c_begin_compound_stmt (true);
4177 /* Create the appropriate declaration for the argument. */
4178 if (decl
== error_mark_node
)
4179 type
= error_mark_node
;
4182 if (decl
== NULL_TREE
)
4184 /* If @catch(...) was specified, create a temporary variable of
4185 type 'id' and use it. */
4186 decl
= objc_create_temporary_var (objc_object_type
, "__objc_generic_catch_var");
4187 DECL_SOURCE_LOCATION (decl
) = input_location
;
4188 /* ... but allow the runtime to differentiate between ellipsis and the
4189 case of @catch (id xyz). */
4194 /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL. */
4195 decl
= build_decl (input_location
,
4196 VAR_DECL
, DECL_NAME (decl
), TREE_TYPE (decl
));
4198 lang_hooks
.decls
.pushdecl (decl
);
4200 /* Mark the declaration as used so you never any warnings whether
4201 you use the exception argument or not. TODO: Implement a
4202 -Wunused-exception-parameter flag, which would cause warnings
4203 if exception parameter is not used. */
4204 TREE_USED (decl
) = 1;
4205 DECL_READ_P (decl
) = 1;
4207 type
= TREE_TYPE (decl
);
4210 /* Verify that the type of the catch is valid. It must be a pointer
4211 to an Objective-C class, or "id" (which is catch-all). */
4212 if (type
== error_mark_node
)
4214 ;/* Just keep going. */
4216 else if (!objc_type_valid_for_messaging (type
, false))
4218 error ("@catch parameter is not a known Objective-C class type");
4219 type
= error_mark_node
;
4221 else if (TYPE_HAS_OBJC_INFO (TREE_TYPE (type
))
4222 && TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (type
)))
4224 error ("@catch parameter can not be protocol-qualified");
4225 type
= error_mark_node
;
4227 else if (POINTER_TYPE_P (type
) && objc_is_object_id (TREE_TYPE (type
)))
4228 /* @catch (id xyz) or @catch (...) but we note this for runtimes that
4233 /* If 'type' was built using typedefs, we need to get rid of
4234 them and get a simple pointer to the class. */
4235 bool is_typedef
= false;
4236 tree x
= TYPE_MAIN_VARIANT (type
);
4238 /* Skip from the pointer to the pointee. */
4239 if (TREE_CODE (x
) == POINTER_TYPE
)
4242 /* Traverse typedef aliases */
4243 while (TREE_CODE (x
) == RECORD_TYPE
&& OBJC_TYPE_NAME (x
)
4244 && TREE_CODE (OBJC_TYPE_NAME (x
)) == TYPE_DECL
4245 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x
)))
4248 x
= DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x
));
4251 /* If it was a typedef, build a pointer to the final, original
4254 type
= build_pointer_type (x
);
4256 if (cur_try_context
->catch_list
)
4258 /* Examine previous @catch clauses and see if we've already
4259 caught the type in question. */
4260 tree_stmt_iterator i
= tsi_start (cur_try_context
->catch_list
);
4261 for (; !tsi_end_p (i
); tsi_next (&i
))
4263 tree stmt
= tsi_stmt (i
);
4264 t
= CATCH_TYPES (stmt
);
4265 if (t
== error_mark_node
)
4267 if (!t
|| DERIVED_FROM_P (TREE_TYPE (t
), TREE_TYPE (type
)))
4269 warning (0, "exception of type %<%T%> will be caught",
4271 warning_at (EXPR_LOCATION (stmt
), 0, " by earlier handler for %<%T%>",
4272 TREE_TYPE (t
? t
: objc_object_type
));
4279 t
= (*runtime
.begin_catch
) (&cur_try_context
, type
, decl
, compound
, ellipsis
);
4283 /* Called just after parsing the closing brace of a @catch clause. Close
4284 the open binding level, and record a CATCH_EXPR for it. */
4287 objc_finish_catch_clause (void)
4289 tree c
= cur_try_context
->current_catch
;
4290 cur_try_context
->current_catch
= NULL
;
4291 cur_try_context
->end_catch_locus
= input_location
;
4293 CATCH_BODY (c
) = c_end_compound_stmt (input_location
, CATCH_BODY (c
), 1);
4295 (*runtime
.finish_catch
) (&cur_try_context
, c
);
4298 /* Called after parsing a @finally clause and its associated BODY.
4299 Record the body for later placement. */
4302 objc_build_finally_clause (location_t finally_locus
, tree body
)
4304 cur_try_context
->finally_body
= body
;
4305 cur_try_context
->finally_locus
= finally_locus
;
4306 cur_try_context
->end_finally_locus
= input_location
;
4309 /* Called to finalize a @try construct. */
4312 objc_finish_try_stmt (void)
4314 struct objc_try_context
*c
= cur_try_context
;
4317 if (c
->catch_list
== NULL
&& c
->finally_body
== NULL
)
4318 error ("%<@try%> without %<@catch%> or %<@finally%>");
4320 stmt
= (*runtime
.finish_try_stmt
) (&cur_try_context
);
4323 cur_try_context
= c
->outer
;
4329 objc_build_throw_stmt (location_t loc
, tree throw_expr
)
4331 bool rethrown
= false;
4333 objc_maybe_warn_exceptions (loc
);
4335 /* Don't waste time trying to build something if we're already dead. */
4336 if (throw_expr
== error_mark_node
)
4337 return error_mark_node
;
4339 if (throw_expr
== NULL
)
4341 /* If we're not inside a @catch block, there is no "current
4342 exception" to be rethrown. */
4343 if (cur_try_context
== NULL
4344 || cur_try_context
->current_catch
== NULL
)
4346 error_at (loc
, "%<@throw%> (rethrow) used outside of a @catch block");
4347 return error_mark_node
;
4350 /* Otherwise the object is still sitting in the EXC_PTR_EXPR
4351 value that we get from the runtime. */
4352 throw_expr
= (*runtime
.build_exc_ptr
) (&cur_try_context
);
4357 if (!objc_type_valid_for_messaging (TREE_TYPE (throw_expr
), true))
4359 error_at (loc
, "%<@throw%> argument is not an object");
4360 return error_mark_node
;
4364 return (*runtime
.build_throw_stmt
) (loc
, throw_expr
, rethrown
);
4368 objc_build_synchronized (location_t start_locus
, tree object_expr
, tree body
)
4370 /* object_expr should never be NULL; but in case it is, convert it to
4372 if (object_expr
== NULL
)
4373 object_expr
= error_mark_node
;
4375 /* Validate object_expr. If not valid, set it to error_mark_node. */
4376 if (object_expr
!= error_mark_node
)
4378 if (!objc_type_valid_for_messaging (TREE_TYPE (object_expr
), true))
4380 error_at (start_locus
, "%<@synchronized%> argument is not an object");
4381 object_expr
= error_mark_node
;
4385 if (object_expr
== error_mark_node
)
4387 /* If we found an error, we simply ignore the '@synchronized'.
4388 Compile the body so we can keep going with minimal
4390 return add_stmt (body
);
4397 /* objc_sync_enter (object_expr); */
4398 object_expr
= save_expr (object_expr
);
4399 args
= tree_cons (NULL
, object_expr
, NULL
);
4400 call
= build_function_call (input_location
,
4401 objc_sync_enter_decl
, args
);
4402 SET_EXPR_LOCATION (call
, start_locus
);
4405 /* Build "objc_sync_exit (object_expr);" but do not add it yet;
4406 it goes inside the @finalize() clause. */
4407 args
= tree_cons (NULL
, object_expr
, NULL
);
4408 call
= build_function_call (input_location
,
4409 objc_sync_exit_decl
, args
);
4410 SET_EXPR_LOCATION (call
, input_location
);
4412 /* @try { body; } */
4413 objc_begin_try_stmt (start_locus
, body
);
4415 /* @finally { objc_sync_exit (object_expr); } */
4416 objc_build_finally_clause (input_location
, call
);
4418 /* End of try statement. */
4419 return objc_finish_try_stmt ();
4423 /* Construct a C struct corresponding to ObjC class CLASS, with the same
4426 struct <classname> {
4427 struct _objc_class *isa;
4432 build_private_template (tree klass
)
4434 if (!CLASS_STATIC_TEMPLATE (klass
))
4436 tree record
= objc_build_struct (klass
,
4437 get_class_ivars (klass
, false),
4438 CLASS_SUPER_NAME (klass
));
4440 /* Set the TREE_USED bit for this struct, so that stab generator
4441 can emit stabs for this struct type. */
4442 if (flag_debug_only_used_symbols
&& TYPE_STUB_DECL (record
))
4443 TREE_USED (TYPE_STUB_DECL (record
)) = 1;
4445 /* Copy the attributes from the class to the type. */
4446 if (TREE_DEPRECATED (klass
))
4447 TREE_DEPRECATED (record
) = 1;
4451 /* Generate either '- .cxx_construct' or '- .cxx_destruct' for the
4455 objc_generate_cxx_ctor_or_dtor (bool dtor
)
4457 tree fn
, body
, compound_stmt
, ivar
;
4459 /* - (id) .cxx_construct { ... return self; } */
4460 /* - (void) .cxx_construct { ... } */
4462 objc_start_method_definition
4463 (false /* is_class_method */,
4464 objc_build_method_signature (false /* is_class_method */,
4465 build_tree_list (NULL_TREE
,
4468 : objc_object_type
),
4469 get_identifier (dtor
4471 : TAG_CXX_CONSTRUCT
),
4472 make_node (TREE_LIST
),
4473 false), NULL
, NULL_TREE
);
4474 body
= begin_function_body ();
4475 compound_stmt
= begin_compound_stmt (0);
4477 ivar
= CLASS_IVARS (implementation_template
);
4478 /* Destroy ivars in reverse order. */
4480 ivar
= nreverse (copy_list (ivar
));
4482 for (; ivar
; ivar
= TREE_CHAIN (ivar
))
4484 if (TREE_CODE (ivar
) == FIELD_DECL
)
4486 tree type
= TREE_TYPE (ivar
);
4488 /* Call the ivar's default constructor or destructor. Do not
4489 call the destructor unless a corresponding constructor call
4490 has also been made (or is not needed). */
4491 if (MAYBE_CLASS_TYPE_P (type
)
4493 ? (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4494 && (!TYPE_NEEDS_CONSTRUCTING (type
)
4495 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
4496 : (TYPE_NEEDS_CONSTRUCTING (type
)
4497 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))))
4499 (build_special_member_call
4500 (build_ivar_reference (DECL_NAME (ivar
)),
4501 dtor
? complete_dtor_identifier
: complete_ctor_identifier
,
4502 NULL
, type
, LOOKUP_NORMAL
, tf_warning_or_error
));
4506 /* The constructor returns 'self'. */
4508 finish_return_stmt (self_decl
);
4510 finish_compound_stmt (compound_stmt
);
4511 finish_function_body (body
);
4512 fn
= current_function_decl
;
4514 objc_finish_method_definition (fn
);
4517 /* The following routine will examine the current @interface for any
4518 non-POD C++ ivars requiring non-trivial construction and/or
4519 destruction, and then synthesize special '- .cxx_construct' and/or
4520 '- .cxx_destruct' methods which will run the appropriate
4521 construction or destruction code. Note that ivars inherited from
4522 super-classes are _not_ considered. */
4524 objc_generate_cxx_cdtors (void)
4526 bool need_ctor
= false, need_dtor
= false;
4529 /* Error case, due to possibly an extra @end. */
4530 if (!objc_implementation_context
)
4533 /* We do not want to do this for categories, since they do not have
4536 if (TREE_CODE (objc_implementation_context
) != CLASS_IMPLEMENTATION_TYPE
)
4539 /* First, determine if we even need a constructor and/or destructor. */
4541 for (ivar
= CLASS_IVARS (implementation_template
); ivar
;
4542 ivar
= TREE_CHAIN (ivar
))
4544 if (TREE_CODE (ivar
) == FIELD_DECL
)
4546 tree type
= TREE_TYPE (ivar
);
4548 if (MAYBE_CLASS_TYPE_P (type
))
4550 if (TYPE_NEEDS_CONSTRUCTING (type
)
4551 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
4552 /* NB: If a default constructor is not available, we will not
4553 be able to initialize this ivar; the add_instance_variable()
4554 routine will already have warned about this. */
4557 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4558 && (!TYPE_NEEDS_CONSTRUCTING (type
)
4559 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
4560 /* NB: If a default constructor is not available, we will not
4561 call the destructor either, for symmetry. */
4567 /* Generate '- .cxx_construct' if needed. */
4570 objc_generate_cxx_ctor_or_dtor (false);
4572 /* Generate '- .cxx_destruct' if needed. */
4575 objc_generate_cxx_ctor_or_dtor (true);
4577 /* The 'imp_list' variable points at an imp_entry record for the current
4578 @implementation. Record the existence of '- .cxx_construct' and/or
4579 '- .cxx_destruct' methods therein; it will be included in the
4580 metadata for the class if the runtime needs it. */
4581 imp_list
->has_cxx_cdtors
= (need_ctor
|| need_dtor
);
4586 error_with_ivar (const char *message
, tree decl
)
4588 error_at (DECL_SOURCE_LOCATION (decl
), "%s %qs",
4589 message
, identifier_to_locale (gen_declaration (decl
)));
4594 check_ivars (tree inter
, tree imp
)
4596 tree intdecls
= CLASS_RAW_IVARS (inter
);
4597 tree impdecls
= CLASS_RAW_IVARS (imp
);
4604 if (intdecls
&& TREE_CODE (intdecls
) == TYPE_DECL
)
4605 intdecls
= TREE_CHAIN (intdecls
);
4607 if (intdecls
== 0 && impdecls
== 0)
4609 if (intdecls
== 0 || impdecls
== 0)
4611 error ("inconsistent instance variable specification");
4615 t1
= TREE_TYPE (intdecls
); t2
= TREE_TYPE (impdecls
);
4617 if (!comptypes (t1
, t2
)
4618 || !tree_int_cst_equal (DECL_INITIAL (intdecls
),
4619 DECL_INITIAL (impdecls
)))
4621 if (DECL_NAME (intdecls
) == DECL_NAME (impdecls
))
4623 error_with_ivar ("conflicting instance variable type",
4625 error_with_ivar ("previous declaration of",
4628 else /* both the type and the name don't match */
4630 error ("inconsistent instance variable specification");
4635 else if (DECL_NAME (intdecls
) != DECL_NAME (impdecls
))
4637 error_with_ivar ("conflicting instance variable name",
4639 error_with_ivar ("previous declaration of",
4643 intdecls
= DECL_CHAIN (intdecls
);
4644 impdecls
= DECL_CHAIN (impdecls
);
4650 mark_referenced_methods (void)
4652 struct imp_entry
*impent
;
4655 for (impent
= imp_list
; impent
; impent
= impent
->next
)
4657 chain
= CLASS_CLS_METHODS (impent
->imp_context
);
4660 cgraph_node::get_create (METHOD_DEFINITION (chain
))->mark_force_output ();
4661 chain
= DECL_CHAIN (chain
);
4664 chain
= CLASS_NST_METHODS (impent
->imp_context
);
4667 cgraph_node::get_create (METHOD_DEFINITION (chain
))->mark_force_output ();
4668 chain
= DECL_CHAIN (chain
);
4673 /* If type is empty or only type qualifiers are present, add default
4674 type of id (otherwise grokdeclarator will default to int). */
4676 adjust_type_for_id_default (tree type
)
4679 type
= make_node (TREE_LIST
);
4681 if (!TREE_VALUE (type
))
4682 TREE_VALUE (type
) = objc_object_type
;
4683 else if (TREE_CODE (TREE_VALUE (type
)) == RECORD_TYPE
4684 && TYPED_OBJECT (TREE_VALUE (type
)))
4685 error ("can not use an object as parameter to a method");
4690 /* Return a KEYWORD_DECL built using the specified key_name, arg_type,
4691 arg_name and attributes. (TODO: Rename KEYWORD_DECL to
4692 OBJC_METHOD_PARM_DECL ?)
4694 A KEYWORD_DECL is a tree representing the declaration of a
4695 parameter of an Objective-C method. It is produced when parsing a
4696 fragment of Objective-C method declaration of the form
4699 selector ':' '(' typename ')' identifier
4701 For example, take the Objective-C method
4703 -(NSString *)pathForResource:(NSString *)resource ofType:(NSString *)type;
4705 the two fragments "pathForResource:(NSString *)resource" and
4706 "ofType:(NSString *)type" will generate a KEYWORD_DECL each. The
4707 KEYWORD_DECL stores the 'key_name' (eg, identifier for
4708 "pathForResource"), the 'arg_type' (eg, tree representing a
4709 NSString *), the 'arg_name' (eg identifier for "resource") and
4710 potentially some attributes (for example, a tree representing
4711 __attribute__ ((unused)) if such an attribute was attached to a
4712 certain parameter). You can access this information using the
4713 TREE_TYPE (for arg_type), KEYWORD_ARG_NAME (for arg_name),
4714 KEYWORD_KEY_NAME (for key_name), DECL_ATTRIBUTES (for attributes).
4716 'key_name' is an identifier node (and is optional as you can omit
4717 it in Objective-C methods).
4718 'arg_type' is a tree list (and is optional too if no parameter type
4720 'arg_name' is an identifier node and is required.
4721 'attributes' is an optional tree containing parameter attributes. */
4723 objc_build_keyword_decl (tree key_name
, tree arg_type
,
4724 tree arg_name
, tree attributes
)
4728 if (flag_objc1_only
&& attributes
)
4729 error_at (input_location
, "method argument attributes are not available in Objective-C 1.0");
4731 /* If no type is specified, default to "id". */
4732 arg_type
= adjust_type_for_id_default (arg_type
);
4734 keyword_decl
= make_node (KEYWORD_DECL
);
4736 TREE_TYPE (keyword_decl
) = arg_type
;
4737 KEYWORD_ARG_NAME (keyword_decl
) = arg_name
;
4738 KEYWORD_KEY_NAME (keyword_decl
) = key_name
;
4739 DECL_ATTRIBUTES (keyword_decl
) = attributes
;
4741 return keyword_decl
;
4744 /* Given a chain of keyword_decl's, synthesize the full keyword selector. */
4746 build_keyword_selector (tree selector
)
4749 tree key_chain
, key_name
;
4752 /* Scan the selector to see how much space we'll need. */
4753 for (key_chain
= selector
; key_chain
; key_chain
= TREE_CHAIN (key_chain
))
4755 switch (TREE_CODE (selector
))
4758 key_name
= KEYWORD_KEY_NAME (key_chain
);
4761 key_name
= TREE_PURPOSE (key_chain
);
4768 len
+= IDENTIFIER_LENGTH (key_name
) + 1;
4770 /* Just a ':' arg. */
4774 buf
= (char *) alloca (len
+ 1);
4775 /* Start the buffer out as an empty string. */
4778 for (key_chain
= selector
; key_chain
; key_chain
= TREE_CHAIN (key_chain
))
4780 switch (TREE_CODE (selector
))
4783 key_name
= KEYWORD_KEY_NAME (key_chain
);
4786 key_name
= TREE_PURPOSE (key_chain
);
4787 /* The keyword decl chain will later be used as a function
4788 argument chain. Unhook the selector itself so as to not
4789 confuse other parts of the compiler. */
4790 TREE_PURPOSE (key_chain
) = NULL_TREE
;
4797 strcat (buf
, IDENTIFIER_POINTER (key_name
));
4801 return get_identifier_with_length (buf
, len
);
4804 /* Used for declarations and definitions. */
4807 build_method_decl (enum tree_code code
, tree ret_type
, tree selector
,
4808 tree add_args
, bool ellipsis
)
4812 /* If no type is specified, default to "id". */
4813 ret_type
= adjust_type_for_id_default (ret_type
);
4815 /* Note how a method_decl has a TREE_TYPE which is not the function
4816 type of the function implementing the method, but only the return
4817 type of the method. We may want to change this, and store the
4818 entire function type in there (eg, it may be used to simplify
4819 dealing with attributes below). */
4820 method_decl
= make_node (code
);
4821 TREE_TYPE (method_decl
) = ret_type
;
4823 /* If we have a keyword selector, create an identifier_node that
4824 represents the full selector name (`:' included)... */
4825 if (TREE_CODE (selector
) == KEYWORD_DECL
)
4827 METHOD_SEL_NAME (method_decl
) = build_keyword_selector (selector
);
4828 METHOD_SEL_ARGS (method_decl
) = selector
;
4829 METHOD_ADD_ARGS (method_decl
) = add_args
;
4830 METHOD_ADD_ARGS_ELLIPSIS_P (method_decl
) = ellipsis
;
4834 METHOD_SEL_NAME (method_decl
) = selector
;
4835 METHOD_SEL_ARGS (method_decl
) = NULL_TREE
;
4836 METHOD_ADD_ARGS (method_decl
) = NULL_TREE
;
4842 /* This routine processes objective-c method attributes. */
4845 objc_decl_method_attributes (tree
*node
, tree attributes
, int flags
)
4847 /* TODO: Replace the hackery below. An idea would be to store the
4848 full function type in the method declaration (for example in
4849 TREE_TYPE) and then expose ObjC method declarations to c-family
4850 and they could deal with them by simply treating them as
4853 /* Because of the dangers in the hackery below, we filter out any
4854 attribute that we do not know about. For the ones we know about,
4855 we know that they work with the hackery. For the other ones,
4856 there is no guarantee, so we have to filter them out. */
4857 tree filtered_attributes
= NULL_TREE
;
4862 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
4864 tree name
= TREE_PURPOSE (attribute
);
4866 if (is_attribute_p ("deprecated", name
)
4867 || is_attribute_p ("sentinel", name
)
4868 || is_attribute_p ("noreturn", name
))
4870 /* An attribute that we support; add it to the filtered
4872 filtered_attributes
= chainon (filtered_attributes
,
4873 copy_node (attribute
));
4875 else if (is_attribute_p ("format", name
))
4877 /* "format" is special because before adding it to the
4878 filtered attributes we need to adjust the specified
4879 format by adding the hidden function parameters for
4880 an Objective-C method (self, _cmd). */
4881 tree new_attribute
= copy_node (attribute
);
4883 /* Check the arguments specified with the attribute, and
4884 modify them adding 2 for the two hidden arguments.
4885 Note how this differs from C++; according to the
4886 specs, C++ does not do it so you have to add the +1
4887 yourself. For Objective-C, instead, the compiler
4888 adds the +2 for you. */
4890 /* The attribute arguments have not been checked yet, so
4891 we need to be careful as they could be missing or
4892 invalid. If anything looks wrong, we skip the
4893 process and the compiler will complain about it later
4894 when it validates the attribute. */
4895 /* Check that we have at least three arguments. */
4896 if (TREE_VALUE (new_attribute
)
4897 && TREE_CHAIN (TREE_VALUE (new_attribute
))
4898 && TREE_CHAIN (TREE_CHAIN (TREE_VALUE (new_attribute
))))
4900 tree second_argument
= TREE_CHAIN (TREE_VALUE (new_attribute
));
4901 tree third_argument
= TREE_CHAIN (second_argument
);
4904 /* This is the second argument, the "string-index",
4905 which specifies the index of the format string
4907 number
= TREE_VALUE (second_argument
);
4909 && TREE_CODE (number
) == INTEGER_CST
4910 && !wi::eq_p (number
, 0))
4911 TREE_VALUE (second_argument
)
4912 = wide_int_to_tree (TREE_TYPE (number
),
4913 wi::add (number
, 2));
4915 /* This is the third argument, the "first-to-check",
4916 which specifies the index of the first argument to
4917 check. This could be 0, meaning it is not available,
4918 in which case we don't need to add 2. Add 2 if not
4920 number
= TREE_VALUE (third_argument
);
4922 && TREE_CODE (number
) == INTEGER_CST
4923 && !wi::eq_p (number
, 0))
4924 TREE_VALUE (third_argument
)
4925 = wide_int_to_tree (TREE_TYPE (number
),
4926 wi::add (number
, 2));
4928 filtered_attributes
= chainon (filtered_attributes
,
4931 else if (is_attribute_p ("nonnull", name
))
4933 /* We need to fixup all the argument indexes by adding 2
4934 for the two hidden arguments of an Objective-C method
4935 invocation, similat to what we do above for the
4936 "format" attribute. */
4937 /* FIXME: This works great in terms of implementing the
4938 functionality, but the warnings that are produced by
4939 nonnull do mention the argument index (while the
4940 format ones don't). For example, you could get
4941 "warning: null argument where non-null required
4942 (argument 3)". Now in that message, "argument 3"
4943 includes the 2 hidden arguments; it would be much
4944 more friendly to call it "argument 1", as that would
4945 be consistent with __attribute__ ((nonnnull (1))).
4946 To do this, we'd need to have the C family code that
4947 checks the arguments know about adding/removing 2 to
4948 the argument index ... or alternatively we could
4949 maybe store the "printable" argument index in
4950 addition to the actual argument index ? Some
4951 refactoring is needed to do this elegantly. */
4952 tree new_attribute
= copy_node (attribute
);
4953 tree argument
= TREE_VALUE (attribute
);
4954 while (argument
!= NULL_TREE
)
4956 /* Get the value of the argument and add 2. */
4957 tree number
= TREE_VALUE (argument
);
4958 if (number
&& TREE_CODE (number
) == INTEGER_CST
4959 && !wi::eq_p (number
, 0))
4960 TREE_VALUE (argument
)
4961 = wide_int_to_tree (TREE_TYPE (number
),
4962 wi::add (number
, 2));
4963 argument
= TREE_CHAIN (argument
);
4966 filtered_attributes
= chainon (filtered_attributes
,
4970 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
4974 if (filtered_attributes
)
4976 /* This hackery changes the TREE_TYPE of the ObjC method
4977 declaration to be a function type, so that decl_attributes
4978 will treat the ObjC method as if it was a function. Some
4979 attributes (sentinel, format) will be applied to the function
4980 type, changing it in place; so after calling decl_attributes,
4981 we extract the function type attributes and store them in
4982 METHOD_TYPE_ATTRIBUTES. Some other attributes (noreturn,
4983 deprecated) are applied directly to the method declaration
4984 (by setting TREE_DEPRECATED and TREE_THIS_VOLATILE) so there
4985 is nothing to do. */
4986 tree saved_type
= TREE_TYPE (*node
);
4988 = build_function_type_for_method (TREE_VALUE (saved_type
), *node
,
4990 decl_attributes (node
, filtered_attributes
, flags
);
4991 METHOD_TYPE_ATTRIBUTES (*node
) = TYPE_ATTRIBUTES (TREE_TYPE (*node
));
4992 TREE_TYPE (*node
) = saved_type
;
4997 objc_method_decl (enum tree_code opcode
)
4999 return opcode
== INSTANCE_METHOD_DECL
|| opcode
== CLASS_METHOD_DECL
;
5002 /* Return a function type for METHOD with RETURN_TYPE. CONTEXT is
5003 either METHOD_DEF or METHOD_REF, indicating whether we are defining a
5004 method or calling one. SUPER_FLAG indicates whether this is a send
5005 to super; this makes a difference for the NeXT calling sequence in
5006 which the lookup and the method call are done together. If METHOD is
5007 NULL, user-defined arguments (i.e., beyond self and _cmd) shall be
5008 represented as varargs. */
5011 build_function_type_for_method (tree return_type
, tree method
,
5012 int context
, bool super_flag
)
5014 vec
<tree
, va_gc
> *argtypes
= make_tree_vector ();
5016 bool is_varargs
= false;
5018 (*runtime
.get_arg_type_list_base
) (&argtypes
, method
, context
, super_flag
);
5020 /* No actual method prototype given; remaining args passed as varargs. */
5021 if (method
== NULL_TREE
)
5027 for (t
= METHOD_SEL_ARGS (method
); t
; t
= DECL_CHAIN (t
))
5029 tree arg_type
= TREE_VALUE (TREE_TYPE (t
));
5031 /* Decay argument types for the underlying C function as
5033 arg_type
= objc_decay_parm_type (arg_type
);
5035 vec_safe_push (argtypes
, arg_type
);
5038 if (METHOD_ADD_ARGS (method
))
5040 for (t
= TREE_CHAIN (METHOD_ADD_ARGS (method
));
5041 t
; t
= TREE_CHAIN (t
))
5043 tree arg_type
= TREE_TYPE (TREE_VALUE (t
));
5045 arg_type
= objc_decay_parm_type (arg_type
);
5047 vec_safe_push (argtypes
, arg_type
);
5050 if (METHOD_ADD_ARGS_ELLIPSIS_P (method
))
5056 ftype
= build_varargs_function_type_vec (return_type
, argtypes
);
5058 ftype
= build_function_type_vec (return_type
, argtypes
);
5060 release_tree_vector (argtypes
);
5064 /* The 'method' argument is a tree; this tree could either be a single
5065 method, which is returned, or could be a TREE_VEC containing a list
5066 of methods. In that case, the first one is returned, and warnings
5067 are issued as appropriate. */
5069 check_duplicates (tree method
, int methods
, int is_class
)
5074 if (method
== NULL_TREE
)
5077 if (TREE_CODE (method
) != TREE_VEC
)
5080 /* We have two or more methods with the same name but different
5082 first_method
= TREE_VEC_ELT (method
, 0);
5084 /* But just how different are those types? If
5085 -Wno-strict-selector-match is specified, we shall not complain if
5086 the differences are solely among types with identical size and
5088 if (!warn_strict_selector_match
)
5090 for (i
= 0; i
< (size_t) TREE_VEC_LENGTH (method
); i
++)
5091 if (!comp_proto_with_proto (first_method
, TREE_VEC_ELT (method
, i
), 0))
5094 return first_method
;
5100 bool type
= TREE_CODE (first_method
) == INSTANCE_METHOD_DECL
;
5102 warning_at (input_location
, 0,
5103 "multiple methods named %<%c%E%> found",
5104 (is_class
? '+' : '-'),
5105 METHOD_SEL_NAME (first_method
));
5106 inform (DECL_SOURCE_LOCATION (first_method
), "using %<%c%s%>",
5108 identifier_to_locale (gen_method_decl (first_method
)));
5112 bool type
= TREE_CODE (first_method
) == INSTANCE_METHOD_DECL
;
5114 warning_at (input_location
, 0,
5115 "multiple selectors named %<%c%E%> found",
5116 (is_class
? '+' : '-'),
5117 METHOD_SEL_NAME (first_method
));
5118 inform (DECL_SOURCE_LOCATION (first_method
), "found %<%c%s%>",
5120 identifier_to_locale (gen_method_decl (first_method
)));
5123 for (i
= 0; i
< (size_t) TREE_VEC_LENGTH (method
); i
++)
5125 bool type
= TREE_CODE (TREE_VEC_ELT (method
, i
)) == INSTANCE_METHOD_DECL
;
5127 inform (DECL_SOURCE_LOCATION (TREE_VEC_ELT (method
, i
)), "also found %<%c%s%>",
5129 identifier_to_locale (gen_method_decl (TREE_VEC_ELT (method
, i
))));
5132 return first_method
;
5135 /* If RECEIVER is a class reference, return the identifier node for
5136 the referenced class. RECEIVER is created by objc_get_class_reference,
5137 so we check the exact form created depending on which runtimes are
5141 receiver_is_class_object (tree receiver
, int self
, int super
)
5145 /* The receiver is 'self' or 'super' in the context of a class method. */
5146 if (objc_method_context
5147 && TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
5150 ? CLASS_SUPER_NAME (implementation_template
)
5151 : CLASS_NAME (implementation_template
));
5153 /* The runtime might encapsulate things its own way. */
5154 exp
= (*runtime
.receiver_is_class_object
) (receiver
);
5158 /* The receiver is a function call that returns an id. Check if
5159 it is a call to objc_getClass, if so, pick up the class name.
5161 This is required by the GNU runtime, which compiles
5167 [objc_get_class ("NSObject") alloc];
5169 and then, to check that the receiver responds to the +alloc
5170 method, needs to be able to determine that the objc_get_class()
5171 call returns the NSObject class and not just a generic Class
5174 But, traditionally this is enabled for all runtimes, not just the
5175 GNU one, which means that the compiler is smarter than you'd
5176 expect when dealing with objc_getClass(). For example, with the
5177 Apple runtime, in the code
5179 [objc_getClass ("NSObject") alloc];
5181 the compiler will recognize the objc_getClass() call as special
5182 (due to the code below) and so will know that +alloc is called on
5183 the 'NSObject' class, and can perform the corresponding checks.
5185 Programmers can disable this behaviour by casting the results of
5186 objc_getClass() to 'Class' (this may seem weird because
5187 objc_getClass() is already declared to return 'Class', but the
5188 compiler treats it as a special function). This may be useful if
5189 the class is never declared, and the compiler would complain
5190 about a missing @interface for it. Then, you can do
5192 [(Class)objc_getClass ("MyClassNeverDeclared") alloc];
5194 to silence the warnings. */
5195 if (TREE_CODE (receiver
) == CALL_EXPR
5196 && (exp
= CALL_EXPR_FN (receiver
))
5197 && TREE_CODE (exp
) == ADDR_EXPR
5198 && (exp
= TREE_OPERAND (exp
, 0))
5199 && TREE_CODE (exp
) == FUNCTION_DECL
5200 /* For some reason, we sometimes wind up with multiple FUNCTION_DECL
5201 prototypes for objc_get_class(). Thankfully, they seem to share the
5202 same function type. */
5203 && TREE_TYPE (exp
) == TREE_TYPE (objc_get_class_decl
)
5204 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp
)), runtime
.tag_getclass
)
5205 /* We have a call to objc_get_class/objc_getClass! */
5206 && (arg
= CALL_EXPR_ARG (receiver
, 0)))
5209 if (TREE_CODE (arg
) == ADDR_EXPR
5210 && (arg
= TREE_OPERAND (arg
, 0))
5211 && TREE_CODE (arg
) == STRING_CST
)
5212 /* Finally, we have the class name. */
5213 return get_identifier (TREE_STRING_POINTER (arg
));
5218 /* If we are currently building a message expr, this holds
5219 the identifier of the selector of the message. This is
5220 used when printing warnings about argument mismatches. */
5222 static tree current_objc_message_selector
= 0;
5225 objc_message_selector (void)
5227 return current_objc_message_selector
;
5230 /* Construct an expression for sending a message.
5231 MESS has the object to send to in TREE_PURPOSE
5232 and the argument list (including selector) in TREE_VALUE.
5234 (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
5235 (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */
5238 objc_build_message_expr (tree receiver
, tree message_args
)
5242 tree args
= TREE_PURPOSE (message_args
);
5244 tree args
= message_args
;
5246 tree method_params
= NULL_TREE
;
5248 if (TREE_CODE (receiver
) == ERROR_MARK
|| TREE_CODE (args
) == ERROR_MARK
)
5249 return error_mark_node
;
5251 /* Obtain the full selector name. */
5252 switch (TREE_CODE (args
))
5254 case IDENTIFIER_NODE
:
5255 /* A unary selector. */
5259 sel_name
= build_keyword_selector (args
);
5265 /* Build the parameter list to give to the method. */
5266 if (TREE_CODE (args
) == TREE_LIST
)
5268 method_params
= chainon (args
, TREE_VALUE (message_args
));
5271 tree chain
= args
, prev
= NULL_TREE
;
5273 /* We have a keyword selector--check for comma expressions. */
5276 tree element
= TREE_VALUE (chain
);
5278 /* We have a comma expression, must collapse... */
5279 if (TREE_CODE (element
) == TREE_LIST
)
5282 TREE_CHAIN (prev
) = element
;
5287 chain
= TREE_CHAIN (chain
);
5289 method_params
= args
;
5294 if (processing_template_decl
)
5295 /* Must wait until template instantiation time. */
5296 return build_min_nt_loc (UNKNOWN_LOCATION
, MESSAGE_SEND_EXPR
, receiver
,
5297 sel_name
, method_params
);
5300 return objc_finish_message_expr (receiver
, sel_name
, method_params
, NULL
);
5303 /* Look up method SEL_NAME that would be suitable for receiver
5304 of type 'id' (if IS_CLASS is zero) or 'Class' (if IS_CLASS is
5305 nonzero), and report on any duplicates. */
5308 lookup_method_in_hash_lists (tree sel_name
, int is_class
)
5310 tree method_prototype
= OBJC_MAP_NOT_FOUND
;
5313 method_prototype
= objc_map_get (instance_method_map
, sel_name
);
5315 if (method_prototype
== OBJC_MAP_NOT_FOUND
)
5317 method_prototype
= objc_map_get (class_method_map
, sel_name
);
5320 if (method_prototype
== OBJC_MAP_NOT_FOUND
)
5324 return check_duplicates (method_prototype
, 1, is_class
);
5327 /* The 'objc_finish_message_expr' routine is called from within
5328 'objc_build_message_expr' for non-template functions. In the case of
5329 C++ template functions, it is called from 'build_expr_from_tree'
5330 (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded.
5332 If the DEPRECATED_METHOD_PROTOTYPE argument is NULL, then we warn
5333 if the method being used is deprecated. If it is not NULL, instead
5334 of deprecating, we set *DEPRECATED_METHOD_PROTOTYPE to the method
5335 prototype that was used and is deprecated. This is useful for
5336 getter calls that are always generated when compiling dot-syntax
5337 expressions, even if they may not be used. In that case, we don't
5338 want the warning immediately; we produce it (if needed) at gimplify
5339 stage when we are sure that the deprecated getter is being
5342 objc_finish_message_expr (tree receiver
, tree sel_name
, tree method_params
,
5343 tree
*deprecated_method_prototype
)
5345 tree method_prototype
= NULL_TREE
, rprotos
= NULL_TREE
, rtype
;
5346 tree retval
, class_tree
;
5347 int self
, super
, have_cast
;
5349 /* We have used the receiver, so mark it as read. */
5350 mark_exp_read (receiver
);
5352 /* Extract the receiver of the message, as well as its type
5353 (where the latter may take the form of a cast or be inferred
5354 from the implementation context). */
5356 while (TREE_CODE (rtype
) == COMPOUND_EXPR
5357 || TREE_CODE (rtype
) == MODIFY_EXPR
5358 || CONVERT_EXPR_P (rtype
)
5359 || TREE_CODE (rtype
) == COMPONENT_REF
)
5360 rtype
= TREE_OPERAND (rtype
, 0);
5362 /* self is 1 if this is a message to self, 0 otherwise */
5363 self
= (rtype
== self_decl
);
5365 /* super is 1 if this is a message to super, 0 otherwise. */
5366 super
= (rtype
== UOBJC_SUPER_decl
);
5368 /* rtype is the type of the receiver. */
5369 rtype
= TREE_TYPE (receiver
);
5371 /* have_cast is 1 if the receiver is casted. */
5372 have_cast
= (TREE_CODE (receiver
) == NOP_EXPR
5373 || (TREE_CODE (receiver
) == COMPOUND_EXPR
5374 && !IS_SUPER (rtype
)));
5376 /* If we are calling [super dealloc], reset our warning flag. */
5377 if (super
&& !strcmp ("dealloc", IDENTIFIER_POINTER (sel_name
)))
5378 should_call_super_dealloc
= 0;
5380 /* If the receiver is a class object, retrieve the corresponding
5381 @interface, if one exists. class_tree is the class name
5382 identifier, or NULL_TREE if this is not a class method or the
5383 class name could not be determined (as in the case "Class c; [c
5385 class_tree
= receiver_is_class_object (receiver
, self
, super
);
5387 /* Now determine the receiver type (if an explicit cast has not been
5393 /* We are here when we have no cast, and we have a class
5394 name. So, this is a plain method to a class object, as
5395 in [NSObject alloc]. Find the interface corresponding to
5397 rtype
= lookup_interface (class_tree
);
5399 if (rtype
== NULL_TREE
)
5401 /* If 'rtype' is NULL_TREE at this point it means that
5402 we have seen no @interface corresponding to that
5403 class name, only a @class declaration (alternatively,
5404 this was a call such as [objc_getClass("SomeClass")
5405 alloc], where we've never seen the @interface of
5406 SomeClass). So, we have a class name (class_tree)
5407 but no actual details of the class methods. We won't
5408 be able to check that the class responds to the
5409 method, and we will have to guess the method
5410 prototype. Emit a warning, then keep going (this
5411 will use any method with a matching name, as if the
5412 receiver was of type 'Class'). */
5413 warning (0, "@interface of class %qE not found", class_tree
);
5416 /* Handle `self' and `super'. */
5419 if (!CLASS_SUPER_NAME (implementation_template
))
5421 error ("no super class declared in @interface for %qE",
5422 CLASS_NAME (implementation_template
));
5423 return error_mark_node
;
5425 rtype
= lookup_interface (CLASS_SUPER_NAME (implementation_template
));
5428 rtype
= lookup_interface (CLASS_NAME (implementation_template
));
5431 if (objc_is_id (rtype
))
5433 /* The receiver is of type 'id' or 'Class' (with or without some
5434 protocols attached to it). */
5436 /* We set class_tree to the identifier for 'Class' if this is a
5437 class method, and to NULL_TREE if not. */
5438 class_tree
= (IS_CLASS (rtype
) ? objc_class_name
: NULL_TREE
);
5440 /* 'rprotos' is the list of protocols that the receiver
5442 rprotos
= (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype
))
5443 ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype
))
5446 /* We have no information on the type, and we set it to
5450 /* If there are any protocols, check that the method we are
5451 calling appears in the protocol list. If there are no
5452 protocols, this is a message to 'id' or 'Class' and we accept
5453 any method that exists. */
5456 /* If messaging 'id <Protos>' or 'Class <Proto>', first
5457 search in protocols themselves for the method
5460 = lookup_method_in_protocol_list (rprotos
, sel_name
,
5461 class_tree
!= NULL_TREE
);
5463 /* If messaging 'Class <Proto>' but did not find a class
5464 method prototype, search for an instance method instead,
5465 and warn about having done so. */
5466 if (!method_prototype
&& !rtype
&& class_tree
!= NULL_TREE
)
5469 = lookup_method_in_protocol_list (rprotos
, sel_name
, 0);
5471 if (method_prototype
)
5472 warning (0, "found %<-%E%> instead of %<+%E%> in protocol(s)",
5473 sel_name
, sel_name
);
5479 /* We have a receiver type which is more specific than 'id' or
5481 tree orig_rtype
= rtype
;
5483 if (TREE_CODE (rtype
) == POINTER_TYPE
)
5484 rtype
= TREE_TYPE (rtype
);
5485 /* Traverse typedef aliases */
5486 while (TREE_CODE (rtype
) == RECORD_TYPE
&& OBJC_TYPE_NAME (rtype
)
5487 && TREE_CODE (OBJC_TYPE_NAME (rtype
)) == TYPE_DECL
5488 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype
)))
5489 rtype
= DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype
));
5490 if (TYPED_OBJECT (rtype
))
5492 rprotos
= TYPE_OBJC_PROTOCOL_LIST (rtype
);
5493 rtype
= TYPE_OBJC_INTERFACE (rtype
);
5495 if (!rtype
|| TREE_CODE (rtype
) == IDENTIFIER_NODE
)
5497 /* If we could not find an @interface declaration, we must
5498 have only seen a @class declaration; so, we cannot say
5499 anything more intelligent about which methods the
5500 receiver will understand. Note that this only happens
5501 for instance methods; for class methods to a class where
5502 we have only seen a @class declaration,
5503 lookup_interface() above would have set rtype to
5507 /* We could not find an @interface declaration, yet, if
5508 there are protocols attached to the type, we can
5509 still look up the method in the protocols. Ie, we
5510 are in the following case:
5513 MyClass<MyProtocol> *x;
5516 If 'MyProtocol' has the method 'method', we can check
5517 and retrieve the method prototype. */
5519 = lookup_method_in_protocol_list (rprotos
, sel_name
, 0);
5521 /* At this point, if we have found the method_prototype,
5522 we are quite happy. The details of the class are
5523 irrelevant. If we haven't found it, a warning will
5524 have been produced that the method could not be found
5525 in the protocol, and we won't produce further
5526 warnings (please note that this means that "@class
5527 MyClass; MyClass <MyProtocol> *x;" is exactly
5528 equivalent to "id <MyProtocol> x", which isn't too
5529 satisfactory but it's not easy to see how to do
5536 /* We could not find an @interface declaration, and
5537 there are no protocols attached to the receiver,
5538 so we can't complete the check that the receiver
5539 responds to the method, and we can't retrieve the
5540 method prototype. But, because the receiver has
5541 a well-specified class, the programmer did want
5542 this check to be performed. Emit a warning, then
5543 keep going as if it was an 'id'. To remove the
5544 warning, either include an @interface for the
5545 class, or cast the receiver to 'id'. Note that
5546 rtype is an IDENTIFIER_NODE at this point. */
5547 warning (0, "@interface of class %qE not found", rtype
);
5553 else if (TREE_CODE (rtype
) == CLASS_INTERFACE_TYPE
5554 || TREE_CODE (rtype
) == CLASS_IMPLEMENTATION_TYPE
)
5556 /* We have a valid ObjC class name with an associated
5557 @interface. Look up the method name in the published
5558 @interface for the class (and its superclasses). */
5560 = lookup_method_static (rtype
, sel_name
, class_tree
!= NULL_TREE
);
5562 /* If the method was not found in the @interface, it may still
5563 exist locally as part of the @implementation. */
5564 if (!method_prototype
&& objc_implementation_context
5565 && CLASS_NAME (objc_implementation_context
)
5566 == OBJC_TYPE_NAME (rtype
))
5570 ? CLASS_CLS_METHODS (objc_implementation_context
)
5571 : CLASS_NST_METHODS (objc_implementation_context
)),
5574 /* If we haven't found a candidate method by now, try looking for
5575 it in the protocol list. */
5576 if (!method_prototype
&& rprotos
)
5578 = lookup_method_in_protocol_list (rprotos
, sel_name
,
5579 class_tree
!= NULL_TREE
);
5583 /* We have a type, but it's not an Objective-C type (!). */
5584 warning (0, "invalid receiver type %qs",
5585 identifier_to_locale (gen_type_name (orig_rtype
)));
5586 /* After issuing the "invalid receiver" warning, perform method
5587 lookup as if we were messaging 'id'. */
5588 rtype
= rprotos
= NULL_TREE
;
5591 /* Note that rtype could also be NULL_TREE. This happens if we are
5592 messaging a class by name, but the class was only
5593 forward-declared using @class. */
5595 /* For 'id' or 'Class' receivers, search in the global hash table as
5596 a last resort. For all receivers, warn if protocol searches have
5598 if (!method_prototype
)
5601 warning (0, "%<%c%E%> not found in protocol(s)",
5602 (class_tree
? '+' : '-'),
5607 = lookup_method_in_hash_lists (sel_name
, class_tree
!= NULL_TREE
);
5610 if (!method_prototype
)
5612 static bool warn_missing_methods
= false;
5615 warning (0, "%qE may not respond to %<%c%E%>",
5616 OBJC_TYPE_NAME (rtype
),
5617 (class_tree
? '+' : '-'),
5619 /* If we are messaging an 'id' or 'Class' object and made it here,
5620 then we have failed to find _any_ instance or class method,
5623 warning (0, "no %<%c%E%> method found",
5624 (class_tree
? '+' : '-'),
5627 if (!warn_missing_methods
)
5629 warning_at (input_location
,
5630 0, "(Messages without a matching method signature");
5631 warning_at (input_location
,
5632 0, "will be assumed to return %<id%> and accept");
5633 warning_at (input_location
,
5634 0, "%<...%> as arguments.)");
5635 warn_missing_methods
= true;
5640 /* Warn if the method is deprecated, but not if the receiver is
5641 a generic 'id'. 'id' is used to cast an object to a generic
5642 object of an unspecified class; in that case, we'll use
5643 whatever method prototype we can find to get the method
5644 argument and return types, but it is not appropriate to
5645 produce deprecation warnings since we don't know the class
5646 that the object will be of at runtime. The @interface(s) for
5647 that class may not even be available to the compiler right
5648 now, and it is perfectly possible that the method is marked
5649 as non-deprecated in such @interface(s).
5651 In practice this makes sense since casting an object to 'id'
5652 is often used precisely to turn off warnings associated with
5653 the object being of a particular class. */
5654 if (TREE_DEPRECATED (method_prototype
) && rtype
!= NULL_TREE
)
5656 if (deprecated_method_prototype
)
5657 *deprecated_method_prototype
= method_prototype
;
5659 warn_deprecated_use (method_prototype
, NULL_TREE
);
5663 /* Save the selector name for printing error messages. */
5664 current_objc_message_selector
= sel_name
;
5666 /* Build the method call.
5667 TODO: Get the location from somewhere that will work for delayed
5670 retval
= (*runtime
.build_objc_method_call
) (input_location
, method_prototype
,
5671 receiver
, rtype
, sel_name
,
5672 method_params
, super
);
5674 current_objc_message_selector
= 0;
5680 /* This routine creates a static variable used to implement @protocol(MyProtocol)
5681 expression. This variable will be initialized to global protocol_t meta-data
5684 /* This function is called by the parser when (and only when) a
5685 @protocol() expression is found, in order to compile it. */
5687 objc_build_protocol_expr (tree protoname
)
5689 tree p
= lookup_protocol (protoname
, /* warn if deprecated */ true,
5690 /* definition_required */ false);
5694 error ("cannot find protocol declaration for %qE", protoname
);
5695 return error_mark_node
;
5698 return (*runtime
.get_protocol_reference
) (input_location
, p
);
5701 /* This function is called by the parser when a @selector() expression
5702 is found, in order to compile it. It is only called by the parser
5703 and only to compile a @selector(). LOC is the location of the
5706 objc_build_selector_expr (location_t loc
, tree selnamelist
)
5710 /* Obtain the full selector name. */
5711 switch (TREE_CODE (selnamelist
))
5713 case IDENTIFIER_NODE
:
5714 /* A unary selector. */
5715 selname
= selnamelist
;
5718 selname
= build_keyword_selector (selnamelist
);
5724 /* If we are required to check @selector() expressions as they
5725 are found, check that the selector has been declared. */
5726 if (warn_undeclared_selector
)
5728 /* Look the selector up in the list of all known class and
5729 instance methods (up to this line) to check that the selector
5733 /* First try with instance methods. */
5734 method
= objc_map_get (instance_method_map
, selname
);
5736 /* If not found, try with class methods. */
5737 if (method
== OBJC_MAP_NOT_FOUND
)
5739 method
= objc_map_get (class_method_map
, selname
);
5741 /* If still not found, print out a warning. */
5742 if (method
== OBJC_MAP_NOT_FOUND
)
5743 warning (0, "undeclared selector %qE", selname
);
5747 /* The runtimes do this differently, most particularly, GNU has typed
5748 selectors, whilst NeXT does not. */
5749 return (*runtime
.build_selector_reference
) (loc
, selname
, NULL_TREE
);
5753 build_ivar_reference (tree id
)
5756 if (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
)
5758 /* Historically, a class method that produced objects (factory
5759 method) would assign `self' to the instance that it
5760 allocated. This would effectively turn the class method into
5761 an instance method. Following this assignment, the instance
5762 variables could be accessed. That practice, while safe,
5763 violates the simple rule that a class method should not refer
5764 to an instance variable. It's better to catch the cases
5765 where this is done unknowingly than to support the above
5767 warning (0, "instance variable %qE accessed in class method",
5769 self_decl
= convert (objc_instance_type
, self_decl
); /* cast */
5772 base
= build_indirect_ref (input_location
, self_decl
, RO_ARROW
);
5773 return (*runtime
.build_ivar_reference
) (input_location
, base
, id
);
5779 instance_method_map
= objc_map_alloc_ggc (1000);
5780 class_method_map
= objc_map_alloc_ggc (1000);
5782 class_name_map
= objc_map_alloc_ggc (200);
5783 alias_name_map
= objc_map_alloc_ggc (200);
5785 /* Initialize the hash table used to hold the constant string objects. */
5786 string_htab
= hash_table
<objc_string_hasher
>::create_ggc (31);
5789 /* Use the following to add a method to class_method_map or
5790 instance_method_map. It will add the method, keyed by the
5791 METHOD_SEL_NAME. If the method already exists, but with one or
5792 more different prototypes, it will store a TREE_VEC in the map,
5793 with the method prototypes in the vector. */
5795 insert_method_into_method_map (bool class_method
, tree method
)
5797 tree method_name
= METHOD_SEL_NAME (method
);
5798 tree existing_entry
;
5802 map
= class_method_map
;
5804 map
= instance_method_map
;
5806 /* Check if the method already exists in the map. */
5807 existing_entry
= objc_map_get (map
, method_name
);
5809 /* If not, we simply add it to the map. */
5810 if (existing_entry
== OBJC_MAP_NOT_FOUND
)
5811 objc_map_put (map
, method_name
, method
);
5816 /* If an entry already exists, it's more complicated. We'll
5817 have to check whether the method prototype is the same or
5819 if (TREE_CODE (existing_entry
) != TREE_VEC
)
5821 /* If the method prototypes are the same, there is nothing
5823 if (comp_proto_with_proto (method
, existing_entry
, 1))
5826 /* If not, create a vector to store both the method already
5827 in the map, and the new one that we are adding. */
5828 new_entry
= make_tree_vec (2);
5830 TREE_VEC_ELT (new_entry
, 0) = existing_entry
;
5831 TREE_VEC_ELT (new_entry
, 1) = method
;
5835 /* An entry already exists, and it's already a vector. This
5836 means that at least 2 different method prototypes were
5837 already found, and we're considering registering yet
5841 /* Check all the existing prototypes. If any matches the
5842 one we need to add, there is nothing to do because it's
5844 for (i
= 0; i
< (size_t) TREE_VEC_LENGTH (existing_entry
); i
++)
5845 if (comp_proto_with_proto (method
, TREE_VEC_ELT (existing_entry
, i
), 1))
5848 /* Else, create a new, bigger vector and add the new method
5849 at the end of it. This is inefficient but extremely
5850 rare; in any sane program most methods have a single
5851 prototype, and very few, if any, will have more than
5853 new_entry
= make_tree_vec (TREE_VEC_LENGTH (existing_entry
) + 1);
5855 /* Copy the methods from the existing vector. */
5856 for (i
= 0; i
< (size_t) TREE_VEC_LENGTH (existing_entry
); i
++)
5857 TREE_VEC_ELT (new_entry
, i
) = TREE_VEC_ELT (existing_entry
, i
);
5859 /* Add the new method at the end. */
5860 TREE_VEC_ELT (new_entry
, i
) = method
;
5863 /* Store the new vector in the map. */
5864 objc_map_put (map
, method_name
, new_entry
);
5870 lookup_method (tree mchain
, tree method
)
5874 if (TREE_CODE (method
) == IDENTIFIER_NODE
)
5877 key
= METHOD_SEL_NAME (method
);
5881 if (METHOD_SEL_NAME (mchain
) == key
)
5884 mchain
= DECL_CHAIN (mchain
);
5889 /* Look up a class (if OBJC_LOOKUP_CLASS is set in FLAGS) or instance
5890 method in INTERFACE, along with any categories and protocols
5891 attached thereto. If method is not found, and the
5892 OBJC_LOOKUP_NO_SUPER is _not_ set in FLAGS, recursively examine the
5893 INTERFACE's superclass. If OBJC_LOOKUP_CLASS is set,
5894 OBJC_LOOKUP_NO_SUPER is clear, and no suitable class method could
5895 be found in INTERFACE or any of its superclasses, look for an
5896 _instance_ method of the same name in the root class as a last
5897 resort. This behaviour can be turned off by using
5898 OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS.
5900 If a suitable method cannot be found, return NULL_TREE. */
5903 lookup_method_static (tree interface
, tree ident
, int flags
)
5905 tree meth
= NULL_TREE
, root_inter
= NULL_TREE
;
5906 tree inter
= interface
;
5907 int is_class
= (flags
& OBJC_LOOKUP_CLASS
);
5908 int no_superclasses
= (flags
& OBJC_LOOKUP_NO_SUPER
);
5909 int no_instance_methods_of_root_class
= (flags
& OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS
);
5913 tree chain
= is_class
? CLASS_CLS_METHODS (inter
) : CLASS_NST_METHODS (inter
);
5914 tree category
= inter
;
5916 /* First, look up the method in the class itself. */
5917 if ((meth
= lookup_method (chain
, ident
)))
5920 /* Failing that, look for the method in each category of the class. */
5921 while ((category
= CLASS_CATEGORY_LIST (category
)))
5923 chain
= is_class
? CLASS_CLS_METHODS (category
) : CLASS_NST_METHODS (category
);
5925 /* Check directly in each category. */
5926 if ((meth
= lookup_method (chain
, ident
)))
5929 /* Failing that, check in each category's protocols. */
5930 if (CLASS_PROTOCOL_LIST (category
))
5932 if ((meth
= (lookup_method_in_protocol_list
5933 (CLASS_PROTOCOL_LIST (category
), ident
, is_class
))))
5938 /* If not found in categories, check in protocols of the main class. */
5939 if (CLASS_PROTOCOL_LIST (inter
))
5941 if ((meth
= (lookup_method_in_protocol_list
5942 (CLASS_PROTOCOL_LIST (inter
), ident
, is_class
))))
5946 /* If we were instructed not to look in superclasses, don't. */
5947 if (no_superclasses
)
5950 /* Failing that, climb up the inheritance hierarchy. */
5952 inter
= lookup_interface (CLASS_SUPER_NAME (inter
));
5956 if (is_class
&& !no_instance_methods_of_root_class
)
5958 /* If no class (factory) method was found, check if an _instance_
5959 method of the same name exists in the root class. This is what
5960 the Objective-C runtime will do. */
5961 return lookup_method_static (root_inter
, ident
, 0);
5965 /* If an instance method was not found, return 0. */
5971 objc_add_method (tree klass
, tree method
, int is_class
, bool is_optional
)
5973 tree existing_method
= NULL_TREE
;
5975 /* The first thing we do is look up the method in the list of
5976 methods already defined in the interface (or implementation). */
5978 existing_method
= lookup_method (CLASS_CLS_METHODS (klass
), method
);
5980 existing_method
= lookup_method (CLASS_NST_METHODS (klass
), method
);
5982 /* In the case of protocols, we have a second list of methods to
5983 consider, the list of optional ones. */
5984 if (TREE_CODE (klass
) == PROTOCOL_INTERFACE_TYPE
)
5986 /* @required methods are added to the protocol's normal list.
5987 @optional methods are added to the protocol's OPTIONAL lists.
5988 Note that adding the methods to the optional lists disables
5989 checking that the methods are implemented by classes
5990 implementing the protocol, since these checks only use the
5991 CLASS_CLS_METHODS and CLASS_NST_METHODS. */
5993 /* First of all, if the method to add is @optional, and we found
5994 it already existing as @required, emit an error. */
5995 if (is_optional
&& existing_method
)
5997 error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time",
5998 (is_class
? '+' : '-'),
5999 METHOD_SEL_NAME (existing_method
));
6000 inform (DECL_SOURCE_LOCATION (existing_method
),
6001 "previous declaration of %<%c%E%> as %<@required%>",
6002 (is_class
? '+' : '-'),
6003 METHOD_SEL_NAME (existing_method
));
6006 /* Now check the list of @optional methods if we didn't find the
6007 method in the @required list. */
6008 if (!existing_method
)
6011 existing_method
= lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (klass
), method
);
6013 existing_method
= lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (klass
), method
);
6015 if (!is_optional
&& existing_method
)
6017 error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time",
6018 (is_class
? '+' : '-'),
6019 METHOD_SEL_NAME (existing_method
));
6020 inform (DECL_SOURCE_LOCATION (existing_method
),
6021 "previous declaration of %<%c%E%> as %<@optional%>",
6022 (is_class
? '+' : '-'),
6023 METHOD_SEL_NAME (existing_method
));
6028 /* If the method didn't exist already, add it. */
6029 if (!existing_method
)
6035 /* Put the method on the list in reverse order. */
6036 TREE_CHAIN (method
) = PROTOCOL_OPTIONAL_CLS_METHODS (klass
);
6037 PROTOCOL_OPTIONAL_CLS_METHODS (klass
) = method
;
6041 TREE_CHAIN (method
) = PROTOCOL_OPTIONAL_NST_METHODS (klass
);
6042 PROTOCOL_OPTIONAL_NST_METHODS (klass
) = method
;
6049 DECL_CHAIN (method
) = CLASS_CLS_METHODS (klass
);
6050 CLASS_CLS_METHODS (klass
) = method
;
6054 DECL_CHAIN (method
) = CLASS_NST_METHODS (klass
);
6055 CLASS_NST_METHODS (klass
) = method
;
6061 /* The method was already defined. Check that the types match
6062 for an @interface for a class or category, or for a
6063 @protocol. Give hard errors on methods with identical
6064 selectors but differing argument and/or return types. We do
6065 not do this for @implementations, because C/C++ will do it
6066 for us (i.e., there will be duplicate function definition
6068 if ((TREE_CODE (klass
) == CLASS_INTERFACE_TYPE
6069 || TREE_CODE (klass
) == CATEGORY_INTERFACE_TYPE
6070 /* Starting with GCC 4.6, we emit the same error for
6071 protocols too. The situation is identical to
6072 @interfaces as there is no possible meaningful reason
6073 for defining the same method with different signatures
6074 in the very same @protocol. If that was allowed,
6075 whenever the protocol is used (both at compile and run
6076 time) there wouldn't be any meaningful way to decide
6077 which of the two method signatures should be used. */
6078 || TREE_CODE (klass
) == PROTOCOL_INTERFACE_TYPE
)
6079 && !comp_proto_with_proto (method
, existing_method
, 1))
6081 error ("duplicate declaration of method %<%c%E%> with conflicting types",
6082 (is_class
? '+' : '-'),
6083 METHOD_SEL_NAME (existing_method
));
6084 inform (DECL_SOURCE_LOCATION (existing_method
),
6085 "previous declaration of %<%c%E%>",
6086 (is_class
? '+' : '-'),
6087 METHOD_SEL_NAME (existing_method
));
6092 insert_method_into_method_map (true, method
);
6095 insert_method_into_method_map (false, method
);
6097 /* Instance methods in root classes (and categories thereof)
6098 may act as class methods as a last resort. We also add
6099 instance methods listed in @protocol declarations to
6100 the class hash table, on the assumption that @protocols
6101 may be adopted by root classes or categories. */
6102 if (TREE_CODE (klass
) == CATEGORY_INTERFACE_TYPE
6103 || TREE_CODE (klass
) == CATEGORY_IMPLEMENTATION_TYPE
)
6104 klass
= lookup_interface (CLASS_NAME (klass
));
6106 if (TREE_CODE (klass
) == PROTOCOL_INTERFACE_TYPE
6107 || !CLASS_SUPER_NAME (klass
))
6108 insert_method_into_method_map (true, method
);
6115 add_category (tree klass
, tree category
)
6117 /* Put categories on list in reverse order. */
6118 tree cat
= lookup_category (klass
, CLASS_SUPER_NAME (category
));
6122 warning (0, "duplicate interface declaration for category %<%E(%E)%>",
6124 CLASS_SUPER_NAME (category
));
6128 CLASS_CATEGORY_LIST (category
) = CLASS_CATEGORY_LIST (klass
);
6129 CLASS_CATEGORY_LIST (klass
) = category
;
6134 /* A flexible array member is a C99 extension where you can use
6135 "type[]" at the end of a struct to mean a variable-length array.
6137 In Objective-C, instance variables are fundamentally members of a
6138 struct, but the struct can always be extended by subclassing; hence
6139 we need to detect and forbid all instance variables declared using
6140 flexible array members.
6142 No check for this is needed in Objective-C++, since C++ does not
6143 have flexible array members. */
6145 /* Determine whether TYPE is a structure with a flexible array member,
6146 a union containing such a structure (possibly recursively) or an
6147 array of such structures or unions. These are all invalid as
6148 instance variable. */
6150 flexible_array_type_p (tree type
)
6153 switch (TREE_CODE (type
))
6156 x
= TYPE_FIELDS (type
);
6159 while (DECL_CHAIN (x
) != NULL_TREE
)
6161 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
6162 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
6163 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
6164 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
6168 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
6170 if (flexible_array_type_p (TREE_TYPE (x
)))
6174 /* Note that we also check for arrays of something that uses a flexible array member. */
6176 if (flexible_array_type_p (TREE_TYPE (type
)))
6185 /* Produce a printable version of an ivar name. This is only used
6186 inside add_instance_variable. */
6188 printable_ivar_name (tree field_decl
)
6190 if (DECL_NAME (field_decl
))
6191 return identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (field_decl
)));
6193 return _("<unnamed>");
6196 /* Called after parsing each instance variable declaration. Necessary to
6197 preserve typedefs and implement public/private...
6199 VISIBILITY is 1 for public, 0 for protected, and 2 for private. */
6202 add_instance_variable (tree klass
, objc_ivar_visibility_kind visibility
,
6205 tree field_type
= TREE_TYPE (field_decl
);
6208 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
6210 error ("illegal reference type specified for instance variable %qs",
6211 printable_ivar_name (field_decl
));
6212 /* Return class as is without adding this ivar. */
6217 if (field_type
== error_mark_node
|| !TYPE_SIZE (field_type
)
6218 || TYPE_SIZE (field_type
) == error_mark_node
)
6219 /* 'type[0]' is allowed, but 'type[]' is not! */
6221 error ("instance variable %qs has unknown size",
6222 printable_ivar_name (field_decl
));
6223 /* Return class as is without adding this ivar. */
6228 /* Also, in C reject a struct with a flexible array member. Ie,
6230 struct A { int x; int[] y; };
6234 struct A instance_variable;
6238 is not valid because if the class is subclassed, we wouldn't be able
6239 to calculate the offset of the next instance variable. */
6240 if (flexible_array_type_p (field_type
))
6242 error ("instance variable %qs uses flexible array member",
6243 printable_ivar_name (field_decl
));
6244 /* Return class as is without adding this ivar. */
6250 /* Check if the ivar being added has a non-POD C++ type. If so, we will
6251 need to either (1) warn the user about it or (2) generate suitable
6252 constructor/destructor call from '- .cxx_construct' or '- .cxx_destruct'
6253 methods (if '-fobjc-call-cxx-cdtors' was specified). */
6254 if (MAYBE_CLASS_TYPE_P (field_type
)
6255 && (TYPE_NEEDS_CONSTRUCTING (field_type
)
6256 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
)
6257 || TYPE_POLYMORPHIC_P (field_type
)))
6259 tree type_name
= OBJC_TYPE_NAME (field_type
);
6261 if (flag_objc_call_cxx_cdtors
)
6263 /* Since the ObjC runtime will be calling the constructors and
6264 destructors for us, the only thing we can't handle is the lack
6265 of a default constructor. */
6266 if (TYPE_NEEDS_CONSTRUCTING (field_type
)
6267 && !TYPE_HAS_DEFAULT_CONSTRUCTOR (field_type
))
6269 warning (0, "type %qE has no default constructor to call",
6272 /* If we cannot call a constructor, we should also avoid
6273 calling the destructor, for symmetry. */
6274 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
))
6275 warning (0, "destructor for %qE shall not be run either",
6281 static bool warn_cxx_ivars
= false;
6283 if (TYPE_POLYMORPHIC_P (field_type
))
6285 /* Vtable pointers are Real Bad(tm), since Obj-C cannot
6287 error ("type %qE has virtual member functions", type_name
);
6288 error ("illegal aggregate type %qE specified "
6289 "for instance variable %qs",
6290 type_name
, printable_ivar_name (field_decl
));
6291 /* Return class as is without adding this ivar. */
6295 /* User-defined constructors and destructors are not known to Obj-C
6296 and hence will not be called. This may or may not be a problem. */
6297 if (TYPE_NEEDS_CONSTRUCTING (field_type
))
6298 warning (0, "type %qE has a user-defined constructor", type_name
);
6299 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
))
6300 warning (0, "type %qE has a user-defined destructor", type_name
);
6302 if (!warn_cxx_ivars
)
6304 warning (0, "C++ constructors and destructors will not "
6305 "be invoked for Objective-C fields");
6306 warn_cxx_ivars
= true;
6312 /* Overload the public attribute, it is not used for FIELD_DECLs. */
6315 case OBJC_IVAR_VIS_PROTECTED
:
6316 TREE_PUBLIC (field_decl
) = 0;
6317 TREE_PRIVATE (field_decl
) = 0;
6318 TREE_PROTECTED (field_decl
) = 1;
6321 case OBJC_IVAR_VIS_PACKAGE
:
6322 /* TODO: Implement the package variant. */
6323 case OBJC_IVAR_VIS_PUBLIC
:
6324 TREE_PUBLIC (field_decl
) = 1;
6325 TREE_PRIVATE (field_decl
) = 0;
6326 TREE_PROTECTED (field_decl
) = 0;
6329 case OBJC_IVAR_VIS_PRIVATE
:
6330 TREE_PUBLIC (field_decl
) = 0;
6331 TREE_PRIVATE (field_decl
) = 1;
6332 TREE_PROTECTED (field_decl
) = 0;
6337 CLASS_RAW_IVARS (klass
) = chainon (CLASS_RAW_IVARS (klass
), field_decl
);
6342 /* True if the ivar is private and we are not in its implementation. */
6345 is_private (tree decl
)
6347 return (TREE_PRIVATE (decl
)
6348 && ! is_ivar (CLASS_IVARS (implementation_template
),
6352 /* Searches all the instance variables of 'klass' and of its
6353 superclasses for an instance variable whose name (identifier) is
6354 'ivar_name_ident'. Return the declaration (DECL) of the instance
6355 variable, if found, or NULL_TREE, if not found. */
6357 ivar_of_class (tree klass
, tree ivar_name_ident
)
6359 /* First, look up the ivar in CLASS_RAW_IVARS. */
6360 tree decl_chain
= CLASS_RAW_IVARS (klass
);
6362 for ( ; decl_chain
; decl_chain
= DECL_CHAIN (decl_chain
))
6363 if (DECL_NAME (decl_chain
) == ivar_name_ident
)
6366 /* If not found, search up the class hierarchy. */
6367 while (CLASS_SUPER_NAME (klass
))
6369 klass
= lookup_interface (CLASS_SUPER_NAME (klass
));
6371 decl_chain
= CLASS_RAW_IVARS (klass
);
6373 for ( ; decl_chain
; decl_chain
= DECL_CHAIN (decl_chain
))
6374 if (DECL_NAME (decl_chain
) == ivar_name_ident
)
6381 /* We have an instance variable reference;, check to see if it is public. */
6384 objc_is_public (tree expr
, tree identifier
)
6386 tree basetype
, decl
;
6389 if (processing_template_decl
)
6393 if (TREE_TYPE (expr
) == error_mark_node
)
6396 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
6398 if (basetype
&& TREE_CODE (basetype
) == RECORD_TYPE
)
6400 if (TYPE_HAS_OBJC_INFO (basetype
) && TYPE_OBJC_INTERFACE (basetype
))
6402 tree klass
= lookup_interface (OBJC_TYPE_NAME (basetype
));
6406 error ("cannot find interface declaration for %qE",
6407 OBJC_TYPE_NAME (basetype
));
6411 if ((decl
= ivar_of_class (klass
, identifier
)))
6413 if (TREE_PUBLIC (decl
))
6416 /* Important difference between the Stepstone translator:
6417 all instance variables should be public within the context
6418 of the implementation. */
6419 if (objc_implementation_context
6420 && ((TREE_CODE (objc_implementation_context
)
6421 == CLASS_IMPLEMENTATION_TYPE
)
6422 || (TREE_CODE (objc_implementation_context
)
6423 == CATEGORY_IMPLEMENTATION_TYPE
)))
6425 tree curtype
= TYPE_MAIN_VARIANT
6426 (CLASS_STATIC_TEMPLATE
6427 (implementation_template
));
6429 if (basetype
== curtype
6430 || DERIVED_FROM_P (basetype
, curtype
))
6432 int priv
= is_private (decl
);
6435 error ("instance variable %qE is declared private",
6442 /* The 2.95.2 compiler sometimes allowed C functions to access
6443 non-@public ivars. We will let this slide for now... */
6444 if (!objc_method_context
)
6446 warning (0, "instance variable %qE is %s; "
6447 "this will be a hard error in the future",
6449 TREE_PRIVATE (decl
) ? "@private" : "@protected");
6453 error ("instance variable %qE is declared %s",
6455 TREE_PRIVATE (decl
) ? "private" : "protected");
6464 /* Make sure all methods in CHAIN (a list of method declarations from
6465 an @interface or a @protocol) are in IMPLEMENTATION (the
6466 implementation context). This is used to check for example that
6467 all methods declared in an @interface were implemented in an
6470 Some special methods (property setters/getters) are special and if
6471 they are not found in IMPLEMENTATION, we look them up in its
6475 check_methods (tree chain
, tree implementation
, int mtype
)
6480 if (mtype
== (int)'+')
6481 list
= CLASS_CLS_METHODS (implementation
);
6483 list
= CLASS_NST_METHODS (implementation
);
6487 /* If the method is associated with a dynamic property, then it
6488 is Ok not to have the method implementation, as it will be
6489 generated dynamically at runtime. To decide if the method is
6490 associated with a @dynamic property, we search the list of
6491 @synthesize and @dynamic for this implementation, and look
6492 for any @dynamic property with the same setter or getter name
6495 for (x
= IMPL_PROPERTY_DECL (implementation
); x
; x
= TREE_CHAIN (x
))
6496 if (PROPERTY_DYNAMIC (x
)
6497 && (PROPERTY_GETTER_NAME (x
) == METHOD_SEL_NAME (chain
)
6498 || PROPERTY_SETTER_NAME (x
) == METHOD_SEL_NAME (chain
)))
6503 chain
= TREE_CHAIN (chain
); /* next method... */
6507 if (!lookup_method (list
, chain
))
6509 /* If the method is a property setter/getter, we'll still
6510 allow it to be missing if it is implemented by
6511 'interface' or any of its superclasses. */
6512 tree property
= METHOD_PROPERTY_CONTEXT (chain
);
6515 /* Note that since this is a property getter/setter, it
6516 is obviously an instance method. */
6517 tree interface
= NULL_TREE
;
6519 /* For a category, first check the main class
6521 if (TREE_CODE (implementation
) == CATEGORY_IMPLEMENTATION_TYPE
)
6523 interface
= lookup_interface (CLASS_NAME (implementation
));
6525 /* If the method is found in the main class, it's Ok. */
6526 if (lookup_method (CLASS_NST_METHODS (interface
), chain
))
6528 chain
= DECL_CHAIN (chain
);
6532 /* Else, get the superclass. */
6533 if (CLASS_SUPER_NAME (interface
))
6534 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
6536 interface
= NULL_TREE
;
6539 /* Get the superclass for classes. */
6540 if (TREE_CODE (implementation
) == CLASS_IMPLEMENTATION_TYPE
)
6542 if (CLASS_SUPER_NAME (implementation
))
6543 interface
= lookup_interface (CLASS_SUPER_NAME (implementation
));
6545 interface
= NULL_TREE
;
6548 /* Now, interface is the superclass, if any; go check it. */
6551 if (lookup_method_static (interface
, chain
, 0))
6553 chain
= DECL_CHAIN (chain
);
6557 /* Else, fall through - warn. */
6561 switch (TREE_CODE (implementation
))
6563 case CLASS_IMPLEMENTATION_TYPE
:
6564 warning (0, "incomplete implementation of class %qE",
6565 CLASS_NAME (implementation
));
6567 case CATEGORY_IMPLEMENTATION_TYPE
:
6568 warning (0, "incomplete implementation of category %qE",
6569 CLASS_SUPER_NAME (implementation
));
6577 warning (0, "method definition for %<%c%E%> not found",
6578 mtype
, METHOD_SEL_NAME (chain
));
6581 chain
= DECL_CHAIN (chain
);
6587 /* Check if KLASS, or its superclasses, explicitly conforms to PROTOCOL. */
6590 conforms_to_protocol (tree klass
, tree protocol
)
6592 if (TREE_CODE (protocol
) == PROTOCOL_INTERFACE_TYPE
)
6594 tree p
= CLASS_PROTOCOL_LIST (klass
);
6595 while (p
&& TREE_VALUE (p
) != protocol
)
6600 tree super
= (CLASS_SUPER_NAME (klass
)
6601 ? lookup_interface (CLASS_SUPER_NAME (klass
))
6603 int tmp
= super
? conforms_to_protocol (super
, protocol
) : 0;
6612 /* Make sure all methods in CHAIN are accessible as MTYPE methods in
6613 CONTEXT. This is one of two mechanisms to check protocol integrity. */
6616 check_methods_accessible (tree chain
, tree context
, int mtype
)
6620 tree base_context
= context
;
6624 /* If the method is associated with a dynamic property, then it
6625 is Ok not to have the method implementation, as it will be
6626 generated dynamically at runtime. Search for any @dynamic
6627 property with the same setter or getter name as this
6628 method. TODO: Use a hashtable lookup. */
6630 for (x
= IMPL_PROPERTY_DECL (base_context
); x
; x
= TREE_CHAIN (x
))
6631 if (PROPERTY_DYNAMIC (x
)
6632 && (PROPERTY_GETTER_NAME (x
) == METHOD_SEL_NAME (chain
)
6633 || PROPERTY_SETTER_NAME (x
) == METHOD_SEL_NAME (chain
)))
6638 chain
= TREE_CHAIN (chain
); /* next method... */
6642 context
= base_context
;
6646 list
= CLASS_CLS_METHODS (context
);
6648 list
= CLASS_NST_METHODS (context
);
6650 if (lookup_method (list
, chain
))
6653 switch (TREE_CODE (context
))
6655 case CLASS_IMPLEMENTATION_TYPE
:
6656 case CLASS_INTERFACE_TYPE
:
6657 context
= (CLASS_SUPER_NAME (context
)
6658 ? lookup_interface (CLASS_SUPER_NAME (context
))
6661 case CATEGORY_IMPLEMENTATION_TYPE
:
6662 case CATEGORY_INTERFACE_TYPE
:
6663 context
= (CLASS_NAME (context
)
6664 ? lookup_interface (CLASS_NAME (context
))
6672 if (context
== NULL_TREE
)
6676 switch (TREE_CODE (objc_implementation_context
))
6678 case CLASS_IMPLEMENTATION_TYPE
:
6679 warning (0, "incomplete implementation of class %qE",
6680 CLASS_NAME (objc_implementation_context
));
6682 case CATEGORY_IMPLEMENTATION_TYPE
:
6683 warning (0, "incomplete implementation of category %qE",
6684 CLASS_SUPER_NAME (objc_implementation_context
));
6691 warning (0, "method definition for %<%c%E%> not found",
6692 mtype
, METHOD_SEL_NAME (chain
));
6695 chain
= TREE_CHAIN (chain
); /* next method... */
6700 /* Check whether the current interface (accessible via
6701 'objc_implementation_context') actually implements protocol P, along
6702 with any protocols that P inherits. */
6705 check_protocol (tree p
, const char *type
, tree name
)
6707 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
6711 /* Ensure that all protocols have bodies! */
6714 f1
= check_methods (PROTOCOL_CLS_METHODS (p
),
6715 objc_implementation_context
,
6717 f2
= check_methods (PROTOCOL_NST_METHODS (p
),
6718 objc_implementation_context
,
6723 f1
= check_methods_accessible (PROTOCOL_CLS_METHODS (p
),
6724 objc_implementation_context
,
6726 f2
= check_methods_accessible (PROTOCOL_NST_METHODS (p
),
6727 objc_implementation_context
,
6732 warning (0, "%s %qE does not fully implement the %qE protocol",
6733 type
, name
, PROTOCOL_NAME (p
));
6736 /* Check protocols recursively. */
6737 if (PROTOCOL_LIST (p
))
6739 tree subs
= PROTOCOL_LIST (p
);
6741 lookup_interface (CLASS_SUPER_NAME (implementation_template
));
6745 tree sub
= TREE_VALUE (subs
);
6747 /* If the superclass does not conform to the protocols
6748 inherited by P, then we must! */
6749 if (!super_class
|| !conforms_to_protocol (super_class
, sub
))
6750 check_protocol (sub
, type
, name
);
6751 subs
= TREE_CHAIN (subs
);
6756 /* Check whether the current interface (accessible via
6757 'objc_implementation_context') actually implements the protocols listed
6761 check_protocols (tree proto_list
, const char *type
, tree name
)
6763 for ( ; proto_list
; proto_list
= TREE_CHAIN (proto_list
))
6765 tree p
= TREE_VALUE (proto_list
);
6767 check_protocol (p
, type
, name
);
6771 /* Make sure that the class CLASS_NAME is defined CODE says which kind
6772 of thing CLASS_NAME ought to be. It can be CLASS_INTERFACE_TYPE,
6773 CLASS_IMPLEMENTATION_TYPE, CATEGORY_INTERFACE_TYPE, or
6774 CATEGORY_IMPLEMENTATION_TYPE. For a CATEGORY_INTERFACE_TYPE,
6775 SUPER_NAME is the name of the category. For a class extension,
6776 CODE is CATEGORY_INTERFACE_TYPE and SUPER_NAME is NULL_TREE. */
6778 start_class (enum tree_code code
, tree class_name
, tree super_name
,
6779 tree protocol_list
, tree attributes
)
6781 tree klass
= NULL_TREE
;
6785 if (current_namespace
!= global_namespace
)
6787 error ("Objective-C declarations may only appear in global scope");
6789 #endif /* OBJCPLUS */
6791 if (objc_implementation_context
)
6793 warning (0, "%<@end%> missing in implementation context");
6794 finish_class (objc_implementation_context
);
6795 objc_ivar_chain
= NULL_TREE
;
6796 objc_implementation_context
= NULL_TREE
;
6799 /* If this is a class extension, we'll be "reopening" the existing
6800 CLASS_INTERFACE_TYPE, so in that case there is no need to create
6802 if (code
!= CATEGORY_INTERFACE_TYPE
|| super_name
!= NULL_TREE
)
6804 klass
= make_node (code
);
6805 TYPE_LANG_SLOT_1 (klass
) = make_tree_vec (CLASS_LANG_SLOT_ELTS
);
6808 /* Check for existence of the super class, if one was specified. Note
6809 that we must have seen an @interface, not just a @class. If we
6810 are looking at a @compatibility_alias, traverse it first. */
6811 if ((code
== CLASS_INTERFACE_TYPE
|| code
== CLASS_IMPLEMENTATION_TYPE
)
6814 tree super
= objc_is_class_name (super_name
);
6815 tree super_interface
= NULL_TREE
;
6818 super_interface
= lookup_interface (super
);
6820 if (!super_interface
)
6822 error ("cannot find interface declaration for %qE, superclass of %qE",
6823 super
? super
: super_name
,
6825 super_name
= NULL_TREE
;
6829 if (TREE_DEPRECATED (super_interface
))
6830 warning (OPT_Wdeprecated_declarations
, "class %qE is deprecated",
6836 if (code
!= CATEGORY_INTERFACE_TYPE
|| super_name
!= NULL_TREE
)
6838 CLASS_NAME (klass
) = class_name
;
6839 CLASS_SUPER_NAME (klass
) = super_name
;
6840 CLASS_CLS_METHODS (klass
) = NULL_TREE
;
6843 if (! objc_is_class_name (class_name
)
6844 && (decl
= lookup_name (class_name
)))
6846 error ("%qE redeclared as different kind of symbol",
6848 error ("previous declaration of %q+D",
6854 case CLASS_IMPLEMENTATION_TYPE
:
6858 for (chain
= implemented_classes
; chain
; chain
= TREE_CHAIN (chain
))
6859 if (TREE_VALUE (chain
) == class_name
)
6861 error ("reimplementation of class %qE",
6863 /* TODO: error message saying where it was previously
6867 if (chain
== NULL_TREE
)
6868 implemented_classes
= tree_cons (NULL_TREE
, class_name
,
6869 implemented_classes
);
6872 /* Reset for multiple classes per file. */
6875 objc_implementation_context
= klass
;
6877 /* Lookup the interface for this implementation. */
6879 if (!(implementation_template
= lookup_interface (class_name
)))
6881 warning (0, "cannot find interface declaration for %qE",
6883 add_interface (implementation_template
= objc_implementation_context
,
6887 /* If a super class has been specified in the implementation,
6888 insure it conforms to the one specified in the interface. */
6891 && (super_name
!= CLASS_SUPER_NAME (implementation_template
)))
6893 tree previous_name
= CLASS_SUPER_NAME (implementation_template
);
6894 error ("conflicting super class name %qE",
6897 error ("previous declaration of %qE", previous_name
);
6899 error ("previous declaration");
6902 else if (! super_name
)
6904 CLASS_SUPER_NAME (objc_implementation_context
)
6905 = CLASS_SUPER_NAME (implementation_template
);
6909 case CLASS_INTERFACE_TYPE
:
6910 if (lookup_interface (class_name
))
6912 error ("duplicate interface declaration for class %qE", class_name
);
6914 warning (0, "duplicate interface declaration for class %qE", class_name
);
6917 add_interface (klass
, class_name
);
6920 CLASS_PROTOCOL_LIST (klass
)
6921 = lookup_and_install_protocols (protocol_list
, /* definition_required */ true);
6926 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
6928 tree name
= TREE_PURPOSE (attribute
);
6930 /* TODO: Document what the objc_exception attribute is/does. */
6931 /* We handle the 'deprecated' and (undocumented) 'objc_exception'
6933 if (is_attribute_p ("deprecated", name
))
6934 TREE_DEPRECATED (klass
) = 1;
6935 else if (is_attribute_p ("objc_exception", name
))
6936 CLASS_HAS_EXCEPTION_ATTR (klass
) = 1;
6938 /* Warn about and ignore all others for now, but store them. */
6939 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
6941 TYPE_ATTRIBUTES (klass
) = attributes
;
6945 case CATEGORY_INTERFACE_TYPE
:
6947 tree class_category_is_assoc_with
;
6949 /* For a category, class_name is really the name of the class that
6950 the following set of methods will be associated with. We must
6951 find the interface so that can derive the objects template. */
6952 if (!(class_category_is_assoc_with
= lookup_interface (class_name
)))
6954 error ("cannot find interface declaration for %qE",
6956 exit (FATAL_EXIT_CODE
);
6960 if (TREE_DEPRECATED (class_category_is_assoc_with
))
6961 warning (OPT_Wdeprecated_declarations
, "class %qE is deprecated",
6964 if (super_name
== NULL_TREE
)
6966 /* This is a class extension. Get the original
6967 interface, and continue working on it. */
6968 objc_in_class_extension
= true;
6969 klass
= class_category_is_assoc_with
;
6973 /* Append protocols to the original protocol
6975 CLASS_PROTOCOL_LIST (klass
)
6976 = chainon (CLASS_PROTOCOL_LIST (klass
),
6977 lookup_and_install_protocols
6979 /* definition_required */ true));
6984 add_category (class_category_is_assoc_with
, klass
);
6987 CLASS_PROTOCOL_LIST (klass
)
6988 = lookup_and_install_protocols
6989 (protocol_list
, /* definition_required */ true);
6995 case CATEGORY_IMPLEMENTATION_TYPE
:
6996 /* Reset for multiple classes per file. */
6999 objc_implementation_context
= klass
;
7001 /* For a category, class_name is really the name of the class that
7002 the following set of methods will be associated with. We must
7003 find the interface so that can derive the objects template. */
7005 if (!(implementation_template
= lookup_interface (class_name
)))
7007 error ("cannot find interface declaration for %qE",
7009 exit (FATAL_EXIT_CODE
);
7019 continue_class (tree klass
)
7021 switch (TREE_CODE (klass
))
7023 case CLASS_IMPLEMENTATION_TYPE
:
7024 case CATEGORY_IMPLEMENTATION_TYPE
:
7026 struct imp_entry
*imp_entry
;
7028 /* Check consistency of the instance variables. */
7030 if (CLASS_RAW_IVARS (klass
))
7031 check_ivars (implementation_template
, klass
);
7033 /* code generation */
7035 push_lang_context (lang_name_c
);
7037 build_private_template (implementation_template
);
7038 uprivate_record
= CLASS_STATIC_TEMPLATE (implementation_template
);
7039 objc_instance_type
= build_pointer_type (uprivate_record
);
7041 imp_entry
= ggc_alloc
<struct imp_entry
> ();
7043 imp_entry
->next
= imp_list
;
7044 imp_entry
->imp_context
= klass
;
7045 imp_entry
->imp_template
= implementation_template
;
7046 ucls_super_ref
= uucls_super_ref
= NULL
;
7047 if (TREE_CODE (klass
) == CLASS_IMPLEMENTATION_TYPE
)
7049 imp_entry
->class_decl
= (*runtime
.class_decl
) (klass
);
7050 imp_entry
->meta_decl
= (*runtime
.metaclass_decl
) (klass
);
7054 imp_entry
->class_decl
= (*runtime
.category_decl
) (klass
);
7055 imp_entry
->meta_decl
= NULL
;
7057 imp_entry
->has_cxx_cdtors
= 0;
7059 /* Append to front and increment count. */
7060 imp_list
= imp_entry
;
7061 if (TREE_CODE (klass
) == CLASS_IMPLEMENTATION_TYPE
)
7066 pop_lang_context ();
7067 #endif /* OBJCPLUS */
7069 return get_class_ivars (implementation_template
, true);
7072 case CLASS_INTERFACE_TYPE
:
7074 if (objc_in_class_extension
)
7077 push_lang_context (lang_name_c
);
7078 #endif /* OBJCPLUS */
7079 objc_collecting_ivars
= 1;
7080 build_private_template (klass
);
7081 objc_collecting_ivars
= 0;
7083 pop_lang_context ();
7084 #endif /* OBJCPLUS */
7089 return error_mark_node
;
7093 /* This routine builds name of the setter synthesized function. */
7095 objc_build_property_setter_name (tree ident
)
7097 /* TODO: Use alloca to allocate buffer of appropriate size. */
7098 static char string
[BUFSIZE
];
7099 sprintf (string
, "set%s:", IDENTIFIER_POINTER (ident
));
7100 string
[3] = TOUPPER (string
[3]);
7104 /* This routine prepares the declarations of the property accessor
7105 helper functions (objc_getProperty(), etc) that are used when
7106 @synthesize is used.
7108 runtime-specific routines are built in the respective runtime
7109 initialize functions. */
7111 build_common_objc_property_accessor_helpers (void)
7115 /* Declare the following function:
7117 objc_getProperty (id self, SEL _cmd,
7118 ptrdiff_t offset, BOOL is_atomic); */
7119 type
= build_function_type_list (objc_object_type
,
7125 objc_getProperty_decl
= add_builtin_function ("objc_getProperty",
7126 type
, 0, NOT_BUILT_IN
,
7128 TREE_NOTHROW (objc_getProperty_decl
) = 0;
7130 /* Declare the following function:
7132 objc_setProperty (id self, SEL _cmd,
7133 ptrdiff_t offset, id new_value,
7134 BOOL is_atomic, BOOL should_copy); */
7135 type
= build_function_type_list (void_type_node
,
7143 objc_setProperty_decl
= add_builtin_function ("objc_setProperty",
7144 type
, 0, NOT_BUILT_IN
,
7146 TREE_NOTHROW (objc_setProperty_decl
) = 0;
7149 /* This looks up an ivar in a class (including superclasses). */
7151 lookup_ivar (tree interface
, tree instance_variable_name
)
7157 for (decl_chain
= CLASS_IVARS (interface
); decl_chain
; decl_chain
= DECL_CHAIN (decl_chain
))
7158 if (DECL_NAME (decl_chain
) == instance_variable_name
)
7161 /* Not found. Search superclass if any. */
7162 if (CLASS_SUPER_NAME (interface
))
7163 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
7169 /* This routine synthesizes a 'getter' method. This is only called
7170 for @synthesize properties. */
7172 objc_synthesize_getter (tree klass
, tree class_methods ATTRIBUTE_UNUSED
, tree property
)
7174 location_t location
= DECL_SOURCE_LOCATION (property
);
7179 /* If user has implemented a getter with same name then do nothing. */
7180 if (lookup_method (CLASS_NST_METHODS (objc_implementation_context
),
7181 PROPERTY_GETTER_NAME (property
)))
7184 /* Find declaration of the property getter in the interface (or
7185 superclass, or protocol). There must be one. */
7186 decl
= lookup_method_static (klass
, PROPERTY_GETTER_NAME (property
), 0);
7188 /* If one not declared in the interface, this condition has already
7189 been reported as user error (because property was not declared in
7194 /* Adapt the 'decl'. Use the source location of the @synthesize
7195 statement for error messages. */
7196 decl
= copy_node (decl
);
7197 DECL_SOURCE_LOCATION (decl
) = location
;
7199 objc_start_method_definition (false /* is_class_method */, decl
, NULL_TREE
,
7201 body
= c_begin_compound_stmt (true);
7203 /* Now we need to decide how we build the getter. There are three
7206 for 'copy' or 'retain' properties we need to use the
7207 objc_getProperty() accessor helper which knows about retain and
7208 copy. It supports both 'nonatomic' and 'atomic' access.
7210 for 'nonatomic, assign' properties we can access the instance
7211 variable directly. 'nonatomic' means we don't have to use locks,
7212 and 'assign' means we don't have to worry about retain or copy.
7213 If you combine the two, it means we can just access the instance
7216 for 'atomic, assign' properties we use objc_copyStruct() (for the
7217 next runtime) or objc_getPropertyStruct() (for the GNU runtime). */
7218 switch (PROPERTY_ASSIGN_SEMANTICS (property
))
7220 case OBJC_PROPERTY_RETAIN
:
7221 case OBJC_PROPERTY_COPY
:
7223 /* We build "return objc_getProperty (self, _cmd, offset, is_atomic);" */
7224 tree cmd
, ivar
, offset
, is_atomic
;
7225 cmd
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
7227 /* Find the ivar to compute the offset. */
7228 ivar
= lookup_ivar (klass
, PROPERTY_IVAR_NAME (property
));
7229 if (!ivar
|| is_private (ivar
))
7231 /* This should never happen. */
7233 "can not find instance variable associated with property");
7234 ret_val
= error_mark_node
;
7237 offset
= byte_position (ivar
);
7239 if (PROPERTY_NONATOMIC (property
))
7240 is_atomic
= boolean_false_node
;
7242 is_atomic
= boolean_true_node
;
7244 ret_val
= build_function_call
7246 /* Function prototype. */
7247 objc_getProperty_decl
,
7249 tree_cons
/* self */
7250 (NULL_TREE
, self_decl
,
7251 tree_cons
/* _cmd */
7253 tree_cons
/* offset */
7255 tree_cons
/* is_atomic */
7256 (NULL_TREE
, is_atomic
, NULL_TREE
)))));
7259 case OBJC_PROPERTY_ASSIGN
:
7260 if (PROPERTY_NONATOMIC (property
))
7262 /* We build "return self->PROPERTY_IVAR_NAME;" */
7263 ret_val
= objc_lookup_ivar (NULL_TREE
, PROPERTY_IVAR_NAME (property
));
7269 <property type> __objc_property_temp;
7270 objc_getPropertyStruct (&__objc_property_temp,
7271 &(self->PROPERTY_IVAR_NAME),
7272 sizeof (type of self->PROPERTY_IVAR_NAME),
7275 return __objc_property_temp;
7277 For the NeXT runtime, we need to use objc_copyStruct
7278 instead of objc_getPropertyStruct. */
7279 tree objc_property_temp_decl
, function_decl
, function_call
;
7280 tree size_of
, is_atomic
;
7282 objc_property_temp_decl
= objc_create_temporary_var (TREE_TYPE (property
), "__objc_property_temp");
7283 DECL_SOURCE_LOCATION (objc_property_temp_decl
) = location
;
7284 objc_property_temp_decl
= lang_hooks
.decls
.pushdecl (objc_property_temp_decl
);
7286 /* sizeof (ivar type). Since the ivar and the property have
7287 the same type, there is no need to lookup the ivar. */
7288 size_of
= c_sizeof_or_alignof_type (location
, TREE_TYPE (property
),
7289 true /* is_sizeof */,
7290 false /* min_alignof */,
7291 false /* complain */);
7293 if (PROPERTY_NONATOMIC (property
))
7294 is_atomic
= boolean_false_node
;
7296 is_atomic
= boolean_true_node
;
7298 if (objc_copyStruct_decl
)
7299 function_decl
= objc_copyStruct_decl
;
7301 function_decl
= objc_getPropertyStruct_decl
;
7303 function_call
= build_function_call
7305 /* Function prototype. */
7308 tree_cons
/* &__objc_property_temp_decl */
7309 /* Warning: note that using build_fold_addr_expr_loc()
7310 here causes invalid code to be generated. */
7311 (NULL_TREE
, build_unary_op (location
, ADDR_EXPR
, objc_property_temp_decl
, 0),
7312 tree_cons
/* &(self->PROPERTY_IVAR_NAME); */
7313 (NULL_TREE
, build_fold_addr_expr_loc (location
,
7315 (NULL_TREE
, PROPERTY_IVAR_NAME (property
))),
7316 tree_cons
/* sizeof (PROPERTY_IVAR) */
7317 (NULL_TREE
, size_of
,
7318 tree_cons
/* is_atomic */
7319 (NULL_TREE
, is_atomic
,
7320 /* TODO: This is currently ignored by the GNU
7321 runtime, but what about the next one ? */
7322 tree_cons
/* has_strong */
7323 (NULL_TREE
, boolean_true_node
, NULL_TREE
))))));
7325 add_stmt (function_call
);
7327 ret_val
= objc_property_temp_decl
;
7334 gcc_assert (ret_val
);
7337 finish_return_stmt (ret_val
);
7339 c_finish_return (location
, ret_val
, NULL_TREE
);
7342 add_stmt (c_end_compound_stmt (location
, body
, true));
7343 fn
= current_function_decl
;
7347 objc_finish_method_definition (fn
);
7350 /* This routine synthesizes a 'setter' method. */
7353 objc_synthesize_setter (tree klass
, tree class_methods ATTRIBUTE_UNUSED
, tree property
)
7355 location_t location
= DECL_SOURCE_LOCATION (property
);
7358 tree new_value
, statement
;
7360 /* If user has implemented a setter with same name then do nothing. */
7361 if (lookup_method (CLASS_NST_METHODS (objc_implementation_context
),
7362 PROPERTY_SETTER_NAME (property
)))
7365 /* Find declaration of the property setter in the interface (or
7366 superclass, or protocol). There must be one. */
7367 decl
= lookup_method_static (klass
, PROPERTY_SETTER_NAME (property
), 0);
7369 /* If one not declared in the interface, this condition has already
7370 been reported as user error (because property was not declared in
7375 /* Adapt the 'decl'. Use the source location of the @synthesize
7376 statement for error messages. */
7377 decl
= copy_node (decl
);
7378 DECL_SOURCE_LOCATION (decl
) = DECL_SOURCE_LOCATION (property
);
7380 objc_start_method_definition (false /* is_class_method */, decl
, NULL_TREE
,
7383 body
= c_begin_compound_stmt (true);
7385 /* The 'new_value' is the only argument to the method, which is the
7386 3rd argument of the function, after self and _cmd. We use twice
7387 TREE_CHAIN to move forward two arguments. */
7388 new_value
= TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
)));
7390 /* This would presumably happen if the user has specified a
7391 prototype for the setter that does not have an argument! */
7392 if (new_value
== NULL_TREE
)
7394 /* TODO: This should be caught much earlier than this. */
7395 error_at (DECL_SOURCE_LOCATION (decl
), "invalid setter, it must have one argument");
7396 /* Try to recover somehow. */
7397 new_value
= error_mark_node
;
7400 /* Now we need to decide how we build the setter. There are three
7403 for 'copy' or 'retain' properties we need to use the
7404 objc_setProperty() accessor helper which knows about retain and
7405 copy. It supports both 'nonatomic' and 'atomic' access.
7407 for 'nonatomic, assign' properties we can access the instance
7408 variable directly. 'nonatomic' means we don't have to use locks,
7409 and 'assign' means we don't have to worry about retain or copy.
7410 If you combine the two, it means we can just access the instance
7413 for 'atomic, assign' properties we use objc_copyStruct() (for the
7414 next runtime) or objc_setPropertyStruct() (for the GNU runtime). */
7415 switch (PROPERTY_ASSIGN_SEMANTICS (property
))
7417 case OBJC_PROPERTY_RETAIN
:
7418 case OBJC_PROPERTY_COPY
:
7420 /* We build "objc_setProperty (self, _cmd, new_value, offset, is_atomic, should_copy);" */
7421 tree cmd
, ivar
, offset
, is_atomic
, should_copy
;
7422 cmd
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
7424 /* Find the ivar to compute the offset. */
7425 ivar
= lookup_ivar (klass
, PROPERTY_IVAR_NAME (property
));
7426 if (!ivar
|| is_private (ivar
))
7429 "can not find instance variable associated with property");
7430 statement
= error_mark_node
;
7433 offset
= byte_position (ivar
);
7435 if (PROPERTY_NONATOMIC (property
))
7436 is_atomic
= boolean_false_node
;
7438 is_atomic
= boolean_true_node
;
7440 if (PROPERTY_ASSIGN_SEMANTICS (property
) == OBJC_PROPERTY_COPY
)
7441 should_copy
= boolean_true_node
;
7443 should_copy
= boolean_false_node
;
7445 statement
= build_function_call
7447 /* Function prototype. */
7448 objc_setProperty_decl
,
7450 tree_cons
/* self */
7451 (NULL_TREE
, self_decl
,
7452 tree_cons
/* _cmd */
7454 tree_cons
/* offset */
7456 tree_cons
/* new_value */
7457 (NULL_TREE
, new_value
,
7458 tree_cons
/* is_atomic */
7459 (NULL_TREE
, is_atomic
,
7460 tree_cons
/* should_copy */
7461 (NULL_TREE
, should_copy
, NULL_TREE
)))))));
7464 case OBJC_PROPERTY_ASSIGN
:
7465 if (PROPERTY_NONATOMIC (property
))
7467 /* We build "self->PROPERTY_IVAR_NAME = new_value;" */
7468 statement
= build_modify_expr
7470 objc_lookup_ivar (NULL_TREE
, PROPERTY_IVAR_NAME (property
)),
7471 NULL_TREE
, NOP_EXPR
,
7472 location
, new_value
, NULL_TREE
);
7478 objc_setPropertyStruct (&(self->PROPERTY_IVAR_NAME),
7480 sizeof (type of self->PROPERTY_IVAR_NAME),
7484 For the NeXT runtime, we need to use objc_copyStruct
7485 instead of objc_getPropertyStruct. */
7486 tree function_decl
, size_of
, is_atomic
;
7488 /* sizeof (ivar type). Since the ivar and the property have
7489 the same type, there is no need to lookup the ivar. */
7490 size_of
= c_sizeof_or_alignof_type (location
, TREE_TYPE (property
),
7491 true /* is_sizeof */,
7492 false /* min_alignof */,
7493 false /* complain */);
7495 if (PROPERTY_NONATOMIC (property
))
7496 is_atomic
= boolean_false_node
;
7498 is_atomic
= boolean_true_node
;
7500 if (objc_copyStruct_decl
)
7501 function_decl
= objc_copyStruct_decl
;
7503 function_decl
= objc_setPropertyStruct_decl
;
7505 statement
= build_function_call
7507 /* Function prototype. */
7510 tree_cons
/* &(self->PROPERTY_IVAR_NAME); */
7511 (NULL_TREE
, build_fold_addr_expr_loc (location
,
7513 (NULL_TREE
, PROPERTY_IVAR_NAME (property
))),
7514 tree_cons
/* &new_value */
7515 (NULL_TREE
, build_fold_addr_expr_loc (location
, new_value
),
7516 tree_cons
/* sizeof (PROPERTY_IVAR) */
7517 (NULL_TREE
, size_of
,
7518 tree_cons
/* is_atomic */
7519 (NULL_TREE
, is_atomic
,
7520 /* TODO: This is currently ignored by the GNU
7521 runtime, but what about the next one ? */
7522 tree_cons
/* has_strong */
7523 (NULL_TREE
, boolean_true_node
, NULL_TREE
))))));
7529 gcc_assert (statement
);
7531 add_stmt (statement
);
7532 add_stmt (c_end_compound_stmt (location
, body
, true));
7533 fn
= current_function_decl
;
7537 objc_finish_method_definition (fn
);
7540 /* This function is a sub-routine of objc_add_synthesize_declaration.
7541 It is called for each property to synthesize once we have
7542 determined that the context is Ok. */
7544 objc_add_synthesize_declaration_for_property (location_t location
, tree interface
,
7545 tree property_name
, tree ivar_name
)
7547 /* Find the @property declaration. */
7551 /* Check that synthesize or dynamic has not already been used for
7552 the same property. */
7553 for (property
= IMPL_PROPERTY_DECL (objc_implementation_context
); property
; property
= TREE_CHAIN (property
))
7554 if (PROPERTY_NAME (property
) == property_name
)
7556 location_t original_location
= DECL_SOURCE_LOCATION (property
);
7558 if (PROPERTY_DYNAMIC (property
))
7559 error_at (location
, "property %qs already specified in %<@dynamic%>",
7560 IDENTIFIER_POINTER (property_name
));
7562 error_at (location
, "property %qs already specified in %<@synthesize%>",
7563 IDENTIFIER_POINTER (property_name
));
7565 if (original_location
!= UNKNOWN_LOCATION
)
7566 inform (original_location
, "originally specified here");
7570 /* Check that the property is declared in the interface. It could
7571 also be declared in a superclass or protocol. */
7572 property
= lookup_property (interface
, property_name
);
7576 error_at (location
, "no declaration of property %qs found in the interface",
7577 IDENTIFIER_POINTER (property_name
));
7582 /* We have to copy the property, because we want to chain it to
7583 the implementation context, and we want to store the source
7584 location of the @synthesize, not of the original
7586 property
= copy_node (property
);
7587 DECL_SOURCE_LOCATION (property
) = location
;
7590 /* Determine PROPERTY_IVAR_NAME. */
7591 if (ivar_name
== NULL_TREE
)
7592 ivar_name
= property_name
;
7594 /* Check that the instance variable exists. You can only use an
7595 instance variable from the same class, not one from the
7596 superclass (this makes sense as it allows us to check that an
7597 instance variable is only used in one synthesized property). */
7599 tree ivar
= is_ivar (CLASS_IVARS (interface
), ivar_name
);
7603 error_at (location
, "ivar %qs used by %<@synthesize%> declaration must be an existing ivar",
7604 IDENTIFIER_POINTER (property_name
));
7608 if (DECL_BIT_FIELD_TYPE (ivar
))
7609 type_of_ivar
= DECL_BIT_FIELD_TYPE (ivar
);
7611 type_of_ivar
= TREE_TYPE (ivar
);
7613 /* If the instance variable has a different C type, we throw an error ... */
7614 if (!comptypes (TREE_TYPE (property
), type_of_ivar
)
7615 /* ... unless the property is readonly, in which case we allow
7616 the instance variable to be more specialized (this means we
7617 can generate the getter all right and it works). */
7618 && (!PROPERTY_READONLY (property
)
7619 || !objc_compare_types (TREE_TYPE (property
),
7620 type_of_ivar
, -5, NULL_TREE
)))
7622 location_t original_location
= DECL_SOURCE_LOCATION (ivar
);
7624 error_at (location
, "property %qs is using instance variable %qs of incompatible type",
7625 IDENTIFIER_POINTER (property_name
),
7626 IDENTIFIER_POINTER (ivar_name
));
7628 if (original_location
!= UNKNOWN_LOCATION
)
7629 inform (original_location
, "originally specified here");
7632 /* If the instance variable is a bitfield, the property must be
7633 'assign', 'nonatomic' because the runtime getter/setter helper
7634 do not work with bitfield instance variables. */
7635 if (DECL_BIT_FIELD_TYPE (ivar
))
7637 /* If there is an error, we return and not generate any
7638 getter/setter because trying to set up the runtime
7639 getter/setter helper calls with bitfields is at high risk
7642 if (PROPERTY_ASSIGN_SEMANTICS (property
) != OBJC_PROPERTY_ASSIGN
)
7644 location_t original_location
= DECL_SOURCE_LOCATION (ivar
);
7646 error_at (location
, "'assign' property %qs is using bit-field instance variable %qs",
7647 IDENTIFIER_POINTER (property_name
),
7648 IDENTIFIER_POINTER (ivar_name
));
7650 if (original_location
!= UNKNOWN_LOCATION
)
7651 inform (original_location
, "originally specified here");
7655 if (!PROPERTY_NONATOMIC (property
))
7657 location_t original_location
= DECL_SOURCE_LOCATION (ivar
);
7659 error_at (location
, "'atomic' property %qs is using bit-field instance variable %qs",
7660 IDENTIFIER_POINTER (property_name
),
7661 IDENTIFIER_POINTER (ivar_name
));
7663 if (original_location
!= UNKNOWN_LOCATION
)
7664 inform (original_location
, "originally specified here");
7670 /* Check that no other property is using the same instance
7672 for (x
= IMPL_PROPERTY_DECL (objc_implementation_context
); x
; x
= TREE_CHAIN (x
))
7673 if (PROPERTY_IVAR_NAME (x
) == ivar_name
)
7675 location_t original_location
= DECL_SOURCE_LOCATION (x
);
7677 error_at (location
, "property %qs is using the same instance variable as property %qs",
7678 IDENTIFIER_POINTER (property_name
),
7679 IDENTIFIER_POINTER (PROPERTY_NAME (x
)));
7681 if (original_location
!= UNKNOWN_LOCATION
)
7682 inform (original_location
, "originally specified here");
7684 /* We keep going on. This won't cause the compiler to fail;
7685 the failure would most likely be at runtime. */
7688 /* Note that a @synthesize (and only a @synthesize) always sets
7689 PROPERTY_IVAR_NAME to a non-NULL_TREE. You can recognize a
7690 @synthesize by that. */
7691 PROPERTY_IVAR_NAME (property
) = ivar_name
;
7693 /* PROPERTY_SETTER_NAME and PROPERTY_GETTER_NAME are copied from the
7694 original declaration; they are always set (with the exception of
7695 PROPERTY_SETTER_NAME not being set if PROPERTY_READONLY == 1). */
7697 /* Add the property to the list of properties for current implementation. */
7698 TREE_CHAIN (property
) = IMPL_PROPERTY_DECL (objc_implementation_context
);
7699 IMPL_PROPERTY_DECL (objc_implementation_context
) = property
;
7701 /* Note how we don't actually synthesize the getter/setter here; it
7702 would be very natural, but we may miss the fact that the user has
7703 implemented his own getter/setter later on in the @implementation
7704 (in which case we shouldn't generate getter/setter). We wait
7705 until we have parsed it all before generating the code. */
7708 /* This function is called by the parser after a @synthesize
7709 expression is parsed. 'location' is the location of the
7710 @synthesize expression, and 'property_and_ivar_list' is a chained
7711 list of the property and ivar names. */
7713 objc_add_synthesize_declaration (location_t location
, tree property_and_ivar_list
)
7715 tree interface
, chain
;
7717 if (flag_objc1_only
)
7718 error_at (input_location
, "%<@synthesize%> is not available in Objective-C 1.0");
7720 if (property_and_ivar_list
== error_mark_node
)
7723 if (!objc_implementation_context
)
7725 /* We can get here only in Objective-C; the Objective-C++ parser
7726 detects the problem while parsing, outputs the error
7727 "misplaced '@synthesize' Objective-C++ construct" and skips
7729 error_at (location
, "%<@synthesize%> not in @implementation context");
7733 if (TREE_CODE (objc_implementation_context
) == CATEGORY_IMPLEMENTATION_TYPE
)
7735 error_at (location
, "%<@synthesize%> can not be used in categories");
7739 interface
= lookup_interface (CLASS_NAME (objc_implementation_context
));
7742 /* I can't see how this could happen, but it is good as a safety check. */
7744 "%<@synthesize%> requires the @interface of the class to be available");
7748 /* Now, iterate over the properties and do each of them. */
7749 for (chain
= property_and_ivar_list
; chain
; chain
= TREE_CHAIN (chain
))
7751 objc_add_synthesize_declaration_for_property (location
, interface
, TREE_VALUE (chain
),
7752 TREE_PURPOSE (chain
));
7756 /* This function is a sub-routine of objc_add_dynamic_declaration. It
7757 is called for each property to mark as dynamic once we have
7758 determined that the context is Ok. */
7760 objc_add_dynamic_declaration_for_property (location_t location
, tree interface
,
7763 /* Find the @property declaration. */
7766 /* Check that synthesize or dynamic has not already been used for
7767 the same property. */
7768 for (property
= IMPL_PROPERTY_DECL (objc_implementation_context
); property
; property
= TREE_CHAIN (property
))
7769 if (PROPERTY_NAME (property
) == property_name
)
7771 location_t original_location
= DECL_SOURCE_LOCATION (property
);
7773 if (PROPERTY_DYNAMIC (property
))
7774 error_at (location
, "property %qs already specified in %<@dynamic%>",
7775 IDENTIFIER_POINTER (property_name
));
7777 error_at (location
, "property %qs already specified in %<@synthesize%>",
7778 IDENTIFIER_POINTER (property_name
));
7780 if (original_location
!= UNKNOWN_LOCATION
)
7781 inform (original_location
, "originally specified here");
7785 /* Check that the property is declared in the interface. It could
7786 also be declared in a superclass or protocol. */
7787 property
= lookup_property (interface
, property_name
);
7791 error_at (location
, "no declaration of property %qs found in the interface",
7792 IDENTIFIER_POINTER (property_name
));
7797 /* We have to copy the property, because we want to chain it to
7798 the implementation context, and we want to store the source
7799 location of the @synthesize, not of the original
7801 property
= copy_node (property
);
7802 DECL_SOURCE_LOCATION (property
) = location
;
7805 /* Note that a @dynamic (and only a @dynamic) always sets
7806 PROPERTY_DYNAMIC to 1. You can recognize a @dynamic by that.
7807 (actually, as explained above, PROPERTY_DECL generated by
7808 @property and associated with a @dynamic property are also marked
7809 as PROPERTY_DYNAMIC). */
7810 PROPERTY_DYNAMIC (property
) = 1;
7812 /* Add the property to the list of properties for current implementation. */
7813 TREE_CHAIN (property
) = IMPL_PROPERTY_DECL (objc_implementation_context
);
7814 IMPL_PROPERTY_DECL (objc_implementation_context
) = property
;
7817 /* This function is called by the parser after a @dynamic expression
7818 is parsed. 'location' is the location of the @dynamic expression,
7819 and 'property_list' is a chained list of all the property
7822 objc_add_dynamic_declaration (location_t location
, tree property_list
)
7824 tree interface
, chain
;
7826 if (flag_objc1_only
)
7827 error_at (input_location
, "%<@dynamic%> is not available in Objective-C 1.0");
7829 if (property_list
== error_mark_node
)
7832 if (!objc_implementation_context
)
7834 /* We can get here only in Objective-C; the Objective-C++ parser
7835 detects the problem while parsing, outputs the error
7836 "misplaced '@dynamic' Objective-C++ construct" and skips the
7838 error_at (location
, "%<@dynamic%> not in @implementation context");
7842 /* @dynamic is allowed in categories. */
7843 switch (TREE_CODE (objc_implementation_context
))
7845 case CLASS_IMPLEMENTATION_TYPE
:
7846 interface
= lookup_interface (CLASS_NAME (objc_implementation_context
));
7848 case CATEGORY_IMPLEMENTATION_TYPE
:
7849 interface
= lookup_category (implementation_template
,
7850 CLASS_SUPER_NAME (objc_implementation_context
));
7858 /* I can't see how this could happen, but it is good as a safety check. */
7860 "%<@dynamic%> requires the @interface of the class to be available");
7864 /* Now, iterate over the properties and do each of them. */
7865 for (chain
= property_list
; chain
; chain
= TREE_CHAIN (chain
))
7867 objc_add_dynamic_declaration_for_property (location
, interface
, TREE_VALUE (chain
));
7871 /* Main routine to generate code/data for all the property information for
7872 current implementation (class or category). CLASS is the interface where
7873 ivars are declared. CLASS_METHODS is where methods are found which
7874 could be a class or a category depending on whether we are implementing
7875 property of a class or a category. */
7878 objc_gen_property_data (tree klass
, tree class_methods
)
7882 for (x
= IMPL_PROPERTY_DECL (objc_implementation_context
); x
; x
= TREE_CHAIN (x
))
7884 /* @dynamic property - nothing to check or synthesize. */
7885 if (PROPERTY_DYNAMIC (x
))
7888 /* @synthesize property - need to synthesize the accessors. */
7889 if (PROPERTY_IVAR_NAME (x
))
7891 objc_synthesize_getter (klass
, class_methods
, x
);
7893 if (PROPERTY_READONLY (x
) == 0)
7894 objc_synthesize_setter (klass
, class_methods
, x
);
7903 /* This is called once we see the "@end" in an interface/implementation. */
7906 finish_class (tree klass
)
7908 switch (TREE_CODE (klass
))
7910 case CLASS_IMPLEMENTATION_TYPE
:
7912 /* All metadata generation is done in runtime.generate_metadata(). */
7914 /* Generate what needed for property; setters, getters, etc. */
7915 objc_gen_property_data (implementation_template
, implementation_template
);
7917 if (implementation_template
!= objc_implementation_context
)
7919 /* Ensure that all method listed in the interface contain bodies. */
7920 check_methods (CLASS_CLS_METHODS (implementation_template
),
7921 objc_implementation_context
, '+');
7922 check_methods (CLASS_NST_METHODS (implementation_template
),
7923 objc_implementation_context
, '-');
7925 if (CLASS_PROTOCOL_LIST (implementation_template
))
7926 check_protocols (CLASS_PROTOCOL_LIST (implementation_template
),
7928 CLASS_NAME (objc_implementation_context
));
7932 case CATEGORY_IMPLEMENTATION_TYPE
:
7934 tree category
= lookup_category (implementation_template
, CLASS_SUPER_NAME (klass
));
7938 /* Generate what needed for property; setters, getters, etc. */
7939 objc_gen_property_data (implementation_template
, category
);
7941 /* Ensure all method listed in the interface contain bodies. */
7942 check_methods (CLASS_CLS_METHODS (category
),
7943 objc_implementation_context
, '+');
7944 check_methods (CLASS_NST_METHODS (category
),
7945 objc_implementation_context
, '-');
7947 if (CLASS_PROTOCOL_LIST (category
))
7948 check_protocols (CLASS_PROTOCOL_LIST (category
),
7950 CLASS_SUPER_NAME (objc_implementation_context
));
7954 case CLASS_INTERFACE_TYPE
:
7955 case CATEGORY_INTERFACE_TYPE
:
7956 case PROTOCOL_INTERFACE_TYPE
:
7958 /* Process properties of the class. */
7960 for (x
= CLASS_PROPERTY_DECL (objc_interface_context
); x
; x
= TREE_CHAIN (x
))
7962 /* Now we check that the appropriate getter is declared,
7963 and if not, we declare one ourselves. */
7964 tree getter_decl
= lookup_method (CLASS_NST_METHODS (klass
),
7965 PROPERTY_GETTER_NAME (x
));
7969 /* TODO: Check that the declaration is consistent with the property. */
7974 /* Generate an instance method declaration for the
7975 getter; for example "- (id) name;". In general it
7977 -(type)property_getter_name; */
7978 tree rettype
= build_tree_list (NULL_TREE
, TREE_TYPE (x
));
7979 getter_decl
= build_method_decl (INSTANCE_METHOD_DECL
,
7980 rettype
, PROPERTY_GETTER_NAME (x
),
7982 if (PROPERTY_OPTIONAL (x
))
7983 objc_add_method (objc_interface_context
, getter_decl
, false, true);
7985 objc_add_method (objc_interface_context
, getter_decl
, false, false);
7986 TREE_DEPRECATED (getter_decl
) = TREE_DEPRECATED (x
);
7987 METHOD_PROPERTY_CONTEXT (getter_decl
) = x
;
7990 if (PROPERTY_READONLY (x
) == 0)
7992 /* Now we check that the appropriate setter is declared,
7993 and if not, we declare on ourselves. */
7994 tree setter_decl
= lookup_method (CLASS_NST_METHODS (klass
),
7995 PROPERTY_SETTER_NAME (x
));
7999 /* TODO: Check that the declaration is consistent with the property. */
8004 /* The setter name is something like 'setName:'.
8005 We need the substring 'setName' to build the
8006 method declaration due to how the declaration
8007 works. TODO: build_method_decl() will then
8008 generate back 'setName:' from 'setName'; it
8009 would be more efficient to hook into there. */
8010 const char *full_setter_name
= IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x
));
8011 size_t length
= strlen (full_setter_name
);
8012 char *setter_name
= (char *) alloca (length
);
8013 tree ret_type
, selector
, arg_type
, arg_name
;
8015 strcpy (setter_name
, full_setter_name
);
8016 setter_name
[length
- 1] = '\0';
8017 ret_type
= build_tree_list (NULL_TREE
, void_type_node
);
8018 arg_type
= build_tree_list (NULL_TREE
, TREE_TYPE (x
));
8019 arg_name
= get_identifier ("_value");
8020 selector
= objc_build_keyword_decl (get_identifier (setter_name
),
8021 arg_type
, arg_name
, NULL
);
8022 setter_decl
= build_method_decl (INSTANCE_METHOD_DECL
,
8024 build_tree_list (NULL_TREE
, NULL_TREE
),
8026 if (PROPERTY_OPTIONAL (x
))
8027 objc_add_method (objc_interface_context
, setter_decl
, false, true);
8029 objc_add_method (objc_interface_context
, setter_decl
, false, false);
8030 TREE_DEPRECATED (setter_decl
) = TREE_DEPRECATED (x
);
8031 METHOD_PROPERTY_CONTEXT (setter_decl
) = x
;
8044 add_protocol (tree protocol
)
8046 /* Put protocol on list in reverse order. */
8047 TREE_CHAIN (protocol
) = protocol_chain
;
8048 protocol_chain
= protocol
;
8049 return protocol_chain
;
8052 /* Check that a protocol is defined, and, recursively, that all
8053 protocols that this protocol conforms to are defined too. */
8055 check_that_protocol_is_defined (tree protocol
)
8057 if (!PROTOCOL_DEFINED (protocol
))
8058 warning (0, "definition of protocol %qE not found",
8059 PROTOCOL_NAME (protocol
));
8061 /* If the protocol itself conforms to other protocols, check them
8062 too, recursively. */
8063 if (PROTOCOL_LIST (protocol
))
8067 for (p
= PROTOCOL_LIST (protocol
); p
; p
= TREE_CHAIN (p
))
8068 check_that_protocol_is_defined (TREE_VALUE (p
));
8072 /* Looks up a protocol. If 'warn_if_deprecated' is true, a warning is
8073 emitted if the protocol is deprecated. If 'definition_required' is
8074 true, a warning is emitted if a full @protocol definition has not
8077 lookup_protocol (tree ident
, bool warn_if_deprecated
, bool definition_required
)
8081 for (chain
= protocol_chain
; chain
; chain
= TREE_CHAIN (chain
))
8082 if (ident
== PROTOCOL_NAME (chain
))
8084 if (warn_if_deprecated
&& TREE_DEPRECATED (chain
))
8086 /* It would be nice to use warn_deprecated_use() here, but
8087 we are using TREE_CHAIN (which is supposed to be the
8088 TYPE_STUB_DECL for a TYPE) for something different. */
8089 warning (OPT_Wdeprecated_declarations
, "protocol %qE is deprecated",
8090 PROTOCOL_NAME (chain
));
8093 if (definition_required
)
8094 check_that_protocol_is_defined (chain
);
8102 /* This function forward declares the protocols named by NAMES. If
8103 they are already declared or defined, the function has no effect. */
8106 objc_declare_protocol (tree name
, tree attributes
)
8108 bool deprecated
= false;
8111 if (current_namespace
!= global_namespace
) {
8112 error ("Objective-C declarations may only appear in global scope");
8114 #endif /* OBJCPLUS */
8116 /* Determine if 'deprecated', the only attribute we recognize for
8117 protocols, was used. Ignore all other attributes. */
8121 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
8123 tree name
= TREE_PURPOSE (attribute
);
8125 if (is_attribute_p ("deprecated", name
))
8128 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
8132 if (lookup_protocol (name
, /* warn if deprecated */ false,
8133 /* definition_required */ false) == NULL_TREE
)
8135 tree protocol
= make_node (PROTOCOL_INTERFACE_TYPE
);
8137 TYPE_LANG_SLOT_1 (protocol
)
8138 = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS
);
8139 PROTOCOL_NAME (protocol
) = name
;
8140 PROTOCOL_LIST (protocol
) = NULL_TREE
;
8141 add_protocol (protocol
);
8142 PROTOCOL_DEFINED (protocol
) = 0;
8143 PROTOCOL_FORWARD_DECL (protocol
) = NULL_TREE
;
8147 /* TODO: Do we need to store the attributes here ? */
8148 TYPE_ATTRIBUTES (protocol
) = attributes
;
8150 TREE_DEPRECATED (protocol
) = 1;
8156 start_protocol (enum tree_code code
, tree name
, tree list
, tree attributes
)
8159 bool deprecated
= false;
8162 if (current_namespace
!= global_namespace
) {
8163 error ("Objective-C declarations may only appear in global scope");
8165 #endif /* OBJCPLUS */
8167 /* Determine if 'deprecated', the only attribute we recognize for
8168 protocols, was used. Ignore all other attributes. */
8172 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
8174 tree name
= TREE_PURPOSE (attribute
);
8176 if (is_attribute_p ("deprecated", name
))
8179 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
8183 protocol
= lookup_protocol (name
, /* warn_if_deprecated */ false,
8184 /* definition_required */ false);
8188 protocol
= make_node (code
);
8189 TYPE_LANG_SLOT_1 (protocol
) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS
);
8191 PROTOCOL_NAME (protocol
) = name
;
8192 PROTOCOL_LIST (protocol
) = lookup_and_install_protocols (list
, /* definition_required */ false);
8193 add_protocol (protocol
);
8194 PROTOCOL_DEFINED (protocol
) = 1;
8195 PROTOCOL_FORWARD_DECL (protocol
) = NULL_TREE
;
8197 check_protocol_recursively (protocol
, list
);
8199 else if (! PROTOCOL_DEFINED (protocol
))
8201 PROTOCOL_DEFINED (protocol
) = 1;
8202 PROTOCOL_LIST (protocol
) = lookup_and_install_protocols (list
, /* definition_required */ false);
8204 check_protocol_recursively (protocol
, list
);
8208 warning (0, "duplicate declaration for protocol %qE",
8214 TYPE_ATTRIBUTES (protocol
) = attributes
;
8216 TREE_DEPRECATED (protocol
) = 1;
8222 /* Decay array and function parameters into pointers. */
8225 objc_decay_parm_type (tree type
)
8227 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == FUNCTION_TYPE
)
8228 type
= build_pointer_type (TREE_CODE (type
) == ARRAY_TYPE
8235 static GTY(()) tree objc_parmlist
= NULL_TREE
;
8237 /* Append PARM to a list of formal parameters of a method, making a necessary
8238 array-to-pointer adjustment along the way. */
8241 objc_push_parm (tree parm
)
8245 if (TREE_TYPE (parm
) == error_mark_node
)
8247 objc_parmlist
= chainon (objc_parmlist
, parm
);
8251 /* Decay arrays and functions into pointers. */
8252 type
= objc_decay_parm_type (TREE_TYPE (parm
));
8254 /* If the parameter type has been decayed, a new PARM_DECL needs to be
8256 if (type
!= TREE_TYPE (parm
))
8257 parm
= build_decl (input_location
, PARM_DECL
, DECL_NAME (parm
), type
);
8259 DECL_ARG_TYPE (parm
)
8260 = lang_hooks
.types
.type_promotes_to (TREE_TYPE (parm
));
8262 /* Record constancy and volatility. */
8263 c_apply_type_quals_to_decl
8264 ((TYPE_READONLY (TREE_TYPE (parm
)) ? TYPE_QUAL_CONST
: 0)
8265 | (TYPE_RESTRICT (TREE_TYPE (parm
)) ? TYPE_QUAL_RESTRICT
: 0)
8266 | (TYPE_ATOMIC (TREE_TYPE (parm
)) ? TYPE_QUAL_ATOMIC
: 0)
8267 | (TYPE_VOLATILE (TREE_TYPE (parm
)) ? TYPE_QUAL_VOLATILE
: 0), parm
);
8269 objc_parmlist
= chainon (objc_parmlist
, parm
);
8272 /* Retrieve the formal parameter list constructed via preceding calls to
8273 objc_push_parm(). */
8277 objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED
,
8278 tree expr ATTRIBUTE_UNUSED
)
8280 tree parm_info
= objc_parmlist
;
8281 objc_parmlist
= NULL_TREE
;
8287 objc_get_parm_info (int have_ellipsis
, tree expr
)
8289 tree parm_info
= objc_parmlist
;
8290 struct c_arg_info
*arg_info
;
8291 /* The C front-end requires an elaborate song and dance at
8294 declare_parm_level ();
8297 tree next
= DECL_CHAIN (parm_info
);
8299 DECL_CHAIN (parm_info
) = NULL_TREE
;
8300 parm_info
= pushdecl (parm_info
);
8301 finish_decl (parm_info
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
8304 arg_info
= get_parm_info (have_ellipsis
, expr
);
8306 objc_parmlist
= NULL_TREE
;
8311 /* Synthesize the formal parameters 'id self' and 'SEL _cmd' needed for ObjC
8312 method definitions. In the case of instance methods, we can be more
8313 specific as to the type of 'self'. */
8316 synth_self_and_ucmd_args (void)
8320 if (objc_method_context
8321 && TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
)
8322 self_type
= objc_instance_type
;
8324 /* Really a `struct objc_class *'. However, we allow people to
8325 assign to self, which changes its type midstream. */
8326 self_type
= objc_object_type
;
8329 objc_push_parm (build_decl (input_location
,
8330 PARM_DECL
, self_id
, self_type
));
8333 objc_push_parm (build_decl (input_location
,
8334 PARM_DECL
, ucmd_id
, objc_selector_type
));
8337 /* Transform an Objective-C method definition into a static C function
8338 definition, synthesizing the first two arguments, "self" and "_cmd",
8339 in the process. EXPR is NULL or an expression that needs to be
8340 evaluated for the side effects of array size expressions in the
8344 start_method_def (tree method
, tree expr
)
8350 struct c_arg_info
*parm_info
;
8352 int have_ellipsis
= 0;
8354 /* If we are defining a "dealloc" method in a non-root class, we
8355 will need to check if a [super dealloc] is missing, and warn if
8357 if(CLASS_SUPER_NAME (objc_implementation_context
)
8358 && !strcmp ("dealloc", IDENTIFIER_POINTER (METHOD_SEL_NAME (method
))))
8359 should_call_super_dealloc
= 1;
8361 should_call_super_dealloc
= 0;
8363 /* Required to implement _msgSuper. */
8364 objc_method_context
= method
;
8365 UOBJC_SUPER_decl
= NULL_TREE
;
8367 /* Generate prototype declarations for arguments..."new-style". */
8368 synth_self_and_ucmd_args ();
8370 /* Generate argument declarations if a keyword_decl. */
8371 parmlist
= METHOD_SEL_ARGS (method
);
8374 /* parmlist is a KEYWORD_DECL. */
8375 tree type
= TREE_VALUE (TREE_TYPE (parmlist
));
8378 parm
= build_decl (input_location
,
8379 PARM_DECL
, KEYWORD_ARG_NAME (parmlist
), type
);
8380 decl_attributes (&parm
, DECL_ATTRIBUTES (parmlist
), 0);
8381 objc_push_parm (parm
);
8382 parmlist
= DECL_CHAIN (parmlist
);
8385 if (METHOD_ADD_ARGS (method
))
8389 for (akey
= TREE_CHAIN (METHOD_ADD_ARGS (method
));
8390 akey
; akey
= TREE_CHAIN (akey
))
8392 objc_push_parm (TREE_VALUE (akey
));
8395 if (METHOD_ADD_ARGS_ELLIPSIS_P (method
))
8399 parm_info
= objc_get_parm_info (have_ellipsis
, expr
);
8401 really_start_method (objc_method_context
, parm_info
);
8404 /* Return 1 if TYPE1 is equivalent to TYPE2 for purposes of method
8407 objc_types_are_equivalent (tree type1
, tree type2
)
8412 /* Strip away indirections. */
8413 while ((TREE_CODE (type1
) == ARRAY_TYPE
|| TREE_CODE (type1
) == POINTER_TYPE
)
8414 && (TREE_CODE (type1
) == TREE_CODE (type2
)))
8415 type1
= TREE_TYPE (type1
), type2
= TREE_TYPE (type2
);
8416 if (TYPE_MAIN_VARIANT (type1
) != TYPE_MAIN_VARIANT (type2
))
8419 /* Compare the protocol lists. */
8420 type1
= (TYPE_HAS_OBJC_INFO (type1
)
8421 ? TYPE_OBJC_PROTOCOL_LIST (type1
)
8423 type2
= (TYPE_HAS_OBJC_INFO (type2
)
8424 ? TYPE_OBJC_PROTOCOL_LIST (type2
)
8427 /* If there are no protocols (most common case), the types are
8429 if (type1
== NULL_TREE
&& type2
== NULL_TREE
)
8432 /* If one has protocols, and the other one hasn't, they are not
8434 if ((type1
== NULL_TREE
&& type2
!= NULL_TREE
)
8435 || (type1
!= NULL_TREE
&& type2
== NULL_TREE
))
8439 /* Else, both have protocols, and we need to do the full
8440 comparison. It is possible that either type1 or type2
8441 contain some duplicate protocols in the list, so we can't
8442 even just compare list_length as a first check. */
8445 for (t
= type2
; t
; t
= TREE_CHAIN (t
))
8446 if (!lookup_protocol_in_reflist (type1
, TREE_VALUE (t
)))
8449 for (t
= type1
; t
; t
= TREE_CHAIN (t
))
8450 if (!lookup_protocol_in_reflist (type2
, TREE_VALUE (t
)))
8457 /* Return 1 if TYPE1 has the same size and alignment as TYPE2. */
8460 objc_types_share_size_and_alignment (tree type1
, tree type2
)
8462 return (simple_cst_equal (TYPE_SIZE (type1
), TYPE_SIZE (type2
))
8463 && TYPE_ALIGN (type1
) == TYPE_ALIGN (type2
));
8466 /* Return 1 if PROTO1 is equivalent to PROTO2
8467 for purposes of method overloading. Ordinarily, the type signatures
8468 should match up exactly, unless STRICT is zero, in which case we
8469 shall allow differences in which the size and alignment of a type
8473 comp_proto_with_proto (tree proto1
, tree proto2
, int strict
)
8477 /* The following test is needed in case there are hashing
8479 if (METHOD_SEL_NAME (proto1
) != METHOD_SEL_NAME (proto2
))
8482 /* Compare return types. */
8483 type1
= TREE_VALUE (TREE_TYPE (proto1
));
8484 type2
= TREE_VALUE (TREE_TYPE (proto2
));
8486 if (!objc_types_are_equivalent (type1
, type2
)
8487 && (strict
|| !objc_types_share_size_and_alignment (type1
, type2
)))
8490 /* Compare argument types. */
8492 /* The first argument (objc_object_type) is always the same, no need
8495 /* The second argument (objc_selector_type) is always the same, no
8498 /* Compare the other arguments. */
8502 /* Compare METHOD_SEL_ARGS. */
8503 for (arg1
= METHOD_SEL_ARGS (proto1
), arg2
= METHOD_SEL_ARGS (proto2
);
8505 arg1
= DECL_CHAIN (arg1
), arg2
= DECL_CHAIN (arg2
))
8507 type1
= TREE_VALUE (TREE_TYPE (arg1
));
8508 type2
= TREE_VALUE (TREE_TYPE (arg2
));
8510 /* FIXME: Do we need to decay argument types to compare them ? */
8511 type1
= objc_decay_parm_type (type1
);
8512 type2
= objc_decay_parm_type (type2
);
8514 if (!objc_types_are_equivalent (type1
, type2
)
8515 && (strict
|| !objc_types_share_size_and_alignment (type1
, type2
)))
8519 /* The loop ends when arg1 or arg2 are NULL. Make sure they are
8524 /* Compare METHOD_ADD_ARGS. */
8525 if ((METHOD_ADD_ARGS (proto1
) && !METHOD_ADD_ARGS (proto2
))
8526 || (METHOD_ADD_ARGS (proto2
) && !METHOD_ADD_ARGS (proto1
)))
8529 if (METHOD_ADD_ARGS (proto1
))
8531 for (arg1
= TREE_CHAIN (METHOD_ADD_ARGS (proto1
)), arg2
= TREE_CHAIN (METHOD_ADD_ARGS (proto2
));
8533 arg1
= TREE_CHAIN (arg1
), arg2
= TREE_CHAIN (arg2
))
8535 type1
= TREE_TYPE (TREE_VALUE (arg1
));
8536 type2
= TREE_TYPE (TREE_VALUE (arg2
));
8538 /* FIXME: Do we need to decay argument types to compare them ? */
8539 type1
= objc_decay_parm_type (type1
);
8540 type2
= objc_decay_parm_type (type2
);
8542 if (!objc_types_are_equivalent (type1
, type2
)
8543 && (strict
|| !objc_types_share_size_and_alignment (type1
, type2
)))
8548 /* The loop ends when arg1 or arg2 are NULL. Make sure they are
8553 /* Compare METHOD_ADD_ARGS_ELLIPSIS_P. */
8554 if (METHOD_ADD_ARGS_ELLIPSIS_P (proto1
) != METHOD_ADD_ARGS_ELLIPSIS_P (proto2
))
8562 /* This routine returns true if TYPE is a valid objc object type,
8563 suitable for messaging; false otherwise. If 'accept_class' is
8564 'true', then a Class object is considered valid for messaging and
8565 'true' is returned if 'type' refers to a Class. If 'accept_class'
8566 is 'false', then a Class object is not considered valid for
8567 messaging and 'false' is returned in that case. */
8570 objc_type_valid_for_messaging (tree type
, bool accept_classes
)
8572 if (!POINTER_TYPE_P (type
))
8575 /* Remove the pointer indirection; don't remove more than one
8576 otherwise we'd consider "NSObject **" a valid type for messaging,
8578 type
= TREE_TYPE (type
);
8580 if (TREE_CODE (type
) != RECORD_TYPE
)
8583 if (objc_is_object_id (type
))
8586 if (objc_is_class_id (type
))
8587 return accept_classes
;
8589 if (TYPE_HAS_OBJC_INFO (type
))
8596 objc_start_function (tree name
, tree type
, tree attrs
,
8600 struct c_arg_info
*params
8604 tree fndecl
= build_decl (input_location
,
8605 FUNCTION_DECL
, name
, type
);
8608 DECL_ARGUMENTS (fndecl
) = params
;
8609 DECL_INITIAL (fndecl
) = error_mark_node
;
8610 DECL_EXTERNAL (fndecl
) = 0;
8611 TREE_STATIC (fndecl
) = 1;
8612 retrofit_lang_decl (fndecl
);
8613 cplus_decl_attributes (&fndecl
, attrs
, 0);
8614 start_preparsed_function (fndecl
, attrs
, /*flags=*/SF_DEFAULT
);
8616 current_function_returns_value
= 0; /* Assume, until we see it does. */
8617 current_function_returns_null
= 0;
8618 decl_attributes (&fndecl
, attrs
, 0);
8619 announce_function (fndecl
);
8620 DECL_INITIAL (fndecl
) = error_mark_node
;
8621 DECL_EXTERNAL (fndecl
) = 0;
8622 TREE_STATIC (fndecl
) = 1;
8623 current_function_decl
= pushdecl (fndecl
);
8625 declare_parm_level ();
8626 DECL_RESULT (current_function_decl
)
8627 = build_decl (input_location
,
8628 RESULT_DECL
, NULL_TREE
,
8629 TREE_TYPE (TREE_TYPE (current_function_decl
)));
8630 DECL_ARTIFICIAL (DECL_RESULT (current_function_decl
)) = 1;
8631 DECL_IGNORED_P (DECL_RESULT (current_function_decl
)) = 1;
8632 start_fname_decls ();
8633 store_parm_decls_from (params
);
8636 TREE_USED (current_function_decl
) = 1;
8639 /* - Generate an identifier for the function. the format is "_n_cls",
8640 where 1 <= n <= nMethods, and cls is the name the implementation we
8642 - Install the return type from the method declaration.
8643 - If we have a prototype, check for type consistency. */
8646 really_start_method (tree method
,
8650 struct c_arg_info
*parmlist
8654 tree ret_type
, meth_type
;
8656 const char *sel_name
, *class_name
, *cat_name
;
8659 /* Synth the storage class & assemble the return type. */
8660 ret_type
= TREE_VALUE (TREE_TYPE (method
));
8662 sel_name
= IDENTIFIER_POINTER (METHOD_SEL_NAME (method
));
8663 class_name
= IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context
));
8664 cat_name
= ((TREE_CODE (objc_implementation_context
)
8665 == CLASS_IMPLEMENTATION_TYPE
)
8667 : IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context
)));
8670 /* Make sure this is big enough for any plausible method label. */
8671 buf
= (char *) alloca (50 + strlen (sel_name
) + strlen (class_name
)
8672 + (cat_name
? strlen (cat_name
) : 0));
8674 OBJC_GEN_METHOD_LABEL (buf
, TREE_CODE (method
) == INSTANCE_METHOD_DECL
,
8675 class_name
, cat_name
, sel_name
, method_slot
);
8677 method_id
= get_identifier (buf
);
8680 /* Objective-C methods cannot be overloaded, so we don't need
8681 the type encoding appended. It looks bad anyway... */
8682 push_lang_context (lang_name_c
);
8685 meth_type
= build_function_type_for_method (ret_type
, method
, METHOD_DEF
, 0);
8686 objc_start_function (method_id
, meth_type
, NULL_TREE
, parmlist
);
8688 /* Set self_decl from the first argument. */
8689 self_decl
= DECL_ARGUMENTS (current_function_decl
);
8691 /* Suppress unused warnings. */
8692 TREE_USED (self_decl
) = 1;
8693 DECL_READ_P (self_decl
) = 1;
8694 TREE_USED (DECL_CHAIN (self_decl
)) = 1;
8695 DECL_READ_P (DECL_CHAIN (self_decl
)) = 1;
8697 pop_lang_context ();
8700 METHOD_DEFINITION (method
) = current_function_decl
;
8702 /* Check consistency...start_function, pushdecl, duplicate_decls. */
8704 if (implementation_template
!= objc_implementation_context
)
8707 = lookup_method_static (implementation_template
,
8708 METHOD_SEL_NAME (method
),
8709 ((TREE_CODE (method
) == CLASS_METHOD_DECL
)
8710 | OBJC_LOOKUP_NO_SUPER
));
8714 if (!comp_proto_with_proto (method
, proto
, 1))
8716 bool type
= TREE_CODE (method
) == INSTANCE_METHOD_DECL
;
8718 warning_at (DECL_SOURCE_LOCATION (method
), 0,
8719 "conflicting types for %<%c%s%>",
8721 identifier_to_locale (gen_method_decl (method
)));
8722 inform (DECL_SOURCE_LOCATION (proto
),
8723 "previous declaration of %<%c%s%>",
8725 identifier_to_locale (gen_method_decl (proto
)));
8729 /* If the method in the @interface was deprecated, mark
8730 the implemented method as deprecated too. It should
8731 never be used for messaging (when the deprecation
8732 warnings are produced), but just in case. */
8733 if (TREE_DEPRECATED (proto
))
8734 TREE_DEPRECATED (method
) = 1;
8736 /* If the method in the @interface was marked as
8737 'noreturn', mark the function implementing the method
8738 as 'noreturn' too. */
8739 TREE_THIS_VOLATILE (current_function_decl
) = TREE_THIS_VOLATILE (proto
);
8744 /* We have a method @implementation even though we did not
8745 see a corresponding @interface declaration (which is allowed
8746 by Objective-C rules). Go ahead and place the method in
8747 the @interface anyway, so that message dispatch lookups
8749 tree interface
= implementation_template
;
8751 if (TREE_CODE (objc_implementation_context
)
8752 == CATEGORY_IMPLEMENTATION_TYPE
)
8753 interface
= lookup_category
8755 CLASS_SUPER_NAME (objc_implementation_context
));
8758 objc_add_method (interface
, copy_node (method
),
8759 TREE_CODE (method
) == CLASS_METHOD_DECL
,
8760 /* is_optional= */ false);
8765 static void *UOBJC_SUPER_scope
= 0;
8767 /* _n_Method (id self, SEL sel, ...)
8769 struct objc_super _S;
8770 _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
8774 get_super_receiver (void)
8776 if (objc_method_context
)
8778 tree super_expr
, super_expr_list
, class_expr
;
8780 if (!UOBJC_SUPER_decl
)
8782 UOBJC_SUPER_decl
= build_decl (input_location
,
8783 VAR_DECL
, get_identifier (TAG_SUPER
),
8784 objc_super_template
);
8785 /* This prevents `unused variable' warnings when compiling with -Wall. */
8786 TREE_USED (UOBJC_SUPER_decl
) = 1;
8787 DECL_READ_P (UOBJC_SUPER_decl
) = 1;
8788 lang_hooks
.decls
.pushdecl (UOBJC_SUPER_decl
);
8789 finish_decl (UOBJC_SUPER_decl
, input_location
, NULL_TREE
, NULL_TREE
,
8791 UOBJC_SUPER_scope
= objc_get_current_scope ();
8794 /* Set receiver to self. */
8795 super_expr
= objc_build_component_ref (UOBJC_SUPER_decl
, self_id
);
8796 super_expr
= build_modify_expr (input_location
, super_expr
, NULL_TREE
,
8797 NOP_EXPR
, input_location
, self_decl
,
8799 super_expr_list
= super_expr
;
8801 /* Set class to begin searching. */
8802 /* Get the ident for the superclass class field & build a ref to it.
8803 ??? maybe we should just name the field the same for all runtimes. */
8804 super_expr
= (*runtime
.super_superclassfield_ident
) ();
8805 super_expr
= objc_build_component_ref (UOBJC_SUPER_decl
, super_expr
);
8807 gcc_assert (imp_list
->imp_context
== objc_implementation_context
8808 && imp_list
->imp_template
== implementation_template
);
8809 inst_meth
= (TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
);
8811 if (TREE_CODE (objc_implementation_context
) == CLASS_IMPLEMENTATION_TYPE
)
8812 class_expr
= (*runtime
.get_class_super_ref
) (input_location
,
8813 imp_list
, inst_meth
);
8815 /* We have a category. */
8817 tree super_name
= CLASS_SUPER_NAME (imp_list
->imp_template
);
8820 /* Barf if super used in a category of a root object. */
8823 error ("no super class declared in interface for %qE",
8824 CLASS_NAME (imp_list
->imp_template
));
8825 return error_mark_node
;
8828 super_class
= (*runtime
.get_category_super_ref
) (input_location
,
8829 imp_list
, inst_meth
);
8830 class_expr
= build_c_cast (input_location
,
8831 TREE_TYPE (super_expr
), super_class
);
8834 super_expr
= build_modify_expr (input_location
, super_expr
, NULL_TREE
,
8836 input_location
, class_expr
, NULL_TREE
);
8838 super_expr_list
= build_compound_expr (input_location
,
8839 super_expr_list
, super_expr
);
8841 super_expr
= build_unary_op (input_location
,
8842 ADDR_EXPR
, UOBJC_SUPER_decl
, 0);
8843 super_expr_list
= build_compound_expr (input_location
,
8844 super_expr_list
, super_expr
);
8846 return super_expr_list
;
8850 error ("[super ...] must appear in a method context");
8851 return error_mark_node
;
8855 /* When exiting a scope, sever links to a 'super' declaration (if any)
8856 therein contained. */
8859 objc_clear_super_receiver (void)
8861 if (objc_method_context
8862 && UOBJC_SUPER_scope
== objc_get_current_scope ())
8864 UOBJC_SUPER_decl
= 0;
8865 UOBJC_SUPER_scope
= 0;
8870 objc_finish_method_definition (tree fndecl
)
8872 /* We cannot validly inline ObjC methods, at least not without a language
8873 extension to declare that a method need not be dynamically
8874 dispatched, so suppress all thoughts of doing so. */
8875 DECL_UNINLINABLE (fndecl
) = 1;
8878 /* The C++ front-end will have called finish_function() for us. */
8882 METHOD_ENCODING (objc_method_context
)
8883 = encode_method_prototype (objc_method_context
);
8885 /* Required to implement _msgSuper. This must be done AFTER finish_function,
8886 since the optimizer may find "may be used before set" errors. */
8887 objc_method_context
= NULL_TREE
;
8889 if (should_call_super_dealloc
)
8890 warning (0, "method possibly missing a [super dealloc] call");
8893 /* Given a tree DECL node, produce a printable description of it in the given
8894 buffer, overwriting the buffer. */
8897 gen_declaration (tree decl
)
8903 gen_type_name_0 (TREE_TYPE (decl
));
8905 if (DECL_NAME (decl
))
8907 if (!POINTER_TYPE_P (TREE_TYPE (decl
)))
8908 strcat (errbuf
, " ");
8910 strcat (errbuf
, IDENTIFIER_POINTER (DECL_NAME (decl
)));
8913 if (DECL_INITIAL (decl
)
8914 && TREE_CODE (DECL_INITIAL (decl
)) == INTEGER_CST
)
8915 sprintf (errbuf
+ strlen (errbuf
), ": " HOST_WIDE_INT_PRINT_DEC
,
8916 TREE_INT_CST_LOW (DECL_INITIAL (decl
)));
8922 /* Given a tree TYPE node, produce a printable description of it in the given
8923 buffer, overwriting the buffer. */
8926 gen_type_name_0 (tree type
)
8928 tree orig
= type
, proto
;
8930 if (TYPE_P (type
) && TYPE_NAME (type
))
8931 type
= TYPE_NAME (type
);
8932 else if (POINTER_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
8934 tree inner
= TREE_TYPE (type
);
8936 while (TREE_CODE (inner
) == ARRAY_TYPE
)
8937 inner
= TREE_TYPE (inner
);
8939 gen_type_name_0 (inner
);
8941 if (!POINTER_TYPE_P (inner
))
8942 strcat (errbuf
, " ");
8944 if (POINTER_TYPE_P (type
))
8945 strcat (errbuf
, "*");
8947 while (type
!= inner
)
8949 strcat (errbuf
, "[");
8951 if (TYPE_DOMAIN (type
))
8955 sprintf (sz
, HOST_WIDE_INT_PRINT_DEC
,
8957 (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))) + 1));
8958 strcat (errbuf
, sz
);
8961 strcat (errbuf
, "]");
8962 type
= TREE_TYPE (type
);
8968 if (TREE_CODE (type
) == TYPE_DECL
&& DECL_NAME (type
))
8969 type
= DECL_NAME (type
);
8971 strcat (errbuf
, TREE_CODE (type
) == IDENTIFIER_NODE
8972 ? IDENTIFIER_POINTER (type
)
8975 /* For 'id' and 'Class', adopted protocols are stored in the pointee. */
8976 if (objc_is_id (orig
))
8977 orig
= TREE_TYPE (orig
);
8979 proto
= TYPE_HAS_OBJC_INFO (orig
) ? TYPE_OBJC_PROTOCOL_LIST (orig
) : NULL_TREE
;
8983 strcat (errbuf
, " <");
8987 IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto
))));
8988 proto
= TREE_CHAIN (proto
);
8989 strcat (errbuf
, proto
? ", " : ">");
8998 gen_type_name (tree type
)
9002 return gen_type_name_0 (type
);
9005 /* Given a method tree, put a printable description into the given
9006 buffer (overwriting) and return a pointer to the buffer. */
9009 gen_method_decl (tree method
)
9013 strcpy (errbuf
, "("); /* NB: Do _not_ call strcat() here. */
9014 gen_type_name_0 (TREE_VALUE (TREE_TYPE (method
)));
9015 strcat (errbuf
, ")");
9016 chain
= METHOD_SEL_ARGS (method
);
9020 /* We have a chain of keyword_decls. */
9023 if (KEYWORD_KEY_NAME (chain
))
9024 strcat (errbuf
, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain
)));
9026 strcat (errbuf
, ":(");
9027 gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain
)));
9028 strcat (errbuf
, ")");
9030 strcat (errbuf
, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain
)));
9031 if ((chain
= DECL_CHAIN (chain
)))
9032 strcat (errbuf
, " ");
9036 if (METHOD_ADD_ARGS (method
))
9038 chain
= TREE_CHAIN (METHOD_ADD_ARGS (method
));
9040 /* Know we have a chain of parm_decls. */
9043 strcat (errbuf
, ", ");
9044 gen_type_name_0 (TREE_TYPE (TREE_VALUE (chain
)));
9045 chain
= TREE_CHAIN (chain
);
9048 if (METHOD_ADD_ARGS_ELLIPSIS_P (method
))
9049 strcat (errbuf
, ", ...");
9054 /* We have a unary selector. */
9055 strcat (errbuf
, IDENTIFIER_POINTER (METHOD_SEL_NAME (method
)));
9063 /* Dump an @interface declaration of the supplied class CHAIN to the
9064 supplied file FP. Used to implement the -gen-decls option (which
9065 prints out an @interface declaration of all classes compiled in
9066 this run); potentially useful for debugging the compiler too. */
9068 dump_interface (FILE *fp
, tree chain
)
9070 /* FIXME: A heap overflow here whenever a method (or ivar)
9071 declaration is so long that it doesn't fit in the buffer. The
9072 code and all the related functions should be rewritten to avoid
9073 using fixed size buffers. */
9074 const char *my_name
= IDENTIFIER_POINTER (CLASS_NAME (chain
));
9075 tree ivar_decls
= CLASS_RAW_IVARS (chain
);
9076 tree nst_methods
= CLASS_NST_METHODS (chain
);
9077 tree cls_methods
= CLASS_CLS_METHODS (chain
);
9079 fprintf (fp
, "\n@interface %s", my_name
);
9081 /* CLASS_SUPER_NAME is used to store the superclass name for
9082 classes, and the category name for categories. */
9083 if (CLASS_SUPER_NAME (chain
))
9085 const char *name
= IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain
));
9087 switch (TREE_CODE (chain
))
9089 case CATEGORY_IMPLEMENTATION_TYPE
:
9090 case CATEGORY_INTERFACE_TYPE
:
9091 fprintf (fp
, " (%s)\n", name
);
9094 fprintf (fp
, " : %s\n", name
);
9101 /* FIXME - the following doesn't seem to work at the moment. */
9104 fprintf (fp
, "{\n");
9107 fprintf (fp
, "\t%s;\n", gen_declaration (ivar_decls
));
9108 ivar_decls
= TREE_CHAIN (ivar_decls
);
9111 fprintf (fp
, "}\n");
9116 fprintf (fp
, "- %s;\n", gen_method_decl (nst_methods
));
9117 nst_methods
= TREE_CHAIN (nst_methods
);
9122 fprintf (fp
, "+ %s;\n", gen_method_decl (cls_methods
));
9123 cls_methods
= TREE_CHAIN (cls_methods
);
9126 fprintf (fp
, "@end\n");
9130 /* Produce the pretty printing for an Objective-C method. This is
9131 currently unused, but could be handy while reorganizing the pretty
9132 printing to be more robust. */
9134 objc_pretty_print_method (bool is_class_method
,
9135 const char *class_name
,
9136 const char *category_name
,
9137 const char *selector
)
9141 char *result
= XNEWVEC (char, strlen (class_name
) + strlen (category_name
)
9142 + strlen (selector
) + 7);
9144 if (is_class_method
)
9145 sprintf (result
, "+[%s(%s) %s]", class_name
, category_name
, selector
);
9147 sprintf (result
, "-[%s(%s) %s]", class_name
, category_name
, selector
);
9153 char *result
= XNEWVEC (char, strlen (class_name
)
9154 + strlen (selector
) + 5);
9156 if (is_class_method
)
9157 sprintf (result
, "+[%s %s]", class_name
, selector
);
9159 sprintf (result
, "-[%s %s]", class_name
, selector
);
9166 /* Demangle function for Objective-C. Attempt to demangle the
9167 function name associated with a method (eg, going from
9168 "_i_NSObject__class" to "-[NSObject class]"); usually for the
9169 purpose of pretty printing or error messages. Return the demangled
9170 name, or NULL if the string is not an Objective-C mangled method
9173 Because of how the mangling is done, any method that has a '_' in
9174 its original name is at risk of being demangled incorrectly. In
9175 some cases there are multiple valid ways to demangle a method name
9176 and there is no way we can decide.
9178 TODO: objc_demangle() can't always get it right; the right way to
9179 get this correct for all method names would be to store the
9180 Objective-C method name somewhere in the function decl. Then,
9181 there is no demangling to do; we'd just pull the method name out of
9182 the decl. As an additional bonus, when printing error messages we
9183 could check for such a method name, and if we find it, we know the
9184 function is actually an Objective-C method and we could print error
9185 messages saying "In method '+[NSObject class]" instead of "In
9186 function '+[NSObject class]" as we do now. */
9188 objc_demangle (const char *mangled
)
9190 char *demangled
, *cp
;
9192 /* First of all, if the name is too short it can't be an Objective-C
9193 mangled method name. */
9194 if (mangled
[0] == '\0' || mangled
[1] == '\0' || mangled
[2] == '\0')
9197 /* If the name looks like an already demangled one, return it
9198 unchanged. This should only happen on Darwin, where method names
9199 are mangled differently into a pretty-print form (such as
9200 '+[NSObject class]', see darwin.h). In that case, demangling is
9201 a no-op, but we need to return the demangled name if it was an
9202 ObjC one, and return NULL if not. We should be safe as no C/C++
9203 function can start with "-[" or "+[". */
9204 if ((mangled
[0] == '-' || mangled
[0] == '+')
9205 && (mangled
[1] == '['))
9208 if (mangled
[0] == '_' &&
9209 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
9212 cp
= demangled
= XNEWVEC (char, strlen(mangled
) + 2);
9213 if (mangled
[1] == 'i')
9214 *cp
++ = '-'; /* for instance method */
9216 *cp
++ = '+'; /* for class method */
9217 *cp
++ = '['; /* opening left brace */
9218 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
9219 while (*cp
&& *cp
== '_')
9220 cp
++; /* skip any initial underbars in class name */
9221 cp
= strchr(cp
, '_'); /* find first non-initial underbar */
9224 free(demangled
); /* not mangled name */
9227 if (cp
[1] == '_') /* easy case: no category name */
9229 *cp
++ = ' '; /* replace two '_' with one ' ' */
9230 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
9234 *cp
++ = '('; /* less easy case: category name */
9235 cp
= strchr(cp
, '_');
9238 free(demangled
); /* not mangled name */
9242 *cp
++ = ' '; /* overwriting 1st char of method name... */
9243 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
9245 /* Now we have the method name. We need to generally replace
9246 '_' with ':' but trying to preserve '_' if it could only have
9247 been in the mangled string because it was already in the
9248 original name. In cases where it's ambiguous, we assume that
9249 any '_' originated from a ':'. */
9251 /* Initial '_'s in method name can't have been generating by
9252 converting ':'s. Skip them. */
9253 while (*cp
&& *cp
== '_')
9256 /* If the method name does not end with '_', then it has no
9257 arguments and there was no replacement of ':'s with '_'s
9258 during mangling. Check for that case, and skip any
9259 replacement if so. This at least guarantees that methods
9260 with no arguments are always demangled correctly (unless the
9261 original name ends with '_'). */
9262 if (*(mangled
+ strlen (mangled
) - 1) != '_')
9264 /* Skip to the end. */
9270 /* Replace remaining '_' with ':'. This may get it wrong if
9271 there were '_'s in the original name. In most cases it
9272 is impossible to disambiguate. */
9277 *cp
++ = ']'; /* closing right brace */
9278 *cp
++ = 0; /* string terminator */
9282 return NULL
; /* not an objc mangled name */
9285 /* Try to pretty-print a decl. If the 'decl' is an Objective-C
9286 specific decl, return the printable name for it. If not, return
9289 objc_maybe_printable_name (tree decl
, int v ATTRIBUTE_UNUSED
)
9291 switch (TREE_CODE (decl
))
9294 return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl
)));
9297 /* The following happens when we are printing a deprecation
9298 warning for a method. The warn_deprecation() will end up
9299 trying to print the decl for INSTANCE_METHOD_DECL or
9300 CLASS_METHOD_DECL. It would be nice to be able to print
9301 "-[NSObject autorelease] is deprecated", but to do that, we'd
9302 need to store the class and method name in the method decl,
9303 which we currently don't do. For now, just return the name
9304 of the method. We don't return NULL, because that may
9305 trigger further attempts to pretty-print the decl in C/C++,
9306 but they wouldn't know how to pretty-print it. */
9307 case INSTANCE_METHOD_DECL
:
9308 case CLASS_METHOD_DECL
:
9309 return IDENTIFIER_POINTER (DECL_NAME (decl
));
9311 /* This happens when printing a deprecation warning for a
9312 property. We may want to consider some sort of pretty
9313 printing (eg, include the class name where it was declared
9316 return IDENTIFIER_POINTER (PROPERTY_NAME (decl
));
9324 /* Return a printable name for 'decl'. This first tries
9325 objc_maybe_printable_name(), and if that fails, it returns the name
9326 in the decl. This is used as LANG_HOOKS_DECL_PRINTABLE_NAME for
9327 Objective-C; in Objective-C++, setting the hook is not enough
9328 because lots of C++ Front-End code calls cxx_printable_name,
9329 dump_decl and other C++ functions directly. So instead we have
9330 modified dump_decl to call objc_maybe_printable_name directly. */
9332 objc_printable_name (tree decl
, int v
)
9334 const char *demangled_name
= objc_maybe_printable_name (decl
, v
);
9336 if (demangled_name
!= NULL
)
9337 return demangled_name
;
9339 return IDENTIFIER_POINTER (DECL_NAME (decl
));
9342 /* Routine is called to issue diagnostic when reference to a private
9343 ivar is made and no other variable with same name is found in
9346 objc_diagnose_private_ivar (tree id
)
9349 if (!objc_method_context
)
9351 ivar
= is_ivar (objc_ivar_chain
, id
);
9352 if (ivar
&& is_private (ivar
))
9354 error ("instance variable %qs is declared private",
9355 IDENTIFIER_POINTER (id
));
9361 /* Look up ID as an instance variable. OTHER contains the result of
9362 the C or C++ lookup, which we may want to use instead. */
9363 /* To use properties inside an instance method, use self.property. */
9365 objc_lookup_ivar (tree other
, tree id
)
9369 /* If we are not inside of an ObjC method, ivar lookup makes no sense. */
9370 if (!objc_method_context
)
9373 if (!strcmp (IDENTIFIER_POINTER (id
), "super"))
9374 /* We have a message to super. */
9375 return get_super_receiver ();
9377 /* In a class method, look up an instance variable only as a last
9379 if (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
9380 && other
&& other
!= error_mark_node
)
9383 /* Don't look up the ivar if the user has explicitly advised against
9384 it with -fno-local-ivars. */
9386 if (!flag_local_ivars
)
9389 /* Look up the ivar, but do not use it if it is not accessible. */
9390 ivar
= is_ivar (objc_ivar_chain
, id
);
9392 if (!ivar
|| is_private (ivar
))
9395 /* In an instance method, a local variable (or parameter) may hide the
9396 instance variable. */
9397 if (TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
9398 && other
&& other
!= error_mark_node
9400 && CP_DECL_CONTEXT (other
) != global_namespace
)
9402 && !DECL_FILE_SCOPE_P (other
))
9405 if (warn_shadow_ivar
== 1 || (warn_shadow
&& warn_shadow_ivar
!= 0)) {
9406 warning (warn_shadow_ivar
? OPT_Wshadow_ivar
: OPT_Wshadow
,
9407 "local declaration of %qE hides instance variable", id
);
9413 /* At this point, we are either in an instance method with no obscuring
9414 local definitions, or in a class method with no alternate definitions
9416 return build_ivar_reference (id
);
9419 /* Possibly rewrite a function CALL into an OBJ_TYPE_REF expression. This
9420 needs to be done if we are calling a function through a cast. */
9423 objc_rewrite_function_call (tree function
, tree first_param
)
9425 if (TREE_CODE (function
) == NOP_EXPR
9426 && TREE_CODE (TREE_OPERAND (function
, 0)) == ADDR_EXPR
9427 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (function
, 0), 0))
9430 function
= build3 (OBJ_TYPE_REF
, TREE_TYPE (function
),
9431 TREE_OPERAND (function
, 0),
9432 first_param
, size_zero_node
);
9438 /* This is called to "gimplify" a PROPERTY_REF node. It builds the
9439 corresponding 'getter' function call. Note that we assume the
9440 PROPERTY_REF to be valid since we generated it while parsing. */
9442 objc_gimplify_property_ref (tree
*expr_p
)
9444 tree getter
= PROPERTY_REF_GETTER_CALL (*expr_p
);
9447 if (getter
== NULL_TREE
)
9449 tree property_decl
= PROPERTY_REF_PROPERTY_DECL (*expr_p
);
9450 /* This can happen if DECL_ARTIFICIAL (*expr_p), but
9451 should be impossible for real properties, which always
9453 error_at (EXPR_LOCATION (*expr_p
), "no %qs getter found",
9454 IDENTIFIER_POINTER (PROPERTY_NAME (property_decl
)));
9455 /* Try to recover from the error to prevent an ICE. We take
9456 zero and cast it to the type of the property. */
9457 *expr_p
= convert (TREE_TYPE (property_decl
),
9462 if (PROPERTY_REF_DEPRECATED_GETTER (*expr_p
))
9464 /* PROPERTY_REF_DEPRECATED_GETTER contains the method prototype
9465 that is deprecated. */
9466 warn_deprecated_use (PROPERTY_REF_DEPRECATED_GETTER (*expr_p
),
9472 /* In C++, a getter which returns an aggregate value results in a
9473 target_expr which initializes a temporary to the call
9475 if (TREE_CODE (getter
) == TARGET_EXPR
)
9477 gcc_assert (MAYBE_CLASS_TYPE_P (TREE_TYPE (getter
)));
9478 gcc_assert (TREE_CODE (TREE_OPERAND (getter
, 0)) == VAR_DECL
);
9479 call_exp
= TREE_OPERAND (getter
, 1);
9482 gcc_assert (TREE_CODE (call_exp
) == CALL_EXPR
);
9487 /* This is called when "gimplifying" the trees. We need to gimplify
9488 the Objective-C/Objective-C++ specific trees, then hand over the
9489 process to C/C++. */
9491 objc_gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
9493 enum tree_code code
= TREE_CODE (*expr_p
);
9496 /* Look for the special case of OBJC_TYPE_REF with the address
9497 of a function in OBJ_TYPE_REF_EXPR (presumably objc_msgSend
9498 or one of its cousins). */
9500 if (TREE_CODE (OBJ_TYPE_REF_EXPR (*expr_p
)) == ADDR_EXPR
9501 && TREE_CODE (TREE_OPERAND (OBJ_TYPE_REF_EXPR (*expr_p
), 0))
9504 enum gimplify_status r0
, r1
;
9506 /* Postincrements in OBJ_TYPE_REF_OBJECT don't affect the
9507 value of the OBJ_TYPE_REF, so force them to be emitted
9508 during subexpression evaluation rather than after the
9509 OBJ_TYPE_REF. This permits objc_msgSend calls in
9510 Objective C to use direct rather than indirect calls when
9511 the object expression has a postincrement. */
9512 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
, NULL
,
9513 is_gimple_val
, fb_rvalue
);
9514 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
, post_p
,
9515 is_gimple_val
, fb_rvalue
);
9517 return MIN (r0
, r1
);
9521 objc_gimplify_property_ref (expr_p
);
9522 /* Do not return yet; let C/C++ gimplify the resulting expression. */
9529 return (enum gimplify_status
) cp_gimplify_expr (expr_p
, pre_p
, post_p
);
9531 return (enum gimplify_status
) c_gimplify_expr (expr_p
, pre_p
, post_p
);
9535 /* --- FAST ENUMERATION --- */
9536 /* Begin code generation for fast enumeration (foreach) ... */
9540 struct __objcFastEnumerationState
9542 unsigned long state;
9544 unsigned long *mutationsPtr;
9545 unsigned long extra[5];
9548 Confusingly enough, NSFastEnumeration is then defined by libraries
9549 to be the same structure.
9553 build_fast_enumeration_state_template (void)
9555 tree decls
, *chain
= NULL
;
9558 objc_fast_enumeration_state_template
= objc_start_struct (get_identifier
9559 (TAG_FAST_ENUMERATION_STATE
));
9561 /* unsigned long state; */
9562 decls
= add_field_decl (long_unsigned_type_node
, "state", &chain
);
9565 add_field_decl (build_pointer_type (objc_object_type
),
9566 "itemsPtr", &chain
);
9568 /* unsigned long *mutationsPtr; */
9569 add_field_decl (build_pointer_type (long_unsigned_type_node
),
9570 "mutationsPtr", &chain
);
9572 /* unsigned long extra[5]; */
9573 add_field_decl (build_sized_array_type (long_unsigned_type_node
, 5),
9577 objc_finish_struct (objc_fast_enumeration_state_template
, decls
);
9581 'objc_finish_foreach_loop()' generates the code for an Objective-C
9582 foreach loop. The 'location' argument is the location of the 'for'
9583 that starts the loop. The 'object_expression' is the expression of
9584 the 'object' that iterates; the 'collection_expression' is the
9585 expression of the collection that we iterate over (we need to make
9586 sure we evaluate this only once); the 'for_body' is the set of
9587 statements to be executed in each iteration; 'break_label' and
9588 'continue_label' are the break and continue labels which we need to
9589 emit since the <statements> may be jumping to 'break_label' (if they
9590 contain 'break') or to 'continue_label' (if they contain
9595 for (<object expression> in <collection expression>)
9598 which is compiled into the following blurb:
9601 id __objc_foreach_collection;
9602 __objc_fast_enumeration_state __objc_foreach_enum_state;
9603 unsigned long __objc_foreach_batchsize;
9604 id __objc_foreach_items[16];
9605 __objc_foreach_collection = <collection expression>;
9606 __objc_foreach_enum_state = { 0 };
9607 __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16];
9609 if (__objc_foreach_batchsize == 0)
9610 <object expression> = nil;
9613 unsigned long __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr;
9616 unsigned long __objc_foreach_index;
9617 __objc_foreach_index = 0;
9620 if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>);
9621 <object expression> = enumState.itemsPtr[__objc_foreach_index];
9622 <statements> [PS: inside <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label]
9625 __objc_foreach_index++;
9626 if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object;
9627 __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16];
9629 if (__objc_foreach_batchsize != 0) goto next_batch;
9630 <object expression> = nil;
9635 'statements' may contain a 'continue' or 'break' instruction, which
9636 the user expects to 'continue' or 'break' the entire foreach loop.
9637 We are provided the labels that 'break' and 'continue' jump to, so
9638 we place them where we want them to jump to when they pick them.
9640 Optimization TODO: we could cache the IMP of
9641 countByEnumeratingWithState:objects:count:.
9644 /* If you need to debug objc_finish_foreach_loop(), uncomment the following line. */
9645 /* #define DEBUG_OBJC_FINISH_FOREACH_LOOP 1 */
9647 #ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP
9648 #include "tree-pretty-print.h"
9652 objc_finish_foreach_loop (location_t location
, tree object_expression
, tree collection_expression
, tree for_body
,
9653 tree break_label
, tree continue_label
)
9655 /* A tree representing the __objcFastEnumerationState struct type,
9656 or NSFastEnumerationState struct, whatever we are using. */
9657 tree objc_fast_enumeration_state_type
;
9659 /* The trees representing the declarations of each of the local variables. */
9660 tree objc_foreach_collection_decl
;
9661 tree objc_foreach_enum_state_decl
;
9662 tree objc_foreach_items_decl
;
9663 tree objc_foreach_batchsize_decl
;
9664 tree objc_foreach_mutations_pointer_decl
;
9665 tree objc_foreach_index_decl
;
9667 /* A tree representing the selector countByEnumeratingWithState:objects:count:. */
9670 /* A tree representing the local bind. */
9673 /* A tree representing the external 'if (__objc_foreach_batchsize)' */
9676 /* A tree representing the 'else' part of 'first_if' */
9679 /* A tree representing the 'next_batch' label. */
9680 tree next_batch_label_decl
;
9682 /* A tree representing the binding after the 'next_batch' label. */
9683 tree next_batch_bind
;
9685 /* A tree representing the 'next_object' label. */
9686 tree next_object_label_decl
;
9688 /* Temporary variables. */
9692 if (flag_objc1_only
)
9693 error_at (location
, "fast enumeration is not available in Objective-C 1.0");
9695 if (object_expression
== error_mark_node
)
9698 if (collection_expression
== error_mark_node
)
9701 if (!objc_type_valid_for_messaging (TREE_TYPE (object_expression
), true))
9703 error_at (location
, "iterating variable in fast enumeration is not an object");
9707 if (!objc_type_valid_for_messaging (TREE_TYPE (collection_expression
), true))
9709 error_at (location
, "collection in fast enumeration is not an object");
9713 /* TODO: Check that object_expression is either a variable
9714 declaration, or an lvalue. */
9716 /* This kludge is an idea from apple. We use the
9717 __objcFastEnumerationState struct implicitly defined by the
9718 compiler, unless a NSFastEnumerationState struct has been defined
9719 (by a Foundation library such as GNUstep Base) in which case, we
9722 objc_fast_enumeration_state_type
= objc_fast_enumeration_state_template
;
9724 tree objc_NSFastEnumeration_type
= lookup_name (get_identifier ("NSFastEnumerationState"));
9726 if (objc_NSFastEnumeration_type
)
9728 /* TODO: We really need to check that
9729 objc_NSFastEnumeration_type is the same as ours! */
9730 if (TREE_CODE (objc_NSFastEnumeration_type
) == TYPE_DECL
)
9732 /* If it's a typedef, use the original type. */
9733 if (DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type
))
9734 objc_fast_enumeration_state_type
= DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type
);
9736 objc_fast_enumeration_state_type
= TREE_TYPE (objc_NSFastEnumeration_type
);
9742 /* Done by c-parser.c. */
9745 /* Done by c-parser.c. */
9747 /* Disable warnings that 'object' is unused. For example the code
9749 for (id object in collection)
9752 which can be used to count how many objects there are in the
9753 collection is fine and should generate no warnings even if
9754 'object' is technically unused. */
9755 TREE_USED (object_expression
) = 1;
9756 if (DECL_P (object_expression
))
9757 DECL_READ_P (object_expression
) = 1;
9759 /* id __objc_foreach_collection */
9760 objc_foreach_collection_decl
= objc_create_temporary_var (objc_object_type
, "__objc_foreach_collection");
9762 /* __objcFastEnumerationState __objc_foreach_enum_state; */
9763 objc_foreach_enum_state_decl
= objc_create_temporary_var (objc_fast_enumeration_state_type
, "__objc_foreach_enum_state");
9764 TREE_CHAIN (objc_foreach_enum_state_decl
) = objc_foreach_collection_decl
;
9766 /* id __objc_foreach_items[16]; */
9767 objc_foreach_items_decl
= objc_create_temporary_var (build_sized_array_type (objc_object_type
, 16), "__objc_foreach_items");
9768 TREE_CHAIN (objc_foreach_items_decl
) = objc_foreach_enum_state_decl
;
9770 /* unsigned long __objc_foreach_batchsize; */
9771 objc_foreach_batchsize_decl
= objc_create_temporary_var (long_unsigned_type_node
, "__objc_foreach_batchsize");
9772 TREE_CHAIN (objc_foreach_batchsize_decl
) = objc_foreach_items_decl
;
9774 /* Generate the local variable binding. */
9775 bind
= build3 (BIND_EXPR
, void_type_node
, objc_foreach_batchsize_decl
, NULL
, NULL
);
9776 SET_EXPR_LOCATION (bind
, location
);
9777 TREE_SIDE_EFFECTS (bind
) = 1;
9779 /* __objc_foreach_collection = <collection expression>; */
9780 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_collection_decl
, collection_expression
);
9781 SET_EXPR_LOCATION (t
, location
);
9782 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9783 /* We have used 'collection_expression'. */
9784 mark_exp_read (collection_expression
);
9786 /* __objc_foreach_enum_state.state = 0; */
9787 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9788 get_identifier ("state")),
9789 build_int_cst (long_unsigned_type_node
, 0));
9790 SET_EXPR_LOCATION (t
, location
);
9791 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9793 /* __objc_foreach_enum_state.itemsPtr = NULL; */
9794 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9795 get_identifier ("itemsPtr")),
9797 SET_EXPR_LOCATION (t
, location
);
9798 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9800 /* __objc_foreach_enum_state.mutationsPtr = NULL; */
9801 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9802 get_identifier ("mutationsPtr")),
9804 SET_EXPR_LOCATION (t
, location
);
9805 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9807 /* __objc_foreach_enum_state.extra[0] = 0; */
9808 /* __objc_foreach_enum_state.extra[1] = 0; */
9809 /* __objc_foreach_enum_state.extra[2] = 0; */
9810 /* __objc_foreach_enum_state.extra[3] = 0; */
9811 /* __objc_foreach_enum_state.extra[4] = 0; */
9812 for (i
= 0; i
< 5 ; i
++)
9814 t
= build2 (MODIFY_EXPR
, void_type_node
,
9815 build_array_ref (location
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9816 get_identifier ("extra")),
9817 build_int_cst (NULL_TREE
, i
)),
9818 build_int_cst (long_unsigned_type_node
, 0));
9819 SET_EXPR_LOCATION (t
, location
);
9820 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9823 /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */
9824 selector_name
= get_identifier ("countByEnumeratingWithState:objects:count:");
9826 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
9828 tree_cons
/* &__objc_foreach_enum_state */
9829 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
9830 tree_cons
/* __objc_foreach_items */
9831 (NULL_TREE
, objc_foreach_items_decl
,
9833 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
9835 /* In C, we need to decay the __objc_foreach_items array that we are passing. */
9837 struct c_expr array
;
9838 array
.value
= objc_foreach_items_decl
;
9839 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
9841 tree_cons
/* &__objc_foreach_enum_state */
9842 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
9843 tree_cons
/* __objc_foreach_items */
9844 (NULL_TREE
, default_function_array_conversion (location
, array
).value
,
9846 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
9849 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_batchsize_decl
,
9850 convert (long_unsigned_type_node
, t
));
9851 SET_EXPR_LOCATION (t
, location
);
9852 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9854 /* if (__objc_foreach_batchsize == 0) */
9855 first_if
= build3 (COND_EXPR
, void_type_node
,
9858 (c_common_truthvalue_conversion
9860 build_binary_op (location
,
9862 objc_foreach_batchsize_decl
,
9863 build_int_cst (long_unsigned_type_node
, 0), 1)),
9865 /* Then block (we fill it in later). */
9867 /* Else block (we fill it in later). */
9869 SET_EXPR_LOCATION (first_if
, location
);
9870 append_to_statement_list (first_if
, &BIND_EXPR_BODY (bind
));
9872 /* then <object expression> = nil; */
9873 t
= build2 (MODIFY_EXPR
, void_type_node
, object_expression
, convert (objc_object_type
, null_pointer_node
));
9874 SET_EXPR_LOCATION (t
, location
);
9875 COND_EXPR_THEN (first_if
) = t
;
9877 /* Now we build the 'else' part of the if; once we finish building
9878 it, we attach it to first_if as the 'else' part. */
9883 /* unsigned long __objc_foreach_mutations_pointer; */
9884 objc_foreach_mutations_pointer_decl
= objc_create_temporary_var (long_unsigned_type_node
, "__objc_foreach_mutations_pointer");
9886 /* Generate the local variable binding. */
9887 first_else
= build3 (BIND_EXPR
, void_type_node
, objc_foreach_mutations_pointer_decl
, NULL
, NULL
);
9888 SET_EXPR_LOCATION (first_else
, location
);
9889 TREE_SIDE_EFFECTS (first_else
) = 1;
9891 /* __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr; */
9892 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_mutations_pointer_decl
,
9893 build_indirect_ref (location
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9894 get_identifier ("mutationsPtr")),
9896 SET_EXPR_LOCATION (t
, location
);
9897 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
9900 next_batch_label_decl
= create_artificial_label (location
);
9901 t
= build1 (LABEL_EXPR
, void_type_node
, next_batch_label_decl
);
9902 SET_EXPR_LOCATION (t
, location
);
9903 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
9907 /* unsigned long __objc_foreach_index; */
9908 objc_foreach_index_decl
= objc_create_temporary_var (long_unsigned_type_node
, "__objc_foreach_index");
9910 /* Generate the local variable binding. */
9911 next_batch_bind
= build3 (BIND_EXPR
, void_type_node
, objc_foreach_index_decl
, NULL
, NULL
);
9912 SET_EXPR_LOCATION (next_batch_bind
, location
);
9913 TREE_SIDE_EFFECTS (next_batch_bind
) = 1;
9914 append_to_statement_list (next_batch_bind
, &BIND_EXPR_BODY (first_else
));
9916 /* __objc_foreach_index = 0; */
9917 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_index_decl
,
9918 build_int_cst (long_unsigned_type_node
, 0));
9919 SET_EXPR_LOCATION (t
, location
);
9920 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9923 next_object_label_decl
= create_artificial_label (location
);
9924 t
= build1 (LABEL_EXPR
, void_type_node
, next_object_label_decl
);
9925 SET_EXPR_LOCATION (t
, location
);
9926 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9928 /* if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>); */
9929 t
= build3 (COND_EXPR
, void_type_node
,
9932 (c_common_truthvalue_conversion
9937 objc_foreach_mutations_pointer_decl
,
9938 build_indirect_ref (location
,
9939 objc_build_component_ref (objc_foreach_enum_state_decl
,
9940 get_identifier ("mutationsPtr")),
9941 RO_UNARY_STAR
), 1)),
9944 build_function_call (input_location
,
9945 objc_enumeration_mutation_decl
,
9946 tree_cons (NULL
, collection_expression
, NULL
)),
9949 SET_EXPR_LOCATION (t
, location
);
9950 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9952 /* <object expression> = enumState.itemsPtr[__objc_foreach_index]; */
9953 t
= build2 (MODIFY_EXPR
, void_type_node
, object_expression
,
9954 build_array_ref (location
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9955 get_identifier ("itemsPtr")),
9956 objc_foreach_index_decl
));
9957 SET_EXPR_LOCATION (t
, location
);
9958 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9960 /* <statements> [PS: in <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label] */
9961 append_to_statement_list (for_body
, &BIND_EXPR_BODY (next_batch_bind
));
9963 /* continue_label: */
9966 t
= build1 (LABEL_EXPR
, void_type_node
, continue_label
);
9967 SET_EXPR_LOCATION (t
, location
);
9968 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9971 /* __objc_foreach_index++; */
9972 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_index_decl
,
9973 build_binary_op (location
,
9975 objc_foreach_index_decl
,
9976 build_int_cst (long_unsigned_type_node
, 1), 1));
9977 SET_EXPR_LOCATION (t
, location
);
9978 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9980 /* if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object; */
9981 t
= build3 (COND_EXPR
, void_type_node
,
9984 (c_common_truthvalue_conversion
9986 build_binary_op (location
,
9988 objc_foreach_index_decl
,
9989 objc_foreach_batchsize_decl
, 1)),
9992 build1 (GOTO_EXPR
, void_type_node
, next_object_label_decl
),
9995 SET_EXPR_LOCATION (t
, location
);
9996 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9998 /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */
10000 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
10002 tree_cons
/* &__objc_foreach_enum_state */
10003 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
10004 tree_cons
/* __objc_foreach_items */
10005 (NULL_TREE
, objc_foreach_items_decl
,
10007 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
10009 /* In C, we need to decay the __objc_foreach_items array that we are passing. */
10011 struct c_expr array
;
10012 array
.value
= objc_foreach_items_decl
;
10013 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
10015 tree_cons
/* &__objc_foreach_enum_state */
10016 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
10017 tree_cons
/* __objc_foreach_items */
10018 (NULL_TREE
, default_function_array_conversion (location
, array
).value
,
10020 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
10023 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_batchsize_decl
,
10024 convert (long_unsigned_type_node
, t
));
10025 SET_EXPR_LOCATION (t
, location
);
10026 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
10030 /* if (__objc_foreach_batchsize != 0) goto next_batch; */
10031 t
= build3 (COND_EXPR
, void_type_node
,
10034 (c_common_truthvalue_conversion
10036 build_binary_op (location
,
10038 objc_foreach_batchsize_decl
,
10039 build_int_cst (long_unsigned_type_node
, 0), 1)),
10042 build1 (GOTO_EXPR
, void_type_node
, next_batch_label_decl
),
10045 SET_EXPR_LOCATION (t
, location
);
10046 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
10048 /* <object expression> = nil; */
10049 t
= build2 (MODIFY_EXPR
, void_type_node
, object_expression
, convert (objc_object_type
, null_pointer_node
));
10050 SET_EXPR_LOCATION (t
, location
);
10051 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
10056 t
= build1 (LABEL_EXPR
, void_type_node
, break_label
);
10057 SET_EXPR_LOCATION (t
, location
);
10058 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
10062 COND_EXPR_ELSE (first_if
) = first_else
;
10064 /* Do the whole thing. */
10067 #ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP
10068 /* This will print to stderr the whole blurb generated by the
10069 compiler while compiling (assuming the compiler doesn't crash
10070 before getting here).
10072 debug_generic_stmt (bind
);
10076 /* Done by c-parser.c */
10079 /* --- SUPPORT FOR FORMAT ARG CHECKING --- */
10080 /* Return true if we have an NxString object pointer. */
10083 objc_string_ref_type_p (tree strp
)
10086 if (!strp
|| TREE_CODE (strp
) != POINTER_TYPE
)
10089 tmv
= TYPE_MAIN_VARIANT (TREE_TYPE (strp
));
10090 tmv
= OBJC_TYPE_NAME (tmv
);
10092 && TREE_CODE (tmv
) == IDENTIFIER_NODE
10093 && IDENTIFIER_POINTER (tmv
)
10094 && !strncmp (IDENTIFIER_POINTER (tmv
), "NSString", 8));
10097 /* At present the behavior of this is undefined and it does nothing. */
10099 objc_check_format_arg (tree
ARG_UNUSED (format_arg
),
10100 tree
ARG_UNUSED (args_list
))
10105 objc_common_init_ts (void)
10107 c_common_init_ts ();
10109 MARK_TS_DECL_NON_COMMON (CLASS_METHOD_DECL
);
10110 MARK_TS_DECL_NON_COMMON (INSTANCE_METHOD_DECL
);
10111 MARK_TS_DECL_NON_COMMON (KEYWORD_DECL
);
10112 MARK_TS_DECL_NON_COMMON (PROPERTY_DECL
);
10114 MARK_TS_COMMON (CLASS_INTERFACE_TYPE
);
10115 MARK_TS_COMMON (PROTOCOL_INTERFACE_TYPE
);
10116 MARK_TS_COMMON (CLASS_IMPLEMENTATION_TYPE
);
10118 MARK_TS_TYPED (MESSAGE_SEND_EXPR
);
10119 MARK_TS_TYPED (PROPERTY_REF
);
10123 objc_common_tree_size (enum tree_code code
)
10127 case CLASS_METHOD_DECL
:
10128 case INSTANCE_METHOD_DECL
:
10130 case PROPERTY_DECL
:
10131 return sizeof (struct tree_decl_non_common
);
10133 gcc_unreachable ();
10139 #include "gt-objc-objc-act.h"